@basou/cli 0.11.0 → 0.13.0

package/dist/program.js

@@ -1512,7 +1512,8 @@ async function importDerivedSessions(paths, manifest, options, sourceKind, candi
     reimported: 0,
     skippedLegacy: 0,
     skippedDecreased: 0,
-    skippedDuplicate: 0
+    skippedDuplicate: 0,
+    skippedUnverifiable: 0
   };
   let sanitizedPaths = 0;
   const validate = (payload) => {
@@ -1554,7 +1555,7 @@ async function importDerivedSessions(paths, manifest, options, sourceKind, candi
       if (outcome.status === "skipped") {
         const detail = outcome.reason === "prior_events_unreadable" ? "prior events.jsonl has unreadable lines" : outcome.reason === "prior_chain_broken" ? "prior events.jsonl failed hash-chain verification (run 'basou verify')" : "source changed in a non-append way (derived events would be dropped)";
         console.error(`Import: ${externalId} ${detail}; re-import skipped`);
-        counts.skippedNoAction++;
+        counts.skippedUnverifiable++;
         continue;
       }
       counts.reimported++;
@@ -1825,7 +1826,8 @@ function printImportResult(options, results, counts) {
     reimported,
     skippedLegacy,
     skippedDecreased,
-    skippedDuplicate
+    skippedDuplicate,
+    skippedUnverifiable
   } = counts;
   if (options.json === true) {
     console.log(
@@ -1844,6 +1846,7 @@ function printImportResult(options, results, counts) {
         skipped_legacy_untracked: skippedLegacy,
         skipped_decreased: skippedDecreased,
         skipped_duplicate: skippedDuplicate,
+        skipped_unverifiable: skippedUnverifiable,
         event_total: eventTotal,
         dry_run: isDry
       })
@@ -1856,6 +1859,8 @@ function printImportResult(options, results, counts) {
   if (skippedLegacy > 0) skipParts.push(`${skippedLegacy} legacy (untracked size)`);
   if (skippedDecreased > 0) skipParts.push(`${skippedDecreased} shrank`);
   if (skippedDuplicate > 0) skipParts.push(`${skippedDuplicate} duplicated`);
+  if (skippedUnverifiable > 0)
+    skipParts.push(`${skippedUnverifiable} unverifiable (run 'basou verify')`);
   const skipSuffix = skipParts.length > 0 ? `; skipped ${skipParts.join(", ")}` : "";
   const eventsPart = replaced > 0 ? `${eventTotal} events, ${replaced} replaced` : `${eventTotal} events`;
   if (isDry) {
@@ -1935,6 +1940,9 @@ function registerInitCommand(program) {
     "Extra import source root, relative to the repo root (repeatable; aggregates sibling repos into this workspace)",
     collectValue,
     []
+  ).option(
+    "--local-only",
+    "Write a .basou/ full-exclude .gitignore block (keep the trail out of version control) instead of the default ignore+commit block"
   ).option("-f, --force", "Overwrite an existing manifest").option("-v, --verbose", "Show error causes").action(async (options) => {
     await runInit(options);
   });
@@ -1971,7 +1979,7 @@ async function doRunInit(options, ctx) {
   });
   await writeManifest(paths, manifest, { force: options.force === true });
   try {
-    await appendBasouGitignore(repositoryRoot);
+    await appendBasouGitignore(repositoryRoot, { localOnly: options.localOnly === true });
   } catch (error) {
     renderGitignoreWarning(error, isVerbose(options));
   }
@@ -2000,15 +2008,187 @@ async function resolveRepositoryRootForInit(cwd) {
   }
 }
 
-// src/commands/refresh.ts
-import { assertBasouRootSafe as assertBasouRootSafe7, basouPaths as basouPaths7, findErrorCode as findErrorCode7, resolveRepositoryRoot as resolveRepositoryRoot8 } from "@basou/core";
+// 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";
+
 // src/lib/provenance-actions.ts
 import {
   readMarkdownFile as readMarkdownFile3,
   renderDecisions as renderDecisions2,
   renderHandoff as renderHandoff2,
+  renderOrientation,
   renderWithMarkers as renderWithMarkers3,
   writeMarkdownFile as writeMarkdownFile3
 } from "@basou/core";
@@ -2059,6 +2239,7 @@ async function runImport(adapter, fn) {
       skippedNoAction: readCount(json.skipped_no_action),
       skippedAlreadyImported: readCount(json.skipped_already_imported),
       skippedLegacyUntracked: readCount(json.skipped_legacy_untracked),
+      skippedUnverifiable: readCount(json.skipped_unverifiable),
       eventTotal: readCount(json.event_total),
       dryRun: json.dry_run === true
     };
@@ -2105,40 +2286,1889 @@ async function regenerateDecisions(paths, nowIso, callbacks) {
     paths.files.decisions,
     renderWithMarkers3(existing, result.body, "decisions.md")
   );
-  return { decisionCount: result.decisionCount };
+  return { decisionCount: result.decisionCount };
+}
+async function regenerateOrientation(paths, nowIso, callbacks) {
+  const result = await renderOrientation({ paths, nowIso, ...callbacks });
+  await writeMarkdownFile3(paths.files.orientation, `${result.body}
+`);
+  return {
+    sessionCount: result.sessionCount,
+    inFlightTaskCount: result.inFlightTaskCount,
+    pendingApprovalsCount: result.pendingApprovalsCount,
+    suspectCount: result.suspectCount
+  };
+}
+async function refreshAll(args) {
+  const { options, ctx, paths, nowIso } = args;
+  const dryRun = options.dryRun === true;
+  const claudeCode = await importClaudeCode(options, ctx);
+  const codex = await importCodex(options, ctx);
+  if (dryRun) {
+    const skipped = { status: "skipped", reason: "dry-run" };
+    return {
+      claudeCode,
+      codex,
+      handoff: skipped,
+      decisions: skipped,
+      orientation: skipped,
+      dryRun
+    };
+  }
+  const handoffCounts = await regenerateHandoff(paths, nowIso);
+  const decisionCounts = await regenerateDecisions(paths, nowIso);
+  const scoped = options.project !== void 0 && options.project.length > 0;
+  const orientationCounts = await regenerateOrientation(
+    paths,
+    nowIso,
+    scoped ? {} : {
+      staleness: {
+        newSessions: 0,
+        updatedSessions: 0,
+        unverifiableSessions: wouldBlock(claudeCode) + wouldBlock(codex)
+      }
+    }
+  );
+  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");
+}
+async function runProjectPreset(options, ctx = {}) {
+  try {
+    await doRunProjectPreset(options, ctx);
+  } catch (error) {
+    renderCliError(error, { verbose: isVerbose(options) });
+    process.exitCode = 1;
+  }
+}
+function canonicalFileFor(anchorReal, canonicalName) {
+  return join4(anchorReal, "agents", canonicalName, CANONICAL_FILE);
+}
+function canonicalLabelFor(canonicalName) {
+  return join4("agents", canonicalName, CANONICAL_FILE);
+}
+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 {
+    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 {
+      ...declared,
+      isAnchor: false,
+      reachable: true,
+      canonicalName,
+      canonicalPresent: true,
+      canonicalReadable: false
+    };
+  }
+  if (content === null) {
+    return {
+      ...declared,
+      isAnchor: false,
+      reachable: true,
+      canonicalName,
+      canonicalPresent: false
+    };
+  }
+  const section = parseMarkers(content);
+  return {
+    ...declared,
+    isAnchor: false,
+    reachable: true,
+    canonicalName,
+    canonicalPresent: true,
+    canonicalReadable: true,
+    markerKind: section.kind,
+    ...section.kind === "ok" ? { currentBlock: section.generated } : {}
+  };
+}
+async function applyPresetPlan(anchorReal, plan) {
+  const file = canonicalFileFor(anchorReal, plan.canonicalName);
+  const label = canonicalLabelFor(plan.canonicalName);
+  let isLink = false;
+  try {
+    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) });
+      }
+    }
+  }
+  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;
+}
+function presetActionLabel(action) {
+  return action === "create" ? "\u65B0\u898F\u4F5C\u6210" : "\u66F4\u65B0";
+}
+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 doRunProjectArchive(target, options, ctx);
+  } catch (error) {
+    renderCliError(error, { verbose: isVerbose(options) });
+    process.exitCode = 1;
+  }
+}
+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, "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
+  });
+  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 {
+    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 runProjectRename(oldPath, newPath, options, ctx = {}) {
+  try {
+    await doRunProjectRename(oldPath, newPath, options, ctx);
+  } catch (error) {
+    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 {
+    }
+  }
+  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");
 }
-async function refreshAll(args) {
-  const { options, ctx, paths, nowIso } = args;
-  const dryRun = options.dryRun === true;
-  const claudeCode = await importClaudeCode(options, ctx);
-  const codex = await importCodex(options, ctx);
-  if (dryRun) {
-    const skipped = { status: "skipped", reason: "dry-run" };
-    return { claudeCode, codex, handoff: skipped, decisions: skipped, dryRun };
+
+// src/commands/refresh.ts
+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 as isAbsolute2, join as join5, resolve as resolve4 } from "path";
+import { readYamlFile as readYamlFile3 } from "@basou/core";
+var DEFAULT_PORTFOLIO_CONFIG_PATH = join5(homedir3(), ".basou", "portfolio.yaml");
+function expandTilde(p) {
+  if (p === "~") return homedir3();
+  if (p.startsWith("~/")) return join5(homedir3(), p.slice(2));
+  return p;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+async function loadPortfolioConfig(configPath = DEFAULT_PORTFOLIO_CONFIG_PATH) {
+  let raw;
+  try {
+    raw = await readYamlFile3(configPath);
+  } catch (error) {
+    if (error instanceof Error && error.message === "YAML file not found") {
+      throw new Error(
+        "No portfolio config at ~/.basou/portfolio.yaml. Create one (a 'workspaces:' list of repo paths) or pass --workspace <path>."
+      );
+    }
+    if (error instanceof Error && error.message === "Failed to parse YAML content") {
+      throw new Error("~/.basou/portfolio.yaml is not valid YAML.");
+    }
+    throw error;
   }
-  const handoffCounts = await regenerateHandoff(paths, nowIso);
-  const decisionCounts = await regenerateDecisions(paths, nowIso);
-  return {
-    claudeCode,
-    codex,
-    handoff: { status: "generated", ...handoffCounts },
-    decisions: { status: "generated", ...decisionCounts },
-    dryRun
-  };
+  if (!isRecord(raw) || !Array.isArray(raw.workspaces)) {
+    throw new Error("~/.basou/portfolio.yaml must contain a 'workspaces:' list.");
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const entry of raw.workspaces) {
+    if (!isRecord(entry) || typeof entry.path !== "string" || entry.path.trim().length === 0) {
+      throw new Error("Each portfolio workspace needs a non-empty string 'path'.");
+    }
+    if (entry.label !== void 0 && typeof entry.label !== "string") {
+      throw new Error("A portfolio workspace 'label' must be a string when present.");
+    }
+    const expanded = expandTilde(entry.path.trim());
+    if (!isAbsolute2(expanded)) {
+      throw new Error(
+        "Portfolio workspace paths must be absolute (or start with '~'); use --workspace for relative ad-hoc paths."
+      );
+    }
+    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 });
+  }
+  if (result.length === 0) {
+    throw new Error("~/.basou/portfolio.yaml has no workspaces.");
+  }
+  return result;
 }
 
 // src/commands/refresh-watch.ts
 import { readdir as readdir2, stat as stat2 } from "fs/promises";
-import { homedir as homedir3 } from "os";
-import { join as join4 } from "path";
-import { findErrorCode as findErrorCode6 } from "@basou/core";
+import { homedir as homedir4 } from "os";
+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 ?? join4(homedir3(), ".codex", "sessions"),
-    ctx.claudeProjectsDir ?? join4(homedir3(), ".claude", "projects")
+    ctx.codexSessionsDir ?? join6(homedir4(), ".codex", "sessions"),
+    ctx.claudeProjectsDir ?? join6(homedir4(), ".claude", "projects")
   ];
 }
 async function scanSourceLogs(roots) {
@@ -2148,11 +4178,11 @@ async function scanSourceLogs(roots) {
     try {
       entries = await readdir2(dir, { withFileTypes: true });
     } catch (error) {
-      if (findErrorCode6(error, "ENOENT") || findErrorCode6(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 = join4(dir, entry.name);
+      const full = join6(dir, entry.name);
       if (entry.isDirectory()) {
         await walk(full);
       } else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
@@ -2160,7 +4190,7 @@ async function scanSourceLogs(roots) {
           const info = await stat2(full);
           out.set(full, { mtimeMs: info.mtimeMs, size: info.size });
         } catch (error) {
-          if (findErrorCode6(error, "ENOENT")) continue;
+          if (findErrorCode8(error, "ENOENT")) continue;
           throw new Error("Failed to stat a source log file", { cause: error });
         }
       }
@@ -2252,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((resolve4) => {
+  return new Promise((resolve8) => {
     if (signal.aborted) {
-      resolve4();
+      resolve8();
       return;
     }
     let timer;
     const onAbort = () => {
       clearTimeout(timer);
-      resolve4();
+      resolve8();
     };
     timer = setTimeout(() => {
       signal.removeEventListener("abort", onAbort);
-      resolve4();
+      resolve8();
     }, ms);
     signal.addEventListener("abort", onAbort, { once: true });
   });
@@ -2285,6 +4315,9 @@ function registerRefreshCommand(program) {
     collectPath2,
     []
   ).option("--force", "Re-import sessions already imported instead of skipping").option("--dry-run", "Preview imports and skip writing handoff / decisions").option("--json", "Output the result as JSON").option(
+    "--portfolio",
+    "Refresh every workspace listed in ~/.basou/portfolio.yaml (each with its own source roots)"
+  ).option(
     "--watch",
     "Keep running: re-import + regenerate when the native logs change (Ctrl-C to stop)"
   ).option(
@@ -2297,7 +4330,9 @@ function registerRefreshCommand(program) {
 }
 async function runRefresh(options, ctx = {}) {
   try {
-    if (options.watch === true) {
+    if (options.portfolio === true) {
+      await doRunRefreshPortfolio(options, ctx);
+    } else if (options.watch === true) {
       await doRunRefreshWatch(options, ctx);
     } else {
       await doRunRefresh(options, ctx);
@@ -2307,14 +4342,58 @@ async function runRefresh(options, ctx = {}) {
     process.exitCode = 1;
   }
 }
+async function doRunRefreshPortfolio(options, ctx) {
+  if (options.watch === true) throw new Error("--portfolio cannot be combined with --watch.");
+  if (options.project !== void 0 && options.project.length > 0) {
+    throw new Error(
+      "--portfolio refreshes each workspace with its own source roots; remove --project."
+    );
+  }
+  const workspaces = await loadPortfolioConfig(ctx.portfolioConfigPath);
+  const rollup = [];
+  for (const ws of workspaces) {
+    const label = ws.label ?? ws.path;
+    try {
+      const result = await computeRefresh(
+        { ...options, portfolio: false },
+        { ...ctx, cwd: ws.path }
+      );
+      rollup.push({ label, path: ws.path, status: "ok", result });
+      if (options.json !== true) {
+        console.log(`
+## ${label} (${ws.path})`);
+        printRefreshSummary(result);
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      rollup.push({ label, path: ws.path, status: "failed", error: message });
+      if (options.json !== true) {
+        console.log(`
+## ${label} (${ws.path})`);
+        console.log(`  failed: ${message}`);
+      }
+    }
+  }
+  if (options.json === true) {
+    console.log(JSON.stringify({ portfolio: true, workspaces: rollup }));
+  } else {
+    const failed = rollup.filter((r) => r.status === "failed").length;
+    const ok = rollup.length - failed;
+    console.log(
+      `
+portfolio: ${ok}/${rollup.length} refreshed${failed > 0 ? `, ${failed} failed` : ""}.`
+    );
+  }
+  if (rollup.some((r) => r.status === "failed")) process.exitCode = 1;
+}
 async function doRunRefreshWatch(options, ctx) {
   if (options.dryRun === true) throw new Error("--watch cannot be combined with --dry-run.");
   if (options.json === true) throw new Error("--watch cannot be combined with --json.");
   if (options.force === true) throw new Error("--watch cannot be combined with --force.");
   const cwd = ctx.cwd ?? process.cwd();
-  const repositoryRoot = await resolveRepositoryRootForRefresh(cwd);
-  const paths = basouPaths7(repositoryRoot);
-  await assertWorkspaceInitialized6(paths.root);
+  const repositoryRoot = await resolveBasouRootForCommand(cwd, "refresh");
+  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();
@@ -2322,7 +4401,9 @@ async function doRunRefreshWatch(options, ctx) {
   process.on("SIGTERM", onSignal);
   try {
     await runRefreshWatch({
-      ctx,
+      // Watch from a workspace view: import from the resolved planning repo, not
+      // the raw (non-git) view cwd — mirrors the redirect in computeRefresh.
+      ctx: { ...ctx, cwd: repositoryRoot },
       paths,
       intervalMs,
       importOptions: options.project !== void 0 && options.project.length > 0 ? { project: options.project } : {},
@@ -2336,22 +4417,27 @@ async function doRunRefreshWatch(options, ctx) {
     process.off("SIGTERM", onSignal);
   }
 }
-async function doRunRefresh(options, ctx) {
+async function computeRefresh(options, ctx) {
   const cwd = ctx.cwd ?? process.cwd();
-  const repositoryRoot = await resolveRepositoryRootForRefresh(cwd);
-  const paths = basouPaths7(repositoryRoot);
-  await assertWorkspaceInitialized6(paths.root);
+  const repositoryRoot = await resolveBasouRootForCommand(cwd, "refresh");
+  const paths = basouPaths10(repositoryRoot);
+  await assertWorkspaceInitialized8(paths.root);
   const nowIso = (ctx.nowProvider?.() ?? /* @__PURE__ */ new Date()).toISOString();
-  const result = await refreshAll({
+  return refreshAll({
     options: {
       ...options.project !== void 0 && options.project.length > 0 ? { project: options.project } : {},
       ...options.force === true ? { force: true } : {},
       ...options.dryRun === true ? { dryRun: true } : {}
     },
-    ctx,
+    // Import from the resolved repo root, not the raw cwd: a workspace-view cwd
+    // redirects to its planning repo, and the import must run there too.
+    ctx: { ...ctx, cwd: repositoryRoot },
     paths,
     nowIso
   });
+}
+async function doRunRefresh(options, ctx) {
+  const result = await computeRefresh(options, ctx);
   if (options.json === true) {
     console.log(JSON.stringify(result));
   } else {
@@ -2383,28 +4469,30 @@ 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})`);
   }
-}
-async function resolveRepositoryRootForRefresh(cwd) {
-  try {
-    return await resolveRepositoryRoot8(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 refresh'.", {
-        cause: error
-      });
-    }
-    throw error;
+  if (result.orientation.status === "generated") {
+    console.log(
+      `orientation: regenerated (in-flight: ${result.orientation.inFlightTaskCount}, pending approvals: ${result.orientation.pendingApprovalsCount}, suspect: ${result.orientation.suspectCount})`
+    );
+  } else {
+    console.log(`orientation: skipped (${result.orientation.reason})`);
   }
 }
-async function assertWorkspaceInitialized6(basouRoot) {
+async function assertWorkspaceInitialized8(basouRoot) {
   try {
-    await assertBasouRootSafe7(basouRoot);
+    await assertBasouRootSafe9(basouRoot);
   } catch (error) {
-    if (findErrorCode7(error, "ENOENT")) {
+    if (findErrorCode9(error, "ENOENT")) {
       throw new Error("Workspace not initialized. Run 'basou init' first.");
     }
     throw error;
@@ -2412,14 +4500,14 @@ async function assertWorkspaceInitialized6(basouRoot) {
 }
 
 // src/commands/report.ts
-import { isAbsolute, resolve as resolve3 } from "path";
+import { isAbsolute as isAbsolute3, resolve as resolve5 } from "path";
 import {
-  assertBasouRootSafe as assertBasouRootSafe8,
-  basouPaths as basouPaths8,
-  findErrorCode as findErrorCode8,
+  assertBasouRootSafe as assertBasouRootSafe10,
+  basouPaths as basouPaths11,
+  findErrorCode as findErrorCode10,
   renderReport,
-  resolveRepositoryRoot as resolveRepositoryRoot9,
-  writeMarkdownFile as writeMarkdownFile4
+  resolveRepositoryRoot as resolveRepositoryRoot8,
+  writeMarkdownFile as writeMarkdownFile6
 } from "@basou/core";
 function registerReportCommand(program) {
   const report = program.command("report").description(
@@ -2440,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 = basouPaths8(repositoryRoot);
-  await assertWorkspaceInitialized7(paths.root);
+  const paths = basouPaths11(repositoryRoot);
+  await assertWorkspaceInitialized9(paths.root);
   const nowIso = (ctx.nowProvider?.() ?? /* @__PURE__ */ new Date()).toISOString();
   const result = await renderReport({
     paths,
@@ -2452,8 +4540,8 @@ async function doRunReportGenerate(options, ctx) {
     onTaskSkip: (taskId, reason) => printTaskSkip(taskId, reason)
   });
   if (options.out !== void 0) {
-    const outPath = isAbsolute(options.out) ? options.out : resolve3(cwd, options.out);
-    await writeMarkdownFile4(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})`
@@ -2467,7 +4555,7 @@ async function doRunReportGenerate(options, ctx) {
 }
 async function resolveRepositoryRootForReport(cwd) {
   try {
-    return await resolveRepositoryRoot9(cwd);
+    return await resolveRepositoryRoot8(cwd);
   } catch (error) {
     if (error instanceof Error && error.message === "Not a git repository") {
       throw new Error(
@@ -2478,25 +4566,149 @@ async function resolveRepositoryRootForReport(cwd) {
     throw error;
   }
 }
-async function assertWorkspaceInitialized7(basouRoot) {
+async function assertWorkspaceInitialized9(basouRoot) {
   try {
-    await assertBasouRootSafe8(basouRoot);
+    await assertBasouRootSafe10(basouRoot);
   } catch (error) {
-    if (findErrorCode8(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 homedir4 } from "os";
-import { join as join5 } from "path";
+import { homedir as homedir5 } from "os";
+import { join as join7 } from "path";
 import {
-  acquireLock as acquireLock4,
-  assertBasouRootSafe as assertBasouRootSafe9,
-  basouPaths as basouPaths9,
+  acquireLock as acquireLock5,
+  assertBasouRootSafe as assertBasouRootSafe11,
+  basouPaths as basouPaths13,
   ChildProcessRunner as ChildProcessRunner2,
   claudeCodeAdapterMetadata,
   appendChainedEvent as coreAppendChainedEvent2,
@@ -2505,10 +4717,10 @@ import {
   getSnapshot as getSnapshot2,
   overwriteYamlFile as overwriteYamlFile2,
   prefixedUlid as prefixedUlid4,
-  readManifest as readManifest4,
-  readYamlFile as readYamlFile3,
+  readManifest as readManifest6,
+  readYamlFile as readYamlFile4,
   resolveClaudeCodeCommand,
-  resolveRepositoryRoot as resolveRepositoryRoot10,
+  resolveRepositoryRoot as resolveRepositoryRoot9,
   SessionSchema as SessionSchema2,
   sanitizeRelatedFiles,
   sanitizeWorkingDirectory as sanitizeWorkingDirectory2,
@@ -2541,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 = basouPaths9(repoRoot);
-  await assertBasouRootSafe9(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 = join5(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 = join5(sessionDir, "session.yaml");
+  const sessionYamlPath = join7(sessionDir, "session.yaml");
   const session = buildInitialSession2({
     id: sessionId,
     command,
@@ -2584,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";
@@ -2677,7 +4889,7 @@ async function runClaudeCode(args, options, ctx = {}) {
   const rawRelated = computeRelatedFiles(preSnapshot, postSnapshot, diff);
   const relatedFiles = sanitizeRelatedFiles(rawRelated, {
     workingDirectory: repoRoot,
-    homedir: homedir4()
+    homedir: homedir5()
   }).sanitized;
   const finalStatus = decideFinalStatus2(result, signalReceived);
   await appendEvent(sessionDir, {
@@ -2821,7 +5033,7 @@ function buildInitialSession2(input) {
       source: { ...claudeCodeAdapterMetadata },
       started_at: input.startedAt,
       status: "initialized",
-      working_directory: sanitizeWorkingDirectory2(input.cwd, { homedir: homedir4() }),
+      working_directory: sanitizeWorkingDirectory2(input.cwd, { homedir: homedir5() }),
       invocation: {
         command: input.command,
         args: [...input.args],
@@ -2833,7 +5045,7 @@ function buildInitialSession2(input) {
   };
 }
 async function mutateSessionYaml2(filePath, mutator) {
-  const raw = await readYamlFile3(filePath);
+  const raw = await readYamlFile4(filePath);
   const parsed = SessionSchema2.parse(raw);
   mutator(parsed);
   const validated = SessionSchema2.parse(parsed);
@@ -2881,7 +5093,7 @@ async function finalizeSessionAsFailed2(paths, sessionDir, sessionId, appendEven
 }
 async function resolveRepositoryRootForRun(cwd) {
   try {
-    return await resolveRepositoryRoot10(cwd);
+    return await resolveRepositoryRoot9(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 run'.", {
@@ -2894,29 +5106,28 @@ async function resolveRepositoryRootForRun(cwd) {
 
 // src/commands/session.ts
 import { readFile as readFile2 } from "fs/promises";
-import { basename as basename3, isAbsolute as isAbsolute2, join as join6, 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 assertBasouRootSafe10,
-  basouPaths as basouPaths10,
+  acquireLock as acquireLock6,
+  appendEventToExistingSession as appendEventToExistingSession3,
+  assertBasouRootSafe as assertBasouRootSafe12,
+  basouPaths as basouPaths14,
   enumerateSessionDirs as enumerateSessionDirs2,
-  findErrorCode as findErrorCode9,
+  findErrorCode as findErrorCode11,
   importSessionFromJson as importSessionFromJson2,
   loadSessionEntries,
   readAllEvents,
-  readManifest as readManifest5,
-  readYamlFile as readYamlFile4,
+  readManifest as readManifest7,
+  readYamlFile as readYamlFile5,
   rechainSessionInPlace,
-  resolveRepositoryRoot as resolveRepositoryRoot11,
-  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";
@@ -2965,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 = basouPaths10(repositoryRoot);
-  await assertWorkspaceInitialized8(paths.root);
+  const paths = basouPaths14(repositoryRoot);
+  await assertWorkspaceInitialized10(paths.root);
   const now = /* @__PURE__ */ new Date();
   const records = (await loadSessionEntries(paths, {
     now,
@@ -3017,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 = basouPaths10(repositoryRoot);
-  await assertWorkspaceInitialized8(paths.root);
-  const sessionId = await resolveSessionId2(paths, idInput);
-  const sessionDir = join6(paths.sessions, sessionId);
-  const sessionYamlPath = join6(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 readYamlFile4(sessionYamlPath);
+    const raw = await readYamlFile5(sessionYamlPath);
     session = SessionSchema3.parse(raw);
   } catch (error) {
-    if (findErrorCode9(error, "ENOENT")) {
+    if (findErrorCode11(error, "ENOENT")) {
       throw new Error(`Session not found: ${idInput}`);
     }
     throw new Error("Failed to read session", { cause: error });
@@ -3142,12 +5353,12 @@ function formatSessionWork(session, events, now) {
 }
 function formatWorkingDir(workingDir, repositoryRoot, options) {
   if (options.fullPath === true) return workingDir;
-  if (!isAbsolute2(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}`;
@@ -3261,23 +5472,13 @@ function maxLen2(values, floor) {
   return max;
 }
 async function resolveRepositoryRootForSession(cwd, subcmd) {
-  try {
-    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 session ${subcmd}'.`,
-        { cause: error }
-      );
-    }
-    throw error;
-  }
+  return resolveBasouRootForCommand(cwd, `session ${subcmd}`);
 }
-async function assertWorkspaceInitialized8(basouRoot) {
+async function assertWorkspaceInitialized10(basouRoot) {
   try {
-    await assertBasouRootSafe10(basouRoot);
+    await assertBasouRootSafe12(basouRoot);
   } catch (error) {
-    if (findErrorCode9(error, "ENOENT")) {
+    if (findErrorCode11(error, "ENOENT")) {
       throw new Error("Workspace not initialized. Run 'basou init' first.");
     }
     throw error;
@@ -3315,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 = basouPaths10(repositoryRoot);
-  await assertWorkspaceInitialized8(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);
@@ -3346,10 +5547,10 @@ async function readInputFile(path) {
   try {
     return await readFile2(path, "utf8");
   } catch (error) {
-    if (findErrorCode9(error, "ENOENT")) {
+    if (findErrorCode11(error, "ENOENT")) {
       throw new Error("Import source not found", { cause: error });
     }
-    if (findErrorCode9(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 });
@@ -3364,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;
 }
@@ -3402,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;
@@ -3429,19 +5630,19 @@ async function doRunSessionNote(sessionIdInput, options, ctx) {
   }
   const cwd = ctx.cwd ?? process.cwd();
   const repositoryRoot = await resolveRepositoryRootForSession(cwd, "note");
-  const paths = basouPaths10(repositoryRoot);
-  await assertWorkspaceInitialized8(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) => ({
@@ -3463,10 +5664,10 @@ async function readNoteFile(path) {
   try {
     return await readFile2(path, "utf8");
   } catch (error) {
-    if (findErrorCode9(error, "ENOENT")) {
+    if (findErrorCode11(error, "ENOENT")) {
       throw new Error("Note source not found", { cause: error });
     }
-    if (findErrorCode9(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 });
@@ -3474,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;
 }
@@ -3511,9 +5712,9 @@ async function doRunSessionRechain(options, ctx) {
   }
   const cwd = ctx.cwd ?? process.cwd();
   const repositoryRoot = await resolveRepositoryRootForSession(cwd, "rechain");
-  const paths = basouPaths10(repositoryRoot);
-  await assertWorkspaceInitialized8(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) {
@@ -3565,11 +5766,11 @@ function renderRechainRow(row, dryRun) {
 
 // src/commands/stats.ts
 import {
-  assertBasouRootSafe as assertBasouRootSafe11,
-  basouPaths as basouPaths11,
+  assertBasouRootSafe as assertBasouRootSafe13,
+  basouPaths as basouPaths15,
   computeWorkStats,
-  findErrorCode as findErrorCode10,
-  resolveRepositoryRoot as resolveRepositoryRoot12
+  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) => {
@@ -3587,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 = basouPaths11(repositoryRoot);
-  await assertWorkspaceInitialized9(paths.root);
+  const paths = basouPaths15(repositoryRoot);
+  await assertWorkspaceInitialized11(paths.root);
   const now = ctx.nowProvider?.() ?? /* @__PURE__ */ new Date();
   const result = await computeWorkStats({
     paths,
@@ -3672,7 +5873,7 @@ function formatInt(n) {
 }
 async function resolveRepositoryRootForStats(cwd) {
   try {
-    return await resolveRepositoryRoot12(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'.", {
@@ -3682,11 +5883,11 @@ async function resolveRepositoryRootForStats(cwd) {
     throw error;
   }
 }
-async function assertWorkspaceInitialized9(basouRoot) {
+async function assertWorkspaceInitialized11(basouRoot) {
   try {
-    await assertBasouRootSafe11(basouRoot);
+    await assertBasouRootSafe13(basouRoot);
   } catch (error) {
-    if (findErrorCode10(error, "ENOENT")) {
+    if (findErrorCode12(error, "ENOENT")) {
       throw new Error("Workspace not initialized. Run 'basou init' first.");
     }
     throw error;
@@ -3695,12 +5896,12 @@ async function assertWorkspaceInitialized9(basouRoot) {
 
 // src/commands/status.ts
 import {
-  assertBasouRootSafe as assertBasouRootSafe12,
-  basouPaths as basouPaths12,
+  assertBasouRootSafe as assertBasouRootSafe14,
+  basouPaths as basouPaths16,
   buildStatusSnapshot,
-  findErrorCode as findErrorCode11,
-  readManifest as readManifest6,
-  resolveRepositoryRoot as resolveRepositoryRoot13,
+  findErrorCode as findErrorCode13,
+  readManifest as readManifest8,
+  resolveRepositoryRoot as resolveRepositoryRoot11,
   writeStatus
 } from "@basou/core";
 function registerStatusCommand(program) {
@@ -3719,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 = basouPaths12(repositoryRoot);
+  const paths = basouPaths16(repositoryRoot);
   try {
-    await assertBasouRootSafe12(paths.root);
+    await assertBasouRootSafe14(paths.root);
   } catch (error) {
-    if (findErrorCode11(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 (findErrorCode11(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 });
@@ -3756,7 +5957,7 @@ function renderTextStatus(s) {
 }
 async function resolveRepositoryRootForStatus(cwd) {
   try {
-    return await resolveRepositoryRoot13(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'.", {
@@ -3769,34 +5970,34 @@ async function resolveRepositoryRootForStatus(cwd) {
 
 // src/commands/task.ts
 import { readFile as readFile3 } from "fs/promises";
-import { join as join7 } from "path";
+import { join as join9 } from "path";
 import {
   archiveTask,
-  assertBasouRootSafe as assertBasouRootSafe13,
-  basouPaths as basouPaths13,
+  assertBasouRootSafe as assertBasouRootSafe15,
+  basouPaths as basouPaths17,
   createTaskWithEvent,
   deleteTask,
   editTask,
   enumerateArchivedTaskIds,
-  findErrorCode as findErrorCode12,
+  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 resolveRepositoryRoot14,
-  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)");
@@ -3875,14 +6076,14 @@ async function doRunTaskNew(options, ctx) {
   }
   const cwd = ctx.cwd ?? process.cwd();
   const repositoryRoot = await resolveRepositoryRootForTask(cwd, "new");
-  const paths = basouPaths13(repositoryRoot);
-  await assertWorkspaceInitialized10(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,
@@ -3910,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,
@@ -3984,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 = basouPaths13(repositoryRoot);
-  await assertWorkspaceInitialized10(paths.root);
+  const paths = basouPaths17(repositoryRoot);
+  await assertWorkspaceInitialized12(paths.root);
   const entries = await loadTaskEntries(paths, {
     onSkip: (id, reason) => printTaskSkip(id, reason)
   });
@@ -4088,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 = basouPaths13(repositoryRoot);
-  await assertWorkspaceInitialized10(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 = join7(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)
@@ -4232,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 = basouPaths13(repositoryRoot);
-  await assertWorkspaceInitialized10(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,
@@ -4258,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,
@@ -4309,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 = basouPaths13(repositoryRoot);
-  await assertWorkspaceInitialized10(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);
@@ -4489,9 +6690,9 @@ async function doRunTaskRefreshLinkage(taskIdInput, options, ctx) {
   }
   const cwd = ctx.cwd ?? process.cwd();
   const repositoryRoot = await resolveRepositoryRootForTask(cwd, "refresh-linkage");
-  const paths = basouPaths13(repositoryRoot);
-  await assertWorkspaceInitialized10(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;
@@ -4569,9 +6770,9 @@ async function doRunTaskEdit(taskIdInput, options, ctx) {
   }
   const cwd = ctx.cwd ?? process.cwd();
   const repositoryRoot = await resolveRepositoryRootForTask(cwd, "edit");
-  const paths = basouPaths13(repositoryRoot);
-  await assertWorkspaceInitialized10(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();
@@ -4625,9 +6826,9 @@ async function doRunTaskDelete(taskIdInput, options, ctx) {
   }
   const cwd = ctx.cwd ?? process.cwd();
   const repositoryRoot = await resolveRepositoryRootForTask(cwd, "delete");
-  const paths = basouPaths13(repositoryRoot);
-  await assertWorkspaceInitialized10(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);
@@ -4670,9 +6871,9 @@ async function doRunTaskArchive(taskIdInput, options, ctx) {
   }
   const cwd = ctx.cwd ?? process.cwd();
   const repositoryRoot = await resolveRepositoryRootForTask(cwd, "archive");
-  const paths = basouPaths13(repositoryRoot);
-  await assertWorkspaceInitialized10(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);
@@ -4725,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(", ")}`
     );
   }
@@ -4747,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"
     );
   }
@@ -4756,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(", ")}`
     );
   }
@@ -4771,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;
 }
@@ -4786,10 +6987,10 @@ async function readDescriptionFile(path) {
   try {
     return await readFile3(path, "utf8");
   } catch (error) {
-    if (findErrorCode12(error, "ENOENT")) {
+    if (findErrorCode14(error, "ENOENT")) {
       throw new Error("Description source not found", { cause: error });
     }
-    if (findErrorCode12(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 });
@@ -4797,7 +6998,7 @@ async function readDescriptionFile(path) {
 }
 async function resolveRepositoryRootForTask(cwd, subcmd) {
   try {
-    return await resolveRepositoryRoot14(cwd);
+    return await resolveRepositoryRoot12(cwd);
   } catch (error) {
     if (error instanceof Error && error.message === "Not a git repository") {
       throw new Error(
@@ -4808,11 +7009,11 @@ async function resolveRepositoryRootForTask(cwd, subcmd) {
     throw error;
   }
 }
-async function assertWorkspaceInitialized10(basouRoot) {
+async function assertWorkspaceInitialized12(basouRoot) {
   try {
-    await assertBasouRootSafe13(basouRoot);
+    await assertBasouRootSafe15(basouRoot);
   } catch (error) {
-    if (findErrorCode12(error, "ENOENT")) {
+    if (findErrorCode14(error, "ENOENT")) {
       throw new Error("Workspace not initialized. Run 'basou init' first.");
     }
     throw error;
@@ -4900,12 +7101,12 @@ function maxLen3(values, floor) {
 
 // src/commands/verify.ts
 import {
-  assertBasouRootSafe as assertBasouRootSafe14,
-  basouPaths as basouPaths14,
+  assertBasouRootSafe as assertBasouRootSafe16,
+  basouPaths as basouPaths18,
   enumerateSessionDirs as enumerateSessionDirs3,
-  findErrorCode as findErrorCode13,
-  resolveRepositoryRoot as resolveRepositoryRoot15,
-  resolveSessionId as resolveSessionId4,
+  findErrorCode as findErrorCode15,
+  resolveRepositoryRoot as resolveRepositoryRoot13,
+  resolveSessionId as resolveSessionId5,
   verifyEventsChain
 } from "@basou/core";
 function registerVerifyCommand(program) {
@@ -4927,9 +7128,9 @@ async function doRunVerify(options, ctx) {
   }
   const cwd = ctx.cwd ?? process.cwd();
   const repositoryRoot = await resolveRepositoryRootForVerify(cwd);
-  const paths = basouPaths14(repositoryRoot);
-  await assertWorkspaceInitialized11(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);
@@ -4975,7 +7176,7 @@ function renderVerdict(row) {
 }
 async function resolveRepositoryRootForVerify(cwd) {
   try {
-    return await resolveRepositoryRoot15(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'.", {
@@ -4985,11 +7186,11 @@ async function resolveRepositoryRootForVerify(cwd) {
     throw error;
   }
 }
-async function assertWorkspaceInitialized11(basouRoot) {
+async function assertWorkspaceInitialized13(basouRoot) {
   try {
-    await assertBasouRootSafe14(basouRoot);
+    await assertBasouRootSafe16(basouRoot);
   } catch (error) {
-    if (findErrorCode13(error, "ENOENT")) {
+    if (findErrorCode15(error, "ENOENT")) {
       throw new Error("Workspace not initialized. Run 'basou init' first.");
     }
     throw error;
@@ -4998,27 +7199,162 @@ async function assertWorkspaceInitialized11(basouRoot) {
 
 // src/commands/view.ts
 import { spawn } from "child_process";
-import { assertBasouRootSafe as assertBasouRootSafe15, basouPaths as basouPaths15, findErrorCode as findErrorCode15, resolveRepositoryRoot as resolveRepositoryRoot16 } from "@basou/core";
-import { InvalidArgumentError as InvalidArgumentError5 } from "commander";
+import { createHash } from "crypto";
+import { basename as basename5, resolve as resolve7 } from "path";
+import {
+  assertBasouRootSafe as assertBasouRootSafe17,
+  basouPaths as basouPaths19,
+  findErrorCode as findErrorCode17,
+  readManifest as readManifest12,
+  resolveRepositoryRoot as resolveRepositoryRoot14
+} from "@basou/core";
+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 isAbsolute5, join as join10, relative as relative4, resolve as resolve6 } from "path";
+import { promisify } from "util";
+import { readManifest as readManifest10 } from "@basou/core";
+var execFileAsync = promisify(execFile);
+function errorCode(error) {
+  return error instanceof Error ? error.code : void 0;
+}
+async function canonical(p) {
+  try {
+    return await realpath(p);
+  } catch {
+    return resolve6(p);
+  }
+}
+function isInside(child, parent) {
+  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");
+}
+async function inspectRepo(repoPath) {
+  let hasEntry = false;
+  try {
+    await lstat(join10(repoPath, ".basou"));
+    hasEntry = true;
+  } catch (error) {
+    if (errorCode(error) !== "ENOENT") {
+      return {
+        kind: "unverifiable",
+        detail: `could not check for a .basou here (${errorCode(error) ?? "unknown error"}) \u2014 treat as unsafe`
+      };
+    }
+  }
+  try {
+    const { stdout } = await execFileAsync("git", ["-C", repoPath, "ls-files", "-z"]);
+    const tracked = stdout.split("\0").some((f) => f.length > 0 && isBasouPath(f));
+    if (tracked) {
+      return {
+        kind: "footprint",
+        detail: "a .basou/ entry is tracked by git here and would be pushed"
+      };
+    }
+  } catch {
+  }
+  if (hasEntry) return { kind: "footprint", detail: "a .basou/ entry exists here" };
+  return null;
+}
+async function checkPortfolioSafety(workspaces) {
+  const findings = [];
+  let monitoredReposChecked = 0;
+  for (const ws of workspaces) {
+    const wsReal = await canonical(ws.repoRoot);
+    let sourceRoots = [];
+    try {
+      const manifest = await readManifest10(ws.paths);
+      sourceRoots = manifest.import?.source_roots ?? [];
+    } catch (error) {
+      if (error instanceof Error && error.message === "YAML file not found") {
+        sourceRoots = [];
+      } else {
+        findings.push({
+          workspaceLabel: ws.label,
+          workspaceRoot: ws.repoRoot,
+          monitoredRepo: ws.repoRoot,
+          kind: "unverifiable",
+          detail: "the workspace manifest is present but unreadable \u2014 cannot determine which repos it monitors; treat as unsafe"
+        });
+        continue;
+      }
+    }
+    const monitored = /* @__PURE__ */ new Map();
+    for (const root of sourceRoots) {
+      const display = resolve6(ws.repoRoot, root);
+      const real = await canonical(display);
+      if (real !== wsReal) monitored.set(real, display);
+    }
+    for (const [real, display] of monitored) {
+      monitoredReposChecked++;
+      if (isInside(wsReal, real)) {
+        findings.push({
+          workspaceLabel: ws.label,
+          workspaceRoot: ws.repoRoot,
+          monitoredRepo: display,
+          kind: "overlap",
+          detail: "the workspace (where .basou/ is written) is inside this monitored repo"
+        });
+      }
+      const inspection = await inspectRepo(real);
+      if (inspection !== null) {
+        findings.push({
+          workspaceLabel: ws.label,
+          workspaceRoot: ws.repoRoot,
+          monitoredRepo: display,
+          kind: inspection.kind,
+          detail: inspection.detail
+        });
+      }
+    }
+  }
+  return { findings, workspacesChecked: workspaces.length, monitoredReposChecked };
+}
+function formatSafetyReport(result) {
+  if (result.findings.length === 0) {
+    if (result.monitoredReposChecked === 0) {
+      return [
+        `Portfolio safety: OK. ${result.workspacesChecked} workspace(s) checked \u2014 no monitored repos configured (portfolio safety applies when a workspace imports from sibling repos via source_roots).`
+      ];
+    }
+    return [
+      `Portfolio safety: OK. ${result.workspacesChecked} workspace(s), ${result.monitoredReposChecked} monitored repo(s) checked \u2014 no .basou footprint, no overlap.`
+    ];
+  }
+  const lines = [`Portfolio safety: DANGER \u2014 ${result.findings.length} finding(s):`];
+  for (const f of result.findings) {
+    lines.push(`  [${f.kind}] ${f.monitoredRepo} (workspace "${f.workspaceLabel}"): ${f.detail}`);
+  }
+  lines.push(
+    "A monitored repo must have no basou footprint. Use a separate workspace repo whose source_roots point at the monitored repo as a sibling; never 'basou init' / 'run' / 'exec' inside a monitored repo."
+  );
+  return lines;
+}
 
 // src/lib/view-server.ts
 import { createServer } from "http";
-import { join as join8 } from "path";
+import { join as join11 } from "path";
 import {
   computeWorkStats as computeWorkStats2,
   enumerateApprovals as enumerateApprovals2,
-  findErrorCode as findErrorCode14,
+  findErrorCode as findErrorCode16,
   isLazyExpired as isLazyExpired2,
   loadApproval as loadApproval2,
   loadSessionEntries as loadSessionEntries3,
   loadTaskEntries as loadTaskEntries2,
   readAllEvents as readAllEvents2,
-  readManifest as readManifest8,
-  readMarkdownFile as readMarkdownFile4,
+  readManifest as readManifest11,
+  readMarkdownFile as readMarkdownFile5,
   readSessionYaml as readSessionYaml3,
   readTaskFile as readTaskFile2,
   renderDecisions as renderDecisions3,
-  renderHandoff as renderHandoff3
+  renderHandoff as renderHandoff3,
+  summarizeOrientation
 } from "@basou/core";
 
 // src/lib/view-ui.ts
@@ -5040,8 +7376,13 @@ var VIEW_HTML = `<!doctype html>
   button.primary { background: #2563eb; color: #fff; border-color: #2563eb; }
   button:disabled { opacity: .5; cursor: default; }
   label.chk { font-size: 13px; opacity: .85; }
+  /* On the portfolio landing there is no selected workspace, so the per-workspace action bar is hidden. */
+  body.landing #project, body.landing label.chk,
+  body.landing #btn-refresh, body.landing #btn-import-claude, body.landing #btn-import-codex,
+  body.landing #btn-gen-handoff, body.landing #btn-gen-decisions { display: none; }
   #status { padding: 6px 16px; font-size: 13px; min-height: 20px; border-bottom: 1px solid #8884; white-space: pre-wrap; }
   #status.err { color: #dc2626; }
+  .err { color: #dc2626; }
   nav { display: flex; gap: 2px; padding: 6px 12px; border-bottom: 1px solid #8884; flex-wrap: wrap; }
   nav button { border: none; border-radius: 6px; background: transparent; }
   nav button.active { background: #2563eb22; font-weight: 600; }
@@ -5055,6 +7396,8 @@ var VIEW_HTML = `<!doctype html>
   #detail { padding: 12px 16px; overflow: auto; max-height: 80vh; }
   .badge { display: inline-block; padding: 0 6px; border-radius: 6px; background: #8882; font-size: 12px; }
   .badge.warn { background: #f59e0b33; }
+  .badge.danger { background: #ef444433; }
+  .badge.ok { background: #22c55e33; }
   pre { background: #8881; padding: 12px; border-radius: 8px; overflow: auto; white-space: pre-wrap; word-break: break-word; }
   table.kv { border-collapse: collapse; }
   table.kv td { padding: 2px 10px 2px 0; vertical-align: top; }
@@ -5063,6 +7406,11 @@ var VIEW_HTML = `<!doctype html>
   .card { border: 1px solid #8884; border-radius: 8px; padding: 10px 14px; min-width: 120px; }
   .card .n { font-size: 22px; font-weight: 700; }
   .card .l { font-size: 12px; opacity: .7; }
+  .pcard { min-width: 240px; max-width: 340px; }
+  .pcard.open { cursor: pointer; }
+  .pcard.open:hover { background: #8881; }
+  .pcard .l { font-size: 14px; font-weight: 700; opacity: 1; margin-bottom: 4px; }
+  .pcard .f { font-size: 13px; }
   .tl { border-left: 2px solid #8885; margin-left: 6px; padding-left: 12px; }
   .tl .ev { margin-bottom: 8px; }
   .tl .ev .t { font-size: 12px; opacity: .65; }
@@ -5072,6 +7420,7 @@ var VIEW_HTML = `<!doctype html>
 <body>
 <header>
   <h1>basou view</h1>
+  <button id="btn-back" style="display:none">&larr; portfolio</button>
   <input type="text" id="project" placeholder="source root (optional override)" />
   <button class="primary" id="btn-refresh">Refresh all</button>
   <button id="btn-import-claude">Import claude-code</button>
@@ -5091,7 +7440,12 @@ var VIEW_HTML = `<!doctype html>
 <script>
 (function () {
   var TABS = ['overview', 'stats', 'sessions', 'tasks', 'decisions', 'approvals', 'handoff'];
-  var state = { tab: 'overview', repoRoot: '' };
+  // base is the API prefix for the active workspace: '/api' in single mode,
+  // '/api/ws/<key>' once a portfolio card is opened.
+  // canAct gates the mutating action bar: true only when a concrete workspace
+  // is active (single mode, or a portfolio card opened). It is the real safety
+  // guard \u2014 body.landing also hides the buttons, but that is cosmetic.
+  var state = { tab: 'overview', repoRoot: '', base: '/api', mode: 'single', wsKey: null, canAct: false };
 
   function $(id) { return document.getElementById(id); }
   function clear(node) { while (node.firstChild) node.removeChild(node.firstChild); }
@@ -5155,7 +7509,15 @@ var VIEW_HTML = `<!doctype html>
     for (var i = 0; i < ids.length; i++) $(ids[i]).disabled = busy;
   }
 
+  // Enable the action bar only when a workspace is active; disabled buttons
+  // cannot post to a stale/wrong workspace even if a CSS regression un-hides them.
+  function updateActionBar() {
+    var ids = ['btn-refresh', 'btn-import-claude', 'btn-import-codex', 'btn-gen-handoff', 'btn-gen-decisions'];
+    for (var i = 0; i < ids.length; i++) $(ids[i]).disabled = !state.canAct;
+  }
+
   function post(path, label) {
+    if (!state.canAct) { setStatus('Open a workspace first.', true); return; }
     setBusy(true);
     setStatus(label + '...', false);
     fetchJson(path, {
@@ -5174,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 + ')';
@@ -5188,6 +7552,155 @@ var VIEW_HTML = `<!doctype html>
     return (o.dryRun ? 'would import ' : 'imported ') + o.importedCount + ' (' + o.eventTotal + ' events)';
   }
 
+  // --- portfolio landing --------------------------------------------------
+
+  function boot() {
+    fetchJson('/api/portfolio').then(function (d) {
+      if (d && d.mode === 'portfolio') { state.mode = 'portfolio'; showLanding(d); }
+      else { enterSingle(); }
+    }).catch(function () {
+      // First-load bootstrap failure: the single-workspace view is the safe default.
+      enterSingle();
+    });
+  }
+
+  // Re-render the portfolio landing (the back button). Unlike boot(), a fetch
+  // failure here keeps the inert landing and shows an error rather than silently
+  // dropping into single mode pointed at the first workspace.
+  function backToPortfolio() {
+    enterLandingChrome();
+    fetchJson('/api/portfolio').then(function (d) {
+      if (d && d.workspaces) renderCards(d);
+      else portfolioError('Portfolio unavailable.');
+    }).catch(function (err) { portfolioError('Could not load portfolio: ' + err.message); });
+  }
+
+  function enterSingle() {
+    state.mode = 'single';
+    state.base = '/api';
+    state.wsKey = null;
+    state.canAct = true;
+    document.body.classList.remove('landing');
+    $('btn-back').style.display = 'none';
+    updateActionBar();
+    buildTabs();
+    loadTab('overview');
+  }
+
+  // Landing chrome: no workspace is active, so actions are disabled (and hidden
+  // by body.landing). The disable is the safety guard; the hide is cosmetic.
+  function enterLandingChrome() {
+    state.wsKey = null;
+    state.canAct = false;
+    document.body.classList.add('landing');
+    $('btn-back').style.display = 'none';
+    setStatus('', false);
+    clear($('tabs'));
+    updateActionBar();
+    single(true);
+  }
+
+  function showLanding(d) { enterLandingChrome(); renderCards(d); }
+
+  function renderCards(d) {
+    var detail = $('detail');
+    clear(detail);
+    var ws = d.workspaces || [];
+    detail.appendChild(el('p', { class: 'muted', text: 'Portfolio \u2014 ' + ws.length + ' workspace(s). Click a card to open it.' }));
+    var cards = el('div', { class: 'cards' }, []);
+    ws.forEach(function (w) { cards.appendChild(portfolioCard(w, d.generatedAt)); });
+    detail.appendChild(cards);
+  }
+
+  function portfolioError(msg) {
+    var detail = $('detail');
+    clear(detail);
+    detail.appendChild(el('p', { class: 'err', text: msg }));
+    detail.appendChild(el('button', { text: 'Retry', onclick: backToPortfolio }));
+  }
+
+  function highestRisk(approvals) {
+    var order = ['critical', 'high', 'medium', 'low'];
+    for (var i = 0; i < order.length; i++) {
+      for (var j = 0; j < approvals.length; j++) {
+        if (approvals[j].risk === order[i]) return order[i];
+      }
+    }
+    return approvals.length ? approvals[0].risk : '';
+  }
+
+  // Human-readable age of an ISO timestamp relative to the portfolio's
+  // generatedAt ("now"), so a stale capture reads as "3d ago" not a raw ISO.
+  function relAge(iso, nowIso) {
+    if (!iso) return '(none)';
+    var ms = Date.parse(nowIso) - Date.parse(iso);
+    if (!isFinite(ms)) return iso;
+    if (ms < 60000) return 'just now';
+    var m = Math.floor(ms / 60000); if (m < 60) return m + 'm ago';
+    var h = Math.floor(m / 60); if (h < 48) return h + 'h ago';
+    return Math.floor(h / 24) + 'd ago';
+  }
+
+  // A "run refresh" badge when a dry-run found uncaptured/changed native sessions,
+  // an "up to date" badge when the capture is current, and nothing loud when the
+  // staleness probe could not run (degrades to a quiet note).
+  function stalenessBadge(st) {
+    if (!st) return null;
+    if (!st.checked) return el('span', { class: 'badge', text: 'freshness unknown' });
+    if (st.unverifiableSessions > 0)
+      return el('span', { class: 'badge danger', text: '\u26A0 ' + st.unverifiableSessions + ' unverifiable \u2014 run verify' });
+    if (st.newSessions > 0)
+      return el('span', { class: 'badge danger', text: '\u26A0 ' + st.newSessions + ' uncaptured \u2014 run refresh' });
+    if (st.updatedSessions > 0)
+      return el('span', { class: 'badge warn', text: st.updatedSessions + ' updated \u2014 run refresh' });
+    return el('span', { class: 'badge ok', text: 'up to date' });
+  }
+
+  function portfolioCard(w, generatedAt) {
+    if (!w.initialized) {
+      return el('div', { class: 'card pcard muted' }, [
+        el('div', { class: 'l', text: w.label }),
+        el('div', { class: 'f', text: w.error ? ('unreadable: ' + w.error) : 'not initialized' })
+      ]);
+    }
+    if (w.error) {
+      return el('div', { class: 'card pcard' }, [
+        el('div', { class: 'l', text: w.label }),
+        el('div', { class: 'f' }, [el('span', { class: 'badge warn', text: 'unreadable: ' + w.error })])
+      ]);
+    }
+    var pend = w.pendingApprovals || [];
+    var pendText = 'pending ' + pend.length + (pend.length ? ' (' + highestRisk(pend) + ')' : '');
+    var now = w.latestSession ? ((w.latestSession.label || '(session)') + ' [' + w.latestSession.status + ']') : '(no live sessions)';
+    var dec = w.latestDecision ? w.latestDecision.title : '(no decisions yet)';
+    var newest = (w.freshness && w.freshness.newestStartedAt) ? w.freshness.newestStartedAt : null;
+    var badge = stalenessBadge(w.staleness);
+    return el('div', { class: 'card pcard open', onclick: function () { openWorkspace(w.key, w.label); } }, [
+      el('div', { class: 'l' }, [
+        el('span', { text: w.label }),
+        badge ? el('span', { text: '  ' }) : null,
+        badge
+      ]),
+      el('div', { class: 'f', text: 'now: ' + now }),
+      el('div', { class: 'f', text: 'latest: ' + dec }),
+      el('div', { class: 'f', text: 'in-flight ' + w.inFlightCount + '  |  ' + pendText + '  |  suspect ' + w.suspectCount }),
+      el('div', { class: 'f muted', text: 'sessions ' + w.sessionCount + '  |  newest ' + relAge(newest, generatedAt) })
+    ]);
+  }
+
+  function openWorkspace(key, label) {
+    state.mode = 'portfolio';
+    state.wsKey = key;
+    state.base = '/api/ws/' + encodeURIComponent(key);
+    state.canAct = true;
+    document.body.classList.remove('landing');
+    $('btn-back').style.display = '';
+    updateActionBar();
+    setStatus('workspace: ' + label, false);
+    buildTabs();
+    loadTab('overview');
+  }
+
   // --- tabs ---------------------------------------------------------------
 
   function buildTabs() {
@@ -5211,16 +7724,16 @@ var VIEW_HTML = `<!doctype html>
     if (name === 'stats') return loadStats();
     if (name === 'sessions') return loadSessions();
     if (name === 'tasks') return loadTasks();
-    if (name === 'decisions') return loadMarkdown('/api/decisions', 'decisions');
+    if (name === 'decisions') return loadMarkdown(state.base + '/decisions', 'decisions');
     if (name === 'approvals') return loadApprovals();
-    if (name === 'handoff') return loadMarkdown('/api/handoff', 'handoff');
+    if (name === 'handoff') return loadMarkdown(state.base + '/handoff', 'handoff');
   }
 
   function fail(err) { setStatus(err.message, true); }
 
   function loadOverview() {
     single(true);
-    fetchJson('/api/overview').then(function (d) {
+    fetchJson(state.base + '/overview').then(function (d) {
       var detail = $('detail');
       if (!d || d.initialized === false) {
         detail.appendChild(el('p', { class: 'muted', text: 'Workspace not initialized.' }));
@@ -5269,7 +7782,7 @@ var VIEW_HTML = `<!doctype html>
 
   function loadStats() {
     single(true);
-    fetchJson('/api/stats').then(function (d) {
+    fetchJson(state.base + '/stats').then(function (d) {
       var detail = $('detail');
       var t = d.totals;
       detail.appendChild(el('p', { text: 'Sessions: ' + t.sessionCount }));
@@ -5330,7 +7843,7 @@ var VIEW_HTML = `<!doctype html>
 
   function loadSessions() {
     single(false);
-    fetchJson('/api/sessions').then(function (d) {
+    fetchJson(state.base + '/sessions').then(function (d) {
       var list = $('list');
       var rows = (d && d.sessions) || [];
       if (rows.length === 0) { list.appendChild(el('div', { class: 'row muted', text: 'no sessions' })); return; }
@@ -5349,7 +7862,7 @@ var VIEW_HTML = `<!doctype html>
     row.classList.add('active');
     var detail = $('detail');
     clear(detail);
-    fetchJson('/api/sessions/' + encodeURIComponent(id)).then(function (d) {
+    fetchJson(state.base + '/sessions/' + encodeURIComponent(id)).then(function (d) {
       var s = d.session.session;
       detail.appendChild(el('h3', { text: s.label || id }));
       detail.appendChild(kv([
@@ -5382,7 +7895,7 @@ var VIEW_HTML = `<!doctype html>
 
   function loadTasks() {
     single(false);
-    fetchJson('/api/tasks').then(function (d) {
+    fetchJson(state.base + '/tasks').then(function (d) {
       var list = $('list');
       var rows = (d && d.tasks) || [];
       if (rows.length === 0) { list.appendChild(el('div', { class: 'row muted', text: 'no tasks' })); return; }
@@ -5401,7 +7914,7 @@ var VIEW_HTML = `<!doctype html>
     row.classList.add('active');
     var detail = $('detail');
     clear(detail);
-    fetchJson('/api/tasks/' + encodeURIComponent(id)).then(function (d) {
+    fetchJson(state.base + '/tasks/' + encodeURIComponent(id)).then(function (d) {
       detail.appendChild(el('h3', { text: (d.task && (d.task.title || d.task.label)) || id }));
       detail.appendChild(el('pre', { text: JSON.stringify(d.task, null, 2) }));
       if (d.body) detail.appendChild(el('pre', { text: d.body }));
@@ -5420,7 +7933,7 @@ var VIEW_HTML = `<!doctype html>
 
   function loadApprovals() {
     single(true);
-    fetchJson('/api/approvals').then(function (d) {
+    fetchJson(state.base + '/approvals').then(function (d) {
       var detail = $('detail');
       var groups = [['pending', d.pending || []], ['resolved', d.resolved || []]];
       groups.forEach(function (g) {
@@ -5445,14 +7958,14 @@ var VIEW_HTML = `<!doctype html>
 
   // --- wire up ------------------------------------------------------------
 
-  $('btn-refresh').addEventListener('click', function () { post('/api/refresh', 'Refresh all'); });
-  $('btn-import-claude').addEventListener('click', function () { post('/api/import/claude-code', 'Import claude-code'); });
-  $('btn-import-codex').addEventListener('click', function () { post('/api/import/codex', 'Import codex'); });
-  $('btn-gen-handoff').addEventListener('click', function () { post('/api/handoff/generate', 'Regenerate handoff'); });
-  $('btn-gen-decisions').addEventListener('click', function () { post('/api/decisions/generate', 'Regenerate decisions'); });
+  $('btn-back').addEventListener('click', function () { backToPortfolio(); });
+  $('btn-refresh').addEventListener('click', function () { post(state.base + '/refresh', 'Refresh all'); });
+  $('btn-import-claude').addEventListener('click', function () { post(state.base + '/import/claude-code', 'Import claude-code'); });
+  $('btn-import-codex').addEventListener('click', function () { post(state.base + '/import/codex', 'Import codex'); });
+  $('btn-gen-handoff').addEventListener('click', function () { post(state.base + '/handoff/generate', 'Regenerate handoff'); });
+  $('btn-gen-decisions').addEventListener('click', function () { post(state.base + '/decisions/generate', 'Regenerate decisions'); });
 
-  buildTabs();
-  loadTab('overview');
+  boot();
 })();
 </script>
 </body>
@@ -5467,6 +7980,8 @@ var HttpError = class extends Error {
   status;
 };
 var MAX_BODY_BYTES = 64 * 1024;
+var API_PREFIX = "/api/";
+var WS_PREFIX = "/api/ws/";
 function startViewServer(opts) {
   const { port, host = "127.0.0.1", deps } = opts;
   let actionQueue = Promise.resolve();
@@ -5480,7 +7995,7 @@ function startViewServer(opts) {
   };
   let boundPort = port;
   const getPort = () => boundPort;
-  return new Promise((resolve4, 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));
@@ -5491,7 +8006,7 @@ function startViewServer(opts) {
       const address = server.address();
       boundPort = isAddressInfo(address) ? address.port : port;
       server.off("error", reject);
-      resolve4({
+      resolve8({
         url: `http://${host}:${boundPort}`,
         port: boundPort,
         close: () => closeServer(server)
@@ -5503,8 +8018,8 @@ function isAddressInfo(value) {
   return value !== null && typeof value === "object";
 }
 function closeServer(server) {
-  return new Promise((resolve4) => {
-    server.close(() => resolve4());
+  return new Promise((resolve8) => {
+    server.close(() => resolve8());
     server.closeAllConnections();
   });
 }
@@ -5536,90 +8051,204 @@ async function handleGet(res, pathname, deps) {
     sendHtml(res, VIEW_HTML);
     return;
   }
-  if (pathname === "/api/overview") {
-    sendJson(res, 200, await overview(deps));
+  if (pathname === "/api/portfolio") {
+    sendJson(res, 200, await portfolio(deps));
     return;
   }
-  if (pathname === "/api/sessions") {
-    sendJson(res, 200, await sessionsList(deps));
+  const scoped = matchWsRoute(pathname);
+  if (scoped !== null) {
+    const ws = findWorkspace(deps, scoped.key);
+    if (ws === null) {
+      sendError(res, 404, "Unknown workspace");
+      return;
+    }
+    if (!await handleWorkspaceGet(res, scoped.sub, ws, deps.nowProvider)) {
+      sendError(res, 404, "Not found");
+    }
     return;
   }
-  const sessionId = matchId(pathname, "/api/sessions/");
-  if (sessionId !== null) {
-    sendJson(res, 200, await sessionDetail(deps, sessionId));
+  if (pathname.startsWith(API_PREFIX)) {
+    const sub = pathname.slice(API_PREFIX.length);
+    if (!await handleWorkspaceGet(res, sub, primaryWorkspace(deps), deps.nowProvider)) {
+      sendError(res, 404, "Not found");
+    }
     return;
   }
-  if (pathname === "/api/tasks") {
-    sendJson(res, 200, await tasksList(deps));
+  sendError(res, 404, "Not found");
+}
+async function handlePost(res, pathname, body, deps, runExclusive) {
+  const scoped = matchWsRoute(pathname);
+  if (scoped !== null) {
+    const ws = findWorkspace(deps, scoped.key);
+    if (ws === null) {
+      sendError(res, 404, "Unknown workspace");
+      return;
+    }
+    if (!await handleWorkspacePost(res, scoped.sub, ws, body, deps, runExclusive)) {
+      sendError(res, 404, "Not found");
+    }
     return;
   }
-  const taskId = matchId(pathname, "/api/tasks/");
-  if (taskId !== null) {
-    sendJson(res, 200, await taskDetail(deps, taskId));
+  if (pathname.startsWith(API_PREFIX)) {
+    const sub = pathname.slice(API_PREFIX.length);
+    if (!await handleWorkspacePost(res, sub, primaryWorkspace(deps), body, deps, runExclusive)) {
+      sendError(res, 404, "Not found");
+    }
     return;
   }
-  if (pathname === "/api/decisions") {
-    sendJson(res, 200, await decisionsView(deps));
-    return;
+  sendError(res, 404, "Not found");
+}
+async function handleWorkspaceGet(res, sub, ws, nowProvider) {
+  if (sub === "overview") {
+    sendJson(res, 200, await overview(ws, nowProvider));
+    return true;
   }
-  if (pathname === "/api/approvals") {
-    sendJson(res, 200, await approvalsView(deps));
-    return;
+  if (sub === "sessions") {
+    sendJson(res, 200, await sessionsList(ws, nowProvider));
+    return true;
   }
-  if (pathname === "/api/handoff") {
-    sendJson(res, 200, await handoffView(deps));
-    return;
+  const sessionId = matchId(sub, "sessions/");
+  if (sessionId !== null) {
+    sendJson(res, 200, await sessionDetail(ws, sessionId));
+    return true;
   }
-  if (pathname === "/api/stats") {
-    sendJson(res, 200, await computeWorkStats2({ paths: deps.paths, now: deps.nowProvider() }));
-    return;
+  if (sub === "tasks") {
+    sendJson(res, 200, await tasksList(ws));
+    return true;
   }
-  sendError(res, 404, "Not found");
+  const taskId = matchId(sub, "tasks/");
+  if (taskId !== null) {
+    sendJson(res, 200, await taskDetail(ws, taskId));
+    return true;
+  }
+  if (sub === "decisions") {
+    sendJson(res, 200, await decisionsView(ws, nowProvider));
+    return true;
+  }
+  if (sub === "approvals") {
+    sendJson(res, 200, await approvalsView(ws, nowProvider));
+    return true;
+  }
+  if (sub === "handoff") {
+    sendJson(res, 200, await handoffView(ws, nowProvider));
+    return true;
+  }
+  if (sub === "stats") {
+    sendJson(res, 200, await computeWorkStats2({ paths: ws.paths, now: nowProvider() }));
+    return true;
+  }
+  return false;
 }
-async function handlePost(res, pathname, body, deps, runExclusive) {
+async function handleWorkspacePost(res, sub, ws, body, deps, runExclusive) {
   const nowIso = deps.nowProvider().toISOString();
   const actionOptions = readActionOptions(body);
-  if (pathname === "/api/refresh") {
+  if (sub === "refresh") {
     const result = await runExclusive(
-      () => refreshAll({ options: actionOptions, ctx: deps.importCtx, paths: deps.paths, nowIso })
+      () => refreshAll({ options: actionOptions, ctx: ws.importCtx, paths: ws.paths, nowIso })
     );
     sendJson(res, 200, result);
-    return;
+    return true;
   }
-  if (pathname === "/api/import/claude-code") {
-    sendJson(res, 200, await runExclusive(() => importClaudeCode(actionOptions, deps.importCtx)));
-    return;
+  if (sub === "import/claude-code") {
+    sendJson(res, 200, await runExclusive(() => importClaudeCode(actionOptions, ws.importCtx)));
+    return true;
   }
-  if (pathname === "/api/import/codex") {
-    sendJson(res, 200, await runExclusive(() => importCodex(actionOptions, deps.importCtx)));
-    return;
+  if (sub === "import/codex") {
+    sendJson(res, 200, await runExclusive(() => importCodex(actionOptions, ws.importCtx)));
+    return true;
   }
-  if (pathname === "/api/handoff/generate") {
-    sendJson(res, 200, await runExclusive(() => regenerateHandoff(deps.paths, nowIso)));
-    return;
+  if (sub === "handoff/generate") {
+    sendJson(res, 200, await runExclusive(() => regenerateHandoff(ws.paths, nowIso)));
+    return true;
   }
-  if (pathname === "/api/decisions/generate") {
-    sendJson(res, 200, await runExclusive(() => regenerateDecisions(deps.paths, nowIso)));
-    return;
+  if (sub === "decisions/generate") {
+    sendJson(res, 200, await runExclusive(() => regenerateDecisions(ws.paths, nowIso)));
+    return true;
   }
-  sendError(res, 404, "Not found");
+  return false;
+}
+function primaryWorkspace(deps) {
+  const first = deps.workspaces[0];
+  if (first === void 0) throw new HttpError(500, "No workspace configured");
+  return first;
+}
+function findWorkspace(deps, key) {
+  return deps.workspaces.find((w) => w.key === key) ?? null;
+}
+function matchWsRoute(pathname) {
+  if (!pathname.startsWith(WS_PREFIX)) return null;
+  const rest = pathname.slice(WS_PREFIX.length);
+  const slash = rest.indexOf("/");
+  if (slash <= 0) return null;
+  const sub = rest.slice(slash + 1);
+  if (sub.length === 0) return null;
+  let key;
+  try {
+    key = decodeURIComponent(rest.slice(0, slash));
+  } catch {
+    return null;
+  }
+  if (key.length === 0 || key.includes("/") || key.includes("\0")) return null;
+  return { key, sub };
+}
+async function portfolio(deps) {
+  const nowIso = deps.nowProvider().toISOString();
+  const workspaces = await Promise.all(deps.workspaces.map((ws) => portfolioCard(ws, nowIso)));
+  for (let i = 0; i < deps.workspaces.length; i++) {
+    const card = workspaces[i];
+    const ws = deps.workspaces[i];
+    if (ws !== void 0 && card !== void 0 && card.initialized === true && card.error === void 0) {
+      card.staleness = await captureStaleness(ws, nowIso);
+    }
+  }
+  return { mode: deps.mode, generatedAt: nowIso, workspaces };
+}
+async function portfolioCard(ws, nowIso) {
+  const base = { key: ws.key, label: ws.label, repoRoot: ws.repoRoot };
+  if (!ws.initialized) {
+    return ws.manifestError !== void 0 ? { ...base, initialized: false, error: ws.manifestError } : { ...base, initialized: false };
+  }
+  try {
+    const s = await summarizeOrientation({ paths: ws.paths, nowIso });
+    return {
+      ...base,
+      initialized: true,
+      sessionCount: s.sessionCount,
+      suspectCount: s.suspects.length,
+      inFlightCount: s.inFlightTasks.length,
+      pendingApprovals: s.pendingApprovals.map((a) => ({
+        risk: a.risk,
+        kind: a.kind,
+        expired: a.expired
+      })),
+      latestDecision: s.latestDecision !== null ? { title: s.latestDecision.title } : null,
+      latestSession: s.latestSession !== null ? { label: s.latestSession.label, status: s.latestSession.status } : null,
+      freshness: { newestStartedAt: s.freshness.newestStartedAt, bySource: s.freshness.bySource }
+    };
+  } catch (error) {
+    return { ...base, initialized: true, error: pathlessMessage(error) };
+  }
+}
+async function captureStaleness(ws, nowIso) {
+  const probe = await probeStaleness({ ctx: ws.importCtx, paths: ws.paths, nowIso });
+  return probe === null ? { checked: false } : { checked: true, ...probe };
 }
-async function overview(deps) {
+async function overview(ws, nowProvider) {
   let manifest;
   try {
-    manifest = await readManifest8(deps.paths);
+    manifest = await readManifest11(ws.paths);
   } catch (error) {
-    if (findErrorCode14(error, "ENOENT")) {
-      return { initialized: false, repoRoot: deps.repoRoot };
+    if (findErrorCode16(error, "ENOENT")) {
+      return { initialized: false, repoRoot: ws.repoRoot };
     }
     throw error;
   }
-  const nowIso = deps.nowProvider().toISOString();
-  const handoff = await renderHandoff3({ paths: deps.paths, nowIso });
-  const approvals = await enumerateApprovals2(deps.paths);
+  const nowIso = nowProvider().toISOString();
+  const handoff = await renderHandoff3({ paths: ws.paths, nowIso });
+  const approvals = await enumerateApprovals2(ws.paths);
   return {
     initialized: true,
-    repoRoot: deps.repoRoot,
+    repoRoot: ws.repoRoot,
     workspace: {
       id: manifest.workspace.id,
       name: manifest.workspace.name,
@@ -5637,8 +8266,8 @@ async function overview(deps) {
     generatedAt: nowIso
   };
 }
-async function sessionsList(deps) {
-  const entries = await loadSessionEntries3(deps.paths, { now: deps.nowProvider() });
+async function sessionsList(ws, nowProvider) {
+  const entries = await loadSessionEntries3(ws.paths, { now: nowProvider() });
   const sessions = entries.map((entry) => ({
     sessionId: entry.sessionId,
     label: entry.session.session.label ?? null,
@@ -5653,10 +8282,10 @@ async function sessionsList(deps) {
   })).reverse();
   return { sessions };
 }
-async function sessionDetail(deps, sessionId) {
+async function sessionDetail(ws, sessionId) {
   let session;
   try {
-    session = await readSessionYaml3(deps.paths, sessionId);
+    session = await readSessionYaml3(ws.paths, sessionId);
   } catch (error) {
     if (error instanceof Error && error.message === "YAML file not found") {
       throw new HttpError(404, "Session not found");
@@ -5664,19 +8293,19 @@ async function sessionDetail(deps, sessionId) {
     throw error;
   }
   try {
-    const events = await readAllEvents2(join8(deps.paths.sessions, sessionId));
+    const events = await readAllEvents2(join11(ws.paths.sessions, sessionId));
     return { session, events };
   } catch {
     return { session, events: [], degraded: true };
   }
 }
-async function tasksList(deps) {
-  const entries = await loadTaskEntries2(deps.paths);
+async function tasksList(ws) {
+  const entries = await loadTaskEntries2(ws.paths);
   return { tasks: entries.map((entry) => entry.task).reverse() };
 }
-async function taskDetail(deps, taskId) {
+async function taskDetail(ws, taskId) {
   try {
-    const doc = await readTaskFile2(deps.paths, taskId);
+    const doc = await readTaskFile2(ws.paths, taskId);
     return { task: doc.task, body: doc.body };
   } catch (error) {
     if (error instanceof Error && error.message === "Task file not found") {
@@ -5685,22 +8314,22 @@ async function taskDetail(deps, taskId) {
     throw error;
   }
 }
-async function decisionsView(deps) {
-  const fromDisk = await readMarkdownFile4(deps.paths.files.decisions);
+async function decisionsView(ws, nowProvider) {
+  const fromDisk = await readMarkdownFile5(ws.paths.files.decisions);
   if (fromDisk !== null) {
     return { body: fromDisk, fromDisk: true };
   }
-  const nowIso = deps.nowProvider().toISOString();
-  const result = await renderDecisions3({ paths: deps.paths, nowIso });
+  const nowIso = nowProvider().toISOString();
+  const result = await renderDecisions3({ paths: ws.paths, nowIso });
   return { body: result.body, decisionCount: result.decisionCount, fromDisk: false };
 }
-async function approvalsView(deps) {
-  const now = deps.nowProvider();
-  const ids = await enumerateApprovals2(deps.paths);
+async function approvalsView(ws, nowProvider) {
+  const now = nowProvider();
+  const ids = await enumerateApprovals2(ws.paths);
   const toViews = async (list) => {
     const views = [];
     for (const id of list) {
-      const loaded = await loadApproval2(deps.paths, id);
+      const loaded = await loadApproval2(ws.paths, id);
       if (loaded === null) continue;
       views.push({ id, expired: isLazyExpired2(loaded.approval, now), approval: loaded.approval });
     }
@@ -5708,13 +8337,13 @@ async function approvalsView(deps) {
   };
   return { pending: await toViews(ids.pending), resolved: await toViews(ids.resolved) };
 }
-async function handoffView(deps) {
-  const fromDisk = await readMarkdownFile4(deps.paths.files.handoff);
+async function handoffView(ws, nowProvider) {
+  const fromDisk = await readMarkdownFile5(ws.paths.files.handoff);
   if (fromDisk !== null) {
     return { body: fromDisk, fromDisk: true };
   }
-  const nowIso = deps.nowProvider().toISOString();
-  const result = await renderHandoff3({ paths: deps.paths, nowIso });
+  const nowIso = nowProvider().toISOString();
+  const result = await renderHandoff3({ paths: ws.paths, nowIso });
   return { body: result.body, fromDisk: false };
 }
 function readActionOptions(body) {
@@ -5804,12 +8433,22 @@ 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;
 }
+function collectPath3(value, previous = []) {
+  return [...previous, value];
+}
 function registerViewCommand(program) {
-  program.command("view").description("Open a local web UI to browse provenance and run imports (localhost only)").option("--port <number>", "Port to listen on (default 4319)", parsePort).option("--no-open", "Do not open the browser automatically").option("-v, --verbose", "Show error causes").action(async (options) => {
+  program.command("view").description("Open a local web UI to browse provenance and run imports (localhost only)").option("--port <number>", "Port to listen on (default 4319)", parsePort).option("--no-open", "Do not open the browser automatically").option(
+    "--portfolio",
+    "Serve every workspace listed in ~/.basou/portfolio.yaml (cross-repo orientation)"
+  ).option(
+    "--workspace <path>",
+    "Workspace repo path to include (repeatable; implies portfolio mode; resolved against the cwd)",
+    collectPath3
+  ).option("--check", "Run the portfolio safety preflight and exit (no server)").option("--skip-safety-check", "Skip the portfolio safety preflight on start (not recommended)").option("-v, --verbose", "Show error causes").action(async (options) => {
     await runView(options);
   });
 }
@@ -5823,23 +8462,37 @@ async function runView(options, ctx = {}) {
 }
 async function doRunView(options, ctx) {
   const cwd = ctx.cwd ?? process.cwd();
-  const repositoryRoot = await resolveRepositoryRootForView(cwd);
-  const paths = basouPaths15(repositoryRoot);
-  await assertWorkspaceInitialized12(paths.root);
-  const deps = {
-    paths,
-    repoRoot: repositoryRoot,
-    importCtx: {
-      cwd: repositoryRoot,
-      ...ctx.claudeProjectsDir !== void 0 ? { claudeProjectsDir: ctx.claudeProjectsDir } : {},
-      ...ctx.codexSessionsDir !== void 0 ? { codexSessionsDir: ctx.codexSessionsDir } : {}
-    },
-    nowProvider: ctx.nowProvider ?? (() => /* @__PURE__ */ new Date())
-  };
+  const workspaceFlags = options.workspace ?? [];
+  const isPortfolio = workspaceFlags.length > 0 || options.portfolio === true;
+  const deps = isPortfolio ? await buildPortfolioDeps(workspaceFlags, ctx, cwd) : await buildSingleDeps(ctx, cwd);
+  if (options.check === true) {
+    const result = await checkPortfolioSafety(deps.workspaces);
+    for (const line of formatSafetyReport(result)) console.log(line);
+    if (result.findings.length > 0) process.exitCode = 1;
+    return;
+  }
+  if (deps.mode === "portfolio" && options.skipSafetyCheck !== true) {
+    const result = await checkPortfolioSafety(deps.workspaces);
+    const blocking = result.findings.filter((f) => f.kind === "footprint" || f.kind === "overlap");
+    if (blocking.length > 0) {
+      for (const line of formatSafetyReport(result)) console.error(line);
+      throw new Error(
+        "Portfolio safety preflight failed (see findings above). Fix the monitored repos, or re-run with --skip-safety-check to override."
+      );
+    }
+    if (result.findings.length > 0) {
+      console.error(
+        `Portfolio safety: ${result.findings.length} unverifiable item(s) \u2014 the read-only view will still open; run 'basou view --check' for detail.`
+      );
+    }
+  }
   const port = options.port ?? DEFAULT_PORT;
   const handle = await startListening(port, deps);
   try {
     console.log(`basou view running at ${handle.url}`);
+    if (deps.mode === "portfolio") {
+      console.log(`Portfolio mode: ${deps.workspaces.length} workspace(s).`);
+    }
     console.log(
       "Localhost only, no authentication. Do not expose this port beyond your machine. Press Ctrl+C to stop."
     );
@@ -5852,11 +8505,69 @@ async function doRunView(options, ctx) {
     await handle.close();
   }
 }
+async function buildSingleDeps(ctx, cwd) {
+  const repositoryRoot = await resolveRepositoryRootForView(cwd);
+  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: 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 = resolve7(spec.path);
+    if (seenPath.has(repoRoot)) continue;
+    seenPath.add(repoRoot);
+    const entry = await buildWorkspaceEntry(repoRoot, ctx, spec.label);
+    let key = entry.key;
+    for (let n = 1; seenKey.has(key); n++) key = `${entry.key}-${n}`;
+    seenKey.add(key);
+    entries.push({ ...entry, key });
+  }
+  if (entries.length === 0) throw new Error("No workspaces to show.");
+  return { workspaces: entries, mode: "portfolio", nowProvider: nowProviderOf(ctx) };
+}
+async function buildWorkspaceEntry(repoRoot, ctx, labelOverride) {
+  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 readManifest12(paths);
+    return {
+      key: manifest.workspace.id,
+      label: labelOverride ?? manifest.workspace.name,
+      paths,
+      repoRoot,
+      importCtx,
+      initialized: true
+    };
+  } catch (error) {
+    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 ?? basename5(repoRoot),
+      paths,
+      repoRoot,
+      importCtx,
+      initialized: false,
+      ...notFound ? {} : { manifestError: "manifest unreadable or invalid" }
+    };
+  }
+}
+function nowProviderOf(ctx) {
+  return ctx.nowProvider ?? (() => /* @__PURE__ */ new Date());
+}
 async function startListening(port, deps) {
   try {
     return await startViewServer({ port, deps });
   } catch (error) {
-    if (findErrorCode15(error, "EADDRINUSE")) {
+    if (findErrorCode17(error, "EADDRINUSE")) {
       throw new Error(`Port ${port} is already in use. Pass --port <n> to choose another.`, {
         cause: error
       });
@@ -5879,7 +8590,7 @@ function openInBrowser(url, override) {
   }
 }
 function waitForShutdown(signal) {
-  return new Promise((resolve4) => {
+  return new Promise((resolve8) => {
     const cleanup = () => {
       process.off("SIGINT", onSignal);
       process.off("SIGTERM", onSignal);
@@ -5887,18 +8598,18 @@ function waitForShutdown(signal) {
     };
     const onSignal = () => {
       cleanup();
-      resolve4();
+      resolve8();
     };
     const onAbort = () => {
       cleanup();
-      resolve4();
+      resolve8();
     };
     process.on("SIGINT", onSignal);
     process.on("SIGTERM", onSignal);
     if (signal !== void 0) {
       if (signal.aborted) {
         cleanup();
-        resolve4();
+        resolve8();
         return;
       }
       signal.addEventListener("abort", onAbort);
@@ -5907,7 +8618,7 @@ function waitForShutdown(signal) {
 }
 async function resolveRepositoryRootForView(cwd) {
   try {
-    return await resolveRepositoryRoot16(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'.", {
@@ -5917,11 +8628,11 @@ async function resolveRepositoryRootForView(cwd) {
     throw error;
   }
 }
-async function assertWorkspaceInitialized12(basouRoot) {
+async function assertWorkspaceInitialized14(basouRoot) {
   try {
-    await assertBasouRootSafe15(basouRoot);
+    await assertBasouRootSafe17(basouRoot);
   } catch (error) {
-    if (findErrorCode15(error, "ENOENT")) {
+    if (findErrorCode17(error, "ENOENT")) {
       throw new Error("Workspace not initialized. Run 'basou init' first.");
     }
     throw error;
@@ -5947,10 +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 {