openclaw-node-harness 2.0.0

package/mission-control/src/lib/db/index.ts

@@ -0,0 +1,429 @@
+import Database from "better-sqlite3";
+import { drizzle } from "drizzle-orm/better-sqlite3";
+import * as schema from "./schema";
+import { DB_PATH } from "../config";
+import fs from "fs";
+import path from "path";
+
+let _db: ReturnType<typeof drizzle<typeof schema>> | null = null;
+let _sqlite: Database.Database | null = null;
+
+function ensureDataDir() {
+  const dir = path.dirname(DB_PATH);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+}
+
+function runMigrations(sqlite: Database.Database) {
+  sqlite.exec(`
+    CREATE TABLE IF NOT EXISTS tasks (
+      id TEXT PRIMARY KEY,
+      title TEXT NOT NULL,
+      status TEXT NOT NULL,
+      kanban_column TEXT NOT NULL,
+      owner TEXT,
+      success_criteria TEXT,
+      artifacts TEXT,
+      next_action TEXT,
+      updated_at TEXT NOT NULL,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      sort_order INTEGER DEFAULT 0
+    );
+
+    CREATE TABLE IF NOT EXISTS memory_docs (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      source TEXT NOT NULL,
+      category TEXT,
+      file_path TEXT NOT NULL UNIQUE,
+      title TEXT,
+      date TEXT,
+      frontmatter TEXT,
+      content TEXT NOT NULL,
+      modified_at TEXT,
+      indexed_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS activity_log (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      event_type TEXT NOT NULL,
+      task_id TEXT,
+      description TEXT NOT NULL,
+      timestamp TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE VIRTUAL TABLE IF NOT EXISTS memory_fts USING fts5(
+      title,
+      content,
+      category,
+      source,
+      content='memory_docs',
+      content_rowid='id'
+    );
+  `);
+
+  // Create triggers for FTS sync (idempotent via IF NOT EXISTS workaround)
+  const triggerExists = sqlite
+    .prepare(
+      "SELECT name FROM sqlite_master WHERE type='trigger' AND name='memory_docs_ai'"
+    )
+    .get();
+
+  if (!triggerExists) {
+    sqlite.exec(`
+      CREATE TRIGGER memory_docs_ai AFTER INSERT ON memory_docs BEGIN
+        INSERT INTO memory_fts(rowid, title, content, category, source)
+        VALUES (new.id, new.title, new.content, new.category, new.source);
+      END;
+
+      CREATE TRIGGER memory_docs_ad AFTER DELETE ON memory_docs BEGIN
+        INSERT INTO memory_fts(memory_fts, rowid, title, content, category, source)
+        VALUES ('delete', old.id, old.title, old.content, old.category, old.source);
+      END;
+
+      CREATE TRIGGER memory_docs_au AFTER UPDATE ON memory_docs BEGIN
+        INSERT INTO memory_fts(memory_fts, rowid, title, content, category, source)
+        VALUES ('delete', old.id, old.title, old.content, old.category, old.source);
+        INSERT INTO memory_fts(rowid, title, content, category, source)
+        VALUES (new.id, new.title, new.content, new.category, new.source);
+      END;
+    `);
+  }
+
+  // Soul-related tables
+  sqlite.exec(`
+    CREATE TABLE IF NOT EXISTS soul_handoffs (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      task_id TEXT NOT NULL,
+      from_soul TEXT NOT NULL,
+      to_soul TEXT NOT NULL,
+      reason TEXT,
+      context_path TEXT,
+      timestamp TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS soul_evolution_log (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      soul_id TEXT NOT NULL,
+      event_id TEXT NOT NULL UNIQUE,
+      event_type TEXT NOT NULL,
+      description TEXT NOT NULL,
+      review_status TEXT NOT NULL DEFAULT 'pending',
+      commit_hash TEXT,
+      reviewed_by TEXT,
+      reviewed_at TEXT,
+      timestamp TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS soul_spawns (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      soul_id TEXT NOT NULL,
+      task_id TEXT,
+      subagent_type TEXT NOT NULL,
+      timestamp TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+  `);
+
+  // Add soul columns to tasks if missing
+  const taskCols = sqlite.prepare("PRAGMA table_info(tasks)").all() as { name: string }[];
+  const colNames = taskCols.map((c) => c.name);
+  if (!colNames.includes("soul_id")) {
+    sqlite.exec("ALTER TABLE tasks ADD COLUMN soul_id TEXT");
+  }
+  if (!colNames.includes("handoff_source")) {
+    sqlite.exec("ALTER TABLE tasks ADD COLUMN handoff_source TEXT");
+  }
+  if (!colNames.includes("handoff_reason")) {
+    sqlite.exec("ALTER TABLE tasks ADD COLUMN handoff_reason TEXT");
+  }
+  if (!colNames.includes("scheduled_date")) {
+    sqlite.exec("ALTER TABLE tasks ADD COLUMN scheduled_date TEXT");
+  }
+  if (!colNames.includes("project")) {
+    sqlite.exec("ALTER TABLE tasks ADD COLUMN project TEXT");
+  }
+
+  // Hierarchy columns
+  if (!colNames.includes("type")) {
+    sqlite.exec("ALTER TABLE tasks ADD COLUMN type TEXT DEFAULT 'task'");
+  }
+  if (!colNames.includes("parent_id")) {
+    sqlite.exec("ALTER TABLE tasks ADD COLUMN parent_id TEXT");
+  }
+  if (!colNames.includes("start_date")) {
+    sqlite.exec("ALTER TABLE tasks ADD COLUMN start_date TEXT");
+  }
+  if (!colNames.includes("end_date")) {
+    sqlite.exec("ALTER TABLE tasks ADD COLUMN end_date TEXT");
+  }
+  if (!colNames.includes("color")) {
+    sqlite.exec("ALTER TABLE tasks ADD COLUMN color TEXT");
+  }
+  if (!colNames.includes("description")) {
+    sqlite.exec("ALTER TABLE tasks ADD COLUMN description TEXT");
+  }
+
+  // Scheduling columns (replaces auto_start*)
+  if (!colNames.includes("needs_approval")) {
+    sqlite.exec("ALTER TABLE tasks ADD COLUMN needs_approval INTEGER DEFAULT 1");
+  }
+  if (!colNames.includes("trigger_kind")) {
+    sqlite.exec("ALTER TABLE tasks ADD COLUMN trigger_kind TEXT DEFAULT 'none'");
+  }
+  if (!colNames.includes("trigger_at")) {
+    sqlite.exec("ALTER TABLE tasks ADD COLUMN trigger_at TEXT");
+  }
+  if (!colNames.includes("trigger_cron")) {
+    sqlite.exec("ALTER TABLE tasks ADD COLUMN trigger_cron TEXT");
+  }
+  if (!colNames.includes("trigger_tz")) {
+    sqlite.exec("ALTER TABLE tasks ADD COLUMN trigger_tz TEXT DEFAULT 'America/Montreal'");
+  }
+  if (!colNames.includes("is_recurring")) {
+    sqlite.exec("ALTER TABLE tasks ADD COLUMN is_recurring INTEGER DEFAULT 0");
+  }
+  if (!colNames.includes("capacity_class")) {
+    sqlite.exec("ALTER TABLE tasks ADD COLUMN capacity_class TEXT DEFAULT 'normal'");
+  }
+  if (!colNames.includes("auto_priority")) {
+    sqlite.exec("ALTER TABLE tasks ADD COLUMN auto_priority INTEGER DEFAULT 0");
+  }
+  if (!colNames.includes("show_in_calendar")) {
+    sqlite.exec("ALTER TABLE tasks ADD COLUMN show_in_calendar INTEGER DEFAULT 0");
+  }
+  // FIX: acknowledged_at was in schema.ts but missing from migrations —
+  // existing DBs would crash on any read/write touching this column.
+  if (!colNames.includes("acknowledged_at")) {
+    sqlite.exec("ALTER TABLE tasks ADD COLUMN acknowledged_at TEXT");
+  }
+
+  // Mesh execution columns (synced from active-tasks.md via kanban-io)
+  if (!colNames.includes("execution")) {
+    sqlite.exec("ALTER TABLE tasks ADD COLUMN execution TEXT");
+  }
+  if (!colNames.includes("metric")) {
+    sqlite.exec("ALTER TABLE tasks ADD COLUMN metric TEXT");
+  }
+  if (!colNames.includes("budget_minutes")) {
+    sqlite.exec("ALTER TABLE tasks ADD COLUMN budget_minutes INTEGER DEFAULT 30");
+  }
+  if (!colNames.includes("scope")) {
+    sqlite.exec("ALTER TABLE tasks ADD COLUMN scope TEXT");
+  }
+
+  // Mesh node tracking — links MC tasks to NATS KV tasks and claiming nodes
+  if (!colNames.includes("mesh_task_id")) {
+    sqlite.exec("ALTER TABLE tasks ADD COLUMN mesh_task_id TEXT");
+  }
+  if (!colNames.includes("mesh_node")) {
+    sqlite.exec("ALTER TABLE tasks ADD COLUMN mesh_node TEXT");
+  }
+
+  // Data migration: convert old auto_start columns to new scheduling schema
+  if (colNames.includes("auto_start")) {
+    sqlite.exec(`
+      UPDATE tasks SET
+        needs_approval = CASE WHEN auto_start = 1 THEN 0 ELSE 1 END,
+        trigger_kind = CASE
+          WHEN auto_start = 1 AND auto_start_after IS NOT NULL THEN 'at'
+          WHEN auto_start = 1 THEN 'none'
+          ELSE 'none'
+        END,
+        trigger_at = auto_start_after
+      WHERE auto_start IS NOT NULL AND needs_approval IS NULL
+    `);
+  }
+
+  // Dependencies table (DAG edges)
+  sqlite.exec(`
+    CREATE TABLE IF NOT EXISTS dependencies (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      source_id TEXT NOT NULL,
+      target_id TEXT NOT NULL,
+      type TEXT NOT NULL DEFAULT 'finish_to_start',
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+  `);
+
+  // Indexes for hierarchy and dependency lookups
+  sqlite.exec(`
+    CREATE INDEX IF NOT EXISTS idx_tasks_parent_id ON tasks(parent_id);
+    CREATE INDEX IF NOT EXISTS idx_tasks_type ON tasks(type);
+    CREATE INDEX IF NOT EXISTS idx_deps_source ON dependencies(source_id);
+    CREATE INDEX IF NOT EXISTS idx_deps_target ON dependencies(target_id);
+    CREATE INDEX IF NOT EXISTS idx_tasks_trigger_kind ON tasks(trigger_kind);
+    CREATE INDEX IF NOT EXISTS idx_tasks_needs_approval ON tasks(needs_approval);
+    CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status);
+    CREATE INDEX IF NOT EXISTS idx_tasks_project ON tasks(project);
+    CREATE INDEX IF NOT EXISTS idx_tasks_kanban_column ON tasks(kanban_column);
+  `);
+
+  // Memory items table (extracted atomic facts)
+  sqlite.exec(`
+    CREATE TABLE IF NOT EXISTS memory_items (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      fact_text TEXT NOT NULL,
+      confidence INTEGER DEFAULT 70,
+      source_doc_id INTEGER,
+      category TEXT,
+      status TEXT DEFAULT 'active',
+      gate_decision TEXT,
+      gate_reason TEXT,
+      extraction_source TEXT,
+      last_accessed TEXT,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS memory_audit (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      operation TEXT NOT NULL,
+      item_id INTEGER,
+      detail TEXT,
+      timestamp TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_items_category ON memory_items(category);
+    CREATE INDEX IF NOT EXISTS idx_items_status ON memory_items(status);
+    CREATE INDEX IF NOT EXISTS idx_items_source ON memory_items(source_doc_id);
+    CREATE INDEX IF NOT EXISTS idx_audit_operation ON memory_audit(operation);
+  `);
+
+  // FTS5 index for memory items (fact-level search)
+  sqlite.exec(`
+    CREATE VIRTUAL TABLE IF NOT EXISTS memory_items_fts USING fts5(
+      fact_text,
+      category,
+      content='memory_items',
+      content_rowid='id'
+    );
+  `);
+
+  // FTS triggers for memory items
+  const itemTriggerExists = sqlite
+    .prepare(
+      "SELECT name FROM sqlite_master WHERE type='trigger' AND name='memory_items_ai'"
+    )
+    .get();
+
+  if (!itemTriggerExists) {
+    sqlite.exec(`
+      CREATE TRIGGER memory_items_ai AFTER INSERT ON memory_items BEGIN
+        INSERT INTO memory_items_fts(rowid, fact_text, category)
+        VALUES (new.id, new.fact_text, new.category);
+      END;
+
+      CREATE TRIGGER memory_items_ad AFTER DELETE ON memory_items BEGIN
+        INSERT INTO memory_items_fts(memory_items_fts, rowid, fact_text, category)
+        VALUES ('delete', old.id, old.fact_text, old.category);
+      END;
+
+      CREATE TRIGGER memory_items_au AFTER UPDATE ON memory_items BEGIN
+        INSERT INTO memory_items_fts(memory_items_fts, rowid, fact_text, category)
+        VALUES ('delete', old.id, old.fact_text, old.category);
+        INSERT INTO memory_items_fts(rowid, fact_text, category)
+        VALUES (new.id, new.fact_text, new.category);
+      END;
+    `);
+  }
+
+  // --- Knowledge Graph tables ---
+  sqlite.exec(`
+    CREATE TABLE IF NOT EXISTS memory_entities (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      name TEXT NOT NULL,
+      type TEXT NOT NULL,
+      aliases TEXT,
+      first_seen TEXT NOT NULL DEFAULT (datetime('now')),
+      last_seen TEXT NOT NULL DEFAULT (datetime('now')),
+      access_count INTEGER DEFAULT 1,
+      metadata TEXT
+    );
+
+    CREATE TABLE IF NOT EXISTS memory_relations (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      source_entity_id INTEGER NOT NULL,
+      target_entity_id INTEGER NOT NULL,
+      relation_type TEXT NOT NULL,
+      confidence INTEGER DEFAULT 80,
+      source_item_id INTEGER,
+      valid_from TEXT NOT NULL DEFAULT (datetime('now')),
+      valid_to TEXT,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS memory_entity_items (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      entity_id INTEGER NOT NULL,
+      item_id INTEGER NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_entities_name ON memory_entities(name);
+    CREATE INDEX IF NOT EXISTS idx_entities_type ON memory_entities(type);
+    CREATE INDEX IF NOT EXISTS idx_relations_source ON memory_relations(source_entity_id);
+    CREATE INDEX IF NOT EXISTS idx_relations_target ON memory_relations(target_entity_id);
+    CREATE INDEX IF NOT EXISTS idx_relations_type ON memory_relations(relation_type);
+    CREATE INDEX IF NOT EXISTS idx_entity_items_entity ON memory_entity_items(entity_id);
+    CREATE INDEX IF NOT EXISTS idx_entity_items_item ON memory_entity_items(item_id);
+  `);
+
+  // --- Temporal columns on memory_items ---
+  const itemCols = sqlite.prepare("PRAGMA table_info(memory_items)").all() as { name: string }[];
+  const itemColNames = itemCols.map((c) => c.name);
+  if (!itemColNames.includes("superseded_by")) {
+    sqlite.exec("ALTER TABLE memory_items ADD COLUMN superseded_by INTEGER");
+  }
+  if (!itemColNames.includes("valid_from")) {
+    sqlite.exec("ALTER TABLE memory_items ADD COLUMN valid_from TEXT DEFAULT (datetime('now'))");
+  }
+  if (!itemColNames.includes("valid_to")) {
+    sqlite.exec("ALTER TABLE memory_items ADD COLUMN valid_to TEXT");
+  }
+
+  // Add cross-soul propagation columns to soul_evolution_log if missing
+  const evolCols = sqlite.prepare("PRAGMA table_info(soul_evolution_log)").all() as { name: string }[];
+  const evolColNames = evolCols.map((c) => c.name);
+  if (!evolColNames.includes("source_soul_id")) {
+    sqlite.exec("ALTER TABLE soul_evolution_log ADD COLUMN source_soul_id TEXT");
+  }
+  if (!evolColNames.includes("source_event_id")) {
+    sqlite.exec("ALTER TABLE soul_evolution_log ADD COLUMN source_event_id TEXT");
+  }
+
+  // --- Token usage tracking (mesh agent cost data) ---
+  sqlite.exec(`
+    CREATE TABLE IF NOT EXISTS token_usage (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      task_id TEXT,
+      node_id TEXT,
+      model TEXT NOT NULL,
+      input_tokens INTEGER NOT NULL,
+      output_tokens INTEGER NOT NULL,
+      cost_usd REAL NOT NULL,
+      timestamp TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_token_usage_task ON token_usage(task_id);
+    CREATE INDEX IF NOT EXISTS idx_token_usage_node ON token_usage(node_id);
+    CREATE INDEX IF NOT EXISTS idx_token_usage_ts ON token_usage(timestamp);
+  `);
+}
+
+export function getDb() {
+  if (_db) return _db;
+
+  ensureDataDir();
+
+  _sqlite = new Database(DB_PATH);
+  _sqlite.pragma("journal_mode = WAL");
+  _sqlite.pragma("foreign_keys = ON");
+
+  runMigrations(_sqlite);
+
+  _db = drizzle(_sqlite, { schema });
+  return _db;
+}
+
+export function getRawDb(): Database.Database {
+  if (!_sqlite) getDb();
+  return _sqlite!;
+}

