tldr-experts 0.14.2 → 0.14.3

package/dist/tldrx.js

@@ -7285,6 +7285,8 @@ var EVENT_TYPES = [
   "story.review_retried",
   "story.work_rescued",
   "story.touches_widened",
+  "worktree.foreign_work_aside",
+  "worktree.foreign_work_restored",
   "result.unreadable",
   "operator_note",
   "check.passed",
@@ -24219,65 +24221,9 @@ function effortFlag(args, name = "effort") {
 }
 
 // src/core/facilitator/runAuto.ts
+import { readFileSync as readFileSync70 } from "node:fs";
 import { join as join93 } from "node:path";
 
-// src/core/budget/wouldExceed.ts
-function totalSpent(budget) {
-  return budget.phases.reduce((sum, p) => sum + p.spent_usd, 0);
-}
-function remaining(budget, phaseId) {
-  if (phaseId !== undefined) {
-    const phase = budget.phases.find((p) => p.id === phaseId);
-    if (phase !== undefined)
-      return round5(phase.ceiling_usd - phase.spent_usd);
-  }
-  return round5(budget.ceiling_usd - totalSpent(budget));
-}
-function wouldExceed(budget, phaseId, estimate) {
-  const phase = phaseId === null ? undefined : budget.phases.find((p) => p.id === phaseId);
-  const scope = phase === undefined ? "run" : "phase";
-  const ceiling = phase === undefined ? budget.ceiling_usd : phase.ceiling_usd;
-  const spent = phase === undefined ? totalSpent(budget) : phase.spent_usd;
-  const left = round5(ceiling - spent);
-  const exceeds = round5(spent + estimate) > ceiling;
-  const pct = ceiling === 0 ? 100 : (spent + estimate) / ceiling * 100;
-  return {
-    exceeds,
-    blocked: exceeds && budget.on_exceed === "block",
-    scope,
-    phaseId: phase === undefined ? null : phase.id,
-    remaining: left,
-    ceiling,
-    estimate,
-    warns: !exceeds && pct >= budget.warn_at_pct
-  };
-}
-function round5(n) {
-  return Math.round(n * 1e6) / 1e6;
-}
-function wouldExceedHostTokens(budget, phaseId, spentTokens) {
-  const ceiling = hostTokenCeiling(budget, phaseId);
-  if (ceiling === null)
-    return null;
-  const phase = phaseId === null ? undefined : budget.phases.find((p) => p.id === phaseId);
-  const over = ceiling > 0 && spentTokens > ceiling;
-  return {
-    over,
-    blocked: over && budget.on_host_tokens_exceed === "block",
-    scope: phase === undefined ? "run" : "phase",
-    spent: spentTokens,
-    ceiling
-  };
-}
-
-// src/core/budget/remainingWork.ts
-import { existsSync as existsSync39, readFileSync as readFileSync35 } from "node:fs";
-import { join as join58 } from "node:path";
-
-// src/core/run/buildProgress.ts
-import { existsSync as existsSync37, readFileSync as readFileSync33 } from "node:fs";
-import { join as join56 } from "node:path";
-
 // src/core/build/implicitPlan.ts
 import { existsSync as existsSync36, mkdirSync as mkdirSync10, readFileSync as readFileSync32, readdirSync as readdirSync18, rmSync as rmSync7, statSync as statSync15, writeFileSync as writeFileSync9 } from "node:fs";
 import { join as join55 } from "node:path";
@@ -24918,13 +24864,125 @@ function repoDirOf(workspace, name) {
     throw new GitError(`repo \`${name}\` resolves to ${resolved}, which does not exist`);
   return resolved;
 }
-async function dirtyPaths(cwd) {
-  const result2 = await git(["status", "--porcelain"], cwd);
+async function dirtyEntries(cwd) {
+  const result2 = await git(["status", "--porcelain", "-z"], cwd);
   if (!result2.ok)
     throw new GitError(`\`git status\` failed in ${cwd}: ${firstLine7(result2.stderr)}`);
+  const fields = result2.stdout.split("\x00");
+  const out = [];
+  for (let i = 0;i < fields.length; i += 1) {
+    const record2 = fields[i] ?? "";
+    if (record2 === "")
+      continue;
+    const code = record2.slice(0, 2);
+    const path = record2.slice(3);
+    if (code.startsWith("R") || code.startsWith("C") || code[1] === "R" || code[1] === "C")
+      i += 1;
+    out.push({ code, path, entry: `${code} ${path}`.trim() });
+  }
+  return out;
+}
+async function dirtyPaths(cwd) {
+  return (await dirtyEntries(cwd)).map((entry) => entry.entry);
+}
+function literalPathspec(path) {
+  return `:(literal)${path}`;
+}
+async function submodulePaths(cwd) {
+  const result2 = await git(["config", "--file", ".gitmodules", "--get-regexp", "^submodule\\..*\\.path$"], cwd);
+  const paths = new Set;
+  if (!result2.ok)
+    return paths;
+  for (const line of result2.stdout.split(`
+`)) {
+    const at = line.indexOf(" ");
+    if (at === -1)
+      continue;
+    const path = line.slice(at + 1).trim();
+    if (path !== "")
+      paths.add(path);
+  }
+  return paths;
+}
+async function operationInProgress(cwd) {
+  const gitDir = await git(["rev-parse", "--git-dir"], cwd);
+  if (!gitDir.ok)
+    return null;
+  const dir = resolve9(cwd, gitDir.stdout.trim());
+  for (const [name, what] of [
+    ["MERGE_HEAD", "a merge"],
+    ["rebase-merge", "a rebase"],
+    ["rebase-apply", "a rebase or `git am`"],
+    ["CHERRY_PICK_HEAD", "a cherry-pick"],
+    ["REVERT_HEAD", "a revert"],
+    ["BISECT_LOG", "a bisect"]
+  ]) {
+    if (existsSync32(join51(dir, name)))
+      return what;
+  }
+  return null;
+}
+async function unmergedPaths(cwd) {
+  const result2 = await git(["diff", "--name-only", "--diff-filter=U"], cwd);
   return result2.stdout.split(`
 `).map((line) => line.trim()).filter((line) => line !== "");
 }
+async function stashPushPaths(cwd, message4, paths) {
+  if (paths.length === 0)
+    return { ok: false, hash: "", message: message4, detail: "no paths to set aside" };
+  const pushed = await git(["stash", "push", "-u", "-m", message4, "--", ...paths.map(literalPathspec)], cwd);
+  if (!pushed.ok) {
+    return { ok: false, hash: "", message: message4, detail: firstLine7(pushed.stderr) || firstLine7(pushed.stdout) };
+  }
+  const hash = await fullShaOf(cwd, "refs/stash");
+  if (hash === "")
+    return { ok: false, hash: "", message: message4, detail: "`git stash push` left no refs/stash to name" };
+  return { ok: true, hash, message: message4, detail: firstLine7(pushed.stdout) };
+}
+async function stashRefFor(cwd, hash) {
+  const listed = await git(["stash", "list", "--format=%H %gd"], cwd);
+  if (!listed.ok)
+    return "";
+  for (const line of listed.stdout.split(`
+`)) {
+    const [sha, ref] = line.trim().split(" ");
+    if (sha === hash && ref !== undefined)
+      return ref;
+  }
+  return "";
+}
+async function stashPop(cwd, hash) {
+  const ref = await stashRefFor(cwd, hash);
+  if (ref === "") {
+    return {
+      restored: false,
+      indexRestored: false,
+      conflicts: [],
+      ref: "",
+      detail: "the stash entry is no longer in `git stash list`"
+    };
+  }
+  const withIndex = await git(["stash", "pop", "--index", ref], cwd);
+  if (withIndex.ok)
+    return { restored: true, indexRestored: true, conflicts: [], ref, detail: firstLine7(withIndex.stdout) };
+  const plain = await git(["stash", "pop", ref], cwd);
+  if (plain.ok) {
+    return {
+      restored: true,
+      indexRestored: false,
+      conflicts: [],
+      ref,
+      detail: `${firstLine7(plain.stdout)} — the index could not be reinstated (${firstLine7(withIndex.stderr)})`
+    };
+  }
+  return {
+    restored: false,
+    indexRestored: false,
+    conflicts: await unmergedPaths(cwd),
+    ref: await stashRefFor(cwd, hash),
+    detail: firstLine7(plain.stderr) || firstLine7(plain.stdout) || `git stash pop exited ${String(plain.exitCode)}`
+  };
+}
 function stateDirPrefixes(workspaceRoot, repoDir) {
   const base = resolve9(repoDir);
   const prefixes = [];
@@ -26621,7 +26679,13 @@ function readOrEmpty2(path) {
   }
 }
 
+// src/core/run/boundary.ts
+import { existsSync as existsSync38, readFileSync as readFileSync34, readdirSync as readdirSync19 } from "node:fs";
+import { join as join57 } from "node:path";
+
 // src/core/run/buildProgress.ts
+import { existsSync as existsSync37, readFileSync as readFileSync33 } from "node:fs";
+import { join as join56 } from "node:path";
 var PLAN_DIR = "03-plan";
 var BUILD_PHASE2 = "04-build";
 var STATUS_RE2 = /^status\s*:\s*(\w+)\s*$/m;
@@ -26658,7 +26722,7 @@ function buildProgress(runDir) {
     }
     waves.push({ id: wave.id, stories });
   }
-  return { waves, done, total, cost_usd: round6(cost), implicit };
+  return { waves, done, total, cost_usd: round5(cost), implicit };
 }
 function renderBuildProgress(progress) {
   return progress.waves.map((wave) => `${wave.id} [${wave.stories.map((s) => `${s.id} ${s.status}`).join(", ")}]`).join(" ");
@@ -26713,17 +26777,569 @@ function costByStory(runDir) {
     const story = typeof payload.story === "string" ? payload.story : payload.key;
     if (typeof story !== "string" || story === "")
       continue;
-    costs.set(story, round6((costs.get(story) ?? 0) + (typeof event2.cost_usd === "number" ? event2.cost_usd : 0)));
+    costs.set(story, round5((costs.get(story) ?? 0) + (typeof event2.cost_usd === "number" ? event2.cost_usd : 0)));
   }
   return costs;
 }
