@coreplane/switchboard 1.257.0 → 1.259.0

package/dist/assets/config/config.example.yaml

@@ -164,7 +164,7 @@ defaults:
 #   addressSeverity: minor         # blocking | major | minor (default) | nit
 #   readingDiff:
 #     provider: git                # git (default) | meat | off
-#     meatModel: claude-opus-5     # meat's -model; Opus-class is the floor that actually abridges
+#     meatModel: claude-opus-5     # meat's -model; required with provider: meat (no built-in model) — Opus-class is the floor that actually abridges
 #     meatTimeoutS: 240            # meat's own budget on the host; past it the abridging fails by name
 
 # Static per-channel defaults (channel ID -> scope). Runtime overrides set via

package/dist/assets/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "switchboard",
-  "version": "1.257.0",
+  "version": "1.259.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "switchboard",
-      "version": "1.257.0",
+      "version": "1.259.0",
       "license": "Apache-2.0",
       "workspaces": [
         "web",
@@ -20445,7 +20445,7 @@
     },
     "packages/switchboard": {
       "name": "@coreplane/switchboard",
-      "version": "1.257.0",
+      "version": "1.259.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.257.0",
+  "version": "1.259.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.257.0",
-  "commit": "222646c5fe1a6686c238020f6571c69c3ab87e43",
-  "builtAt": "2026-09-20T15:27:11.679Z"
+  "version": "1.259.0",
+  "commit": "0b28f0fb4925d069547233cbae61f1d3187972d8",
+  "builtAt": "2026-09-21T02:10:55.399Z"
 }

package/dist/assets/src/agents/registry.ts

