@open-tomato/rafa 0.9.0 → 0.9.2

package/dist/cli.js

@@ -1534,7 +1534,7 @@ function routeLine(registry, argv) {
 
 // package.json
 var name = "@open-tomato/rafa";
-var version = "0.9.0";
+var version = "0.9.2";
 
 // src/cli/version.ts
 var RAFA_VERSION = version;
@@ -3146,7 +3146,7 @@ var describeCommand2 = {
 var describe_default = Object.freeze(describeCommand2);
 
 // src/commands/doctor.ts
-import { basename as basename5, relative, resolve as resolve7, sep as sep2 } from "path";
+import { basename as basename6, relative, resolve as resolve8, sep as sep2 } from "path";
 
 // src/adapters/tracker/issue-values.ts
 var TYPE_MEMBERS = {
@@ -3508,8 +3508,8 @@ function createGithubTracker(options) {
 }
 
 // src/board/status.ts
-import { statSync as statSync5 } from "fs";
-import { join as join10 } from "path";
+import { statSync as statSync6 } from "fs";
+import { join as join11 } from "path";
 
 // src/board/naming.ts
 import path from "path";
@@ -3842,8 +3842,8 @@ function withRoadmapIssue(text2, issue) {
 }
 
 // src/board/setup.ts
-import { existsSync as existsSync6, lstatSync, mkdirSync as mkdirSync4, readFileSync as readFileSync9, statSync as statSync4, writeFileSync as writeFileSync4 } from "fs";
-import { dirname as dirname5, join as join9 } from "path";
+import { existsSync as existsSync6, lstatSync, mkdirSync as mkdirSync5, readFileSync as readFileSync9, statSync as statSync5, writeFileSync as writeFileSync4 } from "fs";
+import { dirname as dirname5, join as join10 } from "path";
 import { fileURLToPath } from "url";
 
 // src/board/blocked.ts
@@ -5394,9 +5394,89 @@ async function enforceSpecReview(options) {
 }
 
 // src/board/issue.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync8, statSync as statSync3, writeFileSync as writeFileSync3 } from "fs";
-import { dirname as dirname4, resolve as resolve4 } from "path";
-var PREFIX3 = "board issue";
+import { existsSync as existsSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync8, statSync as statSync4, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname4, resolve as resolve5 } from "path";
+
+// src/board/previous-copy.ts
+import { linkSync, mkdirSync as mkdirSync3, readdirSync as readdirSync2, statSync as statSync3, unlinkSync } from "fs";
+import { basename as basename4, extname, join as join9, resolve as resolve4 } from "path";
+var PREFIX3 = "board previous copy";
+var PREVIOUS_DIR_NAME = "previous";
+var PREVIOUS_COPY_WARN_ABOVE = 50;
+var COPY_EXTENSION = ".md";
+var FIRST_SUFFIX = 2;
+function previousDir(specsDir) {
+  return join9(specsDir, PREVIOUS_DIR_NAME);
+}
+function two(value) {
+  return String(value).padStart(2, "0");
+}
+function previousTimestamp(mtime) {
+  const date = `${String(mtime.getUTCFullYear()).padStart(4, "0")}${two(mtime.getUTCMonth() + 1)}${two(mtime.getUTCDate())}`;
+  const time = `${two(mtime.getUTCHours())}${two(mtime.getUTCMinutes())}${two(mtime.getUTCSeconds())}`;
+  return `${date}T${time}Z`;
+}
+function previousCopyName(savedName, timestamp, attempt) {
+  const stem = basename4(savedName, extname(savedName));
+  const suffix = attempt < FIRST_SUFFIX ? "" : `-${String(attempt)}`;
+  return `${stem}.${timestamp}${suffix}${COPY_EXTENSION}`;
+}
+function isTaken(error) {
+  return error instanceof Error && "code" in error && error.code === "EEXIST";
+}
+function linkUnderFreeName(source, directory2, savedName, timestamp) {
+  for (let attempt = 1;; attempt += 1) {
+    const name2 = previousCopyName(savedName, timestamp, attempt);
+    try {
+      linkSync(source, join9(directory2, name2));
+      return name2;
+    } catch (error) {
+      if (!isTaken(error))
+        throw error;
+    }
+  }
+}
+function movePreviousCopy(options) {
+  const { repoRoot, specsDir, path: path2 } = options;
+  const source = resolve4(repoRoot, path2);
+  const directory2 = previousDir(specsDir);
+  const absoluteDirectory = resolve4(repoRoot, directory2);
+  const savedName = basename4(path2);
+  let name2;
+  try {
+    const timestamp = previousTimestamp(statSync3(source).mtime);
+    mkdirSync3(absoluteDirectory, { recursive: true });
+    name2 = linkUnderFreeName(source, absoluteDirectory, savedName, timestamp);
+  } catch (error) {
+    throw new Error(`${PREFIX3}: ${path2} could not be moved to ${directory2}: ${messageOf(error)}`, { cause: error });
+  }
+  const moved = {
+    path: join9(directory2, name2),
+    absolute: join9(absoluteDirectory, name2)
+  };
+  try {
+    unlinkSync(source);
+  } catch (error) {
+    throw new Error(`${PREFIX3}: ${path2} was copied to ${moved.path} but could not be removed: ${messageOf(error)}`, { cause: error });
+  }
+  return moved;
+}
+function isMissing(error) {
+  return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+function countPreviousCopies(repoRoot, specsDir) {
+  const directory2 = previousDir(specsDir);
+  try {
+    return readdirSync2(resolve4(repoRoot, directory2), { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(COPY_EXTENSION)).length;
+  } catch (error) {
+    if (isMissing(error))
+      return 0;
+    throw new Error(`${PREFIX3}: ${directory2} could not be read: ${messageOf(error)}`, { cause: error });
+  }
+}
+
+// src/board/issue.ts
+var PREFIX4 = "board issue";
 var ISSUE_VIEW_FIELDS = "number,title,body,state,labels,author";
 var SPEC_LABEL = "type:spec";
 var ISSUE_REFUSAL_EXIT = 2;
@@ -5407,7 +5487,7 @@ function detailOf4(result, command) {
 }
 function issueNumber2(value) {
   if (!Number.isSafeInteger(value) || value < 1) {
-    throw new TypeError(`${PREFIX3}: the read refused issue number ${describeValue(value)}, expected a positive whole number`);
+    throw new TypeError(`${PREFIX4}: the read refused issue number ${describeValue(value)}, expected a positive whole number`);
   }
   return String(value);
 }
@@ -5442,11 +5522,11 @@ function readViewedIssue(stdout, number, command) {
   try {
     payload = JSON.parse(stdout);
   } catch (error) {
-    throw new Error(`${PREFIX3}: ${command} wrote output that is not JSON: ${messageOf(error)}`, { cause: error });
+    throw new Error(`${PREFIX4}: ${command} wrote output that is not JSON: ${messageOf(error)}`, { cause: error });
   }
   const problem = viewProblem2(payload, number);
   if (problem !== null)
-    throw new Error(`${PREFIX3}: ${command} answered ${problem}`);
+    throw new Error(`${PREFIX4}: ${command} answered ${problem}`);
   const checked = payload;
   return {
     number,
@@ -5464,7 +5544,7 @@ function createGhSpecIssueReader(options) {
     const command = `gh issue view ${number} --json ${ISSUE_VIEW_FIELDS}`;
     const result = await gh(["issue", "view", number, "--json", ISSUE_VIEW_FIELDS]);
     if (!result.ok)
-      throw new Error(`${PREFIX3}: ${detailOf4(result, command)}`);
+      throw new Error(`${PREFIX4}: ${detailOf4(result, command)}`);
     return readViewedIssue(result.stdout, issue, command);
   };
 }
@@ -5502,10 +5582,91 @@ ${local}`
 `)}
 `;
 }
+var NOTES_SEPARATOR = `
+
+${LOCAL_NOTES_HEADING}
+
+`;
+var HEADING = /^#{1,6}(?:[ \t]|$)/u;
+var FENCE2 = /^ {0,3}(?:`{3,}|~{3,})/u;
+function commonLines(before, after) {
+  let previous = new Uint32Array(after.length + 1);
+  for (const line of before) {
+    const row2 = new Uint32Array(after.length + 1);
+    after.forEach((other, index) => {
+      row2[index + 1] = line === other ? (previous[index] ?? 0) + 1 : Math.max(previous[index + 1] ?? 0, row2[index] ?? 0);
+    });
+    previous = row2;
+  }
+  return previous[after.length] ?? 0;
+}
+function headingName(line) {
+  const text2 = line.replace(/^#+/u, "").replace(/[ \t]+#+[ \t]*$/u, "").trim();
+  return text2 === "" ? line.trim() : text2;
+}
+function headingSections(lines) {
+  const sections = new Map;
+  let fenced = false;
+  let current = null;
+  const close = () => {
+    if (current === null)
+      return;
+    sections.set(current.key, [...sections.get(current.key) ?? [], current.lines.join(`
+`)]);
+  };
+  for (const line of lines) {
+    if (FENCE2.test(line))
+      fenced = !fenced;
+    if (fenced || !HEADING.test(line)) {
+      current?.lines.push(line);
+      continue;
+    }
+    close();
+    current = { key: line.trim(), lines: [] };
+  }
+  close();
+  return sections;
+}
+function changedHeadings(before, after) {
+  const old = headingSections(before);
+  const now = headingSections(after);
+  const keys = [...now.keys(), ...[...old.keys()].filter((key) => !now.has(key))];
+  const changed = keys.filter((key) => JSON.stringify(old.get(key) ?? []) !== JSON.stringify(now.get(key) ?? []));
+  return [...new Set(changed.map(headingName))];
+}
+function bodyChangeLine(before, after) {
+  const old = before.split(`
+`);
+  const now = after.split(`
+`);
+  const common = commonLines(old, now);
+  const headings = changedHeadings(old, now);
+  const clause = headings.length === 0 ? "no heading changed" : `headings changed: ${headings.join(", ")}`;
+  return `issue body: +${String(now.length - common)} -${String(old.length - common)} lines; ${clause}`;
+}
+function notesChangeLine(path2) {
+  return `local notes: ${path2} changed since the saved copy`;
+}
+function readSnapshotChange(options) {
+  const { saved, body, notes, notesPath: path2 } = options;
+  if (saved === snapshotText(body, notes))
+    return { kind: "unchanged", bodyLine: null, notesLine: null };
+  const now = normalise(body);
+  if (saved === `${now}
+` || saved.startsWith(`${now}${NOTES_SEPARATOR}`)) {
+    return { kind: "notes", bodyLine: null, notesLine: notesChangeLine(path2) };
+  }
+  const split = saved.lastIndexOf(NOTES_SEPARATOR);
+  const oldBody = split === -1 ? saved : saved.slice(0, split);
+  const oldNotes = split === -1 ? "" : normalise(saved.slice(split + NOTES_SEPARATOR.length)).trim();
+  const newNotes = notes === null ? "" : normalise(notes).trim();
+  const bodyLine = bodyChangeLine(normalise(oldBody), now);
+  return oldNotes === newNotes ? { kind: "body", bodyLine, notesLine: null } : { kind: "both", bodyLine, notesLine: notesChangeLine(path2) };
+}
 function readIfFile(file, what) {
   if (!existsSync5(file))
     return null;
-  if (!statSync3(file).isFile()) {
+  if (!statSync4(file).isFile()) {
     throw new CommandExit(ISSUE_REFUSAL_EXIT, `${what} ${file} is not a file, and a spec is one`);
   }
   try {
@@ -5515,7 +5676,7 @@ function readIfFile(file, what) {
   }
 }
 function readLocalNotes(repoRoot, specsDir, issue) {
-  return readIfFile(resolve4(repoRoot, notesPath(specsDir, issue)), "the local notes");
+  return readIfFile(resolve5(repoRoot, notesPath(specsDir, issue)), "the local notes");
 }
 function snapshotDiffersMessage(path2, issue) {
   return `${path2} is a snapshot of issue #${String(issue)} that no longer matches it:` + " the issue body, or the local notes appended to it, changed since the snapshot was written;" + ` pass ${REFRESH_FLAG} to plan from the issue as it reads now, or --spec=${path2} to plan from` + " the snapshot as it stands";
@@ -5532,31 +5693,42 @@ function writeSpecSnapshot(options) {
   }
   const local = readLocalNotes(repoRoot, specsDir, issue.number);
   const text2 = snapshotText(issue.body, local);
-  const absolute = resolve4(repoRoot, path2);
+  const absolute = resolve5(repoRoot, path2);
   const existing = readIfFile(absolute, "the spec snapshot");
   const written = {
     path: path2,
     absolute,
     action: "created",
     notes: local === null ? null : notes,
+    previous: null,
     text: text2
   };
   if (existing === text2)
     return { ...written, action: "unchanged" };
-  if (existing !== null && !refresh) {
+  const action = rewriteAction(existing, issue.body, local, notes, refresh);
+  if (action === null) {
     throw new CommandExit(ISSUE_REFUSAL_EXIT, snapshotDiffersMessage(path2, issue.number));
   }
+  const previous = action === "created" ? null : movePreviousCopy({ repoRoot, specsDir, path: path2 }).path;
   try {
-    mkdirSync3(dirname4(absolute), { recursive: true });
+    mkdirSync4(dirname4(absolute), { recursive: true });
     writeFileSync3(absolute, text2);
   } catch (error) {
-    throw new Error(`${PREFIX3}: the snapshot ${path2} could not be written: ${messageOf(error)}`, { cause: error });
+    throw new Error(`${PREFIX4}: the snapshot ${path2} could not be written: ${messageOf(error)}`, { cause: error });
   }
-  return existing === null ? written : { ...written, action: "refreshed" };
+  return { ...written, action, previous };
+}
+function rewriteAction(existing, body, notes, notesFile, refresh) {
+  if (existing === null)
+    return "created";
+  const { kind } = readSnapshotChange({ saved: existing, body, notes, notesPath: notesFile });
+  if (kind === "notes")
+    return "notes-rebuilt";
+  return refresh ? "refreshed" : null;
 }
 
 // src/board/setup.ts
-var PREFIX4 = "board setup";
+var PREFIX5 = "board setup";
 var MODULE_DIR = dirname5(fileURLToPath(import.meta.url));
 var BOARD_LABELS = Object.freeze([
   {
@@ -5589,7 +5761,7 @@ var BOARD_LABELS = Object.freeze([
   }
 ]);
 var LABEL_LIST_LIMIT = 100;
-var SPEC_TEMPLATE_PATH = join9(".github", "ISSUE_TEMPLATE", "spec.md");
+var SPEC_TEMPLATE_PATH = join10(".github", "ISSUE_TEMPLATE", "spec.md");
 var TEMPLATES_DIRNAME = "templates";
 var SPEC_TEMPLATE_FILE = "spec.md";
 function boardChanged(report) {
@@ -5607,24 +5779,24 @@ function parseRows2(stdout, command) {
   try {
     payload = JSON.parse(stdout);
   } catch (error) {
-    throw new Error(`${PREFIX4}: ${command} wrote output that is not JSON: ${messageOf(error)}`, { cause: error });
+    throw new Error(`${PREFIX5}: ${command} wrote output that is not JSON: ${messageOf(error)}`, { cause: error });
   }
   if (!Array.isArray(payload)) {
-    throw new Error(`${PREFIX4}: ${command} answered ${describeValue(payload)}, expected a list`);
+    throw new Error(`${PREFIX5}: ${command} answered ${describeValue(payload)}, expected a list`);
   }
   return payload;
 }
 function rowText2(row2, key, command, where) {
   const value = isMapping(row2) ? row2[key] : null;
   if (typeof value !== "string") {
-    throw new Error(`${PREFIX4}: ${command} answered ${where}.${key} as ${describeValue(value)}, expected a string`);
+    throw new Error(`${PREFIX5}: ${command} answered ${where}.${key} as ${describeValue(value)}, expected a string`);
   }
   return value;
 }
 function rowNumber2(row2, key, command, where) {
   const value = isMapping(row2) ? row2[key] : null;
   if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 1) {
-    throw new Error(`${PREFIX4}: ${command} answered ${where}.${key} as ${describeValue(value)}, expected a positive whole number`);
+    throw new Error(`${PREFIX5}: ${command} answered ${where}.${key} as ${describeValue(value)}, expected a positive whole number`);
   }
   return value;
 }
@@ -5634,7 +5806,7 @@ async function listBoardLabels(gh) {
   const command = `gh label list --limit ${limit} --json name`;
   const result = await gh(args);
   if (!result.ok)
-    throw new Error(`${PREFIX4}: ${detailOf5(result, command)}`);
+    throw new Error(`${PREFIX5}: ${detailOf5(result, command)}`);
   return Object.freeze(parseRows2(result.stdout, command).map((row2, index) => rowText2(row2, "name", command, `label ${String(index)}`)));
 }
 function holdsLabel(held, name2) {
@@ -5667,7 +5839,7 @@ async function setUpLabels(gh) {
 }
 function statOrNull(path2) {
   try {
-    return statSync4(path2);
+    return statSync5(path2);
   } catch {
     return null;
   }
@@ -5681,17 +5853,17 @@ function anythingAt(path2) {
   }
 }
 function specTemplateSource(moduleDir = MODULE_DIR) {
-  return join9(moduleDir, TEMPLATES_DIRNAME, SPEC_TEMPLATE_FILE);
+  return join10(moduleDir, TEMPLATES_DIRNAME, SPEC_TEMPLATE_FILE);
 }
 function readSpecTemplate(moduleDir = MODULE_DIR) {
   const source = specTemplateSource(moduleDir);
   if (!existsSync6(source)) {
-    throw new Error(`${PREFIX4}: the spec issue template is missing: no file at ${source}`);
+    throw new Error(`${PREFIX5}: the spec issue template is missing: no file at ${source}`);
   }
   return readFileSync9(source, "utf8");
 }
 function writeSpecTemplate(root, moduleDir = MODULE_DIR) {
-  const path2 = join9(root, SPEC_TEMPLATE_PATH);
+  const path2 = join10(root, SPEC_TEMPLATE_PATH);
   const name2 = SPEC_TEMPLATE_PATH;
   const found = statOrNull(path2);
   if (found !== null) {
@@ -5702,7 +5874,7 @@ function writeSpecTemplate(root, moduleDir = MODULE_DIR) {
   }
   try {
     const text2 = readSpecTemplate(moduleDir);
-    mkdirSync4(dirname5(path2), { recursive: true });
+    mkdirSync5(dirname5(path2), { recursive: true });
     writeFileSync4(path2, text2, { encoding: "utf8", flag: "wx" });
     return partOf("template", name2, "created", `written from ${specTemplateSource(moduleDir)}`);
   } catch (error) {
@@ -5776,7 +5948,7 @@ async function searchRoadmapIssues(gh) {
   const command = `gh issue list --state open --search "${search}" --json number,title`;
   const result = await gh(args);
   if (!result.ok)
-    throw new Error(`${PREFIX4}: ${detailOf5(result, command)}`);
+    throw new Error(`${PREFIX5}: ${detailOf5(result, command)}`);
   const wanted = ROADMAP_TITLE.toLowerCase();
   return Object.freeze(parseRows2(result.stdout, command).map((row2, index) => ({
     number: rowNumber2(row2, "number", command, `issue ${String(index)}`),
@@ -5787,12 +5959,12 @@ async function createRoadmapIssue(gh) {
   const command = `gh issue create --title ${ROADMAP_TITLE}`;
   const result = await gh(["issue", "create", "--title", ROADMAP_TITLE, "--body", roadmapIssueBody()]);
   if (!result.ok)
-    throw new Error(`${PREFIX4}: ${detailOf5(result, command)}`);
+    throw new Error(`${PREFIX5}: ${detailOf5(result, command)}`);
   const url = result.stdout.trim().split(`
 `).at(-1) ?? "";
   const number = CREATED_ISSUE_URL2.exec(url)?.[1];
   if (number === undefined) {
-    throw new Error(`${PREFIX4}: ${command} exited 0 and printed no issue URL, so the issue may exist` + ` unrecorded; it wrote ${describeValue(result.stdout)}`);
+    throw new Error(`${PREFIX5}: ${command} exited 0 and printed no issue URL, so the issue may exist` + ` unrecorded; it wrote ${describeValue(result.stdout)}`);
   }
   return Number.parseInt(number, 10);
 }
@@ -5882,11 +6054,11 @@ async function readLabelRows(gh) {
   return Object.freeze(BOARD_LABELS.map((label) => missing2.includes(label) ? rowOf("label", label.name, "missing", "the repository carries no label of that name") : rowOf("label", label.name, "present", "the repository carries it")));
 }
 function readTemplateRow(root) {
-  const path2 = join10(root, SPEC_TEMPLATE_PATH);
+  const path2 = join11(root, SPEC_TEMPLATE_PATH);
   const name2 = SPEC_TEMPLATE_PATH;
   let found;
   try {
-    found = statSync5(path2);
+    found = statSync6(path2);
   } catch {
     return rowOf("template", name2, "missing", "the repository carries no spec issue template");
   }
@@ -5954,18 +6126,18 @@ async function readBoardStatus(options) {
 }
 
 // src/effort/store/legacy.ts
-import { statSync as statSync6 } from "fs";
-import { basename as basename4, join as join13 } from "path";
+import { statSync as statSync7 } from "fs";
+import { basename as basename5, join as join14 } from "path";
 
 // src/effort/store.ts
 import {
   appendFileSync,
   existsSync as existsSync7,
-  mkdirSync as mkdirSync5,
+  mkdirSync as mkdirSync6,
   readFileSync as readFileSync10
 } from "fs";
-import { dirname as dirname6, join as join11 } from "path";
-var EFFORT_STORE_DIR = join11(".rafa", "effort");
+import { dirname as dirname6, join as join12 } from "path";
+var EFFORT_STORE_DIR = join12(".rafa", "effort");
 var STORE_FILE_NAMES = {
   sessions: "sessions.ndjson",
   commits: "commits.ndjson"
@@ -5977,7 +6149,7 @@ function normaliseKey(key) {
   return typeof key === "string" && key.length > 0 ? key : null;
 }
 function effortStorePath(repoRoot, kind) {
-  return join11(repoRoot, EFFORT_STORE_DIR, STORE_FILE_NAMES[kind]);
+  return join12(repoRoot, EFFORT_STORE_DIR, STORE_FILE_NAMES[kind]);
 }
 function readStoreText(path2) {
   return existsSync7(path2) ? readFileSync10(path2, "utf8") : null;
@@ -6052,7 +6224,7 @@ function appendRows(path2, rows2, keyOf) {
 `);
   const lead = separatedPartialLine ? `
 ` : "";
-  mkdirSync5(dirname6(path2), { recursive: true });
+  mkdirSync6(dirname6(path2), { recursive: true });
   appendFileSync(path2, `${lead}${lines.join(`
 `)}
 `, "utf8");
@@ -6065,8 +6237,8 @@ function appendRows(path2, rows2, keyOf) {
 }
 
 // src/effort/store/sqlite.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync6 } from "fs";
-import { dirname as dirname7, join as join12 } from "path";
+import { existsSync as existsSync8, mkdirSync as mkdirSync7 } from "fs";
+import { dirname as dirname7, join as join13 } from "path";
 import { Database } from "bun:sqlite";
 
 // src/effort/store/types.ts
@@ -6081,7 +6253,7 @@ var EFFORT_KEY_PROJECTIONS = {
 // src/effort/store/sqlite.ts
 var STORE_FILE_NAME = "effort.sqlite";
 function sqliteStorePath(repoRoot) {
-  return join12(repoRoot, EFFORT_STORE_DIR, STORE_FILE_NAME);
+  return join13(repoRoot, EFFORT_STORE_DIR, STORE_FILE_NAME);
 }
 var SQLITE_MIGRATIONS = [
   `
@@ -6291,7 +6463,7 @@ function migrateSchema(db, path2, migrations = SQLITE_MIGRATIONS) {
 }
 function withSqliteStore(path2, create, use) {
   if (create)
-    mkdirSync6(dirname7(path2), { recursive: true });
+    mkdirSync7(dirname7(path2), { recursive: true });
   const db = new Database(path2, { readwrite: true, create });
   try {
     migrateSchema(db, path2);
@@ -6361,11 +6533,11 @@ function openSqliteStore(repoRoot) {
 }
 
 // src/effort/store/legacy.ts
-var LEGACY_EFFORT_STORE_DIR = join13(".ralph", "effort");
+var LEGACY_EFFORT_STORE_DIR = join14(".ralph", "effort");
 var NDJSON_KINDS = { sessions: true, commits: true };
 var STORE_FILE_NAMES2 = Object.freeze([
-  basename4(sqliteStorePath("")),
-  ...Object.keys(NDJSON_KINDS).map((kind) => basename4(effortStorePath("", kind)))
+  basename5(sqliteStorePath("")),
+  ...Object.keys(NDJSON_KINDS).map((kind) => basename5(effortStorePath("", kind)))
 ]);
 function isAbsence(error) {
   if (typeof error !== "object" || error === null || !("code" in error))
@@ -6374,7 +6546,7 @@ function isAbsence(error) {
 }
 function isStoreFile(path2) {
   try {
-    return statSync6(path2).isFile();
+    return statSync7(path2).isFile();
   } catch (error) {
     if (isAbsence(error))
       return false;
@@ -6382,7 +6554,7 @@ function isStoreFile(path2) {
   }
 }
 function storeFilesIn(dir) {
-  return Object.freeze(STORE_FILE_NAMES2.filter((name2) => isStoreFile(join13(dir, name2))));
+  return Object.freeze(STORE_FILE_NAMES2.filter((name2) => isStoreFile(join14(dir, name2))));
 }
 function shellQuoted(path2) {
   return `'${path2.replaceAll("'", "'\\''")}'`;
@@ -6392,8 +6564,8 @@ function legacyWarning(legacyDir, storeDir, legacyFiles) {
   return `${legacyDir} holds an effort store (${legacyFiles.join(", ")}) and ${storeDir} holds none;` + ` rafa reads ${storeDir} alone, so its reports start from an empty store. Once no loop is running,` + ` move it: ${move}`;
 }
 function readLegacyStore(root) {
-  const legacyDir = join13(root, LEGACY_EFFORT_STORE_DIR);
-  const storeDir = join13(root, EFFORT_STORE_DIR);
+  const legacyDir = join14(root, LEGACY_EFFORT_STORE_DIR);
+  const storeDir = join14(root, EFFORT_STORE_DIR);
   const legacyFiles = storeFilesIn(legacyDir);
   const storeFiles = storeFilesIn(storeDir);
   const warning = legacyFiles.length > 0 && storeFiles.length === 0 ? legacyWarning(legacyDir, storeDir, legacyFiles) : null;
@@ -6541,9 +6713,9 @@ function isFirstDispatch(planPath) {
 }
 
 // src/project/bin-path.ts
-import { delimiter, isAbsolute as isAbsolute4, join as join14, resolve as resolve5 } from "path";
-var RAFA_BIN_DIR = join14(SCOPE_DIR, "bin");
-var BUN_BIN_DIR = join14(".bun", "bin");
+import { delimiter, isAbsolute as isAbsolute4, join as join15, resolve as resolve6 } from "path";
+var RAFA_BIN_DIR = join15(SCOPE_DIR, "bin");
+var BUN_BIN_DIR = join15(".bun", "bin");
 function exportLine(rafaBin) {
   return `export PATH="${rafaBin}:$PATH"`;
 }
@@ -6560,7 +6732,7 @@ function canonical(path2, fs2) {
   try {
     return fs2.realpath(path2);
   } catch {
-    return resolve5(path2);
+    return resolve6(path2);
   }
 }
 function indexOf(entries, dir, fs2) {
@@ -6576,8 +6748,8 @@ function stateOf2(rafaIndex, bunIndex) {
   return "ahead";
 }
 function readBinPath(pathValue, home, fs2 = DISK_FILE_SYSTEM) {
-  const rafaBin = join14(home, RAFA_BIN_DIR);
-  const bunBin = join14(home, BUN_BIN_DIR);
+  const rafaBin = join15(home, RAFA_BIN_DIR);
+  const bunBin = join15(home, BUN_BIN_DIR);
   const entries = (pathValue ?? "").split(delimiter);
   const rafaIndex = indexOf(entries, rafaBin, fs2);
   const bunIndex = indexOf(entries, bunBin, fs2);
@@ -6620,20 +6792,20 @@ function readPreInitDirs(config) {
 
 // src/start/plan-path.ts
 import { existsSync as existsSync9 } from "fs";
-import { resolve as resolve6 } from "path";
+import { resolve as resolve7 } from "path";
 var DEFAULT_PLAN_FILE = "PLAN.md";
 function resolvePlanPath(repoRoot, planDir, planArg) {
   if (planArg)
-    return resolve6(repoRoot, planArg);
-  const inPlanDir = resolve6(repoRoot, planDir, DEFAULT_PLAN_FILE);
-  return existsSync9(inPlanDir) ? inPlanDir : resolve6(repoRoot, DEFAULT_PLAN_FILE);
+    return resolve7(repoRoot, planArg);
+  const inPlanDir = resolve7(repoRoot, planDir, DEFAULT_PLAN_FILE);
+  return existsSync9(inPlanDir) ? inPlanDir : resolve7(repoRoot, DEFAULT_PLAN_FILE);
 }
 
 // src/commands/doctor-blocked.ts
 var BLOCKED_HEADING = "Blocked issues:";
 var BLOCKED_LIST_LIMIT = 100;
 var KNOWN_LIST_LIMIT = 500;
-var PREFIX5 = "board blocked";
+var PREFIX6 = "board blocked";
 function detailOf6(result, command) {
   const written = result.stderr.trim() || result.stdout.trim();
   return written === "" ? `${command} failed and wrote nothing` : `${command} failed: ${written}`;
@@ -6641,32 +6813,32 @@ function detailOf6(result, command) {
 async function rowsOf(gh, args, command) {
   const result = await gh(args);
   if (!result.ok)
-    throw new Error(`${PREFIX5}: ${detailOf6(result, command)}`);
+    throw new Error(`${PREFIX6}: ${detailOf6(result, command)}`);
   let parsed;
   try {
     parsed = JSON.parse(result.stdout);
   } catch (error) {
-    throw new Error(`${PREFIX5}: ${command} wrote output that is not JSON: ${messageOf(error)}`, { cause: error });
+    throw new Error(`${PREFIX6}: ${command} wrote output that is not JSON: ${messageOf(error)}`, { cause: error });
   }
   if (!Array.isArray(parsed)) {
-    throw new Error(`${PREFIX5}: ${command} answered ${describeValue(parsed)}, expected a list of issues`);
+    throw new Error(`${PREFIX6}: ${command} answered ${describeValue(parsed)}, expected a list of issues`);
   }
   return parsed;
 }
 function rowNumber3(row2, command, where) {
   if (!isMapping(row2)) {
-    throw new Error(`${PREFIX5}: ${command} answered ${where} as ${describeValue(row2)}, expected a mapping`);
+    throw new Error(`${PREFIX6}: ${command} answered ${where} as ${describeValue(row2)}, expected a mapping`);
   }
   const number = row2["number"];
   if (typeof number !== "number" || !Number.isSafeInteger(number) || number < 1) {
-    throw new Error(`${PREFIX5}: ${command} answered ${where}.number as ${describeValue(number)}, expected a positive whole number`);
+    throw new Error(`${PREFIX6}: ${command} answered ${where}.number as ${describeValue(number)}, expected a positive whole number`);
   }
   return number;
 }
 function rowBody(row2, command, where) {
   const body = isMapping(row2) ? row2["body"] : null;
   if (typeof body !== "string") {
-    throw new Error(`${PREFIX5}: ${command} answered ${where}.body as ${describeValue(body)}, expected a string`);
+    throw new Error(`${PREFIX6}: ${command} answered ${where}.body as ${describeValue(body)}, expected a string`);
   }
   return body;
 }
@@ -6756,6 +6928,16 @@ function renderBlockedIssues(report) {
   return [BLOCKED_HEADING, ...body, ...unchecked];
 }
 
+// src/commands/doctor-previous.ts
+function previousCopiesWarning(specsDir, count) {
+  return `rafa doctor: ${previousDir(specsDir)}/ holds ${count} previous copies of issue specs; they are safe to delete`;
+}
+function readPreviousCopies(repoRoot, config) {
+  const count = countPreviousCopies(repoRoot, config.specsDir);
+  const warning = count > PREVIOUS_COPY_WARN_ABOVE ? previousCopiesWarning(config.specsDir, count) : null;
+  return { count, warning };
+}
+
 // src/commands/init-board.ts
 var YES_ANSWERS = ["y", "yes"];
 var BOARD_QUESTION = "Set up the GitHub board for this repo? [y/N] ";
@@ -6896,7 +7078,7 @@ function resolvedConfig3(project, warn) {
   }
 }
 function defaultPlanPaths(root, planDir) {
-  return [...new Set([resolve7(root, planDir, DEFAULT_PLAN_FILE), resolve7(root, DEFAULT_PLAN_FILE)])];
+  return [...new Set([resolve8(root, planDir, DEFAULT_PLAN_FILE), resolve8(root, DEFAULT_PLAN_FILE)])];
 }
 function planFileAt(path2) {
   try {
@@ -6941,7 +7123,7 @@ function readStartTier(plan, items) {
     return { tier: NO_START_TIER, items: NO_ITEMS2 };
   if (isFirstDispatch(plan))
     return { tier: { checked: start.length, skipped: 0, tracker: null }, items: start };
-  const tracker = basename5(trackerPathFor(plan));
+  const tracker = basename6(trackerPathFor(plan));
   return { tier: { checked: 0, skipped: start.length, tracker }, items: NO_ITEMS2 };
 }
 async function checkPreflight(context, project, seams) {
@@ -6998,24 +7180,37 @@ function readPreInit(project) {
     return null;
   }
 }
+function readPrevious(project) {
+  try {
+    const { config } = loadConfig({ root: project.root, home: project.home }, {}, () => {
+      return;
+    });
+    return readPreviousCopies(project.root, config);
+  } catch {
+    return null;
+  }
+}
 function readInstall(context, project) {
   const binPath = readBinPath(context.env["PATH"], project.home);
   const preInitDirs = readPreInit(project);
+  const previousCopies = readPrevious(project);
   try {
-    return { binPath, legacyStore: readLegacyStore(project.root), preInitDirs, storeProblem: null };
+    return { binPath, legacyStore: readLegacyStore(project.root), preInitDirs, previousCopies, storeProblem: null };
   } catch (error) {
     const storeProblem = `rafa doctor: the effort store directories could not be checked: ${messageOf(error)}`;
-    return { binPath, legacyStore: null, preInitDirs, storeProblem };
+    return { binPath, legacyStore: null, preInitDirs, previousCopies, storeProblem };
   }
 }
 function writeInstall(context, install) {
-  const { binPath, legacyStore, preInitDirs, storeProblem } = install;
+  const { binPath, legacyStore, preInitDirs, previousCopies, storeProblem } = install;
   if (storeProblem !== null)
     context.output.warn(storeProblem);
   if (legacyStore !== null && legacyStore.warning !== null)
     context.output.warn(legacyStore.warning);
   if (preInitDirs !== null && preInitDirs.warning !== null)
     context.output.warn(preInitDirs.warning);
+  if (previousCopies !== null && previousCopies.warning !== null)
+    context.output.warn(previousCopies.warning);
   if (binPath.warning !== null) {
     context.output.warn(binPath.warning);
     return;
@@ -7042,7 +7237,7 @@ function headLine(preflight) {
     const checked2 = checkedPhrase(count, automatic, "from the config ");
     return `Preflight with no plan, none being at ${where}: ${checked2}, no run started.`;
   }
-  const merged = prerequisitesFile === null ? "" : `, with ${basename5(prerequisitesFile)} merged in`;
+  const merged = prerequisitesFile === null ? "" : `, with ${basename6(prerequisitesFile)} merged in`;
   const checked = checkedPhrase(count, automatic, "");
   return `Preflight for ${shownPath(plan, root)}${merged}: ${checked}, no run started.`;
 }
@@ -7064,7 +7259,7 @@ function reminderLines(preflight) {
   if (reminders.length === 0 || prerequisitesFile === null)
     return [];
   return [
-    `${basename5(prerequisitesFile)} names ${plural(reminders.length, "step")} the preflight does not check:`,
+    `${basename6(prerequisitesFile)} names ${plural(reminders.length, "step")} the preflight does not check:`,
     ...reminders.map((reminder) => `  line ${String(reminder.line)}: ${reminder.description}`)
   ];
 }
@@ -7123,6 +7318,7 @@ function resultOf(preflight, install, readings) {
     binPath: install.binPath,
     legacyStore: install.legacyStore,
     preInitDirs: install.preInitDirs,
+    previousCopies: install.previousCopies,
     board: readings.board,
     blocked: readings.blocked
   };
@@ -7164,7 +7360,7 @@ function createDoctorCommand(seams = DEFAULT_DOCTOR_SEAMS) {
     subject: "doctor",
     action: "doctor",
     summary: "check the prerequisites rafa loop start checks, and the install, starting no run",
-    description: "Checks the prerequisites `rafa loop start` checks before its first session and prints each" + " check, starting no run and storing nothing: the required and optional items of" + " `.rafa/config.yaml`, with the `PREREQUISITES-<stub>.md` beside the plan merged in, and, when the" + " repository resolves to `pr.provider: gh`, the two required items that provider adds ahead of them:" + " `gh` on PATH and `gh auth status` for the remote's host. A plan's `[start]` items are checked" + " after those and ahead of the configured tiers, on a first dispatch alone: a" + " `PLAN_TRACKER-<stub>.md` beside the plan already holding a ticked task makes the next run a" + " resume, which checks none of them and says in one line how many it passed over." + " The plan is the" + " one `--plan=<file>` names, relative to the project root, or the default plan `rafa loop start`" + ` runs. Each probe runs in the project root with stdin closed and a ${String(PROBE_TIMEOUT_MS / 1000)}-second` + " timeout. It exits 1 when a required item fails, naming the item, its probe and its exit code or" + " first line of stderr, where `rafa loop start` would halt, and 0 otherwise. It warns when" + " `.ralph/effort/` holds an effort store and `.rafa/effort/` holds none, and when `~/.rafa/bin` is" + " not on PATH ahead of `~/.bun/bin`; a warning never changes the exit code. On a repository whose" + " provider is `gh` it also reads the GitHub board `rafa init --board` sets up and prints one row per" + " part \u2014 the seven labels, the spec issue template, the Roadmap issue and `roadmap.issue` \u2014 as present," + " missing, or unknown for a reading that failed, naming `rafa init --board` as the fix; it writes" + " nothing to the board and a row never changes the exit code. It then names, under `Blocked" + " issues:`, every open issue labelled `spec:blocked` whose `Blocked by:` line is missing, names no" + " issue, names itself, or names an id the board has no issue for, with what an author does about" + " it; that reading writes nothing and never changes the exit code either. With `--output=json` the" + " checks, both readings, those rows and those issues are the data of the terminal result event," + " unless a required item failed.",
+    description: "Checks the prerequisites `rafa loop start` checks before its first session and prints each" + " check, starting no run and storing nothing: the required and optional items of" + " `.rafa/config.yaml`, with the `PREREQUISITES-<stub>.md` beside the plan merged in, and, when the" + " repository resolves to `pr.provider: gh`, the two required items that provider adds ahead of them:" + " `gh` on PATH and `gh auth status` for the remote's host. A plan's `[start]` items are checked" + " after those and ahead of the configured tiers, on a first dispatch alone: a" + " `PLAN_TRACKER-<stub>.md` beside the plan already holding a ticked task makes the next run a" + " resume, which checks none of them and says in one line how many it passed over." + " The plan is the" + " one `--plan=<file>` names, relative to the project root, or the default plan `rafa loop start`" + ` runs. Each probe runs in the project root with stdin closed and a ${String(PROBE_TIMEOUT_MS / 1000)}-second` + " timeout. It exits 1 when a required item fails, naming the item, its probe and its exit code or" + " first line of stderr, where `rafa loop start` would halt, and 0 otherwise. It warns when" + " `.ralph/effort/` holds an effort store and `.rafa/effort/` holds none, and when `~/.rafa/bin` is" + " not on PATH ahead of `~/.bun/bin`, and when `previous/` under `specs.dir` holds more than fifty" + " previous copies of issue specs, which are safe to delete; a warning never changes the exit code. On a repository whose" + " provider is `gh` it also reads the GitHub board `rafa init --board` sets up and prints one row per" + " part \u2014 the seven labels, the spec issue template, the Roadmap issue and `roadmap.issue` \u2014 as present," + " missing, or unknown for a reading that failed, naming `rafa init --board` as the fix; it writes" + " nothing to the board and a row never changes the exit code. It then names, under `Blocked" + " issues:`, every open issue labelled `spec:blocked` whose `Blocked by:` line is missing, names no" + " issue, names itself, or names an id the board has no issue for, with what an author does about" + " it; that reading writes nothing and never changes the exit code either. With `--output=json` the" + " checks, both readings, those rows and those issues are the data of the terminal result event," + " unless a required item failed.",
     args: [],
     flags: [
       {
@@ -7191,13 +7387,13 @@ function createDoctorCommand(seams = DEFAULT_DOCTOR_SEAMS) {
 var doctor_default = createDoctorCommand();
 
 // src/effort/collect.ts
-import { existsSync as existsSync11, readdirSync as readdirSync2, statSync as statSync7 } from "fs";
+import { existsSync as existsSync11, readdirSync as readdirSync3, statSync as statSync8 } from "fs";
 import { homedir as homedir2 } from "os";
-import { join as join17, resolve as resolve9 } from "path";
+import { join as join18, resolve as resolve10 } from "path";
 
 // src/effort/session-log.ts
 import { createReadStream } from "fs";
-import { basename as basename6 } from "path";
+import { basename as basename7 } from "path";
 import { createInterface } from "readline";
 function emptyUsageTotals() {
   return {
@@ -7225,7 +7421,7 @@ function bump(counts, key) {
   counts[key] = (counts[key] ?? 0) + 1;
 }
 function sessionIdFromPath(filePath) {
-  return basename6(filePath).replace(/\.jsonl$/i, "");
+  return basename7(filePath).replace(/\.jsonl$/i, "");
 }
 async function* readLines2(filePath) {
   const stream = createReadStream(filePath, { encoding: "utf8" });
@@ -7782,8 +7978,8 @@ function openNdjsonStore(repoRoot) {
 
 // src/adapters/learning/local.ts
 import { appendFile, mkdir, readFile } from "fs/promises";
-import { join as join15 } from "path";
-var PREFIX6 = "local learning";
+import { join as join16 } from "path";
+var PREFIX7 = "local learning";
 var INSTINCTS_FILE = "instincts.ndjson";
 var FLAGS_FILE = "flags.ndjson";
 var MIN_CONFIDENCE = 0.3;
@@ -7910,21 +8106,21 @@ function warnThroughActiveOutput2(message) {
   activeOutput().warn(message);
 }
 function localInstinctsDir(repoRoot) {
-  return join15(repoRoot, ".rafa", "instincts");
+  return join16(repoRoot, ".rafa", "instincts");
 }
 function createLocalLearning(options) {
   const { instinctsDir } = options;
   const now = options.now ?? (() => new Date().toISOString());
   const warn = options.warn ?? warnThroughActiveOutput2;
-  const instinctsPath = join15(instinctsDir, INSTINCTS_FILE);
-  const flagsPath = join15(instinctsDir, FLAGS_FILE);
+  const instinctsPath = join16(instinctsDir, INSTINCTS_FILE);
+  const flagsPath = join16(instinctsDir, FLAGS_FILE);
   async function heldInstincts() {
     const lines = numberedLines(await readIfPresent2(instinctsPath));
     return lines.flatMap(([number, line]) => {
       const reading2 = readLine2(line, heldInstinctProblem);
       if (reading2.ok)
         return [copyInstinct(reading2.value.instinct)];
-      warn(`${PREFIX6}: line ${number} of ${instinctsPath} is not a held instinct, so it was skipped: ${reading2.problem}`);
+      warn(`${PREFIX7}: line ${number} of ${instinctsPath} is not a held instinct, so it was skipped: ${reading2.problem}`);
       return [];
     });
   }
@@ -7934,14 +8130,14 @@ function createLocalLearning(options) {
       const reading2 = readLine2(line, flagProblem);
       if (reading2.ok)
         return reading2.value.id;
-      throw new Error(`${PREFIX6}: line ${number} of ${flagsPath} is not a flag,` + ` and a bundle skipping it could hold an instinct it flags: ${reading2.problem}`);
+      throw new Error(`${PREFIX7}: line ${number} of ${flagsPath} is not a flag,` + ` and a bundle skipping it could hold an instinct it flags: ${reading2.problem}`);
     }));
   }
   const learning = {
     push: async (payload) => {
       const problem = payloadProblem(payload);
       if (problem !== null) {
-        throw new TypeError(`${PREFIX6}: refused to store a push: ${problem}`);
+        throw new TypeError(`${PREFIX7}: refused to store a push: ${problem}`);
       }
       const decisions = payload.instincts.map((incoming) => ({
         incoming,
@@ -7967,11 +8163,11 @@ function createLocalLearning(options) {
       const flag2 = { id, reason, flagged_at: now() };
       const problem = flagProblem(flag2);
       if (problem !== null) {
-        throw new TypeError(`${PREFIX6}: refused to write an invalid flag: ${problem}`);
+        throw new TypeError(`${PREFIX7}: refused to write an invalid flag: ${problem}`);
       }
       const held = await heldInstincts();
       if (!held.some((instinct) => instinct.id === id)) {
-        throw new Error(`${PREFIX6}: no instinct ${describeValue(id)} is held under ${instinctsDir}`);
+        throw new Error(`${PREFIX7}: no instinct ${describeValue(id)} is held under ${instinctsDir}`);
       }
       await appendLines(flagsPath, [JSON.stringify(flag2)]);
     }
@@ -7982,7 +8178,7 @@ function createLocalLearning(options) {
 // src/adapters/planner/claude.ts
 import { existsSync as existsSync10 } from "fs";
 import { mkdir as mkdir2, readFile as readFile2 } from "fs/promises";
-import { posix, resolve as resolve8 } from "path";
+import { posix, resolve as resolve9 } from "path";
 
 // src/board/spec-review.ts
 var SPEC_REVIEW_KIND = "spec-review";
@@ -8293,12 +8489,12 @@ function createClaudePlanner(options) {
   const create = async ({ specPath: specPath2, stub }) => {
     const planPath = planFilePath(planDir, `PLAN-${stub}.md`);
     const prerequisitesPath = planFilePath(planDir, `PREREQUISITES-${stub}.md`);
-    const isWritten = (path2) => existsSync10(resolve8(repoRoot, path2));
+    const isWritten = (path2) => existsSync10(resolve9(repoRoot, path2));
     if (isWritten(planPath)) {
       throw new ClaudePlannerError(`${planPath} already exists`, FAILURE_EXIT_CODE);
     }
-    const specContent = await readFile2(resolve8(repoRoot, specPath2), "utf8");
-    await mkdir2(resolve8(repoRoot, planDir), { recursive: true });
+    const specContent = await readFile2(resolve9(repoRoot, specPath2), "utf8");
+    await mkdir2(resolve9(repoRoot, planDir), { recursive: true });
     const session = await runClaudeCaptured(buildPrompt(specContent, stub), settingSources, [], spawn);
     const review = parseSpecReview(session.stdout);
     const { exitCode } = session;
@@ -8319,8 +8515,8 @@ function createClaudePlanner(options) {
 
 // src/adapters/tracker/local.ts
 import { mkdir as mkdir3, readdir, readFile as readFile3, writeFile } from "fs/promises";
-import { join as join16 } from "path";
-var PREFIX7 = "local tracker";
+import { join as join17 } from "path";
+var PREFIX8 = "local tracker";
 var FRONTMATTER = /^---\n([\s\S]*?)\n---\n([\s\S]*)$/;
 var ISSUE_NUMBER2 = /^[1-9]\d*$/;
 var ISSUE_EXTENSION = ".md";
@@ -8376,7 +8572,7 @@ function issueNumberOfFile(name2) {
   return name2.endsWith(ISSUE_EXTENSION) ? parseIssueNumber(name2.slice(0, -ISSUE_EXTENSION.length)) : null;
 }
 function issuePath(issuesDir, number) {
-  return join16(issuesDir, `${number}${ISSUE_EXTENSION}`);
+  return join17(issuesDir, `${number}${ISSUE_EXTENSION}`);
 }
 async function issueNumbers(issuesDir) {
   let names;
@@ -8390,7 +8586,7 @@ async function issueNumbers(issuesDir) {
   return names.map(issueNumberOfFile).filter((number) => number !== null).sort((a, b) => a - b);
 }
 function localIssuesDir(repoRoot) {
-  return join16(repoRoot, ".rafa", "issues");
+  return join17(repoRoot, ".rafa", "issues");
 }
 function renderLocalIssue(record) {
   const { draft } = record;
@@ -8409,7 +8605,7 @@ function renderLocalIssue(record) {
   };
   const problem = frontmatterProblem(frontmatter) ?? (typeof draft.body === "string" ? null : `body is ${describeValue(draft.body)}, expected a string`);
   if (problem !== null) {
-    throw new TypeError(`${PREFIX7}: refused to write an invalid issue: ${problem}`);
+    throw new TypeError(`${PREFIX8}: refused to write an invalid issue: ${problem}`);
   }
   return `---
 ${Bun.YAML.stringify(frontmatter, null, 2)}
@@ -8420,18 +8616,18 @@ function parseLocalIssue(contents, sourcePath) {
   const at = sourcePath === undefined ? "" : ` at ${sourcePath}`;
   const match = FRONTMATTER.exec(contents);
   if (match === null) {
-    throw new Error(`${PREFIX7}: the issue${at} has no YAML frontmatter block`);
+    throw new Error(`${PREFIX8}: the issue${at} has no YAML frontmatter block`);
   }
   const [, block2 = "", body = ""] = match;
   let meta;
   try {
     meta = Bun.YAML.parse(block2);
   } catch (error) {
-    throw new Error(`${PREFIX7}: invalid issue${at}: ${messageOf(error)}`, { cause: error });
+    throw new Error(`${PREFIX8}: invalid issue${at}: ${messageOf(error)}`, { cause: error });
   }
   const problem = frontmatterProblem(meta);
   if (problem !== null) {
-    throw new Error(`${PREFIX7}: invalid issue${at}: ${problem}`);
+    throw new Error(`${PREFIX8}: invalid issue${at}: ${problem}`);
   }
   const fields = meta;
   return {
@@ -8462,7 +8658,7 @@ async function listLocalIssues(issuesDir, warn = warnThroughActiveOutput3) {
     try {
       contents = await readFile3(path2, "utf8");
     } catch (error) {
-      throw new Error(`${PREFIX7}: could not read ${path2}: ${messageOf(error)}`, { cause: error });
+      throw new Error(`${PREFIX8}: could not read ${path2}: ${messageOf(error)}`, { cause: error });
     }
     return { number, path: path2, record: parseLocalIssue(contents, path2) };
   }));
@@ -8491,11 +8687,11 @@ function refFor(number, opt) {
 }
 function issueNumberOfRef2(ref) {
   if (ref.kind !== "local") {
-    throw new Error(`${PREFIX7}: refused a ref of kind ${describeValue(ref.kind)}; this tracker reads local refs only`);
+    throw new Error(`${PREFIX8}: refused a ref of kind ${describeValue(ref.kind)}; this tracker reads local refs only`);
   }
   const number = typeof ref.externalId === "string" ? parseIssueNumber(ref.externalId) : null;
   if (number === null) {
-    throw new Error(`${PREFIX7}: externalId ${describeValue(ref.externalId)} is not a local issue number,` + " expected a positive whole number with no leading zero");
+    throw new Error(`${PREFIX8}: externalId ${describeValue(ref.externalId)} is not a local issue number,` + " expected a positive whole number with no leading zero");
   }
   return number;
 }
@@ -8510,7 +8706,7 @@ function createLocalTracker(options) {
     try {
       contents = await readFile3(path2, "utf8");
     } catch (cause) {
-      throw new Error(`${PREFIX7}: no issue ${number} under ${issuesDir}`, { cause });
+      throw new Error(`${PREFIX8}: no issue ${number} under ${issuesDir}`, { cause });
     }
     return { number, record: parseLocalIssue(contents, path2) };
   }
@@ -8545,7 +8741,7 @@ function createLocalTracker(options) {
             throw error;
         }
       }
-      throw new Error(`${PREFIX7}: no issue number is left under ${issuesDir}`);
+      throw new Error(`${PREFIX8}: no issue number is left under ${issuesDir}`);
     },
     get: async (ref) => {
       const { record } = await read(ref);
@@ -8728,20 +8924,20 @@ function projectLogDirName(repoRoot) {
   return repoRoot.replace(LOG_DIR_SEPARATORS, "-");
 }
 function sessionLogDir(repoRoot, home = homedir2()) {
-  return join17(home, ...PROJECT_LOG_ROOT, projectLogDirName(repoRoot));
+  return join18(home, ...PROJECT_LOG_ROOT, projectLogDirName(repoRoot));
 }
 function listSessionLogs(dir) {
   if (!existsSync11(dir)) {
     throw new Error(`effort collect: no session log directory at ${dir}` + " (pass logDir, or run with --no-sessions)");
   }
   const candidates = [];
-  for (const entry of readdirSync2(dir, { withFileTypes: true })) {
+  for (const entry of readdirSync3(dir, { withFileTypes: true })) {
     if (!entry.isFile())
       continue;
     if (!SESSION_LOG_NAME.test(entry.name))
       continue;
-    const path2 = join17(dir, entry.name);
-    const stats = statSync7(path2);
+    const path2 = join18(dir, entry.name);
+    const stats = statSync8(path2);
     candidates.push({
       path: path2,
       sessionId: sessionIdFromPath(path2),
@@ -8839,7 +9035,7 @@ function parseCollectArgs(args) {
   };
 }
 function readPlanStubs(plansDir) {
-  return existsSync11(plansDir) ? planStubsFromFileNames(readdirSync2(plansDir)) : [];
+  return existsSync11(plansDir) ? planStubsFromFileNames(readdirSync3(plansDir)) : [];
 }
 async function collectSessionRow(candidate, planStubs) {
   const enqueue = await findFirstEnqueue(readLines2(candidate.path));
@@ -8920,7 +9116,7 @@ function resolveSources(options, log) {
   if (store !== undefined && plansDir !== undefined)
     return { store, plansDir };
   const { config } = loadConfig({ root, home: options.home }, {}, log);
-  return { store: store ?? selectEffortStore(root, config), plansDir: plansDir ?? resolve9(root, config.planDir) };
+  return { store: store ?? selectEffortStore(root, config), plansDir: plansDir ?? resolve10(root, config.planDir) };
 }
 async function collectEffort(options) {
   const { repoRoot } = options;
@@ -10048,15 +10244,15 @@ var report_default = wrapPhaseZeroCommand({
 // src/commands/init.ts
 import { existsSync as existsSync17, readFileSync as readFileSync16 } from "fs";
 import { homedir as homedir4 } from "os";
-import { join as join22, relative as relative2, sep as sep3 } from "path";
+import { join as join23, relative as relative2, sep as sep3 } from "path";
 
 // src/agents/vendorable.ts
-import { readdirSync as readdirSync3, readFileSync as readFileSync12 } from "fs";
-import { isAbsolute as isAbsolute5, join as join18 } from "path";
+import { readdirSync as readdirSync4, readFileSync as readFileSync12 } from "fs";
+import { isAbsolute as isAbsolute5, join as join19 } from "path";
 function planFiles(dir) {
   let entries;
   try {
-    entries = readdirSync3(dir, { withFileTypes: true });
+    entries = readdirSync4(dir, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -10070,11 +10266,11 @@ function readText3(path2) {
   }
 }
 function vendorableAgents(scan) {
-  const dir = isAbsolute5(scan.planDir) ? scan.planDir : join18(scan.repoRoot, scan.planDir);
+  const dir = isAbsolute5(scan.planDir) ? scan.planDir : join19(scan.repoRoot, scan.planDir);
   const roster = resolveAgentRoster({ repoRoot: scan.repoRoot, home: scan.home }, scan.settingSources);
   const found = [];
   for (const file of planFiles(dir)) {
-    const path2 = join18(dir, file);
+    const path2 = join19(dir, file);
     const markdown = readText3(path2);
     if (markdown === null)
       continue;
@@ -10100,12 +10296,12 @@ function vendorableAgentWarnings(agents, root) {
 
 // src/project/gitignore.ts
 import { createHash } from "crypto";
-import { existsSync as existsSync15, mkdirSync as mkdirSync7, readFileSync as readFileSync13, writeFileSync as writeFileSync5 } from "fs";
-import { dirname as dirname8, isAbsolute as isAbsolute6, join as join19 } from "path";
+import { existsSync as existsSync15, mkdirSync as mkdirSync8, readFileSync as readFileSync13, writeFileSync as writeFileSync5 } from "fs";
+import { dirname as dirname8, isAbsolute as isAbsolute6, join as join20 } from "path";
 var GITIGNORE_FILE = ".gitignore";
 var DIGEST_NAME = "tracking.digest";
 var PRIVATE_TRIAGE = "triage/private";
-var TRACKING_DIGEST_FILE = join19(SCOPE_DIR, DIGEST_NAME);
+var TRACKING_DIGEST_FILE = join20(SCOPE_DIR, DIGEST_NAME);
 var BLOCK_BEGIN = "# >>> rafa tracking: rafa rewrites the lines up to the end marker";
 var BLOCK_END = "# <<< rafa tracking";
 var SUB_PATHS = [
@@ -10193,7 +10389,7 @@ function readIfPresent3(file) {
 }
 function writeTrackingGitignore(root, flags) {
   requireAbsolute2(root);
-  const file = join19(root, GITIGNORE_FILE);
+  const file = join20(root, GITIGNORE_FILE);
   const text2 = readIfPresent3(file);
   const next = withTrackingBlock(text2, flags, file);
   if (next === text2)
@@ -10215,7 +10411,7 @@ function trackingDigest(flags) {
 }
 function exposureNotice(root) {
   return [
-    `tracking.all is true, so ${join19(root, GITIGNORE_FILE)} no longer ignores ${SCOPE_DIR}/` + " and a commit can carry what it holds, including:",
+    `tracking.all is true, so ${join20(root, GITIGNORE_FILE)} no longer ignores ${SCOPE_DIR}/` + " and a commit can carry what it holds, including:",
     "  - unpatched issues described in specs and plans",
     "  - effort rows with model names and token counts",
     "  - instincts that may quote error output",
@@ -10228,7 +10424,7 @@ function printWarning2(message) {
 }
 function noticeTrackingChange(root, flags, print = printWarning2) {
   requireAbsolute2(root);
-  const digestFile = join19(root, TRACKING_DIGEST_FILE);
+  const digestFile = join20(root, TRACKING_DIGEST_FILE);
   const recorded = `${trackingDigest(flags)}
 `;
   if (readIfPresent3(digestFile) === recorded) {
@@ -10237,7 +10433,7 @@ function noticeTrackingChange(root, flags, print = printWarning2) {
   if (flags.trackingAll)
     print(exposureNotice(root));
   attempt(digestFile, "cannot be written", () => {
-    mkdirSync7(dirname8(digestFile), { recursive: true });
+    mkdirSync8(dirname8(digestFile), { recursive: true });
     writeFileSync5(digestFile, recorded);
   });
   return { digestFile, changed: true, printed: flags.trackingAll };
@@ -10248,13 +10444,13 @@ function applyTracking(root, flags, print = printWarning2) {
 }
 
 // src/project/root-choice.ts
-import { resolve as resolve11 } from "path";
+import { resolve as resolve12 } from "path";
 import { createInterface as createInterface2 } from "readline";
 
 // src/project/roots.ts
 import { spawnSync as spawnSync2 } from "child_process";
-import { accessSync, constants, readFileSync as readFileSync14, statSync as statSync8 } from "fs";
-import { isAbsolute as isAbsolute7, join as join20, resolve as resolve10 } from "path";
+import { accessSync, constants, readFileSync as readFileSync14, statSync as statSync9 } from "fs";
+import { isAbsolute as isAbsolute7, join as join21, resolve as resolve11 } from "path";
 var REFUSED_ROOTS = Object.freeze([
   { path: "/", why: "is the filesystem root" },
   { path: "/var", why: "holds system state" },
@@ -10275,7 +10471,7 @@ var NOT_A_REPOSITORY = "fatal: not a git repository (or any ";
 var DISK_ROOTS_FILE_SYSTEM = Object.freeze({
   ...DISK_FILE_SYSTEM,
   readFile: (path2) => readFileSync14(path2, "utf8"),
-  isDirectory: (path2) => statSync8(path2).isDirectory(),
+  isDirectory: (path2) => statSync9(path2).isDirectory(),
   assertWritable: (path2) => accessSync(path2, constants.W_OK)
 });
 
@@ -10317,7 +10513,7 @@ function realOrSpelled(path2, fs2) {
   try {
     return fs2.realpath(path2);
   } catch {
-    return resolve10(path2);
+    return resolve11(path2);
   }
 }
 function namedRoots(home, fs2) {
@@ -10359,7 +10555,7 @@ function writeRefusal(given, real, fs2) {
 }
 function refusalOf(given, named, fs2) {
   const resolved = resolveReal(given, fs2);
-  const byName = namedRefusal(given, resolved.real ?? resolve10(given), named);
+  const byName = namedRefusal(given, resolved.real ?? resolve11(given), named);
   if (byName !== null)
     return byName;
   if (resolved.real === null) {
@@ -10387,8 +10583,8 @@ function readManifest(file, fs2) {
   }
 }
 function readDir(dir, fs2) {
-  const manifest = readManifest(join20(dir, PACKAGE_JSON), fs2);
-  const files = MONOREPO_MARKER_FILES.filter((name2) => fs2.exists(join20(dir, name2)));
+  const manifest = readManifest(join21(dir, PACKAGE_JSON), fs2);
+  const files = MONOREPO_MARKER_FILES.filter((name2) => fs2.exists(join21(dir, name2)));
   const markers = manifest.marks ? [PACKAGE_JSON, ...files] : files;
   return { ...manifest, dir, markers };
 }
@@ -10458,7 +10654,7 @@ function firstCandidate(found) {
   return first.refusal === null ? chosen(first.path, first.source) : problem(first.refusal.reason);
 }
 function namedRoot(typed, start, source, seams) {
-  const path2 = resolve11(start, typed);
+  const path2 = resolve12(start, typed);
   const refusal3 = rootRefusal(path2, seams);
   if (refusal3 !== null)
     return problem(refusal3.reason);
@@ -10537,8 +10733,8 @@ function createLinePrompter(input, output) {
 }
 
 // src/project/scaffold.ts
-import { existsSync as existsSync16, lstatSync as lstatSync2, mkdirSync as mkdirSync8, statSync as statSync9, writeFileSync as writeFileSync6 } from "fs";
-import { join as join21 } from "path";
+import { existsSync as existsSync16, lstatSync as lstatSync2, mkdirSync as mkdirSync9, statSync as statSync10, writeFileSync as writeFileSync6 } from "fs";
+import { join as join22 } from "path";
 var PROJECT_TREE = Object.freeze(["specs", "plans", "runs", "effort", "instincts"]);
 var USER_TREE = Object.freeze(["instincts"]);
 var CONFIG_SETTINGS_LINES = Object.freeze([
@@ -10617,13 +10813,13 @@ class ScaffoldError extends Error {
 }
 function layoutOf(base, tree) {
   const scope = scopeAt(base);
-  return { dirs: [scope.dir, ...tree.map((name2) => join21(scope.dir, name2))], configFile: configFilePath(base) };
+  return { dirs: [scope.dir, ...tree.map((name2) => join22(scope.dir, name2))], configFile: configFilePath(base) };
 }
 function occupied(path2) {
   return lstatSync2(path2, { throwIfNoEntry: false }) !== undefined;
 }
 function isDirectory(path2) {
-  return statSync9(path2, { throwIfNoEntry: false })?.isDirectory() === true;
+  return statSync10(path2, { throwIfNoEntry: false })?.isDirectory() === true;
 }
 function directoryConflict(dir) {
   if (!occupied(dir) || isDirectory(dir))
@@ -10653,7 +10849,7 @@ function ensureDirectory(path2) {
   if (existsSync16(path2))
     return { path: path2, kind: "directory", change: "unchanged" };
   attempt2(path2, "cannot be created", () => {
-    mkdirSync8(path2, { recursive: true });
+    mkdirSync9(path2, { recursive: true });
   });
   return { path: path2, kind: "directory", change: "created" };
 }
@@ -10681,17 +10877,17 @@ function writeUserScope(home) {
 import { writeFileSync as writeFileSync7 } from "fs";
 
 // src/release/enabled.ts
-import { statSync as statSync10 } from "fs";
-import { resolve as resolve12 } from "path";
+import { statSync as statSync11 } from "fs";
+import { resolve as resolve13 } from "path";
 function isRegularFile(full) {
   try {
-    return statSync10(full).isFile();
+    return statSync11(full).isFile();
   } catch {
     return false;
   }
 }
 function readFile4(repoRoot, path2) {
-  const resolved = resolve12(repoRoot, path2);
+  const resolved = resolve13(repoRoot, path2);
   return { path: path2, resolved, present: isRegularFile(resolved) };
 }
 function resolveReleaseEnabled(settings, repoRoot) {
@@ -10992,7 +11188,7 @@ function resolvedConfig4(root, home, warn) {
   }
 }
 function checkGitignore(root, flags) {
-  const file = join22(root, GITIGNORE_FILE);
+  const file = join23(root, GITIGNORE_FILE);
   try {
     const text2 = existsSync17(file) ? readFileSync16(file, "utf8") : null;
     withTrackingBlock(text2, flags, file);
@@ -11026,7 +11222,7 @@ function initialise(root, start, home, context) {
   const config = resolvedConfig4(root.path, home, warn);
   checkGitignore(root.path, config);
   const configExisted = existsSync17(configFilePath(root.path));
-  const digestExisted = existsSync17(join22(root.path, TRACKING_DIGEST_FILE));
+  const digestExisted = existsSync17(join23(root.path, TRACKING_DIGEST_FILE));
   const project = writeProjectScope(root.path);
   const tracking = applyTracking(root.path, config, warn);
   const writes = [...project, ...trackingWrites(tracking, digestExisted), ...writeUserScope(home)];
@@ -11179,11 +11375,11 @@ function createInitCommand(seams = DEFAULT_INIT_SEAMS) {
 var init_default = createInitCommand();
 
 // src/commands/check-report.ts
-import { resolve as resolve14 } from "path";
+import { resolve as resolve15 } from "path";
 
 // src/check/references.ts
-import { existsSync as existsSync18, statSync as statSync11 } from "fs";
-import { delimiter as delimiter2, isAbsolute as isAbsolute8, relative as relative3, resolve as resolve13 } from "path";
+import { existsSync as existsSync18, statSync as statSync12 } from "fs";
+import { delimiter as delimiter2, isAbsolute as isAbsolute8, relative as relative3, resolve as resolve14 } from "path";
 
 // src/schema/stack.ts
 var LANGUAGE_EXTENSIONS = {
@@ -11626,12 +11822,12 @@ function isAbsoluteReference(token) {
   return KNOWN_ROOTS.includes(`/${first}`) || EXTENSION.test(token);
 }
 function isInside(root, target) {
-  const step = relative3(resolve13(root), resolve13(target));
+  const step = relative3(resolve14(root), resolve14(target));
   return step !== "" && !step.startsWith("..") && !isAbsolute8(step);
 }
 function isExecutableFile(path2) {
   try {
-    const stats = statSync11(path2);
+    const stats = statSync12(path2);
     return stats.isFile() && (stats.mode & 73) !== 0;
   } catch {
     return false;
@@ -11751,21 +11947,21 @@ function issueOf2(code, ref, sentence) {
   };
 }
 function scriptIssue(ref, skillDir) {
-  if (existsSync18(resolve13(skillDir, ref.text)))
+  if (existsSync18(resolve14(skillDir, ref.text)))
     return null;
   return issueOf2("missing-script", ref, `${ref.text} names nothing under the skill directory`);
 }
 function isSkillPath(token, skillDir) {
-  const target = resolve13(skillDir, token);
+  const target = resolve14(skillDir, token);
   if (!isInside(skillDir, target))
     return false;
   if (existsSync18(target))
     return true;
   const head = token.split("/")[0] ?? "";
-  return head !== "" && head !== "." && head !== ".." && existsSync18(resolve13(skillDir, head));
+  return head !== "" && head !== "." && head !== ".." && existsSync18(resolve14(skillDir, head));
 }
 function projectPathIssue(ref, projectRoot) {
-  const target = resolve13(projectRoot, ref.text);
+  const target = resolve14(projectRoot, ref.text);
   if (!isInside(projectRoot, target)) {
     return issueOf2("unresolved-path", ref, `${ref.text} points outside the project root`);
   }
@@ -11809,7 +12005,7 @@ function isOffStack(stack) {
 function toolIssue(ref, pathDirs, functions, offStack) {
   if (functions.has(ref.text))
     return null;
-  if (pathDirs.some((dir) => isExecutableFile(resolve13(dir, ref.text))))
+  if (pathDirs.some((dir) => isExecutableFile(resolve14(dir, ref.text))))
     return null;
   if (offStack) {
     return issueOf2("missing-tool-off-stack", ref, `the command ${ref.text} is in no directory of the PATH this run was given,` + " and this file declares a stack this machine need not carry");
@@ -11843,7 +12039,7 @@ function checkReferences(body, seams) {
 
 // src/check/run.ts
 import { readFileSync as readFileSync17, writeFileSync as writeFileSync8 } from "fs";
-import { basename as basename7, dirname as dirname9 } from "path";
+import { basename as basename8, dirname as dirname9 } from "path";
 
 // src/schema/instinct.ts
 import { createHash as createHash2 } from "crypto";
@@ -12370,8 +12566,8 @@ function checkSkillFrontmatter(data) {
 }
 
 // src/check/layout.ts
-import { readdirSync as readdirSync4, statSync as statSync12 } from "fs";
-import { join as join23, relative as relative4 } from "path";
+import { readdirSync as readdirSync5, statSync as statSync13 } from "fs";
+import { join as join24, relative as relative4 } from "path";
 var SKILL_FILE = "SKILL.md";
 var MARKDOWN_EXTENSION = ".md";
 var LAYOUT_SEVERITY = Object.freeze({
@@ -12389,7 +12585,7 @@ function layoutIssue(code, message) {
 }
 function entryKind(path2) {
   try {
-    const stats = statSync12(path2);
+    const stats = statSync13(path2);
     if (stats.isFile())
       return "file";
     if (stats.isDirectory())
@@ -12400,7 +12596,7 @@ function entryKind(path2) {
   }
 }
 function visibleNames(dir) {
-  return readdirSync4(dir).filter((name2) => !name2.startsWith(".")).sort((left, right) => left.localeCompare(right));
+  return readdirSync5(dir).filter((name2) => !name2.startsWith(".")).sort((left, right) => left.localeCompare(right));
 }
 function isMarkdown(name2) {
   return name2.endsWith(MARKDOWN_EXTENSION);
@@ -12488,7 +12684,7 @@ function scanGroupMember(root, dir, name2) {
   const children = visibleNames(dir);
   if (children.length === 0)
     return [dotfileOnlyEntry("skill", root, dir)];
-  const skillPath = join23(dir, SKILL_FILE);
+  const skillPath = join24(dir, SKILL_FILE);
   if (children.includes(SKILL_FILE) && entryKind(skillPath) === "file") {
     return [nestedGroupEntry(root, skillPath, name2)];
   }
@@ -12497,7 +12693,7 @@ function scanGroupMember(root, dir, name2) {
 function scanSkillGroup(root, dir, children) {
   const entries = [];
   for (const child of children) {
-    const path2 = join23(dir, child);
+    const path2 = join24(dir, child);
     const found = entryKind(path2);
     if (found === null) {
       entries.push(unreadableEntry("skill", root, path2));
@@ -12518,7 +12714,7 @@ function scanSkillDirectory(root, dir, name2) {
   const children = visibleNames(dir);
   if (children.length === 0)
     return [dotfileOnlyEntry("skill", root, dir)];
-  const skillPath = join23(dir, SKILL_FILE);
+  const skillPath = join24(dir, SKILL_FILE);
   if (children.includes(SKILL_FILE) && entryKind(skillPath) === "file") {
     return [skillFileEntry(skillPath, name2)];
   }
@@ -12527,7 +12723,7 @@ function scanSkillDirectory(root, dir, name2) {
 function scanSkillRoot(root) {
   const entries = [];
   for (const name2 of visibleNames(root)) {
-    const path2 = join23(root, name2);
+    const path2 = join24(root, name2);
     const found = entryKind(path2);
     if (found === null) {
       entries.push(unreadableEntry("skill", root, path2));
@@ -12548,7 +12744,7 @@ function scanInstinctSubdirectory(root, dir) {
     return [dotfileOnlyEntry("instinct", root, dir)];
   const entries = [];
   for (const child of children) {
-    const path2 = join23(dir, child);
+    const path2 = join24(dir, child);
     const found = entryKind(path2);
     if (found === null) {
       entries.push(unreadableEntry("instinct", root, path2));
@@ -12566,7 +12762,7 @@ function scanInstinctSubdirectory(root, dir) {
 function scanInstinctRoot(root) {
   const entries = [];
   for (const name2 of visibleNames(root)) {
-    const path2 = join23(root, name2);
+    const path2 = join24(root, name2);
     const found = entryKind(path2);
     if (found === null) {
       entries.push(unreadableEntry("instinct", root, path2));
@@ -12672,7 +12868,7 @@ function isMarkdown2(name2) {
   return name2.endsWith(MARKDOWN_EXTENSION);
 }
 function fileEntry(path2, kind) {
-  const base = basename7(path2);
+  const base = basename8(path2);
   const stem = isMarkdown2(base) ? base.slice(0, -MARKDOWN_EXTENSION.length) : base;
   if (kind === "instinct") {
     return {
@@ -12684,10 +12880,10 @@ function fileEntry(path2, kind) {
       issues: []
     };
   }
-  return base === SKILL_FILE ? { kind, path: path2, isFile: true, shape: "skill-file", name: basename7(dirname9(path2)), issues: [] } : { kind, path: path2, isFile: true, shape: "loose-file", name: stem, issues: [] };
+  return base === SKILL_FILE ? { kind, path: path2, isFile: true, shape: "skill-file", name: basename8(dirname9(path2)), issues: [] } : { kind, path: path2, isFile: true, shape: "loose-file", name: stem, issues: [] };
 }
 function unregisteredIssue(path2, kind) {
-  const base = basename7(path2);
+  const base = basename8(path2);
   if (kind === "instinct") {
     return isMarkdown2(base) ? null : checkerIssue("layout", "unregistered-path", `${base} is not a ${MARKDOWN_EXTENSION} file, so it is no instinct record`);
   }
@@ -12696,7 +12892,7 @@ function unregisteredIssue(path2, kind) {
 function skillDirectoryOf(entry) {
   if (entry.kind !== "skill" || !entry.isFile)
     return null;
-  return basename7(entry.path) === SKILL_FILE ? dirname9(entry.path) : null;
+  return basename8(entry.path) === SKILL_FILE ? dirname9(entry.path) : null;
 }
 function declaredStack(data) {
   const value = data["stack"];
@@ -12857,7 +13053,7 @@ Usage: ${usage}`);
     throw new CommandExit(1, `\u274C Expected one directory, and read "${extra}" as a second
 Usage: ${usage}`);
   }
-  return resolve14(cwd(), dir);
+  return resolve15(cwd(), dir);
 }
 function readFix(value, usage) {
   if (value === undefined || value === false || value === "false")
@@ -12874,7 +13070,7 @@ function readProjectRoot(value, usage, cwd) {
     throw new CommandExit(1, `\u274C --project needs a path, and the line gave it none
 Usage: ${usage}`);
   }
-  return resolve14(cwd(), value);
+  return resolve15(cwd(), value);
 }
 function reportMarker(report2) {
   if (report2.failed)
@@ -12987,16 +13183,16 @@ function createInstinctCheckCommand(seams = DEFAULT_CHECK_SEAMS) {
 var check_default = createInstinctCheckCommand();
 
 // src/commands/instinct/instinct-records.ts
-import { readdirSync as readdirSync5, readFileSync as readFileSync18, statSync as statSync13 } from "fs";
-import { join as join25 } from "path";
+import { readdirSync as readdirSync6, readFileSync as readFileSync18, statSync as statSync14 } from "fs";
+import { join as join26 } from "path";
 
 // src/schema/tiers.ts
 import { existsSync as existsSync19, realpathSync as realpathSync3 } from "fs";
-import { dirname as dirname10, join as join24 } from "path";
+import { dirname as dirname10, join as join25 } from "path";
 var SKILL_TIERS = ["project", "rafa", "user"];
 var INSTINCT_SCOPES2 = ["project", "user"];
-var CLAUDE_SKILLS_PATH = join24(".claude", "skills");
-var RAFA_INSTINCTS_PATH = join24(".rafa", "instincts");
+var CLAUDE_SKILLS_PATH = join25(".claude", "skills");
+var RAFA_INSTINCTS_PATH = join25(".rafa", "instincts");
 var BUNDLED_SKILLS_DIR = "skills";
 function isSkillTier(value) {
   return SKILL_TIERS.includes(value);
@@ -13009,14 +13205,14 @@ function realEntry(entry) {
   }
 }
 function bundledSkillsDirectory(entry) {
-  return join24(dirname10(realEntry(entry ?? Bun.main)), BUNDLED_SKILLS_DIR);
+  return join25(dirname10(realEntry(entry ?? Bun.main)), BUNDLED_SKILLS_DIR);
 }
 function skillTierDirectory(tier, seams) {
   if (tier === "user")
-    return join24(seams.home, CLAUDE_SKILLS_PATH);
+    return join25(seams.home, CLAUDE_SKILLS_PATH);
   if (tier === "rafa")
     return bundledSkillsDirectory(seams.entry);
-  return seams.projectRoot === null ? null : join24(seams.projectRoot, CLAUDE_SKILLS_PATH);
+  return seams.projectRoot === null ? null : join25(seams.projectRoot, CLAUDE_SKILLS_PATH);
 }
 function resolveSkillTiers(seams) {
   const located = [];
@@ -13029,8 +13225,8 @@ function resolveSkillTiers(seams) {
 }
 function instinctScopeDirectory(scope, seams) {
   if (scope === "user")
-    return join24(seams.home, RAFA_INSTINCTS_PATH);
-  return seams.projectRoot === null ? null : join24(seams.projectRoot, RAFA_INSTINCTS_PATH);
+    return join25(seams.home, RAFA_INSTINCTS_PATH);
+  return seams.projectRoot === null ? null : join25(seams.projectRoot, RAFA_INSTINCTS_PATH);
 }
 function resolveInstinctScopes(seams) {
   const located = [];
@@ -13068,13 +13264,13 @@ function readRecord(path2, scope, id) {
 }
 function isFile2(path2) {
   try {
-    return statSync13(path2).isFile();
+    return statSync14(path2).isFile();
   } catch {
     return false;
   }
 }
 function recordFiles(dir) {
-  return readdirSync5(dir).filter((name2) => isRecordFile(name2) && isFile2(join25(dir, name2))).sort((left, right) => left.localeCompare(right));
+  return readdirSync6(dir).filter((name2) => isRecordFile(name2) && isFile2(join26(dir, name2))).sort((left, right) => left.localeCompare(right));
 }
 function readScope(scope, dir) {
   if (!tierExists(dir))
@@ -13083,7 +13279,7 @@ function readScope(scope, dir) {
     scope,
     dir,
     exists: true,
-    records: recordFiles(dir).map((name2) => readRecord(join25(dir, name2), scope, recordId(name2)))
+    records: recordFiles(dir).map((name2) => readRecord(join26(dir, name2), scope, recordId(name2)))
   };
 }
 function readScopes(seams) {
@@ -13310,7 +13506,7 @@ function createInstinctShowCommand() {
 var show_default = createInstinctShowCommand();
 
 // src/adapters/tracker/resolve.ts
-var PREFIX8 = "tracker chain";
+var PREFIX9 = "tracker chain";
 var FAILURE_SEPARATOR = "; ";
 function warnThroughActiveOutput4(message) {
   activeOutput().warn(message);
@@ -13351,9 +13547,9 @@ async function resolveTracker(options) {
     }
     attempts = [...attempts, Object.freeze({ kind, ok: false, reason: outcome.reason })];
     failures = [...failures, `${kind}: ${outcome.reason}`];
-    log(`${PREFIX8}: ${kind} unavailable: ${outcome.reason}`);
+    log(`${PREFIX9}: ${kind} unavailable: ${outcome.reason}`);
   }
-  throw new Error(`${PREFIX8}: no tracker available; tried ${failures.join(FAILURE_SEPARATOR)}`);
+  throw new Error(`${PREFIX9}: no tracker available; tried ${failures.join(FAILURE_SEPARATOR)}`);
 }
 
 // src/commands/issue/issue-tracker.ts
@@ -13507,7 +13703,7 @@ function createIssueCommentCommand(seams = DEFAULT_ISSUE_SEAMS) {
 var comment_default = createIssueCommentCommand();
 
 // src/triage/triage.ts
-import { basename as basename8, join as join26 } from "path";
+import { basename as basename9, join as join27 } from "path";
 
 // src/effort/store/tracker-refs.ts
 import { randomUUID as randomUUID3 } from "crypto";
@@ -13712,7 +13908,7 @@ function machineFaultSentence(fault) {
 }
 
 // src/triage/triage.ts
-var PRIVATE_TRIAGE_DIR = join26(".rafa", "triage", "private");
+var PRIVATE_TRIAGE_DIR = join27(".rafa", "triage", "private");
 var SECRET_ENV_NAMES = ["GITHUB_TOKEN", "ANTHROPIC_API_KEY", "LINEAR_API_KEY"];
 var TRIAGE_MODULE = "unassigned";
 var BLOCKER_SEPARATOR = "; ";
@@ -13723,7 +13919,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 join26(repoRoot, PRIVATE_TRIAGE_DIR);
+  return join27(repoRoot, PRIVATE_TRIAGE_DIR);
 }
 function createPrivateTriageTracker(repoRoot, options = {}) {
   return createLocalTracker({
@@ -13786,7 +13982,7 @@ function oneLine3(text2) {
   return text2.replace(/\s+/g, " ").trim();
 }
 function bugKeyOf(trackerPath, artifact) {
-  return `${basename8(trackerPath)}${KEY_SEPARATOR}${oneLine3(artifact)}`;
+  return `${basename9(trackerPath)}${KEY_SEPARATOR}${oneLine3(artifact)}`;
 }
 function fenced(value) {
   const runs = Array.from(value.matchAll(/`+/g), (run) => run[0].length);
@@ -14225,7 +14421,7 @@ function createIssueMoveCommand(seams = DEFAULT_ISSUE_SEAMS) {
 var move_default = createIssueMoveCommand();
 
 // src/board/issue-board.ts
-var PREFIX9 = "board issue";
+var PREFIX10 = "board issue";
 var REPO_PATH2 = "{owner}/{repo}";
 var COMMENT_ID = /^[1-9]\d*$/;
 function detailOf7(result, command) {
@@ -14233,29 +14429,29 @@ function detailOf7(result, command) {
   return written === "" ? `${command} failed and wrote nothing` : `${command} failed: ${written}`;
 }
 function failure2(command, result) {
-  return new Error(`${PREFIX9}: ${detailOf7(result, command)}`);
+  return new Error(`${PREFIX10}: ${detailOf7(result, command)}`);
 }
 function issueNumber3(value, member) {
   if (!Number.isSafeInteger(value) || value < 1) {
-    throw new TypeError(`${PREFIX9}: ${member} refused issue number ${describeValue(value)}, expected a positive whole number`);
+    throw new TypeError(`${PREFIX10}: ${member} refused issue number ${describeValue(value)}, expected a positive whole number`);
   }
   return String(value);
 }
 function commentId(value) {
   if (typeof value !== "string" || !COMMENT_ID.test(value)) {
-    throw new TypeError(`${PREFIX9}: editComment refused comment id ${describeValue(value)},` + " expected a positive whole number with no leading zero");
+    throw new TypeError(`${PREFIX10}: editComment refused comment id ${describeValue(value)},` + " expected a positive whole number with no leading zero");
   }
   return value;
 }
 function commentBody2(value, member) {
   if (typeof value !== "string") {
-    throw new TypeError(`${PREFIX9}: ${member} refused a body ${describeValue(value)}, expected a string`);
+    throw new TypeError(`${PREFIX10}: ${member} refused a body ${describeValue(value)}, expected a string`);
   }
   return value;
 }
 function labelName(value, member, what) {
   if (typeof value !== "string" || value === "" || value.startsWith("-")) {
-    throw new TypeError(`${PREFIX9}: ${member} refused ${what} ${describeValue(value)},` + " expected a non-empty name that does not open with a hyphen");
+    throw new TypeError(`${PREFIX10}: ${member} refused ${what} ${describeValue(value)},` + " expected a non-empty name that does not open with a hyphen");
   }
   return value;
 }
@@ -14263,20 +14459,20 @@ function parseJson2(stdout, command) {
   try {
     return JSON.parse(stdout);
   } catch (error) {
-    throw new Error(`${PREFIX9}: ${command} wrote output that is not JSON: ${messageOf(error)}`, { cause: error });
+    throw new Error(`${PREFIX10}: ${command} wrote output that is not JSON: ${messageOf(error)}`, { cause: error });
   }
 }
 function readComment(value, command, where) {
   if (!isMapping(value)) {
-    throw new Error(`${PREFIX9}: ${command} answered ${where} as ${describeValue(value)}, expected a mapping`);
+    throw new Error(`${PREFIX10}: ${command} answered ${where} as ${describeValue(value)}, expected a mapping`);
   }
   const id = value["id"];
   if (typeof id !== "number" || !Number.isSafeInteger(id) || id < 1) {
-    throw new Error(`${PREFIX9}: ${command} answered ${where}.id as ${describeValue(id)}, expected a positive whole number`);
+    throw new Error(`${PREFIX10}: ${command} answered ${where}.id as ${describeValue(id)}, expected a positive whole number`);
   }
   const body = value["body"];
   if (typeof body !== "string") {
-    throw new Error(`${PREFIX9}: ${command} answered ${where}.body as ${describeValue(body)}, expected a string`);
+    throw new Error(`${PREFIX10}: ${command} answered ${where}.body as ${describeValue(body)}, expected a string`);
   }
   const user = value["user"];
   const login = isMapping(user) ? user["login"] : null;
@@ -14301,7 +14497,7 @@ function createGhIssueBoard(options) {
       const command = `gh api ${path2}`;
       const rows2 = parseJson2(await succeed(["api", path2], command), command);
       if (!Array.isArray(rows2)) {
-        throw new Error(`${PREFIX9}: ${command} answered ${describeValue(rows2)}, expected a list of comments`);
+        throw new Error(`${PREFIX10}: ${command} answered ${describeValue(rows2)}, expected a list of comments`);
       }
       return rows2.map((row2, index) => readComment(row2, command, `comment ${String(index)}`));
     },
@@ -14546,8 +14742,74 @@ function declinedMessage(alternative) {
   return `#${String(alternative)} was not planned, and nothing was written`;
 }
 
+// src/board/snapshot-settle.ts
+import { existsSync as existsSync21, readFileSync as readFileSync19, statSync as statSync15 } from "fs";
+import { resolve as resolve16 } from "path";
+var PREFIX11 = "board snapshot settle";
+var DATE_LENGTH = 10;
+function savedCopyDate(savedAt) {
+  return savedAt.toISOString().slice(0, DATE_LENGTH);
+}
+function refreshQuestion(issue3, savedAt) {
+  return `Issue #${String(issue3)} changed since the saved copy of ${savedCopyDate(savedAt)}.` + " Plan from it as it reads now? [y/N] ";
+}
+function notesRebuiltLine(path2, issue3, previous) {
+  return `local notes changed; rebuilt ${path2} from issue #${String(issue3)} and the notes,` + ` the old copy is at ${previous}`;
+}
+function readSavedCopy(absolute, path2) {
+  if (!existsSync21(absolute))
+    return null;
+  try {
+    const stat = statSync15(absolute);
+    if (!stat.isFile())
+      return null;
+    return { text: readFileSync19(absolute, "utf8"), savedAt: stat.mtime };
+  } catch (error) {
+    throw new Error(`${PREFIX11}: the saved copy ${path2} could not be read: ${messageOf(error)}`, { cause: error });
+  }
+}
+function printChange(change, output) {
+  for (const line of [change.bodyLine, change.notesLine]) {
+    if (line !== null)
+      output.info(line);
+  }
+}
+async function settleSpecSnapshot(options) {
+  const { repoRoot, specsDir, issue: issue3, refresh, output } = options;
+  const write = (rewrite) => writeSpecSnapshot({ repoRoot, specsDir, issue: issue3, refresh: rewrite });
+  const path2 = specPath(specsDir, issue3.number, issue3.title);
+  const notes = notesPath(specsDir, issue3.number);
+  if (path2 === notes)
+    return write(refresh);
+  const saved = readSavedCopy(resolve16(repoRoot, path2), path2);
+  if (saved === null)
+    return write(refresh);
+  const change = readSnapshotChange({
+    saved: saved.text,
+    body: issue3.body,
+    notes: readLocalNotes(repoRoot, specsDir, issue3.number),
+    notesPath: notes
+  });
+  if (change.kind === "unchanged")
+    return write(refresh);
+  printChange(change, output);
+  if (change.kind === "notes") {
+    const rebuilt = write(refresh);
+    if (rebuilt.previous !== null)
+      output.info(notesRebuiltLine(rebuilt.path, issue3.number, rebuilt.previous));
+    return rebuilt;
+  }
+  if (refresh)
+    return write(true);
+  const offer = options.offerRefresh ?? null;
+  const accepted2 = offer !== null && await offer({ issue: issue3.number, path: path2, savedAt: saved.savedAt });
+  if (!accepted2)
+    throw new CommandExit(ISSUE_REFUSAL_EXIT, snapshotDiffersMessage(path2, issue3.number));
+  return write(true);
+}
+
 // src/board/spec-source.ts
-var PREFIX10 = "board spec source";
+var PREFIX12 = "board spec source";
 var SOURCE_FLAGS = [SPEC_FLAG, ISSUE_FLAG, NEXT_FLAG];
 var SOURCE_REFUSAL_EXIT = 1;
 function severalSourcesMessage(given) {
@@ -14666,7 +14928,7 @@ async function settleBlockedPick(options) {
 async function pickRoadmapIssue(request, options, issues, output) {
   const seams = options.roadmap;
   if (seams === undefined) {
-    throw new TypeError(`${PREFIX10}: ${NEXT_FLAG} was resolved with no roadmap seams`);
+    throw new TypeError(`${PREFIX12}: ${NEXT_FLAG} was resolved with no roadmap seams`);
   }
   const roadmap = await resolveRoadmapIssue({
     configured: request.roadmap ?? seams.configured,
@@ -14739,7 +15001,14 @@ async function resolveSpecSource(options) {
     output.info(dryRunLine(describeIssue(read)));
     return stopped("dry-run");
   }
-  const snapshot = writeSpecSnapshot({ repoRoot, specsDir, issue: read, refresh });
+  const snapshot = await settleSpecSnapshot({
+    repoRoot,
+    specsDir,
+    issue: read,
+    refresh,
+    offerRefresh: options.offerRefresh ?? null,
+    output
+  });
   return Object.freeze({
     outcome: "spec",
     spec: Object.freeze({
@@ -14812,6 +15081,7 @@ async function resolvePlanSpec(options) {
   const offer = offerReady === null || options.dryRun ? undefined : (issue3) => offerReady({ issue: issue3, gh, trust: trust(), output });
   const offerAlternative = options.offerAlternative ?? null;
   const alternative = offerAlternative === null || options.dryRun ? undefined : offerAlternative;
+  const offerRefresh = options.dryRun ? null : options.offerRefresh ?? null;
   const resolution = await resolveSpecSource({
     request: options.request,
     refresh: options.refresh,
@@ -14821,6 +15091,7 @@ async function resolvePlanSpec(options) {
     findSpec: options.findSpec,
     issues: createGhSpecIssueReader({ gh }),
     inspect: (issue3) => inspectSpecIssue(issue3, trust(), offer),
+    offerRefresh,
     roadmap: {
       configured: options.roadmapIssue,
       search: createGhRoadmapSearch({ gh }),
@@ -14916,8 +15187,8 @@ function formatRows(rows2) {
 `);
 }
 function defaultSleep(ms) {
-  return new Promise((resolve15) => {
-    setTimeout(resolve15, ms);
+  return new Promise((resolve17) => {
+    setTimeout(resolve17, ms);
   });
 }
 async function waitForChecks(options) {
@@ -15163,7 +15434,7 @@ function compareUrl(remote, branch) {
   return `https://${segments[0] ?? host}/${path2}/compare/${encodeBranch(branch)}${COMPARE_QUERY}`;
 }
 // src/pr/gh.ts
-var PREFIX11 = "gh pull requests";
+var PREFIX13 = "gh pull requests";
 var REPO_PATH3 = "{owner}/{repo}";
 var SUMMARY_FIELDS = "author,baseRefName,headRefName,isCrossRepository,number,state,title,updatedAt,url";
 var DETAIL_FIELDS = `${SUMMARY_FIELDS},body,headRefOid,labels,mergeStateStatus,mergeable`;
@@ -15192,16 +15463,16 @@ function detailOf8(result, command) {
   return result.ok ? `${command} exited 0 and wrote nothing` : `${command} exited non-zero and wrote nothing`;
 }
 function failure3(command, result) {
-  return new Error(`${PREFIX11}: ${command} failed: ${detailOf8(result, command)}`);
+  return new Error(`${PREFIX13}: ${command} failed: ${detailOf8(result, command)}`);
 }
 function refuse3(command, problem2) {
-  throw new Error(`${PREFIX11}: ${command} answered ${problem2}`);
+  throw new Error(`${PREFIX13}: ${command} answered ${problem2}`);
 }
 function parseJson3(stdout, command) {
   try {
     return JSON.parse(stdout);
   } catch (error) {
-    throw new Error(`${PREFIX11}: ${command} wrote output that is not JSON: ${messageOf(error)}`, { cause: error });
+    throw new Error(`${PREFIX13}: ${command} wrote output that is not JSON: ${messageOf(error)}`, { cause: error });
   }
 }
 function readString2(value, command, where) {
@@ -15304,7 +15575,7 @@ function readWorkflowCount(stdout) {
 }
 function pullNumber(value, member) {
   if (!Number.isSafeInteger(value) || value < 1) {
-    throw new TypeError(`${PREFIX11}: ${member} refused pull request number ${describeValue(value)},` + " expected a positive whole number");
+    throw new TypeError(`${PREFIX13}: ${member} refused pull request number ${describeValue(value)},` + " expected a positive whole number");
   }
   return String(value);
 }
@@ -15312,13 +15583,13 @@ function textArgument(value, member, what, whole) {
   const bad = typeof value !== "string" || value === "" || whole && !(WHOLE_NUMBER.test(value) && Number.isSafeInteger(Number(value)));
   if (bad) {
     const expected = whole ? "a positive whole number with no leading zero" : "a non-empty string";
-    throw new TypeError(`${PREFIX11}: ${member} refused ${what} ${describeValue(value)}, expected ${expected}`);
+    throw new TypeError(`${PREFIX13}: ${member} refused ${what} ${describeValue(value)}, expected ${expected}`);
   }
   return value;
 }
 function bodyText(value, member) {
   if (typeof value !== "string") {
-    throw new TypeError(`${PREFIX11}: ${member} refused a body ${describeValue(value)}, expected a string`);
+    throw new TypeError(`${PREFIX13}: ${member} refused a body ${describeValue(value)}, expected a string`);
   }
   return value;
 }
@@ -15388,7 +15659,7 @@ function createGhPullRequests(options) {
     merge: async (number, method) => {
       const target = pullNumber(number, "merge");
       if (!isMergeMethod(method)) {
-        throw new TypeError(`${PREFIX11}: merge refused method ${describeValue(method)},` + ` expected one of: ${MERGE_METHODS.join(", ")}`);
+        throw new TypeError(`${PREFIX13}: merge refused method ${describeValue(method)},` + ` expected one of: ${MERGE_METHODS.join(", ")}`);
       }
       const command = `gh pr merge ${target} --${method}`;
       const result = await gh(["pr", "merge", target, `--${method}`]);
@@ -15623,11 +15894,11 @@ function readStepOutcome(step2, result, plan) {
 
 // src/commands/loop/loop-sessions.ts
 import { execFileSync as execFileSync2 } from "child_process";
-import { readFileSync as readFileSync20 } from "fs";
-import { join as join28, relative as relative5 } from "path";
+import { readFileSync as readFileSync21 } from "fs";
+import { join as join29, relative as relative5 } from "path";
 
 // src/effort/store/task-finishes.ts
-import { existsSync as existsSync21 } from "fs";
+import { existsSync as existsSync22 } from "fs";
 var SELECT_FINISHES = `
   SELECT collected_at FROM task_reports
   WHERE plan_stub IS ? AND outcome = 'done' AND collected_at >= ?
@@ -15638,7 +15909,7 @@ var SELECT_FINISHES = `
 `;
 function readTaskFinishes(repoRoot, query) {
   const path2 = sqliteStorePath(repoRoot);
-  if (!existsSync21(path2))
+  if (!existsSync22(path2))
     return [];
   const bound = [query.planStub, query.since, query.planStub, query.since];
   const rows2 = withSqliteStore(path2, false, (db) => db.query(SELECT_FINISHES).all(...bound));
@@ -15647,15 +15918,15 @@ function readTaskFinishes(repoRoot, query) {
 
 // src/loop/sessions.ts
 import {
-  linkSync,
-  mkdirSync as mkdirSync9,
-  readdirSync as readdirSync6,
-  readFileSync as readFileSync19,
+  linkSync as linkSync2,
+  mkdirSync as mkdirSync10,
+  readdirSync as readdirSync7,
+  readFileSync as readFileSync20,
   renameSync as renameSync2,
   rmSync,
   writeFileSync as writeFileSync9
 } from "fs";
-import { basename as basename9, dirname as dirname11, join as join27 } from "path";
+import { basename as basename10, dirname as dirname11, join as join28 } from "path";
 var SESSION_STATES = Object.freeze(["running", "paused", "stopped", "done"]);
 var RUNS_DIR = "runs";
 var RECORD_EXTENSION = ".json";
@@ -15695,13 +15966,13 @@ function isSessionId(value) {
   return SESSION_ID_PATTERN.test(value);
 }
 function runsDir(root) {
-  return join27(scopeAt(root).dir, RUNS_DIR);
+  return join28(scopeAt(root).dir, RUNS_DIR);
 }
 function sessionFilePath(root, sessionId) {
   if (!isSessionId(sessionId)) {
     throw new Error(`session record: unusable session id ${JSON.stringify(sessionId)}`);
   }
-  return join27(runsDir(root), `${sessionId}${RECORD_EXTENSION}`);
+  return join28(runsDir(root), `${sessionId}${RECORD_EXTENSION}`);
 }
 function describeValue7(value) {
   return value === undefined ? "missing" : JSON.stringify(value) ?? String(value);
@@ -15732,7 +16003,7 @@ function sessionIdProblem(sessionId, file) {
   if (typeof sessionId !== "string" || !isSessionId(sessionId)) {
     return `sessionId is ${describeValue7(sessionId)}, expected a plain file name`;
   }
-  return basename9(file) === `${sessionId}${RECORD_EXTENSION}` ? null : `sessionId ${JSON.stringify(sessionId)} is not the file's name`;
+  return basename10(file) === `${sessionId}${RECORD_EXTENSION}` ? null : `sessionId ${JSON.stringify(sessionId)} is not the file's name`;
 }
 function planStubProblem(planStub2) {
   return planStub2 === null || typeof planStub2 === "string" && isStampableStub(planStub2) ? null : `planStub is ${describeValue7(planStub2)}, expected null or a plan stub`;
@@ -15803,7 +16074,7 @@ function readState2(record, isAlive = isPidAlive) {
 function readRecordFile(file) {
   let text2;
   try {
-    text2 = readFileSync19(file, "utf8");
+    text2 = readFileSync20(file, "utf8");
   } catch (error) {
     throw new SessionRecordError(file, `cannot be read: ${messageOf(error)}`);
   }
@@ -15811,7 +16082,7 @@ function readRecordFile(file) {
 }
 function recordNames(dir) {
   try {
-    return readdirSync6(dir);
+    return readdirSync7(dir);
   } catch (error) {
     if (errorCode(error) === "ENOENT")
       return [];
@@ -15824,7 +16095,7 @@ function byStart(a, b) {
 function readSessions(root, seams = {}) {
   const dir = runsDir(root);
   const isAlive = seams.isAlive ?? isPidAlive;
-  const records = recordNames(dir).filter((name2) => name2.endsWith(RECORD_EXTENSION)).map((name2) => readRecordFile(join27(dir, name2))).map((record) => Object.freeze({ ...record, state: readState2(record, isAlive) }));
+  const records = recordNames(dir).filter((name2) => name2.endsWith(RECORD_EXTENSION)).map((name2) => readRecordFile(join28(dir, name2))).map((record) => Object.freeze({ ...record, state: readState2(record, isAlive) }));
   return Object.freeze(records.sort(byStart));
 }
 function readSession(root, sessionId, seams = {}) {
@@ -15850,13 +16121,13 @@ function checkRecord(record, file) {
 }
 function writeRecordFile(file, record, isNew) {
   checkRecord(record, file);
-  mkdirSync9(dirname11(file), { recursive: true });
+  mkdirSync10(dirname11(file), { recursive: true });
   const temporary = `${file}.${process.pid}.tmp`;
   writeFileSync9(temporary, `${JSON.stringify(record, null, 2)}
 `);
   try {
     if (isNew)
-      linkSync(temporary, file);
+      linkSync2(temporary, file);
     else
       renameSync2(temporary, file);
   } finally {
@@ -16010,11 +16281,11 @@ function writeSession(root, record, change) {
   }
 }
 function readSessionChecklist(root, record) {
-  const plan = join28(root, record.plan);
+  const plan = join29(root, record.plan);
   const file = [trackerPathFor(plan), plan].find((path2) => isFile(path2));
   if (file === undefined)
     return null;
-  const content = readFileSync20(file, "utf8");
+  const content = readFileSync21(file, "utf8");
   return { file, tasks: parsePlan(content).tasks, lines: content.split(`
 `) };
 }
@@ -16052,7 +16323,7 @@ function etaLine(eta) {
 }
 
 // src/next/sources.ts
-var PREFIX12 = "rafa next";
+var PREFIX14 = "rafa next";
 var DEFAULT_BASE_BRANCH = "main";
 var DEFAULT_NEXT_SOURCE_SEAMS = Object.freeze({});
 function memoiseIssues2(issues) {
@@ -16090,7 +16361,7 @@ function ghNextBoard(options) {
 }
 function nextProject(context) {
   if (context.project === null)
-    throw new Error(`${PREFIX12} runs inside a project, and was handed none`);
+    throw new Error(`${PREFIX14} runs inside a project, and was handed none`);
   return context.project;
 }
 function nextConfig(project, warn) {
@@ -16100,7 +16371,7 @@ function nextConfig(project, warn) {
     if (!(error instanceof ConfigError))
       throw error;
     throw new CommandExit(1, [
-      `\u274C ${PREFIX12}: the config cannot be used:`,
+      `\u274C ${PREFIX14}: the config cannot be used:`,
       ...error.problems.map((problem2) => `   ${problem2}`)
     ].join(`
 `));
@@ -16119,33 +16390,38 @@ 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 });
-  return Object.freeze({
+  const board = () => ghNextBoard({ gh, git, configured: config.roadmapIssue });
+  const held = {
     base: config.prBase ?? DEFAULT_BASE_BRANCH,
     plans: plansDirAt(project.root, config.planDir),
     runs: () => readRecords(project.root, loop),
     git,
-    pulls: (seams.pullRequests ?? ghPullRequestsIn)(project.root),
-    board: ghNextBoard({ gh, git, configured: config.roadmapIssue })
+    pulls: (seams.pullRequests ?? ghPullRequestsIn)(project.root)
+  };
+  return Object.freeze({
+    ...held,
+    board: board(),
+    answer: () => Object.freeze({ ...held, board: board() })
   });
 }
 
 // src/commands/plan/list.ts
-import { existsSync as existsSync22, readdirSync as readdirSync7, readFileSync as readFileSync21 } from "fs";
-import { join as join29 } from "path";
+import { existsSync as existsSync23, readdirSync as readdirSync8, readFileSync as readFileSync22 } from "fs";
+import { join as join30 } from "path";
 var USAGE10 = "rafa plan list";
 function listing(dir, stub) {
-  const plan = join29(dir, planFileName(stub, false));
-  const trackerPath = join29(dir, planFileName(stub, true));
+  const plan = join30(dir, planFileName(stub, false));
+  const trackerPath = join30(dir, planFileName(stub, true));
   const tracker = isFile(trackerPath) ? trackerPath : null;
-  const planModel = parsePlan(readFileSync21(plan, "utf8"));
-  const counted3 = tracker === null ? planModel : parsePlan(readFileSync21(tracker, "utf8"));
+  const planModel = parsePlan(readFileSync22(plan, "utf8"));
+  const counted3 = tracker === null ? planModel : parsePlan(readFileSync22(tracker, "utf8"));
   return { stub, plan, tracker, tasks: countTasks(counted3.tasks), issues: planModel.issues.length };
 }
 function listPlans(plans) {
   const dir = plans.path;
-  if (!existsSync22(dir))
+  if (!existsSync23(dir))
     return { dir, plans: [] };
-  const stubs = readdirSync7(dir).filter((name2) => isFile(join29(dir, name2))).map((name2) => stubOfPlanFile(name2)).filter((stub) => stub !== null).sort((a, b) => a.localeCompare(b));
+  const stubs = readdirSync8(dir).filter((name2) => isFile(join30(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) {
@@ -16340,7 +16616,7 @@ function branchLabel(world) {
 }
 
 // src/next/state.ts
-var PREFIX13 = "rafa next";
+var PREFIX15 = "rafa next";
 var MAX_NAMED_FILES = 5;
 var NEXT_PRECONDITIONS = Object.freeze([
   "tree-modified",
@@ -16618,7 +16894,7 @@ async function readNextState(sources) {
     if (found !== null)
       return answer(found, world.problems());
   }
-  throw new Error(`${PREFIX13}: no row of the table answered, and the last row answers for every reading`);
+  throw new Error(`${PREFIX15}: no row of the table answered, and the last row answers for every reading`);
 }
 
 // src/next/hint.ts
@@ -16644,8 +16920,8 @@ function wantsHint(flags) {
 }
 var DEFAULT_HINT_SEAMS = Object.freeze({});
 function afterDelay(ms) {
-  return new Promise((resolve15) => {
-    setTimeout(resolve15, ms).unref();
+  return new Promise((resolve17) => {
+    setTimeout(resolve17, ms).unref();
   });
 }
 function silenced() {
@@ -16699,10 +16975,10 @@ async function nextStepHint(context, seams = DEFAULT_HINT_SEAMS) {
 }
 
 // src/next/actions.ts
-var PREFIX14 = "rafa next";
+var PREFIX16 = "rafa next";
 function needed(state, value, what) {
   if (value === null) {
-    throw new Error(`${PREFIX14}: state "${state.id}" proposes "${state.action}" and names no ${what}`);
+    throw new Error(`${PREFIX16}: state "${state.id}" proposes "${state.action}" and names no ${what}`);
   }
   return String(value);
 }
@@ -16752,12 +17028,12 @@ function actionContext(caller, command, argv) {
 async function runAction(caller, state) {
   const invocation = actionInvocation(state);
   if (invocation === null) {
-    throw new Error(`${PREFIX14}: the action "${state.action}" of state "${state.id}" runs no registered command`);
+    throw new Error(`${PREFIX16}: the action "${state.action}" of state "${state.id}" runs no registered command`);
   }
   const spec = ACTION_COMMANDS[invocation.action];
   const command = caller.registry.find(spec.subject, spec.action);
   if (command === undefined) {
-    throw new CommandExit(1, `\u274C ${PREFIX14}: the "${invocation.action}" step runs "rafa ${invocation.command}", which is registered by nothing`);
+    throw new CommandExit(1, `\u274C ${PREFIX16}: the "${invocation.action}" step runs "rafa ${invocation.command}", which is registered by nothing`);
   }
   await command.run(actionContext(caller, command, invocation.argv));
 }
@@ -17042,7 +17318,7 @@ var UNBLOCK_USAGE = "rafa issue unblock [<n>] [--all]";
 var ALL_FLAG = "all";
 var ISSUE_NUMBER4 = /^[1-9]\d*$/u;
 var YES_ANSWERS3 = ["y", "yes"];
-var PREFIX15 = "board unblock";
+var PREFIX17 = "board unblock";
 function nameIds2(ids) {
   return ids.map((id) => `#${String(id)}`).join(" ");
 }
@@ -17056,32 +17332,32 @@ function detailOf9(result, command) {
 async function rowsOf2(gh, args, command) {
   const result = await gh(args);
   if (!result.ok)
-    throw new Error(`${PREFIX15}: ${detailOf9(result, command)}`);
+    throw new Error(`${PREFIX17}: ${detailOf9(result, command)}`);
   let parsed;
   try {
     parsed = JSON.parse(result.stdout);
   } catch (error) {
-    throw new Error(`${PREFIX15}: ${command} wrote output that is not JSON: ${messageOf(error)}`, { cause: error });
+    throw new Error(`${PREFIX17}: ${command} wrote output that is not JSON: ${messageOf(error)}`, { cause: error });
   }
   if (!Array.isArray(parsed)) {
-    throw new Error(`${PREFIX15}: ${command} answered ${describeValue(parsed)}, expected a list of issues`);
+    throw new Error(`${PREFIX17}: ${command} answered ${describeValue(parsed)}, expected a list of issues`);
   }
   return parsed;
 }
 function rowNumber4(row2, command, where) {
   if (!isMapping(row2)) {
-    throw new Error(`${PREFIX15}: ${command} answered ${where} as ${describeValue(row2)}, expected a mapping`);
+    throw new Error(`${PREFIX17}: ${command} answered ${where} as ${describeValue(row2)}, expected a mapping`);
   }
   const number = row2["number"];
   if (typeof number !== "number" || !Number.isSafeInteger(number) || number < 1) {
-    throw new Error(`${PREFIX15}: ${command} answered ${where}.number as ${describeValue(number)}, expected a positive whole number`);
+    throw new Error(`${PREFIX17}: ${command} answered ${where}.number as ${describeValue(number)}, expected a positive whole number`);
   }
   return number;
 }
 function rowBody2(row2, command, where) {
   const body = isMapping(row2) ? row2["body"] : null;
   if (typeof body !== "string") {
-    throw new Error(`${PREFIX15}: ${command} answered ${where}.body as ${describeValue(body)}, expected a string`);
+    throw new Error(`${PREFIX17}: ${command} answered ${where}.body as ${describeValue(body)}, expected a string`);
   }
   return body;
 }
@@ -17723,9 +17999,9 @@ async function handleRedChecks(io, branch, prNumber, rows2) {
 }
 
 // src/start/runtime.ts
-import { existsSync as existsSync23, readdirSync as readdirSync8, realpathSync as realpathSync4, statSync as statSync14 } from "fs";
+import { existsSync as existsSync24, readdirSync as readdirSync9, realpathSync as realpathSync4, statSync as statSync16 } from "fs";
 import { homedir as homedir5 } from "os";
-import { isAbsolute as isAbsolute9, join as join30, relative as relative7, resolve as resolve15, sep as sep4 } from "path";
+import { isAbsolute as isAbsolute9, join as join31, relative as relative7, resolve as resolve17, sep as sep4 } from "path";
 
 // src/start/session.ts
 import { randomUUID as randomUUID4 } from "crypto";
@@ -17876,7 +18152,7 @@ function announcePlanIssues(planContent) {
 
 // src/start/runtime.ts
 var RUNTIME_FLAG = "--runtime";
-var RUNTIME_SUBDIR = join30(".rafa", "runtime");
+var RUNTIME_SUBDIR = join31(".rafa", "runtime");
 var RUNTIME_ENTRY = "cli.js";
 var SOURCE_DIR = "src";
 var RUNTIME_COMMAND = ["start"];
@@ -17903,7 +18179,7 @@ function resolveRuntime(value, places) {
     throw refusal5([`\u274C Refusing to start: \`--runtime\` names no runtime. Spell it ${SPELLING}.`]);
   }
   const isVersion = VERSION_SHAPE.test(value);
-  const named = isVersion ? join30(places.home, RUNTIME_SUBDIR, value, RUNTIME_ENTRY) : resolve15(places.cwd, value);
+  const named = isVersion ? join31(places.home, RUNTIME_SUBDIR, value, RUNTIME_ENTRY) : resolve17(places.cwd, value);
   refuseInsideSource(value, named, places);
   const entry = entryOf(value, named, isVersion, places.home);
   const real = realpathSync4(entry);
@@ -17914,7 +18190,7 @@ function entryOf(value, named, isVersion, home) {
   if (isVersion) {
     if (isFile3(named))
       return named;
-    const root = join30(home, RUNTIME_SUBDIR);
+    const root = join31(home, RUNTIME_SUBDIR);
     const installed = installedVersions(root);
     throw refusal5([
       `\u274C Refusing to start: \`--runtime=${value}\` names no installed runtime: ${named} is no file.`,
@@ -17923,7 +18199,7 @@ function entryOf(value, named, isVersion, home) {
   }
   if (isFile3(named))
     return named;
-  const inside = join30(named, RUNTIME_ENTRY);
+  const inside = join31(named, RUNTIME_ENTRY);
   if (isDirectory2(named) && isFile3(inside))
     return inside;
   throw refusal5([
@@ -17941,8 +18217,8 @@ function refuseInsideSource(value, path2, places) {
   ]);
 }
 function sourceDirs({ cwd, root }) {
-  const dirs = [join30(cwd, SOURCE_DIR), join30(root, SOURCE_DIR)];
-  const real = dirs.filter((dir) => existsSync23(dir)).map((dir) => realpathSync4(dir));
+  const dirs = [join31(cwd, SOURCE_DIR), join31(root, SOURCE_DIR)];
+  const real = dirs.filter((dir) => existsSync24(dir)).map((dir) => realpathSync4(dir));
   return [...new Set([...dirs, ...real])];
 }
 function isInside2(path2, dir) {
@@ -17951,21 +18227,21 @@ function isInside2(path2, dir) {
 }
 function installedVersions(root) {
   try {
-    return readdirSync8(root).filter((name2) => isFile3(join30(root, name2, RUNTIME_ENTRY))).sort((a, b) => a.localeCompare(b));
+    return readdirSync9(root).filter((name2) => isFile3(join31(root, name2, RUNTIME_ENTRY))).sort((a, b) => a.localeCompare(b));
   } catch {
     return [];
   }
 }
 function isFile3(path2) {
   try {
-    return statSync14(path2).isFile();
+    return statSync16(path2).isFile();
   } catch {
     return false;
   }
 }
 function isDirectory2(path2) {
   try {
-    return statSync14(path2).isDirectory();
+    return statSync16(path2).isDirectory();
   } catch {
     return false;
   }
@@ -17996,7 +18272,7 @@ function realOrResolved(path2) {
   try {
     return realpathSync4(path2);
   } catch {
-    return resolve15(path2);
+    return resolve17(path2);
   }
 }
 async function runRuntime(entry, words, run) {
@@ -18091,13 +18367,13 @@ import { fileURLToPath as fileURLToPath2 } from "url";
 import { homedir as homedir6 } from "os";
 
 // src/notices/notices.ts
-import { mkdirSync as mkdirSync10, readFileSync as readFileSync22, writeFileSync as writeFileSync10 } from "fs";
-import { dirname as dirname12, join as join31 } from "path";
+import { mkdirSync as mkdirSync11, readFileSync as readFileSync23, writeFileSync as writeFileSync10 } from "fs";
+import { dirname as dirname12, join as join32 } 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 join31(home, ".rafa", "notices.json");
+  return join32(home, ".rafa", "notices.json");
 }
 function isNoticeId(value) {
   return typeof value === "string" && NOTICE_IDS.includes(value);
@@ -18105,7 +18381,7 @@ function isNoticeId(value) {
 function readDismissed(home) {
   let raw;
   try {
-    raw = readFileSync22(noticesPath(home), "utf8");
+    raw = readFileSync23(noticesPath(home), "utf8");
   } catch {
     return [];
   }
@@ -18124,7 +18400,7 @@ function readDismissed(home) {
 function writeDismissed(home, ids) {
   const all = NOTICE_IDS.filter((id) => ids.includes(id) || readDismissed(home).includes(id));
   const path2 = noticesPath(home);
-  mkdirSync10(dirname12(path2), { recursive: true });
+  mkdirSync11(dirname12(path2), { recursive: true });
   writeFileSync10(path2, `${JSON.stringify({ dismissed: all }, null, 2)}
 `);
 }
@@ -18667,7 +18943,7 @@ import { randomUUID as randomUUID9 } from "crypto";
 
 // src/effort/store/absences.ts
 import { randomUUID as randomUUID5 } from "crypto";
-import { existsSync as existsSync24 } from "fs";
+import { existsSync as existsSync25 } from "fs";
 var ABSENCE_REASONS = {
   "no-block": true,
   "unclosed-block": true,
@@ -18726,13 +19002,13 @@ function writeReportAbsence(repoRoot, write, seams = {}) {
     write.outcome,
     collectedAt
   ];
-  const appended3 = withSqliteStore(path2, !existsSync24(path2), (db) => db.query(INSERT_ABSENCE).run(...values).changes);
+  const appended3 = withSqliteStore(path2, !existsSync25(path2), (db) => db.query(INSERT_ABSENCE).run(...values).changes);
   return { path: path2, appended: appended3, skipped: 1 - appended3 };
 }
 
 // src/effort/store/changes.ts
 import { randomUUID as randomUUID6 } from "crypto";
-import { existsSync as existsSync25 } from "fs";
+import { existsSync as existsSync26 } from "fs";
 var INSERT_CHANGE = `
   INSERT INTO changes (
     id, session_id, plan_stub, task_line,
@@ -18811,7 +19087,7 @@ var SELECT_PLAN_CHANGES = `
 `;
 function readPlanChanges(repoRoot, planStub2) {
   const path2 = sqliteStorePath(repoRoot);
-  if (!existsSync25(path2))
+  if (!existsSync26(path2))
     return [];
   const rows2 = withSqliteStore(path2, false, (db) => db.query(SELECT_PLAN_CHANGES).all(planStub2));
   return rows2.map((row2) => ({
@@ -18980,8 +19256,8 @@ function describeTaskReportRecord(record) {
 }
 
 // src/utils/progress.ts
-import { existsSync as existsSync26, writeFileSync as writeFileSync11 } from "fs";
-import { join as join32 } from "path";
+import { existsSync as existsSync27, writeFileSync as writeFileSync11 } from "fs";
+import { join as join33 } from "path";
 var PROGRESS_FILE_NAME = "progress.txt";
 var PROGRESS_CAP_BYTES = 16000;
 var LISTED_FIELDS = [
@@ -19023,7 +19299,7 @@ var ESCAPED_CODE_POINTS = new Set([
   8233
 ]);
 function progressFilePath(repoRoot) {
-  return join32(repoRoot, PROGRESS_FILE_NAME);
+  return join33(repoRoot, PROGRESS_FILE_NAME);
 }
 function escapeValue(value) {
   let escaped = "";
@@ -19084,7 +19360,7 @@ function renderProgressText(findings, capBytes = PROGRESS_CAP_BYTES) {
 }
 function readProgressFindings(repoRoot, planStub2) {
   const path2 = sqliteStorePath(repoRoot);
-  if (!existsSync26(path2))
+  if (!existsSync27(path2))
     return [];
   const rows2 = withSqliteStore(path2, false, (db) => {
     const query = db.query(SELECT_FINDINGS);
@@ -19111,20 +19387,20 @@ function writeProgress(repoRoot, planStub2) {
 
 // src/start/preflight.ts
 import { randomUUID as randomUUID8 } from "crypto";
-import { existsSync as existsSync27, readFileSync as readFileSync23 } from "fs";
+import { existsSync as existsSync28, readFileSync as readFileSync24 } from "fs";
 import { homedir as homedir7 } from "os";
-import { basename as basename10 } from "path";
+import { basename as basename11 } from "path";
 var KNOWN_MISSING_SENTENCE = "A known-missing item is neither a bug to fix nor a credential to patch" + " around: the preflight found it unavailable on this machine, so do the task without it.";
 function knownMissingNotice(lines) {
   return lines.length === 0 ? [] : [...lines, KNOWN_MISSING_SENTENCE];
 }
 function agentSourcePath(planPath) {
   const tracker = trackerPathFor(planPath);
-  return existsSync27(tracker) ? tracker : planPath;
+  return existsSync28(tracker) ? tracker : planPath;
 }
 function readIfReadable2(path2) {
   try {
-    return readFileSync23(path2, "utf8");
+    return readFileSync24(path2, "utf8");
   } catch {
     return null;
   }
@@ -19140,7 +19416,7 @@ function refuseUnresolvableAgents(options) {
   if (missing2.length === 0)
     return;
   throw new CommandExit(1, [
-    `\u274C Refusing to start: ${basename10(path2)} names ${missing2.length} agent(s) no loaded scope` + ` defines (loop.settingSources: ${settingSources.join(", ")}).`,
+    `\u274C Refusing to start: ${basename11(path2)} names ${missing2.length} agent(s) no loaded scope` + ` defines (loop.settingSources: ${settingSources.join(", ")}).`,
     ...missing2.map((agent) => `   ${missingAgentLine(agent)}`),
     "   Nothing was checked and nothing was dispatched."
   ].join(`
@@ -19173,7 +19449,7 @@ function skippedStartLine(item, tracker) {
   return `\u23ED start-only item ${item.kind} ${JSON.stringify(item.name)} was not checked:` + " it is probed on a first dispatch alone," + ` and ${tracker} already holds a ticked task`;
 }
 function announceSkippedStart(planPath, skipped) {
-  const tracker = basename10(trackerPathFor(planPath));
+  const tracker = basename11(trackerPathFor(planPath));
   const output = activeOutput();
   for (const [index, item] of skipped.entries()) {
     const lead = index === 0 ? `
@@ -19192,7 +19468,7 @@ function startTier(planPath, items) {
 function announceReminders(planPath, reminders) {
   if (reminders.length === 0)
     return;
-  const file = basename10(prerequisitesPathForPlan(planPath) ?? planPath);
+  const file = basename11(prerequisitesPathForPlan(planPath) ?? planPath);
   const output = activeOutput();
   output.info(`
 \uD83D\uDCCC ${file} names ${reminders.length} step(s) the preflight does not check:`);
@@ -19419,7 +19695,7 @@ async function holdWhilePaused(options) {
 }
 
 // src/release/prepare.ts
-import { readFileSync as readFileSync25, writeFileSync as writeFileSync13 } from "fs";
+import { readFileSync as readFileSync26, writeFileSync as writeFileSync13 } from "fs";
 
 // src/release/changelog.ts
 var RELEASE_HEADING_FIELDS = ["version", "date", "title"];
@@ -19623,7 +19899,7 @@ function resolveReleaseLevel(declared, notes) {
 }
 
 // src/release/version.ts
-import { readFileSync as readFileSync24, writeFileSync as writeFileSync12 } from "fs";
+import { readFileSync as readFileSync25, writeFileSync as writeFileSync12 } from "fs";
 var RELEASE_REMOTE = "origin";
 var RELEASE_BASE_BRANCH = "main";
 var VERSION_SHAPE2 = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([0-9A-Za-z.-]+))?(?:\+([0-9A-Za-z.-]+))?$/;
@@ -19715,7 +19991,7 @@ function writeManifestVersion(path2, next) {
   const unwritten = { path: path2, written: false, previous: null, version: next };
   let text2;
   try {
-    text2 = readFileSync24(path2, "utf8");
+    text2 = readFileSync25(path2, "utf8");
   } catch (error) {
     return { ...unwritten, problem: `${path2} could not be read: ${messageOf(error)}` };
   }
@@ -19818,7 +20094,7 @@ function planVersion(input, versionFile, level) {
 }
 function textOf(path2) {
   try {
-    return readFileSync25(path2, "utf8");
+    return readFileSync26(path2, "utf8");
   } catch {
     return null;
   }
@@ -19931,7 +20207,7 @@ function changelogFailure(failed2, versionEdit, restored) {
 }
 
 // src/release/verify.ts
-import { readFileSync as readFileSync26, writeFileSync as writeFileSync14 } from "fs";
+import { readFileSync as readFileSync27, writeFileSync as writeFileSync14 } from "fs";
 function changelogInsertionSpan(before, after) {
   const beforeLines = before.split(`
 `);
@@ -19948,7 +20224,7 @@ function changelogInsertionSpan(before, after) {
 }
 function textOf2(path2) {
   try {
-    return readFileSync26(path2, "utf8");
+    return readFileSync27(path2, "utf8");
   } catch {
     return null;
   }
@@ -20340,9 +20616,9 @@ function describeStartTriage(result) {
   };
 }
 async function resolvePublicTracker(options, redact) {
-  const resolve16 = options.resolve ?? resolveTracker;
+  const resolve18 = options.resolve ?? resolveTracker;
   try {
-    const { tracker, attempts } = await resolve16({
+    const { tracker, attempts } = await resolve18({
       config: options.config,
       context: { repoRoot: options.repoRoot }
     });
@@ -20513,8 +20789,8 @@ function msUntil(startAt, now = new Date) {
   return target.getTime() - now.getTime();
 }
 function sleepFor(ms) {
-  return new Promise((resolve16) => {
-    setTimeout(resolve16, ms);
+  return new Promise((resolve18) => {
+    setTimeout(resolve18, ms);
   });
 }
 async function deferUntil(startAt, now = new Date, sleep = sleepFor) {
@@ -21070,8 +21346,8 @@ Usage: ${USAGE17}`);
 var exec_default = Object.freeze(execCommand);
 
 // src/modules/load.ts
-import { readFileSync as readFileSync27 } from "fs";
-import { isAbsolute as isAbsolute10, join as join33, relative as relative8, resolve as resolve16 } from "path";
+import { readFileSync as readFileSync28 } from "fs";
+import { isAbsolute as isAbsolute10, join as join34, relative as relative8, resolve as resolve18 } from "path";
 
 // src/modules/manifest.ts
 var MANIFEST_VERSION = 1;
@@ -21356,11 +21632,11 @@ function unread(name2, directory2, ...problems) {
   return { name: name2, version: null, directory: directory2, manifest: null, problems };
 }
 function readPathSource(source, settings, seams) {
-  const directory2 = resolve16(settings.base, source.location);
-  const file = join33(directory2, "package.json");
+  const directory2 = resolve18(settings.base, source.location);
+  const file = join34(directory2, "package.json");
   let parsed;
   try {
-    parsed = JSON.parse((seams.readText ?? ((path3) => readFileSync27(path3, "utf8")))(file));
+    parsed = JSON.parse((seams.readText ?? ((path3) => readFileSync28(path3, "utf8")))(file));
   } catch (error) {
     return unread(null, directory2, `${file} cannot be read as JSON: ${firstLine2(error)}`);
   }
@@ -21391,7 +21667,7 @@ function readSource(source, settings, seams) {
   return unread(source.location, null, `${source.kind} source ${describeValue(source.location)} is refused: ${PHASE_7}`);
 }
 function resolveEntry(directory2, entry, label) {
-  const path3 = resolve16(directory2, entry);
+  const path3 = resolve18(directory2, entry);
   const inside = relative8(directory2, path3);
   return inside === "" || inside.startsWith("..") || isAbsolute10(inside) ? { problem: `${label} is ${describeValue(entry)}, which resolves outside the module directory ${directory2}` } : { path: path3 };
 }
@@ -21859,7 +22135,7 @@ async function runNext(context, seams) {
   const prompter = lazyPrompter(openPrompter);
   try {
     return await runNextChain({
-      read: () => readNextState(sources),
+      read: () => readNextState(sources.answer()),
       run: (state) => runStateAction(context, sources, state),
       ask: prompter.ask,
       handOver: prompter.close,
@@ -22063,6 +22339,23 @@ function createPlanReadyOffer(seams = DEFAULT_OFFER_SEAMS) {
   };
 }
 
+// src/commands/plan/refresh-offer.ts
+var DEFAULT_REFRESH_OFFER_SEAMS = Object.freeze({});
+function createPlanRefreshOffer(seams = DEFAULT_REFRESH_OFFER_SEAMS) {
+  const isTerminal = seams.isTerminal ?? (() => process.stdin.isTTY === true);
+  if (!isTerminal())
+    return null;
+  const openPrompter = seams.openPrompter ?? (() => createLinePrompter(process.stdin, process.stderr));
+  return async (request) => {
+    const prompter = lazyPrompter(openPrompter);
+    try {
+      return await prompter.ask(refreshQuestion(request.issue, request.savedAt));
+    } finally {
+      prompter.close();
+    }
+  };
+}
+
 // src/commands/plan/spec-route.ts
 function specCandidates(specArg, specsDir) {
   if (path4.isAbsolute(specArg))
@@ -22092,10 +22385,11 @@ async function resolveCreateSpec(options, seams = DEFAULT_ROUTE_SEAMS) {
   const source = readSpecSourceFlags(options.args);
   if (source.request === null)
     throw new CommandExit(SOURCE_REFUSAL_EXIT, usageRefusal(specsDir));
-  const resolve17 = seams.resolve ?? resolvePlanSpec;
+  const resolve19 = seams.resolve ?? resolvePlanSpec;
   const makeReadyOffer = seams.makeReadyOffer ?? createPlanReadyOffer;
   const makeAlternativeOffer = seams.makeAlternativeOffer ?? createPlanBlockedOffer;
-  return await resolve17({
+  const makeRefreshOffer = seams.makeRefreshOffer ?? createPlanRefreshOffer;
+  return await resolve19({
     request: source.request,
     refresh: source.refresh,
     dryRun: source.dryRun,
@@ -22105,7 +22399,8 @@ async function resolveCreateSpec(options, seams = DEFAULT_ROUTE_SEAMS) {
     trustedAuthors: options.trustedAuthors,
     findSpec: (spec) => findSpec(repoRoot, spec, specsDir),
     offerReady: makeReadyOffer(),
-    offerAlternative: makeAlternativeOffer()
+    offerAlternative: makeAlternativeOffer(),
+    offerRefresh: makeRefreshOffer()
   });
 }
 
@@ -22277,7 +22572,7 @@ var wrapped2 = wrapPhaseZeroCommand({
     },
     {
       name: "refresh",
-      description: "Rewrites a snapshot that no longer matches the issue, which is otherwise refused.",
+      description: "Rebuilds a snapshot that no longer matches the issue without asking; the old copy moves under" + " `previous/`.",
       type: "boolean"
     },
     {
@@ -22337,8 +22632,8 @@ var wrapped2 = wrapPhaseZeroCommand({
 var create_default2 = endingWith(wrapped2);
 
 // src/commands/plan/show.ts
-import { readFileSync as readFileSync28 } from "fs";
-import { join as join34 } from "path";
+import { readFileSync as readFileSync29 } from "fs";
+import { join as join35 } from "path";
 var USAGE19 = "rafa plan show <stub> [--tracker]";
 var COMMAND = "rafa plan show";
 function readTrackerFlag(value) {
@@ -22356,10 +22651,10 @@ function showPlan(plans, stub, tracker) {
     throw new CommandExit(1, `\u274C "${stub}" is no plan stub: a stub is letters, digits, ".", "_" and "-"`);
   }
   const name2 = planFileName(stub, tracker);
-  const file = join34(plans.path, name2);
+  const file = join35(plans.path, name2);
   if (!isFile(file))
-    throw new CommandExit(1, missingText(stub, tracker, join34(plans.label, name2)));
-  const model = parsePlan(readFileSync28(file, "utf8"));
+    throw new CommandExit(1, missingText(stub, tracker, join35(plans.label, name2)));
+  const model = parsePlan(readFileSync29(file, "utf8"));
   const { header } = model;
   return {
     stub,
@@ -22382,7 +22677,7 @@ function taskLine2(task) {
   return `  ${checkbox(task.status)} ${task.text}`;
 }
 function renderShownPlan(shown2, dirLabel) {
-  const relative9 = join34(dirLabel, planFileName(shown2.stub, shown2.tracker));
+  const relative9 = join35(dirLabel, planFileName(shown2.stub, shown2.tracker));
   const fileLabel = shown2.tracker ? "Tracker" : "File";
   const lines = [`Plan: ${shown2.stub}`, `${fileLabel}: ${relative9}`];
   if (shown2.header.issue !== null)
@@ -22801,11 +23096,11 @@ function createPrListCommand(seams = DEFAULT_PR_SEAMS) {
 var list_default7 = createPrListCommand();
 
 // src/commands/pr/merge.ts
-import { existsSync as existsSync29, readFileSync as readFileSync30 } from "fs";
-import { join as join36 } from "path";
+import { existsSync as existsSync30, readFileSync as readFileSync31 } from "fs";
+import { join as join37 } from "path";
 
 // src/board/roadmap-tick.ts
-var PREFIX16 = "board roadmap";
+var PREFIX18 = "board roadmap";
 var REPO_PATH4 = "{owner}/{repo}";
 var TICK_ATTEMPTS = 2;
 var UNTICKED = /\[ \]/u;
@@ -22856,17 +23151,17 @@ function bodyOf(stdout, command) {
   try {
     payload = JSON.parse(stdout);
   } catch (error) {
-    throw new Error(`${PREFIX16}: ${command} wrote output that is not JSON: ${messageOf(error)}`, { cause: error });
+    throw new Error(`${PREFIX18}: ${command} wrote output that is not JSON: ${messageOf(error)}`, { cause: error });
   }
   const body = isMapping(payload) ? payload["body"] : null;
   if (typeof body !== "string") {
-    throw new Error(`${PREFIX16}: ${command} answered body as ${describeValue(body)}, expected a string`);
+    throw new Error(`${PREFIX18}: ${command} answered body as ${describeValue(body)}, expected a string`);
   }
   return body;
 }
 function issueSegment(value, member) {
   if (!Number.isSafeInteger(value) || value < 1) {
-    throw new TypeError(`${PREFIX16}: ${member} refused issue number ${describeValue(value)}, expected a positive whole number`);
+    throw new TypeError(`${PREFIX18}: ${member} refused issue number ${describeValue(value)}, expected a positive whole number`);
   }
   return String(value);
 }
@@ -22876,23 +23171,23 @@ function createGhRoadmapBody(options) {
   return Object.freeze({
     read: async (issue3) => {
       const path6 = pathOf(issue3, "read");
-      const result = await gh([path6]);
+      const result = await gh(["api", path6]);
       if (!result.ok)
-        throw new Error(`${PREFIX16}: ${detailOf10(result, `gh api ${path6}`)}`);
+        throw new Error(`${PREFIX18}: ${detailOf10(result, `gh api ${path6}`)}`);
       return bodyOf(result.stdout, `gh api ${path6}`);
     },
     write: async (issue3, body) => {
       const path6 = pathOf(issue3, "write");
-      const result = await gh([path6, "-X", "PATCH", "-f", `body=${body}`]);
+      const result = await gh(["api", path6, "-X", "PATCH", "-f", `body=${body}`]);
       const command = `gh api ${path6} -X PATCH -f body=<body>`;
       if (!result.ok)
-        throw new Error(`${PREFIX16}: ${detailOf10(result, command)}`);
+        throw new Error(`${PREFIX18}: ${detailOf10(result, command)}`);
       return bodyOf(result.stdout, command);
     }
   });
 }
 function conflictProblem(issue3) {
-  return `${PREFIX16}: issue #${String(issue3)} answered a body other than the one that was written,` + " so somebody edited it in between";
+  return `${PREFIX18}: issue #${String(issue3)} answered a body other than the one that was written,` + " so somebody edited it in between";
 }
 async function attemptTick(roadmap, issues, board, attempt4) {
   let edit;
@@ -22957,17 +23252,17 @@ function tickSentence(result) {
 import {
   chmodSync,
   copyFileSync as copyFileSync2,
-  existsSync as existsSync28,
-  mkdirSync as mkdirSync11,
-  readdirSync as readdirSync9,
-  readFileSync as readFileSync29,
+  existsSync as existsSync29,
+  mkdirSync as mkdirSync12,
+  readdirSync as readdirSync10,
+  readFileSync as readFileSync30,
   realpathSync as realpathSync5,
   renameSync as renameSync3,
   rmSync as rmSync2,
-  statSync as statSync15,
+  statSync as statSync17,
   symlinkSync
 } from "fs";
-import { basename as basename11, delimiter as delimiter3, dirname as dirname13, join as join35, relative as relative9, resolve as resolve17 } from "path";
+import { basename as basename12, delimiter as delimiter3, dirname as dirname13, join as join36, relative as relative9, resolve as resolve19 } from "path";
 var LINK_NAME = "rafa";
 var FORCE_FLAG = "--force";
 var EXIT_DONE = 0;
@@ -23028,20 +23323,20 @@ function runtimeRefusalLines(runtimeDir, version2) {
   ];
 }
 function listTrackers(repoRoot, planDir) {
-  const dir = resolve17(repoRoot, planDir);
-  return entryNames(dir).filter((entry) => TRACKER_NAME.test(entry)).sort((a, b) => a.localeCompare(b)).map((entry) => join35(dir, entry)).filter((path6) => statSync15(path6).isFile()).map((path6) => relative9(repoRoot, path6));
+  const dir = resolve19(repoRoot, planDir);
+  return entryNames(dir).filter((entry) => TRACKER_NAME.test(entry)).sort((a, b) => a.localeCompare(b)).map((entry) => join36(dir, entry)).filter((path6) => statSync17(path6).isFile()).map((path6) => relative9(repoRoot, path6));
 }
 function openTrackers(repoRoot, planDir) {
   return listTrackers(repoRoot, planDir).flatMap((path6) => {
-    const task = findNextTask(readFileSync29(join35(repoRoot, path6), "utf8"));
+    const task = findNextTask(readFileSync30(join36(repoRoot, path6), "utf8"));
     return task ? [{ path: path6, task }] : [];
   });
 }
 function readManifestVersion2(repoRoot) {
-  const manifest = JSON.parse(readFileSync29(join35(repoRoot, "package.json"), "utf8"));
+  const manifest = JSON.parse(readFileSync30(join36(repoRoot, "package.json"), "utf8"));
   const record = typeof manifest === "object" && manifest !== null ? manifest : {};
   if (record["name"] !== name) {
-    throw new Error(`${join35(repoRoot, "package.json")} names ${JSON.stringify(record["name"])}, not ${name}: this is no rafa checkout`);
+    throw new Error(`${join36(repoRoot, "package.json")} names ${JSON.stringify(record["name"])}, not ${name}: this is no rafa checkout`);
   }
   const version2 = record["version"];
   if (typeof version2 !== "string" || !VERSION_SHAPE.test(version2)) {
@@ -23050,12 +23345,12 @@ function readManifestVersion2(repoRoot) {
   return version2;
 }
 function copyTree(from, to) {
-  mkdirSync11(to, { recursive: true });
+  mkdirSync12(to, { recursive: true });
   let copied = 0;
-  const entries = readdirSync9(from, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+  const entries = readdirSync10(from, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
   for (const entry of entries) {
-    const source = join35(from, entry.name);
-    const target = join35(to, entry.name);
+    const source = join36(from, entry.name);
+    const target = join36(to, entry.name);
     if (entry.isDirectory()) {
       copied += copyTree(source, target);
     } else if (entry.isFile()) {
@@ -23080,7 +23375,7 @@ function replaceTree(from, to) {
   }
 }
 function swapIn(staging, to) {
-  if (!existsSync28(to)) {
+  if (!existsSync29(to)) {
     renameSync3(staging, to);
     return;
   }
@@ -23096,7 +23391,7 @@ function swapIn(staging, to) {
   rmSync2(outgoing, { recursive: true, force: true });
 }
 function relink(linkPath, target) {
-  mkdirSync11(dirname13(linkPath), { recursive: true });
+  mkdirSync12(dirname13(linkPath), { recursive: true });
   const temporary = temporaryName(linkPath);
   rmSync2(temporary, { force: true });
   try {
@@ -23150,20 +23445,20 @@ function installRuntime(seams, options = {}) {
 }
 function runInstall(seams, options) {
   const { repoRoot, home, log } = seams;
-  const runtimeRoot = join35(home, RUNTIME_SUBDIR);
-  const linkPath = join35(home, RAFA_BIN_DIR, LINK_NAME);
+  const runtimeRoot = join36(home, RUNTIME_SUBDIR);
+  const linkPath = join36(home, RAFA_BIN_DIR, LINK_NAME);
   log(`repo root: ${repoRoot}`);
   log(`runtime root: ${runtimeRoot}`);
   log(`link: ${linkPath}`);
   const version2 = inStage("manifest", () => readManifestVersion2(repoRoot));
-  const planDir = inStage("config", () => resolve17(repoRoot, loadConfig({ root: repoRoot, home }, {}, seams.warn).config.planDir));
+  const planDir = inStage("config", () => resolve19(repoRoot, loadConfig({ root: repoRoot, home }, {}, seams.warn).config.planDir));
   log(`plan dir: ${planDir}`);
   const open = inStage("trackers", () => openTrackers(repoRoot, planDir));
   if (open.length > 0)
     return { kind: "refused", reason: "trackers", planDir, trackers: open };
-  const distDir = join35(repoRoot, "dist");
-  const runtimeDir = join35(runtimeRoot, version2);
-  const installed = existsSync28(runtimeDir);
+  const distDir = join36(repoRoot, "dist");
+  const runtimeDir = join36(runtimeRoot, version2);
+  const installed = existsSync29(runtimeDir);
   if (installed && options.force !== true) {
     return { kind: "refused", reason: "runtime-exists", version: version2, runtimeDir };
   }
@@ -23171,13 +23466,13 @@ function runInstall(seams, options) {
   const code = inStage("build", () => seams.build(repoRoot));
   if (code !== 0)
     throw new StageFailure("build", `the build exited ${code}`);
-  if (!existsSync28(join35(distDir, RUNTIME_ENTRY))) {
-    throw new StageFailure("build", `the build exited 0 and left no ${join35(distDir, RUNTIME_ENTRY)}`);
+  if (!existsSync29(join36(distDir, RUNTIME_ENTRY))) {
+    throw new StageFailure("build", `the build exited 0 and left no ${join36(distDir, RUNTIME_ENTRY)}`);
   }
   log(installed ? `copying ${distDir} over ${runtimeDir}, replacing it whole` : `copying ${distDir} into ${runtimeDir}`);
   const copied = inStage("copy", () => replaceTree(distDir, runtimeDir));
   log(`copied ${copied} file(s)`);
-  const resolved = inStage("link", () => relink(linkPath, join35(runtimeDir, RUNTIME_ENTRY)));
+  const resolved = inStage("link", () => relink(linkPath, join36(runtimeDir, RUNTIME_ENTRY)));
   log(`${linkPath} resolves to ${resolved}`);
   return { kind: "done", version: version2, runtimeDir, linkPath, resolved, copied };
 }
@@ -23192,7 +23487,7 @@ function inStage(stage, run) {
 }
 function entryNames(dir) {
   try {
-    return readdirSync9(dir);
+    return readdirSync10(dir);
   } catch (err) {
     if (typeof err === "object" && err !== null && "code" in err && err.code === "ENOENT")
       return [];
@@ -23203,7 +23498,7 @@ function replaceFile(source, target) {
   const temporary = temporaryName(target);
   try {
     copyFileSync2(source, temporary);
-    chmodSync(temporary, statSync15(source).mode & 4095);
+    chmodSync(temporary, statSync17(source).mode & 4095);
     renameSync3(temporary, target);
   } catch (err) {
     rmSync2(temporary, { force: true });
@@ -23211,7 +23506,7 @@ function replaceFile(source, target) {
   }
 }
 function temporaryName(path6) {
-  return join35(dirname13(path6), `.${basename11(path6)}.snapshot-${process.pid}`);
+  return join36(dirname13(path6), `.${basename12(path6)}.snapshot-${process.pid}`);
 }
 
 // src/commands/pr/merge-followups.ts
@@ -23502,13 +23797,13 @@ function remoteHoldsBranch(git, branch, warn) {
 }
 function textOf3(path6) {
   try {
-    return readFileSync30(path6, "utf8");
+    return readFileSync31(path6, "utf8");
   } catch {
     return "";
   }
 }
 function followUpsFor(pr, git) {
-  const facts = readPackageFacts(textOf3(join36(pr.project.root, "package.json")));
+  const facts = readPackageFacts(textOf3(join37(pr.project.root, "package.json")));
   if (facts.version === null)
     return [];
   const tags = git(["tag", "--list", versionTag(facts.version)]);
@@ -23516,7 +23811,7 @@ function followUpsFor(pr, git) {
     version: facts.version,
     tagged: tags.ok && tags.stdout.trim() !== "",
     rafaCheckout: facts.rafaCheckout,
-    runtimeInstalled: existsSync29(join36(pr.project.home, RUNTIME_SUBDIR, facts.version))
+    runtimeInstalled: existsSync30(join37(pr.project.home, RUNTIME_SUBDIR, facts.version))
   });
 }
 function openGh(pr, seams) {
@@ -23767,7 +24062,7 @@ var COLUMN = "\t";
 var BOM = "\uFEFF";
 var TIMESTAMP = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z /;
 var COLOUR = new RegExp(`(?:${String.fromCharCode(27)}|\\^\\[)\\[[0-9;]*m`, "g");
-var PREFIX17 = "pr triage evidence";
+var PREFIX19 = "pr triage evidence";
 function named2(value) {
   return value === "" ? undefined : value;
 }
@@ -23833,7 +24128,7 @@ function readCap(value) {
   if (value === undefined)
     return FAILED_LOG_TAIL_LINES;
   if (!Number.isSafeInteger(value) || value < 1) {
-    throw new TypeError(`${PREFIX17}: readFailedLog refused a line cap ${describeValue(value)},` + " expected a positive whole number");
+    throw new TypeError(`${PREFIX19}: readFailedLog refused a line cap ${describeValue(value)},` + " expected a positive whole number");
   }
   return value;
 }
@@ -24720,8 +25015,8 @@ function describeAge(updatedAt, now) {
     return `${plural4(hours, "hour", "hours")} ago`;
   return `${plural4(Math.floor(age / DAY_MS2), "day", "days")} ago`;
 }
-function triageCommand(number, resolve18 = false) {
-  return resolve18 ? `rafa pr triage ${number} --resolve` : `rafa pr triage ${number}`;
+function triageCommand(number, resolve20 = false) {
+  return resolve20 ? `rafa pr triage ${number} --resolve` : `rafa pr triage ${number}`;
 }
 function joinNumbers(pulls) {
   const names = pulls.map((pull) => `#${pull.number}`);
@@ -24732,14 +25027,14 @@ function joinNumbers(pulls) {
 function byNumber(pulls) {
   return Object.freeze([...pulls].sort((left, right) => left.number - right.number));
 }
-function skipped(pull, now, resolve18) {
+function skipped(pull, now, resolve20) {
   return Object.freeze({
     number: pull.number,
     title: pull.title,
     updatedAt: pull.updatedAt,
     age: describeAge(pull.updatedAt, now),
     fresh: isFreshCandidate(pull.updatedAt, now),
-    command: triageCommand(pull.number, resolve18)
+    command: triageCommand(pull.number, resolve20)
   });
 }
 function skippedLine(one) {
@@ -24783,15 +25078,15 @@ function listReading(rest, count) {
   return listing2("list", Object.freeze([]), rest, headline);
 }
 function selectTriagePullRequests(input) {
-  const resolve18 = input.resolve === true;
+  const resolve20 = input.resolve === true;
   const { current, now } = input;
   if (current !== null) {
     return plain("branch", Object.freeze([current]), `assessing #${current.number}, the pull request open on ${current.headRefName}`);
   }
   const candidates = byNumber(input.candidates);
   const count = candidates.length;
-  const lines = candidates.map((pull) => skipped(pull, now, resolve18));
-  if (resolve18 && count > 1)
+  const lines = candidates.map((pull) => skipped(pull, now, resolve20));
+  if (resolve20 && count > 1)
     return refusal9(lines, count);
   if (count === 0) {
     return plain("none", Object.freeze([]), "no red pull request to triage, and no pull request on the current branch");
@@ -25093,11 +25388,11 @@ function renderTriages(readings) {
 var BUDGET_KEY = "budget";
 var TASK_LINE2 = /^- \[[^\]]*\] /;
 var TRAILING_BLOCK = /\{([^{}]*)\}$/;
-var PREFIX18 = "pr triage --resolve budget";
+var PREFIX20 = "pr triage --resolve budget";
 function budgetEntry(usd) {
   const spelled = String(usd);
   if (parseBudgetUsd(spelled) === null) {
-    throw new TypeError(`${PREFIX18}: refused an amount of ${JSON.stringify(usd)}, expected US dollars above zero` + " with at most six whole digits and six decimal places");
+    throw new TypeError(`${PREFIX20}: refused an amount of ${JSON.stringify(usd)}, expected US dollars above zero` + " with at most six whole digits and six decimal places");
   }
   return `${BUDGET_KEY}=${spelled}`;
 }
@@ -25126,8 +25421,8 @@ function withTaskBudget(plan2, usd) {
 }
 
 // src/pr/plans/load.ts
-import { existsSync as existsSync30, readFileSync as readFileSync31 } from "fs";
-import { dirname as dirname14, join as join37 } from "path";
+import { existsSync as existsSync31, readFileSync as readFileSync32 } from "fs";
+import { dirname as dirname14, join as join38 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 var MODULE_DIR2 = dirname14(fileURLToPath4(import.meta.url));
 var PINNED_PLANS_DIRNAME = "plans";
@@ -25144,8 +25439,8 @@ function hasPinnedPlan(triageClass) {
 function pinnedPlanCandidates(moduleDir, triageClass) {
   const name2 = pinnedPlanFileName(triageClass);
   return [
-    join37(moduleDir, PINNED_PLANS_DIRNAME, name2),
-    join37(moduleDir, name2)
+    join38(moduleDir, PINNED_PLANS_DIRNAME, name2),
+    join38(moduleDir, name2)
   ];
 }
 function readPinnedPlan(triageClass, lookup = {}) {
@@ -25153,11 +25448,11 @@ function readPinnedPlan(triageClass, lookup = {}) {
     throw new Error(`No pinned resolve plan ships for ${triageClass}; ` + `one ships for ${PINNED_PLAN_CLASSES.join(", ")}`);
   }
   const candidates = pinnedPlanCandidates(lookup.moduleDir ?? MODULE_DIR2, triageClass);
-  const found = candidates.find((candidate) => existsSync30(candidate));
+  const found = candidates.find((candidate) => existsSync31(candidate));
   if (found === undefined) {
     throw new Error(`The pinned resolve plan for ${triageClass} is missing: ` + `no file at ${candidates.join(" or ")}`);
   }
-  return readFileSync31(found, "utf8");
+  return readFileSync32(found, "utf8");
 }
 var SLOT_PATTERN2 = /\{[A-Z][A-Z0-9_]*\}/g;
 var CONFLICT_SENTENCE_SLOT = "CONFLICT_SENTENCE";
@@ -25220,12 +25515,12 @@ var ATTEMPT_STOPS = Object.freeze([
   "cap",
   "repeat"
 ]);
-var PREFIX19 = "pr triage attempts";
+var PREFIX21 = "pr triage attempts";
 var WHITESPACE2 = /\s+/g;
 var NO_STEP_KEY = "";
 function readCap2(maxAttempts) {
   if (!Number.isSafeInteger(maxAttempts) || maxAttempts < 1) {
-    throw new TypeError(`${PREFIX19}: refused a cap of ${JSON.stringify(maxAttempts)},` + " expected a positive whole number");
+    throw new TypeError(`${PREFIX21}: refused a cap of ${JSON.stringify(maxAttempts)},` + " expected a positive whole number");
   }
   return maxAttempts;
 }
@@ -25297,13 +25592,13 @@ function readAttemptRepeat(input) {
 }
 
 // src/pr/worktree.ts
-import { existsSync as existsSync31, realpathSync as realpathSync6 } from "fs";
-import { join as join38 } from "path";
-var WORKTREES_SUBDIR = join38(".rafa", "worktrees");
+import { existsSync as existsSync32, realpathSync as realpathSync6 } from "fs";
+import { join as join39 } from "path";
+var WORKTREES_SUBDIR = join39(".rafa", "worktrees");
 var WORKTREE_PREFIX = "pr-";
 var REFUSAL_PREFIX3 = "rafa pr triage --resolve refuses";
 function resolveWorktreePath(home, number) {
-  return join38(home, WORKTREES_SUBDIR, `${WORKTREE_PREFIX}${number}`);
+  return join39(home, WORKTREES_SUBDIR, `${WORKTREE_PREFIX}${number}`);
 }
 function crossRepositoryRefusal(pr) {
   if (!pr.isCrossRepository)
@@ -25346,7 +25641,7 @@ function removeResolveWorktree(git, path6) {
   return runStep(git, removeWorktreeStep(path6));
 }
 function pathForms(path6) {
-  if (!existsSync31(path6))
+  if (!existsSync32(path6))
     return [path6];
   return [path6, realpathSync6(path6)];
 }
@@ -25359,20 +25654,20 @@ function worktreeAt(git, path6) {
 }
 
 // src/commands/pr/resolve-loop.ts
-import { mkdirSync as mkdirSync12, writeFileSync as writeFileSync15 } from "fs";
-import { join as join39 } from "path";
-var RESOLVE_SUBDIR = join39(".rafa", "resolve");
+import { mkdirSync as mkdirSync13, writeFileSync as writeFileSync15 } from "fs";
+import { join as join40 } from "path";
+var RESOLVE_SUBDIR = join40(".rafa", "resolve");
 var RUN_PREFIX = "pr-";
 var ATTEMPT_PREFIX = "attempt-";
 var LOOP_WORDS = Object.freeze(["loop", "start"]);
 var CHILD_OUTPUT = "text";
 function resolveRunDir(home, number, attempt4) {
-  return join39(home, RESOLVE_SUBDIR, `${RUN_PREFIX}${number}`, `${ATTEMPT_PREFIX}${attempt4}`);
+  return join40(home, RESOLVE_SUBDIR, `${RUN_PREFIX}${number}`, `${ATTEMPT_PREFIX}${attempt4}`);
 }
 function writeResolvePlan(write) {
   const dir = resolveRunDir(write.home, write.number, write.attempt);
-  mkdirSync12(dir, { recursive: true });
-  const path6 = join39(dir, pinnedPlanFileName(write.triageClass));
+  mkdirSync13(dir, { recursive: true });
+  const path6 = join40(dir, pinnedPlanFileName(write.triageClass));
   writeFileSync15(path6, write.plan, "utf8");
   return path6;
 }
@@ -25772,16 +26067,16 @@ async function redPullRequests(pr) {
   }
   return red;
 }
-async function selectTargets(pr, warn, now, resolve18) {
+async function selectTargets(pr, warn, now, resolve20) {
   const branch = readBranchOrNone(pr, warn);
   const current = branch === null ? null : await onProvider(`read the open pull request for the branch "${branch}"`, () => pr.pulls.findOpen(branch));
   if (current !== null)
-    return selectTriagePullRequests({ current, candidates: [], now, resolve: resolve18 });
+    return selectTriagePullRequests({ current, candidates: [], now, resolve: resolve20 });
   return selectTriagePullRequests({
     current: null,
     candidates: await redPullRequests(pr),
     now,
-    resolve: resolve18
+    resolve: resolve20
   });
 }
 async function detailOf11(pr, number) {
@@ -25902,7 +26197,7 @@ async function runTriage(context, seams) {
   }
   const numbers = asked === null ? (selection?.assess ?? []).map((one) => one.number) : [asked];
   const readings = [];
-  let resolve18 = null;
+  let resolve20 = null;
   for (const number of numbers) {
     const assess = () => assessOne({
       pr,
@@ -25918,7 +26213,7 @@ async function runTriage(context, seams) {
       readings.push(reading2);
       continue;
     }
-    resolve18 = await resolvePullRequest({
+    resolve20 = await resolvePullRequest({
       trust: {
         permissions,
         trustedAuthors: pr.trustedAuthors,
@@ -25939,16 +26234,16 @@ async function runTriage(context, seams) {
       ...seams.clock === undefined ? {} : { clock: seams.clock },
       ...seams.sleep === undefined ? {} : { sleep: seams.sleep }
     });
-    readings.push(resolve18.reading);
+    readings.push(resolve20.reading);
   }
   const text2 = [
     ...selection === null ? [] : [selection.message],
     ...readings.length === 0 ? [] : [renderTriages(readings)],
-    ...resolve18 === null ? [] : resolve18.lines
+    ...resolve20 === null ? [] : resolve20.lines
   ].join(`
 
 `);
-  return { selection, readings, resolve: resolve18, text: text2, exitCode: resolve18?.exitCode ?? 0 };
+  return { selection, readings, resolve: resolve20, text: text2, exitCode: resolve20?.exitCode ?? 0 };
 }
 function createPrTriageCommand(seams = DEFAULT_TRIAGE_SEAMS) {
   const command = {
@@ -26236,8 +26531,8 @@ function createPrWaitCommand(seams = DEFAULT_WAIT_SEAMS) {
 var wait_default = createPrWaitCommand();
 
 // src/commands/release/status.ts
-import { existsSync as existsSync32, readdirSync as readdirSync10, readFileSync as readFileSync32 } from "fs";
-import { join as join40 } from "path";
+import { existsSync as existsSync33, readdirSync as readdirSync11, readFileSync as readFileSync33 } from "fs";
+import { join as join41 } from "path";
 var RELEASE_STATUS_USAGE = "rafa release status [--plan=<stub>]";
 var UNREADABLE2 = "?";
 var NOTHING = "none";
@@ -26338,13 +26633,13 @@ function untaggedVersions(released, tags) {
 }
 function textOf4(path6) {
   try {
-    return readFileSync32(path6, "utf8");
+    return readFileSync33(path6, "utf8");
   } catch {
     return null;
   }
 }
 function readVersionFile(root, configured) {
-  const resolved = join40(root, configured);
+  const resolved = join41(root, configured);
   const text2 = textOf4(resolved);
   if (text2 === null) {
     return { path: configured, version: null, problem: `the version file could not be read at ${resolved}` };
@@ -26361,7 +26656,7 @@ function readTags(git) {
   return { tags, latest: tags[0] ?? null, problem: null };
 }
 function readUntagged(root, configured, tags) {
-  const resolved = join40(root, configured);
+  const resolved = join41(root, configured);
   const text2 = textOf4(resolved);
   if (text2 === null) {
     return {
@@ -26380,11 +26675,11 @@ function readBranch2(git) {
   return result.ok && branch !== "" && branch !== "HEAD" ? branch : null;
 }
 function planStubsUnder(root, planDir) {
-  const resolved = join40(root, planDir);
-  if (!existsSync32(resolved))
+  const resolved = join41(root, planDir);
+  if (!existsSync33(resolved))
     return [];
   try {
-    return planStubsFromFileNames(readdirSync10(resolved));
+    return planStubsFromFileNames(readdirSync11(resolved));
   } catch {
     return [];
   }
@@ -26582,8 +26877,8 @@ function createReleaseStatusCommand(seams = DEFAULT_RELEASE_SEAMS) {
 var status_default2 = createReleaseStatusCommand();
 
 // src/commands/release/tag.ts
-import { readFileSync as readFileSync33 } from "fs";
-import { join as join41 } from "path";
+import { readFileSync as readFileSync34 } from "fs";
+import { join as join42 } from "path";
 var RELEASE_TAG_USAGE = "rafa release tag";
 var DEFAULT_RELEASE_BRANCH = "main";
 var DEFAULT_REGISTRY = "https://registry.npmjs.org";
@@ -26602,13 +26897,13 @@ function readBranch3(git) {
 }
 function textOf5(path6) {
   try {
-    return readFileSync33(path6, "utf8");
+    return readFileSync34(path6, "utf8");
   } catch {
     return null;
   }
 }
 function readVersion(root, configured) {
-  const resolved = join41(root, configured);
+  const resolved = join42(root, configured);
   const text2 = textOf5(resolved);
   if (text2 === null) {
     return {
@@ -26622,7 +26917,7 @@ function readVersion(root, configured) {
   return version2 === null ? { path: configured, text: text2, version: null, problem: `${resolved} declares no version this can read` } : { path: configured, text: text2, version: version2, problem: null };
 }
 function readNewestRelease(root, configured) {
-  const resolved = join41(root, configured);
+  const resolved = join42(root, configured);
   const text2 = textOf5(resolved);
   if (text2 === null) {
     return { path: configured, version: null, problem: `the changelog could not be read at ${resolved}` };
@@ -26887,17 +27182,17 @@ function createSelfUpdateCommand(seams = DEFAULT_SELF_UPDATE_SEAMS) {
 var self_update_default = createSelfUpdateCommand();
 
 // src/commands/skill/backfill.ts
-import { statSync as statSync17 } from "fs";
-import { join as join46, resolve as resolve20 } from "path";
+import { statSync as statSync19 } from "fs";
+import { join as join47, resolve as resolve22 } from "path";
 
 // src/backfill/backup.ts
-import { copyFileSync as copyFileSync3, existsSync as existsSync33, mkdirSync as mkdirSync13 } from "fs";
-import { dirname as dirname15, isAbsolute as isAbsolute11, join as join43, relative as relative10, resolve as resolve18, sep as sep5 } from "path";
+import { copyFileSync as copyFileSync3, existsSync as existsSync34, mkdirSync as mkdirSync14 } from "fs";
+import { dirname as dirname15, isAbsolute as isAbsolute11, join as join44, relative as relative10, resolve as resolve20, sep as sep5 } from "path";
 
 // src/backfill/proposal-file.ts
-import { readdirSync as readdirSync11, readFileSync as readFileSync34 } from "fs";
-import { join as join42 } from "path";
-var BACKFILL_PATH = join42(".rafa", "backfill");
+import { readdirSync as readdirSync12, readFileSync as readFileSync35 } from "fs";
+import { join as join43 } from "path";
+var BACKFILL_PATH = join43(".rafa", "backfill");
 var PROPOSAL_FILE_PREFIX = "proposals-";
 var PROPOSAL_FILE_EXTENSION = ".yaml";
 var SHA256_PATTERN = /^[0-9a-f]{64}$/;
@@ -26923,7 +27218,7 @@ var PROPOSAL_FILE_HEADER = [
 ].join(`
 `);
 function proposalPath(dir, batch) {
-  return join42(dir, `${PROPOSAL_FILE_PREFIX}${String(batch).padStart(2, "0")}${PROPOSAL_FILE_EXTENSION}`);
+  return join43(dir, `${PROPOSAL_FILE_PREFIX}${String(batch).padStart(2, "0")}${PROPOSAL_FILE_EXTENSION}`);
 }
 function isProposalFileName(name2) {
   return name2.startsWith(PROPOSAL_FILE_PREFIX) && name2.endsWith(PROPOSAL_FILE_EXTENSION);
@@ -27054,14 +27349,14 @@ function parseProposalFile(text2) {
 function readProposalFiles(dir) {
   let names;
   try {
-    names = readdirSync11(dir);
+    names = readdirSync12(dir);
   } catch {
     return [];
   }
   return names.filter((name2) => isProposalFileName(name2)).sort((left, right) => left.localeCompare(right)).map((name2) => {
-    const path6 = join42(dir, name2);
+    const path6 = join43(dir, name2);
     try {
-      return { path: path6, result: parseProposalFile(readFileSync34(path6, "utf8")) };
+      return { path: path6, result: parseProposalFile(readFileSync35(path6, "utf8")) };
     } catch (error) {
       return { path: path6, result: unreadable2(`the file cannot be read (${error instanceof Error ? error.message : String(error)})`) };
     }
@@ -27069,19 +27364,19 @@ function readProposalFiles(dir) {
 }
 
 // src/backfill/backup.ts
-var BACKUP_PATH = join43(BACKFILL_PATH, "backup");
+var BACKUP_PATH = join44(BACKFILL_PATH, "backup");
 var BACKUP_KINDS = ["copied", "kept", "tracked", "outside", "missing"];
 function backupDirectory(base) {
-  return join43(base, BACKUP_PATH);
+  return join44(base, BACKUP_PATH);
 }
 function isUnder(root, path6) {
-  const step2 = relative10(resolve18(root), resolve18(path6));
+  const step2 = relative10(resolve20(root), resolve20(path6));
   return step2 === "" || !step2.startsWith(`..${sep5}`) && step2 !== ".." && !isAbsolute11(step2);
 }
 function backupPathFor(path6, root, backupDir) {
   if (!isUnder(root, path6))
     return null;
-  return join43(backupDir, relative10(resolve18(root), resolve18(path6)));
+  return join44(backupDir, relative10(resolve20(root), resolve20(path6)));
 }
 function backupFile(path6, options) {
   if (options.repoRoot !== null && isUnder(options.repoRoot, path6)) {
@@ -27090,11 +27385,11 @@ function backupFile(path6, options) {
   const backup = backupPathFor(path6, options.root, options.backupDir);
   if (backup === null)
     return { path: path6, kind: "outside", backup: null };
-  if (!existsSync33(path6))
+  if (!existsSync34(path6))
     return { path: path6, kind: "missing", backup: null };
-  if (existsSync33(backup))
+  if (existsSync34(backup))
     return { path: path6, kind: "kept", backup };
-  mkdirSync13(dirname15(backup), { recursive: true });
+  mkdirSync14(dirname15(backup), { recursive: true });
   copyFileSync3(path6, backup);
   return { path: path6, kind: "copied", backup };
 }
@@ -27117,8 +27412,8 @@ function countBackups(results) {
 }
 
 // src/backfill/derive.ts
-import { readFileSync as readFileSync35, writeFileSync as writeFileSync16 } from "fs";
-import { basename as basename12 } from "path";
+import { readFileSync as readFileSync36, writeFileSync as writeFileSync16 } from "fs";
+import { basename as basename13 } from "path";
 
 // src/demote/classify.ts
 var LEARNED_DIRECTORY = "learned";
@@ -27575,15 +27870,15 @@ function fileChanges(name2, data, body, options) {
   return { changes, notes };
 }
 function planFile(entry, options) {
-  if (basename12(entry.path) !== SKILL_FILE) {
-    return inert(entry, "skipped", `${basename12(entry.path)} is no ${SKILL_FILE}, so it registers no skill`);
+  if (basename13(entry.path) !== SKILL_FILE) {
+    return inert(entry, "skipped", `${basename13(entry.path)} is no ${SKILL_FILE}, so it registers no skill`);
   }
   if (entry.name === null) {
     return inert(entry, "skipped", "its place implies no skill name, so no stack can be derived from it");
   }
   let original;
   try {
-    original = readFileSync35(entry.path, "utf8");
+    original = readFileSync36(entry.path, "utf8");
   } catch (error) {
     return inert(entry, "skipped", `the file cannot be read (${error instanceof Error ? error.message : String(error)})`);
   }
@@ -27627,7 +27922,7 @@ function planDerivation(root, options) {
 function applyFile(action, options) {
   if (action.text === null || action.original === null)
     return action;
-  const current = readFileSync35(action.path, "utf8");
+  const current = readFileSync36(action.path, "utf8");
   if (current !== action.original) {
     return {
       ...action,
@@ -27658,7 +27953,7 @@ function applyDerivation(plan2, options) {
 }
 
 // src/backfill/proposal-batch.ts
-import { readFileSync as readFileSync36 } from "fs";
+import { readFileSync as readFileSync37 } from "fs";
 import { relative as relative11 } from "path";
 
 // src/demote/report.ts
@@ -27957,7 +28252,7 @@ function readCandidate(root, entry) {
     return null;
   let text2;
   try {
-    text2 = readFileSync36(entry.path, "utf8");
+    text2 = readFileSync37(entry.path, "utf8");
   } catch {
     return null;
   }
@@ -28063,8 +28358,8 @@ function parseSessionAnswer(stdout) {
 }
 
 // src/backfill/propose.ts
-import { mkdirSync as mkdirSync14, readFileSync as readFileSync37, writeFileSync as writeFileSync17 } from "fs";
-import { join as join44, resolve as resolve19 } from "path";
+import { mkdirSync as mkdirSync15, readFileSync as readFileSync38, writeFileSync as writeFileSync17 } from "fs";
+import { join as join45, resolve as resolve21 } from "path";
 var PROPOSAL_ACTION_KINDS = [
   "applied",
   "unchanged",
@@ -28143,7 +28438,7 @@ async function runProposalPass(options) {
   const batches = batchCandidates(candidates);
   const written = [];
   if (batches.length > 0)
-    mkdirSync14(options.backfillDir, { recursive: true });
+    mkdirSync15(options.backfillDir, { recursive: true });
   for (const [index, batch] of batches.entries()) {
     const number = index + 1;
     const file = await runProposalBatch(number, batch, options);
@@ -28213,7 +28508,7 @@ function writeRow(path6, row2, original, options) {
   };
 }
 function applyRow(root, row2, options) {
-  const path6 = join44(root, ...row2.path.split("/"));
+  const path6 = join45(root, ...row2.path.split("/"));
   if (row2.status === UNANSWERED_ROW) {
     return inert2(path6, row2, "unanswered", row2.note ?? "the row carries no answer");
   }
@@ -28222,7 +28517,7 @@ function applyRow(root, row2, options) {
   }
   let original;
   try {
-    original = readFileSync37(path6, "utf8");
+    original = readFileSync38(path6, "utf8");
   } catch {
     return inert2(path6, row2, "refused", "the file the row names is gone");
   }
@@ -28236,7 +28531,7 @@ function fileRefusal(file, root) {
   if (file.status !== REVIEWED_FILE) {
     return `the proposal file is still marked ${file.status}: review it and mark it ${REVIEWED_FILE}`;
   }
-  return resolve19(file.skills) === resolve19(root) ? null : `the proposal file names the skills directory ${file.skills}, not ${root}`;
+  return resolve21(file.skills) === resolve21(root) ? null : `the proposal file names the skills directory ${file.skills}, not ${root}`;
 }
 function countProposalActions(actions) {
   const counts = Object.fromEntries(PROPOSAL_ACTION_KINDS.map((kind) => [kind, 0]));
@@ -28250,7 +28545,7 @@ function applyProposals(files, root, options) {
   for (const file of files) {
     const refusal10 = fileRefusal(file, root);
     for (const row2 of file.rows) {
-      const action = refusal10 === null ? applyRow(root, row2, options) : inert2(join44(root, ...row2.path.split("/")), row2, "refused", refusal10);
+      const action = refusal10 === null ? applyRow(root, row2, options) : inert2(join45(root, ...row2.path.split("/")), row2, "refused", refusal10);
       actions.push(action);
       if (row2.trigger !== null && action.kind !== "refused" && action.kind !== "unanswered") {
         triggers[row2.name] = row2.trigger;
@@ -28261,13 +28556,13 @@ function applyProposals(files, root, options) {
 }
 
 // src/demote/select.ts
-import { readdirSync as readdirSync12, readFileSync as readFileSync38, realpathSync as realpathSync7, statSync as statSync16 } from "fs";
-import { basename as basename13, dirname as dirname16, join as join45 } from "path";
+import { readdirSync as readdirSync13, readFileSync as readFileSync39, realpathSync as realpathSync7, statSync as statSync18 } from "fs";
+import { basename as basename14, dirname as dirname16, join as join46 } from "path";
 var SKILLS_DIRECTORY = "skills";
 var CLAUDE_DIRECTORY = ".claude";
 var AUTO_EXTRACTED_ORIGIN = "auto-extracted";
-var DEMOTED_PATH = join45(".rafa", "demoted");
-var INSTINCTS_PATH = join45(".rafa", "instincts");
+var DEMOTED_PATH = join46(".rafa", "demoted");
+var INSTINCTS_PATH = join46(".rafa", "instincts");
 var REPORT_FILE = "report.md";
 function realOrSelf(path6) {
   try {
@@ -28284,25 +28579,25 @@ function samePath(left, right) {
   return resolved === other || resolved.toLowerCase() === other.toLowerCase();
 }
 function resolveDemotionScope(dir, home) {
-  if (basename13(dir) !== SKILLS_DIRECTORY)
+  if (basename14(dir) !== SKILLS_DIRECTORY)
     return null;
   const claude = dirname16(dir);
-  if (basename13(claude) !== CLAUDE_DIRECTORY)
+  if (basename14(claude) !== CLAUDE_DIRECTORY)
     return null;
   const base = dirname16(claude);
-  const demotedDir = join45(base, DEMOTED_PATH);
+  const demotedDir = join46(base, DEMOTED_PATH);
   return {
     scope: samePath(base, home) ? "user" : "project",
     dir,
     base,
     demotedDir,
-    instinctsDir: join45(base, INSTINCTS_PATH),
-    reportPath: join45(demotedDir, REPORT_FILE)
+    instinctsDir: join46(base, INSTINCTS_PATH),
+    reportPath: join46(demotedDir, REPORT_FILE)
   };
 }
 function entryKind2(path6) {
   try {
-    const stats = statSync16(path6);
+    const stats = statSync18(path6);
     if (stats.isFile())
       return "file";
     if (stats.isDirectory())
@@ -28314,7 +28609,7 @@ function entryKind2(path6) {
 }
 function visibleNames2(dir) {
   try {
-    return readdirSync12(dir).filter((name2) => !name2.startsWith(".")).sort((left, right) => left.localeCompare(right));
+    return readdirSync13(dir).filter((name2) => !name2.startsWith(".")).sort((left, right) => left.localeCompare(right));
   } catch {
     return [];
   }
@@ -28323,8 +28618,8 @@ function readSelected(absolute, path6, entries) {
   let text2;
   let mtime;
   try {
-    text2 = readFileSync38(absolute, "utf8");
-    mtime = statSync16(absolute).mtime.toISOString();
+    text2 = readFileSync39(absolute, "utf8");
+    mtime = statSync18(absolute).mtime.toISOString();
   } catch {
     return null;
   }
@@ -28339,14 +28634,14 @@ function selectsLearned(text2, scope) {
   return origin === AUTO_EXTRACTED_ORIGIN;
 }
 function selectLearned(scope) {
-  const dir = join45(scope.dir, LEARNED_DIRECTORY);
+  const dir = join46(scope.dir, LEARNED_DIRECTORY);
   if (entryKind2(dir) !== "directory")
     return [];
   const selected = [];
   for (const name2 of visibleNames2(dir)) {
     if (!name2.endsWith(MARKDOWN_EXTENSION) || name2 === MARKDOWN_EXTENSION)
       continue;
-    const absolute = join45(dir, name2);
+    const absolute = join46(dir, name2);
     if (entryKind2(absolute) !== "file")
       continue;
     const file = readSelected(absolute, `${LEARNED_DIRECTORY}/${name2}`, undefined);
@@ -28360,10 +28655,10 @@ function selectSkillFiles(scope) {
   for (const name2 of visibleNames2(scope.dir)) {
     if (name2 === LEARNED_DIRECTORY)
       continue;
-    const skillDir = join45(scope.dir, name2);
+    const skillDir = join46(scope.dir, name2);
     if (entryKind2(skillDir) !== "directory")
       continue;
-    const absolute = join45(skillDir, SKILL_FILE);
+    const absolute = join46(skillDir, SKILL_FILE);
     if (entryKind2(absolute) !== "file")
       continue;
     const file = readSelected(absolute, `${name2}/${SKILL_FILE}`, visibleNames2(skillDir));
@@ -28411,7 +28706,7 @@ Usage: ${BACKFILL_USAGE}`);
     throw new CommandExit(1, `\u274C Expected one directory, and read "${extra}" as a second
 Usage: ${BACKFILL_USAGE}`);
   }
-  return resolve20(cwd(), dir);
+  return resolve22(cwd(), dir);
 }
 function readConsumerRoot(value, cwd) {
   if (value === undefined || value === false)
@@ -28420,11 +28715,11 @@ function readConsumerRoot(value, cwd) {
     throw new CommandExit(1, `\u274C --project needs a path, and the line gave it none
 Usage: ${BACKFILL_USAGE}`);
   }
-  return resolve20(cwd(), value);
+  return resolve22(cwd(), value);
 }
 function isDirectory3(path6) {
   try {
-    return statSync17(path6).isDirectory();
+    return statSync19(path6).isDirectory();
   } catch {
     return false;
   }
@@ -28548,7 +28843,7 @@ function reviewedProposals(dir) {
   return read2.flatMap((entry) => entry.result.file === null ? [] : [entry.result.file]);
 }
 function rowPaths(files, root) {
-  return files.flatMap((file) => file.status !== REVIEWED_FILE ? [] : file.rows.filter((row2) => row2.status === ANSWERED_ROW).map((row2) => join46(root, ...row2.path.split("/"))));
+  return files.flatMap((file) => file.status !== REVIEWED_FILE ? [] : file.rows.filter((row2) => row2.status === ANSWERED_ROW).map((row2) => join47(root, ...row2.path.split("/"))));
 }
 function runApply(context, scope, backfillDir, projectRoot3) {
   const options = checkOptions(context, projectRoot3);
@@ -28594,7 +28889,7 @@ async function runBackfill(context, seams) {
   const dir = readBackfillDirectory(context.args, seams.cwd);
   const projectRoot3 = readConsumerRoot(context.flags["project"], seams.cwd);
   const scope = backfillScopeOf(dir, projectOf8(context).home);
-  const backfillDir = join46(scope.base, BACKFILL_PATH);
+  const backfillDir = join47(scope.base, BACKFILL_PATH);
   if (mode === "propose") {
     await runPropose(context, scope, backfillDir, seams);
     return;
@@ -28707,13 +29002,13 @@ function createSkillCheckCommand(seams = DEFAULT_CHECK_SEAMS) {
 var check_default2 = createSkillCheckCommand();
 
 // src/commands/skill/demote.ts
-import { existsSync as existsSync35, mkdirSync as mkdirSync16, readFileSync as readFileSync40, statSync as statSync19, writeFileSync as writeFileSync19 } from "fs";
-import { dirname as dirname18, resolve as resolve21 } from "path";
+import { existsSync as existsSync36, mkdirSync as mkdirSync17, readFileSync as readFileSync41, statSync as statSync21, writeFileSync as writeFileSync19 } from "fs";
+import { dirname as dirname18, resolve as resolve23 } from "path";
 
 // src/demote/apply.ts
-import { copyFileSync as copyFileSync4, existsSync as existsSync34, mkdirSync as mkdirSync15, mkdtempSync, readdirSync as readdirSync13, readFileSync as readFileSync39, renameSync as renameSync4, rmSync as rmSync3, statSync as statSync18, unlinkSync, writeFileSync as writeFileSync18 } from "fs";
+import { copyFileSync as copyFileSync4, existsSync as existsSync35, mkdirSync as mkdirSync16, mkdtempSync, readdirSync as readdirSync14, readFileSync as readFileSync40, renameSync as renameSync4, rmSync as rmSync3, statSync as statSync20, unlinkSync as unlinkSync2, writeFileSync as writeFileSync18 } from "fs";
 import { tmpdir } from "os";
-import { dirname as dirname17, join as join47 } from "path";
+import { dirname as dirname17, join as join48 } from "path";
 var DEMOTION_ACTION_KINDS = [
   "demoted",
   "kept",
@@ -28734,18 +29029,18 @@ function learnedSkillName(path6) {
   return base.slice(0, -MARKDOWN_EXTENSION.length);
 }
 function sourcePath(scope, path6) {
-  return join47(scope.dir, ...path6.split("/"));
+  return join48(scope.dir, ...path6.split("/"));
 }
 function demotedPath(scope, path6) {
-  return join47(scope.demotedDir, ...path6.split("/"));
+  return join48(scope.demotedDir, ...path6.split("/"));
 }
 function promotedPath(scope, path6) {
-  return join47(scope.dir, learnedSkillName(path6), SKILL_FILE);
+  return join48(scope.dir, learnedSkillName(path6), SKILL_FILE);
 }
 function takenInstinctIds(dir) {
   let names;
   try {
-    names = readdirSync13(dir);
+    names = readdirSync14(dir);
   } catch {
     return [];
   }
@@ -28753,7 +29048,7 @@ function takenInstinctIds(dir) {
 }
 function readText6(path6) {
   try {
-    return statSync18(path6).isFile() ? readFileSync39(path6, "utf8") : null;
+    return statSync20(path6).isFile() ? readFileSync40(path6, "utf8") : null;
   } catch {
     return null;
   }
@@ -28781,7 +29076,7 @@ function planKept(scope, row2, file) {
     return inert3(row2.path, "procedure", "kept", "procedure-shaped: left where it is, for the backfill");
   }
   const to = promotedPath(scope, row2.path);
-  if (existsSync34(to) || existsSync34(dirname17(to))) {
+  if (existsSync35(to) || existsSync35(dirname17(to))) {
     return inert3(row2.path, "procedure", "refused", `kept as a skill, but ${to} is already there`);
   }
   return {
@@ -28795,7 +29090,7 @@ function planKept(scope, row2, file) {
   };
 }
 function checkCandidate(dir, id, text2, pathDirs) {
-  const path6 = join47(dir, `${id}${MARKDOWN_EXTENSION}`);
+  const path6 = join48(dir, `${id}${MARKDOWN_EXTENSION}`);
   writeFileSync18(path6, text2, "utf8");
   const report3 = checkFile(path6, "instinct", { projectRoot: null, pathDirs });
   return failureLines2(report3.issues);
@@ -28816,11 +29111,11 @@ function planDemoted(scope, row2, file, context) {
   if (failures.length > 0) {
     return inert3(row2.path, "observation", "refused", `the record ${id} fails the checker \u2014 ${failures.join("; ")}`);
   }
-  const destination = join47(scope.instinctsDir, `${id}${MARKDOWN_EXTENSION}`);
+  const destination = join48(scope.instinctsDir, `${id}${MARKDOWN_EXTENSION}`);
   const kept = demotedPath(scope, row2.path);
-  if (existsSync34(destination))
+  if (existsSync35(destination))
     return inert3(row2.path, "observation", "refused", `${destination} is already there`);
-  if (existsSync34(kept))
+  if (existsSync35(kept))
     return inert3(row2.path, "observation", "refused", `${kept} is already there`);
   context.taken.push(id);
   return {
@@ -28852,7 +29147,7 @@ function planRow(scope, row2, context) {
     entries: undefined,
     absolute,
     hash,
-    mtime: statSync18(absolute).mtime.toISOString()
+    mtime: statSync20(absolute).mtime.toISOString()
   };
   return verdict === "procedure" ? planKept(scope, row2, file) : planDemoted(scope, row2, file, context);
 }
@@ -28863,7 +29158,7 @@ function countActions(actions) {
   return counts;
 }
 function planDemotion(report3, scope, seams = DEFAULT_APPLY_SEAMS) {
-  const temp = mkdtempSync(join47(tmpdir(), "rafa-demote-"));
+  const temp = mkdtempSync(join48(tmpdir(), "rafa-demote-"));
   const taken = [...takenInstinctIds(scope.instinctsDir)];
   try {
     const actions = report3.rows.map((row2) => planRow(scope, row2, { temp, taken, seams }));
@@ -28873,18 +29168,18 @@ function planDemotion(report3, scope, seams = DEFAULT_APPLY_SEAMS) {
   }
 }
 function moveFile(move) {
-  mkdirSync15(dirname17(move.to), { recursive: true });
+  mkdirSync16(dirname17(move.to), { recursive: true });
   try {
     renameSync4(move.from, move.to);
   } catch {
     copyFileSync4(move.from, move.to);
-    unlinkSync(move.from);
+    unlinkSync2(move.from);
   }
 }
 function applyDemotion(plan2) {
   for (const action of plan2.actions) {
     if (action.write !== null) {
-      mkdirSync15(dirname17(action.write.path), { recursive: true });
+      mkdirSync16(dirname17(action.write.path), { recursive: true });
       writeFileSync18(action.write.path, action.write.text, "utf8");
     }
     if (action.move !== null)
@@ -28950,11 +29245,11 @@ Usage: ${DEMOTE_USAGE}`);
     throw new CommandExit(1, `\u274C Expected one directory, and read "${extra}" as a second
 Usage: ${DEMOTE_USAGE}`);
   }
-  return resolve21(cwd(), dir);
+  return resolve23(cwd(), dir);
 }
 function isDirectory4(path6) {
   try {
-    return statSync19(path6).isDirectory();
+    return statSync21(path6).isDirectory();
   } catch {
     return false;
   }
@@ -28982,9 +29277,9 @@ function verdictLine(report3) {
   return `${String(report3.rows.length)} file(s): ${parts.join(", ")}`;
 }
 function previousReport(path6, context) {
-  if (!existsSync35(path6))
+  if (!existsSync36(path6))
     return null;
-  const parsed = parseDemotionReport(readFileSync40(path6, "utf8"));
+  const parsed = parseDemotionReport(readFileSync41(path6, "utf8"));
   if (parsed.report !== null)
     return parsed.report;
   context.output.warn(`the report already at ${path6} does not parse, so no override in it is carried forward:` + ` ${parsed.issues.map((issue4) => `line ${String(issue4.line)} ${issue4.code}`).join(", ")}`);
@@ -28993,7 +29288,7 @@ function previousReport(path6, context) {
 function runWrite(context, scope) {
   const files = selectSources(scope);
   const report3 = buildDemotionReport(files, previousReport(scope.reportPath, context));
-  mkdirSync16(dirname18(scope.reportPath), { recursive: true });
+  mkdirSync17(dirname18(scope.reportPath), { recursive: true });
   writeFileSync19(scope.reportPath, writeDemotionReport(report3), "utf8");
   const result = {
     applied: false,
@@ -29017,10 +29312,10 @@ function runWrite(context, scope) {
     context.output.info(line);
 }
 function reviewedReport(scope) {
-  if (!existsSync35(scope.reportPath)) {
+  if (!existsSync36(scope.reportPath)) {
     throw new CommandExit(1, `\u274C No report at ${scope.reportPath}; run "rafa skill demote ${scope.dir}" first, then review it`);
   }
-  const parsed = parseDemotionReport(readFileSync40(scope.reportPath, "utf8"));
+  const parsed = parseDemotionReport(readFileSync41(scope.reportPath, "utf8"));
   if (parsed.report === null) {
     const lines = parsed.issues.map((issue4) => `   line ${String(issue4.line)} ${issue4.code}: ${issue4.message}`);
     throw new CommandExit(1, [`\u274C ${scope.reportPath} does not parse:`, ...lines].join(`
@@ -29125,7 +29420,7 @@ function createSkillDemoteCommand(seams = DEFAULT_DEMOTE_SEAMS) {
 var demote_default = createSkillDemoteCommand();
 
 // src/commands/skill/list.ts
-import { readFileSync as readFileSync41 } from "fs";
+import { readFileSync as readFileSync42 } from "fs";
 var DEFAULT_SKILL_LIST_SEAMS = Object.freeze({
   entry: () => Bun.main
 });
@@ -29145,7 +29440,7 @@ Usage: ${USAGE28}`);
 function skillStack(path6) {
   let text2;
   try {
-    text2 = readFileSync41(path6, "utf8");
+    text2 = readFileSync42(path6, "utf8");
   } catch {
     return [];
   }