@coreplane/switchboard 1.259.0 → 1.260.1

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

@@ -32,7 +32,14 @@
 import type { ShipRoundOutcome } from "../runEvents.js";
 import { shows, type Verbosity } from "../verbosity.js";
 import type { Handoff, HandoffLanded } from "./handoff.js";
-import { progressOf, renderRenewal, renewalDecision, type PushedHeadFact, type RenewalDecision } from "./renewal.js";
+import {
+  progressOf,
+  renderRenewal,
+  renewalDecision,
+  type PushedHeadFact,
+  type RenewalDecision,
+  type RenewalWhy,
+} from "./renewal.js";
 import type { RunStatus } from "../runRecord.js";
 import { normalizeHead, sameCommit } from "../reviewedHead.js";
 import {
@@ -125,13 +132,15 @@ export function interruptionCauseOfWords(words: string): InterruptionCause | und
   return undefined;
 }
 
-export function shipInterruptedNote(prUrl?: string, cause?: InterruptionCause): string {
+export function shipInterruptedNote(prUrl?: string, cause?: InterruptionCause, idle = false): 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.";
+  const reissue = idle
+    ? "To continue, reply in this thread to continue."
+    : 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.";
   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."
@@ -477,7 +486,7 @@ export type Brief =
       rebase: { branch: string; onto: string };
       /** A renewal's segment (decision 0046): the child continues the previous
        *  segment's work from `from`, briefed with that run's write-up and handoff. */
-      continue?: { segment: number; from?: string; previousRunId?: string };
+      continue?: { segment: number; from?: string; previousRunId?: string; texts?: string[] };
     }
   | {
       kind: "review";
@@ -542,10 +551,10 @@ export type CoordinatorAction =
   | { type: "merge"; step: string; prNumber: number; headSha: string; queued?: true }
   /** Read the check runs at the reviewed head (record 0055, the round verdict):
    *  the merge door's own reading, folded into the round. `retry` names the
-   *  failed checks whose one flake re-run the machine is spending: the bot
-   *  re-runs their failed jobs (the CI retry the deploy already uses) instead
-   *  of reading. */
-  | { type: "checks"; step: string; prNumber: number; headSha: string; retry?: string[] }
+   *  failed checks whose one flake re-run the machine is spending; `refire`
+   *  asks for the one close/reopen recovery when no required check launched.
+   *  Either effect runs instead of a read. */
+  | { type: "checks"; step: string; prNumber: number; headSha: string; retry?: string[]; refire?: true }
   /** Wait for the intake's checks-settled event at the approved head, bounded as the fallback. */
   | { type: "wait-checks"; step: string; headSha: string; timeoutMs: number }
   | { type: "sleep"; step: string; ms: number }
@@ -636,6 +645,10 @@ export type PrCheck =
       /** The head's self-declared fix-up commit subjects (`fixup!`/`squash!`/`amend!`),
        *  when the read asked for the facts — a head carrying one is not in the ready state. */
       fixupCommits?: string[];
+      /** The base branch takes changes only through a merge queue (issue 2011):
+       *  read beside the checks on the ending's facts read, so a `merge_ready`
+       *  report tells the person their merge is queued, never a direct one. */
+      baseHasMergeQueue?: boolean;
     }
   | { state: "merged"; prNumber: number; url: string; sha: string; mergedAt: string };
 
@@ -667,10 +680,18 @@ export type StepReturn =
    *  queue removed it — the reason is the queue's own (issue 2011). */
   | { type: "merge"; step: string; outcome: "pending" | "refused" | "enqueued" | "removed"; reason: string; at: number }
   /** The checks read at the reviewed head; `checks` absent means GitHub could
-   *  not be read, which the machine treats as pending (record 0055). A retry
-   *  ask answers `retried` instead: whether the bot dispatched the re-run —
-   *  false means there is nothing to wait for at the unchanged head. */
-  | { type: "checks"; step: string; checks?: RoundChecks; draft?: boolean; retried?: boolean; at: number }
+   *  not be read, which the machine treats as pending (record 0055). Effect
+   *  asks answer `retried` or `refired` instead; false still spends that one
+   *  recovery so an unchanged head cannot loop on the write. */
+  | {
+      type: "checks";
+      step: string;
+      checks?: RoundChecks;
+      draft?: boolean;
+      retried?: boolean;
+      refired?: boolean;
+      at: number;
+    }
   | { type: "wait-checks"; step: string; outcome: "event" | "timeout" }
   | { type: "sleep"; step: string };
 
