@goah/cli 0.11.4 → 0.13.0

package/node_modules/goah-ledger-sqlite/dist/index.js

@@ -1,6 +1,49 @@
 import { DatabaseSync } from "node:sqlite";
-import { assertActionRequest, assertActionTransition, assertGoalSnapshot, assertGoalTransition, controlStream, goalStream, wakeStream, workRecordStream, } from "goah-ledger-contract";
-export const SQLITE_SCHEMA_VERSION = 9;
+import { isDeepStrictEqual } from "node:util";
+import { assertHandoff, assertGoalSnapshot, assertGoalTransition, controlStream, goalStream, goalRoute, goalExecutionBinding, wakeStream, workRecordStream, } from "goah-ledger-contract";
+export const SQLITE_SCHEMA_VERSION = 24;
+const createThreads = `CREATE TABLE IF NOT EXISTS threads (
+  id TEXT PRIMARY KEY,
+  agent TEXT NOT NULL,
+  parent_thread_id TEXT REFERENCES threads(id),
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  UNIQUE(agent)
+) STRICT;`;
+const createTurns = `CREATE TABLE IF NOT EXISTS turns (
+  id TEXT PRIMARY KEY,
+  thread_id TEXT NOT NULL REFERENCES threads(id) ON DELETE CASCADE,
+  source TEXT NOT NULL CHECK(source IN ('human','goal','system')),
+  binding_kind TEXT NOT NULL CHECK(binding_kind IN ('human','goal','specialist')),
+  specialist_role TEXT CHECK(specialist_role IS NULL OR specialist_role IN ('verifier','audit')),
+  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,
+  runner_profile_id TEXT,
+  CHECK((goal_id IS NULL) = (goal_revision IS NULL)),
+  CHECK((binding_kind='human' AND goal_id IS NULL AND specialist_role IS NULL) OR (binding_kind='goal' AND goal_id IS NOT NULL AND specialist_role IS NULL) OR (binding_kind='specialist' AND goal_id IS NULL AND specialist_role IS NOT NULL)),
+  CHECK((binding_kind='human' AND source='human') OR (binding_kind='goal' AND source IN ('human','goal')) OR (binding_kind='specialist' AND source='system')),
+  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 AND runner_pid IS NULL))
+) STRICT;`;
+const 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;`;
 const createGoals = `CREATE TABLE IF NOT EXISTS goals (
   id TEXT PRIMARY KEY,
   parent_id TEXT REFERENCES goals(id),
@@ -18,7 +61,7 @@ const createWorkRecords = `CREATE TABLE IF NOT EXISTS work_records (
   content TEXT NOT NULL CHECK(length(trim(content)) > 0),
   updated_by TEXT NOT NULL,
   updated_in_turn TEXT NOT NULL,
-  updated_in_wake TEXT,
+  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)),
@@ -26,44 +69,45 @@ const createWorkRecords = `CREATE TABLE IF NOT EXISTS work_records (
 ) STRICT;`;
 const createWakes = `CREATE TABLE IF NOT EXISTS wakes (
   id TEXT PRIMARY KEY,
+  binding_kind TEXT NOT NULL CHECK(binding_kind IN ('human','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','leased','running','done','abnormal','merge_blocked')),
-  lease_until TEXT,
+  status TEXT NOT NULL CHECK(status IN ('queued','claimed','consumed','cancelled')),
   attempt INTEGER NOT NULL CHECK(attempt >= 0),
-  started_at TEXT,
-  ended_at TEXT,
   enqueued_seq INTEGER NOT NULL CHECK(enqueued_seq > 0),
-  lease_token TEXT,
-  runner_pid INTEGER,
+  claimed_at TEXT,
+  consumed_at TEXT,
+  turn_id TEXT REFERENCES turns(id),
+  goal_id TEXT REFERENCES goals(id),
   UNIQUE(agent, trigger_ref),
-  CHECK((status IN ('leased','running') AND lease_until IS NOT NULL AND lease_token IS NOT NULL) OR status NOT IN ('leased','running')),
-  CHECK((status IN ('done','abnormal','merge_blocked') AND ended_at IS NOT NULL) OR status NOT IN ('done','abnormal','merge_blocked'))
+  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((binding_kind='human' AND agent='ceo' AND goal_id IS NULL AND specialist_role IS NULL) OR (binding_kind='goal' AND goal_id IS NOT NULL AND specialist_role IS NULL) OR (binding_kind='specialist' AND goal_id IS NULL AND specialist_role IS NOT NULL))
 ) STRICT;`;
-const createActions = `CREATE TABLE IF NOT EXISTS actions (
-  id TEXT PRIMARY KEY,
+const createWakeTriggers = `CREATE TABLE IF NOT EXISTS wake_triggers (
+  wake_id TEXT NOT NULL REFERENCES wakes(id) ON DELETE CASCADE,
   agent TEXT NOT NULL,
-  kind TEXT NOT NULL,
-  connector TEXT NOT NULL,
-  payload TEXT NOT NULL CHECK(json_valid(payload)),
-  reason TEXT NOT NULL CHECK(length(trim(reason)) > 0),
-  evidence TEXT NOT NULL CHECK(json_valid(evidence) AND json_array_length(evidence) > 0),
-  gated INTEGER NOT NULL CHECK(gated IN (0,1)),
-  status TEXT NOT NULL CHECK(status IN ('requested','approved','dispatching','confirmed','failed','unknown')),
-  reconciled_at TEXT,
-  external_ref TEXT,
-  audit_advice TEXT CHECK(audit_advice IS NULL OR json_valid(audit_advice)),
-  advice_acked INTEGER NOT NULL CHECK(advice_acked IN (0,1)),
-  CHECK(reconciled_at IS NULL OR status IN ('confirmed','failed'))
+  trigger_ref TEXT NOT NULL,
+  source TEXT NOT NULL CHECK(source IN ('human','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;`;
 const indexesAndTriggers = `
-CREATE UNIQUE INDEX IF NOT EXISTS wakes_one_active_agent ON wakes(agent) WHERE status IN ('leased','running');
+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 schedule_due ON schedule(next_wake_at);
+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 INDEX IF NOT EXISTS events_coalesced_trigger ON events(json_extract(data,'$.triggerRef'), stream_id) WHERE type='wake.trigger_coalesced';
-CREATE INDEX IF NOT EXISTS actions_agent_status ON actions(agent, status);
 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
@@ -75,20 +119,20 @@ BEGIN INSERT INTO events_fts(rowid,actor,type,data) VALUES (new.seq,new.actor,ne
 
 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 ('leased','abnormal')) OR
-  (OLD.status = 'leased' AND NEW.status IN ('queued','running','abnormal')) OR
-  (OLD.status = 'running' AND NEW.status IN ('done','abnormal','merge_blocked'))
+  (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 actions_valid_transition BEFORE UPDATE OF status ON actions
+CREATE TRIGGER IF NOT EXISTS schedule_valid_transition BEFORE UPDATE OF status ON schedule
 WHEN OLD.status <> NEW.status AND NOT (
-  (OLD.status = 'requested' AND NEW.status IN ('approved','failed')) OR
-  (OLD.status = 'approved' AND NEW.status IN ('dispatching','failed')) OR
-  (OLD.status = 'dispatching' AND NEW.status IN ('confirmed','failed','unknown')) OR
-  (OLD.status = 'unknown' AND NEW.status IN ('dispatching','confirmed','failed'))
+  OLD.status = 'pending' AND NEW.status IN ('consumed','cancelled','superseded')
 )
-BEGIN SELECT RAISE(ABORT, 'invalid action transition'); END;
+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 (
@@ -107,28 +151,43 @@ CREATE TABLE IF NOT EXISTS events (
   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,
+  binding_kind TEXT NOT NULL CHECK(binding_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
+  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((binding_kind='goal' AND goal_id IS NOT NULL AND specialist_role IS NULL) OR (binding_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
+  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;
-${createActions}
 ${indexesAndTriggers}`;
 class SystemClock {
     now() { return new Date(); }
@@ -147,26 +206,99 @@ export class SqliteLedger {
             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 if (version < SQLITE_SCHEMA_VERSION) {
-            this.#migrateLegacy();
-        }
         else {
             this.db.exec(schema);
         }
     }
     close() { this.db.close(); }
-    appendEvent(input) { return this.#transaction(() => this.#insertEvent(input)); }
-    appendEvents(inputs) { return this.#transaction(() => inputs.map((input) => this.#insertEvent(input))); }
+    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);
     }
-    putGoal(goal, actor, wakeId) {
+    putThread(thread, actor) {
+        if (!thread.id.trim() || !thread.agent.trim())
+            throw new Error("thread id and agent are required");
+        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.parentThreadId !== thread.parentThreadId || current.createdAt !== thread.createdAt))
+            throw new Error("thread identity cannot change");
+        return this.#project("threads", thread, actor, "thread.put", undefined, thread.updatedAt, `thread:${thread.id}`);
+    }
+    putTurn(turn, actor) {
+        if (!turn.id.trim() || !turn.threadId.trim())
+            throw new Error("turn id and thread are required");
+        this.#assertTurnBinding(turn);
+        if (turn.status === "in_progress" && (!turn.leaseUntil || !turn.leaseToken) || turn.status !== "in_progress" && (turn.leaseUntil !== null || turn.leaseToken !== null || turn.runnerPid !== 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.source !== turn.source)
+                throw new Error("turn identity cannot change");
+            if (current.runnerProfileId !== turn.runnerProfileId)
+                throw new Error("turn Runner Profile cannot change");
+            if (current.status !== "in_progress")
+                throw new Error("terminal turn cannot change");
+            const bindsGoal = actor === "supervisor" && current.bindingKind === "human" && turn.bindingKind === "goal" && current.source === "human";
+            if (current.bindingKind !== turn.bindingKind && !bindsGoal || current.bindingKind === turn.bindingKind && (current.goalId !== turn.goalId || current.goalRevision !== turn.goalRevision || current.specialistRole !== turn.specialistRole))
+                throw new Error("turn execution binding cannot change");
+            if (bindsGoal) {
+                const goal = this.#getGoal(turn.goalId);
+                if (thread.agent !== "ceo" || !goal || goal.parentId !== null || goal.owner !== "ceo" || goal.phase !== "active" || goal.revision !== turn.goalRevision)
+                    throw new Error("Human Turn may bind only the current active CEO Root Goal");
+            }
+            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 {
+            if (turn.status !== "in_progress" || turn.attempt !== 1)
+                throw new Error("new turn must start in progress at attempt one");
+            if (actor !== "human" || thread.agent !== "ceo" || turn.bindingKind !== "human")
+                throw new Error("new automatic Turns must start from a claimed Wake");
+        }
+        return this.#project("turns", turn, actor, current ? `turn.${turn.status}` : "turn.started", undefined, undefined, `turn:${turn.id}`);
+    }
+    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)
@@ -177,6 +309,9 @@ export class SqliteLedger {
                 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);
@@ -187,8 +322,9 @@ export class SqliteLedger {
                 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.#recordProjection("goals", normalized, actor, "goal.put", wakeId, undefined, undefined, goalStream(normalized.id));
+            const event = this.#recordGoalChange(normalized, current, actor, wakeId, change);
             if (!current)
                 this.#createWorkRecord(normalized, actor, wakeId ?? `goal:create:${normalized.id}`, wakeId);
             return event;
@@ -204,6 +340,9 @@ export class SqliteLedger {
         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.bindingKind !== "goal" || turn.goalId !== goal.id || turn.goalRevision !== request.goalRevision)
+            throw new Error("work record update does not match an active Goal-bound Turn");
         const current = this.workRecord(goal.id);
         if (!current)
             throw new Error("work record does not exist");
@@ -218,7 +357,7 @@ export class SqliteLedger {
             content: request.content,
             updatedBy: actor,
             updatedInTurn: request.turnId,
-            updatedInWake: request.wakeId ?? null,
+            sourceWakeId: request.sourceWakeId ?? null,
             updatedAt: this.#now(),
             reason: request.reason,
             evidence: request.evidence,
@@ -227,8 +366,10 @@ export class SqliteLedger {
     commitDelegation(request, actor, wakeId) {
         const existing = this.#delegationResult(request.id);
         if (existing) {
-            if (existing.goal.id !== request.childGoal.id || existing.goal.parentId !== request.parentGoalId || existing.goal.objective !== request.childGoal.objective || existing.goal.observationMethod !== request.childGoal.observationMethod || existing.goal.verificationMethod !== request.childGoal.verificationMethod || existing.goal.owner !== request.childGoal.owner)
-                throw new Error("delegation id was reused with a different child goal");
+            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())
@@ -241,6 +382,8 @@ export class SqliteLedger {
         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")
@@ -254,43 +397,44 @@ export class SqliteLedger {
                 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}`,
-                agent: goal.owner,
+                ...goalExecutionBinding(goal.owner, goal.id),
                 triggerRef: `delegation:${request.id}`,
                 status: "queued",
-                leaseUntil: null,
                 attempt: 0,
-                startedAt: null,
-                endedAt: null,
                 enqueuedSeq: 0,
-                leaseToken: null,
-                runnerPid: null,
+                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 },
+                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.#recordProjection("goals", goal, actor, "goal.put", wakeId, undefined, undefined, goalStream(goal.id));
+            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 = { ...wakeBase, enqueuedSeq: this.#nextEventSeq() };
-            this.#recordProjection("wakes", wake, "supervisor", "wake.enqueued", wake.id, undefined, wake.enqueuedSeq);
+            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) {
-            if (existing.goal.id !== request.goalId || existing.goal.owner !== request.newOwner)
-                throw new Error("reassignment id was reused with a different target");
+            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())
@@ -299,6 +443,8 @@ export class SqliteLedger {
         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);
@@ -306,23 +452,19 @@ export class SqliteLedger {
             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-old-mail:${request.id}`, to: current.owner, from: actor, level: "fyi", body: { type: "reassignment", reassignmentId: request.id, goalId: goal.id, role: "previous_owner", reason: request.reason, evidence: request.evidence }, readAt: null },
-                { id: `reassignment-new-mail:${request.id}`, to: goal.owner, from: actor, level: "decision", body: { type: "reassignment", reassignmentId: request.id, goalId: goal.id, role: "new_owner", brief: request.brief, reason: request.reason, evidence: request.evidence }, readAt: null },
-            ];
-            const wakeBase = { id: `reassignment-wake:${request.id}`, agent: goal.owner, triggerRef: `reassignment:${request.id}`, status: "queued", leaseUntil: null, attempt: 0, startedAt: null, endedAt: null, enqueuedSeq: 0, leaseToken: null, runnerPid: 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, reason: request.reason, evidence: request.evidence } });
+            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}`, ...goalExecutionBinding(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.#recordProjection("goals", goal, actor, "goal.put", wakeId, undefined, undefined, goalStream(goal.id));
-            const oldWake = this.queuedWakeForAgent(current.owner);
-            if (oldWake)
-                this.#recordProjection("wakes", { ...oldWake, status: "abnormal", endedAt: this.#now() }, "supervisor", "wake.suppressed", oldWake.id);
-            for (const item of mail)
+            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, enqueuedSeq: this.#nextEventSeq() };
-            this.#recordProjection("wakes", wake, "supervisor", "wake.enqueued", wake.id, undefined, wake.enqueuedSeq);
+            }
+            const wake = wakeBase ? this.#admitWake(wakeBase, "supervisor", false).wake : null;
             return { reassignmentId: request.id, goal, mail, wake };
         });
     }
@@ -333,10 +475,15 @@ export class SqliteLedger {
         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.phase === "complete")
-            return current;
         if (current.observationMethod === null)
             throw new Error("goal completion requires an observation method");
         if (current.verificationMethod === null || current.verificationMethod === undefined)
@@ -344,7 +491,7 @@ export class SqliteLedger {
         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.put' AND json_extract(data,'$.snapshot.revision')=? ORDER BY seq DESC LIMIT 1").get(goalStream(current.id), current.revision);
+        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))
@@ -352,214 +499,188 @@ export class SqliteLedger {
         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.#recordProjection("goals", next, actor, "goal.put", wakeId, undefined, undefined, goalStream(current.id));
+            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) {
-        if (actor !== "supervisor" && actor !== value.agent)
-            throw new Error("schedule may only be set by its agent or supervisor");
-        return this.#project("schedule", value, actor, "schedule.put", wakeId);
+        return this.#transaction(() => this.#admitSchedule(value, actor, wakeId));
     }
-    enqueueWake(input, actor) {
-        if (actor !== "supervisor")
-            throw new Error("only supervisor may enqueue wakes");
-        if (input.status !== "queued" || input.attempt !== 0 || input.leaseUntil || input.startedAt || input.endedAt || input.leaseToken || input.runnerPid) {
-            throw new Error("new wake must be pristine and queued");
-        }
-        const duplicate = this.wakeByTrigger(input.agent, input.triggerRef);
-        if (duplicate) {
-            const row = this.db.prepare("SELECT * FROM events WHERE type='wake.enqueued' AND json_extract(data, '$.snapshot.id')=? ORDER BY seq DESC LIMIT 1").get(duplicate.id);
-            if (!row)
-                throw new Error("wake projection has no source event");
-            return { event: mapEvent(row), created: false };
+    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.bindingKind !== current.bindingKind || 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.bindingKind !== wake.bindingKind || 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.bindingKind === wake.bindingKind && candidate.specialistRole === wake.specialistRole && candidate.goalId === wake.goalId);
+        if (queued) {
+            stored = queued;
+            this.#admitWakeTrigger(queued.id, wake.triggerRef, "supervisor", now);
         }
-        return this.#transaction(() => {
-            const enqueuedSeq = this.#nextEventSeq();
-            const wake = { ...input, enqueuedSeq };
-            const event = this.#recordProjection("wakes", wake, actor, "wake.enqueued", wake.id, undefined, enqueuedSeq);
-            return { event, created: true };
-        });
+        else
+            stored = this.#admitWake(wake, "supervisor", false).wake;
+    } const schedule = { ...current, status: "consumed", resolvedAt: now }; this.#recordProjection("schedule", schedule, "supervisor", "schedule.consumed", undefined, 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", undefined, 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", undefined, now); return next; }
+    enqueueWake(input, actor) {
+        return this.#transaction(() => { const result = this.#admitWake(input, actor, true); return { event: result.event, created: result.created }; });
     }
-    claimNextWake(now, leaseUntil, leaseToken) {
+    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 IN ('leased','running')
-      ) ORDER BY CASE WHEN trigger_ref LIKE 'interaction:%' THEN 0 ELSE 1 END,enqueued_seq LIMIT 1`).get();
+        SELECT 1 FROM wakes active WHERE active.agent=w.agent AND active.status='claimed'
+      ) AND NOT EXISTS (
+        SELECT 1 FROM turns WHERE source='human' 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'
+      ) ORDER BY enqueued_seq LIMIT 1`).get();
             if (!row)
                 return null;
             const current = mapWake(row);
-            const next = { ...current, status: "leased", leaseUntil, leaseToken, runnerPid: null, attempt: current.attempt + 1 };
-            this.#recordProjection("wakes", next, "supervisor", "wake.leased", next.id, now);
+            const next = { ...current, status: "claimed", claimedAt: now, attempt: current.attempt + 1 };
+            this.#recordProjection("wakes", next, "supervisor", "wake.claimed", next.id, now);
             return next;
         });
     }
-    markWakeRunning(id, now, leaseToken) {
+    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.#assertTurnBinding(turn); if (turn.status !== "in_progress" || turn.attempt !== 1 || !turn.leaseUntil || !turn.leaseToken)
+        throw new Error("Wake must start an owned Turn at attempt one"); const thread = this.thread(turn.threadId); if (!thread || thread.agent !== wake.agent)
+        throw new Error("Wake Turn agent does not match"); if (!sameWakeTurnBinding(wake, turn))
+        throw new Error("Wake Turn execution binding does not match"); return this.#transaction(() => { if (this.db.prepare("SELECT 1 FROM turns WHERE source='human' AND status='in_progress' LIMIT 1").get())
+        throw new Error("automatic Wake cannot start while a Human Turn is in progress"); this.#assertCurrentAutomaticTurn(turn, thread.agent); this.#recordProjection("turns", turn, "supervisor", "turn.started", undefined, now, undefined, `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);
-        this.#assertLease(current, leaseToken);
-        const next = { ...current, status: "running", startedAt: now };
-        this.#project("wakes", next, "supervisor", "wake.running", id, now);
+        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;
     }
