@goondocks/myco 0.20.2 → 0.21.1

package/dist/{chunk-MYOZLMB2.js → chunk-DTWUHHFI.js}

@@ -2,7 +2,7 @@ import { createRequire as __cr } from 'node:module'; const require = __cr(import
 import {
   DEFAULT_MACHINE_ID,
   epochSeconds
-} from "./chunk-FLLBJLHM.js";
+} from "./chunk-6C6QZ4PM.js";
 
 // src/db/schema-ddl.ts
 var SCHEMA_VERSION_TABLE = `
@@ -73,6 +73,7 @@ var ACTIVITIES_TABLE = `
 var PLANS_TABLE = `
   CREATE TABLE IF NOT EXISTS plans (
     id               TEXT PRIMARY KEY,
+    logical_key      TEXT NOT NULL,
     status           TEXT DEFAULT 'active',
     author           TEXT,
     title            TEXT,
@@ -229,19 +230,48 @@ var DIGEST_EXTRACTS_TABLE = `
     synced_at       INTEGER,
     UNIQUE (agent_id, tier)
   )`;
+var CORTEX_INSTRUCTIONS_TABLE = `
+  CREATE TABLE IF NOT EXISTS cortex_instructions (
+    id            TEXT PRIMARY KEY,
+    agent_id      TEXT NOT NULL,
+    content       TEXT NOT NULL,
+    input_hash    TEXT NOT NULL,
+    source_run_id TEXT,
+    generated_at  INTEGER NOT NULL,
+    machine_id    TEXT NOT NULL DEFAULT 'local',
+    synced_at     INTEGER
+  )`;
 var AGENT_RUNS_TABLE = `
   CREATE TABLE IF NOT EXISTS agent_runs (
-    id            TEXT PRIMARY KEY,
-    agent_id      TEXT NOT NULL REFERENCES agents(id),
-    task          TEXT,
-    instruction   TEXT,
-    status        TEXT DEFAULT 'pending',
-    started_at    INTEGER,
-    completed_at  INTEGER,
-    tokens_used   INTEGER,
-    cost_usd      REAL,
-    actions_taken TEXT,
-    error         TEXT
+    id             TEXT PRIMARY KEY,
+    agent_id       TEXT NOT NULL REFERENCES agents(id),
+    task           TEXT,
+    instruction    TEXT,
+    status         TEXT DEFAULT 'pending',
+    runtime        TEXT,
+    provider       TEXT,
+    model          TEXT,
+    session_ref    TEXT,
+    resumable      INTEGER DEFAULT 0,
+    resume_status  TEXT,
+    resume_mode    TEXT,
+    resumed_at     INTEGER,
+    checkpoints    TEXT,
+    usage_data     TEXT,
+    started_at     INTEGER,
+    completed_at   INTEGER,
+    tokens_used    INTEGER,
+    cost_usd       REAL,
+    actual_cost_usd REAL,
+    estimated_cost_usd REAL,
+    cost_source    TEXT,
+    cost_data      TEXT,
+    actions_taken  TEXT,
+    error          TEXT,
+    dry_run        INTEGER NOT NULL DEFAULT 0,
+    evaluation_id  TEXT,
+    reasoning_level      TEXT,
+    execution_overrides  TEXT
   )`;
 var AGENT_REPORTS_TABLE = `
   CREATE TABLE IF NOT EXISTS agent_reports (
@@ -383,6 +413,38 @@ var NOTIFICATIONS_TABLE = `
     metadata    TEXT,
     created_at  INTEGER NOT NULL
   )`;
+var AGENT_RUN_WRITE_INTENTS_TABLE = `
+  CREATE TABLE IF NOT EXISTS agent_run_write_intents (
+    id                INTEGER PRIMARY KEY AUTOINCREMENT,
+    run_id            TEXT NOT NULL REFERENCES agent_runs(id) ON DELETE CASCADE,
+    phase_id          TEXT,
+    tool_name         TEXT NOT NULL,
+    tool_input        TEXT NOT NULL,
+    synthetic_output  TEXT NOT NULL,
+    stub_id           TEXT,
+    recorded_at       INTEGER NOT NULL
+  )`;
+var DIGEST_EXTRACT_REVISIONS_TABLE = `
+  CREATE TABLE IF NOT EXISTS digest_extract_revisions (
+    id                  INTEGER PRIMARY KEY AUTOINCREMENT,
+    agent_id            TEXT NOT NULL,
+    tier                INTEGER NOT NULL,
+    content             TEXT NOT NULL,
+    metadata            TEXT,
+    run_id              TEXT REFERENCES agent_runs(id) ON DELETE SET NULL,
+    parent_revision_id  INTEGER REFERENCES digest_extract_revisions(id),
+    created_at          INTEGER NOT NULL
+  )`;
+var AGENT_RUN_EVALUATIONS_TABLE = `
+  CREATE TABLE IF NOT EXISTS agent_run_evaluations (
+    id            TEXT PRIMARY KEY,
+    task_id       TEXT NOT NULL,
+    matrix_json   TEXT NOT NULL,
+    notes         TEXT,
+    status        TEXT NOT NULL DEFAULT 'pending',
+    created_at    INTEGER NOT NULL,
+    completed_at  INTEGER
+  )`;
 var FTS_TABLES = [
   `CREATE VIRTUAL TABLE IF NOT EXISTS prompt_batches_fts
      USING fts5(user_prompt, response_summary, content='prompt_batches', content_rowid='id')`,
@@ -475,11 +537,14 @@ var SECONDARY_INDEXES = [
   "CREATE INDEX IF NOT EXISTS idx_resolution_events_agent_id ON resolution_events (agent_id)",
   // Digest extracts
   "CREATE INDEX IF NOT EXISTS idx_digest_extracts_agent_id ON digest_extracts (agent_id)",
+  "CREATE INDEX IF NOT EXISTS idx_cortex_instructions_agent_id ON cortex_instructions (agent_id)",
   // Agent runs
   "CREATE INDEX IF NOT EXISTS idx_agent_runs_agent_id ON agent_runs (agent_id)",
   "CREATE INDEX IF NOT EXISTS idx_agent_runs_status ON agent_runs (status)",
   "CREATE INDEX IF NOT EXISTS idx_agent_runs_agent_status ON agent_runs (agent_id, status)",
   "CREATE INDEX IF NOT EXISTS idx_agent_runs_task_completed ON agent_runs (task, status, completed_at)",
+  "CREATE INDEX IF NOT EXISTS idx_agent_runs_task_status_started_at ON agent_runs (task, status, started_at)",
+  "CREATE INDEX IF NOT EXISTS idx_agent_runs_resumable_task ON agent_runs (task, resumable, completed_at)",
   // Agent reports
   "CREATE INDEX IF NOT EXISTS idx_agent_reports_run_id ON agent_reports (run_id)",
   // Agent turns
@@ -487,6 +552,7 @@ var SECONDARY_INDEXES = [
   // Agent tasks
   "CREATE INDEX IF NOT EXISTS idx_agent_tasks_agent_id ON agent_tasks (agent_id)",
   // Plans
+  "CREATE UNIQUE INDEX IF NOT EXISTS idx_plans_logical_key ON plans (logical_key)",
   "CREATE INDEX IF NOT EXISTS idx_plans_session_id ON plans (session_id)",
   "CREATE INDEX IF NOT EXISTS idx_plans_source_path ON plans (source_path)",
   "CREATE INDEX IF NOT EXISTS idx_plans_content_hash ON plans (content_hash)",
@@ -527,7 +593,12 @@ var SECONDARY_INDEXES = [
   "CREATE INDEX IF NOT EXISTS idx_notifications_status ON notifications (status)",
   "CREATE INDEX IF NOT EXISTS idx_notifications_domain ON notifications (domain)",
   "CREATE INDEX IF NOT EXISTS idx_notifications_created_at ON notifications (created_at)",
-  "CREATE INDEX IF NOT EXISTS idx_notifications_status_created ON notifications (status, created_at)"
+  "CREATE INDEX IF NOT EXISTS idx_notifications_status_created ON notifications (status, created_at)",
+  // Eval harness
+  "CREATE INDEX IF NOT EXISTS idx_write_intents_run_id ON agent_run_write_intents (run_id)",
+  "CREATE INDEX IF NOT EXISTS idx_write_intents_run_id_tool ON agent_run_write_intents (run_id, tool_name)",
+  "CREATE INDEX IF NOT EXISTS idx_digest_revisions_agent_tier ON digest_extract_revisions (agent_id, tier, created_at DESC)",
+  "CREATE INDEX IF NOT EXISTS idx_agent_runs_evaluation_id ON agent_runs (evaluation_id)"
 ];
 var TABLE_DDLS = [
   SCHEMA_VERSION_TABLE,
@@ -547,6 +618,7 @@ var TABLE_DDLS = [
   ENTITY_MENTIONS_TABLE,
   RESOLUTION_EVENTS_TABLE,
   DIGEST_EXTRACTS_TABLE,
+  CORTEX_INSTRUCTIONS_TABLE,
   // Agent state layer
   AGENT_RUNS_TABLE,
   AGENT_REPORTS_TABLE,
@@ -563,7 +635,11 @@ var TABLE_DDLS = [
   // Logging layer
   LOG_ENTRIES_TABLE,
   // Notifications layer
-  NOTIFICATIONS_TABLE
+  NOTIFICATIONS_TABLE,
+  // Eval harness layer
+  AGENT_RUN_WRITE_INTENTS_TABLE,
+  DIGEST_EXTRACT_REVISIONS_TABLE,
+  AGENT_RUN_EVALUATIONS_TABLE
 ];
 
 // src/constants/skill-candidate-status.ts
@@ -584,6 +660,74 @@ var REST_SETTABLE_STATUSES = [
 ];
 var PIPELINE_FILTER_VALUE = `${CANDIDATE_STATUS.APPROVED},${CANDIDATE_STATUS.GENERATED}`;
 
+// src/plans/identity.ts
+import { createHash } from "crypto";
+import path from "path";
+var TRANSCRIPT_SOURCE_PREFIX = "transcript:";
+var PLAN_ID_HASH_LENGTH = 16;
+var PLAN_PATH_KEY_PREFIX = "path:";
+var PLAN_SESSION_KEY_PREFIX = "session:";
+var PLAN_TAG_KEY_SEGMENT = ":tag:";
+var PLAN_PLAN_KEY_SEGMENT = ":key:";
+var PLAN_LEGACY_KEY_PREFIX = "legacy:";
+var PLAN_SESSION_LEGACY_KEY_SEGMENT = ":legacy:";
+var WINDOWS_SEPARATOR = "\\";
+var POSIX_SEPARATOR = "/";
+var ABSOLUTE_PATH_PREFIXES = ["..", `..${path.sep}`];
+function normalizePathSeparators(value) {
+  return value.replaceAll(WINDOWS_SEPARATOR, POSIX_SEPARATOR);
+}
+function isInsideRoot(relativePath) {
+  if (relativePath === "") return true;
+  return !ABSOLUTE_PATH_PREFIXES.some((prefix) => relativePath === prefix || relativePath.startsWith(prefix)) && !path.isAbsolute(relativePath);
+}
+function normalizePlanSourcePath(sourcePath, projectRoot) {
+  if (sourcePath.startsWith(TRANSCRIPT_SOURCE_PREFIX)) return sourcePath;
+  const normalizedProjectRoot = projectRoot ? path.resolve(projectRoot) : null;
+  const resolvedSourcePath = normalizedProjectRoot ? path.resolve(normalizedProjectRoot, sourcePath) : path.resolve(sourcePath);
+  if (normalizedProjectRoot) {
+    const relativePath = path.relative(normalizedProjectRoot, resolvedSourcePath);
+    if (isInsideRoot(relativePath)) {
+      return normalizePathSeparators(path.normalize(relativePath));
+    }
+  }
+  if (path.isAbsolute(sourcePath)) {
+    return normalizePathSeparators(path.normalize(resolvedSourcePath));
+  }
+  return normalizePathSeparators(path.normalize(sourcePath));
+}
+function buildPathPlanLogicalKey(sourcePath, projectRoot) {
+  return `${PLAN_PATH_KEY_PREFIX}${normalizePlanSourcePath(sourcePath, projectRoot)}`;
+}
+function buildSessionTagPlanLogicalKey(sessionId, tag) {
+  return `${PLAN_SESSION_KEY_PREFIX}${sessionId}${PLAN_TAG_KEY_SEGMENT}${tag}`;
+}
+function buildSessionPlanLogicalKey(sessionId, planKey) {
+  return `${PLAN_SESSION_KEY_PREFIX}${sessionId}${PLAN_PLAN_KEY_SEGMENT}${planKey}`;
+}
+function buildLegacyPlanLogicalKey(id, sessionId) {
+  return sessionId ? `${PLAN_SESSION_KEY_PREFIX}${sessionId}${PLAN_SESSION_LEGACY_KEY_SEGMENT}${id}` : `${PLAN_LEGACY_KEY_PREFIX}${id}`;
+}
+function deriveStoredPlanLogicalKey(row) {
+  const sourcePath = row.source_path ?? null;
+  if (sourcePath) {
+    if (sourcePath.startsWith(TRANSCRIPT_SOURCE_PREFIX) && row.session_id) {
+      return buildSessionTagPlanLogicalKey(
+        row.session_id,
+        sourcePath.slice(TRANSCRIPT_SOURCE_PREFIX.length)
+      );
+    }
+    return buildPathPlanLogicalKey(sourcePath);
+  }
+  return buildLegacyPlanLogicalKey(row.id, row.session_id);
+}
+function buildPlanId(logicalKey) {
+  return createHash("md5").update(logicalKey).digest("hex").slice(0, PLAN_ID_HASH_LENGTH);
+}
+function humanizePlanToken(value) {
+  return value.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[-_]+/g, " ").trim().replace(/\b\w/g, (char) => char.toUpperCase());
+}
+
 // src/db/migrations.ts
 var MIGRATIONS = [
   { version: 2, migrate: (db) => migrateV1ToV2(db) },
@@ -596,8 +740,21 @@ var MIGRATIONS = [
   { version: 9, migrate: (db) => migrateV8ToV9(db) },
   { version: 10, migrate: (db) => migrateV9ToV10(db) },
   { version: 11, migrate: (db) => migrateV10ToV11(db) },
-  { version: 12, migrate: (db) => migrateV11ToV12(db) }
+  { version: 12, migrate: (db) => migrateV11ToV12(db) },
+  { version: 13, migrate: (db) => migrateV12ToV13(db) },
+  { version: 14, migrate: (db) => migrateV13ToV14(db) },
+  { version: 15, migrate: (db) => migrateV14ToV15(db) },
+  { version: 16, migrate: (db) => migrateV15ToV16(db) },
+  { version: 17, migrate: (db) => migrateV16ToV17(db) },
+  { version: 18, migrate: (db) => migrateV17ToV18(db) },
+  { version: 19, migrate: (db) => migrateV18ToV19(db) },
+  { version: 20, migrate: (db, machineId) => migrateV19ToV20(db, machineId) },
+  { version: 21, migrate: (db) => migrateV20ToV21(db) }
 ];
+function getTableColumnSet(db, tableName) {
+  const rows = db.prepare(`PRAGMA table_info(${tableName})`).all();
+  return new Set(rows.map((r) => r.name));
+}
 function migrateV1ToV2(db) {
   db.exec("BEGIN");
   try {
@@ -725,6 +882,249 @@ function migrateV3ToV4(db, machineId) {
     throw err;
   }
 }
+function migrateV17ToV18(db) {
+  db.exec("BEGIN");
+  try {
+    db.exec(CORTEX_INSTRUCTIONS_TABLE);
+    db.exec(
+      "CREATE INDEX IF NOT EXISTS idx_cortex_instructions_agent_id ON cortex_instructions (agent_id)"
+    );
+    db.prepare(
+      `INSERT INTO schema_version (version, applied_at)
+       VALUES (?, ?)
+       ON CONFLICT (version) DO NOTHING`
+    ).run(18, epochSeconds());
+    db.exec("COMMIT");
+  } catch (err) {
+    db.exec("ROLLBACK");
+    throw err;
+  }
+}
+function migrateV18ToV19(db) {
+  db.exec("BEGIN");
+  try {
+    db.prepare(
+      "DELETE FROM team_outbox WHERE table_name = ?"
+    ).run("cortex_instructions");
+    db.prepare(
+      `INSERT INTO schema_version (version, applied_at)
+       VALUES (?, ?)
+       ON CONFLICT (version) DO NOTHING`
+    ).run(19, epochSeconds());
+    db.exec("COMMIT");
+  } catch (err) {
+    db.exec("ROLLBACK");
+    throw err;
+  }
+}
+function migrateV12ToV13(db) {
+  const existing = getTableColumnSet(db, "agent_runs");
+  const columnAdds = [
+    ["runtime", "TEXT"],
+    ["provider", "TEXT"],
+    ["model", "TEXT"],
+    ["session_ref", "TEXT"],
+    ["resumable", "INTEGER DEFAULT 0"],
+    ["resume_status", "TEXT"],
+    ["resume_mode", "TEXT"],
+    ["resumed_at", "INTEGER"],
+    ["checkpoints", "TEXT"],
+    ["usage_data", "TEXT"]
+  ];
+  const pendingAdds = columnAdds.filter(([name]) => !existing.has(name));
+  db.exec("BEGIN");
+  try {
+    for (const [name, decl] of pendingAdds) {
+      db.exec(`ALTER TABLE agent_runs ADD COLUMN ${name} ${decl}`);
+    }
+    const newIndexes = [
+      `CREATE INDEX IF NOT EXISTS idx_agent_runs_task_status_started_at ON agent_runs (task, status, started_at)`,
+      `CREATE INDEX IF NOT EXISTS idx_agent_runs_resumable_task ON agent_runs (task, resumable, completed_at)`
+    ];
+    for (const idx of newIndexes) {
+      db.exec(idx);
+    }
+    db.prepare(
+      `INSERT INTO schema_version (version, applied_at)
+       VALUES (?, ?)
+       ON CONFLICT (version) DO NOTHING`
+    ).run(13, epochSeconds());
+    db.exec("COMMIT");
+  } catch (err) {
+    db.exec("ROLLBACK");
+    throw err;
+  }
+}
+function migrateV13ToV14(db) {
+  const existing = getTableColumnSet(db, "agent_runs");
+  const columnAdds = [
+    ["actual_cost_usd", "REAL"],
+    ["estimated_cost_usd", "REAL"],
+    ["cost_source", "TEXT"],
+    ["cost_data", "TEXT"]
+  ];
+  const pendingAdds = columnAdds.filter(([name]) => !existing.has(name));
+  db.exec("BEGIN");
+  try {
+    for (const [name, decl] of pendingAdds) {
+      db.exec(`ALTER TABLE agent_runs ADD COLUMN ${name} ${decl}`);
+    }
+    db.prepare(
+      `INSERT INTO schema_version (version, applied_at)
+       VALUES (?, ?)
+       ON CONFLICT (version) DO NOTHING`
+    ).run(14, epochSeconds());
+    db.exec("COMMIT");
+  } catch (err) {
+    db.exec("ROLLBACK");
+    throw err;
+  }
+}
+function resolveV20PlanIdentityCollisions(db) {
+  const dupes = db.prepare(
+    `SELECT logical_key_next, COUNT(*) AS n
+       FROM plans
+       WHERE logical_key_next <> ''
+       GROUP BY logical_key_next
+       HAVING n > 1`
+  ).all();
+  if (dupes.length > 0) {
+    const rowsForKey = db.prepare(
+      `SELECT id, session_id
+         FROM plans
+         WHERE logical_key_next = ?
+         ORDER BY created_at ASC, id ASC`
+    );
+    const updateStaging = db.prepare(
+      `UPDATE plans
+          SET logical_key_next = ?, id_next = ?
+        WHERE id = ?`
+    );
+    for (const dupe of dupes) {
+      const conflicting = rowsForKey.all(dupe.logical_key_next);
+      for (let i = 1; i < conflicting.length; i += 1) {
+        const row = conflicting[i];
+        const legacyKey = row.session_id ? `session:${row.session_id}:legacy:${row.id}` : `legacy:${row.id}`;
+        updateStaging.run(legacyKey, buildPlanId(legacyKey), row.id);
+      }
+    }
+  }
+  const remaining = db.prepare(
+    `SELECT id_next, GROUP_CONCAT(id, ',') AS ids
+       FROM plans
+       WHERE id_next IS NOT NULL
+       GROUP BY id_next
+       HAVING COUNT(*) > 1`
+  ).all();
+  if (remaining.length > 0) {
+    const detail = remaining.map((r) => `${r.id_next} <= [${r.ids}]`).join("; ");
+    throw new Error(
+      `v20 plan migration: plan id collisions after legacy fallback: ${detail}`
+    );
+  }
+}
+function migrateV19ToV20(db, machineId) {
+  db.exec("BEGIN");
+  try {
+    const planColumns = getTableColumnSet(db, "plans");
+    if (!planColumns.has("logical_key")) {
+      db.exec(`ALTER TABLE plans ADD COLUMN logical_key TEXT NOT NULL DEFAULT ''`);
+    }
+    if (!planColumns.has("id_next")) {
+      db.exec(`ALTER TABLE plans ADD COLUMN id_next TEXT`);
+    }
+    if (!planColumns.has("logical_key_next")) {
+      db.exec(`ALTER TABLE plans ADD COLUMN logical_key_next TEXT NOT NULL DEFAULT ''`);
+    }
+    const rows = db.prepare(
+      `SELECT *
+       FROM plans
+       ORDER BY created_at ASC, id ASC`
+    ).all();
+    const writeStaging = db.prepare(
+      `UPDATE plans
+          SET id_next = ?, logical_key_next = ?
+        WHERE id = ?`
+    );
+    for (const row of rows) {
+      const derivedLogicalKey = deriveStoredPlanLogicalKey(row);
+      writeStaging.run(buildPlanId(derivedLogicalKey), derivedLogicalKey, row.id);
+    }
+    resolveV20PlanIdentityCollisions(db);
+    const previousLogicalKeyByOldId = /* @__PURE__ */ new Map();
+    const previousIdNextByOldId = /* @__PURE__ */ new Map();
+    const staged = db.prepare(
+      `SELECT id, id_next, logical_key, logical_key_next FROM plans`
+    ).all();
+    for (const row of staged) {
+      previousLogicalKeyByOldId.set(row.id, row.logical_key ?? "");
+      if (row.id_next) previousIdNextByOldId.set(row.id, row.id_next);
+    }
+    db.prepare(
+      `UPDATE plans
+          SET embedded = CASE WHEN id = id_next THEN embedded ELSE 0 END,
+              synced_at = CASE WHEN id = id_next THEN synced_at ELSE NULL END
+        WHERE id_next IS NOT NULL`
+    ).run();
+    db.prepare(
+      `UPDATE plans
+          SET id = id_next,
+              logical_key = logical_key_next
+        WHERE id_next IS NOT NULL`
+    ).run();
+    const deleteOutboxEntries = db.prepare(
+      `DELETE FROM team_outbox
+       WHERE table_name = 'plans' AND row_id IN (?, ?)`
+    );
+    const enqueueOutbox = db.prepare(
+      `INSERT INTO team_outbox (table_name, row_id, operation, payload, machine_id, created_at)
+       VALUES ('plans', ?, ?, ?, ?, ?)`
+    );
+    const now = epochSeconds();
+    for (const row of rows) {
+      const nextId = previousIdNextByOldId.get(row.id) ?? row.id;
+      const fresh = db.prepare(`SELECT * FROM plans WHERE id = ?`).get(nextId);
+      const identityChanged = nextId !== row.id;
+      const previousLogicalKey = previousLogicalKeyByOldId.get(row.id) ?? "";
+      const currentLogicalKey = fresh?.logical_key ?? "";
+      const logicalKeyChanged = previousLogicalKey !== currentLogicalKey;
+      const needsResync = identityChanged || logicalKeyChanged;
+      if (!needsResync) continue;
+      deleteOutboxEntries.run(row.id, nextId);
+      if (identityChanged) {
+        enqueueOutbox.run(
+          row.id,
+          "delete",
+          JSON.stringify({ id: row.id }),
+          row.machine_id ?? machineId,
+          now
+        );
+      }
+      if (fresh) {
+        const { id_next: _idNext, logical_key_next: _lkNext, ...publishable } = fresh;
+        enqueueOutbox.run(
+          nextId,
+          "upsert",
+          JSON.stringify(publishable),
+          fresh.machine_id ?? machineId,
+          now
+        );
+      }
+    }
+    db.exec(`CREATE UNIQUE INDEX IF NOT EXISTS idx_plans_logical_key ON plans (logical_key)`);
+    db.exec(`ALTER TABLE plans DROP COLUMN id_next`);
+    db.exec(`ALTER TABLE plans DROP COLUMN logical_key_next`);
+    db.prepare(
+      `INSERT INTO schema_version (version, applied_at)
+       VALUES (?, ?)
+       ON CONFLICT (version) DO NOTHING`
+    ).run(20, epochSeconds());
+    db.exec("COMMIT");
+  } catch (err) {
+    db.exec("ROLLBACK");
+    throw err;
+  }
+}
 function migrateV4ToV5(db) {
   db.exec("BEGIN");
   try {
@@ -1008,9 +1408,114 @@ function migrateV11ToV12(db) {
     throw err;
   }
 }
+function migrateV15ToV16(db) {
+  const existing = getTableColumnSet(db, "agent_runs");
+  const columnAdds = [
+    ["reasoning_level", "TEXT"],
+    ["execution_overrides", "TEXT"]
+  ];
+  const pendingAdds = columnAdds.filter(([name]) => !existing.has(name));
+  db.exec("BEGIN");
+  try {
+    for (const [name, decl] of pendingAdds) {
+      db.exec(`ALTER TABLE agent_runs ADD COLUMN ${name} ${decl}`);
+    }
+    db.prepare(
+      `INSERT INTO schema_version (version, applied_at)
+       VALUES (?, ?)
+       ON CONFLICT (version) DO NOTHING`
+    ).run(16, epochSeconds());
+    db.exec("COMMIT");
+  } catch (err) {
+    db.exec("ROLLBACK");
+    throw err;
+  }
+}
+function migrateV16ToV17(db) {
+  db.exec("BEGIN");
+  try {
+    db.exec(
+      "CREATE INDEX IF NOT EXISTS idx_write_intents_run_id_tool ON agent_run_write_intents (run_id, tool_name)"
+    );
+    db.prepare(
+      `INSERT INTO schema_version (version, applied_at)
+       VALUES (?, ?)
+       ON CONFLICT (version) DO NOTHING`
+    ).run(17, epochSeconds());
+    db.exec("COMMIT");
+  } catch (err) {
+    db.exec("ROLLBACK");
+    throw err;
+  }
+}
+function migrateV14ToV15(db) {
+  const existing = getTableColumnSet(db, "agent_runs");
+  const columnAdds = [
+    ["dry_run", "INTEGER NOT NULL DEFAULT 0"],
+    ["evaluation_id", "TEXT"]
+  ];
+  const pendingAdds = columnAdds.filter(([name]) => !existing.has(name));
+  db.exec("BEGIN");
+  try {
+    db.exec(AGENT_RUN_WRITE_INTENTS_TABLE);
+    db.exec(DIGEST_EXTRACT_REVISIONS_TABLE);
+    db.exec(AGENT_RUN_EVALUATIONS_TABLE);
+    for (const [name, decl] of pendingAdds) {
+      db.exec(`ALTER TABLE agent_runs ADD COLUMN ${name} ${decl}`);
+    }
+    const newIndexes = [
+      "CREATE INDEX IF NOT EXISTS idx_write_intents_run_id ON agent_run_write_intents (run_id)",
+      "CREATE INDEX IF NOT EXISTS idx_digest_revisions_agent_tier ON digest_extract_revisions (agent_id, tier, created_at DESC)",
+      "CREATE INDEX IF NOT EXISTS idx_agent_runs_evaluation_id ON agent_runs (evaluation_id)"
+    ];
+    for (const idx of newIndexes) {
+      db.exec(idx);
+    }
+    db.prepare(
+      `INSERT INTO schema_version (version, applied_at)
+       VALUES (?, ?)
+       ON CONFLICT (version) DO NOTHING`
+    ).run(15, epochSeconds());
+    db.exec("COMMIT");
+  } catch (err) {
+    db.exec("ROLLBACK");
+    throw err;
+  }
+}
+function migrateV20ToV21(db) {
+  db.prepare("BEGIN").run();
+  try {
+    if (tableExists(db, "graph_edges")) {
+      db.prepare(
+        `DELETE FROM graph_edges WHERE type IN ('REFERENCES', 'AFFECTS', 'DEPENDS_ON', 'RELATES_TO')`
+      ).run();
+    }
+    if (tableExists(db, "entity_mentions")) {
+      db.prepare(`DELETE FROM entity_mentions`).run();
+    }
+    if (tableExists(db, "entities")) {
+      db.prepare(`DELETE FROM entities`).run();
+    }
+    db.prepare(
+      `INSERT INTO schema_version (version, applied_at)
+       VALUES (?, ?)
+       ON CONFLICT (version) DO NOTHING`
+    ).run(21, epochSeconds());
+    db.prepare("COMMIT").run();
+  } catch (err) {
+    db.prepare("ROLLBACK").run();
+    throw err;
+  }
+}
+function tableExists(db, name) {
+  const row = db.prepare(
+    `SELECT count(*) AS c FROM sqlite_master WHERE type = 'table' AND name = ?`
+  ).get(name);
+  return row.c > 0;
+}
 
 // src/db/schema.ts
-var SCHEMA_VERSION = 12;
+var SCHEMA_VERSION = 21;
 var EMBEDDING_DIMENSIONS = 1024;
 function getCurrentVersion(db) {
   const row = db.prepare(
@@ -1018,18 +1523,29 @@ function getCurrentVersion(db) {
   ).get();
   return row?.version ?? 0;
 }
+function hasSchemaVersionTable(db) {
+  const row = db.prepare(
+    `SELECT 1 AS present FROM sqlite_master
+       WHERE type = 'table' AND name = 'schema_version'
+       LIMIT 1`
+  ).get();
+  return row?.present === 1;
+}
 function createSchema(db, machineId = DEFAULT_MACHINE_ID) {
-  try {
+  if (hasSchemaVersionTable(db)) {
     const currentVersion = getCurrentVersion(db);
-    if (currentVersion === SCHEMA_VERSION) return;
+    if (currentVersion === SCHEMA_VERSION) {
+      reapplyCurrentSchemaDdl(db);
+      return;
+    }
     for (const migration of MIGRATIONS) {
       const version = getCurrentVersion(db);
       if (version < migration.version) {
         migration.migrate(db, machineId);
       }
     }
+    reapplyCurrentSchemaDdl(db);
     return;
-  } catch {
   }
   for (const ddl of TABLE_DDLS) {
     db.exec(ddl);
@@ -1046,13 +1562,53 @@ function createSchema(db, machineId = DEFAULT_MACHINE_ID) {
      ON CONFLICT (version) DO NOTHING`
   ).run(SCHEMA_VERSION, epochSeconds());
 }
+var FTS_TRIGGER_GROUPS = [
+  { ftsTable: "log_entries_fts", baseTable: "log_entries", triggers: ["log_entries_ai", "log_entries_ad"] },
+  { ftsTable: "prompt_batches_fts", baseTable: "prompt_batches", triggers: ["prompt_batches_fts_ai", "prompt_batches_fts_au", "prompt_batches_fts_ad"] },
+  { ftsTable: "activities_fts", baseTable: "activities", triggers: ["activities_fts_ai", "activities_fts_au", "activities_fts_ad"] },
+  { ftsTable: "spores_fts", baseTable: "spores", triggers: ["spores_fts_ai", "spores_fts_au", "spores_fts_ad"] },
+  { ftsTable: "sessions_fts", baseTable: "sessions", triggers: ["sessions_fts_ai", "sessions_fts_au", "sessions_fts_ad"] }
+];
+function reapplyCurrentSchemaDdl(db) {
+  const triggersBefore = new Set(
+    db.prepare("SELECT name FROM sqlite_master WHERE type = 'trigger'").all().map((row) => row.name)
+  );
+  for (const ddl of TABLE_DDLS) {
+    db.exec(ddl);
+  }
+  for (const ddl of FTS_TABLES) {
+    db.exec(ddl);
+  }
+  for (const idx of SECONDARY_INDEXES) {
+    db.exec(idx);
+  }
+  let rebuiltAny = false;
+  for (const group of FTS_TRIGGER_GROUPS) {
+    const wasMissing = group.triggers.some((name) => !triggersBefore.has(name));
+    if (!wasMissing) continue;
+    const baseCount = db.prepare(`SELECT COUNT(*) AS n FROM ${group.baseTable}`).get().n;
+    if (baseCount === 0) continue;
+    db.prepare(`INSERT INTO ${group.ftsTable}(${group.ftsTable}) VALUES('rebuild')`).run();
+    rebuiltAny = true;
+  }
+  if (rebuiltAny) {
+    process.stderr.write("[schema] Rebuilt one or more FTS indexes after detecting missing sync triggers\n");
+  }
+}
 
 export {
   CANDIDATE_STATUS,
   AGENT_SETTABLE_STATUSES,
   REST_SETTABLE_STATUSES,
+  TRANSCRIPT_SOURCE_PREFIX,
+  normalizePlanSourcePath,
+  buildPathPlanLogicalKey,
+  buildSessionTagPlanLogicalKey,
+  buildSessionPlanLogicalKey,
+  buildPlanId,
+  humanizePlanToken,
   SCHEMA_VERSION,
   EMBEDDING_DIMENSIONS,
   createSchema
 };
-//# sourceMappingURL=chunk-MYOZLMB2.js.map
+//# sourceMappingURL=chunk-DTWUHHFI.js.map