@basou/core 0.3.1

package/dist/index.js

@@ -0,0 +1,3885 @@
+// src/ids/ulid.ts
+import { isValid as isValidUlid, monotonicFactory } from "ulid";
+var ID_PREFIXES = Object.freeze(["ws", "task", "ses", "evt", "appr", "decision"]);
+var PREFIX_SET = new Set(ID_PREFIXES);
+var ULID_BODY_REGEX = /^[0-7][0-9A-HJKMNP-TV-Z]{25}$/;
+var monotonic = monotonicFactory();
+function ulid(seedTime) {
+  return monotonic(seedTime);
+}
+function prefixedUlid(prefix) {
+  if (!PREFIX_SET.has(prefix)) {
+    throw new Error(`Unknown ID prefix: ${prefix}`);
+  }
+  return `${prefix}_${ulid()}`;
+}
+function isValidPrefixedId(value) {
+  const idx = value.indexOf("_");
+  if (idx <= 0) return false;
+  const prefix = value.slice(0, idx);
+  const ulidPart = value.slice(idx + 1);
+  if (!PREFIX_SET.has(prefix)) return false;
+  if (!ULID_BODY_REGEX.test(ulidPart)) return false;
+  return isValidUlid(ulidPart);
+}
+
+// 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) => {
+  const refiner = (value) => isValidPrefixedId(value) && value.startsWith(`${prefix}_`);
+  return z.string().refine(refiner, { message: `Expected ${prefix}_<ULID>` });
+};
+var WorkspaceIdSchema = createPrefixedIdSchema("ws");
+var TaskIdSchema = createPrefixedIdSchema("task");
+var SessionIdSchema = createPrefixedIdSchema("ses");
+var EventIdSchema = createPrefixedIdSchema("evt");
+var ApprovalIdSchema = createPrefixedIdSchema("appr");
+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({
+  schema_version: SchemaVersionSchema,
+  id: ApprovalIdSchema,
+  session_id: SessionIdSchema,
+  created_at: IsoTimestampSchema,
+  status: ApprovalStatusSchema,
+  risk_level: RiskLevelSchema,
+  action: z7.object({ kind: z7.string() }).passthrough(),
+  reason: z7.string(),
+  expires_at: IsoTimestampSchema.nullable().default(null),
+  // The four fields below are null while `status === "pending"` and set
+  // once a resolver records a decision. Defaulting to null keeps the
+  // pending YAML free of explicit nulls if a producer omits them.
+  resolver: z7.string().nullable().default(null),
+  resolved_at: IsoTimestampSchema.nullable().default(null),
+  note: z7.string().nullable().default(null),
+  rejection_reason: z7.string().nullable().default(null)
+});
+
+// src/schemas/event.schema.ts
+import { z as z8 } from "zod";
+var BaseEventSchema = z8.object({
+  schema_version: SchemaVersionSchema,
+  id: EventIdSchema,
+  session_id: SessionIdSchema,
+  occurred_at: IsoTimestampSchema,
+  source: EventSourceSchema
+});
+var SessionStartedEventSchema = BaseEventSchema.extend({
+  type: z8.literal("session_started")
+});
+var SessionEndedEventSchema = BaseEventSchema.extend({
+  type: z8.literal("session_ended"),
+  exit_code: z8.number().int().optional()
+});
+var SessionStatusChangedEventSchema = BaseEventSchema.extend({
+  type: z8.literal("session_status_changed"),
+  from: z8.string(),
+  to: z8.string()
+});
+var ApprovalRequestedEventSchema = BaseEventSchema.extend({
+  type: z8.literal("approval_requested"),
+  approval_id: ApprovalIdSchema,
+  expires_at: IsoTimestampSchema.nullable().default(null),
+  risk_level: RiskLevelSchema,
+  // `action.kind` is required; additional fields are allowed to support
+  // future action shapes (shell_command, external_send, ...).
+  action: z8.object({ kind: z8.string() }).passthrough(),
+  reason: z8.string(),
+  status: z8.literal("pending")
+});
+var ApprovalApprovedEventSchema = BaseEventSchema.extend({
+  type: z8.literal("approval_approved"),
+  approval_id: ApprovalIdSchema,
+  resolver: z8.string().optional(),
+  note: z8.string().nullable().optional()
+});
+var ApprovalRejectedEventSchema = BaseEventSchema.extend({
+  type: z8.literal("approval_rejected"),
+  approval_id: ApprovalIdSchema,
+  resolver: z8.string().optional(),
+  reason: z8.string()
+});
+var ApprovalExpiredEventSchema = BaseEventSchema.extend({
+  type: z8.literal("approval_expired"),
+  approval_id: ApprovalIdSchema
+});
+var CommandExecutedEventSchema = BaseEventSchema.extend({
+  type: z8.literal("command_executed"),
+  command: z8.string(),
+  args: z8.array(z8.string()),
+  cwd: z8.string(),
+  exit_code: z8.number().int().nullable(),
+  signal: z8.string().nullable().optional(),
+  received_signal: z8.string().nullable().optional(),
+  duration_ms: z8.number().int().nonnegative()
+});
+var GitSnapshotEventSchema = BaseEventSchema.extend({
+  type: z8.literal("git_snapshot"),
+  head: z8.string(),
+  branch: z8.string(),
+  dirty: z8.boolean(),
+  staged: z8.array(z8.string()),
+  unstaged: z8.array(z8.string()),
+  untracked: z8.array(z8.string()),
+  ahead: z8.number().int().nonnegative().optional(),
+  behind: z8.number().int().nonnegative().optional()
+});
+var FileChangedEventSchema = BaseEventSchema.extend({
+  type: z8.literal("file_changed"),
+  path: z8.string(),
+  change_type: z8.enum(["added", "modified", "deleted", "renamed"]),
+  // Renamed entries record the previous path here. Optional + nullable to
+  // keep the wire format stable for added / modified / deleted events.
+  old_path: z8.string().nullable().optional()
+});
+var DecisionRecordedEventSchema = BaseEventSchema.extend({
+  type: z8.literal("decision_recorded"),
+  decision_id: DecisionIdSchema,
+  title: z8.string(),
+  rationale: z8.string().nullable().optional(),
+  alternatives: z8.array(z8.string().min(1)).optional(),
+  rejected_reason: z8.string().nullable().optional(),
+  linked_events: z8.array(EventIdSchema).optional(),
+  linked_files: z8.array(z8.string().min(1).max(4096)).optional()
+});
+var TaskCreatedEventSchema = BaseEventSchema.extend({
+  type: z8.literal("task_created"),
+  task_id: TaskIdSchema,
+  title: z8.string()
+});
+var TaskStatusChangedEventSchema = BaseEventSchema.extend({
+  type: z8.literal("task_status_changed"),
+  task_id: TaskIdSchema,
+  from: z8.string(),
+  to: z8.string()
+});
+var TaskReconciledEventSchema = BaseEventSchema.extend({
+  type: z8.literal("task_reconciled"),
+  task_id: TaskIdSchema,
+  removed_created_in_session: SessionIdSchema.nullable().default(null),
+  created_in_session_replacement: SessionIdSchema.nullable().default(null),
+  removed_linked_sessions: z8.array(SessionIdSchema).default([])
+}).strict();
+var TaskLinkageRefreshedEventSchema = BaseEventSchema.extend({
+  type: z8.literal("task_linkage_refreshed"),
+  task_id: TaskIdSchema,
+  added_linked_sessions: z8.array(SessionIdSchema).default([]),
+  removed_linked_sessions: z8.array(SessionIdSchema).default([]),
+  final_count: z8.number().int().nonnegative().optional()
+}).strict();
+var TaskDeletedEventSchema = BaseEventSchema.extend({
+  type: z8.literal("task_deleted"),
+  task_id: TaskIdSchema,
+  title: z8.string().min(1)
+}).strict();
+var TaskArchivedEventSchema = BaseEventSchema.extend({
+  type: z8.literal("task_archived"),
+  task_id: TaskIdSchema,
+  title: z8.string().min(1)
+}).strict();
+var NoteAddedEventSchema = BaseEventSchema.extend({
+  type: z8.literal("note_added"),
+  body: z8.string()
+});
+var AdapterOutputEventSchema = BaseEventSchema.extend({
+  type: z8.literal("adapter_output"),
+  stream: z8.enum(["stdout", "stderr"]),
+  summary: z8.string(),
+  raw_ref: z8.string(),
+  redacted: z8.boolean().optional()
+}).strict();
+var EventSchema = z8.discriminatedUnion("type", [
+  SessionStartedEventSchema,
+  SessionEndedEventSchema,
+  SessionStatusChangedEventSchema,
+  ApprovalRequestedEventSchema,
+  ApprovalApprovedEventSchema,
+  ApprovalRejectedEventSchema,
+  ApprovalExpiredEventSchema,
+  CommandExecutedEventSchema,
+  GitSnapshotEventSchema,
+  FileChangedEventSchema,
+  DecisionRecordedEventSchema,
+  TaskCreatedEventSchema,
+  TaskStatusChangedEventSchema,
+  TaskReconciledEventSchema,
+  TaskLinkageRefreshedEventSchema,
+  TaskDeletedEventSchema,
+  TaskArchivedEventSchema,
+  NoteAddedEventSchema,
+  AdapterOutputEventSchema
+]);
+
+// src/schemas/session-import.schema.ts
+import { z as z9 } from "zod";
+var SessionInnerImportSchema = z9.object({
+  id: SessionIdSchema.optional(),
+  label: z9.string().optional(),
+  task_id: TaskIdSchema.nullable().optional(),
+  workspace_id: WorkspaceIdSchema,
+  source: z9.object({
+    kind: SessionSourceKindSchema,
+    version: z9.literal("0.1.0")
+  }),
+  started_at: IsoTimestampSchema,
+  ended_at: IsoTimestampSchema.optional(),
+  status: SessionStatusSchema,
+  working_directory: z9.string().min(1),
+  invocation: z9.object({
+    command: z9.string().min(1),
+    args: z9.array(z9.string()),
+    exit_code: z9.number().int().nullable()
+  }),
+  related_files: z9.array(z9.string()).default([]),
+  events_log: z9.string().optional(),
+  summary: z9.string().nullable().optional()
+}).strict();
+var SessionImportPayloadSchema = z9.object({
+  schema_version: z9.string(),
+  session: SessionInnerImportSchema,
+  events: z9.array(EventSchema)
+}).strict();
+
+// src/approval/approval-store.ts
+import { readdir } from "fs/promises";
+import { join } from "path";
+
+// src/lib/error-codes.ts
+function findErrorCode(error, code, depth = 4) {
+  let cur = error;
+  for (let i = 0; i < depth && cur instanceof Error; i++) {
+    const c = cur.code;
+    if (typeof c === "string" && c === code) return true;
+    cur = cur.cause;
+  }
+  return false;
+}
+
+// src/storage/yaml-store.ts
+import { readFile } from "fs/promises";
+import { parse, stringify } from "yaml";
+
+// src/storage/atomic.ts
+import { randomUUID } from "crypto";
+import { link, rename, unlink, writeFile } from "fs/promises";
+async function atomicCreate(targetPath, content) {
+  const tmpPath = `${targetPath}.tmp.${randomUUID()}`;
+  try {
+    await writeFile(tmpPath, content, { encoding: "utf8", flag: "wx" });
+    await link(tmpPath, targetPath);
+  } catch (error) {
+    await unlink(tmpPath).catch(() => void 0);
+    throw error;
+  }
+  await unlink(tmpPath).catch(() => void 0);
+}
+async function atomicReplace(targetPath, content) {
+  const tmpPath = `${targetPath}.tmp.${randomUUID()}`;
+  try {
+    await writeFile(tmpPath, content, { encoding: "utf8", flag: "wx" });
+    await rename(tmpPath, targetPath);
+  } catch (error) {
+    await unlink(tmpPath).catch(() => void 0);
+    throw error;
+  }
+}
+
+// src/storage/yaml-store.ts
+async function readYamlFile(filePath) {
+  let body;
+  try {
+    body = await readFile(filePath, "utf8");
+  } catch (error) {
+    if (hasErrorCode(error) && error.code === "ENOENT") {
+      throw new Error("YAML file not found", { cause: error });
+    }
+    throw new Error("Failed to read YAML file", { cause: error });
+  }
+  try {
+    return parse(body);
+  } catch (error) {
+    throw new Error("Failed to parse YAML content", { cause: error });
+  }
+}
+async function writeYamlFile(filePath, value) {
+  const body = stringify(value);
+  try {
+    await atomicReplace(filePath, body);
+  } catch (error) {
+    throw new Error("Failed to write YAML file", { cause: error });
+  }
+}
+async function linkYamlFile(filePath, value) {
+  const body = stringify(value);
+  try {
+    await atomicCreate(filePath, body);
+  } catch (error) {
+    throw new Error("Failed to write YAML file", { cause: error });
+  }
+}
+async function overwriteYamlFile(filePath, value) {
+  const body = stringify(value);
+  try {
+    await atomicReplace(filePath, body);
+  } catch (error) {
+    throw new Error("Failed to overwrite YAML file", { cause: error });
+  }
+}
+function hasErrorCode(error) {
+  if (!(error instanceof Error)) return false;
+  return typeof error.code === "string";
+}
+
+// src/approval/approval-store.ts
+async function loadApproval(paths, approvalId) {
+  for (const location of ["resolved", "pending"]) {
+    const filePath = join(paths.approvals[location], `${approvalId}.yaml`);
+    let raw;
+    try {
+      raw = await readYamlFile(filePath);
+    } catch (error) {
+      if (error instanceof Error && error.message === "YAML file not found") continue;
+      throw new Error("Failed to read approval", { cause: error });
+    }
+    const result = ApprovalSchema.safeParse(raw);
+    if (!result.success) {
+      throw new Error("Failed to read approval", { cause: result.error });
+    }
+    if (result.data.id !== approvalId) {
+      throw new Error("Failed to read approval", {
+        cause: new Error(
+          `Approval id mismatch: filename id ${approvalId} vs YAML body id ${result.data.id}`
+        )
+      });
+    }
+    return { approval: result.data, location };
+  }
+  return null;
+}
+async function enumerateApprovals(paths) {
+  const [pending, resolved] = await Promise.all([
+    enumerateIds(paths.approvals.pending),
+    enumerateIds(paths.approvals.resolved)
+  ]);
+  return { pending, resolved };
+}
+async function enumerateIds(dir) {
+  let entries;
+  try {
+    const dirents = await readdir(dir, { withFileTypes: true });
+    entries = dirents.filter((e) => e.isFile() && e.name.endsWith(".yaml")).map((e) => e.name.slice(0, -".yaml".length));
+  } catch (error) {
+    if (findErrorCode(error, "ENOENT")) return [];
+    throw new Error("Failed to enumerate approvals", { cause: error });
+  }
+  return entries;
+}
+function isLazyExpired(approval, now) {
+  if (approval.status !== "pending") return false;
+  if (approval.expires_at === null) return false;
+  const expiresMs = Date.parse(approval.expires_at);
+  if (!Number.isFinite(expiresMs)) return false;
+  return expiresMs < now.getTime();
+}
+
+// src/storage/basou-dir.ts
+import { lstat, mkdir } from "fs/promises";
+import { join as join2 } from "path";
+function basouPaths(repositoryRoot) {
+  const root = join2(repositoryRoot, ".basou");
+  const approvalsBase = join2(root, "approvals");
+  return {
+    root,
+    sessions: join2(root, "sessions"),
+    tasks: join2(root, "tasks"),
+    approvals: {
+      pending: join2(approvalsBase, "pending"),
+      resolved: join2(approvalsBase, "resolved")
+    },
+    locks: join2(root, "locks"),
+    logs: join2(root, "logs"),
+    raw: join2(root, "raw"),
+    tmp: join2(root, "tmp"),
+    files: {
+      manifest: join2(root, "manifest.yaml"),
+      status: join2(root, "status.json"),
+      handoff: join2(root, "handoff.md"),
+      decisions: join2(root, "decisions.md")
+    }
+  };
+}
+var PATH_LABELS = {
+  sessions: ".basou/sessions",
+  tasks: ".basou/tasks",
+  approvalsPending: ".basou/approvals/pending",
+  approvalsResolved: ".basou/approvals/resolved",
+  locks: ".basou/locks",
+  logs: ".basou/logs",
+  raw: ".basou/raw",
+  tmp: ".basou/tmp"
+};
+async function ensureBasouDirectory(repositoryRoot) {
+  const paths = basouPaths(repositoryRoot);
+  let existing;
+  try {
+    existing = await lstat(paths.root);
+  } catch (error) {
+    if (!hasErrorCode2(error) || error.code !== "ENOENT") {
+      throw new Error("Failed to inspect .basou directory", { cause: error });
+    }
+  }
+  if (existing !== void 0 && !existing.isDirectory()) {
+    throw new Error("Basou root .basou exists but is not a directory");
+  }
+  await Promise.all([
+    mkdirLabeled(paths.sessions, PATH_LABELS.sessions),
+    mkdirLabeled(paths.tasks, PATH_LABELS.tasks),
+    mkdirLabeled(paths.approvals.pending, PATH_LABELS.approvalsPending),
+    mkdirLabeled(paths.approvals.resolved, PATH_LABELS.approvalsResolved),
+    mkdirLabeled(paths.locks, PATH_LABELS.locks),
+    mkdirLabeled(paths.logs, PATH_LABELS.logs),
+    mkdirLabeled(paths.raw, PATH_LABELS.raw),
+    mkdirLabeled(paths.tmp, PATH_LABELS.tmp)
+  ]);
+  return paths;
+}
+async function mkdirLabeled(target, label) {
+  try {
+    await mkdir(target, { recursive: true });
+  } catch (error) {
+    if (hasErrorCode2(error) && (error.code === "ENOTDIR" || error.code === "EEXIST")) {
+      throw new Error(`${label} exists but is not a directory`, { cause: error });
+    }
+    throw new Error(`Failed to create ${label}`, { cause: error });
+  }
+}
+function hasErrorCode2(error) {
+  if (!(error instanceof Error)) return false;
+  const codeProp = error.code;
+  return typeof codeProp === "string";
+}
+
+// src/storage/manifest.ts
+import { lstat as lstat2 } from "fs/promises";
+function createManifest(input) {
+  if (input.workspaceName.length === 0) {
+    throw new Error("Workspace name is empty. Pass --name explicitly.");
+  }
+  const now = (input.now ?? /* @__PURE__ */ new Date()).toISOString();
+  const workspaceId = input.workspaceId ?? prefixedUlid("ws");
+  const project = {
+    ...input.projectName !== void 0 ? { name: input.projectName } : {},
+    ...input.projectDescription !== void 0 ? { description: input.projectDescription } : {},
+    ...input.repositoryUrl !== void 0 ? { repository_url: input.repositoryUrl } : {}
+  };
+  const manifest = {
+    schema_version: "0.1.0",
+    basou_version: "0.1.0",
+    workspace: {
+      id: workspaceId,
+      name: input.workspaceName,
+      created_at: now,
+      updated_at: now
+    },
+    project,
+    capabilities: {
+      enabled: ["core", "claude-code-adapter", "terminal-recording", "git-capability", "approval"]
+    },
+    approval: {
+      required_for: ["destructive_command", "external_send"],
+      default_risk_level: "medium"
+    },
+    adapters: {
+      "claude-code": { enabled: true }
+    },
+    git: { events_log: "ignore" }
+  };
+  return ManifestSchema.parse(manifest);
+}
+async function writeManifest(paths, manifest, options) {
+  const force = options?.force === true;
+  const validated = ManifestSchema.parse(manifest);
+  if (!force) {
+    let existed = false;
+    try {
+      await lstat2(paths.files.manifest);
+      existed = true;
+    } catch (error) {
+      if (!hasErrorCode3(error) || error.code !== "ENOENT") {
+        throw new Error("Failed to inspect existing manifest", { cause: error });
+      }
+    }
+    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";
+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;
+  try {
+    body = await readFile2(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 (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 hasBasouMarker(body) {
+  for (const rawLine of body.split("\n")) {
+    if (rawLine.trimEnd().startsWith(MARKER)) return true;
+  }
+  return false;
+}
+function composeNextBody(existing) {
+  if (existing.length === 0) return BASOU_GITIGNORE_BLOCK;
+  const normalized = existing.endsWith("\n") ? existing : `${existing}
+`;
+  return `${normalized}
+${BASOU_GITIGNORE_BLOCK}`;
+}
+function hasErrorCode4(error) {
+  if (!(error instanceof Error)) return false;
+  return typeof error.code === "string";
+}
+
+// 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()
+  };
+  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 join4(paths.locks, `${scope}_${ulid2}.lock`);
+}
+
+// src/storage/task-index.ts
+import { readFile as readFile4 } 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;
+  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/status.ts
+import * as fsp from "fs/promises";
+var DIRECTORY_CHECKS = {
+  sessions: (p) => p.sessions,
+  tasks: (p) => p.tasks,
+  approvals_pending: (p) => p.approvals.pending,
+  approvals_resolved: (p) => p.approvals.resolved,
+  logs: (p) => p.logs,
+  raw: (p) => p.raw,
+  tmp: (p) => p.tmp
+};
+async function assertBasouRootSafe(rootPath) {
+  let stat3;
+  try {
+    stat3 = await fsp.lstat(rootPath);
+  } catch (error) {
+    if (hasErrorCode5(error) && error.code === "ENOENT") {
+      throw new Error("Basou workspace not found", { cause: error });
+    }
+    throw new Error("Failed to inspect .basou root", { cause: error });
+  }
+  if (stat3.isSymbolicLink()) {
+    throw new Error(".basou root is a symlink; refusing to operate");
+  }
+  if (!stat3.isDirectory()) {
+    throw new Error(".basou root exists but is not a directory");
+  }
+}
+async function dirPresent(path2) {
+  try {
+    return (await fsp.lstat(path2)).isDirectory();
+  } catch (error) {
+    if (hasErrorCode5(error) && (error.code === "ENOENT" || error.code === "ENOTDIR")) {
+      return false;
+    }
+    throw new Error("Failed to inspect .basou subdirectory", { cause: error });
+  }
+}
+async function buildStatusSnapshot(input) {
+  const { manifest, paths } = input;
+  const generatedAt = (input.now ?? /* @__PURE__ */ new Date()).toISOString();
+  const entries = Object.entries(DIRECTORY_CHECKS);
+  const presence = await Promise.all(
+    entries.map(async ([key, get]) => [key, await dirPresent(get(paths))])
+  );
+  const directoriesEntries = Object.fromEntries(presence);
+  const snapshot = {
+    schema_version: "0.1.0",
+    generated_at: generatedAt,
+    workspace: {
+      id: manifest.workspace.id,
+      name: manifest.workspace.name,
+      basou_version: manifest.basou_version
+    },
+    directories_present: directoriesEntries
+  };
+  return StatusSchema.parse(snapshot);
+}
+async function writeStatus(paths, snapshot) {
+  const validated = StatusSchema.parse(snapshot);
+  const body = `${JSON.stringify(validated, null, 2)}
+`;
+  try {
+    await atomicReplace(paths.files.status, body);
+  } catch (error) {
+    throw new Error("Failed to write status file", { cause: error });
+  }
+}
+async function readStatus(paths) {
+  let body;
+  try {
+    body = await fsp.readFile(paths.files.status, "utf8");
+  } catch (error) {
+    if (hasErrorCode5(error) && error.code === "ENOENT") {
+      throw new Error("Status file not found", { cause: error });
+    }
+    throw new Error("Failed to read status file", { cause: error });
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(body);
+  } catch (error) {
+    throw new Error("Failed to parse status JSON", { cause: error });
+  }
+  return StatusSchema.parse(parsed);
+}
+function hasErrorCode5(error) {
+  if (!(error instanceof Error)) return false;
+  return typeof error.code === "string";
+}
+
+// src/storage/sessions.ts
+import { readdir as readdir2 } from "fs/promises";
+import { join as join7 } from "path";
+
+// src/events/event-replay.ts
+import { createReadStream } from "fs";
+import { stat } from "fs/promises";
+import { join as join6 } from "path";
+async function* replayEvents(sessionDir, options = {}) {
+  const filePath = join6(sessionDir, "events.jsonl");
+  try {
+    await stat(filePath);
+  } catch (error) {
+    if (findErrorCode(error, "ENOENT")) return;
+    throw new Error("Failed to read events.jsonl", { cause: error });
+  }
+  let stream;
+  try {
+    stream = createReadStream(filePath, { encoding: "utf8" });
+  } catch (error) {
+    throw new Error("Failed to read events.jsonl", { cause: error });
+  }
+  let buffer = "";
+  let lineNo = 0;
+  try {
+    for await (const chunk of stream) {
+      buffer += chunk;
+      let newlineIdx = buffer.indexOf("\n");
+      while (newlineIdx !== -1) {
+        lineNo += 1;
+        const rawLine = buffer.slice(0, newlineIdx);
+        buffer = buffer.slice(newlineIdx + 1);
+        const ev = processLine(rawLine, lineNo, options);
+        if (ev !== null) yield ev;
+        newlineIdx = buffer.indexOf("\n");
+      }
+    }
+  } catch (error) {
+    throw new Error("Failed to read events.jsonl", { cause: error });
+  }
+  const trimmed = buffer.replace(/[\r\n\t ]+$/u, "");
+  if (trimmed.length === 0) return;
+  lineNo += 1;
+  let parsed;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch (cause) {
+    options.onWarning?.({ kind: "malformed_json", line: lineNo, cause });
+    return;
+  }
+  const result = EventSchema.safeParse(parsed);
+  if (!result.success) {
+    options.onWarning?.({ kind: "schema_violation", line: lineNo, cause: result.error });
+    return;
+  }
+  options.onWarning?.({ kind: "partial_trailing_line", line: lineNo });
+}
+function processLine(rawLine, lineNo, options) {
+  const trimmed = rawLine.trim();
+  if (trimmed.length === 0) return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch (cause) {
+    options.onWarning?.({ kind: "malformed_json", line: lineNo, cause });
+    return null;
+  }
+  const result = EventSchema.safeParse(parsed);
+  if (!result.success) {
+    options.onWarning?.({ kind: "schema_violation", line: lineNo, cause: result.error });
+    return null;
+  }
+  return result.data;
+}
+async function readAllEvents(sessionDir, options = {}) {
+  const out = [];
+  for await (const ev of replayEvents(sessionDir, options)) {
+    out.push(ev);
+  }
+  return out;
+}
+
+// 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" };
+    }
+  }
+  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 });
+  }
+  return entries;
+}
+
+// src/storage/markdown-store.ts
+import { readFile as readFile6 } from "fs/promises";
+var GENERATED_START = "<!-- BASOU:GENERATED:START -->";
+var GENERATED_END = "<!-- BASOU:GENERATED:END -->";
+async function readMarkdownFile(filePath) {
+  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 });
+  }
+}
+async function writeMarkdownFile(filePath, body) {
+  try {
+    await atomicReplace(filePath, body);
+  } catch (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;
+    }
+  }
+  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;
+  try {
+    validated = EventSchema.parse(event);
+  } catch (error) {
+    throw new Error("Invalid Basou event payload", { cause: error });
+  }
+  const line = `${JSON.stringify(validated)}
+`;
+  try {
+    await appendFile(join8(sessionDir, "events.jsonl"), line, "utf8");
+  } catch (error) {
+    throw new Error("Failed to append event to events.jsonl", { cause: error });
+  }
+}
+async function writeEventsBulk(sessionDir, events) {
+  const validated = [];
+  try {
+    for (const event of events) {
+      validated.push(EventSchema.parse(event));
+    }
+  } catch (error) {
+    throw new Error("Invalid Basou event payload", { cause: error });
+  }
+  const filePath = join8(sessionDir, "events.jsonl");
+  const body = validated.length > 0 ? `${validated.map((e) => JSON.stringify(e)).join("\n")}
+` : "";
+  try {
+    await atomicReplace(filePath, body);
+  } catch (error) {
+    throw new Error("Failed to write events.jsonl", { cause: error });
+  }
+}
+
+// src/lib/path-sanitizer.ts
+import { posix as path } from "path";
+function sanitizePath(rawPath, opts) {
+  if (rawPath.includes("\0")) {
+    throw new Error("Invalid path: contains null byte");
+  }
+  const normalized = path.normalize(rawPath.replace(/\\/g, "/"));
+  const wd = path.normalize(opts.workingDirectory.replace(/\\/g, "/"));
+  const home = path.normalize(opts.homedir.replace(/\\/g, "/"));
+  if (!path.isAbsolute(normalized)) {
+    return normalized;
+  }
+  if (normalized === wd) return ".";
+  const wdRel = path.relative(wd, normalized);
+  if (wdRel !== "" && !wdRel.startsWith("..")) {
+    return wdRel;
+  }
+  if (normalized === home) return "~";
+  const homeRel = path.relative(home, normalized);
+  if (homeRel !== "" && !homeRel.startsWith("..")) {
+    return `~/${homeRel}`;
+  }
+  return normalized;
+}
+function sanitizeWorkingDirectory(rawPath, opts) {
+  return sanitizePath(rawPath, {
+    workingDirectory: "/__basou_sentinel_never_match__",
+    homedir: opts.homedir
+  });
+}
+function sanitizeRelatedFiles(paths, opts) {
+  const sanitized = [];
+  let mutationCount = 0;
+  for (const p of paths) {
+    const next = sanitizePath(p, opts);
+    sanitized.push(next);
+    if (next !== p) mutationCount += 1;
+  }
+  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;
+  constructor(sessionId, targetEventIds, cause) {
+    super("Failed to finalize ad-hoc session", { cause });
+    this.name = "FailedToFinalizeError";
+    if (targetEventIds.length === 0) {
+      throw new Error("FailedToFinalizeError requires at least one target event id");
+    }
+    this.sessionId = sessionId;
+    this.targetEventIds = targetEventIds;
+  }
+};
+async function createAdHocSessionWithEvent(input) {
+  SessionSourceKindSchema.parse(input.sessionSource);
+  if (input.targetEventBuilders.length === 0) {
+    throw new Error("Ad-hoc session requires at least one target event builder");
+  }
+  const sessionId = prefixedUlid("ses");
+  const startedEventId = prefixedUlid("evt");
+  const statusToRunningEventId = prefixedUlid("evt");
+  const targetEventIds = input.targetEventBuilders.map(() => prefixedUlid("evt"));
+  const statusToCompletedEventId = prefixedUlid("evt");
+  const endedEventId = prefixedUlid("evt");
+  const initialSession = SessionSchema.parse(
+    buildInitialSession({
+      sessionId,
+      workspaceId: input.manifest.workspace.id,
+      sourceKind: input.sessionSource,
+      startedAt: input.occurredAt,
+      label: input.label,
+      workingDirectory: input.workingDirectory,
+      invocation: input.invocation,
+      taskId: input.taskId ?? null
+    })
+  );
+  const sessionDir = join9(input.paths.sessions, sessionId);
+  try {
+    await mkdir2(sessionDir, { recursive: true });
+  } catch (error) {
+    throw new Error("Failed to create session directory", { cause: error });
+  }
+  const sessionYamlPath = join9(sessionDir, "session.yaml");
+  try {
+    await linkYamlFile(sessionYamlPath, initialSession);
+  } catch (error) {
+    await rm(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;
+  }
+  try {
+    const targetEvents = input.targetEventBuilders.map((build, index) => {
+      const targetEventId = targetEventIds[index];
+      return assertTargetEventIdentity(build(sessionId, targetEventId), sessionId, targetEventId);
+    });
+    const events = [
+      {
+        schema_version: "0.1.0",
+        id: startedEventId,
+        session_id: sessionId,
+        occurred_at: input.occurredAt,
+        source: "local-cli",
+        type: "session_started"
+      },
+      {
+        schema_version: "0.1.0",
+        id: statusToRunningEventId,
+        session_id: sessionId,
+        occurred_at: input.occurredAt,
+        source: "local-cli",
+        type: "session_status_changed",
+        from: "initialized",
+        to: "running"
+      },
+      ...targetEvents,
+      {
+        schema_version: "0.1.0",
+        id: statusToCompletedEventId,
+        session_id: sessionId,
+        occurred_at: input.occurredAt,
+        source: "local-cli",
+        type: "session_status_changed",
+        from: "running",
+        to: "completed"
+      },
+      {
+        schema_version: "0.1.0",
+        id: endedEventId,
+        session_id: sessionId,
+        occurred_at: input.occurredAt,
+        source: "local-cli",
+        type: "session_ended",
+        exit_code: 0
+      }
+    ];
+    await writeEventsBulk(sessionDir, events);
+  } catch (error) {
+    await rm(sessionDir, { recursive: true, force: true }).catch(() => void 0);
+    throw error;
+  }
+  try {
+    const finalSession = SessionSchema.parse({
+      ...initialSession,
+      session: {
+        ...initialSession.session,
+        status: "completed",
+        ended_at: input.occurredAt,
+        invocation: { ...initialSession.session.invocation, exit_code: 0 }
+      }
+    });
+    await overwriteYamlFile(sessionYamlPath, finalSession);
+  } catch (error) {
+    throw new FailedToFinalizeError(sessionId, targetEventIds, error);
+  }
+  return {
+    sessionId,
+    targetEventIds,
+    lifecycleEventIds: [
+      startedEventId,
+      statusToRunningEventId,
+      statusToCompletedEventId,
+      endedEventId
+    ]
+  };
+}
+function buildInitialSession(input) {
+  return {
+    schema_version: "0.1.0",
+    session: {
+      id: input.sessionId,
+      label: input.label,
+      task_id: input.taskId,
+      workspace_id: input.workspaceId,
+      source: { kind: input.sourceKind, version: "0.1.0" },
+      started_at: input.startedAt,
+      status: "initialized",
+      working_directory: sanitizeWorkingDirectory(input.workingDirectory, { homedir: homedir() }),
+      invocation: { ...input.invocation, exit_code: null },
+      related_files: [],
+      events_log: "events.jsonl"
+    }
+  };
+}
+var DEFAULT_ATTACHABLE_STATUSES = /* @__PURE__ */ new Set([
+  "initialized",
+  "running",
+  "waiting_approval"
+]);
+async function appendEventToExistingSession(input) {
+  SessionIdSchema.parse(input.sessionId);
+  const sessionDoc = await readSessionYaml(input.paths, input.sessionId);
+  const status = sessionDoc.session.status;
+  if (status === "imported") {
+    throw new Error("Cannot attach to imported session");
+  }
+  const attachable = input.attachableStatuses ?? DEFAULT_ATTACHABLE_STATUSES;
+  if (!attachable.has(status)) {
+    throw new Error(`Session is not active: ${status}`);
+  }
+  const eventId = prefixedUlid("evt");
+  const event = assertTargetEventIdentity(input.eventBuilder(eventId), input.sessionId, eventId);
+  const sessionDir = join9(input.paths.sessions, input.sessionId);
+  await appendEvent(sessionDir, event);
+  return { eventId, sessionStatus: status };
+}
+function assertTargetEventIdentity(event, expectedSessionId, expectedEventId) {
+  if (event.session_id !== expectedSessionId) {
+    throw new Error("Target event session_id mismatch");
+  }
+  if (event.id !== expectedEventId) {
+    throw new Error("Target event id mismatch");
+  }
+  return event;
+}
+
+// src/storage/tasks.ts
+var FRONT_MATTER_DELIM = "---";
+var LABEL_TITLE_MAX = 80;
+var LABEL_TRUNCATE_HEAD = LABEL_TITLE_MAX - 3;
+var DEFAULT_ATTACHABLE_STATUSES2 = /* @__PURE__ */ new Set([
+  "initialized",
+  "running",
+  "waiting_approval"
+]);
+var InitialTaskStatusSchema = TaskStatusSchema;
+var TaskTitleSchema = z10.string().min(1);
+var TaskLabelSchema = z10.string().min(1);
+var CompletedAtSchema = IsoTimestampSchema;
+var TERMINAL_TASK_STATUSES = /* @__PURE__ */ new Set(["done", "cancelled"]);
+function isTerminalTaskStatus(status) {
+  return TERMINAL_TASK_STATUSES.has(status);
+}
+function splitFrontMatter(raw) {
+  if (raw.length > 0 && raw.charCodeAt(0) === 65279) {
+    throw new Error("Invalid task file format");
+  }
+  const normalised = raw.replace(/\r\n/g, "\n");
+  if (!normalised.startsWith(`${FRONT_MATTER_DELIM}
+`)) {
+    throw new Error("Invalid task file format");
+  }
+  const remainder = normalised.slice(FRONT_MATTER_DELIM.length + 1);
+  const lines = remainder.split("\n");
+  let closingIdx = -1;
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i] === FRONT_MATTER_DELIM) {
+      closingIdx = i;
+      break;
+    }
+  }
+  if (closingIdx < 0) {
+    throw new Error("Invalid task file format");
+  }
+  const yamlText = lines.slice(0, closingIdx).join("\n");
+  const afterClosing = lines.slice(closingIdx + 1);
+  let body = afterClosing.join("\n");
+  if (body.startsWith("\n")) body = body.slice(1);
+  return { yamlText, body };
+}
+async function readTaskFile(paths, taskId) {
+  const filePath = join10(paths.tasks, `${taskId}.md`);
+  let raw;
+  try {
+    raw = await readFile7(filePath, "utf8");
+  } catch (error) {
+    if (findErrorCode(error, "ENOENT")) {
+      throw new Error("Task file not found", { cause: error });
+    }
+    throw new Error("Failed to read task file", { cause: error });
+  }
+  let split;
+  try {
+    split = splitFrontMatter(raw);
+  } catch (error) {
+    if (error instanceof Error && error.message === "Invalid task file format") {
+      throw error;
+    }
+    throw new Error("Failed to read task file", { cause: error });
+  }
+  let parsed;
+  try {
+    parsed = parseYaml(split.yamlText);
+  } catch (error) {
+    throw new Error("Failed to read task file", { cause: error });
+  }
+  const result = TaskSchema.safeParse(parsed);
+  if (!result.success) {
+    throw new Error("Failed to read task file", { cause: result.error });
+  }
+  return { task: result.data, body: split.body };
+}
+async function writeTaskFile(paths, taskId, doc, options) {
+  const validated = TaskSchema.parse(doc.task);
+  const filePath = join10(paths.tasks, `${taskId}.md`);
+  const yamlText = stringifyYaml(validated);
+  const trimmedBody = doc.body.length === 0 ? "" : `
+${doc.body.endsWith("\n") ? doc.body : `${doc.body}
+`}`;
+  const fileBody = `${FRONT_MATTER_DELIM}
+${yamlText}${FRONT_MATTER_DELIM}
+${trimmedBody}`;
+  if (options.mode === "create") {
+    try {
+      await atomicCreate(filePath, fileBody);
+    } catch (error) {
+      if (findErrorCode(error, "EEXIST")) {
+        throw new Error("Task file already exists", { cause: error });
+      }
+      throw new Error("Failed to write task file", { cause: error });
+    }
+    return;
+  }
+  try {
+    await atomicReplace(filePath, fileBody);
+  } catch (error) {
+    throw new Error("Failed to write task file", { cause: error });
+  }
+}
+var TASK_FILENAME_RE = /^(.+)\.md$/;
+async function enumerateTaskIds(paths) {
+  try {
+    const index = await readTaskIndex(paths);
+    return index.tasks.map((t) => t.id);
+  } catch {
+  }
+  const ids = await enumerateTaskIdsFromDisk(paths);
+  if (ids.length === 0) {
+    return ids;
+  }
+  const entries = [];
+  for (const id of ids) {
+    try {
+      const doc = await readTaskFile(paths, id);
+      entries.push(buildTaskIndexEntry(doc.task.task));
+    } catch {
+    }
+  }
+  await rebuildTaskIndex(paths, entries).catch(() => {
+    console.warn("Failed to rebuild tasks/index.json; subsequent reads will retry");
+  });
+  return ids;
+}
+async function enumerateTaskIdsFromDisk(paths) {
+  let entries;
+  try {
+    entries = (await readdir3(paths.tasks, { withFileTypes: true })).filter((d) => d.isFile()).map((d) => d.name);
+  } catch (error) {
+    if (findErrorCode(error, "ENOENT")) return [];
+    throw new Error("Failed to enumerate tasks", { cause: error });
+  }
+  const taskIds = [];
+  for (const name of entries) {
+    const match = TASK_FILENAME_RE.exec(name);
+    if (match === null) continue;
+    const candidate = match[1];
+    if (!TaskIdSchema.safeParse(candidate).success) continue;
+    taskIds.push(candidate);
+  }
+  taskIds.sort();
+  return taskIds;
+}
+function buildTaskIndexEntry(task) {
+  return {
+    id: task.id,
+    status: task.status,
+    ...task.label !== void 0 ? { label: task.label } : {},
+    updated_at: task.updated_at
+  };
+}
+async function safeUpdateTaskIndex(paths, op) {
+  try {
+    await updateTaskIndex(paths, op);
+  } catch {
+    console.warn("Index update failed; rebuild on next read");
+  }
+}
+var ARCHIVE_DIR_NAME = "archive";
+function archiveTasksDir(paths) {
+  return join10(paths.tasks, ARCHIVE_DIR_NAME);
+}
+async function enumerateArchivedTaskIds(paths) {
+  let entries;
+  try {
+    entries = (await readdir3(archiveTasksDir(paths), { withFileTypes: true })).filter((d) => d.isFile()).map((d) => d.name);
+  } catch (error) {
+    if (findErrorCode(error, "ENOENT")) return [];
+    throw new Error("Failed to enumerate archived tasks", { cause: error });
+  }
+  const taskIds = [];
+  for (const name of entries) {
+    const match = TASK_FILENAME_RE.exec(name);
+    if (match === null) continue;
+    const candidate = match[1];
+    if (!TaskIdSchema.safeParse(candidate).success) continue;
+    taskIds.push(candidate);
+  }
+  taskIds.sort();
+  return taskIds;
+}
+async function readTaskFileWithArchiveFallback(paths, taskId) {
+  try {
+    const doc = await readTaskFile(paths, taskId);
+    return { doc, archived: false };
+  } catch (error) {
+    if (!(error instanceof Error && error.message === "Task file not found")) {
+      throw error;
+    }
+  }
+  const archiveFilePath = join10(archiveTasksDir(paths), `${taskId}.md`);
+  let raw;
+  try {
+    raw = await readFile7(archiveFilePath, "utf8");
+  } catch (error) {
+    if (findErrorCode(error, "ENOENT")) {
+      throw new Error("Task file not found", { cause: error });
+    }
+    throw new Error("Failed to read task file", { cause: error });
+  }
+  let split;
+  try {
+    split = splitFrontMatter(raw);
+  } catch (error) {
+    if (error instanceof Error && error.message === "Invalid task file format") {
+      throw error;
+    }
+    throw new Error("Failed to read task file", { cause: error });
+  }
+  let parsed;
+  try {
+    parsed = parseYaml(split.yamlText);
+  } catch (error) {
+    throw new Error("Failed to read task file", { cause: error });
+  }
+  const result = TaskSchema.safeParse(parsed);
+  if (!result.success) {
+    throw new Error("Failed to read task file", { cause: result.error });
+  }
+  return { doc: { task: result.data, body: split.body }, archived: true };
+}
+async function loadTaskEntries(paths, options = {}) {
+  const ids = await enumerateTaskIds(paths);
+  const entries = [];
+  for (const id of ids) {
+    let doc;
+    try {
+      doc = await readTaskFile(paths, id);
+    } catch (error) {
+      if (error instanceof Error && error.message === "Invalid task file format") {
+        options.onSkip?.(id, "task_file_invalid");
+      } else if (error instanceof Error && error.message === "Failed to read task file") {
+        options.onSkip?.(id, "task_file_invalid");
+      } else if (error instanceof Error && error.message === "Task file not found") {
+        options.onSkip?.(id, "task_file_unreadable");
+      } else {
+        options.onSkip?.(id, "task_file_unreadable");
+      }
+      continue;
+    }
+    entries.push(doc);
+  }
+  entries.sort((a, b) => {
+    const c = Date.parse(a.task.task.created_at) - Date.parse(b.task.task.created_at);
+    return c !== 0 ? c : a.task.task.id.localeCompare(b.task.task.id);
+  });
+  return entries;
+}
+var ALLOWED_TRANSITIONS = {
+  planned: /* @__PURE__ */ new Set(["in_progress", "done", "cancelled"]),
+  in_progress: /* @__PURE__ */ new Set(["done", "cancelled"]),
+  done: /* @__PURE__ */ new Set(),
+  cancelled: /* @__PURE__ */ new Set()
+};
+function assertTransitionAllowed(from, to) {
+  const allowed = ALLOWED_TRANSITIONS[from];
+  if (!allowed.has(to)) {
+    throw new Error(`Invalid task status transition: ${from} -> ${to}`);
+  }
+}
+var TaskWriteAfterEventError = class extends Error {
+  taskId;
+  eventId;
+  sessionId;
+  phase;
+  constructor(args) {
+    super("Failed to write task file after event was persisted", { cause: args.cause });
+    this.name = "TaskWriteAfterEventError";
+    this.taskId = args.taskId;
+    this.eventId = args.eventId;
+    this.sessionId = args.sessionId;
+    this.phase = args.phase;
+  }
+};
+function buildTaskCreatedEvent(input) {
+  return {
+    schema_version: "0.1.0",
+    id: input.eventId,
+    session_id: input.sessionId,
+    occurred_at: input.occurredAt,
+    source: "local-cli",
+    type: "task_created",
+    task_id: input.taskId,
+    title: input.title
+  };
+}
+function buildTaskStatusChangedEvent(input) {
+  return {
+    schema_version: "0.1.0",
+    id: input.eventId,
+    session_id: input.sessionId,
+    occurred_at: input.occurredAt,
+    source: "local-cli",
+    type: "task_status_changed",
+    task_id: input.taskId,
+    from: input.from,
+    to: input.to
+  };
+}
+function buildAdHocTaskLabel(title, mode) {
+  const truncated = title.length > LABEL_TITLE_MAX ? `${title.slice(0, LABEL_TRUNCATE_HEAD)}...` : title;
+  return mode === "new" ? `Ad-hoc task: ${truncated}` : `Ad-hoc task status: ${truncated}`;
+}
+function buildAdHocReconcileLabel(title) {
+  const truncated = title.length > LABEL_TITLE_MAX ? `${title.slice(0, LABEL_TRUNCATE_HEAD)}...` : title;
+  return `Ad-hoc task reconcile: ${truncated}`;
+}
+function buildAdHocRefreshLinkageLabel(title) {
+  const truncated = title.length > LABEL_TITLE_MAX ? `${title.slice(0, LABEL_TRUNCATE_HEAD)}...` : title;
+  return `Ad-hoc task refresh-linkage: ${truncated}`;
+}
+function buildAdHocDeleteLabel(title) {
+  const truncated = title.length > LABEL_TITLE_MAX ? `${title.slice(0, LABEL_TRUNCATE_HEAD)}...` : title;
+  return `Ad-hoc task delete: ${truncated}`;
+}
+function buildAdHocArchiveLabel(title) {
+  const truncated = title.length > LABEL_TITLE_MAX ? `${title.slice(0, LABEL_TRUNCATE_HEAD)}...` : title;
+  return `Ad-hoc task archive: ${truncated}`;
+}
+function buildTaskReconciledEvent(input) {
+  return {
+    schema_version: "0.1.0",
+    id: input.eventId,
+    session_id: input.sessionId,
+    occurred_at: input.occurredAt,
+    source: "local-cli",
+    type: "task_reconciled",
+    task_id: input.taskId,
+    removed_created_in_session: input.removedCreatedInSession,
+    created_in_session_replacement: input.createdInSessionReplacement,
+    removed_linked_sessions: input.removedLinkedSessions
+  };
+}
+function buildTaskDeletedEvent(input) {
+  return {
+    schema_version: "0.1.0",
+    id: input.eventId,
+    session_id: input.sessionId,
+    occurred_at: input.occurredAt,
+    source: "local-cli",
+    type: "task_deleted",
+    task_id: input.taskId,
+    title: input.title
+  };
+}
+function buildTaskArchivedEvent(input) {
+  return {
+    schema_version: "0.1.0",
+    id: input.eventId,
+    session_id: input.sessionId,
+    occurred_at: input.occurredAt,
+    source: "local-cli",
+    type: "task_archived",
+    task_id: input.taskId,
+    title: input.title
+  };
+}
+function buildTaskLinkageRefreshedEvent(input) {
+  return {
+    schema_version: "0.1.0",
+    id: input.eventId,
+    session_id: input.sessionId,
+    occurred_at: input.occurredAt,
+    source: "local-cli",
+    type: "task_linkage_refreshed",
+    task_id: input.taskId,
+    added_linked_sessions: input.addedLinkedSessions,
+    removed_linked_sessions: input.removedLinkedSessions,
+    final_count: input.finalCount
+  };
+}
+async function createTaskWithEvent(input) {
+  TaskIdSchema.parse(input.taskId);
+  InitialTaskStatusSchema.parse(input.initialStatus);
+  TaskTitleSchema.parse(input.title);
+  if (input.label !== void 0) {
+    TaskLabelSchema.parse(input.label);
+  }
+  if (input.completedAt !== void 0) {
+    CompletedAtSchema.parse(input.completedAt);
+  }
+  if (input.mode === "ad-hoc") {
+    return createTaskAdHoc(input);
+  }
+  return createTaskAttach(input);
+}
+async function createTaskAdHoc(input) {
+  const adHoc = await createAdHocSessionWithEvent({
+    paths: input.paths,
+    manifest: input.manifest,
+    label: buildAdHocTaskLabel(input.title, "new"),
+    occurredAt: input.occurredAt,
+    sessionSource: "human",
+    workingDirectory: input.workingDirectory,
+    invocation: {
+      command: "basou task new",
+      args: buildTaskNewInvocationArgs(input.title, input.initialStatus, input.completedAt)
+    },
+    taskId: input.taskId,
+    targetEventBuilders: buildTaskNewTargetEventBuilders({
+      taskId: input.taskId,
+      title: input.title,
+      initialStatus: input.initialStatus,
+      occurredAt: input.occurredAt
+    })
+  });
+  const task = buildInitialTask({
+    taskId: input.taskId,
+    title: input.title,
+    ...input.label !== void 0 ? { label: input.label } : {},
+    status: input.initialStatus,
+    occurredAt: input.occurredAt,
+    ...input.completedAt !== void 0 ? { completedAt: input.completedAt } : {},
+    workspaceId: input.manifest.workspace.id,
+    createdInSession: adHoc.sessionId
+  });
+  const anchorEventId = adHoc.targetEventIds[0];
+  try {
+    await writeTaskFile(
+      input.paths,
+      input.taskId,
+      { task, body: input.description },
+      { mode: "create" }
+    );
+  } catch (error) {
+    throw new TaskWriteAfterEventError({
+      taskId: input.taskId,
+      eventId: anchorEventId,
+      sessionId: adHoc.sessionId,
+      phase: "create",
+      cause: error
+    });
+  }
+  await safeUpdateTaskIndex(input.paths, { kind: "add", entry: buildTaskIndexEntry(task.task) });
+  return {
+    taskId: input.taskId,
+    eventId: anchorEventId,
+    sessionId: adHoc.sessionId,
+    sessionStatus: "completed"
+  };
+}
+async function createTaskAttach(input) {
+  SessionIdSchema.parse(input.sessionId);
+  const sessionLock = await acquireLock(input.paths, "session", input.sessionId);
+  try {
+    return await createTaskAttachLocked(input);
+  } finally {
+    await sessionLock.release();
+  }
+}
+async function createTaskAttachLocked(input) {
+  const sessionDoc = await readSessionYaml(input.paths, input.sessionId);
+  const status = sessionDoc.session.status;
+  if (status === "imported") {
+    throw new Error("Cannot attach to imported session");
+  }
+  const attachable = input.attachableStatuses ?? DEFAULT_ATTACHABLE_STATUSES2;
+  if (!attachable.has(status)) {
+    throw new Error(`Session is not active: ${status}`);
+  }
+  const existingTaskId = sessionDoc.session.task_id ?? null;
+  if (existingTaskId !== null && existingTaskId !== input.taskId) {
+    throw new Error(`Session already linked to a different task: ${existingTaskId}`);
+  }
+  if (existingTaskId === input.taskId) {
+    throw new Error(`Task already exists: ${input.taskId}`);
+  }
+  const appendResult = await appendEventToExistingSession({
+    paths: input.paths,
+    sessionId: input.sessionId,
+    ...input.attachableStatuses !== void 0 ? { attachableStatuses: input.attachableStatuses } : {},
+    eventBuilder: (eventId) => buildTaskCreatedEvent({
+      eventId,
+      sessionId: input.sessionId,
+      taskId: input.taskId,
+      title: input.title,
+      occurredAt: input.occurredAt
+    })
+  });
+  try {
+    const updated = {
+      ...sessionDoc,
+      session: { ...sessionDoc.session, task_id: input.taskId }
+    };
+    await overwriteYamlFile(join10(input.paths.sessions, input.sessionId, "session.yaml"), updated);
+  } catch (error) {
+    throw new TaskWriteAfterEventError({
+      taskId: input.taskId,
+      eventId: appendResult.eventId,
+      sessionId: input.sessionId,
+      phase: "link-session",
+      cause: error
+    });
+  }
+  if (isTerminalTaskStatus(input.initialStatus)) {
+    await appendEventToExistingSession({
+      paths: input.paths,
+      sessionId: input.sessionId,
+      ...input.attachableStatuses !== void 0 ? { attachableStatuses: input.attachableStatuses } : {},
+      eventBuilder: (eventId) => buildTaskStatusChangedEvent({
+        eventId,
+        sessionId: input.sessionId,
+        taskId: input.taskId,
+        from: "planned",
+        to: input.initialStatus,
+        occurredAt: input.occurredAt
+      })
+    });
+  }
+  const task = buildInitialTask({
+    taskId: input.taskId,
+    title: input.title,
+    ...input.label !== void 0 ? { label: input.label } : {},
+    status: input.initialStatus,
+    occurredAt: input.occurredAt,
+    ...input.completedAt !== void 0 ? { completedAt: input.completedAt } : {},
+    workspaceId: sessionDoc.session.workspace_id,
+    createdInSession: input.sessionId
+  });
+  try {
+    await writeTaskFile(
+      input.paths,
+      input.taskId,
+      { task, body: input.description },
+      { mode: "create" }
+    );
+  } catch (error) {
+    throw new TaskWriteAfterEventError({
+      taskId: input.taskId,
+      eventId: appendResult.eventId,
+      sessionId: input.sessionId,
+      phase: "create",
+      cause: error
+    });
+  }
+  await safeUpdateTaskIndex(input.paths, { kind: "add", entry: buildTaskIndexEntry(task.task) });
+  return {
+    taskId: input.taskId,
+    eventId: appendResult.eventId,
+    sessionId: input.sessionId,
+    sessionStatus: status
+  };
+}
+function buildInitialTask(input) {
+  const updatedAt = input.completedAt !== void 0 && isTerminalTaskStatus(input.status) ? input.completedAt : input.occurredAt;
+  return {
+    schema_version: "0.1.0",
+    task: {
+      id: input.taskId,
+      title: input.title,
+      ...input.label !== void 0 ? { label: input.label } : {},
+      status: input.status,
+      created_at: input.occurredAt,
+      updated_at: updatedAt,
+      workspace_id: input.workspaceId,
+      created_in_session: input.createdInSession,
+      linked_sessions: [input.createdInSession]
+    }
+  };
+}
+function buildTaskNewInvocationArgs(title, initialStatus, completedAt) {
+  const args = ["--title", title];
+  if (initialStatus !== "planned") {
+    args.push("--status", initialStatus);
+  }
+  if (completedAt !== void 0 && isTerminalTaskStatus(initialStatus)) {
+    args.push("--completed-at", completedAt);
+  }
+  return args;
+}
+function buildTaskNewTargetEventBuilders(input) {
+  const createdBuilder = (sessionId, eventId) => buildTaskCreatedEvent({
+    eventId,
+    sessionId,
+    taskId: input.taskId,
+    title: input.title,
+    occurredAt: input.occurredAt
+  });
+  if (!isTerminalTaskStatus(input.initialStatus)) {
+    return [createdBuilder];
+  }
+  const statusChangedBuilder = (sessionId, eventId) => buildTaskStatusChangedEvent({
+    eventId,
+    sessionId,
+    taskId: input.taskId,
+    from: "planned",
+    to: input.initialStatus,
+    occurredAt: input.occurredAt
+  });
+  return [createdBuilder, statusChangedBuilder];
+}
+async function updateTaskStatusWithEvent(input) {
+  TaskIdSchema.parse(input.taskId);
+  const handle = await acquireLock(input.paths, "task", input.taskId);
+  try {
+    const currentDoc = await readTaskFile(input.paths, input.taskId);
+    const previousStatus = currentDoc.task.task.status;
+    assertTransitionAllowed(previousStatus, input.newStatus);
+    if (input.mode === "ad-hoc") {
+      return await updateTaskStatusAdHoc(input, currentDoc, previousStatus);
+    }
+    return await updateTaskStatusAttach(input, currentDoc, previousStatus);
+  } finally {
+    await handle.release();
+  }
+}
+async function updateTaskStatusAdHoc(input, currentDoc, previousStatus) {
+  const title = currentDoc.task.task.title;
+  const adHoc = await createAdHocSessionWithEvent({
+    paths: input.paths,
+    manifest: input.manifest,
+    label: buildAdHocTaskLabel(title, "status"),
+    occurredAt: input.occurredAt,
+    sessionSource: "human",
+    workingDirectory: input.workingDirectory,
+    invocation: { command: "basou task status", args: [input.taskId, input.newStatus] },
+    taskId: input.taskId,
+    targetEventBuilders: [
+      (sessionId, eventId) => buildTaskStatusChangedEvent({
+        eventId,
+        sessionId,
+        taskId: input.taskId,
+        from: previousStatus,
+        to: input.newStatus,
+        occurredAt: input.occurredAt
+      })
+    ]
+  });
+  const anchorEventId = adHoc.targetEventIds[0];
+  const updatedDoc = buildUpdatedDoc({
+    currentDoc,
+    newStatus: input.newStatus,
+    occurredAt: input.occurredAt,
+    appendSessionId: adHoc.sessionId
+  });
+  try {
+    await writeTaskFile(input.paths, input.taskId, updatedDoc, { mode: "overwrite" });
+  } catch (error) {
+    throw new TaskWriteAfterEventError({
+      taskId: input.taskId,
+      eventId: anchorEventId,
+      sessionId: adHoc.sessionId,
+      phase: "overwrite",
+      cause: error
+    });
+  }
+  await safeUpdateTaskIndex(input.paths, {
+    kind: "update",
+    entry: buildTaskIndexEntry(updatedDoc.task.task)
+  });
+  return {
+    taskId: input.taskId,
+    eventId: anchorEventId,
+    sessionId: adHoc.sessionId,
+    sessionStatus: "completed",
+    previousStatus,
+    newStatus: input.newStatus
+  };
+}
+async function updateTaskStatusAttach(input, currentDoc, previousStatus) {
+  SessionIdSchema.parse(input.sessionId);
+  const sessionLock = await acquireLock(input.paths, "session", input.sessionId);
+  try {
+    return await updateTaskStatusAttachLocked(input, currentDoc, previousStatus);
+  } finally {
+    await sessionLock.release();
+  }
+}
+async function updateTaskStatusAttachLocked(input, currentDoc, previousStatus) {
+  const sessionDoc = await readSessionYaml(input.paths, input.sessionId);
+  const status = sessionDoc.session.status;
+  if (status === "imported") {
+    throw new Error("Cannot attach to imported session");
+  }
+  const attachable = input.attachableStatuses ?? DEFAULT_ATTACHABLE_STATUSES2;
+  if (!attachable.has(status)) {
+    throw new Error(`Session is not active: ${status}`);
+  }
+  const existingTaskId = sessionDoc.session.task_id ?? null;
+  if (existingTaskId === null) {
+    throw new Error(`Session is not linked to task: ${input.taskId}`);
+  }
+  if (existingTaskId !== input.taskId) {
+    throw new Error(`Session already linked to a different task: ${existingTaskId}`);
+  }
+  const appendResult = await appendEventToExistingSession({
+    paths: input.paths,
+    sessionId: input.sessionId,
+    ...input.attachableStatuses !== void 0 ? { attachableStatuses: input.attachableStatuses } : {},
+    eventBuilder: (eventId) => buildTaskStatusChangedEvent({
+      eventId,
+      sessionId: input.sessionId,
+      taskId: input.taskId,
+      from: previousStatus,
+      to: input.newStatus,
+      occurredAt: input.occurredAt
+    })
+  });
+  const updatedDoc = buildUpdatedDoc({
+    currentDoc,
+    newStatus: input.newStatus,
+    occurredAt: input.occurredAt,
+    appendSessionId: input.sessionId
+  });
+  try {
+    await writeTaskFile(input.paths, input.taskId, updatedDoc, { mode: "overwrite" });
+  } catch (error) {
+    throw new TaskWriteAfterEventError({
+      taskId: input.taskId,
+      eventId: appendResult.eventId,
+      sessionId: input.sessionId,
+      phase: "overwrite",
+      cause: error
+    });
+  }
+  await safeUpdateTaskIndex(input.paths, {
+    kind: "update",
+    entry: buildTaskIndexEntry(updatedDoc.task.task)
+  });
+  return {
+    taskId: input.taskId,
+    eventId: appendResult.eventId,
+    sessionId: input.sessionId,
+    sessionStatus: status,
+    previousStatus,
+    newStatus: input.newStatus
+  };
+}
+function buildUpdatedDoc(input) {
+  const linked = input.currentDoc.task.task.linked_sessions;
+  const merged = linked.includes(input.appendSessionId) ? linked : [...linked, input.appendSessionId];
+  const next = {
+    ...input.currentDoc.task,
+    task: {
+      ...input.currentDoc.task.task,
+      status: input.newStatus,
+      updated_at: input.occurredAt,
+      linked_sessions: merged
+    }
+  };
+  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 hash = createHash("sha256").update(raw).digest("hex");
+  return { mtimeMs: stats.mtimeMs, hash };
+}
+async function readTaskFileWithSnapshot(paths, taskId) {
+  const filePath = join10(paths.tasks, `${taskId}.md`);
+  let rawBuffer;
+  let stats;
+  try {
+    [rawBuffer, stats] = await Promise.all([readFile7(filePath), stat2(filePath)]);
+  } catch (error) {
+    if (findErrorCode(error, "ENOENT")) {
+      throw new Error("Task file not found", { cause: error });
+    }
+    throw new Error("Failed to read task file", { cause: error });
+  }
+  const raw = rawBuffer.toString("utf8");
+  const hash = createHash("sha256").update(rawBuffer).digest("hex");
+  let split;
+  try {
+    split = splitFrontMatter(raw);
+  } catch (error) {
+    if (error instanceof Error && error.message === "Invalid task file format") {
+      throw error;
+    }
+    throw new Error("Failed to read task file", { cause: error });
+  }
+  let parsed;
+  try {
+    parsed = parseYaml(split.yamlText);
+  } catch (error) {
+    throw new Error("Failed to read task file", { cause: error });
+  }
+  const result = TaskSchema.safeParse(parsed);
+  if (!result.success) {
+    throw new Error("Failed to read task file", { cause: result.error });
+  }
+  return {
+    doc: { task: result.data, body: split.body },
+    snapshot: { mtimeMs: stats.mtimeMs, hash }
+  };
+}
+async function detectBrokenRefs(paths, task) {
+  const sessionDirs = new Set(await enumerateSessionDirs(paths));
+  const brokenCreatedInSession = sessionDirs.has(task.created_in_session) ? null : task.created_in_session;
+  const seen = /* @__PURE__ */ new Set();
+  const brokenLinkedSessions = [];
+  for (const sid of task.linked_sessions) {
+    if (sessionDirs.has(sid)) continue;
+    if (seen.has(sid)) continue;
+    seen.add(sid);
+    brokenLinkedSessions.push(sid);
+  }
+  return { brokenCreatedInSession, brokenLinkedSessions };
+}
+function buildReconciledDoc(input) {
+  const brokenSet = new Set(input.brokenLinkedSessions);
+  const filtered = input.currentDoc.task.task.linked_sessions.filter((sid) => !brokenSet.has(sid));
+  const merged = [...filtered];
+  if (!merged.includes(input.reconcileSessionId)) {
+    merged.push(input.reconcileSessionId);
+  }
+  const nextCreatedInSession = input.brokenCreatedInSession !== null ? input.reconcileSessionId : input.currentDoc.task.task.created_in_session;
+  const next = {
+    ...input.currentDoc.task,
+    task: {
+      ...input.currentDoc.task.task,
+      created_in_session: nextCreatedInSession,
+      updated_at: input.occurredAt,
+      linked_sessions: merged
+    }
+  };
+  return { task: next, body: input.currentDoc.body };
+}
+async function reconcileTask(paths, manifest, input) {
+  TaskIdSchema.parse(input.taskId);
+  const handle = await acquireLock(paths, "task", input.taskId);
+  try {
+    return await reconcileTaskLocked(paths, manifest, input);
+  } finally {
+    await handle.release();
+  }
+}
+async function reconcileTaskLocked(paths, manifest, input) {
+  const { doc: currentDoc, snapshot: preSnapshot } = await readTaskFileWithSnapshot(
+    paths,
+    input.taskId
+  );
+  const { brokenCreatedInSession, brokenLinkedSessions } = await detectBrokenRefs(
+    paths,
+    currentDoc.task.task
+  );
+  if (brokenCreatedInSession === null && brokenLinkedSessions.length === 0) {
+    return {
+      taskId: input.taskId,
+      clean: true,
+      brokenCreatedInSession: null,
+      brokenLinkedSessions: [],
+      reconcileSession: null
+    };
+  }
+  if (!input.write) {
+    return {
+      taskId: input.taskId,
+      clean: false,
+      brokenCreatedInSession,
+      brokenLinkedSessions,
+      reconcileSession: null
+    };
+  }
+  if (input._onPhaseCompleted !== void 0) {
+    await input._onPhaseCompleted("phase-4-snapshot");
+  }
+  let adHoc;
+  try {
+    adHoc = await createAdHocSessionWithEvent({
+      paths,
+      manifest,
+      label: buildAdHocReconcileLabel(currentDoc.task.task.title),
+      occurredAt: input.occurredAt,
+      sessionSource: "human",
+      workingDirectory: input.workingDirectory,
+      invocation: {
+        command: "basou task reconcile",
+        args: (input.scope ?? "single") === "single" ? ["--task", input.taskId, "--write"] : ["--write"]
+      },
+      taskId: input.taskId,
+      targetEventBuilders: [
+        (sessionId, eventId) => buildTaskReconciledEvent({
+          eventId,
+          sessionId,
+          taskId: input.taskId,
+          removedCreatedInSession: brokenCreatedInSession,
+          createdInSessionReplacement: brokenCreatedInSession !== null ? sessionId : null,
+          removedLinkedSessions: brokenLinkedSessions,
+          occurredAt: input.occurredAt
+        })
+      ]
+    });
+  } catch (error) {
+    if (error instanceof FailedToFinalizeError) {
+      throw new TaskWriteAfterEventError({
+        taskId: input.taskId,
+        eventId: error.targetEventIds[0],
+        sessionId: error.sessionId,
+        phase: "reconcile-finalize",
+        cause: error
+      });
+    }
+    throw error;
+  }
+  if (input._onPhaseCompleted !== void 0) {
+    await input._onPhaseCompleted("phase-5-bulk-write");
+  }
+  const anchorEventId = adHoc.targetEventIds[0];
+  const postSnapshot = await computeTaskMdSnapshot(paths, input.taskId);
+  if (postSnapshot.mtimeMs !== preSnapshot.mtimeMs || postSnapshot.hash !== preSnapshot.hash) {
+    throw new TaskWriteAfterEventError({
+      taskId: input.taskId,
+      eventId: anchorEventId,
+      sessionId: adHoc.sessionId,
+      phase: "reconcile-concurrent",
+      cause: new Error("task.md changed during reconcile")
+    });
+  }
+  const repaired = buildReconciledDoc({
+    currentDoc,
+    brokenCreatedInSession,
+    brokenLinkedSessions,
+    reconcileSessionId: adHoc.sessionId,
+    occurredAt: input.occurredAt
+  });
+  try {
+    await writeTaskFile(paths, input.taskId, repaired, { mode: "overwrite" });
+  } catch (error) {
+    throw new TaskWriteAfterEventError({
+      taskId: input.taskId,
+      eventId: anchorEventId,
+      sessionId: adHoc.sessionId,
+      phase: "reconcile",
+      cause: error
+    });
+  }
+  await safeUpdateTaskIndex(paths, {
+    kind: "update",
+    entry: buildTaskIndexEntry(repaired.task.task)
+  });
+  return {
+    taskId: input.taskId,
+    clean: false,
+    brokenCreatedInSession,
+    brokenLinkedSessions,
+    reconcileSession: {
+      sessionId: adHoc.sessionId,
+      eventId: anchorEventId
+    }
+  };
+}
+async function reconcileAllTasks(paths, manifest, input, options = {}) {
+  const taskIds = await enumerateTaskIds(paths);
+  const results = [];
+  const failed = [];
+  let scanned = 0;
+  for (const id of taskIds) {
+    try {
+      await readTaskFile(paths, id);
+    } catch {
+      continue;
+    }
+    scanned += 1;
+    try {
+      const r = await reconcileTask(paths, manifest, {
+        taskId: id,
+        occurredAt: input.occurredAt(),
+        workingDirectory: input.workingDirectory,
+        write: input.write,
+        scope: "all"
+      });
+      if (options.includeClean === true || !r.clean) {
+        results.push(r);
+      }
+    } catch (error) {
+      const errorClass = error instanceof Error ? error.constructor.name : "Error";
+      const phase = error instanceof TaskWriteAfterEventError ? error.phase : null;
+      failed.push({
+        taskId: id,
+        errorClass,
+        phase
+      });
+    }
+  }
+  return { results, failed, scanned };
+}
+async function detectLinkageDelta(paths, task) {
+  const sessionIds = await enumerateSessionDirs(paths);
+  const reachable = /* @__PURE__ */ new Set();
+  for (const sid of sessionIds) {
+    try {
+      const doc = await readSessionYaml(paths, sid);
+      if (doc.session.task_id === task.id) {
+        reachable.add(sid);
+      }
+    } catch {
+    }
+  }
+  const finalSet = new Set(reachable);
+  finalSet.add(task.created_in_session);
+  const currentSet = new Set(task.linked_sessions);
+  const addedLinkedSessions = [];
+  const removedLinkedSessions = [];
+  for (const sid of finalSet) {
+    if (!currentSet.has(sid)) addedLinkedSessions.push(sid);
+  }
+  for (const sid of currentSet) {
+    if (!finalSet.has(sid)) removedLinkedSessions.push(sid);
+  }
+  addedLinkedSessions.sort();
+  removedLinkedSessions.sort();
+  const finalLinkedSessions = [...finalSet].sort();
+  return { addedLinkedSessions, removedLinkedSessions, finalLinkedSessions };
+}
+function buildRefreshedDoc(input) {
+  const merged = new Set(input.finalLinkedSessions);
+  merged.add(input.refreshSessionId);
+  const linked = [...merged].sort();
+  const next = {
+    ...input.currentDoc.task,
+    task: {
+      ...input.currentDoc.task.task,
+      updated_at: input.occurredAt,
+      linked_sessions: linked
+    }
+  };
+  return { task: next, body: input.currentDoc.body };
+}
+async function refreshTaskLinkedSessions(paths, manifest, input) {
+  TaskIdSchema.parse(input.taskId);
+  const handle = await acquireLock(paths, "task", input.taskId);
+  try {
+    return await refreshTaskLinkedSessionsLocked(paths, manifest, input);
+  } finally {
+    await handle.release();
+  }
+}
+async function refreshTaskLinkedSessionsLocked(paths, manifest, input) {
+  const { doc: currentDoc, snapshot: preSnapshot } = await readTaskFileWithSnapshot(
+    paths,
+    input.taskId
+  );
+  const { addedLinkedSessions, removedLinkedSessions, finalLinkedSessions } = await detectLinkageDelta(paths, currentDoc.task.task);
+  if (addedLinkedSessions.length === 0 && removedLinkedSessions.length === 0) {
+    return {
+      taskId: input.taskId,
+      clean: true,
+      addedLinkedSessions: [],
+      removedLinkedSessions: [],
+      finalCount: finalLinkedSessions.length,
+      refreshSession: null
+    };
+  }
+  if (!input.write) {
+    return {
+      taskId: input.taskId,
+      clean: false,
+      addedLinkedSessions,
+      removedLinkedSessions,
+      finalCount: finalLinkedSessions.length,
+      refreshSession: null
+    };
+  }
+  const finalCountWithRefreshSession = finalLinkedSessions.length + 1;
+  let adHoc;
+  try {
+    adHoc = await createAdHocSessionWithEvent({
+      paths,
+      manifest,
+      label: buildAdHocRefreshLinkageLabel(currentDoc.task.task.title),
+      occurredAt: input.occurredAt,
+      sessionSource: "human",
+      workingDirectory: input.workingDirectory,
+      invocation: {
+        command: "basou task refresh-linkage",
+        args: [input.taskId, "--write"]
+      },
+      taskId: input.taskId,
+      targetEventBuilders: [
+        (sessionId, eventId) => buildTaskLinkageRefreshedEvent({
+          eventId,
+          sessionId,
+          taskId: input.taskId,
+          addedLinkedSessions,
+          removedLinkedSessions,
+          finalCount: finalCountWithRefreshSession,
+          occurredAt: input.occurredAt
+        })
+      ]
+    });
+  } catch (error) {
+    if (error instanceof FailedToFinalizeError) {
+      throw new TaskWriteAfterEventError({
+        taskId: input.taskId,
+        eventId: error.targetEventIds[0],
+        sessionId: error.sessionId,
+        phase: "linkage-refresh-finalize",
+        cause: error
+      });
+    }
+    throw error;
+  }
+  const anchorEventId = adHoc.targetEventIds[0];
+  const postSnapshot = await computeTaskMdSnapshot(paths, input.taskId);
+  if (postSnapshot.mtimeMs !== preSnapshot.mtimeMs || postSnapshot.hash !== preSnapshot.hash) {
+    throw new TaskWriteAfterEventError({
+      taskId: input.taskId,
+      eventId: anchorEventId,
+      sessionId: adHoc.sessionId,
+      phase: "linkage-refresh-concurrent",
+      cause: new Error("task.md changed during linkage refresh")
+    });
+  }
+  const refreshed = buildRefreshedDoc({
+    currentDoc,
+    finalLinkedSessions,
+    refreshSessionId: adHoc.sessionId,
+    occurredAt: input.occurredAt
+  });
+  try {
+    await writeTaskFile(paths, input.taskId, refreshed, { mode: "overwrite" });
+  } catch (error) {
+    throw new TaskWriteAfterEventError({
+      taskId: input.taskId,
+      eventId: anchorEventId,
+      sessionId: adHoc.sessionId,
+      phase: "linkage-refresh",
+      cause: error
+    });
+  }
+  await safeUpdateTaskIndex(paths, {
+    kind: "update",
+    entry: buildTaskIndexEntry(refreshed.task.task)
+  });
+  return {
+    taskId: input.taskId,
+    clean: false,
+    addedLinkedSessions,
+    removedLinkedSessions,
+    finalCount: finalCountWithRefreshSession,
+    refreshSession: {
+      sessionId: adHoc.sessionId,
+      eventId: anchorEventId
+    }
+  };
+}
+async function editTask(input) {
+  TaskIdSchema.parse(input.taskId);
+  if (input.title === void 0 && input.newStatus === void 0) {
+    throw new Error("Nothing to edit: provide --title or --status");
+  }
+  if (input.title !== void 0) {
+    TaskTitleSchema.parse(input.title);
+  }
+  let statusUpdated = false;
+  let previousStatus = null;
+  let newStatus = null;
+  let statusChangeSession = null;
+  if (input.newStatus !== void 0) {
+    if (input.manifest === void 0 || input.workingDirectory === void 0) {
+      throw new Error("editTask requires manifest + workingDirectory when newStatus is supplied");
+    }
+    const result = await updateTaskStatusWithEvent({
+      mode: "ad-hoc",
+      paths: input.paths,
+      manifest: input.manifest,
+      occurredAt: input.occurredAt,
+      taskId: input.taskId,
+      newStatus: input.newStatus,
+      workingDirectory: input.workingDirectory
+    });
+    statusUpdated = true;
+    previousStatus = result.previousStatus;
+    newStatus = result.newStatus;
+    statusChangeSession = { sessionId: result.sessionId, eventId: result.eventId };
+  }
+  let titleUpdated = false;
+  if (input.title !== void 0) {
+    const handle = await acquireLock(input.paths, "task", input.taskId);
+    try {
+      const doc = await readTaskFile(input.paths, input.taskId);
+      if (doc.task.task.title !== input.title) {
+        const next = {
+          ...doc.task,
+          task: {
+            ...doc.task.task,
+            title: input.title,
+            updated_at: input.occurredAt
+          }
+        };
+        await writeTaskFile(
+          input.paths,
+          input.taskId,
+          { task: next, body: doc.body },
+          { mode: "overwrite" }
+        );
+        await safeUpdateTaskIndex(input.paths, {
+          kind: "update",
+          entry: buildTaskIndexEntry(next.task)
+        });
+        titleUpdated = true;
+      }
+    } finally {
+      await handle.release();
+    }
+  }
+  return {
+    taskId: input.taskId,
+    titleUpdated,
+    statusUpdated,
+    previousStatus,
+    newStatus,
+    statusChangeSession
+  };
+}
+async function deleteTask(input) {
+  TaskIdSchema.parse(input.taskId);
+  const handle = await acquireLock(input.paths, "task", input.taskId);
+  try {
+    return await deleteTaskLocked(input);
+  } finally {
+    await handle.release();
+  }
+}
+async function deleteTaskLocked(input) {
+  const doc = await readTaskFile(input.paths, input.taskId);
+  const title = doc.task.task.title;
+  const adHoc = await createAdHocSessionWithEvent({
+    paths: input.paths,
+    manifest: input.manifest,
+    label: buildAdHocDeleteLabel(title),
+    occurredAt: input.occurredAt,
+    sessionSource: "human",
+    workingDirectory: input.workingDirectory,
+    invocation: {
+      command: "basou task delete",
+      args: [input.taskId, "--yes"]
+    },
+    targetEventBuilders: [
+      (sessionId, eventId2) => buildTaskDeletedEvent({
+        eventId: eventId2,
+        sessionId,
+        taskId: input.taskId,
+        title,
+        occurredAt: input.occurredAt
+      })
+    ]
+  });
+  const eventId = adHoc.targetEventIds[0];
+  try {
+    await unlink3(join10(input.paths.tasks, `${input.taskId}.md`));
+  } catch (error) {
+    throw new TaskWriteAfterEventError({
+      taskId: input.taskId,
+      eventId,
+      sessionId: adHoc.sessionId,
+      phase: "delete",
+      cause: error
+    });
+  }
+  await safeUpdateTaskIndex(input.paths, { kind: "remove", id: input.taskId });
+  return {
+    taskId: input.taskId,
+    title,
+    sessionId: adHoc.sessionId,
+    eventId
+  };
+}
+async function archiveTask(input) {
+  TaskIdSchema.parse(input.taskId);
+  const handle = await acquireLock(input.paths, "task", input.taskId);
+  try {
+    return await archiveTaskLocked(input);
+  } finally {
+    await handle.release();
+  }
+}
+async function archiveTaskLocked(input) {
+  const doc = await readTaskFile(input.paths, input.taskId);
+  const title = doc.task.task.title;
+  const adHoc = await createAdHocSessionWithEvent({
+    paths: input.paths,
+    manifest: input.manifest,
+    label: buildAdHocArchiveLabel(title),
+    occurredAt: input.occurredAt,
+    sessionSource: "human",
+    workingDirectory: input.workingDirectory,
+    invocation: {
+      command: "basou task archive",
+      args: [input.taskId, "--yes"]
+    },
+    taskId: input.taskId,
+    targetEventBuilders: [
+      (sessionId, eventId2) => buildTaskArchivedEvent({
+        eventId: eventId2,
+        sessionId,
+        taskId: input.taskId,
+        title,
+        occurredAt: input.occurredAt
+      })
+    ]
+  });
+  const eventId = adHoc.targetEventIds[0];
+  try {
+    const linked = doc.task.task.linked_sessions;
+    const merged = linked.includes(adHoc.sessionId) ? linked : [...linked, adHoc.sessionId];
+    const next = {
+      ...doc.task,
+      task: {
+        ...doc.task.task,
+        updated_at: input.occurredAt,
+        linked_sessions: merged
+      }
+    };
+    await writeTaskFile(
+      input.paths,
+      input.taskId,
+      { task: next, body: doc.body },
+      { mode: "overwrite" }
+    );
+    await mkdir3(archiveTasksDir(input.paths), { recursive: true });
+    await rename2(
+      join10(input.paths.tasks, `${input.taskId}.md`),
+      join10(archiveTasksDir(input.paths), `${input.taskId}.md`)
+    );
+  } 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}`);
+  }
+  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/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);
+  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 tasksCreated = [];
+  const tasksStatusChanged = [];
+  for (const entry of entries) {
+    const sessionDir = join12(input.paths.sessions, entry.sessionId);
+    try {
+      for await (const ev of replayEvents(sessionDir, {
+        onWarning: (w) => input.onWarning?.(w, entry.sessionId)
+      })) {
+        if (ev.type === "decision_recorded") {
+          decisions.push({
+            decisionId: ev.decision_id,
+            title: ev.title,
+            occurredAt: ev.occurred_at,
+            sessionId: entry.sessionId
+          });
+        } else if (ev.type === "task_created") {
+          tasksCreated.push({
+            taskId: ev.task_id,
+            title: ev.title,
+            occurredAt: ev.occurred_at,
+            sessionId: entry.sessionId
+          });
+        } else if (ev.type === "task_status_changed") {
+          tasksStatusChanged.push({
+            taskId: ev.task_id,
+            occurredAt: ev.occurred_at,
+            sessionId: entry.sessionId
+          });
+        }
+      }
+    } 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);
+  });
+  tasksCreated.sort((a, b) => {
+    const c = Date.parse(a.occurredAt) - Date.parse(b.occurredAt);
+    return c !== 0 ? c : a.taskId.localeCompare(b.taskId);
+  });
+  tasksStatusChanged.sort((a, b) => {
+    const c = Date.parse(a.occurredAt) - Date.parse(b.occurredAt);
+    return c !== 0 ? c : a.taskId.localeCompare(b.taskId);
+  });
+  const taskLoadOpts = {};
+  if (input.onTaskSkip !== void 0) taskLoadOpts.onSkip = input.onTaskSkip;
+  const taskEntries = await loadTaskEntries(input.paths, taskLoadOpts);
+  const taskById = /* @__PURE__ */ new Map();
+  for (const t of taskEntries) taskById.set(t.task.task.id, t);
+  const latestStatusChange = tasksStatusChanged[tasksStatusChanged.length - 1];
+  const latestCreatedRecord = tasksCreated[tasksCreated.length - 1];
+  const latestActivityTaskId = latestStatusChange?.taskId ?? latestCreatedRecord?.taskId;
+  const latestActivityTitle = latestActivityTaskId !== void 0 ? tasksCreated.find((t) => t.taskId === latestActivityTaskId)?.title ?? "(title unknown)" : void 0;
+  const latestActivityRecord = latestActivityTaskId !== void 0 && latestActivityTitle !== void 0 ? { taskId: latestActivityTaskId, title: latestActivityTitle } : void 0;
+  const latestTaskDoc = latestActivityRecord !== void 0 ? taskById.get(latestActivityRecord.taskId) : void 0;
+  const pendingTasks = taskEntries.filter(
+    (t) => t.task.task.status === "planned" || t.task.task.status === "in_progress"
+  );
+  const approvals = await enumerateApprovals(input.paths);
+  const pendingApprovalsCount = approvals.pending.length;
+  const liveEntries = entries.filter(
+    (e) => e.session.session.status !== "archived" && e.session.session.source.kind !== "import"
+  );
+  const latestSession = [...liveEntries].sort(
+    (a, b) => Date.parse(b.session.session.started_at) - Date.parse(a.session.session.started_at)
+  )[0];
+  const allFiles = /* @__PURE__ */ new Set();
+  for (const e of entries) {
+    if (e.session.session.source.kind === "import") continue;
+    for (const f of e.session.session.related_files) allFiles.add(f);
+  }
+  const sortedFiles = [...allFiles].sort();
+  const displayedFiles = sortedFiles.slice(0, limit);
+  const overflow = Math.max(0, sortedFiles.length - limit);
+  const suspectCount = entries.filter((e) => e.suspect).length;
+  const firstEntry = entries[0];
+  const lastEntry = entries[entries.length - 1];
+  const sessionRange = firstEntry !== void 0 && lastEntry !== void 0 ? `${firstEntry.sessionId}..${lastEntry.sessionId}` : "";
+  const body = formatHandoffBody({
+    nowIso: input.nowIso,
+    sessionRange,
+    sessionCount: entries.length,
+    latestSession,
+    decisions,
+    pendingApprovalsCount,
+    suspectCount,
+    displayedFiles,
+    overflow,
+    entries,
+    latestActivityRecord,
+    latestTaskDoc,
+    pendingTasks,
+    totalTaskCount: taskEntries.length
+  });
+  return {
+    body,
+    sessionCount: entries.length,
+    decisionCount: decisions.length,
+    pendingApprovalsCount,
+    suspectCount,
+    taskCount: taskEntries.length,
+    pendingTaskCount: pendingTasks.length
+  };
+}
+function formatHandoffBody(args) {
+  const lines = [];
+  lines.push("# Handoff");
+  lines.push("");
+  if (args.sessionRange !== "") {
+    lines.push(`> Generated at ${args.nowIso} from ${args.sessionRange}`);
+  } else {
+    lines.push(`> Generated at ${args.nowIso}`);
+  }
+  lines.push("");
+  lines.push("## \u73FE\u5728\u306E\u72B6\u614B");
+  lines.push("");
+  if (args.latestSession !== void 0) {
+    const sid = args.latestSession.sessionId;
+    const status = args.latestSession.session.session.status;
+    lines.push(`- \u6700\u7D42 session: ${sid} (${status})`);
+  } else {
+    lines.push("- \u6700\u7D42 session: (no live sessions)");
+  }
+  if (args.latestActivityRecord !== void 0) {
+    const statusLabel = args.latestTaskDoc !== void 0 ? args.latestTaskDoc.task.task.status : "status unknown \u2014 task.md missing or invalid";
+    const linkedCount = args.latestTaskDoc?.task.task.linked_sessions?.length;
+    const linkedSuffix = linkedCount !== void 0 && linkedCount > 1 ? ` (linked_sessions: ${linkedCount})` : "";
+    lines.push(
+      `- \u6700\u7D42 task: ${args.latestActivityRecord.taskId} (${statusLabel}): ${args.latestActivityRecord.title}${linkedSuffix}`
+    );
+  } else {
+    lines.push("- \u6700\u7D42 task: (no tasks recorded yet)");
+  }
+  lines.push("");
+  lines.push("## \u76F4\u8FD1\u306E\u5909\u66F4\u30D5\u30A1\u30A4\u30EB");
+  lines.push("");
+  if (args.displayedFiles.length === 0) {
+    lines.push("(no related files recorded)");
+  } else {
+    for (const f of args.displayedFiles) lines.push(`- ${f}`);
+    if (args.overflow > 0) lines.push(`- ... +${args.overflow} more`);
+  }
+  lines.push("");
+  lines.push("## \u76F4\u8FD1\u306E\u5224\u65AD");
+  lines.push("");
+  if (args.decisions.length === 0) {
+    lines.push("(no decisions recorded yet)");
+  } else {
+    const last = args.decisions[args.decisions.length - 1];
+    lines.push(`- ${last.decisionId}: ${last.title}`);
+    lines.push("");
+    lines.push(`(${args.decisions.length} decisions total \u2014 see decisions.md)`);
+  }
+  lines.push("");
+  lines.push("## \u672A\u6C7A\u4E8B\u9805");
+  lines.push("");
+  if (args.pendingApprovalsCount > 0) {
+    lines.push(`- ${args.pendingApprovalsCount} pending approvals`);
+  }
+  if (args.suspectCount > 0) {
+    lines.push(`- ${args.suspectCount} suspect sessions detected`);
+  }
+  if (args.pendingApprovalsCount === 0 && args.suspectCount === 0) {
+    lines.push("(none)");
+  }
+  lines.push("");
+  lines.push("## \u6B21\u306B\u8AAD\u3080\u3079\u304D\u30D5\u30A1\u30A4\u30EB");
+  lines.push("");
+  lines.push("- .basou/decisions.md");
+  for (const f of args.displayedFiles.slice(0, 3)) lines.push(`- ${f}`);
+  lines.push("");
+  lines.push("## \u6B21\u306B\u5B9F\u884C\u3059\u3079\u304D\u4F5C\u696D");
+  lines.push("");
+  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(", ")}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function shortDecisionSessionId(sessionId) {
+  const SES = "ses_";
+  if (sessionId.startsWith(SES)) return sessionId.slice(SES.length, SES.length + 10);
+  return sessionId.slice(0, 10);
+}
+
+// src/runtime/child-process-runner.ts
+import { spawn } from "child_process";
+var DEFAULT_KILL_GRACE_MS = 5e3;
+var ChildProcessRunner = class {
+  async run(command, args, options) {
+    validateOptions(options);
+    if (options.signal?.aborted) {
+      throw new Error("Process aborted before spawn", {
+        cause: options.signal.reason
+      });
+    }
+    const snapshotCommand = command;
+    const snapshotArgs = [...args];
+    const snapshotCwd = options.cwd;
+    const captureMode = options.capture ?? "buffer";
+    const started_at = /* @__PURE__ */ new Date();
+    let child;
+    try {
+      child = spawn(snapshotCommand, [...snapshotArgs], {
+        cwd: snapshotCwd,
+        env: options.env ?? process.env,
+        stdio: captureMode === "none" ? ["inherit", "inherit", "inherit"] : ["pipe", "pipe", "pipe"],
+        shell: false,
+        detached: false
+      });
+    } catch (error) {
+      throw classifySpawnError(error);
+    }
+    if (options.onSpawn) {
+      try {
+        options.onSpawn(child);
+      } catch {
+      }
+    }
+    let timeoutTimer = null;
+    let killTimer = null;
+    let killed = false;
+    let settled = false;
+    const triggerKill = () => {
+      if (killed || child.exitCode !== null) return;
+      killed = true;
+      child.kill("SIGTERM");
+      killTimer = setTimeout(() => {
+        if (child.exitCode === null) {
+          child.kill("SIGKILL");
+        }
+      }, DEFAULT_KILL_GRACE_MS);
+    };
+    const onAbort = () => {
+      triggerKill();
+    };
+    options.signal?.addEventListener("abort", onAbort);
+    if (options.signal?.aborted) {
+      triggerKill();
+    }
+    let stdout = "";
+    let stderr = "";
+    if (captureMode === "buffer") {
+      child.stdout?.setEncoding("utf8");
+      child.stderr?.setEncoding("utf8");
+      child.stdout?.on("data", (chunk) => {
+        stdout += chunk;
+      });
+      child.stderr?.on("data", (chunk) => {
+        stderr += chunk;
+      });
+      if (options.stdin !== void 0) {
+        child.stdin?.end(options.stdin);
+      } else {
+        child.stdin?.end();
+      }
+    }
+    if (options.timeout_ms !== void 0) {
+      timeoutTimer = setTimeout(triggerKill, options.timeout_ms);
+    }
+    const cleanup = () => {
+      if (timeoutTimer !== null) clearTimeout(timeoutTimer);
+      if (killTimer !== null) clearTimeout(killTimer);
+      options.signal?.removeEventListener("abort", onAbort);
+    };
+    return new Promise((resolve2, reject) => {
+      child.once("error", (error) => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        reject(classifySpawnError(error));
+      });
+      child.once("close", (code, signal) => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        const ended_at = /* @__PURE__ */ new Date();
+        resolve2({
+          command: snapshotCommand,
+          args: snapshotArgs,
+          cwd: snapshotCwd,
+          exit_code: code,
+          signal,
+          stdout,
+          stderr,
+          started_at: started_at.toISOString(),
+          ended_at: ended_at.toISOString(),
+          duration_ms: ended_at.getTime() - started_at.getTime(),
+          pid: child.pid ?? null
+        });
+      });
+    });
+  }
+};
+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/git/snapshot.ts
+import { simpleGit } from "simple-git";
+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 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 });
+    }
+    if (error instanceof Error && error.message === "Not a git repository") {
+      throw error;
+    }
+    throw new Error("Not a git repository", { cause: error });
+  }
+}
+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;
+  }
+}
+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 });
+  }
+  if (!inside) {
+    throw new Error("Not a git repository");
+  }
+  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 });
+  }
+  if (head.length === 0) {
+    throw new Error("No commits in repository");
+  }
+  let branch;
+  try {
+    const raw = (await git.raw(["branch", "--show-current"])).trimEnd();
+    branch = raw.length > 0 ? raw : "HEAD";
+  } catch (error) {
+    throw new Error("Failed to read git state", { cause: error });
+  }
+  let dirty;
+  const staged = [];
+  const unstaged = [];
+  const untracked = [];
+  try {
+    const status = await git.status();
+    dirty = !status.isClean();
+    for (const f of status.files) {
+      if (f.index === "?" && f.working_dir === "?") {
+        untracked.push(f.path);
+        continue;
+      }
+      if (f.index !== " " && f.index !== "?") staged.push(f.path);
+      if (f.working_dir !== " " && f.working_dir !== "?") unstaged.push(f.path);
+    }
+  } catch (error) {
+    throw new Error("Failed to read git state", { cause: error });
+  }
+  let ahead;
+  let behind;
+  if (branch !== "HEAD") {
+    try {
+      const upstream = `${branch}@{upstream}`;
+      const counts = (await git.raw(["rev-list", "--left-right", "--count", `${upstream}...HEAD`])).trim();
+      const [behindStr, aheadStr] = counts.split(/\s+/);
+      const parsedBehind = Number.parseInt(behindStr ?? "", 10);
+      const parsedAhead = Number.parseInt(aheadStr ?? "", 10);
+      if (Number.isFinite(parsedBehind) && parsedBehind >= 0) behind = parsedBehind;
+      if (Number.isFinite(parsedAhead) && parsedAhead >= 0) ahead = parsedAhead;
+    } catch {
+    }
+  }
+  const snapshot = {
+    head,
+    branch,
+    dirty,
+    staged,
+    unstaged,
+    untracked,
+    ...ahead !== void 0 ? { ahead } : {},
+    ...behind !== void 0 ? { behind } : {}
+  };
+  return snapshot;
+}
+
+// src/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 });
+    }
+    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 });
+  }
+  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/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 };
+  }
+  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 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;
+}
+
+// src/index.ts
+var BASOU_CORE_VERSION = "0.1.0";
+export {
+  ApprovalIdSchema,
+  ApprovalSchema,
+  ApprovalStatusSchema,
+  BASOU_CORE_VERSION,
+  ChildProcessRunner,
+  DecisionIdSchema,
+  EventIdSchema,
+  EventSchema,
+  EventSourceSchema,
+  FailedToFinalizeError,
+  GENERATED_END,
+  GENERATED_START,
+  ID_PREFIXES,
+  IsoTimestampSchema,
+  ManifestSchema,
+  RiskLevelSchema,
+  STUCK_THRESHOLD_MS,
+  SchemaVersionSchema,
+  SessionIdSchema,
+  SessionImportPayloadSchema,
+  SessionInnerImportSchema,
+  SessionSchema,
+  SessionSourceKindSchema,
+  SessionStatusSchema,
+  StatusSchema,
+  TaskIdSchema,
+  TaskSchema,
+  TaskStatusSchema,
+  TaskWriteAfterEventError,
+  WorkspaceIdSchema,
+  acquireLock,
+  appendBasouGitignore,
+  appendEvent,
+  appendEventToExistingSession,
+  archiveTask,
+  assertBasouRootSafe,
+  basouPaths,
+  buildStatusSnapshot,
+  classifySuspect,
+  claudeCodeAdapterMetadata,
+  createAdHocSessionWithEvent,
+  createManifest,
+  createTaskWithEvent,
+  deleteTask,
+  editTask,
+  ensureBasouDirectory,
+  enumerateApprovals,
+  enumerateArchivedTaskIds,
+  enumerateSessionDirs,
+  enumerateTaskIds,
+  findErrorCode,
+  getDiff,
+  getSnapshot,
+  importSessionFromJson,
+  isLazyExpired,
+  isValidPrefixedId,
+  linkYamlFile,
+  loadApproval,
+  loadSessionEntries,
+  loadTaskEntries,
+  overwriteYamlFile,
+  parseDuration,
+  parseMarkers,
+  prefixedUlid,
+  readAllEvents,
+  readManifest,
+  readMarkdownFile,
+  readSessionYaml,
+  readStatus,
+  readTaskFile,
+  readTaskFileWithArchiveFallback,
+  readYamlFile,
+  reconcileAllTasks,
+  reconcileTask,
+  refreshTaskLinkedSessions,
+  renderDecisions,
+  renderHandoff,
+  renderWithMarkers,
+  replayEvents,
+  resolveClaudeCodeCommand,
+  resolveRepositoryRoot,
+  resolveSessionId,
+  resolveTaskId,
+  sanitizePath,
+  sanitizeRelatedFiles,
+  sanitizeWorkingDirectory,
+  summarizeAdapterOutput,
+  tryRemoteUrl,
+  ulid,
+  updateTaskStatusWithEvent,
+  writeEventsBulk,
+  writeManifest,
+  writeMarkdownFile,
+  writeStatus,
+  writeTaskFile,
+  writeYamlFile
+};
+//# sourceMappingURL=index.js.map