-    attachWakeProcess(id, leaseToken, pid, now) {
+    cancelWake(id, now) {
         const current = this.#requiredWake(id);
-        this.#assertLease(current, leaseToken);
-        if (current.status !== "running")
-            throw new Error("runner pid may only be attached to a running wake");
-        const next = { ...current, runnerPid: pid };
-        this.#project("wakes", next, "supervisor", "wake.runner_attached", id, now);
-        return next;
+        return this.#transaction(() => this.#cancelWakeProjection(current, now));
     }
-    renewWakeLease(id, leaseToken, leaseUntil, now) {
-        const current = this.#requiredWake(id);
-        this.#assertLease(current, leaseToken);
-        if (current.status !== "leased" && current.status !== "running")
-            throw new Error("only an active wake lease may be renewed");
+    attachTurnProcess(id, leaseToken, pid) {
+        const current = this.#requiredTurn(id);
+        this.#assertTurnLease(current, leaseToken);
+        if (current.status !== "in_progress")
+            throw new Error("runner pid may only be attached to an active Turn");
+        this.putTurn({ ...current, runnerPid: pid }, "supervisor");
+        return this.#requiredTurn(id);
+    }
+    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");
-        const next = { ...current, leaseUntil };
-        this.#project("wakes", next, "supervisor", "wake.lease_renewed", id, now);
-        return next;
+        this.putTurn({ ...current, leaseUntil }, "supervisor");
+        return this.#requiredTurn(id);
     }
-    finishWake(id, status, now) {
-        const current = this.#requiredWake(id);
-        const next = { ...current, status, leaseUntil: null, leaseToken: null, runnerPid: null, endedAt: now };
-        this.#project("wakes", next, "supervisor", `wake.${status}`, id, now);
-        return next;
-    }
-    expiredWakes(now) {
-        return this.db.prepare("SELECT * FROM wakes WHERE status IN ('leased','running') AND lease_until <= ? ORDER BY enqueued_seq").all(now).map(mapWake);
-    }
-    recoverExpiredWake(id, now) {
-        const current = this.#requiredWake(id);
-        if (current.status !== "leased" && current.status !== "running")
-            throw new Error("wake is not recoverable");
-        if (!current.leaseUntil || current.leaseUntil > now)
-            throw new Error("wake lease has not expired");
-        const running = current.status === "running";
-        const next = { ...current, status: running ? "abnormal" : "queued", leaseUntil: null, leaseToken: null, runnerPid: null, endedAt: running ? now : null };
-        this.#project("wakes", next, "supervisor", running ? "wake.expired_abnormal" : "wake.lease_expired", id, now);
-        return next;
-    }
-    appendRunnerEvent(input, leaseToken) {
+    appendTurnEvent(input, leaseToken) {
         return this.#transaction(() => {
-            if (!input.streamId.startsWith("wake:"))
-                throw new Error("runner event requires a wake stream");
-            const wake = this.#requiredWake(input.streamId.slice("wake:".length));
-            this.#assertLease(wake, leaseToken);
-            if (wake.status !== "running" || !wake.leaseUntil || input.ts > wake.leaseUntil)
+            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);
         });
     }
