@basou/cli 0.3.1 → 0.5.0

package/dist/index.js

@@ -1,29 +1,5 @@
 #!/usr/bin/env node
 
-// src/index.ts
-import { createRequire } from "module";
-import { Command } from "commander";
-
-// src/commands/approval.ts
-import { unlink } from "fs/promises";
-import { join } from "path";
-import {
-  ApprovalSchema,
-  ApprovalStatusSchema,
-  appendEvent,
-  assertBasouRootSafe,
-  basouPaths,
-  enumerateApprovals,
-  findErrorCode,
-  isLazyExpired,
-  linkYamlFile,
-  loadApproval,
-  prefixedUlid,
-  readYamlFile,
-  replayEvents,
-  resolveRepositoryRoot
-} from "@basou/core";
-
 // src/lib/error-render.ts
 import {
   FailedToFinalizeError
@@ -129,7 +105,29 @@ function printTaskSkip(taskId, reason) {
   console.error(`Skipped ${shortTaskId(taskId)}: ${reason}`);
 }
 
+// src/program.ts
+import { createRequire } from "module";
+import { Command } from "commander";
+
 // src/commands/approval.ts
+import { unlink } from "fs/promises";
+import { join } from "path";
+import {
+  ApprovalSchema,
+  ApprovalStatusSchema,
+  appendEvent,
+  assertBasouRootSafe,
+  basouPaths,
+  enumerateApprovals,
+  findErrorCode,
+  isLazyExpired,
+  linkYamlFile,
+  loadApproval,
+  prefixedUlid,
+  readYamlFile,
+  replayEvents,
+  resolveRepositoryRoot
+} from "@basou/core";
 var APPR_PREFIX = "appr_";
 var SHORT_ID_BASE_LEN = 6;
 var SHORT_ID_MAX_LEN = 26;
@@ -946,10 +944,9 @@ import { mkdir } from "fs/promises";
 import { homedir } from "os";
 import { join as join2 } from "path";
 import {
-  ChildProcessRunner,
-  SessionSchema,
   assertBasouRootSafe as assertBasouRootSafe4,
   basouPaths as basouPaths4,
+  ChildProcessRunner,
   appendEvent as coreAppendEvent,
   getSnapshot,
   overwriteYamlFile,
@@ -958,6 +955,7 @@ import {
   readManifest as readManifest2,
   readYamlFile as readYamlFile2,
   resolveRepositoryRoot as resolveRepositoryRoot4,
+  SessionSchema,
   sanitizeWorkingDirectory,
   writeYamlFile
 } from "@basou/core";
@@ -1327,13 +1325,396 @@ async function assertWorkspaceInitialized4(basouRoot) {
   }
 }
 
+// src/commands/import.ts
+import { createReadStream } from "fs";
+import { readdir, readFile, rm } from "fs/promises";
+import { homedir as homedir2 } from "os";
+import { basename, join as join3 } from "path";
+import { createInterface } from "readline";
+import {
+  assertBasouRootSafe as assertBasouRootSafe6,
+  basouPaths as basouPaths6,
+  CLAUDE_IMPORT_SOURCE,
+  CODEX_IMPORT_SOURCE,
+  claudeTranscriptToImportPayload,
+  codexRolloutToImportPayload,
+  enumerateSessionDirs,
+  findErrorCode as findErrorCode5,
+  importSessionFromJson,
+  readManifest as readManifest3,
+  readSessionYaml,
+  resolveRepositoryRoot as resolveRepositoryRoot6,
+  SessionImportPayloadSchema
+} from "@basou/core";
+var SES_PREFIX2 = "ses_";
+var SHORT_ID_LEN2 = 6;
+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)"
+  ).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"
+  ).option("--dry-run", "Validate and preview only; do not write to disk").option("--json", "Output the result as JSON").option("-v, --verbose", "Show error causes").action(async (options) => {
+    await runImportClaudeCode(options);
+  });
+  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)"
+  ).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"
+  ).option("--dry-run", "Validate and preview only; do not write to disk").option("--json", "Output the result as JSON").option("-v, --verbose", "Show error causes").action(async (options) => {
+    await runImportCodex(options);
+  });
+}
+async function runImportClaudeCode(options, ctx = {}) {
+  try {
+    await doRunImportClaudeCode(options, ctx);
+  } catch (error) {
+    renderCliError(error, { verbose: isVerbose(options) });
+    process.exitCode = 1;
+  }
+}
+async function runImportCodex(options, ctx = {}) {
+  try {
+    await doRunImportCodex(options, ctx);
+  } catch (error) {
+    renderCliError(error, { verbose: isVerbose(options) });
+    process.exitCode = 1;
+  }
+}
+async function doRunImportClaudeCode(options, ctx) {
+  assertSelector(options);
+  const { repositoryRoot, paths, manifest } = await resolveImportTarget(ctx);
+  const projectPath = options.project ?? repositoryRoot;
+  const projectsRoot = ctx.claudeProjectsDir ?? join3(homedir2(), ".claude", "projects");
+  const transcriptDir = join3(projectsRoot, encodeProjectDir(projectPath));
+  const files = await selectTranscriptFiles(transcriptDir, options);
+  const candidates = files.map((file) => {
+    const externalId = basename(file, ".jsonl");
+    return {
+      externalId,
+      toPayload: async () => claudeTranscriptToImportPayload(await readJsonlRecords(file), {
+        workspaceId: manifest.workspace.id,
+        externalId
+      })
+    };
+  });
+  await importDerivedSessions(paths, manifest, options, CLAUDE_IMPORT_SOURCE, candidates);
+}
+async function doRunImportCodex(options, ctx) {
+  assertSelector(options);
+  const { repositoryRoot, paths, manifest } = await resolveImportTarget(ctx);
+  const projectPath = options.project ?? repositoryRoot;
+  const sessionsRoot = ctx.codexSessionsDir ?? join3(homedir2(), ".codex", "sessions");
+  const rollouts = await discoverCodexRollouts(sessionsRoot, projectPath, options);
+  const candidates = rollouts.map(({ file, externalId }) => ({
+    externalId,
+    toPayload: async () => codexRolloutToImportPayload(await readJsonlRecords(file), {
+      workspaceId: manifest.workspace.id,
+      externalId
+    })
+  }));
+  await importDerivedSessions(paths, manifest, options, CODEX_IMPORT_SOURCE, candidates);
+}
+function assertSelector(options) {
+  if (options.session === void 0 && options.all !== true) {
+    throw new Error("Specify --session <id> or --all");
+  }
+}
+async function resolveImportTarget(ctx) {
+  const cwd = ctx.cwd ?? process.cwd();
+  const repositoryRoot = await resolveRepositoryRootForImport(cwd);
+  const paths = basouPaths6(repositoryRoot);
+  await assertWorkspaceInitialized5(paths.root);
+  const manifest = await readManifest3(paths);
+  return { repositoryRoot, paths, manifest };
+}
+async function importDerivedSessions(paths, manifest, options, sourceKind, candidates) {
+  const existingByExternalId = await loadExistingByExternalId(paths, sourceKind);
+  const seenThisRun = /* @__PURE__ */ new Set();
+  const results = [];
+  let skippedNoAction = 0;
+  let skippedExisting = 0;
+  let replaced = 0;
+  let sanitizedPaths = 0;
+  for (const { externalId, toPayload } of candidates) {
+    if (seenThisRun.has(externalId)) {
+      skippedExisting++;
+      continue;
+    }
+    const priorSessionIds = existingByExternalId.get(externalId) ?? [];
+    if (priorSessionIds.length > 0 && options.force !== true) {
+      skippedExisting++;
+      continue;
+    }
+    const payload = await toPayload();
+    if (payload === null) {
+      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 (options.dryRun !== true) {
+        for (const sid of priorSessionIds) {
+          await rm(join3(paths.sessions, sid), { recursive: true, force: true });
+        }
+      }
+      replaced++;
+    }
+    const result = await importSessionFromJson(paths, manifest, parsed.data, {
+      dryRun: options.dryRun === true
+    });
+    results.push(result);
+    seenThisRun.add(externalId);
+    sanitizedPaths += result.pathSanitizeReport.relatedFiles + (result.pathSanitizeReport.workingDirectoryRewritten ? 1 : 0);
+  }
+  if (sanitizedPaths > 0) {
+    console.error(`Imported sessions: ${sanitizedPaths} path(s) sanitized`);
+  }
+  printImportResult(options, results, { skippedNoAction, skippedExisting, replaced });
+}
+function encodeProjectDir(projectPath) {
+  return projectPath.replaceAll("/", "-");
+}
+async function loadExistingByExternalId(paths, sourceKind) {
+  const byExternalId = /* @__PURE__ */ new Map();
+  const add = (externalId, sessionId) => {
+    const list = byExternalId.get(externalId);
+    if (list === void 0) byExternalId.set(externalId, [sessionId]);
+    else list.push(sessionId);
+  };
+  let sessionIds;
+  try {
+    sessionIds = await enumerateSessionDirs(paths);
+  } catch {
+    return byExternalId;
+  }
+  for (const sessionId of sessionIds) {
+    let session;
+    try {
+      session = await readSessionYaml(paths, sessionId);
+    } catch {
+      continue;
+    }
+    if (session.session.source.kind !== sourceKind) continue;
+    const ext = session.session.source.external_id;
+    if (typeof ext === "string" && ext.length > 0) {
+      add(ext, sessionId);
+      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);
+  }
+  return byExternalId;
+}
+async function selectTranscriptFiles(transcriptDir, options) {
+  if (options.session !== void 0) {
+    return [join3(transcriptDir, `${options.session}.jsonl`)];
+  }
+  let entries;
+  try {
+    entries = await readdir(transcriptDir);
+  } 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 });
+  }
+  return entries.filter((name) => name.endsWith(".jsonl")).sort().map((name) => join3(transcriptDir, name));
+}
+async function discoverCodexRollouts(sessionsRoot, projectPath, options) {
+  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 (options.session !== void 0 && meta.id !== options.session) continue;
+    matched.push({ file, externalId: meta.id });
+  }
+  if (options.session !== void 0 && matched.length === 0) {
+    throw new Error("Codex rollout not found for session id in project");
+  }
+  return matched;
+}
+async function findRolloutFiles(sessionsRoot) {
+  const found = [];
+  const walk = async (dir, isRoot) => {
+    let entries;
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch (error) {
+      if (findErrorCode5(error, "ENOENT")) {
+        if (isRoot) {
+          throw new Error("Codex sessions directory not found", { cause: error });
+        }
+        return;
+      }
+      throw new Error("Failed to read Codex sessions directory", { cause: error });
+    }
+    for (const entry of entries) {
+      const full = join3(dir, entry.name);
+      if (entry.isDirectory()) {
+        await walk(full, false);
+      } else if (entry.isFile() && entry.name.startsWith("rollout-") && entry.name.endsWith(".jsonl")) {
+        found.push(full);
+      }
+    }
+  };
+  await walk(sessionsRoot, true);
+  return found.sort();
+}
+async function readRolloutMeta(file) {
+  const firstLine = await readFirstLine(file);
+  if (firstLine === void 0) return void 0;
+  let parsed;
+  try {
+    parsed = JSON.parse(firstLine);
+  } catch {
+    return void 0;
+  }
+  if (!isObject(parsed) || parsed.type !== "session_meta") return void 0;
+  const payload = isObject(parsed.payload) ? parsed.payload : void 0;
+  if (payload === void 0) return void 0;
+  const id = payload.id;
+  const cwd = payload.cwd;
+  if (typeof id !== "string" || id.length === 0) return void 0;
+  if (typeof cwd !== "string" || cwd.length === 0) return void 0;
+  return { id, cwd };
+}
+async function readFirstLine(file) {
+  const stream = createReadStream(file, { encoding: "utf8" });
+  const rl = createInterface({ input: stream, crlfDelay: Number.POSITIVE_INFINITY });
+  try {
+    for await (const line of rl) {
+      const trimmed = line.trim();
+      if (trimmed.length > 0) return trimmed;
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  } finally {
+    rl.close();
+    stream.destroy();
+  }
+}
+async function readJsonlRecords(file) {
+  let body;
+  try {
+    body = await readFile(file, "utf8");
+  } catch (error) {
+    if (findErrorCode5(error, "ENOENT")) {
+      throw new Error("Source log not found", { cause: error });
+    }
+    if (findErrorCode5(error, "EISDIR")) {
+      throw new Error("Source log path is not a file", { cause: error });
+    }
+    throw new Error("Failed to read source log", { cause: error });
+  }
+  const records = [];
+  for (const line of body.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed.length === 0) continue;
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (isObject(parsed)) {
+        records.push(parsed);
+      }
+    } catch {
+    }
+  }
+  return records;
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(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;
+  if (options.json === true) {
+    console.log(
+      JSON.stringify({
+        imported: results.map((r) => ({
+          session_id: r.sessionId,
+          event_count: r.eventCount,
+          status: r.finalStatus,
+          source: { kind: r.finalSourceKind, version: "0.1.0" }
+        })),
+        imported_count: results.length,
+        replaced_count: replaced,
+        skipped_no_action: skippedNoAction,
+        skipped_already_imported: skippedExisting,
+        event_total: eventTotal,
+        dry_run: isDry
+      })
+    );
+    return;
+  }
+  const skipParts = [];
+  if (skippedNoAction > 0) skipParts.push(`${skippedNoAction} with no actions`);
+  if (skippedExisting > 0) skipParts.push(`${skippedExisting} already imported`);
+  const skipSuffix = skipParts.length > 0 ? `; skipped ${skipParts.join(", ")}` : "";
+  const eventsPart = replaced > 0 ? `${eventTotal} events, ${replaced} replaced` : `${eventTotal} events`;
+  if (results.length === 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 single = results.length === 1 && results[0] !== void 0 ? ` (${shortId2(results[0].sessionId)})` : "";
+  console.log(`Imported ${results.length} session(s)${single} (${eventsPart})${skipSuffix}`);
+}
+function shortId2(id) {
+  if (id.startsWith(SES_PREFIX2)) {
+    return id.slice(SES_PREFIX2.length, SES_PREFIX2.length + SHORT_ID_LEN2);
+  }
+  return id.slice(0, SHORT_ID_LEN2);
+}
+async function resolveRepositoryRootForImport(cwd) {
+  try {
+    return await resolveRepositoryRoot6(cwd);
+  } catch (error) {
+    if (error instanceof Error && error.message === "Not a git repository") {
+      throw new Error("Not a git repository. Run 'git init' first, then re-run 'basou import'.", {
+        cause: error
+      });
+    }
+    throw error;
+  }
+}
+async function assertWorkspaceInitialized5(basouRoot) {
+  try {
+    await assertBasouRootSafe6(basouRoot);
+  } catch (error) {
+    if (findErrorCode5(error, "ENOENT")) {
+      throw new Error("Workspace not initialized. Run 'basou init' first.");
+    }
+    throw error;
+  }
+}
+
 // src/commands/init.ts
-import { basename } from "path";
+import { basename as basename2 } from "path";
 import {
   appendBasouGitignore,
   createManifest,
   ensureBasouDirectory,
-  resolveRepositoryRoot as resolveRepositoryRoot6,
+  resolveRepositoryRoot as resolveRepositoryRoot7,
   tryRemoteUrl,
   writeManifest
 } from "@basou/core";
@@ -1356,7 +1737,7 @@ async function runInit(options, ctx = {}) {
 async function doRunInit(options, ctx) {
   const cwd = ctx.cwd ?? process.cwd();
   const repositoryRoot = await resolveRepositoryRootForInit(cwd);
-  const workspaceName = options.name ?? basename(repositoryRoot);
+  const workspaceName = options.name ?? basename2(repositoryRoot);
   let repositoryUrl;
   if (options.repoUrl !== void 0) {
     repositoryUrl = options.repoUrl === "" ? null : options.repoUrl;
@@ -1390,7 +1771,7 @@ function renderGitignoreWarning(error, verbose) {
 }
 async function resolveRepositoryRootForInit(cwd) {
   try {
-    return await resolveRepositoryRoot6(cwd);
+    return await resolveRepositoryRoot7(cwd);
   } catch (error) {
     if (error instanceof Error && error.message === "Not a git repository") {
       throw new Error("Not a git repository. Run 'git init' first, then re-run 'basou init'.", {
@@ -1401,65 +1782,281 @@ async function resolveRepositoryRootForInit(cwd) {
   }
 }
 
-// src/commands/run.ts
-import { mkdir as mkdir2 } from "fs/promises";
-import { homedir as homedir2 } from "os";
-import { join as join3 } from "path";
+// src/commands/refresh.ts
+import { assertBasouRootSafe as assertBasouRootSafe7, basouPaths as basouPaths7, findErrorCode as findErrorCode6, resolveRepositoryRoot as resolveRepositoryRoot8 } from "@basou/core";
+
+// src/lib/provenance-actions.ts
 import {
-  ChildProcessRunner as ChildProcessRunner2,
-  SessionSchema as SessionSchema2,
-  assertBasouRootSafe as assertBasouRootSafe6,
-  basouPaths as basouPaths6,
-  claudeCodeAdapterMetadata,
-  appendEvent as coreAppendEvent2,
-  getDiff,
-  getSnapshot as getSnapshot2,
-  overwriteYamlFile as overwriteYamlFile2,
-  prefixedUlid as prefixedUlid4,
-  readManifest as readManifest3,
-  readYamlFile as readYamlFile3,
-  resolveClaudeCodeCommand,
-  resolveRepositoryRoot as resolveRepositoryRoot7,
-  sanitizeRelatedFiles,
-  sanitizeWorkingDirectory as sanitizeWorkingDirectory2,
-  writeYamlFile as writeYamlFile2
+  readMarkdownFile as readMarkdownFile3,
+  renderDecisions as renderDecisions2,
+  renderHandoff as renderHandoff2,
+  renderWithMarkers as renderWithMarkers3,
+  writeMarkdownFile as writeMarkdownFile3
 } from "@basou/core";
-function registerRunCommand(program2, ctx = {}) {
-  const runCommand = program2.command("run").description("Run an AI coding tool through Basou as a tracked session").enablePositionalOptions().option("--no-snapshot", "Skip git_snapshot before/after the session").option("--cwd <path>", "Run from a Basou root other than process.cwd()").option("-v, --verbose", "Show error causes");
-  runCommand.command("claude-code [args...]").description("Run Claude Code CLI as a Basou-tracked session").option("--no-snapshot", "Skip git_snapshot before/after the session").option("--cwd <path>", "Run from a Basou root other than process.cwd()").option("-v, --verbose", "Show error causes").passThroughOptions().action(async (args, options, command) => {
-    const parentOptions = command.parent?.opts() ?? {};
-    const snapshotOn = parentOptions.snapshot !== false && options.snapshot !== false;
-    const merged = {
-      ...parentOptions,
-      ...options,
-      snapshot: snapshotOn
-    };
+async function captureImportJson(fn) {
+  const stdout = [];
+  const originalLog = console.log;
+  const originalError = console.error;
+  console.log = ((...args) => {
+    stdout.push(args.map((a) => String(a)).join(" "));
+  });
+  console.error = (() => {
+  });
+  try {
+    await fn();
+  } finally {
+    console.log = originalLog;
+    console.error = originalError;
+  }
+  for (let i = stdout.length - 1; i >= 0; i--) {
+    const line = stdout[i];
+    if (line === void 0) continue;
     try {
-      const exitCode = await runClaudeCode(args, merged, ctx);
-      process.exit(exitCode);
-    } catch (error) {
-      renderCliError(error, { verbose: isVerbose(merged) });
-      process.exit(1);
+      const parsed = JSON.parse(line);
+      if (parsed !== null && typeof parsed === "object" && "imported_count" in parsed) {
+        return parsed;
+      }
+    } catch {
     }
-  });
+  }
+  throw new Error("Import produced no parseable result");
 }
-async function runClaudeCode(args, options, ctx = {}) {
-  const runner = ctx.runner ?? new ChildProcessRunner2();
-  const now = ctx.now ?? (() => /* @__PURE__ */ new Date());
-  const appendEvent2 = ctx.appendEvent ?? coreAppendEvent2;
-  const resolveCommand = ctx.resolveCommand ?? resolveClaudeCodeCommand;
-  const getDiffFn = ctx.getDiff ?? getDiff;
-  const { command } = await resolveCommand();
-  const cwd = options.cwd ?? process.cwd();
-  const repoRoot = await resolveRepositoryRootForRun(cwd);
-  const paths = basouPaths6(repoRoot);
-  await assertBasouRootSafe6(paths.root);
-  const manifest = await readManifest3(paths);
+function readCount(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function isMissingSourceDir(error) {
+  if (!(error instanceof Error)) return false;
+  return error.message === "Claude transcript directory not found for project" || error.message === "Codex sessions directory not found";
+}
+async function runImport(adapter, fn) {
+  try {
+    const json = await captureImportJson(fn);
+    return {
+      adapter,
+      status: "ran",
+      importedCount: readCount(json.imported_count),
+      replacedCount: readCount(json.replaced_count),
+      skippedNoAction: readCount(json.skipped_no_action),
+      skippedAlreadyImported: readCount(json.skipped_already_imported),
+      eventTotal: readCount(json.event_total),
+      dryRun: json.dry_run === true
+    };
+  } catch (error) {
+    if (isMissingSourceDir(error)) {
+      return { adapter, status: "skipped", reason: "no source logs for this project" };
+    }
+    throw error;
+  }
+}
+function importOptions(options) {
+  return {
+    all: true,
+    json: true,
+    ...options.project !== void 0 ? { project: options.project } : {},
+    ...options.force === true ? { force: true } : {},
+    ...options.dryRun === true ? { dryRun: true } : {}
+  };
+}
+function importClaudeCode(options, ctx) {
+  return runImport("claude-code", () => doRunImportClaudeCode(importOptions(options), ctx));
+}
+function importCodex(options, ctx) {
+  return runImport("codex", () => doRunImportCodex(importOptions(options), ctx));
+}
+async function regenerateHandoff(paths, nowIso, callbacks) {
+  const result = await renderHandoff2({ paths, nowIso, ...callbacks });
+  const existing = await readMarkdownFile3(paths.files.handoff);
+  await writeMarkdownFile3(
+    paths.files.handoff,
+    renderWithMarkers3(existing, result.body, "handoff.md")
+  );
+  return {
+    sessionCount: result.sessionCount,
+    taskCount: result.taskCount,
+    decisionCount: result.decisionCount,
+    pendingApprovalsCount: result.pendingApprovalsCount
+  };
+}
+async function regenerateDecisions(paths, nowIso, callbacks) {
+  const result = await renderDecisions2({ paths, nowIso, ...callbacks });
+  const existing = await readMarkdownFile3(paths.files.decisions);
+  await writeMarkdownFile3(
+    paths.files.decisions,
+    renderWithMarkers3(existing, result.body, "decisions.md")
+  );
+  return { decisionCount: result.decisionCount };
+}
+async function refreshAll(args) {
+  const { options, ctx, paths, nowIso } = args;
+  const dryRun = options.dryRun === true;
+  const claudeCode = await importClaudeCode(options, ctx);
+  const codex = await importCodex(options, ctx);
+  if (dryRun) {
+    const skipped = { status: "skipped", reason: "dry-run" };
+    return { claudeCode, codex, handoff: skipped, decisions: skipped, dryRun };
+  }
+  const handoffCounts = await regenerateHandoff(paths, nowIso);
+  const decisionCounts = await regenerateDecisions(paths, nowIso);
+  return {
+    claudeCode,
+    codex,
+    handoff: { status: "generated", ...handoffCounts },
+    decisions: { status: "generated", ...decisionCounts },
+    dryRun
+  };
+}
+
+// src/commands/refresh.ts
+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) => {
+    await runRefresh(options);
+  });
+}
+async function runRefresh(options, ctx = {}) {
+  try {
+    await doRunRefresh(options, ctx);
+  } catch (error) {
+    renderCliError(error, { verbose: isVerbose(options) });
+    process.exitCode = 1;
+  }
+}
+async function doRunRefresh(options, ctx) {
+  const cwd = ctx.cwd ?? process.cwd();
+  const repositoryRoot = await resolveRepositoryRootForRefresh(cwd);
+  const paths = basouPaths7(repositoryRoot);
+  await assertWorkspaceInitialized6(paths.root);
+  const nowIso = (ctx.nowProvider?.() ?? /* @__PURE__ */ new Date()).toISOString();
+  const result = await refreshAll({
+    options: {
+      ...options.project !== void 0 ? { project: options.project } : {},
+      ...options.force === true ? { force: true } : {},
+      ...options.dryRun === true ? { dryRun: true } : {}
+    },
+    ctx,
+    paths,
+    nowIso
+  });
+  if (options.json === true) {
+    console.log(JSON.stringify(result));
+  } else {
+    printRefreshSummary(result);
+  }
+  return result;
+}
+function describeImport(outcome) {
+  if (outcome.status === "skipped") {
+    return `${outcome.adapter}: skipped (${outcome.reason})`;
+  }
+  const verb = outcome.dryRun ? "would import" : "imported";
+  const parts = [`${outcome.importedCount} session(s)`, `${outcome.eventTotal} events`];
+  if (outcome.replacedCount > 0) parts.push(`${outcome.replacedCount} replaced`);
+  if (outcome.skippedAlreadyImported > 0)
+    parts.push(`${outcome.skippedAlreadyImported} already imported`);
+  return `${outcome.adapter}: ${verb} ${parts.join(", ")}`;
+}
+function printRefreshSummary(result) {
+  console.log(describeImport(result.claudeCode));
+  console.log(describeImport(result.codex));
+  if (result.handoff.status === "generated") {
+    console.log(
+      `handoff: regenerated (sessions: ${result.handoff.sessionCount}, decisions: ${result.handoff.decisionCount})`
+    );
+  } else {
+    console.log(`handoff: skipped (${result.handoff.reason})`);
+  }
+  if (result.decisions.status === "generated") {
+    console.log(`decisions: regenerated (${result.decisions.decisionCount})`);
+  } else {
+    console.log(`decisions: skipped (${result.decisions.reason})`);
+  }
+}
+async function resolveRepositoryRootForRefresh(cwd) {
+  try {
+    return await resolveRepositoryRoot8(cwd);
+  } catch (error) {
+    if (error instanceof Error && error.message === "Not a git repository") {
+      throw new Error("Not a git repository. Run 'git init' first, then re-run 'basou refresh'.", {
+        cause: error
+      });
+    }
+    throw error;
+  }
+}
+async function assertWorkspaceInitialized6(basouRoot) {
+  try {
+    await assertBasouRootSafe7(basouRoot);
+  } catch (error) {
+    if (findErrorCode6(error, "ENOENT")) {
+      throw new Error("Workspace not initialized. Run 'basou init' first.");
+    }
+    throw error;
+  }
+}
+
+// src/commands/run.ts
+import { mkdir as mkdir2 } from "fs/promises";
+import { homedir as homedir3 } from "os";
+import { join as join4 } from "path";
+import {
+  assertBasouRootSafe as assertBasouRootSafe8,
+  basouPaths as basouPaths8,
+  ChildProcessRunner as ChildProcessRunner2,
+  claudeCodeAdapterMetadata,
+  appendEvent as coreAppendEvent2,
+  getDiff,
+  getSnapshot as getSnapshot2,
+  overwriteYamlFile as overwriteYamlFile2,
+  prefixedUlid as prefixedUlid4,
+  readManifest as readManifest4,
+  readYamlFile as readYamlFile3,
+  resolveClaudeCodeCommand,
+  resolveRepositoryRoot as resolveRepositoryRoot9,
+  SessionSchema as SessionSchema2,
+  sanitizeRelatedFiles,
+  sanitizeWorkingDirectory as sanitizeWorkingDirectory2,
+  writeYamlFile as writeYamlFile2
+} from "@basou/core";
+function registerRunCommand(program2, ctx = {}) {
+  const runCommand = program2.command("run").description("Run an AI coding tool through Basou as a tracked session").enablePositionalOptions().option("--no-snapshot", "Skip git_snapshot before/after the session").option("--cwd <path>", "Run from a Basou root other than process.cwd()").option("-v, --verbose", "Show error causes");
+  runCommand.command("claude-code [args...]").description("Run Claude Code CLI as a Basou-tracked session").option("--no-snapshot", "Skip git_snapshot before/after the session").option("--cwd <path>", "Run from a Basou root other than process.cwd()").option("-v, --verbose", "Show error causes").passThroughOptions().action(async (args, options, command) => {
+    const parentOptions = command.parent?.opts() ?? {};
+    const snapshotOn = parentOptions.snapshot !== false && options.snapshot !== false;
+    const merged = {
+      ...parentOptions,
+      ...options,
+      snapshot: snapshotOn
+    };
+    try {
+      const exitCode = await runClaudeCode(args, merged, ctx);
+      process.exit(exitCode);
+    } catch (error) {
+      renderCliError(error, { verbose: isVerbose(merged) });
+      process.exit(1);
+    }
+  });
+}
+async function runClaudeCode(args, options, ctx = {}) {
+  const runner = ctx.runner ?? new ChildProcessRunner2();
+  const now = ctx.now ?? (() => /* @__PURE__ */ new Date());
+  const appendEvent2 = ctx.appendEvent ?? coreAppendEvent2;
+  const resolveCommand = ctx.resolveCommand ?? resolveClaudeCodeCommand;
+  const getDiffFn = ctx.getDiff ?? getDiff;
+  const { command } = await resolveCommand();
+  const cwd = options.cwd ?? process.cwd();
+  const repoRoot = await resolveRepositoryRootForRun(cwd);
+  const paths = basouPaths8(repoRoot);
+  await assertBasouRootSafe8(paths.root);
+  const manifest = await readManifest4(paths);
   const sessionId = prefixedUlid4("ses");
-  const sessionDir = join3(paths.sessions, sessionId);
+  const sessionDir = join4(paths.sessions, sessionId);
   await mkdir2(sessionDir, { recursive: true });
   const startedAt = now().toISOString();
-  const sessionYamlPath = join3(sessionDir, "session.yaml");
+  const sessionYamlPath = join4(sessionDir, "session.yaml");
   const session = buildInitialSession2({
     id: sessionId,
     command,
@@ -1580,7 +2177,7 @@ async function runClaudeCode(args, options, ctx = {}) {
   const rawRelated = computeRelatedFiles(preSnapshot, postSnapshot, diff);
   const relatedFiles = sanitizeRelatedFiles(rawRelated, {
     workingDirectory: repoRoot,
-    homedir: homedir2()
+    homedir: homedir3()
   }).sanitized;
   const finalStatus = decideFinalStatus2(result, signalReceived);
   await appendEvent2(sessionDir, {
@@ -1724,7 +2321,7 @@ function buildInitialSession2(input) {
       source: { ...claudeCodeAdapterMetadata },
       started_at: input.startedAt,
       status: "initialized",
-      working_directory: sanitizeWorkingDirectory2(input.cwd, { homedir: homedir2() }),
+      working_directory: sanitizeWorkingDirectory2(input.cwd, { homedir: homedir3() }),
       invocation: {
         command: input.command,
         args: [...input.args],
@@ -1784,7 +2381,7 @@ async function finalizeSessionAsFailed2(sessionDir, sessionYamlPath, sessionId,
 }
 async function resolveRepositoryRootForRun(cwd) {
   try {
-    return await resolveRepositoryRoot7(cwd);
+    return await resolveRepositoryRoot9(cwd);
   } catch (error) {
     if (error instanceof Error && error.message === "Not a git repository") {
       throw new Error("Not a git repository. Run 'git init' first, then re-run 'basou run'.", {
@@ -1796,28 +2393,42 @@ async function resolveRepositoryRootForRun(cwd) {
 }
 
 // src/commands/session.ts
-import { readFile } from "fs/promises";
-import { basename as basename2, isAbsolute, join as join4, relative } from "path";
+import { readFile as readFile2 } from "fs/promises";
+import { basename as basename3, isAbsolute, join as join5, relative } from "path";
 import {
-  SessionImportPayloadSchema,
-  SessionSchema as SessionSchema3,
-  SessionStatusSchema,
   acquireLock as acquireLock2,
   appendEventToExistingSession as appendEventToExistingSession2,
-  assertBasouRootSafe as assertBasouRootSafe7,
-  basouPaths as basouPaths7,
-  findErrorCode as findErrorCode5,
-  importSessionFromJson,
+  assertBasouRootSafe as assertBasouRootSafe9,
+  basouPaths as basouPaths9,
+  findErrorCode as findErrorCode7,
+  importSessionFromJson as importSessionFromJson2,
   loadSessionEntries,
   readAllEvents,
-  readManifest as readManifest4,
+  readManifest as readManifest5,
   readYamlFile as readYamlFile4,
-  resolveRepositoryRoot as resolveRepositoryRoot8,
+  resolveRepositoryRoot as resolveRepositoryRoot10,
   resolveSessionId as resolveSessionId2,
-  resolveTaskId
+  resolveTaskId,
+  SessionImportPayloadSchema as SessionImportPayloadSchema2,
+  SessionSchema as SessionSchema3,
+  SessionStatusSchema,
+  sessionWorkStatsFromEvents
 } from "@basou/core";
 import { InvalidArgumentError as InvalidArgumentError2 } from "commander";
-var SES_PREFIX2 = "ses_";
+
+// src/lib/format-duration.ts
+function formatDurationMs(ms) {
+  const totalSeconds = Math.round(ms / 1e3);
+  const hours = Math.floor(totalSeconds / 3600);
+  const minutes = Math.floor(totalSeconds % 3600 / 60);
+  const seconds = totalSeconds % 60;
+  if (hours > 0) return `${hours}h ${String(minutes).padStart(2, "0")}m`;
+  if (minutes > 0) return `${minutes}m ${String(seconds).padStart(2, "0")}s`;
+  return `${seconds}s`;
+}
+
+// src/commands/session.ts
+var SES_PREFIX3 = "ses_";
 var TASK_PREFIX2 = "task_";
 var SHORT_ID_BASE_LEN2 = 6;
 var SHORT_ID_MAX_LEN2 = 26;
@@ -1855,8 +2466,8 @@ async function runSessionList(options, ctx = {}) {
 async function doRunSessionList(options, ctx) {
   const cwd = ctx.cwd ?? process.cwd();
   const repositoryRoot = await resolveRepositoryRootForSession(cwd, "list");
-  const paths = basouPaths7(repositoryRoot);
-  await assertWorkspaceInitialized5(paths.root);
+  const paths = basouPaths9(repositoryRoot);
+  await assertWorkspaceInitialized7(paths.root);
   const now = /* @__PURE__ */ new Date();
   const records = (await loadSessionEntries(paths, {
     now,
@@ -1907,17 +2518,17 @@ async function runSessionShow(idInput, options, ctx = {}) {
 async function doRunSessionShow(idInput, options, ctx) {
   const cwd = ctx.cwd ?? process.cwd();
   const repositoryRoot = await resolveRepositoryRootForSession(cwd, "show");
-  const paths = basouPaths7(repositoryRoot);
-  await assertWorkspaceInitialized5(paths.root);
+  const paths = basouPaths9(repositoryRoot);
+  await assertWorkspaceInitialized7(paths.root);
   const sessionId = await resolveSessionId2(paths, idInput);
-  const sessionDir = join4(paths.sessions, sessionId);
-  const sessionYamlPath = join4(sessionDir, "session.yaml");
+  const sessionDir = join5(paths.sessions, sessionId);
+  const sessionYamlPath = join5(sessionDir, "session.yaml");
   let session;
   try {
     const raw = await readYamlFile4(sessionYamlPath);
     session = SessionSchema3.parse(raw);
   } catch (error) {
-    if (findErrorCode5(error, "ENOENT")) {
+    if (findErrorCode7(error, "ENOENT")) {
       throw new Error(`Session not found: ${idInput}`);
     }
     throw new Error("Failed to read session", { cause: error });
@@ -1929,7 +2540,8 @@ async function doRunSessionShow(idInput, options, ctx) {
     console.log(JSON.stringify({ session: session.session, events }, null, 2));
     return;
   }
-  printSessionShowText(session, events, options, repositoryRoot);
+  const now = ctx.nowProvider?.() ?? /* @__PURE__ */ new Date();
+  printSessionShowText(session, events, options, repositoryRoot, now);
 }
 function suspectLabel(reason) {
   if (reason === "events_say_ended_but_yaml_running") return " \u26A0 ended (yaml stale)";
@@ -1975,7 +2587,7 @@ function printSessionListText(records) {
     );
   }
 }
-function printSessionShowText(session, events, options, repositoryRoot) {
+function printSessionShowText(session, events, options, repositoryRoot, now) {
   const s = session.session;
   console.log(`Session: ${s.id}  (status: ${s.status})`);
   console.log(`Source:        ${s.source.kind} (v${s.source.version})`);
@@ -2000,6 +2612,8 @@ function printSessionShowText(session, events, options, repositoryRoot) {
   for (const [type, n] of counts) {
     console.log(`  ${pad2(`${type}:`, 24)} ${n}`);
   }
+  console.log("");
+  console.log(`Work:          ${formatSessionWork(session, events, now)}`);
   if (events.length === 0) return;
   const last = options.last ?? 5;
   const showAll = options.events === true && options.last === void 0;
@@ -2011,6 +2625,19 @@ function printSessionShowText(session, events, options, repositoryRoot) {
     console.log(`  ${formatEventLine(ev)}`);
   }
 }
+function formatSessionWork(session, events, now) {
+  const w = sessionWorkStatsFromEvents(session.session.id, session.session, events, now);
+  const parts = [];
+  if (w.tokens.output > 0) parts.push(`${w.tokens.output.toLocaleString("en-US")} output tokens`);
+  parts.push(`${w.commandCount} cmd / ${w.fileChangedCount} files / ${w.decisionCount} dec`);
+  const activeBasis = w.activeTimeBasis === "engaged-turns" ? "turns" : "events";
+  parts.push(`active ${formatDurationMs(w.activeTimeMs)} (${activeBasis})`);
+  parts.push(`span ${formatDurationMs(w.sessionSpanMs)}${w.open ? " (open)" : ""}`);
+  parts.push(
+    w.availability.commandTime ? `command ${formatDurationMs(w.commandTimeMs)}` : "command n/a (import)"
+  );
+  return parts.join(", ");
+}
 function formatWorkingDir(workingDir, repositoryRoot, options) {
   if (options.fullPath === true) return workingDir;
   if (!isAbsolute(workingDir)) {
@@ -2091,7 +2718,7 @@ function eventVariantSummary(ev) {
       return `${ev.stream} "${ev.summary}" raw_ref=${ev.raw_ref}`;
   }
 }
-function shortId2(id) {
+function shortId3(id) {
   return sliceShort2(id, SHORT_ID_BASE_LEN2);
 }
 function shortTaskId2(id) {
@@ -2101,8 +2728,8 @@ function shortTaskId2(id) {
   return id.slice(0, SHORT_ID_BASE_LEN2);
 }
 function sliceShort2(id, len) {
-  if (id.startsWith(SES_PREFIX2)) {
-    return id.slice(SES_PREFIX2.length, SES_PREFIX2.length + len);
+  if (id.startsWith(SES_PREFIX3)) {
+    return id.slice(SES_PREFIX3.length, SES_PREFIX3.length + len);
   }
   return id.slice(0, len);
 }
@@ -2133,7 +2760,7 @@ function maxLen2(values, floor) {
 }
 async function resolveRepositoryRootForSession(cwd, subcmd) {
   try {
-    return await resolveRepositoryRoot8(cwd);
+    return await resolveRepositoryRoot10(cwd);
   } catch (error) {
     if (error instanceof Error && error.message === "Not a git repository") {
       throw new Error(
@@ -2144,11 +2771,11 @@ async function resolveRepositoryRootForSession(cwd, subcmd) {
     throw error;
   }
 }
-async function assertWorkspaceInitialized5(basouRoot) {
+async function assertWorkspaceInitialized7(basouRoot) {
   try {
-    await assertBasouRootSafe7(basouRoot);
+    await assertBasouRootSafe9(basouRoot);
   } catch (error) {
-    if (findErrorCode5(error, "ENOENT")) {
+    if (findErrorCode7(error, "ENOENT")) {
       throw new Error("Workspace not initialized. Run 'basou init' first.");
     }
     throw error;
@@ -2186,24 +2813,24 @@ async function runSessionImport(options, ctx = {}) {
 async function doRunSessionImport(options, ctx) {
   const cwd = ctx.cwd ?? process.cwd();
   const repositoryRoot = await resolveRepositoryRootForSession(cwd, "import");
-  const paths = basouPaths7(repositoryRoot);
-  await assertWorkspaceInitialized5(paths.root);
-  const manifest = await readManifest4(paths);
+  const paths = basouPaths9(repositoryRoot);
+  await assertWorkspaceInitialized7(paths.root);
+  const manifest = await readManifest5(paths);
   const rawBody = await readInputFile(options.from);
   const json = parseJsonStrict(rawBody);
-  const parsed = SessionImportPayloadSchema.safeParse(json);
+  const parsed = SessionImportPayloadSchema2.safeParse(json);
   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}`);
   }
-  const importOptions = { dryRun: options.dryRun === true };
-  if (options.label !== void 0) importOptions.labelOverride = options.label;
+  const importOptions2 = { dryRun: options.dryRun === true };
+  if (options.label !== void 0) importOptions2.labelOverride = options.label;
   if (options.task !== void 0) {
-    importOptions.taskIdOverride = await resolveTaskId(paths, options.task);
+    importOptions2.taskIdOverride = await resolveTaskId(paths, options.task);
   }
-  const result = await importSessionFromJson(paths, manifest, parsed.data, importOptions);
+  const result = await importSessionFromJson2(paths, manifest, parsed.data, importOptions2);
   const sanitizeReport = result.pathSanitizeReport;
   if (sanitizeReport.relatedFiles > 0 || sanitizeReport.workingDirectoryRewritten) {
     const wdCount = sanitizeReport.workingDirectoryRewritten ? 1 : 0;
@@ -2215,12 +2842,12 @@ async function doRunSessionImport(options, ctx) {
 }
 async function readInputFile(path) {
   try {
-    return await readFile(path, "utf8");
+    return await readFile2(path, "utf8");
   } catch (error) {
-    if (findErrorCode5(error, "ENOENT")) {
+    if (findErrorCode7(error, "ENOENT")) {
       throw new Error("Import source not found", { cause: error });
     }
-    if (findErrorCode5(error, "EISDIR")) {
+    if (findErrorCode7(error, "EISDIR")) {
       throw new Error("Import source is not a file", { cause: error });
     }
     throw new Error("Failed to read import source", { cause: error });
@@ -2253,7 +2880,7 @@ function parseTaskIdOverride(raw) {
 }
 function printSessionImportResult(options, result) {
   const isDry = options.dryRun === true;
-  const sid = shortId2(result.sessionId);
+  const sid = shortId3(result.sessionId);
   if (options.json === true) {
     console.log(
       JSON.stringify({
@@ -2273,7 +2900,7 @@ function printSessionImportResult(options, result) {
     return;
   }
   console.log(
-    `Imported session ${sid} (${result.eventCount} events) from ${basename2(options.from)}`
+    `Imported session ${sid} (${result.eventCount} events) from ${basename3(options.from)}`
   );
 }
 var NOTE_BODY_PREVIEW_LIMIT = 80;
@@ -2300,8 +2927,8 @@ async function doRunSessionNote(sessionIdInput, options, ctx) {
   }
   const cwd = ctx.cwd ?? process.cwd();
   const repositoryRoot = await resolveRepositoryRootForSession(cwd, "note");
-  const paths = basouPaths7(repositoryRoot);
-  await assertWorkspaceInitialized5(paths.root);
+  const paths = basouPaths9(repositoryRoot);
+  await assertWorkspaceInitialized7(paths.root);
   const sessionId = await resolveSessionId2(paths, sessionIdInput);
   const body = hasBody ? options.body : await readNoteFile(options.fromFile);
   if (body.length === 0) {
@@ -2332,12 +2959,12 @@ async function doRunSessionNote(sessionIdInput, options, ctx) {
 }
 async function readNoteFile(path) {
   try {
-    return await readFile(path, "utf8");
+    return await readFile2(path, "utf8");
   } catch (error) {
-    if (findErrorCode5(error, "ENOENT")) {
+    if (findErrorCode7(error, "ENOENT")) {
       throw new Error("Note source not found", { cause: error });
     }
-    if (findErrorCode5(error, "EISDIR")) {
+    if (findErrorCode7(error, "EISDIR")) {
       throw new Error("Note source is not a file", { cause: error });
     }
     throw new Error("Failed to read note source", { cause: error });
@@ -2350,7 +2977,7 @@ function parseNoteBodyOption(raw) {
   return raw;
 }
 function printSessionNoteResult(options, sessionId, eventId, sessionStatus, body) {
-  const sid = shortId2(sessionId);
+  const sid = shortId3(sessionId);
   if (options.json === true) {
     console.log(
       JSON.stringify({
@@ -2366,14 +2993,136 @@ function printSessionNoteResult(options, sessionId, eventId, sessionStatus, body
   console.log(`Added note to session ${sid} (${sessionStatus}): ${preview}`);
 }
 
+// src/commands/stats.ts
+import {
+  assertBasouRootSafe as assertBasouRootSafe10,
+  basouPaths as basouPaths10,
+  computeWorkStats,
+  findErrorCode as findErrorCode8,
+  resolveRepositoryRoot as resolveRepositoryRoot11
+} from "@basou/core";
+function registerStatsCommand(program2) {
+  program2.command("stats").description("Report how much the AI worked (output volume + time proxies) across sessions").option("--by-source", "Break the totals down by session source kind").option("--by-day", "Break billable time and volume down by calendar day").option("--json", "Output the full stats as JSON").option("-v, --verbose", "Show error causes").action(async (options) => {
+    await runStats(options);
+  });
+}
+async function runStats(options, ctx = {}) {
+  try {
+    await doRunStats(options, ctx);
+  } catch (error) {
+    renderCliError(error, { verbose: isVerbose(options) });
+    process.exitCode = 1;
+  }
+}
+async function doRunStats(options, ctx) {
+  const cwd = ctx.cwd ?? process.cwd();
+  const repositoryRoot = await resolveRepositoryRootForStats(cwd);
+  const paths = basouPaths10(repositoryRoot);
+  await assertWorkspaceInitialized8(paths.root);
+  const now = ctx.nowProvider?.() ?? /* @__PURE__ */ new Date();
+  const result = await computeWorkStats({
+    paths,
+    now,
+    onWarning: (w, sid) => printReplayWarning(w, sid),
+    onSessionSkip: (sid, reason) => printSessionSkip(sid, reason)
+  });
+  if (options.json === true) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  printStatsText(result, options.bySource === true, options.byDay === true);
+}
+function printStatsText(result, bySource, byDay) {
+  const t = result.totals;
+  const statusPart = result.byStatus.length > 0 ? ` (${result.byStatus.map((s) => `${s.status} ${s.count}`).join(", ")})` : "";
+  console.log(`Sessions: ${t.sessionCount}${statusPart}`);
+  console.log("");
+  console.log("Volume (what the AI produced):");
+  const tokenSessions = result.sessions.filter((s) => s.availability.tokens).length;
+  const tokenCaveat = t.tokensAvailable && tokenSessions < t.sessionCount ? `  (token data on ${tokenSessions} of ${t.sessionCount} sessions)` : t.tokensAvailable ? "" : "  (no token data captured; re-import to backfill)";
+  console.log(`  Output tokens:     ${formatInt(t.tokens.output)}${tokenCaveat}`);
+  if (t.tokens.reasoning > 0) {
+    console.log(`  Reasoning tokens:  ${formatInt(t.tokens.reasoning)}  (Codex)`);
+  }
+  console.log(
+    `  Actions:           ${t.commandCount} commands, ${t.fileChangedCount} files, ${t.decisionCount} decisions`
+  );
+  console.log("");
+  console.log("Time (proxies for human harness labor; active = billing primary):");
+  const turnSessions = result.sessions.filter((s) => s.activeTimeBasis === "engaged-turns").length;
+  const basisCaveat = turnSessions === t.sessionCount ? "engaged turns" : turnSessions === 0 ? "event stream; re-import to capture conversation" : `engaged turns on ${turnSessions} of ${t.sessionCount} sessions, event stream on the rest`;
+  console.log(
+    `  Billable active: ${formatDurationMs(t.billableActiveTimeMs)}  (union; ${basisCaveat}; idle gaps > 5m excluded; tz ${result.timeZone})`
+  );
+  if (t.activeTimeMs !== t.billableActiveTimeMs) {
+    console.log(
+      `  Summed:          ${formatDurationMs(t.activeTimeMs)}  (per-session sum; concurrent sessions double-counted)`
+    );
+  }
+  const openPart = t.openSessionCount > 0 ? `; ${t.openSessionCount} open counted to now` : "";
+  console.log(
+    `  Span:            ${formatDurationMs(t.sessionSpanMs)}  (total elapsed${openPart})`
+  );
+  const cmdCaveat = t.commandTimeReliable ? "" : "; some sessions (e.g. claude-code-import) report 0 shell time";
+  console.log(
+    `  Command:         ${formatDurationMs(t.commandTimeMs)}  (real shell execution${cmdCaveat})`
+  );
+  if (bySource && result.bySource.length > 0) {
+    console.log("");
+    console.log("By source:");
+    for (const s of result.bySource) {
+      console.log(`  ${s.sourceKind}: ${describeSource(s)}`);
+    }
+  }
+  if (byDay && result.byDay.length > 0) {
+    console.log("");
+    console.log("By day (billable time x volume):");
+    for (const d of result.byDay) {
+      console.log(
+        `  ${d.date}: ${formatDurationMs(d.billableActiveTimeMs)} active, ${formatInt(d.tokens.output)} out tok, ${d.commandCount} cmd / ${d.fileChangedCount} files / ${d.decisionCount} dec`
+      );
+    }
+  }
+}
+function describeSource(s) {
+  const cmd = s.commandTimeReliable ? formatDurationMs(s.commandTimeMs) : "n/a";
+  const tokens = s.tokensAvailable ? `${formatInt(s.tokens.output)} out tok` : "no tokens";
+  return `${s.sessionCount} sessions, ${tokens}, active ${formatDurationMs(s.activeTimeMs)}, command ${cmd}`;
+}
+function formatInt(n) {
+  return n.toLocaleString("en-US");
+}
+async function resolveRepositoryRootForStats(cwd) {
+  try {
+    return await resolveRepositoryRoot11(cwd);
+  } catch (error) {
+    if (error instanceof Error && error.message === "Not a git repository") {
+      throw new Error("Not a git repository. Run 'git init' first, then re-run 'basou stats'.", {
+        cause: error
+      });
+    }
+    throw error;
+  }
+}
+async function assertWorkspaceInitialized8(basouRoot) {
+  try {
+    await assertBasouRootSafe10(basouRoot);
+  } catch (error) {
+    if (findErrorCode8(error, "ENOENT")) {
+      throw new Error("Workspace not initialized. Run 'basou init' first.");
+    }
+    throw error;
+  }
+}
+
 // src/commands/status.ts
 import {
-  assertBasouRootSafe as assertBasouRootSafe8,
-  basouPaths as basouPaths8,
+  assertBasouRootSafe as assertBasouRootSafe11,
+  basouPaths as basouPaths11,
   buildStatusSnapshot,
-  findErrorCode as findErrorCode6,
-  readManifest as readManifest5,
-  resolveRepositoryRoot as resolveRepositoryRoot9,
+  findErrorCode as findErrorCode9,
+  readManifest as readManifest6,
+  resolveRepositoryRoot as resolveRepositoryRoot12,
   writeStatus
 } from "@basou/core";
 function registerStatusCommand(program2) {
@@ -2392,20 +3141,20 @@ async function runStatus(options, ctx = {}) {
 async function doRunStatus(options, ctx) {
   const cwd = ctx.cwd ?? process.cwd();
   const repositoryRoot = await resolveRepositoryRootForStatus(cwd);
-  const paths = basouPaths8(repositoryRoot);
+  const paths = basouPaths11(repositoryRoot);
   try {
-    await assertBasouRootSafe8(paths.root);
+    await assertBasouRootSafe11(paths.root);
   } catch (error) {
-    if (findErrorCode6(error, "ENOENT")) {
+    if (findErrorCode9(error, "ENOENT")) {
       throw new Error("Workspace not initialized. Run 'basou init' first.");
     }
     throw error;
   }
   let manifest;
   try {
-    manifest = await readManifest5(paths);
+    manifest = await readManifest6(paths);
   } catch (error) {
-    if (findErrorCode6(error, "ENOENT")) {
+    if (findErrorCode9(error, "ENOENT")) {
       throw new Error("Workspace not initialized. Run 'basou init' first.");
     }
     throw new Error("Failed to read workspace manifest", { cause: error });
@@ -2429,7 +3178,7 @@ function renderTextStatus(s) {
 }
 async function resolveRepositoryRootForStatus(cwd) {
   try {
-    return await resolveRepositoryRoot9(cwd);
+    return await resolveRepositoryRoot12(cwd);
   } catch (error) {
     if (error instanceof Error && error.message === "Not a git repository") {
       throw new Error("Not a git repository. Run 'git init' first, then re-run 'basou status'.", {
@@ -2441,32 +3190,32 @@ async function resolveRepositoryRootForStatus(cwd) {
 }
 
 // src/commands/task.ts
-import { readFile as readFile2 } from "fs/promises";
-import { join as join5 } from "path";
+import { readFile as readFile3 } from "fs/promises";
+import { join as join6 } from "path";
 import {
-  TaskStatusSchema,
-  TaskWriteAfterEventError,
   archiveTask,
-  assertBasouRootSafe as assertBasouRootSafe9,
-  basouPaths as basouPaths9,
+  assertBasouRootSafe as assertBasouRootSafe12,
+  basouPaths as basouPaths12,
   createTaskWithEvent,
   deleteTask,
   editTask,
   enumerateArchivedTaskIds,
-  findErrorCode as findErrorCode7,
+  findErrorCode as findErrorCode10,
   loadSessionEntries as loadSessionEntries2,
   loadTaskEntries,
   prefixedUlid as prefixedUlid5,
-  readManifest as readManifest6,
+  readManifest as readManifest7,
   readTaskFile,
   readTaskFileWithArchiveFallback,
   reconcileAllTasks,
   reconcileTask,
   refreshTaskLinkedSessions,
   replayEvents as replayEvents2,
-  resolveRepositoryRoot as resolveRepositoryRoot10,
+  resolveRepositoryRoot as resolveRepositoryRoot13,
   resolveSessionId as resolveSessionId3,
   resolveTaskId as resolveTaskId2,
+  TaskStatusSchema,
+  TaskWriteAfterEventError,
   updateTaskStatusWithEvent
 } from "@basou/core";
 import { InvalidArgumentError as InvalidArgumentError3 } from "commander";
@@ -2548,8 +3297,8 @@ async function doRunTaskNew(options, ctx) {
   }
   const cwd = ctx.cwd ?? process.cwd();
   const repositoryRoot = await resolveRepositoryRootForTask(cwd, "new");
-  const paths = basouPaths9(repositoryRoot);
-  await assertWorkspaceInitialized6(paths.root);
+  const paths = basouPaths12(repositoryRoot);
+  await assertWorkspaceInitialized9(paths.root);
   const description = options.description !== void 0 ? options.description : options.fromFile !== void 0 ? await readDescriptionFile(options.fromFile) : "";
   const now = ctx.nowProvider !== void 0 ? ctx.nowProvider() : /* @__PURE__ */ new Date();
   const occurredAt = now.toISOString();
@@ -2583,7 +3332,7 @@ async function doRunTaskNew(options, ctx) {
     });
     return;
   }
-  const manifest = await readManifest6(paths);
+  const manifest = await readManifest7(paths);
   const result = await createTaskWithEvent({
     mode: "ad-hoc",
     paths,
@@ -2657,8 +3406,8 @@ async function runTaskList(options, ctx = {}) {
 async function doRunTaskList(options, ctx) {
   const cwd = ctx.cwd ?? process.cwd();
   const repositoryRoot = await resolveRepositoryRootForTask(cwd, "list");
-  const paths = basouPaths9(repositoryRoot);
-  await assertWorkspaceInitialized6(paths.root);
+  const paths = basouPaths12(repositoryRoot);
+  await assertWorkspaceInitialized9(paths.root);
   const entries = await loadTaskEntries(paths, {
     onSkip: (id, reason) => printTaskSkip(id, reason)
   });
@@ -2761,15 +3510,15 @@ async function runTaskShow(idInput, options, ctx = {}) {
 async function doRunTaskShow(idInput, options, ctx) {
   const cwd = ctx.cwd ?? process.cwd();
   const repositoryRoot = await resolveRepositoryRootForTask(cwd, "show");
-  const paths = basouPaths9(repositoryRoot);
-  await assertWorkspaceInitialized6(paths.root);
+  const paths = basouPaths12(repositoryRoot);
+  await assertWorkspaceInitialized9(paths.root);
   const taskId = await resolveTaskId2(paths, idInput, { includeArchived: true });
   const { doc, archived } = await readTaskFileWithArchiveFallback(paths, taskId);
   const sessions = await loadSessionEntries2(paths, { now: /* @__PURE__ */ new Date() });
   const events = [];
   const linkedSessionIds = new Set(doc.task.task.linked_sessions);
   for (const s of sessions) {
-    const sessionDir = join5(paths.sessions, s.sessionId);
+    const sessionDir = join6(paths.sessions, s.sessionId);
     try {
       for await (const ev of replayEvents2(sessionDir, {
         onWarning: (w) => printReplayWarning(w, s.sessionId)
@@ -2905,8 +3654,8 @@ async function doRunTaskStatus(taskIdInput, newStatusInput, options, ctx) {
   const newStatus = parseTaskStatusPositional(newStatusInput);
   const cwd = ctx.cwd ?? process.cwd();
   const repositoryRoot = await resolveRepositoryRootForTask(cwd, "status");
-  const paths = basouPaths9(repositoryRoot);
-  await assertWorkspaceInitialized6(paths.root);
+  const paths = basouPaths12(repositoryRoot);
+  await assertWorkspaceInitialized9(paths.root);
   const taskId = await resolveTaskId2(paths, taskIdInput);
   const now = ctx.nowProvider !== void 0 ? ctx.nowProvider() : /* @__PURE__ */ new Date();
   const occurredAt = now.toISOString();
@@ -2931,7 +3680,7 @@ async function doRunTaskStatus(taskIdInput, newStatusInput, options, ctx) {
     });
     return;
   }
-  const manifest = await readManifest6(paths);
+  const manifest = await readManifest7(paths);
   const result = await updateTaskStatusWithEvent({
     mode: "ad-hoc",
     paths,
@@ -2982,9 +3731,9 @@ async function runTaskReconcile(options, ctx = {}) {
 async function doRunTaskReconcile(options, ctx) {
   const cwd = ctx.cwd ?? process.cwd();
   const repositoryRoot = await resolveRepositoryRootForTask(cwd, "reconcile");
-  const paths = basouPaths9(repositoryRoot);
-  await assertWorkspaceInitialized6(paths.root);
-  const manifest = await readManifest6(paths);
+  const paths = basouPaths12(repositoryRoot);
+  await assertWorkspaceInitialized9(paths.root);
+  const manifest = await readManifest7(paths);
   const nowProvider = ctx.nowProvider ?? (() => /* @__PURE__ */ new Date());
   const write = options.write === true;
   const verbose = isVerbose(options);
@@ -3162,9 +3911,9 @@ async function doRunTaskRefreshLinkage(taskIdInput, options, ctx) {
   }
   const cwd = ctx.cwd ?? process.cwd();
   const repositoryRoot = await resolveRepositoryRootForTask(cwd, "refresh-linkage");
-  const paths = basouPaths9(repositoryRoot);
-  await assertWorkspaceInitialized6(paths.root);
-  const manifest = await readManifest6(paths);
+  const paths = basouPaths12(repositoryRoot);
+  await assertWorkspaceInitialized9(paths.root);
+  const manifest = await readManifest7(paths);
   const taskId = await resolveTaskId2(paths, taskIdInput);
   const nowProvider = ctx.nowProvider ?? (() => /* @__PURE__ */ new Date());
   const write = options.write === true;
@@ -3242,9 +3991,9 @@ async function doRunTaskEdit(taskIdInput, options, ctx) {
   }
   const cwd = ctx.cwd ?? process.cwd();
   const repositoryRoot = await resolveRepositoryRootForTask(cwd, "edit");
-  const paths = basouPaths9(repositoryRoot);
-  await assertWorkspaceInitialized6(paths.root);
-  const manifest = await readManifest6(paths);
+  const paths = basouPaths12(repositoryRoot);
+  await assertWorkspaceInitialized9(paths.root);
+  const manifest = await readManifest7(paths);
   const taskId = await resolveTaskId2(paths, taskIdInput);
   const now = ctx.nowProvider !== void 0 ? ctx.nowProvider() : /* @__PURE__ */ new Date();
   const occurredAt = now.toISOString();
@@ -3298,9 +4047,9 @@ async function doRunTaskDelete(taskIdInput, options, ctx) {
   }
   const cwd = ctx.cwd ?? process.cwd();
   const repositoryRoot = await resolveRepositoryRootForTask(cwd, "delete");
-  const paths = basouPaths9(repositoryRoot);
-  await assertWorkspaceInitialized6(paths.root);
-  const manifest = await readManifest6(paths);
+  const paths = basouPaths12(repositoryRoot);
+  await assertWorkspaceInitialized9(paths.root);
+  const manifest = await readManifest7(paths);
   const taskId = await resolveTaskId2(paths, taskIdInput);
   if (options.yes !== true) {
     await confirmDestructiveAction("delete", taskId);
@@ -3343,9 +4092,9 @@ async function doRunTaskArchive(taskIdInput, options, ctx) {
   }
   const cwd = ctx.cwd ?? process.cwd();
   const repositoryRoot = await resolveRepositoryRootForTask(cwd, "archive");
-  const paths = basouPaths9(repositoryRoot);
-  await assertWorkspaceInitialized6(paths.root);
-  const manifest = await readManifest6(paths);
+  const paths = basouPaths12(repositoryRoot);
+  await assertWorkspaceInitialized9(paths.root);
+  const manifest = await readManifest7(paths);
   const taskId = await resolveTaskId2(paths, taskIdInput);
   if (options.yes !== true) {
     await confirmDestructiveAction("archive", taskId);
@@ -3387,8 +4136,8 @@ async function confirmDestructiveAction(action, taskId) {
   }
 }
 async function readSingleLineFromStdin() {
-  const { createInterface } = await import("readline/promises");
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  const { createInterface: createInterface2 } = await import("readline/promises");
+  const rl = createInterface2({ input: process.stdin, output: process.stdout });
   try {
     const line = await rl.question("");
     return line;
@@ -3457,12 +4206,12 @@ function parsePositiveInt2(raw) {
 }
 async function readDescriptionFile(path) {
   try {
-    return await readFile2(path, "utf8");
+    return await readFile3(path, "utf8");
   } catch (error) {
-    if (findErrorCode7(error, "ENOENT")) {
+    if (findErrorCode10(error, "ENOENT")) {
       throw new Error("Description source not found", { cause: error });
     }
-    if (findErrorCode7(error, "EISDIR")) {
+    if (findErrorCode10(error, "EISDIR")) {
       throw new Error("Description source is not a file", { cause: error });
     }
     throw new Error("Failed to read description source", { cause: error });
@@ -3470,7 +4219,7 @@ async function readDescriptionFile(path) {
 }
 async function resolveRepositoryRootForTask(cwd, subcmd) {
   try {
-    return await resolveRepositoryRoot10(cwd);
+    return await resolveRepositoryRoot13(cwd);
   } catch (error) {
     if (error instanceof Error && error.message === "Not a git repository") {
       throw new Error(
@@ -3481,11 +4230,11 @@ async function resolveRepositoryRootForTask(cwd, subcmd) {
     throw error;
   }
 }
-async function assertWorkspaceInitialized6(basouRoot) {
+async function assertWorkspaceInitialized9(basouRoot) {
   try {
-    await assertBasouRootSafe9(basouRoot);
+    await assertBasouRootSafe12(basouRoot);
   } catch (error) {
-    if (findErrorCode7(error, "ENOENT")) {
+    if (findErrorCode10(error, "ENOENT")) {
       throw new Error("Workspace not initialized. Run 'basou init' first.");
     }
     throw error;
@@ -3571,22 +4320,950 @@ function maxLen3(values, floor) {
   return max;
 }
 
-// src/index.ts
+// 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";
+
+// src/lib/view-server.ts
+import { createServer } from "http";
+import { join as join7 } from "path";
+import {
+  computeWorkStats as computeWorkStats2,
+  enumerateApprovals as enumerateApprovals2,
+  findErrorCode as findErrorCode11,
+  isLazyExpired as isLazyExpired2,
+  loadApproval as loadApproval2,
+  loadSessionEntries as loadSessionEntries3,
+  loadTaskEntries as loadTaskEntries2,
+  readAllEvents as readAllEvents2,
+  readManifest as readManifest8,
+  readMarkdownFile as readMarkdownFile4,
+  readSessionYaml as readSessionYaml2,
+  readTaskFile as readTaskFile2,
+  renderDecisions as renderDecisions3,
+  renderHandoff as renderHandoff3
+} from "@basou/core";
+
+// src/lib/view-ui.ts
+var VIEW_HTML = `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1" />
+<title>basou view</title>
+<style>
+  :root { color-scheme: light dark; }
+  * { box-sizing: border-box; }
+  body { margin: 0; font: 14px/1.5 system-ui, -apple-system, Segoe UI, sans-serif; }
+  header { padding: 10px 16px; border-bottom: 1px solid #8884; display: flex; flex-wrap: wrap; gap: 8px 12px; align-items: center; }
+  header h1 { font-size: 15px; margin: 0 12px 0 0; font-weight: 700; }
+  header .grow { flex: 1; }
+  input[type=text] { padding: 4px 8px; border: 1px solid #8886; border-radius: 6px; min-width: 280px; font: inherit; }
+  button { padding: 4px 10px; border: 1px solid #8886; border-radius: 6px; background: #8881; cursor: pointer; font: inherit; }
+  button.primary { background: #2563eb; color: #fff; border-color: #2563eb; }
+  button:disabled { opacity: .5; cursor: default; }
+  label.chk { font-size: 13px; opacity: .85; }
+  #status { padding: 6px 16px; font-size: 13px; min-height: 20px; border-bottom: 1px solid #8884; white-space: pre-wrap; }
+  #status.err { color: #dc2626; }
+  nav { display: flex; gap: 2px; padding: 6px 12px; border-bottom: 1px solid #8884; flex-wrap: wrap; }
+  nav button { border: none; border-radius: 6px; background: transparent; }
+  nav button.active { background: #2563eb22; font-weight: 600; }
+  main { display: grid; grid-template-columns: minmax(220px, 320px) 1fr; min-height: 60vh; }
+  main.single { grid-template-columns: 1fr; }
+  #list { border-right: 1px solid #8884; overflow: auto; max-height: 80vh; }
+  #list .row { padding: 8px 12px; border-bottom: 1px solid #8883; cursor: pointer; }
+  #list .row:hover { background: #8881; }
+  #list .row.active { background: #2563eb22; }
+  #list .row .meta { font-size: 12px; opacity: .7; }
+  #detail { padding: 12px 16px; overflow: auto; max-height: 80vh; }
+  .badge { display: inline-block; padding: 0 6px; border-radius: 6px; background: #8882; font-size: 12px; }
+  .badge.warn { background: #f59e0b33; }
+  pre { background: #8881; padding: 12px; border-radius: 8px; overflow: auto; white-space: pre-wrap; word-break: break-word; }
+  table.kv { border-collapse: collapse; }
+  table.kv td { padding: 2px 10px 2px 0; vertical-align: top; }
+  table.kv td.k { opacity: .7; }
+  .cards { display: flex; flex-wrap: wrap; gap: 10px; }
+  .card { border: 1px solid #8884; border-radius: 8px; padding: 10px 14px; min-width: 120px; }
+  .card .n { font-size: 22px; font-weight: 700; }
+  .card .l { font-size: 12px; opacity: .7; }
+  .tl { border-left: 2px solid #8885; margin-left: 6px; padding-left: 12px; }
+  .tl .ev { margin-bottom: 8px; }
+  .tl .ev .t { font-size: 12px; opacity: .65; }
+  .muted { opacity: .6; }
+</style>
+</head>
+<body>
+<header>
+  <h1>basou view</h1>
+  <input type="text" id="project" placeholder="project path" />
+  <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>
+  <button id="btn-gen-handoff">Regenerate handoff</button>
+  <button id="btn-gen-decisions">Regenerate decisions</button>
+  <span class="grow"></span>
+  <label class="chk"><input type="checkbox" id="opt-force" /> force</label>
+  <label class="chk"><input type="checkbox" id="opt-dry" /> dry-run</label>
+</header>
+<div id="status"></div>
+<nav id="tabs"></nav>
+<main id="main">
+  <div id="list"></div>
+  <div id="detail"></div>
+</main>
+<script>
+(function () {
+  var TABS = ['overview', 'stats', 'sessions', 'tasks', 'decisions', 'approvals', 'handoff'];
+  var state = { tab: 'overview', repoRoot: '' };
+
+  function $(id) { return document.getElementById(id); }
+  function clear(node) { while (node.firstChild) node.removeChild(node.firstChild); }
+
+  function el(tag, attrs, children) {
+    var node = document.createElement(tag);
+    if (attrs) {
+      for (var k in attrs) {
+        if (!Object.prototype.hasOwnProperty.call(attrs, k)) continue;
+        if (k === 'class') node.className = attrs[k];
+        else if (k === 'text') node.textContent = attrs[k];
+        else if (k.slice(0, 2) === 'on') node.addEventListener(k.slice(2), attrs[k]);
+        else node.setAttribute(k, attrs[k]);
+      }
+    }
+    if (children) {
+      for (var i = 0; i < children.length; i++) {
+        var c = children[i];
+        if (c === null || c === undefined) continue;
+        node.appendChild(typeof c === 'string' ? document.createTextNode(c) : c);
+      }
+    }
+    return node;
+  }
+
+  function setStatus(msg, isErr) {
+    var s = $('status');
+    s.textContent = msg || '';
+    s.className = isErr ? 'err' : '';
+  }
+
+  function fetchJson(path, opts) {
+    return fetch(path, opts).then(function (res) {
+      return res.text().then(function (text) {
+        var data = null;
+        try { data = text ? JSON.parse(text) : null; } catch (e) { data = null; }
+        if (!res.ok) {
+          var m = data && data.error ? data.error : ('HTTP ' + res.status);
+          throw new Error(m);
+        }
+        return data;
+      });
+    });
+  }
+
+  function single(on) { $('main').className = on ? 'single' : ''; if (on) clear($('list')); }
+
+  // --- action bar ---------------------------------------------------------
+
+  function actionBody() {
+    var body = {};
+    var project = $('project').value.trim();
+    if (project) body.project = project;
+    if ($('opt-force').checked) body.force = true;
+    if ($('opt-dry').checked) body.dryRun = true;
+    return body;
+  }
+
+  function setBusy(busy) {
+    var ids = ['btn-refresh', 'btn-import-claude', 'btn-import-codex', 'btn-gen-handoff', 'btn-gen-decisions'];
+    for (var i = 0; i < ids.length; i++) $(ids[i]).disabled = busy;
+  }
+
+  function post(path, label) {
+    setBusy(true);
+    setStatus(label + '...', false);
+    fetchJson(path, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(actionBody())
+    }).then(function (data) {
+      setStatus(label + ' done: ' + summarize(data), false);
+      loadTab(state.tab);
+    }).catch(function (err) {
+      setStatus(label + ' failed: ' + err.message, true);
+    }).then(function () { setBusy(false); });
+  }
+
+  function summarize(data) {
+    if (!data) return 'ok';
+    if (data.claudeCode || data.codex) {
+      return 'claude-code ' + imp(data.claudeCode) + ', codex ' + imp(data.codex)
+        + (data.handoff && data.handoff.status === 'generated' ? '; handoff+decisions regenerated' : '');
+    }
+    if (data.status === 'ran') return imp(data);
+    if (data.status === 'skipped') return 'skipped (' + data.reason + ')';
+    if (typeof data.sessionCount === 'number') return 'sessions ' + data.sessionCount + ', decisions ' + data.decisionCount;
+    if (typeof data.decisionCount === 'number') return 'decisions ' + data.decisionCount;
+    return 'ok';
+  }
+  function imp(o) {
+    if (!o) return '-';
+    if (o.status === 'skipped') return 'skipped';
+    return (o.dryRun ? 'would import ' : 'imported ') + o.importedCount + ' (' + o.eventTotal + ' events)';
+  }
+
+  // --- tabs ---------------------------------------------------------------
+
+  function buildTabs() {
+    var nav = $('tabs');
+    clear(nav);
+    TABS.forEach(function (name) {
+      nav.appendChild(el('button', {
+        class: name === state.tab ? 'active' : '',
+        text: name,
+        onclick: function () { loadTab(name); }
+      }));
+    });
+  }
+
+  function loadTab(name) {
+    state.tab = name;
+    buildTabs();
+    clear($('detail'));
+    clear($('list'));
+    if (name === 'overview') return loadOverview();
+    if (name === 'stats') return loadStats();
+    if (name === 'sessions') return loadSessions();
+    if (name === 'tasks') return loadTasks();
+    if (name === 'decisions') return loadMarkdown('/api/decisions', 'decisions');
+    if (name === 'approvals') return loadApprovals();
+    if (name === 'handoff') return loadMarkdown('/api/handoff', 'handoff');
+  }
+
+  function fail(err) { setStatus(err.message, true); }
+
+  function loadOverview() {
+    single(true);
+    fetchJson('/api/overview').then(function (d) {
+      var detail = $('detail');
+      if (!d || d.initialized === false) {
+        detail.appendChild(el('p', { class: 'muted', text: 'Workspace not initialized.' }));
+        return;
+      }
+      $('project').value = $('project').value || d.repoRoot || '';
+      state.repoRoot = d.repoRoot || '';
+      detail.appendChild(el('p', {}, [
+        el('strong', { text: d.workspace.name }), '  ',
+        el('span', { class: 'muted', text: d.workspace.id })
+      ]));
+      var c = d.counts;
+      var cards = el('div', { class: 'cards' }, [
+        card(c.sessions, 'sessions'),
+        card(c.suspectSessions, 'suspect'),
+        card(c.tasks, 'tasks'),
+        card(c.pendingTasks, 'pending tasks'),
+        card(c.decisions, 'decisions'),
+        card(c.approvalsPending, 'approvals pending')
+      ]);
+      detail.appendChild(cards);
+      detail.appendChild(el('p', { class: 'muted', text: 'repo: ' + d.repoRoot }));
+    }).catch(fail);
+  }
+  function card(n, label) {
+    return el('div', { class: 'card' }, [
+      el('div', { class: 'n', text: String(n) }),
+      el('div', { class: 'l', text: label })
+    ]);
+  }
+
+  function numfmt(n) { return (n || 0).toLocaleString('en-US'); }
+  function fmtDur(ms) {
+    var s = Math.round((ms || 0) / 1000);
+    var h = Math.floor(s / 3600), m = Math.floor((s % 3600) / 60), sec = s % 60;
+    if (h > 0) return h + 'h ' + (m < 10 ? '0' : '') + m + 'm';
+    if (m > 0) return m + 'm ' + (sec < 10 ? '0' : '') + sec + 's';
+    return sec + 's';
+  }
+  function kvrow(k, v) {
+    return el('tr', {}, [el('td', { class: 'k', text: k }), el('td', { text: v })]);
+  }
+
+  function loadStats() {
+    single(true);
+    fetchJson('/api/stats').then(function (d) {
+      var detail = $('detail');
+      var t = d.totals;
+      detail.appendChild(el('p', { text: 'Sessions: ' + t.sessionCount }));
+      detail.appendChild(el('h3', { text: 'Volume (what the AI produced)' }));
+      detail.appendChild(el('div', { class: 'cards' }, [
+        card(numfmt(t.tokens.output), 'output tokens'),
+        (t.tokens.reasoning > 0 ? card(numfmt(t.tokens.reasoning), 'reasoning tokens') : null),
+        card(t.commandCount, 'commands'),
+        card(t.fileChangedCount, 'files'),
+        card(t.decisionCount, 'decisions')
+      ]));
+      var sessions = d.sessions || [];
+      var tokenSessions = sessions.filter(function (s) { return s.availability && s.availability.tokens; }).length;
+      if (!t.tokensAvailable) {
+        detail.appendChild(el('p', { class: 'muted', text: 'No token data captured; re-import to backfill.' }));
+      } else if (tokenSessions < t.sessionCount) {
+        detail.appendChild(el('p', { class: 'muted', text: 'Token data on ' + tokenSessions + ' of ' + t.sessionCount + ' sessions; re-import to backfill the rest.' }));
+      }
+      var degraded = sessions.filter(function (s) { return s.eventsUnreadable; }).length;
+      if (degraded > 0) {
+        detail.appendChild(el('p', { class: 'muted', text: degraded + ' session(s) had unreadable event logs; their counts are incomplete.' }));
+      }
+      detail.appendChild(el('h3', { text: 'Time (human harness labor; active = billing primary)' }));
+      var turnSessions = sessions.filter(function (s) { return s.activeTimeBasis === 'engaged-turns'; }).length;
+      var basisNote = turnSessions === t.sessionCount ? 'engaged turns' : (turnSessions === 0 ? 'event stream; re-import to capture conversation' : 'engaged turns on ' + turnSessions + ' of ' + t.sessionCount + ' sessions');
+      var timeRows = [kvrow('billable active', fmtDur(t.billableActiveTimeMs) + '  (union; ' + basisNote + '; idle gaps > 5m excluded; tz ' + d.timeZone + ')')];
+      if (t.activeTimeMs !== t.billableActiveTimeMs) {
+        timeRows.push(kvrow('summed', fmtDur(t.activeTimeMs) + '  (concurrent sessions double-counted)'));
+      }
+      timeRows.push(kvrow('span', fmtDur(t.sessionSpanMs) + (t.openSessionCount > 0 ? '  (' + t.openSessionCount + ' open)' : '')));
+      timeRows.push(kvrow('command', fmtDur(t.commandTimeMs) + (t.commandTimeReliable ? '' : '  (some sessions report 0)')));
+      detail.appendChild(el('table', { class: 'kv' }, [el('tbody', {}, timeRows)]));
+      if (d.bySource && d.bySource.length) {
+        detail.appendChild(el('h3', { text: 'By source' }));
+        d.bySource.forEach(function (s) {
+          var cmd = s.commandTimeReliable ? fmtDur(s.commandTimeMs) : 'n/a';
+          detail.appendChild(el('div', { class: 'row' }, [
+            el('span', { text: s.sourceKind + ': ' + s.sessionCount + ' sessions, ' + numfmt(s.tokens.output) + ' out tok, active ' + fmtDur(s.activeTimeMs) + ', command ' + cmd })
+          ]));
+        });
+      }
+      if (d.byDay && d.byDay.length) {
+        detail.appendChild(el('h3', { text: 'By day (billable time x volume)' }));
+        d.byDay.forEach(function (day) {
+          detail.appendChild(el('div', { class: 'row' }, [
+            el('span', { text: day.date + ': ' + fmtDur(day.billableActiveTimeMs) + ' active, ' + numfmt(day.tokens.output) + ' out tok, ' + day.commandCount + ' cmd / ' + day.fileChangedCount + ' files / ' + day.decisionCount + ' dec' })
+          ]));
+        });
+      }
+    }).catch(fail);
+  }
+
+  function loadSessions() {
+    single(false);
+    fetchJson('/api/sessions').then(function (d) {
+      var list = $('list');
+      var rows = (d && d.sessions) || [];
+      if (rows.length === 0) { list.appendChild(el('div', { class: 'row muted', text: 'no sessions' })); return; }
+      rows.forEach(function (s) {
+        var row = el('div', { class: 'row', onclick: function () { selectSession(row, s.sessionId); } }, [
+          el('div', { text: s.label || s.sessionId }),
+          el('div', { class: 'meta', text: s.sourceKind + '  ' + s.status + (s.suspect ? '  suspect' : '') })
+        ]);
+        list.appendChild(row);
+      });
+    }).catch(fail);
+  }
+  function selectSession(row, id) {
+    var rows = $('list').querySelectorAll('.row');
+    for (var i = 0; i < rows.length; i++) rows[i].classList.remove('active');
+    row.classList.add('active');
+    var detail = $('detail');
+    clear(detail);
+    fetchJson('/api/sessions/' + encodeURIComponent(id)).then(function (d) {
+      var s = d.session.session;
+      detail.appendChild(el('h3', { text: s.label || id }));
+      detail.appendChild(kv([
+        ['status', s.status], ['source', s.source.kind], ['started', s.started_at],
+        ['ended', s.ended_at || '-'], ['workdir', s.working_directory]
+      ]));
+      if (d.degraded) detail.appendChild(el('p', { class: 'badge warn', text: 'events unreadable' }));
+      var events = d.events || [];
+      detail.appendChild(el('p', { class: 'muted', text: events.length + ' events' }));
+      var tl = el('div', { class: 'tl' }, []);
+      events.forEach(function (ev) {
+        tl.appendChild(el('div', { class: 'ev' }, [
+          el('div', { class: 't', text: ev.occurred_at + '  ' + ev.type }),
+          el('div', { text: eventSummary(ev) })
+        ]));
+      });
+      detail.appendChild(tl);
+    }).catch(fail);
+  }
+  function eventSummary(ev) {
+    if (ev.type === 'command_executed') {
+      var cmd = (ev.args && ev.args.length) ? ev.args.join(' ') : ev.command;
+      var ex = (ev.exit_code === null || ev.exit_code === undefined) ? '' : ' (exit ' + ev.exit_code + ')';
+      return cmd + ex;
+    }
+    if (ev.type === 'file_changed') return ev.path + ' [' + ev.change_type + ']';
+    if (ev.type === 'decision_recorded') return ev.title || '';
+    return '';
+  }
+
+  function loadTasks() {
+    single(false);
+    fetchJson('/api/tasks').then(function (d) {
+      var list = $('list');
+      var rows = (d && d.tasks) || [];
+      if (rows.length === 0) { list.appendChild(el('div', { class: 'row muted', text: 'no tasks' })); return; }
+      rows.forEach(function (t) {
+        var row = el('div', { class: 'row', onclick: function () { selectTask(row, t.id); } }, [
+          el('div', { text: t.title || t.label || t.id }),
+          el('div', { class: 'meta', text: String(t.status || '') })
+        ]);
+        list.appendChild(row);
+      });
+    }).catch(fail);
+  }
+  function selectTask(row, id) {
+    var rows = $('list').querySelectorAll('.row');
+    for (var i = 0; i < rows.length; i++) rows[i].classList.remove('active');
+    row.classList.add('active');
+    var detail = $('detail');
+    clear(detail);
+    fetchJson('/api/tasks/' + encodeURIComponent(id)).then(function (d) {
+      detail.appendChild(el('h3', { text: (d.task && (d.task.title || d.task.label)) || id }));
+      detail.appendChild(el('pre', { text: JSON.stringify(d.task, null, 2) }));
+      if (d.body) detail.appendChild(el('pre', { text: d.body }));
+    }).catch(fail);
+  }
+
+  function loadMarkdown(path, label) {
+    single(true);
+    fetchJson(path).then(function (d) {
+      var detail = $('detail');
+      var count = (typeof d.decisionCount === 'number') ? (' (' + d.decisionCount + ' decisions)') : '';
+      detail.appendChild(el('p', { class: 'muted', text: label + count }));
+      detail.appendChild(el('pre', { text: (d && d.body) || '(empty)' }));
+    }).catch(fail);
+  }
+
+  function loadApprovals() {
+    single(true);
+    fetchJson('/api/approvals').then(function (d) {
+      var detail = $('detail');
+      var groups = [['pending', d.pending || []], ['resolved', d.resolved || []]];
+      groups.forEach(function (g) {
+        detail.appendChild(el('h3', { text: g[0] + ' (' + g[1].length + ')' }));
+        if (g[1].length === 0) { detail.appendChild(el('p', { class: 'muted', text: 'none' })); return; }
+        g[1].forEach(function (a) {
+          detail.appendChild(el('div', { class: 'row' }, [
+            el('span', { text: a.id + '  ' }),
+            el('span', { class: a.expired ? 'badge warn' : 'badge', text: a.expired ? 'expired' : (a.approval && a.approval.status) || '' })
+          ]));
+        });
+      });
+    }).catch(fail);
+  }
+
+  function kv(pairs) {
+    var tbody = el('tbody', {}, pairs.map(function (p) {
+      return el('tr', {}, [el('td', { class: 'k', text: p[0] }), el('td', { text: String(p[1]) })]);
+    }));
+    return el('table', { class: 'kv' }, [tbody]);
+  }
+
+  // --- wire up ------------------------------------------------------------
+
+  $('btn-refresh').addEventListener('click', function () { post('/api/refresh', 'Refresh all'); });
+  $('btn-import-claude').addEventListener('click', function () { post('/api/import/claude-code', 'Import claude-code'); });
+  $('btn-import-codex').addEventListener('click', function () { post('/api/import/codex', 'Import codex'); });
+  $('btn-gen-handoff').addEventListener('click', function () { post('/api/handoff/generate', 'Regenerate handoff'); });
+  $('btn-gen-decisions').addEventListener('click', function () { post('/api/decisions/generate', 'Regenerate decisions'); });
+
+  buildTabs();
+  loadTab('overview');
+})();
+</script>
+</body>
+</html>`;
+
+// src/lib/view-server.ts
+var HttpError = class extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+  }
+  status;
+};
+var MAX_BODY_BYTES = 64 * 1024;
+function startViewServer(opts) {
+  const { port, host = "127.0.0.1", deps } = opts;
+  let actionQueue = Promise.resolve();
+  const runExclusive = (fn) => {
+    const result = actionQueue.then(fn, fn);
+    actionQueue = result.then(
+      () => void 0,
+      () => void 0
+    );
+    return result;
+  };
+  let boundPort = port;
+  const getPort = () => boundPort;
+  return new Promise((resolve, reject) => {
+    const server = createServer((req, res) => {
+      handleRequest(req, res, deps, getPort, runExclusive).catch((error) => {
+        sendError(res, error instanceof HttpError ? error.status : 500, pathlessMessage(error));
+      });
+    });
+    server.on("error", reject);
+    server.listen(port, host, () => {
+      const address = server.address();
+      boundPort = isAddressInfo(address) ? address.port : port;
+      server.off("error", reject);
+      resolve({
+        url: `http://${host}:${boundPort}`,
+        port: boundPort,
+        close: () => closeServer(server)
+      });
+    });
+  });
+}
+function isAddressInfo(value) {
+  return value !== null && typeof value === "object";
+}
+function closeServer(server) {
+  return new Promise((resolve) => {
+    server.close(() => resolve());
+    server.closeAllConnections();
+  });
+}
+async function handleRequest(req, res, deps, getPort, runExclusive) {
+  const method = req.method ?? "GET";
+  const url = new URL(req.url ?? "/", "http://localhost");
+  const pathname = url.pathname;
+  if (!hostAllowed(req, getPort())) {
+    sendError(res, 403, "Forbidden: host not allowed");
+    return;
+  }
+  if (method === "GET") {
+    await handleGet(res, pathname, deps);
+    return;
+  }
+  if (method === "POST") {
+    if (!originAllowed(req, getPort())) {
+      sendError(res, 403, "Forbidden: cross-origin request");
+      return;
+    }
+    const body = await readBody(req);
+    await handlePost(res, pathname, body, deps, runExclusive);
+    return;
+  }
+  sendError(res, 405, "Method not allowed");
+}
+async function handleGet(res, pathname, deps) {
+  if (pathname === "/") {
+    sendHtml(res, VIEW_HTML);
+    return;
+  }
+  if (pathname === "/api/overview") {
+    sendJson(res, 200, await overview(deps));
+    return;
+  }
+  if (pathname === "/api/sessions") {
+    sendJson(res, 200, await sessionsList(deps));
+    return;
+  }
+  const sessionId = matchId(pathname, "/api/sessions/");
+  if (sessionId !== null) {
+    sendJson(res, 200, await sessionDetail(deps, sessionId));
+    return;
+  }
+  if (pathname === "/api/tasks") {
+    sendJson(res, 200, await tasksList(deps));
+    return;
+  }
+  const taskId = matchId(pathname, "/api/tasks/");
+  if (taskId !== null) {
+    sendJson(res, 200, await taskDetail(deps, taskId));
+    return;
+  }
+  if (pathname === "/api/decisions") {
+    sendJson(res, 200, await decisionsView(deps));
+    return;
+  }
+  if (pathname === "/api/approvals") {
+    sendJson(res, 200, await approvalsView(deps));
+    return;
+  }
+  if (pathname === "/api/handoff") {
+    sendJson(res, 200, await handoffView(deps));
+    return;
+  }
+  if (pathname === "/api/stats") {
+    sendJson(res, 200, await computeWorkStats2({ paths: deps.paths, now: deps.nowProvider() }));
+    return;
+  }
+  sendError(res, 404, "Not found");
+}
+async function handlePost(res, pathname, body, deps, runExclusive) {
+  const nowIso = deps.nowProvider().toISOString();
+  const actionOptions = readActionOptions(body);
+  if (pathname === "/api/refresh") {
+    const result = await runExclusive(
+      () => refreshAll({ options: actionOptions, ctx: deps.importCtx, paths: deps.paths, nowIso })
+    );
+    sendJson(res, 200, result);
+    return;
+  }
+  if (pathname === "/api/import/claude-code") {
+    sendJson(res, 200, await runExclusive(() => importClaudeCode(actionOptions, deps.importCtx)));
+    return;
+  }
+  if (pathname === "/api/import/codex") {
+    sendJson(res, 200, await runExclusive(() => importCodex(actionOptions, deps.importCtx)));
+    return;
+  }
+  if (pathname === "/api/handoff/generate") {
+    sendJson(res, 200, await runExclusive(() => regenerateHandoff(deps.paths, nowIso)));
+    return;
+  }
+  if (pathname === "/api/decisions/generate") {
+    sendJson(res, 200, await runExclusive(() => regenerateDecisions(deps.paths, nowIso)));
+    return;
+  }
+  sendError(res, 404, "Not found");
+}
+async function overview(deps) {
+  let manifest;
+  try {
+    manifest = await readManifest8(deps.paths);
+  } catch (error) {
+    if (findErrorCode11(error, "ENOENT")) {
+      return { initialized: false, repoRoot: deps.repoRoot };
+    }
+    throw error;
+  }
+  const nowIso = deps.nowProvider().toISOString();
+  const handoff = await renderHandoff3({ paths: deps.paths, nowIso });
+  const approvals = await enumerateApprovals2(deps.paths);
+  return {
+    initialized: true,
+    repoRoot: deps.repoRoot,
+    workspace: {
+      id: manifest.workspace.id,
+      name: manifest.workspace.name,
+      basouVersion: manifest.basou_version
+    },
+    counts: {
+      sessions: handoff.sessionCount,
+      suspectSessions: handoff.suspectCount,
+      tasks: handoff.taskCount,
+      pendingTasks: handoff.pendingTaskCount,
+      decisions: handoff.decisionCount,
+      approvalsPending: approvals.pending.length,
+      approvalsResolved: approvals.resolved.length
+    },
+    generatedAt: nowIso
+  };
+}
+async function sessionsList(deps) {
+  const entries = await loadSessionEntries3(deps.paths, { now: deps.nowProvider() });
+  const sessions = entries.map((entry) => ({
+    sessionId: entry.sessionId,
+    label: entry.session.session.label ?? null,
+    status: entry.session.session.status,
+    sourceKind: entry.session.session.source.kind,
+    startedAt: entry.session.session.started_at,
+    endedAt: entry.session.session.ended_at ?? null,
+    suspect: entry.suspect,
+    suspectReason: entry.suspectReason,
+    taskId: entry.session.session.task_id ?? null,
+    relatedFilesCount: entry.session.session.related_files.length
+  })).reverse();
+  return { sessions };
+}
+async function sessionDetail(deps, sessionId) {
+  let session;
+  try {
+    session = await readSessionYaml2(deps.paths, sessionId);
+  } catch (error) {
+    if (error instanceof Error && error.message === "YAML file not found") {
+      throw new HttpError(404, "Session not found");
+    }
+    throw error;
+  }
+  try {
+    const events = await readAllEvents2(join7(deps.paths.sessions, sessionId));
+    return { session, events };
+  } catch {
+    return { session, events: [], degraded: true };
+  }
+}
+async function tasksList(deps) {
+  const entries = await loadTaskEntries2(deps.paths);
+  return { tasks: entries.map((entry) => entry.task).reverse() };
+}
+async function taskDetail(deps, taskId) {
+  try {
+    const doc = await readTaskFile2(deps.paths, taskId);
+    return { task: doc.task, body: doc.body };
+  } catch (error) {
+    if (error instanceof Error && error.message === "Task file not found") {
+      throw new HttpError(404, "Task not found");
+    }
+    throw error;
+  }
+}
+async function decisionsView(deps) {
+  const fromDisk = await readMarkdownFile4(deps.paths.files.decisions);
+  if (fromDisk !== null) {
+    return { body: fromDisk, fromDisk: true };
+  }
+  const nowIso = deps.nowProvider().toISOString();
+  const result = await renderDecisions3({ paths: deps.paths, nowIso });
+  return { body: result.body, decisionCount: result.decisionCount, fromDisk: false };
+}
+async function approvalsView(deps) {
+  const now = deps.nowProvider();
+  const ids = await enumerateApprovals2(deps.paths);
+  const toViews = async (list) => {
+    const views = [];
+    for (const id of list) {
+      const loaded = await loadApproval2(deps.paths, id);
+      if (loaded === null) continue;
+      views.push({ id, expired: isLazyExpired2(loaded.approval, now), approval: loaded.approval });
+    }
+    return views;
+  };
+  return { pending: await toViews(ids.pending), resolved: await toViews(ids.resolved) };
+}
+async function handoffView(deps) {
+  const fromDisk = await readMarkdownFile4(deps.paths.files.handoff);
+  if (fromDisk !== null) {
+    return { body: fromDisk, fromDisk: true };
+  }
+  const nowIso = deps.nowProvider().toISOString();
+  const result = await renderHandoff3({ paths: deps.paths, nowIso });
+  return { body: result.body, fromDisk: false };
+}
+function readActionOptions(body) {
+  const options = {};
+  if (typeof body.project === "string" && body.project.length > 0) options.project = body.project;
+  if (body.force === true) options.force = true;
+  if (body.dryRun === true) options.dryRun = true;
+  return options;
+}
+function hostAllowed(req, port) {
+  const host = req.headers.host;
+  return host === `127.0.0.1:${port}` || host === `localhost:${port}`;
+}
+function originAllowed(req, port) {
+  const origin = req.headers.origin;
+  if (origin === void 0) return true;
+  return origin === `http://127.0.0.1:${port}` || origin === `http://localhost:${port}`;
+}
+async function readBody(req) {
+  const chunks = [];
+  let size = 0;
+  for await (const chunk of req) {
+    const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk));
+    size += buf.length;
+    if (size > MAX_BODY_BYTES) throw new HttpError(413, "Request body too large");
+    chunks.push(buf);
+  }
+  const raw = Buffer.concat(chunks).toString("utf8").trim();
+  if (raw.length === 0) return {};
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return parsed;
+    }
+  } catch {
+  }
+  throw new HttpError(400, "Invalid JSON body");
+}
+function matchId(pathname, prefix) {
+  if (!pathname.startsWith(prefix)) return null;
+  const encoded = pathname.slice(prefix.length);
+  if (encoded.length === 0 || encoded.includes("/")) return null;
+  let id;
+  try {
+    id = decodeURIComponent(encoded);
+  } catch {
+    return null;
+  }
+  if (id.length === 0 || id.includes("/") || id.includes("\\") || id.includes("\0") || id === "." || id === "..") {
+    return null;
+  }
+  return id;
+}
+function sendJson(res, status, data) {
+  const body = JSON.stringify(data);
+  res.writeHead(status, {
+    "Content-Type": "application/json; charset=utf-8",
+    "Cache-Control": "no-store"
+  });
+  res.end(body);
+}
+function sendHtml(res, html) {
+  res.writeHead(200, {
+    "Content-Type": "text/html; charset=utf-8",
+    "Cache-Control": "no-store"
+  });
+  res.end(html);
+}
+function sendError(res, status, message) {
+  if (res.headersSent) {
+    res.end();
+    return;
+  }
+  sendJson(res, status, { error: message });
+}
+function pathlessMessage(error) {
+  return error instanceof Error ? error.message : "Internal error";
+}
+
+// src/commands/view.ts
+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.");
+  }
+  return port;
+}
+function registerViewCommand(program2) {
+  program2.command("view").description("Open a local web UI to browse provenance and run imports (localhost only)").option("--port <number>", "Port to listen on (default 4319)", parsePort).option("--no-open", "Do not open the browser automatically").option("-v, --verbose", "Show error causes").action(async (options) => {
+    await runView(options);
+  });
+}
+async function runView(options, ctx = {}) {
+  try {
+    await doRunView(options, ctx);
+  } catch (error) {
+    renderCliError(error, { verbose: isVerbose(options) });
+    process.exitCode = 1;
+  }
+}
+async function doRunView(options, ctx) {
+  const cwd = ctx.cwd ?? process.cwd();
+  const repositoryRoot = await resolveRepositoryRootForView(cwd);
+  const paths = basouPaths13(repositoryRoot);
+  await assertWorkspaceInitialized10(paths.root);
+  const deps = {
+    paths,
+    repoRoot: repositoryRoot,
+    importCtx: {
+      cwd: repositoryRoot,
+      ...ctx.claudeProjectsDir !== void 0 ? { claudeProjectsDir: ctx.claudeProjectsDir } : {},
+      ...ctx.codexSessionsDir !== void 0 ? { codexSessionsDir: ctx.codexSessionsDir } : {}
+    },
+    nowProvider: ctx.nowProvider ?? (() => /* @__PURE__ */ new Date())
+  };
+  const port = options.port ?? DEFAULT_PORT;
+  const handle = await startListening(port, deps);
+  try {
+    console.log(`basou view running at ${handle.url}`);
+    console.log(
+      "Localhost only, no authentication. Do not expose this port beyond your machine. Press Ctrl+C to stop."
+    );
+    if (options.open !== false) {
+      openInBrowser(handle.url, ctx.openBrowser);
+    }
+    ctx.onListening?.(handle);
+    await waitForShutdown(ctx.signal);
+  } finally {
+    await handle.close();
+  }
+}
+async function startListening(port, deps) {
+  try {
+    return await startViewServer({ port, deps });
+  } catch (error) {
+    if (findErrorCode12(error, "EADDRINUSE")) {
+      throw new Error(`Port ${port} is already in use. Pass --port <n> to choose another.`, {
+        cause: error
+      });
+    }
+    throw error;
+  }
+}
+function openInBrowser(url, override) {
+  if (override !== void 0) {
+    override(url);
+    return;
+  }
+  if (process.platform !== "darwin") return;
+  try {
+    const child = spawn("open", [url], { stdio: "ignore", detached: true });
+    child.on("error", () => {
+    });
+    child.unref();
+  } catch {
+  }
+}
+function waitForShutdown(signal) {
+  return new Promise((resolve) => {
+    const cleanup = () => {
+      process.off("SIGINT", onSignal);
+      process.off("SIGTERM", onSignal);
+      signal?.removeEventListener("abort", onAbort);
+    };
+    const onSignal = () => {
+      cleanup();
+      resolve();
+    };
+    const onAbort = () => {
+      cleanup();
+      resolve();
+    };
+    process.on("SIGINT", onSignal);
+    process.on("SIGTERM", onSignal);
+    if (signal !== void 0) {
+      if (signal.aborted) {
+        cleanup();
+        resolve();
+        return;
+      }
+      signal.addEventListener("abort", onAbort);
+    }
+  });
+}
+async function resolveRepositoryRootForView(cwd) {
+  try {
+    return await resolveRepositoryRoot14(cwd);
+  } catch (error) {
+    if (error instanceof Error && error.message === "Not a git repository") {
+      throw new Error("Not a git repository. Run 'git init' first, then re-run 'basou view'.", {
+        cause: error
+      });
+    }
+    throw error;
+  }
+}
+async function assertWorkspaceInitialized10(basouRoot) {
+  try {
+    await assertBasouRootSafe13(basouRoot);
+  } catch (error) {
+    if (findErrorCode12(error, "ENOENT")) {
+      throw new Error("Workspace not initialized. Run 'basou init' first.");
+    }
+    throw error;
+  }
+}
+
+// src/program.ts
 var require2 = createRequire(import.meta.url);
 var pkg = require2("../package.json");
 var BASOU_CLI_VERSION = pkg.version;
-var program = new Command();
-program.name("basou").description("Provenance layer for AI development").version(BASOU_CLI_VERSION).enablePositionalOptions();
-registerInitCommand(program);
-registerStatusCommand(program);
-registerExecCommand(program);
-registerRunCommand(program);
-registerSessionCommand(program);
-registerApprovalCommand(program);
-registerDecisionCommand(program);
-registerTaskCommand(program);
-registerHandoffCommand(program);
-registerDecisionsCommand(program);
+function buildProgram() {
+  const program2 = new Command();
+  program2.name("basou").description("Provenance layer for AI development").version(BASOU_CLI_VERSION).enablePositionalOptions();
+  registerInitCommand(program2);
+  registerStatusCommand(program2);
+  registerStatsCommand(program2);
+  registerExecCommand(program2);
+  registerRunCommand(program2);
+  registerSessionCommand(program2);
+  registerImportCommand(program2);
+  registerRefreshCommand(program2);
+  registerViewCommand(program2);
+  registerApprovalCommand(program2);
+  registerDecisionCommand(program2);
+  registerTaskCommand(program2);
+  registerHandoffCommand(program2);
+  registerDecisionsCommand(program2);
+  return program2;
+}
+
+// src/index.ts
+var program = buildProgram();
 program.parseAsync(process.argv).catch((err) => {
   renderCliError(err, { verbose: isVerbose(void 0) });
   process.exit(1);