koios/docs/neo4j-unified-schema.md

# Neo4j Unified Knowledge Graph Schema

> Canonical schema for the single shared graph database used by all AI assistants

---
version: 2.0.0
last_updated: 2025-02-16
replaces:
  - prompts/personal/neo4j-schema.md (v1.0.0)
  - prompts/work/neo4j-schema.md (v1.0.0)
---

## Overview

This document defines the canonical schema for **one shared Neo4j graph database** used by all AI assistants across three teams. The graph connects personal life, professional work, and engineering infrastructure in a single knowledge space.

### Design Principles

1. **One graph, many domains** — All assistants read from and write to the same database
2. **Domain ownership** — Each assistant owns specific node types and is the primary writer
3. **Universal read access** — Every assistant can read any node to build cross-domain context
4. **ID-based deduplication** — Always MERGE on `id`; always check before creating
5. **Temporal context** — All nodes carry `created_at` / `updated_at` timestamps
6. **Cross-domain relationships** — The graph's power comes from connecting life domains

### Teams & Assistants

| Team | Assistant | Domain | Graph Access |
|------|-----------|--------|--------------|
| **Personal** | Nate | Travel & Adventure | Read all, write own domain |
| **Personal** | Hypatia | Learning & Reading | Read all, write own domain |
| **Personal** | Marcus | Fitness & Training | Read all, write own domain |
| **Personal** | Seneca | Reflection & Wellness | Read all, write own domain |
| **Personal** | Bourdain | Food & Cooking | Read all, write own domain |
| **Personal** | Bowie | Arts & Culture | Read all, write own domain |
| **Personal** | Cousteau | Nature & Living Things | Read all, write own domain |
| **Personal** | Garth | Personal Finance | Read all, write own domain |
| **Personal** | Cristiano | Football | Read all, write own domain |
| **Work** | Alan | Strategy & Business Model | Read all, write all work nodes |
| **Work** | Ann | Marketing & Visibility | Read all, write all work nodes |
| **Work** | Jeffrey | Proposals & Sales | Read all, write all work nodes |
| **Work** | Jarvis | Daily Execution | Read all, write all work nodes |
| **Engineering** | Scotty | Infrastructure & Ops | Read all, write own domain |
| **Engineering** | Harper | Prototyping & Hacking | Read all, write own domain |

---

## Universal Node Types

These nodes are shared across all teams. Any assistant can create or update them.

### Person
People in the user's life — self, family, friends, colleagues, contacts.

```cypher
(:Person {
  id: String!,           // e.g., "user_main", "person_john_doe"
  name: String!,
  relationship: String,  // self, friend, family, colleague, client_contact
  domain: String,        // personal, work, both
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})
```

**Standard user node:**
```cypher
MERGE (p:Person {id: "user_main"})
SET p.name = "User",
    p.relationship = "self",
    p.domain = "both"
```

### Location
Physical places — shared across travel, training, dining, nature, work events.

```cypher
(:Location {
  id: String!,           // e.g., "location_tokyo_japan", "location_home_office"
  name: String!,
  type: String!,         // city, country, landmark, restaurant, gym, trail, park, office, venue
  country: String,
  region: String,
  coordinates: Point,
  address: String,
  domain: String,        // personal, work, both
  notes: String,
  created_by: String,    // which assistant created it
  created_at: DateTime,
  updated_at: DateTime
})
```

### Event
Significant occurrences spanning any domain.

```cypher
(:Event {
  id: String!,           // e.g., "event_birthday_2025", "event_ccw_2025"
  name: String!,
  date: Date!,
  end_date: Date,
  type: String,          // celebration, milestone, conference, webinar, workshop, competition
  domain: String,        // personal, work, both
  description: String,
  location: String,
  role: String,          // attendee, speaker, panelist, host (for work events)
  people: [String],
  outcomes: String,
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})
```

### Topic
Subjects of interest — learning, writing, speaking, thinking.

```cypher
(:Topic {
  id: String!,           // e.g., "topic_stoicism", "topic_ai_in_cx"
  name: String!,
  category: String!,     // philosophy, science, technology, strategy, operations, etc.
  domain: String,        // personal, work, both
  description: String,
  key_figures: [String],
  key_works: [String],
  key_messages: [String],       // (work) core talking points
  target_audience: [String],    // (work) who cares about this
  expertise_level: String,      // learning, competent, expert
  trending: Boolean,
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})
```

### Goal
Objectives and aspirations — life, fitness, career, financial.

```cypher
(:Goal {
  id: String!,           // e.g., "goal_mindfulness_2025", "goal_revenue_target_2025"
  name: String!,
  category: String!,     // personal_growth, wellness, fitness, career, financial, relationship
  domain: String,        // personal, work, both
  why: String,
  status: String,        // planning, in_progress, completed, paused, abandoned
  progress: String,
  milestones: [String],
  deadline: Date,
  values_aligned: [String],
  created_at: DateTime,
  updated_at: DateTime
})
```

---

## Personal Team — Domain Node Types

### Nate's Domain (Travel & Adventure)

#### Trip
```cypher
(:Trip {
  id: String!,           // e.g., "trip_costarica_2025"
  name: String!,
  status: String!,       // planning, booked, in_progress, completed, cancelled
  start_date: Date,
  end_date: Date,
  destinations: [String],
  budget: Float,
  currency: String,
  purpose: String,       // vacation, business, both
  notes: String,
  highlights: [String],
  created_at: DateTime,
  updated_at: DateTime
})
```

#### Destination
```cypher
(:Destination {
  id: String!,           // e.g., "destination_costa_rica"
  name: String!,
  country: String!,
  region: String,
  visited: Boolean,
  visit_dates: [Date],
  rating: Integer,       // 1-5
  want_to_return: Boolean,
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})
```

