@coreplane/switchboard 1.207.0 → 1.207.1

package/dist/assets/package-lock.json

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

package/dist/assets/package.json

@@ -1,6 +1,6 @@
 {
   "name": "switchboard",
-  "version": "1.207.0",
+  "version": "1.207.1",
   "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.207.0",
-  "commit": "123a4b1aba2acf34fc922a24f3493fa6c05df2d9",
-  "builtAt": "2026-09-14T00:08:39.382Z"
+  "version": "1.207.1",
+  "commit": "a5e85d6a364f558fdf079ec32e85eb6deadf5033",
+  "builtAt": "2026-09-14T01:09:34.713Z"
 }

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

@@ -24,7 +24,10 @@
 // dependencies are done. `done` is merged: a plan branch's pull request is the
 // runner's to squash (the `merge` step, under `plan:merge`) once the review
 // approved at its head and the checks are green, so its dependents start on a
-// base that carries it; a unit that ended any other way — a refused merge, a
+// base that carries it — or was found merged already by the machine's first
+// `pr-check` (a re-issued plan whose unit a person, or an earlier attempt,
+// merged), which ends the unit with no branch and no child; a unit that ended
+// any other way — a refused merge, a
 // cap, a stop — blocks its dependents, each told so as its own ending, and the
 // plan finishes `failed` so the summary says which units are left for the
 // plan's re-issue. A task string's ship branch waits for a person. Node-free:
@@ -252,7 +255,7 @@ function readRecordReturn(step: string, a: BotAnswer): StepReturn {
 }
 
 function prCheckReturn(step: string, a: BotAnswer): StepReturn {
-  const { ok, state, prNumber, url, headSha, at } = a.body;
+  const { ok, state, prNumber, url, headSha, sha, mergedAt, at } = a.body;
   if (ok === true && state === "none") return { type: "pr-check", step, pr: { state: "none" }, at };
   if (ok === true && state === "open" && typeof prNumber === "number" && typeof url === "string")
     return {
@@ -261,6 +264,17 @@ function prCheckReturn(step: string, a: BotAnswer): StepReturn {
       pr: { state: "open", prNumber, url, ...(typeof headSha === "string" ? { headSha } : {}) },
       at,
     };
+  // A merged pull request is read whole or not at all: the merge commit and
+  // the time are what the unit's ending and its report carry.
+  if (
+    ok === true &&
+    state === "merged" &&
+    typeof prNumber === "number" &&
+    typeof url === "string" &&
+    typeof sha === "string" &&
+    typeof mergedAt === "string"
+  )
+    return { type: "pr-check", step, pr: { state: "merged", prNumber, url, sha, mergedAt }, at };
   throw new UnreadableAnswer("pr-check", a, "state");
 }
 

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

@@ -16,7 +16,12 @@
 // approve and the merge: one thread and one head branch per unit
 // (`plan/<plan-id>/<unit-slug>`), every child a `dispatch()` run the bot
 // starts as the requesting user, every step retry-safe under the key
-// `<instance>:<unit>/<round>/<kind>`. Nothing here reads a clock: the bot
+// `<instance>:<unit>/<round>/<kind>`. Its first step asks what already heads
+// the branch: a pull request merged before the attempt reached the unit — a
+// person's merge, or an earlier attempt's — ends the unit `merged` with no
+// branch and no child, so a re-issued plan walks past its done units instead
+// of aborting them; the same answer after a round ends it the same way, since
+// a merge can land while a child runs. Nothing here reads a clock: the bot
 // answers every step with its own `at`, and that is the machine's time. Nothing
 // here carries a task's text or a thread's contents: a spawn's brief names the
 // unit and the runs whose records the bot reads to compose the child's turn.
@@ -348,7 +353,12 @@ export type ChildFacts =
       handoff?: boolean;
     };
 
-export type PrCheck = { state: "none" } | { state: "open"; prNumber: number; url: string; headSha?: string };
+/** What heads the unit's branch on GitHub: nothing, an open pull request, or —
+ *  with no open one — a merged one, `sha` the merge commit on the base. */
+export type PrCheck =
+  | { state: "none" }
+  | { state: "open"; prNumber: number; url: string; headSha?: string }
+  | { state: "merged"; prNumber: number; url: string; sha: string; mergedAt: string };
 
 /** What a step answered. Every bot answer carries `at`, the bot's clock — the machine's time. */
 export type StepReturn =
