@basou/core 0.3.1 → 0.4.0

package/dist/index.js

@@ -1,3 +1,47 @@
+// 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/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";
+
 // src/ids/ulid.ts
 import { isValid as isValidUlid, monotonicFactory } from "ulid";
 var ID_PREFIXES = Object.freeze(["ws", "task", "ses", "evt", "appr", "decision"]);
@@ -24,7 +68,6 @@ function isValidPrefixedId(value) {
 }
 
 // src/schemas/shared.schema.ts
-import { z } from "zod";
 var SchemaVersionSchema = z.literal("0.1.0");
 var IsoTimestampSchema = z.string().datetime({ offset: true });
 var createPrefixedIdSchema = (prefix) => {
@@ -40,395 +83,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({
-  schema_version: SchemaVersionSchema,
-  basou_version: z2.literal("0.1.0"),
-  workspace: WorkspaceMetaSchema,
-  project: ProjectSchema,
-  capabilities: CapabilitiesSchema,
-  approval: ApprovalConfigSchema,
-  adapters: AdaptersSchema,
-  git: GitConfigSchema
-});
-
-// 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({
+var ApprovalStatusSchema = z2.enum(["pending", "approved", "rejected", "expired"]);
+var ApprovalSchema = z2.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(),
+  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: z7.string().nullable().default(null),
+  resolver: z2.string().nullable().default(null),
   resolved_at: IsoTimestampSchema.nullable().default(null),
-  note: z7.string().nullable().default(null),
-  rejection_reason: z7.string().nullable().default(null)
+  note: z2.string().nullable().default(null),
+  rejection_reason: z2.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 +231,566 @@ 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;
+
+// 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 {
-    existing = await lstat(paths.root);
+    stream = createReadStream(filePath, { encoding: "utf8" });
   } catch (error) {
-    if (!hasErrorCode2(error) || error.code !== "ENOENT") {
-      throw new Error("Failed to inspect .basou directory", { cause: 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 });
   }
-  if (existing !== void 0 && !existing.isDirectory()) {
-    throw new Error("Basou root .basou exists but is not a directory");
+  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;
   }
-  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;
+  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 mkdirLabeled(target, label) {
+function processLine(rawLine, lineNo, options) {
+  const trimmed = rawLine.trim();
+  if (trimmed.length === 0) return null;
+  let parsed;
   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 });
+    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 hasErrorCode2(error) {
-  if (!(error instanceof Error)) return false;
-  const codeProp = error.code;
-  return typeof codeProp === "string";
+async function readAllEvents(sessionDir, options = {}) {
+  const out = [];
+  for await (const ev of replayEvents(sessionDir, options)) {
+    out.push(ev);
+  }
+  return out;
 }
 
-// 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 });
-      }
-    }
-    if (existed) {
-      throw new Error("Already initialized. Use --force to overwrite.");
-    }
-  }
-  await writeYamlFile(paths.files.manifest, validated);
-}
-async function readManifest(paths) {
-  const raw = await readYamlFile(paths.files.manifest);
-  return ManifestSchema.parse(raw);
-}
-function hasErrorCode3(error) {
-  if (!(error instanceof Error)) return false;
-  return typeof error.code === "string";
-}
-
-// src/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",
+  "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/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 });
-    }
-    await unlink2(lockPath).catch(() => void 0);
+  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 {
-      await atomicCreate(lockPath, serialised);
-    } catch (retryError) {
-      throw new Error("Lock is held by another process", { cause: retryError });
+      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");
+      }
     }
   }
-  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;
+  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 lstat(abs);
+      exists = true;
+    } catch {
+      exists = false;
     }
-    body = { pid: candidate.pid, acquired_at: candidate.acquired_at };
-  } catch {
-    return true;
+    fileExistenceCache.set(relPath, exists);
+    return exists;
   }
-  const ageMs = Date.now() - Date.parse(body.acquired_at);
-  if (!Number.isFinite(ageMs) || ageMs > STALE_LOCK_MAX_AGE_MS) {
-    return true;
+  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");
   }
-  try {
-    process.kill(body.pid, 0);
-    return false;
-  } catch (error) {
-    if (findErrorCode(error, "ESRCH")) return true;
-    return false;
+  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("");
   }