#### Activity
```cypher
(:Activity {
  id: String!,           // e.g., "activity_volcano_hike_arenal"
  name: String!,
  type: String!,         // adventure, cultural, food, nature, relaxation
  location: String,
  date: Date,
  duration: Integer,     // minutes
  cost: Float,
  rating: Integer,
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})
```

### Hypatia's Domain (Learning & Reading)

#### Book
```cypher
(:Book {
  id: String!,           // e.g., "book_meditations_aurelius"
  title: String!,
  author: String!,
  status: String,        // to_read, reading, completed, abandoned
  start_date: Date,
  end_date: Date,
  rating: Integer,       // 1-5
  themes: [String],
  notes: String,
  quotes: [String],
  created_at: DateTime,
  updated_at: DateTime
})
```

#### Author
```cypher
(:Author {
  id: String!,           // e.g., "author_marcus_aurelius"
  name: String!,
  era: String,
  nationality: String,
  fields: [String],
  notable_works: [String],
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})
```

#### LearningPath
```cypher
(:LearningPath {
  id: String!,           // e.g., "path_stoicism_intro"
  name: String!,
  goal: String!,
  topics: [String],
  status: String,        // planning, in_progress, completed
  progress: String,
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})
```

#### Concept
```cypher
(:Concept {
  id: String!,           // e.g., "concept_dichotomy_of_control"
  name: String!,
  definition: String,
  origin: String,
  related_concepts: [String],
  source_works: [String],
  created_at: DateTime,
  updated_at: DateTime
})
```

#### Quote
```cypher
(:Quote {
  id: String!,           // e.g., "quote_obstacle_way_aurelius"
  text: String!,
  source: String!,
  author: String,
  context: String,
  themes: [String],
  personal_notes: String,
  created_at: DateTime,
  updated_at: DateTime
})
```

### Marcus's Domain (Fitness & Training)

#### Training
```cypher
(:Training {
  id: String!,           // e.g., "training_2025-01-07_morning"
  date: Date!,
  type: String!,         // strength, cardio, mobility, sport, mixed
  duration: Integer,     // minutes
  exercises: [String],
  volume: String,        // low, moderate, high
  intensity: String,     // low, moderate, high
  feeling: String,
  location: String,
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})
```

#### Exercise
```cypher
(:Exercise {
  id: String!,           // e.g., "exercise_barbell_squat"
  name: String!,
  category: String!,     // compound, isolation, cardio, mobility, plyometric
  equipment: [String],
  target_muscles: [String],
  technique_notes: String,
  progression_notes: String,
  created_at: DateTime,
  updated_at: DateTime
})
```

#### Program
```cypher
(:Program {
  id: String!,           // e.g., "program_marathon_prep_2025"
  name: String!,
  goal: String!,
  type: String,          // strength, hypertrophy, endurance, sport_specific
  duration_weeks: Integer,
  days_per_week: Integer,
  status: String,        // planning, active, completed, paused
  start_date: Date,
  end_date: Date,
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})
```

#### PersonalRecord
```cypher
(:PersonalRecord {
  id: String!,           // e.g., "pr_squat_2025-01-07"
  exercise: String!,
  value: Float!,
  unit: String!,         // lbs, kg, seconds, meters, reps
  date: Date!,
  conditions: String,
  previous_record: Float,
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})
```

#### BodyMetric
```cypher
(:BodyMetric {
  id: String!,           // e.g., "metric_weight_2025-01-07"
  type: String!,         // weight, bodyfat, chest, waist, etc.
  value: Float!,
  unit: String!,
  date: Date!,
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})
```

### Seneca's Domain (Reflection & Wellness)

#### Reflection
```cypher
(:Reflection {
  id: String!,           // e.g., "reflection_2025-01-07"
  date: Date!,
  type: String!,         // daily, weekly, monthly, event_triggered
  content: String,
  themes: [String],
  mood: String,
  gratitude: [String],
  lessons: String,
  questions: String,
  created_at: DateTime,
  updated_at: DateTime
})
```

#### Value
```cypher
(:Value {
  id: String!,           // e.g., "value_presence"
  name: String!,
  description: String,
  priority: Integer,     // 1-5
  examples: [String],
  challenges: [String],
  created_at: DateTime,
  updated_at: DateTime
})
```

#### Habit
```cypher
(:Habit {
  id: String!,           // e.g., "habit_morning_meditation"
  name: String!,
  frequency: String!,    // daily, weekly, etc.
  purpose: String,
  status: String,        // building, active, paused, dropped
  streak: Integer,
  triggers: [String],
  obstacles: [String],
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})
```

#### LifeEvent
```cypher
(:LifeEvent {
  id: String!,           // e.g., "event_promotion_2025"
  name: String!,
  date: Date!,
  type: String,          // milestone, transition, loss, achievement, relationship
  impact: String,
  lessons: String,
  related_people: [String],
  emotions: [String],
  created_at: DateTime,
  updated_at: DateTime
})
```

#### Intention
```cypher
(:Intention {
  id: String!,           // e.g., "intention_2025-01-07"
  date: Date!,
  content: String!,
  fulfilled: Boolean,
  reflection: String,
  obstacles: String,
  created_at: DateTime,
  updated_at: DateTime
})
```

### Bourdain's Domain (Food & Cooking)

#### Recipe
```cypher
(:Recipe {
  id: String!,           // e.g., "recipe_carbonara_classic"
  name: String!,
  cuisine: String,
  category: String,      // main, appetizer, dessert, drink, etc.
  ingredients: [String],
  instructions: String,
  prep_time: Integer,    // minutes
  cook_time: Integer,
  servings: Integer,
  difficulty: String,    // easy, medium, hard
  notes: String,
  rating: Integer,
  times_made: Integer,
  created_at: DateTime,
  updated_at: DateTime
})
```

