Data Models

model User {
  id        String   @id @default(uuid())
  email     String   @unique
  name      String?
  createdAt DateTime @default(now())
  updatedAt DateTime @updatedAt

  // Relations
  lifestates    LifeState[]
  projects      Project[]
  skills        SkillEvidence[]
  sessions      Session[]
}

model LifeState {
  id        String   @id @default(uuid())
  userId    String
  timestamp DateTime @default(now())

  // Latent vector (stored as JSON)
  latentVector Json

  // Derived physics variables
  thrust        Float
  alignment     Float
  gravity       Float
  mass          Float
  escapeIndex   Float

  // Metadata
  notes         String?

  // Relations
  user          User     @relation(fields: [userId], references: [id], onDelete: Cascade)

  @@index([userId, timestamp])
}

// Get current state
const current = await prisma.lifeState.findFirst({
  where: { userId },
  orderBy: { timestamp: 'desc' }
});

// Get history (last 30 days)
const history = await prisma.lifeState.findMany({
  where: {
    userId,
    timestamp: { gte: thirtyDaysAgo }
  },
  orderBy: { timestamp: 'asc' }
});

model Skill {
 id          String   @id @default(uuid())
  name        String   @unique
  domain      String
  description String?
  createdAt   DateTime @default(now())

  // Relations
  evidence    SkillEvidence[]
  edges       SkillEdge[]     @relation("SkillFrom")
  edgesTo     SkillEdge[]     @relation("SkillTo")
}

const skills = [
  { name: "Python", domain: "Programming" },
  { name: "Choreography", domain: "Creative" },
  { name: "System Design", domain: "Engineering" },
  { name: "Leadership", domain: "Management" }
];

model SkillEdge {
  id            String   @id @default(uuid())
  fromSkillId   String
  toSkillId     String
  weight        Float    @default(0.5)
  description   String?

  fromSkill     Skill    @relation("SkillFrom", fields: [fromSkillId], references: [id], onDelete: Cascade)
  toSkill       Skill    @relation("SkillTo", fields: [toSkillId], references: [id], onDelete: Cascade)

  @@unique([fromSkillId, toSkillId])
}

const edges = [
  { from: "Python", to: "JavaScript", weight: 0.7, description: "Programming concepts transfer" },
  { from: "Choreography", to: "Animation", weight: 0.6, description: "Movement principles" },
  { from: "System Design", to: "Architecture", weight: 0.8, description: "Structural thinking" }
];

// Get all skills reachable from Python within 2 hops
const reachable = await prisma.$queryRaw`
  WITH RECURSIVE skill_path AS (
    SELECT to_skill_id, 1 AS depth
    FROM skill_edges
    WHERE from_skill_id = ${pythonId}
    UNION
    SELECT e.to_skill_id, p.depth + 1
    FROM skill_edges e
    JOIN skill_path p ON e.from_skill_id = p.to_skill_id
    WHERE p.depth < 2
  )
  SELECT DISTINCT s.* FROM skills s
  JOIN skill_path sp ON s.id = sp.to_skill_id
`;

model SkillEvidence {
  id          String   @id @default(uuid())
  userId      String
  skillId     String
  timestamp   DateTime @default(now())

  // Evidence data
  level       Float    // Estimated level (0-10)
  confidence  Float    // Confidence (0-1)
  source      String   // "interview", "artifact", "echelon", etc.
  sourceRef   String?  // Reference to source
  notes       String?

  // Relations
  user        User     @relation(fields: [userId], references: [id], onDelete: Cascade)
  skill       Skill    @relation(fields: [skillId], references: [id], onDelete: Cascade)

  @@index([userId, skillId, timestamp])
}

// When new evidence arrives
const evidence = await prisma.skillEvidence.create({
  data: {
    userId,
    skillId,
    level: 7.5,
    confidence: 0.8,
    source: "interview",
    sourceRef: sessionId,
    notes: "Built 3 production apps in Python"
  }
});

// Trigger Bayesian update in Python model
await fetch('http://skill-model:5001/update', {
  method: 'POST',
  body: JSON.stringify({ userId, skillId, evidence })
});

