@coreplane/switchboard 1.260.5 → 1.260.6

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";
@@ -3256,15 +3257,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()
@@ -5484,6 +5492,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>;

package/dist/assets/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "switchboard",
-  "version": "1.260.5",
+  "version": "1.260.6",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "switchboard",
-      "version": "1.260.5",
+      "version": "1.260.6",
       "license": "Apache-2.0",
       "workspaces": [
         "web",
@@ -21060,7 +21060,7 @@
     },
     "packages/switchboard": {
       "name": "@coreplane/switchboard",
-      "version": "1.260.5",
+      "version": "1.260.6",
       "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.260.6",
   "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.260.6",
+  "commit": "903ae2855833637fbcc0c0a22d54e7268be75965",
+  "builtAt": "2026-09-23T04:57:07.101Z"
 }

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/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/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

@@ -179,6 +179,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;

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

@@ -550,7 +550,7 @@ export type CoordinatorAction =
   | { type: "branch"; step: string; branch: string; from: string }
   | { type: "spawn"; step: string; preset: ChildPreset; round: RoundRef; budgetMinutes: number; brief: Brief }
   | { type: "wait"; step: string; runId: string; timeoutMs: number }
-  | { type: "read-record"; step: string; runId: string }
+  | { type: "read-record"; step: string; runId: string; finishedObserved?: true }
   /** Tell a child whose pull request became terminal or moved to end at its
    *  next turn boundary without publishing anything. This is a steer through
    *  the child's inbox, never a stop that tears down its workspace. */
@@ -1170,7 +1170,7 @@ type Phase =
   | { at: "busy-wait"; round: RoundRef; runId?: string; n: number }
   /** `until`: when the child's budget plus the margin runs out, counted from the spawn's answer — the wait's last slice ends there. */
   | { at: "wait"; round: RoundRef; runId: string; n: number; until: number }
-  | { at: "read"; round: RoundRef; runId: string; n: number; until: number }
+  | { at: "read"; round: RoundRef; runId: string; n: number; until: number; finishedObserved: boolean }
   /** A live child lost authority because its pull request became terminal,
    *  its reviewed head moved, or its branch disappeared. Steer once, then
    *  drain the child to its recorded end while ignoring every late artifact. */
@@ -1197,6 +1197,7 @@ type Phase =
       n: number;
       until: number;
       supersession: ChildSupersession;
+      finishedObserved: boolean;
     }
   /** A moved-head child has drained. Re-read the adopted pull request before
    *  restarting review because it may have merged, closed or moved again. */
@@ -1533,7 +1534,12 @@ export function nextAction(s: UnitPipelineState): CoordinatorAction {
         timeoutMs: Math.min(waitSliceMs(s.clock, p.until), s.pr !== undefined ? PR_TRANSITION_GUARD_MS : WAIT_CHUNK_MS),
       };
     case "read":
-      return { type: "read-record", step: `${roundStep(s, p.round)}/read/${p.n}`, runId: p.runId };
+      return {
+        type: "read-record",
+        step: `${roundStep(s, p.round)}/read/${p.n}`,
+        runId: p.runId,
+        ...(p.finishedObserved ? { finishedObserved: true as const } : {}),
+      };
     case "steer":
       return {
         type: "steer",
@@ -1553,6 +1559,7 @@ export function nextAction(s: UnitPipelineState): CoordinatorAction {
         type: "read-record",
         step: `${roundStep(s, p.round)}/superseded/read/${p.n}`,
         runId: p.runId,
+        ...(p.finishedObserved ? { finishedObserved: true as const } : {}),
       };
     case "superseded-pr-check":
       return {
@@ -2960,11 +2967,23 @@ export function applyReturn(s: UnitPipelineState, ret: StepReturn): Transition {
         notes: [],
       };
     }
-    case "wait":
+    case "wait": {
+      const r = ret as Extract<StepReturn, { type: "wait" }>;
       return {
-        state: { ...s, phase: { at: "read", round: p.round, runId: p.runId, n: p.n, until: p.until } },
+        state: {
+          ...s,
+          phase: {
+            at: "read",
+            round: p.round,
+            runId: p.runId,
+            n: p.n,
+            until: p.until,
+            finishedObserved: r.outcome === "event",
+          },
+        },
         notes: [],
       };
+    }
     case "read": {
       const r = ret as Extract<StepReturn, { type: "read-record" }>;
       const supersession = childSupersession(clocked, p.round, r.pullRequest);
@@ -2979,6 +2998,7 @@ export function applyReturn(s: UnitPipelineState, ret: StepReturn): Transition {
             n: p.n,
             until: p.until,
             supersession,
+            finishedObserved: p.finishedObserved,
           };
           return finishSupersededChild(clocked, terminalPhase);
         }
@@ -3098,7 +3118,8 @@ export function applyReturn(s: UnitPipelineState, ret: StepReturn): Transition {
         notes: [],
       };
     }
-    case "superseded-wait":
+    case "superseded-wait": {
+      const r = ret as Extract<StepReturn, { type: "wait" }>;
       return {
         state: {
           ...s,
@@ -3109,10 +3130,12 @@ export function applyReturn(s: UnitPipelineState, ret: StepReturn): Transition {
             n: p.n,
             until: p.until,
             supersession: p.supersession,
+            finishedObserved: r.outcome === "event",
           },
         },
         notes: [],
       };
+    }
     case "superseded-read": {
       const r = ret as Extract<StepReturn, { type: "read-record" }>;
       if (r.run.finished) return finishSupersededChild(clocked, p);