#### Restaurant
```cypher
(:Restaurant {
  id: String!,           // e.g., "restaurant_jiro_tokyo"
  name: String!,
  cuisine: String,
  location: String,
  price_range: String,   // $, $$, $$$, $$$$
  visited: Boolean,
  visit_dates: [Date],
  rating: Integer,
  favorite_dishes: [String],
  notes: String,
  recommended_by: String,
  created_at: DateTime,
  updated_at: DateTime
})
```

#### Ingredient
```cypher
(:Ingredient {
  id: String!,           // e.g., "ingredient_saffron"
  name: String!,
  category: String,      // protein, vegetable, spice, dairy, etc.
  season: [String],
  notes: String,
  substitutes: [String],
  created_at: DateTime,
  updated_at: DateTime
})
```

#### Meal
```cypher
(:Meal {
  id: String!,           // e.g., "meal_2025-01-07_dinner"
  date: Date!,
  type: String!,         // breakfast, lunch, dinner, snack
  dishes: [String],
  location: String,
  people: [String],
  notes: String,
  rating: Integer,
  created_at: DateTime,
  updated_at: DateTime
})
```

#### Technique
```cypher
(:Technique {
  id: String!,           // e.g., "technique_braising"
  name: String!,
  category: String,      // cooking, prep, preservation
  description: String,
  tips: [String],
  common_mistakes: [String],
  mastery_level: String, // learning, comfortable, mastered
  created_at: DateTime,
  updated_at: DateTime
})
```

### Bowie's Domain (Arts & Culture)

#### Music
```cypher
(:Music {
  id: String!,           // e.g., "music_heroes_bowie"
  title: String!,
  artist: String!,
  album: String,
  year: Integer,
  genre: [String],
  mood: [String],
  rating: Integer,
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})
```

#### Film
```cypher
(:Film {
  id: String!,           // e.g., "film_blade_runner_2049"
  title: String!,
  director: String,
  year: Integer,
  genre: [String],
  status: String,        // to_watch, watched
  watch_date: Date,
  rating: Integer,
  themes: [String],
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})
```

#### Artwork
```cypher
(:Artwork {
  id: String!,           // e.g., "artwork_starry_night_vangogh"
  title: String!,
  artist: String!,
  year: Integer,
  medium: String,
  movement: String,
  location: String,      // museum/gallery
  seen_in_person: Boolean,
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})
```

#### Playlist
```cypher
(:Playlist {
  id: String!,           // e.g., "playlist_morning_focus"
  name: String!,
  purpose: String,       // workout, focus, relaxation, travel, etc.
  tracks: [String],
  mood: [String],
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})
```

#### Artist
```cypher
(:Artist {
  id: String!,           // e.g., "artist_david_bowie"
  name: String!,
  type: String!,         // musician, director, painter, etc.
  active_period: String,
  genres: [String],
  notable_works: [String],
  influences: [String],
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})
```

#### Style
```cypher
(:Style {
  id: String!,           // e.g., "style_minimalist_wardrobe"
  name: String!,
  category: String,      // fashion, interior, aesthetic
  description: String,
  influences: [String],
  key_pieces: [String],
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})
```

### Cousteau's Domain (Nature & Living Things)

#### Species
```cypher
(:Species {
  id: String!,           // e.g., "species_clownfish"
  name: String!,
  scientific_name: String,
  category: String!,     // fish, coral, invertebrate, mammal, bird, reptile, plant
  habitat: String,
  care_level: String,    // easy, moderate, difficult, expert
  notes: String,
  kept: Boolean,
  observed_locations: [String],
  created_at: DateTime,
  updated_at: DateTime
})
```

#### Plant
```cypher
(:Plant {
  id: String!,           // e.g., "plant_monstera_living_room"
  name: String!,
  species: String,
  location: String,      // room or garden area
  acquired_date: Date,
  status: String,        // thriving, stable, struggling, deceased
  light_needs: String,
  water_frequency: String,
  last_watered: Date,
  last_fertilized: Date,
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})
```

#### Tank
```cypher
(:Tank {
  id: String!,           // e.g., "tank_reef_75gal"
  name: String!,
  type: String!,         // freshwater, saltwater, reef, planted
  size_gallons: Integer,
  location: String,
  setup_date: Date,
  inhabitants: [String],
  equipment: [String],
  parameters: Map,       // pH, temp, salinity, etc.
  maintenance_schedule: String,
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})
```

#### Garden
```cypher
(:Garden {
  id: String!,           // e.g., "garden_backyard_vegetables"
  name: String!,
  type: String!,         // vegetable, flower, herb, mixed
  location: String,
  size: String,
  plants: [String],
  soil_type: String,
  sun_exposure: String,
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})
```

#### Ecosystem
```cypher
(:Ecosystem {
  id: String!,           // e.g., "ecosystem_costa_rica_cloud_forest"
  name: String!,
  type: String!,         // forest, reef, desert, wetland, etc.
  location: String,
  key_species: [String],
  visited: Boolean,
  visit_dates: [Date],
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})
```

#### Observation
```cypher
(:Observation {
  id: String!,           // e.g., "observation_2025-01-07_hummingbird"
  date: Date!,
  species: String!,
  location: String,
  behavior: String,
  conditions: String,
  notes: String,
  photos: Boolean,
  created_at: DateTime,
  updated_at: DateTime
})
```

### Garth's Domain (Personal Finance)

#### Account
```cypher
(:Account {
  id: String!,           // e.g., "account_tfsa_questrade"
  name: String!,
  type: String!,         // TFSA, RRSP, RRIF, RESP, non_registered, cash
  institution: String,
  balance: Float,
  contribution_room: Float,
  opened_date: Date,
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})
```

#### Investment
```cypher
(:Investment {
  id: String!,           // e.g., "investment_xeqt"
  name: String!,
  type: String!,         // ETF, stock, bond, GIC, mutual_fund
  ticker: String,
  allocation_percent: Float,
  mer: Float,
  book_value: Float,
  market_value: Float,
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})
```

