@basou/core 0.11.0 → 0.13.0

package/dist/index.js

@@ -102,6 +102,14 @@ function sumDurations(intervals) {
   return total;
 }
 
+// src/adapters/session-label.ts
+function sessionLabelDateSpan(startIso, endIso) {
+  const a = startIso.slice(0, 10);
+  const b = endIso.slice(0, 10);
+  if (a === b) return a;
+  return a < b ? `${a}..${b}` : `${b}..${a}`;
+}
+
 // src/adapters/claude-code/transcript-importer.ts
 var CLAUDE_IMPORT_SOURCE = "claude-code-import";
 function claudeTranscriptToImportPayload(records, options) {
@@ -201,8 +209,7 @@ function claudeTranscriptToImportPayload(records, options) {
   const externalId = options.externalId ?? claudeSessionId;
   const commandCount = derived.reduce((n, e) => e.type === "command_executed" ? n + 1 : n, 0);
   const fileCount = relatedFiles.size;
-  const date = minTs.slice(0, 10);
-  const label = `claude-code ${date}: ${commandCount} ${commandCount === 1 ? "command" : "commands"}, ${fileCount} ${fileCount === 1 ? "file" : "files"}`;
+  const label = `claude-code ${sessionLabelDateSpan(minTs, maxTs)}: ${commandCount} ${commandCount === 1 ? "command" : "commands"}, ${fileCount} ${fileCount === 1 ? "file" : "files"}`;
   const active = engagementTsMs.length >= 2 ? activeTimeFromTimestamps(engagementTsMs, ACTIVE_GAP_CAP_MS) : void 0;
   const metricsFields = {
     ...outputTokens > 0 ? { output_tokens: outputTokens } : {},
@@ -414,8 +421,7 @@ function codexRolloutToImportPayload(records, options) {
   ];
   const externalId = options.externalId ?? codexSessionId;
   const commandCount = derived.length;
-  const date = minTs.slice(0, 10);
-  const label = `codex ${date}: ${commandCount} ${commandCount === 1 ? "command" : "commands"}`;
+  const label = `codex ${sessionLabelDateSpan(minTs, maxTs)}: ${commandCount} ${commandCount === 1 ? "command" : "commands"}`;
   const minTsMs = Date.parse(minTs);
   const turnIntervals = [];
   let machineActiveMs = 0;
@@ -905,7 +911,12 @@ var TaskArchivedEventSchema = BaseEventSchema.extend({
 }).strict();
 var NoteAddedEventSchema = BaseEventSchema.extend({
   type: z3.literal("note_added"),
-  body: z3.string()
+  body: z3.string(),
+  // `next_step` marks a note authored by `basou note` as the operator's resume
+  // hint, which orientation surfaces as the next starting point. Absent (the
+  // `basou session note` default) is a plain annotation orientation does not
+  // surface. Optional so pre-existing note_added events remain valid.
+  kind: z3.enum(["note", "next_step"]).optional()
 });
 var AdapterOutputEventSchema = BaseEventSchema.extend({
   type: z3.literal("adapter_output"),
@@ -1720,6 +1731,8 @@ function splitLinesBytes2(buf) {
 }
 
 // src/git/snapshot.ts
+import { readdir as readdir3, stat as stat2 } from "fs/promises";
+import { join as join9 } from "path";
 import { simpleGit } from "simple-git";
 
 // src/storage/status.ts
@@ -1757,19 +1770,19 @@ var DIRECTORY_CHECKS = {
   tmp: (p) => p.tmp
 };
 async function assertBasouRootSafe(rootPath) {
-  let stat3;
+  let stat4;
   try {
-    stat3 = await fsp.lstat(rootPath);
+    stat4 = await fsp.lstat(rootPath);
   } catch (error) {
     if (hasErrorCode2(error) && error.code === "ENOENT") {
       throw new Error("Basou workspace not found", { cause: error });
     }
     throw new Error("Failed to inspect .basou root", { cause: error });
   }
-  if (stat3.isSymbolicLink()) {
+  if (stat4.isSymbolicLink()) {
     throw new Error(".basou root is a symlink; refusing to operate");
   }
-  if (!stat3.isDirectory()) {
+  if (!stat4.isDirectory()) {
     throw new Error(".basou root exists but is not a directory");
   }
 }
@@ -1849,6 +1862,14 @@ function isGitNotFound(error) {
   }
   return false;
 }
+function isNotAGitRepository(error) {
+  let cur = error;
+  for (let i = 0; i < 4 && cur instanceof Error; i++) {
+    if (/not a git repository/i.test(cur.message)) return true;
+    cur = cur.cause;
+  }
+  return false;
+}
 async function resolveRepositoryRoot(cwd) {
   const git = safeSimpleGit(cwd);
   try {
@@ -1864,8 +1885,53 @@ async function resolveRepositoryRoot(cwd) {
     if (error instanceof Error && error.message === "Not a git repository") {
       throw error;
     }
-    throw new Error("Not a git repository", { cause: error });
+    if (isNotAGitRepository(error)) {
+      throw new Error("Not a git repository", { cause: error });
+    }
+    throw new Error("Git command failed", { cause: error });
+  }
+}
+async function resolveBasouRepositoryRoot(cwd, opts) {
+  try {
+    return await resolveRepositoryRoot(cwd);
+  } catch (error) {
+    if (!(error instanceof Error) || error.message !== "Not a git repository") throw error;
+    const linked = await findLinkedBasouRepos(cwd);
+    const only = linked[0];
+    if (only !== void 0 && linked.length === 1) {
+      opts?.onRedirect?.({ via: only.name, root: only.root });
+      return only.root;
+    }
+    if (linked.length > 1) {
+      const names = linked.map((l) => l.name).join(", ");
+      throw new Error(
+        `Ambiguous workspace view: ${linked.length} linked repos have a .basou store (${names}). cd into the one you want and re-run.`
+      );
+    }
+    throw error;
+  }
+}
+async function findLinkedBasouRepos(dir) {
+  const entries = await readdir3(dir, { withFileTypes: true }).catch(() => null);
+  if (entries === null) return [];
+  const byRoot = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    if (!entry.isSymbolicLink()) continue;
+    let root;
+    try {
+      root = await resolveRepositoryRoot(join9(dir, entry.name));
+    } catch {
+      continue;
+    }
+    try {
+      if (!(await stat2(join9(root, ".basou"))).isDirectory()) continue;
+    } catch {
+      continue;
+    }
+    const existing = byRoot.get(root);
+    if (existing === void 0 || entry.name < existing) byRoot.set(root, entry.name);
   }
+  return [...byRoot.entries()].map(([root, name]) => ({ name, root })).sort((a, b) => a.name.localeCompare(b.name));
 }
 async function tryRemoteUrl(repositoryRoot) {
   const git = safeSimpleGit(repositoryRoot);
@@ -2013,12 +2079,12 @@ function parseDiffNameStatus(raw) {
 }
 
 // src/handoff/handoff-renderer.ts
-import { join as join12 } from "path";
+import { join as join13 } from "path";
 
 // src/storage/tasks.ts
 import { createHash as createHash2 } from "crypto";
-import { mkdir as mkdir3, readdir as readdir3, readFile as readFile7, rename as rename2, stat as stat2, unlink as unlink3 } from "fs/promises";
-import { join as join11 } from "path";
+import { mkdir as mkdir3, readdir as readdir4, readFile as readFile7, rename as rename2, stat as stat3, unlink as unlink3 } from "fs/promises";
+import { join as join12 } from "path";
 import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
 import { z as z8 } from "zod";
 
@@ -2062,7 +2128,7 @@ var TaskSchema = z6.object({
 // src/storage/ad-hoc-session.ts
 import { mkdir as mkdir2, rm } from "fs/promises";
 import { homedir } from "os";
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 
 // src/lib/path-sanitizer.ts
 import { posix as path } from "path";
@@ -2142,8 +2208,8 @@ async function createAdHocSessionWithEvent(input) {
       taskId: input.taskId ?? null
     })
   );
-  const sessionDir = join9(input.paths.sessions, sessionId);
-  const sessionYamlPath = join9(sessionDir, "session.yaml");
+  const sessionDir = join10(input.paths.sessions, sessionId);
+  const sessionYamlPath = join10(sessionDir, "session.yaml");
   const lock = await acquireLock(input.paths, "session", sessionId);
   let bulkResult = null;
   try {
@@ -2293,7 +2359,7 @@ function assertTargetEventIdentity(event, expectedSessionId, expectedEventId) {
 
 // src/storage/task-index.ts
 import { readFile as readFile6 } from "fs/promises";
-import { join as join10 } from "path";
+import { join as join11 } from "path";
 
 // src/schemas/task-index.schema.ts
 import { z as z7 } from "zod";
@@ -2312,7 +2378,7 @@ var TASK_INDEX_SCHEMA_VERSION = "0.1.0";
 
 // src/storage/task-index.ts
 function taskIndexPath(paths) {
-  return join10(paths.tasks, "index.json");
+  return join11(paths.tasks, "index.json");
 }
 async function readTaskIndex(paths) {
   const filePath = taskIndexPath(paths);
@@ -2426,7 +2492,7 @@ function splitFrontMatter(raw) {
   return { yamlText, body };
 }
 async function readTaskFile(paths, taskId) {
-  const filePath = join11(paths.tasks, `${taskId}.md`);
+  const filePath = join12(paths.tasks, `${taskId}.md`);
   let raw;
   try {
     raw = await readFile7(filePath, "utf8");
@@ -2459,7 +2525,7 @@ async function readTaskFile(paths, taskId) {
 }
 async function writeTaskFile(paths, taskId, doc, options) {
   const validated = TaskSchema.parse(doc.task);
-  const filePath = join11(paths.tasks, `${taskId}.md`);
+  const filePath = join12(paths.tasks, `${taskId}.md`);
   const yamlText = stringifyYaml(validated);
   const trimmedBody = doc.body.length === 0 ? "" : `
 ${doc.body.endsWith("\n") ? doc.body : `${doc.body}
@@ -2511,7 +2577,7 @@ async function enumerateTaskIds(paths) {
 async function enumerateTaskIdsFromDisk(paths) {
   let entries;
   try {
-    entries = (await readdir3(paths.tasks, { withFileTypes: true })).filter((d) => d.isFile()).map((d) => d.name);
+    entries = (await readdir4(paths.tasks, { withFileTypes: true })).filter((d) => d.isFile()).map((d) => d.name);
   } catch (error) {
     if (findErrorCode(error, "ENOENT")) return [];
     throw new Error("Failed to enumerate tasks", { cause: error });
@@ -2544,12 +2610,12 @@ async function safeUpdateTaskIndex(paths, op) {
 }
 var ARCHIVE_DIR_NAME = "archive";
 function archiveTasksDir(paths) {
-  return join11(paths.tasks, ARCHIVE_DIR_NAME);
+  return join12(paths.tasks, ARCHIVE_DIR_NAME);
 }
 async function enumerateArchivedTaskIds(paths) {
   let entries;
   try {
-    entries = (await readdir3(archiveTasksDir(paths), { withFileTypes: true })).filter((d) => d.isFile()).map((d) => d.name);
+    entries = (await readdir4(archiveTasksDir(paths), { withFileTypes: true })).filter((d) => d.isFile()).map((d) => d.name);
   } catch (error) {
     if (findErrorCode(error, "ENOENT")) return [];
     throw new Error("Failed to enumerate archived tasks", { cause: error });
@@ -2574,7 +2640,7 @@ async function readTaskFileWithArchiveFallback(paths, taskId) {
       throw error;
     }
   }
-  const archiveFilePath = join11(archiveTasksDir(paths), `${taskId}.md`);
+  const archiveFilePath = join12(archiveTasksDir(paths), `${taskId}.md`);
   let raw;
   try {
     raw = await readFile7(archiveFilePath, "utf8");
@@ -2868,7 +2934,7 @@ async function createTaskAttachLocked(input) {
       ...sessionDoc,
       session: { ...sessionDoc.session, task_id: input.taskId }
     };
-    await overwriteYamlFile(join11(input.paths.sessions, input.sessionId, "session.yaml"), updated);
+    await overwriteYamlFile(join12(input.paths.sessions, input.sessionId, "session.yaml"), updated);
   } catch (error) {
     throw new TaskWriteAfterEventError({
       taskId: input.taskId,
@@ -3127,17 +3193,17 @@ function buildUpdatedDoc(input) {
   return { task: next, body: input.currentDoc.body };
 }
 async function computeTaskMdSnapshot(paths, taskId) {
-  const filePath = join11(paths.tasks, `${taskId}.md`);
-  const [stats, raw] = await Promise.all([stat2(filePath), readFile7(filePath)]);
+  const filePath = join12(paths.tasks, `${taskId}.md`);
+  const [stats, raw] = await Promise.all([stat3(filePath), readFile7(filePath)]);
   const hash = createHash2("sha256").update(raw).digest("hex");
   return { mtimeMs: stats.mtimeMs, hash };
 }
 async function readTaskFileWithSnapshot(paths, taskId) {
-  const filePath = join11(paths.tasks, `${taskId}.md`);
+  const filePath = join12(paths.tasks, `${taskId}.md`);
   let rawBuffer;
   let stats;
   try {
-    [rawBuffer, stats] = await Promise.all([readFile7(filePath), stat2(filePath)]);
+    [rawBuffer, stats] = await Promise.all([readFile7(filePath), stat3(filePath)]);
   } catch (error) {
     if (findErrorCode(error, "ENOENT")) {
       throw new Error("Task file not found", { cause: error });
@@ -3625,7 +3691,7 @@ async function deleteTaskLocked(input) {
   });
   const eventId = adHoc.targetEventIds[0];
   try {
-    await unlink3(join11(input.paths.tasks, `${input.taskId}.md`));
+    await unlink3(join12(input.paths.tasks, `${input.taskId}.md`));
   } catch (error) {
     throw new TaskWriteAfterEventError({
       taskId: input.taskId,
@@ -3697,8 +3763,8 @@ async function archiveTaskLocked(input) {
     );
     await mkdir3(archiveTasksDir(input.paths), { recursive: true });
     await rename2(
-      join11(input.paths.tasks, `${input.taskId}.md`),
-      join11(archiveTasksDir(input.paths), `${input.taskId}.md`)
+      join12(input.paths.tasks, `${input.taskId}.md`),
+      join12(archiveTasksDir(input.paths), `${input.taskId}.md`)
     );
   } catch (error) {
     throw new TaskWriteAfterEventError({
@@ -3734,7 +3800,7 @@ async function renderHandoff(input) {
   const tasksCreated = [];
   const tasksStatusChanged = [];
   for (const entry of entries) {
-    const sessionDir = join12(input.paths.sessions, entry.sessionId);
+    const sessionDir = join13(input.paths.sessions, entry.sessionId);
     try {
       for await (const ev of replayEvents(sessionDir, {
         onWarning: (w) => input.onWarning?.(w, entry.sessionId)
@@ -3850,11 +3916,11 @@ function formatHandoffBody(args) {
   if (args.latestSession !== void 0) {
     const status = args.latestSession.session.session.status;
     const label = args.latestSession.session.session.label;
-    const shortId = shortIdWithPrefix(args.latestSession.sessionId);
+    const shortId2 = shortIdWithPrefix(args.latestSession.sessionId);
     if (label !== void 0 && label !== "") {
-      lines.push(`- \u6700\u7D42 session: ${label} (${status}) [${shortId}]`);
+      lines.push(`- \u6700\u7D42 session: ${label} (${status}) [${shortId2}]`);
     } else {
-      lines.push(`- \u6700\u7D42 session: ${shortId} (${status})`);
+      lines.push(`- \u6700\u7D42 session: ${shortId2} (${status})`);
     }
   } else {
     lines.push("- \u6700\u7D42 session: (no live sessions)");
@@ -4091,94 +4157,1194 @@ async function resolveIdInternal(paths, input, kind, options = {}) {
   return matches[0];
 }
 
-// src/report/report-renderer.ts
+// src/orientation/orientation-renderer.ts
 import { join as join14 } from "path";
 
-// src/stats/work-stats.ts
-import { join as join13 } from "path";
-function resolveTimeZone(timeZone) {
-  if (timeZone !== void 0 && timeZone.length > 0) return timeZone;
-  return Intl.DateTimeFormat().resolvedOptions().timeZone;
+// src/storage/manifest.ts
+import { lstat as lstat3 } from "fs/promises";
+
+// src/schemas/manifest.schema.ts
+import { z as z9 } from "zod";
+var ProjectSchema = z9.looseObject({
+  name: z9.string().optional(),
+  description: z9.string().optional(),
+  repository_url: z9.string().nullable().optional()
+});
+var CapabilitiesSchema = z9.looseObject({
+  enabled: z9.array(z9.string())
+});
+var ApprovalConfigSchema = z9.looseObject({
+  required_for: z9.array(z9.string()).optional(),
+  default_risk_level: z9.enum(["low", "medium", "high", "critical"])
+});
+var ClaudeCodeAdapterConfigSchema = z9.looseObject({
+  enabled: z9.boolean(),
+  config_path: z9.string().optional()
+});
+var AdaptersSchema = z9.looseObject({
+  "claude-code": ClaudeCodeAdapterConfigSchema
+});
+var GitConfigSchema = z9.looseObject({
+  events_log: z9.enum(["ignore", "commit"]).default("ignore")
+});
+var SOURCE_ROOT_PATTERN = /^(?![~/\\])(?![A-Za-z]:)(?!\s)[^\0\\]*[^\0\\\s]$/;
+var SourceRootSchema = z9.string().min(1).regex(SOURCE_ROOT_PATTERN, {
+  message: "source_roots entries must be relative paths (no absolute path, '~', '\\', or null byte)"
+});
+var ImportConfigSchema = z9.looseObject({
+  source_roots: z9.array(SourceRootSchema).min(1).optional()
+});
+var RepoVisibilitySchema = z9.enum(["public", "private", "future-public"]);
+var RepoLanguageSchema = z9.enum(["en", "ja", "en+ja"]);
+var PublishKindSchema = z9.enum(["web", "npm"]);
+var PublishTargetSchema = z9.looseObject({
+  kind: PublishKindSchema,
+  visibility: RepoVisibilitySchema.optional(),
+  language: RepoLanguageSchema.optional()
+});
+var RepoEntrySchema = z9.looseObject({
+  path: SourceRootSchema,
+  visibility: RepoVisibilitySchema.optional(),
+  language: RepoLanguageSchema.optional(),
+  publishes: z9.array(PublishTargetSchema).optional()
+});
+var WorkspaceMetaSchema = z9.looseObject({
+  id: WorkspaceIdSchema,
+  name: z9.string().min(1),
+  created_at: IsoTimestampSchema,
+  updated_at: IsoTimestampSchema,
+  /**
+   * The generated workspace view: a throwaway directory that aggregates the
+   * roster repos via symlinks (one `<repo-basename>` symlink per repo). A path
+   * relative to the manifest root, reusing the machine-portable source-root
+   * constraint. Absent for a solo project (no view needed); `basou project
+   * workspace` reconciles the view's symlinks to the declared roster.
+   */
+  view: SourceRootSchema.optional()
+});
+var ManifestSchema = z9.looseObject({
+  schema_version: SchemaVersionSchema,
+  basou_version: z9.literal("0.1.0"),
+  workspace: WorkspaceMetaSchema,
+  project: ProjectSchema,
+  capabilities: CapabilitiesSchema,
+  approval: ApprovalConfigSchema,
+  adapters: AdaptersSchema,
+  git: GitConfigSchema,
+  import: ImportConfigSchema.optional(),
+  repos: z9.array(RepoEntrySchema).min(1).optional()
+});
+var KNOWN_TOP_LEVEL_KEYS = new Set(Object.keys(ManifestSchema.shape));
+function unknownManifestKeys(manifest) {
+  return Object.keys(manifest).filter((k) => !KNOWN_TOP_LEVEL_KEYS.has(k)).sort();
 }
-var STATUS_ORDER = [
-  "completed",
-  "failed",
-  "running",
-  "interrupted",
-  "waiting_approval",
-  "initialized",
-  "imported",
-  "archived"
-];
-async function computeWorkStats(input) {
-  const { now } = input;
-  const timeZone = resolveTimeZone(input.timeZone);
-  const unreadableEmitted = /* @__PURE__ */ new Set();
-  const wrappedSkip = (sid, reason) => {
-    if (reason === "events_jsonl_unreadable") unreadableEmitted.add(sid);
-    input.onSessionSkip?.(sid, reason);
+
+// src/storage/manifest.ts
+function createManifest(input) {
+  if (input.workspaceName.length === 0) {
+    throw new Error("Workspace name is empty. Pass --name explicitly.");
+  }
+  const now = (input.now ?? /* @__PURE__ */ new Date()).toISOString();
+  const workspaceId = input.workspaceId ?? prefixedUlid("ws");
+  const project = {
+    ...input.projectName !== void 0 ? { name: input.projectName } : {},
+    ...input.projectDescription !== void 0 ? { description: input.projectDescription } : {},
+    ...input.repositoryUrl !== void 0 ? { repository_url: input.repositoryUrl } : {}
   };
-  const loadOpts = { now, onSkip: wrappedSkip };
+  const manifest = {
+    schema_version: "0.1.0",
+    basou_version: "0.1.0",
+    workspace: {
+      id: workspaceId,
+      name: input.workspaceName,
+      created_at: now,
+      updated_at: now
+    },
+    project,
+    capabilities: {
+      enabled: ["core", "claude-code-adapter", "terminal-recording", "git-capability", "approval"]
+    },
+    approval: {
+      required_for: ["destructive_command", "external_send"],
+      default_risk_level: "medium"
+    },
+    adapters: {
+      "claude-code": { enabled: true }
+    },
+    git: { events_log: "ignore" },
+    ...input.sourceRoots !== void 0 && input.sourceRoots.length > 0 ? { import: { source_roots: input.sourceRoots } } : {}
+  };
+  return ManifestSchema.parse(manifest);
+}
+async function writeManifest(paths, manifest, options) {
+  const force = options?.force === true;
+  const validated = ManifestSchema.parse(manifest);
+  if (!force) {
+    let existed = false;
+    try {
+      await lstat3(paths.files.manifest);
+      existed = true;
+    } catch (error) {
+      if (!hasErrorCode3(error) || error.code !== "ENOENT") {
+        throw new Error("Failed to inspect existing manifest", { cause: error });
+      }
+    }
+    if (existed) {
+      throw new Error("Already initialized. Use --force to overwrite.");
+    }
+  }
+  await writeYamlFile(paths.files.manifest, validated);
+}
+async function readManifest(paths) {
+  const raw = await readYamlFile(paths.files.manifest);
+  return ManifestSchema.parse(raw);
+}
+function hasErrorCode3(error) {
+  if (!(error instanceof Error)) return false;
+  return typeof error.code === "string";
+}
+
+// src/orientation/orientation-renderer.ts
+var DECISION_TRAILING_ACTIVITY_GAP_MS = 60 * 60 * 1e3;
+async function summarizeOrientation(input) {
+  const limit = input.relatedFilesLimit ?? 10;
+  const now = new Date(input.nowIso);
+  const loadOpts = { now };
+  if (input.onSessionSkip !== void 0) loadOpts.onSkip = input.onSessionSkip;
   if (input.onWarning !== void 0) loadOpts.onWarning = input.onWarning;
   const entries = await loadSessionEntries(input.paths, loadOpts);
-  const sessions = [];
+  const decisions = [];
+  let latestActivityAt = null;
+  let latestNote = null;
+  const noteActivity = (iso) => {
+    if (latestActivityAt === null || Date.parse(iso) > Date.parse(latestActivityAt)) {
+      latestActivityAt = iso;
+    }
+  };
   for (const entry of entries) {
-    const events = [];
-    let eventsUnreadable = false;
+    const sessionDir = join14(input.paths.sessions, entry.sessionId);
+    const counted = entry.session.session.status !== "archived";
+    if (counted) noteActivity(entry.session.session.ended_at ?? entry.session.session.started_at);
     try {
-      for await (const ev of replayEvents(join13(input.paths.sessions, entry.sessionId), {
+      for await (const ev of replayEvents(sessionDir, {
         onWarning: (w) => input.onWarning?.(w, entry.sessionId)
       })) {
-        events.push(ev);
+        if (ev.type === "decision_recorded") {
+          decisions.push({
+            decisionId: ev.decision_id,
+            title: ev.title,
+            occurredAt: ev.occurred_at
+          });
+        }
+        if (counted && ev.type === "note_added" && ev.kind === "next_step") {
+          if (latestNote === null || Date.parse(ev.occurred_at) > Date.parse(latestNote.occurredAt)) {
+            latestNote = { body: ev.body, sessionId: entry.sessionId, occurredAt: ev.occurred_at };
+          }
+        }
+        if (counted) noteActivity(ev.occurred_at);
       }
     } catch {
-      eventsUnreadable = true;
-      if (!unreadableEmitted.has(entry.sessionId)) {
-        wrappedSkip(entry.sessionId, "events_jsonl_unreadable");
-      }
+      input.onSessionSkip?.(entry.sessionId, "events_jsonl_unreadable");
     }
-    sessions.push(
-      sessionWorkStatsFromEvents(
-        entry.sessionId,
-        entry.session.session,
-        events,
-        now,
-        eventsUnreadable
-      )
-    );
   }
-  const allIntervals = [];
-  for (const s of sessions) allIntervals.push(...intervalsIsoToMs(s.activeIntervals));
-  const union = unionDurationMs(allIntervals);
+  decisions.sort((a, b) => {
+    const c = Date.parse(a.occurredAt) - Date.parse(b.occurredAt);
+    return c !== 0 ? c : a.decisionId.localeCompare(b.decisionId);
+  });
+  const latestDecision = decisions[decisions.length - 1];
+  const taskLoadOpts = {};
+  if (input.onTaskSkip !== void 0) taskLoadOpts.onSkip = input.onTaskSkip;
+  const taskEntries = await loadTaskEntries(input.paths, taskLoadOpts);
+  const inFlightTasks = taskEntries.filter((t) => t.task.task.status === "in_progress" || t.task.task.status === "planned").map((t) => ({
+    id: t.task.task.id,
+    title: t.task.task.title,
+    status: t.task.task.status,
+    linkedSessions: t.task.task.linked_sessions?.length ?? 0
+  }));
+  const plannedTasks = taskEntries.filter((t) => t.task.task.status === "planned").map((t) => ({ id: t.task.task.id, title: t.task.task.title }));
+  const { pending: pendingIds } = await enumerateApprovals(input.paths);
+  const pendingApprovals = [];
+  for (const id of [...pendingIds].sort()) {
+    const loaded = await loadApproval(input.paths, id);
+    if (loaded === null) continue;
+    const a = loaded.approval;
+    pendingApprovals.push({
+      id,
+      risk: a.risk_level,
+      kind: a.action.kind,
+      reason: a.reason,
+      sessionId: a.session_id,
+      createdAt: a.created_at,
+      expired: isLazyExpired(a, now)
+    });
+  }
+  const suspects = entries.filter((e) => e.suspect).map((e) => ({
+    sessionId: e.sessionId,
+    status: e.session.session.status,
+    reason: e.suspectReason
+  }));
+  const liveEntries = entries.filter(
+    (e) => e.session.session.status !== "archived" && e.session.session.source.kind !== "import"
+  );
+  const latestEntry = [...liveEntries].sort(
+    (a, b) => Date.parse(b.session.session.started_at) - Date.parse(a.session.session.started_at)
+  )[0];
+  const latestSession = latestEntry !== void 0 ? {
+    sessionId: latestEntry.sessionId,
+    label: latestEntry.session.session.label ?? null,
+    status: latestEntry.session.session.status
+  } : null;
+  const activityEntries = entries.filter((e) => e.session.session.status !== "archived");
+  const newest = [...activityEntries].sort(
+    (a, b) => Date.parse(b.session.session.started_at) - Date.parse(a.session.session.started_at)
+  )[0];
+  const bySourceMap = /* @__PURE__ */ new Map();
+  for (const e of entries) {
+    const k = e.session.session.source.kind;
+    bySourceMap.set(k, (bySourceMap.get(k) ?? 0) + 1);
+  }
+  const bySource = [...bySourceMap.entries()].sort((a, b) => a[0].localeCompare(b[0])).map(([kind, count]) => ({ kind, count }));
+  let sourceRoots = null;
+  try {
+    const manifest = await readManifest(input.paths);
+    sourceRoots = manifest.import?.source_roots ?? null;
+  } catch {
+    sourceRoots = null;
+  }
+  const latestFiles = latestEntry?.session.session.related_files ?? [];
+  const uniqueFiles = new Set(latestFiles);
+  const displayed = [...uniqueFiles].sort().slice(0, limit);
+  const overflow = Math.max(0, uniqueFiles.size - limit);
   return {
-    generatedAt: now.toISOString(),
-    activeGapCapMs: ACTIVE_GAP_CAP_MS,
-    timeZone,
-    totals: computeTotals(sessions, union.ms),
-    sessions,
-    bySource: computeBySource(sessions),
-    byStatus: computeByStatus(sessions),
-    byDay: computeByDay(sessions, union.merged, timeZone)
+    generatedAt: input.nowIso,
+    sessionCount: entries.length,
+    latestSession,
+    latestDecision: latestDecision ?? null,
+    decisionCount: decisions.length,
+    latestNote,
+    relatedFiles: { displayed, overflow },
+    inFlightTasks,
+    plannedTasks,
+    pendingApprovals,
+    suspects,
+    freshness: {
+      newestStartedAt: newest?.session.session.started_at ?? null,
+      newestSource: newest?.session.session.source.kind ?? null,
+      latestActivityAt,
+      bySource,
+      sourceRoots
+    }
   };
 }
-function sessionWorkStatsFromEvents(sessionId, inner, events, now, eventsUnreadable = false) {
-  let commandCount = 0;
-  let fileChangedCount = 0;
-  let decisionCount = 0;
-  let commandTimeMs = 0;
-  const timestamps = [];
-  for (const ev of events) {
-    const t = Date.parse(ev.occurred_at);
-    if (Number.isFinite(t)) timestamps.push(t);
-    if (ev.type === "command_executed") {
-      commandCount++;
-      commandTimeMs += ev.duration_ms;
-    } else if (ev.type === "file_changed") {
-      fileChangedCount++;
-    } else if (ev.type === "decision_recorded") {
-      decisionCount++;
-    }
-  }
+async function renderOrientation(input) {
+  const summary = await summarizeOrientation(input);
+  return {
+    body: formatOrientationBody(summary, {
+      staleness: input.staleness ?? null,
+      verbose: input.verbose === true
+    }),
+    sessionCount: summary.sessionCount,
+    pendingApprovalsCount: summary.pendingApprovals.length,
+    suspectCount: summary.suspects.length,
+    inFlightTaskCount: summary.inFlightTasks.length,
+    decisionCount: summary.decisionCount
+  };
+}
+function formatOrientationBody(summary, opts) {
+  const lines = [];
+  const now = new Date(summary.generatedAt);
+  const newestRel = relativeAge(summary.freshness.newestStartedAt ?? void 0, now);
+  lines.push("# Orientation");
+  lines.push("");
+  lines.push(
+    `> Generated at ${summary.generatedAt} \xB7 sessions ${summary.sessionCount} \xB7 newest ${newestRel} \xB7 pending ${summary.pendingApprovals.length} \xB7 suspect ${summary.suspects.length}`
+  );
+  lines.push("");
+  lines.push("## \u4ECA\u3069\u3053\u306B\u3044\u308B");
+  lines.push("");
+  if (summary.latestSession !== null) {
+    const s = summary.latestSession;
+    const sid = shortId(s.sessionId);
+    if (s.label !== null && s.label !== "") {
+      lines.push(`- \u6700\u7D42 session: ${s.label} (${s.status}) [${sid}]`);
+    } else {
+      lines.push(`- \u6700\u7D42 session: ${sid} (${s.status})`);
+    }
+  } else {
+    lines.push("- \u6700\u7D42 session: (no live sessions)");
+  }
+  if (summary.latestDecision !== null) {
+    const decAge = relativeAgeJa(summary.latestDecision.occurredAt, now);
+    lines.push(
+      `- \u76F4\u8FD1\u306E\u5224\u65AD: ${summary.latestDecision.title} [${shortId(summary.latestDecision.decisionId)}] (${decAge})`
+    );
+    const activityAt = summary.freshness.latestActivityAt;
+    if (activityAt !== null && Date.parse(activityAt) - Date.parse(summary.latestDecision.occurredAt) > DECISION_TRAILING_ACTIVITY_GAP_MS) {
+      lines.push(
+        `  - \u6CE8: \u3053\u308C\u306F\u6700\u5F8C\u306B\u300C\u8A18\u9332\u3055\u308C\u305F\u300D\u5224\u65AD\u3067\u3059\u3002\u6700\u7D42\u6D3B\u52D5 (${relativeAgeJa(activityAt, now)}) \u306F\u3053\u308C\u3088\u308A\u5F8C\u306E\u305F\u3081\u3001\u73FE\u5728\u306E\u65B9\u91DD\u304C\u53CD\u6620\u3055\u308C\u3066\u3044\u306A\u3044\u53EF\u80FD\u6027\u304C\u3042\u308A\u307E\u3059(\u4F1A\u8A71\u3067\u306E\u610F\u601D\u6C7A\u5B9A\u306F\u81EA\u52D5\u8A18\u9332\u3055\u308C\u307E\u305B\u3093)\u3002`
+      );
+    }
+    if (summary.decisionCount > 1) {
+      lines.push(`  - ${summary.decisionCount} decisions total \u2014 see decisions.md`);
+    }
+  } else {
+    lines.push("- \u76F4\u8FD1\u306E\u5224\u65AD: (no decisions recorded yet)");
+  }
+  if (summary.relatedFiles.displayed.length > 0) {
+    const shown = summary.relatedFiles.displayed.join(", ");
+    const more = summary.relatedFiles.overflow > 0 ? ` (... +${summary.relatedFiles.overflow} more)` : "";
+    lines.push(`- \u76F4\u8FD1\u306E\u5909\u66F4\u30D5\u30A1\u30A4\u30EB: ${shown}${more}`);
+  } else {
+    lines.push("- \u76F4\u8FD1\u306E\u5909\u66F4\u30D5\u30A1\u30A4\u30EB: (none recorded)");
+  }
+  lines.push("");
+  lines.push("## \u4F55\u304C\u52D5\u304F");
+  lines.push("");
+  lines.push(`### \u9032\u884C\u4E2D task (${summary.inFlightTasks.length})`);
+  if (summary.inFlightTasks.length === 0) {
+    lines.push("- (none)");
+  } else {
+    for (const t of summary.inFlightTasks) {
+      const linkedSuffix = t.linkedSessions > 1 ? ` \u2014 linked_sessions: ${t.linkedSessions}` : "";
+      lines.push(`- ${t.title} (${t.status}) [${shortId(t.id)}]${linkedSuffix}`);
+    }
+  }
+  lines.push("");
+  lines.push(`### \u627F\u8A8D\u5F85\u3061 (${summary.pendingApprovals.length})`);
+  if (summary.pendingApprovals.length === 0) {
+    lines.push("- (none)");
+  } else {
+    for (const a of summary.pendingApprovals) {
+      const expired = a.expired ? " (expired)" : "";
+      lines.push(
+        `- [${a.risk}] ${a.kind}: ${a.reason} \u2014 session ${shortId(a.sessionId)}, since ${a.createdAt}${expired}`
+      );
+    }
+  }
+  lines.push("");
+  lines.push(`### \u8981\u6CE8\u610F session (${summary.suspects.length})`);
+  if (summary.suspects.length === 0) {
+    lines.push("- (none)");
+  } else {
+    for (const e of summary.suspects) {
+      lines.push(`- ${shortId(e.sessionId)} (${e.status}) \u2014 ${suspectText(e.reason)}`);
+    }
+  }
+  lines.push("");
+  lines.push("## \u3069\u3053\u3078\u5411\u304B\u3046");
+  lines.push("");
+  if (summary.latestNote !== null) {
+    const noteAge = relativeAgeJa(summary.latestNote.occurredAt, now);
+    lines.push(
+      `- \u6B21\u306E\u8D77\u70B9 (\u8A18\u9332\u6E08\u307F, ${noteAge}): ${noteSummary(summary.latestNote.body)} [session ${shortId(summary.latestNote.sessionId)}]`
+    );
+    const activityAt = summary.freshness.latestActivityAt;
+    if (activityAt !== null && Date.parse(activityAt) - Date.parse(summary.latestNote.occurredAt) > DECISION_TRAILING_ACTIVITY_GAP_MS) {
+      lines.push(
+        `  - \u6CE8: \u3053\u306E\u8D77\u70B9\u306E\u8A18\u9332\u5F8C (\u6700\u7D42\u6D3B\u52D5 ${relativeAgeJa(activityAt, now)}) \u3082\u4F5C\u696D\u304C\u7D9A\u3044\u3066\u3044\u307E\u3059\u3002\u518D\u958B\u70B9\u304C\u53E4\u3044\u53EF\u80FD\u6027\u304C\u3042\u308A\u307E\u3059\u3002`
+      );
+    }
+  }
+  for (const t of summary.plannedTasks) {
+    lines.push(`- ${t.title} [${shortId(t.id)}]`);
+  }
+  if (summary.latestNote === null && summary.plannedTasks.length === 0) {
+    lines.push("- (no planned tasks \u2014 direction is inferred from recent decisions)");
+    if (summary.latestDecision !== null) {
+      lines.push(`  - \u76F4\u8FD1\u306E\u5224\u65AD: ${summary.latestDecision.title}`);
+    }
+  }
+  lines.push("");
+  lines.push("## \u3053\u308C\u306F\u6700\u65B0\u304B");
+  lines.push("");
+  for (const line of freshnessVerdict(summary, opts.staleness, now)) lines.push(line);
+  if (opts.verbose) {
+    lines.push("");
+    lines.push("<!-- verbose: raw freshness telemetry -->");
+    if (summary.freshness.newestStartedAt !== null) {
+      lines.push(`- newest captured session: ${summary.freshness.newestStartedAt} (${newestRel})`);
+    } else {
+      lines.push("- newest captured session: (no sessions captured yet)");
+    }
+    if (summary.freshness.latestActivityAt !== null) {
+      lines.push(
+        `- latest activity: ${summary.freshness.latestActivityAt} (${relativeAge(summary.freshness.latestActivityAt, now)})`
+      );
+    }
+    const sourceBreakdown = summary.freshness.bySource.map(({ kind, count }) => `${kind} ${count}`).join(", ");
+    lines.push(
+      `- sessions: ${summary.sessionCount}${sourceBreakdown !== "" ? ` (${sourceBreakdown})` : ""}`
+    );
+    if (summary.freshness.sourceRoots !== null && summary.freshness.sourceRoots.length > 0) {
+      lines.push(`- source roots: ${summary.freshness.sourceRoots.join(", ")}`);
+    } else {
+      lines.push("- source roots: (single root)");
+    }
+    lines.push(`- suspect sessions: ${summary.suspects.length}`);
+    const probe = opts.staleness === null ? "not run" : `new ${opts.staleness.newSessions}, updated ${opts.staleness.updatedSessions}, unverifiable ${opts.staleness.unverifiableSessions ?? 0}`;
+    lines.push(`- staleness probe: ${probe}`);
+  }
+  return lines.join("\n");
+}
+function toolDisplayName(kind) {
+  switch (kind) {
+    case "claude-code-import":
+    case "claude-code-adapter":
+      return "Claude Code";
+    case "codex-import":
+      return "Codex";
+    case "terminal":
+      return "\u30BF\u30FC\u30DF\u30CA\u30EB";
+    case "human":
+      return "\u624B\u52D5\u30E1\u30E2";
+    case "import":
+      return "\u4ED6\u30EF\u30FC\u30AF\u30B9\u30DA\u30FC\u30B9";
+    default:
+      return kind ?? "\u4E0D\u660E";
+  }
+}
+function freshnessVerdict(summary, staleness, now) {
+  if (staleness !== null && (staleness.unverifiableSessions ?? 0) > 0) {
+    return [
+      `\u26A0\uFE0F \u6700\u65B0\u304B\u78BA\u8A8D\u3067\u304D\u307E\u305B\u3093\u3002\u5909\u5316\u3057\u305F\u304C\u5B89\u5168\u306B\u53D6\u308A\u8FBC\u3081\u306A\u3044\u30BB\u30C3\u30B7\u30E7\u30F3\u304C ${staleness.unverifiableSessions} \u4EF6\u3042\u308A\u307E\u3059(\u30CF\u30C3\u30B7\u30E5\u30C1\u30A7\u30FC\u30F3\u7834\u640D\u30FB\u975E\u8FFD\u8A18\u5909\u66F4\u306A\u3069)\u3002`,
+      "`basou verify` \u3067\u78BA\u8A8D\u3057\u3001`basou refresh --force` \u3067\u518D\u53D6\u308A\u8FBC\u307F\u3057\u3066\u304F\u3060\u3055\u3044\u3002"
+    ];
+  }
+  if (staleness !== null && (staleness.newSessions > 0 || staleness.updatedSessions > 0)) {
+    const parts = [];
+    if (staleness.newSessions > 0) parts.push(`\u65B0\u898F ${staleness.newSessions} \u4EF6`);
+    if (staleness.updatedSessions > 0) parts.push(`\u66F4\u65B0 ${staleness.updatedSessions} \u4EF6`);
+    return [
+      `\u26A0\uFE0F \u53E4\u3044\u304B\u3082\u3057\u308C\u307E\u305B\u3093\u3002\u6700\u5F8C\u306E\u53D6\u308A\u8FBC\u307F\u4EE5\u964D\u306B\u672A\u53D6\u308A\u8FBC\u307F\u306E\u4F5C\u696D\u304C\u3042\u308A\u307E\u3059(${parts.join("\u30FB")})\u3002`,
+      "`basou refresh` \u3067\u66F4\u65B0\u3057\u3066\u304F\u3060\u3055\u3044\u3002"
+    ];
+  }
+  if (summary.freshness.newestStartedAt === null) {
+    return [
+      "\u2139\uFE0F \u307E\u3060\u8A18\u9332\u304C\u3042\u308A\u307E\u305B\u3093\u3002",
+      "\u3053\u306E\u30EF\u30FC\u30AF\u30B9\u30DA\u30FC\u30B9\u3067\u4F5C\u696D\u3059\u308B\u3068\u3001\u3053\u3053\u306B\u73FE\u5728\u5730\u304C\u8868\u793A\u3055\u308C\u307E\u3059\u3002"
+    ];
+  }
+  const rel = relativeAgeJa(summary.freshness.newestStartedAt, now);
+  const tool = toolDisplayName(summary.freshness.newestSource);
+  const suspectCount = summary.suspects.length;
+  if (staleness === null) {
+    return [
+      `\u2139\uFE0F \u53D6\u308A\u8FBC\u307F\u6E08\u307F\u306E\u72B6\u614B\u3092\u8868\u793A\u3057\u3066\u3044\u307E\u3059\u3002\u6700\u5F8C\u306E\u4F5C\u696D\u306F ${rel}(${tool})\u3002`,
+      "\u6700\u65B0\u304B\u78BA\u8A8D\u3059\u308B\u306B\u306F `basou refresh` \u3092\u5B9F\u884C\u3057\u3066\u304F\u3060\u3055\u3044\u3002"
+    ];
+  }
+  const lines = [
+    `\u2705 \u53D6\u308A\u8FBC\u307F\u306F\u6700\u65B0\u3067\u3059\u3002\u6700\u5F8C\u306E\u4F5C\u696D\u306F ${rel}(${tool})\u3002\u672A\u53D6\u308A\u8FBC\u307F\u306E native \u30BB\u30C3\u30B7\u30E7\u30F3\u306F\u3042\u308A\u307E\u305B\u3093\u3002`
+  ];
+  if (suspectCount > 0) {
+    lines.push(`\u305F\u3060\u3057\u8981\u6CE8\u610F\u30BB\u30C3\u30B7\u30E7\u30F3\u304C ${suspectCount} \u4EF6\u3042\u308A\u307E\u3059(\u4E0A\u8A18\u300C\u8981\u6CE8\u610F session\u300D\u53C2\u7167)\u3002`);
+  }
+  lines.push(
+    "\u6CE8: \u3053\u306E\u5224\u5B9A\u306F\u53D6\u308A\u8FBC\u307F\u6E08\u307F native \u30BB\u30C3\u30B7\u30E7\u30F3\u306E\u9BAE\u5EA6\u3068 suspect \u306E\u6709\u7121\u3060\u3051\u3092\u898B\u307E\u3059\u3002\u8A08\u753B\u2194\u5B9F\u88C5\u306E\u30C9\u30EA\u30D5\u30C8\u3084\u672A\u8A18\u9332\u306E\u610F\u601D\u6C7A\u5B9A\u307E\u3067\u306F\u691C\u77E5\u3057\u307E\u305B\u3093\u3002"
+  );
+  return lines;
+}
+function relativeAgeJa(startedAt, now) {
+  if (startedAt === null) return "(\u4E0D\u660E)";
+  const ms = now.getTime() - Date.parse(startedAt);
+  if (!Number.isFinite(ms) || ms < 0) return "\u305F\u3063\u305F\u4ECA";
+  if (ms < 6e4) return "\u305F\u3063\u305F\u4ECA";
+  const totalMin = Math.floor(ms / 6e4);
+  const days = Math.floor(totalMin / 1440);
+  const hours = Math.floor(totalMin % 1440 / 60);
+  const mins = totalMin % 60;
+  if (days > 0) return hours > 0 ? `${days}\u65E5${hours}\u6642\u9593\u524D` : `${days}\u65E5\u524D`;
+  if (hours > 0) return mins > 0 ? `${hours}\u6642\u9593${mins}\u5206\u524D` : `${hours}\u6642\u9593\u524D`;
+  return `${mins}\u5206\u524D`;
+}
+function relativeAge(startedAt, now) {
+  if (startedAt === void 0) return "(unknown)";
+  const ms = now.getTime() - Date.parse(startedAt);
+  if (!Number.isFinite(ms)) return "(unknown)";
+  if (ms < 0) return "just now";
+  if (ms < 1e3) return "just now";
+  return `${formatDurationMs(ms)} ago`;
+}
+var NOTE_SUMMARY_MAX = 200;
+function noteSummary(body) {
+  const oneLine = body.replace(/\s+/g, " ").trim();
+  return oneLine.length > NOTE_SUMMARY_MAX ? `${oneLine.slice(0, NOTE_SUMMARY_MAX - 1)}\u2026` : oneLine;
+}
+function suspectText(reason) {
+  if (reason === "events_say_ended_but_yaml_running") return "ended (yaml stale)";
+  if (reason === "running_no_end_event") return "no end event";
+  return "suspect";
+}
+function shortId(id) {
+  const sep = id.indexOf("_");
+  if (sep === -1) return id.slice(0, 10);
+  return id.slice(0, sep + 1) + id.slice(sep + 1, sep + 1 + 10);
+}
+
+// src/project/relative-path.ts
+function normalizeRelativePath(p) {
+  const trimmed = p.trim();
+  const absolute = trimmed.startsWith("/");
+  const out = [];
+  for (const seg of trimmed.split("/")) {
+    if (seg === "" || seg === ".") continue;
+    if (seg === "..") {
+      const top = out[out.length - 1];
+      if (top !== void 0 && top !== "..") {
+        out.pop();
+      } else if (!absolute) {
+        out.push("..");
+      }
+      continue;
+    }
+    out.push(seg);
+  }
+  const joined = out.join("/");
+  if (absolute) return `/${joined}`;
+  return joined.length === 0 ? "." : joined;
+}
+
+// src/project/archive.ts
+function planArchive(input) {
+  const target = normalizeRelativePath(input.target);
+  const repos = input.repos ?? [];
+  const isAnchor = input.targetIsAnchor === true || target === ".";
+  const matched = repos.filter((r) => normalizeRelativePath(r.path) === target);
+  const found = matched.length > 0;
+  if (isAnchor || !found) {
+    return {
+      target,
+      found,
+      isAnchor,
+      nextRepos: repos,
+      reposEmptied: false,
+      remainingCount: repos.length,
+      becomesSolo: false
+    };
+  }
+  const nextRepos = repos.filter((r) => normalizeRelativePath(r.path) !== target);
+  const remainingCount = nextRepos.length;
+  let sourceRootRemoval;
+  let nextSourceRoots;
+  if (input.sourceRoots !== void 0) {
+    const pruned = input.sourceRoots.filter((s) => normalizeRelativePath(s) !== target);
+    if (pruned.length !== input.sourceRoots.length) {
+      sourceRootRemoval = target;
+      nextSourceRoots = pruned;
+    }
+  }
+  return {
+    target,
+    found: true,
+    isAnchor: false,
+    rosterEntry: matched[matched.length - 1],
+    nextRepos,
+    reposEmptied: remainingCount === 0,
+    ...sourceRootRemoval !== void 0 ? { sourceRootRemoval } : {},
+    ...nextSourceRoots !== void 0 ? { nextSourceRoots } : {},
+    remainingCount,
+    becomesSolo: remainingCount === 1
+  };
+}
+
+// src/project/gitignore-plan.ts
+function isPublicFacing(v) {
+  return v === "public" || v === "future-public";
+}
+function planGitignore(input) {
+  const plans = [];
+  const unknown = [];
+  const unreachable = [];
+  for (const repo of input.repos) {
+    if (!repo.reachable) {
+      unreachable.push(repo.path);
+      continue;
+    }
+    if (repo.visibility === void 0) {
+      unknown.push(repo.path);
+      continue;
+    }
+    if (!isPublicFacing(repo.visibility)) continue;
+    const present = /* @__PURE__ */ new Set();
+    for (const line of repo.currentLines) {
+      const trimmed = line.trim();
+      present.add(trimmed);
+      if (trimmed.startsWith("/")) present.add(trimmed.slice(1));
+    }
+    const toAdd = input.required.filter((p) => !present.has(p));
+    if (toAdd.length > 0) plans.push({ path: repo.path, toAdd });
+  }
+  return {
+    plans,
+    unknown,
+    unreachable,
+    ok: plans.length === 0 && unknown.length === 0 && unreachable.length === 0
+  };
+}
+
+// src/project/preset.ts
+function visibilityLabel(v) {
+  switch (v) {
+    case "public":
+      return "public(git \u5C65\u6B74\u306F\u516C\u958B)";
+    case "private":
+      return "private(git \u5C65\u6B74\u306F\u975E\u516C\u958B)";
+    case "future-public":
+      return "future-public(\u73FE\u5728\u306F\u975E\u516C\u958B\u30FB\u5C06\u6765\u516C\u958B\u4E88\u5B9A)";
+    default:
+      return "\u672A\u8A2D\u5B9A";
+  }
+}
+function sourceLanguageLabel(l) {
+  switch (l) {
+    case "en":
+      return "en(commit\u30FB\u30B3\u30E1\u30F3\u30C8\u30FB\u30B3\u30FC\u30C9\u306F\u82F1\u8A9E)";
+    case "ja":
+      return "ja(commit\u30FB\u30B3\u30E1\u30F3\u30C8\u30FB\u30B3\u30FC\u30C9\u306F\u65E5\u672C\u8A9E)";
+    case "en+ja":
+      return "en+ja(commit\u30FB\u30B3\u30E1\u30F3\u30C8\u30FB\u30B3\u30FC\u30C9\u306F\u65E5\u82F1)";
+    default:
+      return "\u672A\u8A2D\u5B9A";
+  }
+}
+function publishKindLabel(k) {
+  return k === "web" ? "web(\u30C7\u30D7\u30ED\u30A4)" : "npm(\u30D1\u30C3\u30B1\u30FC\u30B8)";
+}
+function publishVisibilityLabel(v) {
+  switch (v) {
+    case "public":
+      return "\u516C\u958B";
+    case "private":
+      return "\u975E\u516C\u958B";
+    case "future-public":
+      return "\u5C06\u6765\u516C\u958B";
+    default:
+      return "\u53EF\u8996\u6027\u672A\u8A2D\u5B9A";
+  }
+}
+function contentLanguageLabel(l) {
+  return l ?? "\u8A00\u8A9E\u672A\u8A2D\u5B9A";
+}
+function isRenderable(repo) {
+  return repo.visibility !== void 0 || repo.language !== void 0 || repo.publishes !== void 0 && repo.publishes.length > 0;
+}
+function renderPresetBlock(repo) {
+  const lines = [];
+  lines.push("## \u30D7\u30ED\u30B8\u30A7\u30AF\u30C8\u69CB\u6210(basou \u304C\u751F\u6210 \u2014 manifest \u304C\u6B63\u672C)");
+  lines.push("");
+  lines.push(
+    "\u3053\u306E\u30BB\u30AF\u30B7\u30E7\u30F3\u306F `.basou/manifest.yaml` \u306E\u5BA3\u8A00\u304B\u3089 `basou project preset` \u304C\u751F\u6210\u3057\u307E\u3059\u3002\u7DE8\u96C6\u306F manifest \u5074\u3067\u884C\u3063\u3066\u304F\u3060\u3055\u3044(\u30DE\u30FC\u30AB\u30FC\u5916\u306E\u8A18\u8FF0\u306F\u4FDD\u6301\u3055\u308C\u307E\u3059)\u3002"
+  );
+  lines.push("");
+  lines.push(`- \u30BD\u30FC\u30B9\u53EF\u8996\u6027: ${visibilityLabel(repo.visibility)}`);
+  lines.push(`- \u30BD\u30FC\u30B9\u8A00\u8A9E: ${sourceLanguageLabel(repo.language)}`);
+  const publishes = repo.publishes ?? [];
+  if (publishes.length === 0) {
+    lines.push("- \u914D\u4FE1\u7269: \u306A\u3057");
+  } else {
+    lines.push("- \u914D\u4FE1\u7269:");
+    for (const p of publishes) {
+      lines.push(
+        `    - ${publishKindLabel(p.kind)} \u2014 ${publishVisibilityLabel(p.visibility)} / ${contentLanguageLabel(p.language)}`
+      );
+    }
+  }
+  return lines.join("\n");
+}
+function normalizeBlock(s) {
+  return s.replace(/\r\n/g, "\n").replace(/\n+$/, "");
+}
+function summarizePresetPlan(facts) {
+  const deduped = [];
+  const seenPath = /* @__PURE__ */ new Set();
+  for (const f of facts) {
+    const key = normalizeRelativePath(f.path);
+    if (seenPath.has(key)) continue;
+    seenPath.add(key);
+    deduped.push(f);
+  }
+  const byCanonical = /* @__PURE__ */ new Map();
+  for (const f of deduped) {
+    if (f.isAnchor || !f.reachable || f.canonicalName === void 0 || !isRenderable(f)) continue;
+    const repos = byCanonical.get(f.canonicalName) ?? [];
+    repos.push(f.path);
+    byCanonical.set(f.canonicalName, repos);
+  }
+  const collisions = [];
+  const collidingPaths = /* @__PURE__ */ new Set();
+  for (const [canonicalName, repos] of byCanonical) {
+    if (repos.length > 1) {
+      collisions.push({ canonicalName, repos });
+      for (const r of repos) collidingPaths.add(r);
+    }
+  }
+  const plans = [];
+  const inSync = [];
+  const undeclared = [];
+  const markerConflicts = [];
+  const unreadable = [];
+  const anchors = [];
+  const unreachable = [];
+  for (const f of deduped) {
+    if (f.isAnchor) {
+      anchors.push(f.path);
+      continue;
+    }
+    if (!f.reachable) {
+      unreachable.push(f.path);
+      continue;
+    }
+    if (!isRenderable(f)) {
+      undeclared.push(f.path);
+      continue;
+    }
+    if (collidingPaths.has(f.path)) continue;
+    if (f.canonicalName === void 0) {
+      unreachable.push(f.path);
+      continue;
+    }
+    const desiredBlock = renderPresetBlock(f);
+    if (!f.canonicalPresent) {
+      plans.push({ path: f.path, canonicalName: f.canonicalName, action: "create", desiredBlock });
+      continue;
+    }
+    if (f.canonicalReadable === false) {
+      unreadable.push(f.path);
+      continue;
+    }
+    if (f.markerKind === "ok") {
+      if (normalizeBlock(f.currentBlock ?? "") === normalizeBlock(desiredBlock)) {
+        inSync.push(f.path);
+      } else {
+        plans.push({
+          path: f.path,
+          canonicalName: f.canonicalName,
+          action: "update",
+          desiredBlock
+        });
+      }
+      continue;
+    }
+    markerConflicts.push({ repo: f.path, reason: f.markerKind ?? "no_markers" });
+  }
+  return {
+    plans,
+    inSync,
+    undeclared,
+    markerConflicts,
+    unreadable,
+    collisions,
+    anchors,
+    unreachable,
+    ok: plans.length === 0 && markerConflicts.length === 0 && unreadable.length === 0 && collisions.length === 0 && unreachable.length === 0 && undeclared.length === 0
+  };
+}
+
+// src/project/rename.ts
+function pathBasename(p) {
+  const parts = normalizeRelativePath(p).split("/");
+  return parts[parts.length - 1];
+}
+function dedupRepos(entries) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const e of entries) {
+    const k = normalizeRelativePath(e.path);
+    if (seen.has(k)) continue;
+    seen.add(k);
+    out.push(e);
+  }
+  return out;
+}
+function dedupNorm(items) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const s of items) {
+    const k = normalizeRelativePath(s);
+    if (seen.has(k)) continue;
+    seen.add(k);
+    out.push(s);
+  }
+  return out;
+}
+function planRename(input) {
+  const oldTarget = normalizeRelativePath(input.oldPath);
+  const newTarget = normalizeRelativePath(input.newPath);
+  const repos = input.repos ?? [];
+  const basenameChanged = pathBasename(oldTarget) !== pathBasename(newTarget);
+  const noop = oldTarget === newTarget;
+  const isAnchor = input.oldIsAnchor === true || oldTarget === ".";
+  const found = repos.some((r) => normalizeRelativePath(r.path) === oldTarget);
+  const collision = !noop && repos.some((r) => normalizeRelativePath(r.path) === newTarget);
+  if (noop || isAnchor || !found || collision) {
+    return {
+      oldTarget,
+      newTarget,
+      noop,
+      isAnchor,
+      found,
+      collision,
+      nextRepos: repos,
+      reposChanged: false,
+      basenameChanged
+    };
+  }
+  const rosterEntry = repos.find((r) => normalizeRelativePath(r.path) === oldTarget);
+  const nextRepos = dedupRepos(
+    repos.map((r) => normalizeRelativePath(r.path) === oldTarget ? { ...r, path: newTarget } : r)
+  );
+  let sourceRootRenamed;
+  let nextSourceRoots;
+  if (input.sourceRoots !== void 0 && input.sourceRoots.some((s) => normalizeRelativePath(s) === oldTarget)) {
+    nextSourceRoots = dedupNorm(
+      input.sourceRoots.map((s) => normalizeRelativePath(s) === oldTarget ? newTarget : s)
+    );
+    sourceRootRenamed = oldTarget;
+  }
+  return {
+    oldTarget,
+    newTarget,
+    noop: false,
+    isAnchor: false,
+    found: true,
+    collision: false,
+    rosterEntry,
+    nextRepos,
+    reposChanged: true,
+    ...sourceRootRenamed !== void 0 ? { sourceRootRenamed } : {},
+    ...nextSourceRoots !== void 0 ? { nextSourceRoots } : {},
+    basenameChanged
+  };
+}
+
+// src/project/roster.ts
+function summarizeRosterDrift(input) {
+  const captured = new Set((input.sourceRoots ?? []).map(normalizeRelativePath));
+  const declared = /* @__PURE__ */ new Map();
+  for (const r of input.repos ?? []) declared.set(normalizeRelativePath(r.path), r);
+  const gaps = [];
+  const matched = [];
+  for (const [norm, entry] of declared) {
+    if (captured.has(norm)) matched.push(norm);
+    else gaps.push(entry);
+  }
+  const extra = [...captured].filter((c) => !declared.has(c)).sort();
+  return {
+    declaredCount: declared.size,
+    capturedCount: captured.size,
+    gaps,
+    extra,
+    matched: matched.sort(),
+    ok: gaps.length === 0
+  };
+}
+function reconcileSourceRoots(input) {
+  const current = input.sourceRoots ?? [];
+  const seen = new Set(current.map(normalizeRelativePath));
+  const added = [];
+  for (const r of input.repos ?? []) {
+    const norm = normalizeRelativePath(r.path);
+    if (seen.has(norm)) continue;
+    seen.add(norm);
+    added.push(norm);
+  }
+  return {
+    next: [...current, ...added],
+    added,
+    unchanged: added.length === 0
+  };
+}
+function planRosterAdoption(candidates) {
+  const repos = [];
+  const excluded = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const c of candidates) {
+    const norm = normalizeRelativePath(c.path);
+    if (seen.has(norm)) continue;
+    seen.add(norm);
+    if (c.kind === "repo") repos.push({ path: c.path });
+    else excluded.push({ path: c.path, kind: c.kind });
+  }
+  return { repos, excluded };
+}
+
+// src/project/symlinks.ts
+function summarizeSymlinkPlan(facts) {
+  const deduped = [];
+  const seenPath = /* @__PURE__ */ new Set();
+  for (const f of facts) {
+    const key = normalizeRelativePath(f.path);
+    if (seenPath.has(key)) continue;
+    seenPath.add(key);
+    deduped.push(f);
+  }
+  const byCanonical = /* @__PURE__ */ new Map();
+  for (const f of deduped) {
+    if (f.isAnchor || !f.reachable || !f.canonicalPresent || f.canonicalName === void 0) {
+      continue;
+    }
+    const repos = byCanonical.get(f.canonicalName) ?? [];
+    repos.push(f.path);
+    byCanonical.set(f.canonicalName, repos);
+  }
+  const collisions = [];
+  const collidingPaths = /* @__PURE__ */ new Set();
+  for (const [canonicalName, repos] of byCanonical) {
+    if (repos.length > 1) {
+      collisions.push({ canonicalName, repos });
+      for (const r of repos) collidingPaths.add(r);
+    }
+  }
+  const plans = [];
+  const conflicts = [];
+  const missingCanonical = [];
+  const unreachable = [];
+  for (const f of deduped) {
+    if (f.isAnchor) continue;
+    if (!f.reachable) {
+      unreachable.push(f.path);
+      continue;
+    }
+    if (!f.canonicalPresent) {
+      missingCanonical.push(f.path);
+      continue;
+    }
+    if (collidingPaths.has(f.path)) continue;
+    const toCreate = [];
+    for (const file of f.files) {
+      if (file.state === "missing") {
+        toCreate.push({ name: file.name, target: file.expectedTarget });
+      } else if (file.state === "mismatch") {
+        conflicts.push({
+          repo: f.path,
+          file: file.name,
+          reason: "mismatch",
+          ...file.actualTarget !== void 0 ? { actualTarget: file.actualTarget } : {}
+        });
+      } else if (file.state === "occupied") {
+        conflicts.push({ repo: f.path, file: file.name, reason: "occupied" });
+      } else if (file.state === "blocked") {
+        conflicts.push({ repo: f.path, file: file.name, reason: "blocked" });
+      }
+    }
+    if (toCreate.length > 0) plans.push({ path: f.path, toCreate });
+  }
+  return {
+    plans,
+    conflicts,
+    missingCanonical,
+    unreachable,
+    collisions,
+    ok: plans.length === 0 && conflicts.length === 0 && missingCanonical.length === 0 && unreachable.length === 0 && collisions.length === 0
+  };
+}
+
+// src/project/wiring.ts
+function isPublicFacing2(v) {
+  return v === "public" || v === "future-public";
+}
+function summarizeWiring(facts) {
+  const risks = [];
+  const unknown = [];
+  const incomplete = [];
+  const unreachable = [];
+  for (const f of facts) {
+    if (!f.reachable) {
+      unreachable.push(f.path);
+      continue;
+    }
+    if (isPublicFacing2(f.visibility)) {
+      for (const file of f.instructionFiles) {
+        if (file.tracked) risks.push({ repo: f.path, visibility: f.visibility, file: file.name });
+      }
+    } else if (f.visibility === void 0) {
+      unknown.push(f.path);
+    }
+    const missing = f.instructionFiles.filter((file) => !file.present).map((file) => file.name);
+    if (missing.length > 0) incomplete.push({ repo: f.path, missing });
+  }
+  return {
+    repos: facts,
+    risks,
+    unknown,
+    incomplete,
+    unreachable,
+    ok: risks.length === 0 && unknown.length === 0 && unreachable.length === 0
+  };
+}
+
+// src/project/workspace-view.ts
+function planWorkspaceView(facts, existing = [], rosterNames = []) {
+  const deduped = [];
+  const seenPath = /* @__PURE__ */ new Set();
+  for (const f of facts) {
+    const key = normalizeRelativePath(f.path);
+    if (seenPath.has(key)) continue;
+    seenPath.add(key);
+    deduped.push(f);
+  }
+  const byLinkName = /* @__PURE__ */ new Map();
+  for (const f of deduped) {
+    if (!f.reachable || f.linkName === void 0) continue;
+    const repos = byLinkName.get(f.linkName) ?? [];
+    repos.push(f.path);
+    byLinkName.set(f.linkName, repos);
+  }
+  const collisions = [];
+  const collidingPaths = /* @__PURE__ */ new Set();
+  for (const [linkName, repos] of byLinkName) {
+    if (repos.length > 1) {
+      collisions.push({ linkName, repos });
+      for (const r of repos) collidingPaths.add(r);
+    }
+  }
+  const toCreate = [];
+  const conflicts = [];
+  const unreachable = [];
+  let correctCount = 0;
+  for (const f of deduped) {
+    if (!f.reachable) {
+      unreachable.push(f.path);
+      continue;
+    }
+    if (collidingPaths.has(f.path)) continue;
+    if (f.linkName === void 0 || f.expectedTarget === void 0 || f.state === void 0) {
+      continue;
+    }
+    if (f.state === "missing") {
+      toCreate.push({ name: f.linkName, target: f.expectedTarget });
+    } else if (f.state === "mismatch") {
+      conflicts.push({
+        name: f.linkName,
+        reason: "mismatch",
+        ...f.actualTarget !== void 0 ? { actualTarget: f.actualTarget } : {}
+      });
+    } else if (f.state === "occupied") {
+      conflicts.push({ name: f.linkName, reason: "occupied" });
+    } else if (f.state === "blocked") {
+      conflicts.push({ name: f.linkName, reason: "blocked" });
+    } else {
+      correctCount += 1;
+    }
+  }
+  const ownedNames = new Set(rosterNames);
+  for (const f of deduped) {
+    if (f.reachable && f.linkName !== void 0) ownedNames.add(f.linkName);
+  }
+  const toPrune = [];
+  const strayUnknown = [];
+  const seenExisting = /* @__PURE__ */ new Set();
+  for (const e of existing) {
+    if (ownedNames.has(e.name)) continue;
+    if (seenExisting.has(e.name)) continue;
+    seenExisting.add(e.name);
+    if (e.kind === "repo") {
+      toPrune.push({ name: e.name, target: e.target });
+    } else {
+      strayUnknown.push({ name: e.name, target: e.target, reason: e.kind });
+    }
+  }
+  return {
+    toCreate,
+    conflicts,
+    collisions,
+    unreachable,
+    toPrune,
+    strayUnknown,
+    correctCount,
+    ok: toCreate.length === 0 && conflicts.length === 0 && collisions.length === 0 && unreachable.length === 0 && toPrune.length === 0 && strayUnknown.length === 0
+  };
+}
+
+// src/report/report-renderer.ts
+import { join as join16 } from "path";
+
+// src/stats/work-stats.ts
+import { join as join15 } from "path";
+function resolveTimeZone(timeZone) {
+  if (timeZone !== void 0 && timeZone.length > 0) return timeZone;
+  return Intl.DateTimeFormat().resolvedOptions().timeZone;
+}
+var STATUS_ORDER = [
+  "completed",
+  "failed",
+  "running",
+  "interrupted",
+  "waiting_approval",
+  "initialized",
+  "imported",
+  "archived"
+];
+async function computeWorkStats(input) {
+  const { now } = input;
+  const timeZone = resolveTimeZone(input.timeZone);
+  const unreadableEmitted = /* @__PURE__ */ new Set();
+  const wrappedSkip = (sid, reason) => {
+    if (reason === "events_jsonl_unreadable") unreadableEmitted.add(sid);
+    input.onSessionSkip?.(sid, reason);
+  };
+  const loadOpts = { now, onSkip: wrappedSkip };
+  if (input.onWarning !== void 0) loadOpts.onWarning = input.onWarning;
+  const entries = await loadSessionEntries(input.paths, loadOpts);
+  const sessions = [];
+  for (const entry of entries) {
+    const events = [];
+    let eventsUnreadable = false;
+    try {
+      for await (const ev of replayEvents(join15(input.paths.sessions, entry.sessionId), {
+        onWarning: (w) => input.onWarning?.(w, entry.sessionId)
+      })) {
+        events.push(ev);
+      }
+    } catch {
+      eventsUnreadable = true;
+      if (!unreadableEmitted.has(entry.sessionId)) {
+        wrappedSkip(entry.sessionId, "events_jsonl_unreadable");
+      }
+    }
+    sessions.push(
+      sessionWorkStatsFromEvents(
+        entry.sessionId,
+        entry.session.session,
+        events,
+        now,
+        eventsUnreadable
+      )
+    );
+  }
+  const allIntervals = [];
+  for (const s of sessions) allIntervals.push(...intervalsIsoToMs(s.activeIntervals));
+  const union = unionDurationMs(allIntervals);
+  return {
+    generatedAt: now.toISOString(),
+    activeGapCapMs: ACTIVE_GAP_CAP_MS,
+    timeZone,
+    totals: computeTotals(sessions, union.ms),
+    sessions,
+    bySource: computeBySource(sessions),
+    byStatus: computeByStatus(sessions),
+    byDay: computeByDay(sessions, union.merged, timeZone)
+  };
+}
+function sessionWorkStatsFromEvents(sessionId, inner, events, now, eventsUnreadable = false) {
+  let commandCount = 0;
+  let fileChangedCount = 0;
+  let decisionCount = 0;
+  let commandTimeMs = 0;
+  const timestamps = [];
+  for (const ev of events) {
+    const t = Date.parse(ev.occurred_at);
+    if (Number.isFinite(t)) timestamps.push(t);
+    if (ev.type === "command_executed") {
+      commandCount++;
+      commandTimeMs += ev.duration_ms;
+    } else if (ev.type === "file_changed") {
+      fileChangedCount++;
+    } else if (ev.type === "decision_recorded") {
+      decisionCount++;
+    }
+  }
   const span = computeSpan(inner.started_at, inner.ended_at, now);
   const tokens = readTokens(inner.metrics);
   const active = resolveActiveTime(inner.metrics, timestamps);
@@ -4413,7 +5579,7 @@ async function renderReport(input) {
   const statsBySession = new Map(stats.sessions.map((s) => [s.sessionId, s]));
   const decisions = [];
   for (const entry of entries) {
-    const sessionDir = join14(input.paths.sessions, entry.sessionId);
+    const sessionDir = join16(input.paths.sessions, entry.sessionId);
     try {
       for await (const ev of replayEvents(sessionDir, {
         onWarning: (w) => input.onWarning?.(w, entry.sessionId)
@@ -4691,6 +5857,231 @@ function formatInt(n) {
   return n.toLocaleString("en-US");
 }
 
+// src/review/review-gaps.ts
+import { existsSync, realpathSync } from "fs";
+import { homedir as homedir2 } from "os";
+import { basename as basename2, isAbsolute, join as join17 } from "path";
+function stripQuotes(s) {
+  if (s.length >= 2 && (s[0] === '"' && s.at(-1) === '"' || s[0] === "'" && s.at(-1) === "'")) {
+    return s.slice(1, -1);
+  }
+  return s;
+}
+var realpathCache = /* @__PURE__ */ new Map();
+function resolveRealpath(absPath) {
+  const cached = realpathCache.get(absPath);
+  if (cached !== void 0) return cached;
+  let resolved;
+  try {
+    resolved = realpathSync(absPath);
+  } catch {
+    resolved = null;
+  }
+  realpathCache.set(absPath, resolved);
+  return resolved;
+}
+var repoRootCache = /* @__PURE__ */ new Map();
+function isRepoRoot(realPath) {
+  const cached = repoRootCache.get(realPath);
+  if (cached !== void 0) return cached;
+  const result = existsSync(join17(realPath, ".git"));
+  repoRootCache.set(realPath, result);
+  return result;
+}
+function normalizeRepoPath(p) {
+  if (!p) return null;
+  let s = stripQuotes(p.trim()).replace(/\/+$/, "");
+  if (s.length === 0 || s === "~") return null;
+  if (s.startsWith("~/")) s = homedir2() + s.slice(1);
+  if (isAbsolute(s)) {
+    const real = resolveRealpath(s);
+    if (real !== null) {
+      return isRepoRoot(real) ? real : null;
+    }
+  }
+  s = s.replace(/\/[^/]*-workspace\/([^/]+)/, "/$1");
+  const seg = s.split("/").filter((x) => x.length > 0).pop();
+  if (seg === void 0) return null;
+  if (/-workspace$/.test(seg) || seg.includes("$")) return null;
+  return s;
+}
+function normalizeRepoKey(p) {
+  const full = normalizeRepoPath(p);
+  return full === null ? null : basename2(full);
+}
+function inspectCommand(args) {
+  const a = args.join(" ");
+  const files = /* @__PURE__ */ new Set();
+  const examinedDiff = /\bgit\s+(?:diff|show|log\s+-p|add\s+-p)\b/.test(a);
+  for (const re of [
+    /\b(?:cat|less|bat|head|tail)\s+([^\s|&;<>]+)/g,
+    /\bsed\s+-n\s+'[^']*'\s+([^\s|&;<>]+)/g,
+    /\b(?:rg|grep)\b[^|&;]*?\s([^\s|&;<>]+\.[A-Za-z0-9]+)(?:\s|$)/g
+  ]) {
+    let m;
+    while ((m = re.exec(a)) !== null) {
+      const f = m[1];
+      if (f !== void 0) files.add(basename2(f));
+    }
+  }
+  return { files: [...files], examinedDiff };
+}
+function commandRepo(args, cwd) {
+  const cd = args.join(" ").match(/\bcd\s+("[^"]+"|'[^']+'|[^\s&]+)\s*&&/);
+  if (cd) return normalizeRepoPath(cd[1]);
+  return normalizeRepoPath(cwd);
+}
+function commandFailed(exitCode) {
+  return exitCode !== null && exitCode !== 0;
+}
+function commitFiles(args) {
+  const a = args.join(" ");
+  const add = a.match(/git add\s+([^&|;]+)/);
+  if (!add?.[1]) return [];
+  return add[1].split(/\s+/).filter((t) => /\.[A-Za-z]/.test(t) && !t.startsWith("-")).map((t) => basename2(t));
+}
+var REVIEW_SOURCE = "codex-import";
+var DEFAULT_WINDOW_HOURS = 24;
+async function findReviewGaps(input) {
+  const now = new Date(input.nowIso);
+  const windowHours = input.windowHours ?? DEFAULT_WINDOW_HOURS;
+  const scope = input.scope && input.scope.length > 0 ? input.scope : null;
+  const loadOpts = { now };
+  if (input.onSessionSkip !== void 0) loadOpts.onSkip = input.onSessionSkip;
+  if (input.onWarning !== void 0) loadOpts.onWarning = input.onWarning;
+  const entries = await loadSessionEntries(input.paths, loadOpts);
+  const reviews = [];
+  const workUnits = /* @__PURE__ */ new Map();
+  const unknownCommits = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const sessionDir = join17(input.paths.sessions, entry.sessionId);
+    const isReview = entry.session.session.source.kind === REVIEW_SOURCE;
+    const reviewRepos = /* @__PURE__ */ new Map();
+    let reviewEnd = null;
+    try {
+      for await (const ev of replayEvents(sessionDir, {
+        onWarning: (w) => input.onWarning?.(w, entry.sessionId)
+      })) {
+        if (ev.type !== "command_executed") continue;
+        if (commandFailed(ev.exit_code)) continue;
+        const at = Date.parse(ev.occurred_at);
+        if (isReview) {
+          const repo2 = commandRepo(ev.args, ev.cwd);
+          if (repo2 === null) continue;
+          const ins = inspectCommand(ev.args);
+          const slot = reviewRepos.get(repo2) ?? { examinedDiff: false, files: /* @__PURE__ */ new Set() };
+          if (ins.examinedDiff) slot.examinedDiff = true;
+          for (const f of ins.files) slot.files.add(f);
+          reviewRepos.set(repo2, slot);
+          if (!Number.isNaN(at)) reviewEnd = reviewEnd === null ? at : Math.max(reviewEnd, at);
+          continue;
+        }
+        if (!ev.args.join(" ").includes("git commit")) continue;
+        const repo = commandRepo(ev.args, ev.cwd);
+        if (repo === null || Number.isNaN(at)) {
+          const list2 = unknownCommits.get(entry.sessionId) ?? [];
+          list2.push(Number.isNaN(at) ? null : at);
+          unknownCommits.set(entry.sessionId, list2);
+          continue;
+        }
+        const byRepo = workUnits.get(entry.sessionId) ?? /* @__PURE__ */ new Map();
+        const list = byRepo.get(repo) ?? [];
+        list.push({ repo, at, files: commitFiles(ev.args) });
+        byRepo.set(repo, list);
+        workUnits.set(entry.sessionId, byRepo);
+      }
+    } catch {
+      input.onSessionSkip?.(entry.sessionId, "events_jsonl_unreadable");
+      continue;
+    }
+    if (isReview && reviewRepos.size > 0) {
+      reviews.push({ sessionId: entry.sessionId, endedAt: reviewEnd, repos: reviewRepos });
+    }
+  }
+  const windowMs = windowHours * 3600 * 1e3;
+  const units = [];
+  let newestCommit = null;
+  for (const [sessionId, byRepo] of workUnits) {
+    for (const [repoPath, commits] of byRepo) {
+      const label = basename2(repoPath);
+      if (scope !== null && !scope.includes(label)) continue;
+      const times = commits.map((c) => c.at).sort((a, b) => a - b);
+      const first = times[0] ?? null;
+      const last = times[times.length - 1] ?? null;
+      if (last !== null) newestCommit = newestCommit === null ? last : Math.max(newestCommit, last);
+      const changedFiles = new Set(commits.flatMap((c) => c.files));
+      const before = first ?? last ?? 0;
+      const nearby = reviews.filter((r) => {
+        if (!r.repos.has(repoPath) || r.endedAt === null) return false;
+        return r.endedAt <= before && r.endedAt >= before - windowMs;
+      });
+      const bound = nearby.filter((r) => {
+        const touched = r.repos.get(repoPath);
+        if (touched === void 0) return false;
+        if (touched.examinedDiff) return true;
+        for (const f of changedFiles) if (touched.files.has(f)) return true;
+        return false;
+      });
+      const verdict = bound.length > 0 ? "candidate" : nearby.length > 0 ? "near_unbound" : "omission";
+      const cited = verdict === "candidate" ? bound : verdict === "near_unbound" ? nearby : [];
+      units.push({
+        repo: label,
+        sessionId,
+        commitCount: commits.length,
+        firstCommitAt: first === null ? null : new Date(first).toISOString(),
+        lastCommitAt: last === null ? null : new Date(last).toISOString(),
+        verdict,
+        reviews: cited.map((r) => ({
+          sessionId: r.sessionId,
+          examinedDiff: r.repos.get(repoPath)?.examinedDiff ?? false,
+          files: [...r.repos.get(repoPath)?.files ?? []].slice(0, 8),
+          endedAt: r.endedAt === null ? null : new Date(r.endedAt).toISOString()
+        }))
+      });
+    }
+  }
+  if (scope === null) {
+    for (const [sessionId, times] of unknownCommits) {
+      const valid = times.filter((t) => t !== null).sort((a, b) => a - b);
+      const first = valid[0] ?? null;
+      const last = valid[valid.length - 1] ?? null;
+      if (last !== null) newestCommit = newestCommit === null ? last : Math.max(newestCommit, last);
+      units.push({
+        repo: "(unknown)",
+        sessionId,
+        commitCount: times.length,
+        firstCommitAt: first === null ? null : new Date(first).toISOString(),
+        lastCommitAt: last === null ? null : new Date(last).toISOString(),
+        verdict: "unknown",
+        reviews: []
+      });
+    }
+  }
+  const recentFirst = (a, b) => (Date.parse(b.lastCommitAt ?? "") || 0) - (Date.parse(a.lastCommitAt ?? "") || 0);
+  const repoKeys = [...new Set(units.map((u) => u.repo))].sort();
+  const repos = repoKeys.map((repo) => {
+    const us = units.filter((u) => u.repo === repo);
+    return {
+      repo,
+      units: us.length,
+      omissionUnits: us.filter((u) => u.verdict === "omission").length,
+      nearUnboundUnits: us.filter((u) => u.verdict === "near_unbound").length,
+      candidateUnits: us.filter((u) => u.verdict === "candidate").length,
+      unknownUnits: us.filter((u) => u.verdict === "unknown").length
+    };
+  });
+  return {
+    generatedAt: input.nowIso,
+    windowHours,
+    scope,
+    repos,
+    gaps: units.filter((u) => u.verdict === "omission" || u.verdict === "near_unbound").sort(recentFirst),
+    candidates: units.filter((u) => u.verdict === "candidate").sort(recentFirst),
+    unknowns: units.filter((u) => u.verdict === "unknown").sort(recentFirst),
+    newestCommitAt: newestCommit === null ? null : new Date(newestCommit).toISOString()
+  };
+}
+
 // src/runtime/child-process-runner.ts
 import { spawn as spawn2 } from "child_process";
 var DEFAULT_KILL_GRACE_MS = 5e3;
@@ -4818,55 +6209,6 @@ function classifySpawnError(error) {
 // src/schemas/json-schema.ts
 import { z as z11 } from "zod";
 
-// src/schemas/manifest.schema.ts
-import { z as z9 } from "zod";
-var ProjectSchema = z9.object({
-  name: z9.string().optional(),
-  description: z9.string().optional(),
-  repository_url: z9.string().nullable().optional()
-});
-var CapabilitiesSchema = z9.object({
-  enabled: z9.array(z9.string())
-});
-var ApprovalConfigSchema = z9.object({
-  required_for: z9.array(z9.string()).optional(),
-  default_risk_level: z9.enum(["low", "medium", "high", "critical"])
-});
-var ClaudeCodeAdapterConfigSchema = z9.object({
-  enabled: z9.boolean(),
-  config_path: z9.string().optional()
-});
-var AdaptersSchema = z9.object({
-  "claude-code": ClaudeCodeAdapterConfigSchema
-});
-var GitConfigSchema = z9.object({
-  events_log: z9.enum(["ignore", "commit"]).default("ignore")
-});
-var SOURCE_ROOT_PATTERN = /^(?![~/\\])(?![A-Za-z]:)[^\0\\]+$/;
-var SourceRootSchema = z9.string().min(1).regex(SOURCE_ROOT_PATTERN, {
-  message: "source_roots entries must be relative paths (no absolute path, '~', '\\', or null byte)"
-});
-var ImportConfigSchema = z9.object({
-  source_roots: z9.array(SourceRootSchema).min(1).optional()
-});
-var WorkspaceMetaSchema = z9.object({
-  id: WorkspaceIdSchema,
-  name: z9.string().min(1),
-  created_at: IsoTimestampSchema,
-  updated_at: IsoTimestampSchema
-});
-var ManifestSchema = z9.object({
-  schema_version: SchemaVersionSchema,
-  basou_version: z9.literal("0.1.0"),
-  workspace: WorkspaceMetaSchema,
-  project: ProjectSchema,
-  capabilities: CapabilitiesSchema,
-  approval: ApprovalConfigSchema,
-  adapters: AdaptersSchema,
-  git: GitConfigSchema,
-  import: ImportConfigSchema.optional()
-});
-
 // src/schemas/session-import.schema.ts
 import { z as z10 } from "zod";
 var SessionInnerImportSchema = z10.object({
@@ -4986,28 +6328,29 @@ function serializeJsonSchema(schema) {
 }
 
 // src/storage/basou-dir.ts
-import { lstat as lstat3, mkdir as mkdir4 } from "fs/promises";
-import { join as join15 } from "path";
+import { lstat as lstat4, mkdir as mkdir4 } from "fs/promises";
+import { join as join18 } from "path";
 function basouPaths(repositoryRoot) {
-  const root = join15(repositoryRoot, ".basou");
-  const approvalsBase = join15(root, "approvals");
+  const root = join18(repositoryRoot, ".basou");
+  const approvalsBase = join18(root, "approvals");
   return {
     root,
-    sessions: join15(root, "sessions"),
-    tasks: join15(root, "tasks"),
+    sessions: join18(root, "sessions"),
+    tasks: join18(root, "tasks"),
     approvals: {
-      pending: join15(approvalsBase, "pending"),
-      resolved: join15(approvalsBase, "resolved")
+      pending: join18(approvalsBase, "pending"),
+      resolved: join18(approvalsBase, "resolved")
     },
-    locks: join15(root, "locks"),
-    logs: join15(root, "logs"),
-    raw: join15(root, "raw"),
-    tmp: join15(root, "tmp"),
+    locks: join18(root, "locks"),
+    logs: join18(root, "logs"),
+    raw: join18(root, "raw"),
+    tmp: join18(root, "tmp"),
     files: {
-      manifest: join15(root, "manifest.yaml"),
-      status: join15(root, "status.json"),
-      handoff: join15(root, "handoff.md"),
-      decisions: join15(root, "decisions.md")
+      manifest: join18(root, "manifest.yaml"),
+      status: join18(root, "status.json"),
+      handoff: join18(root, "handoff.md"),
+      decisions: join18(root, "decisions.md"),
+      orientation: join18(root, "orientation.md")
     }
   };
 }
@@ -5025,9 +6368,9 @@ async function ensureBasouDirectory(repositoryRoot) {
   const paths = basouPaths(repositoryRoot);
   let existing;
   try {
-    existing = await lstat3(paths.root);
+    existing = await lstat4(paths.root);
   } catch (error) {
-    if (!hasErrorCode3(error) || error.code !== "ENOENT") {
+    if (!hasErrorCode4(error) || error.code !== "ENOENT") {
       throw new Error("Failed to inspect .basou directory", { cause: error });
     }
   }
@@ -5050,13 +6393,13 @@ async function mkdirLabeled(target, label) {
   try {
     await mkdir4(target, { recursive: true });
   } catch (error) {
-    if (hasErrorCode3(error) && (error.code === "ENOTDIR" || error.code === "EEXIST")) {
+    if (hasErrorCode4(error) && (error.code === "ENOTDIR" || error.code === "EEXIST")) {
       throw new Error(`${label} exists but is not a directory`, { cause: error });
     }
     throw new Error(`Failed to create ${label}`, { cause: error });
   }
 }
-function hasErrorCode3(error) {
+function hasErrorCode4(error) {
   if (!(error instanceof Error)) return false;
   const codeProp = error.code;
   return typeof codeProp === "string";
@@ -5064,28 +6407,30 @@ function hasErrorCode3(error) {
 
 // src/storage/gitignore.ts
 import { readFile as readFile8, writeFile as writeFile2 } from "fs/promises";
-import { join as join16 } from "path";
+import { join as join19 } from "path";
 var MARKER = "# Basou - default ignore";
-var BASOU_GITIGNORE_BLOCK = "# Basou - default ignore\n.basou/logs/\n.basou/raw/\n.basou/tmp/\n.basou/locks/\n.basou/status.json\n.basou/sessions/*/events.jsonl\n.basou/sessions/*/artifacts/\n.basou/approvals/pending/\n.basou/approvals/resolved/\n\n# Basou - default commit\n# .basou/manifest.yaml\n# .basou/handoff.md\n# .basou/decisions.md\n# .basou/tasks/\n# .basou/sessions/*/session.yaml\n# .basou/sessions/*/transcript.md\n# .basou/sessions/*/changed-files.json\n";
-async function appendBasouGitignore(repositoryRoot) {
-  const gitignorePath = join16(repositoryRoot, ".gitignore");
+var BASOU_GITIGNORE_BLOCK = "# Basou - default ignore\n.basou/logs/\n.basou/raw/\n.basou/tmp/\n.basou/locks/\n.basou/status.json\n.basou/orientation.md\n.basou/sessions/*/events.jsonl\n.basou/sessions/*/artifacts/\n.basou/approvals/pending/\n.basou/approvals/resolved/\n\n# Basou - default commit\n# .basou/manifest.yaml\n# .basou/handoff.md\n# .basou/decisions.md\n# .basou/tasks/\n# .basou/sessions/*/session.yaml\n# .basou/sessions/*/transcript.md\n# .basou/sessions/*/changed-files.json\n";
+var BASOU_GITIGNORE_BLOCK_LOCAL_ONLY = "# Basou - default ignore\n# Local-only: basou's trail is never committed (personal/local state,\n# regenerable by re-importing from the agents' own logs). Recommended for\n# monitored repos and any workspace kept out of version control.\n.basou/\n";
+async function appendBasouGitignore(repositoryRoot, options = {}) {
+  const gitignorePath = join19(repositoryRoot, ".gitignore");
   let body;
   let existed;
   try {
     body = await readFile8(gitignorePath, "utf8");
     existed = true;
   } catch (error) {
-    if (hasErrorCode4(error) && error.code === "ENOENT") {
+    if (hasErrorCode5(error) && error.code === "ENOENT") {
       body = "";
       existed = false;
     } else {
       throw new Error("Failed to read .gitignore", { cause: error });
     }
   }
-  if (existed && hasBasouMarker(body)) {
+  if (existed && hasBasouGitignore(body)) {
     return { appended: false };
   }
-  const next = composeNextBody(body);
+  const block = options.localOnly === true ? BASOU_GITIGNORE_BLOCK_LOCAL_ONLY : BASOU_GITIGNORE_BLOCK;
+  const next = composeNextBody(body, block);
   try {
     await writeFile2(gitignorePath, next, { encoding: "utf8" });
   } catch (error) {
@@ -5093,84 +6438,20 @@ async function appendBasouGitignore(repositoryRoot) {
   }
   return { appended: true };
 }
-function hasBasouMarker(body) {
+function hasBasouGitignore(body) {
   for (const rawLine of body.split("\n")) {
-    if (rawLine.trimEnd().startsWith(MARKER)) return true;
+    const line = rawLine.trimEnd();
+    if (line.startsWith(MARKER)) return true;
+    if (line === ".basou/" || line === "/.basou/") return true;
   }
   return false;
 }
-function composeNextBody(existing) {
-  if (existing.length === 0) return BASOU_GITIGNORE_BLOCK;
+function composeNextBody(existing, block) {
+  if (existing.length === 0) return block;
   const normalized = existing.endsWith("\n") ? existing : `${existing}
 `;
   return `${normalized}
-${BASOU_GITIGNORE_BLOCK}`;
-}
-function hasErrorCode4(error) {
-  if (!(error instanceof Error)) return false;
-  return typeof error.code === "string";
-}
-
-// src/storage/manifest.ts
-import { lstat as lstat4 } from "fs/promises";
-function createManifest(input) {
-  if (input.workspaceName.length === 0) {
-    throw new Error("Workspace name is empty. Pass --name explicitly.");
-  }
-  const now = (input.now ?? /* @__PURE__ */ new Date()).toISOString();
-  const workspaceId = input.workspaceId ?? prefixedUlid("ws");
-  const project = {
-    ...input.projectName !== void 0 ? { name: input.projectName } : {},
-    ...input.projectDescription !== void 0 ? { description: input.projectDescription } : {},
-    ...input.repositoryUrl !== void 0 ? { repository_url: input.repositoryUrl } : {}
-  };
-  const manifest = {
-    schema_version: "0.1.0",
-    basou_version: "0.1.0",
-    workspace: {
-      id: workspaceId,
-      name: input.workspaceName,
-      created_at: now,
-      updated_at: now
-    },
-    project,
-    capabilities: {
-      enabled: ["core", "claude-code-adapter", "terminal-recording", "git-capability", "approval"]
-    },
-    approval: {
-      required_for: ["destructive_command", "external_send"],
-      default_risk_level: "medium"
-    },
-    adapters: {
-      "claude-code": { enabled: true }
-    },
-    git: { events_log: "ignore" },
-    ...input.sourceRoots !== void 0 && input.sourceRoots.length > 0 ? { import: { source_roots: input.sourceRoots } } : {}
-  };
-  return ManifestSchema.parse(manifest);
-}
-async function writeManifest(paths, manifest, options) {
-  const force = options?.force === true;
-  const validated = ManifestSchema.parse(manifest);
-  if (!force) {
-    let existed = false;
-    try {
-      await lstat4(paths.files.manifest);
-      existed = true;
-    } catch (error) {
-      if (!hasErrorCode5(error) || error.code !== "ENOENT") {
-        throw new Error("Failed to inspect existing manifest", { cause: error });
-      }
-    }
-    if (existed) {
-      throw new Error("Already initialized. Use --force to overwrite.");
-    }
-  }
-  await writeYamlFile(paths.files.manifest, validated);
-}
-async function readManifest(paths) {
-  const raw = await readYamlFile(paths.files.manifest);
-  return ManifestSchema.parse(raw);
+${block}`;
 }
 function hasErrorCode5(error) {
   if (!(error instanceof Error)) return false;
@@ -5282,8 +6563,8 @@ function hasErrorCode6(error) {
 
 // src/storage/session-import.ts
 import { mkdir as mkdir5, readFile as readFile10, rm as rm2 } from "fs/promises";
-import { homedir as homedir2 } from "os";
-import { join as join17 } from "path";
+import { homedir as homedir3 } from "os";
+import { join as join20 } from "path";
 async function importSessionFromJson(paths, manifest, payload, options) {
   if (options.taskIdOverride !== void 0 && !TaskIdSchema.safeParse(options.taskIdOverride).success) {
     throw new Error(`Invalid task_id: ${options.taskIdOverride}`);
@@ -5308,7 +6589,7 @@ async function importSessionFromJson(paths, manifest, payload, options) {
       pathSanitizeReport
     };
   }
-  const sessionDir = join17(paths.sessions, newSessionId);
+  const sessionDir = join20(paths.sessions, newSessionId);
   try {
     await mkdir5(sessionDir, { recursive: true });
   } catch (error) {
@@ -5322,7 +6603,7 @@ async function importSessionFromJson(paths, manifest, payload, options) {
     throw error;
   }
   try {
-    const sessionYamlPath = join17(sessionDir, "session.yaml");
+    const sessionYamlPath = join20(sessionDir, "session.yaml");
     await linkYamlFile(sessionYamlPath, withIntegrity(sessionRecord, chainResult));
   } catch (error) {
     await rm2(sessionDir, { recursive: true, force: true }).catch(() => void 0);
@@ -5391,7 +6672,7 @@ function withIntegrity(record, chainResult) {
   };
 }
 function buildSessionRecord(input, manifest, newSessionId, options) {
-  const home = homedir2();
+  const home = homedir3();
   const workingDirectoryRaw = input.working_directory;
   const workingDirectorySanitized = sanitizeWorkingDirectory(workingDirectoryRaw, {
     homedir: home
@@ -5490,7 +6771,7 @@ function reuseDerivedIds(priorDerived, freshDerived, sessionId) {
 async function reimportPreservingId(paths, manifest, priorSessionId, freshPayload, options = {}) {
   const sessionId = priorSessionId;
   const importSource = freshPayload.session.source.kind;
-  const sessionDir = join17(paths.sessions, priorSessionId);
+  const sessionDir = join20(paths.sessions, priorSessionId);
   const lock = options.dryRun === true ? null : await acquireLock(paths, "session", priorSessionId);
   try {
     const priorVerdict = await verifyEventsChain(paths, priorSessionId);
@@ -5532,7 +6813,7 @@ async function reimportPreservingId(paths, manifest, priorSessionId, freshPayloa
     };
     const updatedRecord = { schema_version: "0.1.0", session: preservedInner };
     if (options.dryRun !== true) {
-      const eventsPath = join17(sessionDir, "events.jsonl");
+      const eventsPath = join20(sessionDir, "events.jsonl");
       let priorEventsRaw = null;
       try {
         priorEventsRaw = await readFile10(eventsPath);
@@ -5544,7 +6825,7 @@ async function reimportPreservingId(paths, manifest, priorSessionId, freshPayloa
       const chainResult = await writeEventsBulk(sessionDir, mergedEvents, { chain: true });
       try {
         await overwriteYamlFile(
-          join17(sessionDir, "session.yaml"),
+          join20(sessionDir, "session.yaml"),
           withIntegrity(updatedRecord, chainResult)
         );
       } catch (error) {
@@ -5568,7 +6849,7 @@ async function reimportPreservingId(paths, manifest, priorSessionId, freshPayloa
   }
 }
 async function rechainSessionInPlace(paths, sessionId, options = {}) {
-  const sessionDir = join17(paths.sessions, sessionId);
+  const sessionDir = join20(paths.sessions, sessionId);
   let lock;
   try {
     lock = await acquireLock(paths, "session", sessionId);
@@ -5601,7 +6882,7 @@ async function rechainSessionInPlace(paths, sessionId, options = {}) {
     if (verdict.status !== "unchained") {
       return { status: "skipped", reason: "tampered" };
     }
-    const eventsPath = join17(sessionDir, "events.jsonl");
+    const eventsPath = join20(sessionDir, "events.jsonl");
     let priorRaw;
     try {
       priorRaw = await readFile10(eventsPath);
@@ -5649,7 +6930,7 @@ async function rechainSessionInPlace(paths, sessionId, options = {}) {
     }
     try {
       await overwriteYamlFile(
-        join17(sessionDir, "session.yaml"),
+        join20(sessionDir, "session.yaml"),
         withIntegrity(record, { headHash: chainResult.headHash, count: chainResult.count })
       );
     } catch (error) {
@@ -5731,23 +7012,34 @@ export {
   enumerateTaskIds,
   finalizeSessionYaml,
   findErrorCode,
+  findReviewGaps,
   formatDurationMs,
   genesisHash,
   getDiff,
   getSnapshot,
   importSessionFromJson,
   inspectChainTail,
+  isGitNotFound,
   isImportDerivedSource,
   isLazyExpired,
+  isRenderable,
   isValidPrefixedId,
   lineHash,
   linkYamlFile,
   loadApproval,
   loadSessionEntries,
   loadTaskEntries,
+  normalizeRepoKey,
+  normalizeRepoPath,
   overwriteYamlFile,
   parseDuration,
   parseMarkers,
+  pathBasename,
+  planArchive,
+  planGitignore,
+  planRename,
+  planRosterAdoption,
+  planWorkspaceView,
   prefixedUlid,
   readAllEvents,
   readManifest,
@@ -5759,18 +7051,23 @@ export {
   readYamlFile,
   rechainSessionInPlace,
   reconcileAllTasks,
+  reconcileSourceRoots,
   reconcileTask,
   refreshTaskLinkedSessions,
   reimportPreservingId,
   renderDecisions,
   renderHandoff,
+  renderOrientation,
+  renderPresetBlock,
   renderReport,
   renderWithMarkers,
   replayEvents,
+  resolveBasouRepositoryRoot,
   resolveClaudeCodeCommand,
   resolveRepositoryRoot,
   resolveSessionId,
   resolveTaskId,
+  safeSimpleGit,
   sanitizePath,
   sanitizeRelatedFiles,
   sanitizeWorkingDirectory,
@@ -5778,8 +7075,14 @@ export {
   serializeJsonSchema,
   sessionWorkStatsFromEvents,
   summarizeAdapterOutput,
+  summarizeOrientation,
+  summarizePresetPlan,
+  summarizeRosterDrift,
+  summarizeSymlinkPlan,
+  summarizeWiring,
   tryRemoteUrl,
   ulid,
+  unknownManifestKeys,
   updateTaskStatusWithEvent,
   verifyEventsChain,
   writeEventsBulk,