-    requestAction(action, actor, wakeId) {
-        assertActionRequest(action);
-        if (actor !== action.agent)
-            throw new Error("action actor does not match action agent");
-        this.#assertEvidenceExists(action.evidence);
-        return this.#project("actions", action, actor, "action.requested", wakeId);
-    }
-    approveAction(id, approver, reason, evidence) {
-        return this.#decideAction(id, "approved", approver, reason, evidence);
-    }
-    rejectAction(id, approver, reason, evidence) {
-        return this.#decideAction(id, "failed", approver, reason, evidence);
-    }
-    transitionAction(id, status, patch = {}) {
-        const current = this.#requiredAction(id);
-        assertActionTransition(current.status, status);
-        if (current.status === "unknown" && (status === "confirmed" || status === "failed") && !patch.reconciledAt)
-            throw new Error("unknown action requires a reconciliation timestamp");
-        if (patch.reconciledAt && current.status !== "unknown")
-            throw new Error("reconciledAt is only written after unknown is queried");
-        if (patch.reconciledAt && status !== "confirmed" && status !== "failed")
-            throw new Error("reconciliation must resolve to a final state");
-        const next = { ...current, ...patch, status };
-        this.#project("actions", next, "supervisor", `action.${status}`);
-        return next;
-    }
-    recoverDispatchingActions() {
-        const rows = this.db.prepare("SELECT id FROM actions WHERE status='dispatching' ORDER BY id").all();
-        return rows.map(({ id }) => this.transitionAction(id, "unknown"));
-    }
-    putAuditAdvice(id, input, wakeId) {
-        const advice = { ...input, at: this.#now() };
-        this.#assertEvidenceExists(advice.evidence);
-        const current = this.#requiredAction(id);
-        const next = { ...current, auditAdvice: advice, adviceAcked: false };
-        this.#project("actions", next, advice.by, "action.audit_advice", wakeId, advice.at);
-        return next;
-    }
-    ackAuditAdvice(id, agent) {
-        const current = this.#requiredAction(id);
-        if (current.agent !== agent)
-            throw new Error("only the action owner may acknowledge audit advice");
-        if (!current.auditAdvice)
-            throw new Error("action has no audit advice");
-        const next = { ...current, adviceAcked: true };
-        this.#project("actions", next, agent, "action.audit_advice_acked");
-        return next;
-    }
-    putMail(mail, actor, wakeId) {
-        if (mail.from !== actor && actor !== "supervisor")
-            throw new Error("mail sender does not match actor");
-        return this.#project("mailbox", mail, actor, "mail.put", wakeId);
-    }
+    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); if (current.status !== "in_progress")
+        throw new Error("only an active Turn may finish"); if (status === "completed" && current.bindingKind === "goal")
+        throw new Error("Goal-bound Turn completion requires commitHandoff"); if (status === "completed" && error !== null || status !== "completed" && error === null)
+        throw new Error("Turn terminal error does not match status"); return this.#transaction(() => { if (status !== "completed")
+        this.#repairOpenTurnItems(id, String(error.message ?? "Turn interrupted"), now, actor);
+    else if (this.turnItems(id).some((item) => item.status === "in_progress"))
+        throw new Error("successful Turn cannot retain in-progress Items"); const streamId = `turn:${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, runnerPid: null }; this.#recordProjection("turns", next, actor, `turn.${status}`, undefined, now, undefined, streamId); return next; }); }
+    putMail(mail, actor, wakeId) { return this.putMails([mail], actor, wakeId)[0]; }
+    putMails(mails, actor, wakeId) { const ids = new Set(); const prior = 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 wake = this.#requiredWake(commit.wakeId);
-            if (wake.status !== "running" || wake.agent !== commit.agent)
-                throw new Error("handoff does not match a running wake");
-            const event = this.#insertEvent({ streamId: wakeStream(commit.wakeId), ts: commit.ts, actor: commit.agent, type: "handoff.recorded", data: commit.output.handoff });
-            for (const mail of this.unreadMail(commit.agent)) {
-                this.#recordProjection("mailbox", { ...mail, readAt: commit.ts }, "supervisor", "mail.read", commit.wakeId, commit.ts);
-            }
-            for (const mail of commit.outgoingMail) {
-                if (mail.from !== commit.agent)
-                    throw new Error("handoff mail sender does not match agent");
-                this.#recordProjection("mailbox", mail, commit.agent, "mail.put", commit.wakeId, commit.ts);
-            }
-            if (commit.schedule) {
-                if (commit.schedule.agent !== commit.agent || commit.schedule.setBy !== commit.agent)
-                    throw new Error("handoff schedule does not match agent");
-                this.#recordProjection("schedule", commit.schedule, commit.agent, "schedule.put", commit.wakeId, commit.ts);
+            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.bindingKind !== "goal")
+                throw new Error("only a Goal-bound 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 binding is stale");
+            const record = this.workRecord(goal.id);
+            if (!record || record.updatedInTurn !== turn.id || record.goalRevision !== goal.revision || record.recordRevision < 1)
+                throw new Error("Goal-bound 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, runnerPid: null }, "supervisor", "turn.completed", undefined, commit.ts, undefined, streamId);
             return event;
         });
     }
-    commitInteraction(commit) {
-        return this.#transaction(() => {
-            const wake = this.#requiredWake(commit.wakeId);
-            if (wake.status !== "running" || wake.agent !== commit.agent)
-                throw new Error("interaction does not match a running wake");
-            const mailRow = this.db.prepare("SELECT * FROM mailbox WHERE id=?").get(commit.mailId);
-            if (!mailRow)
-                throw new Error("interaction mail does not exist");
-            const mail = mapMail(mailRow);
-            if (mail.to !== commit.agent || mail.readAt !== null)
-                throw new Error("interaction mail is not unread for the agent");
-            const event = this.#insertEvent({ streamId: wakeStream(commit.wakeId), ts: commit.ts, actor: commit.agent, type: "interaction.completed", data: { mailId: mail.id, response: commit.response } });
-            this.#recordProjection("mailbox", { ...mail, readAt: commit.ts }, "supervisor", "mail.read", commit.wakeId, commit.ts);
-            return event;
-        });
-    }
-    dueSchedules(now) { return this.db.prepare("SELECT * FROM schedule WHERE next_wake_at <= ? ORDER BY next_wake_at,id").all(now).map(mapSchedule); }
+    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); }
-    unackedAuditAdvice(agent) { return this.db.prepare("SELECT * FROM actions WHERE agent=? AND audit_advice IS NOT NULL AND advice_acked=0 ORDER BY rowid").all(agent).map(mapAction); }
     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 direct = this.db.prepare("SELECT * FROM wakes WHERE agent=? AND trigger_ref=?").get(agent, triggerRef);
-        if (direct)
-            return mapWake(direct);
-        const coalesced = this.db.prepare(`SELECT w.* FROM events e JOIN wakes w ON e.stream_id='wake:'||w.id
-      WHERE e.type='wake.trigger_coalesced' AND json_extract(e.data,'$.triggerRef')=? AND w.agent=? LIMIT 1`).get(triggerRef, agent);
-        return coalesced ? mapWake(coalesced) : null;
+        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; }
-    action(id) { const row = this.db.prepare("SELECT * FROM actions WHERE id=?").get(id); return row ? mapAction(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; }
@@ -586,69 +707,116 @@ export class SqliteLedger {
     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);
     }
-    metricSamples(goalId) {
-        return this.db.prepare("SELECT data FROM events WHERE type='metric.sampled' AND json_extract(data,'$.goalId')=? ORDER BY seq").all(goalId).map((row) => JSON.parse(row.data));
-    }
     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); }
-    actions() { return this.db.prepare("SELECT * FROM actions ORDER BY id").all().map(mapAction); }
     mailbox() { return this.db.prepare("SELECT * FROM mailbox ORDER BY rowid").all().map(mapMail); }
     rebuildProjections() {
-        const source = this.events();
+        const source = this.db.prepare("SELECT * FROM events ORDER BY seq").all();
         this.#transaction(() => {
-            this.db.exec("DELETE FROM work_records; DELETE FROM actions; DELETE FROM mailbox; DELETE FROM wakes; DELETE FROM schedule; DELETE FROM goals;");
-            for (const event of source) {
-                const data = event.data;
-                if (data.projection && data.snapshot)
-                    this.#applyProjection(data.projection, data.snapshot, event.seq);
+            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 = 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 FROM events WHERE type='delegation.created' AND json_extract(data,'$.delegationId')=? ORDER BY seq LIMIT 1").get(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.#getGoal(data.goalId);
-        const mailRow = this.db.prepare("SELECT * FROM mailbox WHERE id=?").get(data.mailId);
-        const wake = this.wake(data.wakeId);
-        if (!goal || !mailRow || !wake)
-            throw new Error("committed delegation projections are incomplete");
-        return { delegationId: id, goal, mail: mapMail(mailRow), wake };
+        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 FROM events WHERE type='goal.reassigned' AND json_extract(data,'$.reassignmentId')=? ORDER BY seq LIMIT 1").get(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.#getGoal(data.goalId);
-        const mail = data.mailIds.map((mailId) => {
-            const mailRow = this.db.prepare("SELECT * FROM mailbox WHERE id=?").get(mailId);
-            if (!mailRow)
-                throw new Error("committed reassignment mail is missing");
-            return mapMail(mailRow);
-        });
-        const wake = this.wake(data.wakeId);
-        if (!goal || !wake)
-            throw new Error("committed reassignment projections are incomplete");
+        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 };
     }
-    #decideAction(id, status, approver, reason, evidence) {
-        if (!reason.trim())
-            throw new Error("approval reason is required");
-        this.#assertEvidenceExists(evidence);
-        return this.#transaction(() => {
-            const current = this.#requiredAction(id);
-            assertActionTransition(current.status, status);
-            this.#insertEvent({ streamId: controlStream("actions"), ts: this.#now(), actor: approver, type: `action.${status}_decision`, data: { actionId: id, reason, evidence } });
-            const next = { ...current, status };
-            this.#recordProjection("actions", next, approver, `action.${status}`);
-            return next;
-        });
-    }
+    #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: data }, undefined, "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}\u0000${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 legalBinding = turn.bindingKind === "human" || turn.bindingKind === "goal" && turn.goalId === snapshot.id;
+            if (turn.source !== "human" || thread.agent !== "ceo" || !legalBinding)
+                throw new Error("Goal change source Turn does not carry Human authority");
+        }
+        else if (authority.kind === "parent_goal") {
+            if (thread.agent !== actor || turn.bindingKind !== "goal" || turn.goalId !== authority.goalId || turn.goalRevision !== authority.goalRevision)
+                throw new Error("Goal change source Turn is not bound 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.bindingKind !== "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,
@@ -657,7 +825,7 @@ export class SqliteLedger {
             content: seed?.content ?? initialWorkRecord(),
             updatedBy: actor,
             updatedInTurn: turnId,
-            updatedInWake: wakeId ?? null,
+            sourceWakeId: wakeId ?? null,
             updatedAt: this.#now(),
             reason: "Goal created",
             evidence: seed?.evidence ?? [],
@@ -667,7 +835,7 @@ export class SqliteLedger {
     #recordWorkRecord(snapshot, type) {
         const seq = this.#nextEventSeq();
         const committed = { ...snapshot, lastEventSeq: seq };
-        this.#recordProjection("work_records", committed, committed.updatedBy, type, committed.updatedInWake ?? undefined, committed.updatedAt, seq, workRecordStream(committed.goalId));
+        this.#recordProjection("work_records", committed, committed.updatedBy, type, committed.sourceWakeId ?? undefined, committed.updatedAt, seq, workRecordStream(committed.goalId));
         return committed;
     }
     #assertWorkRecordAuthority(goal, actor) {
@@ -689,6 +857,9 @@ export class SqliteLedger {
         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=?
@@ -696,36 +867,270 @@ export class SqliteLedger {
     ) 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}`);
     }