#### Asset
```cypher
(:Asset {
  id: String!,           // e.g., "asset_home_main"
  name: String!,
  type: String!,         // real_estate, vehicle, other
  value: Float,
  purchase_price: Float,
  purchase_date: Date,
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})
```

#### Liability
```cypher
(:Liability {
  id: String!,           // e.g., "liability_mortgage_main"
  name: String!,
  type: String!,         // mortgage, heloc, credit_card, loan, line_of_credit
  balance: Float,
  interest_rate: Float,
  payment: Float,
  maturity_date: Date,
  secured_by: String,
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})
```

#### Budget
```cypher
(:Budget {
  id: String!,           // e.g., "budget_2025_monthly"
  period: String!,       // monthly, quarterly, annual
  income: Float,
  expenses: Float,
  savings_rate: Float,
  categories: Map,       // {housing: 2000, food: 600, ...}
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})
```

#### FinancialGoal
```cypher
(:FinancialGoal {
  id: String!,           // e.g., "fgoal_retirement_2045"
  name: String!,
  target_amount: Float,
  deadline: Date,
  current_progress: Float,
  strategy: String,
  priority: String,      // critical, high, medium, low
  status: String,        // planning, in_progress, completed, paused
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})
```

---

### Cristiano's Domain (Football)

#### Match
```cypher
(:Match {
  id: String!,           // e.g., "match_arsenal_city_2025-02-15"
  date: Date!,
  home_team: String!,
  away_team: String!,
  competition: String,   // "Premier League", "Champions League", etc.
  stage: String,         // "Group Stage", "Quarter-Final", "Matchday 25"
  score: String,         // "2-1"
  venue: String,
  watched: Boolean,
  key_moments: [String],
  tactical_notes: String,
  man_of_the_match: String,
  rating: Integer,       // 1-5
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})
```

#### Team
```cypher
(:Team {
  id: String!,           // e.g., "team_arsenal", "team_real_madrid"
  name: String!,
  league: String,
  country: String,
  manager: String,
  formation: String,     // "4-3-3", "3-5-2"
  style: String,         // "Positional play, inverted fullbacks, high press"
  followed: Boolean,
  stadium: String,
  founded: Integer,
  season_status: String,
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})
```

#### League
```cypher
(:League {
  id: String!,           // e.g., "league_premier_league", "league_la_liga"
  name: String!,
  country: String,
  tier: Integer,         // 1 = top flight
  season: String,        // "2025-26"
  current_leader: String,
  following: Boolean,
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})
```

#### Tournament
```cypher
(:Tournament {
  id: String!,           // e.g., "tournament_ucl_2025-26", "tournament_wc_2026"
  name: String!,
  type: String,          // "club", "international"
  year: Integer,
  stage: String,         // current stage of tournament
  host: String,
  current_holder: String,
  following: Boolean,
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})
```

#### Player
```cypher
(:Player {
  id: String!,           // e.g., "player_bellingham_jude"
  name: String!,
  team: String,
  nationality: String,
  position: String,      // "CM", "RW", "ST", "CB", "GK"
  age: Integer,
  style: String,
  strengths: [String],
  weaknesses: [String],
  market_value: String,
  favorite: Boolean,
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})
```

#### Season
```cypher
(:Season {
  id: String!,           // e.g., "season_arsenal_2025-26"
  team: String!,
  season_year: String!,  // "2025-26"
  league_position: Integer,
  champions_league: String,
  domestic_cup: String,
  top_scorer: String,
  key_signings: [String],
  key_departures: [String],
  manager: String,
  assessment: String,
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})
```

---

## Work Team — Domain Node Types

### Business Nodes

#### Client
```cypher
(:Client {
  id: String!,           // e.g., "client_acme_corp"
  name: String!,
  industry: String,
  size: String,          // startup, smb, mid-market, enterprise
  status: String!,       // prospect, active, past, dormant
  relationship_start: Date,
  primary_contact: String,
  account_value: String, // low, medium, high, strategic
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})
```

#### Contact
```cypher
(:Contact {
  id: String!,           // e.g., "contact_john_smith_acme"
  name: String!,
  title: String,
  company: String,
  email: String,
  phone: String,
  linkedin: String,
  relationship_strength: String,  // new, developing, strong, champion
  last_contact: Date,
  notes: String,
  tags: [String],        // decision_maker, influencer, technical, executive
  created_at: DateTime,
  updated_at: DateTime
})
```

#### Opportunity
```cypher
(:Opportunity {
  id: String!,           // e.g., "opp_acme_cx_transformation_2025"
  name: String!,
  client: String!,
  status: String!,       // identified, qualifying, proposing, negotiating, won, lost
  value: Float,
  currency: String,
  probability: Integer,  // 0-100
  expected_close: Date,
  type: String,          // project, retainer, managed_services, advisory
  description: String,
  next_action: String,
  competitors: [String],
  win_themes: [String],
  loss_reasons: [String],
  created_at: DateTime,
  updated_at: DateTime
})
```

#### Proposal
```cypher
(:Proposal {
  id: String!,           // e.g., "proposal_acme_cx_2025-01"
  name: String!,
  client: String!,
  opportunity: String,
  status: String!,       // drafting, submitted, presented, won, lost, withdrawn
  submitted_date: Date,
  decision_date: Date,
  value: Float,
  currency: String,
  type: String,          // project, retainer, managed_services
  executive_summary: String,
  key_differentiators: [String],
  pricing_approach: String,
  outcome_notes: String,
  lessons_learned: String,
  created_at: DateTime,
  updated_at: DateTime
})
```

#### Project
```cypher
(:Project {
  id: String!,           // e.g., "project_acme_cx_implementation"
  name: String!,
  client: String!,
  status: String!,       // planning, active, on_hold, completed, cancelled
  type: String,          // assessment, strategy, implementation, managed_services
  start_date: Date,
  end_date: Date,
  value: Float,
  description: String,
  outcomes: [String],
  lessons_learned: String,
  referenceable: Boolean,
  satisfaction_score: Integer,
  created_at: DateTime,
  updated_at: DateTime
})
```

