@coreplane/switchboard 1.258.0 → 1.260.0

package/dist/assets/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "switchboard",
-  "version": "1.258.0",
+  "version": "1.260.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "switchboard",
-      "version": "1.258.0",
+      "version": "1.260.0",
       "license": "Apache-2.0",
       "workspaces": [
         "web",
@@ -20445,7 +20445,7 @@
     },
     "packages/switchboard": {
       "name": "@coreplane/switchboard",
-      "version": "1.258.0",
+      "version": "1.260.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.258.0",
+  "version": "1.260.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.258.0",
-  "commit": "05d8b84a387c7b7c15ed8dd2dc30f08a5982a981",
-  "builtAt": "2026-09-20T17:05:48.184Z"
+  "version": "1.260.0",
+  "commit": "33c6cd103ce9d8a49be5249f98306fe46160f81c",
+  "builtAt": "2026-09-21T15:19:23.063Z"
 }

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

@@ -47,11 +47,9 @@ export function machineNeedsRepo(machine: MachineClass): boolean {
 export const IDENTITIES = ["none", "read", "write"] as const;
 export type Identity = (typeof IDENTITIES)[number];
 
-/** The model tiers a preset may run on (the one-door plan's tiers rule): the
- *  `fast` tier is the router's own model (`routing.model`), everything else is
- *  `strong`. Each preset declares its allowed set below (`AgentDef.tiers`);
- *  a parent choosing a child's model at spawn is held to the child preset's
- *  set, and escalation is a new run — a run's tier is fixed at dispatch. */
+/** The model tiers a preset may run on. The retired classifier leaves no
+ *  configured fast-tier ref, so current run models resolve strong; declarations
+ *  remain explicit for model-card tiering and future configured catalogues. */
 export const MODEL_TIERS = ["fast", "strong"] as const;
 export type ModelTier = (typeof MODEL_TIERS)[number];
 

package/dist/assets/src/core/authz/policy.ts

@@ -118,6 +118,11 @@ export const POLICY: readonly Rule[] = [
   // `pulls rebase` force-pushes the pipeline's branches and can start a paid
   // fix round (record 0071): a grant, never a chat baseline.
   { action: "pulls:write", resource: "command", when: [grant("pulls:write")] },
+  // `pulls merge|enqueue` (record 0070, criterion 4): a person's merge through
+  // the door — the grant, never a baseline, so a grant-less person has a
+  // thread that reads everything and merges nothing. The release pull
+  // request's handoff and the approval fences are the handler's own refusals.
+  { action: "merge:write", resource: "command", when: [grant("merge:write")] },
 
   // ── repos ────────────────────────────────────────────────────────────────
   { action: "repo:read", resource: "command", when: [grant("repo:read")] },

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

@@ -236,6 +236,13 @@ 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;
 
+/** 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
+ *  replacement claim without shortening the parent's first wait; a successor
+ *  found after this deadline still wins because read-record searches first. */
+export const RESTART_CLAIM_GRACE_MS = minutesToMs(SHIP_WAIT.chunkMinutes);
+
 /** The plane's table (docs/decisions/0064): how long a finished run stays on
  *  it, a reservation's window, and the default re-ask cadence — how often a
  *  silent resident something waits on is probed (`plane.reaskMinutes`

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

@@ -111,12 +111,24 @@ export interface ThreadEventAttachment {
   mediaType: string;
   data: string;
   name?: string;
+  /** The accepted channel file's by-reference source, when one exists, so the
+   *  coding child can stage it without moving the inline bytes through a
+   *  second request. */
+  staged?: {
+    name: string;
+    size: number;
+    type: string;
+    url: string;
+    messageId: string;
+    workspaceIndex?: number;
+  };
 }
 
 export interface ThreadEvent {
   /** Assigned by the store's append, in arrival order, per unit. */
   seq: number;
-  /** The channel's message id, when the platform gave one. */
+  /** The channel's message id, or another producer's stable event id. An
+   *  append that repeats it on one unit returns the original row. */
   id?: string;
   /** The sender (platform-namespaced) and the display name the channel knew. */
   sender: string;
@@ -174,11 +186,24 @@ export function capThreadEvent<T extends Omit<ThreadEvent, "seq"> & { seq?: numb
   }
 }
 
+const isThreadEventStagedFile = (v: unknown): v is NonNullable<ThreadEventAttachment["staged"]> =>
+  isObject(v) &&
+  typeof v.name === "string" &&
+  typeof v.size === "number" &&
+  Number.isInteger(v.size) &&
+  v.size > 0 &&
+  typeof v.type === "string" &&
+  typeof v.url === "string" &&
+  typeof v.messageId === "string" &&
+  (v.workspaceIndex === undefined ||
+    (typeof v.workspaceIndex === "number" && Number.isInteger(v.workspaceIndex) && v.workspaceIndex >= 0));
+
 const isThreadEventAttachment = (v: unknown): v is ThreadEventAttachment =>
   isObject(v) &&
   typeof v.mediaType === "string" &&
   typeof v.data === "string" &&
-  (v.name === undefined || typeof v.name === "string");
+  (v.name === undefined || typeof v.name === "string") &&
+  (v.staged === undefined || isThreadEventStagedFile(v.staged));
 
 const isThreadEventMode = (v: unknown): v is ThreadEventMode => v === "steer" || v === "wake" || v === "interrupt";
 
@@ -399,6 +424,26 @@ export interface UnitIdle {
   wakes: number;
 }
 
+/** The durable answer to one indexed idle wait. The wait id is the key on the
+ * unit row, so a reclaimed runner receives byte-for-byte the decision the
+ * first caller stored instead of spending a renewal or consuming an event
+ * twice. */
+export type UnitWakeAnswer =
+  | {
+      kind: "segment";
+      index: number;
+      from?: string;
+      runId?: string;
+      spendUsd: number | null;
+      handoff?: Handoff;
+      texts: string[];
+      senders: string[];
+      leaseMs?: number;
+    }
+  | { kind: "answered"; reply: string }
+  | { kind: "stopped" }
+  | { kind: "expired" };
+
 /** What the severity gate caught on a round: the level in force and the gated findings as `id (severity)`. */
 export interface RoundGate {
   level: AddressSeverity;
@@ -456,14 +501,20 @@ export interface CoordinatorUnit {
    *  (null once any run's cost is unknown), `handoff` that child's lists, and
    *  `wakes` how many wakes this idle has answered — zero at the write. */
   idle?: UnitIdle;
+  /** Answers to indexed idle waits, keyed by the wait step's durable identity. */
+  wakes?: Record<string, UnitWakeAnswer>;
   /** The round boundaries the coordinator reported, oldest first (the `ship_round`
    *  vocabulary). `gate` rides an approve the machine's severity check caught
    *  carrying a finding at or above the level in force ([agent-ship](../../../docs/reference/specs/agent-ship.md)
    *  item 9) — a mismatch to be seen, since the child's parser holds an approve
    *  to the same level. */
   rounds: Array<{ index: number; agent: string; outcome: string; at: number; gate?: RoundGate }>;
-  /** How the unit ended: the ending's kind and the thread's report, when it has. */
-  ending?: { kind: string; report: string; at: number };
+  /** How the unit ended: the ending's kind and the thread's report, when it
+   *  has. `cause` names the machine's reason behind a driver-posted kind;
+   *  `step` and `round` locate that reason without parsing the report. For a
+   *  `step_threw` failure the driver records all available fields before it
+   *  rethrows (issue 2100); unit-start has no round yet. */
+  ending?: { kind: string; report: string; at: number; cause?: string; step?: string; round?: number };
   startedAt?: number;
 }
 
@@ -548,6 +599,27 @@ const isSegment = (v: unknown): boolean =>
   (v.runId === undefined || isText(v.runId)) &&
   typeof v.at === "number";
 
+export const isUnitWakeAnswer = (v: unknown): v is UnitWakeAnswer => {
+  if (!isObject(v)) return false;
+  if (v.kind === "answered") return typeof v.reply === "string";
+  if (v.kind === "stopped" || v.kind === "expired") return true;
+  return (
+    v.kind === "segment" &&
+    typeof v.index === "number" &&
+    Number.isInteger(v.index) &&
+    v.index >= 1 &&
+    (v.from === undefined || isText(v.from)) &&
+    (v.runId === undefined || isText(v.runId)) &&
+    (v.spendUsd === null || isFinite(v.spendUsd)) &&
+    (v.handoff === undefined || isHandoffShape(v.handoff)) &&
+    Array.isArray(v.texts) &&
+    v.texts.every((text) => typeof text === "string") &&
+    Array.isArray(v.senders) &&
+    v.senders.every((sender) => isText(sender)) &&
+    (v.leaseMs === undefined || (isFinite(v.leaseMs) && v.leaseMs > 0))
+  );
+};
+
 export function isCoordinatorUnit(v: unknown): v is CoordinatorUnit {
   if (!isObject(v)) return false;
   const r = v;
@@ -562,6 +634,13 @@ export function isCoordinatorUnit(v: unknown): v is CoordinatorUnit {
   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;
+  if (
+    r.wakes !== undefined &&
+    (!isObject(r.wakes) ||
+      Array.isArray(r.wakes) ||
+      !Object.entries(r.wakes).every(([waitId, answer]) => STEP_NAME_PATTERN.test(waitId) && isUnitWakeAnswer(answer)))
+  )
+    return false;
   if (
     !Array.isArray(r.rounds) ||
     r.rounds.length > MAX_ROUNDS ||
@@ -578,7 +657,16 @@ export function isCoordinatorUnit(v: unknown): v is CoordinatorUnit {
     return false;
   if (
     r.ending !== undefined &&
-    !(isObject(r.ending) && isText(r.ending.kind) && isText(r.ending.report, MAX_REPORT) && isFinite(r.ending.at))
+    !(
+      isObject(r.ending) &&
+      isText(r.ending.kind) &&
+      isText(r.ending.report, MAX_REPORT) &&
+      isFinite(r.ending.at) &&
+      (r.ending.cause === undefined || isText(r.ending.cause, 64)) &&
+      (r.ending.step === undefined || (typeof r.ending.step === "string" && STEP_NAME_PATTERN.test(r.ending.step))) &&
+      (r.ending.round === undefined ||
+        (typeof r.ending.round === "number" && Number.isInteger(r.ending.round) && r.ending.round >= 0))
+    )
   )
     return false;
   if (r.startedAt !== undefined && !isFinite(r.startedAt)) return false;