tldr-experts 0.24.0 → 0.26.0

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");
 }
@@ -17140,6 +17150,7 @@ import { basename as basename4 } from "node:path";
 
 // src/core/run/RunStore.ts
 import { existsSync as existsSync12, readFileSync as readFileSync12 } from "node:fs";
+import { isDeepStrictEqual } from "node:util";
 import { basename as basename3, join as join14 } from "node:path";
 
 // src/hooks/lib/actor.ts
@@ -17160,11 +17171,14 @@ class RunStore {
   events;
   current;
   currentBudget;
+  loaded;
+  cancelledUnderFlag = false;
   budgetMutated = false;
   constructor(runDir, run, budget, events) {
     this.runDir = runDir;
     this.events = events;
     this.current = run;
+    this.loaded = run;
     this.currentBudget = budget;
   }
   static open(runDir) {
@@ -17249,6 +17263,20 @@ class RunStore {
   get runId() {
     return this.current.run;
   }
+  get cancelledUnder() {
+    return this.cancelledUnderFlag;
+  }
+  static cancelledOnDisk(runDir) {
+    const path = join14(runDir, "run.yml");
+    if (!existsSync12(path))
+      return false;
+    try {
+      const doc = parseYaml(readFileSync12(path, "utf8"));
+      return validateRunFile(doc).ok && asRunFile(doc).cancelled !== undefined;
+    } catch {
+      return false;
+    }
+  }
   cursorEntry() {
     return stageAt(this.current, this.current.cursor);
   }
@@ -17270,13 +17298,14 @@ class RunStore {
     this.events.append(event2);
   }
   save() {
-    const rolled = rollUp(this.current);
-    const runValidation = validateRunFile(rolled);
-    if (!runValidation.ok) {
-      const first = runValidation.issues[0];
-      throw new RunStoreError(`refusing to write an invalid run.yml: ${first?.path ?? ""} ${first?.message ?? ""}`);
-    }
-    withWorkspaceLock(workspaceRootOfRunDir(this.runDir), () => {
+    return withWorkspaceLock(workspaceRootOfRunDir(this.runDir), () => {
+      const base = this.runToWrite();
+      const rolled = rollUp(base.run);
+      const runValidation = validateRunFile(rolled);
+      if (!runValidation.ok) {
+        const first = runValidation.issues[0];
+        throw new RunStoreError(`refusing to write an invalid run.yml: ${first?.path ?? ""} ${first?.message ?? ""}`);
+      }
       const budget = rollUpBudget(this.ceilingsToWrite(), rolled);
       const budgetValidation = validateRunBudget(budget);
       if (!budgetValidation.ok) {
@@ -17284,12 +17313,56 @@ class RunStore {
         throw new RunStoreError(`refusing to write an invalid budget.yml: ${first?.path ?? ""} ${first?.message ?? ""}`);
       }
       writeAtomic(join14(this.runDir, "budget.yml"), emitBudgetYaml(budget));
-      writeAtomic(join14(this.runDir, "run.yml"), emitRunYaml(rolled));
+      const runPath = join14(this.runDir, "run.yml");
+      writeAtomic(runPath, emitRunYaml(rolled));
       this.current = rolled;
+      this.loaded = rolled;
       this.currentBudget = budget;
       this.budgetMutated = false;
+      if (base.fallback !== null) {
+        process.stderr.write(`tldrx: ${runPath} ${base.fallback}, so it could not be merged with: this process's copy of ` + `the run was written whole, and the version that was on disk is beside it as ${backupPathFor(runPath)}. ` + "A change another command wrote there since this process read the run (a budget raise, a " + `cancel, a rejection) may be in that backup and not in run.yml.
+`);
+      }
+      if (base.cancelledUnder) {
+        this.cancelledUnderFlag = true;
+        const who = rolled.cancelled;
+        process.stderr.write(`tldrx: run ${rolled.run} was cancelled` + (who === undefined ? "" : ` by ${who.by} at ${who.at} (${who.note})`) + " while this process held it: the cancel's statuses were kept, this process's task rows were " + `recorded beside them, and nothing more may be spawned for it.
+`);
+      }
+      return { cancelledUnder: base.cancelledUnder };
     });
   }
+  runToWrite() {
+    const path = join14(this.runDir, "run.yml");
+    if (!existsSync12(path))
+      return { run: this.current, fallback: null, cancelledUnder: false };
+    let doc;
+    try {
+      doc = parseYaml(readFileSync12(path, "utf8"));
+    } catch (error) {
+      const detail = error instanceof Error ? error.message : String(error);
+      return { run: this.current, fallback: `could not be read or parsed (${detail})`, cancelledUnder: false };
+    }
+    const validation = validateRunFile(doc);
+    if (!validation.ok) {
+      const first = validation.issues[0];
+      return {
+        run: this.current,
+        fallback: `does not validate (${first?.path ?? ""} ${first?.message ?? "schema error"})`,
+        cancelledUnder: false
+      };
+    }
+    const onDisk = asRunFile(doc);
+    if (onDisk.run !== this.current.run) {
+      throw new RunStoreError(`refusing to write ${path}: it records run ${onDisk.run}, and this store holds run ` + `${this.current.run} — a save never overwrites another run's record`);
+    }
+    const cancelledUnder = onDisk.cancelled !== undefined && this.loaded.cancelled === undefined && this.current.cancelled === undefined;
+    return {
+      run: carryChanges(onDisk, this.current, this.loaded, { cancelledWins: this.cancelledUnderFlag || cancelledUnder }),
+      fallback: null,
+      cancelledUnder
+    };
+  }
   ceilingsToWrite() {
     if (this.budgetMutated)
       return this.currentBudget;
@@ -17337,6 +17410,41 @@ function parseStateFile(path) {
 `));
   }
 }
+function carryChanges(onDisk, mine, loaded, rules = { cancelledWins: false }) {
+  const top = carryLevel(onDisk, mine, loaded, rules.cancelledWins ? ["phases", "cursor"] : ["phases"]);
+  const phases = mine.phases.map((phase) => {
+    const theirs = onDisk.phases.find((p) => p.id === phase.id);
+    const was = loaded.phases.find((p) => p.id === phase.id);
+    if (theirs === undefined || was === undefined)
+      return phase;
+    const stages = phase.stages.map((stage2) => {
+      const theirStage = theirs.stages.find((s) => s.id === stage2.id);
+      const wasStage = was.stages.find((s) => s.id === stage2.id);
+      if (theirStage === undefined || wasStage === undefined)
+        return stage2;
+      const kept = rules.cancelledWins && theirStage.status === "cancelled" ? ["status", "started_at", "ended_at"] : [];
+      return carryLevel(theirStage, stage2, wasStage, kept);
+    });
+    return { ...carryLevel(theirs, phase, was, ["stages"]), stages };
+  });
+  return { ...top, phases };
+}
+function carryLevel(onDisk, mine, loaded, skip) {
+  const out = { ...onDisk };
+  const theirs = mine;
+  const was = loaded;
+  for (const key of new Set([...Object.keys(theirs), ...Object.keys(was)])) {
+    if (skip.includes(key))
+      continue;
+    if (isDeepStrictEqual(theirs[key], was[key]))
+      continue;
+    if (theirs[key] === undefined)
+      delete out[key];
+    else
+      out[key] = theirs[key];
+  }
+  return out;
+}
 function rollUp(run) {
   const phases = run.phases.map((phase) => {
     const stages = phase.stages.map((stage2) => ({
@@ -25206,6 +25314,8 @@ function renderStagePreamble(preamble) {
 var QUESTIONS_FILE2 = "questions.md";
 var INPUTS_HEADING = "Inputs";
 var PREVIOUS_ATTEMPT_HEADING = "Previous attempt";
+var PREVIOUS_ATTEMPT_EDIT_HEADING = "Previous attempt — edit, do not restart";
+var MAX_PREVIOUS_ATTEMPT_BYTES = 32 * 1024;
 function buildPrompt(parts) {
   return renderParts(parts).map((part) => part.text).join("");
 }
@@ -29938,8 +30048,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;
@@ -34508,94 +34619,6 @@ function quoted(values) {
 // src/core/watch/watchPrompt.ts
 import { existsSync as existsSync66, readFileSync as readFileSync60 } from "node:fs";
 import { join as join80 } from "node:path";
-var WATCH_FACT_AREAS = ["observability", "deploy", "ownership"];
-function featureInputs(options) {
-  const inputs = [];
-  for (const story of options.feature.stories) {
-    inputs.push({ path: story.path, content: story.text });
-  }
-  const epicPath = `${PLAN_PHASE2}/${EPICS_DIR}/${options.feature.epicId}.md`;
-  const epicAbs = join80(options.runDir, epicPath);
-  if (existsSync66(epicAbs))
-    inputs.push({ path: epicPath, content: readFileSync60(epicAbs, "utf8") });
-  inputs.push({ path: `(git) ${options.feature.epicId} branch vs default branch`, content: renderDiffs(options.diffs) });
-  inputs.push({ path: `(facts) area: ${WATCH_FACT_AREAS.join(", ")}`, content: renderWatchFacts(options.facts, options.feature.repos) });
-  for (const repo of options.feature.repos) {
-    const rel = `${PROJECT_FRAMEWORK_DIR}/map/${repo}/gotchas.md`;
-    const abs = join80(options.root, rel);
-    if (existsSync66(abs))
-      inputs.push({ path: rel, content: readFileSync60(abs, "utf8") });
-  }
-  return inputs.slice(0, MAX_STAGE_INPUTS);
-}
-function renderWatchFacts(facts, repos) {
-  const areas = new Set(WATCH_FACT_AREAS);
-  const relevant = facts.filter((fact) => isLive(fact) && areas.has(fact.area) && (fact.repos.length === 0 || fact.repos.some((r) => repos.includes(r))));
-  if (relevant.length === 0) {
-    return `_No live fact is tagged ${WATCH_FACT_AREAS.join(" or ")} for these repos. ` + "Cite `absent:.tldrx/memory/facts.yml` rather than inventing where a signal is read._";
-  }
-  return relevant.map((fact) => `- [${fact.id}] ${fact.fact} (${fact.area} · ${fact.confidence})`).join(`
-`);
-}
-function watcherRelPath(featureId2) {
-  return `${WATCH_PHASE}/${WATCHERS_DIR}/${featureId2}.md`;
-}
-function featureBrief(feature) {
-  const path = watcherRelPath(feature.id);
-  const stories = feature.stories.map((s) => s.story.id);
-  return [
-    `Write exactly ONE file: \`${path}\`. Do not write, edit or delete anything else.`,
-    "",
-    "Its YAML front matter is fixed — copy it verbatim:",
-    "",
-    "```yaml",
-    "---",
-    "version: 1",
-    `id: ${feature.id}`,
-    `epic: ${feature.epicId}`,
-    `title: ${JSON.stringify(feature.title)}`,
-    `stories: [${stories.join(", ")}]`,
-    `repos: [${feature.repos.join(", ")}]`,
-    "status: draft",
-    "---",
-    "```",
-    "",
-    `Then these H2 sections, in this order: ${WATCHER_SECTIONS.map((s) => `\`## ${s}\``).join(" · ")}.`,
-    "",
-    "- Every list item under **Signal**, **Where**, **Healthy baseline** and **Looks broken when**",
-    "  ends with a `[src: …]` token: `<repo>:<path>:<line>` for a line in the built code, `F<n>` for",
-    "  a recorded fact, or `absent:<what you looked at>` when the code emits nothing.",
-    "- **Signal** names the log line, metric or event that is IN the diff above, at the line it is on.",
-    "  If nothing is emitted, say so with an `absent:` source and say what to instrument. Do not",
-    "  describe a signal that would be nice to have as though it exists.",
-    "- **Query** is one fenced block, copy-pasteable in whatever place **Where** names.",
-    "  If — and ONLY if — the code emits nothing at all, so there is no place to paste a query into,",
-    "  write ONE line instead of the block, sourced like every other claim on the card:",
-    "",
-    "      Query: none — <why nothing is queryable> [src: absent:<what you looked at>]",
-    "",
-    "  This is CHECKED, not trusted: it is refused unless **Signal** above cites `absent:` and the",
-    "  reason's own source is `absent:` too. A card that names a real signal has somewhere to point a",
-    "  query at, so `none` on one is a shortcut and will fail the stage. An unsourced `none` is refused",
-    "  exactly like an unsourced bullet, and describing a query in prose is still refused either way.",
-    "- **Sources** is prose: each citation above, once, with what it establishes.",
-    "",
-    "Owner (optional, gh #70). A Signal item may name WHO to ask about it, as `(owner: <name>)`",
-    "placed BEFORE its `[src: …]` token — the token is still the last thing on the line:",
-    "",
-    "    - `checkout.completed` is written on every order (owner: alice) [src: api:src/Checkout.cs:88]",
-    "",
-    "Write it ONLY from an `ownership` fact inlined above, and write the SAME name that fact uses.",
-    "Put it in the front matter as `owner: <name>` when one name covers every item on the card, or on",
-    "the individual items when they differ. Do not invent a name, do not put a repo name there (the",
-    "framework already derives that from your citation), and leave it off entirely when no fact says.",
-    "An `(owner: )` with nothing in it is refused — it loses the name it was trying to write.",
-    "",
-    "Leave `status: draft`. The framework sets it: a card is stamped `verified` only when nothing",
-    "under **Signal** cites `absent:`. Writing `verified` yourself changes nothing and will be overwritten."
-  ].join(`
-`);
-}
 
 // src/core/watch/itemOwner.ts
 var MAX_OWNER_CHARS = 64;
@@ -34632,7 +34655,8 @@ function itemOwner(text3) {
 }
 
 // src/core/watch/watcherFile.ts
-var NO_SRC_TOKEN_ISSUE = "no `[src: …]` token — every item on a card is sourced";
+var NON_FILE_SOURCE_CURE = "a table, queue, dashboard or console is not a line of code, so cite the file that defines it " + "(the migration, model or config, as `<repo>:<path>:<line>`) or the `F<n>` fact that names it";
+var NO_SRC_TOKEN_ISSUE = `no \`[src: …]\` token — every item on a card is sourced; ${NON_FILE_SOURCE_CURE}`;
 var QUERY_NONE_NOT_EARNED_ISSUE = "`Query: none` is only for a card whose `## Signal` is itself `absent:` — this one names a real signal";
 var QUERY_NOT_PASTEABLE_ISSUE = "`## Query` holds no fenced block — the query has to be copy-pasteable, not described";
 var SRC_SECTION2 = "Evidence ledger";
@@ -34820,12 +34844,147 @@ function setWatcherStatus(text3, status) {
   }
   return text3;
 }
+function describeWatcherIssue(issue) {
+  return `L${String(issue.line)}${issue.path === "" ? "" : ` ${issue.path}`}: ${issue.message}`;
+}
 function describeWatcherIssues(issues, max = 5) {
-  const shown = issues.slice(0, max).map((issue) => `  L${String(issue.line)}${issue.path === "" ? "" : ` ${issue.path}`}: ${issue.message}`);
+  const shown = issues.slice(0, max).map((issue) => `  ${describeWatcherIssue(issue)}`);
   const rest = issues.length - shown.length;
   return rest > 0 ? [...shown, `  (+${String(rest)} more)`] : shown;
 }
 
+// src/core/watch/watchPrompt.ts
+var WATCH_FACT_AREAS = ["observability", "deploy", "ownership"];
+function featureInputs(options) {
+  const inputs = [];
+  for (const story of options.feature.stories) {
+    inputs.push({ path: story.path, content: story.text });
+  }
+  const epicPath = `${PLAN_PHASE2}/${EPICS_DIR}/${options.feature.epicId}.md`;
+  const epicAbs = join80(options.runDir, epicPath);
+  if (existsSync66(epicAbs))
+    inputs.push({ path: epicPath, content: readFileSync60(epicAbs, "utf8") });
+  inputs.push({ path: `(git) ${options.feature.epicId} branch vs default branch`, content: renderDiffs(options.diffs) });
+  inputs.push({ path: `(facts) area: ${WATCH_FACT_AREAS.join(", ")}`, content: renderWatchFacts(options.facts, options.feature.repos) });
+  for (const repo of options.feature.repos) {
+    const rel = `${PROJECT_FRAMEWORK_DIR}/map/${repo}/gotchas.md`;
+    const abs = join80(options.root, rel);
+    if (existsSync66(abs))
+      inputs.push({ path: rel, content: readFileSync60(abs, "utf8") });
+  }
+  return inputs.slice(0, MAX_STAGE_INPUTS);
+}
+function renderWatchFacts(facts, repos) {
+  const areas = new Set(WATCH_FACT_AREAS);
+  const relevant = facts.filter((fact) => isLive(fact) && areas.has(fact.area) && (fact.repos.length === 0 || fact.repos.some((r) => repos.includes(r))));
+  if (relevant.length === 0) {
+    return `_No live fact is tagged ${WATCH_FACT_AREAS.join(" or ")} for these repos. ` + "Cite `absent:.tldrx/memory/facts.yml` rather than inventing where a signal is read._";
+  }
+  return relevant.map((fact) => `- [${fact.id}] ${fact.fact} (${fact.area} · ${fact.confidence})`).join(`
+`);
+}
+function watcherRelPath(featureId2) {
+  return `${WATCH_PHASE}/${WATCHERS_DIR}/${featureId2}.md`;
+}
+function featureBrief(feature) {
+  const path = watcherRelPath(feature.id);
+  const stories = feature.stories.map((s) => s.story.id);
+  return [
+    `Write exactly ONE file: \`${path}\`. Do not write, edit or delete anything else.`,
+    "",
+    "Its YAML front matter is fixed — copy it verbatim:",
+    "",
+    "```yaml",
+    "---",
+    "version: 1",
+    `id: ${feature.id}`,
+    `epic: ${feature.epicId}`,
+    `title: ${JSON.stringify(feature.title)}`,
+    `stories: [${stories.join(", ")}]`,
+    `repos: [${feature.repos.join(", ")}]`,
+    "status: draft",
+    "---",
+    "```",
+    "",
+    `Then these H2 sections, in this order: ${WATCHER_SECTIONS.map((s) => `\`## ${s}\``).join(" · ")}.`,
+    "",
+    "- Every list item under **Signal**, **Where**, **Healthy baseline** and **Looks broken when**",
+    "  ends with a `[src: …]` token: `<repo>:<path>:<line>` for a line in the built code, `F<n>` for",
+    "  a recorded fact, or `absent:<what you looked at>` when the code emits nothing.",
+    `- **Where** names a PLACE, and a place is cited like a line: ${NON_FILE_SOURCE_CURE}.`,
+    "  An item with no token at all is refused, however obvious the place. One example, for a table",
+    "  that no fact and no dashboard names yet:",
+    "",
+    "      - PostgreSQL `leaderboard_refreshes` table, read with `psql` [src: api:db/migrations/0007_leaderboard_refreshes.sql:1]",
+    "",
+    "- **Signal** names the log line, metric or event that is IN the diff above, at the line it is on.",
+    "  If nothing is emitted, say so with an `absent:` source and say what to instrument. Do not",
+    "  describe a signal that would be nice to have as though it exists.",
+    "- **Query** is one fenced block, copy-pasteable in whatever place **Where** names.",
+    "  If — and ONLY if — the code emits nothing at all, so there is no place to paste a query into,",
+    "  write ONE line instead of the block, sourced like every other claim on the card:",
+    "",
+    "      Query: none — <why nothing is queryable> [src: absent:<what you looked at>]",
+    "",
+    "  This is CHECKED, not trusted: it is refused unless **Signal** above cites `absent:` and the",
+    "  reason's own source is `absent:` too. A card that names a real signal has somewhere to point a",
+    "  query at, so `none` on one is a shortcut and will fail the stage. An unsourced `none` is refused",
+    "  exactly like an unsourced bullet, and describing a query in prose is still refused either way.",
+    "- **Sources** is prose: each citation above, once, with what it establishes.",
+    "",
+    "Owner (optional, gh #70). A Signal item may name WHO to ask about it, as `(owner: <name>)`",
+    "placed BEFORE its `[src: …]` token — the token is still the last thing on the line:",
+    "",
+    "    - `checkout.completed` is written on every order (owner: alice) [src: api:src/Checkout.cs:88]",
+    "",
+    "Write it ONLY from an `ownership` fact inlined above, and write the SAME name that fact uses.",
+    "Put it in the front matter as `owner: <name>` when one name covers every item on the card, or on",
+    "the individual items when they differ. Do not invent a name, do not put a repo name there (the",
+    "framework already derives that from your citation), and leave it off entirely when no fact says.",
+    "An `(owner: )` with nothing in it is refused — it loses the name it was trying to write.",
+    "",
+    "Leave `status: draft`. The framework sets it: a card is stamped `verified` only when nothing",
+    "under **Signal** cites `absent:`. Writing `verified` yourself changes nothing and will be overwritten."
+  ].join(`
+`);
+}
+function previousCard(options) {
+  const rel = watcherRelPath(options.feature.id);
+  const abs = join80(options.runDir, rel);
+  if (!existsSync66(abs))
+    return "";
+  const text3 = readFileSync60(abs, "utf8");
+  if (text3.trim() === "")
+    return "";
+  const card = parseWatcherCard(text3, options.ctx, options.feature.id);
+  const lines = text3.split(`
+`);
+  const out = [];
+  if (card.ok) {
+    out.push(`The previous attempt at this stage wrote \`${rel}\` and it validates. The stage is being run`, "again for another reason; keep this card as it is unless the evidence above contradicts it.");
+  } else {
+    out.push(`The previous attempt at this stage wrote \`${rel}\` and it was REFUSED — ` + `${String(card.issues.length)} line(s) do not validate. Each one, with the line as written:`, "");
+    for (const issue of card.issues) {
+      out.push(`- ${describeWatcherIssue(issue)}`);
+      const quoted2 = issue.line > 0 ? lines[issue.line - 1] : undefined;
+      if (quoted2 !== undefined && quoted2.trim() !== "")
+        out.push(`  > ${quoted2}`);
+    }
+    out.push("", "Fix what is described above. Everything else in this prompt still applies.");
+  }
+  out.push("", `### ${PREVIOUS_ATTEMPT_EDIT_HEADING}`, "", "This card is on disk RIGHT NOW, exactly as the last attempt left it. It is the draft you are", "being paid to fix, not history: keep every item that already carries a `[src: …]` token, cure", "the lines marked above, and write the file back at the same path. Starting from a blank page", "throws away paid-for work — and, measured, moves a refusal to a different line instead of", "curing it.", "");
+  const budget = options.maxBytes ?? MAX_PREVIOUS_ATTEMPT_BYTES;
+  const size = Buffer.byteLength(text3, "utf8");
+  if (size > budget) {
+    out.push(`_Not inlined (past the ${budget.toLocaleString("en-US")}-byte previous-attempt budget): ` + `${rel} (${size.toLocaleString("en-US")} B). It is on disk; read it before you rewrite it._`);
+  } else {
+    const fence = fenceFor(text3);
+    out.push(`#### \`${rel}\``, "", fence, text3.replace(/\n$/, ""), fence);
+  }
+  return out.join(`
+`);
+}
+
 // src/core/watch/renderWatchHandoff.ts
 var NO_STORIES_SRC = `absent:${PLAN_PHASE2}/stories`;
 function renderWatchHandoff(cards, ctx) {
@@ -35050,6 +35209,7 @@ async function watchExecutor(ctx) {
       refused: true
     };
   }
+  const srcCtx = toSrcContext(loadWorkspace(ctx.root), ctx.runDir, { epicRefs: true });
   let prompts = [];
   if (ctx.mode !== "commit") {
     const build = recordedBuild(ctx.runDir);
@@ -35068,7 +35228,7 @@ async function watchExecutor(ctx) {
         signature: incoherent.signature
       };
     }
-    prompts = features.map((feature, i) => featurePrompt(ctx, feature, diffs[i] ?? []));
+    prompts = features.map((feature, i) => featurePrompt(ctx, feature, diffs[i] ?? [], srcCtx));
   }
   if (ctx.mode === "prepare")
     return prepare2(ctx, features, prompts);
@@ -35109,7 +35269,6 @@ async function watchExecutor(ctx) {
       }
     }
   }