@@ -686,14 +707,18 @@ export interface CheckFailure {
 }
 
 /** The check runs at the reviewed head as the round's checks step reads them.
- *  `expected` names checks the head must still gain — a required check, or the
- *  repository's approve workflow whose run does not exist yet (issue 2063):
- *  the base's required contexts not among the reported runs. The table reads
- *  an expected-but-unreported check exactly as a pending one. */
+ *  `required` carries the base's whole required-context set and `expected`
+ *  its unreported subset. The whole set lets the table distinguish no required
+ *  check launching from an unrelated run that did report; an ordinary missing
+ *  subset reads exactly as pending (issue 2063). */
 export interface RoundChecks {
   total: number;
   pending: string[];
   failed: CheckFailure[];
+  /** Every check context required by the base. Together with `expected`, this
+   *  distinguishes an empty required-check launch from an unrelated check
+   *  that did report (for example the title workflow). */
+  required?: string[];
   expected?: string[];
 }
 
@@ -818,6 +843,8 @@ export type UnitEnding =
       finalReply?: string;
       /** A changes-requested review posted this round before the stop. */
       postedReview?: boolean;
+      /** The mechanical WIP checkpoint a stopped coding child pushed before teardown. */
+      checkpoint?: { branch: string; sha: string };
     }
   | {
       kind: "aborted";
@@ -852,6 +879,7 @@ export type UnitEnding =
       spent: ShipBudgetSpent;
     }
   | { kind: "no_verdict"; round: RoundRef; reviewRounds: number; finalReply?: string }
+  | { kind: "idle_expired"; reviewRounds: number }
   /** Round 0's coding child died on a provider transient — a model-gateway
    *  5xx, a cut stream, a gateway timeout, past the harness's retry ladder —
    *  with nothing pushed, TWICE: the first such death re-ran the round once
@@ -860,7 +888,14 @@ 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; cause?: InterruptionCause }
+  | {
+      kind: "interrupted";
+      round: RoundRef;
+      runId: string;
+      reviewRounds: number;
+      cause?: InterruptionCause;
+      checkpoint?: { branch: string; sha: string };
+    }
   | { 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
@@ -896,7 +931,8 @@ export type UnitEnding =
  *  the pull request, which no thread reply can produce — but a blocked hold
  *  (issue 2086) waits for exactly the person's word the idle's wake carries,
  *  so it alone idles; `idleEnding` draws that line by cause. */
