@coreplane/switchboard 1.207.0 → 1.208.0

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

@@ -278,20 +278,20 @@ workspaceDir: ./workspaces
 #     tokenEnv: MEMORY_TOKEN    # env var holding the Worker's bearer (default)
 
 # agent:ship pipeline caps (docs/reference/specs/agent-ship.md). `agent:ship in owner/repo:
-# <task>` runs the coding → review → fix loop to LGTM as one pipeline: at most
+# <task>` hands the coding → review → fix loop to LGTM to the plan runner — the
+# ShipCoordinator Workflow in the bot Worker, whose rounds are child runs — which
+# needs the `coordinator` ingress entry, its grants, run history on the state
+# Worker and PUBLIC_BASE_URL (docs/how-to/turn-features-on-and-off.md); without
+# them the request is refused naming what is missing. Per unit: at most
 # `maxRounds` review rounds and `maxMinutes` minutes of wall clock — whichever
-# hits first ends the loop, and each child round's own budget is clipped to the
-# remaining pipeline time. `maxMinutes` is the ship preset's declared budget:
-# a channel or user `boundary.maxMinutes` and a per-message `budget:` directive
-# clip it like any preset's, and the card says so. Defaults shown; both must be
-# integers >= 1.
+# hits first ends the unit, and each child round's own budget is clipped to the
+# remaining time. `maxMinutes` is the ship preset's declared budget: a channel or
+# user `boundary.maxMinutes` and a per-message `budget:` directive clip it like
+# any preset's, and the card says so. Defaults shown; both must be integers >= 1;
+# any other key under `ship` fails the load by name.
 # ship:
-#   maxRounds: 3      # review rounds per pipeline
+#   maxRounds: 3      # review rounds per unit
 #   maxMinutes: 120   # the ship preset's wall-clock budget in minutes (the registry's default)
-#   coordinator: false # true hands every agent:ship request to the plan runner — the ShipCoordinator
-#                      # Workflow in the bot Worker — instead of the in-process round loop; needs the
-#                      # `coordinator` ingress entry, its grant, run history on the state Worker and
-#                      # PUBLIC_BASE_URL (see docs/how-to/turn-features-on-and-off.md)
 
 # The fan-out cap a spawning run meets (docs/reference/specs/agent-conductor.md).
 # `agent:conductor` starts child runs as the person who asked — each an

package/dist/assets/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "switchboard",
-  "version": "1.207.0",
+  "version": "1.208.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "switchboard",
-      "version": "1.207.0",
+      "version": "1.208.0",
       "license": "Apache-2.0",
       "workspaces": [
         "web",
@@ -18999,7 +18999,7 @@
     },
     "packages/switchboard": {
       "name": "@coreplane/switchboard",
-      "version": "1.207.0",
+      "version": "1.208.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.207.0",
+  "version": "1.208.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.207.0",
-  "commit": "123a4b1aba2acf34fc922a24f3493fa6c05df2d9",
-  "builtAt": "2026-09-14T00:08:39.382Z"
+  "version": "1.208.0",
+  "commit": "348d6f6ebbf7cf242f39951c0a81585527f49181",
+  "builtAt": "2026-09-14T03:37:32.458Z"
 }

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