-  const srcCtx = toSrcContext(loadWorkspace(ctx.root), ctx.runDir, { epicRefs: true });
   const written = [];
   for (const feature of features) {
     const rel = watcherRelPath(feature.id);
@@ -35196,7 +35355,7 @@ function collectResults(ctx, features) {
   }
   return { tasks, error: null };
 }
-function featurePrompt(ctx, feature, diffs) {
+function featurePrompt(ctx, feature, diffs, srcCtx) {
   const facts = FactsStore.loadOrEmpty(factsPath(ctx.root)).facts;
   const stageMd = applyCheckContracts(readFileSync62(stageMdPath(ctx.spec.planned.id, ctx.spec.planned.source), "utf8"), {
     checks: ctx.spec.planned.checks.map((check) => check.id),
@@ -35227,7 +35386,8 @@ function featurePrompt(ctx, feature, diffs) {
       budget_usd: agentShare(ctx, 1).toFixed(2)
     },
     experts: bundles.experts,
-    inputs: featureInputs({ root: ctx.root, runDir: ctx.runDir, feature, diffs, facts })
+    inputs: featureInputs({ root: ctx.root, runDir: ctx.runDir, feature, diffs, facts }),
+    previousAttempt: previousCard({ runDir: ctx.runDir, feature, ctx: srcCtx })
   });
   return replaceSection(body, "Feature", featureBrief(feature));
 }
@@ -35649,6 +35809,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") : [];
 }