@@ -74,7 +74,7 @@ export interface AgentDef {
   system: string;
   /** key into TOOLSETS (src/tools/toolsets.ts): the tools the bot relays to
    *  the preset's pi; pi's own workspace tools follow `identity`. */
-  toolset: "full" | "readonly" | "web" | "assistant" | "explore" | "conductor" | "none";
+  toolset: "full" | "readonly" | "web" | "assistant" | "explore" | "conductor" | "orchestrator" | "none";
   /** The runaway guard, not a budget: `runawayTurnCap(maxMinutes)` for every
    *  preset that runs the loop (`loopBudget`). The wall clock below is the
    *  budget; a run that reaches this cap first was pacing like a loop, and its
@@ -647,6 +647,32 @@ ${BREVITY_RULE}
 ${FENCED_CONTENT_RULE}
 Report outcomes faithfully: a check you could not run is "could not check", never a guess. Use Slack-friendly formatting (no markdown headers; *bold*, bullets, code blocks — render the claim table as aligned rows inside a code block). Your final message is posted to Slack: lead with the overall verdict in one line, then the claim table, then what a follow-up should do.`;
 
+// The orchestrator (record 0070; docs/reference/specs/orchestration-plane.md
+// item 11): the plane's chat preset — one long-lived thread per person beside
+// the panels, and `agent:orchestrator` from any channel a grant admits. It
+// reads the fleet from the plane's projections (the `plane_show` tool answers
+// the SAME rows the panels paint) and never from its own context: every fleet
+// fact cites the row it read, and a question the tables cannot answer says so
+// instead of recalling. Machine `none`, identity `none`: no workspace, no
+// shell, no credential — the read tool set is its whole reach, and its writes
+// are the registry's fenced commands through the door (record 0070's later
+// units), never a tool here. The prose speaks record 0066's twelve nouns:
+// thread, run, agent, pipeline, unit, round, budget, follow-up, verdict,
+// outcome, card, pull request — no thirteenth noun rides in.
+const ORCHESTRATOR_SYSTEM = `You are Switchboard's orchestrator: the control plane's chat, answering a person about their fleet — every thread, run, agent, pipeline, unit, round, budget, follow-up, verdict, outcome, card and pull request the plane's tables carry.
+
+You have no workspace and no shell. Your tools: \`plane_show\` (the plane's live tables — every live and recently ended run, every unit and every tracked pull request, each with its owner and its health: the same rows the /plane panels paint, seen as the person who asked may see them), \`recall\` and \`notes\` (this thread's log and your notepad), and \`update_status\`.
+
+EVERY FLEET FACT COMES FROM THE TABLES, NEVER FROM MEMORY. Before answering any question about the fleet — what is running, which unit is idle, which pull request is merge-ready and nobody's — read the tables with \`plane_show\` and cite the row you read: name the run id, the unit or the pull request the answer stands on, so the person can check it against the panel beside you. Never answer a standing question from this conversation's earlier turns or your own context: an earlier turn is history, the table is now. A question the tables cannot answer — a why the rows do not carry, a fact outside the fleet — is answered "the tables do not say", plainly, instead of recalling or guessing; say what the rows do show and where the answer would live.
+
+You cannot run commands, edit code, merge or stop anything from here: acting on the fleet goes through Switchboard's own commands, which the person's own words reach through the door under their own grants — say what you found and let their next sentence act.
+
+${statusCardRule('"Read the plane tables", "Check the run\'s standing"')} A one-read answer needs no checklist.
+
+${BREVITY_RULE}
+${FENCED_CONTENT_RULE}
+Lead with the answer, then the cited rows — short lines, the row's own words. Your reply renders in the plane's chat column or the channel the question came from.`;
+
 // The conductor (docs/reference/specs/agent-conductor.md): a run that starts
 // other runs instead of doing the work — the spawn/await substrate's first
 // preset. A child is a `dispatch()` run as the requesting user, in a thread of
@@ -825,6 +851,20 @@ const WORK_PRESETS = {
     ...loopBudget("explore"),
     // No built-in effort: the deployment decides, as for coding.
   },
+  orchestrator: {
+    name: "orchestrator",
+    description:
+      "Answers fleet questions from the plane's live tables — runs, units, pull requests — with the row cited. No workspace or shell.",
+    system: ORCHESTRATOR_SYSTEM,
+    toolset: "orchestrator",
+    // The plane read is a call in the bot process: nothing is provisioned
+    // and no credential is minted (record 0070, criterion 3).
+    machine: "none",
+    identity: "none",
+    tiers: ["fast", "strong"], // reads and cites rows: may run fast
+    maxTokens: 16000,
+    ...loopBudget("orchestrator"),
+  },
 } satisfies Record<string, AgentDef>;
 
 export const AGENTS: Record<string, AgentDef> = {

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

@@ -144,7 +144,15 @@ export function intakeReceiptRetentionMs(catchUpWindowMs: number): number {
 export const INTAKE_RECOVERY_WINDOW_MS = 10 * MINUTE_MS;
 
 /** The presets that run the tool loop, and the one pipeline preset. */
-export const LOOP_PRESETS = ["general", "coding", "review", "research", "explore", "conductor"] as const;
+export const LOOP_PRESETS = [
+  "general",
+  "coding",
+  "review",
+  "research",
+  "explore",
+  "conductor",
+  "orchestrator",
+] as const;
 export type LoopPreset = (typeof LOOP_PRESETS)[number];
 export type Preset = LoopPreset | "ship";
 
@@ -165,6 +173,10 @@ export const ASKS: Readonly<Record<Preset, number>> = {
   research: 8,
   explore: 120,
   conductor: 120,
+  // The plane's chat preset (record 0070): reads the fleet's tables and
+  // answers; a turn is a projection read plus a write-up, so its ask sits
+  // between general's and research's kind of work, with room for a few reads.
+  orchestrator: 10,
 };
 
 /** The rounds a ship loop is made of. `findings` is a coding child handed the
@@ -187,6 +199,7 @@ export const PRESET_FLOORS: Readonly<Record<LoopPreset, number>> = {
   research: 3,
   explore: 15,
   conductor: 15,
+  orchestrator: 2,
 };
 export const FLOORS: Readonly<Record<RoundKind, number>> = {
   coding: PRESET_FLOORS.coding,
@@ -265,6 +278,7 @@ export const POST_STEP_MINUTES: Readonly<Record<Preset, number>> = {
   research: 0,
   explore: 0,
   conductor: 0,
+  orchestrator: 0,
   ship: 0,
 };
 

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

@@ -99,6 +99,7 @@ export const ROUND_STAGE = {
   dequeued: "fix",
   aborted: "hold",
   stopped: "hold",
+  held: "hold",
   continued: "continue",
   idle: "idle",
 } as const satisfies Record<ShipRoundOutcome, Stage | "start" | "continue" | "hold">;
@@ -171,6 +172,7 @@ export const ROUND_OUTCOME_WORDS = {
   dequeued: "removed from the merge queue",
   aborted: "aborted",
   stopped: "stopped",
+  held: "held",
   continued: "continuing",
   idle: "idle",
 } as const satisfies Record<ShipRoundOutcome, string>;

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

@@ -265,6 +265,15 @@ export function reissueSteerSentence(provider: string): string {
   return `the model provider ${provider} is answering again — re-issue the held turn and continue`;
 }
 
+/** The reissue steer read back (model-proxy item 12a): what the pi harness
+ *  releases a held turn on — the sentence above with any provider's name,
+ *  judged whole against the inbox row's text beside its `plane` sender, so a
+ *  parked turn is only re-driven by the plane's own words, never a person's
+ *  follow-up that happens to mention a provider. */
+export function isReissueSteerText(text: string): boolean {
+  return /^the model provider .+ is answering again — re-issue the held turn and continue$/.test(text.trim());
+}
+
 /** The checkpoint steer's causes: an in-flight call past its bound (or the
  *  no-bound line) and a coding round with no pushed head past `noPushMinutes`. */
 export type SteerCause = "long_call" | "no_push";

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

@@ -187,7 +187,7 @@ export interface VendorRef {
 /** The one vendor parse (record 0052): `parseModelRef` is the only other parser of a
  *  ref. A block that declares a vendor name uses it; a block that declares
  *  `vendor: model`, or a model id that carries its own vendor prefix
- *  (`openrouter/anthropic/claude-sonnet-5`), reads the vendor off the id's
+ *  (`openrouter/<vendor>/<model>`), reads the vendor off the id's
  *  first segment; otherwise the block's own name is the vendor. `catalog`
  *  never enters: a block named unlike its catalog still serves the vendor the
  *  declaration or the id names. */
@@ -272,11 +272,11 @@ export function billerHarnessProvider(biller: string | undefined): BillerHarness
 /** The env var Anthropic's own SDK reads when an `anthropic` provider block names none. */
 export const ANTHROPIC_API_KEY_ENV = "ANTHROPIC_API_KEY";
 
-/** "anthropic/claude-opus-5" -> { provider: "anthropic", model: "claude-opus-5" } */
+/** "<provider>/<model>" -> { provider, model }: the split at the ref's first slash. */
 export function parseModelRef(ref: string): { provider: string; model: string } {
   const i = ref.indexOf("/");
   if (i === -1) {
-    throw new Error(`Model "${ref}" must be qualified as "<provider>/<model>", e.g. "anthropic/claude-opus-5"`);
+    throw new Error(`Model "${ref}" must be qualified as "<provider>/<model>"`);
   }
   return { provider: ref.slice(0, i), model: ref.slice(i + 1) };
 }

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

@@ -128,6 +128,13 @@ export type RunNoteKind =
    *  (docs/reference/specs/run-history.md item 37); the summary says how many calls were
    *  in flight at the kill and how each was settled. Published by the runner. */
   | "resumed"
+  /** The restart the run's `restarting` close promised never claimed the run
+   *  (issue 2081): its dispatch died between the close and the successor's
+   *  claim, so this interrupted close is the run's end, not a restart. The
+   *  summary names how the dispatch ended. Published by the dispatcher over
+   *  the closed record — a kind of its own, so the interruption's cause is
+   *  still read off the roll's earlier words, never off the dispatch error. */
+  | "restart_died"
   /** A control was decided against the model card and is not native (record
    *  0052): a fallback (`applied` differs from `asked`, `vouched` true) or
    *  an unvouched send (`vouched` false). One note per degraded control,
@@ -332,6 +339,7 @@ export const RUN_NOTE_KINDS = [
   "mcp_unavailable",
   "follow_up",
   "resumed",
+  "restart_died",
   "control_degraded",
   "seed",
   "redispatch",
@@ -436,6 +444,11 @@ export type ShipRoundOutcome =
   | "dequeued"
   | "aborted"
   | "stopped"
+  /** The round-0 coding child concluded its round with an answer instead of a
+   *  pull request (issue 2086): its handoff records a deviation — a stop
+   *  condition, a blocked precondition — so the unit ends held for the
+   *  person's word and no renewal is judged. */
+  | "held"
   /** The coding round ended at its lease with the unit unfinished and the row
    *  showing progress, and the grant renewed: the next segment opens (decision 0046). */
   | "continued"

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

@@ -776,6 +776,25 @@ export type UnitEnding =
       round: RoundRef;
       reviewRounds: number;
     }
+  /** The round-0 coding child concluded its round with an answer instead of a
+   *  pull request (issue 2086): its handoff records a deviation — a stop
+   *  condition it hit, a precondition that does not hold, a question it could
+   *  not resolve — read off the record, never its prose. The round has ended;
+   *  the unit ends held with the deviations as its reason and waits for the
+   *  person's word (it idles when the flag is on — the one held cause that
+   *  does), and the round is never renewed as a second segment: the renewal
+   *  grant (decision 0046, amended) is for a lease that ran out mid-work, not
+   *  for a round with an answer. */
+  | {
+      kind: "held";
+      cause: "blocked";
+      pr?: PrRef;
+      round: RoundRef;
+      runId: string;
+      reason: string;
+      finalReply?: string;
+      reviewRounds: number;
+    }
   | { kind: "merge_refused"; pr: PrRef; reason: string; reviewRounds: number }
   | { kind: "round_cap"; maxRounds: number; reviewRounds: number }
   | {
@@ -870,22 +889,20 @@ export type UnitEnding =
 
 /** The kinds that idle: every ending but the ended ones — the unit is
  *  unfinished (a cap, a stop, an abort, a refused merge, a segment's end) and
- *  a reply could continue it. `merged`, `already_landed`, `merge_ready`,
- *  `held` and `refused` never idle: the first two are done, merge-ready waits
- *  only for a person's merge, held waits only for a person's receipt (a fix
- *  round could change nothing, so nothing here can continue it), and a
- *  refused child would be refused again. */
-export type IdleWhy = Exclude<
-  UnitEnding["kind"],
-  "idle" | "merged" | "already_landed" | "merge_ready" | "held" | "refused"
->;
+ *  a reply could continue it. `merged`, `already_landed`, `merge_ready` and
+ *  `refused` never idle: the first two are done, merge-ready waits only for a
+ *  person's merge, and a refused child would be refused again. A gated or
+ *  draft `held` never idles either — it waits only for a person's receipt at
+ *  the pull request, which no thread reply can produce — but a blocked hold
+ *  (issue 2086) waits for exactly the person's word the idle's wake carries,
+ *  so it alone idles; `idleEnding` draws that line by cause. */
+export type IdleWhy = Exclude<UnitEnding["kind"], "idle" | "merged" | "already_landed" | "merge_ready" | "refused">;
 
 const NEVER_IDLES: ReadonlySet<UnitEnding["kind"]> = new Set([
   "idle",
   "merged",
   "already_landed",
   "merge_ready",
-  "held",
   "refused",
 ]);
 
@@ -1354,10 +1371,11 @@ function end(s: UnitPipelineState, ending: UnitEnding, notes: CoordinatorNote[]
 function idleEnding(s: UnitPipelineState, ending: UnitEnding): Extract<UnitEnding, { kind: "idle" }> | undefined {
   if ((s.input.idleDays ?? 0) <= 0) return undefined;
   if (NEVER_IDLES.has(ending.kind)) return undefined;
-  const old = ending as Exclude<
-    UnitEnding,
-    { kind: "idle" | "merged" | "already_landed" | "merge_ready" | "held" | "refused" }
-  >;
+  // A gated or draft hold waits only for a person's receipt at the pull
+  // request — no thread reply can continue it — while a blocked hold (issue
+  // 2086) waits for exactly the person's word the wake carries, so it idles.
+  if (ending.kind === "held" && ending.cause !== "blocked") return undefined;
+  const old = ending as Exclude<UnitEnding, { kind: "idle" | "merged" | "already_landed" | "merge_ready" | "refused" }>;
   const grant = s.input.grant ?? DEFAULT_GRANT;
   // Unspent: an idle spends no renewal — the wake's segment does (this plan's
   // fifth unit) — so the row says what the grant still holds.
@@ -1996,14 +2014,42 @@ function settlePrCheck(s: UnitPipelineState, phase: Extract<Phase, { at: "pr-che
         return end(s, { kind: "already_landed", landed, round, runId: phase.runId, reviewRounds: s.reviewRounds }, [
           roundNote(round, "completed"),
         ]);
-      // Round 0 ended without a pull request: the segment is over with the unit
-      // unfinished, and the grant decides whether the next opens (decision
-      // 0046, Renewal). Progress is read off the child's record — a head pushed
-      // to the unit's branch since the segment started, or a handoff that moved —
-      // never off its words; the decision then asks the grant's count, the cap
-      // and the fit, in that order, and a refusal names the clause. A plain
-      // abort keeps its old shape when nothing was pushed under a grant of zero:
-      // a clarifying question is not a stop to explain.
+      // A concluded round is never renewed (issue 2086; decision 0046,
+      // amended): a handoff recording a deviation is the round's own ending —
+      // a stop condition the child hit, a precondition that does not hold, a
+      // question it could not resolve — a typed fact off the record, never its
+      // prose. The unit ends held with the deviations as its reason and waits
+      // for the person's word; no renewal is judged and no second segment
+      // opens — the grant is for a lease that ran out mid-work, and a renewed
+      // segment would re-run the same brief with no memory of the answer. A
+      // handoff without deviations is the lease-end checkpoint (follow-ups,
+      // unproven criteria) and leaves the renewal decision below to the grant.
+      const deviations = phase.childHandoff?.deviations ?? [];
+      if (deviations.length > 0)
+        return end(
+          s,
+          {
+            kind: "held",
+            cause: "blocked",
+            ...(s.pr !== undefined ? { pr: s.pr } : {}),
+            round,
+            runId: phase.runId,
+            reason: deviations.map((dv) => `${dv.from} → ${dv.to} — ${dv.why}`).join("; "),
+            ...(phase.finalReply !== undefined ? { finalReply: phase.finalReply } : {}),
+            reviewRounds: s.reviewRounds,
+          },
+          [roundNote(round, "held")],
+        );
+      // Round 0 ended without a pull request and without an ending of its own:
+      // the segment is over with the unit unfinished — a lease end, never a
+      // concluded round (those ended above) — and the grant decides whether
+      // the next opens (decision 0046, Renewal). Progress is read off the
+      // child's record — a head pushed to the unit's branch since the segment
+      // started, or a checkpoint handoff that moved — never off its words; the
+      // decision then asks the grant's count, the cap and the fit, in that
+      // order, and a refusal names the clause. A plain abort keeps its old
+      // shape when nothing was pushed under a grant of zero: a clarifying
+      // question is not a stop to explain.
       const grant = s.input.grant ?? DEFAULT_GRANT;
       const session = s.input.session;
       const progress = progressOf({
@@ -2707,6 +2753,19 @@ export function renderUnitReport(
           draftReissue,
         ]);
       }
+      // The blocked hold (issue 2086): the coding child concluded its round
+      // with an answer instead of a pull request — its handoff's deviations
+      // are the reason — so the report leads with that answer and says plainly
+      // that no renewal was spent and no second coding child ran: the person's
+      // word in this thread is what continues the unit.
+      if (e.cause === "blocked") {
+        if (!shows(verbosity, "verbose")) return `⏸️ Held: blocked — ${e.reason}${prLine}`;
+        return join([
+          `⏸️ Held after ${rounds}: the coding child of round ${e.round.index} concluded its round blocked instead of opening a pull request — ${e.reason}.${prLine}`,
+          writeUpPointer(s, e.round.kind, e.runId),
+          `No renewal was spent and no second coding child ran — a concluded round is not renewed (a renewal continues a budget that ran out mid-work). Next step: your word in this thread — answer what the child raised, and the unit continues from there. ${reissue}`,
+        ]);
+      }
       // The person's next step is the report's whole point (issue 1990): the
       // human-gated rows are named with the reviewer's own words, and the
       // re-issue line says the attempt resumes at the review round — item 10's

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

@@ -54,7 +54,9 @@ const sameSha = (a: string, b: string): boolean => {
 /** Progress is a fact the row records after unit eight and the runner reads
  *  without a model: the last head pushed to the unit's branch that differs from
  *  the head the segment started at and is not older than the lease; failing
- *  that, a handoff whose follow-ups shrank or whose deviations grew. */
+ *  that, a checkpoint handoff whose follow-ups shrank. A handoff carrying
+ *  deviations never reaches this decision: it is the round's own ending (issue
+ *  2086) and the unit ends held before any renewal is judged. */
 export function progressOf(input: ProgressInput): Progress {
   const last = [...input.pushed].reverse().find((h) => h.ref === input.branch);
   if (last !== undefined) {
@@ -69,8 +71,7 @@ export function progressOf(input: ProgressInput): Progress {
   const pushWhy = `no head newer than the budget's start was pushed to \`${input.branch}\``;
   if (input.handoff === undefined) return { progressed: false, why: pushWhy };
   const { previous, current } = input.handoff;
-  if (current.followUps.length < previous.followUps.length || current.deviations.length > previous.deviations.length)
-    return { progressed: true, by: "handoff" };
+  if (current.followUps.length < previous.followUps.length) return { progressed: true, by: "handoff" };
   return { progressed: false, why: `${pushWhy} and the write-up is unchanged` };
 }
 

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

@@ -162,7 +162,7 @@ export type StatusActivity = { kind: "command"; tool: string; command: string }
 
 /** A structured progress frame; adapters decide how to render it. */
 export interface StatusUpdate {
-  /** one-line headline, e.g. "⚡ review on anthropic/claude-fable-5 · 42s" */
+  /** one-line headline, e.g. "⚡ review on <provider>/<model> · 42s" */
   title: string;
   /** the agent's checklist and any lead lines, one per line */
   detail?: string;