### Market Intelligence Nodes

#### Vendor
```cypher
(:Vendor {
  id: String!,           // e.g., "vendor_genesys"
  name: String!,
  category: String!,     // ccaas, wfm, qa, virtual_agent, crm, analytics
  tier: String,          // leader, challenger, niche
  relationship: String,  // partner, familiar, competitor_aligned
  strengths: [String],
  weaknesses: [String],
  ideal_for: [String],
  certifications_held: [String],
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})
```

#### Competitor
```cypher
(:Competitor {
  id: String!,           // e.g., "competitor_big_consulting"
  name: String!,
  type: String,          // global_si, boutique, vendor_services, freelance
  strengths: [String],
  weaknesses: [String],
  typical_clients: [String],
  pricing_approach: String,
  differentiation: String,
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})
```

#### MarketTrend
```cypher
(:MarketTrend {
  id: String!,           // e.g., "trend_ai_agents_2025"
  name: String!,
  category: String,      // technology, buyer_behavior, regulation, workforce
  status: String,        // emerging, growing, mature, declining
  impact: String,        // high, medium, low
  timeframe: String,     // immediate, near_term, long_term
  description: String,
  implications: [String],
  opportunities: [String],
  sources: [String],
  created_at: DateTime,
  updated_at: DateTime
})
```

#### Technology
```cypher
(:Technology {
  id: String!,           // e.g., "tech_conversational_ai"
  name: String!,
  category: String!,     // platform, capability, integration, methodology
  maturity: String,      // emerging, established, commoditized
  vendors: [String],
  use_cases: [String],
  expertise_level: String,
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})
```

### Content & Visibility Nodes

#### Content
```cypher
(:Content {
  id: String!,           // e.g., "content_ai_cx_article_2025-01"
  title: String!,
  type: String!,         // article, blog_post, linkedin_post, whitepaper, talk, webinar, podcast
  status: String!,       // idea, drafting, review, published, archived
  topic: String,
  publication: String,
  published_date: Date,
  url: String,
  abstract: String,
  key_points: [String],
  performance: String,
  repurpose_ideas: [String],
  created_at: DateTime,
  updated_at: DateTime
})
```

#### Publication
```cypher
(:Publication {
  id: String!,           // e.g., "pub_linkedin"
  name: String!,
  type: String,          // social, blog, industry_pub, conference, podcast
  audience: String,
  reach: String,
  submission_process: String,
  contacts: [String],
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})
```

### Professional Development Nodes

#### Skill
```cypher
(:Skill {
  id: String!,           // e.g., "skill_conversational_ai_design"
  name: String!,
  category: String!,     // technical, consulting, leadership, industry
  level: String!,        // learning, competent, proficient, expert
  evidence: [String],
  development_plan: String,
  priority: String,      // active, maintenance, future
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})
```

#### Certification
```cypher
(:Certification {
  id: String!,           // e.g., "cert_aws_solutions_architect"
  name: String!,
  issuer: String!,
  status: String!,       // pursuing, active, expired, planned
  earned_date: Date,
  expiry_date: Date,
  renewal_requirements: String,
  value_proposition: String,
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})
```

#### Relationship
Professional network beyond clients.

```cypher
(:Relationship {
  id: String!,           // e.g., "rel_analyst_jane_doe"
  name: String!,
  type: String!,         // analyst, journalist, peer, mentor, mentee, partner
  organization: String,
  context: String,
  strength: String,      // new, developing, strong
  last_contact: Date,
  value_exchange: String,
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})
```

### Daily Operations Nodes

#### Task
```cypher
(:Task {
  id: String!,           // e.g., "task_2025-01-08_proposal_draft"
  title: String!,
  status: String!,       // pending, in_progress, completed, deferred, cancelled
  priority: String,      // urgent, high, medium, low
  due_date: Date,
  context: String,       // client, opportunity, content, admin
  related_to: String,
  description: String,
  completed_date: Date,
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})
```

#### Meeting
```cypher
(:Meeting {
  id: String!,           // e.g., "meeting_2025-01-08_acme_discovery"
  title: String!,
  date: Date!,
  time: String,
  duration: Integer,     // minutes
  type: String,          // discovery, presentation, negotiation, check_in, internal
  attendees: [String],
  client: String,
  opportunity: String,
  agenda: String,
  notes: String,
  outcomes: [String],
  follow_ups: [String],
  created_at: DateTime,
  updated_at: DateTime
})
```

#### Note
```cypher
(:Note {
  id: String!,           // e.g., "note_2025-01-08_market_observation"
  date: Date!,
  type: String,          // observation, idea, insight, concern, opportunity
  content: String!,
  context: String,
  related_to: [String],
  action_required: Boolean,
  tags: [String],
  created_at: DateTime,
  updated_at: DateTime
})
```

#### Decision
```cypher
(:Decision {
  id: String!,           // e.g., "decision_2025-01-08_pricing_model"
  date: Date!,
  title: String!,
  context: String,
  options_considered: [String],
  decision: String!,
  rationale: String,
  outcome: String,
  lessons: String,
  reversible: Boolean,
  created_at: DateTime,
  updated_at: DateTime
})
```

---

## Engineering Team — Domain Node Types

### Scotty's Domain (Infrastructure & Ops)

#### Infrastructure
```cypher
(:Infrastructure {
  id: String!,           // e.g., "infra_neo4j_prod", "infra_haproxy_main"
  name: String!,
  type: String!,         // server, container, service, network, database, loadbalancer
  host: String,
  status: String,        // running, stopped, degraded, planned
  environment: String,   // production, staging, development
  config_notes: String,
  documentation: String,
  last_checked: DateTime,
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})
```

