@open-code-review/cli 2.0.0 → 2.2.0

package/dist/lib/db/index.js

@@ -1,35 +1,97 @@
 // src/lib/db/index.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, copyFileSync, statSync } from "node:fs";
-import { dirname as dirname3, join as join3 } from "node:path";
+import {
+  existsSync as existsSync4,
+  mkdirSync as mkdirSync2,
+  copyFileSync as copyFileSync2,
+  statSync as statSync2,
+  mkdtempSync,
+  rmSync
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname as dirname4, join as join4 } from "node:path";
 
 // src/lib/db/engine.ts
-import BetterSqlite3 from "better-sqlite3";
+import { createRequire } from "node:module";
+
+// src/lib/runtime-checks.ts
+var NODE_FLOOR = { major: 22, minor: 5 };
+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");
+}
+
+// src/lib/db/engine.ts
+var SQLITE_BUSY = 5;
+var SQLITE_BUSY_SNAPSHOT = 261;
 var BUSY_RETRY_ATTEMPTS = 5;
 var BUSY_RETRY_BACKOFF_MS = 50;
-function isBusyError(e) {
-  if (e instanceof BetterSqlite3.SqliteError) {
-    return e.code === "SQLITE_BUSY" || e.code === "SQLITE_BUSY_SNAPSHOT";
+var savepointName = (depth) => `ocr_sp_${depth}`;
+var nodeRequire = createRequire(import.meta.url);
+var _preconditionsApplied = false;
+function applyEnginePreconditions() {
+  if (_preconditionsApplied) return;
+  _preconditionsApplied = true;
+  const originalEmitWarning = process.emitWarning.bind(process);
+  process.emitWarning = (warning, ...args) => {
+    if (isSuppressibleSqliteWarning(warning)) return;
+    originalEmitWarning(warning, ...args);
+  };
+}
+var _DatabaseSyncCtor;
+function newDatabase(path) {
+  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(path);
+}
+function isBusyError(e) {
+  const errcode = e?.errcode;
+  return errcode === SQLITE_BUSY || errcode === SQLITE_BUSY_SNAPSHOT;
 }
+var SLEEP_BUF = new Int32Array(new SharedArrayBuffer(4));
 function sleepSync(ms) {
-  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+  Atomics.wait(SLEEP_BUF, 0, 0, ms);
 }
-var BetterSqliteAdapter = class {
+var 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) {
@@ -42,31 +104,90 @@ var BetterSqliteAdapter = class {
     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 {
+        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 tx.immediate();
+        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;
+    }
   }
 };
 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();
@@ -76,12 +197,12 @@ 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);
+  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);
 }
 
 // src/lib/db/migrations.ts
@@ -548,6 +669,35 @@ var MIGRATIONS = [
       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)