package/mission-control/src/lib/db/schema.ts

@@ -0,0 +1,218 @@
+import { sqliteTable, text, integer } from "drizzle-orm/sqlite-core";
+import { sql } from "drizzle-orm";
+
+export const tasks = sqliteTable("tasks", {
+  id: text("id").primaryKey(),
+  title: text("title").notNull(),
+  status: text("status").notNull(),
+  kanbanColumn: text("kanban_column").notNull(),
+  owner: text("owner"),
+  soulId: text("soul_id"), // NEW: which soul owns this task
+  handoffSource: text("handoff_source"), // NEW: previous owner (for handoffs)
+  handoffReason: text("handoff_reason"), // NEW: why handed off
+  successCriteria: text("success_criteria"),
+  artifacts: text("artifacts"),
+  nextAction: text("next_action"),
+  scheduledDate: text("scheduled_date"), // ISO date for calendar: "2026-02-21"
+  project: text("project"), // Freeform project tag: "arcane", "budgetapp", etc.
+  type: text("type").default("task"), // "project" | "pipeline" | "phase" | "task"
+  parentId: text("parent_id"), // FK to tasks.id (self-reference for hierarchy)
+  startDate: text("start_date"), // ISO date: "2026-03-01" (range start)
+  endDate: text("end_date"), // ISO date: "2026-04-15" (range end)
+  color: text("color"), // hex color for Gantt bars
+  description: text("description"), // markdown body for projects/phases
+  needsApproval: integer("needs_approval").default(1), // 0=Daedalus can start, 1=wait for Gui
+  triggerKind: text("trigger_kind").default("none"), // "none" | "at" | "cron"
+  triggerAt: text("trigger_at"), // ISO datetime for one-shot trigger
+  triggerCron: text("trigger_cron"), // cron expression (e.g. "0 10 * * 1")
+  triggerTz: text("trigger_tz").default("America/Montreal"), // timezone for cron eval
+  isRecurring: integer("is_recurring").default(0), // 1=auto-recreate after done
+  capacityClass: text("capacity_class").default("normal"), // "light" | "normal" | "heavy"
+  autoPriority: integer("auto_priority").default(0), // higher = dispatched first
+  // Mesh execution fields (synced from active-tasks.md)
+  execution: text("execution"), // "mesh" = dispatched via mesh bridge; null = manual/Daedalus
+  meshTaskId: text("mesh_task_id"), // NATS KV task ID (e.g. "MESH-TEST-003")
+  meshNode: text("mesh_node"), // node that claimed the task (e.g. "calos-ubuntu")
+  metric: text("metric"), // mechanical success check (e.g. "tests pass")
+  budgetMinutes: integer("budget_minutes").default(30), // agent time budget
+  scope: text("scope"), // JSON array of allowed file paths
+  showInCalendar: integer("show_in_calendar").default(0), // 1=show meta-task in calendar view
+  acknowledgedAt: text("acknowledged_at"), // ISO datetime — when Daedalus acknowledged auto-dispatch
+  updatedAt: text("updated_at").notNull(),
+  createdAt: text("created_at")
+    .notNull()
+    .default(sql`(datetime('now'))`),
+  sortOrder: integer("sort_order").default(0),
+});
+
+export const memoryDocs = sqliteTable("memory_docs", {
+  id: integer("id").primaryKey({ autoIncrement: true }),
+  source: text("source").notNull(),
+  category: text("category"),
+  filePath: text("file_path").notNull().unique(),
+  title: text("title"),
+  date: text("date"),
+  frontmatter: text("frontmatter"),
+  content: text("content").notNull(),
+  modifiedAt: text("modified_at"),
+  indexedAt: text("indexed_at")
+    .notNull()
+    .default(sql`(datetime('now'))`),
+});
+
+export const activityLog = sqliteTable("activity_log", {
+  id: integer("id").primaryKey({ autoIncrement: true }),
+  eventType: text("event_type").notNull(),
+  taskId: text("task_id"),
+  description: text("description").notNull(),
+  timestamp: text("timestamp")
+    .notNull()
+    .default(sql`(datetime('now'))`),
+});
+
+export const soulHandoffs = sqliteTable("soul_handoffs", {
+  id: integer("id").primaryKey({ autoIncrement: true }),
+  taskId: text("task_id").notNull(),
+  fromSoul: text("from_soul").notNull(),
+  toSoul: text("to_soul").notNull(),
+  reason: text("reason"),
+  contextPath: text("context_path"), // Path to handoff document in ClawVault
+  timestamp: text("timestamp")
+    .notNull()
+    .default(sql`(datetime('now'))`),
+});
+
+export const soulEvolutionLog = sqliteTable("soul_evolution_log", {
+  id: integer("id").primaryKey({ autoIncrement: true }),
+  soulId: text("soul_id").notNull(),
+  eventId: text("event_id").notNull().unique(), // References evolution/events.jsonl
+  eventType: text("event_type").notNull(), // learning, correction, feature_request
+  description: text("description").notNull(),
+  reviewStatus: text("review_status").notNull().default("pending"), // pending, approved, rejected
+  commitHash: text("commit_hash"), // Git commit after approval
+  reviewedBy: text("reviewed_by"), // Soul ID of reviewer
+  reviewedAt: text("reviewed_at"),
+  sourceSoulId: text("source_soul_id"), // Cross-soul: which soul originated this gene
+  sourceEventId: text("source_event_id"), // Cross-soul: original event ID
+  timestamp: text("timestamp")
+    .notNull()
+    .default(sql`(datetime('now'))`),
+});
+
+export const dependencies = sqliteTable("dependencies", {
+  id: integer("id").primaryKey({ autoIncrement: true }),
+  sourceId: text("source_id").notNull(), // task that must complete first
+  targetId: text("target_id").notNull(), // task that is blocked
+  type: text("type").notNull().default("finish_to_start"),
+  createdAt: text("created_at")
+    .notNull()
+    .default(sql`(datetime('now'))`),
+});
+
+export type Task = typeof tasks.$inferSelect;
+export type NewTask = typeof tasks.$inferInsert;
+export type Dependency = typeof dependencies.$inferSelect;
+export type NewDependency = typeof dependencies.$inferInsert;
+export type MemoryDoc = typeof memoryDocs.$inferSelect;
+export type NewMemoryDoc = typeof memoryDocs.$inferInsert;
+export type ActivityLogEntry = typeof activityLog.$inferSelect;
+export type SoulHandoff = typeof soulHandoffs.$inferSelect;
+export type NewSoulHandoff = typeof soulHandoffs.$inferInsert;
+export const soulSpawns = sqliteTable("soul_spawns", {
+  id: integer("id").primaryKey({ autoIncrement: true }),
+  soulId: text("soul_id").notNull(),
+  taskId: text("task_id"), // Optional — linked task if spawned for a specific task
+  subagentType: text("subagent_type").notNull(), // general-purpose, Explore, etc.
+  timestamp: text("timestamp")
+    .notNull()
+    .default(sql`(datetime('now'))`),
+});
+
+// --- Memory Items (extracted atomic facts) ---
+
+export const memoryItems = sqliteTable("memory_items", {
+  id: integer("id").primaryKey({ autoIncrement: true }),
+  factText: text("fact_text").notNull(),
+  confidence: integer("confidence").default(70), // 0-100 (stored as int, display as 0.XX)
+  sourceDocId: integer("source_doc_id"), // FK to memory_docs.id
+  category: text("category"), // work, preferences, people, projects, technical, relationships
+  status: text("status").default("active"), // active | archived | stale
+  gateDecision: text("gate_decision"), // accepted | rejected
+  gateReason: text("gate_reason"), // why accepted/rejected
+  extractionSource: text("extraction_source"), // file path or session ID
+  lastAccessed: text("last_accessed"),
+  supersededBy: integer("superseded_by"), // FK to memory_items.id (temporal chain)
+  validFrom: text("valid_from")
+    .notNull()
+    .default(sql`(datetime('now'))`),
+  validTo: text("valid_to"), // null = still valid; set when superseded
+  createdAt: text("created_at")
+    .notNull()
+    .default(sql`(datetime('now'))`),
+});
+
+export const memoryAudit = sqliteTable("memory_audit", {
+  id: integer("id").primaryKey({ autoIncrement: true }),
+  operation: text("operation").notNull(), // extract, gate_accept, gate_reject, merge, archive, search
+  itemId: integer("item_id"),
+  detail: text("detail"), // JSON or descriptive text
+  timestamp: text("timestamp")
+    .notNull()
+    .default(sql`(datetime('now'))`),
+});
+
+export type MemoryItem = typeof memoryItems.$inferSelect;
+export type NewMemoryItem = typeof memoryItems.$inferInsert;
+export type MemoryAuditEntry = typeof memoryAudit.$inferSelect;
+
+// --- Knowledge Graph: Entities + Relations ---
+
+export const memoryEntities = sqliteTable("memory_entities", {
+  id: integer("id").primaryKey({ autoIncrement: true }),
+  name: text("name").notNull(), // canonical name: "ManaWell", "Gui", "Arcane"
+  type: text("type").notNull(), // person | project | contract | concept | tool | file
+  aliases: text("aliases"), // JSON array of alternate names: ["mana well", "ManaWell.sol"]
+  firstSeen: text("first_seen")
+    .notNull()
+    .default(sql`(datetime('now'))`),
+  lastSeen: text("last_seen")
+    .notNull()
+    .default(sql`(datetime('now'))`),
+  accessCount: integer("access_count").default(1),
+  metadata: text("metadata"), // JSON: extra type-specific data
+});
+
+export const memoryRelations = sqliteTable("memory_relations", {
+  id: integer("id").primaryKey({ autoIncrement: true }),
+  sourceEntityId: integer("source_entity_id").notNull(), // FK to memory_entities.id
+  targetEntityId: integer("target_entity_id").notNull(), // FK to memory_entities.id
+  relationType: text("relation_type").notNull(), // owns | uses | depends_on | blocks | part_of | related_to | supersedes
+  confidence: integer("confidence").default(80), // 0-100
+  sourceItemId: integer("source_item_id"), // FK to memory_items.id (which fact established this relation)
+  validFrom: text("valid_from")
+    .notNull()
+    .default(sql`(datetime('now'))`),
+  validTo: text("valid_to"), // null = still valid
+  createdAt: text("created_at")
+    .notNull()
+    .default(sql`(datetime('now'))`),
+});
+
+// --- Entity-Item junction (which entities appear in which facts) ---
+
+export const memoryEntityItems = sqliteTable("memory_entity_items", {
+  id: integer("id").primaryKey({ autoIncrement: true }),
+  entityId: integer("entity_id").notNull(), // FK to memory_entities.id
+  itemId: integer("item_id").notNull(), // FK to memory_items.id
+});
+
+export type MemoryEntity = typeof memoryEntities.$inferSelect;
+export type NewMemoryEntity = typeof memoryEntities.$inferInsert;
+export type MemoryRelation = typeof memoryRelations.$inferSelect;
+export type NewMemoryRelation = typeof memoryRelations.$inferInsert;
+export type MemoryEntityItem = typeof memoryEntityItems.$inferSelect;
+
+export type SoulEvolution = typeof soulEvolutionLog.$inferSelect;
+export type NewSoulEvolution = typeof soulEvolutionLog.$inferInsert;
+export type SoulSpawn = typeof soulSpawns.$inferSelect;
+export type NewSoulSpawn = typeof soulSpawns.$inferInsert;