tldr-experts 0.25.0 → 0.26.1

package/CHANGELOG.md

@@ -1,5 +1,169 @@
 # Changelog
 
+## 0.26.1 — 2026-09-14
+
+### Changed
+
+- **A patch is fixes again, and this release is one: 0.26.1, not 0.27.0 (owner decision).**
+  MEASURED with `git tag -l`: v0.19.0 through v0.26.0 are eight releases, every one a minor and
+  none a patch, while 0.21.0, 0.22.0, 0.23.0, 0.25.0 and 0.26.0 carry nothing but `### Fixed`.
+  Mechanism: `docs/RELEASING.md` said "bump minor when a command, file schema or hook changes
+  behaviour; patch for fixes only", and every fix changes some command's behaviour — so the
+  rule had no fix left to call a patch, and the version number stopped telling an upgrader
+  whether a release was safe to take blind. The rule now reads by capability: a *patch* is
+  fixes, including a fix that makes a command do what it already promised (a refusal where it
+  should have refused, a message that keeps what it should say); a *minor* is a new
+  capability — a new command, flag, file field or schema, hook or event, or a changed meaning
+  of an existing one. The maintain skill used to gloss the old rule beside its citation, which
+  made two copies to move; it now cites `docs/RELEASING.md` "What to consider" only, and
+  `test/maintain-skill.test.ts` refuses a skill line that restates what a patch or a minor is
+  (RED on the old gloss, which it quoted).
+
+### Fixed
+
+- **A Build fix round whose developer lands no diff is refused, not settled `done` (#308).**
+  MEASURED live on a client workspace (0.24.0, two `--for-fix` reopens, one Build re-run): the
+  developer read the file, said it "already satisfies every acceptance criterion", spent $1.69
+  across two spawns and changed nothing — and the stage closed with the story `done`, the epic
+  head unchanged and every gap the reopen note named still in the tree. Mechanism, confirmed at
+  `f1c9aa8`: `commitIfDirty` hands back the OLD head sha on a clean tree, so `settleHalf`'s "no
+  commit to review" gate never fired, `mergeNoFf` was a no-op on an already-merged tip, and the
+  ledger closes a fix round on `done` alone. `workSince` — the "did the tree move since the one
+  the developer was handed" comparison the two refusal branches already use — was never asked on
+  the success path, where a fix round is precisely the case "nothing changed and the DoD is still
+  green" looks normal, because that tree was accepted once already. Now, for a story a PERSON put
+  back with a note — a fix round or a plain reopen, off the ledger — `buildHalf` asks it BEFORE
+  the DoD: no work, and the attempt blocks with the existing `task.done`/`blocked` vocabulary and
+  a reason that carries the note's first line (`NO_DIFF_MARK`, exported and pinned) — no DoD paid
+  for, no reviewer asked to judge an empty diff, the fix round still open because nothing landed.
+  A first attempt that lands nothing is deliberately NOT gated: "added nothing — identical to the
+  epic" is a pinned rendering decision, not this defect. Three RED tests in
+  `test/story-reopen.test.ts` (no-write developer on a fix round, the same bytes rewritten, a
+  no-write developer on a plain reopen — each settled `done` before); the neighbouring fix-round
+  tests now land a REAL diff, because the fake developer's default rewrote the bytes the first
+  attempt committed, which is #308's shape exactly. Golden byte-identical.
+- **`tldrx ship` refuses an epic carrying a story the reviewer rejected (#282).** MEASURED on a
+  live unattended run (0.18.2, 8 stories), story S5: DoD green, `48f8bdd merge(S5)` on the epic,
+  THEN `check.failed check:review verdict:changes`; the requeue did the same (`7fd2468 merge(S5)`,
+  `changes` again) and the story settled `blocked` — the epic carried, twice, code the reviewer
+  rejected twice. Merging BEFORE the review is design (#166: the reviewer reads the merged diff from
+  the epic base) and every verdict settles with `merged: true`; the defect was downstream. `ship`'s
+  only story refusal was #210's "zero stories done", so with one `done` story beside S5 it pushed
+  the epic and opened the PR with the rejected code in its diff, while the body listed S5 under
+  "Not done" with no word that the diff was there — a record lying in the dangerous direction (§7).
+  Reproduced at `bdc43e7` with the fake agent (`GOLDEN_ROUNDS`, S2 scripted `changes` twice): S1
+  `done`, S2 `blocked`, every S2 `task.done` commit an ancestor of `epic/e1`, and `ship --dry-run`
+  exited 0 printing the `gh pr create` line. Now `ship` asks the ledger's `lastMerge` (#295 — the
+  last `task.done` carrying `commit` and `epic_base`, which survives a reopen precisely so "what
+  does the epic hold" can be asked) for every story not `done`, and a `changes` there is a
+  rejection that stands: exit 2 — a gate DID say no, unlike #210's 1 — naming the story, the merge
+  and the handoff's own reason, with #210's remedy (`tldrx story reopen <id> --note`, re-run Build,
+  or open the PR by hand). Not widened to a merged diff nobody judged (`n-a`/`error`) — that is #311,
+  filed from this change. Guards, all passing before: a `changes` a later attempt merged over and got approved
+  ships; a story whose diff never merged ships; a story parked at `review` under a SIGNED fix list
+  ships with its findings listed. Two mutations of the predicate each redden a different test.
+  Golden byte-identical: nothing in Build changed. The unattended path was already closed one
+  door earlier — the auto gate refuses to self-sign over any story not `done`
+  (`autoGate.ts` `UNFINISHED_STORIES`, pinned in `test/build-executor.test.ts`) — so this reaches
+  a PR only after a person approved the Build gate, which is exactly when the record has to say
+  what the diff contains.
+
+- **A stage-failure line keeps the branch it exists to name when the worktree path is wider than
+  the line (#310, #293).** MEASURED 2026-09-14 under a ~115-char session scratchpad, the very place
+  `AGENTS.md §2` sends every agent to work: the epic-worktree refusal put the absolute path FIRST
+  and the two branch names after it, `oneLine` kept the first 220 chars, and the operator line —
+  and `run.yml`'s task row, and the `stage.failed` event — read `epic worktree /private/tmp/…/
+  _epic-260829-build-E1 is checked out on \`epic/someb…`: the branch cut two characters in, while
+  the same test passed on the same sha under a short `TMPDIR`. A refusal that loses its subject
+  exactly when the path is long is a refusal that names the wrong thing when it matters most.
+  Two halves, one implementation each: `assertWorktreeOn` now says the branches first and the
+  path last (`… is checked out on \`X\`, not \`Y\` — refusing … — at <path>`), and `oneLine`'s
+  cap keeps a line's head AND its tail, losing the middle — so what a cut takes is the middle of
+  a directory whose root the operator already knows. The cap itself stays at 220: each of the
+  three records is still one bounded line. `test/build-executor.test.ts` builds the refusal under
+  a path wider than the cap on purpose (the fixture roots in `os.tmpdir()`, which reads
+  `TMPDIR` at call time) and pins both branches, the worktree's own directory and the bound in
+  all three records — RED on the old order (only the path and `…` survived), and each half
+  reverted alone reddens it on its own assertion; the unit test on `assertWorktreeOn` pins the
+  order. The existing WRONG-branch test asserts the worktree's relative directory rather than
+  the whole absolute path, so it no longer depends on how long the box's `TMPDIR` is.
+
+## 0.26.0 — 2026-09-14
+
+### Fixed
+
+- **`tldrx replay` says what a failed stage died of, instead of `FAILED: no reason recorded` for
+  every one (#309).** MEASURED by inspection at `03d53e8`: the ONLY writer of `stage.failed` in the
+  tree — and, per `git log -S`, in its whole history — carries the failure as `payload.reason`
+  (`runNext.ts`, the fail path; the same field `stage.skipped` uses, and the same field `run auto`'s
+  own summary reads). The narrative renderer read `payload.error`, a field nothing ever set, so
+  `text()` was always empty and the fallback always fired — a stakeholder reading a replay saw
+  that a stage failed and never why, while the reason sat one field over in the same line of
+  `events.jsonl`. Same class as the `message`/`detail` drift #249's round-1 review found:
+  payloads are untyped and nothing checks a reader's field name against its writer's. The
+  renderer now reads `reason`, like its sibling one line down; the `FAILED: ` marker and the
+  fallback sentence are exported constants, and `test/replay.test.ts` feeds a hand-built
+  `stage.failed` event and pins the rendered line to the reason it carried (RED on the old read:
+  the line was never found; the fallback case is a guard). No record changes shape — nothing
+  wrote `error`, so there is no old record to tolerate.
+
+- **A wide story's measured widening no longer kills the invocation that earned it, and an executor that
+  throws after paid turns leaves their rows and their money in `run.yml` (#249).** MEASURED on a live 0.24.0
+  field run: a story with 16 declared touches changed 32 files, and the `story.touches_widened` the framework
+  measures at settle carried `paths`, `before` and `after` — three unbounded path lists, 5556 bytes against
+  the 4096-byte cap. `capPayload` knew `detail` and `outputs` by name and nothing else, so `EventLog.append`
+  threw; `measureSurface`'s "advisory, never throws" contract guarded the git read and not the emit, so the
+  throw went out through `settle` — after the story's `done` was on disk and before its `task.done` was in
+  the ledger — into `runNext`'s catch, which failed the stage with `tasks_recorded: false`: the developer's
+  and the reviewer's paid turns never reached `run.yml`, and every ceiling that derives from recorded spend
+  was short by exactly that, so the next economy refusal that should have fired would not have. Three fixes,
+  one per seam. The cap seam knows the three lists BY NAME in one declared table (`DROPPABLE_LISTS`):
+  `after` first (the largest, and derivable from the other two), then `before`, then `paths` last — each
+  dropped WHOLE and only while the payload is still over, each replaced by `<field>_omitted: N` and the same
+  reason-and-pointer sentence `outputs_omitted` carries, never a shortened list, which would read downstream
+  as the whole one; a `paths_omitted` a writer already put there (`worktree.foreign_work_aside`) is added
+  to, not overwritten. Every reader — `wideningRows`, the Build handoff, `tldrx replay` — renders
+  `(16 → 29 path(s))` from ONE derivation, `listCount`, so a row the cap could not carry reads the same
+  everywhere. `measureSurface` never throws: a refused emit records a bounded absence on the same event (the
+  counts, and a `note` naming the failure), and a log that refuses even that says so on stderr while the
+  story still settles. And the structural half, the expensive one: the Build executor carries the rows it
+  had already earned ON the error it throws (`withPartialTasks` — data on the same object, never a wrapper,
+  so what threw is still what the caller sees), and `runNext`'s catch records them through the same
+  `recordExecutorTasks` the return path uses BEFORE it fails the stage: the `error` event says
+  `tasks_recorded: true` with `rows_written`/`rows_expected` measured off the store after the write, the
+  rows keep their own `done` rather than being repainted with a throw they did not produce, and
+  `budget.spent_usd` is what was paid. Pinned by a real fake-agent build whose settle throws after both turns:
+  MEASURED on that case, the ledger before the fix recorded 0 rows / $0.00 for two paid turns, and after it
+  records 2 rows / $0.50. Which is the sentence an operator needs after this release: the cost half does not
+  just stop losing money, it stops LYING in favour of spend. With paid turns now recorded, ceilings bite
+  earlier — a run that used to reach the end because the ledger counted short may now be refused mid-way,
+  correctly but differently, so a new economy refusal after upgrading is this change working, not a
+  regression to hunt elsewhere. Pre-merge review found the double fault behind that: when recording the
+  carried rows itself threw (an `agent.result` the cap cannot rescue), rows and events were interleaved, so
+  a throw at event k stranded rows k+1… in memory and nothing the spend surfaces read said so — a plausible
+  short total, worse than a loud zero — and the `error` event was emitted BEFORE the save with a free-text
+  `recording_error` the cap did not trim, so a long one could throw the seam and lose the rows with no
+  trace. Now every row goes into the store before any event is appended (the in-memory row write cannot
+  throw; the append is the only line that can), the store is saved before the `error` event is emitted and
+  that emit is wrapped, `recording_error` sits in the cap's prose table beside `detail`, and no new
+  vocabulary reaches `budget show`, the dashboard or status: `run.yml` is whole, so they read a
+  measurement. Pre-merge review round 2 found the events side was NOT labelled — `tldrx cost --stories`
+  reads only `agent.result` events, so a story the fault left un-evented came back with no measured cost
+  and zero unmetered turns, a silent null at odds with the `budget.spent_usd` run.yml records. Now the
+  story ledger walks the log in order: a spawn opens a slot for its story, a result closes one (or, arriving
+  late from an orphaned agent after its slot was already counted lost, retires that lost slot — a result is
+  proof the turn was metered whenever it lands, never both the dollars and a lost turn), and an
+  invocation-terminal event on that stage (`stage.done`/`failed`/`skipped`, the executor or record-tasks
+  `error`, or a later `stage.started` that superseded it) turns every slot still open into a LOST turn,
+  which enters the SAME unmetered/lower-bound door: the story reads as a LOWER BOUND with the turn count,
+  not a confident zero (the dollars are in run.yml; a task row carries no story key, so they are named
+  absent per story, never invented). A spawn with nothing terminal after it is a turn IN FLIGHT — every
+  healthy mid-run read of `tldrx cost` and of the handoff — and is counted as nothing, review round 3's
+  finding: `spawned − accounted` alone had flagged every live build as a lower bound. Events carry no
+  attempt id, so the log's own order is the attempt scope. `tldrx replay`
+  renders the error line from `detail` (it read `message`, a field the event never carried) and reports
+  `rows_written` of `rows_expected` — reports, never sums.
+
 ## 0.25.0 — 2026-09-14
 
 ### Fixed

package/README.md

@@ -335,6 +335,8 @@ back on the registry is 0.3.0.
 
 | Version | Date | Status | Contains |
 |---|---|---|---|
+| 0.26.1 | 2026-09-14 | `beta` | Three refusals that stop a bad state from settling quietly. A Build fix round whose developer lands no diff is refused before the DoD instead of closing `done` on an unmoved tree, because `commitIfDirty` hands back the old head sha on a clean commit and the existing "no commit to review" gate never fires for it — `workSince` is now asked on the success path too, for any story a person put back with a note. `tldrx ship` refuses an epic carrying a story the reviewer marked `changes`: it asks the ledger's `lastMerge` for every story not `done` and exits 2 naming the story, the merge and the handoff's reason, instead of opening a PR whose "Not done" list hid rejected code already merged into the diff. And a stage-failure line keeps the branch it names when the worktree path is wider than the line: the refusal puts the branches before the path, and `oneLine` keeps a line's head and tail instead of dropping the identifiers that sat at the end. |
+| 0.26.0 | 2026-09-14 | `beta` | Two field defects from the same class — a reader of an event payload trusting a field its writer never set — plus the ceiling that killed the turn that earned it. A wide story's measured `touches_widened` no longer throws after the turn has settled: the cap knows the three lists by name and drops them whole by count, every reader derives before/after through one function, and an executor that throws after paid turns leaves their rows and money in `run.yml` and saves before it emits. The cost surfaces then agree with each other: a turn whose result was lost to that fault reads as UNMETERED, LOWER BOUND on `tldrx cost` and in the Build handoff through the door other unmeasured turns already use, a turn still in flight reads as nothing, and a late result retires the lost mark instead of counting twice. Replay reads the reason a failed stage recorded instead of printing "no reason recorded" for every one. |
 | 0.25.0 | 2026-09-14 | `beta` | The other half of the two-session protocol and four holes measured on live runs. `scripts/release.sh` now waits on a running wave's lock before touching the tree and never hands back the marker it wrote — release has precedence, the wave yields, exit 14 when it gives up; the heading gate also refuses an unreleased version at or below `package.json`; the marker carries its phase and `--status` reports a release queued behind a wave (#304). In-session `tldrx next --prepare` and `--commit` ask the same dependency frontier the headless loop asks: a terminal hold records the dependent `blocked`, a pending hold refuses without writing, a held `--commit` keeps the work it sits on and says where it is (#300). A Watch card refused for an unsourced `## Where` item comes back to its writer marked, the refusal names the cure, and the brief shows one non-file example, so a retry edits the card instead of regenerating it blind (#301). And `run.yml` no longer loses an external write to a live loop: a save carries only the fields the store changed over a fresh read, ownership is declared, `cancelled` is terminal and wins in the file and in the process, a file that cannot be merged is kept beside as `.bak` and said so, and a file recording another run is refused (#305). Minor release: a new exit code on a public script, a stricter merge gate, and `--prepare`/`--commit` refuse where they used to proceed. |
 | 0.24.0 | 2026-09-14 | `beta` | Five fixes from one unattended night, all measured on live runs. The two-session protocol is mechanical where it was chat: the merge wave refuses a merged tree with two unreleased CHANGELOG headings or one at or below the last release (exit 12), `release.sh` holds a `.RELEASE-IN-PROGRESS` marker the wave waits on (exit 13 when it gives up), `merge-wave.sh --status` reads holder, branch and phase in one line, and the `maintain` skill gains a worker-mode section (#299). A per-story cap says what it was derived from — plan price × stage scale — and names the lever that moves it, and a plan whose prices exceed the stage budget is told so instead of being scaled in silence (#281). A story whose dependency is still at `review` waits in `todo` instead of being written `blocked`, and a dependency block left by an earlier version is released once the dependency is `done` (#280). `--until-done` compares the refusal across attempts, not the advice line printed under it, so a failure that made progress keeps its relaunches (#297). And the Build handoff no longer fails its own `claim-sources` check over a refused command that spans lines: one physical line per element, the break shown as `⏎` and explained once in the document (#283). Minor release: the wave and `--until-done` behave differently in situations that exist today. |
 | 0.23.0 | 2026-09-14 | `beta` | `tldrx story reopen --as-is` now settles a story whose work is already merged into the epic but whose review never completed (`n-a` or `error` on its last recorded merge): a new, named review-only case that merges nothing and only routes the story to its reviewer, read from an additive ledger field; the existing refusal ("no commit the epic has not got") is untouched and now names the standing verdict when one exists (`changes`, `approve`, `fixlist` still refuse). A fix list whose findings are all deferred settles the story `done` instead of spawning a developer with nothing to fix, measured on a live run that paid for four such developers (#295). And a turn that died on a provider limit no longer records `success` borrowed from the provider's own subtype: the failure record says what the host saw (#296, first half — DETECTING the provider limit as its own non-execution kind is #298 and is NOT in this release). Minor release: `story reopen --as-is` behaves differently in a situation that exists today. |

package/dist/hooks/answer-capture.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   conflictOf
-} from "./chunk-tjx8g39f.js";
+} from "./chunk-d0jhr5wh.js";
 import {
   FactsStore,
   formatJaccard
@@ -13,7 +13,7 @@ import {
 import {
   EventLog,
   PHASE_ID_RE
-} from "./chunk-6z5rmj0b.js";
+} from "./chunk-41k19q8t.js";
 import {
   PHASE_IDS
 } from "./chunk-m1s8a6s0.js";

package/dist/hooks/budget-gate.js

@@ -25,7 +25,7 @@ import {
 } from "./chunk-bbrhs055.js";
 import {
   EventLog
-} from "./chunk-6z5rmj0b.js";
+} from "./chunk-41k19q8t.js";
 import {
   cursorStage,
   hostTokensIn,

package/dist/hooks/{chunk-tjx8g39f.js → chunk-d0jhr5wh.js}

@@ -5,7 +5,7 @@ import {
   evidencePath,
   gateEvidencePath,
   parseEvidence
-} from "./chunk-6z5rmj0b.js";
+} from "./chunk-41k19q8t.js";
 import {
   openBlocks,
   parseQuestions

package/dist/hooks/{chunk-rgn23z77.js → chunk-pwzy19er.js}

@@ -21,7 +21,7 @@ import {
   isTerminal,
   stageAt,
   validateRunFile
-} from "./chunk-6z5rmj0b.js";
+} from "./chunk-41k19q8t.js";
 import {
   cursorStage,
   isAttendedByHostView,

package/dist/hooks/session-start.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   questionsCard
-} from "./chunk-tjx8g39f.js";
+} from "./chunk-d0jhr5wh.js";
 import"./chunk-jpp137mb.js";
 import {
   allow,
@@ -20,7 +20,7 @@ import {
   runSnapshot,
   statusWithOutcome,
   whatIsWaiting
-} from "./chunk-rgn23z77.js";
+} from "./chunk-pwzy19er.js";
 import {
   expertsDir,
   loadExperts,
@@ -30,7 +30,7 @@ import {
 } from "./chunk-bbrhs055.js";
 import {
   isFinished
-} from "./chunk-6z5rmj0b.js";
+} from "./chunk-41k19q8t.js";
 import"./chunk-m1s8a6s0.js";
 import {
   openRunViews

package/dist/hooks/statusline.js

@@ -2,9 +2,9 @@
 import {
   bar,
   runSnapshot
-} from "./chunk-rgn23z77.js";
+} from "./chunk-pwzy19er.js";
 import"./chunk-bbrhs055.js";
-import"./chunk-6z5rmj0b.js";
+import"./chunk-41k19q8t.js";
 import"./chunk-m1s8a6s0.js";
 import"./chunk-yre2scxn.js";
 import"./chunk-bznt6jb2.js";

package/dist/tldrx.js

@@ -7362,24 +7362,34 @@ function capPayload(payload, save) {
   const where = (text, field) => save === undefined ? "the full text was not preserved and is not recoverable from this event" : save(text, field);
   const named = (size, text, field) => `${String(size)} bytes exceeds the ${String(MAX_PAYLOAD_BYTES)}-byte cap — ${where(text, field)}`;
   let current = payload;
-  if (typeof current.detail === "string") {
-    const { detail: dropped, ...rest } = current;
-    current = { ...rest, detail_omitted: named(byteSize(current), dropped, "detail") };
+  for (const field of DROPPABLE_PROSE) {
+    const dropped = current[field];
+    if (typeof dropped !== "string")
+      continue;
+    const { [field]: _gone, ...rest } = current;
+    current = { ...rest, [`${field}_omitted`]: named(byteSize(current), dropped, field) };
     if (byteSize(current) <= MAX_PAYLOAD_BYTES)
       return current;
   }
-  if (Array.isArray(current.outputs) && current.outputs.length > 0) {
-    const { outputs: dropped, ...rest } = current;
-    const list = dropped;
+  for (const field of DROPPABLE_LISTS) {
+    if (byteSize(current) <= MAX_PAYLOAD_BYTES)
+      return current;
+    const list = current[field];
+    if (!Array.isArray(list) || list.length === 0)
+      continue;
+    const { [field]: dropped, ...rest } = current;
+    const already = current[`${field}_omitted`];
     current = {
       ...rest,
-      outputs_omitted: list.length,
-      outputs_omitted_reason: named(byteSize(current), list.map((p) => String(p)).join(`
-`), "outputs")
+      [`${field}_omitted`]: list.length + (typeof already === "number" ? already : 0),
+      [`${field}_omitted_reason`]: named(byteSize(current), dropped.map((p) => String(p)).join(`
+`), field)
     };
   }
   return current;
 }
+var DROPPABLE_LISTS = ["outputs", "after", "before", "paths"];
+var DROPPABLE_PROSE = ["recording_error", "detail"];
 function byteSize(payload) {
   return Buffer.byteLength(JSON.stringify(payload), "utf8");
 }
@@ -16563,6 +16573,7 @@ var ENTRIES = [
       "It pushes ONLY when the run says so. Publishing a branch is a decision, so by default a branch the remote has not seen is a refusal that names the `git push` command rather than running it. The decision is taken once, at `tldrx run new --ship <push|pr|merge>` (#253): then this verb pushes the epic first, through the one push wrapper in the codebase (the Build phase itself still has none, spec §5), and under `merge` arms `gh pr merge --auto --merge` after the PR opens — unless the PR reports NO check at all, or the BASE branch was not seen to require one (#274: `--auto` waits on the base's requirements, not on the PR's reported checks, so over a base that requires nothing it merges at once), in which case the PR is left open and run.yml says which absence it was. `run auto` calls this verb when it sees the run close and skips a run whose record already carries `shipped_at`; typing `tldrx ship` again is the recovery after a partial failure — a repo whose merge is recorded `failed` is armed again, one recorded `queued` is left alone, and the record is the union, so a recorded failure is never erased. A run without the block is never written.",
       "The body is WRITTEN for a PR (#167): an **Outcome** line saying how much of the plan landed (`partial: 1 of 3 stories delivered; S2 — …`); what shipped and what did not, from the handoff's own done/not-done split; the reviewer findings still open, read from the run's fix lists; and the LAST phase handoff the run has on disk — `04-build/handoff.md` on a run that built something — verbatim and complete, inside a `<details>` block. It goes to `gh` as a file, never as an argument, so a long body cannot overflow an argv limit.",
       "It REFUSES a run that delivered no story (exit 1 — nothing behind it, #210). `ship` already knew: the body it renders keeps only the handoff bullets that say `done`, and with none it wrote `(nothing settled `done` in this run)` into a PR it opened anyway. The refusal names the counts and the first blocked story's own reason, and `--dry-run` is refused in the same words. A run that delivered at least one story ships exactly as it did before.",
+      "It REFUSES an epic carrying a story the reviewer REJECTED (exit 2 — a gate said no, #282). A story merges into its epic BEFORE its review, by design, so a `changes` verdict leaves the diff on the branch: with one story `done` beside it the PR opened with the rejected code in its diff and a body that listed the story under \"Not done\" without saying so. The refusal reads the ledger's last merge for every story not `done` — the last `task.done` carrying `commit` and `epic_base` — and names the story, that merge and the handoff's own reason. A `changes` a later attempt merged over and got approved is not a rejection, a story whose diff never merged has nothing to refuse, and a story parked at `review` under a SIGNED fix list ships with its findings listed. `--dry-run` is refused in the same words.",
       "It moves no gate and no cursor and appends no event. On a run with no `ship:` block it never writes to the run at all; on a run with one it writes exactly that block's record (`pr_urls`, `merge`, `merges`, `shipped_at`) and nothing else. To mirror the plan's epics and stories to a ticket tool, `tldrx tickets sync` is the verb that does that, and it stays separate.",
       "It refuses cleanly, in a sentence, when there is no epic branch, no handoff, no remote, no `gh` on PATH, or when several epic branches leave the choice open.",
       "When the branch exists in SEVERAL repos — the normal shape of a chained multi-repo run, whose epics share one integration branch — it opens one PR per repo: the same body, the repo name in the title, and every URL listed at the end. `--repo` narrows it to one.",
@@ -25898,7 +25909,7 @@ async function assertWorktreeOn(path, branch, what = "worktree") {
   const on = await currentBranch(path);
   if (on === branch)
     return;
-  throw new WorktreeBranchMismatchError(`${what} ${path} is checked out on \`${on === "" ? "(no branch)" : on}\`, not \`${branch}\` — ` + "refusing to touch it, because a merge here would land on another run's branch");
+  throw new WorktreeBranchMismatchError(`${what} is checked out on \`${on === "" ? "(no branch)" : on}\`, not \`${branch}\` — ` + `refusing to touch it, because a merge here would land on another run's branch — at ${path}`);
 }
 async function shaReachability(cwd, sha, ref) {
   const resolved = await git(["rev-parse", "--verify", "--quiet", `${sha}^{commit}`], cwd);
@@ -26562,6 +26573,11 @@ var AS_IS_MARK = "the branch was taken AS IT STANDS — no developer was spawned
 var AS_IS_NOT_AHEAD_MARK = "nothing to take as it stands";
 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";
+var NO_DIFF_MARK = "the developer produced no diff";
+function noDiffAfterReopenReason(parts) {
+  const round4 = parts.fix ? "the fix round" : "the reopen";
+  return `${NO_DIFF_MARK}: the tree is the one it was handed (\`${parts.handed.slice(0, 7)}\`), ` + `and ${round4} ${parts.actor} signed says \`${firstLine7(parts.note)}\`. ` + "Nothing changed, so nothing could have landed it — no DoD ran and no reviewer was spawned. " + "Reopen it with a note that names what the developer has to change";
+}
 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";
@@ -30038,8 +30054,9 @@ function wideningBullets(rows) {
   for (const row2 of rows.slice(0, MAX_WIDENING_BULLETS)) {
     const named = row2.paths.slice(0, NAMED_WIDENED_PATHS).map((path) => `\`${path}\``).join(", ");
     const more = row2.paths.length > NAMED_WIDENED_PATHS ? `, +${String(row2.paths.length - NAMED_WIDENED_PATHS)} more` : "";
+    const unlisted = (row2.pathsOmitted ?? 0) > 0 ? `${row2.paths.length === 0 ? "" : ", "}${String(row2.pathsOmitted)} path(s) not listed on the event` : "";
     const opening = row2.basis === "measured" ? `${row2.story}'s declared surface was under the work it did (measured)` : `${row2.story}'s surface was widened by a person (declared)`;
-    out.push(`- ${opening}: +${named}${more} ` + `(${String(row2.before)} → ${String(row2.after)} path(s))` + `${row2.note === "" ? "" : ` — ${row2.note}`} [src: events.jsonl:${String(row2.line)}]`);
+    out.push(`- ${opening}: +${named}${more}${unlisted} ` + `(${String(row2.before)} → ${String(row2.after)} path(s))` + `${row2.note === "" ? "" : ` — ${row2.note}`} [src: events.jsonl:${String(row2.line)}]`);
   }
   if (rows.length > MAX_WIDENING_BULLETS) {
     const next = rows[MAX_WIDENING_BULLETS]?.line ?? 1;
@@ -35798,6 +35815,11 @@ var MEASURED_NOTE_TAIL = " — measured off the story's own diff, the range the
 function basisOf(payload) {
   return payload.basis === "measured" ? "measured" : "declared";
 }
+function listCount(payload, field) {
+  const list = payload[field];
+  const omitted = payload[`${field}_omitted`];
+  return (Array.isArray(list) ? list.length : 0) + (typeof omitted === "number" ? omitted : 0);
+}
 function stringList3(value) {
   return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
 }
@@ -35822,8 +35844,9 @@ function wideningRows(eventsText) {
       story: typeof payload.story === "string" ? payload.story : "?",
       basis: basisOf(payload),
       paths: stringList3(payload.paths),
-      before: stringList3(payload.before).length,
-      after: stringList3(payload.after).length,
+      ...typeof payload.paths_omitted === "number" && payload.paths_omitted > 0 ? { pathsOmitted: payload.paths_omitted } : {},
+      before: listCount(payload, "before"),
+      after: listCount(payload, "after"),
       note: typeof payload.note === "string" ? payload.note : "",
       line: i + 1
     });
@@ -38830,6 +38853,9 @@ function storyLedger(runDir2, scope = null, extraTurns = []) {
   const ceilings = new Map;
   const measured = new Map;
   const unmetered = new Map;
+  const open = new Map;
+  const openStage = new Map;
+  const lost = new Map;
   const storyKeys = new Set;
   const storyPhases = new Set;
   let excluded = 0;
@@ -38878,6 +38904,39 @@ function storyLedger(runDir2, scope = null, extraTurns = []) {
     else
       measured.set(turn.key, round9((measured.get(turn.key) ?? 0) + turn.costUsd));
   }
+  for (const event4 of events) {
+    if (event4.type === "agent.spawned" && inScope(event4)) {
+      const story = str10(event4.payload.story);
+      if (story === null)
+        continue;
+      open.set(story, (open.get(story) ?? 0) + 1);
+      openStage.set(story, event4.stage);
+      continue;
+    }
+    if (event4.type === "agent.result" && inScope(event4)) {
+      const key = str10(event4.payload.key);
+      if (key === null || !isStory(key, str10(event4.payload.phase)))
+        continue;
+      const opened = open.get(key) ?? 0;
+      if (opened > 0)
+        open.set(key, opened - 1);
+      else if ((lost.get(key) ?? 0) > 0)
+        lost.set(key, (lost.get(key) ?? 0) - 1);
+      continue;
+    }
+    if (!closesAttempt(event4))
+      continue;
+    for (const [story, count] of open) {
+      if (count === 0 || openStage.get(story) !== event4.stage)
+        continue;
+      lost.set(story, (lost.get(story) ?? 0) + count);
+      open.set(story, 0);
+    }
+  }
+  for (const [story, count] of lost) {
+    if (count > 0)
+      unmetered.set(story, (unmetered.get(story) ?? 0) + count);
+  }
   return {
     rows: order.map((story) => ({
       story,
@@ -38889,6 +38948,14 @@ function storyLedger(runDir2, scope = null, extraTurns = []) {
     events: events.length
   };
 }
+function closesAttempt(event4) {
+  if (event4.type === "stage.started" || event4.type === "stage.done" || event4.type === "stage.failed" || event4.type === "stage.skipped")
+    return true;
+  if (event4.type !== "error")
+    return false;
+  const where = str10(event4.payload.where);
+  return where === "executor" || where === "record-tasks";
+}
 function buildStoryCost(runDir2) {
   let title = "";
   let runId = basename13(runDir2);
@@ -39006,7 +39073,7 @@ function storyVerdict(cost) {
     return "no total: a story above is missing one side, and an absent figure is not summed as zero.";
   }
   if (floor) {
-    return `no verdict: ${turns} unmetered, so at least one story's measurement is a LOWER BOUND ` + "— an unmetered turn could put it over a spawn ceiling this cannot see.";
+    return `no verdict: ${turns} unmetered, so at least one story's measurement is a ${LOWER_BOUND_MARK} ` + "— an unmetered turn could put it over a spawn ceiling this cannot see.";
   }
   return "every story measured inside the spawn ceilings it was given.";
 }
@@ -39035,7 +39102,7 @@ function renderStoryCost(cost) {
     lines.push("  measured not recorded — no metered `agent.result` carried a cost for that story. " + "A turn this process never metered is a cost it did not see, never a free one.");
   }
   if (cost.unmeteredStories.length > 0) {
-    lines.push(`  ${cost.unmeteredStories.join(", ")}: ${plural3(cost.unmeteredTurns, "turn")} UNMETERED, so ` + "that measurement is a LOWER BOUND, not a total.");
+    lines.push(`  ${cost.unmeteredStories.join(", ")}: ${plural3(cost.unmeteredTurns, "turn")} UNMETERED, so ` + `that measurement is a ${LOWER_BOUND_MARK}, not a total.`);
   }
   if (cost.excludedKeyedResults > 0)
     lines.push(`  ${excludedLine(cost)}`);
@@ -39104,6 +39171,7 @@ function readBudget(runDir2) {
 var ECONOMY_WIDTH = 12;
 var DASH = "—";
 var NOT_RECORDED = "not recorded";
+var LOWER_BOUND_MARK = "LOWER BOUND";
 function tokenColumns(t, declared2 = 0) {
   const measured = `${bigTokens(t.input)} in · ${bigTokens(t.output)} out · ` + `${bigTokens(t.cacheCreation)} cache write · ${bigTokens(t.cacheRead)} cache read`;
   if (declared2 <= 0)
@@ -39287,7 +39355,7 @@ async function buildExecutor(ctx) {
     try {
       await session.restoreForeignWorkAside();
     } catch {}
-    throw error;
+    throw withPartialTasks(error, session.tasks);
   }
 }
 function refusedOnBase(session, error) {
@@ -40024,6 +40092,26 @@ class BuildSession {
         before
       };
     }
+    const reopen = this.reopenFor(planned);
+    if (reopen !== null) {
+      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: noDiffAfterReopenReason({ handed, ...reopen }),
+          developerError: null,
+          before
+        };
+      }
+    }
     const dod = await this.runDod(story);
     if (!this.dodProves(dod)) {
       const failing = dodFailure(dod);
@@ -40393,6 +40481,14 @@ class BuildSession {
       return;
     this.lines.push(`  · ${planned.story.id} was reopened by ${ledger4.reopened.actor} (${ledger4.reopened.note}) — ` + `the verdicts before that do not count against it, so it runs as attempt 1 of ${String(this.attempts)}`);
   }
+  reopenFor(planned) {
+    const ledger4 = readReviewLedger(this.ctx.runDir, planned.story.id);
+    if (ledger4.fixRound !== null)
+      return { note: ledger4.fixRound.note, actor: ledger4.fixRound.actor, fix: true };
+    if (ledger4.reopened !== null)
+      return { note: ledger4.reopened.note, actor: ledger4.reopened.actor, fix: false };
+    return null;
+  }
   waveFailed(wave) {
     return wave.stories.some((planned) => this.statusOf(planned) === "blocked");
   }
@@ -41173,14 +41269,33 @@ class BuildSession {
     const measured = measuredWidening(changed, declared2);
     if (measured === null)
       return;
-    this.ctx.emit("story.touches_widened", {
-      story: story.planned.story.id,
-      paths: [...measured.paths],
-      note: measured.note,
-      before: [...measured.before],
-      after: [...measured.after],
-      basis: "measured"
-    }, 0, "framework");
+    const id = story.planned.story.id;
+    const actor = "framework";
+    try {
+      this.ctx.emit("story.touches_widened", {
+        story: id,
+        paths: [...measured.paths],
+        note: measured.note,
+        before: [...measured.before],
+        after: [...measured.after],
+        basis: "measured"
+      }, 0, actor);
+      return;
+    } catch (error) {
+      const why = firstLine7(error instanceof Error ? error.message : String(error));
+      try {
+        this.ctx.emit("story.touches_widened", {
+          story: id,
+          paths_omitted: measured.paths.length,
+          before_omitted: measured.before.length,
+          after_omitted: measured.after.length,
+          note: `${measured.note} — the lists could not be recorded on this event: ${why}`,
+          basis: "measured"
+        }, 0, actor);
+      } catch (again) {
+        this.advisories.push(`${id}: the measured widening of its surface (${String(measured.paths.length)} path(s) outside ` + `\`touches:\`) could not be recorded in events.jsonl — ` + firstLine7(again instanceof Error ? again.message : String(again)));
+      }
+    }
   }
   orderedOutcomes() {
     const rows = [];
@@ -41791,6 +41906,20 @@ function failed3(ctx, error, tasks) {
 }
 
 // src/core/facilitator/executors/index.ts
+var PARTIAL_TASKS = Symbol.for("tldrx.partialTasks");
+function withPartialTasks(error, tasks) {
+  if (tasks.length === 0)
+    return error;
+  const carrier = typeof error === "object" && error !== null ? error : new Error(String(error));
+  Object.defineProperty(carrier, PARTIAL_TASKS, { value: [...tasks], enumerable: false, configurable: true });
+  return carrier;
+}
+function partialTasksOf(error) {
+  if (typeof error !== "object" || error === null)
+    return [];
+  const tasks = error[PARTIAL_TASKS];
+  return Array.isArray(tasks) ? tasks : [];
+}
 var EXECUTORS = new Map([
   [BUILD_PHASE, buildExecutor],
   [WATCH_PHASE, watchExecutor]
@@ -42535,14 +42664,33 @@ async function runExecutor(store, options, phaseId, stageId, spec, notes, execut
     outcome = await executor(executorCtx);
   } catch (error) {
     const why = error instanceof Error ? error.message : String(error);
-    appendCapped("error", {
+    const partial = partialTasksOf(error);
+    const progress2 = { rows: 0, events: 0 };
+    let recordingFailed = null;
+    if (partial.length > 0) {
+      try {
+        recordExecutorTasks(store, options, phaseId, stageId, spec, partial, progress2);
+      } catch (again) {
+        recordingFailed = again instanceof Error ? again.message : String(again);
+      }
+    }
+    const written = requireStage(store, phaseId, stageId).tasks.length - tasksBefore;
+    const whole = partial.length > 0 && written === partial.length;
+    store.save();
+    const extra = appendOrSay(() => appendCapped("error", {
       phase: phaseId,
       where: "executor",
       detail: why,
-      tasks_recorded: false
-    }, 0);
-    store.save();
-    return failStage(store, options, phaseId, stageId, `the executor threw before returning its task rows — this invocation's turn costs are not in run.yml: ${why}`, notes, tasksBefore);
+      tasks_recorded: whole,
+      rows_written: written,
+      rows_expected: partial.length,
+      events_written: progress2.events,
+      ...recordingFailed === null ? {} : { recording_error: recordingFailed }
+    }, 0));
+    const n = String(partial.length);
+    const eventsShort = recordingFailed === null ? "" : `; ${String(progress2.events)} of ${n} agent.result events could not be appended: ${recordingFailed}`;
+    const reason = partial.length === 0 ? `the executor threw before returning its task rows — this invocation's turn costs are not in run.yml: ${why}` : whole ? `the executor threw after ${n} turn(s) — their rows and costs are in run.yml${eventsShort}: ${why}` : `the executor threw after ${n} turn(s) and recording their rows threw too — ` + `${String(written)} of ${n} rows are in run.yml and the rest are not: ${why}; recording: ${recordingFailed ?? "unknown"}`;
+    return failStage(store, options, phaseId, stageId, reason, [...notes, ...extra], tasksBefore + written);
   }
   if (isSequencingRefusal(outcome)) {
     if (!started) {
@@ -42552,20 +42700,25 @@ async function runExecutor(store, options, phaseId, stageId, spec, notes, execut
     return out(EXIT_USAGE3, [...notes, ...outcome.lines], [], executorSignature(outcome));
   }
   claimEpicBranches(store, outcome.epicBranches, outcome.branchModel);
+  const progress = { rows: 0, events: 0 };
   try {
-    recordExecutorTasks(store, options, phaseId, stageId, spec, outcome);
+    recordExecutorTasks(store, options, phaseId, stageId, spec, outcome.tasks, progress);
   } catch (error) {
     const why = error instanceof Error ? error.message : String(error);
     const recorded = requireStage(store, phaseId, stageId).tasks.length;
-    appendCappedEvent(store, options, phaseId, stageId, "error", {
+    const written = recorded - tasksBefore;
+    const expected = outcome.tasks.length;
+    store.save();
+    const extra = appendOrSay(() => appendCappedEvent(store, options, phaseId, stageId, "error", {
       phase: phaseId,
       where: "record-tasks",
       detail: why,
-      rows_written: recorded - tasksBefore,
-      rows_expected: outcome.tasks.length
-    }, 0);
-    store.save();
-    return failStage(store, options, phaseId, stageId, `recording this invocation's task rows threw — ${String(recorded - tasksBefore)} of ` + `${String(outcome.tasks.length)} rows are in run.yml and the rest are not: ${why}`, notes, recorded);
+      rows_written: written,
+      rows_expected: expected,
+      events_written: progress.events
+    }, 0));
+    const rows = written === expected ? `all ${String(expected)} rows are in run.yml and ${String(progress.events)} of ${String(expected)} ` + "agent.result events were appended" : `${String(written)} of ${String(expected)} rows are in run.yml and the rest are not`;
+    return failStage(store, options, phaseId, stageId, `recording this invocation's task rows threw — ${rows}: ${why}`, [...notes, ...extra], recorded);
   }
   store.save();
   if (store.cancelledUnder) {
@@ -42595,11 +42748,22 @@ async function runExecutor(store, options, phaseId, stageId, spec, notes, execut
 function isSequencingRefusal(outcome) {
   return outcome.sequencing === true && outcome.refused === true && outcome.tasks.length === 0 && outcome.costUsd === 0 && (outcome.epicBranches?.length ?? 0) === 0;
 }
-function recordExecutorTasks(store, options, phaseId, stageId, spec, outcome) {
+function appendOrSay(append) {
+  try {
+    append();
+    return [];
+  } catch (error) {
+    const why = error instanceof Error ? error.message : String(error);
+    return [`the error event for this failure could not be appended to events.jsonl — ${why}; run.yml is saved regardless`];
+  }
+}
+function recordExecutorTasks(store, options, phaseId, stageId, spec, tasks, progress = { rows: 0, events: 0 }) {
   const version = frameworkVersionSync();
-  for (const task2 of outcome.tasks) {
+  const rows = [];
+  for (const task2 of tasks) {
     const id = nextTaskId(store, phaseId, stageId);
     const metered = task2.metered !== false;
+    rows.push({ id, task: task2, metered });
     recordTask(store, phaseId, stageId, {
       id,
       status: task2.error === null ? "done" : "failed",
@@ -42618,6 +42782,9 @@ function recordExecutorTasks(store, options, phaseId, stageId, spec, outcome) {
       ...cacheSplit(task2.usage?.cache_creation_input_tokens, task2.usage?.cache_read_input_tokens),
       ...task2.durationMs === undefined ? {} : { duration_ms: task2.durationMs, duration_basis: "spawned" }
     });
+    progress.rows += 1;
+  }
+  for (const { id, task: task2, metered } of rows) {
     appendCappedEvent(store, options, phaseId, stageId, "agent.result", {
       phase: phaseId,
       task: id,
@@ -42632,6 +42799,7 @@ function recordExecutorTasks(store, options, phaseId, stageId, spec, outcome) {
       ...task2.tokens === undefined ? {} : { tokens: task2.tokens },
       ...task2.usage === undefined ? {} : { usage: usagePayload(task2.usage) }
     }, metered ? round26(task2.costUsd) : 0);
+    progress.events += 1;
   }
 }
 async function commitStage(store, options, phaseId, stageId, spec, notes) {
@@ -43397,7 +43565,10 @@ function nowish(options) {
 function oneLine7(text3, max = 220) {
   const line = text3.split(`
 `)[0]?.trim() ?? "";
-  return line.length > max ? `${line.slice(0, max - 1)}…` : line;
+  if (line.length <= max)
+    return line;
+  const tail2 = Math.floor((max - 1) / 2);
+  return `${line.slice(0, max - 1 - tail2)}…${line.slice(line.length - tail2)}`;
 }
 function phaseMoney(store, phaseId) {
   const phase = store.budget.phases.find((entry) => entry.id === phaseId);
@@ -43612,6 +43783,19 @@ async function shipRun(options) {
     };
   }
   const stories = runStories(store);
+  const rejected = rejectedOnEpic(store.runDir, stories, view);
+  if (rejected.length > 0) {
+    const ids = rejected.map((row2) => row2.id);
+    return refuse2([
+      `${store.runId} carries a story the reviewer rejected, and its diff is on \`${branch}\``,
+      ...rejected.map((row2) => `  ${row2.id} — its last merge into the epic (commit ${row2.commit.slice(0, 7)} over epic base ` + `${row2.epicBase.slice(0, 7)}) was judged \`changes\`${row2.reason === null ? "" : `: ${row2.reason}`}`),
+      "  A story merges into the epic BEFORE its review, so a `changes` verdict leaves the diff on the branch;",
+      `  a PR over \`${branch}\` would carry that code, and its body would list ${ids.join(", ")} under "Not done"`,
+      "  without saying the diff is there.",
+      `  Unblock ${ids.length === 1 ? "it" : "them"} (` + (ids.length === 1 ? `\`tldrx story reopen ${ids[0] ?? ""} --note "<why>"\`` : `\`tldrx story reopen <id> --note "<why>"\` for each`) + ") and re-run Build so a verdict that stands lands over it,",
+      "  or open the PR by hand if you mean to ship the branch as it stands."
+    ]);
+  }
   const body = writeShipBody(store, branch, handoff, stories, new Set(loadWorkspace(options.root).repos.keys()));
   try {
     return await shipTo(options, store, branch, body, stories);
@@ -44061,6 +44245,23 @@ function remedyPaths(refused2, excused) {
     return `${PROJECT_WORK_DIR} ${PROJECT_FRAMEWORK_DIR}`;
   return refused2.map(quote2).join(" ");
 }
+function rejectedOnEpic(runDir2, stories, view) {
+  const rows = [];
+  for (const story of stories) {
+    if (story.status === "done")
+      continue;
+    const merge = readReviewLedger(runDir2, story.id).lastMerge;
+    if (merge === null || merge.verdict !== "changes")
+      continue;
+    rows.push({
+      id: story.id,
+      commit: merge.commit,
+      epicBase: merge.epicBase,
+      reason: view?.unfinished.find((row2) => row2.id === story.id)?.reason ?? null
+    });
+  }
+  return rows;
+}
 function settledTouches(stories) {
   const rows = [];
   for (const story of stories) {
@@ -53512,6 +53713,8 @@ import { isAbsolute as isAbsolute13, join as join135 } from "node:path";
 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
+var STAGE_FAILED_MARKER = "FAILED: ";
+var NO_REASON_RECORDED = "no reason recorded";
 function renderReplay(loaded) {
   const run2 = loaded.run;
   const out2 = [
@@ -53639,9 +53842,9 @@ function bullet2(item, trail) {
     case "stage.done":
       return `${prefix5}ended`;
     case "stage.failed":
-      return `${prefix5}FAILED: ${text3(payload2.error) || "no reason recorded"}`;
+      return `${prefix5}${STAGE_FAILED_MARKER}${text3(payload2.reason) || NO_REASON_RECORDED}`;
     case "stage.skipped":
-      return `${prefix5}skipped: ${text3(payload2.reason) || "no reason recorded"}`;
+      return `${prefix5}skipped: ${text3(payload2.reason) || NO_REASON_RECORDED}`;
     case "question.asked":
       return `${prefix5}${q || "a question"} asked by ${actor}: ${text3(payload2.question)}`.trimEnd();
     case "question.answered":
@@ -53657,7 +53860,7 @@ function bullet2(item, trail) {
     case "story.reopened":
       return `${prefix5}story ${text3(payload2.story) || "?"} REOPENED by ${actor}` + ` — back to \`${text3(payload2.to_status) || "todo"}\` from \`${text3(payload2.from_status) || "?"}\`` + `${note(payload2.note)}`;
     case "story.touches_widened":
-      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)}`;
+      return `${prefix5}story ${text3(payload2.story) || "?"}'s \`touches:\` WIDENED by ${actor}` + ` (${basisOf(payload2)})` + ` — +${widenedPaths(payload2)}` + ` (${String(listCount(payload2, "before"))} → ${String(listCount(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":
@@ -53694,8 +53897,11 @@ function bullet2(item, trail) {
       return `${prefix5}map refreshed`;
     case "result.unreadable":
       return `${prefix5}UNREADABLE ${text3(payload2.path) || "result.json"}` + ` — ${text3(payload2.error) || "no parse error recorded"}` + " (nothing failed; rewrite it and run the same command again)";
-    case "error":
-      return `${prefix5}error: ${text3(payload2.message) || "no message recorded"}`;
+    case "error": {
+      const what = text3(payload2.detail) || text3(payload2.detail_omitted) || text3(payload2.message) || "no message recorded";
+      const rows = typeof payload2.rows_expected === "number" ? ` (${String(payload2.rows_written ?? "?")} of ${String(payload2.rows_expected)} task rows recorded)` : "";
+      return `${prefix5}error: ${what}${rows}`;
+    }
     default:
       return null;
   }
@@ -53753,8 +53959,12 @@ function pathList(value) {
   const items = value.filter((item) => typeof item === "string");
   return items.length === 0 ? "?" : items.join(", ");
 }
-function lengthOf(value) {
-  return Array.isArray(value) ? value.length : 0;
+function widenedPaths(payload2) {
+  const listed = pathList(payload2.paths);
+  const omitted = typeof payload2.paths_omitted === "number" && payload2.paths_omitted > 0 ? `${String(payload2.paths_omitted)} path(s) not listed on the event` : "";
+  if (omitted === "")
+    return listed;
+  return listed === "?" ? omitted : `${listed}, ${omitted}`;
 }
 function signature(actor, payload2) {
   const executed = payload2.executed_by;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tldr-experts",
-  "version": "0.25.0",
+  "version": "0.26.1",
   "description": "tldr-experts: an evidence-first, file-based AI development framework - five stages, a gate on every one, and every claim cited or refused. Installs the `tldrx` (and `tldr-experts`) command. Beta.",
   "license": "MIT",
   "author": "Alan Martinez",

package/plugin/.claude-plugin/plugin.json

@@ -2,7 +2,7 @@
   "$doc": "Shape verified from https://code.claude.com/docs/en/plugins.md (Quickstart > Create the plugin manifest). Fields used here: name, description, version, author.name. Only plugin.json goes inside .claude-plugin/; skills/, agents/ and hooks/ live at the plugin root.",
   "name": "tldrx",
   "description": "tldr-experts: an evidence-first, file-based AI development framework. Five stages, a gate on every one, every claim cited or refused. Beta.",
-  "version": "0.25.0",
+  "version": "0.26.1",
   "author": {
     "name": "Alan Martinez"
   }