@coreplane/switchboard 1.260.6 → 1.261.0

package/dist/cli.js

@@ -4078,6 +4078,7 @@ function isHeadMaterial(event) {
     case "context":
     case "reference":
     case "run_meta":
+    case "run_state":
     case "route":
       return true;
     case "run_note":
@@ -4847,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;
     }
@@ -4929,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 };
@@ -5882,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;
 }
@@ -6008,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",
@@ -16134,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
@@ -16300,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)) {
@@ -16348,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");
@@ -16393,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
@@ -16700,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) ? {
@@ -18413,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,
@@ -18595,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 {
@@ -25400,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 = [];
@@ -25465,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":
@@ -25487,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);
   }
 });
 
@@ -32237,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,
@@ -32420,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 {
@@ -32493,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 } : {},
@@ -32531,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 } : {},
@@ -32628,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;
@@ -32648,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));
@@ -32658,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);
       })
@@ -32672,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;
     }
   };
@@ -32695,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;
     }
   };
@@ -32713,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 {};
     }
@@ -32758,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() });
@@ -32809,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" } };
@@ -32988,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;
@@ -32998,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;
@@ -34929,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 }));
@@ -35757,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":
@@ -36700,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
   );
@@ -38586,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 } : {},
@@ -38621,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) {
@@ -38705,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;
@@ -38778,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 } : {} };
       }
@@ -38866,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
@@ -41867,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;
@@ -42039,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);
@@ -42074,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,
@@ -42086,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,
@@ -42118,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(
@@ -42132,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 {
@@ -42213,7 +42500,7 @@ async function reserveRun(deps, ctx) {
 }
 async function attachRound(deps, ctx) {
   const { threadKey, agent, profile, repoCtx, root, clock: clock4, reattach, stopSignal, remainingMs, requester } = ctx;
-  const { onSetupNote } = ctx;
+  const { onLiveStateObservation } = ctx;
   const ownPr = agent.name === "review" ? void 0 : ownPrOf(repoCtx);
   return root.span("dispatch.workspace.attach", async (span) => {
     const graft = (steps, residentTotalMs) => graftResidentSteps(steps, {
@@ -42249,7 +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
@@ -42306,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 } : {}
@@ -42476,7 +42763,6 @@ var init_provision = __esm({
     init_factory();
     init_executor();
     init_residentTrace();
-    init_displayNames();
     init_resident();
     init_memory();
     init_budgets();
@@ -42489,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();
@@ -48715,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
@@ -48824,6 +49117,8 @@ var init_mirror = __esm({
           inboxConsumedSeq: this.inboxConsumedSeq,
           ...this.inboxDeferred()
         };
+        this.lastTurn = report2.turn;
+        this.lastIteration = report2.iteration;
         this.idx += turns.length;
         this.lastAssistantIdx = this.idx - 1;
         this.rows.push(...turns);
@@ -48852,6 +49147,8 @@ var init_mirror = __esm({
           inboxConsumedSeq: this.inboxConsumedSeq,
           ...this.inboxDeferred()
         };
+        this.lastTurn = report2.turn;
+        this.lastIteration = report2.iteration;
         this.idx += turns.length + 1;
         this.rows.push(...turns);
         this.compactionRows.push({ before: this.rows.length, entry });
@@ -48859,6 +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()
+        });
+      }
     };
   }
 });
@@ -50388,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;
@@ -50400,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 });
     };
@@ -50674,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();
           }
         }
@@ -50692,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;
@@ -51049,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();
               }
             }
@@ -51067,6 +51407,7 @@ ${stagedLine}` : prompt;
                   mirror.inboxConsumedSeq,
                   ...turnReissueRows.map((item) => item.ledgerSeq ?? 0)
                 );
+                await mirror.checkpointInbox();
                 clearTurnProviderHold();
               }
             }
@@ -52399,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;
@@ -52472,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) {
@@ -52498,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({
@@ -52520,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"}`);
@@ -52599,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(
@@ -52676,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 = () => {
@@ -52696,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,
@@ -52715,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
@@ -53161,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)),
@@ -53170,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()
@@ -53206,7 +53588,7 @@ async function runLoop(deps, ctx) {
             }
           } : {},
           descriptionTurnRan,
-          publish: (e) => registry.publish(run2.id, e),
+          publish: (event) => events.publish(event),
           logKey: msg.threadKey
         })
       );
@@ -53244,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
         })
       );
@@ -53255,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)
@@ -53264,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),
@@ -53273,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),
@@ -53294,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 }
@@ -53432,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();
@@ -54387,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;
@@ -54457,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,
@@ -54565,6 +55031,8 @@ var init_ship = __esm({
     init_runFriction();
     init_run2();
     init_runRegistry();
+    init_runLiveState();
+    init_pipelineStanding();
     init_statusCardFrame();
     init_types5();
     init_refusal();
@@ -55744,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}`,
@@ -55764,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)
@@ -55775,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;
@@ -55807,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(
@@ -55821,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, {
@@ -55840,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") {
@@ -55892,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 });
@@ -56073,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,
@@ -56114,6 +56694,7 @@ async function dispatch(deps, msg, io, opts = {}) {
       mcpForRun,
       run: run2,
       registry,
+      events,
       round: round2,
       admitted,
       ledgerRun,
@@ -56442,6 +57023,8 @@ var init_dispatcher = __esm({
     init_registry();
     init_budgets();
     init_trace();
+    init_runLiveState();
+    init_decide();
     init_requestTrace();
     init_runShape();
     init_runEvents();
@@ -56973,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;
@@ -56994,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 };
@@ -57378,6 +57985,9 @@ var init_writeThrough = __esm({
       }
       event(_event, _seq) {
       }
+      async assignLiveState(_assignment) {
+        return { ok: false, reason: "unknown-run" };
+      }
       setState(_patch) {
       }
       async finishing() {
@@ -70226,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,
@@ -70667,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 = {};
@@ -71176,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) {
@@ -71300,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 };
@@ -71371,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 }),
@@ -71380,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) {
@@ -71390,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`
       );
@@ -71398,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);
@@ -71618,7 +72300,7 @@ async function readRecord(body, deps) {
   try {
     pullRequest = await childPullRequestState(deps, instanceRow, typeof body.unit === "string" ? body.unit : void 0);
   } catch (err2) {
-    return json3(502, { ok: false, error: "github_unavailable", message: describe11(err2), at });
+    return json3(502, { ok: false, error: "github_unavailable", message: describe12(err2), at });
   }
   if (!view.finished)
     return json3(200, {
@@ -71934,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;
         });
@@ -71958,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) {
@@ -71971,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;
@@ -72064,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,
@@ -72113,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) {
@@ -72194,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,
@@ -72228,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 });
 }
@@ -72402,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 });
 }
@@ -72465,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,
@@ -72496,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 = {
@@ -72514,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)(
@@ -72531,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)}`
       );
     }
   }
@@ -72545,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)}`
       )
     );
   }
@@ -72556,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)}`
       )
     );
   }
@@ -72618,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) {
@@ -72656,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 });
@@ -72782,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(
@@ -72799,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();
@@ -72910,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(() => {
@@ -73078,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";
@@ -73131,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;
@@ -74366,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,
@@ -74374,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 });
@@ -75128,6 +75906,7 @@ var init_index = __esm({
     init_adminModelProxy();
     init_modelProxy();
     init_runBearers();
+    init_providerLiveStateCoordinator();
     init_piHarness();
     init_harness2();
     init_relay();