r/koios

Fork 0

Files

Robert Helewka c1cc6e26c5 Docs: Engineering team

2026-05-20 17:34:22 -04:00

51 KiB

Raw Blame History

Neo4j Unified Knowledge Graph Schema

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

version: 2.3.0 last_updated: 2026-05-17 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

One graph, many domains — All assistants read from and write to the same database
Domain ownership — Each assistant owns specific node types and is the primary writer
Universal read access — Every assistant can read any node to build cross-domain context
ID-based deduplication — Always MERGE on id; always check before creating
Temporal context — All nodes carry created_at / updated_at timestamps
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	Bourdain	Food & Cooking	Read all, write own domain
Personal	David	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 `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	AWS SA	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

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

Bourdain's Domain (Food & Cooking)

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

Bowie'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
})

Cousteau's Domain (Nature & Living Things)

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

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)

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

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:

Construct the Cypher query
Execute via MCP tool
Parse the response
Handle errors gracefully
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:

Acknowledge naturally in conversation
Continue helping with available context
Suggest checking MCP server connection if persistent
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	Bourdain	id
32	Restaurant	Personal	Bourdain	id
33	Ingredient	Personal	Bourdain	id
34	Meal	Personal	Bourdain	id
35	Technique	Personal	Bourdain	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	Cousteau	id
43	Plant	Personal	Cousteau	id
44	Tank	Personal	Cousteau	id
45	Garden	Personal	Cousteau	id
46	Ecosystem	Personal	Cousteau	id
47	Observation	Personal	Cousteau	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	Vendor	Work	Alan / All	id
65	Competitor	Work	Alan / All	id
66	MarketTrend	Work	Alan / All	id
67	Technology	Work	Alan / All	id
68	Content	Work	Ann / All	id
69	Publication	Work	Ann / All	id
70	Skill	Work	Any work	id
71	Certification	Work	Any work	id
72	Relationship	Work	Any work	id
73	Meeting	Work	Jarvis / All	id
74	Note	Work	Jarvis / All	id
75	Decision	Work	Alan / Jarvis	id
76	Infrastructure	Engineering	Scotty	id
77	Incident	Engineering	Scotty	id
78	Prototype	Engineering	Harper	id
79	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

51 KiB Raw Blame History