@@ -35673,8 +35838,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
     });
@@ -38436,6 +38602,27 @@ function dependencyHoldOfLog(log) {
   const body = (end === -1 ? rest : rest.slice(0, end)).map((line) => line.trim()).filter((line) => line !== "");
   return body.length === 1 && body[0] !== undefined ? dependencyNamedByHold(body[0]) : null;
 }
+function dependencyHoldCure(held2) {
+  if (dependencyIsPending(held2.status)) {
+    return `${held2.id} \`done\` is what releases it — it is offered again by the next \`tldrx next --prepare\``;
+  }
+  return held2.status === "blocked" ? `${held2.id} will not land in this run as it stands — \`tldrx story reopen ${held2.id} --note "…"\` gives it its turn` : `${held2.id} is \`todo\` after its wave ran, so its developer never delivered — \`tldrx next --prepare\` offers ${held2.id} first`;
+}
+function dependencyPrepareRefusal(storyId, held2) {
+  if (dependencyIsPending(held2.status)) {
+    return `nothing to prepare yet: ${storyId} waits on dependency ${held2.id}, which is \`${held2.status}\`, ` + `not \`done\` — ${storyId} is left \`todo\`, not \`blocked\`; ${dependencyHoldCure(held2)}`;
+  }
+  return `nothing to review: ${dependencyHoldReason(held2)}, so ${storyId} has no developer turn to review and ` + `none is owed — \`tldrx next --prepare\` records ${storyId} \`blocked\` with that reason; ${dependencyHoldCure(held2)}`;
+}
+function dependencyCommitRefusal(storyId, held2, work) {
+  return `${storyId} is not settled: ${dependencyHoldReason(held2)}, and a story does not land over a dependency ` + `that has not. Nothing is lost — the bundle stays at ${work.bundleDir}, the work stays on \`${work.branch}\` ` + `in ${work.worktree}, and ${storyId} stays \`in_progress\`; ${dependencyHoldCure(held2)}, ` + `then \`tldrx next --commit\` settles ${storyId}`;
+}
+function dependencyNextLine(storyId, held2) {
+  if (dependencyIsPending(held2.status)) {
+    return `nothing is next yet — ${storyId} waits on dependency ${held2.id}, which is \`${held2.status}\`, ` + `not \`done\`; ${dependencyHoldCure(held2)}`;
+  }
+  return `nothing is next — ${dependencyHoldReason(held2)}, so \`tldrx next --prepare\` records ${storyId} ` + `\`blocked\` with that reason and closes the stage at its gate; ${dependencyHoldCure(held2)}`;
+}
 
 // src/core/facilitator/reviewerModel.ts
 function resolveReviewer(layers) {
@@ -38660,6 +38847,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;
@@ -38708,6 +38898,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,
@@ -38719,6 +38942,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);
@@ -38836,7 +39067,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.";
 }
