codealmanac 0.2.5 → 0.2.7

package/dist/{register-commands-FBJ6XQ3L.js → register-commands-LULZUSPO.js}

@@ -1,4 +1,18 @@
 #!/usr/bin/env node
+import {
+  runUpdate
+} from "./chunk-ZZLLOAI6.js";
+import {
+  finishRunRecord,
+  listRunRecords,
+  markRunCancelled,
+  readRunRecord,
+  runRecordPath,
+  startBackgroundProcess,
+  startForegroundProcess,
+  toRunView,
+  writeRunRecord
+} from "./chunk-WL4UE7Q6.js";
 import {
   collectOption,
   deprecationWarning,
@@ -14,40 +28,42 @@ import {
   runAgentsUse,
   runDeprecatedSetAgentModel,
   runDeprecatedSetDefaultAgent
-} from "./chunk-6BJUYZ43.js";
+} from "./chunk-QIA22IAM.js";
 import {
   runConfigGet,
   runConfigList,
   runConfigSet,
   runConfigUnset
-} from "./chunk-TT6ZP4GS.js";
+} from "./chunk-KZXWPG4P.js";
 import {
   addEntry,
   ancestorsInFile,
   descendantsInDb,
   dropEntry,
-  ensureFreshIndex,
   ensureGlobalDir,
+  parseDuration,
+  readRegistry,
+  resolveWikiRoot,
+  runHealth
+} from "./chunk-IZBXXAVL.js";
+import {
+  ensureFreshIndex,
   ensureTopic,
   findTopic,
   loadTopicsFile,
   looksLikeDir,
   normalizePath,
   openIndex,
-  parseDuration,
-  parseFrontmatter,
-  readRegistry,
-  resolveWikiRoot,
-  runHealth,
   runIndexer,
   titleCase,
   toKebabCase,
   writeTopicsFile
-} from "./chunk-KQUVMF27.js";
+} from "./chunk-BFIG2CXM.js";
 import {
   runDoctor
-} from "./chunk-SMIK2YLU.js";
-import "./chunk-TILAKDN6.js";
+} from "./chunk-JLQZELHQ.js";
+import "./chunk-U5DLLWIC.js";
+import "./chunk-CQJVM34R.js";
 import "./chunk-4CODZRHH.js";
 import {
   BLUE,
@@ -57,34 +73,24 @@ import {
 } from "./chunk-FM3VRDK7.js";
 import {
   runUninstall
-} from "./chunk-DL5BXZCX.js";
+} from "./chunk-BQY5L3DL.js";
 import {
   runSetup
-} from "./chunk-GFUB57IT.js";
+} from "./chunk-ZUQN5Y3K.js";
 import {
   runHookInstall,
   runHookStatus,
   runHookUninstall
 } from "./chunk-447U3GQJ.js";
+import "./chunk-RALBM6HZ.js";
+import "./chunk-FUBE6KCO.js";
 import {
-  DEFAULT_AGENT_MODEL,
-  assertAgentAuth,
-  getAgentProvider,
-  getProviderDefaultModel,
-  parseAgentSelection
-} from "./chunk-BGUID5BS.js";
-import {
-  runUpdate
-} from "./chunk-MRRX4UQB.js";
-import "./chunk-F53U6JQG.js";
-import {
-  isAgentProviderId,
   readConfig
-} from "./chunk-P5WGG4FJ.js";
+} from "./chunk-5BWUMAOX.js";
 import {
   findNearestAlmanacDir,
   getRepoAlmanacDir
-} from "./chunk-7JUX4ADQ.js";
+} from "./chunk-IZT6RBHS.js";
 
 // src/topics/frontmatter-rewrite.ts
 import { readFile, rename, writeFile } from "fs/promises";