#### Incident
```cypher
(:Incident {
  id: String!,           // e.g., "incident_2025-02-15_neo4j_oom"
  title: String!,
  date: DateTime!,
  severity: String!,     // critical, high, medium, low
  status: String!,       // active, investigating, resolved, post_mortem
  affected_services: [String],
  root_cause: String,
  resolution: String,
  duration_minutes: Integer,
  lessons_learned: String,
  prevention: String,
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})
```

### Harper's Domain (Prototyping & Experiments)

#### Prototype
```cypher
(:Prototype {
  id: String!,           // e.g., "proto_slack_neo4j_bridge"
  name: String!,
  description: String,
  status: String!,       // idea, building, working, abandoned, promoted
  tech_stack: [String],
  repo_url: String,
  demo_url: String,
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})
```

#### Experiment
```cypher
(:Experiment {
  id: String!,           // e.g., "exp_llm_graph_query_2025-02"
  name: String!,
  hypothesis: String,
  approach: String,
  outcome: String,       // success, partial, failure, inconclusive
  learnings: String,
  tech_used: [String],
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})
```

---

## Relationship Types

### Universal Relationships
```cypher
// Ownership / Creation
(Person)-[:OWNS]->(Tank|Garden|Plant|Account|Asset)
(Person)-[:CREATED]->(Recipe|Playlist|Prototype)
(Person)-[:WROTE]->(Reflection|Content)
(Person)-[:OWES]->(Liability)

// Completion / Progress
(Person)-[:COMPLETED]->(Book|Film|Training|Trip|Project)
(Person)-[:READING|WATCHING|PLANNING]->(Book|Film|Trip)
(Person)-[:PURSUING]->(Goal|FinancialGoal)
(Person)-[:PRACTICING]->(Habit)

// Preferences
(Person)-[:INTERESTED_IN]->(Topic|Species)
(Person)-[:HOLDS]->(Value)
(Person)-[:FAVORITES]->(Recipe|Restaurant|Music|Film)
```

### Personal Cross-Domain Relationships
```cypher
// Location connections
(Trip)-[:VISITS]->(Destination)
(Trip)-[:INCLUDES]->(Activity)
(Activity|Training|Meal|Observation)-[:AT_LOCATION]->(Location)
(Restaurant)-[:LOCATED_IN]->(Location)
(LifeEvent)-[:OCCURRED_AT]->(Location)

// Preparation and support
(Training)-[:PREPARATION_FOR]->(Trip)
(Book)-[:PREPARATION_FOR]->(Trip)
(Recipe)-[:FUELS]->(Training)
(Training)-[:SUPPORTS]->(Goal)
(Habit)-[:SUPPORTS]->(Goal)
(Book)-[:INFORMS]->(Goal)

// Inspiration and influence
(Book)-[:INSPIRED]->(Reflection|Goal)
(Music|Film)-[:EVOKED]->(Reflection)
(Trip)-[:INSPIRED]->(Goal|Reflection)
(Author)-[:INFLUENCED_BY]->(Author)
(Artist)-[:INFLUENCED_BY]->(Artist)

// Content relationships
(Book)-[:WRITTEN_BY]->(Author)
(Book)-[:EXPLORES]->(Topic)
(Book)-[:CONTAINS]->(Quote)
(Book)-[:ADAPTED_TO]->(Film)
(Music)-[:BY_ARTIST]->(Artist)
(Film)-[:DIRECTED_BY]->(Artist)
(Recipe)-[:USES]->(Ingredient)
(Recipe)-[:REQUIRES]->(Technique)

// Nature connections
(Tank|Garden)-[:HOUSES]->(Species|Plant)
(Species)-[:OBSERVED_AT]->(Location)
(Trip)-[:WILDLIFE_HIGHLIGHT]->(Species)
(Ecosystem)-[:CONTAINS]->(Species)

// Financial connections
(Account)-[:HOLDS]->(Investment)
(Liability)-[:SECURED_BY]->(Asset)
(FinancialGoal)-[:SUPPORTS]->(Goal)
(FinancialGoal)-[:FUNDS]->(Trip)
(Budget)-[:ALLOCATED_FOR]->(Trip)
(FinancialGoal)-[:ALIGNED_WITH]->(Value)
(Book)-[:INFORMS]->(Investment)

// Temporal / Sequential
(Exercise)-[:PROGRESSION_FROM]->(Exercise)
(PersonalRecord)-[:IMPROVES_ON]->(PersonalRecord)
(Style)-[:EVOLVED_FROM]->(Style)
(Goal)-[:LED_TO]->(Goal)
(LifeEvent)-[:LED_TO]->(Goal|Reflection)
```

### Work Cross-Domain Relationships
```cypher
// Client relationships
(Contact)-[:WORKS_AT]->(Client)
(Contact)-[:DECISION_MAKER_FOR]->(Opportunity)
(Opportunity)-[:FOR_CLIENT]->(Client)
(Proposal)-[:FOR_CLIENT]->(Client)
(Proposal)-[:ADDRESSES]->(Opportunity)
(Project)-[:FOR_CLIENT]->(Client)
(Project)-[:WON_FROM]->(Proposal)

// Sales process
(Opportunity)-[:COMPETES_WITH]->(Competitor)
(Opportunity)-[:INVOLVES]->(Technology)
(Proposal)-[:DIFFERENTIATES_AGAINST]->(Competitor)
(Proposal)-[:PROPOSES]->(Technology)
(Meeting)-[:ABOUT]->(Opportunity)
(Task)-[:SUPPORTS]->(Opportunity)

// Market intelligence
(Vendor)-[:PROVIDES]->(Technology)
(Competitor)-[:PARTNERS_WITH]->(Vendor)
(MarketTrend)-[:AFFECTS]->(Technology)
(MarketTrend)-[:CREATES]->(Opportunity)
(Client)-[:USES]->(Vendor)

// Content & visibility
(Content)-[:ABOUT]->(Topic)
(Content)-[:PUBLISHED_IN]->(Publication)
(Content)-[:PRESENTED_AT]->(Event)
(Topic)-[:RELATES_TO]->(Technology)
(Topic)-[:ADDRESSES]->(MarketTrend)

// Professional development
(Skill)-[:DEMONSTRATED_IN]->(Project)
(Skill)-[:VALIDATED_BY]->(Certification)
(Certification)-[:ISSUED_BY]->(Vendor)
(Relationship)-[:MET_AT]->(Event)

// Daily operations
(Task)-[:RELATED_TO]->(Client|Opportunity|Proposal|Content)
(Meeting)-[:WITH]->(Contact)
(Meeting)-[:ABOUT]->(Opportunity|Project)
(Note)-[:ABOUT]->(Client|Opportunity|MarketTrend)
(Decision)-[:AFFECTS]->(Opportunity|Project)
```

