codealmanac 0.1.10 → 0.2.1

package/dist/{register-commands-JHC2OFKM.js → register-commands-DPH4ZWEE.js}

@@ -1,4 +1,16 @@
 #!/usr/bin/env node
+import {
+  collectOption,
+  emit,
+  parsePositiveInt,
+  readStdin
+} from "./chunk-P3LDTCLB.js";
+import {
+  assertAgentAuth,
+  runAgentsList,
+  runSetAgentModel,
+  runSetDefaultAgent
+} from "./chunk-R3URPHGH.js";
 import {
   addEntry,
   ancestorsInFile,
@@ -21,24 +33,12 @@ import {
   titleCase,
   toKebabCase,
   writeTopicsFile
-} from "./chunk-3C5SY5SE.js";
+} from "./chunk-KQUVMF27.js";
 import {
   runDoctor
-} from "./chunk-QLHJP2XK.js";
+} from "./chunk-B2AGSRXL.js";
+import "./chunk-V3QOQSXI.js";
 import "./chunk-4CODZRHH.js";
-import {
-  runUninstall
-} from "./chunk-BJVZLP6O.js";
-import {
-  runUpdate
-} from "./chunk-Z6MBJ3D2.js";
-import {
-  collectOption,
-  emit,
-  parsePositiveInt,
-  readStdin
-} from "./chunk-P3LDTCLB.js";
-import "./chunk-QHQ6YH7U.js";
 import {
   BLUE,
   BOLD,
@@ -46,16 +46,27 @@ import {
   RST
 } from "./chunk-FM3VRDK7.js";
 import {
-  assertClaudeAuth,
-  resolveClaudeExecutable,
+  runUninstall
+} from "./chunk-MX2EW5MR.js";
+import {
   runSetup
-} from "./chunk-3LC55TG6.js";
+} from "./chunk-ZDJSJIB6.js";
 import {
   runHookInstall,
   runHookStatus,
   runHookUninstall
-} from "./chunk-Z4MWLVS2.js";
-import "./chunk-AXFPUHBN.js";
+} from "./chunk-447U3GQJ.js";
+import {
+  resolveClaudeExecutable
+} from "./chunk-SSYMRT4I.js";
+import {
+  runUpdate
+} from "./chunk-QQHIVTXT.js";
+import "./chunk-F53U6JQG.js";
+import {
+  isAgentProviderId,
+  readConfig
+} from "./chunk-WRUSDYYE.js";
 import {
   findNearestAlmanacDir,
   getRepoAlmanacDir
@@ -1761,10 +1772,33 @@ function registerQueryCommands(program) {
 
 // src/cli/register-setup-commands.ts
 function registerSetupCommands(program) {
-  program.command("setup").description("install the hook + CLAUDE.md guides (bare codealmanac alias)").option("-y, --yes", "skip prompts; install everything").option("--skip-hook", "opt out of the SessionEnd hook").option("--skip-guides", "opt out of the CLAUDE.md guides").action(
+  const agents = program.command("agents").description("list supported AI agent providers and readiness");
+  agents.command("list").description("show Claude, Codex, and Cursor provider status").action(async () => {
+    emit(await runAgentsList());
+  });
+  program.command("set").description("configure codealmanac defaults").argument("<key>", "setting key, e.g. default-agent or model").argument("[value...]", "setting value").action(async (key, value) => {
+    if (key === "default-agent") {
+      emit(await runSetDefaultAgent({ provider: value[0] ?? "" }));
+      return;
+    }
+    if (key === "model") {
+      emit(await runSetAgentModel({
+        provider: value[0] ?? "",
+        model: value[1]
+      }));
+      return;
+    }
+    emit({
+      stdout: "",
+      stderr: "almanac: unknown setting. Use `default-agent` or `model`.\n",
+      exitCode: 1
+    });
+  });
+  program.command("setup").description("install the hook + CLAUDE.md guides (bare codealmanac alias)").option("-y, --yes", "skip prompts; install everything").option("--agent <agent>", "default agent: claude, codex, or cursor").option("--skip-hook", "opt out of the SessionEnd hook").option("--skip-guides", "opt out of the CLAUDE.md guides").action(
     async (opts) => {
       const result = await runSetup({
         yes: opts.yes,
+        agent: opts.agent,
         skipHook: opts.skipHook,
         skipGuides: opts.skipGuides
       });
@@ -1869,8 +1903,20 @@ async function loadPrompt(name) {
 }
 
 // src/agent/sdk.ts
+import { spawn } from "child_process";
 import { query } from "@anthropic-ai/claude-agent-sdk";
+var DEFAULT_AGENT_MODEL = "claude-sonnet-4-6";
 async function runAgent(opts) {
+  const provider = opts.provider ?? "claude";
+  if (provider === "codex") {
+    return await runCodexAgent(opts);
+  }
+  if (provider === "cursor") {
+    return await runCursorAgent(opts);
+  }
+  return await runClaudeAgent(opts);
+}
+async function runClaudeAgent(opts) {
   const claudeExecutable = resolveClaudeExecutable();
   const q = query({
     prompt: opts.prompt,
@@ -1879,7 +1925,7 @@ async function runAgent(opts) {
       allowedTools: opts.allowedTools,
       agents: opts.agents ?? {},
       cwd: opts.cwd,
-      model: opts.model ?? "claude-sonnet-4-6",
+      model: opts.model ?? DEFAULT_AGENT_MODEL,
       maxTurns: opts.maxTurns ?? 100,
       ...claudeExecutable !== void 0 ? { pathToClaudeCodeExecutable: claudeExecutable } : {},
       env: {
@@ -1925,6 +1971,186 @@ async function runAgent(opts) {
   }
   return { success, cost, turns, result, sessionId, error: errorMsg };
 }
+function combinedPrompt(opts) {
+  const reviewerFallback = buildReviewerFallback(opts);
+  return `${opts.systemPrompt}${reviewerFallback}
+
+---
+
+${opts.prompt}`;
+}
+function buildReviewerFallback(opts) {
+  if ((opts.provider ?? "claude") === "claude") return "";
+  const reviewer = opts.agents?.reviewer;
+  if (reviewer === void 0) return "";
+  return "\n\nNon-Claude provider note: this runtime does not receive Claude's nested Agent tool contract. When the writer prompt asks you to invoke the reviewer subagent, perform that review pass yourself before final wiki edits. Treat this reviewer prompt as read-only review guidance:\n\n" + reviewer.prompt;
+}
+async function runCodexAgent(opts) {
+  const args = [
+    "exec",
+    "--json",
+    "--sandbox",
+    "workspace-write",
+    "--skip-git-repo-check",
+    "-C",
+    opts.cwd
+  ];
+  if (opts.model !== void 0 && opts.model.length > 0) {
+    args.push("--model", opts.model);
+  }
+  args.push(combinedPrompt(opts));
+  return await runJsonlCli({
+    command: "codex",
+    args,
+    cwd: opts.cwd,
+    env: { ...process.env, CODEALMANAC_INTERNAL_SESSION: "1" },
+    onMessage: opts.onMessage,
+    parseFinal: parseCodexFinal
+  });
+}
+async function runCursorAgent(opts) {
+  const args = [
+    "--print",
+    "--output-format",
+    "stream-json",
+    "--stream-partial-output",
+    "--trust",
+    "--workspace",
+    opts.cwd
+  ];
+  if (opts.model !== void 0 && opts.model.length > 0) {
+    args.push("--model", opts.model);
+  }
+  args.push(combinedPrompt(opts));
+  return await runJsonlCli({
+    command: "cursor-agent",
+    args,
+    cwd: opts.cwd,
+    env: { ...process.env, CODEALMANAC_INTERNAL_SESSION: "1" },
+    onMessage: opts.onMessage,
+    parseFinal: parseCursorFinal
+  });
+}
+function runJsonlCli(opts) {
+  return new Promise((resolve) => {
+    const child = spawn(opts.command, opts.args, {
+      cwd: opts.cwd,
+      env: opts.env,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdoutBuf = "";
+    let stderr = "";
+    let cost = 0;
+    let turns = 0;
+    let result = "";
+    let sessionId;
+    let success = false;
+    let finalSeen = false;
+    let error;
+    const observe = (msg) => {
+      opts.onMessage?.(msg);
+      if (sessionId === void 0 && typeof msg.session_id === "string" && msg.session_id.length > 0) {
+        sessionId = msg.session_id;
+      }
+      const final = opts.parseFinal(msg);
+      if (final === null) return;
+      finalSeen = true;
+      if (final.cost !== void 0) cost = final.cost;
+      if (final.turns !== void 0) turns = final.turns;
+      if (final.result !== void 0) result = final.result;
+      if (final.sessionId !== void 0) sessionId = final.sessionId;
+      if (final.success !== void 0) success = final.success;
+      if (final.error !== void 0) error = final.error;
+    };
+    const flushLines = () => {
+      let idx = stdoutBuf.indexOf("\n");
+      while (idx !== -1) {
+        const rawLine = stdoutBuf.slice(0, idx);
+        stdoutBuf = stdoutBuf.slice(idx + 1);
+        const line = rawLine.trim();
+        if (line.length > 0) {
+          try {
+            const parsed = JSON.parse(line);
+            observe(parsed);
+          } catch {
+          }
+        }
+        idx = stdoutBuf.indexOf("\n");
+      }
+    };
+    child.stdout.on("data", (chunk) => {
+      stdoutBuf += chunk.toString("utf8");
+      flushLines();
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString("utf8");
+    });
+    child.on("error", (err) => {
+      resolve({
+        success: false,
+        cost,
+        turns,
+        result,
+        sessionId,
+        error: err.code === "ENOENT" ? `${opts.command} not found on PATH` : err.message
+      });
+    });
+    child.on("close", (code) => {
+      flushLines();
+      if (stdoutBuf.trim().length > 0) {
+        try {
+          observe(JSON.parse(stdoutBuf.trim()));
+        } catch {
+        }
+      }
+      if (code === 0 && finalSeen && success) {
+        resolve({ success, cost, turns, result, sessionId });
+        return;
+      }
+      const firstStderr = stderr.trim().split("\n")[0];
+      resolve({
+        success: false,
+        cost,
+        turns,
+        result,
+        sessionId,
+        error: error ?? (firstStderr !== void 0 && firstStderr.length > 0 ? firstStderr : `${opts.command} exited ${code ?? 1}`)
+      });
+    });
+  });
+}
+function parseCodexFinal(msg) {
+  if (msg.type === "item.completed") {
+    const item = msg.item;
+    if (item !== null && typeof item === "object") {
+      const obj = item;
+      if (obj.type === "agent_message" && typeof obj.text === "string") {
+        return { result: obj.text };
+      }
+    }
+    return null;
+  }
+  if (msg.type === "turn.completed") {
+    return { success: true };
+  }
+  if (msg.type === "turn.failed" || msg.type === "error") {
+    return {
+      success: false,
+      error: typeof msg.message === "string" ? msg.message : typeof msg.error === "string" ? msg.error : "codex turn failed"
+    };
+  }
+  return null;
+}
+function parseCursorFinal(msg) {
+  if (msg.type !== "result") return null;
+  const isError = msg.is_error === true || msg.subtype !== "success";
+  return {
+    success: !isError,
+    result: typeof msg.result === "string" ? msg.result : "",
+    sessionId: typeof msg.session_id === "string" ? msg.session_id : void 0,
+    error: isError ? typeof msg.result === "string" ? msg.result : `cursor result: ${String(msg.subtype ?? "error")}` : void 0
+  };
+}
 
 // src/commands/init.ts
 import { existsSync as existsSync4 } from "fs";
@@ -2069,8 +2295,21 @@ and optional \`files:\`. The rest is prose.
 // src/commands/bootstrap.ts
 var BOOTSTRAP_TOOLS = ["Read", "Write", "Edit", "Glob", "Grep", "Bash"];
 async function runBootstrap(options) {
+  const providerResolution = await resolveAgentSelection({
+    agent: options.agent,
+    model: options.model
+  });
+  if (!providerResolution.ok) {
+    return {
+      stdout: "",
+      stderr: `almanac: ${providerResolution.error}
+`,
+      exitCode: 1
+    };
+  }
+  const { provider, model } = providerResolution;
   try {
-    await assertClaudeAuth(options.spawnCli);
+    await assertAgentAuth({ provider, spawnCli: options.spawnCli });
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     return {
@@ -2137,7 +2376,8 @@ async function runBootstrap(options) {
       prompt: userPrompt,
       allowedTools: BOOTSTRAP_TOOLS,
       cwd: repoRoot,
-      model: options.model,
+      provider,
+      model,
       onMessage
     });
   } finally {
@@ -2160,6 +2400,19 @@ async function runBootstrap(options) {
     exitCode: 1
   };
 }
+async function resolveAgentSelection(args) {
+  const config = await readConfig();
+  const rawProvider = args.agent ?? config.agent.default;
+  if (!isAgentProviderId(rawProvider)) {
+    return {
+      ok: false,
+      error: `unknown agent '${rawProvider}'. Expected one of: claude, codex, cursor.`
+    };
+  }
+  const configuredModel = config.agent.models[rawProvider] ?? void 0;
+  const model = args.model !== void 0 ? args.model : configuredModel === null ? void 0 : configuredModel;
+  return { ok: true, provider: rawProvider, model };
+}
 function formatFinalLine(result, logPath, repoRoot) {
   const status = result.success ? "done" : "failed";
   const rel = relative(repoRoot, logPath);
@@ -2210,17 +2463,23 @@ var StreamingFormatter = class {
     this.currentAgent = name;
   }
   handle(msg) {
-    if (msg.type === "assistant") {
+    if (!isRecord(msg)) return;
+    if (msg.type === "assistant" && isRecord(msg.message)) {
+      const content = msg.message.content;
+      if (!Array.isArray(content)) return;
       for (const block of msg.message.content) {
-        if (block.type !== "tool_use") continue;
+        if (!isRecord(block) || block.type !== "tool_use") continue;
+        if (typeof block.name !== "string") continue;
         this.handleToolUse(block.name, block.input);
       }
       return;
     }
     if (msg.type === "result") {
       const status = msg.subtype === "success" ? "done" : `failed (${msg.subtype})`;
+      const cost = typeof msg.total_cost_usd === "number" ? msg.total_cost_usd : 0;
+      const turns = typeof msg.num_turns === "number" ? msg.num_turns : 0;
       this.sink.write(
-        `[${status}] cost: $${msg.total_cost_usd.toFixed(3)}, turns: ${msg.num_turns}
+        `[${status}] cost: $${cost.toFixed(3)}, turns: ${turns}
 `
       );
       return;
@@ -2292,23 +2551,246 @@ function stringField(input, key) {
   const value = input[key];
   return typeof value === "string" ? value : void 0;
 }
+function isRecord(value) {
+  return value !== null && typeof value === "object";
+}
 
 // src/commands/capture.ts
 import { createHash } from "crypto";
 import {
   createWriteStream as createWriteStream2,
-  existsSync as existsSync6,
+  existsSync as existsSync7,
   statSync
 } from "fs";
-import { mkdir as mkdir3, readFile as readFile6, readdir as readdir2, stat } from "fs/promises";
+import { mkdir as mkdir4, readFile as readFile7, readdir as readdir3, stat } from "fs/promises";
 import { homedir } from "os";
-import { basename as basename3, join as join7, relative as relative2 } from "path";
+import { basename as basename3, join as join8, relative as relative3 } from "path";
+
+// src/commands/captureStatus.ts
+import { existsSync as existsSync6 } from "fs";
+import { mkdir as mkdir3, readFile as readFile6, readdir as readdir2, rename as rename2, writeFile as writeFile3 } from "fs/promises";
+import { dirname, join as join7, relative as relative2 } from "path";
+function captureStatePath(dir, stem) {
+  return join7(dir, `.capture-${stem}.state.json`);
+}
+async function writeCaptureRunRecord(path2, record) {
+  await mkdir3(dirname(path2), { recursive: true });
+  const tmp = `${path2}.tmp-${process.pid}`;
+  await writeFile3(tmp, `${JSON.stringify(record, null, 2)}
+`, "utf8");
+  await rename2(tmp, path2);
+}
+function buildStartedCaptureRecord(args) {
+  return {
+    version: 1,
+    kind: "capture",
+    status: "running",
+    sessionId: args.sessionId ?? args.stem,
+    repoRoot: args.repoRoot,
+    pid: process.pid,
+    model: args.model ?? DEFAULT_AGENT_MODEL,
+    transcriptPath: args.transcriptPath,
+    startedAt: args.startedAt.toISOString(),
+    logPath: join7(args.almanacDir, `.capture-${args.stem}.log`),
+    jsonlPath: join7(args.almanacDir, `.capture-${args.stem}.jsonl`)
+  };
+}
+function finishCaptureRecord(args) {
+  const started = Date.parse(args.record.startedAt);
+  const finished = args.finishedAt.getTime();
+  return {
+    ...args.record,
+    status: args.status,
+    finishedAt: args.finishedAt.toISOString(),
+    durationMs: Number.isFinite(started) ? Math.max(0, finished - started) : void 0,
+    summary: args.summary,
+    error: args.error
+  };
+}
+async function runCaptureStatus(options) {
+  const repoRoot = findNearestAlmanacDir(options.cwd);
+  if (repoRoot === null) {
+    return {
+      stdout: "",
+      stderr: "almanac: no .almanac/ found in this directory or any parent. Run 'almanac bootstrap' first.\n",
+      exitCode: 1
+    };
+  }
+  const almanacDir = getRepoAlmanacDir(repoRoot);
+  const records = await readCaptureRecords(almanacDir);
+  const now = options.now?.() ?? /* @__PURE__ */ new Date();
+  const isPidAlive = options.isPidAlive ?? defaultIsPidAlive;
+  const views = records.map((record) => toView(record, repoRoot, now, isPidAlive)).sort((a, b) => b.sortTime - a.sortTime);
+  if (options.json === true) {
+    return {
+      stdout: `${JSON.stringify(
+        {
+          repo: repoRoot,
+          captures: views.map(({ sortTime: _sortTime, ...v }) => v)
+        },
+        null,
+        2
+      )}
+`,
+      stderr: "",
+      exitCode: 0
+    };
+  }
+  return {
+    stdout: formatCaptureStatus(views),
+    stderr: "",
+    exitCode: 0
+  };
+}
+async function readCaptureRecords(almanacDir) {
+  if (!existsSync6(almanacDir)) return [];
+  const out = [];
+  const dirs = [join7(almanacDir, "logs"), almanacDir];
+  for (const dir of dirs) {
+    let entries;
+    try {
+      entries = await readdir2(dir);
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (!entry.startsWith(".capture-") || !entry.endsWith(".state.json")) {
+        continue;
+      }
+      try {
+        const parsed = JSON.parse(await readFile6(join7(dir, entry), "utf8"));
+        if (isCaptureRunRecord(parsed)) out.push(parsed);
+      } catch {
+        continue;
+      }
+    }
+  }
+  return out;
+}
+function isCaptureRunRecord(value) {
+  if (value === null || typeof value !== "object") return false;
+  const v = value;
+  return v.version === 1 && v.kind === "capture" && (v.status === "running" || v.status === "done" || v.status === "failed") && typeof v.sessionId === "string" && typeof v.repoRoot === "string" && typeof v.pid === "number" && typeof v.model === "string" && typeof v.transcriptPath === "string" && typeof v.startedAt === "string" && typeof v.logPath === "string" && typeof v.jsonlPath === "string";
+}
+function toView(record, repoRoot, now, isPidAlive) {
+  const started = Date.parse(record.startedAt);
+  const finished = record.finishedAt !== void 0 ? Date.parse(record.finishedAt) : void 0;
+  const elapsedMs = record.durationMs ?? (Number.isFinite(started) ? Math.max(0, (finished ?? now.getTime()) - started) : 0);
+  const status = record.status === "running" && !isPidAlive(record.pid) ? "stale" : record.status;
+  return {
+    status,
+    sessionId: record.sessionId,
+    model: record.model,
+    elapsedMs,
+    startedAt: record.startedAt,
+    finishedAt: record.finishedAt,
+    pid: record.pid,
+    logPath: relative2(repoRoot, record.logPath),
+    jsonlPath: relative2(repoRoot, record.jsonlPath),
+    summary: record.summary,
+    error: status === "stale" ? "process ended without a final status" : record.error,
+    sortTime: finished ?? (Number.isFinite(started) ? started : 0)
+  };
+}
+function formatCaptureStatus(views) {
+  const lines = ["Capture jobs", ""];
+  if (views.length === 0) {
+    lines.push("No capture jobs found.");
+    return `${lines.join("\n")}
+`;
+  }
+  const active = views.filter((v) => v.status === "running" || v.status === "stale");
+  const finished = views.filter((v) => v.status === "done" || v.status === "failed");
+  if (active.length === 0) {
+    lines.push("No active captures.", "");
+  } else {
+    for (const view of active) {
+      lines.push(formatRow(view));
+      lines.push(`         log: ${view.logPath}`);
+      if (view.error !== void 0) lines.push(`         error: ${view.error}`);
+      lines.push("");
+    }
+  }
+  if (finished.length > 0) {
+    lines.push(active.length === 0 ? "Last capture:" : "Last finished:");
+    for (const view of finished.slice(0, 3)) {
+      lines.push(formatRow(view));
+      if (view.status === "failed") {
+        lines.push(`         log: ${view.logPath}`);
+        if (view.error !== void 0) lines.push(`         error: ${view.error}`);
+      }
+    }
+  }
+  return `${trimTrailingBlank(lines).join("\n")}
+`;
+}
+function formatRow(view) {
+  const status = view.status.padEnd(7, " ");
+  const session = view.sessionId.padEnd(12, " ");
+  const model = view.model.padEnd(17, " ");
+  const elapsed = formatDuration(view.elapsedMs);
+  const summary = formatSummary(view);
+  return `${status}  ${session}  ${model}  ${elapsed}${summary.length > 0 ? `  ${summary}` : ""}`;
+}
+function formatSummary(view) {
+  if (view.status === "failed") return "failed; see log";
+  if (view.summary === void 0) return "";
+  const parts = [];
+  if (view.summary.updated > 0) {
+    parts.push(`${view.summary.updated} updated`);
+  }
+  if (view.summary.created > 0) {
+    parts.push(`${view.summary.created} created`);
+  }
+  if (view.summary.archived > 0) {
+    parts.push(`${view.summary.archived} archived`);
+  }
+  return parts.length > 0 ? parts.join(", ") : "0 pages written";
+}
+function formatDuration(ms) {
+  const totalSeconds = Math.max(0, Math.floor(ms / 1e3));
+  const minutes = Math.floor(totalSeconds / 60);
+  const seconds = totalSeconds % 60;
+  if (minutes < 60) return `${minutes}m${seconds.toString().padStart(2, "0")}s`;
+  const hours = Math.floor(minutes / 60);
+  const restMinutes = minutes % 60;
+  return `${hours}h${restMinutes.toString().padStart(2, "0")}m`;
+}
+function trimTrailingBlank(lines) {
+  while (lines.length > 0 && lines[lines.length - 1] === "") {
+    lines.pop();
+  }
+  return lines;
+}
+function defaultIsPidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/commands/capture.ts
 var WRITER_TOOLS = ["Read", "Write", "Edit", "Glob", "Grep", "Bash", "Agent"];
 var REVIEWER_TOOLS = ["Read", "Grep", "Glob", "Bash"];
 var REVIEWER_DESCRIPTION = "Reviews proposed wiki changes against the full knowledge base for cohesion, duplication, missing links, notability, and writing conventions.";
 async function runCapture(options) {
+  const providerResolution = await resolveAgentSelection2({
+    agent: options.agent,
+    model: options.model
+  });
+  if (!providerResolution.ok) {
+    return {
+      stdout: "",
+      stderr: `almanac: ${providerResolution.error}
+`,
+      exitCode: 1
+    };
+  }
+  const { provider, model } = providerResolution;
   try {
-    await assertClaudeAuth(options.spawnCli);
+    await assertAgentAuth({ provider, spawnCli: options.spawnCli });
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     return {
@@ -2327,7 +2809,7 @@ async function runCapture(options) {
     };
   }
   const almanacDir = getRepoAlmanacDir(repoRoot);
-  const pagesDir = join7(almanacDir, "pages");
+  const pagesDir = join8(almanacDir, "pages");
   const transcriptResolution = await resolveTranscript({
     repoRoot,
     explicit: options.transcriptPath,
@@ -2353,12 +2835,24 @@ async function runCapture(options) {
       tools: REVIEWER_TOOLS
     }
   };
-  const now = options.now?.() ?? /* @__PURE__ */ new Date();
-  const logStem = options.sessionId !== void 0 && options.sessionId.length > 0 ? options.sessionId : formatTimestamp2(now);
-  const logsDir = join7(almanacDir, "logs");
-  await mkdir3(logsDir, { recursive: true });
+  const startedAt = options.now?.() ?? /* @__PURE__ */ new Date();
+  const logStem = options.sessionId !== void 0 && options.sessionId.length > 0 ? options.sessionId : formatTimestamp2(startedAt);
+  const logsDir = join8(almanacDir, "logs");
+  await mkdir4(logsDir, { recursive: true });
   const logName = `.capture-${logStem}.jsonl`;
-  const logPath = join7(logsDir, logName);
+  const logPath = join8(logsDir, logName);
+  const statePath = captureStatePath(logsDir, logStem);
+  const stateRecord = buildStartedCaptureRecord({
+    repoRoot,
+    almanacDir: logsDir,
+    stem: logStem,
+    sessionId: options.sessionId,
+    transcriptPath,
+    model: options.model,
+    startedAt
+  });
+  await writeCaptureRunRecord(statePath, stateRecord).catch(() => {
+  });
   const logStream = createWriteStream2(logPath, { flags: "w" });
   const out = process.stdout;
   const formatter = new StreamingFormatter({
@@ -2387,7 +2881,8 @@ Working directory: ${repoRoot}.`;
       allowedTools: WRITER_TOOLS,
       agents,
       cwd: repoRoot,
-      model: options.model,
+      provider,
+      model,
       // Capture sessions can touch many pages; give it more headroom than
       // bootstrap. The SDK treats `maxTurns` as a hard stop — better to
       // overshoot than to cut off mid-review.
@@ -2399,16 +2894,43 @@ Working directory: ${repoRoot}.`;
   }
   const snapshotAfter = await snapshotPages(pagesDir);
   const delta = diffSnapshots(snapshotBefore, snapshotAfter);
+  const finishedAt = options.now?.() ?? /* @__PURE__ */ new Date();
+  const captureSummary = {
+    ...delta,
+    cost: result.cost,
+    turns: result.turns
+  };
   if (!result.success) {
+    await writeCaptureRunRecord(
+      statePath,
+      finishCaptureRecord({
+        record: stateRecord,
+        status: "failed",
+        finishedAt,
+        summary: captureSummary,
+        error: result.error ?? "unknown error"
+      })
+    ).catch(() => {
+    });
     return {
       stdout: "",
       stderr: `almanac: capture failed: ${result.error ?? "unknown error"}
-(transcript: ${relative2(repoRoot, logPath)})
+(transcript: ${relative3(repoRoot, logPath)})
 `,
       exitCode: 1
     };
   }
-  const summary = formatSummary(result, delta, logPath, repoRoot);
+  await writeCaptureRunRecord(
+    statePath,
+    finishCaptureRecord({
+      record: stateRecord,
+      status: "done",
+      finishedAt,
+      summary: captureSummary
+    })
+  ).catch(() => {
+  });
+  const summary = formatSummary2(result, delta, logPath, repoRoot);
   return {
     stdout: `${summary}
 `,
@@ -2416,9 +2938,22 @@ Working directory: ${repoRoot}.`;
     exitCode: 0
   };
 }
+async function resolveAgentSelection2(args) {
+  const config = await readConfig();
+  const rawProvider = args.agent ?? config.agent.default;
+  if (!isAgentProviderId(rawProvider)) {
+    return {
+      ok: false,
+      error: `unknown agent '${rawProvider}'. Expected one of: claude, codex, cursor.`
+    };
+  }
+  const configuredModel = config.agent.models[rawProvider] ?? void 0;
+  const model = args.model !== void 0 ? args.model : configuredModel === null ? void 0 : configuredModel;
+  return { ok: true, provider: rawProvider, model };
+}
 async function resolveTranscript(args) {
   if (args.explicit !== void 0 && args.explicit.length > 0) {
-    if (!existsSync6(args.explicit)) {
+    if (!existsSync7(args.explicit)) {
       return {
         ok: false,
         error: `transcript not found: ${args.explicit}`
@@ -2426,8 +2961,8 @@ async function resolveTranscript(args) {
     }
     return { ok: true, path: args.explicit };
   }
-  const projectsDir = args.claudeProjectsDir ?? join7(homedir(), ".claude", "projects");
-  if (!existsSync6(projectsDir)) {
+  const projectsDir = args.claudeProjectsDir ?? join8(homedir(), ".claude", "projects");
+  if (!existsSync7(projectsDir)) {
     return {
       ok: false,
       error: `could not auto-resolve transcript; ${projectsDir} does not exist. Pass --session <id> or <transcript-path>.`
@@ -2459,21 +2994,21 @@ async function collectTranscripts(projectsDir) {
   const out = [];
   let topLevel;
   try {
-    topLevel = await readdir2(projectsDir);
+    topLevel = await readdir3(projectsDir);
   } catch {
     return out;
   }
   for (const name of topLevel) {
-    const projectDir = join7(projectsDir, name);
+    const projectDir = join8(projectsDir, name);
     let entries;
     try {
-      entries = await readdir2(projectDir);
+      entries = await readdir3(projectDir);
     } catch {
       continue;
     }
     for (const entry of entries) {
       if (!entry.endsWith(".jsonl")) continue;
-      const full = join7(projectDir, entry);
+      const full = join8(projectDir, entry);
       try {
         const st = await stat(full);
         if (st.isFile()) {
@@ -2488,7 +3023,7 @@ async function collectTranscripts(projectsDir) {
 async function filterTranscriptsByCwd(transcripts, repoRoot) {
   const dirHash = `-${repoRoot.replace(/^\/+/, "").replace(/\//g, "-")}`;
   const byDirName = transcripts.filter((t) => {
-    const parent = basename3(join7(t.path, ".."));
+    const parent = basename3(join8(t.path, ".."));
     return parent === dirHash || parent.endsWith(dirHash);
   });
   if (byDirName.length > 0) return byDirName;
@@ -2505,26 +3040,26 @@ async function filterTranscriptsByCwd(transcripts, repoRoot) {
   return hits;
 }
 async function readHead(path2, bytes) {
-  const content = await readFile6(path2, "utf8");
+  const content = await readFile7(path2, "utf8");
   return content.length > bytes ? content.slice(0, bytes) : content;
 }
 async function snapshotPages(pagesDir) {
   const out = /* @__PURE__ */ new Map();
-  if (!existsSync6(pagesDir)) return out;
+  if (!existsSync7(pagesDir)) return out;
   let entries;
   try {
-    entries = await readdir2(pagesDir);
+    entries = await readdir3(pagesDir);
   } catch {
     return out;
   }
   for (const entry of entries) {
     if (!entry.endsWith(".md")) continue;
     const slug = entry.slice(0, -3);
-    const full = join7(pagesDir, entry);
+    const full = join8(pagesDir, entry);
     try {
       const st = statSync(full);
       if (!st.isFile()) continue;
-      const content = await readFile6(full, "utf8");
+      const content = await readFile7(full, "utf8");
       const hash = createHash("sha256").update(content).digest("hex");
       const fm = parseFrontmatter(content);
       out.set(slug, {
@@ -2558,8 +3093,8 @@ function diffSnapshots(before, after) {
   }
   return { created, updated, archived };
 }
-function formatSummary(result, delta, logPath, repoRoot) {
-  const rel = relative2(repoRoot, logPath);
+function formatSummary2(result, delta, logPath, repoRoot) {
+  const rel = relative3(repoRoot, logPath);
   const cost = `$${result.cost.toFixed(3)}`;
   const { created, updated, archived } = delta;
   if (created === 0 && updated === 0 && archived === 0) {
@@ -2594,18 +3129,19 @@ async function runReindex(options) {
 function registerWikiLifecycleCommands(program) {
   program.command("bootstrap").description(
     "scaffold a wiki in this repo via an AI agent (requires ANTHROPIC_API_KEY or Claude subscription)"
-  ).option("--quiet", "suppress per-tool streaming; print only the final line").option("--model <model>", "override the agent model").option("--force", "overwrite an existing populated wiki (default: refuse)").action(
+  ).option("--quiet", "suppress per-tool streaming; print only the final line").option("--agent <agent>", "agent provider: claude, codex, or cursor").option("--model <model>", "override the agent model").option("--force", "overwrite an existing populated wiki (default: refuse)").action(
     async (opts) => {
       const result = await runBootstrap({
         cwd: process.cwd(),
         quiet: opts.quiet,
+        agent: opts.agent,
         model: opts.model,
         force: opts.force
       });
       emit(result);
     }
   );
-  program.command("capture [transcript]").description("run the writer/reviewer pipeline on a session (usually automatic)").option("--session <id>", "target a specific session by ID").option("--quiet", "suppress per-tool streaming; print only the final summary").option("--model <model>", "override the agent model").action(
+  const capture = program.command("capture [transcript]").alias("c").description("run the writer/reviewer pipeline on a session (usually automatic)").option("--session <id>", "target a specific session by ID").option("--quiet", "suppress per-tool streaming; print only the final summary").option("--agent <agent>", "agent provider: claude, codex, or cursor").option("--model <model>", "override the agent model").action(
     async (transcript, opts) => {
       await autoRegisterIfNeeded(process.cwd());
       const result = await runCapture({
@@ -2613,14 +3149,33 @@ function registerWikiLifecycleCommands(program) {
         transcriptPath: transcript,
         sessionId: opts.session,
         quiet: opts.quiet,
+        agent: opts.agent,
         model: opts.model
       });
       emit(result);
     }
   );
+  capture.command("status").description("show running and recent capture jobs").option("--json", "emit structured JSON").action(async (opts) => {
+    await autoRegisterIfNeeded(process.cwd());
+    const result = await runCaptureStatus({
+      cwd: process.cwd(),
+      json: opts.json
+    });
+    emit(result);
+  });
+  program.command("ps").description("show running and recent capture jobs").option("--json", "emit structured JSON").action(async (opts) => {
+    await autoRegisterIfNeeded(process.cwd());
+    const result = await runCaptureStatus({
+      cwd: process.cwd(),
+      json: opts.json
+    });
+    emit(result);
+  });
   const hook = program.command("hook").description("manage the SessionEnd auto-capture hook");
-  hook.command("install").description("add a SessionEnd entry that runs 'almanac capture' on session end").action(async () => {
-    const result = await runHookInstall();
+  hook.command("install").description("add a SessionEnd entry that runs 'almanac capture' on session end").option("--source <source>", "claude, codex, cursor, or all").action(async (opts) => {
+    const result = await runHookInstall({
+      source: normalizeHookSource(opts.source)
+    });
     emit(result);
   });
   hook.command("uninstall").description("remove codealmanac's SessionEnd entry; leaves foreign entries alone").action(async () => {
@@ -2641,6 +3196,12 @@ function registerWikiLifecycleCommands(program) {
     if (result.exitCode !== 0) process.exitCode = result.exitCode;
   });
 }
+function normalizeHookSource(source) {
+  if (source === "claude" || source === "codex" || source === "cursor" || source === "all") {
+    return source;
+  }
+  return void 0;
+}
 
 // src/cli/register-commands.ts
 function registerCommands(program) {
@@ -2652,4 +3213,4 @@ function registerCommands(program) {
 export {
   registerCommands
 };
-//# sourceMappingURL=register-commands-JHC2OFKM.js.map
+//# sourceMappingURL=register-commands-DPH4ZWEE.js.map