+  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 +805,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 +821,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 });
@@ -955,336 +861,253 @@ 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;
-}
-
-// src/storage/sessions.ts
-var STUCK_THRESHOLD_MS = 24 * 60 * 60 * 1e3;
-async function enumerateSessionDirs(paths) {
-  try {
-    const dirents = await readdir2(paths.sessions, { withFileTypes: true });
-    return dirents.filter((d) => d.isDirectory()).map((d) => d.name).sort();
-  } catch (error) {
-    if (findErrorCode(error, "ENOENT")) return [];
-    throw new Error("Failed to enumerate sessions", { cause: error });
-  }
-}
-async function readSessionYaml(paths, sessionId) {
-  const filePath = join7(paths.sessions, sessionId, "session.yaml");
-  let raw;
-  try {
-    raw = await readYamlFile(filePath);
-  } catch (error) {
-    if (error instanceof Error && error.message === "YAML file not found") throw error;
-    throw new Error("Failed to read session.yaml", { cause: error });
-  }
-  const result = SessionSchema.safeParse(raw);
-  if (!result.success) {
-    throw new Error("Failed to read session.yaml", { cause: result.error });
-  }
-  return result.data;
-}
-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" };
+  } catch (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 });
   }
-  return { suspect: false, suspectReason: null };
-}
-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 });
+  let parsed;
+  try {
+    parsed = JSON.parse(body);
+  } catch (error) {
+    throw new Error("Failed to parse status JSON", { cause: error });
   }
-  return entries;
+  return StatusSchema.parse(parsed);
+}
+function hasErrorCode2(error) {
+  if (!(error instanceof Error)) return false;
+  return typeof error.code === "string";
 }
 
-// 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) {
-  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 });
+// 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 false;
 }
-async function writeMarkdownFile(filePath, body) {
+async function resolveRepositoryRoot(cwd) {
+  const git = safeSimpleGit(cwd);
   try {
-    await atomicReplace(filePath, body);
+    const root = (await git.revparse(["--show-toplevel"])).trimEnd();
+    if (root.length === 0) {
+      throw new Error("Not a git repository");
+    }
+    return root;
   } 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 });