-export type IdleWhy = Exclude<UnitEnding["kind"], "idle" | "merged" | "already_landed" | "merge_ready" | "refused">;
+export type IdleWhy =
+  Exclude<UnitEnding["kind"], "idle" | "merged" | "already_landed" | "merge_ready" | "refused"> | RenewalWhy;
 
 const NEVER_IDLES: ReadonlySet<UnitEnding["kind"]> = new Set([
   "idle",
@@ -904,6 +940,7 @@ const NEVER_IDLES: ReadonlySet<UnitEnding["kind"]> = new Set([
   "already_landed",
   "merge_ready",
   "refused",
+  "idle_expired",
 ]);
 
 /** What a transition tells the driver beyond the next action: a round boundary
@@ -957,6 +994,12 @@ export interface LeaseSegmentProgress {
   /** The previous segment's coding run: its write-up and handoff brief the continuation. */
   previousRunId?: string;
   previousHandoff?: Handoff;
+  /** Words that woke an idle segment, already attributed in arrival order. */
+  texts?: string[];
+  /** A stopped segment reopens under the remainder of its cut lease. Each
+   *  reopen gets a fresh attempt so its Workflow steps cannot replay the
+   *  stopped attempt's cached answers. */
+  resume?: { leaseMs: number; attempt: number };
 }
 
 export interface UnitPipelineInput {
@@ -1050,9 +1093,10 @@ type Phase =
   | { at: "merge-wait"; pr: PrRef; headSha: string; n: number; since: number; waitMs: number; queued?: true }
   /** The round's checks step (record 0055): the check runs at the reviewed head
    *  are read after an approve settles, before merge_ready or the merge door.
-   *  `graced`: a head with no check reported has had its one-chunk grace;
-   *  `retried`: the one flake re-run is spent; `retry` names the failed checks
-   *  the next ask re-runs instead of reading. */
+   *  `graced`: a head with no required check reported has had its one-chunk
+   *  grace; `refired`: the one pull_request close/reopen recovery is spent;
+   *  `retried`: the one flake re-run is spent. `retry` and `refire` make the
+   *  next ask perform that effect instead of reading. */
   | {
       at: "checks";
       round: RoundRef;
@@ -1063,7 +1107,9 @@ type Phase =
       waitMs: number;
       graced: boolean;
       retried: boolean;
+      refired: boolean;
       retry?: string[];
+      refire?: true;
     }
   /** Waiting on `checks-settled-<head>` between two checks reads, in the merge
    *  wait's own chunks — the intake wakes the machine when the head settles. */
@@ -1077,6 +1123,7 @@ type Phase =
       waitMs: number;
       graced: boolean;
       retried: boolean;
+      refired: boolean;
     }
   | { at: "ended" };
 
@@ -1162,7 +1209,8 @@ export function openUnitPipeline(input: UnitPipelineInput, at: number): UnitPipe
   return nextReview(resumed).state;
 }
 
-const deadlineAt = (s: UnitPipelineState) => s.startedAt + s.input.caps.maxMinutes * MIN;
+const deadlineAt = (s: UnitPipelineState) =>
+  s.startedAt + (s.input.session?.resume?.leaseMs ?? 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
@@ -1189,11 +1237,14 @@ function roundCarve(s: UnitPipelineState, round: RoundRef): Carve {
   );
 }
 
-/** The prefix every step of this pipeline is named under: the unit id, and for
- *  a renewal's segment the segment too (`U10/s2/…`), so the Workflow's durable
- *  step cache never hands segment two the answers of segment one. */
-export const stepPrefixOf = (unit: string, session: LeaseSegmentProgress | undefined): string =>
-  session !== undefined && session.segment > 1 ? `${unit}/s${session.segment}` : unit;
+/** The prefix every step of this pipeline is named under: the unit id, a
+ *  renewal's segment (`U10/s2/…`), and a stopped segment's resumed attempt
+ *  (`U10/s2/r1/…`). Both transitions need fresh Workflow identities so the
+ *  durable step cache cannot answer a new attempt with an older one's result. */
+export const stepPrefixOf = (unit: string, session: LeaseSegmentProgress | undefined): string => {
+  const segment = session !== undefined && session.segment > 1 ? `${unit}/s${session.segment}` : unit;
+  return session?.resume !== undefined ? `${segment}/r${session.resume.attempt}` : segment;
+};
 const stepPrefix = (s: UnitPipelineState) => stepPrefixOf(s.input.unit.id, s.input.session);
 const roundStep = (s: UnitPipelineState, round: RoundRef) =>
   `${stepPrefix(s)}/${round.index}/${round.kind}${round.attempt !== undefined ? `/a${round.attempt}` : ""}`;
@@ -1212,6 +1263,7 @@ function briefFor(s: UnitPipelineState, round: RoundRef): Brief {
               segment: session.segment,
               ...(session.continueFrom !== undefined ? { from: session.continueFrom } : {}),
               ...(session.previousRunId !== undefined ? { previousRunId: session.previousRunId } : {}),
+              ...(session.texts !== undefined ? { texts: session.texts } : {}),
             },
           }
         : {}),
