@open-code-review/cli 2.1.0 → 2.2.0

package/dist/lib/db/index.js

@@ -1,14 +1,14 @@
 // src/lib/db/index.ts
 import {
-  existsSync as existsSync3,
+  existsSync as existsSync4,
   mkdirSync as mkdirSync2,
-  copyFileSync,
-  statSync,
+  copyFileSync as copyFileSync2,
+  statSync as statSync2,
   mkdtempSync,
   rmSync
 } from "node:fs";
 import { tmpdir } from "node:os";
-import { dirname as dirname3, join as join3 } from "node:path";
+import { dirname as dirname4, join as join4 } from "node:path";
 
 // src/lib/db/engine.ts
 import { createRequire } from "node:module";
@@ -669,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) {
@@ -1029,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";
@@ -1399,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";
@@ -1412,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++;
@@ -1431,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")) {
@@ -1501,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;
@@ -1539,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);
@@ -1548,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 {
@@ -1584,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);
@@ -1626,8 +2076,8 @@ function closeAllDatabases() {
 function probeWrite() {
   let dir;
   try {
-    dir = mkdtempSync(join3(tmpdir(), "ocr-probe-"));
-    const db = openEngine(join3(dir, "probe.db"));
+    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(() => {
@@ -1666,6 +2116,7 @@ export {
   PID_REUSE_GUARD_MS,
   STATE_EXIT,
   StateError,
+  WATCHDOG_DEADLINE_EXIT_CODE,
   appendCommandLog,
   bindVendorSessionIdOpportunistically,
   bumpAgentSessionHeartbeat,
@@ -1673,10 +2124,12 @@ export {
   cascadeTerminateExecutions,
   closeAllDatabases,
   closeDatabase,
+  collectDbHealth,
   commandLogPath,
   commitReasonClose,
   defaultIsAlive,
   ensureDatabase,
+  fixDb,
   formatUpgradeNotice,
   generateCommandUid,
   getAgentSession,
@@ -1688,6 +2141,7 @@ export {
   getLatestEventId,
   getSchemaVersion,
   getSession,
+  hasInFlightDependents,
   insertAgentSession,
   insertEvent,
   insertSession,
@@ -1697,7 +2151,11 @@ export {
   openDatabase,
   probeEngine,
   probeWrite,
+  pruneBackups,
+  pruneDb,
   readCommandLog,
+  reapOrphanDbFiles,
+  reapStaleExecLogs,
   reconcileLegacyState,
   recordVendorSessionIdForExecution,
   replayCommandLog,
@@ -1707,10 +2165,13 @@ export {
   runMigrations,
   setAgentSessionStatus,
   setAgentSessionVendorId,
+  snapshotDb,
   sqliteUtcMs,
   sweepStaleAgentSessions,
   sweepStaleSessions,
   updateAgentSession,
   updateSession,
-  walCheckpointTruncate
+  vacuumDb,
+  walCheckpointTruncate,
+  withForeignKeysDisabled
 };

package/dist/lib/runtime-config.js

@@ -2,38 +2,54 @@
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 var DEFAULT_AGENT_HEARTBEAT_SECONDS = 60;
-function getAgentHeartbeatSeconds(ocrDir) {
+var DEFAULT_WORKFLOW_HARD_DEADLINE_MINUTES = 60;
+function readRuntimePositiveInt(ocrDir, key, defaultValue) {
   const configPath = join(ocrDir, "config.yaml");
-  if (!existsSync(configPath)) {
-    return DEFAULT_AGENT_HEARTBEAT_SECONDS;
-  }
+  if (!existsSync(configPath)) return defaultValue;
   let content;
   try {
     content = readFileSync(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
+  );
+}
+function getWorkflowHardDeadlineMs(ocrDir) {
+  return readRuntimePositiveInt(
+    ocrDir,
+    "workflow_hard_deadline_minutes",
+    DEFAULT_WORKFLOW_HARD_DEADLINE_MINUTES
+  ) * 60 * 1e3;
+}
 export {
   DEFAULT_AGENT_HEARTBEAT_SECONDS,
-  getAgentHeartbeatSeconds
+  DEFAULT_WORKFLOW_HARD_DEADLINE_MINUTES,
+  getAgentHeartbeatSeconds,
+  getWorkflowHardDeadlineMs
 };