@coreplane/switchboard 1.245.0 → 1.247.0

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

@@ -247,14 +247,146 @@ export function formatDisposition(d: FindingDisposition): string {
   return `${d.findingId}: ${d.disposition}${d.note ? ` — ${d.note}` : ""}`;
 }
 
+/** Where the posted body's file links point: the PR's repository and the
+ *  head the review is pinned to (the post-step's `commitId`). */
+export interface ReviewBodyTarget {
+  /** `owner/name` */
+  repo: string;
+  /** The pinned head, full sha. */
+  head: string;
+}
+
+/** The verdict word the callout carries, per verdict kind (or its absence). */
+function verdictWord(verdict: ReviewVerdict | undefined): string {
+  if (!verdict) return "No verdict";
+  return verdict.verdict === "approve" ? "Approved" : "Changes requested";
+}
+
+/** GitHub's alert callout kind per verdict: an approve is a note, changes
+ *  requested a warning, a missing verdict a caution. */
+function calloutKind(verdict: ReviewVerdict | undefined): "NOTE" | "WARNING" | "CAUTION" {
+  if (!verdict) return "CAUTION";
+  return verdict.verdict === "approve" ? "NOTE" : "WARNING";
+}
+
+/** `2 findings: 1 minor, 1 nit` — counted on the ladder, most severe first;
+ *  an empty array is `no findings`, no array `findings not itemized`. */
+function findingCounts(findings: readonly Finding[] | undefined): string {
+  if (findings === undefined) return "findings not itemized";
+  if (findings.length === 0) return "no findings";
+  const by = FINDING_SEVERITIES.map((sev) => [sev, findings.filter((f) => f.severity === sev).length] as const)
+    .filter(([, n]) => n > 0)
+    .map(([sev, n]) => `${n} ${sev}`)
+    .join(", ");
+  return `${findings.length} finding${findings.length === 1 ? "" : "s"}: ${by}`;
+}
+
+/** A table cell: pipes escaped so the row holds, already one line. */
+const cell = (text: string): string => oneLine(text).replace(/\|/g, "\\|");
+
+/** Whether a finding's `file` is a path a blob URL can point at: no
+ *  whitespace, no backtick, not a URL. */
+const isRepoPath = (file: string): boolean => /^[^\s`]+$/.test(file) && !/^[a-z][a-z0-9+.-]*:\/\//i.test(file);
+
+/** The `Where` cell: the location in code, linked at the pinned head when the
+ *  file is a path and a target is known. */
+function whereCell(f: Finding, target: ReviewBodyTarget | undefined): string {
+  const location = f.line !== undefined ? `${f.file}:${f.line}` : f.file;
+  const label = `\`${cell(location)}\``;
+  if (!target || !isRepoPath(f.file)) return label;
+  const path = encodeURI(f.file).replace(/#/g, "%23").replace(/\?/g, "%3F");
+  const url = `https://github.com/${target.repo}/blob/${target.head}/${path}${f.line !== undefined ? `#L${f.line}` : ""}`;
+  return `[${label}](${url})`;
+}
+
+/** The machine-readable marker the body ends with — the verdict, the head and
+ *  the findings index as JSON inside an HTML comment, for a scanner that would
+ *  otherwise parse the token line. `-->` can never occur inside it. */
+function verdictMarker(verdict: ReviewVerdict | undefined, target: ReviewBodyTarget | undefined): string {
+  const head = target?.head ?? verdict?.head;
+  const payload = {
+    verdict: verdict?.verdict ?? "none",
+    ...(head ? { head } : {}),
+    ...(verdict?.findings
+      ? {
+          findings: verdict.findings.map((f) => ({
+            id: f.id,
+            severity: f.severity,
+            file: f.file,
+            ...(f.line !== undefined ? { line: f.line } : {}),
+          })),
+        }
+      : {}),
+  };
+  return `<!-- switchboard:verdict ${JSON.stringify(payload).replace(/-->/g, "--\\u003e")} -->`;
+}
+
 /**
- * Build the body posted to GitHub: the deterministic verdict line, the
- * compact findings list (when present), a blank line, then the model's
- * review text. Never starts with "LGTM" unless the verdict is `approve`.
+ * Build the body posted to GitHub, rendered from the typed verdict
+ * (docs/reference/specs/agent-review.md item 5b): the deterministic verdict
+ * line first (the auto-approve contract — never `LGTM:` unless the verdict is
+ * `approve`), a GitHub alert callout with the verdict word, the pinned head
+ * and the finding counts, the findings as a table (severity, id + title, the
+ * file linked at the head), the model's text folded under `Full review`, and
+ * the machine-readable marker last. The prose decides nothing above the fold.
  */
-export function buildReviewPostBody(answer: string, verdict: ReviewVerdict | undefined): string {
-  const head = [verdictLine(verdict), ...(verdict?.findings ?? []).map((f) => `- ${formatFinding(f)}`)];
-  return `${head.join("\n")}\n\n${answer.trim()}`;
+export function buildReviewPostBody(
+  answer: string,
+  verdict: ReviewVerdict | undefined,
+  target?: ReviewBodyTarget,
+): string {
+  const facts = [
+    `**${verdictWord(verdict)}**`,
+    ...(target ? [`head \`${target.head.slice(0, 7)}\``] : []),
+    verdict ? findingCounts(verdict.findings) : "the run ended without a submit_verdict call",
+  ];
+  const parts: string[] = [verdictLine(verdict), `> [!${calloutKind(verdict)}]\n> ${facts.join(" · ")}`];
+  const findings = verdict?.findings ?? [];
+  if (findings.length > 0) {
+    parts.push(
+      [
+        "| Severity | Finding | Where |",
+        "| --- | --- | --- |",
+        ...findings.map((f) => `| ${f.severity} | **${cell(f.id)}** ${cell(f.title)} | ${whereCell(f, target)} |`),
+      ].join("\n"),
+    );
+  }
+  const prose = answer.trim();
+  if (prose) parts.push(`<details>\n<summary>Full review</summary>\n\n${prose}\n\n</details>`);
+  parts.push(verdictMarker(verdict, target));
+  return parts.join("\n\n");
+}
+
+/**
+ * The channel reply for a review run, rendered from the typed verdict
+ * (agent-review.md item 5b): the verdict line, one bullet per finding, then
+ * where the review was posted and the run link. The model's write-up rides
+ * along only when it landed nowhere else — no GitHub post (Slack-only, an
+ * opt-out, a guard refusal) or findings not itemized (a list that says
+ * nothing is no substitute) — so the review's text is always somewhere a
+ * person reads it. No verdict → the bare answer with the link, as before.
+ */
+export function buildReviewChannelReply(input: {
+  answer: string;
+  verdict: ReviewVerdict | undefined;
+  /** The PR the post landed on, or undefined when nothing was posted. */
+  posted: { repo: string; number: number } | undefined;
+  liveUrl: string | undefined;
+}): string {
+  const { answer, verdict, posted, liveUrl } = input;
+  const tail = [
+    ...(posted && verdict ? [`Posted to ${posted.repo}#${posted.number}`] : []),
+    ...(liveUrl ? [`[Live run](${liveUrl})`] : []),
+  ].join(" · ");
+  const blocks: string[] = [];
+  if (!verdict) blocks.push(answer);
+  else {
+    blocks.push([verdictLine(verdict), ...(verdict.findings ?? []).map((f) => `- ${formatFinding(f)}`)].join("\n"));
+    const compact = posted !== undefined && verdict.findings !== undefined;
+    if (!compact && answer.trim()) blocks.push(answer.trim());
+  }
+  if (tail) blocks.push(tail);
+  return blocks.join("\n\n");
 }
 
 // --- Dispositions (the coding side's answer to findings) -------------------

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

@@ -94,6 +94,10 @@ export type RunNoteKind =
   | "sandbox_restarted"
   | "stop_requested"
   | "stopped"
+  /** A stop the loop or turn had to ask pi for again reached it: the series a
+   *  failed abort's write opened (its `harness_error` line) closes here with
+   *  the count of re-asks (harness-pi item 16). Written by the pi harness. */
+  | "stop_landed"
   /** Setup spans the request's stream sink had to drop before this run was
    *  bound (docs/reference/specs/tracing.md): `summary` says how many, `from`/`to` the
    *  interval, which the partition reports as not recorded. */
@@ -142,6 +146,16 @@ export type RunNoteKind =
    *  after the attach, before the first turn, so the run page explains a
    *  sandbox run that shows resident steps. */
   | "cold_sandbox"
+  /** The run ledger would not track this run (docs/reference/specs/run-history.md
+   *  item 54): its reservation met the row of a run this process was closing
+   *  (a restart from its request, or the fresh turn for its follow-ups), waited
+   *  for that finish, and the row still stood — the finish failed or was
+   *  refused — so no handoff, resume or reclaim reaches this run, and its
+   *  record reaches the store when it finishes. The summary names that run and
+   *  how its finish ended; published by the dispatcher right after the
+   *  reservation, before the attach, and carried on the card's label — the bot
+   *  log's warning is not the only witness. */
+  | "ledger_untracked"
   /** The resident kept this thread's binding where it was instead of moving
    *  it onto the branch the thread's own run opened a pull request on
    *  (docs/reference/specs/resident-repos.md item 16): the summary names the
@@ -248,6 +262,7 @@ export const RUN_NOTE_KINDS = [
   "sandbox_restarted",
   "stop_requested",
   "stopped",
+  "stop_landed",
   "spans_dropped",
   "head_moved",
   "run_failed",
@@ -258,6 +273,7 @@ export const RUN_NOTE_KINDS = [
   "description_turn",
   "verdict_turn",
   "cold_sandbox",
+  "ledger_untracked",
   "rebind_refused",
   "work_left_behind",
   "workspace_torn_down",
@@ -373,6 +389,7 @@ export function isHeadMaterial(event: RunEvent): boolean {
         event.kind === "mcp_unavailable" ||
         event.kind === "spans_dropped" ||
         event.kind === "cold_sandbox" ||
+        event.kind === "ledger_untracked" ||
         event.kind === "rebind_refused"
       );
     case "span_start":
@@ -445,7 +462,7 @@ export type RouteInputValue = RouteInputLeafOrList | RouteInputObject3;
  *  `pasted` — the typed line that followed a hand-back in its thread, with the
  *  same receipt, ran. A routed read carries no outcome: it is not a decision
  *  about a state change. */
-export type RouteOutcome = "hand_back" | "offered" | "confirmed" | "pasted";
+export type RouteOutcome = "hand_back" | "offered" | "confirmed" | "pasted" | "refused";
 
 export type RunEvent =
   /** `callId` is the provider's tool_use id — the explicit pair key between a
@@ -794,7 +811,18 @@ export type RunEvent =
    *  round and its fix round share an index. Published by the ship pipeline
    *  straight to the registry (like `pr_opened`), never through the runner.
    *  Additive: unknown → ignored. */
-  | { type: "ship_round"; index: number; agent: string; outcome: ShipRoundOutcome; seq?: number; at?: number }
+  | {
+      type: "ship_round";
+      index: number;
+      agent: string;
+      outcome: ShipRoundOutcome;
+      /** The severity gate fired on this approve (agent-ship item 9): the level
+       *  in force and the gated findings as `id (severity)` — a mismatch the
+       *  child's own parser should have made impossible, kept visible. */
+      gate?: { level: string; findings: string[] };
+      seq?: number;
+      at?: number;
+    }
   /** The request router's decision (docs/reference/specs/routing-and-config.md
    *  item 21): the preset a plain message was routed to, the one-line reason
    *  the router gave (redacted, capped — the same text the card's `routed:`
@@ -836,6 +864,10 @@ export type RunEvent =
       input?: { readonly [key: string]: RouteInputValue };
       receipt?: string;
       outcome?: RouteOutcome;
+      /** The refusal's code (src/core/refusal.ts) when `outcome` is `refused`
+       *  (record 0054): a refusal after a command was bound is a run
+       *  record, and the door report counts it by cause and code. */
+      refusalCode?: string;
       handBackRunId?: string;
       seq?: number;
       at?: number;

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

@@ -291,6 +291,16 @@ export function pushedBranchesOf(events: readonly RunEvent[]): PushedBranch[] {
   return [...byRef].map(([ref, pr]) => ({ ref, pr }));
 }
 
+/** A call a run's ending may have left running in its workspace (harness.md
+ *  item 13): the id the record pairs by, the tool, and the line the
+ *  `workspace_torn_down` note names it by — the `tool_call`'s own summary
+ *  while the record holds it, else the tool and the id. */
+export interface CallInFlight {
+  callId: string;
+  tool: string;
+  summary: string;
+}
+
 /** The tool calls a run's ending may have left running in its workspace, in
  *  the record's order — what the workspace's release reads to tear the
  *  workspace down rather than wait for an idle the command would refuse, and
@@ -299,26 +309,38 @@ export function pushedBranchesOf(events: readonly RunEvent[]): PushedBranch[] {
  *  settled, whatever the run's status, and stays cut whatever lands for it
  *  later — an unmarked result (a post-turn's bridge reads the earlier
  *  execution's aborted settle as its own), or the call announced again under
- *  the same id; a call with no result at
- *  all was left open by a run that failed, was interrupted or hard-stopped,
- *  while on a run that completed or stopped softly it is a relayed tool that
- *  ran in the bot or a result lost to a transport gap, nothing running. Calls
- *  and results pair by id; a result for a call the record never opened counts
- *  for nothing. */
-export function callsInFlight(
-  events: readonly RunEvent[],
-  status: RunStatus,
-): Extract<RunEvent, { type: "tool_call" }>[] {
-  const calls = new Map<
-    string,
-    { call: Extract<RunEvent, { type: "tool_call" }>; state: "open" | "cut" | "settled" }
-  >();
+ *  the same id; a call with no result at all was left open by a run that
+ *  failed, was interrupted or hard-stopped, while on a run that completed or
+ *  stopped softly it is a relayed tool that ran in the bot or a result lost to
+ *  a transport gap, nothing running. Calls and results pair by id. The events
+ *  are the registry's bounded backlog (`runRegistry/backlog.ts` drops the
+ *  oldest past its count or byte bound), so on a long run the line of a
+ *  command that hung early may be gone while its cut result — the ending's,
+ *  landing last — survives: a cut result for a call the record no longer
+ *  holds is the harness's own word that the call was ended and not settled,
+ *  and counts by itself, named by its tool and id; an unmarked result for a
+ *  call never opened counts for nothing. */
+export function callsInFlight(events: readonly RunEvent[], status: RunStatus): CallInFlight[] {
+  const calls = new Map<string, { call: CallInFlight; state: "open" | "cut" | "settled" }>();
   for (const e of events) {
     if (e.type === "tool_call" && e.callId !== undefined) {
-      if (calls.get(e.callId)?.state !== "cut") calls.set(e.callId, { call: e, state: "open" });
+      const seen = calls.get(e.callId);
+      if (seen?.state === "cut") {
+        // Announced again after its cut — or after an orphan cut, the line the
+        // backlog evicted now written again: the line is the record's, the
+        // state stays the cut's.
+        seen.call.tool = e.tool;
+        seen.call.summary = e.summary;
+      } else calls.set(e.callId, { call: { callId: e.callId, tool: e.tool, summary: e.summary }, state: "open" });
     } else if (e.type === "tool_result" && e.callId !== undefined) {
       const seen = calls.get(e.callId);
-      if (seen !== undefined && seen.state !== "cut") seen.state = e.cut === true ? "cut" : "settled";
+      if (seen === undefined) {
+        if (e.cut === true)
+          calls.set(e.callId, {
+            call: { callId: e.callId, tool: e.tool, summary: `${e.tool} (call ${e.callId})` },
+            state: "cut",
+          });
+      } else if (seen.state !== "cut") seen.state = e.cut === true ? "cut" : "settled";
     }
   }
   const orderly = status === "completed" || status === "stopped_soft";

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

@@ -129,6 +129,13 @@ export const CONTRACT_SECTION_HEADINGS = {
  *  repository's rules file (~15k characters) and a long unit both inside it. */
 export const DEFAULT_CONTRACT_MAX_CHARS = 48_000;
 
+/** The most of a plan a reader hands the parsers: ten times the tool clip
+ *  (`MAX_FILE_CHARS`, `src/execution/githubApi.ts`), which a plan that grows by
+ *  amendment passes — the program plan crossed 400k characters and the seed
+ *  then saw its first 25 units alone. A plan past this bound is refused by
+ *  name, never parsed short. */
+export const PLAN_MAX_CHARS = 2_000_000;
+
 const UNIT_HEADING = /^### (U\d+)\. (.+?)\s*$/;
 const ANY_HEADING = /^#{2,3} /;
 const BULLET = /^- \*\*([^*]+)\*\*:(?:\s?(.*))?$/;

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

@@ -600,8 +600,22 @@ export type UnitEnding =
 /** What a transition tells the driver beyond the next action: a round boundary
  *  the card draws (`shipRoundHeader`) and the run stream records, and the end. */
 export type CoordinatorNote =
-  | { type: "round"; index: number; agent: ChildPreset; outcome: ShipRoundOutcome }
+  | {
+      type: "round";
+      index: number;
+      agent: ChildPreset;
+      outcome: ShipRoundOutcome;
+      /** The severity gate fired on this approve (agent-ship item 9): the
+       *  findings at or above the level in force, as `id (severity)`. The
+       *  child's own verdict parser holds an approve to the same level
+       *  (agent-review item 5a), so this should never be set — when it is, the
+       *  verdict was parsed at another level (a lost directive, an older
+       *  record, a harness around `submit_verdict`) and the row, the card and
+       *  the log say so instead of routing silently into the findings step. */
+      gate?: { level: AddressSeverity; findings: string[] };
+    }
   | { type: "ended"; ending: UnitEnding };
+type RoundNote = Extract<CoordinatorNote, { type: "round" }>;
 
 /** How the pipeline's budget went, in ms: the coding rounds' (round 0 and the
  *  findings steps), the review rounds', and everything else (branching,
@@ -740,7 +754,7 @@ export const WAIT_MARGIN_MS = SHIP_WAIT.marginMinutes * MIN;
  *  one chunk of the runner's time, not the child's whole budget. Five minutes
  *  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. */
+ *  few steps: a coding child's 90 minutes are eighteen waits and eighteen reads. */
 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
@@ -939,7 +953,10 @@ function end(s: UnitPipelineState, ending: UnitEnding, notes: CoordinatorNote[]
   return { state: { ...s, phase: ENDED, ending }, notes: [...notes, { type: "ended", ending }] };
 }
 
-const roundNote = (round: RoundRef, outcome: ShipRoundOutcome): CoordinatorNote => ({
+/** A gated finding as the gate note names it: `F1 (minor)`. */
+const gateLabel = (f: Finding): string => `${f.id} (${f.severity})`;
+
+const roundNote = (round: RoundRef, outcome: ShipRoundOutcome): RoundNote => ({
   type: "round",
   index: round.index,
   agent: presetOf(round.kind),
@@ -1114,6 +1131,10 @@ function settleReview(
     const level = next.input.addressSeverity ?? DEFAULT_ADDRESS_SEVERITY;
     const gated = findingsAtOrAbove(verdict.findings, level);
     if (gated.length > 0) {
+      // The gate fired — which the child's parser should have made impossible
+      // (agent-review item 5a): the round note carries what it caught, so the
+      // mismatch is seen and not just routed around.
+      notes[0] = { ...roundNote(round, verdict.verdict), gate: { level, findings: gated.map(gateLabel) } };
       if (mode !== undefined)
         return end(
           next,

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

@@ -24,8 +24,12 @@ export interface ProgressInput {
   /** The heads the segment's coding run pushed (`RunRecord.pushed`). */
   pushed: readonly PushedHeadFact[];
   /** The head the segment started from — the previous segment's recorded sha.
-   *  Absent on a fresh branch, where any push is progress. */
+   *  Absent on a fresh branch, where the base head stands in for it. */
   startHead?: string;
+  /** The base branch's head the unit's branch was created at. On a fresh
+   *  branch (no `startHead`) a push of this head is the branch's creation,
+   *  not the unit's progress; with neither known, any push is progress. */
+  baseHead?: string;
   /** When the segment's lease began; a push stamped before it is not this segment's. */
   leaseStartedAt?: number;
   /** The previous segment's handoff and this one's, when both exist. */
@@ -53,7 +57,10 @@ export function progressOf(input: ProgressInput): Progress {
   if (last !== undefined) {
     const newerThanLease =
       input.leaseStartedAt === undefined || last.at === undefined || last.at >= input.leaseStartedAt;
-    const moved = input.startHead === undefined || !sameSha(last.sha, input.startHead);
+    // A fresh branch starts at the base head, so that head is the bar a push
+    // must move past when no segment recorded a start.
+    const startHead = input.startHead ?? input.baseHead;
+    const moved = startHead === undefined || !sameSha(last.sha, startHead);
     if (newerThanLease && moved) return { progressed: true, by: "push", sha: last.sha };
   }
   const pushWhy = `no head newer than the lease's start was pushed to \`${input.branch}\``;
@@ -95,7 +102,7 @@ export function renewalDecision(input: RenewalInput): RenewalDecision {
     const detail =
       input.grant.renewals === 0
         ? "the grant holds no renewals"
-        : `the grant's ${input.grant.renewals} renewal${input.grant.renewals === 1 ? "" : "s"} are spent`;
+        : `the grant's ${input.grant.renewals} renewal${input.grant.renewals === 1 ? " is" : "s are"} spent`;
     return { renew: false, why: "grant_exhausted", detail, renewalsLeft };
   }
   const cap = input.grant.costCapUsd;

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

@@ -26,6 +26,11 @@ export interface AttrDomain {
   requester: "message" | "relay-footer" | "thread-parent" | "bot";
   // dispatch.* / run.* / post.*
   outcome: string;
+  /** The refusal's code (src/core/refusal.ts) — on the `dispatch.refuse` span
+   *  and the request's root, so refusals are countable from the trace alone. */
+  refusal: string;
+  /** The refusal's cause, from the one code→cause table in src/core/refusal.ts. */
+  cause: "request" | "policy" | "system";
   count: number;
   backend: Backend;
   // run.command
@@ -114,6 +119,8 @@ export type SpanAttrs = { readonly [K in SpanAttrKey]?: AttrDomain[K] };
 const IDENTIFIER_KEYS: ReadonlySet<SpanAttrKey> = new Set<SpanAttrKey>([
   "runId",
   "outcome",
+  "refusal",
+  "cause",
   "command",
   "route",
   "host",
@@ -163,6 +170,8 @@ const ATTR_TYPE: Record<SpanAttrKey, "string" | "number" | "boolean"> = {
   dedupe: "string",
   requester: "string",
   outcome: "string",
+  refusal: "string",
+  cause: "string",
   count: "number",
   backend: "string",
   command: "string",

package/dist/assets/src/execution/bashTimeout.ts

@@ -4,7 +4,7 @@
 // Deliberately free of node: imports so wrangler can bundle it into Workers.
 // The numbers are rows of src/core/budgets.ts (docs/decisions/0046); this file
 // keeps their names for the readers that learned them here.
-import { ALLOWANCES, BASH_COMMAND, MINUTE_MS } from "../core/budgets.js";
+import { ALLOWANCES, ATTACH_REQUEST_MIN_MS, BASH_COMMAND, MINUTE_MS } from "../core/budgets.js";
 
 /** Default per-command budget when the caller passes no timeoutMs. */
 export const BASH_TIMEOUT_MS = BASH_COMMAND.defaultMinutes * MINUTE_MS;
@@ -50,8 +50,10 @@ export function clampBashTimeout(requested: unknown): number {
 export type RunBudget =
   { kind: "unchanged" } | { kind: "clipped"; timeoutMs: number; note: string } | { kind: "exhausted"; note: string };
 
+/** Whole seconds for the notes below, never negative: the two clip notes phrase the reserve alike. */
+const secs = (ms: number): number => Math.max(0, Math.round(ms / 1000));
+
 export function bashBudgetWithinRun(wantedMs: number, remainingMs: number): RunBudget {
-  const secs = (ms: number) => Math.max(0, Math.round(ms / 1000));
   const cap = Math.trunc(remainingMs - RUN_DEADLINE_RESERVE_MS);
   if (cap < BASH_TIMEOUT_MIN_MS) {
     return {
@@ -69,6 +71,48 @@ export function bashBudgetWithinRun(wantedMs: number, remainingMs: number): RunB
   };
 }
 
+/** The bound on an attach request an executor opens while its run has
+ *  `remainingMs` of wall clock left (`ResidentExecutorOptions.remainingMs`):
+ *  `bounded` by the attach's own default, `BASH_TIMEOUT_MS` — an attach may
+ *  clone and install deps — clipped to what the run has left less the same
+ *  write-up reserve a command keeps back, so an attach never holds a run past
+ *  its lease and the model keeps its write-up; never raised above the default.
+ *  Inside the reserve, or with less than an attach's floor past it
+ *  (`ATTACH_REQUEST_MIN_MS`: a bound too short to clone would be cut and
+ *  struck as a rollout), `exhausted`: the request is not opened at all — the
+ *  resident would run the attach to its end server-side for a run that is
+ *  ending, and the caller would get a deadline it could read as waitable — and
+ *  the note names the run's clock and the bound that refused (the reserve, or
+ *  the floor past it): it is the one sentence every reader carries, the
+ *  executor's refusal and the relaunch's note alike. The command's own budget
+ *  never bounds an attach: the attach is not the command, and the command's
+ *  one-second floor is the model's to choose. */
+export type AttachBound = { kind: "bounded"; timeoutMs: number } | { kind: "exhausted"; note: string };
+
+export function attachBoundWithinRun(remainingMs: number): AttachBound {
+  const left = Math.trunc(remainingMs - RUN_DEADLINE_RESERVE_MS);
+  // The one sentence every reader of an exhausted bound carries — the
+  // executor's refusal, the relaunch's note — worded by the bound that refused.
+  if (left <= 0) {
+    return {
+      kind: "exhausted",
+      note:
+        `the run has ${secs(remainingMs)}s of wall clock left, inside the ${secs(RUN_DEADLINE_RESERVE_MS)}s ` +
+        "write-up reserve, so no attach was opened",
+    };
+  }
+  if (left < ATTACH_REQUEST_MIN_MS) {
+    return {
+      kind: "exhausted",
+      note:
+        `the run has ${secs(remainingMs)}s of wall clock left, only ${secs(left)}s past the ` +
+        `${secs(RUN_DEADLINE_RESERVE_MS)}s write-up reserve — under the ${secs(ATTACH_REQUEST_MIN_MS)}s an attach needs — ` +
+        "so no attach was opened",
+    };
+  }
+  return { kind: "bounded", timeoutMs: Math.min(BASH_TIMEOUT_MS, left) };
+}
+
 /** The line a timed-out command shows the model: names the limit that fired
  *  and the knob that raises it, so the model can self-correct (re-run with a
  *  larger timeoutMs, split the command, or background it) instead of guessing

package/dist/assets/src/execution/residentRefresh.ts

@@ -180,11 +180,15 @@ export function killStaleBuildProcessesCommand(user: string, dir: string): strin
 }
 
 /** Signature of a step killed from OUTSIDE its own budget: the exit status of
- *  SIGTERM (128 + 15), bash's "Session terminated" on a killed login shell, or
- *  a tool naming the signal. A bare "killed" is NOT enough — compilers and
- *  OOM messages say it too — and a step the cycle itself timed out is a real
- *  failure however it died. */
-const INTERRUPTION_SIGNATURE = /\bexit 143\b|Session terminated|SIGTERM|^restore-interrupted:/;
+ *  SIGTERM (128 + 15) — as a shell reports it (`exit 143`) or as the platform
+ *  words a container that died under a short exec ("Container exited with
+ *  unexpected exit code: 143"; seen live on the wake path's ready-stamp probe
+ *  when a stop landed on it) — bash's "Session terminated" on a killed login
+ *  shell, or a tool naming the signal. Only 143: the platform's same wording
+ *  with any other code (1, 137, 139) is a genuine crash and stays a failure.
+ *  A bare "killed" is NOT enough — compilers and OOM messages say it too —
+ *  and a step the cycle itself timed out is a real failure however it died. */
+const INTERRUPTION_SIGNATURE = /\bexit 143\b|exit code: 143\b|Session terminated|SIGTERM|^restore-interrupted:/;
 
 /** The wordings git gives when the MIRROR itself is broken: its `origin`
  *  remote gone from `config`, the repository not a repository, an object store

package/dist/assets/src/execution/sandboxErrors.ts

@@ -154,10 +154,15 @@ export const SANDBOX_STARTING_EXPLANATION =
   "the thread's sandbox container is starting (image pull, boot, runtime) — nothing ran yet; the request is re-sent once it is up";
 
 /** The executor waits at most this long for a container to start, whatever
- *  the command's own budget: the platform's own start allowances (30 s for an
- *  instance, 90 s for the port) plus a slow image pull fit inside it, and a
- *  60 s command is never killed by a two-minute start it did not cause. */
-export const SANDBOX_START_WAIT_MAX_MS = 5 * 60_000;
+ *  the command's own budget: the platform's own start allowances (the
+ *  instance grant, 90 s for the port) plus a slow image pull fit inside it,
+ *  and a 60 s command is never killed by a two-minute start it did not cause.
+ *  Ten minutes, not five: under a midday burst the platform admitted about
+ *  seven starts at once and granted the rest 2.5 to 5 minutes later — two
+ *  threads of twenty-four died at the five-minute mark with their container
+ *  a minute away. A run that waits ten minutes for its container starts; one
+ *  that dies at five does not, and nothing else in the run was in progress. */
+export const SANDBOX_START_WAIT_MAX_MS = 10 * 60_000;
 
 /** Backoff between re-sends while a container starts: 5 s, 10 s, then 15 s.
  *  A start takes tens of seconds, not minutes, so the poll is denser than the