-function round6(n) {
+function round5(n) {
   return Math.round(n * 100) / 100;
 }
 
+// src/core/run/boundary.ts
+var OUTSIDE_SURFACE = "work outside the declared surface is a boundary change — a human decides whether to widen the scope";
+var NAMED_PATHS = 8;
+var SURFACE_HANDOFFS = ["01-what/handoff.md", "02-how/handoff.md"];
+var STORIES_DIR2 = "stories";
+var EPICS_DIR2 = "epics";
+function normalisePath2(path) {
+  let out = path.trim().split("\\").join("/");
+  while (out.startsWith("./"))
+    out = out.slice(2);
+  while (out.endsWith("/"))
+    out = out.slice(0, -1);
+  return out;
+}
+function inSurface(changed, surface) {
+  const path = normalisePath2(changed);
+  for (const raw of surface) {
+    const entry = normalisePath2(raw);
+    if (entry === "")
+      continue;
+    if (path === entry || path.startsWith(`${entry}/`))
+      return true;
+  }
+  return false;
+}
+function unqualifiedCitedPaths(handoffText, repos) {
+  const out = [];
+  const seen = new Set;
+  if (handoffText === "")
+    return out;
+  for (const line of handoffText.split(`
+`)) {
+    const token = parseSrcToken(line, repos);
+    if (token === null)
+      continue;
+    for (const ref of token.refs) {
+      if (ref.kind !== "file" || ref.repo !== null)
+        continue;
+      const path = normalisePath2(ref.path);
+      if (path === "" || seen.has(path))
+        continue;
+      seen.add(path);
+      out.push(path);
+    }
+  }
+  return out;
+}
+function storyTouches(runDir) {
+  const dir = join57(runDir, PLAN_DIR, STORIES_DIR2);
+  if (!existsSync38(dir))
+    return [];
+  const out = [];
+  let names;
+  try {
+    names = readdirSync19(dir).filter((name) => name.endsWith(".md")).sort();
+  } catch {
+    return [];
+  }
+  for (const name of names) {
+    const front2 = readFront(join57(dir, name));
+    if (front2 === null)
+      continue;
+    const repo = typeof front2.repo === "string" ? front2.repo : "";
+    const id = typeof front2.id === "string" && front2.id !== "" ? front2.id : name.replace(/\.md$/, "");
+    out.push({ story: id, repo, touches: stringList2(front2.touches) });
+  }
+  return out;
+}
+function declaredTouchesFor(runDir, storyId) {
+  for (const row2 of storyTouches(runDir)) {
+    if (row2.story === storyId)
+      return row2.touches;
+  }
+  const implicit = implicitStorySurface(runDir);
+  return implicit !== null && implicit.story === storyId ? implicit.touches : null;
+}
+function implicitStorySurface(runDir) {
+  const doc = readYaml(join57(runDir, BUILD_PHASE2, IMPLICIT_PLAN_FILE));
+  const story = doc?.story;
+  if (story === null || typeof story !== "object")
+    return null;
+  const row2 = story;
+  return {
+    story: typeof row2.id === "string" && row2.id !== "" ? row2.id : IMPLICIT_STORY_ID,
+    repo: typeof row2.repo === "string" ? row2.repo : "",
+    touches: stringList2(row2.touches)
+  };
+}
+function deriveSurface(runDir, workspace) {
+  const byRepo = new Map;
+  const unqualified = [];
+  const excluded = [];
+  let cited = 0;
+  let declared = 0;
+  const add = (repo, path, count) => {
+    const entry = normalisePath2(path);
+    if (entry === "")
+      return;
+    if (isStatePath(entry)) {
+      if (!excluded.includes(entry))
+        excluded.push(entry);
+      return;
+    }
+    count();
+    if (repo === "") {
+      if (!unqualified.includes(entry))
+        unqualified.push(entry);
+      return;
+    }
+    const list = byRepo.get(repo) ?? [];
+    if (!list.includes(entry))
+      list.push(entry);
+    byRepo.set(repo, list);
+  };
+  const repoNames = new Set(workspace.repos.keys());
+  for (const rel of SURFACE_HANDOFFS) {
+    const text2 = readText2(join57(runDir, rel));
+    if (text2 === "")
+      continue;
+    for (const entry of citedRepoPaths(text2, workspace)) {
+      add(entry.repo, entry.path, () => {
+        cited += 1;
+      });
+    }
+    for (const path of unqualifiedCitedPaths(text2, repoNames)) {
+      add("", path, () => {
+        cited += 1;
+      });
+    }
+  }
+  const stories = storyTouches(runDir);
+  const sources = stories.length > 0 ? stories : [implicitStorySurface(runDir)].filter((s) => s !== null);
+  for (const story of sources) {
+    for (const path of story.touches) {
+      add(story.repo, path, () => {
+        declared += 1;
+      });
+    }
+  }
+  return { byRepo, unqualified, cited, declared, excluded };
+}
+function epicTargets2(runDir, workspace) {
+  const out = [];
+  const seen = new Set;
+  const push2 = (epic2, repo, branch) => {
+    if (repo === "" || branch === "")
+      return;
+    const key = `${repo}\x00${branch}`;
+    if (seen.has(key))
+      return;
+    seen.add(key);
+    const rel = repoPath(workspace, repo);
+    out.push({
+      epic: epic2,
+      repo,
+      branch,
+      base: workspace.defaultBranches.get(repo) ?? "main",
+      dir: rel
+    });
+  };
+  const dir = join57(runDir, PLAN_DIR, EPICS_DIR2);
+  if (existsSync38(dir)) {
+    let names = [];
+    try {
+      names = readdirSync19(dir).filter((name) => name.endsWith(".md")).sort();
+    } catch {
+      names = [];
+    }
+    for (const name of names) {
+      const front2 = readFront(join57(dir, name));
+      if (front2 === null)
+        continue;
+      const id = typeof front2.id === "string" ? front2.id : name.replace(/\.md$/, "");
+      const branch = typeof front2.branch === "string" ? front2.branch : "";
+      const repos = stringList2(front2.repos);
+      const fallback = storyTouches(runDir).map((story) => story.repo).filter((repo) => repo !== "");
+      for (const repo of repos.length > 0 ? repos : [...new Set(fallback)])
+        push2(id, repo, branch);
+    }
+    if (out.length > 0)
+      return out;
+  }
+  const doc = readYaml(join57(runDir, BUILD_PHASE2, IMPLICIT_PLAN_FILE));
+  const epic = doc?.epic;
+  if (epic !== null && typeof epic === "object") {
+    const row2 = epic;
+    const id = typeof row2.id === "string" ? row2.id : "E1";
+    const branch = typeof row2.branch === "string" ? row2.branch : "";
+    for (const repo of stringList2(row2.repos))
+      push2(id, repo, branch);
+  }
+  return out;
+}
+async function diffRepo(target) {
+  if (target.dir === null)
+    return { changed: null, reason: `${target.repo} is not in ${PROJECT_WORKSPACE_FILE}` };
+  if (!existsSync38(target.dir))
+    return { changed: null, reason: `${target.repo} is not on disk` };
+  const baseCheck = await git(["rev-parse", "--verify", "--quiet", `${target.base}^{commit}`], target.dir);
+  if (!baseCheck.ok) {
+    return {
+      changed: null,
+      reason: `\`${target.base}\`, the \`default_branch\` ${PROJECT_WORKSPACE_FILE} records for ${target.repo}, does not ` + "resolve there — the record is stale, so nothing in this repo has a base to be diffed against " + "(run `tldrx doctor`)"
+    };
+  }
+  const branchCheck = await git(["rev-parse", "--verify", "--quiet", `${target.branch}^{commit}`], target.dir);
+  if (!branchCheck.ok) {
+    return { changed: null, reason: `\`${target.branch}\` does not resolve in ${target.repo}` };
+  }
+  const range = `${target.base}...${target.branch}`;
+  const diff = await git(["diff", "--name-only", range], target.dir);
+  if (!diff.ok)
+    return { changed: null, reason: `\`git diff ${range}\` failed in ${target.repo}` };
+  const changed = diff.stdout.split(`
+`).map(normalisePath2).filter((path) => path !== "");
+  return { changed, reason: null };
+}
+async function evaluateBoundary(input) {
+  if (input.phaseId !== BUILD_PHASE2)
+    return { ok: true, detail: "n/a (not a build stage)" };
+  const workspace = loadWorkspace(input.root);
+  const targets = epicTargets2(input.runDir, workspace);
+  if (targets.length === 0)
+    return { ok: true, detail: "n/a (no plan naming an epic branch)" };
+  const surface = deriveSurface(input.runDir, workspace);
+  const excludedPart = surface.excluded.length === 0 ? "" : `; ${String(surface.excluded.length)} state path(s) excluded from the surface: ` + surface.excluded.slice(0, NAMED_PATHS).join(", ") + (surface.excluded.length > NAMED_PATHS ? `, +${String(surface.excluded.length - NAMED_PATHS)} more` : "");
+  if (surface.cited + surface.declared === 0) {
+    return {
+      ok: true,
+      detail: `n/a (the run declares no surface: no cited path, no \`touches:\`)${excludedPart}`
+    };
+  }
+  const repos = [];
+  for (const target of targets) {
+    const { changed, reason } = await diffRepo(target);
+    if (changed === null) {
+      repos.push({ target, changed: null, reason, outside: [], state: [] });
+      continue;
+    }
+    const allowed = [...surface.byRepo.get(target.repo) ?? [], ...surface.unqualified];
+    const state = changed.filter(isStatePath);
+    const product = changed.filter((path) => !isStatePath(path));
+    repos.push({
+      target,
+      changed: product,
+      reason: null,
+      outside: product.filter((path) => !inSurface(path, allowed)),
+      state
+    });
+  }
+  const measured = repos.filter((repo) => repo.changed !== null);
+  if (measured.length === 0) {
+    const why = repos.map((repo) => repo.reason ?? "unavailable").join("; ");
+    return { ok: true, detail: `n/a (nothing could be diffed: ${why})${excludedPart}` };
+  }
+  const audited = measured.reduce((sum, repo) => sum + (repo.changed?.length ?? 0), 0);
+  const outside = measured.flatMap((repo) => repo.outside.map((path) => `${repo.target.repo}:${path}`));
+  const unread = repos.filter((repo) => repo.changed === null);
+  const unreadPart = unread.length === 0 ? "" : `; not diffed: ${unread.map((repo) => repo.reason ?? "unavailable").join(", ")}`;
+  const range = measured.map((repo) => `${repo.target.repo} ${repo.target.base}...${repo.target.branch}`).join(", ");
+  if (outside.length === 0) {
+    return {
+      ok: true,
+      detail: `${String(audited)} changed path(s), 0 outside the surface (${range})${unreadPart}${excludedPart}`
+    };
+  }
+  const named = outside.slice(0, NAMED_PATHS);
+  const rest = outside.length - named.length;
+  return {
+    ok: false,
+    detail: `${String(audited)} changed path(s), ${String(outside.length)} outside the surface: ` + `${named.join(", ")}${rest > 0 ? `, +${String(rest)} more` : ""}` + `${unreadPart}${excludedPart}; ${OUTSIDE_SURFACE}`
+  };
+}
+function readText2(path) {
+  if (!existsSync38(path))
+    return "";
+  try {
+    return readFileSync34(path, "utf8");
+  } catch {
+    return "";
+  }
+}
+function readYaml(path) {
+  const text2 = readText2(path);
+  if (text2 === "")
+    return null;
+  try {
+    return parseYaml(text2);
+  } catch {
+    return null;
+  }
+}
+function readFront(path) {
+  const text2 = readText2(path);
+  if (text2 === "")
+    return null;
+  const parsed = parseFrontMatter(text2);
+  const doc = parsed.doc;
+  if (doc === null || typeof doc !== "object" || Array.isArray(doc))
+    return null;
+  return doc;
+}
+function stringList2(value) {
+  if (!Array.isArray(value))
+    return [];
+  return value.filter((item) => typeof item === "string");
+}
+
+// src/core/build/foreignWork.ts
+var FOREIGN_ASIDE_EVENT = "worktree.foreign_work_aside";
+var FOREIGN_RESTORED_EVENT = "worktree.foreign_work_restored";
+var NAMED_PATHS2 = 5;
+function classifyDirty(input) {
+  const own = [];
+  const foreign = [];
+  const overlapping = [];
+  for (const entry of input.entries) {
+    if (input.statePrefixes.some((p) => entry.path === p || entry.path.startsWith(`${p}/`))) {
+      own.push(entry);
+      continue;
+    }
+    if (isStatePath(entry.path)) {
+      overlapping.push({
+        entry,
+        why: "this is your own directory that happens to be named like tldrx state — the framework " + "never stashes a `tldrx-work/`, `.tldrx/` or `.agent/` path, so this one is yours to move"
+      });
+      continue;
+    }
+    const submodule = [...input.submodules].find((path) => entry.path === path || entry.path.startsWith(`${path}/`));
+    if (submodule !== undefined) {
+      overlapping.push({
+        entry,
+        why: `\`${submodule}\` is a submodule — its uncommitted state is another repository's, ` + "and a stash here does not carry it"
+      });
+      continue;
+    }
+    if (inSurface(entry.path, input.touches)) {
+      overlapping.push({
+        entry,
+        why: "a pending story declares this path in its `touches:` — setting your version of it " + "aside would hand the developer a tree you did not agree to"
+      });
+      continue;
+    }
+    foreign.push(entry);
+  }
+  return { own, foreign, overlapping };
+}
+function stashMessage(runId) {
+  return `tldrx ${runId} foreign work`;
+}
+function shellQuote2(word) {
+  return `'${word.split("'").join(`'\\''`)}'`;
+}
+function stashCommand(repoDir, runId, paths) {
+  const pathspecs = paths.map((path) => shellQuote2(literalPathspec(path))).join(" ");
+  return `git -C ${shellQuote2(repoDir)} stash push -u -m ${shellQuote2(stashMessage(runId))} -- ${pathspecs}`;
+}
+async function setAsideForeignWork(repo, repoDir, runId, paths) {
+  if (paths.length === 0)
+    return { stash: null, reason: null };
+  const busy = await operationInProgress(repoDir);
+  if (busy !== null)
+    return { stash: null, reason: `${repo} is in the middle of ${busy}` };
+  const pushed = await stashPushPaths(repoDir, stashMessage(runId), paths);
+  if (!pushed.ok)
+    return { stash: null, reason: pushed.detail };
+  return { stash: { repo, repoDir, paths, hash: pushed.hash, message: pushed.message }, reason: null };
+}
+async function restoreForeignWork(stash) {
+  const popped = await stashPop(stash.repoDir, stash.hash);
+  return {
+    stash,
+    restored: popped.restored,
+    indexRestored: popped.indexRestored,
+    conflicts: popped.conflicts,
+    command: popped.ref === "" ? "" : `git -C ${stash.repoDir} stash pop ${popped.ref}`,
+    detail: popped.detail
+  };
+}
+function namePaths(paths, max = NAMED_PATHS2) {
+  const named = paths.slice(0, max).join(", ");
+  return paths.length > max ? `${named}, +${String(paths.length - max)} more` : named;
+}
+function notRestoredLine(outcome) {
+  return notRestoredSentence({
+    repo: outcome.stash.repo,
+    hash: outcome.stash.hash,
+    paths: outcome.conflicts.length > 0 ? outcome.conflicts : outcome.stash.paths,
+    command: outcome.command,
+    detail: outcome.detail
+  });
+}
+var NOT_RESTORED_MARK = "foreign work NOT restored";
+function notRestoredSentence(row2) {
+  const how = row2.command === "" ? row2.detail : row2.command;
+  return `${NOT_RESTORED_MARK} in ${row2.repo} — stash ${row2.hash.slice(0, 12)} ` + `still holds ${namePaths(row2.paths)}: ${how}`;
+}
+function notRestoredSummary(eventsText) {
+  const failed2 = new Map;
+  for (const line of eventsText.split(`
+`)) {
+    if (line.trim() === "")
+      continue;
+    let event2;
+    try {
+      event2 = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (event2.type !== FOREIGN_RESTORED_EVENT)
+      continue;
+    const payload = typeof event2.payload === "object" && event2.payload !== null ? event2.payload : {};
+    const hash = typeof payload.stash_ref === "string" ? payload.stash_ref : "";
+    if (hash === "")
+      continue;
+    if (payload.restored === true) {
+      failed2.delete(hash);
+      continue;
+    }
+    failed2.set(hash, notRestoredSentence({
+      repo: typeof payload.repo === "string" ? payload.repo : "a repo",
+      hash,
+      paths: Array.isArray(payload.paths) ? payload.paths.filter((p) => typeof p === "string") : [],
+      command: typeof payload.command === "string" ? payload.command : "",
+      detail: typeof payload.detail === "string" ? payload.detail : "git refused the pop"
+    }));
+  }
+  return failed2.size === 0 ? null : [...failed2.values()].join(" ");
+}
+function restoredLine(outcome) {
+  const head2 = `${outcome.stash.repo}: foreign work restored from stash ` + `${outcome.stash.hash.slice(0, 12)} (${namePaths(outcome.stash.paths)})`;
+  return outcome.indexRestored ? head2 : `${head2} — the staged snapshot could NOT be reinstated, so those paths are back UNSTAGED; ` + "`git add` them as you had them";
+}
+function unrestored(outcomes) {
+  return outcomes.filter((outcome) => !outcome.restored);
+}
+var MAX_RECORDED_PATHS = 40;
+function asidePayload(stash, reason) {
+  const omitted = stash.paths.length - MAX_RECORDED_PATHS;
+  return {
+    repo: stash.repo,
+    paths: stash.paths.slice(0, MAX_RECORDED_PATHS),
+    ...omitted > 0 ? { paths_omitted: omitted } : {},
+    stash_ref: stash.hash,
+    reason
+  };
+}
+function restoredPayload(outcome) {
+  const paths = outcome.restored ? outcome.stash.paths : outcome.conflicts.length > 0 ? outcome.conflicts : outcome.stash.paths;
+  const omitted = paths.length - MAX_RECORDED_PATHS;
+  return {
+    repo: outcome.stash.repo,
+    paths: paths.slice(0, MAX_RECORDED_PATHS),
+    ...omitted > 0 ? { paths_omitted: omitted } : {},
+    stash_ref: outcome.stash.hash,
+    restored: outcome.restored,
+    index_restored: outcome.indexRestored,
+    ...outcome.restored ? {} : { conflicts: outcome.conflicts.slice(0, MAX_RECORDED_PATHS) },
+    ...outcome.restored ? {} : { command: outcome.command },
+    ...outcome.restored ? {} : { detail: outcome.detail }
+  };
+}
+function pendingAsides(eventsText, repoDirOf2) {
+  const open = new Map;
+  for (const line of eventsText.split(`
+`)) {
+    if (line.trim() === "")
+      continue;
+    let event2;
+    try {
+      event2 = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const payload = typeof event2.payload === "object" && event2.payload !== null ? event2.payload : {};
+    const hash = typeof payload.stash_ref === "string" ? payload.stash_ref : "";
+    if (hash === "")
+      continue;
+    if (event2.type === FOREIGN_RESTORED_EVENT && payload.restored === true) {
+      open.delete(hash);
+      continue;
+    }
+    if (event2.type !== FOREIGN_ASIDE_EVENT)
+      continue;
+    const repo = typeof payload.repo === "string" ? payload.repo : "";
+    const repoDir = repo === "" ? null : repoDirOf2(repo);
+    if (repoDir === null)
+      continue;
+    open.set(hash, {
+      repo,
+      repoDir,
+      paths: Array.isArray(payload.paths) ? payload.paths.filter((p) => typeof p === "string") : [],
+      hash,
+      message: ""
+    });
+  }
+  return [...open.values()];
+}
+
+// src/core/budget/wouldExceed.ts
+function totalSpent(budget) {
+  return budget.phases.reduce((sum, p) => sum + p.spent_usd, 0);
+}
+function remaining(budget, phaseId) {
+  if (phaseId !== undefined) {
+    const phase = budget.phases.find((p) => p.id === phaseId);
+    if (phase !== undefined)
+      return round6(phase.ceiling_usd - phase.spent_usd);
+  }
+  return round6(budget.ceiling_usd - totalSpent(budget));
+}
+function wouldExceed(budget, phaseId, estimate) {
+  const phase = phaseId === null ? undefined : budget.phases.find((p) => p.id === phaseId);
+  const scope = phase === undefined ? "run" : "phase";
+  const ceiling = phase === undefined ? budget.ceiling_usd : phase.ceiling_usd;
+  const spent = phase === undefined ? totalSpent(budget) : phase.spent_usd;
+  const left = round6(ceiling - spent);
+  const exceeds = round6(spent + estimate) > ceiling;
+  const pct = ceiling === 0 ? 100 : (spent + estimate) / ceiling * 100;
+  return {
+    exceeds,
+    blocked: exceeds && budget.on_exceed === "block",
+    scope,
+    phaseId: phase === undefined ? null : phase.id,
+    remaining: left,
+    ceiling,
+    estimate,
+    warns: !exceeds && pct >= budget.warn_at_pct
+  };
+}
+function round6(n) {
+  return Math.round(n * 1e6) / 1e6;
+}
+function wouldExceedHostTokens(budget, phaseId, spentTokens) {
+  const ceiling = hostTokenCeiling(budget, phaseId);
+  if (ceiling === null)
+    return null;
+  const phase = phaseId === null ? undefined : budget.phases.find((p) => p.id === phaseId);
+  const over = ceiling > 0 && spentTokens > ceiling;
+  return {
+    over,
+    blocked: over && budget.on_host_tokens_exceed === "block",
+    scope: phase === undefined ? "run" : "phase",
+    spent: spentTokens,
+    ceiling
+  };
+}
+
+// src/core/budget/remainingWork.ts
+import { existsSync as existsSync40, readFileSync as readFileSync36 } from "node:fs";
+import { join as join59 } from "node:path";
+
 // src/core/build/fixlist.ts
-import { existsSync as existsSync38, mkdirSync as mkdirSync11, readdirSync as readdirSync19, readFileSync as readFileSync34, writeFileSync as writeFileSync10 } from "node:fs";
-import { join as join57 } from "node:path";
+import { existsSync as existsSync39, mkdirSync as mkdirSync11, readdirSync as readdirSync20, readFileSync as readFileSync35, writeFileSync as writeFileSync10 } from "node:fs";
+import { join as join58 } from "node:path";
 var FIXLIST_DIR = "fixlist";
 var MAX_FIXLIST_ROUNDS = 1;
 var DISPOSITIONS = ["fix-now", "defer-with-log", "refuted", "out-of-scope"];
@@ -26998,21 +27614,21 @@ function fixlistRel(phaseDir, storyId, round4) {
   return `${phaseDir}/${FIXLIST_DIR}/${storyId}-${String(round4)}.md`;
 }
 function fixlistDir(runDir, phaseDir) {
-  return join57(runDir, phaseDir, FIXLIST_DIR);
+  return join58(runDir, phaseDir, FIXLIST_DIR);
 }
 function writeFixlist(runDir, phaseDir, parts) {
   const dir = fixlistDir(runDir, phaseDir);
   mkdirSync11(dir, { recursive: true });
-  writeFileSync10(join57(dir, `${parts.storyId}-${String(parts.round)}.md`), renderFixlist(parts), "utf8");
+  writeFileSync10(join58(dir, `${parts.storyId}-${String(parts.round)}.md`), renderFixlist(parts), "utf8");
   return fixlistRel(phaseDir, parts.storyId, parts.round);
 }
 function fixlistRounds(runDir, phaseDir, storyId) {
   const dir = fixlistDir(runDir, phaseDir);
-  if (!existsSync38(dir))
+  if (!existsSync39(dir))
     return [];
   let entries;
   try {
-    entries = readdirSync19(dir);
+    entries = readdirSync20(dir);
   } catch {
     return [];
   }
@@ -27022,7 +27638,7 @@ function fixlistRounds(runDir, phaseDir, storyId) {
     if (match === null)
       continue;
     const round4 = Number(match[1] ?? "0");
-    const path = join57(dir, entry);
+    const path = join58(dir, entry);
     rows.push({ round: round4, path, rel: fixlistRel(phaseDir, storyId, round4), findings: readFindings(path) });
   }
   return rows.sort((a, b) => a.round - b.round);
@@ -27032,11 +27648,11 @@ function latestFixlist(runDir, phaseDir, storyId) {
   return rounds[rounds.length - 1] ?? null;
 }
 function readFixlistAt(path, rel) {
-  if (!existsSync38(path))
+  if (!existsSync39(path))
     return null;
   let text2;
   try {
-    text2 = readFileSync34(path, "utf8");
+    text2 = readFileSync35(path, "utf8");
   } catch {
     return null;
   }
@@ -27048,7 +27664,7 @@ function readFixlistAt(path, rel) {
 }
 function readFindings(path) {
   try {
-    return parseFixlistFile(readFileSync34(path, "utf8"));
+    return parseFixlistFile(readFileSync35(path, "utf8"));
   } catch {
     return [];
   }
@@ -27412,7 +28028,7 @@ function measure(input) {
   if (all.length === 0)
     return fallback;
   const ids = new Set(all.map((story) => story.id));
-  const prices = progress.implicit ? new Map : loadPlanPrices(join58(input.runDir, PLAN_DIR), ids).prices;
+  const prices = progress.implicit ? new Map : loadPlanPrices(join59(input.runDir, PLAN_DIR), ids).prices;
   const verdicts = reviewVerdictsByStory(input.runDir);
   const caps = new CapMath(input, prices, all.length);
   const stories = [];
@@ -27561,12 +28177,12 @@ class CapMath {
 }
 function reviewVerdictsByStory(runDir) {
   const counts = new Map;
-  const path = join58(runDir, "events.jsonl");
-  if (!existsSync39(path))
+  const path = join59(runDir, "events.jsonl");
+  if (!existsSync40(path))
     return counts;
   let text3;
   try {
-    text3 = readFileSync35(path, "utf8");
+    text3 = readFileSync36(path, "utf8");
   } catch {
     return counts;
   }
@@ -27733,11 +28349,11 @@ function round7(n) {
 }
 
 // src/core/run/attempts.ts
-import { existsSync as existsSync40, readFileSync as readFileSync36 } from "node:fs";
-import { join as join59 } from "node:path";
+import { existsSync as existsSync41, readFileSync as readFileSync37 } from "node:fs";
+import { join as join60 } from "node:path";
 function stageAttempts(runDir, phase, stage2) {
   const costs = [];
-  for (const event2 of readEvents(join59(runDir, "events.jsonl"))) {
+  for (const event2 of readEvents(join60(runDir, "events.jsonl"))) {
     if (event2.type !== "agent.result" || event2.stage !== stage2)
       continue;
     const eventPhase = event2.payload.phase;
@@ -27754,12 +28370,12 @@ function renderAttempts(attempts) {
   return `attempts: ${String(attempts.costs.length)} · ${each}`;
 }
 function readEvents(path) {
-  if (!existsSync40(path))
+  if (!existsSync41(path))
     return [];
   const events = [];
   let text3;
   try {
-    text3 = readFileSync36(path, "utf8");
+    text3 = readFileSync37(path, "utf8");
   } catch {
     return events;
   }
@@ -27782,8 +28398,8 @@ import { existsSync as existsSync43, readFileSync as readFileSync39 } from "node
 import { join as join62 } from "node:path";
 
 // src/core/run/checks.ts
-import { existsSync as existsSync41, readFileSync as readFileSync37 } from "node:fs";
-import { basename as basename9, join as join60 } from "node:path";
+import { existsSync as existsSync42, readFileSync as readFileSync38 } from "node:fs";
+import { basename as basename9, join as join61 } from "node:path";
 var WRITE_TIME_ONLY = ["no-reask", "budget-gate", "dod"];
 async function runChecks(checks, ctx) {
   const outcomes = [];
@@ -27829,12 +28445,12 @@ function checkClaimSources(ctx) {
       continue;
     }
     for (const hit of hits) {
-      if (!existsSync41(hit.absolute)) {
+      if (!existsSync42(hit.absolute)) {
         if (isHandoffOutput)
           failures.push(`${hit.path} was declared but never written`);
         continue;
       }
-      const text3 = readFileSync37(hit.absolute, "utf8");
+      const text3 = readFileSync38(hit.absolute, "utf8");
       if (isHandoffOutput || isHandoff(text3)) {
         handoffs++;
         const validation = validateHandoff(text3, srcCtx);
@@ -27977,7 +28593,7 @@ function checkPlan(ctx) {
   if (!writesPlanArtefacts(ctx.stage.outputs)) {
     return { id: "plan", status: "skipped", detail: "the stage declares no waves.yml output" };
   }
-  const planDir = join60(ctx.runDir, ctx.stage.phase);
+  const planDir = join61(ctx.runDir, ctx.stage.phase);
   const workspace = loadWorkspace(ctx.root);
   const report2 = validatePlan(planDir, workspace.commands, workspace.iterationCommands);
   if (!report2.ok) {
@@ -27996,10 +28612,10 @@ function checkSchema(ctx) {
     ["budget.yml", validateRunBudget]
   ];
   for (const [name, validate2] of pairs) {
-    const path = join60(ctx.runDir, name);
-    if (!existsSync41(path))
+    const path = join61(ctx.runDir, name);
+    if (!existsSync42(path))
       return { id: "schema", status: "failed", detail: `${name} is missing` };
-    const validation = validate2(parseYaml(readFileSync37(path, "utf8")));
+    const validation = validate2(parseYaml(readFileSync38(path, "utf8")));
     if (!validation.ok) {
       const first2 = validation.issues[0];
       return { id: "schema", status: "failed", detail: `${name}: ${first2?.path ?? ""} ${first2?.message ?? ""}`.trim() };
@@ -28086,316 +28702,6 @@ ${stderr}`.split(`
   return last.length > max ? `${last.slice(0, max - 1)}…` : last;
 }
 
-// src/core/run/boundary.ts
-import { existsSync as existsSync42, readFileSync as readFileSync38, readdirSync as readdirSync20 } from "node:fs";
-import { join as join61 } from "node:path";
-var OUTSIDE_SURFACE = "work outside the declared surface is a boundary change — a human decides whether to widen the scope";
-var NAMED_PATHS = 8;
-var SURFACE_HANDOFFS = ["01-what/handoff.md", "02-how/handoff.md"];
-var STORIES_DIR2 = "stories";
-var EPICS_DIR2 = "epics";
-function normalisePath2(path) {
-  let out = path.trim().split("\\").join("/");
-  while (out.startsWith("./"))
-    out = out.slice(2);
-  while (out.endsWith("/"))
-    out = out.slice(0, -1);
-  return out;
-}
-function inSurface(changed, surface) {
-  const path = normalisePath2(changed);
-  for (const raw of surface) {
-    const entry = normalisePath2(raw);
-    if (entry === "")
-      continue;
-    if (path === entry || path.startsWith(`${entry}/`))
-      return true;
-  }
-  return false;
-}
-function unqualifiedCitedPaths(handoffText, repos) {
-  const out = [];
-  const seen = new Set;
-  if (handoffText === "")
-    return out;
-  for (const line of handoffText.split(`
-`)) {
-    const token = parseSrcToken(line, repos);
-    if (token === null)
-      continue;
-    for (const ref of token.refs) {
-      if (ref.kind !== "file" || ref.repo !== null)
-        continue;
-      const path = normalisePath2(ref.path);
-      if (path === "" || seen.has(path))
-        continue;
-      seen.add(path);
-      out.push(path);
-    }
-  }
-  return out;
-}
-function storyTouches(runDir) {
-  const dir = join61(runDir, PLAN_DIR, STORIES_DIR2);
-  if (!existsSync42(dir))
-    return [];
-  const out = [];
-  let names;
-  try {
-    names = readdirSync20(dir).filter((name) => name.endsWith(".md")).sort();
-  } catch {
-    return [];
-  }
-  for (const name of names) {
-    const front2 = readFront(join61(dir, name));
-    if (front2 === null)
-      continue;
-    const repo = typeof front2.repo === "string" ? front2.repo : "";
-    const id = typeof front2.id === "string" && front2.id !== "" ? front2.id : name.replace(/\.md$/, "");
-    out.push({ story: id, repo, touches: stringList2(front2.touches) });
-  }
-  return out;
-}
-function declaredTouchesFor(runDir, storyId) {
-  for (const row2 of storyTouches(runDir)) {
-    if (row2.story === storyId)
-      return row2.touches;
-  }
-  const implicit = implicitStorySurface(runDir);
-  return implicit !== null && implicit.story === storyId ? implicit.touches : null;
-}
-function implicitStorySurface(runDir) {
-  const doc = readYaml(join61(runDir, BUILD_PHASE2, IMPLICIT_PLAN_FILE));
-  const story = doc?.story;
-  if (story === null || typeof story !== "object")
-    return null;
-  const row2 = story;
-  return {
-    story: typeof row2.id === "string" && row2.id !== "" ? row2.id : IMPLICIT_STORY_ID,
-    repo: typeof row2.repo === "string" ? row2.repo : "",
-    touches: stringList2(row2.touches)
-  };
-}
-function deriveSurface(runDir, workspace) {
-  const byRepo = new Map;
-  const unqualified = [];
-  const excluded = [];
-  let cited = 0;
-  let declared = 0;
-  const add = (repo, path, count) => {
-    const entry = normalisePath2(path);
-    if (entry === "")
-      return;
-    if (isStatePath(entry)) {
-      if (!excluded.includes(entry))
-        excluded.push(entry);
-      return;
-    }
-    count();
-    if (repo === "") {
-      if (!unqualified.includes(entry))
-        unqualified.push(entry);
-      return;
-    }
-    const list = byRepo.get(repo) ?? [];
-    if (!list.includes(entry))
-      list.push(entry);
-    byRepo.set(repo, list);
-  };
-  const repoNames = new Set(workspace.repos.keys());
-  for (const rel of SURFACE_HANDOFFS) {
-    const text3 = readText2(join61(runDir, rel));
-    if (text3 === "")
-      continue;
-    for (const entry of citedRepoPaths(text3, workspace)) {
-      add(entry.repo, entry.path, () => {
-        cited += 1;
-      });
-    }
-    for (const path of unqualifiedCitedPaths(text3, repoNames)) {
-      add("", path, () => {
-        cited += 1;
-      });
-    }
-  }
-  const stories = storyTouches(runDir);
-  const sources = stories.length > 0 ? stories : [implicitStorySurface(runDir)].filter((s) => s !== null);
-  for (const story of sources) {
-    for (const path of story.touches) {
-      add(story.repo, path, () => {
-        declared += 1;
-      });
-    }
-  }
-  return { byRepo, unqualified, cited, declared, excluded };
-}
-function epicTargets2(runDir, workspace) {
-  const out = [];
-  const seen = new Set;
-  const push2 = (epic2, repo, branch) => {
-    if (repo === "" || branch === "")
-      return;
-    const key = `${repo}\x00${branch}`;
-    if (seen.has(key))
-      return;
-    seen.add(key);
-    const rel = repoPath(workspace, repo);
-    out.push({
-      epic: epic2,
-      repo,
-      branch,
-      base: workspace.defaultBranches.get(repo) ?? "main",
-      dir: rel
-    });
-  };
-  const dir = join61(runDir, PLAN_DIR, EPICS_DIR2);
-  if (existsSync42(dir)) {
-    let names = [];
-    try {
-      names = readdirSync20(dir).filter((name) => name.endsWith(".md")).sort();
-    } catch {
-      names = [];
-    }
-    for (const name of names) {
-      const front2 = readFront(join61(dir, name));
-      if (front2 === null)
-        continue;
-      const id = typeof front2.id === "string" ? front2.id : name.replace(/\.md$/, "");
-      const branch = typeof front2.branch === "string" ? front2.branch : "";
-      const repos = stringList2(front2.repos);
-      const fallback = storyTouches(runDir).map((story) => story.repo).filter((repo) => repo !== "");
-      for (const repo of repos.length > 0 ? repos : [...new Set(fallback)])
-        push2(id, repo, branch);
-    }
-    if (out.length > 0)
-      return out;
-  }
-  const doc = readYaml(join61(runDir, BUILD_PHASE2, IMPLICIT_PLAN_FILE));
-  const epic = doc?.epic;
-  if (epic !== null && typeof epic === "object") {
-    const row2 = epic;
-    const id = typeof row2.id === "string" ? row2.id : "E1";
-    const branch = typeof row2.branch === "string" ? row2.branch : "";
-    for (const repo of stringList2(row2.repos))
-      push2(id, repo, branch);
-  }
-  return out;
-}
-async function diffRepo(target) {
-  if (target.dir === null)
-    return { changed: null, reason: `${target.repo} is not in ${PROJECT_WORKSPACE_FILE}` };
-  if (!existsSync42(target.dir))
-    return { changed: null, reason: `${target.repo} is not on disk` };
-  const baseCheck = await git(["rev-parse", "--verify", "--quiet", `${target.base}^{commit}`], target.dir);
-  if (!baseCheck.ok) {
-    return {
-      changed: null,
-      reason: `\`${target.base}\`, the \`default_branch\` ${PROJECT_WORKSPACE_FILE} records for ${target.repo}, does not ` + "resolve there — the record is stale, so nothing in this repo has a base to be diffed against " + "(run `tldrx doctor`)"
-    };
-  }
-  const branchCheck = await git(["rev-parse", "--verify", "--quiet", `${target.branch}^{commit}`], target.dir);
-  if (!branchCheck.ok) {
-    return { changed: null, reason: `\`${target.branch}\` does not resolve in ${target.repo}` };
-  }
-  const range = `${target.base}...${target.branch}`;
-  const diff = await git(["diff", "--name-only", range], target.dir);
-  if (!diff.ok)
-    return { changed: null, reason: `\`git diff ${range}\` failed in ${target.repo}` };
-  const changed = diff.stdout.split(`
-`).map(normalisePath2).filter((path) => path !== "");
-  return { changed, reason: null };
-}
-async function evaluateBoundary(input) {
-  if (input.phaseId !== BUILD_PHASE2)
-    return { ok: true, detail: "n/a (not a build stage)" };
-  const workspace = loadWorkspace(input.root);
-  const targets = epicTargets2(input.runDir, workspace);
-  if (targets.length === 0)
-    return { ok: true, detail: "n/a (no plan naming an epic branch)" };
-  const surface = deriveSurface(input.runDir, workspace);
-  const excludedPart = surface.excluded.length === 0 ? "" : `; ${String(surface.excluded.length)} state path(s) excluded from the surface: ` + surface.excluded.slice(0, NAMED_PATHS).join(", ") + (surface.excluded.length > NAMED_PATHS ? `, +${String(surface.excluded.length - NAMED_PATHS)} more` : "");
-  if (surface.cited + surface.declared === 0) {
-    return {
-      ok: true,
-      detail: `n/a (the run declares no surface: no cited path, no \`touches:\`)${excludedPart}`
-    };
-  }
-  const repos = [];
-  for (const target of targets) {
-    const { changed, reason } = await diffRepo(target);
-    if (changed === null) {
-      repos.push({ target, changed: null, reason, outside: [], state: [] });
-      continue;
-    }
-    const allowed = [...surface.byRepo.get(target.repo) ?? [], ...surface.unqualified];
-    const state = changed.filter(isStatePath);
-    const product = changed.filter((path) => !isStatePath(path));
-    repos.push({
-      target,
-      changed: product,
-      reason: null,
-      outside: product.filter((path) => !inSurface(path, allowed)),
-      state
-    });
-  }
-  const measured = repos.filter((repo) => repo.changed !== null);
-  if (measured.length === 0) {
-    const why = repos.map((repo) => repo.reason ?? "unavailable").join("; ");
-    return { ok: true, detail: `n/a (nothing could be diffed: ${why})${excludedPart}` };
-  }
-  const audited = measured.reduce((sum, repo) => sum + (repo.changed?.length ?? 0), 0);
-  const outside = measured.flatMap((repo) => repo.outside.map((path) => `${repo.target.repo}:${path}`));
-  const unread = repos.filter((repo) => repo.changed === null);
-  const unreadPart = unread.length === 0 ? "" : `; not diffed: ${unread.map((repo) => repo.reason ?? "unavailable").join(", ")}`;
-  const range = measured.map((repo) => `${repo.target.repo} ${repo.target.base}...${repo.target.branch}`).join(", ");
-  if (outside.length === 0) {
-    return {
-      ok: true,
-      detail: `${String(audited)} changed path(s), 0 outside the surface (${range})${unreadPart}${excludedPart}`
-    };
-  }
-  const named = outside.slice(0, NAMED_PATHS);
-  const rest = outside.length - named.length;
-  return {
-    ok: false,
-    detail: `${String(audited)} changed path(s), ${String(outside.length)} outside the surface: ` + `${named.join(", ")}${rest > 0 ? `, +${String(rest)} more` : ""}` + `${unreadPart}${excludedPart}; ${OUTSIDE_SURFACE}`
-  };
-}
-function readText2(path) {
-  if (!existsSync42(path))
-    return "";
-  try {
-    return readFileSync38(path, "utf8");
-  } catch {
-    return "";
-  }
-}
-function readYaml(path) {
-  const text3 = readText2(path);
-  if (text3 === "")
-    return null;
-  try {
-    return parseYaml(text3);
-  } catch {
-    return null;
-  }
-}
-function readFront(path) {
-  const text3 = readText2(path);
-  if (text3 === "")
-    return null;
-  const parsed = parseFrontMatter(text3);
-  const doc = parsed.doc;
-  if (doc === null || typeof doc !== "object" || Array.isArray(doc))
-    return null;
-  return doc;
-}
-function stringList2(value) {
-  if (!Array.isArray(value))
-    return [];
-  return value.filter((item) => typeof item === "string");
-}
-
 // src/core/run/autoGate.ts
 var AUTO_GATE_ACTOR = "auto";
 async function evaluateAutoGate(input) {
@@ -29696,11 +30002,11 @@ function gateTimeoutNotification(ctx, costUsd, waitedMs, policy = null) {
     }
   };
 }