@@ -1183,7 +1189,7 @@ function isReachable(entry) {
 }
 function formatPretty(entries) {
   if (entries.length === 0) {
-    return `${DIM}no wikis registered. run \`almanac bootstrap\` in a repo to create one.${RST}
+    return `${DIM}no wikis registered. run \`almanac init\` in a repo to create one.${RST}
 `;
   }
   const nameWidth = Math.min(
@@ -1790,7 +1796,7 @@ function registerQueryCommands(program) {
 // src/cli/register-setup-commands.ts
 function registerSetupCommands(program) {
   const agents = program.command("agents").description("list supported AI agent providers and readiness");
-  agents.command("list").description("show supported provider status, defaults, and models").action(async () => {
+  agents.command("list").description("show Claude, Codex, and Cursor provider status").action(async () => {
     emit(await runAgentsList());
   });
   agents.command("doctor").description("diagnose supported AI agent providers").action(async () => {
@@ -1837,7 +1843,7 @@ function registerSetupCommands(program) {
       exitCode: 1
     });
   });
-  program.command("setup").description("choose provider/model and install provider integrations").option("-y, --yes", "skip prompts; install everything").option("--agent <agent>", "default provider: claude, codex, or cursor").option("--model <model>", "default model for the selected agent").option("--skip-hook", "opt out of auto-capture hooks").option("--skip-guides", "opt out of provider guide install").action(
+  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("--model <model>", "default model for the selected agent").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,
@@ -1880,9 +1886,9 @@ function registerSetupCommands(program) {
       emit(result);
     }
   );
-  program.command("uninstall").description("remove the hook + guides + import line").option("-y, --yes", "skip confirmations; remove everything").option("--keep-hook", "don't remove auto-capture hooks (guides still prompted unless --yes)").option(
+  program.command("uninstall").description("remove the hook + guides + import line").option("-y, --yes", "skip confirmations; remove everything").option("--keep-hook", "don't remove the SessionEnd hook (guides still prompted unless --yes)").option(
     "--keep-guides",
-    "don't remove guides or provider imports/rules (hook still prompted unless --yes)"
+    "don't remove the guides or CLAUDE.md import (hook still prompted unless --yes)"
   ).action(
     async (opts) => {
       const result = await runUninstall({
@@ -1895,20 +1901,290 @@ function registerSetupCommands(program) {
   );
 }
 
-// src/commands/bootstrap.ts
-import { createWriteStream, existsSync as existsSync5 } from "fs";
-import { mkdir as mkdir2, readdir } from "fs/promises";
-import { join as join6, relative } from "path";
+// src/commands/jobs.ts
+import { readFile as readFile4 } from "fs/promises";
+
+// src/cli/outcome.ts
+function renderOutcome(outcome, opts = {}) {
+  const exitCode = opts.exitCode ?? defaultExitCode(outcome);
+  if (opts.json === true) {
+    return {
+      stdout: `${JSON.stringify(outcome, null, 2)}
+`,
+      stderr: "",
+      exitCode
+    };
+  }
+  if (outcome.type === "needs-action") {
+    return {
+      stdout: opts.stdout ?? "",
+      stderr: `almanac: ${outcome.message}
+${outcome.fix}
+`,
+      exitCode
+    };
+  }
+  if (outcome.type === "error") {
+    return {
+      stdout: opts.stdout ?? "",
+      stderr: `almanac: ${outcome.message}
+`,
+      exitCode
+    };
+  }
+  return {
+    stdout: opts.stdout ?? `${outcome.message}
+`,
+    stderr: "",
+    exitCode
+  };
+}
+function defaultExitCode(outcome) {
+  switch (outcome.type) {
+    case "success":
+    case "noop":
+      return 0;
+    case "needs-action":
+    case "error":
+      return 1;
+  }
+}
+
+// src/commands/jobs.ts
+async function runJobsList(options) {
+  const repoRoot = resolveWikiOrResult(options.cwd, options.json);
+  if (typeof repoRoot !== "string") return repoRoot;
+  const views = await listRunViews(repoRoot, options);
+  if (options.json === true) {
+    return {
+      stdout: `${JSON.stringify({ runs: views }, null, 2)}
+`,
+      stderr: "",
+      exitCode: 0
+    };
+  }
+  if (views.length === 0) {
+    return { stdout: "Jobs\n\nNo jobs found.\n", stderr: "", exitCode: 0 };
+  }
+  const lines = ["Jobs", ""];
+  for (const view of views) {
+    lines.push(
+      `${view.id}  ${view.operation}  ${view.displayStatus}  ${formatMs(view.elapsedMs)}`
+    );
+  }
+  return { stdout: `${lines.join("\n")}
+`, stderr: "", exitCode: 0 };
+}
+async function runJobsShow(options) {
+  const repoRoot = resolveWikiOrResult(options.cwd, options.json);
+  if (typeof repoRoot !== "string") return repoRoot;
+  const view = await readRunView(repoRoot, options);
+  if (view === null) return missingRun(options.runId, options.json);
+  if (options.json === true) {
+    return {
+      stdout: `${JSON.stringify(view, null, 2)}
+`,
+      stderr: "",
+      exitCode: 0
+    };
+  }
+  return {
+    stdout: [
+      `Run: ${view.id}`,
+      `Operation: ${view.operation}`,
+      `Status: ${view.displayStatus}`,
+      `Provider: ${view.provider}${view.model !== void 0 ? `/${view.model}` : ""}`,
+      `Elapsed: ${formatMs(view.elapsedMs)}`,
+      `Log: ${view.logPath}`,
+      view.failure !== void 0 ? `Reason: ${view.failure.message}` : view.error !== void 0 ? `Error: ${view.error}` : void 0,
+      view.failure?.fix !== void 0 ? `Fix: ${view.failure.fix}` : void 0
+    ].filter((line) => line !== void 0).join("\n") + "\n",
+    stderr: "",
+    exitCode: 0
+  };
+}
+async function runJobsLogs(options) {
+  const repoRoot = resolveWikiOrResult(options.cwd, options.json);
+  if (typeof repoRoot !== "string") return repoRoot;
+  const record = await readRunRecord(runRecordPath(repoRoot, options.runId));
+  if (record === null) return missingRun(options.runId, options.json);
+  try {
+    return {
+      stdout: await readFile4(record.logPath, "utf8"),
+      stderr: "",
+      exitCode: 0
+    };
+  } catch (err) {
+    return renderOutcome(
+      {
+        type: "error",
+        message: err instanceof Error ? err.message : String(err)
+      },
+      { json: options.json }
+    );
+  }
+}
+async function streamJobsAttach(options) {
+  const repoRoot = resolveWikiOrResult(options.cwd, options.json);
+  if (typeof repoRoot !== "string") return repoRoot;
+  const initial = await readRunRecord(runRecordPath(repoRoot, options.runId));
+  if (initial === null) return missingRun(options.runId, options.json);
+  const write = options.write ?? ((chunk) => process.stdout.write(chunk));
+  let offset = 0;
+  while (true) {
+    const record = await readRunRecord(runRecordPath(repoRoot, options.runId));
+    if (record === null) return missingRun(options.runId, options.json);
+    offset = await writeLogChunk(record.logPath, offset, write);
+    const view = toRunView({
+      record,
+      now: options.now?.() ?? /* @__PURE__ */ new Date(),
+      isPidAlive: options.isPidAlive ?? isPidAlive
+    });
+    if (view.displayStatus === "done" || view.displayStatus === "failed" || view.displayStatus === "cancelled" || view.displayStatus === "stale") {
+      const summary = terminalAttachSummary(view);
+      if (summary.length > 0) write(summary);
+      return { stdout: "", stderr: "", exitCode: 0 };
+    }
+    await sleep(options.pollMs ?? 500);
+  }
+}
+async function runJobsCancel(options) {
+  const repoRoot = resolveWikiOrResult(options.cwd, options.json);
+  if (typeof repoRoot !== "string") return repoRoot;
+  const path2 = runRecordPath(repoRoot, options.runId);
+  const record = await readRunRecord(path2);
+  if (record === null) return missingRun(options.runId, options.json);
+  if (record.status === "done" || record.status === "failed" || record.status === "cancelled") {
+    return renderOutcome(
+      {
+        type: "noop",
+        message: `job already ${record.status}: ${record.id}`,
+        data: { runId: record.id, status: record.status }
+      },
+      { json: options.json }
+    );
+  }
+  await markRunCancelled(repoRoot, record.id);
+  if (record.pid > 0) {
+    try {
+      process.kill(record.pid, "SIGTERM");
+    } catch {
+    }
+  }
+  const cancelled = finishRunRecord({
+    record,
+    status: "cancelled",
+    finishedAt: options.now?.() ?? /* @__PURE__ */ new Date()
+  });
+  await writeRunRecord(path2, cancelled);
+  return renderOutcome(
+    {
+      type: "success",
+      message: `cancelled job: ${record.id}`,
+      data: { runId: record.id, status: "cancelled" }
+    },
+    { json: options.json }
+  );
+}
+async function listRunViews(repoRoot, options) {
+  const records = await listRunRecords(repoRoot);
+  return records.map(
+    (record) => toRunView({
+      record,
+      now: options.now?.() ?? /* @__PURE__ */ new Date(),
+      isPidAlive: options.isPidAlive ?? isPidAlive
+    })
+  );
+}
+async function readRunView(repoRoot, options) {
+  const record = await readRunRecord(runRecordPath(repoRoot, options.runId));
+  if (record === null) return null;
+  return toRunView({
+    record,
+    now: options.now?.() ?? /* @__PURE__ */ new Date(),
+    isPidAlive: options.isPidAlive ?? isPidAlive
+  });
+}
+function resolveWikiOrResult(cwd, json) {
+  const repoRoot = findNearestAlmanacDir(cwd);
+  if (repoRoot !== null) return repoRoot;
+  return renderOutcome(
+    {
+      type: "needs-action",
+      message: "no .almanac/ found in this directory or any parent",
+      fix: "run: almanac init"
+    },
+    { json }
+  );
+}
+function missingRun(runId, json) {
+  return renderOutcome(
+    { type: "error", message: `run not found: ${runId}` },
+    { json }
+  );
+}
+async function writeLogChunk(path2, offset, write) {
+  let text = "";
+  try {
+    text = await readFile4(path2, "utf8");
+  } catch {
+    return offset;
+  }
+  if (text.length <= offset) return offset;
+  const chunk = text.slice(offset);
+  write(chunk);
+  return text.length;
+}
+function sleep(ms) {
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
+}
+function isPidAlive(pid) {
+  if (pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function formatMs(ms) {
+  if (ms < 1e3) return `${ms}ms`;
+  const seconds = Math.round(ms / 1e3);
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.round(seconds / 60);
+  if (minutes < 60) return `${minutes}m`;
+  return `${Math.round(minutes / 60)}h`;
+}
+function terminalAttachSummary(view) {
+  if (view.displayStatus !== "failed" && view.displayStatus !== "stale") {
+    return "";
+  }
+  const lines = [`job ${view.displayStatus}: ${view.id}`];
+  if (view.failure !== void 0) {
+    lines.push(`Reason: ${view.failure.message}`);
+    if (view.failure.fix !== void 0) lines.push(`Fix: ${view.failure.fix}`);
+  } else if (view.error !== void 0) {
+    lines.push(`Error: ${view.error}`);
+  }
+  return `${lines.join("\n")}
+`;
+}
+
+// src/commands/operations.ts
+import { resolve as resolve2 } from "path";
 
 // src/agent/prompts.ts
 import { existsSync as existsSync3 } from "fs";
-import { readFile as readFile4 } from "fs/promises";
+import { readFile as readFile5 } from "fs/promises";
 import path from "path";
 import { fileURLToPath } from "url";
 var PROMPT_NAMES = [
-  "bootstrap",
-  "writer",
-  "reviewer"
+  "base/purpose",
+  "base/notability",
+  "base/syntax",
+  "operations/build",
+  "operations/absorb",
+  "operations/garden"
 ];
 var overrideDir = null;
 var resolvedDir = null;
@@ -1943,82 +2219,132 @@ function isPromptsDir(dir) {
 }
 async function loadPrompt(name) {
   const dir = resolvePromptsDir();
-  return readFile4(path.join(dir, `${name}.md`), "utf8");
+  return readFile5(resolvePromptPath(dir, name), "utf8");
 }
-
-// src/agent/selection.ts
-async function resolveAgentSelection(args) {
-  const config = await readConfig({ cwd: args.cwd });
-  const rawAgent = args.agent ?? process.env.ALMANAC_AGENT ?? config.agent.default;
-  const agentSource = args.agent !== void 0 ? "flag" : process.env.ALMANAC_AGENT !== void 0 ? "env" : "config";
-  const parsed = parseAgentSelection(rawAgent);
-  if (parsed.provider === null || !isAgentProviderId(parsed.provider)) {
-    return {
-      ok: false,
-      error: `unknown agent '${rawAgent}'. Expected one of: claude, codex, cursor.`
-    };
+function resolvePromptPath(dir, name) {
+  if (name.length === 0 || path.isAbsolute(name) || name.includes("\\") || name.split("/").some((part) => part === "" || part === "." || part === "..")) {
+    throw new Error(`invalid prompt name: ${name}`);
   }
-  const provider = parsed.provider;
-  const configuredModel = config.agent.models[provider] ?? void 0;
-  const model = args.model !== void 0 ? args.model : parsed.model !== void 0 && agentSource === "flag" ? parsed.model : process.env.ALMANAC_MODEL !== void 0 ? process.env.ALMANAC_MODEL : parsed.model !== void 0 ? parsed.model : configuredModel === null ? void 0 : configuredModel;
-  return { ok: true, provider, model };
+  const file = path.resolve(dir, `${name}.md`);
+  const relative = path.relative(dir, file);
+  if (relative.startsWith("..") || path.isAbsolute(relative)) {
+    throw new Error(`invalid prompt name: ${name}`);
+  }
+  return file;
+}
+function joinPrompts(parts) {
+  return parts.map((part) => part?.trim()).filter((part) => part !== void 0 && part.length > 0).join("\n\n---\n\n");
 }
 
-// src/cli/outcome.ts
-function renderOutcome(outcome, opts = {}) {
-  const exitCode = opts.exitCode ?? defaultExitCode(outcome);
-  if (opts.json === true) {
-    return {
-      stdout: `${JSON.stringify(outcome, null, 2)}
-`,
-      stderr: "",
-      exitCode
-    };
-  }
-  if (outcome.type === "needs-action") {
-    return {
-      stdout: opts.stdout ?? "",
-      stderr: `almanac: ${outcome.message}
-${outcome.fix}
-`,
-      exitCode
-    };
-  }
-  if (outcome.type === "error") {
-    return {
-      stdout: opts.stdout ?? "",
-      stderr: `almanac: ${outcome.message}
-`,
-      exitCode
-    };
-  }
+// src/operations/run.ts
+var DEFAULT_MAX_TURNS = 150;
+var BASE_OPERATION_TOOLS = [
+  { id: "read" },
+  { id: "write" },
+  { id: "edit" },
+  { id: "search" },
+  { id: "shell" }
+];
+var BASE_PROMPTS = [
+  "base/purpose",
+  "base/notability",
+  "base/syntax"
+];
+async function createOperationRunSpec(args) {
+  const basePrompts = await Promise.all(
+    BASE_PROMPTS.map((name) => loadPrompt(name))
+  );
+  const operationPrompt = await loadPrompt(args.promptName);
+  const prompt = joinPrompts([
+    ...basePrompts,
+    operationPrompt,
+    operationRuntimeContext(args.repoRoot),
+    args.context
+  ]);
   return {
-    stdout: opts.stdout ?? `${outcome.message}
-`,
-    stderr: "",
-    exitCode
+    provider: args.provider ?? { id: "claude" },
+    cwd: args.repoRoot,
+    prompt,
+    tools: BASE_OPERATION_TOOLS,
+    limits: {
+      maxTurns: DEFAULT_MAX_TURNS
+    },
+    metadata: {
+      operation: args.operation,
+      targetKind: args.targetKind,
+      targetPaths: args.targetPaths
+    }
   };
 }
-function defaultExitCode(outcome) {
-  switch (outcome.type) {
-    case "success":
-    case "noop":
-      return 0;
-    case "needs-action":
-    case "error":
-      return 1;
+async function runOperationProcess(args) {
+  if (args.background) {
+    const background = await (args.startBackground ?? startBackgroundProcess)({
+      repoRoot: args.repoRoot,
+      spec: args.spec,
+      runId: args.runId
+    });
+    return { mode: "background", runId: background.runId, background };
   }
+  const foreground = await (args.startForeground ?? startForegroundProcess)({
+    repoRoot: args.repoRoot,
+    spec: args.spec,
+    runId: args.runId,
+    onEvent: args.onEvent
+  });
+  return { mode: "foreground", runId: foreground.runId, foreground };
+}
+function operationRuntimeContext(repoRoot) {
+  return [
+    "Runtime context:",
+    `- Repository root: ${repoRoot}`,
+    `- Almanac directory: ${repoRoot}/.almanac`,
+    `- Wiki pages directory: ${repoRoot}/.almanac/pages`
+  ].join("\n");
 }
 
-// src/agent/sdk.ts
-async function runAgent(opts) {
-  const provider = opts.provider ?? "claude";
-  return await getAgentProvider(provider).run(opts);
+// src/operations/absorb.ts
+async function createAbsorbRunSpec(args) {
+  return createOperationRunSpec({
+    operation: "absorb",
+    promptName: "operations/absorb",
+    provider: args.provider ?? { id: "claude" },
+    repoRoot: args.repoRoot,
+    context: args.context,
+    targetKind: args.targetKind,
+    targetPaths: args.targetPaths
+  });
+}
+async function runAbsorbOperation(options) {
+  const repoRoot = findNearestAlmanacDir(options.cwd);
+  if (repoRoot === null) {
+    throw new Error("no .almanac/ found in this directory or any parent");
+  }
+  const spec = await createAbsorbRunSpec({
+    repoRoot,
+    provider: options.provider,
+    context: options.context,
+    targetKind: options.targetKind,
+    targetPaths: options.targetPaths
+  });
+  return runOperationProcess({
+    repoRoot,
+    spec,
+    background: options.background !== false,
+    runId: options.runId,
+    onEvent: options.onEvent,
+    startForeground: options.startForeground,
+    startBackground: options.startBackground
+  });
 }
 
+// src/operations/build.ts
+import { existsSync as existsSync5 } from "fs";
+import { readdir } from "fs/promises";
+import { join as join6 } from "path";
+
 // src/commands/init.ts
 import { existsSync as existsSync4 } from "fs";
-import { mkdir, readFile as readFile5, writeFile as writeFile2 } from "fs/promises";
+import { mkdir, readFile as readFile6, writeFile as writeFile2 } from "fs/promises";
 import { basename as basename2, join as join5 } from "path";
 async function initWiki(options) {
   const repoRoot = findNearestAlmanacDir(options.cwd) ?? options.cwd;
@@ -2030,7 +2356,7 @@ async function initWiki(options) {
   if (!existsSync4(readmePath)) {
     await writeFile2(readmePath, starterReadme(), "utf8");
   }
-  await ensureGitignoreHasIndexDb(repoRoot);
+  await ensureGitignoreHasRuntimeArtifacts(repoRoot);
   const name = toKebabCase(options.name ?? basename2(repoRoot));
   if (name.length === 0) {
     throw new Error(
@@ -2048,23 +2374,17 @@ async function initWiki(options) {
   await addEntry(entry);
   return { entry, almanacDir, created: !alreadyExisted };
 }
-async function ensureGitignoreHasIndexDb(cwd) {
+async function ensureGitignoreHasRuntimeArtifacts(cwd) {
   const path2 = join5(cwd, ".gitignore");
   const targets = [
     ".almanac/index.db",
     ".almanac/index.db-wal",
     ".almanac/index.db-shm",
-    // Runtime logs written by the AI pipeline. These can be multi-megabyte
-    // JSONL files and should never be committed. Keep the old root-level
-    // globs too so repos initialized by earlier releases stay quiet.
-    ".almanac/logs/",
-    ".almanac/.capture-*",
-    ".almanac/.bootstrap-*",
-    ".almanac/.ingest-*"
+    ".almanac/runs/"
   ];
   let existing = "";
   if (existsSync4(path2)) {
-    existing = await readFile5(path2, "utf8");
+    existing = await readFile6(path2, "utf8");
   }
   const lines = existing.split(/\r?\n/).map((l) => l.trim());
   const missing = targets.filter((t) => !lines.includes(t));
@@ -2156,882 +2476,224 @@ 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 repoRoot = findNearestAlmanacDir(options.cwd) ?? options.cwd;
-  const providerResolution = await resolveAgentSelection({
-    agent: options.agent,
-    model: options.model,
-    cwd: repoRoot
+// src/operations/build.ts
+async function createBuildRunSpec(args) {
+  return createOperationRunSpec({
+    operation: "build",
+    promptName: "operations/build",
+    provider: args.provider ?? { id: "claude" },
+    repoRoot: args.repoRoot,
+    context: args.context,
+    targetKind: "repo",
+    targetPaths: [args.repoRoot]
   });
-  if (!providerResolution.ok) {
-    return renderOutcome(
-      { type: "error", message: providerResolution.error },
-      { json: options.json }
-    );
-  }
-  const { provider, model } = providerResolution;
-  try {
-    await assertAgentAuth({ provider, spawnCli: options.spawnCli });
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    return renderOutcome(
-      {
-        type: "needs-action",
-        message: msg,
-        fix: authFixFor(provider),
-        data: { provider }
-      },
-      { json: options.json }
+}
+async function runBuildOperation(options) {
+  const init = await initWiki({ cwd: options.cwd });
+  const repoRoot = init.entry.path;
+  const pageCount = await countWikiPages(repoRoot);
+  if (pageCount > 0 && options.force !== true) {
+    throw new Error(
+      `.almanac/ already initialized with ${pageCount} page${pageCount === 1 ? "" : "s"}; pass --force to rebuild`
     );
   }
-  const almanacDir = getRepoAlmanacDir(repoRoot);
-  const pagesDir = join6(almanacDir, "pages");
-  if (options.force !== true && existsSync5(pagesDir)) {
-    const existing = await countMarkdownPages(pagesDir);
-    if (existing > 0) {
-      return renderOutcome(
-        {
-          type: "needs-action",
-          message: `.almanac/ already initialized with ${existing} page${existing === 1 ? "" : "s"}.`,
-          fix: "run: almanac capture  (or pass --force to overwrite)",
-          data: { pages: existing }
-        },
-        { json: options.json }
-      );
-    }
-  }
-  if (!existsSync5(almanacDir)) {
-    try {
-      await initWiki({ cwd: repoRoot });
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      return renderOutcome(
-        { type: "error", message: `init failed during bootstrap: ${msg}` },
-        { json: options.json }
-      );
-    }
-  }
-  const systemPrompt = await loadPrompt("bootstrap");
-  const now = options.now?.() ?? /* @__PURE__ */ new Date();
-  const logsDir = join6(almanacDir, "logs");
-  await mkdir2(logsDir, { recursive: true });
-  const logName = `.bootstrap-${formatTimestamp(now)}.log`;
-  const logPath = join6(logsDir, logName);
-  const logStream = createWriteStream(logPath, { flags: "w" });
-  const out = process.stdout;
-  const formatter = new StreamingFormatter({
-    write: (line) => {
-      if (options.quiet !== true && options.json !== true) out.write(line);
-    }
+  const spec = await createBuildRunSpec({
+    repoRoot,
+    provider: options.provider,
+    context: options.context
   });
-  const onMessage = (msg) => {
-    try {
-      logStream.write(`${JSON.stringify(msg)}
-`);
-    } catch {
-    }
-    formatter.handle(msg);
-  };
-  const runner = options.runAgent ?? runAgent;
-  const userPrompt = `Begin the bootstrap now. Working directory: ${repoRoot}.`;
-  let result;
-  try {
-    result = await runner({
-      systemPrompt,
-      prompt: userPrompt,
-      allowedTools: BOOTSTRAP_TOOLS,
-      cwd: repoRoot,
-      provider,
-      model,
-      onMessage
-    });
-  } finally {
-    await closeStream(logStream);
-  }
-  const finalLine = formatFinalLine(result, logPath, repoRoot);
-  if (result.success) {
-    return renderOutcome(
-      {
-        type: "success",
-        message: finalLine,
-        data: runData(result, logPath, repoRoot)
-      },
-      { json: options.json }
-    );
-  }
-  return renderOutcome(
-    {
-      type: "error",
-      message: `bootstrap failed: ${result.error ?? "unknown error"}`,
-      data: runData(result, logPath, repoRoot)
-    },
-    {
-      json: options.json,
-      stdout: options.quiet === true || options.json === true ? "" : `${finalLine}
-`
-    }
-  );
-}
-function authFixFor(provider) {
-  switch (provider) {
-    case "claude":
-      return "run: claude auth login --claudeai  (or export ANTHROPIC_API_KEY)";
-    case "codex":
-      return "run: codex login";
-    case "cursor":
-      return "run: cursor-agent login";
-    default:
-      return "run: almanac agents doctor";
-  }
-}
-function runData(result, logPath, repoRoot) {
-  return {
-    transcript: relative(repoRoot, logPath),
-    cost: result.cost,
-    turns: result.turns,
-    sessionId: result.sessionId
-  };
-}
-function formatFinalLine(result, logPath, repoRoot) {
-  const status = result.success ? "done" : "failed";
-  const rel = relative(repoRoot, logPath);
-  const usage = formatRunUsage(result);
-  return `[${status}] ${usage} (transcript: ${rel})`;
-}
-function formatRunUsage(result) {
-  const parts = [];
-  if (result.cost > 0 || result.usage === void 0) {
-    parts.push(`cost: $${result.cost.toFixed(3)}`);
-  }
-  parts.push(`turns: ${result.turns}`);
-  const usage = result.usage;
-  if (usage !== void 0) {
-    const tokenParts = [];
-    if (usage.inputTokens !== void 0) {
-      tokenParts.push(`${usage.inputTokens.toLocaleString("en-US")} in`);
-    }
-    if (usage.outputTokens !== void 0) {
-      tokenParts.push(`${usage.outputTokens.toLocaleString("en-US")} out`);
-    }
-    if (usage.cachedInputTokens !== void 0) {
-      tokenParts.push(
-        `${usage.cachedInputTokens.toLocaleString("en-US")} cached`
-      );
-    }
-    if (usage.reasoningOutputTokens !== void 0) {
-      tokenParts.push(
-        `${usage.reasoningOutputTokens.toLocaleString("en-US")} reasoning`
-      );
-    }
-    if (tokenParts.length > 0) {
-      parts.push(`tokens: ${tokenParts.join(", ")}`);
-    }
-  }
-  return parts.join(", ");
-}
-async function countMarkdownPages(pagesDir) {
-  try {
-    const entries = await readdir(pagesDir, { withFileTypes: true });
-    return entries.filter((e) => e.isFile() && e.name.endsWith(".md")).length;
-  } catch {
-    return 0;
-  }
-}
-function closeStream(stream) {
-  return new Promise((resolve) => {
-    stream.end(() => resolve());
+  return runOperationProcess({
+    repoRoot,
+    spec,
+    background: options.background === true,
+    runId: options.runId,
+    onEvent: options.onEvent,
+    startForeground: options.startForeground,
+    startBackground: options.startBackground
   });
 }
-function formatTimestamp(d) {
-  const pad = (n) => n.toString().padStart(2, "0");
-  const y = d.getFullYear();
-  const mo = pad(d.getMonth() + 1);
-  const da = pad(d.getDate());
-  const h = pad(d.getHours());
-  const mi = pad(d.getMinutes());
-  const s = pad(d.getSeconds());
-  return `${y}${mo}${da}-${h}${mi}${s}`;
-}
-var StreamingFormatter = class {
-  sink;
-  /**
-   * Current agent label. Starts as "bootstrap"; switches when we see an
-   * `Agent` tool-use (slice 5 will exercise this). We still track it here
-   * so the formatter can stay shared between bootstrap and capture.
-   */
-  currentAgent = "bootstrap";
-  constructor(sink) {
-    this.sink = sink;
-  }
-  /**
-   * Swap the top-level agent label. `capture` uses this to relabel from
-   * the default "bootstrap" to "writer" — otherwise the writer's tool-use
-   * output would render as `[bootstrap] …`, which is confusing when you're
-   * reading capture logs.
-   */
-  setAgent(name) {
-    this.currentAgent = name;
-  }
-  handle(msg) {
-    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 (!isRecord(block) || block.type !== "tool_use") continue;
-        if (typeof block.name !== "string") continue;
-        this.handleToolUse(block.name, block.input);
-      }
-      return;
-    }
-    if (msg.type === "item.started" && isRecord(msg.item)) {
-      this.handleCodexItemStarted(msg.item);
-      return;
-    }
-    if (msg.type === "item.completed" && isRecord(msg.item)) {
-      this.handleCodexItemCompleted(msg.item);
-      return;
-    }
-    if (msg.type === "tool_call") {
-      this.handleCursorToolCall(msg);
-      return;
-    }
-  }
-  handleToolUse(name, rawInput) {
-    const input = normalizeToolInput(rawInput);
-    if (name === "Agent") {
-      const sub = typeof input.subagent_type === "string" ? input.subagent_type : "subagent";
-      this.currentAgent = sub;
-      this.sink.write(`[${sub}] starting
-`);
-      return;
-    }
-    const summary = formatToolSummary(name, input);
-    this.sink.write(`[${this.currentAgent}] ${summary}
-`);
-  }
-  handleCodexItemStarted(item) {
-    if (item.type !== "command_execution") return;
-    const command = stringField(item, "command") ?? "?";
-    this.sink.write(`[${this.currentAgent}] bash ${truncate(command, 80)}
-`);
-  }
-  handleCodexItemCompleted(item) {
-    if (item.type !== "file_change") return;
-    const changes = Array.isArray(item.changes) ? item.changes : [];
-    for (const change of changes) {
-      if (!isRecord(change)) continue;
-      const rawPath = stringField(change, "path") ?? "?";
-      const kind = stringField(change, "kind") ?? "edit";
-      const verb = kind === "add" ? "writing" : kind === "delete" ? "deleting" : "editing";
-      this.sink.write(
-        `[${this.currentAgent}] ${verb} ${formatCodexPath(rawPath)}
-`
-      );
-    }
-  }
-  handleCursorToolCall(msg) {
-    if (msg.subtype !== "started" || !isRecord(msg.tool_call)) return;
-    const summary = formatCursorToolSummary(msg.tool_call);
-    if (summary === void 0) return;
-    this.sink.write(`[${this.currentAgent}] ${summary}
-`);
-  }
-};
-function normalizeToolInput(raw) {
-  if (typeof raw === "string") {
-    try {
-      const parsed = JSON.parse(raw);
-      if (parsed !== null && typeof parsed === "object") {
-        return parsed;
-      }
-    } catch {
-    }
-    return {};
-  }
-  if (raw !== null && typeof raw === "object") {
-    return raw;
-  }
-  return {};
+async function countWikiPages(repoRoot) {
+  const pagesDir = join6(repoRoot, ".almanac", "pages");
+  if (!existsSync5(pagesDir)) return 0;
+  const entries = await readdir(pagesDir);
+  return entries.filter((entry) => entry.endsWith(".md")).length;
 }
-function formatToolSummary(name, input) {
-  switch (name) {
-    case "Read": {
-      const target = stringField(input, "file_path") ?? "?";
-      return `reading ${target}`;
-    }
-    case "Write": {
-      const target = stringField(input, "file_path") ?? "?";
-      return `writing ${target}`;
-    }
-    case "Edit": {
-      const target = stringField(input, "file_path") ?? "?";
-      return `editing ${target}`;
-    }
-    case "Glob": {
-      const pattern = stringField(input, "pattern") ?? "?";
-      return `glob ${pattern}`;
-    }
-    case "Grep": {
-      const pattern = stringField(input, "pattern") ?? "?";
-      return `grep ${pattern}`;
-    }
-    case "Bash": {
-      const command = stringField(input, "command") ?? "?";
-      return `bash ${truncate(command, 80)}`;
-    }
-    default: {
-      return name;
-    }
-  }
-}
-function formatCursorToolSummary(toolCall) {
-  if (isRecord(toolCall.readToolCall)) {
-    const args = recordField(toolCall.readToolCall, "args");
-    return `reading ${stringField(args, "path") ?? "?"}`;
-  }
-  if (isRecord(toolCall.editToolCall)) {
-    const args = recordField(toolCall.editToolCall, "args");
-    return `editing ${formatCodexPath(stringField(args, "path") ?? "?")}`;
-  }
-  if (isRecord(toolCall.globToolCall)) {
-    const args = recordField(toolCall.globToolCall, "args");
-    return `glob ${stringField(args, "globPattern") ?? "?"}`;
-  }
-  if (isRecord(toolCall.grepToolCall)) {
-    const args = recordField(toolCall.grepToolCall, "args");
-    return `grep ${stringField(args, "pattern") ?? "?"}`;
-  }
-  if (isRecord(toolCall.shellToolCall)) {
-    const args = recordField(toolCall.shellToolCall, "args");
-    const description = stringField(toolCall.shellToolCall, "description");
-    const command = stringField(args, "command") ?? description ?? "?";
-    return `bash ${truncate(command, 80)}`;
-  }
-  return void 0;
-}
-function truncate(value, max) {
-  return value.length > max ? `${value.slice(0, max - 3)}...` : value;
-}
-function formatCodexPath(value) {
-  const marker = "/.almanac/";
-  const idx = value.indexOf(marker);
-  if (idx !== -1) {
-    return `.almanac/${value.slice(idx + marker.length)}`;
-  }
-  return value;
-}
-function stringField(input, key) {
-  const value = input[key];
-  return typeof value === "string" ? value : void 0;
-}
-function recordField(input, key) {
-  const value = input[key];
-  return isRecord(value) ? value : {};
-}
-function isRecord(value) {
-  return value !== null && typeof value === "object";
-}
-
-// src/commands/capture.ts
-import { createHash } from "crypto";
-import {
-  createWriteStream as createWriteStream2,
-  existsSync as existsSync7,
-  statSync
-} from "fs";
-import { mkdir as mkdir4, readFile as readFile7, readdir as readdir3, stat } from "fs/promises";
-import { homedir } from "os";
-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,
+// src/operations/garden.ts
+async function createGardenRunSpec(args) {
+  return createOperationRunSpec({
+    operation: "garden",
+    promptName: "operations/garden",
+    provider: args.provider ?? { id: "claude" },
     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;
-  }
+    context: args.context,
+    targetKind: "wiki",
+    targetPaths: [`${args.repoRoot}/.almanac`]
+  });
 }
-
-// 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) {
+async function runGardenOperation(options) {
   const repoRoot = findNearestAlmanacDir(options.cwd);
   if (repoRoot === null) {
-    return renderOutcome(
-      {
-        type: "needs-action",
-        message: "no .almanac/ found in this directory or any parent.",
-        fix: "run: almanac bootstrap"
-      },
-      { json: options.json }
-    );
+    throw new Error("no .almanac/ found in this directory or any parent");
   }
-  const providerResolution = await resolveAgentSelection({
-    agent: options.agent,
-    model: options.model,
-    cwd: repoRoot
-  });
-  if (!providerResolution.ok) {
-    return renderOutcome(
-      { type: "error", message: providerResolution.error },
-      { json: options.json }
-    );
-  }
-  const { provider, model } = providerResolution;
-  const statusModel = model ?? getProviderDefaultModel(provider) ?? "provider default";
-  try {
-    await (options.assertAgentAuthFn ?? assertAgentAuth)({
-      provider,
-      spawnCli: options.spawnCli
-    });
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    return renderOutcome(
-      {
-        type: "needs-action",
-        message: msg,
-        fix: authFixFor2(provider),
-        data: { provider }
-      },
-      { json: options.json }
-    );
-  }
-  const almanacDir = getRepoAlmanacDir(repoRoot);
-  const pagesDir = join8(almanacDir, "pages");
-  const transcriptResolution = await resolveTranscript({
+  const spec = await createGardenRunSpec({
     repoRoot,
-    explicit: options.transcriptPath,
-    sessionId: options.sessionId,
-    claudeProjectsDir: options.claudeProjectsDir
+    provider: options.provider,
+    context: options.context
   });
-  if (!transcriptResolution.ok) {
-    return renderOutcome(
-      {
-        type: "needs-action",
-        message: transcriptResolution.error,
-        fix: transcriptFix(transcriptResolution.error)
-      },
-      { json: options.json }
-    );
-  }
-  const transcriptPath = transcriptResolution.path;
-  const snapshotBefore = await snapshotPages(pagesDir);
-  const systemPrompt = await loadPrompt("writer");
-  const reviewerPrompt = await loadPrompt("reviewer");
-  const agents = {
-    reviewer: {
-      description: REVIEWER_DESCRIPTION,
-      prompt: reviewerPrompt,
-      tools: REVIEWER_TOOLS
-    }
-  };
-  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 = join8(logsDir, logName);
-  const statePath = captureStatePath(logsDir, logStem);
-  const stateRecord = buildStartedCaptureRecord({
+  return runOperationProcess({
     repoRoot,
-    almanacDir: logsDir,
-    stem: logStem,
-    sessionId: options.sessionId,
-    transcriptPath,
-    model: statusModel,
-    startedAt
-  });
-  await writeCaptureRunRecord(statePath, stateRecord).catch(() => {
-  });
-  const logStream = createWriteStream2(logPath, { flags: "w" });
-  const out = process.stdout;
-  const formatter = new StreamingFormatter({
-    write: (line) => {
-      if (options.quiet !== true && options.json !== true) out.write(line);
-    }
+    spec,
+    background: options.background !== false,
+    runId: options.runId,
+    onEvent: options.onEvent,
+    startForeground: options.startForeground,
+    startBackground: options.startBackground
   });
-  formatter.setAgent("writer");
-  const onMessage = (msg) => {
-    try {
-      logStream.write(`${JSON.stringify(msg)}
-`);
-    } catch {
-    }
-    formatter.handle(msg);
-  };
-  const userPrompt = `Capture this coding session.
-Transcript: ${transcriptPath}.
-Working directory: ${repoRoot}.`;
-  const runner = options.runAgent ?? runAgent;
-  let result;
-  try {
-    result = await runner({
-      systemPrompt,
-      prompt: userPrompt,
-      allowedTools: WRITER_TOOLS,
-      agents,
-      cwd: repoRoot,
-      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.
-      maxTurns: 150,
-      onMessage
-    });
-  } finally {
-    await closeStream2(logStream);
-  }
-  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 renderOutcome(
-      {
-        type: "error",
-        message: `capture failed: ${result.error ?? "unknown error"}
-(transcript: ${relative3(repoRoot, logPath)})`,
-        data: captureOutcomeData(result, delta, logPath, repoRoot)
-      },
-      {
-        json: options.json,
-        stdout: ""
-      }
-    );
-  }
-  await writeCaptureRunRecord(
-    statePath,
-    finishCaptureRecord({
-      record: stateRecord,
-      status: "done",
-      finishedAt,
-      summary: captureSummary
-    })
-  ).catch(() => {
-  });
-  const summary = formatSummary2(result, delta, logPath, repoRoot);
-  return renderOutcome(
-    {
-      type: isNoopDelta(delta) ? "noop" : "success",
-      message: summary,
-      data: captureOutcomeData(result, delta, logPath, repoRoot)
-    },
-    { json: options.json }
-  );
-}
-function transcriptFix(error) {
-  if (error.includes("transcript not found")) {
-    return "pass a valid <transcript-path>";
-  }
-  return "pass --session <id> or <transcript-path>";
-}
-function authFixFor2(provider) {
-  switch (provider) {
-    case "claude":
-      return "run: claude auth login --claudeai  (or export ANTHROPIC_API_KEY)";
-    case "codex":
-      return "run: codex login";
-    case "cursor":
-      return "run: cursor-agent login";
-    default:
-      return "run: almanac agents doctor";
-  }
-}
-function captureOutcomeData(result, delta, logPath, repoRoot) {
-  return {
-    transcript: relative3(repoRoot, logPath),
-    updated: delta.updated,
-    created: delta.created,
-    archived: delta.archived,
-    cost: result.cost,
-    turns: result.turns,
-    sessionId: result.sessionId
-  };
 }
-function isNoopDelta(delta) {
-  return delta.created === 0 && delta.updated === 0 && delta.archived === 0;
-}
-async function resolveTranscript(args) {
-  if (args.explicit !== void 0 && args.explicit.length > 0) {
-    if (!existsSync7(args.explicit)) {
+
+// src/commands/session-transcripts.ts
+import { existsSync as existsSync6 } from "fs";
+import { readFile as readFile7, readdir as readdir2, stat } from "fs/promises";
+import { homedir } from "os";
+import { basename as basename3, join as join7, resolve } from "path";
+async function resolveCaptureTranscripts(options) {
+  const explicit = options.files ?? [];
+  if (explicit.length > 0) {
+    const paths = explicit.map((path2) => resolve(options.cwd, path2));
+    const missing = paths.find((path2) => !existsSync6(path2));
+    if (missing !== void 0) {
       return {
         ok: false,
-        error: `transcript not found: ${args.explicit}`
+        error: `transcript not found: ${missing}`,
+        fix: "pass an existing transcript file"
       };
     }
-    return { ok: true, path: args.explicit };
+    return { ok: true, paths, app: "file" };
+  }
+  const app = options.app ?? "claude";
+  if (options.allApps === true) {
+    return {
+      ok: false,
+      error: "capture --all-apps discovery is not implemented yet",
+      fix: "run capture per app, pass transcript files explicitly, or use almanac ingest <file-or-folder>"
+    };
+  }
+  if (app !== "claude") {
+    return {
+      ok: false,
+      error: `capture discovery for ${app} sessions is not implemented yet`,
+      fix: "pass one or more transcript files, or use almanac ingest <file-or-folder>"
+    };
   }
-  const projectsDir = args.claudeProjectsDir ?? join8(homedir(), ".claude", "projects");
-  if (!existsSync7(projectsDir)) {
+  const projectsDir = options.claudeProjectsDir ?? join7(homedir(), ".claude", "projects");
+  if (!existsSync6(projectsDir)) {
     return {
       ok: false,
-      error: `could not auto-resolve transcript; ${projectsDir} does not exist. Pass --session <id> or <transcript-path>.`
+      error: `could not auto-resolve Claude transcript; ${projectsDir} does not exist`,
+      fix: "pass --session <id> with a Claude transcript available, or pass a transcript file"
     };
   }
-  const allTranscripts = await collectTranscripts(projectsDir);
-  if (args.sessionId !== void 0 && args.sessionId.length > 0) {
-    const expected = `${args.sessionId}.jsonl`;
-    const match = allTranscripts.find((t) => basename3(t.path) === expected);
+  const transcripts = await collectTranscripts(projectsDir);
+  if (options.session !== void 0 && options.session.length > 0) {
+    if (hasBulkScope(options)) {
+      return {
+        ok: false,
+        error: "capture --session cannot be combined with --since, --limit, --all, or --all-apps",
+        fix: "use --session for one transcript, or remove --session to capture a filtered set"
+      };
+    }
+    const expected = `${options.session}.jsonl`;
+    const match = transcripts.find((entry) => basename3(entry.path) === expected);
     if (match === void 0) {
       return {
         ok: false,
-        error: `no transcript found for session ${args.sessionId} under ${projectsDir}`
+        error: `no Claude transcript found for session ${options.session}`,
+        fix: "pass an existing transcript file"
       };
     }
-    return { ok: true, path: match.path };
+    return { ok: true, paths: [match.path], app: "claude" };
+  }
+  let matches = await filterTranscriptsByCwd(transcripts, options.repoRoot);
+  const cutoff = parseSinceCutoff(options.since, options.now?.() ?? /* @__PURE__ */ new Date());
+  if (!cutoff.ok) return cutoff;
+  const cutoffMtime = cutoff.mtime;
+  if (cutoffMtime !== void 0) {
+    matches = matches.filter((entry) => entry.mtime >= cutoffMtime);
   }
-  const matches = await filterTranscriptsByCwd(allTranscripts, args.repoRoot);
   if (matches.length === 0) {
     return {
       ok: false,
-      error: `could not auto-resolve transcript under ${projectsDir}; no session matches cwd ${args.repoRoot}. Pass --session <id> or <transcript-path>.`
+      error: `could not auto-resolve Claude transcript for cwd ${options.repoRoot}`,
+      fix: "pass --session <id> or a transcript file"
     };
   }
   matches.sort((a, b) => b.mtime - a.mtime);
-  return { ok: true, path: matches[0].path };
+  const limit = normalizeLimit(options.limit);
+  if (!limit.ok) return limit;
+  const count = options.all === true ? limit.value ?? matches.length : limit.value ?? 1;
+  return {
+    ok: true,
+    paths: matches.slice(0, count).map((entry) => entry.path),
+    app: "claude"
+  };
+}
+function hasBulkScope(options) {
+  return options.since !== void 0 || options.limit !== void 0 || options.all === true || options.allApps === true;
+}
+function normalizeLimit(limit) {
+  if (limit === void 0) return { ok: true };
+  if (Number.isInteger(limit) && limit > 0) {
+    return { ok: true, value: limit };
+  }
+  return {
+    ok: false,
+    error: "capture --limit must be a positive integer",
+    fix: "pass --limit 1 or higher"
+  };
+}
+function parseSinceCutoff(since, now) {
+  if (since === void 0 || since.trim().length === 0) return { ok: true };
+  const trimmed = since.trim();
+  const parsedDate = Date.parse(trimmed);
+  if (!Number.isNaN(parsedDate)) return { ok: true, mtime: parsedDate };
+  try {
+    return {
+      ok: true,
+      mtime: now.getTime() - parseDuration(trimmed) * 1e3
+    };
+  } catch {
+    return {
+      ok: false,
+      error: `invalid --since "${since}"`,
+      fix: "pass a date or a duration like 2w, 30d, 12h, or 45m"
+    };
+  }
 }
 async function collectTranscripts(projectsDir) {
   const out = [];
   let topLevel;
   try {
-    topLevel = await readdir3(projectsDir);
+    topLevel = await readdir2(projectsDir);
   } catch {
     return out;
   }
   for (const name of topLevel) {
-    const projectDir = join8(projectsDir, name);
+    const projectDir = join7(projectsDir, name);
     let entries;
     try {
-      entries = await readdir3(projectDir);
+      entries = await readdir2(projectDir);
     } catch {
       continue;
     }
     for (const entry of entries) {
       if (!entry.endsWith(".jsonl")) continue;
-      const full = join8(projectDir, entry);
+      const full = join7(projectDir, entry);
       try {
         const st = await stat(full);
-        if (st.isFile()) {
-          out.push({ path: full, mtime: st.mtimeMs });
-        }
+        if (st.isFile()) out.push({ path: full, mtime: st.mtimeMs });
       } catch {
+        continue;
       }
     }
   }
@@ -3039,17 +2701,17 @@ async function collectTranscripts(projectsDir) {
 }
 async function filterTranscriptsByCwd(transcripts, repoRoot) {
   const dirHash = `-${repoRoot.replace(/^\/+/, "").replace(/\//g, "-")}`;
-  const byDirName = transcripts.filter((t) => {
-    const parent = basename3(join8(t.path, ".."));
+  const byDirName = transcripts.filter((entry) => {
+    const parent = basename3(join7(entry.path, ".."));
     return parent === dirHash || parent.endsWith(dirHash);
   });
   if (byDirName.length > 0) return byDirName;
   const needle = `"cwd":"${repoRoot}"`;
   const hits = [];
-  for (const t of transcripts) {
+  for (const transcript of transcripts) {
     try {
-      const head = await readHead(t.path, 4096);
-      if (head.includes(needle)) hits.push(t);
+      const head = await readHead(transcript.path, 4096);
+      if (head.includes(needle)) hits.push(transcript);
     } catch {
       continue;
     }
@@ -3060,73 +2722,293 @@ async function readHead(path2, bytes) {
   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 (!existsSync7(pagesDir)) return out;
-  let entries;
+
+// src/commands/operations.ts
+async function runInitCommand(options) {
+  const provider = await resolveProviderOrOutcome(options);
+  if ("error" in provider) return provider.error;
+  const background = options.background === true;
+  if (options.json === true && !background) return jsonForegroundError(options.json);
   try {
-    entries = await readdir3(pagesDir);
-  } catch {
-    return out;
+    const result = await runBuildOperation({
+      cwd: options.cwd,
+      provider: provider.value,
+      background,
+      context: initContext(options),
+      force: options.force,
+      onEvent: options.onEvent,
+      startForeground: options.startForeground,
+      startBackground: options.startBackground
+    });
+    return renderOperationResult("init", result, options.json);
+  } catch (err) {
+    return renderOperationError(err, options.json);
   }
-  for (const entry of entries) {
-    if (!entry.endsWith(".md")) continue;
-    const slug = entry.slice(0, -3);
-    const full = join8(pagesDir, entry);
-    try {
-      const st = statSync(full);
-      if (!st.isFile()) continue;
-      const content = await readFile7(full, "utf8");
-      const hash = createHash("sha256").update(content).digest("hex");
-      const fm = parseFrontmatter(content);
-      out.set(slug, {
-        slug,
-        hash,
-        archived: fm.archived_at !== null
-      });
-    } catch {
-      continue;
+}
+async function runCaptureCommand(options) {
+  const provider = await resolveProviderOrOutcome(options);
+  if ("error" in provider) return provider.error;
+  if (options.json === true && options.foreground === true) {
+    return jsonForegroundError(options.json);
+  }
+  try {
+    const repoRoot = await resolveCaptureRepoRoot(options.cwd, options.json);
+    if (typeof repoRoot !== "string") return repoRoot;
+    const resolved = await resolveCaptureTranscripts({
+      repoRoot,
+      cwd: options.cwd,
+      files: options.sessionFiles,
+      app: options.app,
+      session: options.session,
+      since: options.since,
+      limit: options.limit,
+      all: options.all,
+      allApps: options.allApps,
+      claudeProjectsDir: options.claudeProjectsDir
+    });
+    if (!resolved.ok) {
+      return renderOutcome(
+        {
+          type: "needs-action",
+          message: resolved.error,
+          fix: resolved.fix,
+          data: {
+            app: options.app,
+            session: options.session,
+            since: options.since,
+            limit: options.limit,
+            all: options.all,
+            allApps: options.allApps
+          }
+        },
+        { json: options.json }
+      );
     }
+    const paths = resolved.paths;
+    const result = await runAbsorbOperation({
+      cwd: options.cwd,
+      provider: provider.value,
+      background: options.foreground !== true,
+      context: captureContext({ ...options, sessionFiles: paths }),
+      targetKind: "session",
+      targetPaths: paths,
+      onEvent: options.onEvent,
+      startForeground: options.startForeground,
+      startBackground: options.startBackground
+    });
+    return renderOperationResult("capture", result, options.json);
+  } catch (err) {
+    return renderOperationError(err, options.json);
   }
-  return out;
 }
-function diffSnapshots(before, after) {
-  let created = 0;
-  let updated = 0;
-  let archived = 0;
-  for (const [slug, entry] of after) {
-    const prev = before.get(slug);
-    if (prev === void 0) {
-      created += 1;
-      continue;
+async function runIngestCommand(options) {
+  const provider = await resolveProviderOrOutcome(options);
+  if ("error" in provider) return provider.error;
+  if (options.paths.length === 0) {
+    return renderOutcome(
+      { type: "error", message: "ingest requires at least one file or folder" },
+      { json: options.json }
+    );
+  }
+  if (options.json === true && options.foreground === true) {
+    return jsonForegroundError(options.json);
+  }
+  try {
+    const paths = options.paths.map((path2) => resolve2(options.cwd, path2));
+    const result = await runAbsorbOperation({
+      cwd: options.cwd,
+      provider: provider.value,
+      background: options.foreground !== true,
+      context: ingestContext(paths),
+      targetKind: "path",
+      targetPaths: paths,
+      onEvent: options.onEvent,
+      startForeground: options.startForeground,
+      startBackground: options.startBackground
+    });
+    return renderOperationResult("ingest", result, options.json);
+  } catch (err) {
+    return renderOperationError(err, options.json);
+  }
+}
+async function runGardenCommand(options) {
+  const provider = await resolveProviderOrOutcome(options);
+  if ("error" in provider) return provider.error;
+  if (options.json === true && options.foreground === true) {
+    return jsonForegroundError(options.json);
+  }
+  try {
+    const result = await runGardenOperation({
+      cwd: options.cwd,
+      provider: provider.value,
+      background: options.foreground !== true,
+      onEvent: options.onEvent,
+      startForeground: options.startForeground,
+      startBackground: options.startBackground
+    });
+    return renderOperationResult("garden", result, options.json);
+  } catch (err) {
+    return renderOperationError(err, options.json);
+  }
+}
+function parseUsing(value) {
+  if (value === void 0 || value.trim().length === 0) {
+    return { id: "claude" };
+  }
+  const [rawProvider, ...modelParts] = value.split("/");
+  if (!isProviderId(rawProvider)) {
+    throw new Error(
+      `invalid --using "${value}" (expected claude, codex, or cursor)`
+    );
+  }
+  const model = modelParts.join("/");
+  return {
+    id: rawProvider,
+    model: model.length > 0 ? model : void 0
+  };
+}
+async function resolveProviderOrOutcome(options) {
+  try {
+    if (options.using !== void 0) {
+      return { value: parseUsing(options.using) };
     }
-    if (prev.hash !== entry.hash) {
-      if (!prev.archived && entry.archived) {
-        archived += 1;
-      } else {
-        updated += 1;
+    const config = await readConfig({ cwd: options.cwd });
+    const id = config.agent.default;
+    const model = config.agent.models[id] ?? void 0;
+    return { value: { id, model: model ?? void 0 } };
+  } catch (err) {
+    return {
+      error: renderOutcome(
+        { type: "error", message: err instanceof Error ? err.message : String(err) },
+        { json: options.json }
+      )
+    };
+  }
+}
+function isProviderId(value) {
+  return value === "claude" || value === "codex" || value === "cursor";
+}
+function renderOperationResult(operation, result, json) {
+  const record = result.background?.record ?? result.foreground?.record;
+  const status = record?.status;
+  const foregroundResult = result.foreground?.result;
+  if (result.mode === "foreground" && (foregroundResult?.success === false || status === "failed")) {
+    const failure = foregroundResult?.failure ?? record?.failure;
+    return renderOutcome(
+      {
+        type: "error",
+        message: renderOperationFailureMessage({
+          operation,
+          runId: result.runId,
+          error: foregroundResult?.error,
+          failure
+        }),
+        data: {
+          operation,
+          runId: result.runId,
+          mode: result.mode,
+          status,
+          pid: record?.pid,
+          logPath: record?.logPath,
+          error: foregroundResult?.error,
+          failure
+        }
+      },
+      { json }
+    );
+  }
+  return renderOutcome(
+    {
+      type: "success",
+      message: result.mode === "background" ? `${operation} started: ${result.runId}` : `${operation} finished: ${result.runId}`,
+      data: {
+        operation,
+        runId: result.runId,
+        mode: result.mode,
+        status,
+        pid: record?.pid,
+        logPath: record?.logPath
       }
-    }
+    },
+    { json }
+  );
+}
+function renderOperationFailureMessage(args) {
+  const lines = [`${args.operation} failed: ${args.runId}`];
+  if (args.failure !== void 0) {
+    lines.push(`Reason: ${args.failure.message}`);
+    if (args.failure.fix !== void 0) lines.push(`Fix: ${args.failure.fix}`);
+    return lines.join("\n");
   }
-  return { created, updated, archived };
+  if (args.error !== void 0) lines[0] += `: ${args.error}`;
+  return lines.join("\n");
 }
-function formatSummary2(result, delta, logPath, repoRoot) {
-  const rel = relative3(repoRoot, logPath);
-  const usage = formatRunUsage(result);
-  const { created, updated, archived } = delta;
-  if (created === 0 && updated === 0 && archived === 0) {
-    return `[capture] no new knowledge met the notability bar (0 pages written), ${usage} (transcript: ${rel})`;
+function renderOperationError(err, json) {
+  const message = err instanceof Error ? err.message : String(err);
+  if (message.includes("no .almanac/")) {
+    return renderOutcome(
+      {
+        type: "needs-action",
+        message,
+        fix: "run: almanac init"
+      },
+      { json }
+    );
   }
-  return `[done] ${updated} page${updated === 1 ? "" : "s"} updated, ${created} created, ${archived} archived, ${usage} (transcript: ${rel})`;
+  return renderOutcome({ type: "error", message }, { json });
 }
-function formatTimestamp2(d) {
-  const pad = (n) => n.toString().padStart(2, "0");
-  return `${d.getFullYear()}${pad(d.getMonth() + 1)}${pad(d.getDate())}-${pad(d.getHours())}${pad(d.getMinutes())}${pad(d.getSeconds())}`;
+async function resolveCaptureRepoRoot(cwd, json) {
+  const { findNearestAlmanacDir: findNearestAlmanacDir2 } = await import("./paths-O5CZADP2.js");
+  const repoRoot = findNearestAlmanacDir2(cwd);
+  if (repoRoot !== null) return repoRoot;
+  return renderOutcome(
+    {
+      type: "needs-action",
+      message: "no .almanac/ found in this directory or any parent",
+      fix: "run: almanac init"
+    },
+    { json }
+  );
 }
-function closeStream2(stream) {
-  return new Promise((resolve) => {
-    stream.end(() => resolve());
-  });
+function jsonForegroundError(json) {
+  return renderOutcome({
+    type: "error",
+    message: "--json is only supported for background job start responses"
+  }, { json });
+}
+function initContext(options) {
+  return [
+    "Command context:",
+    `- Command: init`,
+    `- Force requested: ${options.force === true ? "yes" : "no"}`,
+    `- Non-interactive confirmation: ${options.yes === true ? "yes" : "no"}`
+  ].join("\n");
+}
+function captureContext(options) {
+  const lines = ["Command context:", "- Command: capture"];
+  if (options.app !== void 0) lines.push(`- App: ${options.app}`);
+  if (options.session !== void 0) lines.push(`- Session id: ${options.session}`);
+  if (options.since !== void 0) lines.push(`- Since: ${options.since}`);
+  if (options.limit !== void 0) lines.push(`- Limit: ${options.limit}`);
+  if (options.all === true) lines.push("- Capture all matching sessions");
+  if (options.allApps === true) lines.push("- Capture all supported apps");
+  const paths = options.sessionFiles ?? [];
+  if (paths.length > 0) {
+    lines.push("- Session/transcript files:");
+    for (const path2 of paths) lines.push(`  - ${path2}`);
+  }
+  if (paths.length === 0 && options.session === void 0) {
+    lines.push("- No explicit session file or session id was provided.");
+  }
+  return lines.join("\n");
+}
+function ingestContext(paths) {
+  return [
+    "Command context:",
+    "- Command: ingest",
+    "- Paths:",
+    ...paths.map((path2) => `  - ${path2}`)
+  ].join("\n");
 }
 
 // src/commands/reindex.ts
@@ -3144,53 +3026,128 @@ async function runReindex(options) {
 
 // src/cli/register-wiki-lifecycle-commands.ts
 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("--agent <agent>", "agent provider: claude, codex, or cursor").option("--model <model>", "override the agent model").option("--force", "overwrite an existing populated wiki (default: refuse)").option("--json", "emit structured CommandOutcome JSON").action(
+  program.command("init").description("initialize and build this repo's CodeAlmanac wiki").option("--using <provider[/model]>", "provider and optional model").option("--background", "start as a background job").option("--json", "emit structured JSON for background job start").option("--force", "allow rebuilding an existing wiki").option("-y, --yes", "confirm non-interactively").action(
     async (opts) => {
-      const result = await runBootstrap({
+      const result = await runInitCommand({
         cwd: process.cwd(),
-        quiet: opts.quiet,
-        agent: opts.agent,
-        model: opts.model,
+        using: opts.using,
+        background: opts.background,
+        json: opts.json,
         force: opts.force,
-        json: opts.json
+        yes: opts.yes,
+        onEvent: opts.background === true ? void 0 : writeForegroundEvent
       });
       emit(result);
     }
   );
-  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").option("--json", "emit structured CommandOutcome JSON").action(
-    async (transcript, opts) => {
+  const capture = program.command("capture [sessionFiles...]").alias("c").description("absorb coding-session knowledge into the wiki").option("--app <app>", "source app: claude, codex, cursor, or generic").option("--session <id>", "target a specific session by ID").option("--since <duration-or-date>", "capture sessions since a time").option("--limit <n>", "maximum sessions to capture", parsePositiveInt).option("--all", "capture all matching sessions").option("--all-apps", "capture from all supported apps").option("--using <provider[/model]>", "provider and optional model").option("--foreground", "run now instead of starting a background job").option("--json", "emit structured JSON for background job start").option("-y, --yes", "confirm non-interactively").action(
+    async (sessionFiles, opts) => {
       await autoRegisterIfNeeded(process.cwd());
-      const result = await runCapture({
+      const result = await runCaptureCommand({
         cwd: process.cwd(),
-        transcriptPath: transcript,
-        sessionId: opts.session,
-        quiet: opts.quiet,
-        agent: opts.agent,
-        model: opts.model,
-        json: opts.json
+        sessionFiles,
+        app: opts.app,
+        session: opts.session,
+        since: opts.since,
+        limit: opts.limit,
+        all: opts.all,
+        allApps: opts.allApps,
+        using: opts.using,
+        foreground: opts.foreground,
+        json: opts.json,
+        yes: opts.yes,
+        onEvent: opts.foreground === true ? writeForegroundEvent : void 0
       });
       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({
+  program.command("ingest <paths...>").description("absorb knowledge from one or more files or folders").option("--using <provider[/model]>", "provider and optional model").option("--foreground", "run now instead of starting a background job").option("--json", "emit structured JSON for background job start").option("-y, --yes", "confirm non-interactively").action(
+    async (paths, opts) => {
+      await autoRegisterIfNeeded(process.cwd());
+      const result = await runIngestCommand({
+        cwd: process.cwd(),
+        paths,
+        using: opts.using,
+        foreground: opts.foreground,
+        json: opts.json,
+        yes: opts.yes,
+        onEvent: opts.foreground === true ? writeForegroundEvent : void 0
+      });
+      emit(result);
+    }
+  );
+  program.command("garden").description("clean up, reconcile, and improve the wiki").option("--using <provider[/model]>", "provider and optional model").option("--foreground", "run now instead of starting a background job").option("--json", "emit structured JSON for background job start").option("-y, --yes", "confirm non-interactively").action(
+    async (opts) => {
+      await autoRegisterIfNeeded(process.cwd());
+      const result = await runGardenCommand({
+        cwd: process.cwd(),
+        using: opts.using,
+        foreground: opts.foreground,
+        json: opts.json,
+        yes: opts.yes,
+        onEvent: opts.foreground === true ? writeForegroundEvent : void 0
+      });
+      emit(result);
+    }
+  );
+  const jobs = program.command("jobs").description("show and manage CodeAlmanac background jobs");
+  jobs.command("list", { isDefault: true }).description("list runs for this wiki").option("--json", "emit structured JSON").action(async (opts) => {
+    const result = await runJobsList({
       cwd: process.cwd(),
       json: opts.json
     });
     emit(result);
   });
-  program.command("ps").description("deprecated alias for capture status").option("--json", "emit structured JSON").action(async (opts) => {
-    await autoRegisterIfNeeded(process.cwd());
-    const result = await runCaptureStatus({
+  jobs.command("show <run-id>").description("show one run record").option("--json", "emit structured JSON").action(async (runId, opts) => {
+    const result = await runJobsShow({
+      cwd: process.cwd(),
+      runId,
+      json: opts.json
+    });
+    emit(result);
+  });
+  jobs.command("logs <run-id>").description("print a run's JSONL event log").option("--json", "emit structured errors as JSON").action(async (runId, opts) => {
+    const result = await runJobsLogs({
+      cwd: process.cwd(),
+      runId,
+      json: opts.json
+    });
+    emit(result);
+  });
+  jobs.command("attach <run-id>").description("stream a run log until the job exits").option("--json", "emit structured errors as JSON").action(async (runId, opts) => {
+    const result = await streamJobsAttach({
+      cwd: process.cwd(),
+      runId,
+      json: opts.json
+    });
+    emit(result);
+  });
+  jobs.command("cancel <run-id>").description("cancel a running or queued job").option("--json", "emit structured JSON").action(async (runId, opts) => {
+    const result = await runJobsCancel({
+      cwd: process.cwd(),
+      runId,
+      json: opts.json
+    });
+    emit(result);
+  });
+  capture.command("status").description("deprecated alias for jobs").option("--json", "emit structured JSON").action(async (opts) => {
+    const result = await runJobsList({
+      cwd: process.cwd(),
+      json: opts.json
+    });
+    emit(withWarning(
+      result,
+      deprecationWarning("almanac capture status", "almanac jobs")
+    ));
+  });
+  program.command("ps").description("deprecated alias for jobs").option("--json", "emit structured JSON").action(async (opts) => {
+    const result = await runJobsList({
       cwd: process.cwd(),
       json: opts.json
     });
     emit(withWarning(
       result,
-      deprecationWarning("almanac ps", "almanac capture status")
+      deprecationWarning("almanac ps", "almanac jobs")
     ));
   });
   const hook = program.command("hook").description("manage the SessionEnd auto-capture hook");
@@ -3218,6 +3175,27 @@ function registerWikiLifecycleCommands(program) {
     if (result.exitCode !== 0) process.exitCode = result.exitCode;
   });
 }
+function writeForegroundEvent(event) {
+  const line = formatForegroundEvent(event);
+  if (line !== null) process.stdout.write(`${line}
+`);
+}
+function formatForegroundEvent(event) {
+  switch (event.type) {
+    case "text":
+      return event.content.trim().length > 0 ? event.content.trim() : null;
+    case "tool_use":
+      return `[tool] ${event.tool}`;
+    case "tool_summary":
+      return `[tool] ${event.summary}`;
+    case "error":
+      return null;
+    case "done":
+      return event.error !== void 0 ? null : "[done]";
+    default:
+      return null;
+  }
+}
 function normalizeHookSource(source) {
   if (source === "claude" || source === "codex" || source === "cursor" || source === "all") {
     return source;
@@ -3235,4 +3213,4 @@ function registerCommands(program) {
 export {
   registerCommands
 };
-//# sourceMappingURL=register-commands-FBJ6XQ3L.js.map
+//# sourceMappingURL=register-commands-LULZUSPO.js.map