tldr-experts 0.22.0 → 0.24.0

package/dist/tldrx.js

@@ -16033,7 +16033,7 @@ var ENTRIES = [
       {
         name: "until-done",
         arg: "[<n>]",
-        meaning: "Relaunch the loop IN-PROCESS after an exit it can do nothing else with, at most n times — bare means 5, the cap. `--retry-failed` bounds one stage's exit 5s INSIDE the loop; this bounds the loop ENDING: a stage failure past that bound (5), a thrown error that used to reach the shell as a bare 1 with nothing on the ledger, a refusal whose remedy is the same command typed again (2). Measured on one 28 h unattended run: five such exits, each a person reading it and typing `tldrx run auto` again, 18 h before a story ran. Every relaunch is a `run.relaunched` event with the exit it recovered from, the attempt and the bound, and `run.finished` / `run.failed` go out ONCE, from the last attempt. What it NEVER relaunches over: exit 4 (a person's — `--wait-answers` and `--wait-gates` own it), a `budget.blocked` or this loop's own `--max-usd` (nothing in-process moves a ceiling, and `--max-usd` spans every relaunch rather than resetting), and an attempt whose last line is the previous attempt's verbatim — a refusal that repeats is not one a relaunch moves. `0` is the default and is one launch, exactly as before. Put the run id before the flag, or write `--until-done=3`.",
+        meaning: "Relaunch the loop IN-PROCESS after an exit it can do nothing else with, at most n times — bare means 5, the cap. `--retry-failed` bounds one stage's exit 5s INSIDE the loop; this bounds the loop ENDING: a stage failure past that bound (5), a thrown error that used to reach the shell as a bare 1 with nothing on the ledger, a refusal whose remedy is the same command typed again (2). Measured on one 28 h unattended run: five such exits, each a person reading it and typing `tldrx run auto` again, 18 h before a story ran. Every relaunch is a `run.relaunched` event with the exit it recovered from, the attempt and the bound, and `run.finished` / `run.failed` go out ONCE, from the last attempt. What it NEVER relaunches over: exit 4 (a person's — `--wait-answers` and `--wait-gates` own it), a `budget.blocked` or this loop's own `--max-usd` (nothing in-process moves a ceiling, and `--max-usd` spans every relaunch rather than resetting), and an attempt REFUSED BY THE SAME WORDS as the one before it — a refusal that repeats is not one a relaunch moves. The words compared are the ones the stop NAMES, never the last line printed: every stage death ends with the same advice about cost, and comparing that stopped runs that were making progress (#297). `0` is the default and is one launch, exactly as before. Put the run id before the flag, or write `--until-done=3`.",
         sub: "auto"
       },
       {
@@ -16100,7 +16100,7 @@ var ENTRIES = [
     exits: [EXIT_OK, EXIT_USAGE, EXIT_GATE_REFUSED, EXIT_NOT_FOUND, EXIT_AWAITING_HUMAN, EXIT_AGENT_FAILED],
     notes: [
       "`run attend host` is a LOCK, not an engine. It sets one field, spends nothing, runs no stage and touches no branch — and from then on THE FRAMEWORK WILL NOT SPAWN on that run: every turn is a `tldrx next --prepare` / `tldrx next --commit` handshake with the session driving it, the Build reviewer included. `run attend --none` hands it back.",
-      "`run auto` is an ENGINE, not a lock. It calls `next` HEADLESS over and over, so THE FRAMEWORK spawns a metered sub-agent stage after stage, and it stops at the first thing it may not decide: a human gate or an open question (4), a stage failure (5) — unless `--retry-failed <n>` lets it run that stage again, bounded, up to n times in a row — a phase ceiling or this loop's own --max-usd (2). `--until-done [<n>]` puts a bounded relauncher OVER those stops: after a 5 past the retry bound, a throw, or a 2 with no money behind it, the same process runs the loop again and writes `run.relaunched` — never over a person's 4, never over a `budget.blocked`, never twice over the same last line. It is REFUSED ON AN ATTENDED RUN (exit 1, before the event log is opened) — a lock and an engine are alternatives, never layers.",
+      "`run auto` is an ENGINE, not a lock. It calls `next` HEADLESS over and over, so THE FRAMEWORK spawns a metered sub-agent stage after stage, and it stops at the first thing it may not decide: a human gate or an open question (4), a stage failure (5) — unless `--retry-failed <n>` lets it run that stage again, bounded, up to n times in a row — a phase ceiling or this loop's own --max-usd (2). `--until-done [<n>]` puts a bounded relauncher OVER those stops: after a 5 past the retry bound, a throw, or a 2 with no money behind it, the same process runs the loop again and writes `run.relaunched` — never over a person's 4, never over a `budget.blocked`, never twice over the same refusal. It is REFUSED ON AN ATTENDED RUN (exit 1, before the event log is opened) — a lock and an engine are alternatives, never layers.",
       "`run auto` can also TELL SOMEBODY. When `.tldrx/workspace.yml` declares a `notify:` command (§2.18), the loop hands that command one `version: 1` JSON object on stdin at every moment a person is needed — an open question with its options and the literal `tldrx answer` line, a gate with the literal approve line, a finished or failed run with its exit code and family — plus a periodic `status` under `--notify-every`. The framework names no chat tool: the command is the owner's own, run as argv with no shell, and its exit code is recorded as `notify.sent` / `notify.failed` and NEVER changes the run's outcome.",
       "Under `run auto`, a stage whose `gates_policy` is `agent` gets one bounded GATE-SIGNER turn of its own. When the stage's checks have passed, the engine spawns a single sub-agent at the stage's model and effort, on a quarter of the stage's per-agent ceiling, allowed to read and to write exactly one file: `.agent/<stage>/evidence.md`. The note then goes through the UNCHANGED `approve --as-agent` path — the same validator a person's note goes through — so `verdict: sign` plus every condition holding closes the gate under the note's own `by:`, and anything else leaves it pending for a person with the reasons named. The turn is recorded like any other (`agent.spawned` / `agent.result`, `role: gate-signer`) and shows up in `tldrx cost`. There is no flag for it: `gates_policy: agent` is already the owner's recorded decision that an agent may close this gate, and `human` gates are never touched.",
       "`run auto` walks the LAST MILE when the run was opened with `--ship` (#253): the moment the run reads `done` under it, it runs `tldrx ship` — push, PR, and under `merge` the auto-merge — and `run.finished` carries `pr_url` and `merge`. A ship that is refused is the loop's exit code (2), because the loop was asked for a PR and did not deliver one; the run's own work is still `done` on disk. A run closed by a hand `tldrx approve` outside the loop is shipped by typing `tldrx ship`, which reads the same block.",
@@ -16449,7 +16449,7 @@ var ENTRIES = [
       {
         name: "as-is",
         arg: null,
-        meaning: "Settle the story from its BRANCH AS IT STANDS: the next Build turn runs the dod, the review and the merge over the commits already on `story/<run>/<id>`, and spawns NO developer. For a story a person finished by hand — a rebase after a conflict, a fix typed directly on the branch — which the plain verb cannot land, because a developer handed finished work has nothing to do and the story blocks on the no-work rule. It is not a shortcut past a gate: a red dod blocks the story, and so does a branch carrying no commit its epic has not already got. Requires --note; refused together with --for-fix.",
+        meaning: "Settle the story from its BRANCH AS IT STANDS: the next Build turn runs the dod, the review and the merge over the commits already on `story/<run>/<id>`, and spawns NO developer. For a story a person finished by hand — a rebase after a conflict, a fix typed directly on the branch — which the plain verb cannot land, because a developer handed finished work has nothing to do and the story blocks on the no-work rule. It is not a shortcut past a gate: a red dod blocks the story, and so does a branch carrying no commit its epic has not already got — with one named exception: a story whose work is ALREADY on the epic from an earlier turn and whose review never completed (the reviewer died, or the attempt after the merge died with no work) is settled review-only: nothing is merged, the dod runs on the epic head and the reviewer judges the range the story was merged as; a review that stands (`approve`, `changes`, `fixlist`) still refuses. Requires --note; refused together with --for-fix.",
         sub: "reopen"
       },
       runFlag(),
@@ -20652,10 +20652,17 @@ function describe4(exitCode, doc, stderr, timedOut, stdout, provider) {
     return `${name} exited ${exitCode} without a parseable result event: ${tail}`;
   }
   const errors2 = Array.isArray(doc.errors) ? doc.errors.filter((e) => typeof e === "string") : [];
-  const reason = errors2[0] ?? (typeof doc.subtype === "string" ? doc.subtype : "") ?? "";
-  const suffix = reason === "" ? "" : `: ${String(reason)}`;
-  return `${name} exited ${exitCode} with is_error=${String(doc.is_error === true)}${suffix}`;
-}
+  const verdict = `${name} exited ${exitCode} with is_error=${String(doc.is_error === true)}`;
+  const named = typeof errors2[0] === "string" && errors2[0] !== "" ? errors2[0] : "";
+  if (named !== "")
+    return `${verdict}: ${named}`;
+  const subtype = typeof doc.subtype === "string" ? doc.subtype : "";
+  if (subtype !== "" && !SUCCESS_SUBTYPES.has(subtype))
+    return `${verdict}: ${subtype}`;
+  const contradiction = subtype === "" ? "" : ` (the provider's own subtype said "${subtype}")`;
+  return `${verdict}: no reason named${contradiction}`;
+}
+var SUCCESS_SUBTYPES = new Set(["success"]);
 function firstLine3(text2) {
   const line = text2.split(`
 `).map((l) => l.trim()).find((l) => l !== "");
@@ -24906,7 +24913,7 @@ function effortFlag(args, name = "effort") {
 }
 
 // src/core/facilitator/runAuto.ts
-import { readFileSync as readFileSync76 } from "node:fs";
+import { readFileSync as readFileSync77 } from "node:fs";
 import { join as join102 } from "node:path";
 
 // src/core/build/implicitPlan.ts
@@ -25937,6 +25944,7 @@ function carriedFindings(findings2) {
   return findings2.filter((f) => f.disposition === "defer-with-log" && !(f.resolved && f.resolvedSha !== null));
 }
 var CLAIMED_UNVERIFIED = "claimed-unverified";
+var FIXLIST_SETTLED_MARK = "every finding is routed away from `fix-now`, so the story is done without a fix round";
 function parseFixFindings(value) {
   const problems = [];
   const format = [];
@@ -26452,8 +26460,16 @@ function reviewStillOwed(outcome) {
 }
 var AS_IS_MARK = "the branch was taken AS IT STANDS — no developer was spawned for it";
 var AS_IS_NOT_AHEAD_MARK = "nothing to take as it stands";
-function asIsNotAheadReason(branch, epicBranch, ahead) {
-  return ahead === null ? `${AS_IS_NOT_AHEAD_MARK}: git could not count what \`${branch}\` carries beyond ` + `\`${epicBranch}\`, and a settlement that spawns no developer will not merge on a ` + "measurement it does not have. Nothing was merged" : `${AS_IS_NOT_AHEAD_MARK}: \`${branch}\` carries no commit \`${epicBranch}\` has not already ` + "got, so there is no work to settle. Commit the fix to the story branch first, then reopen it " + "--as-is. Nothing was merged";
+var AS_IS_JUDGED_MARK = "the last review of that work stands";
+var AS_IS_REVIEW_ONLY_MARK = "the review was run AS IT STANDS — nothing was merged and no developer was spawned";
+function asIsNotAheadReason(branch, epicBranch, ahead, judged) {
+  if (ahead === null) {
+    return `${AS_IS_NOT_AHEAD_MARK}: git could not count what \`${branch}\` carries beyond ` + `\`${epicBranch}\`, and a settlement that spawns no developer will not merge on a ` + "measurement it does not have. Nothing was merged";
+  }
+  return `${AS_IS_NOT_AHEAD_MARK}: \`${branch}\` carries no commit \`${epicBranch}\` has not already ` + "got, so there is no work to settle" + (judged === undefined ? "" : `, and ${AS_IS_JUDGED_MARK} — \`${judged.commit.slice(0, 7)}\` is on \`${epicBranch}\` and its ` + `review said \`${judged.verdict}\`, so the review is not what is owed`) + ". Commit the fix to the story branch first, then reopen it --as-is. Nothing was merged";
+}
+function reviewNeverCompleted(verdict) {
+  return verdict === "n-a" || verdict === "error";
 }
 function scopedNote(result2) {
   if (result2.scope !== "paths" || result2.rendered === undefined)
@@ -28997,6 +29013,7 @@ function dodLines(r) {
     `  \`${r.outputPath}\` [src: ${r.outputPath}:${String(r.outputLine ?? 1)}]. Read that before re-running anything.`
   ];
 }
+var WHY_NOT_DONE_HEADING = "## Why it is not done";
 function renderReviewLog(outcome) {
   const lines = [
     `# Review — ${outcome.id} · ${outcome.title}`,
@@ -29008,7 +29025,7 @@ function renderReviewLog(outcome) {
     `- Repo: \`${outcome.repo}\` · wave ${outcome.wave} · epic ${outcome.epic}`,
     `- Branch: \`${outcome.branch}\` → \`${outcome.epicBranch}\` (${mergeWord(outcome)})`,
     `- Commit: ${outcome.commit ?? "(none)"}`,
-    ...outcome.asIs == null ? [] : [`- Developer: **none** — ${AS_IS_MARK}. \`${outcome.branch}\` was settled as it stands, ` + `signed by ${outcome.asIs.actor}: ${outcome.asIs.note}. The Definition of Done below and ` + "the reviewer above judged that branch, unchanged."],
+    ...outcome.asIs == null ? [] : outcome.asIs.reason === "review-only" ? [`- Developer: **none** — ${AS_IS_REVIEW_ONLY_MARK}. \`${outcome.asIs.reviewed?.commit ?? outcome.commit ?? "(none)"}\` ` + `was already on \`${outcome.epicBranch}\` from an earlier turn and nothing had judged it; ` + `signed by ${outcome.asIs.actor}: ${outcome.asIs.note}. The Definition of Done below ran on the ` + "epic head, and the reviewer above judged the range that merge was recorded as."] : [`- Developer: **none** — ${AS_IS_MARK}. \`${outcome.branch}\` was settled as it stands, ` + `signed by ${outcome.asIs.actor}: ${outcome.asIs.note}. The Definition of Done below and ` + "the reviewer above judged that branch, unchanged."],
     ...outcome.developerError === null ? [] : [`- Developer: **FAILED** — ${outcome.developerError}`],
     ...outcome.permissionRefused == null ? [] : [withCure(`- Developer: \`${outcome.permissionRefused}\` was refused for approval by the agent's own ` + "permission layer; the tree held committed work, so the Definition of Done below decided", outcome.permissionRefused, outcome.declaredCommands)],
     ...outcome.budgetDeath == null ? [] : [`- Developer: died on its per-story cap — ${outcome.budgetDeath}; the tree held work, ` + "so the Definition of Done below decided"],
@@ -29033,7 +29050,7 @@ function renderReviewLog(outcome) {
     lines.push("## Uncommitted work rescued", "", ...rescueLines(outcome), "");
   }
   if (outcome.reason !== null) {
-    lines.push("## Why it is not done", "", outcome.reason, "");
+    lines.push(WHY_NOT_DONE_HEADING, "", outcome.reason, "");
   }
   return lines.join(`
 `);
@@ -29369,6 +29386,161 @@ function round22(n) {
   return Math.round(n * 100) / 100;
 }
 
+// src/core/build/caps.ts
+var MAX_ATTEMPTS2 = STAGE_TUNING_DEFAULTS.attempts;
+var REVIEWER_SHARE2 = STAGE_TUNING_DEFAULTS.reviewerShare;
+var REVIEWER_FLOOR_USD2 = 1;
+var STORY_CAP_MULTIPLIER2 = STAGE_TUNING_DEFAULTS.storyCapMultiplier;
+var STORY_CAP_FLOOR_USD2 = STAGE_TUNING_DEFAULTS.storyCapFloorUsd;
+function developerAttemptDivisor2(attempt, attempts = MAX_ATTEMPTS2) {
+  return attempt <= 1 ? 1 : attempts;
+}
+var DEFAULT_PARALLEL = 1;
+function clampParallel(requested) {
+  if (requested === undefined || !Number.isFinite(requested))
+    return DEFAULT_PARALLEL;
+  return Math.max(1, Math.min(MAX_STORIES_PER_WAVE, Math.trunc(requested)));
+}
+function attemptsOf(parts) {
+  return parts.attempts ?? MAX_ATTEMPTS2;
+}
+function storyCapMultiplierOf(parts) {
+  return parts.storyCapMultiplier ?? STORY_CAP_MULTIPLIER2;
+}
+function storyCapFloorOf(parts) {
+  return parts.storyCapFloorUsd ?? STORY_CAP_FLOOR_USD2;
+}
+function reviewerShareOf(parts) {
+  return parts.reviewerShare ?? REVIEWER_SHARE2;
+}
+function round23(n) {
+  return Math.round(n * 100) / 100;
+}
+function developerCap(parts, storyId, attempt = 1) {
+  const price = priceOf(parts, storyId);
+  if (price === null)
+    return parts.agentCap(1 / worstCaseShares(parts));
+  return parts.agentCap(shareOf(parts, storyCeilingUsd(parts, price) / developerAttemptDivisor2(attempt, attemptsOf(parts))));
+}
+function storyCeilingUsd(parts, price) {
+  const floor = parts.budgetUsd > 0 ? Math.min(storyCapFloorOf(parts), parts.budgetUsd) : storyCapFloorOf(parts);
+  return Math.max(price * storyCapMultiplierOf(parts), floor);
+}
+function reviewerCap(parts, spentUsd, storyId) {
+  const price = priceOf(parts, storyId);
+  const share = reviewerShareOf(parts);
+  const derived = price === null ? parts.agentCap(share / worstCaseShares(parts)) : parts.agentCap(shareOf(parts, price * share / (attemptsOf(parts) * (1 + share))));
+  const floor = Math.min(REVIEWER_FLOOR_USD2, Math.max(parts.budgetUsd - spentUsd, 0));
+  return round23(Math.min(Math.max(derived, floor), parts.maxBudgetUsd));
+}
+function stageRemainderUsd(parts, spentUsd) {
+  if (!(parts.budgetUsd > 0))
+    return null;
+  return Math.max(round23(parts.budgetUsd - spentUsd), 0);
+}
+function reviewerUnderfunded(parts, spentUsd) {
+  const left = stageRemainderUsd(parts, spentUsd);
+  return left !== null && left < REVIEWER_FLOOR_USD2;
+}
+function priceOf(parts, storyId) {
+  if (storyId === undefined)
+    return null;
+  const price = parts.prices.get(storyId);
+  if (price === undefined || !Number.isFinite(price) || price <= 0)
+    return null;
+  return price * priceScale(parts);
+}
+function priceScale(parts) {
+  if (parts.budgetUsd <= 0)
+    return 1;
+  const sum = plannedSumUsd(parts);
+  return sum <= parts.budgetUsd ? 1 : parts.budgetUsd / sum;
+}
+function plannedSumUsd(parts) {
+  let sum = 0;
+  for (const price of parts.prices.values()) {
+    if (Number.isFinite(price) && price > 0)
+      sum += price;
+  }
+  return sum;
+}
+function shareOf(parts, usd) {
+  return parts.budgetUsd <= 0 ? 1 : usd / parts.budgetUsd;
+}
+function worstCaseShares(parts) {
+  return Math.max(parts.storyCount, 1) * attemptsOf(parts) * (1 + reviewerShareOf(parts));
+}
+function storyCapDerivation(parts, storyId, attempt = 1) {
+  const scaled = priceOf(parts, storyId);
+  if (scaled === null)
+    return null;
+  const planPriceUsd = parts.prices.get(storyId);
+  const floorUsd = parts.budgetUsd > 0 ? Math.min(storyCapFloorOf(parts), parts.budgetUsd) : storyCapFloorOf(parts);
+  return {
+    storyId,
+    attempt,
+    planPriceUsd,
+    plannedSumUsd: plannedSumUsd(parts),
+    stageBudgetUsd: parts.budgetUsd,
+    scale: priceScale(parts),
+    scaledPriceUsd: scaled,
+    multiplier: storyCapMultiplierOf(parts),
+    floorUsd,
+    ceilingUsd: storyCeilingUsd(parts, scaled),
+    divisor: developerAttemptDivisor2(attempt, attemptsOf(parts)),
+    capUsd: developerCap(parts, storyId, attempt)
+  };
+}
+function usd(n) {
+  return `$${n.toFixed(2)}`;
+}
+function scaleOf(scale) {
+  return scale === 1 ? "1" : scale.toFixed(4);
+}
+function describeStoryCap(d) {
+  const multiplied = d.scaledPriceUsd * d.multiplier;
+  const scaleNote = d.scale === 1 ? ` (stage scale 1: ${usd(d.plannedSumUsd)} of plan prices fit the stage's ${usd(d.stageBudgetUsd)})` : ` (stage budget_usd ${usd(d.stageBudgetUsd)} over ${usd(d.plannedSumUsd)} of plan prices)`;
+  const scaleTerm = d.scale === 1 ? "" : ` × stage scale ${scaleOf(d.scale)}${scaleNote}`;
+  const ceiling = multiplied >= d.floorUsd ? `plan price ${usd(d.planPriceUsd)}${scaleTerm} × story_cap_multiplier ${String(d.multiplier)}` + ` = ${usd(multiplied)}${d.scale === 1 ? scaleNote : ""}, above the floor ${usd(d.floorUsd)}` : `story_cap_floor_usd ${usd(d.floorUsd)} (plan price ${usd(d.planPriceUsd)} × stage scale ${scaleOf(d.scale)}` + ` × story_cap_multiplier ${String(d.multiplier)} = ${usd(multiplied)} is below it)`;
+  const perAttempt = round23(d.ceilingUsd / d.divisor);
+  const contingency = d.divisor === 1 ? "" : `; attempt ${String(d.attempt)} is the contingency and gets that ÷ ${String(d.divisor)} = ${usd(perAttempt)}`;
+  const clamp = d.capUsd < perAttempt ? `; clamped to ${usd(d.capUsd)} by per_agent_max_usd / --max-usd` : "";
+  return `cap ${usd(d.capUsd)} = ${ceiling}${contingency}${clamp}`;
+}
+function capDeathReason(error, parts, storyId, attempt, lever) {
+  const head2 = `the developer died on its per-story cap — ${error}: `;
+  const d = storyCapDerivation(parts, storyId, attempt);
+  if (d === null) {
+    const cap2 = developerCap(parts, storyId, attempt);
+    return head2 + `this story has no price in \`03-plan/budget.yml\`, so its cap ${usd(cap2)} is the uniform share of the ` + `stage's budget_usd ${usd(parts.budgetUsd)} over ${String(Math.max(parts.storyCount, 1))} story(ies)` + ` × ${String(attemptsOf(parts))} attempt(s) × (1 + reviewer share ${String(reviewerShareOf(parts))})` + ` — the stage's own \`budget_usd\` is what moves it (\`${lever.raiseCommand(parts.budgetUsd)}\` doubles it)`;
+  }
+  const formula = describeStoryCap(d);
+  if (d.scale === 1) {
+    return head2 + formula + "; a story that really costs more than the plan guessed wants a higher price in `03-plan/budget.yml` " + "or a higher `story_cap_multiplier:` on the stage";
+  }
+  const short2 = shortBy(d.plannedSumUsd, d.stageBudgetUsd);
+  return head2 + formula + "; the plan's price cannot move this cap while the plan is scaled — raising every price keeps the " + "ratio and the sum still exceeds the stage — so raise the stage's own `budget_usd` " + `(\`${lever.raiseCommand(short2)}\` lifts the scale to 1) or \`story_cap_multiplier:\` on the stage`;
+}
+function planOverStageAdvisory(parts, lever) {
+  const scale = priceScale(parts);
+  if (scale >= 1)
+    return null;
+  const sum = plannedSumUsd(parts);
+  const factor = (sum / parts.budgetUsd).toFixed(1);
+  let largest = null;
+  for (const [id, price] of parts.prices) {
+    if (Number.isFinite(price) && price > 0 && (largest === null || price > (parts.prices.get(largest) ?? 0))) {
+      largest = id;
+    }
+  }
+  const example = largest === null ? null : storyCapDerivation(parts, largest);
+  const worked = example === null ? "" : `: ${example.storyId} priced ${usd(example.planPriceUsd)} gets max(${usd(example.planPriceUsd)} × ${scaleOf(scale)}` + ` × ${String(example.multiplier)}, ${usd(example.floorUsd)}) = ${usd(example.capUsd)}`;
+  return `advisory: 03-plan/budget.yml prices ${usd(sum)} of stories into a stage whose budget_usd is ` + `${usd(parts.budgetUsd)} — ${factor}× what the stage holds — so every per-story cap is derived from ` + `the plan price × ${scaleOf(scale)}, not the price as written${worked}. Raising the prices cannot lift a ` + `cap while their sum exceeds the stage; \`${lever.raiseCommand(shortBy(sum, parts.budgetUsd))}\` ` + "makes the stage hold the plan as priced, or raise `story_cap_multiplier:` on the stage";
+}
+function shortBy(estimate, remaining2) {
+  return Math.max(0.01, Math.ceil((estimate - remaining2) * 100) / 100);
+}
+
 // src/core/budget/budgetView.ts
 function buildBudgetView(run, budget, runDir) {
   const tally = runTally(run);
@@ -29428,8 +29600,8 @@ function grantLine(view) {
   if (by === null)
     return [];
   const scopes = [
-    ...view.authorized_usd === null ? [] : [`the run ${usd(view.authorized_usd)}`],
-    ...view.phases.filter((phase) => phase.authorized_usd !== null).map((phase) => `${phase.id} ${usd(phase.authorized_usd ?? 0)}`)
+    ...view.authorized_usd === null ? [] : [`the run ${usd2(view.authorized_usd)}`],
+    ...view.phases.filter((phase) => phase.authorized_usd !== null).map((phase) => `${phase.id} ${usd2(phase.authorized_usd ?? 0)}`)
   ];
   if (scopes.length === 0)
     return [];
@@ -29447,9 +29619,6 @@ function raiseCommand(runId, phaseId, amountUsd) {
 function stageRaiseCommand(runId, phaseId, stageId, amountUsd) {
   return `${raiseCommand(runId, phaseId, amountUsd)} --stage ${stageId}`;
 }
-function shortBy(estimate, remaining2) {
-  return Math.max(0.01, Math.ceil((estimate - remaining2) * 100) / 100);
-}
 function nextStageOf(stages) {
   return stages.find((stage2) => !isTerminal(stage2.status)) ?? null;
 }
@@ -29458,29 +29627,29 @@ function renderBudget(view) {
   const stageWidth = Math.max(...view.phases.map((p) => (p.next_stage ?? "—").length), 10);
   const lines = [
     `${view.run} · ${view.title}`,
-    `ceiling ${usd(view.ceiling_usd)} · spent ${spentFigure({
+    `ceiling ${usd2(view.ceiling_usd)} · spent ${spentFigure({
       usd: view.spent_usd,
       unmetered: view.unmetered_tasks,
       metered: view.metered_tasks
-    })}` + ` · left ${usd(view.remaining_usd)} · ` + `per-agent max ${usd(view.per_agent_max_usd)} · on_exceed ${view.on_exceed}`,
+    })}` + ` · left ${usd2(view.remaining_usd)} · ` + `per-agent max ${usd2(view.per_agent_max_usd)} · on_exceed ${view.on_exceed}`,
     ...view.unmetered_tasks === 0 ? [] : [unmeteredNote(view.unmetered_tasks)],
     ...grantLine(view),
     "",
     `  ${"phase".padEnd(width)}  ${pad2("ceiling")}  ${pad2("spent")}  ${pad2("left")}  ` + `${"next stage".padEnd(stageWidth)}  ${pad2("est.")}  next`
   ];
   for (const phase of view.phases) {
-    lines.push(`${phase.is_cursor ? ">" : " "} ${phase.id.padEnd(width)}  ${pad2(usd(phase.ceiling_usd))}  ` + `${pad2(usd(phase.spent_usd))}  ${pad2(usd(phase.remaining_usd))}  ` + `${(phase.next_stage ?? "—").padEnd(stageWidth)}  ` + `${pad2(phase.next_stage === null ? "—" : usd(phase.next_estimate_usd))}  ` + `${phase.next_stage === null ? "—" : phase.blocked ? "BLOCKED" : "ok"}`);
+    lines.push(`${phase.is_cursor ? ">" : " "} ${phase.id.padEnd(width)}  ${pad2(usd2(phase.ceiling_usd))}  ` + `${pad2(usd2(phase.spent_usd))}  ${pad2(usd2(phase.remaining_usd))}  ` + `${(phase.next_stage ?? "—").padEnd(stageWidth)}  ` + `${pad2(phase.next_stage === null ? "—" : usd2(phase.next_estimate_usd))}  ` + `${phase.next_stage === null ? "—" : phase.blocked ? "BLOCKED" : "ok"}`);
   }
   for (const phase of view.phases) {
     if (phase.next_estimate_detail !== null) {
-      lines.push(`  ${phase.id}: ${phase.next_estimate_detail} ` + `(stage estimate ${usd(phase.next_estimate_static_usd)})`);
+      lines.push(`  ${phase.id}: ${phase.next_estimate_detail} ` + `(stage estimate ${usd2(phase.next_estimate_static_usd)})`);
     }
   }
   const blocked = view.blocked;
   if (blocked === null) {
     lines.push("", "`tldrx next` is affordable in every phase that still has a stage to run.");
   } else {
-    lines.push("", `\`tldrx next\` is BLOCKED: phase ${blocked.id} has ${usd(blocked.remaining_usd)} left and stage ` + `\`${blocked.next_stage ?? "?"}\` estimates ${usd(blocked.next_estimate_usd)} ` + `(short by ${usd(blocked.short_by_usd)}).`, `Fix it with:  ${view.fix_command ?? ""}`, `Or move the money instead of adding it:  ${view.fix_command ?? ""} --take-from <phase>`);
+    lines.push("", `\`tldrx next\` is BLOCKED: phase ${blocked.id} has ${usd2(blocked.remaining_usd)} left and stage ` + `\`${blocked.next_stage ?? "?"}\` estimates ${usd2(blocked.next_estimate_usd)} ` + `(short by ${usd2(blocked.short_by_usd)}).`, `Fix it with:  ${view.fix_command ?? ""}`, `Or move the money instead of adding it:  ${view.fix_command ?? ""} --take-from <phase>`);
   }
   return lines.join(`
 `);
@@ -29488,7 +29657,7 @@ function renderBudget(view) {
 function pad2(text3) {
   return text3.padStart(9);
 }
-function usd(amount) {
+function usd2(amount) {
   return `$${amount.toFixed(2)}`;
 }
 function round7(n) {
@@ -29598,6 +29767,26 @@ import { join as join61 } from "node:path";
 
 // src/core/build/handoff.ts
 var MAX_CARRIED_BULLETS = 25;
+var LINE_BREAK_MARK = "⏎";
+var LINE_BREAK_NOTE = `\`${LINE_BREAK_MARK}\` marks a line break inside a quoted command; the review log beside this file ` + "keeps the command verbatim.";
+function ensureLineBreakNote(document) {
+  if (!document.includes(LINE_BREAK_MARK) || document.includes(LINE_BREAK_NOTE))
+    return document;
+  const lines = document.split(`
+`);
+  const at = lines.findIndex((line) => line.startsWith("## "));
+  if (at === -1)
+    return `${document.trimEnd()}
+
+${LINE_BREAK_NOTE}
+`;
+  lines.splice(at, 0, LINE_BREAK_NOTE, "");
+  return lines.join(`
+`);
+}
+function asOneLine(line) {
+  return line.replace(/[ \t]*\r?\n[ \t]*/g, ` ${LINE_BREAK_MARK} `);
+}
 function renderBuildHandoff(parts) {
   const done = parts.outcomes.filter((o) => o.status === "done");
   const notDone = parts.outcomes.filter((o) => o.status !== "done");
@@ -29648,8 +29837,8 @@ function renderBuildHandoff(parts) {
     ...parts.epics.length === 0 ? ["- (no epic branch was written)"] : gateRows(parts.epics).map((e) => `- \`${e.branch}\` in ${e.repos.join(", ")} → \`${e.defaultBranches.join(", ")}\` ` + `(${mergeSummary(e)})`),
     ""
   ];
-  return lines.join(`
-`);
+  return ensureLineBreakNote(lines.map(asOneLine).join(`
+`));
 }
 function gateRows(epics) {
   const byBranch = new Map;
@@ -29913,12 +30102,412 @@ function statusWithOutcome(status, outcome) {
 }
 
 // src/core/run/autoGate.ts
-import { existsSync as existsSync45, readFileSync as readFileSync40 } from "node:fs";
+import { existsSync as existsSync46, readFileSync as readFileSync42 } from "node:fs";
 import { join as join63 } from "node:path";
 
 // src/core/run/checks.ts
-import { existsSync as existsSync44, readFileSync as readFileSync39 } from "node:fs";
+import { existsSync as existsSync45, readFileSync as readFileSync41 } from "node:fs";
 import { basename as basename10, join as join62 } from "node:path";
+
+// src/core/facilitator/stageSpec.ts
+import { existsSync as existsSync44, readFileSync as readFileSync40 } from "node:fs";
+
+// src/core/facilitator/seedInputs.ts
+import { readFileSync as readFileSync39, statSync as statSync16 } from "node:fs";
+var DEFAULT_INPUTS_MAX_BYTES = 256 * 1024;
+var MAX_SEED_INLINE_BYTES = 64 * 1024;
+var MIN_SLICE_BYTES = 2 * 1024;
+function inlineInputs(declared, options) {
+  const budget = options.budgetBytes ?? DEFAULT_INPUTS_MAX_BYTES;
+  const exempt = options.exempt ?? new Set;
+  const inputs = [];
+  const truncated = [];
+  let spent = 0;
+  let seedOverflowed = false;
+  for (const path of declared) {
+    const abs = resolveDeclared(path, options.ctx);
+    if (exempt.has(path)) {
+      inputs.push({ path, content: readOrEmpty3(abs) });
+      continue;
+    }
+    const size = sizeOf4(abs);
+    const room = budget - spent;
+    if (size <= room) {
+      spent += size;
+      inputs.push({ path, content: readOrEmpty3(abs) });
+      continue;
+    }
+    if (options.seed.has(path))
+      seedOverflowed = true;
+    if (room >= MIN_SLICE_BYTES) {
+      spent += room;
+      truncated.push({ path, totalBytes: size, inlinedBytes: room });
+      inputs.push({ path, content: slice(abs, room), inlinedBytes: room, totalBytes: size });
+      continue;
+    }
+    truncated.push({ path, totalBytes: size, inlinedBytes: 0 });
+    inputs.push({ path, content: "", inlinedBytes: 0, totalBytes: size });
+  }
+  return {
+    inputs,
+    note: describe5(budget, truncated, seedOverflowed),
+    truncated,
+    inlinedBytes: spent,
+    budgetBytes: budget
+  };
+}
+function describe5(budget, truncated, seedOverflowed) {
+  if (truncated.length === 0)
+    return null;
+  const listed = truncated.map((entry) => `${entry.path} (${entry.totalBytes.toLocaleString("en-US")} B` + `${entry.inlinedBytes === 0 ? ", none inlined" : `, first ${entry.inlinedBytes.toLocaleString("en-US")} B only`})`).join("; ");
+  const fix = seedOverflowed ? "raise `inputs_max_bytes` in the stage file or split the seed (`tldrx seed triage`)" : "raise `inputs_max_bytes` in the stage file";
+  return `truncated inputs: ${listed} — the ${budget.toLocaleString("en-US")}-byte ` + `\`inputs_max_bytes\` budget ran out. ${fix}. ` + "Work from what IS inlined and say in your handoff what you could not read.";
+}
+function describeTruncatedInputs(result2) {
+  return result2.truncated.map((entry) => `truncated input: ${entry.path} (${entry.totalBytes.toLocaleString("en-US")} B` + `${entry.inlinedBytes === 0 ? ", none inlined" : `, ${entry.inlinedBytes.toLocaleString("en-US")} B inlined`})` + ` — raise inputs_max_bytes (now ${result2.budgetBytes.toLocaleString("en-US")}) or split the seed`);
+}
+function capInputs(declared, max = MAX_STAGE_INPUTS) {
+  return declared.length <= max ? declared : declared.slice(0, max);
+}
+function sizeOf4(abs) {
+  try {
+    return statSync16(abs).size;
+  } catch {
+    return 0;
+  }
+}
+function slice(abs, bytes) {
+  try {
+    return readFileSync39(abs).subarray(0, bytes).toString("utf8");
+  } catch {
+    return "";
+  }
+}
+function readOrEmpty3(abs) {
+  try {
+    return readFileSync39(abs, "utf8");
+  } catch {
+    return "";
+  }
+}
+
+// src/core/budget/modelPrices.ts
+var CACHE_WRITE_MULTIPLIER = 1.25;
+var CACHE_READ_MULTIPLIER = 0.1;
+var BYTES_PER_TOKEN = 3.6;
+var MODEL_PRICES = [
+  { id: "opus", contextTokens: 200000, inputUsdPerMTok: 5, outputUsdPerMTok: 25 },
+  { id: "opus[1m]", contextTokens: 1e6, inputUsdPerMTok: 5, outputUsdPerMTok: 25 },
+  { id: "sonnet", contextTokens: 200000, inputUsdPerMTok: 2, outputUsdPerMTok: 10 },
+  { id: "sonnet[1m]", contextTokens: 1e6, inputUsdPerMTok: 2, outputUsdPerMTok: 10 },
+  { id: "haiku", contextTokens: 200000, inputUsdPerMTok: 1, outputUsdPerMTok: 5 }
+];
+var ONE_MILLION_MARKER = "[1m]";
+var ONE_MILLION_TOKENS = 1e6;
+function familyOf(id) {
+  return id.endsWith(ONE_MILLION_MARKER) ? id.slice(0, -ONE_MILLION_MARKER.length) : id;
+}
+function priceFor(model2) {
+  if (model2 === null)
+    return null;
+  const name = model2.toLowerCase();
+  const oneMillion = name.includes(ONE_MILLION_MARKER);
+  let best = null;
+  for (const row2 of MODEL_PRICES) {
+    const family = familyOf(row2.id);
+    if (family !== row2.id && !oneMillion)
+      continue;
+    if (!name.includes(family))
+      continue;
+    if (best === null || row2.id.length > best.id.length)
+      best = row2;
+  }
+  return best;
+}
+function knownContextTokensFor(model2) {
+  const priced = priceFor(model2);
+  if (priced !== null)
+    return priced.contextTokens;
+  if (model2 !== null && model2.toLowerCase().includes(ONE_MILLION_MARKER))
+    return ONE_MILLION_TOKENS;
+  return null;
+}
+function estimateTokensFromBytes(bytes) {
+  return Math.round(bytes / BYTES_PER_TOKEN);
+}
+
+// src/core/facilitator/contextLedger.ts
+var DEFAULT_PROMPT_MAX_BYTES = 400 * 1024;
+var CONTEXT_WARN_PCT = 80;
+function buildLedger(input) {
+  const rows = [];
+  let stage2 = 0;
+  let inputs = 0;
+  let expertBodies = 0;
+  let expertKnowledge = 0;
+  let dispatchNotes = 0;
+  let projectSkills = 0;
+  let previousAttempt = 0;
+  for (const part of input.parts) {
+    const bytes = byteLength(part.text);
+    switch (part.kind) {
+      case "preamble":
+        stage2 += bytes;
+        rows.push({ kind: part.kind, name: part.name, bytes });
+        break;
+      case "stage":
+        stage2 += bytes;
+        rows.push({ kind: part.kind, name: part.name, bytes });
+        break;
+      case "expert-body":
+        expertBodies += bytes;
+        rows.push({ kind: part.kind, name: part.name, bytes });
+        break;
+      case "expert-knowledge":
+        expertKnowledge += bytes;
+        rows.push({ kind: part.kind, name: part.name, bytes });
+        break;
+      case "dispatch-notes":
+        dispatchNotes += bytes;
+        rows.push({ kind: part.kind, name: part.name, bytes });
+        break;
+      case "project-skills":
+        projectSkills += bytes;
+        rows.push({ kind: part.kind, name: part.name, bytes });
+        break;
+      case "previous-attempt":
+        previousAttempt += bytes;
+        rows.push({ kind: part.kind, name: part.name, bytes });
+        break;
+      case "inputs":
+        inputs += bytes;
+        for (const file of input.inputBytes) {
+          rows.push({ kind: "inputs", name: file.path, bytes: file.bytes });
+        }
+        break;
+    }
+  }
+  const totalBytes = stage2 + inputs + expertBodies + expertKnowledge + dispatchNotes + projectSkills + previousAttempt;
+  const estimatedTokens = estimateTokensFromBytes(totalBytes);
+  const contextTokens = knownContextTokensFor(input.model);
+  const contextPct = contextTokens === null || contextTokens === 0 ? null : estimatedTokens / contextTokens * 100;
+  return {
+    totalBytes,
+    rows,
+    groups: {
+      stage: stage2,
+      inputs,
+      experts: expertBodies + expertKnowledge,
+      expertBodies,
+      expertKnowledge,
+      dispatchNotes,
+      projectSkills,
+      previousAttempt,
+      questions: input.questionsBytes ?? 0
+    },
+    truncatedInputs: input.truncatedInputs,
+    limitBytes: input.limitBytes,
+    overLimit: totalBytes > input.limitBytes,
+    model: input.model,
+    estimatedTokens,
+    contextTokens,
+    contextPct,
+    contextWarns: contextPct !== null && contextPct >= CONTEXT_WARN_PCT
+  };
+}
+function questionsBytesOf(stageMd) {
+  const lines = stageMd.split(`
+`);
+  const start = lines.findIndex((line) => line.trim() === "## Questions");
+  if (start === -1)
+    return 0;
+  let end = lines.length;
+  for (let i = start + 1;i < lines.length; i++) {
+    if ((lines[i] ?? "").startsWith("## ")) {
+      end = i;
+      break;
+    }
+  }
+  return byteLength(lines.slice(start, end).join(`
+`));
+}
+function renderLedger(ledger3, maxRows = 8) {
+  const g = ledger3.groups;
+  const lines = [
+    `context ${bytes(ledger3.totalBytes)} of ${bytes(ledger3.limitBytes)} ` + `(~${tokens2(ledger3.estimatedTokens)} tok${windowClause(ledger3)})`,
+    `  stage ${bytes(g.stage)}${g.questions === 0 ? "" : ` (questions ${bytes(g.questions)})`}` + ` · inputs ${bytes(g.inputs)} · experts ${bytes(g.experts)}` + ` (bodies ${bytes(g.expertBodies)}, knowledge ${bytes(g.expertKnowledge)})` + (g.dispatchNotes === 0 ? "" : ` · dispatch notes ${bytes(g.dispatchNotes)}`) + (g.projectSkills === 0 ? "" : ` · project skills ${bytes(g.projectSkills)}`) + (g.previousAttempt === 0 ? "" : ` · previous attempt ${bytes(g.previousAttempt)}`)
+  ];
+  const biggest = [...ledger3.rows].filter((row2) => row2.kind !== "inputs" || row2.name !== "Inputs").sort((a, b) => b.bytes - a.bytes).slice(0, maxRows);
+  for (const row2 of biggest) {
+    lines.push(`  ${label(row2)} ${bytes(row2.bytes)}`);
+  }
+  return lines;
+}
+function renderRefusal(ledger3, stageId) {
+  const g = ledger3.groups;
+  const lines = [
+    `[tldrx] context: refusing to start stage "${stageId}" — the prompt is ` + `${bytes(ledger3.totalBytes)} and prompt_max_bytes is ${bytes(ledger3.limitBytes)}.`,
+    ...renderLedger(ledger3, 5),
+    "Shrink it, then run again:"
+  ];
+  if (g.inputs >= g.experts) {
+    lines.push(`  inputs are the biggest section (${bytes(g.inputs)}) — lower \`inputs_max_bytes\` ` + "in the stage file, declare fewer inputs, or split the seed with `tldrx seed triage`.");
+  }
+  if (g.experts > 0) {
+    lines.push(`  experts are ${bytes(g.experts)} (${bytes(g.expertKnowledge)} of it trained knowledge) — ` + "lower `knowledge_max_bytes` in the stage file, or narrow the stage's `experts:` list.");
+  }
+  lines.push(`  or raise the ceiling deliberately: \`prompt_max_bytes\` in the stage file, ` + "or `--prompt-max-bytes <n>` for this one invocation.");
+  return lines;
+}
+function renderContextWarning(ledger3) {
+  if (!ledger3.contextWarns || ledger3.contextTokens === null || ledger3.contextPct === null)
+    return [];
+  return [
+    `note: this prompt is ~${tokens2(ledger3.estimatedTokens)} tokens, ` + `${ledger3.contextPct.toFixed(0)}% of ${shortModel2(ledger3.model)}'s ~${tokens2(ledger3.contextTokens)}-token ` + "window [assumption: both the window and the ~3.6 bytes/token ratio are estimates, " + "see src/core/budget/modelPrices.ts]. The sub-agent still has to fit its own reading and " + "its answer in what is left."
+  ];
+}
+function windowClause(ledger3) {
+  if (ledger3.contextTokens === null || ledger3.contextPct === null)
+    return "";
+  return `, ${ledger3.contextPct.toFixed(0)}% of ${shortModel2(ledger3.model)}'s ` + `~${tokens2(ledger3.contextTokens)} window`;
+}
+function label(row2) {
+  switch (row2.kind) {
+    case "stage":
+      return "stage.md";
+    case "inputs":
+      return `input ${row2.name}`;
+    case "expert-body":
+      return `expert ${row2.name} body`;
+    case "expert-knowledge":
+      return `expert ${row2.name} knowledge`;
+    case "preamble":
+      return "stage preamble";
+    case "dispatch-notes":
+      return "dispatch notes";
+    case "project-skills":
+      return "project skills";
+    case "previous-attempt":
+      return "previous attempt";
+  }
+}
+function shortModel2(model2) {
+  return model2 === null || model2 === "" ? "the default model" : model2;
+}
+function bytes(count) {
+  return count < 1024 ? `${String(count)} B` : `${(count / 1024).toFixed(1)} KB`;
+}
+function tokens2(count) {
+  return count < 1000 ? String(count) : `${(count / 1000).toFixed(1)}k`;
+}
+
+// src/core/facilitator/stageSpec.ts
+var DEFAULT_STACK_EXPERTS = true;
+var DEFAULT_DRY_RUN_ALLOWED = true;
+function loadStageSpec(root2, scope, stageId) {
+  const preset = loadWorkflowPreset(root2, scope);
+  const planned = preset.stages.find((s) => s.id === stageId);
+  if (planned === undefined) {
+    throw new PresetError(`stage '${stageId}' is not in workflow '${preset.name}' (${preset.source})`);
+  }
+  const over = overlay(root2, scope, stageId);
+  return {
+    planned,
+    scope: preset.name,
+    skips: preset.skips,
+    ...over,
+    tuning: { ...over.tuning, attempts: planned.attempts },
+    ...inputSplit(root2, stageId)
+  };
+}
+function overlay(root2, scope, stageId) {
+  const stageDoc = readDoc(stagePath(root2, stageId));
+  const workflowDoc = readDoc(workflowPath(root2, scope));
+  let skipIf = null;
+  const entries = isRecord(workflowDoc) && Array.isArray(workflowDoc.stages) ? workflowDoc.stages : [];
+  for (const entry of entries) {
+    if (!isRecord(entry) || entry.id !== stageId)
+      continue;
+    if (typeof entry.skip_if === "string" && entry.skip_if !== "")
+      skipIf = entry.skip_if;
+  }
+  const questions = isRecord(stageDoc) && isRecord(stageDoc.questions) ? stageDoc.questions : null;
+  return {
+    stackExperts: isRecord(stageDoc) && typeof stageDoc.stack_experts === "boolean" ? stageDoc.stack_experts : DEFAULT_STACK_EXPERTS,
+    knowledgeMaxBytes: byteKey(stageDoc, "knowledge_max_bytes") ?? byteKey(stageDoc, "expert_knowledge_bytes") ?? DEFAULT_KNOWLEDGE_MAX_BYTES,
+    inputsMaxBytes: byteKey(stageDoc, "inputs_max_bytes") ?? DEFAULT_INPUTS_MAX_BYTES,
+    promptMaxBytes: byteKey(stageDoc, "prompt_max_bytes") ?? DEFAULT_PROMPT_MAX_BYTES,
+    maxReads: byteKey(stageDoc, "max_reads") ?? defaultMaxReads(stageId),
+    parallel: parallelKey(workflowDoc, stageId) ?? byteKey(stageDoc, "parallel"),
+    reviewer: reviewerOverride(isRecord(stageDoc) ? stageDoc.reviewer : undefined),
+    reviewerByStakes: reviewerByStakesMap(isRecord(stageDoc) ? stageDoc.reviewer_by_stakes : undefined),
+    tuning: readStageTuning(stageDoc),
+    dryRunAllowed: isRecord(stageDoc) && typeof stageDoc.dry_run_allowed === "boolean" ? stageDoc.dry_run_allowed : DEFAULT_DRY_RUN_ALLOWED,
+    skipIf,
+    questionsMax: questions !== null && typeof questions.max === "number" ? questions.max : null
+  };
+}
+function inputSplit(root2, stageId) {
+  const doc = readDoc(stagePath(root2, stageId));
+  const inputs = isRecord(doc) ? doc.inputs : undefined;
+  const topLevelSeed = isRecord(doc) && doc.seed === true;
+  if (isRecord(inputs)) {
+    return {
+      requiredInputs: strings2(inputs.required),
+      optionalInputs: strings2(inputs.optional),
+      seedInputs: inputs.seed === true || topLevelSeed
+    };
+  }
+  return { requiredInputs: [], optionalInputs: strings2(inputs), seedInputs: topLevelSeed };
+}
+function reviewerOverride(value) {
+  if (!isRecord(value))
+    return null;
+  const model2 = typeof value.model === "string" && value.model !== "" ? value.model : undefined;
+  const effort2 = EFFORT_LEVELS.includes(String(value.effort)) ? value.effort : undefined;
+  if (model2 === undefined && effort2 === undefined)
+    return null;
+  return { ...model2 === undefined ? {} : { model: model2 }, ...effort2 === undefined ? {} : { effort: effort2 } };
+}
+function reviewerByStakesMap(value) {
+  if (!isRecord(value))
+    return {};
+  const out = {};
+  for (const [key, entry] of Object.entries(value)) {
+    const override = reviewerOverride(entry);
+    if (override !== null)
+      out[key] = override;
+  }
+  return out;
+}
+function parallelKey(workflowDoc, stageId) {
+  if (!isRecord(workflowDoc))
+    return null;
+  const entry = workflowDoc[stageId];
+  return isRecord(entry) ? byteKey(entry, "parallel") : null;
+}
+function byteKey(doc, key) {
+  if (!isRecord(doc))
+    return null;
+  const value = doc[key];
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0)
+    return null;
+  return Math.trunc(value);
+}
+function readDoc(path) {
+  if (path === null || !existsSync44(path))
+    return null;
+  try {
+    return parseYaml(readFileSync40(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function strings2(value) {
+  return Array.isArray(value) ? value.filter((v) => typeof v === "string") : [];
+}
+
+// src/core/run/checks.ts
 var WRITE_TIME_ONLY = ["no-reask", "budget-gate", "dod"];
 async function runChecks(checks, ctx) {
   const outcomes = [];
@@ -29964,12 +30553,12 @@ function checkClaimSources(ctx) {
       continue;
     }
     for (const hit of hits) {
-      if (!existsSync44(hit.absolute)) {
+      if (!existsSync45(hit.absolute)) {
         if (isHandoffOutput)
           failures.push(`${hit.path} was declared but never written`);
         continue;
       }
-      const text3 = readFileSync39(hit.absolute, "utf8");
+      const text3 = readFileSync41(hit.absolute, "utf8");
       if (isHandoffOutput || isHandoff(text3)) {
         handoffs++;
         const validation = validateHandoff(text3, srcCtx);
@@ -30120,12 +30709,63 @@ function checkPlan(ctx) {
     return { id: "plan", status: "failed", detail: describePlanIssues(issues) };
   }
   const model2 = branchModelFor(basename10(ctx.runDir), report2.epicChain);
+  const over = planPricesOverStage(ctx, planDir);
   return {
     id: "plan",
     status: "passed",
-    detail: `${report2.epicCount} epic(s), ${report2.storyCount} story(ies), ${report2.waveCount} wave(s)` + ` — ${describeBranchModel(model2)}`
+    detail: `${report2.epicCount} epic(s), ${report2.storyCount} story(ies), ${report2.waveCount} wave(s)` + ` — ${describeBranchModel(model2)}${over === null ? "" : ` — ${over}`}`
   };
 }
+function planPricesOverStage(ctx, planDir) {
+  const run = rawYaml(join62(ctx.runDir, "run.yml"));
+  if (run === null || typeof run.scope !== "string" || !Array.isArray(run.phases))
+    return null;
+  const stage2 = run.phases.find((phase) => phase.id === BUILD_PHASE2)?.stages?.[0];
+  if (stage2 === undefined || typeof stage2.id !== "string" || typeof stage2.budget_usd !== "number")
+    return null;
+  const progress = buildProgress(ctx.runDir);
+  if (progress === null || progress.implicit)
+    return null;
+  const ids = new Set(progress.waves.flatMap((wave) => wave.stories.map((story) => story.id)));
+  const prices = loadPlanPrices(planDir, ids).prices;
+  if (prices.size === 0)
+    return null;
+  let spec = null;
+  try {
+    spec = loadStageSpec(ctx.root, run.scope, stage2.id);
+  } catch {
+    spec = null;
+  }
+  const budget = rawYaml(join62(ctx.runDir, "budget.yml"));
+  const perAgentMax = typeof budget?.per_agent_max_usd === "number" ? budget.per_agent_max_usd : Infinity;
+  const budgetUsd = stage2.budget_usd;
+  const parts = {
+    prices,
+    storyCount: ids.size,
+    budgetUsd,
+    maxBudgetUsd: Math.min(budgetUsd, perAgentMax),
+    agentCap: (share = 1) => round23(Math.min(budgetUsd * share, perAgentMax)),
+    ...spec === null ? {} : {
+      attempts: spec.tuning.attempts,
+      reviewerShare: spec.tuning.reviewerShare,
+      storyCapMultiplier: spec.tuning.storyCapMultiplier,
+      storyCapFloorUsd: spec.tuning.storyCapFloorUsd
+    }
+  };
+  const runId = basename10(ctx.runDir);
+  return planOverStageAdvisory(parts, {
+    raiseCommand: (usd3) => stageRaiseCommand(runId, BUILD_PHASE2, stage2.id, usd3)
+  });
+}
+function rawYaml(path) {
+  if (!existsSync45(path))
+    return null;
+  try {
+    return parseYaml(readFileSync41(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
 function checkSchema(ctx) {
   const pairs = [
     ["run.yml", validateRunFile],
@@ -30133,9 +30773,9 @@ function checkSchema(ctx) {
   ];
   for (const [name, validate2] of pairs) {
     const path = join62(ctx.runDir, name);
-    if (!existsSync44(path))
+    if (!existsSync45(path))
       return { id: "schema", status: "failed", detail: `${name} is missing` };
-    const validation = validate2(parseYaml(readFileSync39(path, "utf8")));
+    const validation = validate2(parseYaml(readFileSync41(path, "utf8")));
     if (!validation.ok) {
       const first2 = validation.issues[0];
       return { id: "schema", status: "failed", detail: `${name}: ${first2?.path ?? ""} ${first2?.message ?? ""}`.trim() };
@@ -30334,7 +30974,7 @@ var MISSING_QUESTIONS = "questions.md is a declared output of this stage and was
 function questionsCondition(runDir, phaseId, planned) {
   const path = join63(runDir, phaseId, "questions.md");
   if (declaresQuestions(planned)) {
-    if (!existsSync45(path)) {
+    if (!existsSync46(path)) {
       return { id: "questions", ok: false, detail: MISSING_QUESTIONS };
     }
     const unreadable = unreadableHeadings(path);
@@ -30357,17 +30997,17 @@ function declaresQuestions(planned) {
   return planned.outputs.some((path) => path.endsWith("questions.md"));
 }
 function unreadableHeadings(path) {
-  if (!existsSync45(path))
+  if (!existsSync46(path))
     return [];
   try {
-    return unreadableQuestionHeadings(readFileSync40(path, "utf8"));
+    return unreadableQuestionHeadings(readFileSync42(path, "utf8"));
   } catch {
     return [];
   }
 }
 function parsedBlocks(path) {
   try {
-    return parseQuestions(readFileSync40(path, "utf8")).blocks.length;
+    return parseQuestions(readFileSync42(path, "utf8")).blocks.length;
   } catch {
     return 0;
   }
@@ -30376,7 +31016,7 @@ function budgetCondition(input) {
   if (isHostTokens(input.budget, input.phaseId)) {
     return { id: "budget", ok: true, detail: "n/a (host-tokens economy)" };
   }
-  const spent = round23(input.stage.tasks.reduce((sum, task2) => sum + (task2.cost_usd ?? 0), 0));
+  const spent = round24(input.stage.tasks.reduce((sum, task2) => sum + (task2.cost_usd ?? 0), 0));
   const unmetered = input.stage.tasks.filter((task2) => task2.cost_usd === null).length;
   const phase = input.budget.phases.find((entry) => entry.id === input.phaseId);
   const phaseSpent = phase === undefined ? 0 : phase.spent_usd;
@@ -30446,10 +31086,10 @@ async function boundaryCondition(input) {
   return { id: "boundary", ...verdict };
 }
 function openQuestions(path) {
-  if (!existsSync45(path))
+  if (!existsSync46(path))
     return { blocking: [], advisory: [] };
   try {
-    const open = openBlocks(parseQuestions(readFileSync40(path, "utf8")).blocks);
+    const open = openBlocks(parseQuestions(readFileSync42(path, "utf8")).blocks);
     return {
       blocking: open.filter((block2) => !isAdvisory(block2)).map((block2) => block2.id),
       advisory: open.filter((block2) => isAdvisory(block2)).map((block2) => block2.id)
@@ -30458,7 +31098,7 @@ function openQuestions(path) {
     return { blocking: ["(questions.md does not parse)"], advisory: [] };
   }
 }
-function round23(n) {
+function round24(n) {
   return Math.round(n * 100) / 100;
 }
 
@@ -30527,7 +31167,7 @@ function describeGateSignature(sig) {
 import { basename as basename11, join as join65 } from "node:path";
 
 // src/core/facilitator/skipIf.ts
-import { existsSync as existsSync46, readdirSync as readdirSync21, readFileSync as readFileSync41 } from "node:fs";
+import { existsSync as existsSync47, readdirSync as readdirSync21, readFileSync as readFileSync43 } from "node:fs";
 import { join as join64 } from "node:path";
 var SKIP_IF_RE = /^(stories|repos|questions)(<=|>=|==|<|>)(\d{1,4})$/;
 
@@ -30564,7 +31204,7 @@ function countSkipInputs(runDir, run) {
 }
 function countStories(runDir) {
   const dir = join64(runDir, "03-plan", "stories");
-  if (!existsSync46(dir))
+  if (!existsSync47(dir))
     return 0;
   try {
     return readdirSync21(dir).filter((name) => name.endsWith(".md")).length;
@@ -30587,10 +31227,10 @@ function phaseDirs(runDir) {
   }
 }
 function blockingQuestionIds(path) {
-  if (!existsSync46(path))
+  if (!existsSync47(path))
     return [];
   try {
-    return openBlocks(parseQuestions(readFileSync41(path, "utf8")).blocks).filter((block2) => !isAdvisory(block2)).map((block2) => block2.id);
+    return openBlocks(parseQuestions(readFileSync43(path, "utf8")).blocks).filter((block2) => !isAdvisory(block2)).map((block2) => block2.id);
   } catch {
     return [];
   }
@@ -30702,7 +31342,7 @@ function cancelledMessage(cancelled) {
 }
 
 // src/core/run/operatorNote.ts
-import { existsSync as existsSync47 } from "node:fs";
+import { existsSync as existsSync48 } from "node:fs";
 import { join as join66 } from "node:path";
 var EXIT_OK3 = 0;
 var EXIT_USAGE2 = 1;
@@ -30719,7 +31359,7 @@ function addOperatorNote(options) {
       ]
     };
   }
-  if (options.soleArgument === true && existsSync47(join66(options.root, PROJECT_WORK_DIR, text3))) {
+  if (options.soleArgument === true && existsSync48(join66(options.root, PROJECT_WORK_DIR, text3))) {
     return {
       code: EXIT_USAGE2,
       lines: [
@@ -30963,8 +31603,8 @@ function renderGates(rows, verbose = false) {
   rows.forEach((row2, i) => {
     const head2 = `  ${(where[i] ?? "").padEnd(width)}  ${row2.policy.padEnd(5)}  `;
     const tail = tails[i] ?? "";
-    const describe5 = described[i] ?? "";
-    lines.push(tail === "" ? head2 + describe5 : `${head2}${describe5.padEnd(tailWidth)}  ${tail}`);
+    const describe6 = described[i] ?? "";
+    lines.push(tail === "" ? head2 + describe6 : `${head2}${describe6.padEnd(tailWidth)}  ${tail}`);
     if (verbose)
       lines.push(...gateDetail(row2));
   });
@@ -31079,7 +31719,7 @@ function width(rows, of) {
 }
 
 // src/core/run/decisionCards.ts
-import { existsSync as existsSync48, readFileSync as readFileSync42 } from "node:fs";
+import { existsSync as existsSync49, readFileSync as readFileSync44 } from "node:fs";
 import { join as join67 } from "node:path";
 function questionsCard(ctx) {
   const blocks = openQuestionBlocks(join67(ctx.runDir, ctx.phaseId, "questions.md"));
@@ -31194,10 +31834,10 @@ function toRecommendation2(entry) {
   return { option: entry.option, why: entry.why, src: entry.src };
 }
 function openQuestionBlocks(path) {
-  if (!existsSync48(path))
+  if (!existsSync49(path))
     return [];
   try {
-    return openBlocks(parseQuestions(readFileSync42(path, "utf8")).blocks);
+    return openBlocks(parseQuestions(readFileSync44(path, "utf8")).blocks);
   } catch {
     return [];
   }
@@ -31225,17 +31865,17 @@ function readRecommendations(ctx) {
   return out;
 }
 function readOrNull(path) {
-  if (!existsSync48(path))
+  if (!existsSync49(path))
     return null;
   try {
-    return readFileSync42(path, "utf8");
+    return readFileSync44(path, "utf8");
   } catch {
     return null;
   }
 }
 
 // src/core/run/questionCards.ts
-import { existsSync as existsSync49, readFileSync as readFileSync43 } from "node:fs";
+import { existsSync as existsSync50, readFileSync as readFileSync45 } from "node:fs";
 import { join as join68 } from "node:path";
 var QUESTION_PHASES = PHASE_IDS;
 var NEEDS_OPTIONS = "NEEDS OPTIONS";
@@ -31243,11 +31883,11 @@ function collectQuestionCards(runDir, runId) {
   const cards = [];
   for (const phase of QUESTION_PHASES) {
     const path = join68(runDir, phase, "questions.md");
-    if (!existsSync49(path))
+    if (!existsSync50(path))
       continue;
     let text3;
     try {
-      text3 = readFileSync43(path, "utf8");
+      text3 = readFileSync45(path, "utf8");
     } catch {
       continue;
     }
@@ -31261,7 +31901,7 @@ function collectQuestionCards(runDir, runId) {
 function countQuestionFiles(runDir) {
   let found = 0;
   for (const phase of QUESTION_PHASES) {
-    if (existsSync49(join68(runDir, phase, "questions.md")))
+    if (existsSync50(join68(runDir, phase, "questions.md")))
       found++;
   }
   return found;
@@ -31340,14 +31980,14 @@ function cardBlock(card, n, total) {
 }
 
 // src/core/facilitator/autoAnswer.ts
-import { existsSync as existsSync53, readFileSync as readFileSync47 } from "node:fs";
+import { existsSync as existsSync54, readFileSync as readFileSync49 } from "node:fs";
 import { join as join71 } from "node:path";
 
 // src/core/answers/captureAnswers.ts
-import { existsSync as existsSync52, readFileSync as readFileSync46, writeFileSync as writeFileSync11 } from "node:fs";
+import { existsSync as existsSync53, readFileSync as readFileSync48, writeFileSync as writeFileSync11 } from "node:fs";
 
 // src/core/answers/stampSuperseded.ts
-import { appendFileSync as appendFileSync2, existsSync as existsSync50, readFileSync as readFileSync44, statSync as statSync16 } from "node:fs";
+import { appendFileSync as appendFileSync2, existsSync as existsSync51, readFileSync as readFileSync46, statSync as statSync17 } from "node:fs";
 import { isAbsolute as isAbsolute6, join as join69, relative as relative11 } from "node:path";
 var STAMP_MARKER = "tldrx:superseded";
 var AFFECTS_KEY = "affects";
@@ -31387,7 +32027,7 @@ function stampSuperseded(runDir, questionsPath, block2, fact, at) {
   const questionsRel = runRelative(runDir, questionsPath) ?? "questions.md";
   const stamped = [];
   for (const doc of affectedDocs(runDir, questionsPath, block2)) {
-    const text3 = readFileSync44(doc.abs, "utf8");
+    const text3 = readFileSync46(doc.abs, "utf8");
     if (isStamped(text3, fact))
       continue;
     const lead = text3 === "" ? "" : text3.endsWith(`
@@ -31412,7 +32052,7 @@ function resolveInRun(runDir, raw) {
     const rel = runRelative(runDir, candidate);
     if (rel === null)
       continue;
-    if (!existsSync50(candidate) || !statSync16(candidate).isFile())
+    if (!existsSync51(candidate) || !statSync17(candidate).isFile())
       continue;
     return rel;
   }
@@ -31461,18 +32101,18 @@ function reposFromAffects(affects, repoNames) {
 }
 
 // src/core/answers/raiseConflict.ts
-import { appendFileSync as appendFileSync3, existsSync as existsSync51, readFileSync as readFileSync45 } from "node:fs";
+import { appendFileSync as appendFileSync3, existsSync as existsSync52, readFileSync as readFileSync47 } from "node:fs";
 import { join as join70 } from "node:path";
 var RAISED_BY = "tldrx";
 function nextQuestionId(runDir) {
   let highest = 0;
   for (const phase of QUESTION_PHASES) {
     const path = join70(runDir, phase, "questions.md");
-    if (!existsSync51(path))
+    if (!existsSync52(path))
       continue;
     let blocks;
     try {
-      blocks = parseQuestions(readFileSync45(path, "utf8")).blocks;
+      blocks = parseQuestions(readFileSync47(path, "utf8")).blocks;
     } catch {
       continue;
     }
@@ -31552,9 +32192,9 @@ function factWasTruncated(title, answer) {
   return `${title} — ${answer}`.length > MAX_FACT_CHARS;
 }
 function captureAnswers(questionsPath, ctx) {
-  if (!existsSync52(questionsPath))
+  if (!existsSync53(questionsPath))
     return [];
-  let doc = parseQuestions(readFileSync46(questionsPath, "utf8"));
+  let doc = parseQuestions(readFileSync48(questionsPath, "utf8"));
   const answered = detectAnswered(doc.blocks);
   if (answered.length === 0)
     return [];
@@ -31684,12 +32324,12 @@ function markSuperseded(log, ctx, questionsPath, block2, fact) {
   }
 }
 function supersedeAnswer(questionsPath, qid, text3, ctx) {
-  if (!existsSync52(questionsPath))
+  if (!existsSync53(questionsPath))
     throw new AnswerError(`no questions file at ${questionsPath}`);
   const answer = text3.trim();
   if (answer === "")
     throw new AnswerError("a superseding answer cannot be empty");
-  const doc = parseQuestions(readFileSync46(questionsPath, "utf8"));
+  const doc = parseQuestions(readFileSync48(questionsPath, "utf8"));
   const block2 = doc.blocks.find((b) => b.id === qid);
   if (block2 === undefined)
     throw new AnswerError(`${qid} is not in ${questionsPath}`);
@@ -31767,11 +32407,11 @@ function supersedeAnswer(questionsPath, qid, text3, ctx) {
   return conflict === undefined ? result2 : { ...result2, conflict };
 }
 function writeAnswerSlot(questionsPath, qid, text3) {
-  if (!existsSync52(questionsPath))
+  if (!existsSync53(questionsPath))
     throw new AnswerError(`no questions file at ${questionsPath}`);
   if (text3.trim() === "")
     throw new AnswerError("an answer cannot be empty");
-  const doc = parseQuestions(readFileSync46(questionsPath, "utf8"));
+  const doc = parseQuestions(readFileSync48(questionsPath, "utf8"));
   const block2 = doc.blocks.find((b) => b.id === qid);
   if (block2 === undefined)
     throw new AnswerError(`${qid} is not in ${questionsPath}`);
@@ -31793,11 +32433,11 @@ function answerRecommended(ctx) {
   for (const phase of QUESTION_PHASES) {
     const rel = `${phase}/questions.md`;
     const path = join71(ctx.runDir, phase, "questions.md");
-    if (!existsSync53(path))
+    if (!existsSync54(path))
       continue;
     const ids = blockingIds(path);
     for (const id of ids) {
-      const block2 = openBlocks(parseQuestions(readFileSync47(path, "utf8")).blocks).find((b) => b.id === id);
+      const block2 = openBlocks(parseQuestions(readFileSync49(path, "utf8")).blocks).find((b) => b.id === id);
       if (block2 === undefined)
         continue;
       if (pinnedToPerson(block2)) {
@@ -31839,23 +32479,23 @@ function answerRecommended(ctx) {
 }
 function blockingIds(path) {
   try {
-    return openBlocks(parseQuestions(readFileSync47(path, "utf8")).blocks).filter((block2) => !isAdvisory(block2)).map((block2) => block2.id);
+    return openBlocks(parseQuestions(readFileSync49(path, "utf8")).blocks).filter((block2) => !isAdvisory(block2)).map((block2) => block2.id);
   } catch {
     return [];
   }
 }
 
 // src/core/notify/declaration.ts
-import { existsSync as existsSync54, readFileSync as readFileSync48 } from "node:fs";
+import { existsSync as existsSync55, readFileSync as readFileSync50 } from "node:fs";
 import { join as join72 } from "node:path";
 var NOTIFY_TIMEOUT_MS = 30000;
 function readNotifyDeclaration(root2) {
   const path = join72(root2, PROJECT_WORKSPACE_FILE);
-  if (!existsSync54(path))
+  if (!existsSync55(path))
     return null;
   let parsed;
   try {
-    parsed = parseYaml(readFileSync48(path, "utf8"));
+    parsed = parseYaml(readFileSync50(path, "utf8"));
   } catch {
     return null;
   }
@@ -32259,7 +32899,7 @@ import { mkdirSync as mkdirSync12, writeFileSync as writeFileSync12 } from "node
 import { dirname as dirname12, join as join74 } from "node:path";
 
 // src/core/run/closeRun.ts
-import { existsSync as existsSync55, readFileSync as readFileSync49 } from "node:fs";
+import { existsSync as existsSync56, readFileSync as readFileSync51 } from "node:fs";
 import { join as join73, relative as relative12, resolve as resolve10, sep as sep9 } from "node:path";
 
 // src/core/facts/decidedTally.ts
@@ -32304,11 +32944,11 @@ function collectOpenQuestions(runDir) {
   for (const phase of QUESTION_PHASES) {
     const rel = `${phase}/questions.md`;
     const abs = join73(runDir, phase, "questions.md");
-    if (!existsSync55(abs))
+    if (!existsSync56(abs))
       continue;
     let text3;
     try {
-      text3 = readFileSync49(abs, "utf8");
+      text3 = readFileSync51(abs, "utf8");
     } catch {
       continue;
     }
@@ -32647,11 +33287,11 @@ function event2(ts, run, stage2, type, actor, payload) {
 
 // src/core/facilitator/runNext.ts
 import { rmSync as rmSync10 } from "node:fs";
-import { mkdirSync as mkdirSync19, readFileSync as readFileSync74, writeFileSync as writeFileSync18 } from "node:fs";
+import { mkdirSync as mkdirSync19, readFileSync as readFileSync75, writeFileSync as writeFileSync19 } from "node:fs";
 import { join as join100, relative as relative18 } from "node:path";
 
 // src/core/run/agentGate.ts
-import { existsSync as existsSync56, readFileSync as readFileSync50 } from "node:fs";
+import { existsSync as existsSync57, readFileSync as readFileSync52 } from "node:fs";
 var BUDGET_DECISION_EVENTS = ["budget.raised", "budget.blocked"];
 async function evaluateAgentGate(input) {
   const auto = await evaluateAutoGate(input);
@@ -32740,17 +33380,17 @@ function describeAgentFallthroughs(fallthroughs) {
   return fallthroughs.map((f) => `  ${f.trigger}: ${f.detail}`);
 }
 function readOrNull2(path) {
-  if (!existsSync56(path))
+  if (!existsSync57(path))
     return null;
   try {
-    return readFileSync50(path, "utf8");
+    return readFileSync52(path, "utf8");
   } catch {
     return null;
   }
 }
 
 // src/core/build/carriedRows.ts
-import { existsSync as existsSync57, readFileSync as readFileSync51, readdirSync as readdirSync22 } from "node:fs";
+import { existsSync as existsSync58, readFileSync as readFileSync53, readdirSync as readdirSync22 } from "node:fs";
 import { join as join75 } from "node:path";
 
 // src/core/build/unownedFindings.ts
@@ -32784,7 +33424,7 @@ function unownedFindings(carried, declared, repoNames) {
 function declaredPhases(runDir) {
   let doc;
   try {
-    doc = parseYaml(readFileSync51(join75(runDir, "run.yml"), "utf8"));
+    doc = parseYaml(readFileSync53(join75(runDir, "run.yml"), "utf8"));
   } catch {
     return [];
   }
@@ -32810,7 +33450,7 @@ function scanStories(runDir) {
   const seen = new Set;
   for (const phase of phaseDirsOf(runDir)) {
     const dir = join75(runDir, phase, STORIES_DIR);
-    if (!existsSync57(dir))
+    if (!existsSync58(dir))
       continue;
     let names;
     try {
@@ -32826,7 +33466,7 @@ function scanStories(runDir) {
       const rel = `${phase}/${STORIES_DIR}/${name}`;
       let text3;
       try {
-        text3 = readFileSync51(join75(dir, name), "utf8");
+        text3 = readFileSync53(join75(dir, name), "utf8");
       } catch (error) {
         unreadable.push({ rel, reason: `the file could not be read — ${String(error)}` });
         continue;
@@ -32889,404 +33529,6 @@ function carriedDetailLines(report2) {
   return [...report2.rows.map(carriedCardLine), ...report2.unreadable.map(unreadableCardLine)];
 }
 
-// src/core/facilitator/stageSpec.ts
-import { existsSync as existsSync58, readFileSync as readFileSync53 } from "node:fs";
-
-// src/core/facilitator/seedInputs.ts
-import { readFileSync as readFileSync52, statSync as statSync17 } from "node:fs";
-var DEFAULT_INPUTS_MAX_BYTES = 256 * 1024;
-var MAX_SEED_INLINE_BYTES = 64 * 1024;
-var MIN_SLICE_BYTES = 2 * 1024;
-function inlineInputs(declared, options) {
-  const budget = options.budgetBytes ?? DEFAULT_INPUTS_MAX_BYTES;
-  const exempt = options.exempt ?? new Set;
-  const inputs = [];
-  const truncated = [];
-  let spent = 0;
-  let seedOverflowed = false;
-  for (const path of declared) {
-    const abs = resolveDeclared(path, options.ctx);
-    if (exempt.has(path)) {
-      inputs.push({ path, content: readOrEmpty3(abs) });
-      continue;
-    }
-    const size = sizeOf4(abs);
-    const room = budget - spent;
-    if (size <= room) {
-      spent += size;
-      inputs.push({ path, content: readOrEmpty3(abs) });
-      continue;
-    }
-    if (options.seed.has(path))
-      seedOverflowed = true;
-    if (room >= MIN_SLICE_BYTES) {
-      spent += room;
-      truncated.push({ path, totalBytes: size, inlinedBytes: room });
-      inputs.push({ path, content: slice(abs, room), inlinedBytes: room, totalBytes: size });
-      continue;
-    }
-    truncated.push({ path, totalBytes: size, inlinedBytes: 0 });
-    inputs.push({ path, content: "", inlinedBytes: 0, totalBytes: size });
-  }
-  return {
-    inputs,
-    note: describe5(budget, truncated, seedOverflowed),
-    truncated,
-    inlinedBytes: spent,
-    budgetBytes: budget
-  };
-}
-function describe5(budget, truncated, seedOverflowed) {
-  if (truncated.length === 0)
-    return null;
-  const listed = truncated.map((entry) => `${entry.path} (${entry.totalBytes.toLocaleString("en-US")} B` + `${entry.inlinedBytes === 0 ? ", none inlined" : `, first ${entry.inlinedBytes.toLocaleString("en-US")} B only`})`).join("; ");
-  const fix = seedOverflowed ? "raise `inputs_max_bytes` in the stage file or split the seed (`tldrx seed triage`)" : "raise `inputs_max_bytes` in the stage file";
-  return `truncated inputs: ${listed} — the ${budget.toLocaleString("en-US")}-byte ` + `\`inputs_max_bytes\` budget ran out. ${fix}. ` + "Work from what IS inlined and say in your handoff what you could not read.";
-}
-function describeTruncatedInputs(result2) {
-  return result2.truncated.map((entry) => `truncated input: ${entry.path} (${entry.totalBytes.toLocaleString("en-US")} B` + `${entry.inlinedBytes === 0 ? ", none inlined" : `, ${entry.inlinedBytes.toLocaleString("en-US")} B inlined`})` + ` — raise inputs_max_bytes (now ${result2.budgetBytes.toLocaleString("en-US")}) or split the seed`);
-}
-function capInputs(declared, max = MAX_STAGE_INPUTS) {
-  return declared.length <= max ? declared : declared.slice(0, max);
-}
-function sizeOf4(abs) {
-  try {
-    return statSync17(abs).size;
-  } catch {
-    return 0;
-  }
-}
-function slice(abs, bytes) {
-  try {
-    return readFileSync52(abs).subarray(0, bytes).toString("utf8");
-  } catch {
-    return "";
-  }
-}
-function readOrEmpty3(abs) {
-  try {
-    return readFileSync52(abs, "utf8");
-  } catch {
-    return "";
-  }
-}
-
-// src/core/budget/modelPrices.ts
-var CACHE_WRITE_MULTIPLIER = 1.25;
-var CACHE_READ_MULTIPLIER = 0.1;
-var BYTES_PER_TOKEN = 3.6;
-var MODEL_PRICES = [
-  { id: "opus", contextTokens: 200000, inputUsdPerMTok: 5, outputUsdPerMTok: 25 },
-  { id: "opus[1m]", contextTokens: 1e6, inputUsdPerMTok: 5, outputUsdPerMTok: 25 },
-  { id: "sonnet", contextTokens: 200000, inputUsdPerMTok: 2, outputUsdPerMTok: 10 },
-  { id: "sonnet[1m]", contextTokens: 1e6, inputUsdPerMTok: 2, outputUsdPerMTok: 10 },
-  { id: "haiku", contextTokens: 200000, inputUsdPerMTok: 1, outputUsdPerMTok: 5 }
-];
-var ONE_MILLION_MARKER = "[1m]";
-var ONE_MILLION_TOKENS = 1e6;
-function familyOf(id) {
-  return id.endsWith(ONE_MILLION_MARKER) ? id.slice(0, -ONE_MILLION_MARKER.length) : id;
-}
-function priceFor(model2) {
-  if (model2 === null)
-    return null;
-  const name = model2.toLowerCase();
-  const oneMillion = name.includes(ONE_MILLION_MARKER);
-  let best = null;
-  for (const row2 of MODEL_PRICES) {
-    const family = familyOf(row2.id);
-    if (family !== row2.id && !oneMillion)
-      continue;
-    if (!name.includes(family))
-      continue;
-    if (best === null || row2.id.length > best.id.length)
-      best = row2;
-  }
-  return best;
-}
-function knownContextTokensFor(model2) {
-  const priced = priceFor(model2);
-  if (priced !== null)
-    return priced.contextTokens;
-  if (model2 !== null && model2.toLowerCase().includes(ONE_MILLION_MARKER))
-    return ONE_MILLION_TOKENS;
-  return null;
-}
-function estimateTokensFromBytes(bytes) {
-  return Math.round(bytes / BYTES_PER_TOKEN);
-}
-
-// src/core/facilitator/contextLedger.ts
-var DEFAULT_PROMPT_MAX_BYTES = 400 * 1024;
-var CONTEXT_WARN_PCT = 80;
-function buildLedger(input) {
-  const rows = [];
-  let stage2 = 0;
-  let inputs = 0;
-  let expertBodies = 0;
-  let expertKnowledge = 0;
-  let dispatchNotes = 0;
-  let projectSkills = 0;
-  let previousAttempt = 0;
-  for (const part of input.parts) {
-    const bytes = byteLength(part.text);
-    switch (part.kind) {
-      case "preamble":
-        stage2 += bytes;
-        rows.push({ kind: part.kind, name: part.name, bytes });
-        break;
-      case "stage":
-        stage2 += bytes;
-        rows.push({ kind: part.kind, name: part.name, bytes });
-        break;
-      case "expert-body":
-        expertBodies += bytes;
-        rows.push({ kind: part.kind, name: part.name, bytes });
-        break;
-      case "expert-knowledge":
-        expertKnowledge += bytes;
-        rows.push({ kind: part.kind, name: part.name, bytes });
-        break;
-      case "dispatch-notes":
-        dispatchNotes += bytes;
-        rows.push({ kind: part.kind, name: part.name, bytes });
-        break;
-      case "project-skills":
-        projectSkills += bytes;
-        rows.push({ kind: part.kind, name: part.name, bytes });
-        break;
-      case "previous-attempt":
-        previousAttempt += bytes;
-        rows.push({ kind: part.kind, name: part.name, bytes });
-        break;
-      case "inputs":
-        inputs += bytes;
-        for (const file of input.inputBytes) {
-          rows.push({ kind: "inputs", name: file.path, bytes: file.bytes });
-        }
-        break;
-    }
-  }
-  const totalBytes = stage2 + inputs + expertBodies + expertKnowledge + dispatchNotes + projectSkills + previousAttempt;
-  const estimatedTokens = estimateTokensFromBytes(totalBytes);
-  const contextTokens = knownContextTokensFor(input.model);
-  const contextPct = contextTokens === null || contextTokens === 0 ? null : estimatedTokens / contextTokens * 100;
-  return {
-    totalBytes,
-    rows,
-    groups: {
-      stage: stage2,
-      inputs,
-      experts: expertBodies + expertKnowledge,
-      expertBodies,
-      expertKnowledge,
-      dispatchNotes,
-      projectSkills,
-      previousAttempt,
-      questions: input.questionsBytes ?? 0
-    },
-    truncatedInputs: input.truncatedInputs,
-    limitBytes: input.limitBytes,
-    overLimit: totalBytes > input.limitBytes,
-    model: input.model,
-    estimatedTokens,
-    contextTokens,
-    contextPct,
-    contextWarns: contextPct !== null && contextPct >= CONTEXT_WARN_PCT
-  };
-}
-function questionsBytesOf(stageMd) {
-  const lines = stageMd.split(`
-`);
-  const start = lines.findIndex((line) => line.trim() === "## Questions");
-  if (start === -1)
-    return 0;
-  let end = lines.length;
-  for (let i = start + 1;i < lines.length; i++) {
-    if ((lines[i] ?? "").startsWith("## ")) {
-      end = i;
-      break;
-    }
-  }
-  return byteLength(lines.slice(start, end).join(`
-`));
-}
-function renderLedger(ledger3, maxRows = 8) {
-  const g = ledger3.groups;
-  const lines = [
-    `context ${bytes(ledger3.totalBytes)} of ${bytes(ledger3.limitBytes)} ` + `(~${tokens2(ledger3.estimatedTokens)} tok${windowClause(ledger3)})`,
-    `  stage ${bytes(g.stage)}${g.questions === 0 ? "" : ` (questions ${bytes(g.questions)})`}` + ` · inputs ${bytes(g.inputs)} · experts ${bytes(g.experts)}` + ` (bodies ${bytes(g.expertBodies)}, knowledge ${bytes(g.expertKnowledge)})` + (g.dispatchNotes === 0 ? "" : ` · dispatch notes ${bytes(g.dispatchNotes)}`) + (g.projectSkills === 0 ? "" : ` · project skills ${bytes(g.projectSkills)}`) + (g.previousAttempt === 0 ? "" : ` · previous attempt ${bytes(g.previousAttempt)}`)
-  ];
-  const biggest = [...ledger3.rows].filter((row2) => row2.kind !== "inputs" || row2.name !== "Inputs").sort((a, b) => b.bytes - a.bytes).slice(0, maxRows);
-  for (const row2 of biggest) {
-    lines.push(`  ${label(row2)} ${bytes(row2.bytes)}`);
-  }
-  return lines;
-}
-function renderRefusal(ledger3, stageId) {
-  const g = ledger3.groups;
-  const lines = [
-    `[tldrx] context: refusing to start stage "${stageId}" — the prompt is ` + `${bytes(ledger3.totalBytes)} and prompt_max_bytes is ${bytes(ledger3.limitBytes)}.`,
-    ...renderLedger(ledger3, 5),
-    "Shrink it, then run again:"
-  ];
-  if (g.inputs >= g.experts) {
-    lines.push(`  inputs are the biggest section (${bytes(g.inputs)}) — lower \`inputs_max_bytes\` ` + "in the stage file, declare fewer inputs, or split the seed with `tldrx seed triage`.");
-  }
-  if (g.experts > 0) {
-    lines.push(`  experts are ${bytes(g.experts)} (${bytes(g.expertKnowledge)} of it trained knowledge) — ` + "lower `knowledge_max_bytes` in the stage file, or narrow the stage's `experts:` list.");
-  }
-  lines.push(`  or raise the ceiling deliberately: \`prompt_max_bytes\` in the stage file, ` + "or `--prompt-max-bytes <n>` for this one invocation.");
-  return lines;
-}
-function renderContextWarning(ledger3) {
-  if (!ledger3.contextWarns || ledger3.contextTokens === null || ledger3.contextPct === null)
-    return [];
-  return [
-    `note: this prompt is ~${tokens2(ledger3.estimatedTokens)} tokens, ` + `${ledger3.contextPct.toFixed(0)}% of ${shortModel2(ledger3.model)}'s ~${tokens2(ledger3.contextTokens)}-token ` + "window [assumption: both the window and the ~3.6 bytes/token ratio are estimates, " + "see src/core/budget/modelPrices.ts]. The sub-agent still has to fit its own reading and " + "its answer in what is left."
-  ];
-}
-function windowClause(ledger3) {
-  if (ledger3.contextTokens === null || ledger3.contextPct === null)
-    return "";
-  return `, ${ledger3.contextPct.toFixed(0)}% of ${shortModel2(ledger3.model)}'s ` + `~${tokens2(ledger3.contextTokens)} window`;
-}
-function label(row2) {
-  switch (row2.kind) {
-    case "stage":
-      return "stage.md";
-    case "inputs":
-      return `input ${row2.name}`;
-    case "expert-body":
-      return `expert ${row2.name} body`;
-    case "expert-knowledge":
-      return `expert ${row2.name} knowledge`;
-    case "preamble":
-      return "stage preamble";
-    case "dispatch-notes":
-      return "dispatch notes";
-    case "project-skills":
-      return "project skills";
-    case "previous-attempt":
-      return "previous attempt";
-  }
-}
-function shortModel2(model2) {
-  return model2 === null || model2 === "" ? "the default model" : model2;
-}
-function bytes(count) {
-  return count < 1024 ? `${String(count)} B` : `${(count / 1024).toFixed(1)} KB`;
-}
-function tokens2(count) {
-  return count < 1000 ? String(count) : `${(count / 1000).toFixed(1)}k`;
-}
-
-// src/core/facilitator/stageSpec.ts
-var DEFAULT_STACK_EXPERTS = true;
-var DEFAULT_DRY_RUN_ALLOWED = true;
-function loadStageSpec(root2, scope, stageId) {
-  const preset = loadWorkflowPreset(root2, scope);
-  const planned = preset.stages.find((s) => s.id === stageId);
-  if (planned === undefined) {
-    throw new PresetError(`stage '${stageId}' is not in workflow '${preset.name}' (${preset.source})`);
-  }
-  const over = overlay(root2, scope, stageId);
-  return {
-    planned,
-    scope: preset.name,
-    skips: preset.skips,
-    ...over,
-    tuning: { ...over.tuning, attempts: planned.attempts },
-    ...inputSplit(root2, stageId)
-  };
-}
-function overlay(root2, scope, stageId) {
-  const stageDoc = readDoc(stagePath(root2, stageId));
-  const workflowDoc = readDoc(workflowPath(root2, scope));
-  let skipIf = null;
-  const entries = isRecord(workflowDoc) && Array.isArray(workflowDoc.stages) ? workflowDoc.stages : [];
-  for (const entry of entries) {
-    if (!isRecord(entry) || entry.id !== stageId)
-      continue;
-    if (typeof entry.skip_if === "string" && entry.skip_if !== "")
-      skipIf = entry.skip_if;
-  }
-  const questions = isRecord(stageDoc) && isRecord(stageDoc.questions) ? stageDoc.questions : null;
-  return {
-    stackExperts: isRecord(stageDoc) && typeof stageDoc.stack_experts === "boolean" ? stageDoc.stack_experts : DEFAULT_STACK_EXPERTS,
-    knowledgeMaxBytes: byteKey(stageDoc, "knowledge_max_bytes") ?? byteKey(stageDoc, "expert_knowledge_bytes") ?? DEFAULT_KNOWLEDGE_MAX_BYTES,
-    inputsMaxBytes: byteKey(stageDoc, "inputs_max_bytes") ?? DEFAULT_INPUTS_MAX_BYTES,
-    promptMaxBytes: byteKey(stageDoc, "prompt_max_bytes") ?? DEFAULT_PROMPT_MAX_BYTES,
-    maxReads: byteKey(stageDoc, "max_reads") ?? defaultMaxReads(stageId),
-    parallel: parallelKey(workflowDoc, stageId) ?? byteKey(stageDoc, "parallel"),
-    reviewer: reviewerOverride(isRecord(stageDoc) ? stageDoc.reviewer : undefined),
-    reviewerByStakes: reviewerByStakesMap(isRecord(stageDoc) ? stageDoc.reviewer_by_stakes : undefined),
-    tuning: readStageTuning(stageDoc),
-    dryRunAllowed: isRecord(stageDoc) && typeof stageDoc.dry_run_allowed === "boolean" ? stageDoc.dry_run_allowed : DEFAULT_DRY_RUN_ALLOWED,
-    skipIf,
-    questionsMax: questions !== null && typeof questions.max === "number" ? questions.max : null
-  };
-}
-function inputSplit(root2, stageId) {
-  const doc = readDoc(stagePath(root2, stageId));
-  const inputs = isRecord(doc) ? doc.inputs : undefined;
-  const topLevelSeed = isRecord(doc) && doc.seed === true;
-  if (isRecord(inputs)) {
-    return {
-      requiredInputs: strings2(inputs.required),
-      optionalInputs: strings2(inputs.optional),
-      seedInputs: inputs.seed === true || topLevelSeed
-    };
-  }
-  return { requiredInputs: [], optionalInputs: strings2(inputs), seedInputs: topLevelSeed };
-}
-function reviewerOverride(value) {
-  if (!isRecord(value))
-    return null;
-  const model2 = typeof value.model === "string" && value.model !== "" ? value.model : undefined;
-  const effort2 = EFFORT_LEVELS.includes(String(value.effort)) ? value.effort : undefined;
-  if (model2 === undefined && effort2 === undefined)
-    return null;
-  return { ...model2 === undefined ? {} : { model: model2 }, ...effort2 === undefined ? {} : { effort: effort2 } };
-}
-function reviewerByStakesMap(value) {
-  if (!isRecord(value))
-    return {};
-  const out = {};
-  for (const [key, entry] of Object.entries(value)) {
-    const override = reviewerOverride(entry);
-    if (override !== null)
-      out[key] = override;
-  }
-  return out;
-}
-function parallelKey(workflowDoc, stageId) {
-  if (!isRecord(workflowDoc))
-    return null;
-  const entry = workflowDoc[stageId];
-  return isRecord(entry) ? byteKey(entry, "parallel") : null;
-}
-function byteKey(doc, key) {
-  if (!isRecord(doc))
-    return null;
-  const value = doc[key];
-  if (typeof value !== "number" || !Number.isFinite(value) || value < 0)
-    return null;
-  return Math.trunc(value);
-}
-function readDoc(path) {
-  if (path === null || !existsSync58(path))
-    return null;
-  try {
-    return parseYaml(readFileSync53(path, "utf8"));
-  } catch {
-    return null;
-  }
-}
-function strings2(value) {
-  return Array.isArray(value) ? value.filter((v) => typeof v === "string") : [];
-}
-
 // src/core/plan/schemaContract.ts
 var PLAN_CONTRACT_HEADING = "Output schemas";
 var STORY_OPTIONAL_KEYS = ["stakes"];
@@ -34820,9 +35062,10 @@ async function watchExecutor(ctx) {
         tasks: [],
         costUsd: 0,
         outputs: [],
-        lines: incoherent,
+        lines: incoherent.lines,
         error: null,
-        refused: true
+        refused: true,
+        signature: incoherent.signature
       };
     }
     prompts = features.map((feature, i) => featurePrompt(ctx, feature, diffs[i] ?? []));
@@ -34853,7 +35096,7 @@ async function watchExecutor(ctx) {
       tasks.push({
         key: feature.id,
         model: ctx.model ?? ctx.spec.planned.model,
-        costUsd: round24(outcome.costUsd),
+        costUsd: round25(outcome.costUsd),
         sessionId: outcome.sessionId,
         error: outcome.error,
         outputs: outcome.envelope?.outputs ?? [],
@@ -34890,7 +35133,7 @@ async function watchExecutor(ctx) {
     ok: true,
     awaiting: false,
     tasks,
-    costUsd: round24(tasks.reduce((sum, task2) => sum + task2.costUsd, 0)),
+    costUsd: round25(tasks.reduce((sum, task2) => sum + task2.costUsd, 0)),
     outputs: [...written.map((w) => w.path), HANDOFF_REL],
     lines: [
       `${ctx.phaseId}/${ctx.stageId}: ${String(written.length)} watcher card(s) — ` + `${String(verified)} verified, ${String(written.length - verified)} draft`,
@@ -34940,7 +35183,7 @@ function collectResults(ctx, features) {
       tasks.push({
         key: feature.id,
         model: ctx.model ?? ctx.spec.planned.model,
-        costUsd: round24(result2.cost_usd ?? 0),
+        costUsd: round25(result2.cost_usd ?? 0),
         sessionId: result2.session_id,
         error: null,
         outputs: result2.outputs
@@ -35059,7 +35302,14 @@ function branchIncoherence(ctx, features, diffs) {
     const [opening, ...rest] = block2;
     out.push(i === 0 ? `${ctx.phaseId}/${ctx.stageId} refuses to start: ${opening ?? ""}` : `  and: ${opening ?? ""}`, ...rest);
   }
-  return out;
+  const faults = [
+    ...bases.map((row2) => `base \`${row2.diff.base}\` missing in \`${row2.diff.repo}\``),
+    ...branches.map((row2) => `branch \`${row2.diff.branch}\` (${row2.owner}) missing in \`${row2.diff.repo}\``)
+  ];
+  return {
+    lines: out,
+    signature: `${ctx.phaseId}/${ctx.stageId} refuses to start: ${faults.join("; ")}`
+  };
 }
 function dedupeByRepo(rows) {
   const seen = new Set;
@@ -35090,7 +35340,7 @@ function failed2(ctx, error, tasks) {
     ok: false,
     awaiting: false,
     tasks,
-    costUsd: round24(tasks.reduce((sum, task2) => sum + task2.costUsd, 0)),
+    costUsd: round25(tasks.reduce((sum, task2) => sum + task2.costUsd, 0)),
     outputs: [],
     lines: [`${ctx.phaseId}/${ctx.stageId} failed: ${error}`],
     error
@@ -35101,21 +35351,21 @@ function taskKey(ctx, feature) {
 }
 function agentShare(ctx, features) {
   const share = features <= 1 ? ctx.maxBudgetUsd : ctx.maxBudgetUsd / features;
-  return round24(Math.max(MIN_AGENT_USD, share));
+  return round25(Math.max(MIN_AGENT_USD, share));
 }
 function floorOverrun(ctx, features) {
-  const needed = round24(features * MIN_AGENT_USD);
+  const needed = round25(features * MIN_AGENT_USD);
   if (needed <= ctx.budgetUsd + 0.001)
     return null;
-  const short2 = round24(Math.ceil((needed - ctx.budgetUsd) * 100) / 100);
+  const short2 = round25(Math.ceil((needed - ctx.budgetUsd) * 100) / 100);
   return `${ctx.phaseId}/${ctx.stageId} refuses to start: ${features} feature(s) need at least ` + `$${MIN_AGENT_USD.toFixed(2)} each ($${needed.toFixed(2)} in total) and the stage ceiling is ` + `$${ctx.budgetUsd.toFixed(2)}. A spawn under the floor fails as \`error_max_budget_usd\` before it ` + `does any work, so splitting it further would just buy N failures. ` + `Run \`tldrx budget raise ${ctx.phaseId} ${short2.toFixed(2)}\` (add \`--take-from <phase>\` to move ` + "the money instead of adding it), or ship fewer features in one run.";
 }
-function round24(n) {
+function round25(n) {
   return Math.round(n * 100) / 100;
 }
 
 // src/core/facilitator/executors/build.ts
-import { existsSync as existsSync83, mkdirSync as mkdirSync18, readFileSync as readFileSync73, rmSync as rmSync9, writeFileSync as writeFileSync17 } from "node:fs";
+import { existsSync as existsSync83, mkdirSync as mkdirSync18, readFileSync as readFileSync74, rmSync as rmSync9, writeFileSync as writeFileSync18 } from "node:fs";
 import { isAbsolute as isAbsolute8, join as join99, relative as relative16 } from "node:path";
 
 // src/core/build/preflight.ts
@@ -35646,10 +35896,9 @@ async function redBaseRefusal(parts, stories) {
   }
   if (failures.length === 0)
     return null;
-  const first2 = failures[0];
   return {
     lines: [...baseRefusalLines(failures, parts.workspace)],
-    error: first2 === undefined ? "a workspace command fails on the base tree" : `\`${first2.command}\` exits ${String(first2.exitCode ?? "?")} on the base tree of ${first2.repo}`
+    error: failures.length === 0 ? "a workspace command fails on the base tree" : failures.map((row2) => `\`${row2.command}\` exits ${String(row2.exitCode ?? "?")} on the base tree of ${row2.repo}`).join("; ")
   };
 }
 async function runStoryDod(parts) {
@@ -36176,7 +36425,7 @@ async function measureWorktree(parts, decl, dod, repoDir, baseRef, baseSha, decl
 import { basename as basename12 } from "node:path";
 
 // src/core/build/epicRelease.ts
-import { appendFileSync as appendFileSync4, existsSync as existsSync73 } from "node:fs";
+import { existsSync as existsSync73, readFileSync as readFileSync64, writeFileSync as writeFileSync16 } from "node:fs";
 import { join as join88 } from "node:path";
 var ASIDE_SEPARATOR = "@";
 function asideBranchOf(epicBranch, ownerRunId) {
@@ -36302,14 +36551,15 @@ function appendToHandoff(runDir, released) {
   const path = join88(runDir, BUILD_PHASE, "handoff.md");
   if (!existsSync73(path))
     return;
-  const bullets = released.map((record2) => `- ${describeRelease(record2)} — ${record2.via} at ${record2.at}: ${record2.reason} ` + `[src: absent:${BUILD_PHASE}/log]`);
+  const bullets = released.map((record2) => asOneLine(`- ${describeRelease(record2)} — ${record2.via} at ${record2.at}: ${record2.reason} ` + `[src: absent:${BUILD_PHASE}/log]`));
   try {
-    appendFileSync4(path, `
+    const before = readFileSync64(path, "utf8");
+    writeFileSync16(path, ensureLineBreakNote(`${before}
 ## Epic branch released
 
 ${bullets.join(`
 `)}
-`, "utf8");
+`), "utf8");
   } catch {}
 }
 
@@ -36365,21 +36615,27 @@ async function foreignEpicRefusal(state, parts, stories) {
       `[tldrx] build: \`${branch}\` already exists in ${planned.story.repo} and run ${parts.runId} ` + "did not cut it — refusing to stack this run's commits onto someone else's epic.",
       "  either delete or rename that branch, or run `tldrx next --reuse-epic` to work on it deliberately."
     ];
-    const error = `epic branch \`${branch}\` was not created by this run`;
+    const about = `epic branch \`${branch}\` in ${planned.story.repo} was not created by this run`;
     const owners = epicClaimants(parts.root, branch, parts.runId);
     if (owners.unreadable.length > 0) {
-      return { lines: [...verbatim, `  · ${owners.unreadable.join(", ")} could not be read, so who owns it is unknown`], error };
+      return {
+        lines: [...verbatim, `  · ${owners.unreadable.join(", ")} could not be read, so who owns it is unknown`],
+        error: `${about}; who owns it is unknown — unreadable claim(s): ${owners.unreadable.join(", ")}`
+      };
     }
     const open = owners.claimants.filter((store) => !isFinished(store.run.status));
     if (open.length > 0) {
       const named = open.map((store) => `${store.runId} (${store.run.status})`).join(", ");
-      return { lines: [...verbatim, `  · claimed by run ${named}, which is still open`], error };
+      return {
+        lines: [...verbatim, `  · claimed by run ${named}, which is still open`],
+        error: `${about}; claimed by open run(s) ${named}`
+      };
     }
     const owner = owners.claimants[0];
     if (owner === undefined) {
       return {
         lines: [...verbatim, `  · no run under ${PROJECT_WORK_DIR}/ records cutting it, so it is nobody's leftover to move`],
-        error
+        error: `${about}; no run records cutting it, so it is nobody's leftover to move`
       };
     }
     const status = owner.run.status;
@@ -36403,7 +36659,7 @@ async function foreignEpicRefusal(state, parts, stories) {
           `[tldrx] build: \`${branch}\` already exists in ${planned.story.repo}, left by run ${owner.runId} ` + `(${status}), and could not be moved aside — ${why}.`,
           verbatim[1] ?? ""
         ],
-        error
+        error: `${about}; left by run ${owner.runId} (${status}) and could not be moved aside — ${why}`
       };
     }
     state.released.push({ record: record2, owner: owner.runId, ownerStatus: status });
@@ -36482,7 +36738,7 @@ async function dirtyRepoRefusal(parts, stories) {
           `    git -C ${shellQuote2(dir)} stash pop`,
           ...setAside.length === 0 ? [] : [`  The other ${String(setAside.length)} change(s) here are nobody's story — ` + "the engine would have set those aside and given them back itself."]
         ],
-        error: `repo \`${name}\` has uncommitted changes a pending story declares`
+        error: `repo \`${name}\` has uncommitted changes a pending story declares: ` + verdict2.overlapping.map((row2) => `${row2.entry.path} (${row2.why})`).join("; ")
       });
     }
     aside.push({ repo: name, repoDir: dir, paths: verdict2.foreign.map((entry) => entry.path) });
@@ -36509,92 +36765,11 @@ function epicRows(state, parts, outcomes) {
 }
 
 // src/core/build/reviewBundle.ts
-import { existsSync as existsSync75, readFileSync as readFileSync65, renameSync as renameSync3, rmSync as rmSync8 } from "node:fs";
+import { existsSync as existsSync75, readFileSync as readFileSync66, renameSync as renameSync3, rmSync as rmSync8 } from "node:fs";
 import { join as join90, relative as relative15 } from "node:path";
 
-// src/core/build/caps.ts
-var MAX_ATTEMPTS2 = STAGE_TUNING_DEFAULTS.attempts;
-var REVIEWER_SHARE2 = STAGE_TUNING_DEFAULTS.reviewerShare;
-var REVIEWER_FLOOR_USD2 = 1;
-var STORY_CAP_MULTIPLIER2 = STAGE_TUNING_DEFAULTS.storyCapMultiplier;
-var STORY_CAP_FLOOR_USD2 = STAGE_TUNING_DEFAULTS.storyCapFloorUsd;
-function developerAttemptDivisor2(attempt, attempts = MAX_ATTEMPTS2) {
-  return attempt <= 1 ? 1 : attempts;
-}
-var DEFAULT_PARALLEL = 1;
-function clampParallel(requested) {
-  if (requested === undefined || !Number.isFinite(requested))
-    return DEFAULT_PARALLEL;
-  return Math.max(1, Math.min(MAX_STORIES_PER_WAVE, Math.trunc(requested)));
-}
-function attemptsOf(parts) {
-  return parts.attempts ?? MAX_ATTEMPTS2;
-}
-function storyCapMultiplierOf(parts) {
-  return parts.storyCapMultiplier ?? STORY_CAP_MULTIPLIER2;
-}
-function storyCapFloorOf(parts) {
-  return parts.storyCapFloorUsd ?? STORY_CAP_FLOOR_USD2;
-}
-function reviewerShareOf(parts) {
-  return parts.reviewerShare ?? REVIEWER_SHARE2;
-}
-function round25(n) {
-  return Math.round(n * 100) / 100;
-}
-function developerCap(parts, storyId, attempt = 1) {
-  const price = priceOf(parts, storyId);
-  if (price === null)
-    return parts.agentCap(1 / worstCaseShares(parts));
-  return parts.agentCap(shareOf(parts, storyCeilingUsd(parts, price) / developerAttemptDivisor2(attempt, attemptsOf(parts))));
-}
-function storyCeilingUsd(parts, price) {
-  const floor = parts.budgetUsd > 0 ? Math.min(storyCapFloorOf(parts), parts.budgetUsd) : storyCapFloorOf(parts);
-  return Math.max(price * storyCapMultiplierOf(parts), floor);
-}
-function reviewerCap(parts, spentUsd, storyId) {
-  const price = priceOf(parts, storyId);
-  const share = reviewerShareOf(parts);
-  const derived = price === null ? parts.agentCap(share / worstCaseShares(parts)) : parts.agentCap(shareOf(parts, price * share / (attemptsOf(parts) * (1 + share))));
-  const floor = Math.min(REVIEWER_FLOOR_USD2, Math.max(parts.budgetUsd - spentUsd, 0));
-  return round25(Math.min(Math.max(derived, floor), parts.maxBudgetUsd));
-}
-function stageRemainderUsd(parts, spentUsd) {
-  if (!(parts.budgetUsd > 0))
-    return null;
-  return Math.max(round25(parts.budgetUsd - spentUsd), 0);
-}
-function reviewerUnderfunded(parts, spentUsd) {
-  const left = stageRemainderUsd(parts, spentUsd);
-  return left !== null && left < REVIEWER_FLOOR_USD2;
-}
-function priceOf(parts, storyId) {
-  if (storyId === undefined)
-    return null;
-  const price = parts.prices.get(storyId);
-  if (price === undefined || !Number.isFinite(price) || price <= 0)
-    return null;
-  return price * priceScale(parts);
-}
-function priceScale(parts) {
-  if (parts.budgetUsd <= 0)
-    return 1;
-  let sum = 0;
-  for (const price of parts.prices.values()) {
-    if (Number.isFinite(price) && price > 0)
-      sum += price;
-  }
-  return sum <= parts.budgetUsd ? 1 : parts.budgetUsd / sum;
-}
-function shareOf(parts, usd2) {
-  return parts.budgetUsd <= 0 ? 1 : usd2 / parts.budgetUsd;
-}
-function worstCaseShares(parts) {
-  return Math.max(parts.storyCount, 1) * attemptsOf(parts) * (1 + reviewerShareOf(parts));
-}
-
 // src/core/build/reviewLedger.ts
-import { existsSync as existsSync74, readFileSync as readFileSync64 } from "node:fs";
+import { existsSync as existsSync74, readFileSync as readFileSync65 } from "node:fs";
 import { join as join89 } from "node:path";
 function readReviewLedger(runDir, storyId) {
   const path = join89(runDir, "events.jsonl");
@@ -36610,6 +36785,7 @@ function readReviewLedger(runDir, storyId) {
     blockedWithNothingRun: false,
     reopened: null,
     asIs: null,
+    lastMerge: null,
     fixRound: null,
     formatRetries: 0,
     formatRefusal: null,
@@ -36631,12 +36807,13 @@ function readReviewLedger(runDir, storyId) {
   let lastDodOutputPath = null;
   let reopened = null;
   let asIs = null;
+  let lastMerge = null;
   let fixRound = null;
   let formatRetries = 0;
   let formatRefusal = null;
   let spawned = null;
   let reviewer = null;
-  for (const line of readFileSync64(path, "utf8").split(`
+  for (const line of readFileSync65(path, "utf8").split(`
 `)) {
     if (line.trim() === "")
       continue;
@@ -36698,6 +36875,13 @@ function readReviewLedger(runDir, storyId) {
         commit2 = payload.commit;
       if (typeof payload.epic_base === "string" && payload.epic_base !== "")
         epicBase = payload.epic_base;
+      if (typeof payload.commit === "string" && payload.commit !== "" && typeof payload.epic_base === "string" && payload.epic_base !== "") {
+        lastMerge = {
+          commit: payload.commit,
+          epicBase: payload.epic_base,
+          verdict: typeof payload.verdict === "string" && payload.verdict !== "" ? payload.verdict : "n-a"
+        };
+      }
       if (payload.status === "done")
         fixRound = null;
       asIs = null;
@@ -36761,6 +36945,7 @@ function readReviewLedger(runDir, storyId) {
     blockedWithNothingRun,
     reopened,
     asIs,
+    lastMerge,
     fixRound,
     formatRetries,
     formatRefusal,
@@ -36864,7 +37049,7 @@ function reviewWorkFromBundle(runDir, key) {
     return null;
   let doc;
   try {
-    doc = JSON.parse(readFileSync65(path, "utf8"));
+    doc = JSON.parse(readFileSync66(path, "utf8"));
   } catch {
     return null;
   }
@@ -36919,11 +37104,11 @@ function resumableReview(runDir, storyId, status, fresh) {
 }
 
 // src/core/retro/findings.ts
-import { existsSync as existsSync81, readdirSync as readdirSync26, readFileSync as readFileSync71 } from "node:fs";
+import { existsSync as existsSync81, readdirSync as readdirSync26, readFileSync as readFileSync72 } from "node:fs";
 import { join as join97 } from "node:path";
 
 // src/core/replay/loadRun.ts
-import { existsSync as existsSync76, readdirSync as readdirSync25, readFileSync as readFileSync66, statSync as statSync21 } from "node:fs";
+import { existsSync as existsSync76, readdirSync as readdirSync25, readFileSync as readFileSync67, statSync as statSync21 } from "node:fs";
 import { join as join91 } from "node:path";
 // src/core/replay/RunDocument.ts
 function toRunDocument(input, fallbackId) {
@@ -37171,7 +37356,7 @@ function loadRunResult(root2, id) {
     return { kind: "missing" };
   let doc;
   try {
-    doc = parseYamlRepairing(readFileSync66(runPath, "utf8")).doc;
+    doc = parseYamlRepairing(readFileSync67(runPath, "utf8")).doc;
   } catch (error2) {
     return { kind: "unreadable", dir, error: error2 instanceof Error ? error2.message : String(error2) };
   }
@@ -37182,7 +37367,7 @@ function loadRunResult(root2, id) {
   let budget = null;
   if (existsSync76(budgetPath)) {
     try {
-      budget = toBudgetDocument(parseYamlRepairing(readFileSync66(budgetPath, "utf8")).doc);
+      budget = toBudgetDocument(parseYamlRepairing(readFileSync67(budgetPath, "utf8")).doc);
     } catch {
       budget = null;
     }
@@ -37233,7 +37418,7 @@ function readEvents2(dir) {
 function loadPhaseArtefacts(loaded, phase) {
   const read2 = (name) => {
     const path = join91(loaded.dir, phase, name);
-    return existsSync76(path) ? readFileSync66(path, "utf8") : null;
+    return existsSync76(path) ? readFileSync67(path, "utf8") : null;
   };
   return { phase, handoff: read2(HANDOFF_FILE2), questions: read2(QUESTIONS_FILE3) };
 }
@@ -37244,7 +37429,7 @@ function loadGateEvidence(loaded, relPath) {
   if (!existsSync76(path))
     return null;
   try {
-    return readFileSync66(path, "utf8");
+    return readFileSync67(path, "utf8");
   } catch {
     return null;
   }
@@ -37257,7 +37442,7 @@ function runLevelEvents(loaded) {
 }
 
 // src/core/build/retroLog.ts
-import { existsSync as existsSync77, mkdirSync as mkdirSync17, readFileSync as readFileSync67, writeFileSync as writeFileSync16 } from "node:fs";
+import { existsSync as existsSync77, mkdirSync as mkdirSync17, readFileSync as readFileSync68, writeFileSync as writeFileSync17 } from "node:fs";
 import { join as join92 } from "node:path";
 var RETRO_FILE = "retro.md";
 var BUILD_RETRO_SECTION = "Build feedback";
@@ -37306,7 +37491,7 @@ function gateRetroLines(runDir2, runId) {
     return [];
   let text3;
   try {
-    text3 = readFileSync67(path, "utf8");
+    text3 = readFileSync68(path, "utf8");
   } catch {
     return [];
   }
@@ -37341,7 +37526,7 @@ function appendBuildRetro(runDir2, incoming) {
   if (incoming.length === 0)
     return [];
   const path = buildRetroPath(runDir2);
-  const existing = existsSync77(path) ? readFileSync67(path, "utf8") : "";
+  const existing = existsSync77(path) ? readFileSync68(path, "utf8") : "";
   const { before, section: section2 } = splitBuildSection(existing);
   const already = new Set(section2.split(`
 `).map((line) => line.trim()));
@@ -37363,7 +37548,7 @@ function appendBuildRetro(runDir2, incoming) {
   ].join(`
 `);
   mkdirSync17(runDir2, { recursive: true });
-  writeFileSync16(path, out, "utf8");
+  writeFileSync17(path, out, "utf8");
   return added;
 }
 function extractBuildSection(text3) {
@@ -37400,7 +37585,7 @@ function str7(value) {
 }
 
 // src/core/retro/renderRetro.ts
-import { existsSync as existsSync79, readFileSync as readFileSync69 } from "node:fs";
+import { existsSync as existsSync79, readFileSync as readFileSync70 } from "node:fs";
 import { join as join95 } from "node:path";
 
 // src/core/retro/factsFromRun.ts
@@ -37447,7 +37632,7 @@ function str8(value) {
 }
 
 // src/core/retro/proposals.ts
-import { existsSync as existsSync78, readFileSync as readFileSync68 } from "node:fs";
+import { existsSync as existsSync78, readFileSync as readFileSync69 } from "node:fs";
 import { join as join94 } from "node:path";
 var PROPOSE_STAGE_MARKER = "propose stage:";
 function practiceProposals(loaded) {
@@ -37526,7 +37711,7 @@ function questionsMax(root2, stage2) {
   if (!existsSync78(path))
     return null;
   try {
-    const doc = parseYaml(readFileSync68(path, "utf8"));
+    const doc = parseYaml(readFileSync69(path, "utf8"));
     if (typeof doc !== "object" || doc === null)
       return null;
     const questions = doc.questions;
@@ -37618,7 +37803,7 @@ function carryBuildSection(dir) {
   if (!existsSync79(path))
     return "";
   try {
-    return extractBuildSection(readFileSync69(path, "utf8"));
+    return extractBuildSection(readFileSync70(path, "utf8"));
   } catch {
     return "";
   }
@@ -37643,7 +37828,7 @@ var OTHER = "other";
 var RULED_CLASSES = FINDING_CLASSES.filter((cls) => cls !== OTHER);
 
 // src/core/retro/findingClasses.ts
-import { existsSync as existsSync80, readFileSync as readFileSync70 } from "node:fs";
+import { existsSync as existsSync80, readFileSync as readFileSync71 } from "node:fs";
 import { join as join96 } from "node:path";
 var FINDING_CLASSES_FILE = `${PROJECT_FRAMEWORK_DIR}/memory/finding-classes.yml`;
 var MAX_CLASSES = 16;
@@ -37665,7 +37850,7 @@ function loadExtraClasses(root2) {
     return [];
   let text3;
   try {
-    text3 = readFileSync70(path, "utf8");
+    text3 = readFileSync71(path, "utf8");
   } catch (error) {
     throw new FindingClassesError(`cannot be read — ${messageOf3(error)}`);
   }
@@ -37841,7 +38026,7 @@ function readText3(path) {
   if (!existsSync81(path))
     return null;
   try {
-    return readFileSync71(path, "utf8");
+    return readFileSync72(path, "utf8");
   } catch {
     return null;
   }
@@ -38220,6 +38405,38 @@ function clipDetail(detail) {
   return text3.length <= 1200 ? text3 : `${text3.slice(0, 1197)}…`;
 }
 
+// src/core/build/dependencyHold.ts
+function dependencyIsPending(status) {
+  return status === "review" || status === "in_progress";
+}
+function decidingHold(holds) {
+  return holds.find((hold) => !dependencyIsPending(hold.status)) ?? holds[0] ?? null;
+}
+function dependencyHoldReason(held2) {
+  return held2.status === "blocked" ? `dependency ${held2.id} blocked` : `dependency ${held2.id} is \`${held2.status}\`, not \`done\``;
+}
+function dependencyWaitReason(held2) {
+  return `it waits on dependency ${held2.id}, which is \`${held2.status}\` and is offered again by the next ` + `invocation; ${held2.id} \`done\` is what releases it, and no reopen is owed`;
+}
+function dependencyWaitLine(storyId, held2) {
+  return `  · ${storyId} waits on ${held2.id}, which is \`${held2.status}\` — left \`todo\`, not \`blocked\`: ` + `it is asked again once ${held2.id} settles`;
+}
+function dependencyNamedByHold(reason) {
+  const found = /^dependency (\S+) (?:blocked|is `\w+`, not `done`)$/.exec(reason.trim());
+  return found?.[1] ?? null;
+}
+function dependencyHoldOfLog(log) {
+  const lines = log.split(`
+`);
+  const start = lines.indexOf(WHY_NOT_DONE_HEADING);
+  if (start === -1)
+    return null;
+  const rest = lines.slice(start + 1);
+  const end = rest.findIndex((line) => line.startsWith("## "));
+  const body = (end === -1 ? rest : rest.slice(0, end)).map((line) => line.trim()).filter((line) => line !== "");
+  return body.length === 1 && body[0] !== undefined ? dependencyNamedByHold(body[0]) : null;
+}
+
 // src/core/facilitator/reviewerModel.ts
 function resolveReviewer(layers) {
   const byStakes = layers.stakes === null ? undefined : layers.byStakes[layers.stakes];
@@ -38326,7 +38543,7 @@ function overShareSentence(ceilingUsd, measuredUsd, stories) {
   if (ratio <= 1)
     return null;
   const over = stories === 1 ? "1 story" : `${String(stories)} stories`;
-  return `${over} measured $${round25(measuredUsd).toFixed(2)} against ` + `$${round25(ceilingUsd).toFixed(2)} of spawn ceilings — ${ratio.toFixed(1)}x`;
+  return `${over} measured $${round23(measuredUsd).toFixed(2)} against ` + `$${round23(ceilingUsd).toFixed(2)} of spawn ceilings — ${ratio.toFixed(1)}x`;
 }
 function sumOrNull(values) {
   if (values.length === 0)
@@ -38344,10 +38561,10 @@ function sumOrNull(values) {
 import { basename as basename13 } from "node:path";
 
 // src/core/budget/loadBudget.ts
-import { existsSync as existsSync82, readFileSync as readFileSync72 } from "node:fs";
+import { existsSync as existsSync82, readFileSync as readFileSync73 } from "node:fs";
 import { join as join98 } from "node:path";
 function loadBudget(path) {
-  const doc = parseYaml(readFileSync72(path, "utf8"));
+  const doc = parseYaml(readFileSync73(path, "utf8"));
   const validation = validateRunBudget(doc);
   noteDeprecations(path, validation);
   if (!validation.ok) {
@@ -38794,7 +39011,7 @@ function phaseCostToDate(runDir2, phaseId, stageId, invocationUsd, invocationTur
   turns = [
     ...turns,
     ...invocationTurns.map((task2) => ({
-      costUsd: task2.metered === false ? null : round25(task2.costUsd),
+      costUsd: task2.metered === false ? null : round23(task2.costUsd),
       metered: task2.metered !== false,
       tokens: turnTokens({
         tokens: task2.tokens,
@@ -38812,12 +39029,12 @@ function phaseCostToDate(runDir2, phaseId, stageId, invocationUsd, invocationTur
   const tally = { unmetered, metered: turns.length - unmetered };
   if (recorded === null) {
     return {
-      usd: round25(invocationUsd),
+      usd: round23(invocationUsd),
       note: "this invocation only — `run.yml` could not be read for what the stage spent before it" + (note === null ? "" : `; ${note}`),
       ...tally
     };
   }
-  return { usd: round25(recorded + invocationUsd), note, ...tally };
+  return { usd: round23(recorded + invocationUsd), note, ...tally };
 }
 
 // src/core/facilitator/executors/build.ts
@@ -38947,7 +39164,7 @@ async function rederiveImplicitPlan(ctx, workspace, parts, lines) {
   const kept = (why) => {
     lines.push(`  · kept ${IMPLICIT_PLAN_REL} (--discard-pending re-derives only an unbuilt plan): ${why}`);
   };
-  const blocker = implicitPlanIsStale(readFileSync73(implicitPlanPath(ctx.runDir), "utf8"));
+  const blocker = implicitPlanIsStale(readFileSync74(implicitPlanPath(ctx.runDir), "utf8"));
   if (blocker !== null) {
     kept(blocker);
     return;
@@ -39015,6 +39232,7 @@ class BuildSession {
   aside = [];
   preflight;
   lanes;
+  waits = new Map;
   constructor(ctx, workspace, plan, opening = []) {
     this.ctx = ctx;
     this.workspace = workspace;
@@ -39028,6 +39246,9 @@ class BuildSession {
     }
     if (plan.priceIssue !== null)
       this.advisories.push(plan.priceIssue);
+    const over = planOverStageAdvisory(this.capParts, this.capLever);
+    if (over !== null)
+      this.advisories.push(over);
   }
   async runAll() {
     const refusal = await this.refuseOnDirtyRepos() ?? await this.refuseOnForeignEpic() ?? await this.setAsideForeign() ?? await this.refuseOnRedBase() ?? await this.refuseOnUnrunnableWorktree();
@@ -39044,13 +39265,22 @@ class BuildSession {
           pending.push(planned);
           continue;
         }
+        const released = status === "blocked" ? this.staleDependencyHold(planned) : null;
+        if (released !== null) {
+          this.lines.push(`  · ${planned.story.id} was \`blocked\` for dependency ${released}, which is now \`done\` — ` + "that was never an attempt, so it is offered again");
+          pending.push(planned);
+          continue;
+        }
         if (status === "done" || status === "blocked") {
           this.lines.push(`  · ${planned.story.id} is already \`${status}\` — left alone`);
           continue;
         }
         const held2 = this.blockingDependency(planned);
         if (held2 !== null) {
-          this.blockOnDependency(planned, held2);
+          if (dependencyIsPending(held2.status))
+            this.waitOnDependency(planned, held2);
+          else
+            this.blockOnDependency(planned, held2);
           continue;
         }
         this.noteIfReopened(planned, status);
@@ -39286,7 +39516,7 @@ class BuildSession {
     }
     const story = await this.openStory(planned);
     const declared2 = this.ctx.costUsd ?? result2.cost_usd;
-    const cost = declared2 === null ? null : round25(declared2);
+    const cost = declared2 === null ? null : round23(declared2);
     this.tasks.push({
       key: planned.story.id,
       model: this.model(),
@@ -39430,7 +39660,22 @@ class BuildSession {
       };
     }
     const ahead = await commitsBetween(story.repoDir, story.epicBranch, story.branch);
-    if (ahead === null || ahead === 0) {
+    if (ahead === 0) {
+      const merge = readReviewLedger(this.ctx.runDir, id).lastMerge;
+      if (merge !== null && reviewNeverCompleted(merge.verdict)) {
+        return await this.reviewOnlyHalf(planned, asIs, story, before, merge);
+      }
+      return {
+        story,
+        cost: 0,
+        dod: [],
+        commit: null,
+        failure: asIsNotAheadReason(story.branch, story.epicBranch, ahead, merge === null ? undefined : merge),
+        developerError: null,
+        before
+      };
+    }
+    if (ahead === null) {
       return {
         story,
         cost: 0,
@@ -39468,6 +39713,27 @@ class BuildSession {
     }
     return { story, cost: 0, dod, commit: commit2, failure: null, developerError: null, before };
   }
+  async reviewOnlyHalf(planned, asIs, story, before, merge) {
+    const id = planned.story.id;
+    const reviewed = { commit: merge.commit, epicBase: merge.epicBase };
+    this.asIsSettlements.set(id, { ...asIs, reason: "review-only", reviewed });
+    this.lines.push(`  · ${id}: ${AS_IS_REVIEW_ONLY_MARK} — \`${merge.commit.slice(0, 7)}\` is already on ` + `\`${story.epicBranch}\` and nothing judged it; running the dod on the epic head and the review ` + `over \`${reviewDiffRange(merge.epicBase, story.epicBranch, story.branch)}\``);
+    await this.writes.run(() => this.refreshStoryBase(planned, story.repoDir, story.worktree, story.branch, story.epicBranch));
+    const dod = await this.runDod(story);
+    if (!this.dodProves(dod)) {
+      const failing = dodFailure(dod);
+      return {
+        story,
+        cost: 0,
+        dod,
+        commit: null,
+        failure: failing === undefined ? "the story declares no dod commands, so nothing could prove it" : dodFailureReason(failing, planned.story.repo),
+        developerError: null,
+        before
+      };
+    }
+    return { story, cost: 0, dod, commit: merge.commit, failure: null, developerError: null, before, reviewOnly: reviewed };
+  }
   async buildHalf(planned) {
     const asIs = this.asIsFor(planned);
     if (asIs !== null)
@@ -39507,7 +39773,7 @@ class BuildSession {
     let spent = 0;
     let separatorRetries = 0;
     for (;; ) {
-      spent = round25(spent + developer.cost);
+      spent = round23(spent + developer.cost);
       const capDeath = developer.error !== null && diedOnCap(developer.error);
       if (developer.error !== null) {
         const proven2 = capDeath && await workSince({
@@ -39572,7 +39838,7 @@ class BuildSession {
         failure: [
           why,
           ...developer.refused === null ? [] : [permissionBlockReason(developer.refused, { declared: this.repoCommands(story.planned.story.repo) })],
-          ...budgetDeath === null ? [] : [capDeathReason(budgetDeath)]
+          ...budgetDeath === null ? [] : [capDeathReason(budgetDeath, this.capParts, story.planned.story.id, story.attempt, this.capLever)]
         ].join("; and "),
         developerError: null,
         before
@@ -39606,6 +39872,10 @@ class BuildSession {
       await this.block(story, "the story produced no commit to review", half.cost, dod);
       return "settled";
     }
+    if (half.reviewOnly !== undefined) {
+      this.noteMerged(story, null);
+      return await this.reviewAndSettle(story, dod, half.reviewOnly.commit, half.cost, null, half.reviewOnly.epicBase);
+    }
     const update = await updateStoryBase({
       storyId: story.planned.story.id,
       repoDir: story.repoDir,
@@ -39665,14 +39935,14 @@ class BuildSession {
         epicBase,
         verdict: "n-a",
         review: review2,
-        cost: round25(priorCost),
+        cost: round23(priorCost),
         reason: review2.summary
       });
       return "settled";
     }
     const outcome = supplied === undefined ? await this.spawnReviewer(story, dod, epicBase) : { review: supplied, cost: 0 };
     const review = outcome.review;
-    const cost = round25(priorCost + outcome.cost);
+    const cost = round23(priorCost + outcome.cost);
     if (review.verdict === "error") {
       await this.settle(story, "review", {
         dod,
@@ -39690,6 +39960,21 @@ class BuildSession {
     if (review.verdict === "fixlist") {
       const rel = this.writeFixlistFor(story, review, commit2, epicBase);
       const open2 = openFindings(review.fixlist).length;
+      if (open2 === 0) {
+        this.lines.push(`  · ${story.planned.story.id}: ${FIXLIST_SETTLED_MARK} (${rel})`);
+        await this.settle(story, "done", {
+          dod,
+          commit: commit2,
+          merged: true,
+          carried,
+          epicBase,
+          verdict: "fixlist",
+          review,
+          cost,
+          reason: null
+        });
+        return "settled";
+      }
       await this.settle(story, "review", {
         dod,
         commit: commit2,
@@ -39789,17 +40074,17 @@ class BuildSession {
       }
       findings3.push({ ...finding2, resolved: false, resolvedSha: null });
       refused2.push(`#${String(finding2.n)} — ${why}`);
-      text3 = markUnverified(text3 ?? readFileSync73(fixlist.path, "utf8"), finding2.n, why);
+      text3 = markUnverified(text3 ?? readFileSync74(fixlist.path, "utf8"), finding2.n, why);
       this.lines.push(`  · ${id}: fix-list finding #${String(finding2.n)} claimed \`Resolved: yes\` and ` + `${why} — recorded as \`${CLAIMED_UNVERIFIED}\`, and it still blocks \`done\``);
     }
-    const canonicalized = await canonicalizeResolutions(story.repoDir, findings3, text3 ?? readFileSync73(fixlist.path, "utf8"));
+    const canonicalized = await canonicalizeResolutions(story.repoDir, findings3, text3 ?? readFileSync74(fixlist.path, "utf8"));
     if (canonicalized.lines.length > 0) {
       text3 = canonicalized.text;
       for (const line of canonicalized.lines)
         this.lines.push(`  · ${id}: ${line}`);
     }
     if (text3 !== null)
-      writeFileSync17(fixlist.path, text3, "utf8");
+      writeFileSync18(fixlist.path, text3, "utf8");
     return { findings: canonicalized.findings, refused: refused2 };
   }
   async unverifiedBecause(story, sha) {
@@ -39891,19 +40176,36 @@ class BuildSession {
     return wave.stories.some((planned) => this.statusOf(planned) === "blocked");
   }
   blockingDependency(planned) {
+    const holds = [];
     for (const id of planned.story.depends_on) {
       const dependency = this.plan.stories.get(id);
       if (dependency === undefined)
         continue;
       const status = this.statusOf(dependency);
       if (status !== "done")
-        return { id, status };
+        holds.push({ id, status });
     }
-    return null;
+    return decidingHold(holds);
+  }
+  waitOnDependency(planned, held2) {
+    this.waits.set(planned.story.id, held2);
+    this.lines.push(dependencyWaitLine(planned.story.id, held2));
+  }
+  staleDependencyHold(planned) {
+    const path = join99(this.ctx.runDir, BUILD_PHASE, LOG_DIR, `${planned.story.id}.md`);
+    let named;
+    try {
+      named = dependencyHoldOfLog(readFileSync74(path, "utf8"));
+    } catch {
+      return null;
+    }
+    if (named === null)
+      return null;
+    return this.blockingDependency(planned) === null ? named : null;
   }
   blockOnDependency(planned, held2) {
     const id = planned.story.id;
-    const reason = held2.status === "blocked" ? `dependency ${held2.id} blocked` : `dependency ${held2.id} is \`${held2.status}\`, not \`done\``;
+    const reason = dependencyHoldReason(held2);
     const epic = this.plan.epics.get(planned.story.epic);
     const outcome = {
       id,
@@ -40076,7 +40378,7 @@ class BuildSession {
     this.tasks.push({
       key: story.planned.story.id,
       model: this.model(),
-      costUsd: round25(agent.costUsd),
+      costUsd: round23(agent.costUsd),
       sessionId: agent.sessionId,
       error: agent.error,
       role: "developer",
@@ -40086,7 +40388,7 @@ class BuildSession {
       durationMs: agent.durationMs
     });
     if (agent.ok) {
-      return { cost: round25(agent.costUsd), error: null, refused: agent.permissionRefusal };
+      return { cost: round23(agent.costUsd), error: null, refused: agent.permissionRefusal };
     }
     const error = (agent.error ?? "").trim() === "" ? DEVELOPER_FAILED : (agent.error ?? "").trim();
     this.ctx.emit("check.failed", {
@@ -40097,7 +40399,7 @@ class BuildSession {
       attempt: story.attempt,
       detail: error
     });
-    return { cost: round25(agent.costUsd), error, refused: null };
+    return { cost: round23(agent.costUsd), error, refused: null };
   }
   dodProves(dod) {
     return dod.length === 0 ? dodIsSatisfiedEmpty(this.plan) : dodGreen({ dod });
@@ -40268,7 +40570,7 @@ class BuildSession {
       });
       const parsed = agent.ok ? parseReview(agent.structured, agent.result) : reviewerFailed(agent.error);
       const review = this.narrowFixlist(id, parsed);
-      const turn = round25(agent.costUsd);
+      const turn = round23(agent.costUsd);
       const again = this.formatRetry(story, review, {
         costUsd: turn,
         sessionId: agent.sessionId,
@@ -40278,7 +40580,7 @@ class BuildSession {
       });
       if (again !== null) {
         refusal = again;
-        spent = round25(spent + turn);
+        spent = round23(spent + turn);
         continue;
       }
       this.recordReview(story, review, {
@@ -40291,7 +40593,7 @@ class BuildSession {
         source: "agent",
         reviewer: { model: reviewer.model, effort: reviewer.effort, basis: "spawned" }
       });
-      return { review, cost: round25(spent + turn) };
+      return { review, cost: round23(spent + turn) };
     }
   }
   formatRetry(story, review, task2) {
@@ -40492,17 +40794,18 @@ class BuildSession {
       ...outcome.permissionRefused == null ? {} : { permission_refused: outcome.permissionRefused },
       ...outcome.budgetDeath == null ? {} : { budget_death: outcome.budgetDeath },
       ...outcome.reviewerUnfunded == null ? {} : { reviewer_unfunded: outcome.reviewerUnfunded },
-      ...outcome.asIs == null ? {} : { as_is: true, as_is_by: outcome.asIs.actor, as_is_note: outcome.asIs.note }
+      ...outcome.asIs == null ? {} : { as_is: true, as_is_by: outcome.asIs.actor, as_is_note: outcome.asIs.note },
+      ...outcome.asIs?.reason === undefined ? {} : { as_is_reason: outcome.asIs.reason }
     });
     if (pruning && (rescued === null || rescued.worktree === null)) {
       await removeWorktree(story.repoDir, story.worktree);
     }
-    this.lines.push(`  ${status === "done" ? "✓" : "·"} ${id} → \`${status}\`` + (outcome.reason === null ? "" : ` (${outcome.reason})`) + (outcome.asIs == null ? "" : ` — ${AS_IS_MARK}; ${outcome.asIs.actor} signed it`) + (outcome.permissionRefused == null ? "" : ` — ${withCure(`\`${outcome.permissionRefused}\` was refused for approval; the tree held committed work, so the DoD decided`, outcome.permissionRefused, outcome.declaredCommands)}`));
+    this.lines.push(`  ${status === "done" ? "✓" : "·"} ${id} → \`${status}\`` + (outcome.reason === null ? "" : ` (${outcome.reason})`) + (outcome.asIs == null ? "" : ` — ${outcome.asIs.reason === "review-only" ? AS_IS_REVIEW_ONLY_MARK : AS_IS_MARK}; ` + `${outcome.asIs.actor} signed it`) + (outcome.permissionRefused == null ? "" : ` — ${withCure(`\`${outcome.permissionRefused}\` was refused for approval; the tree held committed work, so the DoD decided`, outcome.permissionRefused, outcome.declaredCommands)}`));
   }
   writeLog(outcome) {
     const dir = join99(this.ctx.runDir, BUILD_PHASE, LOG_DIR);
     mkdirSync18(dir, { recursive: true });
-    writeFileSync17(join99(dir, `${outcome.id}.md`), renderReviewLog(outcome), "utf8");
+    writeFileSync18(join99(dir, `${outcome.id}.md`), renderReviewLog(outcome), "utf8");
   }
   recordStoryFeedback(outcome) {
     appendBuildRetro(this.ctx.runDir, storyRetroLines(outcome, this.ctx.runId));
@@ -40546,11 +40849,12 @@ class BuildSession {
       for (const planned of wave.stories) {
         if (named.has(planned.story.id))
           continue;
+        const wait = this.waits.get(planned.story.id);
         rows.push({
           id: planned.story.id,
           rel: this.plan.implicit ? IMPLICIT_PLAN_REL : planned.rel,
           status: this.statusOf(planned),
-          reason: "this stage recorded no attempt and no reason for it — " + "nothing here says the work was done, and nothing says why it was not"
+          reason: wait !== undefined ? dependencyWaitReason(wait) : "this stage recorded no attempt and no reason for it — " + "nothing here says the work was done, and nothing says why it was not"
         });
       }
     }
@@ -40561,7 +40865,7 @@ class BuildSession {
     mkdirSync18(join99(path, ".."), { recursive: true });
     const cost = phaseCostToDate(this.ctx.runDir, this.ctx.phaseId, this.ctx.stageId, this.spent(), this.tasks, storySpendToDate(this.ctx.runDir, this.ctx.phaseId, this.ctx.stageId, this.tasks));
     const carried = this.carriedRows();
-    writeFileSync17(path, renderBuildHandoff({
+    writeFileSync18(path, renderBuildHandoff({
       runId: this.ctx.runId,
       stageId: this.ctx.stageId,
       model: this.model(),
@@ -40594,7 +40898,7 @@ class BuildSession {
   }
   wideningRows() {
     try {
-      return wideningRows(readFileSync73(join99(this.ctx.runDir, EVENTS_FILE2), "utf8"));
+      return wideningRows(readFileSync74(join99(this.ctx.runDir, EVENTS_FILE2), "utf8"));
     } catch {
       return [];
     }
@@ -40812,7 +41116,7 @@ class BuildSession {
             `  ${namePaths(row2.paths)}`,
             "  Commit them, or set them aside by hand, then run " + `\`${relaunchCommand(this.ctx.mode, this.ctx.runId)}\`.`
           ],
-          error: `repo \`${row2.repo}\` has uncommitted changes that could not be set aside`
+          error: `repo \`${row2.repo}\` has uncommitted changes that could not be set aside: ` + `${outcome.reason ?? "no reason given"}`
         };
       }
       this.ctx.emit(FOREIGN_ASIDE_EVENT, asidePayload(outcome.stash, reason));
@@ -40823,7 +41127,7 @@ class BuildSession {
   async restoreForeignWorkAside() {
     let open;
     try {
-      open = pendingAsides(readFileSync73(join99(this.ctx.runDir, EVENTS_FILE2), "utf8"), (repo) => {
+      open = pendingAsides(readFileSync74(join99(this.ctx.runDir, EVENTS_FILE2), "utf8"), (repo) => {
         try {
           return repoDirOf(this.workspace, repo);
         } catch {
@@ -40852,7 +41156,7 @@ class BuildSession {
         const status = this.statusOf(planned);
         if (status === "done")
           continue;
-        if (status === "blocked" && this.blockedByFailedDeveloper(planned) === null)
+        if (status === "blocked" && this.blockedByFailedDeveloper(planned) === null && this.staleDependencyHold(planned) === null)
           continue;
         rows.push(planned);
       }
@@ -40870,16 +41174,16 @@ class BuildSession {
     if (fresh !== undefined)
       return fresh.status;
     try {
-      const value = /^status\s*:\s*(\w+)\s*$/m.exec(readFileSync73(planned.path, "utf8"))?.[1];
+      const value = /^status\s*:\s*(\w+)\s*$/m.exec(readFileSync74(planned.path, "utf8"))?.[1];
       return isPlanStatus2(value) ? value : planned.story.status;
     } catch {
       return planned.story.status;
     }
   }
   setStoryStatus(planned, status, evidence) {
-    const text3 = readFileSync73(planned.path, "utf8");
+    const text3 = readFileSync74(planned.path, "utf8");
     const patched = this.plan.implicit ? updateImplicitPlan(text3, { status, evidence }) : updateStoryFront(text3, { status, evidence });
-    writeFileSync17(planned.path, patched, "utf8");
+    writeFileSync18(planned.path, patched, "utf8");
   }
   updateEpicStatus(epic) {
     const statuses = epic.epic.stories.map((id) => {
@@ -40887,7 +41191,7 @@ class BuildSession {
       return planned === undefined ? "todo" : this.statusOf(planned);
     });
     const status = statuses.every((s) => s === "done") ? "done" : statuses.some((s) => s === "blocked") ? "blocked" : "in_progress";
-    writeFileSync17(epic.path, updateStoryFront(readFileSync73(epic.path, "utf8"), { status }), "utf8");
+    writeFileSync18(epic.path, updateStoryFront(readFileSync74(epic.path, "utf8"), { status }), "utf8");
     return status;
   }
   noteMerged(story, carried) {
@@ -40957,7 +41261,7 @@ class BuildSession {
     if (!existsSync83(path))
       return null;
     try {
-      const doc = JSON.parse(readFileSync73(path, "utf8"));
+      const doc = JSON.parse(readFileSync74(path, "utf8"));
       return typeof doc.session_id === "string" && doc.session_id !== "" ? doc.session_id : null;
     } catch {
       return null;
@@ -41021,6 +41325,11 @@ class BuildSession {
       storyCapFloorUsd: this.ctx.spec.tuning.storyCapFloorUsd
     };
   }
+  get capLever() {
+    return {
+      raiseCommand: (usd3) => stageRaiseCommand(this.ctx.runId, this.ctx.phaseId, this.ctx.stageId, usd3)
+    };
+  }
   get attempts() {
     return this.ctx.spec.tuning.attempts;
   }
@@ -41028,7 +41337,7 @@ class BuildSession {
     return this.ctx.spec.tuning.fixlistRounds;
   }
   spent() {
-    return round25(this.tasks.reduce((sum, task2) => sum + task2.costUsd, 0));
+    return round23(this.tasks.reduce((sum, task2) => sum + task2.costUsd, 0));
   }
   logPaths() {
     return [...this.outcomes.values()].map((outcome) => outcome.reviewRel);
@@ -41141,7 +41450,7 @@ class BuildSession {
     const path = join99(this.ctx.runDir, BUILD_PHASE, LOG_DIR, `${storyId}.md`);
     if (!this.hasPriorAttempt(storyId) || !existsSync83(path))
       return "";
-    return readFileSync73(path, "utf8").trimEnd().split(`
+    return readFileSync74(path, "utf8").trimEnd().split(`
 `).map((line) => `> ${line}`).join(`
 `);
   }
@@ -41190,9 +41499,6 @@ function permissionBlockReason(command2, options = {}) {
 function diedOnCap(error) {
   return error.includes("Reached maximum budget");
 }
-function capDeathReason(error) {
-  return `the developer died on its per-story cap — ${error}: the ceiling is derived from ` + "`03-plan/budget.yml`'s price for this story, so a story that really costs more than the " + "plan guessed wants a higher price there or a higher `story_cap_multiplier:` on the stage";
-}
 var REVIEWER_TOOLS = ["Read", "Grep", "Glob", "Bash(git diff *)"];
 function summaryOf(envelope) {
   return typeof envelope.summary === "string" ? envelope.summary : "";
@@ -41221,7 +41527,7 @@ function failed3(ctx, error, tasks) {
     ok: false,
     awaiting: false,
     tasks,
-    costUsd: round25(tasks.reduce((sum, task2) => sum + task2.costUsd, 0)),
+    costUsd: round23(tasks.reduce((sum, task2) => sum + task2.costUsd, 0)),
     outputs: [],
     lines: [`${ctx.phaseId}/${ctx.stageId} failed: ${error}`],
     error
@@ -41401,7 +41707,7 @@ function preparedRefusal(store, options, notes) {
     `  finish it:  run ${where}/prompt.md, write ${where}/result.json, then \`tldrx next --commit ${store.runId}\``,
     `  drop it:    \`tldrx reject --run ${store.runId} --note "…"\``,
     `  redo it:    \`tldrx next --discard-pending\` (throws the bundle away and runs the stage again)`
-  ]);
+  ], [], `${entry.phase.id}/${entry.stage.id} has a --prepare bundle waiting and nothing is holding the run`);
 }
 function demoteStaleRunning(store, deadPid) {
   const stuck = [];
@@ -41547,7 +41853,8 @@ async function runStage(store, options, phaseId, stageId, spec, notes) {
   if (options.mode === "prepare" || options.dryRun)
     notes.push(...renderLedger(ledger4));
   if (ledger4.overLimit) {
-    return out(EXIT_REFUSED2, [...notes, ...renderRefusal(ledger4, stageId)]);
+    const refusal = renderRefusal(ledger4, stageId);
+    return out(EXIT_REFUSED2, [...notes, ...refusal], [], refusal[0]);
   }
   const providerAdvisory = providerBudgetAdvisory(agentProvider(), cap2);
   const advisories = [
@@ -41715,7 +42022,7 @@ function saveOverflow(store, options, phaseId, type, field, text3) {
   const relPath = `${phaseId}/${LOG_DIR}/overflow/${stamp2}-${String(overflowSeq)}-${type}-${field}.txt`;
   try {
     mkdirSync19(join100(store.runDir, phaseId, LOG_DIR, "overflow"), { recursive: true });
-    writeFileSync18(join100(store.runDir, relPath), text3, "utf8");
+    writeFileSync19(join100(store.runDir, relPath), text3, "utf8");
     return `omitted text saved at ${relPath}`;
   } catch (error) {
     return `could not be saved: ${error instanceof Error ? error.message : String(error)}`;
@@ -41804,7 +42111,7 @@ async function preconditionRefusal(store, options, phaseId, stageId, spec, notes
       `refusing to dispatch ${phaseId}/${stageId} — precondition \`${precondition.id}\` is red.`,
       `  ${ran.detail}`,
       `Fix it and run the same command again: the stage is still \`${stageStatusOf(store, phaseId, stageId)}\` and nothing was spent.`
-    ]);
+    ], [], `${phaseId}/${stageId}: precondition \`${precondition.id}\` is red — ${ran.detail}`);
   }
   return null;
 }
@@ -41830,7 +42137,7 @@ function economyRefusal(store, options, phaseId, stageId, notes) {
     `refusing to spawn — ${phaseId} is priced in \`host-tokens\` ` + `($${ceiling.toFixed(2)} is not dollars a spawn may`,
     "spend) and this invocation is headless. Either run it in-session (tldrx next --prepare), or set the",
     `phase to \`economy: metered-usd\` and re-price it (tldrx budget raise ${phaseId} <usd>).`
-  ]);
+  ], [], `${phaseId}/${stageId}: refusing to spawn — ${phaseId} is priced in \`host-tokens\` ($${ceiling.toFixed(2)}) and this invocation is headless`);
 }
 function budgetRefusal(store, options, phaseId, stageId, spec, notes) {
   const stage2 = requireStage(store, phaseId, stageId);
@@ -41870,7 +42177,7 @@ function budgetRefusal(store, options, phaseId, stageId, spec, notes) {
       ...work.basis === "plan" ? [renderRemainingWork(work), ...remainingWorkContext(work)] : [],
       `Run \`${fix}\` (add \`--take-from <phase>\` to move the money instead of adding it), ` + `lower budget_usd in the stage, or set on_exceed: warn.`,
       `See the whole picture first: \`tldrx budget show --run ${store.runId}\`.`
-    ]);
+    ], [], `${phaseId}/${stageId}: phase ${phaseId} has $${phaseRemaining.toFixed(2)} left and the estimate is $${estimate.toFixed(2)}`);
   }
   warnOnce(store, options, phaseId, stageId, estimate, phaseRemaining, spec.tuning.attempts, notes);
   return null;
@@ -41986,7 +42293,7 @@ async function runExecutor(store, options, phaseId, stageId, spec, notes, execut
       mapStage2(store, phaseId, stageId, () => stageOnEntry);
       store.save();
     }
-    return out(EXIT_USAGE3, [...notes, ...outcome.lines]);
+    return out(EXIT_USAGE3, [...notes, ...outcome.lines], [], executorSignature(outcome));
   }
   claimEpicBranches(store, outcome.epicBranches, outcome.branchModel);
   try {
@@ -42008,7 +42315,7 @@ async function runExecutor(store, options, phaseId, stageId, spec, notes, execut
   if (outcome.refused === true) {
     setStatus(store, phaseId, stageId, "ready");
     store.save();
-    return out(EXIT_REFUSED2, [...notes, ...outcome.lines]);
+    return out(EXIT_REFUSED2, [...notes, ...outcome.lines], [], executorSignature(outcome));
   }
   if (!outcome.ok) {
     return failStage(store, options, phaseId, stageId, outcome.error ?? "the executor failed", notes);
@@ -42140,7 +42447,7 @@ async function commitStage(store, options, phaseId, stageId, spec, notes) {
       `${phaseId}/questions.md has ${unreadable.length} question(s) the parser cannot read ` + `(${unreadable.join(", ")}) — a heading must be \`## Qn · <title>\` with the ` + "`<!-- id: Qn | status: open | area: … | asked_by: … | asked_at: … -->` line under it.",
       'As written they are invisible: the gate would read this file as "0 open" and sign itself.',
       `Fix: \`tldrx questions lint --run ${store.runId} --fix\`, then \`tldrx next --commit\` again.`
-    ]);
+    ], [], `${phaseId}/questions.md has ${String(unreadable.length)} unreadable question(s): ${unreadable.join(", ")}`);
   }
   return await finishStage(store, options, phaseId, stageId, spec, notes);
 }
@@ -42378,7 +42685,7 @@ function failStage(store, options, phaseId, stageId, reason, notes, tasksBefore)
     ...notes,
     `${phaseId}/${stageId} failed: ${oneLine7(reason)}`,
     `cost is recorded, not refunded — retry with \`tldrx next\`, or \`tldrx reject --note "…"\``
-  ]);
+  ], [], `${phaseId}/${stageId} failed: ${oneLine7(reason)}`);
 }
 function seedInputsOf(spec, stage2, ctx) {
   if (!spec.seedInputs)
@@ -42541,11 +42848,11 @@ function priorOutputs(options) {
   return [...out, ...blocks];
 }
 function readStageMd(planned) {
-  return readFileSync74(stageMdPath(planned.id, planned.source), "utf8");
+  return readFileSync75(stageMdPath(planned.id, planned.source), "utf8");
 }
 function readOrEmpty4(path) {
   try {
-    return readFileSync74(path, "utf8");
+    return readFileSync75(path, "utf8");
   } catch {
     return "";
   }
@@ -42754,7 +43061,7 @@ function hostTokensNote(store, options, phaseId, stageId, notes) {
     ...notes,
     `[tldrx] budget: refusing to start stage "${stageId}" — phase ${phaseId} is priced in \`host-tokens\` ` + `and has declared ${String(tokens3.spent)} of ${String(tokens3.ceiling)} allowed.`,
     "Raise that phase's ceiling in budget.yml (under this economy the number is a TOKEN allowance), " + "or set `on_host_tokens_exceed: warn` to go back to a note."
-  ]);
+  ], [], `${phaseId}/${stageId}: phase ${phaseId} has declared ${String(tokens3.spent)} of ${String(tokens3.ceiling)} allowed host-tokens`);
 }
 function declaredTokensIn(run, phaseId) {
   let tokens3 = 0;
@@ -42853,14 +43160,22 @@ function cacheSplit(cacheCreationTokens, cacheReadTokens) {
     ...reported(cacheReadTokens) ? { cache_read_input_tokens: cacheReadTokens } : {}
   };
 }
-function out(code, lines, stderr = []) {
+function executorSignature(outcome) {
+  return outcome.signature ?? outcome.error ?? undefined;
+}
+function out(code, lines, stderr = [], signature) {
   const held2 = lines.filter((line) => line.includes(NOT_RESTORED_MARK));
   const ordered = held2.length === 0 ? lines : [...lines.filter((line) => !line.includes(NOT_RESTORED_MARK)), ...held2];
-  return stderr.length === 0 ? { code, lines: ordered } : { code, lines: ordered, stderr };
+  return {
+    code,
+    lines: ordered,
+    ...stderr.length === 0 ? {} : { stderr },
+    ...signature === undefined ? {} : { signature }
+  };
 }
 
 // src/core/run/ship.ts
-import { existsSync as existsSync84, mkdtempSync as mkdtempSync2, readFileSync as readFileSync75, rmSync as rmSync11, writeFileSync as writeFileSync19 } from "node:fs";
+import { existsSync as existsSync84, mkdtempSync as mkdtempSync2, readFileSync as readFileSync76, rmSync as rmSync11, writeFileSync as writeFileSync20 } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
 import { dirname as dirname13, join as join101, resolve as resolve11 } from "node:path";
 
@@ -43600,7 +43915,7 @@ function lastHandoff(runDir2, phases) {
       continue;
     let text3;
     try {
-      text3 = readFileSync75(path, "utf8");
+      text3 = readFileSync76(path, "utf8");
     } catch {
       continue;
     }
@@ -43625,7 +43940,7 @@ function writeShipBody(store, branch, handoff, stories, repoNames) {
     outcome: describeShipOutcome(store)
   });
   const path = join101(mkdtempSync2(join101(tmpdir2(), "tldrx-ship-")), "pr-body.md");
-  writeFileSync19(path, text3, "utf8");
+  writeFileSync20(path, text3, "utf8");
   return { path, bytes: Buffer.byteLength(text3, "utf8"), handoffRel: handoff.rel, open: rows.length };
 }
 function bodyRecipe(body) {
@@ -43702,6 +44017,9 @@ function clipForLedger(text3) {
   const tail2 = text3.slice(-(LAST_LINE_CHARS - CLIP_HEAD_CHARS - 1));
   return `${text3.slice(0, CLIP_HEAD_CHARS)}…${tail2}`;
 }
+function comparandOf(signature, lines) {
+  return signature ?? lines[lines.length - 1] ?? "";
+}
 function relaunchVerdict(input) {
   const { code } = input;
   if (code === EXIT_OK5)
@@ -43724,14 +44042,14 @@ function relaunchVerdict(input) {
       reason: `the --until-done ${String(input.of)} bound is spent after ${String(input.attempt)} attempts`
     };
   }
-  if (input.previousLastLine !== null && input.lastLine === input.previousLastLine) {
+  if (input.previousComparand !== null && input.comparand === input.previousComparand) {
     return {
       relaunch: false,
-      reason: "its last line is the same as the previous attempt's — a refusal that repeats " + "verbatim is not one a relaunch moves"
+      reason: "its refusal is the same as the previous attempt's — a refusal that repeats " + "verbatim is not one a relaunch moves"
     };
   }
   const family = code === EXIT_AGENT_FAILED3 ? "a stage failed past --retry-failed" : code === EXIT_REFUSED3 ? "a refusal with no money behind it" : "the loop ended with exit 1";
-  return { relaunch: true, reason: `${family}: ${input.lastLine}` };
+  return { relaunch: true, reason: `${family}: ${input.comparand}` };
 }
 function budgetBlockedReason(fresh) {
   for (let i = fresh.length - 1;i >= 0; i--) {
@@ -43757,11 +44075,11 @@ async function runAuto(options) {
   };
   let runId = options.runId;
   let baseline = null;
-  let previousLastLine = null;
+  let previousComparand = null;
   for (let attempt = 1;; attempt++) {
     let outcome;
     try {
-      outcome = await runAutoOnce({ ...options, runId, onLine: say }, { attempt, of: bound, previousLastLine, baseline });
+      outcome = await runAutoOnce({ ...options, runId, onLine: say }, { attempt, of: bound, previousComparand, baseline });
     } catch (error) {
       const line = `run auto threw: ${error instanceof Error ? error.message : String(error)}`;
       say(line);
@@ -43770,10 +44088,11 @@ async function runAuto(options) {
     runId = outcome.runId ?? runId;
     baseline = outcome.baseline ?? baseline;
     const lastLine2 = outcome.lines[outcome.lines.length - 1] ?? "";
+    const comparand = comparandOf(outcome.signature, outcome.lines);
     const verdict2 = outcome.verdict ?? relaunchVerdict({
       code: outcome.code,
-      lastLine: lastLine2,
-      previousLastLine,
+      comparand,
+      previousComparand,
       held: null,
       attempt,
       of: bound,
@@ -43799,11 +44118,12 @@ async function runAuto(options) {
         exit: outcome.code,
         attempt,
         of: bound,
-        last_line: clipForLedger(lastLine2)
+        last_line: clipForLedger(lastLine2),
+        comparand: clipForLedger(comparand)
       }
     });
     say(`relaunching run auto after exit ${String(outcome.code)} — ${verdict2.reason} ` + `(relaunch ${String(attempt)} of ${String(bound)}, --until-done)`);
-    previousLastLine = lastLine2;
+    previousComparand = comparand;
   }
 }
 async function runAutoOnce(options, supervision) {
@@ -43814,16 +44134,17 @@ async function runAutoOnce(options, supervision) {
   };
   let resolved = null;
   let baseline = supervision?.baseline ?? null;
-  const leave = (code, held2 = null) => ({
+  const leave = (code, held2 = null, signature) => ({
     code,
     lines,
+    ...signature === undefined ? {} : { signature },
     runId: resolved?.runId ?? null,
     runDir: resolved?.runDir ?? null,
     baseline,
     verdict: supervision === undefined ? null : relaunchVerdict({
       code,
-      lastLine: lines[lines.length - 1] ?? "",
-      previousLastLine: supervision.previousLastLine,
+      comparand: comparandOf(signature, lines),
+      previousComparand: supervision.previousComparand,
       held: held2,
       attempt: supervision.attempt,
       of: supervision.of,
@@ -43894,10 +44215,10 @@ async function runAutoOnce(options, supervision) {
       await notifier.send(statusNotification(notifyCtx(), text3, stillBlocking(runDir2), gate2, cutInputs(stageIdOf()), gate2 === null ? null : gateStories(runDir2, gate2.phase)), stageIdOf());
     })();
   }, options.notifyEveryMs);
-  const finish = async (code, spentUsd, held2 = null) => {
+  const finish = async (code, spentUsd, held2 = null, signature) => {
     if (heartbeat !== null)
       clearInterval(heartbeat);
-    const outcome = leave(code, held2 ?? budgetBlockedReason(readEvents3(log).slice(attemptStart)));
+    const outcome = leave(code, held2 ?? budgetBlockedReason(readEvents3(log).slice(attemptStart)), signature);
     if (outcome.verdict?.relaunch === true)
       return outcome;
     if (notifier !== null) {
@@ -43919,7 +44240,7 @@ async function runAutoOnce(options, supervision) {
   };
   const heldForeignWork = () => {
     try {
-      return notRestoredSummary(readFileSync76(join102(runDir2, "events.jsonl"), "utf8"));
+      return notRestoredSummary(readFileSync77(join102(runDir2, "events.jsonl"), "utf8"));
     } catch {
       return null;
     }
@@ -44142,7 +44463,7 @@ async function runAutoOnce(options, supervision) {
         if (outcome.code === EXIT_AGENT_FAILED3 && retryBound > 0) {
           say(`stopped: ${String(consecutiveFailures)} consecutive stage failures at ${cursorBefore} ` + `— the --retry-failed ${String(retryBound)} bound is spent, and the exit code is still ` + "5, the failure's own");
         }
-        return await finish(outcome.code, spentByLoop);
+        return await finish(outcome.code, spentByLoop, null, outcome.signature);
       }
       const after = RunStore.open(runDir2);
       if (fresh.length === 0 && `${after.run.cursor.phase}/${after.run.cursor.stage}` === cursorBefore) {
@@ -44491,7 +44812,7 @@ function event5(options, runId, payload2) {
   return { ts: options.at, run: runId, stage: null, type: "run.attended", actor: options.actor, cost_usd: 0, payload: payload2 };
 }
 // src/core/status/initQuestionsItem.ts
-import { existsSync as existsSync85, readFileSync as readFileSync77 } from "node:fs";
+import { existsSync as existsSync85, readFileSync as readFileSync78 } from "node:fs";
 import { join as join103 } from "node:path";
 var MAX_LISTED = 5;
 function initQuestionsItem(root2) {
@@ -44500,7 +44821,7 @@ function initQuestionsItem(root2) {
     return null;
   let open;
   try {
-    open = openBlocks(parseQuestions(readFileSync77(path, "utf8")).blocks);
+    open = openBlocks(parseQuestions(readFileSync78(path, "utf8")).blocks);
   } catch {
     return null;
   }
@@ -44520,7 +44841,7 @@ function initQuestionsItem(root2) {
 }
 
 // src/core/status/seedSplitItems.ts
-import { closeSync as closeSync2, existsSync as existsSync87, openSync as openSync2, readSync, readdirSync as readdirSync27, readFileSync as readFileSync78, statSync as statSync23 } from "node:fs";
+import { closeSync as closeSync2, existsSync as existsSync87, openSync as openSync2, readSync, readdirSync as readdirSync27, readFileSync as readFileSync79, statSync as statSync23 } from "node:fs";
 import { basename as basename14, join as join105, relative as relative19 } from "node:path";
 
 // src/core/seed/triageInventory.ts
@@ -44720,7 +45041,7 @@ function proposedSplits(root2) {
     try {
       if (!statSync23(dir).isDirectory() || !existsSync87(path))
         continue;
-      const file = readSplitFile(parseYaml(readFileSync78(path, "utf8")));
+      const file = readSplitFile(parseYaml(readFileSync79(path, "utf8")));
       if (file.status !== "proposed" && file.status !== "applying")
         continue;
       found.push({ path, rel: toRel(root2, path), dir, file });
@@ -44788,7 +45109,7 @@ function seedDocuments2(dir, file) {
   const inventory = join105(dir, "inventory.json");
   if (existsSync87(inventory)) {
     try {
-      const doc = JSON.parse(readFileSync78(inventory, "utf8"));
+      const doc = JSON.parse(readFileSync79(inventory, "utf8"));
       const rels2 = (doc.documents ?? []).map((row2) => row2.rel).filter((rel) => typeof rel === "string");
       if (rels2.length > 0)
         return rels2;
@@ -44824,7 +45145,7 @@ function cachedStatuses(dir) {
   if (!existsSync87(inventory))
     return out2;
   try {
-    const doc = JSON.parse(readFileSync78(inventory, "utf8"));
+    const doc = JSON.parse(readFileSync79(inventory, "utf8"));
     for (const row2 of doc.documents ?? []) {
       if (typeof row2.rel === "string" && typeof row2.adrStatus === "string")
         out2.set(row2.rel, row2.adrStatus);
@@ -45141,7 +45462,7 @@ function resolveWorkspaceRoot(explicit, start = process.cwd()) {
   return findWorkspaceRoot2(start) ?? resolve12(start);
 }
 // src/core/experts/stageCoverage.ts
-import { existsSync as existsSync89, readdirSync as readdirSync28, readFileSync as readFileSync79, statSync as statSync24 } from "node:fs";
+import { existsSync as existsSync89, readdirSync as readdirSync28, readFileSync as readFileSync80, statSync as statSync24 } from "node:fs";
 import { join as join107 } from "node:path";
 function stagesLoadingExperts(root2) {
   const repos = workspaceRepos(root2);
@@ -45201,7 +45522,7 @@ function readStage(root2, id) {
   if (!existsSync89(path))
     return null;
   try {
-    const doc = parseYaml(readFileSync79(path, "utf8"));
+    const doc = parseYaml(readFileSync80(path, "utf8"));
     return isRecord(doc) ? doc : null;
   } catch {
     return null;
@@ -45212,7 +45533,7 @@ function workspaceRepos(root2) {
   if (!existsSync89(path))
     return [];
   try {
-    const doc = parseYaml(readFileSync79(path, "utf8"));
+    const doc = parseYaml(readFileSync80(path, "utf8"));
     const list = isRecord(doc) && Array.isArray(doc.repos) ? doc.repos : [];
     return list.map((row2) => isRecord(row2) && typeof row2.name === "string" ? row2.name : "").filter((name) => name !== "");
   } catch {
@@ -45305,7 +45626,7 @@ function expertListJson(experts, loads) {
   })), null, 2);
 }
 // src/core/experts/createExpert.ts
-import { mkdirSync as mkdirSync20, existsSync as existsSync90, writeFileSync as writeFileSync20 } from "node:fs";
+import { mkdirSync as mkdirSync20, existsSync as existsSync90, writeFileSync as writeFileSync21 } from "node:fs";
 import { join as join108 } from "node:path";
 var EXPERT_NAME_RE = /^[a-z0-9-]{1,32}$/;
 function planAreas(options) {
@@ -45362,8 +45683,8 @@ async function createExpert(options) {
     repos
   });
   mkdirSync20(dir, { recursive: true });
-  writeFileSync20(expertPath, body, "utf8");
-  writeFileSync20(competenciesPath, "# Written by `tldrx expert create` (spec §2.6). `level` is computed, never hand-set.\n" + stringifyYaml(buildCompetenciesDocument(options.name, areas)), "utf8");
+  writeFileSync21(expertPath, body, "utf8");
+  writeFileSync21(competenciesPath, "# Written by `tldrx expert create` (spec §2.6). `level` is computed, never hand-set.\n" + stringifyYaml(buildCompetenciesDocument(options.name, areas)), "utf8");
   if (kind === "role")
     mkdirSync20(join108(dir, KNOWLEDGE_DIRNAME), { recursive: true });
   return {
@@ -45562,7 +45883,7 @@ function sharedCitationWarnings(shared) {
   return shared.map((row2) => `warning: shared citation ${row2.src} by ${row2.experts.join(",")} — check for contradiction`);
 }
 // src/core/training/mineRuns.ts
-import { existsSync as existsSync91, readFileSync as readFileSync80, readdirSync as readdirSync29, statSync as statSync25 } from "node:fs";
+import { existsSync as existsSync91, readFileSync as readFileSync81, readdirSync as readdirSync29, statSync as statSync25 } from "node:fs";
 import { join as join110, relative as relative20 } from "node:path";
 var MAX_RUN_FILES = 24;
 var MAX_RUN_BYTES = 64 * 1024;
@@ -45599,7 +45920,7 @@ function mineRuns(options) {
     }
     let text3;
     try {
-      text3 = readFileSync80(candidate.abs, "utf8");
+      text3 = readFileSync81(candidate.abs, "utf8");
     } catch {
       notRead.push(candidate.path);
       continue;
@@ -45663,7 +45984,7 @@ function runRepos(path) {
   if (!existsSync91(path))
     return [];
   try {
-    const doc = parseYaml(readFileSync80(path, "utf8"));
+    const doc = parseYaml(readFileSync81(path, "utf8"));
     const repos = doc?.repos;
     if (!Array.isArray(repos))
       return [];
@@ -46383,7 +46704,7 @@ function estimateNextStage(root2, runId) {
 function runRemainingOf(store, phaseId, stageId, work) {
   const stages = [];
   let staticUsd = 0;
-  let usd2 = 0;
+  let usd3 = 0;
   let done = 0;
   for (const entry of flatten(store.run)) {
     if (isTerminal(entry.stage.status)) {
@@ -46393,9 +46714,9 @@ function runRemainingOf(store, phaseId, stageId, work) {
     stages.push(`${entry.phase.id}/${entry.stage.id}`);
     staticUsd += entry.stage.budget_usd;
     const isCursor = entry.phase.id === phaseId && entry.stage.id === stageId;
-    usd2 += isCursor && work.basis === "plan" ? work.usd : entry.stage.budget_usd;
+    usd3 += isCursor && work.basis === "plan" ? work.usd : entry.stage.budget_usd;
   }
-  return { stages, done, staticUsd: round10(staticUsd), usd: round10(usd2) };
+  return { stages, done, staticUsd: round10(staticUsd), usd: round10(usd3) };
 }
 function renderEstimate(estimate) {
   const lines = [
@@ -46901,7 +47222,7 @@ var statusCommand = {
 };
 
 // src/core/seed/runTriage.ts
-import { mkdirSync as mkdirSync21, readFileSync as readFileSync81, writeFileSync as writeFileSync21, existsSync as existsSync93 } from "node:fs";
+import { mkdirSync as mkdirSync21, readFileSync as readFileSync82, writeFileSync as writeFileSync22, existsSync as existsSync93 } from "node:fs";
 import { isAbsolute as isAbsolute10, join as join111, relative as relative21, resolve as resolve15 } from "node:path";
 
 // src/core/seed/renderInventory.ts
@@ -47161,8 +47482,8 @@ async function runTriage(options) {
   });
   const outDir = resolveOut(options);
   mkdirSync21(outDir, { recursive: true });
-  writeFileSync21(join111(outDir, INVENTORY_MD), renderInventory(inventory, options.seedPath, options.at), "utf8");
-  writeFileSync21(join111(outDir, INVENTORY_JSON), inventoryJson(inventory, options.seedPath, options.at), "utf8");
+  writeFileSync22(join111(outDir, INVENTORY_MD), renderInventory(inventory, options.seedPath, options.at), "utf8");
+  writeFileSync22(join111(outDir, INVENTORY_JSON), inventoryJson(inventory, options.seedPath, options.at), "utf8");
   if (options.propose !== true) {
     const where = display(options.root, outDir);
     const lines = options.json === true ? [inventoryJson(inventory, options.seedPath, options.at).replace(/\n$/, "")] : [
@@ -47318,8 +47639,8 @@ async function propose(options, workspaceCommands, inventory, seed, outDir) {
     created_at: options.at,
     ...validation.proposal
   };
-  writeFileSync21(join111(outDir, SPLIT_YML), emitSplitYaml(file), "utf8");
-  writeFileSync21(join111(outDir, SPLIT_MD), renderSplitMarkdown(file, where), "utf8");
+  writeFileSync22(join111(outDir, SPLIT_YML), emitSplitYaml(file), "utf8");
+  writeFileSync22(join111(outDir, SPLIT_MD), renderSplitMarkdown(file, where), "utf8");
   const over = metered && costUsd > ceiling + 0.000000001;
   return {
     code: EXIT_OK9,
@@ -47344,7 +47665,7 @@ function readTriageResult(outDir) {
   }
   let doc;
   try {
-    doc = JSON.parse(readFileSync81(path, "utf8"));
+    doc = JSON.parse(readFileSync82(path, "utf8"));
   } catch (error) {
     throw new PendingError(`${path} is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
   }
@@ -47385,7 +47706,7 @@ function round28(n) {
 }
 
 // src/core/seed/applySplit.ts
-import { existsSync as existsSync94, readFileSync as readFileSync82, writeFileSync as writeFileSync22 } from "node:fs";
+import { existsSync as existsSync94, readFileSync as readFileSync83, writeFileSync as writeFileSync23 } from "node:fs";
 import { dirname as dirname15, isAbsolute as isAbsolute11, join as join112, relative as relative22, resolve as resolve16 } from "node:path";
 var EXIT_OK10 = 0;
 var EXIT_USAGE7 = 1;
@@ -47397,7 +47718,7 @@ function applySplit(options) {
   }
   let file;
   try {
-    file = readSplitFile(parseYaml(readFileSync82(path, "utf8")));
+    file = readSplitFile(parseYaml(readFileSync83(path, "utf8")));
   } catch (error) {
     return fail2(EXIT_USAGE7, [error instanceof SplitError ? error.message : message5(error)]);
   }
@@ -47438,7 +47759,7 @@ function applySplit(options) {
   }
   const created = [];
   const stamp2 = (status) => {
-    writeFileSync22(path, emitSplitYaml({
+    writeFileSync23(path, emitSplitYaml({
       ...file,
       ...validation.proposal,
       status,
@@ -47483,11 +47804,11 @@ function applySplit(options) {
     applied_at: rfc33393(options.now),
     created_runs: created
   };
-  writeFileSync22(path, emitSplitYaml(applied), "utf8");
+  writeFileSync23(path, emitSplitYaml(applied), "utf8");
   const outRel = reference(options.root, dirname15(path));
   const markdown = join112(dirname15(path), SPLIT_MD);
   if (existsSync94(markdown))
-    writeFileSync22(markdown, renderSplitMarkdown(applied, outRel), "utf8");
+    writeFileSync23(markdown, renderSplitMarkdown(applied, outRel), "utf8");
   return {
     code: EXIT_OK10,
     created,
@@ -47522,7 +47843,7 @@ function splitUniverse(splitPath, file) {
   const inventory = join112(dirname15(splitPath), "inventory.json");
   if (existsSync94(inventory)) {
     try {
-      const doc = JSON.parse(readFileSync82(inventory, "utf8"));
+      const doc = JSON.parse(readFileSync83(inventory, "utf8"));
       const rels2 = (doc.documents ?? []).map((row2) => row2.rel).filter((rel) => typeof rel === "string");
       if (rels2.length > 0)
         return new Set(rels2);
@@ -47565,7 +47886,7 @@ function message5(error) {
 }
 
 // src/core/seed/answerSplitQuestion.ts
-import { existsSync as existsSync95, readFileSync as readFileSync83, writeFileSync as writeFileSync23 } from "node:fs";
+import { existsSync as existsSync95, readFileSync as readFileSync84, writeFileSync as writeFileSync24 } from "node:fs";
 import { dirname as dirname16, isAbsolute as isAbsolute12, join as join113, relative as relative23, resolve as resolve17 } from "node:path";
 var EXIT_OK11 = 0;
 var EXIT_USAGE8 = 1;
@@ -47579,7 +47900,7 @@ function answerSplitQuestion(options) {
     return { code: EXIT_NOT_FOUND9, lines: [`no such file: ${options.splitPath}`] };
   let file;
   try {
-    file = readSplitFile(parseYaml(readFileSync83(path, "utf8")));
+    file = readSplitFile(parseYaml(readFileSync84(path, "utf8")));
   } catch (error) {
     return { code: EXIT_USAGE8, lines: [error instanceof SplitError ? error.message : message6(error)] };
   }
@@ -47613,10 +47934,10 @@ function answerSplitQuestion(options) {
     ...validation.proposal,
     questions: questions.map((question) => question.id === options.id ? { ...question, answer: trimmed } : question)
   };
-  writeFileSync23(path, emitSplitYaml(answered), "utf8");
+  writeFileSync24(path, emitSplitYaml(answered), "utf8");
   const markdown = join113(dirname16(path), SPLIT_MD);
   if (existsSync95(markdown)) {
-    writeFileSync23(markdown, renderSplitMarkdown(answered, reference2(options.root, dirname16(path))), "utf8");
+    writeFileSync24(markdown, renderSplitMarkdown(answered, reference2(options.root, dirname16(path))), "utf8");
   }
   const open = answered.questions.filter((question) => question.answer === undefined).length;
   return {
@@ -47637,7 +47958,7 @@ function message6(error) {
 }
 
 // src/core/seed/checkSeed.ts
-import { mkdirSync as mkdirSync22, mkdtempSync as mkdtempSync3, rmSync as rmSync12, writeFileSync as writeFileSync24 } from "node:fs";
+import { mkdirSync as mkdirSync22, mkdtempSync as mkdtempSync3, rmSync as rmSync12, writeFileSync as writeFileSync25 } from "node:fs";
 import { tmpdir as tmpdir3 } from "node:os";
 import { join as join114 } from "node:path";
 var MAX_SEED_BULLET_CHARS = 200;
@@ -47983,7 +48304,7 @@ function importerVerdict(seed, preset, workspace) {
     const headings2 = allSeedHeadings(seed.documents);
     const indexPath = join114(temp, ...phase.split("/"), SEED_INDEX);
     mkdirSync22(join114(temp, phase), { recursive: true });
-    writeFileSync24(indexPath, renderSeedIndex("seed-check", seed, phase), "utf8");
+    writeFileSync25(indexPath, renderSeedIndex("seed-check", seed, phase), "utf8");
     const handoff = renderSeedHandoff({
       runId: "seed-check",
       stageId: stage2?.id ?? "what",
@@ -48024,7 +48345,7 @@ function budgetView(preset, ceiling, storyCount) {
       storyCount: Math.max(storyCount, 1),
       budgetUsd,
       maxBudgetUsd: Math.min(budgetUsd, plan.perAgentMax),
-      agentCap: (share = 1) => round25(budgetUsd * share),
+      agentCap: (share = 1) => round23(budgetUsd * share),
       attempts: buildStage.attempts
     };
     build = {
@@ -48056,7 +48377,7 @@ function renderSeedCheck(report3) {
       lines.push(`  ${stage2.id.padEnd(7)} ${`$${stage2.perAttemptUsd.toFixed(2)}`.padStart(8)} per attempt` + `  (${stage2.phase} holds $${stage2.phaseUsd.toFixed(2)} for ${String(stage2.attempts)} attempt(s))`);
     }
     if (b.build !== null) {
-      lines.push(`  per story, ${String(b.build.storyCount)} story(ies), no plan price yet: developer cap $${b.build.developerUsd.toFixed(2)}` + ` per attempt, reviewer cap $${b.build.reviewerUsd.toFixed(2)} (#244/#289 — a priced story gets` + " max(price x 3, $4.00) at dispatch; raise --budget if the cap does not cover the largest story)");
+      lines.push(`  per story, ${String(b.build.storyCount)} story(ies), no plan price yet: developer cap $${b.build.developerUsd.toFixed(2)}` + ` per attempt, reviewer cap $${b.build.reviewerUsd.toFixed(2)} (#244/#289 — a priced story gets` + " max(price x scale x 3, $4.00) at dispatch, scale being 1 only while the plan's prices sum inside" + " the stage (#281); raise --budget if the cap does not cover the largest story)");
     }
   }
   const stories = report3.stories.length;
@@ -48282,7 +48603,7 @@ function scopeRepos(names, repoNames) {
 }
 
 // src/cli/commands/answer.ts
-import { readFileSync as readFileSync84 } from "node:fs";
+import { readFileSync as readFileSync85 } from "node:fs";
 var QUESTION_ID_RE = /^Q\d{1,6}$/;
 var answerCommand2 = {
   name: "answer",
@@ -48397,7 +48718,7 @@ function locateQuestion(store, qid, status) {
     const path = join115(store.runDir, phase.id, "questions.md");
     if (!existsSync96(path))
       continue;
-    const block2 = parseQuestions(readFileSync84(path, "utf8")).blocks.find((b) => b.id === qid);
+    const block2 = parseQuestions(readFileSync85(path, "utf8")).blocks.find((b) => b.id === qid);
     if (block2 !== undefined && block2.metadata?.status === status)
       return { path, block: block2 };
   }
@@ -48405,7 +48726,7 @@ function locateQuestion(store, qid, status) {
 }
 
 // src/cli/commands/approve.ts
-import { existsSync as existsSync97, readFileSync as readFileSync85 } from "node:fs";
+import { existsSync as existsSync97, readFileSync as readFileSync86 } from "node:fs";
 import { relative as relative24 } from "node:path";
 var approveCommand2 = {
   name: "approve",
@@ -48490,7 +48811,7 @@ function readAgentEvidence(root2, store, override) {
     process.stderr.write(`tldrx approve: --as-agent refused — no evidence note at ${relative24(root2, path)}. ` + "Write one (`tldrx gate template` puts the blank form there), then sign with it.\n");
     return { kind: "stop", exit: EXIT_GATE_REFUSED };
   }
-  const text3 = readFileSync85(path, "utf8");
+  const text3 = readFileSync86(path, "utf8");
   const gate2 = `${entry.phase.id}/${entry.stage.id}`;
   const validation = validateEvidence(text3, toSrcContext(loadWorkspace(root2), store.runDir, { epicRefs: true }), { gate: gate2 });
   const refusals = validation.issues.filter((issue) => issue.kind === "verdict");
@@ -48750,7 +49071,7 @@ function budgetRaise(argv) {
           ...phase,
           stages: phase.stages.map((stage2) => stage2.id !== stageId ? stage2 : {
             ...stage2,
-            budget_usd: round25(stage2.budget_usd + amountUsd)
+            budget_usd: round23(stage2.budget_usd + amountUsd)
           })
         })
       }));
@@ -48773,7 +49094,7 @@ function budgetRaise(argv) {
         ...stageId === null || stageBefore === null ? {} : {
           stage: stageId,
           stage_budget_before: stageBefore,
-          stage_budget_after: round25(stageBefore + amountUsd)
+          stage_budget_after: round23(stageBefore + amountUsd)
         },
         note: stringFlag(args, "note") ?? ""
       }
@@ -48899,7 +49220,7 @@ function stageRaiseLines(phaseId, stageId, before, amountUsd) {
     ];
   }
   return [
-    `${phaseId}/${stageId} budget_usd $${before.toFixed(2)} → $${round25(before + amountUsd).toFixed(2)} ` + `(+$${amountUsd.toFixed(2)}) — every per-story and reviewer cap is derived from this figure.`
+    `${phaseId}/${stageId} budget_usd $${before.toFixed(2)} → $${round23(before + amountUsd).toFixed(2)} ` + `(+$${amountUsd.toFixed(2)}) — every per-story and reviewer cap is derived from this figure.`
   ];
 }
 
@@ -49062,7 +49383,7 @@ function resolveIncludingFinished(root2, wanted) {
 }
 
 // src/cli/commands/gate.ts
-import { existsSync as existsSync98, mkdirSync as mkdirSync23, writeFileSync as writeFileSync25 } from "node:fs";
+import { existsSync as existsSync98, mkdirSync as mkdirSync23, writeFileSync as writeFileSync26 } from "node:fs";
 import { dirname as dirname17, relative as relative25 } from "node:path";
 var VALUE_FLAGS5 = ["run", "root"];
 var gateCommand = {
@@ -49111,7 +49432,7 @@ function template(argv) {
       touchesAudited: countDeclaredTouches(ctx)
     };
     mkdirSync23(dirname17(path), { recursive: true });
-    writeFileSync25(path, renderEvidenceTemplate(input), "utf8");
+    writeFileSync26(path, renderEvidenceTemplate(input), "utf8");
     const lines = describeEvidenceTemplate(relative25(root2, path), input);
     process.stdout.write(`${lines.join(`
 `)}
@@ -49123,7 +49444,7 @@ function template(argv) {
 }
 
 // src/core/run/reopenStory.ts
-import { existsSync as existsSync99, readFileSync as readFileSync86, writeFileSync as writeFileSync26 } from "node:fs";
+import { existsSync as existsSync99, readFileSync as readFileSync87, writeFileSync as writeFileSync27 } from "node:fs";
 import { join as join116 } from "node:path";
 var EXIT_OK12 = 0;
 var EXIT_REFUSED8 = 2;
@@ -49228,7 +49549,7 @@ function reopenStory(options) {
   }
   let patched;
   try {
-    const text3 = readFileSync86(path, "utf8");
+    const text3 = readFileSync87(path, "utf8");
     patched = progress.implicit ? updateImplicitPlan(text3, { status: REOPENED_TO }) : updateStoryFront(text3, { status: REOPENED_TO });
   } catch (error) {
     if (error instanceof StoryWriteError) {
@@ -49245,7 +49566,7 @@ function reopenStory(options) {
       "  nothing was written — the note is the only free text in it, so it is almost certainly too long"
     ]);
   }
-  writeFileSync26(path, patched, "utf8");
+  writeFileSync27(path, patched, "utf8");
   store.append(event7);
   const kept = [
     "  its branch is kept, so the next developer starts from the commits the last one made " + "(the worktree is reopened from that branch if the build had removed it)",
@@ -49275,6 +49596,7 @@ function reopenStory(options) {
         `  signed by ${options.actor}: ${options.note}`,
         "  no developer will be spawned: the next Build turn runs the dod, the review and the merge " + "over the commits already on the story branch",
         "  it is not a shortcut past either gate — a red dod BLOCKS the story, and so does a branch " + "that carries no commit its epic has not already got; the refusal says which",
+        "  one named exception: work that is ALREADY on the epic with a review that never completed is " + "settled review-only — nothing merged, the dod on the epic head, the reviewer over the recorded range",
         "  the record will say the branch was taken as it stands and name you, so nothing reads as " + "though a developer delivered it",
         ...kept
       ]
@@ -49330,7 +49652,7 @@ function refuse4(lines) {
 }
 
 // src/core/run/widenStory.ts
-import { existsSync as existsSync100, readFileSync as readFileSync87, writeFileSync as writeFileSync27 } from "node:fs";
+import { existsSync as existsSync100, readFileSync as readFileSync88, writeFileSync as writeFileSync28 } from "node:fs";
 import { join as join117 } from "node:path";
 var EXIT_OK13 = 0;
 var EXIT_REFUSED9 = 2;
@@ -49410,7 +49732,7 @@ function widenStory(options) {
   if (!existsSync100(path)) {
     return refuse5([`${id} is \`${row2.status}\` but ${path} is not on disk — refusing to write a file that is not there`]);
   }
-  const text3 = readFileSync87(path, "utf8");
+  const text3 = readFileSync88(path, "utf8");
   const before = touchesIn(text3, progress.implicit);
   if (before === null) {
     return refuse5([
@@ -49466,7 +49788,7 @@ function widenStory(options) {
       "  nothing was written — the note is the only free text in it, so it is almost certainly too long"
     ]);
   }
-  writeFileSync27(path, patched, "utf8");
+  writeFileSync28(path, patched, "utf8");
   store.append(event7);
   return {
     code: EXIT_OK13,
@@ -49790,11 +50112,11 @@ var shipCommand = {
 import { join as join120 } from "node:path";
 
 // src/core/plan/syncDod.ts
-import { existsSync as existsSync102, readdirSync as readdirSync30, readFileSync as readFileSync89 } from "node:fs";
+import { existsSync as existsSync102, readdirSync as readdirSync30, readFileSync as readFileSync90 } from "node:fs";
 import { join as join119 } from "node:path";
 
 // src/core/plan/workspaceHistory.ts
-import { existsSync as existsSync101, readFileSync as readFileSync88, realpathSync } from "node:fs";
+import { existsSync as existsSync101, readFileSync as readFileSync89, realpathSync } from "node:fs";
 import { join as join118, relative as relative26, sep as sep10 } from "node:path";
 var WORKSPACE_REL = `${PROJECT_FRAMEWORK_DIR}/workspace.yml`;
 var MAX_VERSIONS = 50;
@@ -49802,7 +50124,7 @@ async function readWorkspaceHistory(root2) {
   const documents = [];
   const live2 = join118(root2, WORKSPACE_REL);
   if (existsSync101(live2)) {
-    const parsed = parse(readFileSync88(live2, "utf8"));
+    const parsed = parse(readFileSync89(live2, "utf8"));
     if (parsed !== null)
       documents.push(parsed);
   }
@@ -49892,7 +50214,7 @@ function planSyncDod(input) {
   };
 }
 function syncOne(path, name, input) {
-  const text3 = readFileSync89(path, "utf8");
+  const text3 = readFileSync90(path, "utf8");
   const id = name.replace(/\.md$/, "");
   const rel = `${STORIES_DIR}/${name}`;
   const repo = readStory(text3).repo ?? "";
@@ -50487,7 +50809,7 @@ function refusal(input, model2, share, expected) {
   ];
 }
 // src/core/training/ambientModel.ts
-import { readFileSync as readFileSync90 } from "node:fs";
+import { readFileSync as readFileSync91 } from "node:fs";
 import { join as join122 } from "node:path";
 function ambientModelFiles(root2, home) {
   return [
@@ -50510,7 +50832,7 @@ function resolveAmbientModel(input) {
 function modelIn(path) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync90(path, "utf8"));
+    parsed = JSON.parse(readFileSync91(path, "utf8"));
   } catch {
     return null;
   }
@@ -50582,11 +50904,11 @@ function noEvidenceNote(costUsd, added, warnings) {
   return lines;
 }
 // src/core/training/rescoreExperts.ts
-import { readFileSync as readFileSync93 } from "node:fs";
+import { readFileSync as readFileSync94 } from "node:fs";
 import { relative as relative27 } from "node:path";
 
 // src/core/training/competenciesWrite.ts
-import { existsSync as existsSync104, mkdirSync as mkdirSync24, readFileSync as readFileSync91, writeFileSync as writeFileSync28 } from "node:fs";
+import { existsSync as existsSync104, mkdirSync as mkdirSync24, readFileSync as readFileSync92, writeFileSync as writeFileSync29 } from "node:fs";
 import { dirname as dirname18, join as join124 } from "node:path";
 var HEADER = "# Written by `tldrx expert train` (spec §2.6). `level` is computed, never hand-set.\n";
 
@@ -50596,7 +50918,7 @@ function readDocument(root2, expert) {
   const path = join124(expertDir(root2, expert), COMPETENCIES_FILE);
   if (!existsSync104(path))
     throw new CompetenciesError(`${path} is missing — \`tldrx expert create\` writes it`);
-  const text3 = readFileSync91(path, "utf8");
+  const text3 = readFileSync92(path, "utf8");
   const parsed = parseYaml(text3);
   if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
     throw new CompetenciesError(`${path} is not a mapping`);
@@ -50656,7 +50978,7 @@ function writeCompetencies(options) {
   doc.status = options.status;
   doc.last_trained = options.lastTrained;
   mkdirSync24(dirname18(path), { recursive: true });
-  writeFileSync28(path, serialize(loaded, doc), "utf8");
+  writeFileSync29(path, serialize(loaded, doc), "utf8");
   return { ...write2, warnings };
 }
 function rejectBadEvidence(expert, areaId2, evidence) {
@@ -50695,7 +51017,7 @@ function recomputeCompetencies(options) {
   if (next === loaded.text)
     return { path, written: false, areas: recomputed, warnings };
   mkdirSync24(dirname18(path), { recursive: true });
-  writeFileSync28(path, next, "utf8");
+  writeFileSync29(path, next, "utf8");
   return { path, written: true, areas: recomputed, warnings };
 }
 function headerOf(text3) {
@@ -50709,7 +51031,7 @@ function str11(value) {
 }
 
 // src/core/training/trainingLog.ts
-import { appendFileSync as appendFileSync5, existsSync as existsSync105, mkdirSync as mkdirSync25, readFileSync as readFileSync92, statSync as statSync27 } from "node:fs";
+import { appendFileSync as appendFileSync4, existsSync as existsSync105, mkdirSync as mkdirSync25, readFileSync as readFileSync93, statSync as statSync27 } from "node:fs";
 import { dirname as dirname19, join as join125 } from "node:path";
 var TRAINING_EVENT_TYPES = [
   "agent.spawned",
@@ -50745,7 +51067,7 @@ class TrainingLog {
       throw new Error(`training record is ${String(bytes3)} bytes (max ${String(MAX_LINE_BYTES2)})`);
     const before = this.sizeBytes;
     mkdirSync25(dirname19(this.path), { recursive: true });
-    appendFileSync5(this.path, `${line}
+    appendFileSync4(this.path, `${line}
 `, "utf8");
     const after = this.sizeBytes;
     if (after < before + bytes3) {
@@ -50756,7 +51078,7 @@ class TrainingLog {
     if (!existsSync105(this.path))
       return [];
     const out2 = [];
-    for (const line of readFileSync92(this.path, "utf8").split(`
+    for (const line of readFileSync93(this.path, "utf8").split(`
 `)) {
       if (line.trim() === "")
         continue;
@@ -50906,7 +51228,7 @@ function rescoreExperts(options) {
       }
       const shape = minesRunRecord ? RUNS_SHAPE : LIGHT_SHAPE;
       const scope = knowledgeScopeFor(options.root, expert, area);
-      const parsed = parseKnowledgeFile(readFileSync93(file.path, "utf8"), srcCtx, shape, scope);
+      const parsed = parseKnowledgeFile(readFileSync94(file.path, "utf8"), srcCtx, shape, scope);
       if (!parsed.ok) {
         const errors2 = knowledgeErrors(parsed).length;
         skip(`the file does not validate under today's rules — ${String(errors2)} problem(s), so it is not evidence`);
@@ -50993,7 +51315,7 @@ function rescoreJson(rows) {
   return JSON.stringify(rows, null, 2);
 }
 // src/core/training/selectFiles.ts
-import { existsSync as existsSync107, readFileSync as readFileSync94, statSync as statSync29 } from "node:fs";
+import { existsSync as existsSync107, readFileSync as readFileSync95, statSync as statSync29 } from "node:fs";
 import { join as join126 } from "node:path";
 var MAX_SCANNED_FILES2 = 4000;
 var MAX_SCAN_BYTES2 = 512 * 1024;
@@ -51133,7 +51455,7 @@ function readDomains(root2, repos) {
     const path = join126(root2, PROJECT_FRAMEWORK_DIR, "map", repo, "domains.md");
     if (!existsSync107(path))
       continue;
-    for (const line of readFileSync94(path, "utf8").split(`
+    for (const line of readFileSync95(path, "utf8").split(`
 `)) {
       if (!line.startsWith("- "))
         continue;
@@ -51162,7 +51484,7 @@ function readCommunities(root2, repos, keywords) {
     }
     let text3;
     try {
-      text3 = readFileSync94(path, "utf8");
+      text3 = readFileSync95(path, "utf8");
     } catch {
       notes.push(`${repo}: graph.json could not be read`);
       continue;
@@ -51241,7 +51563,7 @@ function matches2(label2, keywords) {
 function contentHits(abs, keywords) {
   let text3;
   try {
-    text3 = readFileSync94(abs, "utf8").toLowerCase();
+    text3 = readFileSync95(abs, "utf8").toLowerCase();
   } catch {
     return [];
   }
@@ -51252,7 +51574,7 @@ function readCapped2(abs, remaining2) {
   try {
     if (statSync29(abs).size > MAX_SCAN_BYTES2)
       return null;
-    text3 = readFileSync94(abs, "utf8");
+    text3 = readFileSync95(abs, "utf8");
   } catch {
     return null;
   }
@@ -51825,7 +52147,7 @@ function skipNoteLines(expert, area, reason) {
   return [`${expert}/${area}: skipped — ${first2 ?? ""}`, ...rest.map((line) => `  ${line}`)];
 }
 // src/core/training/strayWrite.ts
-import { existsSync as existsSync108, mkdirSync as mkdirSync26, readdirSync as readdirSync33, readFileSync as readFileSync95, renameSync as renameSync4, rmdirSync as rmdirSync2, unlinkSync, writeFileSync as writeFileSync29 } from "node:fs";
+import { existsSync as existsSync108, mkdirSync as mkdirSync26, readdirSync as readdirSync33, readFileSync as readFileSync96, renameSync as renameSync4, rmdirSync as rmdirSync2, unlinkSync, writeFileSync as writeFileSync30 } from "node:fs";
 import { dirname as dirname20, join as join128, relative as relative28, resolve as resolve19 } from "node:path";
 function findStrayWrite(probe2) {
   const root2 = resolve19(probe2.root);
@@ -51848,7 +52170,7 @@ function recoverStrayWrite(stray, dest) {
     renameSync4(stray.path, dest);
   } catch {
     try {
-      writeFileSync29(dest, readFileSync95(stray.path, "utf8"), "utf8");
+      writeFileSync30(dest, readFileSync96(stray.path, "utf8"), "utf8");
       unlinkSync(stray.path);
     } catch {
       return { stray, recovered: existsSync108(dest), leftBehind: stray.path };
@@ -51897,7 +52219,7 @@ function describeStrayRecovery(root2, recovery, rel) {
   return lines;
 }
 // src/core/training/runTraining.ts
-import { existsSync as existsSync109, mkdirSync as mkdirSync27, readFileSync as readFileSync96, renameSync as renameSync5, rmSync as rmSync13, writeFileSync as writeFileSync30 } from "node:fs";
+import { existsSync as existsSync109, mkdirSync as mkdirSync27, readFileSync as readFileSync97, renameSync as renameSync5, rmSync as rmSync13, writeFileSync as writeFileSync31 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
 import { join as join129, relative as relative29 } from "node:path";
 var EXIT_OK14 = 0;
@@ -52079,7 +52401,7 @@ async function trainWithPreflight(options, said2) {
   const previous = prompts.map((task2) => ({
     path: join129(dir, task2.final),
     partial: join129(dir, task2.output),
-    content: existsSync109(join129(dir, task2.final)) ? readFileSync96(join129(dir, task2.final), "utf8") : null
+    content: existsSync109(join129(dir, task2.final)) ? readFileSync97(join129(dir, task2.final), "utf8") : null
   }));
   const tasks = [];
   for (const task2 of prompts) {
@@ -52193,7 +52515,7 @@ async function trainWithPreflight(options, said2) {
         "  nothing was written to competencies.yml and the status is unchanged"
       ]);
     }
-    const text3 = readFileSync96(abs, "utf8");
+    const text3 = readFileSync97(abs, "utf8");
     const shape = task2.key === CODE_TASK ? LIGHT_SHAPE : RUNS_SHAPE;
     let parsed = parseKnowledgeFile(text3, srcCtx, shape, scope);
     if (!parsed.ok && options.run === "headless") {
@@ -52364,14 +52686,14 @@ async function repairRound(input) {
     };
   }
   if (!existsSync109(abs)) {
-    writeFileSync30(abs, input.rejectedText, "utf8");
+    writeFileSync31(abs, input.rejectedText, "utf8");
     return {
       lines: [opened, "  the repair sub-agent removed the file instead of rewriting it"],
       spend,
       parsed: null
     };
   }
-  const parsed = parseKnowledgeFile(readFileSync96(abs, "utf8"), input.srcCtx, input.shape, input.scope);
+  const parsed = parseKnowledgeFile(readFileSync97(abs, "utf8"), input.srcCtx, input.shape, input.scope);
   const left = knowledgeErrors(parsed).length;
   return {
     lines: [
@@ -52401,11 +52723,11 @@ function quarantine(abs, header2 = []) {
   try {
     const body = header2.length === 0 ? null : `${header2.join(`
 `)}
-${readFileSync96(abs, "utf8")}`;
+${readFileSync97(abs, "utf8")}`;
     rmSync13(kept, { force: true });
     renameSync5(abs, kept);
     if (body !== null)
-      writeFileSync30(kept, body, "utf8");
+      writeFileSync31(kept, body, "utf8");
   } catch {
     return abs;
   }
@@ -52435,7 +52757,7 @@ function rollback(previous) {
       quarantine(entry.partial);
     if (entry.content !== null) {
       mkdirSync27(join129(entry.path, ".."), { recursive: true });
-      writeFileSync30(entry.path, entry.content, "utf8");
+      writeFileSync31(entry.path, entry.content, "utf8");
       continue;
     }
     if (existsSync109(entry.path))
@@ -52445,7 +52767,7 @@ function rollback(previous) {
 function setExpertStatus(path, status) {
   if (!existsSync109(path))
     return;
-  const lines = readFileSync96(path, "utf8").split(`
+  const lines = readFileSync97(path, "utf8").split(`
 `);
   if ((lines[0] ?? "").trimEnd() !== "---")
     return;
@@ -52457,7 +52779,7 @@ function setExpertStatus(path, status) {
       continue;
     const comment = line.indexOf("#", line.indexOf(":") + 1);
     lines[i] = comment === -1 ? `status: ${status}` : `status: ${status} ${line.slice(comment)}`;
-    writeFileSync30(path, lines.join(`
+    writeFileSync31(path, lines.join(`
 `), "utf8");
     return;
   }
@@ -52925,7 +53247,7 @@ function message8(error) {
 import { isAbsolute as isAbsolute13, join as join135 } from "node:path";
 
 // src/core/dashboard/model.ts
-import { existsSync as existsSync111, readFileSync as readFileSync97, readdirSync as readdirSync34 } from "node:fs";
+import { existsSync as existsSync111, readFileSync as readFileSync98, readdirSync as readdirSync34 } from "node:fs";
 import { basename as basename17, join as join131 } from "node:path";
 // src/core/replay/renderReplay.ts
 function renderReplay(loaded) {
@@ -53819,7 +54141,7 @@ function readWaves(path, unreadable) {
 }
 function read2(path, unreadable, label2) {
   try {
-    return readFileSync97(path, "utf8");
+    return readFileSync98(path, "utf8");
   } catch {
     unreadable.push(label2);
     return null;
@@ -55701,7 +56023,7 @@ function dashWavesView(model2) {
   return head2 + blocks.join("");
 }
 // src/core/dashboard/writeStatic.ts
-import { mkdirSync as mkdirSync28, writeFileSync as writeFileSync31 } from "node:fs";
+import { mkdirSync as mkdirSync28, writeFileSync as writeFileSync32 } from "node:fs";
 import { join as join132 } from "node:path";
 var DEFAULT_OUT_DIR = join132(PROJECT_FRAMEWORK_DIR, "cache", "dashboard");
 var INDEX_FILE = "index.html";
@@ -55710,7 +56032,7 @@ function writeStaticDashboard(root2, outDir, generatedAt, now = new Date) {
   const html = renderDashboard(model2);
   const path = join132(outDir, INDEX_FILE);
   mkdirSync28(outDir, { recursive: true });
-  writeFileSync31(path, html, "utf8");
+  writeFileSync32(path, html, "utf8");
   return {
     path,
     bytes: Buffer.byteLength(html, "utf8"),
@@ -56252,10 +56574,10 @@ function option2(argv, name) {
 }
 
 // src/cli/commands/retro.ts
-import { writeFileSync as writeFileSync33 } from "node:fs";
+import { writeFileSync as writeFileSync34 } from "node:fs";
 import { join as join137 } from "node:path";
 // src/core/retro/applyPractices.ts
-import { existsSync as existsSync113, mkdirSync as mkdirSync29, readFileSync as readFileSync98, writeFileSync as writeFileSync32 } from "node:fs";
+import { existsSync as existsSync113, mkdirSync as mkdirSync29, readFileSync as readFileSync99, writeFileSync as writeFileSync33 } from "node:fs";
 import { dirname as dirname21, join as join136 } from "node:path";
 var PRACTICES_FILE = "practices.md";
 var HEADER2 = [
@@ -56274,7 +56596,7 @@ function applyPractices(root2, run2, proposals, now = new Date) {
   if (proposals.length === 0) {
     return { path, appended: false, reason: "there are no practice proposals to apply" };
   }
-  const existing = existsSync113(path) ? readFileSync98(path, "utf8") : "";
+  const existing = existsSync113(path) ? readFileSync99(path, "utf8") : "";
   const stamp4 = `— run ${run2}`;
   if (existing.includes(stamp4)) {
     return { path, appended: false, reason: `practices.md already carries a block for run ${run2}` };
@@ -56286,7 +56608,7 @@ function applyPractices(root2, run2, proposals, now = new Date) {
 `) ? existing : `${existing}
 `;
   mkdirSync29(dirname21(path), { recursive: true });
-  writeFileSync32(path, `${base2}
+  writeFileSync33(path, `${base2}
 ${block2}`, "utf8");
   return { path, appended: true, reason: null };
 }
@@ -56440,7 +56762,7 @@ var retroCommand = {
     }
     const report3 = buildRetro(loaded);
     const path = join137(loaded.dir, RETRO_FILE);
-    writeFileSync33(path, report3.markdown, "utf8");
+    writeFileSync34(path, report3.markdown, "utf8");
     const lines = [
       `wrote ${path}`,
       `  ${report3.facts.length} fact(s) · ${report3.practices.length} practice proposal(s) ` + `· ${report3.stages.length} proposed stage(s)`
@@ -56823,7 +57145,7 @@ function theOneOpenRun() {
   }
 }
 // src/core/watch/watchViews.ts
-import { existsSync as existsSync114, readdirSync as readdirSync36, readFileSync as readFileSync99 } from "node:fs";
+import { existsSync as existsSync114, readdirSync as readdirSync36, readFileSync as readFileSync100 } from "node:fs";
 import { join as join138 } from "node:path";
 function watchersDir(runDir2) {
   return join138(runDir2, WATCH_PHASE, WATCHERS_DIR);
@@ -56835,7 +57157,7 @@ function loadCards(runDir2, ctx) {
   const cards = [];
   for (const name of readdirSync36(dir).filter((n) => n.endsWith(".md")).sort()) {
     const id = name.slice(0, -".md".length);
-    const text5 = readFileSync99(join138(dir, name), "utf8");
+    const text5 = readFileSync100(join138(dir, name), "utf8");
     cards.push({
       id,
       text: text5,
@@ -57596,7 +57918,7 @@ function quote4(value) {
   return JSON.stringify(value);
 }
 // src/core/adapters/processConfig.ts
-import { existsSync as existsSync116, readFileSync as readFileSync100 } from "node:fs";
+import { existsSync as existsSync116, readFileSync as readFileSync101 } from "node:fs";
 import { join as join140 } from "node:path";
 var PROCESS_FILE2 = "process.yml";
 var DISABLED = {
@@ -57615,7 +57937,7 @@ function readTicketToolConfig(root2) {
     return DISABLED;
   let doc;
   try {
-    doc = parseYaml(readFileSync100(path, "utf8"));
+    doc = parseYaml(readFileSync101(path, "utf8"));
   } catch {
     return { ...DISABLED, path };
   }
@@ -57777,7 +58099,7 @@ function strip(url) {
   return at === -1 ? url : url.slice(at);
 }
 // src/core/adapters/collect.ts
-import { existsSync as existsSync117, readdirSync as readdirSync37, readFileSync as readFileSync101 } from "node:fs";
+import { existsSync as existsSync117, readdirSync as readdirSync37, readFileSync as readFileSync102 } from "node:fs";
 import { join as join141 } from "node:path";
 var PLAN_PHASE3 = "03-plan";
 function collectMirrorItems(planDir, runId) {
@@ -57785,7 +58107,7 @@ function collectMirrorItems(planDir, runId) {
   const skipped = [];
   for (const name of markdownIn4(join141(planDir, EPICS_DIR))) {
     const path = join141(planDir, EPICS_DIR, name);
-    const text6 = readFileSync101(path, "utf8");
+    const text6 = readFileSync102(path, "utf8");
     const parsed = validateEpicFile(text6);
     const epic = parsed.epic;
     if (epic === null) {
@@ -57818,7 +58140,7 @@ function collectMirrorItems(planDir, runId) {
   }
   for (const name of markdownIn4(join141(planDir, STORIES_DIR))) {
     const path = join141(planDir, STORIES_DIR, name);
-    const text6 = readFileSync101(path, "utf8");
+    const text6 = readFileSync102(path, "utf8");
     const parsed = validateStoryFile(text6);
     const story = parsed.story;
     if (story === null) {
@@ -57863,7 +58185,7 @@ function reason(issues) {
   return first2.path === "" ? first2.message : `${first2.path}: ${first2.message}`;
 }
 // src/core/adapters/sync.ts
-import { readFileSync as readFileSync102, writeFileSync as writeFileSync34 } from "node:fs";
+import { readFileSync as readFileSync103, writeFileSync as writeFileSync35 } from "node:fs";
 function planSync(options) {
   const collected = collectMirrorItems(options.planDir, options.runId);
   const actions = new Map;
@@ -57907,14 +58229,14 @@ async function syncTickets(options) {
   return { results, skipped: collected.skipped, created, updated, dryRun: options.dryRun };
 }
 function writeBack(item, ref, externalStatus, sync) {
-  const before2 = readFileSync102(item.path, "utf8");
+  const before2 = readFileSync103(item.path, "utf8");
   const after = applyExternal(before2, {
     external: ref,
     ...sync === "two-way" ? { externalStatus } : {}
   });
   if (after === before2)
     return;
-  writeFileSync34(item.path, after, "utf8");
+  writeFileSync35(item.path, after, "utf8");
 }
 // src/core/adapters/statusTable.ts
 var DONE_LIKE = ["done", "closed", "resolved", "complete", "completed", "shipped"];
@@ -58159,7 +58481,7 @@ function renderSync(runId, provider, config, outcome) {
 }
 
 // src/cli/commands/interview.ts
-import { existsSync as existsSync120, readFileSync as readFileSync105 } from "node:fs";
+import { existsSync as existsSync120, readFileSync as readFileSync106 } from "node:fs";
 import { join as join144 } from "node:path";
 
 // src/core/interview/lineReader.ts
@@ -58273,7 +58595,7 @@ function renderNextSteps(hasRun) {
 }
 
 // src/core/interview/runInterview.ts
-import { existsSync as existsSync118, readFileSync as readFileSync103 } from "node:fs";
+import { existsSync as existsSync118, readFileSync as readFileSync104 } from "node:fs";
 
 // src/core/interview/reply.ts
 var LETTER_RE = /^[A-Ea-e]$/;
@@ -58314,7 +58636,7 @@ async function interview(options) {
   const { questionsPath, out: out2, ctx } = options;
   if (!existsSync118(questionsPath))
     throw new InterviewError(`no questions file at ${questionsPath}`);
-  const blocks = openBlocks(parseQuestions(readFileSync103(questionsPath, "utf8")).blocks);
+  const blocks = openBlocks(parseQuestions(readFileSync104(questionsPath, "utf8")).blocks);
   const answered = [];
   let skipped = 0;
   let quit = false;
@@ -58375,7 +58697,7 @@ function renderInterviewSummary(result2) {
 }
 
 // src/core/init/processAnswers.ts
-import { existsSync as existsSync119, readFileSync as readFileSync104 } from "node:fs";
+import { existsSync as existsSync119, readFileSync as readFileSync105 } from "node:fs";
 
 // src/core/init/githubProject.ts
 import { join as join143 } from "node:path";
@@ -58425,7 +58747,7 @@ function hasProcessAnswer(answers) {
 function collectProcessAnswers(questionsPath, answered) {
   if (answered.length === 0 || !existsSync119(questionsPath))
     return NO_PROCESS_ANSWERS;
-  const titles = new Map(parseQuestions(readFileSync104(questionsPath, "utf8")).blocks.map((block2) => [block2.id, block2.title]));
+  const titles = new Map(parseQuestions(readFileSync105(questionsPath, "utf8")).blocks.map((block2) => [block2.id, block2.title]));
   const find = (title) => answered.find((answer2) => titles.get(answer2.q) === title);
   const methodology = find(METHODOLOGY_QUESTION);
   const ticket = find(TICKET_QUESTION);
@@ -58463,7 +58785,7 @@ async function applyProcessAnswers(input) {
   }
   assertEnum(methodology, METHODOLOGIES, "methodology");
   assertEnum(ticketTool, TICKET_TOOLS, "ticket_tool.kind");
-  const before2 = existsSync119(path) ? readFileSync104(path, "utf8") : null;
+  const before2 = existsSync119(path) ? readFileSync105(path, "utf8") : null;
   const seed = before2 ?? PROCESS_HEADER + stringifyYaml(buildProcessDocument({
     methodology: null,
     approver: await gitUserName(input.runner, input.root),
@@ -58700,11 +59022,11 @@ No open questions.
   return "no-open-questions";
 }
 function countOpen(path) {
-  return openBlocks(parseQuestions(readFileSync105(path, "utf8")).blocks).length;
+  return openBlocks(parseQuestions(readFileSync106(path, "utf8")).blocks).length;
 }
 
 // src/cli/commands/questions.ts
-import { existsSync as existsSync121, readFileSync as readFileSync106, writeFileSync as writeFileSync35 } from "node:fs";
+import { existsSync as existsSync121, readFileSync as readFileSync107, writeFileSync as writeFileSync36 } from "node:fs";
 import { join as join145 } from "node:path";
 var VALUE_FLAGS15 = ["run", "root", "area"];
 var questionsCommand = {
@@ -58761,7 +59083,7 @@ function lint(argv) {
     const needSource = [];
     for (const path of files) {
       const rel = path.slice(store.runDir.length + 1);
-      const text6 = readFileSync106(path, "utf8");
+      const text6 = readFileSync107(path, "utf8");
       const readable = parseQuestions(text6).blocks.length;
       const lost = unreadableQuestionHeadings(text6);
       if (lost.length === 0) {
@@ -58782,7 +59104,7 @@ function lint(argv) {
         askedBy: currentActor(),
         askedAt: nowRfc3339()
       });
-      writeFileSync35(path, result2.text, "utf8");
+      writeFileSync36(path, result2.text, "utf8");
       fixed += result2.converted.length;
       needSource.push(...result2.needSource);
       lines.push(`  FIX  ${rel} — converted ${result2.converted.join(", ")} to the §2.7 grammar`);
@@ -58926,11 +59248,11 @@ function renderFinale(ink) {
 }
 
 // src/core/learn/engine.ts
-import { existsSync as existsSync124, readdirSync as readdirSync38, readFileSync as readFileSync107 } from "node:fs";
+import { existsSync as existsSync124, readdirSync as readdirSync38, readFileSync as readFileSync108 } from "node:fs";
 import { join as join148 } from "node:path";
 
 // src/core/learn/sandbox.ts
-import { chmodSync, existsSync as existsSync123, mkdirSync as mkdirSync30, rmSync as rmSync14, writeFileSync as writeFileSync36 } from "node:fs";
+import { chmodSync, existsSync as existsSync123, mkdirSync as mkdirSync30, rmSync as rmSync14, writeFileSync as writeFileSync37 } from "node:fs";
 import { dirname as dirname22, join as join147, resolve as resolve20 } from "node:path";
 import { homedir as homedir4 } from "node:os";
 function defaultSandboxRoot(home = homedir4()) {
@@ -59002,14 +59324,14 @@ function claudeShimScript(selfCmd, scriptPath) {
 `);
 }
 function writeClaudeShim(sandbox, selfCmd) {
-  writeFileSync36(sandbox.claudeBin, claudeShimScript(selfCmd, sandbox.scriptPath), "utf8");
+  writeFileSync37(sandbox.claudeBin, claudeShimScript(selfCmd, sandbox.scriptPath), "utf8");
   chmodSync(sandbox.claudeBin, 493);
 }
 function shellQuote3(text6) {
   return `'${text6.replaceAll("'", `'\\''`)}'`;
 }
 function writeScript(sandbox, script) {
-  writeFileSync36(sandbox.scriptPath, stringifyScript(script), "utf8");
+  writeFileSync37(sandbox.scriptPath, stringifyScript(script), "utf8");
   rmSync14(`${sandbox.scriptPath}.tally.json`, { force: true });
 }
 function sandboxEnv(sandbox, base2 = process.env) {
@@ -59074,7 +59396,7 @@ async function makeToyRepo(dir) {
   for (const [rel, content] of Object.entries(TOY_FILES)) {
     const path = join147(dir, rel);
     mkdirSync30(dirname22(path), { recursive: true });
-    writeFileSync36(path, content, "utf8");
+    writeFileSync37(path, content, "utf8");
   }
   await git3(dir, ["init", "-q"]);
   await git3(dir, ["symbolic-ref", "HEAD", "refs/heads/main"]);
@@ -59200,7 +59522,7 @@ function newestRunId(sandbox) {
 }
 function runIsFinished(runDir2) {
   try {
-    const status = /^status:\s*(\S+)/m.exec(readFileSync107(join148(runDir2, "run.yml"), "utf8"))?.[1] ?? "";
+    const status = /^status:\s*(\S+)/m.exec(readFileSync108(join148(runDir2, "run.yml"), "utf8"))?.[1] ?? "";
     return isFinished(status);
   } catch {
     return false;
@@ -59241,7 +59563,7 @@ function sandboxHas(sandbox, rel) {
 }
 
 // src/core/learn/chapters.ts
-import { existsSync as existsSync125, mkdirSync as mkdirSync31, readdirSync as readdirSync39, readFileSync as readFileSync108, writeFileSync as writeFileSync37 } from "node:fs";
+import { existsSync as existsSync125, mkdirSync as mkdirSync31, readdirSync as readdirSync39, readFileSync as readFileSync109, writeFileSync as writeFileSync38 } from "node:fs";
 import { dirname as dirname23, join as join149 } from "node:path";
 var LEARN_RUN_SLUG = "bulk-pricing";
 var WATCH_PHASE_DIR = "05-watch";
@@ -60169,7 +60491,7 @@ var CHAPTER_6 = {
       return;
     const path = join149(sandbox.workspace, PROJECT_WORK_DIR, run2, ".agent", "watch", "evidence.md");
     mkdirSync31(dirname23(path), { recursive: true });
-    writeFileSync37(path, evidenceNote2(), "utf8");
+    writeFileSync38(path, evidenceNote2(), "utf8");
   },
   steps: [
     {
@@ -60492,11 +60814,11 @@ var CHAPTERS = [
 ];
 function writeInto(path, content) {
   mkdirSync31(dirname23(path), { recursive: true });
-  writeFileSync37(path, content, "utf8");
+  writeFileSync38(path, content, "utf8");
 }
 function read3(sandbox, rel) {
   try {
-    return readFileSync108(join149(sandbox.workspace, rel), "utf8");
+    return readFileSync109(join149(sandbox.workspace, rel), "utf8");
   } catch {
     return "";
   }
@@ -60527,14 +60849,14 @@ function runIdBySlug(sandbox, slug) {
 }
 
 // src/core/learn/progress.ts
-import { existsSync as existsSync126, mkdirSync as mkdirSync32, readFileSync as readFileSync109, writeFileSync as writeFileSync38 } from "node:fs";
+import { existsSync as existsSync126, mkdirSync as mkdirSync32, readFileSync as readFileSync110, writeFileSync as writeFileSync39 } from "node:fs";
 import { dirname as dirname24 } from "node:path";
 var NO_PROGRESS = { version: 1, completed: [], updatedAt: null };
 function readProgress(path) {
   if (!existsSync126(path))
     return NO_PROGRESS;
   try {
-    const doc = JSON.parse(readFileSync109(path, "utf8"));
+    const doc = JSON.parse(readFileSync110(path, "utf8"));
     const completed = doc.completed;
     if (!Array.isArray(completed))
       return NO_PROGRESS;
@@ -60551,7 +60873,7 @@ function readProgress(path) {
 }
 function writeProgress(path, progress) {
   mkdirSync32(dirname24(path), { recursive: true });
-  writeFileSync38(path, `${JSON.stringify(progress, null, 2)}
+  writeFileSync39(path, `${JSON.stringify(progress, null, 2)}
 `, "utf8");
 }
 function markComplete(progress, chapter, at) {