-function stageDoneNotification(ctx, costUsd, unmetered = 0) {
+function stageDoneNotification(ctx, costUsd, unmetered = 0, note = null) {
   const figure = spentFigure({ usd: costUsd, unmetered, metered: unmetered > 0 && costUsd === 0 ? 0 : 1 });
   return {
     ...base(ctx, "stage.done"),
-    summary: `${ctx.runId} finished ${ctx.stage ?? "a stage"} for ${figure} and moved on. ` + "No decision is waiting on you.",
+    summary: `${ctx.runId} finished ${ctx.stage ?? "a stage"} for ${figure} and moved on. ` + (note === null ? "No decision is waiting on you." : note),
     command: null,
     detail: { cost_usd: costUsd, ...unmetered === 0 ? {} : { unmetered_tasks: unmetered } }
   };
@@ -29718,12 +30024,12 @@ function budgetNotification(ctx, spentUsd, ceilingUsd, tally = { usd: spentUsd,
     }
   };
 }
-function runEndNotification(ctx, exitCode, spentUsd, lastLine2, tally = { usd: spentUsd, unmetered: 0, metered: 1 }) {
+function runEndNotification(ctx, exitCode, spentUsd, lastLine2, tally = { usd: spentUsd, unmetered: 0, metered: 1 }, note = null) {
   const kind = exitCode === 0 ? "run.finished" : "run.failed";
   const verb = exitCode === 0 ? "finished" : "stopped";
   return {
     ...base(ctx, kind),
-    summary: `${ctx.runId}: the loop ${verb} with exit ${String(exitCode)} ` + `(${exitFamily(exitCode)}), ${spentFigure(tally)} spent by this loop. ${lastLine2}`,
+    summary: `${ctx.runId}: the loop ${verb} with exit ${String(exitCode)} ` + `(${exitFamily(exitCode)}), ${spentFigure(tally)} spent by this loop. ${lastLine2}` + `${note === null ? "" : ` ${note}`}`,
     command: exitCode === 0 ? null : `tldrx run status ${ctx.runId}`,
     detail: {
       exit_code: exitCode,
@@ -32762,10 +33068,11 @@ function renderBuildHandoff(parts) {
     "",
     "## Unknowns",
     "",
-    ...notDone.length === 0 && (parts.carried ?? []).length === 0 && (parts.unreadableStories ?? []).length === 0 ? [`- none — every scheduled story reached \`done\` and no carried finding is unowned ` + `[src: absent:04-build/log]`] : [],
+    ...notDone.length === 0 && (parts.carried ?? []).length === 0 && (parts.unreadableStories ?? []).length === 0 && (parts.foreignWork ?? []).length === 0 ? [`- none — every scheduled story reached \`done\` and no carried finding is unowned ` + `[src: absent:04-build/log]`] : [],
     ...notDone.map((o) => `- ${o.id} is \`${o.status}\` and needs a human: ${o.reason ?? "see the review"} ` + `[src: ${o.reviewRel}:1]`),
     ...carriedBullets(parts.carried ?? []),
     ...(parts.unreadableStories ?? []).map((row2) => `- a story file could not be read, so its carried findings were not checked: ` + `\`${row2.rel}\` — ${row2.reason} [src: absent:${row2.rel}]`),
+    ...(parts.foreignWork ?? []).map((row2) => `- uncommitted work this stage set aside in \`${row2.repo}\` was NOT restored and needs a human: ` + `stash \`${row2.stashRef.slice(0, 12)}\` still holds ${row2.paths.join(", ")} — ${row2.detail}. ` + `Take it back with \`${row2.command === "" ? `git -C <${row2.repo}> stash list` : row2.command}\` ` + `[src: absent:04-build/log]`),
     "",
     "## Evidence ledger",
     "",
@@ -33324,36 +33631,65 @@ async function foreignEpicRefusal(state, parts, stories) {
   }
   return null;
 }
+function relaunchCommand(mode, runId) {
+  return mode === "headless" ? `tldrx run auto ${runId}` : "tldrx next";
+}
 async function dirtyRepoRefusal(parts, stories) {
   const seen = new Set;
+  const aside = [];
   let ignored = 0;
+  const refuse2 = (refusal) => ({ refusal, ignored, aside: [] });
   for (const planned of stories) {
     const name = planned.story.repo;
     if (seen.has(name))
       continue;
     seen.add(name);
     const dir = repoDirOf(parts.workspace, name);
-    const split = partitionDirty(await dirtyPaths(dir), stateDirPrefixes(parts.workspace.root, dir));
-    ignored += split.state.length;
-    const dirty = split.product;
-    if (dirty.length === 0)
+    const entries = await dirtyEntries(dir);
+    const touches = stories.filter((row2) => row2.story.repo === name).flatMap((row2) => [...row2.story.touches]);
+    const verdict2 = classifyDirty({
+      entries,
+      statePrefixes: stateDirPrefixes(parts.workspace.root, dir),
+      touches,
+      submodules: await submodulePaths(dir)
+    });
+    ignored += verdict2.own.length;
+    if (verdict2.foreign.length === 0 && verdict2.overlapping.length === 0)
       continue;
     const branch = await currentBranch(dir);
-    return { ignored, refusal: {
-      lines: [
-        `[tldrx] build: repo \`${name}\` has ${String(dirty.length)} uncommitted change(s) on ` + `\`${branch}\` — refusing to cut an epic branch from a dirty tree.`,
-        `  ${dirty.slice(0, 5).join(", ")}${dirty.length > 5 ? `, +${String(dirty.length - 5)} more` : ""}`,
-        "  Why: the base pre-flight runs in this checkout, so uncommitted product changes here",
-        "  land inside the measurement that decides whether a red DoD is the story's fault.",
-        "  Commit them, or set them aside and take them back afterwards:",
-        `    git -C ${dir} stash push -u -m "tldrx ${parts.runId} foreign work"`,
-        "    tldrx next",
-        `    git -C ${dir} stash pop`
-      ],
-      error: `repo \`${name}\` has uncommitted changes`
-    } };
+    const busy = await operationInProgress(dir);
+    if (busy !== null) {
+      return refuse2({
+        lines: [
+          `[tldrx] build: repo \`${name}\` is in the middle of ${busy} on \`${branch}\` — refusing to cut ` + "an epic branch, and refusing to stash anything into that state.",
+          `  ${namePaths(entries.map((entry) => entry.entry))}`,
+          `  Finish or abort ${busy} first, then run \`${relaunchCommand(parts.mode, parts.runId)}\`.`
+        ],
+        error: `repo \`${name}\` is in the middle of ${busy}`
+      });
+    }
+    if (verdict2.overlapping.length > 0) {
+      const paths = verdict2.overlapping.map((row2) => row2.entry.path);
+      const setAside = verdict2.foreign.map((entry) => entry.path);
+      return refuse2({
+        lines: [
+          `[tldrx] build: repo \`${name}\` has ${String(paths.length)} uncommitted change(s) on ` + `\`${branch}\` that a pending story is about to write — refusing to cut an epic branch ` + "from a dirty tree.",
+          `  ${namePaths(verdict2.overlapping.map((row2) => row2.entry.entry))}`,
+          ...verdict2.overlapping.slice(0, NAMED_PATHS2).map((row2) => `  · ${row2.entry.path}: ${row2.why}`),
+          "  Why: the base pre-flight runs in this checkout, so uncommitted product changes here",
+          "  land inside the measurement that decides whether a red DoD is the story's fault.",
+          "  Commit them, or set exactly these paths aside and take them back afterwards:",
+          `    ${stashCommand(dir, parts.runId, paths)}`,
+          `    ${relaunchCommand(parts.mode, parts.runId)}`,
+          `    git -C ${shellQuote2(dir)} stash pop`,
+          ...setAside.length === 0 ? [] : [`  The other ${String(setAside.length)} change(s) here are nobody's story — ` + "the engine would have set those aside and given them back itself."]
+        ],
+        error: `repo \`${name}\` has uncommitted changes a pending story declares`
+      });
+    }
+    aside.push({ repo: name, repoDir: dir, paths: verdict2.foreign.map((entry) => entry.path) });
   }
-  return { refusal: null, ignored };
+  return { refusal: null, ignored, aside };
 }
 function epicRows(state, parts, outcomes) {
   const rows = [];
@@ -35659,20 +35995,28 @@ async function buildExecutor(ctx) {
     epicBranches: [...session.claimedEpics],
     branchModel: session.branchModel.kind
   };
+  const withRestore = async (outcome) => {
+    const lines = await session.restoreForeignWorkAside();
+    return withClaims(lines.length === 0 ? outcome : { ...outcome, lines: [...outcome.lines, ...lines] });
+  };
   try {
     if (ctx.mode === "prepare") {
-      return withClaims(ctx.review ? await session.prepareReviewOnly() : await session.prepare());
+      return await withRestore(ctx.review ? await session.prepareReviewOnly() : await session.prepare());
     }
     if (ctx.mode === "commit") {
-      return withClaims(ctx.review ? await session.commitReview() : await session.commit());
+      return await withRestore(ctx.review ? await session.commitReview() : await session.commit());
     }
-    return withClaims(await session.runAll());
+    return await withRestore(await session.runAll());
   } catch (error) {
     if (error instanceof BaseGateFailure)
-      return withClaims(refusedOnBase(session, error));
+      return await withRestore(refusedOnBase(session, error));
     if (error instanceof GitError || error instanceof PlanLoadError) {
-      return withClaims(failed3(ctx, error.message, session.tasks));
+      const outcome = failed3(ctx, error.message, session.tasks);
+      return await withRestore({ ...outcome, lines: [...session.reportLines, ...outcome.lines] });
     }
+    try {
+      await session.restoreForeignWorkAside();
+    } catch {}
     throw error;
   }
 }
@@ -35686,6 +36030,7 @@ function refusedOnBase(session, error) {
     costUsd: session.tasks.reduce((sum, task2) => sum + task2.costUsd, 0),
     outputs: [],
     lines: [
+      ...session.reportLines,
       `[tldrx] build: ${who} was not blocked — its Definition of Done failed for a reason the base tree shares.`,
       ...baseRefusalLines([error.result])
     ],
@@ -35774,6 +36119,9 @@ class BuildSession {
   branchModel;
   writes = new SerialQueue;
   advisories = [];
+  restores = [];
+  restoreAttempted = new Set;
+  aside = [];
   preflight;
   lanes;
   constructor(ctx, workspace, plan, opening = []) {
@@ -35791,7 +36139,7 @@ class BuildSession {
       this.advisories.push(plan.priceIssue);
   }
   async runAll() {
-    const refusal = await this.refuseOnDirtyRepos() ?? await this.refuseOnForeignEpic() ?? await this.refuseOnRedBase();
+    const refusal = await this.refuseOnDirtyRepos() ?? await this.refuseOnForeignEpic() ?? await this.setAsideForeign() ?? await this.refuseOnRedBase();
     if (refusal !== null)
       return refusal;
     this.recordGateFeedback();
@@ -35832,7 +36180,7 @@ class BuildSession {
     const planned = this.nextPending();
     if (planned === null)
       return await this.finish();
-    const refusal = await this.refuseOnDirtyRepos() ?? await this.refuseOnForeignEpic() ?? await this.refuseOnRedBase();
+    const refusal = await this.refuseOnDirtyRepos() ?? await this.refuseOnForeignEpic() ?? await this.setAsideForeign() ?? await this.refuseOnRedBase();
     if (refusal !== null)
       return refusal;
     const review = this.reviewWorkFor(planned);
@@ -35914,7 +36262,7 @@ class BuildSession {
     const planned = this.nextPending();
     if (planned === null)
       return await this.finish();
-    const refusal = await this.refuseOnDirtyRepos() ?? await this.refuseOnForeignEpic();
+    const refusal = await this.refuseOnDirtyRepos() ?? await this.refuseOnForeignEpic() ?? await this.setAsideForeign();
     if (refusal !== null)
       return refusal;
     const work = this.reviewWorkFor(planned) ?? this.reviewWorkFromLedger(planned);
@@ -36878,6 +37226,7 @@ class BuildSession {
     return existsSync74(buildRetroPath(this.ctx.runDir)) ? [RETRO_REL] : [];
   }
   async finish() {
+    const restored = await this.restoreForeignWorkAside();
     const outcomes = this.orderedOutcomes();
     const done = outcomes.filter((o) => o.status === "done").length;
     this.writeHandoff(outcomes);
@@ -36891,7 +37240,8 @@ class BuildSession {
       lines: [
         `${this.ctx.phaseId}/${this.ctx.stageId}: ${String(done)} of ${String(outcomes.length)} story(ies) done ` + `across ${String(this.plan.waves.length)} wave(s)`,
         ...this.lines,
-        `wrote ${HANDOFF_REL2}`
+        `wrote ${HANDOFF_REL2}`,
+        ...restored
       ],
       stderr: [...this.advisories],
       error: null
@@ -36918,7 +37268,14 @@ class BuildSession {
       storiesRel: this.plan.implicit ? IMPLICIT_PLAN_REL : null,
       carried: carried.rows,
       unreadableStories: carried.unreadable,
-      widenings: this.wideningRows()
+      widenings: this.wideningRows(),
+      foreignWork: unrestored(this.restores).map((outcome) => ({
+        repo: outcome.stash.repo,
+        paths: outcome.conflicts.length > 0 ? outcome.conflicts : outcome.stash.paths,
+        stashRef: outcome.stash.hash,
+        command: outcome.command,
+        detail: outcome.detail
+      }))
     }), "utf8");
   }
   carriedRows() {
@@ -37066,13 +37423,17 @@ class BuildSession {
       tasks: [],
       costUsd: 0,
       outputs: [],
-      lines: refusal.lines,
+      lines: [...this.lines, ...refusal.lines],
       error: refusal.error
     };
   }
+  get reportLines() {
+    return this.lines;
+  }
   async refuseOnDirtyRepos() {
-    const { refusal, ignored } = await dirtyRepoRefusal(this.claimParts, this.pendingStories());
-    if (refusal !== null) {
+    const plan = await dirtyRepoRefusal({ ...this.claimParts, mode: this.ctx.mode }, this.pendingStories());
+    this.aside = plan.aside;
+    if (plan.refusal !== null) {
       return {
         ok: false,
         refused: true,
@@ -37080,15 +37441,65 @@ class BuildSession {
         tasks: [],
         costUsd: 0,
         outputs: [],
-        lines: refusal.lines,
-        error: refusal.error
+        lines: plan.refusal.lines,
+        error: plan.refusal.error
       };
     }
-    if (ignored > 0) {
-      this.lines.push(`  · ignoring ${String(ignored)} tldrx state file(s) in the dirty-tree check`);
+    if (plan.ignored > 0) {
+      this.lines.push(`  · ignoring ${String(plan.ignored)} tldrx state file(s) in the dirty-tree check`);
+    }
+    return null;
+  }
+  async setAsideForeign() {
+    for (const row2 of this.aside) {
+      const reason = "uncommitted work no pending story declares in its `touches:` — set aside so the " + "base pre-flight measures the tree the stories are cut from";
+      const outcome = await setAsideForeignWork(row2.repo, row2.repoDir, this.ctx.runId, row2.paths);
+      if (outcome.stash === null) {
+        return {
+          ok: false,
+          refused: true,
+          awaiting: false,
+          tasks: [],
+          costUsd: 0,
+          outputs: [],
+          lines: [
+            `[tldrx] build: repo \`${row2.repo}\` has ${String(row2.paths.length)} uncommitted change(s) that ` + `are nobody's story, and they could not be set aside: ${outcome.reason ?? "no reason given"}.`,
+            `  ${namePaths(row2.paths)}`,
+            "  Commit them, or set them aside by hand, then run " + `\`${relaunchCommand(this.ctx.mode, this.ctx.runId)}\`.`
+          ],
+          error: `repo \`${row2.repo}\` has uncommitted changes that could not be set aside`
+        };
+      }
+      this.ctx.emit(FOREIGN_ASIDE_EVENT, asidePayload(outcome.stash, reason));
+      this.lines.push(`  · ${row2.repo}: ${String(row2.paths.length)} uncommitted change(s) nobody's story declares — ` + `set aside in stash ${outcome.stash.hash.slice(0, 12)} (${namePaths(row2.paths)}) and ` + "given back when this stage ends");
     }
     return null;
   }
+  async restoreForeignWorkAside() {
+    let open;
+    try {
+      open = pendingAsides(readFileSync68(join91(this.ctx.runDir, EVENTS_FILE2), "utf8"), (repo) => {
+        try {
+          return repoDirOf(this.workspace, repo);
+        } catch {
+          return null;
+        }
+      });
+    } catch {
+      return [];
+    }
+    const lines = [];
+    for (const stash of open) {
+      if (this.restoreAttempted.has(stash.hash))
+        continue;
+      this.restoreAttempted.add(stash.hash);
+      const outcome = await restoreForeignWork(stash);
+      this.restores.push(outcome);
+      this.ctx.emit(FOREIGN_RESTORED_EVENT, restoredPayload(outcome));
+      lines.push(outcome.restored ? `  · ${restoredLine(outcome)}` : `[tldrx] build: ${notRestoredLine(outcome)}`);
+    }
+    return lines;
+  }
   pendingStories() {
     const rows = [];
     for (const wave of this.plan.waves) {
@@ -39004,7 +39415,9 @@ function tokenSplit(inputTokens, outputTokens) {
   return {};
 }
 function out(code, lines, stderr = []) {
-  return stderr.length === 0 ? { code, lines } : { code, lines, stderr };
+  const held2 = lines.filter((line) => line.includes(NOT_RESTORED_MARK));
+  const ordered = held2.length === 0 ? lines : [...lines.filter((line) => !line.includes(NOT_RESTORED_MARK)), ...held2];
+  return stderr.length === 0 ? { code, lines: ordered } : { code, lines: ordered, stderr };
 }
 
 // src/core/facilitator/runAuto.ts
@@ -39081,11 +39494,18 @@ async function runAuto(options) {
     if (heartbeat !== null)
       clearInterval(heartbeat);
     if (notifier !== null) {
-      await notifier.send(runEndNotification(notifyCtx(), code, spentUsd, lines[lines.length - 1] ?? "", loopTally(RunStore.open(runDir2).run, spentUsd)), stageIdOf());
+      await notifier.send(runEndNotification(notifyCtx(), code, spentUsd, lines[lines.length - 1] ?? "", loopTally(RunStore.open(runDir2).run, spentUsd), heldForeignWork()), stageIdOf());
       await notifier.drain();
     }
     return { code, lines };
   };
+  const heldForeignWork = () => {
+    try {
+      return notRestoredSummary(readFileSync70(join93(runDir2, "events.jsonl"), "utf8"));
+    } catch {
+      return null;
+    }
+  };
   const openQuestions2 = () => {
     const ctx = cursorContext(runDir2, runId);
     return ctx === null ? null : questionsCard(ctx);
@@ -39126,7 +39546,7 @@ async function runAuto(options) {
       if (event4.type === "stage.done") {
         const stage2 = flatten(RunStore.open(runDir2).run).find((entry) => entry.stage.id === event4.stage);
         const unmetered = stage2 === undefined ? 0 : stage2.stage.tasks.filter((task2) => task2.metered === false).length;
-        await notifier.send(stageDoneNotification(notifyCtx(), number2(payload(event4, "cost_usd")), unmetered), event4.stage);
+        await notifier.send(stageDoneNotification(notifyCtx(), number2(payload(event4, "cost_usd")), unmetered, heldForeignWork()), event4.stage);
       }
     }
     return { costUsd: null, deferredGate: null };
@@ -39537,7 +39957,7 @@ function event4(options, runId, payload2) {
   return { ts: options.at, run: runId, stage: null, type: "run.attended", actor: options.actor, cost_usd: 0, payload: payload2 };
 }
 // src/core/status/initQuestionsItem.ts
-import { existsSync as existsSync75, readFileSync as readFileSync70 } from "node:fs";
+import { existsSync as existsSync75, readFileSync as readFileSync71 } from "node:fs";
 import { join as join94 } from "node:path";
 var MAX_LISTED = 5;
 function initQuestionsItem(root2) {
@@ -39546,7 +39966,7 @@ function initQuestionsItem(root2) {
     return null;
   let open;
   try {
-    open = openBlocks(parseQuestions(readFileSync70(path, "utf8")).blocks);
+    open = openBlocks(parseQuestions(readFileSync71(path, "utf8")).blocks);
   } catch {
     return null;
   }
@@ -39566,7 +39986,7 @@ function initQuestionsItem(root2) {
 }
 
 // src/core/status/seedSplitItems.ts
-import { closeSync as closeSync2, existsSync as existsSync77, openSync as openSync2, readSync, readdirSync as readdirSync27, readFileSync as readFileSync71, statSync as statSync21 } from "node:fs";
+import { closeSync as closeSync2, existsSync as existsSync77, openSync as openSync2, readSync, readdirSync as readdirSync27, readFileSync as readFileSync72, statSync as statSync21 } from "node:fs";
 import { basename as basename12, join as join96, relative as relative18 } from "node:path";
 
 // src/core/seed/triageInventory.ts
@@ -39766,7 +40186,7 @@ function proposedSplits(root2) {
     try {
       if (!statSync21(dir).isDirectory() || !existsSync77(path))
         continue;
-      const file = readSplitFile(parseYaml(readFileSync71(path, "utf8")));
+      const file = readSplitFile(parseYaml(readFileSync72(path, "utf8")));
       if (file.status !== "proposed" && file.status !== "applying")
         continue;
       found.push({ path, rel: toRel(root2, path), dir, file });
@@ -39834,7 +40254,7 @@ function seedDocuments2(dir, file) {
   const inventory = join96(dir, "inventory.json");
   if (existsSync77(inventory)) {
     try {
-      const doc = JSON.parse(readFileSync71(inventory, "utf8"));
+      const doc = JSON.parse(readFileSync72(inventory, "utf8"));
       const rels2 = (doc.documents ?? []).map((row2) => row2.rel).filter((rel) => typeof rel === "string");
       if (rels2.length > 0)
         return rels2;
@@ -39870,7 +40290,7 @@ function cachedStatuses(dir) {
   if (!existsSync77(inventory))
     return out2;
   try {
-    const doc = JSON.parse(readFileSync71(inventory, "utf8"));
+    const doc = JSON.parse(readFileSync72(inventory, "utf8"));
     for (const row2 of doc.documents ?? []) {
       if (typeof row2.rel === "string" && typeof row2.adrStatus === "string")
         out2.set(row2.rel, row2.adrStatus);
@@ -40186,7 +40606,7 @@ function resolveWorkspaceRoot(explicit, start = process.cwd()) {
   return findWorkspaceRoot2(start) ?? resolve11(start);
 }
 // src/core/experts/stageCoverage.ts
-import { existsSync as existsSync79, readdirSync as readdirSync28, readFileSync as readFileSync72, statSync as statSync22 } from "node:fs";
+import { existsSync as existsSync79, readdirSync as readdirSync28, readFileSync as readFileSync73, statSync as statSync22 } from "node:fs";
 import { join as join98 } from "node:path";
 function stagesLoadingExperts(root2) {
   const repos = workspaceRepos(root2);
@@ -40246,7 +40666,7 @@ function readStage(root2, id) {
   if (!existsSync79(path))
     return null;
   try {
-    const doc = parseYaml(readFileSync72(path, "utf8"));
+    const doc = parseYaml(readFileSync73(path, "utf8"));
     return isRecord(doc) ? doc : null;
   } catch {
     return null;
@@ -40257,7 +40677,7 @@ function workspaceRepos(root2) {
   if (!existsSync79(path))
     return [];
   try {
-    const doc = parseYaml(readFileSync72(path, "utf8"));
+    const doc = parseYaml(readFileSync73(path, "utf8"));
     const list = isRecord(doc) && Array.isArray(doc.repos) ? doc.repos : [];
     return list.map((row2) => isRecord(row2) && typeof row2.name === "string" ? row2.name : "").filter((name) => name !== "");
   } catch {
@@ -40607,7 +41027,7 @@ function sharedCitationWarnings(shared) {
   return shared.map((row2) => `warning: shared citation ${row2.src} by ${row2.experts.join(",")} — check for contradiction`);
 }
 // src/core/training/mineRuns.ts
-import { existsSync as existsSync81, readFileSync as readFileSync73, readdirSync as readdirSync29, statSync as statSync23 } from "node:fs";
+import { existsSync as existsSync81, readFileSync as readFileSync74, readdirSync as readdirSync29, statSync as statSync23 } from "node:fs";
 import { join as join101, relative as relative19 } from "node:path";
 var MAX_RUN_FILES = 24;
 var MAX_RUN_BYTES = 64 * 1024;
@@ -40644,7 +41064,7 @@ function mineRuns(options) {
     }
     let text3;
     try {
-      text3 = readFileSync73(candidate.abs, "utf8");
+      text3 = readFileSync74(candidate.abs, "utf8");
     } catch {
       notRead.push(candidate.path);
       continue;
@@ -40708,7 +41128,7 @@ function runRepos(path) {
   if (!existsSync81(path))
     return [];
   try {
-    const doc = parseYaml(readFileSync73(path, "utf8"));
+    const doc = parseYaml(readFileSync74(path, "utf8"));
     const repos = doc?.repos;
     if (!Array.isArray(repos))
       return [];
@@ -41823,7 +42243,7 @@ var statusCommand = {
 };
 
 // src/core/seed/runTriage.ts
-import { mkdirSync as mkdirSync20, readFileSync as readFileSync74, writeFileSync as writeFileSync18, existsSync as existsSync83 } from "node:fs";
+import { mkdirSync as mkdirSync20, readFileSync as readFileSync75, writeFileSync as writeFileSync18, existsSync as existsSync83 } from "node:fs";
 import { isAbsolute as isAbsolute8, join as join102, relative as relative20, resolve as resolve14 } from "node:path";
 
 // src/core/seed/renderInventory.ts
@@ -42266,7 +42686,7 @@ function readTriageResult(outDir) {
   }
   let doc;
   try {
-    doc = JSON.parse(readFileSync74(path, "utf8"));
+    doc = JSON.parse(readFileSync75(path, "utf8"));
   } catch (error) {
     throw new PendingError(`${path} is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
   }
@@ -42307,7 +42727,7 @@ function round28(n) {
 }
 
 // src/core/seed/applySplit.ts
-import { existsSync as existsSync84, readFileSync as readFileSync75, writeFileSync as writeFileSync19 } from "node:fs";
+import { existsSync as existsSync84, readFileSync as readFileSync76, writeFileSync as writeFileSync19 } from "node:fs";
 import { dirname as dirname14, isAbsolute as isAbsolute9, join as join103, relative as relative21, resolve as resolve15 } from "node:path";
 var EXIT_OK10 = 0;
 var EXIT_USAGE7 = 1;
@@ -42319,7 +42739,7 @@ function applySplit(options) {
   }
   let file;
   try {
-    file = readSplitFile(parseYaml(readFileSync75(path, "utf8")));
+    file = readSplitFile(parseYaml(readFileSync76(path, "utf8")));
   } catch (error) {
     return fail2(EXIT_USAGE7, [error instanceof SplitError ? error.message : message5(error)]);
   }
@@ -42444,7 +42864,7 @@ function splitUniverse(splitPath, file) {
   const inventory = join103(dirname14(splitPath), "inventory.json");
   if (existsSync84(inventory)) {
     try {
-      const doc = JSON.parse(readFileSync75(inventory, "utf8"));
+      const doc = JSON.parse(readFileSync76(inventory, "utf8"));
       const rels2 = (doc.documents ?? []).map((row2) => row2.rel).filter((rel) => typeof rel === "string");
       if (rels2.length > 0)
         return new Set(rels2);
@@ -42487,7 +42907,7 @@ function message5(error) {
 }
 
 // src/core/seed/answerSplitQuestion.ts
-import { existsSync as existsSync85, readFileSync as readFileSync76, writeFileSync as writeFileSync20 } from "node:fs";
+import { existsSync as existsSync85, readFileSync as readFileSync77, writeFileSync as writeFileSync20 } from "node:fs";
 import { dirname as dirname15, isAbsolute as isAbsolute10, join as join104, relative as relative22, resolve as resolve16 } from "node:path";
 var EXIT_OK11 = 0;
 var EXIT_USAGE8 = 1;
@@ -42501,7 +42921,7 @@ function answerSplitQuestion(options) {
     return { code: EXIT_NOT_FOUND9, lines: [`no such file: ${options.splitPath}`] };
   let file;
   try {
-    file = readSplitFile(parseYaml(readFileSync76(path, "utf8")));
+    file = readSplitFile(parseYaml(readFileSync77(path, "utf8")));
   } catch (error) {
     return { code: EXIT_USAGE8, lines: [error instanceof SplitError ? error.message : message6(error)] };
   }
@@ -42728,10 +43148,10 @@ import { existsSync as existsSync89 } from "node:fs";
 import { join as join107 } from "node:path";
 
 // src/core/answers/captureAnswers.ts
-import { existsSync as existsSync88, readFileSync as readFileSync79, writeFileSync as writeFileSync21 } from "node:fs";
+import { existsSync as existsSync88, readFileSync as readFileSync80, writeFileSync as writeFileSync21 } from "node:fs";
 
 // src/core/answers/stampSuperseded.ts
-import { appendFileSync as appendFileSync2, existsSync as existsSync86, readFileSync as readFileSync77, statSync as statSync24 } from "node:fs";
+import { appendFileSync as appendFileSync2, existsSync as existsSync86, readFileSync as readFileSync78, statSync as statSync24 } from "node:fs";
 import { isAbsolute as isAbsolute11, join as join105, relative as relative23 } from "node:path";
 var STAMP_MARKER = "tldrx:superseded";
 var AFFECTS_KEY = "affects";
@@ -42771,7 +43191,7 @@ function stampSuperseded(runDir2, questionsPath, block2, fact, at) {
   const questionsRel = runRelative(runDir2, questionsPath) ?? "questions.md";
   const stamped = [];
   for (const doc of affectedDocs(runDir2, questionsPath, block2)) {
-    const text3 = readFileSync77(doc.abs, "utf8");
+    const text3 = readFileSync78(doc.abs, "utf8");
     if (isStamped(text3, fact))
       continue;
     const lead = text3 === "" ? "" : text3.endsWith(`
@@ -42845,7 +43265,7 @@ function reposFromAffects(affects, repoNames) {
 }
 
 // src/core/answers/raiseConflict.ts
-import { appendFileSync as appendFileSync3, existsSync as existsSync87, readFileSync as readFileSync78 } from "node:fs";
+import { appendFileSync as appendFileSync3, existsSync as existsSync87, readFileSync as readFileSync79 } from "node:fs";
 import { join as join106 } from "node:path";
 var RAISED_BY = "tldrx";
 function nextQuestionId(runDir2) {
@@ -42856,7 +43276,7 @@ function nextQuestionId(runDir2) {
       continue;
     let blocks;
     try {
-      blocks = parseQuestions(readFileSync78(path, "utf8")).blocks;
+      blocks = parseQuestions(readFileSync79(path, "utf8")).blocks;
     } catch {
       continue;
     }
@@ -42934,7 +43354,7 @@ function factWasTruncated(title, answer2) {
 function captureAnswers(questionsPath, ctx) {
   if (!existsSync88(questionsPath))
     return [];
-  let doc = parseQuestions(readFileSync79(questionsPath, "utf8"));
+  let doc = parseQuestions(readFileSync80(questionsPath, "utf8"));
   const answered = detectAnswered(doc.blocks);
   if (answered.length === 0)
     return [];
@@ -43068,7 +43488,7 @@ function supersedeAnswer(questionsPath, qid, text3, ctx) {
   const answer2 = text3.trim();
   if (answer2 === "")
     throw new AnswerError("a superseding answer cannot be empty");
-  const doc = parseQuestions(readFileSync79(questionsPath, "utf8"));
+  const doc = parseQuestions(readFileSync80(questionsPath, "utf8"));
   const block2 = doc.blocks.find((b) => b.id === qid);
   if (block2 === undefined)
     throw new AnswerError(`${qid} is not in ${questionsPath}`);
@@ -43149,7 +43569,7 @@ function writeAnswerSlot(questionsPath, qid, text3) {
     throw new AnswerError(`no questions file at ${questionsPath}`);
   if (text3.trim() === "")
     throw new AnswerError("an answer cannot be empty");
-  const doc = parseQuestions(readFileSync79(questionsPath, "utf8"));
+  const doc = parseQuestions(readFileSync80(questionsPath, "utf8"));
   const block2 = doc.blocks.find((b) => b.id === qid);
   if (block2 === undefined)
     throw new AnswerError(`${qid} is not in ${questionsPath}`);
@@ -43180,7 +43600,7 @@ function scopeRepos(names, repoNames) {
 }
 
 // src/cli/commands/answer.ts
-import { readFileSync as readFileSync80 } from "node:fs";
+import { readFileSync as readFileSync81 } from "node:fs";
 var QUESTION_ID_RE = /^Q\d{1,6}$/;
 var answerCommand2 = {
   name: "answer",
@@ -43295,7 +43715,7 @@ function locateQuestion(store, qid, status) {
     const path = join107(store.runDir, phase.id, "questions.md");
     if (!existsSync89(path))
       continue;
-    const block2 = parseQuestions(readFileSync80(path, "utf8")).blocks.find((b) => b.id === qid);
+    const block2 = parseQuestions(readFileSync81(path, "utf8")).blocks.find((b) => b.id === qid);
     if (block2 !== undefined && block2.metadata?.status === status)
       return { path, block: block2 };
   }
@@ -43303,7 +43723,7 @@ function locateQuestion(store, qid, status) {
 }
 
 // src/cli/commands/approve.ts
-import { existsSync as existsSync90, readFileSync as readFileSync81 } from "node:fs";
+import { existsSync as existsSync90, readFileSync as readFileSync82 } from "node:fs";
 import { relative as relative24 } from "node:path";
 var approveCommand2 = {
   name: "approve",
@@ -43388,7 +43808,7 @@ function readAgentEvidence(root2, store, override) {
     process.stderr.write(`tldrx approve: --as-agent refused — no evidence note at ${relative24(root2, path)}. ` + "Write one (`tldrx gate template` puts the blank form there), then sign with it.\n");
     return { kind: "stop", exit: EXIT_GATE_REFUSED };
   }
-  const text3 = readFileSync81(path, "utf8");
+  const text3 = readFileSync82(path, "utf8");
   const gate2 = `${entry.phase.id}/${entry.stage.id}`;
   const validation = validateEvidence(text3, toSrcContext(loadWorkspace(root2), store.runDir, { epicRefs: true }), { gate: gate2 });
   const refusals = validation.issues.filter((issue) => issue.kind === "verdict");
@@ -43964,7 +44384,7 @@ function template(argv) {
 }
 
 // src/core/run/reopenStory.ts
-import { existsSync as existsSync92, readFileSync as readFileSync82, writeFileSync as writeFileSync23 } from "node:fs";
+import { existsSync as existsSync92, readFileSync as readFileSync83, writeFileSync as writeFileSync23 } from "node:fs";
 import { join as join108 } from "node:path";
 var EXIT_OK12 = 0;
 var EXIT_REFUSED8 = 2;
@@ -44064,7 +44484,7 @@ function reopenStory(options) {
   }
   let patched;
   try {
-    const text3 = readFileSync82(path, "utf8");
+    const text3 = readFileSync83(path, "utf8");
     patched = progress.implicit ? updateImplicitPlan(text3, { status: REOPENED_TO }) : updateStoryFront(text3, { status: REOPENED_TO });
   } catch (error) {
     if (error instanceof StoryWriteError) {
@@ -44152,7 +44572,7 @@ function refuse3(lines) {
 }
 
 // src/core/run/widenStory.ts
-import { existsSync as existsSync93, readFileSync as readFileSync83, writeFileSync as writeFileSync24 } from "node:fs";
+import { existsSync as existsSync93, readFileSync as readFileSync84, writeFileSync as writeFileSync24 } from "node:fs";
 import { join as join109 } from "node:path";
 var EXIT_OK13 = 0;
 var EXIT_REFUSED9 = 2;
@@ -44232,7 +44652,7 @@ function widenStory(options) {
   if (!existsSync93(path)) {
     return refuse4([`${id} is \`${row2.status}\` but ${path} is not on disk — refusing to write a file that is not there`]);
   }
-  const text3 = readFileSync83(path, "utf8");
+  const text3 = readFileSync84(path, "utf8");
   const before = touchesIn(text3, progress.implicit);
   if (before === null) {
     return refuse4([
@@ -44557,7 +44977,7 @@ function firstProblem(text3, area, kind, confidence, decidedBy) {
 }
 
 // src/core/run/ship.ts
-import { existsSync as existsSync94, mkdtempSync as mkdtempSync2, readFileSync as readFileSync84, rmSync as rmSync11, writeFileSync as writeFileSync25 } from "node:fs";
+import { existsSync as existsSync94, mkdtempSync as mkdtempSync2, readFileSync as readFileSync85, rmSync as rmSync11, writeFileSync as writeFileSync25 } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
 import { dirname as dirname17, join as join110, resolve as resolve17 } from "node:path";
 
@@ -45048,7 +45468,7 @@ function lastHandoff(runDir2, phases) {
       continue;
     let text3;
     try {
-      text3 = readFileSync84(path, "utf8");
+      text3 = readFileSync85(path, "utf8");
     } catch {
       continue;
     }
@@ -45171,11 +45591,11 @@ var shipCommand = {
 import { join as join113 } from "node:path";
 
 // src/core/plan/syncDod.ts
-import { existsSync as existsSync96, readdirSync as readdirSync30, readFileSync as readFileSync86 } from "node:fs";
+import { existsSync as existsSync96, readdirSync as readdirSync30, readFileSync as readFileSync87 } from "node:fs";
 import { join as join112 } from "node:path";
 
 // src/core/plan/workspaceHistory.ts
-import { existsSync as existsSync95, readFileSync as readFileSync85, realpathSync } from "node:fs";
+import { existsSync as existsSync95, readFileSync as readFileSync86, realpathSync } from "node:fs";
 import { join as join111, relative as relative26, sep as sep10 } from "node:path";
 var WORKSPACE_REL = `${PROJECT_FRAMEWORK_DIR}/workspace.yml`;
 var MAX_VERSIONS = 50;
@@ -45183,7 +45603,7 @@ async function readWorkspaceHistory(root2) {
   const documents = [];
   const live2 = join111(root2, WORKSPACE_REL);
   if (existsSync95(live2)) {
-    const parsed = parse(readFileSync85(live2, "utf8"));
+    const parsed = parse(readFileSync86(live2, "utf8"));
     if (parsed !== null)
       documents.push(parsed);
   }
@@ -45273,7 +45693,7 @@ function planSyncDod(input) {
   };
 }
 function syncOne(path, name, input) {
-  const text3 = readFileSync86(path, "utf8");
+  const text3 = readFileSync87(path, "utf8");
   const id = name.replace(/\.md$/, "");
   const rel = `${STORIES_DIR}/${name}`;
   const repo = readStory(text3).repo ?? "";
@@ -45868,7 +46288,7 @@ function refusal(input, model2, share, expected) {
   ];
 }
 // src/core/training/ambientModel.ts
-import { readFileSync as readFileSync87 } from "node:fs";
+import { readFileSync as readFileSync88 } from "node:fs";
 import { join as join115 } from "node:path";
 function ambientModelFiles(root2, home) {
   return [
@@ -45891,7 +46311,7 @@ function resolveAmbientModel(input) {
 function modelIn(path) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync87(path, "utf8"));
+    parsed = JSON.parse(readFileSync88(path, "utf8"));
   } catch {
     return null;
   }
@@ -45963,11 +46383,11 @@ function noEvidenceNote(costUsd, added, warnings) {
   return lines;
 }
 // src/core/training/rescoreExperts.ts
-import { readFileSync as readFileSync90 } from "node:fs";
+import { readFileSync as readFileSync91 } from "node:fs";
 import { relative as relative27 } from "node:path";
 
 // src/core/training/competenciesWrite.ts
-import { existsSync as existsSync98, mkdirSync as mkdirSync22, readFileSync as readFileSync88, writeFileSync as writeFileSync26 } from "node:fs";
+import { existsSync as existsSync98, mkdirSync as mkdirSync22, readFileSync as readFileSync89, writeFileSync as writeFileSync26 } from "node:fs";
 import { dirname as dirname18, join as join117 } from "node:path";
 var HEADER = "# Written by `tldrx expert train` (spec §2.6). `level` is computed, never hand-set.\n";
 
@@ -45977,7 +46397,7 @@ function readDocument(root2, expert) {
   const path = join117(expertDir(root2, expert), COMPETENCIES_FILE);
   if (!existsSync98(path))
     throw new CompetenciesError(`${path} is missing — \`tldrx expert create\` writes it`);
-  const text3 = readFileSync88(path, "utf8");
+  const text3 = readFileSync89(path, "utf8");
   const parsed = parseYaml(text3);
   if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
     throw new CompetenciesError(`${path} is not a mapping`);
@@ -46090,7 +46510,7 @@ function str11(value) {
 }
 
 // src/core/training/trainingLog.ts
-import { appendFileSync as appendFileSync4, existsSync as existsSync99, mkdirSync as mkdirSync23, readFileSync as readFileSync89, statSync as statSync26 } from "node:fs";
+import { appendFileSync as appendFileSync4, existsSync as existsSync99, mkdirSync as mkdirSync23, readFileSync as readFileSync90, statSync as statSync26 } from "node:fs";
 import { dirname as dirname19, join as join118 } from "node:path";
 var TRAINING_EVENT_TYPES = [
   "agent.spawned",
@@ -46137,7 +46557,7 @@ class TrainingLog {
     if (!existsSync99(this.path))
       return [];
     const out2 = [];
-    for (const line of readFileSync89(this.path, "utf8").split(`
+    for (const line of readFileSync90(this.path, "utf8").split(`
 `)) {
       if (line.trim() === "")
         continue;
@@ -46287,7 +46707,7 @@ function rescoreExperts(options) {
       }
       const shape = minesRunRecord ? RUNS_SHAPE : LIGHT_SHAPE;
       const scope = knowledgeScopeFor(options.root, expert, area);
-      const parsed = parseKnowledgeFile(readFileSync90(file.path, "utf8"), srcCtx, shape, scope);
+      const parsed = parseKnowledgeFile(readFileSync91(file.path, "utf8"), srcCtx, shape, scope);
       if (!parsed.ok) {
         const errors2 = knowledgeErrors(parsed).length;
         skip(`the file does not validate under today's rules — ${String(errors2)} problem(s), so it is not evidence`);
@@ -46374,7 +46794,7 @@ function rescoreJson(rows) {
   return JSON.stringify(rows, null, 2);
 }
 // src/core/training/selectFiles.ts
-import { existsSync as existsSync101, readFileSync as readFileSync91, statSync as statSync28 } from "node:fs";
+import { existsSync as existsSync101, readFileSync as readFileSync92, statSync as statSync28 } from "node:fs";
 import { join as join119 } from "node:path";
 var MAX_SCANNED_FILES2 = 4000;
 var MAX_SCAN_BYTES2 = 512 * 1024;
@@ -46514,7 +46934,7 @@ function readDomains(root2, repos) {
     const path = join119(root2, PROJECT_FRAMEWORK_DIR, "map", repo, "domains.md");
     if (!existsSync101(path))
       continue;
-    for (const line of readFileSync91(path, "utf8").split(`
+    for (const line of readFileSync92(path, "utf8").split(`
 `)) {
       if (!line.startsWith("- "))
         continue;
@@ -46543,7 +46963,7 @@ function readCommunities(root2, repos, keywords) {
     }
     let text3;
     try {
-      text3 = readFileSync91(path, "utf8");
+      text3 = readFileSync92(path, "utf8");
     } catch {
       notes.push(`${repo}: graph.json could not be read`);
       continue;
@@ -46622,7 +47042,7 @@ function matches2(label2, keywords) {
 function contentHits(abs, keywords) {
   let text3;
   try {
-    text3 = readFileSync91(abs, "utf8").toLowerCase();
+    text3 = readFileSync92(abs, "utf8").toLowerCase();
   } catch {
     return [];
   }
@@ -46633,7 +47053,7 @@ function readCapped2(abs, remaining2) {
   try {
     if (statSync28(abs).size > MAX_SCAN_BYTES2)
       return null;
-    text3 = readFileSync91(abs, "utf8");
+    text3 = readFileSync92(abs, "utf8");
   } catch {
     return null;
   }
@@ -47206,7 +47626,7 @@ function skipNoteLines(expert, area, reason) {
   return [`${expert}/${area}: skipped — ${first2 ?? ""}`, ...rest.map((line) => `  ${line}`)];
 }
 // src/core/training/strayWrite.ts
-import { existsSync as existsSync102, mkdirSync as mkdirSync24, readdirSync as readdirSync33, readFileSync as readFileSync92, renameSync as renameSync4, rmdirSync as rmdirSync2, unlinkSync, writeFileSync as writeFileSync27 } from "node:fs";
+import { existsSync as existsSync102, mkdirSync as mkdirSync24, readdirSync as readdirSync33, readFileSync as readFileSync93, renameSync as renameSync4, rmdirSync as rmdirSync2, unlinkSync, writeFileSync as writeFileSync27 } from "node:fs";
 import { dirname as dirname20, join as join121, relative as relative28, resolve as resolve19 } from "node:path";
 function findStrayWrite(probe2) {
   const root2 = resolve19(probe2.root);
@@ -47229,7 +47649,7 @@ function recoverStrayWrite(stray, dest) {
     renameSync4(stray.path, dest);
   } catch {
     try {
-      writeFileSync27(dest, readFileSync92(stray.path, "utf8"), "utf8");
+      writeFileSync27(dest, readFileSync93(stray.path, "utf8"), "utf8");
       unlinkSync(stray.path);
     } catch {
       return { stray, recovered: existsSync102(dest), leftBehind: stray.path };
@@ -47278,7 +47698,7 @@ function describeStrayRecovery(root2, recovery, rel) {
   return lines;
 }
 // src/core/training/runTraining.ts
-import { existsSync as existsSync103, mkdirSync as mkdirSync25, readFileSync as readFileSync93, renameSync as renameSync5, rmSync as rmSync12, writeFileSync as writeFileSync28 } from "node:fs";
+import { existsSync as existsSync103, mkdirSync as mkdirSync25, readFileSync as readFileSync94, renameSync as renameSync5, rmSync as rmSync12, writeFileSync as writeFileSync28 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
 import { join as join122, relative as relative29 } from "node:path";
 var EXIT_OK14 = 0;
@@ -47460,7 +47880,7 @@ async function trainWithPreflight(options, said2) {
   const previous = prompts.map((task2) => ({
     path: join122(dir, task2.final),
     partial: join122(dir, task2.output),
-    content: existsSync103(join122(dir, task2.final)) ? readFileSync93(join122(dir, task2.final), "utf8") : null
+    content: existsSync103(join122(dir, task2.final)) ? readFileSync94(join122(dir, task2.final), "utf8") : null
   }));
   const tasks = [];
   for (const task2 of prompts) {
@@ -47574,7 +47994,7 @@ async function trainWithPreflight(options, said2) {
         "  nothing was written to competencies.yml and the status is unchanged"
       ]);
     }
-    const text3 = readFileSync93(abs, "utf8");
+    const text3 = readFileSync94(abs, "utf8");
     const shape = task2.key === CODE_TASK ? LIGHT_SHAPE : RUNS_SHAPE;
     let parsed = parseKnowledgeFile(text3, srcCtx, shape, scope);
     if (!parsed.ok && options.run === "headless") {
@@ -47752,7 +48172,7 @@ async function repairRound(input) {
       parsed: null
     };
   }
-  const parsed = parseKnowledgeFile(readFileSync93(abs, "utf8"), input.srcCtx, input.shape, input.scope);
+  const parsed = parseKnowledgeFile(readFileSync94(abs, "utf8"), input.srcCtx, input.shape, input.scope);
   const left = knowledgeErrors(parsed).length;
   return {
     lines: [
@@ -47782,7 +48202,7 @@ function quarantine(abs, header2 = []) {
   try {
     const body = header2.length === 0 ? null : `${header2.join(`
 `)}
-${readFileSync93(abs, "utf8")}`;
+${readFileSync94(abs, "utf8")}`;
     rmSync12(kept, { force: true });
     renameSync5(abs, kept);
     if (body !== null)
@@ -47826,7 +48246,7 @@ function rollback(previous) {
 function setExpertStatus(path, status) {
   if (!existsSync103(path))
     return;
-  const lines = readFileSync93(path, "utf8").split(`
+  const lines = readFileSync94(path, "utf8").split(`
 `);
   if ((lines[0] ?? "").trimEnd() !== "---")
     return;
@@ -48306,7 +48726,7 @@ function message8(error) {
 import { isAbsolute as isAbsolute12, join as join128 } from "node:path";
 
 // src/core/dashboard/model.ts
-import { existsSync as existsSync105, readFileSync as readFileSync94, readdirSync as readdirSync34 } from "node:fs";
+import { existsSync as existsSync105, readFileSync as readFileSync95, readdirSync as readdirSync34 } from "node:fs";
 import { basename as basename15, join as join124 } from "node:path";
 // src/core/replay/renderReplay.ts
 function renderReplay(loaded) {
@@ -49192,7 +49612,7 @@ function readWaves(path, unreadable) {
 }
 function read2(path, unreadable, label2) {
   try {
-    return readFileSync94(path, "utf8");
+    return readFileSync95(path, "utf8");
   } catch {
     unreadable.push(label2);
     return null;
@@ -51184,6 +51604,7 @@ var LOOPBACK = "127.0.0.1";
 var LOOPBACK_HOSTNAMES = ["127.0.0.1", "localhost", "::1"];
 var DEBOUNCE_MS = 300;
 var POLL_MS = 500;
+var SWEEP_MS = 2000;
 var AGE_TICK_MS = 25000;
 var PROBE_NOW = new Date(0);
 var PROBE_STAMP = "1970-01-01T00:00:00Z";
@@ -51207,7 +51628,7 @@ async function startDashboardServer(options) {
   const tail2 = createLedgerTail(root2);
   tail2.poll();
   let shown = probe2(root2);
-  const watcher = watchWorkspace(root2, debounceMs, options.watch ?? "auto", () => {
+  const watcher = watchWorkspace(root2, debounceMs, options.watch ?? "auto", options.sweepMs ?? SWEEP_MS, () => {
     const change = tail2.poll();
     const next = probe2(root2);
     if (next !== null && shown !== null && next === shown)
@@ -51233,6 +51654,9 @@ async function startDashboardServer(options) {
     port,
     url: `http://${host}:${String(port)}`,
     watchMode: watcher.mode,
+    simulateWatcherLoss: () => {
+      watcher.dropWatchers();
+    },
     close: async () => {
       clearInterval(tick);
       watcher.close();
@@ -51348,12 +51772,13 @@ function probe2(root2) {
     return null;
   }
 }
-function watchWorkspace(root2, debounceMs, requested, onChange) {
+function watchWorkspace(root2, debounceMs, requested, sweepMs, onChange) {
   const targets = [join127(root2, PROJECT_FRAMEWORK_DIR), join127(root2, PROJECT_WORK_DIR)];
   const watchers = new Map;
   let timer = null;
   let closed = false;
   let mode = "watch";
+  let swept = "";
   const fire = () => {
     if (closed)
       return;
@@ -51362,6 +51787,7 @@ function watchWorkspace(root2, debounceMs, requested, onChange) {
     timer = setTimeout(() => {
       timer = null;
       arm();
+      swept = fingerprint(root2, targets);
       onChange();
     }, debounceMs);
     timer.unref();
@@ -51392,26 +51818,27 @@ function watchWorkspace(root2, debounceMs, requested, onChange) {
     mode = "poll";
   else
     arm();
-  let poller = null;
-  if (mode === "poll") {
-    let previous = fingerprint(root2, targets);
-    poller = setInterval(() => {
-      const next = fingerprint(root2, targets);
-      if (next !== previous) {
-        previous = next;
-        fire();
-      }
-    }, POLL_MS);
-    poller.unref();
-  }
+  swept = fingerprint(root2, targets);
+  const poller = setInterval(() => {
+    const next = fingerprint(root2, targets);
+    if (next === swept)
+      return;
+    swept = next;
+    fire();
+  }, mode === "poll" ? POLL_MS : sweepMs);
+  poller.unref();
   return {
     mode,
+    dropWatchers: () => {
+      for (const watcher of watchers.values())
+        watcher.close();
+      watchers.clear();
+    },
     close: () => {
       closed = true;
       if (timer !== null)
         clearTimeout(timer);
-      if (poller !== null)
-        clearInterval(poller);
+      clearInterval(poller);
       for (const watcher of watchers.values())
         watcher.close();
       watchers.clear();
@@ -51621,7 +52048,7 @@ function option2(argv, name) {
 import { writeFileSync as writeFileSync31 } from "node:fs";
 import { join as join130 } from "node:path";
 // src/core/retro/applyPractices.ts
-import { existsSync as existsSync107, mkdirSync as mkdirSync27, readFileSync as readFileSync95, writeFileSync as writeFileSync30 } from "node:fs";
+import { existsSync as existsSync107, mkdirSync as mkdirSync27, readFileSync as readFileSync96, writeFileSync as writeFileSync30 } from "node:fs";
 import { dirname as dirname21, join as join129 } from "node:path";
 var PRACTICES_FILE = "practices.md";
 var HEADER2 = [
@@ -51640,7 +52067,7 @@ function applyPractices(root2, run2, proposals, now = new Date) {
   if (proposals.length === 0) {
     return { path, appended: false, reason: "there are no practice proposals to apply" };
   }
-  const existing = existsSync107(path) ? readFileSync95(path, "utf8") : "";
+  const existing = existsSync107(path) ? readFileSync96(path, "utf8") : "";
   const stamp4 = `— run ${run2}`;
   if (existing.includes(stamp4)) {
     return { path, appended: false, reason: `practices.md already carries a block for run ${run2}` };
@@ -52189,7 +52616,7 @@ function theOneOpenRun() {
   }
 }
 // src/core/watch/watchViews.ts
-import { existsSync as existsSync108, readdirSync as readdirSync36, readFileSync as readFileSync96 } from "node:fs";
+import { existsSync as existsSync108, readdirSync as readdirSync36, readFileSync as readFileSync97 } from "node:fs";
 import { join as join131 } from "node:path";
 function watchersDir(runDir2) {
   return join131(runDir2, WATCH_PHASE, WATCHERS_DIR);
@@ -52201,7 +52628,7 @@ function loadCards(runDir2, ctx) {
   const cards = [];
   for (const name of readdirSync36(dir).filter((n) => n.endsWith(".md")).sort()) {
     const id = name.slice(0, -".md".length);
-    const text5 = readFileSync96(join131(dir, name), "utf8");
+    const text5 = readFileSync97(join131(dir, name), "utf8");
     cards.push({
       id,
       text: text5,
@@ -52972,7 +53399,7 @@ function quote4(value) {
   return JSON.stringify(value);
 }
 // src/core/adapters/processConfig.ts
-import { existsSync as existsSync110, readFileSync as readFileSync97 } from "node:fs";
+import { existsSync as existsSync110, readFileSync as readFileSync98 } from "node:fs";
 import { join as join133 } from "node:path";
 var PROCESS_FILE2 = "process.yml";
 var DISABLED = {
@@ -52991,7 +53418,7 @@ function readTicketToolConfig(root2) {
     return DISABLED;
   let doc;
   try {
-    doc = parseYaml(readFileSync97(path, "utf8"));
+    doc = parseYaml(readFileSync98(path, "utf8"));
   } catch {
     return { ...DISABLED, path };
   }
@@ -53153,7 +53580,7 @@ function strip(url) {
   return at === -1 ? url : url.slice(at);
 }
 // src/core/adapters/collect.ts
-import { existsSync as existsSync111, readdirSync as readdirSync37, readFileSync as readFileSync98 } from "node:fs";
+import { existsSync as existsSync111, readdirSync as readdirSync37, readFileSync as readFileSync99 } from "node:fs";
 import { join as join134 } from "node:path";
 var PLAN_PHASE3 = "03-plan";
 function collectMirrorItems(planDir, runId) {
@@ -53161,7 +53588,7 @@ function collectMirrorItems(planDir, runId) {
   const skipped = [];
   for (const name of markdownIn4(join134(planDir, EPICS_DIR))) {
     const path = join134(planDir, EPICS_DIR, name);
-    const text6 = readFileSync98(path, "utf8");
+    const text6 = readFileSync99(path, "utf8");
     const parsed = validateEpicFile(text6);
     const epic = parsed.epic;
     if (epic === null) {
@@ -53194,7 +53621,7 @@ function collectMirrorItems(planDir, runId) {
   }
   for (const name of markdownIn4(join134(planDir, STORIES_DIR))) {
     const path = join134(planDir, STORIES_DIR, name);
-    const text6 = readFileSync98(path, "utf8");
+    const text6 = readFileSync99(path, "utf8");
     const parsed = validateStoryFile(text6);
     const story = parsed.story;
     if (story === null) {
@@ -53239,7 +53666,7 @@ function reason(issues) {
   return first2.path === "" ? first2.message : `${first2.path}: ${first2.message}`;
 }
 // src/core/adapters/sync.ts
-import { readFileSync as readFileSync99, writeFileSync as writeFileSync32 } from "node:fs";
+import { readFileSync as readFileSync100, writeFileSync as writeFileSync32 } from "node:fs";
 function planSync(options) {
   const collected = collectMirrorItems(options.planDir, options.runId);
   const actions = new Map;
@@ -53283,7 +53710,7 @@ async function syncTickets(options) {
   return { results, skipped: collected.skipped, created, updated, dryRun: options.dryRun };
 }
 function writeBack(item, ref, externalStatus, sync) {
-  const before2 = readFileSync99(item.path, "utf8");
+  const before2 = readFileSync100(item.path, "utf8");
   const after = applyExternal(before2, {
     external: ref,
     ...sync === "two-way" ? { externalStatus } : {}
@@ -53535,7 +53962,7 @@ function renderSync(runId, provider, config, outcome) {
 }
 
 // src/cli/commands/interview.ts
-import { existsSync as existsSync114, readFileSync as readFileSync102 } from "node:fs";
+import { existsSync as existsSync114, readFileSync as readFileSync103 } from "node:fs";
 import { join as join137 } from "node:path";
 
 // src/core/interview/lineReader.ts
@@ -53649,7 +54076,7 @@ function renderNextSteps(hasRun) {
 }
 
 // src/core/interview/runInterview.ts
-import { existsSync as existsSync112, readFileSync as readFileSync100 } from "node:fs";
+import { existsSync as existsSync112, readFileSync as readFileSync101 } from "node:fs";
 
 // src/core/interview/reply.ts
 var LETTER_RE = /^[A-Ea-e]$/;
@@ -53690,7 +54117,7 @@ async function interview(options) {
   const { questionsPath, out: out2, ctx } = options;
   if (!existsSync112(questionsPath))
     throw new InterviewError(`no questions file at ${questionsPath}`);
-  const blocks = openBlocks(parseQuestions(readFileSync100(questionsPath, "utf8")).blocks);
+  const blocks = openBlocks(parseQuestions(readFileSync101(questionsPath, "utf8")).blocks);
   const answered = [];
   let skipped = 0;
   let quit = false;
@@ -53751,7 +54178,7 @@ function renderInterviewSummary(result2) {
 }
 
 // src/core/init/processAnswers.ts
-import { existsSync as existsSync113, readFileSync as readFileSync101 } from "node:fs";
+import { existsSync as existsSync113, readFileSync as readFileSync102 } from "node:fs";
 
 // src/core/init/githubProject.ts
 import { join as join136 } from "node:path";
@@ -53801,7 +54228,7 @@ function hasProcessAnswer(answers) {
 function collectProcessAnswers(questionsPath, answered) {
   if (answered.length === 0 || !existsSync113(questionsPath))
     return NO_PROCESS_ANSWERS;
-  const titles = new Map(parseQuestions(readFileSync101(questionsPath, "utf8")).blocks.map((block2) => [block2.id, block2.title]));
+  const titles = new Map(parseQuestions(readFileSync102(questionsPath, "utf8")).blocks.map((block2) => [block2.id, block2.title]));
   const find = (title) => answered.find((answer2) => titles.get(answer2.q) === title);
   const methodology = find(METHODOLOGY_QUESTION);
   const ticket = find(TICKET_QUESTION);
@@ -53839,7 +54266,7 @@ async function applyProcessAnswers(input) {
   }
   assertEnum(methodology, METHODOLOGIES, "methodology");
   assertEnum(ticketTool, TICKET_TOOLS, "ticket_tool.kind");
-  const before2 = existsSync113(path) ? readFileSync101(path, "utf8") : null;
+  const before2 = existsSync113(path) ? readFileSync102(path, "utf8") : null;
   const seed = before2 ?? PROCESS_HEADER + stringifyYaml(buildProcessDocument({
     methodology: null,
     approver: await gitUserName(input.runner, input.root),
@@ -54076,11 +54503,11 @@ No open questions.
   return "no-open-questions";
 }
 function countOpen(path) {
-  return openBlocks(parseQuestions(readFileSync102(path, "utf8")).blocks).length;
+  return openBlocks(parseQuestions(readFileSync103(path, "utf8")).blocks).length;
 }
 
 // src/cli/commands/questions.ts
-import { existsSync as existsSync115, readFileSync as readFileSync103, writeFileSync as writeFileSync33 } from "node:fs";
+import { existsSync as existsSync115, readFileSync as readFileSync104, writeFileSync as writeFileSync33 } from "node:fs";
 import { join as join138 } from "node:path";
 var VALUE_FLAGS15 = ["run", "root", "area"];
 var questionsCommand = {
@@ -54137,7 +54564,7 @@ function lint(argv) {
     const needSource = [];
     for (const path of files) {
       const rel = path.slice(store.runDir.length + 1);
-      const text6 = readFileSync103(path, "utf8");
+      const text6 = readFileSync104(path, "utf8");
       const readable = parseQuestions(text6).blocks.length;
       const lost = unreadableQuestionHeadings(text6);
       if (lost.length === 0) {
@@ -54302,7 +54729,7 @@ function renderFinale(ink) {
 }
 
 // src/core/learn/engine.ts
-import { existsSync as existsSync118, readdirSync as readdirSync38, readFileSync as readFileSync104 } from "node:fs";
+import { existsSync as existsSync118, readdirSync as readdirSync38, readFileSync as readFileSync105 } from "node:fs";
 import { join as join141 } from "node:path";
 
 // src/core/learn/sandbox.ts
@@ -54370,9 +54797,9 @@ function claudeShimScript(selfCmd, scriptPath) {
     "#!/bin/sh",
     "# The tutorial's stand-in for `claude`, written by `tldrx learn`.",
     "# It is not the real CLI, it never reaches a network, and it never costs anything.",
-    `${SCRIPT_ENV}=${shellQuote2(scriptPath)}`,
+    `${SCRIPT_ENV}=${shellQuote3(scriptPath)}`,
     `export ${SCRIPT_ENV}`,
-    `exec ${shellQuote2(interpreter)} ${shellQuote2(entry)} ${LEARN_AGENT_ARGV0} "$@"`,
+    `exec ${shellQuote3(interpreter)} ${shellQuote3(entry)} ${LEARN_AGENT_ARGV0} "$@"`,
     ""
   ].join(`
 `);
@@ -54381,7 +54808,7 @@ function writeClaudeShim(sandbox, selfCmd) {
   writeFileSync34(sandbox.claudeBin, claudeShimScript(selfCmd, sandbox.scriptPath), "utf8");
   chmodSync(sandbox.claudeBin, 493);
 }
-function shellQuote2(text6) {
+function shellQuote3(text6) {
   return `'${text6.replaceAll("'", `'\\''`)}'`;
 }
 function writeScript(sandbox, script) {
@@ -54576,7 +55003,7 @@ function newestRunId(sandbox) {
 }
 function runIsFinished(runDir2) {
   try {
-    const status = /^status:\s*(\S+)/m.exec(readFileSync104(join141(runDir2, "run.yml"), "utf8"))?.[1] ?? "";
+    const status = /^status:\s*(\S+)/m.exec(readFileSync105(join141(runDir2, "run.yml"), "utf8"))?.[1] ?? "";
     return isFinished(status);
   } catch {
     return false;
@@ -54617,7 +55044,7 @@ function sandboxHas(sandbox, rel) {
 }
 
 // src/core/learn/chapters.ts
-import { existsSync as existsSync119, mkdirSync as mkdirSync29, readdirSync as readdirSync39, readFileSync as readFileSync105, writeFileSync as writeFileSync35 } from "node:fs";
+import { existsSync as existsSync119, mkdirSync as mkdirSync29, readdirSync as readdirSync39, readFileSync as readFileSync106, writeFileSync as writeFileSync35 } from "node:fs";
 import { dirname as dirname23, join as join142 } from "node:path";
 var LEARN_RUN_SLUG = "bulk-pricing";
 var WATCH_PHASE_DIR = "05-watch";
@@ -55862,7 +56289,7 @@ function writeInto(path, content) {
 }
 function read3(sandbox, rel) {
   try {
-    return readFileSync105(join142(sandbox.workspace, rel), "utf8");
+    return readFileSync106(join142(sandbox.workspace, rel), "utf8");
   } catch {
     return "";
   }
@@ -55893,14 +56320,14 @@ function runIdBySlug(sandbox, slug) {
 }
 
 // src/core/learn/progress.ts
-import { existsSync as existsSync120, mkdirSync as mkdirSync30, readFileSync as readFileSync106, writeFileSync as writeFileSync36 } from "node:fs";
+import { existsSync as existsSync120, mkdirSync as mkdirSync30, readFileSync as readFileSync107, writeFileSync as writeFileSync36 } from "node:fs";
 import { dirname as dirname24 } from "node:path";
 var NO_PROGRESS = { version: 1, completed: [], updatedAt: null };
 function readProgress(path) {
   if (!existsSync120(path))
     return NO_PROGRESS;
   try {
-    const doc = JSON.parse(readFileSync106(path, "utf8"));
+    const doc = JSON.parse(readFileSync107(path, "utf8"));
     const completed = doc.completed;
     if (!Array.isArray(completed))
       return NO_PROGRESS;