@basou/cli 0.6.0 → 0.7.0

package/dist/index.js

@@ -1327,9 +1327,9 @@ async function assertWorkspaceInitialized4(basouRoot) {
 
 // src/commands/import.ts
 import { createReadStream } from "fs";
-import { readdir, readFile, rm } from "fs/promises";
+import { readdir, readFile, rm, stat } from "fs/promises";
 import { homedir as homedir2 } from "os";
-import { basename, join as join3 } from "path";
+import { basename, join as join3, resolve } from "path";
 import { createInterface } from "readline";
 import {
   assertBasouRootSafe as assertBasouRootSafe6,
@@ -1348,11 +1348,16 @@ import {
 } from "@basou/core";
 var SES_PREFIX2 = "ses_";
 var SHORT_ID_LEN2 = 6;
+function collectPath(value, previous) {
+  return [...previous, value];
+}
 function registerImportCommand(program2) {
   const importCmd = program2.command("import").description("Import provenance from an external AI tool's native logs");
   importCmd.command("claude-code").description("Derive Basou sessions from Claude Code native transcripts (~/.claude/projects)").option(
     "--project <path>",
-    "Source project path whose transcripts to import (defaults to the current repository root)"
+    "Source project path whose transcripts to import (repeatable; defaults to the manifest source roots, then the repository root)",
+    collectPath,
+    []
   ).option("--session <id>", "Import a single transcript by its Claude session id").option("--all", "Import every transcript found for the project").option(
     "--force",
     "Re-import sessions already imported: delete and replace them instead of skipping"
@@ -1361,7 +1366,9 @@ function registerImportCommand(program2) {
   });
   importCmd.command("codex").description("Derive Basou sessions from OpenAI Codex native rollout logs (~/.codex/sessions)").option(
     "--project <path>",
-    "Source project path whose rollouts to import (defaults to the current repository root)"
+    "Source project path whose rollouts to import (repeatable; defaults to the manifest source roots, then the repository root)",
+    collectPath,
+    []
   ).option("--session <id>", "Import a single rollout by its Codex session id").option("--all", "Import every rollout found for the project").option(
     "--force",
     "Re-import sessions already imported: delete and replace them instead of skipping"
@@ -1385,13 +1392,28 @@ async function runImportCodex(options, ctx = {}) {
     process.exitCode = 1;
   }
 }
+function resolveSourceRoots(args) {
+  const { projectFlags, manifest, repoRoot, cwd } = args;
+  let resolved;
+  if (projectFlags.length > 0) {
+    resolved = projectFlags.map((p) => resolve(cwd, p));
+  } else {
+    const roots = manifest.import?.source_roots;
+    resolved = roots !== void 0 && roots.length > 0 ? roots.map((r) => resolve(repoRoot, r)) : [repoRoot];
+  }
+  return [...new Set(resolved)];
+}
 async function doRunImportClaudeCode(options, ctx) {
   assertSelector(options);
   const { repositoryRoot, paths, manifest } = await resolveImportTarget(ctx);
-  const projectPath = options.project ?? repositoryRoot;
+  const projectPaths = resolveSourceRoots({
+    projectFlags: options.project ?? [],
+    manifest,
+    repoRoot: repositoryRoot,
+    cwd: ctx.cwd ?? process.cwd()
+  });
   const projectsRoot = ctx.claudeProjectsDir ?? join3(homedir2(), ".claude", "projects");
-  const transcriptDir = join3(projectsRoot, encodeProjectDir(projectPath));
-  const files = await selectTranscriptFiles(transcriptDir, options);
+  const files = await selectTranscriptFiles(projectsRoot, projectPaths, options);
   const candidates = files.map((file) => {
     const externalId = basename(file, ".jsonl");
     return {
@@ -1407,9 +1429,14 @@ async function doRunImportClaudeCode(options, ctx) {
 async function doRunImportCodex(options, ctx) {
   assertSelector(options);
   const { repositoryRoot, paths, manifest } = await resolveImportTarget(ctx);
-  const projectPath = options.project ?? repositoryRoot;
+  const projectPaths = resolveSourceRoots({
+    projectFlags: options.project ?? [],
+    manifest,
+    repoRoot: repositoryRoot,
+    cwd: ctx.cwd ?? process.cwd()
+  });
   const sessionsRoot = ctx.codexSessionsDir ?? join3(homedir2(), ".codex", "sessions");
-  const rollouts = await discoverCodexRollouts(sessionsRoot, projectPath, options);
+  const rollouts = await discoverCodexRollouts(sessionsRoot, projectPaths, options);
   const candidates = rollouts.map(({ file, externalId }) => ({
     externalId,
     toPayload: async () => codexRolloutToImportPayload(await readJsonlRecords(file), {
@@ -1420,6 +1447,9 @@ async function doRunImportCodex(options, ctx) {
   await importDerivedSessions(paths, manifest, options, CODEX_IMPORT_SOURCE, candidates);
 }
 function assertSelector(options) {
+  if (options.session !== void 0 && options.all === true) {
+    throw new Error("Specify either --session <id> or --all, not both");
+  }
   if (options.session === void 0 && options.all !== true) {
     throw new Error("Specify --session <id> or --all");
   }
@@ -1517,28 +1547,56 @@ async function loadExistingByExternalId(paths, sourceKind) {
   }
   return byExternalId;
 }
-async function selectTranscriptFiles(transcriptDir, options) {
+async function selectTranscriptFiles(projectsRoot, projectPaths, options) {
   if (options.session !== void 0) {
-    return [join3(transcriptDir, `${options.session}.jsonl`)];
+    const matches = [];
+    for (const projectPath of projectPaths) {
+      const file = join3(projectsRoot, encodeProjectDir(projectPath), `${options.session}.jsonl`);
+      if (await pathExists(file)) matches.push(file);
+    }
+    if (matches.length === 0) {
+      throw new Error("Claude transcript not found for session id in project");
+    }
+    return [...new Set(matches)];
+  }
+  const files = [];
+  let anyDirFound = false;
+  for (const projectPath of projectPaths) {
+    const transcriptDir = join3(projectsRoot, encodeProjectDir(projectPath));
+    let entries;
+    try {
+      entries = await readdir(transcriptDir);
+    } catch (error) {
+      if (findErrorCode5(error, "ENOENT")) continue;
+      throw new Error("Failed to read Claude transcript directory", { cause: error });
+    }
+    anyDirFound = true;
+    for (const name of entries) {
+      if (name.endsWith(".jsonl")) files.push(join3(transcriptDir, name));
+    }
+  }
+  if (!anyDirFound) {
+    throw new Error("Claude transcript directory not found for project");
   }
-  let entries;
+  return [...new Set(files)].sort();
+}
+async function pathExists(file) {
   try {
-    entries = await readdir(transcriptDir);
+    await stat(file);
+    return true;
   } catch (error) {
-    if (findErrorCode5(error, "ENOENT")) {
-      throw new Error("Claude transcript directory not found for project", { cause: error });
-    }
-    throw new Error("Failed to read Claude transcript directory", { cause: error });
+    if (findErrorCode5(error, "ENOENT")) return false;
+    throw error;
   }
-  return entries.filter((name) => name.endsWith(".jsonl")).sort().map((name) => join3(transcriptDir, name));
 }
-async function discoverCodexRollouts(sessionsRoot, projectPath, options) {
+async function discoverCodexRollouts(sessionsRoot, projectPaths, options) {
+  const projectSet = new Set(projectPaths);
   const files = await findRolloutFiles(sessionsRoot);
   const matched = [];
   for (const file of files) {
     const meta = await readRolloutMeta(file);
     if (meta === void 0) continue;
-    if (meta.cwd !== projectPath) continue;
+    if (!projectSet.has(meta.cwd)) continue;
     if (options.session !== void 0 && meta.id !== options.session) continue;
     matched.push({ file, externalId: meta.id });
   }
@@ -1709,7 +1767,7 @@ async function assertWorkspaceInitialized5(basouRoot) {
 }
 
 // src/commands/init.ts
-import { basename as basename2 } from "path";
+import { basename as basename2, relative, resolve as resolve2 } from "path";
 import {
   appendBasouGitignore,
   createManifest,
@@ -1718,10 +1776,18 @@ import {
   tryRemoteUrl,
   writeManifest
 } from "@basou/core";
+function collectValue(value, previous) {
+  return [...previous, value];
+}
 function registerInitCommand(program2) {
   program2.command("init").description("Initialize a Basou workspace at the current Git repository root").option("--name <name>", "Workspace name (defaults to the repository directory name)").option("--project-name <name>", "Project display name").option("--project-description <description>", "Project description").option(
     "--repo-url <url>",
     "Repository URL (defaults to git remote.origin.url; pass empty string for null)"
+  ).option(
+    "--source-root <path>",
+    "Extra import source root, relative to the repo root (repeatable; aggregates sibling repos into this workspace)",
+    collectValue,
+    []
   ).option("-f, --force", "Overwrite an existing manifest").option("-v, --verbose", "Show error causes").action(async (options) => {
     await runInit(options);
   });
@@ -1744,12 +1810,17 @@ async function doRunInit(options, ctx) {
   } else {
     repositoryUrl = await tryRemoteUrl(repositoryRoot);
   }
+  const sourceRoots = (options.sourceRoot ?? []).map((p) => {
+    const rel = relative(repositoryRoot, resolve2(cwd, p));
+    return rel === "" ? "." : rel;
+  });
   const paths = await ensureBasouDirectory(repositoryRoot);
   const manifest = createManifest({
     workspaceName,
     ...options.projectName !== void 0 ? { projectName: options.projectName } : {},
     ...options.projectDescription !== void 0 ? { projectDescription: options.projectDescription } : {},
-    ...repositoryUrl !== void 0 ? { repositoryUrl } : {}
+    ...repositoryUrl !== void 0 ? { repositoryUrl } : {},
+    ...sourceRoots.length > 0 ? { sourceRoots } : {}
   });
   await writeManifest(paths, manifest, { force: options.force === true });
   try {
@@ -1783,7 +1854,8 @@ async function resolveRepositoryRootForInit(cwd) {
 }
 
 // src/commands/refresh.ts
-import { assertBasouRootSafe as assertBasouRootSafe7, basouPaths as basouPaths7, findErrorCode as findErrorCode6, resolveRepositoryRoot as resolveRepositoryRoot8 } from "@basou/core";
+import { assertBasouRootSafe as assertBasouRootSafe7, basouPaths as basouPaths7, findErrorCode as findErrorCode7, resolveRepositoryRoot as resolveRepositoryRoot8 } from "@basou/core";
+import { InvalidArgumentError as InvalidArgumentError2 } from "commander";
 
 // src/lib/provenance-actions.ts
 import {
@@ -1906,25 +1978,213 @@ async function refreshAll(args) {
   };
 }
 
+// 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";
+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")
+  ];
+}
+async function scanSourceLogs(roots) {
+  const out = /* @__PURE__ */ new Map();
+  const walk = async (dir) => {
+    let entries;
+    try {
+      entries = await readdir2(dir, { withFileTypes: true });
+    } catch (error) {
+      if (findErrorCode6(error, "ENOENT") || findErrorCode6(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);
+      if (entry.isDirectory()) {
+        await walk(full);
+      } else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
+        try {
+          const info = await stat2(full);
+          out.set(full, { mtimeMs: info.mtimeMs, size: info.size });
+        } catch (error) {
+          if (findErrorCode6(error, "ENOENT")) continue;
+          throw new Error("Failed to stat a source log file", { cause: error });
+        }
+      }
+    }
+  };
+  for (const root of roots) await walk(root);
+  return out;
+}
+function scansEqual(a, b) {
+  if (a.size !== b.size) return false;
+  for (const [path, sig] of a) {
+    const other = b.get(path);
+    if (other === void 0 || other.mtimeMs !== sig.mtimeMs || other.size !== sig.size) {
+      return false;
+    }
+  }
+  return true;
+}
+function importedCount(outcome) {
+  return outcome.status === "ran" ? outcome.importedCount : 0;
+}
+function describeOutcome(outcome) {
+  return outcome.status === "ran" ? `${outcome.adapter} +${outcome.importedCount}` : `${outcome.adapter} skipped`;
+}
+function hms(date) {
+  return date.toISOString().slice(11, 19);
+}
+async function runImports(deps) {
+  const claude = await importClaudeCode(deps.importOptions, deps.ctx);
+  const codex = await importCodex(deps.importOptions, deps.ctx);
+  return { claude, codex, imported: importedCount(claude) + importedCount(codex) };
+}
+async function regenerate(deps) {
+  const nowIso = deps.now().toISOString();
+  const handoff = await regenerateHandoff(deps.paths, nowIso);
+  await regenerateDecisions(deps.paths, nowIso);
+  return handoff.sessionCount;
+}
+async function runRefreshWatch(deps) {
+  const { intervalMs, ctx, signal, sleep, log } = deps;
+  const roots = watchedRoots(ctx);
+  log(
+    `watching ${roots.join(", ")} every ${Math.round(intervalMs / 1e3)}s (imports on change; Ctrl-C to stop)`
+  );
+  let lastScan = await scanSourceLogs(roots);
+  let importedScan = lastScan;
+  const initial = await runImports(deps);
+  const initialSessions = await regenerate(deps);
+  log(
+    `[${hms(deps.now())}] refreshed: ${describeOutcome(initial.codex)}, ${describeOutcome(initial.claude)} (sessions: ${initialSessions})`
+  );
+  if (signal.aborted) {
+    log("watch stopped");
+    return;
+  }
+  let pendingRegen = false;
+  while (!signal.aborted) {
+    await sleep(intervalMs, signal);
+    if (signal.aborted) break;
+    try {
+      const current = await scanSourceLogs(roots);
+      if (scansEqual(current, lastScan) && !scansEqual(current, importedScan)) {
+        const { claude, codex, imported } = await runImports(deps);
+        if (imported > 0) pendingRegen = true;
+        if (pendingRegen) {
+          const sessions = await regenerate(deps);
+          pendingRegen = false;
+          log(
+            `[${hms(deps.now())}] refreshed: ${describeOutcome(codex)}, ${describeOutcome(claude)} (sessions: ${sessions})`
+          );
+        }
+        importedScan = current;
+      }
+      lastScan = current;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      log(`[${hms(deps.now())}] refresh cycle skipped: ${message}`);
+    }
+  }
+  log("watch stopped");
+}
+
 // src/commands/refresh.ts
+function collectPath2(value, previous) {
+  return [...previous, value];
+}
+function parseInterval(value) {
+  const seconds = Number(value);
+  if (!Number.isInteger(seconds) || seconds < MIN_WATCH_INTERVAL_SEC || seconds > MAX_WATCH_INTERVAL_SEC) {
+    throw new InvalidArgumentError2(
+      `--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((resolve3) => {
+    if (signal.aborted) {
+      resolve3();
+      return;
+    }
+    let timer;
+    const onAbort = () => {
+      clearTimeout(timer);
+      resolve3();
+    };
+    timer = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve3();
+    }, ms);
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
 function registerRefreshCommand(program2) {
   program2.command("refresh").description(
     "Import all adapters for the project and regenerate handoff + decisions in one step"
   ).option(
     "--project <path>",
-    "Source project path to import (defaults to the current repository root)"
-  ).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("-v, --verbose", "Show error causes").action(async (options) => {
+    "Source project path to import (repeatable; defaults to the manifest source roots, then the repository root)",
+    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(
+    "--watch",
+    "Keep running: re-import + regenerate when the native logs change (Ctrl-C to stop)"
+  ).option(
+    "--interval <seconds>",
+    `Poll interval for --watch, in seconds (default ${DEFAULT_WATCH_INTERVAL_SEC}, min ${MIN_WATCH_INTERVAL_SEC})`,
+    parseInterval
+  ).option("-v, --verbose", "Show error causes").action(async (options) => {
     await runRefresh(options);
   });
 }
 async function runRefresh(options, ctx = {}) {
   try {
-    await doRunRefresh(options, ctx);
+    if (options.watch === true) {
+      await doRunRefreshWatch(options, ctx);
+    } else {
+      await doRunRefresh(options, ctx);
+    }
   } catch (error) {
     renderCliError(error, { verbose: isVerbose(options) });
     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 intervalMs = (options.interval ?? DEFAULT_WATCH_INTERVAL_SEC) * 1e3;
+  const controller = new AbortController();
+  const onSignal = () => controller.abort();
+  process.on("SIGINT", onSignal);
+  process.on("SIGTERM", onSignal);
+  try {
+    await runRefreshWatch({
+      ctx,
+      paths,
+      intervalMs,
+      importOptions: options.project !== void 0 && options.project.length > 0 ? { project: options.project } : {},
+      now: () => ctx.nowProvider?.() ?? /* @__PURE__ */ new Date(),
+      signal: controller.signal,
+      sleep: abortableSleep,
+      log: (line) => console.log(line)
+    });
+  } finally {
+    process.off("SIGINT", onSignal);
+    process.off("SIGTERM", onSignal);
+  }
+}
 async function doRunRefresh(options, ctx) {
   const cwd = ctx.cwd ?? process.cwd();
   const repositoryRoot = await resolveRepositoryRootForRefresh(cwd);
@@ -1933,7 +2193,7 @@ async function doRunRefresh(options, ctx) {
   const nowIso = (ctx.nowProvider?.() ?? /* @__PURE__ */ new Date()).toISOString();
   const result = await refreshAll({
     options: {
-      ...options.project !== void 0 ? { project: options.project } : {},
+      ...options.project !== void 0 && options.project.length > 0 ? { project: options.project } : {},
       ...options.force === true ? { force: true } : {},
       ...options.dryRun === true ? { dryRun: true } : {}
     },
@@ -1991,7 +2251,7 @@ async function assertWorkspaceInitialized6(basouRoot) {
   try {
     await assertBasouRootSafe7(basouRoot);
   } catch (error) {
-    if (findErrorCode6(error, "ENOENT")) {
+    if (findErrorCode7(error, "ENOENT")) {
       throw new Error("Workspace not initialized. Run 'basou init' first.");
     }
     throw error;
@@ -2000,8 +2260,8 @@ async function assertWorkspaceInitialized6(basouRoot) {
 
 // src/commands/run.ts
 import { mkdir as mkdir2 } from "fs/promises";
-import { homedir as homedir3 } from "os";
-import { join as join4 } from "path";
+import { homedir as homedir4 } from "os";
+import { join as join5 } from "path";
 import {
   assertBasouRootSafe as assertBasouRootSafe8,
   basouPaths as basouPaths8,
@@ -2053,10 +2313,10 @@ async function runClaudeCode(args, options, ctx = {}) {
   await assertBasouRootSafe8(paths.root);
   const manifest = await readManifest4(paths);
   const sessionId = prefixedUlid4("ses");
-  const sessionDir = join4(paths.sessions, sessionId);
+  const sessionDir = join5(paths.sessions, sessionId);
   await mkdir2(sessionDir, { recursive: true });
   const startedAt = now().toISOString();
-  const sessionYamlPath = join4(sessionDir, "session.yaml");
+  const sessionYamlPath = join5(sessionDir, "session.yaml");
   const session = buildInitialSession2({
     id: sessionId,
     command,
@@ -2177,7 +2437,7 @@ async function runClaudeCode(args, options, ctx = {}) {
   const rawRelated = computeRelatedFiles(preSnapshot, postSnapshot, diff);
   const relatedFiles = sanitizeRelatedFiles(rawRelated, {
     workingDirectory: repoRoot,
-    homedir: homedir3()
+    homedir: homedir4()
   }).sanitized;
   const finalStatus = decideFinalStatus2(result, signalReceived);
   await appendEvent2(sessionDir, {
@@ -2321,7 +2581,7 @@ function buildInitialSession2(input) {
       source: { ...claudeCodeAdapterMetadata },
       started_at: input.startedAt,
       status: "initialized",
-      working_directory: sanitizeWorkingDirectory2(input.cwd, { homedir: homedir3() }),
+      working_directory: sanitizeWorkingDirectory2(input.cwd, { homedir: homedir4() }),
       invocation: {
         command: input.command,
         args: [...input.args],
@@ -2394,13 +2654,13 @@ async function resolveRepositoryRootForRun(cwd) {
 
 // src/commands/session.ts
 import { readFile as readFile2 } from "fs/promises";
-import { basename as basename3, isAbsolute, join as join5, relative } from "path";
+import { basename as basename3, isAbsolute, join as join6, relative as relative2 } from "path";
 import {
   acquireLock as acquireLock2,
   appendEventToExistingSession as appendEventToExistingSession2,
   assertBasouRootSafe as assertBasouRootSafe9,
   basouPaths as basouPaths9,
-  findErrorCode as findErrorCode7,
+  findErrorCode as findErrorCode8,
   importSessionFromJson as importSessionFromJson2,
   loadSessionEntries,
   readAllEvents,
@@ -2414,7 +2674,7 @@ import {
   SessionStatusSchema,
   sessionWorkStatsFromEvents
 } from "@basou/core";
-import { InvalidArgumentError as InvalidArgumentError2 } from "commander";
+import { InvalidArgumentError as InvalidArgumentError3 } from "commander";
 
 // src/lib/format-duration.ts
 function formatDurationMs(ms) {
@@ -2521,14 +2781,14 @@ async function doRunSessionShow(idInput, options, ctx) {
   const paths = basouPaths9(repositoryRoot);
   await assertWorkspaceInitialized7(paths.root);
   const sessionId = await resolveSessionId2(paths, idInput);
-  const sessionDir = join5(paths.sessions, sessionId);
-  const sessionYamlPath = join5(sessionDir, "session.yaml");
+  const sessionDir = join6(paths.sessions, sessionId);
+  const sessionYamlPath = join6(sessionDir, "session.yaml");
   let session;
   try {
     const raw = await readYamlFile4(sessionYamlPath);
     session = SessionSchema3.parse(raw);
   } catch (error) {
-    if (findErrorCode7(error, "ENOENT")) {
+    if (findErrorCode8(error, "ENOENT")) {
       throw new Error(`Session not found: ${idInput}`);
     }
     throw new Error("Failed to read session", { cause: error });
@@ -2648,7 +2908,7 @@ function formatWorkingDir(workingDir, repositoryRoot, options) {
     return workingDir;
   }
   if (workingDir === repositoryRoot) return "<repository_root>";
-  const rel = relative(repositoryRoot, workingDir);
+  const rel = relative2(repositoryRoot, workingDir);
   if (rel.length === 0 || rel === ".") return "<repository_root>";
   if (rel.startsWith("..")) return rel;
   return `./${rel}`;
@@ -2778,7 +3038,7 @@ async function assertWorkspaceInitialized7(basouRoot) {
   try {
     await assertBasouRootSafe9(basouRoot);
   } catch (error) {
-    if (findErrorCode7(error, "ENOENT")) {
+    if (findErrorCode8(error, "ENOENT")) {
       throw new Error("Workspace not initialized. Run 'basou init' first.");
     }
     throw error;
@@ -2847,10 +3107,10 @@ async function readInputFile(path) {
   try {
     return await readFile2(path, "utf8");
   } catch (error) {
-    if (findErrorCode7(error, "ENOENT")) {
+    if (findErrorCode8(error, "ENOENT")) {
       throw new Error("Import source not found", { cause: error });
     }
-    if (findErrorCode7(error, "EISDIR")) {
+    if (findErrorCode8(error, "EISDIR")) {
       throw new Error("Import source is not a file", { cause: error });
     }
     throw new Error("Failed to read import source", { cause: error });
@@ -2865,19 +3125,19 @@ function parseJsonStrict(body) {
 }
 function parseImportFormat(raw) {
   if (raw !== "json") {
-    throw new InvalidArgumentError2(`Unsupported format: ${raw}. Valid values: json`);
+    throw new InvalidArgumentError3(`Unsupported format: ${raw}. Valid values: json`);
   }
   return "json";
 }
 function parseLabelOverride(raw) {
   if (raw.length === 0) {
-    throw new InvalidArgumentError2("Label must not be empty");
+    throw new InvalidArgumentError3("Label must not be empty");
   }
   return raw;
 }
 function parseTaskIdOverride(raw) {
   if (raw.length === 0) {
-    throw new InvalidArgumentError2("Task id is empty");
+    throw new InvalidArgumentError3("Task id is empty");
   }
   return raw;
 }
@@ -2964,10 +3224,10 @@ async function readNoteFile(path) {
   try {
     return await readFile2(path, "utf8");
   } catch (error) {
-    if (findErrorCode7(error, "ENOENT")) {
+    if (findErrorCode8(error, "ENOENT")) {
       throw new Error("Note source not found", { cause: error });
     }
-    if (findErrorCode7(error, "EISDIR")) {
+    if (findErrorCode8(error, "EISDIR")) {
       throw new Error("Note source is not a file", { cause: error });
     }
     throw new Error("Failed to read note source", { cause: error });
@@ -2975,7 +3235,7 @@ async function readNoteFile(path) {
 }
 function parseNoteBodyOption(raw) {
   if (raw.length === 0) {
-    throw new InvalidArgumentError2("--body must not be empty");
+    throw new InvalidArgumentError3("--body must not be empty");
   }
   return raw;
 }
@@ -3001,7 +3261,7 @@ import {
   assertBasouRootSafe as assertBasouRootSafe10,
   basouPaths as basouPaths10,
   computeWorkStats,
-  findErrorCode as findErrorCode8,
+  findErrorCode as findErrorCode9,
   resolveRepositoryRoot as resolveRepositoryRoot11
 } from "@basou/core";
 function registerStatsCommand(program2) {
@@ -3119,7 +3379,7 @@ async function assertWorkspaceInitialized8(basouRoot) {
   try {
     await assertBasouRootSafe10(basouRoot);
   } catch (error) {
-    if (findErrorCode8(error, "ENOENT")) {
+    if (findErrorCode9(error, "ENOENT")) {
       throw new Error("Workspace not initialized. Run 'basou init' first.");
     }
     throw error;
@@ -3131,7 +3391,7 @@ import {
   assertBasouRootSafe as assertBasouRootSafe11,
   basouPaths as basouPaths11,
   buildStatusSnapshot,
-  findErrorCode as findErrorCode9,
+  findErrorCode as findErrorCode10,
   readManifest as readManifest6,
   resolveRepositoryRoot as resolveRepositoryRoot12,
   writeStatus
@@ -3156,7 +3416,7 @@ async function doRunStatus(options, ctx) {
   try {
     await assertBasouRootSafe11(paths.root);
   } catch (error) {
-    if (findErrorCode9(error, "ENOENT")) {
+    if (findErrorCode10(error, "ENOENT")) {
       throw new Error("Workspace not initialized. Run 'basou init' first.");
     }
     throw error;
@@ -3165,7 +3425,7 @@ async function doRunStatus(options, ctx) {
   try {
     manifest = await readManifest6(paths);
   } catch (error) {
-    if (findErrorCode9(error, "ENOENT")) {
+    if (findErrorCode10(error, "ENOENT")) {
       throw new Error("Workspace not initialized. Run 'basou init' first.");
     }
     throw new Error("Failed to read workspace manifest", { cause: error });
@@ -3202,7 +3462,7 @@ async function resolveRepositoryRootForStatus(cwd) {
 
 // src/commands/task.ts
 import { readFile as readFile3 } from "fs/promises";
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 import {
   archiveTask,
   assertBasouRootSafe as assertBasouRootSafe12,
@@ -3211,7 +3471,7 @@ import {
   deleteTask,
   editTask,
   enumerateArchivedTaskIds,
-  findErrorCode as findErrorCode10,
+  findErrorCode as findErrorCode11,
   loadSessionEntries as loadSessionEntries2,
   loadTaskEntries,
   prefixedUlid as prefixedUlid5,
@@ -3229,7 +3489,7 @@ import {
   TaskWriteAfterEventError,
   updateTaskStatusWithEvent
 } from "@basou/core";
-import { InvalidArgumentError as InvalidArgumentError3 } from "commander";
+import { InvalidArgumentError as InvalidArgumentError4 } from "commander";
 var STATUS_VALUES3 = TaskStatusSchema.options;
 function registerTaskCommand(program2) {
   const task = program2.command("task").description("Manage Basou tasks (purpose units that span sessions)");
@@ -3529,7 +3789,7 @@ async function doRunTaskShow(idInput, options, ctx) {
   const events = [];
   const linkedSessionIds = new Set(doc.task.task.linked_sessions);
   for (const s of sessions) {
-    const sessionDir = join6(paths.sessions, s.sessionId);
+    const sessionDir = join7(paths.sessions, s.sessionId);
     try {
       for await (const ev of replayEvents2(sessionDir, {
         onWarning: (w) => printReplayWarning(w, s.sessionId)
@@ -4158,20 +4418,20 @@ async function readSingleLineFromStdin() {
 }
 function parseTitle2(raw) {
   if (raw.length === 0) {
-    throw new InvalidArgumentError3("Title must not be empty");
+    throw new InvalidArgumentError4("Title must not be empty");
   }
   return raw;
 }
 function parseLabel(raw) {
   if (raw.length === 0) {
-    throw new InvalidArgumentError3("Label must not be empty");
+    throw new InvalidArgumentError4("Label must not be empty");
   }
   return raw;
 }
 function parseInitialTaskStatus(raw) {
   const result = TaskStatusSchema.safeParse(raw);
   if (!result.success) {
-    throw new InvalidArgumentError3(
+    throw new InvalidArgumentError4(
       `Initial task status must be one of: ${STATUS_VALUES3.join(", ")}`
     );
   }
@@ -4180,7 +4440,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 InvalidArgumentError3(
+    throw new InvalidArgumentError4(
       "Invalid --completed-at value; expected ISO-8601 timestamp like 2026-05-10T12:34:56+09:00"
     );
   }
@@ -4189,7 +4449,7 @@ function parseIsoTimestampOption(raw) {
 function parseTaskStatusFilter(raw) {
   const result = TaskStatusSchema.safeParse(raw);
   if (!result.success) {
-    throw new InvalidArgumentError3(
+    throw new InvalidArgumentError4(
       `Invalid task status: ${raw}. Valid values: ${STATUS_VALUES3.join(", ")}`
     );
   }
@@ -4204,14 +4464,14 @@ function parseTaskStatusPositional(raw) {
 }
 function parseDescriptionOption(raw) {
   if (raw.length === 0) {
-    throw new InvalidArgumentError3("Description must not be empty");
+    throw new InvalidArgumentError4("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 InvalidArgumentError3(`Invalid number: ${raw}`);
+    throw new InvalidArgumentError4(`Invalid number: ${raw}`);
   }
   return n;
 }
@@ -4219,10 +4479,10 @@ async function readDescriptionFile(path) {
   try {
     return await readFile3(path, "utf8");
   } catch (error) {
-    if (findErrorCode10(error, "ENOENT")) {
+    if (findErrorCode11(error, "ENOENT")) {
       throw new Error("Description source not found", { cause: error });
     }
-    if (findErrorCode10(error, "EISDIR")) {
+    if (findErrorCode11(error, "EISDIR")) {
       throw new Error("Description source is not a file", { cause: error });
     }
     throw new Error("Failed to read description source", { cause: error });
@@ -4245,7 +4505,7 @@ async function assertWorkspaceInitialized9(basouRoot) {
   try {
     await assertBasouRootSafe12(basouRoot);
   } catch (error) {
-    if (findErrorCode10(error, "ENOENT")) {
+    if (findErrorCode11(error, "ENOENT")) {
       throw new Error("Workspace not initialized. Run 'basou init' first.");
     }
     throw error;
@@ -4333,16 +4593,16 @@ function maxLen3(values, floor) {
 
 // src/commands/view.ts
 import { spawn } from "child_process";
-import { assertBasouRootSafe as assertBasouRootSafe13, basouPaths as basouPaths13, findErrorCode as findErrorCode12, resolveRepositoryRoot as resolveRepositoryRoot14 } from "@basou/core";
-import { InvalidArgumentError as InvalidArgumentError4 } from "commander";
+import { assertBasouRootSafe as assertBasouRootSafe13, basouPaths as basouPaths13, findErrorCode as findErrorCode13, resolveRepositoryRoot as resolveRepositoryRoot14 } from "@basou/core";
+import { InvalidArgumentError as InvalidArgumentError5 } from "commander";
 
 // src/lib/view-server.ts
 import { createServer } from "http";
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 import {
   computeWorkStats as computeWorkStats2,
   enumerateApprovals as enumerateApprovals2,
-  findErrorCode as findErrorCode11,
+  findErrorCode as findErrorCode12,
   isLazyExpired as isLazyExpired2,
   loadApproval as loadApproval2,
   loadSessionEntries as loadSessionEntries3,
@@ -4407,7 +4667,7 @@ var VIEW_HTML = `<!doctype html>
 <body>
 <header>
   <h1>basou view</h1>
-  <input type="text" id="project" placeholder="project path" />
+  <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>
   <button id="btn-import-codex">Import codex</button>
@@ -4561,7 +4821,10 @@ var VIEW_HTML = `<!doctype html>
         detail.appendChild(el('p', { class: 'muted', text: 'Workspace not initialized.' }));
         return;
       }
-      $('project').value = $('project').value || d.repoRoot || '';
+      // Leave the project field empty by default so refresh / import use the
+      // manifest's import.source_roots (then the repo root) -- pre-filling the
+      // repo root here would send it as an explicit --project and silently
+      // override multi-root source roots. The field is an optional override.
       state.repoRoot = d.repoRoot || '';
       detail.appendChild(el('p', {}, [
         el('strong', { text: d.workspace.name }), '  ',
@@ -4812,7 +5075,7 @@ function startViewServer(opts) {
   };
   let boundPort = port;
   const getPort = () => boundPort;
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve3, reject) => {
     const server = createServer((req, res) => {
       handleRequest(req, res, deps, getPort, runExclusive).catch((error) => {
         sendError(res, error instanceof HttpError ? error.status : 500, pathlessMessage(error));
@@ -4823,7 +5086,7 @@ function startViewServer(opts) {
       const address = server.address();
       boundPort = isAddressInfo(address) ? address.port : port;
       server.off("error", reject);
-      resolve({
+      resolve3({
         url: `http://${host}:${boundPort}`,
         port: boundPort,
         close: () => closeServer(server)
@@ -4835,8 +5098,8 @@ function isAddressInfo(value) {
   return value !== null && typeof value === "object";
 }
 function closeServer(server) {
-  return new Promise((resolve) => {
-    server.close(() => resolve());
+  return new Promise((resolve3) => {
+    server.close(() => resolve3());
     server.closeAllConnections();
   });
 }
@@ -4941,7 +5204,7 @@ async function overview(deps) {
   try {
     manifest = await readManifest8(deps.paths);
   } catch (error) {
-    if (findErrorCode11(error, "ENOENT")) {
+    if (findErrorCode12(error, "ENOENT")) {
       return { initialized: false, repoRoot: deps.repoRoot };
     }
     throw error;
@@ -4996,7 +5259,7 @@ async function sessionDetail(deps, sessionId) {
     throw error;
   }
   try {
-    const events = await readAllEvents2(join7(deps.paths.sessions, sessionId));
+    const events = await readAllEvents2(join8(deps.paths.sessions, sessionId));
     return { session, events };
   } catch {
     return { session, events: [], degraded: true };
@@ -5051,11 +5314,16 @@ async function handoffView(deps) {
 }
 function readActionOptions(body) {
   const options = {};
-  if (typeof body.project === "string" && body.project.length > 0) options.project = body.project;
+  const project = normalizeProject(body.project);
+  if (project.length > 0) options.project = project;
   if (body.force === true) options.force = true;
   if (body.dryRun === true) options.dryRun = true;
   return options;
 }
+function normalizeProject(value) {
+  const raw = Array.isArray(value) ? value : [value];
+  return raw.filter((p) => typeof p === "string" && p.length > 0);
+}
 function hostAllowed(req, port) {
   const host = req.headers.host;
   return host === `127.0.0.1:${port}` || host === `localhost:${port}`;
@@ -5131,7 +5399,7 @@ var DEFAULT_PORT = 4319;
 function parsePort(value) {
   const port = Number.parseInt(value, 10);
   if (!Number.isInteger(port) || port < 1 || port > 65535) {
-    throw new InvalidArgumentError4("Port must be an integer between 1 and 65535.");
+    throw new InvalidArgumentError5("Port must be an integer between 1 and 65535.");
   }
   return port;
 }
@@ -5183,7 +5451,7 @@ async function startListening(port, deps) {
   try {
     return await startViewServer({ port, deps });
   } catch (error) {
-    if (findErrorCode12(error, "EADDRINUSE")) {
+    if (findErrorCode13(error, "EADDRINUSE")) {
       throw new Error(`Port ${port} is already in use. Pass --port <n> to choose another.`, {
         cause: error
       });
@@ -5206,7 +5474,7 @@ function openInBrowser(url, override) {
   }
 }
 function waitForShutdown(signal) {
-  return new Promise((resolve) => {
+  return new Promise((resolve3) => {
     const cleanup = () => {
       process.off("SIGINT", onSignal);
       process.off("SIGTERM", onSignal);
@@ -5214,18 +5482,18 @@ function waitForShutdown(signal) {
     };
     const onSignal = () => {
       cleanup();
-      resolve();
+      resolve3();
     };
     const onAbort = () => {
       cleanup();
-      resolve();
+      resolve3();
     };
     process.on("SIGINT", onSignal);
     process.on("SIGTERM", onSignal);
     if (signal !== void 0) {
       if (signal.aborted) {
         cleanup();
-        resolve();
+        resolve3();
         return;
       }
       signal.addEventListener("abort", onAbort);
@@ -5248,7 +5516,7 @@ async function assertWorkspaceInitialized10(basouRoot) {
   try {
     await assertBasouRootSafe13(basouRoot);
   } catch (error) {
-    if (findErrorCode12(error, "ENOENT")) {
+    if (findErrorCode13(error, "ENOENT")) {
       throw new Error("Workspace not initialized. Run 'basou init' first.");
     }
     throw error;