@coreplane/switchboard 1.242.0 → 1.244.0

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

@@ -30,12 +30,25 @@
 // arrive in the input rather than from the agent registry.
 
 import type { ShipRoundOutcome } from "../runEvents.js";
+import type { Handoff } from "./handoff.js";
+import { progressOf, renderRenewal, renewalDecision, type PushedHeadFact, type RenewalDecision } from "./renewal.js";
 import type { RunStatus } from "../runRecord.js";
 import { normalizeHead, sameCommit } from "../reviewedHead.js";
 import { formatFinding, type Finding, type FindingDisposition, type ReviewVerdictKind } from "../reviewVerdict.js";
 import { parsePlanUnit, planUnitIds } from "./contract.js";
-
-const MIN = 60_000;
+import {
+  carve,
+  DEFAULT_GRANT,
+  loopPosition,
+  MINUTE_MS,
+  SHIP_WAIT,
+  type Carve,
+  type Grant,
+  type GrantSource,
+  type Loop,
+} from "../budgets.js";
+
+const MIN = MINUTE_MS;
 
 /** What a pipeline runs under: the rounds cap from the `ship` config block, and
  *  the wall clock from the parent's EFFECTIVE profile — the ship preset's
@@ -45,34 +58,10 @@ export interface ShipCaps {
   maxMinutes: number;
 }
 
-/** A round is dispatched only when at least this much of the pipeline budget
- *  remains (the reservation check, agent-ship item 8): a child clipped below
- *  this cannot do useful work, so the pipeline reports the cap instead of
- *  burning an attach and a model turn on a doomed round. */
-export const SHIP_ROUND_RESERVE_MS = 3 * MIN;
-
-/** What a round-0 coding child must leave on the pipeline's clock: two review
- *  rounds (a review and, after a fix, its re-review) and one merge poll — the
- *  loop the pipeline exists to run. The coding child's budget is clipped to
- *  the remaining wall clock MINUS this reserve (never under the two minutes a
- *  spawn accepts), so a child that uses its whole directive still hands the
- *  pipeline a clock that holds the review; without the clip a 40-minute
- *  pipeline hands 39 minutes to the child and caps out with the pull request
- *  shipped and unreviewed. */
-export const SHIP_LOOP_RESERVE_MS = 2 * SHIP_ROUND_RESERVE_MS + 5 * MIN;
-
-/** What a findings child (the fix after a review asked for changes) must leave
- *  on the clock: the re-review and one merge poll — one round's reserve and
- *  five minutes. Never the whole loop's: by the time a fix round runs, the
- *  first review has already happened, and holding two rounds back from a late
- *  fix would cap a pipeline that still has the time. */
-export const SHIP_FIX_RESERVE_MS = SHIP_ROUND_RESERVE_MS + 5 * MIN;
-
-/** The floor `validateShip` holds `ship.maxMinutes` to: the loop's reserve
- *  plus one round's — under it no coding child can both work and leave the
- *  review its time, so the config is refused at load rather than left to cap
- *  out on every unit. */
-export const SHIP_MIN_MAX_MINUTES = (SHIP_LOOP_RESERVE_MS + SHIP_ROUND_RESERVE_MS) / MIN;
+/** A round's minutes come from `carve` in `src/core/budgets.ts` (agent-ship
+ *  item 8, decision 0046): the remainder minus the reserve derived over the
+ *  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,
@@ -414,7 +403,14 @@ export function presetOf(kind: RoundKind): ChildPreset {
  *  turn: the unit's contract, or the review turn from the pull request and the
  *  prior rounds' records, or the findings message from the review run's verdict. */
 export type Brief =