+      `);
+    }
   }
 ];
 function columnExists(db, table, column) {
@@ -908,6 +1058,7 @@ var StateError = class extends Error {
 var CANCELLED_EXIT_CODE = -2;
 var ORPHAN_EXIT_CODE = -3;
 var CASCADE_CLOSE_EXIT_CODE = -4;
+var WATCHDOG_DEADLINE_EXIT_CODE = -5;
 
 // src/lib/db/agent-sessions.ts
 var NOTE_ORPHAN_PREFIX = "orphaned by liveness sweep";
@@ -1278,9 +1429,429 @@ function sweepStaleSessions(db, thresholdSeconds) {
   return { closedSessionIds: rows.map((r) => r.id) };
 }
 
+// src/lib/db/maintenance.ts
+import {
+  existsSync as existsSync2,
+  readdirSync,
+  statSync,
+  unlinkSync,
+  copyFileSync
+} from "node:fs";
+import { dirname as dirname2, join as join2, basename } from "node:path";
+
+// ../shared/platform/src/index.ts
+import {
+  execFile,
+  execFileSync,
+  spawn
+} from "node:child_process";
+import { promisify } from "node:util";
+var execFilePromise = promisify(execFile);
+var isWindows = process.platform === "win32";
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return !(err instanceof Error && "code" in err && err.code === "ESRCH");
+  }
+}
+
+// src/lib/db/maintenance.ts
+var PROTECTED_TABLES = /* @__PURE__ */ new Set([
+  "sessions",
+  "orchestration_events",
+  "agent_sessions",
+  "command_executions",
+  "schema_version"
+]);
+var 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)"
+  }
+];
+var 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
+   )`;
+var ONE_HOUR_MS = 60 * 60 * 1e3;
+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 = readdirSync(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(join2(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 = readdirSync(dataDir);
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const name of entries) {
+    if (!name.startsWith(`${dbBase}.bak`)) continue;
+    try {
+      out.push({ name, sizeBytes: statSync(join2(dataDir, name)).size });
+    } catch {
+    }
+  }
+  return out.sort((a, b) => b.sizeBytes - a.sizeBytes);
+}
+function collectDbHealth(db, dbPath) {
+  const dataDir = dirname2(dbPath);
+  const dbBase = basename(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 = existsSync2(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 (!existsSync2(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 {
+      unlinkSync(join2(dataDir, f.name));
+      reaped.push(f.name);
+    } catch {
+    }
+  }
+  return reaped;
+}
+var SEVEN_DAYS_MS = 7 * 24 * 60 * 60 * 1e3;
+function reapStaleExecLogs(execLogsDir, maxAgeMs = SEVEN_DAYS_MS) {
+  let entries;
+  try {
+    entries = readdirSync(execLogsDir);
+  } catch {
+    return [];
+  }
+  const cutoff = Date.now() - maxAgeMs;
+  const reaped = [];
+  for (const name of entries) {
+    if (!name.endsWith(".log")) continue;
+    const full = join2(execLogsDir, name);
+    try {
+      if (statSync(full).mtimeMs > cutoff) continue;
+      unlinkSync(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 = basename(dbPath);
+  const withMtime = [];
+  for (const file of scanBackupFiles(dataDir, dbBase)) {
+    try {
+      withMtime.push({ file, mtimeMs: statSync(join2(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 {
+        unlinkSync(join2(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 = dirname2(dbPath);
+  const sizeBeforeBytes = existsSync2(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 = existsSync2(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 = existsSync2(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)
+  };
+}
+
 // src/lib/db/command-log.ts
-import { appendFileSync, existsSync as existsSync2, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
-import { dirname as dirname2, join as join2 } from "node:path";
+import { appendFileSync, existsSync as existsSync3, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname as dirname3, join as join3 } from "node:path";
 import { randomUUID } from "node:crypto";
 var CACHE_DIR = ".cache";
 var FILENAME = "command-history.jsonl";
@@ -1291,16 +1862,16 @@ function generateCommandUid() {
   return randomUUID();
 }
 function cacheDir(ocrDir) {
-  return join2(ocrDir, "data", CACHE_DIR);
+  return join3(ocrDir, "data", CACHE_DIR);
 }
 function commandLogPath(ocrDir) {
-  return join2(cacheDir(ocrDir), FILENAME);
+  return join3(cacheDir(ocrDir), FILENAME);
 }
 function appendCommandLog(ocrDir, entry) {
   try {
     const filePath = commandLogPath(ocrDir);
-    const dir = dirname2(filePath);
-    if (!existsSync2(dir)) mkdirSync(dir, { recursive: true });
+    const dir = dirname3(filePath);
+    if (!existsSync3(dir)) mkdirSync(dir, { recursive: true });
     const line = JSON.stringify(entry) + "\n";
     appendFileSync(filePath, line, { encoding: "utf-8" });
     if (approxLineCount >= 0) approxLineCount++;
@@ -1310,7 +1881,7 @@ function appendCommandLog(ocrDir, entry) {
 }
 function readCommandLog(ocrDir) {
   const filePath = commandLogPath(ocrDir);
-  if (!existsSync2(filePath)) return [];
+  if (!existsSync3(filePath)) return [];
   const content = readFileSync(filePath, "utf-8");
   const entries = [];
   for (const line of content.split("\n")) {
@@ -1380,11 +1951,11 @@ var V2_SCHEMA_VERSION = 12;
 function maybeSnapshotBeforeUpgrade(db, dbPath, fromVersion) {
   if (fromVersion < 1 || fromVersion >= V2_SCHEMA_VERSION) return null;
   const bakPath = `${dbPath}.bak.v${fromVersion}`;
-  if (existsSync3(bakPath)) return bakPath;
+  if (existsSync4(bakPath)) return bakPath;
   try {
-    if (!existsSync3(dbPath) || statSync(dbPath).size === 0) return null;
+    if (!existsSync4(dbPath) || statSync2(dbPath).size === 0) return null;
     db.pragma("wal_checkpoint(TRUNCATE)");
-    copyFileSync(dbPath, bakPath);
+    copyFileSync2(dbPath, bakPath);
     return bakPath;
   } catch {
     return null;
@@ -1418,8 +1989,8 @@ async function openDatabase(dbPath) {
   if (cached) {
     return cached;
   }
-  const dir = dirname3(dbPath);
-  if (!existsSync3(dir)) {
+  const dir = dirname4(dbPath);
+  if (!existsSync4(dir)) {
     mkdirSync2(dir, { recursive: true });
   }
   const db = openEngine(dbPath);
@@ -1427,15 +1998,15 @@ async function openDatabase(dbPath) {
   return db;
 }
 async function getDb(ocrDir) {
-  const dbPath = join3(ocrDir, "data", "ocr.db");
+  const dbPath = join4(ocrDir, "data", "ocr.db");
   return openDatabase(dbPath);
 }
 async function ensureDatabase(ocrDir) {
-  const dataDir = join3(ocrDir, "data");
-  if (!existsSync3(dataDir)) {
+  const dataDir = join4(ocrDir, "data");
+  if (!existsSync4(dataDir)) {
     mkdirSync2(dataDir, { recursive: true });
   }
-  const dbPath = join3(dataDir, "ocr.db");
+  const dbPath = join4(dataDir, "ocr.db");
   const db = await openDatabase(dbPath);
   let before = 0;
   try {
@@ -1463,7 +2034,7 @@ async function ensureDatabase(ocrDir) {
   return db;
 }
 function walCheckpointTruncate(dbPath) {
-  if (!existsSync3(dbPath)) {
+  if (!existsSync4(dbPath)) {
     return "skipped";
   }
   const cached = connections.get(dbPath);
@@ -1484,7 +2055,7 @@ function walCheckpointTruncate(dbPath) {
     return "failed";
   } finally {
     try {
-      transient?.raw.close();
+      transient?.close();
     } catch {
     }
   }
@@ -1502,6 +2073,41 @@ function closeAllDatabases() {
     connections.delete(path);
   }
 }
+function probeWrite() {
+  let dir;
+  try {
+    dir = mkdtempSync(join4(tmpdir(), "ocr-probe-"));
+    const db = openEngine(join4(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);
+    }
+  }
+}
 export {
   CANCELLED_EXIT_CODE,
   CASCADE_CLOSE_EXIT_CODE,
@@ -1510,6 +2116,7 @@ export {
   PID_REUSE_GUARD_MS,
   STATE_EXIT,
   StateError,
+  WATCHDOG_DEADLINE_EXIT_CODE,
   appendCommandLog,
   bindVendorSessionIdOpportunistically,
   bumpAgentSessionHeartbeat,
@@ -1517,10 +2124,12 @@ export {
   cascadeTerminateExecutions,
   closeAllDatabases,
   closeDatabase,
+  collectDbHealth,
   commandLogPath,
   commitReasonClose,
   defaultIsAlive,
   ensureDatabase,
+  fixDb,
   formatUpgradeNotice,
   generateCommandUid,
   getAgentSession,
@@ -1532,6 +2141,7 @@ export {
   getLatestEventId,
   getSchemaVersion,
   getSession,
+  hasInFlightDependents,
   insertAgentSession,
   insertEvent,
   insertSession,
@@ -1540,7 +2150,12 @@ export {
   listAgentSessionsForWorkflow,
   openDatabase,
   probeEngine,
+  probeWrite,
+  pruneBackups,
+  pruneDb,
   readCommandLog,
+  reapOrphanDbFiles,
+  reapStaleExecLogs,
   reconcileLegacyState,
   recordVendorSessionIdForExecution,
   replayCommandLog,
@@ -1550,10 +2165,13 @@ export {
   runMigrations,
   setAgentSessionStatus,
   setAgentSessionVendorId,
+  snapshotDb,
   sqliteUtcMs,
   sweepStaleAgentSessions,
   sweepStaleSessions,
   updateAgentSession,
   updateSession,
-  walCheckpointTruncate
+  vacuumDb,
+  walCheckpointTruncate,
+  withForeignKeysDisabled
 };