chainlesschain 0.162.149 → 0.162.151

package/src/lib/async-hook-supervisor.cjs

@@ -23,9 +23,10 @@
  *     flight — a rapid PostToolUse hook can't stack N copies of itself;
  *   - a maxConcurrent cap — overflow is DROPPED with a recorded skip, never
  *     queued unbounded;
- *   - a per-hook timeout that kills the child;
- *   - reaping of every child on stopAll() / process 'exit', so a session never
- *     leaves an orphan hook process.
+ *   - a per-hook timeout that TREE-kills the child (shell + the real command it
+ *     spawned — a bare child.kill would orphan the grandchild);
+ *   - tree-reaping of every child on stopAll() / process 'exit', so a session
+ *     never leaves an orphan hook process.
  *
  * `_deps.spawn` / `_deps.now` are injected so the whole supervisor is unit-
  * testable with fake child processes (no real shell).
@@ -37,6 +38,12 @@ const { tryParseDecision } = require("./hook-runner.cjs");
 const DEFAULT_TIMEOUT_MS = 60000;
 const MAX_TIMEOUT_MS = 600000;
 const DEFAULT_MAX_CONCURRENT = 4;
+// Ring cap on undrained records (parity with PluginMonitorSupervisor's
+// OUTPUT_RING): drainResults()/drainRewakes() normally clear each turn, but a
+// stalled/absent drain over a high-frequency hook would otherwise grow these
+// arrays without bound. Keep only the most recent RESULT_RING; older records
+// are dropped oldest-first.
+const RESULT_RING = 500;
 
 class AsyncHookSupervisor {
   constructor(opts = {}) {
@@ -46,20 +53,87 @@ class AsyncHookSupervisor {
         : DEFAULT_MAX_CONCURRENT;
     this._deps = {
       spawn: opts.spawn || cpDefault.spawn,
+      spawnSync: opts.spawnSync || cpDefault.spawnSync,
       now: opts.now || (() => Date.now()),
     };
     this._running = new Map(); // key -> { child, timer }
     this._results = []; // completed records awaiting drainResults()
     this._rewakes = []; // failed asyncRewake records awaiting drainRewakes()
     this._stopped = false;
+    // The exit reaper is installed LAZILY (on first spawn), not in the ctor:
+    // a supervisor that never dispatches a hook (or the many built in tests)
+    // must not leave a permanent `process.once('exit')` listener behind —
+    // that accumulates across sessions/instances into a MaxListenersExceeded
+    // leak. Mirrors PluginMonitorSupervisor._installExitHook.
     this._exitHook = () => this.stopAll();
-    process.once("exit", this._exitHook);
+    this._exitHookInstalled = false;
   }
 
   _key(hook) {
     return `${hook.event || ""}::${hook.command}`;
   }
 
+  /**
+   * Kill a hook child's WHOLE process tree. Hooks run with `shell: true`, so the
+   * real command is a grandchild of the shell — a plain `child.kill()` only
+   * signals the shell (POSIX: reparents + keeps the command running; Windows:
+   * killing cmd.exe never touches its children), orphaning the actual hook
+   * process. POSIX: the child is spawned detached (its own group), so a negative
+   * pid signals the whole group. Windows: `taskkill /T` walks the tree. Both are
+   * SYNCHRONOUS (spawnSync / process.kill) so this is safe inside stopAll() and
+   * the process 'exit' reaper, where async work would be cut off. A child with no
+   * real pid (the unit-test fakes) falls back to its own `.kill()`.
+   */
+  _killChildTree(child, signal = "SIGTERM") {
+    if (!child) return;
+    const pid = child.pid;
+    if (typeof pid !== "number" || pid <= 0) {
+      try {
+        child.kill(signal);
+      } catch {
+        /* already gone / fake with no kill */
+      }
+      return;
+    }
+    try {
+      if (process.platform === "win32") {
+        const r = this._deps.spawnSync(
+          "taskkill",
+          ["/pid", String(pid), "/T", "/F"],
+          { windowsHide: true },
+        );
+        // If taskkill couldn't launch, fall back to a direct kill.
+        if (r && r.error) child.kill(signal);
+      } else {
+        // Negative pid → the whole process group (requires the detached spawn).
+        try {
+          process.kill(-pid, signal);
+        } catch {
+          child.kill(signal);
+        }
+      }
+    } catch {
+      try {
+        child.kill(signal);
+      } catch {
+        /* already gone */
+      }
+    }
+  }
+
+  /** Install the process-exit reaper exactly once, only when a child exists. */
+  _installExitHook() {
+    if (this._exitHookInstalled) return;
+    this._exitHookInstalled = true;
+    process.once("exit", this._exitHook);
+  }
+
+  /** Append a result record, bounded to the most recent RESULT_RING. */
+  _pushResult(rec) {
+    this._results.push(rec);
+    if (this._results.length > RESULT_RING) this._results.shift();
+  }
+
   /**
    * Dispatch a batch of async hooks fire-and-forget. Returns IMMEDIATELY with a
    * per-hook disposition (`{command, dispatched, reason?}`) — it never awaits a
@@ -100,7 +174,7 @@ class AsyncHookSupervisor {
         });
         // Record the skip so the caller/agent can SEE that a hook was dropped
         // (silent truncation would read as "the hook ran and said nothing").
-        this._results.push({
+        this._pushResult({
           command: hook.command,
           event: hook.event || null,
           ok: false,
@@ -121,6 +195,9 @@ class AsyncHookSupervisor {
   }
 
   _spawnOne(hook, payload, opts) {
+    // A live child now exists — arm the exit reaper so a session never leaves
+    // an orphan hook process (installed once, only from here).
+    this._installExitHook();
     const key = this._key(hook);
     const started = this._deps.now();
     const rawTimeout = Number(
@@ -136,6 +213,10 @@ class AsyncHookSupervisor {
       child = this._deps.spawn(hook.command, {
         cwd: opts.cwd || process.cwd(),
         shell: true,
+        // POSIX: own process group so a timeout / stopAll can signal the whole
+        // tree (shell + the real hook command), not just the shell wrapper.
+        // No-op on Windows, where the tree is reaped via `taskkill /T` instead.
+        detached: process.platform !== "win32",
         env: {
           ...process.env,
           CLAUDE_HOOK_EVENT: hook.event || payload.hook_event_name || "",
@@ -158,6 +239,13 @@ class AsyncHookSupervisor {
     this._running.set(key, rec);
 
     try {
+      // `.end(data)` flushes ASYNCHRONOUSLY: if the hook exited before consuming
+      // stdin (a fast command), the write fails with an async EPIPE emitted as an
+      // 'error' event on the stream — NOT a sync throw this catch can see. With no
+      // listener that becomes an uncaught exception that crashes the process (seen
+      // on Linux CI). Attach a no-op error handler first so a closed-stdin write
+      // is swallowed as the non-fatal condition it is.
+      child.stdin?.on("error", () => {});
       child.stdin?.end(JSON.stringify(payload));
     } catch {
       /* stdin may already be closed — non-fatal */
@@ -171,11 +259,9 @@ class AsyncHookSupervisor {
 
     const timer = setTimeout(() => {
       killedByTimeout = true;
-      try {
-        child.kill("SIGTERM");
-      } catch {
-        /* already gone */
-      }
+      // Tree-kill: a hook that spawned a subprocess (e.g. `npm test`) must not
+      // leave that subprocess orphaned when it exceeds its timeout.
+      this._killChildTree(child, "SIGTERM");
     }, timeout);
     if (typeof timer.unref === "function") timer.unref();
     rec.timer = timer;
@@ -240,11 +326,12 @@ class AsyncHookSupervisor {
       ts: now,
       ms: fields.started != null ? now - fields.started : 0,
     };
-    this._results.push(rec);
+    this._pushResult(rec);
     // A rewake fires only for a hook that OPTED IN and finished in a failure
     // state — a passing async check should not re-engage the agent.
     if (hook.asyncRewake && !rec.ok) {
       this._rewakes.push(rec);
+      if (this._rewakes.length > RESULT_RING) this._rewakes.shift();
     }
   }
 
@@ -283,11 +370,9 @@ class AsyncHookSupervisor {
       } catch {
         /* ignore */
       }
-      try {
-        rec.child.kill("SIGTERM");
-      } catch {
-        /* already gone */
-      }
+      // Tree-kill (not a bare child.kill) so a session end / process exit never
+      // leaves an orphaned hook subprocess — the guarantee this class documents.
+      this._killChildTree(rec.child, "SIGTERM");
       this._running.delete(key);
     }
     try {
@@ -295,6 +380,7 @@ class AsyncHookSupervisor {
     } catch {
       /* ignore */
     }
+    this._exitHookInstalled = false;
   }
 }
 