@@ -38865,7 +39096,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)}`);
@@ -38934,6 +39165,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)
@@ -39117,7 +39349,7 @@ async function buildExecutor(ctx) {
     try {
       await session.restoreForeignWorkAside();
     } catch {}
-    throw error;
+    throw withPartialTasks(error, session.tasks);
   }
 }
 function refusedOnBase(session, error) {
@@ -39302,12 +39534,18 @@ class BuildSession {
     return await this.finish();
   }
   async prepare() {
-    const planned = this.nextPending();
+    let planned = this.nextPending();
     if (planned === null)
       return await this.finish();
     const refusal = await this.refuseOnDirtyRepos() ?? await this.refuseOnForeignEpic() ?? await this.setAsideForeign() ?? await this.refuseOnRedBase() ?? await this.refuseOnUnrunnableWorktree();
     if (refusal !== null)
       return refusal;
+    const offered = this.offerAtFrontier();
+    if (offered.kind === "wait")
+      return refusedOnSequence(this.ctx, dependencyPrepareRefusal(offered.story, offered.held));
+    if (offered.kind === "none")
+      return await this.finish();
+    planned = offered.planned;
     const review = this.reviewWorkFor(planned);
     if (review !== null)
       return await this.prepareReview(planned, review);
@@ -39399,6 +39637,9 @@ class BuildSession {
     const refusal = await this.refuseOnDirtyRepos() ?? await this.refuseOnForeignEpic() ?? await this.setAsideForeign();
     if (refusal !== null)
       return refusal;
+    const held2 = this.blockingDependency(planned);
+    if (held2 !== null)
+      return refusedOnSequence(this.ctx, dependencyPrepareRefusal(planned.story.id, held2));
     const work = this.reviewWorkFor(planned) ?? this.reviewWorkFromLedger(planned);
     if (work === null) {
       return refusedOnSequence(this.ctx, `${planned.story.id} has no merged commit to review — a story is reviewed after its developer turn, ` + "not instead of one. Run `tldrx next --prepare` for the developer half first.");
@@ -39493,7 +39734,7 @@ class BuildSession {
       lines: [
         ...this.lines,
         `${planned.story.id} → \`${outcome?.status ?? "?"}\` (host review, unmetered)`,
