tldr-experts 0.18.2 → 0.19.0

package/dist/tldrx.js

@@ -7290,6 +7290,7 @@ var EVENT_TYPES = [
   "questions.policy_changed",
   "story.reopened",
   "story.base_fastforwarded",
+  "story.base_updated",
   "story.review_retried",
   "story.work_rescued",
   "story.touches_widened",
@@ -8361,6 +8362,16 @@ function withoutSrcToken(line) {
 function hasSrcMarker(line) {
   return line.includes(SRC_MARKER);
 }
+function unclosedSrcMarker(text) {
+  const open = text.lastIndexOf(SRC_MARKER);
+  if (open < 0)
+    return null;
+  return text.includes("]", open + SRC_MARKER.length) ? null : open;
+}
+function foldsUnclosedSrcMarker(line) {
+  const token = parseSrcToken(line);
+  return token !== null && token.raw.indexOf(SRC_MARKER, SRC_MARKER.length) >= 0;
+}
 function classifySrc(src, repos) {
   const raw = src;
   if (raw === "")
@@ -10405,8 +10416,7 @@ function splitArgv(command) {
   if (/[\n\r]/.test(command))
     return null;
   const argv = [];
-  const pattern = /"([^"]*)"|'([^']*)'|([^\s"']+)/g;
-  for (const match of command.matchAll(pattern)) {
+  for (const match of command.matchAll(TOKEN_RE)) {
     if (match[1] !== undefined || match[2] !== undefined) {
       argv.push(match[1] ?? match[2] ?? "");
       continue;
@@ -10418,6 +10428,21 @@ function splitArgv(command) {
   }
   return argv.length === 0 ? null : argv;
 }
+var TOKEN_RE = /"([^"]*)"|'([^']*)'|([^\s"']+)/g;
+var SEPARATOR_RE = /\|\||&&|2>&1|>>|\$\((?!\()|[|&;<>`]/;
+function unquotedShellSeparator(command) {
+  if (/[\n\r]/.test(command))
+    return `
+`;
+  for (const match of command.matchAll(TOKEN_RE)) {
+    if (match[1] !== undefined || match[2] !== undefined)
+      continue;
+    const found = SEPARATOR_RE.exec(match[3] ?? "");
+    if (found !== null)
+      return found[0];
+  }
+  return null;
+}
 
 class DodCommandRefused extends Error {
 }
@@ -11300,7 +11325,12 @@ function clean(text) {
   const stripped = text.replace(GROUNDING_TAG_RE, "").replace(/\s+/g, " ").replace(/\*\*/g, "").trim();
   if (stripped.length <= MAX_CLAIM_CHARS)
     return stripped;
-  return `${stripped.slice(0, MAX_CLAIM_CHARS - 1).trimEnd()}…`;
+  const cut = stripped.slice(0, MAX_CLAIM_CHARS - 1);
+  const open = unclosedSrcMarker(cut);
+  if (open === null)
+    return `${cut.trimEnd()}…`;
+  const kept = cut.slice(0, open).trimEnd();
+  return kept === "" ? stripped : `${kept}…`;
 }
 
 // src/core/distill/aidlcQuestions.ts
@@ -13892,7 +13922,7 @@ function createRunLocked(options) {
       write(temp, handoffPath, handoff, written);
       const check = validateHandoff(handoff, toSrcContext(workspace, temp));
       if (!check.ok) {
-        throw new NewRunError(`seeded handoff is invalid: ${describeHandoff(check.missingSections, check.emptySections, check.unsourced, check.unresolved)}`);
+        throw new NewRunError(`seeded handoff is invalid: ${describeHandoff(check.missingSections, check.emptySections, check.unsourced, check.unresolved, handoff)}`);
       }
     }
     let factsYaml = null;
@@ -13926,7 +13956,7 @@ function createRunLocked(options) {
       const srcCtx = toSrcContext(workspace, temp);
       const handoffCheck = validateHandoff(handoff, srcCtx);
       if (!handoffCheck.ok) {
-        throw new NewRunError(`distilled handoff is invalid: ${describeHandoff(handoffCheck.missingSections, handoffCheck.emptySections, handoffCheck.unsourced, handoffCheck.unresolved)}`);
+        throw new NewRunError(`distilled handoff is invalid: ${describeHandoff(handoffCheck.missingSections, handoffCheck.emptySections, handoffCheck.unsourced, handoffCheck.unresolved, handoff)}`);
       }
       if (result2.conflicts.length > 0) {
         const text = renderQuestions(runId, phaseId, at, result2.conflicts);
@@ -14096,7 +14126,7 @@ function assertValid(what, validation) {
   const first = validation.issues[0];
   throw new NewRunError(`refusing to create a run with an invalid ${what}: ${first?.path ?? ""} ${first?.message ?? ""}`);
 }
-function describeHandoff(missing, empty, unsourced, unresolved) {
+function describeHandoff(missing, empty, unsourced, unresolved, text = "") {
   if (missing.length > 0)
     return `missing section(s) ${missing.join(", ")}`;
   if (empty.length > 0) {
@@ -14104,7 +14134,24 @@ function describeHandoff(missing, empty, unsourced, unresolved) {
   }
   if (unsourced.length > 0)
     return `unsourced bullet(s) on line(s) ${unsourced.join(", ")}`;
-  return unresolved[0]?.message ?? "unknown problem";
+  const first = unresolved[0];
+  if (first === undefined)
+    return "unknown problem";
+  return `${first.message}${foldedCitationNote(text, first.line)}`;
+}
+var MAX_QUOTED_CHARS2 = 120;
+function foldedCitationNote(text, line) {
+  if (text === "" || line < 1)
+    return "";
+  const raw = text.split(`
+`)[line - 1];
+  if (raw === undefined || raw.trim() === "")
+    return "";
+  if (!foldsUnclosedSrcMarker(raw))
+    return "";
+  const trimmed = raw.trim();
+  const quoted = trimmed.length <= MAX_QUOTED_CHARS2 ? trimmed : `${trimmed.slice(0, MAX_QUOTED_CHARS2)}…`;
+  return ` — L${String(line)} carries an unterminated \`[src:\` citation, so the path above is two ` + `citations folded into one and is not a file to look for; close or remove the inline citation ` + `in the seed (shorter bullets are safest). L${String(line)} reads \`${quoted}\``;
 }
 function yymmdd(now) {
   return now.toISOString().slice(2, 10).replace(/-/g, "");
@@ -16380,11 +16427,18 @@ var ENTRIES = [
         meaning: "Open a FIX ROUND on a story that is `done`: one named defect in work a reviewer already approved. No attempt is consumed, the fix passes the same dod and the same reviewer as the original, and the story's acceptance criteria are not touched — it is not a way to relitigate scope. Refused when the story is not done, when --note is missing, and when that story already has a fix round open (the bound is one).",
         sub: "reopen"
       },
+      {
+        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.",
+        sub: "reopen"
+      },
       runFlag(),
       root()
     ],
     examples: [
       'tldrx story reopen S3 --note "it gates wave 3 (S4, S6) and the owner has decided it ships"',
+      'tldrx story reopen S2 --as-is --note "rebased onto the epic by hand after the merge conflict; dod green"',
       'tldrx story reopen S11 --for-fix --note "linkEmail succeeds then setDisplayName fails: account linked, score never claimable"',
       'tldrx story widen S3 platform/Auth.cs --note "the tenancy check the story is for lives here too"'
     ],
@@ -16395,6 +16449,7 @@ var ENTRIES = [
       "The story goes back to `todo` and its attempt counter restarts at 1 of 2. Nothing is erased to make that true: `story.reopened` is a reset boundary the review ledger reads, every earlier attempt stays in events.jsonl, and the event records how many verdicts the closed run consumed.",
       "It runs no agent, spends nothing, deletes nothing and refunds nothing. The story's branch is kept — that is what carries the last developer's commits forward — and its worktree is left exactly as the build left it, to be reopened from the branch if the build had removed it.",
       'It does NOT make the stage runnable. If the Build stage is at its gate, `tldrx reject --note "…"` sends it back to `ready` first; if the gate is already signed, `tldrx reject --stage` takes that back.',
+      "`--as-is` is the other arc the plain verb cannot cover: a story a PERSON finished. `reopen` hands the story to a developer, and a developer handed a branch whose work is already done has nothing to commit — the story then blocks on the rule that measures work SINCE THE SPAWN, because work older than the spawn cannot be told apart from a developer that did nothing. `--as-is` spawns nothing at all, so there is nothing to measure: the dod runs in the story's worktree (reopened from the branch when the build had removed it), the reviewer judges the same diff, and the merge into the epic is the same merge. It records `story.reopened` with `reason: as_is`, and the story's row and review log say the branch was taken as it stands and name who signed that — no record claims a developer delivered it.",
       "`widen` adds paths to a story's `touches:` — the sanctioned form of the advice the boundary decision card gives when a Build stage changed a path nobody scoped. Widenable states are `todo`, `in_progress`, `review` and `blocked`. A `done` story refuses: its evidence was written against the surface it DECLARED, and widening it afterwards would make the record say the plan declared a path it did not — reopen it with `--for-fix` first. A path the story already declares refuses too, because a widening that widened nothing is a record of something that did not happen.",
       "`widen` runs no agent, spends nothing, consumes no attempt, changes no status and moves no cursor — it declares scope and nothing else. No gate code knows about it: the boundary condition re-reads `touches:` off disk at evaluation time, so the same run, the same branch and the same diff simply stop counting the widened path as outside the surface at the next evaluation. One `story.touches_widened` records the paths, the note and the list before and after."
     ]
@@ -25784,14 +25839,10 @@ async function mergeNoFf(cwd, branch, message4) {
     detail: conflicts.length > 0 ? `conflict in ${conflicts.join(", ")}` : firstLine7(merged.stderr) || firstLine7(merged.stdout) || `git merge exited ${String(merged.exitCode)}`
   };
 }
-async function commitsBetween(cwd, base, head) {
-  const result2 = await git(["rev-list", "--count", `${base}..${head}`], cwd);
-  if (!result2.ok)
-    return 0;
-  const n = Number.parseInt(result2.stdout.trim(), 10);
-  return Number.isFinite(n) ? n : 0;
+function uncountedCount(base, head) {
+  return `\`git rev-list --count ${base}..${head}\` could not count what it carries`;
 }
-async function commitsAhead(cwd, base, head) {
+async function commitsBetween(cwd, base, head) {
   const result2 = await git(["rev-list", "--count", `${base}..${head}`], cwd);
   if (!result2.ok)
     return null;
@@ -25799,12 +25850,15 @@ async function commitsAhead(cwd, base, head) {
   return Number.isFinite(n) ? n : null;
 }
 async function baseStateOf(cwd, branch, base) {
-  const ahead = await commitsBetween(cwd, base, branch);
-  const behind = await commitsBetween(cwd, branch, base);
+  const counted = await commitsBetween(cwd, base, branch);
+  const countedBack = await commitsBetween(cwd, branch, base);
+  const ahead = counted ?? 0;
+  const behind = countedBack ?? 0;
   return {
     state: behind === 0 ? "current" : ahead === 0 ? "behind" : "diverged",
     ahead,
     behind,
+    uncounted: counted === null ? uncountedCount(base, branch) : countedBack === null ? uncountedCount(branch, base) : null,
     branchSha: await shaOf(cwd, branch),
     baseSha: await shaOf(cwd, base)
   };
@@ -26356,6 +26410,11 @@ function dodRefused(result2) {
 }
 var DOD_REFUSAL_FALLBACK = "the gate declined to run it";
 var DEVELOPER_FAILED = "the developer sub-agent failed";
+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";
+}
 function scopedNote(result2) {
   if (result2.scope !== "paths" || result2.rendered === undefined)
     return "";
@@ -26364,6 +26423,9 @@ function scopedNote(result2) {
 function dodGreen(outcome) {
   return outcome.dod.length > 0 && outcome.dod.every((r) => !dodRefused(r) && r.exitCode === 0 && !r.timedOut);
 }
+function dodFailure(dod) {
+  return dod.find((r) => dodRefused(r) || r.exitCode !== 0 || r.timedOut);
+}
 function dodFailureReason(result2, repo) {
   if (dodRefused(result2)) {
     return `\`${result2.command}\` was REFUSED in repo ${repo} and never ran — ` + `${result2.refusedBecause ?? DOD_REFUSAL_FALLBACK}`;
@@ -26374,6 +26436,15 @@ function dodFailureReason(result2, repo) {
   return `\`${result2.rendered ?? result2.command}\`${scopedNote(result2)} exited ${String(result2.exitCode ?? "?")} in repo ${repo}` + `${result2.timedOut ? " (timed out)" : ""} — ${result2.tail}` + (result2.outputPath === undefined ? "" : ` [src: ${result2.outputPath}:${String(result2.outputLine ?? 1)}]`);
 }
 
+// src/core/build/developerGrants.ts
+var DEVELOPER_GIT_VERBS = ["add", "commit", "rm", "mv", "restore"];
+function developerGitGrants() {
+  return DEVELOPER_GIT_VERBS.map((verb) => `Bash(git ${verb} *)`);
+}
+function isDeveloperGitVerb(verb) {
+  return DEVELOPER_GIT_VERBS.includes(verb);
+}
+
 // src/core/build/prompts.ts
 var MAX_TOUCHED_BYTES = 64 * 1024;
 var MAX_TOUCHED_FILES = 24;
@@ -26403,6 +26474,10 @@ function testFastRule(fast, full) {
     ]
   ];
 }
+function gitVerbList() {
+  const names = DEVELOPER_GIT_VERBS.map((verb) => `\`git ${verb}\``);
+  return `${names.slice(0, -1).join(", ")} and ${names[names.length - 1] ?? ""}`;
+}
 function buildDeveloperPrompt(parts) {
   const { story } = parts.story;
   const extra = parts.story.extraInputs ?? [];
@@ -26472,7 +26547,9 @@ function buildDeveloperPrompt(parts) {
     ...parts.commands.length === 0 ? ["- (this repo declares no commands in workspace.yml — the DoD will run nothing)"] : parts.commands.map((command2) => `- \`${command2}\``),
     "",
     ...parts.testFast === undefined ? [] : [...testFastRule(parts.testFast.fast, parts.testFast.full), ""],
-    "Commit with `git add` and `git commit`. Nothing else about git is yours to do.",
+    `Commit with \`git add\` and \`git commit\`. The git verbs you hold are exactly ${gitVerbList()}.`,
+    "`git restore <path>` is how to put a file back (there is no checkout in that list). Nothing",
+    "else about git is yours to do.",
     "",
     "## Rules",
     "",
@@ -28581,6 +28658,68 @@ function verdictReviewer(checkPayload, lastSpawn) {
   return lastSpawn;
 }
 
+// src/core/build/refusalKind.ts
+var MAX_SEPARATOR_RETRIES = 1;
+function classifyRefusal(command2) {
+  const separator = unquotedShellSeparator(command2);
+  if (separator !== null)
+    return { kind: "separator", separator };
+  const argv = command2.trim().split(/\s+/);
+  if (argv[0] !== "git")
+    return { kind: "unknown" };
+  const verb = argv[1] ?? "";
+  if (verb === "" || verb.startsWith("-"))
+    return { kind: "unknown" };
+  if (isDeveloperGitVerb(verb))
+    return { kind: "unknown" };
+  return { kind: "verb", verb, equivalent: grantedEquivalent(verb, argv.slice(2)) };
+}
+function grantedEquivalent(verb, args) {
+  if (verb === "checkout") {
+    const switching = args.some((a) => a === "-b" || a === "-B" || a === "--orphan" || a === "-t" || a === "--track");
+    if (switching)
+      return null;
+    const hasTarget = args.some((a) => !a.startsWith("-")) || args.includes("--");
+    return hasTarget ? "git restore <path>" : null;
+  }
+  if (verb === "reset") {
+    const mode = args.some((a) => /^--(hard|soft|mixed|merge|keep)$/.test(a));
+    if (mode)
+      return null;
+    if (args.includes("--"))
+      return "git restore --staged <path>";
+    const [first2, second] = args.filter((a) => !a.startsWith("-"));
+    if (first2 === "HEAD" && second !== undefined)
+      return "git restore --staged <path>";
+    return null;
+  }
+  return null;
+}
+function refusalCure(kind) {
+  switch (kind.kind) {
+    case "separator":
+      return "run each command alone — shell separators split a line into subcommands that each need their own grant";
+    case "verb":
+      return kind.equivalent === null ? `\`git ${kind.verb}\` is not granted` : `\`git ${kind.verb}\` is not granted; use \`${kind.equivalent}\``;
+    case "unknown":
+      return "";
+  }
+}
+function withCure(sentence, command2) {
+  const cure = refusalCure(classifyRefusal(command2));
+  return cure === "" ? sentence : `${sentence}. The cure: ${cure}`;
+}
+function separatorCurePrefix(command2) {
+  return [
+    `Your previous command \`${command2}\` was refused because it chains commands. Run each command alone.`,
+    "The permission layer splits a line at every shell separator (`&&`, `;`, `|`, `>`, `2>&1`, `$()`)",
+    "and each fragment must match its own grant, so a compound line is refused even when every",
+    "command in it is allowed on its own. This is the one retry: a second refusal blocks the story.",
+    ""
+  ].join(`
+`);
+}
+
 // src/core/build/review.ts
 var VERDICT_WORDS = ["approve", "fixlist", "changes"];
 var VERDICT_ENUM = VERDICT_WORDS.join("|");
@@ -28751,8 +28890,9 @@ 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.developerError === null ? [] : [`- Developer: **FAILED** — ${outcome.developerError}`],
-    ...outcome.permissionRefused == null ? [] : [`- 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 == 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.budgetDeath == null ? [] : [`- Developer: died on its per-story cap — ${outcome.budgetDeath}; the tree held work, ` + "so the Definition of Done below decided"],
     "",
     "## Definition of done",
@@ -29354,7 +29494,7 @@ function renderBuildHandoff(parts) {
     "",
     ...notDone.length === 0 && (parts.carried ?? []).length === 0 && (parts.unreadableStories ?? []).length === 0 && (parts.foreignWork ?? []).length === 0 && (parts.notStarted ?? []).length === 0 && refusedButMeasured.length === 0 && diedButMeasured.length === 0 ? [`- none — every scheduled story reached \`done\` and no carried finding is unowned ` + `[src: absent:04-build/log]`] : [],
     ...notDone.map((o) => `- ${o.id} is \`${o.status}\` and needs a human: ${o.reason ?? "see the review"} ` + `[src: ${o.reviewRel}:1]`),
-    ...refusedButMeasured.map((o) => `- ${o.id}'s developer had \`${o.permissionRefused ?? ""}\` refused for approval by the agent's own ` + `permission layer; its tree held committed work, so the Definition of Done decided and the story is ` + `\`${o.status}\` — a person may still want to know the command it could not run [src: ${o.reviewRel}:1]`),
+    ...refusedButMeasured.map((o) => withCure(`- ${o.id}'s developer had \`${o.permissionRefused ?? ""}\` refused for approval by the agent's own ` + `permission layer; its tree held committed work, so the Definition of Done decided and the story is ` + `\`${o.status}\` — a person may still want to know the command it could not run`, o.permissionRefused ?? "") + ` [src: ${o.reviewRel}:1]`),
     ...diedButMeasured.map((o) => `- ${o.id}'s developer died on its per-story cap (${o.budgetDeath ?? ""}) with work in its tree, ` + `so the Definition of Done decided and the story is \`${o.status}\` — the plan priced this story ` + `below what it cost, which is worth knowing before the next one [src: ${o.reviewRel}:1]`),
     ...(parts.notStarted ?? []).map((row2) => `- ${row2.id} was scheduled and never started, and is still \`${row2.status}\` — ` + `${row2.reason} [src: ${row2.rel}:1]`),
     ...carriedBullets(parts.carried ?? []),
@@ -29769,9 +29909,9 @@ function quoteLine(text3, line) {
   if (found === undefined || found.trim() === "")
     return null;
   const trimmed = found.trim();
-  return trimmed.length <= MAX_QUOTED_CHARS2 ? trimmed : `${trimmed.slice(0, MAX_QUOTED_CHARS2)}…`;
+  return trimmed.length <= MAX_QUOTED_CHARS3 ? trimmed : `${trimmed.slice(0, MAX_QUOTED_CHARS3)}…`;
 }
-var MAX_QUOTED_CHARS2 = 120;
+var MAX_QUOTED_CHARS3 = 120;
 function describeHandoff2(rel, validation, text3 = "") {
   if (validation.ok)
     return [];
@@ -35532,6 +35672,10 @@ function storyWorktreePath(root2, repo, runId, storyId) {
 async function refreshStoryBase(parts) {
   const id = parts.storyId;
   const base2 = await baseStateOf(parts.repoDir, parts.branch, parts.epicBranch);
+  if (base2.uncounted !== null && base2.branchSha !== "") {
+    parts.lines.push(`  · ${id}: ${base2.uncounted} — \`${parts.branch}\` was left exactly as it is, ` + `and the dispatch below is on its current tip`);
+    return;
+  }
   if (base2.state === "current")
     return;
   const where = relative14(parts.root, parts.worktree) || parts.worktree;
@@ -35646,6 +35790,24 @@ async function rescueUncommitted(parts) {
     return { sha, branch: parts.branch, worktree: null, failure: null };
   });
 }
+async function updateStoryBase(parts) {
+  const base2 = await baseStateOf(parts.repoDir, parts.branch, parts.epicBranch);
+  if (base2.state === "current" && base2.uncounted === null)
+    return { kind: "current", why: null };
+  await assertWorktreeOn(parts.worktree, parts.branch, "story worktree");
+  const from = await headSha(parts.worktree);
+  const merged = await mergeNoFf(parts.worktree, parts.epicBranch, `sync(${parts.storyId}): \`${parts.epicBranch}\` moved under this story before it merged back`);
+  if (!merged.ok)
+    return { kind: "blocked", conflicts: merged.conflicts, detail: merged.detail };
+  const to = await headSha(parts.worktree);
+  if (to === from || to === "")
+    return { kind: "current", why: base2.uncounted };
+  return { kind: "updated", from, to, behind: base2.behind, uncounted: base2.uncounted };
+}
+function staleBaseConflict(branch, epicBranch, conflicts, detail, where) {
+  const files = conflicts.length > 0 ? conflicts.join(", ") : detail;
+  return `\`${epicBranch}\` moved since \`${branch}\` was cut, and bringing the story up to it ` + `CONFLICTS in ${files} — nothing was merged and nothing is half-applied. ` + `Resolve it in ${where} (\`git merge ${epicBranch}\`), then reopen the story`;
+}
 
 // src/core/build/entryProbe.ts
 import { accessSync, constants, existsSync as existsSync72, statSync as statSync20 } from "node:fs";
@@ -35892,7 +36054,7 @@ function asideBranchOf(epicBranch, ownerRunId) {
   return `${epicBranch}${ASIDE_SEPARATOR}${ownerRunId}`;
 }
 function uncountedReason(base2, branch) {
-  return `\`git rev-list --count ${base2}..${branch}\` could not count what it carries, ` + "and an uncounted branch is never deleted";
+  return `${uncountedCount(base2, branch)}, and an uncounted branch is never deleted`;
 }
 async function releaseEpicBranch(parts) {
   const { repoDir, branch } = parts;
@@ -35902,7 +36064,7 @@ async function releaseEpicBranch(parts) {
   if (checkout !== null) {
     return { kind: "kept", branch, reason: `it is checked out in ${checkout}` };
   }
-  const commits = await commitsAhead(repoDir, parts.base, branch);
+  const commits = await commitsBetween(repoDir, parts.base, branch);
   if (commits === null)
     return { kind: "kept", branch, reason: uncountedReason(parts.base, branch) };
   const sha = await shaOf(repoDir, branch);
@@ -36309,6 +36471,7 @@ function readReviewLedger(runDir, storyId) {
     developerErroredWith: null,
     blockedWithNothingRun: false,
     reopened: null,
+    asIs: null,
     fixRound: null,
     formatRetries: 0,
     formatRefusal: null,
@@ -36329,6 +36492,7 @@ function readReviewLedger(runDir, storyId) {
   let current = [];
   let lastDodOutputPath = null;
   let reopened = null;
+  let asIs = null;
   let fixRound = null;
   let formatRetries = 0;
   let formatRefusal = null;
@@ -36366,6 +36530,7 @@ function readReviewLedger(runDir, storyId) {
       };
       if (payload.reason === "fix")
         fixRound = reopened;
+      asIs = payload.reason === "as_is" ? reopened : null;
       formatRetries = 0;
       formatRefusal = null;
       spawned = null;
@@ -36397,6 +36562,7 @@ function readReviewLedger(runDir, storyId) {
         epicBase = payload.epic_base;
       if (payload.status === "done")
         fixRound = null;
+      asIs = null;
       blockedWithNothingRun = payload.status === "blocked" && payload.verdict === "n-a" && (payload.commit === null || payload.commit === undefined || payload.commit === "") && !ranACheck && !sawReviewer;
     }
     if (event4.type !== "check.passed" && event4.type !== "check.failed")
@@ -36456,6 +36622,7 @@ function readReviewLedger(runDir, storyId) {
     developerErroredWith,
     blockedWithNothingRun,
     reopened,
+    asIs,
     fixRound,
     formatRetries,
     formatRefusal,
@@ -38645,6 +38812,10 @@ async function rederiveImplicitPlan(ctx, workspace, parts, lines) {
   const content = implicitPlanContent(parts);
   const storyBranch = storyBranchOf(ctx.runId, IMPLICIT_STORY_ID);
   const commits = await commitsBetween(repoDirOf(workspace, content.repo), content.branch, storyBranch);
+  if (commits === null) {
+    kept(uncountedCount(content.branch, storyBranch));
+    return;
+  }
   if (commits > 0) {
     kept(`\`${storyBranch}\` carries ${String(commits)} commit(s) beyond \`${content.branch}\``);
     return;
@@ -38683,6 +38854,7 @@ class BuildSession {
   outcomes = new Map;
   refusals = new Map;
   capDeaths = new Map;
+  asIsSettlements = new Map;
   epics = new EpicState;
   lines = [];
   counters = new ReviewCounters;
@@ -38765,6 +38937,10 @@ class BuildSession {
     const review = this.reviewWorkFor(planned);
     if (review !== null)
       return await this.prepareReview(planned, review);
+    const asIs = this.asIsFor(planned);
+    if (asIs !== null) {
+      return refusedOnSequence(this.ctx, `${planned.story.id} was reopened \`--as-is\` by ${asIs.actor} (${asIs.note}) — the branch is to be ` + "settled as it stands, and `--prepare` dispatches a developer. `tldrx next` (headless) runs the " + "dod, the review and the merge over it; to build it with a developer instead, " + `\`tldrx story reopen ${planned.story.id} --note "…"\` replaces the signature.`);
+    }
     let fixlist;
     try {
       fixlist = this.fixlistFor(planned.story.id);
@@ -39073,10 +39249,88 @@ class BuildSession {
       throw rejected.reason;
     return halves;
   }
+  asIsFor(planned) {
+    return readReviewLedger(this.ctx.runDir, planned.story.id).asIs;
+  }
+  async asIsHalf(planned, asIs) {
+    const id = planned.story.id;
+    const before = this.statusOf(planned);
+    this.refusals.delete(id);
+    this.capDeaths.delete(id);
+    this.asIsSettlements.set(id, asIs);
+    const story = await this.writes.run(() => this.openStory(planned));
+    await this.writes.run(() => {
+      this.ctx.emit("task.started", {
+        phase: this.ctx.phaseId,
+        story: id,
+        wave: planned.wave,
+        repo: planned.story.repo,
+        branch: story.branch,
+        attempt: story.attempt,
+        as_is: true
+      });
+      this.setStoryStatus(planned, "in_progress");
+    });
+    this.lines.push(`  · ${id}: settling \`${story.branch}\` as it stands — signed by ${asIs.actor}: ${asIs.note}`);
+    const install = await this.installDeps(story);
+    if (install !== null && installFailed(install)) {
+      return {
+        story,
+        cost: 0,
+        dod: [],
+        commit: null,
+        failure: installFailureReason(install, planned.story.repo),
+        developerError: null,
+        before
+      };
+    }
+    const ahead = await commitsBetween(story.repoDir, story.epicBranch, story.branch);
+    if (ahead === null || ahead === 0) {
+      return {
+        story,
+        cost: 0,
+        dod: [],
+        commit: null,
+        failure: asIsNotAheadReason(story.branch, story.epicBranch, ahead),
+        developerError: null,
+        before
+      };
+    }
+    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
+      };
+    }
+    const commit2 = await headSha(story.worktree);
+    if (commit2 === "") {
+      return {
+        story,
+        cost: 0,
+        dod,
+        commit: null,
+        failure: `\`${story.branch}\` has no HEAD to take — git could not resolve it`,
+        developerError: null,
+        before
+      };
+    }
+    return { story, cost: 0, dod, commit: commit2, failure: null, developerError: null, before };
+  }
   async buildHalf(planned) {
+    const asIs = this.asIsFor(planned);
+    if (asIs !== null)
+      return await this.asIsHalf(planned, asIs);
     const before = this.statusOf(planned);
     this.refusals.delete(planned.story.id);
     this.capDeaths.delete(planned.story.id);
+    this.asIsSettlements.delete(planned.story.id);
     const story = await this.writes.run(() => this.openStory(planned, true));
     await this.writes.run(() => {
       this.ctx.emit("task.started", {
@@ -39102,55 +39356,64 @@ class BuildSession {
       };
     }
     const handed = await headSha(story.worktree);
-    const developer = await this.spawnDeveloper(story);
-    const capDeath = developer.error !== null && diedOnCap(developer.error);
+    let developer = await this.spawnDeveloper(story);
     let budgetDeath = null;
-    if (developer.error !== null) {
-      const proven = capDeath && await workSince({
-        workspaceRoot: this.workspace.root,
-        repoDir: story.repoDir,
-        worktree: story.worktree,
-        since: handed
-      });
-      if (!proven) {
-        return {
-          story,
-          cost: developer.cost,
-          dod: [],
-          commit: null,
-          failure: null,
-          developerError: developer.error,
-          before
-        };
+    let spent = 0;
+    let separatorRetries = 0;
+    for (;; ) {
+      spent = round25(spent + developer.cost);
+      const capDeath = developer.error !== null && diedOnCap(developer.error);
+      if (developer.error !== null) {
+        const proven2 = capDeath && await workSince({
+          workspaceRoot: this.workspace.root,
+          repoDir: story.repoDir,
+          worktree: story.worktree,
+          since: handed
+        });
+        if (!proven2) {
+          return {
+            story,
+            cost: spent,
+            dod: [],
+            commit: null,
+            failure: null,
+            developerError: developer.error,
+            before
+          };
+        }
+        budgetDeath = developer.error;
+        this.capDeaths.set(story.planned.story.id, developer.error);
       }
-      budgetDeath = developer.error;
-      this.capDeaths.set(story.planned.story.id, developer.error);
-    }
-    const spent = developer.cost;
-    if (developer.refused !== null) {
+      if (developer.refused === null)
+        break;
       const proven = await workSince({
         workspaceRoot: this.workspace.root,
         repoDir: story.repoDir,
         worktree: story.worktree,
         since: handed
       });
-      if (!proven) {
-        return {
-          story,
-          cost: spent,
-          dod: [],
-          commit: null,
-          failure: permissionBlockReason(developer.refused),
-          developerError: null,
-          before
-        };
+      if (proven) {
+        this.refusals.set(story.planned.story.id, developer.refused);
+        break;
+      }
+      if (classifyRefusal(developer.refused).kind === "separator" && separatorRetries < MAX_SEPARATOR_RETRIES) {
+        separatorRetries += 1;
+        developer = await this.spawnDeveloper(story, { after: developer.refused });
+        continue;
       }
-      this.refusals.set(story.planned.story.id, developer.refused);
+      return {
+        story,
+        cost: spent,
+        dod: [],
+        commit: null,
+        failure: permissionBlockReason(developer.refused, { retried: separatorRetries > 0 }),
+        developerError: null,
+        before
+      };
     }
     const dod = await this.runDod(story);
-    const green = dod.length === 0 ? dodIsSatisfiedEmpty(this.plan) : dodGreen({ dod });
-    if (!green) {
-      const failing = dod.find((r) => dodRefused(r) || r.exitCode !== 0 || r.timedOut);
+    if (!this.dodProves(dod)) {
+      const failing = dodFailure(dod);
       const why = failing === undefined ? "the story declares no dod commands, so nothing could prove it" : dodFailureReason(failing, story.planned.story.repo);
       return {
         story,
@@ -39194,18 +39457,49 @@ class BuildSession {
       await this.block(story, "the story produced no commit to review", half.cost, dod);
       return "settled";
     }
+    const update = await updateStoryBase({
+      storyId: story.planned.story.id,
+      repoDir: story.repoDir,
+      worktree: story.worktree,
+      branch: story.branch,
+      epicBranch: story.epicBranch
+    });
+    if (update.kind === "blocked") {
+      await this.block(story, staleBaseConflict(story.branch, story.epicBranch, update.conflicts, update.detail, relative16(this.ctx.root, story.worktree) || story.worktree), half.cost, dod, { commit: commit2, conflicts: update.conflicts });
+      return "settled";
+    }
+    let proven = dod;
+    if (update.kind === "updated") {
+      this.lines.push(`  · ${story.planned.story.id}: \`${story.branch}\` was ${String(update.behind)} commit(s) behind ` + `\`${story.epicBranch}\`${update.uncounted === null ? "" : ` (${update.uncounted})`} — merged the epic ` + `into it (${update.from.slice(0, 7)} → ${update.to.slice(0, 7)}) and re-ran the DoD on the result`);
+      this.ctx.emit("story.base_updated", {
+        phase: this.ctx.phaseId,
+        story: story.planned.story.id,
+        repo: story.planned.story.repo,
+        branch: story.branch,
+        base: story.epicBranch,
+        from: update.from,
+        to: update.to,
+        commits: update.behind
+      });
+      proven = await this.runDod(story);
+      if (!this.dodProves(proven)) {
+        const failing = dodFailure(proven);
+        await this.block(story, `${failing === undefined ? "the story declares no dod commands, so nothing could prove it" : dodFailureReason(failing, story.planned.story.repo)}` + ` — re-run after \`${story.epicBranch}\` moved under \`${story.branch}\` ` + `(${update.from.slice(0, 7)} → ${update.to.slice(0, 7)}); nothing was merged`, half.cost, proven, { commit: commit2 });
+        return "settled";
+      }
+    }
     const carried = await commitsBetween(story.repoDir, story.epicBranch, story.branch);
     const epicShaBefore = await fullShaOf(story.repoDir, story.epicBranch);
     const merge = await this.mergeIntoEpic(story);
     if (!merge.ok) {
-      await this.block(story, `merge into \`${story.epicBranch}\` failed: ${merge.detail}`, half.cost, dod, {
+      await this.block(story, `merge into \`${story.epicBranch}\` failed: ${merge.detail}`, half.cost, proven, {
         commit: commit2,
         conflicts: merge.conflicts
       });
       return "settled";
     }
     this.noteMerged(story, carried);
-    return await this.reviewAndSettle(story, dod, commit2, half.cost, carried, epicShaBefore);
+    return await this.reviewAndSettle(story, proven, commit2, half.cost, carried, epicShaBefore);
   }
   async reviewAndSettle(story, dod, commit2, priorCost, carried, epicBase, supplied) {
     if (supplied === undefined && this.ctx.attendedByHost) {
@@ -39481,9 +39775,8 @@ class BuildSession {
   }
   async pipelineFromDod(story, developerCost) {
     const dod = await this.runDod(story);
-    const green = dod.length === 0 ? dodIsSatisfiedEmpty(this.plan) : dodGreen({ dod });
-    if (!green) {
-      const failing = dod.find((r) => dodRefused(r) || r.exitCode !== 0 || r.timedOut);
+    if (!this.dodProves(dod)) {
+      const failing = dodFailure(dod);
       await this.block(story, failing === undefined ? "the story declares no dod commands, so nothing could prove it" : dodFailureReason(failing, story.planned.story.repo), developerCost, dod);
       return "settled";
     }
@@ -39586,7 +39879,7 @@ class BuildSession {
       advisories: this.advisories
     });
   }
-  async spawnDeveloper(story) {
+  async spawnDeveloper(story, retry = null) {
     const cap2 = developerCap(this.capParts, story.planned.story.id, story.attempt);
     const commands = this.repoCommands(story.planned.story.repo);
     this.ctx.emit("agent.spawned", {
@@ -39595,10 +39888,11 @@ class BuildSession {
       role: "developer",
       model: this.model(),
       effort: this.ctx.effort,
-      max_budget_usd: cap2
+      max_budget_usd: cap2,
+      ...retry === null ? {} : { retry: "separator-cure", retry_after: retry.after }
     }, 0, "developer");
     const agent = await spawnAgent({
-      prompt: this.developerPrompt(story),
+      prompt: (retry === null ? "" : separatorCurePrefix(retry.after)) + this.developerPrompt(story),
       model: this.model(),
       effort: this.ctx.effort,
       maxBudgetUsd: cap2,
@@ -39640,6 +39934,9 @@ class BuildSession {
     });
     return { cost: round25(agent.costUsd), error, refused: null };
   }
+  dodProves(dod) {
+    return dod.length === 0 ? dodIsSatisfiedEmpty(this.plan) : dodGreen({ dod });
+  }
   async runDod(story) {
     const scoped = await this.scopedParts(story);
     const results = await runStoryDod({
@@ -39973,6 +40270,7 @@ class BuildSession {
       reason: parts.reason,
       permissionRefused: this.refusals.get(id) ?? null,
       budgetDeath: this.capDeaths.get(id) ?? null,
+      asIs: this.asIsSettlements.get(id) ?? null,
       rescued,
       cost_usd: parts.cost
     };
@@ -40003,12 +40301,13 @@ class BuildSession {
       attempt: story.attempt,
       ...parts.epicBase === null || parts.epicBase === undefined || parts.epicBase === "" ? {} : { epic_base: parts.epicBase },
       ...outcome.permissionRefused == null ? {} : { permission_refused: outcome.permissionRefused },
-      ...outcome.budgetDeath == null ? {} : { budget_death: outcome.budgetDeath }
+      ...outcome.budgetDeath == null ? {} : { budget_death: outcome.budgetDeath },
+      ...outcome.asIs == null ? {} : { as_is: true, as_is_by: outcome.asIs.actor, as_is_note: outcome.asIs.note }
     });
     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.permissionRefused == null ? "" : ` — \`${outcome.permissionRefused}\` was refused for approval; the tree held committed work, so the DoD decided`));
+    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)}`));
   }
   writeLog(outcome) {
     const dir = join100(this.ctx.runDir, BUILD_PHASE, LOG_DIR);
@@ -40691,15 +40990,12 @@ function developerTools(repoCommands, options = {}) {
     ...BASE_TOOLS,
     ...options.skills === true ? ["Skill"] : [],
     ...repoCommands.flatMap((command2) => bashGrantsFor(command2)),
-    "Bash(git add *)",
-    "Bash(git commit *)",
-    "Bash(git rm *)",
-    "Bash(git mv *)",
-    "Bash(git restore *)"
+    ...developerGitGrants()
   ];
 }
-function permissionBlockReason(command2) {
-  return `permission — \`${command2}\` was refused for approval by the agent's own permission layer, ` + "and a headless turn has nobody to approve it: the same allowance would refuse it again, " + "so this attempt was not repeated";
+function permissionBlockReason(command2, options = {}) {
+  const base2 = `permission — \`${command2}\` was refused for approval by the agent's own permission layer, ` + "and a headless turn has nobody to approve it: the same allowance would refuse it again, " + "so this attempt was not repeated" + (options.retried === true ? " beyond the one re-spawn with the cure stated, which was refused too" : "");
+  return withCure(base2, command2);
 }
 function diedOnCap(error) {
   return error.includes("Reached maximum budget");
@@ -48138,8 +48434,13 @@ function reopenStory(options) {
     return refuse4(['story reopen needs a story id: `tldrx story reopen S3 --note "why"`']);
   }
   const forFix = options.forFix === true;
+  const asIs = options.asIs === true;
   if (options.note.trim() === "") {
-    return forFix ? refuse4([
+    return asIs ? refuse4([
+      `story reopen --as-is needs --note: \`tldrx story reopen ${id} --as-is --note "<what you did by hand>"\``,
+      "  the note is the ONLY record of who finished this branch and how — no developer will run,",
+      "  so nothing else in the log will say where the commits came from"
+    ]) : forFix ? refuse4([
       `story reopen --for-fix needs --note: \`tldrx story reopen ${id} --for-fix --note "<the defect>"\``,
       "  the note IS the defect — it is what scopes the fix round, and what the reviewer reads",
       "  to tell a fix from a second opinion about the story"
@@ -48233,7 +48534,7 @@ function reopenStory(options) {
     }
     throw error;
   }
-  const event7 = reopenEvent(options, store.runId, id, row2.wave, row2.status, ledger4.verdicts, forFix);
+  const event7 = reopenEvent(options, store.runId, id, row2.wave, row2.status, ledger4.verdicts, forFix, asIs);
   const validation = validateEvent(event7);
   if (!validation.ok) {
     const first2 = validation.issues[0];
@@ -48264,6 +48565,19 @@ function reopenStory(options) {
       ]
     };
   }
+  if (asIs) {
+    return {
+      code: EXIT_OK12,
+      lines: [
+        `reopened ${id} in ${store.runId} — \`${row2.status}\` → \`${REOPENED_TO}\` (${row2.wave}), ` + "to be settled from its branch AS IT STANDS",
+        `  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",
+        "  the record will say the branch was taken as it stands and name you, so nothing reads as " + "though a developer delivered it",
+        ...kept
+      ]
+    };
+  }
   return {
     code: EXIT_OK12,
     lines: [
@@ -48289,7 +48603,7 @@ function nextStep(runId, stage2) {
 function buildStage(store) {
   return store.run.phases.find((phase) => phase.id === BUILD_PHASE2)?.stages[0];
 }
-function reopenEvent(options, runId, storyId, wave, from, verdicts, forFix) {
+function reopenEvent(options, runId, storyId, wave, from, verdicts, forFix, asIs) {
   return {
     ts: options.at,
     run: runId,
@@ -48304,7 +48618,7 @@ function reopenEvent(options, runId, storyId, wave, from, verdicts, forFix) {
       from_status: from,
       to_status: REOPENED_TO,
       verdicts,
-      reason: forFix ? "fix" : "attempts",
+      reason: forFix ? "fix" : asIs ? "as_is" : "attempts",
       note: options.note
     }
   };
@@ -48511,7 +48825,7 @@ var VALUE_FLAGS6 = ["run", "root", "note"];
 var storyCommand = {
   name: "story",
   summary: "Give one Build story another run of attempts, or widen the paths it declares",
-  usage: `tldrx story reopen <id> --note <text> [--for-fix] [--run <id>] [--root <path>]
+  usage: `tldrx story reopen <id> --note <text> [--for-fix | --as-is] [--run <id>] [--root <path>]
 ` + "       tldrx story widen <id> <path>… --note <text> [--run <id>] [--root <path>]",
   implemented: true,
   async run(argv) {
@@ -48529,11 +48843,20 @@ ${storyCommand.usage}
 function storyReopen(argv) {
   try {
     const args = parseArgs(argv, VALUE_FLAGS6);
+    if (boolFlag(args, "for-fix") && boolFlag(args, "as-is")) {
+      process.stderr.write(`tldrx story reopen: --for-fix and --as-is answer different questions — nothing was written
+` + "  --for-fix opens a fix round on a `done` story: one named defect, landed by a developer.\n" + `  --as-is settles an UNFINISHED story from its branch as it stands, with no developer at all.
+` + `  Type the one you mean.
+` + `${storyCommand.usage}
+`);
+      return EXIT_USAGE;
+    }
     const outcome = reopenStory({
       root: workspaceRootFrom(args),
       storyId: args.positionals[0] ?? "",
       note: stringFlag(args, "note") ?? "",
       forFix: boolFlag(args, "for-fix"),
+      asIs: boolFlag(args, "as-is"),
       runId: stringFlag(args, "run"),
       actor: currentActor(),
       at: nowRfc3339()
@@ -48553,6 +48876,12 @@ function storyReopen(argv) {
 function storyWiden(argv) {
   try {
     const args = parseArgs(argv, VALUE_FLAGS6);
+    if (boolFlag(args, "as-is")) {
+      process.stderr.write("tldrx story widen: --as-is is a flag of `reopen`, not of `widen` — nothing was written\n" + "  widening declares a path; `--as-is` settles a story from its branch as it stands.\n" + `  \`tldrx story reopen <id> --as-is --note "<what you did by hand>"\` is the verb you want.
+` + `${storyCommand.usage}
+`);
+      return EXIT_USAGE;
+    }
     if (boolFlag(args, "for-fix")) {
       process.stderr.write("tldrx story widen: --for-fix is a flag of `reopen`, not of `widen` — nothing was written\n" + "  widening declares a path; `--for-fix` reopens finished work for one named defect.\n" + `  \`tldrx story reopen <id> --for-fix --note "<the defect>"\` first, then widen the reopened story.
 ` + `${storyCommand.usage}
@@ -52045,6 +52374,8 @@ function bullet2(item, trail) {
       return `${prefix5}story ${text3(payload2.story) || "?"}'s \`touches:\` WIDENED by ${actor}` + ` (${basisOf(payload2)})` + ` — +${pathList(payload2.paths)}` + ` (${String(lengthOf(payload2.before))} → ${String(lengthOf(payload2.after))} path(s))` + `${note(payload2.note)}`;
     case "story.base_fastforwarded":
       return `${prefix5}story ${text3(payload2.story) || "?"}'s base fast-forwarded to` + ` \`${text3(payload2.base) || "?"}\` — ${text3(payload2.from) || "?"} → ${text3(payload2.to) || "?"}` + ` (${String(payload2.commits ?? "?")} commit(s))`;
+    case "story.base_updated":
+      return `${prefix5}story ${text3(payload2.story) || "?"}'s base UPDATED to` + ` \`${text3(payload2.base) || "?"}\` before merging — ${text3(payload2.from) || "?"} →` + ` ${text3(payload2.to) || "?"} (${String(payload2.commits ?? "?")} commit(s) behind), DoD re-run`;
     case "epic.released":
       return `${prefix5}epic \`${text3(payload2.branch) || "?"}\` of run ${text3(payload2.owner) || "?"} ` + (text3(payload2.outcome) === "deleted" ? `deleted — no commit beyond \`${text3(payload2.base) || "?"}\`` : `renamed to \`${text3(payload2.renamed_to) || "?"}\` — ${String(payload2.commits ?? "?")} commit(s) ` + `beyond \`${text3(payload2.base) || "?"}\` survive there`) + ` (${text3(payload2.via) || "?"})`;
     case "story.work_rescued":