@coreplane/switchboard 1.260.4 → 1.260.6

package/dist/assets/package.json

@@ -1,6 +1,6 @@
 {
   "name": "switchboard",
-  "version": "1.260.4",
+  "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",
@@ -89,11 +89,11 @@
     "@earendil-works/pi-ai": "0.85.1",
     "@slack/bolt": "^5.1.0",
     "aws4fetch": "^1.0.20",
-    "e2b": "^2.46.1",
+    "e2b": "^2.49.1",
     "mdast-util-from-markdown": "^2.0.3",
     "undici": "^8.10.2",
-    "yaml": "^2.7.0",
-    "zod": "^4.5.4"
+    "yaml": "^2.9.1",
+    "zod": "^4.6.5"
   },
   "devDependencies": {
     "@earendil-works/pi-coding-agent": "0.85.1",

package/dist/assets/source.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.260.4",
-  "commit": "714dbd34ad03841fe421bfdc78648854b4c8dbc1",
-  "builtAt": "2026-09-22T07:09:50.930Z"
+  "version": "1.260.6",
+  "commit": "903ae2855833637fbcc0c0a22d54e7268be75965",
+  "builtAt": "2026-09-23T04:57:07.101Z"
 }

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

@@ -150,6 +150,11 @@ export function intakeReceiptRetentionMs(catchUpWindowMs: number): number {
  *  prompt one bounds the ratio the gate is judged by. */
 export const INTAKE_RECOVERY_WINDOW_MS = 10 * MINUTE_MS;
 
+/** How long one process owns the right to post a stored intake-failure
+ * sentence. A rejected post releases immediately; this bound only recovers a
+ * process that died after the atomic claim and before it could finish it. */
+export const INTAKE_DELIVERY_CLAIM_MS = 5 * MINUTE_MS;
+
 /** The presets that run the tool loop, and the one pipeline preset. */
 export const LOOP_PRESETS = [
   "general",
@@ -249,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/contract.ts

@@ -489,6 +489,10 @@ export interface CoordinatorUnit {
    *  — no pre-check, no branch, no round 0. A task string's row only; written by
    *  the hand-off, read by the driver into the machine's input. */
   resume?: { pr: number; headSha?: string; url?: string };
+  /** The decision-record number reserved at admission for this unit. A unit
+   * that writes a record carries it through every attempt and briefs its child
+   * as `record: NNNN`; the child never scans the directory for a number. */
+  record?: string;
   /** The head the unit's own coding child last pushed, recorded when the unit
    *  ended `review_pending` (the wall clock capped after the pull request was
    *  opened or updated): the next attempt's pre-check starts at the review
@@ -659,6 +663,7 @@ export function isCoordinatorUnit(v: unknown): v is CoordinatorUnit {
   if (r.issue !== undefined && !isFinite(r.issue)) return false;
   if (r.pr !== undefined && !isPr(r.pr)) return false;
   if (r.resume !== undefined && !isResume(r.resume)) return false;
+  if (r.record !== undefined && (typeof r.record !== "string" || !/^\d{4}$/.test(r.record))) return false;
   if (r.lastPush !== undefined && !isText(r.lastPush)) return false;
   if (r.segments !== undefined && (!Array.isArray(r.segments) || !r.segments.every(isSegment))) return false;
   if (r.idle !== undefined && !isUnitIdle(r.idle)) return false;

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 {
@@ -53,6 +61,7 @@ import {
   type UnitStatus,
   renderUnitReport,
   reenterApprovedRebase,
+  reconcileTerminalPr,
   settleUnit,
   startUnit,
   type ChildFacts,
@@ -110,6 +119,7 @@ export type CoordinatorStepRoute =
   | "branch"
   | "spawn"
   | "read-record"
+  | "steer"
   | "pr-check"
   | "round"
   | "unit-end"
@@ -334,11 +344,25 @@ function readRecordReturn(step: string, a: BotAnswer): StepReturn {
   // The hard stop's mark, as the bot's answer carries it (record 0060; issue
   // 1924): a finished child's unit ends stopped on it.
   const stopped = a.body.stopped === true ? { stopped: true as const } : {};
+  const pullRequest = isRecord(a.body.pullRequest)
+    ? prCheckReturn(step, {
+        status: a.status,
+        body: { ok: true, ...a.body.pullRequest, at: a.body.at },
+      }).pr
+    : undefined;
   // The interrupted child restarted from its request (issue 1903): the bot
   // answers the live successor's id, and the machine keeps the wait on it.
   const restarted = typeof a.body.restartedAs === "string" ? { restartedAs: a.body.restartedAs } : {};
   if (!run.finished)
-    return { type: "read-record", step, run: { finished: false }, ...stopped, ...restarted, at: a.body.at };
+    return {
+      type: "read-record",
+      step,
+      run: { finished: false },
+      ...(pullRequest !== undefined ? { pullRequest } : {}),
+      ...stopped,
+      ...restarted,
+      at: a.body.at,
+    };
   if (typeof run.status !== "string") throw new UnreadableAnswer("read-record", a, "status");
   // The typed artifacts as the bot's record carries them — shape-checked where
   // they were written (the run record's validator), read here as they are.
@@ -367,6 +391,7 @@ function readRecordReturn(step: string, a: BotAnswer): StepReturn {
     type: "read-record",
     step,
     ...stopped,
+    ...(pullRequest !== undefined ? { pullRequest } : {}),
     run: {
       finished: true,
       status: run.status as Extract<ChildFacts, { finished: true }>["status"],
@@ -435,8 +460,8 @@ function entryHumanGate(v: unknown):
   };
 }
 
-function prCheckReturn(step: string, a: BotAnswer): StepReturn {
-  const { ok, state, prNumber, url, headSha, sha, mergedAt, at } = a.body;
+function prCheckReturn(step: string, a: BotAnswer): Extract<StepReturn, { type: "pr-check" }> {
+  const { ok, state, prNumber, url, headSha, sha, mergedAt, mergedBy, closedBy, at } = a.body;
   if (ok === true && state === "none") {
     const { unrecovered, aheadOfBase, prClosed } = a.body;
     return {
@@ -464,6 +489,7 @@ function prCheckReturn(step: string, a: BotAnswer): StepReturn {
         prNumber,
         url,
         ...(typeof headSha === "string" ? { headSha } : {}),
+        ...(typeof a.body.headBranchExists === "boolean" ? { headBranchExists: a.body.headBranchExists } : {}),
         // The entry facts (issue 1689): the branch's own tip and whether the
         // bot's approval stands at the head, read at the unit-start's pre-check
         // so a re-issued plan resumes at review or at the merge decision.
@@ -494,10 +520,36 @@ function prCheckReturn(step: string, a: BotAnswer): StepReturn {
     typeof sha === "string" &&
     typeof mergedAt === "string"
   )
-    return { type: "pr-check", step, pr: { state: "merged", prNumber, url, sha, mergedAt }, at };
+    return {
+      type: "pr-check",
+      step,
+      pr: {
+        state: "merged",
+        prNumber,
+        url,
+        sha,
+        mergedAt,
+        ...(typeof mergedBy === "string" ? { mergedBy } : {}),
+      },
+      at,
+    };
+  if (
+    ok === true &&
+    state === "closed" &&
+    typeof prNumber === "number" &&
+    typeof url === "string" &&
+    typeof closedBy === "string"
+  )
+    return { type: "pr-check", step, pr: { state: "closed", prNumber, url, closedBy }, at };
   throw new UnreadableAnswer("pr-check", a, "state");
 }
 
+function steerReturn(step: string, a: BotAnswer): Extract<StepReturn, { type: "steer" }> {
+  if (a.body.ok === true && (a.body.outcome === "steered" || a.body.outcome === "not_live"))
+    return { type: "steer", step, outcome: a.body.outcome, at: a.body.at };
+  throw new UnreadableAnswer("steer", a, "outcome");
+}
+
 /** The round's checks read as the bot answered it (record 0055): the runs at
  *  the reviewed head, or none when GitHub could not be read — the machine
  *  treats an absent read as pending and asks again at the chunk's end. A retry
@@ -510,6 +562,14 @@ function checksReturn(step: string, a: BotAnswer): StepReturn {
     type: "checks",
     step,
     ...(isRoundChecks(checks) ? { checks } : {}),
+    ...(isRecord(a.body.pullRequest)
+      ? {
+          pullRequest: prCheckReturn(step, {
+            status: a.status,
+            body: { ok: true, ...a.body.pullRequest, at },
+          }).pr,
+        }
+      : {}),
     // The pull request is a draft (issue 2063): the machine's table holds the
     // unit for the ready event instead of merging or ending without a cause.
     ...(draft === true ? { draft: true } : {}),
@@ -531,11 +591,31 @@ const isRoundChecks = (v: unknown): v is RoundChecks =>
   (v.expected === undefined || (Array.isArray(v.expected) && v.expected.every((n: unknown) => typeof n === "string")));
 
 function mergeReturn(step: string, a: BotAnswer): StepReturn {
-  const { ok, outcome, by, sha, mergedAt, reason, at } = a.body;
+  const { ok, outcome, by, sha, mergedAt, mergedBy, reason, at } = a.body;
   // The door found the pull request already merged after the approval: the
   // merge commit and the time ride the answer, and the unit ends `by: other`.
   if (ok === true && outcome === "merged" && by === "other" && typeof sha === "string" && typeof mergedAt === "string")
-    return { type: "merge", step, outcome: "merged", by: "other", sha, mergedAt, at };
+    return {
+      type: "merge",
+      step,
+      outcome: "merged",
+      by: "other",
+      sha,
+      mergedAt,
+      ...(typeof mergedBy === "string" ? { mergedBy } : {}),
+      at,
+    };
+  if (ok === true && outcome === "recheck" && isRecord(a.body.pullRequest))
+    return {
+      type: "merge",
+      step,
+      outcome: "recheck",
+      pullRequest: prCheckReturn(step, {
+        status: a.status,
+        body: { ok: true, ...a.body.pullRequest, at },
+      }).pr,
+      at,
+    };
   if (ok === true && outcome === "merged" && typeof sha === "string")
     return { type: "merge", step, outcome: "merged", sha, at };
   if (
@@ -568,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);
@@ -672,10 +784,17 @@ async function perform(
       return { type: "wait", step: action.step, outcome: await waitForRun(step, action) };
     case "read-record":
       return readRecordReturn(
+        action.step,
+        answerOf("read-record", await readRecordStep(step, bot, action, { ...tag, runId: action.runId })),
+      );
+    case "steer":
+      return steerReturn(
         action.step,
         answerOf(
-          "read-record",
-          await step.do(action.step, STEP_CONFIG, () => call(bot, "read-record", { ...tag, runId: action.runId })),
+          "steer",
+          await step.do(action.step, STEP_CONFIG, () =>
+            call(bot, "steer", { ...tag, runId: action.runId, reason: action.reason }),
+          ),
         ),
       );
     case "pr-check":
@@ -939,11 +1058,17 @@ async function runUnit(
                 factsStep,
                 answerOf(
                   "pr-check",
-                  await step.do(factsStep, STEP_CONFIG, () => call(bot, "pr-check", { ...tag, checks: true })),
+                  await step.do(factsStep, STEP_CONFIG, () =>
+                    call(bot, "pr-check", {
+                      ...tag,
+                      checks: true,
+                      ...(state.pr !== undefined ? { pr: state.pr.number } : {}),
+                    }),
+                  ),
                 ),
               );
-              if (check.type === "pr-check" && check.pr.state === "merged")
-                endFacts = { merged: { sha: check.pr.sha, mergedAt: check.pr.mergedAt } };
+              if (check.type === "pr-check" && (check.pr.state === "merged" || check.pr.state === "closed"))
+                state = reconcileTerminalPr(state, check.pr);
               else if (check.type === "pr-check" && check.pr.state === "open")
                 endFacts = {
                   ...(check.pr.autoMergeEnabled !== undefined ? { autoMergeEnabled: check.pr.autoMergeEnabled } : {}),
@@ -973,6 +1098,7 @@ async function runUnit(
             state = reenterApprovedRebase(state);
             continue pipeline;
           }
+          const ending = state.ending ?? note.ending;
           // The last coding child's run is named so the bot can put its handoff
           // — the deviations it recorded — on the unit's board issue beside the
           // ending (agent-ship item 14).
@@ -981,20 +1107,20 @@ async function runUnit(
             // Two copies (routing-and-config item 28): the full report for the
             // row and the board, and the thread's at the request's verbosity.
             ending: {
-              kind: note.ending.kind,
+              kind: ending.kind,
               report: renderUnitReport(state, endFacts),
               threadReport: renderUnitReport(state, endFacts, state.input.verbosity ?? DEFAULT_VERBOSITY),
               // An idle ending carries its continuation facts (record 0051): the
               // bot writes them on the row's `idle` in place of an ending, with
               // the coding run id it already receives below.
-              ...(note.ending.kind === "idle"
+              ...(ending.kind === "idle"
                 ? {
-                    why: note.ending.why,
-                    renewalsLeft: note.ending.renewalsLeft,
-                    ...(note.ending.from !== undefined ? { from: note.ending.from } : {}),
-                    spendUsd: note.ending.spendUsd,
-                    ...(note.ending.handoff !== undefined ? { handoff: note.ending.handoff } : {}),
-                    ...(note.ending.humanGate !== undefined ? { humanGate: note.ending.humanGate } : {}),
+                    why: ending.why,
+                    renewalsLeft: ending.renewalsLeft,
+                    ...(ending.from !== undefined ? { from: ending.from } : {}),
+                    spendUsd: ending.spendUsd,
+                    ...(ending.handoff !== undefined ? { handoff: ending.handoff } : {}),
+                    ...(ending.humanGate !== undefined ? { humanGate: ending.humanGate } : {}),
                   }
                 : {}),
             },
@@ -1002,21 +1128,21 @@ async function runUnit(
             // A review_pending ending names the child's own last push so the next
             // attempt's pre-check can start at the review round (the row's lastPush)
             // — an idled one the same, off the idle's `from` (record 0051).
-            ...(note.ending.kind === "review_pending" && note.ending.headSha !== undefined
-              ? { headSha: note.ending.headSha }
-              : note.ending.kind === "idle" && note.ending.why === "review_pending" && note.ending.from !== undefined
-                ? { headSha: note.ending.from }
+            ...(ending.kind === "review_pending" && ending.headSha !== undefined
+              ? { headSha: ending.headSha }
+              : ending.kind === "idle" && ending.why === "review_pending" && ending.from !== undefined
+                ? { headSha: ending.from }
                 : {}),
             ...(state.lastCodingRunId !== undefined ? { codingRunId: state.lastCodingRunId } : {}),
             // A continued ending is a segment's end, not the unit's: the bot
             // writes the renewal as a row keyed by the next segment's index
             // (decision 0046), so a runner reclaimed here never renews twice.
-            ...(note.ending.kind === "continued"
+            ...(ending.kind === "continued"
               ? {
                   segment: {
-                    index: note.ending.segment,
-                    ...(note.ending.from !== undefined ? { from: note.ending.from } : {}),
-                    runId: note.ending.runId,
+                    index: ending.segment,
+                    ...(ending.from !== undefined ? { from: ending.from } : {}),
+                    runId: ending.runId,
                   },
                 }
               : {}),

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

@@ -116,6 +116,7 @@ export const ROUND_STAGE = {
  *  issue 2100) — closes the unit the same way. */
 export const ENDING_STAGE = {
   merged: "merged",
+  closed: "ended",
   already_landed: "merged",
   merge_ready: "merge-ready",
   held: "ended",
@@ -144,6 +145,7 @@ export const ENDING_STAGE = {
  *  2100), so a new ending kind fails the build here. */
 export const ENDING_WORDS = {
   merged: "merged",
+  closed: "closed",
   already_landed: "merged",
   merge_ready: "merge-ready",
   held: "held",

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

@@ -10,6 +10,7 @@
 // literal where `clock:check` expects it.)
 
 import { PLANE, minutesToMs } from "../budgets.js";
+import type { ProviderFailureCause } from "../provider.js";
 import type { PlaneFinding } from "./findings.js";
 
 // ---- endings and their causes (record 0064, "Endings and the watches") ------------------------
@@ -139,6 +140,9 @@ export interface PlaneLevelRow {
   side: "below" | "above";
   reportedAt: number;
   generation: string;
+  /** A provider row's typed down cause; absent on resident rows, provider-up,
+   * and reports from an older bot generation. */
+  cause?: ProviderFailureCause;
 }
 
 /** The side a resident's level reads for an observer that knows the current
@@ -300,7 +304,13 @@ export type PlaneEvent =
   /** A provider's level as the model proxy reported it: `up` on a relayed
    *  success, `down` on a failure past its one retry. `up` re-issues every
    *  turn held parked on the provider, once each. */
-  | { kind: "provider_level"; at: number; provider: string; level: "up" | "down" }
+  | {
+      kind: "provider_level";
+      at: number;
+      provider: string;
+      level: "up" | "down";
+      cause?: ProviderFailureCause;
+    }
   /** A run parked on its provider (record 0064): the harness holds the turn,
    *  the lease keeps counting, and the provider's next `up` steers it once. */
   | { kind: "park"; at: number; runId: string; provider: string }
@@ -692,7 +702,13 @@ function onHeartbeat(
  *  then walks the queue for anything waiting on `provider_up`. */
 function onProviderLevel(
   state: PlaneState,
-  event: { kind: "provider_level"; at: number; provider: string; level: "up" | "down" },
+  event: {
+    kind: "provider_level";
+    at: number;
+    provider: string;
+    level: "up" | "down";
+    cause?: ProviderFailureCause;
+  },
 ): PlaneDecision {
   const row: PlaneLevelRow = {
     resident: event.provider,
@@ -700,6 +716,7 @@ function onProviderLevel(
     side: event.level === "up" ? "below" : "above",
     reportedAt: event.at,
     generation: "",
+    ...(event.level === "down" && event.cause !== undefined ? { cause: event.cause } : {}),
   };
   const levels = [...state.levels.filter((l) => !(l.resident === event.provider && l.name === "provider")), row];
   const writes: PlaneWrite[] = [{ table: "plane_levels", op: "put", row }];