@basou/cli 0.29.0 → 0.30.0

package/dist/index.js

@@ -2114,16 +2114,20 @@ function registerHookCommand(program2) {
   ).option(
     "--block",
     "Opt-in enforcement: hold the agent in-turn (decision:block) instead of a non-blocking reminder"
+  ).option(
+    "--require-review",
+    "Opt-in review gate: also remind when a session shipped substantive code (push / PR / merge) without recording a review"
   ).addHelpText("after", HOOK_STOP_HELP).action(async (options) => {
     const minEdits = parseMinEdits(options.minEdits);
     await runHookStop({
       ...minEdits !== void 0 ? { minEdits } : {},
-      ...options.block === true ? { block: true } : {}
+      ...options.block === true ? { block: true } : {},
+      ...options.requireReview === true ? { requireReview: true } : {}
     });
   });
   hook.command("install").description(
-    "Register the Stop hook in ~/.claude/settings.json (reproducible, idempotent). Default is advisory; --block opts into in-turn enforcement."
-  ).option("--block", "Register the blocking (opt-in enforcement) form instead of advisory").option("--min-edits <n>", "Pass a custom file-edit threshold to the registered hook").option("--settings <path>", "Override the settings.json path (intended for tests)").option("--dry-run", "Print what would change without writing").option("-v, --verbose", "Show error causes").action(async (opts) => {
+    "Register the Stop hook in ~/.claude/settings.json (reproducible, idempotent). Default is advisory capture-only; --block opts into in-turn enforcement, --require-review opts into the review gate."
+  ).option("--block", "Register the blocking (opt-in enforcement) form instead of advisory").option("--require-review", "Register with the opt-in review gate enabled").option("--min-edits <n>", "Pass a custom file-edit threshold to the registered hook").option("--settings <path>", "Override the settings.json path (intended for tests)").option("--dry-run", "Print what would change without writing").option("-v, --verbose", "Show error causes").action(async (opts) => {
     await runHookInstall(opts);
   });
   hook.command("uninstall").description(
@@ -2147,6 +2151,12 @@ Substantive = EITHER >= ${DEFAULT_STOP_HOOK_MIN_EDITS} file edits (default) OR a
 answer (an uncaptured conversational decision). Read-only Bash (ls / grep /
 git status) does NOT count.
 
+With --require-review (opt-in, 'basou hook install --require-review') it also
+reminds when the session SHIPPED substantive code (git push / git merge /
+gh pr create|merge) without recording a review ('basou review record'). This
+gate is off by default; when on, its reminder is composed into the same
+envelope as the capture reminder.
+
 By default the reminder is non-blocking: Claude sees it and may act on it or
 stop. With --block (opt-in enforcement, 'basou hook install --block') it instead
 returns decision:block, holding the agent in-turn to act on the reminder; the
@@ -2190,11 +2200,17 @@ async function doRunHookStop(options, ctx) {
     stopHookActive: false,
     ...options.minEdits !== void 0 ? { minEdits: options.minEdits } : {}
   });
-  if (evaluation.kind !== "nudge") return;
-  const payloadJson = options.block === true ? JSON.stringify({ decision: "block", reason: evaluation.additionalContext }) : JSON.stringify({
+  const parts = [];
+  if (evaluation.kind === "nudge") parts.push(evaluation.additionalContext);
+  if (options.requireReview === true && evaluation.review.fires) {
+    parts.push(evaluation.review.additionalContext);
+  }
+  if (parts.length === 0) return;
+  const reason = parts.join("\n\n");
+  const payloadJson = options.block === true ? JSON.stringify({ decision: "block", reason }) : JSON.stringify({
     hookSpecificOutput: {
       hookEventName: "Stop",
-      additionalContext: evaluation.additionalContext
+      additionalContext: reason
     }
   });
   write(`${payloadJson}
@@ -2247,6 +2263,7 @@ function resolveCliEntry() {
 function normalizeInstallOptions(raw) {
   const out = {};
   if (raw.block === true) out.block = true;
+  if (raw.requireReview === true) out.requireReview = true;
   if (raw.settings !== void 0) out.settings = raw.settings;
   if (raw.dryRun === true) out.dryRun = true;
   if (raw.verbose === true) out.verbose = true;
@@ -2306,9 +2323,13 @@ async function doRunHookInstall(options, ctx = {}) {
   const command = buildStopHookCommand({
     cliEntry,
     ...options.block === true ? { block: true } : {},
+    ...options.requireReview === true ? { requireReview: true } : {},
     ...options.minEdits !== void 0 ? { minEdits: options.minEdits } : {}
   });
-  const mode = options.block === true ? "blocking" : "advisory";
+  const mode = describeHookMode({
+    block: options.block === true,
+    review: options.requireReview === true
+  });
   await assertNotSymlink(settingsPath);
   const { raw, parsed } = await readSettings(settingsPath);
   const { settings, action } = upsertStopHook(parsed, command);
@@ -2385,9 +2406,17 @@ async function doRunHookStatus(options) {
     console.log("basou Stop hook: not registered. Run 'basou hook install' to register it.");
     return;
   }
-  const mode = / --block\b/.test(command) ? "blocking (opt-in enforcement)" : "advisory (non-blocking)";
+  const mode = describeHookMode({
+    block: / --block\b/.test(command),
+    review: / --require-review\b/.test(command)
+  });
   console.log(`basou Stop hook: registered, ${mode}.`);
 }
+function describeHookMode(tiers) {
+  const enforcement = tiers.block ? "blocking (opt-in enforcement)" : "advisory (non-blocking)";
+  const gates = tiers.review ? "capture + review" : "capture";
+  return `${enforcement}, ${gates}`;
+}
 
 // src/commands/import.ts
 import { createReadStream } from "fs";
@@ -6220,25 +6249,131 @@ function renderProjectRetrofit(result) {
 
 // src/commands/protocol.ts
 import { readFile as readFile4 } from "fs/promises";
+import { PROTOCOL_END, PROTOCOL_START, parseMarkers as parseMarkers3, readMarkdownFile as readMarkdownFile6 } from "@basou/core";
+
+// src/lib/context-channel.ts
+import { homedir as homedir7 } from "os";
+import { join as join10 } from "path";
 import {
-  PROTOCOL_END,
-  PROTOCOL_START,
+  ORIENTATION_END,
+  ORIENTATION_START,
   parseMarkers as parseMarkers2,
   readMarkdownFile as readMarkdownFile5,
   removeMarkerSection as removeMarkerSection2
 } from "@basou/core";
+var CODEX_TARGET_PATH = join10(homedir7(), ".codex", "AGENTS.md");
+var ORIENTATION_MARKERS = { start: ORIENTATION_START, end: ORIENTATION_END };
+var ORIENTATION_MANAGED_NOTE = "<!-- Managed by basou: 'basou refresh' regenerates everything between the BASOU:ORIENTATION markers with the workspace's current position. This block is transient \u2014 it changes every refresh; do not edit it. -->";
+function buildTargetBody(existing, block, markers) {
+  const wrapped = `${markers.start}
+${block}${markers.end}
+`;
+  if (existing === null || existing === "") return wrapped;
+  const section = parseMarkers2(existing, markers);
+  switch (section.kind) {
+    case "ok":
+      return `${section.before}${markers.start}
+${block}${markers.end}${section.after}`;
+    case "no_markers": {
+      const sep = existing.endsWith("\n\n") ? "" : existing.endsWith("\n") ? "\n" : "\n\n";
+      return `${existing}${sep}${wrapped}`;
+    }
+    default:
+      throw new Error(
+        "The basou-managed markers in the target are malformed (a marker is missing, duplicated, or out of order). Fix or remove them, then retry."
+      );
+  }
+}
+async function backupOnce(target, existing) {
+  if (existing === null) return;
+  const bak = `${target}.basou-bak`;
+  const already = await readMarkdownFile5(bak);
+  if (already !== null) return;
+  await writeFileDurable(bak, existing);
+}
+async function syncMarkerBlock(opts) {
+  const { target, markers, block } = opts;
+  await assertNotSymlink(target);
+  const existing = await readMarkdownFile5(target);
+  const newBody = buildTargetBody(existing, block, markers);
+  if (newBody === existing) return { action: "unchanged" };
+  const hadBlock = existing !== null && parseMarkers2(existing, markers).kind === "ok";
+  const action = hadBlock ? "updated" : "installed";
+  if (opts.dryRun === true) return { action };
+  const recheck = await readMarkdownFile5(target);
+  if (recheck !== existing) {
+    throw new Error(
+      "The target changed during sync; aborting so a concurrent edit is not overwritten. Re-run the command."
+    );
+  }
+  await backupOnce(target, existing);
+  await writeFileDurable(target, newBody);
+  return { action };
+}
+function assertNoMarkerLine(body, markers) {
+  for (const line of body.split(/\r?\n/)) {
+    if (line === markers.start || line === markers.end) {
+      throw new Error(
+        "The content contains a basou marker line, which would corrupt the managed block. Remove that line from the source."
+      );
+    }
+  }
+}
+async function removeMarkerBlock(opts) {
+  const { target, markers, fileLabel } = opts;
+  await assertNotSymlink(target);
+  const existing = await readMarkdownFile5(target);
+  if (existing === null) return { removed: false };
+  const newBody = removeMarkerSection2(existing, fileLabel, markers);
+  if (newBody === existing) return { removed: false };
+  if (opts.dryRun === true) return { removed: true };
+  const recheck = await readMarkdownFile5(target);
+  if (recheck !== existing) {
+    throw new Error(
+      "The target changed during unsync; aborting so a concurrent edit is not overwritten. Re-run the command."
+    );
+  }
+  await backupOnce(target, existing);
+  await writeFileDurable(target, newBody);
+  return { removed: true };
+}
+async function syncOrientationChannel(opts) {
+  assertNoMarkerLine(opts.body, ORIENTATION_MARKERS);
+  const block = `${ORIENTATION_MANAGED_NOTE}
+
+${opts.body.replace(/\s+$/, "")}
+`;
+  return syncMarkerBlock({
+    target: opts.target ?? CODEX_TARGET_PATH,
+    markers: ORIENTATION_MARKERS,
+    block,
+    ...opts.dryRun === true ? { dryRun: true } : {}
+  });
+}
+async function renderOrientationToCodexChannel(opts) {
+  const body = await readMarkdownFile5(opts.orientationPath);
+  if (body === null) return null;
+  const { action } = await syncOrientationChannel({
+    body,
+    ...opts.channelPath !== void 0 ? { target: opts.channelPath } : {}
+  });
+  return {
+    action,
+    line: `codex channel: orientation ${action} in ${opts.channelPath ?? "~/.codex/AGENTS.md"}`
+  };
+}
 
 // src/lib/protocols-config.ts
-import { homedir as homedir7 } from "os";
-import { isAbsolute as isAbsolute4, join as join10, resolve as resolve8 } from "path";
+import { homedir as homedir8 } from "os";
+import { isAbsolute as isAbsolute4, join as join11, resolve as resolve8 } from "path";
 import { readYamlFile as readYamlFile5 } from "@basou/core";
-var DEFAULT_PROTOCOLS_CONFIG_PATH = join10(homedir7(), ".basou", "protocols.yaml");
-var DEFAULT_TARGET_PATH = join10(homedir7(), ".claude", "CLAUDE.md");
+var DEFAULT_PROTOCOLS_CONFIG_PATH = join11(homedir8(), ".basou", "protocols.yaml");
+var DEFAULT_TARGET_PATH = join11(homedir8(), ".claude", "CLAUDE.md");
 var ALLOWED_TOP_KEYS = /* @__PURE__ */ new Set(["version", "protocols"]);
 var ALLOWED_ENTRY_KEYS = /* @__PURE__ */ new Set(["source", "title"]);
 function expandTilde3(p) {
-  if (p === "~") return homedir7();
-  if (p.startsWith("~/")) return join10(homedir7(), p.slice(2));
+  if (p === "~") return homedir8();
+  if (p.startsWith("~/")) return join11(homedir8(), p.slice(2));
   return p;
 }
 function isRecord3(value) {
@@ -6359,13 +6494,7 @@ async function readProtocolSources(entries) {
       }
       throw new Error("Failed to read a protocol source file.", { cause: error });
     }
-    for (const line of content.split(/\r?\n/)) {
-      if (line === PROTOCOL_START || line === PROTOCOL_END) {
-        throw new Error(
-          "A protocol source contains a BASOU:PROTOCOLS marker line, which would corrupt the managed block. Remove that line from the source."
-        );
-      }
-    }
+    assertNoMarkerLine(content, PROTOCOL_MARKERS);
     out.push({ entry, content });
   }
   return out;
@@ -6382,74 +6511,41 @@ ${body}` : body;
 ${sections.join("\n\n")}
 `;
 }
-function buildTargetBody(existing, block) {
-  const wrapped = `${PROTOCOL_START}
-${block}${PROTOCOL_END}
-`;
-  if (existing === null || existing === "") return wrapped;
-  const section = parseMarkers2(existing, PROTOCOL_MARKERS);
-  switch (section.kind) {
-    case "ok":
-      return `${section.before}${PROTOCOL_START}
-${block}${PROTOCOL_END}${section.after}`;
-    case "no_markers": {
-      const sep = existing.endsWith("\n\n") ? "" : existing.endsWith("\n") ? "\n" : "\n\n";
-      return `${existing}${sep}${wrapped}`;
-    }
-    default:
-      throw new Error(
-        "The BASOU:PROTOCOLS markers in the target are malformed (a marker is missing, duplicated, or out of order). Fix or remove them, then retry."
-      );
-  }
-}
-async function backupOnce(target, existing) {
-  if (existing === null) return;
-  const bak = `${target}.basou-bak`;
-  const already = await readMarkdownFile5(bak);
-  if (already !== null) return;
-  await writeFileDurable(bak, existing);
-}
 async function doRunProtocolSync(options) {
   const configPath = options.config ?? DEFAULT_PROTOCOLS_CONFIG_PATH;
   const target = options.target ?? DEFAULT_TARGET_PATH;
   const entries = await loadProtocolsConfig(configPath);
   const sources = await readProtocolSources(entries);
   const block = buildBlock(sources);
-  await assertNotSymlink(target);
-  const existing = await readMarkdownFile5(target);
-  const newBody = buildTargetBody(existing, block);
-  if (newBody === existing) {
+  const result = await syncMarkerBlock({
+    target,
+    markers: PROTOCOL_MARKERS,
+    block,
+    ...options.dryRun === true ? { dryRun: true } : {}
+  });
+  if (result.action === "unchanged") {
     console.log(`The basou:protocols block is already up to date (${entries.length} protocol(s)).`);
     return;
   }
-  const hadBlock = existing !== null && parseMarkers2(existing, PROTOCOL_MARKERS).kind === "ok";
   if (options.dryRun === true) {
     console.log(
-      `[dry-run] Would ${hadBlock ? "update" : "install"} the basou:protocols block (${entries.length} protocol(s)).`
+      `[dry-run] Would ${result.action === "updated" ? "update" : "install"} the basou:protocols block (${entries.length} protocol(s)).`
     );
     for (const { entry } of sources) {
       console.log(`  - ${entry.title ?? entry.source}`);
     }
     return;
   }
-  const recheck = await readMarkdownFile5(target);
-  if (recheck !== existing) {
-    throw new Error(
-      "The target changed during sync; aborting so a concurrent edit is not overwritten. Re-run 'basou protocol sync'."
-    );
-  }
-  await backupOnce(target, existing);
-  await writeFileDurable(target, newBody);
   console.log(
-    `${hadBlock ? "Updated" : "Installed"} the basou:protocols block in the global CLAUDE.md (${entries.length} protocol(s)).`
+    `${result.action === "updated" ? "Updated" : "Installed"} the basou:protocols block in the global CLAUDE.md (${entries.length} protocol(s)).`
   );
 }
 async function doRunProtocolList(options) {
   const configPath = options.config ?? DEFAULT_PROTOCOLS_CONFIG_PATH;
   const target = options.target ?? DEFAULT_TARGET_PATH;
   const entries = await loadProtocolsConfig(configPath);
-  const existing = await readMarkdownFile5(target);
-  const installed = existing !== null && parseMarkers2(existing, PROTOCOL_MARKERS).kind === "ok";
+  const existing = await readMarkdownFile6(target);
+  const installed = existing !== null && parseMarkers3(existing, PROTOCOL_MARKERS).kind === "ok";
   console.log(`Declared protocols (${entries.length}):`);
   for (const entry of entries) {
     console.log(`  - ${entry.title ?? entry.source}`);
@@ -6458,14 +6554,13 @@ async function doRunProtocolList(options) {
 }
 async function doRunProtocolUnsync(options) {
   const target = options.target ?? DEFAULT_TARGET_PATH;
-  await assertNotSymlink(target);
-  const existing = await readMarkdownFile5(target);
-  if (existing === null) {
-    console.log("No target file; nothing to remove.");
-    return;
-  }
-  const newBody = removeMarkerSection2(existing, "CLAUDE.md", PROTOCOL_MARKERS);
-  if (newBody === existing) {
+  const result = await removeMarkerBlock({
+    target,
+    markers: PROTOCOL_MARKERS,
+    fileLabel: "CLAUDE.md",
+    ...options.dryRun === true ? { dryRun: true } : {}
+  });
+  if (!result.removed) {
     console.log("No basou:protocols block found; nothing removed.");
     return;
   }
@@ -6473,14 +6568,6 @@ async function doRunProtocolUnsync(options) {
     console.log("[dry-run] Would remove the basou:protocols block from the global CLAUDE.md.");
     return;
   }
-  const recheck = await readMarkdownFile5(target);
-  if (recheck !== existing) {
-    throw new Error(
-      "The target changed during unsync; aborting so a concurrent edit is not overwritten. Re-run 'basou protocol unsync'."
-    );
-  }
-  await backupOnce(target, existing);
-  await writeFileDurable(target, newBody);
   console.log("Removed the basou:protocols block from the global CLAUDE.md.");
 }
 
@@ -6490,16 +6577,16 @@ import { InvalidArgumentError as InvalidArgumentError3 } from "commander";
 
 // src/commands/refresh-watch.ts
 import { readdir as readdir2, stat as stat5 } from "fs/promises";
-import { homedir as homedir8 } from "os";
-import { join as join11 } from "path";
+import { homedir as homedir9 } from "os";
+import { join as join12 } from "path";
 import { findErrorCode as findErrorCode8 } from "@basou/core";
 var DEFAULT_WATCH_INTERVAL_SEC = 30;
 var MIN_WATCH_INTERVAL_SEC = 5;
 var MAX_WATCH_INTERVAL_SEC = 86400;
 function watchedRoots(ctx) {
   return [
-    ctx.codexSessionsDir ?? join11(homedir8(), ".codex", "sessions"),
-    ctx.claudeProjectsDir ?? join11(homedir8(), ".claude", "projects")
+    ctx.codexSessionsDir ?? join12(homedir9(), ".codex", "sessions"),
+    ctx.claudeProjectsDir ?? join12(homedir9(), ".claude", "projects")
   ];
 }
 async function scanSourceLogs(roots) {
@@ -6513,7 +6600,7 @@ async function scanSourceLogs(roots) {
       throw new Error("Failed to read a source log directory", { cause: error });
     }
     for (const entry of entries) {
-      const full = join11(dir, entry.name);
+      const full = join12(dir, entry.name);
       if (entry.isDirectory()) {
         await walk(full);
       } else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
@@ -6620,19 +6707,19 @@ function parseInterval(value) {
   return seconds;
 }
 function abortableSleep(ms, signal) {
-  return new Promise((resolve12) => {
+  return new Promise((resolve13) => {
     if (signal.aborted) {
-      resolve12();
+      resolve13();
       return;
     }
     let timer;
     const onAbort = () => {
       clearTimeout(timer);
-      resolve12();
+      resolve13();
     };
     timer = setTimeout(() => {
       signal.removeEventListener("abort", onAbort);
-      resolve12();
+      resolve13();
     }, ms);
     signal.addEventListener("abort", onAbort, { once: true });
   });
@@ -6685,7 +6772,7 @@ async function doRunRefreshPortfolio(options, ctx) {
   for (const ws of workspaces) {
     const label = ws.label ?? ws.path;
     try {
-      const result = await computeRefresh(
+      const { result } = await computeRefresh(
         { ...options, portfolio: false },
         { ...ctx, cwd: ws.path }
       );
@@ -6754,7 +6841,7 @@ async function computeRefresh(options, ctx) {
   const paths = basouPaths11(repositoryRoot);
   await assertWorkspaceInitialized8(paths.root);
   const nowIso = (ctx.nowProvider?.() ?? /* @__PURE__ */ new Date()).toISOString();
-  return refreshAll({
+  const result = await refreshAll({
     options: {
       ...options.project !== void 0 && options.project.length > 0 ? { project: options.project } : {},
       ...options.force === true ? { force: true } : {},
@@ -6766,16 +6853,30 @@ async function computeRefresh(options, ctx) {
     paths,
     nowIso
   });
+  return { result, paths };
 }
 async function doRunRefresh(options, ctx) {
-  const result = await computeRefresh(options, ctx);
+  const { result, paths } = await computeRefresh(options, ctx);
+  const channelLine = options.dryRun === true ? null : await syncCodexOrientationChannel(paths, ctx.codexChannelPath);
   if (options.json === true) {
     console.log(JSON.stringify(result));
   } else {
     printRefreshSummary(result);
+    if (channelLine !== null) console.log(channelLine);
   }
   return result;
 }
+async function syncCodexOrientationChannel(paths, channelPath) {
+  try {
+    const rendered = await renderOrientationToCodexChannel({
+      orientationPath: paths.files.orientation,
+      ...channelPath !== void 0 ? { channelPath } : {}
+    });
+    return rendered === null ? null : rendered.line;
+  } catch (error) {
+    return `codex channel skipped: ${error instanceof Error ? error.message : String(error)}`;
+  }
+}
 function describeImport(outcome) {
   if (outcome.status === "skipped") {
     return `${outcome.adapter}: skipped (${outcome.reason})`;
@@ -6908,9 +7009,195 @@ async function assertWorkspaceInitialized9(basouRoot) {
   }
 }
 
-// src/commands/review-gaps.ts
+// src/commands/review.ts
+import { readFile as readFile5 } from "fs/promises";
+import { homedir as homedir10 } from "os";
+import { resolve as resolve10 } from "path";
 import {
+  assertBasouRootSafe as assertBasouRootSafe11,
   basouPaths as basouPaths13,
+  buildReviewRecordedEvent,
+  buildReviewRecordLabel,
+  createAdHocSessionWithEvent as createAdHocSessionWithEvent3,
+  findErrorCode as findErrorCode11,
+  parseReviewRecordInput,
+  readManifest as readManifest7,
+  sanitizePath as sanitizePath2
+} from "@basou/core";
+function registerReviewCommand(program2) {
+  const review = program2.command("review").description("Record reviews that ran (the durable signal a review happened)");
+  review.command("record").description(
+    "Record that a review ran, from a JSON object (stdin or --file). The in-loop agent runs an adversarial / second-opinion review and pipes a description -- reviewer, target, optional verdict/findings/blocked -- and basou writes one review_recorded event deterministically."
+  ).option("--file <path>", "Read the JSON object from a file instead of stdin").option("--dry-run", "Validate and preview the review without writing it").option("--json", "Output the result as JSON").option("-v, --verbose", "Show error causes").addHelpText("after", REVIEW_RECORD_HELP).action(async (options) => {
+    await runReviewRecord(options);
+  });
+}
+var REVIEW_RECORD_HELP = `
+Input format (a single JSON object describing one review):
+  {
+    "reviewer": "codex",
+    "target":   "working-tree",
+    "verdict":  "needs-attention",
+    "findings": [
+      { "title": "Off-by-one in pager", "severity": "medium", "location": "src/page.ts:42", "summary": "..." }
+    ],
+    "blocked": [
+      { "title": "Reviewer wanted to drop the singleton", "reason": "design-reversal", "why": "Settled in decision_X" }
+    ]
+  }
+
+Only "reviewer" and "target" are required; verdict / findings / blocked are
+optional. Record blocked findings (spec-deviation / design-reversal) here so the
+adversarial-review protocol's "always report what you blocked" becomes a durable
+trail artifact -- an explicit empty "blocked": [] is encouraged to record that
+you blocked nothing. The review is written into one ad-hoc session timestamped
+now. Run from a workspace-view directory and it resolves to the planning repo,
+like 'basou decision capture' / 'basou note'.
+
+Example (heredoc on stdin):
+  basou review record <<'JSON'
+  { "reviewer": "codex", "target": "working-tree", "verdict": "pass", "blocked": [] }
+  JSON
+`;
+async function runReviewRecord(options, ctx = {}) {
+  try {
+    await doRunReviewRecord(options, ctx);
+  } catch (error) {
+    renderCliError(error, {
+      verbose: isVerbose(options),
+      classifiers: [failedToFinalizeClassifier]
+    });
+    process.exitCode = 1;
+  }
+}
+async function doRunReviewRecord(options, ctx) {
+  const cwd = ctx.cwd ?? process.cwd();
+  const repositoryRoot = await resolveBasouRootForCommand(cwd, "review record");
+  const paths = basouPaths13(repositoryRoot);
+  await assertWorkspaceInitialized10(paths.root);
+  const raw = await readReviewInput(options, ctx);
+  const review = parseReviewRecordInput(raw);
+  if (options.dryRun === true) {
+    printReviewPreview(options, review);
+    return;
+  }
+  const now = ctx.nowProvider !== void 0 ? ctx.nowProvider() : /* @__PURE__ */ new Date();
+  const occurredAt = now.toISOString();
+  const manifest = await readManifest7(paths);
+  const invocationArgs = options.file !== void 0 ? [
+    "--file",
+    sanitizePath2(resolve10(cwd, options.file), {
+      workingDirectory: repositoryRoot,
+      homedir: homedir10()
+    })
+  ] : [];
+  const adHoc = await createAdHocSessionWithEvent3({
+    paths,
+    manifest,
+    label: buildReviewRecordLabel(review),
+    occurredAt,
+    sessionSource: "human",
+    workingDirectory: repositoryRoot,
+    invocation: { command: "basou review record", args: invocationArgs },
+    targetEventBuilders: [
+      (sessionId, eventId) => buildReviewRecordedEvent({ eventId, sessionId, occurredAt, review })
+    ]
+  });
+  printReviewResult(options, {
+    sessionId: adHoc.sessionId,
+    eventId: adHoc.targetEventIds[0],
+    review
+  });
+}
+async function readReviewInput(options, ctx) {
+  if (options.file !== void 0) {
+    try {
+      return await readFile5(options.file, "utf8");
+    } catch (error) {
+      if (findErrorCode11(error, "ENOENT")) {
+        throw new Error(`Input file not found: ${options.file}`);
+      }
+      throw error;
+    }
+  }
+  if (ctx.readInput !== void 0) {
+    return await ctx.readInput();
+  }
+  if (process.stdin.isTTY === true) {
+    throw new Error(NO_INPUT_HINT2);
+  }
+  return await readStdinToEnd2();
+}
+async function readStdinToEnd2() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(Buffer.from(chunk));
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+var NO_INPUT_HINT2 = "No input: pipe a JSON object describing the review to stdin or pass --file <path>.";
+function reviewToPayload(review) {
+  const payload = {
+    reviewer: review.reviewer,
+    target: review.target
+  };
+  if (review.verdict !== void 0) payload.verdict = review.verdict;
+  if (review.findings !== void 0) payload.findings = review.findings;
+  if (review.blocked !== void 0) payload.blocked = review.blocked;
+  return payload;
+}
+function reviewSummaryLine(review) {
+  const parts = [];
+  if (review.verdict !== void 0) parts.push(`verdict: ${review.verdict}`);
+  if (review.findings !== void 0) {
+    parts.push(`${review.findings.length} finding${review.findings.length === 1 ? "" : "s"}`);
+  }
+  if (review.blocked !== void 0) {
+    parts.push(`${review.blocked.length} blocked`);
+  }
+  return parts.length > 0 ? ` (${parts.join(", ")})` : "";
+}
+function printReviewPreview(options, review) {
+  if (options.json === true) {
+    console.log(JSON.stringify({ dry_run: true, review: reviewToPayload(review) }));
+    return;
+  }
+  console.log(
+    `Would record review by ${review.reviewer} of ${review.target}${reviewSummaryLine(review)} (dry run; nothing written).`
+  );
+}
+function printReviewResult(options, result) {
+  const sid = shortSessionId(result.sessionId);
+  if (options.json === true) {
+    console.log(
+      JSON.stringify({
+        mode: "ad-hoc",
+        session_id: result.sessionId,
+        session_status: "completed",
+        event_id: result.eventId,
+        review: reviewToPayload(result.review)
+      })
+    );
+    return;
+  }
+  console.log(
+    `Recorded review by ${result.review.reviewer} of ${result.review.target}${reviewSummaryLine(result.review)} in ad-hoc session ${sid}.`
+  );
+}
+async function assertWorkspaceInitialized10(basouRoot) {
+  try {
+    await assertBasouRootSafe11(basouRoot);
+  } catch (error) {
+    if (findErrorCode11(error, "ENOENT")) {
+      throw new Error("Workspace not initialized. Run 'basou init' first.");
+    }
+    throw error;
+  }
+}
+
+// src/commands/review-gaps.ts
+import {
+  basouPaths as basouPaths14,
   findReviewGaps
 } from "@basou/core";
 import { InvalidArgumentError as InvalidArgumentError4 } from "commander";
@@ -6951,7 +7238,7 @@ async function runReviewGaps(options, ctx = {}) {
 async function doRunReviewGaps(options, ctx) {
   const cwd = ctx.cwd ?? process.cwd();
   const repositoryRoot = await resolveBasouRootForCommand(cwd, "review-gaps");
-  const paths = basouPaths13(repositoryRoot);
+  const paths = basouPaths14(repositoryRoot);
   const nowIso = (ctx.nowProvider?.() ?? /* @__PURE__ */ new Date()).toISOString();
   const summary = await findReviewGaps({
     paths,
@@ -7034,23 +7321,25 @@ function renderReviewGaps(summary) {
 
 // src/commands/run.ts
 import { mkdir as mkdir2 } from "fs/promises";
-import { homedir as homedir9 } from "os";
-import { join as join12 } from "path";
+import { homedir as homedir11 } from "os";
+import { join as join13 } from "path";
 import {
   acquireLock as acquireLock5,
-  assertBasouRootSafe as assertBasouRootSafe11,
-  basouPaths as basouPaths14,
+  assertBasouRootSafe as assertBasouRootSafe12,
+  basouPaths as basouPaths15,
   ChildProcessRunner as ChildProcessRunner2,
   claudeCodeAdapterMetadata,
+  codexAdapterMetadata,
   appendChainedEvent as coreAppendChainedEvent2,
   finalizeSessionYaml as finalizeSessionYaml2,
   getDiff,
   getSnapshot as getSnapshot2,
   overwriteYamlFile as overwriteYamlFile2,
   prefixedUlid as prefixedUlid4,
-  readManifest as readManifest7,
+  readManifest as readManifest8,
   readYamlFile as readYamlFile6,
   resolveClaudeCodeCommand,
+  resolveCodexCommand,
   resolveRepositoryRoot as resolveRepositoryRoot10,
   SessionSchema as SessionSchema2,
   sanitizeRelatedFiles,
@@ -7058,50 +7347,72 @@ import {
   writeYamlFile as writeYamlFile2
 } from "@basou/core";
 function registerRunCommand(program2, ctx = {}) {
-  const runCommand = program2.command("run").description("Run an AI coding tool through Basou as a tracked session").enablePositionalOptions().option("--no-snapshot", "Skip git_snapshot before/after the session").option("--cwd <path>", "Run from a Basou root other than process.cwd()").option("-v, --verbose", "Show error causes");
-  runCommand.command("claude-code [args...]").description("Run Claude Code CLI as a Basou-tracked session").option("--no-snapshot", "Skip git_snapshot before/after the session").option("--cwd <path>", "Run from a Basou root other than process.cwd()").option("-v, --verbose", "Show error causes").passThroughOptions().action(async (args, options, command) => {
+  const runCommand = addRunOptions(
+    program2.command("run").description("Run an AI coding tool through Basou as a tracked session").enablePositionalOptions()
+  );
+  const dispatch = async (args, options, command, run) => {
     const parentOptions = command.parent?.opts() ?? {};
     const snapshotOn = parentOptions.snapshot !== false && options.snapshot !== false;
-    const merged = {
-      ...parentOptions,
-      ...options,
-      snapshot: snapshotOn
-    };
+    const merged = { ...parentOptions, ...options, snapshot: snapshotOn };
     try {
-      const exitCode = await runClaudeCode(args, merged, ctx);
+      const exitCode = await run(args, merged, ctx);
       process.exit(exitCode);
     } catch (error) {
       renderCliError(error, { verbose: isVerbose(merged) });
       process.exit(1);
     }
+  };
+  addRunOptions(runCommand.command("claude-code [args...]")).description("Run Claude Code CLI as a Basou-tracked session").passThroughOptions().action(
+    (args, options, command) => dispatch(args, options, command, runClaudeCode)
+  );
+  addRunOptions(runCommand.command("codex [args...]")).description("Run the Codex CLI as a Basou-tracked session").passThroughOptions().action(
+    (args, options, command) => dispatch(args, options, command, runCodex)
+  );
+}
+function addRunOptions(command) {
+  return command.option("--no-snapshot", "Skip git_snapshot before/after the session").option("--cwd <path>", "Run from a Basou root other than process.cwd()").option("-v, --verbose", "Show error causes");
+}
+function runClaudeCode(args, options, ctx = {}) {
+  return runTrackedTool(args, options, ctx, {
+    resolveCommand: ctx.resolveCommand ?? resolveClaudeCodeCommand,
+    metadata: claudeCodeAdapterMetadata
+  });
+}
+function runCodex(args, options, ctx = {}) {
+  return runTrackedTool(args, options, ctx, {
+    resolveCommand: ctx.resolveCodexCommand ?? resolveCodexCommand,
+    metadata: codexAdapterMetadata,
+    transformArgs: (a) => ["-c", "shell_environment_policy.inherit=all", ...a],
+    preSpawn: syncCodexOrientationChannelPreSpawn
   });
 }
-async function runClaudeCode(args, options, ctx = {}) {
+async function runTrackedTool(args, options, ctx, adapter) {
   const runner = ctx.runner ?? new ChildProcessRunner2();
   const now = ctx.now ?? (() => /* @__PURE__ */ new Date());
-  const resolveCommand = ctx.resolveCommand ?? resolveClaudeCodeCommand;
   const getDiffFn = ctx.getDiff ?? getDiff;
-  const { command } = await resolveCommand();
+  const { command } = await adapter.resolveCommand();
+  const childArgs = adapter.transformArgs ? adapter.transformArgs(args) : args;
   const cwd = options.cwd ?? process.cwd();
   const repoRoot = await resolveRepositoryRootForRun(cwd);
-  const paths = basouPaths14(repoRoot);
-  await assertBasouRootSafe11(paths.root);
-  const manifest = await readManifest7(paths);
+  const paths = basouPaths15(repoRoot);
+  await assertBasouRootSafe12(paths.root);
+  const manifest = await readManifest8(paths);
   const sessionId = prefixedUlid4("ses");
-  const sessionDir = join12(paths.sessions, sessionId);
+  const sessionDir = join13(paths.sessions, sessionId);
   await mkdir2(sessionDir, { recursive: true });
   const appendEvent = ctx.appendEvent ?? (async (_sessionDir, event) => {
     await coreAppendChainedEvent2(paths, sessionId, event);
   });
   const startedAt = now().toISOString();
-  const sessionYamlPath = join12(sessionDir, "session.yaml");
+  const sessionYamlPath = join13(sessionDir, "session.yaml");
   const session = buildInitialSession2({
     id: sessionId,
     command,
-    args,
+    args: childArgs,
     cwd: repoRoot,
     workspaceId: manifest.workspace.id,
-    startedAt
+    startedAt,
+    source: adapter.metadata
   });
   await writeYamlFile2(sessionYamlPath, session);
   await appendEvent(sessionDir, {
@@ -7110,7 +7421,7 @@ async function runClaudeCode(args, options, ctx = {}) {
     id: prefixedUlid4("evt"),
     session_id: sessionId,
     occurred_at: startedAt,
-    source: claudeCodeAdapterMetadata.kind
+    source: adapter.metadata.kind
   });
   let preSnapshot = null;
   if (options.snapshot !== false) {
@@ -7123,7 +7434,7 @@ async function runClaudeCode(args, options, ctx = {}) {
     id: prefixedUlid4("evt"),
     session_id: sessionId,
     occurred_at: runningAt,
-    source: claudeCodeAdapterMetadata.kind,
+    source: adapter.metadata.kind,
     from: "initialized",
     to: "running"
   });
@@ -7157,10 +7468,14 @@ async function runClaudeCode(args, options, ctx = {}) {
   process.on("SIGTERM", onSigTerm);
   process.on("exit", exitHandler);
   ctx.onExitHookInstalled?.(exitHandler);
+  if (adapter.preSpawn !== void 0) {
+    const line = await adapter.preSpawn(cwd, ctx);
+    if (line !== null) console.log(line);
+  }
   let result;
   try {
     try {
-      result = await runner.run(command, args, {
+      result = await runner.run(command, childArgs, {
         cwd: repoRoot,
         capture: "none",
         signal: controller.signal,
@@ -7171,10 +7486,11 @@ async function runClaudeCode(args, options, ctx = {}) {
     } catch (spawnError) {
       await finalizeSessionAsFailed2(paths, sessionDir, sessionId, appendEvent, {
         command,
-        args,
+        args: childArgs,
         cwd: repoRoot,
         occurredAt: now().toISOString(),
-        signalReceived
+        signalReceived,
+        sourceKind: adapter.metadata.kind
       });
       throw spawnError;
     }
@@ -7193,7 +7509,7 @@ async function runClaudeCode(args, options, ctx = {}) {
     occurred_at: endedAt,
     source: "terminal-recording",
     command,
-    args,
+    args: childArgs,
     cwd: repoRoot,
     exit_code: result.exit_code,
     ...result.signal !== null ? { signal: result.signal } : {},
@@ -7220,7 +7536,7 @@ async function runClaudeCode(args, options, ctx = {}) {
   const rawRelated = computeRelatedFiles(preSnapshot, postSnapshot, diff);
   const relatedFiles = sanitizeRelatedFiles(rawRelated, {
     workingDirectory: repoRoot,
-    homedir: homedir9()
+    homedir: homedir11()
   }).sanitized;
   const finalStatus = decideFinalStatus2(result, signalReceived);
   await appendEvent(sessionDir, {
@@ -7229,7 +7545,7 @@ async function runClaudeCode(args, options, ctx = {}) {
     id: prefixedUlid4("evt"),
     session_id: sessionId,
     occurred_at: endedAt,
-    source: claudeCodeAdapterMetadata.kind,
+    source: adapter.metadata.kind,
     from: "running",
     to: finalStatus
   });
@@ -7239,7 +7555,7 @@ async function runClaudeCode(args, options, ctx = {}) {
     id: prefixedUlid4("evt"),
     session_id: sessionId,
     occurred_at: endedAt,
-    source: claudeCodeAdapterMetadata.kind,
+    source: adapter.metadata.kind,
     ...result.exit_code !== null ? { exit_code: result.exit_code } : {}
   });
   await finalizeSessionYaml2(paths, sessionId, (s) => {
@@ -7361,10 +7677,10 @@ function buildInitialSession2(input) {
       label: `basou run ${cmdline} (${input.startedAt})`,
       task_id: null,
       workspace_id: input.workspaceId,
-      source: { ...claudeCodeAdapterMetadata },
+      source: { ...input.source },
       started_at: input.startedAt,
       status: "initialized",
-      working_directory: sanitizeWorkingDirectory2(input.cwd, { homedir: homedir9() }),
+      working_directory: sanitizeWorkingDirectory2(input.cwd, { homedir: homedir11() }),
       invocation: {
         command: input.command,
         args: [...input.args],
@@ -7404,7 +7720,7 @@ async function finalizeSessionAsFailed2(paths, sessionDir, sessionId, appendEven
     id: prefixedUlid4("evt"),
     session_id: sessionId,
     occurred_at: ctx.occurredAt,
-    source: claudeCodeAdapterMetadata.kind,
+    source: ctx.sourceKind,
     from: "running",
     to: "failed"
   });
@@ -7414,7 +7730,7 @@ async function finalizeSessionAsFailed2(paths, sessionDir, sessionId, appendEven
     id: prefixedUlid4("evt"),
     session_id: sessionId,
     occurred_at: ctx.occurredAt,
-    source: claudeCodeAdapterMetadata.kind
+    source: ctx.sourceKind
   });
   await finalizeSessionYaml2(paths, sessionId, (s) => {
     s.session.status = "failed";
@@ -7434,21 +7750,34 @@ async function resolveRepositoryRootForRun(cwd) {
     throw error;
   }
 }
+async function syncCodexOrientationChannelPreSpawn(cwd, ctx) {
+  try {
+    const root = await resolveBasouRootForCommand(cwd, "run");
+    const paths = basouPaths15(root);
+    const rendered = await renderOrientationToCodexChannel({
+      orientationPath: paths.files.orientation,
+      ...ctx.codexChannelPath !== void 0 ? { channelPath: ctx.codexChannelPath } : {}
+    });
+    return rendered === null ? null : rendered.line;
+  } catch {
+    return null;
+  }
+}
 
 // src/commands/session.ts
-import { readFile as readFile5 } from "fs/promises";
-import { basename as basename6, isAbsolute as isAbsolute6, join as join13, relative as relative3 } from "path";
+import { readFile as readFile6 } from "fs/promises";
+import { basename as basename6, isAbsolute as isAbsolute6, join as join14, relative as relative3 } from "path";
 import {
   acquireLock as acquireLock6,
   appendEventToExistingSession as appendEventToExistingSession3,
-  assertBasouRootSafe as assertBasouRootSafe12,
-  basouPaths as basouPaths15,
+  assertBasouRootSafe as assertBasouRootSafe13,
+  basouPaths as basouPaths16,
   enumerateSessionDirs as enumerateSessionDirs2,
-  findErrorCode as findErrorCode11,
+  findErrorCode as findErrorCode12,
   importSessionFromJson as importSessionFromJson2,
   loadSessionEntries as loadSessionEntries2,
   readAllEvents,
-  readManifest as readManifest8,
+  readManifest as readManifest9,
   readYamlFile as readYamlFile7,
   rechainSessionInPlace,
   resolveSessionId as resolveSessionId3,
@@ -7507,8 +7836,8 @@ async function runSessionList(options, ctx = {}) {
 async function doRunSessionList(options, ctx) {
   const cwd = ctx.cwd ?? process.cwd();
   const repositoryRoot = await resolveRepositoryRootForSession(cwd, "list");
-  const paths = basouPaths15(repositoryRoot);
-  await assertWorkspaceInitialized10(paths.root);
+  const paths = basouPaths16(repositoryRoot);
+  await assertWorkspaceInitialized11(paths.root);
   const now = /* @__PURE__ */ new Date();
   const records = (await loadSessionEntries2(paths, {
     now,
@@ -7559,17 +7888,17 @@ async function runSessionShow(idInput, options, ctx = {}) {
 async function doRunSessionShow(idInput, options, ctx) {
   const cwd = ctx.cwd ?? process.cwd();
   const repositoryRoot = await resolveRepositoryRootForSession(cwd, "show");
-  const paths = basouPaths15(repositoryRoot);
-  await assertWorkspaceInitialized10(paths.root);
+  const paths = basouPaths16(repositoryRoot);
+  await assertWorkspaceInitialized11(paths.root);
   const sessionId = await resolveSessionId3(paths, idInput);
-  const sessionDir = join13(paths.sessions, sessionId);
-  const sessionYamlPath = join13(sessionDir, "session.yaml");
+  const sessionDir = join14(paths.sessions, sessionId);
+  const sessionYamlPath = join14(sessionDir, "session.yaml");
   let session;
   try {
     const raw = await readYamlFile7(sessionYamlPath);
     session = SessionSchema3.parse(raw);
   } catch (error) {
-    if (findErrorCode11(error, "ENOENT")) {
+    if (findErrorCode12(error, "ENOENT")) {
       throw new Error(`Session not found: ${idInput}`);
     }
     throw new Error("Failed to read session", { cause: error });
@@ -7763,6 +8092,11 @@ function eventVariantSummary(ev) {
       return `task ${shortTaskId2(ev.task_id)}: ${ev.title} (archived)`;
     case "note_added":
       return ev.body.length > 80 ? `${ev.body.slice(0, 77)}...` : ev.body;
+    case "review_recorded": {
+      const verdict = ev.verdict !== void 0 ? ` (${ev.verdict})` : "";
+      const blocked = ev.blocked !== void 0 && ev.blocked.length > 0 ? ` ${ev.blocked.length} blocked` : "";
+      return `${ev.reviewer} -> ${ev.target}${verdict}${blocked}`;
+    }
     case "adapter_output":
       return `${ev.stream} "${ev.summary}" raw_ref=${ev.raw_ref}`;
   }
@@ -7810,11 +8144,11 @@ function maxLen2(values, floor) {
 async function resolveRepositoryRootForSession(cwd, subcmd) {
   return resolveBasouRootForCommand(cwd, `session ${subcmd}`);
 }
-async function assertWorkspaceInitialized10(basouRoot) {
+async function assertWorkspaceInitialized11(basouRoot) {
   try {
-    await assertBasouRootSafe12(basouRoot);
+    await assertBasouRootSafe13(basouRoot);
   } catch (error) {
-    if (findErrorCode11(error, "ENOENT")) {
+    if (findErrorCode12(error, "ENOENT")) {
       throw new Error("Workspace not initialized. Run 'basou init' first.");
     }
     throw error;
@@ -7852,9 +8186,9 @@ async function runSessionImport(options, ctx = {}) {
 async function doRunSessionImport(options, ctx) {
   const cwd = ctx.cwd ?? process.cwd();
   const repositoryRoot = await resolveRepositoryRootForSession(cwd, "import");
-  const paths = basouPaths15(repositoryRoot);
-  await assertWorkspaceInitialized10(paths.root);
-  const manifest = await readManifest8(paths);
+  const paths = basouPaths16(repositoryRoot);
+  await assertWorkspaceInitialized11(paths.root);
+  const manifest = await readManifest9(paths);
   const rawBody = await readInputFile(options.from);
   const json = parseJsonStrict(rawBody);
   const parsed = SessionImportPayloadSchema2.safeParse(json);
@@ -7881,12 +8215,12 @@ async function doRunSessionImport(options, ctx) {
 }
 async function readInputFile(path) {
   try {
-    return await readFile5(path, "utf8");
+    return await readFile6(path, "utf8");
   } catch (error) {
-    if (findErrorCode11(error, "ENOENT")) {
+    if (findErrorCode12(error, "ENOENT")) {
       throw new Error("Import source not found", { cause: error });
     }
-    if (findErrorCode11(error, "EISDIR")) {
+    if (findErrorCode12(error, "EISDIR")) {
       throw new Error("Import source is not a file", { cause: error });
     }
     throw new Error("Failed to read import source", { cause: error });
@@ -7966,8 +8300,8 @@ async function doRunSessionNote(sessionIdInput, options, ctx) {
   }
   const cwd = ctx.cwd ?? process.cwd();
   const repositoryRoot = await resolveRepositoryRootForSession(cwd, "note");
-  const paths = basouPaths15(repositoryRoot);
-  await assertWorkspaceInitialized10(paths.root);
+  const paths = basouPaths16(repositoryRoot);
+  await assertWorkspaceInitialized11(paths.root);
   const sessionId = await resolveSessionId3(paths, sessionIdInput);
   const body = hasBody ? options.body : await readNoteFile(options.fromFile);
   if (body.length === 0) {
@@ -7998,12 +8332,12 @@ async function doRunSessionNote(sessionIdInput, options, ctx) {
 }
 async function readNoteFile(path) {
   try {
-    return await readFile5(path, "utf8");
+    return await readFile6(path, "utf8");
   } catch (error) {
-    if (findErrorCode11(error, "ENOENT")) {
+    if (findErrorCode12(error, "ENOENT")) {
       throw new Error("Note source not found", { cause: error });
     }
-    if (findErrorCode11(error, "EISDIR")) {
+    if (findErrorCode12(error, "EISDIR")) {
       throw new Error("Note source is not a file", { cause: error });
     }
     throw new Error("Failed to read note source", { cause: error });
@@ -8048,8 +8382,8 @@ async function doRunSessionRechain(options, ctx) {
   }
   const cwd = ctx.cwd ?? process.cwd();
   const repositoryRoot = await resolveRepositoryRootForSession(cwd, "rechain");
-  const paths = basouPaths15(repositoryRoot);
-  await assertWorkspaceInitialized10(paths.root);
+  const paths = basouPaths16(repositoryRoot);
+  await assertWorkspaceInitialized11(paths.root);
   const sessionIds = options.session !== void 0 ? [await resolveSessionId3(paths, options.session)] : await enumerateSessionDirs2(paths);
   const dryRun = options.dryRun === true;
   const rows = [];
@@ -8102,10 +8436,10 @@ function renderRechainRow(row, dryRun) {
 
 // src/commands/stats.ts
 import {
-  assertBasouRootSafe as assertBasouRootSafe13,
-  basouPaths as basouPaths16,
+  assertBasouRootSafe as assertBasouRootSafe14,
+  basouPaths as basouPaths17,
   computeWorkStats,
-  findErrorCode as findErrorCode12,
+  findErrorCode as findErrorCode13,
   resolveRepositoryRoot as resolveRepositoryRoot11
 } from "@basou/core";
 function registerStatsCommand(program2) {
@@ -8124,8 +8458,8 @@ async function runStats(options, ctx = {}) {
 async function doRunStats(options, ctx) {
   const cwd = ctx.cwd ?? process.cwd();
   const repositoryRoot = await resolveRepositoryRootForStats(cwd);
-  const paths = basouPaths16(repositoryRoot);
-  await assertWorkspaceInitialized11(paths.root);
+  const paths = basouPaths17(repositoryRoot);
+  await assertWorkspaceInitialized12(paths.root);
   const now = ctx.nowProvider?.() ?? /* @__PURE__ */ new Date();
   const result = await computeWorkStats({
     paths,
@@ -8219,11 +8553,11 @@ async function resolveRepositoryRootForStats(cwd) {
     throw error;
   }
 }
-async function assertWorkspaceInitialized11(basouRoot) {
+async function assertWorkspaceInitialized12(basouRoot) {
   try {
-    await assertBasouRootSafe13(basouRoot);
+    await assertBasouRootSafe14(basouRoot);
   } catch (error) {
-    if (findErrorCode12(error, "ENOENT")) {
+    if (findErrorCode13(error, "ENOENT")) {
       throw new Error("Workspace not initialized. Run 'basou init' first.");
     }
     throw error;
@@ -8232,11 +8566,11 @@ async function assertWorkspaceInitialized11(basouRoot) {
 
 // src/commands/status.ts
 import {
-  assertBasouRootSafe as assertBasouRootSafe14,
-  basouPaths as basouPaths17,
+  assertBasouRootSafe as assertBasouRootSafe15,
+  basouPaths as basouPaths18,
   buildStatusSnapshot,
-  findErrorCode as findErrorCode13,
-  readManifest as readManifest9,
+  findErrorCode as findErrorCode14,
+  readManifest as readManifest10,
   resolveRepositoryRoot as resolveRepositoryRoot12,
   writeStatus
 } from "@basou/core";
@@ -8256,20 +8590,20 @@ async function runStatus(options, ctx = {}) {
 async function doRunStatus(options, ctx) {
   const cwd = ctx.cwd ?? process.cwd();
   const repositoryRoot = await resolveRepositoryRootForStatus(cwd);
-  const paths = basouPaths17(repositoryRoot);
+  const paths = basouPaths18(repositoryRoot);
   try {
-    await assertBasouRootSafe14(paths.root);
+    await assertBasouRootSafe15(paths.root);
   } catch (error) {
-    if (findErrorCode13(error, "ENOENT")) {
+    if (findErrorCode14(error, "ENOENT")) {
       throw new Error("Workspace not initialized. Run 'basou init' first.");
     }
     throw error;
   }
   let manifest;
   try {
-    manifest = await readManifest9(paths);
+    manifest = await readManifest10(paths);
   } catch (error) {
-    if (findErrorCode13(error, "ENOENT")) {
+    if (findErrorCode14(error, "ENOENT")) {
       throw new Error("Workspace not initialized. Run 'basou init' first.");
     }
     throw new Error("Failed to read workspace manifest", { cause: error });
@@ -8305,21 +8639,21 @@ async function resolveRepositoryRootForStatus(cwd) {
 }
 
 // src/commands/task.ts
-import { readFile as readFile6 } from "fs/promises";
-import { join as join14 } from "path";
+import { readFile as readFile7 } from "fs/promises";
+import { join as join15 } from "path";
 import {
   archiveTask,
-  assertBasouRootSafe as assertBasouRootSafe15,
-  basouPaths as basouPaths18,
+  assertBasouRootSafe as assertBasouRootSafe16,
+  basouPaths as basouPaths19,
   createTaskWithEvent,
   deleteTask,
   editTask,
   enumerateArchivedTaskIds,
-  findErrorCode as findErrorCode14,
+  findErrorCode as findErrorCode15,
   loadSessionEntries as loadSessionEntries3,
   loadTaskEntries,
   prefixedUlid as prefixedUlid5,
-  readManifest as readManifest10,
+  readManifest as readManifest11,
   readTaskFile,
   readTaskFileWithArchiveFallback,
   reconcileAllTasks,
@@ -8411,8 +8745,8 @@ async function doRunTaskNew(options, ctx) {
   }
   const cwd = ctx.cwd ?? process.cwd();
   const repositoryRoot = await resolveRepositoryRootForTask(cwd, "new");
-  const paths = basouPaths18(repositoryRoot);
-  await assertWorkspaceInitialized12(paths.root);
+  const paths = basouPaths19(repositoryRoot);
+  await assertWorkspaceInitialized13(paths.root);
   const description = options.description !== void 0 ? options.description : options.fromFile !== void 0 ? await readDescriptionFile(options.fromFile) : "";
   const now = ctx.nowProvider !== void 0 ? ctx.nowProvider() : /* @__PURE__ */ new Date();
   const occurredAt = now.toISOString();
@@ -8446,7 +8780,7 @@ async function doRunTaskNew(options, ctx) {
     });
     return;
   }
-  const manifest = await readManifest10(paths);
+  const manifest = await readManifest11(paths);
   const result = await createTaskWithEvent({
     mode: "ad-hoc",
     paths,
@@ -8520,8 +8854,8 @@ async function runTaskList(options, ctx = {}) {
 async function doRunTaskList(options, ctx) {
   const cwd = ctx.cwd ?? process.cwd();
   const repositoryRoot = await resolveRepositoryRootForTask(cwd, "list");
-  const paths = basouPaths18(repositoryRoot);
-  await assertWorkspaceInitialized12(paths.root);
+  const paths = basouPaths19(repositoryRoot);
+  await assertWorkspaceInitialized13(paths.root);
   const entries = await loadTaskEntries(paths, {
     onSkip: (id, reason) => printTaskSkip(id, reason)
   });
@@ -8624,15 +8958,15 @@ async function runTaskShow(idInput, options, ctx = {}) {
 async function doRunTaskShow(idInput, options, ctx) {
   const cwd = ctx.cwd ?? process.cwd();
   const repositoryRoot = await resolveRepositoryRootForTask(cwd, "show");
-  const paths = basouPaths18(repositoryRoot);
-  await assertWorkspaceInitialized12(paths.root);
+  const paths = basouPaths19(repositoryRoot);
+  await assertWorkspaceInitialized13(paths.root);
   const taskId = await resolveTaskId2(paths, idInput, { includeArchived: true });
   const { doc, archived } = await readTaskFileWithArchiveFallback(paths, taskId);
   const sessions = await loadSessionEntries3(paths, { now: /* @__PURE__ */ new Date() });
   const events = [];
   const linkedSessionIds = new Set(doc.task.task.linked_sessions);
   for (const s of sessions) {
-    const sessionDir = join14(paths.sessions, s.sessionId);
+    const sessionDir = join15(paths.sessions, s.sessionId);
     try {
       for await (const ev of replayEvents3(sessionDir, {
         onWarning: (w) => printReplayWarning(w, s.sessionId)
@@ -8768,8 +9102,8 @@ async function doRunTaskStatus(taskIdInput, newStatusInput, options, ctx) {
   const newStatus = parseTaskStatusPositional(newStatusInput);
   const cwd = ctx.cwd ?? process.cwd();
   const repositoryRoot = await resolveRepositoryRootForTask(cwd, "status");
-  const paths = basouPaths18(repositoryRoot);
-  await assertWorkspaceInitialized12(paths.root);
+  const paths = basouPaths19(repositoryRoot);
+  await assertWorkspaceInitialized13(paths.root);
   const taskId = await resolveTaskId2(paths, taskIdInput);
   const now = ctx.nowProvider !== void 0 ? ctx.nowProvider() : /* @__PURE__ */ new Date();
   const occurredAt = now.toISOString();
@@ -8794,7 +9128,7 @@ async function doRunTaskStatus(taskIdInput, newStatusInput, options, ctx) {
     });
     return;
   }
-  const manifest = await readManifest10(paths);
+  const manifest = await readManifest11(paths);
   const result = await updateTaskStatusWithEvent({
     mode: "ad-hoc",
     paths,
@@ -8845,9 +9179,9 @@ async function runTaskReconcile(options, ctx = {}) {
 async function doRunTaskReconcile(options, ctx) {
   const cwd = ctx.cwd ?? process.cwd();
   const repositoryRoot = await resolveRepositoryRootForTask(cwd, "reconcile");
-  const paths = basouPaths18(repositoryRoot);
-  await assertWorkspaceInitialized12(paths.root);
-  const manifest = await readManifest10(paths);
+  const paths = basouPaths19(repositoryRoot);
+  await assertWorkspaceInitialized13(paths.root);
+  const manifest = await readManifest11(paths);
   const nowProvider = ctx.nowProvider ?? (() => /* @__PURE__ */ new Date());
   const write = options.write === true;
   const verbose = isVerbose(options);
@@ -9025,9 +9359,9 @@ async function doRunTaskRefreshLinkage(taskIdInput, options, ctx) {
   }
   const cwd = ctx.cwd ?? process.cwd();
   const repositoryRoot = await resolveRepositoryRootForTask(cwd, "refresh-linkage");
-  const paths = basouPaths18(repositoryRoot);
-  await assertWorkspaceInitialized12(paths.root);
-  const manifest = await readManifest10(paths);
+  const paths = basouPaths19(repositoryRoot);
+  await assertWorkspaceInitialized13(paths.root);
+  const manifest = await readManifest11(paths);
   const taskId = await resolveTaskId2(paths, taskIdInput);
   const nowProvider = ctx.nowProvider ?? (() => /* @__PURE__ */ new Date());
   const write = options.write === true;
@@ -9105,9 +9439,9 @@ async function doRunTaskEdit(taskIdInput, options, ctx) {
   }
   const cwd = ctx.cwd ?? process.cwd();
   const repositoryRoot = await resolveRepositoryRootForTask(cwd, "edit");
-  const paths = basouPaths18(repositoryRoot);
-  await assertWorkspaceInitialized12(paths.root);
-  const manifest = await readManifest10(paths);
+  const paths = basouPaths19(repositoryRoot);
+  await assertWorkspaceInitialized13(paths.root);
+  const manifest = await readManifest11(paths);
   const taskId = await resolveTaskId2(paths, taskIdInput);
   const now = ctx.nowProvider !== void 0 ? ctx.nowProvider() : /* @__PURE__ */ new Date();
   const occurredAt = now.toISOString();
@@ -9161,9 +9495,9 @@ async function doRunTaskDelete(taskIdInput, options, ctx) {
   }
   const cwd = ctx.cwd ?? process.cwd();
   const repositoryRoot = await resolveRepositoryRootForTask(cwd, "delete");
-  const paths = basouPaths18(repositoryRoot);
-  await assertWorkspaceInitialized12(paths.root);
-  const manifest = await readManifest10(paths);
+  const paths = basouPaths19(repositoryRoot);
+  await assertWorkspaceInitialized13(paths.root);
+  const manifest = await readManifest11(paths);
   const taskId = await resolveTaskId2(paths, taskIdInput);
   if (options.yes !== true) {
     await confirmDestructiveAction("delete", taskId);
@@ -9206,9 +9540,9 @@ async function doRunTaskArchive(taskIdInput, options, ctx) {
   }
   const cwd = ctx.cwd ?? process.cwd();
   const repositoryRoot = await resolveRepositoryRootForTask(cwd, "archive");
-  const paths = basouPaths18(repositoryRoot);
-  await assertWorkspaceInitialized12(paths.root);
-  const manifest = await readManifest10(paths);
+  const paths = basouPaths19(repositoryRoot);
+  await assertWorkspaceInitialized13(paths.root);
+  const manifest = await readManifest11(paths);
   const taskId = await resolveTaskId2(paths, taskIdInput);
   if (options.yes !== true) {
     await confirmDestructiveAction("archive", taskId);
@@ -9320,12 +9654,12 @@ function parsePositiveInt2(raw) {
 }
 async function readDescriptionFile(path) {
   try {
-    return await readFile6(path, "utf8");
+    return await readFile7(path, "utf8");
   } catch (error) {
-    if (findErrorCode14(error, "ENOENT")) {
+    if (findErrorCode15(error, "ENOENT")) {
       throw new Error("Description source not found", { cause: error });
     }
-    if (findErrorCode14(error, "EISDIR")) {
+    if (findErrorCode15(error, "EISDIR")) {
       throw new Error("Description source is not a file", { cause: error });
     }
     throw new Error("Failed to read description source", { cause: error });
@@ -9334,11 +9668,11 @@ async function readDescriptionFile(path) {
 async function resolveRepositoryRootForTask(cwd, subcmd) {
   return resolveBasouRootForCommand(cwd, `task ${subcmd}`);
 }
-async function assertWorkspaceInitialized12(basouRoot) {
+async function assertWorkspaceInitialized13(basouRoot) {
   try {
-    await assertBasouRootSafe15(basouRoot);
+    await assertBasouRootSafe16(basouRoot);
   } catch (error) {
-    if (findErrorCode14(error, "ENOENT")) {
+    if (findErrorCode15(error, "ENOENT")) {
       throw new Error("Workspace not initialized. Run 'basou init' first.");
     }
     throw error;
@@ -9426,10 +9760,10 @@ function maxLen3(values, floor) {
 
 // src/commands/verify.ts
 import {
-  assertBasouRootSafe as assertBasouRootSafe16,
-  basouPaths as basouPaths19,
+  assertBasouRootSafe as assertBasouRootSafe17,
+  basouPaths as basouPaths20,
   enumerateSessionDirs as enumerateSessionDirs3,
-  findErrorCode as findErrorCode15,
+  findErrorCode as findErrorCode16,
   resolveRepositoryRoot as resolveRepositoryRoot13,
   resolveSessionId as resolveSessionId5,
   verifyEventsChain
@@ -9453,8 +9787,8 @@ async function doRunVerify(options, ctx) {
   }
   const cwd = ctx.cwd ?? process.cwd();
   const repositoryRoot = await resolveRepositoryRootForVerify(cwd);
-  const paths = basouPaths19(repositoryRoot);
-  await assertWorkspaceInitialized13(paths.root);
+  const paths = basouPaths20(repositoryRoot);
+  await assertWorkspaceInitialized14(paths.root);
   const sessionIds = options.session !== void 0 ? [await resolveSessionId5(paths, options.session)] : await enumerateSessionDirs3(paths);
   const rows = [];
   for (const sessionId of sessionIds) {
@@ -9511,11 +9845,11 @@ async function resolveRepositoryRootForVerify(cwd) {
     throw error;
   }
 }
-async function assertWorkspaceInitialized13(basouRoot) {
+async function assertWorkspaceInitialized14(basouRoot) {
   try {
-    await assertBasouRootSafe16(basouRoot);
+    await assertBasouRootSafe17(basouRoot);
   } catch (error) {
-    if (findErrorCode15(error, "ENOENT")) {
+    if (findErrorCode16(error, "ENOENT")) {
       throw new Error("Workspace not initialized. Run 'basou init' first.");
     }
     throw error;
@@ -9525,12 +9859,12 @@ async function assertWorkspaceInitialized13(basouRoot) {
 // src/commands/view.ts
 import { spawn } from "child_process";
 import { createHash } from "crypto";
-import { basename as basename7, resolve as resolve11 } from "path";
+import { basename as basename7, resolve as resolve12 } from "path";
 import {
-  assertBasouRootSafe as assertBasouRootSafe17,
-  basouPaths as basouPaths20,
-  findErrorCode as findErrorCode17,
-  readManifest as readManifest13,
+  assertBasouRootSafe as assertBasouRootSafe18,
+  basouPaths as basouPaths21,
+  findErrorCode as findErrorCode18,
+  readManifest as readManifest14,
   resolveRepositoryRoot as resolveRepositoryRoot14
 } from "@basou/core";
 import { InvalidArgumentError as InvalidArgumentError7 } from "commander";
@@ -9538,9 +9872,9 @@ import { InvalidArgumentError as InvalidArgumentError7 } from "commander";
 // src/lib/portfolio-safety.ts
 import { execFile } from "child_process";
 import { lstat as lstat2, realpath as realpath2 } from "fs/promises";
-import { isAbsolute as isAbsolute7, join as join15, relative as relative4, resolve as resolve10 } from "path";
+import { isAbsolute as isAbsolute7, join as join16, relative as relative4, resolve as resolve11 } from "path";
 import { promisify } from "util";
-import { readManifest as readManifest11 } from "@basou/core";
+import { readManifest as readManifest12 } from "@basou/core";
 var execFileAsync = promisify(execFile);
 function errorCode(error) {
   return error instanceof Error ? error.code : void 0;
@@ -9549,7 +9883,7 @@ async function canonical(p) {
   try {
     return await realpath2(p);
   } catch {
-    return resolve10(p);
+    return resolve11(p);
   }
 }
 function isInside(child, parent) {
@@ -9562,7 +9896,7 @@ function isBasouPath(p) {
 async function inspectRepo(repoPath) {
   let hasEntry = false;
   try {
-    await lstat2(join15(repoPath, ".basou"));
+    await lstat2(join16(repoPath, ".basou"));
     hasEntry = true;
   } catch (error) {
     if (errorCode(error) !== "ENOENT") {
@@ -9593,7 +9927,7 @@ async function checkPortfolioSafety(workspaces) {
     const wsReal = await canonical(ws.repoRoot);
     let sourceRoots = [];
     try {
-      const manifest = await readManifest11(ws.paths);
+      const manifest = await readManifest12(ws.paths);
       sourceRoots = manifest.import?.source_roots ?? [];
     } catch (error) {
       if (error instanceof Error && error.message === "YAML file not found") {
@@ -9611,7 +9945,7 @@ async function checkPortfolioSafety(workspaces) {
     }
     const monitored = /* @__PURE__ */ new Map();
     for (const root of sourceRoots) {
-      const display = resolve10(ws.repoRoot, root);
+      const display = resolve11(ws.repoRoot, root);
       const real = await canonical(display);
       if (real !== wsReal) monitored.set(real, display);
     }
@@ -9663,18 +9997,18 @@ function formatSafetyReport(result) {
 
 // src/lib/view-server.ts
 import { createServer } from "http";
-import { join as join16 } from "path";
+import { join as join17 } from "path";
 import {
   computeWorkStats as computeWorkStats2,
   enumerateApprovals as enumerateApprovals2,
-  findErrorCode as findErrorCode16,
+  findErrorCode as findErrorCode17,
   isLazyExpired as isLazyExpired2,
   loadApproval as loadApproval2,
   loadSessionEntries as loadSessionEntries4,
   loadTaskEntries as loadTaskEntries2,
   readAllEvents as readAllEvents2,
-  readManifest as readManifest12,
-  readMarkdownFile as readMarkdownFile6,
+  readManifest as readManifest13,
+  readMarkdownFile as readMarkdownFile7,
   readSessionYaml as readSessionYaml3,
   readTaskFile as readTaskFile2,
   renderDecisions as renderDecisions3,
@@ -10324,7 +10658,7 @@ function startViewServer(opts) {
   };
   let boundPort = port;
   const getPort = () => boundPort;
-  return new Promise((resolve12, reject) => {
+  return new Promise((resolve13, reject) => {
     const server = createServer((req, res) => {
       handleRequest(req, res, deps, getPort, runExclusive).catch((error) => {
         sendError(res, error instanceof HttpError ? error.status : 500, pathlessMessage(error));
@@ -10335,7 +10669,7 @@ function startViewServer(opts) {
       const address = server.address();
       boundPort = isAddressInfo(address) ? address.port : port;
       server.off("error", reject);
-      resolve12({
+      resolve13({
         url: `http://${host}:${boundPort}`,
         port: boundPort,
         close: () => closeServer(server)
@@ -10347,8 +10681,8 @@ function isAddressInfo(value) {
   return value !== null && typeof value === "object";
 }
 function closeServer(server) {
-  return new Promise((resolve12) => {
-    server.close(() => resolve12());
+  return new Promise((resolve13) => {
+    server.close(() => resolve13());
     server.closeAllConnections();
   });
 }
@@ -10565,9 +10899,9 @@ async function captureStaleness(ws, nowIso) {
 async function overview(ws, nowProvider) {
   let manifest;
   try {
-    manifest = await readManifest12(ws.paths);
+    manifest = await readManifest13(ws.paths);
   } catch (error) {
-    if (findErrorCode16(error, "ENOENT")) {
+    if (findErrorCode17(error, "ENOENT")) {
       return { initialized: false, repoRoot: ws.repoRoot };
     }
     throw error;
@@ -10622,7 +10956,7 @@ async function sessionDetail(ws, sessionId) {
     throw error;
   }
   try {
-    const events = await readAllEvents2(join16(ws.paths.sessions, sessionId));
+    const events = await readAllEvents2(join17(ws.paths.sessions, sessionId));
     return { session, events };
   } catch {
     return { session, events: [], degraded: true };
@@ -10644,7 +10978,7 @@ async function taskDetail(ws, taskId) {
   }
 }
 async function decisionsView(ws, nowProvider) {
-  const fromDisk = await readMarkdownFile6(ws.paths.files.decisions);
+  const fromDisk = await readMarkdownFile7(ws.paths.files.decisions);
   if (fromDisk !== null) {
     return { body: fromDisk, fromDisk: true };
   }
@@ -10667,7 +11001,7 @@ async function approvalsView(ws, nowProvider) {
   return { pending: await toViews(ids.pending), resolved: await toViews(ids.resolved) };
 }
 async function handoffView(ws, nowProvider) {
-  const fromDisk = await readMarkdownFile6(ws.paths.files.handoff);
+  const fromDisk = await readMarkdownFile7(ws.paths.files.handoff);
   if (fromDisk !== null) {
     return { body: fromDisk, fromDisk: true };
   }
@@ -10836,18 +11170,18 @@ async function doRunView(options, ctx) {
 }
 async function buildSingleDeps(ctx, cwd) {
   const repositoryRoot = await resolveRepositoryRootForView(cwd);
-  const paths = basouPaths20(repositoryRoot);
-  await assertWorkspaceInitialized14(paths.root);
+  const paths = basouPaths21(repositoryRoot);
+  await assertWorkspaceInitialized15(paths.root);
   const entry = await buildWorkspaceEntry(repositoryRoot, ctx);
   return { workspaces: [entry], mode: "single", nowProvider: nowProviderOf(ctx) };
 }
 async function buildPortfolioDeps(workspaceFlags, ctx, cwd) {
-  const specs = workspaceFlags.length > 0 ? workspaceFlags.map((p) => ({ path: resolve11(cwd, p) })) : await loadPortfolioConfig(ctx.portfolioConfigPath);
+  const specs = workspaceFlags.length > 0 ? workspaceFlags.map((p) => ({ path: resolve12(cwd, p) })) : await loadPortfolioConfig(ctx.portfolioConfigPath);
   const entries = [];
   const seenPath = /* @__PURE__ */ new Set();
   const seenKey = /* @__PURE__ */ new Set();
   for (const spec of specs) {
-    const repoRoot = resolve11(spec.path);
+    const repoRoot = resolve12(spec.path);
     if (seenPath.has(repoRoot)) continue;
     seenPath.add(repoRoot);
     const entry = await buildWorkspaceEntry(repoRoot, ctx, spec.label);
@@ -10860,14 +11194,14 @@ async function buildPortfolioDeps(workspaceFlags, ctx, cwd) {
   return { workspaces: entries, mode: "portfolio", nowProvider: nowProviderOf(ctx) };
 }
 async function buildWorkspaceEntry(repoRoot, ctx, labelOverride) {
-  const paths = basouPaths20(repoRoot);
+  const paths = basouPaths21(repoRoot);
   const importCtx = {
     cwd: repoRoot,
     ...ctx.claudeProjectsDir !== void 0 ? { claudeProjectsDir: ctx.claudeProjectsDir } : {},
     ...ctx.codexSessionsDir !== void 0 ? { codexSessionsDir: ctx.codexSessionsDir } : {}
   };
   try {
-    const manifest = await readManifest13(paths);
+    const manifest = await readManifest14(paths);
     return {
       key: manifest.workspace.id,
       label: labelOverride ?? manifest.workspace.name,
@@ -10896,7 +11230,7 @@ async function startListening(port, deps) {
   try {
     return await startViewServer({ port, deps });
   } catch (error) {
-    if (findErrorCode17(error, "EADDRINUSE")) {
+    if (findErrorCode18(error, "EADDRINUSE")) {
       throw new Error(`Port ${port} is already in use. Pass --port <n> to choose another.`, {
         cause: error
       });
@@ -10919,7 +11253,7 @@ function openInBrowser(url, override) {
   }
 }
 function waitForShutdown(signal) {
-  return new Promise((resolve12) => {
+  return new Promise((resolve13) => {
     const cleanup = () => {
       process.off("SIGINT", onSignal);
       process.off("SIGTERM", onSignal);
@@ -10927,18 +11261,18 @@ function waitForShutdown(signal) {
     };
     const onSignal = () => {
       cleanup();
-      resolve12();
+      resolve13();
     };
     const onAbort = () => {
       cleanup();
-      resolve12();
+      resolve13();
     };
     process.on("SIGINT", onSignal);
     process.on("SIGTERM", onSignal);
     if (signal !== void 0) {
       if (signal.aborted) {
         cleanup();
-        resolve12();
+        resolve13();
         return;
       }
       signal.addEventListener("abort", onAbort);
@@ -10957,11 +11291,11 @@ async function resolveRepositoryRootForView(cwd) {
     throw error;
   }
 }
-async function assertWorkspaceInitialized14(basouRoot) {
+async function assertWorkspaceInitialized15(basouRoot) {
   try {
-    await assertBasouRootSafe17(basouRoot);
+    await assertBasouRootSafe18(basouRoot);
   } catch (error) {
-    if (findErrorCode17(error, "ENOENT")) {
+    if (findErrorCode18(error, "ENOENT")) {
       throw new Error("Workspace not initialized. Run 'basou init' first.");
     }
     throw error;
@@ -10993,6 +11327,7 @@ function buildProgram() {
   registerDecisionsCommand(program2);
   registerReportCommand(program2);
   registerOrientCommand(program2);
+  registerReviewCommand(program2);
   registerReviewGapsCommand(program2);
   registerProjectCommand(program2);
   registerProtocolCommand(program2);