@coreplane/switchboard 1.260.5 → 1.261.0

package/dist/cli.js

@@ -597,7 +597,7 @@ function fit(pipeline) {
   const need = ALLOWANCES.provision + ASKS.coding + reserveMinutes({ kind: "coding", index: 0 }, pipeline);
   return { ok: pipeline.maxMinutes >= need, need, have: pipeline.maxMinutes };
 }
-var SECOND_MS, secondsToMs, MINUTE_MS, minutesToMs, DAY_MS, WEEK_MS, CONFIRMATION_TTL_MS, QUESTION_TTL_MS, AUTHOR_BINDING_TTL_MS, FIRST_ATTACH_WAIT_MS, ATTACH_REQUEST_MIN_MS, HARNESS_PROBE_WAIT_MS, DRAIN, INTAKE_WINDOW_MAX_MS, INTAKE_RECOVERY_WINDOW_MS, INTAKE_DELIVERY_CLAIM_MS, LOOP_PRESETS, ASKS, PRESET_FLOORS, FLOORS, PULL_SWEEP, PROVIDER_RETRY_BACKOFFS_MS, MODEL_STREAM_HEARTBEAT_MS, HOSTED_DEADLINE_MARGIN_MINUTES, SHIP_WAIT, RESTART_CLAIM_GRACE_MS, PLANE, PACE_WINDOW_MINUTES, ALLOWANCES, POST_STEP_MINUTES, WRAP_UP_WARNING, SANDBOX_CREDENTIAL_WRITE_TIMEOUT_MS, BASH_COMMAND, RUNAWAY_TURNS_PER_MINUTE, DEFAULT_GRANT, GRANT_RENEWALS_MAX, STRUCTURED_RETRIES_MAX, IDLE_DAYS_DEFAULT, IDLE_DAYS_MAX, IDLE_WAKES_MAX;
+var SECOND_MS, secondsToMs, MINUTE_MS, minutesToMs, DAY_MS, WEEK_MS, CONFIRMATION_TTL_MS, QUESTION_TTL_MS, AUTHOR_BINDING_TTL_MS, FIRST_ATTACH_WAIT_MS, ATTACH_REQUEST_MIN_MS, HARNESS_PROBE_WAIT_MS, DRAIN, INTAKE_WINDOW_MAX_MS, INTAKE_RECOVERY_WINDOW_MS, INTAKE_DELIVERY_CLAIM_MS, LOOP_PRESETS, ASKS, PRESET_FLOORS, FLOORS, PULL_SWEEP, PROVIDER_RETRY_BACKOFFS_MS, MODEL_STREAM_HEARTBEAT_MS, HOSTED_DEADLINE_MARGIN_MINUTES, SHIP_WAIT, SHIP_RECORD_VISIBILITY, RESTART_CLAIM_GRACE_MS, PLANE, PACE_WINDOW_MINUTES, ALLOWANCES, POST_STEP_MINUTES, WRAP_UP_WARNING, SANDBOX_CREDENTIAL_WRITE_TIMEOUT_MS, BASH_COMMAND, RUNAWAY_TURNS_PER_MINUTE, DEFAULT_GRANT, GRANT_RENEWALS_MAX, STRUCTURED_RETRIES_MAX, IDLE_DAYS_DEFAULT, IDLE_DAYS_MAX, IDLE_WAKES_MAX;
 var init_budgets = __esm({
   "../../src/core/budgets.ts"() {
     "use strict";
@@ -676,6 +676,7 @@ var init_budgets = __esm({
     MODEL_STREAM_HEARTBEAT_MS = 15e3;
     HOSTED_DEADLINE_MARGIN_MINUTES = 60;
     SHIP_WAIT = { marginMinutes: 5, chunkMinutes: 5, mergeChunkMinutes: 5, busyRetryMinutes: 2 };
+    SHIP_RECORD_VISIBILITY = { retries: 3, retryMs: secondsToMs(1) };
     RESTART_CLAIM_GRACE_MS = minutesToMs(SHIP_WAIT.chunkMinutes);
     PLANE = {
       recentMinutes: 60,
@@ -4077,6 +4078,7 @@ function isHeadMaterial(event) {
     case "context":
     case "reference":
     case "run_meta":
+    case "run_state":
     case "route":
       return true;
     case "run_note":
@@ -4846,7 +4848,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;
     }
@@ -4928,6 +4930,7 @@ function analyzeRunFriction(events, opts = {}) {
       }
       return;
     }
+    if (ev.type !== "run_note") return;
     switch (ev.kind) {
       case "wrap_up":
         wrapUp = { index, at: ev.at };
@@ -5881,6 +5884,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;
 }
@@ -6007,10 +6030,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",
@@ -15400,7 +15424,7 @@ var init_refusal = __esm({
       repo_not_onboarded: "request",
       repo_access: "policy",
       pr_head_unknown: "system",
-      branch_moved: "system",
+      workspace_head_mismatch: "system",
       coordinator_thread_live: "system",
       live_agent_allowlist: "policy",
       follow_up_refused: "request",
@@ -16133,6 +16157,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
@@ -16299,6 +16324,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)) {
@@ -16347,14 +16373,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");
@@ -16392,7 +16420,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
@@ -16699,6 +16726,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) ? {
@@ -18412,7 +18446,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,
@@ -18594,7 +18628,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 {
@@ -25399,6 +25433,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(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 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 = [];
@@ -25464,6 +25691,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":
@@ -25486,12 +25715,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);
   }
 });
 
@@ -29134,6 +29367,505 @@ var init_llmOutput = __esm({
   }
 });
 
+// ../../src/core/dispatch/handBack.ts
+function renderHandBackLine(line4) {
+  return `${HAND_BACK_PREFIX}
+\`${line4}\``;
+}
+var HAND_BACK_PREFIX;
+var init_handBack = __esm({
+  "../../src/core/dispatch/handBack.ts"() {
+    "use strict";
+    HAND_BACK_PREFIX = "To run this:";
+  }
+});
+
+// ../../src/core/statusCardFrame.ts
+function activityText(activity) {
+  if (!activity) return void 0;
+  if (activity.kind === "line") return activity.text;
+  return `\u2192 $ ${activity.command.replace(/\s+/g, " ").trim()}`;
+}
+function createCardShell(opts) {
+  const verbosity2 = opts.verbosity ?? DEFAULT_VERBOSITY;
+  const notes = [];
+  let link = opts.link;
+  let frame2 = 0;
+  let finishedAt;
+  let setupLabel;
+  const lead = opts.lead ?? [];
+  const base = () => opts.model !== void 0 && shows(verbosity2, "verbose") ? `${opts.label} on \`${opts.model}\`` : opts.label;
+  const label = () => [base(), ...notes.filter((n2) => shows(verbosity2, n2.level)).map((n2) => n2.text)].join(" \xB7 ");
+  const elapsed2 = () => formatDuration((finishedAt ?? opts.now()) - opts.startedAt, "clock");
+  const headline = (icon) => `${icon} ${label()} \xB7 ${elapsed2()}`;
+  const closeDetail = (close, own) => [...shows(verbosity2, "debug") ? [close.shape, close.queued] : [], own].filter(Boolean).join("\n") || void 0;
+  return {
+    get label() {
+      return label();
+    },
+    note(level, text) {
+      notes.push({ level, text });
+    },
+    setLink(next) {
+      link = next;
+    },
+    freeze(at) {
+      finishedAt = at;
+    },
+    setSetupLabel(next) {
+      setupLabel = next;
+    },
+    ack() {
+      const detail = lead.join("\n");
+      return { title: `\u{1F440} ${label()} \xB7 preparing workspace\u2026`, ...detail ? { detail } : {} };
+    },
+    live(parts = {}) {
+      const glyph = SPINNER_GLYPHS[frame2++ % SPINNER_GLYPHS.length];
+      const detail = [...lead, ...parts.detail ?? []].filter(Boolean).join("\n");
+      return {
+        title: headline(glyph) + (setupLabel ? ` \u2014 ${setupLabel}` : "") + (parts.suffix ?? "") + (parts.notice ? ` \xB7 ${parts.notice}` : ""),
+        detail: detail || void 0,
+        ...parts.activity ? { activity: parts.activity } : {},
+        link
+      };
+    },
+    close(close) {
+      const detail = closeDetail(close, close.kind === "done" ? close.detail : void 0);
+      switch (close.kind) {
+        case "done":
+          return { title: headline(close.icon), detail, link };
+        case "not_started":
+          return { title: `${close.icon} ${label()} \xB7 not started (${close.reason}) \xB7 ${elapsed2()}`, detail };
+        case "refused":
+          return { title: `${close.icon} ${label()} \xB7 ${close.reason} \xB7 ${elapsed2()}`, detail };
+        case "setup_failed":
+          return { title: `\u274C setup failed \xB7 ${close.reason} \xB7 ${elapsed2()}`, detail };
+      }
+    }
+  };
+}
+var SPINNER_GLYPHS, LIVE_CARD_PREFIXES, ROUTE_REASON_PREFIX;
+var init_statusCardFrame = __esm({
+  "../../src/core/statusCardFrame.ts"() {
+    "use strict";
+    init_formatDuration();
+    init_verbosity();
+    SPINNER_GLYPHS = ["\u25D0", "\u25D3", "\u25D1", "\u25D2"];
+    LIVE_CARD_PREFIXES = [...SPINNER_GLYPHS, "\u{1F440}"];
+    ROUTE_REASON_PREFIX = "route reason:";
+  }
+});
+
+// ../../src/core/confirmations.ts
+import { randomUUID } from "node:crypto";
+import { existsSync as existsSync12, mkdirSync as mkdirSync9, readFileSync as readFileSync14, writeFileSync as writeFileSync8 } from "node:fs";
+import { dirname as dirname10, resolve as resolve9 } from "node:path";
+function newConfirmationId() {
+  return randomUUID();
+}
+function renderOffer(offer) {
+  if (offer.question) return `${offer.question.text}
+Did you mean:
+\`${offer.line}\`
+
+${offer.question.evidence}`;
+  return [offer.line, ...offer.risk ? [offer.risk] : []].join("\n");
+}
+function confirmationMessageOf(msg) {
+  const { images: _images, documents: _documents, staged: _staged, ...kept } = msg;
+  return kept;
+}
+function isRecord3(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function isMessage(v) {
+  return isRecord3(v) && typeof v.channelId === "string" && typeof v.userId === "string" && typeof v.threadKey === "string" && typeof v.text === "string";
+}
+function isRunShape(v) {
+  return typeof v.id === "string" && isMessage(v.message) && typeof v.command === "string" && isRecord3(v.input) && typeof v.receipt === "string" && typeof v.risk === "string" && typeof v.model === "string";
+}
+function isRedispatchShape(v) {
+  return typeof v.id === "string" && isMessage(v.message) && typeof v.line === "string" && typeof v.evidence === "string" && typeof v.code === "string";
+}
+function parsePendingConfirmation(v) {
+  if (!isRecord3(v)) return void 0;
+  if (v.kind === "redispatch")
+    return isRedispatchShape(v) ? v : void 0;
+  if (v.kind !== void 0 && v.kind !== "run") return void 0;
+  return isRunShape(v) ? { ...v, kind: "run" } : void 0;
+}
+function parseConfirmation(v) {
+  if (!isRecord3(v) || typeof v.expiresAt !== "number") return void 0;
+  const pending2 = parsePendingConfirmation(v);
+  return pending2 ? { ...pending2, expiresAt: v.expiresAt } : void 0;
+}
+function isRefusal(v) {
+  return typeof v === "string" && CONFIRMATION_REFUSALS.includes(v);
+}
+function judge2(rows, id, actorIds, now, kind) {
+  const row2 = rows.get(id);
+  if (!row2) return { ok: false, refused: "used" };
+  if (kind === "consume" && row2.expiresAt <= now) {
+    rows.delete(id);
+    return { ok: false, refused: "expired", row: row2 };
+  }
+  if (!actorIds.includes(row2.message.userId))
+    return kind === "consume" ? { ok: false, refused: "foreign", row: row2 } : { ok: false, refused: "foreign" };
+  rows.delete(id);
+  return kind === "consume" ? { ok: true, row: row2 } : { ok: true };
+}
+function replaceThreadRow(rows, row2) {
+  for (const [id, r] of rows) if (r.message.threadKey === row2.message.threadKey) rows.delete(id);
+  rows.set(row2.id, row2);
+}
+function threadRowId(rows, threadKey) {
+  for (const [id, r] of rows) if (r.message.threadKey === threadKey) return id;
+  return void 0;
+}
+function buildConfirmationStore(config, secrets, opts) {
+  const worker = config.config.runtimeOverrides?.worker;
+  if (!worker) return new FileConfirmationStore(opts.path);
+  const tokenEnv = worker.tokenEnv ?? "MEMORY_TOKEN";
+  const token2 = secrets.named(tokenEnv);
+  if (!token2) throw new Error(`runtimeOverrides.worker is configured but ${tokenEnv} is not set`);
+  return new WorkerConfirmationStore({
+    baseUrl: worker.baseUrl,
+    token: token2.reveal(),
+    ...opts.fetch ? { fetch: opts.fetch } : {}
+  });
+}
+var CONFIRMATION_REFUSALS, UNSHOWABLE_LINE, STORE_UNREACHABLE_LINE, FileConfirmationStore, CONFIRMATION_WORKER_TIMEOUT_MS, WorkerConfirmationStore;
+var init_confirmations = __esm({
+  "../../src/core/confirmations.ts"() {
+    "use strict";
+    init_clock();
+    CONFIRMATION_REFUSALS = ["used", "expired", "foreign"];
+    UNSHOWABLE_LINE = "this command carries a value that cannot be shown, so no confirmation can be offered; nothing ran";
+    STORE_UNREACHABLE_LINE = "this command needs a confirmation click, and the confirmation store could not be reached; nothing ran \u2014 ask again for the button";
+    FileConfirmationStore = class {
+      path;
+      clock;
+      constructor(path, opts = {}) {
+        this.path = resolve9(path);
+        this.clock = opts.clock ?? systemClock;
+      }
+      read() {
+        const rows = /* @__PURE__ */ new Map();
+        if (!existsSync12(this.path)) return rows;
+        const raw = JSON.parse(readFileSync14(this.path, "utf8"));
+        for (const v of Array.isArray(raw.confirmations) ? raw.confirmations : []) {
+          const row2 = parseConfirmation(v);
+          if (row2) rows.set(row2.id, row2);
+        }
+        return rows;
+      }
+      write(rows) {
+        mkdirSync9(dirname10(this.path), { recursive: true });
+        writeFileSync8(this.path, JSON.stringify({ confirmations: [...rows.values()] }, null, 2));
+      }
+      async put(row2, ttlMs) {
+        const rows = this.read();
+        const stored = { ...row2, expiresAt: this.clock() + ttlMs };
+        replaceThreadRow(rows, stored);
+        this.write(rows);
+        return stored;
+      }
+      async consume(id, actorIds) {
+        const rows = this.read();
+        const out = judge2(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");
+        this.write(rows);
+        return out;
+      }
+      async cancelByThread(threadKey, actorIds) {
+        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");
+        this.write(rows);
+        return out;
+      }
+      async pendingByThread(threadKey) {
+        const rows = this.read();
+        const id = threadRowId(rows, threadKey);
+        const row2 = id === void 0 ? void 0 : rows.get(id);
+        if (!row2 || row2.expiresAt <= this.clock()) return void 0;
+        return row2;
+      }
+      describe() {
+        return `file ${this.path}`;
+      }
+    };
+    CONFIRMATION_WORKER_TIMEOUT_MS = 8e3;
+    WorkerConfirmationStore = class {
+      constructor(opts) {
+        this.opts = opts;
+        this.baseUrl = opts.baseUrl.replace(/\/+$/, "");
+        this.fetchImpl = opts.fetch ?? fetch;
+      }
+      opts;
+      baseUrl;
+      fetchImpl;
+      async put(row2, ttlMs) {
+        const body = await this.post("/config/confirmations/put", {
+          id: row2.id,
+          threadKey: row2.message.threadKey,
+          requester: row2.message.userId,
+          body: row2,
+          ttlMs
+        });
+        if (typeof body.expiresAt !== "number")
+          throw new Error("confirmation store answered a put without the expiry it stamped");
+        return { ...row2, expiresAt: body.expiresAt };
+      }
+      async consume(id, actorIds) {
+        const body = await this.post("/config/confirmations/consume", { id, actorIds });
+        const stored = isRecord3(body.row) ? body.row : void 0;
+        const row2 = parseConfirmation(
+          stored && isRecord3(stored.body) ? { ...stored.body, expiresAt: stored.expiresAt } : void 0
+        );
+        if (isRefusal(body.refused))
+          return { ok: false, refused: body.refused, ...row2 ? { row: row2 } : {} };
+        if (!row2) throw new Error("confirmation store answered a consume outside its contract");
+        return { ok: true, row: row2 };
+      }
+      async cancel(id, actorIds) {
+        const body = await this.post("/config/confirmations/cancel", { id, actorIds });
+        if (body.ok === true) return { ok: true };
+        if (body.refused === "used" || body.refused === "foreign") return { ok: false, refused: body.refused };
+        throw new Error("confirmation store answered a cancel outside its contract");
+      }
+      async cancelByThread(threadKey, actorIds) {
+        const body = await this.post("/config/confirmations/cancel-by-thread", { threadKey, actorIds });
+        if (body.ok === true) return { ok: true };
+        if (body.refused === "used" || body.refused === "foreign") return { ok: false, refused: body.refused };
+        throw new Error("confirmation store answered a cancel-by-thread outside its contract");
+      }
+      async pendingByThread(threadKey) {
+        const body = await this.post("/config/confirmations/pending-by-thread", { threadKey });
+        if (body.row === null) return void 0;
+        const stored = isRecord3(body.row) ? body.row : void 0;
+        const row2 = parseConfirmation(
+          stored && isRecord3(stored.body) ? { ...stored.body, expiresAt: stored.expiresAt } : void 0
+        );
+        if (!row2) throw new Error("confirmation store answered a pending-by-thread outside its contract");
+        return row2;
+      }
+      describe() {
+        return `state Worker ${this.baseUrl} (ConfigDO confirmations)`;
+      }
+      async post(path, payload2) {
+        let res;
+        try {
+          res = await this.fetchImpl(`${this.baseUrl}${path}`, {
+            method: "POST",
+            headers: { authorization: `Bearer ${this.opts.token}`, "content-type": "application/json" },
+            body: JSON.stringify(payload2),
+            signal: AbortSignal.timeout(CONFIRMATION_WORKER_TIMEOUT_MS)
+          });
+        } catch (err2) {
+          throw new Error(`confirmation store unreachable: ${err2 instanceof Error ? err2.message : String(err2)}`, {
+            cause: err2
+          });
+        }
+        if (!res.ok) throw new Error(`confirmation store answered HTTP ${res.status} on ${path}`);
+        const body = await res.json().catch(() => void 0);
+        if (!isRecord3(body)) throw new Error(`confirmation store returned a non-JSON body on ${path}`);
+        return body;
+      }
+    };
+  }
+});
+
+// ../../src/core/dispatch/route.ts
+function outputCapWithReasoning(visibleAnswerTokens, opts = {}) {
+  return opts.capField !== void 0 && REASONING_COUNTING_CAP_FIELDS.has(opts.capField) ? visibleAnswerTokens + REASONING_OUTPUT_TOKEN_ALLOWANCE : visibleAnswerTokens;
+}
+function outputCapRetry(current) {
+  return Math.max(current * 2, REASONING_OUTPUT_TOKEN_ALLOWANCE);
+}
+function routedRunsAtOnce(def, confirm, input) {
+  const radius = input === void 0 ? blastRadius(def) : boundBlastRadius(def, input);
+  return radius === "read" || CONFIRM_ORDER[radius] < CONFIRM_ORDER[confirm];
+}
+function routeReceipt(def, input) {
+  return redactAndCap(chatInvocation(def, input), ROUTE_RECEIPT_CAP);
+}
+function routablePresets() {
+  return Object.values(AGENTS).filter((a) => a.routable !== false).map(({ name, description, machine, identity: identity2, maxMinutes }) => ({
+    name,
+    description,
+    machine,
+    identity: identity2,
+    maxMinutes
+  }));
+}
+function routableCommands(commands) {
+  return commands.list().filter((cmd) => CommandRegistry.exposedTo(cmd, "chat")).map((cmd) => ({
+    id: cmd.id,
+    effect: cmd.effect,
+    def: cmd,
+    tool: { name: mcpToolName(cmd.id), description: cmd.describe, inputSchema: jsonSchemaFor(cmd) }
+  }));
+}
+function renderPresetTable(presets) {
+  const rows = presets.map(
+    (p) => `| \`${p.name}\` | ${oneLine(p.description)} | ${p.machine} | ${p.identity} | ${p.maxMinutes} min |`
+  );
+  return ["| name | what it does | machine | credential | budget |", "|---|---|---|---|---|", ...rows].join("\n");
+}
+function quoteRequest(text) {
+  const cap = 2e3;
+  const bent = text.replace(/<(\/?)request>/gi, "\u2039$1request\u203A");
+  if (bent.length <= cap) return bent;
+  return `${bent.slice(0, cap)}
+\u2026[truncated: ${bent.length - cap} more characters]`;
+}
+function providerStructuredModel(provider, model, opts = {}) {
+  const forced = (opts.answer ?? "tool") === "tool";
+  return async (prompt, call2) => {
+    const tools = [prompt.tool, ...prompt.tools ?? []];
+    const toolChoice = prompt.open ? void 0 : tools.length > 1 ? { type: "any" } : { type: "tool", name: prompt.tool.name };
+    const messages = [
+      { role: "user", content: [{ type: "text", text: prompt.user }] },
+      ...(prompt.retries ?? []).flatMap((r) => [
+        { role: "assistant", content: [{ type: "text", text: r.answer }] },
+        { role: "user", content: [{ type: "text", text: r.violation }] }
+      ])
+    ];
+    const result = await provider.complete({
+      model,
+      system: prompt.system,
+      messages,
+      maxTokens: call2.maxTokens,
+      signal: call2.signal,
+      // The caller's configured effort, card-decided (`turnEffort`): intake's
+      // `intake.effort` or the operator's `defaults.efforts.general`. Absent →
+      // the model's own default.
+      ...opts.effort ? { effort: opts.effort.effort, effortWord: opts.effort.effortWord } : {},
+      ...forced ? { tools, toolChoice } : {}
+    });
+    if (result.stopReason === "max_tokens") throw new OutputCapError(call2.maxTokens);
+    const calls = result.content.filter(
+      (p) => p.type === "tool_use"
+    );
+    if (calls.length > 1) throw new MultiToolCallError(calls.map((c) => ({ tool: c.name, input: c.input })));
+    if (calls.length === 1) return { tool: calls[0].name, input: calls[0].input };
+    return result.content.filter((p) => p.type === "text").map((p) => p.text).join("");
+  };
+}
+async function mintConfirmationOffer(args) {
+  const { io, store, msg, origin, def, input, receipt, model } = args;
+  if (!io.offer || !store) return { kind: "no_click" };
+  const line4 = chatInvocation(def, input);
+  if (redactSecrets(line4) !== line4) return { kind: "unshowable" };
+  const risk = def.annotations?.risk?.(input, origin) ?? "";
+  let row2;
+  try {
+    row2 = await store.put(
+      {
+        kind: "run",
+        id: newConfirmationId(),
+        message: confirmationMessageOf(msg),
+        command: def.id,
+        input,
+        receipt,
+        risk,
+        model
+      },
+      CONFIRMATION_TTL_MS
+    );
+  } catch (err2) {
+    console.warn(
+      `[route] ${msg.threadKey} confirmation store unreachable at mint, handing back: ${err2 instanceof Error ? err2.message : String(err2)}`
+    );
+    return { kind: "store_unreachable" };
+  }
+  return { kind: "offered", shown: { id: row2.id, line: line4, risk, expiresAt: row2.expiresAt } };
+}
+function redactedInput(input) {
+  const text = (s) => redactAndCap(redactSecrets(s), 200);
+  const leaf = (v) => {
+    if (typeof v === "string") return text(v);
+    if (typeof v === "number" || typeof v === "boolean" || v === null) return v;
+    return v === void 0 ? null : text(JSON.stringify(v) ?? String(v));
+  };
+  const leafOrList = (v) => Array.isArray(v) ? v.map(leaf) : leaf(v);
+  const isRecord11 = (v) => typeof v === "object" && v !== null && (Object.getPrototypeOf(v) === Object.prototype || Object.getPrototypeOf(v) === null);
+  const entries = (v, of) => Object.fromEntries(
+    Object.entries(v).filter(([, x]) => x !== void 0).map(([k, x]) => [k, of(x)])
+  );
+  const object1 = (v) => entries(v, leafOrList);
+  const object2 = (v) => entries(v, (x) => isRecord11(x) ? object1(x) : leafOrList(x));
+  const object3 = (v) => entries(v, (x) => isRecord11(x) ? object2(x) : leafOrList(x));
+  return {
+    ...input.args ? { args: input.args.map(leaf) } : {},
+    ...input.options ? { options: object3(input.options) } : {}
+  };
+}
+function routeReasonLabel(reason2, collapsed) {
+  return `${ROUTE_REASON_PREFIX} ${reason2}${collapsed ? ` (compound collapsed: ${collapsed.presets.join("+")})` : ""}`;
+}
+function routedPartLines(parts) {
+  return parts.map((p) => {
+    const line4 = p.text.replace(/\s+/g, " ").trim();
+    return `${p.preset}: ${line4.length > ROUTE_PART_LINE_CAP ? `${line4.slice(0, ROUTE_PART_LINE_CAP - 1)}\u2026` : line4}`;
+  });
+}
+function compoundBrief(text, parts) {
+  return [
+    text,
+    "",
+    `${COMPOUND_BRIEF_HEADING}: ${parts.length} independent parts. Spawn exactly these children \u2014 one \`spawn_run\` per part, on the preset named, with the part's text as the child's whole prompt (add the repository where the preset needs one) \u2014 then \`await_runs\` them all and compile one answer. Do not merge, drop or add a part.`,
+    ...parts.map((p, i) => `${i + 1}. \`${p.preset}\`: ${p.text}`)
+  ].join("\n");
+}
+var REASONING_COUNTING_CAP_FIELDS, REASONING_OUTPUT_TOKEN_ALLOWANCE, OutputCapError, ROUTE_REASON_CAP, ROUTE_MIN_OUTPUT_TOKENS, ROUTE_TIMEOUT_MS, ROUTE_PART_LINE_CAP, ROUTE_RECEIPT_CAP, ROUTED_RECEIPT_PREFIX, COMPOUND_BRIEF_HEADING, MultiToolCallError;
+var init_route = __esm({
+  "../../src/core/dispatch/route.ts"() {
+    "use strict";
+    init_registry();
+    init_handBack();
+    init_profile();
+    init_redact();
+    init_statusCardFrame();
+    init_commandRegistry();
+    init_commandSurface();
+    init_budgets();
+    init_confirmations();
+    REASONING_COUNTING_CAP_FIELDS = /* @__PURE__ */ new Set(["max_tokens", "max_completion_tokens", "max_output_tokens"]);
+    REASONING_OUTPUT_TOKEN_ALLOWANCE = 4096;
+    OutputCapError = class extends Error {
+      constructor(maxTokens) {
+        super(`answer cut at the output cap (${maxTokens} tokens)`);
+        this.maxTokens = maxTokens;
+        this.name = "OutputCapError";
+      }
+      maxTokens;
+    };
+    ROUTE_REASON_CAP = 120;
+    ROUTE_MIN_OUTPUT_TOKENS = 200;
+    ROUTE_TIMEOUT_MS = 8e3;
+    ROUTE_PART_LINE_CAP = 100;
+    ROUTE_RECEIPT_CAP = 300;
+    ROUTED_RECEIPT_PREFIX = "routed:";
+    COMPOUND_BRIEF_HEADING = "Routed as a compound request";
+    MultiToolCallError = class extends Error {
+      constructor(calls) {
+        super(`answer carried ${calls.length} tool calls; the route is one call`);
+        this.calls = calls;
+        this.name = "MultiToolCallError";
+      }
+      calls;
+    };
+  }
+});
+
 // ../../src/core/memory/reflection.ts
 import { z as z15 } from "zod";
 function shouldReflect(input) {
@@ -29288,13 +30020,14 @@ async function reflect(deps) {
     const seen = /* @__PURE__ */ new Set();
     const existing = [...await windowP, ...hits].filter((r) => !seen.has(r.id) && (seen.add(r.id), true));
     const text = buildReflectionInput({ history: deps.history, request: deps.request, answer: deps.answer, existing });
+    const maxTokens = outputCapWithReasoning(REFLECTION_MAX_TOKENS, { capField: deps.capField });
     let result;
     try {
       result = await deps.provider.complete({
         model: deps.model,
         system: REFLECTION_SYSTEM,
         messages: [{ role: "user", content: [{ type: "text", text }] }],
-        maxTokens: REFLECTION_MAX_TOKENS,
+        maxTokens,
         ...deps.effort !== void 0 ? { effort: deps.effort } : {},
         ...deps.effortWord !== void 0 ? { effortWord: deps.effortWord } : {}
       });
@@ -29303,13 +30036,17 @@ async function reflect(deps) {
       warn(`reflection skipped: ${renderProviderFailure(failure2.cause)}`);
       return;
     }
+    const truncated = result.stopReason === "max_tokens" ? `truncated at ${maxTokens} max tokens` : void 0;
+    if (truncated) {
+      warn(`reflection output rejected (${truncated}); nothing written`);
+      return;
+    }
     const reply = result.content.filter((p) => p.type === "text").map((p) => p.text).join("");
     const prov = { sourceThreadKey: deps.sourceThreadKey, sourceRunId: deps.sourceRunId };
     const parsed = parseReflection(reply, prov, new Set(existing.map((r) => r.id)));
-    const truncated = result.stopReason === "max_tokens" ? `truncated at ${REFLECTION_MAX_TOKENS} max tokens` : void 0;
-    const stopNote = truncated ?? (result.stopReason === "end_turn" ? void 0 : `stop: ${result.stopReason}`);
+    const stopNote = result.stopReason === "end_turn" ? void 0 : `stop: ${result.stopReason}`;
     if (!parsed.ok) {
-      const why = truncated ?? (stopNote ? `${parsed.error}; ${stopNote}` : parsed.error);
+      const why = stopNote ? `${parsed.error}; ${stopNote}` : parsed.error;
       warn(`reflection output rejected (${why}); nothing written`);
       return;
     }
@@ -29380,6 +30117,7 @@ var init_reflection = __esm({
     init_authz();
     init_runEvents();
     init_llmOutput();
+    init_route();
     init_engine();
     init_scorer();
     init_scope2();
@@ -29622,10 +30360,13 @@ function scheduleReflection(input) {
   const info = (m) => console.log(`[memory] ${input.threadKey} ${m}`);
   let provider;
   let model;
+  let capField;
   try {
-    const ref = parseModelRef(input.cfg.model ?? input.runModelRef);
+    const modelRef3 = input.cfg.model ?? input.runModelRef;
+    const ref = parseModelRef(modelRef3);
     provider = input.providers.get(ref.provider);
     model = ref.model;
+    capField = resolveModelCard(modelRef3, input.providerBlocks ?? {}, installedModelRegistry).capField;
   } catch (err2) {
     warn(`reflection skipped: ${err2 instanceof Error ? err2.message : String(err2)}`);
     return;
@@ -29637,6 +30378,7 @@ function scheduleReflection(input) {
       provider,
       model,
       ...effort2.request ? { effort: effort2.request.effort, effortWord: effort2.request.effortWord } : {},
+      ...capField !== void 0 ? { capField } : {},
       store: selectMemoryStore(input.cfg, input.store),
       scopeKeys: requestScopeKeys(input.organization, input.userId, { channelId: input.channelId, repo: input.repo }),
       actor: reflectionActor(input.actor, { channelId: input.channelId, repo: input.repo }),
@@ -29693,6 +30435,8 @@ var init_memory = __esm({
     "use strict";
     init_provider();
     init_turnEffort();
+    init_installedModelRegistry();
+    init_modelCard();
     init_scorer();
     init_scope2();
     init_stores();
@@ -31208,7 +31952,7 @@ ${line4}` : ""}`
 });
 
 // ../../src/core/reviewAbridge.ts
-import { resolve as resolve9 } from "node:path";
+import { resolve as resolve10 } from "node:path";
 function meatArtifactOf(record2) {
   return record2.events.find((e) => isReadingDiff(e) && e.poweredBy === "meat");
 }
@@ -31253,7 +31997,7 @@ function reviewAbridgerFromConfig(config, store, secrets, env, dataDir, warn) {
     github: () => github,
     meat: meatOnHost({
       apiKey: () => anthropicApiKey(config().providers, secrets),
-      cacheDir: resolve9(dataDir, "meat-cache"),
+      cacheDir: resolve10(dataDir, "meat-cache"),
       hostEnv: { PATH: env.PATH, HOME: env.HOME }
     }),
     defaultModel: () => {
@@ -31725,6 +32469,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,
@@ -31908,43 +32654,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 {
@@ -31981,6 +32690,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 } : {},
@@ -32019,6 +32730,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 } : {},
@@ -32116,7 +32829,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;
@@ -32136,7 +32849,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));
@@ -32146,7 +32859,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);
       })
@@ -32160,7 +32873,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;
     }
   };
@@ -32183,7 +32896,7 @@ function createRunsService(deps) {
         activity: row2.state === "waiting" ? `queued at position ${row2.position} \u2014 waiting on ${waiting2}` : 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;
     }
   };
@@ -32201,7 +32914,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 {};
     }
@@ -32246,12 +32959,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() });
@@ -32297,7 +33010,7 @@ function createRunsService(deps) {
           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" } };
@@ -32476,7 +33189,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;
@@ -32486,7 +33199,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;
@@ -34417,6 +35130,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 }));
@@ -34611,7 +35329,7 @@ var init_githubRepoInspect = __esm({
 });
 
 // ../../src/core/commandCatalogue.ts
-import { existsSync as existsSync12, readFileSync as readFileSync14 } from "node:fs";
+import { existsSync as existsSync13, readFileSync as readFileSync15 } from "node:fs";
 import { readFile as readFile2 } from "node:fs/promises";
 function unstampedStatus() {
   let version2 = "unknown";
@@ -34636,10 +35354,10 @@ function defaultOperations(config, secrets, caller) {
   return null;
 }
 function readSource(source2) {
-  return Promise.resolve(readFileSync14(source2 === "-" ? 0 : source2, "utf8"));
+  return Promise.resolve(readFileSync15(source2 === "-" ? 0 : source2, "utf8"));
 }
 async function readOptionalFile(path) {
-  return existsSync12(path) ? readFile2(path, "utf8") : void 0;
+  return existsSync13(path) ? readFile2(path, "utf8") : void 0;
 }
 function once(provided) {
   if (typeof provided !== "function") {
@@ -35116,232 +35834,6 @@ var init_trace = __esm({
   }
 });
 
-// ../../src/core/confirmations.ts
-import { randomUUID } from "node:crypto";
-import { existsSync as existsSync13, mkdirSync as mkdirSync9, readFileSync as readFileSync15, writeFileSync as writeFileSync8 } from "node:fs";
-import { dirname as dirname10, resolve as resolve10 } from "node:path";
-function newConfirmationId() {
-  return randomUUID();
-}
-function renderOffer(offer) {
-  if (offer.question) return `${offer.question.text}
-Did you mean:
-\`${offer.line}\`
-
-${offer.question.evidence}`;
-  return [offer.line, ...offer.risk ? [offer.risk] : []].join("\n");
-}
-function confirmationMessageOf(msg) {
-  const { images: _images, documents: _documents, staged: _staged, ...kept } = msg;
-  return kept;
-}
-function isRecord3(v) {
-  return typeof v === "object" && v !== null && !Array.isArray(v);
-}
-function isMessage(v) {
-  return isRecord3(v) && typeof v.channelId === "string" && typeof v.userId === "string" && typeof v.threadKey === "string" && typeof v.text === "string";
-}
-function isRunShape(v) {
-  return typeof v.id === "string" && isMessage(v.message) && typeof v.command === "string" && isRecord3(v.input) && typeof v.receipt === "string" && typeof v.risk === "string" && typeof v.model === "string";
-}
-function isRedispatchShape(v) {
-  return typeof v.id === "string" && isMessage(v.message) && typeof v.line === "string" && typeof v.evidence === "string" && typeof v.code === "string";
-}
-function parsePendingConfirmation(v) {
-  if (!isRecord3(v)) return void 0;
-  if (v.kind === "redispatch")
-    return isRedispatchShape(v) ? v : void 0;
-  if (v.kind !== void 0 && v.kind !== "run") return void 0;
-  return isRunShape(v) ? { ...v, kind: "run" } : void 0;
-}
-function parseConfirmation(v) {
-  if (!isRecord3(v) || typeof v.expiresAt !== "number") return void 0;
-  const pending2 = parsePendingConfirmation(v);
-  return pending2 ? { ...pending2, expiresAt: v.expiresAt } : void 0;
-}
-function isRefusal(v) {
-  return typeof v === "string" && CONFIRMATION_REFUSALS.includes(v);
-}
-function judge2(rows, id, actorIds, now, kind) {
-  const row2 = rows.get(id);
-  if (!row2) return { ok: false, refused: "used" };
-  if (kind === "consume" && row2.expiresAt <= now) {
-    rows.delete(id);
-    return { ok: false, refused: "expired", row: row2 };
-  }
-  if (!actorIds.includes(row2.message.userId))
-    return kind === "consume" ? { ok: false, refused: "foreign", row: row2 } : { ok: false, refused: "foreign" };
-  rows.delete(id);
-  return kind === "consume" ? { ok: true, row: row2 } : { ok: true };
-}
-function replaceThreadRow(rows, row2) {
-  for (const [id, r] of rows) if (r.message.threadKey === row2.message.threadKey) rows.delete(id);
-  rows.set(row2.id, row2);
-}
-function threadRowId(rows, threadKey) {
-  for (const [id, r] of rows) if (r.message.threadKey === threadKey) return id;
-  return void 0;
-}
-function buildConfirmationStore(config, secrets, opts) {
-  const worker = config.config.runtimeOverrides?.worker;
-  if (!worker) return new FileConfirmationStore(opts.path);
-  const tokenEnv = worker.tokenEnv ?? "MEMORY_TOKEN";
-  const token2 = secrets.named(tokenEnv);
-  if (!token2) throw new Error(`runtimeOverrides.worker is configured but ${tokenEnv} is not set`);
-  return new WorkerConfirmationStore({
-    baseUrl: worker.baseUrl,
-    token: token2.reveal(),
-    ...opts.fetch ? { fetch: opts.fetch } : {}
-  });
-}
-var CONFIRMATION_REFUSALS, UNSHOWABLE_LINE, STORE_UNREACHABLE_LINE, FileConfirmationStore, CONFIRMATION_WORKER_TIMEOUT_MS, WorkerConfirmationStore;
-var init_confirmations = __esm({
-  "../../src/core/confirmations.ts"() {
-    "use strict";
-    init_clock();
-    CONFIRMATION_REFUSALS = ["used", "expired", "foreign"];
-    UNSHOWABLE_LINE = "this command carries a value that cannot be shown, so no confirmation can be offered; nothing ran";
-    STORE_UNREACHABLE_LINE = "this command needs a confirmation click, and the confirmation store could not be reached; nothing ran \u2014 ask again for the button";
-    FileConfirmationStore = class {
-      path;
-      clock;
-      constructor(path, opts = {}) {
-        this.path = resolve10(path);
-        this.clock = opts.clock ?? systemClock;
-      }
-      read() {
-        const rows = /* @__PURE__ */ new Map();
-        if (!existsSync13(this.path)) return rows;
-        const raw = JSON.parse(readFileSync15(this.path, "utf8"));
-        for (const v of Array.isArray(raw.confirmations) ? raw.confirmations : []) {
-          const row2 = parseConfirmation(v);
-          if (row2) rows.set(row2.id, row2);
-        }
-        return rows;
-      }
-      write(rows) {
-        mkdirSync9(dirname10(this.path), { recursive: true });
-        writeFileSync8(this.path, JSON.stringify({ confirmations: [...rows.values()] }, null, 2));
-      }
-      async put(row2, ttlMs) {
-        const rows = this.read();
-        const stored = { ...row2, expiresAt: this.clock() + ttlMs };
-        replaceThreadRow(rows, stored);
-        this.write(rows);
-        return stored;
-      }
-      async consume(id, actorIds) {
-        const rows = this.read();
-        const out = judge2(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");
-        this.write(rows);
-        return out;
-      }
-      async cancelByThread(threadKey, actorIds) {
-        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");
-        this.write(rows);
-        return out;
-      }
-      async pendingByThread(threadKey) {
-        const rows = this.read();
-        const id = threadRowId(rows, threadKey);
-        const row2 = id === void 0 ? void 0 : rows.get(id);
-        if (!row2 || row2.expiresAt <= this.clock()) return void 0;
-        return row2;
-      }
-      describe() {
-        return `file ${this.path}`;
-      }
-    };
-    CONFIRMATION_WORKER_TIMEOUT_MS = 8e3;
-    WorkerConfirmationStore = class {
-      constructor(opts) {
-        this.opts = opts;
-        this.baseUrl = opts.baseUrl.replace(/\/+$/, "");
-        this.fetchImpl = opts.fetch ?? fetch;
-      }
-      opts;
-      baseUrl;
-      fetchImpl;
-      async put(row2, ttlMs) {
-        const body = await this.post("/config/confirmations/put", {
-          id: row2.id,
-          threadKey: row2.message.threadKey,
-          requester: row2.message.userId,
-          body: row2,
-          ttlMs
-        });
-        if (typeof body.expiresAt !== "number")
-          throw new Error("confirmation store answered a put without the expiry it stamped");
-        return { ...row2, expiresAt: body.expiresAt };
-      }
-      async consume(id, actorIds) {
-        const body = await this.post("/config/confirmations/consume", { id, actorIds });
-        const stored = isRecord3(body.row) ? body.row : void 0;
-        const row2 = parseConfirmation(
-          stored && isRecord3(stored.body) ? { ...stored.body, expiresAt: stored.expiresAt } : void 0
-        );
-        if (isRefusal(body.refused))
-          return { ok: false, refused: body.refused, ...row2 ? { row: row2 } : {} };
-        if (!row2) throw new Error("confirmation store answered a consume outside its contract");
-        return { ok: true, row: row2 };
-      }
-      async cancel(id, actorIds) {
-        const body = await this.post("/config/confirmations/cancel", { id, actorIds });
-        if (body.ok === true) return { ok: true };
-        if (body.refused === "used" || body.refused === "foreign") return { ok: false, refused: body.refused };
-        throw new Error("confirmation store answered a cancel outside its contract");
-      }
-      async cancelByThread(threadKey, actorIds) {
-        const body = await this.post("/config/confirmations/cancel-by-thread", { threadKey, actorIds });
-        if (body.ok === true) return { ok: true };
-        if (body.refused === "used" || body.refused === "foreign") return { ok: false, refused: body.refused };
-        throw new Error("confirmation store answered a cancel-by-thread outside its contract");
-      }
-      async pendingByThread(threadKey) {
-        const body = await this.post("/config/confirmations/pending-by-thread", { threadKey });
-        if (body.row === null) return void 0;
-        const stored = isRecord3(body.row) ? body.row : void 0;
-        const row2 = parseConfirmation(
-          stored && isRecord3(stored.body) ? { ...stored.body, expiresAt: stored.expiresAt } : void 0
-        );
-        if (!row2) throw new Error("confirmation store answered a pending-by-thread outside its contract");
-        return row2;
-      }
-      describe() {
-        return `state Worker ${this.baseUrl} (ConfigDO confirmations)`;
-      }
-      async post(path, payload2) {
-        let res;
-        try {
-          res = await this.fetchImpl(`${this.baseUrl}${path}`, {
-            method: "POST",
-            headers: { authorization: `Bearer ${this.opts.token}`, "content-type": "application/json" },
-            body: JSON.stringify(payload2),
-            signal: AbortSignal.timeout(CONFIRMATION_WORKER_TIMEOUT_MS)
-          });
-        } catch (err2) {
-          throw new Error(`confirmation store unreachable: ${err2 instanceof Error ? err2.message : String(err2)}`, {
-            cause: err2
-          });
-        }
-        if (!res.ok) throw new Error(`confirmation store answered HTTP ${res.status} on ${path}`);
-        const body = await res.json().catch(() => void 0);
-        if (!isRecord3(body)) throw new Error(`confirmation store returned a non-JSON body on ${path}`);
-        return body;
-      }
-    };
-  }
-});
-
 // ../../src/core/markdownDocument.ts
 function toMarkdownDocument(text) {
   return text.replace(/[\uE000\uE001]/g, "").split(/(```[\s\S]*?```)/g).map((seg, i) => i % 2 === 1 ? seg : hardBreaks(convertProse(seg))).join("");
@@ -35471,6 +35963,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":
@@ -36414,7 +36909,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
   );
@@ -36463,30 +36958,62 @@ function checkPrHeadPreflight(input) {
 async function guardAttachedHead(input) {
   const expected = normalizeHead(input.expectedHeadSha);
   if (!expected) return { outcome: "unverified" };
-  const attached = normalizeHead(input.attached.sha);
-  const source2 = input.attached.source ?? "workspace-observed";
   const where = `${input.pr.repo}#${input.pr.number}`;
-  const branch2 = input.attached.ref ?? input.fallbackRef;
-  const namedSource = source2 === "resident binding" ? branch2 ? `${source2} for ${branch2}` : source2 : branch2 ? `${source2} HEAD for ${branch2}` : `${source2} HEAD`;
-  if (!attached) {
-    console.log(`[review] ${input.logKey} not started: ${namedSource} unreadable, PR head ${expected} (${where})`);
+  const namedSource = (observed) => {
+    const source3 = observed.source ?? "workspace-observed";
+    const branch2 = observed.ref ?? input.fallbackRef;
+    return source3 === "resident binding" ? branch2 ? `${source3} for ${branch2}` : source3 : branch2 ? `${source3} HEAD for ${branch2}` : `${source3} HEAD`;
+  };
+  const first = normalizeHead(input.attached.sha);
+  if (first && sameCommit(expected, first)) return { outcome: "verified" };
+  if (first) {
+    const current = normalizeHead(await input.fetchPrHead(input.pr).catch(() => void 0));
+    if (current && sameCommit(first, current)) {
+      console.log(
+        `[review] ${input.logKey} PR head moved since resolution: ${expected} \u2192 ${current}; the ${namedSource(input.attached)} is at the current head \u2014 reviewing it (${where})`
+      );
+      return { outcome: "adopted", headSha: current };
+    }
+  }
+  let retried;
+  let reprovisionFailed = false;
+  try {
+    retried = await input.reprovision(expected);
+  } catch {
+    reprovisionFailed = true;
+    retried = { sha: void 0 };
+  }
+  const checked = normalizeHead(retried.sha);
+  if (checked && sameCommit(expected, checked)) {
+    console.log(`[review] ${input.logKey} workspace reprovisioned at reviewed head ${expected} (${where})`);
+    return { outcome: "verified" };
+  }
+  const initial = first ? `the initial ${namedSource(input.attached)} was at ${first}` : `the initial ${namedSource(input.attached)} could not be read`;
+  if (reprovisionFailed) {
+    console.log(
+      `[review] ${input.logKey} not started: ${initial}; reprovision failed before retry HEAD observation, expected reviewed head ${expected} (${where})`
+    );
     return {
       outcome: "refused",
-      reply: `\u{1F500} Review of ${where} not started: ${namedSource} could not be read, so the workspace cannot be verified against PR head ${expected}. This is a bug: the infrastructure failure was not retried automatically. It is not a finding, and nothing was posted to GitHub.`
+      reply: `\u{1F500} Review of ${where} not started: ${initial}, and the automatic reprovision failed before a retry HEAD could be observed; the expected reviewed head is ${expected}. It is not a finding, and nothing was posted to GitHub.`
     };
   }
-  if (sameCommit(expected, attached)) return { outcome: "verified" };
-  const current = normalizeHead(await input.fetchPrHead(input.pr).catch(() => void 0));
-  if (current && sameCommit(attached, current)) {
+  const source2 = namedSource(retried);
+  if (!checked) {
     console.log(
-      `[review] ${input.logKey} PR head moved since resolution: ${expected} \u2192 ${current}; the ${namedSource} is at the current head \u2014 reviewing it (${where})`
+      `[review] ${input.logKey} not started: ${initial}; ${source2} unreadable after reprovision, expected reviewed head ${expected} (${where})`
     );
-    return { outcome: "adopted", headSha: current };
+    return {
+      outcome: "refused",
+      reply: `\u{1F500} Review of ${where} not started: ${initial}, and the ${source2} could not be read after one automatic reprovision, so it could not be verified; the expected reviewed head is ${expected}. It is not a finding, and nothing was posted to GitHub.`
+    };
   }
-  console.log(`[review] ${input.logKey} not started: ${namedSource} ${attached}, PR head ${expected} (${where})`);
+  console.log(
+    `[review] ${input.logKey} not started: ${source2} ${checked} after reprovision, expected reviewed head ${expected} (${where})`
+  );
   return {
     outcome: "refused",
-    reply: `\u{1F500} Review of ${where} not started: the ${namedSource} is at ${attached}, but the PR head is ${expected} \u2014 the branch moved while the workspace was being prepared (a push or force-push). This is a bug: the workspace was not reprovisioned automatically at the new head. It is not a finding, and nothing was posted to GitHub.`
+    reply: `\u{1F500} Review of ${where} not started: after one automatic reprovision, the ${source2} is at ${checked}, but the expected reviewed head is ${expected}. It is not a finding, and nothing was posted to GitHub.`
   };
 }
 function makeSystemComposer(input) {
@@ -36964,14 +37491,19 @@ async function authorizePrHead(ctx) {
   }
   return { kind: "allowed" };
 }
+function reviewCheckoutFacts(repoCtx) {
+  return {
+    remote: `https://github.com/${repoCtx.repo}.git`,
+    helper: `!f() { test -n "$GH_TOKEN" || exit 1; printf '%s\\n' 'username=x-access-token' "password=$GH_TOKEN"; }; f`,
+    refspecs: [
+      "+HEAD:refs/remotes/origin/HEAD",
+      `+refs/pull/${repoCtx.pr}/head:refs/remotes/origin/pull/${repoCtx.pr}/head`,
+      ...repoCtx.baseRef ? [`+refs/heads/${repoCtx.baseRef}:refs/remotes/origin/${repoCtx.baseRef}`] : []
+    ]
+  };
+}
 function coldReviewCheckoutCommand(repoCtx) {
-  const remote = `https://github.com/${repoCtx.repo}.git`;
-  const helper = `!f() { test -n "$GH_TOKEN" || exit 1; printf '%s\\n' 'username=x-access-token' "password=$GH_TOKEN"; }; f`;
-  const refspecs = [
-    "+HEAD:refs/remotes/origin/HEAD",
-    `+refs/pull/${repoCtx.pr}/head:refs/remotes/origin/pull/${repoCtx.pr}/head`,
-    ...repoCtx.baseRef ? [`+refs/heads/${repoCtx.baseRef}:refs/remotes/origin/${repoCtx.baseRef}`] : []
-  ];
+  const { remote, helper, refspecs } = reviewCheckoutFacts(repoCtx);
   return [
     "set -eu",
     "find . -mindepth 1 -maxdepth 1 ! -name attachments -exec rm -rf -- {} +",
@@ -36981,6 +37513,15 @@ function coldReviewCheckoutCommand(repoCtx) {
     `git checkout --detach --force ${shellQuote(repoCtx.headSha)}`
   ].join("\n");
 }
+function seededReviewCheckoutCommand(repoCtx, workspace) {
+  const { helper, refspecs } = reviewCheckoutFacts(repoCtx);
+  const git2 = `git -C ${shellQuote(workspace)}`;
+  return [
+    "set -eu",
+    `${git2} -c credential.helper= -c credential.helper=${shellQuote(helper)} fetch --force --no-tags origin ${refspecs.map(shellQuote).join(" ")}`,
+    `${git2} checkout --detach --force ${shellQuote(repoCtx.headSha)}`
+  ].join("\n");
+}
 async function authorizeAttachedHead(deps, ctx) {
   const { msg, refuse: refuse3, card, shell, closeLines, clock: clock4, agent, resume, selection, root } = ctx;
   const { executor, resident, binding } = selection;
@@ -36991,7 +37532,6 @@ async function authorizeAttachedHead(deps, ctx) {
     const pr = { repo: repoCtx.repo, number: repoCtx.pr };
     const expectedHeadSha = repoCtx.headSha;
     const guard = await root.span("dispatch.gate.attached_head", async (span) => {
-      const source2 = resident && binding?.sha !== void 0 ? "resident binding" : "workspace-observed";
       const command2 = selection.seeded?.workspace ? `git -C ${shellQuote(selection.seeded.workspace)} rev-parse HEAD` : "git rev-parse HEAD";
       if (!resident && selection.seeded === void 0 && expectedHeadSha !== void 0) {
         await executor.exec(
@@ -36999,13 +37539,48 @@ async function authorizeAttachedHead(deps, ctx) {
           { timeoutMs: BASH_TIMEOUT_MAX_MS }
         );
       }
-      const sha = source2 === "resident binding" ? binding?.sha : await executor.exec(command2, { timeoutMs: 3e4 }).then(parseRevParseOutput).catch(() => void 0);
+      const observeHead = () => executor.exec(command2, { timeoutMs: 3e4, span }).then(parseRevParseOutput).catch(() => void 0);
+      const sha = await observeHead();
       const g = await guardAttachedHead({
         pr,
         expectedHeadSha,
-        attached: { sha, ref: binding?.ref ?? repoCtx.ref, source: source2 },
+        attached: { sha, ref: binding?.ref ?? repoCtx.ref, source: "workspace-observed" },
         fallbackRef: repoCtx.ref,
         fetchPrHead: deps.fetchPrHead ?? currentPrHeadSha,
+        reprovision: async (headSha) => {
+          if (executor.moveTo) {
+            await executor.moveTo(headSha, { span });
+            const observedSha = await observeHead();
+            if (selection.binding && observedSha !== void 0) {
+              selection.binding = {
+                ...selection.binding,
+                ref: repoCtx.ref ?? selection.binding.ref,
+                sha: observedSha
+              };
+            }
+            return {
+              sha: observedSha,
+              ref: repoCtx.ref,
+              source: "workspace-observed"
+            };
+          }
+          if (selection.seeded?.workspace) {
+            await executor.exec(
+              seededReviewCheckoutCommand(
+                { ...repoCtx, repo: pr.repo, pr: pr.number, headSha },
+                selection.seeded.workspace
+              ),
+              { timeoutMs: BASH_TIMEOUT_MAX_MS, span }
+            );
+          } else {
+            await executor.exec(coldReviewCheckoutCommand({ ...repoCtx, repo: pr.repo, pr: pr.number, headSha }), {
+              timeoutMs: BASH_TIMEOUT_MAX_MS,
+              span
+            });
+          }
+          const retried = await observeHead();
+          return { sha: retried, ref: repoCtx.ref, source: "workspace-observed" };
+        },
         logKey: msg.threadKey
       });
       span.setAttrs({ outcome: g.outcome });
@@ -37018,14 +37593,19 @@ async function authorizeAttachedHead(deps, ctx) {
       verifiedAtAttach = true;
       headAdopted = true;
     } else if (guard.outcome === "refused") {
-      await refuse3(refusalOf("branch_moved", guard.reply), async () => {
+      await refuse3(refusalOf("workspace_head_mismatch", guard.reply), async () => {
         if (executor.release) await executor.release("always").catch(() => {
         });
         await card.done(
-          shell.close({ kind: "not_started", icon: "\u{1F500}", reason: "branch moved", ...closeLines(clock4(), false) })
+          shell.close({
+            kind: "not_started",
+            icon: "\u{1F500}",
+            reason: "workspace head mismatch",
+            ...closeLines(clock4(), false)
+          })
         );
       });
-      return { kind: "refused", reason: "branch_moved" };
+      return { kind: "refused", reason: "workspace_head_mismatch" };
     }
   }
   return { kind: "allowed", repoCtx, verifiedAtAttach, headAdopted };
@@ -37418,6 +37998,10 @@ var init_threadAdmission = __esm({
       get size() {
         return this.pending.length;
       }
+      /** The ledger seqs of the follow-ups still pending, oldest first. */
+      get pendingSeqs() {
+        return this.pending.flatMap((input) => input.ledgerSeq !== void 0 ? [input.ledgerSeq] : []);
+      }
     };
     ThreadAdmission = class {
       live = /* @__PURE__ */ new Map();
@@ -38085,279 +38669,6 @@ var init_commandChat = __esm({
   }
 });
 
-// ../../src/core/dispatch/handBack.ts
-function renderHandBackLine(line4) {
-  return `${HAND_BACK_PREFIX}
-\`${line4}\``;
-}
-var HAND_BACK_PREFIX;
-var init_handBack = __esm({
-  "../../src/core/dispatch/handBack.ts"() {
-    "use strict";
-    HAND_BACK_PREFIX = "To run this:";
-  }
-});
-
-// ../../src/core/statusCardFrame.ts
-function activityText(activity) {
-  if (!activity) return void 0;
-  if (activity.kind === "line") return activity.text;
-  return `\u2192 $ ${activity.command.replace(/\s+/g, " ").trim()}`;
-}
-function createCardShell(opts) {
-  const verbosity2 = opts.verbosity ?? DEFAULT_VERBOSITY;
-  const notes = [];
-  let link = opts.link;
-  let frame2 = 0;
-  let finishedAt;
-  let setupLabel;
-  const lead = opts.lead ?? [];
-  const base = () => opts.model !== void 0 && shows(verbosity2, "verbose") ? `${opts.label} on \`${opts.model}\`` : opts.label;
-  const label = () => [base(), ...notes.filter((n2) => shows(verbosity2, n2.level)).map((n2) => n2.text)].join(" \xB7 ");
-  const elapsed2 = () => formatDuration((finishedAt ?? opts.now()) - opts.startedAt, "clock");
-  const headline = (icon) => `${icon} ${label()} \xB7 ${elapsed2()}`;
-  const closeDetail = (close, own) => [...shows(verbosity2, "debug") ? [close.shape, close.queued] : [], own].filter(Boolean).join("\n") || void 0;
-  return {
-    get label() {
-      return label();
-    },
-    note(level, text) {
-      notes.push({ level, text });
-    },
-    setLink(next) {
-      link = next;
-    },
-    freeze(at) {
-      finishedAt = at;
-    },
-    setSetupLabel(next) {
-      setupLabel = next;
-    },
-    ack() {
-      const detail = lead.join("\n");
-      return { title: `\u{1F440} ${label()} \xB7 preparing workspace\u2026`, ...detail ? { detail } : {} };
-    },
-    live(parts = {}) {
-      const glyph = SPINNER_GLYPHS[frame2++ % SPINNER_GLYPHS.length];
-      const detail = [...lead, ...parts.detail ?? []].filter(Boolean).join("\n");
-      return {
-        title: headline(glyph) + (setupLabel ? ` \u2014 ${setupLabel}` : "") + (parts.suffix ?? "") + (parts.notice ? ` \xB7 ${parts.notice}` : ""),
-        detail: detail || void 0,
-        ...parts.activity ? { activity: parts.activity } : {},
-        link
-      };
-    },
-    close(close) {
-      const detail = closeDetail(close, close.kind === "done" ? close.detail : void 0);
-      switch (close.kind) {
-        case "done":
-          return { title: headline(close.icon), detail, link };
-        case "not_started":
-          return { title: `${close.icon} ${label()} \xB7 not started (${close.reason}) \xB7 ${elapsed2()}`, detail };
-        case "refused":
-          return { title: `${close.icon} ${label()} \xB7 ${close.reason} \xB7 ${elapsed2()}`, detail };
-        case "setup_failed":
-          return { title: `\u274C setup failed \xB7 ${close.reason} \xB7 ${elapsed2()}`, detail };
-      }
-    }
-  };
-}
-var SPINNER_GLYPHS, LIVE_CARD_PREFIXES, ROUTE_REASON_PREFIX;
-var init_statusCardFrame = __esm({
-  "../../src/core/statusCardFrame.ts"() {
-    "use strict";
-    init_formatDuration();
-    init_verbosity();
-    SPINNER_GLYPHS = ["\u25D0", "\u25D3", "\u25D1", "\u25D2"];
-    LIVE_CARD_PREFIXES = [...SPINNER_GLYPHS, "\u{1F440}"];
-    ROUTE_REASON_PREFIX = "route reason:";
-  }
-});
-
-// ../../src/core/dispatch/route.ts
-function outputCapWithReasoning(visibleAnswerTokens, opts = {}) {
-  return opts.capField !== void 0 && REASONING_COUNTING_CAP_FIELDS.has(opts.capField) ? visibleAnswerTokens + REASONING_OUTPUT_TOKEN_ALLOWANCE : visibleAnswerTokens;
-}
-function outputCapRetry(current) {
-  return Math.max(current * 2, REASONING_OUTPUT_TOKEN_ALLOWANCE);
-}
-function routedRunsAtOnce(def, confirm, input) {
-  const radius = input === void 0 ? blastRadius(def) : boundBlastRadius(def, input);
-  return radius === "read" || CONFIRM_ORDER[radius] < CONFIRM_ORDER[confirm];
-}
-function routeReceipt(def, input) {
-  return redactAndCap(chatInvocation(def, input), ROUTE_RECEIPT_CAP);
-}
-function routablePresets() {
-  return Object.values(AGENTS).filter((a) => a.routable !== false).map(({ name, description, machine, identity: identity2, maxMinutes }) => ({
-    name,
-    description,
-    machine,
-    identity: identity2,
-    maxMinutes
-  }));
-}
-function routableCommands(commands) {
-  return commands.list().filter((cmd) => CommandRegistry.exposedTo(cmd, "chat")).map((cmd) => ({
-    id: cmd.id,
-    effect: cmd.effect,
-    def: cmd,
-    tool: { name: mcpToolName(cmd.id), description: cmd.describe, inputSchema: jsonSchemaFor(cmd) }
-  }));
-}
-function renderPresetTable(presets) {
-  const rows = presets.map(
-    (p) => `| \`${p.name}\` | ${oneLine(p.description)} | ${p.machine} | ${p.identity} | ${p.maxMinutes} min |`
-  );
-  return ["| name | what it does | machine | credential | budget |", "|---|---|---|---|---|", ...rows].join("\n");
-}
-function quoteRequest(text) {
-  const cap = 2e3;
-  const bent = text.replace(/<(\/?)request>/gi, "\u2039$1request\u203A");
-  if (bent.length <= cap) return bent;
-  return `${bent.slice(0, cap)}
-\u2026[truncated: ${bent.length - cap} more characters]`;
-}
-function providerStructuredModel(provider, model, opts = {}) {
-  const forced = (opts.answer ?? "tool") === "tool";
-  return async (prompt, call2) => {
-    const tools = [prompt.tool, ...prompt.tools ?? []];
-    const toolChoice = prompt.open ? void 0 : tools.length > 1 ? { type: "any" } : { type: "tool", name: prompt.tool.name };
-    const messages = [
-      { role: "user", content: [{ type: "text", text: prompt.user }] },
-      ...(prompt.retries ?? []).flatMap((r) => [
-        { role: "assistant", content: [{ type: "text", text: r.answer }] },
-        { role: "user", content: [{ type: "text", text: r.violation }] }
-      ])
-    ];
-    const result = await provider.complete({
-      model,
-      system: prompt.system,
-      messages,
-      maxTokens: call2.maxTokens,
-      signal: call2.signal,
-      // The caller's configured effort, card-decided (`turnEffort`): intake's
-      // `intake.effort` or the operator's `defaults.efforts.general`. Absent →
-      // the model's own default.
-      ...opts.effort ? { effort: opts.effort.effort, effortWord: opts.effort.effortWord } : {},
-      ...forced ? { tools, toolChoice } : {}
-    });
-    if (result.stopReason === "max_tokens") throw new OutputCapError(call2.maxTokens);
-    const calls = result.content.filter(
-      (p) => p.type === "tool_use"
-    );
-    if (calls.length > 1) throw new MultiToolCallError(calls.map((c) => ({ tool: c.name, input: c.input })));
-    if (calls.length === 1) return { tool: calls[0].name, input: calls[0].input };
-    return result.content.filter((p) => p.type === "text").map((p) => p.text).join("");
-  };
-}
-async function mintConfirmationOffer(args) {
-  const { io, store, msg, origin, def, input, receipt, model } = args;
-  if (!io.offer || !store) return { kind: "no_click" };
-  const line4 = chatInvocation(def, input);
-  if (redactSecrets(line4) !== line4) return { kind: "unshowable" };
-  const risk = def.annotations?.risk?.(input, origin) ?? "";
-  let row2;
-  try {
-    row2 = await store.put(
-      {
-        kind: "run",
-        id: newConfirmationId(),
-        message: confirmationMessageOf(msg),
-        command: def.id,
-        input,
-        receipt,
-        risk,
-        model
-      },
-      CONFIRMATION_TTL_MS
-    );
-  } catch (err2) {
-    console.warn(
-      `[route] ${msg.threadKey} confirmation store unreachable at mint, handing back: ${err2 instanceof Error ? err2.message : String(err2)}`
-    );
-    return { kind: "store_unreachable" };
-  }
-  return { kind: "offered", shown: { id: row2.id, line: line4, risk, expiresAt: row2.expiresAt } };
-}
-function redactedInput(input) {
-  const text = (s) => redactAndCap(redactSecrets(s), 200);
-  const leaf = (v) => {
-    if (typeof v === "string") return text(v);
-    if (typeof v === "number" || typeof v === "boolean" || v === null) return v;
-    return v === void 0 ? null : text(JSON.stringify(v) ?? String(v));
-  };
-  const leafOrList = (v) => Array.isArray(v) ? v.map(leaf) : leaf(v);
-  const isRecord11 = (v) => typeof v === "object" && v !== null && (Object.getPrototypeOf(v) === Object.prototype || Object.getPrototypeOf(v) === null);
-  const entries = (v, of) => Object.fromEntries(
-    Object.entries(v).filter(([, x]) => x !== void 0).map(([k, x]) => [k, of(x)])
-  );
-  const object1 = (v) => entries(v, leafOrList);
-  const object2 = (v) => entries(v, (x) => isRecord11(x) ? object1(x) : leafOrList(x));
-  const object3 = (v) => entries(v, (x) => isRecord11(x) ? object2(x) : leafOrList(x));
-  return {
-    ...input.args ? { args: input.args.map(leaf) } : {},
-    ...input.options ? { options: object3(input.options) } : {}
-  };
-}
-function routeReasonLabel(reason2, collapsed) {
-  return `${ROUTE_REASON_PREFIX} ${reason2}${collapsed ? ` (compound collapsed: ${collapsed.presets.join("+")})` : ""}`;
-}
-function routedPartLines(parts) {
-  return parts.map((p) => {
-    const line4 = p.text.replace(/\s+/g, " ").trim();
-    return `${p.preset}: ${line4.length > ROUTE_PART_LINE_CAP ? `${line4.slice(0, ROUTE_PART_LINE_CAP - 1)}\u2026` : line4}`;
-  });
-}
-function compoundBrief(text, parts) {
-  return [
-    text,
-    "",
-    `${COMPOUND_BRIEF_HEADING}: ${parts.length} independent parts. Spawn exactly these children \u2014 one \`spawn_run\` per part, on the preset named, with the part's text as the child's whole prompt (add the repository where the preset needs one) \u2014 then \`await_runs\` them all and compile one answer. Do not merge, drop or add a part.`,
-    ...parts.map((p, i) => `${i + 1}. \`${p.preset}\`: ${p.text}`)
-  ].join("\n");
-}
-var REASONING_COUNTING_CAP_FIELDS, REASONING_OUTPUT_TOKEN_ALLOWANCE, OutputCapError, ROUTE_REASON_CAP, ROUTE_MIN_OUTPUT_TOKENS, ROUTE_TIMEOUT_MS, ROUTE_PART_LINE_CAP, ROUTE_RECEIPT_CAP, ROUTED_RECEIPT_PREFIX, COMPOUND_BRIEF_HEADING, MultiToolCallError;
-var init_route = __esm({
-  "../../src/core/dispatch/route.ts"() {
-    "use strict";
-    init_registry();
-    init_handBack();
-    init_profile();
-    init_redact();
-    init_statusCardFrame();
-    init_commandRegistry();
-    init_commandSurface();
-    init_budgets();
-    init_confirmations();
-    REASONING_COUNTING_CAP_FIELDS = /* @__PURE__ */ new Set(["max_tokens", "max_completion_tokens", "max_output_tokens"]);
-    REASONING_OUTPUT_TOKEN_ALLOWANCE = 4096;
-    OutputCapError = class extends Error {
-      constructor(maxTokens) {
-        super(`answer cut at the output cap (${maxTokens} tokens)`);
-        this.maxTokens = maxTokens;
-        this.name = "OutputCapError";
-      }
-      maxTokens;
-    };
-    ROUTE_REASON_CAP = 120;
-    ROUTE_MIN_OUTPUT_TOKENS = 200;
-    ROUTE_TIMEOUT_MS = 8e3;
-    ROUTE_PART_LINE_CAP = 100;
-    ROUTE_RECEIPT_CAP = 300;
-    ROUTED_RECEIPT_PREFIX = "routed:";
-    COMPOUND_BRIEF_HEADING = "Routed as a compound request";
-    MultiToolCallError = class extends Error {
-      constructor(calls) {
-        super(`answer carried ${calls.length} tool calls; the route is one call`);
-        this.calls = calls;
-        this.name = "MultiToolCallError";
-      }
-      calls;
-    };
-  }
-});
-
 // ../../src/core/runRegistry/runControl.ts
 var RunControl;
 var init_runControl = __esm({
@@ -38484,6 +38795,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 } : {},
@@ -38519,7 +38832,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) {
@@ -38603,6 +38918,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;
@@ -38676,6 +38992,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 } : {} };
       }
@@ -38764,6 +39084,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
@@ -41765,6 +42111,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;
@@ -41937,22 +42324,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);
@@ -41972,7 +42361,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,
@@ -41984,7 +42373,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,
@@ -42016,7 +42405,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(
@@ -42030,12 +42419,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 {
@@ -42111,8 +42500,8 @@ 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 ownPr = ownPrOf(repoCtx);
+  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, {
       parent: span,
@@ -42147,7 +42536,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
@@ -42204,10 +42593,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 } : {}
@@ -42374,7 +42763,6 @@ var init_provision = __esm({
     init_factory();
     init_executor();
     init_residentTrace();
-    init_displayNames();
     init_resident();
     init_memory();
     init_budgets();
@@ -42387,12 +42775,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();
@@ -45718,6 +46108,18 @@ function decisionRecordTaskKey(...parts) {
   }
   return hash.toString(16).padStart(16, "0");
 }
+function durableDecisionRecordReservation(store) {
+  return async (repo, taskKey, claimed2, existing) => {
+    try {
+      const reserved = await store.reserveDecisionRecord(repo, taskKey, claimed2, existing);
+      if (!reserved.ok) throw new DecisionRecordReservationUnavailableError();
+      return reserved.number;
+    } catch (error) {
+      if (error instanceof DecisionRecordReservationUnavailableError) throw error;
+      throw new DecisionRecordReservationUnavailableError();
+    }
+  };
+}
 var DECISION_RECORD_ENV, RECORD_MARKER, POSITIVE_RECORD_INSTRUCTION, NEGATED_INSTRUCTION, DECISION_RECORD_STORE_REFUSAL, DecisionRecordReservationUnavailableError, DecisionRecordAllocator;
 var init_decisionRecordReservation = __esm({
   "../../src/core/decisionRecordReservation.ts"() {
@@ -48601,6 +49003,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
@@ -48614,6 +49021,11 @@ var init_mirror = __esm({
       compactionRows = [];
       /** The highest ledger inbox seq folded in so far (run-history item 40). */
       inboxConsumedSeq = 0;
+      /** The owed seqs the cursor has already passed, ascending; absent when none. */
+      inboxDeferred() {
+        const deferred = [...new Set(this.deps.owedInboxSeqs?.() ?? [])].filter((seq) => seq <= this.inboxConsumedSeq).sort((a, b) => a - b);
+        return deferred.length > 0 ? { inboxDeferredSeqs: deferred } : {};
+      }
       /** Whether a report is owed: the mirror is wired and something happened. */
       get wired() {
         return this.deps.onStep !== void 0;
@@ -48702,8 +49114,11 @@ var init_mirror = __esm({
           turn,
           iteration: this.iteration++,
           remainingMs: Math.max(0, this.deps.remainingMs()),
-          inboxConsumedSeq: this.inboxConsumedSeq
+          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);
@@ -48729,8 +49144,11 @@ var init_mirror = __esm({
           turn,
           iteration: this.iteration,
           remainingMs: Math.max(0, this.deps.remainingMs()),
-          inboxConsumedSeq: this.inboxConsumedSeq
+          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 });
@@ -48738,6 +49156,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()
+        });
+      }
     };
   }
 });
@@ -49813,6 +50247,7 @@ async function runPiHarnessOpen(deps, run2) {
   let paths;
   let requeueUnechoed = () => {
   };
+  let unechoedSeqs = () => [];
   let dropHeld = () => {
   };
   let loopEnded = false;
@@ -49847,7 +50282,10 @@ async function runPiHarnessOpen(deps, run2) {
     onStep: run2.onStep,
     seedLength: run2.resume ? run2.resume.messages.length + (run2.resume.compactions?.length ?? 0) : run2.messages.length,
     remainingMs: () => deadline - now(),
-    ...tail ? { mirroredTail: tail } : {}
+    ...tail ? { mirroredTail: tail } : {},
+    // The rows pi has not read yet: the cursor can pass one when a later row
+    // is consumed first (the plane's provider-up beside an ordinary steer).
+    owedInboxSeqs: () => [...run2.inbox?.pendingSeqs ?? [], ...unechoedSeqs()]
   });
   mirror.inboxConsumedSeq = run2.resume?.inboxConsumedSeq ?? 0;
   placed = (event) => {
@@ -50254,6 +50692,7 @@ async function runPiHarnessOpen(deps, run2) {
       const [echoed] = unechoed.splice(at, 1);
       if (echoed.seq > mirror.inboxConsumedSeq) mirror.inboxConsumedSeq = echoed.seq;
     };
+    unechoedSeqs = () => unechoed.flatMap((u) => u.inputs.flatMap((i) => i.ledgerSeq !== void 0 ? [i.ledgerSeq] : []));
     requeueUnechoed = () => {
       pendingReissue = [];
       run2.inbox?.requeue(unechoed.splice(0).flatMap((u) => u.inputs));
@@ -50262,6 +50701,7 @@ async function runPiHarnessOpen(deps, run2) {
     let parkSettled = false;
     let pendingReissue = [];
     let reissueInFlight;
+    let reissueInFlightRows = [];
     let reissues = 0;
     let providerRetryReady = false;
     let providerRetryWait;
@@ -50274,20 +50714,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 });
     };
@@ -50548,16 +50989,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();
           }
         }
@@ -50566,7 +51020,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;
@@ -50923,10 +51386,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();
               }
             }
@@ -50935,7 +51401,15 @@ ${stagedLine}` : prompt;
               if (obs.response.success === false) {
                 turnParkSettled = false;
                 note("harness_error", "the follow-up turn's model retry prompt was refused; the failure remains held");
-              } else clearTurnProviderHold();
+              } else {
+                drainTurnReissues();
+                mirror.inboxConsumedSeq = Math.max(
+                  mirror.inboxConsumedSeq,
+                  ...turnReissueRows.map((item) => item.ledgerSeq ?? 0)
+                );
+                await mirror.checkpointInbox();
+                clearTurnProviderHold();
+              }
             }
           }
           if (obs.response?.id === id && obs.response.success === false)
@@ -52266,6 +52740,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;
@@ -52339,13 +52814,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) {
@@ -52365,6 +52838,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({
@@ -52387,14 +52901,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"}`);
@@ -52466,10 +52980,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(
@@ -52543,12 +53058,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 = () => {
@@ -52563,8 +53078,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,
@@ -52582,7 +53097,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
@@ -53028,7 +53543,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)),
@@ -53037,7 +53552,7 @@ 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()
@@ -53073,7 +53588,7 @@ async function runLoop(deps, ctx) {
             }
           } : {},
           descriptionTurnRan,
-          publish: (e) => registry.publish(run2.id, e),
+          publish: (event) => events.publish(event),
           logKey: msg.threadKey
         })
       );
@@ -53111,7 +53626,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
         })
       );
@@ -53122,7 +53637,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)
@@ -53131,7 +53646,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),
@@ -53140,13 +53655,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),
@@ -53161,12 +53676,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 }
@@ -53299,10 +53851,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();
@@ -54254,6 +54809,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;
@@ -54324,7 +54907,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,
@@ -54432,6 +55031,8 @@ var init_ship = __esm({
     init_runFriction();
     init_run2();
     init_runRegistry();
+    init_runLiveState();
+    init_pipelineStanding();
     init_statusCardFrame();
     init_types5();
     init_refusal();
@@ -55611,12 +56212,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}`,
@@ -55631,7 +56232,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)
@@ -55642,7 +56243,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;
@@ -55674,7 +56275,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(
@@ -55688,6 +56289,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, {
@@ -55707,7 +56402,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") {
@@ -55759,6 +56455,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 });
@@ -55940,6 +56647,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,
@@ -55981,6 +56694,7 @@ async function dispatch(deps, msg, io, opts = {}) {
       mcpForRun,
       run: run2,
       registry,
+      events,
       round: round2,
       admitted,
       ledgerRun,
@@ -56309,6 +57023,8 @@ var init_dispatcher = __esm({
     init_registry();
     init_budgets();
     init_trace();
+    init_runLiveState();
+    init_decide();
     init_requestTrace();
     init_runShape();
     init_runEvents();
@@ -56806,6 +57522,7 @@ function createLedgerWriteThrough(opts) {
         turnIndex: report2.firstIdx + turns.length,
         inFlight: report2.inFlight,
         inboxConsumedSeq: report2.inboxConsumedSeq,
+        ...report2.inboxDeferredSeqs?.length ? { inboxDeferredSeqs: report2.inboxDeferredSeqs } : {},
         remainingMs: report2.remainingMs,
         turn: report2.turn,
         iteration: report2.iteration
@@ -56839,7 +57556,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;
@@ -56860,6 +57577,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 };
@@ -57244,6 +57985,9 @@ var init_writeThrough = __esm({
       }
       event(_event, _seq) {
       }
+      async assignLiveState(_assignment) {
+        return { ok: false, reason: "unknown-run" };
+      }
       setState(_patch) {
       }
       async finishing() {
@@ -63023,14 +63767,23 @@ var init_configBoot = __esm({
 });
 
 // ../../src/intakeModel.ts
+function intakeDecisionDeps(completion, deps) {
+  return {
+    model: completion.model,
+    ...completion.capField !== void 0 ? { capField: completion.capField } : {},
+    ...deps
+  };
+}
 function intakeCompletion(config, completions, log = console.log) {
   const modelRef3 = intakeModelRef(config);
   if (!modelRef3) return void 0;
   const ref = parseModelRef(modelRef3);
+  const card = resolveModelCard(modelRef3, config.providers, installedModelRegistry);
   const effort2 = turnEffort(modelRef3, config.intake?.effort, config.providers);
   if (effort2.note) log(`[intake] effort: ${effort2.note}`);
   return {
     modelRef: modelRef3,
+    capField: card.capField,
     model: providerStructuredModel(completions.get(ref.provider), ref.model, {
       ...effort2.request ? { effort: effort2.request } : {}
     })
@@ -63042,6 +63795,8 @@ var init_intakeModel = __esm({
     init_config2();
     init_route();
     init_turnEffort();
+    init_installedModelRegistry();
+    init_modelCard();
     init_provider();
   }
 });
@@ -63164,7 +63919,10 @@ async function askModel(input, deps) {
         floor: (violation) => ({ verdict: "silent", reason: violation, source: "error" })
       },
       deps.model,
-      { maxTokens: ROUTE_MIN_OUTPUT_TOKENS, signal: AbortSignal.timeout(deps.timeoutMs ?? ROUTE_TIMEOUT_MS) }
+      {
+        maxTokens: outputCapWithReasoning(ROUTE_MIN_OUTPUT_TOKENS, { capField: deps.capField }),
+        signal: AbortSignal.timeout(deps.timeoutMs ?? ROUTE_TIMEOUT_MS)
+      }
     );
     return { ...seam.value, attempts: seam.attempts };
   } catch (err2) {
@@ -63173,8 +63931,18 @@ async function askModel(input, deps) {
     if (timedOut) {
       return {
         verdict: "silent",
-        reason: tidyReason("the intake call timed out"),
+        reason: renderProviderFailure("transient", "ended"),
         source: "timeout",
+        providerFailure: "transient",
+        ...attempts ? { attempts } : {}
+      };
+    }
+    const outputCapError = err2 instanceof OutputCapError ? err2 : err2 instanceof StructuredAskError && err2.cause instanceof OutputCapError ? err2.cause : void 0;
+    if (outputCapError) {
+      return {
+        verdict: "silent",
+        reason: tidyReason(outputCapError.message),
+        source: "error",
         ...attempts ? { attempts } : {}
       };
     }
@@ -70068,7 +70836,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,
@@ -70509,6 +71283,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 = {};
@@ -71018,7 +71858,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) {
@@ -71142,8 +71982,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 };
@@ -71213,7 +72053,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 }),
@@ -71222,7 +72062,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) {
@@ -71232,7 +72072,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`
       );
