@open-tomato/rafa 0.23.0 → 0.24.1

package/dist/{index-ehsb7198.js → index-h369efkh.js}

@@ -49,7 +49,7 @@ import {
   writeFrontmatter,
   writeInstinct,
   writeSqliteStore
-} from "./index-ae290g0m.js";
+} from "./index-7qgng1rf.js";
 import {
   CHANGE_LEVELS,
   CONFIG_DEFAULTS,
@@ -81,12 +81,12 @@ import {
   DESCRIBE_BINARY,
   DESCRIBE_SCHEMA_VERSION,
   pluralOf
-} from "./index-4a45ffqh.js";
+} from "./index-w1dnwja1.js";
 import {
   CommandExit,
   SPENDS_GLYPH,
   commandSpelling
-} from "./index-28jzpyks.js";
+} from "./index-4fwgqveh.js";
 import {
   BUDGET_FLAG,
   BUNDLED_SKILLS_DIR,
@@ -5132,7 +5132,7 @@ async function report(args, repoRoot) {
 
 // package.json
 var name = "@open-tomato/rafa";
-var version = "0.23.0";
+var version = "0.24.1";
 
 // src/modules/manifest.ts
 var MANIFEST_VERSION = 1;
@@ -8063,6 +8063,202 @@ function readEpics(input) {
   });
 }
 