@@ -145,6 +145,11 @@ export interface CoordinatorUnit {
   /** The unit's board issue in the repository, when one titled by the unit id exists — the handoff's destination. */
   issue?: number;
   pr?: { number: number; url: string };
+  /** Resume at review (agent-ship item 10): the open pull request of ship's own
+   *  the requester named, so the unit's pipeline opens at its first review round
+   *  — 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 round boundaries the coordinator reported, oldest first (the `ship_round` vocabulary). */
   rounds: Array<{ index: number; agent: string; outcome: string; at: number }>;
   /** How the unit ended: the ending's kind and the thread's report, when it has. */
@@ -163,6 +168,11 @@ const isOptionalText = (v: unknown): boolean => v === undefined || isText(v);
 const isFinite = (v: unknown): v is number => typeof v === "number" && Number.isFinite(v);
 const isObject = (v: unknown): v is Record<string, unknown> => typeof v === "object" && v !== null;
 const isPr = (v: unknown): boolean => isObject(v) && isFinite(v.number) && isText(v.url, 2048);
+const isResume = (v: unknown): boolean =>
+  isObject(v) &&
+  isFinite(v.pr) &&
+  (v.headSha === undefined || isText(v.headSha)) &&
+  (v.url === undefined || isText(v.url, 2048));
 
 /** Structural check on a record from outside the process (a Worker response, an HTTP body). */
 export function isCoordinatorInstance(v: unknown): v is CoordinatorInstance {
@@ -194,6 +204,7 @@ export function isCoordinatorUnit(v: unknown): v is CoordinatorUnit {
   if (!isOptionalText(r.threadKey) || !isOptionalText(r.sourceUrl)) return false;
   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 (
     !Array.isArray(r.rounds) ||
     r.rounds.length > MAX_ROUNDS ||

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:
@@ -230,7 +233,18 @@ function readRecordReturn(step: string, a: BotAnswer): StepReturn {
   // 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.
   const facts = run as unknown as Omit<Extract<ChildFacts, { finished: true }>, "finished" | "status">;
-  const { finalReply, pr, headSha, description, verdict, reviewPosted, reviewHead, dispositions, handoff } = facts;
+  const {
+    finalReply,
+    pr,
+    headSha,
+    description,
+    verdict,
+    reviewPosted,
+    reviewPostReason,
+    reviewHead,
+    dispositions,
+    handoff,
+  } = facts;
   return {
     type: "read-record",
     step,
@@ -243,6 +257,7 @@ function readRecordReturn(step: string, a: BotAnswer): StepReturn {
       ...(description !== undefined ? { description } : {}),
       ...(verdict !== undefined ? { verdict } : {}),
       ...(reviewPosted !== undefined ? { reviewPosted } : {}),
+      ...(reviewPostReason !== undefined ? { reviewPostReason } : {}),
       ...(reviewHead !== undefined ? { reviewHead } : {}),
       ...(dispositions !== undefined ? { dispositions } : {}),
       ...(handoff !== undefined ? { handoff } : {}),
@@ -252,7 +267,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 +276,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");
 }
 
@@ -385,6 +411,10 @@ async function runUnit(
   const start = readUnitStart(
     answerOf("unit-start", await step.do(`${unit}/start`, STEP_CONFIG, () => call(bot, "unit-start", tag))),
   );
+  // A resume at review (agent-ship item 10) rides the unit's row: the pull
+  // request of ship's own the requester named opens the pipeline at its first
+  // review round, with no pre-check, no branch and no round 0.
+  const resume = plan.units.find((u) => u.unit === unit)?.resume;
   let state: UnitPipelineState = openUnitPipeline(
     {
       unit: { id: unit, branch: node.branch },
@@ -397,6 +427,7 @@ async function runUnit(
       // approved at its head and the checks are green; any other branch — a
       // task string's ship branch — waits for a person.
       merge: parsePlanBranch(node.branch) !== undefined ? "runner" : "person",
+      ...(resume !== undefined ? { resume } : {}),
     },
     start.at,
   );
@@ -411,10 +442,14 @@ async function runUnit(
         const body = { ...tag, index: note.index, agent: note.agent, outcome: note.outcome };
         await step.do(`${unit}/note/${++notes}`, STEP_CONFIG, () => call(bot, "round", body));
       } else {
+        // 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).
         const body = {
           ...tag,
           ending: { kind: note.ending.kind, report: renderUnitReport(state) },
           ...(state.pr !== undefined ? { pr: state.pr } : {}),
+          ...(state.lastCodingRunId !== undefined ? { codingRunId: state.lastCodingRunId } : {}),
         };
         await step.do(`${unit}/end`, STEP_CONFIG, () => call(bot, "unit-end", body));
       }

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

@@ -259,6 +259,46 @@ export function isReviewVerdictShape(v: unknown): v is ReviewVerdict {
   return true;
 }
 
+/** How a review run's post-step ended, as the run's record carries it
+ *  (docs/reference/specs/agent-review.md item 18; run-history item 2): the verdict
+ *  landed on a named pull request pinned to `head` (the verdict kind rides when
+ *  one was submitted — a review that posted without a verdict posts the
+ *  no-verdict line), or nothing landed and `reason` says why — a guard's
+ *  refusal, an opt-out, no pull request, GitHub's own error. A coordinator's
+ *  `read-record` answers `reviewPosted` from this before it asks GitHub, whose
+ *  review list can lag a post it accepted a second ago. */
+export type ReviewPost =
+  | { posted: true; target: { repo: string; number: number }; head: string; verdict?: ReviewVerdictKind }
+  | { posted: false; reason: string };
+
+const REVIEW_POST_HEAD = /^[0-9a-f]{7,40}$/;
+
+/** Structural check on a review post read back from a stored record: a posted
+ *  outcome names its pull request and a 7-to-40-hex head, its verdict (when
+ *  present) a known kind; a skipped one carries a string reason. */
+export function isReviewPostShape(v: unknown): v is ReviewPost {
+  if (!isRecordLike(v)) return false;
+  if (v.posted === false) return typeof v.reason === "string";
+  if (v.posted !== true) return false;
+  const target = v.target;
+  if (
+    !isRecordLike(target) ||
+    typeof target.repo !== "string" ||
+    typeof target.number !== "number" ||
+    !Number.isInteger(target.number) ||
+    target.number <= 0
+  )
+    return false;
+  if (typeof v.head !== "string" || !REVIEW_POST_HEAD.test(v.head)) return false;
+  return v.verdict === undefined || VERDICT_KINDS.includes(v.verdict as string);
+}
+
+/** The skip's reason through the redaction seam (it may carry GitHub's own
+ *  words); a posted outcome has no free text and is returned as it is. */
+export function redactReviewPost(post: ReviewPost, redact: (s: string) => string = redactSecrets): ReviewPost {
+  return post.posted ? post : { posted: false, reason: redact(post.reason) };
+}
+
 /** Structural check on a disposition set read back from a stored record. */
 export function isFindingDispositionsShape(v: unknown): v is FindingDisposition[] {
   return (

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

@@ -110,7 +110,15 @@ export type RunNoteKind =
    *  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";
+  | "pr_not_opened"
+  /** A review run's post-step posted nothing to the pull request — a guard's
+   *  refusal, an opt-out, no pull request resolved, GitHub's own error — and
+   *  the summary names the pull request (when one was resolved) and the
+   *  reason (docs/reference/specs/agent-review.md item 18). Published by the
+   *  post-step beside the thread's Slack-only note, so the record says the
+   *  verdict is Slack-only and a coordinator reading it never asks GitHub
+   *  for a review that was never sent. */
+  | "review_not_posted";
 
 /** 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). */
@@ -130,6 +138,7 @@ export const RUN_NOTE_KINDS = [
   "description_turn",
   "cold_sandbox",
   "pr_not_opened",
+  "review_not_posted",
 ] as const satisfies readonly RunNoteKind[];
 type _EveryKindListed = [RunNoteKind] extends [(typeof RUN_NOTE_KINDS)[number]] ? true : never;
 const _everyKindListed: _EveryKindListed = true;
@@ -438,6 +447,25 @@ export type RunEvent =
    *  run record carries the PR URL as a fact of the run rather than only the
    *  channel reply's projection of it. Additive: unknown → ignored. */
   | { type: "pr_opened"; url: string; number: number; created: boolean; seq?: number; at?: number }
+  /** The review post-step's outcome when the verdict landed
+   *  (docs/reference/specs/agent-review.md item 18): the pull request it was
+   *  posted to, the head it was pinned to (the carried head after a rebase,
+   *  item 12) and the verdict kind when one was submitted. Published by the
+   *  post-step straight to the registry BEFORE the stream finishes — the
+   *  post-step runs inside the run loop, like the coding one — so the record
+   *  carries the post as a fact of the run and a coordinator woken by the
+   *  finish reads it there instead of asking GitHub, whose review list can
+   *  lag the post it just accepted. A post that did not land is a
+   *  `review_not_posted` note. Additive: unknown → ignored. */
+  | {
+      type: "review_posted";
+      repo: string;
+      number: number;
+      head: string;
+      verdict?: "approve" | "request_changes";
+      seq?: number;
+      at?: number;
+    }
   /** One `agent:ship` round boundary (docs/reference/specs/agent-ship.md item 12): the
    *  pipeline publishes a `started` event when a round's child is dispatched
    *  and one settle event when its outcome is known (`ShipRoundOutcome`), so

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

@@ -370,7 +370,7 @@ export function analyzeRunFriction(events: readonly RunEvent[], opts: FrictionOp
   // final answer (`answer`) — are the run's story, not its steps: none counts
   // toward `eventCount`.
   let narrativeEvents = 0;
-  let sideFactEvents = 0; // skill_use / review_artifact / pr_description / pr_opened / ship_round: facts about the run, not steps
+  let sideFactEvents = 0; // skill_use / review_artifact / pr_description / pr_opened / review_posted / ship_round: facts about the run, not steps
   let spanEvents = 0; // span_start / span_end (docs/reference/specs/tracing.md): timing records, not steps
   let wrapUp: { index: number; at?: number } | undefined;
   events.forEach((ev, index) => {
@@ -385,14 +385,15 @@ export function analyzeRunFriction(events: readonly RunEvent[], opts: FrictionOp
     }
     // Side facts about the run, not steps: skill_use rides beside a use_skill
     // call that already produced its own tool pair; review_artifact,
-    // pr_description, pr_opened and the ship_round boundaries are published
-    // by the dispatcher/pipeline outside the model loop entirely. Counting
-    // any of them would distort the story.
+    // pr_description, pr_opened, review_posted and the ship_round boundaries
+    // are published by the dispatcher/pipeline outside the model loop
+    // entirely. Counting any of them would distort the story.
     if (
       ev.type === "skill_use" ||
       ev.type === "review_artifact" ||
       ev.type === "pr_description" ||
       ev.type === "pr_opened" ||
+      ev.type === "review_posted" ||
       ev.type === "ship_round"
     ) {
       sideFactEvents++;

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

@@ -4,9 +4,11 @@ import type { RunEvent } from "./runEvents.js";
 import { isHeadMaterial, isSpanRecord } from "./runEvents.js";
 import { isHandoffShape, type Handoff } from "./ship/handoff.js";
 import {
+  type FindingDisposition,
   isFindingDispositionsShape,
+  isReviewPostShape,
   isReviewVerdictShape,
-  type FindingDisposition,
+  type ReviewPost,
   type ReviewVerdict,
 } from "./reviewVerdict.js";
 import { IDEMPOTENCY_KEY_PATTERN, INSTANCE_ID_PATTERN } from "./coordinator/contract.js";
@@ -114,6 +116,12 @@ export interface RunRecord {
   /** The head a review run reviewed and posted against (7 to 40 lowercase hex),
    *  after the settle; present only on a review run that pinned one. */
   reviewHead?: string;
+  /** How the review run's post-step ended (docs/reference/specs/agent-review.md
+   *  item 18): the verdict posted to a named pull request at a pinned head, or
+   *  not posted with the reason — what a coordinator's `read-record` answers
+   *  `reviewPosted` from before it asks GitHub. Present only on a review run
+   *  that reached its post-step; absent on records written before it existed. */
+  reviewPost?: ReviewPost;
   /** The dispositions a fix round submitted through `submit_dispositions`
    *  (docs/reference/specs/agent-ship.md item 6), the last call's set, redacted;
    *  present only on a coding run dispatched as a fix round that submitted one. */
@@ -502,6 +510,7 @@ export function isRunRecord(v: unknown): v is RunRecord {
   if (r.reviewHead !== undefined && (typeof r.reviewHead !== "string" || !REVIEW_HEAD_PATTERN.test(r.reviewHead)))
     return false;
   if (r.dispositions !== undefined && !isFindingDispositionsShape(r.dispositions)) return false;
+  if (r.reviewPost !== undefined && !isReviewPostShape(r.reviewPost)) return false;
   if (r.profile !== undefined && !isRunProfileRecord(r.profile)) return false;
   // A parent is named by a run id (item 46): the same shape as the record's own.
   if (r.parentRunId !== undefined && (typeof r.parentRunId !== "string" || !RUN_ID_PATTERN.test(r.parentRunId)))

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

@@ -79,6 +79,10 @@ export interface ChildContract {
   issue: { repo: string; number: number } | undefined;
 }
 
+/** The PR-title gate's name, exported so another module can name the same
+ *  gate without a copied string (`npm run check:pr-title`; CI's `title` check). */
+export const PR_TITLE_GUARD = "check:pr-title";
+
 /** The guards a child may not weaken (AGENTS.md's Commands table), one line each on what they refuse. */
 export const GUARDS: readonly Guard[] = [
   {
@@ -96,6 +100,11 @@ export const GUARDS: readonly Guard[] = [
     refuses:
       "a new imprint in the public tree (a company, a person, a tracker reference, a plan id, a platform id, a date); the recorded list only shrinks",
   },
+  {
+    name: PR_TITLE_GUARD,
+    refuses:
+      "a title whose type, scope or grammar is not the changelog line, the scope being one of the code map's Areas",
+  },
   {
     name: "decisions:check",
     refuses:

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

@@ -4,11 +4,10 @@
 // Workflow instance in the bot's shim Worker with no model turn and no
 // credential — decides between the steps it asks the bot for. The Workflow
 // asks `nextAction`, performs it (a bot route, a `waitForEvent`, a sleep) and
-// feeds the answer to `applyReturn`; everything the in-process round loop
-// decides today (`runShipPipeline`: which round is next, what a child's end
-// means, when a cap ends the pipeline, when the pull request is merge-ready)
-// is decided here over the step returns instead, so the same endings hold
-// with the loop's process gone.
+// feeds the answer to `applyReturn`; everything the pipeline decides — which
+// round is next, what a child's end means, when a cap ends the pipeline, when
+// the pull request is merge-ready — is decided here over the step returns, so
+// the endings hold with no process of the pipeline's own to die.
 //
 // Two machines, both pure. The plan cursor walks a plan record's unit graph:
 // which units are ready (their dependencies merged), which one a failure
@@ -16,7 +15,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.
@@ -340,15 +344,24 @@ export type ChildFacts =
       description?: boolean;
       /** A review child's verdict. */
       verdict?: { verdict: ReviewVerdictKind; summary?: string; findings: Finding[] };
-      /** Whether the review child's verdict landed on the pull request. */
+      /** Whether the review child's verdict landed on the pull request — the
+       *  child's own record of its post, or GitHub's review list when the
+       *  record is silent (http-ingress.md item 9). */
       reviewPosted?: boolean;
+      /** Why the child recorded no post, when it recorded one it chose or failed. */
+      reviewPostReason?: string;
       reviewHead?: string;
       /** A fix child's dispositions. */
       dispositions?: FindingDisposition[];
       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 =
@@ -365,12 +378,15 @@ export type StepReturn =
   | { type: "merge"; step: string; outcome: "pending" | "refused"; reason: string; at: number }
   | { 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. */
+/** How one unit's pipeline ended — the truthful vocabulary the ship pipeline
+ *  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 +427,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 +485,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: {},
@@ -497,7 +515,7 @@ function waitSliceMs(clock: number, until: number): number {
 }
 
 /** 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
+ *  wall clock (agent-ship item 8's clip), never under the two minutes a
  *  spawn accepts. */
 function budgetMinutesFor(s: UnitPipelineState, preset: ChildPreset): number {
   return Math.max(2, Math.min(s.input.childMinutes[preset], Math.floor(remainingMs(s) / MIN)));
@@ -531,6 +549,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": {
@@ -589,7 +609,7 @@ const roundNote = (round: RoundRef, outcome: ShipRoundOutcome): CoordinatorNote
   outcome,
 });
 
-/** Start a round if the reservation holds (the in-process loop's check: a
+/** Start a round if the reservation holds (agent-ship item 8's check: a
  *  child clipped under the reserve cannot do useful work). */
 function enterRound(s: UnitPipelineState, round: RoundRef, notes: CoordinatorNote[] = []): Transition {
   const remaining = remainingMs(s);
@@ -703,13 +723,15 @@ function settleReview(
   const notes = [roundNote(round, verdict.verdict)];
   if (verdict.verdict === "approve") {
     // Merge-ready stands on the POSTED approval: an approve whose post did
-    // not land left no approving review on the pull request.
+    // not land left no approving review on the pull request. The reason is
+    // the child's own when it recorded one; how to continue is the report's
+    // re-issue line, in the runner's words (`renderUnitReport`).
     if (facts.reviewPosted === false)
       return end(
         next,
         {
           kind: "aborted",
-          reason: `⚠️ The review approved, but the approval could not be posted — the pull request carries no approving review. Re-run ship with the pull request URL to retry the approval.`,
+          reason: `⚠️ The review approved, but the approval could not be posted${facts.reviewPostReason !== undefined ? ` (${facts.reviewPostReason})` : ""} — the pull request carries no approving review.`,
           round,
           reviewRounds: next.reviewRounds,
         },
@@ -753,9 +775,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 +860,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 +967,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;
@@ -982,7 +1035,7 @@ function splitReport(s: UnitPipelineState): string {
   return lines.join("\n");
 }
 
-/** The thread's report for a unit's ending — the in-process loop's own words
+/** The thread's report for a unit's ending — the ship pipeline's own words
  *  for the endings it has, and the merge's for the ones it gains. */
 export function renderUnitReport(s: UnitPipelineState): string {
   const e = s.ending;
@@ -1000,6 +1053,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/assets/src/core/trace/streamSpans.ts

@@ -45,6 +45,7 @@ export const STREAMED_SPANS = [
   "run.description_turn",
   "run.observe_workspace",
   "run.pr_post_step",
+  "run.review_post_step",
   "run.reading_diff_join",
   "run.pr_description_join",
   "model.turn",
@@ -92,6 +93,7 @@ const GETTING_READY: ReadonlySet<string> = new Set([
 const FINISHING_UP: ReadonlySet<string> = new Set([
   "run.observe_workspace",
   "run.pr_post_step",
+  "run.review_post_step",
   "run.reading_diff_join",
   "run.pr_description_join",
 ]);
@@ -150,6 +152,7 @@ export const PARENTS: Readonly<Record<string, readonly string[]>> = {
   "run.description_turn": ["request", "ship.round"],
   "run.observe_workspace": ["request", "ship.round"],
   "run.pr_post_step": ["request", "ship.round"],
+  "run.review_post_step": ["request", "ship.round"],
   "run.reading_diff_join": ["request", "ship.round"],
   "run.pr_description_join": ["request", "ship.round"],
   "model.turn": ["run.agent"],

package/dist/assets/src/core/trace/workerTrace.ts

@@ -52,6 +52,9 @@ export function shimRoute(pathname: string): string | undefined {
   if (pathname === "/costs" || pathname.startsWith("/costs/")) return "costs";
   if (pathname.startsWith("/api/")) return "api";
   if (pathname.startsWith("/admin/")) return "admin";
+  // The model proxy's two routes (docs/reference/specs/model-proxy.md): a bounded
+  // request per model call, forwarded to the container like everything else.
+  if (pathname === "/v1/messages" || pathname === "/v1/chat/completions") return "model-proxy";
   if (pathname === "/docs" || pathname.startsWith("/docs/")) return "docs";
   if (pathname === "/" || pathname === "/index.html") return "page";
   return "other";