@open-tomato/rafa 0.38.0 → 0.39.0

package/dist/{index-e3vhhfka.js → index-nwgwxfkt.js}

@@ -14,7 +14,7 @@ import {
   trackerPathFor,
   updateTrackerLine,
   writeTrackerBlocker
-} from "./index-zdz0mp63.js";
+} from "./index-g4116t9m.js";
 import {
   ACROSS_STORES_ORDER,
   CORE_ADAPTER_REGISTRY,
@@ -35,6 +35,7 @@ import {
   NOT_A_REPOSITORY,
   PORT_VERSIONS,
   RAFA_VERSION,
+  RECORD_EXTENSION,
   SCOPE_DIR,
   SKILL_FILE,
   SQLITE_MIGRATIONS,
@@ -77,6 +78,7 @@ import {
   oneLine,
   padKind,
   parseInstinct,
+  parseSessionRecord,
   planFileName,
   planFilePath,
   planSchema,
@@ -93,6 +95,7 @@ import {
   readScopes,
   readSession,
   readSessions,
+  readState,
   readStoreMeta,
   readStoreSchema,
   readSwitch,
@@ -126,7 +129,7 @@ import {
   writeNames,
   writePositionFile,
   writeSqliteStore
-} from "./index-74btmn1e.js";
+} from "./index-1r2b1052.js";
 import {
   CHANGE_LEVELS,
   CONFIG_DEFAULTS,
@@ -135,6 +138,7 @@ import {
   FINDING_KINDS,
   FINDING_SIGNALS,
   PREREQUISITE_KINDS,
+  RELEASE_DEFAULTS,
   REPORT_STATUSES,
   SETTINGS,
   activeOutput,
@@ -154,7 +158,7 @@ import {
   requiredPrerequisite,
   resolveTiers,
   stampPrompt
-} from "./index-w9naz372.js";
+} from "./index-m0wt4nr1.js";
 import {
   promotable
 } from "./index-d6d0942q.js";
@@ -5965,8 +5969,8 @@ async function report(args, repoRoot) {
 }
 
 // src/commands/plan/validate.ts
-import { readFileSync as readFileSync8 } from "fs";
-import { basename as basename4, resolve as resolve6 } from "path";
+import { readFileSync as readFileSync10 } from "fs";
+import { resolve as resolve8 } from "path";
 
 // src/board/readiness.ts
 var SPEC_READY_LABEL = "spec:ready";
@@ -6311,23 +6315,425 @@ function storeRuleLine(file, problem) {
   return `${file}:${String(problem.line)}: ${problem.kind}: ${problem.text}`;
 }
 
-// src/commands/plan/validate.ts
-var USAGE = "rafa plan validate <file>";
+// src/commands/plan/store-check.ts
+import { mkdirSync as mkdirSync3, readFileSync as readFileSync9, renameSync as renameSync2 } from "fs";
+import { basename as basename5, dirname as dirname6, resolve as resolve7 } from "path";
+
+// src/board/gate.ts
+import { existsSync as existsSync11, mkdirSync as mkdirSync2, readFileSync as readFileSync8, renameSync, statSync as statSync4, writeFileSync as writeFileSync3 } from "fs";
+import { basename as basename4, dirname as dirname5, join as join8, resolve as resolve6 } from "path";
+
+// src/board/flags.ts
+var SPEC_FLAG = "--spec";
+var ISSUE_FLAG = "--issue";
+var NEXT_FLAG = "--next";
+var REFRESH_FLAG = "--refresh";
+var ROADMAP_FLAG = "--roadmap";
+var CLAIM_AHEAD_FLAG = "--claim-ahead";
+var DRY_RUN_FLAG = "--dry-run";
+var SKIP_REVIEW_FLAG = "--skip-review";
+var NO_COMMENT_FLAG = "--no-comment";
+var ACCEPT_REFS_FLAG = "--accept-refs";
+
+// src/board/review-comment.ts
+var SPEC_REVIEW_MARKER = "<!-- rafa:spec-review v1 -->";
+var SPEC_REVIEW_COMMENT_NAME = "rafa:spec-review";
+var ONE_LINE = /\s+/gu;
+var COMMENT_REMEDY = "Close the gaps, label the issue `spec:ready` again, and plan from it again.";
+var ASSUMED_COMMENT_REMEDY = "Answer these in the spec where an assumption is wrong, and plan from it" + " again. No label changed: none of these gaps blocked planning.";
+var COMMENT_HISTORY = "This comment is edited in place each time the spec is reviewed.";
+function counted2(count, noun) {
+  return count === 1 ? `1 ${noun}` : `${String(count)} ${noun}s`;
+}
+function gapItem(gap) {
+  return `- **${gap.heading.replace(ONE_LINE, " ").trim()}** \u2014 ${gap.what.replace(ONE_LINE, " ").trim()}`;
+}
+function assumedGapItem(gap) {
+  return gap.assumption === null ? gapItem(gap) : `${gapItem(gap)}
+  - Planned under: ${gap.assumption.replace(ONE_LINE, " ").trim()}`;
+}
+function requireGaps(gaps) {
+  if (gaps.length === 0) {
+    throw new TypeError("board review comment: no gap was named, and there is no comment to write");
+  }
+}
+function commentBody(found, items, remedy) {
+  return [SPEC_REVIEW_MARKER, ...found, "", ...items, "", remedy, "", COMMENT_HISTORY, ""].join(`
+`);
+}
+function specReviewCommentBody(gaps) {
+  requireGaps(gaps);
+  return commentBody([`**rafa reviewed this spec before planning and found ${counted2(gaps.length, "gap")}.**`, "No plan was written."], gaps.map(gapItem), COMMENT_REMEDY);
+}
+function assumedReviewCommentBody(gaps) {
+  requireGaps(gaps);
+  return commentBody([
+    `**rafa reviewed this spec before planning and found ${counted2(gaps.length, "gap")}, none of them blocking.**`,
+    "The plan was written under the assumptions below."
+  ], gaps.map(assumedGapItem), ASSUMED_COMMENT_REMEDY);
+}
+function specReviewComments(comments) {
+  return [...comments].reverse().filter((comment) => comment.body.includes(SPEC_REVIEW_MARKER));
+}
+function ignoredReviewCommentMessage(comment, reading, repo) {
+  const who = `was written by ${reading.login}, ${trustRefusalClause(repo, reading)}`;
+  return `the ${SPEC_REVIEW_COMMENT_NAME} comment ${comment.id} ${who};` + " it was left alone and the gaps went in a comment of their own";
+}
+async function readTrustedSpecReviewComment(comments, trust) {
+  const trustOf = memoisedTrust(trust);
+  const ignored = [];
+  for (const comment of specReviewComments(comments)) {
+    const reading = await trustOf(comment.author);
+    if (reading.trusted)
+      return { comment, ignored };
+    ignored.push({
+      id: comment.id,
+      author: comment.author,
+      reason: ignoredReviewCommentMessage(comment, reading, trust.repo)
+    });
+  }
+  return { comment: null, ignored };
+}
+async function writeSpecReviewComment(options) {
+  const { body, issue: issue3, board, trust } = options;
+  const found = await readTrustedSpecReviewComment(await board.comments(issue3), trust);
+  const { comment: existing, ignored } = found;
+  if (existing === null) {
+    return { action: "posted", comment: await board.comment(issue3, body), ignored };
+  }
+  return { action: "edited", comment: await board.editComment(existing.id, body), ignored };
+}
+function memoisedTrust(trust) {
+  const read = new Map;
+  return (login) => {
+    const taken = read.get(login) ?? readBoardTrust(trust, login);
+    read.set(login, taken);
+    return taken;
+  };
+}
+
+// src/board/plan-field.ts
+var PLAN_BLOCK_KIND = "plan";
+var FIELD_NAME = /^[a-z][a-z-]*$/u;
+var ISSUE_FIELD = "issue";
+function unrecorded(answer, text, note) {
+  return { answer, text, recorded: false, note };
+}
+function indentOf(line) {
+  return /^\s*/u.exec(line)?.[0] ?? "";
+}
+function carriageOf(line) {
+  return line.endsWith("\r") ? "\r" : "";
+}
+function fieldLine(field2) {
+  if (!FIELD_NAME.test(field2)) {
+    throw new TypeError(`board plan field: ${JSON.stringify(field2)} is no rafa:plan key this records`);
+  }
+  return new RegExp(`^(\\s*)${field2}\\s*:(.*)$`, "u");
+}
+function stampPlanField(plan, field2, value) {
+  const pattern = fieldLine(field2);
+  const line = `${field2}: ${value}`;
+  const block = readRafaBlocks(plan).find((found) => found.kind === PLAN_BLOCK_KIND);
+  if (block === undefined) {
+    return unrecorded("no-block", plan, "the plan holds no rafa:plan block to record it in");
+  }
+  if (!block.closed) {
+    return unrecorded("unclosed-block", plan, `the rafa:plan block at line ${String(block.span.first)} is never closed, so nothing was recorded in it`);
+  }
+  const lines = plan.split(`
+`);
+  const opening = lines[block.span.first - 1] ?? "";
+  const indent = indentOf(opening);
+  const written = `${indent}${line}${carriageOf(opening)}`;
+  for (let index = block.span.first;index < block.span.last - 1; index += 1) {
+    const found = pattern.exec(lines[index] ?? "");
+    if (found === null || found[1] !== indent)
+      continue;
+    if ((found[2] ?? "").trim() === value) {
+      return { answer: "unchanged", text: plan, recorded: true, note: `the plan already records ${line}` };
+    }
+    const replaced = [...lines];
+    replaced[index] = written;
+    return {
+      answer: "replaced",
+      text: replaced.join(`
+`),
+      recorded: true,
+      note: `line ${String(index + 1)} of the plan now records ${line}`
+    };
+  }
+  const at = block.span.last - 1;
+  const stamped = [...lines.slice(0, at), written, ...lines.slice(at)];
+  return {
+    answer: "inserted",
+    text: stamped.join(`
+`),
+    recorded: true,
+    note: `line ${String(at + 1)} of the plan now records ${line}`
+  };
+}
+function issueFieldLine(issue3) {
+  if (!Number.isSafeInteger(issue3) || issue3 < 1) {
+    throw new TypeError(`board plan field: issue ${String(issue3)} is no issue number, expected a positive whole one`);
+  }
+  return `${ISSUE_FIELD}: ${JSON.stringify(String(issue3))}`;
+}
+function stampPlanIssue(plan, issue3) {
+  return stampPlanField(plan, ISSUE_FIELD, JSON.stringify(String(issue3)));
+}
+
+// src/board/review-stamp.ts
+var REVIEW_FIELD = "review";
+var REVIEW_SKIPPED = "skipped";
+var REVIEW_MISSING = "missing";
+var REVIEW_ASSUMED = "assumed";
+var REVIEW_SKIPPED_LINE = `${REVIEW_FIELD}: ${REVIEW_SKIPPED}`;
+var REVIEW_MISSING_LINE = `${REVIEW_FIELD}: ${REVIEW_MISSING}`;
+var REVIEW_ASSUMED_LINE = `${REVIEW_FIELD}: ${REVIEW_ASSUMED}`;
+function stampReviewSkipped(plan) {
+  return stampPlanField(plan, REVIEW_FIELD, REVIEW_SKIPPED);
+}
+function stampReviewMissing(plan) {
+  return stampPlanField(plan, REVIEW_FIELD, REVIEW_MISSING);
+}
+function stampReviewAssumed(plan) {
+  return stampPlanField(plan, REVIEW_FIELD, REVIEW_ASSUMED);
+}
+var ASSUMPTIONS_HEADING = "# Planned under assumptions";
+var ASSUMPTIONS_PREAMBLE = [
+  "The spec review found gaps, none of them blocking, so this plan was",
+  "written under the assumptions below. Each names the gap it was",
+  "written for; closing that gap in the spec is what replaces the guess."
+];
+function assumptionsHeading(gaps) {
+  const items = gaps.filter((gap) => gap.assumption !== null).map(assumedGapItem);
+  if (items.length === 0) {
+    throw new TypeError("board review stamp: no gap named an assumption, and there is no heading to open a plan with");
+  }
+  return [ASSUMPTIONS_HEADING, "", ...ASSUMPTIONS_PREAMBLE, "", ...items, "", ""].join(`
+`);
+}
+
+// src/board/gate.ts
+var SPEC_NOT_READY_EXIT = 3;
+var SPEC_NEEDS_WORK_LABEL = "spec:needs-work";
+function readGateFlags(args) {
+  return {
+    skipReview: args.includes(SKIP_REVIEW_FLAG),
+    comment: !args.includes(NO_COMMENT_FLAG)
+  };
+}
+function describeGap2(gap) {
+  return `   \u2022 "${gap.heading}": ${gap.what}`;
+}
+function remedyFor(issue3) {
+  return issue3 === null ? "   Close the gaps in the spec, then plan from it again." : `   Close the gaps, label the issue ${SPEC_READY_LABEL} again, and plan from it again.`;
+}
+function specNotReadyMessage(source, reading, gaps, issue3 = null) {
+  return [
+    `\u274C ${source} is not ready to plan from: ${reading}`,
+    ...gaps.map(describeGap2),
+    remedyFor(issue3)
+  ].join(`
+`);
+}
+function unreadReviewWarning(reading, planPath) {
+  return `${reading}; ${planPath} reads as written, so the plan stands unreviewed`;
+}
+function assumedReviewWarning(reading, planPath) {
+  return `${reading}, none of them blocking; ${planPath} is written under the assumptions the review named`;
+}
+function unreadReviewMessage(source, reading, planIssues) {
+  return [
+    `\u274C ${source}: no plan stands \u2014 ${reading}, and the plan the session wrote does not read as written:`,
+    ...planIssues.map((line) => `   ${line}`),
+    "   Plan from the spec again."
+  ].join(`
+`);
+}
+function isWrittenFile(repoRoot, path) {
+  const full = resolve6(repoRoot, path);
+  return existsSync11(full) && statSync4(full).isFile();
+}
+var NOT_READY_REASON = "the planner judged the spec not ready, so no plan stands.";
+var UNREAD_REASON = "no review came back and the plan does not read as written, so no plan stands.";
+var REJECTED_DIR = "rejected";
+function rejectedPath(path) {
+  const parent = dirname5(path);
+  return parent === "." ? join8(REJECTED_DIR, basename4(path)) : join8(parent, REJECTED_DIR, basename4(path));
+}
+function moveWritten(options, output, reason) {
+  for (const path of [options.planPath, options.prerequisitesPath]) {
+    if (!isWrittenFile(options.repoRoot, path))
+      continue;
+    const destination = rejectedPath(path);
+    try {
+      mkdirSync2(resolve6(options.repoRoot, dirname5(destination)), { recursive: true });
+      renameSync(resolve6(options.repoRoot, path), resolve6(options.repoRoot, destination));
+      output.info(`\uD83D\uDDC3  Moved ${path} to ${destination}: ${reason}`);
+    } catch (error) {
+      output.warn(`${path} was written against a refused review and could not be moved: ${messageOf(error)}`);
+    }
+  }
+}
+function readWrittenPlan(options) {
+  const { repoRoot, planPath } = options;
+  if (!isWrittenFile(repoRoot, planPath)) {
+    return { reads: false, issues: [`${planPath}: the session wrote no plan there`] };
+  }
+  try {
+    const { issues } = validatePlan(resolve6(repoRoot, planPath));
+    return { reads: issues.length === 0, issues: issues.map((issue3) => issueLine(planPath, issue3)) };
+  } catch (error) {
+    return { reads: false, issues: [`${planPath}: ${messageOf(error)}`] };
+  }
+}
+function standOrRefuse(options, review, output) {
+  const plan = readWrittenPlan(options);
+  if (plan.reads) {
+    output.warn(unreadReviewWarning(review.text, options.planPath));
+    return "unread";
+  }
+  moveWritten(options, output, UNREAD_REASON);
+  throw new CommandExit(SPEC_NOT_READY_EXIT, unreadReviewMessage(options.source, review.text, plan.issues));
+}
+function recordAssumptions(options, gaps, output) {
+  const { repoRoot, planPath } = options;
+  const unopened = (why) => {
+    output.warn(`${planPath} was not opened under the review's assumptions: ${why}`);
+  };
+  if (!isWrittenFile(repoRoot, planPath)) {
+    unopened("the session wrote no plan there");
+    return;
+  }
+  const file = resolve6(repoRoot, planPath);
+  let stamped;
+  try {
+    stamped = stampReviewAssumed(`${assumptionsHeading(gaps)}${readFileSync8(file, "utf8")}`);
+    writeFileSync3(file, stamped.text, "utf8");
+  } catch (error) {
+    unopened(messageOf(error));
+    return;
+  }
+  if (!stamped.recorded) {
+    output.warn(`${planPath} opens under the review's assumptions and records no ${REVIEW_ASSUMED_LINE}: ${stamped.note}`);
+    return;
+  }
+  output.info(`\uD83E\uDDED ${planPath} opens under the review's assumptions and records ${REVIEW_ASSUMED_LINE}.`);
+}
+async function publishGaps(issue3, gaps, body, output) {
+  try {
+    const write = await writeSpecReviewComment({
+      issue: issue3.number,
+      body: body(gaps),
+      board: issue3.board,
+      trust: issue3.trust
+    });
+    for (const passed2 of write.ignored)
+      output.warn(passed2.reason);
+    output.info(`\uD83D\uDCAC ${write.action === "posted" ? "Posted" : "Edited"} the review comment on issue #${String(issue3.number)}.`);
+  } catch (error) {
+    output.warn(`the review comment on issue #${String(issue3.number)} was not written: ${messageOf(error)}`);
+  }
+}
+async function swapLabels(issue3, output) {
+  try {
+    await issue3.board.swapLabels(issue3.number, SPEC_READY_LABEL, SPEC_NEEDS_WORK_LABEL);
+    output.info(`\uD83C\uDFF7  Swapped ${SPEC_READY_LABEL} for ${SPEC_NEEDS_WORK_LABEL} on issue #${String(issue3.number)}.`);
+  } catch (error) {
+    output.warn(`${SPEC_READY_LABEL} was not swapped for ${SPEC_NEEDS_WORK_LABEL} on issue` + ` #${String(issue3.number)}: ${messageOf(error)}`);
+  }
+}
+function nothingBlocks(review) {
+  return !review.gaps.some((gap) => gap.blocking);
+}
+async function planUnderAssumptions(options, review, output) {
+  output.warn(assumedReviewWarning(review.text, options.planPath));
+  recordAssumptions(options, review.gaps, output);
+  const { issue: issue3 } = options;
+  if (issue3 !== null) {
+    if (options.comment) {
+      await publishGaps(issue3, review.gaps, assumedReviewCommentBody, output);
+    } else {
+      output.info(`\uD83D\uDCAC ${NO_COMMENT_FLAG}: the gaps were not posted on issue #${String(issue3.number)}.`);
+    }
+  }
+  return "assumed";
+}
+async function enforceSpecReview(options) {
+  const { review, issue: issue3 } = options;
+  if (review === undefined)
+    return "unjudged";
+  if (review.ready)
+    return "ready";
+  const output = options.output ?? activeOutput();
+  if (review.answer !== "not-ready")
+    return standOrRefuse(options, review, output);
+  if (nothingBlocks(review))
+    return planUnderAssumptions(options, review, output);
+  moveWritten(options, output, NOT_READY_REASON);
+  if (issue3 !== null) {
+    if (options.comment) {
+      await publishGaps(issue3, review.gaps, specReviewCommentBody, output);
+    } else {
+      output.info(`\uD83D\uDCAC ${NO_COMMENT_FLAG}: the gaps were not posted on issue #${String(issue3.number)}.`);
+    }
+    await swapLabels(issue3, output);
+  }
+  throw new CommandExit(SPEC_NOT_READY_EXIT, specNotReadyMessage(options.source, review.text, review.gaps, issue3));
+}
+
+// src/commands/plan/store-check.ts
 function readFileOrNull(path) {
-  return path !== null && isFile(path) ? readFileSync8(path, "utf8") : null;
+  return path !== null && isFile(path) ? readFileSync9(path, "utf8") : null;
 }
 function checkStoreRules(file, markdown) {
   const prerequisitesPath = prerequisitesPathForPlan(file);
   return findStoreRuleProblems({
     plan: markdown,
     prerequisites: readFileOrNull(prerequisitesPath),
-    prerequisitesName: basename4(prerequisitesPath ?? "PREREQUISITES-<stub>.md")
+    prerequisitesName: basename5(prerequisitesPath ?? "PREREQUISITES-<stub>.md")
   });
 }
+function moveRejected(repoRoot, path, output) {
+  const full = resolve7(repoRoot, path);
+  if (!isFile(full))
+    return;
+  const destination = rejectedPath(path);
+  try {
+    mkdirSync3(resolve7(repoRoot, dirname6(destination)), { recursive: true });
+    renameSync2(full, resolve7(repoRoot, destination));
+    output.info(`\uD83D\uDDC3  Moved ${path} to ${destination}: the plan breaks the effort-store rules.`);
+  } catch (error) {
+    output.warn(`${path} breaks the effort-store rules and could not be moved: ${messageOf(error)}`);
+  }
+}
+function enforceStoreRules(repoRoot, generated, output = activeOutput()) {
+  const planFile = resolve7(repoRoot, generated.planPath);
+  if (!isFile(planFile))
+    return;
+  const problems = checkStoreRules(planFile, readFileSync9(planFile, "utf8"));
+  if (problems.length === 0)
+    return;
+  const prerequisites = generated.prerequisitesPath ?? prerequisitesPathForPlan(generated.planPath);
+  for (const path of [generated.planPath, prerequisites]) {
+    if (path !== null)
+      moveRejected(repoRoot, path, output);
+  }
+  throw new CommandExit(1, [
+    `\u274C ${generated.planPath}: ${plural(problems.length, "broken effort-store rule")};` + " rafa loop start would refuse this plan, so no plan stands.",
+    ...problems.map((problem) => `   ${storeRuleLine(generated.planPath, problem)}`)
+  ].join(`
+`));
+}
+
+// src/commands/plan/validate.ts
+var USAGE = "rafa plan validate <file>";
 function validatePlan(file) {
   if (!isFile(file))
     throw new CommandExit(1, `\u274C Plan file not found: ${file}`);
-  const model = parsePlan(readFileSync8(file, "utf8"));
+  const model = parsePlan(readFileSync10(file, "utf8"));
   return { file, stages: model.stages.length, tasks: countTasks(model.tasks), issues: model.issues };
 }
 function resolvedConfig(project, warn) {
@@ -6400,10 +6806,10 @@ function createPlanValidateCommand(workingDirectory = () => process.cwd()) {
     outputs: ["text", "json"],
     run: async (context) => {
       const typed = expectOneArgument(context.args, USAGE);
-      const file = resolve6(workingDirectory(), typed);
+      const file = resolve8(workingDirectory(), typed);
       const validation = validatePlan(file);
       const { issues, stages, tasks } = validation;
-      const markdown = readFileSync8(file, "utf8");
+      const markdown = readFileSync10(file, "utf8");
       const findings = checkRoster(context, markdown);
       const { missingAgents, skillCollisions, unresolvedSkills } = findings;
       const storeProblems = checkStoreRules(file, markdown);
@@ -6440,8 +6846,8 @@ function createPlanValidateCommand(workingDirectory = () => process.cwd()) {
 var validate_default = createPlanValidateCommand();
 
 // src/board/board-cache.ts
-import { mkdirSync as mkdirSync2, readFileSync as readFileSync9, renameSync, writeFileSync as writeFileSync3 } from "fs";
-import { dirname as dirname5, join as join8 } from "path";
+import { mkdirSync as mkdirSync4, readFileSync as readFileSync11, renameSync as renameSync3, writeFileSync as writeFileSync4 } from "fs";
+import { dirname as dirname7, join as join9 } from "path";
 
 // src/board/board-cache-native.ts
 var NATIVE_ISSUE_SELECTION = [
@@ -6712,7 +7118,7 @@ function createGhBoardListing(options) {
 }
 
 // src/board/board-cache.ts
-var BOARD_CACHE_FILE = join8(SCOPE_DIR, "cache", "board.json");
+var BOARD_CACHE_FILE = join9(SCOPE_DIR, "cache", "board.json");
 var BOARD_CACHE_VERSION = 1;
 var NATIVE_MODE_KEY = Object.freeze({ mode: "native" });
 var WATERMARK_ARGS = Object.freeze([
@@ -6739,7 +7145,7 @@ function modeOfFile(value) {
 function readCache(path, mode) {
   let payload;
   try {
-    payload = JSON.parse(readFileSync9(path, "utf8"));
+    payload = JSON.parse(readFileSync11(path, "utf8"));
   } catch {
     return null;
   }
@@ -6774,10 +7180,10 @@ function fileOf(cache) {
 function writeCache(path, cache) {
   const temporary = `${path}.${String(process.pid)}.tmp`;
   try {
-    mkdirSync2(dirname5(path), { recursive: true });
-    writeFileSync3(temporary, `${JSON.stringify(fileOf(cache))}
+    mkdirSync4(dirname7(path), { recursive: true });
+    writeFileSync4(temporary, `${JSON.stringify(fileOf(cache))}
 `);
-    renameSync(temporary, path);
+    renameSync3(temporary, path);
     return true;
   } catch {
     return false;
@@ -6859,7 +7265,7 @@ function changesNothing(rows, changed) {
 }
 function createCachedBoardListing(options) {
   const { gh, root, refresh = false, limit = BOARD_LISTING_LIMIT, mode = "labels" } = options;
-  const path = join8(root, BOARD_CACHE_FILE);
+  const path = join9(root, BOARD_CACHE_FILE);
   const full = createGhBoardListing({ gh, limit, mode });
   return async () => {
     const cache = refresh ? null : readCache(path, mode);
@@ -6881,7 +7287,7 @@ function invalidateRows(root, numbers) {
   const bad = numbers.find((number) => !isIssueNumber(number));
   if (bad !== undefined)
     throw new RangeError(`not an issue number: ${String(bad)}`);
-  const path = join8(root, BOARD_CACHE_FILE);
+  const path = join9(root, BOARD_CACHE_FILE);
   const cache = readCache(path, "native");
   if (cache === null)
     return false;
@@ -7031,10 +7437,75 @@ var MAX_LISTED_CHANGES = 10;
 var DEFAULT_REMOTE = "origin";
 var BRANCH_REF_PREFIX = "refs/heads/";
 var INDENT = "   ";
+var UNTRACKED_PREFIX = "?? ";
 function parseWorkingTree(stdout) {
   const entries = stdout.split(`
 `).map((line) => line.replace(/\r$/, "")).filter((line) => line.trim() !== "");
-  return { clean: entries.length === 0, entries: Object.freeze(entries) };
+  const tracked = entries.filter((line) => !line.startsWith(UNTRACKED_PREFIX));
+  const untracked = entries.filter((line) => line.startsWith(UNTRACKED_PREFIX)).map((line) => unquoteGitPath(line.slice(UNTRACKED_PREFIX.length)));
+  return {
+    clean: entries.length === 0,
+    entries: Object.freeze(entries),
+    tracked: Object.freeze(tracked),
+    untracked: Object.freeze(untracked)
+  };
+}
+var C_ESCAPES = {
+  a: 7,
+  b: 8,
+  f: 12,
+  n: 10,
+  r: 13,
+  t: 9,
+  v: 11,
+  "\\": 92,
+  '"': 34
+};
+var OCTAL_ESCAPE = /^[0-7]{3}$/;
+function unquoteGitPath(raw) {
+  if (raw.length < 2 || !raw.startsWith('"') || !raw.endsWith('"'))
+    return raw;
+  const body = raw.slice(1, -1);
+  const bytes = [];
+  const encoder = new TextEncoder;
+  for (let at = 0;at < body.length; at += 1) {
+    const char = body.charAt(at);
+    if (char !== "\\") {
+      bytes.push(...encoder.encode(char));
+      continue;
+    }
+    const octal = body.slice(at + 1, at + 4);
+    if (OCTAL_ESCAPE.test(octal)) {
+      bytes.push(Number.parseInt(octal, 8));
+      at += 3;
+      continue;
+    }
+    const escaped = C_ESCAPES[body.charAt(at + 1)];
+    if (escaped === undefined) {
+      bytes.push(...encoder.encode(char));
+      continue;
+    }
+    bytes.push(escaped);
+    at += 1;
+  }
+  return new TextDecoder().decode(new Uint8Array(bytes));
+}
+function parseTreePaths(stdout) {
+  return Object.freeze(stdout.split(`
+`).map((line) => line.replace(/\r$/, "")).filter((line) => line.trim() !== "").map(unquoteGitPath));
+}
+function untrackedIncoming(untracked, incoming) {
+  const held = new Set(incoming);
+  return Object.freeze(untracked.filter((path2) => path2.endsWith("/") ? incoming.some((file) => file.startsWith(path2)) : held.has(path2)));
+}
+function untrackedLeftLine(paths) {
+  if (paths.length === 0)
+    return null;
+  const named = paths.slice(0, MAX_LISTED_CHANGES).map((path2) => shellQuote(path2));
+  const hidden = paths.length - named.length;
+  const more = hidden > 0 ? ` and ${hidden} more` : "";
+  const which = paths.length === 1 ? "path" : "paths";
+  return `Leaving the untracked ${which} the merge does not touch in place: ${named.join(", ")}${more}.`;
 }
 function parseWorktrees(stdout) {
   const entries = [];
@@ -7097,14 +7568,23 @@ function noChecksRefusal(number) {
 `)
   };
 }
-function dirtyTreeRefusal(tree) {
-  const count = plural2(tree.entries.length, "change", "changes");
+function heldUntracked(reading) {
+  return reading.incoming === undefined ? reading.tree.untracked : untrackedIncoming(reading.tree.untracked, reading.incoming);
+}
+function dirtyTreeRefusal(tree, held) {
+  const heldSet = new Set(held);
+  const listed = tree.entries.filter((line) => !line.startsWith(UNTRACKED_PREFIX) || heldSet.has(unquoteGitPath(line.slice(UNTRACKED_PREFIX.length))));
+  if (listed.length === 0)
+    return null;
+  const count = plural2(listed.length, "change", "changes");
+  const untrackedNote = held.length === 0 ? [] : ["An untracked path listed here is one the merge brings a file onto."];
   return {
     reason: "dirty-tree",
     message: [
       `${REFUSAL_PREFIX}: the working tree has ${count}.`,
       "Commit or stash them, then run rafa pr merge again.",
-      ...listChanges(tree.entries)
+      ...untrackedNote,
+      ...listChanges(listed)
     ].join(`
 `)
   };
@@ -7168,8 +7648,9 @@ function worktreeRefusal(branch, held) {
   };
 }
 function readMergeRefusal(reading) {
-  if (!reading.tree.clean)
-    return dirtyTreeRefusal(reading.tree);
+  const dirty = dirtyTreeRefusal(reading.tree, heldUntracked(reading));
+  if (dirty !== null)
+    return dirty;
   if (reading.merge.mergeable !== "mergeable")
     return mergeStateRefusal(reading);
   const checks = checksRefusalOf(reading);
@@ -7406,7 +7887,7 @@ function readWholeNumber2(value, command, where) {
   }
   return value;
 }
-function readState(value, command, where) {
+function readState2(value, command, where) {
   const state = STATES.get(readString3(value, command, where));
   if (state === undefined) {
     refuse5(command, `${where} is ${describeValue(value)}, expected one of: ${[...STATES.keys()].join(", ")}`);
@@ -7435,7 +7916,7 @@ function readSummary(value, command, where) {
     number: readWholeNumber2(pull["number"], command, `${where}.number`),
     title: readString3(pull["title"], command, `${where}.title`),
     url: readString3(pull["url"], command, `${where}.url`),
-    state: readState(pull["state"], command, `${where}.state`),
+    state: readState2(pull["state"], command, `${where}.state`),
     headRefName: readString3(pull["headRefName"], command, `${where}.headRefName`),
     baseRefName: readString3(pull["baseRefName"], command, `${where}.baseRefName`),
     author: readAuthor(pull["author"], command, `${where}.author`),
@@ -7715,7 +8196,7 @@ function ghAuthOkIn(cwd) {
 var REMOTE = "origin";
 var BRANCH_PREFIX2 = "feat/";
 var INDENT2 = "   ";
-var UNTRACKED_PREFIX = "??";
+var UNTRACKED_PREFIX2 = "??";
 var MAX_LISTED_CHANGES2 = 10;
 var COUNT = /^\d+$/;
 var DETACHED_HEAD = "HEAD";
@@ -7791,7 +8272,7 @@ function listChanges2(entries) {
   return hidden > 0 ? [...shown, `${INDENT2}... and ${hidden} more`] : shown;
 }
 function trackedChanges(tree) {
-  return Object.freeze(tree.entries.filter((entry) => !entry.startsWith(UNTRACKED_PREFIX)));
+  return Object.freeze(tree.entries.filter((entry) => !entry.startsWith(UNTRACKED_PREFIX2)));
 }
 function treeRefusal(tree, plan) {
   const changes = trackedChanges(tree);
@@ -8483,8 +8964,8 @@ function exhaustedMessage(roadmap, skipped2) {
 }
 
 // src/board/setup.ts
-import { existsSync as existsSync13, lstatSync, mkdirSync as mkdirSync6, readFileSync as readFileSync13, statSync as statSync7, writeFileSync as writeFileSync6 } from "fs";
-import { dirname as dirname8, join as join11 } from "path";
+import { existsSync as existsSync13, lstatSync, mkdirSync as mkdirSync7, readFileSync as readFileSync14, statSync as statSync7, writeFileSync as writeFileSync6 } from "fs";
+import { dirname as dirname9, join as join11 } from "path";
 import { fileURLToPath } from "url";
 
 // src/board/blocked.ts
@@ -8588,374 +9069,9 @@ function blockedFaultMessage(read) {
   return `#${String(read.issue)} ${faultClause(read)}; ${REMEDY2}`;
 }
 
-// src/board/gate.ts
-import { existsSync as existsSync11, mkdirSync as mkdirSync3, readFileSync as readFileSync10, renameSync as renameSync2, statSync as statSync4, writeFileSync as writeFileSync4 } from "fs";
-import { basename as basename5, dirname as dirname6, join as join9, resolve as resolve7 } from "path";
-
-// src/board/flags.ts
-var SPEC_FLAG = "--spec";
-var ISSUE_FLAG = "--issue";
-var NEXT_FLAG = "--next";
-var REFRESH_FLAG = "--refresh";
-var ROADMAP_FLAG = "--roadmap";
-var CLAIM_AHEAD_FLAG = "--claim-ahead";
-var DRY_RUN_FLAG = "--dry-run";
-var SKIP_REVIEW_FLAG = "--skip-review";
-var NO_COMMENT_FLAG = "--no-comment";
-var ACCEPT_REFS_FLAG = "--accept-refs";
-
-// src/board/review-comment.ts
-var SPEC_REVIEW_MARKER = "<!-- rafa:spec-review v1 -->";
-var SPEC_REVIEW_COMMENT_NAME = "rafa:spec-review";
-var ONE_LINE = /\s+/gu;
-var COMMENT_REMEDY = "Close the gaps, label the issue `spec:ready` again, and plan from it again.";
-var ASSUMED_COMMENT_REMEDY = "Answer these in the spec where an assumption is wrong, and plan from it" + " again. No label changed: none of these gaps blocked planning.";
-var COMMENT_HISTORY = "This comment is edited in place each time the spec is reviewed.";
-function counted2(count, noun) {
-  return count === 1 ? `1 ${noun}` : `${String(count)} ${noun}s`;
-}
-function gapItem(gap) {
-  return `- **${gap.heading.replace(ONE_LINE, " ").trim()}** \u2014 ${gap.what.replace(ONE_LINE, " ").trim()}`;
-}
-function assumedGapItem(gap) {
-  return gap.assumption === null ? gapItem(gap) : `${gapItem(gap)}
-  - Planned under: ${gap.assumption.replace(ONE_LINE, " ").trim()}`;
-}
-function requireGaps(gaps) {
-  if (gaps.length === 0) {
-    throw new TypeError("board review comment: no gap was named, and there is no comment to write");
-  }
-}
-function commentBody(found, items, remedy) {
-  return [SPEC_REVIEW_MARKER, ...found, "", ...items, "", remedy, "", COMMENT_HISTORY, ""].join(`
-`);
-}
-function specReviewCommentBody(gaps) {
-  requireGaps(gaps);
-  return commentBody([`**rafa reviewed this spec before planning and found ${counted2(gaps.length, "gap")}.**`, "No plan was written."], gaps.map(gapItem), COMMENT_REMEDY);
-}
-function assumedReviewCommentBody(gaps) {
-  requireGaps(gaps);
-  return commentBody([
-    `**rafa reviewed this spec before planning and found ${counted2(gaps.length, "gap")}, none of them blocking.**`,
-    "The plan was written under the assumptions below."
-  ], gaps.map(assumedGapItem), ASSUMED_COMMENT_REMEDY);
-}
-function specReviewComments(comments) {
-  return [...comments].reverse().filter((comment) => comment.body.includes(SPEC_REVIEW_MARKER));
-}
-function ignoredReviewCommentMessage(comment, reading2, repo) {
-  const who = `was written by ${reading2.login}, ${trustRefusalClause(repo, reading2)}`;
-  return `the ${SPEC_REVIEW_COMMENT_NAME} comment ${comment.id} ${who};` + " it was left alone and the gaps went in a comment of their own";
-}
-async function readTrustedSpecReviewComment(comments, trust) {
-  const trustOf = memoisedTrust(trust);
-  const ignored = [];
-  for (const comment of specReviewComments(comments)) {
-    const reading2 = await trustOf(comment.author);
-    if (reading2.trusted)
-      return { comment, ignored };
-    ignored.push({
-      id: comment.id,
-      author: comment.author,
-      reason: ignoredReviewCommentMessage(comment, reading2, trust.repo)
-    });
-  }
-  return { comment: null, ignored };
-}
-async function writeSpecReviewComment(options) {
-  const { body, issue: issue3, board, trust } = options;
-  const found = await readTrustedSpecReviewComment(await board.comments(issue3), trust);
-  const { comment: existing, ignored } = found;
-  if (existing === null) {
-    return { action: "posted", comment: await board.comment(issue3, body), ignored };
-  }
-  return { action: "edited", comment: await board.editComment(existing.id, body), ignored };
-}
-function memoisedTrust(trust) {
-  const read = new Map;
-  return (login) => {
-    const taken = read.get(login) ?? readBoardTrust(trust, login);
-    read.set(login, taken);
-    return taken;
-  };
-}
-
-// src/board/plan-field.ts
-var PLAN_BLOCK_KIND = "plan";
-var FIELD_NAME = /^[a-z][a-z-]*$/u;
-var ISSUE_FIELD = "issue";
-function unrecorded(answer, text, note) {
-  return { answer, text, recorded: false, note };
-}
-function indentOf(line) {
-  return /^\s*/u.exec(line)?.[0] ?? "";
-}
-function carriageOf(line) {
-  return line.endsWith("\r") ? "\r" : "";
-}
-function fieldLine(field2) {
-  if (!FIELD_NAME.test(field2)) {
-    throw new TypeError(`board plan field: ${JSON.stringify(field2)} is no rafa:plan key this records`);
-  }
-  return new RegExp(`^(\\s*)${field2}\\s*:(.*)$`, "u");
-}
-function stampPlanField(plan, field2, value) {
-  const pattern = fieldLine(field2);
-  const line = `${field2}: ${value}`;
-  const block = readRafaBlocks(plan).find((found) => found.kind === PLAN_BLOCK_KIND);
-  if (block === undefined) {
-    return unrecorded("no-block", plan, "the plan holds no rafa:plan block to record it in");
-  }
-  if (!block.closed) {
-    return unrecorded("unclosed-block", plan, `the rafa:plan block at line ${String(block.span.first)} is never closed, so nothing was recorded in it`);
-  }
-  const lines = plan.split(`
-`);
-  const opening = lines[block.span.first - 1] ?? "";
-  const indent = indentOf(opening);
-  const written = `${indent}${line}${carriageOf(opening)}`;
-  for (let index = block.span.first;index < block.span.last - 1; index += 1) {
-    const found = pattern.exec(lines[index] ?? "");
-    if (found === null || found[1] !== indent)
-      continue;
-    if ((found[2] ?? "").trim() === value) {
-      return { answer: "unchanged", text: plan, recorded: true, note: `the plan already records ${line}` };
-    }
-    const replaced = [...lines];
-    replaced[index] = written;
-    return {
-      answer: "replaced",
-      text: replaced.join(`
-`),
-      recorded: true,
-      note: `line ${String(index + 1)} of the plan now records ${line}`
-    };
-  }
-  const at = block.span.last - 1;
-  const stamped = [...lines.slice(0, at), written, ...lines.slice(at)];
-  return {
-    answer: "inserted",
-    text: stamped.join(`
-`),
-    recorded: true,
-    note: `line ${String(at + 1)} of the plan now records ${line}`
-  };
-}
-function issueFieldLine(issue3) {
-  if (!Number.isSafeInteger(issue3) || issue3 < 1) {
-    throw new TypeError(`board plan field: issue ${String(issue3)} is no issue number, expected a positive whole one`);
-  }
-  return `${ISSUE_FIELD}: ${JSON.stringify(String(issue3))}`;
-}
-function stampPlanIssue(plan, issue3) {
-  return stampPlanField(plan, ISSUE_FIELD, JSON.stringify(String(issue3)));
-}
-
-// src/board/review-stamp.ts
-var REVIEW_FIELD = "review";
-var REVIEW_SKIPPED = "skipped";
-var REVIEW_MISSING = "missing";
-var REVIEW_ASSUMED = "assumed";
-var REVIEW_SKIPPED_LINE = `${REVIEW_FIELD}: ${REVIEW_SKIPPED}`;
-var REVIEW_MISSING_LINE = `${REVIEW_FIELD}: ${REVIEW_MISSING}`;
-var REVIEW_ASSUMED_LINE = `${REVIEW_FIELD}: ${REVIEW_ASSUMED}`;
-function stampReviewSkipped(plan) {
-  return stampPlanField(plan, REVIEW_FIELD, REVIEW_SKIPPED);
-}
-function stampReviewMissing(plan) {
-  return stampPlanField(plan, REVIEW_FIELD, REVIEW_MISSING);
-}
-function stampReviewAssumed(plan) {
-  return stampPlanField(plan, REVIEW_FIELD, REVIEW_ASSUMED);
-}
-var ASSUMPTIONS_HEADING = "# Planned under assumptions";
-var ASSUMPTIONS_PREAMBLE = [
-  "The spec review found gaps, none of them blocking, so this plan was",
-  "written under the assumptions below. Each names the gap it was",
-  "written for; closing that gap in the spec is what replaces the guess."
-];
-function assumptionsHeading(gaps) {
-  const items = gaps.filter((gap) => gap.assumption !== null).map(assumedGapItem);
-  if (items.length === 0) {
-    throw new TypeError("board review stamp: no gap named an assumption, and there is no heading to open a plan with");
-  }
-  return [ASSUMPTIONS_HEADING, "", ...ASSUMPTIONS_PREAMBLE, "", ...items, "", ""].join(`
-`);
-}
-
-// src/board/gate.ts
-var SPEC_NOT_READY_EXIT = 3;
-var SPEC_NEEDS_WORK_LABEL = "spec:needs-work";
-function readGateFlags(args) {
-  return {
-    skipReview: args.includes(SKIP_REVIEW_FLAG),
-    comment: !args.includes(NO_COMMENT_FLAG)
-  };
-}
-function describeGap2(gap) {
-  return `   \u2022 "${gap.heading}": ${gap.what}`;
-}
-function remedyFor(issue3) {
-  return issue3 === null ? "   Close the gaps in the spec, then plan from it again." : `   Close the gaps, label the issue ${SPEC_READY_LABEL} again, and plan from it again.`;
-}
-function specNotReadyMessage(source, reading2, gaps, issue3 = null) {
-  return [
-    `\u274C ${source} is not ready to plan from: ${reading2}`,
-    ...gaps.map(describeGap2),
-    remedyFor(issue3)
-  ].join(`
-`);
-}
-function unreadReviewWarning(reading2, planPath) {
-  return `${reading2}; ${planPath} reads as written, so the plan stands unreviewed`;
-}
-function assumedReviewWarning(reading2, planPath) {
-  return `${reading2}, none of them blocking; ${planPath} is written under the assumptions the review named`;
-}
-function unreadReviewMessage(source, reading2, planIssues) {
-  return [
-    `\u274C ${source}: no plan stands \u2014 ${reading2}, and the plan the session wrote does not read as written:`,
-    ...planIssues.map((line) => `   ${line}`),
-    "   Plan from the spec again."
-  ].join(`
-`);
-}
-function isWrittenFile(repoRoot, path2) {
-  const full = resolve7(repoRoot, path2);
-  return existsSync11(full) && statSync4(full).isFile();
-}
-var NOT_READY_REASON = "the planner judged the spec not ready, so no plan stands.";
-var UNREAD_REASON = "no review came back and the plan does not read as written, so no plan stands.";
-var REJECTED_DIR = "rejected";
-function rejectedPath(path2) {
-  const parent = dirname6(path2);
-  return parent === "." ? join9(REJECTED_DIR, basename5(path2)) : join9(parent, REJECTED_DIR, basename5(path2));
-}
-function moveWritten(options, output, reason) {
-  for (const path2 of [options.planPath, options.prerequisitesPath]) {
-    if (!isWrittenFile(options.repoRoot, path2))
-      continue;
-    const destination = rejectedPath(path2);
-    try {
-      mkdirSync3(resolve7(options.repoRoot, dirname6(destination)), { recursive: true });
-      renameSync2(resolve7(options.repoRoot, path2), resolve7(options.repoRoot, destination));
-      output.info(`\uD83D\uDDC3  Moved ${path2} to ${destination}: ${reason}`);
-    } catch (error) {
-      output.warn(`${path2} was written against a refused review and could not be moved: ${messageOf(error)}`);
-    }
-  }
-}
-function readWrittenPlan(options) {
-  const { repoRoot, planPath } = options;
-  if (!isWrittenFile(repoRoot, planPath)) {
-    return { reads: false, issues: [`${planPath}: the session wrote no plan there`] };
-  }
-  try {
-    const { issues } = validatePlan(resolve7(repoRoot, planPath));
-    return { reads: issues.length === 0, issues: issues.map((issue3) => issueLine(planPath, issue3)) };
-  } catch (error) {
-    return { reads: false, issues: [`${planPath}: ${messageOf(error)}`] };
-  }
-}
-function standOrRefuse(options, review, output) {
-  const plan = readWrittenPlan(options);
-  if (plan.reads) {
-    output.warn(unreadReviewWarning(review.text, options.planPath));
-    return "unread";
-  }
-  moveWritten(options, output, UNREAD_REASON);
-  throw new CommandExit(SPEC_NOT_READY_EXIT, unreadReviewMessage(options.source, review.text, plan.issues));
-}
-function recordAssumptions(options, gaps, output) {
-  const { repoRoot, planPath } = options;
-  const unopened = (why) => {
-    output.warn(`${planPath} was not opened under the review's assumptions: ${why}`);
-  };
-  if (!isWrittenFile(repoRoot, planPath)) {
-    unopened("the session wrote no plan there");
-    return;
-  }
-  const file = resolve7(repoRoot, planPath);
-  let stamped;
-  try {
-    stamped = stampReviewAssumed(`${assumptionsHeading(gaps)}${readFileSync10(file, "utf8")}`);
-    writeFileSync4(file, stamped.text, "utf8");
-  } catch (error) {
-    unopened(messageOf(error));
-    return;
-  }
-  if (!stamped.recorded) {
-    output.warn(`${planPath} opens under the review's assumptions and records no ${REVIEW_ASSUMED_LINE}: ${stamped.note}`);
-    return;
-  }
-  output.info(`\uD83E\uDDED ${planPath} opens under the review's assumptions and records ${REVIEW_ASSUMED_LINE}.`);
-}
-async function publishGaps(issue3, gaps, body, output) {
-  try {
-    const write = await writeSpecReviewComment({
-      issue: issue3.number,
-      body: body(gaps),
-      board: issue3.board,
-      trust: issue3.trust
-    });
-    for (const passed2 of write.ignored)
-      output.warn(passed2.reason);
-    output.info(`\uD83D\uDCAC ${write.action === "posted" ? "Posted" : "Edited"} the review comment on issue #${String(issue3.number)}.`);
-  } catch (error) {
-    output.warn(`the review comment on issue #${String(issue3.number)} was not written: ${messageOf(error)}`);
-  }
-}
-async function swapLabels(issue3, output) {
-  try {
-    await issue3.board.swapLabels(issue3.number, SPEC_READY_LABEL, SPEC_NEEDS_WORK_LABEL);
-    output.info(`\uD83C\uDFF7  Swapped ${SPEC_READY_LABEL} for ${SPEC_NEEDS_WORK_LABEL} on issue #${String(issue3.number)}.`);
-  } catch (error) {
-    output.warn(`${SPEC_READY_LABEL} was not swapped for ${SPEC_NEEDS_WORK_LABEL} on issue` + ` #${String(issue3.number)}: ${messageOf(error)}`);
-  }
-}
-function nothingBlocks(review) {
-  return !review.gaps.some((gap) => gap.blocking);
-}
-async function planUnderAssumptions(options, review, output) {
-  output.warn(assumedReviewWarning(review.text, options.planPath));
-  recordAssumptions(options, review.gaps, output);
-  const { issue: issue3 } = options;
-  if (issue3 !== null) {
-    if (options.comment) {
-      await publishGaps(issue3, review.gaps, assumedReviewCommentBody, output);
-    } else {
-      output.info(`\uD83D\uDCAC ${NO_COMMENT_FLAG}: the gaps were not posted on issue #${String(issue3.number)}.`);
-    }
-  }
-  return "assumed";
-}
-async function enforceSpecReview(options) {
-  const { review, issue: issue3 } = options;
-  if (review === undefined)
-    return "unjudged";
-  if (review.ready)
-    return "ready";
-  const output = options.output ?? activeOutput();
-  if (review.answer !== "not-ready")
-    return standOrRefuse(options, review, output);
-  if (nothingBlocks(review))
-    return planUnderAssumptions(options, review, output);
-  moveWritten(options, output, NOT_READY_REASON);
-  if (issue3 !== null) {
-    if (options.comment) {
-      await publishGaps(issue3, review.gaps, specReviewCommentBody, output);
-    } else {
-      output.info(`\uD83D\uDCAC ${NO_COMMENT_FLAG}: the gaps were not posted on issue #${String(issue3.number)}.`);
-    }
-    await swapLabels(issue3, output);
-  }
-  throw new CommandExit(SPEC_NOT_READY_EXIT, specNotReadyMessage(options.source, review.text, review.gaps, issue3));
-}
-
 // src/board/issue.ts
-import { existsSync as existsSync12, mkdirSync as mkdirSync5, readFileSync as readFileSync11, statSync as statSync6, writeFileSync as writeFileSync5 } from "fs";
-import { dirname as dirname7, resolve as resolve9 } from "path";
+import { existsSync as existsSync12, mkdirSync as mkdirSync6, readFileSync as readFileSync12, statSync as statSync6, writeFileSync as writeFileSync5 } from "fs";
+import { dirname as dirname8, resolve as resolve10 } from "path";
 
 // src/refs/stamp.ts
 import { createHash } from "crypto";
@@ -9179,7 +9295,8 @@ function readStamp(entry, index) {
   const text = stringField(field2(entry, "text"), `${what}: text`);
   const fingerprint = readFingerprint(entry, what);
   if (!STAMPS_BY_KIND[refKind].includes(fingerprint.kind)) {
-    throw new RefsBlockError(`${what}: a ${refKind} is not stamped ${fingerprintText(fingerprint)}`);
+    const article = /^[aeiou]/.test(refKind) ? "an" : "a";
+    throw new RefsBlockError(`${what}: ${article} ${refKind} is not stamped ${fingerprintText(fingerprint)}`);
   }
   return Object.freeze({ kind: refKind, text, fingerprint });
 }
@@ -9224,8 +9341,8 @@ function carryRefsBlock(copy, text) {
 }
 
 // src/board/previous-copy.ts
-import { linkSync, mkdirSync as mkdirSync4, readdirSync as readdirSync6, statSync as statSync5, unlinkSync } from "fs";
-import { basename as basename6, extname, join as join10, resolve as resolve8 } from "path";
+import { linkSync, mkdirSync as mkdirSync5, readdirSync as readdirSync6, statSync as statSync5, unlinkSync } from "fs";
+import { basename as basename6, extname, join as join10, resolve as resolve9 } from "path";
 var PREFIX5 = "board previous copy";
 var PREVIOUS_DIR_NAME = "previous";
 var PREVIOUS_COPY_WARN_ABOVE = 50;
@@ -9264,14 +9381,14 @@ function linkUnderFreeName(source, directory, savedName, timestamp) {
 }
 function movePreviousCopy(options) {
   const { repoRoot, specsDir, path: path2 } = options;
-  const source = resolve8(repoRoot, path2);
+  const source = resolve9(repoRoot, path2);
   const directory = previousDir(specsDir);
-  const absoluteDirectory = resolve8(repoRoot, directory);
+  const absoluteDirectory = resolve9(repoRoot, directory);
   const savedName = basename6(path2);
   let name2;
   try {
     const timestamp = previousTimestamp(statSync5(source).mtime);
-    mkdirSync4(absoluteDirectory, { recursive: true });
+    mkdirSync5(absoluteDirectory, { recursive: true });
     name2 = linkUnderFreeName(source, absoluteDirectory, savedName, timestamp);
   } catch (error) {
     throw new Error(`${PREFIX5}: ${path2} could not be moved to ${directory}: ${messageOf(error)}`, { cause: error });
@@ -9293,7 +9410,7 @@ function isMissing(error) {
 function countPreviousCopies(repoRoot, specsDir) {
   const directory = previousDir(specsDir);
   try {
-    return readdirSync6(resolve8(repoRoot, directory), { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(COPY_EXTENSION)).length;
+    return readdirSync6(resolve9(repoRoot, directory), { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(COPY_EXTENSION)).length;
   } catch (error) {
     if (isMissing(error))
       return 0;
@@ -9497,13 +9614,13 @@ function readIfFile(file, what) {
     throw new CommandExit(ISSUE_REFUSAL_EXIT, `${what} ${file} is not a file, and a spec is one`);
   }
   try {
-    return readFileSync11(file, "utf8");
+    return readFileSync12(file, "utf8");
   } catch (error) {
     throw new CommandExit(ISSUE_REFUSAL_EXIT, `${what} ${file} could not be read: ${messageOf(error)}`);
   }
 }
 function readLocalNotes(repoRoot, specsDir, issue3) {
-  return readIfFile(resolve9(repoRoot, notesPath(specsDir, issue3)), "the local notes");
+  return readIfFile(resolve10(repoRoot, notesPath(specsDir, issue3)), "the local notes");
 }
 function snapshotDiffersMessage(path2, issue3) {
   return `${path2} is a snapshot of issue #${String(issue3)} that no longer matches it:` + " the issue body, or the local notes appended to it, changed since the snapshot was written;" + ` pass ${REFRESH_FLAG} to plan from the issue as it reads now, or --spec=${path2} to plan from` + " the snapshot as it stands";
@@ -9519,7 +9636,7 @@ function writeSpecSnapshot(options) {
     throw new CommandExit(ISSUE_REFUSAL_EXIT, notesCollisionMessage(path2, issue3.number));
   }
   const local = readLocalNotes(repoRoot, specsDir, issue3.number);
-  const absolute = resolve9(repoRoot, path2);
+  const absolute = resolve10(repoRoot, path2);
   const existing = readIfFile(absolute, "the spec snapshot");
   const text = carryRefsBlock(existing, snapshotText(issue3.body, local));
   const written = {
@@ -9538,7 +9655,7 @@ function writeSpecSnapshot(options) {
   }
   const previous = action === "created" ? null : movePreviousCopy({ repoRoot, specsDir, path: path2 }).path;
   try {
-    mkdirSync5(dirname7(absolute), { recursive: true });
+    mkdirSync6(dirname8(absolute), { recursive: true });
     writeFileSync5(absolute, text);
   } catch (error) {
     throw new Error(`${PREFIX6}: the snapshot ${path2} could not be written: ${messageOf(error)}`, { cause: error });
@@ -9557,7 +9674,7 @@ function rewriteAction(existing, body, notes, notesFile, refresh) {
 }
 
 // src/board/setup-config.ts
-import { readFileSync as readFileSync12 } from "fs";
+import { readFileSync as readFileSync13 } from "fs";
 function roadmapIssueIn(text, path2) {
   return parseConfigText(text, path2).values.roadmapIssue ?? null;
 }
@@ -9565,7 +9682,7 @@ function readRoadmapSetting(root) {
   const path2 = configFilePath(root);
   let text;
   try {
-    text = readFileSync12(path2, "utf8");
+    text = readFileSync13(path2, "utf8");
   } catch (error) {
     return { issue: null, text: "", problem: `${path2} could not be read: ${messageOf(error)}` };
   }
@@ -9615,7 +9732,7 @@ function withRoadmapIssue(text, issue3) {
 
 // src/board/setup.ts
 var PREFIX7 = "board setup";
-var MODULE_DIR = dirname8(fileURLToPath(import.meta.url));
+var MODULE_DIR = dirname9(fileURLToPath(import.meta.url));
 var ROADMAP_LABEL = `${GITHUB_LABELS.typePrefix}roadmap`;
 var BOARD_LABELS = Object.freeze([
   {
@@ -9779,7 +9896,7 @@ function readSpecTemplate(moduleDir = MODULE_DIR) {
   if (!existsSync13(source)) {
     throw new Error(`${PREFIX7}: the spec issue template is missing: no file at ${source}`);
   }
-  return readFileSync13(source, "utf8");
+  return readFileSync14(source, "utf8");
 }
 function writeShippedFile(root, file) {
   const path2 = join11(root, file.path);
@@ -9793,7 +9910,7 @@ function writeShippedFile(root, file) {
   }
   try {
     const text = file.read();
-    mkdirSync6(dirname8(path2), { recursive: true });
+    mkdirSync7(dirname9(path2), { recursive: true });
     writeFileSync6(path2, text, { encoding: "utf8", flag: "wx" });
     return partOf("template", name2, "created", `written from ${file.source}`);
   } catch (error) {
@@ -11935,14 +12052,14 @@ function withSubIssuesSummary(epic, row, claims, today) {
 import { existsSync as existsSync15, readdirSync as readdirSync8 } from "fs";
 
 // src/commands/doctor-refs.ts
-import { readdirSync as readdirSync7, readFileSync as readFileSync19, statSync as statSync9 } from "fs";
-import { join as join13, resolve as resolve12 } from "path";
+import { readdirSync as readdirSync7, readFileSync as readFileSync20, statSync as statSync9 } from "fs";
+import { join as join13, resolve as resolve13 } from "path";
 
 // src/board/refs-gate.ts
-import { readFileSync as readFileSync16 } from "fs";
+import { readFileSync as readFileSync17 } from "fs";
 
 // src/refs/reading.ts
-import { readFileSync as readFileSync14, writeFileSync as writeFileSync7 } from "fs";
+import { readFileSync as readFileSync15, writeFileSync as writeFileSync7 } from "fs";
 
 // src/refs/extract.ts
 var FILE_EXTENSIONS = new Set([
@@ -12218,7 +12335,7 @@ async function restampRefsText(options) {
   return answer2(rows, options.copy, body, Object.freeze(stamps), true);
 }
 async function overFile(options, reading2) {
-  const copy = readFileSync14(options.path, "utf8");
+  const copy = readFileSync15(options.path, "utf8");
   const { issue: issue3, verify, blockers } = options;
   const read = await reading2(blockers === undefined ? { copy, issue: issue3, verify } : { copy, issue: issue3, verify, blockers });
   if (read.changed)
@@ -12669,8 +12786,8 @@ function aheadNotClaimedWarning(ahead) {
 }
 
 // src/board/snapshot-settle.ts
-import { existsSync as existsSync14, readFileSync as readFileSync15, statSync as statSync8 } from "fs";
-import { resolve as resolve10 } from "path";
+import { existsSync as existsSync14, readFileSync as readFileSync16, statSync as statSync8 } from "fs";
+import { resolve as resolve11 } from "path";
 var PREFIX15 = "board snapshot settle";
 var DATE_LENGTH = 10;
 function savedCopyDate(savedAt) {
@@ -12689,7 +12806,7 @@ function readSavedCopy(absolute, path2) {
     const stat = statSync8(absolute);
     if (!stat.isFile())
       return null;
-    return { text: readFileSync15(absolute, "utf8"), savedAt: stat.mtime };
+    return { text: readFileSync16(absolute, "utf8"), savedAt: stat.mtime };
   } catch (error) {
     throw new Error(`${PREFIX15}: the saved copy ${path2} could not be read: ${messageOf(error)}`, { cause: error });
   }
@@ -12707,7 +12824,7 @@ async function settleSpecSnapshot(options) {
   const notes = notesPath(specsDir, issue3.number);
   if (path2 === notes)
     return write(refresh);
-  const saved = readSavedCopy(resolve10(repoRoot, path2), path2);
+  const saved = readSavedCopy(resolve11(repoRoot, path2), path2);
   if (saved === null)
     return write(refresh);
   const change = readSnapshotChange({
@@ -13459,7 +13576,7 @@ function memoiseVerifier(verify) {
 }
 async function acceptAll(options, acceptance, output) {
   const verify = memoiseVerifier(options.verify);
-  const before = await readRefsText({ copy: readFileSync16(options.path, "utf8"), issue: options.issue, verify });
+  const before = await readRefsText({ copy: readFileSync17(options.path, "utf8"), issue: options.issue, verify });
   const after = await restampCopyRefs({ path: options.path, issue: options.issue, verify });
   const accepted = before.rows.filter(isRefusedRow);
   listPassingRows(before.rows, output);
@@ -13489,12 +13606,12 @@ async function enforceRefsGate(options) {
 
 // src/refs/outline-cache.ts
 import { createHash as createHash2 } from "crypto";
-import { mkdirSync as mkdirSync7, readFileSync as readFileSync17, renameSync as renameSync3, writeFileSync as writeFileSync8 } from "fs";
-import { join as join12, resolve as resolve11 } from "path";
+import { mkdirSync as mkdirSync8, readFileSync as readFileSync18, renameSync as renameSync4, writeFileSync as writeFileSync8 } from "fs";
+import { join as join12, resolve as resolve12 } from "path";
 var OUTLINE_CACHE_DIR = join12(SCOPE_DIR, "cache", "outline", "v2");
 function readKept(path2) {
   try {
-    const payload = JSON.parse(readFileSync17(path2, "utf8"));
+    const payload = JSON.parse(readFileSync18(path2, "utf8"));
     return Array.isArray(payload) && payload.every((name2) => typeof name2 === "string") ? payload : null;
   } catch {
     return null;
@@ -13503,14 +13620,14 @@ function readKept(path2) {
 function keep(path2, dir, names) {
   const temporary = `${path2}.${String(process.pid)}.tmp`;
   try {
-    mkdirSync7(dir, { recursive: true });
+    mkdirSync8(dir, { recursive: true });
     writeFileSync8(temporary, JSON.stringify(names));
-    renameSync3(temporary, path2);
+    renameSync4(temporary, path2);
   } catch {}
 }
 function contentKey(root, file) {
   try {
-    return createHash2("sha256").update(readFileSync17(resolve11(root, file))).digest("hex");
+    return createHash2("sha256").update(readFileSync18(resolve12(root, file))).digest("hex");
   } catch {
     return null;
   }
@@ -13535,7 +13652,7 @@ function withOutlineCache(outline, root) {
 }
 
 // src/commands/plan/refs-check.ts
-import { readFileSync as readFileSync18 } from "fs";
+import { readFileSync as readFileSync19 } from "fs";
 import path2 from "path";
 var RAFA_PACKAGE_NAME = "@open-tomato/rafa";
 var RAFA_ENTRY = "src/rafa.ts";
@@ -13543,7 +13660,7 @@ var CHECKOUT_ROSTER_TIMEOUT_MS = 30000;
 var DESCRIBE_LINE = `bun ${RAFA_ENTRY} describe --output=json`;
 async function coreRoster() {
   const [{ CORE_REGISTRY }, { describeRegistry }] = await Promise.all([
-    import("./index-mzcz139z.js"),
+    import("./index-psv1sxkv.js"),
     import("./describe-pwhh0vws.js")
   ]);
   return describeRegistry(CORE_REGISTRY, version);
@@ -13592,7 +13709,7 @@ function resultData(stdout) {
 }
 function isRafaPackage(repoRoot) {
   try {
-    const manifest = recordOf(JSON.parse(readFileSync18(path2.join(repoRoot, "package.json"), "utf8")));
+    const manifest = recordOf(JSON.parse(readFileSync19(path2.join(repoRoot, "package.json"), "utf8")));
     return manifest?.["name"] === RAFA_PACKAGE_NAME;
   } catch {
     return false;
@@ -13761,7 +13878,7 @@ async function readCopy(file, input, verify) {
   const path3 = join13(input.specsDir, file.name);
   const empty = { issue: file.issue, path: path3, suspect: 0, dangling: 0, unknown: 0 };
   try {
-    const copy = readFileSync19(resolve12(input.root, path3), "utf8");
+    const copy = readFileSync20(resolve13(input.root, path3), "utf8");
     const { rows } = await readRefsText({ copy, issue: file.issue, verify: await verify() });
     const states = rows.map((row) => row.state);
     return Object.freeze({
@@ -13781,7 +13898,7 @@ function total(copies, field4) {
 async function readDoctorRefs(input, seams = {}) {
   let files;
   try {
-    const listed = listCopies(resolve12(input.root, input.specsDir));
+    const listed = listCopies(resolve13(input.root, input.specsDir));
     const only = input.issues === undefined ? null : new Set(input.issues);
     files = listed.filter((file) => only === null || only.has(file.issue));
   } catch (error) {
@@ -17507,7 +17624,7 @@ function createIssueListCommand(seams = DEFAULT_ISSUE_SEAMS) {
 var list_default = createIssueListCommand();
 
 // src/commands/release/status.ts
-import { existsSync as existsSync17, readdirSync as readdirSync9, readFileSync as readFileSync24 } from "fs";
+import { existsSync as existsSync17, readdirSync as readdirSync9, readFileSync as readFileSync25 } from "fs";
 import { join as join17 } from "path";
 
 // src/effort/store/changes.ts
@@ -17606,15 +17723,15 @@ function readPlanChanges(repoRoot, planStub2) {
 }
 
 // src/release/audit.ts
-import { readFileSync as readFileSync22 } from "fs";
+import { readFileSync as readFileSync23 } from "fs";
 import { join as join15 } from "path";
 
 // src/release/receipt.ts
-import { readFileSync as readFileSync21 } from "fs";
+import { readFileSync as readFileSync22 } from "fs";
 import { join as join14 } from "path";
 
 // src/release/version.ts
-import { readFileSync as readFileSync20, writeFileSync as writeFileSync9 } from "fs";
+import { readFileSync as readFileSync21, writeFileSync as writeFileSync9 } from "fs";
 var RELEASE_REMOTE = "origin";
 var RELEASE_BASE_BRANCH = "main";
 var VERSION_SHAPE = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([0-9A-Za-z.-]+))?(?:\+([0-9A-Za-z.-]+))?$/;
@@ -17706,7 +17823,7 @@ function writeManifestVersion(path3, next) {
   const unwritten = { path: path3, written: false, previous: null, version: next };
   let text;
   try {
-    text = readFileSync20(path3, "utf8");
+    text = readFileSync21(path3, "utf8");
   } catch (error) {
     return { ...unwritten, problem: `${path3} could not be read: ${messageOf(error)}` };
   }
@@ -17814,7 +17931,7 @@ function receiptProblem(verdict, version2, path3) {
 function readReceiptVerdict(root, configured, version2) {
   let text;
   try {
-    text = readFileSync21(join14(root, configured), "utf8");
+    text = readFileSync22(join14(root, configured), "utf8");
   } catch {
     return null;
   }
@@ -17915,7 +18032,7 @@ function auditSentence(finding) {
 function readAudit(root, configured, tagged) {
   let text;
   try {
-    text = readFileSync22(join15(root, configured), "utf8");
+    text = readFileSync23(join15(root, configured), "utf8");
   } catch {
     return { path: configured, read: false, sections: 0, findings: [] };
   }
@@ -18286,8 +18403,9 @@ function forecastSettle(input) {
 }
 
 // src/release/settle.ts
-import { readFileSync as readFileSync23, writeFileSync as writeFileSync10 } from "fs";
+import { readFileSync as readFileSync24, writeFileSync as writeFileSync10 } from "fs";
 import { join as join16 } from "path";
+var CHANGELOG_TITLE = "# Changelog";
 function releaseCommitSubject(version2) {
   return `chore: release ${version2}`;
 }
@@ -18325,7 +18443,17 @@ function readSettle(git, tree, settings) {
     return { ...basis, outcome: "failed", line: folded.line };
   if (folded.result === null)
     return { ...basis, outcome: "nothing" };
-  return { ...basis, outcome: "folded", version: folded.result.version, section: folded.result.section };
+  const changelog = changelogMissingAt(git, commit, settings.releaseChangelog);
+  if (typeof changelog === "object")
+    return { outcome: "unread", strategy: strategy.name, problem: changelog.problem };
+  return { ...basis, outcome: "folded", version: folded.result.version, section: folded.result.section, changelogMissing: changelog };
+}
+function changelogMissingAt(git, commit, changelog) {
+  const path3 = gitPathOf(changelog);
+  const listed = git(["ls-tree", "--name-only", commit, "--", path3]);
+  if (!listed.ok)
+    return { problem: `${commit}:${path3} could not be listed: ${gitSaid(listed)}` };
+  return listed.stdout.trim() === "";
 }
 function unbuilt(reading2, problem) {
   return { ...reading2, outcome: "unbuilt", problem };
@@ -18342,18 +18470,24 @@ function writeVersion(root, reading2, versionFile) {
 function writeChangelog(root, reading2, changelog) {
   const path3 = join16(root, gitPathOf(changelog));
   let text;
+  let created = false;
   try {
-    text = readFileSync23(path3, "utf8");
+    text = readFileSync24(path3, "utf8");
   } catch (error) {
-    return { problem: `${changelog} could not be read: ${messageOf(error)}` };
+    if (errorCode(error) !== "ENOENT")
+      return { problem: `${changelog} could not be read: ${messageOf(error)}` };
+    text = `${CHANGELOG_TITLE}
+`;
+    created = true;
   }
   const inserted = insertChangelogEntry(text, reading2.section);
+  const verb = created ? "created" : "written";
   try {
     writeFileSync10(path3, inserted.text);
   } catch (error) {
-    return { problem: `${changelog} could not be written: ${messageOf(error)}` };
+    return { problem: `${changelog} could not be ${verb}: ${messageOf(error)}` };
   }
-  return { point: inserted.point };
+  return { point: inserted.point, created };
 }
 function commitRelease(git, reading2, settings) {
   const files = [gitPathOf(settings.releaseVersionFile), gitPathOf(settings.releaseChangelog)];
@@ -18392,7 +18526,8 @@ function buildSettle(worktree, settings) {
     outcome: "built",
     release: committed.release,
     deleted: reading2.fragments.map((each) => each.path),
-    insertPoint: changelog.point
+    insertPoint: changelog.point,
+    createdChangelog: changelog.created ? settings.releaseChangelog : null
   };
 }
 
@@ -18485,6 +18620,7 @@ var CODE_FENCE4 = /^ {0,3}(?:```|~~~)/;
 var RELEASE_TAG = /^v?(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?)$/;
 var NUMERIC_IDENTIFIER = /^(?:0|[1-9]\d*)$/;
 var DEFAULT_RELEASE_SEAMS = Object.freeze({});
+var MISSING_CHANGELOG_CELL = "missing; rafa release settle creates it";
 function compareIdentifiers(left, right) {
   const leftNumeric = NUMERIC_IDENTIFIER.test(left);
   const rightNumeric = NUMERIC_IDENTIFIER.test(right);
@@ -18574,7 +18710,7 @@ function untaggedVersions(released, tags) {
 }
 function textOf(path3) {
   try {
-    return readFileSync24(path3, "utf8");
+    return readFileSync25(path3, "utf8");
   } catch {
     return null;
   }
@@ -18604,11 +18740,12 @@ function readUntagged(root, configured, tags) {
       path: configured,
       released: [],
       versions: [],
+      missing: !existsSync17(resolved),
       problem: `the changelog could not be read at ${resolved}`
     };
   }
   const released = changelogVersions(text);
-  return { path: configured, released, versions: untaggedVersions(released, tags), problem: null };
+  return { path: configured, released, versions: untaggedVersions(released, tags), missing: false, problem: null };
 }
 function readBranch(git) {
   const result = git(["rev-parse", "--abbrev-ref", "HEAD"]);
@@ -18676,6 +18813,8 @@ function tagCell(reading2) {
   return reading2.latest === null ? `${NOTHING}, ${held}` : `${reading2.latest.tag}, ${held}`;
 }
 function untaggedCell(reading2) {
+  if (reading2.missing)
+    return MISSING_CHANGELOG_CELL;
   if (reading2.problem !== null)
     return UNREADABLE2;
   if (reading2.released.length === 0)
@@ -18700,7 +18839,7 @@ function problemsOf(reading2) {
   return [
     reading2.versionFile.problem,
     reading2.tags.problem,
-    reading2.untagged.problem,
+    reading2.untagged.missing ? null : reading2.untagged.problem,
     reading2.plan.problem,
     ...reading2.waiting.problems
   ].filter((problem) => problem !== null);
@@ -18714,7 +18853,7 @@ function renderStatus(reading2) {
     untaggedCell(reading2.untagged),
     pendingCell(reading2.plan),
     waitingCell(reading2.waiting) ?? UNREADABLE2,
-    auditCell(reading2.audit) ?? UNREADABLE2
+    auditCell(reading2.audit) ?? (reading2.untagged.missing ? MISSING_CHANGELOG_CELL : UNREADABLE2)
   ];
   const [versionLine, tagLine, untaggedLine, pendingLine, waitingLine, auditLine] = LABELS.map((label, index) => `${INDENT3}${label.padEnd(width)}${GAP}${cells[index] ?? ""}`);
   const under = (line) => `${INDENT3}${" ".repeat(width)}${GAP}${line}`;
@@ -18834,7 +18973,7 @@ function createReleaseStatusCommand(seams = DEFAULT_RELEASE_SEAMS) {
 var status_default = createReleaseStatusCommand();
 
 // src/project/bin-path.ts
-import { delimiter as delimiter2, isAbsolute as isAbsolute3, join as join18, resolve as resolve13 } from "path";
+import { delimiter as delimiter2, isAbsolute as isAbsolute3, join as join18, resolve as resolve14 } from "path";
 var RAFA_BIN_DIR = join18(SCOPE_DIR, "bin");
 var BUN_BIN_DIR = join18(".bun", "bin");
 function exportLine(rafaBin) {
@@ -18853,7 +18992,7 @@ function canonical(path3, fs) {
   try {
     return fs.realpath(path3);
   } catch {
-    return resolve13(path3);
+    return resolve14(path3);
   }
 }
 function indexOf(entries, dir, fs) {
@@ -18883,21 +19022,21 @@ import {
   chmodSync,
   copyFileSync,
   existsSync as existsSync19,
-  mkdirSync as mkdirSync8,
+  mkdirSync as mkdirSync9,
   readdirSync as readdirSync11,
-  readFileSync as readFileSync25,
+  readFileSync as readFileSync26,
   realpathSync as realpathSync2,
-  renameSync as renameSync4,
+  renameSync as renameSync5,
   rmSync as rmSync2,
   statSync as statSync11,
   symlinkSync
 } from "fs";
-import { basename as basename7, delimiter as delimiter3, dirname as dirname9, join as join20, relative as relative6, resolve as resolve15 } from "path";
+import { basename as basename7, delimiter as delimiter3, dirname as dirname10, join as join20, relative as relative6, resolve as resolve16 } from "path";
 
 // src/start/runtime.ts
 import { existsSync as existsSync18, readdirSync as readdirSync10, realpathSync, statSync as statSync10 } from "fs";
 import { homedir as homedir5 } from "os";
-import { isAbsolute as isAbsolute4, join as join19, relative as relative5, resolve as resolve14, sep } from "path";
+import { isAbsolute as isAbsolute4, join as join19, relative as relative5, resolve as resolve15, sep } from "path";
 
 // src/start/session.ts
 import { randomUUID as randomUUID4 } from "crypto";
@@ -19119,7 +19258,7 @@ function resolveRuntime(value, places) {
     throw refusal2([`\u274C Refusing to start: \`--runtime\` names no runtime. Spell it ${SPELLING}.`]);
   }
   const isVersion = VERSION_SHAPE2.test(value);
-  const named3 = isVersion ? join19(places.home, RUNTIME_SUBDIR, value, RUNTIME_ENTRY) : resolve14(places.cwd, value);
+  const named3 = isVersion ? join19(places.home, RUNTIME_SUBDIR, value, RUNTIME_ENTRY) : resolve15(places.cwd, value);
   refuseInsideSource(value, named3, places);
   const entry = entryOf2(value, named3, isVersion, places.home);
   const real = realpathSync(entry);
@@ -19212,7 +19351,7 @@ function realOrResolved(path3) {
   try {
     return realpathSync(path3);
   } catch {
-    return resolve14(path3);
+    return resolve15(path3);
   }
 }
 async function runRuntime(entry, words, run) {
@@ -19360,17 +19499,17 @@ function runtimeRefusalLines(runtimeDir, version2) {
   ];
 }
 function listTrackers(repoRoot, planDir) {
-  const dir = resolve15(repoRoot, planDir);
+  const dir = resolve16(repoRoot, planDir);
   return entryNames(dir).filter((entry) => TRACKER_NAME.test(entry)).sort((a, b) => a.localeCompare(b)).map((entry) => join20(dir, entry)).filter((path3) => statSync11(path3).isFile()).map((path3) => relative6(repoRoot, path3));
 }
 function openTrackers(repoRoot, planDir) {
   return listTrackers(repoRoot, planDir).flatMap((path3) => {
-    const task = findNextTask(readFileSync25(join20(repoRoot, path3), "utf8"));
+    const task = findNextTask(readFileSync26(join20(repoRoot, path3), "utf8"));
     return task ? [{ path: path3, task }] : [];
   });
 }
 function readManifestVersion2(repoRoot) {
-  const manifest = JSON.parse(readFileSync25(join20(repoRoot, "package.json"), "utf8"));
+  const manifest = JSON.parse(readFileSync26(join20(repoRoot, "package.json"), "utf8"));
   const record = typeof manifest === "object" && manifest !== null ? manifest : {};
   if (record["name"] !== name) {
     throw new Error(`${join20(repoRoot, "package.json")} names ${JSON.stringify(record["name"])}, not ${name}: this is no rafa checkout`);
@@ -19382,7 +19521,7 @@ function readManifestVersion2(repoRoot) {
   return version2;
 }
 function copyTree(from, to) {
-  mkdirSync8(to, { recursive: true });
+  mkdirSync9(to, { recursive: true });
   let copied = 0;
   const entries = readdirSync11(from, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
   for (const entry of entries) {
@@ -19413,27 +19552,27 @@ function replaceTree(from, to) {
 }
 function swapIn(staging, to) {
   if (!existsSync19(to)) {
-    renameSync4(staging, to);
+    renameSync5(staging, to);
     return;
   }
   const outgoing = `${temporaryName(to)}.outgoing`;
   rmSync2(outgoing, { recursive: true, force: true });
-  renameSync4(to, outgoing);
+  renameSync5(to, outgoing);
   try {
-    renameSync4(staging, to);
+    renameSync5(staging, to);
   } catch (err) {
-    renameSync4(outgoing, to);
+    renameSync5(outgoing, to);
     throw err;
   }
   rmSync2(outgoing, { recursive: true, force: true });
 }
 function relink(linkPath, target) {
-  mkdirSync8(dirname9(linkPath), { recursive: true });
+  mkdirSync9(dirname10(linkPath), { recursive: true });
   const temporary = temporaryName(linkPath);
   rmSync2(temporary, { force: true });
   try {
     symlinkSync(target, temporary);
-    renameSync4(temporary, linkPath);
+    renameSync5(temporary, linkPath);
   } catch (err) {
     rmSync2(temporary, { force: true });
     throw err;
@@ -19451,7 +19590,7 @@ function runBuild(repoRoot, lines) {
     cwd: repoRoot,
     env: {
       ...process.env,
-      PATH: [dirname9(process.execPath), process.env["PATH"] ?? ""].join(delimiter3)
+      PATH: [dirname10(process.execPath), process.env["PATH"] ?? ""].join(delimiter3)
     },
     stdin: "ignore",
     stdout: stdio,
@@ -19488,7 +19627,7 @@ function runInstall(seams, options) {
   log(`runtime root: ${runtimeRoot}`);
   log(`link: ${linkPath}`);
   const version2 = inStage("manifest", () => readManifestVersion2(repoRoot));
-  const planDir = inStage("config", () => resolve15(repoRoot, loadConfig({ root: repoRoot, home }, {}, seams.warn).config.planDir));
+  const planDir = inStage("config", () => resolve16(repoRoot, loadConfig({ root: repoRoot, home }, {}, seams.warn).config.planDir));
   log(`plan dir: ${planDir}`);
   const open = inStage("trackers", () => openTrackers(repoRoot, planDir));
   if (open.length > 0)
@@ -19536,14 +19675,14 @@ function replaceFile(source, target) {
   try {
     copyFileSync(source, temporary);
     chmodSync(temporary, statSync11(source).mode & 4095);
-    renameSync4(temporary, target);
+    renameSync5(temporary, target);
   } catch (err) {
     rmSync2(temporary, { force: true });
     throw err;
   }
 }
 function temporaryName(path3) {
-  return join20(dirname9(path3), `.${basename7(path3)}.snapshot-${process.pid}`);
+  return join20(dirname10(path3), `.${basename7(path3)}.snapshot-${process.pid}`);
 }
 
 // src/commands/self-update.ts
@@ -19651,7 +19790,7 @@ function createSelfUpdateCommand(seams = DEFAULT_SELF_UPDATE_SEAMS) {
 var self_update_default = createSelfUpdateCommand();
 
 // src/commands/plan/list.ts
-import { existsSync as existsSync20, readdirSync as readdirSync12, readFileSync as readFileSync26 } from "fs";
+import { existsSync as existsSync20, readdirSync as readdirSync12, readFileSync as readFileSync27 } from "fs";
 import { join as join21 } from "path";
 var USAGE5 = "rafa plan list";
 var OPEN_HINT = "Type it bare: rafa plan list --open";
@@ -19659,8 +19798,8 @@ function listing(dir, stub) {
   const plan = join21(dir, planFileName(stub, false));
   const trackerPath = join21(dir, planFileName(stub, true));
   const tracker = isFile(trackerPath) ? trackerPath : null;
-  const planModel = parsePlan(readFileSync26(plan, "utf8"));
-  const counted4 = tracker === null ? planModel : parsePlan(readFileSync26(tracker, "utf8"));
+  const planModel = parsePlan(readFileSync27(plan, "utf8"));
+  const counted4 = tracker === null ? planModel : parsePlan(readFileSync27(tracker, "utf8"));
   return { stub, plan, tracker, tasks: countTasks(counted4.tasks), issues: planModel.issues.length };
 }
 function listPlans(plans) {
@@ -19849,7 +19988,7 @@ async function openNextRelations(context, seams) {
 
 // src/commands/loop/loop-sessions.ts
 import { execFileSync } from "child_process";
-import { readFileSync as readFileSync27 } from "fs";
+import { readFileSync as readFileSync28 } from "fs";
 import { join as join22, relative as relative7 } from "path";
 
 // src/effort/store/task-finishes.ts
@@ -20006,15 +20145,20 @@ function readSessionChecklist(root, record) {
   const file = [trackerPathFor(plan), plan].find((path3) => isFile(path3));
   if (file === undefined)
     return null;
-  const content = readFileSync27(file, "utf8");
+  const content = readFileSync28(file, "utf8");
   return { file, tasks: parsePlan(content).tasks, lines: content.split(`
 `) };
 }
-function phaseNote(record) {
-  return `(phase ${sessionPhase(record)})`;
+function phaseNote(record, counts = null) {
+  return `(phase ${notedPhase(record, counts)})`;
+}
+function notedPhase(record, counts) {
+  const phase = sessionPhase(record);
+  const everyTaskTicked = counts !== null && counts.total > 0 && counts.done === counts.total;
+  return phase === "task" && record.state === "running" && record.task === null && everyTaskTicked ? "wrap-up" : phase;
 }
 function phasedCounts(counts, record) {
-  return `${counts.done}/${counts.total} done ${phaseNote(record)}, ${counts.blocked} blocked, ${counts.open} open`;
+  return `${counts.done}/${counts.total} done ${phaseNote(record, counts)}, ${counts.blocked} blocked, ${counts.open} open`;
 }
 function checkboxAt(checklist, line) {
   return checklist?.tasks.find((task) => task.lineNum === line - 1)?.status ?? null;
@@ -20155,7 +20299,7 @@ function readBoardBody(body) {
 }
 
 // src/board/codeowners.ts
-import { readFileSync as readFileSync28, statSync as statSync12 } from "fs";
+import { readFileSync as readFileSync29, statSync as statSync12 } from "fs";
 import { join as join23 } from "path";
 var CODEOWNERS_LOCATIONS = Object.freeze([
   ".github/CODEOWNERS",
@@ -20216,7 +20360,7 @@ function readCodeowners(root) {
     return null;
   let text;
   try {
-    text = readFileSync28(join23(root, path3), "utf8");
+    text = readFileSync29(join23(root, path3), "utf8");
   } catch (error) {
     const why = error instanceof Error ? error.message : String(error);
     throw new Error(`Cannot read ${path3}: ${why}`, { cause: error });
@@ -20990,12 +21134,12 @@ function pickerFor(followed, seams) {
 }
 
 // src/commands/pr/merge-cleanup.ts
-import { existsSync as existsSync22, readFileSync as readFileSync29 } from "fs";
+import { existsSync as existsSync22, readFileSync as readFileSync30 } from "fs";
 import { join as join24 } from "path";
 
 // src/release/enabled.ts
 import { statSync as statSync13 } from "fs";
-import { resolve as resolve16 } from "path";
+import { resolve as resolve17 } from "path";
 function isRegularFile(full) {
   try {
     return statSync13(full).isFile();
@@ -21004,7 +21148,7 @@ function isRegularFile(full) {
   }
 }
 function readFile(repoRoot, path3) {
-  const resolved = resolve16(repoRoot, path3);
+  const resolved = resolve17(repoRoot, path3);
   return { path: path3, resolved, present: isRegularFile(resolved) };
 }
 function resolveReleaseEnabled(settings, repoRoot) {
@@ -21155,7 +21299,7 @@ function cleanUpAfterMerge(git, merged, report2) {
 }
 function textOf2(path3) {
   try {
-    return readFileSync29(path3, "utf8");
+    return readFileSync30(path3, "utf8");
   } catch {
     return "";
   }
@@ -22588,8 +22732,8 @@ function wantsHint(flags) {
 }
 var DEFAULT_HINT_SEAMS = Object.freeze({});
 function afterDelay(ms) {
-  return new Promise((resolve17) => {
-    setTimeout(resolve17, ms).unref();
+  return new Promise((resolve18) => {
+    setTimeout(resolve18, ms).unref();
   });
 }
 function silenced() {
@@ -23131,8 +23275,8 @@ import { fileURLToPath as fileURLToPath2 } from "url";
 import { homedir as homedir6 } from "os";
 
 // src/notices/notices.ts
-import { mkdirSync as mkdirSync9, readFileSync as readFileSync30, writeFileSync as writeFileSync11 } from "fs";
-import { dirname as dirname10, join as join25 } from "path";
+import { mkdirSync as mkdirSync10, readFileSync as readFileSync31, writeFileSync as writeFileSync11 } from "fs";
+import { dirname as dirname11, join as join25 } from "path";
 var NOTICE_IDS = Object.freeze(["alpha", "danger"]);
 var FEEDBACK_URL = "https://github.com/open-tomato/rafa/issues/new/choose";
 var ROADMAP_URL = "https://github.com/open-tomato/rafa/issues/31";
@@ -23145,7 +23289,7 @@ function isNoticeId(value) {
 function readDismissed(home) {
   let raw;
   try {
-    raw = readFileSync30(noticesPath(home), "utf8");
+    raw = readFileSync31(noticesPath(home), "utf8");
   } catch {
     return [];
   }
@@ -23164,7 +23308,7 @@ function readDismissed(home) {
 function writeDismissed(home, ids) {
   const all = NOTICE_IDS.filter((id2) => ids.includes(id2) || readDismissed(home).includes(id2));
   const path3 = noticesPath(home);
-  mkdirSync9(dirname10(path3), { recursive: true });
+  mkdirSync10(dirname11(path3), { recursive: true });
   writeFileSync11(path3, `${JSON.stringify({ dismissed: all }, null, 2)}
 `);
 }
@@ -23450,8 +23594,8 @@ function haltIfWrapUpMoved(options, seams = {}) {
 
 // src/project/roots.ts
 import { spawnSync as spawnSync2 } from "child_process";
-import { accessSync, constants, readFileSync as readFileSync31, statSync as statSync14 } from "fs";
-import { isAbsolute as isAbsolute5, join as join26, resolve as resolve17 } from "path";
+import { accessSync, constants, readFileSync as readFileSync32, statSync as statSync14 } from "fs";
+import { isAbsolute as isAbsolute5, join as join26, resolve as resolve18 } from "path";
 var REFUSED_ROOTS = Object.freeze([
   { path: "/", why: "is the filesystem root" },
   { path: "/var", why: "holds system state" },
@@ -23470,7 +23614,7 @@ var MONOREPO_MARKER_FILES = Object.freeze([
 var PACKAGE_JSON = "package.json";
 var DISK_ROOTS_FILE_SYSTEM = Object.freeze({
   ...DISK_FILE_SYSTEM,
-  readFile: (path3) => readFileSync31(path3, "utf8"),
+  readFile: (path3) => readFileSync32(path3, "utf8"),
   isDirectory: (path3) => statSync14(path3).isDirectory(),
   assertWritable: (path3) => accessSync(path3, constants.W_OK)
 });
@@ -23513,7 +23657,7 @@ function realOrSpelled(path3, fs) {
   try {
     return fs.realpath(path3);
   } catch {
-    return resolve17(path3);
+    return resolve18(path3);
   }
 }
 function namedRoots(home, fs) {
@@ -23555,7 +23699,7 @@ function writeRefusal(given, real, fs) {
 }
 function refusalOf(given, named3, fs) {
   const resolved = resolveReal(given, fs);
-  const byName2 = namedRefusal(given, resolved.real ?? resolve17(given), named3);
+  const byName2 = namedRefusal(given, resolved.real ?? resolve18(given), named3);
   if (byName2 !== null)
     return byName2;
   if (resolved.real === null) {
@@ -23907,9 +24051,46 @@ function commitTaskWork(options) {
   };
 }
 
+// src/start/background-wait.ts
+var WAIT_LINE_CAP = 200;
+var FENCE_LINE5 = /^\s*(?:```|~~~)/;
+var WAIT_PHRASES = [
+  /\b(?:running|runs|run)\s+in\s+(?:the\s+)?background\b/i,
+  /\bwait(?:ing)?\s+(?:for|on)\s+(?:the|a|its)\s+(?:completion\s+)?notification\b/i,
+  /\brun_in_background\b/
+];
+function unfencedLines(output) {
+  const lines = [];
+  let fenced = false;
+  for (const line of output.split(`
+`)) {
+    if (FENCE_LINE5.test(line)) {
+      fenced = !fenced;
+      continue;
+    }
+    if (!fenced)
+      lines.push(line);
+  }
+  return lines;
+}
+function capped(line) {
+  const trimmed = line.trim();
+  return trimmed.length > WAIT_LINE_CAP ? `${trimmed.slice(0, WAIT_LINE_CAP - 1)}\u2026` : trimmed;
+}
+function readBackgroundWait(output) {
+  if (output.trim().length === 0)
+    return null;
+  const reading2 = parseReport(output);
+  if (reading2.present || reading2.reason !== "no-block")
+    return null;
+  const waiting = unfencedLines(output).find((line) => WAIT_PHRASES.some((phrase) => phrase.test(line)));
+  return waiting === undefined ? null : capped(waiting);
+}
+
 // src/start/commit.ts
 var DROPPED_BLOCKER_FIELD = /^blockers\[\d+\]$/;
 var NO_REPORT_HOLD = "no report: the session wrote no rafa:report block the loop could read";
+var BACKGROUND_WAIT_HOLD = "no report: the session ended its turn waiting on a command left running in the background:";
 var NO_COMMIT_HOLD = "no commit: the task changed no tracked file";
 var NOTHING_REPORTED_OR_COMMITTED = "the session wrote no report block and changed no tracked file";
 function indentBlock(text) {
@@ -23935,8 +24116,12 @@ function holdsOf(reading2) {
 function leftNothingBehind(attempt2, reported) {
   return !reported && attempt2.outcome === "nothing-to-commit";
 }
-function holdsAfterCommit(holds4, silent) {
-  return silent ? [...holds4, NO_REPORT_HOLD, NO_COMMIT_HOLD] : holds4;
+function noReportHold(output) {
+  const waiting = output === undefined ? null : readBackgroundWait(output);
+  return waiting === null ? NO_REPORT_HOLD : `${BACKGROUND_WAIT_HOLD} ${waiting}`;
+}
+function holdsAfterCommit(holds4, silent, output) {
+  return silent ? [...holds4, noReportHold(output), NO_COMMIT_HOLD] : holds4;
 }
 function commitFinishedTask(options) {
   const { taskInfo, trackerPath } = options;
@@ -23957,7 +24142,7 @@ function commitFinishedTask(options) {
     return attempt2;
   }
   const silent = leftNothingBehind(attempt2, reported);
-  const holds4 = holdsAfterCommit(reportHolds, silent);
+  const holds4 = holdsAfterCommit(reportHolds, silent, options.output);
   const held = holds4.length > 0;
   const marked = silent && writeTrackerBlocker(trackerPath, taskInfo.lineNum, NOTHING_REPORTED_OR_COMMITTED);
   if (!marked) {
@@ -23988,8 +24173,8 @@ function finishCleanExit(options) {
   const reading2 = parseReport(output);
   const reported = reading2.present;
   const reportHolds = reported ? holdsOf(reading2) : [];
-  const attempt2 = commitFinishedTask({ ...task, holds: reportHolds, reported });
-  const holds4 = holdsAfterCommit(reportHolds, leftNothingBehind(attempt2, reported));
+  const attempt2 = commitFinishedTask({ ...task, holds: reportHolds, reported, output });
+  const holds4 = holdsAfterCommit(reportHolds, leftNothingBehind(attempt2, reported), output);
   const blocked3 = attempt2.outcome === "failed" || holds4.length > 0;
   return {
     attempt: attempt2,
@@ -24038,7 +24223,7 @@ var SCRIPT_EXTENSIONS = [
   ".cjs",
   ".ts"
 ];
-var FENCE_LINE5 = /^ {0,3}(?:```|~~~)/;
+var FENCE_LINE6 = /^ {0,3}(?:```|~~~)/;
 var HEADING_LINE2 = /^ {0,3}(#{1,6})\s+(.*)$/;
 var NUMBERED_ITEM = /^ {0,3}\d+[.)]\s+\S/;
 var CONTINUATION = /^ {2,}\S/;
@@ -24072,7 +24257,7 @@ function bodySections(body) {
   const headings = [];
   let fenced = false;
   lines.forEach((line, index) => {
-    if (FENCE_LINE5.test(line)) {
+    if (FENCE_LINE6.test(line)) {
       fenced = !fenced;
       return;
     }
@@ -24111,7 +24296,7 @@ function numberedRuns(body) {
     steps = 0;
   };
   bodyLines2(body).forEach((text, index) => {
-    if (FENCE_LINE5.test(text)) {
+    if (FENCE_LINE6.test(text)) {
       fenced = !fenced;
       return;
     }
@@ -24199,7 +24384,7 @@ function withoutFences(text) {
   const kept = [];
   let fenced = false;
   for (const line of bodyLines2(text)) {
-    if (FENCE_LINE5.test(line)) {
+    if (FENCE_LINE6.test(line)) {
       fenced = !fenced;
       continue;
     }
@@ -24258,7 +24443,7 @@ function extractedDate(body) {
 function errorString(body) {
   let fenced = false;
   for (const line of bodyLines2(body)) {
-    if (FENCE_LINE5.test(line)) {
+    if (FENCE_LINE6.test(line)) {
       fenced = !fenced;
       continue;
     }
@@ -24861,7 +25046,7 @@ function writeProgress(repoRoot, planStub2, dir = repoRoot) {
 }
 
 // src/inventory/search/rank.ts
-import { readFileSync as readFileSync32 } from "fs";
+import { readFileSync as readFileSync33 } from "fs";
 var SEARCH_LIMIT = 12;
 var MIN_WORD_LENGTH = 2;
 var MIN_PREFIX_LENGTH = 4;
@@ -24983,7 +25168,7 @@ function rankCandidates(question, candidates, limit = SEARCH_LIMIT) {
     return [];
   return candidates.map((candidate) => scoreCandidate(candidate, words)).filter((ranked) => ranked.score > 0).sort((a, b) => b.score - a.score).slice(0, limit);
 }
-function readRankCandidate(record, read = (path3) => readFileSync32(path3, "utf8")) {
+function readRankCandidate(record, read = (path3) => readFileSync33(path3, "utf8")) {
   let text;
   try {
     text = read(record.path);
@@ -25232,7 +25417,7 @@ function renderInheritedSection(failures) {
 
 // src/start/preflight.ts
 import { randomUUID as randomUUID7 } from "crypto";
-import { existsSync as existsSync28, readFileSync as readFileSync34 } from "fs";
+import { existsSync as existsSync28, readFileSync as readFileSync35 } from "fs";
 import { homedir as homedir7 } from "os";
 import { basename as basename8, join as join28 } from "path";
 
@@ -25350,11 +25535,11 @@ function developmentApplied(report2) {
 }
 
 // src/preflight/first-dispatch.ts
-import { readFileSync as readFileSync33 } from "fs";
+import { readFileSync as readFileSync34 } from "fs";
 var TICKED_TASK = /^- \[[xX]\] (.+)/;
 function readIfReadable(path3) {
   try {
-    return readFileSync33(path3, "utf8");
+    return readFileSync34(path3, "utf8");
   } catch {
     return null;
   }
@@ -25696,7 +25881,7 @@ function driftLines(report2) {
 
 // src/start/preflight-drift.ts
 var DRIFT_EVERY = 2;
-var RECORD_EXTENSION = ".json";
+var RECORD_EXTENSION2 = ".json";
 function countRunRecords(root) {
   let names2;
   try {
@@ -25706,7 +25891,7 @@ function countRunRecords(root) {
       return 0;
     throw error;
   }
-  return names2.filter((name2) => name2.endsWith(RECORD_EXTENSION) && isSessionId(name2.slice(0, -RECORD_EXTENSION.length))).length;
+  return names2.filter((name2) => name2.endsWith(RECORD_EXTENSION2) && isSessionId(name2.slice(0, -RECORD_EXTENSION2.length))).length;
 }
 function isDriftRun(count) {
   return count > 0 && count % DRIFT_EVERY === 0;
@@ -25819,7 +26004,7 @@ function agentSourcePath(planPath) {
 }
 function readIfReadable2(path3) {
   try {
-    return readFileSync34(path3, "utf8");
+    return readFileSync35(path3, "utf8");
   } catch {
     return null;
   }
@@ -26075,6 +26260,7 @@ function runTaskSession(prompt, flags, sessionId, settingSources, served = [], c
   const options = cwd === undefined ? {} : { cwd };
   return runClaudeCaptured(prompt, settingSources, [SESSION_ID_FLAG2, sessionId, ...flags], spawn, served, options);
 }
+var HALTED_EXIT_CODE = 1;
 var BLOCKER_PROMPT_PREFIX = "An earlier run of this task left it blocked on: ";
 function blockerLines(blocker) {
   return blocker === null || blocker.trim().length === 0 ? [] : [`${BLOCKER_PROMPT_PREFIX}${escapeBlockerText(blocker)}`];
@@ -26135,22 +26321,28 @@ async function dispatchTask(options) {
   const handed = await handOut(options.handout, task, resolution, options.repoRoot);
   const prompt = withStamp(buildTaskPrompt(taskText, options.promptContent, injection.text, options.knownMissing, taskInfo.blocker ?? null, { skills: renderSkillsSection(handed.skills), lessons: renderLessonsSection(handed.lessons) }, options.base, options.inherited, options.alwaysRun));
   const served = serveForSession(options.serving, resolution);
-  const sessionId = (options.newSessionId ?? randomUUID8)();
-  const session = await run(prompt, flags, sessionId, options.settingSources, served, options.checkout);
-  return {
+  const record = {
     taskText,
     prompt,
     flags,
     served,
     declaration,
     injection,
-    sessionId,
-    exitCode: session.exitCode,
-    output: session.stdout,
     resolver: handed.resolver,
     skillsOffered: handed.skills,
     lessonsOffered: handed.lessons
   };
+  if (haltBeforeSpawn(options.guard ?? null, taskInfo)) {
+    return { ...record, sessionId: "", exitCode: HALTED_EXIT_CODE, output: "", halted: true };
+  }
+  const sessionId = (options.newSessionId ?? randomUUID8)();
+  const session = await run(prompt, flags, sessionId, options.settingSources, served, options.checkout);
+  return { ...record, sessionId, exitCode: session.exitCode, output: session.stdout, halted: false };
+}
+function haltBeforeSpawn(guard, taskInfo) {
+  if (guard === null)
+    return false;
+  return haltIfCheckoutMoved({ expected: guard.expected, trackerPath: guard.trackerPath, taskInfo }, guard.seams);
 }
 function serveForSession(serving, resolution) {
   if (serving === null)
@@ -26240,7 +26432,7 @@ async function storeTaskReport(options) {
 }
 
 // src/start/loop-events.ts
-import { appendFileSync, mkdirSync as mkdirSync10 } from "fs";
+import { appendFileSync, mkdirSync as mkdirSync11 } from "fs";
 import { join as join29 } from "path";
 var MINUTE_MS = 60000;
 var TOKENS_PER_K = 1000;
@@ -26292,7 +26484,7 @@ function bindEventsFile(root, sessionId, warn2 = (line) => {
 }) {
   const file = eventsFilePath(root, sessionId);
   try {
-    mkdirSync10(runsDir(root), { recursive: true });
+    mkdirSync11(runsDir(root), { recursive: true });
   } catch {}
   bound = { file, warn: warn2, warned: false };
   return file;
@@ -26386,20 +26578,20 @@ async function holdWhilePaused(options) {
 
 // src/start/plan-path.ts
 import { existsSync as existsSync29 } from "fs";
-import { resolve as resolve18 } from "path";
+import { resolve as resolve19 } from "path";
 var DEFAULT_PLAN_FILE = "PLAN.md";
 function resolvePlanPath(repoRoot, planDir, planArg) {
   if (planArg)
-    return resolve18(repoRoot, planArg);
-  const inPlanDir = resolve18(repoRoot, planDir, DEFAULT_PLAN_FILE);
-  return existsSync29(inPlanDir) ? inPlanDir : resolve18(repoRoot, DEFAULT_PLAN_FILE);
+    return resolve19(repoRoot, planArg);
+  const inPlanDir = resolve19(repoRoot, planDir, DEFAULT_PLAN_FILE);
+  return existsSync29(inPlanDir) ? inPlanDir : resolve19(repoRoot, DEFAULT_PLAN_FILE);
 }
 
 // src/start/risk-total.ts
-import { readFileSync as readFileSync36 } from "fs";
+import { readFileSync as readFileSync37 } from "fs";
 
 // src/plan/risk.ts
-import { readFileSync as readFileSync35 } from "fs";
+import { readFileSync as readFileSync36 } from "fs";
 import { isAbsolute as isAbsolute6, join as join30, relative as relative8 } from "path";
 
 // src/plan/risk/accounts.ts
@@ -26959,7 +27151,7 @@ function located(finding2, file, task) {
 }
 function readText5(path3) {
   try {
-    return readFileSync35(path3, "utf8");
+    return readFileSync36(path3, "utf8");
   } catch {
     return null;
   }
@@ -27061,7 +27253,7 @@ function spawningRunners(root) {
 }
 async function readRiskTotalLine(input, seams = {}) {
   const makeRunners = seams.runners ?? spawningRunners;
-  const report2 = await assessPlanRisk({ path: input.planPath, text: readFileSync36(input.planPath, "utf8") }, {
+  const report2 = await assessPlanRisk({ path: input.planPath, text: readFileSync37(input.planPath, "utf8") }, {
     repoRoot: input.repoRoot,
     home: input.home,
     settingSources: input.config.settingSources,
@@ -27621,7 +27813,7 @@ function readRunArgs(args) {
 
 // src/start/worktree.ts
 import { realpathSync as realpathSync4 } from "fs";
-import { join as join31, resolve as resolve20 } from "path";
+import { join as join31, resolve as resolve21 } from "path";
 
 // src/start/claim-catch-up.ts
 var OWN_COMMIT_FORMAT = "--format=%H%x09%P%x09%s";
@@ -27686,9 +27878,9 @@ function readClaimCatchUp(git, branch, base) {
 }
 
 // src/start/worktree-dir.ts
-import { resolve as resolve19 } from "path";
+import { resolve as resolve20 } from "path";
 function worktreeDirAt(projectRoot3, worktreeDir) {
-  return resolve19(projectRoot3, worktreeDir);
+  return resolve20(projectRoot3, worktreeDir);
 }
 
 // src/start/worktree.ts
@@ -27752,7 +27944,7 @@ function canonicalPath(path3) {
   try {
     return realpathSync4(path3);
   } catch {
-    return resolve20(path3);
+    return resolve21(path3);
   }
 }
 function readExisting(listing2, branch, path3) {
@@ -27925,13 +28117,13 @@ async function settleRunCheckout(request, seams = {}) {
 }
 
 // src/start/suite-step.ts
-import { existsSync as existsSync35, mkdirSync as mkdirSync13, readFileSync as readFileSync43, renameSync as renameSync6, writeFileSync as writeFileSync16 } from "fs";
+import { existsSync as existsSync36, mkdirSync as mkdirSync14, readFileSync as readFileSync44, renameSync as renameSync7, writeFileSync as writeFileSync17 } from "fs";
 import { constants as constants2 } from "os";
-import { basename as basename11, dirname as dirname13, join as join36 } from "path";
+import { basename as basename11, dirname as dirname15, join as join37 } from "path";
 
 // src/suite/baseline.ts
-import { existsSync as existsSync30, mkdirSync as mkdirSync11, readFileSync as readFileSync37, renameSync as renameSync5, writeFileSync as writeFileSync13 } from "fs";
-import { basename as basename9, dirname as dirname11, join as join32 } from "path";
+import { existsSync as existsSync30, mkdirSync as mkdirSync12, readFileSync as readFileSync38, renameSync as renameSync6, writeFileSync as writeFileSync13 } from "fs";
+import { basename as basename9, dirname as dirname12, join as join32 } from "path";
 var BASELINE_VERSION = 1;
 var BASELINE_FILE_PREFIX = "SUITE_BASELINE";
 var PLAN_FILE_NAME2 = /^PLAN(?:_TRACKER)?(-.+)?\.md$/;
@@ -27941,7 +28133,7 @@ function baselinePathFor(trackerPath) {
   if (match === null) {
     throw new RangeError(`baselinePathFor: ${trackerPath} is not a PLAN or PLAN_TRACKER file`);
   }
-  return join32(dirname11(trackerPath), `${BASELINE_FILE_PREFIX}${match[1] ?? ""}.json`);
+  return join32(dirname12(trackerPath), `${BASELINE_FILE_PREFIX}${match[1] ?? ""}.json`);
 }
 function copyFailure(failure3) {
   return failure3.message === undefined ? { file: failure3.file, name: failure3.name } : { file: failure3.file, name: failure3.name, message: failure3.message };
@@ -27960,11 +28152,11 @@ function baselineOf(result, recordedAt, commit) {
   };
 }
 function writeBaseline(path3, baseline) {
-  mkdirSync11(dirname11(path3), { recursive: true });
+  mkdirSync12(dirname12(path3), { recursive: true });
   const temporary = `${path3}.${process.pid}.tmp`;
   writeFileSync13(temporary, `${JSON.stringify(baseline, null, 2)}
 `, "utf8");
-  renameSync5(temporary, path3);
+  renameSync6(temporary, path3);
 }
 function isStringOrNull(value) {
   return value === null || typeof value === "string";
@@ -28008,7 +28200,7 @@ function readBaseline(path3) {
     return { state: "missing" };
   let text;
   try {
-    text = readFileSync37(path3, "utf8");
+    text = readFileSync38(path3, "utf8");
   } catch (error) {
     const reason = error instanceof Error ? error.message : String(error);
     return { state: "unreadable", reason };
@@ -28103,8 +28295,8 @@ async function readPlanOwns(options) {
 }
 
 // src/suite/run.ts
-import { existsSync as existsSync31, mkdirSync as mkdirSync12, readFileSync as readFileSync38, rmSync as rmSync4, writeFileSync as writeFileSync14 } from "fs";
-import { basename as basename10, dirname as dirname12, extname as extname2, isAbsolute as isAbsolute7, join as join33 } from "path";
+import { existsSync as existsSync31, mkdirSync as mkdirSync13, readFileSync as readFileSync39, rmSync as rmSync4, writeFileSync as writeFileSync14 } from "fs";
+import { basename as basename10, dirname as dirname13, extname as extname2, isAbsolute as isAbsolute7, join as join33 } from "path";
 
 // src/suite/unhandled.ts
 var UNHANDLED_HEADING = "# Unhandled error between tests";
@@ -28214,7 +28406,7 @@ var OUTPUT_SUFFIX = ".output.txt";
 function outputFileFor(junitFile) {
   const name2 = basename10(junitFile);
   const stem = name2.endsWith(JUNIT_SUFFIX) ? name2.slice(0, -JUNIT_SUFFIX.length) : name2.slice(0, name2.length - extname2(name2).length);
-  return join33(dirname12(junitFile), `${stem}${OUTPUT_SUFFIX}`);
+  return join33(dirname13(junitFile), `${stem}${OUTPUT_SUFFIX}`);
 }
 function suiteEnv(base) {
   return Object.fromEntries(Object.entries(base).filter(([key]) => key !== CLAUDE_CODE_ENV));
@@ -28322,7 +28514,7 @@ function readJunit(path3) {
     return { junit: "missing", failures: [] };
   let text;
   try {
-    text = readFileSync38(path3, "utf8");
+    text = readFileSync39(path3, "utf8");
   } catch {
     return { junit: "unreadable", failures: [] };
   }
@@ -28346,7 +28538,7 @@ async function runSuite(options) {
   }
   const command = suiteCommand(options.junitFile, options.paths, options.changedSince);
   const outputFile = outputFileFor(options.junitFile);
-  mkdirSync12(dirname12(options.junitFile), { recursive: true });
+  mkdirSync13(dirname13(options.junitFile), { recursive: true });
   rmSync4(options.junitFile, { force: true });
   rmSync4(outputFile, { force: true });
   const spawn = options.spawn ?? spawnSuite;
@@ -28361,7 +28553,7 @@ async function runSuite(options) {
 }
 
 // src/suite/scope.ts
-import { existsSync as existsSync32, readdirSync as readdirSync14, readFileSync as readFileSync39 } from "fs";
+import { existsSync as existsSync32, readdirSync as readdirSync14, readFileSync as readFileSync40 } from "fs";
 import { isAbsolute as isAbsolute8, join as join34, relative as relative9, sep as sep2 } from "path";
 var BUNFIG_FILE = "bunfig.toml";
 var TEST_FILE_NAME = /[._](?:test|spec)\.(?:tsx?|jsx?|[cm][jt]s)$/;
@@ -28449,7 +28641,7 @@ function readPreloadFiles(root) {
   if (!existsSync32(path3))
     return { state: "missing", files: [] };
   try {
-    return { state: "read", files: preloadFilesOf(readFileSync39(path3, "utf8"), root) };
+    return { state: "read", files: preloadFilesOf(readFileSync40(path3, "utf8"), root) };
   } catch (error) {
     const reason = error instanceof Error ? error.message : String(error);
     return { state: "unreadable", files: [], reason };
@@ -28605,7 +28797,7 @@ async function runLintStep(input) {
 }
 
 // src/start/suite-blocker.ts
-import { readFileSync as readFileSync40, writeFileSync as writeFileSync15 } from "fs";
+import { readFileSync as readFileSync41, writeFileSync as writeFileSync15 } from "fs";
 function failingFiles(failures) {
   const counts = new Map;
   for (const failure3 of failures)
@@ -28689,7 +28881,7 @@ function blockRepairAgain(trackerPath, content, line, blocker) {
   return writeTrackerBlocker(trackerPath, line, blocker) ? { line, inserted: false } : null;
 }
 function writeRepairTask(trackerPath, blocker, site) {
-  const content = readFileSync40(trackerPath, "utf8");
+  const content = readFileSync41(trackerPath, "utf8");
   const repaired = existingRepairOf(content, site);
   if (repaired !== null)
     return blockRepairAgain(trackerPath, content, repaired, blocker);
@@ -28699,7 +28891,7 @@ function writeRepairTask(trackerPath, blocker, site) {
 }
 
 // src/start/sweep-timing.ts
-import { existsSync as existsSync34, readFileSync as readFileSync41 } from "fs";
+import { existsSync as existsSync34, readFileSync as readFileSync42 } from "fs";
 var SLOW_SWEEP_SECONDS = 10;
 var SUITE_TAG = /<(\/?)testsuite\b([^>]*?)(\/?)>/g;
 function fileTimeOf(attributes) {
@@ -28742,7 +28934,7 @@ function readFileTimes(path3) {
   if (!existsSync34(path3))
     return [];
   try {
-    return parseJunitFileTimes(readFileSync41(path3, "utf8")) ?? [];
+    return parseJunitFileTimes(readFileSync42(path3, "utf8")) ?? [];
   } catch {
     return [];
   }
@@ -28816,8 +29008,300 @@ function foldResults(first, second, stopCode) {
   };
   return first.noTestFiles === true && second.noTestFiles === true ? { ...folded2, noTestFiles: true } : folded2;
 }
+
+// src/start/type-step.ts
+import { existsSync as existsSync35, mkdtempSync, realpathSync as realpathSync5, rmSync as rmSync5, symlinkSync as symlinkSync2, writeFileSync as writeFileSync16 } from "fs";
+import { tmpdir } from "os";
+import { dirname as dirname14, join as join36, relative as relative11, resolve as resolve22, sep as sep3 } from "path";
+var TEST_FILE_SUFFIX = ".test.ts";
+var TSC_FLAGS = ["--noEmit", "--pretty", "false"];
+var ERRORS_LISTED2 = 10;
+var NODE_MODULES = "node_modules";
+var TSC_BIN = [".bin", "tsc"];
+var SCRATCH_NAME = "tsconfig.json";
+var FILE_ERROR = /^(.+)\((\d+),(\d+)\): error (TS\d+): (.*)$/;
+var GLOBAL_ERROR = /^error (TS\d+): (.*)$/;
+var NOTHING_RAN2 = { ran: false, red: false, interrupted: false, blocker: null };
+var GREEN = { ran: true, red: false, interrupted: false, blocker: null };
+var INTERRUPTED = { ran: true, red: false, interrupted: true, blocker: null };
+async function runTsc(options) {
+  const proc = Bun.spawn([...options.argv], {
+    cwd: options.cwd,
+    stdin: "ignore",
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  const [stdout, stderr, exitCode] = await Promise.all([
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text(),
+    proc.exited
+  ]);
+  return { exitCode, stdout, stderr };
+}
+function typeLabel(task) {
+  return `type step after "${task}"`;
+}
+function pathsOf(status) {
+  return /^[RC]/.test(status) ? 2 : 1;
+}
+function readTypeFiles(git, base) {
+  const result = git(["diff", "--name-status", "-z", "--find-renames", "--diff-filter=d", base, "HEAD"]);
+  if (!result.ok) {
+    activeOutput().warn(`\u26A0\uFE0F  git diff from ${base} did not answer (${gitSaid(result) || "nothing said"}); the type step runs nothing.`);
+    return null;
+  }
+  const fields = result.stdout.split("\x00").filter((field4) => field4 !== "");
+  const files = [];
+  for (let index = 0;index < fields.length; ) {
+    const status = fields[index] ?? "";
+    const count = pathsOf(status);
+    const paths = fields.slice(index + 1, index + 1 + count);
+    index += 1 + count;
+    const head = paths[paths.length - 1];
+    if (head === undefined || !head.endsWith(TEST_FILE_SUFFIX))
+      continue;
+    files.push({ head, base: status.startsWith("A") ? null : paths[0] ?? null });
+  }
+  return files;
+}
+function realPath(path3) {
+  try {
+    return realpathSync5(path3);
+  } catch {
+    return resolve22(path3);
+  }
+}
+function walkStop(git) {
+  const result = git(["rev-parse", "--path-format=absolute", "--git-common-dir"]);
+  const common = result.stdout.trim();
+  return result.ok && common !== "" ? dirname14(realPath(common)) : null;
+}
+function isUnder(dir, root) {
+  return dir === root || dir.startsWith(root.endsWith(sep3) ? root : `${root}${sep3}`);
+}
+function findNodeModules(checkout, git) {
+  const start = realPath(checkout);
+  const stop = walkStop(git);
+  const top = stop !== null && isUnder(start, stop) ? stop : start;
+  for (let dir = start;; dir = dirname14(dir)) {
+    const modules = join36(dir, NODE_MODULES);
+    if (existsSync35(join36(modules, ...TSC_BIN)))
+      return modules;
+    if (dir === top || dirname14(dir) === dir)
+      return null;
+  }
+}
+function scratchTsconfig(tree, files, modules) {
+  const root = resolve22(tree);
+  return `${JSON.stringify({
+    extends: join36(root, "tsconfig.json"),
+    compilerOptions: { typeRoots: [join36(resolve22(modules), "@types")] },
+    files: files.map((file) => join36(root, file)),
+    include: []
+  }, null, 2)}
+`;
+}
+function parseTscOutput(stdout, cwd) {
+  const errors = [];
+  for (const line of stdout.split(`
+`)) {
+    const atFile = FILE_ERROR.exec(line);
+    const global = atFile === null ? GLOBAL_ERROR.exec(line) : null;
+    const last = errors[errors.length - 1];
+    if (atFile !== null) {
+      const [, file = "", row = "0", column = "0", code = "", message = ""] = atFile;
+      errors.push({ file: relative11(cwd, resolve22(cwd, file)), line: Number(row), column: Number(column), code, message });
+    } else if (global !== null) {
+      errors.push({ file: null, line: 0, column: 0, code: global[1] ?? "", message: global[2] ?? "" });
+    } else if (line.startsWith("  ") && last !== undefined) {
+      errors[errors.length - 1] = { ...last, message: `${last.message}
+${line.trimEnd()}` };
+    }
+  }
+  return errors;
+}
+function identity(error) {
+  return `${error.code} ${error.message}`;
+}
+function newErrors(head, base) {
+  const left = new Map;
+  for (const error of base) {
+    const key = `${error.file ?? ""}\x00${identity(error)}`;
+    left.set(key, (left.get(key) ?? 0) + 1);
+  }
+  return head.filter((error) => {
+    const key = `${error.file ?? ""}\x00${identity(error)}`;
+    const count = left.get(key) ?? 0;
+    if (count === 0)
+      return true;
+    left.set(key, count - 1);
+    return false;
+  });
+}
+function errorLine2(error) {
+  const first = error.message.split(`
+`)[0] ?? "";
+  return `${error.file ?? "(no file)"}:${error.line}:${error.column} ${error.code} ${first}`;
+}
+function listed(errors) {
+  const shown2 = errors.slice(0, ERRORS_LISTED2).map(errorLine2);
+  return errors.length > ERRORS_LISTED2 ? [...shown2, `...and ${errors.length - ERRORS_LISTED2} more`] : shown2;
+}
+function typeBlockerText(label, base, errors) {
+  const files = [...new Set(errors.map((error) => error.file ?? ""))];
+  const shown2 = listed(errors).join("; ").replace(/\.$/u, "");
+  return `The runner's ${label} found type errors in the task's test files that ${base} did not hold. ` + `New errors: ${shown2}. ` + `Fix them, then check ${files.join(" ")} with tsc ${TSC_FLAGS.join(" ")} -p over a tsconfig outside the checkout ` + "that extends its tsconfig.json by absolute path and lists them under files.";
+}
+function brokenBlockerText(label, run, said) {
+  return `The runner's ${label} could not type-check the task's test files: tsc exited ${run.exitCode}${said === undefined ? " and printed no error." : `: ${said}`}`;
+}
+function configError(errors, scratch, cwd) {
+  const config = relative11(cwd, scratch);
+  return errors.find((error) => error.file === null || error.file === config);
+}
+function firstLine7(run) {
+  return `${run.stdout}
+${run.stderr}`.split(`
+`).map((line) => line.trim()).find((line) => line !== "");
+}
+async function checkTree(input, modules, tree, files) {
+  const scratchDir = mkdtempSync(join36(tmpdir(), "rafa-type-step-"));
+  const scratch = join36(scratchDir, SCRATCH_NAME);
+  try {
+    writeFileSync16(scratch, scratchTsconfig(tree, files, modules), "utf8");
+    const tsc = join36(modules, ...TSC_BIN);
+    let run;
+    try {
+      run = await (input.runTypes ?? runTsc)({ cwd: tree, argv: [tsc, "-p", scratch, ...TSC_FLAGS] });
+    } catch (error) {
+      return { kind: "threw", why: messageOf(error) };
+    }
+    if (run.exitCode === input.stopCode || input.isInterrupted?.() === true)
+      return { kind: "interrupted" };
+    const errors = parseTscOutput(run.stdout, tree);
+    const config = configError(errors, scratch, tree);
+    if (config !== undefined)
+      return { kind: "broken", run, said: `error ${config.code}: ${config.message.split(`
+`)[0] ?? ""}` };
+    if (run.exitCode !== 0 && errors.length === 0)
+      return { kind: "broken", run, said: firstLine7(run) };
+    const wanted = new Set(files);
+    return { kind: "read", errors: errors.filter((error) => error.file !== null && wanted.has(error.file)) };
+  } finally {
+    rmSync5(scratchDir, { recursive: true, force: true });
+  }
+}
+async function inBaseTree(input, label, modules, check) {
+  const parent = mkdtempSync(join36(tmpdir(), "rafa-type-base-"));
+  const tree = join36(parent, "tree");
+  try {
+    const added = input.git(["worktree", "add", "--detach", tree, input.base]);
+    if (!added.ok) {
+      activeOutput().warn(`\u26A0\uFE0F  The ${label} could not check out ${input.base} (${gitSaid(added) || "nothing said"}); it reads no error as new.`);
+      return null;
+    }
+    if (existsSync35(modules) && !existsSync35(join36(tree, NODE_MODULES)))
+      symlinkSync2(modules, join36(tree, NODE_MODULES));
+    if (!existsSync35(join36(tree, "tsconfig.json")))
+      return { kind: "read", errors: [] };
+    return await check(tree);
+  } finally {
+    if (existsSync35(tree)) {
+      const removed = input.git(["worktree", "remove", "--force", tree]);
+      if (!removed.ok)
+        activeOutput().warn(`\u26A0\uFE0F  The ${label} could not remove its worktree ${tree} (${gitSaid(removed) || "nothing said"}).`);
+    }
+    rmSync5(parent, { recursive: true, force: true });
+  }
+}
+async function baseErrors(input, label, modules, files) {
+  const pairs = files.filter((file) => file.base !== null);
+  if (pairs.length === 0)
+    return { errors: [] };
+  const run = await inBaseTree(input, label, modules, (tree) => checkTree(input, modules, tree, pairs.map((file) => file.base)));
+  if (run === null)
+    return { outcome: GREEN };
+  if (run.kind === "interrupted")
+    return { outcome: interrupted(label) };
+  if (run.kind !== "read") {
+    const why = run.kind === "threw" ? run.why : brokenBlockerText(label, run.run, run.said);
+    activeOutput().warn(`\u26A0\uFE0F  The ${label} could not check the files at ${input.base} (${why}); it reads no error as new.`);
+    return { outcome: GREEN };
+  }
+  const headOf = new Map(pairs.map((file) => [file.base, file.head]));
+  return { errors: run.errors.map((error) => ({ ...error, file: headOf.get(error.file ?? "") ?? error.file })) };
+}
+function interrupted(label) {
+  activeOutput().info(`\u23F9  The ${label} was interrupted by SIGINT: read as a stop, not as errors.`);
+  return INTERRUPTED;
+}
+function filesToCheck(input, label) {
+  if (!existsSync35(join36(input.checkout, "tsconfig.json"))) {
+    activeOutput().info(`\uD83D\uDD0E ${label}: no tsconfig.json at the checkout root; nothing to type-check.`);
+    return null;
+  }
+  const files = readTypeFiles(input.git, input.base);
+  if (files === null)
+    return null;
+  if (files.length > 0)
+    return files;
+  activeOutput().info(`\uD83D\uDD0E ${label}: the task changed no ${TEST_FILE_SUFFIX} file; nothing to type-check.`);
+  return null;
+}
+async function runTypeStep(input) {
+  const label = typeLabel(input.task);
+  const files = filesToCheck(input, label);
+  if (files === null)
+    return NOTHING_RAN2;
+  const modules = findNodeModules(input.checkout, input.git) ?? join36(resolve22(input.checkout), NODE_MODULES);
+  const head = await checkTree(input, modules, input.checkout, files.map((file) => file.head));
+  if (head.kind === "threw") {
+    activeOutput().warn(`\u26A0\uFE0F  The ${label} could not run tsc (${head.why}); the run goes on without it.`);
+    return NOTHING_RAN2;
+  }
+  if (head.kind === "interrupted")
+    return interrupted(label);
+  if (head.kind === "broken") {
+    const blocker = brokenBlockerText(label, head.run, head.said);
+    activeOutput().info(`\uD83D\uDD0E ${label}: ${blocker}`);
+    return { ran: true, red: true, interrupted: false, blocker };
+  }
+  const ran = `\uD83D\uDD0E ${label}: tsc over ${files.length} test file(s)`;
+  if (head.errors.length === 0) {
+    activeOutput().info(`${ran}: no type error.`);
+    return GREEN;
+  }
+  const base = await baseErrors(input, label, modules, files.filter((file) => head.errors.some((error) => error.file === file.head)));
+  if ("outcome" in base)
+    return base.outcome;
+  const added = newErrors(head.errors, base.errors);
+  activeOutput().info(`${ran}: ${head.errors.length} error(s), ${head.errors.length - added.length} already held at ${input.base}, ${added.length} not held.`);
+  for (const line of listed(added))
+    activeOutput().info(`   ${line}`);
+  if (added.length === 0)
+    return GREEN;
+  return { ran: true, red: true, interrupted: false, blocker: typeBlockerText(label, input.base, added) };
+}
+
+// src/start/task-step-checks.ts
+function lintTask(context, seams, input) {
+  const isInterrupted = context.isInterrupted ?? (() => false);
+  return runLintStep({ checkout: context.checkout, base: input.base, task: input.task, git: seams.git, runLint: seams.runLint, stopCode: SIGINT_EXIT_CODE, isInterrupted });
+}
+function typeCheckTask(context, seams, input) {
+  const isInterrupted = context.isInterrupted ?? (() => false);
+  return runTypeStep({ checkout: context.checkout, base: input.base, task: input.task, git: seams.git, runTypes: seams.runTypes, stopCode: SIGINT_EXIT_CODE, isInterrupted });
+}
+async function taskDiffChecks(context, seams, input, result) {
+  if (isStepInterrupted(context, result))
+    return {};
+  const lint = await lintTask(context, seams, input);
+  if (lint.interrupted)
+    return { lint };
+  return { lint, types: await typeCheckTask(context, seams, input) };
+}
 // src/start/suite-stage-step.ts
-import { readFileSync as readFileSync42 } from "fs";
+import { readFileSync as readFileSync43 } from "fs";
 function stageSince(trackerPath, baseline) {
   const taken = readStageLedger(stageLedgerPathFor(trackerPath)).filter((entry) => entry.commit !== null);
   return taken.at(-1)?.commit ?? baseline?.commit ?? null;
@@ -28873,7 +29357,7 @@ async function runStageStep(context, stage, baseline) {
 }
 async function runDueStageSteps(context, baseline) {
   const ledger = readStageLedger(stageLedgerPathFor(context.trackerPath));
-  const due = dueStages(readFileSync42(context.trackerPath, "utf8"), ledger);
+  const due = dueStages(readFileSync43(context.trackerPath, "utf8"), ledger);
   const outcomes = [];
   for (const stage of due) {
     const outcome2 = await runStageStep(context, stage, baseline);
@@ -28900,19 +29384,20 @@ function seamsOf(context) {
     listTestFiles: seams.listTestFiles ?? listTestFiles,
     readPreloadFiles: seams.readPreloadFiles ?? readPreloadFiles,
     now: seams.now ?? (() => new Date),
-    runLint: seams.runLint ?? runEslint
+    runLint: seams.runLint ?? runEslint,
+    runTypes: seams.runTypes ?? runTsc
   };
 }
 function junitFileFor(repoRoot, sessionId, kind) {
-  return join36(runsDir(repoRoot), sessionId, "suite", `${kind}.junit.xml`);
+  return join37(runsDir(repoRoot), sessionId, "suite", `${kind}.junit.xml`);
 }
 function alwaysRunJunitFileFor(repoRoot, sessionId, kind = "task") {
-  return join36(runsDir(repoRoot), sessionId, "suite", `${kind}-always-run.junit.xml`);
+  return join37(runsDir(repoRoot), sessionId, "suite", `${kind}-always-run.junit.xml`);
 }
 function stageLedgerPathFor(trackerPath) {
   const baselinePath = baselinePathFor(trackerPath);
   const name2 = basename11(baselinePath).replace(BASELINE_FILE_PREFIX, STAGE_LEDGER_PREFIX);
-  return join36(dirname13(baselinePath), name2);
+  return join37(dirname15(baselinePath), name2);
 }
 function isLedgerEntry(value) {
   if (typeof value !== "object" || value === null)
@@ -28936,11 +29421,11 @@ function parseLedger(text) {
   return stages;
 }
 function readStageLedger(path3) {
-  if (!existsSync35(path3))
+  if (!existsSync36(path3))
     return [];
   let parsed2;
   try {
-    parsed2 = parseLedger(readFileSync43(path3, "utf8"));
+    parsed2 = parseLedger(readFileSync44(path3, "utf8"));
   } catch (error) {
     parsed2 = messageOf(error);
   }
@@ -28950,11 +29435,11 @@ function readStageLedger(path3) {
   return [];
 }
 function writeStageLedger(path3, entries) {
-  mkdirSync13(dirname13(path3), { recursive: true });
+  mkdirSync14(dirname15(path3), { recursive: true });
   const temporary = `${path3}.${process.pid}.tmp`;
-  writeFileSync16(temporary, `${JSON.stringify({ version: STAGE_LEDGER_VERSION, stages: entries }, null, 2)}
+  writeFileSync17(temporary, `${JSON.stringify({ version: STAGE_LEDGER_VERSION, stages: entries }, null, 2)}
 `, "utf8");
-  renameSync6(temporary, path3);
+  renameSync7(temporary, path3);
 }
 function addToLedger(trackerPath, added) {
   if (added.length === 0)
@@ -28998,9 +29483,9 @@ function readDiff(git, from) {
 }
 function verdictOf3(result, baseline) {
   const { fresh, known } = splitFailures(result.failures, baseline);
-  const newErrors = Math.max(0, (result.errors ?? 0) - (baseline?.errors ?? 0));
+  const newErrors2 = Math.max(0, (result.errors ?? 0) - (baseline?.errors ?? 0));
   const unreported2 = result.exitCode !== 0 && result.summary === null && result.noTestFiles !== true;
-  return { fresh, known, newErrors, unreported: unreported2 };
+  return { fresh, known, newErrors: newErrors2, unreported: unreported2 };
 }
 function isStepInterrupted(context, result) {
   return result.exitCode === SIGINT_EXIT_CODE || context.isInterrupted?.() === true;
@@ -29038,6 +29523,15 @@ function announce2(label, result, known) {
   if (known.length > KNOWN_LISTED)
     activeOutput().info(`   ...and ${known.length - KNOWN_LISTED} more.`);
 }
+function checksOf(settling) {
+  return [settling.lint, settling.types].filter((check) => check !== undefined);
+}
+function isCheckInterrupted(settling) {
+  return checksOf(settling).some((check) => check.interrupted);
+}
+function checkBlockers(settling) {
+  return checksOf(settling).flatMap((check) => check.blocker === null ? [] : [check.blocker]);
+}
 function settleInterrupted(seams, settling) {
   const { kind, label, result } = settling;
   const step = { ...stepOf(settling, result, []), interrupted: true };
@@ -29048,32 +29542,32 @@ function settleInterrupted(seams, settling) {
 }
 function settleStep(context, seams, settling) {
   const { kind, label, result, baseline } = settling;
-  if (isStepInterrupted(context, result) || settling.lint?.interrupted === true)
+  if (isStepInterrupted(context, result) || isCheckInterrupted(settling))
     return settleInterrupted(seams, settling);
   const verdict = verdictOf3(result, baseline);
   const step = stepOf(settling, result, verdict.fresh);
   recordStep(seams, step);
   announce2(label, result, verdict.known);
-  const lintBlocker = settling.lint?.blocker ?? null;
-  if (!isRed(verdict) && lintBlocker === null)
+  const checked = checkBlockers(settling);
+  if (!isRed(verdict) && checked.length === 0)
     return { kind, step, red: false, interrupted: false, blocker: null, blockedLine: null, repairInserted: false };
   const tested = isRed(verdict) ? [blockerText(label, result, verdict)] : [];
-  const blocker = [...tested, ...lintBlocker === null ? [] : [lintBlocker]].join(" ");
+  const blocker = [...tested, ...checked].join(" ");
   activeOutput().error(`\u274C ${blocker}`);
   const written4 = settling.repair === null ? null : writeRepairTask(context.trackerPath, blocker, { ...settling.repair, commit: readHead(seams.git) });
   if (written4 !== null)
     activeOutput().error(written4.inserted ? `   A repair task (line ${written4.line + 1}) is inserted, blocked on it.` : `   The repair task (line ${written4.line + 1}) is marked blocked on it again.`);
   return { kind, step, red: true, interrupted: false, blocker, blockedLine: written4?.line ?? null, repairInserted: written4?.inserted ?? false };
 }
-function isErrorsOnly(verdict, lint) {
-  return verdict.newErrors > 0 && verdict.fresh.length === 0 && !verdict.unreported && (lint?.blocker ?? null) === null;
+function isErrorsOnly(verdict, settling) {
+  return verdict.newErrors > 0 && verdict.fresh.length === 0 && !verdict.unreported && checkBlockers(settling).length === 0;
 }
 async function retakeOnErrors(context, seams, settling, rerun) {
   const { label, result, baseline } = settling;
-  if (isStepInterrupted(context, result) || settling.lint?.interrupted === true)
+  if (isStepInterrupted(context, result) || isCheckInterrupted(settling))
     return settling;
   const verdict = verdictOf3(result, baseline);
-  if (!isErrorsOnly(verdict, settling.lint))
+  if (!isErrorsOnly(verdict, settling))
     return settling;
   recordStep(seams, stepOf(settling, result, verdict.fresh));
   announce2(label, result, verdict.known);
@@ -29116,7 +29610,7 @@ async function ensureBaseline(context) {
     activeOutput().warn(`\u26A0\uFE0F  Could not write ${basename11(path3)} (${messageOf(error)}); the next run records the baseline again.`);
   }
   const outcome2 = settleStep(context, seams, settling);
-  const covered = completeStages(readFileSync43(context.trackerPath, "utf8"));
+  const covered = completeStages(readFileSync44(context.trackerPath, "utf8"));
   addToLedger(context.trackerPath, covered.map((stage) => ({ ...stage, commit, via: "baseline" })));
   return { baseline, step: outcome2.step, interrupted: false };
 }
@@ -29159,10 +29653,6 @@ async function runWithAlwaysRun(context, seams, kind, runs) {
   const second = await runOne(context, seams, kind, { paths: runs.alwaysRun }, junitFile);
   return foldResults(first, second, SIGINT_EXIT_CODE);
 }
-function lintTask(context, seams, input) {
-  const isInterrupted = context.isInterrupted ?? (() => false);
-  return runLintStep({ checkout: context.checkout, base: input.base, task: input.task, git: seams.git, runLint: seams.runLint, stopCode: SIGINT_EXIT_CODE, isInterrupted });
-}
 async function runTaskStep(context, input) {
   const seams = seamsOf(context);
   const scope = await taskScopeOf(context, seams, input);
@@ -29170,8 +29660,8 @@ async function runTaskStep(context, input) {
   const recorded = scope?.scope ?? "full";
   const result = await runWithAlwaysRun(context, seams, "task", runs);
   const label = `task step after "${input.task}"`;
-  const lint = isStepInterrupted(context, result) ? {} : { lint: await lintTask(context, seams, input) };
-  const settling = { kind: "task", scope: recorded, reason: taskStepReason(scope), label, result, baseline: input.baseline, repair: { kind: "task", task: input.task }, ...lint };
+  const checks = await taskDiffChecks(context, seams, input, result);
+  const settling = { kind: "task", scope: recorded, reason: taskStepReason(scope), label, result, baseline: input.baseline, repair: { kind: "task", task: input.task }, ...checks };
   const outcome2 = settleStep(context, seams, await retakeOnErrors(context, seams, settling, () => runWithAlwaysRun(context, seams, "task", runs)));
   const timedIn = runs.alwaysRun.length > 0 ? alwaysRunJunitFileFor(context.repoRoot, context.sessionId) : junitFileFor(context.repoRoot, context.sessionId, "task");
   if (!outcome2.interrupted)
@@ -29485,13 +29975,13 @@ function similarCommentOpening(score, threshold) {
 }
 function possibleDuplicatesSection(duplicates2, redact) {
   const intro = `No open bug scored at or above the similarity threshold of ${String(duplicates2.threshold)}.`;
-  const listed = duplicates2.nearest.length === 0 ? "No open bug shares a word with this one." : duplicates2.nearest.map(({ issue: issue3, score }) => `- ${issueNameOf(issue3.ref)} (score ${scoreText(score)})`).join(`
+  const listed2 = duplicates2.nearest.length === 0 ? "No open bug shares a word with this one." : duplicates2.nearest.map(({ issue: issue3, score }) => `- ${issueNameOf(issue3.ref)} (score ${scoreText(score)})`).join(`
 `);
   return `## Possible duplicates
 
 ${redact(`${intro}
 
-${listed}`)}`;
+${listed2}`)}`;
 }
 function issueNameOf(ref8) {
   return ref8.url ?? `${ref8.kind} issue ${ref8.externalId}`;
@@ -29527,8 +30017,8 @@ function issueText(opening, values, redact) {
 }
 
 // src/triage/local-paths.ts
-import { realpathSync as realpathSync5 } from "fs";
-import { resolve as resolve21 } from "path";
+import { realpathSync as realpathSync6 } from "fs";
+import { resolve as resolve23 } from "path";
 var HOME_MARKER = "[redacted: HOME]";
 var SEGMENT = "[^/\\s'\"`()<>:,;]+";
 var HOME_PATTERN = `(?:/${SEGMENT})*?/(?:Users|home)/${SEGMENT}`;
@@ -29539,9 +30029,9 @@ function literalPattern(text) {
   return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function forms(path3) {
-  const given = resolve21(path3);
+  const given = resolve23(path3);
   try {
-    const real = realpathSync5(given);
+    const real = realpathSync6(given);
     return real === given ? [given] : [given, real];
   } catch {
     return [given];
@@ -29572,11 +30062,11 @@ function localPathRedactor(repoRoot, home) {
 
 // src/triage/triage.ts
 import { homedir as homedir8 } from "os";
-import { join as join37 } from "path";
+import { join as join38 } from "path";
 
 // src/effort/store/tracker-refs.ts
 import { randomUUID as randomUUID9 } from "crypto";
-import { existsSync as existsSync36 } from "fs";
+import { existsSync as existsSync37 } from "fs";
 var SELECT_HELD2 = `
   SELECT seq, tracker_ref FROM findings
   WHERE session_id = ? AND artifact = ?
@@ -29725,7 +30215,7 @@ function writeTrackerRef(repoRoot, write, seams = {}) {
     wanted.json,
     collectedAt
   ];
-  const [action, stored] = withSqliteStore(path3, "write", !existsSync36(path3), (db) => {
+  const [action, stored] = withSqliteStore(path3, "write", !existsSync37(path3), (db) => {
     const place = db.transaction(() => placeRef(db, path3, write, wanted, superseded, insertValues));
     return place.immediate();
   });
@@ -29734,7 +30224,7 @@ function writeTrackerRef(repoRoot, write, seams = {}) {
 function readTrackerRef(repoRoot, artifact) {
   checkArtifact("read", artifact);
   const path3 = sqliteStorePath(repoRoot);
-  if (!existsSync36(path3))
+  if (!existsSync37(path3))
     return null;
   const newest = withSqliteStore(path3, "read", false, (db) => db.query(SELECT_NEWEST).get(artifact));
   return newest === null ? null : heldRefOf(path3, newest.seq, newest.tracker_ref).ref;
@@ -29804,7 +30294,7 @@ function createArtifactRefsVerifier(repoRoot, env) {
 // src/triage/similarity.ts
 import { basename as basename14 } from "path";
 var NON_WORD2 = /\W+/;
-var FENCE_LINE6 = /^`{3,}$/;
+var FENCE_LINE7 = /^`{3,}$/;
 var HEADING_LINE3 = /^## (.+)$/;
 function wordSetOf(text) {
   const words = strippedText(text).toLowerCase().split(NON_WORD2).filter((word) => word.length > 0);
@@ -29824,7 +30314,7 @@ function fencedValueAt(lines, start) {
   if (open === -1)
     return null;
   const fence = lines[start + open];
-  if (!FENCE_LINE6.test(fence))
+  if (!FENCE_LINE7.test(fence))
     return null;
   const body = lines.slice(start + open + 1);
   const close = body.indexOf(fence);
@@ -29863,12 +30353,12 @@ function nearestOpenBugs(report2, openBugs) {
 }
 
 // src/triage/triage.ts
-var PRIVATE_TRIAGE_DIR = join37(".rafa", "triage", "private");
+var PRIVATE_TRIAGE_DIR = join38(".rafa", "triage", "private");
 var SECRET_ENV_NAMES = ["GITHUB_TOKEN", "ANTHROPIC_API_KEY", "LINEAR_API_KEY"];
 var TRIAGE_MODULE = "unassigned";
 var BLOCKER_SEPARATOR2 = "; ";
 function privateTriageDir(repoRoot) {
-  return join37(repoRoot, PRIVATE_TRIAGE_DIR);
+  return join38(repoRoot, PRIVATE_TRIAGE_DIR);
 }
 function createPrivateTriageTracker(repoRoot, options = {}) {
   return createLocalTracker({
@@ -30047,10 +30537,10 @@ async function answerMiss(run) {
   const list = tracker.openIssues;
   if (similarity === null || list === undefined)
     return fileNew(run);
-  const listed = await step(run, `the ${run.route.channel} tracker openIssues`, () => list.call(tracker, "bug"));
-  if (!listed.ok)
-    return resultOf(run, "failed", { problem: listed.problem });
-  const nearest = nearestOpenBugs(run.filing.compared, listed.value);
+  const listed2 = await step(run, `the ${run.route.channel} tracker openIssues`, () => list.call(tracker, "bug"));
+  if (!listed2.ok)
+    return resultOf(run, "failed", { problem: listed2.problem });
+  const nearest = nearestOpenBugs(run.filing.compared, listed2.value);
   const [first] = nearest;
   return first !== undefined && first.score >= similarity.threshold ? commentOnNearest(run, first, similarity.threshold) : fileNew(run, { duplicates: { threshold: similarity.threshold, nearest: nearest.slice(0, similarity.candidates) } });
 }
@@ -30230,9 +30720,9 @@ function describeStartTriage(result, inherited = new Map) {
   };
 }
 async function resolvePublicTracker(options, redact) {
-  const resolve22 = options.resolve ?? resolveTracker;
+  const resolve24 = options.resolve ?? resolveTracker;
   try {
-    const { tracker, attempts } = await resolve22({
+    const { tracker, attempts } = await resolve24({
       config: options.config,
       context: { repoRoot: options.repoRoot }
     });
@@ -30419,8 +30909,128 @@ function aheadOf(track) {
   return Number(count);
 }
 
+// src/cleanup/groups.ts
+import { basename as basename15 } from "path";
+
+// src/cleanup/past-head.ts
+import { posix as posix4 } from "path";
+var PATH_TERMINATOR = "\x00";
+var FIELD_SEPARATOR = "\t";
+function unread3(command, result) {
+  const said = gitSaid(result);
+  return {
+    kind: "unread",
+    detail: said === "" ? `git ${command} failed` : `git ${command} failed: ${said}`
+  };
+}
+function terminated(output) {
+  return output.split(PATH_TERMINATOR).filter((entry) => entry !== "");
+}
+function isAncestor(git, head, tip) {
+  if (!git(["rev-parse", "--verify", "--quiet", `${head}^{commit}`]).ok) {
+    return false;
+  }
+  const result = git(["merge-base", "--is-ancestor", head, tip]);
+  if (result.ok) {
+    return true;
+  }
+  return result.stderr.trim() === "" ? false : unread3("merge-base --is-ancestor", result);
+}
+function receiptIds(git, baseRef, changelog) {
+  const path3 = posix4.normalize(changelog.replace(/\\/g, "/"));
+  const listed2 = git(["ls-tree", "-z", "--name-only", baseRef, "--", path3]);
+  if (!listed2.ok) {
+    return unread3("ls-tree", listed2);
+  }
+  if (!terminated(listed2.stdout).includes(path3)) {
+    return new Set;
+  }
+  const shown2 = git(["cat-file", "blob", `${baseRef}:${path3}`]);
+  if (!shown2.ok) {
+    return unread3("cat-file", shown2);
+  }
+  return new Set(changelogSections(shown2.stdout).flatMap((section2) => section2.receipt ?? []));
+}
+function readBaseHolding(git, baseRef, settings) {
+  const prefix = directoryPrefix(settings.fragments);
+  const listed2 = git(["ls-tree", "-r", "-z", "--name-only", baseRef, "--", prefix === "" ? "." : prefix]);
+  if (!listed2.ok) {
+    return unread3("ls-tree", listed2);
+  }
+  const ids = receiptIds(git, baseRef, settings.changelog);
+  if ("kind" in ids) {
+    return ids;
+  }
+  return { paths: new Set(terminated(listed2.stdout)), receiptIds: ids };
+}
+function isHeldFragment(path3, prefix, holding) {
+  if (!path3.startsWith(prefix)) {
+    return false;
+  }
+  const name2 = path3.slice(prefix.length);
+  const id2 = name2.includes("/") ? null : fragmentIdOf(name2);
+  if (id2 === null) {
+    return false;
+  }
+  return holding.paths.has(path3) || holding.receiptIds.has(id2);
+}
+function commitsIn(git, range) {
+  const logged = git(["log", "--reverse", `--format=%H${FIELD_SEPARATOR}%s`, range, "--"]);
+  if (!logged.ok) {
+    return unread3("log", logged);
+  }
+  return logged.stdout.split(`
+`).filter((line) => line !== "").map((line) => {
+    const at = line.indexOf(FIELD_SEPARATOR);
+    return at === -1 ? { hash: line, subject: "" } : { hash: line.slice(0, at), subject: line.slice(at + 1) };
+  });
+}
+function readPastHead(git, branch, pullRequest, settings) {
+  const tip = `refs/heads/${branch}`;
+  const descends = isAncestor(git, pullRequest.headRefOid, tip);
+  if (descends === false) {
+    return { kind: "not-descended" };
+  }
+  if (descends !== true) {
+    return descends;
+  }
+  const listed2 = commitsIn(git, `${pullRequest.headRefOid}..${tip}`);
+  if ("kind" in listed2) {
+    return listed2;
+  }
+  if (listed2.length === 0) {
+    return { kind: "past-head", pullRequest, count: 0, commits: [], held: true };
+  }
+  const holding = readBaseHolding(git, `refs/heads/${settings.base}`, settings);
+  if ("kind" in holding) {
+    return holding;
+  }
+  const prefix = directoryPrefix(settings.fragments);
+  const commits = [];
+  for (const { hash, subject } of listed2) {
+    const touched = git(["diff-tree", "-r", "-m", "--no-commit-id", "--name-only", "-z", hash]);
+    if (!touched.ok) {
+      return unread3("diff-tree", touched);
+    }
+    const paths = [...new Set(terminated(touched.stdout))];
+    const held = paths.every((path3) => isHeldFragment(path3, prefix, holding));
+    commits.push({ hash, subject, paths, held });
+  }
+  return {
+    kind: "past-head",
+    pullRequest,
+    count: commits.length,
+    commits,
+    held: commits.every((each) => each.held)
+  };
+}
+
 // src/cleanup/groups.ts
 var MERGED_STATE_UNKNOWN = "merged state unknown";
+var DEFAULT_RELEASE_PATHS = Object.freeze({
+  fragments: RELEASE_DEFAULTS.releaseFragments,
+  changelog: RELEASE_DEFAULTS.releaseChangelog
+});
 var MS_PER_DAY2 = 24 * 60 * 60 * 1000;
 function unreachableNote(detail) {
   return `pull request provider unreachable (${detail}); merged pull requests not read, grouped from git alone`;
@@ -30428,6 +31038,13 @@ function unreachableNote(detail) {
 function baseUnreadNote(base, detail) {
   return `could not read which branches are merged into ${base} (${detail}); none is listed as merged into it`;
 }
+function pastHeadUnreadNote(branch, pullRequest, detail) {
+  return `could not read the commits ${branch} holds past #${String(pullRequest)}'s head (${detail}); its delete is not forced`;
+}
+function pastHeadReason(reading2) {
+  const subjects = reading2.commits.map((commit) => commit.subject).join(", ");
+  return `${plural4(reading2.count, "commit")} past #${String(reading2.pullRequest.number)}'s head: ${subjects}`;
+}
 async function readProviderMerges(pulls) {
   if (pulls === null) {
     return { state: "none" };
@@ -30435,8 +31052,25 @@ async function readProviderMerges(pulls) {
   try {
     return { state: "read", pullRequests: await pulls.listMerged() };
   } catch (error) {
-    return { state: "unreachable", detail: firstLine7(messageOf(error)) };
+    return { state: "unreachable", detail: firstLine8(messageOf(error)) };
+  }
+}
+function heldReason(holder) {
+  return `checked out in ${holder.name} (${holder.blockers.join(", ")})`;
+}
+function holdBranchRows(rows, worktrees) {
+  const holders = new Map;
+  for (const row of worktrees) {
+    if (row.tickable || row.branch === null) {
+      continue;
+    }
+    const blockers = [...new Set(row.blockers.map((blocker) => blocker.kind))];
+    holders.set(row.branch, { path: row.path, name: basename15(row.path), blockers });
   }
+  return rows.map((row) => {
+    const holder = holders.get(row.branch.name);
+    return holder === undefined ? row : { ...row, ticked: false, heldBy: holder, reason: `${row.reason}; ${heldReason(holder)}` };
+  });
 }
 function classifyBranches(git, read, provider, settings) {
   const notes = provider.state === "unreachable" ? [unreachableNote(provider.detail)] : [];
@@ -30458,12 +31092,20 @@ function classifyBranches(git, read, provider, settings) {
     unknown: provider.state === "none",
     exclude: mergedRead.ok ? [baseRef] : []
   };
+  const unreached = {
+    git,
+    base: read.base,
+    baseRead: mergedRead.ok,
+    release: settings.release ?? DEFAULT_RELEASE_PATHS,
+    notes
+  };
   for (const branch of read.branches) {
     const pulls = named3.get(branch.name) ?? [];
     const atTip = pulls.find((pull) => pull.headRefOid === tips.get(branch.name)) ?? null;
     const mergedBy = mergedReadings(branch, reachable.has(branch.name), atTip);
     if (mergedBy.length > 0) {
-      merged.push(mergedRow(branch, mergedBy, atTip, read.base));
+      const row = mergedRow(branch, mergedBy, atTip, read.base);
+      merged.push(mergedBy.includes("base") || atTip !== null ? row : unreachedRow(unreached, row, pulls));
       continue;
     }
     const suffix = rowSuffix(context, pulls[0] ?? null);
@@ -30481,13 +31123,36 @@ function classifyBranches(git, read, provider, settings) {
       stale.push({ group: "stale", branch, ticked: false, idleDays, reason: `no commit in ${plural4(idleDays, "day")}${suffix}` });
     }
   }
-  return { ok: true, base: read.base, merged, stale, notPushed, notes };
+  const worktrees = settings.worktrees ?? [];
+  return {
+    ok: true,
+    base: read.base,
+    merged: holdBranchRows(merged, worktrees),
+    stale: holdBranchRows(stale, worktrees),
+    notPushed: holdBranchRows(notPushed, worktrees),
+    notes
+  };
+}
+function unreachedRow(context, row, pulls) {
+  const settings = { base: context.base, ...context.release };
+  for (const pull of pulls) {
+    const reading2 = readPastHead(context.git, row.branch.name, pull, settings);
+    if (reading2.kind === "past-head") {
+      return { ...row, ticked: false, pastHead: reading2, reason: `${row.reason}; ${pastHeadReason(reading2)}` };
+    }
+    if (reading2.kind === "unread") {
+      context.notes.push(pastHeadUnreadNote(row.branch.name, pull.number, firstLine8(reading2.detail)));
+      break;
+    }
+  }
+  const why = context.baseRead ? `${context.base} does not reach its tip` : `whether ${context.base} reaches its tip could not be read`;
+  return { ...row, ticked: false, reason: `${row.reason}; ${why}` };
 }
 function namedPullRequests(pullRequests, branches) {
-  const listed = new Set(branches.map((branch) => branch.name));
+  const listed2 = new Set(branches.map((branch) => branch.name));
   const named3 = new Map;
   for (const pull of pullRequests) {
-    if (listed.has(pull.headRefName)) {
+    if (listed2.has(pull.headRefName)) {
       named3.set(pull.headRefName, [...named3.get(pull.headRefName) ?? [], pull]);
     }
   }
@@ -30556,7 +31221,7 @@ function countLost(git, name2, exclude) {
   return count;
 }
 function failure3(what, result) {
-  const said = firstLine7(gitSaid(result));
+  const said = firstLine8(gitSaid(result));
   return said === "" ? `${what} failed` : `${what} failed: ${said}`;
 }
 function plural4(count, noun) {
@@ -30566,26 +31231,87 @@ function lines(text) {
   return text.split(`
 `).filter((line) => line !== "");
 }
-function firstLine7(text) {
+function firstLine8(text) {
   return text.split(`
 `).map((line) => line.trim()).find((line) => line !== "") ?? "";
 }
 
+// src/cleanup/runs.ts
+import { existsSync as existsSync38, readdirSync as readdirSync15, readFileSync as readFileSync45 } from "fs";
+import { join as join39 } from "path";
+var LIVE_STATES = new Set(["running", "paused"]);
+function readRunRecords(root, seams = {}) {
+  const dir = runsDir(root);
+  const isAlive = seams.isAlive ?? isPidAlive;
+  let names2;
+  try {
+    names2 = readdirSync15(dir);
+  } catch (error) {
+    if (errorCode(error) === "ENOENT")
+      return { runs: [], notes: [] };
+    return { runs: [], notes: [`run records: cannot list ${dir}: ${messageOf(error)}`] };
+  }
+  const notes = [];
+  const finished = [];
+  for (const name2 of names2.filter((entry) => entry.endsWith(RECORD_EXTENSION)).sort()) {
+    const file = join39(dir, name2);
+    const read = readRecord(file);
+    if (typeof read === "string") {
+      notes.push(read);
+      continue;
+    }
+    if (!LIVE_STATES.has(readState(read, isAlive)))
+      finished.push({ file, record: read });
+  }
+  const sorted = [...finished].sort((a, b) => byStart(a.record, b.record));
+  const newest = new Map;
+  for (const entry of sorted)
+    newest.set(planKey(entry.record), entry);
+  const kept = new Set(newest.values());
+  const runs = sorted.filter((entry) => !kept.has(entry)).map((entry) => runRow(dir, entry));
+  return { runs, notes };
+}
+function readRecord(file) {
+  try {
+    return parseSessionRecord(readFileSync45(file, "utf8"), file);
+  } catch (error) {
+    return `run records: skipped ${file}: ${messageOf(error)}`;
+  }
+}
+function planKey(record) {
+  return record.planStub === null ? `plan:${record.plan}` : `stub:${record.planStub}`;
+}
+function byStart(a, b) {
+  return Date.parse(a.startedAt) - Date.parse(b.startedAt) || a.sessionId.localeCompare(b.sessionId);
+}
+function runRow(dir, entry) {
+  const { record } = entry;
+  const events = join39(dir, `${record.sessionId}${EVENTS_EXTENSION}`);
+  return {
+    sessionId: record.sessionId,
+    path: entry.file,
+    eventsPath: existsSync38(events) ? events : null,
+    plan: record.planStub ?? record.plan,
+    startedAt: record.startedAt,
+    ticked: true
+  };
+}
+
 // src/cleanup/worktrees.ts
-import { realpathSync as realpathSync7, statSync as statSync15 } from "fs";
-import { join as join39, sep as sep3 } from "path";
+import { realpathSync as realpathSync8, statSync as statSync15 } from "fs";
+import { join as join41, sep as sep4 } from "path";
 
 // src/pr/worktree.ts
-import { existsSync as existsSync37, realpathSync as realpathSync6 } from "fs";
-import { join as join38 } from "path";
-var WORKTREES_SUBDIR = join38(".rafa", "worktrees");
+import { existsSync as existsSync39, realpathSync as realpathSync7 } from "fs";
+import { join as join40 } from "path";
+var WORKTREES_SUBDIR = join40(".rafa", "worktrees");
 var WORKTREE_PREFIX = "pr-";
 var DEFAULT_REMOTE3 = "origin";
 var REFUSAL_PREFIX2 = "rafa pr triage --resolve refuses";
 var FORCING_FLAG = /^(?:-f|--force(?:-with-lease|-if-includes)?(?:=.*)?|--mirror)$/;
 var FORCING_REFSPEC_MARK = "+";
 function resolveWorktreePath(home, number) {
-  return join38(home, WORKTREES_SUBDIR, `${WORKTREE_PREFIX}${number}`);
+  return join40(home, WORKTREES_SUBDIR, `${WORKTREE_PREFIX}${number}`);
 }
 function crossRepositoryRefusal(pr) {
   if (!pr.isCrossRepository)
@@ -30652,20 +31378,20 @@ function pushResolved(git, branch, remote = DEFAULT_REMOTE3) {
   return { id: step2.id, ok: false, command: worktreeCommandLine(step2), said: refusal4 };
 }
 function pathForms(path3) {
-  if (!existsSync37(path3))
+  if (!existsSync39(path3))
     return [path3];
-  return [path3, realpathSync6(path3)];
+  return [path3, realpathSync7(path3)];
 }
 function worktreeAt(git, path3) {
-  const listed = git(["worktree", "list", "--porcelain"]);
-  if (!listed.ok)
+  const listed2 = git(["worktree", "list", "--porcelain"]);
+  if (!listed2.ok)
     return null;
   const forms2 = pathForms(path3);
-  return parseWorktrees(listed.stdout).find((entry) => forms2.includes(entry.path)) ?? null;
+  return parseWorktrees(listed2.stdout).find((entry) => forms2.includes(entry.path)) ?? null;
 }
 
 // src/cleanup/worktrees.ts
-var CLAUDE_WORKTREES_SUBDIR = join39(".claude", "worktrees");
+var CLAUDE_WORKTREES_SUBDIR = join41(".claude", "worktrees");
 var WORKTREE_LIST = Object.freeze(["worktree", "list", "--porcelain"]);
 var GIT_DIR = Object.freeze(["rev-parse", "--absolute-git-dir"]);
 var WORKTREE_STATUS = Object.freeze([
@@ -30674,11 +31400,11 @@ var WORKTREE_STATUS = Object.freeze([
   "--porcelain=v1",
   "--untracked-files=all"
 ]);
-var ADMIN_FILES = Object.freeze(["HEAD", join39("logs", "HEAD"), "index"]);
+var ADMIN_FILES = Object.freeze(["HEAD", join41("logs", "HEAD"), "index"]);
 var MS_PER_DAY3 = 24 * 60 * 60 * 1000;
 var UNTRACKED_MARK = "?? ";
 var LOCKED_LINE = "locked";
-var LIVE_STATES = new Set(["running", "paused"]);
+var LIVE_STATES2 = new Set(["running", "paused"]);
 function defaultWorktreeSeams(cwd) {
   return {
     git: createGitRunner(cwd),
@@ -30693,7 +31419,7 @@ function defaultWorktreeSeams(cwd) {
     },
     realPath: (path3) => {
       try {
-        return realpathSync7(path3);
+        return realpathSync8(path3);
       } catch {
         return path3;
       }
@@ -30701,21 +31427,21 @@ function defaultWorktreeSeams(cwd) {
   };
 }
 function readWorktrees(seams, read) {
-  const listed = seams.git(WORKTREE_LIST);
-  if (!listed.ok) {
-    return { ok: false, detail: failure4("git worktree list", listed) };
+  const listed2 = seams.git(WORKTREE_LIST);
+  if (!listed2.ok) {
+    return { ok: false, detail: failure4("git worktree list", listed2) };
   }
-  const entries = parseWorktrees(listed.stdout);
+  const entries = parseWorktrees(listed2.stdout);
   const main = entries[0]?.path;
   if (main === undefined) {
     return { ok: true, worktrees: [] };
   }
   const roots = [
-    ...pathForms2(seams, join39(main, CLAUDE_WORKTREES_SUBDIR)),
-    ...pathForms2(seams, join39(read.home, WORKTREES_SUBDIR)),
+    ...pathForms2(seams, join41(main, CLAUDE_WORKTREES_SUBDIR)),
+    ...pathForms2(seams, join41(read.home, WORKTREES_SUBDIR)),
     ...pathForms2(seams, worktreeDirAt(read.projectRoot, read.worktreeDir))
   ];
-  const locks = parseLocks(listed.stdout);
+  const locks = parseLocks(listed2.stdout);
   const context = {
     seams,
     read,
@@ -30783,7 +31509,7 @@ function lastModified(seams, git, path3) {
   if (!gitDir.ok || adminDir === "") {
     return failure4("git rev-parse --absolute-git-dir", gitDir);
   }
-  const times = [path3, ...ADMIN_FILES.map((file) => join39(adminDir, file))].map((file) => seams.modifiedAt(file)).filter((time) => time !== null).map((time) => time.getTime());
+  const times = [path3, ...ADMIN_FILES.map((file) => join41(adminDir, file))].map((file) => seams.modifiedAt(file)).filter((time) => time !== null).map((time) => time.getTime());
   if (times.length === 0) {
     return `no modification time could be read under ${path3} or ${adminDir}`;
   }
@@ -30835,7 +31561,7 @@ function recentBlockers(modified, read) {
 }
 function readLive(seams, root) {
   try {
-    return seams.sessions(root).filter((record) => LIVE_STATES.has(record.state));
+    return seams.sessions(root).filter((record) => LIVE_STATES2.has(record.state));
   } catch (error) {
     return `the session records under ${runsDir(root)} could not be read: ${messageOf(error)}`;
   }
@@ -30858,7 +31584,7 @@ function pathForms2(seams, path3) {
   return resolved === path3 ? [path3] : [path3, resolved];
 }
 function isInside3(path3, dir) {
-  const prefix = dir.endsWith(sep3) ? dir : `${dir}${sep3}`;
+  const prefix = dir.endsWith(sep4) ? dir : `${dir}${sep4}`;
   return path3.startsWith(prefix);
 }
 function failure4(what, result) {
@@ -30870,7 +31596,14 @@ function plural5(count, noun) {
   return count === 1 ? `1 ${noun}` : `${String(count)} ${noun}s`;
 }
 // src/cleanup/steps.ts
+import { rmSync as rmSync6 } from "fs";
+var SHORT_HASH_LENGTH2 = 7;
 var FORCING_FLAG2 = /^(?:--force(?:=.*)?|-[^-]*f[^-]*)$/;
+var DEFAULT_CLEANUP_FILES = Object.freeze({
+  remove: (path3) => {
+    rmSync6(path3);
+  }
+});
 function frozenStep2(step2) {
   return Object.freeze({ ...step2, argv: Object.freeze([...step2.argv]) });
 }
@@ -30891,30 +31624,72 @@ function deleteBranchStep(branch, forced, after = null) {
     after
   });
 }
+function removeRunStep(row) {
+  const events = row.eventsPath === null ? [] : [row.eventsPath];
+  return frozenStep2({
+    kind: "remove-run",
+    subject: row.path,
+    argv: ["rm", row.path, ...events],
+    after: null
+  });
+}
 function needsForcedDelete(row) {
-  return !row.mergedBy.includes("base") && row.mergedBy.includes("pull-request") && row.pullRequest !== null;
+  if (row.mergedBy.includes("base")) {
+    return false;
+  }
+  if (row.mergedBy.includes("pull-request") && row.pullRequest !== null) {
+    return true;
+  }
+  return row.pastHead?.held === true;
+}
+function unheldPastHeadReason(reading2) {
+  const unheld = reading2.commits.filter((commit) => !commit.held);
+  const named3 = unheld.map((commit) => `${commit.hash.slice(0, SHORT_HASH_LENGTH2)} ${commit.subject}`).join(", ");
+  const head = `#${String(reading2.pullRequest.number)}'s head`;
+  const counted5 = unheld.length === 1 ? `1 commit past ${head} is not a release fragment` : `${String(unheld.length)} commits past ${head} are not release fragments`;
+  return `${counted5} the base holds: ${named3}; deleting it would lose them`;
 }
 function branchPicks(selection) {
   return [
-    ...selection.merged.map((row) => ({ name: row.branch.name, merged: true, forced: needsForcedDelete(row) })),
-    ...selection.stale.map((row) => ({ name: row.branch.name, merged: false, forced: true })),
-    ...selection.notPushed.map((row) => ({ name: row.branch.name, merged: false, forced: true }))
+    ...selection.merged.map((row) => ({
+      name: row.branch.name,
+      merged: true,
+      forced: needsForcedDelete(row),
+      holder: row.heldBy ?? null,
+      unheld: row.pastHead === undefined || row.pastHead.held ? null : row.pastHead
+    })),
+    ...[...selection.stale, ...selection.notPushed].map((row) => ({
+      name: row.branch.name,
+      merged: false,
+      forced: true,
+      holder: row.heldBy ?? null,
+      unheld: null
+    }))
   ];
 }
-function heldReason(path3) {
+function heldReason2(path3) {
   return `held by the worktree at ${path3}; only a Merged branch is deleted with its worktree`;
 }
 function blockedHolderReason(path3) {
   return `held by the worktree at ${path3}, which is not removed`;
 }
+function untickableHolderReason(holder) {
+  return `${heldReason(holder)}, which is not removed`;
+}
 function branchStep(pick, removed, blocked3) {
+  if (pick.holder !== null) {
+    return { kind: "delete-branch", subject: pick.name, reason: untickableHolderReason(pick.holder) };
+  }
+  if (pick.unheld !== null) {
+    return { kind: "delete-branch", subject: pick.name, reason: unheldPastHeadReason(pick.unheld) };
+  }
   const blockedPath = blocked3.get(pick.name);
   if (blockedPath !== undefined) {
     return { kind: "delete-branch", subject: pick.name, reason: blockedHolderReason(blockedPath) };
   }
   const path3 = removed.get(pick.name) ?? null;
   if (path3 !== null && !pick.merged) {
-    return { kind: "delete-branch", subject: pick.name, reason: heldReason(path3) };
+    return { kind: "delete-branch", subject: pick.name, reason: heldReason2(path3) };
   }
   return deleteBranchStep(pick.name, pick.forced, path3);
 }
@@ -30931,7 +31706,8 @@ function cleanupSteps(selection) {
   return Object.freeze({
     steps: Object.freeze([
       ...removable.map((row) => removeWorktreeStep2(row.path)),
-      ...branchEntries.filter(isStep)
+      ...branchEntries.filter(isStep),
+      ...(selection.runs ?? []).filter((row) => row.ticked).map((row) => removeRunStep(row))
     ]),
     withheld: Object.freeze([
       ...untickable.map((row) => ({ kind: "remove-worktree", subject: row.path, reason: row.reason })),
@@ -30961,19 +31737,32 @@ function afterFailedReason(path3) {
 function notRun(step2, said) {
   return { step: step2, ran: false, ok: false, command: cleanupCommandLine(step2), said };
 }
-function runStep2(git, step2, removed) {
+function removeRun(files, step2) {
+  const command = cleanupCommandLine(step2);
+  for (const path3 of step2.argv.slice(1)) {
+    try {
+      files.remove(path3);
+    } catch (error) {
+      return { step: step2, ran: true, ok: false, command, said: `cannot remove ${path3}: ${messageOf(error)}` };
+    }
+  }
+  return { step: step2, ran: true, ok: true, command, said: "" };
+}
+function runStep2(git, files, step2, removed) {
   const refusal4 = forcedFlagRefusal(step2.argv);
   if (refusal4 !== null)
     return notRun(step2, refusal4);
   if (step2.after !== null && !removed.has(step2.after))
     return notRun(step2, afterFailedReason(step2.after));
+  if (step2.kind === "remove-run")
+    return removeRun(files, step2);
   const result = git(step2.argv.slice(1));
   return { step: step2, ran: true, ok: result.ok, command: cleanupCommandLine(step2), said: gitSaid(result) };
 }
-function runCleanupSteps(git, plan) {
+function runCleanupSteps(git, plan, files = DEFAULT_CLEANUP_FILES) {
   const removed = new Set;
   return plan.steps.map((step2) => {
-    const outcome2 = runStep2(git, step2, removed);
+    const outcome2 = runStep2(git, files, step2, removed);
     if (outcome2.ok && step2.kind === "remove-worktree")
       removed.add(step2.subject);
     return outcome2;
@@ -30995,7 +31784,7 @@ async function readCleanup(seams, settings) {
     const result = seams.git(FETCH_PRUNE);
     fetched = result.ok;
     if (!result.ok) {
-      notes.push(fetchFailedNote(firstLine8(gitSaid(result)) || "git said nothing"));
+      notes.push(fetchFailedNote(firstLine9(gitSaid(result)) || "git said nothing"));
     }
   }
   const branches = readBranches(seams.git, { base: settings.base, keep: settings.keep });
@@ -31005,7 +31794,8 @@ async function readCleanup(seams, settings) {
   const provider = await readProviderMerges(seams.pulls);
   const groups = classifyBranches(seams.git, branches, provider, {
     staleDays: settings.staleDays,
-    now: settings.now
+    now: settings.now,
+    ...settings.release === undefined ? {} : { release: settings.release }
   });
   if (!groups.ok) {
     return groups;
@@ -31022,15 +31812,17 @@ async function readCleanup(seams, settings) {
   if (!worktrees.ok) {
     return worktrees;
   }
+  const runs = readRunRecords(settings.projectRoot, seams);
   return {
     ok: true,
     base: groups.base,
     fetched,
-    merged: groups.merged,
-    stale: groups.stale,
-    notPushed: groups.notPushed,
+    merged: holdBranchRows(groups.merged, worktrees.worktrees),
+    stale: holdBranchRows(groups.stale, worktrees.worktrees),
+    notPushed: holdBranchRows(groups.notPushed, worktrees.worktrees),
     worktrees: worktrees.worktrees,
-    notes: [...notes, ...groups.notes]
+    runs: runs.runs,
+    notes: [...notes, ...groups.notes, ...runs.notes]
   };
 }
 function cleanupCounts(read) {
@@ -31041,7 +31833,7 @@ function cleanupCounts(read) {
     worktrees: read.worktrees.length
   };
 }
-function firstLine8(text) {
+function firstLine9(text) {
   return text.split(`
 `).map((line) => line.trim()).find((line) => line !== "") ?? "";
 }
@@ -31068,9 +31860,76 @@ async function retargetPullRequest(pull, base, seams) {
   return { kind: "retargeted", from, to: base };
 }
 
+// src/start/release-body.ts
+var RELEASE_BODY_SEAMS = {
+  pulls: ghPullRequestsIn,
+  readProvider: (repoRoot) => resolvePrProvider({ configured: null, dir: repoRoot })
+};
+function unwritten(number, problem) {
+  return { number, carried: false, already: false, problem };
+}
+async function carryIntoBody(pulls, branch, write) {
+  try {
+    const found = await pulls.findOpen(branch);
+    if (found === null) {
+      return unwritten(null, `no open pull request was found for ${branch} to write it to`);
+    }
+    const detail = await pulls.get(found.number);
+    if (detail === null) {
+      return unwritten(found.number, `pull request #${found.number} could not be read back`);
+    }
+    const next = bodyWithRelease(detail.body, write.sentence, write.block);
+    if (next === detail.body) {
+      return { number: found.number, carried: true, already: true, problem: null };
+    }
+    await pulls.editBody(found.number, next);
+    return { number: found.number, carried: true, already: false, problem: null };
+  } catch (error) {
+    return unwritten(null, `the pull request body could not be written: ${messageOf(error)}`);
+  }
+}
+function noProviderProblem(reading2) {
+  const origin = reading2.remote === null ? "origin is not set" : `origin is ${reading2.remote}`;
+  const because = reading2.source === "config" ? "pr.provider says so" : origin;
+  return `this repository resolves to pr.provider: ${reading2.provider}, because ${because},` + " so there is no pull request to write it to";
+}
+function linesSubject(count) {
+  return count === 1 ? { noun: "That line", verb: "is" } : { noun: "Those lines", verb: "are" };
+}
+function announceBody(write, count) {
+  const out = activeOutput();
+  const { noun, verb } = linesSubject(count);
+  if (write.problem !== null) {
+    out.error(`   ${noun} ${verb} not in the pull request body: ${write.problem}`);
+    return;
+  }
+  if (write.already) {
+    out.info(`   Pull request #${write.number} already carries ${noun.toLowerCase()}.`);
+    return;
+  }
+  out.info(`   ${noun} ${verb} now in the body of pull request #${write.number}.`);
+}
+async function writeBody(seams, target, write) {
+  const reading2 = seams.readProvider(target.repoRoot);
+  if (reading2.provider !== "gh") {
+    const problem = noProviderProblem(reading2);
+    activeOutput().info(`   No pull request body carries ${JSON.stringify(write.lines.join(" "))}: ${problem}.`);
+    return unwritten(null, problem);
+  }
+  const body = await carryIntoBody(seams.pulls(target.repoRoot), target.branch, write);
+  announceBody(body, write.lines.length);
+  return body;
+}
+async function carryReleaseIntoPullRequest(finish, target, seams = {}) {
+  const { written: written4, body } = finish;
+  if (written4 === null || body === null || body.number !== null)
+    return null;
+  return writeBody({ ...RELEASE_BODY_SEAMS, ...seams }, target, written4);
+}
+
 // src/release/prepare.ts
-import { mkdirSync as mkdirSync14, readFileSync as readFileSync44, writeFileSync as writeFileSync17 } from "fs";
-import { dirname as dirname14, join as join40, posix as posix4 } from "path";
+import { mkdirSync as mkdirSync15, readFileSync as readFileSync46, writeFileSync as writeFileSync18 } from "fs";
+import { dirname as dirname16, join as join42, posix as posix5 } from "path";
 var NO_FRAGMENT = "no release fragment";
 var WHITESPACE3 = /\s+/g;
 function levelFields(reading2) {
@@ -31128,18 +31987,18 @@ function readBase(input) {
 }
 function textOf3(path3) {
   try {
-    return readFileSync44(path3, "utf8");
+    return readFileSync46(path3, "utf8");
   } catch {
     return null;
   }
 }
 function nameOf2(path3) {
-  return posix4.basename(path3);
+  return posix5.basename(path3);
 }
 function writeFragment(path3, resolved, text) {
   try {
-    mkdirSync14(dirname14(resolved), { recursive: true });
-    writeFileSync17(resolved, text);
+    mkdirSync15(dirname16(resolved), { recursive: true });
+    writeFileSync18(resolved, text);
     return null;
   } catch (error) {
     return `${path3} could not be written: ${messageOf(error)}`;
@@ -31162,8 +32021,8 @@ function prepareRelease(input) {
   const lines2 = fragmentNotes(input, level, title);
   const fragment = { plan: input.plan, title, level, notes: lines2.notes };
   const name2 = allocateFragmentName(input.plan, read.base.waiting.map((waiting) => nameOf2(waiting.path)));
-  const path3 = posix4.join(input.settings.releaseFragments.replace(/\\/g, "/"), name2);
-  const resolved = join40(input.repoRoot, path3);
+  const path3 = posix5.join(input.settings.releaseFragments.replace(/\\/g, "/"), name2);
+  const resolved = join42(input.repoRoot, path3);
   const before = textOf3(resolved);
   const after = serializeFragment(fragment);
   const problems = lines2.problem === null ? read.problems : [...read.problems, lines2.problem];
@@ -31183,18 +32042,18 @@ function prepareRelease(input) {
 }
 
 // src/release/verify.ts
-import { readFileSync as readFileSync45, writeFileSync as writeFileSync18 } from "fs";
-import { posix as posix5 } from "path";
+import { readFileSync as readFileSync47, writeFileSync as writeFileSync19 } from "fs";
+import { posix as posix6 } from "path";
 var STATUS_PREFIX_LENGTH = 3;
 function textOf4(path3) {
   try {
-    return readFileSync45(path3, "utf8");
+    return readFileSync47(path3, "utf8");
   } catch {
     return null;
   }
 }
 function repoPath2(path3) {
-  const normal = posix5.normalize(path3.replace(/\\/g, "/"));
+  const normal = posix6.normalize(path3.replace(/\\/g, "/"));
   return normal.endsWith("/") && normal.length > 1 ? normal.slice(0, -1) : normal;
 }
 function listOf3(names2) {
@@ -31204,7 +32063,7 @@ function listOf3(names2) {
 }
 function restoreFragment(file) {
   try {
-    writeFileSync18(file.resolved, file.after);
+    writeFileSync19(file.resolved, file.after);
     return { path: file.path, restored: true, problem: null };
   } catch (error) {
     return {
@@ -31307,8 +32166,7 @@ var RELEASE_STAGE_SEAMS = {
   readNotes: readPlanChanges,
   git: createGitRunner,
   push: pushBranch,
-  pulls: ghPullRequestsIn,
-  readProvider: (repoRoot) => resolvePrProvider({ configured: null, dir: repoRoot }),
+  ...RELEASE_BODY_SEAMS,
   now: () => new Date
 };
 var PLAN_HEADING = /^# +(.+)$/;
@@ -31317,14 +32175,10 @@ function releaseTitle(input) {
   return planTitleIn(input.planContent, input.planStub);
 }
 function planTitleIn(planContent, planStub2) {
-  for (const line of planContent.split(`
-`)) {
-    const heading = PLAN_HEADING.exec(line);
-    if (heading === null)
-      continue;
-    return (heading[1] ?? "").replace(PLAN_LABEL, "").trim();
-  }
-  return planStub2 ?? "";
+  const headings = planContent.split(`
+`).filter((line) => line.trim() !== ASSUMPTIONS_HEADING).map((line) => (PLAN_HEADING.exec(line)?.[1] ?? "").trim()).filter((heading) => heading !== "");
+  const chosen = headings.find((heading) => PLAN_LABEL.test(heading)) ?? headings[0];
+  return chosen === undefined ? planStub2 ?? "" : chosen.replace(PLAN_LABEL, "").trim();
 }
 function announcePreparation(preparation) {
   const out = activeOutput();
@@ -31407,61 +32261,6 @@ function bodyWithSentence(body, sentence) {
 
 ${sentence}`;
 }
-function unwritten(number, problem) {
-  return { number, carried: false, already: false, problem };
-}
-async function carryIntoBody(pulls, branch, write) {
-  try {
-    const found = await pulls.findOpen(branch);
-    if (found === null) {
-      return unwritten(null, `no open pull request was found for ${branch} to write it to`);
-    }
-    const detail = await pulls.get(found.number);
-    if (detail === null) {
-      return unwritten(found.number, `pull request #${found.number} could not be read back`);
-    }
-    const next = bodyWithRelease(detail.body, write.sentence, write.block);
-    if (next === detail.body) {
-      return { number: found.number, carried: true, already: true, problem: null };
-    }
-    await pulls.editBody(found.number, next);
-    return { number: found.number, carried: true, already: false, problem: null };
-  } catch (error) {
-    return unwritten(null, `the pull request body could not be written: ${messageOf(error)}`);
-  }
-}
-function noProviderProblem(reading2) {
-  const origin = reading2.remote === null ? "origin is not set" : `origin is ${reading2.remote}`;
-  const because = reading2.source === "config" ? "pr.provider says so" : origin;
-  return `this repository resolves to pr.provider: ${reading2.provider}, because ${because},` + " so there is no pull request to write it to";
-}
-function linesSubject(count) {
-  return count === 1 ? { noun: "That line", verb: "is" } : { noun: "Those lines", verb: "are" };
-}
-function announceBody(write, count) {
-  const out = activeOutput();
-  const { noun, verb } = linesSubject(count);
-  if (write.problem !== null) {
-    out.error(`   ${noun} ${verb} not in the pull request body: ${write.problem}`);
-    return;
-  }
-  if (write.already) {
-    out.info(`   Pull request #${write.number} already carries ${noun.toLowerCase()}.`);
-    return;
-  }
-  out.info(`   ${noun} ${verb} now in the body of pull request #${write.number}.`);
-}
-async function writeBody(io, input, write) {
-  const reading2 = io.readProvider(input.repoRoot);
-  if (reading2.provider !== "gh") {
-    const problem = noProviderProblem(reading2);
-    activeOutput().info(`   No pull request body carries ${JSON.stringify(write.lines.join(" "))}: ${problem}.`);
-    return unwritten(null, problem);
-  }
-  const body = await carryIntoBody(io.pulls(input.repoRoot), input.branch, write);
-  announceBody(body, write.lines.length);
-  return body;
-}
 async function reportFailure(io, input, outcome2, sentence, facts) {
   const out = activeOutput();
   if (outcome2 === "skipped") {
@@ -31473,8 +32272,9 @@ async function reportFailure(io, input, outcome2, sentence, facts) {
   }
   const parts = { forecast: null, levelReport: facts.levelReport };
   const block = releaseBodyBlock(parts);
-  const body = await writeBody(io, input, { sentence, block, lines: [sentence, ...releaseBodyLines(parts)] });
-  return { outcome: outcome2, sentence, forecast: null, body, ...facts };
+  const written4 = { sentence, block, lines: [sentence, ...releaseBodyLines(parts)] };
+  const body = await writeBody(io, input, written4);
+  return { outcome: outcome2, sentence, forecast: null, written: written4, body, ...facts };
 }
 var NO_RELEASE = {
   outcome: "none",
@@ -31484,6 +32284,7 @@ var NO_RELEASE = {
   sentence: null,
   forecast: null,
   levelReport: null,
+  written: null,
   body: null
 };
 async function reportForecast(io, input, forecast, facts) {
@@ -31493,8 +32294,9 @@ async function reportForecast(io, input, forecast, facts) {
     out.warn(`   \u26A0\uFE0F  ${problem}`);
   const parts = { forecast, levelReport: facts.levelReport };
   const block = releaseBodyBlock(parts);
-  const body = await writeBody(io, input, { sentence: null, block, lines: releaseBodyLines(parts) });
-  return { outcome: "released", sentence: null, forecast, body, ...facts };
+  const written4 = { sentence: null, block, lines: releaseBodyLines(parts) };
+  const body = await writeBody(io, input, written4);
+  return { outcome: "released", sentence: null, forecast, written: written4, body, ...facts };
 }
 async function finishRelease(input, seams = {}) {
   const io = { ...RELEASE_STAGE_SEAMS, ...seams };
@@ -31539,7 +32341,7 @@ async function finishRelease(input, seams = {}) {
 }
 
 // src/start/runner-pr.ts
-import { readFileSync as readFileSync46 } from "fs";
+import { readFileSync as readFileSync48 } from "fs";
 import path3 from "path";
 var RELEASE_NOTES_HEADING = "## Release notes";
 var UNFINISHED_WRAP_UP_LINE = "> \u26A0\uFE0F The wrap-up did not finish: no wrap-up session opened this pull request, so the loop opened it. Check that the base is merged in, the release notes were rewritten and the lessons were promoted before merging.";
@@ -31572,7 +32374,7 @@ function fragmentNotesIn(checkout, fragment) {
     return [];
   let text;
   try {
-    text = readFileSync46(path3.resolve(checkout, fragment), "utf8");
+    text = readFileSync48(path3.resolve(checkout, fragment), "utf8");
   } catch {
     return [];
   }
@@ -31634,7 +32436,7 @@ async function openRunnerPullRequest(input, seams) {
 }
 
 // src/start/wrap-up.ts
-import { posix as posix7 } from "path";
+import { posix as posix8 } from "path";
 
 // src/pr/conflict-sentence.ts
 var MECHANICAL_CONFLICT_SENTENCE = "Resolve MECHANICAL conflicts yourself and do not stop for them: dependency version bumps (take the base's version unless this branch deliberately pinned it, and say which in the commit), lockfiles, generated artifacts, and complementary additions where both sides appended different material to the same file (keep BOTH). Stop only for a genuine semantic conflict \u2014 two sides changing the same behaviour incompatibly. In that case commit nothing, leave the branch as it is, and report the conflicting paths and both sides' intent, so a human decides.";
@@ -31643,7 +32445,7 @@ function mechanicalConflictBullet() {
 }
 
 // src/start/promoted-check.ts
-import { isAbsolute as isAbsolute9, posix as posix6, relative as relative11 } from "path";
+import { isAbsolute as isAbsolute9, posix as posix7, relative as relative12 } from "path";
 
 // src/start/promoted.ts
 var PROMOTED_BLOCK_KIND = "promoted";
@@ -31688,7 +32490,7 @@ function parsePromoted(output) {
     return { status: "unclosed", answers: [], unreadable: [] };
   const answers = [];
   const unreadable = [];
-  const firstLine9 = new Map;
+  const firstLine10 = new Map;
   block.body.split(`
 `).forEach((text, index) => {
     if (text.trim() === "")
@@ -31700,13 +32502,13 @@ function parsePromoted(output) {
       return;
     }
     const { id: id2 } = reading2.answer;
-    const earlier = firstLine9.get(id2);
+    const earlier = firstLine10.get(id2);
     if (earlier !== undefined) {
       const reason = `\`${id2}\` was already answered at line ${String(earlier)}`;
       unreadable.push({ line, text, reason });
       return;
     }
-    firstLine9.set(id2, line);
+    firstLine10.set(id2, line);
     answers.push(reading2.answer);
   });
   return { status: "read", answers, unreadable };
@@ -31734,8 +32536,8 @@ function changedSince(git, head) {
   return { ok: true, head, paths: new Set(paths) };
 }
 function repoPath3(path4, repoRoot) {
-  const inside = isAbsolute9(path4) ? relative11(repoRoot, path4) : path4;
-  const normal = posix6.normalize(inside.replaceAll("\\", "/"));
+  const inside = isAbsolute9(path4) ? relative12(repoRoot, path4) : path4;
+  const normal = posix7.normalize(inside.replaceAll("\\", "/"));
   if (normal === "." || normal === ".." || normal.startsWith("../") || isAbsolute9(normal))
     return null;
   return normal.replace(/^(\.\/)+/, "");
@@ -31748,7 +32550,7 @@ function promotedOutcome(lesson, named3, changed, repoRoot) {
 }
 function checkPromoted(lessons, reading2, changed, repoRoot) {
   const answers = new Map(reading2.answers.map((answer4) => [answer4.id, answer4]));
-  const listed = new Set(lessons.map((lesson) => lesson.id));
+  const listed2 = new Set(lessons.map((lesson) => lesson.id));
   const promoted = [];
   const skipped2 = [];
   const unpromoted = [];
@@ -31766,7 +32568,7 @@ function checkPromoted(lessons, reading2, changed, repoRoot) {
         unpromoted.push(outcome2);
     }
   }
-  const unlisted = reading2.answers.map((answer4) => answer4.id).filter((id2) => !listed.has(id2));
+  const unlisted = reading2.answers.map((answer4) => answer4.id).filter((id2) => !listed2.has(id2));
   return { promoted, skipped: skipped2, unpromoted, unlisted };
 }
 function unpromotedPhrase(lesson, head) {
@@ -31934,7 +32736,7 @@ function releaseBullets(release) {
   ];
 }
 function fragmentDirectory(prepared) {
-  return posix7.dirname(prepared.file.path);
+  return posix8.dirname(prepared.file.path);
 }
 function fragmentRewriteBullet(prepared) {
   const { plan, level } = prepared.fragment;
@@ -31982,9 +32784,10 @@ async function lessonsToPromote(learning) {
     return [];
   }
 }
-async function preserveProgress(planContent, settingSources, release, serving, learning, base, checkout) {
+async function preserveProgress(planContent, settingSources, release, serving, learning, base, checkout, seams = {}) {
+  const lookup = seams.lookup ?? openPullRequestNumber;
   const branch = getCurrentBranch(checkout);
-  const openPullRequest = await openPullRequestNumber(checkout, branch);
+  const openPullRequest = await lookup(checkout, branch);
   return runWrapUpSession({
     buildPrompt: (lessons) => buildWrapUpPrompt(branch, base, planContent, openPullRequest, release, lessons),
     settingSources,
@@ -31992,10 +32795,15 @@ async function preserveProgress(planContent, settingSources, release, serving, l
     learning,
     checkout,
     branch,
-    succeeded: `
-\u2705 Progress preserved; PR opened or updated on this branch.`
+    succeeded: async () => progressPreservedLine(await lookup(checkout, branch)),
+    ...seams.spawn === undefined ? {} : { spawn: seams.spawn }
   });
 }
+function progressPreservedLine(openPullRequest) {
+  return openPullRequest === null ? `
+\u2705 Progress preserved; no pull request is open on this branch yet \u2014 the loop retries the wrap-up or opens one itself.` : `
+\u2705 Progress preserved; pull request #${openPullRequest} is open on this branch.`;
+}
 async function runWrapUpSession(run) {
   const { learning, checkout } = run;
   const lessons = await lessonsToPromote(learning);
@@ -32011,7 +32819,7 @@ async function runWrapUpSession(run) {
 \u274C Failed to preserve progress (exit ${session.exitCode}). Please try again.`);
     return session.stdout;
   }
-  activeOutput().info(run.succeeded);
+  activeOutput().info(typeof run.succeeded === "string" ? run.succeeded : await run.succeeded());
   if (learning === null || git === null)
     return session.stdout;
   await checkWrapUpAnswer({
@@ -32085,7 +32893,7 @@ async function runWrapUp(input) {
   session.wrapUpStarted();
   activeOutput().info(`
 \u2705 All tasks completed!`);
-  activeOutput().info("\uD83E\uDDF9 Wrap-up session starting: promote progress.txt findings, sync with main, then commit, push and open the PR.");
+  activeOutput().info("\uD83E\uDDF9 Wrap-up session starting: promote the listed lessons, sync with main, then commit, push and open the PR.");
   activeOutput().info("   This is one full Claude session with no intermediate output \u2014 expect several quiet minutes. Interrupting it skips the push and PR; if that happens, run again to retry just this stage.");
   emitLoopEvent({ kind: "wrap-up", phase: "fragment" });
   const release = prepareReleaseStage({
@@ -32103,9 +32911,8 @@ async function runWrapUp(input) {
     dir: checkout
   });
   const lookup = () => readProvider().provider === "none" ? Promise.resolve(NO_PROVIDER_REASON) : openPullRequestNumber(checkout, expected2.branch);
-  await emitPullRequestEvent("session", expected2.branch, null, lookup);
   if (haltIfWrapUpMoved({ expected: expectWrapUpCommits(expected2), before: "release" })) {
-    await emitPullRequestEvent("delivery", expected2.branch, null, lookup);
+    await emitPullRequestEvent(expected2.branch, null, lookup);
     emitLoopEvent({ kind: "halt", reason: "checkout moved" });
     return;
   }
@@ -32113,14 +32920,15 @@ async function runWrapUp(input) {
   const finish = await finishRelease({ repoRoot: checkout, branch: expected2.branch, settings, preparation: release }, { readProvider });
   if (readProvider().provider !== "none") {
     const delivery = await deliverPullRequest({ branch: expected2.branch, retries: settings.loopWrapUpRetries, previousMessage: finalMessage }, deliverySeamsIn({ ...input, base, fragment: finish.fragment }));
-    await emitPullRequestEvent("delivery", expected2.branch, delivery.kind === "delivered" ? delivery.pull.number : null, lookup);
+    await emitPullRequestEvent(expected2.branch, delivery.kind === "delivered" ? delivery.pull.number : null, lookup);
     if (delivery.kind === "interrupted")
       return;
     if (delivery.kind === "blocked")
       throw new CommandExit(1, delivery.message);
+    await carryReleaseIntoPullRequest(finish, { repoRoot: checkout, branch: expected2.branch }, { readProvider });
     await retargetPullRequest(delivery.pull, base, { pulls: ghPullRequestsIn(checkout), output: activeOutput() });
   } else {
-    await emitPullRequestEvent("delivery", expected2.branch, null, lookup);
+    await emitPullRequestEvent(expected2.branch, null, lookup);
   }
   if (ciWait) {
     emitLoopEvent({ kind: "wrap-up", phase: "ci" });
@@ -32134,11 +32942,7 @@ async function runWrapUp(input) {
   session.finished();
 }
 var NO_PROVIDER_REASON = "no pull request provider is configured";
-async function emitPullRequestEvent(place, branch, known, lookup) {
-  const textPlace = "delivery";
-  const ownPlace = activeOutputMode() === "text" ? textPlace : "session";
-  if (place !== ownPlace)
-    return;
+async function emitPullRequestEvent(branch, known, lookup) {
   const number = known ?? await lookup();
   if (typeof number === "string") {
     emitLoopEvent({ kind: "no-pr", reason: number });
@@ -32275,8 +33079,8 @@ function msUntil(startAt, now = new Date) {
   return target.getTime() - now.getTime();
 }
 function sleepFor(ms) {
-  return new Promise((resolve22) => {
-    setTimeout(resolve22, ms);
+  return new Promise((resolve24) => {
+    setTimeout(resolve24, ms);
   });
 }
 async function deferUntil(startAt, now = new Date, sleep = sleepFor) {
@@ -32287,7 +33091,7 @@ async function deferUntil(startAt, now = new Date, sleep = sleepFor) {
 
 // src/start.ts
 var __dirname2 = path4.dirname(fileURLToPath2(import.meta.url));
-var interrupted = false;
+var interrupted2 = false;
 async function start(args, repoRoot) {
   refuseDetachedRun(args);
   refuseWorktreeBesideCreateBranch(args);
@@ -32391,7 +33195,7 @@ async function start(args, repoRoot) {
       sessionId: session.id,
       settings: runConfig.config,
       planContent,
-      isInterrupted: () => interrupted
+      isInterrupted: () => interrupted2
     });
     if (!fs.existsSync(trackerPath)) {
       activeOutput().info(`\uD83D\uDCCB Creating new plan tracker at ${path4.basename(trackerPath)}...`);
@@ -32400,14 +33204,14 @@ async function start(args, repoRoot) {
       activeOutput().info(`\uD83D\uDCCB Resuming from existing ${path4.basename(trackerPath)}...`);
     }
     process.on("SIGINT", () => {
-      interrupted = true;
+      interrupted2 = true;
       interruptClaudeSessions();
     });
     while (true) {
-      if (interrupted)
+      if (interrupted2)
         break;
-      await holdWhilePaused({ repoRoot, sessionId: session.id, isInterrupted: () => interrupted });
-      if (interrupted)
+      await holdWhilePaused({ repoRoot, sessionId: session.id, isInterrupted: () => interrupted2 });
+      if (interrupted2)
         break;
       const trackerContent = fs.readFileSync(trackerPath, "utf8");
       const taskInfo = findNextTask(trackerContent);
@@ -32423,7 +33227,7 @@ async function start(args, repoRoot) {
         emitLoopEvent({ kind: "halt", reason: "suite step red" });
         return;
       }
-      if (interrupted)
+      if (interrupted2)
         break;
       if (suiteGate === "repair")
         continue;
@@ -32444,7 +33248,7 @@ async function start(args, repoRoot) {
           ciWait,
           ciTimeoutMin,
           ciAttempts,
-          isInterrupted: () => interrupted
+          isInterrupted: () => interrupted2
         });
         break;
       }
@@ -32467,16 +33271,22 @@ async function start(args, repoRoot) {
         alwaysRun: readAlwaysRunFiles(createGitRunner(checkout), runConfig.config.testsAlwaysRun),
         serving,
         handout,
-        base
+        base,
+        guard: { expected: expected2, trackerPath }
       });
       const { exitCode } = dispatch;
+      if (dispatch.halted) {
+        emitLoopEvent({ kind: "task-blocked", position, reason: "checkout moved" });
+        emitLoopEvent({ kind: "halt", reason: "checkout moved" });
+        return;
+      }
       const storeReport = async (outcome2) => {
         const stored2 = await storeTaskReport({ repoRoot, planStub: planStub2, dispatch, outcome: outcome2, learning });
         await triageTask({ trackerPath, lineNum: taskInfo.lineNum, planStub: planStub2, dispatch, outcome: outcome2 });
         await hubContact.pushThenPull();
         return stored2;
       };
-      if (interrupted) {
+      if (interrupted2) {
         updateTrackerLine(trackerPath, taskInfo.lineNum, "blocked");
         activeOutput().info(`
 \u26A0\uFE0F  Interrupted. Task marked as blocked. Run again to resume.`);
@@ -32609,11 +33419,11 @@ function claimOnRemote(attempt3, ahead, context) {
     const answer4 = keepLocally(attempt3, git, "offline", fetched.reason);
     return ahead === null ? answer4 : withAhead(answer4, notTried(ahead, `${REMOTE} could not be reached`));
   }
-  const listed = git(["for-each-ref", "--format=%(refname:lstrip=3)", `refs/remotes/${REMOTE}/${BRANCH_PREFIX2}`]);
-  if (!listed.ok) {
-    return refused2(attempt3, attempt3.branch, null, `the ${REMOTE} branches of #${String(attempt3.issue)} could not be listed: ${gitSaid(listed)}`);
+  const listed2 = git(["for-each-ref", "--format=%(refname:lstrip=3)", `refs/remotes/${REMOTE}/${BRANCH_PREFIX2}`]);
+  if (!listed2.ok) {
+    return refused2(attempt3, attempt3.branch, null, `the ${REMOTE} branches of #${String(attempt3.issue)} could not be listed: ${gitSaid(listed2)}`);
   }
-  const names2 = listed.stdout.split(`
+  const names2 = listed2.stdout.split(`
 `).map((line) => line.trim());
   const move = readMove(attempt3, names2, context);
   if (ahead === null || move.kind === "answer")
@@ -33151,11 +33961,11 @@ async function resolveCreateSpec(options, seams = DEFAULT_ROUTE_SEAMS) {
   const source = readSpecSourceFlags(options.args);
   if (source.request === null)
     throw new CommandExit(SOURCE_REFUSAL_EXIT, usageRefusal(specsDir));
-  const resolve22 = seams.resolve ?? resolvePlanSpec;
+  const resolve24 = seams.resolve ?? resolvePlanSpec;
   const makeReadyOffer = seams.makeReadyOffer ?? createPlanReadyOffer;
   const makeAlternativeOffer = seams.makeAlternativeOffer ?? createPlanBlockedOffer;
   const makeRefreshOffer = seams.makeRefreshOffer ?? createPlanRefreshOffer;
-  return await resolve22({
+  return await resolve24({
     request: source.request,
     refresh: source.refresh,
     dryRun: source.dryRun,
@@ -33184,7 +33994,7 @@ function formatProgressSection(progressContent) {
   const trimmed = progressContent?.trim();
   if (!trimmed)
     return "";
-  const capped = trimmed.length > PROGRESS_CAP_CHARS ? `\u2026(older findings truncated)\u2026
+  const capped2 = trimmed.length > PROGRESS_CAP_CHARS ? `\u2026(older findings truncated)\u2026
 ${trimmed.slice(-PROGRESS_CAP_CHARS)}` : trimmed;
   return [
     "## Findings from previous runs (progress.txt)",
@@ -33195,7 +34005,7 @@ ${trimmed.slice(-PROGRESS_CAP_CHARS)}` : trimmed;
     "not requirements, they may be stale, and they must NOT be copied into",
     "the plan.",
     "",
-    capped,
+    capped2,
     ""
   ].join(`
 `);
@@ -33421,6 +34231,7 @@ async function plan(args, repoRoot, registry = CORE_ADAPTER_REGISTRY) {
   await requireNoticesAnswered();
   activeOutput().info(`\uD83D\uDCDD Generating ${planFile} from ${path8.basename(specPath2)}...`);
   const generated = await generateOrExit(planner, { specPath: specRequest, stub }, gate, flags.skipReview);
+  enforceStoreRules(repoRoot, generated);
   await settleReview(gate, generated, flags.skipReview);
   if (resolved.spec.issue !== null) {
     recordPlanIssue(repoRoot, generated.planPath, resolved.spec.issue);
@@ -33437,4 +34248,4 @@ async function plan(args, repoRoot, registry = CORE_ADAPTER_REGISTRY) {
   }
 }
 
-export { SERVE_CLI_VERSION, PROVENANCE_FIELD, SKILL_FILE2 as SKILL_FILE, provenanceBlock, serveVerdict, SKILL_USE_CLI_VERSION, sessionLogDir, MANIFEST_VERSION, FEATURE_TYPES, OUTPUT_CHANNELS, RUNNING_MANIFEST_SEAMS, validateManifest, loadModules, moduleSettings, pullBeforeRead, collectSessionRow, collect, AGENT_DEFINITION_DIR, VENDOR_COMMAND, readAgentDirectory, resolveAgentRoster, missingPlanAgents, isStackList, stackPaths, stacksFromEccSkillName, DESCRIPTION_LIMIT, LISTING_LIMIT, SKILL_SIGNALS, countCharacters, toolOf, pathDirectories, checkReferences, checkFile, checkDirectory, bundledAgentsDirectory, sourceItem, byName, skillItem, readTrees, parseReportArgs, formatCount, alignRows, verdictOf, failingRows, formatRows, waitForChecks, recordPlanCi, formatTokens, formatTrendSegment, formatLoopsSegment, readTrendInputs, trendReportOf, buildReport, readSkillsReport, report, SPEC_EXTENSION, boardId, notesFileName, branchName, shellQuote, ghMissingMessage, ghUnauthenticatedMessage, ghHostOf, ghPreflightItems, parseWorkingTree, parseWorktrees, worktreesHolding, readMergeRefusal, resolvePrProvider, requireGhProvider, createGhPullRequests, ghPullRequestsIn, REMOTE, BRANCH_PREFIX2 as BRANCH_PREFIX, parseBaseStanding, hasDiverged, parseClaimMessage, claimBranchIssue, makeOwnershipCommit, fetchClaimBranches, readClaimBranch, pushOwnershipCommit, CLAIMED_LABEL, IN_DEVELOPMENT_LABEL, readClaimState, idleText, ROADMAP_TITLE, ROADMAP_SETTING, parseRoadmapBody, createGhRoadmapSearch, severalRoadmapsMessage, createGhOpenPullRequests, closedIssuesIn, branchClaims, scanClaimBranches, readEpicBody, SPEC_BLOCKED_LABEL, BLOCKED_BY_FIELD, hasSpecBlockedLabel, readBlockedBy, EPIC_LABEL_PREFIX, epicSlugsOf, isNotPlanned, groupByEpicLabel, localDay, readEpics, BOARD_LISTING_LIMIT, createGhBoardListing, SPEC_READY_LABEL, findReadinessGaps, requireCompleteSpec, validate_default, RefsBlockError, fingerprintText, PREVIOUS_COPY_WARN_ABOVE, previousDir, countPreviousCopies, createGhSpecIssueReader, hasSpecLabel, readRoadmapSetting, ROADMAP_LABEL, BOARD_LABELS, LABEL_LIST_LIMIT, SPEC_TEMPLATE_PATH, TEMPLATES_DIRNAME, boardChanged, listBoardLabels, missingBoardLabels, setUpLabels, anythingAt, writeShippedFile, setUpBoard, resolveDefaultBoard, unlabelledRoadmapMessage, createGhRoadmapBody, tickSentence, appendLine, tickLine, editChecklist, noBoardListsLine, epicTickSentence, tickRoadmapAfterMerge, createGhIssueBoard, PROJECT_WRITE_PAUSE_MS, matchProjectFields, PROJECT_SCOPE_FIX, BOARD_SYNC_FIX, isMissingProjectScope, scopeWarning, rateLimitWarning, notFoundWarning, isWaiting, blockerArg, createNativeRelations, selectBoardRelations, resolveTracker, DEFAULT_ISSUE_SEAMS, lineRefusal, expectTwoArguments, readTextFlag, readNonBlankFlag, readRequiredFlag, readChoice, readChoiceFlag, issueProject, issueSubjectConfig, resolveIssueTracker, issueRef, issueName, urlLines, onTracker, NATIVE_MODE, NATIVE_RETRY_HINT, nativeEpicLeft, nativeAlreadyMessage, nativeParentLine, readBoardRepository, configuredMoveRelations, FRAGMENT_PLAN_ID_PATTERN, serializeFragment, allocateFragmentName, directoryPrefix, HORIZON_LABEL_PREFIX, readEpicProblems, epicProblemMessage, readEpicDependents, REASON_FLAG, normaliseReason, renderHorizonComment, renderParkedPullRequestComment, renderMoveComment, renderCloseComment, renderCancelComment, cancelMoveReason, renderDependentComment, renderUnblockNote, readReason, unaskedReasonMessage, blankReasonMessage, readRefsText, readCopyRefs, restampCopyRefs, RefVerifyError, readConfiguredRelations, requireNoLeak, blockedLineSentence, boardRepoLabel, memoiseVerifier, LEARNED_DIRECTORY, ORIGIN_FIELD, DEMOTION_VERDICTS, WHEN_TO_USE_HEADING, bodySections, classifySkill, firstSentence, convertToInstinct, rankCandidates, readRankCandidate, NO_NEXT_STEP, readSchemaReport, gateMeaning, unknownAdditive, unknownAdditiveWarning, developmentApplied, isFirstDispatch, STAGE_LABELS, unlabelReleased, createStartPreflightClaim, invalidateRows, checkDrift, driftLines, readDoctorEffortSync, renderDoctorEffortSync, effortSyncRefusal, SESSION_ID_FLAG2 as SESSION_ID_FLAG, readBoardBody, openBoards, boardOfEpic, createOwnerResolver, runIssueList, ISSUE_LIST_FLAGS, list_default, firstNowEpic, show_default, samePlace, resolvePlace, createGhProjectPort, resolveLoopSeams, sessionIdFlag, lineRefusal2 as lineRefusal1, refusal3 as refusal, NoSessionRefusal, isLive, planLabel, sessionLine, projectRoot2 as projectRoot, readRecords, pickSession, writeSession, readSessionChecklist, phaseNote, phasedCounts, checkboxAt, estimateEta, readSessionFinishes, formatDuration, etaLine, RELEASE_REMOTE, RELEASE_BASE_BRANCH, parseSemanticVersion, readManifestVersion, replaceManifestVersion, gitPathOf, receiptProblem, readReceiptVerdict, releaseCommitSubject, readSettle, buildSettle, waitingSettingsOf, readWaiting, forecastPhrase, DEFAULT_RELEASE_SEAMS, compareVersions, changelogVersions, readTags, status_default, epicEndLines, watchDryEpic, nextOwnerGate, resolveReleaseEnabled, refuseMisplacedRuntime, readBinPath, self_update_default, versionTag, INDENT4 as INDENT, cleanUpAfterMerge, reportFollowUps, RELEASE_BLOCK_OPEN, RELEASE_BLOCK_CLOSE, localPlanNotes, readGuard, guardLines, mergeGuardSettings, readMergeGuard, guardReaction, followsMerge, readSettleAfterMerge, DEFAULT_BASE_BRANCH, ghNextBoard, openNextSources, WORKTREES_SUBDIR, resolveWorktreePath, crossRepositoryRefusal, addResolveWorktree, removeResolveWorktree, pushResolved, worktreeAt, worktreeDirAt, WORKTREE_STATUS, countChanges, cleanupSteps, dryRunLines, runCleanupSteps, defaultCleanupSeams, readCleanup, cleanupCounts, createLinePrompter, openNextRelations, list_default2 as list_default1, readBranch2 as readBranch, readPlans, readOpenPull, readBranchPlan, readNextState, readHomeAfterLoop, commandWords, nextQuestion, NEXT_COMMAND_ACTIONS, LABELS_ONLY_ACTIONS, actionInvocation, runAction, HINT_FLAG_SPEC, actionOutput, endWithNextStep, endingWith, lazyPrompter2 as lazyPrompter, ready_default, DEFAULT_PLAN_FILE, resolvePlanPath, assessPlanRisk, renderRiskText, announceRiskTotal, readBlockedIssues, renderBlockedIssues, blockerToken, addBlockerToBody, resolveCreateSpec, TRIAGE_MODULE, namedSecrets, triageReport, eventsFilePath, unresolvedTracker, DISK_ROOTS_FILE_SYSTEM, gitToplevel, rootRefusal, rootCandidates, DEFAULT_CI_TIMEOUT_MIN, CI_POLL_INTERVAL_MS, DEFAULT_CI_ATTEMPTS, MECHANICAL_CONFLICT_SENTENCE, start, createPlanRefsVerifier, readDoctorRefs, renderDoctorRefs, createPlanDirNames, hasPlanFor, HORIZONS, horizonOf, readListedEpics, stageOf, rankOf, readIssueFacts, readRefreshBoard, refreshProjectItems, refreshIssueItems, refreshFailedWarning, unblock_default, unblockAfterMerge, labelsLineBlockersOf, LABELS_READS, createLabelsRelations, EPIC_TYPE_LABEL, plan };
+export { SERVE_CLI_VERSION, PROVENANCE_FIELD, SKILL_FILE2 as SKILL_FILE, provenanceBlock, serveVerdict, SKILL_USE_CLI_VERSION, sessionLogDir, MANIFEST_VERSION, FEATURE_TYPES, OUTPUT_CHANNELS, RUNNING_MANIFEST_SEAMS, validateManifest, loadModules, moduleSettings, pullBeforeRead, collectSessionRow, collect, AGENT_DEFINITION_DIR, VENDOR_COMMAND, readAgentDirectory, resolveAgentRoster, missingPlanAgents, isStackList, stackPaths, stacksFromEccSkillName, DESCRIPTION_LIMIT, LISTING_LIMIT, SKILL_SIGNALS, countCharacters, toolOf, pathDirectories, checkReferences, checkFile, checkDirectory, bundledAgentsDirectory, sourceItem, byName, skillItem, readTrees, parseReportArgs, formatCount, alignRows, verdictOf, failingRows, formatRows, waitForChecks, recordPlanCi, formatTokens, formatTrendSegment, formatLoopsSegment, readTrendInputs, trendReportOf, buildReport, readSkillsReport, report, SPEC_EXTENSION, boardId, notesFileName, branchName, shellQuote, ghMissingMessage, ghUnauthenticatedMessage, ghHostOf, ghPreflightItems, parseWorkingTree, parseTreePaths, untrackedLeftLine, parseWorktrees, worktreesHolding, readMergeRefusal, resolvePrProvider, requireGhProvider, createGhPullRequests, ghPullRequestsIn, REMOTE, BRANCH_PREFIX2 as BRANCH_PREFIX, parseBaseStanding, hasDiverged, parseClaimMessage, claimBranchIssue, makeOwnershipCommit, fetchClaimBranches, readClaimBranch, pushOwnershipCommit, CLAIMED_LABEL, IN_DEVELOPMENT_LABEL, readClaimState, idleText, ROADMAP_TITLE, ROADMAP_SETTING, parseRoadmapBody, createGhRoadmapSearch, severalRoadmapsMessage, createGhOpenPullRequests, closedIssuesIn, branchClaims, scanClaimBranches, readEpicBody, SPEC_BLOCKED_LABEL, BLOCKED_BY_FIELD, hasSpecBlockedLabel, readBlockedBy, EPIC_LABEL_PREFIX, epicSlugsOf, isNotPlanned, groupByEpicLabel, localDay, readEpics, BOARD_LISTING_LIMIT, createGhBoardListing, SPEC_READY_LABEL, findReadinessGaps, requireCompleteSpec, validate_default, RefsBlockError, fingerprintText, PREVIOUS_COPY_WARN_ABOVE, previousDir, countPreviousCopies, createGhSpecIssueReader, hasSpecLabel, readRoadmapSetting, ROADMAP_LABEL, BOARD_LABELS, LABEL_LIST_LIMIT, SPEC_TEMPLATE_PATH, TEMPLATES_DIRNAME, boardChanged, listBoardLabels, missingBoardLabels, setUpLabels, anythingAt, writeShippedFile, setUpBoard, resolveDefaultBoard, unlabelledRoadmapMessage, createGhRoadmapBody, tickSentence, appendLine, tickLine, editChecklist, noBoardListsLine, epicTickSentence, tickRoadmapAfterMerge, createGhIssueBoard, PROJECT_WRITE_PAUSE_MS, matchProjectFields, PROJECT_SCOPE_FIX, BOARD_SYNC_FIX, isMissingProjectScope, scopeWarning, rateLimitWarning, notFoundWarning, isWaiting, blockerArg, createNativeRelations, selectBoardRelations, resolveTracker, DEFAULT_ISSUE_SEAMS, lineRefusal, expectTwoArguments, readTextFlag, readNonBlankFlag, readRequiredFlag, readChoice, readChoiceFlag, issueProject, issueSubjectConfig, resolveIssueTracker, issueRef, issueName, urlLines, onTracker, NATIVE_MODE, NATIVE_RETRY_HINT, nativeEpicLeft, nativeAlreadyMessage, nativeParentLine, readBoardRepository, configuredMoveRelations, FRAGMENT_PLAN_ID_PATTERN, serializeFragment, allocateFragmentName, directoryPrefix, HORIZON_LABEL_PREFIX, readEpicProblems, epicProblemMessage, readEpicDependents, REASON_FLAG, normaliseReason, renderHorizonComment, renderParkedPullRequestComment, renderMoveComment, renderCloseComment, renderCancelComment, cancelMoveReason, renderDependentComment, renderUnblockNote, readReason, unaskedReasonMessage, blankReasonMessage, readRefsText, readCopyRefs, restampCopyRefs, RefVerifyError, readConfiguredRelations, requireNoLeak, blockedLineSentence, boardRepoLabel, memoiseVerifier, LEARNED_DIRECTORY, ORIGIN_FIELD, DEMOTION_VERDICTS, WHEN_TO_USE_HEADING, bodySections, classifySkill, firstSentence, convertToInstinct, rankCandidates, readRankCandidate, NO_NEXT_STEP, readSchemaReport, gateMeaning, unknownAdditive, unknownAdditiveWarning, developmentApplied, isFirstDispatch, STAGE_LABELS, unlabelReleased, createStartPreflightClaim, invalidateRows, checkDrift, driftLines, readDoctorEffortSync, renderDoctorEffortSync, effortSyncRefusal, SESSION_ID_FLAG2 as SESSION_ID_FLAG, readBoardBody, openBoards, boardOfEpic, createOwnerResolver, runIssueList, ISSUE_LIST_FLAGS, list_default, firstNowEpic, show_default, samePlace, resolvePlace, createGhProjectPort, resolveLoopSeams, sessionIdFlag, lineRefusal2 as lineRefusal1, refusal3 as refusal, NoSessionRefusal, isLive, planLabel, sessionLine, projectRoot2 as projectRoot, readRecords, pickSession, writeSession, readSessionChecklist, phaseNote, phasedCounts, checkboxAt, estimateEta, readSessionFinishes, formatDuration, etaLine, RELEASE_REMOTE, RELEASE_BASE_BRANCH, parseSemanticVersion, readManifestVersion, replaceManifestVersion, gitPathOf, receiptProblem, readReceiptVerdict, CHANGELOG_TITLE, releaseCommitSubject, readSettle, buildSettle, waitingSettingsOf, readWaiting, forecastPhrase, DEFAULT_RELEASE_SEAMS, compareVersions, changelogVersions, readTags, status_default, epicEndLines, watchDryEpic, nextOwnerGate, resolveReleaseEnabled, refuseMisplacedRuntime, readBinPath, self_update_default, versionTag, INDENT4 as INDENT, cleanUpAfterMerge, reportFollowUps, RELEASE_BLOCK_OPEN, RELEASE_BLOCK_CLOSE, localPlanNotes, readGuard, guardLines, mergeGuardSettings, readMergeGuard, guardReaction, followsMerge, readSettleAfterMerge, DEFAULT_BASE_BRANCH, ghNextBoard, openNextSources, readRemoteHead, eventsFilePath, WORKTREES_SUBDIR, resolveWorktreePath, crossRepositoryRefusal, addResolveWorktree, removeResolveWorktree, pushResolved, worktreeAt, worktreeDirAt, WORKTREE_STATUS, countChanges, cleanupSteps, dryRunLines, runCleanupSteps, defaultCleanupSeams, readCleanup, cleanupCounts, createLinePrompter, openNextRelations, list_default2 as list_default1, readBranch2 as readBranch, readPlans, readOpenPull, readBranchPlan, readNextState, readHomeAfterLoop, commandWords, nextQuestion, NEXT_COMMAND_ACTIONS, LABELS_ONLY_ACTIONS, actionInvocation, runAction, HINT_FLAG_SPEC, actionOutput, endWithNextStep, endingWith, lazyPrompter2 as lazyPrompter, ready_default, DEFAULT_PLAN_FILE, resolvePlanPath, assessPlanRisk, renderRiskText, announceRiskTotal, readBlockedIssues, renderBlockedIssues, blockerToken, addBlockerToBody, resolveCreateSpec, TRIAGE_MODULE, namedSecrets, triageReport, unresolvedTracker, DISK_ROOTS_FILE_SYSTEM, gitToplevel, rootRefusal, rootCandidates, DEFAULT_CI_TIMEOUT_MIN, CI_POLL_INTERVAL_MS, DEFAULT_CI_ATTEMPTS, retargetedLine, MECHANICAL_CONFLICT_SENTENCE, start, createPlanRefsVerifier, readDoctorRefs, renderDoctorRefs, createPlanDirNames, hasPlanFor, HORIZONS, horizonOf, readListedEpics, stageOf, rankOf, readIssueFacts, readRefreshBoard, refreshProjectItems, refreshIssueItems, refreshFailedWarning, unblock_default, unblockAfterMerge, labelsLineBlockersOf, LABELS_READS, createLabelsRelations, EPIC_TYPE_LABEL, plan };