npm - @basou/cli - Versions diffs - 0.12.0 → 0.13.0 - Mend

@basou/cli 0.12.0 → 0.13.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (5) hide show

package/dist/program.js CHANGED Viewed

@@ -2008,11 +2008,177 @@ async function resolveRepositoryRootForInit(cwd) {
   }
 }
-// src/commands/orient.ts
+// src/commands/note.ts
 import {
+  acquireLock as acquireLock4,
+  appendEventToExistingSession as appendEventToExistingSession2,
   assertBasouRootSafe as assertBasouRootSafe7,
   basouPaths as basouPaths7,
+  createAdHocSessionWithEvent as createAdHocSessionWithEvent2,
   findErrorCode as findErrorCode6,
+  readManifest as readManifest4,
+  resolveSessionId as resolveSessionId2
+} from "@basou/core";
+import { InvalidArgumentError as InvalidArgumentError2 } from "commander";
+// src/lib/repo-root.ts
+import { resolveBasouRepositoryRoot } from "@basou/core";
+async function resolveBasouRootForCommand(cwd, commandName) {
+  try {
+    return await resolveBasouRepositoryRoot(cwd, {
+      onRedirect: ({ via, root }) => console.error(`Resolved workspace view to ${root} (via ${via}).`)
+    });
+  } catch (error) {
+    if (error instanceof Error && error.message === "Not a git repository") {
+      throw new Error(
+        `Not a git repository. Run 'git init' first, then re-run 'basou ${commandName}'.`,
+        { cause: error }
+      );
+    }
+    throw error;
+  }
+}
+// src/commands/note.ts
+var LABEL_BODY_MAX = 80;
+var LABEL_TRUNCATE_HEAD2 = LABEL_BODY_MAX - 3;
+function registerNoteCommand(program) {
+  program.command("note").description("Record a free-text note (orientation surfaces the latest as the next step)").argument("<body>", "Note text", parseBody).option(
+    "--session <session_id>",
+    "Attach to an existing session; otherwise an ad-hoc session is created"
+  ).option("--json", "Output the result as JSON").option("-v, --verbose", "Show error causes").action(async (body, options) => {
+    await runNote(body, options);
+  });
+}
+async function runNote(body, options, ctx = {}) {
+  try {
+    await doRunNote(body, options, ctx);
+  } catch (error) {
+    renderCliError(error, {
+      verbose: isVerbose(options),
+      classifiers: [failedToFinalizeClassifier]
+    });
+    process.exitCode = 1;
+  }
+}
+async function doRunNote(body, options, ctx) {
+  if (body.trim().length === 0) {
+    throw new Error("Note body must not be empty");
+  }
+  const cwd = ctx.cwd ?? process.cwd();
+  const repositoryRoot = await resolveBasouRootForCommand(cwd, "note");
+  const paths = basouPaths7(repositoryRoot);
+  await assertWorkspaceInitialized6(paths.root);
+  const now = ctx.nowProvider !== void 0 ? ctx.nowProvider() : /* @__PURE__ */ new Date();
+  const occurredAt = now.toISOString();
+  if (options.session !== void 0) {
+    const sessionId = await resolveSessionId2(paths, options.session);
+    const sesId = sessionId;
+    const sessionLock = await acquireLock4(paths, "session", sesId);
+    let result;
+    try {
+      result = await appendEventToExistingSession2({
+        paths,
+        sessionId: sesId,
+        eventBuilder: (eventId) => buildNoteEvent({ eventId, sessionId: sesId, occurredAt, body })
+      });
+    } finally {
+      await sessionLock.release();
+    }
+    printNoteResult(options, {
+      mode: "attached",
+      sessionId,
+      eventId: result.eventId,
+      sessionStatus: result.sessionStatus,
+      body
+    });
+    return;
+  }
+  const manifest = await readManifest4(paths);
+  const adHoc = await createAdHocSessionWithEvent2({
+    paths,
+    manifest,
+    label: buildAdHocLabel2(body),
+    occurredAt,
+    sessionSource: "human",
+    workingDirectory: repositoryRoot,
+    invocation: {
+      command: "basou note",
+      args: [body]
+    },
+    targetEventBuilders: [
+      (sessionId, eventId) => buildNoteEvent({ eventId, sessionId, occurredAt, body })
+    ]
+  });
+  printNoteResult(options, {
+    mode: "ad-hoc",
+    sessionId: adHoc.sessionId,
+    eventId: adHoc.targetEventIds[0],
+    sessionStatus: "completed",
+    body
+  });
+}
+function buildNoteEvent(input) {
+  return {
+    schema_version: "0.1.0",
+    id: input.eventId,
+    session_id: input.sessionId,
+    occurred_at: input.occurredAt,
+    source: "local-cli",
+    type: "note_added",
+    body: input.body,
+    // `basou note` is the resume-hint command; mark it so orientation surfaces
+    // it as the next step and a plain `basou session note` annotation does not.
+    kind: "next_step"
+  };
+}
+function buildAdHocLabel2(body) {
+  const oneLine = body.replace(/\s+/g, " ").trim();
+  const truncated = oneLine.length > LABEL_BODY_MAX ? `${oneLine.slice(0, LABEL_TRUNCATE_HEAD2)}...` : oneLine;
+  return `Ad-hoc note: ${truncated}`;
+}
+function parseBody(raw) {
+  if (raw.trim().length === 0) {
+    throw new InvalidArgumentError2("Note body must not be empty");
+  }
+  return raw;
+}
+function printNoteResult(options, result) {
+  const sid = shortSessionId(result.sessionId);
+  if (options.json === true) {
+    console.log(
+      JSON.stringify({
+        event_id: result.eventId,
+        session_id: result.sessionId,
+        session_status: result.sessionStatus,
+        mode: result.mode,
+        body: result.body
+      })
+    );
+    return;
+  }
+  if (result.mode === "ad-hoc") {
+    console.log(`Recorded note ${result.eventId} in ad-hoc session ${sid}`);
+  } else {
+    console.log(`Recorded note ${result.eventId} in session ${sid} (${result.sessionStatus})`);
+  }
+}
+async function assertWorkspaceInitialized6(basouRoot) {
+  try {
+    await assertBasouRootSafe7(basouRoot);
+  } catch (error) {
+    if (findErrorCode6(error, "ENOENT")) {
+      throw new Error("Workspace not initialized. Run 'basou init' first.");
+    }
+    throw error;
+  }
+}
+// src/commands/orient.ts
+import {
+  assertBasouRootSafe as assertBasouRootSafe8,
+  basouPaths as basouPaths8,
+  findErrorCode as findErrorCode7,
   renderOrientation as renderOrientation2,
   writeMarkdownFile as writeMarkdownFile4
 } from "@basou/core";
@@ -2163,126 +2329,1785 @@ async function refreshAll(args) {
       }
     }
   );
