@coreplane/switchboard 1.260.6 → 1.261.1

package/dist/cli.js

@@ -195,7 +195,9 @@ async function ensureWorkArea(at, version2, workers, deps) {
     deps.log(`[deploy] materialised the shipped tree (version ${version2}) under ${at.workArea}`);
   }
   if (plan3.install.length > 0) {
-    deps.log(`[deploy] npm ci --workspace ${plan3.install.join(" --workspace ")} under ${at.workArea}`);
+    deps.log(
+      `[deploy] npm ci --include-workspace-root --workspace ${plan3.install.join(" --workspace ")} under ${at.workArea}`
+    );
     const r = await deps.install(at.workArea, plan3.install);
     if (r.code !== 0)
       return {
@@ -241,10 +243,22 @@ function packageSourceOnHost(at = OPERATOR_ROOT) {
 function cliVersionOnHost(at = OPERATOR_ROOT) {
   return at.mode === "package" ? packageSourceOnHost(at).version : packageVersion();
 }
+function workAreaNpmCiArgs(workspaces) {
+  return [
+    "ci",
+    "--include-workspace-root",
+    "--no-audit",
+    "--no-fund",
+    ...workspaces.flatMap((w) => ["--workspace", w])
+  ];
+}
 function npmCi(cwd, workspaces) {
   return new Promise((resolve13) => {
-    const args = ["ci", "--no-audit", "--no-fund", ...workspaces.flatMap((w) => ["--workspace", w])];
-    const child = spawn("npm", args, { cwd, env: process.env, stdio: ["ignore", "pipe", "pipe"] });
+    const child = spawn("npm", workAreaNpmCiArgs(workspaces), {
+      cwd,
+      env: process.env,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
     let output = "";
     child.stdout.on("data", (c) => output += c.toString());
     child.stderr.on("data", (c) => output += c.toString());
@@ -3264,7 +3278,7 @@ function renewalDecision(input) {
   };
 }
 function renderRenewal(decision, grant2, options = {}) {
-  const recourse = options.idle ? "the next reply in this thread continues the unit" : "the next reply in this thread continues the original task";
+  const recourse = options.idle ? "the next reply in this thread continues the unit" : "start ship again with the original task";
   const senders = options.senders?.length ? `, with ${options.senders.length} message${options.senders.length === 1 ? "" : "s"} from ${options.senders.join(", ")}` : "";
   if (decision.renew)
     return `budget renewed, ${decision.segment - 1} of ${grant2.renewals}, continues ${decision.from !== void 0 ? decision.from.slice(0, 7) : "the branch's head"}${senders}`;
@@ -3564,11 +3578,11 @@ function buildReviewPostBody(answer, verdict, target) {
     ...target ? [`head \`${target.head.slice(0, 7)}\``] : [],
     verdict ? findingCounts(verdict.findings) : "the run ended without a submit_verdict call"
   ];
-  const parts = [verdictLine(verdict), `> [!${calloutKind(verdict)}]
+  const fixedParts = [verdictLine(verdict), `> [!${calloutKind(verdict)}]
 > ${facts2.join(" \xB7 ")}`];
   const findings = verdict?.findings ?? [];
   if (findings.length > 0) {
-    parts.push(
+    fixedParts.push(
       [
         "| Severity | Finding | Where |",
         "| --- | --- | --- |",
@@ -3578,15 +3592,25 @@ function buildReviewPostBody(answer, verdict, target) {
       ].join("\n")
     );
   }
+  const marker = verdictMarker(verdict, target);
+  const fixedBody = [...fixedParts, marker].join("\n\n");
   const prose2 = answer.trim();
-  if (prose2) parts.push(`<details>
+  if (!prose2) return fixedBody;
+  const details2 = (text, truncated) => `<details>
 <summary>Full review</summary>
 
-${prose2}
+${text}${truncated ? `${text ? "\n\n" : ""}${REVIEW_TRUNCATION_NOTE}` : ""}
 
-</details>`);
-  parts.push(verdictMarker(verdict, target));
-  return parts.join("\n\n");
+</details>`;
+  const render3 = (text, truncated) => [...fixedParts, details2(text, truncated), marker].join("\n\n");
+  const full = render3(prose2, false);
+  if ([...full].length <= MAX_REVIEW_POST_CODE_POINTS) return full;
+  const clippedShell = render3("", true);
+  const proseSeparatorCodePoints = 2;
+  const proseBudget = MAX_REVIEW_POST_CODE_POINTS - [...clippedShell].length - proseSeparatorCodePoints;
+  if (proseBudget > 0) return render3([...prose2].slice(0, proseBudget).join(""), true);
+  if ([...clippedShell].length <= MAX_REVIEW_POST_CODE_POINTS) return clippedShell;
+  return full;
 }
 function buildReviewChannelReply(input) {
   const { answer, verdict, posted, liveUrl } = input;
@@ -3675,7 +3699,7 @@ function redactVerdict(v, redact = redactSecrets) {
 function redactDispositions(dispositions, redact = redactSecrets) {
   return dispositions.map((d) => ({ findingId: d.findingId, disposition: d.disposition, note: redact(d.note) }));
 }
-var FINDING_SEVERITIES, ADDRESS_SEVERITIES, DEFAULT_ADDRESS_SEVERITY, isAddressSeverity, severityRank, LGTM_TOKEN, CHANGES_TOKEN, NO_VERDICT_LINE, escapeMarkdownTableCell, unescapeMarkdownTableCell, isRepoPath, VERDICT_KINDS, DISPOSITION_KINDS, isRecordLike, REVIEW_POST_HEAD;
+var FINDING_SEVERITIES, ADDRESS_SEVERITIES, DEFAULT_ADDRESS_SEVERITY, isAddressSeverity, severityRank, LGTM_TOKEN, CHANGES_TOKEN, NO_VERDICT_LINE, MAX_REVIEW_POST_CODE_POINTS, REVIEW_TRUNCATION_NOTE, escapeMarkdownTableCell, unescapeMarkdownTableCell, isRepoPath, VERDICT_KINDS, DISPOSITION_KINDS, isRecordLike, REVIEW_POST_HEAD;
 var init_reviewVerdict = __esm({
   "../../src/core/reviewVerdict.ts"() {
     "use strict";
@@ -3690,6 +3714,8 @@ var init_reviewVerdict = __esm({
     LGTM_TOKEN = "LGTM:";
     CHANGES_TOKEN = "Changes requested:";
     NO_VERDICT_LINE = "No verdict submitted \u2014 not approving.";
+    MAX_REVIEW_POST_CODE_POINTS = 65e3;
+    REVIEW_TRUNCATION_NOTE = "_(review truncated to fit GitHub's review size limit)_";
     escapeMarkdownTableCell = (text) => oneLine2(text).replace(/\\/g, "\\\\").replace(/\|/g, "\\|");
     unescapeMarkdownTableCell = (text) => text.replace(/\\([\\|])/g, "$1");
     isRepoPath = (file) => /^[^\s`]+$/.test(file) && !/^[a-z][a-z0-9+.-]*:\/\//i.test(file);
@@ -3711,10 +3737,10 @@ function interruptionCauseOfWords(words) {
   return void 0;
 }
 function shipInterruptedNote(prUrl3, cause, idle = false) {
-  const stands = prUrl3 ? `Its work stands on GitHub: ${prUrl3}.` : "Whatever it pushed stands on its pipeline branch; no PR was opened yet.";
-  const continuation = idle ? "The next reply in this thread continues the unit." : prUrl3 ? `The pipeline kept its task, branch and pull request; the next reply in this thread continues the review loop at ${prUrl3}.` : "The pipeline kept its task and branch; the next reply in this thread starts round 0 again on that branch.";
-  const opening = cause === "container_replaced" ? "\u26A0\uFE0F The resident container running this pipeline's child was replaced (a deploy's image swap) and the child could not resume, so the pipeline stopped." : cause === "sandbox_fault" ? "\u26A0\uFE0F The sandbox running this pipeline's child failed and the child could not resume, so the pipeline stopped." : cause === "bot_restart" ? "\u26A0\uFE0F The bot restarted while this ship pipeline was running, so the pipeline stopped." : "\u26A0\uFE0F This ship pipeline's child was interrupted and could not resume, so the pipeline stopped.";
-  return `${opening} ${stands} ${continuation}`;
+  const opening = cause === "container_replaced" ? "\u26A0\uFE0F Work stopped before the next review because the repository container was replaced and the run could not continue." : cause === "sandbox_fault" ? "\u26A0\uFE0F Work stopped before the next review because the sandbox failed and the run could not continue." : cause === "bot_restart" ? "\u26A0\uFE0F Work stopped before the next review because Switchboard restarted and the run could not continue." : "\u26A0\uFE0F Work stopped before the next review because the run could not continue.";
+  const saved = prUrl3 ? `The existing pull request is ${prUrl3}; Switchboard did not verify the stopped run's latest commit there.` : "No open pull request was verified for the stopped run's latest commit.";
+  const next = idle ? "The unit remains live; a reply in this thread is recorded as its continuation action." : "No review was started. Next action: start ship again after the remote branch and pull request state can be verified.";
+  return `${opening} ${saved} ${next}`;
 }
 function planIdOf(planPath) {
   const base = planPath.split("/").pop() ?? "";
@@ -4078,6 +4104,7 @@ function isHeadMaterial(event) {
     case "context":
     case "reference":
     case "run_meta":
+    case "run_state":
     case "route":
       return true;
     case "run_note":
@@ -4847,7 +4874,7 @@ function analyzeRunFriction(events, opts = {}) {
       return;
     }
     if (ev.type === "artifact" && ev.direction === "out") outboundArtifacts++;
-    if (ev.type === "skill_use" || ev.type === "artifact" || ev.type === "review_artifact" || ev.type === "pr_description" || ev.type === "pr_opened" || ev.type === "coordinator_tag" || ev.type === "ship_handoff" || ev.type === "child_interrupted" || ev.type === "child_resumed" || ev.type === "review_posted" || ev.type === "ship_round" || ev.type === "ship_unit" || ev.type === "route" || ev.type === "operator" || ev.type === "refusal" || ev.type === "reference" || ev.type === "lease" || ev.type === "pushed_head") {
+    if (ev.type === "skill_use" || ev.type === "artifact" || ev.type === "review_artifact" || ev.type === "pr_description" || ev.type === "pr_opened" || ev.type === "coordinator_tag" || ev.type === "ship_handoff" || ev.type === "child_interrupted" || ev.type === "child_resumed" || ev.type === "review_posted" || ev.type === "ship_round" || ev.type === "ship_unit" || ev.type === "route" || ev.type === "operator" || ev.type === "refusal" || ev.type === "reference" || ev.type === "run_state" || ev.type === "lease" || ev.type === "pushed_head") {
       sideFactEvents++;
       return;
     }
@@ -4929,6 +4956,7 @@ function analyzeRunFriction(events, opts = {}) {
       }
       return;
     }
+    if (ev.type !== "run_note") return;
     switch (ev.kind) {
       case "wrap_up":
         wrapUp = { index, at: ev.at };
@@ -5882,6 +5910,26 @@ var init_contract2 = __esm({
 });
 
 // ../../src/core/pipelineStanding.ts
+function hostedStageDetail(stage) {
+  switch (stage) {
+    case "coding":
+      return "coding a unit";
+    case "review":
+      return "reviewing a unit";
+    case "fix":
+      return "fixing review findings";
+    case "approved":
+      return "waiting for checks and merge";
+    case "merge-ready":
+      return "ready for a person to merge";
+    case "merged":
+      return "a unit merged";
+    case "idle":
+      return "waiting for the next pipeline step";
+    case "ended":
+      return "finishing the pipeline";
+  }
+}
 function endingWordOf(kind) {
   return ENDING_WORDS[kind] ?? kind;
 }
@@ -6008,10 +6056,11 @@ function isPipelineSummaryShape(v) {
   }
   return true;
 }
-var STAGES, OPEN_STAGES, ROUND_STAGE, ENDING_STAGE, ENDING_WORDS, ROUND_OUTCOME_WORDS, isFinite_;
+var HOSTED_PIPELINE_STARTING_DETAIL, STAGES, OPEN_STAGES, ROUND_STAGE, ENDING_STAGE, ENDING_WORDS, ROUND_OUTCOME_WORDS, isFinite_;
 var init_pipelineStanding = __esm({
   "../../src/core/pipelineStanding.ts"() {
     "use strict";
+    HOSTED_PIPELINE_STARTING_DETAIL = "pipeline starting";
     STAGES = [
       "coding",
       "review",
@@ -6530,15 +6579,15 @@ function capEvent(event, maxBytes) {
   }
   return { event: capped4, bytes: size };
 }
-function fitRecordToBudget(record2, maxBytes = MAX_RECORD_BYTES) {
-  const cappedAll = record2.events.map((e) => capEvent(e, MAX_EVENT_BYTES));
-  const measure = (evs) => utf8ByteLength(JSON.stringify({ ...record2, events: evs, storedEventCount: evs.length, truncated: true }));
-  const whole = { ...record2, events: cappedAll.map((c) => c.event), storedEventCount: cappedAll.length };
+function fitRecordToBudget(record3, maxBytes = MAX_RECORD_BYTES) {
+  const cappedAll = record3.events.map((e) => capEvent(e, MAX_EVENT_BYTES));
+  const measure = (evs) => utf8ByteLength(JSON.stringify({ ...record3, events: evs, storedEventCount: evs.length, truncated: true }));
+  const whole = { ...record3, events: cappedAll.map((c) => c.event), storedEventCount: cappedAll.length };
   if (utf8ByteLength(JSON.stringify(whole)) <= maxBytes) return whole;
   const baseline = measure([]);
   const capped4 = dropSpanPairsFromTheMiddle(cappedAll, maxBytes - baseline);
   const events = capped4.map((c) => c.event);
-  if (measure(events) <= maxBytes) return { ...record2, events, storedEventCount: events.length, truncated: true };
+  if (measure(events) <= maxBytes) return { ...record3, events, storedEventCount: events.length, truncated: true };
   const sizes = capped4.map((c) => c.bytes + 1);
   let remaining = maxBytes - measure([]);
   let head = 0;
@@ -6555,7 +6604,7 @@ function fitRecordToBudget(record2, maxBytes = MAX_RECORD_BYTES) {
   while (kept.length > 0 && measure(kept) > maxBytes) {
     kept.splice(Math.floor(kept.length / 2), 1);
   }
-  return { ...record2, events: kept, storedEventCount: kept.length, truncated: true };
+  return { ...record3, events: kept, storedEventCount: kept.length, truncated: true };
 }
 function headLength(events) {
   let n2 = 0;
@@ -6673,9 +6722,9 @@ function dominantFriction(byCategory) {
   }
   return best;
 }
-function pointOf(record2, prices) {
-  if (record2.provisional === true) return void 0;
-  const usage = record2.usage ?? emptyUsage();
+function pointOf(record3, prices) {
+  if (record3.provisional === true) return void 0;
+  const usage = record3.usage ?? emptyUsage();
   const priced = llmUsdOfUsage(usage, prices);
   let inputTokens = 0;
   let outputTokens = 0;
@@ -6687,27 +6736,27 @@ function pointOf(record2, prices) {
     cacheReadTokens += m.cacheReadTokens;
     cacheWriteTokens += m.cacheWriteTokens;
   }
-  const shape = record2.diagnosis.shape;
+  const shape = record3.diagnosis.shape;
   const blobs = {
     schema: POINT_SCHEMA,
-    agent: record2.agent ?? "",
-    preset: record2.profile?.preset ?? "",
-    model: record2.model ?? "",
-    status: record2.status,
-    "failure kind": record2.failure?.kind ?? "",
-    "dominant friction": dominantFriction(record2.diagnosis.byCategory),
-    channel: record2.channelId,
-    repository: record2.repo ?? "",
-    "machine class": record2.profile?.machine ?? "",
-    "route class": record2.route !== void 0 ? "routed" : "chosen",
-    reply: record2.replyOk === true ? "ok" : record2.replyOk === false ? "failed" : "none",
-    lineage: record2.parentRunId !== void 0 ? "child" : "root",
-    requester: record2.userId,
-    identity: record2.profile?.identity ?? "",
-    "run id": record2.id
+    agent: record3.agent ?? "",
+    preset: record3.profile?.preset ?? "",
+    model: record3.model ?? "",
+    status: record3.status,
+    "failure kind": record3.failure?.kind ?? "",
+    "dominant friction": dominantFriction(record3.diagnosis.byCategory),
+    channel: record3.channelId,
+    repository: record3.repo ?? "",
+    "machine class": record3.profile?.machine ?? "",
+    "route class": record3.route !== void 0 ? "routed" : "chosen",
+    reply: record3.replyOk === true ? "ok" : record3.replyOk === false ? "failed" : "none",
+    lineage: record3.parentRunId !== void 0 ? "child" : "root",
+    requester: record3.userId,
+    identity: record3.profile?.identity ?? "",
+    "run id": record3.id
   };
   const doubles = {
-    wall: record2.finishedAt - (record2.receivedAt ?? record2.startedAt),
+    wall: record3.finishedAt - (record3.receivedAt ?? record3.startedAt),
     "getting ready": shape?.gettingReadyMs ?? 0,
     thinking: shape?.thinkingMs ?? 0,
     tools: shape?.toolsMs ?? 0,
@@ -6721,15 +6770,15 @@ function pointOf(record2, prices) {
     "cache read tokens": cacheReadTokens,
     "cache write tokens": cacheWriteTokens,
     dollars: priced.usd,
-    steps: record2.stepCount ?? 0,
-    "tool calls": isFinite_2(record2.diagnosis.toolCalls) ? record2.diagnosis.toolCalls : 0,
-    events: record2.eventCount,
+    steps: record3.stepCount ?? 0,
+    "tool calls": isFinite_2(record3.diagnosis.toolCalls) ? record3.diagnosis.toolCalls : 0,
+    events: record3.eventCount,
     "unpriced tokens": priced.unpricedTokens,
-    minutes: record2.profile?.minutes ?? 0,
-    "finished at": record2.finishedAt
+    minutes: record3.profile?.minutes ?? 0,
+    "finished at": record3.finishedAt
   };
   return {
-    indexes: [capBlob(record2.agent ?? UNKNOWN_AGENT)],
+    indexes: [capBlob(record3.agent ?? UNKNOWN_AGENT)],
     blobs: POINT_COLUMNS.blobs.map((n2) => capBlob(blobs[n2])),
     doubles: POINT_COLUMNS.doubles.map((n2) => doubles[n2])
   };
@@ -10367,12 +10416,8 @@ function containerApplicationName(script, className) {
   return `${script}-${className.toLowerCase()}`;
 }
 function bindLiveGate(gate, script, healthUrl) {
-  return gate.kind === "health" ? { kind: "health", healthUrl } : {
-    kind: "sandbox",
-    healthUrl,
-    bearerEnv: gate.bearerEnv,
-    containerApp: containerApplicationName(script, gate.containerClass)
-  };
+  const containerApp = containerApplicationName(script, gate.containerClass);
+  return gate.kind === "bot" ? { kind: "bot", healthUrl, containerApp } : { kind: "sandbox", healthUrl, bearerEnv: gate.bearerEnv, containerApp };
 }
 function workersFor(profile) {
   return WORKER_SPECS.flatMap(({ preflight, liveGate, ...spec }) => {
@@ -10387,8 +10432,8 @@ function workersFor(profile) {
         script,
         baseUrl,
         healthUrl,
-        // A preflighted step with a health gate reads the same URL for its wait heartbeat.
-        ...preflight ? { preflight: liveGate?.kind === "health" ? { ...preflight, healthUrl } : preflight } : {},
+        // The bot preflight reads the same URL as its application + health live gate.
+        ...preflight ? { preflight: liveGate?.kind === "bot" ? { ...preflight, healthUrl } : preflight } : {},
         ...liveGate ? { liveGate: bindLiveGate(liveGate, script, healthUrl) } : {}
       }
     ];
@@ -10499,7 +10544,7 @@ function formatPlan(plan3) {
   plan3.steps.forEach((s, i) => {
     const pf = s.retryOnPreflightRefusal ? ` \u2014 preflight (retry every ${plan3.pollMs / 1e3}s up to ${(s.waitMaxMs ?? plan3.waitMaxMs) / 6e4} min)` : s.forcedBy ? ` \u2014 preflight FORCED (${s.forcedBy}=1)` : "";
     const env = s.requiredEnv.length > 0 ? ` \u2014 needs ${s.requiredEnv.map((r) => r.anyOf.length === 1 ? r.anyOf[0] : `one of ${r.anyOf.join(" / ")}`).join(", ")}` : "";
-    const live = s.liveGate ? s.liveGate.kind === "health" ? ` \u2014 then wait until live (${s.liveGate.healthUrl} not draining + build.commit == HEAD)` : ` \u2014 then wait until live (${s.liveGate.healthUrl} build.commit == HEAD + every running ${s.liveGate.containerApp} instance on the app version + an /exec probe answers ok from one)` : "";
+    const live = s.liveGate ? s.liveGate.kind === "bot" ? ` \u2014 then wait until live (${s.liveGate.containerApp} advances to the deployed image + ${s.liveGate.healthUrl} build.commit exactly == HEAD)` : ` \u2014 then wait until live (${s.liveGate.healthUrl} build.commit == HEAD + every running ${s.liveGate.containerApp} instance on the app version + an /exec probe answers ok from one)` : "";
     const cap = s.capabilities.length > 0 ? ` \u2014 credential must pass ${s.capabilities.map((c) => `\`${c.command.join(" ")}\` (${c.needs})`).join(" and ")}` : "";
     lines.push(
       `  ${i + 1}. ${s.name} (${s.script}) \u2014 ${s.dir}: ${s.command.join(" ")}${pf}${env}${cap}${live}
@@ -10570,7 +10615,7 @@ function classifyDeployOutput(exitCode, output) {
   const firstError = lines.find((l) => isErrorish(l) && !/^npm ERR!/i.test(l)) ?? lines.find(isErrorish);
   return { kind: "failed", reason: firstError ?? `exit ${exitCode}` };
 }
-var UNSET_ENV, DEPLOY_FORCE_ENV, SANDBOX_CONTAINER_CLASS, SANDBOX_BEARER_ENV, R2_CAPABILITY, RESIDENT_BEARER_ENVS, RESIDENT_WAIT_MAX_MS, CONTAINERS_CAPABILITY, WORKER_DIRS, WORKER_SPECS, DEPLOY_ORDER, CONFIG_DOCUMENT_KEY, hasImage, ANSI_SEQUENCE;
+var UNSET_ENV, DEPLOY_FORCE_ENV, BOT_CONTAINER_CLASS, SANDBOX_CONTAINER_CLASS, SANDBOX_BEARER_ENV, R2_CAPABILITY, RESIDENT_BEARER_ENVS, RESIDENT_WAIT_MAX_MS, CONTAINERS_CAPABILITY, WORKER_DIRS, WORKER_SPECS, DEPLOY_ORDER, CONFIG_DOCUMENT_KEY, hasImage, ANSI_SEQUENCE;
 var init_plan = __esm({
   "../../src/deploy/plan.ts"() {
     "use strict";
@@ -10582,6 +10627,7 @@ var init_plan = __esm({
     init_profile2();
     UNSET_ENV = ["CLOUDFLARE_ACCOUNT_ID"];
     DEPLOY_FORCE_ENV = "SWITCHBOARD_DEPLOY_FORCE";
+    BOT_CONTAINER_CLASS = "SwitchboardServer";
     SANDBOX_CONTAINER_CLASS = "SwitchboardSandbox";
     SANDBOX_BEARER_ENV = "SANDBOX_TOKEN";
     R2_CAPABILITY = {
@@ -10642,10 +10688,10 @@ var init_plan = __esm({
           ]
         },
         preflight: { forceEnv: DEPLOY_FORCE_ENV, baseUrlEnv: "SWITCHBOARD_BASE_URL" },
-        liveGate: { kind: "health" },
+        liveGate: { kind: "bot", containerClass: BOT_CONTAINER_CLASS },
         // The preflight reads the container application and the deploy pushes the image: both need Containers.
         capabilities: [CONTAINERS_CAPABILITY],
-        why: "container shim \u2014 preflight refuses only over a rollout in progress (runs in flight hand off); done only when the new container is live. A rotated bot secret needs no build: `wrangler secret put` alone leaves the running container on its old env \u2014 `deploy restart` restarts it on the current env"
+        why: "container shim \u2014 preflight refuses only over a rollout in progress (runs in flight hand off); done only when the application advances to the deployed image and /healthz serves the exact commit. A rotated bot secret needs no build: `wrangler secret put` alone leaves the running container on its old env \u2014 `deploy restart` restarts it on the current application target"
       },
       {
         name: "resident",
@@ -11765,11 +11811,11 @@ var init_runStoreWorker = __esm({
       fetchImpl;
       abandoned() {
       }
-      async put(record2, trace) {
-        if (!RUN_ID_PATTERN.test(record2.id))
-          throw new PermanentStoreError(`run store: refusing to put malformed id ${JSON.stringify(record2.id)}`);
-        const body = { storeKey: this.opts.storeKey, record: record2 };
-        const point = pointOf(record2, this.opts.prices);
+      async put(record3, trace) {
+        if (!RUN_ID_PATTERN.test(record3.id))
+          throw new PermanentStoreError(`run store: refusing to put malformed id ${JSON.stringify(record3.id)}`);
+        const body = { storeKey: this.opts.storeKey, record: record3 };
+        const point = pointOf(record3, this.opts.prices);
         if (point !== void 0) body.point = point;
         if (this.opts.policy) {
           body.policy = this.opts.policy;
@@ -11939,6 +11985,66 @@ var init_supersede = __esm({
   }
 });
 
+// ../../src/deploy/botLiveGate.ts
+function judge(input) {
+  if ("error" in input.app)
+    return waiting(`container application ${input.containerApp} unreadable: ${input.app.error}`);
+  const app = input.app.value;
+  let rollout;
+  if (input.target) {
+    if (input.target.image !== null && app.image !== input.target.image)
+      return waiting(
+        `container application ${input.containerApp} still targets ${app.image ?? "an unknown image"}; expected ${input.target.image}`
+      );
+    if ("error" in input.before)
+      return waiting(
+        `container application ${input.containerApp} pre-deploy version unreadable (${input.before.error}); cannot prove the application version advanced`
+      );
+    if (app.version <= input.before.value.version)
+      return waiting(
+        `container application ${input.containerApp} is still at pre-deploy version ${input.before.value.version}; expected a newer application version`
+      );
+    rollout = ` at version ${app.version} (up from ${input.before.value.version})`;
+  } else {
+    rollout = ` at version ${app.version} (Worker-only deploy; no application change printed)`;
+  }
+  if ("error" in input.health) return waiting(`health: GET /healthz failed: ${input.health.error}`);
+  if (input.health.status !== 200)
+    return waiting(
+      `health: GET /healthz \u2192 HTTP ${input.health.status}; expected the deployed container's exact build identity`
+    );
+  if (!input.health.body || input.health.body.ok !== true)
+    return waiting("health: /healthz is not ready or did not answer with JSON");
+  const commit = servedCommit(input.health.body);
+  if (!commit) return waiting("health: /healthz carries no build identity");
+  if (commit !== input.expectedCommit)
+    return waiting(`health: serving commit ${commit}, expected exact ${input.expectedCommit}`);
+  if (input.health.body.draining === true)
+    return waiting("health: the exact deployed commit answers but its container is draining");
+  const target = input.target?.image ?? app.image ?? "an unchanged image";
+  return {
+    kind: "live",
+    summary: `container application ${input.containerApp} targets ${target}${rollout}; /healthz serves exact ${commit}`
+  };
+}
+function decideBotLive(input, deadlineMs = LIVE_GATE_DEADLINE_MS) {
+  const decision = judge(input);
+  if (decision.kind !== "waiting" || input.elapsedMs < deadlineMs) return decision;
+  return {
+    kind: "failed",
+    reason: `${decision.reason} \u2014 still not live after ${Math.round(input.elapsedMs / MINUTE_MS)} min (deadline ${deadlineMs / MINUTE_MS} min)`
+  };
+}
+var waiting;
+var init_botLiveGate = __esm({
+  "../../src/deploy/botLiveGate.ts"() {
+    "use strict";
+    init_budgets();
+    init_liveGate();
+    waiting = (reason2) => ({ kind: "waiting", reason: reason2 });
+  }
+});
+
 // ../../src/execution/sandboxErrors.ts
 function fleetBusyRunEndedLine(run2, thread, err2) {
   if (typeof err2 !== "object" || err2 === null) return null;
@@ -12025,51 +12131,51 @@ function rolloutAdvanced(app, before, target) {
     reason: `rollout: pre-deploy version unreadable (${before.error}); application image ${app.image === null ? "?" : shortImage(app.image)} is not the deploy's ${shortImage(target.image)}`
   };
 }
-function judge(input) {
+function judge2(input) {
   const worker = decideWorker(input.health, input.deployedCommit);
-  if (!worker.ok) return worker.fatal ? { kind: "failed", reason: worker.reason } : waiting(worker.reason);
-  if (input.app === null) return waiting("rollout: not read yet");
-  if ("error" in input.app) return waiting(`rollout: ${input.app.error}`);
+  if (!worker.ok) return worker.fatal ? { kind: "failed", reason: worker.reason } : waiting2(worker.reason);
+  if (input.app === null) return waiting2("rollout: not read yet");
+  if ("error" in input.app) return waiting2(`rollout: ${input.app.error}`);
   const app = input.app.value;
   const appVersion = app.version;
   let advancedFrom = null;
   if (input.target) {
     const advanced = rolloutAdvanced(app, input.before, input.target);
-    if (!advanced.ok) return waiting(advanced.reason);
+    if (!advanced.ok) return waiting2(advanced.reason);
     advancedFrom = advanced.from;
   }
-  if (input.instances === null) return waiting("rollout: instances not read yet");
-  if ("error" in input.instances) return waiting(`rollout: ${input.instances.error}`);
+  if (input.instances === null) return waiting2("rollout: instances not read yet");
+  if ("error" in input.instances) return waiting2(`rollout: ${input.instances.error}`);
   const running = input.instances.value.filter((i) => i.state === "running");
   const rolloutSummary = advancedFrom === null ? `Worker-only deploy \u2014 no container change (${running.length} running instance(s) on version ${appVersion})` : `rollout complete (${running.length} running instance(s) on version ${appVersion}, ${advancedFrom})`;
   const stale = running.filter((i) => i.version !== appVersion);
   if (stale.length > 0) {
     const versions = [...new Set(stale.map((i) => i.version === null ? "?" : String(i.version)))].join("/");
-    return waiting(
+    return waiting2(
       `rollout in progress \u2014 ${stale.length} of ${running.length} running instance(s) still on version ${versions}, app version ${appVersion}`
     );
   }
-  if (input.probe === null) return waiting("probe: not sent yet");
-  if ("error" in input.probe) return waiting(`probe: ${input.probe.error}`);
+  if (input.probe === null) return waiting2("probe: not sent yet");
+  if ("error" in input.probe) return waiting2(`probe: ${input.probe.error}`);
   const body = input.probe.body;
   if (body.reason === FLEET_BUSY_REASON)
-    return waiting("probe: fleet busy \u2014 no free instance for the probe thread (max_instances reached)");
+    return waiting2("probe: fleet busy \u2014 no free instance for the probe thread (max_instances reached)");
   if (typeof body.error === "string" && CONTAINER_STARTING.test(body.error))
-    return waiting("probe: container starting");
+    return waiting2("probe: container starting");
   if ("error" in body) {
     const failed = body.error === "" ? "/exec failed with an EMPTY error" : `/exec failed \u2014 ${typeof body.error === "string" ? body.error : JSON.stringify(body.error)}`;
-    return waiting(`probe: ${failed} \u2014 the probe's container may still run the previous image`);
+    return waiting2(`probe: ${failed} \u2014 the probe's container may still run the previous image`);
   }
   if (body.exitCode !== 0) {
     const stderr = typeof body.stderr === "string" ? body.stderr.trim() : "";
-    return waiting(`probe: \`${PROBE_COMMAND}\` exited ${String(body.exitCode)}${stderr ? `: ${stderr}` : ""}`);
+    return waiting2(`probe: \`${PROBE_COMMAND}\` exited ${String(body.exitCode)}${stderr ? `: ${stderr}` : ""}`);
   }
   const stdout = typeof body.stdout === "string" ? body.stdout.trim() : "";
-  if (stdout !== "ok") return waiting(`probe: \`${PROBE_COMMAND}\` printed ${JSON.stringify(stdout)}`);
+  if (stdout !== "ok") return waiting2(`probe: \`${PROBE_COMMAND}\` printed ${JSON.stringify(stdout)}`);
   const mine = input.instances.value.find((i) => i.name === input.probeThreadKey);
-  if (!mine) return waiting(`probe instance ${input.probeThreadKey} not listed yet`);
+  if (!mine) return waiting2(`probe instance ${input.probeThreadKey} not listed yet`);
   if (mine.version !== appVersion)
-    return waiting(
+    return waiting2(
       `probe instance ${input.probeThreadKey} is on version ${mine.version === null ? "?" : mine.version}, app version ${appVersion} \u2014 the probe landed on a previous image`
     );
   return {
@@ -12078,7 +12184,7 @@ function judge(input) {
   };
 }
 function decideSandboxLive(input, deadlineMs = LIVE_GATE_DEADLINE_MS) {
-  const d = judge(input);
+  const d = judge2(input);
   if (d.kind !== "waiting" || input.elapsedMs < deadlineMs) return d;
   return {
     kind: "failed",
@@ -12152,7 +12258,7 @@ function parseExecStream(text) {
     return { error: `/exec answered no JSON document: ${JSON.stringify(text.trim().slice(0, 120))}` };
   }
 }
-var PROBE_COMMAND, PROBE_TIMEOUT_MS, CONTAINER_STARTING, waiting, isRecord2, ANSI_SEQUENCE2, SECTION_GUTTER;
+var PROBE_COMMAND, PROBE_TIMEOUT_MS, CONTAINER_STARTING, waiting2, isRecord2, ANSI_SEQUENCE2, SECTION_GUTTER;
 var init_sandboxLiveGate = __esm({
   "../../src/deploy/sandboxLiveGate.ts"() {
     "use strict";
@@ -12161,7 +12267,7 @@ var init_sandboxLiveGate = __esm({
     PROBE_COMMAND = "echo ok";
     PROBE_TIMEOUT_MS = 6e4;
     CONTAINER_STARTING = /Container is starting/i;
-    waiting = (reason2) => ({ kind: "waiting", reason: reason2 });
+    waiting2 = (reason2) => ({ kind: "waiting", reason: reason2 });
     isRecord2 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
     ANSI_SEQUENCE2 = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, "g");
     SECTION_GUTTER = /^[\s│├╭╰|]+/;
@@ -12487,26 +12593,6 @@ async function fetchHealthz(url) {
   const r = await readHealthz(url);
   return "body" in r ? r.body : void 0;
 }
-async function waitUntilLive(step, healthUrl, expectedCommit, io, clock4, previousStartedAt) {
-  const started = clock4();
-  for (; ; ) {
-    const elapsed2 = clock4() - started;
-    const body = await fetchHealthz(healthUrl);
-    const d = decideLive(body, expectedCommit, elapsed2, LIVE_GATE_DEADLINE_MS, {
-      ...previousStartedAt !== void 0 ? { previousStartedAt } : {}
-    });
-    if (d.kind === "live") return { live: true, detail: `commit ${d.commit.slice(0, 7)}`, waitedMs: elapsed2 };
-    if (d.kind === "timeout")
-      return {
-        live: false,
-        reason: `${d.reason} \u2014 gave up after ${Math.round(elapsed2 / 6e4)} min (drain deadline ${LIVE_GATE_DEADLINE_MS / 6e4} min)`
-      };
-    io.log(
-      `[deploy:all] ${step.name}: deployed, not live yet \u2014 ${d.reason} (${Math.floor(elapsed2 / 6e4)}m ${Math.floor(elapsed2 % 6e4 / 1e3)}s)`
-    );
-    await sleep(LIVE_GATE_POLL_MS);
-  }
-}
 async function wranglerJson(dir, args) {
   const r = await run("npx", ["wrangler", ...args], { cwd: workerDir(dir), unset: UNSET_ENV });
   if (r.code !== 0)
@@ -12527,6 +12613,29 @@ async function resolveContainerAppId(dir, containerApp) {
   containerAppIds.set(containerApp, id);
   return { value: id };
 }
+async function waitUntilBotLive(step, gate, expectedCommit, rollout, io, deps = defaultSandboxGateDeps) {
+  const started = deps.now();
+  for (; ; ) {
+    const elapsed2 = deps.now() - started;
+    const app = await deps.readAppState(step.dir, gate.containerApp);
+    const health = await deps.readHealth(gate.healthUrl);
+    const decision = decideBotLive({
+      containerApp: gate.containerApp,
+      health,
+      app,
+      before: rollout.before,
+      target: rollout.target,
+      expectedCommit,
+      elapsedMs: elapsed2
+    });
+    if (decision.kind === "live") return { live: true, detail: decision.summary, waitedMs: deps.now() - started };
+    if (decision.kind === "failed") return { live: false, reason: decision.reason };
+    io.log(
+      `[deploy:all] ${step.name}: deployed, not live yet \u2014 ${decision.reason} (${Math.floor(elapsed2 / 6e4)}m ${Math.floor(elapsed2 % 6e4 / 1e3)}s)`
+    );
+    await deps.sleep(LIVE_GATE_POLL_MS);
+  }
+}
 async function waitUntilSandboxLive(step, gate, expectedCommit, rollout, io, deps = defaultSandboxGateDeps) {
   const bearer = deps.env[gate.bearerEnv];
   if (!bearer)
@@ -12567,7 +12676,7 @@ async function waitUntilSandboxLive(step, gate, expectedCommit, rollout, io, dep
 async function readAppBeforeUpload(step, gate, io, deps) {
   const before = await deps.readAppState(step.dir, gate.containerApp);
   io.log(
-    "value" in before ? `[deploy:all] ${step.name}: container application at version ${before.value.version}${before.value.image ? ` (image ${shortImage(before.value.image)})` : ""} before the upload` : `[deploy:all] ${step.name}: could not read the container application before the upload \u2014 ${before.error}; the gate will need the deploy's image to show`
+    "value" in before ? `[deploy:all] ${step.name}: container application at version ${before.value.version}${before.value.image ? ` (image ${shortImage(before.value.image)})` : ""} before the upload` : gate.kind === "sandbox" ? `[deploy:all] ${step.name}: could not read the container application before the upload \u2014 ${before.error}; the gate will need the deploy's image to show` : `[deploy:all] ${step.name}: could not read the container application before the upload \u2014 ${before.error}; the gate requires a readable pre-deploy version to prove advancement`
   );
   return before;
 }
@@ -12643,8 +12752,7 @@ async function deployStepLoop(step, plan3, expectedCommit, io, deps, exec, root,
   for (; ; ) {
     io.log(`
 [deploy:all] \u25B6 ${step.name} (${step.script}) \u2014 ${step.dir}: ${step.command.join(" ")}`);
-    const sandbox = step.liveGate?.kind === "sandbox" ? { gate: step.liveGate, before: await readAppBeforeUpload(step, step.liveGate, io, deps) } : void 0;
-    const previousStartedAt = step.liveGate && step.liveGate.kind !== "sandbox" ? await fetchHealthz(step.liveGate.healthUrl).then((b) => b ? servedStartedAt(b) : void 0) : void 0;
+    const application = step.liveGate ? { before: await readAppBeforeUpload(step, step.liveGate, io, deps) } : void 0;
     const r = await exec(step, io);
     const outcome = classifyDeployOutput(r.code, r.output);
     if (outcome.kind === "deployed") {
@@ -12657,15 +12765,20 @@ async function deployStepLoop(step, plan3, expectedCommit, io, deps, exec, root,
       );
       const liveGate = step.liveGate;
       const gate = await root.span("deploy.wait_live", async (wait2) => {
-        let g;
-        if (sandbox) {
-          const target = rolloutTargetFromDeployOutput(r.output);
-          const from = "value" in sandbox.before ? `version ${sandbox.before.value.version}` : "its pre-deploy version";
-          io.log(
-            target ? `[deploy:all] ${step.name}: wrangler printed a container change \u2014 ${target.image ? `image ${shortImage(target.image)}` : "configuration only, image unchanged"}; the application must leave ${from}` : `[deploy:all] ${step.name}: wrangler printed no container change \u2014 Worker-only deploy, no rollout expected`
-          );
-          g = await waitUntilSandboxLive(step, sandbox.gate, expectedCommit, { ...sandbox, target }, io, deps);
-        } else g = await waitUntilLive(step, liveGate.healthUrl, expectedCommit, io, deps.now, previousStartedAt);
+        if (!application) throw new Error(`${step.name}: live gate has no application state`);
+        const target = rolloutTargetFromDeployOutput(r.output);
+        const from = "value" in application.before ? `version ${application.before.value.version}` : "its pre-deploy version";
+        io.log(
+          target ? `[deploy:all] ${step.name}: wrangler printed a container change \u2014 ${target.image ? `image ${shortImage(target.image)}` : "configuration only, image unchanged"}; the application must leave ${from}` : `[deploy:all] ${step.name}: wrangler printed no container change \u2014 Worker-only deploy, no rollout expected`
+        );
+        const g = liveGate.kind === "sandbox" ? await waitUntilSandboxLive(
+          step,
+          liveGate,
+          expectedCommit,
+          { before: application.before, target },
+          io,
+          deps
+        ) : await waitUntilBotLive(step, liveGate, expectedCommit, { before: application.before, target }, io, deps);
         wait2.setAttrs(g.live ? { outcome: "live", waitedMs: g.waitedMs } : { outcome: "not_live" });
         return g;
       });
@@ -13082,6 +13195,7 @@ var init_run = __esm({
     init_planeDeploy();
     init_wranglerTemplate();
     init_supersede();
+    init_botLiveGate();
     init_sandboxLiveGate();
     sleep = (ms) => new Promise((r) => setTimeout(r, ms));
     workerDir = (dir) => workPath(OPERATOR_ROOT, dir);
@@ -16134,6 +16248,7 @@ var init_resident = __esm({
        *  here: its `runtime-replaced` is the typed restart (`opWithReattach`). */
       runtimeReplacedStreak = 0;
       lastBinding;
+      attachAttempt = 0;
       /** The thread's binding as the resident answered it on the most recent
        *  successful attach — including a mid-run re-attach after an eviction, which
        *  may land on a newer sha than the one the run started on. Undefined until
@@ -16300,6 +16415,7 @@ var init_resident = __esm({
        *  an operation's wall clock is the command's, and a recovery attach is not
        *  the command. */
       async attach(span, opts = {}) {
+        this.attachAttempt++;
         const answer = await this.attachOnce(span, this.attachBoundMs("/attach"), opts.signal);
         if (answer.ok) return answer.binding;
         if (isDrainingRefusal(answer)) {
@@ -16348,14 +16464,16 @@ var init_resident = __esm({
           t0 + (left === void 0 ? DRAIN_WAIT_MAX_MS : Math.max(0, left - DRAIN_LEASE_RESERVE_MS))
         );
         let answer = first;
-        const note = (now) => this.opts.onSetupNote?.(
-          `waiting for the deploy to finish \xB7 ${Math.max(1, Math.round((now - t0) / MINUTE_MS))} min`
-        );
+        await this.opts.onLiveStateObservation?.({
+          state: "waiting_deploy",
+          bound: deadline,
+          reason: "deploy",
+          attempt: this.attachAttempt
+        });
         const waitSpan = span?.start("dispatch.workspace.attach.drain-wait");
         try {
           for (; ; ) {
             const now = systemClock();
-            note(now);
             if (now >= deadline)
               throw new ResidentDrainingError(this.opts.resource, now - t0, drainingUntil(answer), refusalWords(answer));
             await wakePause(Math.min(DRAIN_POLL_MS, deadline - now), opts.signal, "/attach");
@@ -16393,7 +16511,6 @@ var init_resident = __esm({
           }
           throw err2;
         } finally {
-          this.opts.onSetupNote?.(void 0);
         }
       }
       /** One `/attach`, answered rather than thrown: the binding on a 200, else
@@ -16700,6 +16817,13 @@ var init_resident = __esm({
           }
         };
         const t0 = systemClock();
+        const wakeBound = t0 + wakeWaitBudget(opts.budgetMs);
+        await this.opts.onLiveStateObservation?.({
+          state: "waiting_repository",
+          bound: wakeBound,
+          reason: "repository_container",
+          attempt: this.attachAttempt
+        });
         let transient = opts.origin === "transient-refusal";
         const definite = (why) => residentWakeStrike(route2, refusal, why, "refused", opts.origin);
         const decide = (view) => transient && isUnansweredProbe(view) ? {
@@ -17331,7 +17455,7 @@ async function branchHeadSubject(repo, branch2) {
   if (typeof message4 !== "string" || message4.trim() === "") return void 0;
   return message4.split("\n", 1)[0].trim();
 }
-async function headRefTipSha(repo, branch2, headers) {
+async function readHeadRef(repo, branch2, headers) {
   let res;
   try {
     res = await fetch(`https://api.github.com/repos/${repo}/git/ref/heads/${encodeGithubRef(branch2)}`, {
@@ -17339,13 +17463,17 @@ async function headRefTipSha(repo, branch2, headers) {
       signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
     });
   } catch {
-    return void 0;
+    return { kind: "unverified" };
   }
-  if (!res.ok) return void 0;
+  if (res.status === 404) return { kind: "missing" };
+  if (!res.ok) return { kind: "unverified" };
   const data = await res.json().catch(() => null);
-  if (data?.object?.type !== "commit") return void 0;
-  const sha = data.object.sha;
-  return typeof sha === "string" && /^[0-9a-f]{40}$/.test(sha) ? sha : void 0;
+  const sha = data?.object?.sha;
+  return data?.object?.type === "commit" && typeof sha === "string" && /^[0-9a-f]{40}$/.test(sha) ? { kind: "verified", sha } : { kind: "unverified" };
+}
+async function headRefTipSha(repo, branch2, headers) {
+  const read = await readHeadRef(repo, branch2, headers);
+  return read.kind === "verified" ? read.sha : void 0;
 }
 function preferRefTip(where, prSha, refTip, branch2) {
   if (refTip === void 0) return prSha;
@@ -17395,8 +17523,11 @@ async function fetchPullRequestFacts(pr) {
   const prSha = typeof data.head?.sha === "string" && /^[0-9a-f]{40}$/.test(data.head.sha) ? data.head.sha : void 0;
   const sameRepoHead = headRepo === pr.repo.toLowerCase();
   const headRef = typeof data.head?.ref === "string" && data.head.ref ? data.head.ref : void 0;
-  const headBranchExists = sameRepoHead && headRef !== void 0 ? await fetchRefExists(pr.repo, headRef) : void 0;
-  const sha = sameRepoHead && headRef !== void 0 && headBranchExists !== false ? preferRefTip(`${pr.repo}#${pr.number}`, prSha, await headRefTipSha(pr.repo, headRef, headers), headRef) : prSha;
+  const headRead = sameRepoHead && headRef !== void 0 ? await readHeadRef(pr.repo, headRef, headers) : void 0;
+  const headBranchExists = headRead?.kind === "verified" ? true : headRead?.kind === "missing" ? false : void 0;
+  const refTip = headRead?.kind === "verified" ? headRead.sha : void 0;
+  const sha = sameRepoHead && headRef !== void 0 ? preferRefTip(`${pr.repo}#${pr.number}`, prSha, refTip, headRef) : prSha;
+  const verifiedHead = sameRepoHead && headRef !== void 0 && prSha !== void 0 && refTip === prSha ? { repo: pr.repo, ref: headRef, sha: refTip } : void 0;
   let closedBy = typeof data.closed_by?.login === "string" ? data.closed_by.login : void 0;
   if (data.state === "closed" && !(typeof data.merged_at === "string" && data.merged_at) && closedBy === void 0) {
     try {
@@ -17421,6 +17552,7 @@ async function fetchPullRequestFacts(pr) {
     } : {},
     ...headRef !== void 0 ? { headRef } : {},
     ...sha ? { headSha: sha } : {},
+    ...verifiedHead !== void 0 ? { verifiedHead } : {},
     ...headBranchExists !== void 0 ? { headBranchExists } : {},
     sameRepoHead,
     ...typeof data.base?.ref === "string" && data.base.ref ? { baseRef: data.base.ref } : {},
@@ -18413,7 +18545,7 @@ async function makeExecutor(opts, ctx, span) {
             resolveEnvs: () => gitIdentityEnvs(ctx.profile.identity, authorSourceOf(opts, ctx)),
             ...ctx.ownPr !== void 0 ? { ownPr: ctx.ownPr } : {},
             ...ctx.remainingMs !== void 0 ? { remainingMs: ctx.remainingMs } : {},
-            ...ctx.onSetupNote !== void 0 ? { onSetupNote: ctx.onSetupNote } : {}
+            ...ctx.onLiveStateObservation !== void 0 ? { onLiveStateObservation: ctx.onLiveStateObservation } : {}
           },
           nonWarm,
           span,
@@ -18595,7 +18727,7 @@ async function reattachWorkspace(opts, ctx, recorded, span) {
     // resident holds its own credential, so the pairs alone ride.
     resolveEnvs: () => gitIdentityEnvs(ctx.profile.identity, authorSourceOf(opts, ctx)),
     ...ctx.remainingMs !== void 0 ? { remainingMs: ctx.remainingMs } : {},
-    ...ctx.onSetupNote !== void 0 ? { onSetupNote: ctx.onSetupNote } : {}
+    ...ctx.onLiveStateObservation !== void 0 ? { onLiveStateObservation: ctx.onLiveStateObservation } : {}
   });
   let binding;
   try {
@@ -21048,8 +21180,8 @@ function pageEvents(events, opts) {
   if (page2.length < rest.length && page2.length > 0) out.nextAfterSeq = page2[page2.length - 1].seq;
   return out;
 }
-function toListItem(record2, bytes) {
-  const { events: _events, ...rest } = record2;
+function toListItem(record3, bytes) {
+  const { events: _events, ...rest } = record3;
   return { ...rest, bytes };
 }
 function retentionPolicyOf(cfg) {
@@ -21200,19 +21332,19 @@ var init_runStore = __esm({
       }
       abandoned() {
       }
-      async put(record2) {
-        if (!isValidRunId(record2.id))
+      async put(record3) {
+        if (!isValidRunId(record3.id))
           return { ok: true, retained: this.readIndex().length, stored: false, rewritten: false };
         this.ensureDir();
-        const content = JSON.stringify(record2);
+        const content = JSON.stringify(record3);
         const bytes = utf8ByteLength(content);
         const index = this.readIndex();
-        const prev = index.find((r) => r.id === record2.id);
-        const rewritten = prev !== void 0 && !sameStoredVersion(prev, { ...record2, bytes });
-        this.writeAtomic(this.recordPath(record2.id), content);
-        const item = toListItem(record2, bytes);
-        const kept = this.compact([...index.filter((r) => r.id !== record2.id), item]);
-        return { ok: true, retained: kept.length, stored: kept.some((r) => r.id === record2.id), rewritten };
+        const prev = index.find((r) => r.id === record3.id);
+        const rewritten = prev !== void 0 && !sameStoredVersion(prev, { ...record3, bytes });
+        this.writeAtomic(this.recordPath(record3.id), content);
+        const item = toListItem(record3, bytes);
+        const kept = this.compact([...index.filter((r) => r.id !== record3.id), item]);
+        return { ok: true, retained: kept.length, stored: kept.some((r) => r.id === record3.id), rewritten };
       }
       /** Retention is decided from the index alone (no per-file stat); the one
        *  file that matters is then read directly — a torn or missing file lands
@@ -21239,16 +21371,16 @@ var init_runStore = __esm({
         return selectListItems(this.retainedIntact(), opts);
       }
       async events(id, opts) {
-        const record2 = await this.get(id);
-        return record2 ? pageEvents(record2.events, opts) : null;
+        const record3 = await this.get(id);
+        return record3 ? pageEvents(record3.events, opts) : null;
       }
       async usage(query) {
         const items = this.retainedIntact();
         const records = [];
         for (const item of items) {
           if (item.finishedAt < query.sinceMs || item.finishedAt >= query.untilMs) continue;
-          const record2 = await this.get(item.id);
-          if (record2) records.push(record2);
+          const record3 = await this.get(item.id);
+          if (record3) records.push(record3);
         }
         const parent = (id) => {
           const p = items.find((i) => i.id === id);
@@ -21966,24 +22098,24 @@ function predicateWith(rules, actor, action, resourceType, kind) {
 function predicateFor(actor, action, resourceType, kind) {
   return predicateWith(POLICY, actor, action, resourceType, kind);
 }
-function matchesPredicate(predicate, record2) {
+function matchesPredicate(predicate, record3) {
   switch (predicate.kind) {
     case "none":
       return false;
     case "all":
       return true;
     case "channels-in":
-      return record2.channelId !== void 0 && holds(predicate.channelIds, record2.channelId);
+      return record3.channelId !== void 0 && holds(predicate.channelIds, record3.channelId);
     case "user-is":
-      return record2.userId !== void 0 && record2.userId === predicate.userId;
+      return record3.userId !== void 0 && record3.userId === predicate.userId;
     case "repos-in":
-      return record2.repo !== void 0 && holds(predicate.repos, record2.repo);
+      return record3.repo !== void 0 && holds(predicate.repos, record3.repo);
     case "visibility-in":
-      return predicate.visibilities.has(record2.channelVisibility ?? "unknown");
+      return predicate.visibilities.has(record3.channelVisibility ?? "unknown");
     case "or":
-      return predicate.of.some((p) => matchesPredicate(p, record2));
+      return predicate.of.some((p) => matchesPredicate(p, record3));
     case "and":
-      return predicate.of.length > 0 && predicate.of.every((p) => matchesPredicate(p, record2));
+      return predicate.of.length > 0 && predicate.of.every((p) => matchesPredicate(p, record3));
   }
   return false;
 }
@@ -25400,6 +25532,199 @@ var init_frictionProposals = __esm({
   }
 });
 
+// ../../src/core/runLiveState.ts
+function safeLiveStateDetail(detail) {
+  if (detail === void 0) return void 0;
+  const line4 = oneLine(detail);
+  if (line4 === "" || UNSAFE_DETAIL.test(line4)) return void 0;
+  return redactAndCap(line4, LIVE_STATE_DETAIL_MAX - 1);
+}
+function assignRunLiveState(current, currentSeq, input) {
+  if (input.expectedSeq !== currentSeq) return { ok: false, reason: "stale-sequence" };
+  if (current === void 0 && input.state !== "admitted") return { ok: false, reason: "invalid-transition" };
+  if (current?.state === "ended") return { ok: false, reason: "terminal" };
+  if (input.state !== "ended") {
+    if (input.bound === void 0) return { ok: false, reason: "bound-required" };
+    if (!Number.isFinite(input.bound) || input.bound < input.at) return { ok: false, reason: "invalid-bound" };
+  } else if (input.cause === void 0) return { ok: false, reason: "cause-required" };
+  if (current !== void 0 && current.state !== input.state && !TRANSITIONS[current.state].includes(input.state))
+    return { ok: false, reason: "invalid-transition" };
+  const detail = safeLiveStateDetail(input.detail);
+  const liveState = {
+    state: input.state,
+    since: current?.state === input.state ? current.since : input.at,
+    ...input.state !== "ended" ? { bound: input.bound } : {},
+    ...detail !== void 0 ? { detail } : {}
+  };
+  if (current?.state === input.state) return { ok: true, liveState };
+  return {
+    ok: true,
+    liveState,
+    event: {
+      type: "run_state",
+      ...liveState,
+      ...input.state === "ended" ? { cause: input.cause } : {},
+      at: input.at
+    }
+  };
+}
+function foldRunLiveState(events, materialized = {}) {
+  let liveState = materialized.liveState;
+  let liveStateSeq = materialized.liveStateSeq ?? 0;
+  let leaseEndsAt;
+  for (const event of [...events].sort((left, right) => (left.seq ?? 0) - (right.seq ?? 0))) {
+    if (event.type === "lease" && event.endsAt !== void 0) leaseEndsAt = event.endsAt;
+    const seq = event.seq ?? 0;
+    if (seq <= liveStateSeq) continue;
+    if (event.type === "run_state" && RUN_LIVE_STATE_NAMES.includes(event.state) && event.since !== void 0) {
+      liveState = {
+        state: event.state,
+        since: event.since,
+        ...event.bound !== void 0 ? { bound: event.bound } : {},
+        ...event.detail !== void 0 ? { detail: event.detail } : {}
+      };
+      liveStateSeq = seq;
+      continue;
+    }
+    if (event.type === "tool_call" && liveState?.state === "working" && event.at !== void 0 && event.boundMs !== void 0) {
+      liveState = { ...liveState, bound: event.at + event.boundMs, detail: "running a tool" };
+      liveStateSeq = seq;
+      continue;
+    }
+    if (event.type === "tool_result" && liveState?.state === "working" && leaseEndsAt !== void 0) {
+      liveState = { ...liveState, bound: leaseEndsAt, detail: "model turn" };
+      liveStateSeq = seq;
+    }
+  }
+  return {
+    ...liveState !== void 0 ? { liveState } : {},
+    ...liveStateSeq > 0 ? { liveStateSeq } : {}
+  };
+}
+var RUN_LIVE_STATE_NAMES, LIVE_STATE_DETAIL_MAX, TRANSITIONS, UNSAFE_DETAIL;
+var init_runLiveState = __esm({
+  "../../src/core/runLiveState.ts"() {
+    "use strict";
+    init_redact();
+    RUN_LIVE_STATE_NAMES = [
+      "admitted",
+      "waiting_deploy",
+      "waiting_repository",
+      "falling_back",
+      "preparing",
+      "working",
+      "waiting_provider",
+      "wrapping_up",
+      "ended"
+    ];
+    LIVE_STATE_DETAIL_MAX = 160;
+    TRANSITIONS = {
+      admitted: ["waiting_deploy", "waiting_repository", "falling_back", "preparing", "working", "wrapping_up", "ended"],
+      waiting_deploy: ["waiting_repository", "falling_back", "preparing", "working", "wrapping_up", "ended"],
+      waiting_repository: ["waiting_deploy", "falling_back", "preparing", "working", "wrapping_up", "ended"],
+      falling_back: ["preparing", "working", "wrapping_up", "ended"],
+      preparing: ["waiting_deploy", "waiting_repository", "falling_back", "working", "wrapping_up", "ended"],
+      working: [
+        "waiting_deploy",
+        "waiting_repository",
+        "falling_back",
+        "preparing",
+        "waiting_provider",
+        "wrapping_up",
+        "ended"
+      ],
+      waiting_provider: ["working", "wrapping_up", "ended"],
+      wrapping_up: ["ended"],
+      ended: []
+    };
+    UNSAFE_DETAIL = /(?:\bimage-stale\b|\battach-failed\b|\bparked-provider\b|<\/?(?:html|body|head)\b|\bbad gateway\b)/i;
+  }
+});
+
+// ../../src/core/plane/decide.ts
+function liveStateWords(state) {
+  switch (state) {
+    case "admitted":
+      return "admitted";
+    case "waiting_deploy":
+      return "waiting for the current deploy";
+    case "waiting_repository":
+      return "waiting for the repository container";
+    case "falling_back":
+      return "switching to a fallback workspace";
+    case "preparing":
+      return "preparing the workspace";
+    case "working":
+      return "working";
+    case "waiting_provider":
+      return "waiting for the model provider";
+    case "wrapping_up":
+      return "wrapping up";
+    case "ended":
+      return "ended";
+  }
+}
+function causeOfClose(status3, restarting) {
+  switch (status3) {
+    case "completed":
+      return "completed";
+    case "failed":
+      return "failed";
+    case "stopped_soft":
+    case "stopped_hard":
+    case "stopped":
+      return "stopped";
+    default:
+      return restarting === true ? "resident_replaced" : "lease_lapsed";
+  }
+}
+function endingCauseWords(cause) {
+  switch (cause) {
+    case "completed":
+      return "it completed";
+    case "failed":
+      return "it failed";
+    case "stopped":
+      return "it was stopped";
+    case "withdrawn":
+      return "its wait was withdrawn";
+    case "refused":
+      return "its admission was refused";
+    case "lease_lapsed":
+      return "its lease lapsed with no heartbeat";
+    case "resident_replaced":
+      return "the resident container running it was replaced";
+    case "runner_gone":
+      return "the runner instance driving it is gone";
+  }
+}
+function isReissueSteerText(text) {
+  return /^the model provider .+ is answering again — re-issue the held turn and continue$/.test(text.trim());
+}
+function waitingWords(waiting3) {
+  if (waiting3.length === 0) return "its turn";
+  return waiting3.map(
+    (c) => c.kind === "thread_free" ? "the thread's live run" : c.kind === "deploy_settled" ? "the pending deploy" : c.kind === "seat" ? `a seat on ${c.resident}` : c.kind === "memory" ? `memory on ${c.resident}` : c.kind === "provider_up" ? `the ${c.provider} provider` : `the ${c.window} window`
+  ).join(", then ");
+}
+var PLANE_ENDING_CAUSES;
+var init_decide = __esm({
+  "../../src/core/plane/decide.ts"() {
+    "use strict";
+    init_budgets();
+    PLANE_ENDING_CAUSES = [
+      "completed",
+      "failed",
+      "stopped",
+      "withdrawn",
+      "refused",
+      "lease_lapsed",
+      "resident_replaced",
+      "runner_gone"
+    ];
+  }
+});
+
 // ../../src/core/runEventLines.ts
 function parseRunEventLines(text) {
   const events = [];
@@ -25465,6 +25790,8 @@ function isRunEvent(v) {
       return typeof o.url === "string" && typeof o.number === "number" && typeof o.created === "boolean";
     case "pushed_head":
       return typeof o.ref === "string" && typeof o.sha === "string" && (o.by === "push" || o.by === "salvage");
+    case "run_state":
+      return typeof o.state === "string" && LIVE_STATES.has(o.state) && typeof o.since === "number" && (o.state === "ended" ? typeof o.cause === "string" && ENDING_CAUSES.has(o.cause) : typeof o.bound === "number");
     case "review_posted":
       return typeof o.repo === "string" && typeof o.number === "number" && typeof o.head === "string";
     case "ship_round":
@@ -25487,12 +25814,16 @@ function isRunEvent(v) {
       return false;
   }
 }
-var NOTE_KINDS;
+var NOTE_KINDS, LIVE_STATES, ENDING_CAUSES;
 var init_runEventLines = __esm({
   "../../src/core/runEventLines.ts"() {
     "use strict";
     init_runEvents();
+    init_runLiveState();
+    init_decide();
     NOTE_KINDS = new Set(RUN_NOTE_KINDS);
+    LIVE_STATES = new Set(RUN_LIVE_STATE_NAMES);
+    ENDING_CAUSES = new Set(PLANE_ENDING_CAUSES);
   }
 });
 
@@ -28644,23 +28975,23 @@ var init_turnEffort = __esm({
 function tokenize2(text) {
   return text.toLowerCase().match(/[a-z0-9]+/g) ?? [];
 }
-function keywordMatch(record2, query) {
+function keywordMatch(record3, query) {
   const queryTokens = typeof query === "string" ? tokenize2(query) : query;
   if (queryTokens.length === 0) return 0;
-  const recordTokens = /* @__PURE__ */ new Set([...tokenize2(record2.keywords.join(" ")), ...tokenize2(record2.text)]);
+  const recordTokens = /* @__PURE__ */ new Set([...tokenize2(record3.keywords.join(" ")), ...tokenize2(record3.text)]);
   let hits = 0;
   for (const token2 of queryTokens) {
     if (recordTokens.has(token2)) hits++;
   }
   return hits / queryTokens.length;
 }
-function recencyScore(record2, now, tau = RECENCY_TAU_MS) {
-  const ts = record2.lastUsedAt ?? record2.createdAt;
+function recencyScore(record3, now, tau = RECENCY_TAU_MS) {
+  const ts = record3.lastUsedAt ?? record3.createdAt;
   const age = Math.max(0, now - ts);
   return Math.exp(-age / tau);
 }
-function scoreRecord(record2, query, now, weights = DEFAULT_WEIGHTS, tau = RECENCY_TAU_MS) {
-  return weights.keyword * keywordMatch(record2, query) + weights.recency * recencyScore(record2, now, tau);
+function scoreRecord(record3, query, now, weights = DEFAULT_WEIGHTS, tau = RECENCY_TAU_MS) {
+  return weights.keyword * keywordMatch(record3, query) + weights.recency * recencyScore(record3, now, tau);
 }
 function estimateTokens(text) {
   return Math.ceil(text.length / 4);
@@ -28668,11 +28999,11 @@ function estimateTokens(text) {
 function applyBudget(records, budget) {
   const out = [];
   let tokens = 0;
-  for (const record2 of records) {
+  for (const record3 of records) {
     if (out.length >= budget.maxRecords) break;
-    const cost = estimateTokens(renderMemoryBullet(record2));
+    const cost = estimateTokens(renderMemoryBullet(record3));
     if (out.length > 0 && tokens + cost > budget.maxTokens) break;
-    out.push(record2);
+    out.push(record3);
     tokens += cost;
   }
   return out;
@@ -28683,8 +29014,8 @@ function memoryBlockPrefix(resource) {
 function sanitizeMemoryField(s) {
   return s.replace(/[\x00-\x1f\x7f-\x9f\u2028\u2029]/g, " ").replace(/\s+/g, " ").trim().replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 }
-function renderMemoryBullet(record2) {
-  return `- ${sanitizeMemoryField(record2.text)} (source: ${sanitizeMemoryField(record2.sourceThreadKey)})`;
+function renderMemoryBullet(record3) {
+  return `- ${sanitizeMemoryField(record3.text)} (source: ${sanitizeMemoryField(record3.sourceThreadKey)})`;
 }
 function renderMemoryBlock(resource, records) {
   const bullets = records.map(renderMemoryBullet);
@@ -29270,7 +29601,7 @@ function parseConfirmation(v) {
 function isRefusal(v) {
   return typeof v === "string" && CONFIRMATION_REFUSALS.includes(v);
 }
-function judge2(rows, id, actorIds, now, kind) {
+function judge3(rows, id, actorIds, now, kind) {
   const row2 = rows.get(id);
   if (!row2) return { ok: false, refused: "used" };
   if (kind === "consume" && row2.expiresAt <= now) {
@@ -29340,13 +29671,13 @@ var init_confirmations = __esm({
       }
       async consume(id, actorIds) {
         const rows = this.read();
-        const out = judge2(rows, id, actorIds, this.clock(), "consume");
+        const out = judge3(rows, id, actorIds, this.clock(), "consume");
         this.write(rows);
         return out;
       }
       async cancel(id, actorIds) {
         const rows = this.read();
-        const out = judge2(rows, id, actorIds, this.clock(), "cancel");
+        const out = judge3(rows, id, actorIds, this.clock(), "cancel");
         this.write(rows);
         return out;
       }
@@ -29354,7 +29685,7 @@ var init_confirmations = __esm({
         const rows = this.read();
         const id = threadRowId(rows, threadKey);
         if (id === void 0) return { ok: false, refused: "used" };
-        const out = judge2(rows, id, actorIds, this.clock(), "cancel");
+        const out = judge3(rows, id, actorIds, this.clock(), "cancel");
         this.write(rows);
         return out;
       }
@@ -29835,16 +30166,16 @@ async function reflect(deps) {
         dropped.push(`${placement.from} (${placement.reason})`);
         continue;
       }
-      let record2 = plain7;
+      let record3 = plain7;
       if (placement.narrowed) {
-        const { supersedes: _supersedes, restates: _restates, ...withoutPointers } = record2;
-        record2 = withoutPointers;
+        const { supersedes: _supersedes, restates: _restates, ...withoutPointers } = record3;
+        record3 = withoutPointers;
         const line4 = `${placement.narrowed.from} \u2192 ${placement.target.kind} (${placement.narrowed.reason})`;
         narrowed.set(line4, (narrowed.get(line4) ?? 0) + 1);
       }
       let batch = byScope.get(placement.target.key);
       if (!batch) byScope.set(placement.target.key, batch = []);
-      batch.push(record2);
+      batch.push(record3);
     }
     if (narrowed.size > 0)
       warn(`write narrowed by policy: ${[...narrowed].map(([line4, n2]) => `${n2}\xD7 ${line4}`).join(", ")}`);
@@ -31675,8 +32006,8 @@ ${line4}`
           const list = await call(() => api.residents());
           if (list.status !== 200) throw residentFailure(list);
           const residents = list.data.residents ?? [];
-          const record2 = residents.find((rec2) => rec2.resource === repoResourceId(args.slug));
-          if (!record2) {
+          const record3 = residents.find((rec2) => rec2.resource === repoResourceId(args.slug));
+          if (!record3) {
             const slugs = residents.map(
               (rec2) => String(rec2.resource ?? "").replace(/^repo:/, "").toLowerCase()
             ).filter(Boolean);
@@ -31696,7 +32027,7 @@ ${line4}`
 ${line4}` : ""}`
             );
           }
-          body.commands = { ...obj(record2.commands), ...commands };
+          body.commands = { ...obj(record3.commands), ...commands };
         }
         if (options.ref !== void 0) body.defaultRef = options.ref;
         const r = await call(() => api.reconfigure(body));
@@ -31721,11 +32052,11 @@ ${line4}` : ""}`
 
 // ../../src/core/reviewAbridge.ts
 import { resolve as resolve10 } from "node:path";
-function meatArtifactOf(record2) {
-  return record2.events.find((e) => isReadingDiff(e) && e.poweredBy === "meat");
+function meatArtifactOf(record3) {
+  return record3.events.find((e) => isReadingDiff(e) && e.poweredBy === "meat");
 }
-function gitArtifactOf(record2) {
-  return record2.events.find((e) => isReadingDiff(e) && e.poweredBy === "git");
+function gitArtifactOf(record3) {
+  return record3.events.find((e) => isReadingDiff(e) && e.poweredBy === "git");
 }
 function summarize(a) {
   return {
@@ -31739,16 +32070,16 @@ function summarize(a) {
   };
 }
 async function appendReviewArtifact(store, runId3, artifact, at) {
-  const record2 = await store.get(runId3);
-  if (!record2) throw new Error("the run's record is gone \u2014 nothing to append to");
-  const kept = record2.events.filter((e) => !(isReadingDiff(e) && e.poweredBy === "meat"));
-  const replaced = kept.length !== record2.events.length;
-  const seq = Math.max(0, ...storedEventSeqs(record2.events), ...record2.events.map((e) => e.seq ?? 0)) + 1;
+  const record3 = await store.get(runId3);
+  if (!record3) throw new Error("the run's record is gone \u2014 nothing to append to");
+  const kept = record3.events.filter((e) => !(isReadingDiff(e) && e.poweredBy === "meat"));
+  const replaced = kept.length !== record3.events.length;
+  const seq = Math.max(0, ...storedEventSeqs(record3.events), ...record3.events.map((e) => e.seq ?? 0)) + 1;
   const event = { type: "review_artifact", artifact: "reading_diff", ...artifact, at, seq };
   const next = fitRecordToBudget({
-    ...record2,
+    ...record3,
     events: [...kept, event],
-    eventCount: record2.eventCount + (replaced ? 0 : 1),
+    eventCount: record3.eventCount + (replaced ? 0 : 1),
     storedEventCount: kept.length + 1
   });
   if (!next.events.includes(event))
@@ -31837,19 +32168,19 @@ var init_reviewAbridge = __esm({
       async decide(req) {
         const job = this.jobs.get(req.runId);
         if (job) return { state: "running", startedAt: job.startedAt };
-        const record2 = await this.deps.store.get(req.runId);
-        if (!record2) throw new AbridgeRefusal("not_found", "run not found");
-        const existing = meatArtifactOf(record2);
+        const record3 = await this.deps.store.get(req.runId);
+        if (!record3) throw new AbridgeRefusal("not_found", "run not found");
+        const existing = meatArtifactOf(record3);
         if (existing && !req.force) return { state: "done", reused: true, artifact: summarize(existing) };
         const failed = this.failures.get(req.runId);
         if (failed && !req.force) return { state: "failed", ...failed };
-        const git2 = gitArtifactOf(record2);
+        const git2 = gitArtifactOf(record3);
         if (!git2)
           throw new AbridgeRefusal("conflict", `run ${req.runId} carries no reading diff \u2014 only PR review runs record one`);
         const startedAt = this.deps.clock();
         const model = req.model ?? this.deps.defaultModel();
         this.failures.delete(req.runId);
-        const done = this.produce(record2, git2, model).finally(() => this.jobs.delete(req.runId));
+        const done = this.produce(record3, git2, model).finally(() => this.jobs.delete(req.runId));
         this.jobs.set(req.runId, { startedAt, done });
         return { state: "running", startedAt };
       }
@@ -31859,8 +32190,8 @@ var init_reviewAbridge = __esm({
         if (job) return { state: "running", startedAt: job.startedAt };
         const failed = this.failures.get(runId3);
         if (failed) return { state: "failed", ...failed };
-        const record2 = await this.deps.store.get(runId3);
-        const existing = record2 ? meatArtifactOf(record2) : void 0;
+        const record3 = await this.deps.store.get(runId3);
+        const existing = record3 ? meatArtifactOf(record3) : void 0;
         return existing ? { state: "done", reused: true, artifact: summarize(existing) } : { state: "absent" };
       }
       /** The running job's final state, or the current state when none runs. */
@@ -31891,10 +32222,10 @@ var init_reviewAbridge = __esm({
           if (!(err2 instanceof AbridgeRefusal)) this.deps.warn(`[reading-diff] ${runId3} abridge failed: ${describe(err2)}`);
         }
       }
-      async produce(record2, git2, model) {
+      async produce(record3, git2, model) {
         const at = () => this.deps.clock();
         try {
-          const input = await this.input(record2, git2);
+          const input = await this.input(record3, git2);
           const meat = await this.deps.meat({ diff: input.diff, model, timeoutMs: this.deps.timeoutMs() });
           if (!meat.ok) throw new Error(meat.reason);
           const capped4 = capDiff(sanitizeArtifactText(meat.result.diff));
@@ -31910,12 +32241,12 @@ var init_reviewAbridge = __esm({
             inputBytes: input.bytes,
             model
           };
-          const stored = await appendReviewArtifact(this.deps.store, record2.id, artifact, at());
-          return this.conclude(record2.id, { state: "done", reused: false, artifact: summarize(stored) });
+          const stored = await appendReviewArtifact(this.deps.store, record3.id, artifact, at());
+          return this.conclude(record3.id, { state: "done", reused: false, artifact: summarize(stored) });
         } catch (err2) {
           const failed = { reason: redactSecrets(describe(err2)), at: at() };
-          this.failures.set(record2.id, failed);
-          return this.conclude(record2.id, { state: "failed", ...failed });
+          this.failures.set(record3.id, failed);
+          return this.conclude(record3.id, { state: "failed", ...failed });
         }
       }
       conclude(runId3, state) {
@@ -31924,8 +32255,8 @@ var init_reviewAbridge = __esm({
       }
       /** The complete diff: GitHub's compare of base...head first; the recorded
        *  git diff only when that fails AND it is whole. */
-      async input(record2, git2) {
-        const meta = record2.events.find((e) => e.type === "run_meta");
+      async input(record3, git2) {
+        const meta = record3.events.find((e) => e.type === "run_meta");
         let compareFailure;
         if (!meta?.repo || !meta.headSha) compareFailure = "the run records no repo and head to compare";
         else {
@@ -31944,7 +32275,7 @@ var init_reviewAbridge = __esm({
           }
         }
         if (git2.truncated) throw new Error(`diff unavailable: ${compareFailure} and the recorded diff is truncated`);
-        this.deps.warn(`[reading-diff] ${record2.id} using the recorded diff: ${compareFailure}`);
+        this.deps.warn(`[reading-diff] ${record3.id} using the recorded diff: ${compareFailure}`);
         return { diff: git2.diff, source: "recorded", bytes: Buffer.byteLength(git2.diff) };
       }
     };
@@ -32237,6 +32568,8 @@ function assembleRunRecord(input) {
     ...seal?.replyNote !== void 0 ? { replyNote: seal.replyNote } : {},
     ...snap !== null ? { stepCount: snap.stepCount } : {},
     status: input.status,
+    ...snap?.liveState !== void 0 ? { liveState: snap.liveState } : {},
+    ...snap?.liveStateSeq !== void 0 ? { liveStateSeq: snap.liveStateSeq } : {},
     eventCount: Math.max(snap?.eventCount ?? atFinish.length, seal?.eventCount ?? 0),
     storedEventCount: events.length,
     truncated: false,
@@ -32420,43 +32753,6 @@ var init_record = __esm({
   }
 });
 
-// ../../src/core/plane/decide.ts
-function endingCauseWords(cause) {
-  switch (cause) {
-    case "completed":
-      return "it completed";
-    case "failed":
-      return "it failed";
-    case "stopped":
-      return "it was stopped";
-    case "withdrawn":
-      return "its wait was withdrawn";
-    case "refused":
-      return "its admission was refused";
-    case "lease_lapsed":
-      return "its lease lapsed with no heartbeat";
-    case "resident_replaced":
-      return "the resident container running it was replaced";
-    case "runner_gone":
-      return "the runner instance driving it is gone";
-  }
-}
-function isReissueSteerText(text) {
-  return /^the model provider .+ is answering again — re-issue the held turn and continue$/.test(text.trim());
-}
-function waitingWords(waiting2) {
-  if (waiting2.length === 0) return "its turn";
-  return waiting2.map(
-    (c) => c.kind === "thread_free" ? "the thread's live run" : c.kind === "deploy_settled" ? "the pending deploy" : c.kind === "seat" ? `a seat on ${c.resident}` : c.kind === "memory" ? `memory on ${c.resident}` : c.kind === "provider_up" ? `the ${c.provider} provider` : `the ${c.window} window`
-  ).join(", then ");
-}
-var init_decide = __esm({
-  "../../src/core/plane/decide.ts"() {
-    "use strict";
-    init_budgets();
-  }
-});
-
 // ../../src/core/runsService.ts
 function runResource(view) {
   return {
@@ -32493,6 +32789,8 @@ function ledgerView(row2, events) {
     ...m.repo !== void 0 ? { repo: m.repo } : {},
     startedAt: row2.startedAt,
     finished: false,
+    ...row2.liveState !== void 0 ? { liveState: row2.liveState } : {},
+    ...row2.liveStateSeq !== void 0 ? { liveStateSeq: row2.liveStateSeq } : {},
     eventCount: events.length,
     ...activity !== void 0 ? { activity } : {},
     ...m.sourceUrl !== void 0 ? { sourceUrl: m.sourceUrl } : {},
@@ -32531,6 +32829,8 @@ function liveView(s) {
     ...s.stepCount !== void 0 ? { stepCount: s.stepCount } : {},
     ...s.schema !== void 0 ? { schema: s.schema } : {},
     ...s.status !== void 0 ? { status: s.status } : {},
+    ...s.liveState !== void 0 ? { liveState: s.liveState } : {},
+    ...s.liveStateSeq !== void 0 ? { liveStateSeq: s.liveStateSeq } : {},
     eventCount: s.eventCount,
     ...s.stop ? { stop: s.stop } : {},
     ...s.activity !== void 0 ? { activity: s.activity } : {},
@@ -32628,7 +32928,7 @@ function createRunsService(deps) {
   const prices = deps.prices ?? NO_PRICES;
   const clock4 = deps.clock ?? systemClock;
   const warn = deps.warn ?? ((m) => console.warn(m));
-  const describe12 = (err2) => err2 instanceof Error ? err2.message : String(err2);
+  const describe13 = (err2) => err2 instanceof Error ? err2.message : String(err2);
   let listing;
   const liveRows = () => {
     if (!ledger) return null;
@@ -32648,7 +32948,7 @@ function createRunsService(deps) {
     try {
       rows = await pending2;
     } catch (err2) {
-      warn(`[runs] run ledger list failed \u2014 showing this process's runs only: ${describe12(err2)}`);
+      warn(`[runs] run ledger list failed \u2014 showing this process's runs only: ${describe13(err2)}`);
       return [];
     }
     const foreign = rows.filter((row2) => !registry.getById(row2.runId));
@@ -32658,7 +32958,7 @@ function createRunsService(deps) {
         try {
           events = await ledger.readEvents(row2.runId);
         } catch (err2) {
-          warn(`[runs] run ledger events read failed for ${row2.runId}: ${describe12(err2)}`);
+          warn(`[runs] run ledger events read failed for ${row2.runId}: ${describe13(err2)}`);
         }
         return ledgerView(row2, events);
       })
@@ -32672,7 +32972,7 @@ function createRunsService(deps) {
       if (!row2) return null;
       return { row: row2, events: await ledger.readEvents(id) };
     } catch (err2) {
-      warn(`[runs] run ledger read failed for ${id}: ${describe12(err2)}`);
+      warn(`[runs] run ledger read failed for ${id}: ${describe13(err2)}`);
       return null;
     }
   };
@@ -32681,21 +32981,23 @@ function createRunsService(deps) {
     try {
       const row2 = await ledger.planeQueued(id);
       if (!row2) return null;
+      const stampedChannel = row2.request.channelId;
       const channelAt = row2.threadKey.lastIndexOf(":");
-      const waiting2 = waitingWords(row2.conditions);
+      const channelId = typeof stampedChannel === "string" ? stampedChannel : channelAt > 0 ? row2.threadKey.slice(0, channelAt) : void 0;
+      const waiting3 = waitingWords(row2.conditions);
       return {
         id: row2.runId,
-        ...channelAt > 0 ? { channelId: row2.threadKey.slice(0, channelAt) } : {},
+        ...channelId !== void 0 ? { channelId } : {},
         userId: row2.requester,
         threadKey: row2.threadKey,
         startedAt: row2.queuedAt,
         finished: false,
         eventCount: 0,
-        queued: { state: row2.state, position: row2.position, waiting: waiting2 },
-        activity: row2.state === "waiting" ? `queued at position ${row2.position} \u2014 waiting on ${waiting2}` : row2.state === "admitted" ? "admitted \u2014 starting" : "withdrawn"
+        queued: { state: row2.state, position: row2.position, waiting: waiting3 },
+        activity: row2.state === "waiting" ? `queued at position ${row2.position} \u2014 waiting on ${waiting3}` : row2.state === "admitted" ? "admitted \u2014 starting" : "withdrawn"
       };
     } catch (err2) {
-      warn(`[runs] plane queued read failed for ${id}: ${describe12(err2)}`);
+      warn(`[runs] plane queued read failed for ${id}: ${describe13(err2)}`);
       return null;
     }
   };
@@ -32713,7 +33015,7 @@ function createRunsService(deps) {
       row2 = await storeSummary(id);
     } catch (err2) {
       warn(
-        `[runs] history store read failed for ${id} \u2014 serving the registry row without its record: ${describe12(err2)}`
+        `[runs] history store read failed for ${id} \u2014 serving the registry row without its record: ${describe13(err2)}`
       );
       return {};
     }
@@ -32758,12 +33060,12 @@ function createRunsService(deps) {
         if (marked.ok) runnerStopped = true;
         else warn(`[runs] the runner's stop mark was refused for ${id} (${marked.reason})`);
       } catch (err2) {
-        warn(`[runs] the runner's stop mark failed for ${id}: ${describe12(err2)}`);
+        warn(`[runs] the runner's stop mark failed for ${id}: ${describe13(err2)}`);
       }
       try {
         unitRows = await units.listUnits(instanceId);
       } catch (err2) {
-        warn(`[runs] unit rows unavailable for the hard stop of ${id}: ${describe12(err2)}`);
+        warn(`[runs] unit rows unavailable for the hard stop of ${id}: ${describe13(err2)}`);
       }
     }
     registry.publish(id, { type: "answer", text: hostedSealAnswer(unitRows, runnerStopped), at: clock4() });
@@ -32777,7 +33079,7 @@ function createRunsService(deps) {
         if (row2) {
           const finishedAt = snap?.finishedAt ?? at;
           const m = row2.meta;
-          const record2 = assembleRunRecord({
+          const record3 = assembleRunRecord({
             run: { id, ...summary?.label !== void 0 ? { label: summary.label } : {} },
             snap,
             agent: m.agent ?? "ship",
@@ -32805,11 +33107,11 @@ function createRunsService(deps) {
             }),
             seal
           });
-          const done = await ledger.finish(id, row2.ownerGen, record2);
+          const done = await ledger.finish(id, row2.ownerGen, record3);
           if (!done.ok) warn(`[runs] run ledger finish refused for ${id} (${done.reason ?? "unknown"})`);
         }
       } catch (err2) {
-        warn(`[runs] run ledger finish failed for ${id}: ${describe12(err2)}`);
+        warn(`[runs] run ledger finish failed for ${id}: ${describe13(err2)}`);
       }
     }
     return { ok: true, value: { id, mode: "hard", state: "stopping" } };
@@ -32903,12 +33205,12 @@ function createRunsService(deps) {
         const queued = await queuedRun(id);
         return queued ? { ok: true, value: queued } : notFound;
       }
-      const record2 = await storeGet(id);
-      if (!record2) {
+      const record3 = await storeGet(id);
+      if (!record3) {
         const queued = await queuedRun(id);
         return queued ? { ok: true, value: queued } : notFound;
       }
-      const { events, ...rest } = record2;
+      const { events, ...rest } = record3;
       const view = persistedView(rest, prices);
       view.events = events;
       return { ok: true, value: view };
@@ -32988,7 +33290,7 @@ function createRunsService(deps) {
           const r = await ledger.requestStop(id, mode);
           if (r.ok) return { ok: true, value: { id, mode, state: "stopping" } };
         } catch (err2) {
-          warn(`[runs] run ledger stop failed for ${id}: ${describe12(err2)}`);
+          warn(`[runs] run ledger stop failed for ${id}: ${describe13(err2)}`);
         }
       }
       if (await storeSummary(id)) return conflict;
@@ -32998,7 +33300,7 @@ function createRunsService(deps) {
           if (r.withdrawn) return { ok: true, value: { id, mode, state: "withdrawn" } };
           if (await ledger.planeQueued(id) !== null) return conflict;
         } catch (err2) {
-          warn(`[runs] plane withdraw failed for ${id}: ${describe12(err2)}`);
+          warn(`[runs] plane withdraw failed for ${id}: ${describe13(err2)}`);
         }
       }
       return notFound;
@@ -34789,11 +35091,11 @@ var init_runLedgerWorker = __esm({
         this.checkIds(runId3, gen);
         return this.writeTurns(runId3, gen, turns, session);
       }
-      async step(runId3, gen, record2, turns, session) {
+      async step(runId3, gen, record3, turns, session) {
         this.checkIds(runId3, gen);
         const written = await this.writeTurns(runId3, gen, turns, session);
         if (!written.ok) return written;
-        return this.fenceResult(await this.post("/runs/step", { storeKey: this.opts.storeKey, runId: runId3, gen, record: record2 }));
+        return this.fenceResult(await this.post("/runs/step", { storeKey: this.opts.storeKey, runId: runId3, gen, record: record3 }));
       }
       checkSessionKey(key) {
         if (!SESSION_KEY_PATTERN.test(key))
@@ -34929,6 +35231,11 @@ var init_runLedgerWorker = __esm({
         if (events.length === 0) return { ok: true };
         return this.fenceResult(await this.post("/runs/append", { storeKey: this.opts.storeKey, runId: runId3, gen, events }));
       }
+      async assignLiveState(runId3, gen, assignment) {
+        this.checkIds(runId3, gen);
+        const r = await this.post("/runs/live-state", { storeKey: this.opts.storeKey, runId: runId3, gen, assignment });
+        return r.data;
+      }
       async setState(runId3, gen, state) {
         this.checkIds(runId3, gen);
         return this.fenceResult(await this.post("/runs/state", { storeKey: this.opts.storeKey, runId: runId3, gen, state }));
@@ -34959,20 +35266,20 @@ var init_runLedgerWorker = __esm({
         this.checkIds(runId3, gen);
         return this.fenceResult(await this.post("/runs/finishing", { storeKey: this.opts.storeKey, runId: runId3, gen }));
       }
-      async finish(runId3, gen, record2) {
+      async finish(runId3, gen, record3) {
         this.checkIds(runId3, gen);
-        const point = pointOf(record2, this.opts.prices);
+        const point = pointOf(record3, this.opts.prices);
         const r = await this.post("/runs/finish", {
           storeKey: this.opts.storeKey,
           runId: runId3,
           gen,
-          record: record2,
+          record: record3,
           ...point !== void 0 ? { point } : {}
         });
         const f = this.fenceResult(r);
         if (!f.ok) return f;
-        if (record2.session)
-          await this.post("/runs/session/clear-owner", { key: record2.session.key, runId: runId3, gen }).catch(() => {
+        if (record3.session)
+          await this.post("/runs/session/clear-owner", { key: record3.session.key, runId: runId3, gen }).catch(() => {
           });
         return { ok: true, stored: r.data.stored === true };
       }
@@ -35671,6 +35978,19 @@ function runPageLink(id) {
   if (!base) return void 0;
   return `${base.replace(/\/+$/, "")}/runs/${encodeURIComponent(id)}`;
 }
+function threadPageLink(threadKey, publicBaseUrl = process.env.PUBLIC_BASE_URL) {
+  if (!publicBaseUrl?.trim()) return void 0;
+  try {
+    const base = new URL(publicBaseUrl.trim());
+    if (!["https:", "http:"].includes(base.protocol) || base.username || base.password) return void 0;
+    base.search = "";
+    base.hash = "";
+    base.pathname = `${base.pathname.replace(/\/+$/, "")}/threads/${encodeURIComponent(threadKey).replace(/[!'()*]/g, (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`)}`;
+    return base.href;
+  } catch {
+    return void 0;
+  }
+}
 function artifactLink(id, key, token2) {
   const page2 = runPageLink(id);
   if (!page2) return void 0;
@@ -35757,6 +36077,9 @@ function activityLine(e) {
     case "lease":
       return "lease started";
     // the harness's clocks: head material the run loop keeps off the card — never arrives here
+    case "run_state":
+      return "";
+    // Existing renderers stay until the surface cutover to the shared wording table.
     case "skill_use":
       return `\u{1F4DA} skill ${e.skill} loaded`;
     case "artifact":
@@ -36345,9 +36668,9 @@ function recordPrOf(ctx) {
 }
 function inheritedPr(thread, records, repo) {
   const turn = thread.pr && thread.pr.repo === repo ? { repo, number: thread.pr.number, source: "turn", at: thread.prAt } : void 0;
-  const record2 = records?.pr && records.pr.repo === repo ? { repo, number: records.pr.number, source: "record", at: records.pr.at } : void 0;
-  if (!turn || !record2) return turn ?? record2;
-  return turn.at !== void 0 && record2.at !== void 0 && turn.at > record2.at ? turn : record2;
+  const record3 = records?.pr && records.pr.repo === repo ? { repo, number: records.pr.number, source: "record", at: records.pr.at } : void 0;
+  if (!turn || !record3) return turn ?? record3;
+  return turn.at !== void 0 && record3.at !== void 0 && turn.at > record3.at ? turn : record3;
 }
 async function openPrHeadSha(pr) {
   const head = await prHead(pr).catch(() => void 0);
@@ -36700,7 +37023,7 @@ async function attachRoundWorkspace(input) {
       ...input.round.stopSignal !== void 0 ? { stopSignal: input.round.stopSignal } : {},
       ...input.round.remainingMs !== void 0 ? { remainingMs: input.round.remainingMs } : {},
       ...input.round.requester !== void 0 ? { requester: input.round.requester } : {},
-      ...input.round.onSetupNote !== void 0 ? { onSetupNote: input.round.onSetupNote } : {}
+      ...input.round.onLiveStateObservation !== void 0 ? { onLiveStateObservation: input.round.onLiveStateObservation } : {}
     },
     input.span
   );
@@ -36955,7 +37278,7 @@ async function classifyMove(fetchPrCommits, q) {
 async function runReviewPostStep(input) {
   const { agent, repoCtx, verdict, carried, logKey } = input;
   const { reviewHead, observedHead } = input.heads;
-  const record2 = (outcome) => {
+  const record3 = (outcome) => {
     if (input.publish && agent.name === "review" && !input.hardStopped) {
       const where = outcome.posted ? void 0 : repoCtx.repo && repoCtx.pr ? `${repoCtx.repo}#${repoCtx.pr}` : void 0;
       input.publish(
@@ -37054,7 +37377,7 @@ ${carriedFooter(carried)}` : rendered;
       console.error(`[review-post] ${logKey} failed for ${where}: ${reason2}`);
       await input.reply(`\u2139\uFE0F Review not posted to ${where}: ${reason2} \u2014 this verdict is Slack-only.`).catch(() => {
       });
-      return record2({ posted: false, reason: reason2 });
+      return record3({ posted: false, reason: reason2 });
     }
     console.log(
       `[review-post] ${logKey} \u2192 ${where} (${verdict?.verdict ?? "no verdict"})${carried ? ` carried ${carried.reviewed.slice(0, 7)} \u2192 ${pinned.slice(0, 7)}` : ""}`
@@ -37070,14 +37393,14 @@ ${carriedFooter(carried)}` : rendered;
       await input.reply(moved).catch(() => {
       });
     }
-    return record2({
+    return record3({
       posted: true,
       target: { repo: postTarget.repo, number: postTarget.number },
       head: pinned,
       ...verdict !== void 0 ? { verdict: verdict.verdict } : {}
     });
   }
-  return record2({ posted: false, reason: skipReason });
+  return record3({ posted: false, reason: skipReason });
 }
 var init_reviewRound = __esm({
   "../../src/core/reviewRound.ts"() {
@@ -37434,11 +37757,11 @@ var init_authorize2 = __esm({
 });
 
 // ../../src/core/runHistoryWriter.ts
-async function putOnce(sink, record2) {
+async function putOnce(sink, record3) {
   try {
-    return await sink.put(record2);
+    return await sink.put(record3);
   } catch (err2) {
-    sink.abandoned(record2, describe2(err2));
+    sink.abandoned(record3, describe2(err2));
     throw err2;
   }
 }
@@ -37462,28 +37785,28 @@ function createRunHistoryWriter(opts) {
       opts.warn(`[run-history] onPersisted hook failed for ${id}: ${describe2(err2)}`);
     }
   };
-  const attemptAll = async (record2, flag2, sink, span) => {
+  const attemptAll = async (record3, flag2, sink, span) => {
     const attempts = RUN_HISTORY_RETRY_DELAYS_MS.length + 1;
     const giveUp = async (why) => {
       failures++;
       try {
-        sink.abandoned(record2, why);
+        sink.abandoned(record3, why);
       } catch (err2) {
-        opts.warn(`[run-history] abandoned hook failed for ${record2.id}: ${describe2(err2)}`);
+        opts.warn(`[run-history] abandoned hook failed for ${record3.id}: ${describe2(err2)}`);
       }
       if (sink === opts.store || flag2?.superseded) return;
       try {
-        await opts.store.put(record2, span ? { span } : void 0);
-        if (!flag2) persisted(record2.id);
+        await opts.store.put(record3, span ? { span } : void 0);
+        if (!flag2) persisted(record3.id);
       } catch (err2) {
-        opts.warn(`[run-history] ${record2.id} store fallback after give-up failed: ${describe2(err2)}`);
+        opts.warn(`[run-history] ${record3.id} store fallback after give-up failed: ${describe2(err2)}`);
       }
     };
     for (let attempt = 1; ; attempt++) {
       if (flag2?.superseded) return;
       try {
-        await sink.put(record2, span ? { span } : void 0);
-        if (!flag2) persisted(record2.id);
+        await sink.put(record3, span ? { span } : void 0);
+        if (!flag2) persisted(record3.id);
         return;
       } catch (err2) {
         if (err2 instanceof RouteMissingError) {
@@ -37496,12 +37819,12 @@ function createRunHistoryWriter(opts) {
           return;
         }
         if (err2 instanceof PermanentStoreError) {
-          opts.warn(`[run-history] ${record2.id} not persisted (permanent, not retried): ${describe2(err2)}`);
+          opts.warn(`[run-history] ${record3.id} not persisted (permanent, not retried): ${describe2(err2)}`);
           await giveUp(describe2(err2));
           return;
         }
         if (attempt >= attempts) {
-          opts.warn(`[run-history] ${record2.id} not persisted after ${attempts} attempts: ${describe2(err2)}`);
+          opts.warn(`[run-history] ${record3.id} not persisted after ${attempts} attempts: ${describe2(err2)}`);
           await giveUp(`not persisted after ${attempts} attempts: ${describe2(err2)}`);
           return;
         }
@@ -37510,24 +37833,24 @@ function createRunHistoryWriter(opts) {
     }
   };
   return {
-    write(record2, writeOpts) {
+    write(record3, writeOpts) {
       let flag2;
       if (writeOpts?.provisional === true) {
-        if (finals.has(record2.id)) return;
-        flag2 = { id: record2.id, superseded: false };
+        if (finals.has(record3.id)) return;
+        flag2 = { id: record3.id, superseded: false };
         provisionalFlags.add(flag2);
       } else {
-        finals.add(record2.id);
-        for (const f of provisionalFlags) if (f.id === record2.id) f.superseded = true;
+        finals.add(record3.id);
+        for (const f of provisionalFlags) if (f.id === record3.id) f.superseded = true;
       }
       const sink = writeOpts?.via ?? opts.store;
-      const p = attemptAll(record2, flag2, sink, writeOpts?.span).catch((err2) => {
+      const p = attemptAll(record3, flag2, sink, writeOpts?.span).catch((err2) => {
         failures++;
-        opts.warn(`[run-history] ${record2.id} writer failed unexpectedly: ${describe2(err2)}`);
+        opts.warn(`[run-history] ${record3.id} writer failed unexpectedly: ${describe2(err2)}`);
         try {
-          sink.abandoned(record2, `writer failed unexpectedly: ${describe2(err2)}`);
+          sink.abandoned(record3, `writer failed unexpectedly: ${describe2(err2)}`);
         } catch (hookErr) {
-          opts.warn(`[run-history] abandoned hook failed for ${record2.id}: ${describe2(hookErr)}`);
+          opts.warn(`[run-history] abandoned hook failed for ${record3.id}: ${describe2(hookErr)}`);
         }
       }).finally(() => {
         if (flag2) provisionalFlags.delete(flag2);
@@ -37890,12 +38213,12 @@ async function closeRestartRow(adopted, restart, why) {
 async function closeResumedRow(adopted, resume, why, status3 = "interrupted", opts) {
   try {
     const finishedAt = (opts?.clock ?? systemClock)();
-    const record2 = {
+    const record3 = {
       ...reclaimedRunRecord({ row: resume.row, events: resume.events, status: status3, finishedAt }),
       ...opts?.restarting === true ? { restarting: true, restartUntil: finishedAt + RESTART_CLAIM_GRACE_MS } : {}
     };
-    await putOnce(adopted.sink, record2);
-    return record2;
+    await putOnce(adopted.sink, record3);
+    return record3;
   } catch (err2) {
     console.warn(
       `[resume] ${resume.row.runId} could not be closed (${why}): ${err2 instanceof Error ? err2.message : String(err2)}`
@@ -38586,6 +38909,8 @@ function summaryOf(run2, now) {
     ...m?.hosted ? { hosted: true } : {},
     ...run2.instanceId !== void 0 ? { instanceId: run2.instanceId } : {},
     ...run2.pipeline !== void 0 ? { pipeline: run2.pipeline } : {},
+    ...run2.liveState !== void 0 ? { liveState: run2.liveState } : {},
+    ...run2.liveStateSeq !== void 0 ? { liveStateSeq: run2.liveStateSeq } : {},
     finished: run2.finished,
     startedAt: run2.startedAt,
     ...run2.finishedAt !== void 0 ? { finishedAt: run2.finishedAt } : {},
@@ -38621,7 +38946,9 @@ function snapshotOf(run2) {
     ...run2.meta?.receivedAt !== void 0 ? { receivedAt: run2.meta.receivedAt } : {},
     eventCount: run2.eventCount,
     stepCount: run2.stepCount,
-    truncated: run2.eventCount > run2.backlog.length
+    truncated: run2.eventCount > run2.backlog.length,
+    ...run2.liveState !== void 0 ? { liveState: run2.liveState } : {},
+    ...run2.liveStateSeq !== void 0 ? { liveStateSeq: run2.liveStateSeq } : {}
   };
 }
 function sealResultOf(run2) {
@@ -38705,6 +39032,7 @@ var init_runRegistry = __esm({
     init_projections();
     init_indexFeed();
     init_runPace();
+    init_runLiveState();
     PACE_RING_CAP = 1200;
     UNSEALED_HOLD_MS = 15 * 6e4;
     RUN_LABEL_MAX2 = 200;
@@ -38778,6 +39106,10 @@ var init_runRegistry = __esm({
           if (!isSpanRecord(event)) run2.stepCount++;
           appendToBacklog(run2, this.bounds, { ...event, seq });
         }
+        const replayedLiveState = foldRunLiveState(opts.replay ?? [], opts.liveState);
+        const folded = opts.resetLiveState ? { liveStateSeq: replayedLiveState.liveStateSeq } : replayedLiveState;
+        run2.liveState = folded.liveState;
+        run2.liveStateSeq = folded.liveStateSeq;
         this.index.notify({ type: "upsert", run: summaryOf(run2, this.now()) });
         return { id, token: token2, control: run2.control, ...stored !== void 0 ? { label: stored } : {} };
       }
@@ -38866,6 +39198,32 @@ var init_runRegistry = __esm({
         }
         if (!span) this.index.notify({ type: "upsert", run: summaryOf(run2, this.now()) });
       }
+      /** Apply an assignment only after its durable transaction acknowledged. The
+       *  boundary keeps the ledger-assigned stream sequence; subscribers cannot
+       *  observe either half before this call. */
+      commitLiveState(id, committed) {
+        const run2 = this.runs.get(id);
+        if (!run2 || run2.finished || run2.sealedAt !== void 0) return false;
+        const event = committed.event;
+        if (event !== void 0) {
+          const seq = event.seq;
+          if (seq === void 0 || seq !== run2.eventCount + 1) return false;
+          run2.eventCount = seq;
+          run2.stepCount++;
+          const stamped = { ...event, seq };
+          appendToBacklog(run2, this.bounds, stamped);
+          for (const sub of run2.subscribers) {
+            try {
+              sub.onEvent(stamped, seq);
+            } catch {
+            }
+          }
+        }
+        run2.liveState = committed.liveState;
+        run2.liveStateSeq = committed.liveStateSeq;
+        this.index.notify({ type: "upsert", run: summaryOf(run2, this.now()) });
+        return true;
+      }
       /** Mark a run finished — the agent stopped: stamp `finishedAt`, send every
        *  attached subscriber the `finished` frame WITHOUT detaching it (span records
        *  still flow until the seal), and upsert the index. `status` is the terminal
@@ -40277,11 +40635,13 @@ async function ownerOf2(runs, unitsOf, threadKey) {
     const units = await unitsOf(instanceId).catch(() => []);
     const unit = units.find((u) => u.threadKey === threadKey && u.ending === void 0);
     if (unit !== void 0) return { kind: "unit", instanceId, unit };
-    const ended = units.find(
+    const ended = units.filter(
       (u) => u.threadKey === threadKey && u.ending !== void 0 && u.ending.kind !== "merged" && u.ending.kind !== "already_landed"
     );
     const ship = runs.find((r) => r.instanceId === instanceId && r.finished);
-    if (ended !== void 0 && ship !== void 0) return { kind: "pipeline", instanceId, run: ship, unit: ended };
+    if (ended.length === 1 && ship !== void 0) return { kind: "pipeline", instanceId, run: ship, unit: ended[0] };
+    if (ended.length > 1 && ship !== void 0)
+      return { kind: "pipeline_ambiguous", instanceId, run: ship, units: ended };
   }
   const agent = stickyAgentOf(runs);
   if (agent !== void 0) return { kind: "session", agent };
@@ -40492,8 +40852,9 @@ function ownedProjection(p) {
 function ownerNote(owner) {
   const who2 = owner.kind === "live" ? `a live run${owner.runId !== void 0 ? ` (\`${owner.runId}\`)` : ""}` : owner.kind === "unit" ? `the unfinished plan unit ${owner.unit}` : `the ended pipeline for unmerged plan unit ${owner.unit}`;
   const steer = owner.kind === "live" && owner.runId !== void 0 ? ` bind \`steer run ${owner.runId} <words>\` to deliver it,` : "";
-  const fold = owner.kind === "pipeline" ? " Any steer decision also folds, so the pipeline's original task is re-issued instead of targeting an ended transcript run." : "";
-  return `This thread is owned by ${who2}: the request below is a follow-up for that owner. To act on it,${steer} bind a read command, or ask a question. Any other decision \u2014 a refusal, a preset, a write \u2014 folds the whole message into the owner unchanged and posts no answer.${fold}`;
+  if (owner.kind === "pipeline")
+    return `This thread is owned by ${who2}: the request below is a continuation of that durable task. Read tools may ground the decision, but every action folds into the owner so the current pull request is re-read and the pipeline resumes; an informational command or question is not fulfillment.`;
+  return `This thread is owned by ${who2}: the request below is a follow-up for that owner. To act on it,${steer} bind a read command, or ask a question. Any other decision \u2014 a refusal, a preset, a write \u2014 folds the whole message into the owner unchanged and posts no answer.`;
 }
 function operatorProjection(input) {
   return {
@@ -40878,14 +41239,13 @@ function runnableProposal(proposal, ctx) {
   return (ctx.repositories?.length ?? 0) > 0 || /https?:\/\/github\.com\/[\w.-]+\/[\w.-]+|(?:^|\s)[\w.-]+\/[\w.-]+(?:\s|[:#]|$)/i.test(request2);
 }
 function ownedDecisionRuns(event, owner, commands) {
-  if (event.outcome !== "binds") return false;
+  if (owner.kind === "pipeline" || event.outcome !== "binds") return false;
   return (event.binds ?? []).every((bind) => {
     const parsed = commands ? parseChatCommand(bind.line, commands) : null;
     if (parsed?.kind !== "invoke") return false;
     const def = commands.list().find((c) => c.id === parsed.id);
     if (!def) return false;
-    if (def.id === "steer.run")
-      return owner.kind !== "pipeline" && !(owner.kind === "live" && owner.runId === void 0);
+    if (def.id === "steer.run") return !(owner.kind === "live" && owner.runId === void 0);
     return boundBlastRadius(def, parsed.input) === "read";
   });
 }
@@ -41208,6 +41568,7 @@ async function executeOperatorDecision(deps, ctx) {
     "verbose"
   );
   const answered = { kind: "answered" };
+  if (ctx.owner?.kind === "pipeline") return { kind: "fold" };
   if (event.outcome === "question") {
     await io.reply(event.question ?? "");
     await recordOperatorDecision(deps, msg, event, ctx.ending, ctx.trace);
@@ -41567,21 +41928,21 @@ function parseSkillMarkdown(raw) {
   if (!fm || typeof fm !== "object" || Array.isArray(fm)) {
     throw new Error("skill frontmatter is not a YAML mapping");
   }
-  const record2 = fm;
-  const name = record2.name;
+  const record3 = fm;
+  const name = record3.name;
   if (typeof name !== "string" || name.trim() === "") {
     throw new Error("skill frontmatter is missing a non-empty string `name`");
   }
-  const description = record2.description;
+  const description = record3.description;
   if (typeof description !== "string" || description.trim() === "") {
     throw new Error(`skill "${name}" frontmatter is missing a non-empty string \`description\``);
   }
-  const agents = record2.agents;
+  const agents = record3.agents;
   if (!Array.isArray(agents) || agents.length === 0 || !agents.every((a) => typeof a === "string" && a.trim() !== "")) {
     throw new Error(`skill "${name}" frontmatter needs a non-empty \`agents\` array of strings (e.g. [review])`);
   }
-  const source2 = typeof record2.source === "string" ? record2.source.trim() : void 0;
-  const upstream = parseUpstream(record2.upstream, name);
+  const source2 = typeof record3.source === "string" ? record3.source.trim() : void 0;
+  const upstream = parseUpstream(record3.upstream, name);
   return {
     name: name.trim(),
     description: description.trim(),
@@ -41867,6 +42228,47 @@ var init_customInstructions = __esm({
   }
 });
 
+// ../../src/core/runEventLane.ts
+var RunEventLane;
+var init_runEventLane = __esm({
+  "../../src/core/runEventLane.ts"() {
+    "use strict";
+    RunEventLane = class {
+      constructor(publishNow) {
+        this.publishNow = publishNow;
+      }
+      publishNow;
+      tail;
+      /** Publish synchronously while idle; otherwise preserve order behind the active write. */
+      publish(event) {
+        if (!this.tail) {
+          this.publishNow(event);
+          return;
+        }
+        void this.write(() => this.publishNow(event));
+      }
+      /** Queue one operation after every event or operation already accepted. */
+      write(work) {
+        const previous = this.tail ?? Promise.resolve();
+        const next = previous.then(work);
+        const settled = next.then(
+          () => void 0,
+          () => void 0
+        );
+        this.tail = settled;
+        void settled.then(() => {
+          if (this.tail === settled) this.tail = void 0;
+        });
+        return next;
+      }
+      /** Wait until every operation accepted so far has settled. */
+      async drain() {
+        await this.tail;
+      }
+    };
+  }
+});
+
 // ../../src/core/statusCoalescer.ts
 function coalesceStatus(inner, minIntervalMs, now = Date.now, schedule = setTimeout) {
   let lastSentAt = -Infinity;
@@ -42039,22 +42441,24 @@ async function registerRun(deps, ctx) {
     {
       id: runId3,
       startedAt,
-      ...resume ? { replay: resume.events } : ctx.restartCarried ? { replay: ctx.restartCarried.events, token: ctx.restartCarried.token } : {}
+      ...carriedRow?.liveState !== void 0 ? { liveState: { liveState: carriedRow.liveState, liveStateSeq: carriedRow.liveStateSeq } } : {},
+      ...resume ? { replay: resume.events } : ctx.restartCarried ? { replay: ctx.restartCarried.events, token: ctx.restartCarried.token, resetLiveState: true } : {}
     }
   );
+  const events = new RunEventLane((event) => registry.publish(run2.id, event));
   if (ctx.restartCarried)
-    registry.publish(run2.id, { type: "run_note", kind: "resumed", summary: ctx.restartCarried.note, at: clock4() });
+    events.publish({ type: "run_note", kind: "resumed", summary: ctx.restartCarried.note, at: clock4() });
   const liveUrl = liveViewLink(run2.id, run2.token);
   shell.setLink(liveUrl ? { url: liveUrl, label: "Live run" } : void 0);
   if (liveUrl) admitted.runLink = liveUrl;
   io.runStarted?.({ id: run2.id });
-  trace.bindRun(run2.id, (e) => registry.publish(run2.id, e));
+  trace.bindRun(run2.id, (event) => events.publish(event));
   const publishText = (type, text, source3, raw) => {
     const redacted = redactSecrets(text);
     const body = { text: redacted, ...source3 ? { source: source3 } : {}, at: clock4() };
     const event = type === "input" ? { type, messageId: messageIdOf(msg, run2.id), ...body } : { type, ...body };
     const withRaw = raw !== void 0 ? { ...event, raw: redactSecrets(raw) } : event;
-    registry.publish(run2.id, utf8ByteLength(JSON.stringify(withRaw)) <= MAX_EVENT_BYTES ? withRaw : event);
+    events.publish(utf8ByteLength(JSON.stringify(withRaw)) <= MAX_EVENT_BYTES ? withRaw : event);
     console.log(`[event] ${msg.threadKey} type=${type} bytes=${utf8ByteLength(redacted)}`);
   };
   const humanize = isMrkdwnChannel(msg.channelId);
@@ -42074,7 +42478,7 @@ async function registerRun(deps, ctx) {
   if (!resume && ctx.references) {
     const { conversations, blocks } = ctx.references;
     conversations.forEach((rc, i) => {
-      registry.publish(run2.id, {
+      events.publish({
         type: "reference",
         url: rc.permalink,
         channelId: rc.ref.channelId,
@@ -42086,7 +42490,7 @@ async function registerRun(deps, ctx) {
       console.log(`[event] ${msg.threadKey} type=reference channel=${rc.ref.channelId} messages=${rc.messages.length}`);
     });
   }
-  const publishMeta = (repoCtx2) => registry.publish(run2.id, {
+  const publishMeta = (repoCtx2) => events.publish({
     type: "run_meta",
     agent: agent.name,
     agentSource,
@@ -42118,7 +42522,7 @@ async function registerRun(deps, ctx) {
   if (!resume)
     for (const d of cardDecisions ?? []) {
       if (d.outcome !== "degraded") continue;
-      registry.publish(run2.id, {
+      events.publish({
         type: "run_note",
         kind: "control_degraded",
         summary: oneLine(
@@ -42132,12 +42536,12 @@ async function registerRun(deps, ctx) {
         at: clock4()
       });
     }
-  if (!resume && route2) registry.publish(run2.id, { type: "route", ...route2, at: clock4() });
-  if (!resume && ctx.operator) registry.publish(run2.id, { type: "operator", ...ctx.operator, at: clock4() });
+  if (!resume && route2) events.publish({ type: "route", ...route2, at: clock4() });
+  if (!resume && ctx.operator) events.publish({ type: "operator", ...ctx.operator, at: clock4() });
   if (!resume && deps.config.config.runHistory?.includeContext !== false) {
     for (const text of contextMessageTexts(seedTurns ?? history, humanize)) publishText("context", text);
   }
-  return { run: run2, runId: runId3, channelVisibility, liveUrl, publishText, publishMeta };
+  return { run: run2, runId: runId3, channelVisibility, liveUrl, events, publishText, publishMeta };
 }
 async function reserveRun(deps, ctx) {
   const {
@@ -42213,7 +42617,7 @@ async function reserveRun(deps, ctx) {
 }
 async function attachRound(deps, ctx) {
   const { threadKey, agent, profile, repoCtx, root, clock: clock4, reattach, stopSignal, remainingMs, requester } = ctx;
-  const { onSetupNote } = ctx;
+  const { onLiveStateObservation } = ctx;
   const ownPr = agent.name === "review" ? void 0 : ownPrOf(repoCtx);
   return root.span("dispatch.workspace.attach", async (span) => {
     const graft = (steps, residentTotalMs) => graftResidentSteps(steps, {
@@ -42249,7 +42653,7 @@ async function attachRound(deps, ctx) {
           ...stopSignal !== void 0 ? { stopSignal } : {},
           ...remainingMs !== void 0 ? { remainingMs } : {},
           ...requester !== void 0 ? { requester } : {},
-          ...onSetupNote !== void 0 ? { onSetupNote } : {}
+          ...onLiveStateObservation !== void 0 ? { onLiveStateObservation } : {}
         },
         logKey: threadKey,
         span
@@ -42306,10 +42710,10 @@ async function attachWorkspace(deps, ctx) {
       clock: clock4,
       // The requester whose binding names the author pair (record 0062).
       requester: msg.userId,
-      // A run admitted onto a drained fleet says so (issue 2044): the drain
-      // wait paints its one line here, and its end restores the attach label
-      // the card sink painted at the span's start.
-      onSetupNote: (note) => shell.setSetupLabel(note ?? `${displayNameOf("dispatch.workspace.attach")}\u2026`),
+      onLiveStateObservation: async (observation) => {
+        await ctx.onLiveStateObservation?.(observation);
+        shell.setSetupLabel(`${liveStateWords(observation.state)}\u2026`);
+      },
       ...reattach !== void 0 ? { reattach } : {},
       ...stopSignal !== void 0 ? { stopSignal } : {},
       ...remainingMs !== void 0 ? { remainingMs } : {}
@@ -42476,7 +42880,6 @@ var init_provision = __esm({
     init_factory();
     init_executor();
     init_residentTrace();
-    init_displayNames();
     init_resident();
     init_memory();
     init_budgets();
@@ -42489,12 +42892,14 @@ var init_provision = __esm({
     init_reviewRound();
     init_repoContext();
     init_runEvents();
+    init_runEventLane();
     init_redact();
     init_runRecord();
     init_inboxMessage();
     init_statusCardFrame();
     init_statusCoalescer();
     init_types5();
+    init_decide();
     init_record();
     init_reply();
     init_refusal();
@@ -44750,9 +45155,13 @@ function mapStringLeaves(value, fn) {
   }
   return value;
 }
+function requesterText(text) {
+  return text.trim().replace(/\s+/g, " ").replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/[\\`*_{}[\]()#!|~]/g, "\\$&").replace(/@/g, "&#64;");
+}
 function requestedByLine(by) {
-  const steered = by.steeredBy !== void 0 && by.steeredBy.length > 0 ? `; steered by ${by.steeredBy.join(", ")}` : "";
-  return `Requested by @${by.login} in ${by.surface}${steered}`;
+  const steered = by.steeredBy !== void 0 && by.steeredBy.length > 0 ? `; steered by ${by.steeredBy.map(requesterText).join(", ")}` : "";
+  const thread = by.threadUrl ? ` \xB7 [Thread](${by.threadUrl})` : "";
+  return `Requested by **${requesterText(by.name) || "Unknown requester"}**${thread}${steered}`;
 }
 function encodeGithubPathSegments(path) {
   return path.split("/").map(encodeURIComponent).join("/");
@@ -44775,6 +45184,7 @@ function renderPrDescriptionMarkdown(desc, ctx) {
   if (!SHA_RE2.test(ctx.headSha))
     throw new Error(`renderPrDescriptionMarkdown: headSha must be a full 40-char lowercase sha, got "${ctx.headSha}"`);
   const out = [];
+  if (ctx.requestedBy) out.push(requestedByLine(ctx.requestedBy), "");
   out.push(desc.tldr, "");
   out.push(`${MAP_LABELS.why} ${desc.why}`, "");
   out.push(MAP_LABELS.whereToLook, "");
@@ -44801,10 +45211,7 @@ function renderPrDescriptionMarkdown(desc, ctx) {
       ...desc.validation.criteria.map((c) => `| ${cell2(c.criterion)} | ${cell2(c.proof)} |`)
     ])
   );
-  const agentLines = [
-    ...desc.agentNotes ? [desc.agentNotes] : [],
-    ...ctx.requestedBy ? [requestedByLine(ctx.requestedBy)] : []
-  ];
+  const agentLines = desc.agentNotes ? [desc.agentNotes] : [];
   if (agentLines.length > 0) out.push(...details(FOLD_SUMMARIES.agents, agentLines));
   out.push(GENERATED_FOOTER, "");
   return out.join("\n");
@@ -44812,6 +45219,8 @@ function renderPrDescriptionMarkdown(desc, ctx) {
 function parsePrDescriptionMarkdown(body) {
   const problems = [];
   const lines = body.replace(/\r\n?/g, "\n").split("\n").filter((l) => l.trim() !== GENERATED_FOOTER);
+  if (/^Requested by \*\*(?:\\.|[^*\\])+\*\*(?: · \[Thread\]\([^\s)]+\))?(?:; steered by .*)?$/.test(lines[0] ?? ""))
+    lines.shift();
   const fenced = fenceMask(lines);
   const description = { pointers: [] };
   if (lines.some((l, i) => !fenced[i] && /^##\s+Tour\s*$/i.test(l))) {
@@ -46012,12 +46421,12 @@ var init_contract4 = __esm({
     };
     RELAUNCH_CEILING = 2;
     HarnessContainerReplacedError = class extends HarnessInterruptedError {
-      constructor(message4, said2, was, now, record2, condition = "word") {
+      constructor(message4, said2, was, now, record3, condition = "word") {
         super(message4, "container replaced under the run", "container_replaced");
         this.said = said2;
         this.was = was;
         this.now = now;
-        this.record = record2;
+        this.record = record3;
         this.condition = condition;
         this.name = "HarnessContainerReplacedError";
         if (condition !== "identity" !== (said2 !== void 0))
@@ -46104,11 +46513,11 @@ async function prepareRelaunch(deps, ctx) {
   } else {
     ctx.saveFacts(written);
   }
-  const { deadline, ...record2 } = replaced.record;
+  const { deadline, ...record3 } = replaced.record;
   return {
     kind: "relaunch",
     resume: {
-      ...record2,
+      ...record3,
       remainingMs: Math.max(0, deadline - ctx.clock()),
       facts: written,
       relaunch: {
@@ -47271,7 +47680,7 @@ var init_runBearers = __esm({
        *  after `record` returned would carry the old hash ahead of the new one.
        *  Refuses by name the runs `issue` mints nothing for, and hands `record`
        *  nothing then. */
-      rotate(runId3, record2) {
+      rotate(runId3, record3) {
         const entry = this.entries.get(runId3);
         if (!entry) return { ok: false, reason: "unknown_run" };
         if (entry.revoked) return { ok: false, reason: "revoked" };
@@ -47279,7 +47688,7 @@ var init_runBearers = __esm({
         const secret2 = randomBytes4(SECRET_BYTES);
         const hash = hashOf(secret2);
         entry.hashes.push(hash);
-        record2(hash.toString("hex"));
+        record3(hash.toString("hex"));
         entry.hashes = [hash];
         return { ok: true, token: token(runId3, secret2), expiresAt: entry.grant.expiresAt };
       }
@@ -48715,6 +49124,11 @@ var init_mirror = __esm({
       seedEchoPending = false;
       mirroredTail;
       iteration = 0;
+      /** The loop counters on the last transcript-bearing step. A cursor-only
+       * checkpoint repeats them so a post-loop turn cannot become part of the
+       * resumable model loop merely by consuming a control row. */
+      lastTurn = 0;
+      lastIteration = 0;
       /** The rows written since the mirror started, and the compaction entries
        *  among them by position — kept whether or not the ledger is wired, so
        *  the harness holds this generation's copy of the record it wrote
@@ -48824,6 +49238,8 @@ var init_mirror = __esm({
           inboxConsumedSeq: this.inboxConsumedSeq,
           ...this.inboxDeferred()
         };
+        this.lastTurn = report2.turn;
+        this.lastIteration = report2.iteration;
         this.idx += turns.length;
         this.lastAssistantIdx = this.idx - 1;
         this.rows.push(...turns);
@@ -48852,6 +49268,8 @@ var init_mirror = __esm({
           inboxConsumedSeq: this.inboxConsumedSeq,
           ...this.inboxDeferred()
         };
+        this.lastTurn = report2.turn;
+        this.lastIteration = report2.iteration;
         this.idx += turns.length + 1;
         this.rows.push(...turns);
         this.compactionRows.push({ before: this.rows.length, entry });
@@ -48859,6 +49277,22 @@ var init_mirror = __esm({
         await this.deps.onStep(report2);
         return true;
       }
+      /** Persist only the inbox cursor and its deferred exceptions. Post-loop
+       * turns deliberately stay out of the resumable transcript, but a control
+       * row they consume must survive a bot restart just as a loop step does. */
+      async checkpointInbox() {
+        if (!this.deps.onStep) return;
+        await this.deps.onStep({
+          turns: [],
+          firstIdx: this.idx,
+          inFlight: [],
+          turn: this.lastTurn,
+          iteration: this.lastIteration,
+          remainingMs: Math.max(0, this.deps.remainingMs()),
+          inboxConsumedSeq: this.inboxConsumedSeq,
+          ...this.inboxDeferred()
+        });
+      }
     };
   }
 });
@@ -49057,6 +49491,82 @@ var init_process = __esm({
   }
 });
 
+// ../../src/core/providerToolSchemas.ts
+function responsesRejectsPattern(pattern) {
+  return /\(\?(?:[=!]|<[=!])/.test(pattern);
+}
+function shapeResponsesSchema(value, tool, degradations) {
+  const schema = record(value);
+  if (!schema) {
+    if (!Array.isArray(value)) return { value, changed: false };
+    let changed2 = false;
+    const items = value.map((item) => {
+      const shaped = shapeResponsesSchema(item, tool, degradations);
+      changed2 ||= shaped.changed;
+      return shaped.value;
+    });
+    return { value: changed2 ? items : value, changed: changed2 };
+  }
+  let changed = false;
+  const out = {};
+  for (const [keyword, item] of Object.entries(schema)) {
+    if (keyword === "pattern" && typeof item === "string" && responsesRejectsPattern(item)) {
+      degradations.push({
+        tool,
+        keyword,
+        why: "the Responses wire does not accept regular-expression lookaround"
+      });
+      changed = true;
+      continue;
+    }
+    if ((keyword === "properties" || keyword === "$defs" || keyword === "definitions") && record(item)) {
+      let mapChanged = false;
+      const mapped = {};
+      for (const [name, child] of Object.entries(record(item))) {
+        const shaped = shapeResponsesSchema(child, tool, degradations);
+        mapChanged ||= shaped.changed;
+        mapped[name] = shaped.value;
+      }
+      out[keyword] = mapChanged ? mapped : item;
+      changed ||= mapChanged;
+      continue;
+    }
+    if (["additionalProperties", "allOf", "anyOf", "if", "items", "not", "oneOf", "then", "else"].includes(keyword) && typeof item === "object" && item !== null) {
+      const shaped = shapeResponsesSchema(item, tool, degradations);
+      out[keyword] = shaped.value;
+      changed ||= shaped.changed;
+      continue;
+    }
+    out[keyword] = item;
+  }
+  return { value: changed ? out : value, changed };
+}
+function shapeToolSchemasForWire(shape, body) {
+  if (shape !== "openai-responses" || !Array.isArray(body.tools)) return { body, degradations: [] };
+  const degradations = [];
+  let changed = false;
+  const tools = body.tools.map((item) => {
+    const tool = record(item);
+    if (!tool) return item;
+    const name = typeof tool.name === "string" ? tool.name : "unnamed";
+    const shaped = shapeResponsesSchema(tool.parameters, name, degradations);
+    if (!shaped.changed) return item;
+    changed = true;
+    return { ...tool, parameters: shaped.value };
+  });
+  const unique = degradations.filter(
+    (candidate, index, all) => all.findIndex((other) => other.tool === candidate.tool && other.keyword === candidate.keyword) === index
+  );
+  return { body: changed ? { ...body, tools } : body, degradations: unique };
+}
+var record;
+var init_providerToolSchemas = __esm({
+  "../../src/core/providerToolSchemas.ts"() {
+    "use strict";
+    record = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+  }
+});
+
 // ../../src/core/harness/piAi.ts
 import { anthropicMessagesApi } from "@earendil-works/pi-ai/api/anthropic-messages.lazy";
 import { openAICompletionsApi } from "@earendil-works/pi-ai/api/openai-completions.lazy";
@@ -49224,6 +49734,7 @@ var init_piAi = __esm({
   "../../src/core/harness/piAi.ts"() {
     "use strict";
     init_provider();
+    init_providerToolSchemas();
     init_secrets2();
     init_clock();
     ANTHROPIC_BASE_URL = "https://api.anthropic.com";
@@ -49311,7 +49822,10 @@ var init_piAi = __esm({
           ...this.fetchImpl ? { fetch: this.fetchImpl } : {}
         };
         try {
-          const message4 = await this.api$().stream(model, toPiContext(req, model, this.clock), options).result();
+          const context = toPiContext(req, model, this.clock);
+          const wire = this.api === "openai-completions" ? "openai-chat" : this.api;
+          const shaped = shapeToolSchemasForWire(wire, context);
+          const message4 = await this.api$().stream(model, shaped.body, options).result();
           return fromPiMessage(message4, this.name, req.tools);
         } catch (err2) {
           const failure2 = providerFailureOf(err2);
@@ -50388,6 +50902,7 @@ async function runPiHarnessOpen(deps, run2) {
     let parkSettled = false;
     let pendingReissue = [];
     let reissueInFlight;
+    let reissueInFlightRows = [];
     let reissues = 0;
     let providerRetryReady = false;
     let providerRetryWait;
@@ -50400,20 +50915,21 @@ async function runPiHarnessOpen(deps, run2) {
       providerRetryWait = void 0;
       providerRetryGeneration += 1;
       pendingReissue = [];
+      reissueInFlightRows = [];
     };
     const maybeReissue = () => {
       if (heldTurn === void 0 || !parkSettled || reissueInFlight !== void 0 || retryInFlight !== void 0)
         return;
       if (pendingReissue.length === 0) return;
       if (loopEnded || hardStopped || writeUp !== void 0 || finaleAborted) return;
-      const batch = pendingReissue.splice(0);
+      reissueInFlightRows = pendingReissue.splice(0);
       reissues += 1;
       const id = reissues === 1 ? `${ids.prompt}:reissue` : `${ids.prompt}:reissue:${reissues}`;
       reissueInFlight = id;
       unechoed.push({
         message: REISSUE_PROMPT,
-        seq: Math.max(0, ...batch.map((i) => i.ledgerSeq ?? 0)),
-        inputs: batch
+        seq: Math.max(0, ...reissueInFlightRows.map((i) => i.ledgerSeq ?? 0)),
+        inputs: reissueInFlightRows
       });
       sends.send({ id, type: "prompt", message: REISSUE_PROMPT });
     };
@@ -50674,16 +51190,29 @@ ${stagedLine}` : prompt;
           save();
         }
         if (reissueInFlight !== void 0 && r.id === reissueInFlight) {
-          reissueInFlight = void 0;
           if (r.success === false) {
+            reissueInFlight = void 0;
             parkSettled = false;
             const at = unechoed.findIndex((u) => u.message === REISSUE_PROMPT);
-            if (at >= 0) pendingReissue.push(...unechoed.splice(at, 1)[0].inputs);
+            if (at >= 0) unechoed.splice(at, 1);
+            pendingReissue.push(...reissueInFlightRows);
+            reissueInFlightRows = [];
             note(
               "harness_error",
               `the reissue prompt was refused (${String(r.error ?? "no reason")}); the turn stays held for the next settle`
             );
           } else {
+            drainFollowUps2();
+            await steers;
+            const at = unechoed.findIndex((u) => u.message === REISSUE_PROMPT);
+            if (at >= 0) unechoed.splice(at, 1);
+            mirror.inboxConsumedSeq = Math.max(
+              mirror.inboxConsumedSeq,
+              ...reissueInFlightRows.map((item) => item.ledgerSeq ?? 0),
+              ...pendingReissue.map((item) => item.ledgerSeq ?? 0)
+            );
+            await mirror.checkpointInbox();
+            reissueInFlight = void 0;
             clearProviderHold();
           }
         }
@@ -50692,7 +51221,16 @@ ${stagedLine}` : prompt;
           if (r.success === false) {
             parkSettled = false;
             note("harness_error", "the model retry prompt was refused; the transport failure remains held");
-          } else clearProviderHold();
+          } else {
+            drainFollowUps2();
+            await steers;
+            mirror.inboxConsumedSeq = Math.max(
+              mirror.inboxConsumedSeq,
+              ...pendingReissue.map((item) => item.ledgerSeq ?? 0)
+            );
+            await mirror.checkpointInbox();
+            clearProviderHold();
+          }
         }
         if (r.id === ids.prompt) {
           catchingUp = false;
@@ -50926,8 +51464,8 @@ ${stagedLine}` : prompt;
           return;
         }
         const reissued = inputs.filter((item) => item.userId === PLANE_ACTOR_ID && isReissueSteerText(item.text));
-        const waiting2 = reissued.length === 0 ? inputs : inputs.filter((item) => !reissued.includes(item));
-        if (waiting2.length > 0) run2.inbox?.requeue(waiting2);
+        const waiting3 = reissued.length === 0 ? inputs : inputs.filter((item) => !reissued.includes(item));
+        if (waiting3.length > 0) run2.inbox?.requeue(waiting3);
         for (const item of reissued) {
           emit({
             type: "input",
@@ -51049,10 +51587,13 @@ ${stagedLine}` : prompt;
                   `the follow-up turn's reissue prompt was refused (${String(obs.response.error ?? "no reason")}); the turn stays held for the next settle`
                 );
               } else {
+                drainTurnReissues();
                 mirror.inboxConsumedSeq = Math.max(
                   mirror.inboxConsumedSeq,
-                  ...turnReissueInFlightRows.map((item) => item.ledgerSeq ?? 0)
+                  ...turnReissueInFlightRows.map((item) => item.ledgerSeq ?? 0),
+                  ...turnReissueRows.map((item) => item.ledgerSeq ?? 0)
                 );
+                await mirror.checkpointInbox();
                 clearTurnProviderHold();
               }
             }
@@ -51067,6 +51608,7 @@ ${stagedLine}` : prompt;
                   mirror.inboxConsumedSeq,
                   ...turnReissueRows.map((item) => item.ledgerSeq ?? 0)
                 );
+                await mirror.checkpointInbox();
                 clearTurnProviderHold();
               }
             }
@@ -51234,13 +51776,13 @@ var init_harness = __esm({
       }
     };
     PiContainerReplacedError = class extends HarnessContainerReplacedError {
-      constructor(said2, was, now, record2, condition = "word") {
+      constructor(said2, was, now, record3, condition = "word") {
         super(
           condition === "transport" ? `the container running pi stopped answering (${was ?? "unknown"}; ${replacedBecause(condition, said2)})` : `the container running pi was replaced (${was ?? "unknown"} \u2192 ${now ?? "unknown"}; ${replacedBecause(condition, said2)})`,
           said2,
           was,
           now,
-          record2,
+          record3,
           condition
         );
         this.name = "PiContainerReplacedError";
@@ -51451,14 +51993,17 @@ var init_resume = __esm({
 
 // ../../src/execution/githubComments.ts
 async function postReviewComment(target, body) {
+  const codePoints = [...body].length;
+  if (codePoints > MAX_REVIEW_POST_CODE_POINTS) {
+    throw new Error(
+      `PR review body is ${codePoints} Unicode code points, over the ${MAX_REVIEW_POST_CODE_POINTS} limit; refusing to clip the structured verdict`
+    );
+  }
   const token2 = await resolveGithubToken();
   if (!token2) {
     throw new Error("no GitHub credential available to post the PR review comment");
   }
-  const clipped = body.length > MAX_COMMENT_CHARS ? `${body.slice(0, MAX_COMMENT_CHARS)}
-
-_(review truncated to fit GitHub's comment size limit)_` : body;
-  const payload2 = { event: "COMMENT", body: clipped };
+  const payload2 = { event: "COMMENT", body };
   if (target.commitId) payload2.commit_id = target.commitId;
   const res = await fetch(`https://api.github.com/repos/${target.repo}/pulls/${target.number}/reviews`, {
     method: "POST",
@@ -51476,13 +52021,12 @@ _(review truncated to fit GitHub's comment size limit)_` : body;
     throw new Error(`PR comment post failed: HTTP ${res.status} ${redactAndCap(text, 300)}`);
   }
 }
-var MAX_COMMENT_CHARS;
 var init_githubComments = __esm({
   "../../src/execution/githubComments.ts"() {
     "use strict";
     init_githubApp();
     init_redact();
-    MAX_COMMENT_CHARS = 65e3;
+    init_reviewVerdict();
   }
 });
 
@@ -51534,13 +52078,13 @@ function parsedPrDescriptionArtifact(facts2, ctx) {
 async function findSubmittedPrDescription(store, key, limit = SUBMITTED_LOOKUP_LIMIT) {
   const rows = await store.list({ limit, visibleTo: { kind: "repos-in", repos: [key.repo] } });
   for (const row2 of rows) {
-    const record2 = await store.get(row2.id);
-    if (!record2) continue;
-    for (let i = record2.events.length - 1; i >= 0; i--) {
-      const ev = record2.events[i];
+    const record3 = await store.get(row2.id);
+    if (!record3) continue;
+    for (let i = record3.events.length - 1; i >= 0; i--) {
+      const ev = record3.events[i];
       if (ev.type === "review_artifact" && ev.artifact === "pr_description" && ev.origin === "submitted" && ev.repo === key.repo && ev.pr === key.pr && ev.headSha === key.headSha) {
         const { type: _type, seq: _seq, at: _at, ...artifact } = ev;
-        return { artifact: { ...artifact, fromRunId: artifact.fromRunId ?? record2.id }, runId: record2.id };
+        return { artifact: { ...artifact, fromRunId: artifact.fromRunId ?? record3.id }, runId: record3.id };
       }
     }
   }
@@ -51803,7 +52347,7 @@ async function runCodingPrPostStep(input) {
     });
   }
   const ownPr = target.ownPr;
-  const requestedBy = input.identity?.requestedBy;
+  const requestedBy = input.requestedBy;
   const onOwnPrBranch = ownPr?.headBranch !== void 0 && branch2 === ownPr.headBranch;
   const pushedPastOwnPr = ownPr !== void 0 && onOwnPrBranch && pushed && headSha !== void 0 && !sameCommit(headSha, ownPr.headSha) ? headSha : void 0;
   if (prDescription && ownPr !== void 0 && ownPr.state !== "open" && pushedPastOwnPr !== void 0 && branch2 !== void 0) {
@@ -52014,16 +52558,17 @@ async function runCodingPrPostStep(input) {
             );
           }
         }
-        if (requestedBy !== void 0) {
-          const assignable = await input.identity.isAssignable(repo, requestedBy.login).catch(() => void 0);
+        const requestedLogin = input.identity.requestedLogin;
+        if (requestedLogin !== void 0) {
+          const assignable = await input.identity.isAssignable(repo, requestedLogin).catch(() => void 0);
           if (assignable === true)
-            await input.identity.addAssignee(repo, opened.number, requestedBy.login).catch(
+            await input.identity.addAssignee(repo, opened.number, requestedLogin).catch(
               (err2) => console.error(
-                `[pr-post] ${logKey} assignee add failed for ${requestedBy.login} on ${repo}#${opened.number}: ${err2 instanceof Error ? err2.message : String(err2)}`
+                `[pr-post] ${logKey} assignee add failed for ${requestedLogin} on ${repo}#${opened.number}: ${err2 instanceof Error ? err2.message : String(err2)}`
               )
             );
           else if (assignable === false)
-            console.log(`[identity] ${logKey} ${requestedBy.login} is not assignable on ${repo}; skipped`);
+            console.log(`[identity] ${logKey} ${requestedLogin} is not assignable on ${repo}; skipped`);
         }
       }
       console.log(
@@ -52399,6 +52944,7 @@ async function runLoop(deps, ctx) {
     coordinator,
     seed
   } = ctx;
+  const events = ctx.events ?? new RunEventLane((event) => registry.publish(run2.id, event));
   const agent = budgetedAgent(ctx.agent, profile);
   const { round: round2 } = ctx;
   let { executor } = round2.selection;
@@ -52472,13 +53018,11 @@ async function runLoop(deps, ctx) {
   const pushes = trackPushedBranch(typeof restored.pushedBranch === "string" ? restored.pushedBranch : void 0);
   let budgetEnded = false;
   let recordedPushedBranch;
-  const onEvent = (e) => {
+  let modelBudgetEndsAt;
+  const publishEvent = (e, startsRunBudget) => {
     registry.publish(run2.id, e);
     if (isSpanRecord(e)) return;
-    if (e.type === "lease") {
-      run2.control.startLease(() => e.endsAt - clock4());
-      return;
-    }
+    if (startsRunBudget) return;
     if (e.type === "tool_call") toolCalls++;
     if (e.type === "run_note" && e.kind === "time_budget_exhausted") budgetEnded = true;
     if (isCodingPrRun) {
@@ -52498,6 +53042,47 @@ async function runLoop(deps, ctx) {
     lastActivity = bookkeeping && !showBookkeeping ? void 0 : cardActivity(e);
     card.update(currentFrame());
   };
+  const onEvent = (e) => {
+    const startsRunBudget = e.type === "lease";
+    if (startsRunBudget) {
+      modelBudgetEndsAt = e.endsAt;
+      run2.control.startLease(() => e.endsAt - clock4());
+    }
+    void events.write(async () => {
+      if ((e.type === "tool_call" || e.type === "tool_result") && typeof registry.commitLiveState === "function") {
+        const summary = registry.getById(run2.id);
+        if (summary?.liveState?.state === "working") {
+          const at = e.at ?? clock4();
+          const bound = e.type === "tool_call" && e.boundMs !== void 0 ? at + e.boundMs : modelBudgetEndsAt ?? summary.liveState.bound;
+          if (bound !== void 0) {
+            const sourceSeq = summary.eventCount + 1;
+            const assignment = {
+              expectedSeq: summary.liveStateSeq ?? 0,
+              at,
+              state: "working",
+              bound,
+              detail: e.type === "tool_call" ? "running a tool" : "model turn",
+              sourceEvents: [{ ...e, seq: sourceSeq }]
+            };
+            try {
+              if (ledgerRun?.tracked()) {
+                const committed = await ledgerRun.assignLiveState(assignment);
+                if (committed.ok) registry.commitLiveState(run2.id, committed);
+              } else {
+                const local = assignRunLiveState(summary.liveState, summary.liveStateSeq ?? 0, assignment);
+                if (local.ok) registry.commitLiveState(run2.id, { ...local, liveStateSeq: sourceSeq });
+              }
+            } catch (err2) {
+              console.warn(
+                `[run] ${msg.threadKey} live-state projection failed: ${err2 instanceof Error ? err2.message : String(err2)}`
+              );
+            }
+          }
+        }
+      }
+      publishEvent(e, startsRunBudget);
+    });
+  };
   for (const s of mcpForRun?.servers ?? []) {
     if (s.unavailable !== void 0)
       onEvent({
@@ -52520,14 +53105,14 @@ async function runLoop(deps, ctx) {
     descriptionArtifact = startReviewDescription({
       store: deps.runStore,
       repoCtx,
-      publish: (e) => registry.publish(run2.id, e)
+      publish: (event) => events.publish(event)
     });
     readingDiffBaseline = startReviewReadingDiff({
       executor,
       cfg: deps.config.config.review?.readingDiff,
       env: publicEnv(),
       baseRef: repoCtx.baseRef,
-      publish: (e) => registry.publish(run2.id, e),
+      publish: (event) => events.publish(event),
       parent: root
     }).baseline.then((published) => {
       console.log(`[reading-diff] ${msg.threadKey} baseline ${published ? "published" : "none"}`);
@@ -52599,10 +53184,11 @@ async function runLoop(deps, ctx) {
       if (interrupted === void 0) runFailed = true;
       throw err2;
     } finally {
+      await events.drain();
       const calls = callsInFlight(recordEvents(), statusNow());
       commandInFlight = calls.length > 0;
       if (commandInFlight)
-        registry.publish(run2.id, {
+        events.publish({
           type: "run_note",
           kind: "workspace_torn_down",
           summary: redactAndCap(
@@ -52676,12 +53262,12 @@ async function runLoop(deps, ctx) {
   let reviewStoppedBeforeStart = false;
   const latchReviewStoppedBeforeStart = () => {
     if (reviewStoppedBeforeStart || agent.name !== "review") return reviewStoppedBeforeStart;
-    const events = recordEvents();
-    const stopAt = events.findIndex(
+    const events2 = recordEvents();
+    const stopAt = events2.findIndex(
       (event) => event.type === "run_note" && (event.kind === "stop_requested" || event.kind === "stopped")
     );
     if (stopAt < 0) return false;
-    reviewStoppedBeforeStart = !events.slice(0, stopAt).some((event) => event.type === "tool_call" && event.tool !== "update_status");
+    reviewStoppedBeforeStart = !events2.slice(0, stopAt).some((event) => event.type === "tool_call" && event.tool !== "update_status");
     return reviewStoppedBeforeStart;
   };
   const clearStoppedReviewTail = () => {
@@ -52696,8 +53282,8 @@ async function runLoop(deps, ctx) {
   };
   const tailSkipped = () => run2.control.requested === "hard" || relaunchEndedRun || latchReviewStoppedBeforeStart();
   const releaseWorkspace = (span) => {
-    const events = recordEvents();
-    const pushed = pushedBranchesOf(events);
+    const events2 = recordEvents();
+    const pushed = pushedBranchesOf(events2);
     return round2.release({
       hardStopped: run2.control.requested === "hard",
       commandInFlight,
@@ -52715,7 +53301,7 @@ async function runLoop(deps, ctx) {
     const staged = await stageIntoWorkspace(files, {
       store: deps.artifacts,
       threadKey: msg.threadKey,
-      publish: (e) => registry.publish(run2.id, e),
+      publish: (event) => events.publish(event),
       nextIndex: nextStagedIndex,
       executor,
       resident: round2.selection.resident !== void 0
@@ -52793,9 +53379,9 @@ async function runLoop(deps, ctx) {
           throw new Error(
             `the ${agent.name} preset's run left ${facts2.harness} harness facts on its row, but this process has no harness roster to end that process with`
           );
-        const judge4 = harnessOf(deps.harness);
+        const judge5 = harnessOf(deps.harness);
         const container = deps.harness.containerFor?.(executor, profile.machine) ?? harnessContainerFor(executor, profile.machine);
-        const found = await judge4.find(facts2, container).catch((err2) => {
+        const found = await judge5.find(facts2, container).catch((err2) => {
           if (!isContainerGone(err2)) throw err2;
           return "gone";
         });
@@ -52820,11 +53406,11 @@ async function runLoop(deps, ctx) {
             onEvent({
               type: "run_note",
               kind: "resumed",
-              summary: `the run's row carries ${facts2.harness} harness facts (pid ${facts2.pid}) that the ${judge4.name} harness does not own: that process was neither judged nor ended here`
+              summary: `the run's row carries ${facts2.harness} harness facts (pid ${facts2.pid}) that the ${judge5.name} harness does not own: that process was neither judged nor ended here`
             });
             break;
           default:
-            await judge4.end(facts2, container);
+            await judge5.end(facts2, container);
         }
       } else noteUnknownWord("the run finished on the answer it already had");
       windDownEnding = windDownEndingUnder(finish2.answer, loopEnding);
@@ -53161,7 +53747,7 @@ async function runLoop(deps, ctx) {
       return { workspace, description: prDescription !== void 0 ? "submitted" : "not_submitted" };
     };
     if (leftBehind) {
-      registry.publish(run2.id, {
+      events.publish({
         type: "run_note",
         kind: "work_left_behind",
         summary: oneLine(workLeftBehindSummary(leftBehind)),
@@ -53170,14 +53756,16 @@ async function runLoop(deps, ctx) {
       shell.note("quiet", workLeftBehindLabel(leftBehind));
     }
     if (prDescription) {
-      registry.publish(run2.id, {
+      events.publish({
         type: "pr_description",
         description: redactPrDescription(prDescription),
         at: clock4()
       });
     }
     if (isCodingPrRun && !tailSkipped() && !endingSalvageAttempted) {
-      const requestedLogin = identitySeam !== void 0 ? await identitySeam.requestedLogin(msg.userId).catch(() => void 0) : void 0;
+      const instance = coordinator && deps.coordinatorInstances ? await deps.coordinatorInstances.get(coordinator.parentInstanceId).catch(() => void 0) : void 0;
+      const requester = instance?.userId === msg.userId ? instance : msg;
+      const requestedLogin = identitySeam !== void 0 ? await identitySeam.requestedLogin(requester.userId).catch(() => void 0) : void 0;
       prNote = await root.span(
         "run.pr_post_step",
         () => runCodingPrPostStep({
@@ -53190,6 +53778,10 @@ async function runLoop(deps, ctx) {
             remoteRepo: observedRemoteRepo
           },
           description: prDescription,
+          requestedBy: {
+            name: requester.userName?.trim() || requestedLogin || requester.userId,
+            threadUrl: threadPageLink(requester.threadKey)
+          },
           target: prTarget,
           openPullRequest: deps.openPullRequest ?? openPullRequest,
           findOpenPr: deps.findOpenPrByHead ?? findOpenPrByHead,
@@ -53202,11 +53794,11 @@ async function runLoop(deps, ctx) {
               pullRequestHead: identitySeam.pullRequestHead,
               isAssignable: identitySeam.isAssignable,
               addAssignee: identitySeam.addAssignee,
-              ...requestedLogin !== void 0 ? { requestedBy: { login: requestedLogin, surface: msg.channelId } } : {}
+              ...requestedLogin !== void 0 ? { requestedLogin } : {}
             }
           } : {},
           descriptionTurnRan,
-          publish: (e) => registry.publish(run2.id, e),
+          publish: (event) => events.publish(event),
           logKey: msg.threadKey
         })
       );
@@ -53244,7 +53836,7 @@ async function runLoop(deps, ctx) {
           fetchPrHead: deps.fetchPrHead ?? currentPrHeadSha,
           reply: (text) => io.reply(text),
           ack: (text) => replyAck(io, resolved.verbosity, text),
-          publish: (e) => registry.publish(run2.id, e),
+          publish: (event) => events.publish(event),
           logKey: msg.threadKey
         })
       );
@@ -53255,7 +53847,7 @@ async function runLoop(deps, ctx) {
       gateBypassed = err2 instanceof HarnessGateBypassedError;
       if (err2 instanceof ModelPolicyRefusedError) failure2 = { kind: "policy_refusal" };
       else if (err2 instanceof ModelTransientFailureError) failure2 = { kind: "provider_transient" };
-      registry.publish(run2.id, {
+      events.publish({
         type: "run_note",
         kind: "run_failed",
         summary: redactAndCap(err2 instanceof Error ? err2.message : String(err2), ENDING_NOTE_MAX)
@@ -53264,7 +53856,7 @@ async function runLoop(deps, ctx) {
     await endHarness().catch((endErr) => {
       const detail = `the harness session's end failed after the loop's own error: ${endErr instanceof Error ? endErr.message : String(endErr)}`;
       console.warn(`[run] ${msg.threadKey} ${detail}`);
-      registry.publish(run2.id, {
+      events.publish({
         type: "run_note",
         kind: "harness_error",
         summary: redactAndCap(detail, ENDING_NOTE_MAX),
@@ -53273,13 +53865,13 @@ async function runLoop(deps, ctx) {
     });
     await preserveCodingChildWork("ending").catch((salvageErr) => {
       const summary = `the interrupted-work checkpoint failed before teardown: ${salvageErr instanceof Error ? salvageErr.message : String(salvageErr)}`;
-      registry.publish(run2.id, { type: "run_note", kind: "work_salvage", summary, at: clock4() });
+      events.publish({ type: "run_note", kind: "work_salvage", summary, at: clock4() });
       shell.note("quiet", summary);
     });
     await root.span("post.workspace_release", (span) => releaseWorkspace(span));
     if (!interrupted) throw err2;
     if (coordinator !== void 0)
-      registry.publish(run2.id, {
+      events.publish({
         type: "child_interrupted",
         parentInstanceId: coordinator.parentInstanceId,
         reason: redactAndCap(interrupted.message, ENDING_NOTE_MAX),
@@ -53294,12 +53886,49 @@ async function runLoop(deps, ctx) {
     };
   } finally {
     clearInterval(heartbeat);
+    await events.drain();
     const status3 = statusNow();
+    if (typeof registry.commitLiveState === "function") {
+      const commitBoundary = async (state, at2) => {
+        const summary = registry.getById(run2.id);
+        if (!summary) return;
+        const eventSeq = summary.eventCount + 1;
+        const assignment = state === "ended" ? {
+          expectedSeq: summary.liveStateSeq ?? 0,
+          eventSeq,
+          at: at2,
+          state,
+          cause: causeOfClose(status3, interrupted !== void 0)
+        } : {
+          expectedSeq: summary.liveStateSeq ?? 0,
+          eventSeq,
+          at: at2,
+          state,
+          bound: summary.liveState?.bound ?? at2,
+          detail: "writing the final answer"
+        };
+        if (ledgerRun?.tracked()) {
+          const committed = await ledgerRun.assignLiveState(assignment);
+          if (committed.ok) registry.commitLiveState(run2.id, committed);
+          return;
+        }
+        const local = assignRunLiveState(summary.liveState, summary.liveStateSeq ?? 0, assignment);
+        if (!local.ok || !local.event) return;
+        registry.commitLiveState(run2.id, {
+          ...local,
+          event: { ...local.event, seq: eventSeq },
+          liveStateSeq: eventSeq
+        });
+      };
+      const at = clock4();
+      await commitBoundary("wrapping_up", at);
+      await commitBoundary("ended", clock4());
+    }
     registry.finish(run2.id, status3);
     const snap = registry.snapshot(run2.id, run2.token);
-    const events = snap?.events ?? [];
+    const recordEventList = snap?.events ?? [];
     const finishedAt = snap?.finishedAt ?? clock4();
-    const diagnosis = analyzeRunFriction(events, {
+    const diagnosis = analyzeRunFriction(recordEventList, {
       finished: true,
       truncated: snap?.truncated ?? false,
       window: { start: snap?.receivedAt ?? startedAt, end: finishedAt }
@@ -53432,10 +54061,13 @@ var init_runLoop = __esm({
     init_readingDiff();
     init_reviewDescription();
     init_runEvents();
+    init_runEventLane();
     init_redact();
     init_runFriction();
     init_llmOutput();
     init_runRecord();
+    init_runLiveState();
+    init_decide();
     init_statusCardLabel();
     init_runPace();
     init_statusCardFrame();
@@ -53799,7 +54431,7 @@ async function rowsFor(deps, p, selected, instanceId, carried) {
     p.graph.units.filter((u) => selected.includes(u.id)).map(async (u) => {
       const previous = carried?.get(u.id);
       const taskKey = p.recordTasks?.[u.id];
-      const record2 = taskKey !== void 0 ? await reserve(p.identity.repo, taskKey, previous?.record) : previous?.record;
+      const record3 = taskKey !== void 0 ? await reserve(p.identity.repo, taskKey, previous?.record) : previous?.record;
       return {
         instanceId,
         unit: u.id,
@@ -53810,7 +54442,7 @@ async function rowsFor(deps, p, selected, instanceId, carried) {
         rounds: [],
         ...p.resume !== void 0 ? { resume: p.resume } : {},
         ...previous?.lastPush !== void 0 ? { lastPush: previous.lastPush } : {},
-        ...record2 !== void 0 ? { record: record2 } : {}
+        ...record3 !== void 0 ? { record: record3 } : {}
       };
     })
   );
@@ -54226,7 +54858,11 @@ async function runShipBranch(deps, msg, io, ctx) {
     return { hostedLive: false };
   }
   const entry = pre.entry;
-  const caps = { ...resolveShipCaps(deps.config.config.ship), maxMinutes: profile.minutes };
+  const configuredCaps = resolveShipCaps(deps.config.config.ship);
+  const caps = {
+    maxRounds: Math.min(configuredCaps.maxRounds, ctx.reissueCaps?.maxRounds ?? configuredCaps.maxRounds),
+    maxMinutes: Math.min(profile.minutes, ctx.reissueCaps?.maxMinutes ?? profile.minutes)
+  };
   const held2 = fit(caps);
   if (!held2.ok) {
     const reason2 = `budget ${caps.maxMinutes} min cannot hold the ship loop (${caps.maxRounds} review rounds need ${held2.need} min)`;
@@ -54387,6 +55023,34 @@ async function runShipBranch(deps, msg, io, ctx) {
         ...REPLAY_EVERYTHING
       });
     }
+    const admittedAt = clock4();
+    const admittedEventSeq = (registry.getById(run2.id)?.eventCount ?? 0) + 1;
+    const admittedAssignment = {
+      expectedSeq: 0,
+      eventSeq: admittedEventSeq,
+      at: admittedAt,
+      state: "admitted",
+      bound: admittedAt + minutesToMs(profile.minutes),
+      detail: "waiting for the pipeline to start"
+    };
+    if (ledgerRun) {
+      const committed = await ledgerRun.assignLiveState(admittedAssignment);
+      if (!committed.ok || !registry.commitLiveState(run2.id, committed))
+        throw new RefusalError(
+          refusalOf(
+            "setup_failed",
+            `hosted live state start was not committed (${committed.ok ? "registry sequence" : committed.reason})`
+          )
+        );
+    } else {
+      const local = assignRunLiveState(void 0, 0, admittedAssignment);
+      if (local.ok && local.event)
+        registry.commitLiveState(run2.id, {
+          ...local,
+          event: { ...local.event, seq: admittedEventSeq },
+          liveStateSeq: admittedEventSeq
+        });
+    }
     const hostRefused = opened.kind === "untracked" && opened.why === "thread-live";
     const liveUrl = liveViewLink(run2.id, run2.token);
     ctx.live.runId = run2.id;
@@ -54457,7 +55121,23 @@ async function runShipBranch(deps, msg, io, ctx) {
           instanceId: outcome.instanceId,
           until: clock4() + minutesToMs(caps.maxMinutes + HOSTED_DEADLINE_MARGIN_MINUTES)
         };
-        ledgerRun.setState({ hosting });
+        const summary = registry.getById(run2.id);
+        const committed = await ledgerRun.assignLiveState({
+          expectedSeq: summary?.liveStateSeq ?? 0,
+          eventSeq: (summary?.eventCount ?? 0) + 1,
+          at: clock4(),
+          state: "working",
+          bound: hosting.until,
+          detail: HOSTED_PIPELINE_STARTING_DETAIL,
+          statePatch: { hosting }
+        });
+        if (!committed.ok || !registry.commitLiveState(run2.id, committed))
+          throw new RefusalError(
+            refusalOf(
+              "setup_failed",
+              `hosted live state transition was not committed (${committed.ok ? "registry sequence" : committed.reason})`
+            )
+          );
         registry.publish(run2.id, {
           type: "run_meta",
           agent: agent.name,
@@ -54565,6 +55245,8 @@ var init_ship = __esm({
     init_runFriction();
     init_run2();
     init_runRegistry();
+    init_runLiveState();
+    init_pipelineStanding();
     init_statusCardFrame();
     init_types5();
     init_refusal();
@@ -54891,41 +55573,41 @@ function prName(pr) {
   const m = GITHUB_PULL_URL.exec(pr.url);
   return m ? `${m[1]}#${pr.number} (${pr.url})` : `pull request ${pr.number} at ${pr.url}`;
 }
-function runArtifacts(record2) {
+function runArtifacts(record3) {
   const lines = [];
-  if (record2.pr) {
-    const head = record2.pr.head ? `, head branch ${record2.pr.head}` : "";
-    lines.push(`- pull request opened or edited: ${prName(record2.pr)}${head}`);
+  if (record3.pr) {
+    const head = record3.pr.head ? `, head branch ${record3.pr.head}` : "";
+    lines.push(`- pull request opened or edited: ${prName(record3.pr)}${head}`);
   }
-  if (record2.verdict) {
-    lines.push(`- verdict: ${record2.verdict.verdict} \u2014 ${record2.verdict.summary}`);
-    const findings = record2.verdict.findings ?? [];
+  if (record3.verdict) {
+    lines.push(`- verdict: ${record3.verdict.verdict} \u2014 ${record3.verdict.summary}`);
+    const findings = record3.verdict.findings ?? [];
     lines.push(findings.length ? `- findings:
 ${indent(findings.map(formatFinding))}` : "- findings: none recorded");
   }
-  if (record2.dispositions) {
+  if (record3.dispositions) {
     lines.push(
-      record2.dispositions.length ? `- dispositions:
-${indent(record2.dispositions.map(formatDisposition))}` : "- dispositions: none recorded"
+      record3.dispositions.length ? `- dispositions:
+${indent(record3.dispositions.map(formatDisposition))}` : "- dispositions: none recorded"
     );
   }
-  if (record2.handoff) {
-    const entries = handoffLines(record2.handoff);
+  if (record3.handoff) {
+    const entries = handoffLines(record3.handoff);
     lines.push(
       entries.length ? `- handoff:
 ${indent(entries)}` : "- handoff: nothing to hand off (three empty lists)"
     );
   }
-  const tldr = record2.pr ? tldrOf(record2.events) : void 0;
+  const tldr = record3.pr ? tldrOf(record3.events) : void 0;
   if (tldr !== void 0) lines.push(`- description TL;DR: ${tldr}`);
-  if (record2.reviewPost) {
-    const post = record2.reviewPost;
+  if (record3.reviewPost) {
+    const post = record3.reviewPost;
     lines.push(
       post.posted ? `- review post: posted to ${post.target.repo}#${post.target.number} at ${post.head}${post.verdict ? ` (${post.verdict})` : ""}` : `- review post: not posted \u2014 ${post.reason}`
     );
   }
   if (lines.length === 0) return void 0;
-  return [`### run ${record2.id} (${record2.agent ?? "agent unknown"})`, ...lines].join("\n");
+  return [`### run ${record3.id} (${record3.agent ?? "agent unknown"})`, ...lines].join("\n");
 }
 function threadArtifactsBlock(records, opts) {
   const maxRuns = opts.maxRuns ?? THREAD_ARTIFACTS_MAX_RUNS;
@@ -55186,6 +55868,23 @@ async function answerUnitOwnedThread(deps, ctx) {
 function activeRunCount() {
   return activeRuns;
 }
+function continuationBudgetOf(instance, unit) {
+  if (unit.ending?.kind === "wall_clock_cap" || unit.ending?.kind === "review_pending")
+    return { kind: "exhausted", budget: "wall-clock" };
+  if (unit.ending?.kind === "round_cap") return { kind: "exhausted", budget: "review-round" };
+  const caps = instance.caps;
+  if (caps === void 0 || unit.startedAt === void 0 || unit.ending === void 0 || caps.maxMinutes <= 0 || caps.maxRounds <= 0 || unit.ending.at < unit.startedAt)
+    return { kind: "unavailable" };
+  const remainingMinutes = caps.maxMinutes - (unit.ending.at - unit.startedAt) / MINUTE_MS;
+  if (remainingMinutes <= 0) return { kind: "exhausted", budget: "wall-clock" };
+  const reviewRounds = unit.rounds.reduce(
+    (highest, round2) => round2.agent === "review" ? Math.max(highest, round2.index) : highest,
+    0
+  );
+  const remainingRounds = caps.maxRounds - reviewRounds;
+  if (remainingRounds <= 0) return { kind: "exhausted", budget: "review-round" };
+  return { kind: "remaining", caps: { maxRounds: remainingRounds, maxMinutes: remainingMinutes } };
+}
 async function dispatch(deps, msg, io, opts = {}) {
   const ended = { status: "completed" };
   const resume = opts.resume;
@@ -55280,22 +55979,46 @@ async function dispatch(deps, msg, io, opts = {}) {
   try {
     const configuredOperator = !resume && !restart && !opts.parent && !opts.coordinator ? operatorModeOf(deps.config.config) : "off";
     const typedDecision = parseDirectives(msg.text).agent !== void 0 || deps.commands !== void 0 && parseChatCommand(msg.text, deps.commands) !== null;
-    const operatorMode = configuredOperator === "on" && typedDecision ? "off" : configuredOperator;
+    let operatorMode = configuredOperator === "on" && typedDecision ? "off" : configuredOperator;
     let operatorEvent;
     let operatorPreset;
     let operatorRequest;
     let operatorModel;
     let operatorRepo;
     let reissuePlanId;
+    let reissueCaps;
     let operatorThread;
     let pageOwner;
     if (operatorMode !== "off") {
       const runsService2 = deps.runs ?? createRunsService({ registry, store: deps.runStore });
       operatorThread = opts.thread ?? await readThread(runsService2, msg.threadKey);
+      if (operatorThread !== void 0 && deps.coordinatorInstances !== void 0) {
+        const unitReads = /* @__PURE__ */ new Map();
+        const unitsOf = (id) => {
+          let read = unitReads.get(id);
+          if (read === void 0) {
+            read = deps.coordinatorInstances.listUnits(id);
+            unitReads.set(id, read);
+          }
+          return read;
+        };
+        pageOwner = await ownerOf2(operatorThread, unitsOf, msg.threadKey);
+        if (operatorMode === "on" && parseDirectives(msg.text).agent === void 0) {
+          const continuationOwner = pageOwner.kind === "pipeline" || pageOwner.kind === "pipeline_ambiguous" ? pageOwner : await ownerOf2(
+            operatorThread.filter((run3) => run3.finished),
+            unitsOf,
+            msg.threadKey
+          );
+          if (continuationOwner.kind === "pipeline" || continuationOwner.kind === "pipeline_ambiguous") {
+            pageOwner = continuationOwner;
+            operatorMode = "off";
+          }
+        }
+      }
+    }
+    if (operatorMode !== "off") {
       const slot = admission.get(msg.threadKey);
       const liveElsewhere = deps.threadsElsewhere.get(msg.threadKey) !== void 0;
-      if (slot === void 0 && !liveElsewhere && operatorThread !== void 0 && deps.coordinatorInstances !== void 0)
-        pageOwner = await ownerOf2(operatorThread, (id) => deps.coordinatorInstances.listUnits(id), msg.threadKey);
       const pendingQuestion = operatorMode === "on" ? pendingQuestionOf(operatorThread) : void 0;
       const joinedAnswer = pendingQuestion !== void 0 && !(pendingQuestion.proposal !== void 0 && isYesAnswer(msg.text)) ? joinedAnswerRequest(pendingQuestion, msg.text) : void 0;
       const doorMsg = joinedAnswer !== void 0 ? { ...msg, text: joinedAnswer } : msg;
@@ -55307,7 +56030,7 @@ async function dispatch(deps, msg, io, opts = {}) {
         // other, and the fold runs on to the seed refusal below, which
         // names the unit threads to reply in.
         pageOwner.run.instanceId !== void 0 ? { kind: "live" } : { kind: "live", runId: pageOwner.run.id }
-      ) : pageOwner?.kind === "unit" ? { kind: "unit", unit: pageOwner.unit.unit } : pageOwner?.kind === "pipeline" ? { kind: "pipeline", unit: pageOwner.unit.unit } : void 0;
+      ) : pageOwner?.kind === "unit" ? { kind: "unit", unit: pageOwner.unit.unit } : pageOwner?.kind === "pipeline" ? { kind: "pipeline", unit: pageOwner.unit.unit } : pageOwner?.kind === "pipeline_ambiguous" ? { kind: "pipeline", unit: pageOwner.units.map((unit) => unit.unit).join(", ") } : void 0;
       operatorEvent = await root.span(
         "dispatch.operator",
         () => operatorStage(deps, {
@@ -55411,20 +56134,120 @@ async function dispatch(deps, msg, io, opts = {}) {
         await recordPendingOperator();
         return ended;
       }
+      if (owner.kind === "pipeline_ambiguous" && directives.agent === void 0) {
+        await io.reply(
+          `This thread matches multiple ended plan units (${owner.units.map((unit) => unit.unit).join(", ")}), so continuation is ambiguous. Nothing started.`
+        );
+        await recordPendingOperator();
+        return ended;
+      }
       if (owner.kind === "pipeline" && directives.agent === void 0) {
+        const instance = await deps.coordinatorInstances.get(owner.instanceId).catch(() => null);
+        if (instance === null) {
+          await io.reply(
+            `The ended pipeline's record \`${owner.instanceId}\` is unavailable, so continuation did not start.`
+          );
+          await recordPendingOperator();
+          return ended;
+        }
+        const actor = chatActorOf(deps.config, msg);
+        if (authorizeSteerOwner({
+          caller: { ids: actorIdsOf(actor), grants: effectiveGrants(actor) },
+          target: { runId: owner.run.id, requesterId: instance.userId }
+        }).kind === "refused") {
+          await io.reply(STEER_OWNER_REFUSED);
+          await recordPendingOperator();
+          return ended;
+        }
+        if (instance.threadKey !== msg.threadKey || instance.plan === void 0 || instance.plan.path !== void 0) {
+          await io.reply(
+            `The ended pipeline's durable generated-task identity does not match this thread, so continuation did not start.`
+          );
+          await recordPendingOperator();
+          return ended;
+        }
+        if (instance.repo !== owner.run.repo || instance.branch !== owner.unit.branch) {
+          await io.reply(
+            `The ended pipeline's repository or branch identity no longer matches unit ${owner.unit.unit}, so continuation did not start.`
+          );
+          await recordPendingOperator();
+          return ended;
+        }
+        const continuationBudget = continuationBudgetOf(instance, owner.unit);
+        if (continuationBudget.kind === "unavailable") {
+          await io.reply(
+            `Unit ${owner.unit.unit} does not retain a complete durable wall-clock and review-round budget, so continuation did not start. Nothing else ran.`
+          );
+          await recordPendingOperator();
+          return ended;
+        }
+        if (continuationBudget.kind === "exhausted") {
+          await io.reply(
+            `Unit ${owner.unit.unit} exhausted the ended pipeline's ${continuationBudget.budget} budget, so continuation did not start. Nothing else ran.`
+          );
+          await recordPendingOperator();
+          return ended;
+        }
         const original = await shipRequestOf(runsService, owner.run.id);
         if (original === void 0) {
           await io.reply(
-            "This ship pipeline ended, but its original task could not be read. What was the pipeline's original task?"
+            `The ended pipeline's original task is unavailable from run \`${owner.run.id}\`, so continuation did not start.`
           );
           await recordPendingOperator();
           return ended;
         }
-        const instance = await deps.coordinatorInstances.get(owner.instanceId).catch(() => null);
-        if (instance?.plan?.path === void 0) reissuePlanId = instance?.plan?.id;
-        directives.text = original;
+        const recordedPr = owner.unit.pr;
+        if (recordedPr === void 0) {
+          await io.reply(
+            `Unit ${owner.unit.unit} does not retain a durable pull request identity, so continuation did not start. Nothing else ran.`
+          );
+          await recordPendingOperator();
+          return ended;
+        }
+        const expectedHead = owner.unit.lastPush;
+        if (expectedHead === void 0) {
+          await io.reply(
+            `Unit ${owner.unit.unit} does not retain the pull request's durable expected head, so continuation did not start. Nothing else ran.`
+          );
+          await recordPendingOperator();
+          return ended;
+        }
+        const target = { repo: instance.repo, number: recordedPr.number };
+        const facts2 = await (deps.fetchPrFacts ?? fetchPullRequestFacts)(target).catch(() => void 0);
+        if (facts2 === void 0) {
+          await io.reply(
+            `GitHub did not return current facts for ${instance.repo}#${recordedPr.number}, so continuation did not start.`
+          );
+          await recordPendingOperator();
+          return ended;
+        }
+        if (facts2.state !== "open") {
+          await io.reply(
+            `${instance.repo}#${recordedPr.number} is closed, so this ended pipeline has no open pull request to continue. Nothing started.`
+          );
+          await recordPendingOperator();
+          return ended;
+        }
+        const verifiedHead = facts2.verifiedHead;
+        if (!facts2.sameRepoHead || facts2.headBranchExists !== true || facts2.headRef !== owner.unit.branch || verifiedHead === void 0 || verifiedHead.repo.toLowerCase() !== instance.repo.toLowerCase() || verifiedHead.ref !== owner.unit.branch || facts2.headSha !== verifiedHead.sha) {
+          await io.reply(
+            `${instance.repo}#${recordedPr.number} no longer has the pipeline's verifiable \`${owner.unit.branch}\` head, so continuation did not start.`
+          );
+          await recordPendingOperator();
+          return ended;
+        }
+        if (verifiedHead.sha !== expectedHead) {
+          await io.reply(
+            `${instance.repo}#${recordedPr.number} moved from the pipeline's expected head \`${expectedHead}\` to \`${verifiedHead.sha}\`, so continuation did not start. Nothing else ran.`
+          );
+          await recordPendingOperator();
+          return ended;
+        }
+        reissuePlanId = instance.plan.id;
+        reissueCaps = continuationBudget.caps;
+        const durableRequest = parseDirectives(original);
+        Object.assign(directives, durableRequest, { agent: void 0, budget: reissueCaps.maxMinutes });
         operatorPreset = "ship";
-        operatorRequest = original;
         settled = resolveCurrent();
         ({ sticky, resolved, agentSource } = settled);
         agentSource = "sticky";
@@ -55650,6 +56473,7 @@ async function dispatch(deps, msg, io, opts = {}) {
         card,
         directives,
         ...reissuePlanId !== void 0 ? { reissuePlanId } : {},
+        ...reissueCaps !== void 0 ? { reissueCaps: { ...reissueCaps, maxMinutes: Math.min(reissueCaps.maxMinutes, profile.minutes) } } : {},
         sticky,
         history,
         repoCtx,
@@ -55744,12 +56568,12 @@ async function dispatch(deps, msg, io, opts = {}) {
       ...operatorEvent ? { operator: operatorEvent } : {},
       ...references.conversations.length > 0 ? { references } : {}
     });
-    const { run: run2, runId: runId3, channelVisibility, liveUrl, publishText, publishMeta } = registration;
+    const { run: run2, runId: runId3, channelVisibility, liveUrl, events, publishText, publishMeta } = registration;
     registered = run2;
     for (const summary of seedNotes)
-      registry.publish(run2.id, { type: "run_note", kind: "seed", summary: oneLine(summary), at: clock4() });
+      events.publish({ type: "run_note", kind: "seed", summary: oneLine(summary), at: clock4() });
     if (opts.redispatch)
-      registry.publish(run2.id, {
+      events.publish({
         type: "run_note",
         kind: "redispatch",
         summary: `confirmed after question ${opts.redispatch.code}`,
@@ -55764,7 +56588,7 @@ async function dispatch(deps, msg, io, opts = {}) {
       threadKey: msg.threadKey,
       nextIndex: nextStagedIndex,
       preserveWorkspaceIndexes: true,
-      publish: (e) => registry.publish(runId3, e)
+      publish: (event) => events.publish(event)
     }) : void 0;
     const threadAssets = !resume && deps.artifacts && thread && thread.length > 0 ? readThreadAssets({ runs: runsService, store: deps.artifacts }, msg.threadKey).then(
       (assets) => assets.filter((a) => a.runId !== runId3)
@@ -55775,7 +56599,7 @@ async function dispatch(deps, msg, io, opts = {}) {
         {
           nextIndex: nextStagedIndex,
           messageId: messageIdOf(msg, runId3),
-          publish: (e) => registry.publish(runId3, e)
+          publish: (event) => events.publish(event)
         }
       )
     ) : void 0;
@@ -55807,7 +56631,7 @@ async function dispatch(deps, msg, io, opts = {}) {
       reserved = reservation.reserved;
       requestRow = reservation.requestRow;
       if (reservation.untrackedWhy !== void 0) {
-        registry.publish(runId3, {
+        events.publish({
           type: "run_note",
           kind: "ledger_untracked",
           summary: redactAndCap(
@@ -55821,6 +56645,100 @@ async function dispatch(deps, msg, io, opts = {}) {
         shell.note("debug", "untracked by the ledger");
       }
     }
+    if (typeof registry.commitLiveState === "function") {
+      await events.write(async () => {
+        const current = registry.getById(runId3);
+        if (current && current.liveState === void 0) {
+          const at = clock4();
+          const eventSeq = current.eventCount + 1;
+          const assignment = {
+            expectedSeq: 0,
+            eventSeq,
+            at,
+            state: "admitted",
+            bound: resume ? at + resume.plan.remainingMs : Math.max(startedAt + minutesToMs(profile.minutes), at + minutesToMs(profile.minutes)),
+            detail: "waiting to attach the workspace",
+            // A reservation is not subscribed to the registry until promotion.
+            // Commit the setup stream that already exists with admission, or
+            // advancing its ledger cursor here would make promotion skip it.
+            ...reserved ? {
+              sourceEvents: (registry.snapshotById(runId3)?.events ?? []).map((event) => ({
+                ...event,
+                seq: event.seq
+              }))
+            } : {},
+            ...(current.liveStateSeq ?? 0) > 0 ? { restart: true } : {}
+          };
+          const tracked = reserved ?? ledgerRun;
+          if (tracked?.tracked()) {
+            let committed = await tracked.assignLiveState(assignment);
+            if (!committed.ok && committed.reason === "stale-sequence" && (current.liveStateSeq ?? 0) > 0)
+              committed = await tracked.assignLiveState({
+                ...assignment,
+                expectedSeq: current.liveStateSeq ?? 0,
+                sourceEvents: void 0,
+                restart: true
+              });
+            if (!committed.ok || !registry.commitLiveState(runId3, committed))
+              throw new Error(
+                `live state admission was not committed (${committed.ok ? "registry sequence" : committed.reason})`
+              );
+          } else {
+            const expectedSeq = current.liveStateSeq ?? 0;
+            const local = assignRunLiveState(void 0, expectedSeq, { ...assignment, expectedSeq });
+            if (!local.ok || !local.event) throw new Error("live state admission was invalid");
+            registry.commitLiveState(runId3, {
+              ...local,
+              event: { ...local.event, seq: eventSeq },
+              liveStateSeq: eventSeq
+            });
+          }
+        }
+      });
+    }
+    const assignLive = async (next, at, detail) => {
+      if (typeof registry.commitLiveState !== "function") return true;
+      let accepted = false;
+      await events.write(async () => {
+        const summary = registry.getById(runId3);
+        if (!summary) return;
+        const eventSeq = summary.eventCount + 1;
+        const assignment = {
+          expectedSeq: summary.liveStateSeq ?? 0,
+          eventSeq,
+          at,
+          state: next.state,
+          bound: next.bound,
+          ...detail !== void 0 ? { detail } : {}
+        };
+        const tracked = ledgerRun ?? reserved;
+        if (tracked) {
+          const committed = await tracked.assignLiveState(assignment);
+          accepted = committed.ok && (registry.commitLiveState?.(runId3, committed) ?? true);
+          return;
+        }
+        const local = assignRunLiveState(summary.liveState, summary.liveStateSeq ?? 0, assignment);
+        if (!local.ok) return;
+        accepted = registry.commitLiveState?.(runId3, {
+          ...local,
+          ...local.event ? { event: { ...local.event, seq: eventSeq } } : {},
+          liveStateSeq: local.event ? eventSeq : summary.liveStateSeq ?? 0
+        }) ?? true;
+      });
+      return accepted;
+    };
+    let residentAttachAttempt = 0;
+    const observeResidentLiveState = async (observation) => {
+      if (observation.attempt < residentAttachAttempt) return;
+      residentAttachAttempt = observation.attempt;
+      const accepted = await assignLive(
+        { state: observation.state, bound: observation.bound },
+        clock4(),
+        liveStateWords(observation.state)
+      );
+      if (!accepted) throw new Error("resident live-state observation was stale or could not be committed");
+      shell.setSetupLabel(`${liveStateWords(observation.state)}\u2026`);
+    };
     const reattach = resume ? carriedWorkspaceBinding(resume.row) : void 0;
     const control = registered?.control;
     const attach = await attachWorkspace(deps, {
@@ -55840,7 +56758,8 @@ async function dispatch(deps, msg, io, opts = {}) {
       // during the attach ends its wake wait at once, and once the harness
       // starts the lease every attach the executor opens is clipped to the
       // run's remaining clock (execution.md item 9).
-      ...control ? { stopSignal: control.hardSignal, remainingMs: () => control.remainingMs() } : {}
+      ...control ? { stopSignal: control.hardSignal, remainingMs: () => control.remainingMs() } : {},
+      onLiveStateObservation: observeResidentLiveState
     });
     if (attach.kind === "refused") return ended;
     if (attach.kind === "stopped") {
@@ -55892,6 +56811,17 @@ async function dispatch(deps, msg, io, opts = {}) {
       return ended;
     }
     const { round: round2 } = attach;
+    if (typeof registry.commitLiveState === "function") {
+      const summary = registry.getById(runId3);
+      const bound2 = summary?.liveState?.bound ?? startedAt + minutesToMs(profile.minutes);
+      if (summary?.liveState && (summary.liveState.state === "waiting_deploy" || summary.liveState.state === "waiting_repository") && round2.selection.backend !== "resident") {
+        if (!await assignLive({ state: "falling_back", bound: bound2 }, clock4(), "switching to a fallback workspace"))
+          throw new Error("fallback live state could not be committed");
+      }
+      if (!await assignLive({ state: "preparing", bound: bound2 }, clock4(), "preparing the workspace"))
+        throw new Error("preparation live state could not be committed");
+      shell.setSetupLabel(`${liveStateWords("preparing")}\u2026`);
+    }
     if (resume && ledgerRun) {
       const rebound = workspaceBindingFor(round2.selection, profile.machine);
       if (rebound !== void 0) ledgerRun.setState({ binding: rebound });
@@ -56073,6 +57003,12 @@ async function dispatch(deps, msg, io, opts = {}) {
       markUntracked: () => shell.note("debug", "untracked by the ledger"),
       ...seedActors !== void 0 ? { seedActors } : {}
     });
+    if (typeof registry.commitLiveState === "function") {
+      const summary = registry.getById(runId3);
+      const bound2 = summary?.liveState?.bound ?? startedAt + minutesToMs(profile.minutes);
+      if (!await assignLive({ state: "working", bound: bound2 }, clock4(), "model turn"))
+        throw new Error("working live state could not be committed");
+    }
     const sessionTools = sessionCapabilityFor(
       ledgerRun,
       deps.runLedger,
@@ -56114,6 +57050,7 @@ async function dispatch(deps, msg, io, opts = {}) {
       mcpForRun,
       run: run2,
       registry,
+      events,
       round: round2,
       admitted,
       ledgerRun,
@@ -56442,6 +57379,8 @@ var init_dispatcher = __esm({
     init_registry();
     init_budgets();
     init_trace();
+    init_runLiveState();
+    init_decide();
     init_requestTrace();
     init_runShape();
     init_runEvents();
@@ -56463,6 +57402,7 @@ var init_dispatcher = __esm({
     init_route();
     init_operator();
     init_authorize2();
+    init_authorize();
     init_messages();
     init_staging();
     init_runRecord();
@@ -56481,6 +57421,7 @@ var init_dispatcher = __esm({
     init_settle();
     init_reattach2();
     init_factory();
+    init_githubPulls();
     init_sandboxErrors();
     init_lineage();
     init_seed();
@@ -56841,8 +57782,8 @@ function createLedgerWriteThrough(opts) {
         settleLanding(this.runId, entry, outcome);
         return value;
       },
-      abandoned: (record2, why) => {
-        if (record2.id !== this.runId) return;
+      abandoned: (record3, why) => {
+        if (record3.id !== this.runId) return;
         const entry = landing.get(this.runId);
         if (entry !== void 0) settleLanding(this.runId, entry, { kind: "failed", why });
       }
@@ -56852,18 +57793,18 @@ function createLedgerWriteThrough(opts) {
     async land(plain7) {
       await this.close();
       const session = this.sessionOnRecord();
-      const record2 = session ? { ...plain7, session } : plain7;
+      const record3 = session ? { ...plain7, session } : plain7;
       let result;
       try {
-        result = await ledger.finish(this.runId, gen, record2);
+        result = await ledger.finish(this.runId, gen, record3);
       } catch (err2) {
         if (!(err2 instanceof RouteMissingError)) throw err2;
         routeMissing();
-        return { value: await fallback.put(record2), outcome: { kind: "refused" } };
+        return { value: await fallback.put(record3), outcome: { kind: "refused" } };
       }
       if (result.ok) return { value: result, outcome: { kind: "landed" } };
       warn(`[ledger] ${this.threadKey} finish refused (${result.reason}) \u2014 record written to the store directly`);
-      return { value: await fallback.put(record2), outcome: { kind: "refused" } };
+      return { value: await fallback.put(record3), outcome: { kind: "refused" } };
     }
     tracked() {
       return !this.detached;
@@ -56933,7 +57874,7 @@ function createLedgerWriteThrough(opts) {
       }));
       if (report2.compaction)
         turns.push({ idx: this.rowIndex(report2.firstIdx + report2.turns.length), compaction: report2.compaction });
-      const record2 = {
+      const record3 = {
         step: ++this.stepNo,
         seq: this.lastSeq,
         turnIndex: report2.firstIdx + turns.length,
@@ -56944,10 +57885,10 @@ function createLedgerWriteThrough(opts) {
         turn: report2.turn,
         iteration: report2.iteration
       };
-      this.factRound = record2.step;
-      const kept = new Set(record2.inFlight.map((c) => c.callId));
+      this.factRound = record3.step;
+      const kept = new Set(record3.inFlight.map((c) => c.callId));
       for (const id of this.factCallStarts.keys()) if (!kept.has(id)) this.factCallStarts.delete(id);
-      const call2 = record2.inFlight[0];
+      const call2 = record3.inFlight[0];
       this.factInFlight = call2 ? {
         callId: call2.callId,
         tool: call2.tool,
@@ -56959,13 +57900,13 @@ function createLedgerWriteThrough(opts) {
       } : void 0;
       for (let attempt = 1; ; attempt++) {
         try {
-          const result = await ledger.step(this.runId, gen, record2, turns, this.sessionRow?.key);
-          if (!result.ok) this.detach(`step ${record2.step} refused (${result.reason})`);
-          else this.turnsWritten = record2.turnIndex;
+          const result = await ledger.step(this.runId, gen, record3, turns, this.sessionRow?.key);
+          if (!result.ok) this.detach(`step ${record3.step} refused (${result.reason})`);
+          else this.turnsWritten = record3.turnIndex;
           return;
         } catch (err2) {
           if (err2 instanceof RouteMissingError || err2 instanceof PermanentStoreError || attempt >= 2) {
-            this.detach(`step ${record2.step} failed: ${describe9(err2)}`);
+            this.detach(`step ${record3.step} failed: ${describe9(err2)}`);
             return;
           }
           await sleep2(RETRY_MS[0]);
@@ -56973,7 +57914,7 @@ function createLedgerWriteThrough(opts) {
       }
     }
     event(event, seq) {
-      if (this.detached || this.finished) return;
+      if (this.detached || this.finished || seq <= this.lastSeq) return;
       this.lastSeq = seq;
       const e = event;
       if (typeof e.at === "number") this.factLastEventAt = e.at;
@@ -56994,6 +57935,30 @@ function createLedgerWriteThrough(opts) {
         };
       this.flusher.push({ ...event, seq });
     }
+    async assignLiveState(assignment) {
+      if (this.detached || this.finished) return { ok: false, reason: "unknown-run" };
+      await this.flusher.flush();
+      await this.stateSending;
+      try {
+        const result = await ledger.assignLiveState(this.runId, gen, assignment);
+        if (!result.ok) {
+          if (result.reason === "fenced" || result.reason === "unknown-run")
+            this.detach(`live state refused (${result.reason})`);
+          return result;
+        }
+        this.state = {
+          ...this.state,
+          ...assignment.statePatch,
+          liveState: result.liveState,
+          liveStateSeq: result.liveStateSeq
+        };
+        this.lastSeq = Math.max(this.lastSeq, result.liveStateSeq);
+        return result;
+      } catch (err2) {
+        warn(`[ledger] ${this.threadKey} live state not written: ${describe9(err2)}`);
+        return { ok: false, reason: "unknown-run" };
+      }
+    }
     setState(patch) {
       if (this.detached) return;
       this.state = { ...this.state, ...patch };
@@ -57378,6 +58343,9 @@ var init_writeThrough = __esm({
       }
       event(_event, _seq) {
       }
+      async assignLiveState(_assignment) {
+        return { ok: false, reason: "unknown-run" };
+      }
       setState(_patch) {
       }
       async finishing() {
@@ -58766,8 +59734,8 @@ async function launchOpenCode(deps, spec, bearer) {
     let consumed = 0;
     for (const line4 of text.split("\n").slice(0, -1)) {
       consumed += Buffer.byteLength(line4, "utf8") + 1;
-      const record2 = parseFeedRecord(line4);
-      if (record2?.feed === "tailer" && record2.note === "connected") {
+      const record3 = parseFeedRecord(line4);
+      if (record3?.feed === "tailer" && record3.note === "connected") {
         feedOffset = consumed;
         break;
       }
@@ -58847,9 +59815,9 @@ var init_process2 = __esm({
 });
 
 // ../../src/core/harness/opencode/bridge.ts
-function executionStartedFor(record2, sessionID) {
-  if (record2.feed !== "event" || record2.event.type !== "session.execution.started") return false;
-  const data = record2.event.data;
+function executionStartedFor(record3, sessionID) {
+  if (record3.feed !== "event" || record3.event.type !== "session.execution.started") return false;
+  const data = record3.event.data;
   return data?.sessionID === sessionID;
 }
 function openCodeToolNameWord(name) {
@@ -59521,18 +60489,18 @@ async function driveOpenCode(deps, run2, conn, kind = "loop") {
       const after = transport.consumedOffset;
       const reattachCatchUp = conn.reattach !== void 0 && after <= conn.reattach.catchUpTo;
       lastRecord = next.value;
-      const record2 = parseFeedRecord(next.value);
-      if (!record2) continue;
-      if (!reattachCatchUp && executionStartedFor(record2, conn.sessionID)) {
+      const record3 = parseFeedRecord(next.value);
+      if (!record3) continue;
+      if (!reattachCatchUp && executionStartedFor(record3, conn.sessionID)) {
         executionOwned = true;
         awaiting = void 0;
       }
       bridge.observing = reattachCatchUp ? "catching-up" : executionOwned ? "own" : "earlier";
-      const obs = bridge.observe(record2);
+      const obs = bridge.observe(record3);
       if (!reattachCatchUp && obs.boundary === true) conn.boundaries?.reached();
       if (!reattachCatchUp && obs.inboxDelivered !== void 0) conn.inboxFate?.deliver(obs.inboxDelivered);
       if (!reattachCatchUp && obs.inboxDropped === true) conn.inboxFate?.interruptAll();
-      if (record2.feed === "messages" && conn.saveOffset !== void 0) {
+      if (record3.feed === "messages" && conn.saveOffset !== void 0) {
         const save = conn.saveOffset;
         void bridge.flush().then(() => save(after));
       }
@@ -59619,14 +60587,14 @@ async function driveOpenCode(deps, run2, conn, kind = "loop") {
     );
   }
   if (replacedBy !== void 0) {
-    const record2 = bridge.record(recordBase, deadline);
+    const record3 = bridge.record(recordBase, deadline);
     bridge.closeOpenSpans((open2) => openCodeReplacedCallNote(open2.tool));
     const replaced = replacedBy.condition === "word" ? new OpenCodeContainerReplacedError(
       replacedBy.said.message,
       conn.containerWord,
       await conn.container.identity().catch(() => void 0),
-      record2
-    ) : new OpenCodeContainerReplacedError(void 0, replacedBy.was, replacedBy.now, record2, "identity");
+      record3
+    ) : new OpenCodeContainerReplacedError(void 0, replacedBy.was, replacedBy.now, record3, "identity");
     note("sandbox_restarted", replaced.message);
     throw replaced;
   }
@@ -59766,13 +60734,13 @@ var init_bridge3 = __esm({
       diagnostics;
     };
     OpenCodeContainerReplacedError = class extends HarnessContainerReplacedError {
-      constructor(said2, was, now, record2, condition = "word") {
+      constructor(said2, was, now, record3, condition = "word") {
         super(
           `the container running OpenCode was replaced (${was ?? "unknown"} \u2192 ${now ?? "unknown"}; ${replacedBecause(condition, said2)})`,
           said2,
           was,
           now,
-          record2,
+          record3,
           condition
         );
         this.name = "OpenCodeContainerReplacedError";
@@ -60221,25 +61189,25 @@ var init_bridge3 = __esm({
       emit(event) {
         this.deps.emit(event.at === void 0 ? { ...event, at: this.deps.clock() } : event);
       }
-      observe(record2) {
-        switch (record2.feed) {
+      observe(record3) {
+        switch (record3.feed) {
           case "event":
-            return this.onEvent(record2.event);
+            return this.onEvent(record3.event);
           case "permissions":
             if (this.observing === "earlier") return { replies: [], settled: false };
-            return this.onPermissionsRefill(record2.data);
+            return this.onPermissionsRefill(record3.data);
           case "messages": {
-            const out = this.onMessagesRefill(record2.data);
-            if (this.settleOwedTo !== void 0 && record2.reason === this.settleOwedTo) {
+            const out = this.onMessagesRefill(record3.data);
+            if (this.settleOwedTo !== void 0 && record3.reason === this.settleOwedTo) {
               this.settleOwedTo = void 0;
               out.settled = true;
             }
             return out;
           }
           case "tailer":
-            if (record2.note === "stream closed" || record2.note.includes("failed"))
-              this.deps.onProgress?.(`opencode feed: ${redactAndCap(record2.note, 120)}`);
-            if (this.settleOwedTo !== void 0 && (record2.note === "message refill failed" || record2.note === "refill failed") && record2.reason === this.settleOwedTo) {
+            if (record3.note === "stream closed" || record3.note.includes("failed"))
+              this.deps.onProgress?.(`opencode feed: ${redactAndCap(record3.note, 120)}`);
+            if (this.settleOwedTo !== void 0 && (record3.note === "message refill failed" || record3.note === "refill failed") && record3.reason === this.settleOwedTo) {
               this.settleOwedTo = void 0;
               return { replies: [], settled: true };
             }
@@ -61199,7 +62167,7 @@ ${stagedLine}` : prompt;
             return "lost";
           return "running";
         };
-        const resolve13 = async (steerSeq, knownAtSteer, seen, waiting2) => {
+        const resolve13 = async (steerSeq, knownAtSteer, seen, waiting3) => {
           let left = false;
           for (; ; ) {
             const verdict = await learnRow(steerSeq, knownAtSteer);
@@ -61214,7 +62182,7 @@ ${stagedLine}` : prompt;
                 "the follow-up's steer",
                 "the loop left the feed with no row of the steer and the store still showing its execution under way, so the store cannot say whether the server took it"
               );
-            waiting2();
+            waiting3();
             if (await conn.boundaries.wait(seen) === "left") left = true;
             seen = conn.boundaries.count;
           }
@@ -61526,6 +62494,14 @@ var init_requester = __esm({
 
 // ../../src/channels/http.ts
 import { timingSafeEqual as timingSafeEqual4 } from "node:crypto";
+function ingressComponentError(name, value) {
+  if (value.length === 0) return `\`${name}\` must be a non-empty string`;
+  if (value.length > INGRESS_COMPONENT_MAX_LENGTH) {
+    return `\`${name}\` must be at most ${INGRESS_COMPONENT_MAX_LENGTH} characters`;
+  }
+  if (/[:#]/.test(value)) return `\`${name}\` must not contain ':' or '#'`;
+  return void 0;
+}
 function safeEqual2(a, b) {
   const ab = Buffer.from(a, "utf8");
   const bb = Buffer.from(b, "utf8");
@@ -61569,11 +62545,15 @@ function parseBody3(raw) {
   if (typeof obj2.text !== "string" || obj2.text.trim() === "") {
     return { error: "`text` is required and must be a non-empty string" };
   }
-  if (obj2.channel !== void 0 && typeof obj2.channel !== "string") {
-    return { error: "`channel` must be a string" };
+  if (obj2.channel !== void 0) {
+    if (typeof obj2.channel !== "string") return { error: "`channel` must be a string" };
+    const error = ingressComponentError("channel", obj2.channel);
+    if (error) return { error };
   }
-  if (obj2.thread !== void 0 && typeof obj2.thread !== "string") {
-    return { error: "`thread` must be a string" };
+  if (obj2.thread !== void 0) {
+    if (typeof obj2.thread !== "string") return { error: "`thread` must be a string" };
+    const error = ingressComponentError("thread", obj2.thread);
+    if (error) return { error };
   }
   if (obj2.async !== void 0 && typeof obj2.async !== "boolean") {
     return { error: "`async` must be a boolean" };
@@ -61626,6 +62606,10 @@ async function handleAuthorized(identity2, body, deps, options) {
   if ("error" in parsed) {
     return { status: 400, body: { error: parsed.error } };
   }
+  if (identity2.channel !== void 0) {
+    const error = ingressComponentError("channel", identity2.channel);
+    if (error) return { status: 400, body: { error } };
+  }
   const receivedAt = systemClock();
   const trace = startRequestRoot(deps, { channel: "http", receivedAt });
   const msg = {
@@ -61706,7 +62690,7 @@ function parseIngressTokens(secrets) {
   if (!parsed.ok) console.error(`[ingress] SWITCHBOARD_INGRESS_TOKENS is ${parsed.reason} \u2014 ingress disabled`);
   return { tokens: parsed.tokens };
 }
-var PLATFORM, DEFAULT_CHANNEL, DEFAULT_THREAD, MAX_BODY_BYTES2, HttpIO, DISPATCH_ACTION;
+var PLATFORM, DEFAULT_CHANNEL, DEFAULT_THREAD, INGRESS_COMPONENT_MAX_LENGTH, MAX_BODY_BYTES2, HttpIO, DISPATCH_ACTION;
 var init_http = __esm({
   "../../src/channels/http.ts"() {
     "use strict";
@@ -61719,6 +62703,7 @@ var init_http = __esm({
     PLATFORM = "http";
     DEFAULT_CHANNEL = "default";
     DEFAULT_THREAD = "default";
+    INGRESS_COMPONENT_MAX_LENGTH = 128;
     MAX_BODY_BYTES2 = 1e6;
     HttpIO = class {
       constructor(priorTurns = []) {
@@ -61915,7 +62900,7 @@ function openAiStopReason(raw) {
   }
 }
 function meterAnthropicMessage(json4) {
-  const msg = record(json4);
+  const msg = record2(json4);
   if (!msg) return {};
   const usage = usageFromAnthropic(msg.usage);
   return {
@@ -61924,11 +62909,11 @@ function meterAnthropicMessage(json4) {
   };
 }
 function meterOpenAiCompletion(json4) {
-  const body = record(json4);
+  const body = record2(json4);
   if (!body) return {};
   const usage = usageFromOpenAI(body.usage);
   const reported = reportedCostOf(body.usage);
-  const choice = Array.isArray(body.choices) ? record(body.choices[0]) : void 0;
+  const choice = Array.isArray(body.choices) ? record2(body.choices[0]) : void 0;
   return {
     ...usage ? { usage } : {},
     ...reported ? { reported } : {},
@@ -61938,15 +62923,15 @@ function meterOpenAiCompletion(json4) {
 function responsesStopReason(response) {
   const output = Array.isArray(response.output) ? response.output : [];
   if (response.status === "completed") {
-    return output.some((item) => record(item)?.type === "function_call") ? "tool_use" : "end_turn";
+    return output.some((item) => record2(item)?.type === "function_call") ? "tool_use" : "end_turn";
   }
   if (response.status === "incomplete") {
-    return record(response.incomplete_details)?.reason === "max_output_tokens" ? "max_tokens" : "other";
+    return record2(response.incomplete_details)?.reason === "max_output_tokens" ? "max_tokens" : "other";
   }
   return "other";
 }
 function meterResponses(json4) {
-  const body = record(json4);
+  const body = record2(json4);
   if (!body) return {};
   const usage = usageFromResponses(body.usage);
   const reported = reportedCostOf(body.usage);
@@ -61968,87 +62953,20 @@ function shapeTools(shape, body, marks) {
   const allowed2 = new Set(marks.turn.tools);
   const table = Array.isArray(body.tools) ? body.tools : [];
   const kept = table.filter((t) => {
-    const name = toolNameOf(shape, record(t));
+    const name = toolNameOf(shape, record2(t));
     return typeof name === "string" && allowed2.has(name);
   });
   const { tool_choice: _choice, ...rest } = body;
   const shaped = { ...rest, tools: kept };
   return { body: shaped, toolChoice: toolChoiceWord(shape, void 0, kept.length) };
 }
-function responsesRejectsPattern(pattern) {
-  return /\(\?(?:[=!]|<[=!])/.test(pattern);
-}
-function shapeResponsesSchema(value, tool, degradations) {
-  const schema = record(value);
-  if (!schema) {
-    if (!Array.isArray(value)) return { value, changed: false };
-    let changed2 = false;
-    const items = value.map((item) => {
-      const shaped = shapeResponsesSchema(item, tool, degradations);
-      changed2 ||= shaped.changed;
-      return shaped.value;
-    });
-    return { value: changed2 ? items : value, changed: changed2 };
-  }
-  let changed = false;
-  const out = {};
-  for (const [keyword, item] of Object.entries(schema)) {
-    if (keyword === "pattern" && typeof item === "string" && responsesRejectsPattern(item)) {
-      degradations.push({
-        tool,
-        keyword,
-        why: "the Responses wire does not accept regular-expression lookaround"
-      });
-      changed = true;
-      continue;
-    }
-    if ((keyword === "properties" || keyword === "$defs" || keyword === "definitions") && record(item)) {
-      let mapChanged = false;
-      const mapped = {};
-      for (const [name, child] of Object.entries(record(item))) {
-        const shaped = shapeResponsesSchema(child, tool, degradations);
-        mapChanged ||= shaped.changed;
-        mapped[name] = shaped.value;
-      }
-      out[keyword] = mapChanged ? mapped : item;
-      changed ||= mapChanged;
-      continue;
-    }
-    if (["additionalProperties", "allOf", "anyOf", "if", "items", "not", "oneOf", "then", "else"].includes(keyword) && typeof item === "object" && item !== null) {
-      const shaped = shapeResponsesSchema(item, tool, degradations);
-      out[keyword] = shaped.value;
-      changed ||= shaped.changed;
-      continue;
-    }
-    out[keyword] = item;
-  }
-  return { value: changed ? out : value, changed };
-}
-function shapeToolSchemasForWire(shape, body) {
-  if (shape !== "openai-responses" || !Array.isArray(body.tools)) return { body, degradations: [] };
-  const degradations = [];
-  let changed = false;
-  const tools = body.tools.map((item) => {
-    const tool = record(item);
-    if (!tool) return item;
-    const name = typeof tool.name === "string" ? tool.name : "unnamed";
-    const shaped = shapeResponsesSchema(tool.parameters, name, degradations);
-    if (!shaped.changed) return item;
-    changed = true;
-    return { ...tool, parameters: shaped.value };
-  });
-  const unique = degradations.filter(
-    (candidate, index, all) => all.findIndex((other) => other.tool === candidate.tool && other.keyword === candidate.keyword) === index
-  );
-  return { body: changed ? { ...body, tools } : body, degradations: unique };
-}
 function toolNameOf(shape, tool) {
   if (tool === void 0) return void 0;
-  return shape === "openai-chat" ? record(tool.function)?.name : tool.name;
+  return shape === "openai-chat" ? record2(tool.function)?.name : tool.name;
 }
 function toolSchemaOf(shape, tool) {
   if (shape === "anthropic-messages") return tool.input_schema;
-  if (shape === "openai-chat") return record(tool.function)?.parameters;
+  if (shape === "openai-chat") return record2(tool.function)?.parameters;
   return tool.parameters;
 }
 function schemaKeywords(value, into = /* @__PURE__ */ new Set()) {
@@ -62056,12 +62974,12 @@ function schemaKeywords(value, into = /* @__PURE__ */ new Set()) {
     for (const item of value) schemaKeywords(item, into);
     return into;
   }
-  const schema = record(value);
+  const schema = record2(value);
   if (!schema) return into;
   for (const [keyword, item] of Object.entries(schema)) {
     into.add(keyword);
-    if ((keyword === "properties" || keyword === "$defs" || keyword === "definitions") && record(item)) {
-      for (const child of Object.values(record(item))) schemaKeywords(child, into);
+    if ((keyword === "properties" || keyword === "$defs" || keyword === "definitions") && record2(item)) {
+      for (const child of Object.values(record2(item))) schemaKeywords(child, into);
     } else {
       schemaKeywords(item, into);
     }
@@ -62072,7 +62990,7 @@ function providerErrorProse(body) {
   const strings2 = (value, into = []) => {
     if (typeof value === "string") into.push(value);
     else if (Array.isArray(value)) for (const item of value) strings2(item, into);
-    else if (record(value)) for (const item of Object.values(record(value))) strings2(item, into);
+    else if (record2(value)) for (const item of Object.values(record2(value))) strings2(item, into);
     return into;
   };
   try {
@@ -62090,7 +63008,7 @@ function providerSchemaRejectionOf2(shape, body, errorBody) {
     prose2
   ))
     return void 0;
-  const candidates2 = (Array.isArray(body.tools) ? body.tools : []).map((item) => record(item)).filter((item) => item !== void 0).map((tool) => ({ name: toolNameOf(shape, tool), schema: toolSchemaOf(shape, tool) })).filter(
+  const candidates2 = (Array.isArray(body.tools) ? body.tools : []).map((item) => record2(item)).filter((item) => item !== void 0).map((tool) => ({ name: toolNameOf(shape, tool), schema: toolSchemaOf(shape, tool) })).filter(
     (tool) => typeof tool.name === "string" && quoted(prose2, tool.name)
   );
   if (candidates2.length !== 1) return void 0;
@@ -62113,7 +63031,7 @@ function toolsOffered(shape, body) {
   const table = Array.isArray(body.tools) ? body.tools : [];
   const names = [];
   for (const t of table) {
-    const name = toolNameOf(shape, record(t));
+    const name = toolNameOf(shape, record2(t));
     if (typeof name === "string") names.push(name);
   }
   names.sort();
@@ -62126,7 +63044,7 @@ function toolsOffered(shape, body) {
 function toolChoiceWord(shape, choice, tools) {
   if (choice === void 0 || choice === null) return tools > 0 ? "auto" : "none";
   if (shape === "anthropic-messages") {
-    const type = record(choice)?.type;
+    const type = record2(choice)?.type;
     if (type === "none" || type === "any" || type === "tool") return type;
     if (type === "auto") return tools > 0 ? "auto" : "none";
     return tools > 0 ? "auto" : "none";
@@ -62134,7 +63052,7 @@ function toolChoiceWord(shape, choice, tools) {
   if (choice === "none") return "none";
   if (choice === "required") return "any";
   if (choice === "auto") return tools > 0 ? "auto" : "none";
-  return record(choice) ? "tool" : tools > 0 ? "auto" : "none";
+  return record2(choice) ? "tool" : tools > 0 ? "auto" : "none";
 }
 function turnAttrs(grant2, meter, ttftMs, offered, price) {
   const u = meter.usage;
@@ -62243,7 +63161,7 @@ async function handleAdmitted(door, req, deps) {
   } catch {
     return refusalResponse(shape, 400, "invalid_body", "the body is not JSON");
   }
-  const body = record(parsed);
+  const body = record2(parsed);
   if (!body) return refusalResponse(shape, 400, "invalid_body", "the body must be a JSON object");
   const upstream = upstreamFor(
     shape,
@@ -62514,7 +63432,7 @@ function createModelProxyHandler(deps) {
     })();
   };
 }
-var ANTHROPIC_MESSAGES_PATH, OPENAI_CHAT_COMPLETIONS_PATH, OPENAI_RESPONSES_PATH, PROXY_PATHS, RESPONSES_MIN_OUTPUT_TOKENS, MAX_PROXY_BODY_BYTES, DEFAULT_ANTHROPIC_BASE_URL, DEFAULT_ANTHROPIC_VERSION, FORWARDED_REQUEST_HEADERS, FORWARDED_RESPONSE_HEADERS, record, SseMeter, MODEL_STREAM_HEARTBEAT;
+var ANTHROPIC_MESSAGES_PATH, OPENAI_CHAT_COMPLETIONS_PATH, OPENAI_RESPONSES_PATH, PROXY_PATHS, RESPONSES_MIN_OUTPUT_TOKENS, MAX_PROXY_BODY_BYTES, DEFAULT_ANTHROPIC_BASE_URL, DEFAULT_ANTHROPIC_VERSION, FORWARDED_REQUEST_HEADERS, FORWARDED_RESPONSE_HEADERS, record2, SseMeter, MODEL_STREAM_HEARTBEAT;
 var init_modelProxy = __esm({
   "../../src/channels/modelProxy.ts"() {
     "use strict";
@@ -62522,6 +63440,7 @@ var init_modelProxy = __esm({
     init_providerFailureAuth();
     init_usage();
     init_modelPricing();
+    init_providerToolSchemas();
     init_provider();
     init_http();
     ANTHROPIC_MESSAGES_PATH = "/v1/messages";
@@ -62538,7 +63457,7 @@ var init_modelProxy = __esm({
     DEFAULT_ANTHROPIC_VERSION = "2023-06-01";
     FORWARDED_REQUEST_HEADERS = ["accept", "anthropic-version", "anthropic-beta"];
     FORWARDED_RESPONSE_HEADERS = ["content-type", "request-id", "x-request-id"];
-    record = (v) => typeof v === "object" && v !== null && !Array.isArray(v) ? v : void 0;
+    record2 = (v) => typeof v === "object" && v !== null && !Array.isArray(v) ? v : void 0;
     SseMeter = class {
       constructor(shape) {
         this.shape = shape;
@@ -62582,7 +63501,7 @@ var init_modelProxy = __esm({
         };
       }
       apply(json4) {
-        const event = record(json4);
+        const event = record2(json4);
         if (!event) return;
         if (this.shape === "openai-responses") {
           if (event.type !== "response.completed" && event.type !== "response.incomplete" && event.type !== "response.failed")
@@ -62595,12 +63514,12 @@ var init_modelProxy = __esm({
         }
         if (this.shape === "anthropic-messages") {
           if (event.type === "message_start") {
-            const usage2 = usageFromAnthropic(record(event.message)?.usage);
+            const usage2 = usageFromAnthropic(record2(event.message)?.usage);
             if (usage2) this.usage = { ...this.usage, ...usage2 };
           } else if (event.type === "message_delta") {
-            const stop = record(event.delta)?.stop_reason;
+            const stop = record2(event.delta)?.stop_reason;
             if (typeof stop === "string") this.stopReason = anthropicStopReason(stop);
-            const usage2 = record(event.usage);
+            const usage2 = record2(event.usage);
             if (usage2) {
               if (typeof usage2.output_tokens === "number") this.usage.outputTokens = usage2.output_tokens;
               if (typeof usage2.input_tokens === "number") this.usage.inputTokens = usage2.input_tokens;
@@ -62613,7 +63532,7 @@ var init_modelProxy = __esm({
           }
           return;
         }
-        const choice = Array.isArray(event.choices) ? record(event.choices[0]) : void 0;
+        const choice = Array.isArray(event.choices) ? record2(event.choices[0]) : void 0;
         if (typeof choice?.finish_reason === "string") this.stopReason = openAiStopReason(choice.finish_reason);
         const usage = usageFromOpenAI(event.usage);
         if (usage) this.usage = { ...this.usage, ...usage };
@@ -62635,7 +63554,7 @@ function bearerOf(headers) {
   const m = value ? /^Bearer\s+(\S+)$/i.exec(value.trim()) : null;
   return m ? m[1] : void 0;
 }
-function judge3(deps, presented) {
+function judge4(deps, presented) {
   const verdict = deps.bearers.verify(presented);
   if (!verdict.ok) {
     const status3 = verdict.reason === "unknown_run" ? 404 : verdict.reason === "malformed" ? 401 : verdict.reason === "unknown_bearer" ? 401 : 403;
@@ -62657,12 +63576,12 @@ function held(path, reason2, runId3) {
 async function admitHarnessRequest(deps, headers, path) {
   const presented = bearerOf(headers);
   if (!presented) return { ok: false, response: { status: 401, body: { error: "missing_bearer" } } };
-  let verdict = judge3(deps, presented);
+  let verdict = judge4(deps, presented);
   if (verdict.ok) return verdict;
   if (!RESUME_CAN_OPEN.has(verdict.reason)) return refused6(verdict);
   if (!deps.takeover.settled) {
     await deps.takeover.whenSettled(DOOR_HOLD_MS);
-    verdict = judge3(deps, presented);
+    verdict = judge4(deps, presented);
     if (verdict.ok) return verdict;
     if (!RESUME_CAN_OPEN.has(verdict.reason)) return refused6(verdict);
     if (!deps.takeover.settled) return held(path, "reclaim_pending", verdict.runId);
@@ -63998,13 +64917,13 @@ async function catchUpMissedMentions(opts) {
   const orphanCutoffMs = now - (opts.orphanWindowMs ?? ORPHAN_CARD_WINDOW_MS);
   const threadCutoffMs = sweep ? Math.min(cutoffMs, orphanCutoffMs) : cutoffMs;
   const { client, botUserId } = opts;
-  const record2 = opts.record ?? recordCatchUpOutcome;
+  const record3 = opts.record ?? recordCatchUpOutcome;
   let channels;
   try {
     channels = await listChannels(client);
   } catch (err2) {
     log(`[catch-up] cannot list channels: ${errMsg(err2)}`);
-    record2({ at: now, channels: 0, missed: 0, skippedChannels: 0, error: errMsg(err2) });
+    record3({ at: now, channels: 0, missed: 0, skippedChannels: 0, error: errMsg(err2) });
     return { channels: 0, missed: 0, orphans: 0, skippedChannels: 0 };
   }
   const scans = await mapLimit(channels, CATCH_UP_CHANNEL_CONCURRENCY, async (channel) => {
@@ -64073,7 +64992,7 @@ async function catchUpMissedMentions(opts) {
   log(
     `[catch-up] scanned ${channels.length} channel(s): ${missed} missed message(s), ${orphans} orphaned card(s), ${skippedChannels} skipped`
   );
-  record2({ at: now, channels: channels.length, missed, skippedChannels });
+  record3({ at: now, channels: channels.length, missed, skippedChannels });
   return { channels: channels.length, missed, orphans, skippedChannels };
 }
 async function listChannels(client) {
@@ -65961,11 +66880,19 @@ ${JSON.stringify(result.value)}` }] });
       if (typeof args.text !== "string" || args.text.trim() === "") {
         return err(id, INVALID_PARAMS, "`text` is required and must be a non-empty string");
       }
-      if (args.channel !== void 0 && typeof args.channel !== "string") {
-        return err(id, INVALID_PARAMS, "`channel` must be a string");
+      if (args.channel !== void 0) {
+        if (typeof args.channel !== "string") return err(id, INVALID_PARAMS, "`channel` must be a string");
+        const error = ingressComponentError("channel", args.channel);
+        if (error) return err(id, INVALID_PARAMS, error);
+      }
+      if (args.thread !== void 0) {
+        if (typeof args.thread !== "string") return err(id, INVALID_PARAMS, "`thread` must be a string");
+        const error = ingressComponentError("thread", args.thread);
+        if (error) return err(id, INVALID_PARAMS, error);
       }
-      if (args.thread !== void 0 && typeof args.thread !== "string") {
-        return err(id, INVALID_PARAMS, "`thread` must be a string");
+      if (identity2.channel !== void 0) {
+        const error = ingressComponentError("channel", identity2.channel);
+        if (error) return err(id, INVALID_PARAMS, error);
       }
       const receivedAt = systemClock();
       const trace = startRequestRoot(deps, { channel: "mcp", receivedAt });
@@ -67601,16 +68528,16 @@ function residentStateTone(state) {
 }
 function residentsFleetTone(records) {
   if (records.length === 0) return "grey";
-  const tones = new Set(records.map((record2) => residentStateTone(residentLive(rec(record2)).state)));
+  const tones = new Set(records.map((record3) => residentStateTone(residentLive(rec(record3)).state)));
   if (tones.has("red")) return "red";
   if (tones.has("amber")) return "amber";
   return tones.size === 1 && tones.has("green") ? "green" : "grey";
 }
-function residentSlug(record2) {
-  return str8(record2.resource).replace(/^repo:/, "");
+function residentSlug(record3) {
+  return str8(record3.resource).replace(/^repo:/, "");
 }
-function residentLive(record2) {
-  const live = rec(record2.live);
+function residentLive(record3) {
+  const live = rec(record3.live);
   if (typeof live.error === "string") return { ...live, state: "unreachable", reason: live.error };
   return { ...live, state: str8(live.state) || "unknown", reason: str8(live.reason) };
 }
@@ -67910,12 +68837,12 @@ function createResidentsViewHandler(deps) {
         finish2(200);
         return;
       }
-      const record2 = listing.residents.find((x) => residentSlug(x) === route2.slug);
-      if (!record2) {
+      const record3 = listing.residents.find((x) => residentSlug(x) === route2.slug);
+      if (!record3) {
         plainEnd(404, `${route2.slug} is not onboarded as a resident`);
         return;
       }
-      page2(req, res, 200, ctx.actor, route2.slug, { page: "resident", slug: route2.slug, record: record2 });
+      page2(req, res, 200, ctx.actor, route2.slug, { page: "resident", slug: route2.slug, record: record3 });
       finish2(200);
     });
     return true;
@@ -70057,9 +70984,9 @@ function startReclaimSweep(opts) {
   return { stop: () => stop(timer) };
 }
 async function closeReclaimed(ledger, gen, input) {
-  const record2 = reclaimedRunRecord(input);
-  const result = await ledger.finish(input.row.runId, gen, record2);
-  return result.ok ? { ok: true, record: record2 } : { ok: false, reason: result.reason ?? "refused" };
+  const record3 = reclaimedRunRecord(input);
+  const result = await ledger.finish(input.row.runId, gen, record3);
+  return result.ok ? { ok: true, record: record3 } : { ok: false, reason: result.reason ?? "refused" };
 }
 async function completenessVerdict(ledger, row2, lastStep) {
   if (!lastStep) return { resumable: false, why: "no step record: killed before its conversation was stored" };
@@ -70226,7 +71153,13 @@ async function launchResumes(deps, resumable, opts) {
       const handle2 = registry.create(row2.meta.label, rehostMeta(row2), {
         id: row2.runId,
         startedAt: row2.startedAt,
-        replay: run2.events
+        replay: run2.events,
+        ...row2.liveState !== void 0 ? {
+          liveState: {
+            liveState: row2.liveState,
+            ...row2.liveStateSeq !== void 0 ? { liveStateSeq: row2.liveStateSeq } : {}
+          }
+        } : {}
       });
       const adopted = deps.runLedger.adopt({
         runId: row2.runId,
@@ -70667,6 +71600,72 @@ var init_adminModelProxy = __esm({
   }
 });
 
+// ../../src/core/providerLiveStateCoordinator.ts
+function createProviderLiveStateCoordinator(deps) {
+  let tail = Promise.resolve();
+  const enqueue = (label, work) => {
+    const next = tail.then(work).catch((error) => {
+      deps.warn(`${label} failed: ${describe11(error)}`);
+    });
+    tail = next;
+    return next;
+  };
+  return {
+    level: (provider, side, cause) => enqueue(`provider ${side} report for ${provider}`, async () => {
+      await deps.runLedger.planeLevel({
+        provider,
+        name: "provider",
+        side,
+        ...side === "down" && cause !== void 0 ? { cause } : {}
+      });
+      if (side !== "up" || !deps.ledger) return;
+      const rows = await deps.ledger.listLive();
+      for (const row2 of rows) {
+        if (row2.state.liveProvider !== provider || row2.liveState?.state !== "waiting_provider") continue;
+        const tracked = deps.runLedger.liveRuns().find((run2) => run2.runId === row2.runId);
+        const summary = deps.registry.getById(row2.runId);
+        if (!tracked || !summary || row2.liveState.bound === void 0) continue;
+        const committed = await tracked.assignLiveState({
+          expectedSeq: summary.liveStateSeq ?? 0,
+          eventSeq: summary.eventCount + 1,
+          at: deps.clock(),
+          state: "working",
+          bound: row2.liveState.bound,
+          detail: "model turn",
+          statePatch: { liveProvider: void 0 }
+        });
+        if (committed.ok) deps.registry.commitLiveState(row2.runId, committed);
+      }
+    }),
+    park: (runId3, provider) => enqueue(`provider park for ${runId3}`, async () => {
+      await deps.runLedger.planePark(runId3, provider);
+      const summary = deps.registry.getById(runId3);
+      const tracked = deps.runLedger.liveRuns().find((run2) => run2.runId === runId3);
+      const events = deps.registry.snapshotById(runId3)?.events ?? [];
+      let leaseEndsAt;
+      for (const event of events) if (event.type === "lease") leaseEndsAt = event.endsAt;
+      if (!summary || !tracked || leaseEndsAt === void 0) return;
+      const committed = await tracked.assignLiveState({
+        expectedSeq: summary.liveStateSeq ?? 0,
+        eventSeq: summary.eventCount + 1,
+        at: deps.clock(),
+        state: "waiting_provider",
+        bound: leaseEndsAt,
+        detail: "waiting for the model provider",
+        statePatch: { liveProvider: provider }
+      });
+      if (committed.ok) deps.registry.commitLiveState(runId3, committed);
+    })
+  };
+}
+var describe11;
+var init_providerLiveStateCoordinator = __esm({
+  "../../src/core/providerLiveStateCoordinator.ts"() {
+    "use strict";
+    describe11 = (error) => error instanceof Error ? error.message : String(error);
+  }
+});
+
 // ../../src/channels/adminTraceLog.ts
 function parseTraceLogQuery(search) {
   const query = {};
@@ -71176,7 +72175,7 @@ async function openThreadFromRequester(deps, instance, lead, at) {
       }
     };
   } catch (err2) {
-    return { ok: false, response: json3(502, { ok: false, error: "thread_failed", message: describe11(err2), at }) };
+    return { ok: false, response: json3(502, { ok: false, error: "thread_failed", message: describe12(err2), at }) };
   }
 }
 function authorizeStep(headers, step, deps) {
@@ -71300,8 +72299,8 @@ async function spawn6(body, deps) {
     try {
       turn = await composeChild(req.brief, instance, row2, briefReaders(deps, instance));
     } catch (err2) {
-      log(`[coordinator] ${instance.id} ${req.step}: the brief could not be composed: ${describe11(err2)}`);
-      return json3(502, { ok: false, error: "brief_failed", message: describe11(err2), at });
+      log(`[coordinator] ${instance.id} ${req.step}: the brief could not be composed: ${describe12(err2)}`);
+      return json3(502, { ok: false, error: "brief_failed", message: describe12(err2), at });
     }
   } else {
     turn = { prompt: req.prompt };
@@ -71371,7 +72370,7 @@ ${foldThreadEvents(folded)}` };
     });
   } catch (err2) {
     releaseAdmission();
-    return json3(502, { ok: false, error: "spawn_failed", message: describe11(err2), at });
+    return json3(502, { ok: false, error: "spawn_failed", message: describe12(err2), at });
   }
   const settled = dispatching.then(
     (outcome) => ({ kind: "ended", outcome }),
@@ -71380,7 +72379,7 @@ ${foldThreadEvents(folded)}` };
   void settled.then((end) => {
     releaseAdmission();
     if (end.kind === "threw")
-      log(`[coordinator] ${instance.id} ${req.step}: the child's dispatch threw: ${describe11(end.err)}`);
+      log(`[coordinator] ${instance.id} ${req.step}: the child's dispatch threw: ${describe12(end.err)}`);
   });
   const first = await Promise.race([started.then((id) => ({ kind: "started", id })), settled]);
   if (first.kind === "started" || startedId !== void 0) {
@@ -71390,7 +72389,7 @@ ${foldThreadEvents(folded)}` };
         { instanceId: instance.id, unit: row2.unit },
         folded.map((e) => e.seq),
         req.step
-      ).catch((err2) => log(`[coordinator] ${instance.id} ${req.step}: the consumed marks failed: ${describe11(err2)}`));
+      ).catch((err2) => log(`[coordinator] ${instance.id} ${req.step}: the consumed marks failed: ${describe12(err2)}`));
       log(
         `[coordinator] ${instance.id} ${req.step}: folded ${folded.length} thread event(s) into the ${req.preset} child`
       );
@@ -71398,7 +72397,7 @@ ${foldThreadEvents(folded)}` };
     log(`[coordinator] ${instance.id} ${req.step}: spawned ${req.preset} run ${runId3} in ${threadKey}`);
     return json3(200, { ok: true, runId: runId3, threadKey, at });
   }
-  if (first.kind === "threw") return json3(502, { ok: false, error: "spawn_failed", message: describe11(first.err), at });
+  if (first.kind === "threw") return json3(502, { ok: false, error: "spawn_failed", message: describe12(first.err), at });
   const refusal = first.outcome.refusal;
   if (refusal === "coordinator_thread_live") {
     const now = await liveOnThread(deps.runs, instance, threadKey);
@@ -71537,11 +72536,11 @@ async function reviewPostedAtPatiently(deps, pr, verdict, head) {
   }
   return answer;
 }
-function reviewPostedByRecord(record2, pr) {
-  const post = record2.reviewPost;
-  if (post === void 0 || record2.reviewHead === void 0 || record2.verdict === void 0) return void 0;
+function reviewPostedByRecord(record3, pr) {
+  const post = record3.reviewPost;
+  if (post === void 0 || record3.reviewHead === void 0 || record3.verdict === void 0) return void 0;
   if (!post.posted) return { reviewPosted: false, reviewPostReason: post.reason };
-  const same = post.target.repo === pr.repo && post.target.number === pr.number && sameCommit(post.head.toLowerCase(), record2.reviewHead) && post.verdict === record2.verdict.verdict;
+  const same = post.target.repo === pr.repo && post.target.number === pr.number && sameCommit(post.head.toLowerCase(), record3.reviewHead) && post.verdict === record3.verdict.verdict;
   return same ? { reviewPosted: true } : void 0;
 }
 function headBranchStateUnknown(facts2) {
@@ -71558,6 +72557,7 @@ function pullRequestState(number, fallbackUrl, facts2) {
       state: "merged",
       prNumber: number,
       url,
+      ...facts2.headSha !== void 0 ? { headSha: facts2.headSha } : {},
       sha: facts2.mergeCommitSha,
       mergedAt: facts2.mergedAt,
       ...facts2.mergedBy !== void 0 ? { mergedBy: facts2.mergedBy } : {}
@@ -71618,7 +72618,7 @@ async function readRecord(body, deps) {
   try {
     pullRequest = await childPullRequestState(deps, instanceRow, typeof body.unit === "string" ? body.unit : void 0);
   } catch (err2) {
-    return json3(502, { ok: false, error: "github_unavailable", message: describe11(err2), at });
+    return json3(502, { ok: false, error: "github_unavailable", message: describe12(err2), at });
   }
   if (!view.finished)
     return json3(200, {
@@ -71628,15 +72628,16 @@ async function readRecord(body, deps) {
       at
     });
   const full = await deps.runs.getRun(body.runId, { include: "messages" });
-  const record2 = full.ok ? full.value : view;
-  const finalReply = finalReplyOf2(record2.events);
-  const reviewAskedAt = reviewAskedAtOf(record2.events);
-  const opened = prOpenedOf(record2.events);
+  const record3 = full.ok ? full.value : view;
+  const finalReply = finalReplyOf2(record3.events);
+  const reviewAskedAt = reviewAskedAtOf(record3.events);
+  const description = record3.events?.some((event) => event.type === "pr_description") === true;
+  const opened = prOpenedOf(record3.events);
   const pr = opened !== void 0 ? { number: opened.number, url: opened.url, created: opened.created } : void 0;
   let coordinatorUnit;
   if (instanceRow !== null && typeof body.unit === "string") {
     coordinatorUnit = (await deps.instances.listUnits(instanceRow.id)).find((u) => u.unit === body.unit);
-    const pushedPrRef = opened?.head !== void 0 && record2.pushed?.some((pushed) => pushed.ref === opened.head) ? opened.head : void 0;
+    const pushedPrRef = opened?.head !== void 0 && record3.pushed?.some((pushed) => pushed.ref === opened.head) ? opened.head : void 0;
     if (coordinatorUnit !== void 0 && pushedPrRef !== void 0 && coordinatorUnit.branch !== pushedPrRef) {
       coordinatorUnit = { ...coordinatorUnit, branch: pushedPrRef };
       await deps.instances.putUnits([coordinatorUnit]);
@@ -71663,13 +72664,13 @@ async function readRecord(body, deps) {
       });
   }
   let posted;
-  if (record2.verdict !== void 0 && record2.reviewHead !== void 0 && typeof body.unit === "string") {
+  if (record3.verdict !== void 0 && record3.reviewHead !== void 0 && typeof body.unit === "string") {
     const instance = instanceRow;
     if (instance && coordinatorUnit?.pr !== void 0) {
       const unitPr = { repo: instance.repo, number: coordinatorUnit.pr.number };
-      posted = reviewPostedByRecord(record2, unitPr);
+      posted = reviewPostedByRecord(record3, unitPr);
       if (posted === void 0) {
-        const seen = await reviewPostedAtPatiently(deps, unitPr, record2.verdict.verdict, record2.reviewHead);
+        const seen = await reviewPostedAtPatiently(deps, unitPr, record3.verdict.verdict, record3.reviewHead);
         if (seen !== void 0) posted = { reviewPosted: seen };
       }
     }
@@ -71681,27 +72682,31 @@ async function readRecord(body, deps) {
     run: {
       ...coordinatorRunView(view, id.value, finalReply),
       ...pr !== void 0 ? { pr } : {},
-      ...record2.verdict !== void 0 ? { verdict: record2.verdict } : {},
-      ...record2.reviewHead !== void 0 ? { reviewHead: record2.reviewHead } : {},
+      ...record3.verdict !== void 0 ? { verdict: record3.verdict } : {},
+      ...record3.reviewHead !== void 0 ? { reviewHead: record3.reviewHead } : {},
       ...reviewAskedAt !== void 0 ? { reviewAskedAt } : {},
       ...posted !== void 0 ? { reviewPosted: posted.reviewPosted } : {},
       ...posted?.reviewPostReason !== void 0 ? { reviewPostReason: posted.reviewPostReason } : {},
-      ...record2.dispositions !== void 0 ? { dispositions: record2.dispositions } : {},
-      ...record2.handoff !== void 0 ? { handoff: true } : {},
+      ...record3.dispositions !== void 0 ? { dispositions: record3.dispositions } : {},
+      // Findings readiness requires the typed description output. Its event is
+      // durable on the child record, so the runner can verify it without
+      // trusting final-reply prose.
+      ...description ? { description: true } : {},
+      ...record3.handoff !== void 0 ? { handoff: true } : {},
       // The renewal's facts (decision 0046): progress is read off these.
-      ...record2.pushed !== void 0 ? { pushed: record2.pushed } : {},
-      ...record2.lease !== void 0 ? { leaseStartedAt: record2.lease.startedAt } : {},
+      ...record3.pushed !== void 0 ? { pushed: record3.pushed } : {},
+      ...record3.lease !== void 0 ? { leaseStartedAt: record3.lease.startedAt } : {},
       // What the child cost, as the runs service prices it (costs.md item 4c):
       // null when unknown — no usage on the record, or a model without a price
       // — so a capped grant never renews on an understated total.
-      costUsd: record2.cost?.usd ?? null,
-      ...record2.handoff !== void 0 ? { handoffLists: record2.handoff } : {},
+      costUsd: record3.cost?.usd ?? null,
+      ...record3.handoff !== void 0 ? { handoffLists: record3.handoff } : {},
       // The failure by name (run-history item 57): a `provider_transient` lets
       // the machine re-run a round-0 child that pushed nothing (issue 1932).
-      ...record2.failure !== void 0 ? { failure: record2.failure } : {},
+      ...record3.failure !== void 0 ? { failure: record3.failure } : {},
       // What ended an interrupted child (issue 1876), off its record's own
       // events: the unit's ending names the actual cause in the user's nouns.
-      ...view.status === "interrupted" ? interruptionOf(record2.events) : {}
+      ...view.status === "interrupted" ? interruptionOf(record3.events) : {}
     },
     at
   });
@@ -71780,6 +72785,13 @@ async function recoverPushedBranch(deps, instance, row2, branch2, runId3) {
     if (subject2 !== void 0 && checkPrTitle(subject2, prTitleVocabulary_default).ok) title = subject2;
   }
   title ??= recoveredFallbackTitle(row2, branch2, instance.plan?.id ?? parsePlanBranch(branch2)?.planId);
+  const header4 = requestedByLine({
+    name: instance.userName?.trim() || instance.userId,
+    threadUrl: threadPageLink(instance.threadKey, deps.runPageBase?.replace(/\/runs\/?$/, "") ?? "")
+  });
+  prBody = `${header4}
+
+${prBody}`;
   if (deps.rewriteIdentities !== void 0) {
     const rewritten = await deps.rewriteIdentities({
       repo: instance.repo,
@@ -71934,7 +72946,7 @@ async function prCheck(body, deps) {
       if (recover === void 0) {
         const ahead = instance.base === void 0 ? void 0 : await deps.commitsOverBase(instance.repo, instance.base, branch2).catch((err2) => {
           (deps.log ?? console.log)(
-            `[coordinator] ${instance.id} pr-check: the compare of ${branch2} over ${instance.base} could not be read: ${describe11(err2)}`
+            `[coordinator] ${instance.id} pr-check: the compare of ${branch2} over ${instance.base} could not be read: ${describe12(err2)}`
           );
           return void 0;
         });
@@ -71958,7 +72970,7 @@ async function prCheck(body, deps) {
     if (state?.state !== "merged") throw new Error(`${instance.repo}#${merged.number} no longer reads merged`);
     return json3(200, { ok: true, ...state, at });
   } catch (err2) {
-    return json3(502, { ok: false, error: "github_unavailable", message: describe11(err2), at });
+    return json3(502, { ok: false, error: "github_unavailable", message: describe12(err2), at });
   }
 }
 async function hostRunOf(deps, instance) {
@@ -71971,14 +72983,68 @@ async function hostRunOf(deps, instance) {
     return { kind: "not_host" };
   return { kind: "untracked" };
 }
-function hostPublish(deps, instance, runId3, events, at) {
-  for (const event of events) deps.registry.publish(runId3, event);
+async function hostPublish(deps, instance, runId3, events, at) {
   const caps = instance.caps ?? resolveShipCaps(void 0);
   const hosting = {
     instanceId: instance.id,
     until: at + minutesToMs(caps.maxMinutes + HOSTED_DEADLINE_MARGIN_MINUTES)
   };
-  deps.ledgerRuns().find((run2) => run2.runId === runId3)?.setState({ hosting });
+  const ledgerRun = deps.ledgerRuns().find((run2) => run2.runId === runId3);
+  let summary = deps.registry.getById(runId3);
+  if (ledgerRun && summary) {
+    if (summary.liveState === void 0) {
+      const admitted = await ledgerRun.assignLiveState({
+        expectedSeq: 0,
+        eventSeq: summary.eventCount + 1,
+        at,
+        state: "admitted",
+        bound: hosting.until,
+        detail: "waiting for the pipeline hand-off"
+      });
+      if (!admitted.ok || !deps.registry.commitLiveState(runId3, admitted))
+        throw new Error(
+          `hosted live state backfill was not committed (${admitted.ok ? "registry sequence" : admitted.reason})`
+        );
+      summary = deps.registry.getById(runId3);
+      if (!summary) throw new Error("hosted run disappeared during live-state backfill");
+      const working = await ledgerRun.assignLiveState({
+        expectedSeq: summary.liveStateSeq ?? 0,
+        eventSeq: summary.eventCount + 1,
+        at,
+        state: "working",
+        bound: hosting.until,
+        detail: "pipeline starting",
+        statePatch: { hosting }
+      });
+      if (!working.ok || !deps.registry.commitLiveState(runId3, working))
+        throw new Error(
+          `hosted working backfill was not committed (${working.ok ? "registry sequence" : working.reason})`
+        );
+      summary = deps.registry.getById(runId3);
+      if (!summary) throw new Error("hosted run disappeared after live-state backfill");
+    }
+    const firstSeq = summary.eventCount + 1;
+    const sourceEvents = events.map((event, index) => ({ ...event, seq: firstSeq + index }));
+    const prior = deps.registry.snapshotById(runId3)?.events.filter((event) => event.type === "ship_round" || event.type === "ship_unit") ?? [];
+    const standing = pipelineStandingOf([...prior, ...events]);
+    const stage = standing.changes.at(-1)?.stage ?? "idle";
+    const committed = await ledgerRun.assignLiveState({
+      expectedSeq: summary.liveStateSeq ?? 0,
+      at,
+      state: "working",
+      bound: hosting.until,
+      detail: hostedStageDetail(stage),
+      statePatch: { hosting },
+      sourceEvents
+    });
+    if (!committed.ok || !deps.registry.commitLiveState(runId3, committed))
+      throw new Error(
+        `hosted live state refresh was not committed (${committed.ok ? "registry sequence" : committed.reason})`
+      );
+  } else {
+    ledgerRun?.setState({ hosting });
+  }
+  for (const event of events) deps.registry.publish(runId3, event);
 }
 function namesForeignRun(instance, body) {
   return typeof body.runId === "string" && body.runId !== instance.runId;
@@ -72064,7 +73130,7 @@ async function unitStart(body, deps) {
   row2 = { ...row2, startedAt: row2.startedAt ?? at };
   await deps.instances.putUnits([row2]);
   if (host.kind === "host")
-    hostPublish(
+    await hostPublish(
       deps,
       instance,
       host.runId,
@@ -72113,7 +73179,7 @@ async function branch(body, deps) {
     await deps.createBranchRef(instance.repo, name, base);
     return json3(200, { ok: true, branch: name, base, at });
   } catch (err2) {
-    return json3(200, { ok: false, reason: describe11(err2), at });
+    return json3(200, { ok: false, reason: describe12(err2), at });
   }
 }
 function unitLines(units, generated, severity) {
@@ -72194,7 +73260,7 @@ async function round(body, deps) {
   await deps.instances.putUnits([updated]);
   if (host.kind === "host") {
     const thread = unitThread(instance, updated, units.length);
-    hostPublish(
+    await hostPublish(
       deps,
       instance,
       host.runId,
@@ -72228,7 +73294,7 @@ async function round(body, deps) {
     instance,
     units.map((u) => u.unit === updated.unit ? updated : u)
   ).catch(
-    (err2) => (deps.log ?? console.warn)(`[coordinator] ${instance.id}: the card could not be redrawn: ${describe11(err2)}`)
+    (err2) => (deps.log ?? console.warn)(`[coordinator] ${instance.id}: the card could not be redrawn: ${describe12(err2)}`)
   );
   return json3(200, { ok: true, at });
 }
@@ -72402,7 +73468,7 @@ async function unitWake(body, deps) {
     instance,
     units.map((u) => u.unit === visible.unit ? visible : u)
   ).catch(
-    (err2) => (deps.log ?? console.warn)(`[coordinator] ${instance.id}: the card could not be redrawn: ${describe11(err2)}`)
+    (err2) => (deps.log ?? console.warn)(`[coordinator] ${instance.id}: the card could not be redrawn: ${describe12(err2)}`)
   );
   return json3(200, { ok: true, answer, at });
 }
@@ -72465,7 +73531,7 @@ async function unitEnd(body, deps) {
     deps.runnerOwnership?.release(instance.repo, updated.pr.number);
   const thread = unitThread(instance, updated, units.length);
   if (host.kind === "host")
-    hostPublish(
+    await hostPublish(
       deps,
       instance,
       host.runId,
@@ -72496,7 +73562,7 @@ async function unitEnd(body, deps) {
         `unit-end:${row2.unit}`
       ).catch(
         (err2) => (deps.log ?? console.warn)(
-          `[coordinator] ${instance.id} ${row2.unit}: the leftover marks failed: ${describe11(err2)}`
+          `[coordinator] ${instance.id} ${row2.unit}: the leftover marks failed: ${describe12(err2)}`
         )
       );
       const freshTurn = {
@@ -72514,7 +73580,7 @@ async function unitEnd(body, deps) {
       };
       void deps.dispatch(freshTurn, io).catch(
         (err2) => (deps.log ?? console.warn)(
-          `[coordinator] ${instance.id} ${row2.unit}: the leftovers' fresh turn threw: ${describe11(err2)}`
+          `[coordinator] ${instance.id} ${row2.unit}: the leftovers' fresh turn threw: ${describe12(err2)}`
         )
       );
       (deps.log ?? console.log)(
@@ -72531,7 +73597,7 @@ async function unitEnd(body, deps) {
       told = true;
     } catch (err2) {
       (deps.log ?? console.warn)(
-        `[coordinator] ${instance.id} ${row2.unit}: the report could not be posted: ${describe11(err2)}`
+        `[coordinator] ${instance.id} ${row2.unit}: the report could not be posted: ${describe12(err2)}`
       );
     }
   }
@@ -72545,7 +73611,7 @@ ${ending.report}` + (rendered !== void 0 ? `
 ${rendered}` : "");
     await deps.github.commentIssue(instance.repo, row2.issue, comment).catch(
       (err2) => (deps.log ?? console.warn)(
-        `[coordinator] ${instance.id} ${row2.unit}: the board comment could not be posted: ${describe11(err2)}`
+        `[coordinator] ${instance.id} ${row2.unit}: the board comment could not be posted: ${describe12(err2)}`
       )
     );
   }
@@ -72556,7 +73622,7 @@ ${rendered}` : "");
 
 ${ending.report}`).catch(
       (err2) => (deps.log ?? console.warn)(
-        `[coordinator] ${instance.id} ${row2.unit}: the human-gated report could not be posted on the pull request: ${describe11(err2)}`
+        `[coordinator] ${instance.id} ${row2.unit}: the human-gated report could not be posted on the pull request: ${describe12(err2)}`
       )
     );
   }
@@ -72618,7 +73684,7 @@ async function rebaseStep(body, deps) {
       at
     });
   } catch (err2) {
-    return json3(200, { ok: true, outcome: "refused", reason: describe11(err2), at });
+    return json3(200, { ok: true, outcome: "refused", reason: describe12(err2), at });
   }
 }
 async function merge(body, deps, subject2) {
@@ -72656,7 +73722,7 @@ async function merge(body, deps, subject2) {
   try {
     facts2 = await deps.fetchPrFacts(pr);
   } catch (err2) {
-    return json3(502, { ok: false, error: "github_unavailable", message: describe11(err2), at });
+    return json3(502, { ok: false, error: "github_unavailable", message: describe12(err2), at });
   }
   if (facts2 === void 0)
     return json3(502, { ok: false, error: "github_unavailable", message: `${where} could not be read`, at });
@@ -72782,7 +73848,7 @@ async function merge(body, deps, subject2) {
     try {
       queued = await deps.enqueuePullRequest(pr, { sha: headSha });
     } catch (err2) {
-      return json3(502, { ok: false, error: "github_unavailable", message: describe11(err2), at });
+      return json3(502, { ok: false, error: "github_unavailable", message: describe12(err2), at });
     }
     if (!queued.ok) return refused7(`GitHub refused to enqueue ${where}: ${queued.reason}`);
     log(
@@ -72799,7 +73865,7 @@ async function merge(body, deps, subject2) {
       title: facts2.title ?? `Merge pull request #${pr.number}`
     });
   } catch (err2) {
-    return json3(502, { ok: false, error: "github_unavailable", message: describe11(err2), at });
+    return json3(502, { ok: false, error: "github_unavailable", message: describe12(err2), at });
   }
   if (!merged.ok) {
     if (merged.status === 405 && MERGE_QUEUE_405.test(merged.reason)) return enqueue();
@@ -72910,13 +73976,54 @@ async function finish(body, deps) {
   if (host.kind === "not_host") return json3(409, { ok: false, error: "not_host", at });
   const units = await deps.instances.listUnits(instance.id);
   if (host.kind === "host") {
-    hostPublish(
-      deps,
-      instance,
-      host.runId,
-      [{ type: "answer", text: planSummary(units, isGenerated2(instance)), at }],
-      at
-    );
+    const ledgerRun = deps.ledgerRuns().find((run2) => run2.runId === host.runId);
+    let summary = deps.registry.getById(host.runId);
+    if (ledgerRun && summary) {
+      if (summary.liveState === void 0) {
+        await hostPublish(deps, instance, host.runId, [], at);
+        summary = deps.registry.getById(host.runId);
+        if (!summary) throw new Error("hosted run disappeared during finish backfill");
+      }
+      const bound = summary.liveState?.bound ?? at + minutesToMs(HOSTED_DEADLINE_MARGIN_MINUTES);
+      const wrapping = await ledgerRun.assignLiveState({
+        expectedSeq: summary.liveStateSeq ?? 0,
+        eventSeq: summary.eventCount + 1,
+        at,
+        state: "wrapping_up",
+        bound,
+        detail: "writing the pipeline summary"
+      });
+      if (!wrapping.ok || !deps.registry.commitLiveState(host.runId, wrapping))
+        throw new Error(`hosted wrap-up was not committed (${wrapping.ok ? "registry sequence" : wrapping.reason})`);
+      summary = deps.registry.getById(host.runId);
+      if (!summary) throw new Error("hosted run disappeared during wrap-up");
+      const answer = { type: "answer", text: planSummary(units, isGenerated2(instance)), at };
+      const answerSeq = summary.eventCount + 1;
+      const refreshed = await ledgerRun.assignLiveState({
+        expectedSeq: summary.liveStateSeq ?? 0,
+        at,
+        state: "wrapping_up",
+        bound,
+        detail: "writing the pipeline summary",
+        sourceEvents: [{ ...answer, seq: answerSeq }]
+      });
+      if (!refreshed.ok || !deps.registry.commitLiveState(host.runId, refreshed))
+        throw new Error(`hosted summary was not committed (${refreshed.ok ? "registry sequence" : refreshed.reason})`);
+      deps.registry.publish(host.runId, answer);
+      summary = deps.registry.getById(host.runId);
+      if (!summary) throw new Error("hosted run disappeared before ending");
+      const ended = await ledgerRun.assignLiveState({
+        expectedSeq: summary.liveStateSeq ?? 0,
+        eventSeq: summary.eventCount + 1,
+        at,
+        state: "ended",
+        cause: body.outcome === "completed" ? "completed" : "failed"
+      });
+      if (!ended.ok || !deps.registry.commitLiveState(host.runId, ended))
+        throw new Error(`hosted ending was not committed (${ended.ok ? "registry sequence" : ended.reason})`);
+    } else {
+      deps.registry.publish(host.runId, { type: "answer", text: planSummary(units, isGenerated2(instance)), at });
+    }
     deps.registry.finish(host.runId, body.outcome);
   }
   await drawCard(deps, instance, units, { icon: body.outcome === "completed" ? "\u2705" : "\u26A0\uFE0F" }).catch(() => {
@@ -72934,7 +74041,7 @@ ${planSummary(units)}`).catch(() => {
     const summary = deps.registry.getById(host.runId);
     const visibility = await deps.channelVisibilityOf(instance.channelId);
     const finishedAt = snap?.finishedAt ?? at;
-    const record2 = assembleRunRecord({
+    const record3 = assembleRunRecord({
       run: { id: host.runId, ...summary?.label !== void 0 ? { label: summary.label } : {} },
       snap,
       agent: "ship",
@@ -72964,7 +74071,7 @@ ${planSummary(units)}`).catch(() => {
       seal
     });
     const handle2 = deps.ledgerRuns().find((run2) => run2.runId === host.runId);
-    deps.runHistoryWriter.write(record2, handle2 !== void 0 ? { via: handle2.sink } : void 0);
+    deps.runHistoryWriter.write(record3, handle2 !== void 0 ? { via: handle2.sink } : void 0);
   }
   (deps.log ?? console.log)(`[coordinator] ${instance.id}: finished ${body.outcome} \u2014 record ${runId3}`);
   return json3(200, { ok: true, runId: runId3, at });
@@ -73078,18 +74185,20 @@ function createAdminCoordinatorHandler(deps) {
         }
         write(res, await answerCoordinatorStep(door, read.body, deps));
       } catch (err2) {
-        (deps.log ?? console.error)(`[coordinator] ${describe11(err2)}`);
+        (deps.log ?? console.error)(`[coordinator] ${describe12(err2)}`);
         write(res, json3(500, { ok: false, error: "internal error" }));
       }
     })();
   };
 }
-var COORDINATOR_ADMIN_PREFIX, MAX_SPAWN_PROMPT_CHARS, FINISHED_LOOKBACK_PAGES, MAX_ADMIN_BODY_BYTES, UNIT_ID, PRESETS_OF_KIND, invalid, json3, describe11, isGenerated2, EVERY_RUN, REVIEW_POSTED_CHECKS, REVIEW_POSTED_RECHECK_MS, githubSecondStart, CHILD_SUPERSESSION_REASONS, ROUND_OUTCOMES, ENDING_ICON, STEPS;
+var COORDINATOR_ADMIN_PREFIX, MAX_SPAWN_PROMPT_CHARS, FINISHED_LOOKBACK_PAGES, MAX_ADMIN_BODY_BYTES, UNIT_ID, PRESETS_OF_KIND, invalid, json3, describe12, isGenerated2, EVERY_RUN, REVIEW_POSTED_CHECKS, REVIEW_POSTED_RECHECK_MS, githubSecondStart, CHILD_SUPERSESSION_REASONS, ROUND_OUTCOMES, ENDING_ICON, STEPS;
 var init_adminCoordinator = __esm({
   "../../src/channels/adminCoordinator.ts"() {
     "use strict";
     init_budgets();
     init_verbosity();
+    init_prDescription();
+    init_reply();
     init_registry();
     init_authorize();
     init_actor();
@@ -73131,7 +74240,7 @@ var init_adminCoordinator = __esm({
     };
     invalid = (error) => ({ ok: false, error });
     json3 = (status3, body) => ({ status: status3, body });
-    describe11 = (err2) => err2 instanceof Error ? err2.message : String(err2);
+    describe12 = (err2) => err2 instanceof Error ? err2.message : String(err2);
     isGenerated2 = (instance) => instance.plan?.path === void 0;
     EVERY_RUN = { kind: "all" };
     REVIEW_POSTED_CHECKS = 3;
@@ -74366,6 +75475,13 @@ async function runBot() {
   if (process.env.PORT) {
     const ingress = createIngressHandler(deps, { auth, publicBaseUrl: process.env.PUBLIC_BASE_URL, personByEmail });
     const mcp2 = createMcpHandler(deps, { auth, commands, grantsFor: (id) => config.grantsFor(id), personByEmail });
+    const providerLiveState = createProviderLiveStateCoordinator({
+      runLedger,
+      ledger: ledgerClient,
+      registry: defaultRunRegistry,
+      clock: systemClock,
+      warn: (message4) => console.warn(`[provider-state] ${message4}`)
+    });
     const modelProxy = createModelProxyHandler({
       bearers: runBearers,
       providers: () => config.config.providers,
@@ -74374,17 +75490,11 @@ async function runBot() {
       ...costsCfg?.prices ? { prices: () => costsCfg.prices } : {},
       secrets: processSecrets,
       clock: systemClock,
-      // The plane's provider seam (model-proxy item 12a; record 0064): a level
-      // and a park land on the write-through's plane routes, fire and forget —
-      // the null write-through swallows both where no ledger is configured.
+      // The plane's provider seam (model-proxy item 12a; record 0064): one
+      // coordinator sequences level and park writes; the proxy never waits.
       plane: {
-        level: (provider, side, cause) => void runLedger.planeLevel({
-          provider,
-          name: "provider",
-          side,
-          ...side === "down" && cause !== void 0 ? { cause } : {}
-        }),
-        park: (runId3, provider) => void runLedger.planePark(runId3, provider)
+        level: (provider, side, cause) => void providerLiveState.level(provider, side, cause),
+        park: (runId3, provider) => void providerLiveState.park(runId3, provider)
       }
     });
     const harnessRoutes = createHarnessRoutesHandler({ bearers: runBearers, harnesses, takeover });
@@ -75128,6 +76238,7 @@ var init_index = __esm({
     init_adminModelProxy();
     init_modelProxy();
     init_runBearers();
+    init_providerLiveStateCoordinator();
     init_piHarness();
     init_harness2();
     init_relay();