+    }
+    if (error instanceof Error && error.message === "Not a git repository") {
+      throw error;
+    }
+    throw new Error("Not a git repository", { 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);
+async function tryRemoteUrl(repositoryRoot) {
+  const git = safeSimpleGit(repositoryRoot);
+  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;
   }
-  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}
-`;
+async function getSnapshot(repositoryRoot) {
+  const git = safeSimpleGit(repositoryRoot);
+  let inside;
+  try {
+    inside = await git.checkIsRepo();
+  } catch (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 });
   }
-  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 (!inside) {
+    throw new Error("Not a git 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 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 });
   }
-  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 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;
+  if (head.length === 0) {
+    throw new Error("No commits in repository");
+  }
+  let branch;
   try {
-    validated = EventSchema.parse(event);
+    const raw = (await git.raw(["branch", "--show-current"])).trimEnd();
+    branch = raw.length > 0 ? raw : "HEAD";
   } catch (error) {
-    throw new Error("Invalid Basou event payload", { cause: error });
+    throw new Error("Failed to read git state", { cause: error });
   }
-  const line = `${JSON.stringify(validated)}
-`;
+  let dirty;
+  const staged = [];
+  const unstaged = [];
+  const untracked = [];
   try {
-    await appendFile(join8(sessionDir, "events.jsonl"), line, "utf8");
+    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 append event to events.jsonl", { cause: 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;
 }
-async function writeEventsBulk(sessionDir, events) {
-  const validated = [];
+
+// src/git/diff.ts
+async function getDiff(repoRoot, baseRef, headRef) {
+  let git;
   try {
-    for (const event of events) {
-      validated.push(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 filePath = join8(sessionDir, "events.jsonl");
-  const body = validated.length > 0 ? `${validated.map((e) => JSON.stringify(e)).join("\n")}
-` : "";
+  if (baseRef === headRef) return { changed_files: [] };
+  let raw;
   try {
-    await atomicReplace(filePath, body);
+    raw = await git.raw(["diff", "--name-status", `${baseRef}..${headRef}`]);
   } catch (error) {
-    throw new Error("Failed to write 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) };
+}
+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" });
+    }
   }
+  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 +1149,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 +1186,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) {
@@ -1502,7 +1315,7 @@ async function appendEventToExistingSession(input) {
   }
   const eventId = prefixedUlid("evt");
   const event = assertTargetEventIdentity(input.eventBuilder(eventId), input.sessionId, eventId);
-  const sessionDir = join9(input.paths.sessions, input.sessionId);
+  const sessionDir = join6(input.paths.sessions, input.sessionId);
   await appendEvent(sessionDir, event);
   return { eventId, sessionStatus: status };
 }
@@ -1513,7 +1326,163 @@ function assertTargetEventIdentity(event, expectedSessionId, expectedEventId) {
   if (event.id !== expectedEventId) {
     throw new Error("Target event id mismatch");
   }
-  return event;
+  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 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;
+}
+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()
+    };
+  }
+  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 await rebuildTaskIndex(paths, nextTasks, nowFn);
 }
 
 // src/storage/tasks.ts
@@ -1526,8 +1495,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 +1530,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 +1563,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 +1648,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 +1678,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 +1972,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 +2231,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 });
@@ -2760,7 +2729,7 @@ async function deleteTaskLocked(input) {
   });
   const eventId = adHoc.targetEventIds[0];
   try {
-    await unlink3(join10(input.paths.tasks, `${input.taskId}.md`));
+    await unlink3(join9(input.paths.tasks, `${input.taskId}.md`));
   } catch (error) {
     throw new TaskWriteAfterEventError({
       taskId: input.taskId,
@@ -2771,275 +2740,89 @@ async function deleteTaskLocked(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();
-  }
-}
-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`)
-    );
-  } catch (error) {
-    throw new TaskWriteAfterEventError({
-      taskId: input.taskId,
-      eventId,
-      sessionId: adHoc.sessionId,
-      phase: "archive",
-      cause: error
-    });
-  }
-  await safeUpdateTaskIndex(input.paths, { kind: "remove", id: input.taskId });
-  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
-      });
-    }
-    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);
-  }
-  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");
-    }
-  }
-}
-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");
-    }
-  }
-}
-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
-    }
-  };
-}
-
-// 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}`);
+  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 +2838,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)
@@ -3232,199 +3015,169 @@ function formatHandoffBody(args) {
   if (args.pendingTasks.length === 0) {
     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("");
-  const liveTableEntries = args.entries.filter((e) => e.session.session.source.kind !== "import");
-  const importedTableEntries = args.entries.filter(
-    (e) => e.session.session.source.kind === "import"
-  );
-  lines.push("## \u30BB\u30C3\u30B7\u30E7\u30F3\u4E00\u89A7");
-  lines.push("");
-  if (args.entries.length === 0) {
-    lines.push("(no sessions yet)");
-  } else if (liveTableEntries.length === 0) {
-    lines.push("(no live sessions; see Imported sessions below)");
-  } else {
-    lines.push("| short_id | status | started_at | label |");
-    lines.push("|---|---|---|---|");
-    for (const e of [...liveTableEntries].reverse()) {
-      const sid = shortHandoffId(e.sessionId);
-      const status = e.session.session.status + suspectLabel(e.suspectReason);
-      const startedAt = e.session.session.started_at;
-      const label = e.session.session.label ?? "";
-      lines.push(`| ${sid} | ${status} | ${startedAt} | ${label} |`);
-    }
-  }
-  if (importedTableEntries.length > 0) {
-    lines.push("");
-    lines.push("### Imported sessions");
-    lines.push("");
-    lines.push("| short_id | status | started_at | label |");
-    lines.push("|---|---|---|---|");
-    for (const e of [...importedTableEntries].reverse()) {
-      const sid = shortHandoffId(e.sessionId);
-      const status = e.session.session.status + suspectLabel(e.suspectReason);
-      const startedAt = e.session.session.started_at;
-      const label = e.session.session.label ?? "";
-      lines.push(`| ${sid} | ${status} | ${startedAt} | ${label} |`);
-    }
-  }
-  lines.push("");
-  const statusCounts = /* @__PURE__ */ new Map();
-  for (const e of args.entries) {
-    const s = e.session.session.status;
-    statusCounts.set(s, (statusCounts.get(s) ?? 0) + 1);
-  }
-  const orderedStatuses = [
-    "completed",
-    "failed",
-    "running",
-    "interrupted",
-    "waiting_approval",
-    "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(", ")}`);
+    for (const t of args.pendingTasks) {
+      lines.push(`- ${t.task.task.id} (${t.task.task.status}): ${t.task.task.title}`);
+    }
+  }
+  lines.push("");
+  const liveTableEntries = args.entries.filter((e) => e.session.session.source.kind !== "import");
+  const importedTableEntries = args.entries.filter(
+    (e) => e.session.session.source.kind === "import"
+  );
+  lines.push("## \u30BB\u30C3\u30B7\u30E7\u30F3\u4E00\u89A7");
+  lines.push("");
+  if (args.entries.length === 0) {
+    lines.push("(no sessions yet)");
+  } else if (liveTableEntries.length === 0) {
+    lines.push("(no live sessions; see Imported sessions below)");
+  } else {
+    lines.push("| short_id | status | started_at | label |");
+    lines.push("|---|---|---|---|");
+    for (const e of [...liveTableEntries].reverse()) {
+      const sid = shortHandoffId(e.sessionId);
+      const status = e.session.session.status + suspectLabel(e.suspectReason);
+      const startedAt = e.session.session.started_at;
+      const label = e.session.session.label ?? "";
+      lines.push(`| ${sid} | ${status} | ${startedAt} | ${label} |`);
     }
+  }
+  if (importedTableEntries.length > 0) {
+    lines.push("");
+    lines.push("### Imported sessions");
     lines.push("");
+    lines.push("| short_id | status | started_at | label |");
+    lines.push("|---|---|---|---|");
+    for (const e of [...importedTableEntries].reverse()) {
+      const sid = shortHandoffId(e.sessionId);
+      const status = e.session.session.status + suspectLabel(e.suspectReason);
+      const startedAt = e.session.session.started_at;
+      const label = e.session.session.label ?? "";
+      lines.push(`| ${sid} | ${status} | ${startedAt} | ${label} |`);
+    }
+  }
+  lines.push("");
+  const statusCounts = /* @__PURE__ */ new Map();
+  for (const e of args.entries) {
+    const s = e.session.session.status;
+    statusCounts.set(s, (statusCounts.get(s) ?? 0) + 1);
   }
+  const orderedStatuses = [
+    "completed",
+    "failed",
+    "running",
+    "interrupted",
+    "waiting_approval",
+    "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 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);
 }
 
+// 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 +3194,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,255 +3284,518 @@ 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")
+  }),
+  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()
+}).strict();
+var SessionImportPayloadSchema = z10.object({
+  schema_version: z10.string(),
+  session: SessionInnerImportSchema,
+  events: z10.array(EventSchema)
+}).strict();
+
+// src/storage/basou-dir.ts
+import { lstat as lstat3, mkdir as mkdir3 } from "fs/promises";
+import { join as join11 } from "path";
+function basouPaths(repositoryRoot) {
+  const root = join11(repositoryRoot, ".basou");
+  const approvalsBase = join11(root, "approvals");
+  return {
+    root,
+    sessions: join11(root, "sessions"),
+    tasks: join11(root, "tasks"),
+    approvals: {
+      pending: join11(approvalsBase, "pending"),
+      resolved: join11(approvalsBase, "resolved")
+    },
+    locks: join11(root, "locks"),
+    logs: join11(root, "logs"),
+    raw: join11(root, "raw"),
+    tmp: join11(root, "tmp"),
+    files: {
+      manifest: join11(root, "manifest.yaml"),
+      status: join11(root, "status.json"),
+      handoff: join11(root, "handoff.md"),
+      decisions: join11(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 join12 } 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 = join12(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 join13 } 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 = join13(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 = join13(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
+  };
+  return {
+    record: { schema_version: "0.1.0", session: inner },
+    pathSanitizeReport: {
+      relatedFiles: relatedSanitized.mutationCount,
+      workingDirectoryRewritten: workingDirectorySanitized !== workingDirectoryRaw
+    }
+  };
 }
 
 // src/index.ts