-        `${this.nextPending()?.story.id ?? "?"} is next — run \`tldrx next --prepare\``
+        this.nextAtFrontier()
       ],
       stderr: [...this.advisories],
       error: null
@@ -39505,6 +39746,14 @@ class BuildSession {
     if (planned === null) {
       return refusedOnSequence(this.ctx, "no story is `in_progress` — run `tldrx next --prepare` first");
     }
+    const held2 = this.blockingDependency(planned);
+    if (held2 !== null) {
+      return refusedOnSequence(this.ctx, dependencyCommitRefusal(planned.story.id, held2, {
+        bundleDir: relative16(this.ctx.root, agentDir(this.ctx.runDir, this.bundleKey(planned.story.id))),
+        branch: storyBranchOf(this.ctx.runId, planned.story.id),
+        worktree: relative16(this.ctx.root, this.storyWorktree(planned))
+      }));
+    }
     const key = this.bundleKey(planned.story.id);
     let result2;
     try {
@@ -39553,11 +39802,14 @@ class BuildSession {
       lines: [
         ...this.lines,
         `${planned.story.id} → \`${outcome?.status ?? "?"}\``,
-        `${this.nextPending()?.story.id ?? "?"} is next — run \`tldrx next --prepare\``
+        this.nextAtFrontier()
       ],
       error: null
     };
   }
+  cancelledUnder() {
+    return RunStore.cancelledOnDisk(this.ctx.runDir);
+  }
   async driveStory(planned) {
     const resume = this.resumableReview(planned);
     if (resume !== null) {
@@ -39565,6 +39817,10 @@ class BuildSession {
       return;
     }
     for (let i = 0;i < this.attempts; i++) {
+      if (this.cancelledUnder()) {
+        this.lines.push(`  · ${planned.story.id}: ${i === 0 ? "not started" : "not requeued"} — the run was cancelled ` + "(tldrx run cancel) while this stage held it");
+        return;
+      }
       await this.settleHalf(await this.buildHalf(planned));
       const outcome = this.outcomes.get(planned.story.id);
       if (outcome !== undefined && outcome.developerError !== null)
@@ -39614,6 +39870,10 @@ class BuildSession {
         const planned = queue[cursor++];
         if (planned === undefined)
           return;
+        if (this.cancelledUnder()) {
+          this.lines.push(`  · ${planned.story.id}: not started — the run was cancelled (tldrx run cancel) while this stage held it`);
+          return;
+        }
         halves.set(planned.story.id, await this.buildHalf(planned));
       }
     };
@@ -39940,6 +40200,29 @@ class BuildSession {
       });
       return "settled";
     }
+    if (supplied === undefined && this.cancelledUnder()) {
+      const review2 = reviewerUnfunded("the run was cancelled (tldrx run cancel) before the review — the diff is merged on the epic " + "branch and nobody has judged it");
+      this.ctx.emit("check.failed", {
+        phase: this.ctx.phaseId,
+        check: "review",
+        story: story.planned.story.id,
+        verdict: review2.verdict,
+        attempt: story.attempt,
+        detail: review2.summary
+      });
+      await this.settle(story, "review", {
+        dod,
+        commit: commit2,
+        merged: true,
+        carried,
+        epicBase,
+        verdict: "n-a",
+        review: review2,
+        cost: round23(priorCost),
+        reason: review2.summary
+      });
+      return "settled";
+    }
     const outcome = supplied === undefined ? await this.spawnReviewer(story, dod, epicBase) : { review: supplied, cost: 0 };
     const review = outcome.review;
     const cost = round23(priorCost + outcome.cost);
@@ -40187,6 +40470,41 @@ class BuildSession {
     }
     return decidingHold(holds);
   }
