@coreplane/switchboard 1.206.0 → 1.207.0

package/dist/assets/deploy/cloudflare/worker.ts

@@ -64,7 +64,7 @@ const traceSinks = [workerLogSink((line) => console.log(line))];
 export interface Env {
   SWITCHBOARD: DurableObjectNamespace<SwitchboardServer>;
   /** The ship coordinator (coordinator.ts): `POST /admin/coordinator/instances`
-   *  creates its instances; the state Worker's finish sends them `run finished`. */
+   *  creates its instances; the state Worker's finish sends them `run-finished-<runId>`. */
   SHIP_COORDINATOR: Workflow<ShipCoordinatorParams>;
   // secrets (wrangler secret put ...)
   SLACK_BOT_TOKEN: string;

package/dist/assets/deploy/cloudflare-memory/worker.ts

@@ -147,7 +147,7 @@ export interface Env {
   /** Delivery snapshots (delivery item 10): ONE DeliveryDO (named "delivery"), one snapshot per repository. */
   DELIVERY: DurableObjectNamespace<DeliveryDO>;
   /** The ship coordinator Workflow in the bot's shim Worker (run-history item
-   *  47): where `RunHistoryDO.finish` sends `run finished:<runId>` for a record
+   *  47): where `RunHistoryDO.finish` sends `run-finished-<runId>` for a record
    *  carrying `parentInstanceId`. Optional: this Worker deploys without it (the
    *  binding is a cross-script one, and the class must exist on the bot before
    *  the state Worker may name it), and a finish then commits with no event. */
@@ -1505,7 +1505,7 @@ export class RunHistoryDO extends DurableObject<Env> {
       await this.ctx.storage.setAlarm(systemClock() + RUN_SWEEP_INTERVAL_MS);
     const event = await sendRunFinished(this.env.SHIP_COORDINATOR, record);
     if (event.kind === "failed")
-      console.warn(`[runs/finish] ${runId} → run finished not delivered to ${event.instance}: ${event.reason}`);
+      console.warn(`[runs/finish] ${runId} → ${event.type} not delivered to ${event.instance}: ${event.reason}`);
     return { ...out, event: event.kind };
   }
 

package/dist/assets/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "switchboard",
-  "version": "1.206.0",
+  "version": "1.207.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "switchboard",
-      "version": "1.206.0",
+      "version": "1.207.0",
       "license": "Apache-2.0",
       "workspaces": [
         "web",
@@ -18999,7 +18999,7 @@
     },
     "packages/switchboard": {
       "name": "@coreplane/switchboard",
-      "version": "1.206.0",
+      "version": "1.207.0",
       "license": "Apache-2.0",
       "dependencies": {
         "@anthropic-ai/sdk": "^0.124.0",

package/dist/assets/package.json

@@ -1,6 +1,6 @@
 {
   "name": "switchboard",
-  "version": "1.206.0",
+  "version": "1.207.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.206.0",
-  "commit": "c46066984259fae88e1f242c39cc38c8affe0776",
-  "builtAt": "2026-09-12T15:07:26.252Z"
+  "version": "1.207.0",
+  "commit": "123a4b1aba2acf34fc922a24f3493fa6c05df2d9",
+  "builtAt": "2026-09-14T00:08:39.382Z"
 }

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

@@ -38,8 +38,11 @@ export function idempotencyKeyFor(parentInstanceId: string, step: string): strin
 
 /** The event a child's terminal record sends its parent: the type carries the
  *  run id, so each `waitForEvent` matches its own child and a duplicate is
- *  buffered harmlessly. */
-export const RUN_FINISHED_EVENT_PREFIX = "run finished:";
+ *  buffered harmlessly. An event type is the platform's alphabet — letters,
+ *  digits, `-` and `_` (`^[a-zA-Z0-9_][a-zA-Z0-9-_]*$`); a space, a colon or a
+ *  dot is refused as `workflow.invalid_event_type`, and the parent never hears
+ *  the child end. A run id is a UUID, already inside it. */
+export const RUN_FINISHED_EVENT_PREFIX = "run-finished-";
 export function runFinishedEventType(runId: string): string {
   return `${RUN_FINISHED_EVENT_PREFIX}${runId}`;
 }
@@ -54,14 +57,26 @@ export interface RunFinishedPayload {
 }
 
 /** What a coordinator's spawn stamps on the child's every row: the instance
- *  the child belongs to and the key the spawn carried. */
+ *  the child belongs to and the key the spawn carried — and, for the child's
+ *  own post-step, the base its pull request targets. */
 export interface CoordinatorTag {
   parentInstanceId: string;
   idempotencyKey: string;
+  /** The branch the child's pull request targets: the plan's base
+   *  (`CoordinatorInstance.base`), set by the spawn when the instance knows it.
+   *  A coordinator's child is dispatched AT its unit branch so the resident
+   *  attaches there, which makes the binding ref the branch itself — no base
+   *  the post-step could resolve from the thread — so the spawn says it. An
+   *  instruction to the run like `DispatchOptions.contract`, not a fact about
+   *  it: the fact the record keeps is the `pr_opened` it leads to, and
+   *  `coordinatorFields` leaves it off the rows. */
+  base?: string;
 }
 
 /** The tag as the two flat record fields, or nothing — so a row, a summary
- *  and a record spread the same thing and a run with no coordinator carries no key. */
+ *  and a record spread the same thing and a run with no coordinator carries no
+ *  key. The base never rides here: rows and records keep the shape written
+ *  before it existed. */
 export function coordinatorFields(tag: CoordinatorTag | undefined): {
   parentInstanceId?: string;
   idempotencyKey?: string;
@@ -207,7 +222,7 @@ export interface WorkflowSender {
 /** How a send ended. `none`: the record names no instance. `no-binding`: the
  *  Worker has no coordinator binding. `failed`: the engine refused (the
  *  instance ended, or is unknown) — swallowed, never thrown: the commit stands,
- *  and the parent's `waitForEvent` timeout falls back to `read-record`. */
+ *  and the parent's wait falls back to `read-record` at its next chunk. */
 export type RunFinishedSend =
   | { kind: "sent"; instance: string; type: string }
   | { kind: "none" }

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

@@ -13,9 +13,12 @@
 // status and the text of a JSON object the bot stamped with its clock (`at`) —
 // so the mapping onto the machine is pure and runs identically on replay; an
 // answer the runner cannot read fails the instance at once rather than twelve
-// times over. Every wait is a `waitForEvent` typed `run finished:<runId>` for
-// the child's clipped budget plus the margin, and every wait — event or
-// timeout alike — is confirmed by a `read-record` before the machine acts on it.
+// times over. Every wait is a `waitForEvent` typed `run-finished-<runId>` for
+// one chunk of the child's budget (the machine slices the budget plus the
+// margin, `WAIT_CHUNK_MS`, and asks `read-record` between the slices), and
+// every wait — event or timeout alike — is confirmed by a `read-record` before
+// the machine acts on it, so an event the engine never delivered costs a
+// chunk, not the budget.
 //
 // Units run one at a time in the plan's order, each once its in-play
 // dependencies are done. `done` is merged: a plan branch's pull request is the

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

@@ -104,7 +104,13 @@ export type RunNoteKind =
    *  item 24). The same text the card carries; published by the dispatcher
    *  after the attach, before the first turn, so the run page explains a
    *  sandbox run that shows resident steps. */
-  | "cold_sandbox";
+  | "cold_sandbox"
+  /** A coding run submitted a PR description but the post-step opened no
+   *  pull request because the branch it observed IS the base the pull
+   *  request would target (docs/reference/specs/pr-description.md item 5) —
+   *  the summary names the branch. Published by the post-step, so a unit
+   *  that ends without a pull request says why on the record and the card. */
+  | "pr_not_opened";
 
 /** Every `RunNoteKind`, as a value (a reader that filters notes by kind uses
  *  this; adding a kind to the union without adding it here is a type error). */
@@ -123,6 +129,7 @@ export const RUN_NOTE_KINDS = [
   "resumed",
   "description_turn",
   "cold_sandbox",
+  "pr_not_opened",
 ] as const satisfies readonly RunNoteKind[];
 type _EveryKindListed = [RunNoteKind] extends [(typeof RUN_NOTE_KINDS)[number]] ? true : never;
 const _everyKindListed: _EveryKindListed = true;

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

@@ -129,7 +129,7 @@ export interface RunRecord {
    *  on every run a person or a schedule started. */
   parentRunId?: string;
   /** The coordinator instance this run is a child of (item 48): the state
-   *  Worker's finish sends that instance `run finished:<id>` for a record
+   *  Worker's finish sends that instance `run-finished-<id>` for a record
    *  carrying it, and `read-record` answers only for a matching instance.
    *  Absent on every run no coordinator spawned. */
   parentInstanceId?: string;

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

@@ -414,8 +414,9 @@ type Phase =
   | { at: "branch" }
   | { at: "spawn"; round: RoundRef; busy: number }
   | { at: "busy-wait"; round: RoundRef; runId?: string; n: number }
-  | { at: "wait"; round: RoundRef; runId: string; n: number; budgetMinutes: number }
-  | { at: "read"; round: RoundRef; runId: string; n: number; budgetMinutes: 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: "pr-check"; round: RoundRef; runId: string; childHead?: string; finalReply?: string }
   | { at: "merge"; pr: PrRef; headSha: string; n: number; since: number }
   | { at: "merge-sleep"; pr: PrRef; headSha: string; n: number; since: number }
@@ -445,6 +446,14 @@ export interface UnitPipelineState {
 
 /** Past a child's budget, the parent asks the bot instead of waiting on. */
 export const WAIT_MARGIN_MS = 5 * MIN;
+/** One slice of a wait on a child. The child's budget plus the margin is
+ *  walked in chunks with a `read-record` between them, so an event the engine
+ *  never delivered — refused, lost, sent to an instance that had ended — costs
+ *  one chunk of the runner's time, not the child's whole budget. Five minutes
+ *  is the machine's one cadence for asking the bot what it cannot be told (the
+ *  margin and the merge poll are the same number), and it keeps a round to a
+ *  few steps: a coding child's 45 minutes are ten waits and ten reads. */
+export const WAIT_CHUNK_MS = 5 * MIN;
 /** How often the runner asks for the merge while the guards are still pending, and for how long at most. */
 export const MERGE_POLL_MS = 5 * MIN;
 export const MERGE_WAIT_MAX_MS = 60 * MIN;
@@ -478,6 +487,15 @@ export function openUnitPipeline(input: UnitPipelineInput, at: number): UnitPipe
 const deadlineAt = (s: UnitPipelineState) => s.startedAt + s.input.caps.maxMinutes * MIN;
 const remainingMs = (s: UnitPipelineState) => deadlineAt(s) - s.clock;
 
+/** The next slice of a wait: a chunk; the remainder when less is left before
+ *  `until`, so the slices sum to exactly the budget plus the margin; and a
+ *  chunk again once `until` has passed — an overdue child is its own budget's
+ *  to end, and the runner asks about it every chunk, never in a zero-length wait. */
+function waitSliceMs(clock: number, until: number): number {
+  const remaining = until - clock;
+  return remaining > 0 ? Math.min(WAIT_CHUNK_MS, remaining) : WAIT_CHUNK_MS;
+}
+
 /** The child's budget: its preset's own, clipped to the pipeline's remaining
  *  wall clock (the in-process loop's `clip`), never under the two minutes a
  *  spawn accepts. */
@@ -529,14 +547,14 @@ export function nextAction(s: UnitPipelineState): CoordinatorAction {
     case "busy-wait": {
       const step = `${roundStep(s, p.round)}/busy/${p.n}`;
       if (p.runId === undefined) return { type: "sleep", step, ms: BUSY_RETRY_MS };
-      return { type: "wait", step, runId: p.runId, timeoutMs: Math.max(0, remainingMs(s)) + WAIT_MARGIN_MS };
+      return { type: "wait", step, runId: p.runId, timeoutMs: waitSliceMs(s.clock, deadlineAt(s) + WAIT_MARGIN_MS) };
     }
     case "wait":
       return {
         type: "wait",
         step: `${roundStep(s, p.round)}/wait/${p.n}`,
         runId: p.runId,
-        timeoutMs: p.budgetMinutes * MIN + WAIT_MARGIN_MS,
+        timeoutMs: waitSliceMs(s.clock, p.until),
       };
     case "read":
       return { type: "read-record", step: `${roundStep(s, p.round)}/read/${p.n}`, runId: p.runId };
@@ -813,7 +831,8 @@ export function applyReturn(s: UnitPipelineState, ret: StepReturn): Transition {
       switch (r.outcome) {
         case "spawned":
         case "alreadySpawned": {
-          const budgetMinutes = budgetMinutesFor(s, presetOf(p.round.kind));
+          // The child's budget runs from the spawn's answer; the wait walks it, plus the margin, in chunks.
+          const until = clocked.clock + budgetMinutesFor(s, presetOf(p.round.kind)) * MIN + WAIT_MARGIN_MS;
           const runs =
             p.round.kind === "review"
               ? { reviewRunByRound: { ...s.reviewRunByRound, [p.round.index]: r.runId } }
@@ -821,7 +840,7 @@ export function applyReturn(s: UnitPipelineState, ret: StepReturn): Transition {
                 ? { fixRunByRound: { ...s.fixRunByRound, [p.round.index]: r.runId }, lastCodingRunId: r.runId }
                 : { lastCodingRunId: r.runId };
           return {
-            state: { ...clocked, ...runs, phase: { at: "wait", round: p.round, runId: r.runId, n: 1, budgetMinutes } },
+            state: { ...clocked, ...runs, phase: { at: "wait", round: p.round, runId: r.runId, n: 1, until } },
             notes: [roundNote(p.round, "started")],
           };
         }
@@ -869,7 +888,7 @@ export function applyReturn(s: UnitPipelineState, ret: StepReturn): Transition {
       return { state: { ...s, phase: { at: "spawn", round: p.round, busy: p.n } }, notes: [] };
     case "wait":
       return {
-        state: { ...s, phase: { at: "read", round: p.round, runId: p.runId, n: p.n, budgetMinutes: p.budgetMinutes } },
+        state: { ...s, phase: { at: "read", round: p.round, runId: p.runId, n: p.n, until: p.until } },
         notes: [],
       };
     case "read": {
@@ -878,7 +897,7 @@ export function applyReturn(s: UnitPipelineState, ret: StepReturn): Transition {
         return {
           state: {
             ...clocked,
-            phase: { at: "wait", round: p.round, runId: p.runId, n: p.n + 1, budgetMinutes: p.budgetMinutes },
+            phase: { at: "wait", round: p.round, runId: p.runId, n: p.n + 1, until: p.until },
           },
           notes: [],
         };

package/dist/cli.js

@@ -7544,7 +7544,8 @@ var init_runEvents = __esm({
       "follow_up",
       "resumed",
       "description_turn",
-      "cold_sandbox"
+      "cold_sandbox",
+      "pr_not_opened"
     ];
     ACTOR_ID_CHARS = "A-Za-z0-9:@._-";
     ACTOR_ID_MAX = 128;
@@ -19525,6 +19526,24 @@ function createRunsService(deps) {
     if (!store || !RUN_ID_PATTERN.test(id)) return null;
     return store.getSummary(id);
   };
+  const storedArtifacts = async (id) => {
+    let row;
+    try {
+      row = await storeSummary(id);
+    } catch (err2) {
+      warn(
+        `[runs] history store read failed for ${id} \u2014 serving the registry row without its record: ${describe9(err2)}`
+      );
+      return {};
+    }
+    if (!row) return {};
+    return {
+      ...row.verdict !== void 0 ? { verdict: row.verdict } : {},
+      ...row.reviewHead !== void 0 ? { reviewHead: row.reviewHead } : {},
+      ...row.dispositions !== void 0 ? { dispositions: row.dispositions } : {},
+      ...row.handoff !== void 0 ? { handoff: row.handoff } : {}
+    };
+  };
   return {
     async listRuns(opts) {
       const limit = clampListLimit(opts.limit);
@@ -19596,6 +19615,7 @@ function createRunsService(deps) {
       if (summary && snap) {
         const view2 = liveView(summary);
         if (opts.include === "messages") view2.events = snap.events;
+        if (summary.finished) Object.assign(view2, await storedArtifacts(id));
         return { ok: true, value: view2 };
       }
       const far = await ledgerRow(id);
@@ -28281,8 +28301,16 @@ async function runCodingPrPostStep(input) {
   const base = prDescription ? await resolveBaseRefLazy(candidates, repo, input.fetchRepoInfo) : resolveBaseRef(candidates, void 0);
   const pushedBranch = branch2 !== void 0 && branch2 !== base && pushed;
   if (prDescription && branch2 !== void 0 && branch2 === base) {
-    console.log(`[pr-post] ${logKey} skipped: workspace on the base branch ${base} (repo ${repo}) \u2014 nothing pushed`);
-    return void 0;
+    console.log(
+      `[pr-post] ${logKey} skipped: the branch ${branchLog} is the base branch ${base} (repo ${repo}) \u2014 no PR opened`
+    );
+    input.publish({
+      type: "run_note",
+      kind: "pr_not_opened",
+      summary: `no PR opened: the branch ${branch2} is the base branch the pull request would target`,
+      at: systemClock()
+    });
+    return `\u26A0\uFE0F A PR description was submitted but the branch \`${branch2}\`${branchNote} is the base branch the pull request would target, so no PR was opened \u2014 a pull request needs a head branch other than its base.`;
   }
   if (prDescription && branch2 !== void 0 && headSha !== void 0 && !pushed) {
     const why = remoteHead === void 0 ? "was not found on the remote" : `has unpushed commits (the remote branch is at ${remoteHead.slice(0, 7)}, the workspace at ${headSha.slice(0, 7)})`;
@@ -28787,7 +28815,7 @@ async function runLoop2(deps, ctx) {
     };
     const prTarget = {
       repo: repoCtx.repo,
-      baseRef: repoCtx.baseRef,
+      baseRef: repoCtx.baseRef ?? coordinator?.base,
       bindingRef: binding?.ref,
       resolvedRef: repoCtx.ref
     };
@@ -29210,7 +29238,7 @@ function openPlanCursor(graph, selected) {
   for (const id of order) visit(id, []);
   return cursor;
 }
-var MIN, SHIP_ROUND_RESERVE_MS, PLAN_ID_PATTERN, PLAN_BRANCH, UNIT_REF, SLUG_MAX, INSTANCE_ID_MAX, WAIT_MARGIN_MS, MERGE_POLL_MS, MERGE_WAIT_MAX_MS, BUSY_RETRY_MS;
+var MIN, SHIP_ROUND_RESERVE_MS, PLAN_ID_PATTERN, PLAN_BRANCH, UNIT_REF, SLUG_MAX, INSTANCE_ID_MAX, WAIT_MARGIN_MS, WAIT_CHUNK_MS, MERGE_POLL_MS, MERGE_WAIT_MAX_MS, BUSY_RETRY_MS;
 var init_coordinator = __esm({
   "../../src/core/ship/coordinator.ts"() {
     "use strict";
@@ -29225,6 +29253,7 @@ var init_coordinator = __esm({
     SLUG_MAX = 24;
     INSTANCE_ID_MAX = 100;
     WAIT_MARGIN_MS = 5 * MIN;
+    WAIT_CHUNK_MS = 5 * MIN;
     MERGE_POLL_MS = 5 * MIN;
     MERGE_WAIT_MAX_MS = 60 * MIN;
     BUSY_RETRY_MS = 2 * MIN;
@@ -37774,7 +37803,11 @@ async function spawn6(body, deps) {
       lastReply = text;
     }
   });
-  const tag = { parentInstanceId: instance.id, idempotencyKey: key };
+  const tag = {
+    parentInstanceId: instance.id,
+    idempotencyKey: key,
+    ...instance.base !== void 0 ? { base: instance.base } : {}
+  };
   const settled = deps.dispatch(msg, child, {
     coordinator: tag,
     ...turn.contract !== void 0 ? { contract: turn.contract } : {},

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coreplane/switchboard",
-  "version": "1.206.0",
+  "version": "1.207.0",
   "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",
   "homepage": "https://openswitchboard.dev",