### Cross-Team Relationships (Personal ↔ Work ↔ Engineering)
```cypher
// Travel for work
(Trip)-[:FOR_EVENT]->(Event)
(Trip)-[:FOR_CLIENT]->(Client)
(Restaurant)-[:VISITED_WITH]->(Contact)

// Learning supporting work
(Book)-[:INFORMS]->(Content)
(Book)-[:DEVELOPS]->(Skill)
(LearningPath)-[:TARGETS]->(Skill)
(Concept)-[:APPLIED_IN]->(Project)

// Reflection on work
(Reflection)-[:ABOUT]->(Project|Meeting|Decision)
(LifeEvent)-[:CAREER_IMPACT]->(Opportunity|Project)

// Culture and work
(Playlist)-[:CREATED_FOR]->(Task)
(Film)-[:DISCUSSED_WITH]->(Contact)

// Finance and work
(Project)-[:GENERATES_REVENUE]->(Account)
(Opportunity)-[:PROJECTED_VALUE]->(FinancialGoal)

// Engineering supporting everything
(Infrastructure)-[:HOSTS]->(Project|Prototype)
(Incident)-[:AFFECTED]->(Infrastructure)
(Prototype)-[:DEMONSTRATES]->(Technology)
(Prototype)-[:SUPPORTS]->(Opportunity)
(Experiment)-[:TESTED]->(Technology)
(Experiment)-[:INFORMED_BY]->(Book|Concept)

// Fitness and work
(Training)-[:BUILDS]->(Skill)  // discipline, resilience
(Habit)-[:SUPPORTS]->(Goal)    // career goals too
```

---

## ID Naming Conventions

Use lowercase with underscores:
```
{type}_{identifier}_{qualifier}
```

### Examples by Team

**Personal:**
- `person_john_doe`
- `book_meditations_aurelius`
- `trip_costarica_2025`
- `training_2025-01-07_morning`
- `recipe_carbonara_classic`
- `species_clownfish`
- `reflection_2025-01-07`
- `account_tfsa_questrade`
- `investment_xeqt`

**Work:**
- `client_acme_corp`
- `contact_john_smith_acme`
- `opp_acme_cx_transformation_2025`
- `proposal_acme_cx_2025-01`
- `project_acme_implementation`
- `content_ai_cx_article_2025-01`
- `task_2025-01-08_proposal_draft`

**Engineering:**
- `infra_neo4j_prod`
- `incident_2025-02-15_neo4j_oom`
- `proto_slack_neo4j_bridge`
- `exp_llm_graph_query_2025-02`

### Date-based IDs
Use ISO format: `YYYY-MM-DD`

### Qualifiers
Add when needed for uniqueness:
- Time of day: `_morning`, `_evening`
- Year: `_2025`
- Location: `_tokyo`, `_home`
- Company: `_acme`
- Type: `_discovery`, `_proposal`
- Variant: `_v2`, `_spicy`

---

## Query Best Practices

### Always Check Before Creating
```cypher
MATCH (b:Book {title: "Meditations", author: "Marcus Aurelius"})
RETURN b

// Use MERGE for idempotent creation
MERGE (b:Book {id: "book_meditations_aurelius"})
SET b.title = "Meditations",
    b.author = "Marcus Aurelius",
    b.updated_at = datetime()
ON CREATE SET b.created_at = datetime()
```

### Use OPTIONAL MATCH for Graceful Handling
```cypher
MATCH (p:Person {id: "user_main"})
OPTIONAL MATCH (p)-[:PLANNING]->(t:Trip)
WHERE t.start_date > date()
RETURN p, collect(t) as upcoming_trips
```

### Always Set Timestamps
```cypher
MERGE (n:Node {id: "..."})
SET n.property = value,
    n.updated_at = datetime()
ON CREATE SET n.created_at = datetime()
```

### Batch Related Operations
```cypher
MERGE (t:Training {id: "training_2025-01-07_morning"})
SET t.date = date("2025-01-07"),
    t.type = "strength",
    t.updated_at = datetime()
WITH t
MATCH (p:Person {id: "user_main"})
MERGE (p)-[:COMPLETED]->(t)
WITH t
MATCH (trip:Trip {id: "trip_costarica_2025"})
MERGE (t)-[:PREPARATION_FOR]->(trip)
```

### Cross-Team Discovery Queries
```cypher
// Find connections between a trip and work
MATCH (trip:Trip {id: "trip_lisbon_2025"})
OPTIONAL MATCH (trip)-[:FOR_EVENT]->(e:Event)
OPTIONAL MATCH (trip)-[:FOR_CLIENT]->(c:Client)
OPTIONAL MATCH (trip)-[:VISITS]->(d:Destination)
RETURN trip, e, c, d

// Find all nodes related to a topic across domains
MATCH (t:Topic {id: "topic_ai_in_cx"})
OPTIONAL MATCH (b:Book)-[:EXPLORES]->(t)
OPTIONAL MATCH (c:Content)-[:ABOUT]->(t)
OPTIONAL MATCH (e:Event)-[:COVERS]->(t)
RETURN t, collect(b) as books, collect(c) as content, collect(e) as events
```