-  | { kind: "contract"; unit: string; rebase: { branch: string; onto: string } }
+  | {
+      kind: "contract";
+      unit: string;
+      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 };
+    }
   | {
       kind: "review";
       unit: string;
@@ -478,6 +474,13 @@ export type ChildFacts =
       /** The dispositions a coding run recorded, as it submitted them: the machine matches them to the round's findings. */
       dispositions?: FindingDisposition[];
       handoff?: boolean;
+      /** The renewal's facts (decision 0046): the heads the run pushed, when
+       *  its lease began, what it cost (null when a model had no price) and
+       *  the handoff's lists — progress is read off these, never asked. */
+      pushed?: PushedHeadFact[];
+      leaseStartedAt?: number;
+      costUsd?: number | null;
+      handoffLists?: Handoff;
     };
 
 /** What heads the unit's branch on GitHub: nothing, an open pull request, or —
@@ -525,7 +528,14 @@ export type UnitEnding =
   | { kind: "merge_ready"; pr: PrRef; reviewRounds: number }
   | { kind: "merge_refused"; pr: PrRef; reason: string; reviewRounds: number }
   | { kind: "round_cap"; maxRounds: number; reviewRounds: number }
-  | { kind: "wall_clock_cap"; remainingMs: number; reviewRounds: number; spent: ShipBudgetSpent }
+  | {
+      kind: "wall_clock_cap";
+      remainingMs: number;
+      reviewRounds: number;
+      spent: ShipBudgetSpent;
+      /** The round the remainder could not hold: what it would have got and the floor it fell under. */
+      refused?: { round: RoundKind; minutes: number; floor: number };
+    }
   /** The wall clock capped AFTER the coding child opened or updated the pull
    *  request: the work stands and only the review is missing, so the ending
    *  names the pull request and "review pending" instead of calling the unit a
@@ -540,7 +550,38 @@ export type UnitEnding =
       /** A changes-requested review posted this round before the stop. */
       postedReview?: boolean;
     }
-  | { kind: "aborted"; reason: string; round?: RoundRef; reviewRounds: number; finalReply?: string }
+  | {
+      kind: "aborted";
+      reason: string;
+      round?: RoundRef;
+      reviewRounds: number;
+      finalReply?: string;
+      /** A round-0 end without a pull request that was judged for renewal and
+       *  refused: the decision and the card's sentence (decision 0046). */
+      renewal?: { decision: Extract<RenewalDecision, { renew: false }>; line: string };
+    }
+  /** The coding round ended at its lease with the unit unfinished, the row
+   *  showed progress and the grant renewed: this segment is over and the next
+   *  opens in the same thread from `from` under a fresh lease, the coding
+   *  child's write-up as its request (decision 0046, Renewal). */
+  | {
+      kind: "continued";
+      round: RoundRef;
+      /** The coding child whose write-up and handoff the continuation is briefed with. */
+      runId: string;
+      /** The segment the renewal opens (the first segment is 1). */
+      segment: number;
+      from?: string;
+      renewalsLeft: number;
+      /** The session's spend so far, this segment's children included; null when a run's model had no price. */
+      spendUsd: number | null;
+      handoff?: Handoff;
+      /** The coding child's write-up: the checkpoint the continuation is briefed with. */
+      finalReply?: string;
+      line: string;
+      reviewRounds: number;
+      spent: ShipBudgetSpent;
+    }
   | { kind: "no_verdict"; round: RoundRef; reviewRounds: number; finalReply?: string }
   | { kind: "interrupted"; round: RoundRef; runId: string; reviewRounds: number }
   | { kind: "refused"; refusal: string; message?: string; round: RoundRef; reviewRounds: number };
@@ -578,15 +619,22 @@ export function findingsAtOrAbove(findings: readonly Finding[], level: AddressSe
   return findings.filter((f) => severityRank(f.severity) <= severityRank(level));
 }
 