@@ -71240,7 +72080,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);
@@ -71424,6 +72264,25 @@ async function childPullRequestState(deps, instance, unit) {
   if (state === void 0) throw new Error(headBranchStateError(instance.repo, row2.pr.number));
   return state;
 }
+async function isEarlierAttemptRun(deps, current, view, unit) {
+  if (current?.plan === void 0 || view.parentInstanceId === void 0 || unit === void 0) return false;
+  if (unitOfIdempotencyKey(view.idempotencyKey ?? "") !== unit) return false;
+  const prior = await deps.instances.get(view.parentInstanceId);
+  if (prior?.plan === void 0) return false;
+  const currentAttempt = current.attempt ?? 1;
+  const priorAttempt = prior.attempt ?? 1;
+  if (currentAttempt <= priorAttempt || current.plan.id !== prior.plan.id || current.plan.path !== prior.plan.path || current.repo !== prior.repo)
+    return false;
+  const [nextAttempt, currentUnits, priorUnits] = await Promise.all([
+    deps.instances.get(planInstanceId(current.plan.id, currentAttempt + 1)),
+    deps.instances.listUnits(current.id),
+    deps.instances.listUnits(prior.id)
+  ]);
+  if (nextAttempt !== null) return false;
+  const currentUnit = currentUnits.find((row2) => row2.unit === unit);
+  const priorUnit = priorUnits.find((row2) => row2.unit === unit);
+  return currentUnit !== void 0 && priorUnit !== void 0 && currentUnit.branch === priorUnit.branch;
+}
 async function readRecord(body, deps) {
   const id = parseInstanceId(body.parentInstanceId);
   if (!id.ok) return json3(400, { ok: false, error: id.error });
@@ -71432,15 +72291,16 @@ async function readRecord(body, deps) {
   if (body.unit !== void 0 && (typeof body.unit !== "string" || !UNIT_ID.test(body.unit)))
     return json3(400, { ok: false, error: "unit must be a unit id" });
   const at = (deps.clock ?? systemClock)();
-  const res = await deps.runs.getRun(body.runId);
-  if (!res.ok || res.value.parentInstanceId !== id.value) return json3(404, { ok: false, error: "not_found" });
+  const [res, instanceRow] = await Promise.all([deps.runs.getRun(body.runId), deps.instances.get(id.value)]);
+  if (!res.ok) return json3(404, { ok: false, error: "not_found" });
   const view = res.value;
-  const instanceRow = await deps.instances.get(id.value);
+  if (view.parentInstanceId !== id.value && !await isEarlierAttemptRun(deps, instanceRow, view, typeof body.unit === "string" ? body.unit : void 0))
+    return json3(404, { ok: false, error: "not_found" });
   let pullRequest;
   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, {
@@ -71756,7 +72616,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;
         });
@@ -71780,7 +72640,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) {
@@ -71793,14 +72653,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;
@@ -71886,7 +72800,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,
@@ -71935,7 +72849,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) {
@@ -72016,7 +72930,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,
@@ -72050,7 +72964,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 });
 }