---

## MCP Integration

### Neo4j Queries

All assistants execute Cypher queries via the Neo4j MCP server:

```
Tool: neo4j_query (or as configured in MCP setup)
```

**Execution pattern:**
1. Construct the Cypher query
2. Execute via MCP tool
3. Parse the response
4. Handle errors gracefully
5. Never expose raw errors to user

### Athena Integration (Work Team)

Alan, Jeffrey, and Jarvis have additional access to Athena for client relationship management:
- Client history and interaction timeline
- Contact intelligence and relationship mapping
- Proposal history and win/loss analysis
- Relationship health indicators

### Error Handling

If queries fail:
1. Acknowledge naturally in conversation
2. Continue helping with available context
3. Suggest checking MCP server connection if persistent
4. Never show raw errors or stack traces

---

## Node Type Summary

| # | Node Type | Domain | Primary Owner | Constraint Field |
|---|-----------|--------|---------------|-----------------|
| 1 | Person | Universal | Any | id |
| 2 | Location | Universal | Any | id |
| 3 | Event | Universal | Any | id |
| 4 | Topic | Universal | Hypatia / Ann | id |
| 5 | Goal | Universal | Seneca | id |
| 6 | Trip | Personal | Nate | id |
| 7 | Destination | Personal | Nate | id |
| 8 | Activity | Personal | Nate | id |
| 9 | Book | Personal | Hypatia | id |
| 10 | Author | Personal | Hypatia | id |
| 11 | LearningPath | Personal | Hypatia | id |
| 12 | Concept | Personal | Hypatia | id |
| 13 | Quote | Personal | Hypatia | id |
| 14 | Training | Personal | Marcus | id |
| 15 | Exercise | Personal | Marcus | id |
| 16 | Program | Personal | Marcus | id |
| 17 | PersonalRecord | Personal | Marcus | id |
| 18 | BodyMetric | Personal | Marcus | id |
| 19 | Reflection | Personal | Seneca | id |
| 20 | Value | Personal | Seneca | id |
| 21 | Habit | Personal | Seneca | id |
| 22 | LifeEvent | Personal | Seneca | id |
| 23 | Intention | Personal | Seneca | id |
| 24 | Recipe | Personal | Bourdain | id |
| 25 | Restaurant | Personal | Bourdain | id |
| 26 | Ingredient | Personal | Bourdain | id |
| 27 | Meal | Personal | Bourdain | id |
| 28 | Technique | Personal | Bourdain | id |
| 29 | Music | Personal | Bowie | id |
| 30 | Film | Personal | Bowie | id |
| 31 | Artwork | Personal | Bowie | id |
| 32 | Playlist | Personal | Bowie | id |
| 33 | Artist | Personal | Bowie | id |
| 34 | Style | Personal | Bowie | id |
| 35 | Species | Personal | Cousteau | id |
| 36 | Plant | Personal | Cousteau | id |
| 37 | Tank | Personal | Cousteau | id |
| 38 | Garden | Personal | Cousteau | id |
| 39 | Ecosystem | Personal | Cousteau | id |
| 40 | Observation | Personal | Cousteau | id |
| 41 | Account | Personal | Garth | id |
| 42 | Investment | Personal | Garth | id |
| 43 | Asset | Personal | Garth | id |
| 44 | Liability | Personal | Garth | id |
| 45 | Budget | Personal | Garth | id |
| 46 | FinancialGoal | Personal | Garth | id |
| 47 | Match | Personal | Cristiano | id |
| 48 | Team | Personal | Cristiano | id |
| 49 | League | Personal | Cristiano | id |
| 50 | Tournament | Personal | Cristiano | id |
| 51 | Player | Personal | Cristiano | id |
| 52 | Season | Personal | Cristiano | id |
| 53 | Client | Work | Alan / All | id |
| 54 | Contact | Work | Jeffrey / All | id |
| 55 | Opportunity | Work | Jeffrey / All | id |
| 56 | Proposal | Work | Jeffrey / All | id |
| 57 | Project | Work | Jarvis / All | id |
| 58 | Vendor | Work | Alan / All | id |
| 59 | Competitor | Work | Alan / All | id |
| 60 | MarketTrend | Work | Alan / All | id |
| 61 | Technology | Work | Alan / All | id |
| 62 | Content | Work | Ann / All | id |
| 63 | Publication | Work | Ann / All | id |
| 64 | Skill | Work | Any work | id |
| 65 | Certification | Work | Any work | id |
| 66 | Relationship | Work | Any work | id |
| 67 | Task | Work | Jarvis / All | id |
| 68 | Meeting | Work | Jarvis / All | id |
| 69 | Note | Work | Jarvis / All | id |
| 70 | Decision | Work | Alan / Jarvis | id |
| 71 | Infrastructure | Engineering | Scotty | id |
| 72 | Incident | Engineering | Scotty | id |
| 73 | Prototype | Engineering | Harper | id |
| 74 | Experiment | Engineering | Harper | id |

---

## Version History

| Version | Date | Changes |
|---------|------|---------|
| 1.0.0 | 2025-01-07 | Initial personal schema |
| 1.0.0-work | 2025-01-08 | Initial work schema |
| 2.0.0 | 2025-02-16 | Unified schema: merged personal + work, added Garth (finance), added engineering nodes (Scotty/Harper), added cross-team relationships, promoted Topic/Goal/Event to universal, added domain property for disambiguation |
| 2.1.0 | 2026-02-16 | Added Cristiano (Football): Match, Team, League, Tournament, Player, Season (6 node types). Total: 74 nodes, 15 assistants |