+export interface UnitSession {
+  segment: number;
+  renewalsSpent: number;
+  spendUsd: number | null;
+  continueFrom?: string;
+  /** The previous segment's coding run: its write-up and handoff brief the continuation. */
+  previousRunId?: string;
+  previousHandoff?: Handoff;
+}
+
 export interface UnitPipelineInput {
   unit: { id: string; branch: string };
   repo: string;
   /** The pull request's base — the branch the unit is created from and rebased onto. */
   base: string;
   caps: ShipCaps;
-  /** Each child preset's own wall-clock budget (its `maxMinutes`), the number a
-   *  round's budget is clipped from — supplied by the bot, which holds the registry. */
-  childMinutes: Readonly<Record<ChildPreset, number>>;
   /** Who merges: the instance's `merge` field as the plan route answers it —
    *  `runner` (a seeded plan, under its grant) or `person` (a task, or a
    *  record without the field). */
@@ -597,6 +645,18 @@ export interface UnitPipelineInput {
   addressSeverity?: AddressSeverity;
   /** Which layer set the level in force; named in the round header and the ending. */
   addressSeveritySource?: AddressSeveritySource;
+  /** The grant the request carried (decision 0046, the renewable lease):
+   *  renewals and a cost cap, and which layer granted it — named in the report;
+   *  absent reads as zero renewals and no cap, the org's. Nothing here spends
+   *  it yet: the renewal decision is the segment's end, not this unit's. */
+  grant?: Grant;
+  grantSource?: GrantSource;
+  /** The segment this pipeline runs (decision 0046, Renewal): absent for the
+   *  first; a renewal's carries its number, the renewals spent before it, the
+   *  session's spend so far, the sha it continues from and the previous
+   *  segment's handoff. Every step name of a later segment is prefixed with
+   *  it, so the Workflow's durable steps never collide across segments. */
+  session?: UnitSession;
   /** The instance's mark (agent-ship item 16): a generated one-unit plan — a
    *  `plan` with an id and no `path` — whose unit runs in the requesting
    *  thread and is re-issued with the request's own text, never a plan path. */
@@ -614,7 +674,7 @@ 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: "spawn"; round: RoundRef; busy: number; minutes: number; holds: number }
   | { at: "busy-wait"; round: RoundRef; runId?: string; n: number }
   /** `until`: when the child's budget plus the margin runs out, counted from the spawn's answer — the wait's last slice ends there. */
   | { at: "wait"; round: RoundRef; runId: string; n: number; until: number }
@@ -625,13 +685,17 @@ type Phase =
       runId: string;
       childHead?: string;
       finalReply?: string;
+      /** The renewal's facts off the child's record (decision 0046): its pushed heads, its lease's start, its handoff. */
+      childPushed?: PushedHeadFact[];
+      childLeaseStartedAt?: number;
+      childHandoff?: Handoff;
       /** The coding child died (`failed` or `interrupted`) after it may have
        *  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";
     }
-  | { at: "merge"; pr: PrRef; headSha: string; n: number; since: number }
-  | { at: "merge-wait"; pr: PrRef; headSha: string; n: number; since: number }
+  | { at: "merge"; pr: PrRef; headSha: string; n: number; since: number; waitMs: number }
+  | { at: "merge-wait"; pr: PrRef; headSha: string; n: number; since: number; waitMs: number }
   | { at: "ended" };
 
 export interface UnitPipelineState {
@@ -658,11 +722,14 @@ export interface UnitPipelineState {
   readonly lastCodingRunId?: string;
   /** How the budget went so far, accrued as each answer moves the clock. */
   readonly spentMs: ShipBudgetSpent;
+  /** The session's dollars so far: the input's from earlier segments plus each
+   *  child's cost as its record is read; null once any run's cost is unknown. */
+  readonly spendUsd: number | null;
   readonly ending?: UnitEnding;
 }
 
 /** Past a child's budget, the parent asks the bot instead of waiting on. */
-export const WAIT_MARGIN_MS = 5 * MIN;
+export const WAIT_MARGIN_MS = SHIP_WAIT.marginMinutes * MIN;
 /** One slice of a wait on a child. The child's budget plus the margin is
  *  walked in chunks with a `read-record` between them, so an event the engine
  *  never delivered — refused, lost, sent to an instance that had ended — costs
@@ -670,19 +737,18 @@ export const WAIT_MARGIN_MS = 5 * MIN;
  *  is the machine's one cadence for asking the bot what it cannot be told (the
  *  margin and the merge poll are the same number), and it keeps a round to a
  *  few steps: a coding child's 45 minutes are ten waits and ten reads. */
-export const WAIT_CHUNK_MS = 5 * MIN;
-/** How long the merge step waits for the guards at most. While checks are
- *  pending the machine waits on the intake's `checks-settled-<head>` event
- *  (http-ingress.md item 12) — one bounded wait per ask, the remainder of this
- *  cap, as the fallback when the event never arrives. */
-export const MERGE_WAIT_MAX_MS = 60 * MIN;
+export const WAIT_CHUNK_MS = SHIP_WAIT.chunkMinutes * MIN;
+/** The merge wait is a round of its own: its minutes are carved from the
+ *  pipeline's remainder when the door is first asked (the merge wait's ask and
+ *  floor are rows of `src/core/budgets.ts`), and the wait below is sliced
+ *  from that carve. */
 /** One merge wait's fallback timeout: the old poll's cadence. The event wakes
  *  the machine at once when the intake delivers it; without one (the webhook
  *  not configured, a delivery lost) the door is still re-asked every chunk, so
  *  a merge is never slower than the poll it replaced. */
-export const MERGE_WAIT_CHUNK_MS = 5 * MIN;
+export const MERGE_WAIT_CHUNK_MS = SHIP_WAIT.mergeChunkMinutes * MIN;
 /** A `busy` without the live run's id: nothing to wait on, so a short sleep before the spawn is asked again. */
