@orquentra/codebuddy 2.9.0 → 2.15.0

package/dist/{main-YJKSYFPT.js → main-RLMKQZW4.js}

@@ -1,18 +1,16 @@
-import {
-  renderLeanBlock,
-  runLeanHookCommand
-} from "./chunk-UK6XTS2Y.js";
 import {
   runPreToolHookCommand
-} from "./chunk-ENKDFLOO.js";
+} from "./chunk-UOTKHSQ5.js";
 import {
-  failSoft,
-  readHookInput,
-  writeStdout
-} from "./chunk-FJOTP632.js";
+  LOCAL_LLM_SIZES,
+  addLocalLlm,
+  printLocalLlmStatus,
+  removeLocalLlm
+} from "./chunk-UTPC66MV.js";
 import {
   WORKFLOW_CLIENTS,
   clientDisplayName,
+  clientHookCapabilities,
   clientHooksInstalled,
   defaultRulesMode,
   detectClient,
@@ -29,20 +27,16 @@ import {
   removeCodexEntry,
   renderManagedBlock,
   renderWorkflowTemplate,
+  runBridgeHook,
+  runCodexHook,
   setHooks,
   uninstallClient,
   writeProjectMcpConfig
-} from "./chunk-J4T6HHI4.js";
+} from "./chunk-RZ266NHE.js";
 import {
-  AUTOMATION_MODES,
-  CLIENT_ADAPTERS,
-  CLIENT_IDS,
-  LIFECYCLE_EVENTS,
-  MODE_LABELS,
-  parseClient,
-  parseMode,
-  supportedModes
-} from "./chunk-W7GAXL6C.js";
+  renderLeanBlock,
+  runLeanHook
+} from "./chunk-JJQDVGF7.js";
 import {
   isDockerDaemonRunning,
   tryStartDockerDesktop,
@@ -53,8 +47,40 @@ import {
   postgresStatus,
   postgresUp
 } from "./chunk-CSRD5OQA.js";
+import {
+  failSoft,
+  readHookInput,
+  writeStdout
+} from "./chunk-FJOTP632.js";
+import {
+  loadLlmSummaries,
+  summarizeRepository
+} from "./chunk-ITXE27SZ.js";
+import {
+  listIndexFacts,
+  pruneIndexFacts
+} from "./chunk-UATJCD2T.js";
+import {
+  chatJson,
+  coolingDown,
+  usageToday
+} from "./chunk-6YI2D5F5.js";
+import {
+  runIndexModelPass
+} from "./chunk-U7KDM62P.js";
+import {
+  AUTOMATION_MODES,
+  CLIENT_ADAPTERS,
+  CLIENT_IDS,
+  LIFECYCLE_EVENTS,
+  MODE_LABELS,
+  parseClient,
+  parseMode,
+  supportedModes
+} from "./chunk-V7PT6ER5.js";
 import {
   TELEMETRY_NOTICE,
+  findReuse,
   flushTelemetry,
   generateSuggestions,
   migrateMemoryToFiles,
@@ -68,13 +94,9 @@ import {
   traceCliCommand,
   watchRepository,
   writeTelemetryState
-} from "./chunk-2WH2Q4TA.js";
-import {
-  DEFAULT_ZVEC_MODEL,
-  buildZvecIndex,
-  zvecStatus
-} from "./chunk-GXOML4UZ.js";
+} from "./chunk-D5E7SGI5.js";
 import {
+  HookStagingStore,
   PlanFileStore,
   PlanLifecycle,
   ReviewStore,
@@ -83,29 +105,62 @@ import {
   assessRisk,
   buildBeforeEditContext,
   buildBootstrapContext,
+  findCodexRollouts,
+  forgetJournal,
+  importCodexRollout,
+  journalLag,
+  latestUnfinished,
+  listJournals,
   openHookSemantics,
+  readCheckpoint,
+  renderCheckpointNow,
   renderContextBlock,
   resolveRiskPaths,
   runCaptureHook,
+  runCheckpointHook,
   runContextHook,
   runResetHook,
+  runResumeHook,
   runStageHook,
-  runSyncHook
-} from "./chunk-F4BJ3DXW.js";
-import {
-  SessionCapsuleLedger,
-  detectTestCommand,
-  estimateTokens
-} from "./chunk-GKNYMNFM.js";
+  runSyncHook,
+  syncReuseVectors
+} from "./chunk-KQCP3ZYH.js";
 import {
   parseTraceLines,
   readTraces,
   tracePath
 } from "./chunk-YN7TEIUH.js";
+import {
+  SessionCapsuleLedger,
+  detectTestCommand,
+  estimateTokens
+} from "./chunk-7IPSDDO5.js";
 import {
   hookRoot
 } from "./chunk-TGFTKWOR.js";
+import "./chunk-GQKWUHMA.js";
 import "./chunk-DFV2SK6C.js";
+import {
+  DEFAULT_ZVEC_MODEL,
+  buildZvecIndex,
+  zvecStatus
+} from "./chunk-4BSO3HST.js";
+import {
+  buildArchitectureMap,
+  generateGraphifyGraph,
+  indexRepository,
+  loadFreshIndex,
+  loadGraphifyMap,
+  loadProjectArchitectureMap,
+  neighbours,
+  queryMap,
+  setupGraphify,
+  syncFileVectors
+} from "./chunk-UR3DF74I.js";
+import {
+  extractSymbolTable,
+  supportsSymbols
+} from "./chunk-Y7D7PUBE.js";
 import {
   bootstrapDatabase,
   buildProviderFromConfig,
@@ -117,58 +172,25 @@ import {
   pingDatabase,
   runDoctor,
   runMigrations
-} from "./chunk-QN76UJP7.js";
+} from "./chunk-KYRM3HPP.js";
+import "./chunk-57642NGU.js";
 import {
   MemoryFileStore,
   VERSION
-} from "./chunk-SRA4MDVG.js";
+} from "./chunk-YMXFSHXT.js";
 import {
   computeFactHash,
   generateEntityId
-} from "./chunk-CAEPHLHC.js";
-import "./chunk-6JCKMIQY.js";
-import {
-  localRuntimeInstalled,
-  modelCacheDir
-} from "./chunk-3QGW53GD.js";
-import {
-  loadLlmSummaries,
-  summarizeRepository
-} from "./chunk-6NZEZJYD.js";
-import {
-  chatJson,
-  coolingDown,
-  usageToday
-} from "./chunk-ESZXCZIN.js";
-import {
-  generateGraphifyGraph,
-  loadGraphifyMap,
-  setupGraphify,
-  syncFileVectors
-} from "./chunk-TLWGZVPC.js";
-import {
-  buildArchitectureMap,
-  indexRepository,
-  loadFreshIndex,
-  neighbours,
-  queryMap
-} from "./chunk-ITQO632W.js";
-import {
-  extractSymbolTable,
-  supportsSymbols
-} from "./chunk-Y7D7PUBE.js";
+} from "./chunk-EMWGLKPR.js";
 import {
   redactPersisted
 } from "./chunk-AL6VBTNA.js";
+import "./chunk-6JCKMIQY.js";
 import {
-  DEFAULT_CLOUD_EMBEDDING_MODELS,
-  DEFAULT_RERANK_MODELS,
-  LOCAL_EMBEDDING_MODEL,
-  getModelDefinition
-} from "./chunk-HPOR6YXA.js";
-import {
+  mergeGlobalConfig,
+  readGlobalConfig,
   resolveLlmConfig
-} from "./chunk-SFMIMLXR.js";
+} from "./chunk-WHKXUXHE.js";
 import {
   PLAN_POLICIES,
   configPath,
@@ -186,13 +208,26 @@ import {
   setPlanPolicy,
   setZvecEnabled,
   writeConfigFile
-} from "./chunk-KNR2P2UY.js";
-import "./chunk-CG5B3LYG.js";
+} from "./chunk-M75SN4D4.js";
+import {
+  writeAtomic
+} from "./chunk-CG5B3LYG.js";
+import "./chunk-BTTQWSDS.js";
+import {
+  localRuntimeInstalled,
+  modelCacheDir
+} from "./chunk-3QGW53GD.js";
+import {
+  DEFAULT_CLOUD_EMBEDDING_MODELS,
+  DEFAULT_RERANK_MODELS,
+  LOCAL_EMBEDDING_MODEL,
+  getModelDefinition
+} from "./chunk-HPOR6YXA.js";
 import "./chunk-PZ5AY32C.js";
 
 // src/cli/main.ts
 import { Command } from "commander";
-import pc23 from "picocolors";
+import pc25 from "picocolors";
 
 // src/integrations/github.ts
 import { constants } from "fs";
@@ -770,6 +805,7 @@ var CONFORMANCE = {
     const servers = json(result.stdout);
     if (!Array.isArray(servers)) return [fail("mcp", "codex mcp list --json returned no JSON")];
     return [
+      await clientHooksInstalled(root, "codex") ? pass("hooks", ".codex/hooks.json is installed; review trust in Codex /hooks") : skip("hooks", "not installed in this repo"),
       servers.some((server) => server.name === name2) ? pass("mcp", `codex mcp list has ${name2}`) : skip("mcp", `no ${name2} entry (clients install codex --global adds it)`)
     ];
   },
@@ -863,7 +899,7 @@ function registerClientsCommands(program, runSafely2) {
       console.log(pc2.dim("Per-turn token cost per client: codebuddy clients cost"));
     });
   });
-  clients.command("install").argument("<client>", `One of: ${CLIENT_IDS.join(", ")}.`).requiredOption("--mode <mode>", `One of: ${AUTOMATION_MODES.join(", ")}.`).option("--namespace <name>", "Namespace for the MCP entry (defaults to config/folder).").option("--global", "Also add the MCP entry to the global config (Codex, Hermes).").description("Apply one automation mode: rules block, hooks, and MCP config.").action(
+  clients.command("install").argument("<client>", `One of: ${CLIENT_IDS.join(", ")}.`).requiredOption("--mode <mode>", `One of: ${AUTOMATION_MODES.join(", ")}.`).option("--namespace <name>", "Namespace for the MCP entry (defaults to config/folder).").option("--global", "Also add the MCP entry to the global config (Codex, Hermes).").option("--capture", "Capture turns into memory even in lean mode (Claude Code).").option("--no-capture", "Inject context without capturing turns (Claude Code).").description("Apply one automation mode: rules block, hooks, and MCP config.").action(
     async (client, opts) => {
       await runSafely2(async () => {
         const mode = parseMode(opts.mode);
@@ -871,7 +907,8 @@ function registerClientsCommands(program, runSafely2) {
           client: parseClient(client),
           mode,
           ...opts.namespace ? { namespace: opts.namespace } : {},
-          ...opts.global ? { global: true } : {}
+          ...opts.global ? { global: true } : {},
+          ...opts.capture !== void 0 ? { capture: opts.capture } : {}
         });
         printReport2(report, `${MODE_LABELS[mode]} mode`);
       });
@@ -983,6 +1020,30 @@ function registerContextCommands(program, runSafely2) {
       printBootstrap(result);
     });
   });
