@goah/cli 0.13.0 → 0.13.2

package/dist/chunk-YH6YJ2IB.js

@@ -0,0 +1,1773 @@
+import { createRequire as __goahCreateRequire } from "node:module";
+const require = __goahCreateRequire(import.meta.url);
+import {
+  controlStream,
+  goalStream,
+  wakeStream,
+  workRecordStream
+} from "./chunk-KAO7WIXG.js";
+import {
+  assertGoalSnapshot,
+  assertGoalTransition,
+  assertHandoff,
+  goalAutomaticTarget,
+  goalRoute,
+  normalizeAssistantText
+} from "./chunk-TJON22J4.js";
+
+// node_modules/goah-ledger-sqlite/dist/index.js
+import { DatabaseSync } from "node:sqlite";
+import { isDeepStrictEqual } from "node:util";
+var SQLITE_SCHEMA_VERSION = 27;
+var createThreads = `CREATE TABLE IF NOT EXISTS threads (
+  id TEXT PRIMARY KEY,
+  agent TEXT NOT NULL,
+  role TEXT NOT NULL CHECK(role IN ('ceo','child','verifier','audit')),
+  parent_thread_id TEXT REFERENCES threads(id),
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  UNIQUE(agent),
+  CHECK((agent='ceo' AND role='ceo') OR (agent<>'ceo' AND role<>'ceo'))
+) STRICT;`;
+var createTurns = `CREATE TABLE IF NOT EXISTS turns (
+  id TEXT PRIMARY KEY,
+  thread_id TEXT NOT NULL REFERENCES threads(id) ON DELETE CASCADE,
+  trigger_kind TEXT NOT NULL CHECK(trigger_kind IN ('user_message','wake')),
+  goal_id TEXT REFERENCES goals(id),
+  goal_revision INTEGER CHECK(goal_revision IS NULL OR goal_revision >= 0),
+  status TEXT NOT NULL CHECK(status IN ('in_progress','completed','failed','interrupted')),
+  attempt INTEGER NOT NULL CHECK(attempt > 0),
+  error TEXT CHECK(error IS NULL OR json_valid(error)),
+  started_at TEXT NOT NULL,
+  ended_at TEXT,
+  lease_until TEXT,
+  lease_token TEXT,
+  runner_pid INTEGER CHECK(runner_pid IS NULL OR runner_pid > 0),
+  runner_profile_id TEXT,
+  CHECK((goal_id IS NULL) = (goal_revision IS NULL)),
+  CHECK((status='in_progress' AND ended_at IS NULL AND lease_until IS NOT NULL AND lease_token IS NOT NULL) OR (status<>'in_progress' AND ended_at IS NOT NULL AND lease_until IS NULL AND lease_token IS NULL))
+) STRICT;`;
+var createTurnItems = `CREATE TABLE IF NOT EXISTS turn_items (
+  id TEXT PRIMARY KEY,
+  turn_id TEXT NOT NULL REFERENCES turns(id) ON DELETE CASCADE,
+  ordinal INTEGER NOT NULL CHECK(ordinal > 0),
+  type TEXT NOT NULL CHECK(type IN ('user_message','assistant_message','reasoning','tool_call','tool_result','plan','handoff')),
+  status TEXT NOT NULL CHECK(status IN ('in_progress','completed','failed')),
+  data TEXT NOT NULL CHECK(json_valid(data)),
+  created_at TEXT NOT NULL,
+  completed_at TEXT,
+  UNIQUE(turn_id, ordinal),
+  CHECK((status='in_progress' AND completed_at IS NULL) OR (status<>'in_progress' AND completed_at IS NOT NULL))
+) STRICT;`;
+var createGoals = `CREATE TABLE IF NOT EXISTS goals (
+  id TEXT PRIMARY KEY,
+  parent_id TEXT REFERENCES goals(id),
+  objective TEXT NOT NULL,
+  observation_method TEXT CHECK(observation_method IS NULL OR length(trim(observation_method)) > 0),
+  verification_method TEXT CHECK(verification_method IS NULL OR length(trim(verification_method)) > 0),
+  owner TEXT NOT NULL,
+  phase TEXT NOT NULL CHECK(phase IN ('active','paused','blocked','complete')),
+  revision INTEGER NOT NULL CHECK(revision >= 0)
+) STRICT;`;
+var createWorkRecords = `CREATE TABLE IF NOT EXISTS work_records (
+  goal_id TEXT PRIMARY KEY REFERENCES goals(id),
+  record_revision INTEGER NOT NULL CHECK(record_revision >= 0),
+  goal_revision INTEGER NOT NULL CHECK(goal_revision >= 0),
+  content TEXT NOT NULL CHECK(length(trim(content)) > 0),
+  updated_by TEXT NOT NULL,
+  updated_in_turn TEXT NOT NULL,
+  source_wake_id TEXT,
+  updated_at TEXT NOT NULL,
+  reason TEXT NOT NULL CHECK(length(trim(reason)) > 0),
+  evidence TEXT NOT NULL CHECK(json_valid(evidence)),
+  last_event_seq INTEGER NOT NULL REFERENCES events(seq)
+) STRICT;`;
+var createWakes = `CREATE TABLE IF NOT EXISTS wakes (
+  id TEXT PRIMARY KEY,
+  target_kind TEXT NOT NULL CHECK(target_kind IN ('goal','specialist')),
+  agent TEXT NOT NULL,
+  specialist_role TEXT CHECK(specialist_role IS NULL OR specialist_role IN ('verifier','audit')),
+  trigger_ref TEXT NOT NULL,
+  status TEXT NOT NULL CHECK(status IN ('queued','claimed','consumed','cancelled')),
+  attempt INTEGER NOT NULL CHECK(attempt >= 0),
+  enqueued_seq INTEGER NOT NULL CHECK(enqueued_seq > 0),
+  claimed_at TEXT,
+  consumed_at TEXT,
+  turn_id TEXT REFERENCES turns(id),
+  goal_id TEXT REFERENCES goals(id),
+  UNIQUE(agent, trigger_ref),
+  UNIQUE(turn_id),
+  CHECK((status='claimed' AND claimed_at IS NOT NULL) OR status<>'claimed'),
+  CHECK((status='consumed' AND consumed_at IS NOT NULL AND turn_id IS NOT NULL) OR status<>'consumed'),
+  CHECK((target_kind='goal' AND goal_id IS NOT NULL AND specialist_role IS NULL) OR (target_kind='specialist' AND goal_id IS NULL AND specialist_role IS NOT NULL))
+) STRICT;`;
+var createWakeTriggers = `CREATE TABLE IF NOT EXISTS wake_triggers (
+  wake_id TEXT NOT NULL REFERENCES wakes(id) ON DELETE CASCADE,
+  agent TEXT NOT NULL,
+  trigger_ref TEXT NOT NULL,
+  source TEXT NOT NULL CHECK(source IN ('goal','system')),
+  status TEXT NOT NULL CHECK(status IN ('pending','resolved')),
+  added_at TEXT NOT NULL,
+  resolved_at TEXT,
+  PRIMARY KEY(wake_id,trigger_ref),
+  UNIQUE(agent,trigger_ref),
+  CHECK((status='pending' AND resolved_at IS NULL) OR (status='resolved' AND resolved_at IS NOT NULL))
+) STRICT;`;
+var indexesAndTriggers = `
+CREATE UNIQUE INDEX IF NOT EXISTS turns_one_active_thread ON turns(thread_id) WHERE status='in_progress';
+CREATE INDEX IF NOT EXISTS turns_thread_started ON turns(thread_id,started_at,id);
+CREATE INDEX IF NOT EXISTS turn_items_turn_ordinal ON turn_items(turn_id,ordinal);
+CREATE UNIQUE INDEX IF NOT EXISTS wakes_one_claimed_agent ON wakes(agent) WHERE status='claimed';
+CREATE INDEX IF NOT EXISTS wakes_queue_order ON wakes(status, enqueued_seq);
+CREATE INDEX IF NOT EXISTS wake_triggers_pending ON wake_triggers(wake_id,status);
+CREATE INDEX IF NOT EXISTS schedule_due ON schedule(status,next_wake_at);
+CREATE INDEX IF NOT EXISTS events_actor_type_seq ON events(actor, type, seq DESC);
+CREATE INDEX IF NOT EXISTS events_stream_seq ON events(stream_id, stream_seq);
+CREATE VIRTUAL TABLE IF NOT EXISTS events_fts USING fts5(actor, type, data, content='events', content_rowid='seq');
+
+CREATE TRIGGER IF NOT EXISTS events_no_update BEFORE UPDATE ON events
+BEGIN SELECT RAISE(ABORT, 'events are append-only'); END;
+CREATE TRIGGER IF NOT EXISTS events_no_delete BEFORE DELETE ON events
+BEGIN SELECT RAISE(ABORT, 'events are append-only'); END;
+CREATE TRIGGER IF NOT EXISTS events_fts_insert AFTER INSERT ON events
+BEGIN INSERT INTO events_fts(rowid,actor,type,data) VALUES (new.seq,new.actor,new.type,new.data); END;
+
+CREATE TRIGGER IF NOT EXISTS wakes_valid_transition BEFORE UPDATE OF status ON wakes
+WHEN OLD.status <> NEW.status AND NOT (
+  (OLD.status = 'queued' AND NEW.status IN ('claimed','cancelled')) OR
+  (OLD.status = 'claimed' AND NEW.status IN ('queued','consumed','cancelled'))
+)
+BEGIN SELECT RAISE(ABORT, 'invalid wake transition'); END;
+
+CREATE TRIGGER IF NOT EXISTS schedule_valid_transition BEFORE UPDATE OF status ON schedule
+WHEN OLD.status <> NEW.status AND NOT (
+  OLD.status = 'pending' AND NEW.status IN ('consumed','cancelled','superseded')
+)
+BEGIN SELECT RAISE(ABORT, 'invalid schedule transition'); END;
+
+CREATE TRIGGER IF NOT EXISTS wake_triggers_valid_transition BEFORE UPDATE OF status ON wake_triggers
+WHEN OLD.status <> NEW.status AND NOT (OLD.status='pending' AND NEW.status='resolved')
+BEGIN SELECT RAISE(ABORT, 'invalid Wake trigger transition'); END;
+
+CREATE TRIGGER IF NOT EXISTS goals_valid_transition BEFORE UPDATE OF phase ON goals
+WHEN OLD.phase <> NEW.phase AND NOT (
+  (OLD.phase = 'active' AND NEW.phase IN ('paused','blocked','complete')) OR
+  (OLD.phase = 'paused' AND NEW.phase IN ('active','complete')) OR
+  (OLD.phase = 'blocked' AND NEW.phase IN ('active','complete'))
+)
+BEGIN SELECT RAISE(ABORT, 'invalid goal transition'); END;
+`;
+var schema = `
+CREATE TABLE IF NOT EXISTS events (
+  seq INTEGER PRIMARY KEY AUTOINCREMENT,
+  stream_id TEXT NOT NULL,
+  stream_seq INTEGER NOT NULL CHECK(stream_seq > 0),
+  ts TEXT NOT NULL,
+  actor TEXT NOT NULL,
+  type TEXT NOT NULL,
+  data TEXT NOT NULL CHECK(json_valid(data)),
+  projection_name TEXT,
+  ignorable INTEGER CHECK(ignorable IS NULL OR ignorable = 1),
+  UNIQUE(stream_id, stream_seq)
+) STRICT;
+${createGoals}
+${createWorkRecords}
+${createThreads}
+${createTurns}
+${createTurnItems}
+CREATE TABLE IF NOT EXISTS schedule (
+  id TEXT PRIMARY KEY,
+  target_kind TEXT NOT NULL CHECK(target_kind IN ('goal','specialist')),
+  agent TEXT NOT NULL,
+  specialist_role TEXT CHECK(specialist_role IS NULL OR specialist_role IN ('verifier','audit')),
+  next_wake_at TEXT NOT NULL,
+  reason TEXT NOT NULL,
+  set_by TEXT NOT NULL,
+  status TEXT NOT NULL CHECK(status IN ('pending','consumed','cancelled','superseded')),
+  resolved_at TEXT,
+  goal_id TEXT REFERENCES goals(id),
+  CHECK((status='pending' AND resolved_at IS NULL) OR (status<>'pending' AND resolved_at IS NOT NULL)),
+  CHECK((target_kind='goal' AND goal_id IS NOT NULL AND specialist_role IS NULL) OR (target_kind='specialist' AND goal_id IS NULL AND specialist_role IS NOT NULL))
+) STRICT;
+${createWakes}
+${createWakeTriggers}
+CREATE TABLE IF NOT EXISTS mailbox (
+  id TEXT PRIMARY KEY,
+  route_kind TEXT NOT NULL CHECK(route_kind IN ('goal','human_inbox','human_request','specialist_inbox')),
+  to_agent TEXT NOT NULL,
+  from_agent TEXT NOT NULL,
+  specialist_role TEXT CHECK(specialist_role IS NULL OR specialist_role IN ('verifier','audit')),
+  level TEXT NOT NULL CHECK(level IN ('fyi','decision','emergency')),
+  goal_id TEXT REFERENCES goals(id),
+  body TEXT NOT NULL CHECK(json_valid(body)),
+  read_at TEXT,
+  CHECK((route_kind='goal' AND goal_id IS NOT NULL AND specialist_role IS NULL) OR (route_kind='human_inbox' AND to_agent='ceo' AND from_agent IN ('human','verifier','audit','supervisor') AND goal_id IS NULL AND specialist_role IS NULL) OR (route_kind='human_request' AND to_agent='human' AND from_agent='ceo' AND goal_id IS NULL AND specialist_role IS NULL) OR (route_kind='specialist_inbox' AND goal_id IS NULL AND specialist_role IS NOT NULL))
+) STRICT;
+${indexesAndTriggers}`;
+var SystemClock = class {
+  now() {
+    return /* @__PURE__ */ new Date();
+  }
+};
+var SqliteLedger = class {
+  db;
+  #faultInjector;
+  #clock;
+  constructor(path = ":memory:", options = {}) {
+    this.db = new DatabaseSync(path);
+    this.db.exec(`PRAGMA journal_mode = WAL; PRAGMA foreign_keys = ON; PRAGMA busy_timeout = ${options.busyTimeoutMs ?? 5e3};`);
+    this.#faultInjector = options.faultInjector;
+    this.#clock = options.clock ?? new SystemClock();
+    const version = Number(this.db.prepare("PRAGMA user_version").get().user_version);
+    if (version > SQLITE_SCHEMA_VERSION) {
+      this.db.close();
+      throw new Error(`ledger schema ${version} is newer than supported schema ${SQLITE_SCHEMA_VERSION}`);
+    }
+    if (version > 0 && version < SQLITE_SCHEMA_VERSION) {
+      this.db.close();
+      throw new Error(`ledger schema ${version} predates runtime schema ${SQLITE_SCHEMA_VERSION}; recreate this development workspace`);
+    }
+    if (version === 0) {
+      this.db.exec(schema);
+      this.db.exec(`PRAGMA user_version = ${SQLITE_SCHEMA_VERSION}`);
+    } else {
+      this.db.exec(schema);
+    }
+  }
+  close() {
+    this.db.close();
+  }
+  appendEvent(input) {
+    this.#assertRawEvent(input);
+    return this.#transaction(() => this.#insertEvent(input));
+  }
+  appendEvents(inputs) {
+    for (const input of inputs)
+      this.#assertRawEvent(input);
+    return this.#transaction(() => inputs.map((input) => this.#insertEvent(input)));
+  }
+  readStream(streamId, fromStreamSeq = 1) {
+    return this.db.prepare("SELECT * FROM events WHERE stream_id=? AND stream_seq>=? ORDER BY stream_seq").all(streamId, fromStreamSeq).map(mapEvent);
+  }
+  putThread(thread, actor) {
+    return this.#transaction(() => this.#admitThread(thread, actor));
+  }
+  putTurn(turn, actor) {
+    if (!turn.id.trim() || !turn.threadId.trim())
+      throw new Error("turn id and thread are required");
+    this.#assertTurnShape(turn);
+    if (turn.status === "in_progress" && (!turn.leaseUntil || !turn.leaseToken) || turn.status !== "in_progress" && (turn.leaseUntil !== null || turn.leaseToken !== null))
+      throw new Error("Turn execution ownership does not match status");
+    const thread = this.thread(turn.threadId);
+    if (!thread)
+      throw new Error("Turn Thread does not exist");
+    const current = this.turn(turn.id);
+    if (current) {
+      if (turn.status !== "in_progress")
+        throw new Error("terminal Turn state must be committed through finishTurn or commitHandoff");
+      if (current.threadId !== turn.threadId || current.triggerKind !== turn.triggerKind)
+        throw new Error("turn identity cannot change");
+      if (current.runnerProfileId !== turn.runnerProfileId)
+        throw new Error("turn Runner Profile cannot change");
+      if (current.runnerPid !== turn.runnerPid)
+        throw new Error("Turn Runner process may change only through attach/release APIs");
+      if (current.status !== "in_progress")
+        throw new Error("terminal turn cannot change");
+      if (current.goalId !== turn.goalId || current.goalRevision !== turn.goalRevision)
+        throw new Error("Turn Goal commitment cannot change through putTurn");
+      if (turn.attempt !== current.attempt && turn.attempt !== current.attempt + 1)
+        throw new Error("turn attempt must stay current or increment by one");
+      if (turn.status === "in_progress" && turn.endedAt !== null || turn.status !== "in_progress" && turn.endedAt === null)
+        throw new Error("turn terminal time does not match status");
+    } else
+      throw new Error("new Human Turns require atomic admitHumanTurn; automatic Turns require a claimed Wake");
+    return this.#project("turns", turn, actor, current ? `turn.${turn.status}` : "turn.started", void 0, void 0, `turn:${turn.id}`);
+  }
+  admitHumanTurn(request) {
+    return this.#transaction(() => {
+      const { thread, turn, messageItem } = request;
+      this.#admitThread(thread, "supervisor");
+      if (thread.agent !== "ceo" || thread.role !== "ceo" || thread.parentThreadId !== null)
+        throw new Error("Human Turn requires the canonical CEO Thread");
+      const messageData = messageItem.data && typeof messageItem.data === "object" && !Array.isArray(messageItem.data) ? messageItem.data : null;
+      if (!messageData || typeof messageData.text !== "string" || !messageData.text.trim())
+        throw new Error("Human Turn admission requires a readable user message");
+      const active = this.activeTurn(thread.id);
+      if (request.replaceTurnId === null && active)
+        throw new Error("Human Turn admission requires the active Turn to be replaced");
+      if (request.replaceTurnId !== null && active?.id !== request.replaceTurnId)
+        throw new Error("Human Turn replacement lost its active Turn race");
+      let goal = null;
+      if (request.rootGoal) {
+        goal = normalizeGoal(request.rootGoal);
+        assertGoalSnapshot(goal);
+        if (goal.parentId !== null || goal.owner !== "ceo" || goal.phase !== "active" || goal.revision !== 0)
+          throw new Error("Human Goal admission requires a new active CEO Root Goal");
+        if (this.#getGoal(goal.id))
+          throw new Error("Goal id is already in use");
+        if (this.goals().some((candidate) => candidate.parentId === null && candidate.phase !== "complete"))
+          throw new Error("CEO already has an unfinished Root Goal");
+        this.#assertOwnerSeparation(goal.id, null, goal.owner);
+        this.#recordGoalChange(goal, null, "human", void 0, { operation: "create", reason: "Human established a durable Root Goal", evidence: [], authority: { kind: "human" } });
+        this.#createWorkRecord(goal, "human", `goal:create:${goal.id}`);
+        this.#faultInjector?.("after_human_goal_before_turn");
+      }
+      this.#assertTurnShape(turn);
+      if (turn.threadId !== thread.id || turn.triggerKind !== "user_message" || turn.status !== "in_progress" || turn.attempt !== 1 || turn.endedAt !== null || !turn.leaseUntil || !turn.leaseToken || turn.runnerPid !== null)
+        throw new Error("invalid Human Turn admission");
+      if (goal) {
+        if (turn.goalId !== goal.id || turn.goalRevision !== goal.revision)
+          throw new Error("Human Goal Turn does not commit to its admitted Root Goal");
+      } else if (turn.goalId !== null) {
+        const existing = this.#getGoal(turn.goalId);
+        if (!existing || existing.parentId !== null || existing.owner !== "ceo" || existing.phase !== "active" || existing.revision !== turn.goalRevision)
+          throw new Error("Human Turn commitment is not the current active Root Goal");
+      }
+      let replaced = null;
+      if (active) {
+        replaced = this.#finishTurn(active, "interrupted", { message: "interrupted by Human" }, turn.startedAt, "human", []);
+        this.#faultInjector?.("after_human_replacement_before_turn");
+      }
+      this.#recordProjection("turns", turn, "human", "turn.started", void 0, turn.startedAt, void 0, `turn:${turn.id}`);
+      if (messageItem.turnId !== turn.id || messageItem.ordinal !== 1 || messageItem.type !== "user_message" || messageItem.status !== "completed" || messageItem.createdAt !== turn.startedAt || messageItem.completedAt !== turn.startedAt)
+        throw new Error("Human Turn admission requires one completed initial user message");
+      this.#admitTurnItem(messageItem, "human");
+      return { turn, replacedTurn: replaced, goal };
+    });
+  }
+  commitTurnToGoal(turnId, binding, actor) {
+    if (actor !== "supervisor")
+      throw new Error("only supervisor may commit a Turn to a Goal");
+    return this.#transaction(() => {
+      const current = this.#requiredTurn(turnId);
+      if (current.status !== "in_progress")
+        throw new Error("only an active Turn may commit to a Goal");
+      if (current.goalId !== null) {
+        if (current.goalId === binding.goalId && current.goalRevision === binding.goalRevision)
+          return current;
+        throw new Error("Turn Goal commitment is immutable");
+      }
+      const thread = this.thread(current.threadId);
+      const goal = this.#getGoal(binding.goalId);
+      if (!thread || !goal || goal.phase !== "active" || goal.owner !== thread.agent || goal.revision !== binding.goalRevision)
+        throw new Error("Turn commitment must target the current active Goal owned by its Agent");
+      if (thread.role === "ceo" && goal.parentId !== null || thread.role === "child" && goal.parentId === null || thread.role === "verifier" || thread.role === "audit")
+        throw new Error("Thread role cannot commit to this Goal");
+      const next = { ...current, goalId: goal.id, goalRevision: goal.revision };
+      this.#recordProjection("turns", next, "supervisor", "turn.goal_committed", void 0, this.#now(), void 0, `turn:${turnId}`);
+      return next;
+    });
+  }
+  putTurnItem(item, actor) {
+    return this.#transaction(() => this.#admitTurnItem(item, actor));
+  }
+  thread(id) {
+    const row = this.db.prepare("SELECT * FROM threads WHERE id=?").get(id);
+    return row ? mapThread(row) : null;
+  }
+  threads() {
+    return this.db.prepare("SELECT * FROM threads ORDER BY created_at,id").all().map(mapThread);
+  }
+  turn(id) {
+    const row = this.db.prepare("SELECT * FROM turns WHERE id=?").get(id);
+    return row ? mapTurn(row) : null;
+  }
+  turns(threadId) {
+    return (threadId ? this.db.prepare("SELECT * FROM turns WHERE thread_id=? ORDER BY rowid").all(threadId) : this.db.prepare("SELECT * FROM turns ORDER BY rowid").all()).map(mapTurn);
+  }
+  turnItems(turnId) {
+    return this.db.prepare("SELECT * FROM turn_items WHERE turn_id=? ORDER BY ordinal").all(turnId).map(mapTurnItem);
+  }
+  activeTurn(threadId) {
+    const row = this.db.prepare("SELECT * FROM turns WHERE thread_id=? AND status='in_progress'").get(threadId);
+    return row ? mapTurn(row) : null;
+  }
+  putGoal(goal, actor, wakeId, change) {
+    const normalized = normalizeGoal(goal);
+    assertGoalSnapshot(normalized);
+    if (change?.idempotencyKey) {
+      const row = this.db.prepare("SELECT * FROM events WHERE type='goal.changed' AND actor=? AND json_extract(data,'$.idempotencyKey')=? ORDER BY seq LIMIT 1").get(actor, change.idempotencyKey);
+      if (row) {
+        const event = mapEvent(row);
+        const data = event.data;
+        const same = isDeepStrictEqual(data.snapshot, normalized) && data.operation === change.operation && data.reason === change.reason.trim() && isDeepStrictEqual(data.evidence, change.evidence) && (!change.authority || isDeepStrictEqual(data.authority, change.authority));
+        if (!same)
+          throw new Error("Goal idempotency key was reused with a different mutation");
+        return event;
+      }
+    }
+    const current = this.#getGoal(normalized.id);
+    if (current) {
+      if (normalized.revision !== current.revision + 1)
+        throw new Error("goal revision CAS failed");
+      if (current.phase === "complete")
+        throw new Error("completed goal cannot be modified");
+      if (normalized.parentId !== current.parentId)
+        throw new Error("goal reparenting is not supported");
+      if (normalized.phase === "complete")
+        throw new Error("goal completion requires reason and evidence");
+      const definitionChanged = normalized.objective !== current.objective || normalized.observationMethod !== current.observationMethod || normalized.verificationMethod !== current.verificationMethod;
+      if (current.phase !== normalized.phase && (current.owner !== normalized.owner || definitionChanged) || current.owner !== normalized.owner && definitionChanged)
+        throw new Error("Goal mutation must express exactly one lifecycle operation");
+      if (normalized.objective !== current.objective && (current.observationMethod !== null && normalized.observationMethod === current.observationMethod || current.verificationMethod !== null && normalized.verificationMethod === current.verificationMethod))
+        throw new Error("objective revision must replace or invalidate observation and verification methods");
+      assertGoalTransition(current.phase, normalized.phase);
+      this.#assertGoalAuthority(current.parentId, actor);
+    } else {
+      if (normalized.revision !== 0)
+        throw new Error("new goal revision must be 0");
+      this.#assertGoalAuthority(normalized.parentId, actor);
+    }
+    this.#assertOwnerSeparation(normalized.id, normalized.parentId, normalized.owner);
+    return this.#transaction(() => {
+      const event = this.#recordGoalChange(normalized, current, actor, wakeId, change);
+      if (!current)
+        this.#createWorkRecord(normalized, actor, wakeId ?? `goal:create:${normalized.id}`, wakeId);
+      return event;
+    });
+  }
+  updateWorkRecord(request, actor) {
+    if (!request.turnId.trim() || !request.reason.trim() || !request.content.trim())
+      throw new Error("work record turn, reason and content are required");
+    this.#assertEvidenceExists(request.evidence);
+    const goal = this.#getGoal(request.goalId);
+    if (!goal)
+      throw new Error("work record goal does not exist");
+    if (goal.revision !== request.goalRevision)
+      throw new Error("work record goal revision is stale");
+    this.#assertWorkRecordAuthority(goal, actor);
+    const turn = this.turn(request.turnId);
+    if (!turn || turn.status !== "in_progress" || turn.goalId !== goal.id || turn.goalRevision !== request.goalRevision)
+      throw new Error("work record update does not match an active committed Turn");
+    const current = this.workRecord(goal.id);
+    if (!current)
+      throw new Error("work record does not exist");
+    if (current.recordRevision !== request.expectedRevision)
+      throw new Error("work record revision CAS failed");
+    if (current.content === request.content)
+      throw new Error("work record content is unchanged");
+    return this.#transaction(() => this.#recordWorkRecord({
+      ...current,
+      recordRevision: current.recordRevision + 1,
+      goalRevision: goal.revision,
+      content: request.content,
+      updatedBy: actor,
+      updatedInTurn: request.turnId,
+      sourceWakeId: request.sourceWakeId ?? null,
+      updatedAt: this.#now(),
+      reason: request.reason,
+      evidence: request.evidence
+    }, "work_record.updated"));
+  }
+  commitDelegation(request, actor, wakeId) {
+    const existing = this.#delegationResult(request.id);
+    if (existing) {
+      const event = this.events().find((candidate) => candidate.type === "delegation.created" && candidate.data.delegationId === request.id);
+      const prior = event?.data?.request;
+      if (event?.actor !== actor || !isDeepStrictEqual(prior, withoutSourceTurn(request)))
+        throw new Error("delegation id was reused with a different request");
+      return existing;
+    }
+    if (!request.id.trim() || !request.reason.trim())
+      throw new Error("delegation id and reason are required");
+    if (request.childGoal.owner === actor)
+      throw new Error("delegate to a distinct worker agent; use goal.put for self-owned subgoals");
+    if (!request.childGoal.id.trim() || !request.childGoal.objective.trim() || !request.childGoal.observationMethod.trim() || !request.childGoal.verificationMethod.trim() || !request.childGoal.owner.trim())
+      throw new Error("delegation child goal is incomplete");
+    this.#assertEvidenceExists(request.evidence);
+    const parent = this.#getGoal(request.parentGoalId);
+    if (!parent)
+      throw new Error("delegation parent goal does not exist");
+    if (parent.revision !== request.expectedParentRevision)
+      throw new Error("delegation parent Goal revision is stale");
+    if (parent.owner !== actor)
+      throw new Error("only the parent goal owner may delegate");
+    if (parent.phase !== "active")
+      throw new Error("delegation parent goal must be active");
+    if (this.#getGoal(request.childGoal.id))
+      throw new Error("delegation child goal already exists");
+    return this.#transaction(() => {
+      const goal = normalizeGoal({ ...request.childGoal, parentId: request.parentGoalId, phase: "active", revision: 0 });
+      const mail = {
+        id: `delegation-mail:${request.id}`,
+        to: goal.owner,
+        from: actor,
+        level: "decision",
+        ...goalRoute(goal.id),
+        body: { type: "delegation", delegationId: request.id, goalId: goal.id, parentGoalId: request.parentGoalId, objective: goal.objective, observationMethod: goal.observationMethod, verificationMethod: goal.verificationMethod ?? null, brief: request.brief, reason: request.reason, evidence: request.evidence },
+        readAt: null
+      };
+      const wakeBase = {
+        id: `delegation-wake:${request.id}`,
+        ...goalAutomaticTarget(goal.owner, goal.id),
+        triggerRef: `delegation:${request.id}`,
+        status: "queued",
+        attempt: 0,
+        enqueuedSeq: 0,
+        claimedAt: null,
+        consumedAt: null,
+        turnId: null
+      };
+      this.#insertEvent({
+        streamId: wakeId ? wakeStream(wakeId) : controlStream("delegations"),
+        ts: this.#now(),
+        actor,
+        type: "delegation.created",
+        data: { delegationId: request.id, parentGoalId: request.parentGoalId, goalId: goal.id, mailId: mail.id, wakeId: wakeBase.id, reason: request.reason, evidence: request.evidence, request: withoutSourceTurn(request) }
+      });
+      this.#faultInjector?.("after_delegation_event");
+      this.#recordGoalChange(goal, null, actor, wakeId, { operation: "create", reason: request.reason, evidence: request.evidence, authority: { kind: "parent_goal", goalId: parent.id, goalRevision: parent.revision }, ...request.sourceTurnId ? { sourceTurnId: request.sourceTurnId } : {}, ...wakeId ? { sourceWakeId: wakeId } : {}, idempotencyKey: request.id });
+      this.#createWorkRecord(goal, actor, wakeId ?? `delegation:${request.id}`, wakeId);
+      this.#assertNewMail(mail, actor);
+      this.#recordProjection("mailbox", mail, actor, "mail.put", wakeId);
+      const wake = this.#admitWake(wakeBase, "supervisor", false).wake;
+      return { delegationId: request.id, goal, mail, wake };
+    });
+  }
+  commitReassignment(request, actor, wakeId) {
+    const existing = this.#reassignmentResult(request.id);
+    if (existing) {
+      const event = this.events().find((candidate) => candidate.type === "goal.reassigned" && candidate.data.reassignmentId === request.id);
+      const prior = event?.data?.request;
+      if (event?.actor !== actor || !isDeepStrictEqual(prior, withoutSourceTurn(request)))
+        throw new Error("reassignment id was reused with a different request");
+      return existing;
+    }
+    if (!request.id.trim() || !request.newOwner.trim() || !request.reason.trim())
+      throw new Error("reassignment id, owner and reason are required");
+    this.#assertEvidenceExists(request.evidence);
+    const current = this.#getGoal(request.goalId);
+    if (!current)
+      throw new Error("reassignment goal does not exist");
+    if (current.revision !== request.expectedGoalRevision)
+      throw new Error("reassignment Goal revision is stale");
+    if (!current.parentId)
+      throw new Error("root goals cannot be reassigned by CEO");
+    this.#assertGoalAuthority(current.parentId, actor);
+    if (current.phase === "complete")
+      throw new Error("completed goals cannot be reassigned");
+    if (current.owner === request.newOwner)
+      throw new Error("reassignment owner is unchanged");
+    this.#assertOwnerSeparation(current.id, current.parentId, request.newOwner);
+    return this.#transaction(() => {
+      const goal = { ...current, owner: request.newOwner, revision: current.revision + 1 };
+      const mail = [{ id: `reassignment-new-mail:${request.id}`, to: goal.owner, from: actor, level: "decision", ...goalRoute(goal.id), body: { type: "reassignment", reassignmentId: request.id, role: "new_owner", previousOwner: current.owner, brief: request.brief, reason: request.reason, evidence: request.evidence }, readAt: null }];
+      const wakeBase = goal.phase === "active" ? { id: `reassignment-wake:${request.id}`, ...goalAutomaticTarget(goal.owner, goal.id), triggerRef: `reassignment:${request.id}`, status: "queued", attempt: 0, enqueuedSeq: 0, claimedAt: null, consumedAt: null, turnId: null } : null;
+      this.#insertEvent({ streamId: wakeId ? wakeStream(wakeId) : controlStream("reassignments"), ts: this.#now(), actor, type: "goal.reassigned", data: { reassignmentId: request.id, goalId: goal.id, oldOwner: current.owner, newOwner: goal.owner, mailIds: mail.map((item) => item.id), wakeId: wakeBase?.id ?? null, reason: request.reason, evidence: request.evidence, request: withoutSourceTurn(request) } });
+      this.#faultInjector?.("after_reassignment_event");
+      this.#recordGoalChange(goal, current, actor, wakeId, { operation: "reassign", reason: request.reason, evidence: request.evidence, authority: { kind: "parent_goal", goalId: current.parentId, goalRevision: this.#getGoal(current.parentId).revision }, ...request.sourceTurnId ? { sourceTurnId: request.sourceTurnId } : {}, ...wakeId ? { sourceWakeId: wakeId } : {}, idempotencyKey: request.id });
+      for (const item of mail) {
+        this.#assertNewMail(item, actor);
+        this.#recordProjection("mailbox", item, actor, "mail.put", wakeId);
+      }
+      const wake = wakeBase ? this.#admitWake(wakeBase, "supervisor", false).wake : null;
+      return { reassignmentId: request.id, goal, mail, wake };
+    });
+  }
+  completeGoal(request, actor, wakeId) {
+    if (!request.reason.trim())
+      throw new Error("goal completion reason is required");
+    this.#assertEvidenceExists(request.evidence);
+    const current = this.#getGoal(request.goalId);
+    if (!current)
+      throw new Error("goal does not exist");
+    if (current.phase === "complete") {
+      const decision = this.readStream(goalStream(current.id)).findLast((event) => event.type === "goal.completion_decided");
+      const data = decision?.data;
+      if (decision?.actor === actor && data.revision === request.revision && data.reason === request.reason && JSON.stringify(data.evidence) === JSON.stringify(request.evidence))
+        return current;
+      throw new Error("completed goal cannot accept a different completion decision");
+    }
+    if (request.revision !== current.revision)
+      throw new Error("goal completion revision is stale");
+    if (current.observationMethod === null)
+      throw new Error("goal completion requires an observation method");
+    if (current.verificationMethod === null || current.verificationMethod === void 0)
+      throw new Error("goal completion requires a verification method");
+    this.#assertGoalAuthority(current.parentId, actor);
+    if (current.parentId === null && this.#hasNonCompleteDescendant(current.id))
+      throw new Error("root goal cannot complete while descendants remain non-complete");
+    const source = this.db.prepare("SELECT seq FROM events WHERE stream_id=? AND type='goal.changed' AND json_extract(data,'$.snapshot.revision')=? ORDER BY seq DESC LIMIT 1").get(goalStream(current.id), current.revision);
+    if (!source)
+      throw new Error("goal revision has no source event");
+    if (request.evidence.some((seq) => seq <= source.seq))
+      throw new Error("goal completion evidence predates the current revision");
+    return this.#transaction(() => {
+      this.#insertEvent({ streamId: goalStream(current.id), ts: this.#now(), actor, type: "goal.completion_decided", data: { goalId: current.id, revision: current.revision, observationMethod: current.observationMethod, verificationMethod: current.verificationMethod ?? null, reason: request.reason, evidence: request.evidence } });
+      const next = { ...current, phase: "complete", revision: current.revision + 1 };
+      this.#recordGoalChange(next, current, actor, wakeId, { operation: "complete", reason: request.reason, evidence: request.evidence, authority: this.#goalAuthority(current.parentId, actor), ...request.sourceTurnId ? { sourceTurnId: request.sourceTurnId } : {}, ...wakeId ? { sourceWakeId: wakeId } : {} });
+      return next;
+    });
+  }
+  putSchedule(value, actor, wakeId) {
+    return this.#transaction(() => this.#admitSchedule(value, actor, wakeId));
+  }
+  consumeSchedule(id, wake, now) {
+    const current = this.#requiredSchedule(id);
+    if (current.status !== "pending")
+      throw new Error("only a pending Schedule may be consumed");
+    if (wake.targetKind !== current.targetKind || wake.agent !== current.agent || wake.specialistRole !== current.specialistRole || wake.triggerRef !== `${current.id}@${current.nextWakeAt}` || wake.goalId !== current.goalId)
+      throw new Error("scheduled Wake does not match Schedule");
+    if (wake.status !== "queued" || wake.attempt !== 0 || wake.claimedAt || wake.consumedAt || wake.turnId)
+      throw new Error("scheduled Wake must be pristine");
+    return this.#transaction(() => {
+      const exact = this.wakeByTrigger(wake.agent, wake.triggerRef);
+      let stored;
+      if (exact) {
+        if (exact.status !== "queued" || exact.targetKind !== wake.targetKind || exact.specialistRole !== wake.specialistRole || exact.goalId !== wake.goalId)
+          throw new Error("scheduled Wake trigger is already terminal or bound differently");
+        stored = exact;
+      } else {
+        const queued = this.wakes().find((candidate) => candidate.agent === wake.agent && candidate.status === "queued" && candidate.targetKind === wake.targetKind && candidate.specialistRole === wake.specialistRole && candidate.goalId === wake.goalId);
+        if (queued) {
+          stored = queued;
+          this.#admitWakeTrigger(queued.id, wake.triggerRef, "supervisor", now);
+        } else
+          stored = this.#admitWake(wake, "supervisor", false).wake;
+      }
+      const schedule = { ...current, status: "consumed", resolvedAt: now };
+      this.#recordProjection("schedule", schedule, "supervisor", "schedule.consumed", void 0, now);
+      return { schedule, wake: stored };
+    });
+  }
+  cancelSchedule(id, now) {
+    const current = this.#requiredSchedule(id);
+    if (current.status !== "pending")
+      throw new Error("only a pending Schedule may be cancelled");
+    const next = { ...current, status: "cancelled", resolvedAt: now };
+    this.#project("schedule", next, "supervisor", "schedule.cancelled", void 0, now);
+    return next;
+  }
+  supersedeSchedule(id, now) {
+    const current = this.#requiredSchedule(id);
+    if (current.status !== "pending")
+      throw new Error("only a pending Schedule may be superseded");
+    const next = { ...current, status: "superseded", resolvedAt: now };
+    this.#project("schedule", next, "supervisor", "schedule.superseded", void 0, now);
+    return next;
+  }
+  enqueueWake(input, actor) {
+    return this.#transaction(() => {
+      const result = this.#admitWake(input, actor, true);
+      return { event: result.event, created: result.created };
+    });
+  }
+  addWakeTrigger(wakeId, triggerRef, actor) {
+    return this.#transaction(() => this.#admitWakeTrigger(wakeId, triggerRef, actor, this.#now()));
+  }
+  claimNextWake(now) {
+    return this.#transaction(() => {
+      const row = this.db.prepare(`SELECT * FROM wakes w WHERE status='queued' AND NOT EXISTS (
+        SELECT 1 FROM wakes active WHERE active.agent=w.agent AND active.status='claimed'
+      ) AND NOT EXISTS (
+        SELECT 1 FROM turns WHERE trigger_kind='user_message' AND status='in_progress'
+      ) AND NOT EXISTS (
+        SELECT 1 FROM turns t JOIN threads th ON th.id=t.thread_id WHERE th.agent=w.agent AND t.status='in_progress'
+      ) AND NOT EXISTS (
+        SELECT 1 FROM turns t JOIN threads th ON th.id=t.thread_id WHERE th.agent=w.agent AND t.runner_pid IS NOT NULL
+      ) ORDER BY enqueued_seq LIMIT 1`).get();
+      if (!row)
+        return null;
+      const current = mapWake(row);
+      const next = { ...current, status: "claimed", claimedAt: now, attempt: current.attempt + 1 };
+      this.#recordProjection("wakes", next, "supervisor", "wake.claimed", next.id, now);
+      return next;
+    });
+  }
+  startTurnFromWake(id, turn, now) {
+    const wake = this.#requiredWake(id);
+    if (wake.status !== "claimed")
+      throw new Error("only a claimed Wake may start a Turn");
+    if (this.turn(turn.id))
+      throw new Error("Wake Turn already exists");
+    this.#assertTurnShape(turn);
+    if (turn.status !== "in_progress" || turn.attempt !== 1 || !turn.leaseUntil || !turn.leaseToken || turn.triggerKind !== "wake" || turn.runnerPid !== null)
+      throw new Error("Wake must start an owned Turn at attempt one without a Runner process");
+    const thread = this.thread(turn.threadId);
+    if (!thread || thread.agent !== wake.agent)
+      throw new Error("Wake Turn agent does not match");
+    if (!sameWakeTurnTarget(wake, turn, thread))
+      throw new Error("Wake Turn target does not match");
+    return this.#transaction(() => {
+      if (this.db.prepare("SELECT 1 FROM turns WHERE trigger_kind='user_message' AND status='in_progress' LIMIT 1").get())
+        throw new Error("automatic Wake cannot start while a user Turn is in progress");
+      this.#assertCurrentAutomaticTurn(turn, thread);
+      this.#recordProjection("turns", turn, "supervisor", "turn.started", void 0, now, void 0, `turn:${turn.id}`);
+      this.#resolveWakeTriggers(id, now);
+      const next = { ...wake, status: "consumed", consumedAt: now, turnId: turn.id };
+      this.#recordProjection("wakes", next, "supervisor", "wake.consumed", id, now);
+      return next;
+    });
+  }
+  releaseWake(id, now) {
+    const current = this.#requiredWake(id);
+    if (current.status !== "claimed")
+      throw new Error("only a claimed Wake may be released");
+    const next = { ...current, status: "queued", claimedAt: null };
+    this.#project("wakes", next, "supervisor", "wake.released", id, now);
+    return next;
+  }
+  cancelWake(id, now) {
+    const current = this.#requiredWake(id);
+    return this.#transaction(() => this.#cancelWakeProjection(current, now));
+  }
+  attachTurnProcess(id, leaseToken, pid) {
+    const current = this.#requiredTurn(id);
+    this.#assertTurnLease(current, leaseToken);
+    if (current.status !== "in_progress" || current.runnerPid !== null || !Number.isInteger(pid) || pid <= 0)
+      throw new Error("a positive Runner pid may attach once to an active Turn");
+    return this.#transaction(() => {
+      const next = { ...current, runnerPid: pid };
+      this.#recordProjection("turns", next, "supervisor", "turn.process_attached", void 0, this.#now(), void 0, `turn:${id}`);
+      return next;
+    });
+  }
+  renewTurnLease(id, leaseToken, leaseUntil, now) {
+    const current = this.#requiredTurn(id);
+    this.#assertTurnLease(current, leaseToken);
+    if (current.status !== "in_progress")
+      throw new Error("only an active Turn lease may be renewed");
+    if (leaseUntil <= now)
+      throw new Error("renewed lease must expire in the future");
+    this.putTurn({ ...current, leaseUntil }, "supervisor");
+    return this.#requiredTurn(id);
+  }
+  appendTurnEvent(input, leaseToken) {
+    return this.#transaction(() => {
+      this.#assertRawEvent(input);
+      if (!input.streamId.startsWith("turn:"))
+        throw new Error("runner event requires a Turn stream");
+      const turn = this.#requiredTurn(input.streamId.slice("turn:".length));
+      this.#assertTurnLease(turn, leaseToken);
+      if (turn.status !== "in_progress" || !turn.leaseUntil || input.ts > turn.leaseUntil)
+        throw new Error("stale runner event rejected");
+      return this.#insertEvent(input);
+    });
+  }
+  repairTurnAttempt(id, reason, now, actor) {
+    const current = this.#requiredTurn(id);
+    if (current.status !== "in_progress")
+      throw new Error("only an active Turn attempt may be repaired");
+    return this.#transaction(() => this.#repairOpenTurnItems(id, reason, now, actor));
+  }
+  finishTurn(id, status, error, now, actor, mailIds = []) {
+    const current = this.#requiredTurn(id);
+    return this.#transaction(() => this.#finishTurn(current, status, error, now, actor, mailIds));
+  }
+  releaseTurnProcess(id, actor) {
+    if (actor !== "supervisor")
+      throw new Error("only supervisor may release Runner process ownership");
+    return this.#transaction(() => {
+      const current = this.#requiredTurn(id);
+      if (current.runnerPid === null)
+        throw new Error("Turn has no Runner process ownership to release");
+      const next = { ...current, runnerPid: null };
+      this.#recordProjection("turns", next, actor, "turn.process_released", void 0, this.#now(), void 0, `turn:${id}`);
+      return next;
+    });
+  }
+  putMail(mail, actor, wakeId) {
+    return this.putMails([mail], actor, wakeId)[0];
+  }
+  putMails(mails, actor, wakeId) {
+    const ids = /* @__PURE__ */ new Set();
+    const prior = /* @__PURE__ */ new Map();
+    for (const mail of mails) {
+      this.#assertMailRequest(mail, actor);
+      if (ids.has(mail.id))
+        throw new Error("mail batch contains a duplicate id");
+      ids.add(mail.id);
+      const row = this.db.prepare("SELECT * FROM mailbox WHERE id=?").get(mail.id);
+      if (!row)
+        continue;
+      const current = mapMail(row);
+      if (current.routeKind !== mail.routeKind || current.to !== mail.to || current.from !== mail.from || current.specialistRole !== mail.specialistRole || current.level !== mail.level || current.goalId !== mail.goalId || !isDeepStrictEqual(current.body, mail.body))
+        throw new Error("mail id was reused with different content");
+      const event = this.db.prepare("SELECT * FROM events WHERE type='mail.put' AND json_extract(data,'$.snapshot.id')=? ORDER BY seq LIMIT 1").get(mail.id);
+      if (!event)
+        throw new Error("mail projection has no source event");
+      prior.set(mail.id, mapEvent(event));
+    }
+    return this.#transaction(() => mails.map((mail) => prior.get(mail.id) ?? this.#recordProjection("mailbox", mail, actor, "mail.put", wakeId)));
+  }
+  commitHandoff(commit) {
+    return this.#transaction(() => {
+      const turn = this.#requiredTurn(commit.turnId);
+      const thread = this.thread(turn.threadId);
+      if (turn.status !== "in_progress" || thread?.agent !== commit.agent)
+        throw new Error("handoff does not match an active Turn");
+      if (turn.goalId === null)
+        throw new Error("only a committed Turn may commit Handoff");
+      const goal = this.#getGoal(turn.goalId);
+      if (!goal || goal.owner !== commit.agent || goal.phase !== "active" || goal.revision !== turn.goalRevision)
+        throw new Error("Handoff Turn Goal commitment is stale");
+      const record = this.workRecord(goal.id);
+      if (!record || record.updatedInTurn !== turn.id || record.goalRevision !== goal.revision || record.recordRevision < 1)
+        throw new Error("committed Turn must update its Work Record before Handoff");
+      assertHandoff(commit.output.handoff);
+      if (commit.output.handoff.goalId !== goal.id || commit.output.handoff.goalRevision !== goal.revision || commit.output.handoff.recordRevision !== record.recordRevision)
+        throw new Error("Goal Handoff does not match the current Goal and Work Record");
+      this.#assertEvidenceExists(commit.output.handoff.evidence);
+      const responseItem = this.turnItems(turn.id).find((item) => item.id === commit.responseItemId);
+      if (!responseItem || responseItem.type !== "assistant_message" || responseItem.status !== "completed" || typeof responseItem.data.text !== "string" || !responseItem.data.text.trim())
+        throw new Error("Handoff response does not match a readable Turn Item");
+      const ordinal = this.turnItems(turn.id).length + 1;
+      if (commit.item.turnId !== turn.id || commit.item.type !== "handoff" || commit.item.status !== "completed" || commit.item.completedAt !== commit.ts || commit.item.createdAt !== commit.ts || commit.item.ordinal !== ordinal || !isDeepStrictEqual(commit.item.data, commit.output.handoff))
+        throw new Error("handoff Item does not match active TurnOutput");
+      if (commit.sourceWakeId) {
+        const wake = this.#requiredWake(commit.sourceWakeId);
+        if (wake.status !== "consumed" || wake.turnId !== turn.id)
+          throw new Error("handoff source Wake does not match Turn");
+      }
+      const streamId = `turn:${commit.turnId}`;
+      this.#insertEvent({ streamId, ts: commit.ts, actor: commit.agent, type: "response.committed", data: { messageItemId: responseItem.id, text: responseItem.data.text } });
+      this.#admitTurnItem(commit.item, commit.agent, streamId);
+      const event = this.#insertEvent({ streamId, ts: commit.ts, actor: commit.agent, type: "handoff.recorded", data: commit.output.handoff });
+      const delivered = new Set(commit.mailIds);
+      this.#recordMailReads(this.unreadMail(commit.agent).filter((candidate) => delivered.has(candidate.id)), commit.ts, streamId);
+      if (this.turnItems(turn.id).some((item) => item.status === "in_progress"))
+        throw new Error("successful Turn cannot retain in-progress Items");
+      this.#insertEvent({ streamId, ts: commit.ts, actor: "supervisor", type: "transcript.completed", data: {} });
+      this.#recordProjection("turns", { ...turn, status: "completed", error: null, endedAt: commit.ts, leaseUntil: null, leaseToken: null }, "supervisor", "turn.completed", void 0, commit.ts, void 0, streamId);
+      return event;
+    });
+  }
+  dueSchedules(now) {
+    return this.db.prepare("SELECT * FROM schedule WHERE status='pending' AND next_wake_at <= ? ORDER BY next_wake_at,id").all(now).map(mapSchedule);
+  }
+  unreadMail(agent) {
+    return this.db.prepare("SELECT * FROM mailbox WHERE to_agent=? AND read_at IS NULL ORDER BY rowid").all(agent).map(mapMail);
+  }
+  lastEvent(actor, type) {
+    const row = this.db.prepare("SELECT * FROM events WHERE actor=? AND type=? ORDER BY seq DESC LIMIT 1").get(actor, type);
+    return row ? mapEvent(row) : null;
+  }
+  lastGoalHandoff(goalId) {
+    const row = this.db.prepare("SELECT * FROM events WHERE type='handoff.recorded' AND json_extract(data,'$.goalId')=? ORDER BY seq DESC LIMIT 1").get(goalId);
+    return row ? mapEvent(row) : null;
+  }
+  latestEvent() {
+    const row = this.db.prepare("SELECT * FROM events ORDER BY seq DESC LIMIT 1").get();
+    return row ? mapEvent(row) : null;
+  }
+  eventsForWake(wakeId) {
+    return this.readStream(wakeStream(wakeId));
+  }
+  wake(id) {
+    const row = this.db.prepare("SELECT * FROM wakes WHERE id=?").get(id);
+    return row ? mapWake(row) : null;
+  }
+  wakeByTrigger(agent, triggerRef) {
+    const row = this.db.prepare("SELECT w.* FROM wake_triggers t JOIN wakes w ON w.id=t.wake_id WHERE t.agent=? AND t.trigger_ref=?").get(agent, triggerRef);
+    return row ? mapWake(row) : null;
+  }
+  wakeTriggers(wakeId) {
+    return this.db.prepare("SELECT * FROM wake_triggers WHERE wake_id=? ORDER BY rowid").all(wakeId).map(mapWakeTrigger);
+  }
+  wakeTriggersForAgent(agent) {
+    return this.db.prepare("SELECT * FROM wake_triggers WHERE agent=? ORDER BY rowid").all(agent).map(mapWakeTrigger);
+  }
+  queuedWakeForAgent(agent) {
+    const row = this.db.prepare("SELECT * FROM wakes WHERE agent=? AND status='queued' ORDER BY enqueued_seq LIMIT 1").get(agent);
+    return row ? mapWake(row) : null;
+  }
+  goalsForOwner(owner) {
+    return this.db.prepare("SELECT * FROM goals WHERE owner=? ORDER BY id").all(owner).map(mapGoal);
+  }
+  goal(id) {
+    return this.#getGoal(id);
+  }
+  workRecord(goalId) {
+    const row = this.db.prepare("SELECT * FROM work_records WHERE goal_id=?").get(goalId);
+    return row ? mapWorkRecord(row) : null;
+  }
+  workRecordHistory(goalId) {
+    return this.readStream(workRecordStream(goalId)).filter((event) => event.type === "work_record.created" || event.type === "work_record.updated").map((event) => mapWorkRecordEvent(event));
+  }
+  workRecordDiff(goalId, fromRevision, toRevision) {
+    const history = this.workRecordHistory(goalId);
+    const from = history.find((record) => record.recordRevision === fromRevision);
+    const to = history.find((record) => record.recordRevision === toRevision);
+    if (!from || !to)
+      throw new Error("work record diff revision does not exist");
+    return { goalId, fromRevision, toRevision, text: lineDiff(from.content, to.content) };
+  }
+  searchWorkRecords(query, limit = 50) {
+    return this.db.prepare(`SELECT e.* FROM events_fts f JOIN events e ON e.seq=f.rowid
+      WHERE events_fts MATCH ? AND e.type IN ('work_record.created','work_record.updated') ORDER BY rank LIMIT ?`).all(query, limit).map((row) => mapWorkRecordEvent(mapEvent(row)));
+  }
+  triggeringMail() {
+    return this.db.prepare("SELECT * FROM mailbox WHERE read_at IS NULL AND level IN ('decision','emergency') ORDER BY rowid").all().map(mapMail);
+  }
+  eventsSince(seq, types) {
+    const events = this.db.prepare("SELECT * FROM events WHERE seq>? ORDER BY seq").all(seq).map(mapEvent);
+    return types?.length ? events.filter((event) => types.includes(event.type)) : events;
+  }
+  searchEvents(query, limit = 50) {
+    return this.db.prepare("SELECT e.* FROM events_fts f JOIN events e ON e.seq=f.rowid WHERE events_fts MATCH ? ORDER BY rank LIMIT ?").all(query, limit).map(mapEvent);
+  }
+  events() {
+    return this.db.prepare("SELECT * FROM events ORDER BY seq").all().map(mapEvent);
+  }
+  goals() {
+    return this.db.prepare("SELECT * FROM goals ORDER BY id").all().map(mapGoal);
+  }
+  workRecords() {
+    return this.db.prepare("SELECT * FROM work_records ORDER BY goal_id").all().map(mapWorkRecord);
+  }
+  schedules() {
+    return this.db.prepare("SELECT * FROM schedule ORDER BY id").all().map(mapSchedule);
+  }
+  wakes() {
+    return this.db.prepare("SELECT * FROM wakes ORDER BY enqueued_seq").all().map(mapWake);
+  }
+  mailbox() {
+    return this.db.prepare("SELECT * FROM mailbox ORDER BY rowid").all().map(mapMail);
+  }
+  rebuildProjections() {
+    const source = this.db.prepare("SELECT * FROM events ORDER BY seq").all();
+    this.#transaction(() => {
+      this.db.exec("DELETE FROM turn_items; DELETE FROM wake_triggers; DELETE FROM wakes; DELETE FROM turns; DELETE FROM threads; DELETE FROM work_records; DELETE FROM mailbox; DELETE FROM schedule; DELETE FROM goals;");
+      const goalKeys = /* @__PURE__ */ new Set();
+      for (const row of source) {
+        if (row.projection_name === null)
+          continue;
+        const event = mapEvent(row);
+        const projection = String(row.projection_name);
+        const expected = projectionForEvent(event.type);
+        if (expected !== projection)
+          throw new Error(`event ${event.seq} cannot drive ${projection} projection`);
+        const data = event.data && typeof event.data === "object" && !Array.isArray(event.data) ? event.data : null;
+        if (!data || !("snapshot" in data))
+          throw new Error(`projection event ${event.seq} has no snapshot`);
+        if (projection === "goals")
+          this.#replayGoalChange(event, goalKeys);
+        else
+          this.#replayProjection(projection, data.snapshot, event);
+      }
+    });
+  }
+  #delegationResult(id) {
+    const row = this.db.prepare("SELECT data,actor FROM events WHERE type='delegation.created' AND json_extract(data,'$.delegationId')=? ORDER BY seq LIMIT 1").get(id);
+    if (!row)
+      return null;
+    const data = JSON.parse(row.data);
+    const goal = this.#goalChangeSnapshot(id, row.actor);
+    const mail = this.#eventSnapshot("mail.put", data.mailId);
+    const wake = this.#eventSnapshot("wake.enqueued", data.wakeId);
+    if (!goal || !mail || !wake)
+      throw new Error("committed delegation facts are incomplete");
+    return { delegationId: id, goal, mail, wake };
+  }
+  #reassignmentResult(id) {
+    const row = this.db.prepare("SELECT data,actor FROM events WHERE type='goal.reassigned' AND json_extract(data,'$.reassignmentId')=? ORDER BY seq LIMIT 1").get(id);
+    if (!row)
+      return null;
+    const data = JSON.parse(row.data);
+    const goal = this.#goalChangeSnapshot(id, row.actor);
+    const mail = data.mailIds.map((mailId) => {
+      const value = this.#eventSnapshot("mail.put", mailId);
+      if (!value)
+        throw new Error("committed reassignment mail is missing");
+      return value;
+    });
+    const wake = data.wakeId ? this.#eventSnapshot("wake.enqueued", data.wakeId) : null;
+    if (!goal || data.wakeId && !wake)
+      throw new Error("committed reassignment facts are incomplete");
+    return { reassignmentId: id, goal, mail, wake };
+  }
+  #goalChangeSnapshot(id, actor) {
+    const row = this.db.prepare("SELECT data FROM events WHERE type='goal.changed' AND actor=? AND json_extract(data,'$.idempotencyKey')=? ORDER BY seq LIMIT 1").get(actor, id);
+    return row ? JSON.parse(row.data).snapshot : null;
+  }
+  #eventSnapshot(type, id) {
+    const row = this.db.prepare("SELECT data FROM events WHERE type=? AND json_extract(data,'$.snapshot.id')=? ORDER BY seq LIMIT 1").get(type, id);
+    return row ? JSON.parse(row.data).snapshot : null;
+  }
+  #recordGoalChange(snapshot, previous, actor, wakeId, change) {
+    const derivedOperation = goalOperation(previous, snapshot);
+    if (change && change.operation !== derivedOperation)
+      throw new Error("Goal change operation does not match its state transition");
+    const operation = change?.operation ?? derivedOperation;
+    if (change && !change.reason.trim())
+      throw new Error("Goal change reason is required");
+    const evidence = change?.evidence ?? [];
+    if (evidence.length)
+      this.#assertEvidenceExists(evidence);
+    const expectedAuthority = this.#goalAuthority(snapshot.parentId, actor);
+    if (change?.authority && !isDeepStrictEqual(change.authority, expectedAuthority))
+      throw new Error("Goal change authority does not match the authenticated actor");
+    const authority = change?.authority ?? expectedAuthority;
+    const sourceWakeId = change?.sourceWakeId ?? wakeId;
+    this.#assertGoalProvenance(snapshot, actor, authority, change?.sourceTurnId, sourceWakeId);
+    if (change?.idempotencyKey && this.db.prepare("SELECT 1 FROM events WHERE type='goal.changed' AND actor=? AND json_extract(data,'$.idempotencyKey')=?").get(actor, change.idempotencyKey))
+      throw new Error("Goal idempotency key is already committed");
+    const data = { version: 1, operation, previousRevision: previous?.revision ?? null, snapshot, reason: change?.reason?.trim() || defaultGoalReason(operation), evidence, authority, ...change?.sourceTurnId ? { sourceTurnId: change.sourceTurnId } : {}, ...sourceWakeId ? { sourceWakeId } : {}, ...change?.idempotencyKey ? { idempotencyKey: change.idempotencyKey } : {} };
+    const event = this.#insertEvent({ streamId: goalStream(snapshot.id), ts: this.#now(), actor, type: "goal.changed", data }, void 0, "goals");
+    this.#faultInjector?.("after_event_before_projection");
+    this.#applyProjection("goals", snapshot, event.seq);
+    if (previous && (previous.owner !== snapshot.owner || previous.phase !== snapshot.phase && snapshot.phase !== "active")) {
+      this.#cancelWakesForGoal(snapshot.id, this.#now());
+      this.#supersedeSchedulesForGoal(snapshot.id, this.#now());
+    }
+    return event;
+  }
+  #replayGoalChange(event, keys) {
+    if (event.type !== "goal.changed")
+      throw new Error(`event ${event.seq} is not an authoritative Goal change`);
+    const data = event.data;
+    if (data.version !== 1)
+      throw new Error(`goal.changed ${event.seq} has an unsupported format`);
+    const snapshot = normalizeGoal(data.snapshot);
+    assertGoalSnapshot(snapshot);
+    if (event.streamId !== goalStream(snapshot.id))
+      throw new Error(`goal.changed ${event.seq} uses the wrong stream`);
+    const previous = this.#getGoal(snapshot.id);
+    if (data.previousRevision !== (previous?.revision ?? null) || snapshot.revision !== (previous ? previous.revision + 1 : 0) || data.operation !== goalOperation(previous, snapshot))
+      throw new Error(`goal.changed ${event.seq} breaks the Goal revision chain`);
+    if (!data.reason.trim())
+      throw new Error(`goal.changed ${event.seq} has no reason`);
+    for (const seq of data.evidence)
+      if (!Number.isInteger(seq) || seq <= 0 || seq >= event.seq)
+        throw new Error(`goal.changed ${event.seq} has invalid evidence`);
+    const expected = this.#goalAuthority(snapshot.parentId, event.actor);
+    if (!isDeepStrictEqual(data.authority, expected))
+      throw new Error(`goal.changed ${event.seq} has invalid authority`);
+    this.#assertGoalProvenance(snapshot, event.actor, data.authority, data.sourceTurnId, data.sourceWakeId);
+    if (data.idempotencyKey) {
+      const key = `${event.actor}\0${data.idempotencyKey}`;
+      if (keys.has(key))
+        throw new Error(`goal.changed ${event.seq} reuses an idempotency key`);
+      keys.add(key);
+    }
+    this.#applyProjection("goals", snapshot, event.seq);
+  }
+  #assertGoalProvenance(snapshot, actor, authority, sourceTurnId, sourceWakeId) {
+    if (sourceWakeId && !sourceTurnId)
+      throw new Error("Goal change source Wake requires its source Turn");
+    const turn = sourceTurnId ? this.turn(sourceTurnId) : null;
+    if (sourceTurnId && !turn)
+      throw new Error("Goal change source Turn does not exist");
+    if (turn) {
+      if (turn.status !== "in_progress")
+        throw new Error("Goal change source Turn is not active");
+      const thread = this.thread(turn.threadId);
+      if (!thread)
+        throw new Error("Goal change source Turn has no Thread");
+      if (authority.kind === "human") {
+        const legalCommitment = turn.goalId === null || turn.goalId === snapshot.id;
+        if (turn.triggerKind !== "user_message" || thread.role !== "ceo" || !legalCommitment)
+          throw new Error("Goal change source Turn does not carry Human authority");
+      } else if (authority.kind === "parent_goal") {
+        if (thread.agent !== actor || turn.goalId !== authority.goalId || turn.goalRevision !== authority.goalRevision)
+          throw new Error("Goal change source Turn is not committed to the authorizing parent Goal");
+      } else if (thread.agent !== actor)
+        throw new Error("Goal change source Turn actor does not match");
+    }
+    if (sourceWakeId) {
+      const wake = this.wake(sourceWakeId);
+      if (!wake)
+        throw new Error("Goal change source Wake does not exist");
+      if (wake.status !== "consumed" || sourceTurnId && wake.turnId !== sourceTurnId)
+        throw new Error("Goal change source Wake does not match its Turn");
+      if (authority.kind === "parent_goal" && (wake.targetKind !== "goal" || wake.agent !== actor || wake.goalId !== authority.goalId))
+        throw new Error("Goal change source Wake is not bound to the authorizing parent Goal");
+    }
+  }
+  #goalAuthority(parentId, actor) {
+    if (parentId === null)
+      return actor === "human" ? { kind: "human" } : { kind: "system", reason: `root mutation by ${actor}` };
+    const parent = this.#getGoal(parentId);
+    if (!parent)
+      throw new Error("parent goal does not exist");
+    return { kind: "parent_goal", goalId: parent.id, goalRevision: parent.revision };
+  }
+  #createWorkRecord(goal, actor, turnId, wakeId, seed) {
+    return this.#recordWorkRecord({
+      goalId: goal.id,
+      recordRevision: 0,
+      goalRevision: goal.revision,
+      content: seed?.content ?? initialWorkRecord(),
+      updatedBy: actor,
+      updatedInTurn: turnId,
+      sourceWakeId: wakeId ?? null,
+      updatedAt: this.#now(),
+      reason: "Goal created",
+      evidence: seed?.evidence ?? [],
+      lastEventSeq: 0
+    }, "work_record.created");
+  }
+  #recordWorkRecord(snapshot, type) {
+    const seq = this.#nextEventSeq();
+    const committed = { ...snapshot, lastEventSeq: seq };
+    this.#recordProjection("work_records", committed, committed.updatedBy, type, committed.sourceWakeId ?? void 0, committed.updatedAt, seq, workRecordStream(committed.goalId));
+    return committed;
+  }
+  #assertWorkRecordAuthority(goal, actor) {
+    if (goal.owner === actor || goal.parentId === null && actor === "human")
+      return;
+    const parent = goal.parentId ? this.#getGoal(goal.parentId) : null;
+    if (parent?.owner !== actor)
+      throw new Error("only the goal owner or parent owner may update its work record");
+  }
+  #assertGoalAuthority(parentId, actor) {
+    if (parentId === null) {
+      if (actor !== "human")
+        throw new Error("only human may modify a root goal");
+      return;
+    }
+    const parent = this.#getGoal(parentId);
+    if (!parent)
+      throw new Error("parent goal does not exist");
+    if (parent.owner !== actor)
+      throw new Error("only the parent goal owner may modify a child goal");
+  }
+  #assertOwnerSeparation(goalId, parentId, owner) {
+    if (parentId && this.#getGoal(parentId)?.owner === owner)
+      throw new Error("parent and child Goals require distinct owners");
+    if (this.goals().some((goal) => goal.parentId === goalId && goal.owner === owner))
+      throw new Error("parent and child Goals require distinct owners");
+  }
+  #hasNonCompleteDescendant(goalId) {
+    return Boolean(this.db.prepare(`WITH RECURSIVE descendants(id) AS (
+      SELECT id FROM goals WHERE parent_id=?
+      UNION ALL SELECT g.id FROM goals g JOIN descendants d ON g.parent_id=d.id
+    ) SELECT 1 FROM goals WHERE id IN (SELECT id FROM descendants) AND phase<>'complete' LIMIT 1`).get(goalId));
+  }
+  #assertEvidenceExists(evidence) {
+    if (evidence.length === 0)
+      throw new Error("evidence is required");
+    const exists = this.db.prepare("SELECT 1 FROM events WHERE seq=?");
+    for (const seq of evidence)
+      if (!Number.isInteger(seq) || seq <= 0 || !exists.get(seq))
+        throw new Error(`evidence event does not exist: ${seq}`);
+  }
+  #assertTurnLease(turn, leaseToken) {
+    if (turn.leaseToken !== leaseToken)
+      throw new Error("stale Turn lease token");
+  }
+  #assertRawEvent(input) {
+    if (input.type === "goal.changed")
+      throw new Error("projection-driving events must use a typed Ledger domain API");
+  }
+  #getGoal(id) {
+    const row = this.db.prepare("SELECT * FROM goals WHERE id=?").get(id);
+    return row ? mapGoal(row) : null;
+  }
+  #requiredTurn(id) {
+    const value = this.turn(id);
+    if (!value)
+      throw new Error(`turn not found: ${id}`);
+    return value;
+  }
+  #requiredWake(id) {
+    const value = this.wake(id);
+    if (!value)
+      throw new Error(`wake not found: ${id}`);
+    return value;
+  }
+  #admitThread(thread, actor) {
+    if (!thread.id.trim() || !thread.agent.trim())
+      throw new Error("thread id and agent are required");
+    if (thread.agent === "ceo" !== (thread.role === "ceo"))
+      throw new Error("exactly the ceo Agent must use the ceo Thread role");
+    const current = this.thread(thread.id);
+    const agentThread = this.threads().find((candidate) => candidate.agent === thread.agent);
+    if (agentThread && agentThread.id !== thread.id)
+      throw new Error("agent already owns a Thread");
+    if (current && (current.agent !== thread.agent || current.role !== thread.role || current.parentThreadId !== thread.parentThreadId || current.createdAt !== thread.createdAt))
+      throw new Error("thread identity cannot change");
+    return this.#recordProjection("threads", thread, actor, "thread.put", void 0, thread.updatedAt, void 0, `thread:${thread.id}`);
+  }
+  #finishTurn(current, status, error, now, actor, mailIds) {
+    if (current.status !== "in_progress")
+      throw new Error("only an active Turn may finish");
+    if (status === "completed" && current.goalId !== null)
+      throw new Error("committed Turn completion requires commitHandoff");
+    if (status === "completed" && error !== null || status !== "completed" && error === null)
+      throw new Error("Turn terminal error does not match status");
+    if (status !== "completed")
+      this.#repairOpenTurnItems(current.id, String(error.message ?? "Turn interrupted"), now, actor);
+    else if (this.turnItems(current.id).some((item) => item.status === "in_progress"))
+      throw new Error("successful Turn cannot retain in-progress Items");
+    const streamId = `turn:${current.id}`;
+    const thread = this.thread(current.threadId);
+    const delivered = new Set(mailIds);
+    if (status !== "completed" && mailIds.length)
+      throw new Error("failed Turn cannot acknowledge Mail");
+    if (status === "completed" && thread)
+      this.#recordMailReads(this.unreadMail(thread.agent).filter((candidate) => delivered.has(candidate.id)), now, streamId);
+    this.#insertEvent({ streamId, ts: now, actor, type: status === "completed" ? "transcript.completed" : "transcript.interrupted", data: status === "completed" ? {} : { reason: String(error.message ?? "Turn interrupted") } });
+    const next = { ...current, status, error, endedAt: now, leaseUntil: null, leaseToken: null };
+    this.#recordProjection("turns", next, actor, `turn.${status}`, void 0, now, void 0, streamId);
+    return next;
+  }
+  #admitWake(input, actor, allowExisting) {
+    if (actor !== "supervisor")
+      throw new Error("only supervisor may enqueue wakes");
+    this.#assertAutomaticTarget(input);
+    if (!input.id.trim() || !input.agent.trim() || !input.triggerRef.trim())
+      throw new Error("Wake id, agent, and trigger are required");
+    if (input.status !== "queued" || input.attempt !== 0 || input.claimedAt || input.consumedAt || input.turnId)
+      throw new Error("new wake must be pristine and queued");
+    const sameId = this.wake(input.id);
+    if (sameId) {
+      const sameIdentity = sameId.targetKind === input.targetKind && sameId.agent === input.agent && sameId.specialistRole === input.specialistRole && sameId.triggerRef === input.triggerRef && sameId.goalId === input.goalId;
+      if (!allowExisting || !sameIdentity)
+        throw new Error("wake id was reused with a different identity");
+      const row = this.db.prepare("SELECT * FROM events WHERE type='wake.enqueued' AND json_extract(data,'$.snapshot.id')=? ORDER BY seq LIMIT 1").get(sameId.id);
+      if (!row)
+        throw new Error("wake projection has no source event");
+      return { event: mapEvent(row), created: false, wake: sameId };
+    }
+    const duplicate = this.wakeByTrigger(input.agent, input.triggerRef);
+    if (duplicate) {
+      const sameTarget = duplicate.targetKind === input.targetKind && duplicate.specialistRole === input.specialistRole && duplicate.goalId === input.goalId;
+      if (!allowExisting || !sameTarget)
+        throw new Error("Wake trigger was reused with a different automatic target");
+      const row = this.db.prepare("SELECT * FROM events WHERE type='wake.enqueued' AND json_extract(data,'$.snapshot.id')=? ORDER BY seq LIMIT 1").get(duplicate.id);
+      if (!row)
+        throw new Error("wake projection has no source event");
+      return { event: mapEvent(row), created: false, wake: duplicate };
+    }
+    if (input.targetKind === "goal") {
+      const goal = this.#getGoal(input.goalId);
+      if (!goal || goal.owner !== input.agent || goal.phase !== "active")
+        throw new Error("Wake Goal target is inactive or owned by another Agent");
+    }
+    const enqueuedSeq = this.#nextEventSeq();
+    const wake = { ...input, enqueuedSeq };
+    const event = this.#recordProjection("wakes", wake, actor, "wake.enqueued", wake.id, void 0, enqueuedSeq);
+    this.#admitWakeTrigger(wake.id, wake.triggerRef, actor, event.ts);
+    return { event, created: true, wake };
+  }
+  #admitWakeTrigger(wakeId, triggerRef, actor, at) {
+    if (actor !== "supervisor")
+      throw new Error("only supervisor may add Wake triggers");
+    if (!triggerRef.trim())
+      throw new Error("Wake trigger is required");
+    const wake = this.#requiredWake(wakeId);
+    if (wake.status !== "queued" && wake.status !== "claimed")
+      throw new Error("triggers may only be added before a Wake starts its Turn");
+    const row = this.db.prepare("SELECT * FROM wake_triggers WHERE agent=? AND trigger_ref=?").get(wake.agent, triggerRef);
+    if (row) {
+      const current = mapWakeTrigger(row);
+      if (current.wakeId !== wake.id)
+        throw new Error("Wake trigger is already owned by another Wake");
+      return current;
+    }
+    const mailId = mailIdFromTrigger(triggerRef);
+    const mail = mailId ? this.mailbox().find((candidate) => candidate.id === mailId) : null;
+    if (mail) {
+      const matches = mail.routeKind === "goal" ? wake.targetKind === "goal" && wake.goalId === mail.goalId : mail.routeKind === "specialist_inbox" ? wake.targetKind === "specialist" && wake.specialistRole === mail.specialistRole : false;
+      if (!matches)
+        throw new Error("Mail trigger does not match the Wake automatic target");
+    }
+    const source = wake.targetKind === "goal" ? "goal" : "system";
+    const trigger = { wakeId: wake.id, agent: wake.agent, triggerRef, source, status: "pending", addedAt: at, resolvedAt: null };
+    this.#recordProjection("wake_triggers", trigger, "supervisor", "wake_trigger.added", wake.id, at);
+    return trigger;
+  }
+  #resolveWakeTriggers(wakeId, now) {
+    return this.wakeTriggers(wakeId).filter((trigger) => trigger.status === "pending").map((trigger) => {
+      const next = { ...trigger, status: "resolved", resolvedAt: now };
+      this.#recordProjection("wake_triggers", next, "supervisor", "wake_trigger.resolved", wakeId, now);
+      return next;
+    });
+  }
+  #cancelWakeProjection(wake, now) {
+    if (wake.status !== "queued" && wake.status !== "claimed")
+      throw new Error("only a pending Wake may be cancelled");
+    this.#resolveWakeTriggers(wake.id, now);
+    const next = { ...wake, status: "cancelled", consumedAt: now };
+    this.#recordProjection("wakes", next, "supervisor", "wake.cancelled", wake.id, now);
+    return next;
+  }
+  #requiredSchedule(id) {
+    const row = this.db.prepare("SELECT * FROM schedule WHERE id=?").get(id);
+    if (!row)
+      throw new Error(`schedule not found: ${id}`);
+    return mapSchedule(row);
+  }
+  #admitTurnItem(item, actor, streamId = `turn:${item.turnId}`) {
+    if (item.type === "assistant_message") {
+      const data = item.data && typeof item.data === "object" && !Array.isArray(item.data) ? item.data : null;
+      const text = normalizeAssistantText(String(data?.text ?? ""));
+      if (!data || !text)
+        throw new Error("assistant message requires canonical readable text");
+      item = { ...item, data: { ...data, text } };
+    }
+    if (!item.id.trim() || !item.turnId.trim())
+      throw new Error("turn item id and turn are required");
+    const turn = this.turn(item.turnId);
+    if (!turn)
+      throw new Error("turn item turn does not exist");
+    if (turn.status !== "in_progress")
+      throw new Error("terminal turn cannot accept items");
+    if (item.status === "in_progress" && item.completedAt !== null || item.status !== "in_progress" && item.completedAt === null)
+      throw new Error("turn item terminal time does not match status");
+    const current = this.db.prepare("SELECT * FROM turn_items WHERE id=?").get(item.id);
+    if (current && (String(current.turn_id) !== item.turnId || String(current.type) !== item.type || String(current.status) !== "in_progress"))
+      throw new Error("turn item identity or terminal state cannot change");
+    return this.#recordProjection("turn_items", item, actor, current ? `item.${item.type}.${item.status}` : `item.${item.type}.started`, void 0, item.completedAt ?? item.createdAt, void 0, streamId);
+  }
+  #assertMailRequest(mail, actor) {
+    if (!mail.id.trim() || !mail.to.trim() || !mail.from.trim())
+      throw new Error("mail id, sender, and recipient are required");
+    if (mail.from !== actor && actor !== "supervisor")
+      throw new Error("mail sender does not match actor");
+    if (mail.readAt !== null)
+      throw new Error("new mail must be unread");
+    if (mail.routeKind === "goal") {
+      if (mail.specialistRole !== null)
+        throw new Error("Goal Mail cannot carry a specialist role");
+      const goal = this.#getGoal(mail.goalId);
+      if (!goal || goal.owner !== mail.to)
+        throw new Error("Mail Goal route is not owned by its recipient");
+    } else if (mail.routeKind === "human_inbox") {
+      if (mail.to !== "ceo" || mail.goalId !== null || mail.specialistRole !== null || !["human", "verifier", "audit", "supervisor"].includes(mail.from))
+        throw new Error("Human inbox Mail has an invalid sender or recipient");
+    } else if (mail.routeKind === "human_request") {
+      if (mail.to !== "human" || mail.from !== "ceo" || mail.goalId !== null || mail.specialistRole !== null)
+        throw new Error("Human request Mail has an invalid sender or recipient");
+    } else if (mail.goalId !== null || mail.specialistRole === null)
+      throw new Error("Specialist inbox Mail has an invalid route");
+  }
+  #assertNewMail(mail, actor) {
+    this.#assertMailRequest(mail, actor);
+    if (this.db.prepare("SELECT 1 FROM mailbox WHERE id=?").get(mail.id))
+      throw new Error("mail id is already in use");
+  }
+  #recordMailReads(mails, now, streamId) {
+    for (const mail of mails)
+      this.#recordProjection("mailbox", { ...mail, readAt: now }, "supervisor", "mail.read", void 0, now, void 0, streamId);
+    const recipients = new Set(mails.map((mail) => mail.to));
+    const ids = new Set(mails.map((mail) => mail.id));
+    for (const wake of this.wakes().filter((candidate) => recipients.has(candidate.agent) && (candidate.status === "queued" || candidate.status === "claimed"))) {
+      for (const trigger of this.wakeTriggers(wake.id).filter((candidate) => candidate.status === "pending")) {
+        const mailId = mailIdFromTrigger(trigger.triggerRef);
+        if (mailId && ids.has(mailId)) {
+          const next = { ...trigger, status: "resolved", resolvedAt: now };
+          this.#recordProjection("wake_triggers", next, "supervisor", "wake_trigger.resolved", wake.id, now);
+        }
+      }
+      if (this.wakeTriggers(wake.id).every((trigger) => trigger.status === "resolved"))
+        this.#cancelWakeProjection(wake, now);
+    }
+  }
+  #normalizeSchedule(value, actor, binding) {
+    this.#assertAutomaticTarget(value);
+    if (actor !== "supervisor" && actor !== value.agent)
+      throw new Error("schedule may only be set by its agent or supervisor");
+    if (value.setBy !== actor)
+      throw new Error("schedule setBy does not match actor");
+    const parsed = Date.parse(value.nextWakeAt);
+    if (!value.id.trim() || !value.agent.trim() || !value.reason.trim() || !Number.isFinite(parsed))
+      throw new Error("schedule requires an id, agent, valid time, and reason");
+    const normalized = { ...value, nextWakeAt: new Date(parsed).toISOString() };
+    if (normalized.status !== "pending" || normalized.resolvedAt !== null)
+      throw new Error("new schedule must be pending");
+    if (binding && normalized.goalId !== binding.goalId)
+      throw new Error("handoff schedule does not match the Turn Goal commitment");
+    if (normalized.targetKind === "goal") {
+      const goal = this.#getGoal(normalized.goalId);
+      if (!goal || goal.owner !== normalized.agent || goal.phase !== "active")
+        throw new Error("schedule Goal target is inactive or owned by another Agent");
+    }
+    return normalized;
+  }
+  #assertAutomaticTarget(value) {
+    if (value.targetKind === "goal") {
+      if (!value.goalId || value.specialistRole !== null)
+        throw new Error("invalid Goal automatic target");
+      return;
+    }
+    if (value.targetKind !== "specialist" || value.goalId !== null || !value.specialistRole || !["verifier", "audit"].includes(value.specialistRole))
+      throw new Error("invalid Specialist automatic target");
+  }
+  #assertTurnShape(value) {
+    if (!["user_message", "wake"].includes(value.triggerKind) || value.goalId === null !== (value.goalRevision === null) || value.goalRevision !== null && (!Number.isInteger(value.goalRevision) || value.goalRevision < 0))
+      throw new Error("invalid Turn trigger or Goal commitment");
+  }
+  #replayProjection(projection, snapshot, event) {
+    if (projection === "turns")
+      this.#assertReplayTurn(snapshot, event);
+    else if (projection === "wakes")
+      this.#assertReplayWake(snapshot, event);
+    this.#applyProjection(projection, snapshot, event.seq);
+  }
+  #assertReplayTurn(turn, event) {
+    this.#assertTurnShape(turn);
+    const thread = this.thread(turn.threadId);
+    if (!thread)
+      throw new Error(`turn event ${event.seq} has no Thread`);
+    const current = this.turn(turn.id);
+    if (!current) {
+      if (event.type !== "turn.started" || turn.status !== "in_progress" || turn.attempt !== 1 || turn.runnerPid !== null)
+        throw new Error(`turn event ${event.seq} has an invalid initial state`);
+      if (event.actor === "human") {
+        if (turn.triggerKind !== "user_message" || thread.role !== "ceo")
+          throw new Error(`turn event ${event.seq} has invalid user ownership`);
+        if (turn.goalId) {
+          const goal = this.#getGoal(turn.goalId);
+          if (!goal || goal.parentId !== null || goal.owner !== thread.agent || goal.phase !== "active" || goal.revision !== turn.goalRevision)
+            throw new Error(`turn event ${event.seq} has an invalid direct Goal commitment`);
+        }
+      } else {
+        if (event.actor !== "supervisor" || !this.wakes().some((wake) => wake.status === "claimed" && wake.agent === thread.agent && sameWakeTurnTarget(wake, turn, thread)))
+          throw new Error(`turn event ${event.seq} bypasses Wake admission`);
+        this.#assertCurrentAutomaticTurn(turn, thread, event.seq);
+      }
+      return;
+    }
+    if (current.threadId !== turn.threadId || current.triggerKind !== turn.triggerKind || current.startedAt !== turn.startedAt || current.runnerProfileId !== turn.runnerProfileId)
+      throw new Error(`turn event ${event.seq} changes Turn identity`);
+    const sameProcessState = sameTurnExceptRunnerPid(current, turn);
+    if (event.type === "turn.process_attached") {
+      if (event.actor !== "supervisor" || current.status !== "in_progress" || current.runnerPid !== null || !Number.isInteger(turn.runnerPid) || turn.runnerPid <= 0 || !sameProcessState)
+        throw new Error(`turn event ${event.seq} has an invalid Runner process attachment`);
+      return;
+    }
+    if (event.type === "turn.process_released") {
+      if (event.actor !== "supervisor" || current.runnerPid === null || turn.runnerPid !== null || !sameProcessState)
+        throw new Error(`turn event ${event.seq} has an invalid Runner process release`);
+      return;
+    }
+    if (current.status !== "in_progress")
+      throw new Error(`turn event ${event.seq} changes a terminal Turn`);
+    if (current.runnerPid !== turn.runnerPid)
+      throw new Error(`turn event ${event.seq} changes Runner process ownership outside attach/release`);
+    const commitsGoal = event.type === "turn.goal_committed" && event.actor === "supervisor" && current.goalId === null && turn.goalId !== null;
+    if (!commitsGoal && (current.goalId !== turn.goalId || current.goalRevision !== turn.goalRevision))
+      throw new Error(`turn event ${event.seq} changes Goal commitment`);
+    if (commitsGoal) {
+      const goal = this.#getGoal(turn.goalId);
+      if (!goal || goal.owner !== thread.agent || goal.phase !== "active" || goal.revision !== turn.goalRevision || thread.role === "ceo" && goal.parentId !== null || thread.role === "child" && goal.parentId === null || thread.role === "verifier" || thread.role === "audit")
+        throw new Error(`turn event ${event.seq} has an invalid Goal commitment`);
+    }
+    if (turn.status === "in_progress") {
+      if (!commitsGoal && event.type !== "turn.in_progress" || turn.attempt !== current.attempt && turn.attempt !== current.attempt + 1)
+        throw new Error(`turn event ${event.seq} has an invalid retry transition`);
+    } else {
+      if (event.type !== `turn.${turn.status}` || turn.attempt !== current.attempt || turn.runnerPid !== current.runnerPid)
+        throw new Error(`turn event ${event.seq} has an invalid terminal transition`);
+      if (turn.status === "completed" && turn.goalId !== null)
+        this.#assertReplayGoalCompletion(turn, event);
+    }
+  }
+  #assertReplayGoalCompletion(turn, event) {
+    if (turn.goalId === null || turn.goalRevision === null)
+      throw new Error(`turn event ${event.seq} has no Goal commitment`);
+    const items = this.turnItems(turn.id);
+    const responses = items.filter((item) => item.type === "assistant_message" && item.status === "completed" && typeof item.data.text === "string" && Boolean(item.data.text.trim()));
+    const handoffItem = items.findLast((item) => item.type === "handoff" && item.status === "completed");
+    const responseRow = this.db.prepare("SELECT data FROM events WHERE stream_id=? AND type='response.committed' AND seq<? ORDER BY seq DESC LIMIT 1").get(`turn:${turn.id}`, event.seq);
+    const handoffRow = this.db.prepare("SELECT data FROM events WHERE stream_id=? AND type='handoff.recorded' AND seq<? ORDER BY seq DESC LIMIT 1").get(`turn:${turn.id}`, event.seq);
+    if (!responseRow || !handoffRow || !handoffItem)
+      throw new Error(`turn event ${event.seq} completes a Goal without response and Handoff`);
+    const response = JSON.parse(responseRow.data);
+    const handoff = JSON.parse(handoffRow.data);
+    const responseItem = responses.find((item) => item.id === response.messageItemId);
+    if (!responseItem || responseItem.data.text !== response.text || !isDeepStrictEqual(handoffItem.data, handoff))
+      throw new Error(`turn event ${event.seq} has mismatched response or Handoff facts`);
+    assertHandoff(handoff);
+    const record = this.workRecord(turn.goalId);
+    if (handoff.goalId !== turn.goalId || handoff.goalRevision !== turn.goalRevision || record?.recordRevision !== handoff.recordRevision)
+      throw new Error(`turn event ${event.seq} has a Handoff for another Goal or Work Record`);
+    for (const seq of handoff.evidence)
+      if (seq >= event.seq || !this.db.prepare("SELECT 1 FROM events WHERE seq=?").get(seq))
+        throw new Error(`turn event ${event.seq} has invalid Handoff evidence`);
+  }
+  #assertReplayWake(wake, event) {
+    this.#assertAutomaticTarget(wake);
+    const current = this.wake(wake.id);
+    if (!current) {
+      if (event.type !== "wake.enqueued" || wake.status !== "queued" || wake.attempt !== 0 || wake.claimedAt || wake.consumedAt || wake.turnId)
+        throw new Error(`wake event ${event.seq} has an invalid initial state`);
+      if (wake.targetKind === "goal") {
+        const goal = this.#getGoal(wake.goalId);
+        if (!goal || goal.phase !== "active" || goal.owner !== wake.agent)
+          throw new Error(`wake event ${event.seq} has an invalid Goal target`);
+      }
+      return;
+    }
+    if (current.targetKind !== wake.targetKind || current.agent !== wake.agent || current.goalId !== wake.goalId || current.specialistRole !== wake.specialistRole || current.triggerRef !== wake.triggerRef || current.enqueuedSeq !== wake.enqueuedSeq)
+      throw new Error(`wake event ${event.seq} changes Wake identity`);
+    if (current.status === "consumed" || current.status === "cancelled")
+      throw new Error(`wake event ${event.seq} changes a terminal Wake`);
+    if (wake.status === "claimed") {
+      if (event.type !== "wake.claimed" || current.status !== "queued" || wake.attempt !== current.attempt + 1 || !wake.claimedAt || wake.consumedAt !== null || wake.turnId !== null)
+        throw new Error(`wake event ${event.seq} has an invalid claim transition`);
+    } else if (wake.status === "queued") {
+      if (event.type !== "wake.released" || current.status !== "claimed" || wake.attempt !== current.attempt || wake.claimedAt !== null || wake.consumedAt !== null || wake.turnId !== null)
+        throw new Error(`wake event ${event.seq} has an invalid release transition`);
+    } else if (wake.status === "cancelled") {
+      if (event.type !== "wake.cancelled" || wake.attempt !== current.attempt || wake.claimedAt !== current.claimedAt || wake.consumedAt === null || wake.turnId !== null)
+        throw new Error(`wake event ${event.seq} has an invalid cancel transition`);
+    } else {
+      if (event.type !== "wake.consumed" || current.status !== "claimed" || wake.attempt !== current.attempt || wake.claimedAt !== current.claimedAt || wake.consumedAt === null || !wake.turnId)
+        throw new Error(`wake event ${event.seq} has an invalid consume transition`);
+      const turn = this.turn(wake.turnId);
+      const thread = turn ? this.thread(turn.threadId) : null;
+      if (!turn || !thread || thread.agent !== wake.agent || !sameWakeTurnTarget(wake, turn, thread))
+        throw new Error(`wake event ${event.seq} does not match its Turn`);
+    }
+  }
+  #assertCurrentAutomaticTurn(turn, thread, seq) {
+    if (turn.triggerKind !== "wake")
+      throw new Error(seq ? `turn event ${seq} is not Wake-triggered` : "automatic Turn must be Wake-triggered");
+    if (turn.goalId !== null) {
+      const goal = this.#getGoal(turn.goalId);
+      if (thread.role !== "ceo" && thread.role !== "child" || !goal || goal.phase !== "active" || goal.owner !== thread.agent || goal.revision !== turn.goalRevision || thread.role === "ceo" && goal.parentId !== null || thread.role === "child" && goal.parentId === null)
+        throw new Error(seq ? `turn event ${seq} has an invalid current Goal commitment for its Thread role` : "Wake Turn must commit to the current active Goal revision allowed by its Thread role");
+      return;
+    }
+    if (thread.role !== "verifier" && thread.role !== "audit")
+      throw new Error(seq ? `turn event ${seq} has an uncommitted Goal-owning Agent` : "only Specialists may start an uncommitted Wake Turn");
+  }
+  #admitSchedule(value, actor, wakeId, ts = this.#now(), streamId, binding, allowExisting = true) {
+    const normalized = this.#normalizeSchedule(value, actor, binding);
+    const existing = this.db.prepare("SELECT * FROM schedule WHERE id=?").get(normalized.id);
+    if (existing) {
+      const current = mapSchedule(existing);
+      if (!allowExisting || !isDeepStrictEqual(current, normalized))
+        throw new Error("schedule id was reused with different content");
+      const row = this.db.prepare("SELECT * FROM events WHERE type='schedule.put' AND json_extract(data,'$.snapshot.id')=? ORDER BY seq LIMIT 1").get(normalized.id);
+      if (!row)
+        throw new Error("schedule projection has no source event");
+      return mapEvent(row);
+    }
+    this.#supersedeScheduleRoute(normalized.agent, normalized.goalId ?? null, normalized.id, ts);
+    return this.#recordProjection("schedule", normalized, actor, "schedule.put", wakeId, ts, void 0, streamId);
+  }
+  #supersedeScheduleRoute(agent, goalId, exceptId, now) {
+    const rows = goalId === null ? this.db.prepare("SELECT * FROM schedule WHERE agent=? AND goal_id IS NULL AND id<>? AND status='pending' ORDER BY id").all(agent, exceptId) : this.db.prepare("SELECT * FROM schedule WHERE agent=? AND goal_id=? AND id<>? AND status='pending' ORDER BY id").all(agent, goalId, exceptId);
+    return rows.map((row) => {
+      const current = mapSchedule(row);
+      const next = { ...current, status: "superseded", resolvedAt: now };
+      this.#recordProjection("schedule", next, "supervisor", "schedule.superseded", void 0, now);
+      return next;
+    });
+  }
+  #supersedeSchedulesForGoal(goalId, now) {
+    const rows = this.db.prepare("SELECT * FROM schedule WHERE goal_id=? AND status='pending' ORDER BY id").all(goalId);
+    return rows.map((row) => {
+      const current = mapSchedule(row);
+      const next = { ...current, status: "superseded", resolvedAt: now };
+      this.#recordProjection("schedule", next, "supervisor", "schedule.superseded", void 0, now);
+      return next;
+    });
+  }
+  #cancelWakesForGoal(goalId, now) {
+    return this.wakes().filter((wake) => wake.goalId === goalId && (wake.status === "queued" || wake.status === "claimed")).map((wake) => this.#cancelWakeProjection(wake, now));
+  }
+  #repairOpenTurnItems(turnId, reason, now, actor) {
+    const streamId = `turn:${turnId}`;
+    const open = this.turnItems(turnId).filter((item) => item.status === "in_progress");
+    const repaired = [];
+    let ordinal = this.turnItems(turnId).length + 1;
+    for (const item of open) {
+      const failed = { ...item, status: "failed", completedAt: now };
+      this.#recordProjection("turn_items", failed, actor, `item.${item.type}.failed`, void 0, now, void 0, streamId);
+      repaired.push(failed);
+      if (item.type === "tool_call") {
+        const callId = String(item.data.callId ?? item.id);
+        const result = { id: `repair:${turnId}:${item.ordinal}`, turnId, ordinal: ordinal++, type: "tool_result", status: "completed", data: { callId, result: { outcome: "unknown", synthetic: true, reason } }, createdAt: now, completedAt: now };
+        this.#admitTurnItem(result, actor, streamId);
+        this.#insertEvent({ streamId, ts: now, actor, type: "tool.completed", data: { callId, messageId: `repair:${callId}`, result: { outcome: "unknown", synthetic: true, reason }, isError: true } });
+        repaired.push(result);
+      }
+    }
+    return repaired;
+  }
+  #project(projection, snapshot, actor, type, wakeId, ts, streamId) {
+    return this.#transaction(() => this.#recordProjection(projection, snapshot, actor, type, wakeId, ts, void 0, streamId));
+  }
+  #recordProjection(projection, snapshot, actor, type, wakeId, ts, expectedSeq, streamId) {
+    const event = this.#insertEvent({ streamId: streamId ?? (wakeId ? wakeStream(wakeId) : controlStream(projection)), ts: ts ?? this.#now(), actor, type, data: { snapshot }, ignorable: true }, expectedSeq, projection);
+    this.#faultInjector?.("after_event_before_projection");
+    this.#applyProjection(projection, snapshot, event.seq);
+    return event;
+  }
+  #insertEvent(input, expectedSeq, projection) {
+    if (!input.streamId.trim() || !input.actor.trim() || !input.type.trim())
+      throw new Error("event streamId, actor and type are required");
+    const streamSeq = Number(this.db.prepare("SELECT COALESCE(MAX(stream_seq),0)+1 AS next FROM events WHERE stream_id=?").get(input.streamId).next);
+    const result = expectedSeq === void 0 ? this.db.prepare("INSERT INTO events(stream_id,stream_seq,ts,actor,type,data,projection_name,ignorable) VALUES (?,?,?,?,?,json(?),?,?)").run(input.streamId, streamSeq, input.ts, input.actor, input.type, JSON.stringify(input.data), projection ?? null, input.ignorable === true ? 1 : null) : this.db.prepare("INSERT INTO events(seq,stream_id,stream_seq,ts,actor,type,data,projection_name,ignorable) VALUES (?,?,?,?,?,?,json(?),?,?)").run(expectedSeq, input.streamId, streamSeq, input.ts, input.actor, input.type, JSON.stringify(input.data), projection ?? null, input.ignorable === true ? 1 : null);
+    return { ...input, seq: Number(result.lastInsertRowid), streamSeq };
+  }
+  #nextEventSeq() {
+    const row = this.db.prepare("SELECT seq FROM sqlite_sequence WHERE name='events'").get();
+    return Number(row?.seq ?? 0) + 1;
+  }
+  #applyProjection(projection, raw, sourceSeq) {
+    if (projection === "threads") {
+      const v = raw;
+      this.db.prepare(`INSERT INTO threads VALUES (?,?,?,?,?,?) ON CONFLICT(id) DO UPDATE SET agent=excluded.agent,role=excluded.role,parent_thread_id=excluded.parent_thread_id,updated_at=excluded.updated_at`).run(v.id, v.agent, v.role, v.parentThreadId, v.createdAt, v.updatedAt);
+    } else if (projection === "turns") {
+      const v = raw;
+      this.db.prepare(`INSERT INTO turns VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?) ON CONFLICT(id) DO UPDATE SET goal_id=excluded.goal_id,goal_revision=excluded.goal_revision,status=excluded.status,attempt=excluded.attempt,error=excluded.error,ended_at=excluded.ended_at,lease_until=excluded.lease_until,lease_token=excluded.lease_token,runner_pid=excluded.runner_pid`).run(v.id, v.threadId, v.triggerKind, v.goalId, v.goalRevision, v.status, v.attempt, v.error === null ? null : JSON.stringify(v.error), v.startedAt, v.endedAt, v.leaseUntil, v.leaseToken, v.runnerPid, v.runnerProfileId ?? null);
+      this.db.prepare("UPDATE threads SET updated_at=CASE WHEN updated_at<? THEN ? ELSE updated_at END WHERE id=?").run(v.endedAt ?? v.startedAt, v.endedAt ?? v.startedAt, v.threadId);
+    } else if (projection === "turn_items") {
+      const v = raw;
+      this.db.prepare(`INSERT INTO turn_items VALUES (?,?,?,?,?,json(?),?,?) ON CONFLICT(id) DO UPDATE SET status=excluded.status,data=excluded.data,completed_at=excluded.completed_at`).run(v.id, v.turnId, v.ordinal, v.type, v.status, JSON.stringify(v.data), v.createdAt, v.completedAt);
+      this.db.prepare("UPDATE threads SET updated_at=CASE WHEN updated_at<? THEN ? ELSE updated_at END WHERE id=(SELECT thread_id FROM turns WHERE id=?)").run(v.completedAt ?? v.createdAt, v.completedAt ?? v.createdAt, v.turnId);
+    } else if (projection === "goals") {
+      const v = normalizeGoal(raw);
+      this.db.prepare(`INSERT INTO goals VALUES (?,?,?,?,?,?,?,?) ON CONFLICT(id) DO UPDATE SET parent_id=excluded.parent_id,objective=excluded.objective,observation_method=excluded.observation_method,verification_method=excluded.verification_method,owner=excluded.owner,phase=excluded.phase,revision=excluded.revision`).run(v.id, v.parentId, v.objective, v.observationMethod, v.verificationMethod ?? null, v.owner, v.phase, v.revision);
+    } else if (projection === "work_records") {
+      const v = raw;
+      this.db.prepare(`INSERT INTO work_records VALUES (?,?,?,?,?,?,?,?,?,?,?) ON CONFLICT(goal_id) DO UPDATE SET record_revision=excluded.record_revision,goal_revision=excluded.goal_revision,content=excluded.content,updated_by=excluded.updated_by,updated_in_turn=excluded.updated_in_turn,source_wake_id=excluded.source_wake_id,updated_at=excluded.updated_at,reason=excluded.reason,evidence=excluded.evidence,last_event_seq=excluded.last_event_seq`).run(v.goalId, v.recordRevision, v.goalRevision, v.content, v.updatedBy, v.updatedInTurn, v.sourceWakeId, v.updatedAt, v.reason, JSON.stringify(v.evidence), v.lastEventSeq || sourceSeq);
+    } else if (projection === "schedule") {
+      const v = raw;
+      this.db.prepare(`INSERT INTO schedule VALUES (?,?,?,?,?,?,?,?,?,?) ON CONFLICT(id) DO UPDATE SET target_kind=excluded.target_kind,agent=excluded.agent,specialist_role=excluded.specialist_role,next_wake_at=excluded.next_wake_at,reason=excluded.reason,set_by=excluded.set_by,status=excluded.status,resolved_at=excluded.resolved_at,goal_id=excluded.goal_id`).run(v.id, v.targetKind, v.agent, v.specialistRole, v.nextWakeAt, v.reason, v.setBy, v.status, v.resolvedAt, v.goalId);
+    } else if (projection === "wakes") {
+      const v = raw;
+      this.db.prepare(`INSERT INTO wakes VALUES (?,?,?,?,?,?,?,?,?,?,?,?) ON CONFLICT(id) DO UPDATE SET target_kind=excluded.target_kind,agent=excluded.agent,specialist_role=excluded.specialist_role,trigger_ref=excluded.trigger_ref,status=excluded.status,attempt=excluded.attempt,enqueued_seq=excluded.enqueued_seq,claimed_at=excluded.claimed_at,consumed_at=excluded.consumed_at,turn_id=excluded.turn_id,goal_id=excluded.goal_id`).run(v.id, v.targetKind, v.agent, v.specialistRole, v.triggerRef, v.status, v.attempt, v.enqueuedSeq || sourceSeq, v.claimedAt, v.consumedAt, v.turnId, v.goalId);
+    } else if (projection === "wake_triggers") {
+      const v = raw;
+      this.db.prepare(`INSERT INTO wake_triggers VALUES (?,?,?,?,?,?,?) ON CONFLICT(wake_id,trigger_ref) DO UPDATE SET status=excluded.status,resolved_at=excluded.resolved_at`).run(v.wakeId, v.agent, v.triggerRef, v.source, v.status, v.addedAt, v.resolvedAt);
+    } else if (projection === "mailbox") {
+      const v = raw;
+      this.db.prepare(`INSERT INTO mailbox VALUES (?,?,?,?,?,?,?,json(?),?) ON CONFLICT(id) DO UPDATE SET route_kind=excluded.route_kind,to_agent=excluded.to_agent,from_agent=excluded.from_agent,specialist_role=excluded.specialist_role,level=excluded.level,goal_id=excluded.goal_id,body=excluded.body,read_at=excluded.read_at`).run(v.id, v.routeKind, v.to, v.from, v.specialistRole, v.level, v.goalId, JSON.stringify(v.body), v.readAt);
+    }
+  }
+  #transaction(fn) {
+    this.db.exec("BEGIN IMMEDIATE");
+    try {
+      const result = fn();
+      this.db.exec("COMMIT");
+      return result;
+    } catch (error) {
+      this.db.exec("ROLLBACK");
+      throw error;
+    }
+  }
+  #now() {
+    return this.#clock.now().toISOString();
+  }
+};
+function mapEvent(r) {
+  return { seq: Number(r.seq), streamId: String(r.stream_id), streamSeq: Number(r.stream_seq), ts: String(r.ts), actor: String(r.actor), type: String(r.type), data: JSON.parse(String(r.data)), ...Number(r.ignorable) === 1 ? { ignorable: true } : {} };
+}
+function mapThread(r) {
+  return { id: String(r.id), agent: String(r.agent), role: String(r.role), parentThreadId: r.parent_thread_id === null ? null : String(r.parent_thread_id), createdAt: String(r.created_at), updatedAt: String(r.updated_at) };
+}
+function mapTurn(r) {
+  return { id: String(r.id), threadId: String(r.thread_id), triggerKind: String(r.trigger_kind), goalId: r.goal_id === null ? null : String(r.goal_id), goalRevision: r.goal_revision === null ? null : Number(r.goal_revision), status: String(r.status), attempt: Number(r.attempt), error: r.error === null ? null : JSON.parse(String(r.error)), startedAt: String(r.started_at), endedAt: r.ended_at === null ? null : String(r.ended_at), leaseUntil: r.lease_until === null ? null : String(r.lease_until), leaseToken: r.lease_token === null ? null : String(r.lease_token), runnerPid: r.runner_pid === null ? null : Number(r.runner_pid), ...r.runner_profile_id === null || r.runner_profile_id === void 0 ? {} : { runnerProfileId: String(r.runner_profile_id) } };
+}
+function mapTurnItem(r) {
+  return { id: String(r.id), turnId: String(r.turn_id), ordinal: Number(r.ordinal), type: String(r.type), status: String(r.status), data: JSON.parse(String(r.data)), createdAt: String(r.created_at), completedAt: r.completed_at === null ? null : String(r.completed_at) };
+}
+function normalizeGoal(goal) {
+  return { ...goal, observationMethod: goal.observationMethod ?? null, verificationMethod: goal.verificationMethod === void 0 ? goal.observationMethod ?? null : goal.verificationMethod };
+}
+function mapGoal(r) {
+  return { id: String(r.id), parentId: r.parent_id === null ? null : String(r.parent_id), objective: String(r.objective), observationMethod: r.observation_method === null || r.observation_method === void 0 ? null : String(r.observation_method), verificationMethod: r.verification_method === null || r.verification_method === void 0 ? null : String(r.verification_method), owner: String(r.owner), phase: String(r.phase), revision: Number(r.revision) };
+}
+function mapWorkRecord(r) {
+  return { goalId: String(r.goal_id), recordRevision: Number(r.record_revision), goalRevision: Number(r.goal_revision), content: String(r.content), updatedBy: String(r.updated_by), updatedInTurn: String(r.updated_in_turn), sourceWakeId: r.source_wake_id === null ? null : String(r.source_wake_id), updatedAt: String(r.updated_at), reason: String(r.reason), evidence: JSON.parse(String(r.evidence)), lastEventSeq: Number(r.last_event_seq) };
+}
+function mapWorkRecordEvent(event) {
+  const data = event.data;
+  if (!data.snapshot)
+    throw new Error(`work record event ${event.seq} has no snapshot`);
+  return { ...data.snapshot, lastEventSeq: event.seq };
+}
+function initialWorkRecord() {
+  return "# Current State\n\nGoal created. Work has not started.\n\n# Observations\n\n# Work Completed\n\n# Decisions\n\n# Blockers\n\n# Next Steps\n";
+}
+function goalOperation(previous, next) {
+  if (!previous)
+    return "create";
+  if (previous.phase !== next.phase) {
+    if (next.phase === "paused")
+      return "pause";
+    if (next.phase === "active")
+      return "resume";
+    if (next.phase === "blocked")
+      return "block";
+    if (next.phase === "complete")
+      return "complete";
+  }
+  return previous.owner !== next.owner ? "reassign" : "revise";
+}
+function defaultGoalReason(operation) {
+  return `Goal ${operation}`;
+}
+function withoutSourceTurn(value) {
+  const { sourceTurnId: _, ...semantic } = value;
+  return semantic;
+}
+function projectionForEvent(type) {
+  if (type === "thread.put")
+    return "threads";
+  if (type.startsWith("turn."))
+    return "turns";
+  if (type.startsWith("item."))
+    return "turn_items";
+  if (type === "goal.changed")
+    return "goals";
+  if (type.startsWith("schedule."))
+    return "schedule";
+  if (type.startsWith("wake_trigger."))
+    return "wake_triggers";
+  if (type.startsWith("wake."))
+    return "wakes";
+  if (type.startsWith("mail."))
+    return "mailbox";
+  if (type === "work_record.created" || type === "work_record.updated")
+    return "work_records";
+  return null;
+}
+function lineDiff(from, to) {
+  const before = from.split("\n");
+  const after = to.split("\n");
+  const lines = [];
+  for (let index = 0; index < Math.max(before.length, after.length); index += 1) {
+    if (before[index] === after[index]) {
+      if (before[index] !== void 0)
+        lines.push(` ${before[index]}`);
+      continue;
+    }
+    if (before[index] !== void 0)
+      lines.push(`-${before[index]}`);
+    if (after[index] !== void 0)
+      lines.push(`+${after[index]}`);
+  }
+  return lines.join("\n");
+}
+function mapSchedule(r) {
+  return { id: String(r.id), targetKind: String(r.target_kind), agent: String(r.agent), specialistRole: r.specialist_role === null ? null : String(r.specialist_role), goalId: r.goal_id === null ? null : String(r.goal_id), nextWakeAt: String(r.next_wake_at), reason: String(r.reason), setBy: String(r.set_by), status: String(r.status), resolvedAt: r.resolved_at === null ? null : String(r.resolved_at) };
+}
+function mapWake(r) {
+  return { id: String(r.id), targetKind: String(r.target_kind), agent: String(r.agent), specialistRole: r.specialist_role === null ? null : String(r.specialist_role), goalId: r.goal_id === null ? null : String(r.goal_id), triggerRef: String(r.trigger_ref), status: String(r.status), attempt: Number(r.attempt), enqueuedSeq: Number(r.enqueued_seq), claimedAt: r.claimed_at === null ? null : String(r.claimed_at), consumedAt: r.consumed_at === null ? null : String(r.consumed_at), turnId: r.turn_id === null ? null : String(r.turn_id) };
+}
+function sameTurnExceptRunnerPid(left, right) {
+  const { runnerPid: _left, ...leftRest } = left;
+  const { runnerPid: _right, ...rightRest } = right;
+  return isDeepStrictEqual(leftRest, rightRest);
+}
+function sameWakeTurnTarget(wake, turn, thread) {
+  if (turn.triggerKind !== "wake")
+    return false;
+  if (wake.targetKind === "goal")
+    return wake.goalId === turn.goalId;
+  return turn.goalId === null && thread.role === wake.specialistRole;
+}
+function mapWakeTrigger(r) {
+  return { wakeId: String(r.wake_id), agent: String(r.agent), triggerRef: String(r.trigger_ref), source: String(r.source), status: String(r.status), addedAt: String(r.added_at), resolvedAt: r.resolved_at === null ? null : String(r.resolved_at) };
+}
+function mapMail(r) {
+  return { id: String(r.id), routeKind: String(r.route_kind), to: String(r.to_agent), from: String(r.from_agent), specialistRole: r.specialist_role === null ? null : String(r.specialist_role), level: String(r.level), goalId: r.goal_id === null ? null : String(r.goal_id), body: JSON.parse(String(r.body)), readAt: r.read_at === null ? null : String(r.read_at) };
+}
+function mailIdFromTrigger(trigger) {
+  if (!trigger.startsWith("mail:"))
+    return null;
+  return trigger.slice("mail:".length).split("@redelivery:")[0] || null;
+}
+
+export {
+  SQLITE_SCHEMA_VERSION,
+  SqliteLedger
+};