@open-code-review/cli 2.0.0 → 2.2.0

package/dist/dashboard/server.js

@@ -1579,14 +1579,14 @@ var require_internal = __commonJS({
     }
     InternalCodec.prototype.encoder = InternalEncoder;
     InternalCodec.prototype.decoder = InternalDecoder;
-    var StringDecoder = __require("string_decoder").StringDecoder;
-    if (!StringDecoder.prototype.end)
-      StringDecoder.prototype.end = function() {
+    var StringDecoder2 = __require("string_decoder").StringDecoder;
+    if (!StringDecoder2.prototype.end)
+      StringDecoder2.prototype.end = function() {
       };
     function InternalDecoder(options, codec) {
-      StringDecoder.call(this, codec.enc);
+      StringDecoder2.call(this, codec.enc);
     }
-    InternalDecoder.prototype = StringDecoder.prototype;
+    InternalDecoder.prototype = StringDecoder2.prototype;
     function InternalEncoder(options, codec) {
       this.enc = codec.enc;
     }
@@ -18410,10 +18410,10 @@ var require_view = __commonJS({
     var debug = require_src()("express:view");
     var path2 = __require("path");
     var fs6 = __require("fs");
-    var dirname14 = path2.dirname;
-    var basename4 = path2.basename;
+    var dirname15 = path2.dirname;
+    var basename5 = path2.basename;
     var extname = path2.extname;
-    var join19 = path2.join;
+    var join20 = path2.join;
     var resolve3 = path2.resolve;
     module.exports = View;
     function View(name, options) {
@@ -18449,8 +18449,8 @@ var require_view = __commonJS({
       for (var i = 0; i < roots.length && !path3; i++) {
         var root = roots[i];
         var loc = resolve3(root, name);
-        var dir = dirname14(loc);
-        var file = basename4(loc);
+        var dir = dirname15(loc);
+        var file = basename5(loc);
         path3 = this.resolve(dir, file);
       }
       return path3;
@@ -18461,12 +18461,12 @@ var require_view = __commonJS({
     };
     View.prototype.resolve = function resolve4(dir, file) {
       var ext = this.ext;
-      var path3 = join19(dir, file);
+      var path3 = join20(dir, file);
       var stat = tryStat(path3);
       if (stat && stat.isFile()) {
         return path3;
       }
-      path3 = join19(dir, basename4(file, ext), "index" + ext);
+      path3 = join20(dir, basename5(file, ext), "index" + ext);
       stat = tryStat(path3);
       if (stat && stat.isFile()) {
         return path3;
@@ -18547,7 +18547,7 @@ var require_content_disposition = __commonJS({
     "use strict";
     module.exports = contentDisposition;
     module.exports.parse = parse;
-    var basename4 = __require("path").basename;
+    var basename5 = __require("path").basename;
     var Buffer3 = require_safe_buffer().Buffer;
     var ENCODE_URL_ATTR_CHAR_REGEXP = /[\x00-\x20"'()*,/:;<=>?@[\\\]{}\x7f]/g;
     var HEX_ESCAPE_REGEXP = /%[0-9A-Fa-f]{2}/;
@@ -18583,9 +18583,9 @@ var require_content_disposition = __commonJS({
       if (typeof fallback === "string" && NON_LATIN1_REGEXP.test(fallback)) {
         throw new TypeError("fallback must be ISO-8859-1 string");
       }
-      var name = basename4(filename);
+      var name = basename5(filename);
       var isQuotedString = TEXT_REGEXP.test(name);
-      var fallbackName = typeof fallback !== "string" ? fallback && getlatin1(name) : basename4(fallback);
+      var fallbackName = typeof fallback !== "string" ? fallback && getlatin1(name) : basename5(fallback);
       var hasFallback = typeof fallbackName === "string" && fallbackName !== name;
       if (hasFallback || !isQuotedString || HEX_ESCAPE_REGEXP.test(name)) {
         params["filename*"] = name;
@@ -19099,7 +19099,7 @@ var require_send = __commonJS({
     var Stream = __require("stream");
     var util = __require("util");
     var extname = path2.extname;
-    var join19 = path2.join;
+    var join20 = path2.join;
     var normalize = path2.normalize;
     var resolve3 = path2.resolve;
     var sep = path2.sep;
@@ -19318,7 +19318,7 @@ var require_send = __commonJS({
           return res;
         }
         parts = path3.split(sep);
-        path3 = normalize(join19(root, path3));
+        path3 = normalize(join20(root, path3));
       } else {
         if (UP_PATH_REGEXP.test(path3)) {
           debug('malicious path "%s"', path3);
@@ -19453,7 +19453,7 @@ var require_send = __commonJS({
           if (err) return self.onStatError(err);
           return self.error(404);
         }
-        var p = join19(path3, self._index[i]);
+        var p = join20(path3, self._index[i]);
         debug('stat "%s"', p);
         fs6.stat(p, function(err2, stat) {
           if (err2) return next(err2);
@@ -30483,10 +30483,152 @@ var init_open = __esm({
 // src/server/index.ts
 var import_express15 = __toESM(require_express2(), 1);
 import { createServer } from "node:http";
-import { existsSync as existsSync15, readFileSync as readFileSync12, writeFileSync as writeFileSync5, unlinkSync as unlinkSync3, mkdirSync as mkdirSync6 } from "node:fs";
-import { join as join18, dirname as dirname13, resolve as resolve2 } from "node:path";
+import { existsSync as existsSync17, readFileSync as readFileSync12, writeFileSync as writeFileSync6, unlinkSync as unlinkSync5, mkdirSync as mkdirSync7 } from "node:fs";
+import { join as join19, dirname as dirname14, resolve as resolve2 } 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 execBinary(binary, args, opts) {
+  return execFileSync(binary, args, {
+    ...opts,
+    shell: isWindows
+  });
+}
+async function execBinaryAsync(binary, args, opts) {
+  return execFilePromise(binary, args, {
+    ...opts,
+    shell: isWindows
+  });
+}
+function spawnBinary(binary, args, opts) {
+  return spawn(binary, args, {
+    ...opts,
+    ...isWindows && { shell: true, windowsHide: true }
+  });
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return !(err instanceof Error && "code" in err && err.code === "ESRCH");
+  }
+}
+function walkDescendants(rootPid) {
+  if (isWindows) return { pids: [], psAvailable: false };
+  let out;
+  try {
+    out = execFileSync("ps", ["-A", "-o", "pid=,ppid="], {
+      encoding: "utf-8",
+      timeout: 5e3
+    });
+  } catch {
+    return { pids: [], psAvailable: false };
+  }
+  const children = /* @__PURE__ */ new Map();
+  for (const line of out.split("\n")) {
+    const m = line.trim().match(/^(\d+)\s+(\d+)$/);
+    if (!m) continue;
+    const pid = Number(m[1]);
+    const ppid = Number(m[2]);
+    if (!children.has(ppid)) children.set(ppid, []);
+    children.get(ppid).push(pid);
+  }
+  const acc = [];
+  const queue = [rootPid];
+  const seen = /* @__PURE__ */ new Set([rootPid]);
+  while (queue.length) {
+    const p = queue.shift();
+    for (const c of children.get(p) ?? []) {
+      if (seen.has(c)) continue;
+      seen.add(c);
+      acc.push(c);
+      queue.push(c);
+    }
+  }
+  return { pids: acc, psAvailable: true };
+}
+function descendantPids(rootPid) {
+  return walkDescendants(rootPid).pids;
+}
+function reapTree(rootPid, graceMs = 5e3) {
+  if (isWindows) {
+    try {
+      execFileSync("taskkill", ["/PID", String(rootPid), "/T", "/F"], {
+        timeout: 5e3
+      });
+    } catch {
+    }
+    return { signaled: 1, psAvailable: false };
+  }
+  const { pids: descendants, psAvailable } = walkDescendants(rootPid);
+  if (!psAvailable) {
+    console.warn(
+      `[reapTree] 'ps' unavailable \u2014 signalling only the root (PID ${rootPid}); escaped descendants cannot be enumerated on this system.`
+    );
+  }
+  const term = [...descendants, rootPid];
+  for (const pid of term) {
+    try {
+      process.kill(pid, "SIGTERM");
+    } catch {
+    }
+  }
+  setTimeout(() => {
+    const kill = [...descendantPids(rootPid), rootPid];
+    let stragglers = 0;
+    for (const pid of kill) {
+      if (!isProcessAlive(pid)) continue;
+      stragglers++;
+      try {
+        process.kill(pid, "SIGKILL");
+      } catch {
+      }
+    }
+    if (stragglers > 0) {
+      console.warn(
+        `[reapTree] ${stragglers} process(es) under PID ${rootPid} survived SIGTERM after ${graceMs}ms; sending SIGKILL \u2014 investigate a leaked daemon.`
+      );
+    }
+  }, graceMs).unref();
+  return { signaled: term.length, psAvailable };
+}
+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"
+};
+function defaultIconFor(id, tier) {
+  return BUILTIN_ICON_MAP[id] ?? (tier === "persona" ? "brain" : "user");
+}
+
+// src/server/index.ts
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 import { randomBytes } from "node:crypto";
+import { execFileSync as execFileSync3 } from "node:child_process";
 import { Server as SocketIOServer } from "socket.io";
 
 // src/server/services/ocr-resolver.ts
@@ -30510,37 +30652,98 @@ function resolveOcrDir(startDir) {
 }
 
 // ../cli/src/lib/db/index.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync2, copyFileSync, statSync } from "node:fs";
-import { dirname as dirname4, join as join4 } from "node:path";
+import {
+  existsSync as existsSync5,
+  mkdirSync as mkdirSync2,
+  copyFileSync as copyFileSync2,
+  statSync as statSync2,
+  mkdtempSync,
+  rmSync
+} from "node:fs";
+import { dirname as dirname5, join as join5 } from "node:path";
+
+// ../cli/src/lib/db/engine.ts
+import { createRequire } from "node:module";
+
+// ../cli/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");
+}
 
 // ../cli/src/lib/db/engine.ts
-import BetterSqlite3 from "better-sqlite3";
+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(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;
 }
+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) {
@@ -30553,34 +30756,93 @@ 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 {
-        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;
+    }
   }
 };
 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);
 }
 
 // ../cli/src/lib/db/migrations.ts
@@ -31047,6 +31309,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) {
@@ -31361,9 +31652,28 @@ function sqliteUtcMs(ts) {
 }
 
 // ../cli/src/lib/state/exit-codes.ts
+var STATE_EXIT = {
+  OK: 0,
+  USAGE: 2,
+  AMBIGUOUS: 3,
+  NOT_FOUND: 4,
+  ILLEGAL_TRANSITION: 5,
+  INVARIANT_UNMET: 6,
+  SCHEMA_INVALID: 7,
+  /** Database was locked past the bounded retry budget (SQLITE_BUSY). */
+  BUSY: 8
+};
+var StateError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "StateError";
+  }
+};
 var CANCELLED_EXIT_CODE = -2;
 var ORPHAN_EXIT_CODE = -3;
 var CASCADE_CLOSE_EXIT_CODE = -4;
+var WATCHDOG_DEADLINE_EXIT_CODE = -5;
 
 // ../cli/src/lib/db/agent-sessions.ts
 var NOTE_ORPHAN_PREFIX = "orphaned by liveness sweep";
@@ -31558,9 +31868,84 @@ function sweepStaleSessions(db, thresholdSeconds) {
   return { closedSessionIds: rows.map((r) => r.id) };
 }
 
+// ../cli/src/lib/db/maintenance.ts
+import {
+  existsSync as existsSync3,
+  readdirSync,
+  statSync,
+  unlinkSync,
+  copyFileSync
+} from "node:fs";
+import { dirname as dirname3, join as join3, basename } from "node:path";
+var ONE_HOUR_MS = 60 * 60 * 1e3;
+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(join3(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 reapOrphanDbFiles(dataDir) {
+  const reaped = [];
+  for (const f of scanOrphanTempFiles(dataDir)) {
+    if (!f.reapable) continue;
+    try {
+      unlinkSync(join3(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 = join3(execLogsDir, name);
+    try {
+      if (statSync(full).mtimeMs > cutoff) continue;
+      unlinkSync(full);
+      reaped.push(name);
+    } catch {
+    }
+  }
+  return reaped;
+}
+
 // ../cli/src/lib/db/command-log.ts
-import { appendFileSync, existsSync as existsSync3, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
-import { dirname as dirname3, join as join3 } from "node:path";
+import { appendFileSync, existsSync as existsSync4, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname as dirname4, join as join4 } from "node:path";
 import { randomUUID } from "node:crypto";
 var CACHE_DIR = ".cache";
 var FILENAME = "command-history.jsonl";
@@ -31571,16 +31956,16 @@ function generateCommandUid() {
   return randomUUID();
 }
 function cacheDir(ocrDir) {
-  return join3(ocrDir, "data", CACHE_DIR);
+  return join4(ocrDir, "data", CACHE_DIR);
 }
 function commandLogPath(ocrDir) {
-  return join3(cacheDir(ocrDir), FILENAME);
+  return join4(cacheDir(ocrDir), FILENAME);
 }
 function appendCommandLog(ocrDir, entry) {
   try {
     const filePath = commandLogPath(ocrDir);
-    const dir = dirname3(filePath);
-    if (!existsSync3(dir)) mkdirSync(dir, { recursive: true });
+    const dir = dirname4(filePath);
+    if (!existsSync4(dir)) mkdirSync(dir, { recursive: true });
     const line = JSON.stringify(entry) + "\n";
     appendFileSync(filePath, line, { encoding: "utf-8" });
     if (approxLineCount >= 0) approxLineCount++;
@@ -31590,7 +31975,7 @@ function appendCommandLog(ocrDir, entry) {
 }
 function readCommandLog(ocrDir) {
   const filePath = commandLogPath(ocrDir);
-  if (!existsSync3(filePath)) return [];
+  if (!existsSync4(filePath)) return [];
   const content = readFileSync(filePath, "utf-8");
   const entries = [];
   for (const line of content.split("\n")) {
@@ -31660,11 +32045,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 (existsSync4(bakPath)) return bakPath;
+  if (existsSync5(bakPath)) return bakPath;
   try {
-    if (!existsSync4(dbPath) || statSync(dbPath).size === 0) return null;
+    if (!existsSync5(dbPath) || statSync2(dbPath).size === 0) return null;
     db.pragma("wal_checkpoint(TRUNCATE)");
-    copyFileSync(dbPath, bakPath);
+    copyFileSync2(dbPath, bakPath);
     return bakPath;
   } catch {
     return null;
@@ -31698,8 +32083,8 @@ async function openDatabase(dbPath) {
   if (cached) {
     return cached;
   }
-  const dir = dirname4(dbPath);
-  if (!existsSync4(dir)) {
+  const dir = dirname5(dbPath);
+  if (!existsSync5(dir)) {
     mkdirSync2(dir, { recursive: true });
   }
   const db = openEngine(dbPath);
@@ -31707,11 +32092,11 @@ async function openDatabase(dbPath) {
   return db;
 }
 async function ensureDatabase(ocrDir) {
-  const dataDir = join4(ocrDir, "data");
-  if (!existsSync4(dataDir)) {
+  const dataDir = join5(ocrDir, "data");
+  if (!existsSync5(dataDir)) {
     mkdirSync2(dataDir, { recursive: true });
   }
-  const dbPath = join4(dataDir, "ocr.db");
+  const dbPath = join5(dataDir, "ocr.db");
   const db = await openDatabase(dbPath);
   let before = 0;
   try {
@@ -31739,7 +32124,7 @@ async function ensureDatabase(ocrDir) {
   return db;
 }
 function walCheckpointTruncate(dbPath) {
-  if (!existsSync4(dbPath)) {
+  if (!existsSync5(dbPath)) {
     return "skipped";
   }
   const cached = connections.get(dbPath);
@@ -31760,7 +32145,7 @@ function walCheckpointTruncate(dbPath) {
     return "failed";
   } finally {
     try {
-      transient?.raw.close();
+      transient?.close();
     } catch {
     }
   }
@@ -31774,11 +32159,11 @@ function closeDatabase(dbPath) {
 }
 
 // src/server/db.ts
-import { join as join5 } from "node:path";
+import { join as join6 } from "node:path";
 var cachedDb = null;
 var cachedDbPath = null;
 async function openDb(ocrDir) {
-  const dbPath = join5(ocrDir, "data", "ocr.db");
+  const dbPath = join6(ocrDir, "data", "ocr.db");
   const db = await ensureDatabase(ocrDir);
   cachedDb = db;
   cachedDbPath = dbPath;
@@ -32960,37 +33345,9 @@ function createStatsRouter(db) {
 // src/server/routes/commands.ts
 var import_express8 = __toESM(require_express2(), 1);
 
-// ../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 execBinary(binary, args, opts) {
-  return execFileSync(binary, args, {
-    ...opts,
-    shell: isWindows
-  });
-}
-async function execBinaryAsync(binary, args, opts) {
-  return execFilePromise(binary, args, {
-    ...opts,
-    shell: isWindows
-  });
-}
-function spawnBinary(binary, args, opts) {
-  return spawn(binary, args, {
-    ...opts,
-    ...isWindows && { shell: true, windowsHide: true }
-  });
-}
-
 // src/server/socket/command-runner.ts
-import { readFileSync as readFileSync4, writeFileSync as writeFileSync2, unlinkSync, mkdirSync as mkdirSync4, existsSync as existsSync7 } from "node:fs";
-import { dirname as dirname6, join as join10 } from "node:path";
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync3, unlinkSync as unlinkSync3, mkdirSync as mkdirSync5, existsSync as existsSync10 } from "node:fs";
+import { dirname as dirname7, join as join12 } from "node:path";
 
 // src/server/services/command-outcome.ts
 function deriveCommandOutcome(exitCode, completeness) {
@@ -32998,6 +33355,7 @@ function deriveCommandOutcome(exitCode, completeness) {
   if (exitCode === CANCELLED_EXIT_CODE || exitCode === CASCADE_CLOSE_EXIT_CODE) {
     return "cancelled";
   }
+  if (exitCode === WATCHDOG_DEADLINE_EXIT_CODE) return "failed";
   if (exitCode !== 0) return "failed";
   if (completeness === null || completeness === "complete") return "success";
   return "incomplete";
@@ -33026,7 +33384,50 @@ function getWorkflowCompletenessForExecution(db, executionId) {
 
 // src/server/services/ai-cli/index.ts
 import { readFileSync as readFileSync3 } from "node:fs";
-import { join as join8 } from "node:path";
+import { join as join9 } from "node:path";
+
+// src/server/services/ai-cli/helpers.ts
+import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync2, unlinkSync as unlinkSync2, openSync, closeSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join as join7 } from "node:path";
+function buildFileStdio(stdin, logFile) {
+  if (!logFile) {
+    return { stdio: [stdin, "pipe", "pipe"], logFd: null, logPath: void 0 };
+  }
+  const logFd = openSync(logFile, "a");
+  return { stdio: [stdin, logFd, logFd], logFd, logPath: logFile };
+}
+function closeFileStdio(logFd) {
+  if (logFd === null) return;
+  try {
+    closeSync(logFd);
+  } catch {
+  }
+}
+function formatToolDetail(tool, input) {
+  switch (tool) {
+    case "Read":
+      return `Reading ${input["file_path"] ?? "file"}`;
+    case "Write":
+      return `Writing ${input["file_path"] ?? "file"}`;
+    case "Edit":
+      return `Editing ${input["file_path"] ?? "file"}`;
+    case "Grep":
+      return `Searching for "${input["pattern"] ?? "..."}"`;
+    case "Glob":
+      return `Finding files matching ${input["pattern"] ?? "..."}`;
+    case "Bash": {
+      let cmd = input["command"] ?? "...";
+      cmd = cmd.replace(/^cd\s+\S+\s*&&\s*/, "");
+      return `Running: ${cmd.slice(0, 120)}`;
+    }
+    case "Agent":
+      return `Spawning agent: ${input["description"] ?? "..."}`;
+    default:
+      return `Using ${tool}`;
+  }
+}
+var TEMP_BASE = join7(tmpdir(), "ocr-ai-prompts");
 
 // src/server/socket/env.ts
 var ENV_ALLOWLIST = [
@@ -33099,6 +33500,8 @@ var ClaudeCodeAdapter = class {
   // Claude Code subagent definitions support per-subagent model frontmatter,
   // so per-task model overrides are honored at the host level.
   supportsPerTaskModel = true;
+  // Claude Code can spawn reviewer sub-agents via its Task tool.
+  supportsSubagentSpawn = true;
   buildResumeArgs(vendorSessionId) {
     return buildResumeArgs("claude", vendorSessionId);
   }
@@ -33139,15 +33542,25 @@ var ClaudeCodeAdapter = class {
     if (opts.model) {
       flags.push("--model", opts.model);
     }
+    const { stdio, logFd, logPath } = buildFileStdio(
+      "pipe",
+      isWorkflow ? opts.logFile : void 0
+    );
     const proc = spawnBinary("claude", flags, {
       cwd: opts.cwd,
       env: { ...cleanEnv(), ...opts.env ?? {} },
       detached: isWorkflow,
-      stdio: ["pipe", "pipe", "pipe"]
+      stdio
     });
+    closeFileStdio(logFd);
+    if (isWorkflow) proc.unref();
     proc.stdin?.write(opts.prompt);
     proc.stdin?.end();
-    return { process: proc, detached: isWorkflow };
+    return {
+      process: proc,
+      detached: isWorkflow,
+      ...logPath ? { logPath } : {}
+    };
   }
   async listModels() {
     try {
@@ -33306,6 +33719,13 @@ var ClaudeLineParser = class {
       const message = typeof parsed["message"] === "string" ? parsed["message"] : "Agent error";
       events.push({ type: "error", source: "agent", message });
     }
+    if (type === "result") {
+      events.push({
+        type: "result",
+        isError: parsed["is_error"] === true,
+        subtype: typeof parsed["subtype"] === "string" ? parsed["subtype"] : void 0
+      });
+    }
     return events;
   }
 };
@@ -33341,6 +33761,9 @@ var OpenCodeAdapter = class {
   // until OpenCode adds per-task model support; OCR surfaces a warning to
   // the user when this happens.
   supportsPerTaskModel = false;
+  // OpenCode exposes a sub-agent primitive (`--agent`), so reviewer sub-agents
+  // can be spawned in-agent (uniform model — see supportsPerTaskModel above).
+  supportsSubagentSpawn = true;
   buildResumeArgs(vendorSessionId) {
     return buildResumeArgs("opencode", vendorSessionId);
   }
@@ -33378,13 +33801,23 @@ var OpenCodeAdapter = class {
     if (opts.model) {
       args.push("--model", opts.model);
     }
+    const { stdio, logFd, logPath } = buildFileStdio(
+      "ignore",
+      isWorkflow ? opts.logFile : void 0
+    );
     const proc = spawnBinary("opencode", args, {
       cwd: opts.cwd,
       env: { ...cleanEnv(), ...opts.env ?? {} },
       detached: isWorkflow,
-      stdio: ["ignore", "pipe", "pipe"]
+      stdio
     });
-    return { process: proc, detached: isWorkflow };
+    closeFileStdio(logFd);
+    if (isWorkflow) proc.unref();
+    return {
+      process: proc,
+      detached: isWorkflow,
+      ...logPath ? { logPath } : {}
+    };
   }
   async listModels() {
     try {
@@ -33515,20 +33948,20 @@ function extractToolOutput(part) {
 // src/server/services/event-journal.ts
 import {
   createWriteStream,
-  existsSync as existsSync5,
-  mkdirSync as mkdirSync3,
+  existsSync as existsSync6,
+  mkdirSync as mkdirSync4,
   readFileSync as readFileSync2
 } from "node:fs";
-import { join as join6 } from "node:path";
+import { join as join8 } from "node:path";
 function eventsDir(ocrDir) {
-  const dir = join6(ocrDir, "data", "events");
-  if (!existsSync5(dir)) {
-    mkdirSync3(dir, { recursive: true });
+  const dir = join8(ocrDir, "data", "events");
+  if (!existsSync6(dir)) {
+    mkdirSync4(dir, { recursive: true });
   }
   return dir;
 }
 function eventJournalPath(ocrDir, executionId) {
-  return join6(eventsDir(ocrDir), `${executionId}.jsonl`);
+  return join8(eventsDir(ocrDir), `${executionId}.jsonl`);
 }
 var EventJournalAppender = class {
   stream;
@@ -33565,7 +33998,7 @@ var EventJournalAppender = class {
 };
 function readEventJournal(ocrDir, executionId) {
   const path2 = eventJournalPath(ocrDir, executionId);
-  if (!existsSync5(path2)) return [];
+  if (!existsSync6(path2)) return [];
   let raw;
   try {
     raw = readFileSync2(path2, "utf-8");
@@ -33585,38 +34018,10 @@ function readEventJournal(ocrDir, executionId) {
   return events;
 }
 
-// src/server/services/ai-cli/helpers.ts
-import { tmpdir } from "node:os";
-import { join as join7 } from "node:path";
-function formatToolDetail(tool, input) {
-  switch (tool) {
-    case "Read":
-      return `Reading ${input["file_path"] ?? "file"}`;
-    case "Write":
-      return `Writing ${input["file_path"] ?? "file"}`;
-    case "Edit":
-      return `Editing ${input["file_path"] ?? "file"}`;
-    case "Grep":
-      return `Searching for "${input["pattern"] ?? "..."}"`;
-    case "Glob":
-      return `Finding files matching ${input["pattern"] ?? "..."}`;
-    case "Bash": {
-      let cmd = input["command"] ?? "...";
-      cmd = cmd.replace(/^cd\s+\S+\s*&&\s*/, "");
-      return `Running: ${cmd.slice(0, 120)}`;
-    }
-    case "Agent":
-      return `Spawning agent: ${input["description"] ?? "..."}`;
-    default:
-      return `Using ${tool}`;
-  }
-}
-var TEMP_BASE = join7(tmpdir(), "ocr-ai-prompts");
-
 // src/server/services/ai-cli/index.ts
 function readAiCliPreference(ocrDir) {
   try {
-    const configPath = join8(ocrDir, "config.yaml");
+    const configPath = join9(ocrDir, "config.yaml");
     const content = readFileSync3(configPath, "utf-8");
     const match = content.match(/^\s*ai_cli:\s*(\S+)/m);
     const value = match?.[1] ?? "auto";
@@ -33725,31 +34130,245 @@ var AiCliService = class {
   }
 };
 
+// src/server/services/ai-cli/file-tailer.ts
+import { openSync as openSync2, readSync, closeSync as closeSync2, existsSync as existsSync7 } from "node:fs";
+import { StringDecoder } from "node:string_decoder";
+var DEFAULT_POLL_MS = 100;
+var READ_CHUNK_BYTES = 64 * 1024;
+var FileTailer = class {
+  constructor(path2, onChunk, pollMs = DEFAULT_POLL_MS) {
+    this.path = path2;
+    this.onChunk = onChunk;
+    this.pollMs = pollMs;
+  }
+  fd = null;
+  offset = 0;
+  decoder = new StringDecoder("utf8");
+  timer = null;
+  buf = Buffer.allocUnsafe(READ_CHUNK_BYTES);
+  stopped = false;
+  /** Begin polling for appended bytes. Idempotent. */
+  start() {
+    if (this.timer || this.stopped) return;
+    this.timer = setInterval(() => this.poll(), this.pollMs);
+    this.timer.unref?.();
+  }
+  ensureOpen() {
+    if (this.fd !== null) return true;
+    if (!existsSync7(this.path)) return false;
+    try {
+      this.fd = openSync2(this.path, "r");
+    } catch {
+      return false;
+    }
+    return true;
+  }
+  /** Read everything currently available from `offset` to EOF. */
+  poll() {
+    if (!this.ensureOpen()) return;
+    let bytes;
+    do {
+      try {
+        bytes = readSync(this.fd, this.buf, 0, this.buf.length, this.offset);
+      } catch {
+        return;
+      }
+      if (bytes > 0) {
+        this.offset += bytes;
+        const chunk = this.decoder.write(this.buf.subarray(0, bytes));
+        if (chunk) this.onChunk(chunk);
+      }
+    } while (bytes === this.buf.length);
+  }
+  /**
+   * Stop tailing: do one final drain to EOF, flush any partial multi-byte
+   * remainder, and close the fd. Safe to call more than once. Synchronous so a
+   * `close` handler can finalize the stream with no lost-tail race.
+   */
+  stop() {
+    if (this.stopped) return;
+    this.stopped = true;
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    this.poll();
+    const tail = this.decoder.end();
+    if (tail) this.onChunk(tail);
+    if (this.fd !== null) {
+      try {
+        closeSync2(this.fd);
+      } catch {
+      }
+      this.fd = null;
+    }
+  }
+};
+
 // src/server/socket/cli-resolver.ts
-import { existsSync as existsSync6 } from "node:fs";
-import { dirname as dirname5, join as join9 } from "node:path";
+import { existsSync as existsSync8 } from "node:fs";
+import { dirname as dirname6, join as join10 } from "node:path";
 import { fileURLToPath } from "node:url";
-var __dirname = dirname5(fileURLToPath(import.meta.url));
+var __dirname = dirname6(fileURLToPath(import.meta.url));
 function resolveLocalCli() {
-  const parentDir = join9(__dirname, "..");
-  const bundledCli = join9(parentDir, "index.js");
-  if (existsSync6(bundledCli) && existsSync6(join9(parentDir, "dashboard", "server.js"))) {
+  const parentDir = join10(__dirname, "..");
+  const bundledCli = join10(parentDir, "index.js");
+  if (existsSync8(bundledCli) && existsSync8(join10(parentDir, "dashboard", "server.js"))) {
     return bundledCli;
   }
   let dir = __dirname;
   for (let i = 0; i < 8; i++) {
-    if (existsSync6(join9(dir, "nx.json"))) {
-      const candidate = join9(dir, "packages", "cli", "dist", "index.js");
-      if (existsSync6(candidate)) return candidate;
+    if (existsSync8(join10(dir, "nx.json"))) {
+      const candidate = join10(dir, "packages", "cli", "dist", "index.js");
+      if (existsSync8(candidate)) return candidate;
       break;
     }
-    const parent = dirname5(dir);
+    const parent = dirname6(dir);
     if (parent === dir) break;
     dir = parent;
   }
   return null;
 }
 
+// ../cli/src/lib/state/projection.ts
+var REASON_EVENT_TYPES = [
+  "session_aborted",
+  "session_auto_closed_stale",
+  "session_synced",
+  "session_legacy_import"
+];
+var TERMINAL_EVENT_TYPES = /* @__PURE__ */ new Set([
+  "session_closed",
+  ...REASON_EVENT_TYPES
+]);
+function hasCompletionInvariant(db, session) {
+  const eventType = session.workflow_type === "map" ? "map_completed" : "round_completed";
+  const round = session.workflow_type === "map" ? session.current_map_run : session.current_round;
+  const r = db.exec(
+    `SELECT 1 FROM orchestration_events
+       WHERE session_id = ? AND event_type = ? AND round = ? LIMIT 1`,
+    [session.id, eventType, round]
+  );
+  return (r[0]?.values.length ?? 0) > 0;
+}
+
+// ../cli/src/lib/state/index.ts
+async function stateClose(params) {
+  const { sessionId, ocrDir, abort } = params;
+  const db = await ensureDatabase(ocrDir);
+  const existing = getSession(db, sessionId);
+  if (!existing) {
+    throw new StateError(STATE_EXIT.NOT_FOUND, `Session not found: ${sessionId}`);
+  }
+  if (existing.status === "closed") {
+    console.error(`[ocr] Session already closed: ${sessionId}`);
+    return;
+  }
+  if (!abort && !hasCompletionInvariant(db, existing)) {
+    const what = existing.workflow_type === "map" ? `map run ${existing.current_map_run} has no map_completed event` : `round ${existing.current_round} has no round_completed event`;
+    throw new StateError(
+      STATE_EXIT.INVARIANT_UNMET,
+      `Cannot close session ${sessionId}: ${what}. Run 'ocr state complete-round' to finalize it, or pass --abort to record an abandoned session.`
+    );
+  }
+  const note = "closed by parent workflow close";
+  db.transaction(() => {
+    if (abort) {
+      insertEvent(db, {
+        session_id: sessionId,
+        event_type: "session_aborted",
+        phase: existing.current_phase,
+        phase_number: existing.phase_number,
+        round: existing.current_round
+      });
+    }
+    updateSession(db, sessionId, {
+      status: "closed",
+      current_phase: "complete"
+    });
+    if (!abort) {
+      insertEvent(db, {
+        session_id: sessionId,
+        event_type: "session_closed",
+        phase: "complete",
+        phase_number: existing.phase_number,
+        round: existing.current_round
+      });
+    }
+    cascadeTerminateExecutions(db, sessionId, CASCADE_CLOSE_EXIT_CODE, note);
+  });
+}
+async function reconcileWorkflowOnExit(ocrDir, sessionId, db) {
+  db ??= await ensureDatabase(ocrDir);
+  const existing = getSession(db, sessionId);
+  if (!existing) return "not-found";
+  if (existing.status === "closed") return "already-closed";
+  if (!hasCompletionInvariant(db, existing)) return "incomplete";
+  if (hasInFlightDependents(db, sessionId)) return "in-flight";
+  await stateClose({ sessionId, ocrDir, abort: false });
+  return "closed";
+}
+async function reconcileCompletedSessions(ocrDir) {
+  const db = await ensureDatabase(ocrDir);
+  const closed = [];
+  for (const s of getAllSessions(db)) {
+    if (s.status !== "active") continue;
+    const outcome = await reconcileWorkflowOnExit(ocrDir, s.id, db);
+    if (outcome === "closed") closed.push(s.id);
+  }
+  return closed;
+}
+
+// ../cli/src/lib/runtime-config.ts
+import { existsSync as existsSync9, readFileSync as readFileSync4 } from "node:fs";
+import { join as join11 } from "node:path";
+var DEFAULT_AGENT_HEARTBEAT_SECONDS = 60;
+var DEFAULT_WORKFLOW_HARD_DEADLINE_MINUTES = 60;
+function readRuntimePositiveInt(ocrDir, key, defaultValue) {
+  const configPath = join11(ocrDir, "config.yaml");
+  if (!existsSync9(configPath)) return defaultValue;
+  let content;
+  try {
+    content = readFileSync4(configPath, "utf-8");
+  } catch {
+    return defaultValue;
+  }
+  const blockMatch = content.match(
+    new RegExp(
+      String.raw`^runtime:\s*\n(?:\s+[^\n]*\n)*?\s+${key}:\s*([^\s#\n]+)`,
+      "m"
+    )
+  );
+  const inlineMatch = content.match(
+    new RegExp(String.raw`^runtime:\s*\{[^}]*\b${key}:\s*([^\s,}]+)`, "m")
+  );
+  const raw = blockMatch?.[1] ?? inlineMatch?.[1];
+  if (!raw) return defaultValue;
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed) || parsed <= 0 || !Number.isInteger(parsed)) {
+    process.stderr.write(
+      `[ocr] runtime.${key} is not a positive integer (got "${raw}"); falling back to ${defaultValue}.
+`
+    );
+    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;
+}
+
 // src/server/socket/command-runner.ts
 function shellSplit(str) {
   const tokens = [];
@@ -33783,7 +34402,7 @@ var ALLOWED_COMMANDS = /* @__PURE__ */ new Set([
 ]);
 var AI_COMMANDS = /* @__PURE__ */ new Set(["map", "review", "translate-review-to-single-human", "address", "create-reviewer", "sync-reviewers"]);
 function escapeUserHeaders(value) {
-  return value.replace(/^([ \t]{0,3})(#+)/gm, "$1\\$2").replace(/^([ \t]{0,3})(＃+)/gm, "$1\\$2").replace(/^([ \t]{0,3})(={3,}|-{3,})\s*$/gm, "$1\\$2").replace(/^([ \t]{0,3})(```+)/gm, "$1\\$2");
+  return value.normalize("NFKC").replace(/[\u2028\u2029]/g, "\n").replace(/\p{Cf}/gu, "").replace(/^([ \t]{0,3})(#+)/gm, "$1\\$2").replace(/^([ \t]{0,3})(＃+)/gm, "$1\\$2").replace(/^([ \t]{0,3})(={3,}|-{3,})\s*$/gm, "$1\\$2").replace(/^([ \t]{0,3})(```+)/gm, "$1\\$2");
 }
 function buildPrompt(opts) {
   const { baseCommand, subArgs, commandContent, executionUid, localCli } = opts;
@@ -33930,23 +34549,45 @@ function extractPerInstanceModels(subArgs) {
   return [...models];
 }
 var MAX_CONCURRENT = 3;
+var WATCHDOG_TICK_MS = 1e4;
+var POST_RESULT_GRACE_MS = 3e4;
+var HEARTBEAT_THROTTLE_MS = 5e3;
+function decideWatchdogTick(i) {
+  if (i.resultSeenAt !== void 0 && i.nowMs - i.resultSeenAt > i.postResultGraceMs) {
+    return {
+      action: "finalize",
+      reap: !i.exited,
+      exitCode: i.resultIsError ? 1 : 0,
+      reason: "result-grace"
+    };
+  }
+  if (i.nowMs - i.startedAtMs > i.hardDeadlineMs) {
+    return {
+      action: "finalize",
+      reap: !i.exited,
+      exitCode: WATCHDOG_DEADLINE_EXIT_CODE,
+      reason: "hard-deadline"
+    };
+  }
+  return i.exited ? { action: "wait" } : { action: "beat" };
+}
 var activeCommands = /* @__PURE__ */ new Map();
 function spawnMarkerPath(ocrDir) {
-  return join10(ocrDir, "data", "dashboard-active-spawn.json");
+  return join12(ocrDir, "data", "dashboard-active-spawn.json");
 }
 function writeSpawnMarker(ocrDir, executionUid, pid) {
-  const dataDir = join10(ocrDir, "data");
-  if (!existsSync7(dataDir)) mkdirSync4(dataDir, { recursive: true });
+  const dataDir = join12(ocrDir, "data");
+  if (!existsSync10(dataDir)) mkdirSync5(dataDir, { recursive: true });
   const payload = JSON.stringify({
     execution_uid: executionUid,
     pid,
     started_at: (/* @__PURE__ */ new Date()).toISOString()
   });
-  writeFileSync2(spawnMarkerPath(ocrDir), payload, { mode: 384 });
+  writeFileSync3(spawnMarkerPath(ocrDir), payload, { mode: 384 });
 }
 function clearSpawnMarker(ocrDir) {
   try {
-    unlinkSync(spawnMarkerPath(ocrDir));
+    unlinkSync3(spawnMarkerPath(ocrDir));
   } catch {
   }
 }
@@ -34073,25 +34714,14 @@ function registerCommandHandlers(io2, socket, db, ocrDir, aiCliService, sessionC
       if (!proc) return;
       const pid = proc.pid;
       if (entry.detached && pid) {
-        try {
-          process.kill(-pid, "SIGTERM");
-        } catch {
-          proc.kill("SIGTERM");
-        }
+        reapTree(pid);
       } else {
         proc.kill("SIGTERM");
+        const killTimer = setTimeout(() => {
+          if (activeCommands.has(targetId)) proc.kill("SIGKILL");
+        }, 5e3);
+        proc.once("close", () => clearTimeout(killTimer));
       }
-      const killTimer = setTimeout(() => {
-        if (!activeCommands.has(targetId)) return;
-        if (entry.detached && pid) {
-          try {
-            process.kill(-pid, "SIGKILL");
-          } catch {
-          }
-        }
-        proc.kill("SIGKILL");
-      }, 5e3);
-      proc.once("close", () => clearTimeout(killTimer));
     } catch (err) {
       console.error("Error in command:cancel handler:", err);
       socket.emit("error", { message: "Internal error" });
@@ -34100,7 +34730,7 @@ function registerCommandHandlers(io2, socket, db, ocrDir, aiCliService, sessionC
 }
 function spawnCliCommand(io2, db, ocrDir, executionId, baseCommand, subArgs, entry) {
   const localCli = resolveLocalCli();
-  const repoRoot = dirname6(ocrDir);
+  const repoRoot = dirname7(ocrDir);
   const proc = localCli ? spawnBinary("node", [localCli, baseCommand, ...subArgs], {
     cwd: repoRoot,
     env: cleanEnv()
@@ -34126,8 +34756,7 @@ function spawnCliCommand(io2, db, ocrDir, executionId, baseCommand, subArgs, ent
     io2.emit("command:output", { execution_id: executionId, content: chunk });
   });
   proc.on("close", (code) => {
-    const finalCode = code ?? (entry.cancelled ? -2 : -1);
-    finishExecution(io2, db, ocrDir, executionId, finalCode, entry.outputBuffer);
+    finishExecution(io2, db, ocrDir, executionId, code ?? -1, entry.outputBuffer);
   });
   proc.on("error", (err) => {
     entry.outputBuffer += `Process error: ${err.message}`;
@@ -34150,10 +34779,10 @@ function spawnAiCommand(io2, _socket, db, ocrDir, executionId, baseCommand, subA
       io2.emit("command:output", { execution_id: executionId, content: warning });
     }
   }
-  const commandMdPath = join10(ocrDir, "commands", `${baseCommand}.md`);
+  const commandMdPath = join12(ocrDir, "commands", `${baseCommand}.md`);
   let commandContent;
   try {
-    commandContent = readFileSync4(commandMdPath, "utf-8");
+    commandContent = readFileSync5(commandMdPath, "utf-8");
   } catch {
     const content = `Error: Could not read command file at ${commandMdPath}
 `;
@@ -34197,7 +34826,20 @@ function spawnAiCommand(io2, _socket, db, ocrDir, executionId, baseCommand, subA
       console.error("Failed to resolve resume context:", err);
     }
   }
-  const repoRoot = dirname6(ocrDir);
+  const repoRoot = dirname7(ocrDir);
+  let logFile;
+  if (entry.uid) {
+    try {
+      const logDir = join12(ocrDir, "data", "exec-logs");
+      mkdirSync5(logDir, { recursive: true });
+      logFile = join12(logDir, `${entry.uid}.log`);
+    } catch (err) {
+      console.error(
+        "[command-runner] could not prepare exec-log dir \u2014 falling back to pipe stdio (degraded: close may be withheld by a leaked grandchild; watchdog deadlines still finalize):",
+        err
+      );
+    }
+  }
   const spawnOpts = {
     mode: "workflow",
     prompt,
@@ -34207,7 +34849,10 @@ function spawnAiCommand(io2, _socket, db, ocrDir, executionId, baseCommand, subA
   if (resumeSessionId) {
     spawnOpts.resumeSessionId = resumeSessionId;
   }
-  const { process: proc, detached } = adapter.spawn(spawnOpts);
+  if (logFile) {
+    spawnOpts.logFile = logFile;
+  }
+  const { process: proc, detached, logPath } = adapter.spawn(spawnOpts);
   entry.process = proc;
   entry.detached = detached;
   if (proc.pid) {
@@ -34243,6 +34888,61 @@ function spawnAiCommand(io2, _socket, db, ocrDir, executionId, baseCommand, subA
     }
   }, POLL_INTERVAL_MS);
   entry.linkPoll = linkPoll;
+  const bumpHeartbeat = () => {
+    if (entry.finalized) return;
+    const now = Date.now();
+    if (now - (entry.lastBeatWrite ?? 0) < HEARTBEAT_THROTTLE_MS) return;
+    entry.lastBeatWrite = now;
+    try {
+      db.run(
+        `UPDATE command_executions SET last_heartbeat_at = datetime('now') WHERE id = ? AND finished_at IS NULL`,
+        [executionId]
+      );
+    } catch (err) {
+      console.error("[command-runner] heartbeat bump failed:", err);
+    }
+  };
+  const hardDeadlineMs = getWorkflowHardDeadlineMs(ocrDir);
+  entry.watchdog = setInterval(() => {
+    if (entry.finalized) return;
+    const child = entry.process;
+    const pid = child?.pid;
+    if (!child || !pid) return;
+    const exited = child.exitCode !== null || child.signalCode !== null;
+    const decision = decideWatchdogTick({
+      exited,
+      resultSeenAt: entry.resultSeenAt,
+      resultIsError: entry.resultIsError,
+      startedAtMs: Date.parse(entry.startedAt),
+      nowMs: Date.now(),
+      postResultGraceMs: POST_RESULT_GRACE_MS,
+      hardDeadlineMs
+    });
+    switch (decision.action) {
+      case "beat":
+        bumpHeartbeat();
+        return;
+      case "wait":
+        return;
+      case "finalize": {
+        if (decision.reason === "hard-deadline") {
+          const minutes = Math.round(hardDeadlineMs / 6e4);
+          console.warn(`[watchdog] execution ${executionId}: exceeded hard deadline (${minutes}m) \u2014 finalizing${decision.reap ? " + reaping tree" : ""}`);
+          const notice = `
+[watchdog] Reaped after exceeding the ${minutes}-minute hard deadline. Raise runtime.workflow_hard_deadline_minutes in .ocr/config.yaml for large reviewer fleets.
+`;
+          entry.outputBuffer += notice;
+          io2.emit("command:output", { execution_id: executionId, content: notice });
+        } else {
+          console.warn(`[watchdog] execution ${executionId}: result seen but no close after grace \u2014 finalizing${decision.reap ? " + reaping tree" : ""}`);
+        }
+        if (decision.reap) reapTree(pid);
+        finishExecution(io2, db, ocrDir, executionId, decision.exitCode, entry.outputBuffer);
+        return;
+      }
+    }
+  }, WATCHDOG_TICK_MS);
+  entry.watchdog.unref();
   io2.emit("command:output", {
     execution_id: executionId,
     content: `\u25B8 Starting OCR ${baseCommand} workflow...
@@ -34307,11 +35007,16 @@ function spawnAiCommand(io2, _socket, db, ocrDir, executionId, baseCommand, subA
         emitStreamEvent(evt);
         break;
       }
+      case "result": {
+        entry.resultSeenAt = Date.now();
+        entry.resultIsError = evt.isError;
+        emitStreamEvent(evt);
+        break;
+      }
     }
   }
-  proc.stdout?.setEncoding("utf-8");
-  proc.stderr?.setEncoding("utf-8");
-  proc.stdout?.on("data", (chunk) => {
+  function onOutputChunk(chunk) {
+    bumpHeartbeat();
     lineBuffer += chunk;
     const lines = lineBuffer.split("\n");
     lineBuffer = lines.pop() ?? "";
@@ -34326,17 +35031,30 @@ function spawnAiCommand(io2, _socket, db, ocrDir, executionId, baseCommand, subA
         handleEvent(evt);
       }
     }
-  });
+  }
   let stderrBuffer = "";
-  proc.stderr?.on("data", (chunk) => {
-    stderrBuffer += chunk;
-  });
+  if (logPath) {
+    const tailer = new FileTailer(logPath, onOutputChunk);
+    tailer.start();
+    entry.tailer = tailer;
+  } else {
+    proc.stdout?.setEncoding("utf-8");
+    proc.stderr?.setEncoding("utf-8");
+    proc.stdout?.on("data", onOutputChunk);
+    proc.stderr?.on("data", (chunk) => {
+      stderrBuffer += chunk;
+    });
+  }
   proc.on("close", (code) => {
     if (entry.linkPoll) {
       clearInterval(entry.linkPoll);
       entry.linkPoll = void 0;
     }
     clearSpawnMarker(ocrDir);
+    if (entry.tailer) {
+      entry.tailer.stop();
+      entry.tailer = void 0;
+    }
     if (lineBuffer.trim()) {
       const events = parser.parseLine(lineBuffer);
       for (const evt of events) {
@@ -34360,8 +35078,7 @@ ${stderrBuffer}`;
     journal.close().catch((err) => {
       console.error("[event-journal] close failed:", err);
     });
-    const finalCode = code ?? (entry.cancelled ? -2 : -1);
-    finishExecution(io2, db, ocrDir, executionId, finalCode, entry.outputBuffer);
+    finishExecution(io2, db, ocrDir, executionId, code ?? -1, entry.outputBuffer);
   });
   proc.on("error", (err) => {
     if (entry.linkPoll) {
@@ -34375,15 +35092,28 @@ ${stderrBuffer}`;
     finishExecution(io2, db, ocrDir, executionId, -1, entry.outputBuffer);
   });
 }
-function finishExecution(io2, db, ocrDir, executionId, code, output) {
+function finishExecution(io2, db, ocrDir, executionId, rawCode, output) {
   const finishedAt = (/* @__PURE__ */ new Date()).toISOString();
   const entry = activeCommands.get(executionId);
-  db.run(
+  const code = entry?.cancelled ? CANCELLED_EXIT_CODE : rawCode;
+  if (entry?.finalized) return;
+  if (entry) {
+    entry.finalized = true;
+    if (entry.watchdog) {
+      clearInterval(entry.watchdog);
+      entry.watchdog = void 0;
+    }
+    if (entry.tailer) {
+      entry.tailer.stop();
+      entry.tailer = void 0;
+    }
+  }
+  const res = db.prepare(
     `UPDATE command_executions
-     SET exit_code = ?, finished_at = ?, output = ?, pid = NULL
-     WHERE id = ?`,
-    [code, finishedAt, output, executionId]
-  );
+       SET exit_code = ?, finished_at = ?, output = ?, pid = NULL
+       WHERE id = ? AND finished_at IS NULL`
+  ).run(code, finishedAt, output, executionId);
+  if (Number(res.changes) === 0 && !entry) return;
   const completeness = getWorkflowCompletenessForExecution(db, executionId);
   const outcome = deriveCommandOutcome(code, completeness);
   const cancellationReason = deriveCancellationReason(code);
@@ -34398,7 +35128,7 @@ function finishExecution(io2, db, ocrDir, executionId, code, output) {
       started_at: entry.startedAt,
       finished_at: finishedAt,
       is_detached: entry.detached ? 1 : 0,
-      event: code === -2 ? "cancel" : "finish",
+      event: code === CANCELLED_EXIT_CODE ? "cancel" : "finish",
       writer: "dashboard"
     });
   }
@@ -34410,6 +35140,27 @@ function finishExecution(io2, db, ocrDir, executionId, code, output) {
     cancellation_reason: cancellationReason
   });
   activeCommands.delete(executionId);
+  const workflowRow = db.exec(
+    "SELECT workflow_id FROM command_executions WHERE id = ?",
+    [executionId]
+  );
+  const workflowId = workflowRow[0]?.values[0]?.[0];
+  if (typeof workflowId === "string" && workflowId.length > 0) {
+    void reconcileWorkflowOnExit(ocrDir, workflowId, db).then((outcome2) => {
+      if (outcome2 === "closed") {
+        console.log(`[command-runner] auto-finalized workflow ${workflowId}`);
+      } else if (outcome2 === "incomplete" || outcome2 === "in-flight") {
+        console.debug(
+          `[command-runner] workflow ${workflowId} not finalized: ${outcome2}`
+        );
+      }
+    }).catch((err) => {
+      console.error(
+        `[command-runner] reconcileWorkflowOnExit(${workflowId}) failed:`,
+        err instanceof Error ? err.message : err
+      );
+    });
+  }
 }
 
 // src/server/routes/commands.ts
@@ -34497,8 +35248,8 @@ function createCommandsRouter(db, ocrDir) {
 
 // src/server/routes/config.ts
 var import_express9 = __toESM(require_express2(), 1);
-import { readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "node:fs";
-import { join as join11, dirname as dirname7, basename } from "node:path";
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "node:fs";
+import { join as join13, dirname as dirname8, basename as basename2 } from "node:path";
 var VALID_IDES = ["vscode", "cursor", "windsurf", "jetbrains", "sublime"];
 function detectIde() {
   const termProgram = process.env.TERM_PROGRAM?.toLowerCase() ?? "";
@@ -34515,8 +35266,8 @@ function detectIde() {
 }
 function readIdeFromConfig(ocrDir) {
   try {
-    const configPath = join11(ocrDir, "config.yaml");
-    const content = readFileSync5(configPath, "utf-8");
+    const configPath = join13(ocrDir, "config.yaml");
+    const content = readFileSync6(configPath, "utf-8");
     const match = content.match(/^\s*ide:\s*(\S+)/m);
     return match?.[1] ?? "auto";
   } catch {
@@ -34543,8 +35294,8 @@ function detectGitBranch(cwd) {
 }
 function createConfigRouter(ocrDir, aiCliService) {
   const router = (0, import_express9.Router)();
-  const projectRoot = dirname7(ocrDir);
-  const workspaceName = basename(projectRoot);
+  const projectRoot = dirname8(ocrDir);
+  const workspaceName = basename2(projectRoot);
   const gitBranch = detectGitBranch(projectRoot);
   router.get("/", (_req, res) => {
     res.json({
@@ -34562,8 +35313,8 @@ function createConfigRouter(ocrDir, aiCliService) {
       return;
     }
     try {
-      const configPath = join11(ocrDir, "config.yaml");
-      let content = readFileSync5(configPath, "utf-8");
+      const configPath = join13(ocrDir, "config.yaml");
+      let content = readFileSync6(configPath, "utf-8");
       if (content.match(/^\s*ide:\s*\S+/m)) {
         content = content.replace(/^(\s*ide:\s*)\S+/m, `$1${ide}`);
       } else if (content.includes("dashboard:")) {
@@ -34575,7 +35326,7 @@ dashboard:
   ide: ${ide}
 `;
       }
-      writeFileSync3(configPath, content);
+      writeFileSync4(configPath, content);
       res.json({ ide });
     } catch (err) {
       console.error("Failed to update config:", err);
@@ -34651,17 +35402,20 @@ function createChatRouter(db) {
 
 // src/server/routes/reviewers.ts
 var import_express11 = __toESM(require_express2(), 1);
-import { readFileSync as readFileSync6, existsSync as existsSync8, watch } from "node:fs";
-import { join as join12 } from "node:path";
+import { readFileSync as readFileSync7, existsSync as existsSync11, watch } from "node:fs";
+import { join as join14 } from "node:path";
 function readReviewersMeta(ocrDir) {
-  const metaPath = join12(ocrDir, "reviewers-meta.json");
-  if (!existsSync8(metaPath)) {
+  const metaPath = join14(ocrDir, "reviewers-meta.json");
+  if (!existsSync11(metaPath)) {
     return { reviewers: [], defaults: [] };
   }
   try {
-    const raw = readFileSync6(metaPath, "utf-8");
+    const raw = readFileSync7(metaPath, "utf-8");
     const meta = JSON.parse(raw);
-    const reviewers = meta.reviewers ?? [];
+    const reviewers = (meta.reviewers ?? []).map((r) => ({
+      ...r,
+      icon: r.icon || defaultIconFor(r.id, r.tier)
+    }));
     const defaults = reviewers.filter((r) => r.is_default).map((r) => r.id);
     return { reviewers, defaults };
   } catch {
@@ -34680,13 +35434,13 @@ function createReviewersRouter(ocrDir) {
       res.status(400).json({ error: "Invalid reviewer ID" });
       return;
     }
-    const filePath = join12(ocrDir, "skills", "references", "reviewers", `${id}.md`);
-    if (!existsSync8(filePath)) {
+    const filePath = join14(ocrDir, "skills", "references", "reviewers", `${id}.md`);
+    if (!existsSync11(filePath)) {
       res.status(404).json({ error: "Reviewer not found", id });
       return;
     }
     try {
-      const content = readFileSync6(filePath, "utf-8");
+      const content = readFileSync7(filePath, "utf-8");
       res.json({ id, content });
     } catch {
       res.status(500).json({ error: "Failed to read reviewer file", id });
@@ -34695,7 +35449,7 @@ function createReviewersRouter(ocrDir) {
   return router;
 }
 function watchReviewersMeta(ocrDir, io2) {
-  const metaPath = join12(ocrDir, "reviewers-meta.json");
+  const metaPath = join14(ocrDir, "reviewers-meta.json");
   let watcher = null;
   let debounce;
   try {
@@ -34741,11 +35495,11 @@ function createAgentSessionsRouter(db, syncFromDisk = () => {
 
 // src/server/routes/handoff.ts
 var import_express13 = __toESM(require_express2(), 1);
-import { dirname as dirname8 } from "node:path";
+import { dirname as dirname9 } from "node:path";
 function createHandoffRouter(sessionCapture, ocrDir, syncFromDisk = () => {
 }) {
   const router = (0, import_express13.Router)();
-  const projectDir = dirname8(ocrDir);
+  const projectDir = dirname9(ocrDir);
   router.get("/:id/handoff", (req, res) => {
     const workflowId = req.params["id"];
     if (!workflowId) {
@@ -34775,14 +35529,14 @@ import { spawnSync } from "node:child_process";
 
 // ../cli/src/lib/team-config.ts
 var import_yaml = __toESM(require_dist(), 1);
-import { existsSync as existsSync9, readFileSync as readFileSync7 } from "node:fs";
-import { join as join13 } from "node:path";
+import { existsSync as existsSync12, readFileSync as readFileSync8 } from "node:fs";
+import { join as join15 } from "node:path";
 function loadTeamConfig(ocrDir) {
-  const configPath = join13(ocrDir, "config.yaml");
-  if (!existsSync9(configPath)) {
+  const configPath = join15(ocrDir, "config.yaml");
+  if (!existsSync12(configPath)) {
     return { team: [], aliases: {}, defaultModel: null };
   }
-  const content = readFileSync7(configPath, "utf-8");
+  const content = readFileSync8(configPath, "utf-8");
   return parseTeamConfigYaml(content);
 }
 function parseTeamConfigYaml(content) {
@@ -35382,8 +36136,8 @@ function buildDiagnostics(input) {
 }
 
 // src/server/services/filesystem-sync.ts
-import { readdirSync, readFileSync as readFileSync8, statSync as statSync2, existsSync as existsSync10 } from "node:fs";
-import { join as join14, basename as basename2, dirname as dirname9, relative } from "node:path";
+import { readdirSync as readdirSync2, readFileSync as readFileSync9, statSync as statSync3, existsSync as existsSync13 } from "node:fs";
+import { join as join16, basename as basename3, dirname as dirname10, relative } from "node:path";
 import { watch as watch2 } from "chokidar";
 
 // src/server/services/parsers/reviewer-parser.ts
@@ -35586,67 +36340,67 @@ var FilesystemSync = class {
   debounceTimers = /* @__PURE__ */ new Map();
   // ── 6.1: Full Scan ──
   async fullScan() {
-    if (!existsSync10(this.sessionsDir)) return;
-    const entries = readdirSync(this.sessionsDir, { withFileTypes: true });
+    if (!existsSync13(this.sessionsDir)) return;
+    const entries = readdirSync2(this.sessionsDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
       const sessionId = entry.name;
-      const sessionDir = join14(this.sessionsDir, sessionId);
+      const sessionDir = join16(this.sessionsDir, sessionId);
       this.syncSession(sessionId, sessionDir);
     }
   }
   syncSession(sessionId, sessionDir) {
     this.ensureSessionRow(sessionId, sessionDir);
-    const roundsDir = join14(sessionDir, "rounds");
-    if (existsSync10(roundsDir)) {
-      const rounds = readdirSync(roundsDir, { withFileTypes: true });
+    const roundsDir = join16(sessionDir, "rounds");
+    if (existsSync13(roundsDir)) {
+      const rounds = readdirSync2(roundsDir, { withFileTypes: true });
       for (const roundEntry of rounds) {
         if (!roundEntry.isDirectory()) continue;
         const roundMatch = roundEntry.name.match(/^round-(\d+)$/);
         if (!roundMatch) continue;
         const roundNumber = parseInt(roundMatch[1] ?? "0", 10);
-        const roundDir = join14(roundsDir, roundEntry.name);
-        const reviewsDir = join14(roundDir, "reviews");
-        if (existsSync10(reviewsDir)) {
-          const reviewFiles = readdirSync(reviewsDir).filter((f) => f.endsWith(".md"));
+        const roundDir = join16(roundsDir, roundEntry.name);
+        const reviewsDir = join16(roundDir, "reviews");
+        if (existsSync13(reviewsDir)) {
+          const reviewFiles = readdirSync2(reviewsDir).filter((f) => f.endsWith(".md"));
           for (const reviewFile of reviewFiles) {
-            const filePath = join14(reviewsDir, reviewFile);
+            const filePath = join16(reviewsDir, reviewFile);
             this.processReviewerOutput(sessionId, roundNumber, filePath, reviewFile);
           }
         }
-        const roundMetaPath = join14(roundDir, "round-meta.json");
-        if (existsSync10(roundMetaPath)) {
+        const roundMetaPath = join16(roundDir, "round-meta.json");
+        if (existsSync13(roundMetaPath)) {
           this.processRoundMeta(sessionId, roundNumber, roundMetaPath);
         }
-        const finalPath = join14(roundDir, "final.md");
-        if (existsSync10(finalPath)) {
+        const finalPath = join16(roundDir, "final.md");
+        if (existsSync13(finalPath)) {
           this.processFinalMd(sessionId, roundNumber, finalPath);
         }
-        const finalHumanPath = join14(roundDir, "final-human.md");
-        if (existsSync10(finalHumanPath)) {
+        const finalHumanPath = join16(roundDir, "final-human.md");
+        if (existsSync13(finalHumanPath)) {
           this.processGenericArtifact(sessionId, "final-human", finalHumanPath, roundNumber);
         }
-        const discoursePath = join14(roundDir, "discourse.md");
-        if (existsSync10(discoursePath)) {
+        const discoursePath = join16(roundDir, "discourse.md");
+        if (existsSync13(discoursePath)) {
           this.processGenericArtifact(sessionId, "discourse", discoursePath, roundNumber);
         }
       }
     }
-    const mapDir = join14(sessionDir, "map", "runs");
-    if (existsSync10(mapDir)) {
-      const runs = readdirSync(mapDir, { withFileTypes: true });
+    const mapDir = join16(sessionDir, "map", "runs");
+    if (existsSync13(mapDir)) {
+      const runs = readdirSync2(mapDir, { withFileTypes: true });
       for (const runEntry of runs) {
         if (!runEntry.isDirectory()) continue;
         const runMatch = runEntry.name.match(/^run-(\d+)$/);
         if (!runMatch) continue;
         const runNumber = parseInt(runMatch[1] ?? "0", 10);
-        const runDir = join14(mapDir, runEntry.name);
-        const mapMetaPath = join14(runDir, "map-meta.json");
-        if (existsSync10(mapMetaPath)) {
+        const runDir = join16(mapDir, runEntry.name);
+        const mapMetaPath = join16(runDir, "map-meta.json");
+        if (existsSync13(mapMetaPath)) {
           this.processMapMeta(sessionId, runNumber, mapMetaPath);
         }
-        const mapPath = join14(runDir, "map.md");
-        if (existsSync10(mapPath)) {
+        const mapPath = join16(runDir, "map.md");
+        if (existsSync13(mapPath)) {
           this.processMapMd(sessionId, runNumber, mapPath);
         }
         const mapArtifacts = [
@@ -35655,8 +36409,8 @@ var FilesystemSync = class {
           ["requirements-mapping.md", "requirements-mapping"]
         ];
         for (const [fileName, artifactType] of mapArtifacts) {
-          const filePath = join14(runDir, fileName);
-          if (existsSync10(filePath)) {
+          const filePath = join16(runDir, fileName);
+          if (existsSync13(filePath)) {
             this.processGenericArtifact(sessionId, artifactType, filePath, void 0, runNumber);
           }
         }
@@ -35667,8 +36421,8 @@ var FilesystemSync = class {
       ["discovered-standards.md", "discovered-standards"]
     ];
     for (const [fileName, artifactType] of sessionArtifacts) {
-      const filePath = join14(sessionDir, fileName);
-      if (existsSync10(filePath)) {
+      const filePath = join16(sessionDir, fileName);
+      if (existsSync13(filePath)) {
         this.processGenericArtifact(sessionId, artifactType, filePath);
       }
     }
@@ -35677,58 +36431,58 @@ var FilesystemSync = class {
   ensureSessionRow(sessionId, sessionDir) {
     const branchMatch = sessionId.match(/^\d{4}-\d{2}-\d{2}-(.+)$/);
     const branch = branchMatch?.[1] ?? "unknown";
-    const hasRoundsDir = existsSync10(join14(sessionDir, "rounds"));
-    const hasMapDir = existsSync10(join14(sessionDir, "map"));
+    const hasRoundsDir = existsSync13(join16(sessionDir, "rounds"));
+    const hasMapDir = existsSync13(join16(sessionDir, "map"));
     const workflowType = hasMapDir && !hasRoundsDir ? "map" : "review";
     let currentRound = 1;
     if (hasRoundsDir) {
-      const roundDirs = readdirSync(join14(sessionDir, "rounds")).filter((d) => d.match(/^round-\d+$/));
+      const roundDirs = readdirSync2(join16(sessionDir, "rounds")).filter((d) => d.match(/^round-\d+$/));
       currentRound = Math.max(1, roundDirs.length);
     }
     let currentMapRun = 1;
-    const mapRunsDir = join14(sessionDir, "map", "runs");
-    if (existsSync10(mapRunsDir)) {
-      const runDirs = readdirSync(mapRunsDir).filter((d) => d.match(/^run-\d+$/));
+    const mapRunsDir = join16(sessionDir, "map", "runs");
+    if (existsSync13(mapRunsDir)) {
+      const runDirs = readdirSync2(mapRunsDir).filter((d) => d.match(/^run-\d+$/));
       currentMapRun = Math.max(1, runDirs.length);
     }
     let phase = "context";
     let phaseNumber = 1;
     let status = "closed";
     if (workflowType === "review" && hasRoundsDir) {
-      const roundDir = join14(sessionDir, "rounds", `round-${currentRound}`);
-      if (existsSync10(join14(roundDir, "final.md"))) {
+      const roundDir = join16(sessionDir, "rounds", `round-${currentRound}`);
+      if (existsSync13(join16(roundDir, "final.md"))) {
         phase = "complete";
         phaseNumber = 8;
         status = "closed";
-      } else if (existsSync10(join14(roundDir, "discourse.md"))) {
+      } else if (existsSync13(join16(roundDir, "discourse.md"))) {
         phase = "synthesis";
         phaseNumber = 7;
-      } else if (existsSync10(join14(roundDir, "reviews")) && readdirSync(join14(roundDir, "reviews")).filter((f) => f.endsWith(".md")).length > 0) {
+      } else if (existsSync13(join16(roundDir, "reviews")) && readdirSync2(join16(roundDir, "reviews")).filter((f) => f.endsWith(".md")).length > 0) {
         phase = "reviews";
         phaseNumber = 4;
-      } else if (existsSync10(join14(sessionDir, "context.md"))) {
+      } else if (existsSync13(join16(sessionDir, "context.md"))) {
         phase = "analysis";
         phaseNumber = 3;
-      } else if (existsSync10(join14(sessionDir, "discovered-standards.md"))) {
+      } else if (existsSync13(join16(sessionDir, "discovered-standards.md"))) {
         phase = "change-context";
         phaseNumber = 2;
       }
     } else if (workflowType === "map" && hasMapDir) {
-      const runDir = join14(mapRunsDir, `run-${currentMapRun}`);
-      if (existsSync10(join14(runDir, "map.md"))) {
+      const runDir = join16(mapRunsDir, `run-${currentMapRun}`);
+      if (existsSync13(join16(runDir, "map.md"))) {
         phase = "complete";
         phaseNumber = 6;
         status = "closed";
-      } else if (existsSync10(join14(runDir, "requirements-mapping.md"))) {
+      } else if (existsSync13(join16(runDir, "requirements-mapping.md"))) {
         phase = "synthesis";
         phaseNumber = 5;
-      } else if (existsSync10(join14(runDir, "flow-analysis.md"))) {
+      } else if (existsSync13(join16(runDir, "flow-analysis.md"))) {
         phase = "requirements-mapping";
         phaseNumber = 4;
-      } else if (existsSync10(join14(runDir, "topology.md"))) {
+      } else if (existsSync13(join16(runDir, "topology.md"))) {
         phase = "flow-analysis";
         phaseNumber = 3;
-      } else if (existsSync10(join14(sessionDir, "discovered-standards.md"))) {
+      } else if (existsSync13(join16(sessionDir, "discovered-standards.md"))) {
         phase = "topology";
         phaseNumber = 2;
       }
@@ -35781,9 +36535,9 @@ var FilesystemSync = class {
   /** Returns true if the directory contains at least one .md or .json file (recursively). */
   hasArtifacts(dir) {
     try {
-      for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      for (const entry of readdirSync2(dir, { withFileTypes: true })) {
         if (entry.isDirectory()) {
-          if (this.hasArtifacts(join14(dir, entry.name))) return true;
+          if (this.hasArtifacts(join16(dir, entry.name))) return true;
         } else if (/\.(md|json)$/.test(entry.name)) {
           return true;
         }
@@ -35796,7 +36550,7 @@ var FilesystemSync = class {
   shouldSkip(filePath, existingParsedAt) {
     if (!existingParsedAt) return false;
     try {
-      const mtime = statSync2(filePath).mtime;
+      const mtime = statSync3(filePath).mtime;
       const parsedAt = new Date(existingParsedAt);
       return mtime <= parsedAt;
     } catch {
@@ -35811,13 +36565,19 @@ var FilesystemSync = class {
       "SELECT id FROM markdown_artifacts WHERE session_id = ? AND artifact_type = ? AND round_number IS ? AND file_path = ?",
       [sessionId, artifactType, roundNumber ?? null, relPath]
     );
-    const isUpdate = existing !== null;
+    if (existing !== null) {
+      this.db.run(
+        `UPDATE markdown_artifacts SET content = ?, parsed_at = datetime('now') WHERE id = ?`,
+        [content, existing]
+      );
+      return "updated";
+    }
     this.db.run(
-      `INSERT OR REPLACE INTO markdown_artifacts (session_id, artifact_type, round_number, file_path, content, parsed_at)
+      `INSERT INTO markdown_artifacts (session_id, artifact_type, round_number, file_path, content, parsed_at)
        VALUES (?, ?, ?, ?, ?, datetime('now'))`,
       [sessionId, artifactType, roundNumber ?? null, relPath, content]
     );
-    return isUpdate ? "updated" : "created";
+    return "created";
   }
   // ── 6.7: Socket.IO Emission ──
   emitArtifactEvent(action, event) {
@@ -35833,12 +36593,12 @@ var FilesystemSync = class {
     );
     if (existingRun && this.shouldSkip(filePath, existingRun["parsed_at"] ?? null)) return;
     if (existingRun?.["source"] === "orchestrator") {
-      const content2 = readFileSync8(filePath, "utf-8");
+      const content2 = readFileSync9(filePath, "utf-8");
       const action2 = this.upsertMarkdownArtifact(sessionId, "map", filePath, content2, void 0);
       this.emitArtifactEvent(action2, { sessionId, artifactType: "map", filePath });
       return;
     }
-    const content = readFileSync8(filePath, "utf-8");
+    const content = readFileSync9(filePath, "utf-8");
     const parsed = parseMapMd(content);
     this.db.run(
       `INSERT OR REPLACE INTO map_runs (session_id, run_number, file_count, map_md_path, parsed_at, source)
@@ -35964,7 +36724,7 @@ var FilesystemSync = class {
     const roundId = roundRow?.["id"];
     if (!roundId) return;
     if (roundRow?.["source"] === "orchestrator") {
-      const content2 = readFileSync8(filePath, "utf-8");
+      const content2 = readFileSync9(filePath, "utf-8");
       const action2 = this.upsertMarkdownArtifact(sessionId, "reviewer-output", filePath, content2, roundNumber);
       this.emitArtifactEvent(action2, {
         sessionId,
@@ -35983,7 +36743,7 @@ var FilesystemSync = class {
       [roundId, reviewerType, instanceNumber]
     );
     if (existingOutput && this.shouldSkip(filePath, existingOutput["parsed_at"] ?? null)) return;
-    const content = readFileSync8(filePath, "utf-8");
+    const content = readFileSync9(filePath, "utf-8");
     const parsed = parseReviewerOutput(content);
     this.db.run(
       `INSERT OR REPLACE INTO reviewer_outputs (round_id, reviewer_type, instance_number, file_path, finding_count, parsed_at)
@@ -36071,7 +36831,7 @@ var FilesystemSync = class {
     if (existingRound?.["source"] === "orchestrator" && this.shouldSkip(filePath, existingRound["parsed_at"] ?? null)) return;
     let raw;
     try {
-      raw = JSON.parse(readFileSync8(filePath, "utf-8"));
+      raw = JSON.parse(readFileSync9(filePath, "utf-8"));
     } catch {
       console.error(`[FilesystemSync] Failed to parse ${filePath}`);
       return;
@@ -36117,12 +36877,12 @@ var FilesystemSync = class {
         this.db.run("COMMIT");
         return;
       }
-      const roundDir = dirname9(filePath);
+      const roundDir = dirname10(filePath);
       for (const reviewer of meta.reviewers) {
         const reviewerType = reviewer.type ?? "unknown";
         const instanceNumber = reviewer.instance ?? 1;
         const findings = reviewer.findings ?? [];
-        const reviewerMdPath = join14(roundDir, "reviews", `${reviewerType}-${instanceNumber}.md`);
+        const reviewerMdPath = join16(roundDir, "reviews", `${reviewerType}-${instanceNumber}.md`);
         this.db.run(
           `INSERT OR REPLACE INTO reviewer_outputs (round_id, reviewer_type, instance_number, file_path, finding_count, parsed_at)
            VALUES (?, ?, ?, ?, ?, ?)`,
@@ -36220,7 +36980,7 @@ var FilesystemSync = class {
     if (existingRun?.["source"] === "orchestrator" && this.shouldSkip(filePath, existingRun["parsed_at"] ?? null)) return;
     let raw;
     try {
-      raw = JSON.parse(readFileSync8(filePath, "utf-8"));
+      raw = JSON.parse(readFileSync9(filePath, "utf-8"));
     } catch {
       console.error(`[FilesystemSync] Failed to parse ${filePath}`);
       return;
@@ -36348,7 +37108,7 @@ var FilesystemSync = class {
     );
     const isOrchestratorSource = existingRound?.["source"] === "orchestrator";
     if (!isOrchestratorSource && existingRound && this.shouldSkip(filePath, existingRound["parsed_at"] ?? null)) return;
-    const content = readFileSync8(filePath, "utf-8");
+    const content = readFileSync9(filePath, "utf-8");
     if (isOrchestratorSource) {
       this.db.run(
         `UPDATE review_rounds SET final_md_path = ?, parsed_at = ?
@@ -36427,7 +37187,7 @@ var FilesystemSync = class {
       [sessionId, artifactType, relPath]
     );
     if (existing && this.shouldSkip(filePath, existing["parsed_at"] ?? null)) return;
-    const content = readFileSync8(filePath, "utf-8");
+    const content = readFileSync9(filePath, "utf-8");
     const action = this.upsertMarkdownArtifact(sessionId, artifactType, filePath, content, roundNumber);
     this.emitArtifactEvent(action, {
       sessionId,
@@ -36446,7 +37206,7 @@ var FilesystemSync = class {
       ignored: [
         // Only ignore entries whose own name starts with a dot — the old regex
         // /(^|[/\\])\../ matched `.ocr` in the parent path, silencing ALL events.
-        (filePath) => basename2(filePath).startsWith("."),
+        (filePath) => basename3(filePath).startsWith("."),
         /node_modules/,
         /\.db$/
       ]
@@ -36485,9 +37245,9 @@ var FilesystemSync = class {
     const parts = relFromSessions.split("/");
     const sessionId = parts[0];
     if (!sessionId) return;
-    const sessionDir = join14(this.sessionsDir, sessionId);
+    const sessionDir = join16(this.sessionsDir, sessionId);
     this.ensureSessionRow(sessionId, sessionDir);
-    const fileName = basename2(filePath);
+    const fileName = basename3(filePath);
     const reviewerMatch = relFromSessions.match(/rounds\/round-(\d+)\/reviews\/(.+\.md)$/);
     if (reviewerMatch) {
       const roundNumber = parseInt(reviewerMatch[1] ?? "0", 10);
@@ -36557,8 +37317,8 @@ var FilesystemSync = class {
 };
 
 // src/server/services/db-sync-watcher.ts
-import { existsSync as existsSync11 } from "node:fs";
-import { dirname as dirname10, basename as basename3 } from "node:path";
+import { existsSync as existsSync14 } from "node:fs";
+import { dirname as dirname11, basename as basename4 } from "node:path";
 import { watch as watch3 } from "chokidar";
 function col(row, key) {
   return row[key] ?? null;
@@ -36599,9 +37359,9 @@ var DbSyncWatcher = class {
   }
   /** Start watching the DB file (and its WAL sidecar) for external writes. */
   startWatching() {
-    if (!existsSync11(this.dbFilePath)) return;
-    const watchDir = dirname10(this.dbFilePath);
-    const dbFile = basename3(this.dbFilePath);
+    if (!existsSync14(this.dbFilePath)) return;
+    const watchDir = dirname11(this.dbFilePath);
+    const dbFile = basename4(this.dbFilePath);
     const walFile = `${dbFile}-wal`;
     this.watcher = watch3(watchDir, {
       persistent: true,
@@ -36611,7 +37371,7 @@ var DbSyncWatcher = class {
       interval: 200
     });
     const onAnyEvent = (path2) => {
-      const name = basename3(path2);
+      const name = basename4(path2);
       if (name === dbFile || name === walFile) this.debouncedSync();
     };
     this.watcher.on("change", onAnyEvent);
@@ -36862,20 +37622,20 @@ function commandFingerprint(row) {
 }
 
 // src/server/socket/chat-handler.ts
-import { dirname as dirname11 } from "node:path";
+import { dirname as dirname12 } from "node:path";
 
 // src/server/services/chat-context.ts
-import { readFileSync as readFileSync9, readdirSync as readdirSync2, existsSync as existsSync12 } from "node:fs";
-import { join as join15 } from "node:path";
+import { readFileSync as readFileSync10, readdirSync as readdirSync3, existsSync as existsSync15 } from "node:fs";
+import { join as join17 } from "node:path";
 function buildChatContext(ocrDir, target) {
-  const sessionsDir = join15(ocrDir, "sessions");
+  const sessionsDir = join17(ocrDir, "sessions");
   if (target.type === "map_run") {
     return buildMapRunContext(sessionsDir, target.sessionId, target.runNumber);
   }
   return buildReviewRoundContext(sessionsDir, target.sessionId, target.roundNumber);
 }
 function buildMapRunContext(sessionsDir, sessionId, runNumber) {
-  const mapPath = join15(
+  const mapPath = join17(
     sessionsDir,
     sessionId,
     "map",
@@ -36889,8 +37649,8 @@ function buildMapRunContext(sessionsDir, sessionId, runNumber) {
     "",
     `Below is the Code Review Map that organizes the changeset into reviewable sections:`
   ];
-  if (existsSync12(mapPath)) {
-    const content = readFileSync9(mapPath, "utf-8");
+  if (existsSync15(mapPath)) {
+    const content = readFileSync10(mapPath, "utf-8");
     parts.push("");
     parts.push("<map>");
     parts.push(content);
@@ -36902,26 +37662,26 @@ function buildMapRunContext(sessionsDir, sessionId, runNumber) {
   return parts.join("\n");
 }
 function buildReviewRoundContext(sessionsDir, sessionId, roundNumber) {
-  const roundDir = join15(sessionsDir, sessionId, "rounds", `round-${roundNumber}`);
-  const finalPath = join15(roundDir, "final.md");
-  const reviewersDir = join15(roundDir, "reviews");
+  const roundDir = join17(sessionsDir, sessionId, "rounds", `round-${roundNumber}`);
+  const finalPath = join17(roundDir, "final.md");
+  const reviewersDir = join17(roundDir, "reviews");
   const parts = [
     `You are an expert code reviewer assisting with a code review session.`,
     `You are looking at review round #${roundNumber} for session "${sessionId}".`,
     "",
     `Below are the review artifacts for this round:`
   ];
-  if (existsSync12(finalPath)) {
-    const content = readFileSync9(finalPath, "utf-8");
+  if (existsSync15(finalPath)) {
+    const content = readFileSync10(finalPath, "utf-8");
     parts.push("");
     parts.push("<final-synthesis>");
     parts.push(content);
     parts.push("</final-synthesis>");
   }
-  if (existsSync12(reviewersDir)) {
-    const files = readdirSync2(reviewersDir).filter((f) => f.endsWith(".md")).sort();
+  if (existsSync15(reviewersDir)) {
+    const files = readdirSync3(reviewersDir).filter((f) => f.endsWith(".md")).sort();
     for (const file of files) {
-      const content = readFileSync9(join15(reviewersDir, file), "utf-8");
+      const content = readFileSync10(join17(reviewersDir, file), "utf-8");
       const reviewerName = file.replace(/\.md$/, "");
       parts.push("");
       parts.push(`<reviewer name="${reviewerName}">`);
@@ -36929,7 +37689,7 @@ function buildReviewRoundContext(sessionsDir, sessionId, roundNumber) {
       parts.push("</reviewer>");
     }
   }
-  if (!existsSync12(finalPath) && !existsSync12(reviewersDir)) {
+  if (!existsSync15(finalPath) && !existsSync15(reviewersDir)) {
     parts.push("");
     parts.push("(No review artifacts found on disk for this round.)");
   }
@@ -37075,7 +37835,7 @@ User: ${message}`;
         });
         return;
       }
-      const repoRoot = dirname11(ocrDir);
+      const repoRoot = dirname12(ocrDir);
       const spawnResult = adapter.spawn({
         prompt,
         cwd: repoRoot,
@@ -37251,13 +38011,13 @@ function cleanupAllChats() {
 }
 
 // src/server/socket/post-handler.ts
-import { existsSync as existsSync13, mkdirSync as mkdirSync5, readFileSync as readFileSync10, unlinkSync as unlinkSync2, writeFileSync as writeFileSync4 } from "node:fs";
+import { existsSync as existsSync16, mkdirSync as mkdirSync6, readFileSync as readFileSync11, unlinkSync as unlinkSync4, writeFileSync as writeFileSync5 } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
-import { join as join16, dirname as dirname12, isAbsolute as isAbsolute2 } from "node:path";
+import { join as join18, dirname as dirname13, isAbsolute as isAbsolute2 } from "node:path";
 import { randomUUID as randomUUID2 } from "node:crypto";
 function resolveSessionDir2(sessionDir, ocrDir) {
   if (isAbsolute2(sessionDir)) return sessionDir;
-  return join16(dirname12(ocrDir), sessionDir);
+  return join18(dirname13(ocrDir), sessionDir);
 }
 var BRANCH_PREFIXES = [
   "feat",
@@ -37326,7 +38086,7 @@ function registerPostHandlers(io2, socket, db, ocrDir, aiCliService) {
         return;
       }
       const branch = session.branch;
-      const repoRoot = dirname12(ocrDir);
+      const repoRoot = dirname13(ocrDir);
       try {
         await execBinaryAsync("gh", ["auth", "status"], { env: cleanEnv(), cwd: repoRoot, encoding: "utf-8" });
       } catch {
@@ -37427,19 +38187,19 @@ function registerPostHandlers(io2, socket, db, ocrDir, aiCliService) {
         socket.emit("post:error", { error: "Session not found" });
         return;
       }
-      const sessionDir = session.session_dir ? resolveSessionDir2(session.session_dir, ocrDir) : join16(ocrDir, "sessions", sessionId);
-      const roundDir = join16(sessionDir, "rounds", `round-${roundNumber}`);
-      const finalPath = join16(roundDir, "final.md");
-      if (!existsSync13(finalPath)) {
+      const sessionDir = session.session_dir ? resolveSessionDir2(session.session_dir, ocrDir) : join18(ocrDir, "sessions", sessionId);
+      const roundDir = join18(sessionDir, "rounds", `round-${roundNumber}`);
+      const finalPath = join18(roundDir, "final.md");
+      if (!existsSync16(finalPath)) {
         socket.emit("post:error", { error: "final.md not found for this round" });
         return;
       }
-      const humanReviewPath = join16(roundDir, "final-human.md");
-      const repoRoot = dirname12(ocrDir);
-      const commandMdPath = join16(ocrDir, "commands", "translate-review-to-single-human.md");
+      const humanReviewPath = join18(roundDir, "final-human.md");
+      const repoRoot = dirname13(ocrDir);
+      const commandMdPath = join18(ocrDir, "commands", "translate-review-to-single-human.md");
       let commandContent;
       try {
-        commandContent = readFileSync10(commandMdPath, "utf-8");
+        commandContent = readFileSync11(commandMdPath, "utf-8");
       } catch {
         socket.emit("post:error", {
           error: `Command file not found: ${commandMdPath}. Run \`ocr init\` to set up.`
@@ -37519,9 +38279,9 @@ function registerPostHandlers(io2, socket, db, ocrDir, aiCliService) {
           }
         }
         let generatedContent = "";
-        if (existsSync13(humanReviewPath)) {
+        if (existsSync16(humanReviewPath)) {
           try {
-            generatedContent = readFileSync10(humanReviewPath, "utf-8").trim();
+            generatedContent = readFileSync11(humanReviewPath, "utf-8").trim();
           } catch {
           }
         }
@@ -37596,11 +38356,11 @@ function registerPostHandlers(io2, socket, db, ocrDir, aiCliService) {
           socket.emit("post:save-result", { success: false, error: "Session not found" });
           return;
         }
-        const sessionDir = session.session_dir ? resolveSessionDir2(session.session_dir, ocrDir) : join16(ocrDir, "sessions", sessionId);
-        const roundDir = join16(sessionDir, "rounds", `round-${roundNumber}`);
-        mkdirSync5(roundDir, { recursive: true });
-        const filePath = join16(roundDir, "final-human.md");
-        writeFileSync4(filePath, content, { mode: 420 });
+        const sessionDir = session.session_dir ? resolveSessionDir2(session.session_dir, ocrDir) : join18(ocrDir, "sessions", sessionId);
+        const roundDir = join18(sessionDir, "rounds", `round-${roundNumber}`);
+        mkdirSync6(roundDir, { recursive: true });
+        const filePath = join18(roundDir, "final-human.md");
+        writeFileSync5(filePath, content, { mode: 420 });
         socket.emit("post:save-result", { success: true });
       } catch (err) {
         console.error("Error in post:save handler:", err);
@@ -37626,14 +38386,14 @@ function registerPostHandlers(io2, socket, db, ocrDir, aiCliService) {
         );
         tracker.appendOutput(`\u25B8 Posting review to PR #${prNumber}...
 `);
-        const tmpDir = join16(tmpdir2(), "ocr-post-comments");
+        const tmpDir = join18(tmpdir2(), "ocr-post-comments");
         try {
-          mkdirSync5(tmpDir, { recursive: true, mode: 448 });
+          mkdirSync6(tmpDir, { recursive: true, mode: 448 });
         } catch {
         }
-        const tmpFile = join16(tmpDir, `${randomUUID2()}.md`);
-        writeFileSync4(tmpFile, content, { mode: 384 });
-        const repoRoot = dirname12(ocrDir);
+        const tmpFile = join18(tmpDir, `${randomUUID2()}.md`);
+        writeFileSync5(tmpFile, content, { mode: 384 });
+        const repoRoot = dirname13(ocrDir);
         try {
           const { stdout } = await execBinaryAsync(
             "gh",
@@ -37656,7 +38416,7 @@ function registerPostHandlers(io2, socket, db, ocrDir, aiCliService) {
           });
         } finally {
           try {
-            unlinkSync2(tmpFile);
+            unlinkSync4(tmpFile);
           } catch {
           }
         }
@@ -37676,45 +38436,9 @@ function cleanupAllPostGenerations() {
   }
 }
 
-// ../cli/src/lib/runtime-config.ts
-import { existsSync as existsSync14, readFileSync as readFileSync11 } from "node:fs";
-import { join as join17 } from "node:path";
-var DEFAULT_AGENT_HEARTBEAT_SECONDS = 60;
-function getAgentHeartbeatSeconds(ocrDir) {
-  const configPath = join17(ocrDir, "config.yaml");
-  if (!existsSync14(configPath)) {
-    return DEFAULT_AGENT_HEARTBEAT_SECONDS;
-  }
-  let content;
-  try {
-    content = readFileSync11(configPath, "utf-8");
-  } catch {
-    return DEFAULT_AGENT_HEARTBEAT_SECONDS;
-  }
-  const blockMatch = content.match(
-    /^runtime:\s*\n(?:\s+[^\n]*\n)*?\s+agent_heartbeat_seconds:\s*([^\s#\n]+)/m
-  );
-  const inlineMatch = content.match(
-    /^runtime:\s*\{[^}]*\bagent_heartbeat_seconds:\s*([^\s,}]+)/m
-  );
-  const raw = blockMatch?.[1] ?? inlineMatch?.[1];
-  if (!raw) {
-    return DEFAULT_AGENT_HEARTBEAT_SECONDS;
-  }
-  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.
-`
-    );
-    return DEFAULT_AGENT_HEARTBEAT_SECONDS;
-  }
-  return parsed;
-}
-
 // src/server/index.ts
 import { homedir } from "node:os";
-var __dirname3 = dirname13(fileURLToPath3(import.meta.url));
+var __dirname3 = dirname14(fileURLToPath3(import.meta.url));
 function shortenPath(p) {
   const home = homedir();
   return p.startsWith(home) ? "~" + p.slice(home.length) : p;
@@ -37778,40 +38502,61 @@ if (process.env.NODE_ENV !== "production") {
     res.json({ token: AUTH_TOKEN });
   });
 }
+function isOcrDashboardProcess(pid) {
+  if (process.platform === "win32") return false;
+  try {
+    const cmd = execFileSync3("ps", ["-p", String(pid), "-o", "command="], {
+      encoding: "utf-8",
+      timeout: 3e3
+    }).trim();
+    if (/^ocr-dashboard\b/.test(cmd)) return true;
+    return /dashboard\/server\.js|server\/index\.ts/.test(cmd);
+  } catch {
+    return false;
+  }
+}
 async function startServer(options = {}) {
   const port = options.port ?? parseInt(process.env.PORT ?? "4173", 10);
+  process.title = "ocr-dashboard";
   const ocrDir = resolveOcrDir();
   const aiCliService = new AiCliService(ocrDir);
-  const dbPathForCheckpoint = join18(ocrDir, "data", "ocr.db");
+  const dbPathForCheckpoint = join19(ocrDir, "data", "ocr.db");
   const walResult = walCheckpointTruncate(dbPathForCheckpoint);
   if (walResult === "checkpointed") {
     console.log("  WAL checkpoint:    truncated stale write-ahead-log file");
   }
+  for (const reaped of reapOrphanDbFiles(join19(ocrDir, "data"))) {
+    console.log(`  Orphan reap:       removed stale ${reaped}`);
+  }
+  const staleLogs = reapStaleExecLogs(join19(ocrDir, "data", "exec-logs"));
+  if (staleLogs.length > 0) {
+    console.log(`  Exec-log reap:     removed ${staleLogs.length} stale agent log(s)`);
+  }
   const db = await openDb(ocrDir);
-  const dataDir = join18(ocrDir, "data");
-  const pidFilePath = join18(dataDir, "dashboard.pid");
-  const portFilePath = join18(dataDir, "server-port");
-  mkdirSync6(dataDir, { recursive: true });
+  const dataDir = join19(ocrDir, "data");
+  const pidFilePath = join19(dataDir, "dashboard.pid");
+  const portFilePath = join19(dataDir, "server-port");
+  mkdirSync7(dataDir, { recursive: true });
   try {
-    unlinkSync3(portFilePath);
+    unlinkSync5(portFilePath);
   } catch {
   }
-  if (existsSync15(pidFilePath)) {
+  if (existsSync17(pidFilePath)) {
     try {
       const oldPid = parseInt(readFileSync12(pidFilePath, "utf-8").trim(), 10);
-      if (!isNaN(oldPid)) {
-        try {
-          process.kill(oldPid, 0);
-          console.warn(
-            `Warning: another dashboard server (PID ${oldPid}) appears to be running. If this is stale, delete ${pidFilePath} and restart.`
-          );
-        } catch {
+      if (!isNaN(oldPid) && oldPid !== process.pid && isProcessAlive(oldPid) && isOcrDashboardProcess(oldPid)) {
+        console.log(`  Single-instance:   reaping prior dashboard server (PID ${oldPid}) and taking over`);
+        reapTree(oldPid);
+        const deadline = Date.now() + 6e3;
+        while (isProcessAlive(oldPid) && Date.now() < deadline) {
+          await new Promise((resolve3) => setTimeout(resolve3, 100));
         }
+        walCheckpointTruncate(dbPathForCheckpoint);
       }
     } catch {
     }
   }
-  writeFileSync5(pidFilePath, String(process.pid), { mode: 384 });
+  writeFileSync6(pidFilePath, String(process.pid), { mode: 384 });
   const cmdCountResult = db.exec("SELECT COUNT(*) as c FROM command_executions");
   const totalCmds = cmdCountResult[0]?.values[0]?.[0] ?? 0;
   if (totalCmds === 0) {
@@ -37821,7 +38566,7 @@ async function startServer(options = {}) {
     }
   }
   const orphanResult = db.exec(
-    `SELECT id, pid, is_detached, started_at FROM command_executions
+    `SELECT id, pid, started_at FROM command_executions
      WHERE pid IS NOT NULL AND finished_at IS NULL`
   );
   if (orphanResult.length > 0 && orphanResult[0]) {
@@ -37831,37 +38576,15 @@ async function startServer(options = {}) {
     let killedCount = 0;
     for (const row of orphanRows) {
       const pid = row[colIdx["pid"]];
-      const isDetached = row[colIdx["is_detached"]] === 1;
       const startedAt = row[colIdx["started_at"]];
       if (sqliteUtcMs(startedAt) < cutoff) continue;
       if (defaultIsAlive(pid)) {
-        if (isDetached) {
-          try {
-            process.kill(-pid, "SIGTERM");
-          } catch {
-            process.kill(pid, "SIGTERM");
-          }
-        } else {
-          process.kill(pid, "SIGTERM");
-        }
+        reapTree(pid);
         killedCount++;
-        setTimeout(() => {
-          try {
-            process.kill(pid, 0);
-            if (isDetached) {
-              try {
-                process.kill(-pid, "SIGKILL");
-              } catch {
-              }
-            }
-            process.kill(pid, "SIGKILL");
-          } catch {
-          }
-        }, 2e3);
       }
     }
     if (killedCount > 0) {
-      console.log(`  Cleaned up ${killedCount} orphaned process(es)`);
+      console.log(`  Reaped ${killedCount} orphaned process tree(s)`);
     }
   }
   const legacyResult = db.exec(
@@ -37871,10 +38594,11 @@ async function startServer(options = {}) {
   if (legacyCount > 0) {
     db.run(
       `UPDATE command_executions
-       SET exit_code = -2,
+       SET exit_code = ?,
            output = COALESCE(output, '') || '
 [Cancelled]'
-       WHERE finished_at IS NOT NULL AND exit_code IS NULL`
+       WHERE finished_at IS NOT NULL AND exit_code IS NULL`,
+      [CANCELLED_EXIT_CODE]
     );
     console.log(`  Backfilled ${legacyCount} finished command(s) missing an exit code`);
   }
@@ -37897,11 +38621,25 @@ async function startServer(options = {}) {
       `  Auto-closed ${staleSessionResult.closedSessionIds.length} stale active session(s) (threshold 7 days)`
     );
   }
+  const reconcileCompleted = async () => {
+    try {
+      const closed = await reconcileCompletedSessions(ocrDir);
+      if (closed.length > 0) {
+        console.log(
+          `  Auto-finalized ${closed.length} completed-but-open session(s)`
+        );
+      }
+    } catch (err) {
+      console.error("[reconcile] completed-session reconciliation failed:", err);
+    }
+  };
+  await reconcileCompleted();
   const SWEEP_INTERVAL_MS = 5 * 60 * 1e3;
   const sweepTimer = setInterval(() => {
     try {
       logAgentSweep(sweepStaleAgentSessions(db, heartbeatSeconds, defaultIsAlive));
       sweepStaleSessions(db, STALE_SESSION_THRESHOLD_SECONDS);
+      void reconcileCompleted();
     } catch (err) {
       console.error("[sweep] periodic sweep failed:", err);
     }
@@ -37937,11 +38675,11 @@ async function startServer(options = {}) {
   app.use("/api/agent-sessions", createAgentSessionsRouter(db, () => pullSync()));
   app.use("/api/sessions", createHandoffRouter(sessionCapture, ocrDir, () => pullSync()));
   app.use("/api/team", createTeamRouter(ocrDir));
-  const clientDir = join18(__dirname3, "client");
-  if (process.env.NODE_ENV === "production" && existsSync15(clientDir)) {
+  const clientDir = join19(__dirname3, "client");
+  if (process.env.NODE_ENV === "production" && existsSync17(clientDir)) {
     app.use(import_express15.default.static(clientDir, { index: false }));
-    const indexHtmlPath = join18(clientDir, "index.html");
-    const rawIndexHtml = existsSync15(indexHtmlPath) ? readFileSync12(indexHtmlPath, "utf-8") : "";
+    const indexHtmlPath = join19(clientDir, "index.html");
+    const rawIndexHtml = existsSync17(indexHtmlPath) ? readFileSync12(indexHtmlPath, "utf-8") : "";
     const tokenScript = `<script>window.__OCR_TOKEN__=${JSON.stringify(AUTH_TOKEN)};</script>`;
     const injectedIndexHtml = rawIndexHtml.replace(
       "</head>",
@@ -37960,7 +38698,7 @@ async function startServer(options = {}) {
     registerChatHandlers(io, socket, db, ocrDir, aiCliService);
     registerPostHandlers(io, socket, db, ocrDir, aiCliService);
   });
-  const dbFilePath = join18(ocrDir, "data", "ocr.db");
+  const dbFilePath = join19(ocrDir, "data", "ocr.db");
   const dbSyncWatcher = new DbSyncWatcher(
     db,
     dbFilePath,
@@ -37976,7 +38714,7 @@ async function startServer(options = {}) {
   dbSyncWatcher.startWatching();
   pullSync = () => dbSyncWatcher.syncFromDisk();
   console.log(`  Watching DB:       ${shortenPath(dbFilePath)}`);
-  const sessionsDir = join18(ocrDir, "sessions");
+  const sessionsDir = join19(ocrDir, "sessions");
   const fsSync = new FilesystemSync(db, sessionsDir, io);
   await fsSync.fullScan();
   fsSync.startWatching();
@@ -38015,7 +38753,7 @@ async function startServer(options = {}) {
   if (actualPort !== port) {
     console.log(`  Note: using port ${actualPort} (${port} was in use)`);
   }
-  writeFileSync5(portFilePath, String(actualPort), { mode: 384 });
+  writeFileSync6(portFilePath, String(actualPort), { mode: 384 });
   console.log(`  Server:            http://localhost:${actualPort}`);
   console.log(`  OCR directory:     ${shortenPath(ocrDir)}`);
   console.log();
@@ -38028,53 +38766,40 @@ async function startServer(options = {}) {
     } catch {
     }
   }
-  const shutdown = (signal) => {
+  const shutdown = async (signal) => {
     console.log(
       `Shutting down dashboard server${signal ? ` (received ${signal})` : ""}...`
     );
     try {
-      unlinkSync3(pidFilePath);
-    } catch {
-    }
-    try {
-      unlinkSync3(portFilePath);
+      unlinkSync5(pidFilePath);
     } catch {
     }
     try {
-      unlinkSync3(join18(dataDir, "dashboard-active-spawn.json"));
+      unlinkSync5(portFilePath);
     } catch {
     }
+    clearSpawnMarker(ocrDir);
     try {
       const activeResult = db.exec(
-        "SELECT id, pid, is_detached FROM command_executions WHERE pid IS NOT NULL AND finished_at IS NULL"
+        "SELECT id, pid FROM command_executions WHERE pid IS NOT NULL AND finished_at IS NULL"
       );
       if (activeResult.length > 0 && activeResult[0]) {
         const { columns, values: activeRows } = activeResult[0];
         const colIdx = Object.fromEntries(columns.map((c, i) => [c, i]));
         for (const row of activeRows) {
           const pid = row[colIdx["pid"]];
-          const isDetached = row[colIdx["is_detached"]] === 1;
-          try {
-            if (isDetached) {
-              try {
-                process.kill(-pid, "SIGTERM");
-              } catch {
-                process.kill(pid, "SIGTERM");
-              }
-            } else {
-              process.kill(pid, "SIGTERM");
-            }
-            console.log(`Sent SIGTERM to child process (PID ${pid})`);
-          } catch {
-          }
+          reapTree(pid, 750);
+          console.log(`Reaping child process tree (PID ${pid})`);
         }
+        await new Promise((resolve3) => setTimeout(resolve3, 1e3));
         db.run(
           `UPDATE command_executions
-           SET exit_code = -2, finished_at = datetime('now'),
+           SET exit_code = ?, finished_at = datetime('now'),
                output = COALESCE(output, '') || '
 [Cancelled \u2014 server shutdown]',
                pid = NULL
-           WHERE pid IS NOT NULL AND finished_at IS NULL`
+           WHERE pid IS NOT NULL AND finished_at IS NULL`,
+          [CANCELLED_EXIT_CODE]
         );
       }
     } catch (err) {
@@ -38097,9 +38822,9 @@ async function startServer(options = {}) {
       process.exit(1);
     }, 2e3).unref();
   };
-  process.on("SIGINT", () => shutdown("SIGINT"));
-  process.on("SIGTERM", () => shutdown("SIGTERM"));
-  process.on("SIGHUP", () => shutdown("SIGHUP"));
+  process.on("SIGINT", () => void shutdown("SIGINT"));
+  process.on("SIGTERM", () => void shutdown("SIGTERM"));
+  process.on("SIGHUP", () => void shutdown("SIGHUP"));
   process.on("uncaughtException", (err) => {
     console.error("[dashboard] uncaughtException:", err);
   });