-  return {
-    claudeCode,
-    codex,
-    handoff: { status: "generated", ...handoffCounts },
-    decisions: { status: "generated", ...decisionCounts },
-    orientation: { status: "generated", ...orientationCounts },
-    dryRun
-  };
+  return {
+    claudeCode,
+    codex,
+    handoff: { status: "generated", ...handoffCounts },
+    decisions: { status: "generated", ...decisionCounts },
+    orientation: { status: "generated", ...orientationCounts },
+    dryRun
+  };
+}
+function wouldImport(outcome) {
+  return outcome.status === "ran" ? outcome.importedCount : 0;
+}
+function wouldUpdate(outcome) {
+  return outcome.status === "ran" ? outcome.reimportedCount + outcome.replacedCount : 0;
+}
+function wouldBlock(outcome) {
+  return outcome.status === "ran" ? outcome.skippedUnverifiable : 0;
+}
+async function probeStaleness(args) {
+  try {
+    const dry = await refreshAll({
+      options: { dryRun: true },
+      ctx: args.ctx,
+      paths: args.paths,
+      nowIso: args.nowIso
+    });
+    return {
+      newSessions: wouldImport(dry.claudeCode) + wouldImport(dry.codex),
+      updatedSessions: wouldUpdate(dry.claudeCode) + wouldUpdate(dry.codex),
+      unverifiableSessions: wouldBlock(dry.claudeCode) + wouldBlock(dry.codex)
+    };
+  } catch {
+    return null;
+  }
+}
+// src/commands/orient.ts
+function registerOrientCommand(program) {
+  program.command("orient").description("Show the workspace's current position (also writes .basou/orientation.md)").option("-q, --quiet", "Write the file without printing the body").option("-v, --verbose", "Show error causes").action(async (opts) => {
+    await runOrient(opts);
+  });
+}
+async function runOrient(options, ctx = {}) {
+  try {
+    await doRunOrient(options, ctx);
+  } catch (error) {
+    renderCliError(error, { verbose: isVerbose(options) });
+    process.exitCode = 1;
+  }
+}
+async function doRunOrient(options, ctx) {
+  const cwd = ctx.cwd ?? process.cwd();
+  const repositoryRoot = await resolveBasouRootForCommand(cwd, "orient");
+  const paths = basouPaths8(repositoryRoot);
+  await assertWorkspaceInitialized7(paths.root);
+  const nowIso = (ctx.nowProvider?.() ?? /* @__PURE__ */ new Date()).toISOString();
+  const probeCtx = { cwd: repositoryRoot };
+  if (ctx.claudeProjectsDir !== void 0) probeCtx.claudeProjectsDir = ctx.claudeProjectsDir;
+  if (ctx.codexSessionsDir !== void 0) probeCtx.codexSessionsDir = ctx.codexSessionsDir;
+  const staleness = await probeStaleness({ ctx: probeCtx, paths, nowIso });
+  const result = await renderOrientation2({
+    paths,
+    nowIso,
+    staleness,
+    verbose: options.verbose === true,
+    onWarning: (w, sid) => printReplayWarning(w, sid),
+    onSessionSkip: (sid, reason) => printSessionSkip(sid, reason),
+    onTaskSkip: (taskId, reason) => printTaskSkip(taskId, reason)
+  });
+  await writeMarkdownFile4(paths.files.orientation, `${result.body}
+`);
+  if (options.quiet === true) {
+    console.log(
+      `Generated .basou/orientation.md (sessions: ${result.sessionCount}, in-flight tasks: ${result.inFlightTaskCount}, pending approvals: ${result.pendingApprovalsCount}, suspect: ${result.suspectCount})`
+    );
+  } else {
+    console.log(result.body);
+  }
+}
+async function assertWorkspaceInitialized7(basouRoot) {
+  try {
+    await assertBasouRootSafe8(basouRoot);
+  } catch (error) {
+    if (findErrorCode7(error, "ENOENT")) {
+      throw new Error("Workspace not initialized. Run 'basou init' first.");
+    }
+    throw error;
+  }
+}
+// src/commands/project.ts
+import {
+  existsSync,
+  lstatSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  readlinkSync,
+  realpathSync,
+  statSync,
+  symlinkSync,
+  unlinkSync,
+  writeFileSync
+} from "fs";
+import { basename as basename3, dirname, isAbsolute, join as join4, relative as relative2, resolve as resolve3 } from "path";
+import {
+  basouPaths as basouPaths9,
+  GENERATED_END,
+  GENERATED_START,
+  isGitNotFound,
+  parseMarkers,
+  pathBasename,
+  planArchive,
+  planGitignore,
+  planRename,
+  planRosterAdoption,
+  planWorkspaceView,
+  readManifest as readManifest5,
+  readMarkdownFile as readMarkdownFile4,
+  reconcileSourceRoots,
+  renderWithMarkers as renderWithMarkers4,
+  safeSimpleGit,
+  summarizePresetPlan,
+  summarizeRosterDrift,
+  summarizeSymlinkPlan,
+  summarizeWiring,
+  unknownManifestKeys,
+  writeManifest as writeManifest2,
+  writeMarkdownFile as writeMarkdownFile5
+} from "@basou/core";
+var INSTRUCTION_FILES = ["AGENTS.md", "CLAUDE.md", ".github/copilot-instructions.md"];
+var CANONICAL_FILE = "AGENTS.md";
+function registerProjectCommand(program) {
+  const project = program.command("project").description("Inspect a project's declared repo roster (read-only)");
+  project.command("check").description(
+    "Compare the declared repo roster (manifest `repos`) against the capture config (`source_roots`) and surface drift (read-only, advisory)"
+  ).option("--json", "Output the result as JSON").option("-v, --verbose", "Show error causes").action(async (opts) => {
+    await runProjectCheck(opts);
+  });
+  project.command("sync").description(
+    "Reconcile the capture config (`source_roots`) to cover every declared repo (manifest `repos`). Dry-run by default; pass --apply to write. Additive only \u2014 it never removes an existing source root (e.g. the workspace view)"
+  ).option(
+    "--apply",
+    "Write the reconciled source_roots to the manifest (default: dry-run preview)"
+  ).option("--json", "Output the result as JSON").option("-v, --verbose", "Show error causes").action(async (opts) => {
+    await runProjectSync(opts);
+  });
+  project.command("adopt").description(
+    "Bootstrap a repo roster (manifest `repos`) from the existing capture config (`source_roots`): classify each by realpath + `.git`, keep the git repos, exclude non-repos (the workspace view, /tmp). Dry-run by default; pass --apply to write (refuses if a roster already exists)"
+  ).option("--apply", "Write the bootstrapped roster to the manifest (default: dry-run preview)").option("--json", "Output the result as JSON").option("-v, --verbose", "Show error causes").action(async (opts) => {
+    await runProjectAdopt(opts);
+  });
+  project.command("wiring").description(
+    "Inspect each declared repo's agent instruction-file wiring (AGENTS.md, CLAUDE.md, copilot-instructions.md): present? tracked by git? Surfaces privacy risks (a public repo tracking an instruction file) and gaps (read-only, advisory)"
+  ).option("--json", "Output the result as JSON").option("-v, --verbose", "Show error causes").action(async (opts) => {
+    await runProjectWiring(opts);
+  });
+  project.command("gitignore").description(
+    "Reconcile each public-facing repo's .gitignore to exclude the agent instruction files (so the gitignored symlinks never enter public history). Dry-run by default; pass --apply to write. Additive only \u2014 it never removes a line; private repos and unset-visibility repos are left untouched"
+  ).option(
+    "--apply",
+    "Append the missing patterns to each repo's .gitignore (default: dry-run preview)"
+  ).option("--json", "Output the result as JSON").option("-v, --verbose", "Show error causes").action(async (opts) => {
+    await runProjectGitignore(opts);
+  });
+  project.command("symlinks").description(
+    "Generate each declared repo's agent instruction-file symlinks (AGENTS.md, CLAUDE.md, copilot-instructions.md) pointing at the project anchor's canonical (agents/<repo>/AGENTS.md). Dry-run by default; pass --apply to create. Non-destructive \u2014 it only creates missing links and never overwrites an existing file or repoints a link"
+  ).option("--apply", "Create the missing instruction-file symlinks (default: dry-run preview)").option("--json", "Output the result as JSON").option("-v, --verbose", "Show error causes").action(async (opts) => {
+    await runProjectSymlinks(opts);
+  });
+  project.command("workspace").description(
+    "Generate the project's workspace view: a directory (manifest `workspace.view`) that aggregates every declared repo via a `<repo-basename>` symlink (the anchor included). Dry-run by default; pass --apply to create missing links. Creation is non-destructive \u2014 it never overwrites an existing entry or repoints a link. Stray repo links (a view symlink whose repo is no longer in the roster) are reported always and removed only with --prune; pruning removes ONLY a symlink whose relative target resolves to a git repository (never a real file/dir, the view's own instruction files, a broken link, or a non-repo target), and never the linked repo itself"
+  ).option("--apply", "Create the missing view symlinks (default: dry-run preview)").option(
+    "--prune",
+    "Remove stray repo symlinks (links the roster no longer backs); default: dry-run preview. Independent of --apply"
+  ).option("--json", "Output the result as JSON").option("-v, --verbose", "Show error causes").action(async (opts) => {
+    await runProjectWorkspace(opts);
+  });
+  project.command("preset").description(
+    "Generate the stable-preset block (source visibility, source language, published surfaces) of each declared repo's canonical instruction file (agents/<repo>/AGENTS.md) from the manifest. Dry-run by default; pass --apply to write. Non-destructive \u2014 it only writes the marker-delimited region (creating an absent canonical, updating an out-of-date one) and never touches hand-authored content or a canonical whose markers are missing/malformed"
+  ).option(
+    "--apply",
+    "Write the generated preset block to each canonical (default: dry-run preview)"
+  ).option("--json", "Output the result as JSON").option("-v, --verbose", "Show error causes").action(async (opts) => {
+    await runProjectPreset(opts);
+  });
+  project.command("archive").argument("<repo>", "The roster repo path to archive (as declared, e.g. ../takuhon)").description(
+    "Fold a repo out of the project: remove it from the declared roster (manifest `repos`) and prune its capture entry (`source_roots`). Dry-run by default; pass --apply to write. Manifest-only and reversible (the manifest is git-tracked); it never deletes the repo, its captured history, or its on-disk wiring (view symlink / instruction symlinks / .gitignore / canonical) \u2014 those are reported as a manual teardown checklist. Archiving the anchor (`.`) is refused"
+  ).option(
+    "--apply",
+    "Write the pruned roster / source_roots to the manifest (default: dry-run preview)"
+  ).option("--json", "Output the result as JSON").option("-v, --verbose", "Show error causes").action(async (repo, opts) => {
+    await runProjectArchive(repo, opts);
+  });
+  project.command("rename").argument("<old>", "The current roster repo path (as declared, e.g. ../takuhon)").argument("<new>", "The new roster repo path (e.g. ../takuhon-cli)").description(
+    "Re-path a repo in the project: update its declared roster path (manifest `repos`) and its capture entry (`source_roots`). Dry-run by default; pass --apply to write. Manifest-only and reversible (the manifest is git-tracked); it does not move the repo on disk or rewire it \u2014 when the basename changes, the anchor canonical dir and view symlink that still use the old name are reported as a manual checklist (re-run `basou project symlinks` / `workspace` after). Renaming the anchor (`.`) or onto an existing entry is refused"
+  ).option(
+    "--apply",
+    "Write the re-pathed roster / source_roots to the manifest (default: dry-run preview)"
+  ).option("--json", "Output the result as JSON").option("-v, --verbose", "Show error causes").action(async (oldPath, newPath, opts) => {
+    await runProjectRename(oldPath, newPath, opts);
+  });
+}
+async function runProjectCheck(options, ctx = {}) {
+  try {
+    await doRunProjectCheck(options, ctx);
+  } catch (error) {
+    renderCliError(error, { verbose: isVerbose(options) });
+    process.exitCode = 1;
+  }
+}
+function effectiveSourceRoots(manifest) {
+  return manifest.import?.source_roots ?? ["."];
+}
+function preservedUnknownLines(fields) {
+  if (fields.length === 0) return [];
+  return [
+    `\u2139\uFE0F basou \u304C\u8A8D\u8B58\u3057\u306A\u3044 manifest \u306E\u30C8\u30C3\u30D7\u30EC\u30D9\u30EB\u30D5\u30A3\u30FC\u30EB\u30C9\u3092 ${fields.length} \u4EF6\u4FDD\u6301\u3057\u3066\u3044\u307E\u3059(write \u6642\u3082\u524A\u9664\u3057\u307E\u305B\u3093): ${fields.join(", ")}`,
+    ""
+  ];
+}
+async function doRunProjectCheck(options, ctx) {
+  const cwd = ctx.cwd ?? process.cwd();
+  const repositoryRoot = await resolveBasouRootForCommand(cwd, "project check");
+  const paths = basouPaths9(repositoryRoot);
+  const manifest = await readManifest5(paths);
+  const summary = summarizeRosterDrift({
+    ...manifest.repos !== void 0 ? { repos: manifest.repos } : {},
+    sourceRoots: effectiveSourceRoots(manifest)
+  });
+  if (options.json === true) {
+    console.log(JSON.stringify(summary));
+  } else {
+    console.log(renderProjectCheck(summary));
+  }
+  return summary;
+}
+function renderProjectCheck(summary) {
+  const lines = [];
+  lines.push("# \u30D7\u30ED\u30B8\u30A7\u30AF\u30C8\u69CB\u6210\u30C1\u30A7\u30C3\u30AF(\u5BA3\u8A00 vs \u6355\u6349)");
+  lines.push("");
+  if (summary.declaredCount === 0) {
+    lines.push(
+      "\u2139\uFE0F repo \u30ED\u30FC\u30B9\u30BF\u30FC\u304C\u672A\u5BA3\u8A00\u3067\u3059(manifest \u306E `repos`)\u3002`source_roots` \u306E\u307F\u3067\u904B\u7528\u4E2D\u306E\u305F\u3081\u3001\u5BA3\u8A00\u3068\u306E\u7167\u5408\u306F\u3067\u304D\u307E\u305B\u3093\u3002"
+    );
+    if (summary.extra.length > 0) {
+      lines.push("");
+      lines.push(`\u6355\u6349\u4E2D\u306E source_roots (${summary.extra.length}):`);
+      for (const p of summary.extra) lines.push(`- ${p}`);
+    }
+    return lines.join("\n");
+  }
+  if (summary.gaps.length === 0) {
+    lines.push(
+      `\u2705 \u5BA3\u8A00\u3055\u308C\u305F ${summary.declaredCount} repo \u306F\u3059\u3079\u3066\u6355\u6349\u5BFE\u8C61(source_roots)\u306B\u542B\u307E\u308C\u3066\u3044\u307E\u3059\u3002`
+    );
+  } else {
+    lines.push(`\u26A0\uFE0F \u5BA3\u8A00\u3055\u308C\u3066\u3044\u308B\u306E\u306B\u6355\u6349\u5BFE\u8C61\u306B\u7121\u3044 repo: ${summary.gaps.length}(\u53D6\u308A\u3053\u307C\u3057)`);
+    for (const g of summary.gaps) {
+      lines.push(`- ${g.path}${g.visibility ? ` [${g.visibility}]` : ""} \u2014 source_roots \u306B\u672A\u767B\u9332`);
+    }
+  }
+  lines.push("");
+  if (summary.extra.length > 0) {
+    lines.push(
+      `## \u5BA3\u8A00\u5916\u306E\u6355\u6349\u5BFE\u8C61 (${summary.extra.length}) \u2014 workspace view \u304B\u3001\u5BA3\u8A00\u6F0F\u308C\u306E\u53EF\u80FD\u6027`
+    );
+    for (const p of summary.extra) lines.push(`- ${p}`);
+    lines.push("");
+  }
+  lines.push(
+    "\u6CE8: read-only \u306E advisory \u3067\u3059\u3002\u5BA3\u8A00(repos)\u3068\u6355\u6349\u8A2D\u5B9A(source_roots)\u306E\u5DEE\u5206\u306E\u307F\u3092\u8868\u793A\u3057\u3001enforce \u306F\u3057\u307E\u305B\u3093\u3002"
+  );
+  return lines.join("\n");
+}
+async function runProjectSync(options, ctx = {}) {
+  try {
+    await doRunProjectSync(options, ctx);
+  } catch (error) {
+    renderCliError(error, { verbose: isVerbose(options) });
+    process.exitCode = 1;
+  }
+}
+async function doRunProjectSync(options, ctx) {
+  const cwd = ctx.cwd ?? process.cwd();
+  const repositoryRoot = await resolveBasouRootForCommand(cwd, "project sync");
+  const paths = basouPaths9(repositoryRoot);
+  const manifest = await readManifest5(paths);
+  const hasRoster = manifest.repos !== void 0 && manifest.repos.length > 0;
+  const reconcile = reconcileSourceRoots({
+    ...manifest.repos !== void 0 ? { repos: manifest.repos } : {},
+    ...manifest.import?.source_roots !== void 0 ? { sourceRoots: manifest.import.source_roots } : {}
+  });
+  const applied = options.apply === true && hasRoster && !reconcile.unchanged;
+  if (applied) {
+    const now = ctx.now ?? (() => /* @__PURE__ */ new Date());
+    await writeManifest2(
+      paths,
+      {
+        ...manifest,
+        import: { ...manifest.import, source_roots: reconcile.next },
+        workspace: { ...manifest.workspace, updated_at: now().toISOString() }
+      },
+      { force: true }
+    );
+  }
+  const result = {
+    ...reconcile,
+    hasRoster,
+    applied,
+    preservedUnknownFields: unknownManifestKeys(manifest)
+  };
+  if (options.json === true) {
+    console.log(JSON.stringify(result));
+  } else {
+    console.log(renderProjectSync(result));
+  }
+  return result;
+}
+function renderProjectSync(result) {
+  const lines = [];
+  lines.push("# source_roots \u540C\u671F(\u5BA3\u8A00\u30ED\u30FC\u30B9\u30BF\u30FC \u2192 \u6355\u6349\u8A2D\u5B9A)");
+  lines.push("");
+  lines.push(...preservedUnknownLines(result.preservedUnknownFields));
+  if (!result.hasRoster) {
+    lines.push(
+      "\u2139\uFE0F repo \u30ED\u30FC\u30B9\u30BF\u30FC\u304C\u672A\u5BA3\u8A00\u3067\u3059(manifest \u306E `repos`)\u3002\u540C\u671F\u306E\u5143\u306B\u306A\u308B\u5BA3\u8A00\u304C\u7121\u3044\u305F\u3081\u3001\u5909\u66F4\u306F\u3042\u308A\u307E\u305B\u3093\u3002"
+    );
+    return lines.join("\n");
+  }
+  if (result.unchanged) {
+    lines.push("\u2705 source_roots \u306F\u5BA3\u8A00\u30ED\u30FC\u30B9\u30BF\u30FC\u3092\u3059\u3079\u3066\u8986\u3063\u3066\u3044\u307E\u3059(\u540C\u671F\u4E0D\u8981)\u3002");
+    return lines.join("\n");
+  }
+  if (result.applied) {
+    lines.push(`\u2705 source_roots \u306B ${result.added.length} \u4EF6\u8FFD\u52A0\u3057\u307E\u3057\u305F:`);
+    for (const p of result.added) lines.push(`- ${p}`);
+  } else {
+    lines.push(
+      `${result.added.length} \u4EF6\u306E repo \u304C source_roots \u306B\u672A\u767B\u9332\u3067\u3059\u3002\u8FFD\u52A0\u4E88\u5B9A(dry-run\u3001\u53CD\u6620\u3059\u308B\u306B\u306F --apply):`
+    );
+    for (const p of result.added) lines.push(`- ${p}`);
+    lines.push("");
+    lines.push("\u6CE8: \u65E2\u5B58\u306E source_roots \u306F\u4FDD\u6301\u3057\u3001\u4E0D\u8DB3\u5206\u306E\u8FFD\u8A18\u306E\u307F\u884C\u3044\u307E\u3059(\u524A\u9664\u306F\u3057\u307E\u305B\u3093)\u3002");
+  }
+  return lines.join("\n");
+}
+async function runProjectAdopt(options, ctx = {}) {
+  try {
+    await doRunProjectAdopt(options, ctx);
+  } catch (error) {
+    renderCliError(error, { verbose: isVerbose(options) });
+    process.exitCode = 1;
+  }
+}
+function classifySourceRoot(repositoryRoot, declaredPath) {
+  const absolute = resolve3(repositoryRoot, declaredPath);
+  let real;
+  try {
+    real = realpathSync(absolute);
+  } catch {
+    return { path: declaredPath, kind: "unresolved" };
+  }
+  return { path: declaredPath, kind: existsSync(join4(real, ".git")) ? "repo" : "non-repo" };
+}
+async function doRunProjectAdopt(options, ctx) {
+  const cwd = ctx.cwd ?? process.cwd();
+  const repositoryRoot = await resolveBasouRootForCommand(cwd, "project adopt");
+  const paths = basouPaths9(repositoryRoot);
+  const manifest = await readManifest5(paths);
+  const alreadyDeclared = manifest.repos !== void 0 && manifest.repos.length > 0;
+  const candidates = effectiveSourceRoots(manifest).map(
+    (r) => classifySourceRoot(repositoryRoot, r)
+  );
+  const plan = planRosterAdoption(candidates);
+  const applied = options.apply === true && !alreadyDeclared && plan.repos.length > 0;
+  if (applied) {
+    const now = ctx.now ?? (() => /* @__PURE__ */ new Date());
+    await writeManifest2(
+      paths,
+      {
+        ...manifest,
+        repos: plan.repos,
+        workspace: { ...manifest.workspace, updated_at: now().toISOString() }
+      },
+      { force: true }
+    );
+  }
+  const result = {
+    ...plan,
+    alreadyDeclared,
+    applied,
+    preservedUnknownFields: unknownManifestKeys(manifest)
+  };
+  if (options.json === true) {
+    console.log(JSON.stringify(result));
+  } else {
+    console.log(renderProjectAdopt(result));
+  }
+  return result;
+}
+function renderProjectAdopt(result) {
+  const lines = [];
+  lines.push("# repo \u30ED\u30FC\u30B9\u30BF\u30FC\u306E bootstrap(source_roots \u2192 repos)");
+  lines.push("");
+  lines.push(...preservedUnknownLines(result.preservedUnknownFields));
+  if (result.alreadyDeclared) {
+    lines.push(
+      "\u2139\uFE0F repo \u30ED\u30FC\u30B9\u30BF\u30FC(manifest \u306E `repos`)\u306F\u65E2\u306B\u5BA3\u8A00\u6E08\u307F\u3067\u3059\u3002adopt \u306F\u4E00\u5EA6\u304D\u308A\u306E bootstrap \u306E\u305F\u3081\u4F55\u3082\u66F8\u304D\u8FBC\u307F\u307E\u305B\u3093\u3002\u4EE5\u5F8C\u306E\u4FDD\u5B88\u306F `project check` / `project sync` \u3092\u4F7F\u3063\u3066\u304F\u3060\u3055\u3044\u3002"
+    );
+    return lines.join("\n");
+  }
+  if (result.repos.length === 0) {
+    lines.push("\u2139\uFE0F source_roots \u306B git repo \u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093\u3067\u3057\u305F(bootstrap \u5BFE\u8C61\u306A\u3057)\u3002");
+  } else if (result.applied) {
+    lines.push(`\u2705 ${result.repos.length} repo \u3092 repos \u30ED\u30FC\u30B9\u30BF\u30FC\u306B\u66F8\u304D\u8FBC\u307F\u307E\u3057\u305F:`);
+    for (const r of result.repos) lines.push(`- ${r.path}`);
+    lines.push("");
+    lines.push(
+      "\u6CE8: visibility \u306F\u672A\u8A2D\u5B9A\u3067\u3059\u3002\u5404 repo \u306B public / private / future-public \u3092\u624B\u52D5\u3067\u4ED8\u4E0E\u3057\u3066\u304F\u3060\u3055\u3044\u3002"
+    );
+  } else {
+    lines.push(
+      `${result.repos.length} repo \u3092 repos \u30ED\u30FC\u30B9\u30BF\u30FC\u306B\u5BA3\u8A00\u4E88\u5B9A(dry-run\u3001\u53CD\u6620\u3059\u308B\u306B\u306F --apply):`
+    );
+    for (const r of result.repos) lines.push(`- ${r.path}`);
+    lines.push("");
+    lines.push("\u6CE8: visibility \u306F\u672A\u8A2D\u5B9A\u3067\u63D0\u6848\u3057\u307E\u3059\u3002\u53CD\u6620\u5F8C\u306B\u624B\u52D5\u3067\u4ED8\u4E0E\u3057\u3066\u304F\u3060\u3055\u3044\u3002");
+  }
+  if (result.excluded.length > 0) {
+    lines.push("");
+    lines.push(`## \u9664\u5916 (${result.excluded.length}) \u2014 git repo \u3067\u306F\u306A\u3044\u305F\u3081 repos \u306B\u542B\u3081\u307E\u305B\u3093`);
+    for (const e of result.excluded) {
+      const reason = e.kind === "non-repo" ? "\u975E repo(workspace view / tmp \u7B49)" : "\u89E3\u6C7A\u4E0D\u80FD(\u30D1\u30B9\u304C\u5B58\u5728\u3057\u306A\u3044)";
+      lines.push(`- ${e.path} \u2014 ${reason}`);
+    }
+  }
+  return lines.join("\n");
+}
+async function runProjectWiring(options, ctx = {}) {
+  try {
+    await doRunProjectWiring(options, ctx);
+  } catch (error) {
+    renderCliError(error, { verbose: isVerbose(options) });
+    process.exitCode = 1;
+  }
+}
+async function isTrackedByGit(repoRoot, relPath) {
+  const out = await safeSimpleGit(repoRoot).raw(["ls-files", "--", relPath]);
+  return out.trim().length > 0;
+}
+async function gatherRepoWiring(repositoryRoot, entry) {
+  const base = {
+    path: entry.path,
+    ...entry.visibility !== void 0 ? { visibility: entry.visibility } : {}
+  };
+  let real;
+  try {
+    real = realpathSync(resolve3(repositoryRoot, entry.path));
+  } catch {
+    return { ...base, reachable: false, instructionFiles: [] };
+  }
+  if (!existsSync(join4(real, ".git"))) {
+    return { ...base, reachable: false, instructionFiles: [] };
+  }
+  try {
+    const instructionFiles = [];
+    for (const name of INSTRUCTION_FILES) {
+      let present = true;
+      try {
+        lstatSync(join4(real, name));
+      } catch {
+        present = false;
+      }
+      instructionFiles.push({ name, present, tracked: await isTrackedByGit(real, name) });
+    }
+    return { ...base, reachable: true, instructionFiles };
+  } catch (error) {
+    if (isGitNotFound(error)) throw error;
+    return { ...base, reachable: false, instructionFiles: [] };
+  }
+}
+async function doRunProjectWiring(options, ctx) {
+  const cwd = ctx.cwd ?? process.cwd();
+  const repositoryRoot = await resolveBasouRootForCommand(cwd, "project wiring");
+  const paths = basouPaths9(repositoryRoot);
+  const manifest = await readManifest5(paths);
+  const roster = manifest.repos ?? [];
+  const facts = [];
+  for (const entry of roster) facts.push(await gatherRepoWiring(repositoryRoot, entry));
+  const summary = summarizeWiring(facts);
+  const result = { ...summary, hasRoster: roster.length > 0 };
+  if (options.json === true) {
+    console.log(JSON.stringify(result));
+  } else {
+    console.log(renderProjectWiring(result));
+  }
+  return result;
+}
+function renderProjectWiring(result) {
+  const lines = [];
+  lines.push("# \u6307\u793A\u66F8 wiring \u30C1\u30A7\u30C3\u30AF(\u5BA3\u8A00\u30ED\u30FC\u30B9\u30BF\u30FC \xD7 \u6307\u793A\u66F8\u306E\u5B58\u5728/git \u8FFD\u8DE1)");
+  lines.push("");
+  if (!result.hasRoster) {
+    lines.push(
+      "\u2139\uFE0F repo \u30ED\u30FC\u30B9\u30BF\u30FC\u304C\u672A\u5BA3\u8A00\u3067\u3059(manifest \u306E `repos`)\u3002`basou project adopt` \u3067\u5BA3\u8A00\u3057\u3066\u304B\u3089\u5B9F\u884C\u3057\u3066\u304F\u3060\u3055\u3044\u3002"
+    );
+    return lines.join("\n");
+  }
+  if (result.risks.length > 0) {
+    lines.push(
+      `\u26A0\uFE0F \u516C\u958B\u7CFB repo \u3067\u6307\u793A\u66F8\u304C git \u8FFD\u8DE1\u3055\u308C\u3066\u3044\u307E\u3059: ${result.risks.length}(canonical \u306E\u6F0F\u6D29\u30EA\u30B9\u30AF)`
+    );
+    for (const r of result.risks) {
+      lines.push(
+        `- ${r.repo} [${r.visibility}] \u2014 ${r.file} \u304C tracked(gitignore \u3055\u308C\u305F symlink \u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059)`
+      );
+    }
+  } else if (result.ok) {
+    lines.push("\u2705 \u516C\u958B\u7CFB repo \u3067 git \u8FFD\u8DE1\u3055\u308C\u3066\u3044\u308B\u6307\u793A\u66F8\u306F\u3042\u308A\u307E\u305B\u3093(privacy \u30EA\u30B9\u30AF\u306A\u3057)\u3002");
+  } else {
+    lines.push(
+      "\u2139\uFE0F \u78BA\u5B9A\u3057\u305F privacy \u30EA\u30B9\u30AF\u306F\u3042\u308A\u307E\u305B\u3093\u304C\u3001\u5224\u5B9A\u3067\u304D\u306A\u3044/\u5230\u9054\u3067\u304D\u306A\u3044 repo \u304C\u3042\u308A\u307E\u3059(\u4E0B\u8A18\u53C2\u7167)\u3002"
+    );
+  }
+  lines.push("");
+  if (result.unknown.length > 0) {
+    lines.push(
+      `## visibility \u672A\u8A2D\u5B9A (${result.unknown.length}) \u2014 privacy \u5224\u5B9A\u4E0D\u53EF\u3002manifest \u306E repos \u306B visibility \u3092\u4ED8\u4E0E\u3057\u3066\u304F\u3060\u3055\u3044`
+    );
+    for (const p of result.unknown) lines.push(`- ${p}`);
+    lines.push("");
+  }
+  if (result.incomplete.length > 0) {
+    lines.push(`## \u6307\u793A\u66F8\u306E\u6B20\u843D (${result.incomplete.length}) \u2014 \u5F8C\u7D9A\u306E\u751F\u6210\u30B9\u30E9\u30A4\u30B9\u3067\u88DC\u5B8C\u4E88\u5B9A`);
+    for (const i of result.incomplete) lines.push(`- ${i.repo} \u2014 ${i.missing.join(", ")}`);
+    lines.push("");
+  }
+  if (result.unreachable.length > 0) {
+    lines.push(`## \u5230\u9054\u4E0D\u80FD (${result.unreachable.length}) \u2014 \u30D1\u30B9\u672A\u89E3\u6C7A / git repo \u3067\u306A\u3044`);
+    for (const p of result.unreachable) lines.push(`- ${p}`);
+    lines.push("");
+  }
+  lines.push(
+    "\u6CE8: read-only \u306E advisory \u3067\u3059\u3002\u6307\u793A\u66F8\u306E\u5B58\u5728\u3068 git \u8FFD\u8DE1\u72B6\u6CC1\u306E\u307F\u3092\u8868\u793A\u3057\u3001\u751F\u6210\u30FBenforce \u306F\u3057\u307E\u305B\u3093(.basou \u306E\u30D5\u30C3\u30C8\u30D7\u30EA\u30F3\u30C8\u306F `basou view --check`)\u3002"
+  );
+  return lines.join("\n");
+}
+async function runProjectGitignore(options, ctx = {}) {
+  try {
+    await doRunProjectGitignore(options, ctx);
+  } catch (error) {
+    renderCliError(error, { verbose: isVerbose(options) });
+    process.exitCode = 1;
+  }
+}
+function gatherRepoGitignore(repositoryRoot, entry) {
+  const base = {
+    path: entry.path,
+    ...entry.visibility !== void 0 ? { visibility: entry.visibility } : {}
+  };
+  let real;
+  try {
+    real = realpathSync(resolve3(repositoryRoot, entry.path));
+  } catch {
+    return { ...base, reachable: false, currentLines: [] };
+  }
+  if (!existsSync(join4(real, ".git"))) {
+    return { ...base, reachable: false, currentLines: [] };
+  }
+  return { ...base, reachable: true, currentLines: readGitignoreLines(join4(real, ".gitignore")) };
+}
+function hasErrorCode(error) {
+  return error instanceof Error && typeof error.code === "string";
+}
+function readGitignoreLines(file) {
+  try {
+    return readFileSync(file, "utf8").split(/\r?\n/);
+  } catch (error) {
+    if (hasErrorCode(error) && error.code === "ENOENT") return [];
+    throw new Error("Failed to read .gitignore", { cause: error });
+  }
+}
+function applyGitignorePlan(repositoryRoot, plan) {
+  const file = join4(realpathSync(resolve3(repositoryRoot, plan.path)), ".gitignore");
+  let existing = "";
+  try {
+    existing = readFileSync(file, "utf8");
+  } catch (error) {
+    if (!(hasErrorCode(error) && error.code === "ENOENT")) {
+      throw new Error("Failed to read .gitignore", { cause: error });
+    }
+  }
+  const sep = existing.length > 0 && !existing.endsWith("\n") ? "\n" : "";
+  try {
+    writeFileSync(file, `${existing}${sep}${plan.toAdd.join("\n")}
+`);
+  } catch (error) {
+    throw new Error("Failed to write .gitignore", { cause: error });
+  }
+}
+async function doRunProjectGitignore(options, ctx) {
+  const cwd = ctx.cwd ?? process.cwd();
+  const repositoryRoot = await resolveBasouRootForCommand(cwd, "project gitignore");
+  const paths = basouPaths9(repositoryRoot);
+  const manifest = await readManifest5(paths);
+  const roster = manifest.repos ?? [];
+  const facts = roster.map((entry) => gatherRepoGitignore(repositoryRoot, entry));
+  const summary = planGitignore({ repos: facts, required: [...INSTRUCTION_FILES] });
+  const applied = options.apply === true && summary.plans.length > 0;
+  if (applied) {
+    for (const plan of summary.plans) applyGitignorePlan(repositoryRoot, plan);
+  }
+  const result = { ...summary, hasRoster: roster.length > 0, applied };
+  if (options.json === true) {
+    console.log(JSON.stringify(result));
+  } else {
+    console.log(renderProjectGitignore(result));
+  }
+  return result;
+}
+function renderProjectGitignore(result) {
+  const lines = [];
+  lines.push("# .gitignore \u751F\u6210(\u516C\u958B\u7CFB repo \u306E\u6307\u793A\u66F8\u3092\u9664\u5916)");
+  lines.push("");
+  if (!result.hasRoster) {
+    lines.push(
+      "\u2139\uFE0F repo \u30ED\u30FC\u30B9\u30BF\u30FC\u304C\u672A\u5BA3\u8A00\u3067\u3059(manifest \u306E `repos`)\u3002`basou project adopt` \u3067\u5BA3\u8A00\u3057\u3066\u304B\u3089\u5B9F\u884C\u3057\u3066\u304F\u3060\u3055\u3044\u3002"
+    );
+    return lines.join("\n");
+  }
+  if (result.plans.length > 0) {
+    const verb = result.applied ? "\u8FFD\u52A0\u3057\u307E\u3057\u305F" : "\u8FFD\u52A0\u4E88\u5B9A(dry-run\u3001\u53CD\u6620\u3059\u308B\u306B\u306F --apply)";
+    lines.push(
+      `${result.applied ? "\u2705 " : ""}${result.plans.length} repo \u306E .gitignore \u306B${verb}:`
+    );
+    for (const p of result.plans) lines.push(`- ${p.path} \u2014 ${p.toAdd.join(", ")}`);
+  } else if (result.ok) {
+    lines.push("\u2705 \u516C\u958B\u7CFB repo \u306E .gitignore \u306F\u6307\u793A\u66F8\u3092\u3059\u3079\u3066\u9664\u5916\u6E08\u307F\u3067\u3059(\u8FFD\u52A0\u4E0D\u8981)\u3002");
+  } else {
+    lines.push(
+      "\u2139\uFE0F \u8FFD\u52A0\u304C\u5FC5\u8981\u306A\u516C\u958B\u7CFB repo \u306F\u3042\u308A\u307E\u305B\u3093\u304C\u3001\u5224\u5B9A\u3067\u304D\u306A\u3044/\u5230\u9054\u3067\u304D\u306A\u3044 repo \u304C\u3042\u308A\u307E\u3059(\u4E0B\u8A18\u53C2\u7167)\u3002"
+    );
+  }
+  lines.push("");
+  if (result.unknown.length > 0) {
+    lines.push(
+      `## visibility \u672A\u8A2D\u5B9A (${result.unknown.length}) \u2014 \u5BFE\u8C61\u5916\u3002manifest \u306E repos \u306B visibility \u3092\u4ED8\u4E0E\u3057\u3066\u304F\u3060\u3055\u3044`
+    );
+    for (const p of result.unknown) lines.push(`- ${p}`);
+    lines.push("");
+  }
+  if (result.unreachable.length > 0) {
+    lines.push(`## \u5230\u9054\u4E0D\u80FD (${result.unreachable.length}) \u2014 \u30D1\u30B9\u672A\u89E3\u6C7A / git repo \u3067\u306A\u3044`);
+    for (const p of result.unreachable) lines.push(`- ${p}`);
+    lines.push("");
+  }
+  lines.push(
+    "\u6CE8: \u65E2\u5B58\u306E .gitignore \u884C\u306F\u4FDD\u6301\u3057\u3001\u4E0D\u8DB3\u30D1\u30BF\u30FC\u30F3\u306E\u8FFD\u8A18\u306E\u307F\u884C\u3044\u307E\u3059(\u524A\u9664\u306F\u3057\u307E\u305B\u3093)\u3002private / visibility \u672A\u8A2D\u5B9A\u306E repo \u306F\u5BFE\u8C61\u5916\u3067\u3059\u3002"
+  );
+  lines.push(
+    "\u6CE8: .gitignore \u3078\u306E\u8FFD\u8A18\u306F\u3001\u65E2\u306B git \u8FFD\u8DE1\u6E08\u307F\u306E\u30D5\u30A1\u30A4\u30EB\u3092 untrack \u3057\u307E\u305B\u3093\u3002\u8FFD\u8DE1\u6E08\u307F\u306E\u6307\u793A\u66F8\u306F `basou project wiring` \u3067\u691C\u51FA\u3057\u3001`git rm --cached <file>` \u3067\u5916\u3057\u3066\u304F\u3060\u3055\u3044\u3002"
+  );
+  return lines.join("\n");
+}
+async function runProjectSymlinks(options, ctx = {}) {
+  try {
+    await doRunProjectSymlinks(options, ctx);
+  } catch (error) {
+    renderCliError(error, { verbose: isVerbose(options) });
+    process.exitCode = 1;
+  }
+}
+function expectedSymlinkTargets(repoDirReal, canonicalFile) {
+  return [
+    { name: "AGENTS.md", target: relative2(repoDirReal, canonicalFile) },
+    { name: "CLAUDE.md", target: CANONICAL_FILE },
+    { name: ".github/copilot-instructions.md", target: `../${CANONICAL_FILE}` }
+  ];
+}
+function inspectSymlink(filePath, expectedTarget) {
+  let isLink;
+  try {
+    isLink = lstatSync(filePath).isSymbolicLink();
+  } catch (error) {
+    if (hasErrorCode(error) && error.code === "ENOENT") return { state: "missing" };
+    return { state: "blocked" };
+  }
+  if (!isLink) return { state: "occupied" };
+  const actual = readlinkSync(filePath);
+  return actual === expectedTarget ? { state: "correct" } : { state: "mismatch", actualTarget: actual };
+}
+function gatherRepoSymlinks(repositoryRoot, anchorReal, entry) {
+  const base = { path: entry.path };
+  let real;
+  try {
+    real = realpathSync(resolve3(repositoryRoot, entry.path));
+  } catch {
+    return { ...base, isAnchor: false, reachable: false, canonicalPresent: false, files: [] };
+  }
+  if (real === anchorReal) {
+    return { ...base, isAnchor: true, reachable: true, canonicalPresent: false, files: [] };
+  }
+  if (!existsSync(join4(real, ".git"))) {
+    return { ...base, isAnchor: false, reachable: false, canonicalPresent: false, files: [] };
+  }
+  const canonicalFile = join4(anchorReal, "agents", basename3(real), CANONICAL_FILE);
+  if (!existsSync(canonicalFile)) {
+    return { ...base, isAnchor: false, reachable: true, canonicalPresent: false, files: [] };
+  }
+  const files = expectedSymlinkTargets(real, canonicalFile).map(
+    (spec) => {
+      const { state, actualTarget } = inspectSymlink(join4(real, spec.name), spec.target);
+      return {
+        name: spec.name,
+        expectedTarget: spec.target,
+        state,
+        ...actualTarget !== void 0 ? { actualTarget } : {}
+      };
+    }
+  );
+  return {
+    ...base,
+    isAnchor: false,
+    reachable: true,
+    canonicalPresent: true,
+    canonicalName: basename3(real),
+    files
+  };
+}
+function applySymlinkPlan(repositoryRoot, plan) {
+  let real;
+  try {
+    real = realpathSync(resolve3(repositoryRoot, plan.path));
+  } catch (error) {
+    const message = failureReason(error);
+    return { created: [], failed: plan.toCreate.map((c) => ({ file: c.name, message })) };
+  }
+  const created = [];
+  const failed = [];
+  for (const { name, target } of plan.toCreate) {
+    const filePath = join4(real, name);
+    try {
+      mkdirSync(dirname(filePath), { recursive: true });
+      symlinkSync(target, filePath);
+      created.push(name);
+    } catch (error) {
+      failed.push({ file: name, message: failureReason(error) });
+    }
+  }
+  return { created, failed };
+}
+function failureReason(error) {
+  return hasErrorCode(error) ? error.code : "unknown error";
+}
+async function doRunProjectSymlinks(options, ctx) {
+  const cwd = ctx.cwd ?? process.cwd();
+  const repositoryRoot = await resolveBasouRootForCommand(cwd, "project symlinks");
+  const paths = basouPaths9(repositoryRoot);
+  const manifest = await readManifest5(paths);
+  const roster = manifest.repos ?? [];
+  const anchorReal = realpathSync(repositoryRoot);
+  const facts = roster.map((entry) => gatherRepoSymlinks(repositoryRoot, anchorReal, entry));
+  const summary = summarizeSymlinkPlan(facts);
+  const wantApply = options.apply === true && summary.plans.length > 0;
+  const failures = [];
+  let createdCount = 0;
+  if (wantApply) {
+    for (const plan of summary.plans) {
+      const { created, failed } = applySymlinkPlan(repositoryRoot, plan);
+      createdCount += created.length;
+      for (const f of failed) failures.push({ repo: plan.path, file: f.file, message: f.message });
+    }
+  }
+  const result = {
+    ...summary,
+    hasRoster: roster.length > 0,
+    applied: createdCount > 0,
+    failures
+  };
+  if (options.json === true) {
+    console.log(JSON.stringify(result));
+  } else {
+    console.log(renderProjectSymlinks(result));
+  }
+  return result;
+}
+function renderProjectSymlinks(result) {
+  const lines = [];
+  lines.push("# \u6307\u793A\u66F8 symlink \u751F\u6210(\u5404 repo \u2192 anchor \u306E canonical)");
+  lines.push("");
+  if (!result.hasRoster) {
+    lines.push(
+      "\u2139\uFE0F repo \u30ED\u30FC\u30B9\u30BF\u30FC\u304C\u672A\u5BA3\u8A00\u3067\u3059(manifest \u306E `repos`)\u3002`basou project adopt` \u3067\u5BA3\u8A00\u3057\u3066\u304B\u3089\u5B9F\u884C\u3057\u3066\u304F\u3060\u3055\u3044\u3002"
+    );
+    return lines.join("\n");
+  }
+  if (result.plans.length > 0) {
+    const attempted = result.applied || result.failures.length > 0;
+    if (!attempted) {
+      lines.push(
+        `${result.plans.length} repo \u306B\u6307\u793A\u66F8 symlink \u3092\u4F5C\u6210\u4E88\u5B9A(dry-run\u3001\u53CD\u6620\u3059\u308B\u306B\u306F --apply):`
+      );
+      for (const p of result.plans) {
+        lines.push(`- ${p.path}`);
+        for (const c of p.toCreate) lines.push(`    ${c.name} -> ${c.target}`);
+      }
+    } else {
+      const header = result.failures.length === 0 ? "\u2705 \u6307\u793A\u66F8 symlink \u3092\u4F5C\u6210\u3057\u307E\u3057\u305F:" : result.applied ? "\u6307\u793A\u66F8 symlink \u3092\u4F5C\u6210\u3057\u307E\u3057\u305F(\u4E00\u90E8\u5931\u6557\u3001\u4E0B\u8A18\u53C2\u7167):" : "\u6307\u793A\u66F8 symlink \u3092\u4F5C\u6210\u3067\u304D\u307E\u305B\u3093\u3067\u3057\u305F(\u4E0B\u8A18\u53C2\u7167):";
+      lines.push(header);
+      for (const p of result.plans) {
+        const failedFiles = new Set(
+          result.failures.filter((f) => f.repo === p.path).map((f) => f.file)
+        );
+        const created = p.toCreate.filter((c) => !failedFiles.has(c.name));
+        if (created.length === 0) continue;
+        lines.push(`- ${p.path}`);
+        for (const c of created) lines.push(`    ${c.name} -> ${c.target}`);
+      }
+    }
+  } else if (result.ok) {
+    lines.push("\u2705 \u5BA3\u8A00\u3055\u308C\u305F\u5168 repo \u306E\u6307\u793A\u66F8 symlink \u306F\u6B63\u3057\u304F\u5F35\u3089\u308C\u3066\u3044\u307E\u3059(\u751F\u6210\u4E0D\u8981)\u3002");
+  } else {
+    lines.push(
+      "\u2139\uFE0F \u751F\u6210\u304C\u5FC5\u8981\u306A symlink \u306F\u3042\u308A\u307E\u305B\u3093\u304C\u3001\u7AF6\u5408 / \u885D\u7A81 / canonical \u4E0D\u5728 / \u5230\u9054\u3067\u304D\u306A\u3044 repo \u304C\u3042\u308A\u307E\u3059(\u4E0B\u8A18\u53C2\u7167)\u3002"
+    );
+  }
+  lines.push("");
+  if (result.failures.length > 0) {
+    lines.push(`## \u4F5C\u6210\u306B\u5931\u6557 (${result.failures.length}) \u2014 \u4E00\u90E8\u306E symlink \u3092\u4F5C\u6210\u3067\u304D\u307E\u305B\u3093\u3067\u3057\u305F`);
+    for (const f of result.failures) lines.push(`- ${f.repo} \u2014 ${f.file}: ${f.message}`);
+    lines.push("");
+  }
+  if (result.conflicts.length > 0) {
+    lines.push(
+      `## \u7AF6\u5408 (${result.conflicts.length}) \u2014 \u65E2\u5B58\u3092\u4E0A\u66F8\u304D\u3057\u307E\u305B\u3093\u3002\u624B\u52D5\u3067\u78BA\u8A8D\u3057\u3066\u304F\u3060\u3055\u3044`
+    );
+    for (const c of result.conflicts) {
+      const detail = c.reason === "mismatch" ? `\u5225\u306E\u5834\u6240\u3092\u6307\u3059 symlink(\u73FE\u5728: ${c.actualTarget ?? "?"})` : c.reason === "occupied" ? "symlink \u3067\u306A\u3044\u5B9F\u30D5\u30A1\u30A4\u30EB/\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA" : "\u691C\u67FB\u3067\u304D\u306A\u3044\u30D1\u30B9(\u89AA\u304C\u975E\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA\u7B49)";
+      lines.push(`- ${c.repo} \u2014 ${c.file}: ${detail}`);
+    }
+    lines.push("");
+  }
+  if (result.collisions.length > 0) {
+    lines.push(
+      `## canonical \u885D\u7A81 (${result.collisions.length}) \u2014 \u5225 repo \u304C\u540C\u540D canonical \u3092\u5171\u6709(\u81EA\u52D5\u914D\u7DDA\u3057\u307E\u305B\u3093)`
+    );
+    for (const c of result.collisions) {
+      lines.push(`- agents/${c.canonicalName}/AGENTS.md \u2190 ${c.repos.join(", ")}`);
+    }
+    lines.push("");
+  }
+  if (result.missingCanonical.length > 0) {
+    lines.push(
+      `## canonical \u4E0D\u5728 (${result.missingCanonical.length}) \u2014 anchor \u306B agents/<repo>/AGENTS.md \u304C\u7121\u3044\u305F\u3081\u751F\u6210\u3067\u304D\u307E\u305B\u3093`
+    );
+    for (const p of result.missingCanonical) lines.push(`- ${p}`);
+    lines.push("");
+  }
+  if (result.unreachable.length > 0) {
+    lines.push(`## \u5230\u9054\u4E0D\u80FD (${result.unreachable.length}) \u2014 \u30D1\u30B9\u672A\u89E3\u6C7A / git repo \u3067\u306A\u3044`);
+    for (const p of result.unreachable) lines.push(`- ${p}`);
+    lines.push("");
+  }
+  lines.push(
+    "\u6CE8: \u65E2\u5B58\u30D5\u30A1\u30A4\u30EB\u30FB\u5225\u306E\u5834\u6240\u3092\u6307\u3059 symlink \u306F\u4E0A\u66F8\u304D\u305B\u305A\u3001\u4E0D\u8DB3\u5206\u306E\u4F5C\u6210\u306E\u307F\u884C\u3044\u307E\u3059(GEMINI.md \u306F\u5EC3\u6B62\u306E\u305F\u3081\u751F\u6210\u3057\u307E\u305B\u3093)\u3002"
+  );
+  return lines.join("\n");
+}
+async function runProjectWorkspace(options, ctx = {}) {
+  try {
+    await doRunProjectWorkspace(options, ctx);
+  } catch (error) {
+    renderCliError(error, { verbose: isVerbose(options) });
+    process.exitCode = 1;
+  }
+}
+function resolveViewDir(repositoryRoot, viewPath) {
+  const abs = resolve3(repositoryRoot, viewPath);
+  try {
+    return realpathSync(abs);
+  } catch {
+    try {
+      return join4(realpathSync(dirname(abs)), basename3(abs));
+    } catch {
+      return abs;
+    }
+  }
+}
+function gatherViewRepo(repositoryRoot, viewDir, entry) {
+  let repoReal;
+  try {
+    repoReal = realpathSync(resolve3(repositoryRoot, entry.path));
+  } catch {
+    return { path: entry.path, reachable: false };
+  }
+  const expectedTarget = relative2(viewDir, repoReal);
+  if (expectedTarget === "" || expectedTarget === ".") {
+    return { path: entry.path, reachable: false };
+  }
+  const linkName = basename3(repoReal);
+  const { state, actualTarget } = inspectSymlink(join4(viewDir, linkName), expectedTarget);
+  return {
+    path: entry.path,
+    reachable: true,
+    linkName,
+    expectedTarget,
+    state,
+    ...actualTarget !== void 0 ? { actualTarget } : {}
+  };
+}
+function applyViewPlan(viewDir, toCreate) {
+  const created = [];
+  const failed = [];
+  for (const { name, target } of toCreate) {
+    const filePath = join4(viewDir, name);
+    try {
+      mkdirSync(dirname(filePath), { recursive: true });
+      symlinkSync(target, filePath);
+      created.push(name);
+    } catch (error) {
+      failed.push({ name, message: failureReason(error) });
+    }
+  }
+  return { created, failed };
+}
+var TOP_LEVEL_INSTRUCTION_FILES_LOWER = new Set(
+  INSTRUCTION_FILES.filter((f) => !f.includes("/")).map((f) => f.toLowerCase())
+);
+function classifyViewLink(viewDir, name, rosterRealpaths) {
+  const filePath = join4(viewDir, name);
+  let isLink;
+  try {
+    isLink = lstatSync(filePath).isSymbolicLink();
+  } catch {
+    return null;
+  }
+  if (!isLink) return null;
+  let target;
+  try {
+    target = readlinkSync(filePath);
+  } catch {
+    return null;
+  }
+  const resolved = isAbsolute(target) ? target : resolve3(viewDir, target);
+  try {
+    if (rosterRealpaths.has(realpathSync(resolved))) return null;
+  } catch {
+  }
+  if (isAbsolute(target)) return { target, kind: "absolute" };
+  let isDir = false;
+  try {
+    isDir = statSync(resolved).isDirectory();
+  } catch {
+    isDir = false;
+  }
+  if (!isDir) {
+    return { target, kind: existsSync(resolved) ? "non-repo" : "broken" };
+  }
+  return { target, kind: existsSync(join4(resolved, ".git")) ? "repo" : "non-repo" };
+}
+function gatherExistingViewLinks(viewDir, rosterRealpaths) {
+  let names;
+  try {
+    names = readdirSync(viewDir);
+  } catch (error) {
+    if (hasErrorCode(error) && error.code === "ENOENT") return [];
+    throw new Error("workspace view \u3092\u8D70\u67FB\u3067\u304D\u307E\u305B\u3093(\u30D1\u30B9/\u7A2E\u5225\u3092\u78BA\u8A8D\u3057\u3066\u304F\u3060\u3055\u3044)", {
+      cause: error
+    });
+  }
+  const links = [];
+  for (const name of names) {
+    if (TOP_LEVEL_INSTRUCTION_FILES_LOWER.has(name.toLowerCase())) continue;
+    const c = classifyViewLink(viewDir, name, rosterRealpaths);
+    if (c === null) continue;
+    links.push({ name, target: c.target, kind: c.kind });
+  }
+  return links;
+}
+function pruneViewLinks(viewDir, toPrune, rosterRealpaths) {
+  const pruned = [];
+  const failed = [];
+  for (const { name } of toPrune) {
+    const filePath = join4(viewDir, name);
+    const c = classifyViewLink(viewDir, name, rosterRealpaths);
+    if (c === null || c.kind !== "repo") {
+      failed.push({
+        name,
+        message: "\u64A4\u53BB\u5BFE\u8C61\u304C scan \u6642\u3068\u5909\u308F\u308A\u307E\u3057\u305F(basou \u751F\u6210\u306E stray repo link \u3067\u306F\u306A\u304F\u306A\u3063\u305F/\u518D\u5B9F\u884C\u3057\u3066\u304F\u3060\u3055\u3044)"
+      });
+      continue;
+    }
+    try {
+      unlinkSync(filePath);
+      pruned.push(name);
+    } catch (error) {
+      failed.push({ name, message: failureReason(error) });
+    }
+  }
+  return { pruned, failed };
+}
+async function doRunProjectWorkspace(options, ctx) {
+  const cwd = ctx.cwd ?? process.cwd();
+  const repositoryRoot = await resolveBasouRootForCommand(cwd, "project workspace");
+  const paths = basouPaths9(repositoryRoot);
+  const manifest = await readManifest5(paths);
+  const viewPath = manifest.workspace.view;
+  const roster = manifest.repos ?? [];
+  let result;
+  if (viewPath === void 0) {
+    result = {
+      toCreate: [],
+      conflicts: [],
+      collisions: [],
+      unreachable: [],
+      toPrune: [],
+      strayUnknown: [],
+      correctCount: 0,
+      ok: true,
+      hasView: false,
+      applied: false,
+      pruned: false,
+      pruneWithheld: false,
+      failures: [],
+      pruneFailures: []
+    };
+  } else {
+    const viewDir = resolveViewDir(repositoryRoot, viewPath);
+    const facts = roster.map((entry) => gatherViewRepo(repositoryRoot, viewDir, entry));
+    const rosterNames = roster.map((entry) => basename3(resolve3(repositoryRoot, entry.path)));
+    const rosterRealpaths = /* @__PURE__ */ new Set();
+    for (const entry of roster) {
+      try {
+        rosterRealpaths.add(realpathSync(resolve3(repositoryRoot, entry.path)));
+      } catch {
+      }
+    }
+    const existing = gatherExistingViewLinks(viewDir, rosterRealpaths);
+    const plan = planWorkspaceView(facts, existing, rosterNames);
+    const failures = [];
+    let createdCount = 0;
+    if (options.apply === true && plan.toCreate.length > 0) {
+      const applied = applyViewPlan(viewDir, plan.toCreate);
+      createdCount = applied.created.length;
+      for (const f of applied.failed) failures.push(f);
+    }
+    const pruneWithheld = options.prune === true && plan.toPrune.length > 0 && plan.unreachable.length > 0;
+    const pruneFailures = [];
+    let prunedCount = 0;
+    if (options.prune === true && plan.toPrune.length > 0 && plan.unreachable.length === 0) {
+      const removed = pruneViewLinks(viewDir, plan.toPrune, rosterRealpaths);
+      prunedCount = removed.pruned.length;
+      for (const f of removed.failed) pruneFailures.push(f);
+    }
+    const createsOutstanding = plan.toCreate.length > 0 && !(options.apply === true && failures.length === 0);
+    const prunesOutstanding = plan.toPrune.length > 0 && !(options.prune === true && !pruneWithheld && pruneFailures.length === 0);
+    const ok = plan.conflicts.length === 0 && plan.collisions.length === 0 && plan.unreachable.length === 0 && plan.strayUnknown.length === 0 && !createsOutstanding && !prunesOutstanding;
+    result = {
+      ...plan,
+      ok,
+      hasView: true,
+      applied: createdCount > 0,
+      pruned: prunedCount > 0,
+      pruneWithheld,
+      failures,
+      pruneFailures
+    };
+  }
+  if (options.json === true) {
+    console.log(JSON.stringify(result));
+  } else {
+    console.log(renderProjectWorkspace(result));
+  }
+  return result;
+}
+function renderProjectWorkspace(result) {
+  const lines = [];
+  lines.push("# workspace view \u751F\u6210(roster repo \u3092\u96C6\u7D04)");
+  lines.push("");
+  if (!result.hasView) {
+    lines.push(
+      "\u2139\uFE0F view \u304C\u672A\u5BA3\u8A00\u3067\u3059(manifest \u306E `workspace.view`)\u3002\u96C6\u7D04\u5148\u306E\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA\u3092\u5BA3\u8A00\u3057\u3066\u304B\u3089\u5B9F\u884C\u3057\u3066\u304F\u3060\u3055\u3044\u3002"
+    );
+    return lines.join("\n");
+  }
+  if (result.toCreate.length > 0) {
+    const attempted = result.applied || result.failures.length > 0;
+    if (!attempted) {
+      lines.push(
+        `${result.toCreate.length} \u4EF6\u306E repo symlink \u3092 view \u306B\u4F5C\u6210\u4E88\u5B9A(dry-run\u3001\u53CD\u6620\u3059\u308B\u306B\u306F --apply):`
+      );
+      for (const c of result.toCreate) lines.push(`    ${c.name} -> ${c.target}`);
+    } else {
+      const failed = new Set(result.failures.map((f) => f.name));
+      const header = result.failures.length === 0 ? "\u2705 view \u306B repo symlink \u3092\u4F5C\u6210\u3057\u307E\u3057\u305F:" : result.applied ? "view \u306B repo symlink \u3092\u4F5C\u6210\u3057\u307E\u3057\u305F(\u4E00\u90E8\u5931\u6557\u3001\u4E0B\u8A18\u53C2\u7167):" : "view \u306B repo symlink \u3092\u4F5C\u6210\u3067\u304D\u307E\u305B\u3093\u3067\u3057\u305F(\u4E0B\u8A18\u53C2\u7167):";
+      lines.push(header);
+      for (const c of result.toCreate) {
+        if (failed.has(c.name)) continue;
+        lines.push(`    ${c.name} -> ${c.target}`);
+      }
+    }
+  } else if (result.ok) {
+    lines.push(
+      `\u2705 view \u306F\u5BA3\u8A00\u3055\u308C\u305F roster \u3092\u3059\u3079\u3066\u96C6\u7D04\u3057\u3066\u3044\u307E\u3059(${result.correctCount} links\u3001\u751F\u6210\u4E0D\u8981)\u3002`
+    );
+  } else {
+    lines.push(
+      "\u2139\uFE0F \u4F5C\u6210\u304C\u5FC5\u8981\u306A symlink \u306F\u3042\u308A\u307E\u305B\u3093\u304C\u3001\u5BFE\u5FDC\u306E\u5FC5\u8981\u306A\u9805\u76EE\u304C\u3042\u308A\u307E\u3059(stray / \u7AF6\u5408 / \u885D\u7A81 / \u5230\u9054\u3067\u304D\u306A\u3044 repo\u3001\u4E0B\u8A18\u53C2\u7167)\u3002"
+    );
+  }
+  lines.push("");
+  if (result.failures.length > 0) {
+    lines.push(`## \u4F5C\u6210\u306B\u5931\u6557 (${result.failures.length}) \u2014 \u4E00\u90E8\u306E symlink \u3092\u4F5C\u6210\u3067\u304D\u307E\u305B\u3093\u3067\u3057\u305F`);
+    for (const f of result.failures) lines.push(`- ${f.name}: ${f.message}`);
+    lines.push("");
+  }
+  if (result.toPrune.length > 0) {
+    const attempted = result.pruned || result.pruneFailures.length > 0;
+    if (result.pruneWithheld) {
+      lines.push(
+        `${result.toPrune.length} \u4EF6\u306E stray repo symlink \u3092\u64A4\u53BB\u4E88\u5B9A\u3067\u3057\u305F\u304C\u3001\u5230\u9054\u3067\u304D\u306A\u3044 repo \u304C\u3042\u308B\u305F\u3081\u64A4\u53BB\u3092\u4FDD\u7559\u3057\u307E\u3057\u305F(\u5230\u9054\u3067\u304D\u306A\u3044 repo \u306E link \u3068 stray \u3092\u533A\u5225\u3067\u304D\u306A\u3044\u305F\u3081\u3002\u4E0B\u8A18\u306E repo \u3092\u89E3\u6C7A\u3059\u308B\u304B archive \u3057\u3066\u304B\u3089\u518D\u5B9F\u884C\u3057\u3066\u304F\u3060\u3055\u3044):`
+      );
+      for (const p of result.toPrune) lines.push(`    ${p.name} -> ${p.target}`);
+    } else if (!attempted) {
+      lines.push(
+        `${result.toPrune.length} \u4EF6\u306E stray repo symlink \u3092\u64A4\u53BB\u4E88\u5B9A(dry-run\u3001\u64A4\u53BB\u3059\u308B\u306B\u306F --prune):`
+      );
+      for (const p of result.toPrune) lines.push(`    ${p.name} -> ${p.target}`);
+    } else {
+      const failed = new Set(result.pruneFailures.map((f) => f.name));
+      const header = result.pruneFailures.length === 0 ? "\u{1F9F9} stray repo symlink \u3092\u64A4\u53BB\u3057\u307E\u3057\u305F:" : result.pruned ? "stray repo symlink \u3092\u64A4\u53BB\u3057\u307E\u3057\u305F(\u4E00\u90E8\u5931\u6557\u3001\u4E0B\u8A18\u53C2\u7167):" : "stray repo symlink \u3092\u64A4\u53BB\u3067\u304D\u307E\u305B\u3093\u3067\u3057\u305F(\u4E0B\u8A18\u53C2\u7167):";
+      lines.push(header);
+      for (const p of result.toPrune) {
+        if (failed.has(p.name)) continue;
+        lines.push(`    ${p.name} -> ${p.target}`);
+      }
+    }
+    lines.push("");
+  }
+  if (result.pruneFailures.length > 0) {
+    lines.push(
+      `## \u64A4\u53BB\u306B\u5931\u6557 (${result.pruneFailures.length}) \u2014 \u4E00\u90E8\u306E stray symlink \u3092\u64A4\u53BB\u3067\u304D\u307E\u305B\u3093\u3067\u3057\u305F`
+    );
+    for (const f of result.pruneFailures) lines.push(`- ${f.name}: ${f.message}`);
+    lines.push("");
+  }
+  if (result.conflicts.length > 0) {
+    lines.push(
+      `## \u7AF6\u5408 (${result.conflicts.length}) \u2014 \u65E2\u5B58\u3092\u4E0A\u66F8\u304D\u3057\u307E\u305B\u3093\u3002\u624B\u52D5\u3067\u78BA\u8A8D\u3057\u3066\u304F\u3060\u3055\u3044`
+    );
+    for (const c of result.conflicts) {
+      const detail = c.reason === "mismatch" ? `\u5225\u306E\u5834\u6240\u3092\u6307\u3059 symlink(\u73FE\u5728: ${c.actualTarget ?? "?"})` : c.reason === "occupied" ? "symlink \u3067\u306A\u3044\u5B9F\u30D5\u30A1\u30A4\u30EB/\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA" : "\u691C\u67FB\u3067\u304D\u306A\u3044\u30D1\u30B9(\u89AA\u304C\u975E\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA\u7B49)";
+      lines.push(`- ${c.name}: ${detail}`);
+    }
+    lines.push("");
+  }
+  if (result.collisions.length > 0) {
+    lines.push(
+      `## basename \u885D\u7A81 (${result.collisions.length}) \u2014 \u5225 repo \u304C\u540C\u3058 view \u540D\u3092\u53D6\u308A\u5408\u3044(\u81EA\u52D5\u914D\u7DDA\u3057\u307E\u305B\u3093)`
+    );
+    for (const c of result.collisions) lines.push(`- ${c.linkName} \u2190 ${c.repos.join(", ")}`);
+    lines.push("");
+  }
+  if (result.unreachable.length > 0) {
+    lines.push(
+      `## \u5230\u9054\u4E0D\u80FD (${result.unreachable.length}) \u2014 \u30D1\u30B9\u672A\u89E3\u6C7A\u3001\u307E\u305F\u306F view \u81EA\u8EAB\u306B\u89E3\u6C7A\u3059\u308B\u305F\u3081\u96C6\u7D04\u3067\u304D\u307E\u305B\u3093`
+    );
+    for (const p of result.unreachable) lines.push(`- ${p}`);
+    lines.push("");
+  }
+  if (result.strayUnknown.length > 0) {
+    lines.push(
+      `## \u672A\u64A4\u53BB\u306E stray (${result.strayUnknown.length}) \u2014 basou \u751F\u6210\u306E repo link \u3068\u78BA\u8A8D\u3067\u304D\u306A\u3044\u305F\u3081\u64A4\u53BB\u3057\u307E\u305B\u3093\u3002\u624B\u52D5\u3067\u78BA\u8A8D\u3057\u3066\u304F\u3060\u3055\u3044`
+    );
+    for (const s of result.strayUnknown) {
+      const detail = s.reason === "broken" ? "\u30EA\u30F3\u30AF\u5207\u308C(\u30BF\u30FC\u30B2\u30C3\u30C8\u304C\u89E3\u6C7A\u3067\u304D\u307E\u305B\u3093)" : s.reason === "non-repo" ? "git repo \u3067\u306A\u3044\u30BF\u30FC\u30B2\u30C3\u30C8(\u30D5\u30A1\u30A4\u30EB\u3001\u307E\u305F\u306F .git \u306E\u7121\u3044\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA)" : "\u7D76\u5BFE\u30D1\u30B9\u306E\u30BF\u30FC\u30B2\u30C3\u30C8(basou \u306F\u76F8\u5BFE\u30EA\u30F3\u30AF\u306E\u307F\u751F\u6210\u3057\u307E\u3059)";
+      lines.push(`- ${s.name} -> ${s.target}: ${detail}`);
+    }
+    lines.push("");
+  }
+  lines.push(
+    "\u6CE8: \u4F5C\u6210(--apply)\u306F\u65E2\u5B58\u30A8\u30F3\u30C8\u30EA\u3092\u4E0A\u66F8\u304D\u3057\u307E\u305B\u3093\u3002stray repo link \u306E\u64A4\u53BB\u306F --prune \u3067\u884C\u3044\u307E\u3059(symlink \u306E\u307F\u524A\u9664\u3057\u3001\u53C2\u7167\u5148 repo \u306F\u524A\u9664\u3057\u307E\u305B\u3093)\u3002basou \u751F\u6210\u3068\u78BA\u8A8D\u3067\u304D\u306A\u3044 stray(\u30EA\u30F3\u30AF\u5207\u308C / \u975E repo / \u7D76\u5BFE\u30D1\u30B9)\u306F\u64A4\u53BB\u3057\u307E\u305B\u3093\u3002"
+  );
+  return lines.join("\n");
 }