model Project {
  id          String   @id @default(uuid())
  userId      String
  name        String
  description String?
  status      String   @default("active")
  createdAt   DateTime @default(now())
  updatedAt   DateTime @updatedAt

  // Project metadata
  embedding   Json?    // Vector embedding
  metadata    Json?    // Flexible metadata

  // Relations
  user        User     @relation(fields: [userId], references: [id], onDelete: Cascade)

  @@index([userId, status])
}

{
  "tags": ["web-dev", "side-project"],
  "hoursPerWeek": 10,
  "priority": "high",
  "repository": "https://github.com/user/project",
  "relatedSkills": ["Python", "React", "System Design"]
}

// Get all active projects
const projects = await prisma.project.findMany({
  where: { userId, status: 'active' }
});

// Compute alignment (cosine similarity of embeddings)
const alignment = await fetch('http://alignment-model:5002/compute', {
  method: 'POST',
  body: JSON.stringify({ projects })
});

model Session {
  id          String   @id @default(uuid())
  userId      String
  type        String
  startTime   DateTime @default(now())
  endTime     DateTime?
  status      String   @default("active")

  // Session data
  transcript  String?
  artifacts   Json?
  metadata    Json?

  // Relations
  user        User     @relation(fields: [userId], references: [id], onDelete: Cascade)

  @@index([userId, startTime])
}

{
  "messages": [
    { "role": "agent", "content": "Tell me about your recent work.", "timestamp": "..." },
    { "role": "user", "content": "I've been building a choreography app.", "timestamp": "..." },
    { "role": "agent", "content": "What technologies are you using?", "timestamp": "..." }
  ]
}

model Memory {
  id          String   @id @default(uuid())
  userId      String?
  content     String
  embedding   Json
  source      String
  sourceRef   String?
  timestamp   DateTime @default(now())
  metadata    Json?

  @@index([userId, timestamp])
}

// Store memory from interview
await prisma.memory.create({
  data: {
    userId,
    content: "User is interested in computational choreography and has experience with Python and creative coding.",
    embedding: await embed(content),
    source: "interview",
    sourceRef: sessionId
  }
});

// Later, retrieve relevant memories
const query = "What are my main interests?";
const queryEmbedding = await embed(query);

const relevant = await vectorStore.search(queryEmbedding, {
  filter: { userId },
  limit: 5
});

export interface LifePhysics {
  thrust: number;
  alignment: number;
  gravity: number;
  mass: number;
  escapeIndex: number;
}

export interface SkillBelief {
  skillId: string;
  mean: number;          // Posterior mean level
  variance: number;      // Posterior variance
  confidence: number;    // Confidence interval width
  utilization: number;   // How actively used (0-1)
  lastEvidence: Date;
}

export interface EchelonSummary {
  sessionId: string;
  userId: string;
  startTime: Date;
  endTime: Date;

  // Aggregated metrics
  avgTension: number;
  avgDrift: number;
  avgMomentum: number;
  avgPhase: number;
  flowScore: number;

  // Detected episodes
  flowEpisodes: Array<{ start: Date; end: Date }>;
  breakdownPeriods?: Array<{ start: Date; end: Date }>;

  // Context tagging
  activity?: string;
  projectIds?: string[];
  skillIds?: string[];
  notes?: string;
}

// Already defined in models above:
@@index([userId, timestamp])  // LifeState, Session, Memory
@@index([userId, skillId, timestamp])  // SkillEvidence
@@index([userId, status])  // Project

cd services/trajectory-core
pnpm prisma migrate dev --name init

pnpm prisma migrate dev --name add_new_model

pnpm prisma migrate deploy

1. Create User record
2. Run initial interview
3. Create SkillEvidence from interview
4. Compute initial LifeState
5. Store in database

Daily:
- Background analysis job
- Recompute LifeState
- Store new snapshot

Weekly:
- Prune old LifeState snapshots (keep daily aggregates)
- Cleanup completed sessions

1. Mark user as deleted
2. Cascade delete all related records
3. Anonymize memories (remove userId)
4. Export user data before deletion (if requested)