+  offerAtFrontier() {
+    const walked = this.walkFrontier(true);
+    if (walked.kind === "held" && !walked.recorded)
+      return { kind: "wait", story: walked.story, held: walked.held };
+    if (walked.kind === "held")
+      return { kind: "none" };
+    return walked;
+  }
+  nextAtFrontier() {
+    const walked = this.walkFrontier(false);
+    if (walked.kind === "offer")
+      return `${walked.planned.story.id} is next — run \`tldrx next --prepare\``;
+    if (walked.kind === "held")
+      return dependencyNextLine(walked.story, walked.held);
+    return "nothing is next — run `tldrx next --prepare` to close the stage at its gate";
+  }
+  walkFrontier(record3) {
+    let recorded = false;
+    let first2 = null;
+    for (const planned of this.pendingStories()) {
+      const held2 = this.blockingDependency(planned);
+      if (held2 === null)
+        return { kind: "offer", planned };
+      first2 ??= { story: planned.story.id, held: held2 };
+      if (dependencyIsPending(held2.status)) {
+        if (record3)
+          this.waitOnDependency(planned, held2);
+        continue;
+      }
+      if (record3)
+        this.blockOnDependency(planned, held2);
+      recorded = true;
+    }
+    return first2 === null ? { kind: "none" } : { kind: "held", ...first2, recorded };
+  }
   waitOnDependency(planned, held2) {
     this.waits.set(planned.story.id, held2);
     this.lines.push(dependencyWaitLine(planned.story.id, held2));
@@ -40917,14 +41235,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 = [];
@@ -41535,6 +41872,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]
@@ -42279,14 +42630,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) {
@@ -42296,22 +42666,34 @@ 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) {
+    return out(EXIT_OK4, [
+      ...notes,
+      ...outcome.lines,
+      `run ${store.runId} was cancelled while ${phaseId}/${stageId} ran — stopped here: ` + `${String(outcome.tasks.length)} task row(s) from this invocation are recorded, and nothing more is spawned`
+    ], outcome.stderr ?? []);
+  }
   if (outcome.refused === true) {
     setStatus(store, phaseId, stageId, "ready");
     store.save();
@@ -42332,11 +42714,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",
@@ -42355,6 +42748,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,
@@ -42369,6 +42765,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) {
@@ -42790,7 +43187,6 @@ function assemblePrompt(store, options, spec, stage2, inputs, ctx, seed) {
     dispatchNotes
   };
 }
-var MAX_PREVIOUS_ATTEMPT_BYTES = 32 * 1024;
 function describePreviousAttempt(stage2, options) {
   const lines = [];
   const failure = [...stage2.tasks].reverse().find((task2) => task2.error !== null)?.error ?? null;
@@ -42833,7 +43229,7 @@ function priorOutputs(options) {
     return [];
   const out = [
     "",
-    "### Previous attempt — edit, do not restart",
+    `### ${PREVIOUS_ATTEMPT_EDIT_HEADING}`,
     "",
     "These files are on disk RIGHT NOW, exactly as the last attempt left them. They are",
     "not a suggestion and they are not history: they are the draft you are being paid to",
@@ -53250,6 +53646,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 = [
@@ -53377,9 +53775,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":
@@ -53395,7 +53793,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":
@@ -53432,8 +53830,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;
   }
@@ -53491,8 +53892,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;