-function wouldImport(outcome) {
-  return outcome.status === "ran" ? outcome.importedCount : 0;
+async function runProjectPreset(options, ctx = {}) {
+  try {
+    await doRunProjectPreset(options, ctx);
+  } catch (error) {
+    renderCliError(error, { verbose: isVerbose(options) });
+    process.exitCode = 1;
+  }
 }
-function wouldUpdate(outcome) {
-  return outcome.status === "ran" ? outcome.reimportedCount + outcome.replacedCount : 0;
+function canonicalFileFor(anchorReal, canonicalName) {
+  return join4(anchorReal, "agents", canonicalName, CANONICAL_FILE);
 }
-function wouldBlock(outcome) {
-  return outcome.status === "ran" ? outcome.skippedUnverifiable : 0;
+function canonicalLabelFor(canonicalName) {
+  return join4("agents", canonicalName, CANONICAL_FILE);
 }
-async function probeStaleness(args) {
+async function gatherRepoPreset(repositoryRoot, anchorReal, entry) {
+  const declared = {
+    path: entry.path,
+    ...entry.visibility !== void 0 ? { visibility: entry.visibility } : {},
+    ...entry.language !== void 0 ? { language: entry.language } : {},
+    ...entry.publishes !== void 0 ? { publishes: entry.publishes } : {}
+  };
+  let real;
   try {
-    const dry = await refreshAll({
-      options: { dryRun: true },
-      ctx: args.ctx,
-      paths: args.paths,
-      nowIso: args.nowIso
-    });
+    real = realpathSync(resolve3(repositoryRoot, entry.path));
+  } catch {
+    return { ...declared, isAnchor: false, reachable: false, canonicalPresent: false };
+  }
+  if (real === anchorReal) {
+    return { ...declared, isAnchor: true, reachable: true, canonicalPresent: false };
+  }
+  if (!existsSync(join4(real, ".git"))) {
+    return { ...declared, isAnchor: false, reachable: false, canonicalPresent: false };
+  }
+  const canonicalName = basename3(real);
+  let content;
+  try {
+    content = await readMarkdownFile4(canonicalFileFor(anchorReal, canonicalName));
+  } catch {
     return {
-      newSessions: wouldImport(dry.claudeCode) + wouldImport(dry.codex),
-      updatedSessions: wouldUpdate(dry.claudeCode) + wouldUpdate(dry.codex),
-      unverifiableSessions: wouldBlock(dry.claudeCode) + wouldBlock(dry.codex)
+      ...declared,
+      isAnchor: false,
+      reachable: true,
+      canonicalName,
+      canonicalPresent: true,
+      canonicalReadable: false
+    };
+  }
+  if (content === null) {
+    return {
+      ...declared,
+      isAnchor: false,
+      reachable: true,
+      canonicalName,
+      canonicalPresent: false
     };
-  } catch {
-    return null;
   }
+  const section = parseMarkers(content);
+  return {
+    ...declared,
+    isAnchor: false,
+    reachable: true,
+    canonicalName,
+    canonicalPresent: true,
+    canonicalReadable: true,
+    markerKind: section.kind,
+    ...section.kind === "ok" ? { currentBlock: section.generated } : {}
+  };
 }
-// src/lib/repo-root.ts
-import { resolveBasouRepositoryRoot } from "@basou/core";
-async function resolveBasouRootForCommand(cwd, commandName) {
+async function applyPresetPlan(anchorReal, plan) {
+  const file = canonicalFileFor(anchorReal, plan.canonicalName);
+  const label = canonicalLabelFor(plan.canonicalName);
+  let isLink = false;
   try {
-    return await resolveBasouRepositoryRoot(cwd, {
-      onRedirect: ({ via, root }) => console.error(`Resolved workspace view to ${root} (via ${via}).`)
-    });
-  } catch (error) {
-    if (error instanceof Error && error.message === "Not a git repository") {
-      throw new Error(
-        `Not a git repository. Run 'git init' first, then re-run 'basou ${commandName}'.`,
-        { cause: error }
-      );
+    isLink = lstatSync(file).isSymbolicLink();
+  } catch {
+    isLink = false;
+  }
+  if (isLink) throw new Error(`Canonical is a symlink in ${label}`);
+  if (plan.action === "create") mkdirSync(dirname(file), { recursive: true });
+  const existing = await readMarkdownFile4(file);
+  await writeMarkdownFile5(file, renderWithMarkers4(existing, plan.desiredBlock, label));
+}
+function presetFailureReason(error) {
+  if (error instanceof Error && (error.message.startsWith("Markers") || error.message.startsWith("Canonical"))) {
+    return error.message;
+  }
+  const cause = error instanceof Error ? error.cause : void 0;
+  if (hasErrorCode(cause)) return cause.code;
+  if (hasErrorCode(error)) return error.code;
+  return "unknown error";
+}
+async function doRunProjectPreset(options, ctx) {
+  const cwd = ctx.cwd ?? process.cwd();
+  const repositoryRoot = await resolveBasouRootForCommand(cwd, "project preset");
+  const paths = basouPaths9(repositoryRoot);
+  const manifest = await readManifest5(paths);
+  const roster = manifest.repos ?? [];
+  const anchorReal = realpathSync(repositoryRoot);
+  const facts = [];
+  for (const entry of roster) facts.push(await gatherRepoPreset(repositoryRoot, anchorReal, entry));
+  const summary = summarizePresetPlan(facts);
+  const failures = [];
+  let writtenCount = 0;
+  if (options.apply === true && summary.plans.length > 0) {
+    for (const plan of summary.plans) {
+      try {
+        await applyPresetPlan(anchorReal, plan);
+        writtenCount += 1;
+      } catch (error) {
+        failures.push({ repo: plan.path, message: presetFailureReason(error) });
+      }
     }
-    throw error;
   }
+  const result = {
+    ...summary,
+    hasRoster: roster.length > 0,
+    applied: writtenCount > 0,
+    failures
+  };
+  if (options.json === true) {
+    console.log(JSON.stringify(result));
+  } else {
+    console.log(renderProjectPreset(result));
+  }
+  return result;
 }
-// src/commands/orient.ts
-function registerOrientCommand(program) {
-  program.command("orient").description("Show the workspace's current position (also writes .basou/orientation.md)").option("-q, --quiet", "Write the file without printing the body").option("-v, --verbose", "Show error causes").action(async (opts) => {
-    await runOrient(opts);
-  });
+function presetActionLabel(action) {
+  return action === "create" ? "\u65B0\u898F\u4F5C\u6210" : "\u66F4\u65B0";
 }
-async function runOrient(options, ctx = {}) {
+function renderProjectPreset(result) {
+  const lines = [];
+  lines.push("# \u6307\u793A\u66F8 A \u30D7\u30EA\u30BB\u30C3\u30C8\u751F\u6210(\u5BA3\u8A00 \u2192 canonical \u306E\u751F\u6210\u9818\u57DF)");
+  lines.push("");
+  if (!result.hasRoster) {
+    lines.push(
+      "\u2139\uFE0F repo \u30ED\u30FC\u30B9\u30BF\u30FC\u304C\u672A\u5BA3\u8A00\u3067\u3059(manifest \u306E `repos`)\u3002`basou project adopt` \u3067\u5BA3\u8A00\u3057\u3066\u304B\u3089\u5B9F\u884C\u3057\u3066\u304F\u3060\u3055\u3044\u3002"
+    );
+    return lines.join("\n");
+  }
+  if (result.plans.length > 0) {
+    const attempted = result.applied || result.failures.length > 0;
+    if (!attempted) {
+      lines.push(
+        `${result.plans.length} repo \u306E canonical \u306B A \u30D7\u30EA\u30BB\u30C3\u30C8\u3092\u751F\u6210\u4E88\u5B9A(dry-run\u3001\u53CD\u6620\u3059\u308B\u306B\u306F --apply):`
+      );
+      for (const p of result.plans) {
+        lines.push(
+          `- ${p.path} [${presetActionLabel(p.action)}] \u2192 ${canonicalLabelFor(p.canonicalName)}`
+        );
+        for (const bl of p.desiredBlock.split("\n")) lines.push(`    ${bl}`);
+      }
+    } else {
+      const failed = new Set(result.failures.map((f) => f.repo));
+      const header = result.failures.length === 0 ? "\u2705 canonical \u306B A \u30D7\u30EA\u30BB\u30C3\u30C8\u3092\u751F\u6210\u3057\u307E\u3057\u305F:" : result.applied ? "A \u30D7\u30EA\u30BB\u30C3\u30C8\u3092\u751F\u6210\u3057\u307E\u3057\u305F(\u4E00\u90E8\u5931\u6557\u3001\u4E0B\u8A18\u53C2\u7167):" : "A \u30D7\u30EA\u30BB\u30C3\u30C8\u3092\u751F\u6210\u3067\u304D\u307E\u305B\u3093\u3067\u3057\u305F(\u4E0B\u8A18\u53C2\u7167):";
+      lines.push(header);
+      for (const p of result.plans) {
+        if (failed.has(p.path)) continue;
+        lines.push(
+          `- ${p.path} [${presetActionLabel(p.action)}] \u2192 ${canonicalLabelFor(p.canonicalName)}`
+        );
+      }
+    }
+  } else if (result.ok) {
+    lines.push("\u2705 \u5BA3\u8A00\u3055\u308C\u305F\u5168 repo \u306E A \u30D7\u30EA\u30BB\u30C3\u30C8\u306F canonical \u3068\u540C\u671F\u6E08\u307F\u3067\u3059(\u751F\u6210\u4E0D\u8981)\u3002");
+  } else {
+    lines.push(
+      "\u2139\uFE0F \u751F\u6210\u304C\u5FC5\u8981\u306A repo \u306F\u3042\u308A\u307E\u305B\u3093\u304C\u3001\u30DE\u30FC\u30AB\u30FC\u7AF6\u5408 / \u885D\u7A81 / \u672A\u5BA3\u8A00 / \u5230\u9054\u3067\u304D\u306A\u3044 repo \u304C\u3042\u308A\u307E\u3059(\u4E0B\u8A18\u53C2\u7167)\u3002"
+    );
+  }
+  lines.push("");
+  if (result.inSync.length > 0) {
+    lines.push(`\u540C\u671F\u6E08\u307F (${result.inSync.length}): ${result.inSync.join(", ")}`);
+    lines.push("");
+  }
+  if (result.failures.length > 0) {
+    lines.push(
+      `## \u66F8\u304D\u8FBC\u307F\u306B\u5931\u6557 (${result.failures.length}) \u2014 \u4E00\u90E8\u306E canonical \u3092\u66F8\u3051\u307E\u305B\u3093\u3067\u3057\u305F`
+    );
+    for (const f of result.failures) lines.push(`- ${f.repo}: ${f.message}`);
+    lines.push("");
+  }
+  if (result.markerConflicts.length > 0) {
+    lines.push(
+      `## \u30DE\u30FC\u30AB\u30FC\u7AF6\u5408 (${result.markerConflicts.length}) \u2014 canonical \u306E\u30DE\u30FC\u30AB\u30FC\u304C\u7121\u3044/\u58CA\u308C\u3066\u3044\u308B\u305F\u3081\u4E0A\u66F8\u304D\u3057\u307E\u305B\u3093`
+    );
+    for (const c of result.markerConflicts) {
+      const detail = c.reason === "no_markers" ? "\u30DE\u30FC\u30AB\u30FC\u9818\u57DF\u304C\u7121\u3044" : `\u30DE\u30FC\u30AB\u30FC\u4E0D\u6574\u5408(${c.reason})`;
+      lines.push(`- ${c.repo}: ${detail}`);
+    }
+    lines.push(
+      `  \u5BFE\u51E6: A \u30D7\u30EA\u30BB\u30C3\u30C8\u3092\u5165\u308C\u305F\u3044\u4F4D\u7F6E\u306B\u6B21\u306E2\u884C\u3092\u8FFD\u52A0\u3057\u3066\u304F\u3060\u3055\u3044 \u2014 \`${GENERATED_START}\` \u3068 \`${GENERATED_END}\`(\u7121\u3051\u308C\u3070 basou \u304C\u65B0\u898F canonical \u3092\u4F5C\u308A\u307E\u3059)\u3002`
+    );
+    lines.push("");
+  }
+  if (result.unreadable.length > 0) {
+    lines.push(
+      `## canonical \u8AAD\u307F\u53D6\u308A\u4E0D\u80FD (${result.unreadable.length}) \u2014 \u30C7\u30A3\u30EC\u30AF\u30C8\u30EA/\u6A29\u9650\u7B49\u3067\u8AAD\u3081\u307E\u305B\u3093`
+    );
+    for (const p of result.unreadable) lines.push(`- ${p}`);
+    lines.push("");
+  }
+  if (result.collisions.length > 0) {
+    lines.push(
+      `## canonical \u885D\u7A81 (${result.collisions.length}) \u2014 \u5225 repo \u304C\u540C\u540D canonical \u3092\u5171\u6709(\u81EA\u52D5\u751F\u6210\u3057\u307E\u305B\u3093)`
+    );
+    for (const c of result.collisions) {
+      lines.push(`- agents/${c.canonicalName}/AGENTS.md \u2190 ${c.repos.join(", ")}`);
+    }
+    lines.push("");
+  }
+  if (result.undeclared.length > 0) {
+    lines.push(
+      `## \u5BA3\u8A00\u306A\u3057 (${result.undeclared.length}) \u2014 visibility / language / publishes \u304C\u672A\u8A2D\u5B9A\u306E\u305F\u3081\u751F\u6210\u3057\u307E\u305B\u3093`
+    );
+    for (const p of result.undeclared) lines.push(`- ${p}`);
+    lines.push("");
+  }
+  if (result.anchors.length > 0) {
+    lines.push(
+      `## anchor (${result.anchors.length}) \u2014 \u81EA\u8EAB\u306E AGENTS.md \u306F\u624B\u3067\u7DAD\u6301\u3059\u308B\u305F\u3081\u30B9\u30AD\u30C3\u30D7`
+    );
+    for (const p of result.anchors) lines.push(`- ${p}`);
+    lines.push("");
+  }
+  if (result.unreachable.length > 0) {
+    lines.push(`## \u5230\u9054\u4E0D\u80FD (${result.unreachable.length}) \u2014 \u30D1\u30B9\u672A\u89E3\u6C7A / git repo \u3067\u306A\u3044`);
+    for (const p of result.unreachable) lines.push(`- ${p}`);
+    lines.push("");
+  }
+  lines.push(
+    "\u6CE8: \u30DE\u30FC\u30AB\u30FC\u9818\u57DF\u306E\u307F\u3092\u751F\u6210\u3057\u3001canonical \u306E\u624B\u66F8\u304D\u90E8\u5206(\u30DE\u30FC\u30AB\u30FC\u5916)\u306F\u4FDD\u6301\u3057\u307E\u3059\u3002\u751F\u6210\u5185\u5BB9\u306F manifest \u306E\u5BA3\u8A00\u304B\u3089\u5C0E\u51FA\u3055\u308C\u307E\u3059\u3002"
+  );
+  return lines.join("\n");
+}
+async function runProjectArchive(target, options, ctx = {}) {
   try {
-    await doRunOrient(options, ctx);
+    await doRunProjectArchive(target, options, ctx);
   } catch (error) {
     renderCliError(error, { verbose: isVerbose(options) });
     process.exitCode = 1;
   }
 }
-async function doRunOrient(options, ctx) {
+function gatherArchiveTeardown(repositoryRoot, manifest, target) {
+  const empty = {
+    inspected: false,
+    viewLink: false,
+    instructionFiles: [],
+    gitignorePatterns: [],
+    canonical: false
+  };
+  let real;
+  try {
+    real = realpathSync(resolve3(repositoryRoot, target));
+  } catch {
+    return empty;
+  }
+  const anchorReal = realpathSync(repositoryRoot);
+  const canonicalName = basename3(real);
+  const instructionFiles = [];
+  for (const name of INSTRUCTION_FILES) {
+    try {
+      lstatSync(join4(real, name));
+      instructionFiles.push(name);
+    } catch {
+    }
+  }
+  let ignored;
+  try {
+    ignored = new Set(readGitignoreLines(join4(real, ".gitignore")).map((l) => l.trim()));
+  } catch {
+    ignored = /* @__PURE__ */ new Set();
+  }
+  const gitignorePatterns = INSTRUCTION_FILES.filter((p) => ignored.has(p) || ignored.has(`/${p}`));
+  const canonical2 = existsSync(join4(anchorReal, "agents", canonicalName, CANONICAL_FILE));
+  let viewLink = false;
+  const viewPath = manifest.workspace.view;
+  if (viewPath !== void 0) {
+    try {
+      lstatSync(join4(resolveViewDir(repositoryRoot, viewPath), canonicalName));
+      viewLink = true;
+    } catch {
+    }
+  }
+  return {
+    inspected: true,
+    viewLink,
+    instructionFiles,
+    gitignorePatterns: [...gitignorePatterns],
+    canonical: canonical2
+  };
+}
+function omitKey(obj, key) {
+  const clone = { ...obj };
+  delete clone[key];
+  return clone;
+}
+function buildArchivedManifest(manifest, plan, updatedAt) {
+  let next = { ...manifest, workspace: { ...manifest.workspace, updated_at: updatedAt } };
+  next = plan.reposEmptied ? omitKey(next, "repos") : { ...next, repos: plan.nextRepos };
+  if (plan.nextSourceRoots !== void 0) {
+    if (plan.nextSourceRoots.length === 0) {
+      const prunedImport = manifest.import !== void 0 ? omitKey(manifest.import, "source_roots") : {};
+      next = Object.keys(prunedImport).length === 0 ? omitKey(next, "import") : { ...next, import: prunedImport };
+    } else {
+      next = {
+        ...next,
+        import: { ...manifest.import ?? {}, source_roots: plan.nextSourceRoots }
+      };
+    }
+  }
+  return next;
+}
+async function doRunProjectArchive(target, options, ctx) {
   const cwd = ctx.cwd ?? process.cwd();
-  const repositoryRoot = await resolveBasouRootForCommand(cwd, "orient");
-  const paths = basouPaths7(repositoryRoot);
-  await assertWorkspaceInitialized6(paths.root);
-  const nowIso = (ctx.nowProvider?.() ?? /* @__PURE__ */ new Date()).toISOString();
-  const probeCtx = { cwd: repositoryRoot };
-  if (ctx.claudeProjectsDir !== void 0) probeCtx.claudeProjectsDir = ctx.claudeProjectsDir;
-  if (ctx.codexSessionsDir !== void 0) probeCtx.codexSessionsDir = ctx.codexSessionsDir;
-  const staleness = await probeStaleness({ ctx: probeCtx, paths, nowIso });
-  const result = await renderOrientation2({
-    paths,
-    nowIso,
-    staleness,
-    verbose: options.verbose === true,
-    onWarning: (w, sid) => printReplayWarning(w, sid),
-    onSessionSkip: (sid, reason) => printSessionSkip(sid, reason),
-    onTaskSkip: (taskId, reason) => printTaskSkip(taskId, reason)
+  const repositoryRoot = await resolveBasouRootForCommand(cwd, "project archive");
+  const paths = basouPaths9(repositoryRoot);
+  const manifest = await readManifest5(paths);
+  const roster = manifest.repos ?? [];
+  let targetIsAnchor = false;
+  try {
+    targetIsAnchor = realpathSync(resolve3(repositoryRoot, target)) === realpathSync(repositoryRoot);
+  } catch {
+    targetIsAnchor = false;
+  }
+  const plan = planArchive({
+    ...manifest.repos !== void 0 ? { repos: manifest.repos } : {},
+    ...manifest.import?.source_roots !== void 0 ? { sourceRoots: manifest.import.source_roots } : {},
+    target,
+    targetIsAnchor
   });
-  await writeMarkdownFile4(paths.files.orientation, `${result.body}
-`);
-  if (options.quiet === true) {
-    console.log(
-      `Generated .basou/orientation.md (sessions: ${result.sessionCount}, in-flight tasks: ${result.inFlightTaskCount}, pending approvals: ${result.pendingApprovalsCount}, suspect: ${result.suspectCount})`
+  const teardown = plan.found && !plan.isAnchor ? gatherArchiveTeardown(repositoryRoot, manifest, target) : {
+    inspected: false,
+    viewLink: false,
+    instructionFiles: [],
+    gitignorePatterns: [],
+    canonical: false
+  };
+  const applied = options.apply === true && plan.found && !plan.isAnchor;
+  if (applied) {
+    const now = ctx.now ?? (() => /* @__PURE__ */ new Date());
+    await writeManifest2(paths, buildArchivedManifest(manifest, plan, now().toISOString()), {
+      force: true
+    });
+  }
+  const result = {
+    ...plan,
+    hasRoster: roster.length > 0,
+    applied,
+    teardown,
+    preservedUnknownFields: unknownManifestKeys(manifest)
+  };
+  if (options.json === true) {
+    console.log(JSON.stringify(result));
+  } else {
+    console.log(renderProjectArchive(result));
+  }
+  return result;
+}
+function renderProjectArchive(result) {
+  const lines = [];
+  lines.push("# repo \u306E archive(roster \u304B\u3089\u7573\u3080)");
+  lines.push("");
+  lines.push(...preservedUnknownLines(result.preservedUnknownFields));
+  if (!result.hasRoster) {
+    lines.push("\u2139\uFE0F repo \u30ED\u30FC\u30B9\u30BF\u30FC\u304C\u672A\u5BA3\u8A00\u3067\u3059(manifest \u306E `repos`)\u3002archive \u5BFE\u8C61\u304C\u3042\u308A\u307E\u305B\u3093\u3002");
+    return lines.join("\n");
+  }
+  if (result.isAnchor) {
+    lines.push(
+      `\u26A0\uFE0F \`${result.target}\` \u306F anchor(\u30D7\u30ED\u30B8\u30A7\u30AF\u30C8\u306E root)\u3067\u3059\u3002anchor \u306F archive \u3067\u304D\u307E\u305B\u3093(manifest \u306E\u5BB6\u306E\u305F\u3081)\u3002`
     );
+    return lines.join("\n");
+  }
+  if (!result.found) {
+    lines.push(`\u2139\uFE0F \`${result.target}\` \u306F roster \u306B\u5BA3\u8A00\u3055\u308C\u3066\u3044\u307E\u305B\u3093(archive \u5BFE\u8C61\u306A\u3057)\u3002`);
+    return lines.join("\n");
+  }
+  if (result.applied) {
+    lines.push(`\u2705 \`${result.target}\` \u3092 roster \u304B\u3089\u524A\u9664\u3057\u307E\u3057\u305F\u3002`);
   } else {
-    console.log(result.body);
+    lines.push(`\`${result.target}\` \u3092 roster \u304B\u3089\u524A\u9664\u4E88\u5B9A(dry-run\u3001\u53CD\u6620\u3059\u308B\u306B\u306F --apply):`);
+  }
+  if (result.sourceRootRemoval !== void 0) {
+    lines.push(
+      `- source_roots \u304B\u3089 ${result.sourceRootRemoval} \u3092 prune${result.applied ? "\u3057\u307E\u3057\u305F" : "\u3057\u307E\u3059"}(\u4EE5\u5F8C refresh \u306E\u5BFE\u8C61\u5916)\u3002`
+    );
+  } else {
+    lines.push("- source_roots \u306B\u8A72\u5F53\u30A8\u30F3\u30C8\u30EA\u306F\u3042\u308A\u307E\u305B\u3093(prune \u4E0D\u8981)\u3002");
+  }
+  if (result.reposEmptied) {
+    lines.push(
+      "- \u3053\u308C\u304C\u6700\u5F8C\u306E\u30E1\u30F3\u30D0\u30FC\u3067\u3059 \u2192 roster \u306F\u7A7A\u306B\u306A\u308A `repos` \u5BA3\u8A00\u306F\u9664\u53BB\u3055\u308C\u307E\u3059(\u30D7\u30ED\u30B8\u30A7\u30AF\u30C8\u3092\u7573\u3080)\u3002"
+    );
+  } else if (result.becomesSolo) {
+    lines.push(
+      "- \u6B8B\u308A 1 repo(solo)\u306B\u306A\u308A\u307E\u3059 \u2192 workspace view \u306F\u4E0D\u8981\u3067\u3059(view \u5BA3\u8A00/\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA\u306E\u64A4\u53BB\u3092\u691C\u8A0E)\u3002"
+    );
+  }
+  lines.push("");
+  const t = result.teardown;
+  const items = [];
+  if (t.viewLink) items.push("workspace view \u306E symlink \u30A8\u30F3\u30C8\u30EA");
+  if (t.instructionFiles.length > 0) items.push(`\u6307\u793A\u66F8(${t.instructionFiles.join(", ")})`);
+  if (t.gitignorePatterns.length > 0)
+    items.push(`.gitignore \u306E\u6307\u793A\u66F8\u30D1\u30BF\u30FC\u30F3(${t.gitignorePatterns.join(", ")})`);
+  if (t.canonical) items.push(`anchor \u306E canonical(agents/${basename3(result.target)}/AGENTS.md)`);
+  if (!t.inspected) {
+    lines.push("## \u624B\u52D5 teardown(repo \u304C\u30C7\u30A3\u30B9\u30AF\u4E0A\u306B\u89E3\u6C7A\u3067\u304D\u306A\u3044\u305F\u3081\u672A\u691C\u67FB)");
+    lines.push(
+      "- repo \u306F\u65E2\u306B\u524A\u9664\u6E08\u307F\u306E\u53EF\u80FD\u6027\u304C\u3042\u308A\u307E\u3059\u3002view symlink / \u6307\u793A\u66F8 symlink / .gitignore / canonical \u304C\u6B8B\u3063\u3066\u3044\u306A\u3044\u304B\u624B\u52D5\u3067\u78BA\u8A8D\u3057\u3066\u304F\u3060\u3055\u3044\u3002"
+    );
+    lines.push("");
+  } else if (items.length > 0) {
+    lines.push("## \u624B\u52D5 teardown(--apply \u306F\u89E6\u308C\u307E\u305B\u3093\u3002\u6B8B\u3063\u3066\u3044\u308B wiring \u3092\u624B\u3067\u64A4\u53BB\u3057\u3066\u304F\u3060\u3055\u3044)");
+    for (const i of items) lines.push(`- ${i}`);
+    lines.push("");
+  } else {
+    lines.push("repo \u5074\u306E wiring(view/\u6307\u793A\u66F8/.gitignore/canonical)\u306F\u6B8B\u3063\u3066\u3044\u307E\u305B\u3093\u3002");
+    lines.push("");
   }
+  lines.push(
+    "\u6CE8: archive \u306F manifest(.basou\u3001git \u8FFD\u8DE1=\u53EF\u9006)\u306E\u307F\u3092\u5909\u66F4\u3057\u307E\u3059\u3002repo\u30FB\u6355\u6349\u5C65\u6B74\u30FBon-disk \u306E wiring \u306F\u524A\u9664\u3057\u307E\u305B\u3093\u3002"
+  );
+  return lines.join("\n");
 }
-async function assertWorkspaceInitialized6(basouRoot) {
+async function runProjectRename(oldPath, newPath, options, ctx = {}) {
   try {
-    await assertBasouRootSafe7(basouRoot);
+    await doRunProjectRename(oldPath, newPath, options, ctx);
   } catch (error) {
-    if (findErrorCode6(error, "ENOENT")) {
-      throw new Error("Workspace not initialized. Run 'basou init' first.");
+    renderCliError(error, { verbose: isVerbose(options) });
+    process.exitCode = 1;
+  }
+}
+function gatherRenameWiring(repositoryRoot, manifest, oldBasename) {
+  let anchorReal;
+  try {
+    anchorReal = realpathSync(repositoryRoot);
+  } catch {
+    return { canonicalDirOld: false, viewLinkOld: false };
+  }
+  const canonicalDirOld = existsSync(join4(anchorReal, "agents", oldBasename));
+  let viewLinkOld = false;
+  const viewPath = manifest.workspace.view;
+  if (viewPath !== void 0) {
+    try {
+      lstatSync(join4(resolveViewDir(repositoryRoot, viewPath), oldBasename));
+      viewLinkOld = true;
+    } catch {
     }
-    throw error;
   }
+  return { canonicalDirOld, viewLinkOld };
+}
+function buildRenamedManifest(manifest, plan, updatedAt) {
+  const next = {
+    ...manifest,
+    workspace: { ...manifest.workspace, updated_at: updatedAt },
+    repos: plan.nextRepos
+  };
+  if (plan.nextSourceRoots !== void 0) {
+    return { ...next, import: { ...manifest.import ?? {}, source_roots: plan.nextSourceRoots } };
+  }
+  return next;
+}
+async function doRunProjectRename(oldPath, newPath, options, ctx) {
+  const cwd = ctx.cwd ?? process.cwd();
+  const repositoryRoot = await resolveBasouRootForCommand(cwd, "project rename");
+  const paths = basouPaths9(repositoryRoot);
+  const manifest = await readManifest5(paths);
+  const roster = manifest.repos ?? [];
+  let oldIsAnchor = false;
+  try {
+    oldIsAnchor = realpathSync(resolve3(repositoryRoot, oldPath)) === realpathSync(repositoryRoot);
+  } catch {
+    oldIsAnchor = false;
+  }
+  const plan = planRename({
+    ...manifest.repos !== void 0 ? { repos: manifest.repos } : {},
+    ...manifest.import?.source_roots !== void 0 ? { sourceRoots: manifest.import.source_roots } : {},
+    oldPath,
+    newPath,
+    oldIsAnchor
+  });
+  const actionable = plan.found && !plan.isAnchor && !plan.collision && !plan.noop;
+  const wiring = actionable && plan.basenameChanged ? gatherRenameWiring(repositoryRoot, manifest, pathBasename(plan.oldTarget)) : { canonicalDirOld: false, viewLinkOld: false };
+  const applied = options.apply === true && actionable;
+  if (applied) {
+    const now = ctx.now ?? (() => /* @__PURE__ */ new Date());
+    await writeManifest2(paths, buildRenamedManifest(manifest, plan, now().toISOString()), {
+      force: true
+    });
+  }
+  const result = {
+    ...plan,
+    hasRoster: roster.length > 0,
+    applied,
+    wiring,
+    preservedUnknownFields: unknownManifestKeys(manifest)
+  };
+  if (options.json === true) {
+    console.log(JSON.stringify(result));
+  } else {
+    console.log(renderProjectRename(result));
+  }
+  return result;
+}
+function renderProjectRename(result) {
+  const lines = [];
+  lines.push("# repo \u306E rename(roster \u306E\u30D1\u30B9\u66F4\u65B0)");
+  lines.push("");
+  lines.push(...preservedUnknownLines(result.preservedUnknownFields));
+  if (!result.hasRoster) {
+    lines.push("\u2139\uFE0F repo \u30ED\u30FC\u30B9\u30BF\u30FC\u304C\u672A\u5BA3\u8A00\u3067\u3059(manifest \u306E `repos`)\u3002rename \u5BFE\u8C61\u304C\u3042\u308A\u307E\u305B\u3093\u3002");
+    return lines.join("\n");
+  }
+  if (result.noop) {
+    lines.push(`\u2139\uFE0F \`${result.oldTarget}\` \u3068 \`${result.newTarget}\` \u306F\u540C\u4E00\u3067\u3059(\u5909\u66F4\u306A\u3057)\u3002`);
+    return lines.join("\n");
+  }
+  if (result.isAnchor) {
+    lines.push(
+      `\u26A0\uFE0F \`${result.oldTarget}\` \u306F anchor(\u30D7\u30ED\u30B8\u30A7\u30AF\u30C8\u306E root)\u3067\u3059\u3002anchor \u306F rename \u3067\u304D\u307E\u305B\u3093\u3002`
+    );
+    return lines.join("\n");
+  }
+  if (!result.found) {
+    lines.push(`\u2139\uFE0F \`${result.oldTarget}\` \u306F roster \u306B\u5BA3\u8A00\u3055\u308C\u3066\u3044\u307E\u305B\u3093(rename \u5BFE\u8C61\u306A\u3057)\u3002`);
+    return lines.join("\n");
+  }
+  if (result.collision) {
+    lines.push(
+      `\u26A0\uFE0F \`${result.newTarget}\` \u306F\u65E2\u306B roster \u306B\u5BA3\u8A00\u3055\u308C\u3066\u3044\u307E\u3059\u3002\u91CD\u8907\u3092\u907F\u3051\u308B\u305F\u3081 rename \u3057\u307E\u305B\u3093\u3002`
+    );
+    return lines.join("\n");
+  }
+  if (result.applied) {
+    lines.push(`\u2705 \`${result.oldTarget}\` \u3092 \`${result.newTarget}\` \u306B rename \u3057\u307E\u3057\u305F\u3002`);
+  } else {
+    lines.push(
+      `\`${result.oldTarget}\` \u3092 \`${result.newTarget}\` \u306B rename \u4E88\u5B9A(dry-run\u3001\u53CD\u6620\u3059\u308B\u306B\u306F --apply):`
+    );
+  }
+  if (result.sourceRootRenamed !== void 0) {
+    lines.push(
+      `- source_roots \u306E ${result.sourceRootRenamed} \u3092 ${result.newTarget} \u306B\u66F4\u65B0${result.applied ? "\u3057\u307E\u3057\u305F" : "\u3057\u307E\u3059"}\u3002`
+    );
+  } else {
+    lines.push("- source_roots \u306B\u8A72\u5F53\u30A8\u30F3\u30C8\u30EA\u306F\u3042\u308A\u307E\u305B\u3093(\u66F4\u65B0\u4E0D\u8981)\u3002");
+  }
+  lines.push("");
+  if (result.basenameChanged) {
+    const oldName = pathBasename(result.oldTarget);
+    const newName = pathBasename(result.newTarget);
+    const items = [];
+    if (result.wiring.canonicalDirOld)
+      items.push(`anchor canonical: agents/${oldName}/ \u2192 agents/${newName}/`);
+    if (result.wiring.viewLinkOld) items.push(`workspace view \u306E symlink: ${oldName} \u2192 ${newName}`);
+    if (items.length > 0) {
+      lines.push(
+        "## \u624B\u52D5\u30EA\u30CD\u30FC\u30E0(--apply \u306F\u89E6\u308C\u307E\u305B\u3093\u3002basename \u304C\u5909\u308F\u308B\u305F\u3081\u624B\u3067\u66F4\u65B0\u3057\u3066\u304F\u3060\u3055\u3044)"
+      );
+      for (const i of items) lines.push(`- ${i}`);
+    } else {
+      lines.push(
+        `basename \u304C ${oldName} \u2192 ${newName} \u306B\u5909\u308F\u308A\u307E\u3059\u304C\u3001anchor canonical / view symlink \u306F\u898B\u3064\u304B\u308A\u307E\u305B\u3093\u3067\u3057\u305F\u3002`
+      );
+    }
+    lines.push(
+      "  \u53CD\u6620\u5F8C\u306F `basou project symlinks` / `basou project workspace` \u3067\u6307\u793A\u66F8 symlink \u3068 view \u3092\u518D\u751F\u6210\u3057\u3066\u304F\u3060\u3055\u3044\u3002"
+    );
+  } else {
+    lines.push(
+      "\u6CE8: basename \u306F\u4E0D\u5909\u3067\u3059\u3002repo \u3092\u5225\u306E\u5834\u6240\u3078\u79FB\u52D5\u3057\u305F\u5834\u5408\u306F `basou project symlinks` / `basou project workspace` \u3067\u76F8\u5BFE\u30BF\u30FC\u30B2\u30C3\u30C8\u3092\u518D\u751F\u6210\u3057\u3066\u304F\u3060\u3055\u3044\u3002"
+    );
+  }
+  lines.push("");
+  lines.push(
+    "\u6CE8: rename \u306F manifest(.basou\u3001git \u8FFD\u8DE1=\u53EF\u9006)\u306E\u307F\u3092\u5909\u66F4\u3057\u307E\u3059\u3002repo \u306E\u79FB\u52D5\u30FBon-disk \u306E wiring \u66F4\u65B0\u306F\u884C\u3044\u307E\u305B\u3093\u3002"
+  );
+  return lines.join("\n");
 }
 // src/commands/refresh.ts
-import { assertBasouRootSafe as assertBasouRootSafe8, basouPaths as basouPaths8, findErrorCode as findErrorCode8 } from "@basou/core";
-import { InvalidArgumentError as InvalidArgumentError2 } from "commander";
+import { assertBasouRootSafe as assertBasouRootSafe9, basouPaths as basouPaths10, findErrorCode as findErrorCode9 } from "@basou/core";
+import { InvalidArgumentError as InvalidArgumentError3 } from "commander";
 // src/lib/portfolio-config.ts
 import { homedir as homedir3 } from "os";
-import { isAbsolute, join as join4, resolve as resolve3 } from "path";
+import { isAbsolute as isAbsolute2, join as join5, resolve as resolve4 } from "path";
 import { readYamlFile as readYamlFile3 } from "@basou/core";
-var DEFAULT_PORTFOLIO_CONFIG_PATH = join4(homedir3(), ".basou", "portfolio.yaml");
+var DEFAULT_PORTFOLIO_CONFIG_PATH = join5(homedir3(), ".basou", "portfolio.yaml");
 function expandTilde(p) {
   if (p === "~") return homedir3();
-  if (p.startsWith("~/")) return join4(homedir3(), p.slice(2));
+  if (p.startsWith("~/")) return join5(homedir3(), p.slice(2));
   return p;
 }
 function isRecord(value) {
@@ -2316,12 +4141,12 @@ async function loadPortfolioConfig(configPath = DEFAULT_PORTFOLIO_CONFIG_PATH) {
       throw new Error("A portfolio workspace 'label' must be a string when present.");
     }
     const expanded = expandTilde(entry.path.trim());
-    if (!isAbsolute(expanded)) {
+    if (!isAbsolute2(expanded)) {
       throw new Error(
         "Portfolio workspace paths must be absolute (or start with '~'); use --workspace for relative ad-hoc paths."
       );
     }
-    const abs = resolve3(expanded);
+    const abs = resolve4(expanded);
     if (seen.has(abs)) continue;
     seen.add(abs);
     result.push(entry.label !== void 0 ? { path: abs, label: entry.label } : { path: abs });
@@ -2335,15 +4160,15 @@ async function loadPortfolioConfig(configPath = DEFAULT_PORTFOLIO_CONFIG_PATH) {
 // src/commands/refresh-watch.ts
 import { readdir as readdir2, stat as stat2 } from "fs/promises";
 import { homedir as homedir4 } from "os";
-import { join as join5 } from "path";
-import { findErrorCode as findErrorCode7 } from "@basou/core";
+import { join as join6 } 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 ?? join5(homedir4(), ".codex", "sessions"),
-    ctx.claudeProjectsDir ?? join5(homedir4(), ".claude", "projects")
+    ctx.codexSessionsDir ?? join6(homedir4(), ".codex", "sessions"),
+    ctx.claudeProjectsDir ?? join6(homedir4(), ".claude", "projects")
   ];
 }
 async function scanSourceLogs(roots) {
@@ -2353,11 +4178,11 @@ async function scanSourceLogs(roots) {
     try {
       entries = await readdir2(dir, { withFileTypes: true });
     } catch (error) {
-      if (findErrorCode7(error, "ENOENT") || findErrorCode7(error, "ENOTDIR")) return;
+      if (findErrorCode8(error, "ENOENT") || findErrorCode8(error, "ENOTDIR")) return;
       throw new Error("Failed to read a source log directory", { cause: error });
     }
     for (const entry of entries) {
-      const full = join5(dir, entry.name);
+      const full = join6(dir, entry.name);
       if (entry.isDirectory()) {
         await walk(full);
       } else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
@@ -2365,7 +4190,7 @@ async function scanSourceLogs(roots) {
           const info = await stat2(full);
           out.set(full, { mtimeMs: info.mtimeMs, size: info.size });
         } catch (error) {
-          if (findErrorCode7(error, "ENOENT")) continue;
+          if (findErrorCode8(error, "ENOENT")) continue;
           throw new Error("Failed to stat a source log file", { cause: error });
         }
       }
@@ -2457,26 +4282,26 @@ function collectPath2(value, previous) {
 function parseInterval(value) {
   const seconds = Number(value);
   if (!Number.isInteger(seconds) || seconds < MIN_WATCH_INTERVAL_SEC || seconds > MAX_WATCH_INTERVAL_SEC) {
-    throw new InvalidArgumentError2(
+    throw new InvalidArgumentError3(
       `--interval must be an integer between ${MIN_WATCH_INTERVAL_SEC} and ${MAX_WATCH_INTERVAL_SEC} (seconds).`
     );
   }
   return seconds;
 }
 function abortableSleep(ms, signal) {
-  return new Promise((resolve7) => {
+  return new Promise((resolve8) => {
     if (signal.aborted) {
-      resolve7();
+      resolve8();
       return;
     }
     let timer;
     const onAbort = () => {
       clearTimeout(timer);
-      resolve7();
+      resolve8();
     };
     timer = setTimeout(() => {
       signal.removeEventListener("abort", onAbort);
-      resolve7();
+      resolve8();
     }, ms);
     signal.addEventListener("abort", onAbort, { once: true });
   });
@@ -2567,8 +4392,8 @@ async function doRunRefreshWatch(options, ctx) {
   if (options.force === true) throw new Error("--watch cannot be combined with --force.");
   const cwd = ctx.cwd ?? process.cwd();
   const repositoryRoot = await resolveBasouRootForCommand(cwd, "refresh");
-  const paths = basouPaths8(repositoryRoot);
-  await assertWorkspaceInitialized7(paths.root);
+  const paths = basouPaths10(repositoryRoot);
+  await assertWorkspaceInitialized8(paths.root);
   const intervalMs = (options.interval ?? DEFAULT_WATCH_INTERVAL_SEC) * 1e3;
   const controller = new AbortController();
   const onSignal = () => controller.abort();
@@ -2595,8 +4420,8 @@ async function doRunRefreshWatch(options, ctx) {
 async function computeRefresh(options, ctx) {
   const cwd = ctx.cwd ?? process.cwd();
   const repositoryRoot = await resolveBasouRootForCommand(cwd, "refresh");
-  const paths = basouPaths8(repositoryRoot);
-  await assertWorkspaceInitialized7(paths.root);
+  const paths = basouPaths10(repositoryRoot);
+  await assertWorkspaceInitialized8(paths.root);
   const nowIso = (ctx.nowProvider?.() ?? /* @__PURE__ */ new Date()).toISOString();
   return refreshAll({
     options: {
@@ -2644,7 +4469,14 @@ function printRefreshSummary(result) {
     console.log(`handoff: skipped (${result.handoff.reason})`);
   }
   if (result.decisions.status === "generated") {
-    console.log(`decisions: regenerated (${result.decisions.decisionCount})`);
+    if (result.decisions.decisionCount === 0) {
+      const hasSessions = result.handoff.status === "generated" && result.handoff.sessionCount > 0;
+      console.log(
+        hasSessions ? "decisions: 0 (none auto-recorded from these sessions; record any made with 'basou decision record')" : "decisions: 0"
+      );
+    } else {
+      console.log(`decisions: regenerated (${result.decisions.decisionCount})`);
+    }
   } else {
     console.log(`decisions: skipped (${result.decisions.reason})`);
   }
@@ -2656,11 +4488,11 @@ function printRefreshSummary(result) {
     console.log(`orientation: skipped (${result.orientation.reason})`);
   }
 }
-async function assertWorkspaceInitialized7(basouRoot) {
+async function assertWorkspaceInitialized8(basouRoot) {
   try {
-    await assertBasouRootSafe8(basouRoot);
+    await assertBasouRootSafe9(basouRoot);
   } catch (error) {
-    if (findErrorCode8(error, "ENOENT")) {
+    if (findErrorCode9(error, "ENOENT")) {
       throw new Error("Workspace not initialized. Run 'basou init' first.");
     }
     throw error;
@@ -2668,14 +4500,14 @@ async function assertWorkspaceInitialized7(basouRoot) {
 }
 // src/commands/report.ts
-import { isAbsolute as isAbsolute2, resolve as resolve4 } from "path";
+import { isAbsolute as isAbsolute3, resolve as resolve5 } from "path";
 import {
-  assertBasouRootSafe as assertBasouRootSafe9,
-  basouPaths as basouPaths9,
-  findErrorCode as findErrorCode9,
+  assertBasouRootSafe as assertBasouRootSafe10,
+  basouPaths as basouPaths11,
+  findErrorCode as findErrorCode10,
   renderReport,
   resolveRepositoryRoot as resolveRepositoryRoot8,
-  writeMarkdownFile as writeMarkdownFile5
+  writeMarkdownFile as writeMarkdownFile6
 } from "@basou/core";
 function registerReportCommand(program) {
   const report = program.command("report").description(
@@ -2696,8 +4528,8 @@ async function runReportGenerate(options, ctx = {}) {
 async function doRunReportGenerate(options, ctx) {
   const cwd = ctx.cwd ?? process.cwd();
   const repositoryRoot = await resolveRepositoryRootForReport(cwd);
-  const paths = basouPaths9(repositoryRoot);
-  await assertWorkspaceInitialized8(paths.root);
+  const paths = basouPaths11(repositoryRoot);
+  await assertWorkspaceInitialized9(paths.root);
   const nowIso = (ctx.nowProvider?.() ?? /* @__PURE__ */ new Date()).toISOString();
   const result = await renderReport({
     paths,
@@ -2708,8 +4540,8 @@ async function doRunReportGenerate(options, ctx) {
     onTaskSkip: (taskId, reason) => printTaskSkip(taskId, reason)
   });
   if (options.out !== void 0) {
-    const outPath = isAbsolute2(options.out) ? options.out : resolve4(cwd, options.out);
-    await writeMarkdownFile5(outPath, result.body);
+    const outPath = isAbsolute3(options.out) ? options.out : resolve5(cwd, options.out);
+    await writeMarkdownFile6(outPath, result.body);
     const { sessions, decisions, tasks } = result.data;
     console.error(
       `Wrote report to ${options.out} (sessions: ${sessions.total}, decisions: ${decisions.count}, tasks: ${tasks.total})`
@@ -2734,25 +4566,149 @@ async function resolveRepositoryRootForReport(cwd) {
     throw error;
   }
 }
-async function assertWorkspaceInitialized8(basouRoot) {
+async function assertWorkspaceInitialized9(basouRoot) {
   try {
-    await assertBasouRootSafe9(basouRoot);
+    await assertBasouRootSafe10(basouRoot);
   } catch (error) {
-    if (findErrorCode9(error, "ENOENT")) {
+    if (findErrorCode10(error, "ENOENT")) {
       throw new Error("Workspace not initialized. Run 'basou init' first.");
     }
     throw error;
   }
 }
+// src/commands/review-gaps.ts
+import {
+  basouPaths as basouPaths12,
+  findReviewGaps
+} from "@basou/core";
+import { InvalidArgumentError as InvalidArgumentError4 } from "commander";
+function collectRepo(value, previous) {
+  return [...previous, value];
+}
+function parseWindow(value) {
+  const hours = Number(value);
+  if (!Number.isInteger(hours) || hours <= 0) {
+    throw new InvalidArgumentError4("--window must be a positive integer (hours).");
+  }
+  return hours;
+}
+function registerReviewGapsCommand(program) {
+  program.command("review-gaps").description(
+    "Surface units of work committed without a bound cross-model review trail (read-only, advisory)"
+  ).option(
+    "--repo <name>",
+    "Restrict to a repo by name (repeatable; default: every repo with captured commits)",
+    collectRepo,
+    []
+  ).option(
+    "--window <hours>",
+    "Hours before a commit to look for a review (default 24)",
+    parseWindow
+  ).option("--json", "Output the result as JSON").option("-v, --verbose", "Show error causes").action(async (opts) => {
+    await runReviewGaps(opts);
+  });
+}
+async function runReviewGaps(options, ctx = {}) {
+  try {
+    await doRunReviewGaps(options, ctx);
+  } catch (error) {
+    renderCliError(error, { verbose: isVerbose(options) });
+    process.exitCode = 1;
+  }
+}
+async function doRunReviewGaps(options, ctx) {
+  const cwd = ctx.cwd ?? process.cwd();
+  const repositoryRoot = await resolveBasouRootForCommand(cwd, "review-gaps");
+  const paths = basouPaths12(repositoryRoot);
+  const nowIso = (ctx.nowProvider?.() ?? /* @__PURE__ */ new Date()).toISOString();
+  const summary = await findReviewGaps({
+    paths,
+    nowIso,
+    ...options.repo !== void 0 && options.repo.length > 0 ? { scope: options.repo } : {},
+    ...options.window !== void 0 ? { windowHours: options.window } : {},
+    onWarning: (w, sid) => printReplayWarning(w, sid),
+    onSessionSkip: (sid, reason) => printSessionSkip(sid, reason)
+  });
+  if (options.json === true) {
+    console.log(JSON.stringify(summary));
+  } else {
+    console.log(renderReviewGaps(summary));
+  }
+  return summary;
+}
+function relAge(iso, now) {
+  if (iso === null) return "(\u4E0D\u660E)";
+  const ms = now.getTime() - Date.parse(iso);
+  if (!Number.isFinite(ms) || ms < 0) return "\u305F\u3063\u305F\u4ECA";
+  const days = Math.floor(ms / 864e5);
+  if (days >= 1) return `${days}\u65E5\u524D`;
+  const hours = Math.floor(ms / 36e5);
+  if (hours >= 1) return `${hours}\u6642\u9593\u524D`;
+  return `${Math.max(1, Math.floor(ms / 6e4))}\u5206\u524D`;
+}
+function unitLine(u, now) {
+  const when = relAge(u.lastCommitAt, now);
+  const head = `- ${u.repo} ${when} (${u.commitCount} commit${u.commitCount === 1 ? "" : "s"})`;
+  if (u.verdict === "near_unbound") {
+    const ids = u.reviews.map((r) => r.sessionId.slice(0, 14)).join(", ");
+    return `${head} \u2014 \u8FD1\u63A5\u30EC\u30D3\u30E5\u30FC\u306F\u3042\u308B\u304C diff/\u5909\u66F4\u30D5\u30A1\u30A4\u30EB\u3092\u78BA\u8A8D\u3057\u3066\u3044\u306A\u3044 [${ids}]`;
+  }
+  return `${head} \u2014 \u7D10\u3065\u304F\u30AF\u30ED\u30B9\u30E2\u30C7\u30EB\u30EC\u30D3\u30E5\u30FC\u306A\u3057`;
+}
+function candidateLine(u, now) {
+  const when = relAge(u.lastCommitAt, now);
+  const cite = u.reviews.map((r) => `${r.sessionId.slice(0, 14)}${r.examinedDiff ? "(diff)" : ""}`).join(", ");
+  return `- ${u.repo} ${when} (${u.commitCount} commit${u.commitCount === 1 ? "" : "s"}) \u2014 \u30EC\u30D3\u30E5\u30FC\u5F62\u8DE1: ${cite}`;
+}
+function renderReviewGaps(summary) {
+  const now = new Date(summary.generatedAt);
+  const lines = [];
+  const scope = summary.scope ? summary.scope.join(", ") : "\u5168\u30EA\u30DD\u30B8\u30C8\u30EA";
+  lines.push(`# \u30EC\u30D3\u30E5\u30FC\u8A3C\u8DE1\u306E\u30AE\u30E3\u30C3\u30D7 (${scope})`);
+  lines.push("");
+  if (summary.gaps.length === 0) {
+    lines.push("\u2705 \u53D6\u308A\u8FBC\u307F\u6E08\u307F\u306E\u7BC4\u56F2\u3067\u306F\u3001\u30EC\u30D3\u30E5\u30FC\u8A3C\u8DE1\u306A\u3057\u3067\u7740\u5730\u3057\u305F\u4F5C\u696D\u5358\u4F4D\u306F\u3042\u308A\u307E\u305B\u3093\u3002");
+  } else {
+    lines.push(`\u26A0\uFE0F \u30EC\u30D3\u30E5\u30FC\u8A3C\u8DE1\u306A\u3057\u3067\u7740\u5730\u3057\u305F\u4F5C\u696D\u5358\u4F4D: ${summary.gaps.length}`);
+    for (const u of summary.gaps) lines.push(unitLine(u, now));
+  }
+  lines.push("");
+  if (summary.candidates.length > 0) {
+    lines.push(
+      `## \u78BA\u8A8D\u5F85\u3061 (${summary.candidates.length}) \u2014 \u30AF\u30ED\u30B9\u30E2\u30C7\u30EB\u304C\u30EC\u30D3\u30E5\u30FC\u3057\u305F\u5F62\u8DE1\u3042\u308A\u3002\u3053\u306E\u5909\u66F4\u3092\u672C\u5F53\u306B\u898B\u305F\u304B\u78BA\u8A8D\u3057\u3066\u304F\u3060\u3055\u3044`
+    );
+    for (const u of summary.candidates) lines.push(candidateLine(u, now));
+    lines.push("");
+  }
+  if (summary.unknowns.length > 0) {
+    const n = summary.unknowns.reduce((sum, u) => sum + u.commitCount, 0);
+    lines.push(
+      `## \u5C0E\u51FA\u4E0D\u53EF (${summary.unknowns.length} \u5358\u4F4D / ${n} commit) \u2014 repo \u304B\u6642\u523B\u3092\u6355\u6349\u304B\u3089\u5C0E\u3051\u305A\u3001\u5224\u5B9A\u3092\u4FDD\u7559(clear \u3067\u306F\u3042\u308A\u307E\u305B\u3093)`
+    );
+    lines.push("");
+  }
+  lines.push("## \u30EA\u30DD\u30B8\u30C8\u30EA\u5225");
+  for (const r of summary.repos) {
+    lines.push(
+      `- ${r.repo}: ${r.units} \u5358\u4F4D (\u8A3C\u8DE1\u306A\u3057 ${r.omissionUnits} / \u8FD1\u63A5\u306E\u307F ${r.nearUnboundUnits} / \u78BA\u8A8D\u5F85\u3061 ${r.candidateUnits}${r.unknownUnits > 0 ? ` / \u4E0D\u660E ${r.unknownUnits}` : ""})`
+    );
+  }
+  lines.push("");
+  lines.push(
+    `\u6CE8: read-only \u306E advisory \u3067\u3059\u3002\u53D6\u308A\u8FBC\u307F\u6E08\u307F\u306E commit \u306E\u307F\u304C\u5BFE\u8C61\uFF08\u6700\u65B0\u53D6\u8FBC commit: ${summary.newestCommitAt === null ? "\u306A\u3057" : relAge(summary.newestCommitAt, now)}\uFF09\u3002\u30EC\u30D3\u30E5\u30FC\u306E\u300C\u5B9F\u65BD\u300D\u306F\u81EA\u52D5\u5224\u5B9A\u305B\u305A\u3001\u6642\u9593\u7684\u8FD1\u63A5\u3060\u3051\u3067\u306F\u5408\u683C\u306B\u3057\u307E\u305B\u3093\u3002enforce \u306F\u3057\u307E\u305B\u3093\u3002`
+  );
+  return lines.join("\n");
+}
 // src/commands/run.ts
 import { mkdir as mkdir2 } from "fs/promises";
 import { homedir as homedir5 } from "os";
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 import {
-  acquireLock as acquireLock4,
-  assertBasouRootSafe as assertBasouRootSafe10,
-  basouPaths as basouPaths10,
+  acquireLock as acquireLock5,
+  assertBasouRootSafe as assertBasouRootSafe11,
+  basouPaths as basouPaths13,
   ChildProcessRunner as ChildProcessRunner2,
   claudeCodeAdapterMetadata,
   appendChainedEvent as coreAppendChainedEvent2,
@@ -2761,7 +4717,7 @@ import {
   getSnapshot as getSnapshot2,
   overwriteYamlFile as overwriteYamlFile2,
   prefixedUlid as prefixedUlid4,
-  readManifest as readManifest4,
+  readManifest as readManifest6,
   readYamlFile as readYamlFile4,
   resolveClaudeCodeCommand,
   resolveRepositoryRoot as resolveRepositoryRoot9,
@@ -2797,17 +4753,17 @@ async function runClaudeCode(args, options, ctx = {}) {
   const { command } = await resolveCommand();
   const cwd = options.cwd ?? process.cwd();
   const repoRoot = await resolveRepositoryRootForRun(cwd);
-  const paths = basouPaths10(repoRoot);
-  await assertBasouRootSafe10(paths.root);
-  const manifest = await readManifest4(paths);
+  const paths = basouPaths13(repoRoot);
+  await assertBasouRootSafe11(paths.root);
+  const manifest = await readManifest6(paths);
   const sessionId = prefixedUlid4("ses");
-  const sessionDir = join6(paths.sessions, sessionId);
+  const sessionDir = join7(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 = join6(sessionDir, "session.yaml");
+  const sessionYamlPath = join7(sessionDir, "session.yaml");
   const session = buildInitialSession2({
     id: sessionId,
     command,
@@ -2840,7 +4796,7 @@ async function runClaudeCode(args, options, ctx = {}) {
     from: "initialized",
     to: "running"
   });
-  const runningLock = await acquireLock4(paths, "session", sessionId);
+  const runningLock = await acquireLock5(paths, "session", sessionId);
   try {
     await mutateSessionYaml2(sessionYamlPath, (s) => {
       s.session.status = "running";
@@ -3150,29 +5106,28 @@ async function resolveRepositoryRootForRun(cwd) {
 // src/commands/session.ts
 import { readFile as readFile2 } from "fs/promises";
-import { basename as basename3, isAbsolute as isAbsolute3, join as join7, relative as relative2 } from "path";
+import { basename as basename4, isAbsolute as isAbsolute4, join as join8, relative as relative3 } from "path";
 import {
-  acquireLock as acquireLock5,
-  appendEventToExistingSession as appendEventToExistingSession2,
-  assertBasouRootSafe as assertBasouRootSafe11,
-  basouPaths as basouPaths11,
+  acquireLock as acquireLock6,
+  appendEventToExistingSession as appendEventToExistingSession3,
+  assertBasouRootSafe as assertBasouRootSafe12,
+  basouPaths as basouPaths14,
   enumerateSessionDirs as enumerateSessionDirs2,
-  findErrorCode as findErrorCode10,
+  findErrorCode as findErrorCode11,
   importSessionFromJson as importSessionFromJson2,
   loadSessionEntries,
   readAllEvents,
-  readManifest as readManifest5,
+  readManifest as readManifest7,
   readYamlFile as readYamlFile5,
   rechainSessionInPlace,
-  resolveRepositoryRoot as resolveRepositoryRoot10,
-  resolveSessionId as resolveSessionId2,
+  resolveSessionId as resolveSessionId3,
   resolveTaskId,
   SessionImportPayloadSchema as SessionImportPayloadSchema2,
   SessionSchema as SessionSchema3,
   SessionStatusSchema,
   sessionWorkStatsFromEvents
 } from "@basou/core";
-import { InvalidArgumentError as InvalidArgumentError3 } from "commander";
+import { InvalidArgumentError as InvalidArgumentError5 } from "commander";
 // src/lib/format-duration.ts
 import { formatDurationMs } from "@basou/core";
@@ -3221,8 +5176,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 = basouPaths11(repositoryRoot);
-  await assertWorkspaceInitialized9(paths.root);
+  const paths = basouPaths14(repositoryRoot);
+  await assertWorkspaceInitialized10(paths.root);
   const now = /* @__PURE__ */ new Date();
   const records = (await loadSessionEntries(paths, {
     now,
@@ -3273,17 +5228,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 = basouPaths11(repositoryRoot);
-  await assertWorkspaceInitialized9(paths.root);
-  const sessionId = await resolveSessionId2(paths, idInput);
-  const sessionDir = join7(paths.sessions, sessionId);
-  const sessionYamlPath = join7(sessionDir, "session.yaml");
+  const paths = basouPaths14(repositoryRoot);
+  await assertWorkspaceInitialized10(paths.root);
+  const sessionId = await resolveSessionId3(paths, idInput);
+  const sessionDir = join8(paths.sessions, sessionId);
+  const sessionYamlPath = join8(sessionDir, "session.yaml");
   let session;
   try {
     const raw = await readYamlFile5(sessionYamlPath);
     session = SessionSchema3.parse(raw);
   } catch (error) {
-    if (findErrorCode10(error, "ENOENT")) {
+    if (findErrorCode11(error, "ENOENT")) {
       throw new Error(`Session not found: ${idInput}`);
     }
     throw new Error("Failed to read session", { cause: error });
@@ -3398,12 +5353,12 @@ function formatSessionWork(session, events, now) {
 }
 function formatWorkingDir(workingDir, repositoryRoot, options) {
   if (options.fullPath === true) return workingDir;
-  if (!isAbsolute3(workingDir)) {
+  if (!isAbsolute4(workingDir)) {
     if (workingDir === ".") return "<repository_root>";
     return workingDir;
   }
   if (workingDir === repositoryRoot) return "<repository_root>";
-  const rel = relative2(repositoryRoot, workingDir);
+  const rel = relative3(repositoryRoot, workingDir);
   if (rel.length === 0 || rel === ".") return "<repository_root>";
   if (rel.startsWith("..")) return rel;
   return `./${rel}`;
@@ -3517,23 +5472,13 @@ function maxLen2(values, floor) {
   return max;
 }
 async function resolveRepositoryRootForSession(cwd, subcmd) {
-  try {
-    return await resolveRepositoryRoot10(cwd);
-  } catch (error) {
-    if (error instanceof Error && error.message === "Not a git repository") {
-      throw new Error(
-        `Not a git repository. Run 'git init' first, then re-run 'basou session ${subcmd}'.`,
-        { cause: error }
-      );
-    }
-    throw error;
-  }
+  return resolveBasouRootForCommand(cwd, `session ${subcmd}`);
 }
-async function assertWorkspaceInitialized9(basouRoot) {
+async function assertWorkspaceInitialized10(basouRoot) {
   try {
-    await assertBasouRootSafe11(basouRoot);
+    await assertBasouRootSafe12(basouRoot);
   } catch (error) {
-    if (findErrorCode10(error, "ENOENT")) {
+    if (findErrorCode11(error, "ENOENT")) {
       throw new Error("Workspace not initialized. Run 'basou init' first.");
     }
     throw error;
@@ -3571,9 +5516,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 = basouPaths11(repositoryRoot);
-  await assertWorkspaceInitialized9(paths.root);
-  const manifest = await readManifest5(paths);
+  const paths = basouPaths14(repositoryRoot);
+  await assertWorkspaceInitialized10(paths.root);
+  const manifest = await readManifest7(paths);
   const rawBody = await readInputFile(options.from);
   const json = parseJsonStrict(rawBody);
   const parsed = SessionImportPayloadSchema2.safeParse(json);
@@ -3602,10 +5547,10 @@ async function readInputFile(path) {
   try {
     return await readFile2(path, "utf8");
   } catch (error) {
-    if (findErrorCode10(error, "ENOENT")) {
+    if (findErrorCode11(error, "ENOENT")) {
       throw new Error("Import source not found", { cause: error });
     }
-    if (findErrorCode10(error, "EISDIR")) {
+    if (findErrorCode11(error, "EISDIR")) {
       throw new Error("Import source is not a file", { cause: error });
     }
     throw new Error("Failed to read import source", { cause: error });
@@ -3620,19 +5565,19 @@ function parseJsonStrict(body) {
 }
 function parseImportFormat(raw) {
   if (raw !== "json") {
-    throw new InvalidArgumentError3(`Unsupported format: ${raw}. Valid values: json`);
+    throw new InvalidArgumentError5(`Unsupported format: ${raw}. Valid values: json`);
   }
   return "json";
 }
 function parseLabelOverride(raw) {
   if (raw.length === 0) {
-    throw new InvalidArgumentError3("Label must not be empty");
+    throw new InvalidArgumentError5("Label must not be empty");
   }
   return raw;
 }
 function parseTaskIdOverride(raw) {
   if (raw.length === 0) {
-    throw new InvalidArgumentError3("Task id is empty");
+    throw new InvalidArgumentError5("Task id is empty");
   }
   return raw;
 }
@@ -3658,7 +5603,7 @@ function printSessionImportResult(options, result) {
     return;
   }
   console.log(
-    `Imported session ${sid} (${result.eventCount} events) from ${basename3(options.from)}`
+    `Imported session ${sid} (${result.eventCount} events) from ${basename4(options.from)}`
   );
 }
 var NOTE_BODY_PREVIEW_LIMIT = 80;
@@ -3685,19 +5630,19 @@ async function doRunSessionNote(sessionIdInput, options, ctx) {
   }
   const cwd = ctx.cwd ?? process.cwd();
   const repositoryRoot = await resolveRepositoryRootForSession(cwd, "note");
-  const paths = basouPaths11(repositoryRoot);
-  await assertWorkspaceInitialized9(paths.root);
-  const sessionId = await resolveSessionId2(paths, sessionIdInput);
+  const paths = basouPaths14(repositoryRoot);
+  await assertWorkspaceInitialized10(paths.root);
+  const sessionId = await resolveSessionId3(paths, sessionIdInput);
   const body = hasBody ? options.body : await readNoteFile(options.fromFile);
   if (body.length === 0) {
     throw new Error("Note body is empty");
   }
   const occurredAt = (/* @__PURE__ */ new Date()).toISOString();
   const sesId = sessionId;
-  const sessionLock = await acquireLock5(paths, "session", sesId);
+  const sessionLock = await acquireLock6(paths, "session", sesId);
   let result;
   try {
-    result = await appendEventToExistingSession2({
+    result = await appendEventToExistingSession3({
       paths,
       sessionId: sesId,
       eventBuilder: (eventId) => ({
@@ -3719,10 +5664,10 @@ async function readNoteFile(path) {
   try {
     return await readFile2(path, "utf8");
   } catch (error) {
-    if (findErrorCode10(error, "ENOENT")) {
+    if (findErrorCode11(error, "ENOENT")) {
       throw new Error("Note source not found", { cause: error });
     }
-    if (findErrorCode10(error, "EISDIR")) {
+    if (findErrorCode11(error, "EISDIR")) {
       throw new Error("Note source is not a file", { cause: error });
     }
     throw new Error("Failed to read note source", { cause: error });
@@ -3730,7 +5675,7 @@ async function readNoteFile(path) {
 }
 function parseNoteBodyOption(raw) {
   if (raw.length === 0) {
-    throw new InvalidArgumentError3("--body must not be empty");
+    throw new InvalidArgumentError5("--body must not be empty");
   }
   return raw;
 }
@@ -3767,9 +5712,9 @@ async function doRunSessionRechain(options, ctx) {
   }
   const cwd = ctx.cwd ?? process.cwd();
   const repositoryRoot = await resolveRepositoryRootForSession(cwd, "rechain");
-  const paths = basouPaths11(repositoryRoot);
-  await assertWorkspaceInitialized9(paths.root);
-  const sessionIds = options.session !== void 0 ? [await resolveSessionId2(paths, options.session)] : await enumerateSessionDirs2(paths);
+  const paths = basouPaths14(repositoryRoot);
+  await assertWorkspaceInitialized10(paths.root);
+  const sessionIds = options.session !== void 0 ? [await resolveSessionId3(paths, options.session)] : await enumerateSessionDirs2(paths);
   const dryRun = options.dryRun === true;
   const rows = [];
   for (const sessionId of sessionIds) {
@@ -3821,11 +5766,11 @@ function renderRechainRow(row, dryRun) {
 // src/commands/stats.ts
 import {
-  assertBasouRootSafe as assertBasouRootSafe12,
-  basouPaths as basouPaths12,
+  assertBasouRootSafe as assertBasouRootSafe13,
+  basouPaths as basouPaths15,
   computeWorkStats,
-  findErrorCode as findErrorCode11,
-  resolveRepositoryRoot as resolveRepositoryRoot11
+  findErrorCode as findErrorCode12,
+  resolveRepositoryRoot as resolveRepositoryRoot10
 } from "@basou/core";
 function registerStatsCommand(program) {
   program.command("stats").description("Report how much the AI worked (output volume + time proxies) across sessions").option("--by-source", "Break the totals down by session source kind").option("--by-day", "Break billable time and volume down by calendar day").option("--json", "Output the full stats as JSON").option("-v, --verbose", "Show error causes").action(async (options) => {
@@ -3843,8 +5788,8 @@ async function runStats(options, ctx = {}) {
 async function doRunStats(options, ctx) {
   const cwd = ctx.cwd ?? process.cwd();
   const repositoryRoot = await resolveRepositoryRootForStats(cwd);
-  const paths = basouPaths12(repositoryRoot);
-  await assertWorkspaceInitialized10(paths.root);
+  const paths = basouPaths15(repositoryRoot);
+  await assertWorkspaceInitialized11(paths.root);
   const now = ctx.nowProvider?.() ?? /* @__PURE__ */ new Date();
   const result = await computeWorkStats({
     paths,
@@ -3928,7 +5873,7 @@ function formatInt(n) {
 }
 async function resolveRepositoryRootForStats(cwd) {
   try {
-    return await resolveRepositoryRoot11(cwd);
+    return await resolveRepositoryRoot10(cwd);
   } catch (error) {
     if (error instanceof Error && error.message === "Not a git repository") {
       throw new Error("Not a git repository. Run 'git init' first, then re-run 'basou stats'.", {
@@ -3938,11 +5883,11 @@ async function resolveRepositoryRootForStats(cwd) {
     throw error;
   }
 }
-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;
@@ -3951,12 +5896,12 @@ async function assertWorkspaceInitialized10(basouRoot) {
 // src/commands/status.ts
 import {
-  assertBasouRootSafe as assertBasouRootSafe13,
-  basouPaths as basouPaths13,
+  assertBasouRootSafe as assertBasouRootSafe14,
+  basouPaths as basouPaths16,
   buildStatusSnapshot,
-  findErrorCode as findErrorCode12,
-  readManifest as readManifest6,
-  resolveRepositoryRoot as resolveRepositoryRoot12,
+  findErrorCode as findErrorCode13,
+  readManifest as readManifest8,
+  resolveRepositoryRoot as resolveRepositoryRoot11,
   writeStatus
 } from "@basou/core";
 function registerStatusCommand(program) {
@@ -3975,20 +5920,20 @@ async function runStatus(options, ctx = {}) {
 async function doRunStatus(options, ctx) {
   const cwd = ctx.cwd ?? process.cwd();
   const repositoryRoot = await resolveRepositoryRootForStatus(cwd);
-  const paths = basouPaths13(repositoryRoot);
+  const paths = basouPaths16(repositoryRoot);
   try {
-    await assertBasouRootSafe13(paths.root);
+    await assertBasouRootSafe14(paths.root);
   } catch (error) {
-    if (findErrorCode12(error, "ENOENT")) {
+    if (findErrorCode13(error, "ENOENT")) {
       throw new Error("Workspace not initialized. Run 'basou init' first.");
     }
     throw error;
   }
   let manifest;
   try {
-    manifest = await readManifest6(paths);
+    manifest = await readManifest8(paths);
   } catch (error) {
-    if (findErrorCode12(error, "ENOENT")) {
+    if (findErrorCode13(error, "ENOENT")) {
       throw new Error("Workspace not initialized. Run 'basou init' first.");
     }
     throw new Error("Failed to read workspace manifest", { cause: error });
@@ -4012,7 +5957,7 @@ function renderTextStatus(s) {
 }
 async function resolveRepositoryRootForStatus(cwd) {
   try {
-    return await resolveRepositoryRoot12(cwd);
+    return await resolveRepositoryRoot11(cwd);
   } catch (error) {
     if (error instanceof Error && error.message === "Not a git repository") {
       throw new Error("Not a git repository. Run 'git init' first, then re-run 'basou status'.", {
@@ -4025,34 +5970,34 @@ async function resolveRepositoryRootForStatus(cwd) {
 // src/commands/task.ts
 import { readFile as readFile3 } from "fs/promises";
-import { join as join8 } from "path";
+import { join as join9 } from "path";
 import {
   archiveTask,
-  assertBasouRootSafe as assertBasouRootSafe14,
-  basouPaths as basouPaths14,
+  assertBasouRootSafe as assertBasouRootSafe15,
+  basouPaths as basouPaths17,
   createTaskWithEvent,
   deleteTask,
   editTask,
   enumerateArchivedTaskIds,
-  findErrorCode as findErrorCode13,
+  findErrorCode as findErrorCode14,
   loadSessionEntries as loadSessionEntries2,
   loadTaskEntries,
   prefixedUlid as prefixedUlid5,
-  readManifest as readManifest7,
+  readManifest as readManifest9,
   readTaskFile,
   readTaskFileWithArchiveFallback,
   reconcileAllTasks,
   reconcileTask,
   refreshTaskLinkedSessions,
   replayEvents as replayEvents2,
-  resolveRepositoryRoot as resolveRepositoryRoot13,
-  resolveSessionId as resolveSessionId3,
+  resolveRepositoryRoot as resolveRepositoryRoot12,
+  resolveSessionId as resolveSessionId4,
   resolveTaskId as resolveTaskId2,
   TaskStatusSchema,
   TaskWriteAfterEventError,
   updateTaskStatusWithEvent
 } from "@basou/core";
-import { InvalidArgumentError as InvalidArgumentError4 } from "commander";
+import { InvalidArgumentError as InvalidArgumentError6 } from "commander";
 var STATUS_VALUES3 = TaskStatusSchema.options;
 function registerTaskCommand(program) {
   const task = program.command("task").description("Manage Basou tasks (purpose units that span sessions)");
@@ -4131,14 +6076,14 @@ async function doRunTaskNew(options, ctx) {
   }
   const cwd = ctx.cwd ?? process.cwd();
   const repositoryRoot = await resolveRepositoryRootForTask(cwd, "new");
-  const paths = basouPaths14(repositoryRoot);
-  await assertWorkspaceInitialized11(paths.root);
+  const paths = basouPaths17(repositoryRoot);
+  await assertWorkspaceInitialized12(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();
   const taskId = prefixedUlid5("task");
   if (options.session !== void 0) {
-    const sessionId = await resolveSessionId3(paths, options.session);
+    const sessionId = await resolveSessionId4(paths, options.session);
     const result2 = await createTaskWithEvent({
       mode: "attach",
       paths,
@@ -4166,7 +6111,7 @@ async function doRunTaskNew(options, ctx) {
     });
     return;
   }
-  const manifest = await readManifest7(paths);
+  const manifest = await readManifest9(paths);
   const result = await createTaskWithEvent({
     mode: "ad-hoc",
     paths,
@@ -4240,8 +6185,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 = basouPaths14(repositoryRoot);
-  await assertWorkspaceInitialized11(paths.root);
+  const paths = basouPaths17(repositoryRoot);
+  await assertWorkspaceInitialized12(paths.root);
   const entries = await loadTaskEntries(paths, {
     onSkip: (id, reason) => printTaskSkip(id, reason)
   });
@@ -4344,15 +6289,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 = basouPaths14(repositoryRoot);
-  await assertWorkspaceInitialized11(paths.root);
+  const paths = basouPaths17(repositoryRoot);
+  await assertWorkspaceInitialized12(paths.root);
   const taskId = await resolveTaskId2(paths, idInput, { includeArchived: true });
   const { doc, archived } = await readTaskFileWithArchiveFallback(paths, taskId);
   const sessions = await loadSessionEntries2(paths, { now: /* @__PURE__ */ new Date() });
   const events = [];
   const linkedSessionIds = new Set(doc.task.task.linked_sessions);
   for (const s of sessions) {
-    const sessionDir = join8(paths.sessions, s.sessionId);
+    const sessionDir = join9(paths.sessions, s.sessionId);
     try {
       for await (const ev of replayEvents2(sessionDir, {
         onWarning: (w) => printReplayWarning(w, s.sessionId)
@@ -4488,13 +6433,13 @@ 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 = basouPaths14(repositoryRoot);
-  await assertWorkspaceInitialized11(paths.root);
+  const paths = basouPaths17(repositoryRoot);
+  await assertWorkspaceInitialized12(paths.root);
   const taskId = await resolveTaskId2(paths, taskIdInput);
   const now = ctx.nowProvider !== void 0 ? ctx.nowProvider() : /* @__PURE__ */ new Date();
   const occurredAt = now.toISOString();
   if (options.session !== void 0) {
-    const sessionId = await resolveSessionId3(paths, options.session);
+    const sessionId = await resolveSessionId4(paths, options.session);
     const result2 = await updateTaskStatusWithEvent({
       mode: "attach",
       paths,
@@ -4514,7 +6459,7 @@ async function doRunTaskStatus(taskIdInput, newStatusInput, options, ctx) {
     });
     return;
   }
-  const manifest = await readManifest7(paths);
+  const manifest = await readManifest9(paths);
   const result = await updateTaskStatusWithEvent({
     mode: "ad-hoc",
     paths,
@@ -4565,9 +6510,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 = basouPaths14(repositoryRoot);
-  await assertWorkspaceInitialized11(paths.root);
-  const manifest = await readManifest7(paths);
+  const paths = basouPaths17(repositoryRoot);
+  await assertWorkspaceInitialized12(paths.root);
+  const manifest = await readManifest9(paths);
   const nowProvider = ctx.nowProvider ?? (() => /* @__PURE__ */ new Date());
   const write = options.write === true;
   const verbose = isVerbose(options);
@@ -4745,9 +6690,9 @@ async function doRunTaskRefreshLinkage(taskIdInput, options, ctx) {
   }
   const cwd = ctx.cwd ?? process.cwd();
   const repositoryRoot = await resolveRepositoryRootForTask(cwd, "refresh-linkage");
-  const paths = basouPaths14(repositoryRoot);
-  await assertWorkspaceInitialized11(paths.root);
-  const manifest = await readManifest7(paths);
+  const paths = basouPaths17(repositoryRoot);
+  await assertWorkspaceInitialized12(paths.root);
+  const manifest = await readManifest9(paths);
   const taskId = await resolveTaskId2(paths, taskIdInput);
   const nowProvider = ctx.nowProvider ?? (() => /* @__PURE__ */ new Date());
   const write = options.write === true;
@@ -4825,9 +6770,9 @@ async function doRunTaskEdit(taskIdInput, options, ctx) {
   }
   const cwd = ctx.cwd ?? process.cwd();
   const repositoryRoot = await resolveRepositoryRootForTask(cwd, "edit");
-  const paths = basouPaths14(repositoryRoot);
-  await assertWorkspaceInitialized11(paths.root);
-  const manifest = await readManifest7(paths);
+  const paths = basouPaths17(repositoryRoot);
+  await assertWorkspaceInitialized12(paths.root);
+  const manifest = await readManifest9(paths);
   const taskId = await resolveTaskId2(paths, taskIdInput);
   const now = ctx.nowProvider !== void 0 ? ctx.nowProvider() : /* @__PURE__ */ new Date();
   const occurredAt = now.toISOString();
@@ -4881,9 +6826,9 @@ async function doRunTaskDelete(taskIdInput, options, ctx) {
   }
   const cwd = ctx.cwd ?? process.cwd();
   const repositoryRoot = await resolveRepositoryRootForTask(cwd, "delete");
-  const paths = basouPaths14(repositoryRoot);
-  await assertWorkspaceInitialized11(paths.root);
-  const manifest = await readManifest7(paths);
+  const paths = basouPaths17(repositoryRoot);
+  await assertWorkspaceInitialized12(paths.root);
+  const manifest = await readManifest9(paths);
   const taskId = await resolveTaskId2(paths, taskIdInput);
   if (options.yes !== true) {
     await confirmDestructiveAction("delete", taskId);
@@ -4926,9 +6871,9 @@ async function doRunTaskArchive(taskIdInput, options, ctx) {
   }
   const cwd = ctx.cwd ?? process.cwd();
   const repositoryRoot = await resolveRepositoryRootForTask(cwd, "archive");
-  const paths = basouPaths14(repositoryRoot);
-  await assertWorkspaceInitialized11(paths.root);
-  const manifest = await readManifest7(paths);
+  const paths = basouPaths17(repositoryRoot);
+  await assertWorkspaceInitialized12(paths.root);
+  const manifest = await readManifest9(paths);
   const taskId = await resolveTaskId2(paths, taskIdInput);
   if (options.yes !== true) {
     await confirmDestructiveAction("archive", taskId);
@@ -4981,20 +6926,20 @@ async function readSingleLineFromStdin() {
 }
 function parseTitle2(raw) {
   if (raw.length === 0) {
-    throw new InvalidArgumentError4("Title must not be empty");
+    throw new InvalidArgumentError6("Title must not be empty");
   }
   return raw;
 }
 function parseLabel(raw) {
   if (raw.length === 0) {
-    throw new InvalidArgumentError4("Label must not be empty");
+    throw new InvalidArgumentError6("Label must not be empty");
   }
   return raw;
 }
 function parseInitialTaskStatus(raw) {
   const result = TaskStatusSchema.safeParse(raw);
   if (!result.success) {
-    throw new InvalidArgumentError4(
+    throw new InvalidArgumentError6(
       `Initial task status must be one of: ${STATUS_VALUES3.join(", ")}`
     );
   }
@@ -5003,7 +6948,7 @@ function parseInitialTaskStatus(raw) {
 var ISO_DATE_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/;
 function parseIsoTimestampOption(raw) {
   if (!ISO_DATE_RE.test(raw) || Number.isNaN(Date.parse(raw))) {
-    throw new InvalidArgumentError4(
+    throw new InvalidArgumentError6(
       "Invalid --completed-at value; expected ISO-8601 timestamp like 2026-05-10T12:34:56+09:00"
     );
   }
@@ -5012,7 +6957,7 @@ function parseIsoTimestampOption(raw) {
 function parseTaskStatusFilter(raw) {
   const result = TaskStatusSchema.safeParse(raw);
   if (!result.success) {
-    throw new InvalidArgumentError4(
+    throw new InvalidArgumentError6(
       `Invalid task status: ${raw}. Valid values: ${STATUS_VALUES3.join(", ")}`
     );
   }
@@ -5027,14 +6972,14 @@ function parseTaskStatusPositional(raw) {
 }
 function parseDescriptionOption(raw) {
   if (raw.length === 0) {
-    throw new InvalidArgumentError4("Description must not be empty");
+    throw new InvalidArgumentError6("Description must not be empty");
   }
   return raw;
 }
 function parsePositiveInt2(raw) {
   const n = Number.parseInt(raw, 10);
   if (!Number.isInteger(n) || n < 1 || raw.trim() !== String(n)) {
-    throw new InvalidArgumentError4(`Invalid number: ${raw}`);
+    throw new InvalidArgumentError6(`Invalid number: ${raw}`);
   }
   return n;
 }
@@ -5042,10 +6987,10 @@ async function readDescriptionFile(path) {
   try {
     return await readFile3(path, "utf8");
   } catch (error) {
-    if (findErrorCode13(error, "ENOENT")) {
+    if (findErrorCode14(error, "ENOENT")) {
       throw new Error("Description source not found", { cause: error });
     }
-    if (findErrorCode13(error, "EISDIR")) {
+    if (findErrorCode14(error, "EISDIR")) {
       throw new Error("Description source is not a file", { cause: error });
     }
     throw new Error("Failed to read description source", { cause: error });
@@ -5053,7 +6998,7 @@ async function readDescriptionFile(path) {
 }
 async function resolveRepositoryRootForTask(cwd, subcmd) {
   try {
-    return await resolveRepositoryRoot13(cwd);
+    return await resolveRepositoryRoot12(cwd);
   } catch (error) {
     if (error instanceof Error && error.message === "Not a git repository") {
       throw new Error(
@@ -5064,11 +7009,11 @@ async function resolveRepositoryRootForTask(cwd, subcmd) {
     throw error;
   }
 }
-async function assertWorkspaceInitialized11(basouRoot) {
+async function assertWorkspaceInitialized12(basouRoot) {
   try {
-    await assertBasouRootSafe14(basouRoot);
+    await assertBasouRootSafe15(basouRoot);
   } catch (error) {
-    if (findErrorCode13(error, "ENOENT")) {
+    if (findErrorCode14(error, "ENOENT")) {
       throw new Error("Workspace not initialized. Run 'basou init' first.");
     }
     throw error;
@@ -5156,12 +7101,12 @@ function maxLen3(values, floor) {
 // src/commands/verify.ts
 import {
-  assertBasouRootSafe as assertBasouRootSafe15,
-  basouPaths as basouPaths15,
+  assertBasouRootSafe as assertBasouRootSafe16,
+  basouPaths as basouPaths18,
   enumerateSessionDirs as enumerateSessionDirs3,
-  findErrorCode as findErrorCode14,
-  resolveRepositoryRoot as resolveRepositoryRoot14,
-  resolveSessionId as resolveSessionId4,
+  findErrorCode as findErrorCode15,
+  resolveRepositoryRoot as resolveRepositoryRoot13,
+  resolveSessionId as resolveSessionId5,
   verifyEventsChain
 } from "@basou/core";
 function registerVerifyCommand(program) {
@@ -5183,9 +7128,9 @@ async function doRunVerify(options, ctx) {
   }
   const cwd = ctx.cwd ?? process.cwd();
   const repositoryRoot = await resolveRepositoryRootForVerify(cwd);
-  const paths = basouPaths15(repositoryRoot);
-  await assertWorkspaceInitialized12(paths.root);
-  const sessionIds = options.session !== void 0 ? [await resolveSessionId4(paths, options.session)] : await enumerateSessionDirs3(paths);
+  const paths = basouPaths18(repositoryRoot);
+  await assertWorkspaceInitialized13(paths.root);
+  const sessionIds = options.session !== void 0 ? [await resolveSessionId5(paths, options.session)] : await enumerateSessionDirs3(paths);
   const rows = [];
   for (const sessionId of sessionIds) {
     const verdict = await verifyEventsChain(paths, sessionId);
@@ -5231,7 +7176,7 @@ function renderVerdict(row) {
 }
 async function resolveRepositoryRootForVerify(cwd) {
   try {
-    return await resolveRepositoryRoot14(cwd);
+    return await resolveRepositoryRoot13(cwd);
   } catch (error) {
     if (error instanceof Error && error.message === "Not a git repository") {
       throw new Error("Not a git repository. Run 'git init' first, then re-run 'basou verify'.", {
@@ -5241,11 +7186,11 @@ async function resolveRepositoryRootForVerify(cwd) {
     throw error;
   }
 }
-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;
@@ -5255,22 +7200,22 @@ async function assertWorkspaceInitialized12(basouRoot) {
 // src/commands/view.ts
 import { spawn } from "child_process";
 import { createHash } from "crypto";
-import { basename as basename4, resolve as resolve6 } from "path";
+import { basename as basename5, resolve as resolve7 } from "path";
 import {
-  assertBasouRootSafe as assertBasouRootSafe16,
-  basouPaths as basouPaths16,
-  findErrorCode as findErrorCode16,
-  readManifest as readManifest10,
-  resolveRepositoryRoot as resolveRepositoryRoot15
+  assertBasouRootSafe as assertBasouRootSafe17,
+  basouPaths as basouPaths19,
+  findErrorCode as findErrorCode17,
+  readManifest as readManifest12,
+  resolveRepositoryRoot as resolveRepositoryRoot14
 } from "@basou/core";
-import { InvalidArgumentError as InvalidArgumentError5 } from "commander";
+import { InvalidArgumentError as InvalidArgumentError7 } from "commander";
 // src/lib/portfolio-safety.ts
 import { execFile } from "child_process";
 import { lstat, realpath } from "fs/promises";
-import { isAbsolute as isAbsolute4, join as join9, relative as relative3, resolve as resolve5 } from "path";
+import { isAbsolute as isAbsolute5, join as join10, relative as relative4, resolve as resolve6 } from "path";
 import { promisify } from "util";
-import { readManifest as readManifest8 } from "@basou/core";
+import { readManifest as readManifest10 } from "@basou/core";
 var execFileAsync = promisify(execFile);
 function errorCode(error) {
   return error instanceof Error ? error.code : void 0;
@@ -5279,12 +7224,12 @@ async function canonical(p) {
   try {
     return await realpath(p);
   } catch {
-    return resolve5(p);
+    return resolve6(p);
   }
 }
 function isInside(child, parent) {
-  const rel = relative3(parent, child);
-  return rel === "" || !rel.startsWith("..") && !isAbsolute4(rel);
+  const rel = relative4(parent, child);
+  return rel === "" || !rel.startsWith("..") && !isAbsolute5(rel);
 }
 function isBasouPath(p) {
   return p === ".basou" || p.startsWith(".basou/") || p.includes("/.basou/") || p.endsWith("/.basou");
@@ -5292,7 +7237,7 @@ function isBasouPath(p) {
 async function inspectRepo(repoPath) {
   let hasEntry = false;
   try {
-    await lstat(join9(repoPath, ".basou"));
+    await lstat(join10(repoPath, ".basou"));
     hasEntry = true;
   } catch (error) {
     if (errorCode(error) !== "ENOENT") {
@@ -5323,7 +7268,7 @@ async function checkPortfolioSafety(workspaces) {
     const wsReal = await canonical(ws.repoRoot);
     let sourceRoots = [];
     try {
-      const manifest = await readManifest8(ws.paths);
+      const manifest = await readManifest10(ws.paths);
       sourceRoots = manifest.import?.source_roots ?? [];
     } catch (error) {
       if (error instanceof Error && error.message === "YAML file not found") {
@@ -5341,7 +7286,7 @@ async function checkPortfolioSafety(workspaces) {
     }
     const monitored = /* @__PURE__ */ new Map();
     for (const root of sourceRoots) {
-      const display = resolve5(ws.repoRoot, root);
+      const display = resolve6(ws.repoRoot, root);
       const real = await canonical(display);
       if (real !== wsReal) monitored.set(real, display);
     }
@@ -5393,18 +7338,18 @@ function formatSafetyReport(result) {
 // src/lib/view-server.ts
 import { createServer } from "http";
-import { join as join10 } from "path";
+import { join as join11 } from "path";
 import {
   computeWorkStats as computeWorkStats2,
   enumerateApprovals as enumerateApprovals2,
-  findErrorCode as findErrorCode15,
+  findErrorCode as findErrorCode16,
   isLazyExpired as isLazyExpired2,
   loadApproval as loadApproval2,
   loadSessionEntries as loadSessionEntries3,
   loadTaskEntries as loadTaskEntries2,
   readAllEvents as readAllEvents2,
-  readManifest as readManifest9,
-  readMarkdownFile as readMarkdownFile4,
+  readManifest as readManifest11,
+  readMarkdownFile as readMarkdownFile5,
   readSessionYaml as readSessionYaml3,
   readTaskFile as readTaskFile2,
   renderDecisions as renderDecisions3,
@@ -5591,7 +7536,9 @@ var VIEW_HTML = `<!doctype html>
     if (!data) return 'ok';
     if (data.claudeCode || data.codex) {
       return 'claude-code ' + imp(data.claudeCode) + ', codex ' + imp(data.codex)
-        + (data.handoff && data.handoff.status === 'generated' ? '; handoff+decisions regenerated' : '');
+        + (data.handoff && data.handoff.status === 'generated'
+           ? '; handoff regenerated, decisions: ' + (data.decisions ? data.decisions.decisionCount : 0)
+           : '');
     }
     if (data.status === 'ran') return imp(data);
     if (data.status === 'skipped') return 'skipped (' + data.reason + ')';
@@ -6048,7 +7995,7 @@ function startViewServer(opts) {
   };
   let boundPort = port;
   const getPort = () => boundPort;
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve8, reject) => {
     const server = createServer((req, res) => {
       handleRequest(req, res, deps, getPort, runExclusive).catch((error) => {
         sendError(res, error instanceof HttpError ? error.status : 500, pathlessMessage(error));
@@ -6059,7 +8006,7 @@ function startViewServer(opts) {
       const address = server.address();
       boundPort = isAddressInfo(address) ? address.port : port;
       server.off("error", reject);
-      resolve7({
+      resolve8({
         url: `http://${host}:${boundPort}`,
         port: boundPort,
         close: () => closeServer(server)
@@ -6071,8 +8018,8 @@ function isAddressInfo(value) {
   return value !== null && typeof value === "object";
 }
 function closeServer(server) {
-  return new Promise((resolve7) => {
-    server.close(() => resolve7());
+  return new Promise((resolve8) => {
+    server.close(() => resolve8());
     server.closeAllConnections();
   });
 }
@@ -6289,9 +8236,9 @@ async function captureStaleness(ws, nowIso) {
 async function overview(ws, nowProvider) {
   let manifest;
   try {
-    manifest = await readManifest9(ws.paths);
+    manifest = await readManifest11(ws.paths);
   } catch (error) {
-    if (findErrorCode15(error, "ENOENT")) {
+    if (findErrorCode16(error, "ENOENT")) {
       return { initialized: false, repoRoot: ws.repoRoot };
     }
     throw error;
@@ -6346,7 +8293,7 @@ async function sessionDetail(ws, sessionId) {
     throw error;
   }
   try {
-    const events = await readAllEvents2(join10(ws.paths.sessions, sessionId));
+    const events = await readAllEvents2(join11(ws.paths.sessions, sessionId));
     return { session, events };
   } catch {
     return { session, events: [], degraded: true };
@@ -6368,7 +8315,7 @@ async function taskDetail(ws, taskId) {
   }
 }
 async function decisionsView(ws, nowProvider) {
-  const fromDisk = await readMarkdownFile4(ws.paths.files.decisions);
+  const fromDisk = await readMarkdownFile5(ws.paths.files.decisions);
   if (fromDisk !== null) {
     return { body: fromDisk, fromDisk: true };
   }
@@ -6391,7 +8338,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 readMarkdownFile4(ws.paths.files.handoff);
+  const fromDisk = await readMarkdownFile5(ws.paths.files.handoff);
   if (fromDisk !== null) {
     return { body: fromDisk, fromDisk: true };
   }
@@ -6486,7 +8433,7 @@ var DEFAULT_PORT = 4319;
 function parsePort(value) {
   const port = Number.parseInt(value, 10);
   if (!Number.isInteger(port) || port < 1 || port > 65535) {
-    throw new InvalidArgumentError5("Port must be an integer between 1 and 65535.");
+    throw new InvalidArgumentError7("Port must be an integer between 1 and 65535.");
   }
   return port;
 }
@@ -6560,18 +8507,18 @@ async function doRunView(options, ctx) {
 }
 async function buildSingleDeps(ctx, cwd) {
   const repositoryRoot = await resolveRepositoryRootForView(cwd);
-  const paths = basouPaths16(repositoryRoot);
-  await assertWorkspaceInitialized13(paths.root);
+  const paths = basouPaths19(repositoryRoot);
+  await assertWorkspaceInitialized14(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: resolve6(cwd, p) })) : await loadPortfolioConfig(ctx.portfolioConfigPath);
+  const specs = workspaceFlags.length > 0 ? workspaceFlags.map((p) => ({ path: resolve7(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 = resolve6(spec.path);
+    const repoRoot = resolve7(spec.path);
     if (seenPath.has(repoRoot)) continue;
     seenPath.add(repoRoot);
     const entry = await buildWorkspaceEntry(repoRoot, ctx, spec.label);
@@ -6584,14 +8531,14 @@ async function buildPortfolioDeps(workspaceFlags, ctx, cwd) {
   return { workspaces: entries, mode: "portfolio", nowProvider: nowProviderOf(ctx) };
 }
 async function buildWorkspaceEntry(repoRoot, ctx, labelOverride) {
-  const paths = basouPaths16(repoRoot);
+  const paths = basouPaths19(repoRoot);
   const importCtx = {
     cwd: repoRoot,
     ...ctx.claudeProjectsDir !== void 0 ? { claudeProjectsDir: ctx.claudeProjectsDir } : {},
     ...ctx.codexSessionsDir !== void 0 ? { codexSessionsDir: ctx.codexSessionsDir } : {}
   };
   try {
-    const manifest = await readManifest10(paths);
+    const manifest = await readManifest12(paths);
     return {
       key: manifest.workspace.id,
       label: labelOverride ?? manifest.workspace.name,
@@ -6604,7 +8551,7 @@ async function buildWorkspaceEntry(repoRoot, ctx, labelOverride) {
     const notFound = error instanceof Error && error.message === "YAML file not found";
     return {
       key: `ws-${createHash("sha1").update(repoRoot).digest("hex").slice(0, 12)}`,
-      label: labelOverride ?? basename4(repoRoot),
+      label: labelOverride ?? basename5(repoRoot),
       paths,
       repoRoot,
       importCtx,
@@ -6620,7 +8567,7 @@ async function startListening(port, deps) {
   try {
     return await startViewServer({ port, deps });
   } catch (error) {
-    if (findErrorCode16(error, "EADDRINUSE")) {
+    if (findErrorCode17(error, "EADDRINUSE")) {
       throw new Error(`Port ${port} is already in use. Pass --port <n> to choose another.`, {
         cause: error
       });
@@ -6643,7 +8590,7 @@ function openInBrowser(url, override) {
   }
 }
 function waitForShutdown(signal) {
-  return new Promise((resolve7) => {
+  return new Promise((resolve8) => {
     const cleanup = () => {
       process.off("SIGINT", onSignal);
       process.off("SIGTERM", onSignal);
@@ -6651,18 +8598,18 @@ function waitForShutdown(signal) {
     };
     const onSignal = () => {
       cleanup();
-      resolve7();
+      resolve8();
     };
     const onAbort = () => {
       cleanup();
-      resolve7();
+      resolve8();
     };
     process.on("SIGINT", onSignal);
     process.on("SIGTERM", onSignal);
     if (signal !== void 0) {
       if (signal.aborted) {
         cleanup();
-        resolve7();
+        resolve8();
         return;
       }
       signal.addEventListener("abort", onAbort);
@@ -6671,7 +8618,7 @@ function waitForShutdown(signal) {
 }
 async function resolveRepositoryRootForView(cwd) {
   try {
-    return await resolveRepositoryRoot15(cwd);
+    return await resolveRepositoryRoot14(cwd);
   } catch (error) {
     if (error instanceof Error && error.message === "Not a git repository") {
       throw new Error("Not a git repository. Run 'git init' first, then re-run 'basou view'.", {
@@ -6681,11 +8628,11 @@ async function resolveRepositoryRootForView(cwd) {
     throw error;
   }
 }
-async function assertWorkspaceInitialized13(basouRoot) {
+async function assertWorkspaceInitialized14(basouRoot) {
   try {
-    await assertBasouRootSafe16(basouRoot);
+    await assertBasouRootSafe17(basouRoot);
   } catch (error) {
-    if (findErrorCode16(error, "ENOENT")) {
+    if (findErrorCode17(error, "ENOENT")) {
       throw new Error("Workspace not initialized. Run 'basou init' first.");
     }
     throw error;
@@ -6711,11 +8658,14 @@ function buildProgram() {
   registerViewCommand(program);
   registerApprovalCommand(program);
   registerDecisionCommand(program);
+  registerNoteCommand(program);
   registerTaskCommand(program);
   registerHandoffCommand(program);
   registerDecisionsCommand(program);
   registerReportCommand(program);
   registerOrientCommand(program);
+  registerReviewGapsCommand(program);
+  registerProjectCommand(program);
   return program;
 }
 export {