@@ -1311,6 +1363,7 @@ export function nextAction(s: UnitPipelineState): CoordinatorAction {
         prNumber: p.prNumber,
         headSha: p.headSha,
         ...(p.retry !== undefined ? { retry: p.retry } : {}),
+        ...(p.refire === true ? { refire: true as const } : {}),
       };
     case "checks-wait":
       return {
@@ -1400,7 +1453,7 @@ function idleEnding(s: UnitPipelineState, ending: UnitEnding): Extract<UnitEndin
   const round = "round" in old ? old.round : undefined;
   return {
     kind: "idle",
-    why: old.kind,
+    why: old.kind === "aborted" && old.renewal !== undefined ? old.renewal.decision.why : old.kind,
     idled: old,
     renewalsLeft,
     ...(from !== undefined ? { from } : {}),
@@ -1491,6 +1544,16 @@ function nextReview(s: UnitPipelineState, notes: CoordinatorNote[] = []): Transi
 const stopMode = (status: RunStatus): "soft" | "hard" | undefined =>
   status === "stopped_soft" ? "soft" : status === "stopped_hard" ? "hard" : undefined;
 
+/** The last mechanical WIP push to this unit branch. Unlike an ordinary push,
+ *  it says the child ended before its work was ready for review. */
+function interruptedCheckpoint(
+  s: UnitPipelineState,
+  pushed: readonly PushedHeadFact[] | undefined,
+): { branch: string; sha: string } | undefined {
+  const found = pushed?.filter((p) => p.ref === s.input.unit.branch && p.by === "salvage").at(-1);
+  return found ? { branch: found.ref, sha: found.sha } : undefined;
+}
+
 /** A coding run's confirmed end: round 0's child, or the run a findings step dispatched. */
 function settleCoding(
   s: UnitPipelineState,
@@ -1518,6 +1581,7 @@ function settleCoding(
         }
       : {}),
   };
+  const checkpoint = interruptedCheckpoint(next, facts.pushed);
   const mode = stopMode(facts.status);
   if (mode !== undefined)
     return end(
@@ -1528,13 +1592,33 @@ function settleCoding(
         round,
         reviewRounds: next.reviewRounds,
         ...(facts.finalReply !== undefined ? { finalReply: facts.finalReply } : {}),
+        ...(checkpoint !== undefined ? { checkpoint } : {}),
       },
       [roundNote(round, "stopped")],
     );
+  // A mechanical WIP push means the child did not declare the work ready for
+  // review. Keep the unit branch as the resumption point and abort this
+  // attempt; an ordinary push still takes the established recover-PR path.
+  if (facts.status === "failed" && checkpoint !== undefined) {
+    const cause =
+      facts.failure?.kind === "provider_transient"
+        ? "the model provider's transport retry budget was spent"
+        : "it failed before finishing";
+    return end(
+      next,
+      {
+        kind: "aborted",
+        reason: `⚠️ The coding child ended because ${cause}; the branch carries the interrupted work at \`${checkpoint.sha.slice(0, 7)}\` on \`${checkpoint.branch}\`. Re-issue the request to resume from it instead of starting over.`,
+        round,
+        reviewRounds: next.reviewRounds,
+      },
+      [roundNote(round, "aborted")],
+    );
+  }
   // A failed coding child no longer aborts outright: the pr-check looks at the
-  // branch first — a push before the death is recovered as the round's pull
-  // request (agent-ship items 10 and 15), and only a branch with
-  // nothing on it ends the unit with the child's own reason.
+  // branch first — an ordinary push before the death is recovered as the
+  // round's pull request, and only a branch with nothing on it ends the unit
+  // with the child's own reason.
   if (facts.status === "failed")
     return {
       state: {
@@ -1718,6 +1802,7 @@ function enterChecks(s: UnitPipelineState, round: RoundRef, notes: CoordinatorNo
         waitMs,
         graced: false,
         retried: false,
+        refired: false,
       },
     },
     notes,
@@ -1737,14 +1822,16 @@ function enterChecks(s: UnitPipelineState, round: RoundRef, notes: CoordinatorNo
  *      (`expected`: a required check, or the repository's approve workflow
  *      whose run does not exist yet), or GitHub unreadable: the head waits on
  *      the settled event and is read again;
- *  (—) no check reported at all: one chunk of grace, never more;
+ *  (—) no required check reported: one chunk of grace, then the pull_request
+ *      event is re-fired once by closing and reopening the pull request;
  *  (c) every expected check reported green: the round proceeds with no wait. */
 function checksVerdict(
   checks: RoundChecks | undefined,
-  p: { retried: boolean; graced: boolean },
+  p: { retried: boolean; graced: boolean; refired: boolean },
   draft?: boolean,
 ):
   | { kind: "retry"; names: string[] }
+  | { kind: "refire" }
   | { kind: "failed"; failed: CheckFailure[] }
   | { kind: "draft" }
   | { kind: "pending" }
@@ -1764,14 +1851,18 @@ function checksVerdict(
   // person's "ready" changes anything — a red check above still gets its fix
   // round, since that work stands whether or not the pull request is a draft.
   if (draft === true) return { kind: "draft" };
+  const required = checks?.required ?? [];
+  const missing = checks?.expected ?? [];
+  const noRequiredReported = required.length > 0 && missing.length === required.length;
+  // A check launcher may report an unrelated workflow while every required
+  // context is still absent. Give it one normal chunk; if it remains empty,
+  // re-fire pull_request once. This is the same recovery a person performs for
+  // a CI run that exists but started no workflows.
+  if ((checks?.total === 0 || noRequiredReported) && !p.graced) return { kind: "grace" };
+  if (noRequiredReported && !p.refired) return { kind: "refire" };
   // GitHub unreadable answers as pending and is re-read at the chunk's end;
   // an expected check not yet reported (issue 2063) is pending the same way.
-  if (checks === undefined || checks.pending.length > 0 || (checks.expected?.length ?? 0) > 0)
-    return { kind: "pending" };
-  // No check reported at the head: one chunk of grace — the first check starts
-  // within minutes where CI exists — then the round proceeds, so a repository
-  // without CI costs one chunk per round and never idles (record 0055).
-  if (checks.total === 0 && !p.graced) return { kind: "grace" };
+  if (checks === undefined || checks.pending.length > 0 || missing.length > 0) return { kind: "pending" };
   return { kind: "green" };
 }
 
@@ -1783,14 +1874,15 @@ function checksVerdict(
  *  is still pending (issue 1991); only a head with no failed check waits a
  *  chunk inside the step's ask on what is unreadable or pending and then
  *  proceeds — the ending's facts read names what is still pending; a head with
- *  no check reported waits one chunk of grace and never more; a green head
- *  proceeds with no wait added. */
+ *  no required check reported gets one grace chunk and one event re-fire; a
+ *  green head proceeds with no wait added. */
 function settleChecks(
   s: UnitPipelineState,
   p: Extract<Phase, { at: "checks" }>,
   checks: RoundChecks | undefined,
   retried?: boolean,
   draft?: boolean,
+  refired?: boolean,
 ): Transition {
   const { round } = p;
   const wait = (over: Partial<Extract<Phase, { at: "checks-wait" }>>): Transition => ({
@@ -1806,11 +1898,23 @@ function settleChecks(
         waitMs: p.waitMs,
         graced: p.graced,
         retried: p.retried,
+        refired: p.refired,
         ...over,
       },
     },
     notes: [],
   });
+  // The pull_request re-fire is an effect ask after a whole grace chunk with
+  // no required check. Whether GitHub accepted it or not, spend the one attempt
+  // and read immediately: that read registers the ordinary bounded wait. A
+  // successful effect adds the round boundary the card renders.
+  if (p.refire === true) {
+    const { refire: _refire, ...read } = p;
+    return {
+      state: { ...s, phase: { ...read, n: p.n + 1, refired: true } },
+      notes: refired === true ? [roundNote(p.round, "checks_restarted")] : [],
+    };
+  }
   // The retry ask. Dispatched: wait for the head to settle, then read again;
   // a second failure is the finding. NOT dispatched (`retried: false` — no
   // re-runnable run behind the checks, or GitHub refused): the one re-run is
@@ -1831,6 +1935,11 @@ function settleChecks(
         state: { ...s, phase: { ...p, n: p.n + 1, retry: verdict.names } },
         notes: [],
       };
+    case "refire":
+      return {
+        state: { ...s, phase: { ...p, n: p.n + 1, refire: true } },
+        notes: [],
+      };
     case "failed": {
       const findings = [...(s.findingsByRound[round.index] ?? []), ...verdict.failed.map(checkFinding)];
       const next: UnitPipelineState = {
@@ -2360,7 +2469,8 @@ export function applyReturn(s: UnitPipelineState, ret: StepReturn): Transition {
       // The hosted parent's hard stop landed while this child ran (record 0060;
       // issue 1924): the unit ends stopped as the child ends, whatever the
       // child's own status — the runner runs nothing more of it.
-      if (r.stopped === true)
+      if (r.stopped === true) {
+        const checkpoint = p.round.kind === "review" ? undefined : interruptedCheckpoint(clocked, r.run.pushed);
         return end(
           clocked,
           {
@@ -2369,14 +2479,33 @@ export function applyReturn(s: UnitPipelineState, ret: StepReturn): Transition {
             round: p.round,
             reviewRounds: s.reviewRounds,
             ...(r.run.finalReply !== undefined ? { finalReply: r.run.finalReply } : {}),
+            ...(checkpoint !== undefined ? { checkpoint } : {}),
           },
           [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.
+        const checkpoint = interruptedCheckpoint(clocked, r.run.pushed);
+        // A mechanical WIP checkpoint is deliberately not opened for review:
+        // the interrupted child never declared it finished. The next attempt
+        // starts from the unit branch at that head.
+        if (p.round.kind !== "review" && checkpoint !== undefined)
+          return end(
+            clocked,
+            {
+              kind: "interrupted",
+              round: p.round,
+              runId: p.runId,
+              reviewRounds: s.reviewRounds,
+              ...(cause !== undefined ? { cause } : {}),
+              checkpoint,
+            },
+            [roundNote(p.round, "aborted")],
+          );
+        // A dead CODING child may have pushed normally before the ledger closed
+        // it: the pr-check recovers that 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: {
@@ -2411,7 +2540,7 @@ export function applyReturn(s: UnitPipelineState, ret: StepReturn): Transition {
       return settlePrCheck(clocked, p, (ret as Extract<StepReturn, { type: "pr-check" }>).pr);
     case "checks": {
       const r = ret as Extract<StepReturn, { type: "checks" }>;
-      return settleChecks(clocked, p, r.checks, r.retried, r.draft);
+      return settleChecks(clocked, p, r.checks, r.retried, r.draft, r.refired);
     }
     case "checks-wait":
       // The event fired or the chunk elapsed either way the head is read again.
@@ -2428,6 +2557,7 @@ export function applyReturn(s: UnitPipelineState, ret: StepReturn): Transition {
             waitMs: p.waitMs,
             graced: p.graced,
             retried: p.retried,
+            refired: p.refired,
           },
         },
         notes: [],
@@ -2612,6 +2742,10 @@ export interface MergeReadyFacts {
    *  (git's autosquash prefixes `fixup!`, `squash!`, `amend!`): a head
    *  carrying one is by its own words not in the ready state. */
   fixupCommits?: string[];
+  /** The base branch takes changes only through a merge queue (issue 2011):
+   *  the merge:person path names "queued" in its line — the person's merge
+   *  enqueues the pull request and the queue merges it on its own. */
+  baseHasMergeQueue?: boolean;
 }
 
 /** The check runs at one commit: how many, which still run, which failed. */
@@ -2694,6 +2828,10 @@ export function renderUnitReport(
       ? `Findings below ${level}, left as-is: ${skipped.map((f) => `${f.id} (${f.severity}) — ${f.title}`).join("; ")}`
       : undefined;
   const join = (parts: Array<string | undefined>) => parts.filter(Boolean).join("\n\n");
+  const checkpointLine = (checkpoint: { branch: string; sha: string } | undefined) =>
+    checkpoint === undefined
+      ? undefined
+      : `The branch carries the interrupted work at \`${checkpoint.sha.slice(0, 7)}\` on \`${checkpoint.branch}\`; re-issue to resume from it instead of starting over.`;
   switch (e.kind) {
     case "merged":
       if (e.by === "other")
@@ -2733,7 +2871,12 @@ export function renderUnitReport(
             ? `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 pipeline 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 pipeline merges only when the plan's `merge` setting says so, and ship never approves.",
+              : facts?.baseHasMergeQueue === true
+                ? // The merge:person path names "queued" in its line (issue 2011):
+                  // the base takes changes only through a merge queue, so the
+                  // person's merge enqueues — never a direct merge.
+                  `Remaining gate: a person's merge, queued — \`${s.input.base}\` takes changes only through a merge queue, so the merge enqueues the pull request (\`gh pr merge --auto\`) and the queue merges it on its own; the pipeline merges only when the plan's \`merge\` setting says so, and ship never approves.`
+                : "Remaining gate: a person's merge — the pipeline merges only when the plan's `merge` setting says so, and ship never approves.",
         ),
       ]
         .filter(Boolean)
@@ -2837,9 +2980,11 @@ export function renderUnitReport(
         aside(reissue),
       ]);
     case "stopped":
-      if (!shows(verbosity, "verbose")) return `${e.mode === "hard" ? "⛔" : "⏹"} Stopped.${prLine}`;
+      if (!shows(verbosity, "verbose"))
+        return join([`${e.mode === "hard" ? "⛔" : "⏹"} Stopped.${prLine}`, checkpointLine(e.checkpoint)]);
       return join([
         `${e.mode === "hard" ? "⛔" : "⏹"} Ship stopped by operator (${e.mode} stop) after ${rounds}.${prLine}`,
+        checkpointLine(e.checkpoint),
         writeUpPointer(
           s,
           e.round.kind,
@@ -2848,7 +2993,7 @@ export function renderUnitReport(
         e.postedReview
           ? "ℹ️ A changes-requested review was posted this round before the stop — its findings stand on the PR."
           : undefined,
-        reissue,
+        s.input.idleDays && s.input.idleDays > 0 ? "Next step: reply in this thread to continue." : reissue,
       ]);
     case "aborted":
       if (!shows(verbosity, "verbose")) return `⚠️ Aborted after ${rounds}: ${e.reason}${prLine}`;
@@ -2870,7 +3015,9 @@ export function renderUnitReport(
       if (!shows(verbosity, "verbose")) return "";
       return join([
         writeUpPointer(s, e.round.kind, e.runId),
-        `🔁 The unit's budget ran out with the unit unfinished — ${e.line}. A fresh ${s.input.caps.maxMinutes}-minute budget opens in this thread${e.from !== undefined ? ` from \`${e.from.slice(0, 7)}\`` : ""}, with the last run's write-up as its request; ${e.renewalsLeft} renewal${e.renewalsLeft === 1 ? "" : "s"} remain${e.spendUsd !== null ? `, $${e.spendUsd.toFixed(2)} spent so far` : ""}.`,
+        s.input.idleDays && s.input.idleDays > 0
+          ? `🔁 The unit's budget ran out with the unit unfinished — ${e.line}. Next step: reply in this thread to continue; ${e.renewalsLeft} renewal${e.renewalsLeft === 1 ? "" : "s"} remain${e.spendUsd !== null ? `, $${e.spendUsd.toFixed(2)} spent so far` : ""}.`
+          : `🔁 The unit's budget ran out with the unit unfinished — ${e.line}. A fresh ${s.input.caps.maxMinutes}-minute budget opens in this thread${e.from !== undefined ? ` from \`${e.from.slice(0, 7)}\`` : ""}, with the last run's write-up as its request; ${e.renewalsLeft} renewal${e.renewalsLeft === 1 ? "" : "s"} remain${e.spendUsd !== null ? `, $${e.spendUsd.toFixed(2)} spent so far` : ""}.`,
         aside(budgetSplitLine(e.spent, s.input.caps.maxMinutes)),
       ]);
     case "transient":
@@ -2892,7 +3039,9 @@ export function renderUnitReport(
         reissue,
       ]);
     case "interrupted":
-      return shipInterruptedNote(prUrl, e.cause);
+      return join([shipInterruptedNote(prUrl, e.cause, (s.input.idleDays ?? 0) > 0), checkpointLine(e.checkpoint)]);
+    case "idle_expired":
+      return "⌛ Idle expired: no reply continued this unit before its idle window closed.";
     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.`,

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

@@ -18,6 +18,8 @@ import type { Handoff } from "./handoff.js";
 export interface PushedHeadFact {
   ref: string;
   sha: string;
+  /** Mechanical WIP checkpoints are preserved work, not a completed agent push. */
+  by?: "push" | "salvage";
   at?: number;
 }
 
@@ -82,7 +84,10 @@ export interface RenewalInput {
   /** Dollars spent under this request so far; null when a run's model had no
    *  price, since a total that left a model's tokens out would understate it. */
   spendUsd: number | null;
-  progress: Progress;
+  /** Progress normally comes from the segment's row. An idle wake sets it
+   * aside because the person's reply is the new work to run; the count, cap
+   * and fit still decide whether another lease may open. */
+  progress: Progress | "set_aside";
   /** The pipeline the next segment would run: its fit is re-asserted before every segment. */
   pipeline: Pipeline;
 }
@@ -101,7 +106,8 @@ const usd = (n: number): string => `$${n.toFixed(2)}`;
  *  the progress. */
 export function renewalDecision(input: RenewalInput): RenewalDecision {
   const renewalsLeft = Math.max(0, input.grant.renewals - input.renewalsSpent);
-  if (!input.progress.progressed) return { renew: false, why: "no_progress", detail: input.progress.why, renewalsLeft };
+  if (input.progress !== "set_aside" && !input.progress.progressed)
+    return { renew: false, why: "no_progress", detail: input.progress.why, renewalsLeft };
   if (renewalsLeft === 0) {
     const detail =
       input.grant.renewals === 0
@@ -139,7 +145,7 @@ export function renewalDecision(input: RenewalInput): RenewalDecision {
   return {
     renew: true,
     segment: input.renewalsSpent + 2,
-    ...(input.progress.by === "push" ? { from: input.progress.sha } : {}),
+    ...(input.progress !== "set_aside" && input.progress.by === "push" ? { from: input.progress.sha } : {}),
     renewalsLeft: renewalsLeft - 1,
   };
 }
@@ -149,22 +155,31 @@ export function renewalDecision(input: RenewalInput): RenewalDecision {
  *  names the clause and, when renewals remain, what actually spends one — a
  *  budget that made progress — and the honest recourse (re-issue the request).
  *  It teaches no keyword: the router has none (routing-and-config item 3). */
-export function renderRenewal(decision: RenewalDecision, grant: Grant): string {
+export function renderRenewal(
+  decision: RenewalDecision,
+  grant: Grant,
+  options: { idle?: boolean; senders?: readonly string[] } = {},
+): string {
+  const recourse = options.idle ? "reply in this thread to continue" : "re-issue the request to try again";
+  const senders = options.senders?.length
+    ? `, with ${options.senders.length} message${options.senders.length === 1 ? "" : "s"} from ${options.senders.join(", ")}`
+    : "";
   if (decision.renew)
-    return `budget renewed, ${decision.segment - 1} of ${grant.renewals}, continues ${decision.from !== undefined ? decision.from.slice(0, 7) : "the branch's head"}`;
+    return `budget renewed, ${decision.segment - 1} of ${grant.renewals}, continues ${decision.from !== undefined ? decision.from.slice(0, 7) : "the branch's head"}${senders}`;
   const holds =
     decision.renewalsLeft > 0
       ? `${decision.renewalsLeft} renewal${decision.renewalsLeft === 1 ? "" : "s"} left`
       : "no renewals left";
+  const idleRecourse = (line: string): string => (options.idle ? `${line}; ${recourse}` : line);
   switch (decision.why) {
     case "no_progress":
       return decision.renewalsLeft > 0
-        ? `no progress on the last budget; ${holds} unspent — a renewal is spent only by a budget that pushed to the unit's branch or moved its write-up; re-issue the request to try again`
+        ? `no progress on the last budget; ${holds} unspent — a renewal is spent only by a budget that pushed to the unit's branch or moved its write-up; ${recourse}`
         : `no progress on the last budget; ${holds}`;
     case "cost_cap":
-      return decision.renewalsLeft > 0 ? `${decision.detail}; ${holds} unspent` : decision.detail;
+      return idleRecourse(decision.renewalsLeft > 0 ? `${decision.detail}; ${holds} unspent` : decision.detail);
     case "grant_exhausted":
     case "unfit":
-      return decision.detail;
+      return idleRecourse(decision.detail);
   }
 }