-    #assertLease(wake, leaseToken) {
-        if (wake.leaseToken !== leaseToken)
-            throw new Error("stale wake lease token");
-    }
+    #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; }
-    #requiredAction(id) { const value = this.action(id); if (!value)
-        throw new Error(`action not found: ${id}`); return value; }
+    #admitWake(input, actor, allowExisting) {
+        if (actor !== "supervisor")
+            throw new Error("only supervisor may enqueue wakes");
+        this.#assertExecutionBinding(input, true);
+        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.bindingKind === input.bindingKind && 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 sameBinding = duplicate.bindingKind === input.bindingKind && duplicate.specialistRole === input.specialistRole && duplicate.goalId === input.goalId;
+            if (!allowExisting || !sameBinding)
+                throw new Error("Wake trigger was reused with a different execution binding");
+            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.bindingKind === "goal") {
+            const goal = this.#getGoal(input.goalId);
+            if (!goal || goal.owner !== input.agent || goal.phase !== "active")
+                throw new Error("Wake Goal binding 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, undefined, 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.bindingKind === "goal" && wake.goalId === mail.goalId : mail.routeKind === "human_inbox" && mail.from === "human" ? wake.bindingKind === "human" : mail.routeKind === "specialist_inbox" ? wake.bindingKind === "specialist" && wake.specialistRole === mail.specialistRole : false;
+        if (!matches)
+            throw new Error("Mail trigger does not match the Wake execution binding");
+    } const source = wake.bindingKind === "human" ? "human" : wake.bindingKind === "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.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`, undefined, item.completedAt ?? item.createdAt, undefined, 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", undefined, now, undefined, 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.#assertExecutionBinding(value, false); 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 binding"); if (normalized.bindingKind === "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; }
+    #assertExecutionBinding(value, allowHuman) { if (value.bindingKind === "human") {
+        if (!allowHuman || value.agent !== "ceo" || value.goalId !== null || value.specialistRole !== null)
+            throw new Error("invalid Human execution binding");
+        return;
+    } if (value.bindingKind === "goal") {
+        if (!value.goalId || value.specialistRole !== null)
+            throw new Error("invalid Goal execution binding");
+        return;
+    } if (value.bindingKind !== "specialist" || value.goalId !== null || !value.specialistRole || !["verifier", "audit"].includes(value.specialistRole))
+        throw new Error("invalid Specialist execution binding"); }
+    #assertTurnBinding(value) { if (value.bindingKind === "human") {
+        if (value.source !== "human" || value.goalId !== null || value.goalRevision !== null || value.specialistRole !== null)
+            throw new Error("invalid Human Turn binding");
+        return;
+    } if (value.bindingKind === "goal") {
+        if (!["human", "goal"].includes(value.source) || !value.goalId || value.goalRevision === null || value.specialistRole !== null)
+            throw new Error("invalid Goal Turn binding");
+        return;
+    } if (value.bindingKind !== "specialist" || value.source !== "system" || value.goalId !== null || value.goalRevision !== null || !value.specialistRole || !["verifier", "audit"].includes(value.specialistRole))
+        throw new Error("invalid Specialist Turn binding"); }
+    #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.#assertTurnBinding(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)
+            throw new Error(`turn event ${event.seq} has an invalid initial state`);
+        if (event.actor === "human") {
+            if (turn.bindingKind !== "human" || thread.agent !== "ceo")
+                throw new Error(`turn event ${event.seq} has invalid Human ownership`);
+        }
+        else {
+            if (event.actor !== "supervisor" || !this.wakes().some((wake) => wake.status === "claimed" && wake.agent === thread.agent && sameWakeTurnBinding(wake, turn)))
+                throw new Error(`turn event ${event.seq} bypasses Wake admission`);
+            this.#assertCurrentAutomaticTurn(turn, thread.agent, event.seq);
+        }
+        return;
+    } if (current.threadId !== turn.threadId || current.source !== turn.source || current.startedAt !== turn.startedAt || current.runnerProfileId !== turn.runnerProfileId)
+        throw new Error(`turn event ${event.seq} changes Turn identity`); if (current.status !== "in_progress")
+        throw new Error(`turn event ${event.seq} changes a terminal Turn`); const bindsGoal = event.actor === "supervisor" && current.bindingKind === "human" && turn.bindingKind === "goal" && current.source === "human"; if (current.bindingKind !== turn.bindingKind && !bindsGoal || current.bindingKind === turn.bindingKind && (current.goalId !== turn.goalId || current.goalRevision !== turn.goalRevision || current.specialistRole !== turn.specialistRole))
+        throw new Error(`turn event ${event.seq} changes execution binding`); if (bindsGoal) {
+        const goal = this.#getGoal(turn.goalId);
+        if (thread.agent !== "ceo" || !goal || goal.parentId !== null || goal.owner !== "ceo" || goal.phase !== "active" || goal.revision !== turn.goalRevision)
+            throw new Error(`turn event ${event.seq} has an invalid Human-to-Goal binding`);
+    } if (turn.status === "in_progress") {
+        if (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)
+            throw new Error(`turn event ${event.seq} has an invalid terminal transition`);
+        if (turn.status === "completed" && turn.bindingKind === "goal")
+            this.#assertReplayGoalCompletion(turn, event);
+    } }
+    #assertReplayGoalCompletion(turn, event) { 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.#assertExecutionBinding(wake, true); 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.bindingKind === "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 binding`);
+        }
+        return;
+    } if (current.bindingKind !== wake.bindingKind || 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?.agent !== wake.agent || !sameWakeTurnBinding(wake, turn))
+            throw new Error(`wake event ${event.seq} does not match its Turn`);
+    } }
+    #assertCurrentAutomaticTurn(turn, agent, seq) { if (turn.bindingKind === "human") {
+        if (agent !== "ceo")
+            throw new Error(seq ? `turn event ${seq} has invalid Human ownership` : "Human Wake may start only the CEO Turn");
+        return;
+    } if (turn.bindingKind === "goal") {
+        const goal = this.#getGoal(turn.goalId);
+        if (!goal || goal.phase !== "active" || goal.owner !== agent || goal.revision !== turn.goalRevision)
+            throw new Error(seq ? `turn event ${seq} has a stale Goal binding` : "Wake Turn must bind the current active Goal revision owned by its Agent");
+    } }
+    #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, undefined, 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", undefined, 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", undefined, 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`, undefined, now, undefined, 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, undefined, 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: { projection, snapshot } }, expectedSeq);
+        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) {
+    #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 === undefined
-            ? this.db.prepare("INSERT INTO events(stream_id,stream_seq,ts,actor,type,data,ignorable) VALUES (?,?,?,?,?,json(?),?)").run(input.streamId, streamSeq, input.ts, input.actor, input.type, JSON.stringify(input.data), input.ignorable === true ? 1 : null)
-            : this.db.prepare("INSERT INTO events(seq,stream_id,stream_seq,ts,actor,type,data,ignorable) VALUES (?,?,?,?,?,?,json(?),?)").run(expectedSeq, input.streamId, streamSeq, input.ts, input.actor, input.type, JSON.stringify(input.data), input.ignorable === true ? 1 : null);
+            ? 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() {
@@ -733,111 +1138,44 @@ export class SqliteLedger {
         return Number(row?.seq ?? 0) + 1;
     }
     #applyProjection(projection, raw, sourceSeq) {
-        if (projection === "goals") {
+        if (projection === "threads") {
+            const v = raw;
+            this.db.prepare(`INSERT INTO threads VALUES (?,?,?,?,?) ON CONFLICT(id) DO UPDATE SET agent=excluded.agent,parent_thread_id=excluded.parent_thread_id,updated_at=excluded.updated_at`).run(v.id, v.agent, 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 binding_kind=excluded.binding_kind,specialist_role=excluded.specialist_role,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.source, v.bindingKind, v.specialistRole, 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,updated_in_wake=excluded.updated_in_wake,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.updatedInWake, v.updatedAt, v.reason, JSON.stringify(v.evidence), v.lastEventSeq || sourceSeq);
+            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 agent=excluded.agent,next_wake_at=excluded.next_wake_at,reason=excluded.reason,set_by=excluded.set_by`).run(v.id, v.agent, v.nextWakeAt, v.reason, v.setBy);
+            this.db.prepare(`INSERT INTO schedule VALUES (?,?,?,?,?,?,?,?,?,?) ON CONFLICT(id) DO UPDATE SET binding_kind=excluded.binding_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.bindingKind, v.agent, v.specialistRole, v.nextWakeAt, v.reason, v.setBy, v.status, v.resolvedAt, v.goalId);
         }
         else if (projection === "wakes") {
-            const old = raw;
-            const existing = this.wake(old.id);
-            const active = old.status === "leased" || old.status === "running";
-            const v = {
-                ...old,
-                enqueuedSeq: old.enqueuedSeq ?? existing?.enqueuedSeq ?? sourceSeq,
-                leaseToken: old.leaseToken !== undefined ? old.leaseToken : active ? existing?.leaseToken ?? `legacy:${old.id}:${old.attempt}` : null,
-                runnerPid: old.runnerPid !== undefined ? old.runnerPid : existing?.runnerPid ?? null,
-            };
-            this.db.prepare(`INSERT INTO wakes VALUES (?,?,?,?,?,?,?,?,?,?,?) ON CONFLICT(id) DO UPDATE SET agent=excluded.agent,trigger_ref=excluded.trigger_ref,status=excluded.status,lease_until=excluded.lease_until,attempt=excluded.attempt,started_at=excluded.started_at,ended_at=excluded.ended_at,enqueued_seq=excluded.enqueued_seq,lease_token=excluded.lease_token,runner_pid=excluded.runner_pid`).run(v.id, v.agent, v.triggerRef, v.status, v.leaseUntil, v.attempt, v.startedAt, v.endedAt, v.enqueuedSeq, v.leaseToken, v.runnerPid);
+            const v = raw;
+            this.db.prepare(`INSERT INTO wakes VALUES (?,?,?,?,?,?,?,?,?,?,?,?) ON CONFLICT(id) DO UPDATE SET binding_kind=excluded.binding_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.bindingKind, 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 to_agent=excluded.to_agent,from_agent=excluded.from_agent,level=excluded.level,body=excluded.body,read_at=excluded.read_at`).run(v.id, v.to, v.from, v.level, JSON.stringify(v.body), v.readAt);
+            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);
         }
-        else {
-            const old = raw;
-            const v = { ...old, connector: old.connector ?? "legacy" };
-            this.db.prepare(`INSERT INTO actions VALUES (?,?,?,?,json(?),?,json(?),?,?,?,?,?,?) ON CONFLICT(id) DO UPDATE SET agent=excluded.agent,kind=excluded.kind,connector=excluded.connector,payload=excluded.payload,reason=excluded.reason,evidence=excluded.evidence,gated=excluded.gated,status=excluded.status,reconciled_at=excluded.reconciled_at,external_ref=excluded.external_ref,audit_advice=excluded.audit_advice,advice_acked=excluded.advice_acked`).run(v.id, v.agent, v.kind, v.connector, JSON.stringify(v.payload), v.reason, JSON.stringify(v.evidence), v.gated ? 1 : 0, v.status, v.reconciledAt, v.externalRef, v.auditAdvice === null ? null : JSON.stringify(v.auditAdvice), v.adviceAcked ? 1 : 0);
-        }
-    }
-    #legacyWorkRecord(goal) {
-        const handoff = this.lastEvent(goal.owner, "handoff.recorded");
-        const legacy = handoff?.data && typeof handoff.data === "object" && !Array.isArray(handoff.data) && !("goalId" in handoff.data) ? handoff.data : null;
-        const notes = this.readStream(`memory:${goal.owner}`).filter((event) => event.type === "memory.appended");
-        const list = (items) => items?.length ? items.map((item) => `- ${item}`).join("\n") : "None recorded.";
-        const decisions = notes.length ? notes.map((event) => `- ${String(event.data.note ?? "")} [event:${event.seq}]`).join("\n") : "None recorded.";
-        return {
-            content: `# Current State\n\nMigrated from the previous Goal continuity model.\n\n# Observations\n\n${list(legacy?.observations)}\n\n# Work Completed\n\n${list(legacy?.results)}\n\n# Decisions\n\n${decisions}\n\n# Blockers\n\n${legacy?.blocker ?? "None recorded."}\n\n# Next Steps\n\n${list(legacy?.nextSteps)}\n`,
-            evidence: [...(handoff ? [handoff.seq] : []), ...notes.map((event) => event.seq)],
-        };
-    }
-    #migrateLegacy() {
-        this.#transaction(() => {
-            const goalColumns = new Set(this.db.prepare("PRAGMA table_info(goals)").all().map((row) => row.name));
-            const observationSource = goalColumns.has("observation_method") ? "observation_method" : "NULL";
-            const verificationSource = goalColumns.has("verification_method") ? "verification_method" : observationSource;
-            this.db.exec(`PRAGMA defer_foreign_keys=ON;
-        DROP TABLE IF EXISTS work_records;
-        DROP TRIGGER IF EXISTS events_no_update; DROP TRIGGER IF EXISTS events_no_delete; DROP TRIGGER IF EXISTS events_fts_insert;
-        DROP TRIGGER IF EXISTS wakes_valid_transition; DROP TRIGGER IF EXISTS actions_valid_transition; DROP TRIGGER IF EXISTS goals_valid_transition;
-        DROP INDEX IF EXISTS events_agent_kind_seq; DROP INDEX IF EXISTS events_wake_seq; DROP INDEX IF EXISTS events_coalesced_trigger;
-        DROP INDEX IF EXISTS events_actor_type_seq; DROP INDEX IF EXISTS events_stream_seq;
-        DROP INDEX IF EXISTS wakes_one_active_agent; DROP INDEX IF EXISTS wakes_queue_order; DROP INDEX IF EXISTS schedule_due; DROP INDEX IF EXISTS actions_agent_status;
-        DROP TABLE IF EXISTS events_fts;
-
-        ALTER TABLE goals RENAME TO goals_legacy; ${createGoals}
-        INSERT INTO goals(id,parent_id,objective,observation_method,verification_method,owner,phase,revision) SELECT id,parent_id,objective,${observationSource},${verificationSource},owner,phase,revision FROM goals_legacy;
-        DROP TABLE goals_legacy;`);
-            const wakeColumns = new Set(this.db.prepare("PRAGMA table_info(wakes)").all().map((row) => row.name));
-            if (!wakeColumns.has("enqueued_seq")) {
-                this.db.exec(`ALTER TABLE wakes RENAME TO wakes_legacy; ${createWakes}
-          INSERT INTO wakes SELECT id,agent,trigger_ref,status,lease_until,attempt,started_at,ended_at,rowid,
-            CASE WHEN status IN ('leased','running') THEN 'legacy:'||id||':'||attempt ELSE NULL END,NULL FROM wakes_legacy;
-          DROP TABLE wakes_legacy;`);
-            }
-            const actionColumns = new Set(this.db.prepare("PRAGMA table_info(actions)").all().map((row) => row.name));
-            if (!actionColumns.has("connector")) {
-                this.db.exec(`ALTER TABLE actions RENAME TO actions_legacy; ${createActions}
-          INSERT INTO actions SELECT id,agent,kind,'legacy',payload,reason,evidence,gated,status,reconciled_at,external_ref,audit_advice,advice_acked FROM actions_legacy;
-          DROP TABLE actions_legacy;`);
-            }
-            const eventColumns = new Set(this.db.prepare("PRAGMA table_info(events)").all().map((row) => row.name));
-            if (!eventColumns.has("stream_id")) {
-                this.db.exec(`ALTER TABLE events RENAME TO events_legacy;
-          CREATE TABLE 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)),
-            ignorable INTEGER CHECK(ignorable IS NULL OR ignorable = 1),
-            UNIQUE(stream_id, stream_seq)
-          ) STRICT;
-          INSERT INTO events(seq,stream_id,stream_seq,ts,actor,type,data,ignorable)
-          SELECT seq,stream_id,ROW_NUMBER() OVER (PARTITION BY stream_id ORDER BY seq),ts,agent,kind,data,NULL FROM (
-            SELECT seq,ts,agent,kind,data,CASE WHEN wake_id IS NULL THEN 'control:'||agent ELSE 'wake:'||wake_id END AS stream_id FROM events_legacy
-          );
-          DROP TABLE events_legacy;`);
-            }
-            else if (!eventColumns.has("ignorable")) {
-                this.db.exec("ALTER TABLE events ADD COLUMN ignorable INTEGER CHECK(ignorable IS NULL OR ignorable = 1)");
-            }
-            this.db.exec(createWorkRecords);
-            for (const goal of this.goals()) {
-                if (!this.workRecord(goal.id))
-                    this.#createWorkRecord(goal, "supervisor", `migration:work-record:${goal.id}`, undefined, this.#legacyWorkRecord(goal));
-            }
-            this.db.exec(`${indexesAndTriggers} INSERT INTO events_fts(events_fts) VALUES('rebuild'); PRAGMA user_version=${SQLITE_SCHEMA_VERSION};`);
-        });
     }
     #transaction(fn) {
         this.db.exec("BEGIN IMMEDIATE");
