@open-code-review/cli 2.2.1 → 2.4.0

package/dist/lib/db/index.js

@@ -1,2177 +0,0 @@
-// src/lib/db/index.ts
-import {
-  existsSync as existsSync4,
-  mkdirSync as mkdirSync2,
-  copyFileSync as copyFileSync2,
-  statSync as statSync2,
-  mkdtempSync,
-  rmSync
-} from "node:fs";
-import { tmpdir } from "node:os";
-import { dirname as dirname4, join as join4 } from "node:path";
-
-// src/lib/db/engine.ts
-import { createRequire } from "node:module";
-
-// src/lib/runtime-checks.ts
-var NODE_FLOOR = { major: 22, minor: 5 };
-function isSupportedNode(version) {
-  const [major = 0, minor = 0] = version.split(".").map((n) => Number.parseInt(n, 10) || 0);
-  return major > NODE_FLOOR.major || major === NODE_FLOOR.major && minor >= NODE_FLOOR.minor;
-}
-function nodeVersionGuardMessage(version) {
-  return `
-Open Code Review requires Node.js >= ${NODE_FLOOR.major}.${NODE_FLOOR.minor} (it uses Node's built-in SQLite, \`node:sqlite\`).
-You have Node ${version}. Upgrade Node (e.g. \`nvm install 22 && nvm use 22\`) and re-run.
-
-`;
-}
-function isSuppressibleSqliteWarning(warning) {
-  const message = typeof warning === "string" ? warning : warning?.message;
-  return typeof message === "string" && message.includes("SQLite is an experimental feature");
-}
-
-// src/lib/db/engine.ts
-var SQLITE_BUSY = 5;
-var SQLITE_BUSY_SNAPSHOT = 261;
-var BUSY_RETRY_ATTEMPTS = 5;
-var BUSY_RETRY_BACKOFF_MS = 50;
-var savepointName = (depth) => `ocr_sp_${depth}`;
-var nodeRequire = createRequire(import.meta.url);
-var _preconditionsApplied = false;
-function applyEnginePreconditions() {
-  if (_preconditionsApplied) return;
-  _preconditionsApplied = true;
-  const originalEmitWarning = process.emitWarning.bind(process);
-  process.emitWarning = (warning, ...args) => {
-    if (isSuppressibleSqliteWarning(warning)) return;
-    originalEmitWarning(warning, ...args);
-  };
-}
-var _DatabaseSyncCtor;
-function newDatabase(path) {
-  if (!_DatabaseSyncCtor) {
-    applyEnginePreconditions();
-    try {
-      _DatabaseSyncCtor = nodeRequire("node:sqlite").DatabaseSync;
-    } catch (e) {
-      if (!isSupportedNode(process.versions.node)) {
-        throw new Error(nodeVersionGuardMessage(process.versions.node).trim());
-      }
-      throw e;
-    }
-  }
-  return new _DatabaseSyncCtor(path);
-}
-function isBusyError(e) {
-  const errcode = e?.errcode;
-  return errcode === SQLITE_BUSY || errcode === SQLITE_BUSY_SNAPSHOT;
-}
-var SLEEP_BUF = new Int32Array(new SharedArrayBuffer(4));
-function sleepSync(ms) {
-  Atomics.wait(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 probeEngine() {
-  try {
-    const db = newDatabase(":memory:");
-    db.exec("PRAGMA journal_mode = WAL");
-    db.exec("CREATE TABLE _probe(x); INSERT INTO _probe VALUES (1);");
-    const row = db.prepare("SELECT sqlite_version() AS v").get();
-    db.close();
-    return { ok: true, version: row.v };
-  } catch (e) {
-    return { ok: false, error: e instanceof Error ? e.message : String(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);
-}
-
-// src/lib/db/migrations.ts
-var MIGRATIONS = [
-  {
-    version: 1,
-    description: "Initial schema \u2014 sessions, events, artifacts, user state",
-    sql: `
-      -- Layer 1: Workflow State
-
-      CREATE TABLE sessions (
-        id TEXT PRIMARY KEY,
-        branch TEXT NOT NULL,
-        status TEXT NOT NULL DEFAULT 'active' CHECK(status IN ('active', 'closed')),
-        workflow_type TEXT NOT NULL CHECK(workflow_type IN ('review', 'map')),
-        current_phase TEXT NOT NULL DEFAULT 'context',
-        phase_number INTEGER NOT NULL DEFAULT 1,
-        current_round INTEGER NOT NULL DEFAULT 1,
-        current_map_run INTEGER NOT NULL DEFAULT 1,
-        started_at TEXT NOT NULL DEFAULT (datetime('now')),
-        updated_at TEXT NOT NULL DEFAULT (datetime('now')),
-        session_dir TEXT NOT NULL
-      );
-
-      CREATE TABLE orchestration_events (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
-        event_type TEXT NOT NULL,
-        phase TEXT,
-        phase_number INTEGER,
-        round INTEGER,
-        metadata TEXT,
-        created_at TEXT NOT NULL DEFAULT (datetime('now'))
-      );
-      CREATE INDEX idx_events_session ON orchestration_events(session_id);
-      CREATE INDEX idx_events_type ON orchestration_events(event_type);
-
-      -- Layer 2: Artifacts
-
-      CREATE TABLE review_rounds (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
-        round_number INTEGER NOT NULL,
-        verdict TEXT,
-        blocker_count INTEGER DEFAULT 0,
-        suggestion_count INTEGER DEFAULT 0,
-        should_fix_count INTEGER DEFAULT 0,
-        final_md_path TEXT,
-        parsed_at TEXT,
-        UNIQUE(session_id, round_number)
-      );
-
-      CREATE TABLE reviewer_outputs (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        round_id INTEGER NOT NULL REFERENCES review_rounds(id) ON DELETE CASCADE,
-        reviewer_type TEXT NOT NULL,
-        instance_number INTEGER NOT NULL DEFAULT 1,
-        file_path TEXT NOT NULL,
-        finding_count INTEGER DEFAULT 0,
-        parsed_at TEXT,
-        UNIQUE(round_id, reviewer_type, instance_number)
-      );
-
-      CREATE TABLE review_findings (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        reviewer_output_id INTEGER NOT NULL REFERENCES reviewer_outputs(id) ON DELETE CASCADE,
-        title TEXT NOT NULL,
-        severity TEXT NOT NULL CHECK(severity IN ('critical', 'high', 'medium', 'low', 'info')),
-        file_path TEXT,
-        line_start INTEGER,
-        line_end INTEGER,
-        summary TEXT,
-        is_blocker INTEGER NOT NULL DEFAULT 0,
-        parsed_at TEXT
-      );
-      CREATE INDEX idx_findings_severity ON review_findings(severity);
-
-      CREATE TABLE markdown_artifacts (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
-        artifact_type TEXT NOT NULL,
-        round_number INTEGER,
-        file_path TEXT NOT NULL,
-        content TEXT NOT NULL,
-        parsed_at TEXT NOT NULL DEFAULT (datetime('now')),
-        UNIQUE(session_id, artifact_type, round_number, file_path)
-      );
-
-      CREATE TABLE map_runs (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
-        run_number INTEGER NOT NULL,
-        file_count INTEGER DEFAULT 0,
-        map_md_path TEXT,
-        parsed_at TEXT,
-        UNIQUE(session_id, run_number)
-      );
-
-      CREATE TABLE map_sections (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        map_run_id INTEGER NOT NULL REFERENCES map_runs(id) ON DELETE CASCADE,
-        section_number INTEGER NOT NULL,
-        title TEXT NOT NULL,
-        description TEXT,
-        file_count INTEGER DEFAULT 0,
-        display_order INTEGER NOT NULL DEFAULT 0,
-        UNIQUE(map_run_id, section_number)
-      );
-
-      CREATE TABLE map_files (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        section_id INTEGER NOT NULL REFERENCES map_sections(id) ON DELETE CASCADE,
-        file_path TEXT NOT NULL,
-        role TEXT,
-        lines_added INTEGER DEFAULT 0,
-        lines_deleted INTEGER DEFAULT 0,
-        display_order INTEGER NOT NULL DEFAULT 0,
-        UNIQUE(section_id, file_path)
-      );
-
-      -- Layer 3: User Interaction
-
-      CREATE TABLE user_file_progress (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        map_file_id INTEGER NOT NULL REFERENCES map_files(id) ON DELETE CASCADE,
-        is_reviewed INTEGER NOT NULL DEFAULT 0,
-        reviewed_at TEXT,
-        UNIQUE(map_file_id)
-      );
-
-      CREATE TABLE user_finding_progress (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        finding_id INTEGER NOT NULL REFERENCES review_findings(id) ON DELETE CASCADE,
-        status TEXT NOT NULL DEFAULT 'unread' CHECK(status IN ('unread', 'read', 'acknowledged', 'fixed', 'wont_fix')),
-        updated_at TEXT NOT NULL DEFAULT (datetime('now')),
-        UNIQUE(finding_id)
-      );
-
-      CREATE TABLE user_notes (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        target_type TEXT NOT NULL CHECK(target_type IN ('session', 'round', 'finding', 'run', 'section', 'file')),
-        target_id TEXT NOT NULL,
-        content TEXT NOT NULL,
-        created_at TEXT NOT NULL DEFAULT (datetime('now')),
-        updated_at TEXT NOT NULL DEFAULT (datetime('now'))
-      );
-
-      CREATE TABLE command_executions (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        command TEXT NOT NULL,
-        args TEXT,
-        exit_code INTEGER,
-        started_at TEXT NOT NULL DEFAULT (datetime('now')),
-        finished_at TEXT,
-        output TEXT
-      );
-    `
-  },
-  {
-    version: 2,
-    description: "Add chat conversations, messages, and round progress tables",
-    sql: `
-      CREATE TABLE IF NOT EXISTS chat_conversations (
-        id TEXT PRIMARY KEY,
-        session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
-        target_type TEXT NOT NULL CHECK(target_type IN ('map_run', 'review_round')),
-        target_id INTEGER NOT NULL,
-        claude_session_id TEXT,
-        status TEXT NOT NULL DEFAULT 'active' CHECK(status IN ('active', 'expired')),
-        created_at TEXT NOT NULL DEFAULT (datetime('now')),
-        last_active_at TEXT NOT NULL DEFAULT (datetime('now'))
-      );
-
-      CREATE TABLE IF NOT EXISTS chat_messages (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        conversation_id TEXT NOT NULL REFERENCES chat_conversations(id) ON DELETE CASCADE,
-        role TEXT NOT NULL CHECK(role IN ('user', 'assistant')),
-        content TEXT NOT NULL,
-        created_at TEXT NOT NULL DEFAULT (datetime('now'))
-      );
-
-      CREATE TABLE IF NOT EXISTS user_round_progress (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        round_id INTEGER NOT NULL REFERENCES review_rounds(id) ON DELETE CASCADE,
-        status TEXT NOT NULL DEFAULT 'needs_review'
-          CHECK(status IN ('needs_review', 'in_progress', 'changes_made', 'acknowledged', 'dismissed')),
-        updated_at TEXT NOT NULL DEFAULT (datetime('now')),
-        UNIQUE(round_id)
-      );
-    `
-  },
-  {
-    version: 3,
-    description: "Add PID tracking to command_executions for orphan process cleanup",
-    sql: `
-      ALTER TABLE command_executions ADD COLUMN pid INTEGER;
-    `
-  },
-  {
-    version: 4,
-    description: "Add is_detached flag to command_executions for process group kill strategy",
-    sql: `
-      ALTER TABLE command_executions ADD COLUMN is_detached INTEGER NOT NULL DEFAULT 0;
-    `
-  },
-  {
-    version: 5,
-    description: "Change orchestration_events FK to RESTRICT to protect audit trail",
-    sql: `
-      CREATE TABLE orchestration_events_new (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE RESTRICT,
-        event_type TEXT NOT NULL,
-        phase TEXT,
-        phase_number INTEGER,
-        round INTEGER,
-        metadata TEXT,
-        created_at TEXT NOT NULL DEFAULT (datetime('now'))
-      );
-      INSERT INTO orchestration_events_new SELECT * FROM orchestration_events;
-      DROP TABLE orchestration_events;
-      ALTER TABLE orchestration_events_new RENAME TO orchestration_events;
-      CREATE INDEX idx_events_session ON orchestration_events(session_id);
-      CREATE INDEX idx_events_type ON orchestration_events(event_type);
-    `
-  },
-  {
-    version: 6,
-    description: "Add orchestrator-first columns to review_rounds for round-meta.json support",
-    sql: `
-      ALTER TABLE review_rounds ADD COLUMN source TEXT DEFAULT NULL;
-      ALTER TABLE review_rounds ADD COLUMN reviewer_count INTEGER DEFAULT 0;
-      ALTER TABLE review_rounds ADD COLUMN total_finding_count INTEGER DEFAULT 0;
-    `
-  },
-  {
-    version: 7,
-    description: "Add category column to review_findings for blocker/should_fix/suggestion classification",
-    sql: `
-      ALTER TABLE review_findings ADD COLUMN category TEXT DEFAULT NULL;
-    `
-  },
-  {
-    version: 8,
-    description: "Add orchestrator-first columns to map_runs for map-meta.json support",
-    sql: `
-      ALTER TABLE map_runs ADD COLUMN source TEXT DEFAULT NULL;
-      ALTER TABLE map_runs ADD COLUMN section_count INTEGER DEFAULT 0;
-    `
-  },
-  {
-    version: 9,
-    description: "Add uid column to command_executions for JSONL-backed recovery",
-    sql: `
-      ALTER TABLE command_executions ADD COLUMN uid TEXT;
-      CREATE UNIQUE INDEX idx_command_executions_uid ON command_executions(uid);
-    `
-  },
-  {
-    version: 10,
-    description: "Add agent_sessions journal for per-instance lifecycle tracking",
-    sql: `
-      CREATE TABLE agent_sessions (
-        id TEXT PRIMARY KEY,
-        workflow_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE RESTRICT,
-        vendor TEXT NOT NULL,
-        vendor_session_id TEXT,
-        persona TEXT,
-        instance_index INTEGER,
-        name TEXT,
-        resolved_model TEXT,
-        phase TEXT,
-        status TEXT NOT NULL CHECK(status IN ('spawning', 'running', 'done', 'crashed', 'cancelled', 'orphaned')),
-        pid INTEGER,
-        started_at TEXT NOT NULL DEFAULT (datetime('now')),
-        last_heartbeat_at TEXT NOT NULL DEFAULT (datetime('now')),
-        ended_at TEXT,
-        exit_code INTEGER,
-        notes TEXT
-      );
-      CREATE INDEX idx_agent_sessions_workflow ON agent_sessions(workflow_id);
-      CREATE INDEX idx_agent_sessions_status_heartbeat ON agent_sessions(status, last_heartbeat_at);
-    `
-  },
-  {
-    version: 11,
-    description: "Unify agent_sessions into command_executions \u2014 every spawned process is one execution row",
-    sql: `
-      -- Extend command_executions with the journaling fields previously on agent_sessions.
-      -- A NULL workflow_id is allowed because some commands (e.g. sync-reviewers,
-      -- create-reviewer) don't tie to a review workflow. Existing rows get NULL by default.
-      ALTER TABLE command_executions ADD COLUMN workflow_id TEXT REFERENCES sessions(id) ON DELETE RESTRICT;
-      -- parent_id = the dashboard-spawn that's the "Tech Lead" parent of an AI-spawned
-      -- session-instance row. NULL for top-level dashboard spawns.
-      ALTER TABLE command_executions ADD COLUMN parent_id INTEGER REFERENCES command_executions(id);
-      -- Vendor metadata (claude | opencode | gemini | \u2026). NULL for non-AI commands.
-      ALTER TABLE command_executions ADD COLUMN vendor TEXT;
-      -- The underlying CLI's own session id, captured from stream events.
-      -- Used for resume / handoff. Hidden from users (ocr exposes its own id only).
-      ALTER TABLE command_executions ADD COLUMN vendor_session_id TEXT;
-      -- Persona/instance metadata for AI sub-agents (set when the AI calls
-      -- ocr session start-instance). NULL for the parent dashboard spawn.
-      ALTER TABLE command_executions ADD COLUMN persona TEXT;
-      ALTER TABLE command_executions ADD COLUMN instance_index INTEGER;
-      ALTER TABLE command_executions ADD COLUMN name TEXT;
-      -- Resolved model string passed to --model post-alias-expansion.
-      ALTER TABLE command_executions ADD COLUMN resolved_model TEXT;
-      -- Liveness heartbeat. Bumped on every state event the AI emits.
-      -- Stale rows past the threshold are reclassified to orphaned (exit_code=-3).
-      ALTER TABLE command_executions ADD COLUMN last_heartbeat_at TEXT;
-      -- Free-form annotations (sweep notes, host-CLI capability warnings, etc).
-      ALTER TABLE command_executions ADD COLUMN notes TEXT;
-      CREATE INDEX idx_command_executions_workflow ON command_executions(workflow_id);
-      CREATE INDEX idx_command_executions_parent ON command_executions(parent_id);
-      CREATE INDEX idx_command_executions_heartbeat ON command_executions(last_heartbeat_at);
-
-      -- The agent_sessions table is retired. Phase 1 was a parallel journal that
-      -- this migration consolidates. We drop the table outright \u2014 the only existing
-      -- consumers are the cli helpers and tests, which are updated alongside this
-      -- migration. No production deployments have agent_sessions data worth migrating.
-      DROP INDEX IF EXISTS idx_agent_sessions_workflow;
-      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;");
-    }
-  },
-  {
-    version: 14,
-    description: "Self-heal markdown_artifacts duplication: collapse NULL-round duplicate rows and add a NULL-safe unique index so the dedup bug cannot recur",
-    // The table's `UNIQUE(session_id, artifact_type, round_number, file_path)`
-    // never deduped session-level artifacts because SQLite treats NULL ≠ NULL,
-    // and the writer used `INSERT OR REPLACE` — so every re-parse of a
-    // NULL-round artifact (context.md, map.md, …) appended a duplicate (one
-    // context.md reached 775 identical rows, ~177 MB). The writer is now an
-    // explicit UPDATE-or-INSERT; this migration heals existing DBs and adds a
-    // NULL-collapsing unique index as a DB-level backstop.
-    //
-    // Orphan-row sweep (FK-dangling children from the pre-FK-enforcement era)
-    // is intentionally NOT done here — it needs `PRAGMA foreign_keys = OFF`,
-    // which is a no-op inside the migration transaction. `ocr db doctor --fix`
-    // performs it outside a transaction.
-    run: (db) => {
-      db.run(`
-        DELETE FROM markdown_artifacts
-        WHERE rowid NOT IN (
-          SELECT MAX(rowid) FROM markdown_artifacts
-          GROUP BY session_id, artifact_type, IFNULL(round_number, -1), file_path
-        )
-      `);
-      db.run(`
-        CREATE UNIQUE INDEX IF NOT EXISTS idx_markdown_artifacts_logical
-        ON markdown_artifacts(session_id, artifact_type, IFNULL(round_number, -1), file_path)
-      `);
-    }
-  }
-];
-function columnExists(db, table, column) {
-  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 (
-      version INTEGER PRIMARY KEY,
-      applied_at TEXT NOT NULL DEFAULT (datetime('now')),
-      description TEXT NOT NULL
-    );
-  `);
-}
-function getSchemaVersion(db) {
-  ensureSchemaVersionTable(db);
-  return getCurrentVersion(db);
-}
-function getCurrentVersion(db) {
-  const result = db.exec(
-    "SELECT MAX(version) as v FROM schema_version"
-  );
-  if (result.length === 0 || result[0]?.values.length === 0) {
-    return 0;
-  }
-  const val = result[0]?.values[0]?.[0];
-  return typeof val === "number" ? val : 0;
-}
-function runMigrations(db) {
-  ensureSchemaVersionTable(db);
-  const currentVersion = getCurrentVersion(db);
-  for (const migration of MIGRATIONS) {
-    if (migration.version <= currentVersion) {
-      continue;
-    }
-    db.run("BEGIN IMMEDIATE;");
-    try {
-      if (migration.sql) db.run(migration.sql);
-      migration.run?.(db);
-      db.run(
-        "INSERT INTO schema_version (version, description) VALUES (?, ?);",
-        [migration.version, migration.description]
-      );
-      db.run("COMMIT;");
-    } catch (error) {
-      db.run("ROLLBACK;");
-      throw error;
-    }
-  }
-}
-
-// src/lib/db/reconcile.ts
-import { existsSync } from "node:fs";
-import { isAbsolute, join, dirname } from "node:path";
-
-// src/lib/db/result-mapper.ts
-function resultToRows(result) {
-  if (result.length === 0 || !result[0]) {
-    return [];
-  }
-  const { columns, values } = result[0];
-  return values.map((row) => {
-    const obj = {};
-    for (let i = 0; i < columns.length; i++) {
-      obj[columns[i]] = row[i];
-    }
-    return obj;
-  });
-}
-function resultToRow(result) {
-  const rows = resultToRows(result);
-  return rows[0];
-}
-
-// 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 getLatestActiveSession(db) {
-  return resultToRow(
-    db.exec(
-      "SELECT * FROM sessions WHERE status = 'active' ORDER BY started_at DESC LIMIT 1"
-    )
-  );
-}
-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 getEventsForSession(db, sessionId) {
-  return resultToRows(
-    db.exec(
-      "SELECT * FROM orchestration_events WHERE session_id = ? ORDER BY id ASC",
-      [sessionId]
-    )
-  );
-}
-function getLatestEventId(db) {
-  const result = db.exec(
-    "SELECT MAX(id) FROM orchestration_events"
-  );
-  if (result.length === 0 || result[0]?.values.length === 0) {
-    return 0;
-  }
-  const val = result[0]?.values[0]?.[0];
-  return typeof val === "number" ? val : 0;
-}
-function commitReasonClose(db, sessionId, reasonEvent, projectionUpdates) {
-  db.transaction(() => {
-    insertEvent(db, { session_id: sessionId, ...reasonEvent });
-    updateSession(db, sessionId, projectionUpdates);
-  });
-}
-
-// 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 join(dirname(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 ? existsSync(join(dir, "rounds", `round-${s.current_round}`, "final.md")) : false;
-      const mapFinal = s.workflow_type === "map" && dir ? existsSync(join(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 };
-}
-
-// 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();
-}
-
-// src/lib/state/exit-codes.ts
-var STATE_EXIT = {
-  OK: 0,
-  USAGE: 2,
-  AMBIGUOUS: 3,
-  NOT_FOUND: 4,
-  ILLEGAL_TRANSITION: 5,
-  INVARIANT_UNMET: 6,
-  SCHEMA_INVALID: 7,
-  /** Database was locked past the bounded retry budget (SQLITE_BUSY). */
-  BUSY: 8
-};
-var StateError = class extends Error {
-  constructor(code, message) {
-    super(message);
-    this.code = code;
-    this.name = "StateError";
-  }
-};
-var CANCELLED_EXIT_CODE = -2;
-var ORPHAN_EXIT_CODE = -3;
-var CASCADE_CLOSE_EXIT_CODE = -4;
-var WATCHDOG_DEADLINE_EXIT_CODE = -5;
-
-// 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
-    // primary key for legacy command_executions rows without a uid.
-    id: row.uid ?? String(row.id),
-    workflow_id: row.workflow_id ?? "",
-    vendor: row.vendor ?? "",
-    vendor_session_id: row.vendor_session_id,
-    persona: row.persona,
-    instance_index: row.instance_index,
-    name: row.name,
-    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,
-    ended_at: row.finished_at,
-    exit_code: row.exit_code,
-    notes: row.notes
-  };
-}
-function deriveStatus(row) {
-  if (row.finished_at === null) {
-    return "running";
-  }
-  if (row.exit_code === ORPHAN_EXIT_CODE) return "orphaned";
-  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";
-}
-function insertAgentSession(db, params) {
-  const {
-    id,
-    workflow_id,
-    vendor,
-    persona = null,
-    instance_index = null,
-    name = null,
-    resolved_model = null,
-    pid = null,
-    notes = null
-  } = params;
-  const command = persona && instance_index !== null ? `${INSTANCE_COMMAND}:${persona}-${instance_index}` : INSTANCE_COMMAND;
-  db.run(
-    `INSERT INTO command_executions
-       (uid, command, args, workflow_id, vendor, persona, instance_index, name,
-        resolved_model, pid, notes, last_heartbeat_at)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, datetime('now'))`,
-    [
-      id,
-      command,
-      null,
-      workflow_id,
-      vendor,
-      persona,
-      instance_index,
-      name,
-      resolved_model,
-      pid,
-      notes
-    ]
-  );
-}
-function getAgentSession(db, id) {
-  const row = resultToRow(
-    db.exec(
-      `SELECT * FROM command_executions WHERE uid = ? AND last_heartbeat_at IS NOT NULL`,
-      [id]
-    )
-  );
-  return row ? rowToAgentSession(row) : void 0;
-}
-function listAgentSessionsForWorkflow(db, workflowId) {
-  const rows = resultToRows(
-    db.exec(
-      `SELECT * FROM command_executions
-       WHERE workflow_id = ? AND last_heartbeat_at IS NOT NULL
-       ORDER BY started_at ASC, id ASC`,
-      [workflowId]
-    )
-  );
-  return rows.map(rowToAgentSession);
-}
-function getLatestAgentSessionWithVendorId(db, workflowId) {
-  const row = resultToRow(
-    db.exec(
-      `SELECT * FROM command_executions
-       WHERE workflow_id = ? AND vendor_session_id IS NOT NULL
-       ORDER BY started_at DESC, id DESC
-       LIMIT 1`,
-      [workflowId]
-    )
-  );
-  return row ? rowToAgentSession(row) : void 0;
-}
-function bumpAgentSessionHeartbeat(db, id) {
-  db.run(
-    `UPDATE command_executions
-       SET last_heartbeat_at = datetime('now')
-       WHERE uid = ?`,
-    [id]
-  );
-}
-function setAgentSessionVendorId(db, id, vendorSessionId) {
-  const existing = getAgentSession(db, id);
-  if (!existing) {
-    throw new Error(`Agent session not found: ${id}`);
-  }
-  if (existing.vendor_session_id && existing.vendor_session_id !== vendorSessionId) {
-    throw new Error(
-      `Agent session ${id} already bound to vendor session ${existing.vendor_session_id}; refusing to rebind to ${vendorSessionId}`
-    );
-  }
-  db.run(
-    `UPDATE command_executions
-       SET vendor_session_id = ?,
-           last_heartbeat_at = datetime('now')
-       WHERE uid = ?`,
-    [vendorSessionId, id]
-  );
-}
-function bindVendorSessionIdOpportunistically(db, vendorSessionId) {
-  const alreadyBound = resultToRow(
-    db.exec(
-      `SELECT c.uid FROM command_executions c
-       INNER JOIN sessions s ON s.id = c.workflow_id
-       WHERE c.vendor_session_id = ?
-       LIMIT 1`,
-      [vendorSessionId]
-    )
-  );
-  if (alreadyBound?.uid) return alreadyBound.uid;
-  const candidate = resultToRow(
-    db.exec(
-      `SELECT c.uid, c.id FROM command_executions c
-       INNER JOIN sessions s ON s.id = c.workflow_id
-       WHERE c.finished_at IS NULL
-         AND c.vendor_session_id IS NULL
-         AND c.last_heartbeat_at IS NOT NULL
-         AND s.status = 'active'
-       ORDER BY c.started_at DESC, c.id DESC
-       LIMIT 1`
-    )
-  );
-  if (!candidate) return null;
-  db.run(
-    `UPDATE command_executions
-       SET vendor_session_id = ?,
-           last_heartbeat_at = datetime('now')
-       WHERE id = ?`,
-    [vendorSessionId, candidate.id]
-  );
-  return candidate.uid ?? String(candidate.id);
-}
-function recordVendorSessionIdForExecution(db, executionId, vendorSessionId) {
-  db.run(
-    `UPDATE command_executions
-        SET vendor_session_id = COALESCE(vendor_session_id, ?),
-            last_heartbeat_at = datetime('now')
-      WHERE id = ?`,
-    [vendorSessionId, executionId]
-  );
-}
-function linkDashboardInvocationToWorkflow(db, dashboardUid, workflowId) {
-  db.run(
-    `UPDATE command_executions
-        SET workflow_id = COALESCE(workflow_id, ?),
-            last_heartbeat_at = COALESCE(last_heartbeat_at, datetime('now'))
-      WHERE uid = ?`,
-    [workflowId, dashboardUid]
-  );
-}
-function setAgentSessionStatus(db, id, status, options = {}) {
-  const { exitCode, note, setEndedAt } = options;
-  const isTerminal = status === "done" || status === "crashed" || status === "cancelled" || status === "orphaned";
-  const stampEnded = setEndedAt ?? isTerminal;
-  let resolvedExit;
-  if (exitCode !== void 0) {
-    resolvedExit = exitCode;
-  } else if (status === "done") {
-    resolvedExit = 0;
-  } else if (status === "cancelled") {
-    resolvedExit = CANCELLED_EXIT_CODE;
-  } else if (status === "orphaned") {
-    resolvedExit = ORPHAN_EXIT_CODE;
-  } else if (status === "crashed") {
-    resolvedExit = 1;
-  } else {
-    resolvedExit = null;
-  }
-  const finishedClause = stampEnded ? ", finished_at = datetime('now')" : "";
-  if (note !== void 0) {
-    db.run(
-      `UPDATE command_executions
-         SET exit_code = ?,
-             notes = COALESCE(notes || char(10), '') || ?
-             ${finishedClause}
-         WHERE uid = ?`,
-      [resolvedExit, note, id]
-    );
-  } else {
-    db.run(
-      `UPDATE command_executions
-         SET exit_code = ?
-             ${finishedClause}
-         WHERE uid = ?`,
-      [resolvedExit, id]
-    );
-  }
-}
-function updateAgentSession(db, id, params) {
-  const setClauses = [];
-  const values = [];
-  if (params.vendor_session_id !== void 0) {
-    setClauses.push("vendor_session_id = ?");
-    values.push(params.vendor_session_id);
-  }
-  if (params.status !== void 0) {
-    setAgentSessionStatus(db, id, params.status, {
-      exitCode: params.exit_code ?? void 0,
-      note: params.notes ?? void 0
-    });
-    return;
-  }
-  if (params.pid !== void 0) {
-    setClauses.push("pid = ?");
-    values.push(params.pid);
-  }
-  if (params.ended_at !== void 0) {
-    setClauses.push("finished_at = ?");
-    values.push(params.ended_at);
-  }
-  if (params.exit_code !== void 0) {
-    setClauses.push("exit_code = ?");
-    values.push(params.exit_code);
-  }
-  if (params.notes !== void 0) {
-    setClauses.push("notes = ?");
-    values.push(params.notes);
-  }
-  if (setClauses.length === 0) return;
-  values.push(id);
-  db.run(
-    `UPDATE command_executions SET ${setClauses.join(", ")} WHERE uid = ?`,
-    values
-  );
-}
-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 (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)`;
-  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: 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) };
-}
-
-// src/lib/db/maintenance.ts
-import {
-  existsSync as existsSync2,
-  readdirSync,
-  statSync,
-  unlinkSync,
-  copyFileSync
-} from "node:fs";
-import { dirname as dirname2, join as join2, basename } from "node:path";
-
-// ../shared/platform/src/index.ts
-import {
-  execFile,
-  execFileSync,
-  spawn
-} from "node:child_process";
-import { promisify } from "node:util";
-var execFilePromise = promisify(execFile);
-var isWindows = process.platform === "win32";
-function isProcessAlive(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (err) {
-    return !(err instanceof Error && "code" in err && err.code === "ESRCH");
-  }
-}
-
-// src/lib/db/maintenance.ts
-var PROTECTED_TABLES = /* @__PURE__ */ new Set([
-  "sessions",
-  "orchestration_events",
-  "agent_sessions",
-  "command_executions",
-  "schema_version"
-]);
-var ORPHAN_SWEEPS = [
-  // session-rooted parents first
-  {
-    table: "review_rounds",
-    sql: "DELETE FROM review_rounds WHERE session_id NOT IN (SELECT id FROM sessions)"
-  },
-  {
-    table: "map_runs",
-    sql: "DELETE FROM map_runs WHERE session_id NOT IN (SELECT id FROM sessions)"
-  },
-  {
-    table: "markdown_artifacts",
-    sql: "DELETE FROM markdown_artifacts WHERE session_id NOT IN (SELECT id FROM sessions)"
-  },
-  {
-    table: "chat_conversations",
-    sql: "DELETE FROM chat_conversations WHERE session_id NOT IN (SELECT id FROM sessions)"
-  },
-  // second level (pick up parents deleted above)
-  {
-    table: "reviewer_outputs",
-    sql: "DELETE FROM reviewer_outputs WHERE round_id NOT IN (SELECT id FROM review_rounds)"
-  },
-  {
-    table: "map_sections",
-    sql: "DELETE FROM map_sections WHERE map_run_id NOT IN (SELECT id FROM map_runs)"
-  },
-  {
-    table: "chat_messages",
-    sql: "DELETE FROM chat_messages WHERE conversation_id NOT IN (SELECT id FROM chat_conversations)"
-  },
-  {
-    table: "user_round_progress",
-    sql: "DELETE FROM user_round_progress WHERE round_id NOT IN (SELECT id FROM review_rounds)"
-  },
-  // third level
-  {
-    table: "review_findings",
-    sql: "DELETE FROM review_findings WHERE reviewer_output_id NOT IN (SELECT id FROM reviewer_outputs)"
-  },
-  {
-    table: "map_files",
-    sql: "DELETE FROM map_files WHERE section_id NOT IN (SELECT id FROM map_sections)"
-  },
-  // leaves
-  {
-    table: "user_finding_progress",
-    sql: "DELETE FROM user_finding_progress WHERE finding_id NOT IN (SELECT id FROM review_findings)"
-  },
-  {
-    table: "user_file_progress",
-    sql: "DELETE FROM user_file_progress WHERE map_file_id NOT IN (SELECT id FROM map_files)"
-  }
-];
-var MARKDOWN_DEDUP_SQL = `
-  DELETE FROM markdown_artifacts
-   WHERE rowid NOT IN (
-     SELECT MAX(rowid) FROM markdown_artifacts
-      GROUP BY session_id, artifact_type, IFNULL(round_number, -1), file_path
-   )`;
-var ONE_HOUR_MS = 60 * 60 * 1e3;
-function withForeignKeysDisabled(db, fn) {
-  db.pragma("foreign_keys = OFF");
-  try {
-    return fn();
-  } finally {
-    db.pragma("foreign_keys = ON");
-  }
-}
-function scalarInt(db, sql) {
-  const r = db.exec(sql);
-  const v = r[0]?.values[0]?.[0];
-  return typeof v === "number" ? v : Number(v ?? 0);
-}
-function foreignKeyViolationGroups(db) {
-  const r = db.exec("PRAGMA foreign_key_check");
-  const rows = r[0]?.values ?? [];
-  const counts = /* @__PURE__ */ new Map();
-  for (const row of rows) {
-    const table = String(row[0]);
-    counts.set(table, (counts.get(table) ?? 0) + 1);
-  }
-  return [...counts.entries()].map(([table, count]) => ({ table, count })).sort((a, b) => b.count - a.count);
-}
-function scanOrphanTempFiles(dataDir) {
-  let entries;
-  try {
-    entries = readdirSync(dataDir);
-  } catch {
-    return [];
-  }
-  const out = [];
-  for (const name of entries) {
-    const m = name.match(/^ocr\.db\.(\d+)\.tmp$/);
-    if (!m) continue;
-    const pid = Number(m[1]);
-    let ageMs = 0;
-    try {
-      ageMs = Date.now() - statSync(join2(dataDir, name)).mtimeMs;
-    } catch {
-      continue;
-    }
-    const alive = isProcessAlive(pid);
-    out.push({
-      name,
-      pid,
-      ageMs,
-      // Reapable only when the writer PID is dead AND the file is old enough
-      // that no live mid-write could plausibly own it.
-      reapable: !alive && ageMs > ONE_HOUR_MS
-    });
-  }
-  return out;
-}
-function scanBackupFiles(dataDir, dbBase) {
-  let entries;
-  try {
-    entries = readdirSync(dataDir);
-  } catch {
-    return [];
-  }
-  const out = [];
-  for (const name of entries) {
-    if (!name.startsWith(`${dbBase}.bak`)) continue;
-    try {
-      out.push({ name, sizeBytes: statSync(join2(dataDir, name)).size });
-    } catch {
-    }
-  }
-  return out.sort((a, b) => b.sizeBytes - a.sizeBytes);
-}
-function collectDbHealth(db, dbPath) {
-  const dataDir = dirname2(dbPath);
-  const dbBase = basename(dbPath);
-  const pageSize = scalarInt(db, "PRAGMA page_size");
-  const pageCount = scalarInt(db, "PRAGMA page_count");
-  const freelistCount = scalarInt(db, "PRAGMA freelist_count");
-  const integ = db.exec("PRAGMA integrity_check");
-  const integRows = (integ[0]?.values ?? []).map((v) => String(v[0]));
-  const integrityOk = integRows.length === 1 && integRows[0] === "ok";
-  const allGroups = foreignKeyViolationGroups(db);
-  const fkViolations = allGroups.filter((g) => !PROTECTED_TABLES.has(g.table));
-  const protectedFkViolations = allGroups.filter(
-    (g) => PROTECTED_TABLES.has(g.table)
-  );
-  const fileSizeBytes = existsSync2(dbPath) ? statSync(dbPath).size : 0;
-  return {
-    dbPath,
-    fileSizeBytes,
-    pageSize,
-    pageCount,
-    freelistCount,
-    reclaimableBytes: freelistCount * pageSize,
-    integrityOk,
-    integrityErrors: integrityOk ? [] : integRows,
-    fkViolations,
-    protectedFkViolations,
-    totalFkViolations: allGroups.reduce((n, g) => n + g.count, 0),
-    markdownDuplicateRows: scalarInt(
-      db,
-      `SELECT COALESCE(SUM(cnt - 1), 0) FROM (
-         SELECT COUNT(*) AS cnt FROM markdown_artifacts
-          GROUP BY session_id, artifact_type, IFNULL(round_number, -1), file_path
-         HAVING cnt > 1)`
-    ),
-    orphanTempFiles: scanOrphanTempFiles(dataDir),
-    backupFiles: scanBackupFiles(dataDir, dbBase),
-    eventCount: scalarInt(db, "SELECT COUNT(*) FROM orchestration_events"),
-    sessionCount: scalarInt(db, "SELECT COUNT(*) FROM sessions")
-  };
-}
-function snapshotDb(db, dbPath, label = "doctor") {
-  try {
-    if (!existsSync2(dbPath) || statSync(dbPath).size === 0) return null;
-    db.pragma("wal_checkpoint(TRUNCATE)");
-    const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-    const bakPath = `${dbPath}.bak.${label}.${ts}`;
-    copyFileSync(dbPath, bakPath);
-    return bakPath;
-  } catch {
-    return null;
-  }
-}
-function reapOrphanDbFiles(dataDir) {
-  const reaped = [];
-  for (const f of scanOrphanTempFiles(dataDir)) {
-    if (!f.reapable) continue;
-    try {
-      unlinkSync(join2(dataDir, f.name));
-      reaped.push(f.name);
-    } catch {
-    }
-  }
-  return reaped;
-}
-var SEVEN_DAYS_MS = 7 * 24 * 60 * 60 * 1e3;
-function reapStaleExecLogs(execLogsDir, maxAgeMs = SEVEN_DAYS_MS) {
-  let entries;
-  try {
-    entries = readdirSync(execLogsDir);
-  } catch {
-    return [];
-  }
-  const cutoff = Date.now() - maxAgeMs;
-  const reaped = [];
-  for (const name of entries) {
-    if (!name.endsWith(".log")) continue;
-    const full = join2(execLogsDir, name);
-    try {
-      if (statSync(full).mtimeMs > cutoff) continue;
-      unlinkSync(full);
-      reaped.push(name);
-    } catch {
-    }
-  }
-  return reaped;
-}
-function pruneBackups(dataDir, dbPath, opts = {}) {
-  const keep = opts.keep ?? 1;
-  if (!Number.isInteger(keep) || keep < 0) {
-    throw new Error(
-      `pruneBackups: keep must be a non-negative integer (got ${String(keep)})`
-    );
-  }
-  const dryRun = opts.dryRun ?? false;
-  const dbBase = basename(dbPath);
-  const withMtime = [];
-  for (const file of scanBackupFiles(dataDir, dbBase)) {
-    try {
-      withMtime.push({ file, mtimeMs: statSync(join2(dataDir, file.name)).mtimeMs });
-    } catch {
-    }
-  }
-  withMtime.sort((a, b) => b.mtimeMs - a.mtimeMs);
-  const kept = withMtime.slice(0, keep).map((x) => x.file);
-  const toDelete = withMtime.slice(keep).map((x) => x.file);
-  const deleted = [];
-  if (!dryRun) {
-    for (const b of toDelete) {
-      try {
-        unlinkSync(join2(dataDir, b.name));
-        deleted.push(b);
-      } catch {
-      }
-    }
-  }
-  const reported = dryRun ? toDelete : deleted;
-  return {
-    dryRun,
-    deleted: reported,
-    kept,
-    reclaimedBytes: reported.reduce((n, b) => n + b.sizeBytes, 0)
-  };
-}
-function fixDb(db, dbPath, opts = {}) {
-  const dataDir = dirname2(dbPath);
-  const sizeBeforeBytes = existsSync2(dbPath) ? statSync(dbPath).size : 0;
-  const snapshotPath = opts.snapshot === false ? null : snapshotDb(db, dbPath, "doctor");
-  const fkOrphansDeleted = [];
-  withForeignKeysDisabled(db, () => {
-    db.transaction(() => {
-      for (const sweep of ORPHAN_SWEEPS) {
-        const info = db.prepare(sweep.sql).run();
-        const count = Number(info.changes);
-        if (count > 0) fkOrphansDeleted.push({ table: sweep.table, count });
-      }
-    });
-  });
-  let markdownDupsDeleted = 0;
-  db.transaction(() => {
-    const info = db.prepare(MARKDOWN_DEDUP_SQL).run();
-    markdownDupsDeleted = Number(info.changes);
-  });
-  const tempsReaped = opts.reapTemps === false ? [] : reapOrphanDbFiles(dataDir);
-  let vacuumed = false;
-  if (opts.vacuum !== false) {
-    try {
-      db.pragma("wal_checkpoint(TRUNCATE)");
-      db.run("VACUUM");
-      vacuumed = true;
-    } catch {
-      vacuumed = false;
-    }
-  }
-  const post = collectDbHealth(db, dbPath);
-  return {
-    snapshotPath,
-    fkOrphansDeleted,
-    totalFkOrphansDeleted: fkOrphansDeleted.reduce((n, g) => n + g.count, 0),
-    protectedViolationsRemaining: post.protectedFkViolations,
-    markdownDupsDeleted,
-    tempsReaped,
-    vacuumed,
-    sizeBeforeBytes,
-    sizeAfterBytes: post.fileSizeBytes,
-    integrityOkAfter: post.integrityOk,
-    fkViolationsAfter: post.totalFkViolations
-  };
-}
-function vacuumDb(db, dbPath, opts = {}) {
-  const sizeBeforeBytes = existsSync2(dbPath) ? statSync(dbPath).size : 0;
-  const snapshotPath = opts.snapshot === false ? null : snapshotDb(db, dbPath, "vacuum");
-  db.pragma("wal_checkpoint(TRUNCATE)");
-  db.run("VACUUM");
-  db.pragma("wal_checkpoint(TRUNCATE)");
-  const sizeAfterBytes = existsSync2(dbPath) ? statSync(dbPath).size : 0;
-  return {
-    snapshotPath,
-    sizeBeforeBytes,
-    sizeAfterBytes,
-    reclaimedBytes: Math.max(0, sizeBeforeBytes - sizeAfterBytes)
-  };
-}
-function countSessionArtifacts(db, sessionId) {
-  const r = db.exec(
-    `SELECT
-       (SELECT COUNT(*) FROM markdown_artifacts WHERE session_id = ?) +
-       (SELECT COUNT(*) FROM review_rounds      WHERE session_id = ?) +
-       (SELECT COUNT(*) FROM reviewer_outputs ro JOIN review_rounds rr ON ro.round_id = rr.id WHERE rr.session_id = ?) +
-       (SELECT COUNT(*) FROM review_findings rf JOIN reviewer_outputs ro ON rf.reviewer_output_id = ro.id JOIN review_rounds rr ON ro.round_id = rr.id WHERE rr.session_id = ?) +
-       (SELECT COUNT(*) FROM map_runs           WHERE session_id = ?) +
-       (SELECT COUNT(*) FROM chat_conversations WHERE session_id = ?)`,
-    Array(6).fill(sessionId)
-  );
-  const v = r[0]?.values[0]?.[0];
-  return typeof v === "number" ? v : Number(v ?? 0);
-}
-function pruneDb(db, dbPath, opts = {}) {
-  const dryRun = opts.dryRun ?? false;
-  const hasBound = opts.olderThanDays !== void 0 || opts.keepSessions !== void 0;
-  if (!hasBound) {
-    return { dryRun, snapshotPath: null, prunedSessions: [], totalArtifactRows: 0 };
-  }
-  const rows = db.exec(
-    `SELECT s.id,
-            (SELECT (julianday('now') - julianday(MAX(e.created_at))) * 86400
-               FROM orchestration_events e WHERE e.session_id = s.id) AS quiet_seconds
-       FROM sessions s
-      WHERE s.status = 'closed'
-      ORDER BY quiet_seconds ASC`
-  );
-  const closed = (rows[0]?.values ?? []).map((v) => ({
-    id: String(v[0]),
-    quietSeconds: typeof v[1] === "number" ? v[1] : Number(v[1] ?? 0)
-  }));
-  const keepN = opts.keepSessions ?? 0;
-  const olderThanSeconds = opts.olderThanDays !== void 0 ? opts.olderThanDays * 86400 : null;
-  const targets = closed.filter((s, idx) => {
-    if (idx < keepN) return false;
-    if (olderThanSeconds !== null && s.quietSeconds < olderThanSeconds)
-      return false;
-    return true;
-  });
-  const prunedSessions = [];
-  for (const t of targets) {
-    const artifactRows = countSessionArtifacts(db, t.id);
-    if (artifactRows === 0) continue;
-    prunedSessions.push({ sessionId: t.id, artifactRows });
-  }
-  if (dryRun || prunedSessions.length === 0) {
-    return {
-      dryRun,
-      snapshotPath: null,
-      prunedSessions,
-      totalArtifactRows: prunedSessions.reduce((n, p) => n + p.artifactRows, 0)
-    };
-  }
-  const snapshotPath = snapshotDb(db, dbPath, "prune");
-  db.transaction(() => {
-    for (const p of prunedSessions) {
-      db.run("DELETE FROM review_rounds WHERE session_id = ?", [p.sessionId]);
-      db.run("DELETE FROM map_runs WHERE session_id = ?", [p.sessionId]);
-      db.run("DELETE FROM markdown_artifacts WHERE session_id = ?", [p.sessionId]);
-      db.run("DELETE FROM chat_conversations WHERE session_id = ?", [p.sessionId]);
-    }
-  });
-  return {
-    dryRun,
-    snapshotPath,
-    prunedSessions,
-    totalArtifactRows: prunedSessions.reduce((n, p) => n + p.artifactRows, 0)
-  };
-}
-
-// src/lib/db/command-log.ts
-import { appendFileSync, existsSync as 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";
-var MAX_LINES = 5e3;
-var KEEP_LINES = 4e3;
-var approxLineCount = -1;
-function generateCommandUid() {
-  return randomUUID();
-}
-function cacheDir(ocrDir) {
-  return join3(ocrDir, "data", CACHE_DIR);
-}
-function commandLogPath(ocrDir) {
-  return join3(cacheDir(ocrDir), FILENAME);
-}
-function appendCommandLog(ocrDir, entry) {
-  try {
-    const filePath = commandLogPath(ocrDir);
-    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++;
-    rotateIfNeeded(filePath);
-  } catch {
-  }
-}
-function readCommandLog(ocrDir) {
-  const filePath = commandLogPath(ocrDir);
-  if (!existsSync3(filePath)) return [];
-  const content = readFileSync(filePath, "utf-8");
-  const entries = [];
-  for (const line of content.split("\n")) {
-    if (!line.trim()) continue;
-    try {
-      entries.push(JSON.parse(line));
-    } catch {
-    }
-  }
-  return entries;
-}
-function replayCommandLog(db, ocrDir) {
-  const entries = readCommandLog(ocrDir);
-  if (entries.length === 0) return 0;
-  const latest = /* @__PURE__ */ new Map();
-  for (const entry of entries) {
-    if (!entry.uid || !entry.command || !entry.started_at) continue;
-    const existing = latest.get(entry.uid);
-    if (!existing || entry.event !== "start") {
-      latest.set(entry.uid, entry);
-    }
-  }
-  let imported = 0;
-  for (const entry of latest.values()) {
-    if (entry.event === "start" && !entry.finished_at) continue;
-    const existing = db.exec(
-      "SELECT COUNT(*) as c FROM command_executions WHERE uid = ?",
-      [entry.uid]
-    );
-    if ((existing[0]?.values[0]?.[0] ?? 0) > 0) continue;
-    db.run(
-      `INSERT INTO command_executions
-         (uid, command, args, exit_code, started_at, finished_at, pid, is_detached)
-       VALUES (?, ?, ?, ?, ?, ?, NULL, ?)`,
-      [
-        entry.uid,
-        entry.command,
-        entry.args,
-        entry.exit_code,
-        entry.started_at,
-        entry.finished_at,
-        entry.is_detached
-      ]
-    );
-    imported++;
-  }
-  return imported;
-}
-function rotateIfNeeded(filePath) {
-  try {
-    if (approxLineCount >= 0 && approxLineCount <= MAX_LINES) return;
-    const content = readFileSync(filePath, "utf-8");
-    const lines = content.split("\n").filter((l) => l.trim());
-    approxLineCount = lines.length;
-    if (approxLineCount <= MAX_LINES) return;
-    const kept = lines.slice(lines.length - KEEP_LINES);
-    const tmpPath = `${filePath}.${process.pid}.tmp`;
-    writeFileSync(tmpPath, kept.join("\n") + "\n", { encoding: "utf-8" });
-    renameSync(tmpPath, filePath);
-    approxLineCount = KEEP_LINES;
-  } catch {
-  }
-}
-
-// src/lib/db/index.ts
-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) || statSync2(dbPath).size === 0) return null;
-    db.pragma("wal_checkpoint(TRUNCATE)");
-    copyFileSync2(dbPath, bakPath);
-    return bakPath;
-  } catch {
-    return null;
-  }
-}
-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");
-}
-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 getDb(ocrDir) {
-  const dbPath = join4(ocrDir, "data", "ocr.db");
-  return openDatabase(dbPath);
-}
-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 {
-    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 {
-    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);
-  }
-}
-function closeAllDatabases() {
-  for (const [path, db] of connections) {
-    db.close();
-    connections.delete(path);
-  }
-}
-function probeWrite() {
-  let dir;
-  try {
-    dir = mkdtempSync(join4(tmpdir(), "ocr-probe-"));
-    const db = openEngine(join4(dir, "probe.db"));
-    try {
-      db.run("CREATE TABLE _probe_write (id INTEGER PRIMARY KEY, v TEXT)");
-      db.transaction(() => {
-        db.run("INSERT INTO _probe_write (v) VALUES (?)", ["written-in-txn"]);
-      });
-      const value = db.exec("SELECT v FROM _probe_write")[0]?.values[0]?.[0];
-      if (value !== "written-in-txn") {
-        return { ok: false, error: `unexpected probe value: ${String(value)}` };
-      }
-      return { ok: true };
-    } finally {
-      db.close();
-    }
-  } catch (e) {
-    return { ok: false, error: e instanceof Error ? e.message : String(e) };
-  } finally {
-    if (dir) rmDirBestEffort(dir);
-  }
-}
-function rmDirBestEffort(dir) {
-  for (let attempt = 0; attempt < 3; attempt++) {
-    try {
-      rmSync(dir, { recursive: true, force: true });
-      return;
-    } catch {
-      if (attempt === 2) return;
-      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 10);
-    }
-  }
-}
-export {
-  CANCELLED_EXIT_CODE,
-  CASCADE_CLOSE_EXIT_CODE,
-  MIGRATIONS,
-  ORPHAN_EXIT_CODE,
-  PID_REUSE_GUARD_MS,
-  STATE_EXIT,
-  StateError,
-  WATCHDOG_DEADLINE_EXIT_CODE,
-  appendCommandLog,
-  bindVendorSessionIdOpportunistically,
-  bumpAgentSessionHeartbeat,
-  cacheDir,
-  cascadeTerminateExecutions,
-  closeAllDatabases,
-  closeDatabase,
-  collectDbHealth,
-  commandLogPath,
-  commitReasonClose,
-  defaultIsAlive,
-  ensureDatabase,
-  fixDb,
-  formatUpgradeNotice,
-  generateCommandUid,
-  getAgentSession,
-  getAllSessions,
-  getDb,
-  getEventsForSession,
-  getLatestActiveSession,
-  getLatestAgentSessionWithVendorId,
-  getLatestEventId,
-  getSchemaVersion,
-  getSession,
-  hasInFlightDependents,
-  insertAgentSession,
-  insertEvent,
-  insertSession,
-  isBusyError,
-  linkDashboardInvocationToWorkflow,
-  listAgentSessionsForWorkflow,
-  openDatabase,
-  probeEngine,
-  probeWrite,
-  pruneBackups,
-  pruneDb,
-  readCommandLog,
-  reapOrphanDbFiles,
-  reapStaleExecLogs,
-  reconcileLegacyState,
-  recordVendorSessionIdForExecution,
-  replayCommandLog,
-  resultToRow,
-  resultToRows,
-  rowKind,
-  runMigrations,
-  setAgentSessionStatus,
-  setAgentSessionVendorId,
-  snapshotDb,
-  sqliteUtcMs,
-  sweepStaleAgentSessions,
-  sweepStaleSessions,
-  updateAgentSession,
-  updateSession,
-  vacuumDb,
-  walCheckpointTruncate,
-  withForeignKeysDisabled
-};