@basou/core 0.3.1 → 0.5.0

package/dist/index.js

@@ -1,3 +1,26 @@
+// src/adapters/claude-code/claude-code-adapter.ts
+import { spawn } from "child_process";
+var claudeCodeAdapterMetadata = {
+  kind: "claude-code-adapter",
+  version: "0.1.0"
+};
+async function resolveClaudeCodeCommand(lookup = isOnPath) {
+  for (const candidate of ["claude-code", "claude"]) {
+    if (await lookup(candidate)) return { command: candidate };
+  }
+  throw new Error("Claude Code CLI not found in PATH. Install claude-code (or claude) first.");
+}
+async function isOnPath(command) {
+  return new Promise((resolve2) => {
+    const child = spawn("which", [command], { stdio: "ignore" });
+    child.on("error", () => resolve2(false));
+    child.on("exit", (code) => resolve2(code === 0));
+  });
+}
+function summarizeAdapterOutput(_stream, _raw) {
+  throw new Error("adapter_output summary is not implemented in this release");
+}
+
 // src/ids/ulid.ts
 import { isValid as isValidUlid, monotonicFactory } from "ulid";
 var ID_PREFIXES = Object.freeze(["ws", "task", "ses", "evt", "appr", "decision"]);
@@ -23,6 +46,500 @@ function isValidPrefixedId(value) {
   return isValidUlid(ulidPart);
 }
 
+// src/stats/active-time.ts
+var ACTIVE_GAP_CAP_MS = 5 * 60 * 1e3;
+var ENGAGED_TURNS_METHOD = "engaged-turns";
+function activeTimeFromTimestamps(timestampsMs, capMs) {
+  const sorted = timestampsMs.filter((t) => Number.isFinite(t)).sort((a, b) => a - b);
+  const raw = [];
+  for (let i = 1; i < sorted.length; i++) {
+    const prev = sorted[i - 1];
+    const curr = sorted[i];
+    if (prev === void 0 || curr === void 0) continue;
+    const gap = curr - prev;
+    if (gap <= 0) continue;
+    raw.push([prev, prev + Math.min(gap, capMs)]);
+  }
+  const intervals = mergeIntervals(raw);
+  return { ms: sumDurations(intervals), intervals };
+}
+function mergeIntervals(intervals) {
+  const sorted = [...intervals].sort((a, b) => a[0] - b[0]);
+  const merged = [];
+  for (const [start, end] of sorted) {
+    const last = merged[merged.length - 1];
+    if (last !== void 0 && start <= last[1]) {
+      if (end > last[1]) last[1] = end;
+    } else {
+      merged.push([start, end]);
+    }
+  }
+  return merged;
+}
+function unionDurationMs(intervals) {
+  const merged = mergeIntervals(intervals);
+  return { ms: sumDurations(merged), merged };
+}
+function intervalsMsToIso(intervals) {
+  return intervals.map(([start, end]) => ({
+    start: new Date(start).toISOString(),
+    end: new Date(end).toISOString()
+  }));
+}
+function intervalsIsoToMs(intervals) {
+  const out = [];
+  for (const { start, end } of intervals) {
+    const s = Date.parse(start);
+    const e = Date.parse(end);
+    if (Number.isFinite(s) && Number.isFinite(e) && e >= s) out.push([s, e]);
+  }
+  return out;
+}
+function sumDurations(intervals) {
+  let total = 0;
+  for (const [start, end] of intervals) total += end - start;
+  return total;
+}
+
+// src/adapters/claude-code/transcript-importer.ts
+var CLAUDE_IMPORT_SOURCE = "claude-code-import";
+function claudeTranscriptToImportPayload(records, options) {
+  const placeholderSessionId = prefixedUlid("ses");
+  const askAnswers = indexAskAnswers(records);
+  const derived = [];
+  const relatedFiles = /* @__PURE__ */ new Set();
+  let minTs;
+  let maxTs;
+  let workingDir;
+  let claudeSessionId;
+  let outputTokens = 0;
+  let inputTokens = 0;
+  let cachedInputTokens = 0;
+  const seenMessageIds = /* @__PURE__ */ new Set();
+  const engagementTsMs = [];
+  const seenEngagementMessageIds = /* @__PURE__ */ new Set();
+  for (const record of records) {
+    const ts = readString(record.timestamp);
+    if (ts === void 0) continue;
+    if (minTs === void 0 || Date.parse(ts) < Date.parse(minTs)) minTs = ts;
+    if (maxTs === void 0 || Date.parse(ts) > Date.parse(maxTs)) maxTs = ts;
+    if (workingDir === void 0) workingDir = readString(record.cwd);
+    if (claudeSessionId === void 0) claudeSessionId = readString(record.sessionId);
+    if (record.isSidechain !== true) {
+      const tsMs = Date.parse(ts);
+      if (Number.isFinite(tsMs)) {
+        const recType = readString(record.type);
+        if (recType === "user") {
+          if (isHumanUserMessage(record)) engagementTsMs.push(tsMs);
+        } else if (recType === "assistant") {
+          const msg = isObject(record.message) ? record.message : void 0;
+          const mid = msg !== void 0 ? readString(msg.id) : void 0;
+          if (mid === void 0 || !seenEngagementMessageIds.has(mid)) {
+            if (mid !== void 0) seenEngagementMessageIds.add(mid);
+            engagementTsMs.push(tsMs);
+          }
+        }
+      }
+    }
+    if (readString(record.type) !== "assistant") continue;
+    const message = isObject(record.message) ? record.message : void 0;
+    const usage = message !== void 0 && isObject(message.usage) ? message.usage : void 0;
+    if (usage !== void 0) {
+      const messageId = message !== void 0 ? readString(message.id) : void 0;
+      const alreadyCounted = messageId !== void 0 && seenMessageIds.has(messageId);
+      if (!alreadyCounted) {
+        if (messageId !== void 0) seenMessageIds.add(messageId);
+        outputTokens += readNonNegInt(usage.output_tokens);
+        inputTokens += readNonNegInt(usage.input_tokens);
+        cachedInputTokens += readNonNegInt(usage.cache_read_input_tokens);
+      }
+    }
+    const cwd = readString(record.cwd) ?? workingDir ?? ".";
+    for (const item of toolUses(record)) {
+      const name = readString(item.name);
+      const input = isObject(item.input) ? item.input : void 0;
+      if (input === void 0) continue;
+      if (name === "Bash") {
+        const command = readString(input.command);
+        if (command !== void 0) {
+          derived.push(commandExecutedEvent(ts, placeholderSessionId, command, cwd));
+        }
+        continue;
+      }
+      if (name === "AskUserQuestion") {
+        const useId = readString(item.id);
+        const answers = useId !== void 0 ? askAnswers.get(useId) : void 0;
+        if (answers !== void 0) {
+          for (const [question, answer] of Object.entries(answers)) {
+            if (question.length === 0) continue;
+            const answerStr = typeof answer === "string" && answer.length > 0 ? answer : void 0;
+            const title = answerStr !== void 0 ? `${question} -> ${answerStr}` : question;
+            derived.push(decisionRecordedEvent(ts, placeholderSessionId, title));
+          }
+        }
+        continue;
+      }
+      if (name === "Edit" || name === "Write" || name === "NotebookEdit") {
+        const path2 = readString(input.file_path) ?? readString(input.notebook_path);
+        if (path2 !== void 0) {
+          const changeType = name === "Write" ? "added" : "modified";
+          relatedFiles.add(path2);
+          derived.push(fileChangedEvent(ts, placeholderSessionId, path2, changeType));
+        }
+      }
+    }
+  }
+  if (minTs === void 0 || maxTs === void 0) return null;
+  if (derived.length === 0) return null;
+  derived.sort((a, b) => Date.parse(a.occurred_at) - Date.parse(b.occurred_at));
+  const events = [
+    sessionStartedEvent(minTs, placeholderSessionId),
+    ...derived,
+    sessionEndedEvent(maxTs, placeholderSessionId)
+  ];
+  const externalId = options.externalId ?? claudeSessionId;
+  const commandCount = derived.reduce((n, e) => e.type === "command_executed" ? n + 1 : n, 0);
+  const fileCount = relatedFiles.size;
+  const date = minTs.slice(0, 10);
+  const label = `claude-code ${date}: ${commandCount} ${commandCount === 1 ? "command" : "commands"}, ${fileCount} ${fileCount === 1 ? "file" : "files"}`;
+  const active = engagementTsMs.length >= 2 ? activeTimeFromTimestamps(engagementTsMs, ACTIVE_GAP_CAP_MS) : void 0;
+  const metricsFields = {
+    ...outputTokens > 0 ? { output_tokens: outputTokens } : {},
+    ...inputTokens > 0 ? { input_tokens: inputTokens } : {},
+    ...cachedInputTokens > 0 ? { cached_input_tokens: cachedInputTokens } : {},
+    ...active !== void 0 && active.ms > 0 ? {
+      active_time_ms: active.ms,
+      active_intervals: intervalsMsToIso(active.intervals),
+      active_gap_cap_ms: ACTIVE_GAP_CAP_MS,
+      active_time_method: ENGAGED_TURNS_METHOD
+    } : {}
+  };
+  const metrics = Object.keys(metricsFields).length > 0 ? metricsFields : void 0;
+  const payload = {
+    schema_version: "0.1.0",
+    session: {
+      label,
+      workspace_id: options.workspaceId,
+      source: {
+        kind: CLAUDE_IMPORT_SOURCE,
+        version: "0.1.0",
+        ...externalId !== void 0 ? { external_id: externalId } : {}
+      },
+      started_at: minTs,
+      ended_at: maxTs,
+      // Validated against the canonical enum here; importSessionFromJson
+      // overwrites it with the literal "imported" regardless.
+      status: "imported",
+      working_directory: workingDir ?? ".",
+      invocation: { command: "claude", args: [], exit_code: null },
+      related_files: [...relatedFiles].sort(),
+      summary: null,
+      ...metrics !== void 0 ? { metrics } : {}
+    },
+    events
+  };
+  return payload;
+}
+function baseEvent(occurredAt, sessionId) {
+  return {
+    schema_version: "0.1.0",
+    id: prefixedUlid("evt"),
+    session_id: sessionId,
+    occurred_at: occurredAt,
+    source: CLAUDE_IMPORT_SOURCE
+  };
+}
+function sessionStartedEvent(occurredAt, sessionId) {
+  return { ...baseEvent(occurredAt, sessionId), type: "session_started" };
+}
+function sessionEndedEvent(occurredAt, sessionId) {
+  return { ...baseEvent(occurredAt, sessionId), type: "session_ended" };
+}
+function commandExecutedEvent(occurredAt, sessionId, command, cwd) {
+  return {
+    ...baseEvent(occurredAt, sessionId),
+    type: "command_executed",
+    command: "bash",
+    args: ["-c", command],
+    cwd,
+    exit_code: null,
+    duration_ms: 0
+  };
+}
+function fileChangedEvent(occurredAt, sessionId, path2, changeType) {
+  return {
+    ...baseEvent(occurredAt, sessionId),
+    type: "file_changed",
+    path: path2,
+    change_type: changeType
+  };
+}
+function decisionRecordedEvent(occurredAt, sessionId, title) {
+  return {
+    ...baseEvent(occurredAt, sessionId),
+    type: "decision_recorded",
+    decision_id: prefixedUlid("decision"),
+    title
+  };
+}
+function readString(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function readNonNegInt(value) {
+  return typeof value === "number" && Number.isInteger(value) && value >= 0 ? value : 0;
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isHumanUserMessage(record) {
+  const message = isObject(record.message) ? record.message : void 0;
+  if (message === void 0) return false;
+  const content = message.content;
+  if (typeof content === "string") return content.length > 0;
+  if (Array.isArray(content)) {
+    return content.some((block) => {
+      if (!isObject(block)) return false;
+      const type = readString(block.type);
+      return type !== void 0 && type !== "tool_result";
+    });
+  }
+  return false;
+}
+function toolUses(record) {
+  const message = isObject(record.message) ? record.message : void 0;
+  const content = message !== void 0 && Array.isArray(message.content) ? message.content : [];
+  const result = [];
+  for (const item of content) {
+    if (isObject(item) && readString(item.type) === "tool_use") {
+      result.push(item);
+    }
+  }
+  return result;
+}
+function indexAskAnswers(records) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const record of records) {
+    const result = record.toolUseResult;
+    if (!isObject(result)) continue;
+    const answers = result.answers;
+    if (!isObject(answers)) continue;
+    const message = isObject(record.message) ? record.message : void 0;
+    const content = message !== void 0 && Array.isArray(message.content) ? message.content : [];
+    for (const item of content) {
+      if (isObject(item) && readString(item.type) === "tool_result") {
+        const id = readString(item.tool_use_id);
+        if (id !== void 0) byId.set(id, answers);
+      }
+    }
+  }
+  return byId;
+}
+
+// src/adapters/codex/rollout-importer.ts
+var CODEX_IMPORT_SOURCE = "codex-import";
+function codexRolloutToImportPayload(records, options) {
+  const placeholderSessionId = prefixedUlid("ses");
+  const outputsByCallId = indexOutputs(records);
+  const derived = [];
+  let minTs;
+  let maxTs;
+  let workingDir;
+  let codexSessionId;
+  let lastTokenTotals;
+  const engagementTsMs = [];
+  for (const record of records) {
+    const ts = readString2(record.timestamp);
+    if (ts === void 0) continue;
+    if (minTs === void 0 || Date.parse(ts) < Date.parse(minTs)) minTs = ts;
+    if (maxTs === void 0 || Date.parse(ts) > Date.parse(maxTs)) maxTs = ts;
+    const payload2 = isObject2(record.payload) ? record.payload : void 0;
+    if (payload2 === void 0) continue;
+    if (readString2(record.type) === "session_meta") {
+      if (workingDir === void 0) workingDir = readString2(payload2.cwd);
+      if (codexSessionId === void 0) codexSessionId = readString2(payload2.id);
+      continue;
+    }
+    if (readString2(record.type) === "event_msg" && readString2(payload2.type) === "token_count") {
+      const info = isObject2(payload2.info) ? payload2.info : void 0;
+      const totals = info !== void 0 && isObject2(info.total_token_usage) ? info.total_token_usage : void 0;
+      if (totals !== void 0) lastTokenTotals = totals;
+      continue;
+    }
+    if (readString2(record.type) === "event_msg") {
+      const pt = readString2(payload2.type);
+      if (pt === "user_message" || pt === "agent_message" || pt === "task_started" || pt === "task_complete") {
+        const tsMs = Date.parse(ts);
+        if (Number.isFinite(tsMs)) engagementTsMs.push(tsMs);
+      }
+      continue;
+    }
+    if (readString2(record.type) !== "response_item") continue;
+    if (readString2(payload2.type) !== "function_call") continue;
+    if (readString2(payload2.name) !== "exec_command") continue;
+    const command = readExecCommand(payload2.arguments);
+    if (command === void 0) continue;
+    const cwd = command.workdir ?? workingDir ?? ".";
+    const output = readCallId(payload2.call_id, outputsByCallId);
+    const execTsMs = Date.parse(ts);
+    if (Number.isFinite(execTsMs)) engagementTsMs.push(execTsMs);
+    derived.push(
+      commandExecutedEvent2(ts, placeholderSessionId, command.cmd, cwd, {
+        exitCode: parseExitCode(output),
+        durationMs: parseWallTimeMs(output)
+      })
+    );
+  }
+  if (minTs === void 0 || maxTs === void 0) return null;
+  if (derived.length === 0) return null;
+  derived.sort((a, b) => Date.parse(a.occurred_at) - Date.parse(b.occurred_at));
+  const events = [
+    sessionStartedEvent2(minTs, placeholderSessionId),
+    ...derived,
+    sessionEndedEvent2(maxTs, placeholderSessionId)
+  ];
+  const externalId = options.externalId ?? codexSessionId;
+  const commandCount = derived.length;
+  const date = minTs.slice(0, 10);
+  const label = `codex ${date}: ${commandCount} ${commandCount === 1 ? "command" : "commands"}`;
+  const active = engagementTsMs.length >= 2 ? activeTimeFromTimestamps(engagementTsMs, ACTIVE_GAP_CAP_MS) : void 0;
+  const tokenFields = lastTokenTotals === void 0 ? {} : {
+    ...readNonNegInt2(lastTokenTotals.output_tokens) > 0 ? { output_tokens: readNonNegInt2(lastTokenTotals.output_tokens) } : {},
+    ...readNonNegInt2(lastTokenTotals.input_tokens) > 0 ? { input_tokens: readNonNegInt2(lastTokenTotals.input_tokens) } : {},
+    ...readNonNegInt2(lastTokenTotals.cached_input_tokens) > 0 ? { cached_input_tokens: readNonNegInt2(lastTokenTotals.cached_input_tokens) } : {},
+    ...readNonNegInt2(lastTokenTotals.reasoning_output_tokens) > 0 ? { reasoning_output_tokens: readNonNegInt2(lastTokenTotals.reasoning_output_tokens) } : {}
+  };
+  const metricsFields = {
+    ...tokenFields,
+    ...active !== void 0 && active.ms > 0 ? {
+      active_time_ms: active.ms,
+      active_intervals: intervalsMsToIso(active.intervals),
+      active_gap_cap_ms: ACTIVE_GAP_CAP_MS,
+      active_time_method: ENGAGED_TURNS_METHOD
+    } : {}
+  };
+  const metrics = Object.keys(metricsFields).length > 0 ? metricsFields : void 0;
+  const payload = {
+    schema_version: "0.1.0",
+    session: {
+      label,
+      workspace_id: options.workspaceId,
+      source: {
+        kind: CODEX_IMPORT_SOURCE,
+        version: "0.1.0",
+        ...externalId !== void 0 ? { external_id: externalId } : {}
+      },
+      started_at: minTs,
+      ended_at: maxTs,
+      // Validated against the canonical enum here; importSessionFromJson
+      // overwrites it with the literal "imported" regardless.
+      status: "imported",
+      working_directory: workingDir ?? ".",
+      invocation: { command: "codex", args: [], exit_code: null },
+      related_files: [],
+      summary: null,
+      ...metrics !== void 0 ? { metrics } : {}
+    },
+    events
+  };
+  return payload;
+}
+function baseEvent2(occurredAt, sessionId) {
+  return {
+    schema_version: "0.1.0",
+    id: prefixedUlid("evt"),
+    session_id: sessionId,
+    occurred_at: occurredAt,
+    source: CODEX_IMPORT_SOURCE
+  };
+}
+function sessionStartedEvent2(occurredAt, sessionId) {
+  return { ...baseEvent2(occurredAt, sessionId), type: "session_started" };
+}
+function sessionEndedEvent2(occurredAt, sessionId) {
+  return { ...baseEvent2(occurredAt, sessionId), type: "session_ended" };
+}
+function commandExecutedEvent2(occurredAt, sessionId, command, cwd, outcome) {
+  return {
+    ...baseEvent2(occurredAt, sessionId),
+    type: "command_executed",
+    command: "bash",
+    args: ["-c", command],
+    cwd,
+    exit_code: outcome.exitCode,
+    duration_ms: outcome.durationMs
+  };
+}
+function readString2(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function readNonNegInt2(value) {
+  return typeof value === "number" && Number.isInteger(value) && value >= 0 ? value : 0;
+}
+function isObject2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readExecCommand(value) {
+  const raw = readString2(value);
+  if (raw === void 0) return void 0;
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+  if (!isObject2(parsed)) return void 0;
+  const cmd = readString2(parsed.cmd);
+  if (cmd === void 0) return void 0;
+  return { cmd, workdir: readString2(parsed.workdir) };
+}
+function readCallId(value, outputs) {
+  const callId = readString2(value);
+  return callId !== void 0 ? outputs.get(callId) : void 0;
+}
+function parseExitCode(output) {
+  if (output === void 0) return null;
+  const match = output.match(/Process exited with code (-?\d+)/);
+  return match?.[1] !== void 0 ? Number.parseInt(match[1], 10) : null;
+}
+function parseWallTimeMs(output) {
+  if (output === void 0) return 0;
+  const match = output.match(/Wall time:\s*([\d.]+)\s*seconds/);
+  if (match?.[1] === void 0) return 0;
+  const seconds = Number.parseFloat(match[1]);
+  return Number.isFinite(seconds) ? Math.round(seconds * 1e3) : 0;
+}
+function indexOutputs(records) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const record of records) {
+    if (readString2(record.type) !== "response_item") continue;
+    const payload = isObject2(record.payload) ? record.payload : void 0;
+    if (payload === void 0) continue;
+    if (readString2(payload.type) !== "function_call_output") continue;
+    const callId = readString2(payload.call_id);
+    const output = readString2(payload.output);
+    if (callId !== void 0 && output !== void 0) byId.set(callId, output);
+  }
+  return byId;
+}
+
+// src/approval/approval-store.ts
+import { readdir } from "fs/promises";
+import { join } from "path";
+
+// src/lib/error-codes.ts
+function findErrorCode(error, code, depth = 4) {
+  let cur = error;
+  for (let i = 0; i < depth && cur instanceof Error; i++) {
+    const c = cur.code;
+    if (typeof c === "string" && c === code) return true;
+    cur = cur.cause;
+  }
+  return false;
+}
+
+// src/schemas/approval.schema.ts
+import { z as z2 } from "zod";
+
 // src/schemas/shared.schema.ts
 import { z } from "zod";
 var SchemaVersionSchema = z.literal("0.1.0");
@@ -40,395 +557,30 @@ var DecisionIdSchema = createPrefixedIdSchema("decision");
 var RiskLevelSchema = z.enum(["low", "medium", "high", "critical"]);
 var EventSourceSchema = z.string().min(1);
 