-export const BUSY_RETRY_MS = 2 * MIN;
+export const BUSY_RETRY_MS = SHIP_WAIT.busyRetryMinutes * MIN;
 
 // ---- the unit pipeline: opening and the next action -----------------------------------------------
 
@@ -694,6 +760,7 @@ export function openUnitPipeline(input: UnitPipelineInput, at: number): UnitPipe
     phase: { at: "pre-check" },
     reviewRounds: 0,
     spentMs: { coding: 0, review: 0, waiting: 0 },
+    spendUsd: input.session?.spendUsd ?? 0,
     findingsByRound: {},
     dispositionsByRound: {},
     reviewRunByRound: {},
@@ -721,36 +788,45 @@ function waitSliceMs(clock: number, until: number): number {
   return remaining > 0 ? Math.min(WAIT_CHUNK_MS, remaining) : WAIT_CHUNK_MS;
 }
 
-/** The child's budget: its preset's own, clipped to the pipeline's remaining
- *  wall clock (agent-ship item 8's clip), never under the two minutes a
- *  spawn accepts. */
-function budgetMinutesFor(s: UnitPipelineState, round: RoundRef): number {
-  const headroom = remainingMs(s) - reserveFor(round.kind);
-  return Math.max(2, Math.min(s.input.childMinutes[presetOf(round.kind)], Math.floor(headroom / MIN)));
-}
+/** The pipeline's loop as the config allows it. */
+const loopOf = (s: UnitPipelineState): Loop => ({ maxRounds: s.input.caps.maxRounds });
 
