@goah/cli 0.11.4 → 0.13.0

package/node_modules/goah-supervisor/dist/index.js

@@ -1,8 +1,7 @@
 import { randomUUID } from "node:crypto";
-import { spawn } from "node:child_process";
-import { capabilityFor, controlStream, evaluateMetric, goalStream, interruptedSessionEvents, memoryStream, wakeStream, } from "goah-ledger-contract";
+import { assertAgentHandoff, assertHandoff, assertTurnOutput, goalStream, goalRoute, goalExecutionBinding, goalTurnBinding, humanInboxRoute, humanRequestRoute, humanBinding, humanTurnBinding, specialistBinding, specialistTurnBinding, memoryStream, wakeStream, } from "goah-ledger-contract";
 import { composeActiveContext, selectRecoveryEvents, selectWorkingMemory } from "./context-view.js";
-import { defaultRolePrompt } from "./roles.js";
+import { defaultTurnPrompt } from "./roles.js";
 export { composeActiveContext, selectRecoveryEvents } from "./context-view.js";
 /** Dispatches each wake to the runner selected by its opaque Runner Profile. */
 export class RunnerRouter {
@@ -24,12 +23,13 @@ export class RunnerRouter {
         const handle = runner.prepare(request);
         if (handle.pid)
             this.#byPid.set(handle.pid, runner);
-        void handle.result.finally(() => { if (handle.pid)
+        void handle.result.then(() => { if (handle.pid)
+            this.#byPid.delete(handle.pid); }, () => { if (handle.pid)
             this.#byPid.delete(handle.pid); });
         return handle;
     }
-    async terminateProcess(pid) {
-        const runner = this.#byPid.get(pid);
+    async terminateProcess(pid, runnerProfileId) {
+        const runner = this.#byPid.get(pid) ?? this.runners.get(runnerProfileId ?? this.fallback);
         if (!runner)
             return;
         await runner.terminateProcess(pid);
@@ -40,19 +40,17 @@ export class Supervisor {
     clock;
     #leaseMs;
     #memoryTailChars;
-    #allowExternalActions;
-    #approvers;
-    #auditWriters;
     #claimTail = Promise.resolve();
-    #connectors = new Map();
-    #metricCollectors = new Map();
-    #metricContracts = new Map();
-    #silence;
+    #humanTail = Promise.resolve();
     #retryPolicy;
+    #turnRetryPolicy;
     #profiles;
     #runnerProfiles;
     #handles = new Map();
-    #verifyMetricsAfterWake;
+    #executions = new Map();
+    #agentExecutions = new Map();
+    #handoffValidations = new Map();
+    #handoffAttemptSeq = new Map();
     #runner;
     constructor(ledger, runner, clock, options = {}) {
         this.ledger = ledger;
@@ -60,31 +58,25 @@ export class Supervisor {
         this.#runner = runner;
         this.#leaseMs = options.leaseMs ?? 30_000;
         this.#memoryTailChars = options.memoryTailChars ?? 12_000;
-        this.#allowExternalActions = options.allowExternalActions ?? false;
-        this.#approvers = new Set(options.approvers ?? ["human", "ceo"]);
-        this.#auditWriters = new Set(options.auditWriters ?? ["verifier", "audit"]);
-        this.#silence = options.silence === null ? null : { maxSilentMs: options.silence?.maxSilentMs ?? 12 * 3_600_000, notify: options.silence?.notify ?? "ceo" };
         this.#retryPolicy = options.retryPolicy ?? { maxAttempts: 0, baseDelayMs: 1_000 };
+        this.#turnRetryPolicy = options.turnRetryPolicy ?? { maxAttempts: 3, baseDelayMs: 1_000 };
+        for (const profile of options.profiles ?? []) {
+            if (profile.agent === "ceo" && profile.role !== "ceo" || profile.agent !== "ceo" && profile.role === "ceo")
+                throw new Error("exactly the ceo Agent must use the ceo role");
+        }
         this.#profiles = new Map([["ceo", { agent: "ceo", role: "ceo" }], ...(options.profiles ?? []).map((profile) => [profile.agent, profile])]);
         this.#runnerProfiles = new Map((options.runnerProfiles ?? []).map((profile) => [profile.id, profile]));
-        this.#verifyMetricsAfterWake = options.verifyMetricsAfterWake ?? false;
-    }
-    registerConnector(connector) { this.#connectors.set(connector.manifest.connector, connector); }
-    registerMetricContract(goalId, contract) { this.#metricContracts.set(goalId, contract); }
-    registerMetricCollector(goalId, contract, spec, intervalMs = 60_000) {
-        this.registerMetricContract(goalId, contract);
-        this.#metricCollectors.set(goalId, { goalId, contract, spec, intervalMs, nextAt: 0 });
     }
     /**
-     * Hot-swap the runner after a config reload. Refused while a wake is leased
-     * or running: a live child must never observe its runner vanish mid-flight.
-     * The next tick claims wakes through the new runner, and spawn-time env
+     * Hot-swap the runner after a config reload. Refused while a Turn is active:
+     * a live child must never observe its runner vanish mid-flight.
+     * The next Turn uses the new runner, and spawn-time env
      * resolution applies the new credentials to the next spawn.
      */
     swapRunner(runner, profiles) {
-        const active = this.ledger.wakes().filter((wake) => wake.status === "leased" || wake.status === "running");
+        const active = this.ledger.turns().filter((turn) => turn.status === "in_progress");
         if (active.length > 0)
-            throw new Error("cannot swap runner while a wake is leased or running");
+            throw new Error("cannot swap runner while a Turn is in progress");
         this.#runner = runner;
         if (profiles) {
             this.#runnerProfiles.clear();
@@ -93,48 +85,330 @@ export class Supervisor {
         }
     }
     get runner() { return this.#runner; }
-    createGoal(goal, actor = "human") { this.ledger.putGoal(goal, actor); }
-    createRootGoal(objective, id = randomUUID()) {
+    createGoal(goal, actor = "human") { if (!this.#validGoalOwner(goal.owner, goal))
+        throw new Error("Goal owner role does not match Root/Child position"); if (goal.parentId === null && this.ledger.goals().some((candidate) => candidate.id !== goal.id && candidate.parentId === null && candidate.phase !== "complete"))
+        throw new Error("CEO already has an unfinished Root Goal"); this.ledger.putGoal(goal, actor); }
+    createRootGoal(objective, id = randomUUID(), sourceTurnId) {
         if (!objective.trim())
             throw new Error("root objective is required");
         if (this.ledger.goals().some((goal) => goal.parentId === null && goal.owner === "ceo" && goal.phase !== "complete"))
             throw new Error("CEO already has an unfinished Root Goal; use work_on_goal");
         const goal = { id, parentId: null, objective, observationMethod: null, verificationMethod: null, owner: "ceo", phase: "active", revision: 0 };
-        this.ledger.putGoal(goal, "human");
+        this.ledger.putGoal(goal, "human", undefined, { operation: "create", reason: "Human established a durable Root Goal", evidence: [], authority: { kind: "human" }, ...(sourceTurnId ? { sourceTurnId } : {}) });
         return this.#goal(id);
     }
     startGoal(objective, id = randomUUID()) {
         const goal = this.createRootGoal(objective, id);
-        const wake = this.#enqueueTrigger("ceo", `root:${id}:created`);
+        const wake = this.#enqueueTrigger("ceo", `root:${id}:created`, { goalId: goal.id });
         if (!wake)
             throw new Error("CEO wake was not admitted for an active root goal");
         return { goal, wake };
     }
-    interactWithCeo(message) {
+    threadFor(agent = "ceo") {
+        const parentThreadId = agent === "ceo" ? null : this.threadFor("ceo").id;
+        const existing = this.ledger.threads().find((thread) => thread.agent === agent && thread.parentThreadId === parentThreadId);
+        if (existing)
+            return existing;
+        const now = this.#now();
+        const thread = { id: randomUUID(), agent, parentThreadId, createdAt: now, updatedAt: now };
+        this.ledger.putThread(thread, "supervisor");
+        return thread;
+    }
+    async startHumanTurn(message) {
+        const previous = this.#humanTail;
+        let release;
+        this.#humanTail = new Promise((resolve) => { release = resolve; });
+        await previous;
+        try {
+            return await this.#startHumanTurn(message);
+        }
+        finally {
+            release();
+        }
+    }
+    async #startHumanTurn(message) {
         if (!message.trim())
             throw new Error("message is required");
-        const mail = { id: randomUUID(), to: "ceo", from: "human", level: "fyi", body: { type: "interaction", message }, readAt: null };
-        this.ledger.putMail(mail, "human");
-        const wake = this.#enqueueTrigger("ceo", `interaction:${mail.id}`);
-        if (!wake)
-            throw new Error("CEO interaction was not admitted");
-        return { mail, wake };
+        const thread = this.threadFor("ceo");
+        const active = this.ledger.activeTurn(thread.id);
+        if (active) {
+            if (active.source !== "human") {
+                const goalId = active.goalId;
+                await this.interruptTurn(active.id);
+                if (goalId) {
+                    const goal = this.ledger.goal(goalId);
+                    if (goal?.phase === "active")
+                        this.#enqueueTrigger(goal.owner, `human-interrupted:${active.id}`, { goalId: goal.id });
+                }
+            }
+            else {
+                const handle = this.#handles.get(active.id);
+                if (handle && !handle.steer)
+                    await this.interruptTurn(active.id);
+                else if (handle?.steer) {
+                    const item = this.#appendTurnItem(active.id, "user_message", { text: message }, "human", randomUUID(), "in_progress");
+                    try {
+                        await handle.steer(message);
+                        const stored = this.ledger.turnItems(active.id).find((candidate) => candidate.id === item.id);
+                        if (this.ledger.turn(active.id)?.status === "in_progress" && stored?.status === "in_progress") {
+                            this.ledger.putTurnItem({ ...stored, status: "completed", completedAt: this.#now() }, "human");
+                            return { threadId: thread.id, turnId: active.id, steered: true };
+                        }
+                    }
+                    catch {
+                        const stored = this.ledger.turnItems(active.id).find((candidate) => candidate.id === item.id);
+                        if (this.ledger.turn(active.id)?.status === "in_progress" && stored?.status === "in_progress")
+                            this.ledger.putTurnItem({ ...stored, status: "failed", completedAt: this.#now() }, "human");
+                        if (this.ledger.turn(active.id)?.status === "in_progress")
+                            await this.interruptTurn(active.id);
+                    }
+                }
+                else {
+                    this.#appendTurnItem(active.id, "user_message", { text: message }, "human");
+                    return { threadId: thread.id, turnId: active.id, steered: true };
+                }
+            }
+        }
+        await this.#awaitAgentExecution("ceo");
+        if (this.ledger.activeTurn(thread.id))
+            return this.#startHumanTurn(message);
+        const now = this.#now();
+        this.ledger.putThread({ ...thread, updatedAt: now }, "supervisor");
+        const leaseToken = randomUUID();
+        const turn = { id: randomUUID(), threadId: thread.id, source: "human", ...humanTurnBinding(), status: "in_progress", attempt: 1, error: null, startedAt: now, endedAt: null, leaseUntil: new Date(this.clock.now().getTime() + this.#leaseMs).toISOString(), leaseToken, runnerPid: null, runnerProfileId: this.#runnerProfileId("ceo") };
+        this.ledger.putTurn(turn, "human");
+        this.#appendTurnItem(turn.id, "user_message", { text: message }, "human");
+        const context = { source: { kind: "human" } };
+        const deliveredMail = this.#contextMail(humanBinding());
+        void this.#trackExecution(turn, "ceo", context, () => this.#humanContext(turn.id, "ceo", deliveredMail), null, deliveredMail.map((mail) => mail.id));
+        return { threadId: thread.id, turnId: turn.id, steered: false };
+    }
+    async interruptTurn(turnId) {
+        const turn = this.ledger.turn(turnId);
+        if (!turn || turn.status !== "in_progress")
+            throw new Error("active Turn not found");
+        this.#clearHandoffState(turn.id);
+        this.ledger.finishTurn(turn.id, "interrupted", { message: "interrupted by Human" }, this.#now(), "human");
+        const handle = this.#handles.get(turn.id);
+        try {
+            await handle?.terminate();
+        }
+        catch (error) {
+            this.#recordCleanupFailure(turn.id, error);
+        }
+        finally {
+            this.#handles.delete(turn.id);
+        }
+        await this.#executions.get(turn.id);
+        return this.ledger.turn(turn.id);
+    }
+    async #executeTurn(initial, agent, turnContext, contextFactory, sourceWake = null, deliveredMailIds = [], recordRevisionAtStart = -1, sourceWakeTriggers = []) {
+        while (this.ledger.turn(initial.id)?.status === "in_progress") {
+            const execution = this.ledger.turn(initial.id);
+            const leaseToken = execution.leaseToken;
+            let handle = null;
+            let renewal = null;
+            try {
+                handle = this.runner.prepare({ agent, execution, ...(sourceWake ? { sourceWake, sourceWakeTriggers } : {}), turn: turnContext, context: contextFactory(), now: () => this.#now(), emit: (trace) => this.#recordTurnTrace(initial.id, leaseToken, trace.type, trace.data, agent), rpc: (method, params) => this.#agentRpcForTurn(initial.id, agent, turnContext, method, params, sourceWake?.id) });
+                this.#handles.set(initial.id, handle);
+                if (handle.pid)
+                    this.ledger.attachTurnProcess(initial.id, leaseToken, handle.pid);
+                renewal = setInterval(() => { try {
+                    this.ledger.renewTurnLease(initial.id, leaseToken, new Date(this.clock.now().getTime() + this.#leaseMs).toISOString(), this.#now());
+                }
+                catch {
+                    void this.#terminateHandle(initial.id, handle);
+                } }, Math.max(25, Math.floor(this.#leaseMs / 3)));
+                renewal.unref();
+                handle.begin();
+                const result = await handle.result;
+                if (renewal)
+                    clearInterval(renewal);
+                renewal = null;
+                await this.#terminateHandle(initial.id, handle);
+                this.#handles.delete(initial.id);
+                const current = this.ledger.turn(initial.id);
+                if (!current || current.status !== "in_progress")
+                    return;
+                if (current.attempt > 1)
+                    this.ledger.appendEvent({ streamId: `turn:${current.id}`, ts: this.#now(), actor: "supervisor", type: "turn.retry_finished", data: { attempt: current.attempt, outcome: result.outcome }, ignorable: true });
+                if (result.outcome !== "abnormal")
+                    this.#closeStreamingItems(current.id);
+                if (result.outcome === "abnormal") {
+                    if (current.attempt < this.#turnRetryPolicy.maxAttempts) {
+                        this.ledger.repairTurnAttempt(current.id, result.reason, this.#now(), "supervisor");
+                        this.ledger.appendEvent({ streamId: `turn:${current.id}`, ts: this.#now(), actor: "supervisor", type: "turn.retry_started", data: { attempt: current.attempt + 1, reason: result.reason }, ignorable: true });
+                        this.ledger.putTurn({ ...current, attempt: current.attempt + 1, leaseUntil: new Date(this.clock.now().getTime() + this.#leaseMs).toISOString(), runnerPid: null }, "supervisor");
+                        await new Promise((resolve) => setTimeout(resolve, this.#turnRetryPolicy.baseDelayMs * 2 ** (current.attempt - 1)));
+                        continue;
+                    }
+                    this.#failTurn(current.id, result.reason);
+                    this.#scheduleTurnRecovery(sourceWake, sourceWakeTriggers, current.id, agent);
+                    return;
+                }
+                if (turnContext.goalBinding) {
+                    if (result.outcome !== "handoff")
+                        throw new Error("Goal-bound Turn requires Handoff");
+                    this.#commitGoalTurn(current.id, agent, turnContext, result.output, sourceWake?.id ?? null, deliveredMailIds, recordRevisionAtStart);
+                    return;
+                }
+                if (result.outcome !== "response")
+                    throw new Error("ordinary Turn cannot finish with Handoff");
+                if (!this.ledger.turnItems(current.id).some((item) => item.type === "assistant_message" && item.data.text === result.response.content))
+                    this.#appendTurnItem(current.id, "assistant_message", { text: result.response.content }, agent);
+                this.ledger.finishTurn(current.id, "completed", null, this.#now(), "supervisor", deliveredMailIds);
+                return;
+            }
+            catch (error) {
+                if (renewal)
+                    clearInterval(renewal);
+                if (handle)
+                    await this.#terminateHandle(initial.id, handle);
+                this.#handles.delete(initial.id);
+                const current = this.ledger.turn(initial.id);
+                if (current?.status === "in_progress") {
+                    this.#failTurn(current.id, error instanceof Error ? error.message : String(error));
+                    this.#scheduleTurnRecovery(sourceWake, sourceWakeTriggers, current.id, agent);
+                }
+                return;
+            }
+        }
+    }
+    #trackExecution(initial, agent, turnContext, contextFactory, sourceWake = null, deliveredMailIds = [], recordRevisionAtStart = -1, sourceWakeTriggers = []) { const running = this.#executeTurn(initial, agent, turnContext, contextFactory, sourceWake, deliveredMailIds, recordRevisionAtStart, sourceWakeTriggers); this.#executions.set(initial.id, running); this.#agentExecutions.set(agent, running); void running.finally(() => { if (this.#executions.get(initial.id) === running)
+        this.#executions.delete(initial.id); if (this.#agentExecutions.get(agent) === running)
+        this.#agentExecutions.delete(agent); }); return running; }
+    async #awaitAgentExecution(agent) { const running = this.#agentExecutions.get(agent); if (running)
+        await running; }
+    #humanContext(turnId, agent, mail) {
+        const turn = this.ledger.turn(turnId);
+        const current = this.#turnHistory(turn.id);
+        const turnSourceSeqs = this.ledger.readStream(`turn:${turn.id}`).filter((event) => event.type === "item.user_message.started").map((event) => event.seq);
+        if (turn.bindingKind === "goal") {
+            const context = { source: { kind: "human" }, goalBinding: { goalId: turn.goalId, goalRevision: turn.goalRevision } };
+            const base = this.#loadContext({ ...goalExecutionBinding(agent, turn.goalId), attempt: turn.attempt }, context, mail, []);
+            const sourceSeqs = Array.isArray(base.sourceSeqs) ? base.sourceSeqs.filter((value) => typeof value === "number") : [];
+            return { ...base, text: `${String(base.text ?? "")}\n\n# Current Turn\n\n${current}`, sourceSeqs: [...new Set([...sourceSeqs, ...turnSourceSeqs])].sort((a, b) => a - b) };
+        }
+        const profile = this.#profiles.get(agent) ?? { agent, role: "ceo" };
+        const runnerProfile = this.#runnerProfiles.get(profile.runnerProfile ?? "default");
+        const recent = this.ledger.turns(turn.threadId).filter((candidate) => candidate.id !== turn.id && candidate.status === "completed").slice(-8).flatMap((candidate) => this.ledger.turnItems(candidate.id).filter((item) => item.type === "user_message" || item.type === "assistant_message").map((item) => `${item.type === "user_message" ? "Human" : "Assistant"}: ${String(item.data.text ?? "")}`));
+        const sourceSeqs = [...turnSourceSeqs, ...this.#mailSourceSeqs(mail)];
+        const incoming = mail.map((item) => `- [${item.level}] ${item.id} from ${item.from}: ${boundedJson(item.body)}`);
+        const context = { source: { kind: "human" } };
+        return { text: [...(recent.length ? [`# Recent conversation\n\n${recent.join("\n")}`] : []), ...(incoming.length ? [`# Incoming\n\n${incoming.join("\n")}`] : []), `# Current Turn\n\n${current}`].join("\n\n"), sourceSeqs, capabilities: profile.capabilities ?? defaultCapabilities(profile.role), systemPrompt: profile.systemPrompt ?? defaultTurnPrompt(profile.role, agent, context), ...(runnerProfile ? { runnerProfile } : {}) };
+    }
+    #goalContext(wake, turn, turnId, mail, wakeTriggers) { const base = this.#loadContext(wake, turn, mail, wakeTriggers); if (!base || typeof base !== "object" || Array.isArray(base))
+        return base; const value = base; const history = this.#turnHistory(turnId); return { ...value, ...(history ? { text: `${String(value.text ?? "")}\n\n# Current Turn retry history\n\n${history}` } : {}) }; }
+    #threadAgent(threadId) { const thread = this.ledger.thread(threadId); if (!thread)
+        throw new Error("Turn Thread not found"); return thread.agent; }
+    #turnHistory(turnId) { const items = this.ledger.turnItems(turnId).map((item) => { const data = item.data; if (item.type === "user_message")
+        return `Human: ${String(data.text ?? "")}`; if (item.type === "assistant_message")
+        return `Assistant: ${String(data.text ?? "")}`; if (item.type === "tool_call")
+        return `Tool call: ${String(data.tool ?? "")} ${JSON.stringify(item.data)}`; if (item.type === "tool_result")
+        return `Tool result: ${JSON.stringify(data.result ?? item.data)}`; return `${item.type}: ${JSON.stringify(item.data)}`; }); const facts = this.ledger.readStream(`turn:${turnId}`).filter((event) => event.type === "turn.retry_started").map((event) => `${event.type}: ${JSON.stringify(event.data)}`); return [...items, ...facts].join("\n"); }
+    #failTurn(turnId, reason) { const current = this.ledger.turn(turnId); if (!current || current.status !== "in_progress")
+        return; this.#clearHandoffState(turnId); this.ledger.finishTurn(turnId, "failed", { message: reason }, this.#now(), "supervisor"); }
+    #preemptGoalTurn(goalId, reason) { const turn = this.ledger.turns().find((candidate) => candidate.status === "in_progress" && candidate.bindingKind === "goal" && candidate.goalId === goalId); if (!turn)
+        return; this.#clearHandoffState(turn.id); this.ledger.finishTurn(turn.id, "interrupted", { message: reason }, this.#now(), "supervisor"); const handle = this.#handles.get(turn.id); if (handle)
+        void this.#terminateHandle(turn.id, handle).finally(() => this.#handles.delete(turn.id)); }
+    async #terminateHandle(turnId, handle) { try {
+        await handle.terminate();
+    }
+    catch (error) {
+        this.#recordCleanupFailure(turnId, error);
+    } }
+    #recordCleanupFailure(turnId, error) { this.ledger.appendEvent({ streamId: `turn:${turnId}`, ts: this.#now(), actor: "supervisor", type: "runner.cleanup_failed", data: { message: error instanceof Error ? error.message : String(error) }, ignorable: true }); }
+    #scheduleTurnRecovery(sourceWake, triggers, turnId, agent) { if (!sourceWake)
+        return; const turn = this.ledger.turn(turnId); if (!turn)
+        return; const role = this.#role(agent); const goal = turn.bindingKind === "goal" ? this.ledger.goal(turn.goalId) : null; if (turn.bindingKind === "human" || turn.bindingKind === "goal" && (!goal || goal.phase !== "active" || goal.owner !== agent) || turn.bindingKind === "specialist" && role !== turn.specialistRole)
+        return; const prior = Math.max(0, ...triggers.map((trigger) => parseRecoveryTrigger(trigger.triggerRef)?.attempt ?? 0)); const next = prior + 1; if (next < this.#retryPolicy.maxAttempts) {
+        const delay = this.#retryPolicy.baseDelayMs * 2 ** prior;
+        const binding = turn.bindingKind === "goal" ? goalExecutionBinding(agent, turn.goalId) : specialistBinding(agent, turn.specialistRole);
+        this.ledger.putSchedule({ id: recoveryScheduleId(turnId, next), ...binding, nextWakeAt: new Date(this.clock.now().getTime() + delay).toISOString(), reason: recoveryRef(turnId), setBy: "supervisor", status: "pending", resolvedAt: null }, "supervisor", sourceWake.id);
+    }
+    else if (role === "child" && goal?.parentId) {
+        const parent = this.ledger.goal(goal.parentId);
+        if (parent?.phase === "active")
+            this.#enqueueTrigger(parent.owner, childRetryExhaustedRef(turnId), { goalId: parent.id });
+    } }
+    #closeStreamingItems(turnId) { const open = this.ledger.turnItems(turnId).filter((item) => item.status === "in_progress"); if (open.some((item) => item.type === "tool_call" || item.type === "user_message"))
+        throw new Error("Runner returned while an input or tool call was still open"); for (const item of open)
+        this.ledger.putTurnItem({ ...item, status: "completed", completedAt: this.#now() }, "supervisor"); }
+    #appendTurnItem(turnId, type, data, actor, id = randomUUID(), status = "completed") {
+        const now = this.#now();
+        const item = { id, turnId, ordinal: this.ledger.turnItems(turnId).length + 1, type, status, data, createdAt: now, completedAt: status === "in_progress" ? null : now };
+        this.ledger.putTurnItem(item, actor);
+        return item;
+    }
+    #recordTurnTrace(turnId, leaseToken, type, data, actor = "ceo") {
+        if (type === "transcript.completed" || type === "transcript.interrupted")
+            return;
+        if (type === "transcript.started" && this.ledger.readStream(`turn:${turnId}`).some((event) => event.type === "transcript.started"))
+            return;
+        this.ledger.appendTurnEvent({ streamId: `turn:${turnId}`, ts: this.#now(), actor, type, data }, leaseToken);
+        if (type === "message.assistant.completed") {
+            const value = data && typeof data === "object" && !Array.isArray(data) ? data : {};
+            if (!["ordinary", "handoff"].includes(String(value.completionIntent)) || value.commitState !== (value.completionIntent === "handoff" ? "provisional" : "committed"))
+                throw new Error("Runner assistant completion is missing normalized intent/state");
+            const text = messageTextContent(value.message?.content);
+            if (text)
+                this.#appendTurnItem(turnId, "assistant_message", { text }, actor);
+        }
+        else if (type === "plan.updated")
+            this.#appendTurnItem(turnId, "plan", data, actor);
+        else if (type === "message.assistant.delta") {
+            const input = data;
+            const delta = input.delta;
+            if (delta?.type === "thinking_start" || delta?.type === "thinking_delta" || delta?.type === "thinking_end") {
+                const turn = this.ledger.turn(turnId);
+                const id = `${turnId}:attempt:${turn.attempt}:reasoning:${String(input.messageId ?? "message")}`;
+                const existing = this.ledger.turnItems(turnId).find((item) => item.id === id);
+                const text = `${String(existing?.data?.text ?? "")}${delta.type === "thinking_delta" ? String(delta.delta ?? "") : ""}`;
+                if (!existing)
+                    this.#appendTurnItem(turnId, "reasoning", { text }, actor, id, delta.type === "thinking_end" ? "completed" : "in_progress");
+                else
+                    this.ledger.putTurnItem({ ...existing, data: { text }, status: delta.type === "thinking_end" ? "completed" : "in_progress", completedAt: delta.type === "thinking_end" ? this.#now() : null }, actor);
+            }
+        }
+        else if (type === "tool.called") {
+            const input = data;
+            const turn = this.ledger.turn(turnId);
+            const id = `${turnId}:attempt:${turn.attempt}:tool:${String(input.callId)}`;
+            if (this.ledger.turnItems(turnId).some((item) => item.id === id))
+                throw new Error("duplicate tool call id in Turn attempt");
+            this.#appendTurnItem(turnId, "tool_call", { callId: String(input.callId), tool: String(input.name), arguments: input.arguments ?? null }, actor, id, "in_progress");
+        }
+        else if (type === "tool.completed") {
+            const input = data;
+            const turn = this.ledger.turn(turnId);
+            const id = `${turnId}:attempt:${turn.attempt}:tool:${String(input.callId)}`;
+            const existing = this.ledger.turnItems(turnId).find((item) => item.id === id);
+            if (!existing)
+                throw new Error("tool result has no matching call in Turn attempt");
+            this.ledger.putTurnItem({ ...existing, status: input.isError ? "failed" : "completed", completedAt: this.#now() }, actor);
+            this.#appendTurnItem(turnId, "tool_result", { callId: String(input.callId), result: input.result ?? null }, actor);
+        }
     }
     sendToCeo(body, level = "decision") {
-        const mail = { id: randomUUID(), to: "ceo", from: "human", level, body, readAt: null };
+        const mail = { id: randomUUID(), to: "ceo", from: "human", level, ...humanInboxRoute(), body, readAt: null };
         this.ledger.putMail(mail, "human");
         const wake = this.#enqueueTrigger("ceo", `mail:${mail.id}`);
         if (!wake)
             throw new Error("CEO wake was not admitted");
         return { mail, wake };
     }
-    delegate(request, actor = "ceo", wakeId) { return this.ledger.commitDelegation(request, actor, wakeId); }
-    reassignGoal(request, actor = "ceo", wakeId) { return this.ledger.commitReassignment(request, actor, wakeId); }
+    delegate(request, actor = "ceo", wakeId) { const candidate = { ...request.childGoal, parentId: request.parentGoalId, phase: "active", revision: 0 }; if (!this.#validGoalOwner(candidate.owner, candidate))
+        throw new Error("Child Goal owner must use a Child Agent profile"); return this.ledger.commitDelegation(request, actor, wakeId); }
+    async reassignGoal(request, actor = "ceo", wakeId) { const goal = this.#goal(request.goalId); if (!this.#validGoalOwner(request.newOwner, { ...goal, owner: request.newOwner }))
+        throw new Error("Child Goal owner must use a Child Agent profile"); const thread = this.ledger.threads().find((candidate) => candidate.agent === goal.owner); const active = thread ? this.ledger.activeTurn(thread.id) : null; if (active?.bindingKind === "goal" && active.goalId === goal.id)
+        await this.interruptTurn(active.id); return this.ledger.commitReassignment(request, actor, wakeId); }
     teamList(now = this.#now()) { return deriveTeam(this.ledger, now); }
-    updateGoal(id, patch, actor = "human") {
-        if (patch.objective === undefined && patch.observationMethod === undefined && patch.verificationMethod === undefined && patch.owner === undefined)
-            throw new Error("goal update requires objective, observation method, verification method, or owner");
+    agentRole(agent) { return this.#role(agent); }
+    updateGoal(id, patch, actor = "human", change) {
+        if (patch.objective === undefined && patch.observationMethod === undefined && patch.verificationMethod === undefined)
+            throw new Error("goal update requires objective, observation method, or verification method");
         const current = this.#goal(id);
+        this.#assertGoalMutationAuthority(current, actor);
         if (patch.objective !== undefined && patch.objective !== current.objective && current.parentId !== null && (patch.observationMethod === undefined || patch.verificationMethod === undefined))
             throw new Error("child objective revision requires replacement observation and verification methods");
         const next = {
@@ -144,18 +418,19 @@ export class Supervisor {
             ...(patch.objective !== undefined && patch.objective !== current.objective && current.parentId === null && patch.verificationMethod === undefined ? { verificationMethod: null } : {}),
             revision: current.revision + 1,
         };
-        this.ledger.putGoal(next, actor);
+        this.#preemptGoalTurn(current.id, "Goal definition changed");
+        this.ledger.putGoal(next, actor, change?.sourceWakeId, { operation: "revise", reason: change?.reason ?? "Goal definition revised", evidence: change?.evidence ?? [], ...(change?.sourceTurnId ? { sourceTurnId: change.sourceTurnId } : {}), ...(change?.sourceWakeId ? { sourceWakeId: change.sourceWakeId } : {}) });
         if (next.parentId === null && next.owner === "ceo" && actor === "human")
-            this.#enqueueTrigger("ceo", `root:${id}:revised:${next.revision}`);
+            this.#enqueueTrigger("ceo", `root:${id}:revised:${next.revision}`, { goalId: next.id });
         return next;
     }
     confirmObservationMethod(id, observationMethod) {
         const current = this.#goal(id);
         if (current.parentId !== null)
             throw new Error("human confirmation applies only to a root goal");
-        return this.updateGoal(id, { observationMethod, verificationMethod: observationMethod }, "human");
+        return this.updateGoal(id, { observationMethod, verificationMethod: observationMethod }, "human", { reason: "Human confirmed the Root observation and verification method", evidence: [] });
     }
-    reviseChildGoal(id, objective, observationMethod, verificationMethod, actor, reason, evidence, wakeId) {
+    reviseChildGoal(id, objective, observationMethod, verificationMethod, actor, reason, evidence, wakeId, sourceTurnId) {
         const current = this.#goal(id);
         if (current.parentId === null)
             throw new Error("CEO cannot revise a root goal");
@@ -165,143 +440,119 @@ export class Supervisor {
             if (!this.ledger.eventsSince(seq - 1).some((event) => event.seq === seq))
                 throw new Error(`evidence event does not exist: ${seq}`);
         this.ledger.appendEvent({ streamId: wakeId ? wakeStream(wakeId) : goalStream(id), ts: this.#now(), actor, type: "goal.revision_requested", data: { goalId: id, fromRevision: current.revision, objective, observationMethod, verificationMethod, reason, evidence } });
-        return this.updateGoal(id, { objective, observationMethod, verificationMethod }, actor);
+        return this.updateGoal(id, { objective, observationMethod, verificationMethod }, actor, { reason, evidence, ...(wakeId ? { sourceWakeId: wakeId } : {}), ...(sourceTurnId ? { sourceTurnId } : {}) });
     }
     completeGoal(request, actor = "human", wakeId) {
         const goal = this.ledger.completeGoal(request, actor, wakeId);
-        this.#suppressQueuedWake(goal.owner, `goal:${goal.id}:complete`);
-        if (goal.parentId && actor !== "ceo")
-            this.#enqueueTrigger("ceo", `goal:${goal.id}:complete:${goal.revision}`);
+        this.#preemptGoalTurn(goal.id, "Goal completed");
         return goal;
     }
-    transitionGoal(id, phase, actor = "human") {
+    transitionGoal(id, phase, actor = "human", scheduleMotion = true, sourceTurnId) {
         const current = this.#goal(id);
+        this.#assertGoalMutationAuthority(current, actor);
         if (current.phase === phase)
             return current;
         if (phase === "complete")
             throw new Error("goal completion requires reason and evidence");
         const next = { ...current, phase, revision: current.revision + 1 };
-        this.ledger.putGoal(next, actor);
-        if (phase === "paused")
-            this.#suppressQueuedWake(next.owner, `goal:${id}:${phase}`);
-        if (phase === "active")
-            this.#enqueueTrigger(next.owner, `${next.parentId ? "goal" : "root"}:${id}:resumed:${next.revision}`);
-        if (next.parentId && actor !== "ceo" && phase === "blocked")
-            this.#enqueueTrigger("ceo", `goal:${id}:${phase}:${next.revision}`);
+        const operation = phase === "paused" ? "pause" : phase === "blocked" ? "block" : "resume";
+        this.#preemptGoalTurn(current.id, `Goal ${operation}`);
+        this.ledger.putGoal(next, actor, undefined, { operation, reason: `Goal ${operation} requested by ${actor}`, evidence: [], ...(sourceTurnId ? { sourceTurnId } : {}) });
+        if (phase === "active" && scheduleMotion)
+            this.#enqueueTrigger(next.owner, `${next.parentId ? "goal" : "root"}:${id}:resumed:${next.revision}`, { goalId: next.id });
         return next;
     }
-    planWake(agent, at, reason, setBy = agent) {
-        const schedule = { id: `schedule:${agent}`, agent, nextWakeAt: at, reason, setBy };
-        this.ledger.putSchedule(schedule, setBy);
-        return at <= this.#now() ? this.#enqueueSchedule(schedule) : null;
-    }
-    async stopAgentWake(agent) {
-        const wake = this.ledger.wakes().find((item) => item.agent === agent && ["running", "leased", "queued"].includes(item.status));
-        if (!wake)
-            return null;
-        if (wake.status === "queued") {
-            this.#suppressQueuedWake(agent, "stopped by human");
-            return this.#wake(wake.id);
+    planWake(agent, at, reason, setBy = agent, target) {
+        const parsed = Date.parse(at);
+        if (!Number.isFinite(parsed))
+            throw new Error("schedule time is invalid");
+        const nextWakeAt = new Date(parsed).toISOString();
+        const binding = target ?? this.#singleActiveGoalTarget(agent);
+        const role = this.#role(agent);
+        if (!binding && role !== "verifier" && role !== "audit")
+            throw new Error("Goal-owning Agent schedules require an active Goal target");
+        if (binding) {
+            const goal = this.ledger.goal(binding.goalId);
+            if (!goal || goal.phase !== "active" || !this.#validGoalOwner(agent, goal))
+                throw new Error("schedule target is not an active Goal owned by this Agent");
         }
-        const handle = this.#handles.get(wake.id);
-        if (handle)
-            await handle.terminate();
-        else if (wake.runnerPid)
-            await this.runner.terminateProcess(wake.runnerPid);
-        return this.#wake(wake.id);
+        const executionTarget = binding ? goalExecutionBinding(agent, binding.goalId) : specialistBinding(agent, role);
+        const schedule = { id: `schedule:${agent}${binding ? `:${binding.goalId}` : ""}:${randomUUID()}`, ...executionTarget, nextWakeAt, reason, setBy, status: "pending", resolvedAt: null };
+        this.ledger.putSchedule(schedule, setBy);
+        return nextWakeAt <= this.#now() ? this.#enqueueSchedule(schedule) : null;
     }
+    async stopAgentWake(agent, goalId) { const role = this.#role(agent); if (goalId) {
+        const goal = this.#goal(goalId);
+        if (!this.#validGoalOwner(agent, goal))
+            throw new Error("Goal stop target is not owned by the Agent");
+    } const binding = role === "verifier" || role === "audit" ? null : goalId ? { goalId } : this.#singleActiveGoalTarget(agent); if (role !== "verifier" && role !== "audit" && !binding)
+        throw new Error("Goal stop requires an explicit Goal target"); const wake = this.ledger.wakes().find((item) => item.agent === agent && (item.status === "queued" || item.status === "claimed") && (binding ? item.bindingKind === "goal" && item.goalId === binding.goalId : item.bindingKind === "specialist")); if (wake)
+        this.ledger.cancelWake(wake.id, this.#now()); const thread = this.ledger.threads().find((item) => item.agent === agent); const turn = thread ? this.ledger.activeTurn(thread.id) : null; if (turn && (binding ? turn.bindingKind === "goal" && turn.goalId === binding.goalId : turn.bindingKind === "specialist"))
+        await this.interruptTurn(turn.id); return wake ? this.#wake(wake.id) : null; }
     async recover() {
-        this.ledger.recoverDispatchingActions();
-        for (const expired of this.ledger.expiredWakes(this.#now())) {
-            if (expired.status === "running" && expired.runnerPid)
-                await this.runner.terminateProcess(expired.runnerPid);
-            this.ledger.recoverExpiredWake(expired.id, this.#now());
+        for (const wake of this.ledger.wakes().filter((candidate) => candidate.status === "claimed"))
+            this.ledger.releaseWake(wake.id, this.#now());
+        for (const turn of this.ledger.turns().filter((candidate) => candidate.status === "in_progress" && !this.#handles.has(candidate.id))) {
+            if (turn.runnerPid)
+                await this.runner.terminateProcess(turn.runnerPid, turn.runnerProfileId);
+            this.#failTurn(turn.id, "orphaned Runner ownership recovered after Supervisor restart");
+            const thread = this.ledger.thread(turn.threadId);
+            if (!thread)
+                continue;
+            if (turn.bindingKind === "goal") {
+                const goal = this.ledger.goal(turn.goalId);
+                if (goal?.phase === "active" && goal.owner === thread.agent)
+                    this.#enqueueTrigger(thread.agent, recoveryRef(turn.id), { goalId: goal.id });
+            }
+            else if (turn.bindingKind === "specialist" && this.#role(thread.agent) === turn.specialistRole)
+                this.#enqueueTrigger(thread.agent, recoveryRef(turn.id));
         }
     }
     async tick() {
-        const claimed = await this.#claimNextWake();
-        const wake = claimed?.wake ?? null;
+        const wake = await this.#claimNextWake();
         if (!wake)
             return null;
-        const leaseToken = claimed.leaseToken;
-        let running = wake;
-        let handle = null;
-        let renewal;
+        let createdTurnId = null;
         try {
-            running = this.ledger.markWakeRunning(wake.id, this.#now(), leaseToken);
-            const turn = this.#turnContext(running);
-            this.ledger.appendRunnerEvent({ streamId: wakeStream(running.id), ts: this.#now(), actor: running.agent, type: "run.admitted", data: turn }, leaseToken);
-            const workRecordRevisionAtStart = turn.goalBinding ? this.ledger.workRecord(turn.goalBinding.goalId)?.recordRevision ?? -1 : -1;
-            const context = this.#loadContext(running, turn);
-            handle = this.runner.prepare({
-                wake: running,
-                turn,
-                context,
-                now: () => this.#now(),
-                emit: (trace) => this.ledger.appendRunnerEvent({ streamId: wakeStream(running.id), ts: this.#now(), actor: running.agent, type: trace.type, data: trace.data }, leaseToken),
-                rpc: (method, params) => this.#agentRpc(running, turn, leaseToken, method, params),
-            });
-            this.#handles.set(running.id, handle);
-            if (handle.pid)
-                running = this.ledger.attachWakeProcess(running.id, leaseToken, handle.pid, this.#now());
-            renewal = setInterval(() => {
-                try {
-                    const now = this.clock.now();
-                    this.ledger.renewWakeLease(running.id, leaseToken, new Date(now.getTime() + this.#leaseMs).toISOString(), now.toISOString());
+            await this.#awaitAgentExecution(wake.agent);
+            const currentWake = this.#wake(wake.id);
+            if (currentWake.status !== "claimed")
+                return currentWake;
+            if (currentWake.bindingKind === "goal") {
+                const goal = this.ledger.goal(currentWake.goalId);
+                if (!goal || goal.owner !== currentWake.agent || goal.phase !== "active" || !this.#validGoalOwner(currentWake.agent, goal)) {
+                    this.ledger.cancelWake(currentWake.id, this.#now());
+                    return this.#wake(currentWake.id);
                 }
-                catch {
-                    void handle?.terminate();
-                }
-            }, Math.max(25, Math.floor(this.#leaseMs / 3)));
-            renewal.unref();
-            handle.begin();
-            const result = await handle.result;
-            clearInterval(renewal);
-            renewal = undefined;
-            await handle.terminate();
-            this.#handles.delete(running.id);
-            if (result.outcome === "abnormal") {
-                await this.#markAbnormal(running, result.reason);
-                return this.#wake(running.id);
-            }
-            if (result.outcome === "response") {
-                if (turn.goalBinding)
-                    throw new Error("a Goal-bound Turn must finish with a handoff");
-                const mailId = interactionMailId(running);
-                if (!mailId)
-                    throw new Error("an ordinary response requires an interaction mail");
-                this.ledger.commitInteraction({ agent: running.agent, wakeId: running.id, mailId, ts: this.#now(), response: result.response });
-                this.ledger.finishWake(running.id, "done", this.#now());
-                return this.#wake(running.id);
-            }
-            if (turn.goalBinding)
-                this.#validateGoalTurnRecord(running, turn, workRecordRevisionAtStart);
-            const output = turn.goalBinding ? this.#goalWakeOutput(result.output, turn.goalBinding) : result.output;
-            this.#validateCeoHandoff(running, output);
-            const outgoingMail = output.mail.map((draft) => ({ id: randomUUID(), to: draft.to, from: running.agent, level: draft.level, body: draft.body, readAt: null }));
-            const schedule = output.nextWakeAt
-                ? { id: `schedule:${running.agent}`, agent: running.agent, nextWakeAt: output.nextWakeAt, reason: "handoff.next_steps", setBy: running.agent }
-                : null;
-            const handoffEvent = this.ledger.commitHandoff({ agent: running.agent, wakeId: running.id, ts: this.#now(), output, outgoingMail, schedule });
-            this.ledger.finishWake(running.id, "done", this.#now());
-            if (this.#role(running.agent) !== "ceo" && handoffTriggersCeo(output.handoff) && this.#hasActiveRoot()) {
-                this.#enqueueTrigger("ceo", `child-handoff:${handoffEvent.seq}`);
             }
-            if (this.#verifyMetricsAfterWake) {
-                for (const goal of this.ledger.goalsForOwner(running.agent))
-                    if (this.#metricCollectors.has(goal.id))
-                        await this.collectMetricNow(goal.id);
+            const wakeTriggers = this.ledger.wakeTriggers(currentWake.id).filter((trigger) => trigger.status === "pending");
+            const turnContext = this.#turnContext(currentWake, wakeTriggers);
+            if (!this.#validExecution(currentWake.agent, turnContext)) {
+                this.ledger.cancelWake(currentWake.id, this.#now());
+                return this.#wake(currentWake.id);
             }
-            return this.#wake(running.id);
+            const thread = this.threadFor(currentWake.agent);
+            const now = this.#now();
+            const leaseToken = randomUUID();
+            const turnBinding = currentWake.bindingKind === "goal" ? goalTurnBinding(currentWake.goalId, turnContext.goalBinding.goalRevision) : currentWake.bindingKind === "human" ? humanTurnBinding() : specialistTurnBinding(currentWake.specialistRole);
+            const execution = { id: randomUUID(), threadId: thread.id, source: turnContext.source.kind, ...turnBinding, status: "in_progress", attempt: 1, error: null, startedAt: now, endedAt: null, leaseUntil: new Date(this.clock.now().getTime() + this.#leaseMs).toISOString(), leaseToken, runnerPid: null, runnerProfileId: this.#runnerProfileId(currentWake.agent) };
+            this.ledger.putThread({ ...thread, updatedAt: this.#now() }, "supervisor");
+            this.ledger.startTurnFromWake(currentWake.id, execution, now);
+            createdTurnId = execution.id;
+            const deliveredMail = this.#contextMail(currentWake);
+            const deliveredMailIds = deliveredMail.map((mail) => mail.id);
+            this.ledger.appendEvent({ streamId: `turn:${execution.id}`, ts: now, actor: "supervisor", type: "run.admitted", data: { ...turnContext, wakeTriggers }, ignorable: true });
+            const revision = turnContext.goalBinding ? this.ledger.workRecord(turnContext.goalBinding.goalId)?.recordRevision ?? -1 : -1;
+            await this.#trackExecution(execution, currentWake.agent, turnContext, () => this.#goalContext(currentWake, turnContext, execution.id, deliveredMail, wakeTriggers), currentWake, deliveredMailIds, revision, wakeTriggers);
+            return this.#wake(wake.id);
         }
         catch (error) {
-            if (renewal)
-                clearInterval(renewal);
-            if (handle)
-                await handle.terminate();
-            this.#handles.delete(running.id);
-            await this.#markAbnormal(running, error instanceof Error ? error.message : String(error));
-            return this.#wake(running.id);
+            if (createdTurnId && this.ledger.turn(createdTurnId)?.status === "in_progress")
+                this.#failTurn(createdTurnId, error instanceof Error ? error.message : String(error));
+            const current = this.ledger.wake(wake.id);
+            if (current?.status === "claimed")
+                this.ledger.releaseWake(wake.id, this.#now());
+            return this.#wake(wake.id);
         }
     }
     async #claimNextWake() {
@@ -312,15 +563,24 @@ export class Supervisor {
         try {
             for (const schedule of this.ledger.dueSchedules(this.#now()))
                 this.#enqueueSchedule(schedule);
-            await this.#collectMetrics();
-            this.#scheduleMetricAlerts();
-            this.#checkSystemSilence();
-            for (const mail of this.ledger.triggeringMail())
-                this.#enqueueTrigger(mail.to, `mail:${mail.id}`);
-            const now = this.clock.now();
-            const leaseToken = randomUUID();
-            const wake = this.ledger.claimNextWake(now.toISOString(), new Date(now.getTime() + this.#leaseMs).toISOString(), leaseToken);
-            return wake ? { wake, leaseToken } : null;
+            for (const mail of this.ledger.triggeringMail()) {
+                const thread = this.ledger.threads().find((candidate) => candidate.agent === mail.to);
+                if (thread && this.ledger.activeTurn(thread.id))
+                    continue;
+                const goal = mail.routeKind === "goal" ? this.ledger.goal(mail.goalId) : null;
+                const target = goal && goal.owner === mail.to && goal.phase === "active" && this.#validGoalOwner(mail.to, goal) ? { goalId: goal.id } : undefined;
+                const humanInteraction = mail.routeKind === "human_inbox" && mail.to === "ceo" && mail.from === "human";
+                const specialistInteraction = mail.routeKind === "specialist_inbox" && this.#role(mail.to) === mail.specialistRole;
+                if (!target && !humanInteraction && !specialistInteraction)
+                    continue;
+                const base = `mail:${mail.id}`;
+                const related = this.ledger.wakeTriggersForAgent(mail.to).map((trigger) => ({ trigger, attempt: mailDeliveryAttempt(trigger.triggerRef, base) })).filter((entry) => entry.attempt !== null);
+                const pending = related.filter((entry) => entry.trigger.status === "pending").sort((a, b) => b.attempt - a.attempt)[0];
+                const next = related.reduce((highest, entry) => Math.max(highest, entry.attempt), -1) + 1;
+                const trigger = pending?.trigger.triggerRef ?? (next === 0 ? base : `${base}@redelivery:${next}`);
+                this.#enqueueTrigger(mail.to, trigger, target);
+            }
+            return this.ledger.claimNextWake(this.#now());
         }
         finally {
             release();
@@ -336,129 +596,55 @@ export class Supervisor {
                 return completed;
         }
     }
-    async submitAction(action, connectorName, wakeId) {
-        const connector = this.#connectors.get(connectorName);
-        const capability = connector ? capabilityFor(connector.manifest, action.kind) : null;
-        const gated = !connector || !capability || capability.risk !== "reversible"
-            || (!connector.manifest.dryRun && !this.#allowExternalActions);
-        if (gated && action.agent !== "ceo")
-            this.#assertAgentGoalsCurrent(action.agent);
-        const requested = { ...action, connector: connectorName, gated, status: "requested", reconciledAt: null, externalRef: null };
-        this.ledger.requestAction(requested, action.agent, wakeId);
-        if (gated || !connector)
-            return this.#action(action.id);
-        this.ledger.approveAction(action.id, "supervisor", "declared reversible dry-run capability", action.evidence);
-        return this.#dispatch(action.id);
-    }
-    async approveAction(id, approver, reason, evidence) {
-        if (!this.#approvers.has(approver))
-            throw new Error("actor is not authorized to approve actions");
-        this.ledger.approveAction(id, approver, reason, evidence);
-        return this.#dispatch(id);
-    }
-    rejectAction(id, approver, reason, evidence) {
-        if (!this.#approvers.has(approver))
-            throw new Error("actor is not authorized to reject actions");
-        return this.ledger.rejectAction(id, approver, reason, evidence);
-    }
-    putAuditAdvice(id, advice, wakeId) {
-        const role = this.#profiles.get(advice.by)?.role;
-        if (!this.#auditWriters.has(advice.by) && role !== "verifier" && role !== "audit")
-            throw new Error("actor is not authorized to write audit advice");
-        return this.ledger.putAuditAdvice(id, advice, wakeId);
-    }
-    ackAuditAdvice(id, agent) { return this.ledger.ackAuditAdvice(id, agent); }
-    recordMetric(sample) {
-        const goal = this.ledger.goal(sample.goalId);
-        if (!goal)
-            throw new Error(`metric goal not found: ${sample.goalId}`);
-        const contract = this.#metricContracts.get(goal.id);
-        if (!contract)
-            throw new Error(`metric contract is not registered: ${goal.id}`);
-        if (contract.source !== sample.source)
-            throw new Error("metric source does not match registered contract");
-        this.ledger.appendEvent({ streamId: `metric:${goal.id}`, ts: this.#now(), actor: "supervisor", type: "metric.sampled", data: sample });
-        const evaluation = evaluateMetric(contract, this.ledger.metricSamples(goal.id), this.#now());
-        this.ledger.appendEvent({ streamId: `metric:${goal.id}`, ts: this.#now(), actor: "supervisor", type: "metric.evaluated", data: evaluation });
-        if (evaluation.shouldWakeOwner)
-            this.#enqueueTrigger(goal.owner, `metric:${goal.id}:${sample.observedAt}`);
-        return evaluation;
-    }
-    async collectMetricNow(goalId) {
-        const registration = this.#metricCollectors.get(goalId);
-        if (!registration)
-            throw new Error(`metric collector is not registered: ${goalId}`);
-        registration.nextAt = this.clock.now().getTime() + registration.intervalMs;
-        const sample = await runJsonProcess(registration.spec, { goalId });
-        return this.recordMetric({ ...sample, goalId });
-    }
-    async reconcileAction(id) {
-        const action = this.#action(id);
-        if (action.status !== "unknown")
-            throw new Error("only unknown actions may be reconciled");
-        const connector = this.#requiredConnector(action.connector);
-        const capability = capabilityFor(connector.manifest, action.kind);
-        if (!capability || capability.query === "none")
-            throw new Error("connector cannot reconcile this action");
-        const result = await runConnector(connector, "query", action);
-        if (result.status === "pending")
-            return action;
-        return this.ledger.transitionAction(id, result.status, { reconciledAt: this.#now(), ...(result.externalRef ? { externalRef: result.externalRef } : {}) });
-    }
-    async retryUnknownAction(id) {
-        const action = this.#action(id);
-        if (action.status !== "unknown")
-            throw new Error("only unknown actions may be retried");
-        const connector = this.#requiredConnector(action.connector);
-        const capability = capabilityFor(connector.manifest, action.kind);
-        if (!capability?.nativeIdempotency || !capability.automaticRetry)
-            throw new Error("connector manifest forbids automatic retry");
-        return this.#dispatch(id);
-    }
-    async #dispatch(id) {
-        const current = this.#action(id);
-        const connector = this.#requiredConnector(current.connector);
-        const dispatching = this.ledger.transitionAction(id, "dispatching");
-        const result = await runConnector(connector, "dispatch", dispatching);
-        return this.ledger.transitionAction(id, result.status, result.externalRef ? { externalRef: result.externalRef } : {});
-    }
-    async #markAbnormal(wake, reason) {
-        const current = this.#wake(wake.id);
-        if (current.runnerPid)
-            await this.runner.terminateProcess(current.runnerPid);
-        this.ledger.appendEvent({ streamId: wakeStream(current.id), ts: this.#now(), actor: current.agent, type: "wake.abnormal_reason", data: { reason } });
-        const repairs = interruptedSessionEvents(this.ledger.eventsForWake(current.id), this.#now(), "supervisor");
-        if (repairs.length)
-            this.ledger.appendEvents(repairs);
-        if (["leased", "running", "queued"].includes(current.status)) {
-            this.ledger.finishWake(current.id, "abnormal", this.#now());
-            if (current.attempt < this.#retryPolicy.maxAttempts) {
-                const delay = this.#retryPolicy.baseDelayMs * 2 ** Math.max(0, current.attempt - 1);
-                const schedule = { id: `retry:${current.id}`, agent: current.agent, nextWakeAt: new Date(this.clock.now().getTime() + delay).toISOString(), reason: `recovery:${current.id}`, setBy: "supervisor" };
-                this.ledger.putSchedule(schedule, "supervisor", current.id);
-            }
-            else if (current.agent !== "ceo" && this.#hasActiveRoot()) {
-                this.#enqueueTrigger("ceo", `child-retry-exhausted:${current.id}`);
+    #enqueueSchedule(schedule) {
+        if (schedule.status !== "pending")
+            return null;
+        if (schedule.bindingKind === "goal") {
+            const goal = this.ledger.goal(schedule.goalId);
+            if (!goal || goal.owner !== schedule.agent || goal.phase !== "active" || !this.#validGoalOwner(schedule.agent, goal)) {
+                this.ledger.supersedeSchedule(schedule.id, this.#now());
+                return null;
             }
         }
+        else if (!["verifier", "audit"].includes(this.#role(schedule.agent))) {
+            this.ledger.cancelSchedule(schedule.id, this.#now());
+            return null;
+        }
+        const wake = { id: `wake:${schedule.id}`, ...(schedule.bindingKind === "goal" ? goalExecutionBinding(schedule.agent, schedule.goalId) : specialistBinding(schedule.agent, schedule.specialistRole)), triggerRef: `${schedule.id}@${schedule.nextWakeAt}`, status: "queued", attempt: 0, enqueuedSeq: 0, claimedAt: null, consumedAt: null, turnId: null };
+        return this.ledger.consumeSchedule(schedule.id, wake, this.#now()).wake;
     }
-    #enqueueSchedule(schedule) {
-        return this.#enqueueTrigger(schedule.agent, `${schedule.id}@${schedule.nextWakeAt}`);
-    }
-    #enqueueTrigger(agent, triggerRef) {
+    #enqueueTrigger(agent, triggerRef, target) {
+        let binding;
+        if (target) {
+            const goal = this.ledger.goal(target.goalId);
+            if (!goal || goal.owner !== agent || goal.phase !== "active" || !this.#validGoalOwner(agent, goal))
+                return null;
+            binding = goalExecutionBinding(agent, target.goalId);
+        }
+        else {
+            const mailId = mailIdFromTriggerRef(triggerRef);
+            const mail = mailId ? this.ledger.mailbox().find((candidate) => candidate.id === mailId) : null;
+            const role = this.#role(agent);
+            if (agent === "ceo" && role === "ceo" && mail?.routeKind === "human_inbox" && mail.from === "human")
+                binding = humanBinding();
+            else if (role === "verifier" || role === "audit")
+                binding = specialistBinding(agent, role);
+            else
+                return null;
+        }
+        const sameBinding = (wake) => wake.bindingKind === binding.bindingKind && wake.goalId === binding.goalId && wake.specialistRole === binding.specialistRole;
         const exact = this.ledger.wakeByTrigger(agent, triggerRef);
-        if (exact)
+        if (exact) {
+            if (!sameBinding(exact))
+                throw new Error("Wake trigger was reused with a different execution binding");
             return exact;
-        const ownsLiveGoal = this.ledger.goalsForOwner(agent).some((goal) => goal.phase === "active" || goal.phase === "blocked");
-        const ceoInterrupt = agent === "ceo" && (triggerRef.startsWith("interaction:") || triggerRef.startsWith("mail:") || triggerRef.startsWith("child-"));
-        if (!ownsLiveGoal && !ceoInterrupt)
-            return null;
-        const queued = triggerRef.startsWith("interaction:") ? null : this.ledger.queuedWakeForAgent(agent);
-        if (queued) {
-            this.ledger.appendEvent({ streamId: wakeStream(queued.id), ts: this.#now(), actor: "supervisor", type: "wake.trigger_coalesced", data: { wakeId: queued.id, triggerRef } });
-            return queued;
         }
-        const wake = { id: randomUUID(), agent, triggerRef, status: "queued", leaseUntil: null, attempt: 0, startedAt: null, endedAt: null, enqueuedSeq: 0, leaseToken: null, runnerPid: null };
+        const pending = this.ledger.wakes().find((wake) => wake.agent === agent && wake.status === "claimed" && sameBinding(wake)) ?? this.ledger.wakes().find((wake) => wake.agent === agent && wake.status === "queued" && sameBinding(wake));
+        if (pending) {
+            this.ledger.addWakeTrigger(pending.id, triggerRef, "supervisor");
+            return pending;
+        }
+        const wake = { id: randomUUID(), ...binding, triggerRef, status: "queued", attempt: 0, enqueuedSeq: 0, claimedAt: null, consumedAt: null, turnId: null };
         const result = this.ledger.enqueueWake(wake, "supervisor");
         if (result.created)
             return this.#wake(wake.id);
@@ -467,303 +653,270 @@ export class Supervisor {
             throw new Error("deduplicated wake is missing");
         return existing;
     }
-    #suppressQueuedWake(agent, reason) {
-        const wake = this.ledger.queuedWakeForAgent(agent);
-        if (!wake)
-            return;
-        this.ledger.appendEvent({ streamId: wakeStream(wake.id), ts: this.#now(), actor: "supervisor", type: "wake.suppressed", data: { reason } });
-        this.ledger.finishWake(wake.id, "abnormal", this.#now());
-    }
     #hasActiveRoot() { return this.ledger.goals().some((goal) => goal.parentId === null && goal.owner === "ceo" && goal.phase === "active"); }
-    #role(agent) { return this.#profiles.get(agent)?.role ?? "child"; }
-    #validateCeoHandoff(wake, output) {
-        if (this.#role(wake.agent) !== "ceo")
-            return;
-        const idle = this.teamList().filter((member) => member.agent !== "ceo" && member.status === "idle_unplanned");
-        const missingObservationGoalIds = this.ledger.goals().filter((goal) => goal.parentId !== null && goal.phase !== "complete" && goal.observationMethod === null).map((goal) => goal.id);
-        const activeRoot = this.#hasActiveRoot();
-        const hasChildMotion = this.teamList().some((member) => member.agent !== "ceo" && !["idle_unplanned", "retired"].includes(member.status));
-        const hasReview = Boolean(output.nextWakeAt);
-        const hasBlocker = handoffBlocked(output.handoff);
-        const asksHuman = output.mail.some((mail) => mail.to === "human" && (mail.level === "decision" || mail.level === "emergency"))
-            || this.ledger.unreadMail("human").some((mail) => mail.from === "ceo" && (mail.level === "decision" || mail.level === "emergency"));
-        if (idle.length === 0 && missingObservationGoalIds.length === 0 && (!activeRoot || hasChildMotion || hasReview || hasBlocker || asksHuman))
-            return;
-        const violation = {
-            idleAgents: idle.map((member) => member.agent),
-            missingObservationGoalIds,
-            reason: missingObservationGoalIds.length ? "active child goal has no observation method" : idle.length ? "active child goal has no liveness route" : "active root has no motion, review, wait, blocker, or human request",
-        };
-        this.ledger.appendEvent({ streamId: wakeStream(wake.id), ts: this.#now(), actor: "supervisor", type: "ceo.motion_invalid", data: violation });
-        throw new Error(`CEO motion invalid: ${violation.reason}${violation.idleAgents.length ? ` (${violation.idleAgents.join(", ")})` : ""}`);
-    }
-    #validateGoalTurnRecord(wake, turn, revisionAtStart) {
-        const binding = turn.goalBinding;
-        const goal = this.#goal(binding.goalId);
-        if (goal.revision !== binding.goalRevision)
-            throw new Error("Goal revision changed during the Turn");
-        const record = this.ledger.workRecord(goal.id);
-        if (!record || record.recordRevision <= revisionAtStart || record.updatedInTurn !== wake.id || record.goalRevision !== goal.revision)
-            throw new Error("Goal-bound Turn must update its Work Record before handoff");
-    }
-    #goalWakeOutput(output, binding) {
+    #activeRoot() { return this.ledger.goals().find((goal) => goal.parentId === null && goal.owner === "ceo" && goal.phase === "active") ?? null; }
+    #singleActiveGoalTarget(agent) { const goals = this.ledger.goalsForOwner(agent).filter((goal) => goal.phase === "active" && this.#validGoalOwner(agent, goal)); if (goals.length > 1)
+        throw new Error("Wake requires an explicit Goal target when an Agent owns multiple active Goals"); return goals.length === 1 ? { goalId: goals[0].id } : undefined; }
+    #knownAgent(agent) { return this.#profiles.has(agent) || this.ledger.threads().some((thread) => thread.agent === agent) || this.ledger.goals().some((goal) => goal.owner === agent); }
+    #role(agent) { return this.#profiles.get(agent)?.role ?? (agent === "ceo" ? "ceo" : "child"); }
+    #validGoalOwner(agent, goal) { const role = this.#role(agent); return goal.owner === agent && (role === "ceo" ? agent === "ceo" && goal.parentId === null : role === "child" && goal.parentId !== null); }
+    #validExecution(agent, turn) { const role = this.#role(agent); if (turn.goalBinding) {
+        const goal = this.ledger.goal(turn.goalBinding.goalId);
+        return Boolean(goal && this.#validGoalOwner(agent, goal));
+    } if (turn.source.kind === "human")
+        return agent === "ceo" && role === "ceo"; return role === "verifier" || role === "audit"; }
+    #commitGoalTurn(turnId, agent, turn, raw, sourceWakeId, mailIds, revisionAtStart) { const binding = turn.goalBinding; const goal = this.#goal(binding.goalId); if (goal.revision !== binding.goalRevision)
+        throw new Error("Goal revision changed during the Turn"); const record = this.ledger.workRecord(goal.id); if (!record || record.recordRevision <= revisionAtStart || record.updatedInTurn !== turnId || record.goalRevision !== goal.revision)
+        throw new Error("Goal-bound Turn must update its Work Record before handoff"); assertTurnOutput(raw); const validation = this.#handoffValidations.get(raw.validationToken); const execution = this.ledger.turn(turnId); if (!validation || !execution || validation.turnId !== turnId || validation.attemptId !== raw.validationAttemptId || this.#handoffAttemptSeq.get(turnId) !== raw.validationAttemptId || validation.agent !== agent || validation.attempt !== execution.attempt || validation.leaseToken !== execution.leaseToken || validation.goalId !== goal.id || validation.goalRevision !== goal.revision || validation.handoff.outcome !== raw.handoff.outcome || !isSameNumbers(validation.handoff.evidence, raw.handoff.evidence))
+        throw new Error("Handoff validation token is stale or does not match this Turn"); const responseItem = [...this.ledger.turnItems(turnId)].reverse().find((item) => item.type === "assistant_message" && item.status === "completed" && item.data.text === validation.message); if (!responseItem)
+        throw new Error("accepted Handoff response was not recorded in the Turn"); const output = this.#goalTurnOutput(raw, binding); assertHandoff(output.handoff); const now = this.#now(); const item = { id: randomUUID(), turnId, ordinal: this.ledger.turnItems(turnId).length + 1, type: "handoff", status: "completed", data: output.handoff, createdAt: now, completedAt: now }; this.ledger.commitHandoff({ agent, turnId, sourceWakeId, mailIds, ts: now, output, responseItemId: responseItem.id, item }); this.#clearHandoffState(turnId); }
+    #goalTurnOutput(output, binding) {
         const record = this.ledger.workRecord(binding.goalId);
         if (!record)
             throw new Error("Goal Work Record is missing");
-        const legacy = "goalId" in output.handoff ? null : output.handoff;
         const handoff = {
             goalId: binding.goalId,
             goalRevision: binding.goalRevision,
             recordRevision: record.recordRevision,
-            outcome: "goalId" in output.handoff ? output.handoff.outcome : legacy?.blocker ? "blocked" : legacy?.material ? "completion_proposed" : "progress",
-            evidence: "goalId" in output.handoff && output.handoff.evidence.length ? output.handoff.evidence : record.evidence,
+            outcome: output.handoff.outcome,
+            evidence: output.handoff.evidence,
         };
-        return { ...output, handoff };
+        return { handoff };
     }
-    #turnContext(wake) {
-        if (interactionMailId(wake))
+    #turnContext(wake, triggers = this.ledger.wakeTriggers(wake.id).filter((trigger) => trigger.status === "pending")) {
+        if (wake.bindingKind === "human")
             return { source: { kind: "human" } };
-        const goals = this.ledger.goalsForOwner(wake.agent).filter((goal) => goal.phase === "active");
-        const goal = goals.find((candidate) => candidate.parentId === null) ?? goals[0];
-        const humanMail = wake.triggerRef.startsWith("mail:") && this.ledger.mailbox().some((mail) => mail.id === wake.triggerRef.slice(5) && mail.from === "human");
-        return { source: humanMail ? { kind: "human" } : { kind: "goal_driver", round: goal ? (this.ledger.workRecord(goal.id)?.recordRevision ?? 0) + 1 : 1 }, ...(goal ? { goalBinding: { goalId: goal.id, goalRevision: goal.revision } } : {}) };
+        if (wake.bindingKind === "specialist")
+            return { source: { kind: "system", reason: triggers.map((trigger) => trigger.triggerRef).join(", ") } };
+        const goal = this.#goal(wake.goalId);
+        return { source: { kind: "goal", round: (this.ledger.workRecord(goal.id)?.recordRevision ?? 0) + 1 }, goalBinding: { goalId: goal.id, goalRevision: goal.revision } };
     }
-    #loadContext(wake, turn) {
+    #loadContext(wake, turn, mail, wakeTriggers) {
         const profile = this.#profiles.get(wake.agent) ?? { agent: wake.agent, role: "child" };
         const role = profile.role;
         const capabilities = profile.capabilities ?? defaultCapabilities(role);
         const runnerProfile = this.#runnerProfiles.get(profile.runnerProfile ?? "default");
-        if (!turn.goalBinding && interactionMailId(wake)) {
-            const mail = this.ledger.mailbox().find((candidate) => candidate.id === interactionMailId(wake));
-            const body = mail?.body && typeof mail.body === "object" && !Array.isArray(mail.body) ? mail.body : {};
-            const message = typeof body.message === "string" ? body.message : "";
-            const mailEvent = this.ledger.eventsSince(0, ["mail.put"]).findLast((event) => event.data.snapshot?.id === mail?.id);
-            const recent = this.ledger.eventsSince(0, ["interaction.completed"]).filter((event) => event.actor === wake.agent).slice(-8).map((event) => {
-                const data = event.data;
-                const prior = this.ledger.mailbox().find((candidate) => candidate.id === data.mailId);
-                const priorBody = prior?.body && typeof prior.body === "object" && !Array.isArray(prior.body) ? prior.body : {};
-                return `Human: ${typeof priorBody.message === "string" ? priorBody.message : ""}\nAssistant: ${data.response?.content ?? ""}`;
-            });
-            return {
-                text: [...(recent.length ? [`# Recent conversation\n\n${recent.join("\n\n")}`] : []), `# Human message\n\n${message}`].join("\n\n"),
-                sourceSeqs: mailEvent ? [mailEvent.seq] : [],
-                capabilities,
-                systemPrompt: profile.systemPrompt ?? "You are Goah's primary Agent. Respond naturally to the Human, use tools when useful, and keep the final answer concise. Do not create or operate a Goal unless the Human expresses durable Goal intent.",
-                ...(runnerProfile ? { runnerProfile } : {}),
-            };
-        }
         const goals = role === "ceo" ? this.ledger.goals() : this.ledger.goalsForOwner(wake.agent);
-        const mail = this.ledger.unreadMail(wake.agent);
-        const handoff = this.ledger.lastEvent(wake.agent, "handoff.recorded");
-        const recoveryId = wake.triggerRef.startsWith("recovery:")
-            ? wake.triggerRef.slice("recovery:".length)
-            : wake.triggerRef.startsWith("retry:") ? wake.triggerRef.slice("retry:".length).split("@")[0] : null;
-        const recoveryEvents = recoveryId ? selectRecoveryEvents(this.ledger.eventsForWake(recoveryId)) : [];
+        const handoff = turn.goalBinding ? this.ledger.lastGoalHandoff(turn.goalBinding.goalId) : null;
+        const recoveryIds = [...new Set(wakeTriggers.flatMap((trigger) => { const parsed = parseRecoveryTrigger(trigger.triggerRef); const exhausted = childRetryExhaustedTurnId(trigger.triggerRef); return parsed ? [parsed.turnId] : exhausted ? [exhausted] : []; }))];
+        const recoveryEvents = recoveryIds.flatMap((recoveryId) => selectRecoveryEvents(this.ledger.turn(recoveryId) ? this.ledger.readStream(`turn:${recoveryId}`) : this.ledger.eventsForWake(recoveryId)));
         const teamHandoffs = role === "ceo"
             ? [...this.ledger.eventsSince(0, ["handoff.recorded"])].reverse().filter((event, index, all) => all.findIndex((candidate) => candidate.actor === event.actor) === index)
             : [];
-        const actions = this.ledger.actions().filter((action) => action.agent === wake.agent && (action.status === "unknown" || Boolean(action.auditAdvice && !action.adviceAcked)));
-        const revisionWarnings = goals.flatMap((goal) => this.#goalRevisionWarning(goal));
         const workingMemory = selectWorkingMemory(this.ledger.readStream(memoryStream(wake.agent)), this.#memoryTailChars);
-        const active = composeActiveContext({ role, capabilities, systemPrompt: profile.systemPrompt ?? defaultRolePrompt(role), wake, goals, mail, actions, lastHandoff: handoff, teamHandoffs, team: role === "ceo" ? this.teamList() : [], revisionWarnings, recoveryEvents, workingMemory });
+        const active = composeActiveContext({ role, capabilities, systemPrompt: profile.systemPrompt ?? defaultTurnPrompt(role, wake.agent, turn), wake, wakeTriggers, goals, mail, lastHandoff: handoff, teamHandoffs, team: role === "ceo" ? this.teamList() : [], recoveryEvents, workingMemory });
         const records = this.ledger.workRecords();
         const currentRecord = turn.goalBinding ? this.ledger.workRecord(turn.goalBinding.goalId) : null;
         const currentGoal = turn.goalBinding ? this.ledger.goal(turn.goalBinding.goalId) : null;
         const parentRecord = currentGoal?.parentId ? this.ledger.workRecord(currentGoal.parentId) : null;
         const recordIndex = records.map((record) => `- /goals/${record.goalId}.md · r${record.recordRevision} · ${this.ledger.goal(record.goalId)?.owner ?? "unknown"} · ${this.ledger.goal(record.goalId)?.phase ?? "unknown"}`);
         const workText = [`# Shared Work Record Index\n\n${recordIndex.join("\n")}`, ...(currentRecord ? [`# Your Work Record\n\n${currentRecord.content}`] : []), ...(parentRecord ? [`# Parent Work Record\n\n${parentRecord.content}`] : [])].join("\n\n");
-        return { ...active, text: `${active.text}\n\n${workText}`, sourceSeqs: [...new Set([...active.sourceSeqs, ...records.map((record) => record.lastEventSeq)])].sort((a, b) => a - b), workRecord: currentRecord, sharedWorkRecords: records, ...(runnerProfile ? { runnerProfile } : {}) };
+        return { ...active, text: `${active.text}\n\n${workText}`, sourceSeqs: [...new Set([...active.sourceSeqs, ...this.#mailSourceSeqs(mail), ...records.map((record) => record.lastEventSeq)])].sort((a, b) => a - b), workRecord: currentRecord, sharedWorkRecords: records, ...(runnerProfile ? { runnerProfile } : {}) };
     }
-    #requiredConnector(name) { const value = this.#connectors.get(name); if (!value)
-        throw new Error(`connector not registered: ${name}`); return value; }
     #wake(id) { const value = this.ledger.wake(id); if (!value)
         throw new Error(`wake not found: ${id}`); return value; }
-    #action(id) { const value = this.ledger.action(id); if (!value)
-        throw new Error(`action not found: ${id}`); return value; }
     #goal(id) { const value = this.ledger.goal(id); if (!value)
         throw new Error(`goal not found: ${id}`); return value; }
-    #goalRevisionWarning(goal) {
-        if (goal.parentId === null || goal.phase === "complete")
-            return [];
-        let root = this.#goal(goal.parentId);
-        while (root.parentId !== null)
-            root = this.#goal(root.parentId);
-        const rootSeq = this.ledger.readStream(goalStream(root.id)).filter((event) => event.type === "goal.put").at(-1)?.seq ?? 0;
-        const goalSeq = this.ledger.readStream(goalStream(goal.id)).filter((event) => event.type === "goal.put").at(-1)?.seq ?? 0;
-        return rootSeq > goalSeq ? [`Goal ${goal.id} predates root revision ${root.revision}; CEO must revise its objective/observation method before new gated actions.`] : [];
-    }
-    #assertAgentGoalsCurrent(agent) {
-        const warnings = this.ledger.goalsForOwner(agent).flatMap((goal) => this.#goalRevisionWarning(goal));
-        if (warnings.length)
-            throw new Error(warnings.join(" "));
-    }
+    #assertGoalMutationAuthority(goal, actor) { if (goal.parentId === null) {
+        if (actor !== "human")
+            throw new Error("only human may modify a root goal");
+        return;
+    } const parent = this.ledger.goal(goal.parentId); if (parent?.owner !== actor)
+        throw new Error("only the parent goal owner may modify a child goal"); }
     #now() { return this.clock.now().toISOString(); }
-    async #agentRpc(wake, turn, leaseToken, method, params) {
-        const current = this.ledger.wake(wake.id);
-        if (!current || current.status !== "running" || current.leaseToken !== leaseToken || !current.leaseUntil || current.leaseUntil < this.#now())
-            throw new Error("stale runner RPC rejected");
-        const profile = this.#profiles.get(wake.agent) ?? { agent: wake.agent, role: "child" };
+    #futureTime(value, after) { const parsed = Date.parse(value); if (!Number.isFinite(parsed) || parsed <= Date.parse(after))
+        throw new Error("nextWakeAt must be later than the Turn start"); return new Date(parsed).toISOString(); }
+    #runnerProfileId(agent) { return this.#profiles.get(agent)?.runnerProfile ?? "default"; }
+    #contextMail(target) { const selected = []; let used = 0; const matches = (mail) => target.bindingKind === "goal" ? mail.routeKind === "goal" && mail.goalId === target.goalId : target.bindingKind === "human" ? mail.routeKind === "human_inbox" : mail.routeKind === "specialist_inbox" && mail.specialistRole === target.specialistRole; for (const mail of this.ledger.unreadMail(target.agent).filter(matches)) {
+        const cost = Math.min(JSON.stringify(mail.body).length, 2_000) + 128;
+        if (selected.length >= 20 || selected.length > 0 && used + cost > this.#memoryTailChars)
+            break;
+        selected.push(mail);
+        used += cost;
+    } return selected; }
+    #mailSourceSeqs(mail) { const ids = new Set(mail.map((item) => item.id)); if (!ids.size)
+        return []; return this.ledger.eventsSince(0, ["mail.put"]).filter((event) => { const data = event.data && typeof event.data === "object" && !Array.isArray(event.data) ? event.data : {}; return typeof data.snapshot?.id === "string" && ids.has(data.snapshot.id); }).map((event) => event.seq); }
+    async #agentRpcForTurn(turnId, agent, context, method, params, sourceWakeId) {
+        const handoffAttemptId = method === "goal.handoff.validate" ? this.#beginHandoffAttempt(turnId) : null;
+        const execution = this.ledger.turn(turnId);
+        if (!execution || execution.status !== "in_progress" || !execution.leaseToken || !execution.leaseUntil || execution.leaseUntil < this.#now())
+            throw new Error("stale Turn RPC rejected");
+        if (context.goalBinding) {
+            const goal = this.ledger.goal(context.goalBinding.goalId);
+            const thread = this.ledger.thread(execution.threadId);
+            if (!goal || goal.phase !== "active" || goal.revision !== context.goalBinding.goalRevision || goal.owner !== agent || execution.bindingKind !== "goal" || execution.goalId !== goal.id || execution.goalRevision !== goal.revision || thread?.agent !== agent)
+                throw new Error("stale Goal-bound Turn RPC rejected");
+        }
+        const input = asRecord(params);
+        if (method === "goal.handoff.validate") {
+            const candidate = String(input.candidateMessage ?? "");
+            this.ledger.appendEvent({ streamId: `turn:${turnId}`, ts: this.#now(), actor: agent, type: "rpc.goal.handoff.validate", data: { attemptId: handoffAttemptId, handoff: input.handoff ?? null, candidateMessagePresent: Boolean(candidate.trim()), candidateMessageChars: candidate.length }, ignorable: true });
+            return this.#validateHandoffDraft(turnId, handoffAttemptId, agent, execution, context, input);
+        }
+        const profile = this.#profiles.get(agent) ?? { agent, role: "child" };
         const allowed = new Set(profile.capabilities ?? defaultCapabilities(profile.role));
         if (!allowed.has(method))
             throw new Error(`${profile.role} agent is not allowed to call ${method}`);
-        if (!turn.goalBinding && goalBoundCapability(method))
+        if (!context.goalBinding && goalBoundCapability(method))
             throw new Error(`${method} requires a Goal-bound Turn`);
-        this.ledger.appendRunnerEvent({ streamId: wakeStream(wake.id), ts: this.#now(), actor: wake.agent, type: `rpc.${method}`, data: params }, leaseToken);
-        const input = asRecord(params);
+        this.ledger.appendEvent({ streamId: `turn:${turnId}`, ts: this.#now(), actor: agent, type: `rpc.${method}`, data: params, ignorable: true });
         if (method === "ledger.search")
             return this.ledger.searchEvents(String(input.query), Number(input.limit ?? 20));
         if (method === "team.list")
             return this.teamList();
         if (method === "goal.get")
-            return (turn.goalBinding ? this.ledger.goal(turn.goalBinding.goalId) : null);
+            return (context.goalBinding ? this.ledger.goal(context.goalBinding.goalId) : null);
         if (method === "goal.create") {
-            if (turn.source.kind !== "human" || turn.goalBinding)
-                throw new Error("a Root Goal can only be created from an unbound Human Turn");
-            if (wake.agent !== "ceo")
-                throw new Error("only CEO may translate Human intent into a Root Goal");
-            const goal = this.createRootGoal(String(input.objective), typeof input.id === "string" && input.id.trim() ? input.id : undefined);
-            turn.goalBinding = { goalId: goal.id, goalRevision: goal.revision };
-            this.ledger.appendRunnerEvent({ streamId: wakeStream(wake.id), ts: this.#now(), actor: wake.agent, type: "turn.goal_bound", data: { goalId: goal.id, goalRevision: goal.revision, authority: "human" } }, leaseToken);
-            return { goal, goalBinding: turn.goalBinding, instruction: "This Turn is now Goal-bound. Update its Work Record and finish with handoff." };
+            if (context.source.kind !== "human" || context.goalBinding || agent !== "ceo")
+                throw new Error("Root Goal creation requires an unbound CEO Human Turn");
+            const goal = this.createRootGoal(String(input.objective), typeof input.id === "string" ? input.id : undefined, turnId);
+            context.goalBinding = { goalId: goal.id, goalRevision: goal.revision };
+            this.ledger.putTurn({ ...this.ledger.turn(turnId), ...goalTurnBinding(goal.id, goal.revision) }, "supervisor");
+            return { goal, goalBinding: context.goalBinding };
         }
         if (method === "goal.work") {
-            if (turn.source.kind !== "human" || turn.goalBinding)
+            if (context.source.kind !== "human" || context.goalBinding)
                 throw new Error("work_on_goal requires an unbound Human Turn");
             const goal = this.#goal(String(input.goalId));
-            if (goal.owner !== wake.agent || goal.phase !== "active")
-                throw new Error("work_on_goal requires an active Goal owned by this Agent");
-            turn.goalBinding = { goalId: goal.id, goalRevision: goal.revision };
-            this.ledger.appendRunnerEvent({ streamId: wakeStream(wake.id), ts: this.#now(), actor: wake.agent, type: "turn.goal_bound", data: { goalId: goal.id, goalRevision: goal.revision, authority: "human" } }, leaseToken);
-            return { goal, goalBinding: turn.goalBinding, instruction: "This Turn is now Goal-bound. Update its Work Record and finish with handoff." };
+            if (goal.phase !== "active" || !this.#validGoalOwner(agent, goal))
+                throw new Error("work_on_goal requires the active owned Root Goal");
+            context.goalBinding = { goalId: goal.id, goalRevision: goal.revision };
+            this.ledger.putTurn({ ...this.ledger.turn(turnId), ...goalTurnBinding(goal.id, goal.revision) }, "supervisor");
+            return { goal, goalBinding: context.goalBinding };
         }
         if (method === "work_record.list")
             return this.ledger.workRecords();
         if (method === "work_record.read")
-            return this.ledger.workRecord(String(input.goalId ?? turn.goalBinding?.goalId ?? ""));
+            return this.ledger.workRecord(String(input.goalId ?? context.goalBinding?.goalId ?? ""));
         if (method === "work_record.history")
-            return this.ledger.workRecordHistory(String(input.goalId ?? turn.goalBinding?.goalId ?? ""));
+            return this.ledger.workRecordHistory(String(input.goalId ?? context.goalBinding?.goalId ?? ""));
         if (method === "work_record.diff")
-            return this.ledger.workRecordDiff(String(input.goalId ?? turn.goalBinding?.goalId ?? ""), Number(input.fromRevision), Number(input.toRevision));
+            return this.ledger.workRecordDiff(String(input.goalId ?? context.goalBinding?.goalId ?? ""), Number(input.fromRevision), Number(input.toRevision));
         if (method === "work_record.search")
             return this.ledger.searchWorkRecords(String(input.query), Number(input.limit ?? 20));
         if (method === "work_record.update") {
-            if (!turn.goalBinding)
-                throw new Error("work_record.update requires a Goal-bound Turn");
-            return this.ledger.updateWorkRecord({ goalId: turn.goalBinding.goalId, goalRevision: turn.goalBinding.goalRevision, expectedRevision: Number(input.expectedRevision), content: String(input.content), reason: String(input.reason), evidence: numberArray(input.evidence), turnId: wake.id, wakeId: wake.id }, wake.agent);
-        }
-        if (method === "goal.delegate")
-            return this.delegate({
-                id: String(input.id),
-                parentGoalId: String(input.parentGoalId),
-                childGoal: asChildGoal(input.childGoal),
-                brief: (input.brief ?? null),
-                reason: String(input.reason),
-                evidence: numberArray(input.evidence),
-            }, wake.agent, wake.id);
-        if (method === "goal.reassign")
-            return this.reassignGoal({
-                id: String(input.id),
-                goalId: String(input.goalId),
-                newOwner: String(input.newOwner),
-                brief: (input.brief ?? null),
-                reason: String(input.reason),
-                evidence: numberArray(input.evidence),
-            }, wake.agent, wake.id);
+            const binding = context.goalBinding;
+            return this.ledger.updateWorkRecord({ goalId: binding.goalId, goalRevision: binding.goalRevision, expectedRevision: Number(input.expectedRevision), content: String(input.content), reason: String(input.reason), evidence: numberArray(input.evidence), turnId, ...(sourceWakeId ? { sourceWakeId } : {}) }, agent);
+        }
+        if (method === "goal.delegate") {
+            const binding = context.goalBinding;
+            if (String(input.parentGoalId) !== binding.goalId)
+                throw new Error("delegation parent must be the Goal bound to this Turn");
+            return this.delegate({ id: String(input.id), parentGoalId: binding.goalId, expectedParentRevision: Number(input.expectedParentRevision), childGoal: asChildGoal(input.childGoal), brief: (input.brief ?? null), reason: String(input.reason), evidence: numberArray(input.evidence), sourceTurnId: turnId }, agent, sourceWakeId);
+        }
+        if (method === "goal.reassign") {
+            const goal = this.#goal(String(input.goalId));
+            if (goal.parentId !== context.goalBinding.goalId)
+                throw new Error("reassignment target must be a child of the Goal bound to this Turn");
+            return await this.reassignGoal({ id: String(input.id), goalId: goal.id, expectedGoalRevision: Number(input.expectedGoalRevision), newOwner: String(input.newOwner), brief: (input.brief ?? null), reason: String(input.reason), evidence: numberArray(input.evidence), sourceTurnId: turnId }, agent, sourceWakeId);
+        }
         if (method === "goal.revise")
-            return this.reviseChildGoal(String(input.goalId), String(input.objective), String(input.observationMethod), String(input.verificationMethod), wake.agent, String(input.reason), numberArray(input.evidence), wake.id);
+            return this.reviseChildGoal(String(input.goalId), String(input.objective), String(input.observationMethod), String(input.verificationMethod), agent, String(input.reason), numberArray(input.evidence), sourceWakeId, turnId);
         if (method === "goal.pause" || method === "goal.resume") {
-            const goalId = String(input.goalId);
-            const currentGoal = this.#goal(goalId);
-            const directHumanRoot = !turn.goalBinding && turn.source.kind === "human" && currentGoal.parentId === null;
-            if (!turn.goalBinding && !directHumanRoot)
+            const goal = this.#goal(String(input.goalId));
+            const directRoot = !context.goalBinding && context.source.kind === "human" && goal.parentId === null;
+            if (!context.goalBinding && !directRoot)
                 throw new Error(`${method} requires a Goal-bound Turn`);
-            const goal = this.transitionGoal(goalId, method === "goal.pause" ? "paused" : "active", directHumanRoot ? "human" : wake.agent);
-            if (method === "goal.resume" && directHumanRoot) {
-                turn.goalBinding = { goalId: goal.id, goalRevision: goal.revision };
-                this.ledger.appendRunnerEvent({ streamId: wakeStream(wake.id), ts: this.#now(), actor: wake.agent, type: "turn.goal_bound", data: { goalId: goal.id, goalRevision: goal.revision, authority: "human" } }, leaseToken);
-                return { goal, goalBinding: turn.goalBinding, instruction: "This Turn is now Goal-bound. Update its Work Record and finish with handoff." };
+            const next = this.transitionGoal(goal.id, method === "goal.pause" ? "paused" : "active", directRoot ? "human" : agent, !directRoot, turnId);
+            if (method === "goal.resume" && directRoot) {
+                context.goalBinding = { goalId: next.id, goalRevision: next.revision };
+                this.ledger.putTurn({ ...this.ledger.turn(turnId), ...goalTurnBinding(next.id, next.revision) }, "supervisor");
+                return { goal: next, goalBinding: context.goalBinding };
             }
-            return goal;
+            return next;
         }
         if (method === "goal.complete") {
-            const currentGoal = this.#goal(String(input.goalId));
-            const directHumanRoot = !turn.goalBinding && turn.source.kind === "human" && currentGoal.parentId === null;
-            if (!turn.goalBinding && !directHumanRoot)
+            const goal = this.#goal(String(input.goalId));
+            const directRoot = !context.goalBinding && context.source.kind === "human" && goal.parentId === null;
+            if (!context.goalBinding && !directRoot)
                 throw new Error("goal.complete requires a Goal-bound Turn");
-            return this.completeGoal({ goalId: currentGoal.id, revision: Number(input.revision), reason: String(input.reason), evidence: numberArray(input.evidence) }, directHumanRoot ? "human" : wake.agent, wake.id);
+            return this.completeGoal({ goalId: goal.id, revision: Number(input.revision), reason: String(input.reason), evidence: numberArray(input.evidence), sourceTurnId: turnId }, directRoot ? "human" : agent, sourceWakeId);
+        }
+        if (method === "mail.send") {
+            const to = String(input.to);
+            if (to === "human")
+                throw new Error("Human communication requires human.request");
+            if (!this.#knownAgent(to))
+                throw new Error(`unknown Agent recipient: ${to}`);
+            const goalId = String(input.goalId ?? "").trim();
+            if (!goalId)
+                throw new Error("Agent Mail requires a Goal route");
+            const goal = this.#goal(goalId);
+            if (!this.#validGoalOwner(to, goal))
+                throw new Error("Agent Mail Goal route does not match the recipient role and ownership");
+            const mail = { id: randomUUID(), to, from: agent, level: String(input.level), ...goalRoute(goalId), body: (input.body ?? null), readAt: null };
+            this.ledger.putMail(mail, agent, sourceWakeId);
+            return mail;
         }
         if (method === "human.request") {
+            if (agent !== "ceo")
+                throw new Error("only CEO may request Human input");
             const evidence = numberArray(input.evidence);
+            if (!evidence.length)
+                throw new Error("evidence is required");
             for (const seq of evidence)
                 if (!this.ledger.eventsSince(seq - 1).some((event) => event.seq === seq))
                     throw new Error(`evidence event does not exist: ${seq}`);
-            const mail = { id: randomUUID(), to: "human", from: wake.agent, level: "decision", body: { type: String(input.type ?? "decision"), message: input.message ?? null, evidence }, readAt: null };
-            this.ledger.putMail(mail, wake.agent, wake.id);
-            this.ledger.appendRunnerEvent({ streamId: wakeStream(wake.id), ts: this.#now(), actor: wake.agent, type: "ceo.human_requested", data: mail.body }, leaseToken);
+            const mail = { id: randomUUID(), to: "human", from: agent, level: "decision", ...humanRequestRoute(), body: { type: String(input.type), message: input.message ?? null, evidence }, readAt: null };
+            this.ledger.putMail(mail, agent, sourceWakeId);
             return mail;
         }
-        if (method === "mail.send") {
-            const mail = { id: randomUUID(), to: String(input.to), from: wake.agent, level: String(input.level), body: (input.body ?? null), readAt: null };
-            this.ledger.putMail(mail, wake.agent, wake.id);
-            return mail;
+        if (method === "schedule.set")
+            return (this.planWake(agent, String(input.at), String(input.reason), agent, context.goalBinding) ?? { scheduled: true });
+        if (method === "goal.put") {
+            const next = input.goal;
+            if (!this.#validGoalOwner(next.owner, next))
+                throw new Error("Goal owner role does not match Root/Child position");
+            const current = this.ledger.goal(next.id);
+            const operation = !current ? "create" : current.phase !== next.phase ? (next.phase === "paused" ? "pause" : next.phase === "active" ? "resume" : next.phase === "blocked" ? "block" : "complete") : current.owner !== next.owner ? "reassign" : "revise";
+            this.ledger.putGoal(next, agent, sourceWakeId, { operation, reason: String(input.reason ?? "Advanced Goal mutation"), evidence: numberArray(input.evidence ?? []), sourceTurnId: turnId, ...(sourceWakeId ? { sourceWakeId } : {}) });
+            return input.goal;
         }
         if (method === "memory.append") {
             const note = String(input.note ?? "").trim();
             if (!note)
                 throw new Error("memory note cannot be empty");
-            const record = this.ledger.appendEvent({ streamId: memoryStream(wake.agent), ts: this.#now(), actor: wake.agent, type: "memory.appended", data: { note, wakeId: wake.id } });
-            return { seq: record.seq, streamSeq: record.streamSeq };
+            const event = this.ledger.appendEvent({ streamId: memoryStream(agent), ts: this.#now(), actor: agent, type: "memory.appended", data: { note, turnId } });
+            return { seq: event.seq };
         }
-        if (method === "schedule.set")
-            return (this.planWake(wake.agent, String(input.at), String(input.reason), wake.agent) ?? { scheduled: true });
-        if (method === "audit.ack")
-            return this.ackAuditAdvice(String(input.actionId), wake.agent);
-        if (method === "audit.write")
-            return this.putAuditAdvice(String(input.actionId), { by: wake.agent, body: (input.body ?? null), evidence: numberArray(input.evidence) }, wake.id);
-        if (method === "goal.put") {
-            this.ledger.putGoal(input.goal, wake.agent, wake.id);
-            return input.goal;
-        }
-        const action = await this.submitAction({
-            id: String(input.id), agent: wake.agent, kind: String(input.kind), payload: (input.payload ?? null), reason: String(input.reason), evidence: numberArray(input.evidence), auditAdvice: null, adviceAcked: false,
-        }, String(input.connector), wake.id);
-        return action;
+        throw new Error(`unsupported Agent capability: ${method}`);
     }
-    async #collectMetrics() {
-        const now = this.clock.now().getTime();
-        for (const registration of this.#metricCollectors.values()) {
-            if (registration.nextAt > now)
-                continue;
-            registration.nextAt = now + registration.intervalMs;
-            const sample = await runJsonProcess(registration.spec, { goalId: registration.goalId });
-            this.recordMetric({ ...sample, goalId: registration.goalId });
+    #validateHandoffDraft(turnId, attemptId, agent, execution, context, input) {
+        if (!context.goalBinding || execution.bindingKind !== "goal")
+            return { accepted: false, fatal: true, attemptId, issues: [{ code: "turn_not_goal_bound", message: "This Turn is no longer Goal-bound." }] };
+        const request = { handoff: (input.handoff ?? null), candidateMessage: String(input.candidateMessage ?? "") };
+        const issues = [];
+        try {
+            assertAgentHandoff(request.handoff);
         }
-    }
-    #scheduleMetricAlerts() {
-        for (const [goalId, contract] of this.#metricContracts) {
-            const goal = this.ledger.goal(goalId);
-            if (!goal)
-                continue;
-            const samples = this.ledger.metricSamples(goal.id);
-            const evaluation = evaluateMetric(contract, samples, this.#now());
-            if (evaluation.shouldWakeOwner)
-                this.#enqueueTrigger(goal.owner, `metric:${goal.id}:${evaluation.status}:${samples.at(-1)?.observedAt ?? "none"}`);
+        catch {
+            issues.push({ code: "handoff_invalid", message: "Handoff requires a valid outcome and at least one evidence event." });
         }
+        const existingMessage = [...this.ledger.turnItems(turnId)].reverse().find((item) => item.type === "assistant_message" && item.status === "completed" && typeof item.data.text === "string" && Boolean(item.data.text.trim()));
+        const message = request.candidateMessage.trim() || String(existingMessage?.data?.text ?? "").trim();
+        if (!message)
+            issues.push({ code: "message_missing", message: "This Goal Turn needs a readable assistant message before it can finish." });
+        const goal = this.ledger.goal(context.goalBinding.goalId);
+        if (!goal || goal.phase !== "active" || goal.owner !== agent || goal.revision !== context.goalBinding.goalRevision)
+            return { accepted: false, fatal: true, attemptId, issues: [{ code: "goal_fence_changed", message: "Goal ownership, phase, or revision changed; this Turn can no longer finish against the old binding." }] };
+        const record = this.ledger.workRecord(goal.id);
+        if (!record || record.updatedInTurn !== turnId || record.goalRevision !== goal.revision)
+            issues.push({ code: "work_record_not_updated", message: "Update this Goal's Work Record in the current Turn before Handoff.", details: { goalId: goal.id, recordRevision: record?.recordRevision ?? null } });
+        const evidence = Array.isArray(request.handoff?.evidence) ? request.handoff.evidence : [];
+        for (const seq of evidence)
+            if (!Number.isInteger(seq) || !this.ledger.eventsSince(seq - 1).some((event) => event.seq === seq))
+                issues.push({ code: "evidence_not_found", message: `Evidence event ${String(seq)} does not exist in the Ledger.`, details: { seq } });
+        if (issues.length)
+            return { accepted: false, fatal: false, attemptId, issues };
+        const token = randomUUID();
+        this.#handoffValidations.set(token, { turnId, attemptId, agent, attempt: execution.attempt, leaseToken: execution.leaseToken, goalId: goal.id, goalRevision: goal.revision, message, handoff: { outcome: request.handoff.outcome, evidence: [...request.handoff.evidence] } });
+        return { accepted: true, fatal: false, attemptId, token, goalId: goal.id, goalRevision: goal.revision };
     }
-    /** The one mechanical floor: total ledger silence. Any event from anyone resets the clock; stall policy is the CEO's business, not the supervisor's. */
-    #checkSystemSilence() {
-        if (!this.#silence)
-            return;
-        const last = this.ledger.latestEvent();
-        if (!last)
-            return;
-        const silentMs = this.clock.now().getTime() - Date.parse(last.ts);
-        if (silentMs <= this.#silence.maxSilentMs)
-            return;
-        const fact = { silentMs, lastEventSeq: last.seq, lastEventAt: last.ts };
-        this.ledger.appendEvent({ streamId: controlStream("watchdog"), ts: this.#now(), actor: "supervisor", type: "watchdog.system_silence", data: { ...fact, notify: this.#silence.notify } });
-        this.ledger.putMail({ id: `silence:${last.seq}`, to: this.#silence.notify, from: "supervisor", level: "decision", readAt: null, body: { type: "system_silence", ...fact, note: "No ledger events system-wide within the silence window. Confirm this is expected and hand off." } }, "supervisor");
-    }
+    #beginHandoffAttempt(turnId) { this.#invalidateHandoffTokens(turnId); const attemptId = (this.#handoffAttemptSeq.get(turnId) ?? 0) + 1; this.#handoffAttemptSeq.set(turnId, attemptId); return attemptId; }
+    #invalidateHandoffTokens(turnId) { for (const [token, value] of this.#handoffValidations)
+        if (value.turnId === turnId)
+            this.#handoffValidations.delete(token); }
+    #clearHandoffState(turnId) { this.#invalidateHandoffTokens(turnId); this.#handoffAttemptSeq.delete(turnId); }
 }
 export async function runSupervisorDaemon(supervisor, options = {}) {
     const pollMs = options.pollMs ?? 1_000;
@@ -776,8 +929,15 @@ export async function runSupervisorDaemon(supervisor, options = {}) {
             options.onError?.(error);
         }
         await new Promise((resolve) => {
-            const timer = setTimeout(resolve, pollMs);
-            options.signal?.addEventListener("abort", () => { clearTimeout(timer); resolve(); }, { once: true });
+            if (options.signal?.aborted) {
+                resolve();
+                return;
+            }
+            const onAbort = () => { clearTimeout(timer); resolve(); };
+            const timer = setTimeout(() => { options.signal?.removeEventListener("abort", onAbort); resolve(); }, pollMs);
+            options.signal?.addEventListener("abort", onAbort, { once: true });
+            if (options.signal?.aborted)
+                onAbort();
         });
     }
 }
@@ -785,103 +945,130 @@ export function deriveTeam(ledger, now = new Date().toISOString()) {
     const goals = ledger.goals();
     const wakes = ledger.wakes();
     const schedules = ledger.schedules();
+    const threads = ledger.threads();
+    const turns = ledger.turns();
     const handoffs = ledger.eventsSince(0, ["handoff.recorded"]);
     const owners = [...new Set(goals.map((goal) => goal.owner))].sort();
     return owners.map((agent) => {
         const owned = goals.filter((goal) => goal.owner === agent);
         const live = owned.filter((goal) => goal.phase !== "complete");
         const agentWakes = wakes.filter((wake) => wake.agent === agent).sort((a, b) => b.enqueuedSeq - a.enqueuedSeq);
-        const activeWake = agentWakes.find((wake) => ["running", "leased", "queued"].includes(wake.status));
-        const nextWakeAt = schedules.filter((schedule) => schedule.agent === agent && schedule.nextWakeAt > now).map((schedule) => schedule.nextWakeAt).sort()[0] ?? null;
+        const activeWake = agentWakes.find((wake) => { if (wake.status !== "claimed" && wake.status !== "queued")
+            return false; if (!wake.goalId)
+            return true; const goal = ledger.goal(wake.goalId); return goal?.phase === "active" && goal.owner === agent; });
+        const threadIds = new Set(threads.filter((thread) => thread.agent === agent).map((thread) => thread.id));
+        const activeTurn = turns.find((turn) => threadIds.has(turn.threadId) && turn.status === "in_progress");
+        const nextWakeAt = schedules.filter((schedule) => { if (schedule.agent !== agent || schedule.status !== "pending" || schedule.nextWakeAt <= now)
+            return false; if (!schedule.goalId)
+            return true; const goal = ledger.goal(schedule.goalId); return goal?.phase === "active" && goal.owner === agent; }).map((schedule) => schedule.nextWakeAt).sort()[0] ?? null;
         const lastHandoff = [...handoffs].reverse().find((event) => event.actor === agent) ?? null;
-        const blocker = lastHandoff && typeof lastHandoff.data === "object" && lastHandoff.data !== null && !Array.isArray(lastHandoff.data)
-            ? (lastHandoff.data.blocker ?? (lastHandoff.data.outcome === "blocked" ? "blocked" : null))
-            : null;
-        let status;
+        const value = lastHandoff?.data;
+        const lastOutcome = typeof value?.outcome === "string" ? value.outcome : null;
+        let motion;
         if (live.length === 0)
-            status = "retired";
-        else if (activeWake?.status === "running")
-            status = "running";
+            motion = "retired";
+        else if (activeTurn)
+            motion = "running";
         else if (activeWake)
-            status = "queued";
+            motion = "queued";
         else if (nextWakeAt)
-            status = "scheduled";
-        else if (live.every((goal) => goal.phase === "blocked"))
-            status = "blocked";
-        else if (live.every((goal) => goal.phase === "paused") || typeof blocker === "string" && blocker.length > 0)
-            status = "waiting";
+            motion = "scheduled";
         else
-            status = "idle_unplanned";
-        return { agent, goalIds: owned.map((goal) => goal.id), status, lastHandoffSeq: lastHandoff?.seq ?? null, lastWakeStatus: agentWakes[0]?.status ?? null, nextWakeAt };
+            motion = "idle";
+        return { agent, goalIds: owned.map((goal) => goal.id), motion, lastOutcome, lastHandoffSeq: lastHandoff?.seq ?? null, lastWakeStatus: agentWakes[0]?.status ?? null, nextWakeAt };
     });
 }
+export function deriveRecoveryViews(ledger) {
+    const views = [];
+    const wakes = ledger.wakes();
+    const schedules = ledger.schedules();
+    const triggers = wakes.flatMap((wake) => ledger.wakeTriggers(wake.id));
+    for (const turn of ledger.turns()) {
+        if (turn.status !== "failed")
+            continue;
+        const sourceWake = wakes.find((wake) => wake.turnId === turn.id);
+        const thread = ledger.thread(turn.threadId);
+        const goal = turn.bindingKind === "goal" ? ledger.goal(turn.goalId) : null;
+        const goalFailure = Boolean(turn.bindingKind === "goal" && thread && goal && goal.phase === "active" && goal.owner === thread.agent);
+        const specialistFailure = Boolean(turn.bindingKind === "specialist" && thread && sourceWake?.agent === thread.agent);
+        if (!sourceWake || !thread || !goalFailure && !specialistFailure)
+            continue;
+        const base = { turnId: turn.id, agent: thread.agent };
+        const scheduled = schedules.some((schedule) => {
+            const recovery = parseRecoveryTrigger(schedule.id);
+            const sameTarget = goalFailure ? schedule.bindingKind === "goal" && schedule.goalId === goal.id : schedule.bindingKind === "specialist" && turn.bindingKind === "specialist" && schedule.specialistRole === turn.specialistRole;
+            return schedule.status === "pending" && schedule.setBy === "supervisor" && schedule.agent === thread.agent && sameTarget && schedule.reason === recoveryRef(turn.id) && recovery?.turnId === turn.id && recovery.attempt > 0;
+        });
+        if (scheduled) {
+            views.push({ ...base, state: "scheduled", actionable: false });
+            continue;
+        }
+        const recoveryWake = triggers.flatMap((trigger) => {
+            const recovery = parseRecoveryTrigger(trigger.triggerRef);
+            const wake = recovery?.turnId === turn.id ? wakes.find((candidate) => candidate.id === trigger.wakeId) : null;
+            const sameTarget = goalFailure ? wake?.bindingKind === "goal" && wake.goalId === goal.id : wake?.bindingKind === "specialist" && turn.bindingKind === "specialist" && wake.specialistRole === turn.specialistRole;
+            return wake?.agent === thread.agent && sameTarget ? [wake] : [];
+        }).sort((left, right) => right.enqueuedSeq - left.enqueuedSeq)[0];
+        if (recoveryWake?.status === "queued" || recoveryWake?.status === "claimed") {
+            views.push({ ...base, state: "queued", actionable: false });
+            continue;
+        }
+        if (recoveryWake?.status === "consumed" && recoveryWake.turnId) {
+            const retry = ledger.turn(recoveryWake.turnId);
+            const state = retry?.status === "in_progress" ? "running" : retry?.status === "completed" ? "recovered" : "superseded";
+            views.push({ ...base, state, actionable: false });
+            continue;
+        }
+        const parent = goalFailure && goal.parentId ? ledger.goal(goal.parentId) : null;
+        const escalation = triggers.flatMap((trigger) => {
+            const wake = trigger.triggerRef === childRetryExhaustedRef(turn.id) ? wakes.find((candidate) => candidate.id === trigger.wakeId) : null;
+            return wake?.bindingKind === "goal" && parent && wake.agent === parent.owner && wake.goalId === parent.id && parent.phase === "active" ? [wake] : [];
+        }).find((wake) => wake.status === "queued" || wake.status === "claimed" || wake.status === "consumed");
+        if (escalation) {
+            views.push({ ...base, state: "escalated", actionable: false });
+            continue;
+        }
+        views.push({ ...base, state: "needed", actionable: true });
+    }
+    return views;
+}
 export function renderDashboard(ledger) {
     const rows = (values) => values.map((value) => `<tr><td><pre>${escapeHtml(JSON.stringify(value, null, 2))}</pre></td></tr>`).join("");
-    return `<!doctype html><html><head><meta charset="utf-8"><title>goah status</title><style>body{font:14px ui-monospace;margin:32px;background:#101418;color:#dce3e4}section{margin:32px 0}pre{white-space:pre-wrap;border:1px solid #334;padding:12px}</style></head><body><h1>goah</h1><p>seq ${ledger.events().at(-1)?.seq ?? 0}</p><section><h2>Team</h2><table>${rows(deriveTeam(ledger))}</table></section><section><h2>Goals</h2><table>${rows(ledger.goals())}</table></section><section><h2>Wakes</h2><table>${rows(ledger.wakes())}</table></section><section><h2>Actions</h2><table>${rows(ledger.actions())}</table></section><section><h2>Mailbox</h2><table>${rows(ledger.mailbox())}</table></section></body></html>`;
-}
-async function runConnector(spec, operation, action) {
-    return runJsonProcess(spec, { operation, action });
-}
-async function runJsonProcess(spec, input) {
-    const child = spawn(spec.command, spec.args, { detached: process.platform !== "win32", env: minimalEnvironment(spec.env), stdio: ["pipe", "pipe", "pipe"] });
-    let stdout = "";
-    let stderr = "";
-    child.stdout.on("data", (chunk) => { stdout += chunk.toString(); });
-    child.stderr.on("data", (chunk) => { stderr += chunk.toString(); });
-    child.stdin.end(`${JSON.stringify(input)}\n`);
-    const timeoutMs = spec.timeoutMs ?? 30_000;
-    let timer;
-    const exit = new Promise((resolve, reject) => {
-        child.once("error", reject);
-        child.once("close", (code, signal) => resolve({ code, signal }));
-    });
-    timer = setTimeout(() => { void terminateChild(child, 500); }, timeoutMs);
-    const result = await exit;
-    clearTimeout(timer);
-    if (result.code !== 0)
-        throw new Error(stderr.trim() || `connector exited (${result.code ?? result.signal})`);
-    return JSON.parse(stdout.trim());
-}
-async function terminateChild(child, graceMs) {
-    if (!child.pid || child.exitCode !== null || child.signalCode !== null)
-        return;
-    signalPid(child.pid, "SIGTERM");
-    await new Promise((resolve) => setTimeout(resolve, graceMs));
-    if (child.exitCode === null && child.signalCode === null)
-        signalPid(child.pid, "SIGKILL");
-}
-function signalPid(pid, signal) { try {
-    process.kill(process.platform === "win32" ? pid : -pid, signal);
-}
-catch { } }
-function minimalEnvironment(explicit = {}) {
-    const env = {};
-    for (const name of ["PATH", "TMPDIR", "TMP", "TEMP", "SYSTEMROOT"])
-        if (process.env[name] !== undefined)
-            env[name] = process.env[name];
-    return { ...env, ...explicit };
+    return `<!doctype html><html><head><meta charset="utf-8"><title>goah status</title><style>body{font:14px ui-monospace;margin:32px;background:#101418;color:#dce3e4}section{margin:32px 0}pre{white-space:pre-wrap;border:1px solid #334;padding:12px}</style></head><body><h1>goah</h1><p>seq ${ledger.events().at(-1)?.seq ?? 0}</p><section><h2>Team</h2><table>${rows(deriveTeam(ledger))}</table></section><section><h2>Goals</h2><table>${rows(ledger.goals())}</table></section><section><h2>Wakes</h2><table>${rows(ledger.wakes())}</table></section><section><h2>Mailbox</h2><table>${rows(ledger.mailbox())}</table></section></body></html>`;
 }
 function escapeHtml(value) { return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;"); }
-function interactionMailId(wake) { return wake.triggerRef.startsWith("interaction:") ? wake.triggerRef.slice("interaction:".length) : null; }
-function handoffBlocked(handoff) { return "goalId" in handoff ? handoff.outcome === "blocked" : Boolean(handoff.blocker); }
-function handoffTriggersCeo(handoff) { return "goalId" in handoff ? handoff.outcome === "blocked" || handoff.outcome === "completion_proposed" : Boolean(handoff.material || handoff.blocker); }
-function goalBoundCapability(method) { return ["goal.delegate", "goal.reassign", "goal.revise", "goal.put", "work_record.update", "mail.send", "schedule.set", "human.request"].includes(method); }
+function messageTextContent(content) { if (typeof content === "string")
+    return content; if (!Array.isArray(content))
+    return ""; return content.map((part) => part && typeof part === "object" && !Array.isArray(part) && part.type === "text" ? String(part.text ?? "") : "").filter(Boolean).join("\n"); }
+function goalBoundCapability(method) { return ["goal.delegate", "goal.reassign", "goal.revise", "goal.put", "work_record.update", "schedule.set", "human.request"].includes(method); }
 function asRecord(value) { if (typeof value !== "object" || value === null || Array.isArray(value))
     throw new Error("RPC params must be an object"); return value; }
+function boundedJson(value, maxChars = 2_000) { const text = typeof value === "string" ? value : JSON.stringify(value); return text.length <= maxChars ? text : `${text.slice(0, maxChars)}…`; }
+function recoveryRef(turnId) { return `recovery:${turnId}`; }
+function recoveryScheduleId(turnId, attempt) { return `${recoveryRef(turnId)}:${attempt}`; }
+function childRetryExhaustedRef(turnId) { return `child-retry-exhausted:${turnId}`; }
+function childRetryExhaustedTurnId(triggerRef) { return triggerRef.startsWith("child-retry-exhausted:") ? triggerRef.slice("child-retry-exhausted:".length) || null : null; }
+function parseRecoveryTrigger(triggerRef) { if (!triggerRef.startsWith("recovery:"))
+    return null; const [turnId, rawAttempt] = triggerRef.slice("recovery:".length).split("@")[0].split(":"); if (!turnId)
+    return null; const attempt = rawAttempt === undefined ? 0 : Number(rawAttempt); return Number.isInteger(attempt) && attempt >= 0 ? { turnId, attempt } : null; }
+function mailIdFromTriggerRef(triggerRef) { if (!triggerRef.startsWith("mail:"))
+    return null; return triggerRef.slice("mail:".length).split("@redelivery:")[0] || null; }
+function mailDeliveryAttempt(triggerRef, base) { if (triggerRef === base)
+    return 0; const prefix = `${base}@redelivery:`; if (!triggerRef.startsWith(prefix))
+    return null; const attempt = Number(triggerRef.slice(prefix.length)); return Number.isInteger(attempt) && attempt > 0 ? attempt : null; }
 function numberArray(value) { if (!Array.isArray(value) || value.some((item) => typeof item !== "number"))
     throw new Error("RPC evidence must be a number array"); return value; }
+function isSameNumbers(left, right) { return left.length === right.length && left.every((value, index) => value === right[index]); }
 function asChildGoal(value) {
     const input = asRecord(value ?? null);
     return { id: String(input.id), objective: String(input.objective), observationMethod: String(input.observationMethod), verificationMethod: String(input.verificationMethod), owner: String(input.owner) };
 }
 function defaultCapabilities(role) {
     if (role === "ceo")
-        return ["ledger.search", "mail.send", "schedule.set", "action.submit", "audit.ack", "team.list", "goal.get", "goal.create", "goal.work", "goal.delegate", "goal.reassign", "goal.revise", "goal.pause", "goal.resume", "goal.complete", "human.request", "work_record.list", "work_record.read", "work_record.history", "work_record.diff", "work_record.search", "work_record.update"];
-    if (role === "verifier")
-        return ["ledger.search", "mail.send", "memory.append", "audit.write"];
-    if (role === "audit")
-        return ["ledger.search", "mail.send", "memory.append", "audit.write"];
-    return ["ledger.search", "mail.send", "schedule.set", "action.submit", "audit.ack", "goal.get", "work_record.list", "work_record.read", "work_record.history", "work_record.diff", "work_record.search", "work_record.update"];
+        return ["ledger.search", "mail.send", "schedule.set", "team.list", "goal.get", "goal.create", "goal.work", "goal.delegate", "goal.reassign", "goal.revise", "goal.pause", "goal.resume", "goal.complete", "human.request", "work_record.list", "work_record.read", "work_record.history", "work_record.diff", "work_record.search", "work_record.update"];
+    if (role === "verifier" || role === "audit")
+        return ["ledger.search", "mail.send", "memory.append"];
+    return ["ledger.search", "mail.send", "schedule.set", "goal.get", "work_record.list", "work_record.read", "work_record.history", "work_record.diff", "work_record.search", "work_record.update"];
 }
 export * from "./verification.js";
 export * from "./roles.js";