chainlesschain 0.162.148 → 0.162.150

package/src/commands/agent.js

@@ -177,6 +177,23 @@ export function registerAgentCommand(program) {
       "Run shell commands in an ephemeral Docker sandbox (network disabled by default)",
     )
     .option("--sandbox-network", "Allow network access inside --sandbox")
+    .option(
+      "--otlp <file>",
+      "Write the agent run's OpenTelemetry spans (model/tool/retry) as OTLP/JSON to <file>",
+    )
+    .option(
+      "--auto-rewake",
+      "When an async `asyncRewake` hook (e.g. a background test) fails at turn end, re-engage the agent to fix it (bounded by --max-rewakes)",
+    )
+    .option(
+      "--auto-pin",
+      "During auto-compaction, pin the original task (first user turn) so it always survives compaction (off by default)",
+    )
+    .option(
+      "--max-rewakes <n>",
+      "Max auto-rewake re-drives per run (default 1); implies --auto-rewake",
+      (v) => parseInt(v, 10),
+    )
     .option(
       "--bg, --background",
       "Start as a detached background agent and return its id immediately",
@@ -252,7 +269,7 @@ export function registerAgentCommand(program) {
     )
     .option(
       "--fallback-model <model>",
-      "Backup model(s) to try in order when the primary fails (transient error or model-not-found). Repeatable or comma-separated; up to 3. Defaults to config llm.fallbackModels. claude-code parity.",
+      "Backup model(s) to try in order when the primary fails (transient error or model-not-found). Repeatable or comma-separated; up to 3. A `provider:model` entry (e.g. openai:gpt-4o) falls back cross-provider, using that provider's API key from its env var (skipped if unset — never reuses the primary key). Defaults to config llm.fallbackModels.",
       (val, prev) => (prev || []).concat([val]),
     )
     .option(
@@ -367,27 +384,45 @@ export function registerAgentCommand(program) {
       // tree (and parallel sessions) stay untouched. chdir BEFORE everything
       // else so project memory / checkpoint / completion all follow.
       let _worktree = null;
+      let _worktreeFinished = false;
+      let _finishAgentWorktreeFn = null;
       if (options.worktree) {
         try {
-          const { setupAgentWorktree } =
+          const { setupAgentWorktree, finishAgentWorktree } =
             await import("../lib/agent-worktree.js");
+          _finishAgentWorktreeFn = finishAgentWorktree;
           _worktree = setupAgentWorktree({ cwd: process.cwd() });
           process.chdir(_worktree.path);
           process.stderr.write(
             `worktree: ${_worktree.path} (branch ${_worktree.branch})\n`,
           );
+          // The worktree is created BEFORE flag validation, and several
+          // `process.exit(1)` guards below (plus any future ones) would skip the
+          // normal cleanup and orphan an empty worktree + branch on disk. A sync
+          // exit handler guarantees the auto-removable worktree is cleaned up on
+          // EVERY exit path (finishAgentWorktree is synchronous). Deduped with
+          // the normal async _finishWorktree() via _worktreeFinished.
+          process.on("exit", () => {
+            if (!_worktree || _worktreeFinished) return;
+            _worktreeFinished = true;
+            try {
+              process.chdir(_worktree.repoRoot);
+              _finishAgentWorktreeFn(_worktree);
+            } catch {
+              /* never block exit */
+            }
+          });
         } catch (err) {
           process.stderr.write(`--worktree failed: ${err.message}\n`);
           process.exit(1);
         }
       }
       const _finishWorktree = async () => {
-        if (!_worktree) return;
+        if (!_worktree || _worktreeFinished) return;
+        _worktreeFinished = true;
         try {
-          const { finishAgentWorktree } =
-            await import("../lib/agent-worktree.js");
           process.chdir(_worktree.repoRoot); // release the dir before removal
-          const fin = finishAgentWorktree(_worktree);
+          const fin = _finishAgentWorktreeFn(_worktree);
           process.stderr.write(
             fin.removed
               ? `worktree removed (${fin.reason}).\n`
@@ -509,6 +544,7 @@ export function registerAgentCommand(program) {
       // over a settings model. Applied once here so every branch (headless +
       // interactive, which all read options.model) picks it up; env vars are
       // set on the process so the agent loop + child tools inherit them.
+      let settingsSandbox = null;
       try {
         const { loadSettingsConfig } =
           await import("../lib/settings-loader.cjs");
@@ -520,6 +556,7 @@ export function registerAgentCommand(program) {
           process.env[k] = v;
         }
         if (!options.model && sc.model) options.model = sc.model;
+        settingsSandbox = sc.sandbox || null;
       } catch {
         // settings overrides are best-effort 鈥?never block the run
       }
@@ -651,10 +688,22 @@ export function registerAgentCommand(program) {
       const fallbackChatFn = fallbackModels.length
         ? makeFallbackChatFn({
             fallbackModels,
-            onFallback: ({ from, to, error }) =>
-              process.stderr.write(
-                `Note: model "${from}" failed (${error}); retrying with fallback model "${to}".\n`,
-              ),
+            onFallback: ({
+              from,
+              to,
+              error,
+              skipped,
+              reason,
+              crossProvider,
+            }) =>
+              skipped
+                ? process.stderr.write(
+                    `Note: fallback "${to}" skipped (${reason}).\n`,
+                  )
+                : process.stderr.write(
+                    `Note: model "${from}" failed (${error}); retrying with ` +
+                      `${crossProvider ? "cross-provider " : ""}fallback "${to}".\n`,
+                  ),
           })
         : undefined;
 
@@ -822,6 +871,7 @@ export function registerAgentCommand(program) {
         const agentSandbox = normalizeAgentSandbox(options.sandbox, {
           cwd: process.cwd(),
           network: options.sandboxNetwork === true,
+          settings: settingsSandbox,
         });
         // Resume requested onto a session with no headless (JSONL) transcript?
         // Warn instead of silently starting empty 鈥?headless resume rebuilds
@@ -864,6 +914,16 @@ export function registerAgentCommand(program) {
           additionalDirectories,
           sandbox: agentSandbox,
           autoCheckpoint,
+          // --otlp <file>: capture + export the run's OTel spans as OTLP/JSON.
+          otlp: options.otlp || null,
+          // --auto-rewake / --max-rewakes: bounded re-drive on async-hook failure.
+          // --max-rewakes implies --auto-rewake (a positive budget turns it on).
+          autoRewake:
+            options.autoRewake === true ||
+            (Number.isFinite(options.maxRewakes) && options.maxRewakes > 0),
+          maxRewakes: Number.isFinite(options.maxRewakes)
+            ? options.maxRewakes
+            : undefined,
           maxTurns,
           // commander maps --no-file-refs 鈫?options.fileRefs === false
           expandFileRefs: options.fileRefs !== false,
@@ -975,6 +1035,7 @@ export function registerAgentCommand(program) {
         sandbox: normalizeAgentSandbox(options.sandbox, {
           cwd: process.cwd(),
           network: options.sandboxNetwork === true,
+          settings: settingsSandbox,
         }),
         autoCheckpoint,
         // --vim: start the REPL in vim-mode editing (also CC_VIM=1 or /vim).

package/src/commands/audit.js

@@ -450,8 +450,10 @@ export function registerAuditCommand(program) {
     .option("-r, --risk-level <rl>", "Risk level")
     .option("-i, --ip-address <ip>", "IP address")
     .option("-u, --user-agent <ua>", "User agent")
-    .action((logId, opts) => {
-      const db = bootstrap();
+    .action(async (logId, opts) => {
+      // await bootstrap() (it's async): the prior sync `bootstrap()` left an
+      // unawaited Promise and raced teardown against an unresolved init.
+      const db = (await bootstrap({ verbose: program.opts().verbose })).db;
       try {
         const details = parseJsonOption(opts.details, "--details");
         const entry = logEventV2(db, {
@@ -467,7 +469,7 @@ export function registerAuditCommand(program) {
         });
         logger.log(JSON.stringify(entry, null, 2));
       } finally {
-        shutdown();
+        await shutdown();
       }
     });
 
@@ -487,15 +489,17 @@ export function registerAuditCommand(program) {
     .command("set-log-status-v2 <log-id> <status>")
     .description("V2: transition log status (active|archived|purged)")
     .option("-r, --reason <reason>", "Reason")
-    .action((logId, status, opts) => {
-      const db = bootstrap();
+    .action(async (logId, status, opts) => {
+      // await bootstrap() (it's async): the prior sync `bootstrap()` left an
+      // unawaited Promise and raced teardown against an unresolved init.
+      const db = (await bootstrap({ verbose: program.opts().verbose })).db;
       try {
         const entry = setLogStatusV2(db, logId, status, {
           reason: opts.reason,
         });
         logger.log(JSON.stringify(entry, null, 2));
       } finally {
-        shutdown();
+        await shutdown();
       }
     });
 
@@ -510,26 +514,30 @@ export function registerAuditCommand(program) {
   audit
     .command("auto-archive-logs")
     .description("V2: bulk-flip stale ACTIVE logs → ARCHIVED")
-    .action(() => {
-      const db = bootstrap();
+    .action(async () => {
+      // await bootstrap() (it's async): the prior sync `bootstrap()` left an
+      // unawaited Promise and raced teardown against an unresolved init.
+      const db = (await bootstrap({ verbose: program.opts().verbose })).db;
       try {
         const archived = autoArchiveLogs(db);
         logger.log(`Archived ${archived.length} log(s)`);
       } finally {
-        shutdown();
+        await shutdown();
       }
     });
 
   audit
     .command("auto-purge-logs")
     .description("V2: bulk-flip stale ARCHIVED logs → PURGED")
-    .action(() => {
-      const db = bootstrap();
+    .action(async () => {
+      // await bootstrap() (it's async): the prior sync `bootstrap()` left an
+      // unawaited Promise and raced teardown against an unresolved init.
+      const db = (await bootstrap({ verbose: program.opts().verbose })).db;
       try {
         const purged = autoPurgeLogs(db);
         logger.log(`Purged ${purged.length} log(s)`);
       } finally {
-        shutdown();
+        await shutdown();
       }
     });
 
@@ -552,8 +560,10 @@ export function registerAuditCommand(program) {
     )
     .option("-r, --reason <reason>", "Reason")
     .option("-m, --metadata <meta>", "Metadata (JSON)")
-    .action((alertId, status, opts) => {
-      const db = bootstrap();
+    .action(async (alertId, status, opts) => {
+      // await bootstrap() (it's async): the prior sync `bootstrap()` left an
+      // unawaited Promise and raced teardown against an unresolved init.
+      const db = (await bootstrap({ verbose: program.opts().verbose })).db;
       try {
         const metadata = parseJsonOption(opts.metadata, "--metadata");
         const entry = setAlertStatusV2(db, alertId, status, {
@@ -562,7 +572,7 @@ export function registerAuditCommand(program) {
         });
         logger.log(JSON.stringify(entry, null, 2));
       } finally {
-        shutdown();
+        await shutdown();
       }
     });
 
@@ -570,13 +580,15 @@ export function registerAuditCommand(program) {
     .command("acknowledge-alert <alert-id>")
     .description("V2: shortcut → acknowledged")
     .option("-r, --reason <reason>", "Reason")
-    .action((alertId, opts) => {
-      const db = bootstrap();
+    .action(async (alertId, opts) => {
+      // await bootstrap() (it's async): the prior sync `bootstrap()` left an
+      // unawaited Promise and raced teardown against an unresolved init.
+      const db = (await bootstrap({ verbose: program.opts().verbose })).db;
       try {
         const entry = acknowledgeAlert(db, alertId, opts.reason);
         logger.log(JSON.stringify(entry, null, 2));
       } finally {
-        shutdown();
+        await shutdown();
       }
     });
 
@@ -584,13 +596,15 @@ export function registerAuditCommand(program) {
     .command("resolve-alert <alert-id>")
     .description("V2: shortcut → resolved")
     .option("-r, --reason <reason>", "Reason")
-    .action((alertId, opts) => {
-      const db = bootstrap();
+    .action(async (alertId, opts) => {
+      // await bootstrap() (it's async): the prior sync `bootstrap()` left an
+      // unawaited Promise and raced teardown against an unresolved init.
+      const db = (await bootstrap({ verbose: program.opts().verbose })).db;
       try {
         const entry = resolveAlert(db, alertId, opts.reason);
         logger.log(JSON.stringify(entry, null, 2));
       } finally {
-        shutdown();
+        await shutdown();
       }
     });
 
@@ -598,13 +612,15 @@ export function registerAuditCommand(program) {
     .command("dismiss-alert <alert-id>")
     .description("V2: shortcut → dismissed")
     .option("-r, --reason <reason>", "Reason")
-    .action((alertId, opts) => {
-      const db = bootstrap();
+    .action(async (alertId, opts) => {
+      // await bootstrap() (it's async): the prior sync `bootstrap()` left an
+      // unawaited Promise and raced teardown against an unresolved init.
+      const db = (await bootstrap({ verbose: program.opts().verbose })).db;
       try {
         const entry = dismissAlert(db, alertId, opts.reason);
         logger.log(JSON.stringify(entry, null, 2));
       } finally {
-        shutdown();
+        await shutdown();
       }
     });
 

package/src/commands/codeintel.js

@@ -0,0 +1,320 @@
+/**
+ * cc code-intel — semantic code navigation via the Language Server Protocol.
+ *
+ * End-to-end surface for the LSP code-intelligence layer (Phase 2 of the CLI
+ * optimization plan). Proves the stack works without touching the contended
+ * agent-core; the agent `code_intelligence` tool is wired separately.
+ *
+ *   cc code-intel status                          # which servers are installed
+ *   cc code-intel def <file> <line> <col>         # go to definition
+ *   cc code-intel refs <file> <line> <col>        # find references
+ *   cc code-intel hover <file> <line> <col>       # type / doc info
+ *   cc code-intel symbols <file>                  # document symbols
+ *   cc code-intel wsymbols <query>                # workspace symbol search
+ *   cc code-intel diag <file>                     # diagnostics
+ *   cc code-intel rename <file> <line> <col> <newName>   # preview a rename
+ *
+ * Positions are 1-based (line/col), matching editor gutters.
+ */
+
+import chalk from "chalk";
+import { logger } from "../lib/logger.js";
+
+function num(v, name) {
+  const n = Number.parseInt(v, 10);
+  if (!Number.isFinite(n) || n < 1) {
+    throw new Error(`${name} must be a positive integer (1-based), got "${v}"`);
+  }
+  return n;
+}
+
+async function withCI(fn, { json } = {}) {
+  const { CodeIntelligence } = await import("../lib/lsp/code-intelligence.js");
+  // coldStart: each CLI invocation spawns a fresh server, so wait for the
+  // project to load before querying (the warm agent path leaves this off).
+  const ci = new CodeIntelligence({
+    projectRoot: process.cwd(),
+    coldStart: true,
+  });
+  try {
+    const result = await fn(ci);
+    if (json) {
+      console.log(JSON.stringify(result, null, 2));
+    }
+    return result;
+  } finally {
+    await ci.dispose();
+  }
+}
+
+function reportUnavailable(res) {
+  logger.warn(
+    chalk.yellow(`LSP unavailable: ${res.reason}`) +
+      chalk.gray(
+        "\n  → falling back to text search (`cc search` / agent search_files)",
+      ),
+  );
+  process.exitCode = 3;
+}
+
+function fmtLoc(l) {
+  const pos = `${chalk.cyan(l.file)}:${chalk.yellow(l.line)}:${l.col}`;
+  return l.snippet ? `${pos}  ${chalk.gray(l.snippet)}` : pos;
+}
+
+/** Right-align a millisecond number in a 6-char column for the bench table. */
+function fmtMs(v) {
+  return String(v == null ? "-" : v).padStart(6);
+}
+
+export function registerCodeIntelCommand(program) {
+  const ci = program
+    .command("code-intel")
+    .alias("ci")
+    .description(
+      "Semantic code navigation via LSP (definition/references/symbols/diagnostics)",
+    );
+
+  ci.command("status")
+    .description("Show which language servers are installed and detectable")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      const { probeServers, supportedExtensions } =
+        await import("../lib/lsp/lsp-server-registry.js");
+      // Surface plugin-contributed servers too (Phase 3: .lsp.json).
+      const { ensurePluginLspServers } =
+        await import("../lib/plugin-runtime/lsp.js");
+      ensurePluginLspServers({ cwd: process.cwd() });
+      const servers = probeServers(process.cwd());
+      if (options.json) {
+        console.log(
+          JSON.stringify(
+            { servers, extensions: supportedExtensions() },
+            null,
+            2,
+          ),
+        );
+        return;
+      }
+      logger.log(chalk.bold("LSP servers:"));
+      for (const s of servers) {
+        const mark = s.available ? chalk.green("✔") : chalk.gray("✖");
+        const where = s.available
+          ? chalk.gray(s.command)
+          : chalk.gray("not installed");
+        logger.log(`  ${mark} ${s.id.padEnd(28)} ${where}`);
+      }
+      const anyAvail = servers.some((s) => s.available);
+      if (!anyAvail) {
+        logger.log(
+          chalk.yellow(
+            "\nNo language servers found. Install one to enable semantic navigation, e.g.:\n",
+          ) + chalk.gray("  npm i -g typescript-language-server typescript"),
+        );
+      }
+    });
+
+  ci.command("def <file> <line> <col>")
+    .description("Go to definition of the symbol at file:line:col")
+    .option("--json", "Output as JSON")
+    .action(async (file, line, col, options) => {
+      const res = await withCI(
+        (c) => c.definition(file, num(line, "line"), num(col, "col")),
+        options,
+      );
+      if (!res.available) return reportUnavailable(res);
+      if (options.json) return;
+      if (!res.locations.length)
+        return logger.log(chalk.gray("No definition found."));
+      for (const l of res.locations) logger.log(fmtLoc(l));
+    });
+
+  ci.command("refs <file> <line> <col>")
+    .description("Find references to the symbol at file:line:col")
+    .option("--no-decl", "Exclude the declaration itself")
+    .option("--json", "Output as JSON")
+    .action(async (file, line, col, options) => {
+      const res = await withCI(
+        (c) =>
+          c.references(file, num(line, "line"), num(col, "col"), {
+            includeDeclaration: options.decl !== false,
+          }),
+        options,
+      );
+      if (!res.available) return reportUnavailable(res);
+      if (options.json) return;
+      logger.log(chalk.bold(`${res.locations.length} reference(s):`));
+      for (const l of res.locations) logger.log("  " + fmtLoc(l));
+    });
+
+  ci.command("hover <file> <line> <col>")
+    .description("Show type/doc info for the symbol at file:line:col")
+    .option("--json", "Output as JSON")
+    .action(async (file, line, col, options) => {
+      const res = await withCI(
+        (c) => c.hover(file, num(line, "line"), num(col, "col")),
+        options,
+      );
+      if (!res.available) return reportUnavailable(res);
+      if (options.json) return;
+      logger.log(res.contents || chalk.gray("No hover info."));
+    });
+
+  ci.command("symbols <file>")
+    .description("List symbols declared in a document")
+    .option("--json", "Output as JSON")
+    .action(async (file, options) => {
+      const res = await withCI((c) => c.documentSymbols(file), options);
+      if (!res.available) return reportUnavailable(res);
+      if (options.json) return;
+      for (const s of res.symbols) {
+        const loc = chalk.gray(`${s.line}:${s.col}`);
+        const kind = chalk.magenta(s.kind.padEnd(10));
+        const container = s.container ? chalk.gray(` (${s.container})`) : "";
+        logger.log(`  ${loc}  ${kind} ${s.name}${container}`);
+      }
+    });
+
+  ci.command("wsymbols <query>")
+    .description("Search symbols across the workspace by name")
+    .option("--json", "Output as JSON")
+    .action(async (query, options) => {
+      const res = await withCI((c) => c.workspaceSymbols(query), options);
+      if (!res.available) return reportUnavailable(res);
+      if (options.json) return;
+      logger.log(chalk.bold(`${res.symbols.length} symbol(s):`));
+      for (const s of res.symbols) {
+        logger.log(
+          `  ${chalk.magenta(s.kind.padEnd(10))} ${s.name}  ${chalk.gray(`${s.file}:${s.line}`)}`,
+        );
+      }
+    });
+
+  ci.command("diag <file>")
+    .description("Show diagnostics (errors/warnings) for a file")
+    .option(
+      "--timeout <ms>",
+      "How long to wait for the server to publish",
+      "5000",
+    )
+    .option("--json", "Output as JSON")
+    .action(async (file, options) => {
+      const res = await withCI(
+        (c) =>
+          c.diagnostics(file, { timeoutMs: num(options.timeout, "timeout") }),
+        options,
+      );
+      if (!res.available) return reportUnavailable(res);
+      if (options.json) return;
+      if (!res.diagnostics.length)
+        return logger.log(chalk.green("No diagnostics."));
+      for (const d of res.diagnostics) {
+        const sev =
+          d.severity === "error"
+            ? chalk.red(d.severity)
+            : d.severity === "warning"
+              ? chalk.yellow(d.severity)
+              : chalk.gray(d.severity);
+        logger.log(
+          `  ${chalk.gray(`${d.line}:${d.col}`)} ${sev} ${d.message}${d.code ? chalk.gray(` [${d.code}]`) : ""}`,
+        );
+      }
+    });
+
+  ci.command("rename <file> <line> <col> <newName>")
+    .description(
+      "Preview a symbol rename across files (does NOT apply the edit)",
+    )
+    .option("--json", "Output as JSON")
+    .action(async (file, line, col, newName, options) => {
+      const res = await withCI(
+        (c) =>
+          c.renamePreview(file, num(line, "line"), num(col, "col"), newName),
+        options,
+      );
+      if (!res.available) return reportUnavailable(res);
+      if (options.json) return;
+      const total = res.edits.reduce((n, f) => n + f.edits.length, 0);
+      logger.log(
+        chalk.bold(
+          `Rename would touch ${res.edits.length} file(s), ${total} edit(s):`,
+        ),
+      );
+      for (const f of res.edits) {
+        logger.log(`  ${chalk.cyan(f.file)} — ${f.edits.length} edit(s)`);
+        for (const e of f.edits) {
+          logger.log(chalk.gray(`      ${e.line}:${e.col} → "${e.newText}"`));
+        }
+      }
+      logger.log(
+        chalk.gray(
+          "\n(preview only — apply with your editor or agent edit tools)",
+        ),
+      );
+    });
+
+  ci.command("bench <file>")
+    .description(
+      "Benchmark startup + per-query latency (and server RSS) against a real file",
+    )
+    .option("--runs <n>", "Timed iterations per operation", "20")
+    .option("--warmup <n>", "Untimed warmup iterations per operation", "2")
+    .option("--json", "Output as JSON")
+    .action(async (file, options) => {
+      const { runLatencyBenchmark } = await import("../lib/lsp/benchmark.js");
+      const runs = num(options.runs, "runs");
+      const warmup = Number.parseInt(options.warmup, 10);
+      const report = await runLatencyBenchmark({
+        projectRoot: process.cwd(),
+        file,
+        runs,
+        warmup: Number.isFinite(warmup) && warmup >= 0 ? warmup : 2,
+        onProgress: options.json
+          ? () => {}
+          : (m) => process.stderr.write(chalk.gray(`  … ${m}\n`)),
+      });
+      if (!report.available) {
+        return reportUnavailable(report);
+      }
+      if (options.json) {
+        console.log(JSON.stringify(report, null, 2));
+        return;
+      }
+      logger.log(chalk.bold(`\nLSP latency — ${chalk.cyan(file)}`));
+      logger.log(
+        `  cold start (spawn + index + first query): ${chalk.yellow(report.coldStartMs + " ms")}`,
+      );
+      if (report.server) {
+        const rss =
+          report.server.rssMb != null ? `${report.server.rssMb} MB` : "n/a";
+        logger.log(
+          `  server: ${report.server.serverId} (pid ${report.server.pid ?? "?"}), RSS ${chalk.yellow(rss)}`,
+        );
+      }
+      if (report.probe) {
+        logger.log(
+          chalk.gray(
+            `  probe symbol: ${report.probe.name} (${report.probe.kind}) @ ${report.probe.line}:${report.probe.col}`,
+          ),
+        );
+      }
+      logger.log(
+        chalk.bold(
+          `\n  operation          n     min   median    p95     max   (warm, ms)`,
+        ),
+      );
+      for (const [name, s] of Object.entries(report.ops)) {
+        if (s.skipped) {
+          logger.log(
+            `  ${name.padEnd(18)} ${chalk.gray("skipped: " + s.skipped)}`,
+          );
+          continue;
+        }
+        logger.log(
+          `  ${name.padEnd(18)} ${String(s.n).padStart(3)}  ${fmtMs(s.min)} ${fmtMs(s.median)} ${fmtMs(s.p95)} ${fmtMs(s.max)}`,
+        );
+      }
+    });
+
+  return ci;
+}

package/src/commands/collab.js

@@ -12,6 +12,7 @@ import { logger } from "../lib/logger.js";
 import { bootstrap, shutdown } from "../runtime/bootstrap.js";
 import {
   ensureGovernanceTables,
+  loadFromDb,
   listDecisionTypes,
   listConflictStrategies,
   listQualityMetrics,
@@ -69,12 +70,24 @@ function _dbFromCtx(ctx) {
   }
   const db = ctx.db.getDatabase();
   ensureGovernanceTables(db);
+  loadFromDb(db);
   return db;
 }
 
 function _readJsonFile(filePath) {
-  const raw = fs.readFileSync(filePath, "utf-8");
-  return JSON.parse(raw);
+  let raw;
+  try {
+    raw = fs.readFileSync(filePath, "utf-8");
+  } catch (err) {
+    // A user-supplied path — surface which file and why instead of the bare
+    // global "error: ENOENT ..." with no context.
+    throw new Error(`could not read ${filePath}: ${err.message}`);
+  }
+  try {
+    return JSON.parse(raw);
+  } catch (err) {
+    throw new Error(`${filePath} is not valid JSON: ${err.message}`);
+  }
 }
 
 function _printDecision(d) {