+// src/board/epic-dependents.ts
+function membersOf(slug, issues) {
+  const members = slug === null ? [] : groupByEpicLabel(issues).get(slug) ?? [];
+  return {
+    open: members.filter((member) => member.state === "OPEN").map((member) => member.number),
+    all: new Set(members.map((member) => member.number))
+  };
+}
+function readEpicDependents(issues, epic) {
+  const epicIssue = issues.find((issue3) => issue3.number === epic && issue3.type === "epic");
+  if (epicIssue === undefined)
+    return null;
+  const slug = epicSlugsOf(epicIssue.labels)[0] ?? null;
+  const members = membersOf(slug, issues);
+  const open = new Set(members.open);
+  const known = new Set(issues.map((issue3) => issue3.number));
+  const outsiders = issues.filter((issue3) => issue3.state === "OPEN" && issue3.number !== epic && !members.all.has(issue3.number)).sort((left, right) => left.number - right.number);
+  const dependents = [];
+  const problems = [];
+  for (const issue3 of outsiders) {
+    const reading2 = readBlockedBy(issue3.number, issue3.body, known);
+    const names = reading2.blockers.filter((id) => open.has(id));
+    if (names.length === 0)
+      continue;
+    if (reading2.kind === "blocked") {
+      dependents.push(Object.freeze({ issue: issue3, waitsOn: Object.freeze(names) }));
+      continue;
+    }
+    problems.push(Object.freeze({
+      issue: issue3.number,
+      reading: reading2,
+      names: Object.freeze(names),
+      message: blockedFaultMessage(reading2)
+    }));
+  }
+  return Object.freeze({
+    epic,
+    slug,
+    openMembers: Object.freeze([...members.open]),
+    dependents: Object.freeze(dependents),
+    problems: Object.freeze(problems)
+  });
+}
+
+// src/board/epic-trail.ts
+var REASON_FLAG = "reason";
+var WHITESPACE_RUN = /\s+/gu;
+var BACKTICK_RUN = /`+/gu;
+function ref(issue3) {
+  return `#${String(issue3)}`;
+}
+function wordList(words) {
+  if (words.length < 2)
+    return words.join("");
+  return `${words.slice(0, -1).join(", ")} and ${words[words.length - 1] ?? ""}`;
+}
+function refList(issues) {
+  return wordList(issues.map(ref));
+}
+function codeSpan(text) {
+  const longest = (text.match(BACKTICK_RUN) ?? []).reduce((most, run) => Math.max(most, run.length), 0);
+  const fence = "`".repeat(longest + 1);
+  const padding = text.startsWith("`") || text.endsWith("`") ? " " : "";
+  return `${fence}${padding}${text}${padding}${fence}`;
+}
+function normaliseReason(reason) {
+  return reason.trim().replace(WHITESPACE_RUN, " ");
+}
+function renderHorizonComment(change, reason) {
+  return `Moved ${change.from} \u2192 ${change.to}: ${normaliseReason(reason)}`;
+}
+function renderParkedPullRequestComment(change, reason) {
+  return `Closed: epic ${ref(change.epic)} was deferred ${change.from} \u2192 ${change.to}: ${normaliseReason(reason)}` + `
+
+The branch is kept; reopen this pull request to take the work up again.`;
+}
+function openWorkPhrase(work) {
+  const branches = work.branches.map((branch) => `branch ${codeSpan(branch)}`);
+  const pullRequests = work.pullRequests.map((pr) => `pull request ${ref(pr)}`);
+  return [...branches, ...pullRequests].join(", ");
+}
+function renderMoveComment(change, reason, work) {
+  const head = `Moved from epic ${ref(change.from)} to ${ref(change.to)}: ${normaliseReason(reason)}`;
+  const named = work === undefined ? "" : openWorkPhrase(work);
+  return named === "" ? head : `${head}
+
+Open work stays as it is: ${named}.`;
+}
+function criteriaCount(count) {
+  return count === 1 ? "1 acceptance criterion" : `${String(count)} acceptance criteria`;
+}
+function renderCloseComment(trail) {
+  const head = `Closed through the closing gate: every member is closed, and ${criteriaCount(trail.passed.length)}` + " passed against main.";
+  const lines = [head];
+  if (trail.passed.length > 0) {
+    lines.push("", ...trail.passed.map((criterion) => `- [x] ${normaliseReason(criterion)}`));
+  }
+  if (trail.unchecked.length > 0) {
+    lines.push("", `Closed over ${criteriaCount(trail.unchecked.length)} left unchecked, with --accept-unchecked:`, "", ...trail.unchecked.map(({ criterion, reason }) => `- [ ] ${normaliseReason(criterion)} \u2014 ${normaliseReason(reason)}`));
+  }
+  return lines.join(`
+`);
+}
+function dependentLine(outcome) {
+  const { answer } = outcome;
+  switch (answer.kind) {
+    case "moved": {
+      return `- ${ref(outcome.issue)} moved to epic ${ref(answer.to)}`;
+    }
+    case "unblocked": {
+      return `- ${ref(outcome.issue)} unblocked`;
+    }
+    case "cancelled": {
+      return `- ${ref(outcome.issue)} closed as not planned`;
+    }
+  }
+}
+function renderCancelComment(reason, dependents) {
+  const said = reason === null ? "" : normaliseReason(reason);
+  const head = said === "" ? "Cancelled." : `Cancelled: ${said}`;
+  if (dependents.length === 0)
+    return `${head}
+
+No issue in another epic waited on its open members.`;
+  return [head, "", "Issues in other epics that waited on its open members:", "", ...dependents.map(dependentLine)].join(`
+`);
+}
+function cancelMoveReason(epic) {
+  return `epic ${ref(epic)}, which it was blocked by, was cancelled`;
+}
+function renderDependentComment(action, epic, waitedOn) {
+  const why = `epic ${ref(epic)} was cancelled, so ${refList(waitedOn)}`;
+  const verb = waitedOn.length === 1 ? "blocks" : "block";
+  return action === "unblocked" ? `Unblocked: ${why} no longer ${verb} this issue.` : `Closed as not planned: ${why}, which this issue waited on, will not land.`;
+}
+function renderUnblockNote(day, epic, dropped, still) {
+  const verb = dropped.length === 1 ? "blocks" : "block";
+  const rest = still.length === 0 ? "nothing else blocks it." : `it is still blocked by ${wordList(still)}.`;
+  return `**Updated ${day}, epic ${ref(epic)} cancelled:** ${refList(dropped)} no longer ${verb} this issue; ${rest}`;
+}
+function carriesUnblockNote(body, epic) {
+  return new RegExp(String.raw`\*\*Updated \d{4}-\d{2}-\d{2}, epic #${String(epic)} cancelled:\*\*`, "u").test(body);
+}
+function reasonQuestion(change) {
+  return change.kind === "horizon" ? `Why move epic ${ref(change.epic)} from ${change.from} to ${change.to}? ` : `Why move ${ref(change.issue)} from epic ${ref(change.from)} to ${ref(change.to)}? `;
+}
+async function readReason(change, flag, ask) {
+  if (flag !== null)
+    return readingOf(flag);
+  const question = reasonQuestion(change);
+  if (ask === null)
+    return { status: "unasked", question };
+  const answer = await ask(question);
+  return answer === null ? { status: "blank" } : readingOf(answer);
+}
+function readingOf(text) {
+  const reason = normaliseReason(text);
+  return reason === "" ? { status: "blank" } : { status: "given", reason };
+}
+function unaskedReasonMessage(question) {
+  return `No terminal to ask on, so nothing changed. It would have asked: ${question.trim()}` + ` Pass --${REASON_FLAG} "<why>" to answer it.`;
+}
+function blankReasonMessage() {
+  return "No reason was given, so nothing changed: every change to an epic leaves its reason on the issue." + ` Pass --${REASON_FLAG} "<why>" or answer the question.`;
+}
+
+// src/board/epic-cancel-notice.ts
+function ref2(issue3) {
+  return `#${String(issue3)}`;
+}
+function refList2(issues) {
+  const refs = issues.map(ref2);
+  if (refs.length < 2)
+    return refs.join("");
+  return `${refs.slice(0, -1).join(", ")} and ${refs[refs.length - 1] ?? ""}`;
+}
+function readCancelledEpicNotices(issues) {
+  const cancelled = issues.filter((issue3) => issue3.type === "epic" && isNotPlanned(issue3)).map((issue3) => issue3.number).sort((left, right) => left - right);
+  const notices = [];
+  for (const epic of cancelled) {
+    const read = readEpicDependents(issues, epic);
+    const waiting = (read?.dependents ?? []).filter(({ issue: issue3 }) => !carriesUnblockNote(issue3.body, epic)).map(({ issue: issue3 }) => issue3.number);
+    if (waiting.length > 0)
+      notices.push(Object.freeze({ epic, dependents: Object.freeze(waiting) }));
+  }
+  return Object.freeze(notices);
+}
+function renderCancelledEpicNotice(notice) {
+  const { epic, dependents } = notice;
+  const [verb, whom] = dependents.length === 1 ? ["waits", "it"] : ["wait", "each"];
+  return `Epic ${ref2(epic)} was closed as not planned, and ${refList2(dependents)} still ${verb} on its open members;` + ` rafa epic cancel ${String(epic)} asks what becomes of ${whom}.`;
+}
+function cancelledEpicNoticeLines(issues) {
+  return Object.freeze(readCancelledEpicNotices(issues).map(renderCancelledEpicNotice));
+}
+
 // src/board/epic-problems.ts
 var HORIZON_LABEL_PREFIX = "horizon:";
 var EPIC_PROBLEM_KINDS = Object.freeze([
@@ -8516,16 +8712,16 @@ function firstStamp(live) {
 }
 async function liveReadings(body, verify) {
   const read = [];
-  for (const ref of extractRefs(body))
-    read.push([ref, await verify(ref)]);
+  for (const ref3 of extractRefs(body))
+    read.push([ref3, await verify(ref3)]);
   return read;
 }
-function rowOf2(ref, live, stamp, heldTo, issue3) {
-  const { state, changedHeadings: changedHeadings2 } = compareToStamp({ live, stamp, blocker: ref.blocker });
+function rowOf2(ref3, live, stamp, heldTo, issue3) {
+  const { state, changedHeadings: changedHeadings2 } = compareToStamp({ live, stamp, blocker: ref3.blocker });
   return Object.freeze({
-    kind: ref.kind,
-    text: ref.text,
-    line: ref.line,
+    kind: ref3.kind,
+    text: ref3.text,
+    line: ref3.line,
     state,
     fingerprint: live,
     stamp: heldTo,
@@ -8540,12 +8736,12 @@ function answer(rows, copy, body, stamps, write) {
 async function readRefsText(options) {
   const { stamps, body } = readRefsBlock(options.copy);
   const added = [];
-  const rows = (await liveReadings(body, options.verify)).map(([ref, live]) => {
-    const stamp = findStamp(stamps, ref);
+  const rows = (await liveReadings(body, options.verify)).map(([ref3, live]) => {
+    const stamp = findStamp(stamps, ref3);
     const fresh = stamp === null ? firstStamp(live) : null;
     if (fresh !== null)
-      added.push(Object.freeze({ kind: ref.kind, text: ref.text, fingerprint: fresh }));
-    return rowOf2(ref, live, stamp, stamp ?? fresh, options.issue);
+      added.push(Object.freeze({ kind: ref3.kind, text: ref3.text, fingerprint: fresh }));
+    return rowOf2(ref3, live, stamp, stamp ?? fresh, options.issue);
   });
   const kept = added.length === 0 ? stamps : Object.freeze([...stamps ?? [], ...added]);
   return answer(rows, options.copy, body, kept, added.length > 0);
@@ -8553,11 +8749,11 @@ async function readRefsText(options) {
 async function restampRefsText(options) {
   const { stamps: old, body } = readRefsBlock(options.copy);
   const stamps = [];
-  const rows = (await liveReadings(body, options.verify)).map(([ref, live]) => {
-    const stamp = live.kind === "unreadable" ? findStamp(old, ref) : live;
+  const rows = (await liveReadings(body, options.verify)).map(([ref3, live]) => {
+    const stamp = live.kind === "unreadable" ? findStamp(old, ref3) : live;
     if (stamp !== null)
-      stamps.push(Object.freeze({ kind: ref.kind, text: ref.text, fingerprint: stamp }));
-    return rowOf2(ref, live, stamp, stamp, options.issue);
+      stamps.push(Object.freeze({ kind: ref3.kind, text: ref3.text, fingerprint: stamp }));
+    return rowOf2(ref3, live, stamp, stamp, options.issue);
   });
   return answer(rows, options.copy, body, Object.freeze(stamps), true);
 }
@@ -8791,26 +8987,26 @@ function createRefVerifier(seams) {
     tracked ??= trackedFiles(seams.git);
     return tracked;
   };
-  return async (ref) => {
-    switch (ref.kind) {
+  return async (ref3) => {
+    switch (ref3.kind) {
       case "issue":
-        return verifyIssue(ref.text, seams.issues);
+        return verifyIssue(ref3.text, seams.issues);
       case "cross-issue":
-        return verifyCrossIssue(ref.text, seams.issues);
+        return verifyCrossIssue(ref3.text, seams.issues);
       case "path": {
-        const target = pathTarget(ref.text, listed());
+        const target = pathTarget(ref3.text, listed());
         if (target.kind === "file")
           return fileReading(target.path, seams.git);
         return presence(target.kind === "present");
       }
       case "symbol":
-        return verifySymbol(ref.text, seams.git, seams.outline);
+        return verifySymbol(ref3.text, seams.git, seams.outline);
       case "command":
-        return presence(isRosterCommand(ref.text, seams.roster));
+        return presence(isRosterCommand(ref3.text, seams.roster));
       case "flag":
-        return presence(isRosterFlag(ref.text, seams.roster));
+        return presence(isRosterFlag(ref3.text, seams.roster));
       case "key":
-        return presence(isSettingKey(ref.text));
+        return presence(isSettingKey(ref3.text));
     }
   };
 }
@@ -8819,6 +9015,7 @@ function createRefVerifier(seams) {
 var PREFIX8 = "board issue";
 var REPO_PATH2 = "{owner}/{repo}";
 var COMMENT_ID = /^[1-9]\d*$/;
+var CLOSE_REASONS = Object.freeze(["completed", "not planned"]);
 function detailOf7(result, command) {
   const written = result.stderr.trim() || result.stdout.trim();
   return written === "" ? `${command} failed and wrote nothing` : `${command} failed: ${written}`;
@@ -8844,12 +9041,39 @@ function commentBody2(value, member) {
   }
   return value;
 }
+function closeReason(value) {
+  if (!CLOSE_REASONS.includes(value)) {
+    throw new TypeError(`${PREFIX8}: closeIssue refused reason ${describeValue(value)}, expected one of ${CLOSE_REASONS.join(", ")}`);
+  }
+  return value;
+}
+function closeComment(value, member = "closeIssue") {
+  if (commentBody2(value, member).trim() === "") {
+    throw new TypeError(`${PREFIX8}: ${member} refused an empty comment, every close leaves one`);
+  }
+  return value;
+}
 function labelName(value, member, what) {
   if (typeof value !== "string" || value === "" || value.startsWith("-")) {
     throw new TypeError(`${PREFIX8}: ${member} refused ${what} ${describeValue(value)},` + " expected a non-empty name that does not open with a hyphen");
   }
   return value;
 }
+function issueTitle(value) {
+  if (typeof value !== "string" || value.trim() === "" || /[\r\n]/u.test(value)) {
+    throw new TypeError(`${PREFIX8}: createIssue refused the title ${describeValue(value)}, expected one line holding some text`);
+  }
+  return value;
+}
+function createdIssue(stdout) {
+  const url = stdout.trim().split(`
+`).at(-1)?.trim() ?? "";
+  const number = CREATED_ISSUE_URL.exec(url)?.[1];
+  if (number === undefined) {
+    throw new Error(`${PREFIX8}: gh issue create exited 0 and printed no issue URL, so the issue may exist` + ` unrecorded; it wrote ${describeValue(stdout)}`);
+  }
+  return Object.freeze({ number: Number(number), url });
+}
 function parseJson(stdout, command) {
   try {
     return JSON.parse(stdout);
@@ -8920,6 +9144,29 @@ function createGhIssueBoard(options) {
       const number = issueNumber2(issue3, "removeLabel");
       const off = labelName(label, "removeLabel", "the label");
       await succeed(["issue", "edit", number, "--remove-label", off], `gh issue edit ${number} --remove-label ${off}`);
+    },
+    closeIssue: async (issue3, reason, comment) => {
+      const number = issueNumber2(issue3, "closeIssue");
+      const why = closeReason(reason);
+      const text = closeComment(comment);
+      await succeed(["issue", "close", number, `--reason=${why}`, `--comment=${text}`], `gh issue close ${number} --reason=${why}`);
+    },
+    createLabel: async (name2, description) => {
+      const label = labelName(name2, "createLabel", "the label");
+      const text = commentBody2(description, "createLabel");
+      await succeed(["label", "create", label, `--description=${text}`], `gh label create ${label}`);
+    },
+    createIssue: async (title, body, labels) => {
+      const heading = issueTitle(title);
+      const text = commentBody2(body, "createIssue");
+      const names = labels.map((label) => labelName(label, "createIssue", "the label"));
+      const stdout = await succeed(["issue", "create", `--title=${heading}`, `--body=${text}`, ...names.map((name2) => `--label=${name2}`)], "gh issue create");
+      return createdIssue(stdout);
+    },
+    closePullRequest: async (pullRequest, comment) => {
+      const number = issueNumber2(pullRequest, "closePullRequest");
+      const text = closeComment(comment, "closePullRequest");
+      await succeed(["pr", "close", number, `--comment=${text}`], `gh pr close ${number}`);
     }
   };
   return Object.freeze(board);
@@ -9639,12 +9886,12 @@ function listPassingRows(rows, output) {
 }
 function memoiseVerifier(verify) {
   const read = new Map;
-  return (ref) => {
-    const key = `${ref.kind}\x00${ref.text}`;
+  return (ref3) => {
+    const key = `${ref3.kind}\x00${ref3.text}`;
     const known = read.get(key);
     if (known !== undefined)
       return known;
-    const reading2 = verify(ref);
+    const reading2 = verify(ref3);
     read.set(key, reading2);
     return reading2;
   };
@@ -9683,8 +9930,8 @@ async function enforceRefsGate(options) {
 import path2 from "path";
 async function coreRoster() {
   const [{ CORE_REGISTRY }, { describeRegistry }] = await Promise.all([
-    import("./index-rw7tb99r.js"),
-    import("./describe-0tefrkk7.js")
+    import("./index-amyd4dse.js"),
+    import("./describe-66gth329.js")
   ]);
   return describeRegistry(CORE_REGISTRY, version);
 }
@@ -9698,9 +9945,9 @@ function createPlanRefsVerifier(repoRoot) {
     outline: tsSymbolsOutliner({ cwd: repoRoot }),
     roster: await coreRoster()
   });
-  return async (ref) => {
+  return async (ref3) => {
     made ??= verifier();
-    return (await made)(ref);
+    return (await made)(ref3);
   };
 }
 function isBoardRequest(request) {
@@ -9779,11 +10026,11 @@ async function defaultVerifier(input, issues) {
   });
 }
 function boardUnknown(verify) {
-  return async (ref) => {
+  return async (ref3) => {
     try {
-      return await verify(ref);
+      return await verify(ref3);
     } catch (error) {
-      if (ref.kind === "issue" && error instanceof RefVerifyError)
+      if (ref3.kind === "issue" && error instanceof RefVerifyError)
         return UNREADABLE;
       throw error;
     }
@@ -10207,8 +10454,8 @@ function hasPlanFor(names, issue3) {
 }
 function readHasColumn(issue3, sources) {
   const plan = hasPlanFor(sources.planNames, issue3) ? [{ kind: "plan" }] : [];
-  const ref = sources.refs.find((candidate) => branchClaims(candidate, issue3));
-  const branch = ref === undefined ? [] : [{ kind: "branch", ref }];
+  const ref3 = sources.refs.find((candidate) => branchClaims(candidate, issue3));
+  const branch = ref3 === undefined ? [] : [{ kind: "branch", ref: ref3 }];
   const pulls = sources.pulls.filter((pull) => closedIssuesIn(pull.body).includes(issue3)).map((pull) => ({ kind: "pr", number: pull.number }));
   return Object.freeze([...plan, ...branch, ...pulls]);
 }
@@ -10357,7 +10604,7 @@ async function claimsOf(issues, seams) {
   const refs = scanClaimBranches(seams.git, seams.remote).refs;
   const pulls = await orEmpty(seams.pullRequests, []);
   const closing = new Set(pulls.flatMap((pull) => closedIssuesIn(pull.body)));
-  const claimed = issues.map((issue3) => issue3.number).filter((number) => hasPlanFor(names, number) || closing.has(number) || refs.some((ref) => branchClaims(ref, number)));
+  const claimed = issues.map((issue3) => issue3.number).filter((number) => hasPlanFor(names, number) || closing.has(number) || refs.some((ref3) => branchClaims(ref3, number)));
   return new Set(claimed);
 }
 function epicRowOf(row, byNumber2) {
@@ -10389,6 +10636,7 @@ async function readRoadmapEpicRows(options) {
   const { epicRows, specs } = splitRows(read.rows, epics);
   const shown = epicRows.filter((row) => options.all === true || row.horizon === "now");
   const problems = epicRows.length === 0 || listed.issues === null ? [] : readEpicProblems(listed.issues);
+  const cancelled = listed.issues === null ? [] : cancelledEpicNoticeLines(listed.issues);
   return Object.freeze({
     roadmap: read.roadmap,
     groups: groupByHorizon(shown),
@@ -10397,7 +10645,7 @@ async function readRoadmapEpicRows(options) {
     epics,
     unknown: epics.unknown,
     problems: Object.freeze([...problems]),
-    warnings: Object.freeze([...read.warnings, ...problems.map(epicProblemMessage)])
+    warnings: Object.freeze([...read.warnings, ...problems.map(epicProblemMessage), ...cancelled])
   });
 }
 
@@ -10527,11 +10775,11 @@ async function resolveIssueTracker(context, seams) {
 function issueRef(tracker, id2) {
   return { opt: 0, kind: tracker.kind, externalId: id2, url: null };
 }
-function issueName(ref) {
-  return `${ref.kind} issue ${ref.externalId}`;
+function issueName(ref3) {
+  return `${ref3.kind} issue ${ref3.externalId}`;
 }
-function urlLines(ref) {
-  return ref.url === null ? [] : [`URL: ${ref.url}`];
+function urlLines(ref3) {
+  return ref3.url === null ? [] : [`URL: ${ref3.url}`];
 }
 async function onTracker(tracker, doing, call) {
   try {
@@ -10750,7 +10998,7 @@ function renderEpicTable(rows, width, full = false) {
   return [...epicGroups, ...unknown, ...hidden, ...specs].flatMap((group, index) => index === 0 ? group : ["", ...group]);
 }
 
-// src/commands/epics.ts
+// src/commands/epic/show.ts
 var USAGE2 = "rafa epics [<n>]";
 var ISSUE_NUMBER = /^[1-9]\d*$/u;
 function readEpicArgument(args) {
@@ -10880,12 +11128,16 @@ async function readEpicsView(context, seams) {
   }
   const epics = readEpics({ issues: listing, claims: await claimsOf(listing, read), today: new Date });
   const epic = asked === null ? placeEpic(roadmap, listing, epics) : askedEpic(asked, listing, epics);
+  const cancelled = cancelledEpicNoticeLines(listing);
   const row = listing.find((issue3) => issue3.number === epic?.number);
-  if (epic === null || row === undefined)
-    return Object.freeze({ ...empty, epic: null, unknown: null });
+  if (epic === null || row === undefined) {
+    for (const line of cancelled)
+      warn(line);
+    return Object.freeze({ ...empty, epic: null, unknown: null, warnings: Object.freeze([...notices, ...cancelled]) });
+  }
   const rows = await readLineRows(epicLines(epic, row).lines, read);
   const problems = readEpicProblems(listing).filter((problem) => isProblemOf(problem, epic));
-  const warnings = [...rows.warnings, ...problems.map(epicProblemMessage)];
+  const warnings = [...rows.warnings, ...problems.map(epicProblemMessage), ...cancelled];
   for (const warning of warnings)
     warn(warning);
   return Object.freeze({
@@ -10907,13 +11159,13 @@ async function runEpics(context, seams) {
   for (const text of renderEpics(result, width))
     context.output.info(text);
 }
-function createEpicsCommand(seams = DEFAULT_ISSUE_SEAMS) {
+function createEpicShowCommand(seams = DEFAULT_ISSUE_SEAMS) {
   const command = {
-    name: "epics",
-    subject: "epics",
-    action: "epics",
+    name: "epic show",
+    subject: "epic",
+    action: "show",
     summary: "list one epic's issues as the Roadmap table: the epic numbered, or the first now epic not done",
-    description: "Prints one epic's issues as `rafa roadmap` prints its spec lines, with the spec, blocked by," + " has and refs columns: the unticked lines of the epic's checklist in its order, then its open members" + " missing from the checklist by number. The epic is the type:epic issue numbered, or, with no number," + " the current place's epic, the one `rafa switch` moved to; a place naming a board alone, or no" + " position file, takes the first epic that board (with no position file `roadmap.issue`, else the" + " lowest-numbered open type:roadmap board, else the open issue titled Roadmap) names that is open," + " horizon:now and not done, the one `rafa next` walks into. The table is headed by the epic's title," + " computed state and done/total, and a stored state disagreeing with the computed one is printed" + " under it. No issue of another epic is named. Each label problem about the epic and each reading that" + " failed is warned about; an unreachable board prints the epic unknown with the reason. With" + " `--output=json` the epic, its rows, its problems and the warnings are the data of the terminal result" + " event.",
+    description: "Prints one epic's issues as `rafa roadmap` prints its spec lines, with the spec, blocked by," + " has and refs columns: the unticked lines of the epic's checklist in its order, then its open members" + " missing from the checklist by number. The epic is the type:epic issue numbered, or, with no number," + " the current place's epic, the one `rafa switch` moved to; a place naming a board alone, or no" + " position file, takes the first epic that board (with no position file `roadmap.issue`, else the" + " lowest-numbered open type:roadmap board, else the open issue titled Roadmap) names that is open," + " horizon:now and not done, the one `rafa next` walks into. The table is headed by the epic's title," + " computed state and done/total, and a stored state disagreeing with the computed one is printed" + " under it. No issue of another epic is named. Each label problem about the epic and each reading that" + " failed is warned about; an unreachable board prints the epic unknown with the reason. With" + " `--output=json` the epic, its rows, its problems and the warnings are the data of the terminal result" + " event. `rafa epics` and `rafa epic` are the same command, typed by the subject alone.",
     args: [
       {
         name: "n",
@@ -10925,133 +11177,123 @@ function createEpicsCommand(seams = DEFAULT_ISSUE_SEAMS) {
     flags: [],
     examples: [
       {
-        cmd: "rafa epics",
-        note: "Prints the issues of the epic `rafa next` is walking: the first now epic on the Roadmap not done."
+        cmd: "rafa epic show",
+        note: "Prints the issues of the epic `rafa next` is walking: the first now epic on the Roadmap not done." + " `rafa epics` prints the same."
       },
       {
-        cmd: "rafa epics 252",
-        note: "Prints the issues of epic #252, whatever its horizon, in its checklist's order."
+        cmd: "rafa epic show 252",
+        note: "Prints the issues of epic #252, whatever its horizon, in its checklist's order, as `rafa epics 252` does."
       },
       {
-        cmd: "rafa epics 252 --output=json",
+        cmd: "rafa epic show 252 --output=json",
         note: "Writes a result event whose data holds epic #252 as computed, its rows and its label problems."
       }
     ],
     outputs: ["text", "json"],
+    aliases: ["epic"],
+    lastingAliases: ["epic"],
     run: (context) => runEpics(context, seams)
   };
   return Object.freeze(command);
 }
-var epics_default = createEpicsCommand();
+var show_default = createEpicShowCommand();
 
-// src/commands/plan/list.ts
-import { existsSync as existsSync17, readdirSync as readdirSync9, readFileSync as readFileSync19 } from "fs";
+// src/commands/release/status.ts
+import { existsSync as existsSync18, readdirSync as readdirSync9, readFileSync as readFileSync20 } from "fs";
 import { join as join14 } from "path";
-var USAGE3 = "rafa plan list";
-function listing(dir, stub) {
-  const plan = join14(dir, planFileName(stub, false));
-  const trackerPath = join14(dir, planFileName(stub, true));
-  const tracker = isFile(trackerPath) ? trackerPath : null;
-  const planModel = parsePlan(readFileSync19(plan, "utf8"));
-  const counted2 = tracker === null ? planModel : parsePlan(readFileSync19(tracker, "utf8"));
-  return { stub, plan, tracker, tasks: countTasks(counted2.tasks), issues: planModel.issues.length };
-}
-function listPlans(plans) {
-  const dir = plans.path;
-  if (!existsSync17(dir))
-    return { dir, plans: [] };
-  const stubs = readdirSync9(dir).filter((name2) => isFile(join14(dir, name2))).map((name2) => stubOfPlanFile(name2)).filter((stub) => stub !== null).sort((a, b) => a.localeCompare(b));
-  return { dir, plans: stubs.map((stub) => listing(dir, stub)) };
+
+// src/effort/store/changes.ts
+import { randomUUID as randomUUID4 } from "crypto";
+import { existsSync as existsSync17 } from "fs";
+var INSERT_CHANGE = `
+  INSERT INTO changes (
+    id, session_id, plan_stub, task_line,
+    level, area, summary,
+    collected_at
+  )
+  VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+  ON CONFLICT (session_id, level, ifnull(area, ''), summary) DO NOTHING
+`;
+function optionalText(value) {
+  const problem = textProblem(value);
+  return problem === null ? null : { reason: "unstorable-field", problem };
 }
-function rowNotes(plan) {
-  const notes = [formatCounts(plan.tasks)];
-  if (plan.tracker === null)
-    notes.push("no tracker");
-  if (plan.issues > 0)
-    notes.push(plural(plan.issues, "issue"));
-  return notes.join("; ");
+function requiredText(value) {
+  return value === null ? { reason: "missing-field", problem: "is missing" } : optionalText(value);
 }
-function renderPlanList(list, dirLabel) {
-  const label = `${dirLabel}/`;
-  if (list.plans.length === 0)
-    return [`No plans in ${label}.`];
-  const width = Math.max(...list.plans.map((plan) => plan.stub.length));
-  return [`Plans in ${label}:`, ...list.plans.map((plan) => `  ${plan.stub.padEnd(width)}   ${rowNotes(plan)}`)];
+function requiredLevel(value) {
+  if (value === null)
+    return { reason: "missing-field", problem: "is missing" };
+  if (CHANGE_LEVELS.includes(value))
+    return null;
+  const expected2 = CHANGE_LEVELS.join(", ");
+  return {
+    reason: "unstorable-field",
+    problem: `is ${describeValue3(value)}, not one of ${expected2}`
+  };
 }
-var planListCommand = {
-  name: "plan list",
-  subject: "plan",
-  action: "list",
-  summary: "list the plans, with the tasks done in each",
-  description: "Lists each `PLAN-<stub>.md` in the plans directory `plan.dir` names, in stub" + " order, with its tasks counted by checkbox: from its tracker, `PLAN_TRACKER-<stub>.md`, once" + " there is one, and from the plan itself before then. A plan with no tracker is marked `no" + " tracker`, and a plan the plan parser did not read as written shows how many issues `rafa plan" + " validate` reports for it. The directory is read under the project root, and is `.rafa/plans`" + " unless a config names another. With `--output=json` the list is the data of the terminal result" + " event, each path absolute.",
-  args: [],
-  flags: [],
-  examples: [
-    {
-      cmd: "rafa plan list",
-      note: "Prints one row per plan: its stub, then its tasks done, blocked and open."
-    },
-    {
-      cmd: "rafa plan list --output=json",
-      note: "Writes a start event, then a result event whose data is the list."
-    }
-  ],
-  outputs: ["text", "json"],
-  run: async (context) => {
-    expectNoArgument(context.args, USAGE3);
-    const plans = resolvePlansDir(requireProject(context, USAGE3), USAGE3, (message) => {
-      context.output.warn(message);
-    });
-    const list = listPlans(plans);
-    if (context.outputMode === "json") {
-      context.output.result(list);
-      return;
+var FIELD_CHECKS2 = [
+  ["level", requiredLevel],
+  ["area", optionalText],
+  ["summary", requiredText]
+];
+function rejectionOf2(change, index) {
+  for (const [field5, check] of FIELD_CHECKS2) {
+    const found = check(change[field5]);
+    if (found !== null) {
+      const text = `changes[${index}].${field5} ${found.problem}; not written`;
+      return { index, reason: found.reason, field: field5, text };
     }
-    for (const line of renderPlanList(list, plans.label))
-      context.output.info(line);
   }
-};
-var list_default = Object.freeze(planListCommand);
-
-// src/cli/prompt/confirm.ts
-import { createInterface as createInterface2 } from "readline";
-function createLinePrompter(input, output) {
-  const buffered = [];
-  const waiting = [];
-  let ended = false;
-  const lines = createInterface2({ input, terminal: false, crlfDelay: Infinity });
-  lines.on("line", (line) => {
-    const reader = waiting.shift();
-    if (reader === undefined)
-      buffered.push(line);
+  return null;
+}
+function rowValues2(change, dispatch, id2, collectedAt) {
+  const { sessionId, planStub: planStub2, taskLine } = dispatch;
+  const { level, area, summary } = change;
+  return [id2, sessionId, planStub2, taskLine, level, area, summary, collectedAt];
+}
+function insertRows3(db, rows) {
+  const insert = db.query(INSERT_CHANGE);
+  const insertAll = db.transaction(() => rows.reduce((appended2, values) => appended2 + insert.run(...values).changes, 0));
+  return insertAll.immediate();
+}
+function writeChanges(repoRoot, write, seams = {}) {
+  checkDispatch("changes", write.dispatch, null);
+  const path3 = sqliteStorePath(repoRoot);
+  const rejected = [];
+  const stored = [];
+  for (const [index, change] of write.changes.entries()) {
+    const rejection = rejectionOf2(change, index);
+    if (rejection === null)
+      stored.push(change);
     else
-      reader(line);
-  });
-  lines.on("close", () => {
-    ended = true;
-    for (const reader of waiting.splice(0))
-      reader(null);
-  });
-  return {
-    say: (text) => {
-      output.write(`${text}
-`);
-    },
-    ask: async (question) => {
-      output.write(question);
-      const next = buffered.shift();
-      if (next !== undefined)
-        return next;
-      if (ended)
-        return null;
-      return new Promise((settle) => {
-        waiting.push(settle);
-      });
-    },
-    close: () => {
-      lines.close();
-    }
-  };
+      rejected.push(rejection);
+  }
+  const collectedAt = (seams.now ?? (() => new Date))().toISOString();
+  const newId = seams.newId ?? randomUUID4;
+  const rows = stored.map((change) => rowValues2(change, write.dispatch, newId(), collectedAt));
+  const appended2 = writeSqliteStore(path3, rows.length, 0, (db) => insertRows3(db, rows));
+  return { path: path3, appended: appended2, skipped: stored.length - appended2, rejected };
+}
+var SELECT_PLAN_CHANGES = `
+  SELECT session_id, task_line, level, area, summary, collected_at
+  FROM changes
+  WHERE plan_stub IS ?
+  ORDER BY seq
+`;
+function readPlanChanges(repoRoot, planStub2) {
+  const path3 = sqliteStorePath(repoRoot);
+  if (!existsSync17(path3))
+    return [];
+  const rows = withSqliteStore(path3, false, (db) => db.query(SELECT_PLAN_CHANGES).all(planStub2));
+  return rows.map((row) => ({
+    sessionId: row.session_id,
+    taskLine: row.task_line,
+    level: row.level,
+    area: row.area,
+    summary: row.summary,
+    collectedAt: row.collected_at
+  }));
 }
 // src/pr/preflight-items.ts
 var DEFAULT_GH_HOST = "github.com";
@@ -11130,8 +11372,8 @@ function parseWorktrees(stdout) {
       continue;
     }
     if (line.startsWith("branch ")) {
-      const ref = line.slice("branch ".length).trim();
-      branch = ref.startsWith(BRANCH_REF_PREFIX) ? ref.slice(BRANCH_REF_PREFIX.length) : ref;
+      const ref3 = line.slice("branch ".length).trim();
+      branch = ref3.startsWith(BRANCH_REF_PREFIX) ? ref3.slice(BRANCH_REF_PREFIX.length) : ref3;
     }
   }
   flush();
@@ -11254,7 +11496,7 @@ function readMergeRefusal(reading2) {
   return held.length === 0 ? null : worktreeRefusal(reading2.branch, held);
 }
 function cleanUpSteps(plan) {
-  const { base, branch, remote = DEFAULT_REMOTE2, remoteBranchPresent } = plan;
+  const { base, branch, remote = DEFAULT_REMOTE2, localBranchPresent, remoteBranchPresent } = plan;
   const steps = [
     { id: "switch-base", label: `switch to ${base}`, argv: ["git", "switch", base] },
     {
@@ -11265,7 +11507,8 @@ function cleanUpSteps(plan) {
     {
       id: "delete-local",
       label: `delete the local branch ${branch}`,
-      argv: ["git", "branch", "-D", branch]
+      argv: ["git", "branch", "-D", branch],
+      ...localBranchPresent ? {} : { skip: `no local branch ${branch}; nothing to delete` }
     }
   ];
   if (remoteBranchPresent) {
@@ -11290,7 +11533,7 @@ function commandLine(step) {
 }
 function remainingFrom(steps, failed2) {
   const at = steps.findIndex((step) => step.id === failed2);
-  return at === -1 ? Object.freeze([]) : Object.freeze(steps.slice(at));
+  return at === -1 ? Object.freeze([]) : Object.freeze(steps.slice(at).filter((step) => step.skip === undefined));
 }
 // src/pr/none.ts
 import { spawnSync as spawnSync2 } from "child_process";
@@ -11664,14 +11907,809 @@ function ghPullRequestsIn(cwd) {
 function ghAuthOkIn(cwd) {
   return ghAuthOk(createGhRunner({ cwd }));
 }
-// src/start/branch-decision.ts
-var REMOTE = "origin";
-var BRANCH_PREFIX2 = "feat/";
-var INDENT2 = "   ";
-var UNTRACKED_PREFIX = "??";
-var MAX_LISTED_CHANGES2 = 10;
-var COUNT = /^\d+$/;
-function branchNameFor(planStub2) {
+// src/release/changelog.ts
+var RELEASE_HEADING_FIELDS = ["version", "date", "title"];
+var PLACEHOLDER = /\{([A-Za-z]+)\}/g;
+var WHITESPACE = /\s+/g;
+var ATX_HEADING = /^ {0,3}#{1,6}(?: |$)/;
+var CODE_FENCE = /^ {0,3}(?:```|~~~)/;
+var SEPARATORS = "\u2014\u2013-,;:\xB7|";
+function isSeparator(character) {
+  return character.trim() === "" || SEPARATORS.includes(character);
+}
+function trimTrailingSeparators(text) {
+  let end = text.length;
+  while (end > 0 && isSeparator(text[end - 1] ?? ""))
+    end -= 1;
+  return text.slice(0, end);
+}
+function trimLeadingSeparators(text) {
+  let start = 0;
+  while (start < text.length && isSeparator(text[start] ?? ""))
+    start += 1;
+  return text.slice(start);
+}
+function isHeadingField(field5) {
+  return RELEASE_HEADING_FIELDS.includes(field5);
+}
+function renderReleaseHeading(template, values) {
+  let rendered = "";
+  let afterGap = false;
+  const add = (text) => {
+    if (!afterGap) {
+      rendered += text;
+      return;
+    }
+    const kept = trimLeadingSeparators(text);
+    if (kept === "")
+      return;
+    afterGap = false;
+    rendered += kept;
+  };
+  let cursor = 0;
+  for (const found of template.matchAll(PLACEHOLDER)) {
+    const before = template.slice(cursor, found.index);
+    cursor = found.index + found[0].length;
+    const name2 = found[1] ?? "";
+    if (!isHeadingField(name2)) {
+      add(`${before}${found[0]}`);
+      continue;
+    }
+    const value = values[name2].trim();
+    if (value !== "") {
+      add(before);
+      add(value);
+      continue;
+    }
+    add(before);
+    rendered = `${trimTrailingSeparators(rendered)} `;
+    afterGap = true;
+  }
+  add(template.slice(cursor));
+  return rendered.replace(WHITESPACE, " ").trim();
+}
+function areaOf(note) {
+  const area = note.area?.trim() ?? "";
+  return area === "" ? null : area;
+}
+function groupChangeNotes(notes) {
+  const named = new Map;
+  const unnamed = [];
+  const seen = new Set;
+  let noneNotes = 0;
+  let duplicateNotes = 0;
+  let blankNotes = 0;
+  for (const note of notes) {
+    if (note.level === "none") {
+      noneNotes += 1;
+      continue;
+    }
+    const area = areaOf(note);
+    const summary = note.summary.replace(WHITESPACE, " ").trim();
+    if (summary === "") {
+      blankNotes += 1;
+      continue;
+    }
+    const key = `${area ?? ""}
+${summary}`;
+    if (seen.has(key)) {
+      duplicateNotes += 1;
+      continue;
+    }
+    seen.add(key);
+    if (area === null) {
+      unnamed.push(summary);
+      continue;
+    }
+    const summaries = named.get(area);
+    if (summaries === undefined)
+      named.set(area, [summary]);
+    else
+      summaries.push(summary);
+  }
+  const groups = [...named].map(([area, summaries]) => ({ area, summaries }));
+  return {
+    groups: unnamed.length === 0 ? groups : [...groups, { area: null, summaries: unnamed }],
+    noneNotes,
+    duplicateNotes,
+    blankNotes
+  };
+}
+function renderNoteLines(grouping) {
+  return grouping.groups.flatMap((group) => group.summaries.map((summary) => group.area === null ? `- ${summary}` : `- ${group.area}: ${summary}`));
+}
+function renderChangelogEntry(input) {
+  const heading = renderReleaseHeading(input.template, input.values);
+  const grouping = groupChangeNotes(input.notes);
+  const lines = renderNoteLines(grouping);
+  return {
+    heading,
+    lines,
+    groups: grouping.groups,
+    text: lines.length === 0 ? heading : `${heading}
+
+${lines.join(`
+`)}`,
+    noneNotes: grouping.noneNotes,
+    duplicateNotes: grouping.duplicateNotes,
+    blankNotes: grouping.blankNotes
+  };
+}
+function findHeading(lines, from) {
+  let fenced = false;
+  for (let index = 0;index < lines.length; index += 1) {
+    const line = lines[index] ?? "";
+    if (CODE_FENCE.test(line)) {
+      fenced = !fenced;
+      continue;
+    }
+    if (fenced || index < from)
+      continue;
+    if (ATX_HEADING.test(line))
+      return index;
+  }
+  return null;
+}
+function endOfContent(lines) {
+  let end = lines.length;
+  while (end > 0 && (lines[end - 1] ?? "").trim() === "")
+    end -= 1;
+  return end;
+}
+function insertPoint(lines) {
+  const first = findHeading(lines, 0);
+  if (first === null)
+    return { at: 0, point: "file-top" };
+  const next = findHeading(lines, first + 1);
+  if (next !== null)
+    return { at: next, point: "before-next-heading" };
+  return { at: endOfContent(lines), point: "file-end" };
+}
+function insertChangelogEntry(changelog, entry) {
+  const lines = changelog.split(`
+`);
+  const { at, point } = insertPoint(lines);
+  const entryLines = entry.split(`
+`);
+  const before = at === 0 || (lines[at - 1] ?? "").trim() === "" ? [] : [""];
+  const after = at >= lines.length || (lines[at] ?? "").trim() === "" ? [] : [""];
+  const inserted = [
+    ...lines.slice(0, at),
+    ...before,
+    ...entryLines,
+    ...after,
+    ...lines.slice(at)
+  ];
+  return { text: inserted.join(`
+`), point, line: at + before.length + 1 };
+}
+function changelogDate(now) {
+  const month = `${now.getMonth() + 1}`.padStart(2, "0");
+  const day = `${now.getDate()}`.padStart(2, "0");
+  return `${now.getFullYear()}-${month}-${day}`;
+}
+
+// src/release/level.ts
+var RELEASE_LEVEL_RANK = {
+  none: 0,
+  patch: 1,
+  minor: 2,
+  major: 3
+};
+function highestChangeLevel(notes) {
+  return notes.reduce((highest, note) => highest === null || RELEASE_LEVEL_RANK[note.level] > RELEASE_LEVEL_RANK[highest] ? note.level : highest, null);
+}
+function resolveReleaseLevel(declared, notes) {
+  const notesLevel = highestChangeLevel(notes);
+  if (declared !== null)
+    return { level: declared, source: "plan", notesLevel };
+  if (notesLevel !== null)
+    return { level: notesLevel, source: "notes", notesLevel };
+  return { level: "none", source: "default", notesLevel };
+}
+
+// src/release/version.ts
+import { readFileSync as readFileSync19, 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.-]+))?$/;
+function parseSemanticVersion(raw) {
+  const found = VERSION_SHAPE.exec(raw);
+  if (found === null)
+    return null;
+  return {
+    major: Number(found[1]),
+    minor: Number(found[2]),
+    patch: Number(found[3]),
+    prerelease: found[4] ?? "",
+    build: found[5] ?? ""
+  };
+}
+function formatSemanticVersion(version2) {
+  const prerelease = version2.prerelease === "" ? "" : `-${version2.prerelease}`;
+  const build = version2.build === "" ? "" : `+${version2.build}`;
+  return `${version2.major}.${version2.minor}.${version2.patch}${prerelease}${build}`;
+}
+function bumped(version2, level) {
+  const onPrerelease = version2.prerelease !== "";
+  const blank = { prerelease: "", build: "" };
+  if (level === "major") {
+    const stays = onPrerelease && version2.minor === 0 && version2.patch === 0;
+    const major = stays ? version2.major : version2.major + 1;
+    return { major, minor: 0, patch: 0, ...blank };
+  }
+  if (level === "minor") {
+    const stays = onPrerelease && version2.patch === 0;
+    const minor = stays ? version2.minor : version2.minor + 1;
+    return { major: version2.major, minor, patch: 0, ...blank };
+  }
+  const patch = onPrerelease ? version2.patch : version2.patch + 1;
+  return { major: version2.major, minor: version2.minor, patch, ...blank };
+}
+function nextVersion(base, level) {
+  const parsed = parseSemanticVersion(base);
+  if (parsed === null)
+    return null;
+  if (level === "none")
+    return formatSemanticVersion(parsed);
+  return formatSemanticVersion(bumped(parsed, level));
+}
+function manifestFields(text) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return null;
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
+    return null;
+  return parsed;
+}
+function readManifestVersion(text) {
+  const fields = manifestFields(text);
+  if (fields === null)
+    return null;
+  const value = fields["version"];
+  if (typeof value !== "string")
+    return null;
+  const trimmed = value.trim();
+  return trimmed === "" ? null : trimmed;
+}
+var VERSION_PAIR = /("version"\s*:\s*)"(?:[^"\\]|\\.)*"/g;
+function sameBesidesVersion(before, after) {
+  const restored = { ...after, version: before["version"] };
+  return JSON.stringify(restored) === JSON.stringify(before);
+}
+function replaceManifestVersion(text, next) {
+  const previous = readManifestVersion(text);
+  const before = manifestFields(text);
+  if (previous === null || before === null)
+    return null;
+  for (const pair of text.matchAll(VERSION_PAIR)) {
+    const start = pair.index;
+    const candidate = `${text.slice(0, start)}${pair[1]}${JSON.stringify(next)}${text.slice(start + pair[0].length)}`;
+    const after = manifestFields(candidate);
+    if (after === null || after["version"] !== next)
+      continue;
+    if (!sameBesidesVersion(before, after))
+      continue;
+    return { text: candidate, previous };
+  }
+  return null;
+}
+function writeManifestVersion(path3, next) {
+  const unwritten = { path: path3, written: false, previous: null, version: next };
+  let text;
+  try {
+    text = readFileSync19(path3, "utf8");
+  } catch (error) {
+    return { ...unwritten, problem: `${path3} could not be read: ${messageOf(error)}` };
+  }
+  const rewritten = replaceManifestVersion(text, next);
+  if (rewritten === null) {
+    const previous = readManifestVersion(text);
+    return {
+      ...unwritten,
+      previous,
+      problem: previous === null ? `${path3} declares no version to write ${next} over` : `${path3} declares ${previous}, and the pair holding it could not be rewritten`
+    };
+  }
+  try {
+    writeFileSync9(path3, rewritten.text);
+  } catch (error) {
+    return { ...unwritten, previous: rewritten.previous, problem: `${path3} could not be written: ${messageOf(error)}` };
+  }
+  return { path: path3, written: true, previous: rewritten.previous, version: next, problem: null };
+}
+function gitPathOf(versionFile) {
+  let path3 = versionFile;
+  while (path3.startsWith("./"))
+    path3 = path3.slice(2);
+  return path3;
+}
+function readBaseVersion(git, versionFile, options = {}) {
+  const remote = options.remote ?? RELEASE_REMOTE;
+  const branch = options.branch ?? RELEASE_BASE_BRANCH;
+  const ref3 = `${remote}/${branch}`;
+  const path3 = gitPathOf(versionFile);
+  const problems = [];
+  const fetched = git(["fetch", remote, branch]);
+  if (!fetched.ok) {
+    problems.push(`${branch} could not be fetched from ${remote}, so the base version is whatever this clone already holds for ${ref3}: ${gitSaid(fetched)}`);
+  }
+  const shown = git(["show", `${ref3}:${path3}`]);
+  if (!shown.ok) {
+    problems.push(`${ref3}:${path3} could not be read: ${gitSaid(shown)}`);
+    return { ref: ref3, path: path3, version: null, fetched: fetched.ok, problems };
+  }
+  const version2 = readManifestVersion(shown.stdout);
+  if (version2 === null)
+    problems.push(`${ref3}:${path3} declares no version`);
+  return { ref: ref3, path: path3, version: version2, fetched: fetched.ok, problems };
+}
+
+// src/commands/release/status.ts
+var RELEASE_STATUS_USAGE = "rafa release status [--plan=<stub>]";
+var UNREADABLE2 = "?";
+var NOTHING = "none";
+var INDENT2 = "  ";
+var GAP = "  ";
+var HEADING_VERSION = /(?<![0-9A-Za-z.+-])v?(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?)/g;
+var ATX_HEADING2 = /^ {0,3}#{1,6}(?: |$)/;
+var CODE_FENCE2 = /^ {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({});
+function compareIdentifiers(left, right) {
+  const leftNumeric = NUMERIC_IDENTIFIER.test(left);
+  const rightNumeric = NUMERIC_IDENTIFIER.test(right);
+  if (leftNumeric && rightNumeric)
+    return Number(left) - Number(right);
+  if (leftNumeric)
+    return -1;
+  if (rightNumeric)
+    return 1;
+  if (left === right)
+    return 0;
+  return left < right ? -1 : 1;
+}
+function comparePrereleases(left, right) {
+  if (left === right)
+    return 0;
+  if (left === "")
+    return 1;
+  if (right === "")
+    return -1;
+  const leftParts = left.split(".");
+  const rightParts = right.split(".");
+  const shared = Math.min(leftParts.length, rightParts.length);
+  for (let index = 0;index < shared; index += 1) {
+    const order = compareIdentifiers(leftParts[index] ?? "", rightParts[index] ?? "");
+    if (order !== 0)
+      return order;
+  }
+  return leftParts.length - rightParts.length;
+}
+function compareVersions(left, right) {
+  if (left.major !== right.major)
+    return left.major - right.major;
+  if (left.minor !== right.minor)
+    return left.minor - right.minor;
+  if (left.patch !== right.patch)
+    return left.patch - right.patch;
+  return comparePrereleases(left.prerelease, right.prerelease);
+}
+function compareReleaseTags(left, right) {
+  return compareVersions(right.parsed, left.parsed);
+}
+function releaseTagsOf(text) {
+  const tags = [];
+  for (const line of text.split(`
+`)) {
+    const tag = line.trim();
+    const found = RELEASE_TAG.exec(tag);
+    const version2 = found?.[1];
+    if (version2 === undefined)
+      continue;
+    const parsed = parseSemanticVersion(version2);
+    if (parsed === null)
+      continue;
+    tags.push({ tag, version: version2, parsed });
+  }
+  return [...tags].sort(compareReleaseTags);
+}
+function changelogVersions(text) {
+  const versions = [];
+  const seen = new Set;
+  let fenced = false;
+  for (const line of text.split(`
+`)) {
+    if (CODE_FENCE2.test(line)) {
+      fenced = !fenced;
+      continue;
+    }
+    if (fenced || !ATX_HEADING2.test(line))
+      continue;
+    for (const found of line.matchAll(HEADING_VERSION)) {
+      const version2 = found[1] ?? "";
+      if (parseSemanticVersion(version2) === null)
+        continue;
+      if (!seen.has(version2)) {
+        seen.add(version2);
+        versions.push(version2);
+      }
+      break;
+    }
+  }
+  return versions;
+}
+function untaggedVersions(released, tags) {
+  const tagged = new Set(tags.map((tag) => tag.version));
+  return released.filter((version2) => !tagged.has(version2));
+}
+function textOf(path3) {
+  try {
+    return readFileSync20(path3, "utf8");
+  } catch {
+    return null;
+  }
+}
+function readVersionFile(root, configured) {
+  const resolved = join14(root, configured);
+  const text = textOf(resolved);
+  if (text === null) {
+    return { path: configured, version: null, problem: `the version file could not be read at ${resolved}` };
+  }
+  const version2 = readManifestVersion(text);
+  return version2 === null ? { path: configured, version: null, problem: `${resolved} declares no version this can read` } : { path: configured, version: version2, problem: null };
+}
+function readTags(git) {
+  const result = git(["tag", "--list"]);
+  if (!result.ok) {
+    return { tags: [], latest: null, problem: `the tags could not be listed: ${gitSaid(result)}` };
+  }
+  const tags = releaseTagsOf(result.stdout);
+  return { tags, latest: tags[0] ?? null, problem: null };
+}
+function readUntagged(root, configured, tags) {
+  const resolved = join14(root, configured);
+  const text = textOf(resolved);
+  if (text === null) {
+    return {
+      path: configured,
+      released: [],
+      versions: [],
+      problem: `the changelog could not be read at ${resolved}`
+    };
+  }
+  const released = changelogVersions(text);
+  return { path: configured, released, versions: untaggedVersions(released, tags), problem: null };
+}
+function readBranch(git) {
+  const result = git(["rev-parse", "--abbrev-ref", "HEAD"]);
+  const branch = result.stdout.trim();
+  return result.ok && branch !== "" && branch !== "HEAD" ? branch : null;
+}
+function planStubsUnder2(root, planDir) {
+  const resolved = join14(root, planDir);
+  if (!existsSync18(resolved))
+    return [];
+  try {
+    return planStubsFromFileNames(readdirSync9(resolved));
+  } catch {
+    return [];
+  }
+}
+function branchStubOf(branch) {
+  const slashAt = branch.indexOf("/");
+  if (slashAt <= 0)
+    return null;
+  const stub = branch.slice(slashAt + 1);
+  return stub === "" || stub.includes("/") ? null : stub;
+}
+function pickPlan(asked, branch, stubs) {
+  if (asked !== null)
+    return { stub: asked, source: "flag", problem: null };
+  if (branch === null) {
+    return { stub: null, source: "none", problem: "the branch could not be read, so no plan was resolved" };
+  }
+  const branchStub = branchStubOf(branch);
+  if (branchStub === null) {
+    return { stub: null, source: "none", problem: `the branch "${branch}" names no plan stub` };
+  }
+  const resolution = resolvePlanStub(branchStub, stubs);
+  if (resolution.stub !== null)
+    return { stub: resolution.stub, source: "roster", problem: null };
+  if (resolution.match === "ambiguous") {
+    return {
+      stub: null,
+      source: "none",
+      problem: `the branch stub "${branchStub}" reaches ${resolution.candidates.length} plans:` + ` ${resolution.candidates.join(", ")}`
+    };
+  }
+  return { stub: branchStub, source: "branch", problem: null };
+}
+function readPending(root, asked, branch, stubs, readNotes) {
+  const pick = pickPlan(asked, branch, stubs);
+  const empty = { stub: pick.stub, source: pick.source, branch, notes: [], level: null };
+  if (pick.stub === null)
+    return { ...empty, problem: pick.problem };
+  try {
+    const notes = readNotes(root, pick.stub);
+    return { ...empty, notes, level: highestChangeLevel(notes), problem: pick.problem };
+  } catch (error) {
+    return { ...empty, problem: `the change notes could not be read: ${messageOf(error)}` };
+  }
+}
+function versionFileCell(reading2) {
+  return `${reading2.path}: ${reading2.version ?? UNREADABLE2}`;
+}
+function tagCell(reading2) {
+  if (reading2.problem !== null)
+    return UNREADABLE2;
+  const held = `of ${reading2.tags.length} release tags`;
+  return reading2.latest === null ? `${NOTHING}, ${held}` : `${reading2.latest.tag}, ${held}`;
+}
+function untaggedCell(reading2) {
+  if (reading2.problem !== null)
+    return UNREADABLE2;
+  if (reading2.released.length === 0)
+    return `${NOTHING}, and the changelog names no release`;
+  return reading2.versions.length === 0 ? NOTHING : reading2.versions.join(", ");
+}
+function levelPhrase(level) {
+  return level === "none" ? "worth no release" : `worth a ${level} release`;
+}
+function pendingCell(reading2) {
+  if (reading2.stub === null)
+    return `${NOTHING}: no current plan`;
+  const count = reading2.notes.length === 1 ? "1 note" : `${reading2.notes.length} notes`;
+  if (reading2.notes.length === 0)
+    return `${NOTHING} for ${reading2.stub}`;
+  return `${count} for ${reading2.stub}, ${levelPhrase(reading2.level ?? "none")}`;
+}
+function pendingLines(reading2) {
+  return renderNoteLines(groupChangeNotes(reading2.notes));
+}
+function problemsOf(reading2) {
+  return [
+    reading2.versionFile.problem,
+    reading2.tags.problem,
+    reading2.untagged.problem,
+    reading2.plan.problem
+  ].filter((problem) => problem !== null);
+}
+var LABELS = ["version file", "latest tag", "untagged", "pending"];
+function renderStatus(reading2) {
+  const width = Math.max(...LABELS.map((label) => label.length));
+  const cells = [
+    versionFileCell(reading2.versionFile),
+    tagCell(reading2.tags),
+    untaggedCell(reading2.untagged),
+    pendingCell(reading2.plan)
+  ];
+  const lines = LABELS.map((label, index) => `${INDENT2}${label.padEnd(width)}${GAP}${cells[index] ?? ""}`);
+  const notes = pendingLines(reading2.plan).map((line) => `${INDENT2}${" ".repeat(width)}${GAP}${line}`);
+  const problems = problemsOf(reading2).map((problem) => `${INDENT2}${problem}`);
+  const block = [...lines, ...notes].join(`
+`);
+  return problems.length === 0 ? block : [block, problems.join(`
+`)].join(`
+
+`);
+}
+function projectOf(context) {
+  if (context.project === null)
+    throw new Error("rafa release runs inside a project, and was handed none");
+  return context.project;
+}
+function statusConfig(project, warn) {
+  try {
+    const { config } = loadConfig({ root: project.root, home: project.home }, {}, warn);
+    return {
+      versionFile: config.releaseVersionFile,
+      changelog: config.releaseChangelog,
+      planDir: config.planDir
+    };
+  } catch (error) {
+    if (!(error instanceof ConfigError))
+      throw error;
+    throw new CommandExit(1, ["\u274C The config cannot be used:", ...error.problems.map((problem) => `  ${problem}`)].join(`
+`));
+  }
+}
+function readPlanFlag(context) {
+  const value = context.flags["plan"];
+  if (value === undefined)
+    return null;
+  const stub = typeof value === "string" ? value.trim() : "";
+  if (stub === "") {
+    throw new CommandExit(1, `\u274C --plan takes a plan stub, as --plan=rafa-21-changelog-and-release
+Usage: ${RELEASE_STATUS_USAGE}`);
+  }
+  return stub;
+}
+function expectNoArguments(args) {
+  if (args.length === 0)
+    return;
+  throw new CommandExit(1, `\u274C Expected no arguments, got ${args.length}: ${args.join(" ")}
+Usage: ${RELEASE_STATUS_USAGE}`);
+}
+function readStatus(context, seams = DEFAULT_RELEASE_SEAMS) {
+  expectNoArguments(context.args);
+  const asked = readPlanFlag(context);
+  const project = projectOf(context);
+  const config = statusConfig(project, (message) => {
+    context.output.warn(message);
+  });
+  const git = (seams.git ?? createGitRunner)(project.root);
+  const readNotes = seams.readNotes ?? readPlanChanges;
+  const tags = readTags(git);
+  const reading2 = {
+    versionFile: readVersionFile(project.root, config.versionFile),
+    tags,
+    untagged: readUntagged(project.root, config.changelog, tags.tags),
+    plan: readPending(project.root, asked, readBranch(git), planStubsUnder2(project.root, config.planDir), readNotes)
+  };
+  return { reading: reading2, text: renderStatus(reading2) };
+}
+function createReleaseStatusCommand(seams = DEFAULT_RELEASE_SEAMS) {
+  const command = {
+    name: "release status",
+    subject: "release",
+    action: "status",
+    summary: "show the version, the latest tag, the untagged releases and the pending change notes",
+    description: "Reads four things about the release state of the project and writes nothing: the version" + " `release.versionFile` declares, the latest release tag of the repository by semantic version" + " precedence, the versions `release.changelog` calls released that carry no tag, and the change notes" + " the current plan's sessions have stored for its next release. The current plan is the one" + " `--plan=<stub>` names, and otherwise the one the checked-out branch's `<type>/<stub>` names," + " resolved against the plans in `plan.dir`. A reading that could not be made leaves its cell as `?`" + " and says why on a line under the block rather than refusing the other three. With `--output=json`" + " the four readings and the rendered block are the data of the terminal result event.",
+    args: [],
+    flags: [
+      {
+        name: "plan",
+        description: "the plan stub the pending change notes are read for, instead of the branch's",
+        type: "string"
+      }
+    ],
+    examples: [
+      {
+        cmd: "rafa release status",
+        note: "Shows the version, the latest tag, the untagged releases and the notes pending for this branch's plan."
+      },
+      {
+        cmd: "rafa release status --plan=rafa-21-changelog-and-release",
+        note: "Reads the pending change notes for that plan rather than the one the branch names."
+      }
+    ],
+    outputs: ["text", "json"],
+    run: async (context) => {
+      const status = readStatus(context, seams);
+      if (context.outputMode === "json") {
+        context.output.result(status);
+        return;
+      }
+      context.output.info(status.text);
+    }
+  };
+  return Object.freeze(command);
+}
+var status_default = createReleaseStatusCommand();
+
+// src/commands/plan/list.ts
+import { existsSync as existsSync19, readdirSync as readdirSync10, readFileSync as readFileSync21 } from "fs";
+import { join as join15 } from "path";
+var USAGE3 = "rafa plan list";
+function listing(dir, stub) {
+  const plan = join15(dir, planFileName(stub, false));
+  const trackerPath = join15(dir, planFileName(stub, true));
+  const tracker = isFile(trackerPath) ? trackerPath : null;
+  const planModel = parsePlan(readFileSync21(plan, "utf8"));
+  const counted2 = tracker === null ? planModel : parsePlan(readFileSync21(tracker, "utf8"));
+  return { stub, plan, tracker, tasks: countTasks(counted2.tasks), issues: planModel.issues.length };
+}
+function listPlans(plans) {
+  const dir = plans.path;
+  if (!existsSync19(dir))
+    return { dir, plans: [] };
+  const stubs = readdirSync10(dir).filter((name2) => isFile(join15(dir, name2))).map((name2) => stubOfPlanFile(name2)).filter((stub) => stub !== null).sort((a, b) => a.localeCompare(b));
+  return { dir, plans: stubs.map((stub) => listing(dir, stub)) };
+}
+function rowNotes(plan) {
+  const notes = [formatCounts(plan.tasks)];
+  if (plan.tracker === null)
+    notes.push("no tracker");
+  if (plan.issues > 0)
+    notes.push(plural(plan.issues, "issue"));
+  return notes.join("; ");
+}
+function renderPlanList(list, dirLabel) {
+  const label = `${dirLabel}/`;
+  if (list.plans.length === 0)
+    return [`No plans in ${label}.`];
+  const width = Math.max(...list.plans.map((plan) => plan.stub.length));
+  return [`Plans in ${label}:`, ...list.plans.map((plan) => `  ${plan.stub.padEnd(width)}   ${rowNotes(plan)}`)];
+}
+var planListCommand = {
+  name: "plan list",
+  subject: "plan",
+  action: "list",
+  summary: "list the plans, with the tasks done in each",
+  description: "Lists each `PLAN-<stub>.md` in the plans directory `plan.dir` names, in stub" + " order, with its tasks counted by checkbox: from its tracker, `PLAN_TRACKER-<stub>.md`, once" + " there is one, and from the plan itself before then. A plan with no tracker is marked `no" + " tracker`, and a plan the plan parser did not read as written shows how many issues `rafa plan" + " validate` reports for it. The directory is read under the project root, and is `.rafa/plans`" + " unless a config names another. With `--output=json` the list is the data of the terminal result" + " event, each path absolute.",
+  args: [],
+  flags: [],
+  examples: [
+    {
+      cmd: "rafa plan list",
+      note: "Prints one row per plan: its stub, then its tasks done, blocked and open."
+    },
+    {
+      cmd: "rafa plan list --output=json",
+      note: "Writes a start event, then a result event whose data is the list."
+    }
+  ],
+  outputs: ["text", "json"],
+  run: async (context) => {
+    expectNoArgument(context.args, USAGE3);
+    const plans = resolvePlansDir(requireProject(context, USAGE3), USAGE3, (message) => {
+      context.output.warn(message);
+    });
+    const list = listPlans(plans);
+    if (context.outputMode === "json") {
+      context.output.result(list);
+      return;
+    }
+    for (const line of renderPlanList(list, plans.label))
+      context.output.info(line);
+  }
+};
+var list_default = Object.freeze(planListCommand);
+
+// src/cli/prompt/confirm.ts
+import { createInterface as createInterface2 } from "readline";
+function createLinePrompter(input, output) {
+  const buffered = [];
+  const waiting = [];
+  let ended = false;
+  const lines = createInterface2({ input, terminal: false, crlfDelay: Infinity });
+  lines.on("line", (line) => {
+    const reader = waiting.shift();
+    if (reader === undefined)
+      buffered.push(line);
+    else
+      reader(line);
+  });
+  lines.on("close", () => {
+    ended = true;
+    for (const reader of waiting.splice(0))
+      reader(null);
+  });
+  return {
+    say: (text) => {
+      output.write(`${text}
+`);
+    },
+    ask: async (question) => {
+      output.write(question);
+      const next = buffered.shift();
+      if (next !== undefined)
+        return next;
+      if (ended)
+        return null;
+      return new Promise((settle) => {
+        waiting.push(settle);
+      });
+    },
+    close: () => {
+      lines.close();
+    }
+  };
+}
+
+// src/start/branch-decision.ts
+var REMOTE = "origin";
+var BRANCH_PREFIX2 = "feat/";
+var INDENT3 = "   ";
+var UNTRACKED_PREFIX = "??";
+var MAX_LISTED_CHANGES2 = 10;
+var COUNT = /^\d+$/;
+function branchNameFor(planStub2) {
   return `${BRANCH_PREFIX2}${planStub2}`;
 }
 function localRef(branch) {
@@ -11720,9 +12758,9 @@ function plural3(count, singular, many) {
   return count === 1 ? `1 ${singular}` : `${count} ${many}`;
 }
 function listChanges2(entries) {
-  const shown = entries.slice(0, MAX_LISTED_CHANGES2).map((entry) => `${INDENT2}${entry}`);
+  const shown = entries.slice(0, MAX_LISTED_CHANGES2).map((entry) => `${INDENT3}${entry}`);
   const hidden = entries.length - shown.length;
-  return hidden > 0 ? [...shown, `${INDENT2}... and ${hidden} more`] : shown;
+  return hidden > 0 ? [...shown, `${INDENT3}... and ${hidden} more`] : shown;
 }
 function trackedChanges(tree) {
   return Object.freeze(tree.entries.filter((entry) => !entry.startsWith(UNTRACKED_PREFIX)));
@@ -11734,7 +12772,7 @@ function treeRefusal(tree, plan) {
   return [
     `\u274C Refusing to leave ${plan.base} for ${plan.branch}: ` + `the working tree has ${plural3(changes.length, "change", "changes")} to tracked files.`,
     ...listChanges2(changes),
-    `${INDENT2}Commit or stash them, then run again. Untracked files are left alone.`
+    `${INDENT3}Commit or stash them, then run again. Untracked files are left alone.`
   ].join(`
 `);
 }
@@ -11797,10 +12835,10 @@ function refuse4(lines) {
 }
 function quotedLines(said) {
   return said === "" ? [] : said.split(`
-`).map((line) => `${INDENT2}${line}`);
+`).map((line) => `${INDENT3}${line}`);
 }
 function stillOn(plan) {
-  return `${INDENT2}The run is still on ${plan.base}.`;
+  return `${INDENT3}The run is still on ${plan.base}.`;
 }
 function failureHead(step, plan) {
   if (step.id === "fetch") {
@@ -11816,8 +12854,8 @@ function divergedRefusal(standing, plan) {
   const behind = plural3(standing.behind, "commit", "commits");
   return refuse4([
     `\u274C Refusing to create ${plan.branch}: ${plan.base} has diverged from ${REMOTE}/${plan.base}.`,
-    `${INDENT2}${plan.base} is ${ahead} ahead of ${REMOTE}/${plan.base} and ${behind} behind it.`,
-    `${INDENT2}Push, rebase or reset ${plan.base}, then run again.`
+    `${INDENT3}${plan.base} is ${ahead} ahead of ${REMOTE}/${plan.base} and ${behind} behind it.`,
+    `${INDENT3}Push, rebase or reset ${plan.base}, then run again.`
   ]);
 }
 function readStepOutcome(step, result, plan) {
@@ -11830,7 +12868,7 @@ function readStepOutcome(step, result, plan) {
   if (standing === null) {
     return refuse4([
       `\u274C Could not ${step.label}.`,
-      `${INDENT2}git answered ${JSON.stringify(result.stdout)}, which is no pair of counts.`,
+      `${INDENT3}git answered ${JSON.stringify(result.stdout)}, which is no pair of counts.`,
       stillOn(plan)
     ]);
   }
@@ -11920,11 +12958,11 @@ function parseArgs(argv, spec = {}) {
 
 // src/commands/loop/loop-sessions.ts
 import { execFileSync as execFileSync2 } from "child_process";
-import { readFileSync as readFileSync20 } from "fs";
-import { join as join15, relative as relative3 } from "path";
+import { readFileSync as readFileSync22 } from "fs";
+import { join as join16, relative as relative3 } from "path";
 
 // src/effort/store/task-finishes.ts
-import { existsSync as existsSync18 } from "fs";
+import { existsSync as existsSync20 } from "fs";
 var SELECT_FINISHES = `
   SELECT collected_at FROM task_reports
   WHERE plan_stub IS ? AND outcome = 'done' AND collected_at >= ?
@@ -11935,7 +12973,7 @@ var SELECT_FINISHES = `
 `;
 function readTaskFinishes(repoRoot, query) {
   const path3 = sqliteStorePath(repoRoot);
-  if (!existsSync18(path3))
+  if (!existsSync20(path3))
     return [];
   const bound = [query.planStub, query.since, query.planStub, query.since];
   const rows = withSqliteStore(path3, false, (db) => db.query(SELECT_FINISHES).all(...bound));
@@ -12019,9 +13057,9 @@ function readRecords(root, seams) {
     throw refusal2(`The session records under ${runsLabel(root)} cannot be read.`, messageOf(error));
   }
 }
-function readBranchOrRefuse(root, readBranch) {
+function readBranchOrRefuse(root, readBranch2) {
   try {
-    return readBranch(root);
+    return readBranch2(root);
   } catch (error) {
     throw refusal2("The branch checked out at the project root cannot be read, so no session is paired with it.", messageOf(error).split(`
 `)[0] ?? "", `Name the session with --${SESSION_ID_FLAG}; \`rafa loop list\` lists the running ones.`);
@@ -12065,11 +13103,11 @@ function writeSession(root, record, change) {
   }
 }
 function readSessionChecklist(root, record) {
-  const plan = join15(root, record.plan);
+  const plan = join16(root, record.plan);
   const file = [trackerPathFor(plan), plan].find((path3) => isFile(path3));
   if (file === undefined)
     return null;
-  const content = readFileSync20(file, "utf8");
+  const content = readFileSync22(file, "utf8");
   return { file, tasks: parsePlan(content).tasks, lines: content.split(`
 `) };
 }
@@ -12106,6 +13144,60 @@ function etaLine(eta) {
   return `ETA: ${total2} for ${plural(eta.left, "task")} left,` + ` at ${formatDuration(eta.secondsPerTask)} per task over the ${plural(eta.finished, "task")} this session finished`;
 }
 
+// src/next/epic-end.ts
+var CLOSE_MARK = "\uD83D\uDC49";
+var ROADMAP_MARK = "\uD83D\uDDFA";
+var RELEASE_MARK = "\uD83C\uDFF7";
+var EPIC_END_ROADMAP_COMMAND = "rafa roadmap";
+var EPIC_END_RELEASE_COMMAND = "rafa release tag";
+function epicCloseCommand(epic) {
+  return `rafa epic close ${String(epic.number)}`;
+}
+function readEpicEndRelease(git, root, changelog) {
+  const tags = readTags(git);
+  if (tags.problem !== null)
+    return { changelog, versions: [], problem: tags.problem };
+  const untagged = readUntagged(root, changelog, tags.tags);
+  return untagged.problem === null ? { changelog, versions: untagged.versions, problem: null } : { changelog, versions: [], problem: untagged.problem };
+}
+function namedVersions(versions) {
+  if (versions.length === 1)
+    return `${versions[0] ?? ""} is`;
+  const head = versions.slice(0, -1).join(", ");
+  return `${head} and ${versions[versions.length - 1] ?? ""} are`;
+}
+function epicEndLines(epic, release) {
+  const lines = [
+    `${CLOSE_MARK} epic #${String(epic.number)} ${epic.title} has run dry: close it through its gate` + ` \u2014 ${epicCloseCommand(epic)}`,
+    `${ROADMAP_MARK} list the board's epics with their state and progress \u2014 ${EPIC_END_ROADMAP_COMMAND}`
+  ];
+  if (release === null || release.versions.length === 0)
+    return Object.freeze(lines);
+  return Object.freeze([
+    ...lines,
+    `${RELEASE_MARK} ${namedVersions(release.versions)} in ${release.changelog} with no tag: tag the release` + ` \u2014 ${EPIC_END_RELEASE_COMMAND}`
+  ]);
+}
+function watchDryEpic() {
+  let last = null;
+  return {
+    watch: (sources) => {
+      last = null;
+      const { board } = sources;
+      const watched = {
+        ...board,
+        next: async () => {
+          const reading2 = await board.next();
+          last = reading2.dryEpic ?? null;
+          return reading2;
+        }
+      };
+      return { ...sources, board: watched };
+    },
+    last: () => last
+  };
+}
+
 // src/next/sources.ts
 var PREFIX14 = "rafa next";
 var DEFAULT_BASE_BRANCH = "main";
@@ -12125,6 +13217,13 @@ function listOnce3(read) {
     return kept;
   };
 }
+async function cancelledNotices(listing2) {
+  try {
+    return cancelledEpicNoticeLines(await listing2());
+  } catch {
+    return [];
+  }
+}
 async function walkEpic(epic, listing2, readings) {
   const rows = await listing2();
   const read = readEpics({ issues: rows, claims: new Set, today: new Date(0) }).epics.find((candidate) => candidate.number === epic);
@@ -12133,11 +13232,20 @@ async function walkEpic(epic, listing2, readings) {
     throw new Error(`${PREFIX14}: epic #${String(epic)}, the current place, is not on the board listing, so its members cannot be read`);
   }
   const pick = await pickNextRoadmapLine(epicLines(read, row).lines, readings);
-  return { line: pick.line, passed: pick.skipped.length };
+  return {
+    line: pick.line,
+    passed: pick.skipped.length,
+    dry: pick.line === null ? { number: read.number, title: read.title } : null
+  };
 }
 function ghNextBoard(options) {
   const { gh, git, configured, remote, root } = options;
-  const listing2 = listOnce3(options.listing ?? createGhBoardListing({ gh }));
+  const listed = options.listing ?? createGhBoardListing({ gh });
+  let asked = false;
+  const listing2 = listOnce3(() => {
+    asked = true;
+    return listed();
+  });
   const issues = memoiseIssues2(createGhSpecIssueReader({ gh }));
   return Object.freeze({
     next: async () => {
@@ -12156,11 +13264,13 @@ function ghNextBoard(options) {
         pullRequests: createGhOpenPullRequests({ gh })
       });
       const walk = epic === null ? await walkBoard(roadmap, { issues, readings, listing: listing2 }) : await walkEpic(epic, listing2, readings);
+      const cancelled = options.noticeCancelled === true && asked ? await cancelledNotices(listing2) : [];
       return {
         roadmap,
         line: walk.line,
         passed: walk.passed,
-        problems: [...current?.notices ?? [], ...branches.problems]
+        problems: [...current?.notices ?? [], ...cancelled, ...branches.problems],
+        ...walk.dry === null ? {} : { dryEpic: walk.dry }
       };
     },
     blocking: async (issue3) => readBlockedLine(await issues(issue3), blockerStatesOf(issues)),
@@ -12169,8 +13279,12 @@ function ghNextBoard(options) {
 }
 async function walkBoard(roadmap, seams) {
   const read = await seams.issues(roadmap);
-  const { descent, pick } = await pickDescendedLine(parseRoadmapBody(read.body), seams);
-  return { line: pick.line, passed: descent.passed.length + pick.skipped.length };
+  const { descent, pick, dry } = await pickDescendedLine(parseRoadmapBody(read.body), seams);
+  return {
+    line: pick.line,
+    passed: descent.passed.length + pick.skipped.length,
+    dry: dry && descent.epic !== null ? { number: descent.epic.number, title: descent.epic.title } : null
+  };
 }
 function nextProject(context) {
   if (context.project === null)
@@ -12203,7 +13317,7 @@ function openNextSources(context, seams = DEFAULT_NEXT_SOURCE_SEAMS) {
   const git = (seams.openGit ?? createGitRunner)(project.root);
   const gh = (seams.openGh ?? ((root) => createGhRunner({ cwd: root })))(project.root);
   const loop = resolveLoopSeams({ isAlive: seams.isAlive });
-  const board = () => ghNextBoard({ gh, git, configured: config.roadmapIssue, root: project.root });
+  const board = () => ghNextBoard({ gh, git, configured: config.roadmapIssue, root: project.root, noticeCancelled: true });
   const held = {
     base: config.prBase ?? DEFAULT_BASE_BRANCH,
     plans: plansDirAt(project.root, config.planDir),
@@ -12214,7 +13328,8 @@ function openNextSources(context, seams = DEFAULT_NEXT_SOURCE_SEAMS) {
   return Object.freeze({
     ...held,
     board: board(),
-    answer: () => Object.freeze({ ...held, board: board() })
+    answer: () => Object.freeze({ ...held, board: board() }),
+    release: () => readEpicEndRelease(git, project.root, config.releaseChangelog)
   });
 }
 
@@ -12228,7 +13343,7 @@ function once2(read) {
     return held.value;
   };
 }
-function readBranch(sources, note) {
+function readBranch2(sources, note) {
   const result = sources.git(["rev-parse", "--abbrev-ref", "HEAD"]);
   if (!result.ok) {
     note(`the branch at the project root could not be read, so no branch names a plan or a pull request: ${gitSaid(result)}`);
@@ -12308,7 +13423,7 @@ function hasRun(records, stub) {
 }
 function hasBranch(refs, stub) {
   const branch = `${BRANCH_PREFIX2}${stub}`;
-  return refs.some((ref) => ref === branch || ref.endsWith(`/${branch}`));
+  return refs.some((ref3) => ref3 === branch || ref3.endsWith(`/${branch}`));
 }
 function openWorld(sources) {
   let problems = [];
@@ -12317,7 +13432,7 @@ function openWorld(sources) {
   };
   const remote = sources.remote ?? REMOTE;
   const runs = once2(() => sources.runs());
-  const branch = once2(() => readBranch(sources, note));
+  const branch = once2(() => readBranch2(sources, note));
   const plans = once2(() => readPlans(sources, note));
   const refs = once2(() => readRefs(sources, remote, note));
   const roadmap = once2(async () => {
@@ -13021,13 +14136,13 @@ function versionLine() {
 }
 
 // src/notices/notices.ts
-import { mkdirSync as mkdirSync8, readFileSync as readFileSync21, writeFileSync as writeFileSync9 } from "fs";
-import { dirname as dirname11, join as join16 } from "path";
+import { mkdirSync as mkdirSync8, readFileSync as readFileSync23, writeFileSync as writeFileSync10 } from "fs";
+import { dirname as dirname11, join as join17 } 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";
 function noticesPath(home) {
-  return join16(home, ".rafa", "notices.json");
+  return join17(home, ".rafa", "notices.json");
 }
 function isNoticeId(value) {
   return typeof value === "string" && NOTICE_IDS.includes(value);
@@ -13035,7 +14150,7 @@ function isNoticeId(value) {
 function readDismissed(home) {
   let raw;
   try {
-    raw = readFileSync21(noticesPath(home), "utf8");
+    raw = readFileSync23(noticesPath(home), "utf8");
   } catch {
     return [];
   }
@@ -13055,7 +14170,7 @@ function writeDismissed(home, ids) {
   const all = NOTICE_IDS.filter((id2) => ids.includes(id2) || readDismissed(home).includes(id2));
   const path3 = noticesPath(home);
   mkdirSync8(dirname11(path3), { recursive: true });
-  writeFileSync9(path3, `${JSON.stringify({ dismissed: all }, null, 2)}
+  writeFileSync10(path3, `${JSON.stringify({ dismissed: all }, null, 2)}
 `);
 }
 function pendingNotices(dismissed) {
@@ -13130,10 +14245,10 @@ async function requireNoticesAnswered() {
 }
 
 // src/start/branch.ts
-var INDENT3 = "   ";
+var INDENT4 = "   ";
 var DEFAULT_BRANCH_SEAMS = Object.freeze({});
-function refExists(git, ref) {
-  return git(["show-ref", "--verify", "--quiet", ref]).ok;
+function refExists(git, ref3) {
+  return git(["show-ref", "--verify", "--quiet", ref3]).ok;
 }
 function terminalReading(seams) {
   return seams.isTerminal ?? (() => process.stdin.isTTY === true);
@@ -13166,8 +14281,8 @@ function readWorkingTree(git, plan) {
     return parseWorkingTree(result.stdout);
   throw new CommandExit(1, [
     `\u274C Could not read the working tree before leaving ${plan.base} for ${plan.branch}.`,
-    `${INDENT3}${gitSaid(result)}`,
-    `${INDENT3}The run is still on ${plan.base}.`
+    `${INDENT4}${gitSaid(result)}`,
+    `${INDENT4}The run is still on ${plan.base}.`
   ].join(`
 `));
 }
@@ -13188,9 +14303,9 @@ ${refused}`);
     if (outcome.kind === "refuse")
       throw new CommandExit(1, `
 ${outcome.message}`);
-    activeOutput().info(`${INDENT3}${step.label}: done`);
+    activeOutput().info(`${INDENT4}${step.label}: done`);
   }
-  activeOutput().info(`${INDENT3}The run is on ${plan.branch}.`);
+  activeOutput().info(`${INDENT4}The run is on ${plan.branch}.`);
   return Object.freeze({ kind: "moved", branch: plan.branch, route, steps });
 }
 async function offerRunBranch(request, seams = DEFAULT_BRANCH_SEAMS) {
@@ -14001,8 +15116,8 @@ function reportLessons(record, context, now) {
 }
 
 // src/effort/store/absences.ts
-import { randomUUID as randomUUID4 } from "crypto";
-import { existsSync as existsSync19 } from "fs";
+import { randomUUID as randomUUID5 } from "crypto";
+import { existsSync as existsSync21 } from "fs";
 var ABSENCE_REASONS = {
   "no-block": true,
   "unclosed-block": true,
@@ -14022,141 +15137,47 @@ function refusedWrite7(reason) {
   return new Error(`effort store: report absence write ${reason}; nothing written`);
 }
 function checkAbsence(absence) {
-  const { reason, text, block } = absence;
-  if (!REPORT_ABSENCE_REASONS.includes(reason)) {
-    const expected2 = REPORT_ABSENCE_REASONS.join(", ");
-    throw refusedWrite7(`has reason ${describeValue3(reason)}, not one of ${expected2}`);
-  }
-  if (typeof text !== "string") {
-    throw refusedWrite7(`has detail ${describeValue3(text)}, not a string`);
-  }
-  const detailProblem = textProblem(text);
-  if (detailProblem !== null)
-    throw refusedWrite7(`has a detail that ${detailProblem}`);
-  if (block === null)
-    return;
-  if (typeof block.body !== "string") {
-    throw refusedWrite7(`has block body ${describeValue3(block.body)}, not a string`);
-  }
-  if (LONE_SURROGATE.test(block.body)) {
-    throw refusedWrite7("has a block body holding a lone UTF-16 surrogate");
-  }
-}
-function writeReportAbsence(repoRoot, write, seams = {}) {
-  checkDispatch("report absence", write.dispatch, write.outcome);
-  checkAbsence(write.absence);
-  const path3 = sqliteStorePath(repoRoot);
-  const { sessionId, planStub: planStub2, taskLine } = write.dispatch;
-  const { reason, text, block } = write.absence;
-  const collectedAt = (seams.now ?? (() => new Date))().toISOString();
-  const id2 = (seams.newId ?? randomUUID4)();
-  const values = [
-    id2,
-    sessionId,
-    planStub2,
-    taskLine,
-    reason,
-    text,
-    block?.body ?? null,
-    write.outcome,
-    collectedAt
-  ];
-  const appended2 = withSqliteStore(path3, !existsSync19(path3), (db) => db.query(INSERT_ABSENCE).run(...values).changes);
-  return { path: path3, appended: appended2, skipped: 1 - appended2 };
-}
-
-// src/effort/store/changes.ts
-import { randomUUID as randomUUID5 } from "crypto";
-import { existsSync as existsSync20 } from "fs";
-var INSERT_CHANGE = `
-  INSERT INTO changes (
-    id, session_id, plan_stub, task_line,
-    level, area, summary,
-    collected_at
-  )
-  VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-  ON CONFLICT (session_id, level, ifnull(area, ''), summary) DO NOTHING
-`;
-function optionalText(value) {
-  const problem = textProblem(value);
-  return problem === null ? null : { reason: "unstorable-field", problem };
-}
-function requiredText(value) {
-  return value === null ? { reason: "missing-field", problem: "is missing" } : optionalText(value);
-}
-function requiredLevel(value) {
-  if (value === null)
-    return { reason: "missing-field", problem: "is missing" };
-  if (CHANGE_LEVELS.includes(value))
-    return null;
-  const expected2 = CHANGE_LEVELS.join(", ");
-  return {
-    reason: "unstorable-field",
-    problem: `is ${describeValue3(value)}, not one of ${expected2}`
-  };
-}
-var FIELD_CHECKS2 = [
-  ["level", requiredLevel],
-  ["area", optionalText],
-  ["summary", requiredText]
-];
-function rejectionOf2(change, index) {
-  for (const [field5, check] of FIELD_CHECKS2) {
-    const found = check(change[field5]);
-    if (found !== null) {
-      const text = `changes[${index}].${field5} ${found.problem}; not written`;
-      return { index, reason: found.reason, field: field5, text };
-    }
-  }
-  return null;
-}
-function rowValues2(change, dispatch, id2, collectedAt) {
-  const { sessionId, planStub: planStub2, taskLine } = dispatch;
-  const { level, area, summary } = change;
-  return [id2, sessionId, planStub2, taskLine, level, area, summary, collectedAt];
-}
-function insertRows3(db, rows) {
-  const insert = db.query(INSERT_CHANGE);
-  const insertAll = db.transaction(() => rows.reduce((appended2, values) => appended2 + insert.run(...values).changes, 0));
-  return insertAll.immediate();
-}
-function writeChanges(repoRoot, write, seams = {}) {
-  checkDispatch("changes", write.dispatch, null);
-  const path3 = sqliteStorePath(repoRoot);
-  const rejected = [];
-  const stored = [];
-  for (const [index, change] of write.changes.entries()) {
-    const rejection = rejectionOf2(change, index);
-    if (rejection === null)
-      stored.push(change);
-    else
-      rejected.push(rejection);
+  const { reason, text, block } = absence;
+  if (!REPORT_ABSENCE_REASONS.includes(reason)) {
+    const expected2 = REPORT_ABSENCE_REASONS.join(", ");
+    throw refusedWrite7(`has reason ${describeValue3(reason)}, not one of ${expected2}`);
+  }
+  if (typeof text !== "string") {
+    throw refusedWrite7(`has detail ${describeValue3(text)}, not a string`);
+  }
+  const detailProblem = textProblem(text);
+  if (detailProblem !== null)
+    throw refusedWrite7(`has a detail that ${detailProblem}`);
+  if (block === null)
+    return;
+  if (typeof block.body !== "string") {
+    throw refusedWrite7(`has block body ${describeValue3(block.body)}, not a string`);
+  }
+  if (LONE_SURROGATE.test(block.body)) {
+    throw refusedWrite7("has a block body holding a lone UTF-16 surrogate");
   }
-  const collectedAt = (seams.now ?? (() => new Date))().toISOString();
-  const newId = seams.newId ?? randomUUID5;
-  const rows = stored.map((change) => rowValues2(change, write.dispatch, newId(), collectedAt));
-  const appended2 = writeSqliteStore(path3, rows.length, 0, (db) => insertRows3(db, rows));
-  return { path: path3, appended: appended2, skipped: stored.length - appended2, rejected };
 }
-var SELECT_PLAN_CHANGES = `
-  SELECT session_id, task_line, level, area, summary, collected_at
-  FROM changes
-  WHERE plan_stub IS ?
-  ORDER BY seq
-`;
-function readPlanChanges(repoRoot, planStub2) {
+function writeReportAbsence(repoRoot, write, seams = {}) {
+  checkDispatch("report absence", write.dispatch, write.outcome);
+  checkAbsence(write.absence);
   const path3 = sqliteStorePath(repoRoot);
-  if (!existsSync20(path3))
-    return [];
-  const rows = withSqliteStore(path3, false, (db) => db.query(SELECT_PLAN_CHANGES).all(planStub2));
-  return rows.map((row) => ({
-    sessionId: row.session_id,
-    taskLine: row.task_line,
-    level: row.level,
-    area: row.area,
-    summary: row.summary,
-    collectedAt: row.collected_at
-  }));
+  const { sessionId, planStub: planStub2, taskLine } = write.dispatch;
+  const { reason, text, block } = write.absence;
+  const collectedAt = (seams.now ?? (() => new Date))().toISOString();
+  const id2 = (seams.newId ?? randomUUID5)();
+  const values = [
+    id2,
+    sessionId,
+    planStub2,
+    taskLine,
+    reason,
+    text,
+    block?.body ?? null,
+    write.outcome,
+    collectedAt
+  ];
+  const appended2 = withSqliteStore(path3, !existsSync21(path3), (db) => db.query(INSERT_ABSENCE).run(...values).changes);
+  return { path: path3, appended: appended2, skipped: 1 - appended2 };
 }
 
 // src/effort/store/triage.ts
@@ -14416,8 +15437,8 @@ function renderLessonsSection(lessons) {
 }
 
 // src/utils/progress.ts
-import { existsSync as existsSync21, writeFileSync as writeFileSync10 } from "fs";
-import { join as join17 } from "path";
+import { existsSync as existsSync22, writeFileSync as writeFileSync11 } from "fs";
+import { join as join18 } from "path";
 var PROGRESS_FILE_NAME = "progress.txt";
 var PROGRESS_CAP_BYTES = 16000;
 var LISTED_FIELDS = [
@@ -14459,7 +15480,7 @@ var ESCAPED_CODE_POINTS = new Set([
   8233
 ]);
 function progressFilePath(repoRoot) {
-  return join17(repoRoot, PROGRESS_FILE_NAME);
+  return join18(repoRoot, PROGRESS_FILE_NAME);
 }
 function escapeValue(value) {
   let escaped = "";
@@ -14520,7 +15541,7 @@ function renderProgressText(findings, capBytes = PROGRESS_CAP_BYTES) {
 }
 function readProgressFindings(repoRoot, planStub2) {
   const path3 = sqliteStorePath(repoRoot);
-  if (!existsSync21(path3))
+  if (!existsSync22(path3))
     return [];
   const rows = withSqliteStore(path3, false, (db) => {
     const query = db.query(SELECT_FINDINGS2);
@@ -14541,12 +15562,12 @@ function readProgressFindings(repoRoot, planStub2) {
 function writeProgress(repoRoot, planStub2) {
   const render = renderProgressText(readProgressFindings(repoRoot, planStub2));
   const path3 = progressFilePath(repoRoot);
-  writeFileSync10(path3, render.text, "utf8");
+  writeFileSync11(path3, render.text, "utf8");
   return { ...render, path: path3, storePath: sqliteStorePath(repoRoot) };
 }
 
 // src/inventory/search/rank.ts
-import { readFileSync as readFileSync22 } from "fs";
+import { readFileSync as readFileSync24 } from "fs";
 var SEARCH_LIMIT = 12;
 var MIN_WORD_LENGTH = 2;
 var MIN_PREFIX_LENGTH = 4;
@@ -14668,7 +15689,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) => readFileSync22(path3, "utf8")) {
+function readRankCandidate(record, read = (path3) => readFileSync24(path3, "utf8")) {
   let text;
   try {
     text = read(record.path);
@@ -14897,16 +15918,16 @@ async function handOut(handout, task, resolution, repoRoot) {
 
 // src/start/preflight.ts
 import { randomUUID as randomUUID7 } from "crypto";
-import { existsSync as existsSync22, readFileSync as readFileSync24 } from "fs";
+import { existsSync as existsSync23, readFileSync as readFileSync26 } from "fs";
 import { homedir as homedir4 } from "os";
 import { basename as basename7 } from "path";
 
 // src/preflight/first-dispatch.ts
-import { readFileSync as readFileSync23 } from "fs";
+import { readFileSync as readFileSync25 } from "fs";
 var TICKED_TASK = /^- \[[xX]\] (.+)/;
 function readIfReadable(path3) {
   try {
-    return readFileSync23(path3, "utf8");
+    return readFileSync25(path3, "utf8");
   } catch {
     return null;
   }
@@ -14939,11 +15960,11 @@ function knownMissingNotice(lines) {
 }
 function agentSourcePath(planPath) {
   const tracker = trackerPathFor(planPath);
-  return existsSync22(tracker) ? tracker : planPath;
+  return existsSync23(tracker) ? tracker : planPath;
 }
 function readIfReadable2(path3) {
   try {
-    return readFileSync24(path3, "utf8");
+    return readFileSync26(path3, "utf8");
   } catch {
     return null;
   }
@@ -15332,14 +16353,14 @@ async function holdWhilePaused(options) {
 }
 
 // src/start/plan-path.ts
-import { existsSync as existsSync23 } from "fs";
+import { existsSync as existsSync24 } from "fs";
 import { resolve as resolve11 } from "path";
 var DEFAULT_PLAN_FILE = "PLAN.md";
 function resolvePlanPath(repoRoot, planDir, planArg) {
   if (planArg)
     return resolve11(repoRoot, planArg);
   const inPlanDir = resolve11(repoRoot, planDir, DEFAULT_PLAN_FILE);
-  return existsSync23(inPlanDir) ? inPlanDir : resolve11(repoRoot, DEFAULT_PLAN_FILE);
+  return existsSync24(inPlanDir) ? inPlanDir : resolve11(repoRoot, DEFAULT_PLAN_FILE);
 }
 
 // src/utils/git.ts
@@ -15462,250 +16483,68 @@ function pollChecks(io, prNumber, timeoutMs) {
     now: io.now,
     sleep: io.sleep,
     onPoll: (rows, verdict, elapsedMs) => {
-      const secs = Math.round(elapsedMs / 1000);
-      activeOutput().info(`   [${secs}s] ${verdict} \u2014 ${rows.length} check(s)`);
-    }
-  });
-}
-function reportSettledVerdict(prNumber, result) {
-  if (result.verdict === "green") {
-    activeOutput().info(`
-\u2705 CI green on PR #${prNumber}:`);
-    activeOutput().info(formatRows(result.rows));
-    return true;
-  }
-  if (result.verdict === "timeout") {
-    activeOutput().warn(`
-\u26A0\uFE0F  CI still running after ${Math.round(result.elapsedMs / 1000)}s. Not waiting further.`);
-    activeOutput().warn(formatRows(result.rows));
-    activeOutput().warn(`   Check it yourself: gh pr checks ${prNumber}`);
-    return true;
-  }
-  return false;
-}
-async function handleNoChecks(io, branch, prNumber, merge) {
-  if (merge?.state === "merged") {
-    activeOutput().info(`
-\u2705 PR #${prNumber} is already merged.`);
-    return "stop";
-  }
-  if (merge !== null && merge.mergeStateStatus !== "DIRTY") {
-    activeOutput().warn(`
-\u26A0\uFE0F  PR #${prNumber} reports no checks and is not conflicting`);
-    activeOutput().warn(`   (GitHub says it is ${merge.mergeable}, merge state ${merge.mergeStateStatus}).`);
-    activeOutput().warn("   Most likely no workflow matches the changed paths. Nothing to repair.");
-    return "stop";
-  }
-  activeOutput().warn(`
-\u274C PR #${prNumber} has no checks \u2014 it does not merge cleanly, so GitHub scheduled no run.`);
-  const exitCode = await repairPullRequest(prNumber, branch, "it conflicts with the base branch, so GitHub scheduled no CI run at all.", "Merge `origin/main` into this branch and resolve the conflicts, then push. Mechanical conflicts (versions, lockfiles, complementary additions) are yours to resolve; a genuine semantic conflict is not.", io.runRepair);
-  if (exitCode !== 0) {
-    activeOutput().error(`
-\u274C Conflict-repair session failed (exit ${exitCode}).`);
-    return "stop";
-  }
-  return "next";
-}
-async function handleRedChecks(io, branch, prNumber, rows) {
-  activeOutput().warn(`
-\u274C CI red on PR #${prNumber}:`);
-  activeOutput().warn(formatRows(rows));
-  const failed3 = failingRows(rows);
-  const exitCode = await repairPullRequest(prNumber, branch, "its CI checks failed.", ["The failing checks are:", formatRows(failed3)].join(`
-`), io.runRepair);
-  if (exitCode !== 0) {
-    activeOutput().error(`
-\u274C CI-repair session failed (exit ${exitCode}).`);
-    return "stop";
-  }
-  return "next";
-}
-
-// src/release/prepare.ts
-import { readFileSync as readFileSync26, writeFileSync as writeFileSync12 } from "fs";
-
-// src/release/changelog.ts
-var RELEASE_HEADING_FIELDS = ["version", "date", "title"];
-var PLACEHOLDER = /\{([A-Za-z]+)\}/g;
-var WHITESPACE = /\s+/g;
-var ATX_HEADING = /^ {0,3}#{1,6}(?: |$)/;
-var CODE_FENCE = /^ {0,3}(?:```|~~~)/;
-var SEPARATORS = "\u2014\u2013-,;:\xB7|";
-function isSeparator(character) {
-  return character.trim() === "" || SEPARATORS.includes(character);
-}
-function trimTrailingSeparators(text) {
-  let end = text.length;
-  while (end > 0 && isSeparator(text[end - 1] ?? ""))
-    end -= 1;
-  return text.slice(0, end);
-}
-function trimLeadingSeparators(text) {
-  let start = 0;
-  while (start < text.length && isSeparator(text[start] ?? ""))
-    start += 1;
-  return text.slice(start);
-}
-function isHeadingField(field5) {
-  return RELEASE_HEADING_FIELDS.includes(field5);
-}
-function renderReleaseHeading(template, values) {
-  let rendered = "";
-  let afterGap = false;
-  const add = (text) => {
-    if (!afterGap) {
-      rendered += text;
-      return;
-    }
-    const kept = trimLeadingSeparators(text);
-    if (kept === "")
-      return;
-    afterGap = false;
-    rendered += kept;
-  };
-  let cursor = 0;
-  for (const found of template.matchAll(PLACEHOLDER)) {
-    const before = template.slice(cursor, found.index);
-    cursor = found.index + found[0].length;
-    const name2 = found[1] ?? "";
-    if (!isHeadingField(name2)) {
-      add(`${before}${found[0]}`);
-      continue;
-    }
-    const value = values[name2].trim();
-    if (value !== "") {
-      add(before);
-      add(value);
-      continue;
-    }
-    add(before);
-    rendered = `${trimTrailingSeparators(rendered)} `;
-    afterGap = true;
-  }
-  add(template.slice(cursor));
-  return rendered.replace(WHITESPACE, " ").trim();
-}
-function areaOf(note) {
-  const area = note.area?.trim() ?? "";
-  return area === "" ? null : area;
-}
-function groupChangeNotes(notes) {
-  const named = new Map;
-  const unnamed = [];
-  const seen = new Set;
-  let noneNotes = 0;
-  let duplicateNotes = 0;
-  let blankNotes = 0;
-  for (const note of notes) {
-    if (note.level === "none") {
-      noneNotes += 1;
-      continue;
-    }
-    const area = areaOf(note);
-    const summary = note.summary.replace(WHITESPACE, " ").trim();
-    if (summary === "") {
-      blankNotes += 1;
-      continue;
-    }
-    const key = `${area ?? ""}
-${summary}`;
-    if (seen.has(key)) {
-      duplicateNotes += 1;
-      continue;
-    }
-    seen.add(key);
-    if (area === null) {
-      unnamed.push(summary);
-      continue;
-    }
-    const summaries = named.get(area);
-    if (summaries === undefined)
-      named.set(area, [summary]);
-    else
-      summaries.push(summary);
-  }
-  const groups = [...named].map(([area, summaries]) => ({ area, summaries }));
-  return {
-    groups: unnamed.length === 0 ? groups : [...groups, { area: null, summaries: unnamed }],
-    noneNotes,
-    duplicateNotes,
-    blankNotes
-  };
-}
-function renderNoteLines(grouping) {
-  return grouping.groups.flatMap((group) => group.summaries.map((summary) => group.area === null ? `- ${summary}` : `- ${group.area}: ${summary}`));
-}
-function renderChangelogEntry(input) {
-  const heading = renderReleaseHeading(input.template, input.values);
-  const grouping = groupChangeNotes(input.notes);
-  const lines = renderNoteLines(grouping);
-  return {
-    heading,
-    lines,
-    groups: grouping.groups,
-    text: lines.length === 0 ? heading : `${heading}
-
-${lines.join(`
-`)}`,
-    noneNotes: grouping.noneNotes,
-    duplicateNotes: grouping.duplicateNotes,
-    blankNotes: grouping.blankNotes
-  };
-}
-function findHeading(lines, from) {
-  let fenced = false;
-  for (let index = 0;index < lines.length; index += 1) {
-    const line = lines[index] ?? "";
-    if (CODE_FENCE.test(line)) {
-      fenced = !fenced;
-      continue;
+      const secs = Math.round(elapsedMs / 1000);
+      activeOutput().info(`   [${secs}s] ${verdict} \u2014 ${rows.length} check(s)`);
     }
-    if (fenced || index < from)
-      continue;
-    if (ATX_HEADING.test(line))
-      return index;
-  }
-  return null;
-}
-function endOfContent(lines) {
-  let end = lines.length;
-  while (end > 0 && (lines[end - 1] ?? "").trim() === "")
-    end -= 1;
-  return end;
+  });
 }
-function insertPoint(lines) {
-  const first = findHeading(lines, 0);
-  if (first === null)
-    return { at: 0, point: "file-top" };
-  const next = findHeading(lines, first + 1);
-  if (next !== null)
-    return { at: next, point: "before-next-heading" };
-  return { at: endOfContent(lines), point: "file-end" };
+function reportSettledVerdict(prNumber, result) {
+  if (result.verdict === "green") {
+    activeOutput().info(`
+\u2705 CI green on PR #${prNumber}:`);
+    activeOutput().info(formatRows(result.rows));
+    return true;
+  }
+  if (result.verdict === "timeout") {
+    activeOutput().warn(`
+\u26A0\uFE0F  CI still running after ${Math.round(result.elapsedMs / 1000)}s. Not waiting further.`);
+    activeOutput().warn(formatRows(result.rows));
+    activeOutput().warn(`   Check it yourself: gh pr checks ${prNumber}`);
+    return true;
+  }
+  return false;
 }
-function insertChangelogEntry(changelog, entry) {
-  const lines = changelog.split(`
-`);
-  const { at, point } = insertPoint(lines);
-  const entryLines = entry.split(`
-`);
-  const before = at === 0 || (lines[at - 1] ?? "").trim() === "" ? [] : [""];
-  const after = at >= lines.length || (lines[at] ?? "").trim() === "" ? [] : [""];
-  const inserted = [
-    ...lines.slice(0, at),
-    ...before,
-    ...entryLines,
-    ...after,
-    ...lines.slice(at)
-  ];
-  return { text: inserted.join(`
-`), point, line: at + before.length + 1 };
+async function handleNoChecks(io, branch, prNumber, merge) {
+  if (merge?.state === "merged") {
+    activeOutput().info(`
+\u2705 PR #${prNumber} is already merged.`);
+    return "stop";
+  }
+  if (merge !== null && merge.mergeStateStatus !== "DIRTY") {
+    activeOutput().warn(`
+\u26A0\uFE0F  PR #${prNumber} reports no checks and is not conflicting`);
+    activeOutput().warn(`   (GitHub says it is ${merge.mergeable}, merge state ${merge.mergeStateStatus}).`);
+    activeOutput().warn("   Most likely no workflow matches the changed paths. Nothing to repair.");
+    return "stop";
+  }
+  activeOutput().warn(`
+\u274C PR #${prNumber} has no checks \u2014 it does not merge cleanly, so GitHub scheduled no run.`);
+  const exitCode = await repairPullRequest(prNumber, branch, "it conflicts with the base branch, so GitHub scheduled no CI run at all.", "Merge `origin/main` into this branch and resolve the conflicts, then push. Mechanical conflicts (versions, lockfiles, complementary additions) are yours to resolve; a genuine semantic conflict is not.", io.runRepair);
+  if (exitCode !== 0) {
+    activeOutput().error(`
+\u274C Conflict-repair session failed (exit ${exitCode}).`);
+    return "stop";
+  }
+  return "next";
 }
-function changelogDate(now) {
-  const month = `${now.getMonth() + 1}`.padStart(2, "0");
-  const day = `${now.getDate()}`.padStart(2, "0");
-  return `${now.getFullYear()}-${month}-${day}`;
+async function handleRedChecks(io, branch, prNumber, rows) {
+  activeOutput().warn(`
+\u274C CI red on PR #${prNumber}:`);
+  activeOutput().warn(formatRows(rows));
+  const failed3 = failingRows(rows);
+  const exitCode = await repairPullRequest(prNumber, branch, "its CI checks failed.", ["The failing checks are:", formatRows(failed3)].join(`
+`), io.runRepair);
+  if (exitCode !== 0) {
+    activeOutput().error(`
+\u274C CI-repair session failed (exit ${exitCode}).`);
+    return "stop";
+  }
+  return "next";
 }
 
+// src/release/prepare.ts
+import { readFileSync as readFileSync27, writeFileSync as writeFileSync12 } from "fs";
+
 // src/release/enabled.ts
 import { statSync as statSync11 } from "fs";
 import { resolve as resolve12 } from "path";
@@ -15734,165 +16573,6 @@ function resolveReleaseEnabled(settings, repoRoot) {
   return { enabled: settings.releaseEnabled, source: "config", versionFile, changelog };
 }
 
-// src/release/level.ts
-var RELEASE_LEVEL_RANK = {
-  none: 0,
-  patch: 1,
-  minor: 2,
-  major: 3
-};
-function highestChangeLevel(notes) {
-  return notes.reduce((highest, note) => highest === null || RELEASE_LEVEL_RANK[note.level] > RELEASE_LEVEL_RANK[highest] ? note.level : highest, null);
-}
-function resolveReleaseLevel(declared, notes) {
-  const notesLevel = highestChangeLevel(notes);
-  if (declared !== null)
-    return { level: declared, source: "plan", notesLevel };
-  if (notesLevel !== null)
-    return { level: notesLevel, source: "notes", notesLevel };
-  return { level: "none", source: "default", notesLevel };
-}
-
-// src/release/version.ts
-import { readFileSync as readFileSync25, writeFileSync as writeFileSync11 } 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.-]+))?$/;
-function parseSemanticVersion(raw) {
-  const found = VERSION_SHAPE.exec(raw);
-  if (found === null)
-    return null;
-  return {
-    major: Number(found[1]),
-    minor: Number(found[2]),
-    patch: Number(found[3]),
-    prerelease: found[4] ?? "",
-    build: found[5] ?? ""
-  };
-}
-function formatSemanticVersion(version2) {
-  const prerelease = version2.prerelease === "" ? "" : `-${version2.prerelease}`;
-  const build = version2.build === "" ? "" : `+${version2.build}`;
-  return `${version2.major}.${version2.minor}.${version2.patch}${prerelease}${build}`;
-}
-function bumped(version2, level) {
-  const onPrerelease = version2.prerelease !== "";
-  const blank = { prerelease: "", build: "" };
-  if (level === "major") {
-    const stays = onPrerelease && version2.minor === 0 && version2.patch === 0;
-    const major = stays ? version2.major : version2.major + 1;
-    return { major, minor: 0, patch: 0, ...blank };
-  }
-  if (level === "minor") {
-    const stays = onPrerelease && version2.patch === 0;
-    const minor = stays ? version2.minor : version2.minor + 1;
-    return { major: version2.major, minor, patch: 0, ...blank };
-  }
-  const patch = onPrerelease ? version2.patch : version2.patch + 1;
-  return { major: version2.major, minor: version2.minor, patch, ...blank };
-}
-function nextVersion(base, level) {
-  const parsed = parseSemanticVersion(base);
-  if (parsed === null)
-    return null;
-  if (level === "none")
-    return formatSemanticVersion(parsed);
-  return formatSemanticVersion(bumped(parsed, level));
-}
-function manifestFields(text) {
-  let parsed;
-  try {
-    parsed = JSON.parse(text);
-  } catch {
-    return null;
-  }
-  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
-    return null;
-  return parsed;
-}
-function readManifestVersion(text) {
-  const fields = manifestFields(text);
-  if (fields === null)
-    return null;
-  const value = fields["version"];
-  if (typeof value !== "string")
-    return null;
-  const trimmed = value.trim();
-  return trimmed === "" ? null : trimmed;
-}
-var VERSION_PAIR = /("version"\s*:\s*)"(?:[^"\\]|\\.)*"/g;
-function sameBesidesVersion(before, after) {
-  const restored = { ...after, version: before["version"] };
-  return JSON.stringify(restored) === JSON.stringify(before);
-}
-function replaceManifestVersion(text, next) {
-  const previous = readManifestVersion(text);
-  const before = manifestFields(text);
-  if (previous === null || before === null)
-    return null;
-  for (const pair of text.matchAll(VERSION_PAIR)) {
-    const start = pair.index;
-    const candidate = `${text.slice(0, start)}${pair[1]}${JSON.stringify(next)}${text.slice(start + pair[0].length)}`;
-    const after = manifestFields(candidate);
-    if (after === null || after["version"] !== next)
-      continue;
-    if (!sameBesidesVersion(before, after))
-      continue;
-    return { text: candidate, previous };
-  }
-  return null;
-}
-function writeManifestVersion(path3, next) {
-  const unwritten = { path: path3, written: false, previous: null, version: next };
-  let text;
-  try {
-    text = readFileSync25(path3, "utf8");
-  } catch (error) {
-    return { ...unwritten, problem: `${path3} could not be read: ${messageOf(error)}` };
-  }
-  const rewritten = replaceManifestVersion(text, next);
-  if (rewritten === null) {
-    const previous = readManifestVersion(text);
-    return {
-      ...unwritten,
-      previous,
-      problem: previous === null ? `${path3} declares no version to write ${next} over` : `${path3} declares ${previous}, and the pair holding it could not be rewritten`
-    };
-  }
-  try {
-    writeFileSync11(path3, rewritten.text);
-  } catch (error) {
-    return { ...unwritten, previous: rewritten.previous, problem: `${path3} could not be written: ${messageOf(error)}` };
-  }
-  return { path: path3, written: true, previous: rewritten.previous, version: next, problem: null };
-}
-function gitPathOf(versionFile) {
-  let path3 = versionFile;
-  while (path3.startsWith("./"))
-    path3 = path3.slice(2);
-  return path3;
-}
-function readBaseVersion(git, versionFile, options = {}) {
-  const remote = options.remote ?? RELEASE_REMOTE;
-  const branch = options.branch ?? RELEASE_BASE_BRANCH;
-  const ref = `${remote}/${branch}`;
-  const path3 = gitPathOf(versionFile);
-  const problems = [];
-  const fetched = git(["fetch", remote, branch]);
-  if (!fetched.ok) {
-    problems.push(`${branch} could not be fetched from ${remote}, so the base version is whatever this clone already holds for ${ref}: ${gitSaid(fetched)}`);
-  }
-  const shown = git(["show", `${ref}:${path3}`]);
-  if (!shown.ok) {
-    problems.push(`${ref}:${path3} could not be read: ${gitSaid(shown)}`);
-    return { ref, path: path3, version: null, fetched: fetched.ok, problems };
-  }
-  const version2 = readManifestVersion(shown.stdout);
-  if (version2 === null)
-    problems.push(`${ref}:${path3} declares no version`);
-  return { ref, path: path3, version: version2, fetched: fetched.ok, problems };
-}
-
 // src/release/prepare.ts
 function levelFields(reading2) {
   return { level: reading2.level, levelSource: reading2.source, notesLevel: reading2.notesLevel };
@@ -15947,9 +16627,9 @@ function planVersion(input, versionFile, level) {
   }
   return { refused: false, version: version2, baseVersion: base.version, fetched: base.fetched, problems: base.problems };
 }
-function textOf(path3) {
+function textOf2(path3) {
   try {
-    return readFileSync26(path3, "utf8");
+    return readFileSync27(path3, "utf8");
   } catch {
     return null;
   }
@@ -15963,14 +16643,14 @@ function writeText(path3, text) {
   }
 }
 function writeVersionFile(file, version2) {
-  const before = textOf(file.resolved);
+  const before = textOf2(file.resolved);
   if (before === null) {
     return { edit: null, problem: `${file.path} could not be read, so ${version2} was not written to it` };
   }
   const written = writeManifestVersion(file.resolved, version2);
   if (written.problem !== null)
     return { edit: null, problem: written.problem };
-  const after = textOf(file.resolved);
+  const after = textOf2(file.resolved);
   if (after === null) {
     return { edit: null, problem: `${file.path} could not be read back after ${version2} was written to it` };
   }
@@ -16011,7 +16691,7 @@ function prepareRelease(input) {
   if (!files.changelog.present) {
     return skip("changelog-missing", `no version bump and no changelog entry: ${files.changelog.path} is not there`, reading2);
   }
-  const changelogBefore = textOf(files.changelog.resolved);
+  const changelogBefore = textOf2(files.changelog.resolved);
   if (changelogBefore === null) {
     return skip("changelog-unreadable", `no version bump and no changelog entry: ${files.changelog.path} could not be read`, reading2);
   }
@@ -16062,7 +16742,7 @@ function changelogFailure(failed3, versionEdit, restored) {
 }
 
 // src/release/verify.ts
-import { readFileSync as readFileSync27, writeFileSync as writeFileSync13 } from "fs";
+import { readFileSync as readFileSync28, writeFileSync as writeFileSync13 } from "fs";
 function changelogInsertionSpan(before, after) {
   const beforeLines = before.split(`
 `);
@@ -16077,9 +16757,9 @@ function changelogInsertionSpan(before, after) {
     suffix += 1;
   return { prefix, suffix, inserted: afterLines.slice(prefix, afterLines.length - suffix) };
 }
-function textOf2(path3) {
+function textOf3(path3) {
   try {
-    return readFileSync27(path3, "utf8");
+    return readFileSync28(path3, "utf8");
   } catch {
     return null;
   }
@@ -16147,7 +16827,7 @@ function checkVersion(prepared) {
   const file = prepared.versionFile;
   if (file === null)
     return null;
-  const text = textOf2(file.resolved);
+  const text = textOf3(file.resolved);
   if (text === null) {
     return { reason: "version-unreadable", because: `${file.path} could not be read back after the wrap-up session` };
   }
@@ -16165,7 +16845,7 @@ function checkVersion(prepared) {
 }
 function verifyRelease(prepared) {
   const changelog = prepared.changelog;
-  const current = textOf2(changelog.resolved);
+  const current = textOf3(changelog.resolved);
   if (current === null) {
     return refuse5(prepared, "changelog-unreadable", `${changelog.path} could not be read back after the wrap-up session`);
   }
@@ -16414,11 +17094,11 @@ async function finishRelease(input, seams = {}) {
 }
 
 // src/start/risk-total.ts
-import { readFileSync as readFileSync29 } from "fs";
+import { readFileSync as readFileSync30 } from "fs";
 
 // src/plan/risk.ts
-import { readFileSync as readFileSync28 } from "fs";
-import { isAbsolute as isAbsolute4, join as join18, relative as relative4 } from "path";
+import { readFileSync as readFileSync29 } from "fs";
+import { isAbsolute as isAbsolute4, join as join19, relative as relative4 } from "path";
 
 // src/plan/risk/accounts.ts
 var PUSH_REMOTE = "origin";
@@ -16960,7 +17640,7 @@ function toolsFinding(task, plan, seams) {
   return null;
 }
 function displayPath(path3, seams) {
-  const absolute = isAbsolute4(path3) ? path3 : join18(seams.repoRoot, path3);
+  const absolute = isAbsolute4(path3) ? path3 : join19(seams.repoRoot, path3);
   const within = (root) => {
     const step = relative4(root, absolute);
     return step === "" || step.startsWith("..") || isAbsolute4(step) ? null : step;
@@ -16977,7 +17657,7 @@ function located(finding2, file, task) {
 }
 function readText5(path3) {
   try {
-    return readFileSync28(path3, "utf8");
+    return readFileSync29(path3, "utf8");
   } catch {
     return null;
   }
@@ -16985,7 +17665,7 @@ function readText5(path3) {
 function findSkillFile(name2, seams) {
   const tiers = resolveSkillTiers({ home: seams.home, projectRoot: seams.repoRoot, entry: seams.entry });
   for (const { dir } of tiers) {
-    const path3 = join18(dir, name2, "SKILL.md");
+    const path3 = join19(dir, name2, "SKILL.md");
     if (readText5(path3) !== null)
       return path3;
   }
@@ -17079,7 +17759,7 @@ function spawningRunners(root) {
 }
 async function readRiskTotalLine(input, seams = {}) {
   const makeRunners = seams.runners ?? spawningRunners;
-  const report2 = await assessPlanRisk({ path: input.planPath, text: readFileSync29(input.planPath, "utf8") }, {
+  const report2 = await assessPlanRisk({ path: input.planPath, text: readFileSync30(input.planPath, "utf8") }, {
     repoRoot: input.repoRoot,
     home: input.home,
     settingSources: input.config.settingSources,
@@ -17255,11 +17935,11 @@ function announcePlanIssues(planContent) {
 }
 
 // src/start/runtime.ts
-import { existsSync as existsSync24, readdirSync as readdirSync10, realpathSync as realpathSync3, statSync as statSync12 } from "fs";
+import { existsSync as existsSync25, readdirSync as readdirSync11, realpathSync as realpathSync3, statSync as statSync12 } from "fs";
 import { homedir as homedir5 } from "os";
-import { isAbsolute as isAbsolute5, join as join19, relative as relative6, resolve as resolve13, sep } from "path";
+import { isAbsolute as isAbsolute5, join as join20, relative as relative6, resolve as resolve13, sep } from "path";
 var RUNTIME_FLAG = "--runtime";
-var RUNTIME_SUBDIR = join19(".rafa", "runtime");
+var RUNTIME_SUBDIR = join20(".rafa", "runtime");
 var RUNTIME_ENTRY = "cli.js";
 var SOURCE_DIR = "src";
 var RUNTIME_COMMAND = ["start"];
@@ -17286,7 +17966,7 @@ function resolveRuntime(value, places) {
     throw refusal3([`\u274C Refusing to start: \`--runtime\` names no runtime. Spell it ${SPELLING}.`]);
   }
   const isVersion = VERSION_SHAPE2.test(value);
-  const named = isVersion ? join19(places.home, RUNTIME_SUBDIR, value, RUNTIME_ENTRY) : resolve13(places.cwd, value);
+  const named = isVersion ? join20(places.home, RUNTIME_SUBDIR, value, RUNTIME_ENTRY) : resolve13(places.cwd, value);
   refuseInsideSource(value, named, places);
   const entry = entryOf2(value, named, isVersion, places.home);
   const real = realpathSync3(entry);
@@ -17297,7 +17977,7 @@ function entryOf2(value, named, isVersion, home) {
   if (isVersion) {
     if (isFile2(named))
       return named;
-    const root = join19(home, RUNTIME_SUBDIR);
+    const root = join20(home, RUNTIME_SUBDIR);
     const installed = installedVersions(root);
     throw refusal3([
       `\u274C Refusing to start: \`--runtime=${value}\` names no installed runtime: ${named} is no file.`,
@@ -17306,7 +17986,7 @@ function entryOf2(value, named, isVersion, home) {
   }
   if (isFile2(named))
     return named;
-  const inside = join19(named, RUNTIME_ENTRY);
+  const inside = join20(named, RUNTIME_ENTRY);
   if (isDirectory(named) && isFile2(inside))
     return inside;
   throw refusal3([
@@ -17324,8 +18004,8 @@ function refuseInsideSource(value, path3, places) {
   ]);
 }
 function sourceDirs({ cwd, root }) {
-  const dirs = [join19(cwd, SOURCE_DIR), join19(root, SOURCE_DIR)];
-  const real = dirs.filter((dir) => existsSync24(dir)).map((dir) => realpathSync3(dir));
+  const dirs = [join20(cwd, SOURCE_DIR), join20(root, SOURCE_DIR)];
+  const real = dirs.filter((dir) => existsSync25(dir)).map((dir) => realpathSync3(dir));
   return [...new Set([...dirs, ...real])];
 }
 function isInside2(path3, dir) {
@@ -17334,7 +18014,7 @@ function isInside2(path3, dir) {
 }
 function installedVersions(root) {
   try {
-    return readdirSync10(root).filter((name2) => isFile2(join19(root, name2, RUNTIME_ENTRY))).sort((a, b) => a.localeCompare(b));
+    return readdirSync11(root).filter((name2) => isFile2(join20(root, name2, RUNTIME_ENTRY))).sort((a, b) => a.localeCompare(b));
   } catch {
     return [];
   }
@@ -17465,11 +18145,11 @@ function eventOf(line) {
 }
 
 // src/triage/triage.ts
-import { basename as basename8, join as join20 } from "path";
+import { basename as basename8, join as join21 } from "path";
 
 // src/effort/store/tracker-refs.ts
 import { randomUUID as randomUUID10 } from "crypto";
-import { existsSync as existsSync25 } from "fs";
+import { existsSync as existsSync26 } from "fs";
 var SELECT_HELD2 = `
   SELECT seq, tracker_ref FROM findings
   WHERE session_id = ? AND artifact = ?
@@ -17535,17 +18215,17 @@ function storedRefOf(value) {
     if (problem !== null)
       return `whose ${field5} ${problem}`;
   }
-  const ref = {
+  const ref3 = {
     opt: fields.opt,
     kind: fields.kind,
     externalId: fields.externalId,
     url: fields.url
   };
   if (typeof fields.module === "string")
-    ref.module = fields.module;
+    ref3.module = fields.module;
   if (typeof fields.repo === "string")
-    ref.repo = fields.repo;
-  return { ref, json: JSON.stringify(ref) };
+    ref3.repo = fields.repo;
+  return { ref: ref3, json: JSON.stringify(ref3) };
 }
 function heldRefOf(path3, seq, text) {
   let parsed;
@@ -17592,7 +18272,7 @@ function writeTrackerRef(repoRoot, write, seams = {}) {
     wanted.json,
     collectedAt
   ];
-  const [action, stored] = withSqliteStore(path3, !existsSync25(path3), (db) => {
+  const [action, stored] = withSqliteStore(path3, !existsSync26(path3), (db) => {
     const place = db.transaction(() => placeRef(db, path3, write, wanted, insertValues));
     return place.immediate();
   });
@@ -17601,7 +18281,7 @@ function writeTrackerRef(repoRoot, write, seams = {}) {
 function readTrackerRef(repoRoot, artifact) {
   checkArtifact("read", artifact);
   const path3 = sqliteStorePath(repoRoot);
-  if (!existsSync25(path3))
+  if (!existsSync26(path3))
     return null;
   const oldest = withSqliteStore(path3, false, (db) => db.query(SELECT_OLDEST).get(artifact));
   return oldest === null ? null : heldRefOf(path3, oldest.seq, oldest.tracker_ref).ref;
@@ -17613,28 +18293,28 @@ var ARTIFACT_REF_KINDS = new Set(["path", "symbol"]);
 var UNREAD_STAMP = "unread";
 var REFS_INTRO = "The paths and symbols the artifact names, each with its target's" + " fingerprint when this bug was filed.";
 function artifactRefs(artifact) {
-  return extractRefs(artifact).filter((ref) => ARTIFACT_REF_KINDS.has(ref.kind));
+  return extractRefs(artifact).filter((ref3) => ARTIFACT_REF_KINDS.has(ref3.kind));
 }
 function stampWord(live) {
   return live.kind === "unreadable" ? UNREAD_STAMP : fingerprintText(live);
 }
 async function stampArtifactRefs(artifact, verify) {
   const stamps = [];
-  for (const ref of artifactRefs(artifact)) {
+  for (const ref3 of artifactRefs(artifact)) {
     let stamp;
     try {
-      stamp = stampWord(await verify({ kind: ref.kind, text: ref.text }));
+      stamp = stampWord(await verify({ kind: ref3.kind, text: ref3.text }));
     } catch {
       stamp = UNREAD_STAMP;
     }
-    stamps.push(Object.freeze({ kind: ref.kind, text: ref.text, stamp }));
+    stamps.push(Object.freeze({ kind: ref3.kind, text: ref3.text, stamp }));
   }
   return Object.freeze(stamps);
 }
 function refsSection(stamps) {
   if (stamps.length === 0)
     return null;
-  const lines = stamps.map((ref) => `- ${ref.kind} \`${ref.text}\`: \`${ref.stamp}\``);
+  const lines = stamps.map((ref3) => `- ${ref3.kind} \`${ref3.text}\`: \`${ref3.stamp}\``);
   return [`## ${REFS_HEADING}`, REFS_INTRO, lines.join(`
 `)].join(`
 
@@ -17657,19 +18337,19 @@ async function noIssues() {
 }
 function createArtifactRefsVerifier(repoRoot, env) {
   let made = null;
-  return async (ref) => {
+  return async (ref3) => {
     made ??= createRefVerifier({
       issues: noIssues,
       git: createGitRunner(repoRoot),
       outline: tsSymbolsOutliner({ cwd: repoRoot, env }),
       roster: EMPTY_ROSTER
     });
-    return made(ref);
+    return made(ref3);
   };
 }
 
 // src/triage/triage.ts
-var PRIVATE_TRIAGE_DIR = join20(".rafa", "triage", "private");
+var PRIVATE_TRIAGE_DIR = join21(".rafa", "triage", "private");
 var SECRET_ENV_NAMES = ["GITHUB_TOKEN", "ANTHROPIC_API_KEY", "LINEAR_API_KEY"];
 var TRIAGE_MODULE = "unassigned";
 var BLOCKER_SEPARATOR = "; ";
@@ -17680,7 +18360,7 @@ var MIN_FENCE_LENGTH = 3;
 var ISSUE_OPENING = "An out-of-scope bug a rafa task session reported. The loop filed it and" + " dispatches no task for it: a plan that wants it fixed declares a task.";
 var COMMENT_OPENING = "Reported again by a rafa task session.";
 function privateTriageDir(repoRoot) {
-  return join20(repoRoot, PRIVATE_TRIAGE_DIR);
+  return join21(repoRoot, PRIVATE_TRIAGE_DIR);
 }
 function createPrivateTriageTracker(repoRoot, options = {}) {
   return createLocalTracker({
@@ -17754,7 +18434,7 @@ function fenced(value) {
   return `${fence}
 ${body}${fence}`;
 }
-function issueTitle(redactedWhat) {
+function issueTitle2(redactedWhat) {
   const line = oneLine5(redactedWhat);
   const points = Array.from(line);
   if (points.length <= TITLE_MAX_LENGTH)
@@ -17799,7 +18479,7 @@ async function filingFor(what, bug, options, redact, verifyRefs) {
   return {
     draft: {
       opt: 0,
-      title: issueTitle(redact(what)),
+      title: issueTitle2(redact(what)),
       body: issueText(ISSUE_OPENING, values, redact),
       type: "bug",
       module: TRIAGE_MODULE,
@@ -17831,23 +18511,23 @@ function resultOf(run, action, fields = {}) {
     ...fields
   };
 }
-async function settle(run, action, ref, foundBy) {
+async function settle(run, action, ref3, foundBy) {
   const { store } = run.route;
   const { key } = run.filing;
   if (store === null || key === null)
-    return resultOf(run, action, { ref, foundBy });
-  const stored = await step(run, "storing the reference", () => store(key, ref));
-  return stored.ok ? resultOf(run, action, { ref, foundBy, stored: stored.value }) : resultOf(run, action, { ref, foundBy, problem: stored.problem });
+    return resultOf(run, action, { ref: ref3, foundBy });
+  const stored = await step(run, "storing the reference", () => store(key, ref3));
+  return stored.ok ? resultOf(run, action, { ref: ref3, foundBy, stored: stored.value }) : resultOf(run, action, { ref: ref3, foundBy, problem: stored.problem });
 }
 async function fileNew(run) {
   const created = await step(run, `the ${run.route.channel} tracker create`, () => run.route.tracker.create(run.filing.draft));
   return created.ok ? settle(run, "filed", created.value, null) : resultOf(run, "failed", { problem: created.problem });
 }
-async function commentOn(run, ref, foundBy) {
-  const commented = await step(run, `the ${run.route.channel} tracker comment`, () => run.route.tracker.comment(ref, run.filing.comment));
+async function commentOn(run, ref3, foundBy) {
+  const commented = await step(run, `the ${run.route.channel} tracker comment`, () => run.route.tracker.comment(ref3, run.filing.comment));
   if (!commented.ok)
-    return resultOf(run, "failed", { ref, foundBy, problem: commented.problem });
-  return foundBy === "store" ? resultOf(run, "commented", { ref, foundBy }) : settle(run, "commented", ref, foundBy);
+    return resultOf(run, "failed", { ref: ref3, foundBy, problem: commented.problem });
+  return foundBy === "store" ? resultOf(run, "commented", { ref: ref3, foundBy }) : settle(run, "commented", ref3, foundBy);
 }
 async function triageBug(run) {
   const { route, filing } = run;
@@ -17895,11 +18575,11 @@ async function triageReport(options) {
       channel: "public",
       tracker: options.tracker,
       readStored: (key) => readTrackerRef(repoRoot, key),
-      store: (key, ref) => writeTrackerRef(repoRoot, {
+      store: (key, ref3) => writeTrackerRef(repoRoot, {
         dispatch: options.dispatch,
         outcome: options.outcome,
         artifact: key,
-        ref
+        ref: ref3
       }, options.seams).action
     },
     private: { channel: "private", tracker: privateTracker, readStored: null, store: null }
@@ -17926,7 +18606,7 @@ async function triageReport(options) {
 // src/start/triage.ts
 var NOT_RESOLVED_REASON = "start triage: no public tracker is resolved for a report with no public bug";
 var LINE_PREFIX = "Triage: ";
-var INDENT4 = "   ";
+var INDENT5 = "   ";
 var FOUND_BY = {
   store: "its stored reference",
   find: "a tracker find"
@@ -17950,8 +18630,8 @@ function filesPublicly(bug) {
 function hasTriage(report2) {
   return blockerTextOf(report2.blockers) !== null || report2.outOfScopeBugs.length > 0;
 }
-function issueName2(ref) {
-  return ref.url ?? `${ref.kind} issue ${ref.externalId}`;
+function issueName2(ref3) {
+  return ref3.url ?? `${ref3.kind} issue ${ref3.externalId}`;
 }
 function bugLines(bug) {
   const name2 = `out_of_scope_bugs[${bug.index}]`;
@@ -17989,11 +18669,11 @@ async function resolvePublicTracker(options, redact) {
     });
     const passed2 = attempts.filter((attempt2) => !attempt2.ok).map((attempt2) => `\`${attempt2.kind}\``);
     const fallback = passed2.length === 0 ? "" : `, having passed over ${passed2.join(", ")}`;
-    activeOutput().info(`${INDENT4}${LINE_PREFIX}public bugs of this run go to the \`${tracker.kind}\` tracker${fallback}.`);
+    activeOutput().info(`${INDENT5}${LINE_PREFIX}public bugs of this run go to the \`${tracker.kind}\` tracker${fallback}.`);
     return tracker;
   } catch (error) {
     const reason = messageOf(error);
-    activeOutput().warn(`${INDENT4}${LINE_PREFIX}no tracker resolved, so no public bug of this run is filed: ${redact(reason)}`);
+    activeOutput().warn(`${INDENT5}${LINE_PREFIX}no tracker resolved, so no public bug of this run is filed: ${redact(reason)}`);
     return unresolvedTracker(options.config.trackerDefault, reason);
   }
 }
@@ -18031,16 +18711,16 @@ function createStartTriage(options) {
     });
     const { notes, warnings } = describeStartTriage(result);
     for (const note of notes)
-      activeOutput().info(`${INDENT4}${note}`);
+      activeOutput().info(`${INDENT5}${note}`);
     for (const warning of warnings)
-      activeOutput().warn(`${INDENT4}${warning}`);
+      activeOutput().warn(`${INDENT5}${warning}`);
     return result;
   };
   return async (input) => {
     try {
       return await triageTask(input);
     } catch (error) {
-      activeOutput().warn(`${INDENT4}${LINE_PREFIX}nothing more was triaged for this task: ${redact(messageOf(error))}`);
+      activeOutput().warn(`${INDENT5}${LINE_PREFIX}nothing more was triaged for this task: ${redact(messageOf(error))}`);
       return null;
     }
   };
@@ -19255,4 +19935,4 @@ async function plan(args, repoRoot, registry = CORE_ADAPTER_REGISTRY) {
   }
 }
 
-export { readConfigFile, loadConfig, planStubsFromFileNames, resolvePlanStub, SERVE_CLI_VERSION, SCOPE_DIR, INIT_COMMAND, DISK_FILE_SYSTEM, ScopeError, scopeAt, initHint, selfAndAncestors, resolveScope, SessionRecordError, runsDir, errorCode, readSessions, readSession, PROVENANCE_FIELD, SKILL_FILE2 as SKILL_FILE, provenanceBlock, serveVerdict, SKILL_USE_CLI_VERSION, sessionLogDir, 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, verdictOf, failingRows, formatRows, waitForChecks, recordPlanCi, report, name, version, MANIFEST_VERSION, FEATURE_TYPES, OUTPUT_CHANNELS, RUNNING_MANIFEST_SEAMS, validateManifest, SPEC_EXTENSION, boardId, notesFileName, ROADMAP_TITLE, ROADMAP_SETTING, ROADMAP_REFUSAL_EXIT, parseRoadmapBody, createGhRoadmapSearch, severalRoadmapsMessage, createGhOpenPullRequests, closedIssuesIn, bodyLines, findField, SPEC_BLOCKED_LABEL, hasSpecBlockedLabel, readBlockedBy, blockedFaultMessage, EPIC_LABEL_PREFIX, epicSlugsOf, readEpics, BOARD_LISTING_LIMIT, createGhBoardListing, plansDirAt, requireProject, resolvePlansDir, resolveProjectConfig, countTasks, formatCounts, checkbox, planFileName, isFile, issueLine, plural, expectNoArgument, expectOneArgument, expectAtMostOneArgument, readSwitch, validate_default, createGhPermissions, readAuthorTrust, trustRefusalClause, requireTrustedAuthor, RefsBlockError, fingerprintText, readRefsText, readCopyRefs, restampCopyRefs, createGitRunner, gitSaid, RefVerifyError, PREVIOUS_COPY_WARN_ABOVE, previousDir, countPreviousCopies, createGhSpecIssueReader, readRoadmapSetting, ROADMAP_LABEL, BOARD_LABELS, SPEC_TEMPLATE_PATH, TEMPLATES_DIRNAME, boardChanged, listBoardLabels, missingBoardLabels, anythingAt, writeShippedFile, setUpBoard, createGhBoardLister, resolveDefaultBoard, unlabelledRoadmapMessage, createGhIssueBoard, blockedLineSentence, readEpicProblems, epicProblemMessage, readDoctorRefs, roadmapRefsCells, renderDoctorRefs, POSITION_FILE, positionFilePath, readPositionFile, writePositionFile, rehome, hop, hasEpicLines, horizonOf, readRoadmapEpicRows, DEFAULT_ISSUE_SEAMS, lineRefusal, expectTwoArguments, readTextFlag, readNonBlankFlag, readRequiredFlag, readChoice, readChoiceFlag, issueProject, issueSubjectConfig, resolveIssueTracker, issueRef, issueName, urlLines, onTracker, renderRoadmapTable, renderEpicTable, firstNowEpic, epics_default, samePlace, resolvePlace, createPlanDirNames, memoiseVerifier, LEARNED_DIRECTORY, ORIGIN_FIELD, DEMOTION_VERDICTS, WHEN_TO_USE_HEADING, bodySections, classifySkill, firstSentence, convertToInstinct, readPlanChanges, rankCandidates, readRankCandidate, shellQuote, ghMissingMessage, ghUnauthenticatedMessage, ghHostOf, ghPreflightItems, resolvePrProvider, requireGhProvider, isFirstDispatch, SESSION_ID_FLAG2 as SESSION_ID_FLAG, resolveLoopSeams, sessionIdFlag, refusal2 as refusal, isLive, planLabel, sessionLine, projectRoot, readRecords, pickSession, writeSession, readSessionChecklist, checkboxAt, estimateEta, readSessionFinishes, etaLine, parseWorkingTree, parseWorktrees, readMergeRefusal, cleanUpSteps, commandLine, remainingFrom, createGhPullRequests, ghPullRequestsIn, DEFAULT_BASE_BRANCH, ghNextBoard, openNextSources, createLinePrompter, REMOTE, parseBaseStanding, hasDiverged, list_default, readBranch, readPlans, readOpenPull, readBranchPlan, readNextState, commandWords, nextQuestion, NEXT_COMMAND_ACTIONS, actionInvocation, runAction, HINT_FLAG_SPEC, actionOutput, endWithNextStep, endingWith, lazyPrompter, ready_default, versionLine, DEFAULT_PLAN_FILE, resolvePlanPath, assessPlanRisk, renderRiskText, announceRiskTotal, resolveCreateSpec, resolveReleaseEnabled, TRIAGE_MODULE, DEFAULT_CI_TIMEOUT_MIN, CI_POLL_INTERVAL_MS, DEFAULT_CI_ATTEMPTS, RUNTIME_SUBDIR, RUNTIME_ENTRY, VERSION_SHAPE2 as VERSION_SHAPE, refuseMisplacedRuntime, groupChangeNotes, renderNoteLines, highestChangeLevel, parseSemanticVersion, readManifestVersion, MECHANICAL_CONFLICT_SENTENCE, start, usage, createPlanRefsVerifier, plan };
+export { readConfigFile, loadConfig, SERVE_CLI_VERSION, SCOPE_DIR, INIT_COMMAND, DISK_FILE_SYSTEM, ScopeError, scopeAt, initHint, selfAndAncestors, resolveScope, SessionRecordError, runsDir, errorCode, readSessions, readSession, PROVENANCE_FIELD, SKILL_FILE2 as SKILL_FILE, provenanceBlock, serveVerdict, SKILL_USE_CLI_VERSION, minutesBetween, sessionLogDir, 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, formatCount, verdictOf, failingRows, formatRows, waitForChecks, recordPlanCi, report, name, version, MANIFEST_VERSION, FEATURE_TYPES, OUTPUT_CHANNELS, RUNNING_MANIFEST_SEAMS, validateManifest, SPEC_EXTENSION, boardId, notesFileName, ROADMAP_TITLE, ROADMAP_SETTING, ROADMAP_REFUSAL_EXIT, parseRoadmapBody, createGhRoadmapSearch, severalRoadmapsMessage, createGhOpenPullRequests, closedIssuesIn, branchClaims, scanClaimBranches, bodyLines, findField, readEpicBody, SPEC_BLOCKED_LABEL, hasSpecBlockedLabel, readBlockedBy, blockedFaultMessage, EPIC_LABEL_PREFIX, epicSlugsOf, isNotPlanned, groupByEpicLabel, localDay, readEpics, BOARD_LISTING_LIMIT, createGhBoardListing, EPIC_TYPE_LABEL, plansDirAt, requireProject, resolvePlansDir, resolveProjectConfig, countTasks, formatCounts, checkbox, planFileName, isFile, issueLine, plural, expectNoArgument, expectOneArgument, expectAtMostOneArgument, readSwitch, validate_default, createGhPermissions, readAuthorTrust, trustRefusalClause, requireTrustedAuthor, RefsBlockError, fingerprintText, readRefsText, readCopyRefs, restampCopyRefs, createGitRunner, gitSaid, RefVerifyError, PREVIOUS_COPY_WARN_ABOVE, previousDir, countPreviousCopies, createGhSpecIssueReader, readRoadmapSetting, ROADMAP_LABEL, BOARD_LABELS, LABEL_LIST_LIMIT, SPEC_TEMPLATE_PATH, TEMPLATES_DIRNAME, boardChanged, listBoardLabels, missingBoardLabels, anythingAt, writeShippedFile, setUpBoard, createGhBoardLister, resolveDefaultBoard, unlabelledRoadmapMessage, createGhIssueBoard, blockedLineSentence, HORIZON_LABEL_PREFIX, readEpicProblems, epicProblemMessage, readDoctorRefs, roadmapRefsCells, renderDoctorRefs, POSITION_FILE, positionFilePath, readPositionFile, writePositionFile, rehome, hop, readEpicDependents, REASON_FLAG, renderHorizonComment, renderParkedPullRequestComment, renderMoveComment, renderCloseComment, renderCancelComment, cancelMoveReason, renderDependentComment, renderUnblockNote, readReason, unaskedReasonMessage, blankReasonMessage, HORIZONS, hasEpicLines, horizonOf, readRoadmapEpicRows, resolveTracker, DEFAULT_ISSUE_SEAMS, lineRefusal, expectTwoArguments, readTextFlag, readNonBlankFlag, readRequiredFlag, readChoice, readChoiceFlag, issueProject, issueSubjectConfig, resolveIssueTracker, issueRef, issueName, urlLines, onTracker, renderRoadmapTable, renderEpicTable, firstNowEpic, show_default, samePlace, resolvePlace, createPlanDirNames, hasPlanFor, memoiseVerifier, LEARNED_DIRECTORY, ORIGIN_FIELD, DEMOTION_VERDICTS, WHEN_TO_USE_HEADING, bodySections, classifySkill, firstSentence, convertToInstinct, rankCandidates, readRankCandidate, shellQuote, ghMissingMessage, ghUnauthenticatedMessage, ghHostOf, ghPreflightItems, resolvePrProvider, requireGhProvider, isFirstDispatch, SESSION_ID_FLAG2 as SESSION_ID_FLAG, resolveLoopSeams, sessionIdFlag, refusal2 as refusal, isLive, planLabel, sessionLine, projectRoot, readRecords, pickSession, writeSession, readSessionChecklist, checkboxAt, estimateEta, readSessionFinishes, formatDuration, etaLine, parseWorkingTree, parseWorktrees, readMergeRefusal, cleanUpSteps, commandLine, remainingFrom, createGhPullRequests, ghPullRequestsIn, readManifestVersion, DEFAULT_RELEASE_SEAMS, changelogVersions, readTags, status_default, epicEndLines, watchDryEpic, DEFAULT_BASE_BRANCH, ghNextBoard, openNextSources, createLinePrompter, REMOTE, parseBaseStanding, hasDiverged, list_default, readBranch2 as readBranch, readPlans, readOpenPull, readBranchPlan, readNextState, commandWords, nextQuestion, NEXT_COMMAND_ACTIONS, actionInvocation, runAction, HINT_FLAG_SPEC, actionOutput, endWithNextStep, endingWith, lazyPrompter, ready_default, versionLine, DEFAULT_PLAN_FILE, resolvePlanPath, assessPlanRisk, renderRiskText, announceRiskTotal, resolveCreateSpec, TRIAGE_MODULE, namedSecrets, triageReport, unresolvedTracker, resolveReleaseEnabled, DEFAULT_CI_TIMEOUT_MIN, CI_POLL_INTERVAL_MS, DEFAULT_CI_ATTEMPTS, RUNTIME_SUBDIR, RUNTIME_ENTRY, VERSION_SHAPE2 as VERSION_SHAPE, refuseMisplacedRuntime, MECHANICAL_CONFLICT_SENTENCE, start, usage, createPlanRefsVerifier, plan };