@coreplane/switchboard 1.255.0 → 1.256.0

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

@@ -439,42 +439,32 @@ export const TIMEOUT_ON_LONG_COMMANDS =
   "State a timeout on any command you expect to run longer than a minute: a timeout that reaches past the loop's " +
   "end is refused before the command runs, never cut midway.";
 
-/** The fast gates a plan child runs before every push, named one by one and
- *  each scoped to the changed set (agent-ship item 13; agent-coding item 9).
- *  "Its cheapest proving checks" left the choice to the child, and children
- *  chose wrong in both directions: prettier was reported clean while
- *  `format:check` was red, hygiene imprints reached CI that `hygiene:check`
- *  would have caught locally — and children ran the whole suite and the whole
- *  typecheck on the shared resident, minutes each call, time-sliced against
- *  every other run. So the gates are the changed-set forms, the full runs are
- *  said to be CI's alone in the same breath, and each gate is a receipt — the
- *  exit line goes into the PR description's validation table as the row's proof
- *  (the handoff has no verified list; parseHandoff carries deviations, followUps,
- *  unproven and landed), and a gate the child could not run goes under the
- *  handoff's unproven list, never claimed clean. The test gate is the touched
- *  files by name, never a changed-set or directory run. */
-/** The test command the contract hands a child: the touched files by name, once.
- *  Never `--changed`: against a base that moves, it selects most of the suite, and on the
- *  shared resident that is the memory incident the coding contract exists to prevent. */
-export const TOUCHED_TESTS_COMMAND = "`npx vitest run` on the test files you touched, by name,";
-
-export const FAST_GATES_BEFORE_PUSH =
-  "The fast gates, before every push — each scoped to the changed set, never the whole project: " +
-  `${TOUCHED_TESTS_COMMAND} once (never \`--changed\`, never a directory: on a moving base that is most of the suite), ` +
-  "`tsc --noEmit -p` the touched tsconfig under `NODE_OPTIONS=--max-old-space-size=6144`, " +
-  "`npx prettier --check` on the changed files, `npm run hygiene:check` and `npm run specs:check` — " +
-  "then your judgement on what else this change needs, not a longer checklist. Every CI pipeline runs the " +
-  "tests, the types, the formatting and the full verification on your push, so you never run them again: " +
-  "you validate and fix your own change before pushing, at the changed-set scope. Passing the full test suite " +
-  "and the full typecheck is NOT part of your criteria: CI is that gate and the only place they run — on a " +
-  "shared resident they cost minutes that every other run pays for. " +
+/** The fast gates a plan child runs before every push live in the coding
+ *  preset's own instructions (`FAST_GATES_BEFORE_PUSH`,
+ *  src/agents/registry.ts — agent-coding item 13; issue 1796): the changed-set
+ *  forms with their commands named, the full verification named as CI's gate.
+ *  The contract used to restate the whole paragraph, so every ask that was not
+ *  a plan unit had to repeat it by hand; now the first instruction points at
+ *  the preset's paragraph — the child reads the sentence once — and keeps only
+ *  what is the contract's own: the receipts. Each gate is a receipt — the exit
+ *  line goes into the PR description's validation table as the row's proof
+ *  (the handoff has no verified list; parseHandoff carries deviations,
+ *  followUps, unproven and landed), and a gate the child could not run goes
+ *  under the handoff's unproven list, never claimed clean — because only a
+ *  plan child has a handoff to route them to. */
+export const FAST_GATES_POINTER =
+  "The fast gates are the ones your preset instructions name (THE FAST GATES): the changed-set forms, " +
+  "never the whole project — the full suite, the full typecheck and the full verification are CI's, " +
+  "never yours to run.";
+
+export const GATE_RECEIPTS =
   "Paste each command's exit line into the PR description's validation table as the row's proof; a gate you " +
   "could not run goes under the handoff's unproven list and is never claimed clean.";
 
 function renderFirstInstruction(rebase: ChildContract["rebase"]): string {
   const branch = rebase.branch ? `\`${rebase.branch}\`` : "the unit's branch";
   const onto = rebase.onto ? `\`${rebase.onto}\`` : "the merged parent";
-  const gates = FAST_GATES_BEFORE_PUSH;
+  const gates = `${FAST_GATES_POINTER} ${GATE_RECEIPTS}`;
   return (
     `Rebase ${branch} onto ${onto} before any other work — the parent unit has merged and the base has moved; ` +
     `the only writes are your own on that branch. A conflict ends the unit: report it as the handoff and stop. ` +

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

@@ -41,6 +41,7 @@ import {
   findingsAtOrAbove,
   formatFinding,
   isAddressSeverity,
+  severityCounts,
   type AddressSeverity,
   type AddressSeveritySource,
   type Finding,
@@ -76,21 +77,70 @@ export interface ShipCaps {
  *  rounds that must still follow, capped at the preset's ask, refused under the
  *  round's floor. Nothing here holds a reserve of its own. */
 
-/** What a ship pipeline's thread and card say when the bot died under it (run-
- *  history item 36): the work it did stands on GitHub with nobody driving it,
- *  so the note names the PR when one was opened and the exact re-issue that
- *  continues the loop — the same entry the preflight's resume-at-review takes
- *  (agent-ship item 10). Without a PR the task itself is the re-issue: round 0
- *  runs again on the pipeline's own deterministic branch. The coordinator says
- *  the same when a child of its closed `interrupted`. */
-export function shipInterruptedNote(prUrl?: string): string {
+/** What actually ended an interrupted child, from the ledger that saw it
+ *  (issue 1876): the ending's sentence names the cause in the user's nouns —
+ *  the bot restarted, the resident container was replaced, the sandbox failed
+ *  — never "the bot restarted" for a site three causes reach. Read off the
+ *  child's record by the bot's `read-record` (`child_interrupted` / the resume
+ *  notes) and carried on the `interrupted` ending; absent when the record
+ *  named none. */
+export type InterruptionCause = "bot_restart" | "container_replaced" | "sandbox_fault";
+
+/** What a ship pipeline's thread and card say when its child died under it
+ *  (run-history item 36): the work it did stands on GitHub with nobody driving
+ *  it, so the note names the actual cause (issue 1876 — the site is reached by
+ *  a bot restart, a resident container replacement and a sandbox fault, and
+ *  only the ledger's word picks one; with none the sentence claims no cause),
+ *  the PR when one was opened and the exact re-issue that continues the loop —
+ *  the same entry the preflight's resume-at-review takes (agent-ship item 10).
+ *  Without a PR the task itself is the re-issue: round 0 runs again on the
+ *  pipeline's own deterministic branch. A child whose container was replaced
+ *  resumes from its request by itself (issue 1903) and the pipeline keeps
+ *  waiting — this note is written only when that resume failed or no resume
+ *  applied. */
+/** The cause an interruption's recorded words name (issue 1876): the ledger
+ *  that saw the roll wrote them — the relaunch refusals and the lost-workspace
+ *  notes name the replaced container, the sandbox executor's wordings the
+ *  sandbox, the boot gap names the restart — and the ending's sentence repeats
+ *  the cause, never "the bot restarted" for words that say otherwise. Each
+ *  pattern is anchored on the exact phrases those ledgers write —
+ *  `src/core/harness/contract.ts` and `src/core/dispatch/relaunch.ts`
+ *  ("container replaced under the run", "replacement container"),
+ *  `src/core/dispatch/reattach.ts` ("workspace lost", "could not be
+ *  re-attached"), `src/execution/sandboxLifecycle.ts` and the sandbox worker's
+ *  failures ("sandbox recycled", "sandbox worker", "sandbox exec"),
+ *  `src/core/boot.ts` and the resume notes ("bot restarted", the deploy
+ *  hand-off's "next generation") — so an unrelated word ("regenerating…", a
+ *  reason merely mentioning a sandbox path) cannot classify. Unrecognized
+ *  words are no cause: the sentence then claims none. */
+export function interruptionCauseOfWords(words: string): InterruptionCause | undefined {
+  if (
+    /\bcontainer (?:was )?replaced\b|\breplac(?:ed|ement) container\b|\bworkspace lost\b|\bcould not be re-attached\b/i.test(
+      words,
+    )
+  )
+    return "container_replaced";
+  if (/\bsandbox (?:recycled|worker|exec|runtime)\b/i.test(words)) return "sandbox_fault";
+  if (/\bbot restart(?:ed|s)?\b|\b(?:next|previous|another) generation\b/i.test(words)) return "bot_restart";
+  return undefined;
+}
+
+export function shipInterruptedNote(prUrl?: string, cause?: InterruptionCause): string {
   const stands = prUrl
     ? `Its work stands on GitHub: ${prUrl}.`
     : "Whatever it pushed stands on its pipeline branch; no PR was opened yet.";
   const reissue = prUrl
     ? `To continue the review loop, re-issue \`agent:ship\` in this thread with only the PR URL (${prUrl}).`
     : "To continue, re-issue `agent:ship` in this thread with the task — round 0 runs again on the same branch.";
-  return `⚠️ The bot restarted while this ship pipeline was running, so the pipeline stopped. ${stands} ${reissue}`;
+  const opening =
+    cause === "container_replaced"
+      ? "⚠️ The resident container running this pipeline's child was replaced (a deploy's image swap) and the child could not resume, so the pipeline stopped."
+      : cause === "sandbox_fault"
+        ? "⚠️ The sandbox running this pipeline's child failed and the child could not resume, so the pipeline stopped."
+        : cause === "bot_restart"
+          ? "⚠️ The bot restarted while this ship pipeline was running, so the pipeline stopped."
+          : "⚠️ This ship pipeline's child was interrupted and could not resume, so the pipeline stopped.";
+  return `${opening} ${stands} ${reissue}`;
 }
 
 // ---- the plan graph --------------------------------------------------------------------------------
@@ -473,9 +523,10 @@ export type CoordinatorAction =
        *  over an already-shipped pull request. */
       entry?: true;
       /** Set after a coding child died: the bot opens the pull request from the
-       *  pushed branch itself (title from the unit, body from this run's
-       *  submitted description when the record holds one) instead of answering
-       *  `none` over stranded work. */
+       *  pushed branch itself (title from this run's submitted description when
+       *  the record holds one, else a conventional fallback from the unit's
+       *  title — issue 1877; body from the description when the record holds
+       *  one) instead of answering `none` over stranded work. */
       recover?: { runId: string };
       /** The pull request the machine has adopted (`state.pr`), when it holds
        *  one: the child may have worked that pull request's own head branch,
@@ -536,6 +587,10 @@ export type ChildFacts =
        *  `provider_transient` marks a child a gateway 5xx, a cut stream or a
        *  gateway timeout ended past the harness's retry ladder (issue 1932). */
       failure?: { kind: string };
+      /** What ended an `interrupted` child, off its record's own events (issue
+       *  1876): the ending's sentence names it instead of claiming a bot
+       *  restart for every cause. */
+      interruption?: InterruptionCause;
     };
 
 /** What heads the unit's branch on GitHub: nothing, an open pull request, or —
@@ -599,7 +654,10 @@ export type StepReturn =
   | { type: "wait"; step: string; outcome: "event" | "timeout" }
   // `stopped` on a read: the instance row carries the hard stop's mark, so a
   // finished child ends its unit `stopped` whatever the child's own status.
-  | { type: "read-record"; step: string; run: ChildFacts; stopped?: true; at: number }
+  /** `restartedAs`: the interrupted child restarted from its request as this
+   *  run (issue 1903 — a replaced container's child resumes by itself), so the
+   *  machine keeps waiting on the successor instead of ending the unit. */
+  | { type: "read-record"; step: string; run: ChildFacts; stopped?: true; restartedAs?: string; at: number }
   | { type: "pr-check"; step: string; pr: PrCheck; at: number }
   | { type: "merge"; step: string; outcome: "merged"; sha: string; at: number }
   // The door found the pull request already merged after the approval — auto-merge
@@ -766,7 +824,7 @@ export type UnitEnding =
    *  `transient` so it reads as a condition beside `checks_failed` and `held`
    *  in the plane's table, never as the child failing on its task. */
   | { kind: "transient"; round: RoundRef; runId: string; reviewRounds: number }
-  | { kind: "interrupted"; round: RoundRef; runId: string; reviewRounds: number }
+  | { kind: "interrupted"; round: RoundRef; runId: string; reviewRounds: number; cause?: InterruptionCause }
   | { kind: "refused"; refusal: string; message?: string; round: RoundRef; reviewRounds: number }
   /** The unit idles instead of ending (record 0051): with the resolved
    *  `ship.idleDays` above zero, `end()` wraps an idling kind — every kind but
@@ -940,6 +998,8 @@ type Phase =
        *  pushed: the pr-check recovers a pushed branch by opening its pull
        *  request; with nothing pushed the unit ends with the child's own reason. */
       dead?: "failed" | "interrupted";
+      /** What ended the dead child (issue 1876), for the `interrupted` ending's sentence. */
+      cause?: InterruptionCause;
       /** The dead child's record names a provider transient (`failure:
        *  provider_transient`, issue 1932): with nothing pushed, round 0 is
        *  re-run once instead of the unit aborting; a second transient in the
@@ -1812,9 +1872,17 @@ function settlePrCheck(s: UnitPipelineState, phase: Extract<Phase, { at: "pr-che
     // A dead child left nothing on the branch to recover: the unit ends with
     // the child's own reason — never the budget clip.
     if (phase.dead === "interrupted")
-      return end(s, { kind: "interrupted", round, runId: phase.runId, reviewRounds: s.reviewRounds }, [
-        roundNote(round, "aborted"),
-      ]);
+      return end(
+        s,
+        {
+          kind: "interrupted",
+          round,
+          runId: phase.runId,
+          reviewRounds: s.reviewRounds,
+          ...(phase.cause !== undefined ? { cause: phase.cause } : {}),
+        },
+        [roundNote(round, "aborted")],
+      );
     if (phase.dead === "failed") {
       // A provider transient with nothing pushed is not the child's failure
       // (issue 1932): the ledger row and the branch are untouched, so round 0
@@ -1971,9 +2039,17 @@ function roundOnOpenPr(
       // ends with the child's own reason — the ship-restart note for a bot
       // roll, the failure for a failed run — never as the round's inaction.
       if (phase.dead === "interrupted")
-        return end(next, { kind: "interrupted", round, runId: phase.runId, reviewRounds: next.reviewRounds }, [
-          roundNote(round, "aborted"),
-        ]);
+        return end(
+          next,
+          {
+            kind: "interrupted",
+            round,
+            runId: phase.runId,
+            reviewRounds: next.reviewRounds,
+            ...(phase.cause !== undefined ? { cause: phase.cause } : {}),
+          },
+          [roundNote(round, "aborted")],
+        );
       if (phase.dead === "failed")
         return end(
           next,
@@ -2169,10 +2245,14 @@ export function applyReturn(s: UnitPipelineState, ret: StepReturn): Transition {
     case "read": {
       const r = ret as Extract<StepReturn, { type: "read-record" }>;
       if (!r.run.finished)
+        // `restartedAs` (issues 1903/1876): the child's container was replaced
+        // and it restarted from its request as a new run — the round carries on
+        // waiting on the successor, and the unit never ends over a resume that
+        // succeeded. The next wait and read follow the successor's id.
         return {
           state: {
             ...clocked,
-            phase: { at: "wait", round: p.round, runId: p.runId, n: p.n + 1, until: p.until },
+            phase: { at: "wait", round: p.round, runId: r.restartedAs ?? p.runId, n: p.n + 1, until: p.until },
           },
           notes: [],
         };
@@ -2192,17 +2272,35 @@ export function applyReturn(s: UnitPipelineState, ret: StepReturn): Transition {
           [roundNote(p.round, "stopped")],
         );
       if (r.run.status === "interrupted") {
+        const cause = r.run.interruption;
         // A dead CODING child may have pushed before the ledger closed it: the
         // pr-check recovers the branch. A review child has nothing on the
         // branch to recover, so its interruption still ends the unit at once.
         if (p.round.kind !== "review")
           return {
-            state: { ...clocked, phase: { at: "pr-check", round: p.round, runId: p.runId, dead: "interrupted" } },
+            state: {
+              ...clocked,
+              phase: {
+                at: "pr-check",
+                round: p.round,
+                runId: p.runId,
+                dead: "interrupted",
+                ...(cause !== undefined ? { cause } : {}),
+              },
+            },
             notes: [],
           };
-        return end(clocked, { kind: "interrupted", round: p.round, runId: p.runId, reviewRounds: s.reviewRounds }, [
-          roundNote(p.round, "aborted"),
-        ]);
+        return end(
+          clocked,
+          {
+            kind: "interrupted",
+            round: p.round,
+            runId: p.runId,
+            reviewRounds: s.reviewRounds,
+            ...(cause !== undefined ? { cause } : {}),
+          },
+          [roundNote(p.round, "aborted")],
+        );
       }
       return p.round.kind === "review"
         ? settleReview(clocked, p.round, r.run)
@@ -2450,13 +2548,16 @@ function mergeReadyHeadline(rounds: string, url: string, base: string, facts: Me
 export function renderUnitReport(
   s: UnitPipelineState,
   facts?: MergeReadyFacts,
-  /** The level the report speaks at (routing-and-config item 28). The default
-   *  is the full report — the row's and the board's copy; the thread's copy is
-   *  rendered at the request's level, where the asides about the machinery
-   *  (the level in force, the grant, the write-up pointer, the budget split,
-   *  a segment boundary) are `verbose` and the outcome, the verdict, the
-   *  findings left below the gate, the declined ones and what to do next are
-   *  everyone's. */
+  /** The level the report speaks at (routing-and-config item 28, record
+   *  0066). The default is the full report — the row's and the board's copy;
+   *  the thread's copy is rendered at the request's level, where only the
+   *  outcome is everyone's: ONE line in the user's words — `✅ Merge-ready
+   *  after 2 review rounds: <url>`, `Held: <the human-gated row>`, `Stopped`,
+   *  `Round cap reached: <counts>` — and the verdict, the findings left below
+   *  the gate, the declined ones, the remaining-gate sentence, the level in
+   *  force, the grant, the write-up pointer, the budget split, the re-issue
+   *  prompt and a segment boundary are `verbose` asides; the full detail
+   *  stays on the pull request, where the round routes put it. */
   verbosity: Verbosity = "verbose",
 ): string {
   const e = s.ending;
@@ -2498,11 +2599,11 @@ export function renderUnitReport(
         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,
+        aside(verdictLine),
         aside(levelLine),
         aside(grantLine),
-        skippedLine,
-        declinedLine,
+        aside(skippedLine),
+        aside(declinedLine),
       ]
         .filter(Boolean)
         .join("\n");
@@ -2516,19 +2617,23 @@ export function renderUnitReport(
         facts?.merged
           ? `✅ Merge-ready after ${rounds}: ${e.pr.url}`
           : mergeReadyHeadline(rounds, e.pr.url, s.input.base, facts),
-        verdictLine,
+        aside(verdictLine),
         aside(levelLine),
         aside(grantLine),
-        skippedLine,
-        declinedLine,
+        aside(skippedLine),
+        aside(declinedLine),
         // What the driver read at the approved head when it composed this
         // ending (agent-ship item 9): a merge that already happened is named
         // as such, else the pull request's own auto-merge fact, else the gate.
-        facts?.merged
-          ? `Already merged: ${e.pr.url} (merge commit \`${facts.merged.sha.slice(0, 7)}\`, merged ${facts.merged.mergedAt}) — auto-merge or a person merged it after the approval; the runner merged nothing.`
-          : facts?.autoMergeEnabled
-            ? "Auto-merge is on for this pull request: the approval merges it once checks pass."
-            : "Remaining gate: a person's merge — the runner merges only when the instance's `merge` field says runner, and ship never approves.",
+        // A `verbose` aside like the rest — the quiet thread copy is the
+        // headline alone (record 0066).
+        aside(
+          facts?.merged
+            ? `Already merged: ${e.pr.url} (merge commit \`${facts.merged.sha.slice(0, 7)}\`, merged ${facts.merged.mergedAt}) — auto-merge or a person merged it after the approval; the runner merged nothing.`
+            : facts?.autoMergeEnabled
+              ? "Auto-merge is on for this pull request: the approval merges it once checks pass."
+              : "Remaining gate: a person's merge — the runner merges only when the instance's `merge` field says runner, and ship never approves.",
+        ),
       ]
         .filter(Boolean)
         .join("\n");
@@ -2542,12 +2647,15 @@ export function renderUnitReport(
       // first (item 10), the very round this ending exists to avoid — so the
       // held case renders its own re-issue line instead of the shared one.
       const rows = e.findings.map((f) => `${f.id} (${f.severity}) — ${f.title}`).join("; ");
+      // The quiet copy is the ending in the user's words (record 0066): the
+      // held row named, the pull request linked, nothing about the machinery.
+      if (!shows(verbosity, "verbose")) return `⏸️ Held: ${rows}${e.pr !== undefined ? ` — ${e.pr.url}` : ""}`;
       const heldReissue = s.input.generated
         ? `To continue, re-issue \`agent:ship\` in this thread with only the PR URL${e.pr !== undefined ? ` (${e.pr.url})` : ""} — no new task text.`
         : reissue;
       return join([
         `⏸️ ${e.verdict === "approve" ? "Approved but held" : "Changes requested but held"} after ${rounds}${e.pr !== undefined ? `: ${e.pr.url}` : ""} — every finding of review round ${e.round.index} is human-gated, a receipt only a person can produce: ${rows}. No fix round was opened: a coding child cannot produce the receipt.`,
-        aside(levelLine),
+        levelLine,
         `Next step: produce the receipt each finding names and post it on the pull request. ${heldReissue} The re-issued attempt resumes at the review round — no coding round runs first.`,
       ]);
     }
@@ -2558,22 +2666,39 @@ export function renderUnitReport(
       // `already_landed`) and moves on to the dependents. The generated
       // plan's line already says to re-issue with the PR URL, which takes the
       // same recognition path.
+      // The quiet copy: the outcome in the user's words with the person's
+      // remedy — the hand merge is what a person must act on (record 0066).
+      if (!shows(verbosity, "verbose")) return `⚠️ Not merged: ${e.reason} — ${e.pr.url}`;
       return join([
         `⚠️ The review approved ${e.pr.url} but the runner did not merge it: ${e.reason}. A person decides what becomes of the pull request.`,
         s.input.generated
           ? reissue
           : `The approved work is on the branch: rebase or fix it, push, and merge it by hand. Then re-issue the plan naming the remaining units — a unit whose pull request has merged is recognized and not run again, and its dependents start from there.`,
       ]);
-    case "round_cap":
-      return join([
-        `🧢 Ship stopped at a cap: the ${e.maxRounds}-round cap — no approval after ${rounds}.${prLine}`,
-        splitReport(s),
-        reissue,
-      ]);
+    case "round_cap": {
+      // The quiet copy counts the last review's open findings, only the
+      // non-zero severities (record 0066): `Round cap reached: 2 blockers, 1 major`.
+      if (!shows(verbosity, "verbose")) {
+        const counts = severityCounts(s.findingsByRound[e.reviewRounds] ?? []);
+        return `🧢 Round cap reached${counts ? `: ${counts}` : ""}${prUrl !== undefined ? ` — ${prUrl}` : ""}`;
+      }
+      // The cap bounds fix rounds, never the terminal steps (issue 2023): an
+      // approval in the last allowed round still runs the checks step and the
+      // merge, so a round_cap after an approve means the checks (or the merge
+      // queue) failed at the approved head with no fix round left — and the
+      // report names those findings instead of claiming no approval landed.
+      const failedChecks = checkFindingsOf(s.findingsByRound[s.reviewRounds]);
+      const headline =
+        failedChecks.length > 0
+          ? `🧢 Ship stopped at a cap: the ${e.maxRounds}-round cap — the review of round ${e.reviewRounds} approved, but ${failedChecks.map((f) => `\`${f.id}\``).join(", ")} failed at the approved head and no fix round remains.${prLine}`
+          : `🧢 Ship stopped at a cap: the ${e.maxRounds}-round cap — no approval after ${rounds}.${prLine}`;
+      return join([headline, splitReport(s), reissue]);
+    }
     case "wall_clock_cap":
+      if (!shows(verbosity, "verbose")) return `🧢 Out of budget — no approval after ${rounds}.${prLine}`;
       return join([
         `🧢 Ship stopped at a cap: the remaining pipeline time (~${Math.max(0, Math.round(e.remainingMs / MIN))} min of the ${s.input.caps.maxMinutes}-minute budget) cannot hold another round${e.refused ? ` (the ${e.refused.round} round would get ${e.refused.minutes} min, under its floor of ${e.refused.floor})` : ""} — no approval after ${rounds}.${prLine}`,
-        aside(budgetSplitLine(e.spent, s.input.caps.maxMinutes)),
+        budgetSplitLine(e.spent, s.input.caps.maxMinutes),
         splitReport(s),
         reissue,
       ]);
@@ -2581,17 +2706,16 @@ export function renderUnitReport(
       return join([
         `⏳ Review pending: the coding child shipped ${e.pr.url}${e.headSha !== undefined ? ` (head \`${e.headSha.slice(0, 7)}\`)` : ""} but the remaining pipeline time cannot hold the review round — the work stands, only the review is missing. The next attempt starts at the review round while the pull request still heads at the child's own last push.`,
         aside(budgetSplitLine(e.spent, s.input.caps.maxMinutes)),
-        reissue,
+        aside(reissue),
       ]);
     case "stopped":
+      if (!shows(verbosity, "verbose")) return `${e.mode === "hard" ? "⛔" : "⏹"} Stopped.${prLine}`;
       return join([
         `${e.mode === "hard" ? "⛔" : "⏹"} Ship stopped by operator (${e.mode} stop) after ${rounds}.${prLine}`,
-        aside(
-          writeUpPointer(
-            s,
-            e.round.kind,
-            e.round.kind === "review" ? s.reviewRunByRound[e.round.index] : s.lastCodingRunId,
-          ),
+        writeUpPointer(
+          s,
+          e.round.kind,
+          e.round.kind === "review" ? s.reviewRunByRound[e.round.index] : s.lastCodingRunId,
         ),
         e.postedReview
           ? "ℹ️ A changes-requested review was posted this round before the stop — its findings stand on the PR."
@@ -2599,14 +2723,13 @@ export function renderUnitReport(
         reissue,
       ]);
     case "aborted":
+      if (!shows(verbosity, "verbose")) return `⚠️ Aborted after ${rounds}: ${e.reason}${prLine}`;
       return join([
         e.reason,
-        aside(
-          writeUpPointer(
-            s,
-            e.round?.kind ?? "coding",
-            e.round?.kind === "review" ? s.reviewRunByRound[e.round.index] : s.lastCodingRunId,
-          ),
+        writeUpPointer(
+          s,
+          e.round?.kind ?? "coding",
+          e.round?.kind === "review" ? s.reviewRunByRound[e.round.index] : s.lastCodingRunId,
         ),
         e.renewal !== undefined ? `🔁 Not renewed: ${e.renewal.line}.` : undefined,
         `⚠️ Ship aborted after ${rounds}.`,
@@ -2623,25 +2746,29 @@ export function renderUnitReport(
         aside(budgetSplitLine(e.spent, s.input.caps.maxMinutes)),
       ]);
     case "transient":
+      if (!shows(verbosity, "verbose"))
+        return `⚠️ Aborted after ${rounds}: the model provider failed twice; re-issue once it settles.${prLine}`;
       return join([
         `⚠️ The coding child of round ${e.round.index} (run ${e.runId}) died on a provider transient — a model-gateway 5xx, a cut stream or a gateway timeout past the harness's retry ladder — with nothing pushed, after the round was already re-run once for the same reason. The task itself was never the problem.`,
-        aside(writeUpPointer(s, e.round.kind, s.lastCodingRunId)),
+        writeUpPointer(s, e.round.kind, s.lastCodingRunId),
         `⚠️ Ship ended after ${rounds}; re-issue once the provider settles.`,
         reissue,
       ]);
     case "no_verdict":
+      if (!shows(verbosity, "verbose"))
+        return `⚠️ No verdict from review round ${e.round.index} — aborted after ${rounds}.${prLine}`;
       return join([
         `⚠️ Review round ${e.round.index} ended without a submitted verdict (budget, refusal, or stop) — ship never converts that into a request for changes, so no findings step ran.`,
-        aside(writeUpPointer(s, e.round.kind, s.reviewRunByRound[e.round.index])),
+        writeUpPointer(s, e.round.kind, s.reviewRunByRound[e.round.index]),
         `⚠️ Ship aborted after ${rounds}.`,
         reissue,
       ]);
     case "interrupted":
-      return shipInterruptedNote(prUrl);
+      return shipInterruptedNote(prUrl, e.cause);
     case "refused":
       return join([
         `🚫 The ${presetOf(e.round.kind)} child of round ${e.round.index} was refused by the authorize stage (${e.refusal})${e.message ? `: ${e.message}` : ""} — every child is authorized as the requesting user, so the pipeline ends here.`,
-        reissue,
+        aside(reissue),
       ]);
     case "idle":
       // The old kind's sentence at this copy's level — the report is unchanged