@goah/cli 0.13.0 → 0.13.2

package/dist/chunk-QBD6EJ2Z.js

@@ -0,0 +1,1746 @@
+import { createRequire as __goahCreateRequire } from "node:module";
+const require = __goahCreateRequire(import.meta.url);
+import {
+  goalStream,
+  memoryStream,
+  wakeStream
+} from "./chunk-KAO7WIXG.js";
+import {
+  assertAgentHandoff,
+  assertHandoff,
+  assertTurnOutput,
+  goalAutomaticTarget,
+  goalCommitment,
+  goalRoute,
+  humanInboxRoute,
+  humanRequestRoute,
+  noGoalCommitment,
+  normalizeAssistantText,
+  specialistAutomaticTarget,
+  specialistInboxRoute
+} from "./chunk-TJON22J4.js";
+
+// node_modules/goah-supervisor/dist/index.js
+import { randomUUID } from "node:crypto";
+
+// node_modules/goah-supervisor/dist/context-view.js
+function selectRecoveryEvents(events) {
+  const unknownCalls = new Set(events.filter((event) => event.type === "tool.completed" && field(field(event.data, "result"), "outcome") === "unknown").map((event) => String(field(event.data, "callId"))));
+  return events.filter((event) => {
+    if (["transcript.interrupted", "context.compacted"].includes(event.type))
+      return true;
+    if (event.type === "tool.called")
+      return unknownCalls.has(String(field(event.data, "callId")));
+    if (event.type === "tool.completed")
+      return unknownCalls.has(String(field(event.data, "callId")));
+    return false;
+  });
+}
+function selectWorkingMemory(events, charBudget) {
+  const notes = events.filter((event) => event.type === "memory.appended");
+  const tail = [];
+  let used = 0;
+  for (let index = notes.length - 1; index >= 0; index -= 1) {
+    const event = notes[index];
+    const length = String(field(event.data, "note") ?? "").length;
+    if (tail.length > 0 && used + length > charBudget)
+      break;
+    tail.push(event);
+    used += length;
+  }
+  return tail.reverse();
+}
+function composeActiveContext(input) {
+  const handoff = input.lastHandoff?.data;
+  const sourceSeqs = /* @__PURE__ */ new Set();
+  if (input.lastHandoff)
+    sourceSeqs.add(input.lastHandoff.seq);
+  for (const event of input.teamHandoffs)
+    sourceSeqs.add(event.seq);
+  for (const event of input.recoveryEvents)
+    sourceSeqs.add(event.seq);
+  for (const event of input.workingMemory ?? [])
+    sourceSeqs.add(event.seq);
+  const sections = [
+    ["Objectives", input.goals.map((goal) => `- [${goal.id}] ${goal.objective} (owner: ${goal.owner}, phase: ${goal.phase}, revision: ${goal.revision})`)],
+    ["Observation methods", input.goals.map((goal) => `## ${goal.id}
+
+${goal.observationMethod ?? "MISSING \u2014 inspect the project and request authoritative confirmation before claiming progress or completion."}`)],
+    ["Verification methods", input.goals.map((goal) => `## ${goal.id}
+
+${goal.verificationMethod ?? "MISSING \u2014 define authoritative completion evidence before claiming completion."}`)],
+    ["Wake", [...input.wakeTriggers.filter((trigger) => trigger.status === "pending").map((trigger) => `- [${trigger.source}] ${trigger.triggerRef}`), `- Attempt: ${input.wake.attempt}`]],
+    ["Working memory", (input.workingMemory ?? []).map((event) => `- ${String(field(event.data, "note") ?? "")} [event:${event.seq}]`)],
+    ["Last outcome", typeof handoff?.outcome === "string" ? [`- ${handoff.outcome}${input.lastHandoff ? ` [event:${input.lastHandoff.seq}]` : ""}`] : []],
+    ["Incoming", input.mail.map((mail) => `- [${mail.level}] ${mail.id} from ${mail.from}${mail.goalId ? ` for Goal ${mail.goalId}` : ""}: ${render(mail.body, 2e3)}`)],
+    ["Team motion", input.team.map((member) => `- ${member.agent}: motion=${member.motion}; outcome=${member.lastOutcome ?? "none"}; goals=${member.goalIds.join(",") || "none"}; next=${member.nextWakeAt ?? "none"}; handoff=${member.lastHandoffSeq ?? "none"}`)],
+    ["Team handoffs", input.teamHandoffs.map((event) => `- ${event.actor}: ${render(event.data)} [event:${event.seq}]`)],
+    ["Recovery", input.recoveryEvents.map((event) => `- ${event.type}: ${render(event.data)} [event:${event.seq}]`)]
+  ];
+  const text = sections.filter(([, values]) => values.length > 0).map(([title, values]) => `# ${title}
+
+${values.join("\n")}`).join("\n\n");
+  return { role: input.role, capabilities: input.capabilities, systemPrompt: input.systemPrompt, text, sourceSeqs: [...sourceSeqs].sort((a, b) => a - b) };
+}
+function render(value, maxChars = Number.POSITIVE_INFINITY) {
+  const text = typeof value === "string" ? value : JSON.stringify(value);
+  return text.length <= maxChars ? text : `${text.slice(0, maxChars)}\u2026`;
+}
+function field(value, key) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value[key] : void 0;
+}
+
+// node_modules/goah-supervisor/dist/roles.js
+var prompts = {
+  child: "Own the assigned Child Goal. Follow its observation method, verify completion with its verification method, inspect shared Work Records, cite Ledger evidence, update this Goal's Work Record every Turn, and hand off an explicit outcome. Handoff is declarative: use mail.send to notify or escalate, setting its typed goalId route to the parent Goal when it should wake the parent's next committed Turn; use schedule.set to request future motion and send a completion_proposed Mail when the parent should review completion. You are not a task-only worker and cannot redefine or complete your own Goal.",
+  ceo: `You are the user's sole operating interface and the durable CEO identity for this Goal tree. You organize work; you do not impersonate child execution.
+
+On the first wake for a root with no observation method, operationalize the goal before claiming measurable progress: inspect the current directory with read/edit/write/bash; read project documentation, configuration, code, scripts, local CLIs, and existing ledger evidence; clarify the objective, constraints, baseline, and meaning of success; identify the data source or qualitative inspection protocol; define freshness, cadence, time zone, sustain window, and missing-data behavior when relevant; list the exact access required; then propose a textual observation method to the human. Ask only for facts or permissions that cannot be discovered locally. Continue safe reversible exploration while waiting. Never invent a baseline, data source, permission, success criterion, or observation result.
+
+On every wake: (1) orient from the root and descendants, each current observation method and revision, Team motion, incoming mail, handoffs, blockers, unknown Tool Calls, and recovery facts; (2) diagnose every active child's motion, ownership, and adherence to its authoritative observation method; (3) decide whether to keep, delegate, revise the objective/method pair, reassign, pause, resume, complete, or escalate; (4) apply organization changes only through the high-level atomic tools; (5) repair every idle_unplanned child and every child missing an observation method before handoff; (6) close with active child motion plus a CEO review, an explicit wait/blocker, a human request, or a completion recommendation carrying evidence produced under the current method.
+
+Use goal.delegate rather than separate goal/mail/schedule calls. Execute ambiguous or exploratory work yourself until a stream has a bounded objective, independent observation and verification methods, and a reviewable result; only then create a distinct Goal-owning Agent. Use team.list as the roster source of truth. Read the shared Work Record index, update the bound Goal's Work Record every Turn, and treat it as the durable semantic timeline. Handoff is declarative: use mail.send for explicit organization communication, schedule.set for future motion, and human.request when Human authority is required. Never claim authority to confirm Root methods, complete, or materially change a Root Goal: request the Human instead.`,
+  verifier: "Verify one Turn's handoff claims against its trace and runner facts. Do not trust self-report. Persist concise findings with exact evidence sequences.",
+  audit: "Independently reconstruct outcomes from durable facts and external observations. Persist independent audit judgment with memory_append; it never substitutes for fresh evidence."
+};
+function defaultRolePrompt(role) {
+  return prompts[role];
+}
+function defaultTurnPrompt(role, agent, turn) {
+  if (role === "ceo") {
+    if (agent !== "ceo")
+      throw new Error("only the primary Agent may use the CEO role");
+    if (turn.goalCommitment)
+      return defaultRolePrompt(role);
+    return "You are Goah's primary Agent. Respond naturally to the Human and use tools when useful. The active Root Goal, when present, is context rather than an assignment. Do not create or commit to a Goal for routine single-turn work. When the Human expresses durable intent or asks you to advance the active Goal, use the available Goal creation or Goal work tool; only then maintain its Work Record and finish with a Handoff.";
+  }
+  if (role === "child") {
+    if (!turn.goalCommitment)
+      throw new Error("Child Agents require a Goal commitment");
+    return defaultRolePrompt(role);
+  }
+  if (turn.goalCommitment)
+    throw new Error("Specialist Agents cannot commit to a Goal");
+  return `${defaultRolePrompt(role)} You are Goah specialist ${agent}. Inspect the supplied system context and finish with an ordinary response.`;
+}
+
+// node_modules/goah-supervisor/dist/verification.js
+import { createHash } from "node:crypto";
+import { spawn } from "node:child_process";
+var ProcessVerifierModel = class {
+  spec;
+  constructor(spec) {
+    this.spec = spec;
+  }
+  verifyTurn(input) {
+    return this.#call("verify_turn", input);
+  }
+  blindAudit(facts) {
+    return this.#call("blind_audit", { facts });
+  }
+  async #call(operation, input) {
+    const env = {};
+    for (const name of ["PATH", "TMPDIR", "TMP", "TEMP", "SYSTEMROOT"])
+      if (process.env[name] !== void 0)
+        env[name] = process.env[name];
+    const child = spawn(this.spec.command, this.spec.args, { detached: process.platform !== "win32", env: { ...env, ...this.spec.env }, stdio: ["pipe", "pipe", "pipe"] });
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+    let outputOverflow = false;
+    const kill = () => {
+      if (child.pid) {
+        try {
+          process.kill(process.platform === "win32" ? child.pid : -child.pid, "SIGKILL");
+        } catch {
+        }
+      }
+    };
+    const append = (channel, chunk) => {
+      const text = chunk.toString();
+      const remaining = Math.max(0, 1e6 - stdout.length - stderr.length);
+      if (channel === "stdout")
+        stdout += text.slice(0, remaining);
+      else
+        stderr += text.slice(0, remaining);
+      if (text.length > remaining && !outputOverflow) {
+        outputOverflow = true;
+        kill();
+      }
+    };
+    child.stdout.on("data", (chunk) => append("stdout", chunk));
+    child.stderr.on("data", (chunk) => append("stderr", chunk));
+    child.stdin.end(`${JSON.stringify({ operation, input })}
+`);
+    const timer = setTimeout(() => {
+      timedOut = true;
+      kill();
+    }, this.spec.timeoutMs ?? 6e4);
+    let code;
+    try {
+      code = await new Promise((resolve, reject) => {
+        child.once("error", reject);
+        child.once("close", resolve);
+      });
+    } finally {
+      clearTimeout(timer);
+    }
+    if (outputOverflow)
+      throw new Error("verifier output exceeded 1 MB");
+    if (code !== 0)
+      throw new Error(timedOut ? "verifier process timed out" : stderr.trim() || `verifier exited ${code}`);
+    return JSON.parse(stdout);
+  }
+};
+var VerificationPlane = class {
+  ledger;
+  supervisor;
+  model;
+  constructor(ledger, supervisor, model) {
+    this.ledger = ledger;
+    this.supervisor = supervisor;
+    this.model = model;
+  }
+  async verifyTurn(turnId) {
+    const turn = this.ledger.turn(turnId);
+    if (!turn)
+      throw new Error(`Turn not found: ${turnId}`);
+    if (turn.status === "in_progress")
+      throw new Error("cannot verify an in-progress Turn");
+    const trace = this.ledger.readStream(`turn:${turnId}`);
+    const handoff = this.ledger.turnItems(turnId).findLast((item) => item.type === "handoff")?.data ?? null;
+    const result = await this.model.verifyTurn({ turnId, handoff, trace });
+    this.#validate(result);
+    const thread = this.ledger.thread(turn.threadId);
+    if (!thread)
+      throw new Error("verified Turn has no Thread");
+    const level = result.findings.length ? "decision" : "fyi";
+    const body = { type: "verification_result", turnId, agent: thread.agent, findings: result.findings, tokensUsed: result.tokensUsed };
+    let route;
+    if (turn.goalId) {
+      const goal = this.ledger.goal(turn.goalId);
+      if (!goal || goal.owner !== thread.agent)
+        throw new Error("verified committed Turn no longer matches its owner");
+      route = goalRoute(turn.goalId);
+    } else if (thread.role === "ceo") {
+      route = humanInboxRoute();
+    } else {
+      if (thread.role !== "verifier" && thread.role !== "audit")
+        throw new Error("verified uncommitted Turn is not a Specialist");
+      route = specialistInboxRoute(thread.role);
+    }
+    const mail = { id: this.#mailId("verification", turnId, thread.agent, result), to: thread.agent, from: "verifier", level, ...route, body, readAt: null };
+    this.ledger.putMail(mail, "verifier");
+    return result;
+  }
+  async auditGlobal(sinceSeq = 0) {
+    const facts = this.ledger.eventsSince(sinceSeq).filter((event) => !["handoff.recorded", "runner.note"].includes(event.type));
+    const result = await this.model.blindAudit(facts);
+    this.#validate(result);
+    this.ledger.putMail({ id: this.#mailId("audit", String(sinceSeq), "ceo", result), to: "ceo", from: "audit", level: result.findings.length ? "decision" : "fyi", ...humanInboxRoute(), body: { type: "audit_result", sinceSeq, findings: result.findings, tokensUsed: result.tokensUsed }, readAt: null }, "audit");
+    return result;
+  }
+  #validate(result) {
+    const evidence = new Set(this.ledger.events().map((event) => event.seq));
+    for (const finding of result.findings)
+      if (!finding.id.trim() || finding.evidence.length === 0 || finding.evidence.some((seq) => !evidence.has(seq)))
+        throw new Error("verification finding requires an id and existing evidence");
+  }
+  #mailId(kind, source, recipient, result) {
+    const digest = createHash("sha256").update(JSON.stringify(result)).digest("hex").slice(0, 16);
+    return `${kind}:${source}:${recipient}:${digest}`;
+  }
+};
+function evaluateVerification(labels, predictedIds) {
+  const predicted = new Set(predictedIds);
+  const positives = labels.filter((label) => label.shouldFlag);
+  const truePositives = positives.filter((label) => predicted.has(label.id));
+  const falsePositives = labels.filter((label) => !label.shouldFlag && predicted.has(label.id));
+  const precision = truePositives.length + falsePositives.length === 0 ? 1 : truePositives.length / (truePositives.length + falsePositives.length);
+  const totalRisk = positives.reduce((sum, label) => sum + label.riskWeight, 0);
+  const recalledRisk = truePositives.reduce((sum, label) => sum + label.riskWeight, 0);
+  return { precision, riskWeightedRecall: totalRisk === 0 ? 1 : recalledRisk / totalRisk };
+}
+function calibrateVerificationThreshold(labels, predictions, minimumPrecision) {
+  const candidates = [...new Set(predictions.map((prediction) => prediction.score))].sort((a, b) => a - b);
+  let selected = 1;
+  let bestRecall = -1;
+  for (const threshold of candidates) {
+    const metrics = evaluateVerification(labels, predictions.filter((prediction) => prediction.score >= threshold).map((prediction) => prediction.id));
+    if (metrics.precision >= minimumPrecision && metrics.riskWeightedRecall > bestRecall) {
+      selected = threshold;
+      bestRecall = metrics.riskWeightedRecall;
+    }
+  }
+  return selected;
+}
+
+// node_modules/goah-supervisor/dist/index.js
+var RunnerRouter = class {
+  runners;
+  fallback;
+  isolation = "process";
+  #byPid = /* @__PURE__ */ new Map();
+  constructor(runners, fallback = "default") {
+    this.runners = runners;
+    this.fallback = fallback;
+  }
+  prepare(request) {
+    const context = request.context && typeof request.context === "object" && !Array.isArray(request.context) ? request.context : {};
+    const profile = context.runnerProfile && typeof context.runnerProfile === "object" && !Array.isArray(context.runnerProfile) ? context.runnerProfile : {};
+    const id = typeof profile.id === "string" ? profile.id : this.fallback;
+    const runner = this.runners.get(id);
+    if (!runner)
+      throw new Error(`runner profile is not configured: ${id}`);
+    const handle = runner.prepare(request);
+    if (handle.pid !== null && Number.isInteger(handle.pid) && handle.pid > 0)
+      this.#byPid.set(handle.pid, runner);
+    void handle.result.then(() => {
+      if (handle.pid !== null && Number.isInteger(handle.pid) && handle.pid > 0)
+        this.#byPid.delete(handle.pid);
+    }, () => {
+      if (handle.pid !== null && Number.isInteger(handle.pid) && handle.pid > 0)
+        this.#byPid.delete(handle.pid);
+    });
+    return handle;
+  }
+  async terminateProcess(pid, runnerProfileId) {
+    const runner = this.#byPid.get(pid) ?? this.runners.get(runnerProfileId ?? this.fallback);
+    if (!runner)
+      return;
+    await runner.terminateProcess(pid);
+  }
+};
+var Supervisor = class {
+  ledger;
+  clock;
+  #leaseMs;
+  #memoryTailChars;
+  #claimTail = Promise.resolve();
+  #humanTail = Promise.resolve();
+  #retryPolicy;
+  #turnRetryPolicy;
+  #profiles;
+  #runnerProfiles;
+  #handles = /* @__PURE__ */ new Map();
+  #executions = /* @__PURE__ */ new Map();
+  #agentExecutions = /* @__PURE__ */ new Map();
+  #goalExecutionBarriers = /* @__PURE__ */ new Map();
+  #handoffValidations = /* @__PURE__ */ new Map();
+  #handoffAttemptSeq = /* @__PURE__ */ new Map();
+  #runner;
+  constructor(ledger, runner, clock, options = {}) {
+    this.ledger = ledger;
+    this.clock = clock;
+    this.#runner = runner;
+    this.#leaseMs = options.leaseMs ?? 3e4;
+    this.#memoryTailChars = options.memoryTailChars ?? 12e3;
+    this.#retryPolicy = options.retryPolicy ?? { maxAttempts: 0, baseDelayMs: 1e3 };
+    this.#turnRetryPolicy = options.turnRetryPolicy ?? { maxAttempts: 3, baseDelayMs: 1e3 };
+    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])]);
+    for (const thread of this.ledger.threads()) {
+      const configured = this.#profiles.get(thread.agent)?.role ?? (thread.agent === "ceo" ? "ceo" : "child");
+      if (configured !== thread.role)
+        throw new Error(`Agent ${thread.agent} role conflicts with persisted Thread role ${thread.role}`);
+    }
+    for (const goal of this.ledger.goals().filter((candidate) => candidate.phase !== "complete")) {
+      if (!this.#validGoalOwner(goal.owner, goal))
+        throw new Error(`Agent ${goal.owner} role conflicts with persisted ${goal.parentId === null ? "Root" : "Child"} Goal ${goal.id}`);
+    }
+    this.#runnerProfiles = new Map((options.runnerProfiles ?? []).map((profile) => [profile.id, profile]));
+  }
+  /**
+   * 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.turns().filter((turn) => turn.status === "in_progress");
+    if (active.length > 0)
+      throw new Error("cannot swap runner while a Turn is in progress");
+    this.#runner = runner;
+    if (profiles) {
+      this.#runnerProfiles.clear();
+      for (const profile of profiles)
+        this.#runnerProfiles.set(profile.id, profile);
+    }
+  }
+  get runner() {
+    return this.#runner;
+  }
+  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((goal2) => goal2.parentId === null && goal2.owner === "ceo" && goal2.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", void 0, { 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`, { goalId: goal.id });
+    if (!wake)
+      throw new Error("CEO wake was not admitted for an active root goal");
+    return { goal, wake };
+  }
+  threadFor(agent = "ceo") {
+    const parentThreadId = agent === "ceo" ? null : this.threadFor("ceo").id;
+    const role = this.#role(agent);
+    const existing = this.ledger.threads().find((thread2) => thread2.agent === agent && thread2.parentThreadId === parentThreadId);
+    if (existing) {
+      if (existing.role !== role)
+        throw new Error(`Agent ${agent} role changed from ${existing.role} to ${role}`);
+      return existing;
+    }
+    const now = this.#now();
+    const thread = { id: randomUUID(), agent, role, 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 startHumanGoalTurn(objective, id = randomUUID()) {
+    if (!objective.trim())
+      throw new Error("root objective is required");
+    const previous = this.#humanTail;
+    let release;
+    this.#humanTail = new Promise((resolve) => {
+      release = resolve;
+    });
+    await previous;
+    try {
+      const goal = { id, parentId: null, objective, observationMethod: null, verificationMethod: null, owner: "ceo", phase: "active", revision: 0 };
+      const accepted = await this.#startHumanTurn(`/goal ${objective}`, goal);
+      return { ...accepted, steered: false, goal: this.#goal(id) };
+    } finally {
+      release();
+    }
+  }
+  async #startHumanTurn(message, newRoot = null) {
+    if (!message.trim())
+      throw new Error("message is required");
+    const existingThread = this.ledger.threads().find((candidate) => candidate.agent === "ceo");
+    const now = this.#now();
+    const thread = existingThread ? { ...existingThread, updatedAt: now } : { id: randomUUID(), agent: "ceo", role: "ceo", parentThreadId: null, createdAt: now, updatedAt: now };
+    const active = existingThread ? this.ledger.activeTurn(existingThread.id) : null;
+    if (active) {
+      if (active.triggerKind === "user_message" && !newRoot) {
+        const handle = this.#handles.get(active.id);
+        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");
+          }
+        } else if (!handle) {
+          this.#appendTurnItem(active.id, "user_message", { text: message }, "human");
+          return { threadId: thread.id, turnId: active.id, steered: true };
+        }
+      }
+    }
+    const replacement = this.ledger.activeTurn(thread.id);
+    const turnStartedAt = this.#now();
+    const turn = { id: randomUUID(), threadId: thread.id, triggerKind: "user_message", ...newRoot ? goalCommitment(newRoot.id, newRoot.revision) : noGoalCommitment(), status: "in_progress", attempt: 1, error: null, startedAt: turnStartedAt, endedAt: null, leaseUntil: new Date(this.clock.now().getTime() + this.#leaseMs).toISOString(), leaseToken: randomUUID(), runnerPid: null, runnerProfileId: this.#runnerProfileId("ceo") };
+    const messageItem = { id: randomUUID(), turnId: turn.id, ordinal: 1, type: "user_message", status: "completed", data: { text: message }, createdAt: turnStartedAt, completedAt: turnStartedAt };
+    const admitted = this.ledger.admitHumanTurn({ thread: { ...thread, updatedAt: turnStartedAt }, turn, messageItem, replaceTurnId: replacement?.id ?? null, ...newRoot ? { rootGoal: newRoot } : {} });
+    const interruptedGoalId = replacement?.triggerKind === "wake" ? replacement.goalId : null;
+    if (interruptedGoalId) {
+      const goal = this.ledger.goal(interruptedGoalId);
+      if (goal?.phase === "active")
+        this.#enqueueTrigger(goal.owner, `human-interrupted:${replacement.id}`, { goalId: goal.id });
+    }
+    const context = { trigger: { kind: "user_message" }, activeGoal: newRoot ?? this.currentRoot(), goalCommitment: newRoot ? { goalId: newRoot.id, goalRevision: newRoot.revision } : null };
+    const deliveredMail = this.#contextMail("ceo", newRoot?.id ?? null);
+    const recordRevisionAtStart = newRoot ? this.ledger.workRecord(newRoot.id)?.recordRevision ?? -1 : -1;
+    await this.#activateAdmittedHumanTurn(admitted.turn, admitted.replacedTurn, context, deliveredMail, recordRevisionAtStart);
+    return { threadId: thread.id, turnId: turn.id, steered: false };
+  }
+  async interruptTurn(turnId) {
+    return this.#interruptTurn(turnId, "interrupted by Human", "human");
+  }
+  async #interruptTurn(turnId, reason, actor) {
+    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: reason }, this.#now(), actor);
+    await this.#cleanupTerminalTurn(turn);
+    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;
+      let processClean = true;
+      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;
+        processClean = await this.#terminateHandle(initial.id, handle);
+        this.#handles.delete(initial.id);
+        if (!processClean)
+          throw new Error("Runner process cleanup did not complete");
+        const attached = this.ledger.turn(initial.id);
+        if (attached?.status === "in_progress" && attached.runnerPid !== null)
+          this.ledger.releaseTurnProcess(initial.id, "supervisor");
+        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;
+        }
+        const response = normalizeAssistantText(result.response.content);
+        if (!response)
+          throw new Error("completed Turn requires a readable assistant response");
+        if (turnContext.goalCommitment) {
+          if (!result.handoff)
+            throw new Error("committed Turn requires Handoff");
+          this.#commitTurnGoalWork(current.id, agent, turnContext, response, result.handoff, sourceWake?.id ?? null, deliveredMailIds, recordRevisionAtStart);
+          return;
+        }
+        if (result.handoff)
+          throw new Error("uncommitted Turn cannot finish with Handoff");
+        const latestMessage = this.ledger.turnItems(current.id).findLast((item) => item.type === "assistant_message" && item.status === "completed");
+        if (latestMessage) {
+          const traced = normalizeAssistantText(String(latestMessage.data.text ?? ""));
+          if (traced !== response)
+            throw new Error("completed Turn response does not match its latest assistant trace");
+          if (this.#assistantCommitState(current.id, traced) !== "committed")
+            throw new Error("uncommitted Turn requires a committed assistant trace");
+        } else
+          this.#appendTurnItem(current.id, "assistant_message", { text: response }, agent);
+        this.ledger.finishTurn(current.id, "completed", null, this.#now(), "supervisor", deliveredMailIds);
+        return;
+      } catch (error) {
+        if (renewal)
+          clearInterval(renewal);
+        if (handle && processClean)
+          processClean = await this.#terminateHandle(initial.id, handle);
+        this.#handles.delete(initial.id);
+        let current = this.ledger.turn(initial.id);
+        if (processClean && current?.status === "in_progress" && current.runnerPid !== null) {
+          this.ledger.releaseTurnProcess(initial.id, "supervisor");
+          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 #activateAdmittedHumanTurn(turn, replaced, context, mail, recordRevisionAtStart) {
+    if (replaced) {
+      this.#clearHandoffState(replaced.id);
+      if (!await this.#cleanupTerminalTurn(replaced)) {
+        this.#failTurn(turn.id, "previous Runner cleanup did not complete");
+        this.#scheduleTurnRecovery(null, [], turn.id, "ceo");
+        return;
+      }
+    } else
+      await this.#awaitAgentExecution("ceo");
+    for (const fence of this.ledger.turns(turn.threadId).filter((candidate) => candidate.status !== "in_progress" && candidate.runnerPid !== null)) {
+      if (!await this.#cleanupTerminalTurn(fence)) {
+        this.#failTurn(turn.id, "previous Runner cleanup did not complete");
+        this.#scheduleTurnRecovery(null, [], turn.id, "ceo");
+        return;
+      }
+    }
+    const current = this.ledger.turn(turn.id);
+    if (current?.status !== "in_progress")
+      return;
+    const activated = { ...current, leaseUntil: new Date(this.clock.now().getTime() + this.#leaseMs).toISOString() };
+    this.ledger.putTurn(activated, "supervisor");
+    this.#trackExecution(activated, "ceo", context, () => this.#humanContext(turn.id, "ceo", mail), null, mail.map((item) => item.id), recordRevisionAtStart);
+  }
+  async #cleanupTerminalTurn(turn) {
+    const handle = this.#handles.get(turn.id);
+    let cleaned = true;
+    try {
+      if (handle)
+        cleaned = await this.#terminateHandle(turn.id, handle);
+      else if (turn.runnerPid)
+        await this.runner.terminateProcess(turn.runnerPid, turn.runnerProfileId);
+    } catch (error) {
+      this.#recordCleanupFailure(turn.id, error);
+      cleaned = false;
+    } finally {
+      this.#handles.delete(turn.id);
+    }
+    if (!cleaned)
+      return false;
+    await this.#executions.get(turn.id);
+    const stored = this.ledger.turn(turn.id);
+    if (stored && stored.status !== "in_progress" && stored.runnerPid !== null) {
+      try {
+        this.ledger.releaseTurnProcess(turn.id, "supervisor");
+      } catch (error) {
+        this.#recordCleanupFailure(turn.id, error);
+        return false;
+      }
+    }
+    return true;
+  }
+  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.goalId !== null && turn.goalRevision !== null) {
+      const goal = this.#goal(turn.goalId);
+      const context2 = { trigger: { kind: "user_message" }, activeGoal: goal, goalCommitment: { goalId: turn.goalId, goalRevision: turn.goalRevision } };
+      const base = this.#loadContext({ ...goalAutomaticTarget(agent, turn.goalId), attempt: turn.attempt }, context2, mail, []);
+      const sourceSeqs2 = Array.isArray(base.sourceSeqs) ? base.sourceSeqs.filter((value) => typeof value === "number") : [];
+      return { ...base, text: `${String(base.text ?? "")}
+
+# Current Turn
+
+${current}`, sourceSeqs: [.../* @__PURE__ */ new Set([...sourceSeqs2, ...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 activeGoal = this.currentRoot();
+    const context = { trigger: { kind: "user_message" }, activeGoal, goalCommitment: null };
+    const goalText = activeGoal ? [`# Active Goal context
+
+[${activeGoal.id}] ${activeGoal.objective} (phase: ${activeGoal.phase}, revision: ${activeGoal.revision}). This is visible context, not a commitment to advance it.`] : [];
+    return { text: [...recent.length ? [`# Recent conversation
+
+${recent.join("\n")}`] : [], ...goalText, ...incoming.length ? [`# Incoming
+
+${incoming.join("\n")}`] : [], `# Current Turn
+
+${current}`].join("\n\n"), sourceSeqs, activeGoal, 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 ?? "")}
+
+# Current Turn retry history
+
+${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");
+  }
+  #assistantCommitState(turnId, text) {
+    const canonical = normalizeAssistantText(text);
+    const event = this.ledger.readStream(`turn:${turnId}`).findLast((candidate) => {
+      if (candidate.type !== "message.assistant.completed" || !candidate.data || typeof candidate.data !== "object" || Array.isArray(candidate.data))
+        return false;
+      const message = candidate.data.message;
+      return messageTextContent(message?.content) === canonical;
+    });
+    if (!event || !event.data || typeof event.data !== "object" || Array.isArray(event.data))
+      return null;
+    const state = event.data.commitState;
+    return state === "committed" || state === "provisional" ? state : null;
+  }
+  #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.goalId === goalId);
+    if (!turn)
+      return;
+    this.#clearHandoffState(turn.id);
+    this.ledger.finishTurn(turn.id, "interrupted", { message: reason }, this.#now(), "supervisor");
+    void this.#cleanupTerminalTurn(turn);
+  }
+  async #terminateHandle(turnId, handle) {
+    try {
+      await handle.terminate();
+      return true;
+    } catch (error) {
+      this.#recordCleanupFailure(turnId, error);
+      const turn = this.ledger.turn(turnId);
+      const persistedPid = turn?.runnerPid;
+      if (persistedPid === null || persistedPid === void 0)
+        return handle.pid === null;
+      try {
+        await this.runner.terminateProcess(persistedPid, turn?.runnerProfileId);
+        return true;
+      } catch (fallback) {
+        this.#recordCleanupFailure(turnId, fallback);
+        return false;
+      }
+    }
+  }
+  #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) {
+    const turn = this.ledger.turn(turnId);
+    if (!turn)
+      return;
+    const role = this.#role(agent);
+    const goal = turn.goalId ? this.ledger.goal(turn.goalId) : null;
+    if (turn.goalId && (!goal || goal.phase !== "active" || goal.owner !== agent) || !turn.goalId && (turn.triggerKind !== "wake" || role !== "verifier" && role !== "audit"))
+      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 target = goal ? goalAutomaticTarget(agent, goal.id) : specialistAutomaticTarget(agent, role);
+      this.ledger.putSchedule({ id: recoveryScheduleId(turnId, next), ...target, 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;
+    if (type === "message.assistant.completed") {
+      const value = data && typeof data === "object" && !Array.isArray(data) ? data : {};
+      if (!["committed", "provisional"].includes(String(value.commitState)))
+        throw new Error("Runner assistant completion is missing normalized commit state");
+      if (value.commitState === "provisional" && this.ledger.turn(turnId)?.goalId === null)
+        throw new Error("uncommitted Turn cannot emit a provisional assistant response");
+    }
+    this.ledger.appendTurnEvent({ streamId: `turn:${turnId}`, ts: this.#now(), actor, type, data }, leaseToken);
+    if (type === "message.assistant.completed") {
+      const value = data;
+      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);
+    }
+  }
+  async sendToCeo(body) {
+    const value = body && typeof body === "object" && !Array.isArray(body) ? body : {};
+    const message = String(value.message ?? "").trim();
+    if (!message)
+      throw new Error("CEO message is required");
+    const accepted = await this.startHumanTurn(message);
+    await this.waitForTurn(accepted.turnId);
+    return accepted;
+  }
+  async waitForTurn(turnId) {
+    await this.#executions.get(turnId);
+  }
+  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;
+    const gate = active ? Promise.withResolvers() : null;
+    if (gate)
+      this.#goalExecutionBarriers.set(goal.id, gate.promise);
+    try {
+      const result = this.ledger.commitReassignment(request, actor, wakeId);
+      if (active?.goalId === goal.id && this.ledger.turn(active.id)?.status === "in_progress")
+        await this.#interruptTurn(active.id, "Goal reassigned to another Agent", "supervisor");
+      return result;
+    } finally {
+      gate?.resolve();
+      if (gate && this.#goalExecutionBarriers.get(goal.id) === gate.promise)
+        this.#goalExecutionBarriers.delete(goal.id);
+    }
+  }
+  teamList(now = this.#now()) {
+    return deriveTeam(this.ledger, now);
+  }
+  currentRoot() {
+    return this.ledger.goals().find((goal) => goal.parentId === null && goal.owner === "ceo" && goal.phase !== "complete") ?? null;
+  }
+  agentRole(agent) {
+    return this.#role(agent);
+  }
+  updateGoal(id, patch, actor = "human", change) {
+    if (patch.objective === void 0 && patch.observationMethod === void 0 && patch.verificationMethod === void 0)
+      throw new Error("goal update requires objective, observation method, or verification method");
+    const current = this.#goal(id);
+    this.#assertGoalMutationAuthority(current, actor);
+    if (patch.objective !== void 0 && patch.objective !== current.objective && current.parentId !== null && (patch.observationMethod === void 0 || patch.verificationMethod === void 0))
+      throw new Error("child objective revision requires replacement observation and verification methods");
+    const next = {
+      ...current,
+      ...patch,
+      ...patch.objective !== void 0 && patch.objective !== current.objective && current.parentId === null && patch.observationMethod === void 0 ? { observationMethod: null } : {},
+      ...patch.objective !== void 0 && patch.objective !== current.objective && current.parentId === null && patch.verificationMethod === void 0 ? { verificationMethod: null } : {},
+      revision: current.revision + 1
+    };
+    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 } : {} });
+    this.#preemptGoalTurn(current.id, "Goal definition changed");
+    if (next.parentId === null && next.owner === "ceo" && actor === "human")
+      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", { reason: "Human confirmed the Root observation and verification method", evidence: [] });
+  }
+  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");
+    if (!reason.trim())
+      throw new Error("goal revision reason 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}`);
+    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, { reason, evidence, ...wakeId ? { sourceWakeId: wakeId } : {}, ...sourceTurnId ? { sourceTurnId } : {} });
+  }
+  completeGoal(request, actor = "human", wakeId) {
+    const goal = this.ledger.completeGoal(request, actor, wakeId);
+    this.#preemptGoalTurn(goal.id, "Goal completed");
+    return goal;
+  }
+  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 };
+    const operation = phase === "paused" ? "pause" : phase === "blocked" ? "block" : "resume";
+    this.ledger.putGoal(next, actor, void 0, { operation, reason: `Goal ${operation} requested by ${actor}`, evidence: [], ...sourceTurnId ? { sourceTurnId } : {} });
+    this.#preemptGoalTurn(current.id, `Goal ${operation}`);
+    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, 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 executionTarget = binding ? goalAutomaticTarget(agent, binding.goalId) : specialistAutomaticTarget(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 target = role === "verifier" || role === "audit" ? null : goalId ? { goalId } : this.#singleActiveGoalTarget(agent);
+    if (role !== "verifier" && role !== "audit" && !target)
+      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") && (target ? item.targetKind === "goal" && item.goalId === target.goalId : item.targetKind === "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 && (target ? turn.goalId === target.goalId : turn.goalId === null && turn.triggerKind === "wake"))
+      await this.interruptTurn(turn.id);
+    return wake ? this.#wake(wake.id) : null;
+  }
+  async recover() {
+    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" && candidate.runnerPid !== null)) {
+      await this.runner.terminateProcess(turn.runnerPid, turn.runnerProfileId);
+      this.ledger.releaseTurnProcess(turn.id, "supervisor");
+    }
+    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.ledger.releaseTurnProcess(turn.id, "supervisor");
+      }
+      this.#failTurn(turn.id, "orphaned Runner ownership recovered after Supervisor restart");
+      const thread = this.ledger.thread(turn.threadId);
+      if (!thread)
+        continue;
+      if (turn.goalId) {
+        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.triggerKind === "wake" && (thread.role === "verifier" || thread.role === "audit"))
+        this.#enqueueTrigger(thread.agent, recoveryRef(turn.id));
+    }
+  }
+  async tick() {
+    const wake = await this.#claimNextWake();
+    if (!wake)
+      return null;
+    let createdTurnId = null;
+    try {
+      await this.#awaitAgentExecution(wake.agent);
+      let currentWake = this.#wake(wake.id);
+      if (currentWake.targetKind === "goal")
+        await this.#goalExecutionBarriers.get(currentWake.goalId);
+      currentWake = this.#wake(wake.id);
+      if (currentWake.status !== "claimed")
+        return currentWake;
+      if (currentWake.targetKind === "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);
+        }
+      }
+      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);
+      }
+      const thread = this.threadFor(currentWake.agent);
+      const now = this.#now();
+      const leaseToken = randomUUID();
+      const commitment = turnContext.goalCommitment ?? noGoalCommitment();
+      const execution = { id: randomUUID(), threadId: thread.id, triggerKind: "wake", ...commitment, 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.agent, currentWake.targetKind === "goal" ? currentWake.goalId : null);
+      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.goalCommitment ? this.ledger.workRecord(turnContext.goalCommitment.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 (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() {
+    const previous = this.#claimTail;
+    let release;
+    this.#claimTail = new Promise((resolve) => {
+      release = resolve;
+    });
+    await previous;
+    try {
+      for (const schedule of this.ledger.dueSchedules(this.#now()))
+        this.#enqueueSchedule(schedule);
+      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 } : void 0;
+        const specialistInteraction = mail.routeKind === "specialist_inbox" && this.#role(mail.to) === mail.specialistRole;
+        if (!target && !specialistInteraction)
+          continue;
+        const base = `mail:${mail.id}`;
+        const related = this.ledger.wakeTriggersForAgent(mail.to).map((trigger2) => ({ trigger: trigger2, attempt: mailDeliveryAttempt(trigger2.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();
+    }
+  }
+  async runAvailable(concurrency = 4, maxWakes = 100) {
+    const completed = [];
+    while (true) {
+      const batch = await Promise.all(Array.from({ length: concurrency }, () => this.tick()));
+      const wakes = batch.filter((wake) => wake !== null);
+      completed.push(...wakes);
+      if (wakes.length === 0 || completed.length >= maxWakes)
+        return completed;
+    }
+  }
+  #enqueueSchedule(schedule) {
+    if (schedule.status !== "pending")
+      return null;
+    if (schedule.targetKind === "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.targetKind === "goal" ? goalAutomaticTarget(schedule.agent, schedule.goalId) : specialistAutomaticTarget(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;
+  }
+  #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 = goalAutomaticTarget(agent, target.goalId);
+    } else {
+      const role = this.#role(agent);
+      if (role === "verifier" || role === "audit")
+        binding = specialistAutomaticTarget(agent, role);
+      else
+        return null;
+    }
+    const sameBinding = (wake2) => wake2.targetKind === binding.targetKind && wake2.goalId === binding.goalId && wake2.specialistRole === binding.specialistRole;
+    const exact = this.ledger.wakeByTrigger(agent, triggerRef);
+    if (exact) {
+      if (!sameBinding(exact))
+        throw new Error("Wake trigger was reused with a different automatic target");
+      return exact;
+    }
+    const pending = this.ledger.wakes().find((wake2) => wake2.agent === agent && wake2.status === "claimed" && sameBinding(wake2)) ?? this.ledger.wakes().find((wake2) => wake2.agent === agent && wake2.status === "queued" && sameBinding(wake2));
+    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);
+    const existing = this.ledger.wakeByTrigger(agent, triggerRef);
+    if (!existing)
+      throw new Error("deduplicated wake is missing");
+    return existing;
+  }
+  #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 } : void 0;
+  }
+  #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.ledger.threads().find((thread) => thread.agent === agent)?.role ?? 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.goalCommitment) {
+      const goal = this.ledger.goal(turn.goalCommitment.goalId);
+      return Boolean(goal && this.#validGoalOwner(agent, goal) && (role === "ceo" || role === "child"));
+    }
+    if (turn.trigger.kind === "user_message")
+      return agent === "ceo" && role === "ceo";
+    return role === "verifier" || role === "audit";
+  }
+  #commitTurnGoalWork(turnId, agent, turn, response, raw, sourceWakeId, mailIds, revisionAtStart) {
+    const binding = turn.goalCommitment;
+    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("committed 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.message !== response || 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 result");
+    const responseItem = [...this.ledger.turnItems(turnId)].reverse().find((item2) => item2.type === "assistant_message" && item2.status === "completed" && item2.data.text === validation.message);
+    if (!responseItem)
+      throw new Error("accepted Handoff response was not recorded in the Turn");
+    const output = this.#committedTurnOutput(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);
+  }
+  #committedTurnOutput(output, binding) {
+    const record = this.ledger.workRecord(binding.goalId);
+    if (!record)
+      throw new Error("Goal Work Record is missing");
+    const handoff = {
+      goalId: binding.goalId,
+      goalRevision: binding.goalRevision,
+      recordRevision: record.recordRevision,
+      outcome: output.handoff.outcome,
+      evidence: output.handoff.evidence
+    };
+    return { handoff };
+  }
+  #turnContext(wake, triggers = this.ledger.wakeTriggers(wake.id).filter((trigger) => trigger.status === "pending")) {
+    const trigger = { kind: "wake", reasons: triggers.map((item) => item.triggerRef) };
+    if (wake.targetKind === "specialist")
+      return { trigger, activeGoal: null, goalCommitment: null };
+    const goal = this.#goal(wake.goalId);
+    return { trigger, activeGoal: goal, goalCommitment: { goalId: goal.id, goalRevision: goal.revision } };
+  }
+  #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");
+    const goals = role === "ceo" ? this.ledger.goals() : this.ledger.goalsForOwner(wake.agent);
+    const handoff = turn.goalCommitment ? this.ledger.lastGoalHandoff(turn.goalCommitment.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 workingMemory = selectWorkingMemory(this.ledger.readStream(memoryStream(wake.agent)), this.#memoryTailChars);
+    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.goalCommitment ? this.ledger.workRecord(turn.goalCommitment.goalId) : null;
+    const currentGoal = turn.goalCommitment ? this.ledger.goal(turn.goalCommitment.goalId) : null;
+    const parentRecord = currentGoal?.parentId ? this.ledger.workRecord(currentGoal.parentId) : null;
+    const recordIndex = records.map((record) => `- /goals/${record.goalId}.md \xB7 r${record.recordRevision} \xB7 ${this.ledger.goal(record.goalId)?.owner ?? "unknown"} \xB7 ${this.ledger.goal(record.goalId)?.phase ?? "unknown"}`);
+    const workText = [`# Shared Work Record Index
+
+${recordIndex.join("\n")}`, ...currentRecord ? [`# Your Work Record
+
+${currentRecord.content}`] : [], ...parentRecord ? [`# Parent Work Record
+
+${parentRecord.content}`] : []].join("\n\n");
+    return { ...active, text: `${active.text}
+
+${workText}`, activeGoal: turn.activeGoal, goalCommitment: turn.goalCommitment, sourceSeqs: [.../* @__PURE__ */ new Set([...active.sourceSeqs, ...this.#mailSourceSeqs(mail), ...records.map((record) => record.lastEventSeq)])].sort((a, b) => a - b), workRecord: currentRecord, sharedWorkRecords: records, ...runnerProfile ? { runnerProfile } : {} };
+  }
+  #wake(id) {
+    const value = this.ledger.wake(id);
+    if (!value)
+      throw new Error(`wake not found: ${id}`);
+    return value;
+  }
+  #goal(id) {
+    const value = this.ledger.goal(id);
+    if (!value)
+      throw new Error(`goal not found: ${id}`);
+    return value;
+  }
+  #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();
+  }
+  #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(agent, goalId) {
+    const selected = [];
+    let used = 0;
+    const role = this.#role(agent);
+    const matches = (mail) => goalId ? mail.routeKind === "goal" && mail.goalId === goalId : role === "ceo" ? mail.routeKind === "human_inbox" : mail.routeKind === "specialist_inbox" && mail.specialistRole === role;
+    for (const mail of this.ledger.unreadMail(agent).filter(matches)) {
+      const cost = Math.min(JSON.stringify(mail.body).length, 2e3) + 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.goalCommitment) {
+      const goal = this.ledger.goal(context.goalCommitment.goalId);
+      const thread = this.ledger.thread(execution.threadId);
+      if (!goal || goal.phase !== "active" || goal.revision !== context.goalCommitment.goalRevision || goal.owner !== agent || execution.goalId !== goal.id || execution.goalRevision !== goal.revision || thread?.agent !== agent)
+        throw new Error("stale committed 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 (!context.goalCommitment && goalBoundCapability(method))
+      throw new Error(`${method} requires a Goal commitment`);
+    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") {
+      const visibleId = context.goalCommitment?.goalId ?? context.activeGoal?.id;
+      return visibleId ? this.ledger.goal(visibleId) : null;
+    }
+    if (method === "goal.create") {
+      if (context.trigger.kind !== "user_message" || context.goalCommitment || agent !== "ceo")
+        throw new Error("Root Goal creation requires an uncommitted direct CEO Turn");
+      const goal = this.createRootGoal(String(input.objective), typeof input.id === "string" ? input.id : void 0, turnId);
+      context.activeGoal = goal;
+      context.goalCommitment = { goalId: goal.id, goalRevision: goal.revision };
+      this.ledger.commitTurnToGoal(turnId, context.goalCommitment, "supervisor");
+      return { goal, goalCommitment: context.goalCommitment };
+    }
+    if (method === "goal.work") {
+      if (context.trigger.kind !== "user_message" || context.goalCommitment)
+        throw new Error("work_on_goal requires an uncommitted direct CEO Turn");
+      const goal = this.#goal(String(input.goalId));
+      if (goal.phase !== "active" || !this.#validGoalOwner(agent, goal))
+        throw new Error("work_on_goal requires the active owned Root Goal");
+      context.activeGoal = goal;
+      context.goalCommitment = { goalId: goal.id, goalRevision: goal.revision };
+      this.ledger.commitTurnToGoal(turnId, context.goalCommitment, "supervisor");
+      return { goal, goalCommitment: context.goalCommitment };
+    }
+    if (method === "work_record.list")
+      return this.ledger.workRecords();
+    if (method === "work_record.read")
+      return this.ledger.workRecord(String(input.goalId ?? context.goalCommitment?.goalId ?? context.activeGoal?.id ?? ""));
+    if (method === "work_record.history")
+      return this.ledger.workRecordHistory(String(input.goalId ?? context.goalCommitment?.goalId ?? context.activeGoal?.id ?? ""));
+    if (method === "work_record.diff")
+      return this.ledger.workRecordDiff(String(input.goalId ?? context.goalCommitment?.goalId ?? context.activeGoal?.id ?? ""), 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") {
+      const binding = context.goalCommitment;
+      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.goalCommitment;
+      if (String(input.parentGoalId) !== binding.goalId)
+        throw new Error("delegation parent must be the Goal committed 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.goalCommitment.goalId)
+        throw new Error("reassignment target must be a child of the Goal committed 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), agent, String(input.reason), numberArray(input.evidence), sourceWakeId, turnId);
+    if (method === "goal.pause" || method === "goal.resume") {
+      const goal = this.#goal(String(input.goalId));
+      const directRoot = !context.goalCommitment && context.trigger.kind === "user_message" && goal.parentId === null;
+      if (!context.goalCommitment && !directRoot)
+        throw new Error(`${method} requires a Goal commitment`);
+      const next = this.transitionGoal(goal.id, method === "goal.pause" ? "paused" : "active", directRoot ? "human" : agent, !directRoot, turnId);
+      if (method === "goal.resume" && directRoot) {
+        context.activeGoal = next;
+        context.goalCommitment = { goalId: next.id, goalRevision: next.revision };
+        this.ledger.commitTurnToGoal(turnId, context.goalCommitment, "supervisor");
+        return { goal: next, goalCommitment: context.goalCommitment };
+      }
+      return next;
+    }
+    if (method === "goal.complete") {
+      const goal = this.#goal(String(input.goalId));
+      const directRoot = !context.goalCommitment && context.trigger.kind === "user_message" && goal.parentId === null;
+      if (!context.goalCommitment && !directRoot)
+        throw new Error("goal.complete requires a Goal commitment or direct Human Root authority");
+      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: 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 === "schedule.set")
+      return this.planWake(agent, String(input.at), String(input.reason), agent, context.goalCommitment ?? void 0) ?? { 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 event = this.ledger.appendEvent({ streamId: memoryStream(agent), ts: this.#now(), actor: agent, type: "memory.appended", data: { note, turnId } });
+      return { seq: event.seq };
+    }
+    throw new Error(`unsupported Agent capability: ${method}`);
+  }
+  #validateHandoffDraft(turnId, attemptId, agent, execution, context, input) {
+    if (!context.goalCommitment || execution.goalId === null)
+      return { accepted: false, fatal: true, attemptId, issues: [{ code: "turn_not_committed", message: "This Turn no longer has a Goal commitment." }] };
+    const request = { handoff: input.handoff ?? null, candidateMessage: String(input.candidateMessage ?? "") };
+    const issues = [];
+    try {
+      assertAgentHandoff(request.handoff);
+    } 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 = normalizeAssistantText(request.candidateMessage) || normalizeAssistantText(String(existingMessage?.data?.text ?? ""));
+    if (!message)
+      issues.push({ code: "message_missing", message: "This committed Turn needs a readable assistant message before it can finish." });
+    const goal = this.ledger.goal(context.goalCommitment.goalId);
+    if (!goal || goal.phase !== "active" || goal.owner !== agent || goal.revision !== context.goalCommitment.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 commitment." }] };
+    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 };
+  }
+  #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);
+  }
+};
+async function runSupervisorDaemon(supervisor, options = {}) {
+  const pollMs = options.pollMs ?? 1e3;
+  await supervisor.recover();
+  while (!options.signal?.aborted) {
+    try {
+      await supervisor.runAvailable(options.concurrency ?? 4);
+    } catch (error) {
+      options.onError?.(error);
+    }
+    await new Promise((resolve) => {
+      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();
+    });
+  }
+}
+function deriveTeam(ledger, now = (/* @__PURE__ */ 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) => {
+      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 value = lastHandoff?.data;
+    const lastOutcome = typeof value?.outcome === "string" ? value.outcome : null;
+    let motion;
+    if (live.length === 0)
+      motion = "retired";
+    else if (activeTurn)
+      motion = "running";
+    else if (activeWake)
+      motion = "queued";
+    else if (nextWakeAt)
+      motion = "scheduled";
+    else
+      motion = "idle";
+    return { agent, goalIds: owned.map((goal) => goal.id), motion, lastOutcome, lastHandoffSeq: lastHandoff?.seq ?? null, lastWakeStatus: agentWakes[0]?.status ?? null, nextWakeAt };
+  });
+}
+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.goalId ? ledger.goal(turn.goalId) : null;
+    const goalFailure = Boolean(thread && goal && goal.phase === "active" && goal.owner === thread.agent);
+    const specialistFailure = Boolean(!turn.goalId && thread && (thread.role === "verifier" || thread.role === "audit") && sourceWake?.targetKind === "specialist" && sourceWake.agent === thread.agent && sourceWake.specialistRole === thread.role);
+    if (!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.targetKind === "goal" && schedule.goalId === goal.id : schedule.targetKind === "specialist" && thread && schedule.specialistRole === thread.role;
+      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?.targetKind === "goal" && wake.goalId === goal.id : wake?.targetKind === "specialist" && thread && wake.specialistRole === thread.role;
+      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?.targetKind === "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;
+}
+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>Mailbox</h2><table>${rows(ledger.mailbox())}</table></section></body></html>`;
+}
+function escapeHtml(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+function messageTextContent(content) {
+  if (typeof content === "string")
+    return normalizeAssistantText(content);
+  if (!Array.isArray(content))
+    return "";
+  return content.map((part) => part && typeof part === "object" && !Array.isArray(part) && part.type === "text" ? normalizeAssistantText(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 = 2e3) {
+  const text = typeof value === "string" ? value : JSON.stringify(value);
+  return text.length <= maxChars ? text : `${text.slice(0, maxChars)}\u2026`;
+}
+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 === void 0 ? 0 : Number(rawAttempt);
+  return Number.isInteger(attempt) && attempt >= 0 ? { turnId, attempt } : 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", "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 {
+  selectRecoveryEvents,
+  composeActiveContext,
+  defaultRolePrompt,
+  defaultTurnPrompt,
+  ProcessVerifierModel,
+  VerificationPlane,
+  evaluateVerification,
+  calibrateVerificationThreshold,
+  RunnerRouter,
+  Supervisor,
+  runSupervisorDaemon,
+  deriveTeam,
+  deriveRecoveryViews,
+  renderDashboard
+};