-// src/schemas/manifest.schema.ts
-import { z as z2 } from "zod";
-var ProjectSchema = z2.object({
-  name: z2.string().optional(),
-  description: z2.string().optional(),
-  repository_url: z2.string().nullable().optional()
-});
-var CapabilitiesSchema = z2.object({
-  enabled: z2.array(z2.string())
-});
-var ApprovalConfigSchema = z2.object({
-  required_for: z2.array(z2.string()).optional(),
-  default_risk_level: z2.enum(["low", "medium", "high", "critical"])
-});
-var ClaudeCodeAdapterConfigSchema = z2.object({
-  enabled: z2.boolean(),
-  config_path: z2.string().optional()
-});
-var AdaptersSchema = z2.object({
-  "claude-code": ClaudeCodeAdapterConfigSchema
-});
-var GitConfigSchema = z2.object({
-  events_log: z2.enum(["ignore", "commit"]).default("ignore")
-});
-var WorkspaceMetaSchema = z2.object({
-  id: WorkspaceIdSchema,
-  name: z2.string().min(1),
-  created_at: IsoTimestampSchema,
-  updated_at: IsoTimestampSchema
-});
-var ManifestSchema = z2.object({
+// src/schemas/approval.schema.ts
+var ApprovalStatusSchema = z2.enum(["pending", "approved", "rejected", "expired"]);
+var ApprovalSchema = z2.object({
   schema_version: SchemaVersionSchema,
-  basou_version: z2.literal("0.1.0"),
-  workspace: WorkspaceMetaSchema,
-  project: ProjectSchema,
-  capabilities: CapabilitiesSchema,
-  approval: ApprovalConfigSchema,
-  adapters: AdaptersSchema,
-  git: GitConfigSchema
+  id: ApprovalIdSchema,
+  session_id: SessionIdSchema,
+  created_at: IsoTimestampSchema,
+  status: ApprovalStatusSchema,
+  risk_level: RiskLevelSchema,
+  action: z2.object({ kind: z2.string() }).passthrough(),
+  reason: z2.string(),
+  expires_at: IsoTimestampSchema.nullable().default(null),
+  // The four fields below are null while `status === "pending"` and set
+  // once a resolver records a decision. Defaulting to null keeps the
+  // pending YAML free of explicit nulls if a producer omits them.
+  resolver: z2.string().nullable().default(null),
+  resolved_at: IsoTimestampSchema.nullable().default(null),
+  note: z2.string().nullable().default(null),
+  rejection_reason: z2.string().nullable().default(null)
 });
 
-// src/schemas/status.schema.ts
-import { z as z3 } from "zod";
-var StatusSchema = z3.object({
-  schema_version: SchemaVersionSchema,
-  generated_at: IsoTimestampSchema,
-  workspace: z3.object({
-    id: WorkspaceIdSchema,
-    name: z3.string().min(1),
-    basou_version: z3.literal("0.1.0")
-  }).strict(),
-  directories_present: z3.object({
-    sessions: z3.boolean(),
-    tasks: z3.boolean(),
-    approvals_pending: z3.boolean(),
-    approvals_resolved: z3.boolean(),
-    logs: z3.boolean(),
-    raw: z3.boolean(),
-    tmp: z3.boolean()
-  }).strict()
-}).strict();
-
-// src/schemas/session.schema.ts
-import { z as z4 } from "zod";
-var SessionStatusSchema = z4.enum([
-  "initialized",
-  "running",
-  "waiting_approval",
-  "completed",
-  "failed",
-  "interrupted",
-  "imported",
-  "archived"
-]);
-var SessionSourceKindSchema = z4.enum([
-  "claude-code-adapter",
-  "human",
-  "import",
-  "terminal"
-]);
-var SessionSourceSchema = z4.object({
-  kind: SessionSourceKindSchema,
-  version: z4.literal("0.1.0")
-});
-var InvocationSchema = z4.object({
-  command: z4.string().min(1),
-  args: z4.array(z4.string()).default([]),
-  // Nullable to record signal-terminated runs where the child has no exit
-  // code; the same nullability is mirrored in CommandExecutedEventSchema.
-  exit_code: z4.number().int().nullable()
-});
-var SessionInnerSchema = z4.object({
-  id: SessionIdSchema,
-  label: z4.string().optional(),
-  task_id: TaskIdSchema.nullable().optional(),
-  workspace_id: WorkspaceIdSchema,
-  source: SessionSourceSchema,
-  started_at: IsoTimestampSchema,
-  // ended_at is optional because initialized / running sessions have no end time yet.
-  ended_at: IsoTimestampSchema.optional(),
-  status: SessionStatusSchema,
-  working_directory: z4.string().min(1),
-  invocation: InvocationSchema,
-  related_files: z4.array(z4.string()).default([]),
-  events_log: z4.string().default("events.jsonl"),
-  summary: z4.string().nullable().optional()
-});
-var SessionSchema = z4.object({
-  schema_version: SchemaVersionSchema,
-  session: SessionInnerSchema
-});
-
-// src/schemas/task.schema.ts
-import { z as z5 } from "zod";
-var TaskStatusSchema = z5.enum(["planned", "in_progress", "done", "cancelled"]);
-var TaskInnerSchema = z5.object({
-  id: TaskIdSchema,
-  title: z5.string().min(1),
-  label: z5.string().min(1).optional(),
-  status: TaskStatusSchema,
-  created_at: IsoTimestampSchema,
-  updated_at: IsoTimestampSchema,
-  workspace_id: WorkspaceIdSchema,
-  /**
-   * Session id that anchors this task. For freshly created tasks it is the
-   * session that wrote the `task_created` event (= ad-hoc reconcile target
-   * for ad-hoc paths, or the target session id for attach paths). After
-   * `basou task reconcile --write` repairs a broken anchor the
-   * value is replaced with the ad-hoc reconcile session id; the old broken
-   * session_id is preserved on the `task_reconciled` event payload via
-   * `removed_created_in_session` for audit. So this field always names a
-   * reachable session, even after the original anchor is gone.
-   */
-  created_in_session: SessionIdSchema,
-  /**
-   * Snapshot of sessions linked to this task. The events.jsonl history is
-   * the source of truth (see
-   * `docs/spec/generated-markdown.md#105-decisionsmd-generation-principle`);
-   * this field is maintained as a UX-only cache so editors can read the
-   * task.md and immediately see related sessions. Defaults to `[]` for
-   * backward compatibility.
-   */
-  linked_sessions: z5.array(SessionIdSchema).default([])
-});
-var TaskSchema = z5.object({
-  schema_version: SchemaVersionSchema,
-  task: TaskInnerSchema
-});
-
-// src/schemas/task-index.schema.ts
-import { z as z6 } from "zod";
-var TaskIndexEntrySchema = z6.object({
-  id: TaskIdSchema,
-  status: TaskStatusSchema,
-  label: z6.string().min(1).optional(),
-  updated_at: IsoTimestampSchema
-}).strict();
-var TaskIndexSchema = z6.object({
-  schema_version: SchemaVersionSchema,
-  tasks: z6.array(TaskIndexEntrySchema),
-  last_rebuilt_at: IsoTimestampSchema
-}).strict();
-var TASK_INDEX_SCHEMA_VERSION = "0.1.0";
-
-// src/schemas/approval.schema.ts
-import { z as z7 } from "zod";
-var ApprovalStatusSchema = z7.enum(["pending", "approved", "rejected", "expired"]);
-var ApprovalSchema = z7.object({
-  schema_version: SchemaVersionSchema,
-  id: ApprovalIdSchema,
-  session_id: SessionIdSchema,
-  created_at: IsoTimestampSchema,
-  status: ApprovalStatusSchema,
-  risk_level: RiskLevelSchema,
-  action: z7.object({ kind: z7.string() }).passthrough(),
-  reason: z7.string(),
-  expires_at: IsoTimestampSchema.nullable().default(null),
-  // The four fields below are null while `status === "pending"` and set
-  // once a resolver records a decision. Defaulting to null keeps the
-  // pending YAML free of explicit nulls if a producer omits them.
-  resolver: z7.string().nullable().default(null),
-  resolved_at: IsoTimestampSchema.nullable().default(null),
-  note: z7.string().nullable().default(null),
-  rejection_reason: z7.string().nullable().default(null)
-});
-
-// src/schemas/event.schema.ts
-import { z as z8 } from "zod";
-var BaseEventSchema = z8.object({
-  schema_version: SchemaVersionSchema,
-  id: EventIdSchema,
-  session_id: SessionIdSchema,
-  occurred_at: IsoTimestampSchema,
-  source: EventSourceSchema
-});
-var SessionStartedEventSchema = BaseEventSchema.extend({
-  type: z8.literal("session_started")
-});
-var SessionEndedEventSchema = BaseEventSchema.extend({
-  type: z8.literal("session_ended"),
-  exit_code: z8.number().int().optional()
-});
-var SessionStatusChangedEventSchema = BaseEventSchema.extend({
-  type: z8.literal("session_status_changed"),
-  from: z8.string(),
-  to: z8.string()
-});
-var ApprovalRequestedEventSchema = BaseEventSchema.extend({
-  type: z8.literal("approval_requested"),
-  approval_id: ApprovalIdSchema,
-  expires_at: IsoTimestampSchema.nullable().default(null),
-  risk_level: RiskLevelSchema,
-  // `action.kind` is required; additional fields are allowed to support
-  // future action shapes (shell_command, external_send, ...).
-  action: z8.object({ kind: z8.string() }).passthrough(),
-  reason: z8.string(),
-  status: z8.literal("pending")
-});
-var ApprovalApprovedEventSchema = BaseEventSchema.extend({
-  type: z8.literal("approval_approved"),
-  approval_id: ApprovalIdSchema,
-  resolver: z8.string().optional(),
-  note: z8.string().nullable().optional()
-});
-var ApprovalRejectedEventSchema = BaseEventSchema.extend({
-  type: z8.literal("approval_rejected"),
-  approval_id: ApprovalIdSchema,
-  resolver: z8.string().optional(),
-  reason: z8.string()
-});
-var ApprovalExpiredEventSchema = BaseEventSchema.extend({
-  type: z8.literal("approval_expired"),
-  approval_id: ApprovalIdSchema
-});
-var CommandExecutedEventSchema = BaseEventSchema.extend({
-  type: z8.literal("command_executed"),
-  command: z8.string(),
-  args: z8.array(z8.string()),
-  cwd: z8.string(),
-  exit_code: z8.number().int().nullable(),
-  signal: z8.string().nullable().optional(),
-  received_signal: z8.string().nullable().optional(),
-  duration_ms: z8.number().int().nonnegative()
-});
-var GitSnapshotEventSchema = BaseEventSchema.extend({
-  type: z8.literal("git_snapshot"),
-  head: z8.string(),
-  branch: z8.string(),
-  dirty: z8.boolean(),
-  staged: z8.array(z8.string()),
-  unstaged: z8.array(z8.string()),
-  untracked: z8.array(z8.string()),
-  ahead: z8.number().int().nonnegative().optional(),
-  behind: z8.number().int().nonnegative().optional()
-});
-var FileChangedEventSchema = BaseEventSchema.extend({
-  type: z8.literal("file_changed"),
-  path: z8.string(),
-  change_type: z8.enum(["added", "modified", "deleted", "renamed"]),
-  // Renamed entries record the previous path here. Optional + nullable to
-  // keep the wire format stable for added / modified / deleted events.
-  old_path: z8.string().nullable().optional()
-});
-var DecisionRecordedEventSchema = BaseEventSchema.extend({
-  type: z8.literal("decision_recorded"),
-  decision_id: DecisionIdSchema,
-  title: z8.string(),
-  rationale: z8.string().nullable().optional(),
-  alternatives: z8.array(z8.string().min(1)).optional(),
-  rejected_reason: z8.string().nullable().optional(),
-  linked_events: z8.array(EventIdSchema).optional(),
-  linked_files: z8.array(z8.string().min(1).max(4096)).optional()
-});
-var TaskCreatedEventSchema = BaseEventSchema.extend({
-  type: z8.literal("task_created"),
-  task_id: TaskIdSchema,
-  title: z8.string()
-});
-var TaskStatusChangedEventSchema = BaseEventSchema.extend({
-  type: z8.literal("task_status_changed"),
-  task_id: TaskIdSchema,
-  from: z8.string(),
-  to: z8.string()
-});
-var TaskReconciledEventSchema = BaseEventSchema.extend({
-  type: z8.literal("task_reconciled"),
-  task_id: TaskIdSchema,
-  removed_created_in_session: SessionIdSchema.nullable().default(null),
-  created_in_session_replacement: SessionIdSchema.nullable().default(null),
-  removed_linked_sessions: z8.array(SessionIdSchema).default([])
-}).strict();
-var TaskLinkageRefreshedEventSchema = BaseEventSchema.extend({
-  type: z8.literal("task_linkage_refreshed"),
-  task_id: TaskIdSchema,
-  added_linked_sessions: z8.array(SessionIdSchema).default([]),
-  removed_linked_sessions: z8.array(SessionIdSchema).default([]),
-  final_count: z8.number().int().nonnegative().optional()
-}).strict();
-var TaskDeletedEventSchema = BaseEventSchema.extend({
-  type: z8.literal("task_deleted"),
-  task_id: TaskIdSchema,
-  title: z8.string().min(1)
-}).strict();
-var TaskArchivedEventSchema = BaseEventSchema.extend({
-  type: z8.literal("task_archived"),
-  task_id: TaskIdSchema,
-  title: z8.string().min(1)
-}).strict();
-var NoteAddedEventSchema = BaseEventSchema.extend({
-  type: z8.literal("note_added"),
-  body: z8.string()
-});
-var AdapterOutputEventSchema = BaseEventSchema.extend({
-  type: z8.literal("adapter_output"),
-  stream: z8.enum(["stdout", "stderr"]),
-  summary: z8.string(),
-  raw_ref: z8.string(),
-  redacted: z8.boolean().optional()
-}).strict();
-var EventSchema = z8.discriminatedUnion("type", [
-  SessionStartedEventSchema,
-  SessionEndedEventSchema,
-  SessionStatusChangedEventSchema,
-  ApprovalRequestedEventSchema,
-  ApprovalApprovedEventSchema,
-  ApprovalRejectedEventSchema,
-  ApprovalExpiredEventSchema,
-  CommandExecutedEventSchema,
-  GitSnapshotEventSchema,
-  FileChangedEventSchema,
-  DecisionRecordedEventSchema,
-  TaskCreatedEventSchema,
-  TaskStatusChangedEventSchema,
-  TaskReconciledEventSchema,
-  TaskLinkageRefreshedEventSchema,
-  TaskDeletedEventSchema,
-  TaskArchivedEventSchema,
-  NoteAddedEventSchema,
-  AdapterOutputEventSchema
-]);
-
-// src/schemas/session-import.schema.ts
-import { z as z9 } from "zod";
-var SessionInnerImportSchema = z9.object({
-  id: SessionIdSchema.optional(),
-  label: z9.string().optional(),
-  task_id: TaskIdSchema.nullable().optional(),
-  workspace_id: WorkspaceIdSchema,
-  source: z9.object({
-    kind: SessionSourceKindSchema,
-    version: z9.literal("0.1.0")
-  }),
-  started_at: IsoTimestampSchema,
-  ended_at: IsoTimestampSchema.optional(),
-  status: SessionStatusSchema,
-  working_directory: z9.string().min(1),
-  invocation: z9.object({
-    command: z9.string().min(1),
-    args: z9.array(z9.string()),
-    exit_code: z9.number().int().nullable()
-  }),
-  related_files: z9.array(z9.string()).default([]),
-  events_log: z9.string().optional(),
-  summary: z9.string().nullable().optional()
-}).strict();
-var SessionImportPayloadSchema = z9.object({
-  schema_version: z9.string(),
-  session: SessionInnerImportSchema,
-  events: z9.array(EventSchema)
-}).strict();
-
-// src/approval/approval-store.ts
-import { readdir } from "fs/promises";
-import { join } from "path";
-
-// src/lib/error-codes.ts
-function findErrorCode(error, code, depth = 4) {
-  let cur = error;
-  for (let i = 0; i < depth && cur instanceof Error; i++) {
-    const c = cur.code;
-    if (typeof c === "string" && c === code) return true;
-    cur = cur.cause;
-  }
-  return false;
-}
-
-// src/storage/yaml-store.ts
-import { readFile } from "fs/promises";
-import { parse, stringify } from "yaml";
+// src/storage/yaml-store.ts
+import { readFile } from "fs/promises";
+import { parse, stringify } from "yaml";
 
 // src/storage/atomic.ts
 import { randomUUID } from "crypto";
@@ -553,338 +705,583 @@ function isLazyExpired(approval, now) {
   return expiresMs < now.getTime();
 }
 
-// src/storage/basou-dir.ts
-import { lstat, mkdir } from "fs/promises";
+// src/decisions/decisions-renderer.ts
+import { lstat } from "fs/promises";
+import { dirname, join as join4, resolve } from "path";
+
+// src/events/event-replay.ts
+import { createReadStream } from "fs";
+import { stat } from "fs/promises";
 import { join as join2 } from "path";
-function basouPaths(repositoryRoot) {
-  const root = join2(repositoryRoot, ".basou");
-  const approvalsBase = join2(root, "approvals");
-  return {
-    root,
-    sessions: join2(root, "sessions"),
-    tasks: join2(root, "tasks"),
-    approvals: {
-      pending: join2(approvalsBase, "pending"),
-      resolved: join2(approvalsBase, "resolved")
-    },
-    locks: join2(root, "locks"),
-    logs: join2(root, "logs"),
-    raw: join2(root, "raw"),
-    tmp: join2(root, "tmp"),
-    files: {
-      manifest: join2(root, "manifest.yaml"),
-      status: join2(root, "status.json"),
-      handoff: join2(root, "handoff.md"),
-      decisions: join2(root, "decisions.md")
-    }
-  };
-}
-var PATH_LABELS = {
-  sessions: ".basou/sessions",
-  tasks: ".basou/tasks",
-  approvalsPending: ".basou/approvals/pending",
-  approvalsResolved: ".basou/approvals/resolved",
-  locks: ".basou/locks",
-  logs: ".basou/logs",
-  raw: ".basou/raw",
-  tmp: ".basou/tmp"
-};
-async function ensureBasouDirectory(repositoryRoot) {
-  const paths = basouPaths(repositoryRoot);
-  let existing;
-  try {
-    existing = await lstat(paths.root);
-  } catch (error) {
-    if (!hasErrorCode2(error) || error.code !== "ENOENT") {
-      throw new Error("Failed to inspect .basou directory", { cause: error });
-    }
-  }
-  if (existing !== void 0 && !existing.isDirectory()) {
-    throw new Error("Basou root .basou exists but is not a directory");
-  }
-  await Promise.all([
-    mkdirLabeled(paths.sessions, PATH_LABELS.sessions),
-    mkdirLabeled(paths.tasks, PATH_LABELS.tasks),
-    mkdirLabeled(paths.approvals.pending, PATH_LABELS.approvalsPending),
-    mkdirLabeled(paths.approvals.resolved, PATH_LABELS.approvalsResolved),
-    mkdirLabeled(paths.locks, PATH_LABELS.locks),
-    mkdirLabeled(paths.logs, PATH_LABELS.logs),
-    mkdirLabeled(paths.raw, PATH_LABELS.raw),
-    mkdirLabeled(paths.tmp, PATH_LABELS.tmp)
-  ]);
-  return paths;
-}
-async function mkdirLabeled(target, label) {
-  try {
-    await mkdir(target, { recursive: true });
-  } catch (error) {
-    if (hasErrorCode2(error) && (error.code === "ENOTDIR" || error.code === "EEXIST")) {
-      throw new Error(`${label} exists but is not a directory`, { cause: error });
-    }
-    throw new Error(`Failed to create ${label}`, { cause: error });
-  }
-}
-function hasErrorCode2(error) {
-  if (!(error instanceof Error)) return false;
-  const codeProp = error.code;
-  return typeof codeProp === "string";
-}
 
-// src/storage/manifest.ts
-import { lstat as lstat2 } from "fs/promises";
-function createManifest(input) {
-  if (input.workspaceName.length === 0) {
-    throw new Error("Workspace name is empty. Pass --name explicitly.");
-  }
-  const now = (input.now ?? /* @__PURE__ */ new Date()).toISOString();
-  const workspaceId = input.workspaceId ?? prefixedUlid("ws");
-  const project = {
-    ...input.projectName !== void 0 ? { name: input.projectName } : {},
-    ...input.projectDescription !== void 0 ? { description: input.projectDescription } : {},
-    ...input.repositoryUrl !== void 0 ? { repository_url: input.repositoryUrl } : {}
-  };
-  const manifest = {
-    schema_version: "0.1.0",
-    basou_version: "0.1.0",
-    workspace: {
-      id: workspaceId,
-      name: input.workspaceName,
-      created_at: now,
-      updated_at: now
-    },
-    project,
-    capabilities: {
-      enabled: ["core", "claude-code-adapter", "terminal-recording", "git-capability", "approval"]
-    },
-    approval: {
-      required_for: ["destructive_command", "external_send"],
-      default_risk_level: "medium"
-    },
-    adapters: {
-      "claude-code": { enabled: true }
-    },
-    git: { events_log: "ignore" }
-  };
-  return ManifestSchema.parse(manifest);
-}
-async function writeManifest(paths, manifest, options) {
-  const force = options?.force === true;
-  const validated = ManifestSchema.parse(manifest);
-  if (!force) {
-    let existed = false;
-    try {
-      await lstat2(paths.files.manifest);
-      existed = true;
-    } catch (error) {
-      if (!hasErrorCode3(error) || error.code !== "ENOENT") {
-        throw new Error("Failed to inspect existing manifest", { cause: error });
+// src/schemas/event.schema.ts
+import { z as z3 } from "zod";
+var BaseEventSchema = z3.object({
+  schema_version: SchemaVersionSchema,
+  id: EventIdSchema,
+  session_id: SessionIdSchema,
+  occurred_at: IsoTimestampSchema,
+  source: EventSourceSchema
+});
+var SessionStartedEventSchema = BaseEventSchema.extend({
+  type: z3.literal("session_started")
+});
+var SessionEndedEventSchema = BaseEventSchema.extend({
+  type: z3.literal("session_ended"),
+  exit_code: z3.number().int().optional()
+});
+var SessionStatusChangedEventSchema = BaseEventSchema.extend({
+  type: z3.literal("session_status_changed"),
+  from: z3.string(),
+  to: z3.string()
+});
+var ApprovalRequestedEventSchema = BaseEventSchema.extend({
+  type: z3.literal("approval_requested"),
+  approval_id: ApprovalIdSchema,
+  expires_at: IsoTimestampSchema.nullable().default(null),
+  risk_level: RiskLevelSchema,
+  // `action.kind` is required; additional fields are allowed to support
+  // future action shapes (shell_command, external_send, ...).
+  action: z3.object({ kind: z3.string() }).passthrough(),
+  reason: z3.string(),
+  status: z3.literal("pending")
+});
+var ApprovalApprovedEventSchema = BaseEventSchema.extend({
+  type: z3.literal("approval_approved"),
+  approval_id: ApprovalIdSchema,
+  resolver: z3.string().optional(),
+  note: z3.string().nullable().optional()
+});
+var ApprovalRejectedEventSchema = BaseEventSchema.extend({
+  type: z3.literal("approval_rejected"),
+  approval_id: ApprovalIdSchema,
+  resolver: z3.string().optional(),
+  reason: z3.string()
+});
+var ApprovalExpiredEventSchema = BaseEventSchema.extend({
+  type: z3.literal("approval_expired"),
+  approval_id: ApprovalIdSchema
+});
+var CommandExecutedEventSchema = BaseEventSchema.extend({
+  type: z3.literal("command_executed"),
+  command: z3.string(),
+  args: z3.array(z3.string()),
+  cwd: z3.string(),
+  exit_code: z3.number().int().nullable(),
+  signal: z3.string().nullable().optional(),
+  received_signal: z3.string().nullable().optional(),
+  duration_ms: z3.number().int().nonnegative()
+});
+var GitSnapshotEventSchema = BaseEventSchema.extend({
+  type: z3.literal("git_snapshot"),
+  head: z3.string(),
+  branch: z3.string(),
+  dirty: z3.boolean(),
+  staged: z3.array(z3.string()),
+  unstaged: z3.array(z3.string()),
+  untracked: z3.array(z3.string()),
+  ahead: z3.number().int().nonnegative().optional(),
+  behind: z3.number().int().nonnegative().optional()
+});
+var FileChangedEventSchema = BaseEventSchema.extend({
+  type: z3.literal("file_changed"),
+  path: z3.string(),
+  change_type: z3.enum(["added", "modified", "deleted", "renamed"]),
+  // Renamed entries record the previous path here. Optional + nullable to
+  // keep the wire format stable for added / modified / deleted events.
+  old_path: z3.string().nullable().optional()
+});
+var DecisionRecordedEventSchema = BaseEventSchema.extend({
+  type: z3.literal("decision_recorded"),
+  decision_id: DecisionIdSchema,
+  title: z3.string(),
+  rationale: z3.string().nullable().optional(),
+  alternatives: z3.array(z3.string().min(1)).optional(),
+  rejected_reason: z3.string().nullable().optional(),
+  linked_events: z3.array(EventIdSchema).optional(),
+  linked_files: z3.array(z3.string().min(1).max(4096)).optional()
+});
+var TaskCreatedEventSchema = BaseEventSchema.extend({
+  type: z3.literal("task_created"),
+  task_id: TaskIdSchema,
+  title: z3.string()
+});
+var TaskStatusChangedEventSchema = BaseEventSchema.extend({
+  type: z3.literal("task_status_changed"),
+  task_id: TaskIdSchema,
+  from: z3.string(),
+  to: z3.string()
+});
+var TaskReconciledEventSchema = BaseEventSchema.extend({
+  type: z3.literal("task_reconciled"),
+  task_id: TaskIdSchema,
+  removed_created_in_session: SessionIdSchema.nullable().default(null),
+  created_in_session_replacement: SessionIdSchema.nullable().default(null),
+  removed_linked_sessions: z3.array(SessionIdSchema).default([])
+}).strict();
+var TaskLinkageRefreshedEventSchema = BaseEventSchema.extend({
+  type: z3.literal("task_linkage_refreshed"),
+  task_id: TaskIdSchema,
+  added_linked_sessions: z3.array(SessionIdSchema).default([]),
+  removed_linked_sessions: z3.array(SessionIdSchema).default([]),
+  final_count: z3.number().int().nonnegative().optional()
+}).strict();
+var TaskDeletedEventSchema = BaseEventSchema.extend({
+  type: z3.literal("task_deleted"),
+  task_id: TaskIdSchema,
+  title: z3.string().min(1)
+}).strict();
+var TaskArchivedEventSchema = BaseEventSchema.extend({
+  type: z3.literal("task_archived"),
+  task_id: TaskIdSchema,
+  title: z3.string().min(1)
+}).strict();
+var NoteAddedEventSchema = BaseEventSchema.extend({
+  type: z3.literal("note_added"),
+  body: z3.string()
+});
+var AdapterOutputEventSchema = BaseEventSchema.extend({
+  type: z3.literal("adapter_output"),
+  stream: z3.enum(["stdout", "stderr"]),
+  summary: z3.string(),
+  raw_ref: z3.string(),
+  redacted: z3.boolean().optional()
+}).strict();
+var EventSchema = z3.discriminatedUnion("type", [
+  SessionStartedEventSchema,
+  SessionEndedEventSchema,
+  SessionStatusChangedEventSchema,
+  ApprovalRequestedEventSchema,
+  ApprovalApprovedEventSchema,
+  ApprovalRejectedEventSchema,
+  ApprovalExpiredEventSchema,
+  CommandExecutedEventSchema,
+  GitSnapshotEventSchema,
+  FileChangedEventSchema,
+  DecisionRecordedEventSchema,
+  TaskCreatedEventSchema,
+  TaskStatusChangedEventSchema,
+  TaskReconciledEventSchema,
+  TaskLinkageRefreshedEventSchema,
+  TaskDeletedEventSchema,
+  TaskArchivedEventSchema,
+  NoteAddedEventSchema,
+  AdapterOutputEventSchema
+]);
+
+// src/events/event-replay.ts
+async function* replayEvents(sessionDir, options = {}) {
+  const filePath = join2(sessionDir, "events.jsonl");
+  try {
+    await stat(filePath);
+  } catch (error) {
+    if (findErrorCode(error, "ENOENT")) return;
+    throw new Error("Failed to read events.jsonl", { cause: error });
+  }
+  let stream;
+  try {
+    stream = createReadStream(filePath, { encoding: "utf8" });
+  } catch (error) {
+    throw new Error("Failed to read events.jsonl", { cause: error });
+  }
+  let buffer = "";
+  let lineNo = 0;
+  try {
+    for await (const chunk of stream) {
+      buffer += chunk;
+      let newlineIdx = buffer.indexOf("\n");
+      while (newlineIdx !== -1) {
+        lineNo += 1;
+        const rawLine = buffer.slice(0, newlineIdx);
+        buffer = buffer.slice(newlineIdx + 1);
+        const ev = processLine(rawLine, lineNo, options);
+        if (ev !== null) yield ev;
+        newlineIdx = buffer.indexOf("\n");
       }
     }
-    if (existed) {
-      throw new Error("Already initialized. Use --force to overwrite.");
-    }
+  } catch (error) {
+    throw new Error("Failed to read events.jsonl", { cause: error });
   }
-  await writeYamlFile(paths.files.manifest, validated);
+  const trimmed = buffer.replace(/[\r\n\t ]+$/u, "");
+  if (trimmed.length === 0) return;
+  lineNo += 1;
+  let parsed;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch (cause) {
+    options.onWarning?.({ kind: "malformed_json", line: lineNo, cause });
+    return;
+  }
+  const result = EventSchema.safeParse(parsed);
+  if (!result.success) {
+    options.onWarning?.({ kind: "schema_violation", line: lineNo, cause: result.error });
+    return;
+  }
+  options.onWarning?.({ kind: "partial_trailing_line", line: lineNo });
 }
-async function readManifest(paths) {
-  const raw = await readYamlFile(paths.files.manifest);
-  return ManifestSchema.parse(raw);
+function processLine(rawLine, lineNo, options) {
+  const trimmed = rawLine.trim();
+  if (trimmed.length === 0) return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch (cause) {
+    options.onWarning?.({ kind: "malformed_json", line: lineNo, cause });
+    return null;
+  }
+  const result = EventSchema.safeParse(parsed);
+  if (!result.success) {
+    options.onWarning?.({ kind: "schema_violation", line: lineNo, cause: result.error });
+    return null;
+  }
+  return result.data;
 }
-function hasErrorCode3(error) {
-  if (!(error instanceof Error)) return false;
-  return typeof error.code === "string";
+async function readAllEvents(sessionDir, options = {}) {
+  const out = [];
+  for await (const ev of replayEvents(sessionDir, options)) {
+    out.push(ev);
+  }
+  return out;
 }
 
-// src/storage/gitignore.ts
-import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+// src/storage/sessions.ts
+import { readdir as readdir2 } from "fs/promises";
 import { join as join3 } from "path";
-var MARKER = "# Basou - default ignore";
-var BASOU_GITIGNORE_BLOCK = "# Basou - default ignore\n.basou/logs/\n.basou/raw/\n.basou/tmp/\n.basou/locks/\n.basou/status.json\n.basou/sessions/*/events.jsonl\n.basou/sessions/*/artifacts/\n.basou/approvals/pending/\n.basou/approvals/resolved/\n\n# Basou - default commit\n# .basou/manifest.yaml\n# .basou/handoff.md\n# .basou/decisions.md\n# .basou/tasks/\n# .basou/sessions/*/session.yaml\n# .basou/sessions/*/transcript.md\n# .basou/sessions/*/changed-files.json\n";
-async function appendBasouGitignore(repositoryRoot) {
-  const gitignorePath = join3(repositoryRoot, ".gitignore");
-  let body;
-  let existed;
+
+// src/schemas/session.schema.ts
+import { z as z4 } from "zod";
+var SessionStatusSchema = z4.enum([
+  "initialized",
+  "running",
+  "waiting_approval",
+  "completed",
+  "failed",
+  "interrupted",
+  "imported",
+  "archived"
+]);
+var SessionSourceKindSchema = z4.enum([
+  "claude-code-adapter",
+  "claude-code-import",
+  "codex-import",
+  "human",
+  "import",
+  "terminal"
+]);
+var SessionSourceSchema = z4.object({
+  kind: SessionSourceKindSchema,
+  version: z4.literal("0.1.0"),
+  // Optional id of the originating session in the SOURCE tool's own
+  // namespace (e.g. the Claude Code session UUID for a `claude-code-import`).
+  // Lets re-imports of the same source be deduplicated; absent for live runs.
+  external_id: z4.string().optional()
+});
+var InvocationSchema = z4.object({
+  command: z4.string().min(1),
+  args: z4.array(z4.string()).default([]),
+  // Nullable to record signal-terminated runs where the child has no exit
+  // code; the same nullability is mirrored in CommandExecutedEventSchema.
+  exit_code: z4.number().int().nullable()
+});
+var SessionMetricsSchema = z4.object({
+  output_tokens: z4.number().int().nonnegative().optional(),
+  input_tokens: z4.number().int().nonnegative().optional(),
+  cached_input_tokens: z4.number().int().nonnegative().optional(),
+  reasoning_output_tokens: z4.number().int().nonnegative().optional(),
+  active_time_ms: z4.number().int().nonnegative().optional(),
+  active_intervals: z4.array(z4.object({ start: IsoTimestampSchema, end: IsoTimestampSchema })).optional(),
+  active_gap_cap_ms: z4.number().int().nonnegative().optional(),
+  active_time_method: z4.string().optional()
+});
+var SessionInnerSchema = z4.object({
+  id: SessionIdSchema,
+  label: z4.string().optional(),
+  task_id: TaskIdSchema.nullable().optional(),
+  workspace_id: WorkspaceIdSchema,
+  source: SessionSourceSchema,
+  started_at: IsoTimestampSchema,
+  // ended_at is optional because initialized / running sessions have no end time yet.
+  ended_at: IsoTimestampSchema.optional(),
+  status: SessionStatusSchema,
+  working_directory: z4.string().min(1),
+  invocation: InvocationSchema,
+  related_files: z4.array(z4.string()).default([]),
+  events_log: z4.string().default("events.jsonl"),
+  summary: z4.string().nullable().optional(),
+  metrics: SessionMetricsSchema.optional()
+});
+var SessionSchema = z4.object({
+  schema_version: SchemaVersionSchema,
+  session: SessionInnerSchema
+});
+
+// src/storage/sessions.ts
+var STUCK_THRESHOLD_MS = 24 * 60 * 60 * 1e3;
+async function enumerateSessionDirs(paths) {
   try {
-    body = await readFile2(gitignorePath, "utf8");
-    existed = true;
+    const dirents = await readdir2(paths.sessions, { withFileTypes: true });
+    return dirents.filter((d) => d.isDirectory()).map((d) => d.name).sort();
   } catch (error) {
-    if (hasErrorCode4(error) && error.code === "ENOENT") {
-      body = "";
-      existed = false;
-    } else {
-      throw new Error("Failed to read .gitignore", { cause: error });
-    }
-  }
-  if (existed && hasBasouMarker(body)) {
-    return { appended: false };
+    if (findErrorCode(error, "ENOENT")) return [];
+    throw new Error("Failed to enumerate sessions", { cause: error });
   }
-  const next = composeNextBody(body);
+}
+async function readSessionYaml(paths, sessionId) {
+  const filePath = join3(paths.sessions, sessionId, "session.yaml");
+  let raw;
   try {
-    await writeFile2(gitignorePath, next, { encoding: "utf8" });
+    raw = await readYamlFile(filePath);
   } catch (error) {
-    throw new Error("Failed to write .gitignore", { cause: error });
+    if (error instanceof Error && error.message === "YAML file not found") throw error;
+    throw new Error("Failed to read session.yaml", { cause: error });
   }
-  return { appended: true };
-}
-function hasBasouMarker(body) {
-  for (const rawLine of body.split("\n")) {
-    if (rawLine.trimEnd().startsWith(MARKER)) return true;
+  const result = SessionSchema.safeParse(raw);
+  if (!result.success) {
+    throw new Error("Failed to read session.yaml", { cause: result.error });
   }
-  return false;
+  return result.data;
 }
-function composeNextBody(existing) {
-  if (existing.length === 0) return BASOU_GITIGNORE_BLOCK;
-  const normalized = existing.endsWith("\n") ? existing : `${existing}
-`;
-  return `${normalized}
-${BASOU_GITIGNORE_BLOCK}`;
+async function classifySuspect(paths, sessionId, session, now, onWarning) {
+  if (session.session.status !== "running") {
+    return { suspect: false, suspectReason: null };
+  }
+  const sessionDir = join3(paths.sessions, sessionId);
+  let endedFound = false;
+  let lastEventOccurredAt = null;
+  const replayOpts = onWarning !== void 0 ? { onWarning } : {};
+  for await (const ev of replayEvents(sessionDir, replayOpts)) {
+    lastEventOccurredAt = ev.occurred_at;
+    if (ev.type === "session_ended") endedFound = true;
+  }
+  if (endedFound) {
+    return { suspect: true, suspectReason: "events_say_ended_but_yaml_running" };
+  }
+  if (lastEventOccurredAt !== null) {
+    const ageMs = now.getTime() - Date.parse(lastEventOccurredAt);
+    if (Number.isFinite(ageMs) && ageMs > STUCK_THRESHOLD_MS) {
+      return { suspect: true, suspectReason: "running_no_end_event" };
+    }
+  }
+  return { suspect: false, suspectReason: null };
 }
-function hasErrorCode4(error) {
-  if (!(error instanceof Error)) return false;
-  return typeof error.code === "string";
+async function loadSessionEntries(paths, options) {
+  const sessionIds = await enumerateSessionDirs(paths);
+  const entries = [];
+  for (const sid of sessionIds) {
+    let session;
+    try {
+      session = await readSessionYaml(paths, sid);
+    } catch (error) {
+      if (error instanceof Error && error.message === "YAML file not found") {
+        options.onSkip?.(sid, "session_yaml_missing");
+      } else {
+        options.onSkip?.(sid, "session_yaml_invalid");
+      }
+      continue;
+    }
+    let suspect = false;
+    let suspectReason = null;
+    try {
+      const r = await classifySuspect(
+        paths,
+        sid,
+        session,
+        options.now,
+        (w) => options.onWarning?.(w, sid)
+      );
+      suspect = r.suspect;
+      suspectReason = r.suspectReason;
+    } catch {
+      options.onSkip?.(sid, "events_jsonl_unreadable");
+    }
+    entries.push({ sessionId: sid, session, suspect, suspectReason });
+  }
+  return entries;
 }
 
-// src/storage/lockfile.ts
-import { readFile as readFile3, unlink as unlink2 } from "fs/promises";
-import { join as join4 } from "path";
-var STALE_LOCK_MAX_AGE_MS = 60 * 60 * 1e3;
-async function acquireLock(paths, scope, resourceId) {
-  const lockPath = lockfilePath(paths, scope, resourceId);
-  const body = {
-    pid: process.pid,
-    acquired_at: (/* @__PURE__ */ new Date()).toISOString()
+// src/decisions/decisions-renderer.ts
+async function renderDecisions(input) {
+  const now = new Date(input.nowIso);
+  const unreadableEmitted = /* @__PURE__ */ new Set();
+  const wrappedSkip = (sid, reason) => {
+    if (reason === "events_jsonl_unreadable") unreadableEmitted.add(sid);
+    input.onSessionSkip?.(sid, reason);
   };
-  const serialised = JSON.stringify(body);
-  try {
-    await atomicCreate(lockPath, serialised);
-  } catch (error) {
-    if (!findErrorCode(error, "EEXIST")) {
-      throw error;
-    }
-    const stale = await isStaleLock(lockPath);
-    if (!stale) {
-      throw new Error("Lock is held by another process", { cause: error });
+  const loadOpts = { now, onSkip: wrappedSkip };
+  if (input.onWarning !== void 0) loadOpts.onWarning = input.onWarning;
+  const entries = await loadSessionEntries(input.paths, loadOpts);
+  const decisions = [];
+  const knownEventIds = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    const sessionDir = join4(input.paths.sessions, entry.sessionId);
+    try {
+      for await (const ev of replayEvents(sessionDir, {
+        onWarning: (w) => input.onWarning?.(w, entry.sessionId)
+      })) {
+        knownEventIds.add(ev.id);
+        if (ev.type === "decision_recorded") {
+          decisions.push({
+            decisionId: ev.decision_id,
+            title: ev.title,
+            occurredAt: ev.occurred_at,
+            sessionId: entry.sessionId,
+            rationale: ev.rationale,
+            alternatives: ev.alternatives,
+            rejectedReason: ev.rejected_reason,
+            linkedEvents: ev.linked_events,
+            linkedFiles: ev.linked_files
+          });
+        }
+      }
+    } catch {
+      if (!unreadableEmitted.has(entry.sessionId)) {
+        wrappedSkip(entry.sessionId, "events_jsonl_unreadable");
+      }
     }
-    await unlink2(lockPath).catch(() => void 0);
+  }
+  decisions.sort((a, b) => {
+    const c = Date.parse(a.occurredAt) - Date.parse(b.occurredAt);
+    return c !== 0 ? c : a.decisionId.localeCompare(b.decisionId);
+  });
+  const repoRoot = dirname(input.paths.root);
+  const fileExistenceCache = /* @__PURE__ */ new Map();
+  async function fileExists(relPath) {
+    const cached = fileExistenceCache.get(relPath);
+    if (cached !== void 0) return cached;
+    const abs = resolve(repoRoot, relPath);
+    let exists;
     try {
-      await atomicCreate(lockPath, serialised);
-    } catch (retryError) {
-      throw new Error("Lock is held by another process", { cause: retryError });
+      await lstat(abs);
+      exists = true;
+    } catch {
+      exists = false;
     }
+    fileExistenceCache.set(relPath, exists);
+    return exists;
   }
-  return {
-    release: async () => {
-      await unlink2(lockPath).catch(() => void 0);
+  const body = await formatDecisionsBody({
+    nowIso: input.nowIso,
+    decisions,
+    knownEventIds,
+    fileExists
+  });
+  return { body, decisionCount: decisions.length };
+}
+async function formatDecisionsBody(args) {
+  const lines = [];
+  lines.push("# Decisions");
+  lines.push("");
+  lines.push(`> Generated at ${args.nowIso}`);
+  lines.push("");
+  if (args.decisions.length === 0) {
+    lines.push("(no decisions recorded yet)");
+    return lines.join("\n");
+  }
+  for (const d of args.decisions) {
+    lines.push(`## ${d.decisionId}: ${d.title}`);
+    lines.push("");
+    const occurredDate = d.occurredAt.slice(0, 10);
+    lines.push(`- \u6C7A\u5B9A\u65E5: ${occurredDate}`);
+    lines.push(`- session: ${shortDecisionSessionId(d.sessionId)}`);
+    lines.push(`- \u5224\u65AD: ${d.title}`);
+    if (typeof d.rationale === "string" && d.rationale.length > 0) {
+      lines.push(`- rationale: ${d.rationale}`);
+    }
+    if (d.alternatives !== void 0 && d.alternatives.length > 0) {
+      lines.push(`- alternatives: ${d.alternatives.join(", ")}`);
+    }
+    if (typeof d.rejectedReason === "string" && d.rejectedReason.length > 0) {
+      lines.push(`- rejected_reason: ${d.rejectedReason}`);
     }
-  };
-}
-async function isStaleLock(lockPath) {
-  let body;
-  try {
-    const raw = await readFile3(lockPath, "utf8");
-    const parsed = JSON.parse(raw);
-    if (typeof parsed !== "object" || parsed === null) return true;
-    const candidate = parsed;
-    if (typeof candidate.pid !== "number" || typeof candidate.acquired_at !== "string") {
-      return true;
+    if (d.linkedEvents !== void 0 && d.linkedEvents.length > 0) {
+      const parts = d.linkedEvents.map(
+        (eid) => args.knownEventIds.has(eid) ? eid : `${eid} (missing)`
+      );
+      lines.push(`- linked_events: ${parts.join(", ")}`);
     }
-    body = { pid: candidate.pid, acquired_at: candidate.acquired_at };
-  } catch {
-    return true;
-  }
-  const ageMs = Date.now() - Date.parse(body.acquired_at);
-  if (!Number.isFinite(ageMs) || ageMs > STALE_LOCK_MAX_AGE_MS) {
-    return true;
-  }
-  try {
-    process.kill(body.pid, 0);
-    return false;
-  } catch (error) {
-    if (findErrorCode(error, "ESRCH")) return true;
-    return false;
+    if (d.linkedFiles !== void 0 && d.linkedFiles.length > 0) {
+      const parts = await Promise.all(
+        d.linkedFiles.map(
+          async (path2) => await args.fileExists(path2) ? path2 : `${path2} (missing)`
+        )
+      );
+      lines.push(`- linked_files: ${parts.join(", ")}`);
+    }
+    lines.push("");
   }
+  return lines.join("\n");
 }
-function lockfilePath(paths, scope, resourceId) {
-  const sep = resourceId.indexOf("_");
-  const ulid2 = sep >= 0 ? resourceId.slice(sep + 1) : resourceId;
-  return join4(paths.locks, `${scope}_${ulid2}.lock`);
+function shortDecisionSessionId(sessionId) {
+  const SES = "ses_";
+  if (sessionId.startsWith(SES)) return sessionId.slice(SES.length, SES.length + 10);
+  return sessionId.slice(0, 10);
 }
 
-// src/storage/task-index.ts
-import { readFile as readFile4 } from "fs/promises";
+// src/events/event-writer.ts
+import { appendFile } from "fs/promises";
 import { join as join5 } from "path";
-function taskIndexPath(paths) {
-  return join5(paths.tasks, "index.json");
-}
-async function readTaskIndex(paths) {
-  const filePath = taskIndexPath(paths);
-  let raw;
+async function appendEvent(sessionDir, event) {
+  let validated;
   try {
-    raw = await readFile4(filePath, "utf8");
+    validated = EventSchema.parse(event);
   } catch (error) {
-    if (findErrorCode(error, "ENOENT")) {
-      throw new Error("Task index not found", { cause: error });
-    }
-    throw new Error("Failed to read task index", { cause: error });
+    throw new Error("Invalid Basou event payload", { cause: error });
   }
-  let parsedJson;
+  const line = `${JSON.stringify(validated)}
+`;
   try {
-    parsedJson = JSON.parse(raw);
+    await appendFile(join5(sessionDir, "events.jsonl"), line, "utf8");
   } catch (error) {
-    throw new Error("Invalid task index", { cause: error });
-  }
-  const result = TaskIndexSchema.safeParse(parsedJson);
-  if (!result.success) {
-    throw new Error("Invalid task index", { cause: result.error });
-  }
-  if (result.data.schema_version !== TASK_INDEX_SCHEMA_VERSION) {
-    throw new Error("Invalid task index", {
-      cause: new Error(`Unsupported task index schema_version: ${result.data.schema_version}`)
-    });
+    throw new Error("Failed to append event to events.jsonl", { cause: error });
   }
-  return result.data;
-}
-async function rebuildTaskIndex(paths, entries, now) {
-  const sorted = [...entries].sort((a, b) => a.id.localeCompare(b.id));
-  const payload = {
-    schema_version: TASK_INDEX_SCHEMA_VERSION,
-    tasks: sorted,
-    last_rebuilt_at: (now ?? (() => /* @__PURE__ */ new Date()))().toISOString()
-  };
-  TaskIndexSchema.parse(payload);
-  await atomicReplace(taskIndexPath(paths), `${JSON.stringify(payload, null, 2)}
-`);
-  return payload;
 }
-async function updateTaskIndex(paths, op, options) {
-  const nowFn = options?.now ?? (() => /* @__PURE__ */ new Date());
-  let current;
+async function writeEventsBulk(sessionDir, events) {
+  const validated = [];
   try {
-    current = await readTaskIndex(paths);
-  } catch {
-    current = {
-      schema_version: TASK_INDEX_SCHEMA_VERSION,
-      tasks: [],
-      last_rebuilt_at: nowFn().toISOString()
-    };
+    for (const event of events) {
+      validated.push(EventSchema.parse(event));
+    }
+  } catch (error) {
+    throw new Error("Invalid Basou event payload", { cause: error });
   }
-  let nextTasks;
-  switch (op.kind) {
-    case "add":
-      nextTasks = current.tasks.some((t) => t.id === op.entry.id) ? current.tasks.map((t) => t.id === op.entry.id ? op.entry : t) : [...current.tasks, op.entry];
-      break;
-    case "update":
-      nextTasks = current.tasks.some((t) => t.id === op.entry.id) ? current.tasks.map((t) => t.id === op.entry.id ? op.entry : t) : [...current.tasks, op.entry];
-      break;
-    case "remove":
-      nextTasks = current.tasks.filter((t) => t.id !== op.id);
-      break;
+  const filePath = join5(sessionDir, "events.jsonl");
+  const body = validated.length > 0 ? `${validated.map((e) => JSON.stringify(e)).join("\n")}
+` : "";
+  try {
+    await atomicReplace(filePath, body);
+  } catch (error) {
+    throw new Error("Failed to write events.jsonl", { cause: error });
   }
-  return await rebuildTaskIndex(paths, nextTasks, nowFn);
 }
 
+// src/git/snapshot.ts
+import { simpleGit } from "simple-git";
+
 // src/storage/status.ts
 import * as fsp from "fs/promises";
+
+// src/schemas/status.schema.ts
+import { z as z5 } from "zod";
+var StatusSchema = z5.object({
+  schema_version: SchemaVersionSchema,
+  generated_at: IsoTimestampSchema,
+  workspace: z5.object({
+    id: WorkspaceIdSchema,
+    name: z5.string().min(1),
+    basou_version: z5.literal("0.1.0")
+  }).strict(),
+  directories_present: z5.object({
+    sessions: z5.boolean(),
+    tasks: z5.boolean(),
+    approvals_pending: z5.boolean(),
+    approvals_resolved: z5.boolean(),
+    logs: z5.boolean(),
+    raw: z5.boolean(),
+    tmp: z5.boolean()
+  }).strict()
+}).strict();
+
+// src/storage/status.ts
 var DIRECTORY_CHECKS = {
   sessions: (p) => p.sessions,
   tasks: (p) => p.tasks,
@@ -899,7 +1296,7 @@ async function assertBasouRootSafe(rootPath) {
   try {
     stat3 = await fsp.lstat(rootPath);
   } catch (error) {
-    if (hasErrorCode5(error) && error.code === "ENOENT") {
+    if (hasErrorCode2(error) && error.code === "ENOENT") {
       throw new Error("Basou workspace not found", { cause: error });
     }
     throw new Error("Failed to inspect .basou root", { cause: error });
@@ -915,7 +1312,7 @@ async function dirPresent(path2) {
   try {
     return (await fsp.lstat(path2)).isDirectory();
   } catch (error) {
-    if (hasErrorCode5(error) && (error.code === "ENOENT" || error.code === "ENOTDIR")) {
+    if (hasErrorCode2(error) && (error.code === "ENOENT" || error.code === "ENOTDIR")) {
       return false;
     }
     throw new Error("Failed to inspect .basou subdirectory", { cause: error });
@@ -939,352 +1336,269 @@ async function buildStatusSnapshot(input) {
     },
     directories_present: directoriesEntries
   };
-  return StatusSchema.parse(snapshot);
-}
-async function writeStatus(paths, snapshot) {
-  const validated = StatusSchema.parse(snapshot);
-  const body = `${JSON.stringify(validated, null, 2)}
-`;
-  try {
-    await atomicReplace(paths.files.status, body);
-  } catch (error) {
-    throw new Error("Failed to write status file", { cause: error });
-  }
-}
-async function readStatus(paths) {
-  let body;
-  try {
-    body = await fsp.readFile(paths.files.status, "utf8");
-  } catch (error) {
-    if (hasErrorCode5(error) && error.code === "ENOENT") {
-      throw new Error("Status file not found", { cause: error });
-    }
-    throw new Error("Failed to read status file", { cause: error });
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(body);
-  } catch (error) {
-    throw new Error("Failed to parse status JSON", { cause: error });
-  }
-  return StatusSchema.parse(parsed);
-}
-function hasErrorCode5(error) {
-  if (!(error instanceof Error)) return false;
-  return typeof error.code === "string";
-}
-
-// src/storage/sessions.ts
-import { readdir as readdir2 } from "fs/promises";
-import { join as join7 } from "path";
-
-// src/events/event-replay.ts
-import { createReadStream } from "fs";
-import { stat } from "fs/promises";
-import { join as join6 } from "path";
-async function* replayEvents(sessionDir, options = {}) {
-  const filePath = join6(sessionDir, "events.jsonl");
-  try {
-    await stat(filePath);
-  } catch (error) {
-    if (findErrorCode(error, "ENOENT")) return;
-    throw new Error("Failed to read events.jsonl", { cause: error });
-  }
-  let stream;
-  try {
-    stream = createReadStream(filePath, { encoding: "utf8" });
-  } catch (error) {
-    throw new Error("Failed to read events.jsonl", { cause: error });
-  }
-  let buffer = "";
-  let lineNo = 0;
-  try {
-    for await (const chunk of stream) {
-      buffer += chunk;
-      let newlineIdx = buffer.indexOf("\n");
-      while (newlineIdx !== -1) {
-        lineNo += 1;
-        const rawLine = buffer.slice(0, newlineIdx);
-        buffer = buffer.slice(newlineIdx + 1);
-        const ev = processLine(rawLine, lineNo, options);
-        if (ev !== null) yield ev;
-        newlineIdx = buffer.indexOf("\n");
-      }
-    }
-  } catch (error) {
-    throw new Error("Failed to read events.jsonl", { cause: error });
-  }
-  const trimmed = buffer.replace(/[\r\n\t ]+$/u, "");
-  if (trimmed.length === 0) return;
-  lineNo += 1;
-  let parsed;
-  try {
-    parsed = JSON.parse(trimmed);
-  } catch (cause) {
-    options.onWarning?.({ kind: "malformed_json", line: lineNo, cause });
-    return;
-  }
-  const result = EventSchema.safeParse(parsed);
-  if (!result.success) {
-    options.onWarning?.({ kind: "schema_violation", line: lineNo, cause: result.error });
-    return;
-  }
-  options.onWarning?.({ kind: "partial_trailing_line", line: lineNo });
-}
-function processLine(rawLine, lineNo, options) {
-  const trimmed = rawLine.trim();
-  if (trimmed.length === 0) return null;
-  let parsed;
-  try {
-    parsed = JSON.parse(trimmed);
-  } catch (cause) {
-    options.onWarning?.({ kind: "malformed_json", line: lineNo, cause });
-    return null;
-  }
-  const result = EventSchema.safeParse(parsed);
-  if (!result.success) {
-    options.onWarning?.({ kind: "schema_violation", line: lineNo, cause: result.error });
-    return null;
-  }
-  return result.data;
-}
-async function readAllEvents(sessionDir, options = {}) {
-  const out = [];
-  for await (const ev of replayEvents(sessionDir, options)) {
-    out.push(ev);
-  }
-  return out;
+  return StatusSchema.parse(snapshot);
 }
-
-// src/storage/sessions.ts
-var STUCK_THRESHOLD_MS = 24 * 60 * 60 * 1e3;
-async function enumerateSessionDirs(paths) {
+async function writeStatus(paths, snapshot) {
+  const validated = StatusSchema.parse(snapshot);
+  const body = `${JSON.stringify(validated, null, 2)}
+`;
   try {
-    const dirents = await readdir2(paths.sessions, { withFileTypes: true });
-    return dirents.filter((d) => d.isDirectory()).map((d) => d.name).sort();
+    await atomicReplace(paths.files.status, body);
   } catch (error) {
-    if (findErrorCode(error, "ENOENT")) return [];
-    throw new Error("Failed to enumerate sessions", { cause: error });
+    throw new Error("Failed to write status file", { cause: error });
   }
 }
-async function readSessionYaml(paths, sessionId) {
-  const filePath = join7(paths.sessions, sessionId, "session.yaml");
-  let raw;
+async function readStatus(paths) {
+  let body;
   try {
-    raw = await readYamlFile(filePath);
+    body = await fsp.readFile(paths.files.status, "utf8");
   } catch (error) {
-    if (error instanceof Error && error.message === "YAML file not found") throw error;
-    throw new Error("Failed to read session.yaml", { cause: error });
+    if (hasErrorCode2(error) && error.code === "ENOENT") {
+      throw new Error("Status file not found", { cause: error });
+    }
+    throw new Error("Failed to read status file", { cause: error });
   }
-  const result = SessionSchema.safeParse(raw);
-  if (!result.success) {
-    throw new Error("Failed to read session.yaml", { cause: result.error });
+  let parsed;
+  try {
+    parsed = JSON.parse(body);
+  } catch (error) {
+    throw new Error("Failed to parse status JSON", { cause: error });
   }
-  return result.data;
+  return StatusSchema.parse(parsed);
 }
-async function classifySuspect(paths, sessionId, session, now, onWarning) {
-  if (session.session.status !== "running") {
-    return { suspect: false, suspectReason: null };
-  }
-  const sessionDir = join7(paths.sessions, sessionId);
-  let endedFound = false;
-  let lastEventOccurredAt = null;
-  const replayOpts = onWarning !== void 0 ? { onWarning } : {};
-  for await (const ev of replayEvents(sessionDir, replayOpts)) {
-    lastEventOccurredAt = ev.occurred_at;
-    if (ev.type === "session_ended") endedFound = true;
-  }
-  if (endedFound) {
-    return { suspect: true, suspectReason: "events_say_ended_but_yaml_running" };
-  }
-  if (lastEventOccurredAt !== null) {
-    const ageMs = now.getTime() - Date.parse(lastEventOccurredAt);
-    if (Number.isFinite(ageMs) && ageMs > STUCK_THRESHOLD_MS) {
-      return { suspect: true, suspectReason: "running_no_end_event" };
-    }
+function hasErrorCode2(error) {
+  if (!(error instanceof Error)) return false;
+  return typeof error.code === "string";
+}
+
+// src/git/snapshot.ts
+function safeSimpleGit(repoRoot) {
+  return simpleGit({ baseDir: repoRoot });
+}
+function isGitNotFound(error) {
+  if (findErrorCode(error, "ENOENT")) return true;
+  let cur = error;
+  for (let i = 0; i < 4 && cur instanceof Error; i++) {
+    if (/\bENOENT\b/.test(cur.message)) return true;
+    cur = cur.cause;
   }
-  return { suspect: false, suspectReason: null };
+  return false;
 }
-async function loadSessionEntries(paths, options) {
-  const sessionIds = await enumerateSessionDirs(paths);
-  const entries = [];
-  for (const sid of sessionIds) {
-    let session;
-    try {
-      session = await readSessionYaml(paths, sid);
-    } catch (error) {
-      if (error instanceof Error && error.message === "YAML file not found") {
-        options.onSkip?.(sid, "session_yaml_missing");
-      } else {
-        options.onSkip?.(sid, "session_yaml_invalid");
-      }
-      continue;
+async function resolveRepositoryRoot(cwd) {
+  const git = safeSimpleGit(cwd);
+  try {
+    const root = (await git.revparse(["--show-toplevel"])).trimEnd();
+    if (root.length === 0) {
+      throw new Error("Not a git repository");
     }
-    let suspect = false;
-    let suspectReason = null;
-    try {
-      const r = await classifySuspect(
-        paths,
-        sid,
-        session,
-        options.now,
-        (w) => options.onWarning?.(w, sid)
-      );
-      suspect = r.suspect;
-      suspectReason = r.suspectReason;
-    } catch {
-      options.onSkip?.(sid, "events_jsonl_unreadable");
+    return root;
+  } catch (error) {
+    if (isGitNotFound(error)) {
+      throw new Error("Git executable not found in PATH. Install git first.", { cause: error });
     }
-    entries.push({ sessionId: sid, session, suspect, suspectReason });
+    if (error instanceof Error && error.message === "Not a git repository") {
+      throw error;
+    }
+    throw new Error("Not a git repository", { cause: error });
   }
-  return entries;
 }
-
-// src/storage/markdown-store.ts
-import { readFile as readFile6 } from "fs/promises";
-var GENERATED_START = "<!-- BASOU:GENERATED:START -->";
-var GENERATED_END = "<!-- BASOU:GENERATED:END -->";
-async function readMarkdownFile(filePath) {
+async function tryRemoteUrl(repositoryRoot) {
+  const git = safeSimpleGit(repositoryRoot);
   try {
-    return await readFile6(filePath, "utf8");
-  } catch (error) {
-    if (hasErrorCode6(error) && error.code === "ENOENT") return null;
-    throw new Error("Failed to read markdown file", { cause: error });
+    const result = await git.getConfig("remote.origin.url", "local");
+    const url = (result.value ?? "").trimEnd();
+    return url.length > 0 ? url : void 0;
+  } catch {
+    return void 0;
   }
 }
-async function writeMarkdownFile(filePath, body) {
+async function getSnapshot(repositoryRoot) {
+  const git = safeSimpleGit(repositoryRoot);
+  let inside;
   try {
-    await atomicReplace(filePath, body);
+    inside = await git.checkIsRepo();
   } catch (error) {
-    throw new Error("Failed to write markdown file", { cause: error });
+    if (isGitNotFound(error)) {
+      throw new Error("Git executable not found in PATH. Install git first.", { cause: error });
+    }
+    throw new Error("Failed to read git state", { cause: error });
   }
-}
-function parseMarkers(content) {
-  const lines = content.split(/\r?\n/);
-  const startLines = [];
-  const endLines = [];
-  for (let i = 0; i < lines.length; i++) {
-    if (lines[i] === GENERATED_START) startLines.push(i);
-    else if (lines[i] === GENERATED_END) endLines.push(i);
+  if (!inside) {
+    throw new Error("Not a git repository");
   }
-  if (startLines.length === 0 && endLines.length === 0) return { kind: "no_markers" };
-  if (startLines.length === 0) return { kind: "missing_start" };
-  if (endLines.length === 0) return { kind: "missing_end" };
-  if (startLines.length >= 2 || endLines.length >= 2) return { kind: "multiple_pairs" };
-  const startLineIdx = startLines[0];
-  const endLineIdx = endLines[0];
-  if (endLineIdx < startLineIdx) return { kind: "wrong_order" };
-  const startOffset = lineStartOffset(content, startLineIdx);
-  const endLineStart = lineStartOffset(content, endLineIdx);
-  const startLineEnd = startOffset + GENERATED_START.length;
-  const endLineEnd = endLineStart + GENERATED_END.length;
-  const before = content.slice(0, startOffset);
-  const afterStartNewline = skipOneNewline(content, startLineEnd);
-  const beforeEndNewline = trimOneNewline(content, endLineStart);
-  const generated = content.slice(afterStartNewline, beforeEndNewline);
-  const after = content.slice(endLineEnd);
-  return { kind: "ok", before, generated, after };
-}
-function renderWithMarkers(existing, generated, fileLabel) {
-  const normalized = generated.endsWith("\n") ? generated : `${generated}
-`;
-  if (existing === null) {
-    return `${GENERATED_START}
-${normalized}${GENERATED_END}
-`;
+  let head;
+  try {
+    head = (await git.revparse(["HEAD"])).trimEnd();
+  } catch (error) {
+    if (isGitNotFound(error)) {
+      throw new Error("Git executable not found in PATH. Install git first.", { cause: error });
+    }
+    throw new Error("No commits in repository", { cause: error });
   }
-  const section = parseMarkers(existing);
-  switch (section.kind) {
-    case "ok":
-      return `${section.before}${GENERATED_START}
-${normalized}${GENERATED_END}${section.after}`;
-    case "no_markers":
-      throw new Error(`Markers missing in ${fileLabel}`);
-    case "missing_start":
-    case "missing_end":
-    case "multiple_pairs":
-    case "wrong_order":
-      throw new Error(`Markers mismatched in ${fileLabel}`);
+  if (head.length === 0) {
+    throw new Error("No commits in repository");
   }
-}
-function lineStartOffset(content, lineIdx) {
-  if (lineIdx === 0) return 0;
-  let offset = 0;
-  let line = 0;
-  while (offset < content.length && line < lineIdx) {
-    const ch = content[offset];
-    if (ch === "\n") {
-      line += 1;
-      offset += 1;
-    } else if (ch === "\r") {
-      offset += 1;
-      if (content[offset] === "\n") offset += 1;
-      line += 1;
-    } else {
-      offset += 1;
-    }
+  let branch;
+  try {
+    const raw = (await git.raw(["branch", "--show-current"])).trimEnd();
+    branch = raw.length > 0 ? raw : "HEAD";
+  } catch (error) {
+    throw new Error("Failed to read git state", { cause: error });
   }
-  return offset;
-}
-function skipOneNewline(content, offset) {
-  if (content[offset] === "\r" && content[offset + 1] === "\n") return offset + 2;
-  if (content[offset] === "\n") return offset + 1;
-  return offset;
-}
-function trimOneNewline(content, offset) {
-  if (offset >= 2 && content[offset - 2] === "\r" && content[offset - 1] === "\n")
-    return offset - 2;
-  if (offset >= 1 && content[offset - 1] === "\n") return offset - 1;
-  return offset;
-}
-function hasErrorCode6(error) {
-  if (!(error instanceof Error)) return false;
-  const codeProp = error.code;
-  return typeof codeProp === "string";
+  let dirty;
+  const staged = [];
+  const unstaged = [];
+  const untracked = [];
+  try {
+    const status = await git.status();
+    dirty = !status.isClean();
+    for (const f of status.files) {
+      if (f.index === "?" && f.working_dir === "?") {
+        untracked.push(f.path);
+        continue;
+      }
+      if (f.index !== " " && f.index !== "?") staged.push(f.path);
+      if (f.working_dir !== " " && f.working_dir !== "?") unstaged.push(f.path);
+    }
+  } catch (error) {
+    throw new Error("Failed to read git state", { cause: error });
+  }
+  let ahead;
+  let behind;
+  if (branch !== "HEAD") {
+    try {
+      const upstream = `${branch}@{upstream}`;
+      const counts = (await git.raw(["rev-list", "--left-right", "--count", `${upstream}...HEAD`])).trim();
+      const [behindStr, aheadStr] = counts.split(/\s+/);
+      const parsedBehind = Number.parseInt(behindStr ?? "", 10);
+      const parsedAhead = Number.parseInt(aheadStr ?? "", 10);
+      if (Number.isFinite(parsedBehind) && parsedBehind >= 0) behind = parsedBehind;
+      if (Number.isFinite(parsedAhead) && parsedAhead >= 0) ahead = parsedAhead;
+    } catch {
+    }
+  }
+  const snapshot = {
+    head,
+    branch,
+    dirty,
+    staged,
+    unstaged,
+    untracked,
+    ...ahead !== void 0 ? { ahead } : {},
+    ...behind !== void 0 ? { behind } : {}
+  };
+  return snapshot;
 }
 
-// src/storage/session-import.ts
-import { mkdir as mkdir4, rm as rm2 } from "fs/promises";
-import { homedir as homedir2 } from "os";
-import { join as join11 } from "path";
-
-// src/events/event-writer.ts
-import { appendFile } from "fs/promises";
-import { join as join8 } from "path";
-async function appendEvent(sessionDir, event) {
-  let validated;
+// src/git/diff.ts
+async function getDiff(repoRoot, baseRef, headRef) {
+  let git;
   try {
-    validated = EventSchema.parse(event);
+    git = safeSimpleGit(repoRoot);
   } catch (error) {
-    throw new Error("Invalid Basou event payload", { cause: error });
+    if (isGitNotFound(error)) {
+      throw new Error("Git executable not found in PATH. Install git first.", { cause: error });
+    }
+    throw new Error("Not a git repository", { cause: error });
   }
-  const line = `${JSON.stringify(validated)}
-`;
+  if (baseRef === headRef) return { changed_files: [] };
+  let raw;
   try {
-    await appendFile(join8(sessionDir, "events.jsonl"), line, "utf8");
+    raw = await git.raw(["diff", "--name-status", `${baseRef}..${headRef}`]);
   } catch (error) {
-    throw new Error("Failed to append event to events.jsonl", { cause: error });
+    if (isGitNotFound(error)) {
+      throw new Error("Git executable not found in PATH. Install git first.", { cause: error });
+    }
+    const message = error instanceof Error ? error.message : "";
+    if (/not a git repository/i.test(message)) {
+      throw new Error("Not a git repository", { cause: error });
+    }
+    if (message.includes("bad revision") || message.includes("unknown revision") || message.includes("ambiguous argument")) {
+      throw new Error("Invalid ref", { cause: error });
+    }
+    throw new Error("Failed to compute git diff", { cause: error });
   }
+  return { changed_files: parseDiffNameStatus(raw) };
 }
-async function writeEventsBulk(sessionDir, events) {
-  const validated = [];
-  try {
-    for (const event of events) {
-      validated.push(EventSchema.parse(event));
+function parseDiffNameStatus(raw) {
+  const lines = raw.split("\n").filter((l) => l.trim() !== "");
+  const changes = [];
+  for (const line of lines) {
+    const parts = line.split("	");
+    const code = parts[0];
+    if (code === void 0 || code.length === 0) continue;
+    if (code.startsWith("R") && parts.length >= 3) {
+      const newPath = parts[2];
+      const oldPath = parts[1];
+      if (newPath === void 0) continue;
+      changes.push({
+        path: newPath,
+        status: "renamed",
+        ...oldPath !== void 0 ? { old_path: oldPath } : {}
+      });
+    } else if (code === "A" && parts[1]) {
+      changes.push({ path: parts[1], status: "added" });
+    } else if (code === "M" && parts[1]) {
+      changes.push({ path: parts[1], status: "modified" });
+    } else if (code === "D" && parts[1]) {
+      changes.push({ path: parts[1], status: "deleted" });
     }
-  } catch (error) {
-    throw new Error("Invalid Basou event payload", { cause: error });
-  }
-  const filePath = join8(sessionDir, "events.jsonl");
-  const body = validated.length > 0 ? `${validated.map((e) => JSON.stringify(e)).join("\n")}
-` : "";
-  try {
-    await atomicReplace(filePath, body);
-  } catch (error) {
-    throw new Error("Failed to write events.jsonl", { cause: error });
   }
+  return changes;
 }
 
+// src/handoff/handoff-renderer.ts
+import { join as join10 } from "path";
+
+// src/storage/tasks.ts
+import { createHash } from "crypto";
+import { mkdir as mkdir2, readdir as readdir3, readFile as readFile5, rename as rename2, stat as stat2, unlink as unlink3 } from "fs/promises";
+import { join as join9 } from "path";
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+import { z as z8 } from "zod";
+
+// src/schemas/task.schema.ts
+import { z as z6 } from "zod";
+var TaskStatusSchema = z6.enum(["planned", "in_progress", "done", "cancelled"]);
+var TaskInnerSchema = z6.object({
+  id: TaskIdSchema,
+  title: z6.string().min(1),
+  label: z6.string().min(1).optional(),
+  status: TaskStatusSchema,
+  created_at: IsoTimestampSchema,
+  updated_at: IsoTimestampSchema,
+  workspace_id: WorkspaceIdSchema,
+  /**
+   * Session id that anchors this task. For freshly created tasks it is the
+   * session that wrote the `task_created` event (= ad-hoc reconcile target
+   * for ad-hoc paths, or the target session id for attach paths). After
+   * `basou task reconcile --write` repairs a broken anchor the
+   * value is replaced with the ad-hoc reconcile session id; the old broken
+   * session_id is preserved on the `task_reconciled` event payload via
+   * `removed_created_in_session` for audit. So this field always names a
+   * reachable session, even after the original anchor is gone.
+   */
+  created_in_session: SessionIdSchema,
+  /**
+   * Snapshot of sessions linked to this task. The events.jsonl history is
+   * the source of truth (see
+   * `docs/spec/generated-markdown.md#105-decisionsmd-generation-principle`);
+   * this field is maintained as a UX-only cache so editors can read the
+   * task.md and immediately see related sessions. Defaults to `[]` for
+   * backward compatibility.
+   */
+  linked_sessions: z6.array(SessionIdSchema).default([])
+});
+var TaskSchema = z6.object({
+  schema_version: SchemaVersionSchema,
+  task: TaskInnerSchema
+});
+
+// src/storage/ad-hoc-session.ts
+import { mkdir, rm } from "fs/promises";
+import { homedir } from "os";
+import { join as join6 } from "path";
+
 // src/lib/path-sanitizer.ts
 import { posix as path } from "path";
 function sanitizePath(rawPath, opts) {
@@ -1326,17 +1640,7 @@ function sanitizeRelatedFiles(paths, opts) {
   return { sanitized, mutationCount };
 }
 
-// src/storage/tasks.ts
-import { createHash } from "crypto";
-import { mkdir as mkdir3, readFile as readFile7, readdir as readdir3, rename as rename2, stat as stat2, unlink as unlink3 } from "fs/promises";
-import { join as join10 } from "path";
-import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
-import { z as z10 } from "zod";
-
 // src/storage/ad-hoc-session.ts
-import { mkdir as mkdir2, rm } from "fs/promises";
-import { homedir } from "os";
-import { join as join9 } from "path";
 var FailedToFinalizeError = class extends Error {
   sessionId;
   targetEventIds;
@@ -1373,13 +1677,13 @@ async function createAdHocSessionWithEvent(input) {
       taskId: input.taskId ?? null
     })
   );
-  const sessionDir = join9(input.paths.sessions, sessionId);
+  const sessionDir = join6(input.paths.sessions, sessionId);
   try {
-    await mkdir2(sessionDir, { recursive: true });
+    await mkdir(sessionDir, { recursive: true });
   } catch (error) {
     throw new Error("Failed to create session directory", { cause: error });
   }
-  const sessionYamlPath = join9(sessionDir, "session.yaml");
+  const sessionYamlPath = join6(sessionDir, "session.yaml");
   try {
     await linkYamlFile(sessionYamlPath, initialSession);
   } catch (error) {
@@ -1496,24 +1800,180 @@ async function appendEventToExistingSession(input) {
   if (status === "imported") {
     throw new Error("Cannot attach to imported session");
   }
-  const attachable = input.attachableStatuses ?? DEFAULT_ATTACHABLE_STATUSES;
-  if (!attachable.has(status)) {
-    throw new Error(`Session is not active: ${status}`);
+  const attachable = input.attachableStatuses ?? DEFAULT_ATTACHABLE_STATUSES;
+  if (!attachable.has(status)) {
+    throw new Error(`Session is not active: ${status}`);
+  }
+  const eventId = prefixedUlid("evt");
+  const event = assertTargetEventIdentity(input.eventBuilder(eventId), input.sessionId, eventId);
+  const sessionDir = join6(input.paths.sessions, input.sessionId);
+  await appendEvent(sessionDir, event);
+  return { eventId, sessionStatus: status };
+}
+function assertTargetEventIdentity(event, expectedSessionId, expectedEventId) {
+  if (event.session_id !== expectedSessionId) {
+    throw new Error("Target event session_id mismatch");
+  }
+  if (event.id !== expectedEventId) {
+    throw new Error("Target event id mismatch");
+  }
+  return event;
+}
+
+// src/storage/lockfile.ts
+import { readFile as readFile3, unlink as unlink2 } from "fs/promises";
+import { join as join7 } from "path";
+var STALE_LOCK_MAX_AGE_MS = 60 * 60 * 1e3;
+async function acquireLock(paths, scope, resourceId) {
+  const lockPath = lockfilePath(paths, scope, resourceId);
+  const body = {
+    pid: process.pid,
+    acquired_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const serialised = JSON.stringify(body);
+  try {
+    await atomicCreate(lockPath, serialised);
+  } catch (error) {
+    if (!findErrorCode(error, "EEXIST")) {
+      throw error;
+    }
+    const stale = await isStaleLock(lockPath);
+    if (!stale) {
+      throw new Error("Lock is held by another process", { cause: error });
+    }
+    await unlink2(lockPath).catch(() => void 0);
+    try {
+      await atomicCreate(lockPath, serialised);
+    } catch (retryError) {
+      throw new Error("Lock is held by another process", { cause: retryError });
+    }
+  }
+  return {
+    release: async () => {
+      await unlink2(lockPath).catch(() => void 0);
+    }
+  };
+}
+async function isStaleLock(lockPath) {
+  let body;
+  try {
+    const raw = await readFile3(lockPath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null) return true;
+    const candidate = parsed;
+    if (typeof candidate.pid !== "number" || typeof candidate.acquired_at !== "string") {
+      return true;
+    }
+    body = { pid: candidate.pid, acquired_at: candidate.acquired_at };
+  } catch {
+    return true;
+  }
+  const ageMs = Date.now() - Date.parse(body.acquired_at);
+  if (!Number.isFinite(ageMs) || ageMs > STALE_LOCK_MAX_AGE_MS) {
+    return true;
+  }
+  try {
+    process.kill(body.pid, 0);
+    return false;
+  } catch (error) {
+    if (findErrorCode(error, "ESRCH")) return true;
+    return false;
+  }
+}
+function lockfilePath(paths, scope, resourceId) {
+  const sep = resourceId.indexOf("_");
+  const ulid2 = sep >= 0 ? resourceId.slice(sep + 1) : resourceId;
+  return join7(paths.locks, `${scope}_${ulid2}.lock`);
+}
+
+// src/storage/task-index.ts
+import { readFile as readFile4 } from "fs/promises";
+import { join as join8 } from "path";
+
+// src/schemas/task-index.schema.ts
+import { z as z7 } from "zod";
+var TaskIndexEntrySchema = z7.object({
+  id: TaskIdSchema,
+  status: TaskStatusSchema,
+  label: z7.string().min(1).optional(),
+  updated_at: IsoTimestampSchema
+}).strict();
+var TaskIndexSchema = z7.object({
+  schema_version: SchemaVersionSchema,
+  tasks: z7.array(TaskIndexEntrySchema),
+  last_rebuilt_at: IsoTimestampSchema
+}).strict();
+var TASK_INDEX_SCHEMA_VERSION = "0.1.0";
+
+// src/storage/task-index.ts
+function taskIndexPath(paths) {
+  return join8(paths.tasks, "index.json");
+}
+async function readTaskIndex(paths) {
+  const filePath = taskIndexPath(paths);
+  let raw;
+  try {
+    raw = await readFile4(filePath, "utf8");
+  } catch (error) {
+    if (findErrorCode(error, "ENOENT")) {
+      throw new Error("Task index not found", { cause: error });
+    }
+    throw new Error("Failed to read task index", { cause: error });
+  }
+  let parsedJson;
+  try {
+    parsedJson = JSON.parse(raw);
+  } catch (error) {
+    throw new Error("Invalid task index", { cause: error });
   }
-  const eventId = prefixedUlid("evt");
-  const event = assertTargetEventIdentity(input.eventBuilder(eventId), input.sessionId, eventId);
-  const sessionDir = join9(input.paths.sessions, input.sessionId);
-  await appendEvent(sessionDir, event);
-  return { eventId, sessionStatus: status };
+  const result = TaskIndexSchema.safeParse(parsedJson);
+  if (!result.success) {
+    throw new Error("Invalid task index", { cause: result.error });
+  }
+  if (result.data.schema_version !== TASK_INDEX_SCHEMA_VERSION) {
+    throw new Error("Invalid task index", {
+      cause: new Error(`Unsupported task index schema_version: ${result.data.schema_version}`)
+    });
+  }
+  return result.data;
 }
-function assertTargetEventIdentity(event, expectedSessionId, expectedEventId) {
-  if (event.session_id !== expectedSessionId) {
-    throw new Error("Target event session_id mismatch");
+async function rebuildTaskIndex(paths, entries, now) {
+  const sorted = [...entries].sort((a, b) => a.id.localeCompare(b.id));
+  const payload = {
+    schema_version: TASK_INDEX_SCHEMA_VERSION,
+    tasks: sorted,
+    last_rebuilt_at: (now ?? (() => /* @__PURE__ */ new Date()))().toISOString()
+  };
+  TaskIndexSchema.parse(payload);
+  await atomicReplace(taskIndexPath(paths), `${JSON.stringify(payload, null, 2)}
+`);
+  return payload;
+}
+async function updateTaskIndex(paths, op, options) {
+  const nowFn = options?.now ?? (() => /* @__PURE__ */ new Date());
+  let current;
+  try {
+    current = await readTaskIndex(paths);
+  } catch {
+    current = {
+      schema_version: TASK_INDEX_SCHEMA_VERSION,
+      tasks: [],
+      last_rebuilt_at: nowFn().toISOString()
+    };
   }
-  if (event.id !== expectedEventId) {
-    throw new Error("Target event id mismatch");
+  let nextTasks;
+  switch (op.kind) {
+    case "add":
+      nextTasks = current.tasks.some((t) => t.id === op.entry.id) ? current.tasks.map((t) => t.id === op.entry.id ? op.entry : t) : [...current.tasks, op.entry];
+      break;
+    case "update":
+      nextTasks = current.tasks.some((t) => t.id === op.entry.id) ? current.tasks.map((t) => t.id === op.entry.id ? op.entry : t) : [...current.tasks, op.entry];
+      break;
+    case "remove":
+      nextTasks = current.tasks.filter((t) => t.id !== op.id);
+      break;
   }
-  return event;
+  return await rebuildTaskIndex(paths, nextTasks, nowFn);
 }
 
 // src/storage/tasks.ts
@@ -1526,8 +1986,8 @@ var DEFAULT_ATTACHABLE_STATUSES2 = /* @__PURE__ */ new Set([
   "waiting_approval"
 ]);
 var InitialTaskStatusSchema = TaskStatusSchema;
-var TaskTitleSchema = z10.string().min(1);
-var TaskLabelSchema = z10.string().min(1);
+var TaskTitleSchema = z8.string().min(1);
+var TaskLabelSchema = z8.string().min(1);
 var CompletedAtSchema = IsoTimestampSchema;
 var TERMINAL_TASK_STATUSES = /* @__PURE__ */ new Set(["done", "cancelled"]);
 function isTerminalTaskStatus(status) {
@@ -1561,10 +2021,10 @@ function splitFrontMatter(raw) {
   return { yamlText, body };
 }
 async function readTaskFile(paths, taskId) {
-  const filePath = join10(paths.tasks, `${taskId}.md`);
+  const filePath = join9(paths.tasks, `${taskId}.md`);
   let raw;
   try {
-    raw = await readFile7(filePath, "utf8");
+    raw = await readFile5(filePath, "utf8");
   } catch (error) {
     if (findErrorCode(error, "ENOENT")) {
       throw new Error("Task file not found", { cause: error });
@@ -1594,7 +2054,7 @@ async function readTaskFile(paths, taskId) {
 }
 async function writeTaskFile(paths, taskId, doc, options) {
   const validated = TaskSchema.parse(doc.task);
-  const filePath = join10(paths.tasks, `${taskId}.md`);
+  const filePath = join9(paths.tasks, `${taskId}.md`);
   const yamlText = stringifyYaml(validated);
   const trimmedBody = doc.body.length === 0 ? "" : `
 ${doc.body.endsWith("\n") ? doc.body : `${doc.body}
@@ -1679,7 +2139,7 @@ async function safeUpdateTaskIndex(paths, op) {
 }
 var ARCHIVE_DIR_NAME = "archive";
 function archiveTasksDir(paths) {
-  return join10(paths.tasks, ARCHIVE_DIR_NAME);
+  return join9(paths.tasks, ARCHIVE_DIR_NAME);
 }
 async function enumerateArchivedTaskIds(paths) {
   let entries;
@@ -1709,10 +2169,10 @@ async function readTaskFileWithArchiveFallback(paths, taskId) {
       throw error;
     }
   }
-  const archiveFilePath = join10(archiveTasksDir(paths), `${taskId}.md`);
+  const archiveFilePath = join9(archiveTasksDir(paths), `${taskId}.md`);
   let raw;
   try {
-    raw = await readFile7(archiveFilePath, "utf8");
+    raw = await readFile5(archiveFilePath, "utf8");
   } catch (error) {
     if (findErrorCode(error, "ENOENT")) {
       throw new Error("Task file not found", { cause: error });
@@ -2003,7 +2463,7 @@ async function createTaskAttachLocked(input) {
       ...sessionDoc,
       session: { ...sessionDoc.session, task_id: input.taskId }
     };
-    await overwriteYamlFile(join10(input.paths.sessions, input.sessionId, "session.yaml"), updated);
+    await overwriteYamlFile(join9(input.paths.sessions, input.sessionId, "session.yaml"), updated);
   } catch (error) {
     throw new TaskWriteAfterEventError({
       taskId: input.taskId,
@@ -2262,17 +2722,17 @@ function buildUpdatedDoc(input) {
   return { task: next, body: input.currentDoc.body };
 }
 async function computeTaskMdSnapshot(paths, taskId) {
-  const filePath = join10(paths.tasks, `${taskId}.md`);
-  const [stats, raw] = await Promise.all([stat2(filePath), readFile7(filePath)]);
+  const filePath = join9(paths.tasks, `${taskId}.md`);
+  const [stats, raw] = await Promise.all([stat2(filePath), readFile5(filePath)]);
   const hash = createHash("sha256").update(raw).digest("hex");
   return { mtimeMs: stats.mtimeMs, hash };
 }
 async function readTaskFileWithSnapshot(paths, taskId) {
-  const filePath = join10(paths.tasks, `${taskId}.md`);
+  const filePath = join9(paths.tasks, `${taskId}.md`);
   let rawBuffer;
   let stats;
   try {
-    [rawBuffer, stats] = await Promise.all([readFile7(filePath), stat2(filePath)]);
+    [rawBuffer, stats] = await Promise.all([readFile5(filePath), stat2(filePath)]);
   } catch (error) {
     if (findErrorCode(error, "ENOENT")) {
       throw new Error("Task file not found", { cause: error });
@@ -2630,416 +3090,230 @@ async function refreshTaskLinkedSessionsLocked(paths, manifest, input) {
     occurredAt: input.occurredAt
   });
   try {
-    await writeTaskFile(paths, input.taskId, refreshed, { mode: "overwrite" });
-  } catch (error) {
-    throw new TaskWriteAfterEventError({
-      taskId: input.taskId,
-      eventId: anchorEventId,
-      sessionId: adHoc.sessionId,
-      phase: "linkage-refresh",
-      cause: error
-    });
-  }
-  await safeUpdateTaskIndex(paths, {
-    kind: "update",
-    entry: buildTaskIndexEntry(refreshed.task.task)
-  });
-  return {
-    taskId: input.taskId,
-    clean: false,
-    addedLinkedSessions,
-    removedLinkedSessions,
-    finalCount: finalCountWithRefreshSession,
-    refreshSession: {
-      sessionId: adHoc.sessionId,
-      eventId: anchorEventId
-    }
-  };
-}
-async function editTask(input) {
-  TaskIdSchema.parse(input.taskId);
-  if (input.title === void 0 && input.newStatus === void 0) {
-    throw new Error("Nothing to edit: provide --title or --status");
-  }
-  if (input.title !== void 0) {
-    TaskTitleSchema.parse(input.title);
-  }
-  let statusUpdated = false;
-  let previousStatus = null;
-  let newStatus = null;
-  let statusChangeSession = null;
-  if (input.newStatus !== void 0) {
-    if (input.manifest === void 0 || input.workingDirectory === void 0) {
-      throw new Error("editTask requires manifest + workingDirectory when newStatus is supplied");
-    }
-    const result = await updateTaskStatusWithEvent({
-      mode: "ad-hoc",
-      paths: input.paths,
-      manifest: input.manifest,
-      occurredAt: input.occurredAt,
-      taskId: input.taskId,
-      newStatus: input.newStatus,
-      workingDirectory: input.workingDirectory
-    });
-    statusUpdated = true;
-    previousStatus = result.previousStatus;
-    newStatus = result.newStatus;
-    statusChangeSession = { sessionId: result.sessionId, eventId: result.eventId };
-  }
-  let titleUpdated = false;
-  if (input.title !== void 0) {
-    const handle = await acquireLock(input.paths, "task", input.taskId);
-    try {
-      const doc = await readTaskFile(input.paths, input.taskId);
-      if (doc.task.task.title !== input.title) {
-        const next = {
-          ...doc.task,
-          task: {
-            ...doc.task.task,
-            title: input.title,
-            updated_at: input.occurredAt
-          }
-        };
-        await writeTaskFile(
-          input.paths,
-          input.taskId,
-          { task: next, body: doc.body },
-          { mode: "overwrite" }
-        );
-        await safeUpdateTaskIndex(input.paths, {
-          kind: "update",
-          entry: buildTaskIndexEntry(next.task)
-        });
-        titleUpdated = true;
-      }
-    } finally {
-      await handle.release();
-    }
-  }
-  return {
-    taskId: input.taskId,
-    titleUpdated,
-    statusUpdated,
-    previousStatus,
-    newStatus,
-    statusChangeSession
-  };
-}
-async function deleteTask(input) {
-  TaskIdSchema.parse(input.taskId);
-  const handle = await acquireLock(input.paths, "task", input.taskId);
-  try {
-    return await deleteTaskLocked(input);
-  } finally {
-    await handle.release();
-  }
-}
-async function deleteTaskLocked(input) {
-  const doc = await readTaskFile(input.paths, input.taskId);
-  const title = doc.task.task.title;
-  const adHoc = await createAdHocSessionWithEvent({
-    paths: input.paths,
-    manifest: input.manifest,
-    label: buildAdHocDeleteLabel(title),
-    occurredAt: input.occurredAt,
-    sessionSource: "human",
-    workingDirectory: input.workingDirectory,
-    invocation: {
-      command: "basou task delete",
-      args: [input.taskId, "--yes"]
-    },
-    targetEventBuilders: [
-      (sessionId, eventId2) => buildTaskDeletedEvent({
-        eventId: eventId2,
-        sessionId,
-        taskId: input.taskId,
-        title,
-        occurredAt: input.occurredAt
-      })
-    ]
-  });
-  const eventId = adHoc.targetEventIds[0];
-  try {
-    await unlink3(join10(input.paths.tasks, `${input.taskId}.md`));
-  } catch (error) {
-    throw new TaskWriteAfterEventError({
-      taskId: input.taskId,
-      eventId,
-      sessionId: adHoc.sessionId,
-      phase: "delete",
-      cause: error
-    });
-  }
-  await safeUpdateTaskIndex(input.paths, { kind: "remove", id: input.taskId });
-  return {
-    taskId: input.taskId,
-    title,
-    sessionId: adHoc.sessionId,
-    eventId
-  };
-}
-async function archiveTask(input) {
-  TaskIdSchema.parse(input.taskId);
-  const handle = await acquireLock(input.paths, "task", input.taskId);
-  try {
-    return await archiveTaskLocked(input);
-  } finally {
-    await handle.release();
-  }
-}
-async function archiveTaskLocked(input) {
-  const doc = await readTaskFile(input.paths, input.taskId);
-  const title = doc.task.task.title;
-  const adHoc = await createAdHocSessionWithEvent({
-    paths: input.paths,
-    manifest: input.manifest,
-    label: buildAdHocArchiveLabel(title),
-    occurredAt: input.occurredAt,
-    sessionSource: "human",
-    workingDirectory: input.workingDirectory,
-    invocation: {
-      command: "basou task archive",
-      args: [input.taskId, "--yes"]
-    },
-    taskId: input.taskId,
-    targetEventBuilders: [
-      (sessionId, eventId2) => buildTaskArchivedEvent({
-        eventId: eventId2,
-        sessionId,
-        taskId: input.taskId,
-        title,
-        occurredAt: input.occurredAt
-      })
-    ]
-  });
-  const eventId = adHoc.targetEventIds[0];
-  try {
-    const linked = doc.task.task.linked_sessions;
-    const merged = linked.includes(adHoc.sessionId) ? linked : [...linked, adHoc.sessionId];
-    const next = {
-      ...doc.task,
-      task: {
-        ...doc.task.task,
-        updated_at: input.occurredAt,
-        linked_sessions: merged
-      }
-    };
-    await writeTaskFile(
-      input.paths,
-      input.taskId,
-      { task: next, body: doc.body },
-      { mode: "overwrite" }
-    );
-    await mkdir3(archiveTasksDir(input.paths), { recursive: true });
-    await rename2(
-      join10(input.paths.tasks, `${input.taskId}.md`),
-      join10(archiveTasksDir(input.paths), `${input.taskId}.md`)
-    );
+    await writeTaskFile(paths, input.taskId, refreshed, { mode: "overwrite" });
   } catch (error) {
     throw new TaskWriteAfterEventError({
       taskId: input.taskId,
-      eventId,
+      eventId: anchorEventId,
       sessionId: adHoc.sessionId,
-      phase: "archive",
+      phase: "linkage-refresh",
       cause: error
     });
   }
-  await safeUpdateTaskIndex(input.paths, { kind: "remove", id: input.taskId });
+  await safeUpdateTaskIndex(paths, {
+    kind: "update",
+    entry: buildTaskIndexEntry(refreshed.task.task)
+  });
   return {
     taskId: input.taskId,
-    title,
-    sessionId: adHoc.sessionId,
-    eventId
-  };
-}
-
-// src/storage/session-import.ts
-async function importSessionFromJson(paths, manifest, payload, options) {
-  if (options.taskIdOverride !== void 0 && !TaskIdSchema.safeParse(options.taskIdOverride).success) {
-    throw new Error(`Invalid task_id: ${options.taskIdOverride}`);
-  }
-  const effectiveSessionTaskId = options.taskIdOverride ?? payload.session.task_id ?? null;
-  await assertImportedTaskReferencesAreReachable(paths, payload.events, effectiveSessionTaskId);
-  const newSessionId = prefixedUlid("ses");
-  const rewrittenEvents = rewriteEvents(payload.events, newSessionId);
-  assertChronologicalOrder(rewrittenEvents);
-  const { record: sessionRecord, pathSanitizeReport } = buildSessionRecord(
-    payload.session,
-    manifest,
-    newSessionId,
-    options
-  );
-  if (options.dryRun === true) {
-    return {
-      sessionId: newSessionId,
-      eventCount: rewrittenEvents.length,
-      finalStatus: "imported",
-      finalSourceKind: sessionRecord.session.source.kind,
-      pathSanitizeReport
-    };
-  }
-  const sessionDir = join11(paths.sessions, newSessionId);
-  try {
-    await mkdir4(sessionDir, { recursive: true });
-  } catch (error) {
-    throw new Error("Failed to create session directory", { cause: error });
-  }
-  try {
-    await writeEventsBulk(sessionDir, rewrittenEvents);
-  } catch (error) {
-    await rm2(sessionDir, { recursive: true, force: true }).catch(() => void 0);
-    throw error;
-  }
-  try {
-    const sessionYamlPath = join11(sessionDir, "session.yaml");
-    await linkYamlFile(sessionYamlPath, sessionRecord);
-  } catch (error) {
-    await rm2(sessionDir, { recursive: true, force: true }).catch(() => void 0);
-    if (findErrorCode(error, "EEXIST")) {
-      throw new Error("Session directory collision (retry the command)", {
-        cause: error
-      });
+    clean: false,
+    addedLinkedSessions,
+    removedLinkedSessions,
+    finalCount: finalCountWithRefreshSession,
+    refreshSession: {
+      sessionId: adHoc.sessionId,
+      eventId: anchorEventId
     }
-    throw error;
-  }
-  return {
-    sessionId: newSessionId,
-    eventCount: rewrittenEvents.length,
-    finalStatus: "imported",
-    finalSourceKind: sessionRecord.session.source.kind,
-    pathSanitizeReport
   };
 }
-async function assertImportedTaskReferencesAreReachable(paths, events, effectiveSessionTaskId) {
-  const taskIdsToCheck = /* @__PURE__ */ new Set();
-  for (const ev of events) {
-    if (ev.type === "task_created" || ev.type === "task_status_changed" || ev.type === "task_reconciled" || ev.type === "task_linkage_refreshed" || ev.type === "task_deleted" || ev.type === "task_archived") {
-      taskIdsToCheck.add(ev.task_id);
-    }
-  }
-  if (effectiveSessionTaskId !== null) {
-    taskIdsToCheck.add(effectiveSessionTaskId);
+async function editTask(input) {
+  TaskIdSchema.parse(input.taskId);
+  if (input.title === void 0 && input.newStatus === void 0) {
+    throw new Error("Nothing to edit: provide --title or --status");
   }
-  if (taskIdsToCheck.size === 0) {
-    return;
+  if (input.title !== void 0) {
+    TaskTitleSchema.parse(input.title);
   }
-  const knownTaskIds = new Set(await enumerateTaskIds(paths));
-  for (const id of taskIdsToCheck) {
-    if (!knownTaskIds.has(id)) {
-      throw new Error("Imported session references unknown task_id");
+  let statusUpdated = false;
+  let previousStatus = null;
+  let newStatus = null;
+  let statusChangeSession = null;
+  if (input.newStatus !== void 0) {
+    if (input.manifest === void 0 || input.workingDirectory === void 0) {
+      throw new Error("editTask requires manifest + workingDirectory when newStatus is supplied");
     }
+    const result = await updateTaskStatusWithEvent({
+      mode: "ad-hoc",
+      paths: input.paths,
+      manifest: input.manifest,
+      occurredAt: input.occurredAt,
+      taskId: input.taskId,
+      newStatus: input.newStatus,
+      workingDirectory: input.workingDirectory
+    });
+    statusUpdated = true;
+    previousStatus = result.previousStatus;
+    newStatus = result.newStatus;
+    statusChangeSession = { sessionId: result.sessionId, eventId: result.eventId };
   }
-}
-function rewriteEvents(events, newSessionId) {
-  return events.map((event) => ({
-    ...event,
-    id: prefixedUlid("evt"),
-    session_id: newSessionId
-  }));
-}
-function assertChronologicalOrder(events) {
-  for (let i = 1; i < events.length; i++) {
-    const prevEvent = events[i - 1];
-    const currEvent = events[i];
-    if (prevEvent === void 0 || currEvent === void 0) continue;
-    const prev = Date.parse(prevEvent.occurred_at);
-    const curr = Date.parse(currEvent.occurred_at);
-    if (!Number.isFinite(prev) || !Number.isFinite(curr) || curr < prev) {
-      throw new Error("Events are not in chronological order");
+  let titleUpdated = false;
+  if (input.title !== void 0) {
+    const handle = await acquireLock(input.paths, "task", input.taskId);
+    try {
+      const doc = await readTaskFile(input.paths, input.taskId);
+      if (doc.task.task.title !== input.title) {
+        const next = {
+          ...doc.task,
+          task: {
+            ...doc.task.task,
+            title: input.title,
+            updated_at: input.occurredAt
+          }
+        };
+        await writeTaskFile(
+          input.paths,
+          input.taskId,
+          { task: next, body: doc.body },
+          { mode: "overwrite" }
+        );
+        await safeUpdateTaskIndex(input.paths, {
+          kind: "update",
+          entry: buildTaskIndexEntry(next.task)
+        });
+        titleUpdated = true;
+      }
+    } finally {
+      await handle.release();
     }
   }
-}
-function buildSessionRecord(input, manifest, newSessionId, options) {
-  const home = homedir2();
-  const workingDirectoryRaw = input.working_directory;
-  const workingDirectorySanitized = sanitizeWorkingDirectory(workingDirectoryRaw, {
-    homedir: home
-  });
-  const relatedSanitized = sanitizeRelatedFiles(input.related_files, {
-    workingDirectory: workingDirectoryRaw,
-    homedir: home
-  });
-  const inner = {
-    id: newSessionId,
-    ...options.labelOverride !== void 0 || input.label !== void 0 ? { label: options.labelOverride ?? input.label } : {},
-    task_id: options.taskIdOverride !== void 0 ? options.taskIdOverride : input.task_id ?? null,
-    workspace_id: manifest.workspace.id,
-    source: input.source,
-    started_at: input.started_at,
-    ...input.ended_at !== void 0 ? { ended_at: input.ended_at } : {},
-    status: "imported",
-    working_directory: workingDirectorySanitized,
-    invocation: input.invocation,
-    related_files: relatedSanitized.sanitized,
-    events_log: "events.jsonl",
-    summary: input.summary ?? null
-  };
   return {
-    record: { schema_version: "0.1.0", session: inner },
-    pathSanitizeReport: {
-      relatedFiles: relatedSanitized.mutationCount,
-      workingDirectoryRewritten: workingDirectorySanitized !== workingDirectoryRaw
-    }
+    taskId: input.taskId,
+    titleUpdated,
+    statusUpdated,
+    previousStatus,
+    newStatus,
+    statusChangeSession
   };
 }
-
-// src/lib/id-resolver.ts
-async function resolveSessionId(paths, input) {
-  return resolveIdInternal(paths, input, "session");
-}
-async function resolveTaskId(paths, input, options = {}) {
-  return resolveIdInternal(paths, input, "task", options);
-}
-var KIND_CONFIG = {
-  session: {
-    prefix: "ses_",
-    noun: "session",
-    nounPlural: "sessions",
-    capNoun: "Session",
-    enumerate: enumerateSessionDirs
-  },
-  task: {
-    prefix: "task_",
-    noun: "task",
-    nounPlural: "tasks",
-    capNoun: "Task",
-    enumerate: enumerateTaskIds
-  }
-};
-async function resolveIdInternal(paths, input, kind, options = {}) {
-  const cfg = KIND_CONFIG[kind];
-  const trimmed = input.trim();
-  if (trimmed.length === 0) {
-    throw new Error(`${cfg.capNoun} id is empty`);
-  }
-  const normalized = trimmed.startsWith(cfg.prefix) ? trimmed : `${cfg.prefix}${trimmed}`;
-  if (normalized.length <= cfg.prefix.length) {
-    throw new Error(`${cfg.capNoun} not found: ${input}`);
-  }
-  const primary = await cfg.enumerate(paths);
-  const merged = new Set(primary);
-  if (kind === "task" && options.includeArchived === true) {
-    for (const id of await enumerateArchivedTaskIds(paths)) {
-      merged.add(id);
-    }
+async function deleteTask(input) {
+  TaskIdSchema.parse(input.taskId);
+  const handle = await acquireLock(input.paths, "task", input.taskId);
+  try {
+    return await deleteTaskLocked(input);
+  } finally {
+    await handle.release();
   }
-  if (merged.size === 0) {
-    throw new Error(`${cfg.capNoun} not found: ${input}`);
+}
+async function deleteTaskLocked(input) {
+  const doc = await readTaskFile(input.paths, input.taskId);
+  const title = doc.task.task.title;
+  const adHoc = await createAdHocSessionWithEvent({
+    paths: input.paths,
+    manifest: input.manifest,
+    label: buildAdHocDeleteLabel(title),
+    occurredAt: input.occurredAt,
+    sessionSource: "human",
+    workingDirectory: input.workingDirectory,
+    invocation: {
+      command: "basou task delete",
+      args: [input.taskId, "--yes"]
+    },
+    targetEventBuilders: [
+      (sessionId, eventId2) => buildTaskDeletedEvent({
+        eventId: eventId2,
+        sessionId,
+        taskId: input.taskId,
+        title,
+        occurredAt: input.occurredAt
+      })
+    ]
+  });
+  const eventId = adHoc.targetEventIds[0];
+  try {
+    await unlink3(join9(input.paths.tasks, `${input.taskId}.md`));
+  } catch (error) {
+    throw new TaskWriteAfterEventError({
+      taskId: input.taskId,
+      eventId,
+      sessionId: adHoc.sessionId,
+      phase: "delete",
+      cause: error
+    });
   }
-  const matches = [...merged].filter((e) => e.startsWith(normalized));
-  if (matches.length === 0) {
-    throw new Error(`${cfg.capNoun} not found: ${input}`);
+  await safeUpdateTaskIndex(input.paths, { kind: "remove", id: input.taskId });
+  return {
+    taskId: input.taskId,
+    title,
+    sessionId: adHoc.sessionId,
+    eventId
+  };
+}
+async function archiveTask(input) {
+  TaskIdSchema.parse(input.taskId);
+  const handle = await acquireLock(input.paths, "task", input.taskId);
+  try {
+    return await archiveTaskLocked(input);
+  } finally {
+    await handle.release();
   }
-  if (matches.length > 1) {
-    throw new Error(
-      `Ambiguous ${cfg.noun} id '${input}': matched ${matches.length} ${cfg.nounPlural}. Disambiguate with a longer prefix.`
+}
+async function archiveTaskLocked(input) {
+  const doc = await readTaskFile(input.paths, input.taskId);
+  const title = doc.task.task.title;
+  const adHoc = await createAdHocSessionWithEvent({
+    paths: input.paths,
+    manifest: input.manifest,
+    label: buildAdHocArchiveLabel(title),
+    occurredAt: input.occurredAt,
+    sessionSource: "human",
+    workingDirectory: input.workingDirectory,
+    invocation: {
+      command: "basou task archive",
+      args: [input.taskId, "--yes"]
+    },
+    taskId: input.taskId,
+    targetEventBuilders: [
+      (sessionId, eventId2) => buildTaskArchivedEvent({
+        eventId: eventId2,
+        sessionId,
+        taskId: input.taskId,
+        title,
+        occurredAt: input.occurredAt
+      })
+    ]
+  });
+  const eventId = adHoc.targetEventIds[0];
+  try {
+    const linked = doc.task.task.linked_sessions;
+    const merged = linked.includes(adHoc.sessionId) ? linked : [...linked, adHoc.sessionId];
+    const next = {
+      ...doc.task,
+      task: {
+        ...doc.task.task,
+        updated_at: input.occurredAt,
+        linked_sessions: merged
+      }
+    };
+    await writeTaskFile(
+      input.paths,
+      input.taskId,
+      { task: next, body: doc.body },
+      { mode: "overwrite" }
     );
+    await mkdir2(archiveTasksDir(input.paths), { recursive: true });
+    await rename2(
+      join9(input.paths.tasks, `${input.taskId}.md`),
+      join9(archiveTasksDir(input.paths), `${input.taskId}.md`)
+    );
+  } catch (error) {
+    throw new TaskWriteAfterEventError({
+      taskId: input.taskId,
+      eventId,
+      sessionId: adHoc.sessionId,
+      phase: "archive",
+      cause: error
+    });
   }
-  return matches[0];
+  await safeUpdateTaskIndex(input.paths, { kind: "remove", id: input.taskId });
+  return {
+    taskId: input.taskId,
+    title,
+    sessionId: adHoc.sessionId,
+    eventId
+  };
 }
 
 // src/handoff/handoff-renderer.ts
-import { join as join12 } from "path";
 async function renderHandoff(input) {
   const limit = input.relatedFilesLimit ?? 20;
   const now = new Date(input.nowIso);
@@ -3055,7 +3329,7 @@ async function renderHandoff(input) {
   const tasksCreated = [];
   const tasksStatusChanged = [];
   for (const entry of entries) {
-    const sessionDir = join12(input.paths.sessions, entry.sessionId);
+    const sessionDir = join10(input.paths.sessions, entry.sessionId);
     try {
       for await (const ev of replayEvents(sessionDir, {
         onWarning: (w) => input.onWarning?.(w, entry.sessionId)
@@ -3122,18 +3396,14 @@ async function renderHandoff(input) {
   const latestSession = [...liveEntries].sort(
     (a, b) => Date.parse(b.session.session.started_at) - Date.parse(a.session.session.started_at)
   )[0];
-  const allFiles = /* @__PURE__ */ new Set();
-  for (const e of entries) {
-    if (e.session.session.source.kind === "import") continue;
-    for (const f of e.session.session.related_files) allFiles.add(f);
-  }
-  const sortedFiles = [...allFiles].sort();
+  const latestFiles = latestSession?.session.session.related_files ?? [];
+  const sortedFiles = [...new Set(latestFiles)].sort();
   const displayedFiles = sortedFiles.slice(0, limit);
   const overflow = Math.max(0, sortedFiles.length - limit);
   const suspectCount = entries.filter((e) => e.suspect).length;
   const firstEntry = entries[0];
   const lastEntry = entries[entries.length - 1];
-  const sessionRange = firstEntry !== void 0 && lastEntry !== void 0 ? `${firstEntry.sessionId}..${lastEntry.sessionId}` : "";
+  const sessionRange = firstEntry !== void 0 && lastEntry !== void 0 ? `${shortIdWithPrefix(firstEntry.sessionId)}..${shortIdWithPrefix(lastEntry.sessionId)}` : "";
   const body = formatHandoffBody({
     nowIso: input.nowIso,
     sessionRange,
@@ -3173,18 +3443,23 @@ function formatHandoffBody(args) {
   lines.push("## \u73FE\u5728\u306E\u72B6\u614B");
   lines.push("");
   if (args.latestSession !== void 0) {
-    const sid = args.latestSession.sessionId;
     const status = args.latestSession.session.session.status;
-    lines.push(`- \u6700\u7D42 session: ${sid} (${status})`);
+    const label = args.latestSession.session.session.label;
+    const shortId = shortIdWithPrefix(args.latestSession.sessionId);
+    if (label !== void 0 && label !== "") {
+      lines.push(`- \u6700\u7D42 session: ${label} (${status}) [${shortId}]`);
+    } else {
+      lines.push(`- \u6700\u7D42 session: ${shortId} (${status})`);
+    }
   } else {
     lines.push("- \u6700\u7D42 session: (no live sessions)");
   }
   if (args.latestActivityRecord !== void 0) {
     const statusLabel = args.latestTaskDoc !== void 0 ? args.latestTaskDoc.task.task.status : "status unknown \u2014 task.md missing or invalid";
     const linkedCount = args.latestTaskDoc?.task.task.linked_sessions?.length;
-    const linkedSuffix = linkedCount !== void 0 && linkedCount > 1 ? ` (linked_sessions: ${linkedCount})` : "";
+    const linkedSuffix = linkedCount !== void 0 && linkedCount > 1 ? `, linked_sessions: ${linkedCount}` : "";
     lines.push(
-      `- \u6700\u7D42 task: ${args.latestActivityRecord.taskId} (${statusLabel}): ${args.latestActivityRecord.title}${linkedSuffix}`
+      `- \u6700\u7D42 task: ${args.latestActivityRecord.title} (${statusLabel}${linkedSuffix}) [${shortIdWithPrefix(args.latestActivityRecord.taskId)}]`
     );
   } else {
     lines.push("- \u6700\u7D42 task: (no tasks recorded yet)");
@@ -3205,7 +3480,7 @@ function formatHandoffBody(args) {
     lines.push("(no decisions recorded yet)");
   } else {
     const last = args.decisions[args.decisions.length - 1];
-    lines.push(`- ${last.decisionId}: ${last.title}`);
+    lines.push(`- ${last.title} [${shortIdWithPrefix(last.decisionId)}]`);
     lines.push("");
     lines.push(`(${args.decisions.length} decisions total \u2014 see decisions.md)`);
   }
@@ -3233,7 +3508,9 @@ function formatHandoffBody(args) {
     lines.push("(no pending tasks)");
   } else {
     for (const t of args.pendingTasks) {
-      lines.push(`- ${t.task.task.id} (${t.task.task.status}): ${t.task.task.title}`);
+      lines.push(
+        `- ${t.task.task.title} (${t.task.task.status}) [${shortIdWithPrefix(t.task.task.id)}]`
+      );
     }
   }
   lines.push("");
@@ -3287,144 +3564,119 @@ function formatHandoffBody(args) {
     "initialized",
     "imported"
   ];
-  const breakdown = orderedStatuses.filter((s) => (statusCounts.get(s) ?? 0) > 0).map((s) => `${s} ${statusCounts.get(s)}`).join(", ");
-  const sessionsLine = breakdown !== "" ? `Sessions: ${args.sessionCount} (${breakdown}). Tasks: ${args.totalTaskCount}.` : `Sessions: ${args.sessionCount}. Tasks: ${args.totalTaskCount}.`;
-  lines.push(sessionsLine);
-  return lines.join("\n");
-}
-function suspectLabel(reason) {
-  if (reason === "events_say_ended_but_yaml_running") return " \u26A0 ended (yaml stale)";
-  if (reason === "running_no_end_event") return " \u26A0 no end event";
-  return "";
-}
-function shortHandoffId(sessionId) {
-  const SES = "ses_";
-  if (sessionId.startsWith(SES)) return sessionId.slice(SES.length, SES.length + 10);
-  return sessionId.slice(0, 10);
-}
-
-// src/decisions/decisions-renderer.ts
-import { lstat as lstat4 } from "fs/promises";
-import { dirname, join as join13, resolve } from "path";
-async function renderDecisions(input) {
-  const now = new Date(input.nowIso);
-  const unreadableEmitted = /* @__PURE__ */ new Set();
-  const wrappedSkip = (sid, reason) => {
-    if (reason === "events_jsonl_unreadable") unreadableEmitted.add(sid);
-    input.onSessionSkip?.(sid, reason);
-  };
-  const loadOpts = { now, onSkip: wrappedSkip };
-  if (input.onWarning !== void 0) loadOpts.onWarning = input.onWarning;
-  const entries = await loadSessionEntries(input.paths, loadOpts);
-  const decisions = [];
-  const knownEventIds = /* @__PURE__ */ new Set();
-  for (const entry of entries) {
-    const sessionDir = join13(input.paths.sessions, entry.sessionId);
-    try {
-      for await (const ev of replayEvents(sessionDir, {
-        onWarning: (w) => input.onWarning?.(w, entry.sessionId)
-      })) {
-        knownEventIds.add(ev.id);
-        if (ev.type === "decision_recorded") {
-          decisions.push({
-            decisionId: ev.decision_id,
-            title: ev.title,
-            occurredAt: ev.occurred_at,
-            sessionId: entry.sessionId,
-            rationale: ev.rationale,
-            alternatives: ev.alternatives,
-            rejectedReason: ev.rejected_reason,
-            linkedEvents: ev.linked_events,
-            linkedFiles: ev.linked_files
-          });
-        }
-      }
-    } catch {
-      if (!unreadableEmitted.has(entry.sessionId)) {
-        wrappedSkip(entry.sessionId, "events_jsonl_unreadable");
-      }
-    }
-  }
-  decisions.sort((a, b) => {
-    const c = Date.parse(a.occurredAt) - Date.parse(b.occurredAt);
-    return c !== 0 ? c : a.decisionId.localeCompare(b.decisionId);
-  });
-  const repoRoot = dirname(input.paths.root);
-  const fileExistenceCache = /* @__PURE__ */ new Map();
-  async function fileExists(relPath) {
-    const cached = fileExistenceCache.get(relPath);
-    if (cached !== void 0) return cached;
-    const abs = resolve(repoRoot, relPath);
-    let exists;
-    try {
-      await lstat4(abs);
-      exists = true;
-    } catch {
-      exists = false;
-    }
-    fileExistenceCache.set(relPath, exists);
-    return exists;
-  }
-  const body = await formatDecisionsBody({
-    nowIso: input.nowIso,
-    decisions,
-    knownEventIds,
-    fileExists
-  });
-  return { body, decisionCount: decisions.length };
-}
-async function formatDecisionsBody(args) {
-  const lines = [];
-  lines.push("# Decisions");
-  lines.push("");
-  lines.push(`> Generated at ${args.nowIso}`);
-  lines.push("");
-  if (args.decisions.length === 0) {
-    lines.push("(no decisions recorded yet)");
-    return lines.join("\n");
-  }
-  for (const d of args.decisions) {
-    lines.push(`## ${d.decisionId}: ${d.title}`);
-    lines.push("");
-    const occurredDate = d.occurredAt.slice(0, 10);
-    lines.push(`- \u6C7A\u5B9A\u65E5: ${occurredDate}`);
-    lines.push(`- session: ${shortDecisionSessionId(d.sessionId)}`);
-    lines.push(`- \u5224\u65AD: ${d.title}`);
-    if (typeof d.rationale === "string" && d.rationale.length > 0) {
-      lines.push(`- rationale: ${d.rationale}`);
-    }
-    if (d.alternatives !== void 0 && d.alternatives.length > 0) {
-      lines.push(`- alternatives: ${d.alternatives.join(", ")}`);
-    }
-    if (typeof d.rejectedReason === "string" && d.rejectedReason.length > 0) {
-      lines.push(`- rejected_reason: ${d.rejectedReason}`);
-    }
-    if (d.linkedEvents !== void 0 && d.linkedEvents.length > 0) {
-      const parts = d.linkedEvents.map(
-        (eid) => args.knownEventIds.has(eid) ? eid : `${eid} (missing)`
-      );
-      lines.push(`- linked_events: ${parts.join(", ")}`);
-    }
-    if (d.linkedFiles !== void 0 && d.linkedFiles.length > 0) {
-      const parts = await Promise.all(
-        d.linkedFiles.map(
-          async (path2) => await args.fileExists(path2) ? path2 : `${path2} (missing)`
-        )
-      );
-      lines.push(`- linked_files: ${parts.join(", ")}`);
-    }
-    lines.push("");
-  }
+  const breakdown = orderedStatuses.filter((s) => (statusCounts.get(s) ?? 0) > 0).map((s) => `${s} ${statusCounts.get(s)}`).join(", ");
+  const sessionsLine = breakdown !== "" ? `Sessions: ${args.sessionCount} (${breakdown}). Tasks: ${args.totalTaskCount}.` : `Sessions: ${args.sessionCount}. Tasks: ${args.totalTaskCount}.`;
+  lines.push(sessionsLine);
   return lines.join("\n");
 }
-function shortDecisionSessionId(sessionId) {
+function suspectLabel(reason) {
+  if (reason === "events_say_ended_but_yaml_running") return " \u26A0 ended (yaml stale)";
+  if (reason === "running_no_end_event") return " \u26A0 no end event";
+  return "";
+}
+function shortHandoffId(sessionId) {
   const SES = "ses_";
   if (sessionId.startsWith(SES)) return sessionId.slice(SES.length, SES.length + 10);
   return sessionId.slice(0, 10);
 }
+function shortIdWithPrefix(id) {
+  const sep = id.indexOf("_");
+  if (sep === -1) return id.slice(0, 10);
+  return id.slice(0, sep + 1) + id.slice(sep + 1, sep + 1 + 10);
+}
+
+// src/lib/duration.ts
+var DURATION_RE = /^([1-9]\d*)(ms|s|m|h)$/;
+function parseDuration(input) {
+  const trimmed = input.trim();
+  const match = DURATION_RE.exec(trimmed);
+  if (!match) {
+    throw new Error(
+      `Invalid duration: ${trimmed}. Expected format: <positive-integer><unit> where unit is ms/s/m/h`
+    );
+  }
+  const value = Number(match[1]);
+  const unit = match[2];
+  let ms;
+  switch (unit) {
+    case "ms":
+      ms = value;
+      break;
+    case "s":
+      ms = value * 1e3;
+      break;
+    case "m":
+      ms = value * 6e4;
+      break;
+    case "h":
+      ms = value * 36e5;
+      break;
+    default:
+      throw new Error(`Invalid duration unit: ${unit}`);
+  }
+  if (!Number.isFinite(ms)) {
+    throw new Error(`Duration overflow: ${trimmed}`);
+  }
+  return ms;
+}
+
+// src/lib/id-resolver.ts
+async function resolveSessionId(paths, input) {
+  return resolveIdInternal(paths, input, "session");
+}
+async function resolveTaskId(paths, input, options = {}) {
+  return resolveIdInternal(paths, input, "task", options);
+}
+var KIND_CONFIG = {
+  session: {
+    prefix: "ses_",
+    noun: "session",
+    nounPlural: "sessions",
+    capNoun: "Session",
+    enumerate: enumerateSessionDirs
+  },
+  task: {
+    prefix: "task_",
+    noun: "task",
+    nounPlural: "tasks",
+    capNoun: "Task",
+    enumerate: enumerateTaskIds
+  }
+};
+async function resolveIdInternal(paths, input, kind, options = {}) {
+  const cfg = KIND_CONFIG[kind];
+  const trimmed = input.trim();
+  if (trimmed.length === 0) {
+    throw new Error(`${cfg.capNoun} id is empty`);
+  }
+  const normalized = trimmed.startsWith(cfg.prefix) ? trimmed : `${cfg.prefix}${trimmed}`;
+  if (normalized.length <= cfg.prefix.length) {
+    throw new Error(`${cfg.capNoun} not found: ${input}`);
+  }
+  const primary = await cfg.enumerate(paths);
+  const merged = new Set(primary);
+  if (kind === "task" && options.includeArchived === true) {
+    for (const id of await enumerateArchivedTaskIds(paths)) {
+      merged.add(id);
+    }
+  }
+  if (merged.size === 0) {
+    throw new Error(`${cfg.capNoun} not found: ${input}`);
+  }
+  const matches = [...merged].filter((e) => e.startsWith(normalized));
+  if (matches.length === 0) {
+    throw new Error(`${cfg.capNoun} not found: ${input}`);
+  }
+  if (matches.length > 1) {
+    throw new Error(
+      `Ambiguous ${cfg.noun} id '${input}': matched ${matches.length} ${cfg.nounPlural}. Disambiguate with a longer prefix.`
+    );
+  }
+  return matches[0];
+}
 
 // src/runtime/child-process-runner.ts
-import { spawn } from "child_process";
+import { spawn as spawn2 } from "child_process";
 var DEFAULT_KILL_GRACE_MS = 5e3;
 var ChildProcessRunner = class {
   async run(command, args, options) {
@@ -3441,7 +3693,7 @@ var ChildProcessRunner = class {
     const started_at = /* @__PURE__ */ new Date();
     let child;
     try {
-      child = spawn(snapshotCommand, [...snapshotArgs], {
+      child = spawn2(snapshotCommand, [...snapshotArgs], {
         cwd: snapshotCwd,
         env: options.env ?? process.env,
         stdio: captureMode === "none" ? ["inherit", "inherit", "inherit"] : ["pipe", "pipe", "pipe"],
@@ -3531,264 +3783,807 @@ var ChildProcessRunner = class {
       });
     });
   }
-};
-function validateOptions(options) {
-  if (options.timeout_ms !== void 0 && (!Number.isFinite(options.timeout_ms) || options.timeout_ms <= 0)) {
-    throw new Error("Invalid timeout_ms");
+};
+function validateOptions(options) {
+  if (options.timeout_ms !== void 0 && (!Number.isFinite(options.timeout_ms) || options.timeout_ms <= 0)) {
+    throw new Error("Invalid timeout_ms");
+  }
+  if (options.capture === "none" && options.stdin !== void 0) {
+    throw new Error('Combination of capture: "none" and stdin is not supported');
+  }
+}
+function classifySpawnError(error) {
+  if (findErrorCode(error, "ENOENT")) {
+    return new Error("Command not found", { cause: error });
+  }
+  return new Error("Failed to spawn child process", { cause: error });
+}
+
+// src/schemas/manifest.schema.ts
+import { z as z9 } from "zod";
+var ProjectSchema = z9.object({
+  name: z9.string().optional(),
+  description: z9.string().optional(),
+  repository_url: z9.string().nullable().optional()
+});
+var CapabilitiesSchema = z9.object({
+  enabled: z9.array(z9.string())
+});
+var ApprovalConfigSchema = z9.object({
+  required_for: z9.array(z9.string()).optional(),
+  default_risk_level: z9.enum(["low", "medium", "high", "critical"])
+});
+var ClaudeCodeAdapterConfigSchema = z9.object({
+  enabled: z9.boolean(),
+  config_path: z9.string().optional()
+});
+var AdaptersSchema = z9.object({
+  "claude-code": ClaudeCodeAdapterConfigSchema
+});
+var GitConfigSchema = z9.object({
+  events_log: z9.enum(["ignore", "commit"]).default("ignore")
+});
+var WorkspaceMetaSchema = z9.object({
+  id: WorkspaceIdSchema,
+  name: z9.string().min(1),
+  created_at: IsoTimestampSchema,
+  updated_at: IsoTimestampSchema
+});
+var ManifestSchema = z9.object({
+  schema_version: SchemaVersionSchema,
+  basou_version: z9.literal("0.1.0"),
+  workspace: WorkspaceMetaSchema,
+  project: ProjectSchema,
+  capabilities: CapabilitiesSchema,
+  approval: ApprovalConfigSchema,
+  adapters: AdaptersSchema,
+  git: GitConfigSchema
+});
+
+// src/schemas/session-import.schema.ts
+import { z as z10 } from "zod";
+var SessionInnerImportSchema = z10.object({
+  id: SessionIdSchema.optional(),
+  label: z10.string().optional(),
+  task_id: TaskIdSchema.nullable().optional(),
+  workspace_id: WorkspaceIdSchema,
+  source: z10.object({
+    kind: SessionSourceKindSchema,
+    version: z10.literal("0.1.0"),
+    // Source-tool-native id (e.g. Claude Code session UUID), retained so
+    // re-imports of the same source can be deduplicated.
+    external_id: z10.string().optional()
+  }),
+  started_at: IsoTimestampSchema,
+  ended_at: IsoTimestampSchema.optional(),
+  status: SessionStatusSchema,
+  working_directory: z10.string().min(1),
+  invocation: z10.object({
+    command: z10.string().min(1),
+    args: z10.array(z10.string()),
+    exit_code: z10.number().int().nullable()
+  }),
+  related_files: z10.array(z10.string()).default([]),
+  events_log: z10.string().optional(),
+  summary: z10.string().nullable().optional(),
+  metrics: SessionMetricsSchema.optional()
+}).strict();
+var SessionImportPayloadSchema = z10.object({
+  schema_version: z10.string(),
+  session: SessionInnerImportSchema,
+  events: z10.array(EventSchema)
+}).strict();
+
+// src/stats/work-stats.ts
+import { join as join11 } from "path";
+function resolveTimeZone(timeZone) {
+  if (timeZone !== void 0 && timeZone.length > 0) return timeZone;
+  return Intl.DateTimeFormat().resolvedOptions().timeZone;
+}
+var STATUS_ORDER = [
+  "completed",
+  "failed",
+  "running",
+  "interrupted",
+  "waiting_approval",
+  "initialized",
+  "imported",
+  "archived"
+];
+async function computeWorkStats(input) {
+  const { now } = input;
+  const timeZone = resolveTimeZone(input.timeZone);
+  const unreadableEmitted = /* @__PURE__ */ new Set();
+  const wrappedSkip = (sid, reason) => {
+    if (reason === "events_jsonl_unreadable") unreadableEmitted.add(sid);
+    input.onSessionSkip?.(sid, reason);
+  };
+  const loadOpts = { now, onSkip: wrappedSkip };
+  if (input.onWarning !== void 0) loadOpts.onWarning = input.onWarning;
+  const entries = await loadSessionEntries(input.paths, loadOpts);
+  const sessions = [];
+  for (const entry of entries) {
+    const events = [];
+    let eventsUnreadable = false;
+    try {
+      for await (const ev of replayEvents(join11(input.paths.sessions, entry.sessionId), {
+        onWarning: (w) => input.onWarning?.(w, entry.sessionId)
+      })) {
+        events.push(ev);
+      }
+    } catch {
+      eventsUnreadable = true;
+      if (!unreadableEmitted.has(entry.sessionId)) {
+        wrappedSkip(entry.sessionId, "events_jsonl_unreadable");
+      }
+    }
+    sessions.push(
+      sessionWorkStatsFromEvents(
+        entry.sessionId,
+        entry.session.session,
+        events,
+        now,
+        eventsUnreadable
+      )
+    );
+  }
+  const allIntervals = [];
+  for (const s of sessions) allIntervals.push(...intervalsIsoToMs(s.activeIntervals));
+  const union = unionDurationMs(allIntervals);
+  return {
+    generatedAt: now.toISOString(),
+    activeGapCapMs: ACTIVE_GAP_CAP_MS,
+    timeZone,
+    totals: computeTotals(sessions, union.ms),
+    sessions,
+    bySource: computeBySource(sessions),
+    byStatus: computeByStatus(sessions),
+    byDay: computeByDay(sessions, union.merged, timeZone)
+  };
+}
+function sessionWorkStatsFromEvents(sessionId, inner, events, now, eventsUnreadable = false) {
+  let commandCount = 0;
+  let fileChangedCount = 0;
+  let decisionCount = 0;
+  let commandTimeMs = 0;
+  const timestamps = [];
+  for (const ev of events) {
+    const t = Date.parse(ev.occurred_at);
+    if (Number.isFinite(t)) timestamps.push(t);
+    if (ev.type === "command_executed") {
+      commandCount++;
+      commandTimeMs += ev.duration_ms;
+    } else if (ev.type === "file_changed") {
+      fileChangedCount++;
+    } else if (ev.type === "decision_recorded") {
+      decisionCount++;
+    }
+  }
+  const span = computeSpan(inner.started_at, inner.ended_at, now);
+  const tokens = readTokens(inner.metrics);
+  const active = resolveActiveTime(inner.metrics, timestamps);
+  return {
+    sessionId,
+    label: inner.label,
+    status: inner.status,
+    sourceKind: inner.source.kind,
+    startedAt: inner.started_at,
+    endedAt: inner.ended_at,
+    open: inner.ended_at === void 0,
+    sessionSpanMs: span.ms,
+    commandTimeMs,
+    activeTimeMs: active.ms,
+    activeTimeBasis: active.basis,
+    activeIntervals: intervalsMsToIso(active.intervals),
+    commandCount,
+    fileChangedCount,
+    decisionCount,
+    eventCount: events.length,
+    tokens,
+    availability: {
+      span: true,
+      commandTime: inner.source.kind !== "claude-code-import",
+      activeTime: active.intervals.length > 0,
+      tokens: hasTokens(tokens)
+    },
+    spanClamped: span.clamped,
+    eventsUnreadable
+  };
+}
+function resolveActiveTime(metrics, eventTimestamps) {
+  const stored = metrics?.active_intervals;
+  if (stored !== void 0 && stored.length > 0) {
+    const intervals = intervalsIsoToMs(stored);
+    const ms = intervals.reduce((n, [start, end]) => n + (end - start), 0);
+    return { ms, intervals, basis: "engaged-turns" };
+  }
+  const derived = activeTimeFromTimestamps(eventTimestamps, ACTIVE_GAP_CAP_MS);
+  return { ms: derived.ms, intervals: derived.intervals, basis: "events" };
+}
+function computeSpan(startedAt, endedAt, now) {
+  const start = Date.parse(startedAt);
+  const end = endedAt !== void 0 ? Date.parse(endedAt) : now.getTime();
+  if (!Number.isFinite(start) || !Number.isFinite(end)) return { ms: 0, clamped: true };
+  const raw = end - start;
+  return raw < 0 ? { ms: 0, clamped: true } : { ms: raw, clamped: false };
+}
+function readTokens(metrics) {
+  return {
+    output: metrics?.output_tokens ?? 0,
+    input: metrics?.input_tokens ?? 0,
+    cached: metrics?.cached_input_tokens ?? 0,
+    reasoning: metrics?.reasoning_output_tokens ?? 0
+  };
+}
+function hasTokens(t) {
+  return t.output > 0 || t.input > 0 || t.cached > 0 || t.reasoning > 0;
+}
+function emptyTokens() {
+  return { output: 0, input: 0, cached: 0, reasoning: 0 };
+}
+function addTokens(a, b) {
+  a.output += b.output;
+  a.input += b.input;
+  a.cached += b.cached;
+  a.reasoning += b.reasoning;
+}
+function computeTotals(sessions, billableActiveTimeMs) {
+  const tokens = emptyTokens();
+  const totals = {
+    sessionCount: sessions.length,
+    openSessionCount: 0,
+    sessionSpanMs: 0,
+    commandTimeMs: 0,
+    activeTimeMs: 0,
+    billableActiveTimeMs,
+    commandCount: 0,
+    fileChangedCount: 0,
+    decisionCount: 0,
+    eventCount: 0,
+    tokens,
+    commandTimeReliable: true,
+    tokensAvailable: false
+  };
+  for (const s of sessions) {
+    if (s.open) totals.openSessionCount++;
+    totals.sessionSpanMs += s.sessionSpanMs;
+    totals.commandTimeMs += s.commandTimeMs;
+    totals.activeTimeMs += s.activeTimeMs;
+    totals.commandCount += s.commandCount;
+    totals.fileChangedCount += s.fileChangedCount;
+    totals.decisionCount += s.decisionCount;
+    totals.eventCount += s.eventCount;
+    addTokens(tokens, s.tokens);
+    if (!s.availability.commandTime) totals.commandTimeReliable = false;
+    if (s.availability.tokens) totals.tokensAvailable = true;
+  }
+  return totals;
+}
+function computeBySource(sessions) {
+  const map = /* @__PURE__ */ new Map();
+  for (const s of sessions) {
+    let row = map.get(s.sourceKind);
+    if (row === void 0) {
+      row = {
+        sourceKind: s.sourceKind,
+        sessionCount: 0,
+        sessionSpanMs: 0,
+        commandTimeMs: 0,
+        activeTimeMs: 0,
+        commandCount: 0,
+        fileChangedCount: 0,
+        decisionCount: 0,
+        eventCount: 0,
+        tokens: emptyTokens(),
+        commandTimeReliable: true,
+        tokensAvailable: false
+      };
+      map.set(s.sourceKind, row);
+    }
+    row.sessionCount++;
+    row.sessionSpanMs += s.sessionSpanMs;
+    row.commandTimeMs += s.commandTimeMs;
+    row.activeTimeMs += s.activeTimeMs;
+    row.commandCount += s.commandCount;
+    row.fileChangedCount += s.fileChangedCount;
+    row.decisionCount += s.decisionCount;
+    row.eventCount += s.eventCount;
+    addTokens(row.tokens, s.tokens);
+    if (!s.availability.commandTime) row.commandTimeReliable = false;
+    if (s.availability.tokens) row.tokensAvailable = true;
+  }
+  return [...map.values()].sort((a, b) => a.sourceKind.localeCompare(b.sourceKind));
+}
+function computeByStatus(sessions) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const s of sessions) counts.set(s.status, (counts.get(s.status) ?? 0) + 1);
+  const ordered = [];
+  for (const status of STATUS_ORDER) {
+    const count = counts.get(status);
+    if (count !== void 0 && count > 0) ordered.push({ status, count });
+  }
+  return ordered;
+}
+function computeByDay(sessions, unionMerged, timeZone) {
+  const days = /* @__PURE__ */ new Map();
+  const ensure = (date) => {
+    let day = days.get(date);
+    if (day === void 0) {
+      day = {
+        date,
+        billableActiveTimeMs: 0,
+        sessionCount: 0,
+        commandCount: 0,
+        fileChangedCount: 0,
+        decisionCount: 0,
+        tokens: emptyTokens()
+      };
+      days.set(date, day);
+    }
+    return day;
+  };
+  for (const [start, end] of unionMerged) {
+    ensure(tzDate(start, timeZone)).billableActiveTimeMs += end - start;
+  }
+  for (const s of sessions) {
+    const startedMs = Date.parse(s.startedAt);
+    if (!Number.isFinite(startedMs)) continue;
+    const day = ensure(tzDate(startedMs, timeZone));
+    day.sessionCount++;
+    day.commandCount += s.commandCount;
+    day.fileChangedCount += s.fileChangedCount;
+    day.decisionCount += s.decisionCount;
+    addTokens(day.tokens, s.tokens);
+  }
+  return [...days.values()].sort((a, b) => a.date.localeCompare(b.date));
+}
+function tzDate(ms, timeZone) {
+  return new Intl.DateTimeFormat("en-CA", {
+    timeZone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit"
+  }).format(new Date(ms));
+}
+
+// src/storage/basou-dir.ts
+import { lstat as lstat3, mkdir as mkdir3 } from "fs/promises";
+import { join as join12 } from "path";
+function basouPaths(repositoryRoot) {
+  const root = join12(repositoryRoot, ".basou");
+  const approvalsBase = join12(root, "approvals");
+  return {
+    root,
+    sessions: join12(root, "sessions"),
+    tasks: join12(root, "tasks"),
+    approvals: {
+      pending: join12(approvalsBase, "pending"),
+      resolved: join12(approvalsBase, "resolved")
+    },
+    locks: join12(root, "locks"),
+    logs: join12(root, "logs"),
+    raw: join12(root, "raw"),
+    tmp: join12(root, "tmp"),
+    files: {
+      manifest: join12(root, "manifest.yaml"),
+      status: join12(root, "status.json"),
+      handoff: join12(root, "handoff.md"),
+      decisions: join12(root, "decisions.md")
+    }
+  };
+}
+var PATH_LABELS = {
+  sessions: ".basou/sessions",
+  tasks: ".basou/tasks",
+  approvalsPending: ".basou/approvals/pending",
+  approvalsResolved: ".basou/approvals/resolved",
+  locks: ".basou/locks",
+  logs: ".basou/logs",
+  raw: ".basou/raw",
+  tmp: ".basou/tmp"
+};
+async function ensureBasouDirectory(repositoryRoot) {
+  const paths = basouPaths(repositoryRoot);
+  let existing;
+  try {
+    existing = await lstat3(paths.root);
+  } catch (error) {
+    if (!hasErrorCode3(error) || error.code !== "ENOENT") {
+      throw new Error("Failed to inspect .basou directory", { cause: error });
+    }
+  }
+  if (existing !== void 0 && !existing.isDirectory()) {
+    throw new Error("Basou root .basou exists but is not a directory");
+  }
+  await Promise.all([
+    mkdirLabeled(paths.sessions, PATH_LABELS.sessions),
+    mkdirLabeled(paths.tasks, PATH_LABELS.tasks),
+    mkdirLabeled(paths.approvals.pending, PATH_LABELS.approvalsPending),
+    mkdirLabeled(paths.approvals.resolved, PATH_LABELS.approvalsResolved),
+    mkdirLabeled(paths.locks, PATH_LABELS.locks),
+    mkdirLabeled(paths.logs, PATH_LABELS.logs),
+    mkdirLabeled(paths.raw, PATH_LABELS.raw),
+    mkdirLabeled(paths.tmp, PATH_LABELS.tmp)
+  ]);
+  return paths;
+}
+async function mkdirLabeled(target, label) {
+  try {
+    await mkdir3(target, { recursive: true });
+  } catch (error) {
+    if (hasErrorCode3(error) && (error.code === "ENOTDIR" || error.code === "EEXIST")) {
+      throw new Error(`${label} exists but is not a directory`, { cause: error });
+    }
+    throw new Error(`Failed to create ${label}`, { cause: error });
+  }
+}
+function hasErrorCode3(error) {
+  if (!(error instanceof Error)) return false;
+  const codeProp = error.code;
+  return typeof codeProp === "string";
+}
+
+// src/storage/gitignore.ts
+import { readFile as readFile6, writeFile as writeFile2 } from "fs/promises";
+import { join as join13 } from "path";
+var MARKER = "# Basou - default ignore";
+var BASOU_GITIGNORE_BLOCK = "# Basou - default ignore\n.basou/logs/\n.basou/raw/\n.basou/tmp/\n.basou/locks/\n.basou/status.json\n.basou/sessions/*/events.jsonl\n.basou/sessions/*/artifacts/\n.basou/approvals/pending/\n.basou/approvals/resolved/\n\n# Basou - default commit\n# .basou/manifest.yaml\n# .basou/handoff.md\n# .basou/decisions.md\n# .basou/tasks/\n# .basou/sessions/*/session.yaml\n# .basou/sessions/*/transcript.md\n# .basou/sessions/*/changed-files.json\n";
+async function appendBasouGitignore(repositoryRoot) {
+  const gitignorePath = join13(repositoryRoot, ".gitignore");
+  let body;
+  let existed;
+  try {
+    body = await readFile6(gitignorePath, "utf8");
+    existed = true;
+  } catch (error) {
+    if (hasErrorCode4(error) && error.code === "ENOENT") {
+      body = "";
+      existed = false;
+    } else {
+      throw new Error("Failed to read .gitignore", { cause: error });
+    }
   }
-  if (options.capture === "none" && options.stdin !== void 0) {
-    throw new Error('Combination of capture: "none" and stdin is not supported');
+  if (existed && hasBasouMarker(body)) {
+    return { appended: false };
+  }
+  const next = composeNextBody(body);
+  try {
+    await writeFile2(gitignorePath, next, { encoding: "utf8" });
+  } catch (error) {
+    throw new Error("Failed to write .gitignore", { cause: error });
   }
+  return { appended: true };
 }
-function classifySpawnError(error) {
-  if (findErrorCode(error, "ENOENT")) {
-    return new Error("Command not found", { cause: error });
+function hasBasouMarker(body) {
+  for (const rawLine of body.split("\n")) {
+    if (rawLine.trimEnd().startsWith(MARKER)) return true;
   }
-  return new Error("Failed to spawn child process", { cause: error });
+  return false;
 }
-
-// src/git/snapshot.ts
-import { simpleGit } from "simple-git";
-function safeSimpleGit(repoRoot) {
-  return simpleGit({ baseDir: repoRoot });
+function composeNextBody(existing) {
+  if (existing.length === 0) return BASOU_GITIGNORE_BLOCK;
+  const normalized = existing.endsWith("\n") ? existing : `${existing}
+`;
+  return `${normalized}
+${BASOU_GITIGNORE_BLOCK}`;
 }
-function isGitNotFound(error) {
-  if (findErrorCode(error, "ENOENT")) return true;
-  let cur = error;
-  for (let i = 0; i < 4 && cur instanceof Error; i++) {
-    if (/\bENOENT\b/.test(cur.message)) return true;
-    cur = cur.cause;
+function hasErrorCode4(error) {
+  if (!(error instanceof Error)) return false;
+  return typeof error.code === "string";
+}
+
+// src/storage/manifest.ts
+import { lstat as lstat4 } from "fs/promises";
+function createManifest(input) {
+  if (input.workspaceName.length === 0) {
+    throw new Error("Workspace name is empty. Pass --name explicitly.");
   }
-  return false;
+  const now = (input.now ?? /* @__PURE__ */ new Date()).toISOString();
+  const workspaceId = input.workspaceId ?? prefixedUlid("ws");
+  const project = {
+    ...input.projectName !== void 0 ? { name: input.projectName } : {},
+    ...input.projectDescription !== void 0 ? { description: input.projectDescription } : {},
+    ...input.repositoryUrl !== void 0 ? { repository_url: input.repositoryUrl } : {}
+  };
+  const manifest = {
+    schema_version: "0.1.0",
+    basou_version: "0.1.0",
+    workspace: {
+      id: workspaceId,
+      name: input.workspaceName,
+      created_at: now,
+      updated_at: now
+    },
+    project,
+    capabilities: {
+      enabled: ["core", "claude-code-adapter", "terminal-recording", "git-capability", "approval"]
+    },
+    approval: {
+      required_for: ["destructive_command", "external_send"],
+      default_risk_level: "medium"
+    },
+    adapters: {
+      "claude-code": { enabled: true }
+    },
+    git: { events_log: "ignore" }
+  };
+  return ManifestSchema.parse(manifest);
 }
-async function resolveRepositoryRoot(cwd) {
-  const git = safeSimpleGit(cwd);
-  try {
-    const root = (await git.revparse(["--show-toplevel"])).trimEnd();
-    if (root.length === 0) {
-      throw new Error("Not a git repository");
-    }
-    return root;
-  } catch (error) {
-    if (isGitNotFound(error)) {
-      throw new Error("Git executable not found in PATH. Install git first.", { cause: error });
+async function writeManifest(paths, manifest, options) {
+  const force = options?.force === true;
+  const validated = ManifestSchema.parse(manifest);
+  if (!force) {
+    let existed = false;
+    try {
+      await lstat4(paths.files.manifest);
+      existed = true;
+    } catch (error) {
+      if (!hasErrorCode5(error) || error.code !== "ENOENT") {
+        throw new Error("Failed to inspect existing manifest", { cause: error });
+      }
     }
-    if (error instanceof Error && error.message === "Not a git repository") {
-      throw error;
+    if (existed) {
+      throw new Error("Already initialized. Use --force to overwrite.");
     }
-    throw new Error("Not a git repository", { cause: error });
   }
+  await writeYamlFile(paths.files.manifest, validated);
 }
-async function tryRemoteUrl(repositoryRoot) {
-  const git = safeSimpleGit(repositoryRoot);
+async function readManifest(paths) {
+  const raw = await readYamlFile(paths.files.manifest);
+  return ManifestSchema.parse(raw);
+}
+function hasErrorCode5(error) {
+  if (!(error instanceof Error)) return false;
+  return typeof error.code === "string";
+}
+
+// src/storage/markdown-store.ts
+import { readFile as readFile7 } from "fs/promises";
+var GENERATED_START = "<!-- BASOU:GENERATED:START -->";
+var GENERATED_END = "<!-- BASOU:GENERATED:END -->";
+async function readMarkdownFile(filePath) {
   try {
-    const result = await git.getConfig("remote.origin.url", "local");
-    const url = (result.value ?? "").trimEnd();
-    return url.length > 0 ? url : void 0;
-  } catch {
-    return void 0;
+    return await readFile7(filePath, "utf8");
+  } catch (error) {
+    if (hasErrorCode6(error) && error.code === "ENOENT") return null;
+    throw new Error("Failed to read markdown file", { cause: error });
   }
 }
-async function getSnapshot(repositoryRoot) {
-  const git = safeSimpleGit(repositoryRoot);
-  let inside;
+async function writeMarkdownFile(filePath, body) {
   try {
-    inside = await git.checkIsRepo();
+    await atomicReplace(filePath, body);
   } catch (error) {
-    if (isGitNotFound(error)) {
-      throw new Error("Git executable not found in PATH. Install git first.", { cause: error });
+    throw new Error("Failed to write markdown file", { cause: error });
+  }
+}
+function parseMarkers(content) {
+  const lines = content.split(/\r?\n/);
+  const startLines = [];
+  const endLines = [];
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i] === GENERATED_START) startLines.push(i);
+    else if (lines[i] === GENERATED_END) endLines.push(i);
+  }
+  if (startLines.length === 0 && endLines.length === 0) return { kind: "no_markers" };
+  if (startLines.length === 0) return { kind: "missing_start" };
+  if (endLines.length === 0) return { kind: "missing_end" };
+  if (startLines.length >= 2 || endLines.length >= 2) return { kind: "multiple_pairs" };
+  const startLineIdx = startLines[0];
+  const endLineIdx = endLines[0];
+  if (endLineIdx < startLineIdx) return { kind: "wrong_order" };
+  const startOffset = lineStartOffset(content, startLineIdx);
+  const endLineStart = lineStartOffset(content, endLineIdx);
+  const startLineEnd = startOffset + GENERATED_START.length;
+  const endLineEnd = endLineStart + GENERATED_END.length;
+  const before = content.slice(0, startOffset);
+  const afterStartNewline = skipOneNewline(content, startLineEnd);
+  const beforeEndNewline = trimOneNewline(content, endLineStart);
+  const generated = content.slice(afterStartNewline, beforeEndNewline);
+  const after = content.slice(endLineEnd);
+  return { kind: "ok", before, generated, after };
+}
+function renderWithMarkers(existing, generated, fileLabel) {
+  const normalized = generated.endsWith("\n") ? generated : `${generated}
+`;
+  if (existing === null) {
+    return `${GENERATED_START}
+${normalized}${GENERATED_END}
+`;
+  }
+  const section = parseMarkers(existing);
+  switch (section.kind) {
+    case "ok":
+      return `${section.before}${GENERATED_START}
+${normalized}${GENERATED_END}${section.after}`;
+    case "no_markers":
+      throw new Error(`Markers missing in ${fileLabel}`);
+    case "missing_start":
+    case "missing_end":
+    case "multiple_pairs":
+    case "wrong_order":
+      throw new Error(`Markers mismatched in ${fileLabel}`);
+  }
+}
+function lineStartOffset(content, lineIdx) {
+  if (lineIdx === 0) return 0;
+  let offset = 0;
+  let line = 0;
+  while (offset < content.length && line < lineIdx) {
+    const ch = content[offset];
+    if (ch === "\n") {
+      line += 1;
+      offset += 1;
+    } else if (ch === "\r") {
+      offset += 1;
+      if (content[offset] === "\n") offset += 1;
+      line += 1;
+    } else {
+      offset += 1;
     }
-    throw new Error("Failed to read git state", { cause: error });
   }
-  if (!inside) {
-    throw new Error("Not a git repository");
+  return offset;
+}
+function skipOneNewline(content, offset) {
+  if (content[offset] === "\r" && content[offset + 1] === "\n") return offset + 2;
+  if (content[offset] === "\n") return offset + 1;
+  return offset;
+}
+function trimOneNewline(content, offset) {
+  if (offset >= 2 && content[offset - 2] === "\r" && content[offset - 1] === "\n")
+    return offset - 2;
+  if (offset >= 1 && content[offset - 1] === "\n") return offset - 1;
+  return offset;
+}
+function hasErrorCode6(error) {
+  if (!(error instanceof Error)) return false;
+  const codeProp = error.code;
+  return typeof codeProp === "string";
+}
+
+// src/storage/session-import.ts
+import { mkdir as mkdir4, rm as rm2 } from "fs/promises";
+import { homedir as homedir2 } from "os";
+import { join as join14 } from "path";
+async function importSessionFromJson(paths, manifest, payload, options) {
+  if (options.taskIdOverride !== void 0 && !TaskIdSchema.safeParse(options.taskIdOverride).success) {
+    throw new Error(`Invalid task_id: ${options.taskIdOverride}`);
+  }
+  const effectiveSessionTaskId = options.taskIdOverride ?? payload.session.task_id ?? null;
+  await assertImportedTaskReferencesAreReachable(paths, payload.events, effectiveSessionTaskId);
+  const newSessionId = prefixedUlid("ses");
+  const rewrittenEvents = rewriteEvents(payload.events, newSessionId);
+  assertChronologicalOrder(rewrittenEvents);
+  const { record: sessionRecord, pathSanitizeReport } = buildSessionRecord(
+    payload.session,
+    manifest,
+    newSessionId,
+    options
+  );
+  if (options.dryRun === true) {
+    return {
+      sessionId: newSessionId,
+      eventCount: rewrittenEvents.length,
+      finalStatus: "imported",
+      finalSourceKind: sessionRecord.session.source.kind,
+      pathSanitizeReport
+    };
   }
-  let head;
+  const sessionDir = join14(paths.sessions, newSessionId);
   try {
-    head = (await git.revparse(["HEAD"])).trimEnd();
+    await mkdir4(sessionDir, { recursive: true });
   } catch (error) {
-    if (isGitNotFound(error)) {
-      throw new Error("Git executable not found in PATH. Install git first.", { cause: error });
-    }
-    throw new Error("No commits in repository", { cause: error });
-  }
-  if (head.length === 0) {
-    throw new Error("No commits in repository");
+    throw new Error("Failed to create session directory", { cause: error });
   }
-  let branch;
   try {
-    const raw = (await git.raw(["branch", "--show-current"])).trimEnd();
-    branch = raw.length > 0 ? raw : "HEAD";
+    await writeEventsBulk(sessionDir, rewrittenEvents);
   } catch (error) {
-    throw new Error("Failed to read git state", { cause: error });
+    await rm2(sessionDir, { recursive: true, force: true }).catch(() => void 0);
+    throw error;
   }
-  let dirty;
-  const staged = [];
-  const unstaged = [];
-  const untracked = [];
   try {
-    const status = await git.status();
-    dirty = !status.isClean();
-    for (const f of status.files) {
-      if (f.index === "?" && f.working_dir === "?") {
-        untracked.push(f.path);
-        continue;
-      }
-      if (f.index !== " " && f.index !== "?") staged.push(f.path);
-      if (f.working_dir !== " " && f.working_dir !== "?") unstaged.push(f.path);
-    }
+    const sessionYamlPath = join14(sessionDir, "session.yaml");
+    await linkYamlFile(sessionYamlPath, sessionRecord);
   } catch (error) {
-    throw new Error("Failed to read git state", { cause: error });
-  }
-  let ahead;
-  let behind;
-  if (branch !== "HEAD") {
-    try {
-      const upstream = `${branch}@{upstream}`;
-      const counts = (await git.raw(["rev-list", "--left-right", "--count", `${upstream}...HEAD`])).trim();
-      const [behindStr, aheadStr] = counts.split(/\s+/);
-      const parsedBehind = Number.parseInt(behindStr ?? "", 10);
-      const parsedAhead = Number.parseInt(aheadStr ?? "", 10);
-      if (Number.isFinite(parsedBehind) && parsedBehind >= 0) behind = parsedBehind;
-      if (Number.isFinite(parsedAhead) && parsedAhead >= 0) ahead = parsedAhead;
-    } catch {
+    await rm2(sessionDir, { recursive: true, force: true }).catch(() => void 0);
+    if (findErrorCode(error, "EEXIST")) {
+      throw new Error("Session directory collision (retry the command)", {
+        cause: error
+      });
     }
+    throw error;
   }
-  const snapshot = {
-    head,
-    branch,
-    dirty,
-    staged,
-    unstaged,
-    untracked,
-    ...ahead !== void 0 ? { ahead } : {},
-    ...behind !== void 0 ? { behind } : {}
+  return {
+    sessionId: newSessionId,
+    eventCount: rewrittenEvents.length,
+    finalStatus: "imported",
+    finalSourceKind: sessionRecord.session.source.kind,
+    pathSanitizeReport
   };
-  return snapshot;
 }
-
-// src/git/diff.ts
-async function getDiff(repoRoot, baseRef, headRef) {
-  let git;
-  try {
-    git = safeSimpleGit(repoRoot);
-  } catch (error) {
-    if (isGitNotFound(error)) {
-      throw new Error("Git executable not found in PATH. Install git first.", { cause: error });
+async function assertImportedTaskReferencesAreReachable(paths, events, effectiveSessionTaskId) {
+  const taskIdsToCheck = /* @__PURE__ */ new Set();
+  for (const ev of events) {
+    if (ev.type === "task_created" || ev.type === "task_status_changed" || ev.type === "task_reconciled" || ev.type === "task_linkage_refreshed" || ev.type === "task_deleted" || ev.type === "task_archived") {
+      taskIdsToCheck.add(ev.task_id);
     }
-    throw new Error("Not a git repository", { cause: error });
   }
-  if (baseRef === headRef) return { changed_files: [] };
-  let raw;
-  try {
-    raw = await git.raw(["diff", "--name-status", `${baseRef}..${headRef}`]);
-  } catch (error) {
-    if (isGitNotFound(error)) {
-      throw new Error("Git executable not found in PATH. Install git first.", { cause: error });
-    }
-    const message = error instanceof Error ? error.message : "";
-    if (/not a git repository/i.test(message)) {
-      throw new Error("Not a git repository", { cause: error });
-    }
-    if (message.includes("bad revision") || message.includes("unknown revision") || message.includes("ambiguous argument")) {
-      throw new Error("Invalid ref", { cause: error });
-    }
-    throw new Error("Failed to compute git diff", { cause: error });
+  if (effectiveSessionTaskId !== null) {
+    taskIdsToCheck.add(effectiveSessionTaskId);
   }
-  return { changed_files: parseDiffNameStatus(raw) };
-}
-function parseDiffNameStatus(raw) {
-  const lines = raw.split("\n").filter((l) => l.trim() !== "");
-  const changes = [];
-  for (const line of lines) {
-    const parts = line.split("	");
-    const code = parts[0];
-    if (code === void 0 || code.length === 0) continue;
-    if (code.startsWith("R") && parts.length >= 3) {
-      const newPath = parts[2];
-      const oldPath = parts[1];
-      if (newPath === void 0) continue;
-      changes.push({
-        path: newPath,
-        status: "renamed",
-        ...oldPath !== void 0 ? { old_path: oldPath } : {}
-      });
-    } else if (code === "A" && parts[1]) {
-      changes.push({ path: parts[1], status: "added" });
-    } else if (code === "M" && parts[1]) {
-      changes.push({ path: parts[1], status: "modified" });
-    } else if (code === "D" && parts[1]) {
-      changes.push({ path: parts[1], status: "deleted" });
+  if (taskIdsToCheck.size === 0) {
+    return;
+  }
+  const knownTaskIds = new Set(await enumerateTaskIds(paths));
+  for (const id of taskIdsToCheck) {
+    if (!knownTaskIds.has(id)) {
+      throw new Error("Imported session references unknown task_id");
     }
   }
-  return changes;
 }
-
-// src/adapters/claude-code/claude-code-adapter.ts
-import { spawn as spawn2 } from "child_process";
-var claudeCodeAdapterMetadata = {
-  kind: "claude-code-adapter",
-  version: "0.1.0"
-};
-async function resolveClaudeCodeCommand(lookup = isOnPath) {
-  for (const candidate of ["claude-code", "claude"]) {
-    if (await lookup(candidate)) return { command: candidate };
+function rewriteEvents(events, newSessionId) {
+  return events.map((event) => ({
+    ...event,
+    id: prefixedUlid("evt"),
+    session_id: newSessionId
+  }));
+}
+function assertChronologicalOrder(events) {
+  for (let i = 1; i < events.length; i++) {
+    const prevEvent = events[i - 1];
+    const currEvent = events[i];
+    if (prevEvent === void 0 || currEvent === void 0) continue;
+    const prev = Date.parse(prevEvent.occurred_at);
+    const curr = Date.parse(currEvent.occurred_at);
+    if (!Number.isFinite(prev) || !Number.isFinite(curr) || curr < prev) {
+      throw new Error("Events are not in chronological order");
+    }
   }
-  throw new Error("Claude Code CLI not found in PATH. Install claude-code (or claude) first.");
 }
-async function isOnPath(command) {
-  return new Promise((resolve2) => {
-    const child = spawn2("which", [command], { stdio: "ignore" });
-    child.on("error", () => resolve2(false));
-    child.on("exit", (code) => resolve2(code === 0));
+function buildSessionRecord(input, manifest, newSessionId, options) {
+  const home = homedir2();
+  const workingDirectoryRaw = input.working_directory;
+  const workingDirectorySanitized = sanitizeWorkingDirectory(workingDirectoryRaw, {
+    homedir: home
   });
-}
-function summarizeAdapterOutput(_stream, _raw) {
-  throw new Error("adapter_output summary is not implemented in v0.1 Step 11");
-}
-
-// src/lib/duration.ts
-var DURATION_RE = /^([1-9]\d*)(ms|s|m|h)$/;
-function parseDuration(input) {
-  const trimmed = input.trim();
-  const match = DURATION_RE.exec(trimmed);
-  if (!match) {
-    throw new Error(
-      `Invalid duration: ${trimmed}. Expected format: <positive-integer><unit> where unit is ms/s/m/h`
-    );
-  }
-  const value = Number(match[1]);
-  const unit = match[2];
-  let ms;
-  switch (unit) {
-    case "ms":
-      ms = value;
-      break;
-    case "s":
-      ms = value * 1e3;
-      break;
-    case "m":
-      ms = value * 6e4;
-      break;
-    case "h":
-      ms = value * 36e5;
-      break;
-    default:
-      throw new Error(`Invalid duration unit: ${unit}`);
-  }
-  if (!Number.isFinite(ms)) {
-    throw new Error(`Duration overflow: ${trimmed}`);
-  }
-  return ms;
+  const relatedSanitized = sanitizeRelatedFiles(input.related_files, {
+    workingDirectory: workingDirectoryRaw,
+    homedir: home
+  });
+  const inner = {
+    id: newSessionId,
+    ...options.labelOverride !== void 0 || input.label !== void 0 ? { label: options.labelOverride ?? input.label } : {},
+    task_id: options.taskIdOverride !== void 0 ? options.taskIdOverride : input.task_id ?? null,
+    workspace_id: manifest.workspace.id,
+    source: input.source,
+    started_at: input.started_at,
+    ...input.ended_at !== void 0 ? { ended_at: input.ended_at } : {},
+    status: "imported",
+    working_directory: workingDirectorySanitized,
+    invocation: input.invocation,
+    related_files: relatedSanitized.sanitized,
+    events_log: "events.jsonl",
+    summary: input.summary ?? null,
+    ...input.metrics !== void 0 ? { metrics: input.metrics } : {}
+  };
+  return {
+    record: { schema_version: "0.1.0", session: inner },
+    pathSanitizeReport: {
+      relatedFiles: relatedSanitized.mutationCount,
+      workingDirectoryRewritten: workingDirectorySanitized !== workingDirectoryRaw
+    }
+  };
 }
 
 // src/index.ts
 var BASOU_CORE_VERSION = "0.1.0";
 export {
+  ACTIVE_GAP_CAP_MS,
   ApprovalIdSchema,
   ApprovalSchema,
   ApprovalStatusSchema,
   BASOU_CORE_VERSION,
+  CLAUDE_IMPORT_SOURCE,
+  CODEX_IMPORT_SOURCE,
   ChildProcessRunner,
   DecisionIdSchema,
   EventIdSchema,
@@ -3806,6 +4601,7 @@ export {
   SessionIdSchema,
   SessionImportPayloadSchema,
   SessionInnerImportSchema,
+  SessionMetricsSchema,
   SessionSchema,
   SessionSourceKindSchema,
   SessionStatusSchema,
@@ -3825,6 +4621,9 @@ export {
   buildStatusSnapshot,
   classifySuspect,
   claudeCodeAdapterMetadata,
+  claudeTranscriptToImportPayload,
+  codexRolloutToImportPayload,
+  computeWorkStats,
   createAdHocSessionWithEvent,
   createManifest,
   createTaskWithEvent,
@@ -3871,6 +4670,7 @@ export {
   sanitizePath,
   sanitizeRelatedFiles,
   sanitizeWorkingDirectory,
+  sessionWorkStatsFromEvents,
   summarizeAdapterOutput,
   tryRemoteUrl,
   ulid,