@@ -854,12 +1192,38 @@ export class SqliteLedger {
     #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), 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), source: String(r.source), bindingKind: String(r.binding_kind), specialistRole: r.specialist_role === null ? null : String(r.specialist_role), 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 === undefined ? {} : { 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 === undefined ? 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 === undefined ? null : String(r.observation_method), verificationMethod: r.verification_method === null || r.verification_method === undefined ? 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), updatedInWake: r.updated_in_wake === null ? null : String(r.updated_in_wake), updatedAt: String(r.updated_at), reason: String(r.reason), evidence: JSON.parse(String(r.evidence)), lastEventSeq: Number(r.last_event_seq) }; }
+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");
@@ -877,8 +1241,14 @@ function lineDiff(from, to) {
     }
     return lines.join("\n");
 }
-function mapSchedule(r) { return { id: String(r.id), agent: String(r.agent), nextWakeAt: String(r.next_wake_at), reason: String(r.reason), setBy: String(r.set_by) }; }
-function mapWake(r) { return { id: String(r.id), agent: String(r.agent), triggerRef: String(r.trigger_ref), status: String(r.status), leaseUntil: r.lease_until === null ? null : String(r.lease_until), attempt: Number(r.attempt), startedAt: r.started_at === null ? null : String(r.started_at), endedAt: r.ended_at === null ? null : String(r.ended_at), enqueuedSeq: Number(r.enqueued_seq), leaseToken: r.lease_token === null ? null : String(r.lease_token), runnerPid: r.runner_pid === null ? null : Number(r.runner_pid) }; }
-function mapMail(r) { return { id: String(r.id), to: String(r.to_agent), from: String(r.from_agent), level: String(r.level), body: JSON.parse(String(r.body)), readAt: r.read_at === null ? null : String(r.read_at) }; }
-function mapAction(r) { return { id: String(r.id), agent: String(r.agent), kind: String(r.kind), connector: String(r.connector), payload: JSON.parse(String(r.payload)), reason: String(r.reason), evidence: JSON.parse(String(r.evidence)), gated: Boolean(r.gated), status: String(r.status), reconciledAt: r.reconciled_at === null ? null : String(r.reconciled_at), externalRef: r.external_ref === null ? null : String(r.external_ref), auditAdvice: r.audit_advice === null ? null : JSON.parse(String(r.audit_advice)), adviceAcked: Boolean(r.advice_acked) }; }
+function mapSchedule(r) { return { id: String(r.id), bindingKind: String(r.binding_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), bindingKind: String(r.binding_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 sameWakeTurnBinding(wake, turn) { if (wake.bindingKind !== turn.bindingKind)
+    return false; if (wake.bindingKind === "human")
+    return turn.bindingKind === "human" && turn.source === "human"; if (wake.bindingKind === "goal")
+    return turn.bindingKind === "goal" && wake.goalId === turn.goalId; return turn.bindingKind === "specialist" && wake.specialistRole === turn.specialistRole && turn.source === "system"; }
+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; }
 //# sourceMappingURL=index.js.map