@open-code-review/cli 2.0.0 → 2.2.0

package/dist/index.js

@@ -39,6 +39,30 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
+// src/lib/runtime-checks.ts
+function isSupportedNode(version) {
+  const [major = 0, minor = 0] = version.split(".").map((n) => Number.parseInt(n, 10) || 0);
+  return major > NODE_FLOOR.major || major === NODE_FLOOR.major && minor >= NODE_FLOOR.minor;
+}
+function nodeVersionGuardMessage(version) {
+  return `
+Open Code Review requires Node.js >= ${NODE_FLOOR.major}.${NODE_FLOOR.minor} (it uses Node's built-in SQLite, \`node:sqlite\`).
+You have Node ${version}. Upgrade Node (e.g. \`nvm install 22 && nvm use 22\`) and re-run.
+
+`;
+}
+function isSuppressibleSqliteWarning(warning) {
+  const message = typeof warning === "string" ? warning : warning?.message;
+  return typeof message === "string" && message.includes("SQLite is an experimental feature");
+}
+var NODE_FLOOR;
+var init_runtime_checks = __esm({
+  "src/lib/runtime-checks.ts"() {
+    "use strict";
+    NODE_FLOOR = { major: 22, minor: 5 };
+  }
+});
+
 // ../../node_modules/.pnpm/commander@13.1.0/node_modules/commander/lib/error.js
 var require_error = __commonJS({
   "../../node_modules/.pnpm/commander@13.1.0/node_modules/commander/lib/error.js"(exports) {
@@ -15993,6 +16017,80 @@ var require_emoji_regex2 = __commonJS({
   }
 });
 
+// ../shared/platform/src/index.ts
+import { pathToFileURL } from "node:url";
+import {
+  execFile,
+  execFileSync,
+  spawn as spawn2
+} from "node:child_process";
+import { promisify } from "node:util";
+async function importModule(absolutePath) {
+  return import(pathToFileURL(absolutePath).href);
+}
+function execBinary(binary, args, opts) {
+  return execFileSync(binary, args, {
+    ...opts,
+    shell: isWindows
+  });
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return !(err instanceof Error && "code" in err && err.code === "ESRCH");
+  }
+}
+function defaultIconFor(id, tier) {
+  return BUILTIN_ICON_MAP[id] ?? (tier === "persona" ? "brain" : "user");
+}
+function hostCapabilitiesFor(vendor) {
+  return vendor && HOST_CAPABILITIES[vendor] || DEFAULT_HOST_CAPABILITIES;
+}
+var execFilePromise, isWindows, BUILTIN_ICON_MAP, DEFAULT_HOST_CAPABILITIES, HOST_CAPABILITIES;
+var init_src = __esm({
+  "../shared/platform/src/index.ts"() {
+    "use strict";
+    execFilePromise = promisify(execFile);
+    isWindows = process.platform === "win32";
+    BUILTIN_ICON_MAP = {
+      architect: "blocks",
+      fullstack: "layers",
+      reliability: "activity",
+      "staff-engineer": "compass",
+      principal: "crown",
+      frontend: "layout",
+      backend: "server",
+      infrastructure: "cloud",
+      performance: "gauge",
+      accessibility: "accessibility",
+      data: "database",
+      devops: "rocket",
+      dx: "terminal",
+      mobile: "smartphone",
+      security: "shield-alert",
+      quality: "sparkles",
+      testing: "test-tubes",
+      ai: "bot",
+      "docs-writer": "file-text"
+    };
+    DEFAULT_HOST_CAPABILITIES = {
+      subagentSpawn: false,
+      perTaskModel: false
+    };
+    HOST_CAPABILITIES = {
+      // Claude Code: Task tool + per-subagent model frontmatter.
+      claude: { subagentSpawn: true, perTaskModel: true },
+      // OpenCode: `--agent` sub-agent primitive, but no per-task model override.
+      opencode: { subagentSpawn: true, perTaskModel: false },
+      // Gemini CLI / Codex: no in-agent Task primitive → sequential Phase 4.
+      gemini: { subagentSpawn: false, perTaskModel: false },
+      codex: { subagentSpawn: false, perTaskModel: false }
+    };
+  }
+});
+
 // ../../node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/nodes/identity.js
 var require_identity = __commonJS({
   "../../node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/nodes/identity.js"(exports) {
@@ -23320,21 +23418,41 @@ var init_result_mapper = __esm({
 });
 
 // src/lib/db/engine.ts
-import BetterSqlite3 from "better-sqlite3";
-function isBusyError(e) {
-  if (e instanceof BetterSqlite3.SqliteError) {
-    return e.code === "SQLITE_BUSY" || e.code === "SQLITE_BUSY_SNAPSHOT";
+import { createRequire as createRequire2 } from "node:module";
+function applyEnginePreconditions() {
+  if (_preconditionsApplied) return;
+  _preconditionsApplied = true;
+  const originalEmitWarning = process.emitWarning.bind(process);
+  process.emitWarning = (warning, ...args) => {
+    if (isSuppressibleSqliteWarning(warning)) return;
+    originalEmitWarning(warning, ...args);
+  };
+}
+function newDatabase(path2) {
+  if (!_DatabaseSyncCtor) {
+    applyEnginePreconditions();
+    try {
+      _DatabaseSyncCtor = nodeRequire("node:sqlite").DatabaseSync;
+    } catch (e) {
+      if (!isSupportedNode(process.versions.node)) {
+        throw new Error(nodeVersionGuardMessage(process.versions.node).trim());
+      }
+      throw e;
+    }
   }
-  const code = e?.code;
-  return code === "SQLITE_BUSY" || code === "SQLITE_BUSY_SNAPSHOT";
+  return new _DatabaseSyncCtor(path2);
+}
+function isBusyError(e) {
+  const errcode = e?.errcode;
+  return errcode === SQLITE_BUSY || errcode === SQLITE_BUSY_SNAPSHOT;
 }
 function sleepSync(ms) {
-  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+  Atomics.wait(SLEEP_BUF, 0, 0, ms);
 }
 function probeEngine() {
   try {
-    const db = new BetterSqlite3(":memory:");
-    db.pragma("journal_mode = WAL");
+    const db = newDatabase(":memory:");
+    db.exec("PRAGMA journal_mode = WAL");
     db.exec("CREATE TABLE _probe(x); INSERT INTO _probe VALUES (1);");
     const row = db.prepare("SELECT sqlite_version() AS v").get();
     db.close();
@@ -23344,33 +23462,47 @@ function probeEngine() {
   }
 }
 function openEngine(dbPath) {
-  const native = new BetterSqlite3(dbPath);
-  native.pragma("journal_mode = WAL");
-  native.pragma("foreign_keys = ON");
-  native.pragma("busy_timeout = 5000");
-  native.pragma("synchronous = NORMAL");
-  return new BetterSqliteAdapter(native);
-}
-var BUSY_RETRY_ATTEMPTS, BUSY_RETRY_BACKOFF_MS, BetterSqliteAdapter;
+  const native = newDatabase(dbPath);
+  native.exec("PRAGMA journal_mode = WAL");
+  native.exec("PRAGMA foreign_keys = ON");
+  native.exec("PRAGMA busy_timeout = 5000");
+  native.exec("PRAGMA synchronous = NORMAL");
+  return new NodeSqliteAdapter(native);
+}
+var SQLITE_BUSY, SQLITE_BUSY_SNAPSHOT, BUSY_RETRY_ATTEMPTS, BUSY_RETRY_BACKOFF_MS, savepointName, nodeRequire, _preconditionsApplied, _DatabaseSyncCtor, SLEEP_BUF, NodeSqliteAdapter;
 var init_engine = __esm({
   "src/lib/db/engine.ts"() {
     "use strict";
+    init_runtime_checks();
+    SQLITE_BUSY = 5;
+    SQLITE_BUSY_SNAPSHOT = 261;
     BUSY_RETRY_ATTEMPTS = 5;
     BUSY_RETRY_BACKOFF_MS = 50;
-    BetterSqliteAdapter = class {
+    savepointName = (depth) => `ocr_sp_${depth}`;
+    nodeRequire = createRequire2(import.meta.url);
+    _preconditionsApplied = false;
+    SLEEP_BUF = new Int32Array(new SharedArrayBuffer(4));
+    NodeSqliteAdapter = class {
       raw;
+      /**
+       * Transaction nesting depth. `node:sqlite` has no transaction helper, so we
+       * drive `BEGIN IMMEDIATE` ourselves and use SAVEPOINTs for nested calls
+       * (better-sqlite3 did this automatically). 0 = no transaction open.
+       */
+      txnDepth = 0;
       constructor(db) {
         this.raw = db;
       }
       exec(sql, params) {
         const stmt = this.raw.prepare(sql);
-        if (!stmt.reader) {
+        const cols = stmt.columns();
+        if (cols.length === 0) {
           stmt.run(...params ?? []);
           return [];
         }
-        const columns = stmt.columns().map((c) => c.name);
-        const values = stmt.raw().all(...params ?? []);
-        return values.length > 0 ? [{ columns, values }] : [];
+        stmt.setReturnArrays(true);
+        const values = stmt.all(...params ?? []);
+        return values.length > 0 ? [{ columns: cols.map((c) => c.name), values }] : [];
       }
       run(sql, params) {
         if (params !== void 0) {
@@ -23383,25 +23515,84 @@ var init_engine = __esm({
         return this.raw.prepare(sql);
       }
       transaction(fn) {
-        const tx = this.raw.transaction(fn);
-        for (let attempt = 0; ; attempt++) {
+        return this.txnDepth > 0 ? this.runNested(fn) : this.runOuter(fn);
+      }
+      /**
+       * Nested call: a SAVEPOINT within the outer transaction's write lock. No
+       * busy-retry — the outer transaction already holds the lock. The savepoint
+       * lets the inner block roll back independently while the outer continues.
+       */
+      runNested(fn) {
+        const name = savepointName(this.txnDepth);
+        this.raw.exec(`SAVEPOINT ${name}`);
+        this.txnDepth++;
+        try {
+          const result = fn();
+          this.raw.exec(`RELEASE ${name}`);
+          return result;
+        } catch (e) {
           try {
-            return tx.immediate();
+            this.raw.exec(`ROLLBACK TO ${name}`);
+            this.raw.exec(`RELEASE ${name}`);
+          } catch {
+          }
+          throw e;
+        } finally {
+          this.txnDepth--;
+        }
+      }
+      /**
+       * Outer transaction: `BEGIN IMMEDIATE` acquires the write lock up front so
+       * cross-process writers serialize cleanly under WAL instead of failing late
+       * on upgrade. `busy_timeout` covers most contention; a bounded synchronous
+       * retry absorbs the residual SQLITE_BUSY (another connection holds the lock
+       * past the timeout, or BUSY_SNAPSHOT). Non-busy errors and the final attempt
+       * re-throw so genuine failures propagate.
+       */
+      runOuter(fn) {
+        for (let attempt = 0; attempt < BUSY_RETRY_ATTEMPTS; attempt++) {
+          try {
+            return this.runOnce(fn);
           } catch (e) {
-            if (!isBusyError(e) || attempt >= BUSY_RETRY_ATTEMPTS - 1) throw e;
+            if (!isBusyError(e) || attempt === BUSY_RETRY_ATTEMPTS - 1) throw e;
             sleepSync(BUSY_RETRY_BACKOFF_MS);
           }
         }
+        throw new Error("transaction retry budget exhausted");
+      }
+      /** One `BEGIN IMMEDIATE` / `COMMIT` / `ROLLBACK` lifecycle. */
+      runOnce(fn) {
+        this.raw.exec("BEGIN IMMEDIATE");
+        this.txnDepth = 1;
+        try {
+          const result = fn();
+          this.raw.exec("COMMIT");
+          return result;
+        } catch (e) {
+          try {
+            this.raw.exec("ROLLBACK");
+          } catch {
+          }
+          throw e;
+        } finally {
+          this.txnDepth = 0;
+        }
       }
       pragma(source) {
-        return this.raw.pragma(source);
+        this.raw.exec(`PRAGMA ${source}`);
+        return void 0;
       }
       close() {
         try {
-          this.raw.pragma("wal_checkpoint(TRUNCATE)");
+          this.raw.exec("PRAGMA wal_checkpoint(TRUNCATE)");
         } catch {
         }
-        this.raw.close();
+        try {
+          this.raw.close();
+        } catch (e) {
+          const message = e?.message ?? "";
+          if (!/database is not open/i.test(message)) throw e;
+        }
       }
     };
   }
@@ -23927,6 +24118,35 @@ var init_migrations = __esm({
           db.run("DROP INDEX IF EXISTS idx_command_executions_parent;");
           db.run("ALTER TABLE command_executions DROP COLUMN parent_id;");
         }
+      },
+      {
+        version: 14,
+        description: "Self-heal markdown_artifacts duplication: collapse NULL-round duplicate rows and add a NULL-safe unique index so the dedup bug cannot recur",
+        // The table's `UNIQUE(session_id, artifact_type, round_number, file_path)`
+        // never deduped session-level artifacts because SQLite treats NULL ≠ NULL,
+        // and the writer used `INSERT OR REPLACE` — so every re-parse of a
+        // NULL-round artifact (context.md, map.md, …) appended a duplicate (one
+        // context.md reached 775 identical rows, ~177 MB). The writer is now an
+        // explicit UPDATE-or-INSERT; this migration heals existing DBs and adds a
+        // NULL-collapsing unique index as a DB-level backstop.
+        //
+        // Orphan-row sweep (FK-dangling children from the pre-FK-enforcement era)
+        // is intentionally NOT done here — it needs `PRAGMA foreign_keys = OFF`,
+        // which is a no-op inside the migration transaction. `ocr db doctor --fix`
+        // performs it outside a transaction.
+        run: (db) => {
+          db.run(`
+        DELETE FROM markdown_artifacts
+        WHERE rowid NOT IN (
+          SELECT MAX(rowid) FROM markdown_artifacts
+          GROUP BY session_id, artifact_type, IFNULL(round_number, -1), file_path
+        )
+      `);
+          db.run(`
+        CREATE UNIQUE INDEX IF NOT EXISTS idx_markdown_artifacts_logical
+        ON markdown_artifacts(session_id, artifact_type, IFNULL(round_number, -1), file_path)
+      `);
+        }
       }
     ];
   }
@@ -24055,7 +24275,7 @@ var init_queries = __esm({
 
 // src/lib/db/reconcile.ts
 import { existsSync as existsSync10 } from "node:fs";
-import { isAbsolute as isAbsolute2, join as join12, dirname as dirname4 } from "node:path";
+import { isAbsolute as isAbsolute2, join as join12, dirname as dirname5 } from "node:path";
 function hasTerminalArtifactEvent(db, sessionId, workflowType, currentRound, currentMapRun) {
   const eventType = workflowType === "map" ? "map_completed" : "round_completed";
   const round = workflowType === "map" ? currentMapRun : currentRound;
@@ -24096,7 +24316,7 @@ function hasInFlightDependents(db, sessionId) {
 function resolveSessionDir(ocrDir, sessionDir) {
   if (!sessionDir) return null;
   if (isAbsolute2(sessionDir)) return sessionDir;
-  return join12(dirname4(ocrDir), sessionDir);
+  return join12(dirname5(ocrDir), sessionDir);
 }
 function reconcileLegacyState(db, ocrDir, opts = {}) {
   const dryRun = opts.dryRun ?? false;
@@ -24214,7 +24434,7 @@ var init_liveness = __esm({
 });
 
 // src/lib/state/exit-codes.ts
-var STATE_EXIT, StateError, CANCELLED_EXIT_CODE, ORPHAN_EXIT_CODE, CASCADE_CLOSE_EXIT_CODE;
+var STATE_EXIT, StateError, CANCELLED_EXIT_CODE, ORPHAN_EXIT_CODE, CASCADE_CLOSE_EXIT_CODE, WATCHDOG_DEADLINE_EXIT_CODE;
 var init_exit_codes = __esm({
   "src/lib/state/exit-codes.ts"() {
     "use strict";
@@ -24239,6 +24459,7 @@ var init_exit_codes = __esm({
     CANCELLED_EXIT_CODE = -2;
     ORPHAN_EXIT_CODE = -3;
     CASCADE_CLOSE_EXIT_CODE = -4;
+    WATCHDOG_DEADLINE_EXIT_CODE = -5;
   }
 });
 
@@ -24621,24 +24842,431 @@ var init_agent_sessions = __esm({
   }
 });
 
+// src/lib/db/maintenance.ts
+import {
+  existsSync as existsSync11,
+  readdirSync as readdirSync5,
+  statSync,
+  unlinkSync as unlinkSync3,
+  copyFileSync
+} from "node:fs";
+import { dirname as dirname6, join as join13, basename as basename7 } from "node:path";
+function withForeignKeysDisabled(db, fn) {
+  db.pragma("foreign_keys = OFF");
+  try {
+    return fn();
+  } finally {
+    db.pragma("foreign_keys = ON");
+  }
+}
+function scalarInt(db, sql) {
+  const r = db.exec(sql);
+  const v = r[0]?.values[0]?.[0];
+  return typeof v === "number" ? v : Number(v ?? 0);
+}
+function foreignKeyViolationGroups(db) {
+  const r = db.exec("PRAGMA foreign_key_check");
+  const rows = r[0]?.values ?? [];
+  const counts = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const table = String(row[0]);
+    counts.set(table, (counts.get(table) ?? 0) + 1);
+  }
+  return [...counts.entries()].map(([table, count]) => ({ table, count })).sort((a, b) => b.count - a.count);
+}
+function scanOrphanTempFiles(dataDir) {
+  let entries;
+  try {
+    entries = readdirSync5(dataDir);
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const name of entries) {
+    const m = name.match(/^ocr\.db\.(\d+)\.tmp$/);
+    if (!m) continue;
+    const pid = Number(m[1]);
+    let ageMs = 0;
+    try {
+      ageMs = Date.now() - statSync(join13(dataDir, name)).mtimeMs;
+    } catch {
+      continue;
+    }
+    const alive = isProcessAlive(pid);
+    out.push({
+      name,
+      pid,
+      ageMs,
+      // Reapable only when the writer PID is dead AND the file is old enough
+      // that no live mid-write could plausibly own it.
+      reapable: !alive && ageMs > ONE_HOUR_MS
+    });
+  }
+  return out;
+}
+function scanBackupFiles(dataDir, dbBase) {
+  let entries;
+  try {
+    entries = readdirSync5(dataDir);
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const name of entries) {
+    if (!name.startsWith(`${dbBase}.bak`)) continue;
+    try {
+      out.push({ name, sizeBytes: statSync(join13(dataDir, name)).size });
+    } catch {
+    }
+  }
+  return out.sort((a, b) => b.sizeBytes - a.sizeBytes);
+}
+function collectDbHealth(db, dbPath) {
+  const dataDir = dirname6(dbPath);
+  const dbBase = basename7(dbPath);
+  const pageSize = scalarInt(db, "PRAGMA page_size");
+  const pageCount = scalarInt(db, "PRAGMA page_count");
+  const freelistCount = scalarInt(db, "PRAGMA freelist_count");
+  const integ = db.exec("PRAGMA integrity_check");
+  const integRows = (integ[0]?.values ?? []).map((v) => String(v[0]));
+  const integrityOk = integRows.length === 1 && integRows[0] === "ok";
+  const allGroups = foreignKeyViolationGroups(db);
+  const fkViolations = allGroups.filter((g) => !PROTECTED_TABLES.has(g.table));
+  const protectedFkViolations = allGroups.filter(
+    (g) => PROTECTED_TABLES.has(g.table)
+  );
+  const fileSizeBytes = existsSync11(dbPath) ? statSync(dbPath).size : 0;
+  return {
+    dbPath,
+    fileSizeBytes,
+    pageSize,
+    pageCount,
+    freelistCount,
+    reclaimableBytes: freelistCount * pageSize,
+    integrityOk,
+    integrityErrors: integrityOk ? [] : integRows,
+    fkViolations,
+    protectedFkViolations,
+    totalFkViolations: allGroups.reduce((n, g) => n + g.count, 0),
+    markdownDuplicateRows: scalarInt(
+      db,
+      `SELECT COALESCE(SUM(cnt - 1), 0) FROM (
+         SELECT COUNT(*) AS cnt FROM markdown_artifacts
+          GROUP BY session_id, artifact_type, IFNULL(round_number, -1), file_path
+         HAVING cnt > 1)`
+    ),
+    orphanTempFiles: scanOrphanTempFiles(dataDir),
+    backupFiles: scanBackupFiles(dataDir, dbBase),
+    eventCount: scalarInt(db, "SELECT COUNT(*) FROM orchestration_events"),
+    sessionCount: scalarInt(db, "SELECT COUNT(*) FROM sessions")
+  };
+}
+function snapshotDb(db, dbPath, label = "doctor") {
+  try {
+    if (!existsSync11(dbPath) || statSync(dbPath).size === 0) return null;
+    db.pragma("wal_checkpoint(TRUNCATE)");
+    const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+    const bakPath = `${dbPath}.bak.${label}.${ts}`;
+    copyFileSync(dbPath, bakPath);
+    return bakPath;
+  } catch {
+    return null;
+  }
+}
+function reapOrphanDbFiles(dataDir) {
+  const reaped = [];
+  for (const f of scanOrphanTempFiles(dataDir)) {
+    if (!f.reapable) continue;
+    try {
+      unlinkSync3(join13(dataDir, f.name));
+      reaped.push(f.name);
+    } catch {
+    }
+  }
+  return reaped;
+}
+function reapStaleExecLogs(execLogsDir, maxAgeMs = SEVEN_DAYS_MS) {
+  let entries;
+  try {
+    entries = readdirSync5(execLogsDir);
+  } catch {
+    return [];
+  }
+  const cutoff = Date.now() - maxAgeMs;
+  const reaped = [];
+  for (const name of entries) {
+    if (!name.endsWith(".log")) continue;
+    const full = join13(execLogsDir, name);
+    try {
+      if (statSync(full).mtimeMs > cutoff) continue;
+      unlinkSync3(full);
+      reaped.push(name);
+    } catch {
+    }
+  }
+  return reaped;
+}
+function pruneBackups(dataDir, dbPath, opts = {}) {
+  const keep = opts.keep ?? 1;
+  if (!Number.isInteger(keep) || keep < 0) {
+    throw new Error(
+      `pruneBackups: keep must be a non-negative integer (got ${String(keep)})`
+    );
+  }
+  const dryRun = opts.dryRun ?? false;
+  const dbBase = basename7(dbPath);
+  const withMtime = [];
+  for (const file of scanBackupFiles(dataDir, dbBase)) {
+    try {
+      withMtime.push({ file, mtimeMs: statSync(join13(dataDir, file.name)).mtimeMs });
+    } catch {
+    }
+  }
+  withMtime.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  const kept = withMtime.slice(0, keep).map((x) => x.file);
+  const toDelete = withMtime.slice(keep).map((x) => x.file);
+  const deleted = [];
+  if (!dryRun) {
+    for (const b of toDelete) {
+      try {
+        unlinkSync3(join13(dataDir, b.name));
+        deleted.push(b);
+      } catch {
+      }
+    }
+  }
+  const reported = dryRun ? toDelete : deleted;
+  return {
+    dryRun,
+    deleted: reported,
+    kept,
+    reclaimedBytes: reported.reduce((n, b) => n + b.sizeBytes, 0)
+  };
+}
+function fixDb(db, dbPath, opts = {}) {
+  const dataDir = dirname6(dbPath);
+  const sizeBeforeBytes = existsSync11(dbPath) ? statSync(dbPath).size : 0;
+  const snapshotPath = opts.snapshot === false ? null : snapshotDb(db, dbPath, "doctor");
+  const fkOrphansDeleted = [];
+  withForeignKeysDisabled(db, () => {
+    db.transaction(() => {
+      for (const sweep of ORPHAN_SWEEPS) {
+        const info = db.prepare(sweep.sql).run();
+        const count = Number(info.changes);
+        if (count > 0) fkOrphansDeleted.push({ table: sweep.table, count });
+      }
+    });
+  });
+  let markdownDupsDeleted = 0;
+  db.transaction(() => {
+    const info = db.prepare(MARKDOWN_DEDUP_SQL).run();
+    markdownDupsDeleted = Number(info.changes);
+  });
+  const tempsReaped = opts.reapTemps === false ? [] : reapOrphanDbFiles(dataDir);
+  let vacuumed = false;
+  if (opts.vacuum !== false) {
+    try {
+      db.pragma("wal_checkpoint(TRUNCATE)");
+      db.run("VACUUM");
+      vacuumed = true;
+    } catch {
+      vacuumed = false;
+    }
+  }
+  const post = collectDbHealth(db, dbPath);
+  return {
+    snapshotPath,
+    fkOrphansDeleted,
+    totalFkOrphansDeleted: fkOrphansDeleted.reduce((n, g) => n + g.count, 0),
+    protectedViolationsRemaining: post.protectedFkViolations,
+    markdownDupsDeleted,
+    tempsReaped,
+    vacuumed,
+    sizeBeforeBytes,
+    sizeAfterBytes: post.fileSizeBytes,
+    integrityOkAfter: post.integrityOk,
+    fkViolationsAfter: post.totalFkViolations
+  };
+}
+function vacuumDb(db, dbPath, opts = {}) {
+  const sizeBeforeBytes = existsSync11(dbPath) ? statSync(dbPath).size : 0;
+  const snapshotPath = opts.snapshot === false ? null : snapshotDb(db, dbPath, "vacuum");
+  db.pragma("wal_checkpoint(TRUNCATE)");
+  db.run("VACUUM");
+  db.pragma("wal_checkpoint(TRUNCATE)");
+  const sizeAfterBytes = existsSync11(dbPath) ? statSync(dbPath).size : 0;
+  return {
+    snapshotPath,
+    sizeBeforeBytes,
+    sizeAfterBytes,
+    reclaimedBytes: Math.max(0, sizeBeforeBytes - sizeAfterBytes)
+  };
+}
+function countSessionArtifacts(db, sessionId) {
+  const r = db.exec(
+    `SELECT
+       (SELECT COUNT(*) FROM markdown_artifacts WHERE session_id = ?) +
+       (SELECT COUNT(*) FROM review_rounds      WHERE session_id = ?) +
+       (SELECT COUNT(*) FROM reviewer_outputs ro JOIN review_rounds rr ON ro.round_id = rr.id WHERE rr.session_id = ?) +
+       (SELECT COUNT(*) FROM review_findings rf JOIN reviewer_outputs ro ON rf.reviewer_output_id = ro.id JOIN review_rounds rr ON ro.round_id = rr.id WHERE rr.session_id = ?) +
+       (SELECT COUNT(*) FROM map_runs           WHERE session_id = ?) +
+       (SELECT COUNT(*) FROM chat_conversations WHERE session_id = ?)`,
+    Array(6).fill(sessionId)
+  );
+  const v = r[0]?.values[0]?.[0];
+  return typeof v === "number" ? v : Number(v ?? 0);
+}
+function pruneDb(db, dbPath, opts = {}) {
+  const dryRun = opts.dryRun ?? false;
+  const hasBound = opts.olderThanDays !== void 0 || opts.keepSessions !== void 0;
+  if (!hasBound) {
+    return { dryRun, snapshotPath: null, prunedSessions: [], totalArtifactRows: 0 };
+  }
+  const rows = db.exec(
+    `SELECT s.id,
+            (SELECT (julianday('now') - julianday(MAX(e.created_at))) * 86400
+               FROM orchestration_events e WHERE e.session_id = s.id) AS quiet_seconds
+       FROM sessions s
+      WHERE s.status = 'closed'
+      ORDER BY quiet_seconds ASC`
+  );
+  const closed = (rows[0]?.values ?? []).map((v) => ({
+    id: String(v[0]),
+    quietSeconds: typeof v[1] === "number" ? v[1] : Number(v[1] ?? 0)
+  }));
+  const keepN = opts.keepSessions ?? 0;
+  const olderThanSeconds = opts.olderThanDays !== void 0 ? opts.olderThanDays * 86400 : null;
+  const targets = closed.filter((s, idx) => {
+    if (idx < keepN) return false;
+    if (olderThanSeconds !== null && s.quietSeconds < olderThanSeconds)
+      return false;
+    return true;
+  });
+  const prunedSessions = [];
+  for (const t of targets) {
+    const artifactRows = countSessionArtifacts(db, t.id);
+    if (artifactRows === 0) continue;
+    prunedSessions.push({ sessionId: t.id, artifactRows });
+  }
+  if (dryRun || prunedSessions.length === 0) {
+    return {
+      dryRun,
+      snapshotPath: null,
+      prunedSessions,
+      totalArtifactRows: prunedSessions.reduce((n, p) => n + p.artifactRows, 0)
+    };
+  }
+  const snapshotPath = snapshotDb(db, dbPath, "prune");
+  db.transaction(() => {
+    for (const p of prunedSessions) {
+      db.run("DELETE FROM review_rounds WHERE session_id = ?", [p.sessionId]);
+      db.run("DELETE FROM map_runs WHERE session_id = ?", [p.sessionId]);
+      db.run("DELETE FROM markdown_artifacts WHERE session_id = ?", [p.sessionId]);
+      db.run("DELETE FROM chat_conversations WHERE session_id = ?", [p.sessionId]);
+    }
+  });
+  return {
+    dryRun,
+    snapshotPath,
+    prunedSessions,
+    totalArtifactRows: prunedSessions.reduce((n, p) => n + p.artifactRows, 0)
+  };
+}
+var PROTECTED_TABLES, ORPHAN_SWEEPS, MARKDOWN_DEDUP_SQL, ONE_HOUR_MS, SEVEN_DAYS_MS;
+var init_maintenance = __esm({
+  "src/lib/db/maintenance.ts"() {
+    "use strict";
+    init_src();
+    PROTECTED_TABLES = /* @__PURE__ */ new Set([
+      "sessions",
+      "orchestration_events",
+      "agent_sessions",
+      "command_executions",
+      "schema_version"
+    ]);
+    ORPHAN_SWEEPS = [
+      // session-rooted parents first
+      {
+        table: "review_rounds",
+        sql: "DELETE FROM review_rounds WHERE session_id NOT IN (SELECT id FROM sessions)"
+      },
+      {
+        table: "map_runs",
+        sql: "DELETE FROM map_runs WHERE session_id NOT IN (SELECT id FROM sessions)"
+      },
+      {
+        table: "markdown_artifacts",
+        sql: "DELETE FROM markdown_artifacts WHERE session_id NOT IN (SELECT id FROM sessions)"
+      },
+      {
+        table: "chat_conversations",
+        sql: "DELETE FROM chat_conversations WHERE session_id NOT IN (SELECT id FROM sessions)"
+      },
+      // second level (pick up parents deleted above)
+      {
+        table: "reviewer_outputs",
+        sql: "DELETE FROM reviewer_outputs WHERE round_id NOT IN (SELECT id FROM review_rounds)"
+      },
+      {
+        table: "map_sections",
+        sql: "DELETE FROM map_sections WHERE map_run_id NOT IN (SELECT id FROM map_runs)"
+      },
+      {
+        table: "chat_messages",
+        sql: "DELETE FROM chat_messages WHERE conversation_id NOT IN (SELECT id FROM chat_conversations)"
+      },
+      {
+        table: "user_round_progress",
+        sql: "DELETE FROM user_round_progress WHERE round_id NOT IN (SELECT id FROM review_rounds)"
+      },
+      // third level
+      {
+        table: "review_findings",
+        sql: "DELETE FROM review_findings WHERE reviewer_output_id NOT IN (SELECT id FROM reviewer_outputs)"
+      },
+      {
+        table: "map_files",
+        sql: "DELETE FROM map_files WHERE section_id NOT IN (SELECT id FROM map_sections)"
+      },
+      // leaves
+      {
+        table: "user_finding_progress",
+        sql: "DELETE FROM user_finding_progress WHERE finding_id NOT IN (SELECT id FROM review_findings)"
+      },
+      {
+        table: "user_file_progress",
+        sql: "DELETE FROM user_file_progress WHERE map_file_id NOT IN (SELECT id FROM map_files)"
+      }
+    ];
+    MARKDOWN_DEDUP_SQL = `
+  DELETE FROM markdown_artifacts
+   WHERE rowid NOT IN (
+     SELECT MAX(rowid) FROM markdown_artifacts
+      GROUP BY session_id, artifact_type, IFNULL(round_number, -1), file_path
+   )`;
+    ONE_HOUR_MS = 60 * 60 * 1e3;
+    SEVEN_DAYS_MS = 7 * 24 * 60 * 60 * 1e3;
+  }
+});
+
 // src/lib/db/command-log.ts
-import { appendFileSync, existsSync as existsSync11, mkdirSync as mkdirSync3, readFileSync as readFileSync9, renameSync, writeFileSync as writeFileSync6 } from "node:fs";
-import { dirname as dirname5, join as join13 } from "node:path";
+import { appendFileSync, existsSync as existsSync12, mkdirSync as mkdirSync4, readFileSync as readFileSync9, renameSync, writeFileSync as writeFileSync6 } from "node:fs";
+import { dirname as dirname7, join as join14 } from "node:path";
 import { randomUUID as randomUUID2 } from "node:crypto";
 function generateCommandUid() {
   return randomUUID2();
 }
 function cacheDir(ocrDir) {
-  return join13(ocrDir, "data", CACHE_DIR);
+  return join14(ocrDir, "data", CACHE_DIR);
 }
 function commandLogPath(ocrDir) {
-  return join13(cacheDir(ocrDir), FILENAME);
+  return join14(cacheDir(ocrDir), FILENAME);
 }
 function appendCommandLog(ocrDir, entry) {
   try {
     const filePath = commandLogPath(ocrDir);
-    const dir = dirname5(filePath);
-    if (!existsSync11(dir)) mkdirSync3(dir, { recursive: true });
+    const dir = dirname7(filePath);
+    if (!existsSync12(dir)) mkdirSync4(dir, { recursive: true });
     const line = JSON.stringify(entry) + "\n";
     appendFileSync(filePath, line, { encoding: "utf-8" });
     if (approxLineCount >= 0) approxLineCount++;
@@ -24648,7 +25276,7 @@ function appendCommandLog(ocrDir, entry) {
 }
 function readCommandLog(ocrDir) {
   const filePath = commandLogPath(ocrDir);
-  if (!existsSync11(filePath)) return [];
+  if (!existsSync12(filePath)) return [];
   const content = readFileSync9(filePath, "utf-8");
   const entries = [];
   for (const line of content.split("\n")) {
@@ -24734,6 +25362,7 @@ __export(db_exports, {
   PID_REUSE_GUARD_MS: () => PID_REUSE_GUARD_MS,
   STATE_EXIT: () => STATE_EXIT,
   StateError: () => StateError,
+  WATCHDOG_DEADLINE_EXIT_CODE: () => WATCHDOG_DEADLINE_EXIT_CODE,
   appendCommandLog: () => appendCommandLog,
   bindVendorSessionIdOpportunistically: () => bindVendorSessionIdOpportunistically,
   bumpAgentSessionHeartbeat: () => bumpAgentSessionHeartbeat,
@@ -24741,10 +25370,12 @@ __export(db_exports, {
   cascadeTerminateExecutions: () => cascadeTerminateExecutions,
   closeAllDatabases: () => closeAllDatabases,
   closeDatabase: () => closeDatabase,
+  collectDbHealth: () => collectDbHealth,
   commandLogPath: () => commandLogPath,
   commitReasonClose: () => commitReasonClose,
   defaultIsAlive: () => defaultIsAlive,
   ensureDatabase: () => ensureDatabase,
+  fixDb: () => fixDb,
   formatUpgradeNotice: () => formatUpgradeNotice,
   generateCommandUid: () => generateCommandUid,
   getAgentSession: () => getAgentSession,
@@ -24756,6 +25387,7 @@ __export(db_exports, {
   getLatestEventId: () => getLatestEventId,
   getSchemaVersion: () => getSchemaVersion,
   getSession: () => getSession,
+  hasInFlightDependents: () => hasInFlightDependents,
   insertAgentSession: () => insertAgentSession,
   insertEvent: () => insertEvent,
   insertSession: () => insertSession,
@@ -24764,7 +25396,12 @@ __export(db_exports, {
   listAgentSessionsForWorkflow: () => listAgentSessionsForWorkflow,
   openDatabase: () => openDatabase,
   probeEngine: () => probeEngine,
+  probeWrite: () => probeWrite,
+  pruneBackups: () => pruneBackups,
+  pruneDb: () => pruneDb,
   readCommandLog: () => readCommandLog,
+  reapOrphanDbFiles: () => reapOrphanDbFiles,
+  reapStaleExecLogs: () => reapStaleExecLogs,
   reconcileLegacyState: () => reconcileLegacyState,
   recordVendorSessionIdForExecution: () => recordVendorSessionIdForExecution,
   replayCommandLog: () => replayCommandLog,
@@ -24774,23 +25411,34 @@ __export(db_exports, {
   runMigrations: () => runMigrations,
   setAgentSessionStatus: () => setAgentSessionStatus,
   setAgentSessionVendorId: () => setAgentSessionVendorId,
+  snapshotDb: () => snapshotDb,
   sqliteUtcMs: () => sqliteUtcMs,
   sweepStaleAgentSessions: () => sweepStaleAgentSessions,
   sweepStaleSessions: () => sweepStaleSessions,
   updateAgentSession: () => updateAgentSession,
   updateSession: () => updateSession,
-  walCheckpointTruncate: () => walCheckpointTruncate
+  vacuumDb: () => vacuumDb,
+  walCheckpointTruncate: () => walCheckpointTruncate,
+  withForeignKeysDisabled: () => withForeignKeysDisabled
 });
-import { existsSync as existsSync12, mkdirSync as mkdirSync4, copyFileSync, statSync } from "node:fs";
-import { dirname as dirname6, join as join14 } from "node:path";
+import {
+  existsSync as existsSync13,
+  mkdirSync as mkdirSync5,
+  copyFileSync as copyFileSync2,
+  statSync as statSync2,
+  mkdtempSync,
+  rmSync
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname as dirname8, join as join15 } from "node:path";
 function maybeSnapshotBeforeUpgrade(db, dbPath, fromVersion) {
   if (fromVersion < 1 || fromVersion >= V2_SCHEMA_VERSION) return null;
   const bakPath = `${dbPath}.bak.v${fromVersion}`;
-  if (existsSync12(bakPath)) return bakPath;
+  if (existsSync13(bakPath)) return bakPath;
   try {
-    if (!existsSync12(dbPath) || statSync(dbPath).size === 0) return null;
+    if (!existsSync13(dbPath) || statSync2(dbPath).size === 0) return null;
     db.pragma("wal_checkpoint(TRUNCATE)");
-    copyFileSync(dbPath, bakPath);
+    copyFileSync2(dbPath, bakPath);
     return bakPath;
   } catch {
     return null;
@@ -24823,24 +25471,24 @@ async function openDatabase(dbPath) {
   if (cached) {
     return cached;
   }
-  const dir = dirname6(dbPath);
-  if (!existsSync12(dir)) {
-    mkdirSync4(dir, { recursive: true });
+  const dir = dirname8(dbPath);
+  if (!existsSync13(dir)) {
+    mkdirSync5(dir, { recursive: true });
   }
   const db = openEngine(dbPath);
   connections.set(dbPath, db);
   return db;
 }
 async function getDb(ocrDir) {
-  const dbPath = join14(ocrDir, "data", "ocr.db");
+  const dbPath = join15(ocrDir, "data", "ocr.db");
   return openDatabase(dbPath);
 }
 async function ensureDatabase(ocrDir) {
-  const dataDir = join14(ocrDir, "data");
-  if (!existsSync12(dataDir)) {
-    mkdirSync4(dataDir, { recursive: true });
+  const dataDir = join15(ocrDir, "data");
+  if (!existsSync13(dataDir)) {
+    mkdirSync5(dataDir, { recursive: true });
   }
-  const dbPath = join14(dataDir, "ocr.db");
+  const dbPath = join15(dataDir, "ocr.db");
   const db = await openDatabase(dbPath);
   let before = 0;
   try {
@@ -24868,7 +25516,7 @@ async function ensureDatabase(ocrDir) {
   return db;
 }
 function walCheckpointTruncate(dbPath) {
-  if (!existsSync12(dbPath)) {
+  if (!existsSync13(dbPath)) {
     return "skipped";
   }
   const cached = connections.get(dbPath);
@@ -24889,7 +25537,7 @@ function walCheckpointTruncate(dbPath) {
     return "failed";
   } finally {
     try {
-      transient?.raw.close();
+      transient?.close();
     } catch {
     }
   }
@@ -24907,6 +25555,41 @@ function closeAllDatabases() {
     connections.delete(path2);
   }
 }
+function probeWrite() {
+  let dir;
+  try {
+    dir = mkdtempSync(join15(tmpdir(), "ocr-probe-"));
+    const db = openEngine(join15(dir, "probe.db"));
+    try {
+      db.run("CREATE TABLE _probe_write (id INTEGER PRIMARY KEY, v TEXT)");
+      db.transaction(() => {
+        db.run("INSERT INTO _probe_write (v) VALUES (?)", ["written-in-txn"]);
+      });
+      const value = db.exec("SELECT v FROM _probe_write")[0]?.values[0]?.[0];
+      if (value !== "written-in-txn") {
+        return { ok: false, error: `unexpected probe value: ${String(value)}` };
+      }
+      return { ok: true };
+    } finally {
+      db.close();
+    }
+  } catch (e) {
+    return { ok: false, error: e instanceof Error ? e.message : String(e) };
+  } finally {
+    if (dir) rmDirBestEffort(dir);
+  }
+}
+function rmDirBestEffort(dir) {
+  for (let attempt = 0; attempt < 3; attempt++) {
+    try {
+      rmSync(dir, { recursive: true, force: true });
+      return;
+    } catch {
+      if (attempt === 2) return;
+      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 10);
+    }
+  }
+}
 var V2_SCHEMA_VERSION, connections;
 var init_db = __esm({
   "src/lib/db/index.ts"() {
@@ -24922,6 +25605,7 @@ var init_db = __esm({
     init_result_mapper();
     init_engine();
     init_reconcile();
+    init_maintenance();
     init_migrations();
     init_command_log();
     V2_SCHEMA_VERSION = 12;
@@ -24929,6 +25613,13 @@ var init_db = __esm({
   }
 });
 
+// src/lib/runtime-guard.ts
+init_runtime_checks();
+if (!isSupportedNode(process.versions.node)) {
+  process.stderr.write(nodeVersionGuardMessage(process.versions.node));
+  process.exit(1);
+}
+
 // ../../node_modules/.pnpm/commander@13.1.0/node_modules/commander/esm.mjs
 var import_index = __toESM(require_commander(), 1);
 var {
@@ -28445,6 +29136,8 @@ function ora(options) {
 }
 
 // src/lib/config.ts
+init_src();
+init_src();
 var AI_TOOLS = [
   {
     id: "amazon-q",
@@ -28468,7 +29161,9 @@ var AI_TOOLS = [
     configDir: ".claude",
     commandsDir: ".claude/commands",
     skillsDir: ".claude/skills",
-    commandStrategy: "subdirectory"
+    commandStrategy: "subdirectory",
+    instructionFiles: [{ path: "CLAUDE.md", format: "markdown" }],
+    vendorBinary: "claude"
   },
   {
     id: "cline",
@@ -28484,7 +29179,9 @@ var AI_TOOLS = [
     configDir: ".codex",
     commandsDir: ".codex/commands",
     skillsDir: ".codex/skills",
-    commandStrategy: "subdirectory"
+    commandStrategy: "subdirectory",
+    // Codex reads AGENTS.md natively — no extra instruction file.
+    vendorBinary: "codex"
   },
   {
     id: "continue",
@@ -28508,7 +29205,9 @@ var AI_TOOLS = [
     configDir: ".gemini",
     commandsDir: ".gemini/commands",
     skillsDir: ".gemini/skills",
-    commandStrategy: "subdirectory"
+    commandStrategy: "subdirectory",
+    instructionFiles: [{ path: "GEMINI.md", format: "markdown" }],
+    vendorBinary: "gemini"
   },
   {
     id: "github-copilot",
@@ -28516,7 +29215,10 @@ var AI_TOOLS = [
     configDir: ".github",
     commandsDir: ".github/commands",
     skillsDir: ".github/skills",
-    commandStrategy: "subdirectory"
+    commandStrategy: "subdirectory",
+    instructionFiles: [
+      { path: ".github/copilot-instructions.md", format: "markdown" }
+    ]
   },
   {
     id: "kilo-code",
@@ -28532,7 +29234,9 @@ var AI_TOOLS = [
     configDir: ".opencode",
     commandsDir: ".opencode/commands",
     skillsDir: ".opencode/skills",
-    commandStrategy: "subdirectory"
+    commandStrategy: "subdirectory",
+    // OpenCode reads AGENTS.md natively — no extra instruction file.
+    vendorBinary: "opencode"
   },
   {
     id: "qoder",
@@ -28556,9 +29260,16 @@ var AI_TOOLS = [
     configDir: ".windsurf",
     commandsDir: ".windsurf/workflows",
     skillsDir: ".windsurf/skills",
-    commandStrategy: "flat-prefixed"
+    commandStrategy: "flat-prefixed",
+    instructionFiles: [{ path: ".windsurfrules", format: "plaintext" }]
   }
 ];
+function getToolById(id) {
+  return AI_TOOLS.find((tool) => tool.id === id);
+}
+function getHostCapabilities(id) {
+  return hostCapabilitiesFor(id);
+}
 function getToolIds() {
   return AI_TOOLS.map((tool) => tool.id);
 }
@@ -28619,11 +29330,11 @@ function ensureGitignore(ocrDir) {
   const gitignorePath = join(ocrDir, ".gitignore");
   const block = buildManagedBlock();
   let content = existsSync(gitignorePath) ? readFileSync2(gitignorePath, "utf-8") : "";
-  const blockRegex = new RegExp(
+  const blockRegex2 = new RegExp(
     `${escapeRegex(START_MARKER)}[\\s\\S]*?${escapeRegex(END_MARKER)}\\n?`,
     "g"
   );
-  if (blockRegex.test(content)) {
+  if (blockRegex2.test(content)) {
     content = content.replace(
       new RegExp(
         `${escapeRegex(START_MARKER)}[\\s\\S]*?${escapeRegex(END_MARKER)}\\n?`,
@@ -28813,6 +29524,7 @@ function resolveTeamComposition(team, override) {
 }
 
 // src/lib/installer.ts
+init_src();
 var require2 = createRequire(import.meta.url);
 function ensureDir(dir) {
   if (!existsSync3(dir)) {
@@ -28921,27 +29633,6 @@ function installCommandsForTool(tool, commandsSource, targetDir) {
     return false;
   }
 }
-var BUILTIN_ICON_MAP = {
-  architect: "blocks",
-  fullstack: "layers",
-  reliability: "activity",
-  "staff-engineer": "compass",
-  principal: "crown",
-  frontend: "layout",
-  backend: "server",
-  infrastructure: "cloud",
-  performance: "gauge",
-  accessibility: "accessibility",
-  data: "database",
-  devops: "rocket",
-  dx: "terminal",
-  mobile: "smartphone",
-  security: "shield-alert",
-  quality: "sparkles",
-  testing: "test-tubes",
-  ai: "bot",
-  "docs-writer": "file-text"
-};
 var HOLISTIC_IDS = /* @__PURE__ */ new Set(["architect", "fullstack", "reliability", "staff-engineer", "principal"]);
 var SPECIALIST_IDS = /* @__PURE__ */ new Set([
   "frontend",
@@ -29044,7 +29735,7 @@ function generateReviewersMeta(reviewersDir, configPath) {
         id,
         name: extractReviewerName(content),
         tier,
-        icon: BUILTIN_ICON_MAP[id] ?? (tier === "persona" ? "brain" : "user"),
+        icon: defaultIconFor(id, tier),
         description: extractReviewerDescription(content),
         focus_areas: extractFocusAreas(content),
         is_default: defaultTeamIds.has(id),
@@ -29145,7 +29836,9 @@ function installForTool(tool, targetDir) {
     if (meta) {
       writeFileSync3(metaPath, JSON.stringify(meta, null, 2) + "\n");
     }
-  } catch {
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : "unknown error";
+    warnings.push(`Could not generate reviewers-meta.json: ${msg}`);
   }
   const commandsOk = installCommandsForTool(tool, commandsSource, targetDir);
   if (!commandsOk) {
@@ -29179,12 +29872,14 @@ function detectInstalledTools(targetDir, tools) {
 }
 
 // src/lib/injector.ts
-import { existsSync as existsSync4, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "node:fs";
-import { join as join4 } from "node:path";
-var START_MARKER2 = "<!-- OCR:START -->";
-var END_MARKER2 = "<!-- OCR:END -->";
-var OCR_INSTRUCTION_BLOCK = `${START_MARKER2}
-## Open Code Review Instructions
+import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "node:fs";
+import { dirname as dirname2, join as join4 } from "node:path";
+var AGENTS_MD = { path: "AGENTS.md", format: "markdown" };
+var MARKERS = {
+  markdown: { start: "<!-- OCR:START -->", end: "<!-- OCR:END -->" },
+  plaintext: { start: "# OCR:START", end: "# OCR:END" }
+};
+var OCR_INSTRUCTION_BODY = `## Open Code Review Instructions
 
 These instructions are for AI assistants handling code review in this project.
 
@@ -29200,37 +29895,95 @@ Use \`.ocr/skills/SKILL.md\` to learn:
 - Available reviewer personas and their focus areas
 - Session management and output format
 
-Keep this managed block so \`ocr init\` can refresh the instructions.
-
-${END_MARKER2}`;
-function injectOcrInstructions(filePath) {
+Keep this managed block so \`ocr init\` can refresh the instructions.`;
+function buildBlock(format) {
+  const { start, end } = MARKERS[format];
+  return `${start}
+${OCR_INSTRUCTION_BODY}
+${end}`;
+}
+function escapeRegex2(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function blockRegex(format) {
+  const { start, end } = MARKERS[format];
+  return new RegExp(
+    `${escapeRegex2(start)}[\\s\\S]*?${escapeRegex2(end)}\\n?`,
+    "g"
+  );
+}
+function injectOcrInstructions(filePath, format = "markdown") {
   try {
+    mkdirSync2(dirname2(filePath), { recursive: true });
     let content = existsSync4(filePath) ? readFileSync5(filePath, "utf-8") : "";
-    const regex2 = new RegExp(
-      `${escapeRegex2(START_MARKER2)}[\\s\\S]*?${escapeRegex2(END_MARKER2)}\\n?`,
-      "g"
-    );
-    content = content.replace(regex2, "");
+    content = content.replace(blockRegex(format), "");
     content = content.trim();
     if (content.length > 0) {
       content += "\n\n";
     }
-    content += OCR_INSTRUCTION_BLOCK + "\n";
+    content += buildBlock(format) + "\n";
     writeFileSync4(filePath, content);
     return true;
   } catch {
     return false;
   }
 }
-function escapeRegex2(str) {
-  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function resolveTargets(selectedTools) {
+  const targets = /* @__PURE__ */ new Map();
+  targets.set(AGENTS_MD.path, AGENTS_MD);
+  for (const tool of selectedTools) {
+    for (const file of tool.instructionFiles ?? []) {
+      targets.set(file.path, file);
+    }
+  }
+  return [...targets.values()];
 }
-function injectIntoProjectFiles(targetDir) {
-  const agentsMdPath = join4(targetDir, "AGENTS.md");
-  const claudeMdPath = join4(targetDir, "CLAUDE.md");
-  const agentsMd = injectOcrInstructions(agentsMdPath);
-  const claudeMd = injectOcrInstructions(claudeMdPath);
-  return { agentsMd, claudeMd };
+function plannedInstructionFiles(selectedTools) {
+  return resolveTargets(selectedTools).map((t) => t.path);
+}
+function injectIntoProjectFiles(targetDir, selectedTools) {
+  const written = [];
+  const failed = [];
+  for (const target of resolveTargets(selectedTools)) {
+    const ok = injectOcrInstructions(join4(targetDir, target.path), target.format);
+    (ok ? written : failed).push(target.path);
+  }
+  return { written, failed };
+}
+function hasOcrInstructions(filePath) {
+  if (!existsSync4(filePath)) {
+    return false;
+  }
+  const content = readFileSync5(filePath, "utf-8");
+  return Object.values(MARKERS).some(
+    (m) => content.includes(m.start) && content.includes(m.end)
+  );
+}
+function findStaleInstructionFiles(targetDir, writtenPaths) {
+  const written = new Set(writtenPaths);
+  const candidates = /* @__PURE__ */ new Set();
+  for (const tool of AI_TOOLS) {
+    for (const file of tool.instructionFiles ?? []) {
+      candidates.add(file.path);
+    }
+  }
+  const stale = [];
+  for (const path2 of candidates) {
+    if (written.has(path2)) continue;
+    if (hasOcrInstructions(join4(targetDir, path2))) {
+      stale.push(path2);
+    }
+  }
+  return stale;
+}
+function formatStaleWarnings(stale, mode) {
+  if (mode === "dry-run") {
+    return stale.map((path2) => `${path2} (stale OCR block \u2014 left untouched)`);
+  }
+  const owner = mode === "init" ? "installed" : "configured";
+  return stale.map(
+    (path2) => `${path2} still has an OCR block but no ${owner} tool uses it \u2014 remove it manually if unneeded.`
+  );
 }
 
 // src/lib/banner.ts
@@ -29333,29 +30086,10 @@ ${hint}
 }
 
 // src/lib/version.ts
-var CLI_VERSION = true ? "2.0.0" : createRequire(import.meta.url)("../../package.json").version;
-
-// ../shared/platform/src/index.ts
-import { pathToFileURL } from "node:url";
-import {
-  execFile,
-  execFileSync,
-  spawn as spawn2
-} from "node:child_process";
-import { promisify } from "node:util";
-var execFilePromise = promisify(execFile);
-var isWindows = process.platform === "win32";
-async function importModule(absolutePath) {
-  return import(pathToFileURL(absolutePath).href);
-}
-function execBinary(binary, args, opts) {
-  return execFileSync(binary, args, {
-    ...opts,
-    shell: isWindows
-  });
-}
+var CLI_VERSION = true ? "2.2.0" : createRequire(import.meta.url)("../../package.json").version;
 
 // src/lib/deps.ts
+init_src();
 var CATEGORY_ORDER = ["core", "ai-cli", "github"];
 var CATEGORY_INFO = {
   core: { label: "Core", hint: "" },
@@ -29527,7 +30261,7 @@ function printCapabilities(result) {
 }
 
 // src/commands/init.ts
-var initCommand = new Command("init").description("Set up OCR for AI coding environments").option("-t, --tools <tools>", 'Comma-separated tool IDs or "all"').option("--no-inject", "Skip injecting instructions into AGENTS.md/CLAUDE.md").action(async (options) => {
+var initCommand = new Command("init").description("Set up OCR for AI coding environments").option("-t, --tools <tools>", 'Comma-separated tool IDs or "all"').option("--no-inject", "Skip injecting instructions into project instruction files (AGENTS.md + each tool's native file)").action(async (options) => {
   printBanner();
   const depResult = checkDependencies();
   printDepChecks(depResult);
@@ -29618,17 +30352,19 @@ var initCommand = new Command("init").description("Set up OCR for AI coding envi
     const injectSpinner = ora(
       "Injecting OCR instructions into project files..."
     ).start();
-    const injectResults = injectIntoProjectFiles(targetDir);
+    const installedTools = successful.map((r) => r.tool);
+    const injectResults = injectIntoProjectFiles(targetDir, installedTools);
     injectSpinner.stop();
-    if (injectResults.agentsMd || injectResults.claudeMd) {
+    if (injectResults.written.length > 0) {
       console.log(source_default.green("\u2713 OCR instructions injected"));
-      if (injectResults.agentsMd) {
-        console.log(`  ${source_default.green("\u2713")} AGENTS.md`);
-      }
-      if (injectResults.claudeMd) {
-        console.log(`  ${source_default.green("\u2713")} CLAUDE.md`);
+      for (const path2 of injectResults.written) {
+        console.log(`  ${source_default.green("\u2713")} ${path2}`);
       }
     }
+    const stale = findStaleInstructionFiles(targetDir, injectResults.written);
+    for (const warning of formatStaleWarnings(stale, "init")) {
+      console.log(source_default.yellow(`  \u26A0 ${warning}`));
+    }
   }
   console.log();
   console.log(source_default.bold("Next steps:"));
@@ -29816,10 +30552,10 @@ var ReaddirpStream = class extends Readable {
   }
   async _formatEntry(dirent, path2) {
     let entry;
-    const basename8 = this._isDirent ? dirent.name : dirent;
+    const basename9 = this._isDirent ? dirent.name : dirent;
     try {
-      const fullPath = presolve(pjoin(path2, basename8));
-      entry = { path: prelative(this._root, fullPath), fullPath, basename: basename8 };
+      const fullPath = presolve(pjoin(path2, basename9));
+      entry = { path: prelative(this._root, fullPath), fullPath, basename: basename9 };
       entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err) {
       this._onError(err);
@@ -30358,9 +31094,9 @@ var NodeFsHandler = class {
   _watchWithNodeFs(path2, listener) {
     const opts = this.fsw.options;
     const directory = sysPath.dirname(path2);
-    const basename8 = sysPath.basename(path2);
+    const basename9 = sysPath.basename(path2);
     const parent = this.fsw._getWatchedDir(directory);
-    parent.add(basename8);
+    parent.add(basename9);
     const absolutePath = sysPath.resolve(path2);
     const options = {
       persistent: opts.persistent
@@ -30370,7 +31106,7 @@ var NodeFsHandler = class {
     let closer;
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
-      options.interval = enableBin && isBinaryPath(basename8) ? opts.binaryInterval : opts.interval;
+      options.interval = enableBin && isBinaryPath(basename9) ? opts.binaryInterval : opts.interval;
       closer = setFsWatchFileListener(path2, absolutePath, options, {
         listener,
         rawEmitter: this.fsw._emitRaw
@@ -30392,11 +31128,11 @@ var NodeFsHandler = class {
     if (this.fsw.closed) {
       return;
     }
-    const dirname8 = sysPath.dirname(file);
-    const basename8 = sysPath.basename(file);
-    const parent = this.fsw._getWatchedDir(dirname8);
+    const dirname10 = sysPath.dirname(file);
+    const basename9 = sysPath.basename(file);
+    const parent = this.fsw._getWatchedDir(dirname10);
     let prevStats = stats;
-    if (parent.has(basename8))
+    if (parent.has(basename9))
       return;
     const listener = async (path2, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
@@ -30421,9 +31157,9 @@ var NodeFsHandler = class {
             prevStats = newStats2;
           }
         } catch (error) {
-          this.fsw._remove(dirname8, basename8);
+          this.fsw._remove(dirname10, basename9);
         }
-      } else if (parent.has(basename8)) {
+      } else if (parent.has(basename9)) {
         const at = newStats.atimeMs;
         const mt = newStats.mtimeMs;
         if (!at || at <= mt || mt !== prevStats.mtimeMs) {
@@ -31354,8 +32090,8 @@ function watch(paths, options = {}) {
 }
 
 // src/commands/progress.ts
-import { existsSync as existsSync13, readdirSync as readdirSync5, statSync as statSync2 } from "node:fs";
-import { join as join15, basename as basename7 } from "node:path";
+import { existsSync as existsSync14, readdirSync as readdirSync6, statSync as statSync3 } from "node:fs";
+import { join as join16, basename as basename8 } from "node:path";
 
 // ../../node_modules/.pnpm/log-update@7.0.2/node_modules/log-update/index.js
 import process12 from "node:process";
@@ -32223,7 +32959,7 @@ var log_update_default = logUpdate;
 var logUpdateStderr = createLogUpdate(process12.stderr);
 
 // src/lib/guards.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync2 } from "node:fs";
+import { existsSync as existsSync6, mkdirSync as mkdirSync3 } from "node:fs";
 import { join as join8 } from "node:path";
 function checkOcrSetup(targetDir) {
   const ocrDir = join8(targetDir, ".ocr");
@@ -32269,7 +33005,7 @@ function requireOcrSetup(targetDir) {
 function ensureSessionsDir(targetDir) {
   const sessionsDir = join8(targetDir, ".ocr", "sessions");
   if (!existsSync6(sessionsDir)) {
-    mkdirSync2(sessionsDir, { recursive: true });
+    mkdirSync3(sessionsDir, { recursive: true });
   }
   return sessionsDir;
 }
@@ -32991,15 +33727,15 @@ function debounce(fn, delay) {
   };
 }
 function findLatestActiveSession(sessionsDir) {
-  if (!existsSync13(sessionsDir)) {
+  if (!existsSync14(sessionsDir)) {
     return null;
   }
-  const sessions = readdirSync5(sessionsDir).filter((name) => {
-    const sessionPath = join15(sessionsDir, name);
-    return statSync2(sessionPath).isDirectory();
+  const sessions = readdirSync6(sessionsDir).filter((name) => {
+    const sessionPath = join16(sessionsDir, name);
+    return statSync3(sessionPath).isDirectory();
   }).sort().reverse();
   for (const session of sessions) {
-    const sessionPath = join15(sessionsDir, session);
+    const sessionPath = join16(sessionsDir, session);
     if (isSessionActive(sessionPath)) {
       return session;
     }
@@ -33014,8 +33750,8 @@ function getStrategyForSession(sessionPath, explicitWorkflow) {
   return getStrategy(workflowType) ?? null;
 }
 async function initProgressDb(ocrDir) {
-  const dbPath = join15(ocrDir, "data", "ocr.db");
-  if (!existsSync13(dbPath)) {
+  const dbPath = join16(ocrDir, "data", "ocr.db");
+  if (!existsSync14(dbPath)) {
     return;
   }
   try {
@@ -33040,11 +33776,11 @@ var progressCommand = new Command("progress").description("Watch real-time progr
   const targetDir = process.cwd();
   requireOcrSetup(targetDir);
   const sessionsDir = ensureSessionsDir(targetDir);
-  const ocrDir = join15(targetDir, ".ocr");
+  const ocrDir = join16(targetDir, ".ocr");
   await initProgressDb(ocrDir);
   if (options.session) {
-    const sessionPath = join15(sessionsDir, options.session);
-    if (!existsSync13(sessionPath)) {
+    const sessionPath = join16(sessionsDir, options.session);
+    if (!existsSync14(sessionPath)) {
       console.error(source_default.red(`Session not found: ${options.session}`));
       process.exit(1);
     }
@@ -33105,7 +33841,7 @@ var progressCommand = new Command("progress").description("Watch real-time progr
     return;
   }
   let currentSession = findLatestActiveSession(sessionsDir);
-  let currentSessionPath = currentSession ? join15(sessionsDir, currentSession) : null;
+  let currentSessionPath = currentSession ? join16(sessionsDir, currentSession) : null;
   let sessionWatcher = null;
   const preservedStartTimes = {
     review: void 0,
@@ -33113,11 +33849,11 @@ var progressCommand = new Command("progress").description("Watch real-time progr
   };
   let currentStrategy = null;
   const updateDisplayImpl = () => {
-    if (!currentSessionPath || !existsSync13(currentSessionPath) || !isSessionActive(currentSessionPath)) {
+    if (!currentSessionPath || !existsSync14(currentSessionPath) || !isSessionActive(currentSessionPath)) {
       const latestActive = findLatestActiveSession(sessionsDir);
       if (latestActive && latestActive !== currentSession) {
         currentSession = latestActive;
-        currentSessionPath = join15(sessionsDir, latestActive);
+        currentSessionPath = join16(sessionsDir, latestActive);
         preservedStartTimes.review = void 0;
         preservedStartTimes.map = void 0;
         currentStrategy = null;
@@ -33130,7 +33866,7 @@ var progressCommand = new Command("progress").description("Watch real-time progr
         currentStrategy = null;
       }
     }
-    if (currentSessionPath && existsSync13(currentSessionPath)) {
+    if (currentSessionPath && existsSync14(currentSessionPath)) {
       if (!options.workflow) {
         const activeWorkflows = detectActiveWorkflows(currentSessionPath);
         if (activeWorkflows.length > 1) {
@@ -33184,17 +33920,17 @@ var progressCommand = new Command("progress").description("Watch real-time progr
     watchSession(currentSessionPath);
   }
   const timerInterval = setInterval(updateDisplay, 1e3);
-  const watchDir = existsSync13(ocrDir) ? ocrDir : targetDir;
+  const watchDir = existsSync14(ocrDir) ? ocrDir : targetDir;
   const dirWatcher = watch(watchDir, {
     persistent: true,
     ignoreInitial: true,
     depth: 3
   });
   dirWatcher.on("addDir", (dirPath) => {
-    const parentDir = join15(dirPath, "..");
-    const isDirectChild = parentDir.endsWith("sessions") || parentDir.endsWith(join15(".ocr", "sessions"));
+    const parentDir = join16(dirPath, "..");
+    const isDirectChild = parentDir.endsWith("sessions") || parentDir.endsWith(join16(".ocr", "sessions"));
     if (isDirectChild && !dirPath.endsWith("sessions")) {
-      const newSession = basename7(dirPath);
+      const newSession = basename8(dirPath);
       currentSession = newSession;
       currentSessionPath = dirPath;
       preservedStartTimes.review = void 0;
@@ -33233,7 +33969,7 @@ function renderGenericWaiting() {
 }
 function renderCombinedProgress(sessionPath, preservedStartTimes, ocrDir) {
   const lines = [];
-  const session = basename7(sessionPath);
+  const session = basename8(sessionPath);
   lines.push("");
   lines.push(
     source_default.bold.white("  Open Code Review") + source_default.yellow(" \xB7 Parallel Workflows")
@@ -33294,21 +34030,21 @@ function renderCombinedProgress(sessionPath, preservedStartTimes, ocrDir) {
 }
 
 // src/commands/state.ts
-import { existsSync as existsSync15, mkdirSync as mkdirSync6, readFileSync as readFileSync11 } from "node:fs";
-import { join as join17 } from "node:path";
+import { existsSync as existsSync16, mkdirSync as mkdirSync7, readFileSync as readFileSync11 } from "node:fs";
+import { join as join18 } from "node:path";
 
 // src/lib/state/index.ts
 init_db();
 init_exit_codes();
 import {
-  existsSync as existsSync14,
-  mkdirSync as mkdirSync5,
-  readdirSync as readdirSync6,
+  existsSync as existsSync15,
+  mkdirSync as mkdirSync6,
+  readdirSync as readdirSync7,
   readFileSync as readFileSync10,
-  statSync as statSync3,
+  statSync as statSync4,
   writeFileSync as writeFileSync7
 } from "node:fs";
-import { join as join16 } from "node:path";
+import { join as join17 } from "node:path";
 
 // src/lib/state/phase-graph.ts
 init_exit_codes();
@@ -33616,9 +34352,9 @@ function deriveNextRound(db, sessionId, fallbackRound) {
 }
 function hasArtifacts(dir) {
   try {
-    for (const entry of readdirSync6(dir, { withFileTypes: true })) {
+    for (const entry of readdirSync7(dir, { withFileTypes: true })) {
       if (entry.isDirectory()) {
-        if (hasArtifacts(join16(dir, entry.name))) return true;
+        if (hasArtifacts(join17(dir, entry.name))) return true;
       } else if (/\.(md|json)$/.test(entry.name)) {
         return true;
       }
@@ -33629,7 +34365,7 @@ function hasArtifacts(dir) {
 }
 function readJsonFromSource(params) {
   if (params.source === "file") {
-    if (!existsSync14(params.filePath)) {
+    if (!existsSync15(params.filePath)) {
       throw new StateError(STATE_EXIT.NOT_FOUND, `File not found: ${params.filePath}`);
     }
     return readFileSync10(params.filePath, "utf-8");
@@ -33956,7 +34692,7 @@ async function stateCompleteRound(params) {
   }
   const resolved = resolveSession(db, params.sessionId);
   const roundNumber = params.round ?? resolved.current_round;
-  const roundMetaPath = join16(
+  const roundMetaPath = join17(
     resolved.session_dir,
     "rounds",
     `round-${roundNumber}`,
@@ -33977,8 +34713,8 @@ async function stateCompleteRound(params) {
     );
   }
   if (params.requireFinal) {
-    const finalPath = join16(resolved.session_dir, "rounds", `round-${roundNumber}`, "final.md");
-    if (!existsSync14(finalPath)) {
+    const finalPath = join17(resolved.session_dir, "rounds", `round-${roundNumber}`, "final.md");
+    if (!existsSync15(finalPath)) {
       throw new StateError(
         STATE_EXIT.INVARIANT_UNMET,
         `Cannot complete round: --require-final set but ${finalPath} is missing.`
@@ -33987,8 +34723,8 @@ async function stateCompleteRound(params) {
   }
   let metaPath;
   if (params.source === "stdin") {
-    const roundDir = join16(resolved.session_dir, "rounds", `round-${roundNumber}`);
-    mkdirSync5(roundDir, { recursive: true });
+    const roundDir = join17(resolved.session_dir, "rounds", `round-${roundNumber}`);
+    mkdirSync6(roundDir, { recursive: true });
     metaPath = roundMetaPath;
     writeFileSync7(metaPath, JSON.stringify(meta, null, 2));
   }
@@ -34042,7 +34778,7 @@ async function stateCompleteMap(params) {
   }
   const resolved = resolveSession(db, params.sessionId);
   const mapRunNumber = params.mapRun ?? resolved.current_map_run;
-  const mapMetaPath = join16(
+  const mapMetaPath = join17(
     resolved.session_dir,
     "map",
     "runs",
@@ -34065,8 +34801,8 @@ async function stateCompleteMap(params) {
   }
   let metaPath;
   if (params.source === "stdin") {
-    const runDir = join16(resolved.session_dir, "map", "runs", `run-${mapRunNumber}`);
-    mkdirSync5(runDir, { recursive: true });
+    const runDir = join17(resolved.session_dir, "map", "runs", `run-${mapRunNumber}`);
+    mkdirSync6(runDir, { recursive: true });
     metaPath = mapMetaPath;
     writeFileSync7(metaPath, JSON.stringify(meta, null, 2));
   }
@@ -34151,17 +34887,17 @@ async function stateStatus(ocrDir, sessionId) {
 }
 async function stateSync(ocrDir) {
   const db = await ensureDatabase(ocrDir);
-  const sessionsRoot = join16(ocrDir, "sessions");
-  if (!existsSync14(sessionsRoot)) {
+  const sessionsRoot = join17(ocrDir, "sessions");
+  if (!existsSync15(sessionsRoot)) {
     return 0;
   }
-  const entries = readdirSync6(sessionsRoot).filter((name) => {
-    const fullPath = join16(sessionsRoot, name);
-    return statSync3(fullPath).isDirectory();
+  const entries = readdirSync7(sessionsRoot).filter((name) => {
+    const fullPath = join17(sessionsRoot, name);
+    return statSync4(fullPath).isDirectory();
   });
   let synced = 0;
   for (const dirName of entries) {
-    const dirPath = join16(sessionsRoot, dirName);
+    const dirPath = join17(sessionsRoot, dirName);
     const existing = getSession(db, dirName);
     if (existing) {
       continue;
@@ -34169,8 +34905,8 @@ async function stateSync(ocrDir) {
     if (!hasArtifacts(dirPath)) {
       continue;
     }
-    const hasRoundsDir = existsSync14(join16(dirPath, "rounds"));
-    const hasMapDir = existsSync14(join16(dirPath, "map"));
+    const hasRoundsDir = existsSync15(join17(dirPath, "rounds"));
+    const hasMapDir = existsSync15(join17(dirPath, "map"));
     const workflowType = hasMapDir && !hasRoundsDir ? "map" : "review";
     const branchMatch = dirName.match(/^\d{4}-\d{2}-\d{2}-(.+)$/);
     const branch = branchMatch?.[1] ?? dirName;
@@ -34179,14 +34915,14 @@ async function stateSync(ocrDir) {
     let inferredRound = 1;
     let inferredMapRun = 1;
     if (workflowType === "review") {
-      const roundsDir = join16(dirPath, "rounds");
-      if (existsSync14(roundsDir)) {
-        const roundDirs = readdirSync6(roundsDir).filter((d) => /^round-\d+$/.test(d)).map((d) => parseInt(d.replace("round-", ""), 10)).filter((n) => Number.isFinite(n)).sort((a, b) => a - b);
+      const roundsDir = join17(dirPath, "rounds");
+      if (existsSync15(roundsDir)) {
+        const roundDirs = readdirSync7(roundsDir).filter((d) => /^round-\d+$/.test(d)).map((d) => parseInt(d.replace("round-", ""), 10)).filter((n) => Number.isFinite(n)).sort((a, b) => a - b);
         const latestRoundNum = roundDirs[roundDirs.length - 1];
         if (latestRoundNum !== void 0) {
           inferredRound = latestRoundNum;
-          if (existsSync14(
-            join16(roundsDir, `round-${latestRoundNum}`, "final.md")
+          if (existsSync15(
+            join17(roundsDir, `round-${latestRoundNum}`, "final.md")
           )) {
             inferredPhase = "complete";
             inferredPhaseNumber = 8;
@@ -34194,13 +34930,13 @@ async function stateSync(ocrDir) {
         }
       }
     } else if (workflowType === "map") {
-      const runsDir = join16(dirPath, "map", "runs");
-      if (existsSync14(runsDir)) {
-        const runDirs = readdirSync6(runsDir).filter((d) => /^run-\d+$/.test(d)).map((d) => parseInt(d.replace("run-", ""), 10)).filter((n) => Number.isFinite(n)).sort((a, b) => a - b);
+      const runsDir = join17(dirPath, "map", "runs");
+      if (existsSync15(runsDir)) {
+        const runDirs = readdirSync7(runsDir).filter((d) => /^run-\d+$/.test(d)).map((d) => parseInt(d.replace("run-", ""), 10)).filter((n) => Number.isFinite(n)).sort((a, b) => a - b);
         const latestRunNum = runDirs[runDirs.length - 1];
         if (latestRunNum !== void 0) {
           inferredMapRun = latestRunNum;
-          if (existsSync14(join16(runsDir, `run-${latestRunNum}`, "map.md"))) {
+          if (existsSync15(join17(runsDir, `run-${latestRunNum}`, "map.md"))) {
             inferredPhase = "complete";
             inferredPhaseNumber = 6;
           }
@@ -34238,7 +34974,7 @@ init_command_log();
 init_db();
 init_db();
 function readDashboardSpawnMarker(ocrDir) {
-  const path2 = join17(ocrDir, "data", "dashboard-active-spawn.json");
+  const path2 = join18(ocrDir, "data", "dashboard-active-spawn.json");
   let raw;
   try {
     raw = readFileSync11(path2, "utf-8");
@@ -34303,7 +35039,7 @@ async function linkDashboardInvocation(ocrDir, sessionId, explicitUid, label) {
 var showSubcommand = new Command("show").description("Show current session state").option("--session-id <id>", "Session ID (defaults to latest active)").option("--json", "Output as JSON").action(async (options) => {
   const targetDir = process.cwd();
   requireOcrSetup(targetDir);
-  const ocrDir = join17(targetDir, ".ocr");
+  const ocrDir = join18(targetDir, ".ocr");
   try {
     const result = await stateShow(ocrDir, options.sessionId);
     if (!result) {
@@ -34372,7 +35108,7 @@ var showSubcommand = new Command("show").description("Show current session state
 var syncSubcommand = new Command("sync").description("Rebuild session state from filesystem artifacts").action(async () => {
   const targetDir = process.cwd();
   requireOcrSetup(targetDir);
-  const ocrDir = join17(targetDir, ".ocr");
+  const ocrDir = join18(targetDir, ".ocr");
   try {
     const synced = await stateSync(ocrDir);
     console.log(`Synced ${synced} session${synced !== 1 ? "s" : ""} from filesystem.`);
@@ -34399,7 +35135,7 @@ var reconcileSubcommand = new Command("reconcile").description(
 ).option("--dry-run", "Print the repair plan without writing anything").option("--json", "Output the result as JSON").action(async (options) => {
   const targetDir = process.cwd();
   requireOcrSetup(targetDir);
-  const ocrDir = join17(targetDir, ".ocr");
+  const ocrDir = join18(targetDir, ".ocr");
   try {
     const db = await ensureDatabase(ocrDir);
     const result = reconcileLegacyState(db, ocrDir, { dryRun: options.dryRun });
@@ -34458,9 +35194,9 @@ var beginSubcommand = new Command("begin").description("Start or resume a workfl
   async (options) => {
     const targetDir = process.cwd();
     requireOcrSetup(targetDir);
-    const ocrDir = join17(targetDir, ".ocr");
-    const sessionDir = options.sessionDir ?? join17(ocrDir, "sessions", options.sessionId);
-    if (!existsSync15(sessionDir)) mkdirSync6(sessionDir, { recursive: true });
+    const ocrDir = join18(targetDir, ".ocr");
+    const sessionDir = options.sessionDir ?? join18(ocrDir, "sessions", options.sessionId);
+    if (!existsSync16(sessionDir)) mkdirSync7(sessionDir, { recursive: true });
     try {
       const result = await stateBegin({
         sessionId: options.sessionId,
@@ -34482,7 +35218,7 @@ var advanceSubcommand = new Command("advance").description("Advance the workflow
   async (options) => {
     const targetDir = process.cwd();
     requireOcrSetup(targetDir);
-    const ocrDir = join17(targetDir, ".ocr");
+    const ocrDir = join18(targetDir, ".ocr");
     try {
       const { id: sessionId } = await resolveActiveSession(ocrDir, options.sessionId);
       await stateAdvance({
@@ -34502,7 +35238,7 @@ var completeRoundSubcommand = new Command("complete-round").description("Atomica
   async (options) => {
     const targetDir = process.cwd();
     requireOcrSetup(targetDir);
-    const ocrDir = join17(targetDir, ".ocr");
+    const ocrDir = join18(targetDir, ".ocr");
     try {
       const base = options.stdin ? { source: "stdin", data: await readStdin() } : options.file ? { source: "file", filePath: options.file } : (() => {
         throw new StateError(STATE_EXIT.USAGE, "Provide --stdin or --file with round metadata");
@@ -34526,7 +35262,7 @@ var completeMapSubcommand = new Command("complete-map").description("Atomically
   async (options) => {
     const targetDir = process.cwd();
     requireOcrSetup(targetDir);
-    const ocrDir = join17(targetDir, ".ocr");
+    const ocrDir = join18(targetDir, ".ocr");
     try {
       const base = options.stdin ? { source: "stdin", data: await readStdin() } : options.file ? { source: "file", filePath: options.file } : (() => {
         throw new StateError(STATE_EXIT.USAGE, "Provide --stdin or --file with map metadata");
@@ -34548,7 +35284,7 @@ var completeMapSubcommand = new Command("complete-map").description("Atomically
 var finishSubcommand = new Command("finish").description("Close a workflow (refuses unless the current round/run is complete)").option("--session-id <id>", "Session ID (auto-detects active if omitted)").option("--abort", "Abandon the session \u2014 records a distinct, non-success terminal").action(async (options) => {
   const targetDir = process.cwd();
   requireOcrSetup(targetDir);
-  const ocrDir = join17(targetDir, ".ocr");
+  const ocrDir = join18(targetDir, ".ocr");
   try {
     const { id: sessionId } = await resolveActiveSession(ocrDir, options.sessionId);
     await stateClose({ sessionId, ocrDir, abort: options.abort });
@@ -34560,7 +35296,7 @@ var finishSubcommand = new Command("finish").description("Close a workflow (refu
 var statusSubcommand = new Command("status").description("Report whether a session is complete and, if not, what's missing").option("--session-id <id>", "Session ID (auto-detects active if omitted)").option("--json", "Output the result as JSON").action(async (options) => {
   const targetDir = process.cwd();
   requireOcrSetup(targetDir);
-  const ocrDir = join17(targetDir, ".ocr");
+  const ocrDir = join18(targetDir, ".ocr");
   try {
     const result = await stateStatus(ocrDir, options.sessionId);
     if (options.json) {
@@ -34589,44 +35325,50 @@ var stateCommand = new Command("state").description("Manage OCR session state").
 
 // src/commands/session.ts
 import { randomUUID as randomUUID3 } from "node:crypto";
-import { join as join19 } from "node:path";
+import { join as join20 } from "node:path";
 init_db();
 
 // src/lib/runtime-config.ts
-import { existsSync as existsSync16, readFileSync as readFileSync12 } from "node:fs";
-import { join as join18 } from "node:path";
+import { existsSync as existsSync17, readFileSync as readFileSync12 } from "node:fs";
+import { join as join19 } from "node:path";
 var DEFAULT_AGENT_HEARTBEAT_SECONDS = 60;
-function getAgentHeartbeatSeconds(ocrDir) {
-  const configPath = join18(ocrDir, "config.yaml");
-  if (!existsSync16(configPath)) {
-    return DEFAULT_AGENT_HEARTBEAT_SECONDS;
-  }
+function readRuntimePositiveInt(ocrDir, key, defaultValue) {
+  const configPath = join19(ocrDir, "config.yaml");
+  if (!existsSync17(configPath)) return defaultValue;
   let content;
   try {
     content = readFileSync12(configPath, "utf-8");
   } catch {
-    return DEFAULT_AGENT_HEARTBEAT_SECONDS;
+    return defaultValue;
   }
   const blockMatch = content.match(
-    /^runtime:\s*\n(?:\s+[^\n]*\n)*?\s+agent_heartbeat_seconds:\s*([^\s#\n]+)/m
+    new RegExp(
+      String.raw`^runtime:\s*\n(?:\s+[^\n]*\n)*?\s+${key}:\s*([^\s#\n]+)`,
+      "m"
+    )
   );
   const inlineMatch = content.match(
-    /^runtime:\s*\{[^}]*\bagent_heartbeat_seconds:\s*([^\s,}]+)/m
+    new RegExp(String.raw`^runtime:\s*\{[^}]*\b${key}:\s*([^\s,}]+)`, "m")
   );
   const raw = blockMatch?.[1] ?? inlineMatch?.[1];
-  if (!raw) {
-    return DEFAULT_AGENT_HEARTBEAT_SECONDS;
-  }
+  if (!raw) return defaultValue;
   const parsed = Number(raw);
   if (!Number.isFinite(parsed) || parsed <= 0 || !Number.isInteger(parsed)) {
     process.stderr.write(
-      `[ocr] runtime.agent_heartbeat_seconds is not a positive integer (got "${raw}"); falling back to ${DEFAULT_AGENT_HEARTBEAT_SECONDS}s.
+      `[ocr] runtime.${key} is not a positive integer (got "${raw}"); falling back to ${defaultValue}.
 `
     );
-    return DEFAULT_AGENT_HEARTBEAT_SECONDS;
+    return defaultValue;
   }
   return parsed;
 }
+function getAgentHeartbeatSeconds(ocrDir) {
+  return readRuntimePositiveInt(
+    ocrDir,
+    "agent_heartbeat_seconds",
+    DEFAULT_AGENT_HEARTBEAT_SECONDS
+  );
+}
 
 // src/commands/session.ts
 var TERMINAL_STATUSES = /* @__PURE__ */ new Set([
@@ -34642,7 +35384,7 @@ function fail(message) {
 async function setup() {
   const targetDir = process.cwd();
   requireOcrSetup(targetDir);
-  const ocrDir = join19(targetDir, ".ocr");
+  const ocrDir = join20(targetDir, ".ocr");
   return { ocrDir };
 }
 var startInstanceSubcommand = new Command("start-instance").description("Journal a new agent-CLI process spawned for the active review").option("--workflow <id>", "Workflow session id (auto-detects active if omitted)").option("--persona <name>", "Reviewer persona, e.g. 'principal'").option("--instance <number>", "Instance index within (workflow, persona)", parseInt).option("--name <name>", "Human-friendly name (default: '{persona}-{instance}')").requiredOption("--vendor <vendor>", "Underlying CLI vendor (e.g. 'claude', 'opencode')").option("--model <id>", "Resolved model id passed to the CLI's --model flag").option("--phase <phase>", "Workflow phase this instance is doing").option("--pid <pid>", "Process id of the spawned process", parseInt).option("--note <text>", "Free-form note to attach").action(
@@ -34777,6 +35519,7 @@ var listSubcommand = new Command("list").description("List agent sessions for a
 var sessionCommand = new Command("session").description("Manage agent-CLI session lifecycle journal").addCommand(startInstanceSubcommand).addCommand(bindVendorIdSubcommand).addCommand(beatSubcommand).addCommand(endInstanceSubcommand).addCommand(listSubcommand);
 
 // src/lib/models.ts
+init_src();
 var BUNDLED_CLAUDE_MODELS = [
   { id: "claude-opus-4-7", displayName: "Claude Opus 4.7" },
   { id: "claude-sonnet-4-6", displayName: "Claude Sonnet 4.6" },
@@ -34897,8 +35640,8 @@ var modelsCommand = new Command("models").description("Inspect models available
 
 // src/commands/team.ts
 var import_yaml2 = __toESM(require_dist(), 1);
-import { existsSync as existsSync17, readFileSync as readFileSync13, writeFileSync as writeFileSync8 } from "node:fs";
-import { join as join20 } from "node:path";
+import { existsSync as existsSync18, readFileSync as readFileSync13, writeFileSync as writeFileSync8 } from "node:fs";
+import { join as join21 } from "node:path";
 async function readStdin2() {
   const chunks = [];
   for await (const chunk of process.stdin) {
@@ -34957,7 +35700,7 @@ var resolveSubcommand = new Command("resolve").description("Resolve and print th
   async (options) => {
     const targetDir = process.cwd();
     requireOcrSetup(targetDir);
-    const ocrDir = join20(targetDir, ".ocr");
+    const ocrDir = join21(targetDir, ".ocr");
     try {
       const { team } = loadTeamConfig(ocrDir);
       let override;
@@ -34996,8 +35739,8 @@ var setSubcommand = new Command("set").description("Persist a new default_team c
   }
   const targetDir = process.cwd();
   requireOcrSetup(targetDir);
-  const ocrDir = join20(targetDir, ".ocr");
-  const configPath = join20(ocrDir, "config.yaml");
+  const ocrDir = join21(targetDir, ".ocr");
+  const configPath = join21(ocrDir, "config.yaml");
   try {
     const raw = await readStdin2();
     const team = parseSessionOverride(raw);
@@ -35007,12 +35750,12 @@ var setSubcommand = new Command("set").description("Persist a new default_team c
       list.push(inst);
       byPersona.set(inst.persona, list);
     }
-    const doc = existsSync17(configPath) ? (0, import_yaml2.parseDocument)(readFileSync13(configPath, "utf-8")) : new import_yaml2.Document({});
+    const doc = existsSync18(configPath) ? (0, import_yaml2.parseDocument)(readFileSync13(configPath, "utf-8")) : new import_yaml2.Document({});
     applyDefaultTeamSurgically(doc, byPersona);
     const yamlOutput = doc.toString({ lineWidth: 0 });
     writeFileSync8(configPath, yamlOutput, "utf-8");
-    const reviewersDir = join20(ocrDir, "skills", "references", "reviewers");
-    const metaPath = join20(ocrDir, "reviewers-meta.json");
+    const reviewersDir = join21(ocrDir, "skills", "references", "reviewers");
+    const metaPath = join21(ocrDir, "reviewers-meta.json");
     let metaWritten = false;
     try {
       const meta = generateReviewersMeta(reviewersDir, configPath);
@@ -35108,7 +35851,7 @@ var teamCommand = new Command("team").description("Resolve and persist team comp
 
 // src/commands/review.ts
 import { spawn as spawn3 } from "node:child_process";
-import { join as join21 } from "node:path";
+import { join as join22 } from "node:path";
 init_db();
 
 // src/lib/vendor-resume.ts
@@ -35147,7 +35890,7 @@ var reviewCommand = new Command("review").description("Run or resume an OCR revi
   }
   const targetDir = process.cwd();
   requireOcrSetup(targetDir);
-  const ocrDir = join21(targetDir, ".ocr");
+  const ocrDir = join22(targetDir, ".ocr");
   const db = await ensureDatabase(ocrDir);
   const session = getSession(db, options.resume);
   if (!session) {
@@ -35189,23 +35932,23 @@ var reviewCommand = new Command("review").description("Run or resume an OCR revi
 });
 
 // src/commands/update.ts
-import { existsSync as existsSync18 } from "node:fs";
-import { join as join22 } from "node:path";
+import { existsSync as existsSync19 } from "node:fs";
+import { join as join23 } from "node:path";
 function detectConfiguredTools(targetDir) {
   return AI_TOOLS.filter((tool) => {
     if (tool.commandStrategy === "subdirectory") {
-      const ocrDir = join22(targetDir, tool.commandsDir, "ocr");
-      return existsSync18(ocrDir);
+      const ocrDir = join23(targetDir, tool.commandsDir, "ocr");
+      return existsSync19(ocrDir);
     } else {
-      const reviewCmd = join22(targetDir, tool.commandsDir, "ocr-review.md");
-      return existsSync18(reviewCmd);
+      const reviewCmd = join23(targetDir, tool.commandsDir, "ocr-review.md");
+      return existsSync19(reviewCmd);
     }
   });
 }
 var updateCommand = new Command("update").description("Update OCR assets after package upgrade").option("--commands", "Update only commands/workflows").option(
   "--skills",
   "Update only skills (includes templates, references, assets)"
-).option("--inject", "Update only AGENTS.md/CLAUDE.md injection").option("--dry-run", "Preview changes without modifying files").action(async (options) => {
+).option("--inject", "Update only instruction-file injection (AGENTS.md + each tool's native file)").option("--dry-run", "Preview changes without modifying files").action(async (options) => {
   const targetDir = process.cwd();
   requireOcrSetup(targetDir);
   console.log();
@@ -35272,7 +36015,7 @@ var updateCommand = new Command("update").description("Update OCR assets after p
         const result = installForTool(tool, targetDir);
         results.push(result);
       }
-      ensureGitignore(join22(targetDir, ".ocr"));
+      ensureGitignore(join23(targetDir, ".ocr"));
       spinner.stop();
       const successful = results.filter((r) => r.success);
       const failed = results.filter((r) => !r.success);
@@ -35306,30 +36049,34 @@ var updateCommand = new Command("update").description("Update OCR assets after p
     }
   }
   if (updateInject) {
+    const planned = plannedInstructionFiles(toolsToUpdate);
     if (options.dryRun) {
       console.log(source_default.dim("  Would update:"));
-      if (existsSync18(join22(targetDir, "AGENTS.md"))) {
-        console.log(source_default.dim("    \u2022 AGENTS.md (OCR managed block)"));
+      for (const path2 of planned) {
+        const verb = existsSync19(join23(targetDir, path2)) ? "update" : "create";
+        console.log(source_default.dim(`    \u2022 ${path2} (${verb} OCR managed block)`));
       }
-      if (existsSync18(join22(targetDir, "CLAUDE.md"))) {
-        console.log(source_default.dim("    \u2022 CLAUDE.md (OCR managed block)"));
+      const staleDry = findStaleInstructionFiles(targetDir, planned);
+      for (const warning of formatStaleWarnings(staleDry, "dry-run")) {
+        console.log(source_default.dim(`    \u2022 ${warning}`));
       }
       console.log();
     } else {
-      const spinner = ora("Updating AGENTS.md/CLAUDE.md...").start();
-      const injectResults = injectIntoProjectFiles(targetDir);
+      const spinner = ora("Updating instruction files...").start();
+      const injectResults = injectIntoProjectFiles(targetDir, toolsToUpdate);
       spinner.stop();
-      if (injectResults.agentsMd || injectResults.claudeMd) {
+      if (injectResults.written.length > 0) {
         console.log(source_default.green("  \u2713 Instructions updated"));
-        if (injectResults.agentsMd) {
-          console.log(`    ${source_default.green("\u2713")} AGENTS.md`);
-        }
-        if (injectResults.claudeMd) {
-          console.log(`    ${source_default.green("\u2713")} CLAUDE.md`);
+        for (const path2 of injectResults.written) {
+          console.log(`    ${source_default.green("\u2713")} ${path2}`);
         }
       } else {
         console.log(source_default.dim("  No instruction files to update"));
       }
+      const stale = findStaleInstructionFiles(targetDir, injectResults.written);
+      for (const warning of formatStaleWarnings(stale, "update")) {
+        console.log(source_default.yellow(`    \u26A0 ${warning}`));
+      }
       console.log();
     }
   }
@@ -35343,14 +36090,15 @@ var updateCommand = new Command("update").description("Update OCR assets after p
 });
 
 // src/commands/dashboard.ts
-import { existsSync as existsSync19 } from "node:fs";
-import { join as join23, dirname as dirname7 } from "node:path";
+import { existsSync as existsSync20 } from "node:fs";
+import { join as join24, dirname as dirname9 } from "node:path";
 import { fileURLToPath } from "node:url";
+init_src();
 init_db();
 var __filename = fileURLToPath(import.meta.url);
-var __dirname = dirname7(__filename);
+var __dirname = dirname9(__filename);
 function resolveServerPath() {
-  return join23(__dirname, "dashboard", "server.js");
+  return join24(__dirname, "dashboard", "server.js");
 }
 var dashboardCommand = new Command("dashboard").description("Start the OCR dashboard web interface").option("-p, --port <port>", "Port to run the server on", "4173").option("--no-open", "Don't open the browser automatically").action(
   async (options) => {
@@ -35361,7 +36109,7 @@ var dashboardCommand = new Command("dashboard").description("Start the OCR dashb
       console.error(source_default.red(`Error: Invalid port "${options.port}". Must be 1-65535.`));
       process.exit(1);
     }
-    const ocrDir = join23(targetDir, ".ocr");
+    const ocrDir = join24(targetDir, ".ocr");
     try {
       await ensureDatabase(ocrDir);
       closeAllDatabases();
@@ -35375,7 +36123,7 @@ var dashboardCommand = new Command("dashboard").description("Start the OCR dashb
       process.exit(1);
     }
     const serverPath = resolveServerPath();
-    if (!existsSync19(serverPath)) {
+    if (!existsSync20(serverPath)) {
       console.error(source_default.red("Error: Dashboard server bundle not found."));
       console.error(
         source_default.dim(`  Expected at: ${serverPath}`)
@@ -35409,11 +36157,53 @@ var dashboardCommand = new Command("dashboard").description("Start the OCR dashb
 );
 
 // src/commands/doctor.ts
-import { existsSync as existsSync20 } from "node:fs";
-import { join as join24 } from "node:path";
+import { existsSync as existsSync21 } from "node:fs";
+import { join as join25 } from "node:path";
 init_db();
-var doctorCommand = new Command("doctor").description("Check OCR installation and verify all dependencies").action(() => {
+function printStorageEngine(probeWriteEnabled) {
+  console.log();
+  console.log(source_default.bold("  Storage Engine"));
+  console.log();
+  const engine = probeEngine();
+  if (!engine.ok) {
+    console.log(`    ${source_default.red("\u2717")} node:sqlite unavailable`);
+    console.log(`      ${source_default.dim(engine.error)}`);
+    console.log(
+      `      ${source_default.dim(
+        "OCR requires Node >= 22.5 (node:sqlite). Upgrade Node, then re-run `ocr doctor`."
+      )}`
+    );
+    return false;
+  }
+  console.log(
+    `    ${source_default.green("\u2713")} node:sqlite (SQLite ${engine.version}, WAL)`
+  );
+  if (probeWriteEnabled) {
+    const write = probeWrite();
+    if (!write.ok) {
+      console.log(`    ${source_default.red("\u2717")} write probe failed`);
+      console.log(`      ${source_default.dim(write.error)}`);
+      return false;
+    }
+    console.log(
+      `    ${source_default.green("\u2713")} write probe (on-disk WAL transaction round-trip)`
+    );
+  }
+  return true;
+}
+var doctorCommand = new Command("doctor").description("Check OCR installation and verify all dependencies").option(
+  "--probe-write",
+  "additionally exercise an on-disk WAL transaction round-trip (used by the release install gate)"
+).option(
+  "--engine-only",
+  "check ONLY the storage engine and exit on its result \u2014 skips project/tool checks (used by the release install gate, which runs from a non-initialized dir with no AI tools)"
+).action((options) => {
   printHeader();
+  if (options.engineOnly) {
+    const ok = printStorageEngine(options.probeWrite ?? false);
+    console.log();
+    process.exit(ok ? 0 : 1);
+  }
   const targetDir = process.cwd();
   let hasIssues = false;
   const depResult = checkDependencies();
@@ -35425,10 +36215,10 @@ var doctorCommand = new Command("doctor").description("Check OCR installation an
   console.log(source_default.bold("  OCR Installation"));
   console.log();
   const ocrStatus = checkOcrSetup(targetDir);
-  const configPath = join24(targetDir, ".ocr", "config.yaml");
-  const dbPath = join24(targetDir, ".ocr", "data", "ocr.db");
-  const hasConfig = existsSync20(configPath);
-  const hasDb = existsSync20(dbPath);
+  const configPath = join25(targetDir, ".ocr", "config.yaml");
+  const dbPath = join25(targetDir, ".ocr", "data", "ocr.db");
+  const hasConfig = existsSync21(configPath);
+  const hasDb = existsSync21(dbPath);
   const ocrChecks = [
     { label: ".ocr/skills/", ok: ocrStatus.hasSkills },
     { label: ".ocr/sessions/", ok: ocrStatus.hasSessions },
@@ -35450,25 +36240,8 @@ var doctorCommand = new Command("doctor").description("Check OCR installation an
   if (!ocrStatus.valid) {
     hasIssues = true;
   }
-  console.log();
-  console.log(source_default.bold("  Storage Engine"));
-  console.log();
-  const engine = probeEngine();
-  if (engine.ok) {
-    console.log(
-      `    ${source_default.green("\u2713")} better-sqlite3 (SQLite ${engine.version}, WAL)`
-    );
-  } else {
+  if (!printStorageEngine(options.probeWrite ?? false)) {
     hasIssues = true;
-    console.log(
-      `    ${source_default.red("\u2717")} better-sqlite3 failed to load`
-    );
-    console.log(`      ${source_default.dim(engine.error)}`);
-    console.log(
-      `      ${source_default.dim(
-        "Reinstall the CLI; if it persists your platform may need build tools (python3 + a C++ toolchain) or lacks a prebuilt binary."
-      )}`
-    );
   }
   console.log();
   printCapabilities(depResult);
@@ -35521,9 +36294,331 @@ var doctorCommand = new Command("doctor").description("Check OCR installation an
   console.log();
 });
 
+// src/commands/db.ts
+import { existsSync as existsSync22, readFileSync as readFileSync14 } from "node:fs";
+import { join as join26 } from "node:path";
+init_src();
+init_db();
+function fail4(message) {
+  console.error(source_default.red(`Error: ${message}`));
+  process.exit(1);
+}
+function resolveOcrDir() {
+  const targetDir = process.cwd();
+  requireOcrSetup(targetDir);
+  return join26(targetDir, ".ocr");
+}
+function dbPathFor(ocrDir) {
+  return join26(ocrDir, "data", "ocr.db");
+}
+function formatBytes(n) {
+  if (n < 1024) return `${n} B`;
+  const units = ["KB", "MB", "GB", "TB"];
+  let v = n / 1024;
+  let i = 0;
+  while (v >= 1024 && i < units.length - 1) {
+    v /= 1024;
+    i++;
+  }
+  return `${v.toFixed(v >= 100 ? 0 : 1)} ${units[i]}`;
+}
+function liveDashboardPid(ocrDir) {
+  const pidFile = join26(ocrDir, "data", "dashboard.pid");
+  if (!existsSync22(pidFile)) return null;
+  try {
+    const pid = parseInt(readFileSync14(pidFile, "utf-8").trim(), 10);
+    if (!Number.isNaN(pid) && isProcessAlive(pid)) return pid;
+  } catch {
+  }
+  return null;
+}
+function guardExclusive(ocrDir, force, op) {
+  const pid = liveDashboardPid(ocrDir);
+  if (pid !== null && !force) {
+    fail4(
+      `a dashboard appears to be running (PID ${pid}); ${op} needs exclusive access to the database.
+  Stop it first, or pass --force to proceed anyway.`
+    );
+  }
+}
+function printHealth(report) {
+  console.log();
+  console.log(source_default.bold("  Database Health"));
+  console.log();
+  console.log(`    File:        ${report.dbPath}`);
+  console.log(`    Size:        ${formatBytes(report.fileSizeBytes)}`);
+  if (report.reclaimableBytes > 0) {
+    console.log(
+      `    Reclaimable: ${source_default.yellow(formatBytes(report.reclaimableBytes))} ` + source_default.dim(`(${report.freelistCount} free pages \u2014 run \`ocr db vacuum\`)`)
+    );
+  }
+  console.log(
+    `    Records:     ${report.sessionCount} session(s), ${report.eventCount} event(s)`
+  );
+  console.log();
+  const ok = (s) => `    ${source_default.green("\u2713")} ${s}`;
+  const bad = (s) => `    ${source_default.red("\u2717")} ${s}`;
+  console.log(
+    report.integrityOk ? ok("integrity_check: ok") : bad(`integrity_check: ${report.integrityErrors.length} error(s)`)
+  );
+  if (!report.integrityOk) {
+    for (const e of report.integrityErrors.slice(0, 5)) {
+      console.log(`        ${source_default.dim(e)}`);
+    }
+  }
+  const fkTotal = report.fkViolations.reduce((n, g) => n + g.count, 0) + report.protectedFkViolations.reduce((n, g) => n + g.count, 0);
+  if (fkTotal === 0) {
+    console.log(ok("foreign_key_check: 0 violations"));
+  } else {
+    console.log(bad(`foreign_key_check: ${fkTotal} violation(s)`));
+    for (const g of report.fkViolations) {
+      console.log(`        ${source_default.dim(`${g.table}: ${g.count} orphan(s)`)}`);
+    }
+    for (const g of report.protectedFkViolations) {
+      console.log(
+        `        ${source_default.yellow(`${g.table}: ${g.count} (protected \u2014 manual review)`)}`
+      );
+    }
+  }
+  if (report.markdownDuplicateRows === 0) {
+    console.log(ok("markdown_artifacts: no duplicates"));
+  } else {
+    console.log(
+      bad(`markdown_artifacts: ${report.markdownDuplicateRows} duplicate row(s)`)
+    );
+  }
+  const reapable = report.orphanTempFiles.filter((f) => f.reapable);
+  if (report.orphanTempFiles.length > 0) {
+    console.log(
+      `    ${reapable.length > 0 ? source_default.yellow("\u26A0") : source_default.dim("\xB7")} orphan temp files: ${report.orphanTempFiles.length} (${reapable.length} reapable)`
+    );
+  }
+  if (report.backupFiles.length > 0) {
+    const total = report.backupFiles.reduce((n, b) => n + b.sizeBytes, 0);
+    console.log(
+      `    ${source_default.dim("\xB7")} backups: ${report.backupFiles.length} (${formatBytes(total)})`
+    );
+  }
+  console.log();
+}
+function needsFix(report) {
+  return !report.integrityOk || report.fkViolations.length > 0 || report.markdownDuplicateRows > 0 || report.orphanTempFiles.some((f) => f.reapable) || report.reclaimableBytes > 0;
+}
+var doctorSubcommand = new Command("doctor").description("Report database health; --fix repairs orphans/dupes and VACUUMs").option("--fix", "apply repairs: FK-orphan sweep, dedup, temp reap, VACUUM").option("--no-snapshot", "skip the pre-fix snapshot (with --fix)").option("--force", "proceed even if a live dashboard owns the database").option("--json", "emit the health report as JSON (implies no --fix)").action(
+  async (options) => {
+    const ocrDir = resolveOcrDir();
+    const dbPath = dbPathFor(ocrDir);
+    const db = await ensureDatabase(ocrDir);
+    if (options.json) {
+      console.log(JSON.stringify(collectDbHealth(db, dbPath), null, 2));
+      return;
+    }
+    const before = collectDbHealth(db, dbPath);
+    printHealth(before);
+    if (!options.fix) {
+      if (needsFix(before)) {
+        console.log(
+          source_default.dim("  Run `ocr db doctor --fix` to repair the issues above.")
+        );
+        console.log();
+      } else {
+        console.log(source_default.green("  \u2713 Database is healthy"));
+        console.log();
+      }
+      return;
+    }
+    guardExclusive(ocrDir, options.force ?? false, "doctor --fix");
+    const result = fixDb(db, dbPath, { snapshot: options.snapshot !== false });
+    console.log(source_default.bold("  Repairs applied"));
+    console.log();
+    if (result.snapshotPath) {
+      console.log(`    ${source_default.dim("snapshot:")} ${result.snapshotPath}`);
+    }
+    if (result.totalFkOrphansDeleted > 0) {
+      console.log(
+        `    ${source_default.green("\u2713")} swept ${result.totalFkOrphansDeleted} FK-orphan row(s)`
+      );
+      for (const g of result.fkOrphansDeleted) {
+        console.log(`        ${source_default.dim(`${g.table}: ${g.count}`)}`);
+      }
+    }
+    if (result.markdownDupsDeleted > 0) {
+      console.log(
+        `    ${source_default.green("\u2713")} removed ${result.markdownDupsDeleted} duplicate markdown row(s)`
+      );
+    }
+    if (result.tempsReaped.length > 0) {
+      console.log(
+        `    ${source_default.green("\u2713")} reaped ${result.tempsReaped.length} orphan temp file(s)`
+      );
+    }
+    if (result.vacuumed) {
+      const saved = result.sizeBeforeBytes - result.sizeAfterBytes;
+      console.log(
+        `    ${source_default.green("\u2713")} VACUUM: ${formatBytes(result.sizeBeforeBytes)} \u2192 ${formatBytes(result.sizeAfterBytes)} ` + source_default.dim(`(reclaimed ${formatBytes(Math.max(0, saved))})`)
+      );
+    }
+    console.log();
+    if (result.protectedViolationsRemaining.length > 0) {
+      console.log(
+        source_default.yellow(
+          "  \u26A0 Violations remain in protected (system-of-record) tables:"
+        )
+      );
+      for (const g of result.protectedViolationsRemaining) {
+        console.log(`        ${source_default.yellow(`${g.table}: ${g.count}`)}`);
+      }
+      console.log();
+    }
+    if (result.integrityOkAfter && result.fkViolationsAfter === 0) {
+      console.log(source_default.green("  \u2713 Database repaired and healthy"));
+    } else {
+      console.log(
+        source_default.red(
+          `  \u2717 Post-fix check: integrity ${result.integrityOkAfter ? "ok" : "FAILED"}, ${result.fkViolationsAfter} FK violation(s) remaining`
+        )
+      );
+      process.exitCode = 1;
+    }
+    console.log();
+  }
+);
+var vacuumSubcommand = new Command("vacuum").description("Checkpoint the WAL and VACUUM the database (snapshot-first)").option("--no-snapshot", "skip the pre-vacuum snapshot").option("--force", "proceed even if a live dashboard owns the database").action(async (options) => {
+  const ocrDir = resolveOcrDir();
+  const dbPath = dbPathFor(ocrDir);
+  guardExclusive(ocrDir, options.force ?? false, "vacuum");
+  const db = await ensureDatabase(ocrDir);
+  const result = vacuumDb(db, dbPath, { snapshot: options.snapshot !== false });
+  console.log();
+  if (result.snapshotPath) {
+    console.log(`    ${source_default.dim("snapshot:")} ${result.snapshotPath}`);
+  }
+  console.log(
+    `    ${source_default.green("\u2713")} VACUUM: ${formatBytes(result.sizeBeforeBytes)} \u2192 ${formatBytes(result.sizeAfterBytes)} ` + source_default.dim(`(reclaimed ${formatBytes(result.reclaimedBytes)})`)
+  );
+  console.log();
+});
+var pruneSubcommand = new Command("prune").description(
+  "Drop derived artifacts of old CLOSED sessions (events + sessions kept)"
+).option(
+  "--keep-sessions <n>",
+  "protect the N most-recently-active closed sessions",
+  (v) => parseInt(v, 10)
+).option(
+  "--older-than <days>",
+  "only prune closed sessions quiet for more than D days",
+  (v) => parseInt(v, 10)
+).option("--dry-run", "show what would be pruned without deleting").option("--force", "proceed even if a live dashboard owns the database").action(
+  async (options) => {
+    const ocrDir = resolveOcrDir();
+    const dbPath = dbPathFor(ocrDir);
+    if (options.keepSessions === void 0 && options.olderThan === void 0) {
+      fail4(
+        "prune needs a bound: pass --older-than <days> and/or --keep-sessions <n>."
+      );
+    }
+    if (!options.dryRun) {
+      guardExclusive(ocrDir, options.force ?? false, "prune");
+    }
+    const db = await ensureDatabase(ocrDir);
+    const result = pruneDb(db, dbPath, {
+      keepSessions: options.keepSessions,
+      olderThanDays: options.olderThan,
+      dryRun: options.dryRun ?? false
+    });
+    console.log();
+    if (result.prunedSessions.length === 0) {
+      console.log(source_default.green("  \u2713 Nothing to prune"));
+      console.log();
+      return;
+    }
+    const verb = result.dryRun ? "Would prune" : "Pruned";
+    console.log(
+      source_default.bold(
+        `  ${verb} ${result.totalArtifactRows} artifact row(s) across ${result.prunedSessions.length} session(s)`
+      )
+    );
+    console.log();
+    for (const p of result.prunedSessions.slice(0, 20)) {
+      console.log(
+        `    ${source_default.dim("\xB7")} ${p.sessionId} ${source_default.dim(`(${p.artifactRows} rows)`)}`
+      );
+    }
+    if (result.prunedSessions.length > 20) {
+      console.log(
+        `    ${source_default.dim(`\u2026 and ${result.prunedSessions.length - 20} more`)}`
+      );
+    }
+    console.log();
+    if (result.snapshotPath) {
+      console.log(`    ${source_default.dim("snapshot:")} ${result.snapshotPath}`);
+    }
+    console.log(
+      source_default.dim(
+        result.dryRun ? "  Re-run without --dry-run to apply. Events + session rows are always kept." : "  Events + session rows were kept; sessions remain fully auditable."
+      )
+    );
+    console.log();
+  }
+);
+function validatePruneBackupsOptions(options) {
+  if (!Number.isInteger(options.keep) || options.keep < 0) {
+    return `--keep must be a non-negative integer (got "${String(options.keep)}").`;
+  }
+  if (options.keep === 0 && !options.force && !options.dryRun) {
+    return "--keep 0 removes every backup (including any just-written snapshot). Re-run with --dry-run to preview, or --force to confirm.";
+  }
+  return null;
+}
+var pruneBackupsSubcommand = new Command("prune-backups").description("Delete old ocr.db.bak.* snapshots, keeping the most recent few").option(
+  "--keep <n>",
+  "retain the N most-recent backups (default 1; 0 removes all, requires --force)",
+  // Raw conversion only — `Number('oops')` is NaN and flows into
+  // validatePruneBackupsOptions, the single validation home. (parseInt would
+  // also silently accept "3abc" → 3; Number rejects it as NaN.)
+  (v) => Number(v),
+  1
+).option("--force", "permit --keep 0 (removing the last backup / safety net)").option("--dry-run", "show what would be deleted without deleting").action(async (options) => {
+  const ocrDir = resolveOcrDir();
+  const dataDir = join26(ocrDir, "data");
+  const invalid = validatePruneBackupsOptions(options);
+  if (invalid !== null) {
+    fail4(invalid);
+  }
+  const result = pruneBackups(dataDir, dbPathFor(ocrDir), {
+    keep: options.keep,
+    dryRun: options.dryRun ?? false
+  });
+  console.log();
+  if (result.deleted.length === 0) {
+    console.log(source_default.green("  \u2713 No backups to remove"));
+    console.log();
+    return;
+  }
+  const verb = result.dryRun ? "Would delete" : "Deleted";
+  console.log(
+    source_default.bold(
+      `  ${verb} ${result.deleted.length} backup(s) \u2014 ${formatBytes(result.reclaimedBytes)}`
+    )
+  );
+  console.log();
+  for (const b of result.deleted) {
+    console.log(`    ${source_default.dim("\xB7")} ${b.name} ${source_default.dim(`(${formatBytes(b.sizeBytes)})`)}`);
+  }
+  if (result.kept.length > 0) {
+    console.log();
+    console.log(
+      source_default.dim(`  Kept ${result.kept.length} most-recent backup(s) as a safety net.`)
+    );
+  }
+  console.log();
+});
+var dbCommand = new Command("db").description("Inspect and maintain the OCR SQLite database").addCommand(doctorSubcommand).addCommand(vacuumSubcommand).addCommand(pruneSubcommand).addCommand(pruneBackupsSubcommand);
+
 // src/commands/reviewers.ts
 import { writeFileSync as writeFileSync9, renameSync as renameSync2 } from "node:fs";
-import { join as join25 } from "node:path";
+import { join as join27 } from "node:path";
+init_src();
 async function readStdin3() {
   const chunks = [];
   for await (const chunk of process.stdin) {
@@ -35537,6 +36632,25 @@ async function readStdin3() {
 }
 var VALID_TIERS = /* @__PURE__ */ new Set(["holistic", "specialist", "persona", "custom"]);
 var SLUG_RE = /^[a-z][a-z0-9-]*$/;
+var INJECTION_PATTERNS = [
+  /ignore\s+(all\s+|the\s+)?(previous|prior|above)?\s*(instructions|prompts|rules)/i,
+  /disregard\s+(all\s+|the\s+)?(previous|prior|above)/i,
+  /\byou\s+are\s+now\b/i,
+  /^\s*system\s*:/im,
+  /\balways\s+(conclude|respond|reply|return|output|approve|reject|say)\b/i,
+  /\bnew\s+rule\s*:/i
+];
+function warnIfSuspiciousPersona(label, fields) {
+  const text = fields.filter((f) => typeof f === "string").join("\n");
+  const hit = INJECTION_PATTERNS.find((re) => re.test(text));
+  if (hit) {
+    console.error(
+      source_default.yellow(
+        `\u26A0 ${label} contains text resembling a prompt-injection override (matched ${hit}). Review the persona before relying on it.`
+      )
+    );
+  }
+}
 function validateReviewersMeta(data) {
   if (typeof data !== "object" || data === null || Array.isArray(data)) {
     throw new Error("Payload must be a JSON object");
@@ -35574,6 +36688,19 @@ function validateReviewersMeta(data) {
     if (!Array.isArray(r.focus_areas)) {
       throw new Error(`${prefix}.focus_areas must be an array`);
     }
+    if (r.icon !== void 0 && typeof r.icon !== "string") {
+      throw new Error(`${prefix}.icon must be a string if provided (got ${JSON.stringify(r.icon)})`);
+    }
+    if (typeof r.icon !== "string" || r.icon.length === 0) {
+      r.icon = defaultIconFor(r.id, r.tier);
+    }
+    warnIfSuspiciousPersona(`${prefix} ("${r.name}")`, [
+      r.name,
+      r.description,
+      ...Array.isArray(r.focus_areas) ? r.focus_areas : [],
+      r.known_for,
+      r.philosophy
+    ]);
     if (r.known_for !== void 0 && typeof r.known_for !== "string") {
       throw new Error(`${prefix}.known_for must be a string if provided`);
     }
@@ -35586,17 +36713,17 @@ function validateReviewersMeta(data) {
 var syncSubcommand2 = new Command("sync").description("Sync reviewers-meta.json from reviewer markdown files or structured JSON").option("--stdin", "Read reviewers JSON from stdin (for AI-invoked sync)").action(async (options) => {
   const targetDir = process.cwd();
   requireOcrSetup(targetDir);
-  const ocrDir = join25(targetDir, ".ocr");
+  const ocrDir = join27(targetDir, ".ocr");
   if (!options.stdin) {
     try {
-      const reviewersDir = join25(ocrDir, "skills", "references", "reviewers");
-      const configPath = join25(ocrDir, "config.yaml");
+      const reviewersDir = join27(ocrDir, "skills", "references", "reviewers");
+      const configPath = join27(ocrDir, "config.yaml");
       const meta = generateReviewersMeta(reviewersDir, configPath);
       if (!meta || meta.reviewers.length === 0) {
         console.error(source_default.yellow("No reviewer files found in .ocr/skills/references/reviewers/"));
         process.exit(1);
       }
-      const metaPath = join25(ocrDir, "reviewers-meta.json");
+      const metaPath = join27(ocrDir, "reviewers-meta.json");
       const tmpPath = metaPath + ".tmp";
       writeFileSync9(tmpPath, JSON.stringify(meta, null, 2) + "\n");
       renameSync2(tmpPath, metaPath);
@@ -35626,7 +36753,7 @@ var syncSubcommand2 = new Command("sync").description("Sync reviewers-meta.json
       throw new Error("Invalid JSON on stdin");
     }
     const meta = validateReviewersMeta(parsed);
-    const metaPath = join25(ocrDir, "reviewers-meta.json");
+    const metaPath = join27(ocrDir, "reviewers-meta.json");
     const tmpPath = metaPath + ".tmp";
     writeFileSync9(tmpPath, JSON.stringify(meta, null, 2) + "\n");
     renameSync2(tmpPath, metaPath);
@@ -35652,26 +36779,74 @@ var syncSubcommand2 = new Command("sync").description("Sync reviewers-meta.json
 });
 var reviewersCommand = new Command("reviewers").description("Manage OCR reviewer metadata").addCommand(syncSubcommand2);
 
+// src/commands/host.ts
+function describeRow(id) {
+  const tool = getToolById(id);
+  const caps = getHostCapabilities(id);
+  return {
+    id,
+    name: tool?.name ?? id,
+    subagentSpawn: caps.subagentSpawn,
+    perTaskModel: caps.perTaskModel,
+    phase4: caps.subagentSpawn ? "parallel-subagents" : "sequential"
+  };
+}
+var capabilitiesSubcommand = new Command("capabilities").description("Print host (AI CLI) Phase-4 capabilities").option("--tool <id>", "Show capabilities for a single tool id").option("--json", "Output JSON").action((options) => {
+  if (options.tool) {
+    const id = options.tool.trim().toLowerCase();
+    if (!getToolIds().includes(id)) {
+      console.error(
+        source_default.red(
+          `Error: unknown tool id "${options.tool}". Valid ids: ${getToolIds().join(", ")}`
+        )
+      );
+      process.exit(1);
+    }
+    const row = describeRow(id);
+    if (options.json) {
+      console.log(JSON.stringify(row, null, 2));
+    } else {
+      printRows([row]);
+    }
+    return;
+  }
+  const rows = AI_TOOLS.map((t) => describeRow(t.id));
+  if (options.json) {
+    console.log(JSON.stringify(rows, null, 2));
+  } else {
+    printRows(rows);
+  }
+});
+function printRows(rows) {
+  const yn = (v) => v ? source_default.green("yes") : source_default.dim("no");
+  for (const row of rows) {
+    console.log(
+      `${source_default.bold(row.name.padEnd(20))} subagentSpawn=${yn(row.subagentSpawn)}  perTaskModel=${yn(row.perTaskModel)}  \u2192 ${source_default.cyan(row.phase4)}`
+    );
+  }
+}
+var hostCommand = new Command("host").description("Inspect host (AI CLI) capabilities").addCommand(capabilitiesSubcommand);
+
 // src/lib/update-check.ts
 import { homedir } from "node:os";
-import { join as join26 } from "node:path";
-import { readFileSync as readFileSync14, writeFileSync as writeFileSync10, mkdirSync as mkdirSync7 } from "node:fs";
+import { join as join28 } from "node:path";
+import { readFileSync as readFileSync15, writeFileSync as writeFileSync10, mkdirSync as mkdirSync8 } from "node:fs";
 var PACKAGE_NAME = "@open-code-review/cli";
 var REGISTRY_URL = `https://registry.npmjs.org/${PACKAGE_NAME}/latest`;
-var CACHE_DIR2 = join26(homedir(), ".ocr");
-var CACHE_FILE = join26(CACHE_DIR2, "update-check.json");
+var CACHE_DIR2 = join28(homedir(), ".ocr");
+var CACHE_FILE = join28(CACHE_DIR2, "update-check.json");
 var CHECK_INTERVAL_MS = 4 * 60 * 60 * 1e3;
 var FETCH_TIMEOUT_MS = 3e3;
 function readCache(cacheFile) {
   try {
-    return JSON.parse(readFileSync14(cacheFile, "utf-8"));
+    return JSON.parse(readFileSync15(cacheFile, "utf-8"));
   } catch {
     return null;
   }
 }
 function writeCache(cacheFile, cache) {
   try {
-    mkdirSync7(join26(cacheFile, ".."), { recursive: true });
+    mkdirSync8(join28(cacheFile, ".."), { recursive: true });
     writeFileSync10(cacheFile, JSON.stringify(cache));
   } catch {
   }
@@ -35692,7 +36867,7 @@ async function checkForUpdate(currentVersion, options) {
   if (process.env.CI || process.env.OCR_NO_UPDATE_CHECK) {
     return null;
   }
-  const cacheFile = join26(options?.cacheDir ?? CACHE_DIR2, "update-check.json");
+  const cacheFile = join28(options?.cacheDir ?? CACHE_DIR2, "update-check.json");
   try {
     const cache = readCache(cacheFile);
     if (cache && Date.now() - cache.lastCheck < CHECK_INTERVAL_MS) {
@@ -35751,7 +36926,9 @@ program2.addCommand(reviewCommand);
 program2.addCommand(updateCommand);
 program2.addCommand(dashboardCommand);
 program2.addCommand(doctorCommand);
+program2.addCommand(dbCommand);
 program2.addCommand(reviewersCommand);
+program2.addCommand(hostCommand);
 await program2.parseAsync();
 if (subcommand && HUMAN_COMMANDS.has(subcommand)) {
   const drift = checkLocalArtifactVersion(process.cwd(), CLI_VERSION);