@coreplane/switchboard 1.260.3 → 1.260.5

package/dist/assets/package.json

@@ -1,6 +1,6 @@
 {
   "name": "switchboard",
-  "version": "1.260.3",
+  "version": "1.260.5",
   "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",
@@ -39,9 +39,9 @@
     "cli": "tsx src/cli.ts",
     "verify": "npm run verify:root && npm run verify --workspaces --if-present && npm run check:site",
     "verify:root": "npm run check:consistency && npm run typecheck && npm run lint && npm run format:check && npm test && npm run check:dist",
-    "check:consistency": "npm run check:lockfile && npm run check:sandbox-pair && npm run skills:check && npm run check:deps-drift && npm run licenses:check && npm run docs:check && npm run pr-title:check && npm run specs:check && npm run decisions:check && npm run hygiene:check && npm run vocabulary:check && npm run check:project-facts && npm run check:registry-drift && npm run agents:check && npm run clock:check && npm run screenshots:check",
+    "check:consistency": "npm run check:lockfile && npm run check:sandbox-pair && npm run skills:check && npm run check:deps-drift && npm run licenses:check && npm run docs:check && npm run pr-title:check && npm run specs:check && npm run decisions:check && npm run hygiene:check && npm run vocabulary:check && npm run user-message:check && npm run check:project-facts && npm run check:registry-drift && npm run agents:check && npm run clock:check && npm run screenshots:check",
     "ci:gate": "node scripts/ci-gate.mjs",
-    "fix": "npm run docs:gen && npm run pr-title:gen && npm run agents:gen && npm run clock:gen && npm run hygiene:gen && npm run vocabulary:gen && npm run deploy:gen && npm run skills:sync && npm run lint:fix && npm run format",
+    "fix": "npm run docs:gen && npm run pr-title:gen && npm run agents:gen && npm run clock:gen && npm run hygiene:gen && npm run vocabulary:gen && npm run user-message:check -- --write && npm run deploy:gen && npm run skills:sync && npm run lint:fix && npm run format",
     "deploy:gen": "npm run --silent cli -- deploy init",
     "deploy:check": "npm run --silent cli -- deploy init --check",
     "check:lockfile": "node scripts/check-lockfile.mjs",
@@ -75,6 +75,7 @@
     "hygiene:gen": "node scripts/public-hygiene.mjs --write",
     "vocabulary:check": "node scripts/vocabulary-check.mjs",
     "vocabulary:gen": "node scripts/vocabulary-check.mjs --write",
+    "user-message:check": "node scripts/user-message-check.mjs",
     "docs:changed": "node scripts/docs-changed.mjs",
     "deploy:targets": "node scripts/deploy-targets.mjs",
     "docs:dev": "npm run dev -w docs --",
@@ -88,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/project.json

@@ -183,6 +183,10 @@
       "does": "Records the remaining internal words; refuses growth unless `-- --force`.",
       "when": "Part of `fix`."
     },
+    "user-message:check": {
+      "does": "No user-facing statement delegates recovery.",
+      "when": "Part of `check:consistency`; the baseline only shrinks."
+    },
     "agents:gen": {
       "does": "Writes the Commands table in AGENTS.md from `package.json` and this file.",
       "when": "After adding or changing a script; part of `fix`."

package/dist/assets/source.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.260.3",
-  "commit": "9f64917c9c2520b2797f3d5e6a73494879408e26",
-  "builtAt": "2026-09-22T05:04:08.797Z"
+  "version": "1.260.5",
+  "commit": "3b665eb6f1bb239a78981014dae4bc88a50264a7",
+  "builtAt": "2026-09-22T23:49:01.800Z"
 }

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",

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

@@ -53,6 +53,7 @@ import {
   type UnitStatus,
   renderUnitReport,
   reenterApprovedRebase,
+  reconcileTerminalPr,
   settleUnit,
   startUnit,
   type ChildFacts,
@@ -110,6 +111,7 @@ export type CoordinatorStepRoute =
   | "branch"
   | "spawn"
   | "read-record"
+  | "steer"
   | "pr-check"
   | "round"
   | "unit-end"
@@ -334,11 +336,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 +383,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 +452,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 +481,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 +512,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 +554,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 +583,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 (
@@ -678,6 +750,16 @@ async function perform(
           await step.do(action.step, STEP_CONFIG, () => call(bot, "read-record", { ...tag, runId: action.runId })),
         ),
       );
+    case "steer":
+      return steerReturn(
+        action.step,
+        answerOf(
+          "steer",
+          await step.do(action.step, STEP_CONFIG, () =>
+            call(bot, "steer", { ...tag, runId: action.runId, reason: action.reason }),
+          ),
+        ),
+      );
     case "pr-check":
       // `recover` rides only after a dead coding child: the bot opens the pull
       // request from the pushed branch itself instead of answering `none`.
@@ -806,7 +888,7 @@ async function tellStepThrew(
         : `in round ${at.round.index} (\`${at.step}\`)`;
   const report =
     `⚠️ The runner failed ${where}: ${line}\n\n` +
-    "Re-issue `agent:ship` in this thread to continue — a pull request already approved with green checks resumes at the checks step, never at a fresh coding round.";
+    "The unit remains bound to this thread; the next reply continues it, and a pull request already approved with green checks resumes at the checks step, never at a fresh coding round.";
   const body = {
     ...tag,
     ending: {
@@ -939,11 +1021,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 +1061,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 +1070,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 +1091,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,
                   },
                 }
               : {}),
@@ -1041,14 +1130,14 @@ async function runUnit(
 
 /** The report of a unit the hard stop ended before it ran (record 0060; issue 1924). */
 function stoppedReport(unit: string): string {
-  return `⏹ Stopped: the pipeline's hosted parent was hard-stopped, so ${unit} was ended without running. Re-issue the plan naming the remaining units to run them.`;
+  return `⏹ Stopped: the pipeline's hosted parent was hard-stopped, so ${unit} was ended without running. The original plan remains the durable task for any later pipeline.`;
 }
 
 function blockedReport(unit: string, dep: string, depEnding: string): string {
   if (depEnding === "blocked")
-    return `⛔ Blocked: ${unit} waits on ${dep}, which is blocked itself. Re-issue the plan naming the remaining units once it is resolved.`;
+    return `⛔ Blocked: ${unit} waits on ${dep}, which is blocked itself. A later pipeline recognizes both units once the dependency is resolved.`;
   const person = depEnding === "merge_ready";
-  return `⛔ Blocked: ${unit} waits on ${dep}, which ended ${depEnding}${person ? " — a person's merge" : ""}. Re-issue the plan naming the remaining units once it is ${person ? "merged" : "resolved"}.`;
+  return `⛔ Blocked: ${unit} waits on ${dep}, which ended ${depEnding}${person ? " — a person's merge" : ""}. A later pipeline recognizes the dependency once it is ${person ? "merged" : "resolved"}.`;
 }
 
 /** End a unit that never entered `runUnit` under the same failure net. */

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 }];