@open-tomato/rafa 0.36.0 → 0.37.0

package/dist/cli.js

@@ -2236,7 +2236,7 @@ function restoreRunningCommand(previous) {
 var running = null;
 
 // package.json
-var name = "@open-tomato/rafa", version = "0.36.0";
+var name = "@open-tomato/rafa", version = "0.37.0";
 var init_package = () => {};
 
 // src/cli/version.ts
@@ -10361,6 +10361,64 @@ var init_claude2 = __esm(() => {
   };
 });
 
+// src/adapters/tracker/github-edit.ts
+function viewedEditable(payload, labelNames) {
+  if (!isMapping(payload))
+    return `${describeValue(payload)}, expected a mapping`;
+  const { title: title2, body, state, author } = payload;
+  if (typeof title2 !== "string")
+    return `title ${describeValue(title2)}, expected a string`;
+  if (typeof body !== "string")
+    return `body ${describeValue(body)}, expected a string`;
+  if (state !== "OPEN" && state !== "CLOSED")
+    return `state ${describeValue(state)}, expected "OPEN" or "CLOSED"`;
+  const labels = labelNames(payload["labels"]);
+  if (labels === null)
+    return "labels that are not a list of named labels";
+  const login = isMapping(author) ? author["login"] : undefined;
+  if (typeof login !== "string")
+    return `author ${describeValue(author)}, expected a mapping holding a string login`;
+  return { title: title2, body, open: state === "OPEN", labels, author: login };
+}
+function editProblem(change) {
+  if (!isMapping(change))
+    return `the change is ${describeValue(change)}, expected a mapping`;
+  const { body, title: title2 } = change;
+  if (body === undefined && title2 === undefined)
+    return "the change names neither a body nor a title";
+  if (body !== undefined && typeof body !== "string")
+    return `body is ${describeValue(body)}, expected a string`;
+  return title2 !== undefined && typeof title2 !== "string" ? `title is ${describeValue(title2)}, expected a string` : null;
+}
+function optionalFlag(name2, value) {
+  return value === undefined ? [] : [name2, value];
+}
+function createGithubEditMembers(readers) {
+  const { run, issueNumberOf, parseJson, labelNames } = readers;
+  const editable = async (ref) => {
+    const number = issueNumberOf(ref);
+    const command = `gh issue view ${number}`;
+    const stdout = await run(["issue", "view", number, ...optionalFlag("--repo", ref.repo), "--json", EDITABLE_FIELDS], command);
+    const viewed = viewedEditable(parseJson(stdout, command), labelNames);
+    if (typeof viewed === "string")
+      throw new Error(`${PREFIX2}: ${command} answered ${viewed}`);
+    return { ref, ...viewed };
+  };
+  const edit = async (ref, change) => {
+    const number = issueNumberOf(ref);
+    const problem = editProblem(change);
+    if (problem !== null)
+      throw new TypeError(`${PREFIX2}: refused an edit of issue #${number}: ${problem}`);
+    const bodyFlag = change.body === undefined ? [] : ["--body-file", "-"];
+    await run(["issue", "edit", number, ...optionalFlag("--repo", ref.repo), ...optionalFlag("--title", change.title), ...bodyFlag], `gh issue edit ${number}`, change.body);
+  };
+  return Object.freeze({ editable, edit });
+}
+var PREFIX2 = "github tracker", EDITABLE_FIELDS = "title,body,state,labels,author";
+var init_github_edit = __esm(() => {
+  init_config_sections();
+});
+
 // src/adapters/tracker/issue-values.ts
 var TYPE_MEMBERS, PRIORITY_MEMBERS, STATE_MEMBERS, ISSUE_TYPES, ISSUE_PRIORITIES, ISSUE_STATES;
 var init_issue_values = __esm(() => {
@@ -10397,7 +10455,7 @@ var init_issue_values = __esm(() => {
 // src/adapters/tracker/github.ts
 function createGhRunner(options) {
   const { cwd, command = "gh", env, timeoutMs } = options;
-  return async (args) => {
+  return async (args, stdin) => {
     const executable = env === undefined ? command : Bun.which(command, { PATH: env.PATH ?? "", cwd });
     if (executable === null) {
       return { ok: false, stdout: "", stderr: notOnPath(command, cwd, env?.PATH) };
@@ -10406,7 +10464,7 @@ function createGhRunner(options) {
       const proc = Bun.spawn([executable, ...args], {
         cwd,
         ...env === undefined ? {} : { env: { ...env } },
-        stdin: "ignore",
+        stdin: stdin === undefined ? "ignore" : new TextEncoder().encode(stdin),
         stdout: "pipe",
         stderr: "pipe"
       });
@@ -10460,7 +10518,7 @@ function isRepoName(value) {
 function isLabelPart(value) {
   return typeof value === "string" && !value.includes(",");
 }
-function optionalFlag(name2, value) {
+function optionalFlag2(name2, value) {
   return value === undefined ? [] : [name2, value];
 }
 function detailOf(result) {
@@ -10484,13 +10542,13 @@ function labelsFor(draft) {
 }
 function issueNumberOfRef(ref) {
   if (ref.kind !== "github") {
-    throw new Error(`${PREFIX2}: refused a ref of kind ${describeValue(ref.kind)}; this tracker reads github refs only`);
+    throw new Error(`${PREFIX3}: refused a ref of kind ${describeValue(ref.kind)}; this tracker reads github refs only`);
   }
   if (!isIssueNumber3(ref.externalId)) {
-    throw new Error(`${PREFIX2}: externalId ${describeValue(ref.externalId)} is not a GitHub issue number,` + " expected a positive whole number with no leading zero");
+    throw new Error(`${PREFIX3}: externalId ${describeValue(ref.externalId)} is not a GitHub issue number,` + " expected a positive whole number with no leading zero");
   }
   if (ref.repo !== undefined && !isRepoName(ref.repo)) {
-    throw new Error(`${PREFIX2}: repo ${describeValue(ref.repo)} is not a repository, expected owner/name`);
+    throw new Error(`${PREFIX3}: repo ${describeValue(ref.repo)} is not a repository, expected owner/name`);
   }
   return ref.externalId;
 }
@@ -10498,7 +10556,7 @@ function parseJson(stdout, command) {
   try {
     return JSON.parse(stdout);
   } catch (error) {
-    throw new Error(`${PREFIX2}: ${command} wrote output that is not JSON: ${messageOf(error)}`, {
+    throw new Error(`${PREFIX3}: ${command} wrote output that is not JSON: ${messageOf(error)}`, {
       cause: error
     });
   }
@@ -10532,19 +10590,19 @@ function viewedIssue(stdout, number) {
   const payload = parseJson(stdout, command);
   const problem = viewProblem(payload, number);
   if (problem !== null)
-    throw new Error(`${PREFIX2}: ${command} answered ${problem}`);
+    throw new Error(`${PREFIX3}: ${command} answered ${problem}`);
   const checked = payload;
   return { ...checked, labels: labelNames(checked.labels) ?? [] };
 }
 function listedRows(stdout) {
   const payload = parseJson(stdout, LIST_COMMAND);
   if (!Array.isArray(payload)) {
-    throw new Error(`${PREFIX2}: ${LIST_COMMAND} answered ${describeValue(payload)}, expected a list`);
+    throw new Error(`${PREFIX3}: ${LIST_COMMAND} answered ${describeValue(payload)}, expected a list`);
   }
   return payload;
 }
 function rowRefusal(index, problem) {
-  return new Error(`${PREFIX2}: ${LIST_COMMAND} answered row ${index} ${problem}`);
+  return new Error(`${PREFIX3}: ${LIST_COMMAND} answered row ${index} ${problem}`);
 }
 function listedRow(row2, index) {
   if (!isMapping(row2))
@@ -10617,15 +10675,15 @@ function readBackState(state) {
 function stateQueryRefusal(state) {
   const bucket = REST_STATES[state];
   const siblings = ISSUE_STATES.filter((other) => other !== state && REST_STATES[other] === bucket);
-  return `${PREFIX2}: find cannot narrow by state ${describeValue(state)}: GitHub holds an issue open or` + ` closed, and ${state} shares ${bucket} with ${siblings.join(", ")}, so a result would include` + " those too. Search without a state, then read each issue with get.";
+  return `${PREFIX3}: find cannot narrow by state ${describeValue(state)}: GitHub holds an issue open or` + ` closed, and ${state} shares ${bucket} with ${siblings.join(", ")}, so a result would include` + " those too. Search without a state, then read each issue with get.";
 }
 function createGithubTracker(options) {
   const { gh } = options;
   let knownLabels = new Set;
-  async function run(args, command) {
-    const result = await gh(args);
+  async function run(args, command, stdin) {
+    const result = await gh(args, stdin);
     if (!result.ok)
-      throw new Error(`${PREFIX2}: ${command} failed: ${detailOf(result)}`);
+      throw new Error(`${PREFIX3}: ${command} failed: ${detailOf(result)}`);
     return result.stdout;
   }
   async function ensureLabels(names) {
@@ -10658,7 +10716,7 @@ function createGithubTracker(options) {
     create: async (draft) => {
       const problem = draftProblem(draft);
       if (problem !== null)
-        throw new TypeError(`${PREFIX2}: refused to file an invalid draft: ${problem}`);
+        throw new TypeError(`${PREFIX3}: refused to file an invalid draft: ${problem}`);
       const labels = labelsFor(draft);
       await ensureLabels(labels);
       const stdout = await run([
@@ -10674,20 +10732,20 @@ function createGithubTracker(options) {
 `).at(-1) ?? "";
       const number = CREATED_ISSUE_URL.exec(url)?.[1];
       if (number === undefined) {
-        throw new Error(`${PREFIX2}: gh issue create exited 0 and printed no issue URL, so the issue may exist` + ` unrecorded; it wrote ${describeValue(stdout)}`);
+        throw new Error(`${PREFIX3}: gh issue create exited 0 and printed no issue URL, so the issue may exist` + ` unrecorded; it wrote ${describeValue(stdout)}`);
       }
       return { opt: draft.opt, kind: "github", externalId: number, url, module: draft.module };
     },
     get: async (ref) => {
       const number = issueNumberOfRef(ref);
-      const stdout = await run(["issue", "view", number, ...optionalFlag("--repo", ref.repo), "--json", VIEW_FIELDS], `gh issue view ${number}`);
+      const stdout = await run(["issue", "view", number, ...optionalFlag2("--repo", ref.repo), "--json", VIEW_FIELDS], `gh issue view ${number}`);
       return issueOf2(ref, viewedIssue(stdout, number));
     },
     find: async (query) => {
       if (query.state !== undefined)
         throw new Error(stateQueryRefusal(query.state));
       if (query.module !== undefined && !isLabelPart(query.module)) {
-        throw new TypeError(`${PREFIX2}: find refused module ${describeValue(query.module)}, expected a string holding no comma`);
+        throw new TypeError(`${PREFIX3}: find refused module ${describeValue(query.module)}, expected a string holding no comma`);
       }
       const moduleLabel = query.module === undefined ? undefined : `${GITHUB_LABELS.modulePrefix}${query.module}`;
       const typeLabel = query.type === undefined ? undefined : `${GITHUB_LABELS.typePrefix}${query.type}`;
@@ -10700,15 +10758,15 @@ function createGithubTracker(options) {
         LIST_FIELDS,
         "--limit",
         String(query.limit ?? DEFAULT_FIND_LIMIT),
-        ...optionalFlag("--label", moduleLabel),
-        ...optionalFlag("--label", typeLabel),
-        ...optionalFlag("--search", query.text)
+        ...optionalFlag2("--label", moduleLabel),
+        ...optionalFlag2("--label", typeLabel),
+        ...optionalFlag2("--search", query.text)
       ], LIST_COMMAND);
       return listedIssues(stdout).map(refOfRow);
     },
     openIssues: async (type) => {
       if (!isOneOf2(ISSUE_TYPES, type)) {
-        throw new TypeError(`${PREFIX2}: openIssues refused type ${describeValue(type)}, expected one of: ${ISSUE_TYPES.join(", ")}`);
+        throw new TypeError(`${PREFIX3}: openIssues refused type ${describeValue(type)}, expected one of: ${ISSUE_TYPES.join(", ")}`);
       }
       const stdout = await run([
         "issue",
@@ -10727,21 +10785,21 @@ function createGithubTracker(options) {
     comment: async (ref, body) => {
       const number = issueNumberOfRef(ref);
       if (typeof body !== "string") {
-        throw new TypeError(`${PREFIX2}: refused a comment body ${describeValue(body)}, expected a string`);
+        throw new TypeError(`${PREFIX3}: refused a comment body ${describeValue(body)}, expected a string`);
       }
-      await run(["issue", "comment", number, ...optionalFlag("--repo", ref.repo), "--body", body], `gh issue comment ${number}`);
+      await run(["issue", "comment", number, ...optionalFlag2("--repo", ref.repo), "--body", body], `gh issue comment ${number}`);
     },
     transition: async (ref, state) => {
       const number = issueNumberOfRef(ref);
       if (!isOneOf2(ISSUE_STATES, state)) {
-        throw new TypeError(`${PREFIX2}: refused state ${describeValue(state)}, expected one of: ${ISSUE_STATES.join(", ")}`);
+        throw new TypeError(`${PREFIX3}: refused state ${describeValue(state)}, expected one of: ${ISSUE_STATES.join(", ")}`);
       }
       if (REST_STATES[state] === "closed") {
         const path = `repos/${ref.repo ?? "{owner}/{repo}"}/issues/${number}`;
         const reason = state === "cancelled" ? "not_planned" : "completed";
         await run(["api", path, "-X", "PATCH", "-f", "state=closed", "-f", `state_reason=${reason}`], `gh api PATCH ${path}`);
       } else {
-        await run(["issue", "reopen", number, ...optionalFlag("--repo", ref.repo)], `gh issue reopen ${number}`);
+        await run(["issue", "reopen", number, ...optionalFlag2("--repo", ref.repo)], `gh issue reopen ${number}`);
       }
       const readBack = readBackState(state);
       if (readBack === state)
@@ -10749,13 +10807,15 @@ function createGithubTracker(options) {
       return {
         warning: `issue #${number} is now ${REST_STATES[state]}, but GitHub Issues without a board` + ` holds no ${state} state, so get reads it back as ${readBack}`
       };
-    }
+    },
+    ...createGithubEditMembers({ run, issueNumberOf: issueNumberOfRef, parseJson, labelNames })
   };
   return Object.freeze(tracker);
 }
-var PREFIX2 = "github tracker", GITHUB_LABELS, VIEW_FIELDS = "number,title,body,state,stateReason,labels,url", LIST_COMMAND = "gh issue list", LIST_FIELDS = "number,url,labels", OPEN_LIST_FIELDS = "number,url,labels,title,body", OPEN_ISSUES_LIMIT = 1000, DEFAULT_FIND_LIMIT = 30, CANCELLED_REASONS, ISSUE_NUMBER, REPO_PART, CREATED_ISSUE_URL, REST_STATES, TIMED_OUT, DRAFT_CHECKS;
+var PREFIX3 = "github tracker", GITHUB_LABELS, VIEW_FIELDS = "number,title,body,state,stateReason,labels,url", LIST_COMMAND = "gh issue list", LIST_FIELDS = "number,url,labels", OPEN_LIST_FIELDS = "number,url,labels,title,body", OPEN_ISSUES_LIMIT = 1000, DEFAULT_FIND_LIMIT = 30, CANCELLED_REASONS, ISSUE_NUMBER, REPO_PART, CREATED_ISSUE_URL, REST_STATES, TIMED_OUT, DRAFT_CHECKS;
 var init_github = __esm(() => {
   init_config_sections();
+  init_github_edit();
   init_issue_values();
   GITHUB_LABELS = Object.freeze({
     modulePrefix: "module:",
@@ -10882,7 +10942,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(`${PREFIX3}: refused to write an invalid issue: ${problem}`);
+    throw new TypeError(`${PREFIX4}: refused to write an invalid issue: ${problem}`);
   }
   return `---
 ${Bun.YAML.stringify(frontmatter, null, 2)}
@@ -10893,18 +10953,18 @@ function parseLocalIssue(contents, sourcePath) {
   const at = sourcePath === undefined ? "" : ` at ${sourcePath}`;
   const match = FRONTMATTER.exec(contents);
   if (match === null) {
-    throw new Error(`${PREFIX3}: the issue${at} has no YAML frontmatter block`);
+    throw new Error(`${PREFIX4}: 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(`${PREFIX3}: invalid issue${at}: ${messageOf(error)}`, { cause: error });
+    throw new Error(`${PREFIX4}: invalid issue${at}: ${messageOf(error)}`, { cause: error });
   }
   const problem = frontmatterProblem(meta);
   if (problem !== null) {
-    throw new Error(`${PREFIX3}: invalid issue${at}: ${problem}`);
+    throw new Error(`${PREFIX4}: invalid issue${at}: ${problem}`);
   }
   const fields = meta;
   return {
@@ -10936,7 +10996,7 @@ async function listLocalIssues(issuesDir, warn = warnThroughActiveOutput2, reade
     try {
       contents = await readFile3(path, "utf8");
     } catch (error) {
-      throw new Error(`${PREFIX3}: could not read ${path}: ${messageOf(error)}`, { cause: error });
+      throw new Error(`${PREFIX4}: could not read ${path}: ${messageOf(error)}`, { cause: error });
     }
     return { number, path, record: parseLocalIssue(contents, path) };
   }));
@@ -10965,11 +11025,11 @@ function refFor(number, opt) {
 }
 function issueNumberOfRef2(ref) {
   if (ref.kind !== "local") {
-    throw new Error(`${PREFIX3}: refused a ref of kind ${describeValue(ref.kind)}; this tracker reads local refs only`);
+    throw new Error(`${PREFIX4}: 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(`${PREFIX3}: externalId ${describeValue(ref.externalId)} is not a local issue number,` + " expected a positive whole number with no leading zero");
+    throw new Error(`${PREFIX4}: externalId ${describeValue(ref.externalId)} is not a local issue number,` + " expected a positive whole number with no leading zero");
   }
   return number;
 }
@@ -10984,7 +11044,7 @@ function createLocalTracker(options) {
     try {
       contents = await readFile3(path, "utf8");
     } catch (cause) {
-      throw new Error(`${PREFIX3}: no issue ${number} under ${issuesDir}`, { cause });
+      throw new Error(`${PREFIX4}: no issue ${number} under ${issuesDir}`, { cause });
     }
     return { number, record: parseLocalIssue(contents, path) };
   }
@@ -11019,7 +11079,7 @@ function createLocalTracker(options) {
             throw error;
         }
       }
-      throw new Error(`${PREFIX3}: no issue number is left under ${issuesDir}`);
+      throw new Error(`${PREFIX4}: no issue number is left under ${issuesDir}`);
     },
     get: async (ref) => {
       const { record } = await read(ref);
@@ -11045,11 +11105,34 @@ function createLocalTracker(options) {
       const { number, record } = await read(ref);
       await rewrite(number, { ...record, state });
       return {};
+    },
+    editable: async (ref) => {
+      const { number, record } = await read(ref);
+      return {
+        ref: refFor(number, record.draft.opt),
+        title: record.draft.title,
+        body: record.draft.body,
+        open: !CLOSED_STATES.has(record.state),
+        labels: [],
+        author: ""
+      };
+    },
+    edit: async (ref, change) => {
+      if (change.body === undefined && change.title === undefined) {
+        throw new TypeError(`${PREFIX4}: refused an edit naming neither a body nor a title`);
+      }
+      const { number, record } = await read(ref);
+      const draft = {
+        ...record.draft,
+        ...change.body === undefined ? {} : { body: change.body },
+        ...change.title === undefined ? {} : { title: change.title }
+      };
+      await rewrite(number, { ...record, draft });
     }
   };
   return Object.freeze(tracker);
 }
-var PREFIX3 = "local tracker", FRONTMATTER, ISSUE_NUMBER2, CLOSED_STATES, ISSUE_EXTENSION = ".md", FIELD_CHECKS;
+var PREFIX4 = "local tracker", FRONTMATTER, ISSUE_NUMBER2, CLOSED_STATES, ISSUE_EXTENSION = ".md", FIELD_CHECKS;
 var init_local2 = __esm(() => {
   init_config_sections();
   init_active();
@@ -13319,7 +13402,60 @@ function requireTrustedAuthor(item, reading) {
     return;
   throw new CommandExit(TRUST_REFUSAL_EXIT, trustRefusalMessage(item, reading));
 }
-var REPO_PATH = "{owner}/{repo}", TRUSTED_PERMISSIONS, TRUST_REFUSAL_EXIT = 2, REMEDY, UNREPORTED = "the lookup wrote nothing";
+function noLogin(detail) {
+  return { login: null, detail };
+}
+function createGhEditorLogin(options) {
+  const { gh } = options;
+  return async () => {
+    const result = await gh(["api", "user"]);
+    if (!result.ok)
+      return noLogin(detailOf2(result, USER_COMMAND));
+    let payload;
+    try {
+      payload = JSON.parse(result.stdout);
+    } catch (error) {
+      return noLogin(`${USER_COMMAND} wrote output that is not JSON: ${messageOf(error)}`);
+    }
+    if (!isMapping(payload)) {
+      return noLogin(`${USER_COMMAND} answered ${describeValue(payload)}, expected a mapping`);
+    }
+    const login = payload["login"];
+    return typeof login === "string" && isGitHubLogin(login) ? { login, detail: "" } : noLogin(`${USER_COMMAND} answered ${describeValue(login)} as its login, which is not a GitHub login`);
+  };
+}
+async function readEditorTrust(trust, editor) {
+  const read = await editor();
+  if (read.login === null) {
+    return { login: null, trusted: false, refusal: "ownership-unknown", reading: null, detail: read.detail };
+  }
+  const reading = await readBoardTrust(trust, read.login);
+  return {
+    login: read.login,
+    trusted: reading.trusted,
+    refusal: editorRefusalOf(reading),
+    reading,
+    detail: ""
+  };
+}
+function editorRefusalOf(reading) {
+  if (reading.trusted)
+    return null;
+  return reading.refusal === "lookup-failed" ? "ownership-unknown" : "ownership";
+}
+function editorRefusalMessage(item, reading) {
+  const what = `${item.kind} #${String(item.number)}`;
+  if (reading.reading !== null) {
+    const because = trustRefusalClause(item.repo, reading.reading);
+    return `${what} cannot be edited by ${reading.reading.login}, ${because}; a member must make the edit`;
+  }
+  if (reading.trusted) {
+    throw new TypeError("board trust: a trusted editor has no refusal to name");
+  }
+  const detail = reading.detail === "" ? UNREPORTED : reading.detail;
+  return `${what} cannot be edited: the account running the edit could not be read (${detail}); ` + "log gh in with `gh auth login` and run it again";
+}
+var REPO_PATH = "{owner}/{repo}", TRUSTED_PERMISSIONS, TRUST_REFUSAL_EXIT = 2, REMEDY, UNREPORTED = "the lookup wrote nothing", USER_COMMAND = "gh api user";
 var init_trust = __esm(() => {
   init_command();
   init_config_sections();
@@ -16070,7 +16206,7 @@ function optionalText2(value) {
 function requiredText2(value) {
   return value === null ? { reason: "missing-field", problem: "is missing" } : optionalText2(value);
 }
-function optionalFlag2(value) {
+function optionalFlag3(value) {
   return value === null || typeof value === "boolean" ? null : { reason: "unstorable-field", problem: `is ${describeValue7(value)}, not a boolean` };
 }
 function scopeOf2(bug) {
@@ -16163,7 +16299,7 @@ var init_triage = __esm(() => {
   };
   OUT_OF_SCOPE_BUGS = {
     key: "out_of_scope_bugs",
-    checks: [["what", requiredText2], ["artifact", optionalText2], ["security", optionalFlag2]],
+    checks: [["what", requiredText2], ["artifact", optionalText2], ["security", optionalFlag3]],
     insert: `
     INSERT INTO out_of_scope_bugs (
       id, session_id, plan_stub, task_line,
@@ -18462,6 +18598,9 @@ function notesFileName(issue4) {
 function notesPath(specsDir, issue4) {
   return path.join(specsDir, notesFileName(issue4));
 }
+function branchName(issue4, title2) {
+  return `${BRANCH_PREFIX}/${planStub(issue4, title2)}`;
+}
 function pullRequestTitle(issue4, title2) {
   const id = boardId(issue4);
   const spoken = title2.replace(LEADING_ID, "").trim();
@@ -18544,7 +18683,7 @@ function movePreviousCopy(options) {
     mkdirSync9(absoluteDirectory, { recursive: true });
     name2 = linkUnderFreeName(source, absoluteDirectory, savedName, timestamp);
   } catch (error) {
-    throw new Error(`${PREFIX4}: ${path2} could not be moved to ${directory2}: ${messageOf(error)}`, { cause: error });
+    throw new Error(`${PREFIX5}: ${path2} could not be moved to ${directory2}: ${messageOf(error)}`, { cause: error });
   }
   const moved = {
     path: join32(directory2, name2),
@@ -18553,7 +18692,7 @@ function movePreviousCopy(options) {
   try {
     unlinkSync(source);
   } catch (error) {
-    throw new Error(`${PREFIX4}: ${path2} was copied to ${moved.path} but could not be removed: ${messageOf(error)}`, { cause: error });
+    throw new Error(`${PREFIX5}: ${path2} was copied to ${moved.path} but could not be removed: ${messageOf(error)}`, { cause: error });
   }
   return moved;
 }
@@ -18567,10 +18706,10 @@ function countPreviousCopies(repoRoot, specsDir) {
   } catch (error) {
     if (isMissing(error))
       return 0;
-    throw new Error(`${PREFIX4}: ${directory2} could not be read: ${messageOf(error)}`, { cause: error });
+    throw new Error(`${PREFIX5}: ${directory2} could not be read: ${messageOf(error)}`, { cause: error });
   }
 }
-var PREFIX4 = "board previous copy", PREVIOUS_DIR_NAME = "previous", PREVIOUS_COPY_WARN_ABOVE = 50, COPY_EXTENSION = ".md", FIRST_SUFFIX = 2;
+var PREFIX5 = "board previous copy", PREVIOUS_DIR_NAME = "previous", PREVIOUS_COPY_WARN_ABOVE = 50, COPY_EXTENSION = ".md", FIRST_SUFFIX = 2;
 var init_previous_copy = __esm(() => {
   init_config_sections();
 });
@@ -18584,7 +18723,7 @@ function detailOf3(result, command) {
 }
 function issueNumber2(value) {
   if (!Number.isSafeInteger(value) || value < 1) {
-    throw new TypeError(`${PREFIX5}: the read refused issue number ${describeValue(value)}, expected a positive whole number`);
+    throw new TypeError(`${PREFIX6}: the read refused issue number ${describeValue(value)}, expected a positive whole number`);
   }
   return String(value);
 }
@@ -18619,11 +18758,11 @@ function readViewedIssue(stdout, number, command) {
   try {
     payload = JSON.parse(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 });
   }
   const problem = viewProblem2(payload, number);
   if (problem !== null)
-    throw new Error(`${PREFIX5}: ${command} answered ${problem}`);
+    throw new Error(`${PREFIX6}: ${command} answered ${problem}`);
   const checked = payload;
   return {
     number,
@@ -18641,7 +18780,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(`${PREFIX5}: ${detailOf3(result, command)}`);
+      throw new Error(`${PREFIX6}: ${detailOf3(result, command)}`);
     return readViewedIssue(result.stdout, issue4, command);
   };
 }
@@ -18805,7 +18944,7 @@ function writeSpecSnapshot(options) {
     mkdirSync10(dirname19(absolute), { recursive: true });
     writeFileSync9(absolute, text2);
   } catch (error) {
-    throw new Error(`${PREFIX5}: the snapshot ${path2} could not be written: ${messageOf(error)}`, { cause: error });
+    throw new Error(`${PREFIX6}: the snapshot ${path2} could not be written: ${messageOf(error)}`, { cause: error });
   }
   return { ...written, action, previous };
 }
@@ -18819,7 +18958,7 @@ function rewriteAction(existing, body, notes, notesFile, refresh) {
     return "notes-rebuilt";
   return refresh ? "refreshed" : null;
 }
-var PREFIX5 = "board issue", ISSUE_VIEW_FIELDS = "number,title,body,state,labels,author", SPEC_LABEL = "type:spec", ISSUE_REFUSAL_EXIT = 2, LOCAL_NOTES_HEADING = "## Local notes", NOTES_SEPARATOR, HEADING, FENCE2;
+var PREFIX6 = "board issue", ISSUE_VIEW_FIELDS = "number,title,body,state,labels,author", SPEC_LABEL = "type:spec", ISSUE_REFUSAL_EXIT = 2, LOCAL_NOTES_HEADING = "## Local notes", NOTES_SEPARATOR, HEADING, FENCE2;
 var init_issue = __esm(() => {
   init_command();
   init_config_sections();
@@ -19168,7 +19307,7 @@ var init_none = __esm(() => {
 
 // src/pr/gh-closing-issues.ts
 function refuse3(command, problem) {
-  throw new Error(`${PREFIX6}: ${command} answered ${problem}`);
+  throw new Error(`${PREFIX7}: ${command} answered ${problem}`);
 }
 function readMapping(value, command, where) {
   if (!isMapping(value))
@@ -19209,7 +19348,7 @@ function readClosingIssues(value, command, where) {
     refuse3(command, `${where} is ${describeValue(value)}, expected a list`);
   return value.map((reference2, index) => readClosingIssue(reference2, command, `${where}[${index}]`));
 }
-var CLOSING_ISSUES_FIELD = "closingIssuesReferences", PREFIX6 = "gh pull requests";
+var CLOSING_ISSUES_FIELD = "closingIssuesReferences", PREFIX7 = "gh pull requests";
 var init_gh_closing_issues = __esm(() => {
   init_config_sections();
 });
@@ -19222,16 +19361,16 @@ function detailOf4(result, command) {
   return result.ok ? `${command} exited 0 and wrote nothing` : `${command} exited non-zero and wrote nothing`;
 }
 function failure2(command, result) {
-  return new Error(`${PREFIX7}: ${command} failed: ${detailOf4(result, command)}`);
+  return new Error(`${PREFIX8}: ${command} failed: ${detailOf4(result, command)}`);
 }
 function refuse4(command, problem) {
-  throw new Error(`${PREFIX7}: ${command} answered ${problem}`);
+  throw new Error(`${PREFIX8}: ${command} answered ${problem}`);
 }
 function parseJson2(stdout, command) {
   try {
     return JSON.parse(stdout);
   } catch (error) {
-    throw new Error(`${PREFIX7}: ${command} wrote output that is not JSON: ${messageOf(error)}`, { cause: error });
+    throw new Error(`${PREFIX8}: ${command} wrote output that is not JSON: ${messageOf(error)}`, { cause: error });
   }
 }
 function readString3(value, command, where) {
@@ -19371,7 +19510,7 @@ function readWorkflowCount(stdout) {
 }
 function pullNumber(value, member) {
   if (!Number.isSafeInteger(value) || value < 1) {
-    throw new TypeError(`${PREFIX7}: ${member} refused pull request number ${describeValue(value)},` + " expected a positive whole number");
+    throw new TypeError(`${PREFIX8}: ${member} refused pull request number ${describeValue(value)},` + " expected a positive whole number");
   }
   return String(value);
 }
@@ -19379,13 +19518,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 expected2 = whole ? "a positive whole number with no leading zero" : "a non-empty string";
-    throw new TypeError(`${PREFIX7}: ${member} refused ${what} ${describeValue(value)}, expected ${expected2}`);
+    throw new TypeError(`${PREFIX8}: ${member} refused ${what} ${describeValue(value)}, expected ${expected2}`);
   }
   return value;
 }
 function bodyText(value, member) {
   if (typeof value !== "string") {
-    throw new TypeError(`${PREFIX7}: ${member} refused a body ${describeValue(value)}, expected a string`);
+    throw new TypeError(`${PREFIX8}: ${member} refused a body ${describeValue(value)}, expected a string`);
   }
   return value;
 }
@@ -19483,7 +19622,7 @@ function createGhPullRequests(options) {
     merge: async (number, method) => {
       const target = pullNumber(number, "merge");
       if (!isMergeMethod(method)) {
-        throw new TypeError(`${PREFIX7}: merge refused method ${describeValue(method)},` + ` expected one of: ${MERGE_METHODS.join(", ")}`);
+        throw new TypeError(`${PREFIX8}: 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}`]);
@@ -19565,7 +19704,7 @@ function ghPullRequestsIn(cwd) {
 function ghAuthOkIn(cwd) {
   return ghAuthOk(createGhRunner({ cwd }));
 }
-var PREFIX7 = "gh pull requests", REPO_PATH2 = "{owner}/{repo}", SUMMARY_FIELDS = "author,baseRefName,headRefName,isCrossRepository,number,state,title,updatedAt,url", DETAIL_FIELDS, CHECK_FIELDS = "name,state,link", MERGED_FIELDS = "headRefName,headRefOid,mergedAt,number", FILES_FIELDS = "changedFiles,files", REVIEW_FIELDS = "reviews", WORKFLOWS_PATH, LIST_LIMIT = 30, MERGED_LIMIT = 100, FIND_LIMIT = 1, MISSING_PULL = "Could not resolve to a PullRequest", CREATED_URL, NO_CHECKS = "no checks reported on the", LOG_DROPPED = "log not found", WHOLE_NUMBER, STATES, MERGEABILITY;
+var PREFIX8 = "gh pull requests", REPO_PATH2 = "{owner}/{repo}", SUMMARY_FIELDS = "author,baseRefName,headRefName,isCrossRepository,number,state,title,updatedAt,url", DETAIL_FIELDS, CHECK_FIELDS = "name,state,link", MERGED_FIELDS = "headRefName,headRefOid,mergedAt,number", FILES_FIELDS = "changedFiles,files", REVIEW_FIELDS = "reviews", WORKFLOWS_PATH, LIST_LIMIT = 30, MERGED_LIMIT = 100, FIND_LIMIT = 1, MISSING_PULL = "Could not resolve to a PullRequest", CREATED_URL, NO_CHECKS = "no checks reported on the", LOG_DROPPED = "log not found", WHOLE_NUMBER, STATES, MERGEABILITY;
 var init_gh = __esm(() => {
   init_github();
   init_config_sections();
@@ -20144,24 +20283,24 @@ function parseRows(stdout, command) {
   try {
     payload = JSON.parse(stdout);
   } catch (error) {
-    throw new Error(`${PREFIX8}: ${command} wrote output that is not JSON: ${messageOf(error)}`, { cause: error });
+    throw new Error(`${PREFIX9}: ${command} wrote output that is not JSON: ${messageOf(error)}`, { cause: error });
   }
   if (!Array.isArray(payload)) {
-    throw new Error(`${PREFIX8}: ${command} answered ${describeValue(payload)}, expected a list`);
+    throw new Error(`${PREFIX9}: ${command} answered ${describeValue(payload)}, expected a list`);
   }
   return payload;
 }
 function rowNumber(row2, key, command, where) {
   const value = isMapping(row2) ? row2[key] : null;
   if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 1) {
-    throw new Error(`${PREFIX8}: ${command} answered ${where}.${key} as ${describeValue(value)}, expected a positive whole number`);
+    throw new Error(`${PREFIX9}: ${command} answered ${where}.${key} as ${describeValue(value)}, expected a positive whole number`);
   }
   return value;
 }
 function rowText(row2, key, command, where) {
   const value = isMapping(row2) ? row2[key] : null;
   if (typeof value !== "string") {
-    throw new Error(`${PREFIX8}: ${command} answered ${where}.${key} as ${describeValue(value)}, expected a string`);
+    throw new Error(`${PREFIX9}: ${command} answered ${where}.${key} as ${describeValue(value)}, expected a string`);
   }
   return value;
 }
@@ -20173,7 +20312,7 @@ function createGhRoadmapSearch(options) {
   return async () => {
     const result = await gh(args);
     if (!result.ok)
-      throw new Error(`${PREFIX8}: ${detailOf5(result, command)}`);
+      throw new Error(`${PREFIX9}: ${detailOf5(result, command)}`);
     return Object.freeze(parseRows(result.stdout, command).map((row2, index) => ({
       number: rowNumber(row2, "number", command, `issue ${String(index)}`),
       title: rowText(row2, "title", command, `issue ${String(index)}`)
@@ -20210,7 +20349,7 @@ function createGhOpenPullRequests(options) {
   return async () => {
     const result = await gh(args);
     if (!result.ok)
-      throw new Error(`${PREFIX8}: ${detailOf5(result, command)}`);
+      throw new Error(`${PREFIX9}: ${detailOf5(result, command)}`);
     return Object.freeze(parseRows(result.stdout, command).map((row2, index) => ({
       number: rowNumber(row2, "number", command, `pull request ${String(index)}`),
       headRefName: rowText(row2, "headRefName", command, `pull request ${String(index)}`),
@@ -20332,7 +20471,7 @@ function exhaustedMessage(roadmap, skipped2) {
   const id = `issue #${String(roadmap)}`;
   return skipped2.length === 0 ? `the roadmap, ${id}, carries no "- [ ] #<n>" line; add the next spec to its task list` : `every line of the roadmap, ${id}, is done or taken (${String(skipped2.length)} of them);` + " open the next spec issue and add it to the task list";
 }
-var PREFIX8 = "board roadmap", ROADMAP_TITLE = "Roadmap", ROADMAP_SETTING = "roadmap.issue", ROADMAP_REFUSAL_EXIT = 2, DEFAULT_REMOTE2 = "origin", OPEN_PULL_REQUEST_LIMIT = 100, PR_LIST_FIELDS = "number,headRefName,body", ISSUE_LIST_FIELDS = "number,title", TASK_LINE, FENCE3, WHY_SEPARATOR, CLOSING;
+var PREFIX9 = "board roadmap", ROADMAP_TITLE = "Roadmap", ROADMAP_SETTING = "roadmap.issue", ROADMAP_REFUSAL_EXIT = 2, DEFAULT_REMOTE2 = "origin", OPEN_PULL_REQUEST_LIMIT = 100, PR_LIST_FIELDS = "number,headRefName,body", ISSUE_LIST_FIELDS = "number,title", TASK_LINE, FENCE3, WHY_SEPARATOR, CLOSING;
 var init_roadmap = __esm(() => {
   init_command();
   init_config_schema();
@@ -20426,24 +20565,24 @@ function parseRows2(stdout, command) {
   try {
     payload = 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 });
   }
   if (!Array.isArray(payload)) {
-    throw new Error(`${PREFIX9}: ${command} answered ${describeValue(payload)}, expected a list`);
+    throw new Error(`${PREFIX10}: ${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(`${PREFIX9}: ${command} answered ${where}.${key} as ${describeValue(value)}, expected a string`);
+    throw new Error(`${PREFIX10}: ${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(`${PREFIX9}: ${command} answered ${where}.${key} as ${describeValue(value)}, expected a positive whole number`);
+    throw new Error(`${PREFIX10}: ${command} answered ${where}.${key} as ${describeValue(value)}, expected a positive whole number`);
   }
   return value;
 }
@@ -20453,7 +20592,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(`${PREFIX9}: ${detailOf6(result, command)}`);
+    throw new Error(`${PREFIX10}: ${detailOf6(result, command)}`);
   return Object.freeze(parseRows2(result.stdout, command).map((row2, index) => rowText2(row2, "name", command, `label ${String(index)}`)));
 }
 function holdsLabel(held, name2) {
@@ -20505,7 +20644,7 @@ function specTemplateSource(moduleDir = MODULE_DIR) {
 function readSpecTemplate(moduleDir = MODULE_DIR) {
   const source = specTemplateSource(moduleDir);
   if (!existsSync29(source)) {
-    throw new Error(`${PREFIX9}: the spec issue template is missing: no file at ${source}`);
+    throw new Error(`${PREFIX10}: the spec issue template is missing: no file at ${source}`);
   }
   return readFileSync26(source, "utf8");
 }
@@ -20598,7 +20737,7 @@ function roadmapRefused(why) {
 function rowLabels(row2, command, where) {
   const value = isMapping(row2) ? row2["labels"] : null;
   if (!Array.isArray(value)) {
-    throw new Error(`${PREFIX9}: ${command} answered ${where}.labels as ${describeValue(value)}, expected a list`);
+    throw new Error(`${PREFIX10}: ${command} answered ${where}.labels as ${describeValue(value)}, expected a list`);
   }
   return value.map((label, index) => rowText2(label, "name", command, `${where}.labels ${String(index)}`));
 }
@@ -20608,7 +20747,7 @@ async function searchRoadmapIssues(gh) {
   const command = `gh issue list --state open --search "${search}" --json number,title,labels`;
   const result = await gh(args);
   if (!result.ok)
-    throw new Error(`${PREFIX9}: ${detailOf6(result, command)}`);
+    throw new Error(`${PREFIX10}: ${detailOf6(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)}`),
@@ -20620,12 +20759,12 @@ async function createRoadmapIssue(gh) {
   const command = `gh issue create --title ${ROADMAP_TITLE} --label ${ROADMAP_LABEL}`;
   const result = await gh(["issue", "create", "--title", ROADMAP_TITLE, "--label", ROADMAP_LABEL, "--body", roadmapIssueBody()]);
   if (!result.ok)
-    throw new Error(`${PREFIX9}: ${detailOf6(result, command)}`);
+    throw new Error(`${PREFIX10}: ${detailOf6(result, command)}`);
   const url = result.stdout.trim().split(`
 `).at(-1) ?? "";
   const number = CREATED_ISSUE_URL2.exec(url)?.[1];
   if (number === undefined) {
-    throw new Error(`${PREFIX9}: ${command} exited 0 and printed no issue URL, so the issue may exist` + ` unrecorded; it wrote ${describeValue(result.stdout)}`);
+    throw new Error(`${PREFIX10}: ${command} exited 0 and printed no issue URL, so the issue may exist` + ` unrecorded; it wrote ${describeValue(result.stdout)}`);
   }
   return Number.parseInt(number, 10);
 }
@@ -20704,7 +20843,7 @@ async function setUpBoard(options) {
     problems: Object.freeze([...roadmap.problems])
   });
 }
-var PREFIX9 = "board setup", MODULE_DIR, ROADMAP_LABEL, BOARD_LABELS, LABEL_LIST_LIMIT = 100, SPEC_TEMPLATE_PATH, TEMPLATES_DIRNAME = "templates", SPEC_TEMPLATE_FILE = "spec.md", CREATED_ISSUE_URL2, ISSUE_PART_NAME;
+var PREFIX10 = "board setup", MODULE_DIR, ROADMAP_LABEL, BOARD_LABELS, LABEL_LIST_LIMIT = 100, SPEC_TEMPLATE_PATH, TEMPLATES_DIRNAME = "templates", SPEC_TEMPLATE_FILE = "spec.md", CREATED_ISSUE_URL2, ISSUE_PART_NAME;
 var init_setup = __esm(() => {
   init_github();
   init_stale();
@@ -20792,47 +20931,47 @@ function detailOf7(result, command) {
   return written === "" ? `${command} failed and wrote nothing` : `${command} failed: ${written}`;
 }
 function failure3(command, result) {
-  return new Error(`${PREFIX10}: ${detailOf7(result, command)}`);
+  return new Error(`${PREFIX11}: ${detailOf7(result, command)}`);
 }
 function issueNumber3(value, member) {
   if (!Number.isSafeInteger(value) || value < 1) {
-    throw new TypeError(`${PREFIX10}: ${member} refused issue number ${describeValue(value)}, expected a positive whole number`);
+    throw new TypeError(`${PREFIX11}: ${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(`${PREFIX10}: editComment refused comment id ${describeValue(value)},` + " expected a positive whole number with no leading zero");
+    throw new TypeError(`${PREFIX11}: 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(`${PREFIX10}: ${member} refused a body ${describeValue(value)}, expected a string`);
+    throw new TypeError(`${PREFIX11}: ${member} refused a body ${describeValue(value)}, expected a string`);
   }
   return value;
 }
 function closeReason(value) {
   if (!CLOSE_REASONS.includes(value)) {
-    throw new TypeError(`${PREFIX10}: closeIssue refused reason ${describeValue(value)}, expected one of ${CLOSE_REASONS.join(", ")}`);
+    throw new TypeError(`${PREFIX11}: closeIssue refused reason ${describeValue(value)}, expected one of ${CLOSE_REASONS.join(", ")}`);
   }
   return value;
 }
 function closeComment(value, member = "closeIssue") {
   if (commentBody2(value, member).trim() === "") {
-    throw new TypeError(`${PREFIX10}: ${member} refused an empty comment, every close leaves one`);
+    throw new TypeError(`${PREFIX11}: ${member} refused an empty comment, every close leaves one`);
   }
   return value;
 }
 function labelName(value, member, what) {
   if (typeof value !== "string" || value === "" || value.startsWith("-")) {
-    throw new TypeError(`${PREFIX10}: ${member} refused ${what} ${describeValue(value)},` + " expected a non-empty name that does not open with a hyphen");
+    throw new TypeError(`${PREFIX11}: ${member} refused ${what} ${describeValue(value)},` + " expected a non-empty name that does not open with a hyphen");
   }
   return value;
 }
 function issueTitle(value) {
   if (typeof value !== "string" || value.trim() === "" || /[\r\n]/u.test(value)) {
-    throw new TypeError(`${PREFIX10}: createIssue refused the title ${describeValue(value)}, expected one line holding some text`);
+    throw new TypeError(`${PREFIX11}: createIssue refused the title ${describeValue(value)}, expected one line holding some text`);
   }
   return value;
 }
@@ -20841,7 +20980,7 @@ function createdIssue(stdout) {
 `).at(-1)?.trim() ?? "";
   const number = CREATED_ISSUE_URL2.exec(url)?.[1];
   if (number === undefined) {
-    throw new Error(`${PREFIX10}: gh issue create exited 0 and printed no issue URL, so the issue may exist` + ` unrecorded; it wrote ${describeValue(stdout)}`);
+    throw new Error(`${PREFIX11}: gh issue create exited 0 and printed no issue URL, so the issue may exist` + ` unrecorded; it wrote ${describeValue(stdout)}`);
   }
   return Object.freeze({ number: Number(number), url });
 }
@@ -20849,20 +20988,20 @@ function parseJson3(stdout, command) {
   try {
     return JSON.parse(stdout);
   } catch (error) {
-    throw new Error(`${PREFIX10}: ${command} wrote output that is not JSON: ${messageOf(error)}`, { cause: error });
+    throw new Error(`${PREFIX11}: ${command} wrote output that is not JSON: ${messageOf(error)}`, { cause: error });
   }
 }
 function readComment2(value, command, where) {
   if (!isMapping(value)) {
-    throw new Error(`${PREFIX10}: ${command} answered ${where} as ${describeValue(value)}, expected a mapping`);
+    throw new Error(`${PREFIX11}: ${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(`${PREFIX10}: ${command} answered ${where}.id as ${describeValue(id)}, expected a positive whole number`);
+    throw new Error(`${PREFIX11}: ${command} answered ${where}.id as ${describeValue(id)}, expected a positive whole number`);
   }
   const body = value["body"];
   if (typeof body !== "string") {
-    throw new Error(`${PREFIX10}: ${command} answered ${where}.body as ${describeValue(body)}, expected a string`);
+    throw new Error(`${PREFIX11}: ${command} answered ${where}.body as ${describeValue(body)}, expected a string`);
   }
   const user = value["user"];
   const login = isMapping(user) ? user["login"] : null;
@@ -20887,7 +21026,7 @@ function createGhIssueBoard(options) {
       const command = `gh api ${path2}`;
       const rows2 = parseJson3(await succeed(["api", path2], command), command);
       if (!Array.isArray(rows2)) {
-        throw new Error(`${PREFIX10}: ${command} answered ${describeValue(rows2)}, expected a list of comments`);
+        throw new Error(`${PREFIX11}: ${command} answered ${describeValue(rows2)}, expected a list of comments`);
       }
       return rows2.map((row2, index) => readComment2(row2, command, `comment ${String(index)}`));
     },
@@ -20947,7 +21086,7 @@ function createGhIssueBoard(options) {
   };
   return Object.freeze(board);
 }
-var PREFIX10 = "board issue", REPO_PATH3 = "{owner}/{repo}", COMMENT_ID, CLOSE_REASONS;
+var PREFIX11 = "board issue", REPO_PATH3 = "{owner}/{repo}", COMMENT_ID, CLOSE_REASONS;
 var init_issue_board = __esm(() => {
   init_config_sections();
   init_setup();
@@ -20987,14 +21126,14 @@ function warn(warning) {
   return Object.freeze({ outcome: "warning", warning });
 }
 function noBoard(issue4, stage) {
-  return warn(`${PREFIX11}: #${String(issue4)} was not ${stage}: the board is not gh; ${CLAIM_STANDS}`);
+  return warn(`${PREFIX12}: #${String(issue4)} was not ${stage}: the board is not gh; ${CLAIM_STANDS}`);
 }
 async function attempt(issue4, stage, write) {
   try {
     await write();
     return WRITTEN;
   } catch (error) {
-    return warn(`${PREFIX11}: #${String(issue4)} was not ${stage}: ${messageOf(error)}; ${CLAIM_STANDS}`);
+    return warn(`${PREFIX12}: #${String(issue4)} was not ${stage}: ${messageOf(error)}; ${CLAIM_STANDS}`);
   }
 }
 async function labelClaimed(board, issue4) {
@@ -21024,7 +21163,7 @@ async function clearStage(board, issue4, why) {
 async function unlabelReleased(board, issue4) {
   return clearStage(board, issue4, "release");
 }
-var PREFIX11 = "claim labels", CLAIM_STANDS = "the claim stands in git", STAGE_LABELS, WRITTEN;
+var PREFIX12 = "claim labels", CLAIM_STANDS = "the claim stands in git", STAGE_LABELS, WRITTEN;
 var init_labels = __esm(() => {
   init_config_sections();
   init_stale();
@@ -21421,13 +21560,13 @@ function parseBoardListing(stdout, command, mode = "labels") {
   try {
     payload = JSON.parse(stdout);
   } catch (error) {
-    throw new Error(`${PREFIX12}: ${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 });
   }
   if (!Array.isArray(payload)) {
-    throw new Error(`${PREFIX12}: ${command} answered ${describeValue(payload)}, expected a list`);
+    throw new Error(`${PREFIX13}: ${command} answered ${describeValue(payload)}, expected a list`);
   }
   const issues = payload.map((row2, index) => {
-    const refusal3 = `${PREFIX12}: ${command} answered row ${index}`;
+    const refusal3 = `${PREFIX13}: ${command} answered row ${index}`;
     const problem = rowProblem(row2);
     if (problem !== null)
       throw new Error(`${refusal3} with ${problem}`);
@@ -21447,18 +21586,18 @@ function keepListing(listing) {
 function createGhBoardListing(options) {
   const { gh, limit = BOARD_LISTING_LIMIT, mode = "labels" } = options;
   if (!Number.isSafeInteger(limit) || limit < 1) {
-    throw new TypeError(`${PREFIX12}: limit ${describeValue(limit)}, expected a positive whole number`);
+    throw new TypeError(`${PREFIX13}: limit ${describeValue(limit)}, expected a positive whole number`);
   }
   const args = listingArgs(limit, mode);
   const command = boardListingCommand(limit, mode);
   return async () => {
     const result = await gh(args);
     if (!result.ok)
-      throw new Error(`${PREFIX12}: ${detailOf8(result, command)}`);
+      throw new Error(`${PREFIX13}: ${detailOf8(result, command)}`);
     return parseBoardListing(result.stdout, command, mode);
   };
 }
-var PREFIX12 = "board listing", BOARD_LIST_FIELDS = "number,title,body,state,stateReason,labels", nativeBoardListFields, BOARD_LISTING_LIMIT = 1000, NativeFieldProblem, ISSUE_URL;
+var PREFIX13 = "board listing", BOARD_LIST_FIELDS = "number,title,body,state,stateReason,labels", nativeBoardListFields, BOARD_LISTING_LIMIT = 1000, NativeFieldProblem, ISSUE_URL;
 var init_roadmap_board = __esm(() => {
   init_github();
   init_config_sections();
@@ -22039,7 +22178,7 @@ function epicOnListing(number, listing, relations) {
   const epic = readEpics(relations === undefined ? input : { ...input, relations }).epics.find((read) => read.number === number);
   const row2 = listing.find((issue4) => issue4.number === number);
   if (epic === undefined || row2 === undefined) {
-    throw new Error(`${PREFIX13}: epic #${String(number)} is not on the board listing, so its members cannot be read;` + " the listing reads the newest issues only, and an epic it leaves out is not walked as if it had none");
+    throw new Error(`${PREFIX14}: epic #${String(number)} is not on the board listing, so its members cannot be read;` + " the listing reads the newest issues only, and an epic it leaves out is not walked as if it had none");
   }
   return { epic, row: row2 };
 }
@@ -22160,7 +22299,7 @@ function dryEpicSentence(epic) {
 function rowOnListing(number, listing, what) {
   const row2 = listing.find((issue4) => issue4.number === number);
   if (row2 === undefined) {
-    throw new Error(`${PREFIX13}: ${what} #${String(number)} is not on the board listing, so the next ${NOW_HORIZON_LABEL} epic` + " cannot be read; the listing reads the newest issues only, and a line it leaves out is not passed as if it were none");
+    throw new Error(`${PREFIX14}: ${what} #${String(number)} is not on the board listing, so the next ${NOW_HORIZON_LABEL} epic` + " cannot be read; the listing reads the newest issues only, and a line it leaves out is not passed as if it were none");
   }
   return row2;
 }
@@ -22201,7 +22340,7 @@ async function nextNowEpic(request) {
   }
   return null;
 }
-var PREFIX13 = "board epic walk", NOW_HORIZON_LABEL, NO_CLAIMS, UNREAD_DAY, LINE_BREAK;
+var PREFIX14 = "board epic walk", NOW_HORIZON_LABEL, NO_CLAIMS, UNREAD_DAY, LINE_BREAK;
 var init_epic_walk = __esm(() => {
   init_github();
   init_epic_problems();
@@ -22301,11 +22440,11 @@ function driftSentence(finding) {
 }
 function driftLines(report) {
   return Object.freeze([
-    ...report.findings.map((finding) => `${PREFIX14}: ${driftSentence(finding)}`),
-    ...report.notices.map((notice) => `${PREFIX14}: ${notice}`)
+    ...report.findings.map((finding) => `${PREFIX15}: ${driftSentence(finding)}`),
+    ...report.notices.map((notice) => `${PREFIX15}: ${notice}`)
   ]);
 }
-var PREFIX14 = "claim drift";
+var PREFIX15 = "claim drift";
 var init_drift = __esm(() => {
   init_epic_walk();
   init_roadmap_claims();
@@ -23923,7 +24062,7 @@ function createGhBoardLister(options) {
   return async () => {
     const result = await gh(args);
     if (!result.ok)
-      throw new Error(`${PREFIX15}: ${detailOf9(result, command)}`);
+      throw new Error(`${PREFIX16}: ${detailOf9(result, command)}`);
     return parseBoardListing(result.stdout, command, mode);
   };
 }
@@ -23951,7 +24090,7 @@ function unlabelledRoadmapMessage(numbers) {
   const which = numbers.length === 1 ? `open issue ${named} is titled ${ROADMAP_TITLE} but lacks` : `open issues ${named} are titled ${ROADMAP_TITLE} but lack`;
   return `${which} the ${ROADMAP_LABEL} label, so no reader takes it as a board while labelled boards exist;` + " add the label to make it one, or retitle or close it";
 }
-var PREFIX15 = "board listing", BOARDS_LIST_ARGS, BOARDS_LIST_COMMAND;
+var PREFIX16 = "board listing", BOARDS_LIST_ARGS, BOARDS_LIST_COMMAND;
 var init_boards = __esm(() => {
   init_roadmap_board();
   init_roadmap();
@@ -24006,17 +24145,17 @@ function bodyOf2(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(`${PREFIX17}: ${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(`${PREFIX17}: ${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(`${PREFIX17}: ${member} refused issue number ${describeValue(value)}, expected a positive whole number`);
   }
   return String(value);
 }
@@ -24028,7 +24167,7 @@ function createGhRoadmapBody(options) {
       const path2 = pathOf(issue4, "read");
       const result = await gh(["api", path2]);
       if (!result.ok)
-        throw new Error(`${PREFIX16}: ${detailOf10(result, `gh api ${path2}`)}`);
+        throw new Error(`${PREFIX17}: ${detailOf10(result, `gh api ${path2}`)}`);
       return bodyOf2(result.stdout, `gh api ${path2}`);
     },
     write: async (issue4, body) => {
@@ -24036,13 +24175,13 @@ function createGhRoadmapBody(options) {
       const result = await gh(["api", path2, "-X", "PATCH", "-f", `body=${body}`]);
       const command = `gh api ${path2} -X PATCH -f body=<body>`;
       if (!result.ok)
-        throw new Error(`${PREFIX16}: ${detailOf10(result, command)}`);
+        throw new Error(`${PREFIX17}: ${detailOf10(result, command)}`);
       return bodyOf2(result.stdout, command);
     }
   });
 }
 function conflictProblem(issue4) {
-  return `${PREFIX16}: issue #${String(issue4)} answered a body other than the one that was written,` + " so somebody edited it in between";
+  return `${PREFIX17}: issue #${String(issue4)} answered a body other than the one that was written,` + " so somebody edited it in between";
 }
 async function attemptTick(roadmap, issues, board, attempt2) {
   let edit;
@@ -24102,7 +24241,7 @@ function tickSentence(result) {
     return `${named(result.already)} is ticked on ${roadmap} already.`;
   return `${roadmap} carries no line for ${named(result.absent)}, so nothing was ticked.`;
 }
-var PREFIX16 = "board roadmap", REPO_PATH4 = "{owner}/{repo}", TICK_ATTEMPTS = 2, UNTICKED, TICKED = "[x]", LINE_BREAK2;
+var PREFIX17 = "board roadmap", REPO_PATH4 = "{owner}/{repo}", TICK_ATTEMPTS = 2, UNTICKED, TICKED = "[x]", LINE_BREAK2;
 var init_roadmap_tick = __esm(() => {
   init_config_sections();
   init_roadmap();
@@ -24124,7 +24263,7 @@ function joinParts(parts) {
 }
 function checkedIssue(issue4, member) {
   if (!Number.isSafeInteger(issue4) || issue4 < 1) {
-    throw new TypeError(`${PREFIX17}: ${member} refused issue number ${describeValue(issue4)}, expected a positive whole number`);
+    throw new TypeError(`${PREFIX18}: ${member} refused issue number ${describeValue(issue4)}, expected a positive whole number`);
   }
   return issue4;
 }
@@ -24157,7 +24296,7 @@ function lastTextIndex(parts) {
 function appendLine(body, issue4, why = "") {
   checkedIssue(issue4, "appendLine");
   if (LINE_BREAK3.test(why)) {
-    throw new TypeError(`${PREFIX17}: appendLine refused a why spanning several lines: ${describeValue(why)}`);
+    throw new TypeError(`${PREFIX18}: appendLine refused a why spanning several lines: ${describeValue(why)}`);
   }
   if (lineIndicesOf(body, issue4).length > 0)
     return body;
@@ -24182,7 +24321,7 @@ function tickLine(body, issue4) {
   return tickRoadmapLines(body, [checkedIssue(issue4, "tickLine")]).body;
 }
 function unconfirmedProblem(issue4) {
-  return `${PREFIX17}: issue #${String(issue4)} read back without the edit that was written,` + " so somebody edited it in between";
+  return `${PREFIX18}: issue #${String(issue4)} read back without the edit that was written,` + " so somebody edited it in between";
 }
 async function attemptEdit(issue4, edit, board, attempt2) {
   const answered = { issue: issue4, status: "nothing-to-edit", attempts: attempt2 - 1, problem: "" };
@@ -24217,7 +24356,7 @@ async function editChecklists(options) {
   }
   return Object.freeze(results);
 }
-var PREFIX17 = "board epic checklist", BULLET, DEFAULT_BULLET = "- ", LINE_BREAK3, DEFAULT_BREAK = `
+var PREFIX18 = "board epic checklist", BULLET, DEFAULT_BULLET = "- ", LINE_BREAK3, DEFAULT_BREAK = `
 `;
 var init_epic_checklist = __esm(() => {
   init_config_sections();
@@ -24255,24 +24394,24 @@ async function findEpic(slug, options, output) {
   const result = await options.gh(args);
   if (!result.ok) {
     const written = result.stderr.trim() || result.stdout.trim() || "nothing";
-    output.warn(`${PREFIX18}: ${command} failed (${written}); ${id} is planned without its epic`);
+    output.warn(`${PREFIX19}: ${command} failed (${written}); ${id} is planned without its epic`);
     return null;
   }
   let epics;
   try {
     epics = parseBoardListing(result.stdout, command);
   } catch (error) {
-    output.warn(`${PREFIX18}: ${messageOf(error)}; ${id} is planned without its epic`);
+    output.warn(`${PREFIX19}: ${messageOf(error)}; ${id} is planned without its epic`);
     return null;
   }
   const [epic, ...others] = epics;
   if (epic === undefined) {
-    output.warn(`${PREFIX18}: ${id} carries "${label}" but no "${EPIC_TYPE_LABEL}" issue does; it is planned without an epic`);
+    output.warn(`${PREFIX19}: ${id} carries "${label}" but no "${EPIC_TYPE_LABEL}" issue does; it is planned without an epic`);
     return null;
   }
   if (others.length > 0) {
     const found = numbersOf(epics.map((each) => each.number));
-    output.warn(`${PREFIX18}: ${id} carries "${label}" and ${String(epics.length)} epics carry it (${found}); it is planned without an epic`);
+    output.warn(`${PREFIX19}: ${id} carries "${label}" and ${String(epics.length)} epics carry it (${found}); it is planned without an epic`);
     return null;
   }
   return Object.freeze({ number: epic.number, title: epic.title, slug, criteria: readEpicBody(epic.body).criteria });
@@ -24284,7 +24423,7 @@ function nativeEpicOn(listing, options, relations, output) {
   const id = `issue #${String(options.issue)}`;
   const row2 = listing.find((each) => each.number === options.issue);
   if (row2 === undefined) {
-    output.warn(`${PREFIX18}: the board listing holds no ${id}; it is planned without its epic`);
+    output.warn(`${PREFIX19}: the board listing holds no ${id}; it is planned without its epic`);
     return null;
   }
   const epicOf2 = relations.read(listing).epicOf(row2);
@@ -24292,7 +24431,7 @@ function nativeEpicOn(listing, options, relations, output) {
     return null;
   if (epicOf2.kind === "unresolved") {
     const marks = epicOf2.marks.map((each) => each.mark).join(", ");
-    output.warn(`${PREFIX18}: ${id}'s parent ${marks} is no epic on the board; it is planned without an epic`);
+    output.warn(`${PREFIX19}: ${id}'s parent ${marks} is no epic on the board; it is planned without an epic`);
     return null;
   }
   const epic = listing.find((each) => each.number === epicOf2.epic);
@@ -24305,7 +24444,7 @@ async function readNativeEpicContext(options, relations) {
   try {
     return nativeEpicOn(await nativeListing(options), options, relations, output);
   } catch (error) {
-    output.warn(`${PREFIX18}: ${messageOf(error)}; issue #${String(options.issue)} is planned without its epic`);
+    output.warn(`${PREFIX19}: ${messageOf(error)}; issue #${String(options.issue)} is planned without its epic`);
     return null;
   }
 }
@@ -24320,12 +24459,12 @@ async function readEpicContext(options) {
   const output = options.output ?? activeOutput();
   if (others.length > 0) {
     const labels = slugs.map((each) => `"${EPIC_LABEL_PREFIX}${each}"`).join(", ");
-    output.warn(`${PREFIX18}: issue #${String(options.issue)} carries ${String(slugs.length)} epic labels (${labels}); it is planned without an epic`);
+    output.warn(`${PREFIX19}: issue #${String(options.issue)} carries ${String(slugs.length)} epic labels (${labels}); it is planned without an epic`);
     return null;
   }
   return findEpic(slug, options, output);
 }
-var EPIC_TYPE_LABEL = "type:epic", EPIC_CONTEXT_LIMIT = 20, PREFIX18 = "epic context";
+var EPIC_TYPE_LABEL = "type:epic", EPIC_CONTEXT_LIMIT = 20, PREFIX19 = "epic context";
 var init_epic_context = __esm(() => {
   init_active();
   init_config_sections();
@@ -24514,32 +24653,32 @@ function detailOf11(result, command) {
 async function rowsOf3(gh, args, command) {
   const result = await gh(args);
   if (!result.ok)
-    throw new Error(`${PREFIX19}: ${detailOf11(result, command)}`);
+    throw new Error(`${PREFIX20}: ${detailOf11(result, command)}`);
   let parsed;
   try {
     parsed = JSON.parse(result.stdout);
   } catch (error) {
-    throw new Error(`${PREFIX19}: ${command} wrote output that is not JSON: ${messageOf(error)}`, { cause: error });
+    throw new Error(`${PREFIX20}: ${command} wrote output that is not JSON: ${messageOf(error)}`, { cause: error });
   }
   if (!Array.isArray(parsed)) {
-    throw new Error(`${PREFIX19}: ${command} answered ${describeValue(parsed)}, expected a list of issues`);
+    throw new Error(`${PREFIX20}: ${command} answered ${describeValue(parsed)}, expected a list of issues`);
   }
   return parsed;
 }
 function rowNumber3(row2, command, where) {
   if (!isMapping(row2)) {
-    throw new Error(`${PREFIX19}: ${command} answered ${where} as ${describeValue(row2)}, expected a mapping`);
+    throw new Error(`${PREFIX20}: ${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(`${PREFIX19}: ${command} answered ${where}.number as ${describeValue(number)}, expected a positive whole number`);
+    throw new Error(`${PREFIX20}: ${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(`${PREFIX19}: ${command} answered ${where}.body as ${describeValue(body)}, expected a string`);
+    throw new Error(`${PREFIX20}: ${command} answered ${where}.body as ${describeValue(body)}, expected a string`);
   }
   return body;
 }
@@ -24604,7 +24743,7 @@ function renderBlockedIssues(report) {
   const unchecked = report.unchecked === null ? [] : [`  ${report.unchecked}`];
   return [BLOCKED_HEADING, ...body, ...unchecked];
 }
-var BLOCKED_HEADING = "Blocked issues:", BLOCKED_LIST_LIMIT = 100, KNOWN_LIST_LIMIT = 500, PREFIX19 = "board blocked", BLOCKED_ARGS, BLOCKED_COMMAND, KNOWN_ARGS, KNOWN_COMMAND;
+var BLOCKED_HEADING = "Blocked issues:", BLOCKED_LIST_LIMIT = 100, KNOWN_LIST_LIMIT = 500, PREFIX20 = "board blocked", BLOCKED_ARGS, BLOCKED_COMMAND, KNOWN_ARGS, KNOWN_COMMAND;
 var init_doctor_blocked = __esm(() => {
   init_blocked();
   init_config_sections();
@@ -24675,11 +24814,11 @@ async function resolveTracker(options) {
     }
     attempts = [...attempts, Object.freeze({ kind, ok: false, reason: outcome.reason })];
     failures = [...failures, `${kind}: ${outcome.reason}`];
-    log(`${PREFIX20}: ${kind} unavailable: ${outcome.reason}`);
+    log(`${PREFIX21}: ${kind} unavailable: ${outcome.reason}`);
   }
-  throw new Error(`${PREFIX20}: no tracker available; tried ${failures.join(FAILURE_SEPARATOR)}`);
+  throw new Error(`${PREFIX21}: no tracker available; tried ${failures.join(FAILURE_SEPARATOR)}`);
 }
-var PREFIX20 = "tracker chain", FAILURE_SEPARATOR = "; ";
+var PREFIX21 = "tracker chain", FAILURE_SEPARATOR = "; ";
 var init_resolve2 = __esm(() => {
   init_config_sections();
   init_active();
@@ -24825,32 +24964,32 @@ function detailOf12(result, command) {
 async function rowsOf4(gh, args, command) {
   const result = await gh(args);
   if (!result.ok)
-    throw new Error(`${PREFIX21}: ${detailOf12(result, command)}`);
+    throw new Error(`${PREFIX22}: ${detailOf12(result, command)}`);
   let parsed;
   try {
     parsed = JSON.parse(result.stdout);
   } catch (error) {
-    throw new Error(`${PREFIX21}: ${command} wrote output that is not JSON: ${messageOf(error)}`, { cause: error });
+    throw new Error(`${PREFIX22}: ${command} wrote output that is not JSON: ${messageOf(error)}`, { cause: error });
   }
   if (!Array.isArray(parsed)) {
-    throw new Error(`${PREFIX21}: ${command} answered ${describeValue(parsed)}, expected a list of issues`);
+    throw new Error(`${PREFIX22}: ${command} answered ${describeValue(parsed)}, expected a list of issues`);
   }
   return parsed;
 }
 function rowNumber4(row2, command, where) {
   if (!isMapping(row2)) {
-    throw new Error(`${PREFIX21}: ${command} answered ${where} as ${describeValue(row2)}, expected a mapping`);
+    throw new Error(`${PREFIX22}: ${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(`${PREFIX21}: ${command} answered ${where}.number as ${describeValue(number)}, expected a positive whole number`);
+    throw new Error(`${PREFIX22}: ${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(`${PREFIX21}: ${command} answered ${where}.body as ${describeValue(body)}, expected a string`);
+    throw new Error(`${PREFIX22}: ${command} answered ${where}.body as ${describeValue(body)}, expected a string`);
   }
   return body;
 }
@@ -25129,7 +25268,7 @@ function createIssueUnblockCommand(seams = DEFAULT_UNBLOCK_SEAMS) {
   };
   return Object.freeze(command);
 }
-var UNBLOCK_USAGE = "rafa issue unblock [<n>] [--all]", ALL_FLAG = "all", ISSUE_NUMBER3, YES_ANSWERS2, PREFIX21 = "board unblock", BLOCKED_ARGS2, BLOCKED_COMMAND2, STATE_ARGS, STATE_COMMAND, DEFAULT_UNBLOCK_SEAMS, WARNED, unblock_default;
+var UNBLOCK_USAGE = "rafa issue unblock [<n>] [--all]", ALL_FLAG = "all", ISSUE_NUMBER3, YES_ANSWERS2, PREFIX22 = "board unblock", BLOCKED_ARGS2, BLOCKED_COMMAND2, STATE_ARGS, STATE_COMMAND, DEFAULT_UNBLOCK_SEAMS, WARNED, unblock_default;
 var init_unblock = __esm(() => {
   init_github();
   init_blocked();
@@ -25314,14 +25453,14 @@ function ref(issue4) {
 }
 function issueNumber4(value, member) {
   if (!Number.isSafeInteger(value) || value < 1) {
-    throw new TypeError(`${PREFIX22}: ${member} refused issue number ${describeValue(value)}, expected a positive whole number`);
+    throw new TypeError(`${PREFIX23}: ${member} refused issue number ${describeValue(value)}, expected a positive whole number`);
   }
   return value;
 }
 function rowOf3(listing, issue4, member) {
   const row2 = listing.find((candidate) => candidate.number === issue4);
   if (row2 === undefined) {
-    throw new Error(`${PREFIX22}: ${member} refused ${ref(issue4)}, which is not on the board listing, so nothing was changed`);
+    throw new Error(`${PREFIX23}: ${member} refused ${ref(issue4)}, which is not on the board listing, so nothing was changed`);
   }
   return row2;
 }
@@ -25331,7 +25470,7 @@ function detailOf13(result) {
 async function sendRelationship(gh, args, what) {
   const result = await gh(args);
   if (!result.ok)
-    throw new Error(`${PREFIX22}: ${what} was refused, so nothing was changed: ${detailOf13(result)}`);
+    throw new Error(`${PREFIX23}: ${what} was refused, so nothing was changed: ${detailOf13(result)}`);
 }
 function labelEditArgs(issue4, removed, added) {
   return [
@@ -25361,7 +25500,7 @@ function ownersOf(listing, slug) {
 function memberRow(listing, issue4, member) {
   const row2 = rowOf3(listing, issueNumber4(issue4, member), member);
   if (row2.type === "epic") {
-    throw new Error(`${PREFIX22}: ${member} refused ${ref(issue4)}, which is an epic, and an epic belongs to no epic; nothing was changed`);
+    throw new Error(`${PREFIX23}: ${member} refused ${ref(issue4)}, which is an epic, and an epic belongs to no epic; nothing was changed`);
   }
   return row2;
 }
@@ -25369,7 +25508,7 @@ function targetSlug(listing, parent) {
   const row2 = rowOf3(listing, issueNumber4(parent, "setParent"), "setParent");
   const slug = epicSlugsOf(row2.labels)[0];
   if (row2.type !== "epic" || slug === undefined) {
-    throw new Error(`${PREFIX22}: setParent refused epic ${ref(parent)}, which is not an epic carrying an ${EPIC_LABEL_PREFIX}` + " label, so it has no label to give; nothing was changed");
+    throw new Error(`${PREFIX23}: setParent refused epic ${ref(parent)}, which is not an epic carrying an ${EPIC_LABEL_PREFIX}` + " label, so it has no label to give; nothing was changed");
   }
   return slug;
 }
@@ -25423,7 +25562,7 @@ function waitingRow(listing, change, member) {
   const row2 = rowOf3(listing, issueNumber4(change.issue, member), member);
   issueNumber4(change.blocker.number, member);
   if (change.blocker.repository === null && change.blocker.number === row2.number) {
-    throw new Error(`${PREFIX22}: ${member} refused to make ${ref(row2.number)} wait on itself; nothing was changed`);
+    throw new Error(`${PREFIX23}: ${member} refused to make ${ref(row2.number)} wait on itself; nothing was changed`);
   }
   return row2;
 }
@@ -25455,7 +25594,7 @@ async function removeLabelsBlocker(seams, listing, change) {
   await sendRelationship(seams.gh, args, what);
   return [written(row2.number, what, "written")];
 }
-var PREFIX22 = "board relations labels", NO_CLAIMS2, UNREAD_DAY2;
+var PREFIX23 = "board relations labels", NO_CLAIMS2, UNREAD_DAY2;
 var init_labels_writes = __esm(() => {
   init_config_sections();
   init_blocked();
@@ -25495,7 +25634,7 @@ function epicOf3(issue4, owners) {
 }
 function membersOf(epic, listing, epics) {
   if (epic.type !== "epic") {
-    throw new TypeError(`${PREFIX23}: membersOf refused #${String(epic.number)}, which is not typed epic, so it has no members`);
+    throw new TypeError(`${PREFIX24}: membersOf refused #${String(epic.number)}, which is not typed epic, so it has no members`);
   }
   const read = epics.find((candidate) => candidate.number === epic.number) ?? epicsOf([...listing, epic]).find((candidate) => candidate.number === epic.number);
   const members = read?.members ?? [];
@@ -25606,7 +25745,7 @@ function createLabelsRelations(options) {
   };
   return Object.freeze(relations);
 }
-var PREFIX23 = "board relations labels", NO_CLAIMS3, UNREAD_DAY3, FOREIGN_TOKEN, LABELS_READS;
+var PREFIX24 = "board relations labels", NO_CLAIMS3, UNREAD_DAY3, FOREIGN_TOKEN, LABELS_READS;
 var init_labels2 = __esm(() => {
   init_merge_tick();
   init_merge_unblock();
@@ -25874,11 +26013,11 @@ function summaryState(summary, members, claims) {
 }
 function withSubIssuesSummary(epic, row2, claims, today) {
   if (row2.number !== epic.number) {
-    throw new TypeError(`${PREFIX24}: row #${String(row2.number)} is not epic #${String(epic.number)}'s row`);
+    throw new TypeError(`${PREFIX25}: row #${String(row2.number)} is not epic #${String(epic.number)}'s row`);
   }
   const summary = row2.subIssuesSummary;
   if (summary === undefined) {
-    throw new TypeError(`${PREFIX24}: epic #${String(epic.number)} was read without subIssuesSummary; ` + "board.relationships is native, so the listing must be read with the native fields");
+    throw new TypeError(`${PREFIX25}: epic #${String(epic.number)} was read without subIssuesSummary; ` + "board.relationships is native, so the listing must be read with the native fields");
   }
   const progress = Object.freeze({
     done: summary.completed,
@@ -25895,7 +26034,7 @@ function withSubIssuesSummary(epic, row2, claims, today) {
     disagreement: disagreementOf(epic.number, state, epic.stored)
   });
 }
-var PREFIX24 = "board epic summary";
+var PREFIX25 = "board epic summary";
 var init_epic_summary = __esm(() => {
   init_epics();
 });
@@ -26438,7 +26577,7 @@ function ref4(issue4) {
 }
 function issueNumber5(value, member) {
   if (!Number.isSafeInteger(value) || value < 1) {
-    throw new TypeError(`${PREFIX25}: ${member} refused issue number ${describeValue(value)}, expected a positive whole number`);
+    throw new TypeError(`${PREFIX26}: ${member} refused issue number ${describeValue(value)}, expected a positive whole number`);
   }
   return value;
 }
@@ -26449,17 +26588,17 @@ function rowOf5(listing, issue4, member) {
   const number = issueNumber5(issue4, member);
   const row2 = listing.find((candidate) => candidate.number === number);
   if (row2 === undefined) {
-    throw new Error(`${PREFIX25}: ${member} refused ${ref4(issue4)}, which is not on the board listing, so nothing was changed`);
+    throw new Error(`${PREFIX26}: ${member} refused ${ref4(issue4)}, which is not on the board listing, so nothing was changed`);
   }
   if (!Object.hasOwn(row2, "parent") || !Object.hasOwn(row2, "blockedBy")) {
-    throw new TypeError(`${PREFIX25}: ${member} refused ${ref4(issue4)}, which was read without parent and blockedBy; ` + "board.relationships is native, so the listing must be read with the native fields");
+    throw new TypeError(`${PREFIX26}: ${member} refused ${ref4(issue4)}, which was read without parent and blockedBy; ` + "board.relationships is native, so the listing must be read with the native fields");
   }
   return { row: row2, fields: { parent: row2.parent ?? null, blockedBy: row2.blockedBy ?? { nodes: [] } } };
 }
 function memberRow2(listing, issue4, member) {
   const found = rowOf5(listing, issue4, member);
   if (found.row.type === "epic") {
-    throw new Error(`${PREFIX25}: ${member} refused ${ref4(issue4)}, which is an epic, and an epic belongs to no epic; nothing was changed`);
+    throw new Error(`${PREFIX26}: ${member} refused ${ref4(issue4)}, which is an epic, and an epic belongs to no epic; nothing was changed`);
   }
   return found;
 }
@@ -26467,7 +26606,7 @@ function targetEpic(listing, parent) {
   const number = issueNumber5(parent, "setParent");
   const row2 = listing.find((candidate) => candidate.number === number);
   if (row2?.type !== "epic") {
-    throw new Error(`${PREFIX25}: setParent refused epic ${ref4(parent)}, which is not an issue typed epic on the board listing;` + " nothing was changed");
+    throw new Error(`${PREFIX26}: setParent refused epic ${ref4(parent)}, which is not an issue typed epic on the board listing;` + " nothing was changed");
   }
   return row2.number;
 }
@@ -26477,7 +26616,7 @@ function normalBlocker(blocker, board, member) {
   if (repository === null || isBoard(repository, board))
     return { number, repository: null };
   if (!REPOSITORY.test(repository)) {
-    throw new TypeError(`${PREFIX25}: ${member} refused blocker repository "${repository}", which is not owner/name`);
+    throw new TypeError(`${PREFIX26}: ${member} refused blocker repository "${repository}", which is not owner/name`);
   }
   return { number, repository };
 }
@@ -26499,7 +26638,7 @@ function written2(issue4, what, status) {
 async function send(gh, issue4, flags, what) {
   const result = await gh(["issue", "edit", String(issue4), ...flags]);
   if (!result.ok)
-    throw new Error(`${PREFIX25}: ${what} was refused, so nothing was changed: ${detailOf14(result)}`);
+    throw new Error(`${PREFIX26}: ${what} was refused, so nothing was changed: ${detailOf14(result)}`);
   return written2(issue4, what, "written");
 }
 async function setNativeParent(seams, listing, change) {
@@ -26523,7 +26662,7 @@ function blockerWrite(seams, listing, change, member) {
   const { row: row2, fields } = rowOf5(listing, change.issue, member);
   const blocker = normalBlocker(change.blocker, seams.repository, member);
   if (blocker.repository === null && blocker.number === row2.number) {
-    throw new Error(`${PREFIX25}: ${member} refused to make ${ref4(row2.number)} wait on itself; nothing was changed`);
+    throw new Error(`${PREFIX26}: ${member} refused to make ${ref4(row2.number)} wait on itself; nothing was changed`);
   }
   return { row: row2, fields, blocker };
 }
@@ -26543,7 +26682,7 @@ async function removeNativeBlocker(seams, listing, change) {
   }
   return send(seams.gh, row2.number, ["--remove-blocked-by", blockerArg(blocker)], what);
 }
-var PREFIX25 = "board relations native", REPOSITORY, GITHUB_HOST2 = "https://github.com";
+var PREFIX26 = "board relations native", REPOSITORY, GITHUB_HOST2 = "https://github.com";
 var init_native_writes = __esm(() => {
   init_config_sections();
   REPOSITORY = /^[^/\s]+\/[^/\s]+$/u;
@@ -26553,7 +26692,7 @@ var init_native_writes = __esm(() => {
 function nativeFieldsOf(row2) {
   const missing2 = NATIVE_KEYS.filter((key) => !Object.hasOwn(row2, key));
   if (missing2.length > 0) {
-    throw new TypeError(`${PREFIX26}: issue #${String(row2.number)} was read without ${missing2.join(", ")}; ` + "board.relationships is native, so the listing must be read with the native fields");
+    throw new TypeError(`${PREFIX27}: issue #${String(row2.number)} was read without ${missing2.join(", ")}; ` + "board.relationships is native, so the listing must be read with the native fields");
   }
   return { parent: row2.parent ?? null, blockedBy: row2.blockedBy ?? { nodes: [] }, subIssues: row2.subIssues ?? { nodes: [] } };
 }
@@ -26587,7 +26726,7 @@ function isChildOf(row2, epic, board) {
 }
 function membersOf3(epic, listing, board) {
   if (epic.type !== "epic") {
-    throw new TypeError(`${PREFIX26}: membersOf refused #${String(epic.number)}, which is not typed epic, so it has no members`);
+    throw new TypeError(`${PREFIX27}: membersOf refused #${String(epic.number)}, which is not typed epic, so it has no members`);
   }
   const { subIssues } = nativeFieldsOf(epic);
   const children = listing.filter((row2) => row2.type !== "epic" && isChildOf(row2, epic.number, board));
@@ -26630,7 +26769,7 @@ function afterNativeMerge() {
 function createNativeRelations(options) {
   const { repository } = options;
   if (!REPOSITORY2.test(repository)) {
-    throw new TypeError(`${PREFIX26}: the board's repository "${repository}" is not owner/name`);
+    throw new TypeError(`${PREFIX27}: the board's repository "${repository}" is not owner/name`);
   }
   const seams = { gh: options.gh, repository };
   const relations = {
@@ -26645,7 +26784,7 @@ function createNativeRelations(options) {
   };
   return Object.freeze(relations);
 }
-var PREFIX26 = "board relations native", NATIVE_KEYS, REPOSITORY2;
+var PREFIX27 = "board relations native", NATIVE_KEYS, REPOSITORY2;
 var init_native = __esm(() => {
   init_roadmap_board();
   init_freed();
@@ -26966,7 +27105,7 @@ function readSavedCopy(absolute, path2) {
       return null;
     return { text: readFileSync31(absolute, "utf8"), savedAt: stat.mtime };
   } catch (error) {
-    throw new Error(`${PREFIX27}: the saved copy ${path2} could not be read: ${messageOf(error)}`, { cause: error });
+    throw new Error(`${PREFIX28}: the saved copy ${path2} could not be read: ${messageOf(error)}`, { cause: error });
   }
 }
 function printChange(change, output) {
@@ -27008,7 +27147,7 @@ async function settleSpecSnapshot(options) {
     throw new CommandExit(ISSUE_REFUSAL_EXIT, snapshotDiffersMessage(path2, issue4.number));
   return write(true);
 }
-var PREFIX27 = "board snapshot settle", DATE_LENGTH = 10;
+var PREFIX28 = "board snapshot settle", DATE_LENGTH = 10;
 var init_snapshot_settle = __esm(() => {
   init_command();
   init_config_sections();
@@ -27243,7 +27382,7 @@ async function walkPlaceEpic(number, listing, readings, relations) {
   const read = readEpics({ issues: rows2, claims: new Set, today: new Date(0), relations }).epics.find((candidate) => candidate.number === number);
   const row2 = rows2.find((issue4) => issue4.number === number);
   if (read === undefined || row2 === undefined) {
-    throw new Error(`${PREFIX28}: epic #${String(number)}, the current place, is not on the board listing, so its members cannot be read`);
+    throw new Error(`${PREFIX29}: epic #${String(number)}, the current place, is not on the board listing, so its members cannot be read`);
   }
   const { checklist, labelOnly, lines } = epicLines(read, row2);
   const epic = Object.freeze({
@@ -27380,7 +27519,7 @@ async function settleBlockedPick(options) {
   }
   return { issue: plannable.line.issue };
 }
-var PREFIX28 = "board spec source roadmap";
+var PREFIX29 = "board spec source roadmap";
 var init_spec_source_roadmap = __esm(() => {
   init_hop_record();
   init_position();
@@ -27479,7 +27618,7 @@ function dryRunLine(what) {
 }
 function requireRoadmapSeams(seams) {
   if (seams === undefined) {
-    throw new TypeError(`${PREFIX29}: ${NEXT_FLAG} was resolved with no roadmap seams`);
+    throw new TypeError(`${PREFIX30}: ${NEXT_FLAG} was resolved with no roadmap seams`);
   }
   return seams;
 }
@@ -27570,7 +27709,7 @@ async function resolveSpecSource(options) {
     })
   });
 }
-var PREFIX29 = "board spec source", SOURCE_FLAGS, SOURCE_REFUSAL_EXIT = 1, ROADMAP_REFUSAL_EXIT2 = 2;
+var PREFIX30 = "board spec source", SOURCE_FLAGS, SOURCE_REFUSAL_EXIT = 1, ROADMAP_REFUSAL_EXIT2 = 2;
 var init_spec_source = __esm(() => {
   init_active();
   init_ahead();
@@ -33103,7 +33242,7 @@ async function walkEpic(epic, listing, readings, picker, relations) {
   const read = readEpics({ issues: rows2, claims: new Set, today: new Date(0), relations }).epics.find((candidate) => candidate.number === epic);
   const row2 = rows2.find((issue4) => issue4.number === epic);
   if (read === undefined || row2 === undefined) {
-    throw new Error(`${PREFIX30}: epic #${String(epic)}, the current place, is not on the board listing, so its members cannot be read`);
+    throw new Error(`${PREFIX31}: epic #${String(epic)}, the current place, is not on the board listing, so its members cannot be read`);
   }
   const pick = await picker(epicLines(read, row2).lines, readings, epic);
   return {
@@ -33245,7 +33384,7 @@ function pickerFor(followed, seams) {
   }
   return native ? nativeHopPick(followed, seams) : waitingPick(seams.blocking);
 }
-var PREFIX30 = "rafa next", plainPick = async (lines, readings) => {
+var PREFIX31 = "rafa next", plainPick = async (lines, readings) => {
   const pick = await pickNextRoadmapLine(lines, readings);
   return { line: pick.line, passed: pick.skipped.length, waiting: [] };
 }, STOP, PASS2, NOTHING_TAKEN;
@@ -34952,7 +35091,7 @@ function ghNextBoard(options) {
 }
 function nextProject(context) {
   if (context.project === null)
-    throw new Error(`${PREFIX31} runs inside a project, and was handed none`);
+    throw new Error(`${PREFIX32} runs inside a project, and was handed none`);
   return context.project;
 }
 function nextConfig(project, warn2) {
@@ -34962,7 +35101,7 @@ function nextConfig(project, warn2) {
     if (!(error instanceof ConfigError))
       throw error;
     throw new CommandExit(1, [
-      `\u274C ${PREFIX31}: the config cannot be used:`,
+      `\u274C ${PREFIX32}: the config cannot be used:`,
       ...error.problems.map((problem) => `   ${problem}`)
     ].join(`
 `));
@@ -35009,7 +35148,7 @@ function openNextSources(context, seams = DEFAULT_NEXT_SOURCE_SEAMS, options = {
     roots: Object.freeze({ root: project.root, home: project.home })
   });
 }
-var PREFIX31 = "rafa next", DEFAULT_BASE_BRANCH = "main", DEFAULT_NEXT_SOURCE_SEAMS;
+var PREFIX32 = "rafa next", DEFAULT_BASE_BRANCH = "main", DEFAULT_NEXT_SOURCE_SEAMS;
 var init_sources = __esm(() => {
   init_github();
   init_boards();
@@ -36955,7 +37094,7 @@ async function readNextState(sources) {
   const found = await firstAnswer(world, rows2.filter((row2) => AHEAD_OF_TREE.has(row2.id))) ?? readTreeModified(world) ?? await firstAnswer(world, rows2.filter((row2) => !AHEAD_OF_TREE.has(row2.id)));
   if (found !== null)
     return answer3(found, world.problems());
-  throw new Error(`${PREFIX32}: no row of the table answered, and the last row answers for every reading`);
+  throw new Error(`${PREFIX33}: no row of the table answered, and the last row answers for every reading`);
 }
 async function readHomeAfterLoop(sources) {
   if (sources.roadmap === undefined)
@@ -36964,7 +37103,7 @@ async function readHomeAfterLoop(sources) {
   const found = homeAfterLoop(reading2);
   return found === null ? null : answer3(found, reading2.problems);
 }
-var PREFIX32 = "rafa next", NEXT_PRECONDITIONS, ROWS, NEXT_STATES, HOP_ROWS_AHEAD_OF, ROADMAP_ROWS, NEXT_ROADMAP_STATES, AHEAD_OF_TREE;
+var PREFIX33 = "rafa next", NEXT_PRECONDITIONS, ROWS, NEXT_STATES, HOP_ROWS_AHEAD_OF, ROADMAP_ROWS, NEXT_ROADMAP_STATES, AHEAD_OF_TREE;
 var init_state = __esm(() => {
   init_blocked_line();
   init_blocked();
@@ -37204,7 +37343,7 @@ function passedWords(action, options) {
 }
 function needed(state, value, what) {
   if (value === null) {
-    throw new Error(`${PREFIX33}: state "${state.id}" proposes "${state.action}" and names no ${what}`);
+    throw new Error(`${PREFIX34}: state "${state.id}" proposes "${state.action}" and names no ${what}`);
   }
   return String(value);
 }
@@ -37221,7 +37360,7 @@ function offeredCommandActions(mode) {
   return OFFERED_COMMAND_ACTIONS[mode];
 }
 function notOffered(state, mode) {
-  return new Error(`${PREFIX33}: state "${state.id}" proposes "${state.action}", which is offered in labels mode only` + ` and board.relationships is ${mode}: the tracker clears a blocker when it closes`);
+  return new Error(`${PREFIX34}: state "${state.id}" proposes "${state.action}", which is offered in labels mode only` + ` and board.relationships is ${mode}: the tracker clears a blocker when it closes`);
 }
 function runsCommand(action) {
   return NEXT_COMMAND_ACTIONS.includes(action);
@@ -37251,13 +37390,13 @@ function actionContext(caller, command, argv) {
 async function runRegistered(caller, name2, argv, step) {
   const command = caller.registry.find(name2.subject, name2.action);
   if (command === undefined) {
-    throw new CommandExit(1, `\u274C ${PREFIX33}: the "${step}" step runs "rafa ${commandSpelling(name2)}", which is registered by nothing`);
+    throw new CommandExit(1, `\u274C ${PREFIX34}: the "${step}" step runs "rafa ${commandSpelling(name2)}", which is registered by nothing`);
   }
   await command.run(actionContext(caller, command, argv));
 }
 function hopWorld(caller, state) {
   if (caller.project === null) {
-    throw new Error(`${PREFIX33}: the action "${state.action}" of state "${state.id}" runs inside a project, and was handed none`);
+    throw new Error(`${PREFIX34}: the action "${state.action}" of state "${state.id}" runs inside a project, and was handed none`);
   }
   return {
     root: caller.project.root,
@@ -37272,7 +37411,7 @@ function hopWorld(caller, state) {
   };
 }
 function noStep(state) {
-  return new Error(`${PREFIX33}: state "${state.id}" proposes "${state.action}" and carries no ${state.action} step`);
+  return new Error(`${PREFIX34}: state "${state.id}" proposes "${state.action}" and carries no ${state.action} step`);
 }
 async function runHopStep(caller, state) {
   const step = state.hop;
@@ -37291,11 +37430,11 @@ async function runAction(caller, state, options = {}) {
   }
   const invocation = actionInvocation(state, options);
   if (invocation === null) {
-    throw new Error(`${PREFIX33}: the action "${state.action}" of state "${state.id}" runs no registered command`);
+    throw new Error(`${PREFIX34}: the action "${state.action}" of state "${state.id}" runs no registered command`);
   }
   await runRegistered(caller, ACTION_COMMANDS[invocation.action], invocation.argv, invocation.action);
 }
-var PREFIX33 = "rafa next", NEXT_IN_PROCESS_ACTIONS, SWITCH_COMMAND, ROADMAP_WORD = "--roadmap", ROADMAP_PASSED_ACTIONS, CLAIM_AHEAD_WORD = "--claim-ahead", ACTION_COMMANDS, NEXT_COMMAND_ACTIONS, LABELS_ONLY_ACTIONS, OFFERED_COMMAND_ACTIONS;
+var PREFIX34 = "rafa next", NEXT_IN_PROCESS_ACTIONS, SWITCH_COMMAND, ROADMAP_WORD = "--roadmap", ROADMAP_PASSED_ACTIONS, CLAIM_AHEAD_WORD = "--claim-ahead", ACTION_COMMANDS, NEXT_COMMAND_ACTIONS, LABELS_ONLY_ACTIONS, OFFERED_COMMAND_ACTIONS;
 var init_actions = __esm(() => {
   init_command();
   init_hint();
@@ -39021,7 +39160,7 @@ function moveBlockers(readings, issue4) {
 }
 function planRelationsMove(listing2, from, to) {
   if (from.mode === to.mode) {
-    throw new TypeError(`${PREFIX34}: refused to move a board from ${from.mode} to ${to.mode}; the two modes must differ`);
+    throw new TypeError(`${PREFIX35}: refused to move a board from ${from.mode} to ${to.mode}; the two modes must differ`);
   }
   const readings = { from: from.read(listing2), to: to.read(listing2), fromMode: from.mode, toMode: to.mode };
   const members = epicsOf2(listing2).reduce((draft, epic) => joined(draft, to.mode === "native" ? toNativeMembers(readings, epic) : toLabelsMembers(readings, epic)), EMPTY2);
@@ -39157,7 +39296,7 @@ async function writeRelationsMove(seams, plan) {
   const marks = await sendInOrder(plan.marks, (mark) => removeMark(seams.gh, bodies, mark));
   return result(writes, true, marks);
 }
-var PREFIX34 = "board relations move", EMPTY2;
+var PREFIX35 = "board relations move", EMPTY2;
 var init_move = __esm(() => {
   init_blocked();
   init_epic_checklist();
@@ -51302,6 +51441,643 @@ var init_create = __esm(() => {
   create_default = createIssueCreateCommand();
 });
 
+// src/board/issue-edit-body.ts
+function trimmedText(text2, what) {
+  const trimmed = text2.replace(TRAILING_WHITESPACE, "");
+  if (trimmed.trim() === "")
+    throw new RangeError(`${what} holds nothing but whitespace`);
+  return trimmed;
+}
+function renderUpdateHeading(now, reason) {
+  const normalised = normaliseReason(reason);
+  if (normalised === "")
+    throw new RangeError("the reason holds nothing but whitespace");
+  return `**Updated ${localDay(now)}, ${normalised}:**`;
+}
+function renderUpdateBlock(now, reason, text2) {
+  return `${renderUpdateHeading(now, reason)}
+
+${trimmedText(text2, "the added text")}`;
+}
+function separatorAfter(body) {
+  if (body === "" || body.endsWith(`
+
+`))
+    return "";
+  return body.endsWith(`
+`) ? `
+` : `
+
+`;
+}
+function appendedBody(body, block2) {
+  return `${body}${separatorAfter(body)}${block2}`;
+}
+function replacedBody(text2) {
+  return trimmedText(text2, "the replacing text");
+}
+function carriesUpdateBlock(body, block2) {
+  const trimmed = body.replace(TRAILING_WHITESPACE, "");
+  if (!trimmed.endsWith(block2))
+    return false;
+  const before = trimmed.slice(0, trimmed.length - block2.length);
+  return before === "" || before.endsWith(`
+`);
+}
+function originalPartHolds(before, after, block2) {
+  if (!after.startsWith(before))
+    return false;
+  const added = after.slice(before.length).replace(TRAILING_WHITESPACE, "");
+  return added === `${separatorAfter(before)}${block2}`;
+}
+var TRAILING_WHITESPACE;
+var init_issue_edit_body = __esm(() => {
+  init_epic_trail();
+  init_epics();
+  TRAILING_WHITESPACE = /\s+$/u;
+});
+
+// src/board/issue-edit-state.ts
+import { readdirSync as readdirSync20, statSync as statSync28 } from "fs";
+import { join as join81, resolve as resolve36 } from "path";
+function isClaimed(labels) {
+  return labels.includes(CLAIMED_LABEL) || labels.includes(IN_DEVELOPMENT_LABEL);
+}
+function refused4(refusal13, branch = null) {
+  return { pass: false, refusal: refusal13, branch };
+}
+function readEditState(input) {
+  if (!input.open)
+    return refused4("closed");
+  if (isClaimed(input.labels)) {
+    const branch = branchName(input.issue, input.title);
+    return input.kind === "append" && input.whileInDevelopment ? { pass: true, staleCopy: true, branch } : refused4("in-development", branch);
+  }
+  const planned = input.savedCopies.length > 0;
+  if (input.kind === "append")
+    return { pass: true, staleCopy: planned, branch: null };
+  if (input.labels.includes(SPEC_READY_LABEL))
+    return refused4("spec-ready");
+  if (planned)
+    return refused4("planned");
+  return { pass: true, staleCopy: false, branch: null };
+}
+function refreshCommand(issue4) {
+  return `rafa plan create --issue=${String(issue4)} --refresh`;
+}
+function staleCopyMessage(issue4, branch) {
+  const n = String(issue4);
+  const refresh = refreshCommand(issue4);
+  if (branch === null) {
+    return `Issue #${n} has a saved copy this edit makes stale: ${refresh} rebuilds it.`;
+  }
+  return `Issue #${n} is under way on ${branch}: the loop plans from the copy it already has, ` + `and ${refresh} rebuilds that copy.`;
+}
+function editName(kind) {
+  if (kind === "append")
+    return "An append to";
+  return kind === "replace" ? "A replace of the body of" : "A title change on";
+}
+function appendLine2(issue4, extra) {
+  return `rafa issue edit ${String(issue4)} --append-file=<file> --reason=<text>${extra}`;
+}
+function editStateRefusalMessage(input, reading2) {
+  if (reading2.pass)
+    throw new TypeError("issue edit state: a passing reading has no refusal to name");
+  const what = `${editName(input.kind)} issue #${String(input.issue)}`;
+  switch (reading2.refusal) {
+    case "closed":
+      return `${what} is refused: the issue is closed, and rafa edits open issues only.`;
+    case "in-development": {
+      const where = `a loop holds it on ${reading2.branch ?? branchName(input.issue, input.title)}`;
+      return input.kind === "append" ? `${what} is refused: ${where}; add --while-in-development for an amendment the loop must not miss.` : `${what} is refused: ${where}, and a spec under way changes by append: ${appendLine2(input.issue, " --while-in-development")}`;
+    }
+    case "spec-ready":
+      return `${what} is refused: it carries ${SPEC_READY_LABEL}, and a ready spec changes by append: ${appendLine2(input.issue, "")}`;
+    case "planned":
+      return `${what} is refused: it has a saved copy under specs.dir, and a planned spec changes by append: ${appendLine2(input.issue, "")}`;
+  }
+}
+function isSavedCopyName(name2, issue4) {
+  const prefix = `${boardId(issue4)}-`;
+  return name2.startsWith(prefix) && name2.endsWith(SPEC_EXTENSION) && name2.length > prefix.length + SPEC_EXTENSION.length && name2 !== notesFileName(issue4);
+}
+function findSavedCopies(root, specsDir, issue4) {
+  const dir = resolve36(root, specsDir);
+  let names2;
+  try {
+    names2 = readdirSync20(dir);
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT")
+      return [];
+    throw error;
+  }
+  return names2.filter((name2) => isSavedCopyName(name2, issue4)).filter((name2) => statSync28(join81(dir, name2)).isFile()).sort().map((name2) => join81(specsDir, name2));
+}
+var init_issue_edit_state = __esm(() => {
+  init_stale();
+  init_naming();
+  init_readiness();
+});
+
+// src/board/issue-edit-text.ts
+function addedTextSource(issue4) {
+  return `the text added to issue #${String(issue4)}`;
+}
+function editedBodySource(issue4) {
+  return `issue #${String(issue4)} as edited`;
+}
+function completenessApplies(labels, before) {
+  return hasSpecLabel(labels) && findReadinessGaps(before).length === 0;
+}
+function requireEditText(input) {
+  requireNoLeak(addedTextSource(input.issue), input.added);
+  if (!completenessApplies(input.labels, input.before))
+    return;
+  requireCompleteSpec(editedBodySource(input.issue), input.after);
+}
+var init_issue_edit_text = __esm(() => {
+  init_issue();
+  init_leak();
+  init_readiness();
+});
+
+// src/commands/issue/edit-run.ts
+import { existsSync as existsSync54, mkdirSync as mkdirSync21, writeFileSync as writeFileSync22 } from "fs";
+import { join as join82 } from "path";
+function editExitCode(outcome2) {
+  return outcome2 === "conflict" ? EDIT_CONFLICT_EXIT : 0;
+}
+function renderReading(reading2) {
+  return `${reading2.gate}: ${reading2.line}`;
+}
+function readSwitch3(flags, name2) {
+  const value = flags[name2];
+  if (value === undefined)
+    return false;
+  if (typeof value === "boolean")
+    return value;
+  if (value === "true" || value === "false")
+    return value === "true";
+  throw lineRefusal(`--${name2} takes no value, and read "${value}" as one`, EDIT_USAGE);
+}
+function readEditIssue(args) {
+  if (args.length > 1) {
+    throw lineRefusal(`Expected one issue number, got ${String(args.length)}: ${args.join(" ")}`, EDIT_USAGE);
+  }
+  const word = args[0];
+  if (word === undefined)
+    throw lineRefusal("Name the issue number to edit", EDIT_USAGE);
+  if (!ISSUE_NUMBER13.test(word)) {
+    throw lineRefusal(`"${word}" is no issue number, which is a whole number from 1`, EDIT_USAGE);
+  }
+  return Number(word);
+}
+function notTogether(first, second, why) {
+  return lineRefusal(`--${first} and --${second} cannot be used together: ${why}`, EDIT_USAGE);
+}
+function readEditFlags(flags) {
+  return {
+    appendFile: readNonBlankFlag(flags, FLAG2.appendFile, EDIT_USAGE),
+    append: readNonBlankFlag(flags, FLAG2.append, EDIT_USAGE),
+    reason: readNonBlankFlag(flags, FLAG2.reason, EDIT_USAGE),
+    replaceFile: readNonBlankFlag(flags, FLAG2.replaceFile, EDIT_USAGE),
+    title: readNonBlankFlag(flags, FLAG2.title, EDIT_USAGE),
+    whileInDevelopment: readSwitch3(flags, FLAG2.whileInDevelopment),
+    dryRun: readSwitch3(flags, FLAG2.dryRun)
+  };
+}
+function appendLine3(issue4, read) {
+  if (read.appendFile !== undefined && read.append !== undefined) {
+    throw notTogether(FLAG2.appendFile, FLAG2.append, "name the added text one way");
+  }
+  if (read.title !== undefined)
+    throw notTogether(FLAG2.title, FLAG2.append, "a title changes under the gates of a replace");
+  if (read.reason === undefined) {
+    throw lineRefusal(`--${FLAG2.reason} is required with an append: --${FLAG2.reason}=<text>`, EDIT_USAGE);
+  }
+  const source = read.appendFile === undefined ? { from: "line", text: read.append ?? "" } : { from: "file", flag: FLAG2.appendFile, path: read.appendFile };
+  return { ...lineOf3(issue4, read, "append", source), reason: read.reason, whileInDevelopment: read.whileInDevelopment };
+}
+function lineOf3(issue4, read, kind, source) {
+  return { issue: issue4, kind, source, reason: null, title: read.title ?? null, whileInDevelopment: false, dryRun: read.dryRun };
+}
+function readEditLine(args, flags) {
+  const issue4 = readEditIssue(args);
+  const read = readEditFlags(flags);
+  const appending = read.appendFile !== undefined || read.append !== undefined;
+  if (appending && read.replaceFile !== undefined) {
+    const appendFlag = read.appendFile === undefined ? FLAG2.append : FLAG2.appendFile;
+    throw notTogether(appendFlag, FLAG2.replaceFile, "an edit either appends or replaces");
+  }
+  if (appending)
+    return appendLine3(issue4, read);
+  if (read.reason !== undefined) {
+    throw lineRefusal(`--${FLAG2.reason} goes with an append only: a replace and a title change take none`, EDIT_USAGE);
+  }
+  if (read.whileInDevelopment) {
+    throw lineRefusal(`--${FLAG2.whileInDevelopment} goes with an append only: a spec under way is never replaced or retitled`, EDIT_USAGE);
+  }
+  if (read.replaceFile !== undefined) {
+    return lineOf3(issue4, read, "replace", { from: "file", flag: FLAG2.replaceFile, path: read.replaceFile });
+  }
+  if (read.title !== undefined)
+    return lineOf3(issue4, read, "title", null);
+  throw lineRefusal(`Name the edit: --${FLAG2.appendFile}, --${FLAG2.append}, --${FLAG2.replaceFile} or --${FLAG2.title}`, EDIT_USAGE);
+}
+async function readEditText(source, stdin) {
+  if (source.from === "line")
+    return source.text;
+  const where = source.path === STDIN_PATH2 ? "standard input" : `"${source.path}"`;
+  let text2;
+  try {
+    text2 = source.path === STDIN_PATH2 ? await stdin() : await Bun.file(source.path).text();
+  } catch (error) {
+    throw lineRefusal(`--${source.flag} cannot read ${where}: ${messageOf(error)}`, EDIT_USAGE);
+  }
+  if (text2.trim() === "")
+    throw lineRefusal(`--${source.flag} read nothing but whitespace from ${where}`, EDIT_USAGE);
+  return text2;
+}
+async function readEditRequest(line, stdin) {
+  const { source, ...rest } = line;
+  if (source === null)
+    return { ...rest, text: null };
+  return { ...rest, text: await readEditText(source, stdin) };
+}
+function requireEditingTracker(tracker) {
+  if (holdsEditing(tracker))
+    return tracker;
+  throw new CommandExit(1, `\u274C The ${tracker.kind} tracker cannot edit an issue: it reads and writes no issue body.`);
+}
+function holdsEditing(tracker) {
+  return tracker.editable !== undefined && tracker.edit !== undefined;
+}
+function planEdit(request, found, now) {
+  const titled = request.title === null ? {} : { title: request.title };
+  if (request.kind === "append") {
+    const block2 = renderUpdateBlock(now, request.reason ?? "", request.text ?? "");
+    const already = carriesUpdateBlock(found.body, block2);
+    const after = already ? found.body : appendedBody(found.body, block2);
+    return { added: request.text ?? "", shown: block2, block: block2, after, already, change: { body: after } };
+  }
+  if (request.kind === "replace") {
+    const body = replacedBody(request.text ?? "");
+    const added = [request.title, body].filter((part) => part !== null).join(`
+
+`);
+    return { added, shown: added, block: null, after: body, already: false, change: { body, ...titled } };
+  }
+  const title2 = request.title ?? "";
+  return { added: title2, shown: title2, block: null, after: found.body, already: false, change: { title: title2 } };
+}
+function trustedLine(reading2, repo) {
+  return reading2.source === "allow-list" ? `${reading2.login}, listed in board.trustedAuthors` : `${reading2.login}, who has write access to ${repo}`;
+}
+function gatesFor(request) {
+  const readings = [];
+  return {
+    readings,
+    pass: (gate, line) => {
+      readings.push({ gate, line });
+    },
+    refuse: (refusal13, sentence) => {
+      throw new EditRefusal(refusal13, sentence, [...readings], request.dryRun);
+    }
+  };
+}
+async function weighOwnership(options, found, gates) {
+  const { request, tracker } = options;
+  if (tracker.kind === ACCOUNTLESS_KIND) {
+    gates.pass("editor", LOCAL_OWNERSHIP);
+    gates.pass("author", LOCAL_OWNERSHIP);
+    return;
+  }
+  const trust = options.trust();
+  const item = { kind: "issue", number: request.issue, repo: trust.repo };
+  const editor = await readEditorTrust(trust, options.editor);
+  if (!editor.trusted || editor.reading === null) {
+    gates.refuse(editor.refusal ?? "ownership-unknown", editorRefusalMessage(item, editor));
+  }
+  gates.pass("editor", trustedLine(editor.reading, trust.repo));
+  const author = await readBoardTrust(trust, found.author);
+  if (!author.trusted) {
+    const refusal13 = author.refusal === "lookup-failed" ? "ownership-unknown" : "ownership";
+    gates.refuse(refusal13, trustRefusalMessage(item, author));
+  }
+  gates.pass("author", `#${String(request.issue)} was opened by ${trustedLine(author, trust.repo)}`);
+}
+function weighText(request, found, planned, gates) {
+  try {
+    requireEditText({
+      issue: request.issue,
+      labels: found.labels,
+      before: found.body,
+      added: planned.added,
+      after: planned.after
+    });
+  } catch (error) {
+    if (error instanceof CommandExit)
+      gates.refuse("text", error.message);
+    throw error;
+  }
+  const complete = completenessApplies(found.labels, found.body) ? ", and the edited body still fills the spec template" : "";
+  gates.pass("text", `the added text names no machine path or credential${complete}`);
+}
+function stateLine(input, reading2) {
+  if (reading2.branch !== null) {
+    return `a loop holds it on ${reading2.branch}; --while-in-development lets the append through`;
+  }
+  if (input.savedCopies.length > 0)
+    return `planned, its saved copy at ${input.savedCopies.join(", ")}`;
+  return input.labels.length === 0 ? "open, with no plan and no loop building from it" : `open, labelled ${input.labels.join(", ")}, with no saved copy and no loop building from it`;
+}
+function weighState(options, found, gates) {
+  const { request } = options;
+  const input = {
+    issue: request.issue,
+    title: found.title,
+    open: found.open,
+    labels: found.labels,
+    savedCopies: findSavedCopies(options.root, options.specsDir, request.issue),
+    kind: request.kind,
+    whileInDevelopment: request.whileInDevelopment
+  };
+  const reading2 = readEditState(input);
+  if (!reading2.pass)
+    gates.refuse(reading2.refusal, editStateRefusalMessage(input, reading2));
+  gates.pass("state", stateLine(input, reading2));
+  return reading2;
+}
+function normalised(text2) {
+  return text2.replace(/\r\n/gu, `
+`).replace(TRAILING_WHITESPACE2, "");
+}
+function writeHeld(found, planned, reread) {
+  const { change } = planned;
+  if (change.title !== undefined && reread.title !== change.title)
+    return false;
+  const before = found.body.replace(/\r\n/gu, `
+`);
+  const after = reread.body.replace(/\r\n/gu, `
+`);
+  if (planned.block !== null)
+    return originalPartHolds(before, after, normalised(planned.block));
+  return normalised(after) === normalised(change.body ?? found.body);
+}
+function conflictPaths(issue4, stamp2, attempt5) {
+  const suffix = attempt5 === 1 ? "" : `-${String(attempt5)}`;
+  const name2 = (side) => join82(EDIT_SCRATCH_DIR, `${boardId(issue4)}-edit-${side}-${stamp2}${suffix}.md`);
+  return { before: name2("before"), after: name2("after") };
+}
+function saveConflictBodies(root, issue4, now, before, after) {
+  mkdirSync21(join82(root, EDIT_SCRATCH_DIR), { recursive: true });
+  const stamp2 = fileStamp(now);
+  let attempt5 = 1;
+  let paths = conflictPaths(issue4, stamp2, attempt5);
+  while (existsSync54(join82(root, paths.before)) || existsSync54(join82(root, paths.after))) {
+    attempt5 += 1;
+    paths = conflictPaths(issue4, stamp2, attempt5);
+  }
+  writeFileSync22(join82(root, paths.before), before, { flag: "wx" });
+  writeFileSync22(join82(root, paths.after), after, { flag: "wx" });
+  return paths;
+}
+function heldOutcome(request, state) {
+  if (request.kind !== "append")
+    return "replaced";
+  return state.pass && state.staleCopy ? "stale-copy" : "appended";
+}
+function outcomeMessage(request, outcome2, branch, name2) {
+  switch (outcome2) {
+    case "appended":
+      return `Appended an update to ${name2}; the original part is unchanged.`;
+    case "stale-copy":
+      return `Appended an update to ${name2}. ${staleCopyMessage(request.issue, branch)}`;
+    case "already":
+      return `${name2} already ends with this update; nothing was written.`;
+    case "replaced": {
+      if (request.text === null)
+        return `Changed the title of ${name2}.`;
+      return request.title === null ? `Replaced the body of ${name2}.` : `Replaced the body and the title of ${name2}.`;
+    }
+    case "conflict":
+      throw new TypeError("issue edit: a conflict is worded with the paths it saved");
+  }
+}
+function dryRunMessage(issue4, due, branch) {
+  const stale = due === "stale-copy" ? ` ${staleCopyMessage(issue4, branch)}` : "";
+  return `--dry-run: nothing was written; the edit would answer ${due}.${stale}`;
+}
+function conflictMessage(name2, scratch) {
+  return `The edit was written, but ${name2} read back otherwise: somebody changed it around the write. ` + `The body read before is at ${scratch.before} and the body read after at ${scratch.after}; ` + "compare the two and make the edit again over the body as it stands.";
+}
+function report2(request, planned, readings, fields) {
+  return Object.freeze({
+    ...fields,
+    issue: request.issue,
+    exitCode: editExitCode(fields.outcome),
+    dryRun: request.dryRun,
+    added: planned.shown,
+    readings,
+    refresh: fields.outcome === "stale-copy" ? refreshCommand(request.issue) : null,
+    scratch: null
+  });
+}
+async function runIssueEdit(options) {
+  const { request, tracker } = options;
+  const ref15 = issueRef(tracker, String(request.issue));
+  const name2 = issueName(ref15);
+  const now = options.now();
+  const found = await onTracker(tracker, `read ${name2}`, () => tracker.editable(ref15));
+  const gates = gatesFor(request);
+  await weighOwnership(options, found, gates);
+  const planned = planEdit(request, found, now);
+  weighText(request, found, planned, gates);
+  const state = weighState(options, found, gates);
+  const { branch } = state;
+  function done(outcome2, written3, message) {
+    return report2(request, planned, gates.readings, { outcome: outcome2, written: written3, branch, message });
+  }
+  const due = planned.already ? "already" : heldOutcome(request, state);
+  if (request.dryRun)
+    return done(due, false, dryRunMessage(request.issue, due, branch));
+  if (planned.already)
+    return done("already", false, outcomeMessage(request, "already", branch, name2));
+  await onTracker(tracker, `edit ${name2}`, () => tracker.edit(ref15, planned.change));
+  const reread = await onTracker(tracker, `read ${name2} again after the edit was written`, () => tracker.editable(ref15));
+  if (writeHeld(found, planned, reread))
+    return done(due, true, outcomeMessage(request, due, branch, name2));
+  const scratch = saveConflictBodies(options.root, request.issue, now, found.body, reread.body);
+  return Object.freeze({ ...done("conflict", true, conflictMessage(name2, scratch)), scratch });
+}
+function renderEditReport(made) {
+  if (!made.dryRun)
+    return [made.message];
+  return [...made.readings.map(renderReading), "added:", made.added, made.message];
+}
+async function editIssue2(context, seams) {
+  const line = readEditLine(context.args, context.flags);
+  const request = await readEditRequest(line, seams.stdin ?? (() => Bun.stdin.text()));
+  const project = issueProject(context);
+  const { tracker, data } = await resolveIssueTracker(context, seams);
+  const editing = requireEditingTracker(tracker);
+  const config = issueSubjectConfig(project, () => {
+    return;
+  });
+  const gh = seams.gh ?? createGhRunner({ cwd: project.root });
+  const openGit = seams.openGit ?? createGitRunner;
+  const made = await runIssueEdit({
+    request,
+    tracker: editing,
+    root: project.root,
+    specsDir: config.specsDir,
+    trust: () => ghBoardTrust({
+      gh,
+      trustedAuthors: config.boardTrustedAuthors,
+      repo: boardRepoLabel(openGit(project.root))
+    }),
+    editor: createGhEditorLogin({ gh }),
+    now: seams.now ?? (() => new Date)
+  });
+  return Object.freeze({ ...made, tracker: data });
+}
+var EDIT_USAGE, EDIT_REFUSAL_EXIT, EDIT_CONFLICT_EXIT = 1, EDIT_SCRATCH_DIR, STDIN_PATH2 = "-", ISSUE_NUMBER13, TRAILING_WHITESPACE2, ACCOUNTLESS_KIND = "local", LOCAL_OWNERSHIP = "local: the local tracker holds no accounts, so nobody is asked about", FLAG2, EditRefusal;
+var init_edit_run = __esm(() => {
+  init_github();
+  init_issue_edit_body();
+  init_issue_edit_state();
+  init_issue_edit_text();
+  init_naming();
+  init_plan_spec();
+  init_trust();
+  init_command();
+  init_config_sections();
+  init_git();
+  init_fix_schema2();
+  init_issue_tracker();
+  EDIT_USAGE = "rafa issue edit <n> (--append-file=<file> | --append=<text>) --reason=<text>" + " [--while-in-development] | (--replace-file=<file> [--title=<text>] | --title=<text>) [--dry-run]";
+  EDIT_REFUSAL_EXIT = TRUST_REFUSAL_EXIT;
+  EDIT_SCRATCH_DIR = join82(".rafa", "scratch");
+  ISSUE_NUMBER13 = /^[1-9]\d*$/u;
+  TRAILING_WHITESPACE2 = /\s+$/u;
+  FLAG2 = Object.freeze({
+    appendFile: "append-file",
+    append: "append",
+    reason: "reason",
+    replaceFile: "replace-file",
+    title: "title",
+    dryRun: "dry-run",
+    whileInDevelopment: "while-in-development"
+  });
+  EditRefusal = class EditRefusal extends CommandExit {
+    refusal;
+    readings;
+    constructor(refusal13, sentence, readings, dryRun) {
+      const passed2 = dryRun ? readings.map(renderReading) : [];
+      super(EDIT_REFUSAL_EXIT, [...passed2, `\u274C refused ${refusal13}: ${sentence}`].join(`
+`));
+      this.refusal = refusal13;
+      this.readings = readings;
+    }
+  };
+});
+
+// src/commands/issue/edit.ts
+function createIssueEditCommand(seams = DEFAULT_EDIT_SEAMS) {
+  const command = {
+    name: "issue edit",
+    subject: "issue",
+    action: "edit",
+    summary: "append a dated update to an issue body, or replace its body or title, after four gates",
+    description: "Edits one issue on the tracker the chain lands on, after four gates weighed in order, the first" + " refusal ending the run with nothing written and exit code 2: the account editing must have write" + " access or be in board.trustedAuthors; so must the issue's author; the text added must leak nothing," + " and a complete spec must stay complete; and the issue must be open, its labels and saved spec copies" + " allowing the edit. An append (`--append-file` or `--append`, with `--reason`) adds a block" + " `**Updated <YYYY-MM-DD>, <reason>:**` below the body, leaving the original part byte for byte; the" + " same block already closing the body answers `already`. `--replace-file` replaces the body and" + " `--title` the title. After the write the issue is read again: a body that no longer holds what was" + " written answers `conflict` with exit code 1, the bodies read before and after saved under" + " `.rafa/scratch/`. An append on an issue already planned answers `stale-copy` and names" + " `rafa plan create --issue=<n> --refresh`, which it never runs. `--dry-run` prints each gate's" + " reading and the added part and writes nothing. With `--output=json` the report and the tracker are" + " the data of the terminal result event.",
+    args: [
+      {
+        name: "n",
+        description: "The issue number on the tracker.",
+        type: "string",
+        required: true
+      }
+    ],
+    flags: [
+      {
+        name: "append-file",
+        description: "A file holding the text to append, read whole; `-` reads standard input." + " Needs --reason. Not with --append, --replace-file or --title.",
+        type: "string"
+      },
+      {
+        name: "append",
+        description: "The text to append. Needs --reason. Not with --append-file, --replace-file or --title.",
+        type: "string"
+      },
+      {
+        name: "reason",
+        description: "Why the update was made, written into its heading. Required with an append, refused otherwise.",
+        type: "string"
+      },
+      {
+        name: "replace-file",
+        description: "A file holding the new body, read whole; `-` reads standard input. Not with an append.",
+        type: "string"
+      },
+      {
+        name: "title",
+        description: "The new title, alone or beside --replace-file. Not with an append.",
+        type: "string"
+      },
+      {
+        name: "while-in-development",
+        description: "Allows an append on an issue a loop has claimed, answering stale-copy. Only with an append.",
+        type: "boolean"
+      },
+      {
+        name: "dry-run",
+        description: "Prints the added part and each gate's reading and writes nothing; a refusal still exits 2.",
+        type: "boolean"
+      }
+    ],
+    examples: [
+      {
+        cmd: 'rafa issue edit 57 --append-file=update.md --reason="scope narrowed"',
+        note: "Appends what update.md holds to #57 below a dated heading naming the reason."
+      },
+      {
+        cmd: 'rafa issue edit 57 --append="Also covers --dry-run." --reason=clarified --dry-run',
+        note: "Prints each gate's reading and the block it would append, and writes nothing."
+      },
+      {
+        cmd: 'rafa issue edit 57 --title="Faster plan show"',
+        note: "Changes the title of #57 and leaves its body alone."
+      },
+      {
+        cmd: "rafa issue edit 57 --replace-file=spec.md --output=json",
+        note: "Replaces the body of #57; the report and the tracker are the data of the result event."
+      }
+    ],
+    outputs: ["text", "json"],
+    run: async (context) => {
+      const made = await editIssue2(context, seams);
+      if (made.exitCode !== 0)
+        throw new CommandExit(made.exitCode, renderEditReport(made).join(`
+`));
+      if (context.outputMode === "json") {
+        context.output.result(made);
+        return;
+      }
+      for (const line of renderEditReport(made))
+        context.output.info(line);
+    }
+  };
+  return Object.freeze(command);
+}
+var DEFAULT_EDIT_SEAMS, edit_default;
+var init_edit = __esm(() => {
+  init_command();
+  init_edit_run();
+  DEFAULT_EDIT_SEAMS = Object.freeze({});
+  edit_default = createIssueEditCommand();
+});
+
 // src/commands/issue/move.ts
 async function moveIssue(context, seams) {
   const [id3, word] = expectTwoArguments(context.args, USAGE28);
@@ -51983,10 +52759,10 @@ var init_pr_lifecycle = __esm(() => {
 });
 
 // src/notices/notices.ts
-import { mkdirSync as mkdirSync21, readFileSync as readFileSync62, writeFileSync as writeFileSync22 } from "fs";
-import { dirname as dirname29, join as join81 } from "path";
+import { mkdirSync as mkdirSync22, readFileSync as readFileSync62, writeFileSync as writeFileSync23 } from "fs";
+import { dirname as dirname29, join as join83 } from "path";
 function noticesPath(home) {
-  return join81(home, ".rafa", "notices.json");
+  return join83(home, ".rafa", "notices.json");
 }
 function isNoticeId(value) {
   return typeof value === "string" && NOTICE_IDS.includes(value);
@@ -52013,8 +52789,8 @@ function readDismissed(home) {
 function writeDismissed(home, ids) {
   const all = NOTICE_IDS.filter((id3) => ids.includes(id3) || readDismissed(home).includes(id3));
   const path4 = noticesPath(home);
-  mkdirSync21(dirname29(path4), { recursive: true });
-  writeFileSync22(path4, `${JSON.stringify({ dismissed: all }, null, 2)}
+  mkdirSync22(dirname29(path4), { recursive: true });
+  writeFileSync23(path4, `${JSON.stringify({ dismissed: all }, null, 2)}
 `);
 }
 function pendingNotices(dismissed) {
@@ -52133,9 +52909,9 @@ var init_budget = __esm(() => {
 });
 
 // src/start/checkout-guard.ts
-import { existsSync as existsSync54, realpathSync as realpathSync14 } from "fs";
+import { existsSync as existsSync55, realpathSync as realpathSync14 } from "fs";
 function realDirOf(path4) {
-  if (!existsSync54(path4))
+  if (!existsSync55(path4))
     return null;
   try {
     return realpathSync14(path4);
@@ -52446,17 +53222,17 @@ function truncateDescription(description, budget) {
   const cut2 = lastSpace > 0 ? window.slice(0, lastSpace) : window.slice(0, budget);
   return balanceCodeSpans(cut2.trimEnd()).replace(/[\s,;:-]+$/, "");
 }
-function subjectDescription(normalised) {
-  const clause = firstClause(normalised);
-  const description = clause.length === 0 ? normalised : clause;
+function subjectDescription(normalised2) {
+  const clause = firstClause(normalised2);
+  const description = clause.length === 0 ? normalised2 : clause;
   return lowerFirstWord(stripTrailingPeriod(description));
 }
 function deriveCommitSubject(taskText, options = {}) {
   const type = inferCommitType(taskText);
   const scope = options.scope;
   const prefix = scope === undefined || scope.length === 0 ? `${type}: ` : `${type}(${scope}): `;
-  const normalised = normaliseTaskText(taskText);
-  const uncut = normalised.length === 0 ? FALLBACK_DESCRIPTION : subjectDescription(normalised);
+  const normalised2 = normaliseTaskText(taskText);
+  const uncut = normalised2.length === 0 ? FALLBACK_DESCRIPTION : subjectDescription(normalised2);
   const maxLength = options.maxLength ?? MAX_SUBJECT_LENGTH;
   const description = truncateDescription(uncut, maxLength - prefix.length);
   const truncated = description !== uncut;
@@ -52623,11 +53399,11 @@ function indentBlock(text2) {
 `);
 }
 function holdsOf(reading2) {
-  const { report: report2, issues } = reading2;
+  const { report: report3, issues } = reading2;
   const holds2 = [];
-  if (report2.status === "blocked")
+  if (report3.status === "blocked")
     holds2.push("status: blocked");
-  for (const blocker of report2.blockers) {
+  for (const blocker of report3.blockers) {
     holds2.push(`blocker: ${blocker.what ?? "an entry with no usable what"}`);
   }
   for (const issue4 of issues) {
@@ -52810,10 +53586,10 @@ function openingLine(route, plan) {
 \uD83C\uDF3F Switching to the existing ${plan.branch}.`;
 }
 function runRoute(route, plan, git) {
-  const refused4 = treeRefusal(readWorkingTree(git, plan), plan);
-  if (refused4 !== null)
+  const refused5 = treeRefusal(readWorkingTree(git, plan), plan);
+  if (refused5 !== null)
     throw new CommandExit(1, `
-${refused4}`);
+${refused5}`);
   const steps = branchSteps(route, plan);
   activeOutput().info(openingLine(route, plan));
   for (const step2 of steps) {
@@ -53031,9 +53807,9 @@ var init_claim_catch_up = __esm(() => {
 
 // src/start/worktree.ts
 import { realpathSync as realpathSync15 } from "fs";
-import { join as join82, resolve as resolve36 } from "path";
+import { join as join84, resolve as resolve37 } from "path";
 function worktreePathFor(projectRoot3, worktreeDir, stub) {
-  return join82(worktreeDirAt(projectRoot3, worktreeDir), stub);
+  return join84(worktreeDirAt(projectRoot3, worktreeDir), stub);
 }
 function addStep2(route, plan, path4) {
   const label = `add the worktree for ${plan.branch} at ${path4}`;
@@ -53089,7 +53865,7 @@ function canonicalPath(path4) {
   try {
     return realpathSync15(path4);
   } catch {
-    return resolve36(path4);
+    return resolve37(path4);
   }
 }
 function readExisting(listing2, branch, path4) {
@@ -53282,7 +54058,7 @@ function none(reason, detail) {
   return Object.freeze({ owns: null, reason, detail });
 }
 function issueNumberOf2(issue4) {
-  const digits = ISSUE_NUMBER13.exec(issue4?.trim() ?? "")?.[1];
+  const digits = ISSUE_NUMBER14.exec(issue4?.trim() ?? "")?.[1];
   if (digits === undefined)
     return null;
   const number = Number(digits);
@@ -53347,7 +54123,7 @@ async function readPlanOwns(options) {
     return slug;
   return epicOwns(issue4, slug, options.gh);
 }
-var ISSUE_NUMBER13;
+var ISSUE_NUMBER14;
 var init_owns = __esm(() => {
   init_board_owns();
   init_epic_context();
@@ -53355,7 +54131,7 @@ var init_owns = __esm(() => {
   init_issue();
   init_roadmap_board();
   init_config_sections();
-  ISSUE_NUMBER13 = /^#?(\d+)$/u;
+  ISSUE_NUMBER14 = /^#?(\d+)$/u;
 });
 
 // src/suite/unhandled.ts
@@ -53442,8 +54218,8 @@ var init_unhandled = __esm(() => {
 });
 
 // src/suite/run.ts
-import { existsSync as existsSync55, mkdirSync as mkdirSync22, readFileSync as readFileSync63, rmSync as rmSync12, writeFileSync as writeFileSync23 } from "fs";
-import { basename as basename22, dirname as dirname30, extname as extname2, isAbsolute as isAbsolute21, join as join83 } from "path";
+import { existsSync as existsSync56, mkdirSync as mkdirSync23, readFileSync as readFileSync63, rmSync as rmSync12, writeFileSync as writeFileSync24 } from "fs";
+import { basename as basename22, dirname as dirname30, extname as extname2, isAbsolute as isAbsolute21, join as join85 } from "path";
 function readNoTestFiles(stderr) {
   return NO_TEST_FILES_LINE.test(stderr);
 }
@@ -53460,7 +54236,7 @@ function suiteCommand(junitFile, paths, changedSince) {
 function outputFileFor(junitFile) {
   const name2 = basename22(junitFile);
   const stem = name2.endsWith(JUNIT_SUFFIX) ? name2.slice(0, -JUNIT_SUFFIX.length) : name2.slice(0, name2.length - extname2(name2).length);
-  return join83(dirname30(junitFile), `${stem}${OUTPUT_SUFFIX}`);
+  return join85(dirname30(junitFile), `${stem}${OUTPUT_SUFFIX}`);
 }
 function suiteEnv(base) {
   return Object.fromEntries(Object.entries(base).filter(([key]) => key !== CLAUDE_CODE_ENV));
@@ -53563,7 +54339,7 @@ function parseJunitFailures(xml) {
   return walk.failures;
 }
 function readJunit(path4) {
-  if (!existsSync55(path4))
+  if (!existsSync56(path4))
     return { junit: "missing", failures: [] };
   let text2;
   try {
@@ -53591,13 +54367,13 @@ async function runSuite(options) {
   }
   const command = suiteCommand(options.junitFile, options.paths, options.changedSince);
   const outputFile = outputFileFor(options.junitFile);
-  mkdirSync22(dirname30(options.junitFile), { recursive: true });
+  mkdirSync23(dirname30(options.junitFile), { recursive: true });
   rmSync12(options.junitFile, { force: true });
   rmSync12(outputFile, { force: true });
   const spawn = options.spawn ?? spawnSuite;
   const env = suiteEnv(options.env ?? process.env);
   const { exitCode, stderr } = await spawn(command, { cwd: options.cwd, env });
-  writeFileSync23(outputFile, unhandledText(stderr));
+  writeFileSync24(outputFile, unhandledText(stderr));
   const { summary, errors } = readSummary2(stderr);
   const { junit, failures } = readJunit(options.junitFile);
   const unhandled = parseUnhandled(stderr);
@@ -53615,12 +54391,12 @@ var init_run4 = __esm(() => {
 });
 
 // src/suite/scope.ts
-import { existsSync as existsSync56, readdirSync as readdirSync20, readFileSync as readFileSync64 } from "fs";
-import { isAbsolute as isAbsolute22, join as join84, relative as relative17, sep as sep7 } from "path";
+import { existsSync as existsSync57, readdirSync as readdirSync21, readFileSync as readFileSync64 } from "fs";
+import { isAbsolute as isAbsolute22, join as join86, relative as relative17, sep as sep7 } from "path";
 function sortedUnique(paths) {
   return [...new Set(paths)].sort((a, b) => a.localeCompare(b));
 }
-function normalised(paths) {
+function normalised2(paths) {
   return paths.map(normaliseFolder).filter((path4) => path4 !== "");
 }
 function holds2(folder, path4) {
@@ -53628,24 +54404,24 @@ function holds2(folder, path4) {
 }
 function triggeredPaths(diff, triggers) {
   const globs = triggers.globs.map((pattern) => new Bun.Glob(pattern));
-  const preload = new Set(normalised(triggers.preload));
+  const preload = new Set(normalised2(triggers.preload));
   const matches = (path4) => preload.has(path4) || globs.some((glob) => glob.match(path4));
-  return sortedUnique(normalised(diff).filter(matches));
+  return sortedUnique(normalised2(diff).filter(matches));
 }
 function touchedFolders(diff, owns) {
-  const board = { number: 0, owner: null, owns: normalised(owns) };
-  const touched = normalised(diff).map((path4) => owningBoard(path4, [board], null)?.match ?? null);
+  const board = { number: 0, owner: null, owns: normalised2(owns) };
+  const touched = normalised2(diff).map((path4) => owningBoard(path4, [board], null)?.match ?? null);
   return sortedUnique(touched.filter((folder) => folder !== null));
 }
 function testFilesUnder(folders, testFiles) {
-  return sortedUnique(normalised(testFiles).filter((file) => folders.some((folder) => holds2(folder, file))));
+  return sortedUnique(normalised2(testFiles).filter((file) => folders.some((folder) => holds2(folder, file))));
 }
 function integrationFiles(integration, testFiles) {
   const globs = integration.map((pattern) => new Bun.Glob(pattern));
-  return sortedUnique(normalised(testFiles).filter((file) => globs.some((glob) => glob.match(file))));
+  return sortedUnique(normalised2(testFiles).filter((file) => globs.some((glob) => glob.match(file))));
 }
 function ownsFolders(owns) {
-  return owns === null ? [] : normalised(owns);
+  return owns === null ? [] : normalised2(owns);
 }
 function taskStepScope(input) {
   const { declared } = input;
@@ -53696,8 +54472,8 @@ function preloadFilesOf(text2, root) {
   return paths.filter((path4) => path4 !== null);
 }
 function readPreloadFiles(root) {
-  const path4 = join84(root, BUNFIG_FILE);
-  if (!existsSync56(path4))
+  const path4 = join86(root, BUNFIG_FILE);
+  if (!existsSync57(path4))
     return { state: "missing", files: [] };
   try {
     return { state: "read", files: preloadFilesOf(readFileSync64(path4, "utf8"), root) };
@@ -53709,7 +54485,7 @@ function readPreloadFiles(root) {
 function listTestFiles(root) {
   const found = [];
   const walk = (folder) => {
-    for (const entry of readdirSync20(join84(root, folder), { withFileTypes: true })) {
+    for (const entry of readdirSync21(join86(root, folder), { withFileTypes: true })) {
       const path4 = folder === "" ? entry.name : `${folder}/${entry.name}`;
       if (entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== DEPENDENCY_FOLDER)
         walk(path4);
@@ -53728,8 +54504,8 @@ var init_scope2 = __esm(() => {
 });
 
 // src/start/lint-step.ts
-import { existsSync as existsSync57 } from "fs";
-import { join as join85, relative as relative18 } from "path";
+import { existsSync as existsSync58 } from "fs";
+import { join as join87, relative as relative18 } from "path";
 async function runEslint(options) {
   const proc = Bun.spawn([...options.argv], {
     cwd: options.cwd,
@@ -53745,7 +54521,7 @@ async function runEslint(options) {
   return { exitCode, stdout, stderr };
 }
 function hasEslintConfig(checkout) {
-  return ESLINT_CONFIG_FILES.some((name2) => existsSync57(join85(checkout, name2)));
+  return ESLINT_CONFIG_FILES.some((name2) => existsSync58(join87(checkout, name2)));
 }
 function readLintFiles(git, base) {
   const result2 = git(["diff", "--name-only", "-z", "--no-renames", "--diff-filter=d", base, "HEAD"]);
@@ -53867,7 +54643,7 @@ var init_lint_step = __esm(() => {
 });
 
 // src/start/suite-blocker.ts
-import { readFileSync as readFileSync65, writeFileSync as writeFileSync24 } from "fs";
+import { readFileSync as readFileSync65, writeFileSync as writeFileSync25 } from "fs";
 function failingFiles(failures) {
   const counts = new Map;
   for (const failure6 of failures)
@@ -53939,7 +54715,7 @@ function blockRepairAgain(trackerPath, content, line, blocker) {
   const current = lines2[line] ?? "";
   if (current.startsWith(TICKED_PREFIX)) {
     const reopened = [...lines2.slice(0, line), `- [ ] ${current.slice(TICKED_PREFIX.length)}`, ...lines2.slice(line + 1)];
-    writeFileSync24(trackerPath, reopened.join(`
+    writeFileSync25(trackerPath, reopened.join(`
 `), "utf8");
   }
   return writeTrackerBlocker(trackerPath, line, blocker) ? { line, inserted: false } : null;
@@ -53962,7 +54738,7 @@ var init_suite_blocker = __esm(() => {
 });
 
 // src/start/sweep-timing.ts
-import { existsSync as existsSync58, readFileSync as readFileSync66 } from "fs";
+import { existsSync as existsSync59, readFileSync as readFileSync66 } from "fs";
 function fileTimeOf(attributes) {
   const file = attributes["file"] ?? attributes["name"];
   const seconds = Number(attributes["time"]);
@@ -54000,7 +54776,7 @@ function slowSweepLine(slow) {
   return `\uD83D\uDC22 ${slow.length} tests.alwaysRun file(s) took over ${SLOW_SWEEP_SECONDS}s in the task step: ${named3}.`;
 }
 function readFileTimes(path4) {
-  if (!existsSync58(path4))
+  if (!existsSync59(path4))
     return [];
   try {
     return parseJunitFileTimes(readFileSync66(path4, "utf8")) ?? [];
@@ -54165,9 +54941,9 @@ var init_suite_stage_step = __esm(() => {
 });
 
 // src/start/suite-step.ts
-import { existsSync as existsSync59, mkdirSync as mkdirSync23, readFileSync as readFileSync68, renameSync as renameSync11, writeFileSync as writeFileSync25 } from "fs";
+import { existsSync as existsSync60, mkdirSync as mkdirSync24, readFileSync as readFileSync68, renameSync as renameSync11, writeFileSync as writeFileSync26 } from "fs";
 import { constants as constants3 } from "os";
-import { basename as basename23, dirname as dirname31, join as join86 } from "path";
+import { basename as basename23, dirname as dirname31, join as join88 } from "path";
 function seamsOf(context) {
   const seams = context.seams ?? {};
   return {
@@ -54183,15 +54959,15 @@ function seamsOf(context) {
   };
 }
 function junitFileFor(repoRoot, sessionId, kind) {
-  return join86(runsDir(repoRoot), sessionId, "suite", `${kind}.junit.xml`);
+  return join88(runsDir(repoRoot), sessionId, "suite", `${kind}.junit.xml`);
 }
 function alwaysRunJunitFileFor(repoRoot, sessionId, kind = "task") {
-  return join86(runsDir(repoRoot), sessionId, "suite", `${kind}-always-run.junit.xml`);
+  return join88(runsDir(repoRoot), sessionId, "suite", `${kind}-always-run.junit.xml`);
 }
 function stageLedgerPathFor(trackerPath) {
   const baselinePath = baselinePathFor(trackerPath);
   const name2 = basename23(baselinePath).replace(BASELINE_FILE_PREFIX, STAGE_LEDGER_PREFIX);
-  return join86(dirname31(baselinePath), name2);
+  return join88(dirname31(baselinePath), name2);
 }
 function isLedgerEntry(value) {
   if (typeof value !== "object" || value === null)
@@ -54215,7 +54991,7 @@ function parseLedger(text2) {
   return stages;
 }
 function readStageLedger(path4) {
-  if (!existsSync59(path4))
+  if (!existsSync60(path4))
     return [];
   let parsed;
   try {
@@ -54229,9 +55005,9 @@ function readStageLedger(path4) {
   return [];
 }
 function writeStageLedger(path4, entries) {
-  mkdirSync23(dirname31(path4), { recursive: true });
+  mkdirSync24(dirname31(path4), { recursive: true });
   const temporary = `${path4}.${process.pid}.tmp`;
-  writeFileSync25(temporary, `${JSON.stringify({ version: STAGE_LEDGER_VERSION, stages: entries }, null, 2)}
+  writeFileSync26(temporary, `${JSON.stringify({ version: STAGE_LEDGER_VERSION, stages: entries }, null, 2)}
 `, "utf8");
   renameSync11(temporary, path4);
 }
@@ -54645,8 +55421,8 @@ var init_pr_retarget = __esm(() => {
 });
 
 // src/release/prepare.ts
-import { mkdirSync as mkdirSync24, readFileSync as readFileSync69, writeFileSync as writeFileSync26 } from "fs";
-import { dirname as dirname32, join as join87, posix as posix5 } from "path";
+import { mkdirSync as mkdirSync25, readFileSync as readFileSync69, writeFileSync as writeFileSync27 } from "fs";
+import { dirname as dirname32, join as join89, posix as posix5 } from "path";
 function levelFields(reading2) {
   return { level: reading2.level, levelSource: reading2.source, notesLevel: reading2.notesLevel };
 }
@@ -54712,8 +55488,8 @@ function nameOf2(path4) {
 }
 function writeFragment(path4, resolved, text2) {
   try {
-    mkdirSync24(dirname32(resolved), { recursive: true });
-    writeFileSync26(resolved, text2);
+    mkdirSync25(dirname32(resolved), { recursive: true });
+    writeFileSync27(resolved, text2);
     return null;
   } catch (error) {
     return `${path4} could not be written: ${messageOf(error)}`;
@@ -54737,7 +55513,7 @@ function prepareRelease(input) {
   const fragment = { plan: input.plan, title: title2, level, notes: lines2.notes };
   const name2 = allocateFragmentName(input.plan, read.base.waiting.map((waiting) => nameOf2(waiting.path)));
   const path4 = posix5.join(input.settings.releaseFragments.replace(/\\/g, "/"), name2);
-  const resolved = join87(input.repoRoot, path4);
+  const resolved = join89(input.repoRoot, path4);
   const before = textOf3(resolved);
   const after = serializeFragment(fragment);
   const problems = lines2.problem === null ? read.problems : [...read.problems, lines2.problem];
@@ -54769,7 +55545,7 @@ var init_prepare = __esm(() => {
 });
 
 // src/release/verify.ts
-import { readFileSync as readFileSync70, writeFileSync as writeFileSync27 } from "fs";
+import { readFileSync as readFileSync70, writeFileSync as writeFileSync28 } from "fs";
 import { posix as posix6 } from "path";
 function textOf4(path4) {
   try {
@@ -54789,7 +55565,7 @@ function listOf4(names2) {
 }
 function restoreFragment(file) {
   try {
-    writeFileSync27(file.resolved, file.after);
+    writeFileSync28(file.resolved, file.after);
     return { path: file.path, restored: true, problem: null };
   } catch (error) {
     return {
@@ -54916,13 +55692,13 @@ function announcePreparation(preparation) {
   }
   for (const problem2 of preparation.problems)
     out.warn(`   \u26A0\uFE0F  ${problem2}`);
-  const report2 = releaseLevelReport({
+  const report3 = releaseLevelReport({
     level: preparation.level,
     source: preparation.levelSource,
     notesLevel: preparation.notesLevel
   });
-  if (report2 !== null)
-    out.warn(`   \u26A0\uFE0F  Level report: ${report2}`);
+  if (report3 !== null)
+    out.warn(`   \u26A0\uFE0F  Level report: ${report3}`);
 }
 function prepareReleaseStage(input, seams = {}) {
   const io = { ...RELEASE_STAGE_SEAMS, ...seams };
@@ -55439,13 +56215,13 @@ async function checkWrapUpAnswer(input) {
   const line = unpromotedLine(check, input.head);
   if (line === null)
     return check;
-  const report2 = await reportUnpromoted(input.pulls, input.branch, line);
-  if (!report2.written) {
-    out.warn(`   This line is not in the pull request body, as ${report2.problem}: ${line}`);
-  } else if (report2.already) {
-    out.info(`   Pull request #${report2.number} already names the lessons it does not carry.`);
+  const report3 = await reportUnpromoted(input.pulls, input.branch, line);
+  if (!report3.written) {
+    out.warn(`   This line is not in the pull request body, as ${report3.problem}: ${line}`);
+  } else if (report3.already) {
+    out.info(`   Pull request #${report3.number} already names the lessons it does not carry.`);
   } else {
-    out.info(`   Pull request #${report2.number} now names the lessons it does not carry.`);
+    out.info(`   Pull request #${report3.number} now names the lessons it does not carry.`);
   }
   return check;
 }
@@ -55755,8 +56531,8 @@ async function emitPullRequestEvent(place2, branch, known, lookup) {
   }
   emitLoopEvent(number === null ? { kind: "no-pr", reason: `no open pull request for ${branch}` } : { kind: "pr", number });
 }
-function blockedDelivery(report2, retriesSpent) {
-  return { kind: "blocked", message: `${report2}
+function blockedDelivery(report3, retriesSpent) {
+  return { kind: "blocked", message: `${report3}
 ${DELIVERY_BLOCKED_TAIL}`, retriesSpent };
 }
 async function readOpenPull2(seams, branch) {
@@ -55805,7 +56581,7 @@ async function openByRunner(seams, branch, retriesSpent) {
 }
 function planIssueNumber(planContent, planStub2, branch) {
   const declared = parsePlan(planContent).header.issue?.trim() ?? "";
-  const spelled = ISSUE_NUMBER14.exec(declared)?.[1] ?? RAFA_ID.exec(planStub2 ?? "")?.[1] ?? RAFA_ID.exec(branch)?.[1];
+  const spelled = ISSUE_NUMBER15.exec(declared)?.[1] ?? RAFA_ID.exec(planStub2 ?? "")?.[1] ?? RAFA_ID.exec(branch)?.[1];
   return spelled === undefined ? null : Number(spelled);
 }
 function runnerPrInputFor(source) {
@@ -55858,7 +56634,7 @@ function deliverySeamsIn(context) {
   };
 }
 var NO_PROVIDER_REASON = "no pull request provider is configured", DELIVERY_BLOCKED_TAIL = "   The run is recorded stopped, not done. Open the pull request by hand, or fix the step above and run again to retry the wrap-up.", DELIVERY_INTERRUPTED = `
-\u26A0\uFE0F  Interrupted: no further wrap-up session runs and the loop opens no pull request. Run again to retry the wrap-up.`, ISSUE_NUMBER14, RAFA_ID;
+\u26A0\uFE0F  Interrupted: no further wrap-up session runs and the loop opens no pull request. Run again to retry the wrap-up.`, ISSUE_NUMBER15, RAFA_ID;
 var init_wrap_up_run = __esm(() => {
   init_active();
   init_device();
@@ -55875,7 +56651,7 @@ var init_wrap_up_run = __esm(() => {
   init_runner_pr();
   init_wrap_up_retry();
   init_wrap_up();
-  ISSUE_NUMBER14 = /^#?(\d+)$/;
+  ISSUE_NUMBER15 = /^#?(\d+)$/;
   RAFA_ID = /(?:^|\/)rafa-(\d+)(?:-|$)/;
 });
 
@@ -55898,8 +56674,8 @@ function msUntil(startAt, now = new Date) {
   return target.getTime() - now.getTime();
 }
 function sleepFor(ms) {
-  return new Promise((resolve37) => {
-    setTimeout(resolve37, ms);
+  return new Promise((resolve38) => {
+    setTimeout(resolve38, ms);
   });
 }
 async function deferUntil(startAt, now = new Date, sleep = sleepFor) {
@@ -56845,7 +57621,7 @@ function poll(following, before, context, seams) {
   }
   return { cursor, found: null };
 }
-function lineOf3(found, following, session, reading2) {
+function lineOf4(found, following, session, reading2) {
   if (found.event !== null)
     return eventLine(found.event);
   if (found.reason === "exit")
@@ -56866,7 +57642,7 @@ function resultOf6(found, following, seams) {
   return {
     reason: found.reason,
     exitCode: found.reason === "timeout" ? WAIT_TIMEOUT_EXIT : waitExitCode(found.reason),
-    line: lineOf3(found, following, session, reading2),
+    line: lineOf4(found, following, session, reading2),
     event: found.event,
     session,
     awakeMinutes: reading2.awakeMinutes,
@@ -57181,7 +57957,7 @@ var init_ceiling = __esm(() => {
 });
 
 // src/next/lines.ts
-function stateLine(state) {
+function stateLine2(state) {
   return `${STATE_MARK} ${state.reading}.`;
 }
 function proposalLine(state, invocation) {
@@ -57347,7 +58123,7 @@ async function playTurn(options, state, previous) {
   for (const problem2 of state.problems)
     warn4(problem2);
   const invocation = actionInvocation(state, passedOptions(roadmap));
-  info2(stateLine(state));
+  info2(stateLine2(state));
   info2(proposalLine(state, invocation));
   const halt2 = (stop, over = {}) => ({ stop, step: stepOf3(state, invocation, over) });
   if (dryRun !== null)
@@ -57373,7 +58149,7 @@ async function runNextChain(options) {
   let steps = [];
   let hops = [];
   let previous = null;
-  const report2 = (stop) => Object.freeze({
+  const report3 = (stop) => Object.freeze({
     steps: Object.freeze([...steps]),
     stop,
     ...roadmap === undefined ? {} : { hops: Object.freeze([...hops]) }
@@ -57382,7 +58158,7 @@ async function runNextChain(options) {
     const line = stopLine(stop, state, ceiling, dryRun, roadmap !== undefined);
     if (line !== null)
       info2(line);
-    return report2(stop);
+    return report3(stop);
   };
   const turn = async (state, before) => {
     const end = await playTurn(options, state, before);
@@ -57421,8 +58197,8 @@ async function runStateAction(context, sources, state, passed2) {
   if (outcome2.said !== "")
     context.output.info(outcome2.said);
 }
-function endOfEpic(context, sources, report2, epic) {
-  if (epic === null || report2.steps.at(-1)?.state !== "nothing-left")
+function endOfEpic(context, sources, report3, epic) {
+  if (epic === null || report3.steps.at(-1)?.state !== "nothing-left")
     return;
   const release = sources.release();
   if (release.problem !== null)
@@ -57456,7 +58232,7 @@ async function runNext(context, seams) {
   const prompter = lazyPrompter2(openPrompter);
   const dry = watchDryEpic();
   try {
-    const report2 = await runNextChain({
+    const report3 = await runNextChain({
       read: () => readNextState(dry.watch(sources.answer())),
       run: (state) => runStateAction(context, sources, state, {
         roadmap: sources.roadmap !== undefined,
@@ -57477,8 +58253,8 @@ async function runNext(context, seams) {
       }),
       ...roadmap ? { roadmap: { afterLoop: () => homeAfterLoop2(context, sources), claimAhead } } : {}
     });
-    endOfEpic(context, sources, report2, dry.last());
-    return report2;
+    endOfEpic(context, sources, report3, dry.last());
+    return report3;
   } finally {
     prompter.close();
   }
@@ -57517,9 +58293,9 @@ function createNextCommand(seams = DEFAULT_NEXT_SEAMS) {
     outputs: ["text", "json"],
     spends: { when: "through", what: "when the step it runs is one of the above" },
     run: async (context) => {
-      const report2 = await runNext(context, seams);
+      const report3 = await runNext(context, seams);
       if (context.outputMode === "json")
-        context.output.result(report2);
+        context.output.result(report3);
     }
   };
   return Object.freeze(command);
@@ -57578,7 +58354,7 @@ import path6 from "path";
 function unclaimed(issue4, cause, reason, pending = null, warnings = []) {
   return { outcome: "unclaimed", issue: issue4, cause, reason, pending, warnings };
 }
-function refused4(attempt5, branch, owner, reason) {
+function refused5(attempt5, branch, owner, reason) {
   return { outcome: "refused", issue: attempt5.issue, branch, owner, reason };
 }
 function claimed(attempt5, via, warnings = []) {
@@ -57641,7 +58417,7 @@ function claimOnRemote(attempt5, ahead, context) {
   }
   const listed4 = git(["for-each-ref", "--format=%(refname:lstrip=3)", `refs/remotes/${REMOTE}/${BRANCH_PREFIX2}`]);
   if (!listed4.ok) {
-    return refused4(attempt5, attempt5.branch, null, `the ${REMOTE} branches of #${String(attempt5.issue)} could not be listed: ${gitSaid(listed4)}`);
+    return refused5(attempt5, attempt5.branch, null, `the ${REMOTE} branches of #${String(attempt5.issue)} could not be listed: ${gitSaid(listed4)}`);
   }
   const names2 = listed4.stdout.split(`
 `).map((line) => line.trim());
@@ -57681,10 +58457,10 @@ function ownerOf(reading2) {
 }
 function unnamedRefusal(attempt5, reading2) {
   if (reading2.state === "unreadable") {
-    return refused4(attempt5, reading2.branch, null, `the claim on ${reading2.branch} could not be read, so #${String(attempt5.issue)} stays taken: ${reading2.reason}`);
+    return refused5(attempt5, reading2.branch, null, `the claim on ${reading2.branch} could not be read, so #${String(attempt5.issue)} stays taken: ${reading2.reason}`);
   }
   if (reading2.state === "found" && reading2.ownership.state === "none") {
-    return refused4(attempt5, reading2.branch, null, `${reading2.branch} exists on ${REMOTE} carrying no claim commit, so #${String(attempt5.issue)} stays taken`);
+    return refused5(attempt5, reading2.branch, null, `${reading2.branch} exists on ${REMOTE} carrying no claim commit, so #${String(attempt5.issue)} stays taken`);
   }
   return null;
 }
@@ -57704,16 +58480,16 @@ function otherBranchRefusal(attempt5, reading2, context) {
     return null;
   const { owner } = weighed;
   if (owner === attempt5.storeId) {
-    return refused4(attempt5, branch, owner, `this device (store ${owner}) already holds ${issue4} on ${branch}; plan it there with --stub=${stubOf(branch)}`);
+    return refused5(attempt5, branch, owner, `this device (store ${owner}) already holds ${issue4} on ${branch}; plan it there with --stub=${stubOf(branch)}`);
   }
-  return weighed.state === "stale-claimed" ? refused4(attempt5, branch, owner, `${issue4} is claimed by store ${owner} on ${branch}, stale; take it over by planning there with --stub=${stubOf(branch)}`) : refused4(attempt5, branch, owner, `${issue4} is claimed by store ${owner} on ${branch}`);
+  return weighed.state === "stale-claimed" ? refused5(attempt5, branch, owner, `${issue4} is claimed by store ${owner} on ${branch}, stale; take it over by planning there with --stub=${stubOf(branch)}`) : refused5(attempt5, branch, owner, `${issue4} is claimed by store ${owner} on ${branch}`);
 }
 function claimOwnBranch(attempt5, reading2, context) {
   if (reading2.state === "absent")
     return { kind: "fresh" };
   const unreadable3 = () => ({
     kind: "answer",
-    answer: refused4(attempt5, attempt5.branch, null, `the claim on ${attempt5.branch} could not be read`)
+    answer: refused5(attempt5, attempt5.branch, null, `the claim on ${attempt5.branch} could not be read`)
   });
   const unnamed = unnamedRefusal(attempt5, reading2);
   if (unnamed !== null)
@@ -57729,7 +58505,7 @@ function claimOwnBranch(attempt5, reading2, context) {
     return { kind: "held" };
   const note = weighed.state === "stale-in-development" ? ", stale but in development, which is never taken over automatically" : "";
   const reason = `#${String(attempt5.issue)} is claimed by store ${weighed.owner} on ${attempt5.branch}${note}`;
-  return { kind: "answer", answer: refused4(attempt5, attempt5.branch, weighed.owner, reason) };
+  return { kind: "answer", answer: refused5(attempt5, attempt5.branch, weighed.owner, reason) };
 }
 function tipOf(git, ref15) {
   const resolved = git(["rev-parse", "--verify", "--quiet", `${ref15}^{commit}`]);
@@ -57813,7 +58589,7 @@ function pushFreshClaim(attempt5, git) {
     return keepPending(attempt5, git, "push-failed", pushed.reason, staged.sha, staged.localTip);
   if (pushed.outcome === "claimed") {
     const owner = ownerOf(pushed.holder);
-    return refused4(attempt5, attempt5.branch, owner, raceReason(attempt5, "claimed", owner));
+    return refused5(attempt5, attempt5.branch, owner, raceReason(attempt5, "claimed", owner));
   }
   return claimed(attempt5, "claim", warningsOf(landLocal(attempt5, staged, git)));
 }
@@ -57826,7 +58602,7 @@ function pushTake(attempt5, tip, git) {
     return keepPending(attempt5, git, "push-failed", pushed.reason, staged.sha, staged.localTip);
   if (pushed.outcome === "moved") {
     const owner = refetchedOwner(git, attempt5.branch);
-    return refused4(attempt5, attempt5.branch, owner, raceReason(attempt5, "moved", owner));
+    return refused5(attempt5, attempt5.branch, owner, raceReason(attempt5, "moved", owner));
   }
   return claimed(attempt5, "take", warningsOf(landLocal(attempt5, staged, git)));
 }
@@ -57856,20 +58632,20 @@ function claimPair(home, ahead, git) {
   const line = `#${String(forward.issue)}, the line ahead, was not claimed`;
   if (ahead.move.kind === "answer") {
     const reason = ahead.move.answer.outcome === "refused" ? ahead.move.answer.reason : `the claim on ${forward.branch} could not be read`;
-    const report2 = aheadNotClaimed(forward.issue, "taken", `${line}: ${reason}`);
-    return neither(home, git, "ahead-taken", pairWhy(forward.issue, reason), report2);
+    const report3 = aheadNotClaimed(forward.issue, "taken", `${line}: ${reason}`);
+    return neither(home, git, "ahead-taken", pairWhy(forward.issue, reason), report3);
   }
   if (ahead.move.kind === "held")
     return withAhead(carryOut(home.attempt, home.move, git), aheadClaimed(forward, "held"));
   const aheadStaged = stage(forward, ahead.move, git);
   if (!aheadStaged.ok) {
-    const report2 = aheadNotClaimed(forward.issue, "failed", `${line}: ${aheadStaged.reason}`);
-    return neither(home, git, "commit-failed", pairWhy(forward.issue, aheadStaged.reason), report2);
+    const report3 = aheadNotClaimed(forward.issue, "failed", `${line}: ${aheadStaged.reason}`);
+    return neither(home, git, "commit-failed", pairWhy(forward.issue, aheadStaged.reason), report3);
   }
   const homeStaged = home.move.kind === "held" ? null : stage(home.attempt, home.move, git);
   if (homeStaged?.ok === false) {
-    const report2 = aheadNotClaimed(forward.issue, "not-tried", `${line}: the claim on #${String(home.attempt.issue)} could not be made`);
-    return withAhead(unclaimed(home.attempt.issue, "commit-failed", homeStaged.reason), report2);
+    const report3 = aheadNotClaimed(forward.issue, "not-tried", `${line}: the claim on #${String(home.attempt.issue)} could not be made`);
+    return withAhead(unclaimed(home.attempt.issue, "commit-failed", homeStaged.reason), report3);
   }
   return pushPair(home, homeStaged, { attempt: forward, staged: aheadStaged }, git);
 }
@@ -57888,16 +58664,16 @@ function pushPair(home, homeStaged, ahead, git) {
   }
   if (pushed.outcome === "refused" && pushed.branch === home.attempt.branch) {
     const owner = refetchedOwner(git, home.attempt.branch);
-    return refused4(home.attempt, home.attempt.branch, owner, raceReason(home.attempt, pushed.by, owner));
+    return refused5(home.attempt, home.attempt.branch, owner, raceReason(home.attempt, pushed.by, owner));
   }
   const reason = pushed.outcome === "refused" ? raceReason(forward, pushed.by, refetchedOwner(git, forward.branch)) : pushed.reason;
   const cause = pushed.outcome === "refused" ? "taken" : "failed";
-  const report2 = aheadNotClaimed(forward.issue, cause, `${line}: ${reason}`);
+  const report3 = aheadNotClaimed(forward.issue, cause, `${line}: ${reason}`);
   if (homeStaged === null)
-    return withAhead(claimed(home.attempt, "held"), report2);
+    return withAhead(claimed(home.attempt, "held"), report3);
   const homeCause = pushed.outcome === "refused" ? "ahead-taken" : "push-failed";
   const why = pushed.outcome === "refused" ? pairWhy(forward.issue, reason) : reason;
-  return withAhead(keepPending(home.attempt, git, homeCause, why, homeStaged.sha, homeStaged.localTip), report2);
+  return withAhead(keepPending(home.attempt, git, homeCause, why, homeStaged.sha, homeStaged.localTip), report3);
 }
 var init_plan_claim = __esm(() => {
   init_roadmap_claims();
@@ -57953,7 +58729,7 @@ async function aheadRequestOf(spec, setting, output) {
     return;
   }
 }
-function report2(claim, output) {
+function report3(claim, output) {
   if (claim.outcome === "claimed") {
     output.info(claimedLine(claim));
   } else {
@@ -57985,7 +58761,7 @@ async function resolveAndClaim(seams) {
       ...ahead === undefined ? {} : { ahead }
     });
     if (claim.outcome !== "refused") {
-      report2(claim, output);
+      report3(claim, output);
       return { outcome: "spec", spec, gate, stub, claim };
     }
     if (spec.kind !== "next")
@@ -58514,7 +59290,7 @@ var init_create2 = __esm(() => {
 
 // src/commands/plan/risk.ts
 import { readFileSync as readFileSync72 } from "fs";
-import { resolve as resolve37 } from "path";
+import { resolve as resolve38 } from "path";
 function spawningRunners2(root) {
   return { git: createGitRunner(root), gh: createGhRunner({ cwd: root }) };
 }
@@ -58524,7 +59300,7 @@ function riskPlanPath(root, planDir, typed) {
     return path9;
   if (typed !== null)
     throw new CommandExit(1, `\u274C Plan file not found: ${path9}`);
-  const lookedFor = [...new Set([resolve37(root, planDir, DEFAULT_PLAN_FILE), resolve37(root, DEFAULT_PLAN_FILE)])];
+  const lookedFor = [...new Set([resolve38(root, planDir, DEFAULT_PLAN_FILE), resolve38(root, DEFAULT_PLAN_FILE)])];
   throw new CommandExit(1, `\u274C No plan named, and no default plan at ${lookedFor.join(" or ")}
 Usage: ${USAGE38}`);
 }
@@ -58533,8 +59309,8 @@ function riskLine(finding2) {
   const place2 = finding2.file === undefined ? "" : `${finding2.file}${line}: `;
   return `${place2}${finding2.kind}: ${finding2.text}`;
 }
-function strictRefusal(report3) {
-  return `\u274C ${report3.plan}: ${plural(report3.total.high, "high finding")}; --strict refuses a plan with any`;
+function strictRefusal(report4) {
+  return `\u274C ${report4.plan}: ${plural(report4.total.high, "high finding")}; --strict refuses a plan with any`;
 }
 async function readRisk(path9, project, config, context, seams) {
   const makeRunners = seams.runners ?? spawningRunners2;
@@ -58596,24 +59372,24 @@ function createPlanRiskCommand(seams = {}) {
         context.output.warn(message);
       });
       const path9 = riskPlanPath(project.root, config.planDir, typed);
-      const report3 = await readRisk(path9, project, config, context, seams);
-      const refused5 = strict && report3.total.high > 0;
+      const report4 = await readRisk(path9, project, config, context, seams);
+      const refused6 = strict && report4.total.high > 0;
       if (context.outputMode === "json") {
-        if (!refused5) {
-          context.output.result(report3);
+        if (!refused6) {
+          context.output.result(report4);
           return;
         }
-        for (const finding2 of report3.findings) {
+        for (const finding2 of report4.findings) {
           if (finding2.level === "high")
             context.output.error(riskLine(finding2));
         }
       } else {
-        for (const line of renderRiskText(report3).split(`
+        for (const line of renderRiskText(report4).split(`
 `))
           context.output.info(line);
       }
-      if (refused5)
-        throw new CommandExit(1, strictRefusal(report3));
+      if (refused6)
+        throw new CommandExit(1, strictRefusal(report4));
     }
   };
   return Object.freeze(command);
@@ -58632,7 +59408,7 @@ var init_risk2 = __esm(() => {
 
 // src/commands/plan/show.ts
 import { readFileSync as readFileSync73 } from "fs";
-import { join as join88 } from "path";
+import { join as join90 } from "path";
 function readTrackerFlag(value) {
   if (value === undefined || value === false || value === "false")
     return false;
@@ -58648,9 +59424,9 @@ 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 = join88(plans.path, name2);
+  const file = join90(plans.path, name2);
   if (!isFile(file))
-    throw new CommandExit(1, missingText(stub, tracker, join88(plans.label, name2)));
+    throw new CommandExit(1, missingText(stub, tracker, join90(plans.label, name2)));
   const model = parsePlan(readFileSync73(file, "utf8"));
   const { header } = model;
   return {
@@ -58674,7 +59450,7 @@ function taskLine2(task) {
   return `  ${checkbox(task.status)} ${task.text}`;
 }
 function renderShownPlan(shown2, dirLabel) {
-  const relative21 = join88(dirLabel, planFileName(shown2.stub, shown2.tracker));
+  const relative21 = join90(dirLabel, planFileName(shown2.stub, shown2.tracker));
   const fileLabel = shown2.tracker ? "Tracker" : "File";
   const lines2 = [`Plan: ${shown2.stub}`, `${fileLabel}: ${relative21}`];
   if (shown2.header.issue !== null)
@@ -59254,7 +60030,7 @@ function freedIssueLine(issue4) {
   const title2 = issue4.title.trim();
   return title2 === "" ? `${INDENT5}#${String(issue4.number)}` : `${INDENT5}#${String(issue4.number)} ${title2}`;
 }
-function report3(closed, freed, problem2) {
+function report4(closed, freed, problem2) {
   return Object.freeze({ relationships: "native", closed, freed: Object.freeze(freed), problem: problem2 });
 }
 async function readFreed(gh, closed) {
@@ -59275,14 +60051,14 @@ async function freedAfterMerge(options) {
   } catch (error) {
     const problem2 = messageOf(error);
     warn4(freedProblemLine(problem2));
-    return report3(closed, [], problem2);
+    return report4(closed, [], problem2);
   }
   if (freed.length > 0) {
     info2(freedHeaderLine(closed, freed.length));
     for (const issue4 of freed)
       info2(freedIssueLine(issue4));
   }
-  return report3(closed, freed, null);
+  return report4(closed, freed, null);
 }
 var READING2 = "the freed-issue reading";
 var init_merge_freed = __esm(() => {
@@ -59348,13 +60124,13 @@ async function guardBeforeMerge(step2) {
   const answer5 = answerOf2(reading2);
   const reaction = guardReaction(reading2, settings);
   const lines2 = guardLines(reading2, settings.releaseVersionFile);
-  const report4 = { answer: answer5, reaction, lines: lines2 };
+  const report5 = { answer: answer5, reaction, lines: lines2 };
   if (reaction === "refuse")
     throw guardRefusal(refusalHead(step2.detail.number, answer5), lines2);
   if (reaction === "ask")
-    return { report: report4, go: await askGuard(step2, answer5, lines2) };
+    return { report: report5, go: await askGuard(step2, answer5, lines2) };
   printLines(step2, reaction, lines2);
-  return { report: report4, go: true };
+  return { report: report5, go: true };
 }
 var YES_ANSWERS4;
 var init_merge_guard = __esm(() => {
@@ -59366,15 +60142,15 @@ var init_merge_guard = __esm(() => {
 });
 
 // src/commands/pr/merge-loop-worktree.ts
-import { copyFileSync as copyFileSync5, mkdirSync as mkdirSync25, realpathSync as realpathSync16, statSync as statSync28 } from "fs";
-import { dirname as dirname33, isAbsolute as isAbsolute24, join as join89, relative as relative21, resolve as resolve38, sep as sep8 } from "path";
+import { copyFileSync as copyFileSync5, mkdirSync as mkdirSync26, realpathSync as realpathSync16, statSync as statSync29 } from "fs";
+import { dirname as dirname33, isAbsolute as isAbsolute24, join as join91, relative as relative21, resolve as resolve39, sep as sep8 } from "path";
 function defaultLoopWorktreeSeams(mainCheckout) {
   return {
     git: createGitRunner(mainCheckout),
     gitAt: createGitRunner,
-    modifiedAt: (path9) => statSync28(path9, { throwIfNoEntry: false })?.mtime ?? null,
+    modifiedAt: (path9) => statSync29(path9, { throwIfNoEntry: false })?.mtime ?? null,
     copyFile: (from, to) => {
-      mkdirSync25(dirname33(to), { recursive: true });
+      mkdirSync26(dirname33(to), { recursive: true });
       copyFileSync5(from, to);
     },
     realPath: (path9) => {
@@ -59405,11 +60181,11 @@ function readLoopHolder(seams, reading2) {
   };
 }
 function freeLoopWorktree(seams, reading2, holder) {
-  const into = resolve38(reading2.mainCheckout, reading2.planDir);
+  const into = resolve39(reading2.mainCheckout, reading2.planDir);
   const files = [];
   for (const name2 of planFileNames(holder.stub)) {
-    const from = resolve38(holder.path, reading2.planDir, name2);
-    const to = join89(into, name2);
+    const from = resolve39(holder.path, reading2.planDir, name2);
+    const to = join91(into, name2);
     try {
       files.push({ name: name2, from, to, outcome: copyPlanFile(seams, from, to) });
     } catch (error) {
@@ -60274,7 +61050,7 @@ function readCap(value) {
   if (value === undefined)
     return FAILED_LOG_TAIL_LINES;
   if (!Number.isSafeInteger(value) || value < 1) {
-    throw new TypeError(`${PREFIX35}: readFailedLog refused a line cap ${describeValue(value)},` + " expected a positive whole number");
+    throw new TypeError(`${PREFIX36}: readFailedLog refused a line cap ${describeValue(value)},` + " expected a positive whole number");
   }
   return value;
 }
@@ -60290,7 +61066,7 @@ function readFailedLog(text2, options = {}) {
     total: lines2.length
   };
 }
-var FAILED_LOG_TAIL_LINES = 40, UNKNOWN_STEP = "UNKNOWN STEP", GROUP_STEP_PREFIX = "##[group]Run ", ERROR_PREFIX2 = "##[error]", COLUMN = "\t", BOM = "\uFEFF", TIMESTAMP, COLOUR, PREFIX35 = "pr triage evidence";
+var FAILED_LOG_TAIL_LINES = 40, UNKNOWN_STEP = "UNKNOWN STEP", GROUP_STEP_PREFIX = "##[group]Run ", ERROR_PREFIX2 = "##[error]", COLUMN = "\t", BOM = "\uFEFF", TIMESTAMP, COLOUR, PREFIX36 = "pr triage evidence";
 var init_evidence = __esm(() => {
   init_config_sections();
   TIMESTAMP = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z /;
@@ -61236,8 +62012,8 @@ function describeAge(updatedAt, now) {
     return `${plural7(hours, "hour", "hours")} ago`;
   return `${plural7(Math.floor(age / DAY_MS2), "day", "days")} ago`;
 }
-function triageCommand(number, resolve39 = false) {
-  return resolve39 ? `rafa pr triage ${number} --resolve` : `rafa pr triage ${number}`;
+function triageCommand(number, resolve40 = false) {
+  return resolve40 ? `rafa pr triage ${number} --resolve` : `rafa pr triage ${number}`;
 }
 function joinNumbers(pulls) {
   const names2 = pulls.map((pull2) => `#${pull2.number}`);
@@ -61248,14 +62024,14 @@ function joinNumbers(pulls) {
 function byNumber4(pulls) {
   return Object.freeze([...pulls].sort((left, right) => left.number - right.number));
 }
-function skipped2(pull2, now, resolve39) {
+function skipped2(pull2, now, resolve40) {
   return Object.freeze({
     number: pull2.number,
     title: pull2.title,
     updatedAt: pull2.updatedAt,
     age: describeAge(pull2.updatedAt, now),
     fresh: isFreshCandidate(pull2.updatedAt, now),
-    command: triageCommand(pull2.number, resolve39)
+    command: triageCommand(pull2.number, resolve40)
   });
 }
 function skippedLine(one) {
@@ -61299,15 +62075,15 @@ function listReading(rest, count2) {
   return listing2("list", Object.freeze([]), rest, headline);
 }
 function selectTriagePullRequests(input) {
-  const resolve39 = input.resolve === true;
+  const resolve40 = 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 = byNumber4(input.candidates);
   const count2 = candidates.length;
-  const lines2 = candidates.map((pull2) => skipped2(pull2, now, resolve39));
-  if (resolve39 && count2 > 1)
+  const lines2 = candidates.map((pull2) => skipped2(pull2, now, resolve40));
+  if (resolve40 && count2 > 1)
     return refusal15(lines2, count2);
   if (count2 === 0) {
     return plain("none", Object.freeze([]), "no red pull request to triage, and no pull request on the current branch");
@@ -61663,7 +62439,7 @@ var init_triage_report = __esm(() => {
 function budgetEntry(usd) {
   const spelled2 = String(usd);
   if (parseBudgetUsd(spelled2) === null) {
-    throw new TypeError(`${PREFIX36}: 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(`${PREFIX37}: 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}=${spelled2}`;
 }
@@ -61690,7 +62466,7 @@ function withTaskBudget(plan2, usd) {
 `).map((line) => TASK_LINE2.test(line) ? withEntry(line, entry) : line).join(`
 `);
 }
-var BUDGET_KEY = "budget", TASK_LINE2, TRAILING_BLOCK, PREFIX36 = "pr triage --resolve budget";
+var BUDGET_KEY = "budget", TASK_LINE2, TRAILING_BLOCK, PREFIX37 = "pr triage --resolve budget";
 var init_budget2 = __esm(() => {
   init_declaration();
   TASK_LINE2 = /^- \[[^\]]*\] /;
@@ -61698,8 +62474,8 @@ var init_budget2 = __esm(() => {
 });
 
 // src/pr/plans/load.ts
-import { existsSync as existsSync60, readFileSync as readFileSync74 } from "fs";
-import { dirname as dirname34, join as join90 } from "path";
+import { existsSync as existsSync61, readFileSync as readFileSync74 } from "fs";
+import { dirname as dirname34, join as join92 } from "path";
 import { fileURLToPath as fileURLToPath7 } from "url";
 function pinnedPlanFileName(triageClass) {
   return `resolve-${triageClass}.md`;
@@ -61710,8 +62486,8 @@ function hasPinnedPlan(triageClass) {
 function pinnedPlanCandidates(moduleDir, triageClass) {
   const name2 = pinnedPlanFileName(triageClass);
   return [
-    join90(moduleDir, PINNED_PLANS_DIRNAME, name2),
-    join90(moduleDir, name2)
+    join92(moduleDir, PINNED_PLANS_DIRNAME, name2),
+    join92(moduleDir, name2)
   ];
 }
 function readPinnedPlan(triageClass, lookup = {}) {
@@ -61719,7 +62495,7 @@ 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_DIR5, triageClass);
-  const found = candidates.find((candidate) => existsSync60(candidate));
+  const found = candidates.find((candidate) => existsSync61(candidate));
   if (found === undefined) {
     throw new Error(`The pinned resolve plan for ${triageClass} is missing: ` + `no file at ${candidates.join(" or ")}`);
   }
@@ -61790,7 +62566,7 @@ var init_load2 = __esm(() => {
 // src/pr/triage/attempts.ts
 function readCap2(maxAttempts) {
   if (!Number.isSafeInteger(maxAttempts) || maxAttempts < 1) {
-    throw new TypeError(`${PREFIX37}: refused a cap of ${JSON.stringify(maxAttempts)},` + " expected a positive whole number");
+    throw new TypeError(`${PREFIX38}: refused a cap of ${JSON.stringify(maxAttempts)},` + " expected a positive whole number");
   }
   return maxAttempts;
 }
@@ -61860,7 +62636,7 @@ function readAttemptRepeat(input) {
     reason: `attempt ${attempts} ended as \`${outcome2.triageClass}\`` + ` ${describeStep(outcome2.step)}, ${against}`
   };
 }
-var ATTEMPT_STOPS, PREFIX37 = "pr triage attempts", WHITESPACE5, NO_STEP_KEY = "";
+var ATTEMPT_STOPS, PREFIX38 = "pr triage attempts", WHITESPACE5, NO_STEP_KEY = "";
 var init_attempts = __esm(() => {
   ATTEMPT_STOPS = Object.freeze([
     "cap",
@@ -61870,16 +62646,16 @@ var init_attempts = __esm(() => {
 });
 
 // src/commands/pr/resolve-loop.ts
-import { mkdirSync as mkdirSync26, writeFileSync as writeFileSync28 } from "fs";
-import { join as join91 } from "path";
+import { mkdirSync as mkdirSync27, writeFileSync as writeFileSync29 } from "fs";
+import { join as join93 } from "path";
 function resolveRunDir(home, number, attempt5) {
-  return join91(home, RESOLVE_SUBDIR, `${RUN_PREFIX}${number}`, `${ATTEMPT_PREFIX}${attempt5}`);
+  return join93(home, RESOLVE_SUBDIR, `${RUN_PREFIX}${number}`, `${ATTEMPT_PREFIX}${attempt5}`);
 }
 function writeResolvePlan(write) {
   const dir = resolveRunDir(write.home, write.number, write.attempt);
-  mkdirSync26(dir, { recursive: true });
-  const path9 = join91(dir, pinnedPlanFileName(write.triageClass));
-  writeFileSync28(path9, write.plan, "utf8");
+  mkdirSync27(dir, { recursive: true });
+  const path9 = join93(dir, pinnedPlanFileName(write.triageClass));
+  writeFileSync29(path9, write.plan, "utf8");
   return path9;
 }
 function resolveLoopArgv(planPath) {
@@ -61921,13 +62697,13 @@ var RESOLVE_SUBDIR, RUN_PREFIX = "pr-", ATTEMPT_PREFIX = "attempt-", LOOP_WORDS,
 var init_resolve_loop = __esm(() => {
   init_config_sections();
   init_load2();
-  RESOLVE_SUBDIR = join91(".rafa", "resolve");
+  RESOLVE_SUBDIR = join93(".rafa", "resolve");
   LOOP_WORDS = Object.freeze(["loop", "start"]);
 });
 
 // src/pr/triage/version-convert.ts
-import { mkdirSync as mkdirSync27, readFileSync as readFileSync75, writeFileSync as writeFileSync29 } from "fs";
-import { dirname as dirname35, join as join92, posix as posix9 } from "path";
+import { mkdirSync as mkdirSync28, readFileSync as readFileSync75, writeFileSync as writeFileSync30 } from "fs";
+import { dirname as dirname35, join as join94, posix as posix9 } from "path";
 function conversionLevel(from, to) {
   if (from === null)
     return null;
@@ -61966,7 +62742,7 @@ function fragmentNamesAt(git, commit, directory2) {
     return [];
   return listed4.stdout.split("\x00").filter((path9) => path9 !== "").map((path9) => posix9.basename(path9));
 }
-function refused5(problem2, problems) {
+function refused6(problem2, problems) {
   return { outcome: "refused", problem: problem2, problems };
 }
 function fragmentTitle2(title2, plan2) {
@@ -62003,9 +62779,9 @@ function planConversion(input, problems) {
   const baseRef = `${input.remote ?? RELEASE_REMOTE}/${input.base}`;
   const headCommit = commitOf2(git, "HEAD");
   if (headCommit === null)
-    return refused5(`the worktree at ${input.worktree} has no HEAD commit`, problems);
+    return refused6(`the worktree at ${input.worktree} has no HEAD commit`, problems);
   if (input.head !== null && headCommit !== input.head) {
-    return refused5(`the worktree's ${input.branch} is at ${headCommit.slice(0, SHORT_HASH_LENGTH2)}, not at the pull request's` + ` head ${input.head.slice(0, SHORT_HASH_LENGTH2)}; bring the branch up to its pull request's head and run it again`, problems);
+    return refused6(`the worktree's ${input.branch} is at ${headCommit.slice(0, SHORT_HASH_LENGTH2)}, not at the pull request's` + ` head ${input.head.slice(0, SHORT_HASH_LENGTH2)}; bring the branch up to its pull request's head and run it again`, problems);
   }
   const guard = readGuard({
     git,
@@ -62015,7 +62791,7 @@ function planConversion(input, problems) {
     now: input.now
   });
   if (!guard.ok)
-    return refused5(`the release guard could not read ${input.branch}: ${guard.problem}`, problems);
+    return refused6(`the release guard could not read ${input.branch}: ${guard.problem}`, problems);
   const { verdict } = guard;
   if (verdict.answer === "clean" || verdict.answer === "missing") {
     return { outcome: "unstamped", answer: verdict.answer, problems };
@@ -62023,25 +62799,25 @@ function planConversion(input, problems) {
   const { stamp: stamp2 } = verdict;
   const start2 = mergeBaseSide(git, guard.base.commit, headCommit, settings);
   if (start2 === null)
-    return refused5(`${input.branch} and ${baseRef} share no merge base`, problems);
+    return refused6(`${input.branch} and ${baseRef} share no merge base`, problems);
   const level = conversionLevel(start2.version, stamp2.version);
   if (level === null) {
-    return refused5(`no release level reads off the stamp: ${input.branch} stamped ${stamp2.version} over` + ` ${start2.version ?? "no version"} at its merge base with ${baseRef}`, problems);
+    return refused6(`no release level reads off the stamp: ${input.branch} stamped ${stamp2.version} over` + ` ${start2.version ?? "no version"} at its merge base with ${baseRef}`, problems);
   }
   if (start2.version === null)
-    return refused5(`the merge base declares no version in ${settings.releaseVersionFile} to restore`, problems);
+    return refused6(`the merge base declares no version in ${settings.releaseVersionFile} to restore`, problems);
   if (start2.changelog === null) {
-    return refused5(`the merge base holds no ${settings.releaseChangelog}, so ${input.branch} created it and there is no text to restore`, problems);
+    return refused6(`the merge base holds no ${settings.releaseChangelog}, so ${input.branch} created it and there is no text to restore`, problems);
   }
   let branchVersionText;
   try {
-    branchVersionText = readFileSync75(join92(input.worktree, settings.releaseVersionFile), "utf8");
+    branchVersionText = readFileSync75(join94(input.worktree, settings.releaseVersionFile), "utf8");
   } catch (error) {
-    return refused5(`${settings.releaseVersionFile} could not be read in the worktree: ${messageOf(error)}`, problems);
+    return refused6(`${settings.releaseVersionFile} could not be read in the worktree: ${messageOf(error)}`, problems);
   }
   const rewritten = replaceManifestVersion(branchVersionText, start2.version);
   if (rewritten === null) {
-    return refused5(`${input.branch}'s ${settings.releaseVersionFile} holds no version pair ${start2.version} could be written over`, problems);
+    return refused6(`${input.branch}'s ${settings.releaseVersionFile} holds no version pair ${start2.version} could be written over`, problems);
   }
   return {
     stamp: stamp2,
@@ -62061,10 +62837,10 @@ function writeConversion(input, plan2) {
     [input.settings.releaseChangelog, plan2.changelogText]
   ];
   for (const [path9, text2] of writes) {
-    const target = join92(input.worktree, path9);
+    const target = join94(input.worktree, path9);
     try {
-      mkdirSync27(dirname35(target), { recursive: true });
-      writeFileSync29(target, text2);
+      mkdirSync28(dirname35(target), { recursive: true });
+      writeFileSync30(target, text2);
     } catch (error) {
       return `${path9} could not be written in the worktree, which may hold part of the conversion: ${messageOf(error)}`;
     }
@@ -62083,18 +62859,18 @@ function convertStampedVersion(input) {
     return plan2;
   const written3 = writeConversion(input, plan2);
   if (written3 !== null)
-    return refused5(written3, problems);
+    return refused6(written3, problems);
   const paths = [plan2.fragmentPath, settings.releaseVersionFile, settings.releaseChangelog].map((path9) => gitPathOf(path9));
   const added = git(["add", "--", ...paths]);
   if (!added.ok)
-    return refused5(`the conversion's files could not be staged, and are left in the worktree: ${gitSaid(added)}`, problems);
+    return refused6(`the conversion's files could not be staged, and are left in the worktree: ${gitSaid(added)}`, problems);
   const subject = conversionCommitSubject(plan2.plan, plan2.stamp.version);
   const made = git(["commit", "--cleanup=whitespace", "-m", subject, "--", ...paths]);
   if (!made.ok)
-    return refused5(`the conversion could not be committed, and is left staged in the worktree: ${gitSaid(made)}`, problems);
+    return refused6(`the conversion could not be committed, and is left staged in the worktree: ${gitSaid(made)}`, problems);
   const commit = commitOf2(git, "HEAD");
   if (commit === null)
-    return refused5("the conversion was committed, but HEAD names no commit to report", problems);
+    return refused6("the conversion was committed, but HEAD names no commit to report", problems);
   return {
     outcome: "converted",
     commit,
@@ -62563,16 +63339,16 @@ async function redPullRequests(pr) {
   }
   return red;
 }
-async function selectTargets(pr, warn4, now, resolve39) {
+async function selectTargets(pr, warn4, now, resolve40) {
   const branch = readBranchOrNone(pr, warn4);
   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: resolve39 });
+    return selectTriagePullRequests({ current, candidates: [], now, resolve: resolve40 });
   return selectTriagePullRequests({
     current: null,
     candidates: await redPullRequests(pr),
     now,
-    resolve: resolve39
+    resolve: resolve40
   });
 }
 async function detailOf16(pr, number) {
@@ -62709,7 +63485,7 @@ async function runTriage(context, seams) {
   }
   const numbers = asked === null ? (selection?.assess ?? []).map((one) => one.number) : [asked];
   const readings = [];
-  let resolve39 = null;
+  let resolve40 = null;
   for (const number of numbers) {
     const assess = () => assessOne({
       pr,
@@ -62729,7 +63505,7 @@ async function runTriage(context, seams) {
       readings.push(reading2);
       continue;
     }
-    resolve39 = await resolvePullRequest({
+    resolve40 = await resolvePullRequest({
       trust: {
         permissions,
         trustedAuthors: pr.trustedAuthors,
@@ -62751,16 +63527,16 @@ async function runTriage(context, seams) {
       ...seams.clock === undefined ? {} : { clock: seams.clock },
       ...seams.sleep === undefined ? {} : { sleep: seams.sleep }
     });
-    readings.push(resolve39.reading);
+    readings.push(resolve40.reading);
   }
   const text2 = [
     ...selection === null ? [] : [selection.message],
     ...readings.length === 0 ? [] : [renderTriages(readings)],
-    ...resolve39 === null ? [] : resolve39.lines
+    ...resolve40 === null ? [] : resolve40.lines
   ].join(`
 
 `);
-  return { selection, readings, resolve: resolve39, text: text2, exitCode: resolve39?.exitCode ?? 0 };
+  return { selection, readings, resolve: resolve40, text: text2, exitCode: resolve40?.exitCode ?? 0 };
 }
 function createPrTriageCommand(seams = DEFAULT_TRIAGE_SEAMS) {
   const command = {
@@ -63188,9 +63964,9 @@ async function settleByPr(worktree, settings, pulls) {
   if ("problem" in branch)
     return failed4("unpushed", build2, false, branch.problem);
   if (!branch.same) {
-    const refused6 = pushReleaseBranch(worktree, build2, branch.current);
-    if (refused6 !== null)
-      return refused6;
+    const refused7 = pushReleaseBranch(worktree, build2, branch.current);
+    if (refused7 !== null)
+      return refused7;
   }
   const head = branch.same && branch.current !== null ? branch.current : build2.release;
   const draft = {
@@ -63367,9 +64143,9 @@ var init_settle_tag = __esm(() => {
 });
 
 // src/release/settle-worktree.ts
-import { existsSync as existsSync61, mkdtempSync as mkdtempSync3, realpathSync as realpathSync17, rmSync as rmSync13 } from "fs";
+import { existsSync as existsSync62, mkdtempSync as mkdtempSync3, realpathSync as realpathSync17, rmSync as rmSync13 } from "fs";
 import { tmpdir as tmpdir5 } from "os";
-import { join as join93 } from "path";
+import { join as join95 } from "path";
 function removeScratch(git, scratch, path9) {
   const removed = git(["worktree", "remove", "--force", path9]);
   const problems = [];
@@ -63384,14 +64160,14 @@ function removeScratch(git, scratch, path9) {
       problems.push(`the worktree record of ${path9} could not be pruned: ${gitSaid(pruned)}`);
     }
   }
-  if (problems.length === 0 && existsSync61(scratch)) {
+  if (problems.length === 0 && existsSync62(scratch)) {
     problems.push(`the scratch directory ${scratch} is still there`);
   }
   return problems.length === 0 ? null : problems.join("; ");
 }
 function makeScratch(root) {
   try {
-    return realpathSync17(mkdtempSync3(join93(root, SETTLE_SCRATCH_PREFIX)));
+    return realpathSync17(mkdtempSync3(join95(root, SETTLE_SCRATCH_PREFIX)));
   } catch (error) {
     return { ok: false, problem: `no scratch directory could be made under ${root}: ${messageOf(error)}`, leftover: null };
   }
@@ -63413,7 +64189,7 @@ function addWorktree(options) {
   const scratch = makeScratch(options.scratchRoot ?? tmpdir5());
   if (typeof scratch !== "string")
     return scratch;
-  const path9 = join93(scratch, WORKTREE_DIRECTORY);
+  const path9 = join95(scratch, WORKTREE_DIRECTORY);
   const added = git(["worktree", "add", "--detach", path9, commit]);
   if (!added.ok) {
     return {
@@ -63689,7 +64465,7 @@ var init_release_commit = __esm(() => {
 
 // src/commands/release/tag.ts
 import { readFileSync as readFileSync76 } from "fs";
-import { join as join94 } from "path";
+import { join as join96 } from "path";
 function readBranch3(git) {
   const result2 = git(["rev-parse", "--abbrev-ref", "HEAD"]);
   if (!result2.ok) {
@@ -63709,7 +64485,7 @@ function textOf5(path9) {
   }
 }
 function readVersion(root, configured) {
-  const resolved = join94(root, configured);
+  const resolved = join96(root, configured);
   const text2 = textOf5(resolved);
   if (text2 === null) {
     return {
@@ -63723,7 +64499,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 = join94(root, configured);
+  const resolved = join96(root, configured);
   const text2 = textOf5(resolved);
   if (text2 === null) {
     return { path: configured, version: null, problem: `the changelog could not be read at ${resolved}` };
@@ -64011,10 +64787,10 @@ var init_roadmap2 = __esm(() => {
 });
 
 // src/backfill/proposal-file.ts
-import { readdirSync as readdirSync21, readFileSync as readFileSync77 } from "fs";
-import { join as join95 } from "path";
+import { readdirSync as readdirSync22, readFileSync as readFileSync77 } from "fs";
+import { join as join97 } from "path";
 function proposalPath(dir, batch) {
-  return join95(dir, `${PROPOSAL_FILE_PREFIX}${String(batch).padStart(2, "0")}${PROPOSAL_FILE_EXTENSION}`);
+  return join97(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);
@@ -64145,12 +64921,12 @@ function parseProposalFile(text2) {
 function readProposalFiles(dir) {
   let names2;
   try {
-    names2 = readdirSync21(dir);
+    names2 = readdirSync22(dir);
   } catch {
     return [];
   }
   return names2.filter((name2) => isProposalFileName(name2)).sort((left, right) => left.localeCompare(right)).map((name2) => {
-    const path9 = join95(dir, name2);
+    const path9 = join97(dir, name2);
     try {
       return { path: path9, result: parseProposalFile(readFileSync77(path9, "utf8")) };
     } catch (error) {
@@ -64161,7 +64937,7 @@ function readProposalFiles(dir) {
 var BACKFILL_PATH, PROPOSAL_FILE_PREFIX = "proposals-", PROPOSAL_FILE_EXTENSION = ".yaml", SHA256_PATTERN, PROPOSAL_STATUSES, DRAFT_FILE = "draft", REVIEWED_FILE = "reviewed", PROPOSAL_ROW_STATUSES, UNANSWERED_ROW = "unanswered", ANSWERED_ROW = "answered", PROPOSAL_NEEDS, PROPOSAL_FILE_HEADER;
 var init_proposal_file = __esm(() => {
   init_skill();
-  BACKFILL_PATH = join95(".rafa", "backfill");
+  BACKFILL_PATH = join97(".rafa", "backfill");
   SHA256_PATTERN = /^[0-9a-f]{64}$/;
   PROPOSAL_STATUSES = ["draft", "reviewed"];
   PROPOSAL_ROW_STATUSES = ["answered", "unanswered"];
@@ -64183,19 +64959,19 @@ var init_proposal_file = __esm(() => {
 });
 
 // src/backfill/backup.ts
-import { copyFileSync as copyFileSync6, existsSync as existsSync62, mkdirSync as mkdirSync28 } from "fs";
-import { dirname as dirname36, isAbsolute as isAbsolute25, join as join96, relative as relative22, resolve as resolve39, sep as sep9 } from "path";
+import { copyFileSync as copyFileSync6, existsSync as existsSync63, mkdirSync as mkdirSync29 } from "fs";
+import { dirname as dirname36, isAbsolute as isAbsolute25, join as join98, relative as relative22, resolve as resolve40, sep as sep9 } from "path";
 function backupDirectory(base) {
-  return join96(base, BACKUP_PATH);
+  return join98(base, BACKUP_PATH);
 }
 function isUnder(root, path9) {
-  const step2 = relative22(resolve39(root), resolve39(path9));
+  const step2 = relative22(resolve40(root), resolve40(path9));
   return step2 === "" || !step2.startsWith(`..${sep9}`) && step2 !== ".." && !isAbsolute25(step2);
 }
 function backupPathFor(path9, root, backupDir) {
   if (!isUnder(root, path9))
     return null;
-  return join96(backupDir, relative22(resolve39(root), resolve39(path9)));
+  return join98(backupDir, relative22(resolve40(root), resolve40(path9)));
 }
 function backupFile(path9, options) {
   if (options.repoRoot !== null && isUnder(options.repoRoot, path9)) {
@@ -64204,11 +64980,11 @@ function backupFile(path9, options) {
   const backup = backupPathFor(path9, options.root, options.backupDir);
   if (backup === null)
     return { path: path9, kind: "outside", backup: null };
-  if (!existsSync62(path9))
+  if (!existsSync63(path9))
     return { path: path9, kind: "missing", backup: null };
-  if (existsSync62(backup))
+  if (existsSync63(backup))
     return { path: path9, kind: "kept", backup };
-  mkdirSync28(dirname36(backup), { recursive: true });
+  mkdirSync29(dirname36(backup), { recursive: true });
   copyFileSync6(path9, backup);
   return { path: path9, kind: "copied", backup };
 }
@@ -64232,12 +65008,12 @@ function countBackups(results) {
 var BACKUP_PATH, BACKUP_KINDS;
 var init_backup = __esm(() => {
   init_proposal_file();
-  BACKUP_PATH = join96(BACKFILL_PATH, "backup");
+  BACKUP_PATH = join98(BACKFILL_PATH, "backup");
   BACKUP_KINDS = ["copied", "kept", "tracked", "outside", "missing"];
 });
 
 // src/backfill/derive.ts
-import { readFileSync as readFileSync78, writeFileSync as writeFileSync30 } from "fs";
+import { readFileSync as readFileSync78, writeFileSync as writeFileSync31 } from "fs";
 import { basename as basename24 } from "path";
 function renderWhenToUse(trigger, prevents) {
   return `${sentenceEnded(trigger)} Prevents: ${prevents}`;
@@ -64409,7 +65185,7 @@ function applyFile(action, options) {
       text: null
     };
   }
-  writeFileSync30(action.path, action.text, "utf8");
+  writeFileSync31(action.path, action.text, "utf8");
   const after = failureLines(checkFile(action.path, "skill", {
     projectRoot: options.projectRoot,
     pathDirs: options.pathDirs
@@ -64417,7 +65193,7 @@ function applyFile(action, options) {
   const added = addedFailures(action.before, after);
   if (added.length === 0)
     return action;
-  writeFileSync30(action.path, action.original, "utf8");
+  writeFileSync31(action.path, action.original, "utf8");
   return {
     ...action,
     kind: "refused",
@@ -64516,8 +65292,8 @@ function summaryLine3(rows2) {
   const parts = DEMOTION_VERDICTS.map((verdict) => `${counts[verdict]} ${verdict}`);
   return `${files}: ${parts.join(", ")}.`;
 }
-function writeDemotionReport(report4) {
-  const rows2 = report4.rows.map((row3) => tableLine2([
+function writeDemotionReport(report5) {
+  const rows2 = report5.rows.map((row3) => tableLine2([
     escapeCell(row3.path),
     escapeCell(row3.hash),
     escapeCell(row3.verdict),
@@ -64526,11 +65302,11 @@ function writeDemotionReport(report4) {
     escapeCell(row3.overrideReason ?? EMPTY_CELL2)
   ]));
   return [
-    renderHeader(report4.status),
+    renderHeader(report5.status),
     "",
     REPORT_TITLE,
     "",
-    summaryLine3(report4.rows),
+    summaryLine3(report5.rows),
     "",
     tableLine2(DEMOTION_REPORT_COLUMNS),
     tableLine2(DEMOTION_REPORT_COLUMNS.map(() => "---")),
@@ -64853,8 +65629,8 @@ The files:
 });
 
 // src/backfill/propose.ts
-import { mkdirSync as mkdirSync29, readFileSync as readFileSync80, writeFileSync as writeFileSync31 } from "fs";
-import { join as join97, resolve as resolve40 } from "path";
+import { mkdirSync as mkdirSync30, readFileSync as readFileSync80, writeFileSync as writeFileSync32 } from "fs";
+import { join as join99, resolve as resolve41 } from "path";
 function unanswered(candidate, note) {
   return {
     path: candidate.relative,
@@ -64927,12 +65703,12 @@ async function runProposalPass(options) {
   const batches = batchCandidates(candidates);
   const written3 = [];
   if (batches.length > 0)
-    mkdirSync29(options.backfillDir, { recursive: true });
+    mkdirSync30(options.backfillDir, { recursive: true });
   for (const [index, batch] of batches.entries()) {
     const number = index + 1;
     const file = await runProposalBatch(number, batch, options);
     const path9 = proposalPath(options.backfillDir, number);
-    writeFileSync31(path9, renderProposalFile(file), "utf8");
+    writeFileSync32(path9, renderProposalFile(file), "utf8");
     written3.push({ path: path9, file });
   }
   return { written: written3, candidates: candidates.length };
@@ -64974,7 +65750,7 @@ function writeRow(path9, row3, original, options) {
     return inert2(path9, row3, "unchanged", "every field the row proposes is already what the file carries");
   }
   const before = checkLines(path9, options);
-  writeFileSync31(path9, writeFrontmatter(document, mergeFrontmatter(document.data, changes)), "utf8");
+  writeFileSync32(path9, writeFrontmatter(document, mergeFrontmatter(document.data, changes)), "utf8");
   const added = addedFailures(before, checkLines(path9, options));
   if (added.length === 0) {
     return {
@@ -64986,7 +65762,7 @@ function writeRow(path9, row3, original, options) {
       added: []
     };
   }
-  writeFileSync31(path9, original, "utf8");
+  writeFileSync32(path9, original, "utf8");
   return {
     path: path9,
     relative: row3.path,
@@ -64997,7 +65773,7 @@ function writeRow(path9, row3, original, options) {
   };
 }
 function applyRow(root, row3, options) {
-  const path9 = join97(root, ...row3.path.split("/"));
+  const path9 = join99(root, ...row3.path.split("/"));
   if (row3.status === UNANSWERED_ROW) {
     return inert2(path9, row3, "unanswered", row3.note ?? "the row carries no answer");
   }
@@ -65020,7 +65796,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 resolve40(file.skills) === resolve40(root) ? null : `the proposal file names the skills directory ${file.skills}, not ${root}`;
+  return resolve41(file.skills) === resolve41(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]));
@@ -65034,7 +65810,7 @@ function applyProposals(files, root, options) {
   for (const file of files) {
     const refusal16 = fileRefusal(file, root);
     for (const row3 of file.rows) {
-      const action = refusal16 === null ? applyRow(root, row3, options) : inert2(join97(root, ...row3.path.split("/")), row3, "refused", refusal16);
+      const action = refusal16 === null ? applyRow(root, row3, options) : inert2(join99(root, ...row3.path.split("/")), row3, "refused", refusal16);
       actions.push(action);
       if (row3.trigger !== null && action.kind !== "refused" && action.kind !== "unanswered") {
         triggers[row3.name] = row3.trigger;
@@ -65061,8 +65837,8 @@ var init_propose = __esm(() => {
 });
 
 // src/demote/select.ts
-import { readdirSync as readdirSync22, readFileSync as readFileSync81, realpathSync as realpathSync18, statSync as statSync29 } from "fs";
-import { basename as basename25, dirname as dirname37, join as join98 } from "path";
+import { readdirSync as readdirSync23, readFileSync as readFileSync81, realpathSync as realpathSync18, statSync as statSync30 } from "fs";
+import { basename as basename25, dirname as dirname37, join as join100 } from "path";
 function realOrSelf(path9) {
   try {
     return realpathSync18(path9);
@@ -65084,19 +65860,19 @@ function resolveDemotionScope(dir, home) {
   if (basename25(claude) !== CLAUDE_DIRECTORY)
     return null;
   const base = dirname37(claude);
-  const demotedDir = join98(base, DEMOTED_PATH);
+  const demotedDir = join100(base, DEMOTED_PATH);
   return {
     scope: samePath(base, home) ? "user" : "project",
     dir,
     base,
     demotedDir,
-    instinctsDir: join98(base, INSTINCTS_PATH),
-    reportPath: join98(demotedDir, REPORT_FILE)
+    instinctsDir: join100(base, INSTINCTS_PATH),
+    reportPath: join100(demotedDir, REPORT_FILE)
   };
 }
 function entryKind2(path9) {
   try {
-    const stats = statSync29(path9);
+    const stats = statSync30(path9);
     if (stats.isFile())
       return "file";
     if (stats.isDirectory())
@@ -65108,7 +65884,7 @@ function entryKind2(path9) {
 }
 function visibleNames2(dir) {
   try {
-    return readdirSync22(dir).filter((name2) => !name2.startsWith(".")).sort((left, right) => left.localeCompare(right));
+    return readdirSync23(dir).filter((name2) => !name2.startsWith(".")).sort((left, right) => left.localeCompare(right));
   } catch {
     return [];
   }
@@ -65118,7 +65894,7 @@ function readSelected(absolute, path9, entries) {
   let mtime;
   try {
     text2 = readFileSync81(absolute, "utf8");
-    mtime = statSync29(absolute).mtime.toISOString();
+    mtime = statSync30(absolute).mtime.toISOString();
   } catch {
     return null;
   }
@@ -65133,14 +65909,14 @@ function selectsLearned(text2, scope) {
   return origin === AUTO_EXTRACTED_ORIGIN;
 }
 function selectLearned(scope) {
-  const dir = join98(scope.dir, LEARNED_DIRECTORY);
+  const dir = join100(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 = join98(dir, name2);
+    const absolute = join100(dir, name2);
     if (entryKind2(absolute) !== "file")
       continue;
     const file = readSelected(absolute, `${LEARNED_DIRECTORY}/${name2}`, undefined);
@@ -65154,10 +65930,10 @@ function selectSkillFiles(scope) {
   for (const name2 of visibleNames2(scope.dir)) {
     if (name2 === LEARNED_DIRECTORY)
       continue;
-    const skillDir = join98(scope.dir, name2);
+    const skillDir = join100(scope.dir, name2);
     if (entryKind2(skillDir) !== "directory")
       continue;
-    const absolute = join98(skillDir, SKILL_FILE);
+    const absolute = join100(skillDir, SKILL_FILE);
     if (entryKind2(absolute) !== "file")
       continue;
     const file = readSelected(absolute, `${name2}/${SKILL_FILE}`, visibleNames2(skillDir));
@@ -65174,14 +65950,14 @@ var init_select5 = __esm(() => {
   init_layout();
   init_classify2();
   init_report3();
-  DEMOTED_PATH = join98(".rafa", "demoted");
-  INSTINCTS_PATH = join98(".rafa", "instincts");
+  DEMOTED_PATH = join100(".rafa", "demoted");
+  INSTINCTS_PATH = join100(".rafa", "instincts");
 });
 
 // src/commands/skill/backfill.ts
-import { statSync as statSync30 } from "fs";
-import { join as join99, resolve as resolve41 } from "path";
-function readSwitch3(name2, value) {
+import { statSync as statSync31 } from "fs";
+import { join as join101, resolve as resolve42 } from "path";
+function readSwitch4(name2, value) {
   if (value === undefined || value === false || value === "false")
     return false;
   if (value === true || value === "true")
@@ -65190,8 +65966,8 @@ function readSwitch3(name2, value) {
 Usage: ${BACKFILL_USAGE}`);
 }
 function readMode(flags) {
-  const propose = readSwitch3("propose", flags["propose"]);
-  const apply = readSwitch3("apply", flags["apply"]);
+  const propose = readSwitch4("propose", flags["propose"]);
+  const apply = readSwitch4("apply", flags["apply"]);
   if (propose && apply) {
     throw new CommandExit(1, "\u274C --propose asks the sessions and --apply writes their reviewed answers, so a run is one or the" + ` other
 Usage: ${BACKFILL_USAGE}`);
@@ -65210,7 +65986,7 @@ Usage: ${BACKFILL_USAGE}`);
     throw new CommandExit(1, `\u274C Expected one directory, and read "${extra}" as a second
 Usage: ${BACKFILL_USAGE}`);
   }
-  return resolve41(cwd(), dir);
+  return resolve42(cwd(), dir);
 }
 function readConsumerRoot(value, cwd) {
   if (value === undefined || value === false)
@@ -65219,11 +65995,11 @@ function readConsumerRoot(value, cwd) {
     throw new CommandExit(1, `\u274C --project needs a path, and the line gave it none
 Usage: ${BACKFILL_USAGE}`);
   }
-  return resolve41(cwd(), value);
+  return resolve42(cwd(), value);
 }
 function isDirectory4(path9) {
   try {
-    return statSync30(path9).isDirectory();
+    return statSync31(path9).isDirectory();
   } catch {
     return false;
   }
@@ -65272,7 +66048,7 @@ function actionLines(actions) {
 function checkOptions(context, projectRoot3) {
   return { projectRoot: projectRoot3, pathDirs: pathDirectories(context.env["PATH"]) };
 }
-function report4(context, result2, lines2) {
+function report5(context, result2, lines2) {
   if (context.outputMode === "json") {
     context.output.result(result2);
     return;
@@ -65293,7 +66069,7 @@ function runPlan(context, scope, backfillDir, projectRoot3) {
     counts: plan2.counts,
     candidates
   };
-  report4(context, result2, [
+  report5(context, result2, [
     `${scope.scope} scope: ${scope.dir}`,
     ...actionLines(actions),
     derivationLine(plan2),
@@ -65327,7 +66103,7 @@ async function runPropose(context, scope, backfillDir, seams) {
     candidates: pass.candidates,
     files
   };
-  report4(context, result2, [
+  report5(context, result2, [
     `${scope.scope} scope: ${scope.dir}`,
     `${String(pass.candidates)} file(s) to ask about, in ${String(files.length)} batch(es)`,
     ...files.map((file) => `\u2705 ${file.path}: batch ${String(file.batch)}, session exit ${String(file.exitCode)},` + ` ${String(file.rows)} row(s), ${String(file.unanswered)} unanswered`),
@@ -65347,7 +66123,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((row3) => row3.status === ANSWERED_ROW).map((row3) => join99(root, ...row3.path.split("/"))));
+  return files.flatMap((file) => file.status !== REVIEWED_FILE ? [] : file.rows.filter((row3) => row3.status === ANSWERED_ROW).map((row3) => join101(root, ...row3.path.split("/"))));
 }
 function runApply(context, scope, backfillDir, projectRoot3) {
   const options = checkOptions(context, projectRoot3);
@@ -65382,18 +66158,18 @@ function runApply(context, scope, backfillDir, projectRoot3) {
     derivationLine(derived),
     `${String(copied)} file(s) copied under ${backupDir} before they were rewritten`
   ];
-  const refused6 = proposals.counts.refused + derived.counts.refused;
-  if (refused6 > 0)
-    throw new CommandExit(Math.min(refused6, REFUSED_CAP), lines2.join(`
+  const refused7 = proposals.counts.refused + derived.counts.refused;
+  if (refused7 > 0)
+    throw new CommandExit(Math.min(refused7, REFUSED_CAP), lines2.join(`
 `));
-  report4(context, result2, lines2);
+  report5(context, result2, lines2);
 }
 async function runBackfill(context, seams) {
   const mode = readMode(context.flags);
   const dir = readBackfillDirectory(context.args, seams.cwd);
   const projectRoot3 = readConsumerRoot(context.flags["project"], seams.cwd);
   const scope = backfillScopeOf(dir, projectOf13(context).home);
-  const backfillDir = join99(scope.base, BACKFILL_PATH);
+  const backfillDir = join101(scope.base, BACKFILL_PATH);
   if (mode === "propose") {
     await runPropose(context, scope, backfillDir, seams);
     return;
@@ -65526,9 +66302,9 @@ var init_check3 = __esm(() => {
 });
 
 // src/demote/apply.ts
-import { copyFileSync as copyFileSync7, existsSync as existsSync63, mkdirSync as mkdirSync30, mkdtempSync as mkdtempSync4, readdirSync as readdirSync23, readFileSync as readFileSync82, renameSync as renameSync12, rmSync as rmSync14, statSync as statSync31, unlinkSync as unlinkSync2, writeFileSync as writeFileSync32 } from "fs";
+import { copyFileSync as copyFileSync7, existsSync as existsSync64, mkdirSync as mkdirSync31, mkdtempSync as mkdtempSync4, readdirSync as readdirSync24, readFileSync as readFileSync82, renameSync as renameSync12, rmSync as rmSync14, statSync as statSync32, unlinkSync as unlinkSync2, writeFileSync as writeFileSync33 } from "fs";
 import { tmpdir as tmpdir6 } from "os";
-import { dirname as dirname38, join as join100 } from "path";
+import { dirname as dirname38, join as join102 } from "path";
 function isLearnedPath(path9) {
   const segments = path9.split("/");
   return segments.length === 2 && segments[0] === LEARNED_DIRECTORY && (segments[1] ?? "").endsWith(MARKDOWN_EXTENSION);
@@ -65538,18 +66314,18 @@ function learnedSkillName(path9) {
   return base.slice(0, -MARKDOWN_EXTENSION.length);
 }
 function sourcePath(scope, path9) {
-  return join100(scope.dir, ...path9.split("/"));
+  return join102(scope.dir, ...path9.split("/"));
 }
 function demotedPath(scope, path9) {
-  return join100(scope.demotedDir, ...path9.split("/"));
+  return join102(scope.demotedDir, ...path9.split("/"));
 }
 function promotedPath(scope, path9) {
-  return join100(scope.dir, learnedSkillName(path9), SKILL_FILE);
+  return join102(scope.dir, learnedSkillName(path9), SKILL_FILE);
 }
 function takenInstinctIds(dir) {
   let names2;
   try {
-    names2 = readdirSync23(dir);
+    names2 = readdirSync24(dir);
   } catch {
     return [];
   }
@@ -65557,7 +66333,7 @@ function takenInstinctIds(dir) {
 }
 function readText9(path9) {
   try {
-    return statSync31(path9).isFile() ? readFileSync82(path9, "utf8") : null;
+    return statSync32(path9).isFile() ? readFileSync82(path9, "utf8") : null;
   } catch {
     return null;
   }
@@ -65585,7 +66361,7 @@ function planKept(scope, row3, file) {
     return inert3(row3.path, "procedure", "kept", "procedure-shaped: left where it is, for the backfill");
   }
   const to = promotedPath(scope, row3.path);
-  if (existsSync63(to) || existsSync63(dirname38(to))) {
+  if (existsSync64(to) || existsSync64(dirname38(to))) {
     return inert3(row3.path, "procedure", "refused", `kept as a skill, but ${to} is already there`);
   }
   return {
@@ -65599,10 +66375,10 @@ function planKept(scope, row3, file) {
   };
 }
 function checkCandidate(dir, id3, text2, pathDirs) {
-  const path9 = join100(dir, `${id3}${MARKDOWN_EXTENSION}`);
-  writeFileSync32(path9, text2, "utf8");
-  const report5 = checkFile(path9, "instinct", { projectRoot: null, pathDirs });
-  return failureLines2(report5.issues);
+  const path9 = join102(dir, `${id3}${MARKDOWN_EXTENSION}`);
+  writeFileSync33(path9, text2, "utf8");
+  const report6 = checkFile(path9, "instinct", { projectRoot: null, pathDirs });
+  return failureLines2(report6.issues);
 }
 function planDemoted(scope, row3, file, context) {
   const conversion = convertToInstinct(file, {
@@ -65620,11 +66396,11 @@ function planDemoted(scope, row3, file, context) {
   if (failures.length > 0) {
     return inert3(row3.path, "observation", "refused", `the record ${id3} fails the checker \u2014 ${failures.join("; ")}`);
   }
-  const destination = join100(scope.instinctsDir, `${id3}${MARKDOWN_EXTENSION}`);
+  const destination = join102(scope.instinctsDir, `${id3}${MARKDOWN_EXTENSION}`);
   const kept = demotedPath(scope, row3.path);
-  if (existsSync63(destination))
+  if (existsSync64(destination))
     return inert3(row3.path, "observation", "refused", `${destination} is already there`);
-  if (existsSync63(kept))
+  if (existsSync64(kept))
     return inert3(row3.path, "observation", "refused", `${kept} is already there`);
   context.taken.push(id3);
   return {
@@ -65656,7 +66432,7 @@ function planRow(scope, row3, context) {
     entries: undefined,
     absolute,
     hash,
-    mtime: statSync31(absolute).mtime.toISOString()
+    mtime: statSync32(absolute).mtime.toISOString()
   };
   return verdict === "procedure" ? planKept(scope, row3, file) : planDemoted(scope, row3, file, context);
 }
@@ -65666,18 +66442,18 @@ function countActions(actions) {
     counts[action.kind] += 1;
   return counts;
 }
-function planDemotion(report5, scope, seams = DEFAULT_APPLY_SEAMS) {
-  const temp = mkdtempSync4(join100(tmpdir6(), "rafa-demote-"));
+function planDemotion(report6, scope, seams = DEFAULT_APPLY_SEAMS) {
+  const temp = mkdtempSync4(join102(tmpdir6(), "rafa-demote-"));
   const taken = [...takenInstinctIds(scope.instinctsDir)];
   try {
-    const actions = report5.rows.map((row3) => planRow(scope, row3, { temp, taken, seams }));
+    const actions = report6.rows.map((row3) => planRow(scope, row3, { temp, taken, seams }));
     return { scope, actions, counts: countActions(actions) };
   } finally {
     rmSync14(temp, { recursive: true, force: true });
   }
 }
 function moveFile(move3) {
-  mkdirSync30(dirname38(move3.to), { recursive: true });
+  mkdirSync31(dirname38(move3.to), { recursive: true });
   try {
     renameSync12(move3.from, move3.to);
   } catch {
@@ -65688,8 +66464,8 @@ function moveFile(move3) {
 function applyDemotion(plan2) {
   for (const action of plan2.actions) {
     if (action.write !== null) {
-      mkdirSync30(dirname38(action.write.path), { recursive: true });
-      writeFileSync32(action.write.path, action.write.text, "utf8");
+      mkdirSync31(dirname38(action.write.path), { recursive: true });
+      writeFileSync33(action.write.path, action.write.text, "utf8");
     }
     if (action.move !== null)
       moveFile(action.move);
@@ -65753,8 +66529,8 @@ var init_draft = __esm(() => {
 });
 
 // src/commands/skill/demote.ts
-import { existsSync as existsSync64, mkdirSync as mkdirSync31, readFileSync as readFileSync83, statSync as statSync32, writeFileSync as writeFileSync33 } from "fs";
-import { dirname as dirname39, resolve as resolve42 } from "path";
+import { existsSync as existsSync65, mkdirSync as mkdirSync32, readFileSync as readFileSync83, statSync as statSync33, writeFileSync as writeFileSync34 } from "fs";
+import { dirname as dirname39, resolve as resolve43 } from "path";
 function readApply(value) {
   if (value === undefined || value === false || value === "false")
     return false;
@@ -65773,11 +66549,11 @@ Usage: ${DEMOTE_USAGE}`);
     throw new CommandExit(1, `\u274C Expected one directory, and read "${extra}" as a second
 Usage: ${DEMOTE_USAGE}`);
   }
-  return resolve42(cwd(), dir);
+  return resolve43(cwd(), dir);
 }
 function isDirectory5(path9) {
   try {
-    return statSync32(path9).isDirectory();
+    return statSync33(path9).isDirectory();
   } catch {
     return false;
   }
@@ -65799,13 +66575,13 @@ function projectOf14(context) {
     throw new Error("rafa skill demote runs inside a project, and was handed none");
   return context.project;
 }
-function verdictLine2(report5) {
-  const counts = countVerdicts(report5.rows);
+function verdictLine2(report6) {
+  const counts = countVerdicts(report6.rows);
   const parts = DEMOTION_VERDICTS.map((verdict) => `${String(counts[verdict])} ${verdict}`);
-  return `${String(report5.rows.length)} file(s): ${parts.join(", ")}`;
+  return `${String(report6.rows.length)} file(s): ${parts.join(", ")}`;
 }
 function previousReport(path9, context) {
-  if (!existsSync64(path9))
+  if (!existsSync65(path9))
     return null;
   const parsed = parseDemotionReport(readFileSync83(path9, "utf8"));
   if (parsed.report !== null)
@@ -65815,17 +66591,17 @@ function previousReport(path9, context) {
 }
 function runWrite(context, scope) {
   const files = selectSources(scope);
-  const report5 = buildDemotionReport(files, previousReport(scope.reportPath, context));
-  mkdirSync31(dirname39(scope.reportPath), { recursive: true });
-  writeFileSync33(scope.reportPath, writeDemotionReport(report5), "utf8");
+  const report6 = buildDemotionReport(files, previousReport(scope.reportPath, context));
+  mkdirSync32(dirname39(scope.reportPath), { recursive: true });
+  writeFileSync34(scope.reportPath, writeDemotionReport(report6), "utf8");
   const result2 = {
     applied: false,
     scope: scope.scope,
     dir: scope.dir,
     reportPath: scope.reportPath,
-    status: report5.status,
-    files: report5.rows.length,
-    counts: countVerdicts(report5.rows)
+    status: report6.status,
+    files: report6.rows.length,
+    counts: countVerdicts(report6.rows)
   };
   if (context.outputMode === "json") {
     context.output.result(result2);
@@ -65833,14 +66609,14 @@ function runWrite(context, scope) {
   }
   for (const line of [
     `${scope.scope} scope: ${scope.dir}`,
-    verdictLine2(report5),
-    `Report written to ${scope.reportPath} (status: ${report5.status}); nothing was moved`,
+    verdictLine2(report6),
+    `Report written to ${scope.reportPath} (status: ${report6.status}); nothing was moved`,
     `Review each row, then mark the report ${REVIEWED_STATUS} and re-run with --apply`
   ])
     context.output.info(line);
 }
 function reviewedReport(scope) {
-  if (!existsSync64(scope.reportPath)) {
+  if (!existsSync65(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(readFileSync83(scope.reportPath, "utf8"));
@@ -65870,8 +66646,8 @@ function renderApply(result2) {
   return [...rows2, `${String(result2.actions.length)} row(s) of ${result2.reportPath}: ${parts.join(", ")}`];
 }
 function runApply2(context, scope) {
-  const report5 = reviewedReport(scope);
-  const plan2 = planDemotion(report5, scope, {
+  const report6 = reviewedReport(scope);
+  const plan2 = planDemotion(report6, scope, {
     now: () => new Date().toISOString(),
     pathDirs: pathDirectories(context.env["PATH"])
   });
@@ -66244,8 +67020,8 @@ var init_render = __esm(() => {
 
 // src/status/blocked-count.ts
 async function labelsCount(options) {
-  const report5 = await options.blockedIssues(options.gh);
-  return report5.problem === null ? { count: report5.readings.length, notes: [] } : { count: null, notes: [`the issues labelled ${SPEC_BLOCKED_LABEL} could not be read: ${report5.problem}`] };
+  const report6 = await options.blockedIssues(options.gh);
+  return report6.problem === null ? { count: report6.readings.length, notes: [] } : { count: null, notes: [`the issues labelled ${SPEC_BLOCKED_LABEL} could not be read: ${report6.problem}`] };
 }
 async function nativeCount(relations, listing3) {
   try {
@@ -66379,7 +67155,7 @@ var init_waiting = __esm(() => {
 });
 
 // src/status/sections.ts
-import { existsSync as existsSync65 } from "fs";
+import { existsSync as existsSync66 } from "fs";
 function isIdleWorktree(row3) {
   return !row3.blockers.some((blocker) => blocker.kind === "recent");
 }
@@ -66425,9 +67201,9 @@ function boundedRunner(open, root, deadline) {
 }
 async function networkSection(what, deadline, work) {
   let timer;
-  const expired = new Promise((resolve43) => {
+  const expired = new Promise((resolve44) => {
     timer = setTimeout(() => {
-      resolve43(unread4(`the ${what} was not read within the ${String(deadline.ms)}ms network deadline`));
+      resolve44(unread4(`the ${what} was not read within the ${String(deadline.ms)}ms network deadline`));
     }, Math.max(0, deadline.left()));
   });
   try {
@@ -66517,7 +67293,7 @@ function nextOfPlace(current, epic, walk) {
   return epic?.members.some((member) => member.number === line.issue) === true ? line.issue : null;
 }
 function hasBoards(root, listing3) {
-  if (existsSync65(positionFilePath(root)))
+  if (existsSync66(positionFilePath(root)))
     return true;
   return listing3.some((issue5) => issue5.state === "OPEN" && issue5.labels.includes(ROADMAP_LABEL));
 }
@@ -66755,10 +67531,10 @@ var init_board = __esm(() => {
 });
 
 // src/project/lock.ts
-import { existsSync as existsSync66, lstatSync as lstatSync3, readFileSync as readFileSync84, writeFileSync as writeFileSync34 } from "fs";
-import { join as join101 } from "path";
+import { existsSync as existsSync67, lstatSync as lstatSync3, readFileSync as readFileSync84, writeFileSync as writeFileSync35 } from "fs";
+import { join as join103 } from "path";
 function lockPath(root) {
-  return join101(root, LOCK_FILE);
+  return join103(root, LOCK_FILE);
 }
 function projectLockText(version2) {
   const lock = { lockfileVersion: LOCKFILE_VERSION, rafa: version2 };
@@ -66791,7 +67567,7 @@ function lockOf(value) {
 }
 function readProjectLock(root) {
   const path9 = lockPath(root);
-  if (!existsSync66(path9)) {
+  if (!existsSync67(path9)) {
     if (isLink(path9))
       refuse17("is a link to nothing");
     return null;
@@ -66811,7 +67587,7 @@ function readProjectLock(root) {
   return lockOf(value);
 }
 function writeProjectLock(root, version2) {
-  writeFileSync34(lockPath(root), projectLockText(version2), "utf8");
+  writeFileSync35(lockPath(root), projectLockText(version2), "utf8");
 }
 var LOCK_FILE = "rafa.lock", LOCKFILE_VERSION = 1, ProjectLockError;
 var init_lock = __esm(() => {
@@ -66823,10 +67599,10 @@ var init_lock = __esm(() => {
 });
 
 // src/project/update-current.ts
-import { existsSync as existsSync67 } from "fs";
-import { join as join102 } from "path";
+import { existsSync as existsSync68 } from "fs";
+import { join as join104 } from "path";
 function missingFolders(root) {
-  return PROJECT_TREE.map((name2) => join102(SCOPE_DIR, name2)).filter((relative24) => !existsSync67(join102(root, relative24)));
+  return PROJECT_TREE.map((name2) => join104(SCOPE_DIR, name2)).filter((relative24) => !existsSync68(join104(root, relative24)));
 }
 async function readBoard3(access) {
   if (access.gh === null)
@@ -66841,10 +67617,10 @@ async function readBoard3(access) {
 function lockChangeOf(range) {
   if (range.kind === "adopt")
     return "created";
-  return range.kind === "patch" ? "updated" : "unchanged";
+  return range.kind === "same" ? "unchanged" : "updated";
 }
 function fromOf(range) {
-  if (range.kind === "patch")
+  if (range.kind === "patch" || range.kind === "minor")
     return range.from;
   if (range.kind === "same")
     return range.to;
@@ -66868,7 +67644,7 @@ function planChanges(plan2) {
   return plan2.folders.length > 0 || labels > 0 || plan2.deprecations.length > 0 || plan2.lock !== "unchanged";
 }
 function foldersNowThere(plan2) {
-  return plan2.folders.filter((relative24) => existsSync67(join102(plan2.root, relative24)));
+  return plan2.folders.filter((relative24) => existsSync68(join104(plan2.root, relative24)));
 }
 function writeFolders(plan2) {
   if (plan2.folders.length === 0)
@@ -66915,27 +67691,29 @@ var init_update_current = __esm(() => {
 });
 
 // src/project/update-range.ts
-function refused6(reason, message) {
+function refused7(reason, message) {
   return { kind: "refused", reason, message };
 }
 function readCurrentRange(recorded, installed) {
   const to = parseSemanticVersion(installed);
   if (to === null)
-    return refused6("unreadable", `the installed rafa answers "${installed}", which is no version`);
+    return refused7("unreadable", `the installed rafa answers "${installed}", which is no version`);
   if (recorded === null)
     return { kind: "adopt", to: installed };
   const from = parseSemanticVersion(recorded);
   if (from === null)
-    return refused6("unreadable", `the project records rafa "${recorded}", which is no version`);
+    return refused7("unreadable", `the project records rafa "${recorded}", which is no version`);
   const order = compareVersions(to, from);
   if (order < 0) {
-    return refused6("older", `the installed rafa ${installed} is older than the project's ${recorded}, and no downgrade runs before 1.0.0`);
+    return refused7("older", `the installed rafa ${installed} is older than the project's ${recorded}, and no downgrade runs before 1.0.0`);
   }
   if (to.major !== from.major) {
-    return refused6("newer-major", `the installed rafa ${installed} is a newer major than the project's ${recorded}; that move is rafa update latest`);
+    return refused7("newer-major", `the installed rafa ${installed} is a newer major than the project's ${recorded}; that move is rafa update latest`);
   }
+  if (to.minor !== from.minor && to.major === 0)
+    return { kind: "minor", from: recorded, to: installed };
   if (to.minor !== from.minor) {
-    return refused6("newer-minor", `the installed rafa ${installed} is a newer minor than the project's ${recorded}; that move is rafa update next`);
+    return refused7("newer-minor", `the installed rafa ${installed} is a newer minor than the project's ${recorded}; that move is rafa update next`);
   }
   return order === 0 ? { kind: "same", to: installed } : { kind: "patch", from: recorded, to: installed };
 }
@@ -66952,7 +67730,7 @@ function checkoutLockRoot(root, dir) {
   const top = run.stdout.toString().trim();
   return top !== "" && mainCheckoutOf(top) === root ? top : root;
 }
-function readSwitch4(context, name2) {
+function readSwitch5(context, name2) {
   const value = context.flags[name2];
   if (value === undefined || value === false || value === "false")
     return false;
@@ -67082,10 +67860,10 @@ async function applyAndReport(plan2, gh, context) {
   return applied;
 }
 function refusedLabels(applied) {
-  const refused7 = applied.labels.filter((part) => part.outcome === "refused");
-  if (refused7.length === 0)
+  const refused8 = applied.labels.filter((part) => part.outcome === "refused");
+  if (refused8.length === 0)
     return null;
-  return new CommandExit(1, `${String(refused7.length)} board label(s) were not created; everything else was applied.` + " Run rafa update current again once gh can create them.");
+  return new CommandExit(1, `${String(refused8.length)} board label(s) were not created; everything else was applied.` + " Run rafa update current again once gh can create them.");
 }
 function stopLine2(plan2, dryRun) {
   if (!planChanges(plan2))
@@ -67096,8 +67874,8 @@ function stopLine2(plan2, dryRun) {
 }
 async function runUpdateCurrent(context, seams) {
   expectNoArgument(context.args, USAGE48);
-  const dryRun = readSwitch4(context, "dry-run");
-  const yes = readSwitch4(context, "yes");
+  const dryRun = readSwitch5(context, "dry-run");
+  const yes = readSwitch5(context, "yes");
   const project = projectOf17(context);
   const lockRoot = seams.lockRootOf(project.root);
   const range = readRange2(lockRoot, seams.installed);
@@ -67133,8 +67911,8 @@ function createUpdateCurrentCommand(seams = DEFAULT_UPDATE_CURRENT_SEAMS) {
     name: "update current",
     subject: "update",
     action: "current",
-    summary: "bring this project to the installed rafa, within its patch range",
-    description: "Brings the project to the installed rafa when the installed version shares the major and" + ` minor of the version \`${LOCK_FILE}\` records at the project root, and is the same patch or newer.` + " A project with no lock is adopted at the installed version. It creates the missing `.rafa/` folders" + " and the missing board labels on a GitHub board, runs the deprecations step (none registered yet)," + ` and writes \`${LOCK_FILE}\`. It prints every change first; \`--dry-run\` stops there. Otherwise it` + " warns that the changes cannot be rolled back and asks once, `--yes` answering; with no terminal and" + " no `--yes` it refuses with exit code 1. A newer minor or major, or an installed rafa older than the" + " lock, refuses with exit code 1, and so does a board label `gh` would not create, once everything" + " else is applied. A lock or config that cannot be read, or a `.rafa/` path holding something else," + " exits 2 before anything is asked; a folder or the lock that cannot be written exits 2 naming the" + " step and what was already written. In a linked worktree the lock is the worktree's, on its branch." + " With `--output=json` the plan and what was applied are the data of the terminal result event.",
+    summary: "bring this project to the installed rafa: a newer patch, or any newer minor below 1.0.0",
+    description: "Brings the project to the installed rafa when the installed version shares the major and" + ` minor of the version \`${LOCK_FILE}\` records at the project root, and is the same patch or newer;` + " below 1.0.0 it also crosses newer minors, as `0.34.1` to `0.36.0`." + " A project with no lock is adopted at the installed version. It creates the missing `.rafa/` folders" + " and the missing board labels on a GitHub board, runs the deprecations step (none registered yet)," + ` and writes \`${LOCK_FILE}\`. It prints every change first; \`--dry-run\` stops there. Otherwise it` + " warns that the changes cannot be rolled back and asks once, `--yes` answering; with no terminal and" + " no `--yes` it refuses with exit code 1. A newer minor from 1.0.0 on, a newer major, or an installed rafa older than the" + " lock, refuses with exit code 1, and so does a board label `gh` would not create, once everything" + " else is applied. A lock or config that cannot be read, or a `.rafa/` path holding something else," + " exits 2 before anything is asked; a folder or the lock that cannot be written exits 2 naming the" + " step and what was already written. In a linked worktree the lock is the worktree's, on its branch." + " With `--output=json` the plan and what was applied are the data of the terminal result event.",
     args: [],
     flags: [
       { name: "dry-run", description: "Print every change and write nothing.", type: "boolean" },
@@ -67267,6 +68045,7 @@ var init_commands2 = __esm(() => {
   init_check2();
   init_comment();
   init_create();
+  init_edit();
   init_list3();
   init_move5();
   init_ready();
@@ -67319,7 +68098,7 @@ var init_commands2 = __esm(() => {
   CORE_SUBJECTS = Object.freeze([
     { name: "plan", summary: "create plans from specs; list, show and validate them; read their risk and needs" },
     { name: "loop", summary: "start a plan; stop, pause, resume, show and list its sessions" },
-    { name: "issue", summary: "the tracker: list, show, create, comment on and move issues; mark one ready, unblock it and check its references" },
+    { name: "issue", summary: "the tracker: list, show, create, edit, comment on and move issues; mark one ready, unblock it and check its references" },
     { name: "pr", summary: "the pull request of a branch: one line, in full or in the browser; list, wait on, merge and triage them" },
     { name: "effort", summary: "collect session and commit rows; report per plan; read and repair the store: its schema, a copy for testing, migrations, and fixes; merge or import another device's store; move an NDJSON store to SQLite" },
     { name: "module", summary: "list the configured modules; run an action a module provides" },
@@ -67354,6 +68133,7 @@ var init_commands2 = __esm(() => {
     ready_default,
     unblock_default,
     check_default2,
+    edit_default,
     current_default,
     show_default6,
     view_default,
@@ -68040,12 +68820,12 @@ init_config_sections();
 init_sessions();
 init_scope();
 init_sections2();
-import { mkdirSync as mkdirSync32, readFileSync as readFileSync85, renameSync as renameSync13, writeFileSync as writeFileSync35 } from "fs";
-import { dirname as dirname40, join as join103 } from "path";
+import { mkdirSync as mkdirSync33, readFileSync as readFileSync85, renameSync as renameSync13, writeFileSync as writeFileSync36 } from "fs";
+import { dirname as dirname40, join as join105 } from "path";
 var SEEN_FILE = "status-seen.json";
 var SEEN_VERSION = 1;
 function seenFilePath(root) {
-  return join103(scopeAt(root).dir, SEEN_FILE);
+  return join105(scopeAt(root).dir, SEEN_FILE);
 }
 function readSeenSessions(root, isAlive) {
   const sessions = {};
@@ -68112,9 +68892,9 @@ function readSeenFile(root) {
 }
 function writeSeenFile(root, snapshot) {
   const file = seenFilePath(root);
-  mkdirSync32(dirname40(file), { recursive: true });
+  mkdirSync33(dirname40(file), { recursive: true });
   const temporary = `${file}.${String(process.pid)}.tmp`;
-  writeFileSync35(temporary, `${JSON.stringify(snapshot, null, 2)}
+  writeFileSync36(temporary, `${JSON.stringify(snapshot, null, 2)}
 `);
   renameSync13(temporary, file);
 }