@coreplane/switchboard 1.260.5 → 1.261.0

package/dist/assets/deploy/cloudflare-memory/worker.ts

@@ -76,6 +76,7 @@ import {
   phaseTransition,
   reclaimPhase,
   selectReclaim,
+  unreadInbox,
 } from "../../src/core/runLedger/decisions.ts";
 import { INTAKE_DELIVERY_CLAIM_MS, intakeReceiptRetentionMs, minutesToMs, PLANE } from "../../src/core/budgets.ts";
 import { PROVIDER_FAILURE_CAUSES, type ProviderFailureCause } from "../../src/core/provider.ts";
@@ -133,6 +134,8 @@ import {
   type IntakeWriteResult,
   type LivePhase,
   type LiveRunRow,
+  type LiveStateAssignRequest,
+  type LiveStateAssignResult,
   type ReclaimedRun,
   type RunState,
   type SessionHit,
@@ -153,6 +156,7 @@ import { isRunMetricsPoint, pointTurnsFinal, type RunMetricsPoint } from "../../
 import { AnalyticsEngineSink, NullSink, type RunMetricsSink } from "./runMetricsSink.ts";
 import { injectedBuildStamp } from "../../src/deploy/buildStamp.ts";
 import { systemClock } from "../../src/core/trace/clock.ts";
+import { assignRunLiveState } from "../../src/core/runLiveState.ts";
 import { createTracer } from "../../src/core/trace/tracer.ts";
 import { startAdoptedRoot, workerLogSink } from "../../src/core/trace/workerTrace.ts";
 
@@ -1538,6 +1542,9 @@ type LiveRow = {
 };
 
 function rowToLive(r: LiveRow): LiveRunRow {
+  const state = JSON.parse(r.state_json) as RunState;
+  const liveState = state.liveState as LiveRunRow["liveState"];
+  const liveStateSeq = state.liveStateSeq;
   return {
     runId: r.run_id,
     threadKey: r.thread_key,
@@ -1550,7 +1557,9 @@ function rowToLive(r: LiveRow): LiveRunRow {
     card: r.card_json ? (JSON.parse(r.card_json) as LiveRunRow["card"]) : null,
     system: r.system_text,
     tools: JSON.parse(r.tools_json) as LiveRunRow["tools"],
-    state: JSON.parse(r.state_json) as RunState,
+    state,
+    ...(liveState !== undefined ? { liveState } : {}),
+    ...(typeof liveStateSeq === "number" ? { liveStateSeq } : {}),
   };
 }
 
@@ -3077,6 +3086,78 @@ export class RunHistoryDO extends DurableObject<Env> {
     return out;
   }
 
+  async assignLiveState(
+    runId: string,
+    gen: string,
+    assignment: LiveStateAssignRequest,
+  ): Promise<LiveStateAssignResult> {
+    let out: LiveStateAssignResult = { ok: false, reason: "unknown-run" };
+    this.ctx.storage.transactionSync(() => {
+      const row = this.liveRow(runId);
+      const fence = checkFence(row, gen);
+      if (!fence.ok) {
+        out = fence;
+        return;
+      }
+      if (!row) {
+        out = { ok: false, reason: "unknown-run" };
+        return;
+      }
+      const result = assignRunLiveState(
+        assignment.restart ? undefined : row.liveState,
+        row.liveStateSeq ?? 0,
+        assignment,
+      );
+      if (!result.ok) {
+        out = result;
+        return;
+      }
+      let liveStateSeq = row.liveStateSeq ?? 0;
+      const last = this.sql
+        .exec<{ m: number | null }>(`SELECT MAX(seq) AS m FROM run_events WHERE run_id = ?`, runId)
+        .one().m;
+      let lastEventSeq = last ?? 0;
+      for (const source of assignment.sourceEvents ?? []) {
+        if (source.seq <= lastEventSeq) {
+          out = { ok: false, reason: "stale-sequence" };
+          return;
+        }
+        lastEventSeq = source.seq;
+      }
+      const boundarySeq = result.event ? (assignment.eventSeq ?? lastEventSeq + 1) : undefined;
+      if (boundarySeq !== undefined && boundarySeq <= lastEventSeq) {
+        out = { ok: false, reason: "stale-sequence" };
+        return;
+      }
+      for (const source of assignment.sourceEvents ?? []) {
+        this.sql.exec(
+          `INSERT INTO run_events (run_id, seq, json) VALUES (?, ?, ?)`,
+          runId,
+          source.seq,
+          JSON.stringify(source),
+        );
+        liveStateSeq = source.seq;
+      }
+      if (result.event && boundarySeq !== undefined) {
+        liveStateSeq = boundarySeq;
+        this.sql.exec(
+          `INSERT INTO run_events (run_id, seq, json) VALUES (?, ?, ?)`,
+          runId,
+          liveStateSeq,
+          JSON.stringify({ ...result.event, seq: liveStateSeq }),
+        );
+      }
+      const state = { ...row.state, ...assignment.statePatch, liveState: result.liveState, liveStateSeq };
+      this.sql.exec(`UPDATE live_runs SET state_json = ? WHERE run_id = ?`, JSON.stringify(state), runId);
+      out = {
+        ...result,
+        ...(result.event ? { event: { ...result.event, seq: liveStateSeq } } : {}),
+        liveStateSeq,
+      };
+    });
+    return out;
+  }
+
   async setState(runId: string, gen: string, state: RunState): Promise<FenceResult> {
     let out: FenceResult = { ok: true };
     this.ctx.storage.transactionSync(() => {
@@ -3256,15 +3337,22 @@ export class RunHistoryDO extends DurableObject<Env> {
           .exec<{ json: string }>(`SELECT json FROM run_steps WHERE run_id = ? ORDER BY step DESC LIMIT 1`, row.runId)
           .toArray()[0];
         const lastStep = stepRow ? (JSON.parse(stepRow.json) as StepRecord) : null;
-        const consumed = lastStep?.inboxConsumedSeq ?? 0;
+        // Past the cursor, plus the deferred rows at or below it: the lowest
+        // deferred seq bounds the read, and the record's predicate filters.
+        const unread = unreadInbox(lastStep);
+        const from = Math.min(
+          lastStep?.inboxConsumedSeq ?? 0,
+          ...(lastStep?.inboxDeferredSeqs ?? []).map((s) => s - 1),
+        );
         const inbox = this.sql
           .exec<{ seq: number; json: string }>(
             `SELECT seq, json FROM run_inbox WHERE run_id = ? AND seq > ? ORDER BY seq ASC`,
             row.runId,
-            consumed,
+            from,
           )
           .toArray()
-          .map((r) => ({ seq: r.seq, message: JSON.parse(r.json) as Record<string, unknown> }));
+          .map((r) => ({ seq: r.seq, message: JSON.parse(r.json) as Record<string, unknown> }))
+          .filter(unread);
         const jobs = this.sql
           .exec<{ kind: string; json: string }>(`SELECT kind, json FROM run_jobs WHERE run_id = ?`, row.runId)
           .toArray()
@@ -5108,6 +5196,7 @@ const LEDGER_ROUTES = new Set([
   "/runs/claim",
   "/runs/heartbeat",
   "/runs/append",
+  "/runs/live-state",
   "/runs/step",
   "/runs/state",
   "/runs/inbox",
@@ -5484,6 +5573,12 @@ function parseStep(v: unknown): Validated<StepRecord> {
       return invalid(`record.${k} must be a non-negative integer`);
     }
   }
+  if (
+    s.inboxDeferredSeqs !== undefined &&
+    (!Array.isArray(s.inboxDeferredSeqs) ||
+      !s.inboxDeferredSeqs.every((seq) => typeof seq === "number" && Number.isInteger(seq) && seq > 0))
+  )
+    return invalid("record.inboxDeferredSeqs must be an array of positive integers");
   if (!Array.isArray(s.inFlight)) return invalid("record.inFlight must be an array");
   for (const c of s.inFlight) {
     const call = c as Record<string, unknown>;
@@ -5940,6 +6035,13 @@ async function handleLedger(pathname: string, body: unknown, env: Env): Promise<
     console.log(`[runs/append] ${key.value} ${runId.value} <- ${events.length} event(s), ok=${r.ok}`);
     return fenced(r);
   }
+  if (pathname === "/runs/live-state") {
+    if (typeof b.assignment !== "object" || b.assignment === null)
+      return json({ error: "assignment must be an object" }, 400);
+    const assignment = b.assignment as unknown as LiveStateAssignRequest;
+    const r = await stub.assignLiveState(runId.value, g.value, assignment);
+    return r.ok ? json(r) : json(r, r.reason === "fenced" || r.reason === "unknown-run" ? 409 : 400);
+  }
   if (pathname === "/runs/step") {
     const record = parseStep(b.record);
     if (!record.ok) return json({ error: record.error }, 400);

package/dist/assets/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "switchboard",
-  "version": "1.260.5",
+  "version": "1.261.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "switchboard",
-      "version": "1.260.5",
+      "version": "1.261.0",
       "license": "Apache-2.0",
       "workspaces": [
         "web",
@@ -21060,7 +21060,7 @@
     },
     "packages/switchboard": {
       "name": "@coreplane/switchboard",
-      "version": "1.260.5",
+      "version": "1.261.0",
       "license": "Apache-2.0",
       "dependencies": {
         "@earendil-works/pi-ai": "0.85.1",

package/dist/assets/package.json

@@ -1,6 +1,6 @@
 {
   "name": "switchboard",
-  "version": "1.260.5",
+  "version": "1.261.0",
   "private": true,
   "description": "Mention it in Slack and an agent reviews the PR, ships the fix, or answers the question — on the model you choose, with its tools running where you decide.",
   "license": "Apache-2.0",

package/dist/assets/source.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.260.5",
-  "commit": "3b665eb6f1bb239a78981014dae4bc88a50264a7",
-  "builtAt": "2026-09-22T23:49:01.800Z"
+  "version": "1.261.0",
+  "commit": "c60b26943f774d0ba0e71af0df8db7d1d90613c5",
+  "builtAt": "2026-09-23T08:28:35.014Z"
 }

package/dist/assets/src/core/budgets.ts

@@ -254,6 +254,11 @@ export const HOSTED_DEADLINE_MARGIN_MINUTES = 60;
  *  and the pause before a busy spawn is asked again. */
 export const SHIP_WAIT = { marginMinutes: 5, chunkMinutes: 5, mergeChunkMinutes: 5, busyRetryMinutes: 2 } as const;
 
+/** A finish event and the run record's durable write are separate deliveries.
+ *  After the runner receives its own event, it gives the record this short
+ *  visibility bound before treating an opaque absence as permanent. */
+export const SHIP_RECORD_VISIBILITY = { retries: 3, retryMs: secondsToMs(1) } as const;
+
 /** How long a restarting close gives its replacement dispatch to claim the
  *  same run before a read with no successor treats the close as final
  *  (run-history item 47a). One whole coordinator wait chunk lets an ordinary

package/dist/assets/src/core/coordinator/driver.ts

@@ -39,7 +39,15 @@
 // plan's re-issue. A task string's ship branch waits for a person. Node-free:
 // the shim Worker imports this by relative path.
 
-import { DAY_MS, DEFAULT_GRANT, GRANT_RENEWALS_MAX, IDLE_DAYS_MAX, type Grant, type GrantSource } from "../budgets.js";
+import {
+  DAY_MS,
+  DEFAULT_GRANT,
+  GRANT_RENEWALS_MAX,
+  IDLE_DAYS_MAX,
+  SHIP_RECORD_VISIBILITY,
+  type Grant,
+  type GrantSource,
+} from "../budgets.js";
 import { isFindingShape, type Finding } from "../reviewVerdict.js";
 import { DEFAULT_VERBOSITY, isVerbosity, type Verbosity } from "../verbosity.js";
 import {
@@ -640,15 +648,47 @@ async function call(
   bot: CoordinatorBot,
   route: CoordinatorStepRoute,
   body: Record<string, unknown>,
+  acceptOpaqueNotFound = false,
 ): Promise<BotReply> {
   const reply = await bot.step(route, body);
   const read = readBotAnswer(reply.status, reply.text);
-  if (!read.ok) throw new Error(`the bot did not answer ${route}: ${read.reason}`);
+  if (!read.ok) {
+    if (acceptOpaqueNotFound && isOpaqueNotFound(reply)) return reply;
+    throw new Error(`the bot did not answer ${route}: ${read.reason}`);
+  }
   const transient = transientRefusal(read.answer);
   if (transient !== undefined) throw new Error(transient);
   return reply;
 }
 
+/** The read door's authorization mask: absent and denied are deliberately the
+ *  same reply. The runner may pace that reply only from its own addressed
+ *  finish event; parsing it here never changes what another caller sees. */
+function isOpaqueNotFound(reply: BotReply): boolean {
+  if (reply.status !== 404) return false;
+  try {
+    const body = JSON.parse(reply.text) as { ok?: unknown; error?: unknown };
+    return body?.ok === false && body.error === "not_found";
+  } catch {
+    return false;
+  }
+}
+
+async function readRecordStep(
+  step: StepRunner,
+  bot: CoordinatorBot,
+  action: Extract<CoordinatorAction, { type: "read-record" }>,
+  body: Record<string, unknown>,
+): Promise<BotReply> {
+  for (let retry = 0; ; retry++) {
+    const name = retry === 0 ? action.step : `${action.step}/record-read/${retry}`;
+    const reply = await step.do(name, STEP_CONFIG, () => call(bot, "read-record", body, true));
+    if (!isOpaqueNotFound(reply) || action.finishedObserved !== true || retry >= SHIP_RECORD_VISIBILITY.retries)
+      return reply;
+    await step.sleep(`${action.step}/record-visible/${retry + 1}`, SHIP_RECORD_VISIBILITY.retryMs);
+  }
+}
+
 /** The answer a stored reply carries — the reply passed `call` once, so it reads the same on replay. */
 function answerOf(route: CoordinatorStepRoute, reply: BotReply): BotAnswer {
   const read = readBotAnswer(reply.status, reply.text);
@@ -745,10 +785,7 @@ async function perform(
     case "read-record":
       return readRecordReturn(
         action.step,
-        answerOf(
-          "read-record",
-          await step.do(action.step, STEP_CONFIG, () => call(bot, "read-record", { ...tag, runId: action.runId })),
-        ),
+        answerOf("read-record", await readRecordStep(step, bot, action, { ...tag, runId: action.runId })),
       );
     case "steer":
       return steerReturn(

package/dist/assets/src/core/pipelineStanding.ts

@@ -12,6 +12,30 @@ import type { UnitEnding } from "./ship/coordinator.js";
 /** The stage vocabulary (record 0065): what every surface says a unit is in. */
 export type Stage = "coding" | "review" | "fix" | "approved" | "merge-ready" | "merged" | "idle" | "ended";
 
+export const HOSTED_PIPELINE_STARTING_DETAIL = "pipeline starting";
+
+/** Safe detail for a hosted parent's shared `working` state, total over Stage. */
+export function hostedStageDetail(stage: Stage): string {
+  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";
+  }
+}
+
 export const STAGES = [
   "coding",
   "review",

package/dist/assets/src/core/plane/decide.ts

@@ -12,6 +12,31 @@
 import { PLANE, minutesToMs } from "../budgets.js";
 import type { ProviderFailureCause } from "../provider.js";
 import type { PlaneFinding } from "./findings.js";
+import type { RunLiveStateName } from "../runLiveState.js";
+
+/** The one user wording table for the server-owned live condition. */
+export function liveStateWords(state: RunLiveStateName): string {
+  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";
+  }
+}
 
 // ---- endings and their causes (record 0064, "Endings and the watches") ------------------------
 

package/dist/assets/src/core/refusal.ts

@@ -47,7 +47,7 @@ const CAUSE_OF = {
   repo_not_onboarded: "request",
   repo_access: "policy",
   pr_head_unknown: "system",
-  branch_moved: "system",
+  workspace_head_mismatch: "system",
   coordinator_thread_live: "system",
   live_agent_allowlist: "policy",
   follow_up_refused: "request",

package/dist/assets/src/core/runEvents.ts

@@ -5,6 +5,7 @@ import type { DescriptionIssue, PrDescription, RecordedJson, RenderedPointer } f
 import type { HarnessScope } from "./harness/scope.js";
 import type { ModelCard } from "./modelCard.js";
 import type { ProviderFailureCause } from "./provider.js";
+import type { RunStateEvent } from "./runLiveState.js";
 
 /** The `pr_description` review artifact minus the event envelope
  *  (docs/reference/specs/reading-diff.md item 7). */
@@ -492,6 +493,7 @@ export function isHeadMaterial(event: RunEvent): boolean {
     case "context":
     case "reference":
     case "run_meta":
+    case "run_state":
     case "route":
       return true;
     case "run_note":
@@ -923,6 +925,9 @@ export type RunEvent =
    *  start of the loop; a resumed run carries the original. Head material,
    *  like `run_meta`. Additive: unknown → ignored. */
   | { type: "lease"; startedAt: number; endsAt: number; loopEndsAt: number; seq?: number; at?: number }
+  /** A server-owned live-condition boundary. Same-state refreshes update the
+   *  durable projection beside their source event and do not emit this event. */
+  | RunStateEvent
   /** A head the run pushed (docs/reference/specs/run-history.md item 2; decision
    *  0046): the branch and the sha the coding post-step observed on the remote
    *  (`by: "push"`), or the budget-end salvage pushed (`by: "salvage"`),

package/dist/assets/src/core/runFriction.ts

@@ -438,6 +438,7 @@ export function analyzeRunFriction(events: readonly RunEvent[], opts: FrictionOp
       ev.type === "operator" ||
       ev.type === "refusal" ||
       ev.type === "reference" ||
+      ev.type === "run_state" ||
       ev.type === "lease" ||
       ev.type === "pushed_head"
     ) {
@@ -537,6 +538,7 @@ export function analyzeRunFriction(events: readonly RunEvent[], opts: FrictionOp
       return;
     }
 
+    if (ev.type !== "run_note") return;
     switch (ev.kind) {
       case "wrap_up":
         // Its extent is the time from the warning to the end of the window (how

package/dist/assets/src/core/runLedger/decisions.ts

@@ -2,7 +2,7 @@
 // Durable Object applies them inside one transaction; the in-memory ledger
 // applies them in tests; both agree because this is the only copy.
 
-import type { ClaimResult, FenceResult, IntakeReceipt, IntakeWriteResult, LivePhase } from "./types.js";
+import type { ClaimResult, FenceResult, IntakeReceipt, IntakeWriteResult, LivePhase, StepRecord } from "./types.js";
 
 /** One live run per thread. The existing row, if any, is what `live_runs` holds
  *  for the thread; the same run re-claimed by its owner is idempotent (a retry
@@ -80,6 +80,15 @@ export function selectReclaim<T extends { leaseUntil: number; phase: LivePhase;
   return rows.filter((r) => r.ownerGen !== gen && (r.phase === "handoff" || r.leaseUntil <= now));
 }
 
+/** Which inbox rows a reclaim hands the next generation (run-history item 40):
+ *  every row past the last record's cursor, and the rows at or below it the
+ *  record names deferred — handed to the run, never read by its model. */
+export function unreadInbox(lastStep: Pick<StepRecord, "inboxConsumedSeq" | "inboxDeferredSeqs"> | null) {
+  const consumed = lastStep?.inboxConsumedSeq ?? 0;
+  const deferred = new Set(lastStep?.inboxDeferredSeqs ?? []);
+  return (item: { seq: number }): boolean => item.seq > consumed || deferred.has(item.seq);
+}
+
 /** The compare-and-swap table for a run's phase. `attaching → live` (the
  *  prompt landed) or `→ finishing` (the dispatch failed before it — never
  *  handoff: an attaching run has nothing to resume from, so the drain waits

package/dist/assets/src/core/runLedger/types.ts

@@ -9,6 +9,7 @@ import type { ChannelVisibility } from "../authz/types.js";
 import type { RunProfile } from "../../config/profile.js";
 import type { RunEvent } from "../runEvents.js";
 import type { RunSeed, RunSession } from "../runRecord.js";
+import type { AssignRunLiveStateInput, AssignRunLiveStateResult, RunLiveState } from "../runLiveState.js";
 
 /** How long a generation's claim on a run lasts without a heartbeat. */
 export const LEASE_MS = 30_000;
@@ -158,8 +159,28 @@ export interface LiveRunRow {
   /** The tool definitions the run was started with, verbatim. */
   tools: ToolDef[];
   state: RunState;
+  /** The restart-safe live-condition projection. Optional on legacy rows. */
+  liveState?: RunLiveState;
+  /** Stream sequence that most recently produced or refreshed `liveState`. */
+  liveStateSeq?: number;
 }
 
+/** The atomic live-condition assignment request and answer shared by both ledger implementations. */
+export type LiveStateAssignRequest = AssignRunLiveStateInput & {
+  /** Registry sequence reserved for a changed boundary before fan-out. */
+  eventSeq?: number;
+  /** Other durable row facts that must commit with the projection (for example hosting). */
+  statePatch?: RunState;
+  /** Existing activity facts committed with a same-state projection refresh. */
+  sourceEvents?: AppendableEvent[];
+  /** A new execution segment under the same run id starts after an ended predecessor. */
+  restart?: boolean;
+};
+export type LiveStateAssignResult =
+  | (Extract<AssignRunLiveStateResult, { ok: true }> & { liveStateSeq: number })
+  | Extract<AssignRunLiveStateResult, { ok: false }>
+  | { ok: false; reason: "fenced" | "unknown-run" };
+
 /** One tool call the step dispatched; `tool` decides how a resume settles it.
  *  `boundMs` is the bound the call declared (a bash `timeout`), when it stated
  *  one — what the plane judges a `long_call` steer against (record 0064). */
@@ -179,6 +200,9 @@ export interface StepRecord {
   inFlight: InFlightCall[];
   /** The inbox `seq` the run has consumed up to (0 = none). */
   inboxConsumedSeq: number;
+  /** Seqs at or below `inboxConsumedSeq` the run has not consumed yet: a
+   *  reclaim offers them again with every row past the cursor. */
+  inboxDeferredSeqs?: number[];
   remainingMs: number;
   turn: number;
   iteration: number;