@basou/cli 0.6.0 → 0.8.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,
@@ -1343,16 +1343,22 @@ import {
   importSessionFromJson,
   readManifest as readManifest3,
   readSessionYaml,
+  reimportPreservingId,
   resolveRepositoryRoot as resolveRepositoryRoot6,
   SessionImportPayloadSchema
 } 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 +1367,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,21 +1393,41 @@ 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 {
       externalId,
-      toPayload: async () => claudeTranscriptToImportPayload(await readJsonlRecords(file), {
-        workspaceId: manifest.workspace.id,
-        externalId
-      })
+      sourcePath: file,
+      toPayload: async () => {
+        const { records, sizeBytes } = await readJsonlRecords(file);
+        return claudeTranscriptToImportPayload(records, {
+          workspaceId: manifest.workspace.id,
+          externalId,
+          sourceSizeBytes: sizeBytes
+        });
+      }
     };
   });
   await importDerivedSessions(paths, manifest, options, CLAUDE_IMPORT_SOURCE, candidates);
@@ -1407,19 +1435,32 @@ 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), {
-      workspaceId: manifest.workspace.id,
-      externalId
-    })
+    sourcePath: file,
+    toPayload: async () => {
+      const { records, sizeBytes } = await readJsonlRecords(file);
+      return codexRolloutToImportPayload(records, {
+        workspaceId: manifest.workspace.id,
+        externalId,
+        sourceSizeBytes: sizeBytes
+      });
+    }
   }));
   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");
   }
