@open-code-review/cli 1.11.0 → 2.1.0

package/dist/dashboard/server.js

@@ -18413,7 +18413,7 @@ var require_view = __commonJS({
     var dirname14 = path2.dirname;
     var basename4 = path2.basename;
     var extname = path2.extname;
-    var join18 = path2.join;
+    var join19 = path2.join;
     var resolve3 = path2.resolve;
     module.exports = View;
     function View(name, options) {
@@ -18461,12 +18461,12 @@ var require_view = __commonJS({
     };
     View.prototype.resolve = function resolve4(dir, file) {
       var ext = this.ext;
-      var path3 = join18(dir, file);
+      var path3 = join19(dir, file);
       var stat = tryStat(path3);
       if (stat && stat.isFile()) {
         return path3;
       }
-      path3 = join18(dir, basename4(file, ext), "index" + ext);
+      path3 = join19(dir, basename4(file, ext), "index" + ext);
       stat = tryStat(path3);
       if (stat && stat.isFile()) {
         return path3;
@@ -19099,7 +19099,7 @@ var require_send = __commonJS({
     var Stream = __require("stream");
     var util = __require("util");
     var extname = path2.extname;
-    var join18 = path2.join;
+    var join19 = 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(join18(root, path3));
+        path3 = normalize(join19(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 = join18(path3, self._index[i]);
+        var p = join19(path3, self._index[i]);
         debug('stat "%s"', p);
         fs6.stat(p, function(err2, stat) {
           if (err2) return next(err2);
@@ -21876,7 +21876,7 @@ var require_response = __commonJS({
     var encodeUrl = require_encodeurl();
     var escapeHtml = require_escape_html();
     var http = __require("http");
-    var isAbsolute2 = require_utils2().isAbsolute;
+    var isAbsolute3 = require_utils2().isAbsolute;
     var onFinished = require_on_finished();
     var path2 = __require("path");
     var statuses = require_statuses();
@@ -22082,7 +22082,7 @@ var require_response = __commonJS({
         done = options;
         opts = {};
       }
-      if (!opts.root && !isAbsolute2(path3)) {
+      if (!opts.root && !isAbsolute3(path3)) {
         throw new TypeError("path must be absolute or specify root to res.sendFile");
       }
       var pathname = encodeURI(path3);
@@ -30483,8 +30483,8 @@ 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 readFileSync15, writeFileSync as writeFileSync7, unlinkSync as unlinkSync3, mkdirSync as mkdirSync7 } from "node:fs";
-import { join as join17, dirname as dirname13, resolve as resolve2 } from "node:path";
+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 { fileURLToPath as fileURLToPath3 } from "node:url";
 import { randomBytes } from "node:crypto";
 import { Server as SocketIOServer } from "socket.io";
@@ -30509,17 +30509,199 @@ function resolveOcrDir(startDir) {
   }
 }
 
-// src/server/db.ts
-import { existsSync as existsSync4, readFileSync as readFileSync3, renameSync as renameSync3, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3 } from "node:fs";
-import { join as join4, dirname as dirname4 } from "node:path";
-import initSqlJs2 from "sql.js";
-
 // ../cli/src/lib/db/index.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync2, renameSync as renameSync2, writeFileSync as writeFileSync2 } from "node:fs";
-import { dirname as dirname3, join as join3 } from "node:path";
+import {
+  existsSync as existsSync4,
+  mkdirSync as mkdirSync2,
+  copyFileSync,
+  statSync,
+  mkdtempSync,
+  rmSync
+} from "node:fs";
+import { dirname as dirname4, join as join4 } from "node:path";
+
+// ../cli/src/lib/db/engine.ts
 import { createRequire } from "node:module";
-import { spawnSync } from "node:child_process";
-import initSqlJs from "sql.js";
+
+// ../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
+var SQLITE_BUSY = 5;
+var SQLITE_BUSY_SNAPSHOT = 261;
+var BUSY_RETRY_ATTEMPTS = 5;
+var BUSY_RETRY_BACKOFF_MS = 50;
+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;
+    }
+  }
+  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(SLEEP_BUF, 0, 0, ms);
+}
+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);
+    const cols = stmt.columns();
+    if (cols.length === 0) {
+      stmt.run(...params ?? []);
+      return [];
+    }
+    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) {
+      this.raw.prepare(sql).run(...params);
+      return;
+    }
+    this.raw.exec(sql);
+  }
+  prepare(sql) {
+    return this.raw.prepare(sql);
+  }
+  transaction(fn) {
+    return this.txnDepth > 0 ? this.runNested(fn) : this.runOuter(fn);
+  }
+  /**
+   * Nested call: a SAVEPOINT within the outer transaction's write lock. No
+   * busy-retry — the outer transaction already holds the lock. The savepoint
+   * lets the inner block roll back independently while the outer continues.
+   */
+  runNested(fn) {
+    const name = savepointName(this.txnDepth);
+    this.raw.exec(`SAVEPOINT ${name}`);
+    this.txnDepth++;
+    try {
+      const result = fn();
+      this.raw.exec(`RELEASE ${name}`);
+      return result;
+    } catch (e) {
+      try {
+        this.raw.exec(`ROLLBACK TO ${name}`);
+        this.raw.exec(`RELEASE ${name}`);
+      } catch {
+      }
+      throw e;
+    } finally {
+      this.txnDepth--;
+    }
+  }
+  /**
+   * Outer transaction: `BEGIN IMMEDIATE` acquires the write lock up front so
+   * cross-process writers serialize cleanly under WAL instead of failing late
+   * on upgrade. `busy_timeout` covers most contention; a bounded synchronous
+   * retry absorbs the residual SQLITE_BUSY (another connection holds the lock
+   * past the timeout, or BUSY_SNAPSHOT). Non-busy errors and the final attempt
+   * re-throw so genuine failures propagate.
+   */
+  runOuter(fn) {
+    for (let attempt = 0; attempt < BUSY_RETRY_ATTEMPTS; attempt++) {
+      try {
+        return this.runOnce(fn);
+      } catch (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) {
+    this.raw.exec(`PRAGMA ${source}`);
+    return void 0;
+  }
+  close() {
+    try {
+      this.raw.exec("PRAGMA wal_checkpoint(TRUNCATE)");
+    } catch {
+    }
+    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 = 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
 var MIGRATIONS = [
@@ -30843,8 +31025,157 @@ var MIGRATIONS = [
       DROP INDEX IF EXISTS idx_agent_sessions_status_heartbeat;
       DROP TABLE IF EXISTS agent_sessions;
     `
+  },
+  {
+    version: 12,
+    description: "Event-sourced lifecycle hardening: event_type taxonomy guard, sweep indexes, session_completeness view",
+    sql: `
+      -- \u2500\u2500 Indexes for the now-periodic stale-session sweep + round derivation \u2500\u2500
+      -- The sweep filters sessions by status and rolls up MAX(created_at) per
+      -- session over the event log; deriveNextRound does MAX(round). Index both.
+      CREATE INDEX IF NOT EXISTS idx_sessions_status ON sessions(status);
+      CREATE INDEX IF NOT EXISTS idx_events_session_created
+        ON orchestration_events(session_id, created_at);
+
+      -- \u2500\u2500 Event-type taxonomy guard \u2500\u2500
+      -- orchestration_events.event_type is the spine of all lifecycle
+      -- derivation. A typo (e.g. 'round_complete' vs 'round_completed') would
+      -- silently break deriveNextRound and the completeness view. SQLite cannot
+      -- add a CHECK to an existing column without a table rebuild, so enforce
+      -- the closed vocabulary with a BEFORE INSERT trigger instead.
+      CREATE TRIGGER IF NOT EXISTS trg_events_known_type
+      BEFORE INSERT ON orchestration_events
+      WHEN NEW.event_type NOT IN (
+        'session_created', 'session_resumed', 'round_started', 'phase_transition',
+        'round_completed', 'map_completed', 'session_closed', 'session_aborted',
+        'session_auto_closed_stale', 'session_synced', 'session_legacy_import'
+      )
+      BEGIN
+        SELECT RAISE(ABORT, 'unknown orchestration_events.event_type');
+      END;
+
+      -- \u2500\u2500 Close-guard (DB backstop for the completion invariant) \u2500\u2500
+      -- A session cannot transition active \u2192 closed unless its current
+      -- round/run has a terminal artifact event, OR an explicit reason event
+      -- (abort / auto-close-stale / sync / legacy-import) is present. Only a
+      -- *silent* premature close is banned \u2014 every legitimate non-artifact
+      -- close carries a reason event and passes. App-level guards in
+      -- stateClose/finish are the primary check; this makes the illegal state
+      -- unrepresentable even via raw SQL.
+      --
+      -- DEFENCE-IN-DEPTH NOTE (intentional, documented gap): the reason-event
+      -- branch below (event_type IN (...)) is NOT round-scoped \u2014 a reason event
+      -- recorded for an earlier round would also satisfy a later close. The
+      -- app-level guards ARE round-scoped (hasCompletionInvariant checks the
+      -- current round/run), so the precise check lives in the application; this
+      -- trigger is a coarse backstop against a *silent* premature close via raw
+      -- SQL. Tightening it to be round-scoped would require a new migration
+      -- (this v12 trigger is append-only and already shipped); the residual
+      -- risk is a non-artifact close carrying a stale reason event, which is
+      -- still an explicit, audited terminal \u2014 not the failure mode this guards.
+      CREATE TRIGGER IF NOT EXISTS trg_sessions_close_guard
+      BEFORE UPDATE OF status ON sessions
+      WHEN NEW.status = 'closed' AND OLD.status <> 'closed'
+        AND NOT EXISTS (
+          SELECT 1 FROM orchestration_events e
+           WHERE e.session_id = NEW.id
+             AND (
+               (NEW.workflow_type = 'review' AND e.event_type = 'round_completed' AND e.round = NEW.current_round)
+               OR (NEW.workflow_type = 'map' AND e.event_type = 'map_completed'   AND e.round = NEW.current_map_run)
+               OR e.event_type IN ('session_aborted','session_auto_closed_stale','session_synced','session_legacy_import')
+             )
+        )
+      BEGIN
+        SELECT RAISE(ABORT, 'cannot close session without a completed round/run or an explicit reason event');
+      END;
+
+      -- \u2500\u2500 session_completeness view \u2500\u2500
+      -- The published contract for "is this session actually complete, and if
+      -- not, what's missing". Completion is DERIVED from the event log, never a
+      -- mutable flag: a session is complete iff it is closed AND a terminal
+      -- artifact event exists for its current round/run. The dashboard's
+      -- outcome derivation and the agent 'status' command read this view, so
+      -- they cannot disagree.
+      --
+      -- completeness_state is an INTENTIONAL HYBRID: it combines the mutable
+      -- status column (marked_closed) with append-only event evidence (the
+      -- terminal artifact event). This is sound precisely because the
+      -- close-guard trigger above makes the status column trustworthy \u2014 a row
+      -- can only reach status='closed' with a completed round/run or an
+      -- explicit reason event \u2014 so reading the column is not a regression to
+      -- the old "mutable flag that could lie" model.
+      --
+      --   completeness_state:
+      --     'complete'                \u2014 closed + terminal artifact for current round/run
+      --     'closed_without_artifact' \u2014 closed but no terminal artifact (the
+      --                                 "completed too soon" condition)
+      --     'in_flight'               \u2014 open with a dependent process still running
+      --     'open_no_artifact'        \u2014 open, no in-flight dependents
+      CREATE VIEW IF NOT EXISTS session_completeness AS
+      SELECT
+        s.id              AS session_id,
+        s.workflow_type   AS workflow_type,
+        s.status          AS status,
+        s.current_round   AS current_round,
+        s.current_map_run AS current_map_run,
+        CASE WHEN EXISTS (
+          SELECT 1 FROM orchestration_events e
+           WHERE e.session_id = s.id
+             AND (
+               (s.workflow_type = 'review' AND e.event_type = 'round_completed' AND e.round = s.current_round)
+               OR (s.workflow_type = 'map' AND e.event_type = 'map_completed'   AND e.round = s.current_map_run)
+             )
+        ) THEN 1 ELSE 0 END AS has_terminal_artifact,
+        CASE WHEN s.status = 'closed' THEN 1 ELSE 0 END AS marked_closed,
+        CASE WHEN NOT EXISTS (
+          SELECT 1 FROM command_executions ce
+           WHERE ce.workflow_id = s.id AND ce.finished_at IS NULL
+        ) THEN 1 ELSE 0 END AS dependents_settled,
+        CASE
+          WHEN s.status = 'closed' AND EXISTS (
+            SELECT 1 FROM orchestration_events e
+             WHERE e.session_id = s.id
+               AND (
+                 (s.workflow_type = 'review' AND e.event_type = 'round_completed' AND e.round = s.current_round)
+                 OR (s.workflow_type = 'map' AND e.event_type = 'map_completed'   AND e.round = s.current_map_run)
+               )
+          ) THEN 'complete'
+          WHEN s.status = 'closed' THEN 'closed_without_artifact'
+          WHEN EXISTS (
+            SELECT 1 FROM command_executions ce
+             WHERE ce.workflow_id = s.id AND ce.finished_at IS NULL
+          ) THEN 'in_flight'
+          ELSE 'open_no_artifact'
+        END AS completeness_state
+      FROM sessions s;
+    `
+  },
+  {
+    version: 13,
+    description: "Retire dead parent_id column on command_executions (never written; row kind is derived from command)",
+    // parent_id was reserved for an AI-instance → dashboard-spawn lineage link
+    // that was never wired (no writer, no reader). A process's KIND (supervisor
+    // / reviewer-instance / utility) is derived from columns that are always
+    // present (command + last_heartbeat_at), so the dead lineage column and its
+    // all-NULL index are removed. Re-add a wired parent_id alongside a real
+    // consumer (e.g. a parent→child tree view) if lineage is ever needed.
+    //
+    // Imperative + guarded so the DROP COLUMN (which SQLite can't express as
+    // IF EXISTS) is idempotent under re-application.
+    run: (db) => {
+      if (!columnExists(db, "command_executions", "parent_id")) return;
+      db.run("DROP INDEX IF EXISTS idx_command_executions_parent;");
+      db.run("ALTER TABLE command_executions DROP COLUMN parent_id;");
+    }
   }
 ];
+function columnExists(db, table, column) {
+  const result = db.exec(`PRAGMA table_info(${table})`);
+  const first = result[0];
+  if (!first) return false;
+  const nameIdx = first.columns.indexOf("name");
+  return first.values.some((row) => row[nameIdx] === column);
+}
 function ensureSchemaVersionTable(db) {
   db.run(`
     CREATE TABLE IF NOT EXISTS schema_version (
@@ -30854,6 +31185,10 @@ function ensureSchemaVersionTable(db) {
     );
   `);
 }
+function getSchemaVersion(db) {
+  ensureSchemaVersionTable(db);
+  return getCurrentVersion(db);
+}
 function getCurrentVersion(db) {
   const result = db.exec(
     "SELECT MAX(version) as v FROM schema_version"
@@ -30871,9 +31206,10 @@ function runMigrations(db) {
     if (migration.version <= currentVersion) {
       continue;
     }
-    db.run("BEGIN TRANSACTION;");
+    db.run("BEGIN IMMEDIATE;");
     try {
-      db.run(migration.sql);
+      if (migration.sql) db.run(migration.sql);
+      migration.run?.(db);
       db.run(
         "INSERT INTO schema_version (version, description) VALUES (?, ?);",
         [migration.version, migration.description]
@@ -30886,6 +31222,10 @@ function runMigrations(db) {
   }
 }
 
+// ../cli/src/lib/db/reconcile.ts
+import { existsSync as existsSync2 } from "node:fs";
+import { isAbsolute, join as join2, dirname as dirname2 } from "node:path";
+
 // ../cli/src/lib/db/result-mapper.ts
 function resultToRows(result) {
   if (result.length === 0 || !result[0]) {
@@ -30906,16 +31246,260 @@ function resultToRow(result) {
 }
 
 // ../cli/src/lib/db/queries.ts
+function insertSession(db, params) {
+  const {
+    id,
+    branch,
+    workflow_type,
+    current_phase = "context",
+    phase_number = 1,
+    current_round = 1,
+    current_map_run = 1,
+    session_dir
+  } = params;
+  db.run(
+    `INSERT INTO sessions (id, branch, workflow_type, current_phase, phase_number, current_round, current_map_run, session_dir)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+    [id, branch, workflow_type, current_phase, phase_number, current_round, current_map_run, session_dir]
+  );
+}
+function updateSession(db, id, params) {
+  const setClauses = [];
+  const values = [];
+  if (params.status !== void 0) {
+    setClauses.push("status = ?");
+    values.push(params.status);
+  }
+  if (params.current_phase !== void 0) {
+    setClauses.push("current_phase = ?");
+    values.push(params.current_phase);
+  }
+  if (params.phase_number !== void 0) {
+    setClauses.push("phase_number = ?");
+    values.push(params.phase_number);
+  }
+  if (params.current_round !== void 0) {
+    setClauses.push("current_round = ?");
+    values.push(params.current_round);
+  }
+  if (params.current_map_run !== void 0) {
+    setClauses.push("current_map_run = ?");
+    values.push(params.current_map_run);
+  }
+  if (setClauses.length === 0) {
+    return;
+  }
+  setClauses.push("updated_at = datetime('now')");
+  values.push(id);
+  db.run(
+    `UPDATE sessions SET ${setClauses.join(", ")} WHERE id = ?`,
+    values
+  );
+}
 function getSession(db, id) {
   return resultToRow(
     db.exec("SELECT * FROM sessions WHERE id = ?", [id])
   );
 }
+function getAllSessions(db) {
+  return resultToRows(
+    db.exec("SELECT * FROM sessions ORDER BY started_at DESC")
+  );
+}
+function insertEvent(db, params) {
+  const {
+    session_id,
+    event_type,
+    phase,
+    phase_number,
+    round,
+    metadata
+  } = params;
+  db.run(
+    `INSERT INTO orchestration_events (session_id, event_type, phase, phase_number, round, metadata)
+     VALUES (?, ?, ?, ?, ?, ?)`,
+    [
+      session_id,
+      event_type,
+      phase ?? null,
+      phase_number ?? null,
+      round ?? null,
+      metadata ?? null
+    ]
+  );
+}
+function commitReasonClose(db, sessionId, reasonEvent, projectionUpdates) {
+  db.transaction(() => {
+    insertEvent(db, { session_id: sessionId, ...reasonEvent });
+    updateSession(db, sessionId, projectionUpdates);
+  });
+}
 
-// ../cli/src/lib/db/agent-sessions.ts
-var ORPHAN_EXIT_CODE = -3;
+// ../cli/src/lib/db/reconcile.ts
+var DEFAULT_STALE_THRESHOLD_SECONDS = 7 * 24 * 60 * 60;
+function hasTerminalArtifactEvent(db, sessionId, workflowType, currentRound, currentMapRun) {
+  const eventType = workflowType === "map" ? "map_completed" : "round_completed";
+  const round = workflowType === "map" ? currentMapRun : currentRound;
+  const r = db.exec(
+    `SELECT 1 FROM orchestration_events
+       WHERE session_id = ? AND event_type = ? AND round = ? LIMIT 1`,
+    [sessionId, eventType, round]
+  );
+  return (r[0]?.values.length ?? 0) > 0;
+}
+function hasReasonEvent(db, sessionId) {
+  const r = db.exec(
+    `SELECT 1 FROM orchestration_events
+       WHERE session_id = ?
+         AND event_type IN ('session_aborted','session_auto_closed_stale','session_synced','session_legacy_import')
+       LIMIT 1`,
+    [sessionId]
+  );
+  return (r[0]?.values.length ?? 0) > 0;
+}
+function lastEventAgeSeconds(db, sessionId) {
+  const r = db.exec(
+    `SELECT (julianday('now') - julianday(MAX(created_at))) * 86400
+       FROM orchestration_events WHERE session_id = ?`,
+    [sessionId]
+  );
+  const v = r[0]?.values[0]?.[0];
+  return typeof v === "number" ? v : null;
+}
+function hasInFlightDependents(db, sessionId) {
+  const r = db.exec(
+    `SELECT 1 FROM command_executions
+       WHERE workflow_id = ? AND finished_at IS NULL LIMIT 1`,
+    [sessionId]
+  );
+  return (r[0]?.values.length ?? 0) > 0;
+}
+function resolveSessionDir(ocrDir, sessionDir) {
+  if (!sessionDir) return null;
+  if (isAbsolute(sessionDir)) return sessionDir;
+  return join2(dirname2(ocrDir), sessionDir);
+}
+function reconcileLegacyState(db, ocrDir, opts = {}) {
+  const dryRun = opts.dryRun ?? false;
+  const threshold = opts.staleThresholdSeconds ?? DEFAULT_STALE_THRESHOLD_SECONDS;
+  const actions = [];
+  for (const s of getAllSessions(db)) {
+    const dir = resolveSessionDir(ocrDir, s.session_dir);
+    if (s.status === "closed") {
+      if (hasTerminalArtifactEvent(db, s.id, s.workflow_type, s.current_round, s.current_map_run) || hasReasonEvent(db, s.id)) {
+        continue;
+      }
+      const reviewFinal = s.workflow_type === "review" && dir ? existsSync2(join2(dir, "rounds", `round-${s.current_round}`, "final.md")) : false;
+      const mapFinal = s.workflow_type === "map" && dir ? existsSync2(join2(dir, "map", "runs", `run-${s.current_map_run}`, "map.md")) : false;
+      if (reviewFinal) {
+        actions.push({
+          sessionId: s.id,
+          kind: "synthesize-round-completed",
+          detail: `final.md present for round ${s.current_round}; synthesizing round_completed`
+        });
+        if (!dryRun) {
+          insertEvent(db, {
+            session_id: s.id,
+            event_type: "round_completed",
+            phase: "synthesis",
+            phase_number: 7,
+            round: s.current_round,
+            metadata: JSON.stringify({ source: "reconciled", synthesized_from: "final.md" })
+          });
+        }
+      } else if (mapFinal) {
+        actions.push({
+          sessionId: s.id,
+          kind: "synthesize-map-completed",
+          detail: `map.md present for run ${s.current_map_run}; synthesizing map_completed`
+        });
+        if (!dryRun) {
+          insertEvent(db, {
+            session_id: s.id,
+            event_type: "map_completed",
+            phase: "synthesis",
+            phase_number: 5,
+            round: s.current_map_run,
+            metadata: JSON.stringify({ source: "reconciled", synthesized_from: "map.md" })
+          });
+        }
+      } else {
+        actions.push({
+          sessionId: s.id,
+          kind: "grandfather",
+          detail: "no provable artifact; recording session_legacy_import"
+        });
+        if (!dryRun) {
+          insertEvent(db, {
+            session_id: s.id,
+            event_type: "session_legacy_import",
+            phase: "complete",
+            metadata: JSON.stringify({ source: "reconciled" })
+          });
+        }
+      }
+      continue;
+    }
+    const age = lastEventAgeSeconds(db, s.id);
+    const stale = (age === null || age > threshold) && !hasInFlightDependents(db, s.id);
+    if (stale) {
+      actions.push({
+        sessionId: s.id,
+        kind: "stale-close",
+        detail: age === null ? "active with no events and no in-flight dependents" : `active, last event ${Math.round(age / 86400)}d ago, no in-flight dependents`
+      });
+      if (!dryRun) {
+        commitReasonClose(
+          db,
+          s.id,
+          {
+            event_type: "session_auto_closed_stale",
+            phase: "complete",
+            metadata: JSON.stringify({ source: "reconciled", threshold_seconds: threshold })
+          },
+          { status: "closed", current_phase: "complete" }
+        );
+      }
+    }
+  }
+  return { dryRun, actions };
+}
+
+// ../cli/src/lib/db/liveness.ts
+var PID_REUSE_GUARD_MS = 24 * 60 * 60 * 1e3;
+function defaultIsAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return !(err instanceof Error && "code" in err && err.code === "ESRCH");
+  }
+}
+function sqliteUtcMs(ts) {
+  const sqliteShape = ts.includes(" ");
+  return new Date(sqliteShape ? ts.replace(" ", "T") + "Z" : ts).getTime();
+}
+
+// ../cli/src/lib/state/exit-codes.ts
 var CANCELLED_EXIT_CODE = -2;
+var ORPHAN_EXIT_CODE = -3;
+var CASCADE_CLOSE_EXIT_CODE = -4;
+
+// ../cli/src/lib/db/agent-sessions.ts
 var NOTE_ORPHAN_PREFIX = "orphaned by liveness sweep";
+var INSTANCE_COMMAND = "session-instance";
+function cascadeTerminateExecutions(db, workflowId, exitCode, note) {
+  db.run(
+    `UPDATE command_executions
+       SET finished_at = datetime('now'),
+           exit_code   = ?,
+           pid         = NULL,
+           notes       = COALESCE(notes || char(10), '') || ?
+     WHERE workflow_id = ?
+       AND finished_at IS NULL`,
+    [exitCode, note, workflowId]
+  );
+}
 function rowToAgentSession(row) {
   return {
     // The OCR-owned id is the `uid` column. Fall back to the integer
@@ -30930,6 +31514,7 @@ function rowToAgentSession(row) {
     resolved_model: row.resolved_model,
     phase: null,
     status: deriveStatus(row),
+    kind: rowKind(row),
     pid: row.pid,
     started_at: row.started_at,
     last_heartbeat_at: row.last_heartbeat_at ?? row.started_at,
@@ -30943,7 +31528,9 @@ function deriveStatus(row) {
     return "running";
   }
   if (row.exit_code === ORPHAN_EXIT_CODE) return "orphaned";
-  if (row.exit_code === CANCELLED_EXIT_CODE) return "cancelled";
+  if (row.exit_code === CANCELLED_EXIT_CODE || row.exit_code === CASCADE_CLOSE_EXIT_CODE) {
+    return "cancelled";
+  }
   if (row.exit_code === 0) return "done";
   return "crashed";
 }
@@ -30988,38 +31575,112 @@ function linkDashboardInvocationToWorkflow(db, dashboardUid, workflowId) {
     [workflowId, dashboardUid]
   );
 }
-function sweepStaleAgentSessions(db, thresholdSeconds) {
-  const staleSql = `
-    SELECT uid, id FROM command_executions
-    WHERE finished_at IS NULL
-      AND last_heartbeat_at IS NOT NULL
-      AND (julianday('now') - julianday(last_heartbeat_at)) * 86400 > ?
-  `;
-  const stale = resultToRows(
-    db.exec(staleSql, [thresholdSeconds])
+function sweepStaleAgentSessions(db, thresholdSeconds, isAlive = defaultIsAlive) {
+  const candidates = resultToRows(
+    db.exec(
+      `SELECT uid, id, pid, started_at, workflow_id, command, last_heartbeat_at
+         FROM command_executions
+        WHERE finished_at IS NULL
+          AND pid IS NOT NULL
+          AND last_heartbeat_at IS NOT NULL
+          AND (julianday('now') - julianday(last_heartbeat_at)) * 86400 > ?`,
+      [thresholdSeconds]
+    )
   );
-  if (stale.length === 0) {
-    return { orphanedIds: [] };
+  if (candidates.length === 0) {
+    return { orphanedIds: [], cascadedWorkflowIds: [] };
+  }
+  const reuseCutoffMs = Date.now() - PID_REUSE_GUARD_MS;
+  const dead = candidates.filter((row) => {
+    if (row.pid === null) return false;
+    if (sqliteUtcMs(row.started_at) < reuseCutoffMs) return false;
+    return !isAlive(row.pid);
+  });
+  if (dead.length === 0) {
+    return { orphanedIds: [], cascadedWorkflowIds: [] };
   }
   const note = `${NOTE_ORPHAN_PREFIX} (threshold ${thresholdSeconds}s)`;
-  db.run(
-    `UPDATE command_executions
-       SET finished_at = datetime('now'),
-           exit_code = ?,
-           notes = COALESCE(notes || char(10), '') || ?
-     WHERE finished_at IS NULL
-       AND last_heartbeat_at IS NOT NULL
-       AND (julianday('now') - julianday(last_heartbeat_at)) * 86400 > ?`,
-    [ORPHAN_EXIT_CODE, note, thresholdSeconds]
-  );
+  const placeholders = dead.map(() => "?").join(", ");
+  const cascadedWorkflowIds = [];
+  db.transaction(() => {
+    db.run(
+      `UPDATE command_executions
+          SET finished_at = datetime('now'),
+              exit_code = ?,
+              pid = NULL,
+              notes = COALESCE(notes || char(10), '') || ?
+        WHERE id IN (${placeholders})
+          AND finished_at IS NULL`,
+      [ORPHAN_EXIT_CODE, note, ...dead.map((r) => r.id)]
+    );
+    for (const row of dead) {
+      if (row.workflow_id && rowKind(row) === "supervisor") {
+        cascadeTerminateExecutions(
+          db,
+          row.workflow_id,
+          CASCADE_CLOSE_EXIT_CODE,
+          "cascade-closed: workflow process orphaned by liveness sweep"
+        );
+        cascadedWorkflowIds.push(row.workflow_id);
+      }
+    }
+  });
   return {
-    orphanedIds: stale.map((row) => row.uid ?? String(row.id))
+    orphanedIds: dead.map((r) => r.uid ?? String(r.id)),
+    cascadedWorkflowIds
   };
 }
+function rowKind(row) {
+  if (row.command === INSTANCE_COMMAND || row.command.startsWith(`${INSTANCE_COMMAND}:`)) {
+    return "instance";
+  }
+  return row.last_heartbeat_at == null ? "utility" : "supervisor";
+}
+function sweepStaleSessions(db, thresholdSeconds) {
+  const sql = `
+    SELECT s.id
+      FROM sessions s
+      LEFT JOIN (
+        SELECT session_id, MAX(created_at) AS last_event_at
+          FROM orchestration_events
+         GROUP BY session_id
+      ) e ON e.session_id = s.id
+     WHERE s.status = 'active'
+       AND (
+         e.last_event_at IS NULL
+         OR (julianday('now') - julianday(e.last_event_at)) * 86400 > ?
+       )
+       AND NOT EXISTS (
+         SELECT 1 FROM command_executions ce
+          WHERE ce.workflow_id = s.id
+            AND ce.finished_at IS NULL
+       )
+  `;
+  const rows = resultToRows(db.exec(sql, [thresholdSeconds]));
+  if (rows.length === 0) {
+    return { closedSessionIds: [] };
+  }
+  for (const row of rows) {
+    commitReasonClose(
+      db,
+      row.id,
+      {
+        event_type: "session_auto_closed_stale",
+        phase: "complete",
+        metadata: JSON.stringify({
+          reason: "no events past threshold; no in-flight dependents",
+          threshold_seconds: thresholdSeconds
+        })
+      },
+      { status: "closed", current_phase: "complete" }
+    );
+  }
+  return { closedSessionIds: rows.map((r) => r.id) };
+}
 
 // ../cli/src/lib/db/command-log.ts
-import { appendFileSync, existsSync as existsSync2, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
-import { dirname as dirname2, join as join2 } from "node:path";
+import { appendFileSync, existsSync as existsSync3, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname as dirname3, join as join3 } from "node:path";
 import { randomUUID } from "node:crypto";
 var CACHE_DIR = ".cache";
 var FILENAME = "command-history.jsonl";
@@ -31030,16 +31691,16 @@ function generateCommandUid() {
   return randomUUID();
 }
 function cacheDir(ocrDir) {
-  return join2(ocrDir, "data", CACHE_DIR);
+  return join3(ocrDir, "data", CACHE_DIR);
 }
 function commandLogPath(ocrDir) {
-  return join2(cacheDir(ocrDir), FILENAME);
+  return join3(cacheDir(ocrDir), FILENAME);
 }
 function appendCommandLog(ocrDir, entry) {
   try {
     const filePath = commandLogPath(ocrDir);
-    const dir = dirname2(filePath);
-    if (!existsSync2(dir)) mkdirSync(dir, { recursive: true });
+    const dir = dirname3(filePath);
+    if (!existsSync3(dir)) mkdirSync(dir, { recursive: true });
     const line = JSON.stringify(entry) + "\n";
     appendFileSync(filePath, line, { encoding: "utf-8" });
     if (approxLineCount >= 0) approxLineCount++;
@@ -31049,7 +31710,7 @@ function appendCommandLog(ocrDir, entry) {
 }
 function readCommandLog(ocrDir) {
   const filePath = commandLogPath(ocrDir);
-  if (!existsSync2(filePath)) return [];
+  if (!existsSync3(filePath)) return [];
   const content = readFileSync(filePath, "utf-8");
   const entries = [];
   for (const line of content.split("\n")) {
@@ -31115,99 +31776,137 @@ function rotateIfNeeded(filePath) {
 }
 
 // ../cli/src/lib/db/index.ts
-function locateWasm() {
-  const require2 = createRequire(import.meta.url);
-  const sqlJsPath = require2.resolve("sql.js");
-  return join3(dirname3(sqlJsPath), "sql-wasm.wasm");
+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;
+  try {
+    if (!existsSync4(dbPath) || statSync(dbPath).size === 0) return null;
+    db.pragma("wal_checkpoint(TRUNCATE)");
+    copyFileSync(dbPath, bakPath);
+    return bakPath;
+  } catch {
+    return null;
+  }
 }
-function applyPragmas(db) {
-  db.run("PRAGMA foreign_keys = ON;");
-  db.run("PRAGMA journal_mode = WAL;");
-  db.run("PRAGMA busy_timeout = 5000;");
+function formatUpgradeNotice(bakPath, reconcile) {
+  const lines = [
+    "Storage upgraded to v2.0 \u2014 durable SQLite engine (WAL), event-sourced lifecycle."
+  ];
+  if (bakPath) {
+    lines.push(`  A backup of your previous database was saved to: ${bakPath}`);
+  }
+  const repairs = (reconcile?.actions ?? []).filter((a) => a.kind !== "ok");
+  if (repairs.length > 0) {
+    const n = (kind) => repairs.filter((a) => a.kind === kind).length;
+    const parts = [];
+    const finalized = n("synthesize-round-completed") + n("synthesize-map-completed");
+    if (finalized > 0) parts.push(`${finalized} finalized from artifacts`);
+    if (n("grandfather") > 0) parts.push(`${n("grandfather")} grandfathered`);
+    if (n("stale-close") > 0) parts.push(`${n("stale-close")} stale closed`);
+    lines.push(
+      `  Reconciled ${repairs.length} legacy session(s): ${parts.join(", ")}.`
+    );
+  }
+  lines.push("  Run `ocr doctor` to verify the storage engine.");
+  return lines.map((l) => `[ocr] ${l}`).join("\n");
 }
-function walCheckpointTruncate(dbPath) {
-  if (!existsSync3(dbPath)) {
-    return "skipped";
+var connections = /* @__PURE__ */ new Map();
+async function openDatabase(dbPath) {
+  const cached = connections.get(dbPath);
+  if (cached) {
+    return cached;
+  }
+  const dir = dirname4(dbPath);
+  if (!existsSync4(dir)) {
+    mkdirSync2(dir, { recursive: true });
   }
+  const db = openEngine(dbPath);
+  connections.set(dbPath, db);
+  return db;
+}
+async function ensureDatabase(ocrDir) {
+  const dataDir = join4(ocrDir, "data");
+  if (!existsSync4(dataDir)) {
+    mkdirSync2(dataDir, { recursive: true });
+  }
+  const dbPath = join4(dataDir, "ocr.db");
+  const db = await openDatabase(dbPath);
+  let before = 0;
   try {
-    const probe = spawnSync("sqlite3", ["-version"], {
-      stdio: "ignore",
-      timeout: 2e3
-    });
-    if (probe.status !== 0) {
-      return "skipped";
-    }
+    before = getSchemaVersion(db);
   } catch {
+    before = 0;
+  }
+  const isLegacyUpgrade = before >= 1 && before < V2_SCHEMA_VERSION;
+  const bakPath = maybeSnapshotBeforeUpgrade(db, dbPath, before);
+  runMigrations(db);
+  let reconcile;
+  if (before < V2_SCHEMA_VERSION) {
+    try {
+      reconcile = reconcileLegacyState(db, ocrDir);
+    } catch (err) {
+      console.error(
+        `[ocr] legacy reconciliation skipped: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  if (isLegacyUpgrade) {
+    const notice = formatUpgradeNotice(bakPath, reconcile);
+    if (notice) console.error(notice);
+  }
+  return db;
+}
+function walCheckpointTruncate(dbPath) {
+  if (!existsSync4(dbPath)) {
     return "skipped";
   }
+  const cached = connections.get(dbPath);
+  if (cached) {
+    try {
+      cached.pragma("wal_checkpoint(TRUNCATE)");
+      return "checkpointed";
+    } catch {
+      return "failed";
+    }
+  }
+  let transient;
   try {
-    const result = spawnSync(
-      "sqlite3",
-      [dbPath, "PRAGMA wal_checkpoint(TRUNCATE);"],
-      {
-        stdio: "ignore",
-        timeout: 5e3
-      }
-    );
-    return result.status === 0 ? "checkpointed" : "failed";
+    transient = openEngine(dbPath);
+    transient.pragma("wal_checkpoint(TRUNCATE)");
+    return "checkpointed";
   } catch {
     return "failed";
+  } finally {
+    try {
+      transient?.close();
+    } catch {
+    }
+  }
+}
+function closeDatabase(dbPath) {
+  const db = connections.get(dbPath);
+  if (db) {
+    db.close();
+    connections.delete(dbPath);
   }
 }
 
 // src/server/db.ts
+import { join as join5 } from "node:path";
 var cachedDb = null;
 var cachedDbPath = null;
-var preSaveHook = null;
-var postSaveHook = null;
-function registerSaveHooks(preSave, postSave) {
-  preSaveHook = preSave;
-  postSaveHook = postSave;
-}
 async function openDb(ocrDir) {
-  const dbPath = join4(ocrDir, "data", "ocr.db");
-  if (cachedDb && cachedDbPath === dbPath) {
-    return cachedDb;
-  }
-  const wasmBuffer = readFileSync3(locateWasm());
-  const wasmBinary = wasmBuffer.buffer.slice(
-    wasmBuffer.byteOffset,
-    wasmBuffer.byteOffset + wasmBuffer.byteLength
-  );
-  const SQL = await initSqlJs2({ wasmBinary });
-  let db;
-  if (existsSync4(dbPath)) {
-    const fileBuffer = readFileSync3(dbPath);
-    db = new SQL.Database(fileBuffer);
-  } else {
-    const dataDir = dirname4(dbPath);
-    if (!existsSync4(dataDir)) {
-      mkdirSync3(dataDir, { recursive: true });
-    }
-    db = new SQL.Database();
-  }
-  applyPragmas(db);
-  runMigrations(db);
+  const dbPath = join5(ocrDir, "data", "ocr.db");
+  const db = await ensureDatabase(ocrDir);
   cachedDb = db;
   cachedDbPath = dbPath;
   return db;
 }
-function saveDb(db, ocrDir) {
-  preSaveHook?.();
-  const dbPath = join4(ocrDir, "data", "ocr.db");
-  const data = db.export();
-  const dir = dirname4(dbPath);
-  if (!existsSync4(dir)) {
-    mkdirSync3(dir, { recursive: true });
-  }
-  const tmpPath = `${dbPath}.${process.pid}.tmp`;
-  writeFileSync3(tmpPath, Buffer.from(data));
-  renameSync3(tmpPath, dbPath);
-  postSaveHook?.();
-}
 function closeDb() {
-  if (cachedDb) {
-    cachedDb.close();
+  if (cachedDbPath) {
+    closeDatabase(cachedDbPath);
     cachedDb = null;
     cachedDbPath = null;
   }
@@ -31431,7 +32130,11 @@ function deleteNote(db, noteId) {
 function getCommandHistory(db, limit = 50) {
   return resultToRows(
     db.exec(
-      "SELECT * FROM command_executions ORDER BY started_at DESC LIMIT ?",
+      `SELECT ce.*, sc.completeness_state AS workflow_completeness
+         FROM command_executions ce
+         LEFT JOIN session_completeness sc ON sc.session_id = ce.workflow_id
+        ORDER BY ce.started_at DESC
+        LIMIT ?`,
       [limit]
     )
   );
@@ -32120,34 +32823,7 @@ var VALID_ROUND_STATUSES = /* @__PURE__ */ new Set([
   "acknowledged",
   "dismissed"
 ]);
-var saveTimer = null;
-var pendingDb = null;
-var pendingOcrDir = null;
-function debouncedSave(db, ocrDir) {
-  pendingDb = db;
-  pendingOcrDir = ocrDir;
-  if (saveTimer) clearTimeout(saveTimer);
-  saveTimer = setTimeout(() => {
-    if (pendingDb && pendingOcrDir) {
-      saveDb(pendingDb, pendingOcrDir);
-    }
-    saveTimer = null;
-    pendingDb = null;
-    pendingOcrDir = null;
-  }, 500);
-}
-function flushSave() {
-  if (saveTimer) {
-    clearTimeout(saveTimer);
-    saveTimer = null;
-  }
-  if (pendingDb && pendingOcrDir) {
-    saveDb(pendingDb, pendingOcrDir);
-    pendingDb = null;
-    pendingOcrDir = null;
-  }
-}
-function createProgressRouter(db, ocrDir) {
+function createProgressRouter(db) {
   const router = (0, import_express5.Router)();
   router.patch("/map-files/:id/progress", (req, res) => {
     try {
@@ -32167,7 +32843,6 @@ function createProgressRouter(db, ocrDir) {
         return;
       }
       upsertFileProgress(db, fileId, isReviewed);
-      debouncedSave(db, ocrDir);
       const progress = getFileProgress(db, fileId);
       res.json(progress);
     } catch (err) {
@@ -32183,7 +32858,6 @@ function createProgressRouter(db, ocrDir) {
         return;
       }
       deleteFileProgress(db, fileId);
-      debouncedSave(db, ocrDir);
       res.status(200).json({ deleted: true });
     } catch (err) {
       console.error("Failed to clear file progress:", err);
@@ -32211,7 +32885,6 @@ function createProgressRouter(db, ocrDir) {
         return;
       }
       upsertFindingProgress(db, findingId, status);
-      debouncedSave(db, ocrDir);
       const progress = getFindingProgress(db, findingId);
       res.json(progress);
     } catch (err) {
@@ -32227,7 +32900,6 @@ function createProgressRouter(db, ocrDir) {
         return;
       }
       deleteFindingProgress(db, findingId);
-      debouncedSave(db, ocrDir);
       res.status(200).json({ deleted: true });
     } catch (err) {
       console.error("Failed to clear finding progress:", err);
@@ -32255,7 +32927,6 @@ function createProgressRouter(db, ocrDir) {
         return;
       }
       upsertRoundProgress(db, roundId, status);
-      debouncedSave(db, ocrDir);
       const progress = getRoundProgress(db, roundId);
       res.json(progress);
     } catch (err) {
@@ -32271,7 +32942,6 @@ function createProgressRouter(db, ocrDir) {
         return;
       }
       deleteRoundProgress(db, roundId);
-      debouncedSave(db, ocrDir);
       res.status(200).json({ deleted: true });
     } catch (err) {
       console.error("Failed to clear round progress:", err);
@@ -32291,7 +32961,7 @@ var VALID_TARGET_TYPES = /* @__PURE__ */ new Set([
   "section",
   "file"
 ]);
-function createNotesRouter(db, ocrDir) {
+function createNotesRouter(db) {
   const router = (0, import_express6.Router)();
   router.get("/", (req, res) => {
     try {
@@ -32330,7 +33000,6 @@ function createNotesRouter(db, ocrDir) {
         return;
       }
       const noteId = insertNote(db, target_type, target_id, content);
-      saveDb(db, ocrDir);
       const note = getNote(db, noteId);
       res.status(201).json(note);
     } catch (err) {
@@ -32356,7 +33025,6 @@ function createNotesRouter(db, ocrDir) {
         return;
       }
       updateNote(db, noteId, content);
-      saveDb(db, ocrDir);
       const note = getNote(db, noteId);
       res.json(note);
     } catch (err) {
@@ -32377,7 +33045,6 @@ function createNotesRouter(db, ocrDir) {
         return;
       }
       deleteNote(db, noteId);
-      saveDb(db, ocrDir);
       res.status(200).json({ deleted: true });
     } catch (err) {
       console.error("Failed to delete note:", err);
@@ -32442,12 +33109,44 @@ function spawnBinary(binary, args, opts) {
 }
 
 // src/server/socket/command-runner.ts
-import { readFileSync as readFileSync6, writeFileSync as writeFileSync4, unlinkSync, mkdirSync as mkdirSync5, existsSync as existsSync7 } from "node:fs";
-import { dirname as dirname6, join as join9 } from "node:path";
+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";
+
+// src/server/services/command-outcome.ts
+function deriveCommandOutcome(exitCode, completeness) {
+  if (exitCode === null) return null;
+  if (exitCode === CANCELLED_EXIT_CODE || exitCode === CASCADE_CLOSE_EXIT_CODE) {
+    return "cancelled";
+  }
+  if (exitCode !== 0) return "failed";
+  if (completeness === null || completeness === "complete") return "success";
+  return "incomplete";
+}
+function deriveCancellationReason(exitCode) {
+  if (exitCode === CANCELLED_EXIT_CODE) return "user";
+  if (exitCode === CASCADE_CLOSE_EXIT_CODE) return "cascade";
+  return null;
+}
+function getWorkflowCompletenessForExecution(db, executionId) {
+  const result = db.exec(
+    `SELECT sc.completeness_state
+       FROM command_executions ce
+       LEFT JOIN session_completeness sc ON sc.session_id = ce.workflow_id
+      WHERE ce.id = ?`,
+    [executionId]
+  );
+  const row = result[0]?.values[0];
+  if (!row) return null;
+  const state = row[0];
+  if (state === "complete" || state === "closed_without_artifact" || state === "in_flight" || state === "open_no_artifact") {
+    return state;
+  }
+  return null;
+}
 
 // src/server/services/ai-cli/index.ts
-import { readFileSync as readFileSync5 } from "node:fs";
-import { join as join7 } from "node:path";
+import { readFileSync as readFileSync3 } from "node:fs";
+import { join as join8 } from "node:path";
 
 // src/server/socket/env.ts
 var ENV_ALLOWLIST = [
@@ -32937,19 +33636,19 @@ function extractToolOutput(part) {
 import {
   createWriteStream,
   existsSync as existsSync5,
-  mkdirSync as mkdirSync4,
-  readFileSync as readFileSync4
+  mkdirSync as mkdirSync3,
+  readFileSync as readFileSync2
 } from "node:fs";
-import { join as join5 } from "node:path";
+import { join as join6 } from "node:path";
 function eventsDir(ocrDir) {
-  const dir = join5(ocrDir, "data", "events");
+  const dir = join6(ocrDir, "data", "events");
   if (!existsSync5(dir)) {
-    mkdirSync4(dir, { recursive: true });
+    mkdirSync3(dir, { recursive: true });
   }
   return dir;
 }
 function eventJournalPath(ocrDir, executionId) {
-  return join5(eventsDir(ocrDir), `${executionId}.jsonl`);
+  return join6(eventsDir(ocrDir), `${executionId}.jsonl`);
 }
 var EventJournalAppender = class {
   stream;
@@ -32989,7 +33688,7 @@ function readEventJournal(ocrDir, executionId) {
   if (!existsSync5(path2)) return [];
   let raw;
   try {
-    raw = readFileSync4(path2, "utf-8");
+    raw = readFileSync2(path2, "utf-8");
   } catch {
     return [];
   }
@@ -33008,7 +33707,7 @@ function readEventJournal(ocrDir, executionId) {
 
 // src/server/services/ai-cli/helpers.ts
 import { tmpdir } from "node:os";
-import { join as join6 } from "node:path";
+import { join as join7 } from "node:path";
 function formatToolDetail(tool, input) {
   switch (tool) {
     case "Read":
@@ -33032,13 +33731,13 @@ function formatToolDetail(tool, input) {
       return `Using ${tool}`;
   }
 }
-var TEMP_BASE = join6(tmpdir(), "ocr-ai-prompts");
+var TEMP_BASE = join7(tmpdir(), "ocr-ai-prompts");
 
 // src/server/services/ai-cli/index.ts
 function readAiCliPreference(ocrDir) {
   try {
-    const configPath = join7(ocrDir, "config.yaml");
-    const content = readFileSync5(configPath, "utf-8");
+    const configPath = join8(ocrDir, "config.yaml");
+    const content = readFileSync3(configPath, "utf-8");
     const match = content.match(/^\s*ai_cli:\s*(\S+)/m);
     const value = match?.[1] ?? "auto";
     if (value === "claude" || value === "opencode" || value === "off") return value;
@@ -33148,19 +33847,19 @@ var AiCliService = class {
 
 // src/server/socket/cli-resolver.ts
 import { existsSync as existsSync6 } from "node:fs";
-import { dirname as dirname5, join as join8 } from "node:path";
+import { dirname as dirname5, join as join9 } from "node:path";
 import { fileURLToPath } from "node:url";
 var __dirname = dirname5(fileURLToPath(import.meta.url));
 function resolveLocalCli() {
-  const parentDir = join8(__dirname, "..");
-  const bundledCli = join8(parentDir, "index.js");
-  if (existsSync6(bundledCli) && existsSync6(join8(parentDir, "dashboard", "server.js"))) {
+  const parentDir = join9(__dirname, "..");
+  const bundledCli = join9(parentDir, "index.js");
+  if (existsSync6(bundledCli) && existsSync6(join9(parentDir, "dashboard", "server.js"))) {
     return bundledCli;
   }
   let dir = __dirname;
   for (let i = 0; i < 8; i++) {
-    if (existsSync6(join8(dir, "nx.json"))) {
-      const candidate = join8(dir, "packages", "cli", "dist", "index.js");
+    if (existsSync6(join9(dir, "nx.json"))) {
+      const candidate = join9(dir, "packages", "cli", "dist", "index.js");
       if (existsSync6(candidate)) return candidate;
       break;
     }
@@ -33286,8 +33985,8 @@ function buildPrompt(opts) {
       "",
       "Examples:",
       `- Instead of \`ocr state show\`, run: \`node ${localCli} state show\``,
-      `- Instead of \`ocr state init ...\`, run: \`node ${localCli} state init ...\``,
-      `- Instead of \`ocr state transition ...\`, run: \`node ${localCli} state transition ...\``,
+      `- Instead of \`ocr state begin ...\`, run: \`node ${localCli} state begin ...\``,
+      `- Instead of \`ocr state advance ...\`, run: \`node ${localCli} state advance ...\``,
       "",
       "This applies to every `ocr` invocation. Do NOT use bare `ocr` commands."
     );
@@ -33297,7 +33996,7 @@ function buildPrompt(opts) {
       "",
       "## Dashboard Linkage (REQUIRED for terminal handoff)",
       "",
-      'You are running inside the OCR dashboard. To enable the "Pick up in terminal" affordance for this review, your first `ocr state init` invocation MUST include this flag:',
+      'You are running inside the OCR dashboard. To enable the "Pick up in terminal" affordance for this review, your first `ocr state begin` invocation MUST include this flag:',
       "",
       "```",
       `--dashboard-uid ${executionUid}`,
@@ -33306,7 +34005,7 @@ function buildPrompt(opts) {
       "Full example:",
       "",
       "```",
-      `node ${localCli} state init --session-id <id> --branch <branch> --workflow-type review --dashboard-uid ${executionUid}`,
+      `node ${localCli} state begin --session-id <id> --branch <branch> --workflow-type review --dashboard-uid ${executionUid}`,
       "```",
       "",
       "Without this flag the dashboard cannot link your review session to its execution row, and the resume command will not be available."
@@ -33353,17 +34052,17 @@ function extractPerInstanceModels(subArgs) {
 var MAX_CONCURRENT = 3;
 var activeCommands = /* @__PURE__ */ new Map();
 function spawnMarkerPath(ocrDir) {
-  return join9(ocrDir, "data", "dashboard-active-spawn.json");
+  return join10(ocrDir, "data", "dashboard-active-spawn.json");
 }
 function writeSpawnMarker(ocrDir, executionUid, pid) {
-  const dataDir = join9(ocrDir, "data");
-  if (!existsSync7(dataDir)) mkdirSync5(dataDir, { recursive: true });
+  const dataDir = join10(ocrDir, "data");
+  if (!existsSync7(dataDir)) mkdirSync4(dataDir, { recursive: true });
   const payload = JSON.stringify({
     execution_uid: executionUid,
     pid,
     started_at: (/* @__PURE__ */ new Date()).toISOString()
   });
-  writeFileSync4(spawnMarkerPath(ocrDir), payload, { mode: 384 });
+  writeFileSync2(spawnMarkerPath(ocrDir), payload, { mode: 384 });
 }
 function clearSpawnMarker(ocrDir) {
   try {
@@ -33571,10 +34270,10 @@ function spawnAiCommand(io2, _socket, db, ocrDir, executionId, baseCommand, subA
       io2.emit("command:output", { execution_id: executionId, content: warning });
     }
   }
-  const commandMdPath = join9(ocrDir, "commands", `${baseCommand}.md`);
+  const commandMdPath = join10(ocrDir, "commands", `${baseCommand}.md`);
   let commandContent;
   try {
-    commandContent = readFileSync6(commandMdPath, "utf-8");
+    commandContent = readFileSync4(commandMdPath, "utf-8");
   } catch {
     const content = `Error: Could not read command file at ${commandMdPath}
 `;
@@ -33805,7 +34504,9 @@ function finishExecution(io2, db, ocrDir, executionId, code, output) {
      WHERE id = ?`,
     [code, finishedAt, output, executionId]
   );
-  saveDb(db, ocrDir);
+  const completeness = getWorkflowCompletenessForExecution(db, executionId);
+  const outcome = deriveCommandOutcome(code, completeness);
+  const cancellationReason = deriveCancellationReason(code);
   if (entry?.uid) {
     appendCommandLog(ocrDir, {
       v: 1,
@@ -33824,7 +34525,9 @@ function finishExecution(io2, db, ocrDir, executionId, code, output) {
   io2.emit("command:finished", {
     execution_id: executionId,
     exitCode: code,
-    finished_at: finishedAt
+    finished_at: finishedAt,
+    outcome,
+    cancellation_reason: cancellationReason
   });
   activeCommands.delete(executionId);
 }
@@ -33874,10 +34577,21 @@ function createCommandsRouter(db, ocrDir) {
   router.get("/history", (req, res) => {
     try {
       const limit = parseInt(req.query["limit"], 10) || 50;
-      const history = getCommandHistory(db, limit).map((row) => ({
-        ...row,
-        duration_ms: row.finished_at && row.started_at ? new Date(row.finished_at).getTime() - new Date(row.started_at).getTime() : null
-      }));
+      const history = getCommandHistory(db, limit).map((row) => {
+        const { workflow_completeness, ...persisted } = row;
+        return {
+          ...persisted,
+          duration_ms: row.finished_at && row.started_at ? new Date(row.finished_at).getTime() - new Date(row.started_at).getTime() : null,
+          // Derived from (exit_code, event-sourced workflow completeness) —
+          // single source of truth shared with the live `command:finished`
+          // socket event.
+          outcome: deriveCommandOutcome(row.exit_code, workflow_completeness),
+          // Orthogonal discriminator within the 'cancelled' bucket so the
+          // client distinguishes a user cancel from a cascade close without
+          // reaching past `outcome` to match a magic exit-code number.
+          cancellation_reason: deriveCancellationReason(row.exit_code)
+        };
+      });
       res.json(history);
     } catch (err) {
       console.error("Failed to fetch command history:", err);
@@ -33903,8 +34617,8 @@ function createCommandsRouter(db, ocrDir) {
 
 // src/server/routes/config.ts
 var import_express9 = __toESM(require_express2(), 1);
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync5 } from "node:fs";
-import { join as join10, dirname as dirname7, basename } from "node:path";
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "node:fs";
+import { join as join11, dirname as dirname7, basename } from "node:path";
 var VALID_IDES = ["vscode", "cursor", "windsurf", "jetbrains", "sublime"];
 function detectIde() {
   const termProgram = process.env.TERM_PROGRAM?.toLowerCase() ?? "";
@@ -33921,8 +34635,8 @@ function detectIde() {
 }
 function readIdeFromConfig(ocrDir) {
   try {
-    const configPath = join10(ocrDir, "config.yaml");
-    const content = readFileSync7(configPath, "utf-8");
+    const configPath = join11(ocrDir, "config.yaml");
+    const content = readFileSync5(configPath, "utf-8");
     const match = content.match(/^\s*ide:\s*(\S+)/m);
     return match?.[1] ?? "auto";
   } catch {
@@ -33968,8 +34682,8 @@ function createConfigRouter(ocrDir, aiCliService) {
       return;
     }
     try {
-      const configPath = join10(ocrDir, "config.yaml");
-      let content = readFileSync7(configPath, "utf-8");
+      const configPath = join11(ocrDir, "config.yaml");
+      let content = readFileSync5(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:")) {
@@ -33981,7 +34695,7 @@ dashboard:
   ide: ${ide}
 `;
       }
-      writeFileSync5(configPath, content);
+      writeFileSync3(configPath, content);
       res.json({ ide });
     } catch (err) {
       console.error("Failed to update config:", err);
@@ -33993,7 +34707,7 @@ dashboard:
 
 // src/server/routes/chat.ts
 var import_express10 = __toESM(require_express2(), 1);
-function createChatRouter(db, ocrDir) {
+function createChatRouter(db) {
   const router = (0, import_express10.Router)();
   router.get("/:id/chat", (req, res) => {
     try {
@@ -34046,7 +34760,6 @@ function createChatRouter(db, ocrDir) {
         return;
       }
       deleteConversation(db, conversationId);
-      saveDb(db, ocrDir);
       res.status(200).json({ deleted: true });
     } catch (err) {
       console.error("Failed to delete conversation:", err);
@@ -34058,15 +34771,15 @@ function createChatRouter(db, ocrDir) {
 
 // src/server/routes/reviewers.ts
 var import_express11 = __toESM(require_express2(), 1);
-import { readFileSync as readFileSync8, existsSync as existsSync8, watch } from "node:fs";
-import { join as join11 } from "node:path";
+import { readFileSync as readFileSync6, existsSync as existsSync8, watch } from "node:fs";
+import { join as join12 } from "node:path";
 function readReviewersMeta(ocrDir) {
-  const metaPath = join11(ocrDir, "reviewers-meta.json");
+  const metaPath = join12(ocrDir, "reviewers-meta.json");
   if (!existsSync8(metaPath)) {
     return { reviewers: [], defaults: [] };
   }
   try {
-    const raw = readFileSync8(metaPath, "utf-8");
+    const raw = readFileSync6(metaPath, "utf-8");
     const meta = JSON.parse(raw);
     const reviewers = meta.reviewers ?? [];
     const defaults = reviewers.filter((r) => r.is_default).map((r) => r.id);
@@ -34087,13 +34800,13 @@ function createReviewersRouter(ocrDir) {
       res.status(400).json({ error: "Invalid reviewer ID" });
       return;
     }
-    const filePath = join11(ocrDir, "skills", "references", "reviewers", `${id}.md`);
+    const filePath = join12(ocrDir, "skills", "references", "reviewers", `${id}.md`);
     if (!existsSync8(filePath)) {
       res.status(404).json({ error: "Reviewer not found", id });
       return;
     }
     try {
-      const content = readFileSync8(filePath, "utf-8");
+      const content = readFileSync6(filePath, "utf-8");
       res.json({ id, content });
     } catch {
       res.status(500).json({ error: "Failed to read reviewer file", id });
@@ -34102,7 +34815,7 @@ function createReviewersRouter(ocrDir) {
   return router;
 }
 function watchReviewersMeta(ocrDir, io2) {
-  const metaPath = join11(ocrDir, "reviewers-meta.json");
+  const metaPath = join12(ocrDir, "reviewers-meta.json");
   let watcher = null;
   let debounce;
   try {
@@ -34178,18 +34891,18 @@ function createHandoffRouter(sessionCapture, ocrDir, syncFromDisk = () => {
 
 // src/server/routes/team.ts
 var import_express14 = __toESM(require_express2(), 1);
-import { spawnSync as spawnSync2 } from "node:child_process";
+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 readFileSync9 } from "node:fs";
-import { join as join12 } from "node:path";
+import { existsSync as existsSync9, readFileSync as readFileSync7 } from "node:fs";
+import { join as join13 } from "node:path";
 function loadTeamConfig(ocrDir) {
-  const configPath = join12(ocrDir, "config.yaml");
+  const configPath = join13(ocrDir, "config.yaml");
   if (!existsSync9(configPath)) {
     return { team: [], aliases: {}, defaultModel: null };
   }
-  const content = readFileSync9(configPath, "utf-8");
+  const content = readFileSync7(configPath, "utf-8");
   return parseTeamConfigYaml(content);
 }
 function parseTeamConfigYaml(content) {
@@ -34470,7 +35183,7 @@ function createTeamRouter(ocrDir) {
       return;
     }
     try {
-      const result = spawnSync2("ocr", ["team", "set", "--stdin"], {
+      const result = spawnSync("ocr", ["team", "set", "--stdin"], {
         input: JSON.stringify(body.team),
         encoding: "utf-8",
         cwd: ocrDir.replace(/\/\.ocr$/, ""),
@@ -34623,7 +35336,6 @@ function createSessionCaptureService(deps) {
         return;
       }
       recordVendorSessionIdForExecution(db, executionId, vendorSessionId);
-      saveDb(db, ocrDir);
     } catch (err) {
       console.error(
         `[session-capture] recordSessionId failed for execution ${executionId} \u2192 ${vendorSessionId}:`,
@@ -34634,7 +35346,6 @@ function createSessionCaptureService(deps) {
   function linkInvocationToWorkflow(uid, workflowId) {
     try {
       linkDashboardInvocationToWorkflow(db, uid, workflowId);
-      saveDb(db, ocrDir);
     } catch (err) {
       console.error("[session-capture] linkInvocationToWorkflow failed:", err);
     }
@@ -34791,8 +35502,8 @@ function buildDiagnostics(input) {
 }
 
 // src/server/services/filesystem-sync.ts
-import { readdirSync, readFileSync as readFileSync10, statSync, existsSync as existsSync10 } from "node:fs";
-import { join as join13, basename as basename2, dirname as dirname9, relative } from "node:path";
+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 { watch as watch2 } from "chokidar";
 
 // src/server/services/parsers/reviewer-parser.ts
@@ -34986,15 +35697,13 @@ function queryScalar(db, sql, params = []) {
   return result[0].values[0]?.[0] ?? null;
 }
 var FilesystemSync = class {
-  constructor(db, sessionsDir, io2, onSync) {
+  constructor(db, sessionsDir, io2) {
     this.db = db;
     this.sessionsDir = sessionsDir;
     this.io = io2;
-    this.onSync = onSync;
   }
   watcher = null;
   debounceTimers = /* @__PURE__ */ new Map();
-  onSync;
   // ── 6.1: Full Scan ──
   async fullScan() {
     if (!existsSync10(this.sessionsDir)) return;
@@ -35002,13 +35711,13 @@ var FilesystemSync = class {
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
       const sessionId = entry.name;
-      const sessionDir = join13(this.sessionsDir, sessionId);
+      const sessionDir = join14(this.sessionsDir, sessionId);
       this.syncSession(sessionId, sessionDir);
     }
   }
   syncSession(sessionId, sessionDir) {
     this.ensureSessionRow(sessionId, sessionDir);
-    const roundsDir = join13(sessionDir, "rounds");
+    const roundsDir = join14(sessionDir, "rounds");
     if (existsSync10(roundsDir)) {
       const rounds = readdirSync(roundsDir, { withFileTypes: true });
       for (const roundEntry of rounds) {
@@ -35016,34 +35725,34 @@ var FilesystemSync = class {
         const roundMatch = roundEntry.name.match(/^round-(\d+)$/);
         if (!roundMatch) continue;
         const roundNumber = parseInt(roundMatch[1] ?? "0", 10);
-        const roundDir = join13(roundsDir, roundEntry.name);
-        const reviewsDir = join13(roundDir, "reviews");
+        const roundDir = join14(roundsDir, roundEntry.name);
+        const reviewsDir = join14(roundDir, "reviews");
         if (existsSync10(reviewsDir)) {
           const reviewFiles = readdirSync(reviewsDir).filter((f) => f.endsWith(".md"));
           for (const reviewFile of reviewFiles) {
-            const filePath = join13(reviewsDir, reviewFile);
+            const filePath = join14(reviewsDir, reviewFile);
             this.processReviewerOutput(sessionId, roundNumber, filePath, reviewFile);
           }
         }
-        const roundMetaPath = join13(roundDir, "round-meta.json");
+        const roundMetaPath = join14(roundDir, "round-meta.json");
         if (existsSync10(roundMetaPath)) {
           this.processRoundMeta(sessionId, roundNumber, roundMetaPath);
         }
-        const finalPath = join13(roundDir, "final.md");
+        const finalPath = join14(roundDir, "final.md");
         if (existsSync10(finalPath)) {
           this.processFinalMd(sessionId, roundNumber, finalPath);
         }
-        const finalHumanPath = join13(roundDir, "final-human.md");
+        const finalHumanPath = join14(roundDir, "final-human.md");
         if (existsSync10(finalHumanPath)) {
           this.processGenericArtifact(sessionId, "final-human", finalHumanPath, roundNumber);
         }
-        const discoursePath = join13(roundDir, "discourse.md");
+        const discoursePath = join14(roundDir, "discourse.md");
         if (existsSync10(discoursePath)) {
           this.processGenericArtifact(sessionId, "discourse", discoursePath, roundNumber);
         }
       }
     }
-    const mapDir = join13(sessionDir, "map", "runs");
+    const mapDir = join14(sessionDir, "map", "runs");
     if (existsSync10(mapDir)) {
       const runs = readdirSync(mapDir, { withFileTypes: true });
       for (const runEntry of runs) {
@@ -35051,12 +35760,12 @@ var FilesystemSync = class {
         const runMatch = runEntry.name.match(/^run-(\d+)$/);
         if (!runMatch) continue;
         const runNumber = parseInt(runMatch[1] ?? "0", 10);
-        const runDir = join13(mapDir, runEntry.name);
-        const mapMetaPath = join13(runDir, "map-meta.json");
+        const runDir = join14(mapDir, runEntry.name);
+        const mapMetaPath = join14(runDir, "map-meta.json");
         if (existsSync10(mapMetaPath)) {
           this.processMapMeta(sessionId, runNumber, mapMetaPath);
         }
-        const mapPath = join13(runDir, "map.md");
+        const mapPath = join14(runDir, "map.md");
         if (existsSync10(mapPath)) {
           this.processMapMd(sessionId, runNumber, mapPath);
         }
@@ -35066,7 +35775,7 @@ var FilesystemSync = class {
           ["requirements-mapping.md", "requirements-mapping"]
         ];
         for (const [fileName, artifactType] of mapArtifacts) {
-          const filePath = join13(runDir, fileName);
+          const filePath = join14(runDir, fileName);
           if (existsSync10(filePath)) {
             this.processGenericArtifact(sessionId, artifactType, filePath, void 0, runNumber);
           }
@@ -35078,7 +35787,7 @@ var FilesystemSync = class {
       ["discovered-standards.md", "discovered-standards"]
     ];
     for (const [fileName, artifactType] of sessionArtifacts) {
-      const filePath = join13(sessionDir, fileName);
+      const filePath = join14(sessionDir, fileName);
       if (existsSync10(filePath)) {
         this.processGenericArtifact(sessionId, artifactType, filePath);
       }
@@ -35088,16 +35797,16 @@ var FilesystemSync = class {
   ensureSessionRow(sessionId, sessionDir) {
     const branchMatch = sessionId.match(/^\d{4}-\d{2}-\d{2}-(.+)$/);
     const branch = branchMatch?.[1] ?? "unknown";
-    const hasRoundsDir = existsSync10(join13(sessionDir, "rounds"));
-    const hasMapDir = existsSync10(join13(sessionDir, "map"));
+    const hasRoundsDir = existsSync10(join14(sessionDir, "rounds"));
+    const hasMapDir = existsSync10(join14(sessionDir, "map"));
     const workflowType = hasMapDir && !hasRoundsDir ? "map" : "review";
     let currentRound = 1;
     if (hasRoundsDir) {
-      const roundDirs = readdirSync(join13(sessionDir, "rounds")).filter((d) => d.match(/^round-\d+$/));
+      const roundDirs = readdirSync(join14(sessionDir, "rounds")).filter((d) => d.match(/^round-\d+$/));
       currentRound = Math.max(1, roundDirs.length);
     }
     let currentMapRun = 1;
-    const mapRunsDir = join13(sessionDir, "map", "runs");
+    const mapRunsDir = join14(sessionDir, "map", "runs");
     if (existsSync10(mapRunsDir)) {
       const runDirs = readdirSync(mapRunsDir).filter((d) => d.match(/^run-\d+$/));
       currentMapRun = Math.max(1, runDirs.length);
@@ -35106,40 +35815,40 @@ var FilesystemSync = class {
     let phaseNumber = 1;
     let status = "closed";
     if (workflowType === "review" && hasRoundsDir) {
-      const roundDir = join13(sessionDir, "rounds", `round-${currentRound}`);
-      if (existsSync10(join13(roundDir, "final.md"))) {
+      const roundDir = join14(sessionDir, "rounds", `round-${currentRound}`);
+      if (existsSync10(join14(roundDir, "final.md"))) {
         phase = "complete";
         phaseNumber = 8;
         status = "closed";
-      } else if (existsSync10(join13(roundDir, "discourse.md"))) {
+      } else if (existsSync10(join14(roundDir, "discourse.md"))) {
         phase = "synthesis";
         phaseNumber = 7;
-      } else if (existsSync10(join13(roundDir, "reviews")) && readdirSync(join13(roundDir, "reviews")).filter((f) => f.endsWith(".md")).length > 0) {
+      } else if (existsSync10(join14(roundDir, "reviews")) && readdirSync(join14(roundDir, "reviews")).filter((f) => f.endsWith(".md")).length > 0) {
         phase = "reviews";
         phaseNumber = 4;
-      } else if (existsSync10(join13(sessionDir, "context.md"))) {
+      } else if (existsSync10(join14(sessionDir, "context.md"))) {
         phase = "analysis";
         phaseNumber = 3;
-      } else if (existsSync10(join13(sessionDir, "discovered-standards.md"))) {
+      } else if (existsSync10(join14(sessionDir, "discovered-standards.md"))) {
         phase = "change-context";
         phaseNumber = 2;
       }
     } else if (workflowType === "map" && hasMapDir) {
-      const runDir = join13(mapRunsDir, `run-${currentMapRun}`);
-      if (existsSync10(join13(runDir, "map.md"))) {
+      const runDir = join14(mapRunsDir, `run-${currentMapRun}`);
+      if (existsSync10(join14(runDir, "map.md"))) {
         phase = "complete";
         phaseNumber = 6;
         status = "closed";
-      } else if (existsSync10(join13(runDir, "requirements-mapping.md"))) {
+      } else if (existsSync10(join14(runDir, "requirements-mapping.md"))) {
         phase = "synthesis";
         phaseNumber = 5;
-      } else if (existsSync10(join13(runDir, "flow-analysis.md"))) {
+      } else if (existsSync10(join14(runDir, "flow-analysis.md"))) {
         phase = "requirements-mapping";
         phaseNumber = 4;
-      } else if (existsSync10(join13(runDir, "topology.md"))) {
+      } else if (existsSync10(join14(runDir, "topology.md"))) {
         phase = "flow-analysis";
         phaseNumber = 3;
-      } else if (existsSync10(join13(sessionDir, "discovered-standards.md"))) {
+      } else if (existsSync10(join14(sessionDir, "discovered-standards.md"))) {
         phase = "topology";
         phaseNumber = 2;
       }
@@ -35153,14 +35862,40 @@ var FilesystemSync = class {
       );
     } else {
       if (!this.hasArtifacts(sessionDir)) return;
-      this.db.run(
-        `INSERT INTO sessions (id, branch, workflow_type, current_phase, phase_number, current_round, current_map_run, session_dir, status)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-        [sessionId, branch, workflowType, phase, phaseNumber, currentRound, currentMapRun, sessionDir, status]
-      );
+      this.db.transaction(() => {
+        insertSession(this.db, {
+          id: sessionId,
+          branch,
+          workflow_type: workflowType,
+          current_phase: phase,
+          phase_number: phaseNumber,
+          current_round: currentRound,
+          current_map_run: currentMapRun,
+          session_dir: sessionDir
+        });
+        insertEvent(this.db, {
+          session_id: sessionId,
+          event_type: "session_created",
+          phase,
+          phase_number: 1,
+          round: 1
+        });
+      });
+      if (status === "closed") {
+        commitReasonClose(
+          this.db,
+          sessionId,
+          {
+            event_type: "session_synced",
+            phase,
+            phase_number: phaseNumber,
+            metadata: JSON.stringify({ source: "filesystem_backfill" })
+          },
+          { status: "closed", current_phase: phase, phase_number: phaseNumber }
+        );
+      }
       this.io?.emit("session:created", { id: sessionId, branch, workflow_type: workflowType, status, current_phase: phase });
     }
-    this.onSync?.();
   }
   // ── Artifact Check ──
   /** Returns true if the directory contains at least one .md or .json file (recursively). */
@@ -35168,7 +35903,7 @@ var FilesystemSync = class {
     try {
       for (const entry of readdirSync(dir, { withFileTypes: true })) {
         if (entry.isDirectory()) {
-          if (this.hasArtifacts(join13(dir, entry.name))) return true;
+          if (this.hasArtifacts(join14(dir, entry.name))) return true;
         } else if (/\.(md|json)$/.test(entry.name)) {
           return true;
         }
@@ -35181,7 +35916,7 @@ var FilesystemSync = class {
   shouldSkip(filePath, existingParsedAt) {
     if (!existingParsedAt) return false;
     try {
-      const mtime = statSync(filePath).mtime;
+      const mtime = statSync2(filePath).mtime;
       const parsedAt = new Date(existingParsedAt);
       return mtime <= parsedAt;
     } catch {
@@ -35218,12 +35953,12 @@ var FilesystemSync = class {
     );
     if (existingRun && this.shouldSkip(filePath, existingRun["parsed_at"] ?? null)) return;
     if (existingRun?.["source"] === "orchestrator") {
-      const content2 = readFileSync10(filePath, "utf-8");
+      const content2 = readFileSync8(filePath, "utf-8");
       const action2 = this.upsertMarkdownArtifact(sessionId, "map", filePath, content2, void 0);
       this.emitArtifactEvent(action2, { sessionId, artifactType: "map", filePath });
       return;
     }
-    const content = readFileSync10(filePath, "utf-8");
+    const content = readFileSync8(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)
@@ -35309,10 +36044,16 @@ var FilesystemSync = class {
       [sessionId]
     );
     if (session && session["workflow_type"] === "map" && (session["current_phase"] !== "complete" || session["phase_number"] < 6)) {
-      this.db.run(
-        `UPDATE sessions SET current_phase = 'complete', phase_number = 6, status = 'closed', updated_at = datetime('now')
-         WHERE id = ?`,
-        [sessionId]
+      commitReasonClose(
+        this.db,
+        sessionId,
+        {
+          event_type: "session_synced",
+          phase: "complete",
+          phase_number: 6,
+          metadata: JSON.stringify({ source: "filesystem_backfill" })
+        },
+        { status: "closed", current_phase: "complete", phase_number: 6 }
       );
       this.io?.emit("session:updated", {
         id: sessionId,
@@ -35343,7 +36084,7 @@ var FilesystemSync = class {
     const roundId = roundRow?.["id"];
     if (!roundId) return;
     if (roundRow?.["source"] === "orchestrator") {
-      const content2 = readFileSync10(filePath, "utf-8");
+      const content2 = readFileSync8(filePath, "utf-8");
       const action2 = this.upsertMarkdownArtifact(sessionId, "reviewer-output", filePath, content2, roundNumber);
       this.emitArtifactEvent(action2, {
         sessionId,
@@ -35362,7 +36103,7 @@ var FilesystemSync = class {
       [roundId, reviewerType, instanceNumber]
     );
     if (existingOutput && this.shouldSkip(filePath, existingOutput["parsed_at"] ?? null)) return;
-    const content = readFileSync10(filePath, "utf-8");
+    const content = readFileSync8(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)
@@ -35450,7 +36191,7 @@ var FilesystemSync = class {
     if (existingRound?.["source"] === "orchestrator" && this.shouldSkip(filePath, existingRound["parsed_at"] ?? null)) return;
     let raw;
     try {
-      raw = JSON.parse(readFileSync10(filePath, "utf-8"));
+      raw = JSON.parse(readFileSync8(filePath, "utf-8"));
     } catch {
       console.error(`[FilesystemSync] Failed to parse ${filePath}`);
       return;
@@ -35501,7 +36242,7 @@ var FilesystemSync = class {
         const reviewerType = reviewer.type ?? "unknown";
         const instanceNumber = reviewer.instance ?? 1;
         const findings = reviewer.findings ?? [];
-        const reviewerMdPath = join13(roundDir, "reviews", `${reviewerType}-${instanceNumber}.md`);
+        const reviewerMdPath = join14(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 (?, ?, ?, ?, ?, ?)`,
@@ -35599,7 +36340,7 @@ var FilesystemSync = class {
     if (existingRun?.["source"] === "orchestrator" && this.shouldSkip(filePath, existingRun["parsed_at"] ?? null)) return;
     let raw;
     try {
-      raw = JSON.parse(readFileSync10(filePath, "utf-8"));
+      raw = JSON.parse(readFileSync8(filePath, "utf-8"));
     } catch {
       console.error(`[FilesystemSync] Failed to parse ${filePath}`);
       return;
@@ -35727,7 +36468,7 @@ var FilesystemSync = class {
     );
     const isOrchestratorSource = existingRound?.["source"] === "orchestrator";
     if (!isOrchestratorSource && existingRound && this.shouldSkip(filePath, existingRound["parsed_at"] ?? null)) return;
-    const content = readFileSync10(filePath, "utf-8");
+    const content = readFileSync8(filePath, "utf-8");
     if (isOrchestratorSource) {
       this.db.run(
         `UPDATE review_rounds SET final_md_path = ?, parsed_at = ?
@@ -35771,10 +36512,16 @@ var FilesystemSync = class {
       [sessionId]
     );
     if (session && (session["current_phase"] !== "complete" || session["phase_number"] < 8)) {
-      this.db.run(
-        `UPDATE sessions SET current_phase = 'complete', phase_number = 8, status = 'closed', updated_at = datetime('now')
-         WHERE id = ?`,
-        [sessionId]
+      commitReasonClose(
+        this.db,
+        sessionId,
+        {
+          event_type: "session_synced",
+          phase: "complete",
+          phase_number: 8,
+          metadata: JSON.stringify({ source: "filesystem_backfill" })
+        },
+        { status: "closed", current_phase: "complete", phase_number: 8 }
       );
       this.io?.emit("session:updated", {
         id: sessionId,
@@ -35800,7 +36547,7 @@ var FilesystemSync = class {
       [sessionId, artifactType, relPath]
     );
     if (existing && this.shouldSkip(filePath, existing["parsed_at"] ?? null)) return;
-    const content = readFileSync10(filePath, "utf-8");
+    const content = readFileSync8(filePath, "utf-8");
     const action = this.upsertMarkdownArtifact(sessionId, artifactType, filePath, content, roundNumber);
     this.emitArtifactEvent(action, {
       sessionId,
@@ -35847,7 +36594,6 @@ var FilesystemSync = class {
         this.debounceTimers.delete(filePath);
         try {
           this.processChangedFile(filePath);
-          this.onSync?.();
         } catch (err) {
           console.error(`[FilesystemSync] Error processing ${filePath}:`, err);
         }
@@ -35859,7 +36605,7 @@ var FilesystemSync = class {
     const parts = relFromSessions.split("/");
     const sessionId = parts[0];
     if (!sessionId) return;
-    const sessionDir = join13(this.sessionsDir, sessionId);
+    const sessionDir = join14(this.sessionsDir, sessionId);
     this.ensureSessionRow(sessionId, sessionDir);
     const fileName = basename2(filePath);
     const reviewerMatch = relFromSessions.match(/rounds\/round-(\d+)\/reviews\/(.+\.md)$/);
@@ -35931,53 +36677,52 @@ var FilesystemSync = class {
 };
 
 // src/server/services/db-sync-watcher.ts
-import { existsSync as existsSync11, readFileSync as readFileSync11, statSync as statSync2 } from "node:fs";
+import { existsSync as existsSync11 } from "node:fs";
 import { dirname as dirname10, basename as basename3 } from "node:path";
 import { watch as watch3 } from "chokidar";
-import initSqlJs3 from "sql.js";
 function col(row, key) {
   return row[key] ?? null;
 }
-var SQLITE_MAGIC = Buffer.from("SQLite format 3\0", "utf-8");
-function isValidSqliteHeader(buf) {
-  if (buf.length < SQLITE_MAGIC.length) return false;
-  return buf.subarray(0, SQLITE_MAGIC.length).equals(SQLITE_MAGIC);
-}
 var DbSyncWatcher = class {
-  constructor(db, dbFilePath, io2, onSync, onSessionInserted) {
+  constructor(db, dbFilePath, io2, onSessionInserted) {
     this.db = db;
     this.dbFilePath = dbFilePath;
     this.io = io2;
-    this.onSync = onSync;
     this.onSessionInserted = onSessionInserted;
   }
   watcher = null;
   debounceTimer = null;
-  lastMtime = 0;
-  wasmBinary = null;
-  SQL = null;
+  // Snapshots of last-emitted state, so we only emit on genuine changes.
+  seenSessions = /* @__PURE__ */ new Map();
+  maxEventId = 0;
+  seenCommandRows = /* @__PURE__ */ new Map();
   /**
-   * Initialize the WASM runtime (called once at startup).
+   * Prime snapshots from the current database so existing state is not
+   * re-emitted on first watch tick. (No WASM runtime to initialise under
+   * the native engine.)
    */
   async init() {
-    const wasmBuffer = readFileSync11(locateWasm());
-    this.wasmBinary = wasmBuffer.buffer.slice(
-      wasmBuffer.byteOffset,
-      wasmBuffer.byteOffset + wasmBuffer.byteLength
-    );
-    this.SQL = await initSqlJs3({ wasmBinary: this.wasmBinary });
+    this.primeSnapshots();
   }
-  /**
-   * Start watching the DB file for external changes.
-   */
+  primeSnapshots() {
+    for (const row of this.readSessions()) {
+      const id = col(row, "id");
+      if (id) this.seenSessions.set(id, sessionFingerprint(row));
+    }
+    const maxResult = this.db.exec("SELECT MAX(id) FROM orchestration_events");
+    const maxVal = maxResult[0]?.values[0]?.[0];
+    this.maxEventId = typeof maxVal === "number" ? maxVal : 0;
+    for (const row of this.readCommandRows()) {
+      const id = col(row, "id");
+      if (id != null) this.seenCommandRows.set(id, commandFingerprint(row));
+    }
+  }
+  /** Start watching the DB file (and its WAL sidecar) for external writes. */
   startWatching() {
     if (!existsSync11(this.dbFilePath)) return;
-    try {
-      this.lastMtime = statSync2(this.dbFilePath).mtimeMs;
-    } catch {
-    }
     const watchDir = dirname10(this.dbFilePath);
-    const watchedFile = basename3(this.dbFilePath);
+    const dbFile = basename3(this.dbFilePath);
+    const walFile = `${dbFile}-wal`;
     this.watcher = watch3(watchDir, {
       persistent: true,
       ignoreInitial: true,
@@ -35986,15 +36731,13 @@ var DbSyncWatcher = class {
       interval: 200
     });
     const onAnyEvent = (path2) => {
-      if (basename3(path2) === watchedFile) this.debouncedSync();
+      const name = basename3(path2);
+      if (name === dbFile || name === walFile) this.debouncedSync();
     };
     this.watcher.on("change", onAnyEvent);
     this.watcher.on("add", onAnyEvent);
     this.watcher.on("unlink", onAnyEvent);
   }
-  /**
-   * Stop watching.
-   */
   stopWatching() {
     if (this.debounceTimer) {
       clearTimeout(this.debounceTimer);
@@ -36005,9 +36748,6 @@ var DbSyncWatcher = class {
       this.watcher = null;
     }
   }
-  /**
-   * Debounce sync to avoid rapid reloads during multi-statement writes.
-   */
   debouncedSync() {
     if (this.debounceTimer) clearTimeout(this.debounceTimer);
     this.debounceTimer = setTimeout(() => {
@@ -36015,85 +36755,39 @@ var DbSyncWatcher = class {
     }, 300);
   }
   /**
-   * Read the on-disk DB and sync CLI-owned tables into the in-memory DB.
-   *
-   * Only syncs `sessions` and `orchestration_events` — these are the tables
-   * the CLI writes to via `ocr state` commands. All other tables are
-   * dashboard-owned and untouched.
-   *
-   * Public for direct use; also called automatically via registered save hooks
-   * to avoid overwriting CLI changes.
-   *
-   * Resilience:
-   *   1. Validates the SQLite magic header before handing the buffer to
-   *      sql.js. If the header is missing — e.g. we caught the file
-   *      mid-atomic-rename and read the temp file or a zero-byte stub —
-   *      we skip the load and wait for the next watch event. Without this
-   *      guard, a torn read corrupts sql.js and surfaces as an opaque WASM
-   *      `memory access out of bounds` exception.
-   *   2. Only advances `lastMtime` AFTER a successful load. A failed load
-   *      leaves the watermark untouched so the next change event retries.
+   * Rescan the live database and emit notifications for anything that
+   * changed since the last scan. Named `syncFromDisk` for call-site
+   * compatibility; under the native engine it performs no merge writes —
+   * it diffs the live connection against cached snapshots and emits.
    */
   syncFromDisk() {
-    if (!this.SQL || !existsSync11(this.dbFilePath)) return;
-    let currentMtime;
-    try {
-      currentMtime = statSync2(this.dbFilePath).mtimeMs;
-    } catch {
-      return;
-    }
-    if (currentMtime <= this.lastMtime) return;
-    let diskDb = null;
     try {
-      const fileBuffer = readFileSync11(this.dbFilePath);
-      if (!isValidSqliteHeader(fileBuffer)) {
-        return;
-      }
-      diskDb = new this.SQL.Database(fileBuffer);
-      this.syncSessions(diskDb);
-      this.syncEvents(diskDb);
-      this.syncAgentSessions(diskDb);
-      this.lastMtime = currentMtime;
-      this.onSync?.();
+      this.detectSessionChanges();
+      this.detectNewEvents();
+      this.detectCommandChanges();
     } catch (err) {
-      console.error("[DbSyncWatcher] Error syncing from disk:", err);
-    } finally {
-      diskDb?.close();
+      console.error("[DbSyncWatcher] Error scanning for changes:", err);
     }
   }
-  /**
-   * Sync the `sessions` table from disk → in-memory.
-   * The CLI is authoritative for: current_phase, phase_number, status,
-   * current_round, current_map_run, workflow_type, updated_at.
-   */
-  syncSessions(diskDb) {
-    const diskSessions = resultToRows(diskDb.exec("SELECT * FROM sessions"));
-    for (const row of diskSessions) {
+  readSessions() {
+    return resultToRows(this.db.exec("SELECT * FROM sessions"));
+  }
+  readCommandRows() {
+    return resultToRows(
+      this.db.exec(
+        `SELECT id, last_heartbeat_at, finished_at, exit_code, workflow_id, vendor_session_id
+           FROM command_executions`
+      )
+    );
+  }
+  detectSessionChanges() {
+    for (const row of this.readSessions()) {
       const id = col(row, "id");
       if (!id) continue;
-      const memResult = this.db.exec(
-        "SELECT current_phase, phase_number, status, updated_at FROM sessions WHERE id = ?",
-        [id]
-      );
-      const memRows = resultToRows(memResult);
-      if (memRows.length === 0) {
-        this.db.run(
-          `INSERT INTO sessions (id, branch, status, workflow_type, current_phase, phase_number, current_round, current_map_run, started_at, updated_at, session_dir)
-           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-          [
-            col(row, "id"),
-            col(row, "branch"),
-            col(row, "status"),
-            col(row, "workflow_type"),
-            col(row, "current_phase"),
-            col(row, "phase_number"),
-            col(row, "current_round"),
-            col(row, "current_map_run"),
-            col(row, "started_at"),
-            col(row, "updated_at"),
-            col(row, "session_dir")
-          ]
-        );
+      const fp = sessionFingerprint(row);
+      const prev = this.seenSessions.get(id);
+      if (prev === void 0) {
+        this.seenSessions.set(id, fp);
         this.io.emit("session:created", {
           id,
           branch: col(row, "branch"),
@@ -36110,81 +36804,33 @@ var DbSyncWatcher = class {
         } catch (err) {
           console.error("[DbSyncWatcher] onSessionInserted hook failed:", err);
         }
-      } else {
-        const mem = memRows[0];
-        const diskPhase = col(row, "phase_number");
-        const memPhase = col(mem, "phase_number");
-        const diskStatus = col(row, "status");
-        const memStatus = col(mem, "status");
-        const diskCurrent = col(row, "current_phase");
-        const memCurrent = col(mem, "current_phase");
-        if (diskPhase !== memPhase || diskStatus !== memStatus || diskCurrent !== memCurrent) {
-          this.db.run(
-            `UPDATE sessions
-             SET current_phase = ?, phase_number = ?, status = ?,
-                 current_round = ?, current_map_run = ?, workflow_type = ?,
-                 updated_at = ?
-             WHERE id = ?`,
-            [
-              col(row, "current_phase"),
-              col(row, "phase_number"),
-              col(row, "status"),
-              col(row, "current_round"),
-              col(row, "current_map_run"),
-              col(row, "workflow_type"),
-              col(row, "updated_at"),
-              id
-            ]
-          );
-          this.io.emit("session:updated", {
-            id,
-            status: col(row, "status"),
-            current_phase: col(row, "current_phase"),
-            phase_number: col(row, "phase_number")
-          });
-        }
+      } else if (prev !== fp) {
+        this.seenSessions.set(id, fp);
+        this.io.emit("session:updated", {
+          id,
+          status: col(row, "status"),
+          current_phase: col(row, "current_phase"),
+          phase_number: col(row, "phase_number")
+        });
       }
     }
   }
-  /**
-   * Sync the `orchestration_events` table from disk → in-memory.
-   * Events are append-only, so we INSERT any that don't exist yet.
-   */
-  syncEvents(diskDb) {
-    const diskEvents = resultToRows(
-      diskDb.exec("SELECT * FROM orchestration_events ORDER BY id ASC")
+  detectNewEvents() {
+    const rows = resultToRows(
+      this.db.exec(
+        "SELECT * FROM orchestration_events WHERE id > ? ORDER BY id ASC",
+        [this.maxEventId]
+      )
     );
-    const newEvents = [];
+    if (rows.length === 0) return;
     const affectedSessions = /* @__PURE__ */ new Set();
-    for (const row of diskEvents) {
+    for (const row of rows) {
       const eventId = col(row, "id");
       const sessionId = col(row, "session_id");
-      const existing = this.db.exec(
-        "SELECT id FROM orchestration_events WHERE id = ?",
-        [eventId]
-      );
-      if (existing.length > 0 && existing[0]?.values.length !== 0) continue;
-      this.db.run(
-        `INSERT OR IGNORE INTO orchestration_events (id, session_id, event_type, phase, phase_number, round, metadata, created_at)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
-        [
-          eventId,
-          sessionId,
-          col(row, "event_type"),
-          col(row, "phase"),
-          col(row, "phase_number"),
-          col(row, "round"),
-          col(row, "metadata"),
-          col(row, "created_at")
-        ]
-      );
-      newEvents.push(row);
-      affectedSessions.add(sessionId);
-    }
-    for (const row of newEvents) {
       const eventType = col(row, "event_type");
-      const sessionId = col(row, "session_id");
       const metadataStr = col(row, "metadata");
+      if (eventId > this.maxEventId) this.maxEventId = eventId;
+      if (sessionId) affectedSessions.add(sessionId);
       if (eventType === "round_completed") {
         const roundNumber = col(row, "round");
         if (sessionId && roundNumber && metadataStr) {
@@ -36197,98 +36843,33 @@ var DbSyncWatcher = class {
         }
       }
     }
-    if (newEvents.length > 0) {
-      for (const sessionId of affectedSessions) {
-        this.io.to(`session:${sessionId}`).emit("session:events", { session_id: sessionId });
-      }
+    for (const sessionId of affectedSessions) {
+      this.io.to(`session:${sessionId}`).emit("session:events", { session_id: sessionId });
     }
   }
-  /**
-   * Sync the `command_executions` table from disk → in-memory.
-   *
-   * Migration v11 unified `agent_sessions` into `command_executions`. The
-   * journal fields (`vendor`, `vendor_session_id`, `persona`, `resolved_model`,
-   * `last_heartbeat_at`, `notes`, …) live on the same table. Rows the CLI
-   * writes via `ocr session start-instance` / `bind-vendor-id` / `beat` /
-   * `end-instance` flow through atomic file rename, so the disk file is the
-   * source of truth.
-   *
-   * Strategy: full mirror via `INSERT OR REPLACE` keyed on the integer
-   * primary key. The table is small enough that copying every row each
-   * sync is cheap. Emits `agent_session:updated` with affected workflow ids
-   * so the dashboard's query cache invalidates selectively.
-   */
-  syncAgentSessions(diskDb) {
-    const diskRows = resultToRows(
-      diskDb.exec("SELECT * FROM command_executions")
-    );
-    if (diskRows.length === 0) return;
+  detectCommandChanges() {
     const affectedWorkflows = /* @__PURE__ */ new Set();
-    let changed = 0;
-    for (const row of diskRows) {
+    for (const row of this.readCommandRows()) {
       const id = col(row, "id");
+      if (id == null) continue;
+      const fp = commandFingerprint(row);
+      if (this.seenCommandRows.get(id) === fp) continue;
+      this.seenCommandRows.set(id, fp);
       const workflowId = col(row, "workflow_id");
-      const vendorSessionId = col(row, "vendor_session_id");
       const heartbeat = col(row, "last_heartbeat_at");
-      const finishedAt = col(row, "finished_at");
-      const exitCode = col(row, "exit_code");
-      const existing = this.db.exec(
-        `SELECT last_heartbeat_at, finished_at, exit_code,
-                workflow_id, vendor_session_id
-           FROM command_executions WHERE id = ?`,
-        [id]
-      );
-      const existingRow = existing[0]?.values?.[0];
-      const sameHeartbeat = (existingRow?.[0] ?? null) === heartbeat;
-      const sameFinished = (existingRow?.[1] ?? null) === finishedAt;
-      const sameExit = (existingRow?.[2] ?? null) === exitCode;
-      const sameWorkflow = (existingRow?.[3] ?? null) === workflowId;
-      const sameVendorSession = (existingRow?.[4] ?? null) === vendorSessionId;
-      if (existingRow && sameHeartbeat && sameFinished && sameExit && sameWorkflow && sameVendorSession) continue;
-      this.db.run(
-        `INSERT OR REPLACE INTO command_executions
-           (id, uid, command, args, exit_code, started_at, finished_at, output,
-            pid, is_detached, workflow_id, parent_id, vendor, vendor_session_id,
-            persona, instance_index, name, resolved_model, last_heartbeat_at, notes)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-        [
-          id,
-          col(row, "uid"),
-          col(row, "command"),
-          col(row, "args"),
-          exitCode,
-          col(row, "started_at"),
-          finishedAt,
-          col(row, "output"),
-          col(row, "pid"),
-          col(row, "is_detached"),
-          workflowId,
-          col(row, "parent_id"),
-          col(row, "vendor"),
-          col(row, "vendor_session_id"),
-          col(row, "persona"),
-          col(row, "instance_index"),
-          col(row, "name"),
-          col(row, "resolved_model"),
-          heartbeat,
-          col(row, "notes")
-        ]
-      );
       if (heartbeat !== null && workflowId) {
         affectedWorkflows.add(workflowId);
       }
-      changed++;
     }
-    if (changed > 0 && affectedWorkflows.size > 0) {
+    if (affectedWorkflows.size > 0) {
       this.io.emit("agent_session:updated", {
         workflow_ids: Array.from(affectedWorkflows)
       });
     }
   }
   /**
-   * Process a `round_completed` orchestration event.
-   * Upserts review_rounds with orchestrator data for real-time dashboard updates.
-   * Idempotent — skips if round already has source='orchestrator'.
+   * Project a `round_completed` event into `review_rounds` (orchestrator
+   * source latch) and emit a room-scoped `round:updated`. Idempotent.
    */
   processRoundCompletedEvent(sessionId, roundNumber, metadataStr) {
     let metadata;
@@ -36306,8 +36887,7 @@ var DbSyncWatcher = class {
       return;
     }
     this.db.run(
-      `INSERT OR IGNORE INTO review_rounds (session_id, round_number)
-       VALUES (?, ?)`,
+      `INSERT OR IGNORE INTO review_rounds (session_id, round_number) VALUES (?, ?)`,
       [sessionId, roundNumber]
     );
     this.db.run(
@@ -36338,9 +36918,8 @@ var DbSyncWatcher = class {
     });
   }
   /**
-   * Process a `map_completed` orchestration event.
-   * Upserts map_runs with orchestrator data for real-time dashboard updates.
-   * Idempotent — skips if run already has source='orchestrator'.
+   * Project a `map_completed` event into `map_runs` and emit a room-scoped
+   * `map:updated`. Idempotent.
    */
   processMapCompletedEvent(sessionId, runNumber, metadataStr) {
     let metadata;
@@ -36358,8 +36937,7 @@ var DbSyncWatcher = class {
       return;
     }
     this.db.run(
-      `INSERT OR IGNORE INTO map_runs (session_id, run_number)
-       VALUES (?, ?)`,
+      `INSERT OR IGNORE INTO map_runs (session_id, run_number) VALUES (?, ?)`,
       [sessionId, runNumber]
     );
     this.db.run(
@@ -36382,33 +36960,42 @@ var DbSyncWatcher = class {
       source: "orchestrator"
     });
   }
-  /**
-   * Record current mtime after the dashboard writes to disk.
-   * Called automatically via registered save hooks after saveDb().
-   */
-  markOwnWrite() {
-    try {
-      this.lastMtime = statSync2(this.dbFilePath).mtimeMs;
-    } catch {
-    }
-  }
 };
+function sessionFingerprint(row) {
+  return [
+    col(row, "status"),
+    col(row, "current_phase"),
+    col(row, "phase_number"),
+    col(row, "current_round"),
+    col(row, "current_map_run"),
+    col(row, "updated_at")
+  ].join("|");
+}
+function commandFingerprint(row) {
+  return [
+    col(row, "last_heartbeat_at"),
+    col(row, "finished_at"),
+    col(row, "exit_code"),
+    col(row, "workflow_id"),
+    col(row, "vendor_session_id")
+  ].join("|");
+}
 
 // src/server/socket/chat-handler.ts
 import { dirname as dirname11 } from "node:path";
 
 // src/server/services/chat-context.ts
-import { readFileSync as readFileSync12, readdirSync as readdirSync2, existsSync as existsSync12 } from "node:fs";
-import { join as join14 } from "node:path";
+import { readFileSync as readFileSync9, readdirSync as readdirSync2, existsSync as existsSync12 } from "node:fs";
+import { join as join15 } from "node:path";
 function buildChatContext(ocrDir, target) {
-  const sessionsDir = join14(ocrDir, "sessions");
+  const sessionsDir = join15(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 = join14(
+  const mapPath = join15(
     sessionsDir,
     sessionId,
     "map",
@@ -36423,7 +37010,7 @@ function buildMapRunContext(sessionsDir, sessionId, runNumber) {
     `Below is the Code Review Map that organizes the changeset into reviewable sections:`
   ];
   if (existsSync12(mapPath)) {
-    const content = readFileSync12(mapPath, "utf-8");
+    const content = readFileSync9(mapPath, "utf-8");
     parts.push("");
     parts.push("<map>");
     parts.push(content);
@@ -36435,9 +37022,9 @@ function buildMapRunContext(sessionsDir, sessionId, runNumber) {
   return parts.join("\n");
 }
 function buildReviewRoundContext(sessionsDir, sessionId, roundNumber) {
-  const roundDir = join14(sessionsDir, sessionId, "rounds", `round-${roundNumber}`);
-  const finalPath = join14(roundDir, "final.md");
-  const reviewersDir = join14(roundDir, "reviews");
+  const roundDir = join15(sessionsDir, sessionId, "rounds", `round-${roundNumber}`);
+  const finalPath = join15(roundDir, "final.md");
+  const reviewersDir = join15(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}".`,
@@ -36445,7 +37032,7 @@ function buildReviewRoundContext(sessionsDir, sessionId, roundNumber) {
     `Below are the review artifacts for this round:`
   ];
   if (existsSync12(finalPath)) {
-    const content = readFileSync12(finalPath, "utf-8");
+    const content = readFileSync9(finalPath, "utf-8");
     parts.push("");
     parts.push("<final-synthesis>");
     parts.push(content);
@@ -36454,7 +37041,7 @@ function buildReviewRoundContext(sessionsDir, sessionId, roundNumber) {
   if (existsSync12(reviewersDir)) {
     const files = readdirSync2(reviewersDir).filter((f) => f.endsWith(".md")).sort();
     for (const file of files) {
-      const content = readFileSync12(join14(reviewersDir, file), "utf-8");
+      const content = readFileSync9(join15(reviewersDir, file), "utf-8");
       const reviewerName = file.replace(/\.md$/, "");
       parts.push("");
       parts.push(`<reviewer name="${reviewerName}">`);
@@ -36521,7 +37108,6 @@ function startTrackedExecution(io2, db, ocrDir, command, args = []) {
          WHERE id = ?`,
         [exitCode, finishedAt, outputBuffer, executionId]
       );
-      saveDb(db, ocrDir);
       appendCommandLog(ocrDir, {
         ...baseLogEntry,
         is_detached: trackedIsDetached,
@@ -36551,13 +37137,12 @@ function cleanupChat(conversationId) {
     activeChats.delete(conversationId);
   }
 }
-function resetIdleTimer(conversationId, db, ocrDir) {
+function resetIdleTimer(conversationId, db) {
   const chat = activeChats.get(conversationId);
   if (chat) {
     clearTimeout(chat.timer);
     chat.timer = setTimeout(() => {
       updateConversationStatus(db, conversationId, "expired");
-      saveDb(db, ocrDir);
       cleanupChat(conversationId);
     }, IDLE_TIMEOUT_MS);
   }
@@ -36581,9 +37166,7 @@ function registerChatHandlers(io2, socket, db, ocrDir, aiCliService) {
         return;
       }
       upsertConversation(db, conversationId, sessionId, targetType, targetId);
-      saveDb(db, ocrDir);
       insertMessage(db, conversationId, "user", message);
-      saveDb(db, ocrDir);
       const conversation = getConversation(db, conversationId);
       const claudeSessionId = conversation?.claude_session_id ?? null;
       let prompt;
@@ -36624,7 +37207,6 @@ User: ${message}`;
       const proc = spawnResult.process;
       const timer = setTimeout(() => {
         updateConversationStatus(db, conversationId, "expired");
-        saveDb(db, ocrDir);
         cleanupChat(conversationId);
       }, IDLE_TIMEOUT_MS);
       activeChats.set(conversationId, { process: proc, conversationId, timer });
@@ -36714,7 +37296,6 @@ User: ${message}`;
         if (assistantText.trim()) {
           insertMessage(db, conversationId, "assistant", assistantText.trim());
         }
-        saveDb(db, ocrDir);
         if (code === 0) {
           tracker.appendOutput("\n\u2713 Response complete\n");
           tracker.finish(0);
@@ -36730,7 +37311,7 @@ User: ${message}`;
             error: errMsg
           });
         }
-        resetIdleTimer(conversationId, db, ocrDir);
+        resetIdleTimer(conversationId, db);
         const chat = activeChats.get(conversationId);
         if (chat) {
           chat.process = null;
@@ -36790,13 +37371,13 @@ function cleanupAllChats() {
 }
 
 // src/server/socket/post-handler.ts
-import { existsSync as existsSync13, mkdirSync as mkdirSync6, readFileSync as readFileSync13, unlinkSync as unlinkSync2, writeFileSync as writeFileSync6 } from "node:fs";
+import { existsSync as existsSync13, mkdirSync as mkdirSync5, readFileSync as readFileSync10, unlinkSync as unlinkSync2, writeFileSync as writeFileSync4 } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
-import { join as join15, dirname as dirname12, isAbsolute } from "node:path";
+import { join as join16, dirname as dirname12, isAbsolute as isAbsolute2 } from "node:path";
 import { randomUUID as randomUUID2 } from "node:crypto";
-function resolveSessionDir(sessionDir, ocrDir) {
-  if (isAbsolute(sessionDir)) return sessionDir;
-  return join15(dirname12(ocrDir), sessionDir);
+function resolveSessionDir2(sessionDir, ocrDir) {
+  if (isAbsolute2(sessionDir)) return sessionDir;
+  return join16(dirname12(ocrDir), sessionDir);
 }
 var BRANCH_PREFIXES = [
   "feat",
@@ -36966,19 +37547,19 @@ function registerPostHandlers(io2, socket, db, ocrDir, aiCliService) {
         socket.emit("post:error", { error: "Session not found" });
         return;
       }
-      const sessionDir = session.session_dir ? resolveSessionDir(session.session_dir, ocrDir) : join15(ocrDir, "sessions", sessionId);
-      const roundDir = join15(sessionDir, "rounds", `round-${roundNumber}`);
-      const finalPath = join15(roundDir, "final.md");
+      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)) {
         socket.emit("post:error", { error: "final.md not found for this round" });
         return;
       }
-      const humanReviewPath = join15(roundDir, "final-human.md");
+      const humanReviewPath = join16(roundDir, "final-human.md");
       const repoRoot = dirname12(ocrDir);
-      const commandMdPath = join15(ocrDir, "commands", "translate-review-to-single-human.md");
+      const commandMdPath = join16(ocrDir, "commands", "translate-review-to-single-human.md");
       let commandContent;
       try {
-        commandContent = readFileSync13(commandMdPath, "utf-8");
+        commandContent = readFileSync10(commandMdPath, "utf-8");
       } catch {
         socket.emit("post:error", {
           error: `Command file not found: ${commandMdPath}. Run \`ocr init\` to set up.`
@@ -37006,8 +37587,8 @@ function registerPostHandlers(io2, socket, db, ocrDir, aiCliService) {
           "",
           "Examples:",
           `- Instead of \`ocr state show\`, run: \`node ${localCli} state show\``,
-          `- Instead of \`ocr state init ...\`, run: \`node ${localCli} state init ...\``,
-          `- Instead of \`ocr state transition ...\`, run: \`node ${localCli} state transition ...\``,
+          `- Instead of \`ocr state begin ...\`, run: \`node ${localCli} state begin ...\``,
+          `- Instead of \`ocr state advance ...\`, run: \`node ${localCli} state advance ...\``,
           "",
           "This applies to every `ocr` invocation. Do NOT use bare `ocr` commands."
         );
@@ -37060,7 +37641,7 @@ function registerPostHandlers(io2, socket, db, ocrDir, aiCliService) {
         let generatedContent = "";
         if (existsSync13(humanReviewPath)) {
           try {
-            generatedContent = readFileSync13(humanReviewPath, "utf-8").trim();
+            generatedContent = readFileSync10(humanReviewPath, "utf-8").trim();
           } catch {
           }
         }
@@ -37135,12 +37716,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 ? resolveSessionDir(session.session_dir, ocrDir) : join15(ocrDir, "sessions", sessionId);
-        const roundDir = join15(sessionDir, "rounds", `round-${roundNumber}`);
-        mkdirSync6(roundDir, { recursive: true });
-        const filePath = join15(roundDir, "final-human.md");
-        writeFileSync6(filePath, content, { mode: 420 });
-        saveDb(db, ocrDir);
+        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 });
         socket.emit("post:save-result", { success: true });
       } catch (err) {
         console.error("Error in post:save handler:", err);
@@ -37166,13 +37746,13 @@ function registerPostHandlers(io2, socket, db, ocrDir, aiCliService) {
         );
         tracker.appendOutput(`\u25B8 Posting review to PR #${prNumber}...
 `);
-        const tmpDir = join15(tmpdir2(), "ocr-post-comments");
+        const tmpDir = join16(tmpdir2(), "ocr-post-comments");
         try {
-          mkdirSync6(tmpDir, { recursive: true, mode: 448 });
+          mkdirSync5(tmpDir, { recursive: true, mode: 448 });
         } catch {
         }
-        const tmpFile = join15(tmpDir, `${randomUUID2()}.md`);
-        writeFileSync6(tmpFile, content, { mode: 384 });
+        const tmpFile = join16(tmpDir, `${randomUUID2()}.md`);
+        writeFileSync4(tmpFile, content, { mode: 384 });
         const repoRoot = dirname12(ocrDir);
         try {
           const { stdout } = await execBinaryAsync(
@@ -37217,17 +37797,17 @@ function cleanupAllPostGenerations() {
 }
 
 // ../cli/src/lib/runtime-config.ts
-import { existsSync as existsSync14, readFileSync as readFileSync14 } from "node:fs";
-import { join as join16 } from "node:path";
+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 = join16(ocrDir, "config.yaml");
+  const configPath = join17(ocrDir, "config.yaml");
   if (!existsSync14(configPath)) {
     return DEFAULT_AGENT_HEARTBEAT_SECONDS;
   }
   let content;
   try {
-    content = readFileSync14(configPath, "utf-8");
+    content = readFileSync11(configPath, "utf-8");
   } catch {
     return DEFAULT_AGENT_HEARTBEAT_SECONDS;
   }
@@ -37322,23 +37902,23 @@ async function startServer(options = {}) {
   const port = options.port ?? parseInt(process.env.PORT ?? "4173", 10);
   const ocrDir = resolveOcrDir();
   const aiCliService = new AiCliService(ocrDir);
-  const dbPathForCheckpoint = join17(ocrDir, "data", "ocr.db");
+  const dbPathForCheckpoint = join18(ocrDir, "data", "ocr.db");
   const walResult = walCheckpointTruncate(dbPathForCheckpoint);
   if (walResult === "checkpointed") {
     console.log("  WAL checkpoint:    truncated stale write-ahead-log file");
   }
   const db = await openDb(ocrDir);
-  const dataDir = join17(ocrDir, "data");
-  const pidFilePath = join17(dataDir, "dashboard.pid");
-  const portFilePath = join17(dataDir, "server-port");
-  mkdirSync7(dataDir, { recursive: true });
+  const dataDir = join18(ocrDir, "data");
+  const pidFilePath = join18(dataDir, "dashboard.pid");
+  const portFilePath = join18(dataDir, "server-port");
+  mkdirSync6(dataDir, { recursive: true });
   try {
     unlinkSync3(portFilePath);
   } catch {
   }
   if (existsSync15(pidFilePath)) {
     try {
-      const oldPid = parseInt(readFileSync15(pidFilePath, "utf-8").trim(), 10);
+      const oldPid = parseInt(readFileSync12(pidFilePath, "utf-8").trim(), 10);
       if (!isNaN(oldPid)) {
         try {
           process.kill(oldPid, 0);
@@ -37351,13 +37931,12 @@ async function startServer(options = {}) {
     } catch {
     }
   }
-  writeFileSync7(pidFilePath, String(process.pid), { mode: 384 });
+  writeFileSync5(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) {
     const recovered = replayCommandLog(db, ocrDir);
     if (recovered > 0) {
-      saveDb(db, ocrDir);
       console.log(`  Recovered ${recovered} command(s) from JSONL backup`);
     }
   }
@@ -37368,15 +37947,14 @@ async function startServer(options = {}) {
   if (orphanResult.length > 0 && orphanResult[0]) {
     const { columns, values: orphanRows } = orphanResult[0];
     const colIdx = Object.fromEntries(columns.map((c, i) => [c, i]));
-    const cutoff = Date.now() - 24 * 60 * 60 * 1e3;
+    const cutoff = Date.now() - PID_REUSE_GUARD_MS;
     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 (new Date(startedAt).getTime() < cutoff) continue;
-      try {
-        process.kill(pid, 0);
+      if (sqliteUtcMs(startedAt) < cutoff) continue;
+      if (defaultIsAlive(pid)) {
         if (isDetached) {
           try {
             process.kill(-pid, "SIGTERM");
@@ -37400,37 +37978,55 @@ async function startServer(options = {}) {
           } catch {
           }
         }, 2e3);
-      } catch {
       }
     }
     if (killedCount > 0) {
       console.log(`  Cleaned up ${killedCount} orphaned process(es)`);
     }
   }
-  const staleResult = db.exec(
-    "SELECT COUNT(*) as c FROM command_executions WHERE finished_at IS NULL OR exit_code IS NULL"
+  const legacyResult = db.exec(
+    "SELECT COUNT(*) as c FROM command_executions WHERE finished_at IS NOT NULL AND exit_code IS NULL"
   );
-  const staleCount = staleResult[0]?.values[0]?.[0] ?? 0;
-  if (staleCount > 0) {
+  const legacyCount = legacyResult[0]?.values[0]?.[0] ?? 0;
+  if (legacyCount > 0) {
     db.run(
       `UPDATE command_executions
-       SET exit_code = -2, finished_at = COALESCE(finished_at, datetime('now')),
+       SET exit_code = -2,
            output = COALESCE(output, '') || '
-[Cancelled]',
-           pid = NULL
-       WHERE finished_at IS NULL OR exit_code IS NULL`
+[Cancelled]'
+       WHERE finished_at IS NOT NULL AND exit_code IS NULL`
     );
-    saveDb(db, ocrDir);
-    console.log(`  Cleaned up ${staleCount} stale command(s)`);
+    console.log(`  Backfilled ${legacyCount} finished command(s) missing an exit code`);
   }
   const heartbeatSeconds = getAgentHeartbeatSeconds(ocrDir);
-  const sweepResult = sweepStaleAgentSessions(db, heartbeatSeconds);
-  if (sweepResult.orphanedIds.length > 0) {
-    saveDb(db, ocrDir);
+  const logAgentSweep = (result) => {
+    if (result.orphanedIds.length === 0) return;
+    const cascaded = result.cascadedWorkflowIds.length;
+    console.log(
+      `  Cleaned up ${result.orphanedIds.length} stale agent session(s) (heartbeat threshold ${heartbeatSeconds}s)` + (cascaded > 0 ? `; cascade-closed dependents of ${cascaded} workflow(s)` : "")
+    );
+  };
+  logAgentSweep(sweepStaleAgentSessions(db, heartbeatSeconds, defaultIsAlive));
+  const STALE_SESSION_THRESHOLD_SECONDS = 7 * 24 * 60 * 60;
+  const staleSessionResult = sweepStaleSessions(
+    db,
+    STALE_SESSION_THRESHOLD_SECONDS
+  );
+  if (staleSessionResult.closedSessionIds.length > 0) {
     console.log(
-      `  Cleaned up ${sweepResult.orphanedIds.length} stale agent session(s) (heartbeat threshold ${heartbeatSeconds}s)`
+      `  Auto-closed ${staleSessionResult.closedSessionIds.length} stale active session(s) (threshold 7 days)`
     );
   }
+  const SWEEP_INTERVAL_MS = 5 * 60 * 1e3;
+  const sweepTimer = setInterval(() => {
+    try {
+      logAgentSweep(sweepStaleAgentSessions(db, heartbeatSeconds, defaultIsAlive));
+      sweepStaleSessions(db, STALE_SESSION_THRESHOLD_SECONDS);
+    } catch (err) {
+      console.error("[sweep] periodic sweep failed:", err);
+    }
+  }, SWEEP_INTERVAL_MS);
+  sweepTimer.unref();
   app.get("/api/reviews", (_req, res) => {
     try {
       const rounds = getAllRounds(db).map((r) => ({
@@ -37448,12 +38044,12 @@ async function startServer(options = {}) {
   app.use("/api/sessions", createReviewsRouter(db));
   app.use("/api/sessions", createMapsRouter(db));
   app.use("/api/sessions", createArtifactsRouter(db));
-  app.use("/api", createProgressRouter(db, ocrDir));
-  app.use("/api/notes", createNotesRouter(db, ocrDir));
+  app.use("/api", createProgressRouter(db));
+  app.use("/api/notes", createNotesRouter(db));
   app.use("/api/stats", createStatsRouter(db));
   app.use("/api/commands", createCommandsRouter(db, ocrDir));
   app.use("/api/config", createConfigRouter(ocrDir, aiCliService));
-  app.use("/api/sessions", createChatRouter(db, ocrDir));
+  app.use("/api/sessions", createChatRouter(db));
   app.use("/api/reviewers", createReviewersRouter(ocrDir));
   let pullSync = () => {
   };
@@ -37461,11 +38057,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 = join17(__dirname3, "client");
+  const clientDir = join18(__dirname3, "client");
   if (process.env.NODE_ENV === "production" && existsSync15(clientDir)) {
     app.use(import_express15.default.static(clientDir, { index: false }));
-    const indexHtmlPath = join17(clientDir, "index.html");
-    const rawIndexHtml = existsSync15(indexHtmlPath) ? readFileSync15(indexHtmlPath, "utf-8") : "";
+    const indexHtmlPath = join18(clientDir, "index.html");
+    const rawIndexHtml = existsSync15(indexHtmlPath) ? readFileSync12(indexHtmlPath, "utf-8") : "";
     const tokenScript = `<script>window.__OCR_TOKEN__=${JSON.stringify(AUTH_TOKEN)};</script>`;
     const injectedIndexHtml = rawIndexHtml.replace(
       "</head>",
@@ -37484,16 +38080,13 @@ async function startServer(options = {}) {
     registerChatHandlers(io, socket, db, ocrDir, aiCliService);
     registerPostHandlers(io, socket, db, ocrDir, aiCliService);
   });
-  const dbFilePath = join17(ocrDir, "data", "ocr.db");
+  const dbFilePath = join18(ocrDir, "data", "ocr.db");
   const dbSyncWatcher = new DbSyncWatcher(
     db,
     dbFilePath,
     io,
-    () => {
-      saveDb(db, ocrDir);
-    },
     // Auto-link the dashboard's parent execution row when the AI
-    // creates a new session via `ocr state init`. Eliminates the
+    // creates a new session via `ocr state begin`. Eliminates the
     // dependency on env-var/flag propagation through the AI's shell.
     (session) => {
       sessionCapture.autoLinkPendingDashboardExecution(session.id);
@@ -37503,14 +38096,9 @@ async function startServer(options = {}) {
   dbSyncWatcher.startWatching();
   pullSync = () => dbSyncWatcher.syncFromDisk();
   console.log(`  Watching DB:       ${shortenPath(dbFilePath)}`);
-  registerSaveHooks(
-    () => dbSyncWatcher.syncFromDisk(),
-    () => dbSyncWatcher.markOwnWrite()
-  );
-  const sessionsDir = join17(ocrDir, "sessions");
-  const fsSync = new FilesystemSync(db, sessionsDir, io, () => saveDb(db, ocrDir));
+  const sessionsDir = join18(ocrDir, "sessions");
+  const fsSync = new FilesystemSync(db, sessionsDir, io);
   await fsSync.fullScan();
-  saveDb(db, ocrDir);
   fsSync.startWatching();
   console.log(`  Watching sessions: ${shortenPath(sessionsDir)}`);
   const stopReviewersWatch = watchReviewersMeta(ocrDir, io);
@@ -37547,7 +38135,7 @@ async function startServer(options = {}) {
   if (actualPort !== port) {
     console.log(`  Note: using port ${actualPort} (${port} was in use)`);
   }
-  writeFileSync7(portFilePath, String(actualPort), { mode: 384 });
+  writeFileSync5(portFilePath, String(actualPort), { mode: 384 });
   console.log(`  Server:            http://localhost:${actualPort}`);
   console.log(`  OCR directory:     ${shortenPath(ocrDir)}`);
   console.log();
@@ -37573,7 +38161,7 @@ async function startServer(options = {}) {
     } catch {
     }
     try {
-      unlinkSync3(join17(dataDir, "dashboard-active-spawn.json"));
+      unlinkSync3(join18(dataDir, "dashboard-active-spawn.json"));
     } catch {
     }
     try {
@@ -37614,24 +38202,12 @@ async function startServer(options = {}) {
     }
     cleanupAllChats();
     cleanupAllPostGenerations();
-    try {
-      flushSave();
-    } catch {
-    }
-    try {
-      saveDb(db, ocrDir);
-    } catch {
-    }
     dbSyncWatcher.stopWatching();
     fsSync.stopWatching();
     stopReviewersWatch();
     io.close();
     httpServer.closeAllConnections();
     httpServer.close(() => {
-      try {
-        saveDb(db, ocrDir);
-      } catch {
-      }
       closeDb();
       console.log("Server stopped.");
       process.exit(0);