@@ -72224,7 +73138,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 });
 }
@@ -72287,7 +73201,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,
@@ -72318,7 +73232,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 = {
@@ -72336,7 +73250,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)(
@@ -72353,7 +73267,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)}`
       );
     }
   }
@@ -72367,7 +73281,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)}`
       )
     );
   }
@@ -72378,7 +73292,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)}`
       )
     );
   }
@@ -72440,7 +73354,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) {
@@ -72478,7 +73392,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 });
@@ -72604,7 +73518,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(
@@ -72621,7 +73535,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();
@@ -72732,13 +73646,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(() => {
@@ -72900,13 +73855,13 @@ 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";
@@ -72953,7 +73908,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;
@@ -73824,11 +74779,7 @@ async function runBot() {
   const coordinatorInstances = buildCoordinatorInstanceStore(runHistoryCfg, processSecrets);
   const decisionRecordAllocator = new DecisionRecordAllocator(
     fetchDecisionRecordClaims,
-    async (repo, taskKey, claimed2, existing) => {
-      const reserved = await coordinatorInstances.reserveDecisionRecord(repo, taskKey, claimed2, existing);
-      if (!reserved.ok) throw new DecisionRecordReservationUnavailableError();
-      return reserved.number;
-    }
+    durableDecisionRecordReservation(coordinatorInstances)
   );
   let planeAdmitPass;
   const planeEffectExecutor = {
@@ -74100,9 +75051,7 @@ async function runBot() {
       slackIntake = wireIntakeGate({
         intakeModeFor: (threadKey, userId, channelId) => config.intakeModeFor(threadKey, userId, channelId),
         deps: {
-          model: intake.model,
-          ledger: intakeLedger,
-          now: systemClock
+          ...intakeDecisionDeps(intake, { ledger: intakeLedger, now: systemClock })
         },
         modelRef: intake.modelRef,
         gen: PROCESS_STARTED_AT,
@@ -74194,6 +75143,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,
@@ -74202,17 +75158,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 });
@@ -74956,6 +75906,7 @@ var init_index = __esm({
     init_adminModelProxy();
     init_modelProxy();
     init_runBearers();
+    init_providerLiveStateCoordinator();
     init_piHarness();
     init_harness2();
     init_relay();