+  context.command("reuse").argument("<task...>", "What you are about to implement.").option("--json", "Print machine-readable JSON.").description(
+    "Existing helpers to reuse for a task: signature, a call site and the covering test."
+  ).action(async (taskParts, opts) => {
+    await runSafely2(async () => {
+      const root = process.cwd();
+      const { manifest } = await loadFreshIndex(root);
+      const picks = await findReuse(
+        root,
+        taskParts.join(" "),
+        manifest,
+        await loadProjectArchitectureMap(root, manifest)
+      );
+      if (opts.json) {
+        console.log(JSON.stringify(picks, null, 2));
+        return;
+      }
+      if (picks.length === 0) console.log(pc3.dim("no existing helper clearly matches"));
+      for (const pick of picks) {
+        console.log(`${pick.path}:${pick.startLine}-${pick.endLine}  ${pick.signature}`);
+        if (pick.usage) console.log(pc3.dim(`  used at ${pick.usage}`));
+        if (pick.test) console.log(pc3.dim(`  test ${pick.test}`));
+      }
+    });
+  });
   context.command("preview").argument("[task...]", "The task you are about to work on.").option("--paths <paths>", "Comma-separated repo-relative paths to target.").option("--plan <id>", "Resolve target files from a CodeBuddy plan.").option("--git", "Resolve target files from current git changes.").option("--json", "Print machine-readable JSON.").description("Show the context CodeBuddy would assemble before editing the given files.").action(
     async (taskParts, opts) => {
       await runSafely2(async () => {
@@ -1720,15 +1781,22 @@ function registerGitHubCommands(program, runSafely2) {
 import { execFile as execFile2, spawn as spawn3 } from "child_process";
 import { relative as relative2 } from "path";
 import pc7 from "picocolors";
+
+// src/hooks/lean-command.ts
+async function runLeanHookCommand() {
+  await failSoft(async () => {
+    await runLeanHook(await readHookInput(), writeStdout);
+  });
+}
+
+// src/cli/commands/hooks.ts
 function registerHooksCommands(program, runSafely2) {
   const hooks = program.command("hooks").description("Enforce automatic recall/capture via client lifecycle hooks.");
   hooks.command("install").option(
     "--client <client>",
-    "Client with a CodeBuddy hook adapter (claude, opencode, hermes).",
+    "Client with a CodeBuddy hook adapter (claude, codex, opencode, hermes).",
     "claude"
-  ).description(
-    "Add CodeBuddy's recall/capture hooks (.claude/settings.json, .opencode/plugins/codebuddy.js or .hermes/plugins/codebuddy/)."
-  ).action(async (opts) => {
+  ).description("Add CodeBuddy's recall/capture hooks for the selected client.").action(async (opts) => {
     await runSafely2(async () => {
       const client = assertHookClient(opts.client);
       const step = await setHooks(process.cwd(), true, client);
@@ -1750,7 +1818,7 @@ function registerHooksCommands(program, runSafely2) {
   });
   hooks.command("uninstall").option(
     "--client <client>",
-    "Client with a CodeBuddy hook adapter (claude, opencode, hermes).",
+    "Client with a CodeBuddy hook adapter (claude, codex, opencode, hermes).",
     "claude"
   ).description("Remove CodeBuddy's hooks for a client (user hooks untouched).").action(async (opts) => {
     await runSafely2(async () => {
@@ -1764,14 +1832,43 @@ function registerHooksCommands(program, runSafely2) {
   });
   hooks.command("status").option(
     "--client <client>",
-    "Client with a CodeBuddy hook adapter (claude, opencode, hermes).",
+    "Client with a CodeBuddy hook adapter (claude, codex, opencode, hermes).",
     "claude"
-  ).description("Report whether CodeBuddy hooks are installed.").action(async (opts) => {
+  ).description("Report which CodeBuddy hooks are installed and what they do.").action(async (opts) => {
     await runSafely2(async () => {
-      const installed = await clientHooksInstalled(process.cwd(), parseClient(opts.client));
+      const caps = await clientHookCapabilities(process.cwd(), parseClient(opts.client));
+      if (!caps?.injection) {
+        console.log(pc7.dim("CodeBuddy hooks: not installed"));
+        return;
+      }
+      console.log(pc7.green("CodeBuddy hooks: installed"));
+      console.log(`  injection: ${caps.injection}`);
+      console.log(
+        `  capture: ${caps.capture ? "on (edits staged, turn end captured)" : "off (turns are not captured into memory)"}`
+      );
       console.log(
-        installed ? pc7.green("CodeBuddy hooks: installed") : pc7.dim("CodeBuddy hooks: not installed")
+        `  recovery: ${caps.recovery ? "on (pre-compaction checkpoint, unfinished-task resume)" : "off"}`
       );
+      console.log(`  compaction reset: ${caps.reset ? "on" : "off"}`);
+      console.log(`  read guard: ${caps.guard ? "on" : "off"}`);
+    });
+  });
+  hooks.command("codex").option("--injection <mode>", "full or lean", "full").option("--capture", "Capture visible lifecycle events", false).description("[hook] Native Codex event adapter (JSON output, no permission changes).").action(async (opts) => {
+    let result = {};
+    await failSoft(async () => {
+      if (opts.injection !== "full" && opts.injection !== "lean")
+        throw new Error("injection must be full or lean");
+      result = await runCodexHook(
+        await readHookInput(),
+        opts.injection,
+        opts.capture
+      );
+    });
+    await writeStdout(JSON.stringify(result));
+  });
+  hooks.command("bridge").description("[hook] Capture normalized host events and restore checkpoint context.").action(async () => {
+    await failSoft(async () => {
+      await runBridgeHook(await readHookInput(), writeStdout);
     });
   });
   hooks.command("context").description("[hook] Emit compact project context for injection at prompt submit.").action(async () => {
@@ -1824,6 +1921,16 @@ function registerHooksCommands(program, runSafely2) {
       await runResetHook(await readHookInput(), writeStdout);
     });
   });
+  hooks.command("checkpoint").description("[hook] Journal the transcript before compaction (PreCompact).").action(async () => {
+    await failSoft(async () => {
+      await runCheckpointHook(await readHookInput());
+    });
+  });
+  hooks.command("resume").description("[hook] Print another session's unfinished task checkpoint, if any.").action(async () => {
+    await failSoft(async () => {
+      await runResumeHook(await readHookInput(), writeStdout);
+    });
+  });
 }
 function assertHookClient(value) {
   const client = parseClient(value);
@@ -1898,8 +2005,9 @@ var KEY_ENV = { groq: "GROQ_API_KEY", openrouter: "OPENROUTER_API_KEY" };
 var WATCH_BATCH = 8;
 async function llmStatusReport(root, env = process.env) {
   const block = (await readConfigFile(root)).llm;
-  const provider = block?.provider ?? "groq";
   const config = await resolveLlmConfig(root, env);
+  const provider = config.enabled ? config.provider : block?.provider ?? "groq";
+  const keyName = provider === "local" ? "" : KEY_ENV[provider];
   const model = config.enabled ? config.model : block?.model ?? null;
   const key = `${provider}:${model}`;
   const { manifest } = await loadFreshIndex(root);
@@ -1908,8 +2016,9 @@ async function llmStatusReport(root, env = process.env) {
     reason: config.enabled ? "on" : config.reason,
     provider,
     model,
-    keyEnv: env.CODEBUDDY_LLM_API_KEY ? "CODEBUDDY_LLM_API_KEY" : KEY_ENV[provider],
-    keyPresent: Boolean(env.CODEBUDDY_LLM_API_KEY || env[KEY_ENV[provider]]),
+    keyEnv: provider === "local" ? "none needed" : env.CODEBUDDY_LLM_API_KEY ? "CODEBUDDY_LLM_API_KEY" : keyName,
+    // Enabled implies a key (environment or saved by `codebuddy use`).
+    keyPresent: provider === "local" || config.enabled || Boolean(env.CODEBUDDY_LLM_API_KEY || env[keyName]),
     features: config.enabled ? config.features : null,
     usageToday: (await usageToday(root))[key] ?? 0,
     dailyTokenBudget: config.enabled ? config.dailyTokenBudget : block?.dailyTokenBudget ?? 4e5,
@@ -1950,7 +2059,7 @@ function registerLlmCommands(program, runSafely2) {
       if (!report.keyPresent) console.log(pc8.dim(`next: export ${report.keyEnv}=<your key>`));
     });
   });
-  llm.command("enable").option("--provider <provider>", "groq or openrouter", "groq").option("--model <model>", "Model id (default: llama-3.1-8b-instant on groq).").description("Turn the layer on in .codebuddy/config.json (the key stays in your environment).").action(async (opts) => {
+  llm.command("enable").option("--provider <provider>", "groq or openrouter", "groq").option("--model <model>", "Model id (default: qwen/qwen3.8-27b).").description("Turn the layer on in .codebuddy/config.json (the key stays in your environment).").action(async (opts) => {
     await runSafely2(async () => {
       if (opts.provider !== "groq" && opts.provider !== "openrouter") {
         throw new Error("--provider must be groq or openrouter");
@@ -2006,13 +2115,36 @@ function registerLlmCommands(program, runSafely2) {
 // src/cli/commands/indexing.ts
 var VECTOR_BUDGET_MS = 10 * 6e4;
 function registerIndexCommands(program, runSafely2) {
-  program.command("index").option("--full", "Re-summarize every file, ignoring existing content hashes.").option("--json", "Print machine-readable JSON.").option("--no-vectors", "Skip embedding source files for task \u2192 file ordering.").description("Index the repository: content hashes and lightweight file summaries.").action(async (opts) => {
+  program.command("index").option("--full", "Re-summarize every file, ignoring existing content hashes.").option("--json", "Print machine-readable JSON.").option("--no-vectors", "Skip embedding source files for task \u2192 file ordering.").option(
+    "--cards",
+    "Also write intent cards and index facts with the local (or BYOK) model, then embed the cards."
+  ).description("Index the repository: content hashes and lightweight file summaries.").action(async (opts) => {
     await runSafely2(async () => {
       const result = await indexRepository({ ...opts.full ? { full: true } : {} });
       const local = opts.vectors && (await loadRuntimeConfig(process.cwd(), { requireDatabase: false }).catch(() => null))?.provider.type === "local";
+      const vectorStarted = Date.now();
       const vectors = local ? await syncFileVectors(process.cwd(), VECTOR_BUDGET_MS) : null;
+      const reuseVectors = local ? await syncReuseVectors(process.cwd(), VECTOR_BUDGET_MS - (Date.now() - vectorStarted)) : null;
+      const cardsStarted = Date.now();
+      const model = opts.cards ? await runIndexModelPass(process.cwd(), {
+        ...opts.json ? {} : {
+          onProgress: (done, total) => process.stderr.write(`\r  cards: ${done}/${total}`)
+        }
+      }) : null;
+      if (model && !opts.json) process.stderr.write("\n");
       if (opts.json) {
-        console.log(JSON.stringify({ ...result, ...vectors ? { vectors } : {} }, null, 2));
+        console.log(
+          JSON.stringify(
+            {
+              ...result,
+              ...vectors ? { vectors } : {},
+              ...reuseVectors ? { reuseVectors } : {},
+              ...model ? { model: { ...model, ms: Date.now() - cardsStarted } } : {}
+            },
+            null,
+            2
+          )
+        );
         return;
       }
       printResult(result);
@@ -2025,6 +2157,7 @@ function registerIndexCommands(program, runSafely2) {
       } else if (local) {
         console.log(pc9.dim("  file vectors: skipped (local embedding runtime not available)"));
       }
+      if (model) printModelPass(model, Date.now() - cardsStarted);
     });
   });
   program.command("watch").option("--debounce <ms>", "Coalesce file-change bursts within this window.", Number).option("--no-llm", "Do not write BYOK model summaries after index passes.").description("Watch the repository and incrementally re-index on change (Ctrl+C to stop).").action(async (opts) => {
@@ -2051,6 +2184,24 @@ function registerIndexCommands(program, runSafely2) {
     });
   });
 }
+function printModelPass(model, ms) {
+  if (!model.cards && !model.facts) {
+    console.log(pc9.dim("  cards: skipped (no model; codebuddy models add local-llm)"));
+    return;
+  }
+  if (model.cards) {
+    console.log(
+      pc9.dim(
+        `  cards: ${model.cards.summarized} written, ${model.cards.remaining} left (${model.cards.stoppedBy}), ${model.cardVectors} embedded, ${Math.round(ms / 1e3)} s`
+      )
+    );
+  }
+  if (model.facts) {
+    console.log(
+      pc9.dim(`  index facts: ${model.facts.written} written, ${model.facts.removed} replaced`)
+    );
+  }
+}
 function printResult(result, compact = false) {
   const summary = `${result.totalIndexed} indexed (${pc9.green(`+${result.added}`)} ${pc9.yellow(`~${result.changed}`)} ${pc9.dim(`=${result.unchanged}`)} ${pc9.red(`-${result.removed}`)}) in ${result.durationMs}ms`;
   console.log(compact ? pc9.dim(summary) : summary);
@@ -2202,8 +2353,59 @@ async function runInitWizard() {
   }
 }
 
-// src/cli/commands/learn.ts
+// src/cli/commands/journal.ts
 import pc10 from "picocolors";
+function registerJournalCommands(program, runSafely2) {
+  const journal = program.command("journal").description("Inspect or delete session journals and active-task checkpoints.");
+  journal.command("list", { isDefault: true }).description("List sessions with a checkpoint, newest first.").action(async () => {
+    await runSafely2(async () => {
+      const sessions = await listJournals(process.cwd());
+      if (sessions.length === 0) console.log(pc10.dim("no session journals yet"));
+      for (const { session, updatedAt } of sessions) console.log(`${updatedAt}  ${session}`);
+    });
+  });
+  journal.command("show").argument("<session>").description("Print a session's active-task checkpoint as JSON.").action(async (session) => {
+    await runSafely2(async () => {
+      const checkpoint = await readCheckpoint(process.cwd(), session);
+      console.log(checkpoint ? JSON.stringify(checkpoint, null, 2) : pc10.dim("no checkpoint"));
+    });
+  });
+  journal.command("resume").description("Print the newest unfinished task checkpoint (any session or agent).").action(async () => {
+    await runSafely2(async () => {
+      const checkpoint = await latestUnfinished(process.cwd(), void 0);
+      console.log(
+        checkpoint ? await renderCheckpointNow(
+          process.cwd(),
+          checkpoint,
+          `unfinished, from session ${checkpoint.session}`
+        ) : pc10.dim("no unfinished task in the last 3 days")
+      );
+    });
+  });
+  journal.command("import-codex").option("--all", "Import every Codex rollout for this repository, not only the newest.").description("Journal Codex rollouts (~/.codex/sessions) whose working directory is this repo.").action(async (opts) => {
+    await runSafely2(async () => {
+      const rollouts = await findCodexRollouts(process.cwd());
+      if (rollouts.length === 0) {
+        console.log(pc10.dim("no Codex rollout for this repository"));
+        return;
+      }
+      for (const rollout of opts.all ? rollouts : rollouts.slice(0, 1)) {
+        const result = await importCodexRollout(process.cwd(), rollout);
+        console.log(`codex-${rollout.id}: ${result ? `${result.added} new events` : "busy"}`);
+      }
+    });
+  });
+  journal.command("forget").argument("[session]").option("--all", "Delete every session's journal.").description("Delete a session's journal, cursor and checkpoint.").action(async (session, opts) => {
+    await runSafely2(async () => {
+      if (!session && !opts.all) throw new Error("Name a session or pass --all.");
+      await forgetJournal(process.cwd(), opts.all ? void 0 : session);
+      console.log(pc10.yellow(opts.all ? "deleted all session journals" : `deleted ${session}`));
+    });
+  });
+}
+
+// src/cli/commands/learn.ts
+import pc11 from "picocolors";
 
 // src/learning/outcomes.ts
 async function recordChangeOutcome(input) {
@@ -2264,15 +2466,15 @@ function registerLearnCommand(program, runSafely2) {
           ...opts.commit ? { commit: opts.commit } : {},
           ...opts.plan ? { planId: opts.plan } : {}
         });
-        console.log(`${pc10.green("recorded")} ${result.id} (${result.category})`);
-        console.log(pc10.dim(result.path));
+        console.log(`${pc11.green("recorded")} ${result.id} (${result.category})`);
+        console.log(pc11.dim(result.path));
       });
     }
   );
 }
 
 // src/cli/commands/map.ts
-import pc11 from "picocolors";
+import pc12 from "picocolors";
 function registerMapCommands(program, runSafely2) {
   const map = program.command("map").description("Query the lightweight architecture map.");
   map.command("build").description("Scan the current repository and summarize the module graph.").action(async () => {
@@ -2292,7 +2494,7 @@ function registerMapCommands(program, runSafely2) {
         return;
       }
       if (edges.length === 0) {
-        console.log(pc11.dim("no dependencies found"));
+        console.log(pc12.dim("no dependencies found"));
         return;
       }
       for (const edge of edges) console.log(`${edge.from} -> ${edge.to}`);
@@ -2307,7 +2509,7 @@ function registerMapCommands(program, runSafely2) {
         return;
       }
       if (result.edges.length === 0) {
-        console.log(pc11.dim("no dependents found"));
+        console.log(pc12.dim("no dependents found"));
         return;
       }
       for (const edge of result.edges) console.log(`${edge.from} -> ${edge.to}`);
@@ -2318,9 +2520,39 @@ function registerMapCommands(program, runSafely2) {
 // src/cli/commands/memory-review.ts
 import { spawn as spawn4 } from "child_process";
 import { relative as relative3 } from "path";
-import pc12 from "picocolors";
+import pc13 from "picocolors";
 function registerMemoryCommands(program, runSafely2) {
   const memory = program.command("memory").description("Inspect and curate CodeBuddy memory.");
+  memory.command("list").option(
+    "--origin <origin>",
+    "Only facts from this origin: index (extracted from the repository)."
+  ).option("--json", "Print machine-readable JSON.").description("List durable facts (Markdown under .codebuddy/memory/facts/).").action(async (opts) => {
+    await runSafely2(async () => {
+      if (opts.origin !== void 0 && opts.origin !== "index") {
+        throw new Error(`Unknown origin "${opts.origin}"; supported: index.`);
+      }
+      const facts = opts.origin === void 0 ? await new MemoryFileStore().listFacts() : await listIndexFacts(process.cwd());
+      if (opts.json) {
+        console.log(JSON.stringify(facts, null, 2));
+        return;
+      }
+      if (facts.length === 0) console.log(pc13.dim("no facts"));
+      for (const fact of facts) {
+        const source = fact.verification[0] ?? fact.paths[0];
+        console.log(`${pc13.cyan(fact.id)} ${fact.content}${source ? pc13.dim(` [${source}]`) : ""}`);
+      }
+    });
+  });
+  memory.command("prune").requiredOption("--origin <origin>", "Which facts to delete: index.").description("Delete facts by origin (index: re-extracted on the next index pass).").action(async (opts) => {
+    await runSafely2(async () => {
+      if (opts.origin !== "index")
+        throw new Error(`Unknown origin "${opts.origin}"; supported: index.`);
+      const removed = await pruneIndexFacts(process.cwd());
+      console.log(
+        `${removed} index fact(s) removed ${pc13.dim("(run `codebuddy hooks sync` to update the database)")}`
+      );
+    });
+  });
   const review = memory.command("review").description("Review memory candidates captured automatically after turns.");
   review.command("list", { isDefault: true }).option("--json", "Print machine-readable JSON.").description("List pending review candidates.").action(async (opts) => {
     await runSafely2(async () => {
@@ -2330,11 +2562,11 @@ function registerMemoryCommands(program, runSafely2) {
         return;
       }
       if (items.length === 0) {
-        console.log(pc12.dim("no pending review items"));
+        console.log(pc13.dim("no pending review items"));
         return;
       }
       for (const item of items) console.log(renderRow(item));
-      console.log(pc12.dim(`
+      console.log(pc13.dim(`
 ${items.length} pending. approve <id> | reject <id> | show <id>`));
     });
   });
@@ -2348,7 +2580,7 @@ ${items.length} pending. approve <id> | reject <id> | show <id>`));
       const factId = await approveReviewItem(id, {
         ...opts.incident !== void 0 ? { incidentId: opts.incident } : {}
       });
-      console.log(`${pc12.green("approved")} ${id} \u2192 ${factId}`);
+      console.log(`${pc13.green("approved")} ${id} \u2192 ${factId}`);
     });
   });
   review.command("reject").argument("<id>").description("Discard a review candidate without saving it.").action(async (id) => {
@@ -2356,7 +2588,7 @@ ${items.length} pending. approve <id> | reject <id> | show <id>`));
       const store = new ReviewStore();
       await store.read(id);
       await store.delete(id);
-      console.log(`${pc12.yellow("rejected")} ${id}`);
+      console.log(`${pc13.yellow("rejected")} ${id}`);
     });
   });
   review.command("edit").argument("<id>").description("Open a review candidate in $EDITOR and re-validate on save.").action(async (id) => {
@@ -2365,44 +2597,44 @@ ${items.length} pending. approve <id> | reject <id> | show <id>`));
       const item = await store.read(id);
       await openEditor(item.path);
       await store.read(id);
-      console.log(pc12.dim("saved and validated"));
+      console.log(pc13.dim("saved and validated"));
     });
   });
 }
 function renderRow(item) {
-  const flag = item.sensitive ? pc12.red(" \u26A0 sensitive") : "";
-  return `${classColor(item.class)}  ${pc12.dim(item.id)}  ${truncate(item.content, 70)}${flag}`;
+  const flag = item.sensitive ? pc13.red(" \u26A0 sensitive") : "";
+  return `${classColor(item.class)}  ${pc13.dim(item.id)}  ${truncate(item.content, 70)}${flag}`;
 }
 function renderItem(item) {
   const lines = [
-    `${classColor(item.class)}  ${pc12.dim(item.id)}`,
-    `${pc12.bold("reason:")} ${item.reason}`,
-    `${pc12.bold("confidence:")} ${item.confidence.toFixed(2)}`,
-    `${pc12.bold("triple:")} ${item.subject} \xB7 ${item.predicate} \xB7 ${item.object}`
+    `${classColor(item.class)}  ${pc13.dim(item.id)}`,
+    `${pc13.bold("reason:")} ${item.reason}`,
+    `${pc13.bold("confidence:")} ${item.confidence.toFixed(2)}`,
+    `${pc13.bold("triple:")} ${item.subject} \xB7 ${item.predicate} \xB7 ${item.object}`
   ];
-  if (item.paths.length > 0) lines.push(`${pc12.bold("paths:")} ${item.paths.join(", ")}`);
-  if (item.severity) lines.push(`${pc12.bold("severity:")} ${item.severity}`);
+  if (item.paths.length > 0) lines.push(`${pc13.bold("paths:")} ${item.paths.join(", ")}`);
+  if (item.severity) lines.push(`${pc13.bold("severity:")} ${item.severity}`);
   if (item.resolvesIncidents) {
     lines.push(
-      `${pc12.bold("resolves:")} ${item.resolvesIncidents.join(", ") || "(no candidate; approve with --incident <id>)"}`
+      `${pc13.bold("resolves:")} ${item.resolvesIncidents.join(", ") || "(no candidate; approve with --incident <id>)"}`
     );
   }
-  if (item.sensitive) lines.push(pc12.red(`\u26A0 sensitive: ${item.sensitiveReasons.join(", ")}`));
-  lines.push("", item.content, "", pc12.dim(relative3(process.cwd(), item.path)));
+  if (item.sensitive) lines.push(pc13.red(`\u26A0 sensitive: ${item.sensitiveReasons.join(", ")}`));
+  lines.push("", item.content, "", pc13.dim(relative3(process.cwd(), item.path)));
   return lines.join("\n");
 }
 function classColor(memoryClass) {
   switch (memoryClass) {
     case "incident":
-      return pc12.red(memoryClass);
+      return pc13.red(memoryClass);
     case "decision":
-      return pc12.cyan(memoryClass);
+      return pc13.cyan(memoryClass);
     case "fact":
-      return pc12.green(memoryClass);
+      return pc13.green(memoryClass);
     case "note":
-      return pc12.yellow(memoryClass);
+      return pc13.yellow(memoryClass);
     default:
-      return pc12.dim(memoryClass);
+      return pc13.dim(memoryClass);
   }
 }
 function truncate(value, max) {
@@ -2422,7 +2654,7 @@ function openEditor(path) {
 import { existsSync } from "fs";
 import { join as join5 } from "path";
 import { spinner as spinner2 } from "@clack/prompts";
-import pc13 from "picocolors";
+import pc14 from "picocolors";
 
 // evals/fact-relevance.json
 var fact_relevance_default = {
@@ -2686,9 +2918,9 @@ async function calibrateEmbedder(embed) {
 var EMBEDDERS = ["local", "huggingface", "openrouter"];
 var RERANKERS = ["off", "local", "huggingface", "openrouter"];
 var KEY_ENV2 = { huggingface: "HF_TOKEN", openrouter: "OPENROUTER_API_KEY" };
-var ok = (text3) => `${pc13.green("\u2713")} ${text3}`;
-var warn = (text3) => `${pc13.yellow("!")} ${text3}`;
-var row = (label, value) => `  ${pc13.dim(label.padEnd(11))}${value}`;
+var ok = (text3) => `${pc14.green("\u2713")} ${text3}`;
+var warn = (text3) => `${pc14.yellow("!")} ${text3}`;
+var row = (label, value) => `  ${pc14.dim(label.padEnd(11))}${value}`;
 async function withSpinner(label, work, done) {
   const progress = spinner2();
   progress.start(label);
@@ -2697,7 +2929,7 @@ async function withSpinner(label, work, done) {
     progress.stop(done(value));
     return value;
   } catch (error) {
-    progress.error(pc13.red(`\u2717 ${label}`));
+    progress.error(pc14.red(`\u2717 ${label}`));
     throw error;
   }
 }
@@ -2736,8 +2968,8 @@ async function printStatus() {
   const model = provider.type === "local" ? LOCAL_EMBEDDING_MODEL.id : provider.model ?? DEFAULT_CLOUD_EMBEDDING_MODELS[provider.type];
   const floor = provider.relevanceFloor ?? getModelDefinition(model)?.relevanceFloor;
   const next = [];
-  console.log(pc13.bold("Embeddings"));
-  console.log(row("provider", `${provider.type}  ${pc13.dim(model)}`));
+  console.log(pc14.bold("Embeddings"));
+  console.log(row("provider", `${provider.type}  ${pc14.dim(model)}`));
   if (provider.type === "local" && !localRuntimeInstalled()) {
     console.log(
       row("runtime", warn("@huggingface/transformers is not installed: dense recall is off"))
@@ -2748,7 +2980,7 @@ async function printStatus() {
     console.log(
       row(
         "model",
-        ready ? ok(`downloaded ${pc13.dim(modelCacheDir())}`) : warn("not downloaded yet (~90 MB)")
+        ready ? ok(`downloaded ${pc14.dim(modelCacheDir())}`) : warn("not downloaded yet (~90 MB)")
       )
     );
     if (!ready) next.push("codebuddy models pull");
@@ -2765,21 +2997,21 @@ async function printStatus() {
   console.log(
     row(
       "floor",
-      floor !== void 0 ? `${floor} ${pc13.dim(provider.relevanceFloor !== void 0 ? "(calibrated for this project)" : "(built-in)")}` : warn("not calibrated: dense recall is off for this model")
+      floor !== void 0 ? `${floor} ${pc14.dim(provider.relevanceFloor !== void 0 ? "(calibrated for this project)" : "(built-in)")}` : warn("not calibrated: dense recall is off for this model")
     )
   );
   if (floor === void 0) next.push("codebuddy models calibrate");
   const rerank = file.rerank?.provider ?? "off";
-  console.log(pc13.bold("Reranker"));
+  console.log(pc14.bold("Reranker"));
   if (rerank === "off") {
     console.log(
-      row("provider", `off ${pc13.dim("(default: no reranker beat dense order in evals)")}`)
+      row("provider", `off ${pc14.dim("(default: no reranker beat dense order in evals)")}`)
     );
   } else {
     console.log(
       row(
         "provider",
-        `${rerank}  ${pc13.dim(file.rerank?.model ?? DEFAULT_RERANK_MODELS[rerank].id)}`
+        `${rerank}  ${pc14.dim(file.rerank?.model ?? DEFAULT_RERANK_MODELS[rerank].id)}`
       )
     );
     if (rerank !== "local") {
@@ -2792,7 +3024,11 @@ async function printStatus() {
       );
     }
   }
-  console.log(pc13.bold("Memory index"));
+  {
+    const { cardProgress } = await import("./summaries-QXWFFDUZ.js");
+    await printLocalLlmStatus(await cardProgress(process.cwd()).catch(() => null));
+  }
+  console.log(pc14.bold("Memory index"));
   if (process.env.CODEBUDDY_SEMANTIC === "0") {
     console.log(row("recall", warn("CODEBUDDY_SEMANTIC=0: lexical only")));
   }
@@ -2813,7 +3049,7 @@ async function printStatus() {
       console.log(
         row(
           "vectors",
-          `${counts.ready} ready` + (counts.pending ? `, ${counts.pending} pending` : "") + (counts.failed ? pc13.red(`, ${counts.failed} failed`) : "") + (counts.other ? pc13.yellow(`, ${counts.other} from another model`) : "")
+          `${counts.ready} ready` + (counts.pending ? `, ${counts.pending} pending` : "") + (counts.failed ? pc14.red(`, ${counts.failed} failed`) : "") + (counts.other ? pc14.yellow(`, ${counts.other} from another model`) : "")
         )
       );
       if (counts.pending || counts.other)
@@ -2822,9 +3058,9 @@ async function printStatus() {
   }
   console.log(
     next.length > 0 ? `
-${pc13.bold("Next")}
-${next.map((step) => `  ${pc13.cyan(step)}`).join("\n")}` : `
-${ok("Semantic recall is ready.")} ${pc13.dim('Try: codebuddy context preview "<task>"')}`
+${pc14.bold("Next")}
+${next.map((step) => `  ${pc14.cyan(step)}`).join("\n")}` : `
+${ok("Semantic recall is ready.")} ${pc14.dim('Try: codebuddy context preview "<task>"')}`
   );
 }
 function registerModelsCommands(program, runSafely2) {
@@ -2861,27 +3097,27 @@ Examples:
         ...opts.floor !== void 0 ? { relevanceFloor: opts.floor } : {}
       });
       const model = type === "local" ? LOCAL_EMBEDDING_MODEL.id : opts.model ?? DEFAULT_CLOUD_EMBEDDING_MODELS[type];
-      console.log(ok(`Embeddings: ${type} ${pc13.dim(model)}`));
+      console.log(ok(`Embeddings: ${type} ${pc14.dim(model)}`));
       const missingKey = type !== "local" && !keyPresent(type, current?.apiKey);
       if (missingKey) {
         console.log(
           warn(
-            `Set ${KEY_ENV2[type]} in your shell (keys are never stored in config), then run ${pc13.cyan("codebuddy hooks sync")}.`
+            `Set ${KEY_ENV2[type]} in your shell (keys are never stored in config), then run ${pc14.cyan("codebuddy hooks sync")}.`
           )
         );
-        console.log(pc13.dim("  Existing vectors keep working until the new model can embed."));
+        console.log(pc14.dim("  Existing vectors keep working until the new model can embed."));
       }
       if (opts.floor === void 0 && getModelDefinition(model)?.relevanceFloor === void 0) {
         console.log(
           warn(
-            `No floor for ${model} yet: run ${pc13.cyan("codebuddy models calibrate")} to turn on dense recall.`
+            `No floor for ${model} yet: run ${pc14.cyan("codebuddy models calibrate")} to turn on dense recall.`
           )
         );
       }
       if (!missingKey) {
         syncInBackground(process.cwd(), true);
         console.log(
-          pc13.dim("  Re-embedding existing memory in the background (codebuddy hooks sync).")
+          pc14.dim("  Re-embedding existing memory in the background (codebuddy hooks sync).")
         );
       }
     });
@@ -2908,13 +3144,36 @@ before keeping one on. A reranker never admits a fact, it only orders them.`
       }
       const reranker = choice;
       console.log(
-        ok(`Reranker: ${reranker} ${pc13.dim(opts.model ?? DEFAULT_RERANK_MODELS[reranker].id)}`)
+        ok(`Reranker: ${reranker} ${pc14.dim(opts.model ?? DEFAULT_RERANK_MODELS[reranker].id)}`)
       );
       if (reranker !== "local" && !keyPresent(reranker, (await readConfigFile()).provider?.apiKey)) {
         console.log(warn(`Set ${KEY_ENV2[reranker]}; without it reranking is skipped.`));
       }
       if (reranker === "local")
-        console.log(pc13.dim("  Run codebuddy models pull to download it now."));
+        console.log(pc14.dim("  Run codebuddy models pull to download it now."));
+    });
+  });
+  models.command("add").argument("<name>", "Optional model to install: local-llm.").option("--size <size>", `Local LLM size: ${LOCAL_LLM_SIZES.join(" | ")}.`, "default").option("-y, --yes", "Install the runtime without asking.").description(
+    "Download the optional local LLM (Qwen3-0.6B by default) that writes file cards and index facts."
+  ).action(async (name2, opts) => {
+    await runSafely2(async () => {
+      if (name2 !== "local-llm") throw new Error(`Unknown model "${name2}"; try: local-llm.`);
+      if (!LOCAL_LLM_SIZES.includes(opts.size)) {
+        throw new Error(`--size must be one of ${LOCAL_LLM_SIZES.join(", ")}.`);
+      }
+      const added = await addLocalLlm({
+        size: opts.size,
+        ...opts.yes ? { yes: true } : {}
+      });
+      if (!added) process.exitCode = 1;
+    });
+  });
+  models.command("remove").argument("<name>", "Optional model to remove: local-llm.").description(
+    "Delete the local LLM weights; CodeBuddy falls back to keyword/vector-only behaviour."
+  ).action(async (name2) => {
+    await runSafely2(async () => {
+      if (name2 !== "local-llm") throw new Error(`Unknown model "${name2}"; try: local-llm.`);
+      await removeLocalLlm();
     });
   });
   models.command("pull").description("Download the local models now instead of on first use.").action(async () => {
@@ -2925,7 +3184,7 @@ before keeping one on. A reranker never admits a fact, it only orders them.`
       await withSpinner(
         `Downloading ${LOCAL_EMBEDDING_MODEL.id}`,
         () => new LocalModelProvider().embed({ input: "warm up" }),
-        () => ok(`${LOCAL_EMBEDDING_MODEL.id} ready ${pc13.dim(`${Date.now() - started} ms`)}`)
+        () => ok(`${LOCAL_EMBEDDING_MODEL.id} ready ${pc14.dim(`${Date.now() - started} ms`)}`)
       );
       if (file.rerank?.provider === "local") {
         const id = file.rerank.model ?? DEFAULT_RERANK_MODELS.local.id;
@@ -2934,10 +3193,10 @@ before keeping one on. A reranker never admits a fact, it only orders them.`
         await withSpinner(
           `Downloading ${id}`,
           () => rerankLocally({ id, ...revision ? { revision } : {} }, "warm", ["up"]),
-          () => ok(`${id} ready ${pc13.dim(`${Date.now() - started} ms`)}`)
+          () => ok(`${id} ready ${pc14.dim(`${Date.now() - started} ms`)}`)
         );
       }
-      console.log(pc13.dim(`  Cache: ${modelCacheDir()}`));
+      console.log(pc14.dim(`  Cache: ${modelCacheDir()}`));
     });
   });
   models.command("calibrate").option("--dry-run", "Measure only; do not save the floor.").description(
@@ -2955,19 +3214,19 @@ before keeping one on. A reranker never admits a fact, it only orders them.`
       console.log(
         row(
           "ranking",
-          `AUC ${result.auc.toFixed(3)} \xB7 right fact first ${pct(result.recallAt1)} ${pc13.dim("(held-out tasks)")}`
+          `AUC ${result.auc.toFixed(3)} \xB7 right fact first ${pct(result.recallAt1)} ${pc14.dim("(held-out tasks)")}`
         )
       );
       console.log(
         row(
           "floor",
-          `${result.best.floor}: precision ${pct(result.test.precision)}, recall ${pct(result.test.recall)}, silent on ${pct(result.test.abstain)} of unrelated tasks ${pc13.dim("(chosen on dev, measured on test)")}`
+          `${result.best.floor}: precision ${pct(result.test.precision)}, recall ${pct(result.test.recall)}, silent on ${pct(result.test.abstain)} of unrelated tasks ${pc14.dim("(chosen on dev, measured on test)")}`
         )
       );
       console.log(
         row(
           "recall floor",
-          `${result.recall.dev.floor}: precision ${pct(result.recall.test.precision)}, recall ${pct(result.recall.test.recall)} ` + pc13.dim("(explicit recall: best F2 on dev, measured on test)")
+          `${result.recall.dev.floor}: precision ${pct(result.recall.test.precision)}, recall ${pct(result.recall.test.recall)} ` + pc14.dim("(explicit recall: best F2 on dev, measured on test)")
         )
       );
       if (opts.dryRun) return;
@@ -2986,10 +3245,238 @@ before keeping one on. A reranker never admits a fact, it only orders them.`
   });
 }
 
-// src/cli/commands/plan.ts
+// src/cli/commands/output.ts
 import { spawn as spawn5 } from "child_process";
+import { constants as constants2 } from "os";
+import pc15 from "picocolors";
+
+// src/output/reduce.ts
+import { createHash } from "crypto";
+import { mkdir as mkdir2, readdir, readFile as readFile3, rm as rm2 } from "fs/promises";
+import { join as join6 } from "path";
+var OUTPUT_LIMITS = {
+  /** At or below either, output is never reduced. */
+  minLines: 80,
+  minBytes: 6e3,
+  head: 20,
+  tail: 30,
+  contextBefore: 2,
+  contextAfter: 4,
+  /** A reduction must save at least this share, or the original is printed. */
+  minSaving: 0.3,
+  /** Stored bytes per run; beyond this the stored copy says it was cut. */
+  storeBytes: 2e7,
+  retentionDays: 7,
+  /** Lines one `output show` may print. */
+  showLines: 400
+};
+var SIGNAL = /\b(error|errors|fail|failed|failure|failing|exception|traceback|panic|fatal|assert(?:ion)?|warn(?:ing)?|denied|not found|undefined|segfault|timeout|timed out)\b|✗|×|✖|FAIL|ERR!/i;
+function outputDir(root) {
+  return join6(root, ".codebuddy", "cache", "outputs");
+}
+var shape = (line) => line.replace(/\d+/g, "#").trim();
+function reduceOutput(text3, id) {
+  const lines = text3.split("\n");
+  if (lines.length <= OUTPUT_LIMITS.minLines || Buffer.byteLength(text3) <= OUTPUT_LIMITS.minBytes) {
+    return null;
+  }
+  if (text3.includes("\0")) return null;
+  const keep = /* @__PURE__ */ new Set();
+  for (let i = 0; i < Math.min(OUTPUT_LIMITS.head, lines.length); i++) keep.add(i);
+  for (let i = Math.max(0, lines.length - OUTPUT_LIMITS.tail); i < lines.length; i++) keep.add(i);
+  lines.forEach((line, index2) => {
+    if (!SIGNAL.test(line)) return;
+    const from = Math.max(0, index2 - OUTPUT_LIMITS.contextBefore);
+    const to = Math.min(lines.length - 1, index2 + OUTPUT_LIMITS.contextAfter);
+    for (let i = from; i <= to; i++) keep.add(i);
+  });
+  const out = [];
+  let index = 0;
+  while (index < lines.length) {
+    if (!keep.has(index)) {
+      const start = index;
+      while (index < lines.length && !keep.has(index)) index++;
+      out.push(
+        `\u2026 ${index - start} lines omitted (codebuddy output show ${id} --range ${start + 1}:${index})`
+      );
+      continue;
+    }
+    const line = lines[index];
+    const same = SIGNAL.test(line) ? (other) => other === line : (other) => shape(other) === shape(line);
+    let run = index + 1;
+    while (run < lines.length && keep.has(run) && same(lines[run])) run++;
+    out.push(line);
+    if (run - index > 2) {
+      out.push(
+        `\u2026 ${run - index - 1} similar lines (codebuddy output show ${id} --range ${index + 2}:${run})`
+      );
+      index = run;
+    } else index++;
+  }
+  const reduced = out.join("\n");
+  return Buffer.byteLength(reduced) <= Buffer.byteLength(text3) * (1 - OUTPUT_LIMITS.minSaving) ? reduced : null;
+}
+async function storeOutput(root, command, output, exitCode, now = /* @__PURE__ */ new Date()) {
+  const truncated = Buffer.byteLength(output) > OUTPUT_LIMITS.storeBytes;
+  const body = truncated ? `${output.slice(0, OUTPUT_LIMITS.storeBytes)}
+[codebuddy: stored copy cut at ${OUTPUT_LIMITS.storeBytes} bytes]` : output;
+  const id = createHash("sha256").update(`${command}\0${now.toISOString()}\0${body}`).digest("hex").slice(0, 12);
+  const meta = {
+    id,
+    command,
+    exitCode,
+    createdAt: now.toISOString(),
+    expiresAt: new Date(now.getTime() + OUTPUT_LIMITS.retentionDays * 864e5).toISOString(),
+    lines: body.split("\n").length,
+    bytes: Buffer.byteLength(body),
+    truncated
+  };
+  const dir = outputDir(root);
+  await mkdir2(dir, { recursive: true, mode: 448 });
+  await writeAtomic(join6(dir, `${id}.log`), body, { mode: 384 });
+  await writeAtomic(join6(dir, `${id}.json`), `${JSON.stringify(meta)}
+`, { mode: 384 });
+  await pruneOutputs(root, now).catch(() => void 0);
+  return meta;
+}
+async function pruneOutputs(root, now = /* @__PURE__ */ new Date()) {
+  const dir = outputDir(root);
+  let removed = 0;
+  for (const name2 of (await readdir(dir).catch(() => [])).filter(
+    (n) => n.endsWith(".json")
+  )) {
+    const meta = await readMeta(root, name2.slice(0, -5));
+    if (meta && Date.parse(meta.expiresAt) <= now.getTime()) {
+      await rm2(join6(dir, `${meta.id}.log`), { force: true });
+      await rm2(join6(dir, name2), { force: true });
+      removed++;
+    }
+  }
+  return removed;
+}
+async function readMeta(root, id) {
+  if (!/^[a-f0-9]{12}$/.test(id)) return null;
+  try {
+    return JSON.parse(await readFile3(join6(outputDir(root), `${id}.json`), "utf8"));
+  } catch {
+    return null;
+  }
+}
+async function showOutput(root, id, options = {}) {
+  const meta = await readMeta(root, id);
+  if (!meta) return { status: "missing", id };
+  if (Date.parse(meta.expiresAt) <= (options.now ?? /* @__PURE__ */ new Date()).getTime()) {
+    return { status: "expired", id };
+  }
+  const body = await readFile3(join6(outputDir(root), `${id}.log`), "utf8").catch(() => null);
+  if (body === null) return { status: "missing", id };
+  const lines = body.split("\n");
+  let picked;
+  if (options.grep) {
+    const pattern = new RegExp(options.grep, "i");
+    const set = /* @__PURE__ */ new Set();
+    lines.forEach((line, index) => {
+      if (!pattern.test(line)) return;
+      for (let i = Math.max(0, index - 2); i <= Math.min(lines.length - 1, index + 2); i++)
+        set.add(i);
+    });
+    picked = [...set].sort((a, b) => a - b);
+  } else {
+    const [from, to] = options.range ?? [1, lines.length];
+    picked = [];
+    for (let i = Math.max(1, from); i <= Math.min(lines.length, to); i++) picked.push(i - 1);
+  }
+  const shown = picked.slice(0, OUTPUT_LIMITS.showLines);
+  return {
+    status: "ok",
+    meta,
+    text: shown.map((i) => `${i + 1}: ${lines[i]}`).join("\n"),
+    more: picked.length > shown.length
+  };
+}
+async function listOutputs(root) {
+  const names = await readdir(outputDir(root)).catch(() => []);
+  const metas = await Promise.all(
+    names.filter((n) => n.endsWith(".json")).map((n) => readMeta(root, n.slice(0, -5)))
+  );
+  return metas.filter((meta) => meta !== null).sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+}
+
+// src/cli/commands/output.ts
+function registerOutputCommands(program, runSafely2) {
+  program.command("run").argument("<command...>", "The command and its arguments (after --).").description(
+    "Run a command; print a reduced view of long output and keep the original for `codebuddy output show`."
+  ).action(async (parts) => {
+    await runSafely2(async () => {
+      const command = parts.join(" ");
+      const { output: output2, exitCode } = await capture(parts);
+      const root = process.cwd();
+      const provisional = reduceOutput(output2, "xxxxxxxxxxxx");
+      if (provisional === null) {
+        process.stdout.write(output2);
+      } else {
+        const stored = await storeOutput(root, command, output2, exitCode);
+        const reduced = reduceOutput(output2, stored.id) ?? output2;
+        process.stdout.write(`${reduced}
+`);
+        process.stdout.write(
+          `[codebuddy run: exit ${exitCode ?? "signal"}; ${stored.lines} lines shown as ${reduced.split("\n").length}; full output: codebuddy output show ${stored.id} [--grep RE | --range A:B], kept until ${stored.expiresAt.slice(0, 10)}]
+`
+        );
+      }
+      process.exitCode = exitCode ?? 1;
+    });
+  });
+  const output = program.command("output").description("Stored originals of `codebuddy run` output.");
+  output.command("list", { isDefault: true }).description("List stored outputs, newest first.").action(async () => {
+    await runSafely2(async () => {
+      const stored = await listOutputs(process.cwd());
+      if (stored.length === 0) console.log(pc15.dim("no stored outputs"));
+      for (const meta of stored) {
+        console.log(
+          `${meta.id}  exit ${meta.exitCode ?? "-"}  ${meta.lines} lines  until ${meta.expiresAt.slice(0, 10)}  ${meta.command.slice(0, 80)}`
+        );
+      }
+    });
+  });
+  output.command("show").argument("<id>").option("--range <a:b>", "1-based inclusive line range.").option("--grep <pattern>", "Lines matching a regular expression, with 2 lines of context.").description("Print exact stored lines (at most 400 per call).").action(async (id, opts) => {
+    await runSafely2(async () => {
+      const range = opts.range?.match(/^(\d+):(\d+)$/);
+      if (opts.range && !range) throw new Error("--range must look like 120:180");
+      const result = await showOutput(process.cwd(), id, {
+        ...range ? { range: [Number(range[1]), Number(range[2])] } : {},
+        ...opts.grep ? { grep: opts.grep } : {}
+      });
+      if (result.status !== "ok") {
+        throw new Error(`stored output ${id} is ${result.status}`);
+      }
+      console.log(result.text);
+      if (result.more) console.log(pc15.dim("\u2026 more lines; narrow --range or --grep"));
+    });
+  });
+}
+function capture(parts) {
+  return new Promise((resolve6, reject) => {
+    const [file, ...args] = parts;
+    const child = parts.length === 1 ? spawn5(file, { shell: true, stdio: ["inherit", "pipe", "pipe"] }) : spawn5(file, args, { stdio: ["inherit", "pipe", "pipe"] });
+    const chunks = [];
+    child.stdout.on("data", (chunk) => chunks.push(chunk));
+    child.stderr.on("data", (chunk) => chunks.push(chunk));
+    child.on("error", reject);
+    child.on(
+      "close",
+      (code, signal) => resolve6({
+        output: Buffer.concat(chunks).toString("utf8"),
+        exitCode: code ?? (signal ? 128 + (constants2.signals[signal] ?? 0) : null)
+      })
+    );
+  });
+}
+
+// src/cli/commands/plan.ts
+import { spawn as spawn6 } from "child_process";
 import { relative as relative4 } from "path";
-import pc14 from "picocolors";
+import pc16 from "picocolors";
 function makeLifecycle(cwd = process.cwd()) {
   const store = new PlanFileStore(cwd);
   return { store, lifecycle: new PlanLifecycle(store) };
@@ -2997,67 +3484,67 @@ function makeLifecycle(cwd = process.cwd()) {
 function statusColor(status) {
   switch (status) {
     case "draft":
-      return pc14.dim(status);
+      return pc16.dim(status);
     case "approved":
-      return pc14.cyan(status);
+      return pc16.cyan(status);
     case "executing":
-      return pc14.yellow(status);
+      return pc16.yellow(status);
     case "complete":
-      return pc14.green(status);
+      return pc16.green(status);
     case "abandoned":
-      return pc14.red(status);
+      return pc16.red(status);
   }
 }
 function renderPlan(plan) {
   const lines = [];
-  lines.push(`${pc14.bold(plan.title)}  ${statusColor(plan.status)}`);
-  lines.push(pc14.dim(plan.id));
+  lines.push(`${pc16.bold(plan.title)}  ${statusColor(plan.status)}`);
+  lines.push(pc16.dim(plan.id));
   lines.push("");
-  lines.push(`${pc14.bold("Brief:")} ${plan.brief}`);
+  lines.push(`${pc16.bold("Brief:")} ${plan.brief}`);
   if (plan.filesToTouch.length > 0) {
     lines.push("");
-    lines.push(pc14.bold("Files to touch:"));
+    lines.push(pc16.bold("Files to touch:"));
     for (const file of plan.filesToTouch) {
       lines.push(`  ${file.action.padEnd(6)} ${file.path}${file.notes ? `  \u2014 ${file.notes}` : ""}`);
     }
   }
   if (plan.testsToAdd.length > 0) {
     lines.push("");
-    lines.push(pc14.bold("Tests to add:"));
+    lines.push(pc16.bold("Tests to add:"));
     for (const test of plan.testsToAdd) {
       lines.push(`  ${test.path}${test.description ? `  \u2014 ${test.description}` : ""}`);
     }
   }
   if (plan.outOfScope.length > 0) {
     lines.push("");
-    lines.push(pc14.bold("Out of scope:"));
+    lines.push(pc16.bold("Out of scope:"));
     for (const item of plan.outOfScope) lines.push(`  - ${item}`);
   }
   if (plan.risks.length > 0) {
     lines.push("");
-    lines.push(pc14.bold("Risks:"));
+    lines.push(pc16.bold("Risks:"));
     for (const item of plan.risks) lines.push(`  - ${item}`);
   }
   if (plan.commitSha) {
     lines.push("");
-    lines.push(`${pc14.bold("Commit:")} ${plan.commitSha}`);
+    lines.push(`${pc16.bold("Commit:")} ${plan.commitSha}`);
   }
   lines.push("");
-  lines.push(pc14.dim("\u2500".repeat(40)));
+  lines.push(pc16.dim("\u2500".repeat(40)));
   lines.push(plan.body);
   return lines.join("\n");
 }
 function openEditor2(path) {
   const editor = process.env.EDITOR ?? process.env.VISUAL ?? "vi";
   return new Promise((resolve6, reject) => {
-    const child = spawn5(editor, [path], { stdio: "inherit" });
+    const child = spawn6(editor, [path], { stdio: "inherit" });
     child.on("error", reject);
     child.on("close", () => resolve6());
   });
 }
 function runGit(args) {
   return new Promise((resolve6, reject) => {
-    const child = spawn5("git", args, { stdio: ["ignore", "pipe", "pipe"] });
+    const child = spawn6("git", args, { stdio: ["ignore", "pipe", "pipe"] });
     let stdout = "";
     let stderr = "";
     child.stdout.on("data", (c) => {
@@ -3082,14 +3569,14 @@ function registerPlanCommands(program, runSafely2) {
         title: opts.title ?? brief,
         brief
       });
-      console.log(`${pc14.green("created")} ${created.id} (${statusColor(created.status)})`);
+      console.log(`${pc16.green("created")} ${created.id} (${statusColor(created.status)})`);
       if (opts.edit !== false && process.stdin.isTTY) {
         await openEditor2(created.path);
         const { store } = makeLifecycle();
         await store.readPlan(created.id);
-        console.log(pc14.dim("saved and validated"));
+        console.log(pc16.dim("saved and validated"));
       }
-      console.log(pc14.dim(relative4(process.cwd(), created.path)));
+      console.log(pc16.dim(relative4(process.cwd(), created.path)));
     });
   });
   plan.command("list").option("--status <status>", "Filter by status.").option("--all", "Include completed and abandoned plans.").description("List plans in the current namespace.").action(async (opts) => {
@@ -3101,11 +3588,11 @@ function registerPlanCommands(program, runSafely2) {
       else if (!opts.all)
         plans = plans.filter((p) => p.status !== "complete" && p.status !== "abandoned");
       if (plans.length === 0) {
-        console.log(pc14.dim("no plans"));
+        console.log(pc16.dim("no plans"));
         return;
       }
       for (const p of plans) {
-        console.log(`${statusColor(p.status).padEnd(20)} ${pc14.bold(p.title)}  ${pc14.dim(p.id)}`);
+        console.log(`${statusColor(p.status).padEnd(20)} ${pc16.bold(p.title)}  ${pc16.dim(p.id)}`);
       }
     });
   });
@@ -3121,7 +3608,7 @@ function registerPlanCommands(program, runSafely2) {
       const existing = await store.readPlan(id);
       await openEditor2(existing.path);
       await store.readPlan(id);
-      console.log(pc14.dim("saved and validated"));
+      console.log(pc16.dim("saved and validated"));
     });
   });
   plan.command("approve").argument("<id>").description("Promote a draft to approved (one active plan per namespace).").action(async (id) => {
@@ -3145,7 +3632,7 @@ function registerPlanCommands(program, runSafely2) {
         ...opts.commit ? { commitSha: opts.commit } : {},
         ...opts.notes ? { notes: opts.notes } : {}
       });
-      if (!opts.commit) console.log(pc14.yellow("note: no --commit supplied"));
+      if (!opts.commit) console.log(pc16.yellow("note: no --commit supplied"));
       console.log(`${next.id} \u2192 ${statusColor(next.status)}`);
     });
   });
@@ -3164,7 +3651,7 @@ function registerPlanCommands(program, runSafely2) {
       const args = ["diff", opts.from, ...opts.to ? [opts.to] : [], "--", relPath];
       const result = await runGit(args);
       if (result.stdout.trim().length === 0) {
-        console.log(pc14.dim("no changes"));
+        console.log(pc16.dim("no changes"));
       } else {
         process.stdout.write(result.stdout);
       }
@@ -3181,13 +3668,13 @@ function registerPlanCommands(program, runSafely2) {
         throw new Error(`Invalid policy "${mode}". Use one of: ${PLAN_POLICIES.join(", ")}.`);
       }
       await setPlanPolicy(mode);
-      console.log(`${pc14.green("plan policy")} = ${mode}`);
+      console.log(`${pc16.green("plan policy")} = ${mode}`);
     });
   });
 }
 
 // src/cli/commands/risk.ts
-import pc15 from "picocolors";
+import pc17 from "picocolors";
 function registerRiskCommands(program, runSafely2) {
   const risk = program.command("risk").description("Assess evidence-backed change risk.");
   risk.command("assess").option("--plan <id>", "Assess paths listed in a CodeBuddy plan.").option("--paths <paths>", "Comma-separated repo-relative paths to assess.").option("--git", "Assess staged, unstaged, and untracked git changes.").option("--limit <n>", "Maximum risk items to show.", Number).option("--json", "Print machine-readable JSON.").option("--explain", "Show evidence for each risk item.").description("Assess risk for a plan, explicit paths, or current git changes.").action(
@@ -3215,31 +3702,31 @@ function parsePaths3(value) {
 }
 function printAssessment(assessment, explain) {
   if (assessment.items.length === 0) {
-    console.log(pc15.dim("no risk evidence found"));
+    console.log(pc17.dim("no risk evidence found"));
     return;
   }
   for (const item of assessment.items) {
     console.log(
-      `${pc15.bold(item.path)}  score ${scoreColor2(item.score)}  category ${pc15.cyan(item.category)}`
+      `${pc17.bold(item.path)}  score ${scoreColor2(item.score)}  category ${pc17.cyan(item.category)}`
     );
     console.log(`  ${item.reason}`);
     if (explain) {
       for (const evidence of item.evidence) console.log(`  \u21B3 ${formatEvidence(evidence)}`);
     } else {
-      console.log(pc15.dim(`  ${item.evidence.length} evidence item(s)`));
+      console.log(pc17.dim(`  ${item.evidence.length} evidence item(s)`));
     }
   }
   console.log(
-    pc15.dim(
+    pc17.dim(
       `
 ${assessment.stats.itemsProduced} item(s), ${assessment.stats.signalsRun} signal(s), ${assessment.stats.pathsConsidered} path(s) considered`
     )
   );
 }
 function scoreColor2(score) {
-  if (score >= 75) return pc15.red(String(score));
-  if (score >= 50) return pc15.yellow(String(score));
-  return pc15.green(String(score));
+  if (score >= 75) return pc17.red(String(score));
+  if (score >= 50) return pc17.yellow(String(score));
+  return pc17.green(String(score));
 }
 function formatEvidence(evidence) {
   switch (evidence.kind) {
@@ -3261,7 +3748,7 @@ function truncate2(value, max) {
 
 // src/cli/commands/rules.ts
 import { relative as relative5 } from "path";
-import pc16 from "picocolors";
+import pc18 from "picocolors";
 async function resolveMode(client, value) {
   if (value) {
     const mode = parseMode(value);
@@ -3301,7 +3788,7 @@ function registerRulesCommands(program, runSafely2) {
         `${actionLabel(result.action)} ${clientDisplayName(client)} workflow in ${where}`
       );
       if (result.action !== "unchanged") {
-        console.log(pc16.dim("  managed block between codebuddy:workflow markers; safe to re-run"));
+        console.log(pc18.dim("  managed block between codebuddy:workflow markers; safe to re-run"));
       }
     });
   });
@@ -3309,20 +3796,20 @@ function registerRulesCommands(program, runSafely2) {
 function actionLabel(action) {
   switch (action) {
     case "created":
-      return pc16.green("created");
+      return pc18.green("created");
     case "added":
-      return pc16.green("added");
+      return pc18.green("added");
     case "updated":
-      return pc16.cyan("updated");
+      return pc18.cyan("updated");
     case "removed":
-      return pc16.yellow("removed");
+      return pc18.yellow("removed");
     default:
-      return pc16.dim("unchanged");
+      return pc18.dim("unchanged");
   }
 }
 
 // src/cli/commands/suggest.ts
-import pc17 from "picocolors";
+import pc19 from "picocolors";
 function parsePaths4(value) {
   return value.split(",").map((path) => path.trim()).filter(Boolean);
 }
@@ -3344,7 +3831,7 @@ function registerSuggestCommand(program, runSafely2) {
         }
         printSuggestions(result.suggestions);
         console.log(
-          pc17.dim(
+          pc19.dim(
             `
 ${result.stats.produced} suggestion(s) across ${result.stats.pathsConsidered} path(s)`
           )
@@ -3355,72 +3842,72 @@ ${result.stats.produced} suggestion(s) across ${result.stats.pathsConsidered} pa
 }
 function printSuggestions(suggestions) {
   if (suggestions.length === 0) {
-    console.log(pc17.dim("no suggestions \u2014 nothing high-signal to report"));
+    console.log(pc19.dim("no suggestions \u2014 nothing high-signal to report"));
     return;
   }
   for (const suggestion of suggestions) {
-    console.log(`${severityBadge2(suggestion.severity)} ${pc17.bold(suggestion.title)}`);
+    console.log(`${severityBadge2(suggestion.severity)} ${pc19.bold(suggestion.title)}`);
     console.log(`  ${suggestion.detail}`);
     for (const evidence of suggestion.evidence) {
-      console.log(pc17.dim(`  \u21B3 ${evidence.kind}: ${evidence.detail}`));
+      console.log(pc19.dim(`  \u21B3 ${evidence.kind}: ${evidence.detail}`));
     }
-    if (suggestion.commandHint) console.log(pc17.dim(`  \u2192 ${suggestion.commandHint}`));
+    if (suggestion.commandHint) console.log(pc19.dim(`  \u2192 ${suggestion.commandHint}`));
   }
 }
 function severityBadge2(severity) {
   switch (severity) {
     case "high":
-      return pc17.red("[high]");
+      return pc19.red("[high]");
     case "medium":
-      return pc17.yellow("[med ]");
+      return pc19.yellow("[med ]");
     case "low":
-      return pc17.cyan("[low ]");
+      return pc19.cyan("[low ]");
     default:
-      return pc17.dim("[info]");
+      return pc19.dim("[info]");
   }
 }
 
 // src/cli/commands/symbols.ts
-import { readFile as readFile3 } from "fs/promises";
+import { readFile as readFile4 } from "fs/promises";
 import { resolve as resolve5 } from "path";
-import pc18 from "picocolors";
+import pc20 from "picocolors";
 function registerSymbolsCommand(program, runSafely2) {
   program.command("symbols").argument("<path>", "Repo-relative or absolute path to a code file.").option("--json", "Print machine-readable JSON.").description("List a file's top-level symbols (functions, classes, types, exports).").action(async (path, opts) => {
     await runSafely2(async () => {
       if (!supportsSymbols(path)) {
-        console.log(pc18.dim(`no symbol extraction for ${path} (unsupported language)`));
+        console.log(pc20.dim(`no symbol extraction for ${path} (unsupported language)`));
         return;
       }
-      const content = await readFile3(resolve5(path), "utf8");
+      const content = await readFile4(resolve5(path), "utf8");
       const table = extractSymbolTable(content, path);
       if (opts.json) {
         console.log(JSON.stringify({ path, symbols: table }, null, 2));
         return;
       }
       if (table.length === 0) {
-        console.log(pc18.dim("no top-level symbols found"));
+        console.log(pc20.dim("no top-level symbols found"));
         return;
       }
       for (const symbol of table) {
-        const badge = symbol.exported ? pc18.green("export") : pc18.dim("local ");
+        const badge = symbol.exported ? pc20.green("export") : pc20.dim("local ");
         console.log(
-          `${badge} ${pc18.cyan(symbol.kind.padEnd(9))} ${pc18.bold(symbol.name)} ${pc18.dim(`L${symbol.startLine}-${symbol.endLine}`)}`
+          `${badge} ${pc20.cyan(symbol.kind.padEnd(9))} ${pc20.bold(symbol.name)} ${pc20.dim(`L${symbol.startLine}-${symbol.endLine}`)}`
         );
       }
-      console.log(pc18.dim(`
+      console.log(pc20.dim(`
 ${table.length} symbol(s)`));
     });
   });
 }
 
 // src/cli/commands/telemetry.ts
-import pc19 from "picocolors";
+import pc21 from "picocolors";
 
 // src/telemetry/collector.ts
-import { createHash, timingSafeEqual } from "crypto";
-import { appendFile, mkdir as mkdir2, readdir, readFile as readFile4 } from "fs/promises";
+import { createHash as createHash2, timingSafeEqual } from "crypto";
+import { appendFile, mkdir as mkdir3, readdir as readdir2, readFile as readFile5 } from "fs/promises";
 import { createServer as createServer2 } from "http";
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 import { z as z2 } from "zod";
 
 // src/telemetry/admin-page.ts
@@ -3945,7 +4432,7 @@ var batchSchema = z2.object({
 });
 async function startCollector(options) {
   const { dataDir } = options;
-  await mkdir2(dataDir, { recursive: true });
+  await mkdir3(dataDir, { recursive: true });
   const registry = await loadRegistry(dataDir);
   let summaryCache;
   let npmCache;
@@ -3993,7 +4480,7 @@ async function startCollector(options) {
     if (!registry.has(batch.installId)) {
       registry.set(batch.installId, receivedAt);
       await appendFile(
-        join6(dataDir, "installs.jsonl"),
+        join7(dataDir, "installs.jsonl"),
         `${JSON.stringify({ installId: batch.installId, firstSeen: receivedAt })}
 `
       );
@@ -4001,7 +4488,7 @@ async function startCollector(options) {
     const { events, ...meta } = batch;
     const lines = events.map((event) => JSON.stringify({ ...meta, ...event, receivedAt }));
     await appendFile(
-      join6(dataDir, `events-${receivedAt.slice(0, 10)}.jsonl`),
+      join7(dataDir, `events-${receivedAt.slice(0, 10)}.jsonl`),
       `${lines.join("\n")}
 `
     );
@@ -4098,7 +4585,7 @@ function passwordMatches(request, password3) {
   if (!header.startsWith("Basic ")) return false;
   const decoded = Buffer.from(header.slice(6), "base64").toString("utf8");
   const given = decoded.slice(decoded.indexOf(":") + 1);
-  const digest = (value) => createHash("sha256").update(value).digest();
+  const digest = (value) => createHash2("sha256").update(value).digest();
   return timingSafeEqual(digest(given), digest(password3));
 }
 function readBody(request) {
@@ -4122,10 +4609,10 @@ function listen2(server, port) {
 }
 async function readEvents(dataDir, days, now = Date.now()) {
   const since = new Date(now - (days - 1) * 864e5).toISOString().slice(0, 10);
-  const files = (await readdir(dataDir).catch(() => [])).filter((file) => /^events-\d{4}-\d{2}-\d{2}\.jsonl$/.test(file) && file.slice(7, 17) >= since).sort();
+  const files = (await readdir2(dataDir).catch(() => [])).filter((file) => /^events-\d{4}-\d{2}-\d{2}\.jsonl$/.test(file) && file.slice(7, 17) >= since).sort();
   const events = [];
   for (const file of files) {
-    for (const line of (await readFile4(join6(dataDir, file), "utf8")).split("\n")) {
+    for (const line of (await readFile5(join7(dataDir, file), "utf8")).split("\n")) {
       if (!line) continue;
       try {
         events.push(JSON.parse(line));
@@ -4400,8 +4887,8 @@ function installTrace(events, prefix) {
 }
 async function loadRegistry(dataDir) {
   const registry = /* @__PURE__ */ new Map();
-  const path = join6(dataDir, "installs.jsonl");
-  const raw = await readFile4(path, "utf8").catch(() => null);
+  const path = join7(dataDir, "installs.jsonl");
+  const raw = await readFile5(path, "utf8").catch(() => null);
   if (raw !== null) {
     for (const line of raw.split("\n")) {
       try {
@@ -4446,10 +4933,10 @@ function registerTelemetryCommands(program, runSafely2) {
       const state = await readTelemetryState();
       const blocked = telemetryBlocked(state);
       console.log(
-        blocked ? `${pc19.yellow("\u25CB")} telemetry off (${blocked})` : `${pc19.green("\u25CF")} telemetry on`
+        blocked ? `${pc21.yellow("\u25CB")} telemetry off (${blocked})` : `${pc21.green("\u25CF")} telemetry on`
       );
-      console.log(pc19.dim(`  install id ${state.installId} (${telemetryStatePath()})`));
-      if (telemetryUrl()) console.log(pc19.dim(`  collector ${telemetryUrl()}`));
+      console.log(pc21.dim(`  install id ${state.installId} (${telemetryStatePath()})`));
+      if (telemetryUrl()) console.log(pc21.dim(`  collector ${telemetryUrl()}`));
     });
   });
   telemetry.command("enable").description("Allow anonymous usage data from this machine.").action(async () => {
@@ -4460,7 +4947,7 @@ function registerTelemetryCommands(program, runSafely2) {
         noticeAt: state.noticeAt ?? (/* @__PURE__ */ new Date()).toISOString()
       });
       console.log(TELEMETRY_NOTICE);
-      console.log(pc19.green("Telemetry enabled."));
+      console.log(pc21.green("Telemetry enabled."));
     });
   });
   telemetry.command("disable").description("Stop sending anonymous usage data from this machine.").action(async () => {
@@ -4488,14 +4975,14 @@ function registerTelemetryCommands(program, runSafely2) {
         adminPort: opts.adminPort,
         ...process.env.CODEBUDDY_ADMIN_PASSWORD ? { adminPassword: process.env.CODEBUDDY_ADMIN_PASSWORD } : {}
       });
-      console.log(`${pc19.green("\u25CF")} ingest ${pc19.bold(collector.ingestUrl)}`);
-      console.log(`${pc19.green("\u25CF")} admin  ${pc19.bold(collector.adminUrl)}`);
+      console.log(`${pc21.green("\u25CF")} ingest ${pc21.bold(collector.ingestUrl)}`);
+      console.log(`${pc21.green("\u25CF")} admin  ${pc21.bold(collector.adminUrl)}`);
       console.log(
-        pc19.dim(
+        pc21.dim(
           process.env.CODEBUDDY_ADMIN_PASSWORD ? "  admin panel is password-protected (CODEBUDDY_ADMIN_PASSWORD)." : "  admin panel has no password: keep it private, or set CODEBUDDY_ADMIN_PASSWORD."
         )
       );
-      console.log(pc19.dim(`  events in ${opts.data}. Ctrl+C to stop.`));
+      console.log(pc21.dim(`  events in ${opts.data}. Ctrl+C to stop.`));
       await new Promise((resolve6) => {
         const stop = () => void collector.close().then(resolve6);
         process.once("SIGINT", stop);
@@ -4506,54 +4993,10 @@ function registerTelemetryCommands(program, runSafely2) {
 }
 
 // src/cli/commands/use-command.ts
+import { execFile as execFile3, spawn as spawn7 } from "child_process";
 import { basename as basename2 } from "path";
 import { confirm as confirm2, isCancel as isCancel2, log as log2, note as note2, password as password2, select, spinner as spinner3, text as text2 } from "@clack/prompts";
-import pc20 from "picocolors";
-
-// src/core/global-config.ts
-import { chmod, mkdir as mkdir3, readFile as readFile5, writeFile as writeFile3 } from "fs/promises";
-import { homedir } from "os";
-import { dirname as dirname3, join as join7 } from "path";
-import { z as z3 } from "zod";
-var GLOBAL_DIR = ".codebuddy";
-var GLOBAL_FILE = "global.json";
-var globalConfigSchema = z3.object({
-  hfToken: z3.string().min(1).optional(),
-  databaseUrl: z3.string().min(1).optional(),
-  // Where the codebuddy install lives on this machine. Cached so future
-  // `codebuddy use` calls in unrelated projects can find the CLI entry
-  // without re-resolving via process.argv every time.
-  installPath: z3.string().optional()
-});
-function globalConfigPath(home = homedir()) {
-  return join7(home, GLOBAL_DIR, GLOBAL_FILE);
-}
-async function readGlobalConfig(home = homedir()) {
-  const path = globalConfigPath(home);
-  try {
-    const raw = await readFile5(path, "utf8");
-    return globalConfigSchema.parse(JSON.parse(raw));
-  } catch (error) {
-    if (error.code === "ENOENT") return {};
-    throw error;
-  }
-}
-async function writeGlobalConfig(next, home = homedir()) {
-  const path = globalConfigPath(home);
-  await mkdir3(dirname3(path), { recursive: true, mode: 448 });
-  await writeFile3(path, `${JSON.stringify(next, null, 2)}
-`, { mode: 384 });
-  await chmod(path, 384);
-  return { path };
-}
-async function mergeGlobalConfig(patch, home = homedir()) {
-  const current = await readGlobalConfig(home);
-  const merged = { ...current, ...patch };
-  const { path } = await writeGlobalConfig(merged, home);
-  return { path, merged };
-}
-
-// src/cli/commands/use-command.ts
+import pc22 from "picocolors";
 function bail2() {
   log2.warn("Aborted.");
   process.exit(1);
@@ -4572,6 +5015,131 @@ async function pingOnce2(databaseUrl) {
     await client.close().catch(() => void 0);
   }
 }
+async function setupZvec(configured) {
+  if (configured === false) {
+    log2.info(`zvec-grep: disabled in config (enable with ${pc22.cyan("codebuddy zvec enable")}).`);
+    return;
+  }
+  let report = await zvecStatus(process.cwd()).catch(() => null);
+  if (report && report.version === null && process.env.CODEBUDDY_ZVEC !== "0") {
+    const install = spinner3();
+    install.start(`Installing zvec-grep (${ZVEC_PACKAGE})`);
+    const code2 = await npmGlobalInstall(ZVEC_PACKAGE);
+    install.stop(code2 === 0 ? "zvec-grep installed." : `zvec-grep install failed (exit ${code2}).`);
+    if (code2 === 0) report = await zvecStatus(process.cwd()).catch(() => null);
+  }
+  if (!report?.supported) {
+    log2.warn(
+      `zvec-grep: ${report?.reason ?? "unavailable"}; keyword-only file discovery. Install with ${pc22.cyan("npm install -g @zvec/zvec-grep")}, then ${pc22.cyan("codebuddy zvec index && codebuddy zvec enable")}.`
+    );
+    return;
+  }
+  const zvecSpinner = spinner3();
+  zvecSpinner.start("Building the zvec-grep semantic index");
+  const code = report.indexReady ? 0 : await buildZvecIndex(process.cwd(), { quiet: true });
+  if (code !== 0) {
+    zvecSpinner.stop(`zvec-grep index failed (exit ${code}); keyword-only file discovery.`);
+    return;
+  }
+  await setZvecEnabled(true);
+  zvecSpinner.stop("zvec-grep semantic file discovery enabled.");
+}
+var ZVEC_PACKAGE = "@zvec/zvec-grep@0.2";
+function npmGlobalInstall(spec) {
+  return new Promise((resolve6) => {
+    execFile3(
+      "npm",
+      ["install", "-g", spec],
+      { timeout: 10 * 6e4 },
+      (error) => resolve6(error ? typeof error.code === "number" ? error.code : 1 : 0)
+    );
+  });
+}
+async function setupEmbeddings(embeddings) {
+  if (embeddings !== "local" || process.env.CODEBUDDY_SEMANTIC === "0") return;
+  const pull = spinner3();
+  pull.start("Downloading the local embedding model (~90 MB, once)");
+  try {
+    const { LocalModelProvider } = await import("./local-ST4WMRCG.js");
+    await new LocalModelProvider().embed({ input: "warm up" });
+    pull.stop("Local embedding model ready.");
+  } catch (error) {
+    pull.stop(
+      `Embedding model unavailable (${error.message.split("\n")[0]}); recall stays lexical until ${pc22.cyan("codebuddy models pull")} succeeds.`
+    );
+  }
+}
+function startBackgroundIndex(withModel) {
+  const entry = process.argv[1];
+  if (!entry) return;
+  const child = spawn7(process.execPath, [entry, "index", "--cards"], {
+    cwd: process.cwd(),
+    detached: true,
+    stdio: "ignore"
+  });
+  child.unref();
+  log2.info(
+    withModel ? "Building file vectors, intent cards and project facts in the background." : "Building file vectors in the background."
+  );
+}
+async function setupLocalLlm(choice, interactive) {
+  if (choice === false || process.env.CODEBUDDY_LOCAL_LLM === "0") {
+    log2.info(`Local LLM: skipped (add later with ${pc22.cyan("codebuddy models add local-llm")}).`);
+    return false;
+  }
+  const { installedLocalModel, machineCanCard } = await import("./local-75DJECVR.js");
+  let installed = await installedLocalModel() !== null;
+  const machine = machineCanCard();
+  if (!installed && !machine.ok) {
+    if (!await setupCloudQwen(machine.reason, interactive)) return false;
+    installed = true;
+  }
+  if (!installed) {
+    const { addLocalLlm: addLocalLlm2 } = await import("./local-llm-MECVJTVU.js");
+    installed = await addLocalLlm2({ yes: true, interactive });
+    if (!installed) {
+      log2.warn(
+        `Local LLM not installed; file discovery uses keywords and vectors only. Retry with ${pc22.cyan("codebuddy models add local-llm")}.`
+      );
+      return false;
+    }
+  }
+  return installed;
+}
+async function setupCloudQwen(reason, interactive) {
+  const existing = (await readConfigFile()).llm;
+  if (existing && existing.provider !== "local") return existing.enabled;
+  const fromEnv = process.env.GROQ_API_KEY ? "groq" : process.env.OPENROUTER_API_KEY ? "openrouter" : null;
+  const saved = await readGlobalConfig().catch(
+    () => ({})
+  );
+  let chosen = fromEnv ?? (saved.groqApiKey ? "groq" : saved.openrouterApiKey ? "openrouter" : null);
+  if (!chosen && interactive) {
+    log2.info(
+      `This machine is too small for the local model (${reason}), so CodeBuddy can use Qwen in the cloud. Get a free Groq key at ${pc22.cyan("https://console.groq.com/keys")}.`
+    );
+    const key = unwrap2(
+      await password2({
+        message: "Groq API key (Enter to skip; saved to ~/.codebuddy/global.json)"
+      })
+    ).trim();
+    if (key) {
+      await mergeGlobalConfig({ groqApiKey: key });
+      chosen = "groq";
+    }
+  }
+  if (!chosen) {
+    log2.warn(
+      `Local LLM: this machine is too small for it (${reason}). For cloud Qwen, get a free key at ${pc22.cyan("https://console.groq.com/keys")} and rerun ${pc22.cyan("codebuddy use")} (or ${pc22.cyan("export GROQ_API_KEY=\u2026")} and ${pc22.cyan("codebuddy llm enable --provider groq")}). Keyword + vector discovery work meanwhile.`
+    );
+    return false;
+  }
+  await setLlmEnabled(true, { provider: chosen });
+  log2.info(
+    `LLM: this machine is too small for the local model (${reason}); using Qwen (qwen/qwen3.8-27b) on ${chosen}. Redacted file heads and signatures are sent to it; turn off with \`codebuddy llm disable\`.`
+  );
+  return true;
+}
 function sanitizeNamespace(input) {
   return input.replace(/[^a-zA-Z0-9_.:-]/g, "-").slice(0, 128) || "default";
 }
@@ -4592,15 +5160,15 @@ async function runUseCommand(options = {}) {
       })
     ));
     note2(
-      `Project folder: ${pc20.bold(process.cwd())}
-Namespace:      ${pc20.bold(namespace)}`,
+      `Project folder: ${pc22.bold(process.cwd())}
+Namespace:      ${pc22.bold(namespace)}`,
       "codebuddy use"
     );
     const stored = await readGlobalConfig();
     const projectConfig = await readConfigFile();
     let embeddings = projectConfig.provider?.type;
     if (embeddings) {
-      log2.info(`Embeddings: ${embeddings} (change with ${pc20.cyan("codebuddy models use")}).`);
+      log2.info(`Embeddings: ${embeddings} (change with ${pc22.cyan("codebuddy models use")}).`);
     } else if (!interactive) {
       embeddings = "local";
     } else {
@@ -4641,7 +5209,7 @@ Namespace:      ${pc20.bold(namespace)}`,
       log2.info("Using HF_TOKEN from environment.");
     } else if (stored.hfToken) {
       hfToken = stored.hfToken;
-      log2.info(`Reusing saved Hugging Face token (${pc20.dim("~/.codebuddy/global.json")}).`);
+      log2.info(`Reusing saved Hugging Face token (${pc22.dim("~/.codebuddy/global.json")}).`);
     } else if (!interactive) {
       throw new Error(
         "Hugging Face embeddings need a token: set HF_TOKEN (no terminal to prompt for it)."
@@ -4757,6 +5325,9 @@ Namespace:      ${pc20.bold(namespace)}`,
       tokenBudget: existingConfig.tokenBudget ?? 4e3,
       graphify: { enabled: graphifyConfigured, graphPath: "graphify-out/graph.json" }
     });
+    await setupEmbeddings(embeddings);
+    await setupZvec(existingConfig.zvec?.enabled);
+    startBackgroundIndex(await setupLocalLlm(options.localLlm, interactive));
     const graphifyMessage = graphifySetup?.message ?? "Graphify disabled; CodeBuddy MCP remains available.";
     await writeProjectMcpConfig({
       repositoryRoot: process.cwd(),
@@ -4775,7 +5346,7 @@ Namespace:      ${pc20.bold(namespace)}`,
           databaseUrl
         });
         log2.success(
-          `Registered ${pc20.bold(install.serverKey)} in Claude Desktop. Restart with \u2318Q to activate.`
+          `Registered ${pc22.bold(install.serverKey)} in Claude Desktop. Restart with \u2318Q to activate.`
         );
       } catch (error) {
         log2.warn(`Claude Desktop registration skipped: ${error.message}`);
@@ -4790,7 +5361,7 @@ Namespace:      ${pc20.bold(namespace)}`,
           databaseUrl
         });
         log2.success(
-          `Registered ${pc20.bold(install.serverKey)} in Codex. Restart Codex to activate.`
+          `Registered ${pc22.bold(install.serverKey)} in Codex. Restart Codex to activate.`
         );
       } catch (error) {
         log2.warn(`Codex registration skipped: ${error.message}`);
@@ -4798,24 +5369,24 @@ Namespace:      ${pc20.bold(namespace)}`,
     }
     note2(
       [
-        `${pc20.green("\u2713")} CodeBuddy is ready for ${pc20.bold(folderName)}.`,
-        `${pc20.green("\u2713")} Scaffolded ${pc20.cyan(".codebuddy/policies.yaml")} for project-specific guardrails.`,
-        `${pc20.green("\u2713")} ${graphifyMessage}`,
-        `${pc20.green("\u2713")} Added agent workflow instructions to ${pc20.cyan("CLAUDE.md")} and ${pc20.cyan("AGENTS.md")}.`,
+        `${pc22.green("\u2713")} CodeBuddy is ready for ${pc22.bold(folderName)}.`,
+        `${pc22.green("\u2713")} Scaffolded ${pc22.cyan(".codebuddy/policies.yaml")} for project-specific guardrails.`,
+        `${pc22.green("\u2713")} ${graphifyMessage}`,
+        `${pc22.green("\u2713")} Added agent workflow instructions to ${pc22.cyan("CLAUDE.md")} and ${pc22.cyan("AGENTS.md")}.`,
         ``,
         `Next:`,
         `  1. Restart Claude Desktop and Codex.`,
-        `  2. Ask Claude or Codex to use the ${pc20.cyan("context_pack")} tool for each coding task.`,
+        `  2. Ask Claude or Codex to use the ${pc22.cyan("context_pack")} tool for each coding task.`,
         `  3. Indexing, Graphify, Markdown memory import, and embeddings now update automatically while the MCP server is running.`,
-        `  4. Run ${pc20.cyan("codebuddy doctor")} or ${pc20.cyan("codebuddy db doctor")} if you want a full health check.`,
+        `  4. Run ${pc22.cyan("codebuddy doctor")} or ${pc22.cyan("codebuddy db doctor")} if you want a full health check.`,
         ``,
         `Manage:`,
-        `  codebuddy claude list           ${pc20.dim("# see every project wired up")}`,
-        `  codebuddy codex list            ${pc20.dim("# see Codex entries")}`,
-        `  codebuddy db test               ${pc20.dim("# quick Postgres connectivity check")}`,
+        `  codebuddy claude list           ${pc22.dim("# see every project wired up")}`,
+        `  codebuddy codex list            ${pc22.dim("# see Codex entries")}`,
+        `  codebuddy db test               ${pc22.dim("# quick Postgres connectivity check")}`,
         `  codebuddy claude remove codebuddy-${namespace}`,
         `  codebuddy codex remove codebuddy-${namespace}`,
-        `  codebuddy postgres down         ${pc20.dim("# stop the DB (data preserved)")}`
+        `  codebuddy postgres down         ${pc22.dim("# stop the DB (data preserved)")}`
       ].join("\n"),
       "Done"
     );
@@ -4826,7 +5397,7 @@ Namespace:      ${pc20.bold(namespace)}`,
 
 // src/cli/commands/worklog.ts
 import { relative as relative6 } from "path";
-import pc21 from "picocolors";
+import pc23 from "picocolors";
 function registerWorklogCommands(program, runSafely2) {
   const worklog = program.command("worklog").description("Inspect the cross-chat worklog of completed turns.");
   worklog.command("list", { isDefault: true }).option("--limit <n>", "Maximum entries to show.", "20").option("--json", "Print machine-readable JSON.").description("List worklog entries, newest first.").action(async (opts) => {
@@ -4837,7 +5408,7 @@ function registerWorklogCommands(program, runSafely2) {
         return;
       }
       if (entries.length === 0) {
-        console.log(pc21.dim("no worklog entries yet"));
+        console.log(pc23.dim("no worklog entries yet"));
         return;
       }
       for (const entry of entries) console.log(renderRow2(entry));
@@ -4851,36 +5422,36 @@ function registerWorklogCommands(program, runSafely2) {
   worklog.command("latest").description("Show the most recent worklog entry.").action(async () => {
     await runSafely2(async () => {
       const [entry] = await new WorklogStore().list();
-      console.log(entry ? renderEntry(entry) : pc21.dim("no worklog entries yet"));
+      console.log(entry ? renderEntry(entry) : pc23.dim("no worklog entries yet"));
     });
   });
 }
 function renderRow2(entry) {
   const summary = entry.summary.replace(/\s+/g, " ");
   const short2 = summary.length <= 70 ? summary : `${summary.slice(0, 69)}\u2026`;
-  return `${pc21.dim(entry.createdAt.slice(0, 16))}  ${pc21.dim(entry.id)}  ${short2}  ${pc21.dim(`(${entry.files.length} file(s))`)}`;
+  return `${pc23.dim(entry.createdAt.slice(0, 16))}  ${pc23.dim(entry.id)}  ${short2}  ${pc23.dim(`(${entry.files.length} file(s))`)}`;
 }
 function renderEntry(entry) {
-  const lines = [`${pc21.bold(entry.id)}  ${pc21.dim(entry.createdAt)}  ${pc21.dim(entry.namespace)}`];
-  if (entry.sourceSessionId) lines.push(`${pc21.bold("session:")} ${entry.sourceSessionId}`);
-  if (entry.sourcePlanId) lines.push(`${pc21.bold("plan:")} ${entry.sourcePlanId}`);
-  if (entry.commitSha) lines.push(`${pc21.bold("commit:")} ${entry.commitSha}`);
-  if (entry.files.length > 0) lines.push(`${pc21.bold("files:")} ${entry.files.join(", ")}`);
+  const lines = [`${pc23.bold(entry.id)}  ${pc23.dim(entry.createdAt)}  ${pc23.dim(entry.namespace)}`];
+  if (entry.sourceSessionId) lines.push(`${pc23.bold("session:")} ${entry.sourceSessionId}`);
+  if (entry.sourcePlanId) lines.push(`${pc23.bold("plan:")} ${entry.sourcePlanId}`);
+  if (entry.commitSha) lines.push(`${pc23.bold("commit:")} ${entry.commitSha}`);
+  if (entry.files.length > 0) lines.push(`${pc23.bold("files:")} ${entry.files.join(", ")}`);
   if (entry.verification.length > 0) {
-    lines.push(`${pc21.bold("verification:")}`, ...entry.verification.map((line) => `  - ${line}`));
+    lines.push(`${pc23.bold("verification:")}`, ...entry.verification.map((line) => `  - ${line}`));
   }
   if (entry.savedMemory.length > 0) {
-    lines.push(`${pc21.bold("saved memory:")} ${entry.savedMemory.join(", ")}`);
+    lines.push(`${pc23.bold("saved memory:")} ${entry.savedMemory.join(", ")}`);
   }
   if (entry.queuedForReview.length > 0) {
-    lines.push(`${pc21.bold("queued for review:")} ${entry.queuedForReview.join(", ")}`);
+    lines.push(`${pc23.bold("queued for review:")} ${entry.queuedForReview.join(", ")}`);
   }
-  lines.push("", entry.summary, "", pc21.dim(relative6(process.cwd(), entry.path)));
+  lines.push("", entry.summary, "", pc23.dim(relative6(process.cwd(), entry.path)));
   return lines.join("\n");
 }
 
 // src/cli/commands/zvec.ts
-import pc22 from "picocolors";
+import pc24 from "picocolors";
 function registerZvecCommands(program, runSafely2) {
   const zvec = program.command("zvec").description("Optional zvec-grep semantic file discovery for the context tools.");
   zvec.command("status", { isDefault: true }).option("--json", "Print machine-readable JSON.").description("Show whether zvec-grep is enabled, installed, supported and indexed.").action(async (opts) => {
@@ -4890,22 +5461,22 @@ function registerZvecCommands(program, runSafely2) {
         console.log(JSON.stringify(report, null, 2));
         return;
       }
-      const mark = (ok2) => ok2 ? pc22.green("yes") : pc22.yellow("no");
+      const mark = (ok2) => ok2 ? pc24.green("yes") : pc24.yellow("no");
       console.log(`enabled:      ${mark(report.enabled)}`);
       console.log(`binary:       ${report.binary}`);
       console.log(
-        `version:      ${report.version ?? pc22.yellow("not found")}${report.version && !report.supported ? pc22.yellow(" (unsupported; need 0.2.x)") : ""}`
+        `version:      ${report.version ?? pc24.yellow("not found")}${report.version && !report.supported ? pc24.yellow(" (unsupported; need 0.2.x)") : ""}`
       );
       console.log(`index ready:  ${mark(report.indexReady)}`);
       console.log(
-        `zg server:    ${report.server} ${pc22.dim("(running = faster queries; optional)")}`
+        `zg server:    ${report.server} ${pc24.dim("(running = faster queries; optional)")}`
       );
       console.log(`status:       ${report.reason}`);
-      if (!report.version) console.log(pc22.dim("install: npm install -g @zvec/zvec-grep"));
+      if (!report.version) console.log(pc24.dim("install: npm install -g @zvec/zvec-grep"));
       else if (report.supported && !report.indexReady)
-        console.log(pc22.dim("next: codebuddy zvec index"));
+        console.log(pc24.dim("next: codebuddy zvec index"));
       else if (report.indexReady && !report.enabled)
-        console.log(pc22.dim("next: codebuddy zvec enable"));
+        console.log(pc24.dim("next: codebuddy zvec enable"));
     });
   });
   zvec.command("index").option("--model <model>", "Embedding model for a new index.", DEFAULT_ZVEC_MODEL).option("--rebuild", "Rebuild the index from scratch (e.g. after changing model).").description("Build or refresh the zg index for this repository (explicit; never automatic).").action(async (opts) => {
@@ -4915,21 +5486,21 @@ function registerZvecCommands(program, runSafely2) {
         ...opts.rebuild ? { rebuild: true } : {}
       });
       if (code !== 0) throw new Error(`zg index exited with code ${code}`);
-      console.log(pc22.dim("next: codebuddy zvec enable (.zvec-grep/ ignores itself in git)"));
+      console.log(pc24.dim("next: codebuddy zvec enable (.zvec-grep/ ignores itself in git)"));
     });
   });
   zvec.command("enable").description("Use zvec-grep candidates in context_pack / context_before_edit.").action(async () => {
     await runSafely2(async () => {
       await setZvecEnabled(true);
       console.log(
-        `${pc22.green("enabled")} zvec-grep retrieval (falls back to keywords if unavailable)`
+        `${pc24.green("enabled")} zvec-grep retrieval (falls back to keywords if unavailable)`
       );
     });
   });
   zvec.command("disable").description("Stop using zvec-grep; keyword ranking only.").action(async () => {
     await runSafely2(async () => {
       await setZvecEnabled(false);
-      console.log(`${pc22.yellow("disabled")} zvec-grep retrieval`);
+      console.log(`${pc24.yellow("disabled")} zvec-grep retrieval`);
     });
   });
 }
@@ -4950,7 +5521,7 @@ function createCli() {
   ).argument("[namespace]", "Override the namespace (defaults to current folder name).").option("--postgres-url <url>", "Postgres URL to use for this project.").option("--skip-claude", "Do not register with Claude Desktop.").option("--skip-codex", "Do not register with Codex.").option("--graphify", "Enable Graphify setup without prompting.").option("--no-graphify", "Skip Graphify setup without prompting.").option(
     "--docker",
     "Start CodeBuddy's bundled Postgres container when the default DB is unavailable."
-  ).option("--no-docker", "Do not offer to start CodeBuddy's bundled Postgres container.").option("-y, --yes", "Never prompt: use flags and defaults (automatic without a TTY).").option("--non-interactive", "Same as --yes.").action(
+  ).option("--no-docker", "Do not offer to start CodeBuddy's bundled Postgres container.").option("--no-local-llm", "Skip installing the local LLM (Qwen3-0.6B, ~400 MB).").option("-y, --yes", "Never prompt: use flags and defaults (automatic without a TTY).").option("--non-interactive", "Same as --yes.").action(
     async (namespace, opts) => {
       await runSafely(async () => {
         await runUseCommand({
@@ -4960,6 +5531,7 @@ function createCli() {
           ...opts.skipCodex !== void 0 ? { skipCodex: opts.skipCodex } : {},
           ...opts.graphify !== void 0 ? { graphify: opts.graphify } : {},
           ...opts.docker !== void 0 ? { useDocker: opts.docker } : {},
+          ...opts.localLlm !== void 0 ? { localLlm: opts.localLlm } : {},
           ...opts.yes || opts.nonInteractive ? { interactive: false } : {}
         });
       });
@@ -5199,7 +5771,47 @@ function createCli() {
   });
   program.command("stats").description("Show CodeBuddy storage and usage stats.").action(async () => {
     await withRuntime(async (runtime) => {
-      console.log(JSON.stringify(await runtime.repository.getStats(), null, 2));
+      console.log(
+        JSON.stringify(
+          { ...await runtime.repository.getStats(), ...await indexModelStats(process.cwd()) },
+          null,
+          2
+        )
+      );
+    });
+  });
+  program.command("storage").option("--json", "Print machine-readable JSON.").description(
+    "Memory storage health: Markdown/database drift, backup coverage, embedding backlog and spaces, capture lag."
+  ).action(async (opts) => {
+    await runSafely(async () => {
+      const root = process.cwd();
+      const capture2 = {
+        stagedNotCaptured: await new HookStagingStore(root).pending(),
+        journalBehind: (await journalLag(root)).filter((entry) => entry.behindBytes !== 0)
+      };
+      let database;
+      try {
+        const runtime = await createRuntime(await loadRuntimeConfig());
+        try {
+          database = await runtime.memory.storageReport();
+        } finally {
+          await runtime.close();
+        }
+      } catch (error) {
+        database = { unavailable: error.message };
+      }
+      const index = await indexModelStats(root);
+      if (opts.json) {
+        console.log(JSON.stringify({ database, capture: capture2, ...index }, null, 2));
+        return;
+      }
+      printStorage(database, capture2);
+      console.log(
+        `intent cards: ${index.cards.carded} / ${index.cards.eligible} source files; index facts: ${index.indexFacts}`
+      );
+      if ("unavailable" in database || database.markdownOnly.length + database.dbOnly.length > 0) {
+        process.exitCode = 1;
+      }
     });
   });
   program.command("doctor").description("Check CodeBuddy environment health.").option("--skip-model-check", "Do not call Hugging Face models.").action(async (opts) => {
@@ -5228,6 +5840,8 @@ function createCli() {
   registerLearnCommand(program, runSafely);
   registerMemoryCommands(program, runSafely);
   registerWorklogCommands(program, runSafely);
+  registerJournalCommands(program, runSafely);
+  registerOutputCommands(program, runSafely);
   registerZvecCommands(program, runSafely);
   registerLlmCommands(program, runSafely);
   registerSuggestCommand(program, runSafely);
@@ -5255,7 +5869,20 @@ var HELP_GROUPS = [
   ["Get started:", ["use", "init", "doctor", "hooks", "clients", "models", "dashboard"]],
   [
     "Daily work:",
-    ["context", "plan", "change", "risk", "suggest", "memory", "worklog", "map", "symbols"]
+    [
+      "context",
+      "plan",
+      "change",
+      "risk",
+      "suggest",
+      "memory",
+      "worklog",
+      "journal",
+      "run",
+      "output",
+      "map",
+      "symbols"
+    ]
   ],
   ["Indexing and search:", ["index", "watch", "reindex", "zvec", "graphify", "llm"]],
   [
@@ -5265,6 +5892,7 @@ var HELP_GROUPS = [
       "db",
       "migrate",
       "stats",
+      "storage",
       "inspect",
       "namespaces",
       "list-facts",
@@ -5301,6 +5929,14 @@ Quick start:
                                  see exactly what an agent would be given`
   );
 }
+async function indexModelStats(root) {
+  const { cardProgress } = await import("./summaries-QXWFFDUZ.js");
+  const { listIndexFacts: listIndexFacts2 } = await import("./index-facts-4MTEHKMN.js");
+  return {
+    cards: await cardProgress(root).catch(() => ({ carded: 0, eligible: 0 })),
+    indexFacts: (await listIndexFacts2(root).catch(() => [])).length
+  };
+}
 async function withRuntime(fn) {
   await runSafely(async () => {
     const runtime = await createRuntime(await loadRuntimeConfig());
@@ -5315,7 +5951,7 @@ async function runSafely(fn) {
   try {
     await fn();
   } catch (error) {
-    console.error(pc23.red(String(redactSecrets(error.message))));
+    console.error(pc25.red(String(redactSecrets(error.message))));
     process.exitCode = 1;
   }
 }
@@ -5329,9 +5965,9 @@ function parseDuration(value) {
   return amount * 60 * 1e3;
 }
 function printDoctor(report) {
-  const ok2 = pc23.green("ok");
-  const bad = pc23.red("fail");
-  const warn2 = pc23.yellow("warn");
+  const ok2 = pc25.green("ok");
+  const bad = pc25.red("fail");
+  const warn2 = pc25.yellow("warn");
   console.log(`scaffold root: ${report.scaffold.codebuddyDir.ok ? ok2 : bad}`);
   if (report.scaffold.codebuddyDir.warning)
     console.log(`  ${report.scaffold.codebuddyDir.warning}`);
@@ -5357,7 +5993,7 @@ function printDoctor(report) {
   );
   console.log(`estimated daily cap remaining: ${report.usage.estimatedDailyCapRemaining}`);
   if (report.usage.warning80Percent)
-    console.log(pc23.yellow("usage warning: daily cap is over 80% used"));
+    console.log(pc25.yellow("usage warning: daily cap is over 80% used"));
   console.log(
     `config permissions: ${report.config.exists ? report.config.mode : "missing"} ${report.config.ok ? ok2 : warn2}`
   );
@@ -5367,9 +6003,9 @@ function printDoctor(report) {
   }
 }
 function printDbDoctor(report) {
-  const ok2 = pc23.green("ok");
-  const bad = pc23.red("fail");
-  const warn2 = pc23.yellow("warn");
+  const ok2 = pc25.green("ok");
+  const bad = pc25.red("fail");
+  const warn2 = pc25.yellow("warn");
   console.log(`DB connectivity: ${report.db.ok ? ok2 : bad}`);
   if (report.db.postgresUrlSource) console.log(`  url source: ${report.db.postgresUrlSource}`);
   if (report.db.error) console.log(`  ${report.db.error}`);
@@ -5382,7 +6018,42 @@ function printDbDoctor(report) {
   }
   if (report.namespace.warning) console.log(`  ${report.namespace.warning}`);
 }
+function printStorage(database, capture2) {
+  if ("unavailable" in database) {
+    console.log(pc25.yellow(`database: unavailable (${database.unavailable})`));
+  } else {
+    const drift = database.markdownOnly.length + database.dbOnly.length;
+    console.log(
+      `facts: ${database.markdownFacts} Markdown, ${database.databaseFacts} database${database.invalidFiles > 0 ? `, ${database.invalidFiles} unreadable file(s)` : ""}`
+    );
+    console.log(
+      drift === 0 ? pc25.green("sync: Markdown and database agree") : pc25.yellow(
+        `sync: ${database.markdownOnly.length} file(s) not in the database, ${database.dbOnly.length} row(s) without a file (run \`codebuddy reindex\`)`
+      )
+    );
+    if (database.unbacked.length > 0) {
+      console.log(
+        pc25.yellow(
+          `backup: ${database.unbacked.length} database-only fact(s) have no Markdown copy`
+        )
+      );
+    }
+    const e = database.embeddings;
+    console.log(
+      `embeddings: ${e.ready} ready, ${e.pending} pending, ${e.processing} processing, ${e.failed} failed${database.oldestPendingAt ? ` (oldest pending ${database.oldestPendingAt})` : ""}`
+    );
+    for (const space of database.spaces) {
+      console.log(`  space ${space.model} ${space.space ?? "(legacy)"}: ${space.count}`);
+    }
+    if (database.spaces.length > 1) {
+      console.log(pc25.yellow("  more than one embedding space: run `codebuddy reindex --respace`"));
+    }
+  }
+  console.log(
+    capture2.stagedNotCaptured.length === 0 && capture2.journalBehind.length === 0 ? pc25.green("capture: nothing pending") : `capture: ${capture2.stagedNotCaptured.length} session(s) with uncaptured edits, ${capture2.journalBehind.length} journal(s) behind their transcript`
+  );
+}
 export {
   createCli
 };
-//# sourceMappingURL=main-YJKSYFPT.js.map
+//# sourceMappingURL=main-RLMKQZW4.js.map