package/src/lib/audit-logger.js

@@ -5,6 +5,7 @@
 
 import crypto from "crypto";
 import { safeJsonParse } from "./safe-json.js";
+import { escapeLike } from "./sql-like.js";
 
 /**
  * Event types for audit logging.
@@ -183,13 +184,13 @@ export function queryLogs(db, filters = {}) {
   }
 
   if (filters.operation) {
-    sql += " AND operation LIKE ?";
-    params.push(`%${filters.operation}%`);
+    sql += " AND operation LIKE ? ESCAPE '\\'";
+    params.push(`%${escapeLike(filters.operation)}%`);
   }
 
   if (filters.actor) {
-    sql += " AND actor LIKE ?";
-    params.push(`%${filters.actor}%`);
+    sql += " AND actor LIKE ? ESCAPE '\\'";
+    params.push(`%${escapeLike(filters.actor)}%`);
   }
 
   if (filters.riskLevel) {
@@ -214,8 +215,8 @@ export function queryLogs(db, filters = {}) {
 
   if (filters.search) {
     // Search in operation field (primary search field for CLI)
-    sql += " AND operation LIKE ?";
-    params.push(`%${filters.search}%`);
+    sql += " AND operation LIKE ? ESCAPE '\\'";
+    params.push(`%${escapeLike(filters.search)}%`);
   }
 
   sql += " ORDER BY created_at DESC";

package/src/lib/autonomous-developer.js

@@ -151,6 +151,66 @@ export function ensureAutonomousDevTables(db) {
   );
 }
 
+/**
+ * Rehydrate _sessions/_adrs from the persisted dev_sessions/
+ * architecture_decisions tables. The `cc` CLI runs every command in a fresh
+ * process, so without this the Maps start empty and a session/ADR created in a
+ * prior invocation is invisible (`cc dev list`/`show`/`adrs` show nothing) and
+ * every mutation — recordADR, advancePhase, etc. — throws "Session not found"
+ * against the empty Map. Call after ensureAutonomousDevTables(db).
+ */
+export function loadFromDb(db) {
+  if (!db) return 0;
+  _sessions.clear();
+  _adrs.clear();
+
+  const parse = (v, fallback) => {
+    if (v == null) return fallback;
+    try {
+      return JSON.parse(v);
+    } catch {
+      return fallback;
+    }
+  };
+
+  const sessionRows = db.prepare(`SELECT * FROM dev_sessions`).all();
+  for (const row of sessionRows) {
+    _sessions.set(row.session_id, {
+      sessionId: row.session_id,
+      requirement: row.requirement,
+      currentPhase: row.current_phase,
+      status: row.status,
+      autonomyLevel: row.autonomy_level ?? 2,
+      codeChanges: parse(row.code_changes, []),
+      testResults: parse(row.test_results, null),
+      reviewFeedback: parse(row.review_feedback, null),
+      startedAt: row.started_at,
+      completedAt: row.completed_at ?? null,
+      createdBy: row.created_by ?? null,
+      updatedAt: row.updated_at,
+      _seq: ++_seq,
+    });
+  }
+
+  const adrRows = db.prepare(`SELECT * FROM architecture_decisions`).all();
+  for (const row of adrRows) {
+    _adrs.set(row.adr_id, {
+      adrId: row.adr_id,
+      sessionId: row.session_id,
+      title: row.title,
+      context: row.context,
+      decision: row.decision,
+      consequences: row.consequences ?? "",
+      alternatives: parse(row.alternatives, []),
+      status: row.status,
+      createdAt: row.created_at,
+      _seq: ++_seq,
+    });
+  }
+
+  return _sessions.size + _adrs.size;
+}
+
 /* ── Catalogs ──────────────────────────────────────────────── */
 
 export function listAutonomyLevels() {

package/src/lib/changelog.js

@@ -0,0 +1,252 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+/**
+ * The `cc changelog` data source.
+ *
+ * The canonical update record is the repository-root `CHANGELOG.md`, which is
+ * organized by PRODUCT version (`## [v5.0.3.x]`). Each block references the CLI
+ * npm version (`chainlesschain 0.162.x`) it shipped. This parser distills that
+ * into a CLI-focused view: it keeps only blocks that actually reference a CLI
+ * npm version, and within each block keeps only the CLI-relevant sub-sections.
+ *
+ * At publish time `scripts/build-changelog.mjs` runs `parseChangelog` over the
+ * root CHANGELOG and writes the result to `src/data/changelog.json`, which is
+ * bundled with the npm package. `loadChangelog()` reads that file (with a
+ * fallback to parsing a raw CHANGELOG.md for in-repo dev use).
+ */
+
+// Signals that a `### ` sub-section HEADING is about the CLI npm package rather
+// than the desktop app / Android / iOS / PDH portions of the same product
+// release. CASE-SENSITIVE on purpose: real CLI notes write the acronym "CLI"
+// (e.g. "cc CLI 0.162.150", "CLI 安全"), whereas PDH/Android bundle-roll notes
+// write the version tag lowercase ("(pdh 0.4.6 / cli 0.162.48)"). Matching only
+// uppercase "CLI" keeps collector releases that merely bundle a cli bump out of
+// the CLI view. Heading-only (not body) for the same reason.
+const CLI_HEADING_SIGNAL = /\bCLI\b|命令行/;
+
+// A block with no `### ` sub-sections is a CLI release only if its header or
+// preamble uses CLI-publish language. Same case-sensitivity: a lowercase
+// bundle-roll "cli 0.162.x" mention is not enough.
+const CLI_PUBLISH_SIGNAL = /\bCLI\b|命令行|catch-up/;
+
+// CLI npm versions are 3-segment (0.162.x). The `(?<![\d.])` / `(?!\.\d)` guards
+// stop a 4-segment PRODUCT version (v5.0.3.134) from matching as "5.0.3".
+const V = "(?<![\\d.])(\\d+\\.\\d+\\.\\d+)(?!\\.\\d)";
+
+/**
+ * Extract every CLI npm version token referenced in a block of text and return
+ * the "primary" one (the highest semver — the released target in a
+ * `0.162.149 → 0.162.150` style note).
+ *
+ * @param {string} text
+ * @returns {{ primary: string|null, all: string[] }}
+ */
+export function extractCliVersions(text) {
+  const found = new Set();
+  const patterns = [
+    // "cc CLI 0.162.150", "CLI 0.162.150"
+    new RegExp(`(?:cc\\s+)?cli\\s+${V}`, "gi"),
+    // "chainlesschain` 0.162.149 → **0.162.150**" (capture the arrow target)
+    new RegExp(
+      `chainlesschain[\`\\s]+(?:\\d+\\.\\d+\\.\\d+\\s*(?:→|->)\\s*)?\\*{0,2}${V}`,
+      "gi",
+    ),
+    // bare "cli 0.162.71" inside "(pdh 0.4.25 / cli 0.162.71)"
+    new RegExp(`\\bcli\\s+${V}`, "gi"),
+    // "→ 0.162.150" / "→ **0.162.150**"
+    new RegExp(`(?:→|->)\\s*\\*{0,2}${V}`, "gi"),
+  ];
+  for (const re of patterns) {
+    let m;
+    while ((m = re.exec(text)) !== null) {
+      found.add(m[1]);
+    }
+  }
+  // The CLI npm package (`chainlesschain`) is on the 0.x alpha track; the
+  // product line is 5.x. Keeping only major-0 tokens discards any product
+  // version (v5.0.3.x) or desktop-app-vue (5.0.3-alpha.x) tokens that slip past
+  // the context regexes, so the "primary" is always a real CLI npm version.
+  const all = [...found].filter((v) => v.startsWith("0."));
+  const primary =
+    all.length === 0
+      ? null
+      : all.reduce(
+          (best, v) => (compareSemver(v, best) > 0 ? v : best),
+          all[0],
+        );
+  return { primary, all };
+}
+
+/** Numeric semver compare for plain X.Y.Z (no prerelease). */
+export function compareSemver(a, b) {
+  const pa = a.split(".").map(Number);
+  const pb = b.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    if ((pa[i] || 0) !== (pb[i] || 0)) return (pa[i] || 0) - (pb[i] || 0);
+  }
+  return 0;
+}
+
+/**
+ * Parse a raw CHANGELOG.md string into CLI-focused release entries.
+ *
+ * @param {string} md
+ * @returns {Array<{
+ *   productVersion: string,
+ *   cliVersion: string|null,
+ *   cliVersions: string[],
+ *   date: string|null,
+ *   title: string,
+ *   sections: Array<{ heading: string, body: string }>,
+ * }>}
+ */
+export function parseChangelog(md) {
+  const lines = md.split(/\r?\n/);
+  const blocks = [];
+  let current = null;
+
+  for (const line of lines) {
+    const h2 = line.match(/^##\s+(.+)$/);
+    if (h2 && !line.startsWith("###")) {
+      if (current) blocks.push(current);
+      current = { header: h2[1].trim(), lines: [] };
+      continue;
+    }
+    if (current) current.lines.push(line);
+  }
+  if (current) blocks.push(current);
+
+  const releases = [];
+  for (const block of blocks) {
+    const parsed = parseBlockHeader(block.header);
+    const bodyText = block.lines.join("\n");
+    const fullText = block.header + "\n" + bodyText;
+
+    const { primary, all } = extractCliVersions(fullText);
+    // A release must reference a CLI npm version at all.
+    if (!primary) continue;
+
+    // CLI-relevance gate is decided by section HEADINGS (or, for a section-less
+    // block, by CLI-publish language) — not by a bare bundled-cli mention.
+    const sections = extractCliSections(block.lines, block.header);
+    if (!sections) continue;
+
+    releases.push({
+      productVersion: parsed.version,
+      cliVersion: primary,
+      cliVersions: all.sort(compareSemver),
+      date: parsed.date,
+      title: parsed.title,
+      sections,
+    });
+  }
+  return releases;
+}
+
+/** Parse "## [v5.0.3.134] - 2026-07-03 — title" into parts. */
+function parseBlockHeader(header) {
+  const tag = header.match(/\[([^\]]+)\]/);
+  const version = tag ? tag[1] : header;
+  const rest = header.replace(/\[[^\]]+\]\s*/, "");
+  const dateMatch = rest.match(/(\d{4}-\d{2}-\d{2})/);
+  const date = dateMatch ? dateMatch[1] : null;
+  // Title = text after the em dash separator, else whatever remains.
+  let title = "";
+  const emDash = rest.split(/\s+—\s+/);
+  if (emDash.length > 1) {
+    title = emDash.slice(1).join(" — ").trim();
+  } else {
+    title = rest
+      .replace(/^-\s*/, "")
+      .replace(/\d{4}-\d{2}-\d{2}/, "")
+      .trim();
+  }
+  return { version, date, title };
+}
+
+/**
+ * Split a block body into `### ` sub-sections and keep only CLI-relevant ones.
+ *
+ * Returns:
+ *  - an array of CLI sections, when the block is a CLI release; or
+ *  - `null`, when the block is NOT a CLI release (all-non-CLI sub-sections, e.g.
+ *    a PDH/Android collector release that merely bundles a new cli version).
+ *
+ * @param {string[]} bodyLines
+ * @param {string} header
+ * @returns {Array<{heading:string, body:string}>|null}
+ */
+function extractCliSections(bodyLines, header) {
+  const sections = [];
+  const preamble = [];
+  let cur = null;
+  for (const line of bodyLines) {
+    const h3 = line.match(/^###\s+(.+)$/);
+    if (h3) {
+      if (cur) sections.push(cur);
+      cur = { heading: h3[1].trim(), lines: [] };
+      continue;
+    }
+    if (cur) cur.lines.push(line);
+    else preamble.push(line); // before the first ### (blockquote summary etc.)
+  }
+  if (cur) sections.push(cur);
+
+  if (sections.length === 0) {
+    // Section-less block: CLI release only if the `##` TITLE names the CLI.
+    // The preamble is NOT consulted — every block carries a boilerplate
+    // "Version surfaces: CLI 0.162.x → ..." line, so a body match would let
+    // every PDH/Android release through.
+    if (!CLI_PUBLISH_SIGNAL.test(header)) return null;
+    const body = preamble.join("\n").trim();
+    return body ? [{ heading: "", body }] : [];
+  }
+
+  const cliSections = sections
+    .filter((s) => CLI_HEADING_SIGNAL.test(s.heading))
+    .map((s) => ({ heading: s.heading, body: s.lines.join("\n").trim() }));
+
+  // Has `### ` sections but none are CLI-headed → not a CLI release.
+  return cliSections.length > 0 ? cliSections : null;
+}
+
+/**
+ * Resolve and load the CLI changelog data.
+ *
+ * Order is CHANGELOG-FIRST so the data can never go stale: when the repo-root
+ * CHANGELOG.md is reachable (source checkout / dev / this monorepo) it is parsed
+ * live, always reflecting the latest edits. The bundled `src/data/changelog.json`
+ * (a build artifact, refreshed at `prepublishOnly`) is only the fallback for an
+ * installed npm package, where CHANGELOG.md is not shipped.
+ *
+ * @returns {{ source: string, releases: Array }}
+ */
+export function loadChangelog() {
+  const changelogCandidates = [
+    path.join(__dirname, "..", "..", "CHANGELOG.md"), // packages/cli/CHANGELOG.md
+    path.join(__dirname, "..", "..", "..", "..", "CHANGELOG.md"), // repo root
+  ];
+  for (const p of changelogCandidates) {
+    if (fs.existsSync(p)) {
+      return {
+        source: "CHANGELOG.md",
+        releases: parseChangelog(fs.readFileSync(p, "utf-8")),
+      };
+    }
+  }
+  // Installed npm package: CHANGELOG.md isn't shipped, use the bundled artifact.
+  const jsonPath = path.join(__dirname, "..", "data", "changelog.json");
+  if (fs.existsSync(jsonPath)) {
+    try {
+      const data = JSON.parse(fs.readFileSync(jsonPath, "utf-8"));
+      if (Array.isArray(data.releases)) return data;
+    } catch {
+      /* fall through to empty */
+    }
+  }
+  return { source: null, releases: [] };
+}

package/src/lib/chat-core.js

@@ -134,6 +134,11 @@ export async function streamOllama(
   const reader = response.body.getReader();
   const decoder = new TextDecoder();
   let fullResponse = "";
+  // Buffer incomplete lines across reads: an NDJSON line can be split across two
+  // stream chunks (TCP doesn't align to '\n'), so parsing each chunk in
+  // isolation would drop the split line entirely (both halves fail JSON.parse).
+  // Keep the trailing partial for the next read — same pattern as streamAnthropic.
+  let buf = "";
 
   try {
     while (true) {
@@ -141,10 +146,12 @@ export async function streamOllama(
       if (done) break;
       guard.bump();
 
-      const text = decoder.decode(value, { stream: true });
-      const lines = text.split("\n").filter(Boolean);
+      buf += decoder.decode(value, { stream: true });
+      const lines = buf.split("\n");
+      buf = lines.pop() || "";
 
       for (const line of lines) {
+        if (!line) continue;
         try {
           const json = JSON.parse(line);
           if (json.message?.content) {
@@ -225,6 +232,11 @@ export async function streamOpenAI(
   const reader = response.body.getReader();
   const decoder = new TextDecoder();
   let fullResponse = "";
+  // Buffer incomplete lines across reads: an SSE `data:` line can be split
+  // across two stream chunks, so parsing each chunk in isolation would drop the
+  // split line (both halves fail JSON.parse) — losing content and usage. Keep
+  // the trailing partial for the next read — same pattern as streamAnthropic.
+  let buf = "";
 
   try {
     while (true) {
@@ -232,8 +244,9 @@ export async function streamOpenAI(
       if (done) break;
       guard.bump();
 
-      const text = decoder.decode(value, { stream: true });
-      const lines = text.split("\n").filter(Boolean);
+      buf += decoder.decode(value, { stream: true });
+      const lines = buf.split("\n");
+      buf = lines.pop() || "";
 
       for (const line of lines) {
         if (line.startsWith("data: ")) {

package/src/lib/collaboration-governance.js

@@ -129,6 +129,62 @@ export function ensureGovernanceTables(db) {
   );
 }
 
+/**
+ * Rehydrate _decisions/_agentLevels from the persisted governance_decisions/
+ * autonomy_levels tables. The `cc` CLI runs every command in a fresh process, so
+ * without this the Maps start empty and a decision/level set in a prior
+ * invocation is invisible (`cc collab decisions`/`show`/`agents` show nothing),
+ * decision voting throws "not found", and setAutonomyLevel on a cold Map takes
+ * the INSERT branch on an already-persisted agent_id → PRIMARY KEY conflict.
+ * Call after ensureGovernanceTables(db).
+ */
+export function loadFromDb(db) {
+  if (!db) return 0;
+  _decisions.clear();
+  _agentLevels.clear();
+
+  const parse = (v, fallback) => {
+    if (v == null) return fallback;
+    try {
+      return JSON.parse(v);
+    } catch {
+      return fallback;
+    }
+  };
+
+  const decisionRows = db.prepare(`SELECT * FROM governance_decisions`).all();
+  for (const row of decisionRows) {
+    _decisions.set(row.decision_id, {
+      decisionId: row.decision_id,
+      type: row.type,
+      proposal: row.proposal,
+      status: row.status,
+      votes: parse(row.votes, {}),
+      resolution: row.resolution ?? null,
+      executedAt: row.executed_at ?? null,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at,
+      _seq: ++_seq,
+    });
+  }
+
+  const levelRows = db.prepare(`SELECT * FROM autonomy_levels`).all();
+  for (const row of levelRows) {
+    _agentLevels.set(row.agent_id, {
+      agentId: row.agent_id,
+      currentLevel: row.current_level,
+      permissions: parse(row.permissions, []),
+      adjustmentHistory: parse(row.adjustment_history, []),
+      lastReviewAt: row.last_review_at ?? null,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at,
+      _seq: ++_seq,
+    });
+  }
+
+  return _decisions.size + _agentLevels.size;
+}
+
 /* ── Catalogs ──────────────────────────────────────────────── */
 
 export function listDecisionTypes() {