@@ -366,11 +376,14 @@ export type StepReturn =
   | { type: "sleep"; step: string };
 
 /** How one unit's pipeline ended — the truthful vocabulary the in-process loop
- *  has, plus the merge's own: `merged` by the runner, `merge_ready` for a
- *  person, `merge_refused` by the guards; `interrupted` a child the ledger
- *  closed; `refused` a child the authorize stage never started. */
+ *  has, plus the merge's own: `merged` by the runner, or found merged (`by:
+ *  other` — a person's merge, or an earlier attempt's that died after it, so
+ *  the runner merged nothing), `merge_ready` for a person, `merge_refused` by
+ *  the guards; `interrupted` a child the ledger closed; `refused` a child the
+ *  authorize stage never started. */
 export type UnitEnding =
-  | { kind: "merged"; pr: PrRef; sha: string; reviewRounds: number }
+  | { kind: "merged"; by: "runner"; pr: PrRef; sha: string; reviewRounds: number }
+  | { kind: "merged"; by: "other"; pr: PrRef; sha: string; mergedAt: string; reviewRounds: number }
   | { kind: "merge_ready"; pr: PrRef; reviewRounds: number }
   | { kind: "merge_refused"; pr: PrRef; reason: string; reviewRounds: number }
   | { kind: "round_cap"; maxRounds: number; reviewRounds: number }
@@ -411,6 +424,8 @@ export interface UnitPipelineInput {
 }
 
 type Phase =
+  /** Before anything is created: what already heads the branch — a merged pull request ends the unit here. */
+  | { at: "pre-check" }
   | { at: "branch" }
   | { at: "spawn"; round: RoundRef; busy: number }
   | { at: "busy-wait"; round: RoundRef; runId?: string; n: number }
@@ -467,7 +482,7 @@ export function openUnitPipeline(input: UnitPipelineInput, at: number): UnitPipe
     input,
     startedAt: at,
     clock: at,
-    phase: { at: "branch" },
+    phase: { at: "pre-check" },
     reviewRounds: 0,
     findingsByRound: {},
     dispositionsByRound: {},
@@ -531,6 +546,8 @@ export function nextAction(s: UnitPipelineState): CoordinatorAction {
   const unit = s.input.unit.id;
   const p = s.phase;
   switch (p.at) {
+    case "pre-check":
+      return { type: "pr-check", step: `${unit}/pr-check` };
     case "branch":
       return { type: "branch", step: `${unit}/branch`, branch: s.input.unit.branch, from: s.input.base };
     case "spawn": {
@@ -753,9 +770,30 @@ function settleReview(
   return enterRound(next, { index: round.index, kind: "fix" }, notes);
 }
 
+/** The unit's ending when its pull request is found merged — by a person, or
+ *  by an earlier attempt of the plan that died after its merge: the unit is
+ *  done and its dependents run on a base that carries it, and the runner
+ *  merged nothing, so the ending says so (`by: other`). */
+function foundMerged(
+  s: UnitPipelineState,
+  pr: Extract<PrCheck, { state: "merged" }>,
+  notes: CoordinatorNote[] = [],
+): Transition {
+  const ref: PrRef = { number: pr.prNumber, url: pr.url };
+  return end(
+    { ...s, pr: ref },
+    { kind: "merged", by: "other", pr: ref, sha: pr.sha, mergedAt: pr.mergedAt, reviewRounds: s.reviewRounds },
+    notes,
+  );
+}
+
 /** The pull request heading the branch after a coding or fix round. */
 function settlePrCheck(s: UnitPipelineState, phase: Extract<Phase, { at: "pr-check" }>, pr: PrCheck): Transition {
   const { round } = phase;
+  // The merge landed during the round: the child found nothing left to ship
+  // (or shipped into a pull request a person merged under it). The round
+  // completed without a pull request of its own, and the unit is done.
+  if (pr.state === "merged") return foundMerged(s, pr, [roundNote(round, "completed")]);
   if (pr.state === "none") {
     const reason =
       round.index === 0
@@ -817,6 +855,16 @@ export function applyReturn(s: UnitPipelineState, ret: StepReturn): Transition {
   const clocked: UnitPipelineState = "at" in ret ? { ...s, clock: ret.at } : s;
   const p = s.phase;
   switch (p.at) {
+    case "pre-check": {
+      // A pull request merged before this attempt reached the unit — a
+      // person's merge, or an earlier attempt's that died after it — makes the
+      // unit done before a branch or a child: nothing to run. Anything else is
+      // round 0's to work on: an open pull request is rebased and re-described
+      // by the coding child and adopted at the round's own pr-check.
+      const r = ret as Extract<StepReturn, { type: "pr-check" }>;
+      if (r.pr.state === "merged") return foundMerged(clocked, r.pr);
+      return { state: { ...clocked, phase: { at: "branch" } }, notes: [] };
+    }
     case "branch": {
       const r = ret as Extract<StepReturn, { type: "branch" }>;
       if (r.ok) return enterRound(clocked, { index: 0, kind: "coding" });
@@ -914,7 +962,7 @@ export function applyReturn(s: UnitPipelineState, ret: StepReturn): Transition {
     case "merge": {
       const r = ret as Extract<StepReturn, { type: "merge" }>;
       if (r.outcome === "merged")
-        return end(clocked, { kind: "merged", pr: p.pr, sha: r.sha, reviewRounds: s.reviewRounds });
+        return end(clocked, { kind: "merged", by: "runner", pr: p.pr, sha: r.sha, reviewRounds: s.reviewRounds });
       if (r.outcome === "refused")
         return end(clocked, { kind: "merge_refused", pr: p.pr, reason: r.reason, reviewRounds: s.reviewRounds });
       const waited = r.at - p.since;
@@ -1000,6 +1048,8 @@ export function renderUnitReport(s: UnitPipelineState): string {
   const join = (parts: Array<string | undefined>) => parts.filter(Boolean).join("\n\n");
   switch (e.kind) {
     case "merged":
+      if (e.by === "other")
+        return `✅ Already merged: ${e.pr.url} (merge commit \`${e.sha.slice(0, 7)}\`, merged ${e.mergedAt}) — the pull request heading \`${s.input.unit.branch}\` was merged before this attempt reached it, by a person or by an earlier attempt of this plan; the runner merged nothing. The unit is done and its dependents start on a base that carries it.`;
       return [
         `✅ Merged after ${rounds}: ${e.pr.url} (squash \`${e.sha.slice(0, 7)}\`) — merged by the plan runner under \`plan:merge\`: the review approved at this head and the guards were green.`,
         verdictLine,

package/dist/cli.js

@@ -21130,6 +21130,25 @@ async function findOpenPrByHead(repo, branch2) {
     ...first.head?.sha ? { headSha: first.head.sha } : {}
   };
 }
+async function findMergedPrByHead(repo, branch2) {
+  const token = await requireToken();
+  const owner = repo.split("/")[0];
+  const head = encodeURIComponent(`${owner}:${branch2}`);
+  const res = await fetch(
+    `https://api.github.com/repos/${repo}/pulls?state=closed&head=${head}&sort=updated&direction=desc`,
+    { headers: apiHeaders(token), signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS5) }
+  );
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    throw new Error(`PR lookup failed: HTTP ${res.status} ${redactAndCap(text, 300)}`);
+  }
+  const rows = await res.json();
+  if (!Array.isArray(rows)) return null;
+  const merged = rows.flatMap(
+    (r) => typeof r.merged_at === "string" && typeof r.merge_commit_sha === "string" && /^[0-9a-f]{40}$/.test(r.merge_commit_sha) ? [{ number: r.number, htmlUrl: r.html_url, sha: r.merge_commit_sha, mergedAt: r.merged_at }] : []
+  ).sort((a, b) => a.mergedAt < b.mergedAt ? 1 : a.mergedAt > b.mergedAt ? -1 : 0);
+  return merged[0] ?? null;
+}
 async function openPullRequest(target) {
   const existing = await findOpenPrByHead(target.repo, target.headBranch);
   if (existing) {
@@ -37930,17 +37949,33 @@ async function prCheck(body, deps) {
   const unit = await unitRowOf(deps, instance, body.unit);
   if (!unit.ok) return unit.response;
   const branch2 = unit.row?.branch ?? instance.branch;
+  const remember = async (pr) => {
+    if (unit.row && (unit.row.pr?.number !== pr.number || unit.row.pr.url !== pr.url))
+      await deps.instances.putUnits([{ ...unit.row, pr }]);
+  };
   try {
-    const pr = await deps.findOpenPrByHead(instance.repo, branch2);
-    if (!pr) return json(200, { ok: true, state: "none", at });
-    if (unit.row && (unit.row.pr?.number !== pr.number || unit.row.pr.url !== pr.htmlUrl))
-      await deps.instances.putUnits([{ ...unit.row, pr: { number: pr.number, url: pr.htmlUrl } }]);
+    const open = await deps.findOpenPrByHead(instance.repo, branch2);
+    if (open) {
+      await remember({ number: open.number, url: open.htmlUrl });
+      return json(200, {
+        ok: true,
+        state: "open",
+        prNumber: open.number,
+        url: open.htmlUrl,
+        ...open.headSha !== void 0 ? { headSha: open.headSha } : {},
+        at
+      });
+    }
+    const merged = await deps.findMergedPrByHead(instance.repo, branch2);
+    if (!merged) return json(200, { ok: true, state: "none", at });
+    await remember({ number: merged.number, url: merged.htmlUrl });
     return json(200, {
       ok: true,
-      state: "open",
-      prNumber: pr.number,
-      url: pr.htmlUrl,
-      ...pr.headSha !== void 0 ? { headSha: pr.headSha } : {},
+      state: "merged",
+      prNumber: merged.number,
+      url: merged.htmlUrl,
+      sha: merged.sha,
+      mergedAt: merged.mergedAt,
       at
     });
   } catch (err2) {
@@ -38923,6 +38958,7 @@ async function runBot() {
       dispatch: (msg, io, opts) => dispatch(deps, msg, io, opts),
       ioFor: (thread) => threadIoFor(thread),
       findOpenPrByHead,
+      findMergedPrByHead,
       // The App's GitHub reads for the plan, the specs, the rules and a unit's
       // board issue; the branch create; the reviews and the identity the merge
       // gate's "the verdict stands" question is answered from.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coreplane/switchboard",
-  "version": "1.207.0",
+  "version": "1.207.1",
   "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",