koios/docs/tools/neo4j/unified-schema.md

Neo4j Unified Knowledge Graph Schema

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

---

version: 2.5.0 last_updated: 2026-07-26 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	Shawn	Personal General Assistant (calendar, contacts, comms)	Read all, write domain='personal' Contact/Event/Task + own Communication
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	Watson	Relationship Memory & Emotional Safety	Read all, write own domain
Personal	Sophia	Home, Food & Living Things	Read all, write own domain
Personal	David	Arts & Culture	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 domain='work' work nodes
Work	Ann	Marketing & Visibility	Read all, write domain='work' work nodes
Work	Jeffrey	Proposals & Sales	Read all, write domain='work' work nodes
Work	Jarvis	Daily Execution	Read all, write domain='work' Contact/Event/Task + work nodes
Work	Quentin	Solution Architecture	Read all, write domain='work' Solution/Demo + work nodes
Work	AWS SA (Quentin's subagent)	AWS Architecture Design	Read all, generally writes only Note (messages); no domain ownership
Engineering	Scotty	Infrastructure & Ops	Read all, write own domain
Engineering	Harper	Prototyping & Hacking	Read all, write own domain
Engineering	CASE	Field / Physical Layer (LAN, hardware)	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.

(: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:

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.

(: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. Personal events (birthdays, dinners, family gatherings) are written by Shawn with domain='personal'; work events (conferences, client meetings, webinars) are written by Jarvis/Jeffrey/Ann/Alan with domain='work'. Cross-domain events that genuinely span both (e.g., a client takes Robert to a baseball game) use domain='both'.

(: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 — determines owning team
  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.

(: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.

(: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

Shawn's Domain (Personal General Assistant)

Shawn is the personal calendar/contacts/communications assistant. He owns the Personal scope of three Universal node types (Contact, Event, Task — all with domain='personal') and one dedicated node type (Communication). He is the Personal counterpart to the Work team's Jarvis. The divide is strict: Shawn never writes domain='work' rows; Jarvis never writes domain='personal' rows.

Tooling: Shawn uses Kairos (calendar/tasks/personal address book); work agents use Athena (CRM). Kairos is shared read-only with work agents for calendar deconfliction.

Communication

Personal interaction history with contacts — calls, texts, emails, in-person meet-ups, social-media exchanges. Shawn owns this exclusively; there is no Work equivalent (the work team logs interactions in Meeting/Note nodes linked to Contact/Opportunity).

(:Communication {
  id: String!,           // e.g., "comm_2026-05-17_mike_chen_coffee"
  type: String!,         // call, text, email, in_person, social
  contact_id: String!,   // foreign key to Contact.id (domain='personal')
  date: Date!,
  subject: String,
  summary: String,
  follow_up: String,     // freeform: "send podcast link", "schedule next coffee"
  sentiment: String,     // positive, neutral, strained, distant
  created_at: DateTime,
  updated_at: DateTime
})

Relationships:

(Communication)-[:WITH]->(Contact {domain: 'personal'})
(Person {id:"user_main"})-[:HAD]->(Communication)

Nate's Domain (Travel & Adventure)

Trip

(: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

(: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

(: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

(: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

(: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

(: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

(: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

(: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

(: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

(: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

(: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

(: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

(: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
})

Watson's Domain (Relationship Memory & Emotional Safety)

Inspired by Dr. John Watson - companion, confidant, and safe harbor

Note: Watson replaces Seneca as of 2026-04-28. The Reflection, Value, Habit, LifeEvent, and Intention node types are retained but now owned by Watson with a warmer, less goal-oriented approach.

Reflection

(: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

(: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

(: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

(: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

(: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
})

EmotionalMemory

Raw emotional experiences with people and events - the "what it felt like" that doesn't fit elsewhere

(:EmotionalMemory {
  id: String!,           // e.g., "memory_2025-01-08_john_call"
  date: Date!,
  theme: String!,        // rejection, joy, anxiety, love, guilt, safety, confusion, relief
  intensity: Integer,    // 1-5 scale
  body_sensation: String, // "tight chest", "warmth in hands", "shoulders dropped"
  content: String!,
  person_ref: String,    // optional: reference to Shawn's Contact ID
  created_at: DateTime,
  updated_at: DateTime
})

RelationshipTheme

Recurring patterns in how relationships feel or unfold

(:RelationshipTheme {
  id: String!,           // e.g., "theme_boundaries_with_friends"
  name: String!,
  theme: String!,        // boundaries, loyalty, abandonment, permission, pacing, performance
  triggers: [String],    // situations that activate the pattern
  reframes: [String],    // alternative framings that help
  evolution_notes: String,
  created_at: DateTime,
  updated_at: DateTime
})

DialogueNote

Recorded conversation moments - Watson's "session notes" without clinical framing

(:DialogueNote {
  id: String!,           // e.g., "dialogue_2025-01-08_boundaries"
  date: Date!,
  focus: String!,        // guilt, safety, boundaries, pacing, loyalty, permission, self-worth
  content: String!,
  breakthroughs: [String],
  questions_raised: [String],
  what_helped: String,
  created_at: DateTime,
  updated_at: DateTime
})

DynamicPattern

Behavioral and communication patterns that emerge over time

(:DynamicPattern {
  id: String!,           // e.g., "pattern_freeze_when_overwhelmed"
  date: Date!,
  pattern_type: String!, // freeze, protect, perform, give, withdraw, escalate
  context: String,       // when does this show up?
  observation: String!,  // what actually happened
  what_helped: String,
  created_at: DateTime,
  updated_at: DateTime
})

Sophia's Domain — Food (Recipe, Restaurant, Ingredient, Meal, Technique)

Recipe

(: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

(: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

(: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

(: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

(: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
})

David's Domain (Arts & Culture)

Music

(: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

(: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

(: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

(: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

(: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

(: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
})

Sophia's Domain — Living Things (Species, Plant, Tank, Garden, Ecosystem, Observation)

Species

(: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

(: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

(: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

(: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

(: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

(: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

(: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

(: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

(: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

(: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

(: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

(: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

(: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

(: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

(: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

(: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

(: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

(: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

(: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

Universal — used by both Personal (Shawn) and Work (Jeffrey/all-work) teams. The domain field disambiguates ownership.

(:Contact {
  id: String!,           // e.g., "contact_john_smith_acme" (work),
                         //       "contact_mike_chen" (personal)
  name: String!,
  domain: String!,       // personal, work — determines owning team
  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 (work)
                         // family, friend, neighbour (personal)
  created_at: DateTime,
  updated_at: DateTime
})

Ownership rule (strict): Shawn writes domain='personal' rows only; Jarvis/Jeffrey/Alan/Ann write domain='work' rows only. Personal and Work contacts never share an id namespace.

Opportunity

(: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

(: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

(: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
})

Solution Architecture Nodes

Quentin's domain. A Solution is the unit of architecture work — one node carries the design, the scope of work, and the effort estimate together (they are facets of one record, not separate node types). Demo records a working demonstration of a solution. aws_sa, Quentin's subagent, owns no nodes; Quentin persists its output onto the relevant Solution.

Solution

(:Solution {
  id: String!,                 // e.g., "solution_acme_connect_2026"
  name: String!,
  client_id: String,           // owning Client (also link via :FOR_CLIENT)
  summary: String,             // one-line what-this-is
  architecture: String,        // design narrative and key decisions
  scope_of_work: String,       // SOW: in/out, assumptions, acceptance criteria
  effort_estimate: String,     // effort breakdown, assumptions, risk
  status: String,              // draft, proposed, accepted, delivered
  domain: String,              // 'work'
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})

Demo

(:Demo {
  id: String!,                 // e.g., "demo_acme_connect_ivr"
  name: String!,
  solution_id: String,         // the Solution demonstrated (also link via :HAS_DEMO)
  description: String,         // what it demonstrates
  environment: String,         // demo host / reference (demo environment only)
  status: String,              // building, ready, retired
  url: String,
  domain: String,              // 'work'
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})

Market Intelligence Nodes

Vendor

(: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

(: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

(: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

(: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

(: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

(: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

(: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

(: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.

(: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

Universal — Shawn owns Personal tasks; Jarvis owns Work tasks. The domain field disambiguates.

(:Task {
  id: String!,           // e.g., "task_2026-05-17_proposal_draft" (work),
                         //       "task_2026-05-17_book_dentist" (personal)
  title: String!,
  domain: String!,       // personal, work
  status: String!,       // pending, in_progress, completed, deferred, cancelled
  priority: String,      // urgent, high, medium, low
  due_date: Date,
  context: String,       // client, opportunity, content, admin (work)
                         // errand, household, social, health (personal)
  related_to: String,
  description: String,
  completed_date: Date,
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})

Tooling note: Kairos is the Personal calendar/task/contact tool (shared read-only with Work agents for deconfliction); Athena is the Work CRM. Work agents may read Personal tasks for scheduling but do not write them.

Meeting

(: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

(: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

(: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

(: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

(: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

(: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

(: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

// 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

// 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

// 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)

// Solution architecture
(Solution)-[:FOR_CLIENT]->(Client)
(Solution)-[:HAS_DEMO]->(Demo)
(Opportunity)-[:HAS_SOLUTION]->(Solution)
(Solution)-[:INVOLVES]->(Technology)
(Proposal)-[:PRESENTS]->(Solution)

// 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)

// 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

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

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

MERGE (n:Node {id: "..."})
SET n.property = value,
    n.updated_at = datetime()
ON CREATE SET n.created_at = datetime()

Batch Related Operations

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

// 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	Shawn (personal) / Jarvis (work)	id
4	Topic	Universal	Hypatia / Ann	id
5	Goal	Universal	Watson	id
6	Contact	Universal	Shawn (personal) / Jeffrey-All (work)	id
7	Task	Universal	Shawn (personal) / Jarvis (work)	id
8	Communication	Personal	Shawn	id
9	Trip	Personal	Nate	id
10	Destination	Personal	Nate	id
11	Activity	Personal	Nate	id
12	Book	Personal	Hypatia	id
13	Author	Personal	Hypatia	id
14	LearningPath	Personal	Hypatia	id
15	Concept	Personal	Hypatia	id
16	Quote	Personal	Hypatia	id
17	Training	Personal	Marcus	id
18	Exercise	Personal	Marcus	id
19	Program	Personal	Marcus	id
20	PersonalRecord	Personal	Marcus	id
21	BodyMetric	Personal	Marcus	id
22	Reflection	Personal	Watson	id
23	Value	Personal	Watson	id
24	Habit	Personal	Watson	id
25	LifeEvent	Personal	Watson	id
26	Intention	Personal	Watson	id
27	EmotionalMemory	Personal	Watson	id
28	RelationshipTheme	Personal	Watson	id
29	DialogueNote	Personal	Watson	id
30	DynamicPattern	Personal	Watson	id
31	Recipe	Personal	Sophia	id
32	Restaurant	Personal	Sophia	id
33	Ingredient	Personal	Sophia	id
34	Meal	Personal	Sophia	id
35	Technique	Personal	Sophia	id
36	Music	Personal	David	id
37	Film	Personal	David	id
38	Artwork	Personal	David	id
39	Playlist	Personal	David	id
40	Artist	Personal	David	id
41	Style	Personal	David	id
42	Species	Personal	Sophia	id
43	Plant	Personal	Sophia	id
44	Tank	Personal	Sophia	id
45	Garden	Personal	Sophia	id
46	Ecosystem	Personal	Sophia	id
47	Observation	Personal	Sophia	id
48	Account	Personal	Garth	id
49	Investment	Personal	Garth	id
50	Asset	Personal	Garth	id
51	Liability	Personal	Garth	id
52	Budget	Personal	Garth	id
53	FinancialGoal	Personal	Garth	id
54	Match	Personal	Cristiano	id
55	Team	Personal	Cristiano	id
56	League	Personal	Cristiano	id
57	Tournament	Personal	Cristiano	id
58	Player	Personal	Cristiano	id
59	Season	Personal	Cristiano	id
60	Client	Work	Alan / All	id
61	Opportunity	Work	Jeffrey / All	id
62	Proposal	Work	Jeffrey / All	id
63	Project	Work	Jarvis / All	id
64	Solution	Work	Quentin / All	id
65	Demo	Work	Quentin / All	id
66	Vendor	Work	Alan / All	id
67	Competitor	Work	Alan / All	id
68	MarketTrend	Work	Alan / All	id
69	Technology	Work	Alan / All	id
70	Content	Work	Ann / All	id
71	Publication	Work	Ann / All	id
72	Skill	Work	Any work	id
73	Certification	Work	Any work	id
74	Relationship	Work	Any work	id
75	Meeting	Work	Jarvis / All	id
76	Note	Work	Jarvis / All	id
77	Decision	Work	Alan / Jarvis	id
78	Infrastructure	Engineering	Scotty	id
79	Incident	Engineering	Scotty	id
80	Prototype	Engineering	Harper	id
81	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
2.2.0	2026-04-28	Watson replaces Seneca: renamed domain to "Relationship Memory & Emotional Safety", added EmotionalMemory/RelationshipTheme/DialogueNote/DynamicPattern (4 new node types), updated primary owner for Reflection/Value/Habit/LifeEvent/Intention to Watson. Total: 80 nodes, 15 assistants
2.3.0	2026-05-17	Added Shawn (Personal General Assistant). Promoted Contact and Task from Work-only to Universal with domain='personal'|'work' disambiguating ownership (Shawn owns Personal; Jarvis/Jeffrey own Work). Event already had domain field — documented Shawn (personal) vs Jarvis (work) split explicitly. Added Communication node type (Shawn-owned, personal-only interaction history). Renamed Bowie → David in node-summary table. Corrected stale Seneca → Watson on Goal ownership. Documented strict Personal/Work scope divide and Kairos (Personal) vs Athena (Work) tool split. Total: 79 nodes, 16 assistants
2.4.0	2026-06-19	Added Quentin (Solution Architecture lead): Solution and Demo node types (Solution carries architecture + scope_of_work + effort_estimate as facets of one record), with FOR_CLIENT / HAS_DEMO / HAS_SOLUTION / PRESENTS / INVOLVES relationships. Repositioned AWS SA as Quentin's subagent (no node ownership). Added CASE (Field / physical layer) to the Teams & Assistants table — it was already a documented engineering lead but missing from this directory. Total: 81 nodes
2.5.0	2026-07-26	Sophia replaces both Bourdain and Cousteau (2:1 merge): renamed domain to "Home, Food & Living Things", updated primary owner for Recipe/Restaurant/Ingredient/Meal/Technique and Species/Plant/Tank/Garden/Ecosystem/Observation to Sophia. No node types added or removed — uniqueness constraints are keyed on node label, not agent, so no schema or data migration was required. Merged the two per-agent domain sections into one. Corrected stale Bowie's Domain heading to David (missed in 2.3.0). Total: 81 nodes, 17 assistants