-/** What a child of each round kind leaves on the pipeline's clock: round 0's
- *  coding child the whole loop (two reviews and the merge poll,
- *  SHIP_LOOP_RESERVE_MS), a findings child the re-review and the merge poll
- *  (SHIP_FIX_RESERVE_MS), a review child nothing — the review is what the
- *  reserve was held for. */
-function reserveFor(kind: RoundKind): number {
-  switch (kind) {
-    case "coding":
-      return SHIP_LOOP_RESERVE_MS;
-    case "findings":
-      return SHIP_FIX_RESERVE_MS;
-    case "review":
-      return 0;
-  }
+/** A round's carve (agent-ship item 8): the remainder minus the reserve for
+ *  the rounds after it, capped at its preset's ask, refused under its floor.
+ *  A review round `n` and the findings step that follows it share `n`; the
+ *  module's positions are the loop's own. */
+function roundCarve(s: UnitPipelineState, round: RoundRef): Carve {
+  const kind = round.kind === "findings" ? "fix" : round.kind;
+  return carve(remainingMs(s), { kind, index: loopPosition(loopOf(s), kind, round.index) }, loopOf(s));
 }
 
-const roundStep = (s: UnitPipelineState, round: RoundRef) => `${s.input.unit.id}/${round.index}/${round.kind}`;
+/** 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: UnitSession | undefined): string =>
+  session !== undefined && session.segment > 1 ? `${unit}/s${session.segment}` : unit;
+const stepPrefix = (s: UnitPipelineState) => stepPrefixOf(s.input.unit.id, s.input.session);
+const roundStep = (s: UnitPipelineState, round: RoundRef) => `${stepPrefix(s)}/${round.index}/${round.kind}`;
 
 function briefFor(s: UnitPipelineState, round: RoundRef): Brief {
   const unit = s.input.unit.id;
-  if (round.kind === "coding")
-    return { kind: "contract", unit, rebase: { branch: s.input.unit.branch, onto: s.input.base } };
+  if (round.kind === "coding") {
+    const session = s.input.session;
+    return {
+      kind: "contract",
+      unit,
+      rebase: { branch: s.input.unit.branch, onto: s.input.base },
+      ...(session !== undefined && session.segment > 1
+        ? {
+            continue: {
+              segment: session.segment,
+              ...(session.continueFrom !== undefined ? { from: session.continueFrom } : {}),
+              ...(session.previousRunId !== undefined ? { previousRunId: session.previousRunId } : {}),
+            },
+          }
+        : {}),
+    };
+  }
   const pr = s.pr!.number;
   if (round.kind === "findings") return { kind: "findings", unit, pr, reviewRunId: s.reviewRunByRound[round.index]! };
   const priorReview = s.reviewRunByRound[round.index - 1];
@@ -786,7 +862,7 @@ export function matchDispositions(
 /** The step the machine is at. Pure over the state: asked before every step
  *  and again after a replay, it names the same step for the same state. */
 export function nextAction(s: UnitPipelineState): CoordinatorAction {
-  const unit = s.input.unit.id;
+  const unit = stepPrefix(s);
   const p = s.phase;
   switch (p.at) {
     case "pre-check":
@@ -800,7 +876,7 @@ export function nextAction(s: UnitPipelineState): CoordinatorAction {
         step: roundStep(s, p.round),
         preset,
         round: p.round,
-        budgetMinutes: budgetMinutesFor(s, p.round),
+        budgetMinutes: p.minutes,
         brief: briefFor(s, p.round),
       };
     }
@@ -831,7 +907,7 @@ export function nextAction(s: UnitPipelineState): CoordinatorAction {
         type: "wait-checks",
         step: `${unit}/merge/wait/${p.n}`,
         headSha: p.headSha,
-        timeoutMs: Math.max(MIN, Math.min(MERGE_WAIT_CHUNK_MS, MERGE_WAIT_MAX_MS - (s.clock - p.since))),
+        timeoutMs: Math.max(MIN, Math.min(MERGE_WAIT_CHUNK_MS, p.waitMs - (s.clock - p.since))),
       };
     case "ended":
       return { type: "end", step: `${unit}/end`, ending: s.ending! };
@@ -847,6 +923,14 @@ interface Transition {
 
 const ENDED: Phase = { at: "ended" };
 
+/** The session's dollars after one more child: unknown (null) once any run's
+ *  cost is — a total that left a run out would understate the spend a cap
+ *  judges — and a record without the field counts as unknown too. */
+function addSpend(sum: number | null, cost: number | null | undefined): number | null {
+  if (sum === null || cost === null || cost === undefined) return null;
+  return sum + cost;
+}
+
 function end(s: UnitPipelineState, ending: UnitEnding, notes: CoordinatorNote[] = []): Transition {
   return { state: { ...s, phase: ENDED, ending }, notes: [...notes, { type: "ended", ending }] };
 }
@@ -861,7 +945,7 @@ const roundNote = (round: RoundRef, outcome: ShipRoundOutcome): CoordinatorNote
 /** The cap's ending: `review_pending` when the clock ran out entering a
  *  review round with the child's pull request standing — the work shipped and
  *  only the review is missing — else the wall-clock cap. Both carry the split. */
-function capEnding(s: UnitPipelineState, round?: RoundRef): UnitEnding {
+function capEnding(s: UnitPipelineState, round?: RoundRef, refused?: Carve): UnitEnding {
   if (round?.kind === "review" && s.pr !== undefined)
     return {
       kind: "review_pending",
@@ -870,16 +954,28 @@ function capEnding(s: UnitPipelineState, round?: RoundRef): UnitEnding {
       reviewRounds: s.reviewRounds,
       spent: s.spentMs,
     };
-  return { kind: "wall_clock_cap", remainingMs: remainingMs(s), reviewRounds: s.reviewRounds, spent: s.spentMs };
+  return {
+    kind: "wall_clock_cap",
+    remainingMs: remainingMs(s),
+    reviewRounds: s.reviewRounds,
+    spent: s.spentMs,
+    ...(round !== undefined && refused?.kind === "refused"
+      ? { refused: { round: round.kind, minutes: refused.minutes, floor: refused.floor } }
+      : {}),
+  };
 }
 
-/** Start a round if the reservation holds (agent-ship item 8's check: a
- *  child clipped under the reserve cannot do useful work). */
+/** Start a round if its carve holds (agent-ship item 8): a round the
+ *  remainder cannot carve above its floor is not dispatched, and the unit ends
+ *  at the cap naming the round, what it would have got and the floor. */
 function enterRound(s: UnitPipelineState, round: RoundRef, notes: CoordinatorNote[] = []): Transition {
-  const remaining = remainingMs(s);
-  if (remaining < SHIP_ROUND_RESERVE_MS) return end(s, capEnding(s, round), notes);
+  const carved = roundCarve(s, round);
+  if (carved.kind === "refused") return end(s, capEnding(s, round, carved), notes);
   const reviewRounds = round.kind === "review" ? round.index : s.reviewRounds;
-  return { state: { ...s, reviewRounds, phase: { at: "spawn", round, busy: 0 } }, notes };
+  return {
+    state: { ...s, reviewRounds, phase: { at: "spawn", round, busy: 0, minutes: carved.minutes, holds: carved.holds } },
+    notes,
+  };
 }
 
 /** The next review round, or the round cap. */
@@ -905,6 +1001,7 @@ function settleCoding(
   // round's findings enter the state (agent-ship item 6).
   let next: UnitPipelineState = {
     ...s,
+    spendUsd: addSpend(s.spendUsd, facts.costUsd),
     ...(facts.pr !== undefined ? { pr: { number: facts.pr.number, url: facts.pr.url } } : {}),
     ...(round.kind === "findings" && facts.dispositions !== undefined
       ? {
@@ -942,6 +1039,9 @@ function settleCoding(
       runId,
       ...(facts.headSha !== undefined ? { childHead: facts.headSha } : {}),
       ...(facts.finalReply !== undefined ? { finalReply: facts.finalReply } : {}),
+      ...(facts.pushed !== undefined ? { childPushed: facts.pushed } : {}),
+      ...(facts.leaseStartedAt !== undefined ? { childLeaseStartedAt: facts.leaseStartedAt } : {}),
+      ...(facts.handoffLists !== undefined ? { childHandoff: facts.handoffLists } : {}),
     },
   };
   return { state: next, notes: [] };
@@ -981,6 +1081,7 @@ function settleReview(
   const verdict = facts.verdict;
   const next: UnitPipelineState = {
     ...s,
+    spendUsd: addSpend(s.spendUsd, facts.costUsd),
     findingsByRound: { ...s.findingsByRound, [round.index]: verdict.findings },
     ...(facts.reviewHead !== undefined ? { lastReviewHead: facts.reviewHead } : {}),
     ...(verdict.summary !== undefined ? { lastVerdictSummary: verdict.summary } : {}),
@@ -1042,7 +1143,26 @@ function settleReview(
         { kind: "merge_refused", pr, reason: "no approved head is known to merge at", reviewRounds: next.reviewRounds },
         notes,
       );
-    return { state: { ...next, phase: { at: "merge", pr, headSha, n: 1, since: next.clock } }, notes };
+    const mergeWait = carve(
+      remainingMs(next),
+      { kind: "merge", index: loopPosition(loopOf(next), "merge") },
+      loopOf(next),
+    );
+    if (mergeWait.kind === "refused")
+      return end(
+        next,
+        {
+          kind: "merge_refused",
+          pr,
+          reason: `the remaining ${mergeWait.minutes} minutes of the pipeline are under the merge wait's floor of ${mergeWait.floor}`,
+          reviewRounds: next.reviewRounds,
+        },
+        notes,
+      );
+    return {
+      state: { ...next, phase: { at: "merge", pr, headSha, n: 1, since: next.clock, waitMs: mergeWait.minutes * MIN } },
+      notes,
+    };
   }
   // request_changes: the verdict settled (and posted) — now a stop
   // short-circuits the findings step, naming the review standing on the pull request.
@@ -1123,15 +1243,72 @@ function settlePrCheck(s: UnitPipelineState, phase: Extract<Phase, { at: "pr-che
         [roundNote(round, "aborted")],
       );
     }
-    const reason =
-      round.index === 0
-        ? `⚠️ Ship ended at round 0: the coding round ended without opening a pull request (a clarifying question, a budget write-up, an unproven push or a description-less push ends the pipeline here). No review round ran.`
-        : `⚠️ Round ${round.index}'s findings step left no open pull request heading \`${s.input.unit.branch}\` — the pull request was closed out from under the pipeline and none was reopened, so there is nothing to re-review.`;
+    // Round 0 ended without a pull request: the segment is over with the unit
+    // unfinished, and the grant decides whether the next opens (decision
+    // 0046, Renewal). Progress is read off the child's record — a head pushed
+    // to the unit's branch since the segment started, or a handoff that moved —
+    // never off its words; the decision then asks the grant's count, the cap
+    // and the fit, in that order, and a refusal names the clause. A plain
+    // abort keeps its old shape when nothing was pushed under a grant of zero:
+    // a clarifying question is not a stop to explain.
+    if (round.index === 0) {
+      const grant = s.input.grant ?? DEFAULT_GRANT;
+      const session = s.input.session;
+      const progress = progressOf({
+        branch: s.input.unit.branch,
+        pushed: phase.childPushed ?? [],
+        ...(session?.continueFrom !== undefined ? { startHead: session.continueFrom } : {}),
+        ...(phase.childLeaseStartedAt !== undefined ? { leaseStartedAt: phase.childLeaseStartedAt } : {}),
+        ...(session?.previousHandoff !== undefined && phase.childHandoff !== undefined
+          ? { handoff: { previous: session.previousHandoff, current: phase.childHandoff } }
+          : {}),
+      });
+      const decision = renewalDecision({
+        grant,
+        renewalsSpent: session?.renewalsSpent ?? 0,
+        spendUsd: s.spendUsd,
+        progress,
+        pipeline: s.input.caps,
+      });
+      const line = renderRenewal(decision, grant);
+      if (decision.renew)
+        return end(
+          s,
+          {
+            kind: "continued",
+            round,
+            runId: phase.runId,
+            segment: decision.segment,
+            ...(decision.from !== undefined ? { from: decision.from } : {}),
+            renewalsLeft: decision.renewalsLeft,
+            spendUsd: s.spendUsd,
+            ...(phase.childHandoff !== undefined ? { handoff: phase.childHandoff } : {}),
+            ...(phase.finalReply !== undefined ? { finalReply: phase.finalReply } : {}),
+            line,
+            reviewRounds: s.reviewRounds,
+            spent: s.spentMs,
+          },
+          [roundNote(round, "continued")],
+        );
+      const judged = grant.renewals > 0 || progress.progressed;
+      return end(
+        s,
+        {
+          kind: "aborted",
+          reason: `⚠️ Ship ended at round 0: the coding round ended without opening a pull request (a clarifying question, a budget write-up, an unproven push or a description-less push ends the pipeline here). No review round ran.`,
+          round,
+          reviewRounds: s.reviewRounds,
+          ...(phase.finalReply !== undefined ? { finalReply: phase.finalReply } : {}),
+          ...(judged ? { renewal: { decision, line } } : {}),
+        },
+        [roundNote(round, "aborted")],
+      );
+    }
     return end(
       s,
       {
         kind: "aborted",
-        reason,
+        reason: `⚠️ Round ${round.index}'s findings step left no open pull request heading \`${s.input.unit.branch}\` — the pull request was closed out from under the pipeline and none was reopened, so there is nothing to re-review.`,
         round,
         reviewRounds: s.reviewRounds,
         ...(phase.finalReply !== undefined ? { finalReply: phase.finalReply } : {}),
@@ -1252,7 +1429,7 @@ export function applyReturn(s: UnitPipelineState, ret: StepReturn): Transition {
         case "spawned":
         case "alreadySpawned": {
           // The child's budget runs from the spawn's answer; the wait walks it, plus the margin, in chunks.
-          const until = clocked.clock + budgetMinutesFor(s, p.round) * MIN + WAIT_MARGIN_MS;
+          const until = clocked.clock + p.minutes * MIN + WAIT_MARGIN_MS;
           const runs =
             p.round.kind === "review"
               ? { reviewRunByRound: { ...s.reviewRunByRound, [p.round.index]: r.runId } }
@@ -1270,7 +1447,8 @@ export function applyReturn(s: UnitPipelineState, ret: StepReturn): Transition {
         case "busy": {
           // Another run holds the unit's thread: wait for its end, then ask
           // again — unless the pipeline's wall clock ran out meanwhile.
-          if (remainingMs(clocked) < SHIP_ROUND_RESERVE_MS) return end(clocked, capEnding(clocked, p.round));
+          const recarved = roundCarve(clocked, p.round);
+          if (recarved.kind === "refused") return end(clocked, capEnding(clocked, p.round, recarved));
           return {
             state: {
               ...clocked,
@@ -1302,8 +1480,19 @@ export function applyReturn(s: UnitPipelineState, ret: StepReturn): Transition {
       }
       break;
     }
-    case "busy-wait":
-      return { state: { ...s, phase: { at: "spawn", round: p.round, busy: p.n } }, notes: [] };
+    case "busy-wait": {
+      // The clock moved while the spawn was busy: the round is carved again
+      // from what remains, and a carve now under the floor ends at the cap.
+      const carved = roundCarve(s, p.round);
+      if (carved.kind === "refused") return end(s, capEnding(s, p.round, carved));
+      return {
+        state: {
+          ...s,
+          phase: { at: "spawn", round: p.round, busy: p.n, minutes: carved.minutes, holds: carved.holds },
+        },
+        notes: [],
+      };
+    }
     case "wait":
       return {
         state: { ...s, phase: { at: "read", round: p.round, runId: p.runId, n: p.n, until: p.until } },
@@ -1356,7 +1545,7 @@ export function applyReturn(s: UnitPipelineState, ret: StepReturn): Transition {
       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;
-      if (waited >= MERGE_WAIT_MAX_MS)
+      if (waited >= p.waitMs)
         return end(clocked, {
           kind: "merge_refused",
           pr: p.pr,
@@ -1364,13 +1553,19 @@ export function applyReturn(s: UnitPipelineState, ret: StepReturn): Transition {
           reviewRounds: s.reviewRounds,
         });
       return {
-        state: { ...clocked, phase: { at: "merge-wait", pr: p.pr, headSha: p.headSha, n: p.n, since: p.since } },
+        state: {
+          ...clocked,
+          phase: { at: "merge-wait", pr: p.pr, headSha: p.headSha, n: p.n, since: p.since, waitMs: p.waitMs },
+        },
         notes: [],
       };
     }
     case "merge-wait":
       return {
-        state: { ...s, phase: { at: "merge", pr: p.pr, headSha: p.headSha, n: p.n + 1, since: p.since } },
+        state: {
+          ...s,
+          phase: { at: "merge", pr: p.pr, headSha: p.headSha, n: p.n + 1, since: p.since, waitMs: p.waitMs },
+        },
         notes: [],
       };
     case "ended":
@@ -1458,6 +1653,12 @@ export function renderUnitReport(s: UnitPipelineState, facts?: MergeReadyFacts):
   // stated decision, never a silent one.
   const level = s.input.addressSeverity ?? DEFAULT_ADDRESS_SEVERITY;
   const levelLine = `Severity addressed: ${level} and above (set by ${s.input.addressSeveritySource ?? "org"}).`;
+  // The grant as the instance carries it (decision 0046): spent of granted,
+  // the cap when one is set, and who granted it — zero of zero until a scope
+  // or a directive says otherwise, and nothing spends it before the renewal
+  // decision exists.
+  const grant = s.input.grant ?? DEFAULT_GRANT;
+  const grantLine = `Renewals: 0 of ${grant.renewals} spent${grant.costCapUsd !== undefined ? `, cost cap $${grant.costCapUsd}` : ""} (granted by ${s.input.grantSource ?? "org"}).`;
   const lastFindings = s.findingsByRound[e.reviewRounds] ?? [];
   const skipped = lastFindings.filter((f) => !findingsAtOrAbove([f], level).length);
   const skippedLine =
@@ -1473,6 +1674,7 @@ export function renderUnitReport(s: UnitPipelineState, facts?: MergeReadyFacts):
         `✅ 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,
         levelLine,
+        grantLine,
         ...(skippedLine ? [skippedLine] : []),
         declinedLine,
       ].join("\n");
@@ -1481,6 +1683,7 @@ export function renderUnitReport(s: UnitPipelineState, facts?: MergeReadyFacts):
         `✅ Merge-ready after ${rounds}: ${e.pr.url}`,
         verdictLine,
         levelLine,
+        grantLine,
         ...(skippedLine ? [skippedLine] : []),
         declinedLine,
         // What the driver read at the approved head when it composed this
@@ -1505,7 +1708,7 @@ export function renderUnitReport(s: UnitPipelineState, facts?: MergeReadyFacts):
       ]);
     case "wall_clock_cap":
       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 — no approval after ${rounds}.${prLine}`,
+        `🧢 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}`,
         budgetSplitLine(e.spent, s.input.caps.maxMinutes),
         splitReport(s),
         reissue,
@@ -1526,7 +1729,19 @@ export function renderUnitReport(s: UnitPipelineState, facts?: MergeReadyFacts):
         reissue,
       ]);
     case "aborted":
-      return join([e.finalReply, e.reason, `⚠️ Ship aborted after ${rounds}.`, reissue]);
+      return join([
+        e.finalReply,
+        e.reason,
+        e.renewal !== undefined ? `🔁 Not renewed: ${e.renewal.line}.` : undefined,
+        `⚠️ Ship aborted after ${rounds}.`,
+        reissue,
+      ]);
+    case "continued":
+      return join([
+        e.finalReply,
+        `🔁 Segment ${e.segment - 1} ended at its lease with the unit unfinished — ${e.line}. Segment ${e.segment} opens in this thread${e.from !== undefined ? ` from \`${e.from.slice(0, 7)}\`` : ""} under a fresh ${s.input.caps.maxMinutes}-minute lease, with this segment's write-up as its request; ${e.renewalsLeft} renewal${e.renewalsLeft === 1 ? "" : "s"} remain${e.spendUsd !== null ? `, $${e.spendUsd.toFixed(2)} spent so far` : ""}.`,
+        budgetSplitLine(e.spent, s.input.caps.maxMinutes),
+      ]);
     case "no_verdict":
       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.`,