@@ -1436,41 +1477,76 @@ async function importDerivedSessions(paths, manifest, options, sourceKind, candi
   const existingByExternalId = await loadExistingByExternalId(paths, sourceKind);
   const seenThisRun = /* @__PURE__ */ new Set();
   const results = [];
-  let skippedNoAction = 0;
-  let skippedExisting = 0;
-  let replaced = 0;
+  const counts = {
+    skippedNoAction: 0,
+    skippedExisting: 0,
+    replaced: 0,
+    reimported: 0,
+    skippedLegacy: 0,
+    skippedDecreased: 0,
+    skippedDuplicate: 0
+  };
   let sanitizedPaths = 0;
-  for (const { externalId, toPayload } of candidates) {
+  const validate = (payload) => {
+    if (payload === null) return null;
+    const parsed = SessionImportPayloadSchema.safeParse(payload);
+    if (!parsed.success) {
+      throw new Error("Invalid import payload", { cause: parsed.error });
+    }
+    if (parsed.data.schema_version !== "0.1.0") {
+      throw new Error(`Unsupported import schema_version: ${parsed.data.schema_version}`);
+    }
+    return parsed.data;
+  };
+  for (const { externalId, sourcePath, toPayload } of candidates) {
     if (seenThisRun.has(externalId)) {
-      skippedExisting++;
+      counts.skippedExisting++;
       continue;
     }
-    const priorSessionIds = existingByExternalId.get(externalId) ?? [];
-    if (priorSessionIds.length > 0 && options.force !== true) {
-      skippedExisting++;
+    const priors = existingByExternalId.get(externalId) ?? [];
+    if (priors.length > 0 && options.force !== true) {
+      const prior = await classifyReimport(priors, sourcePath, externalId, counts);
+      if (prior === null) continue;
+      const payload2 = validate(await toPayload());
+      if (payload2 === null) {
+        counts.skippedNoAction++;
+        continue;
+      }
+      const readSize = payload2.session.source.source_size_bytes;
+      if (prior.sourceSizeBytes !== void 0 && readSize !== void 0 && readSize <= prior.sourceSizeBytes) {
+        console.error(
+          `Import: ${externalId} source changed during read (now ${readSize} <= ${prior.sourceSizeBytes} bytes); re-import skipped`
+        );
+        counts.skippedDecreased++;
+        continue;
+      }
+      const outcome = await reimportPreservingId(paths, manifest, prior.sessionId, payload2, {
+        dryRun: options.dryRun === true
+      });
+      if (outcome.status === "skipped") {
+        const detail = outcome.reason === "prior_events_unreadable" ? "prior events.jsonl has unreadable lines" : "source changed in a non-append way (derived events would be dropped)";
+        console.error(`Import: ${externalId} ${detail}; re-import skipped`);
+        counts.skippedNoAction++;
+        continue;
+      }
+      counts.reimported++;
+      seenThisRun.add(externalId);
       continue;
     }
-    const payload = await toPayload();
+    const payload = validate(await toPayload());
     if (payload === null) {
-      skippedNoAction++;
+      counts.skippedNoAction++;
       continue;
     }
-    const parsed = SessionImportPayloadSchema.safeParse(payload);
-    if (!parsed.success) {
-      throw new Error("Invalid import payload", { cause: parsed.error });
-    }
-    if (parsed.data.schema_version !== "0.1.0") {
-      throw new Error(`Unsupported import schema_version: ${parsed.data.schema_version}`);
-    }
-    if (priorSessionIds.length > 0 && options.force === true) {
+    if (priors.length > 0 && options.force === true) {
       if (options.dryRun !== true) {
-        for (const sid of priorSessionIds) {
-          await rm(join3(paths.sessions, sid), { recursive: true, force: true });
+        for (const { sessionId } of priors) {
+          await rm(join3(paths.sessions, sessionId), { recursive: true, force: true });
         }
       }
-      replaced++;
+      counts.replaced++;
     }
-    const result = await importSessionFromJson(paths, manifest, parsed.data, {
+    const result = await importSessionFromJson(paths, manifest, payload, {
       dryRun: options.dryRun === true
     });
     results.push(result);
@@ -1480,17 +1556,52 @@ async function importDerivedSessions(paths, manifest, options, sourceKind, candi
   if (sanitizedPaths > 0) {
     console.error(`Imported sessions: ${sanitizedPaths} path(s) sanitized`);
   }
-  printImportResult(options, results, { skippedNoAction, skippedExisting, replaced });
+  printImportResult(options, results, counts);
+}
+async function classifyReimport(priors, sourcePath, externalId, counts) {
+  if (priors.length > 1) {
+    console.error(
+      `Import: ${externalId} has ${priors.length} prior sessions; re-import skipped (use --force)`
+    );
+    counts.skippedDuplicate++;
+    return null;
+  }
+  const prior = priors[0];
+  if (prior === void 0) {
+    counts.skippedExisting++;
+    return null;
+  }
+  const currentSize = await statSize(sourcePath);
+  if (currentSize === void 0) {
+    counts.skippedExisting++;
+    return null;
+  }
+  if (prior.sourceSizeBytes === void 0) {
+    counts.skippedLegacy++;
+    return null;
+  }
+  if (currentSize === prior.sourceSizeBytes) {
+    counts.skippedExisting++;
+    return null;
+  }
+  if (currentSize < prior.sourceSizeBytes) {
+    console.error(
+      `Import: ${externalId} source shrank (${currentSize} < ${prior.sourceSizeBytes} bytes); re-import skipped (use --force to replace)`
+    );
+    counts.skippedDecreased++;
+    return null;
+  }
+  return prior;
 }
 function encodeProjectDir(projectPath) {
   return projectPath.replaceAll("/", "-");
 }
 async function loadExistingByExternalId(paths, sourceKind) {
   const byExternalId = /* @__PURE__ */ new Map();
-  const add = (externalId, sessionId) => {
+  const add = (externalId, prior) => {
     const list = byExternalId.get(externalId);
-    if (list === void 0) byExternalId.set(externalId, [sessionId]);
-    else list.push(sessionId);
+    if (list === void 0) byExternalId.set(externalId, [prior]);
+    else list.push(prior);
   };
   let sessionIds;
   try {
@@ -1506,39 +1617,77 @@ async function loadExistingByExternalId(paths, sourceKind) {
       continue;
     }
     if (session.session.source.kind !== sourceKind) continue;
+    const sourceSizeBytes = session.session.source.source_size_bytes;
+    const prior = sourceSizeBytes !== void 0 ? { sessionId, sourceSizeBytes } : { sessionId };
     const ext = session.session.source.external_id;
     if (typeof ext === "string" && ext.length > 0) {
-      add(ext, sessionId);
+      add(ext, prior);
       continue;
     }
     const label = session.session.label;
     const match = typeof label === "string" ? label.match(/^claude-code import (\S+)$/) : null;
-    if (match?.[1] !== void 0) add(match[1], sessionId);
+    if (match?.[1] !== void 0) add(match[1], prior);
   }
   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;
+  }
+}
+async function statSize(file) {
+  try {
+    return (await stat(file)).size;
+  } catch (error) {
+    if (findErrorCode5(error, "ENOENT")) return void 0;
+    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 });
   }
@@ -1609,9 +1758,9 @@ async function readFirstLine(file) {
   }
 }
 async function readJsonlRecords(file) {
-  let body;
+  let buffer;
   try {
-    body = await readFile(file, "utf8");
+    buffer = await readFile(file);
   } catch (error) {
     if (findErrorCode5(error, "ENOENT")) {
       throw new Error("Source log not found", { cause: error });
@@ -1622,7 +1771,7 @@ async function readJsonlRecords(file) {
     throw new Error("Failed to read source log", { cause: error });
   }
   const records = [];
-  for (const line of body.split("\n")) {
+  for (const line of buffer.toString("utf8").split("\n")) {
     const trimmed = line.trim();
     if (trimmed.length === 0) continue;
     try {
@@ -1633,7 +1782,7 @@ async function readJsonlRecords(file) {
     } catch {
     }
   }
-  return records;
+  return { records, sizeBytes: buffer.length };
 }
 function isObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -1641,7 +1790,15 @@ function isObject(value) {
 function printImportResult(options, results, counts) {
   const isDry = options.dryRun === true;
   const eventTotal = results.reduce((sum, r) => sum + r.eventCount, 0);
-  const { skippedNoAction, skippedExisting, replaced } = counts;
+  const {
+    skippedNoAction,
+    skippedExisting,
+    replaced,
+    reimported,
+    skippedLegacy,
+    skippedDecreased,
+    skippedDuplicate
+  } = counts;
   if (options.json === true) {
     console.log(
       JSON.stringify({
@@ -1653,8 +1810,12 @@ function printImportResult(options, results, counts) {
         })),
         imported_count: results.length,
         replaced_count: replaced,
+        reimported_count: reimported,
         skipped_no_action: skippedNoAction,
         skipped_already_imported: skippedExisting,
+        skipped_legacy_untracked: skippedLegacy,
+        skipped_decreased: skippedDecreased,
+        skipped_duplicate: skippedDuplicate,
         event_total: eventTotal,
         dry_run: isDry
       })
@@ -1664,20 +1825,36 @@ function printImportResult(options, results, counts) {
   const skipParts = [];
   if (skippedNoAction > 0) skipParts.push(`${skippedNoAction} with no actions`);
   if (skippedExisting > 0) skipParts.push(`${skippedExisting} already imported`);
+  if (skippedLegacy > 0) skipParts.push(`${skippedLegacy} legacy (untracked size)`);
+  if (skippedDecreased > 0) skipParts.push(`${skippedDecreased} shrank`);
+  if (skippedDuplicate > 0) skipParts.push(`${skippedDuplicate} duplicated`);
   const skipSuffix = skipParts.length > 0 ? `; skipped ${skipParts.join(", ")}` : "";
   const eventsPart = replaced > 0 ? `${eventTotal} events, ${replaced} replaced` : `${eventTotal} events`;
-  if (results.length === 0) {
+  if (isDry) {
+    const parts = [];
+    if (results.length > 0) parts.push(`import ${results.length} session(s) (${eventsPart})`);
+    if (reimported > 0) parts.push(`re-import ${reimported} changed session(s)`);
+    const head = parts.length > 0 ? `Dry run: would ${parts.join(", ")}` : "Dry run: no changes";
+    console.log(`${head}${skipSuffix}`);
+    return;
+  }
+  if (results.length === 0 && reimported === 0) {
     console.log(
       skipParts.length > 0 ? `No new sessions imported (skipped ${skipParts.join(", ")})` : "No transcripts found to import"
     );
     return;
   }
-  if (isDry) {
-    console.log(`Dry run: would import ${results.length} session(s) (${eventsPart})${skipSuffix}`);
-    return;
+  const segments = [];
+  if (results.length > 0) {
+    const single = results.length === 1 && results[0] !== void 0 ? ` (${shortId2(results[0].sessionId)})` : "";
+    segments.push(`Imported ${results.length} session(s)${single} (${eventsPart})`);
+  }
+  if (reimported > 0) {
+    segments.push(
+      `${results.length > 0 ? "re-imported" : "Re-imported"} ${reimported} changed session(s)`
+    );
   }
-  const single = results.length === 1 && results[0] !== void 0 ? ` (${shortId2(results[0].sessionId)})` : "";
-  console.log(`Imported ${results.length} session(s)${single} (${eventsPart})${skipSuffix}`);
+  console.log(`${segments.join(", ")}${skipSuffix}`);
 }
 function shortId2(id) {
   if (id.startsWith(SES_PREFIX2)) {
@@ -1709,7 +1886,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 +1895,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 +1929,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 +1973,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 {
@@ -1836,8 +2027,10 @@ async function runImport(adapter, fn) {
       status: "ran",
       importedCount: readCount(json.imported_count),
       replacedCount: readCount(json.replaced_count),
+      reimportedCount: readCount(json.reimported_count),
       skippedNoAction: readCount(json.skipped_no_action),
       skippedAlreadyImported: readCount(json.skipped_already_imported),
+      skippedLegacyUntracked: readCount(json.skipped_legacy_untracked),
       eventTotal: readCount(json.event_total),
       dryRun: json.dry_run === true
     };
@@ -1906,25 +2099,215 @@ 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 changedCount(outcome) {
+  return outcome.status === "ran" ? outcome.importedCount + outcome.reimportedCount + outcome.replacedCount : 0;
+}
+function describeOutcome(outcome) {
+  if (outcome.status !== "ran") return `${outcome.adapter} skipped`;
+  const reimported = outcome.reimportedCount > 0 ? ` ~${outcome.reimportedCount}` : "";
+  return `${outcome.adapter} +${outcome.importedCount}${reimported}`;
+}
+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, changed: changedCount(claude) + changedCount(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, changed } = await runImports(deps);
+        if (changed > 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 +2316,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 } : {}
     },
@@ -1954,9 +2337,11 @@ function describeImport(outcome) {
   }
   const verb = outcome.dryRun ? "would import" : "imported";
   const parts = [`${outcome.importedCount} session(s)`, `${outcome.eventTotal} events`];
+  if (outcome.reimportedCount > 0) parts.push(`${outcome.reimportedCount} re-imported`);
   if (outcome.replacedCount > 0) parts.push(`${outcome.replacedCount} replaced`);
   if (outcome.skippedAlreadyImported > 0)
     parts.push(`${outcome.skippedAlreadyImported} already imported`);
+  if (outcome.skippedLegacyUntracked > 0) parts.push(`${outcome.skippedLegacyUntracked} legacy`);
   return `${outcome.adapter}: ${verb} ${parts.join(", ")}`;
 }
 function printRefreshSummary(result) {
@@ -1991,7 +2376,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 +2385,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 +2438,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 +2562,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 +2706,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 +2779,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 +2799,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 +2906,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 +3033,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 +3163,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 +3232,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 +3250,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 +3349,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 +3360,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 +3386,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 +3504,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 +3516,7 @@ import {
   assertBasouRootSafe as assertBasouRootSafe11,
   basouPaths as basouPaths11,
   buildStatusSnapshot,
-  findErrorCode as findErrorCode9,
+  findErrorCode as findErrorCode10,
   readManifest as readManifest6,
   resolveRepositoryRoot as resolveRepositoryRoot12,
   writeStatus
@@ -3156,7 +3541,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 +3550,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 +3587,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 +3596,7 @@ import {
   deleteTask,
   editTask,
   enumerateArchivedTaskIds,
-  findErrorCode as findErrorCode10,
+  findErrorCode as findErrorCode11,
   loadSessionEntries as loadSessionEntries2,
   loadTaskEntries,
   prefixedUlid as prefixedUlid5,
@@ -3229,7 +3614,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 +3914,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 +4543,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 +4565,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 +4574,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 +4589,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 +4604,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 +4630,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 +4718,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 +4792,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 +4946,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 +5200,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 +5211,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 +5223,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 +5329,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 +5384,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 +5439,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 +5524,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 +5576,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 +5599,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 +5607,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 +5641,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;