@open-tomato/rafa 0.36.0 → 0.37.0

package/dist/{index-ddzzmcaz.js → index-b16va6he.js}

@@ -6,6 +6,7 @@ import {
   BOARD_LISTING_LIMIT,
   BRANCH_PREFIX,
   CI_POLL_INTERVAL_MS,
+  CLAIMED_LABEL,
   DEFAULT_BASE_BRANCH,
   DEFAULT_CI_ATTEMPTS,
   DEFAULT_CI_TIMEOUT_MIN,
@@ -22,6 +23,7 @@ import {
   HORIZONS,
   HORIZON_LABEL_PREFIX,
   INDENT,
+  IN_DEVELOPMENT_LABEL,
   ISSUE_LIST_FLAGS,
   LABELS_ONLY_ACTIONS,
   LABELS_READS,
@@ -56,6 +58,7 @@ import {
   SKILL_USE_CLI_VERSION,
   SPEC_BLOCKED_LABEL,
   SPEC_EXTENSION,
+  SPEC_READY_LABEL,
   SPEC_TEMPLATE_PATH,
   STAGE_LABELS,
   TEMPLATES_DIRNAME,
@@ -81,8 +84,10 @@ import {
   boardChanged,
   boardId,
   boardOfEpic,
+  boardRepoLabel,
   bodySections,
   branchClaims,
+  branchName,
   buildReport,
   buildSettle,
   bundledAgentsDirectory,
@@ -143,6 +148,7 @@ import {
   expectTwoArguments,
   failingRows,
   fetchClaimBranches,
+  findReadinessGaps,
   fingerprintText,
   firstNowEpic,
   firstSentence,
@@ -169,6 +175,7 @@ import {
   hasDiverged,
   hasPlanFor,
   hasSpecBlockedLabel,
+  hasSpecLabel,
   horizonOf,
   idleText,
   invalidateRows,
@@ -204,6 +211,7 @@ import {
   nextOwnerGate,
   nextQuestion,
   noBoardListsLine,
+  normaliseReason,
   notesFileName,
   onTracker,
   openBoards,
@@ -299,7 +307,9 @@ import {
   replaceManifestVersion,
   report,
   reportFollowUps,
+  requireCompleteSpec,
   requireGhProvider,
+  requireNoLeak,
   resolveAgentRoster,
   resolveCreateSpec,
   resolveDefaultBoard,
@@ -364,7 +374,7 @@ import {
   worktreesHolding,
   writeSession,
   writeShippedFile
-} from "./index-2n2nedrk.js";
+} from "./index-35ze56rz.js";
 import {
   PROBE_TIMEOUT_MS,
   loadPlanPrerequisites,
@@ -404,6 +414,7 @@ import {
   SQLITE_STORE_FILE_NAME,
   SchemaRefusedError,
   SessionRecordError,
+  TRUST_REFUSAL_EXIT,
   UnionSchemaMismatch,
   allRecords,
   checkbox,
@@ -411,9 +422,11 @@ import {
   copyEffortStore,
   countTasks,
   createFileSync,
+  createGhEditorLogin,
   createGhPermissions,
   createGhRunner,
   createGitRunner,
+  editorRefusalMessage,
   effortStoreDir,
   effortStoreFileName,
   errorCode,
@@ -424,6 +437,7 @@ import {
   findRecords,
   fix_schema_default,
   formatCounts,
+  ghBoardTrust,
   gitRemoteUrl,
   gitSaid,
   hop,
@@ -447,6 +461,8 @@ import {
   plural,
   positionFilePath,
   readAuthorTrust,
+  readBoardTrust,
+  readEditorTrust,
   readFrontmatter,
   readFrontmatterDocument,
   readHopRecord,
@@ -471,11 +487,12 @@ import {
   staleAgainst,
   toHeldRecords,
   trustRefusalClause,
+  trustRefusalMessage,
   version,
   versionLine,
   writeFrontmatter,
   writePositionFile
-} from "./index-qvbeqrx3.js";
+} from "./index-1mxv55ec.js";
 import {
   CONFIG_DEFAULTS,
   CONFIG_FILE,
@@ -13277,6 +13294,615 @@ function createIssueCreateCommand(seams = DEFAULT_ISSUE_SEAMS) {
 }
 var create_default = createIssueCreateCommand();
 
+// src/commands/issue/edit-run.ts
+import { existsSync as existsSync9, mkdirSync as mkdirSync5, writeFileSync as writeFileSync6 } from "fs";
+import { join as join29 } from "path";
+
+// src/board/issue-edit-body.ts
+var TRAILING_WHITESPACE = /\s+$/u;
+function trimmedText(text, what) {
+  const trimmed = text.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, text) {
+  return `${renderUpdateHeading(now, reason)}
+
+${trimmedText(text, "the added text")}`;
+}
+function separatorAfter(body) {
+  if (body === "" || body.endsWith(`
+
+`))
+    return "";
+  return body.endsWith(`
+`) ? `
+` : `
+
+`;
+}
+function appendedBody(body, block) {
+  return `${body}${separatorAfter(body)}${block}`;
+}
+function replacedBody(text) {
+  return trimmedText(text, "the replacing text");
+}
+function carriesUpdateBlock(body, block) {
+  const trimmed = body.replace(TRAILING_WHITESPACE, "");
+  if (!trimmed.endsWith(block))
+    return false;
+  const before = trimmed.slice(0, trimmed.length - block.length);
+  return before === "" || before.endsWith(`
+`);
+}
+function originalPartHolds(before, after, block) {
+  if (!after.startsWith(before))
+    return false;
+  const added = after.slice(before.length).replace(TRAILING_WHITESPACE, "");
+  return added === `${separatorAfter(before)}${block}`;
+}
+
+// src/board/issue-edit-state.ts
+import { readdirSync as readdirSync3, statSync as statSync8 } from "fs";
+import { join as join28, resolve as resolve10 } from "path";
+function isClaimed(labels) {
+  return labels.includes(CLAIMED_LABEL) || labels.includes(IN_DEVELOPMENT_LABEL);
+}
+function refused(refusal10, branch = null) {
+  return { pass: false, refusal: refusal10, branch };
+}
+function readEditState(input) {
+  if (!input.open)
+    return refused("closed");
+  if (isClaimed(input.labels)) {
+    const branch = branchName(input.issue, input.title);
+    return input.kind === "append" && input.whileInDevelopment ? { pass: true, staleCopy: true, branch } : refused("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 refused("spec-ready");
+  if (planned)
+    return refused("planned");
+  return { pass: true, staleCopy: false, branch: null };
+}
+function refreshCommand(issue) {
+  return `rafa plan create --issue=${String(issue)} --refresh`;
+}
+function staleCopyMessage(issue, branch) {
+  const n = String(issue);
+  const refresh = refreshCommand(issue);
+  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(issue, extra) {
+  return `rafa issue edit ${String(issue)} --append-file=<file> --reason=<text>${extra}`;
+}
+function editStateRefusalMessage(input, reading) {
+  if (reading.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 (reading.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 ${reading.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(name, issue) {
+  const prefix = `${boardId(issue)}-`;
+  return name.startsWith(prefix) && name.endsWith(SPEC_EXTENSION) && name.length > prefix.length + SPEC_EXTENSION.length && name !== notesFileName(issue);
+}
+function findSavedCopies(root, specsDir, issue) {
+  const dir = resolve10(root, specsDir);
+  let names;
+  try {
+    names = readdirSync3(dir);
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT")
+      return [];
+    throw error;
+  }
+  return names.filter((name) => isSavedCopyName(name, issue)).filter((name) => statSync8(join28(dir, name)).isFile()).sort().map((name) => join28(specsDir, name));
+}
+
+// src/board/issue-edit-text.ts
+function addedTextSource(issue) {
+  return `the text added to issue #${String(issue)}`;
+}
+function editedBodySource(issue) {
+  return `issue #${String(issue)} 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);
+}
+
+// src/commands/issue/edit-run.ts
+var 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]";
+var EDIT_REFUSAL_EXIT = TRUST_REFUSAL_EXIT;
+var EDIT_CONFLICT_EXIT = 1;
+var EDIT_SCRATCH_DIR = join29(".rafa", "scratch");
+var STDIN_PATH2 = "-";
+var ISSUE_NUMBER8 = /^[1-9]\d*$/u;
+var TRAILING_WHITESPACE2 = /\s+$/u;
+var ACCOUNTLESS_KIND = "local";
+var LOCAL_OWNERSHIP = "local: the local tracker holds no accounts, so nobody is asked about";
+var FLAG = Object.freeze({
+  appendFile: "append-file",
+  append: "append",
+  reason: "reason",
+  replaceFile: "replace-file",
+  title: "title",
+  dryRun: "dry-run",
+  whileInDevelopment: "while-in-development"
+});
+
+class EditRefusal extends CommandExit {
+  refusal;
+  readings;
+  constructor(refusal10, sentence, readings, dryRun) {
+    const passed = dryRun ? readings.map(renderReading) : [];
+    super(EDIT_REFUSAL_EXIT, [...passed, `\u274C refused ${refusal10}: ${sentence}`].join(`
+`));
+    this.refusal = refusal10;
+    this.readings = readings;
+  }
+}
+function editExitCode(outcome) {
+  return outcome === "conflict" ? EDIT_CONFLICT_EXIT : 0;
+}
+function renderReading(reading) {
+  return `${reading.gate}: ${reading.line}`;
+}
+function readSwitch3(flags, name) {
+  const value = flags[name];
+  if (value === undefined)
+    return false;
+  if (typeof value === "boolean")
+    return value;
+  if (value === "true" || value === "false")
+    return value === "true";
+  throw lineRefusal(`--${name} 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_NUMBER8.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, FLAG.appendFile, EDIT_USAGE),
+    append: readNonBlankFlag(flags, FLAG.append, EDIT_USAGE),
+    reason: readNonBlankFlag(flags, FLAG.reason, EDIT_USAGE),
+    replaceFile: readNonBlankFlag(flags, FLAG.replaceFile, EDIT_USAGE),
+    title: readNonBlankFlag(flags, FLAG.title, EDIT_USAGE),
+    whileInDevelopment: readSwitch3(flags, FLAG.whileInDevelopment),
+    dryRun: readSwitch3(flags, FLAG.dryRun)
+  };
+}
+function appendLine3(issue, read) {
+  if (read.appendFile !== undefined && read.append !== undefined) {
+    throw notTogether(FLAG.appendFile, FLAG.append, "name the added text one way");
+  }
+  if (read.title !== undefined)
+    throw notTogether(FLAG.title, FLAG.append, "a title changes under the gates of a replace");
+  if (read.reason === undefined) {
+    throw lineRefusal(`--${FLAG.reason} is required with an append: --${FLAG.reason}=<text>`, EDIT_USAGE);
+  }
+  const source = read.appendFile === undefined ? { from: "line", text: read.append ?? "" } : { from: "file", flag: FLAG.appendFile, path: read.appendFile };
+  return { ...lineOf(issue, read, "append", source), reason: read.reason, whileInDevelopment: read.whileInDevelopment };
+}
+function lineOf(issue, read, kind, source) {
+  return { issue, kind, source, reason: null, title: read.title ?? null, whileInDevelopment: false, dryRun: read.dryRun };
+}
+function readEditLine(args, flags) {
+  const issue = readEditIssue(args);
+  const read = readEditFlags(flags);
+  const appending = read.appendFile !== undefined || read.append !== undefined;
+  if (appending && read.replaceFile !== undefined) {
+    const appendFlag = read.appendFile === undefined ? FLAG.append : FLAG.appendFile;
+    throw notTogether(appendFlag, FLAG.replaceFile, "an edit either appends or replaces");
+  }
+  if (appending)
+    return appendLine3(issue, read);
+  if (read.reason !== undefined) {
+    throw lineRefusal(`--${FLAG.reason} goes with an append only: a replace and a title change take none`, EDIT_USAGE);
+  }
+  if (read.whileInDevelopment) {
+    throw lineRefusal(`--${FLAG.whileInDevelopment} goes with an append only: a spec under way is never replaced or retitled`, EDIT_USAGE);
+  }
+  if (read.replaceFile !== undefined) {
+    return lineOf(issue, read, "replace", { from: "file", flag: FLAG.replaceFile, path: read.replaceFile });
+  }
+  if (read.title !== undefined)
+    return lineOf(issue, read, "title", null);
+  throw lineRefusal(`Name the edit: --${FLAG.appendFile}, --${FLAG.append}, --${FLAG.replaceFile} or --${FLAG.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 text;
+  try {
+    text = 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 (text.trim() === "")
+    throw lineRefusal(`--${source.flag} read nothing but whitespace from ${where}`, EDIT_USAGE);
+  return text;
+}
+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 block = renderUpdateBlock(now, request.reason ?? "", request.text ?? "");
+    const already = carriesUpdateBlock(found.body, block);
+    const after = already ? found.body : appendedBody(found.body, block);
+    return { added: request.text ?? "", shown: block, block, 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 title = request.title ?? "";
+  return { added: title, shown: title, block: null, after: found.body, already: false, change: { title } };
+}
+function trustedLine(reading, repo) {
+  return reading.source === "allow-list" ? `${reading.login}, listed in board.trustedAuthors` : `${reading.login}, who has write access to ${repo}`;
+}
+function gatesFor(request) {
+  const readings = [];
+  return {
+    readings,
+    pass: (gate, line) => {
+      readings.push({ gate, line });
+    },
+    refuse: (refusal10, sentence) => {
+      throw new EditRefusal(refusal10, 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 refusal10 = author.refusal === "lookup-failed" ? "ownership-unknown" : "ownership";
+    gates.refuse(refusal10, 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, reading) {
+  if (reading.branch !== null) {
+    return `a loop holds it on ${reading.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 reading = readEditState(input);
+  if (!reading.pass)
+    gates.refuse(reading.refusal, editStateRefusalMessage(input, reading));
+  gates.pass("state", stateLine(input, reading));
+  return reading;
+}
+function normalised(text) {
+  return text.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(issue, stamp, attempt3) {
+  const suffix = attempt3 === 1 ? "" : `-${String(attempt3)}`;
+  const name = (side) => join29(EDIT_SCRATCH_DIR, `${boardId(issue)}-edit-${side}-${stamp}${suffix}.md`);
+  return { before: name("before"), after: name("after") };
+}
+function saveConflictBodies(root, issue, now, before, after) {
+  mkdirSync5(join29(root, EDIT_SCRATCH_DIR), { recursive: true });
+  const stamp = fileStamp(now);
+  let attempt3 = 1;
+  let paths = conflictPaths(issue, stamp, attempt3);
+  while (existsSync9(join29(root, paths.before)) || existsSync9(join29(root, paths.after))) {
+    attempt3 += 1;
+    paths = conflictPaths(issue, stamp, attempt3);
+  }
+  writeFileSync6(join29(root, paths.before), before, { flag: "wx" });
+  writeFileSync6(join29(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, outcome, branch, name) {
+  switch (outcome) {
+    case "appended":
+      return `Appended an update to ${name}; the original part is unchanged.`;
+    case "stale-copy":
+      return `Appended an update to ${name}. ${staleCopyMessage(request.issue, branch)}`;
+    case "already":
+      return `${name} already ends with this update; nothing was written.`;
+    case "replaced": {
+      if (request.text === null)
+        return `Changed the title of ${name}.`;
+      return request.title === null ? `Replaced the body of ${name}.` : `Replaced the body and the title of ${name}.`;
+    }
+    case "conflict":
+      throw new TypeError("issue edit: a conflict is worded with the paths it saved");
+  }
+}
+function dryRunMessage(issue, due, branch) {
+  const stale = due === "stale-copy" ? ` ${staleCopyMessage(issue, branch)}` : "";
+  return `--dry-run: nothing was written; the edit would answer ${due}.${stale}`;
+}
+function conflictMessage(name, scratch) {
+  return `The edit was written, but ${name} 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 ref8 = issueRef(tracker, String(request.issue));
+  const name = issueName(ref8);
+  const now = options.now();
+  const found = await onTracker(tracker, `read ${name}`, () => tracker.editable(ref8));
+  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(outcome, written, message) {
+    return report2(request, planned, gates.readings, { outcome, written, 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, name));
+  await onTracker(tracker, `edit ${name}`, () => tracker.edit(ref8, planned.change));
+  const reread = await onTracker(tracker, `read ${name} again after the edit was written`, () => tracker.editable(ref8));
+  if (writeHeld(found, planned, reread))
+    return done(due, true, outcomeMessage(request, due, branch, name));
+  const scratch = saveConflictBodies(options.root, request.issue, now, found.body, reread.body);
+  return Object.freeze({ ...done("conflict", true, conflictMessage(name, 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 });
+}
+
+// src/commands/issue/edit.ts
+var DEFAULT_EDIT_SEAMS = Object.freeze({});
+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 edit_default = createIssueEditCommand();
+
 // src/commands/issue/move.ts
 var USAGE23 = "rafa issue move <id> <state>";
 async function moveIssue(context, seams) {
@@ -14201,7 +14827,7 @@ function poll(following, before, context, seams) {
   }
   return { cursor, found: null };
 }
-function lineOf(found, following, session, reading) {
+function lineOf2(found, following, session, reading) {
   if (found.event !== null)
     return eventLine(found.event);
   if (found.reason === "exit")
@@ -14222,7 +14848,7 @@ function resultOf5(found, following, seams) {
   return {
     reason: found.reason,
     exitCode: found.reason === "timeout" ? WAIT_TIMEOUT_EXIT : waitExitCode(found.reason),
-    line: lineOf(found, following, session, reading),
+    line: lineOf2(found, following, session, reading),
     event: found.event,
     session,
     awakeMinutes: reading.awakeMinutes,
@@ -14520,7 +15146,7 @@ var STATE_MARK = "\uD83D\uDCCD";
 var PROPOSAL_MARK = "\uD83D\uDC49";
 var STOP_MARK = "\u23F9";
 var MAX_ACTIONS = 12;
-function stateLine(state) {
+function stateLine2(state) {
   return `${STATE_MARK} ${state.reading}.`;
 }
 function proposalLine(state, invocation) {
@@ -14677,7 +15303,7 @@ async function playTurn(options, state, previous) {
   for (const problem2 of state.problems)
     warn3(problem2);
   const invocation = actionInvocation(state, passedOptions(roadmap));
-  info2(stateLine(state));
+  info2(stateLine2(state));
   info2(proposalLine(state, invocation));
   const halt = (stop, over = {}) => ({ stop, step: stepOf2(state, invocation, over) });
   if (dryRun !== null)
@@ -14703,7 +15329,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]) }
@@ -14712,7 +15338,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);
@@ -14752,8 +15378,8 @@ async function runStateAction(context, sources, state, passed) {
   if (outcome.said !== "")
     context.output.info(outcome.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)
@@ -14787,7 +15413,7 @@ async function runNext(context, seams) {
   const prompter = lazyPrompter(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,
@@ -14808,8 +15434,8 @@ async function runNext(context, seams) {
       }),
       ...roadmap ? { roadmap: { afterLoop: () => homeAfterLoop(context, sources), claimAhead } } : {}
     });
-    endOfEpic(context, sources, report2, dry.last());
-    return report2;
+    endOfEpic(context, sources, report3, dry.last());
+    return report3;
   } finally {
     prompter.close();
   }
@@ -14871,9 +15497,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);
@@ -14991,7 +15617,7 @@ var create_default2 = endingWith(wrapped2);
 
 // src/commands/plan/risk.ts
 import { readFileSync as readFileSync16 } from "fs";
-import { resolve as resolve10 } from "path";
+import { resolve as resolve11 } from "path";
 var COMMAND6 = "rafa plan risk";
 var USAGE33 = "rafa plan risk [<plan>] [--strict]";
 var STRICT_HINT = `Type the plan first: ${COMMAND6} <plan> --strict`;
@@ -15004,7 +15630,7 @@ function riskPlanPath(root, planDir, typed) {
     return path;
   if (typed !== null)
     throw new CommandExit(1, `\u274C Plan file not found: ${path}`);
-  const lookedFor = [...new Set([resolve10(root, planDir, DEFAULT_PLAN_FILE), resolve10(root, DEFAULT_PLAN_FILE)])];
+  const lookedFor = [...new Set([resolve11(root, planDir, DEFAULT_PLAN_FILE), resolve11(root, DEFAULT_PLAN_FILE)])];
   throw new CommandExit(1, `\u274C No plan named, and no default plan at ${lookedFor.join(" or ")}
 Usage: ${USAGE33}`);
 }
@@ -15013,8 +15639,8 @@ function riskLine(finding) {
   const place2 = finding.file === undefined ? "" : `${finding.file}${line}: `;
   return `${place2}${finding.kind}: ${finding.text}`;
 }
-function strictRefusal(report2) {
-  return `\u274C ${report2.plan}: ${plural(report2.total.high, "high finding")}; --strict refuses a plan with any`;
+function strictRefusal(report3) {
+  return `\u274C ${report3.plan}: ${plural(report3.total.high, "high finding")}; --strict refuses a plan with any`;
 }
 async function readRisk(path, project, config, context, seams) {
   const makeRunners = seams.runners ?? spawningRunners;
@@ -15076,24 +15702,24 @@ function createPlanRiskCommand(seams = {}) {
         context.output.warn(message);
       });
       const path = riskPlanPath(project.root, config.planDir, typed);
-      const report2 = await readRisk(path, project, config, context, seams);
-      const refused = strict && report2.total.high > 0;
+      const report3 = await readRisk(path, project, config, context, seams);
+      const refused2 = strict && report3.total.high > 0;
       if (context.outputMode === "json") {
-        if (!refused) {
-          context.output.result(report2);
+        if (!refused2) {
+          context.output.result(report3);
           return;
         }
-        for (const finding of report2.findings) {
+        for (const finding of report3.findings) {
           if (finding.level === "high")
             context.output.error(riskLine(finding));
         }
       } else {
-        for (const line of renderRiskText(report2).split(`
+        for (const line of renderRiskText(report3).split(`
 `))
           context.output.info(line);
       }
-      if (refused)
-        throw new CommandExit(1, strictRefusal(report2));
+      if (refused2)
+        throw new CommandExit(1, strictRefusal(report3));
     }
   };
   return Object.freeze(command);
@@ -15102,7 +15728,7 @@ var risk_default = createPlanRiskCommand();
 
 // src/commands/plan/show.ts
 import { readFileSync as readFileSync17 } from "fs";
-import { join as join28 } from "path";
+import { join as join30 } from "path";
 var USAGE34 = "rafa plan show <stub> [--tracker]";
 var COMMAND7 = "rafa plan show";
 function readTrackerFlag(value) {
@@ -15120,9 +15746,9 @@ function showPlan(plans, stub, tracker) {
     throw new CommandExit(1, `\u274C "${stub}" is no plan stub: a stub is letters, digits, ".", "_" and "-"`);
   }
   const name = planFileName(stub, tracker);
-  const file = join28(plans.path, name);
+  const file = join30(plans.path, name);
   if (!isFile(file))
-    throw new CommandExit(1, missingText(stub, tracker, join28(plans.label, name)));
+    throw new CommandExit(1, missingText(stub, tracker, join30(plans.label, name)));
   const model = parsePlan(readFileSync17(file, "utf8"));
   const { header } = model;
   return {
@@ -15146,7 +15772,7 @@ function taskLine(task) {
   return `  ${checkbox(task.status)} ${task.text}`;
 }
 function renderShownPlan(shown, dirLabel) {
-  const relative8 = join28(dirLabel, planFileName(shown.stub, shown.tracker));
+  const relative8 = join30(dirLabel, planFileName(shown.stub, shown.tracker));
   const fileLabel = shown.tracker ? "Tracker" : "File";
   const lines = [`Plan: ${shown.stub}`, `${fileLabel}: ${relative8}`];
   if (shown.header.issue !== null)
@@ -15700,7 +16326,7 @@ function freedIssueLine(issue) {
   const title = issue.title.trim();
   return title === "" ? `${INDENT}#${String(issue.number)}` : `${INDENT}#${String(issue.number)} ${title}`;
 }
-function report2(closed, freed, problem2) {
+function report3(closed, freed, problem2) {
   return Object.freeze({ relationships: "native", closed, freed: Object.freeze(freed), problem: problem2 });
 }
 async function readFreed(gh, closed) {
@@ -15721,14 +16347,14 @@ async function freedAfterMerge(options) {
   } catch (error) {
     const problem2 = messageOf(error);
     warn3(freedProblemLine(problem2));
-    return report2(closed, [], problem2);
+    return report3(closed, [], problem2);
   }
   if (freed.length > 0) {
     info2(freedHeaderLine(closed, freed.length));
     for (const issue of freed)
       info2(freedIssueLine(issue));
   }
-  return report2(closed, freed, null);
+  return report3(closed, freed, null);
 }
 
 // src/commands/pr/merge-guard.ts
@@ -15785,18 +16411,18 @@ async function guardBeforeMerge(step) {
   const answer2 = answerOf(reading);
   const reaction = guardReaction(reading, settings);
   const lines = guardLines(reading, settings.releaseVersionFile);
-  const report3 = { answer: answer2, reaction, lines };
+  const report4 = { answer: answer2, reaction, lines };
   if (reaction === "refuse")
     throw guardRefusal(refusalHead(step.detail.number, answer2), lines);
   if (reaction === "ask")
-    return { report: report3, go: await askGuard(step, answer2, lines) };
+    return { report: report4, go: await askGuard(step, answer2, lines) };
   printLines(step, reaction, lines);
-  return { report: report3, go: true };
+  return { report: report4, go: true };
 }
 
 // src/commands/pr/merge-loop-worktree.ts
-import { copyFileSync as copyFileSync3, mkdirSync as mkdirSync5, realpathSync as realpathSync3, statSync as statSync8 } from "fs";
-import { dirname as dirname6, isAbsolute as isAbsolute6, join as join29, relative as relative8, resolve as resolve11, sep as sep4 } from "path";
+import { copyFileSync as copyFileSync3, mkdirSync as mkdirSync6, realpathSync as realpathSync3, statSync as statSync9 } from "fs";
+import { dirname as dirname6, isAbsolute as isAbsolute6, join as join31, relative as relative8, resolve as resolve12, sep as sep4 } from "path";
 var REFUSAL_PREFIX = "rafa pr merge refuses";
 var INDENT4 = "   ";
 var LIVE_STATES = new Set(["running", "paused"]);
@@ -15804,9 +16430,9 @@ function defaultLoopWorktreeSeams(mainCheckout) {
   return {
     git: createGitRunner(mainCheckout),
     gitAt: createGitRunner,
-    modifiedAt: (path) => statSync8(path, { throwIfNoEntry: false })?.mtime ?? null,
+    modifiedAt: (path) => statSync9(path, { throwIfNoEntry: false })?.mtime ?? null,
     copyFile: (from, to) => {
-      mkdirSync5(dirname6(to), { recursive: true });
+      mkdirSync6(dirname6(to), { recursive: true });
       copyFileSync3(from, to);
     },
     realPath: (path) => {
@@ -15837,11 +16463,11 @@ function readLoopHolder(seams, reading) {
   };
 }
 function freeLoopWorktree(seams, reading, holder) {
-  const into = resolve11(reading.mainCheckout, reading.planDir);
+  const into = resolve12(reading.mainCheckout, reading.planDir);
   const files = [];
   for (const name of planFileNames(holder.stub)) {
-    const from = resolve11(holder.path, reading.planDir, name);
-    const to = join29(into, name);
+    const from = resolve12(holder.path, reading.planDir, name);
+    const to = join31(into, name);
     try {
       files.push({ name, from, to, outcome: copyPlanFile(seams, from, to) });
     } catch (error) {
@@ -17633,8 +18259,8 @@ function describeAge(updatedAt, now) {
     return `${plural3(hours, "hour", "hours")} ago`;
   return `${plural3(Math.floor(age / DAY_MS2), "day", "days")} ago`;
 }
-function triageCommand(number, resolve12 = false) {
-  return resolve12 ? `rafa pr triage ${number} --resolve` : `rafa pr triage ${number}`;
+function triageCommand(number, resolve13 = false) {
+  return resolve13 ? `rafa pr triage ${number} --resolve` : `rafa pr triage ${number}`;
 }
 function joinNumbers(pulls) {
   const names = pulls.map((pull2) => `#${pull2.number}`);
@@ -17645,14 +18271,14 @@ function joinNumbers(pulls) {
 function byNumber2(pulls) {
   return Object.freeze([...pulls].sort((left, right) => left.number - right.number));
 }
-function skipped(pull2, now, resolve12) {
+function skipped(pull2, now, resolve13) {
   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, resolve12)
+    command: triageCommand(pull2.number, resolve13)
   });
 }
 function skippedLine(one) {
@@ -17696,15 +18322,15 @@ function listReading(rest, count) {
   return listing("list", Object.freeze([]), rest, headline);
 }
 function selectTriagePullRequests(input) {
-  const resolve12 = input.resolve === true;
+  const resolve13 = 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 = byNumber2(input.candidates);
   const count = candidates.length;
-  const lines = candidates.map((pull2) => skipped(pull2, now, resolve12));
-  if (resolve12 && count > 1)
+  const lines = candidates.map((pull2) => skipped(pull2, now, resolve13));
+  if (resolve13 && count > 1)
     return refusal12(lines, count);
   if (count === 0) {
     return plain("none", Object.freeze([]), "no red pull request to triage, and no pull request on the current branch");
@@ -18064,8 +18690,8 @@ function withTaskBudget(plan2, usd) {
 }
 
 // src/pr/plans/load.ts
-import { existsSync as existsSync9, readFileSync as readFileSync18 } from "fs";
-import { dirname as dirname7, join as join30 } from "path";
+import { existsSync as existsSync10, readFileSync as readFileSync18 } from "fs";
+import { dirname as dirname7, join as join32 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 var MODULE_DIR4 = dirname7(fileURLToPath4(import.meta.url));
 var PINNED_PLANS_DIRNAME = "plans";
@@ -18082,8 +18708,8 @@ function hasPinnedPlan(triageClass) {
 function pinnedPlanCandidates(moduleDir, triageClass) {
   const name = pinnedPlanFileName(triageClass);
   return [
-    join30(moduleDir, PINNED_PLANS_DIRNAME, name),
-    join30(moduleDir, name)
+    join32(moduleDir, PINNED_PLANS_DIRNAME, name),
+    join32(moduleDir, name)
   ];
 }
 function readPinnedPlan(triageClass, lookup = {}) {
@@ -18091,7 +18717,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_DIR4, triageClass);
-  const found = candidates.find((candidate) => existsSync9(candidate));
+  const found = candidates.find((candidate) => existsSync10(candidate));
   if (found === undefined) {
     throw new Error(`The pinned resolve plan for ${triageClass} is missing: ` + `no file at ${candidates.join(" or ")}`);
   }
@@ -18235,21 +18861,21 @@ function readAttemptRepeat(input) {
 }
 
 // src/commands/pr/resolve-loop.ts
-import { mkdirSync as mkdirSync6, writeFileSync as writeFileSync6 } from "fs";
-import { join as join31 } from "path";
-var RESOLVE_SUBDIR = join31(".rafa", "resolve");
+import { mkdirSync as mkdirSync7, writeFileSync as writeFileSync7 } from "fs";
+import { join as join33 } from "path";
+var RESOLVE_SUBDIR = join33(".rafa", "resolve");
 var RUN_PREFIX = "pr-";
 var ATTEMPT_PREFIX = "attempt-";
 var LOOP_WORDS = Object.freeze(["loop", "start"]);
 var CHILD_OUTPUT = "text";
 function resolveRunDir(home, number, attempt3) {
-  return join31(home, RESOLVE_SUBDIR, `${RUN_PREFIX}${number}`, `${ATTEMPT_PREFIX}${attempt3}`);
+  return join33(home, RESOLVE_SUBDIR, `${RUN_PREFIX}${number}`, `${ATTEMPT_PREFIX}${attempt3}`);
 }
 function writeResolvePlan(write) {
   const dir = resolveRunDir(write.home, write.number, write.attempt);
-  mkdirSync6(dir, { recursive: true });
-  const path = join31(dir, pinnedPlanFileName(write.triageClass));
-  writeFileSync6(path, write.plan, "utf8");
+  mkdirSync7(dir, { recursive: true });
+  const path = join33(dir, pinnedPlanFileName(write.triageClass));
+  writeFileSync7(path, write.plan, "utf8");
   return path;
 }
 function resolveLoopArgv(planPath) {
@@ -18289,8 +18915,8 @@ async function runResolveLoop(run, seams = {}) {
 }
 
 // src/pr/triage/version-convert.ts
-import { mkdirSync as mkdirSync7, readFileSync as readFileSync19, writeFileSync as writeFileSync7 } from "fs";
-import { dirname as dirname8, join as join32, posix } from "path";
+import { mkdirSync as mkdirSync8, readFileSync as readFileSync19, writeFileSync as writeFileSync8 } from "fs";
+import { dirname as dirname8, join as join34, posix } from "path";
 var FALLBACK_PLAN_PREFIX = "pr-";
 var UNUSABLE_PLAN_CHARACTERS = /[^A-Za-z0-9._-]+/g;
 var UNUSABLE_PLAN_START = /^[^A-Za-z0-9]+/;
@@ -18333,7 +18959,7 @@ function fragmentNamesAt(git, commit, directory) {
     return [];
   return listed2.stdout.split("\x00").filter((path) => path !== "").map((path) => posix.basename(path));
 }
-function refused(problem2, problems) {
+function refused2(problem2, problems) {
   return { outcome: "refused", problem: problem2, problems };
 }
 function fragmentTitle(title, plan2) {
@@ -18370,9 +18996,9 @@ function planConversion(input, problems) {
   const baseRef = `${input.remote ?? RELEASE_REMOTE}/${input.base}`;
   const headCommit = commitOf(git, "HEAD");
   if (headCommit === null)
-    return refused(`the worktree at ${input.worktree} has no HEAD commit`, problems);
+    return refused2(`the worktree at ${input.worktree} has no HEAD commit`, problems);
   if (input.head !== null && headCommit !== input.head) {
-    return refused(`the worktree's ${input.branch} is at ${headCommit.slice(0, SHORT_HASH_LENGTH)}, not at the pull request's` + ` head ${input.head.slice(0, SHORT_HASH_LENGTH)}; bring the branch up to its pull request's head and run it again`, problems);
+    return refused2(`the worktree's ${input.branch} is at ${headCommit.slice(0, SHORT_HASH_LENGTH)}, not at the pull request's` + ` head ${input.head.slice(0, SHORT_HASH_LENGTH)}; bring the branch up to its pull request's head and run it again`, problems);
   }
   const guard = readGuard({
     git,
@@ -18382,7 +19008,7 @@ function planConversion(input, problems) {
     now: input.now
   });
   if (!guard.ok)
-    return refused(`the release guard could not read ${input.branch}: ${guard.problem}`, problems);
+    return refused2(`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 };
@@ -18390,25 +19016,25 @@ function planConversion(input, problems) {
   const { stamp } = verdict;
   const start2 = mergeBaseSide(git, guard.base.commit, headCommit, settings);
   if (start2 === null)
-    return refused(`${input.branch} and ${baseRef} share no merge base`, problems);
+    return refused2(`${input.branch} and ${baseRef} share no merge base`, problems);
   const level = conversionLevel(start2.version, stamp.version);
   if (level === null) {
-    return refused(`no release level reads off the stamp: ${input.branch} stamped ${stamp.version} over` + ` ${start2.version ?? "no version"} at its merge base with ${baseRef}`, problems);
+    return refused2(`no release level reads off the stamp: ${input.branch} stamped ${stamp.version} over` + ` ${start2.version ?? "no version"} at its merge base with ${baseRef}`, problems);
   }
   if (start2.version === null)
-    return refused(`the merge base declares no version in ${settings.releaseVersionFile} to restore`, problems);
+    return refused2(`the merge base declares no version in ${settings.releaseVersionFile} to restore`, problems);
   if (start2.changelog === null) {
-    return refused(`the merge base holds no ${settings.releaseChangelog}, so ${input.branch} created it and there is no text to restore`, problems);
+    return refused2(`the merge base holds no ${settings.releaseChangelog}, so ${input.branch} created it and there is no text to restore`, problems);
   }
   let branchVersionText;
   try {
-    branchVersionText = readFileSync19(join32(input.worktree, settings.releaseVersionFile), "utf8");
+    branchVersionText = readFileSync19(join34(input.worktree, settings.releaseVersionFile), "utf8");
   } catch (error) {
-    return refused(`${settings.releaseVersionFile} could not be read in the worktree: ${messageOf(error)}`, problems);
+    return refused2(`${settings.releaseVersionFile} could not be read in the worktree: ${messageOf(error)}`, problems);
   }
   const rewritten = replaceManifestVersion(branchVersionText, start2.version);
   if (rewritten === null) {
-    return refused(`${input.branch}'s ${settings.releaseVersionFile} holds no version pair ${start2.version} could be written over`, problems);
+    return refused2(`${input.branch}'s ${settings.releaseVersionFile} holds no version pair ${start2.version} could be written over`, problems);
   }
   return {
     stamp,
@@ -18428,10 +19054,10 @@ function writeConversion(input, plan2) {
     [input.settings.releaseChangelog, plan2.changelogText]
   ];
   for (const [path, text] of writes) {
-    const target = join32(input.worktree, path);
+    const target = join34(input.worktree, path);
     try {
-      mkdirSync7(dirname8(target), { recursive: true });
-      writeFileSync7(target, text);
+      mkdirSync8(dirname8(target), { recursive: true });
+      writeFileSync8(target, text);
     } catch (error) {
       return `${path} could not be written in the worktree, which may hold part of the conversion: ${messageOf(error)}`;
     }
@@ -18450,18 +19076,18 @@ function convertStampedVersion(input) {
     return plan2;
   const written = writeConversion(input, plan2);
   if (written !== null)
-    return refused(written, problems);
+    return refused2(written, problems);
   const paths = [plan2.fragmentPath, settings.releaseVersionFile, settings.releaseChangelog].map((path) => gitPathOf(path));
   const added = git(["add", "--", ...paths]);
   if (!added.ok)
-    return refused(`the conversion's files could not be staged, and are left in the worktree: ${gitSaid(added)}`, problems);
+    return refused2(`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 refused(`the conversion could not be committed, and is left staged in the worktree: ${gitSaid(made)}`, problems);
+    return refused2(`the conversion could not be committed, and is left staged in the worktree: ${gitSaid(made)}`, problems);
   const commit = commitOf(git, "HEAD");
   if (commit === null)
-    return refused("the conversion was committed, but HEAD names no commit to report", problems);
+    return refused2("the conversion was committed, but HEAD names no commit to report", problems);
   return {
     outcome: "converted",
     commit,
@@ -18898,16 +19524,16 @@ async function redPullRequests(pr) {
   }
   return red;
 }
-async function selectTargets(pr, warn3, now, resolve12) {
+async function selectTargets(pr, warn3, now, resolve13) {
   const branch = readBranchOrNone(pr, warn3);
   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: resolve12 });
+    return selectTriagePullRequests({ current, candidates: [], now, resolve: resolve13 });
   return selectTriagePullRequests({
     current: null,
     candidates: await redPullRequests(pr),
     now,
-    resolve: resolve12
+    resolve: resolve13
   });
 }
 async function detailOf2(pr, number) {
@@ -19044,7 +19670,7 @@ async function runTriage(context, seams) {
   }
   const numbers = asked === null ? (selection?.assess ?? []).map((one) => one.number) : [asked];
   const readings = [];
-  let resolve12 = null;
+  let resolve13 = null;
   for (const number of numbers) {
     const assess = () => assessOne({
       pr,
@@ -19064,7 +19690,7 @@ async function runTriage(context, seams) {
       readings.push(reading);
       continue;
     }
-    resolve12 = await resolvePullRequest({
+    resolve13 = await resolvePullRequest({
       trust: {
         permissions,
         trustedAuthors: pr.trustedAuthors,
@@ -19086,16 +19712,16 @@ async function runTriage(context, seams) {
       ...seams.clock === undefined ? {} : { clock: seams.clock },
       ...seams.sleep === undefined ? {} : { sleep: seams.sleep }
     });
-    readings.push(resolve12.reading);
+    readings.push(resolve13.reading);
   }
   const text = [
     ...selection === null ? [] : [selection.message],
     ...readings.length === 0 ? [] : [renderTriages(readings)],
-    ...resolve12 === null ? [] : resolve12.lines
+    ...resolve13 === null ? [] : resolve13.lines
   ].join(`
 
 `);
-  return { selection, readings, resolve: resolve12, text, exitCode: resolve12?.exitCode ?? 0 };
+  return { selection, readings, resolve: resolve13, text, exitCode: resolve13?.exitCode ?? 0 };
 }
 function createPrTriageCommand(seams = DEFAULT_TRIAGE_SEAMS) {
   const command = {
@@ -19495,9 +20121,9 @@ async function settleByPr(worktree, settings, pulls) {
   if ("problem" in branch)
     return failed2("unpushed", build, false, branch.problem);
   if (!branch.same) {
-    const refused2 = pushReleaseBranch(worktree, build, branch.current);
-    if (refused2 !== null)
-      return refused2;
+    const refused3 = pushReleaseBranch(worktree, build, branch.current);
+    if (refused3 !== null)
+      return refused3;
   }
   const head = branch.same && branch.current !== null ? branch.current : build.release;
   const draft = {
@@ -19660,9 +20286,9 @@ function tagSettle(worktree, mode, delivered) {
 }
 
 // src/release/settle-worktree.ts
-import { existsSync as existsSync10, mkdtempSync as mkdtempSync2, realpathSync as realpathSync4, rmSync as rmSync2 } from "fs";
+import { existsSync as existsSync11, mkdtempSync as mkdtempSync2, realpathSync as realpathSync4, rmSync as rmSync2 } from "fs";
 import { tmpdir as tmpdir2 } from "os";
-import { join as join33 } from "path";
+import { join as join35 } from "path";
 var SETTLE_SCRATCH_PREFIX = "rafa-settle-";
 var WORKTREE_DIRECTORY = "base";
 function removeScratch(git, scratch, path) {
@@ -19679,14 +20305,14 @@ function removeScratch(git, scratch, path) {
       problems.push(`the worktree record of ${path} could not be pruned: ${gitSaid(pruned)}`);
     }
   }
-  if (problems.length === 0 && existsSync10(scratch)) {
+  if (problems.length === 0 && existsSync11(scratch)) {
     problems.push(`the scratch directory ${scratch} is still there`);
   }
   return problems.length === 0 ? null : problems.join("; ");
 }
 function makeScratch(root) {
   try {
-    return realpathSync4(mkdtempSync2(join33(root, SETTLE_SCRATCH_PREFIX)));
+    return realpathSync4(mkdtempSync2(join35(root, SETTLE_SCRATCH_PREFIX)));
   } catch (error) {
     return { ok: false, problem: `no scratch directory could be made under ${root}: ${messageOf(error)}`, leftover: null };
   }
@@ -19708,7 +20334,7 @@ function addWorktree(options) {
   const scratch = makeScratch(options.scratchRoot ?? tmpdir2());
   if (typeof scratch !== "string")
     return scratch;
-  const path = join33(scratch, WORKTREE_DIRECTORY);
+  const path = join35(scratch, WORKTREE_DIRECTORY);
   const added = git(["worktree", "add", "--detach", path, commit]);
   if (!added.ok) {
     return {
@@ -19931,7 +20557,7 @@ var settle_default = createReleaseSettleCommand();
 
 // src/commands/release/tag.ts
 import { readFileSync as readFileSync20 } from "fs";
-import { join as join34 } from "path";
+import { join as join36 } from "path";
 
 // src/commands/release/release-commit.ts
 function unread(reason, message) {
@@ -19995,7 +20621,7 @@ function textOf(path) {
   }
 }
 function readVersion(root, configured) {
-  const resolved = join34(root, configured);
+  const resolved = join36(root, configured);
   const text = textOf(resolved);
   if (text === null) {
     return {
@@ -20009,7 +20635,7 @@ function readVersion(root, configured) {
   return version2 === null ? { path: configured, text, version: null, problem: `${resolved} declares no version this can read` } : { path: configured, text, version: version2, problem: null };
 }
 function readNewestRelease(root, configured) {
-  const resolved = join34(root, configured);
+  const resolved = join36(root, configured);
   const text = textOf(resolved);
   if (text === null) {
     return { path: configured, version: null, problem: `the changelog could not be read at ${resolved}` };
@@ -20279,17 +20905,17 @@ function createRoadmapCommand(seams = DEFAULT_ISSUE_SEAMS) {
 var roadmap_default = createRoadmapCommand();
 
 // src/commands/skill/backfill.ts
-import { statSync as statSync10 } from "fs";
-import { join as join39, resolve as resolve14 } from "path";
+import { statSync as statSync11 } from "fs";
+import { join as join41, resolve as resolve15 } from "path";
 
 // src/backfill/backup.ts
-import { copyFileSync as copyFileSync4, existsSync as existsSync11, mkdirSync as mkdirSync8 } from "fs";
-import { dirname as dirname9, isAbsolute as isAbsolute7, join as join36, relative as relative9, resolve as resolve12, sep as sep5 } from "path";
+import { copyFileSync as copyFileSync4, existsSync as existsSync12, mkdirSync as mkdirSync9 } from "fs";
+import { dirname as dirname9, isAbsolute as isAbsolute7, join as join38, relative as relative9, resolve as resolve13, sep as sep5 } from "path";
 
 // src/backfill/proposal-file.ts
-import { readdirSync as readdirSync3, readFileSync as readFileSync21 } from "fs";
-import { join as join35 } from "path";
-var BACKFILL_PATH = join35(".rafa", "backfill");
+import { readdirSync as readdirSync4, readFileSync as readFileSync21 } from "fs";
+import { join as join37 } from "path";
+var BACKFILL_PATH = join37(".rafa", "backfill");
 var PROPOSAL_FILE_PREFIX = "proposals-";
 var PROPOSAL_FILE_EXTENSION = ".yaml";
 var SHA256_PATTERN = /^[0-9a-f]{64}$/;
@@ -20315,7 +20941,7 @@ var PROPOSAL_FILE_HEADER = [
 ].join(`
 `);
 function proposalPath(dir, batch) {
-  return join35(dir, `${PROPOSAL_FILE_PREFIX}${String(batch).padStart(2, "0")}${PROPOSAL_FILE_EXTENSION}`);
+  return join37(dir, `${PROPOSAL_FILE_PREFIX}${String(batch).padStart(2, "0")}${PROPOSAL_FILE_EXTENSION}`);
 }
 function isProposalFileName(name) {
   return name.startsWith(PROPOSAL_FILE_PREFIX) && name.endsWith(PROPOSAL_FILE_EXTENSION);
@@ -20446,12 +21072,12 @@ function parseProposalFile(text) {
 function readProposalFiles(dir) {
   let names;
   try {
-    names = readdirSync3(dir);
+    names = readdirSync4(dir);
   } catch {
     return [];
   }
   return names.filter((name) => isProposalFileName(name)).sort((left, right) => left.localeCompare(right)).map((name) => {
-    const path = join35(dir, name);
+    const path = join37(dir, name);
     try {
       return { path, result: parseProposalFile(readFileSync21(path, "utf8")) };
     } catch (error) {
@@ -20461,19 +21087,19 @@ function readProposalFiles(dir) {
 }
 
 // src/backfill/backup.ts
-var BACKUP_PATH = join36(BACKFILL_PATH, "backup");
+var BACKUP_PATH = join38(BACKFILL_PATH, "backup");
 var BACKUP_KINDS = ["copied", "kept", "tracked", "outside", "missing"];
 function backupDirectory(base) {
-  return join36(base, BACKUP_PATH);
+  return join38(base, BACKUP_PATH);
 }
 function isUnder(root, path) {
-  const step = relative9(resolve12(root), resolve12(path));
+  const step = relative9(resolve13(root), resolve13(path));
   return step === "" || !step.startsWith(`..${sep5}`) && step !== ".." && !isAbsolute7(step);
 }
 function backupPathFor(path, root, backupDir) {
   if (!isUnder(root, path))
     return null;
-  return join36(backupDir, relative9(resolve12(root), resolve12(path)));
+  return join38(backupDir, relative9(resolve13(root), resolve13(path)));
 }
 function backupFile(path, options) {
   if (options.repoRoot !== null && isUnder(options.repoRoot, path)) {
@@ -20482,11 +21108,11 @@ function backupFile(path, options) {
   const backup = backupPathFor(path, options.root, options.backupDir);
   if (backup === null)
     return { path, kind: "outside", backup: null };
-  if (!existsSync11(path))
+  if (!existsSync12(path))
     return { path, kind: "missing", backup: null };
-  if (existsSync11(backup))
+  if (existsSync12(backup))
     return { path, kind: "kept", backup };
-  mkdirSync8(dirname9(backup), { recursive: true });
+  mkdirSync9(dirname9(backup), { recursive: true });
   copyFileSync4(path, backup);
   return { path, kind: "copied", backup };
 }
@@ -20509,7 +21135,7 @@ function countBackups(results) {
 }
 
 // src/backfill/derive.ts
-import { readFileSync as readFileSync22, writeFileSync as writeFileSync8 } from "fs";
+import { readFileSync as readFileSync22, writeFileSync as writeFileSync9 } from "fs";
 import { basename as basename6 } from "path";
 var DERIVED_FIELDS = ["stack", "paths", "when_to_use"];
 function renderWhenToUse(trigger, prevents) {
@@ -20688,7 +21314,7 @@ function applyFile(action, options) {
       text: null
     };
   }
-  writeFileSync8(action.path, action.text, "utf8");
+  writeFileSync9(action.path, action.text, "utf8");
   const after = failureLines(checkFile(action.path, "skill", {
     projectRoot: options.projectRoot,
     pathDirs: options.pathDirs
@@ -20696,7 +21322,7 @@ function applyFile(action, options) {
   const added = addedFailures(action.before, after);
   if (added.length === 0)
     return action;
-  writeFileSync8(action.path, action.original, "utf8");
+  writeFileSync9(action.path, action.original, "utf8");
   return {
     ...action,
     kind: "refused",
@@ -20800,8 +21426,8 @@ function summaryLine3(rows) {
   const parts = DEMOTION_VERDICTS.map((verdict) => `${counts[verdict]} ${verdict}`);
   return `${files}: ${parts.join(", ")}.`;
 }
-function writeDemotionReport(report3) {
-  const rows = report3.rows.map((row2) => tableLine2([
+function writeDemotionReport(report4) {
+  const rows = report4.rows.map((row2) => tableLine2([
     escapeCell(row2.path),
     escapeCell(row2.hash),
     escapeCell(row2.verdict),
@@ -20810,11 +21436,11 @@ function writeDemotionReport(report3) {
     escapeCell(row2.overrideReason ?? EMPTY_CELL)
   ]));
   return [
-    renderHeader(report3.status),
+    renderHeader(report4.status),
     "",
     REPORT_TITLE,
     "",
-    summaryLine3(report3.rows),
+    summaryLine3(report4.rows),
     "",
     tableLine2(DEMOTION_REPORT_COLUMNS),
     tableLine2(DEMOTION_REPORT_COLUMNS.map(() => "---")),
@@ -21115,8 +21741,8 @@ function parseSessionAnswer(stdout) {
 }
 
 // src/backfill/propose.ts
-import { mkdirSync as mkdirSync9, readFileSync as readFileSync24, writeFileSync as writeFileSync9 } from "fs";
-import { join as join37, resolve as resolve13 } from "path";
+import { mkdirSync as mkdirSync10, readFileSync as readFileSync24, writeFileSync as writeFileSync10 } from "fs";
+import { join as join39, resolve as resolve14 } from "path";
 var PROPOSAL_ACTION_KINDS = [
   "applied",
   "unchanged",
@@ -21195,12 +21821,12 @@ async function runProposalPass(options) {
   const batches = batchCandidates(candidates);
   const written = [];
   if (batches.length > 0)
-    mkdirSync9(options.backfillDir, { recursive: true });
+    mkdirSync10(options.backfillDir, { recursive: true });
   for (const [index, batch] of batches.entries()) {
     const number = index + 1;
     const file = await runProposalBatch(number, batch, options);
     const path = proposalPath(options.backfillDir, number);
-    writeFileSync9(path, renderProposalFile(file), "utf8");
+    writeFileSync10(path, renderProposalFile(file), "utf8");
     written.push({ path, file });
   }
   return { written, candidates: candidates.length };
@@ -21242,7 +21868,7 @@ function writeRow(path, row2, original, options) {
     return inert2(path, row2, "unchanged", "every field the row proposes is already what the file carries");
   }
   const before = checkLines(path, options);
-  writeFileSync9(path, writeFrontmatter(document, mergeFrontmatter(document.data, changes)), "utf8");
+  writeFileSync10(path, writeFrontmatter(document, mergeFrontmatter(document.data, changes)), "utf8");
   const added = addedFailures(before, checkLines(path, options));
   if (added.length === 0) {
     return {
@@ -21254,7 +21880,7 @@ function writeRow(path, row2, original, options) {
       added: []
     };
   }
-  writeFileSync9(path, original, "utf8");
+  writeFileSync10(path, original, "utf8");
   return {
     path,
     relative: row2.path,
@@ -21265,7 +21891,7 @@ function writeRow(path, row2, original, options) {
   };
 }
 function applyRow(root, row2, options) {
-  const path = join37(root, ...row2.path.split("/"));
+  const path = join39(root, ...row2.path.split("/"));
   if (row2.status === UNANSWERED_ROW) {
     return inert2(path, row2, "unanswered", row2.note ?? "the row carries no answer");
   }
@@ -21288,7 +21914,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 resolve13(file.skills) === resolve13(root) ? null : `the proposal file names the skills directory ${file.skills}, not ${root}`;
+  return resolve14(file.skills) === resolve14(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]));
@@ -21302,7 +21928,7 @@ function applyProposals(files, root, options) {
   for (const file of files) {
     const refusal13 = fileRefusal(file, root);
     for (const row2 of file.rows) {
-      const action = refusal13 === null ? applyRow(root, row2, options) : inert2(join37(root, ...row2.path.split("/")), row2, "refused", refusal13);
+      const action = refusal13 === null ? applyRow(root, row2, options) : inert2(join39(root, ...row2.path.split("/")), row2, "refused", refusal13);
       actions.push(action);
       if (row2.trigger !== null && action.kind !== "refused" && action.kind !== "unanswered") {
         triggers[row2.name] = row2.trigger;
@@ -21313,13 +21939,13 @@ function applyProposals(files, root, options) {
 }
 
 // src/demote/select.ts
-import { readdirSync as readdirSync4, readFileSync as readFileSync25, realpathSync as realpathSync5, statSync as statSync9 } from "fs";
-import { basename as basename7, dirname as dirname10, join as join38 } from "path";
+import { readdirSync as readdirSync5, readFileSync as readFileSync25, realpathSync as realpathSync5, statSync as statSync10 } from "fs";
+import { basename as basename7, dirname as dirname10, join as join40 } from "path";
 var SKILLS_DIRECTORY = "skills";
 var CLAUDE_DIRECTORY = ".claude";
 var AUTO_EXTRACTED_ORIGIN = "auto-extracted";
-var DEMOTED_PATH = join38(".rafa", "demoted");
-var INSTINCTS_PATH = join38(".rafa", "instincts");
+var DEMOTED_PATH = join40(".rafa", "demoted");
+var INSTINCTS_PATH = join40(".rafa", "instincts");
 var REPORT_FILE = "report.md";
 function realOrSelf(path) {
   try {
@@ -21342,19 +21968,19 @@ function resolveDemotionScope(dir, home) {
   if (basename7(claude) !== CLAUDE_DIRECTORY)
     return null;
   const base = dirname10(claude);
-  const demotedDir = join38(base, DEMOTED_PATH);
+  const demotedDir = join40(base, DEMOTED_PATH);
   return {
     scope: samePath(base, home) ? "user" : "project",
     dir,
     base,
     demotedDir,
-    instinctsDir: join38(base, INSTINCTS_PATH),
-    reportPath: join38(demotedDir, REPORT_FILE)
+    instinctsDir: join40(base, INSTINCTS_PATH),
+    reportPath: join40(demotedDir, REPORT_FILE)
   };
 }
 function entryKind(path) {
   try {
-    const stats = statSync9(path);
+    const stats = statSync10(path);
     if (stats.isFile())
       return "file";
     if (stats.isDirectory())
@@ -21366,7 +21992,7 @@ function entryKind(path) {
 }
 function visibleNames(dir) {
   try {
-    return readdirSync4(dir).filter((name) => !name.startsWith(".")).sort((left, right) => left.localeCompare(right));
+    return readdirSync5(dir).filter((name) => !name.startsWith(".")).sort((left, right) => left.localeCompare(right));
   } catch {
     return [];
   }
@@ -21376,7 +22002,7 @@ function readSelected(absolute, path, entries) {
   let mtime;
   try {
     text = readFileSync25(absolute, "utf8");
-    mtime = statSync9(absolute).mtime.toISOString();
+    mtime = statSync10(absolute).mtime.toISOString();
   } catch {
     return null;
   }
@@ -21391,14 +22017,14 @@ function selectsLearned(text, scope) {
   return origin === AUTO_EXTRACTED_ORIGIN;
 }
 function selectLearned(scope) {
-  const dir = join38(scope.dir, LEARNED_DIRECTORY);
+  const dir = join40(scope.dir, LEARNED_DIRECTORY);
   if (entryKind(dir) !== "directory")
     return [];
   const selected = [];
   for (const name of visibleNames(dir)) {
     if (!name.endsWith(MARKDOWN_EXTENSION) || name === MARKDOWN_EXTENSION)
       continue;
-    const absolute = join38(dir, name);
+    const absolute = join40(dir, name);
     if (entryKind(absolute) !== "file")
       continue;
     const file = readSelected(absolute, `${LEARNED_DIRECTORY}/${name}`, undefined);
@@ -21412,10 +22038,10 @@ function selectSkillFiles(scope) {
   for (const name of visibleNames(scope.dir)) {
     if (name === LEARNED_DIRECTORY)
       continue;
-    const skillDir = join38(scope.dir, name);
+    const skillDir = join40(scope.dir, name);
     if (entryKind(skillDir) !== "directory")
       continue;
-    const absolute = join38(skillDir, SKILL_FILE);
+    const absolute = join40(skillDir, SKILL_FILE);
     if (entryKind(absolute) !== "file")
       continue;
     const file = readSelected(absolute, `${name}/${SKILL_FILE}`, visibleNames(skillDir));
@@ -21434,7 +22060,7 @@ var DEFAULT_BACKFILL_SEAMS = Object.freeze({
 });
 var BACKFILL_USAGE = "rafa skill backfill <dir> [--propose|--apply] [--project=<root>]";
 var REFUSED_CAP = 255;
-function readSwitch3(name, value) {
+function readSwitch4(name, value) {
   if (value === undefined || value === false || value === "false")
     return false;
   if (value === true || value === "true")
@@ -21443,8 +22069,8 @@ function readSwitch3(name, 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}`);
@@ -21463,7 +22089,7 @@ Usage: ${BACKFILL_USAGE}`);
     throw new CommandExit(1, `\u274C Expected one directory, and read "${extra}" as a second
 Usage: ${BACKFILL_USAGE}`);
   }
-  return resolve14(cwd(), dir);
+  return resolve15(cwd(), dir);
 }
 function readConsumerRoot(value, cwd) {
   if (value === undefined || value === false)
@@ -21472,11 +22098,11 @@ function readConsumerRoot(value, cwd) {
     throw new CommandExit(1, `\u274C --project needs a path, and the line gave it none
 Usage: ${BACKFILL_USAGE}`);
   }
-  return resolve14(cwd(), value);
+  return resolve15(cwd(), value);
 }
 function isDirectory3(path) {
   try {
-    return statSync10(path).isDirectory();
+    return statSync11(path).isDirectory();
   } catch {
     return false;
   }
@@ -21525,7 +22151,7 @@ function actionLines(actions) {
 function checkOptions(context, projectRoot2) {
   return { projectRoot: projectRoot2, pathDirs: pathDirectories(context.env["PATH"]) };
 }
-function report3(context, result2, lines) {
+function report4(context, result2, lines) {
   if (context.outputMode === "json") {
     context.output.result(result2);
     return;
@@ -21546,7 +22172,7 @@ function runPlan(context, scope, backfillDir, projectRoot2) {
     counts: plan2.counts,
     candidates
   };
-  report3(context, result2, [
+  report4(context, result2, [
     `${scope.scope} scope: ${scope.dir}`,
     ...actionLines(actions),
     derivationLine(plan2),
@@ -21580,7 +22206,7 @@ async function runPropose(context, scope, backfillDir, seams) {
     candidates: pass.candidates,
     files
   };
-  report3(context, result2, [
+  report4(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`),
@@ -21600,7 +22226,7 @@ function reviewedProposals(dir) {
   return read2.flatMap((entry) => entry.result.file === null ? [] : [entry.result.file]);
 }
 function rowPaths(files, root) {
-  return files.flatMap((file) => file.status !== REVIEWED_FILE ? [] : file.rows.filter((row2) => row2.status === ANSWERED_ROW).map((row2) => join39(root, ...row2.path.split("/"))));
+  return files.flatMap((file) => file.status !== REVIEWED_FILE ? [] : file.rows.filter((row2) => row2.status === ANSWERED_ROW).map((row2) => join41(root, ...row2.path.split("/"))));
 }
 function runApply(context, scope, backfillDir, projectRoot2) {
   const options = checkOptions(context, projectRoot2);
@@ -21635,18 +22261,18 @@ function runApply(context, scope, backfillDir, projectRoot2) {
     derivationLine(derived),
     `${String(copied)} file(s) copied under ${backupDir} before they were rewritten`
   ];
-  const refused2 = proposals.counts.refused + derived.counts.refused;
-  if (refused2 > 0)
-    throw new CommandExit(Math.min(refused2, REFUSED_CAP), lines.join(`
+  const refused3 = proposals.counts.refused + derived.counts.refused;
+  if (refused3 > 0)
+    throw new CommandExit(Math.min(refused3, REFUSED_CAP), lines.join(`
 `));
-  report3(context, result2, lines);
+  report4(context, result2, lines);
 }
 async function runBackfill(context, seams) {
   const mode = readMode(context.flags);
   const dir = readBackfillDirectory(context.args, seams.cwd);
   const projectRoot2 = readConsumerRoot(context.flags["project"], seams.cwd);
   const scope = backfillScopeOf(dir, projectOf11(context).home);
-  const backfillDir = join39(scope.base, BACKFILL_PATH);
+  const backfillDir = join41(scope.base, BACKFILL_PATH);
   if (mode === "propose") {
     await runPropose(context, scope, backfillDir, seams);
     return;
@@ -21760,13 +22386,13 @@ function createSkillCheckCommand(seams = DEFAULT_CHECK_SEAMS) {
 var check_default3 = createSkillCheckCommand();
 
 // src/commands/skill/demote.ts
-import { existsSync as existsSync13, mkdirSync as mkdirSync11, readFileSync as readFileSync27, statSync as statSync12, writeFileSync as writeFileSync11 } from "fs";
-import { dirname as dirname12, resolve as resolve15 } from "path";
+import { existsSync as existsSync14, mkdirSync as mkdirSync12, readFileSync as readFileSync27, statSync as statSync13, writeFileSync as writeFileSync12 } from "fs";
+import { dirname as dirname12, resolve as resolve16 } from "path";
 
 // src/demote/apply.ts
-import { copyFileSync as copyFileSync5, existsSync as existsSync12, mkdirSync as mkdirSync10, mkdtempSync as mkdtempSync3, readdirSync as readdirSync5, readFileSync as readFileSync26, renameSync, rmSync as rmSync3, statSync as statSync11, unlinkSync, writeFileSync as writeFileSync10 } from "fs";
+import { copyFileSync as copyFileSync5, existsSync as existsSync13, mkdirSync as mkdirSync11, mkdtempSync as mkdtempSync3, readdirSync as readdirSync6, readFileSync as readFileSync26, renameSync, rmSync as rmSync3, statSync as statSync12, unlinkSync, writeFileSync as writeFileSync11 } from "fs";
 import { tmpdir as tmpdir3 } from "os";
-import { dirname as dirname11, join as join40 } from "path";
+import { dirname as dirname11, join as join42 } from "path";
 var DEMOTION_ACTION_KINDS = [
   "demoted",
   "kept",
@@ -21787,18 +22413,18 @@ function learnedSkillName(path) {
   return base.slice(0, -MARKDOWN_EXTENSION.length);
 }
 function sourcePath(scope, path) {
-  return join40(scope.dir, ...path.split("/"));
+  return join42(scope.dir, ...path.split("/"));
 }
 function demotedPath(scope, path) {
-  return join40(scope.demotedDir, ...path.split("/"));
+  return join42(scope.demotedDir, ...path.split("/"));
 }
 function promotedPath(scope, path) {
-  return join40(scope.dir, learnedSkillName(path), SKILL_FILE);
+  return join42(scope.dir, learnedSkillName(path), SKILL_FILE);
 }
 function takenInstinctIds(dir) {
   let names;
   try {
-    names = readdirSync5(dir);
+    names = readdirSync6(dir);
   } catch {
     return [];
   }
@@ -21806,7 +22432,7 @@ function takenInstinctIds(dir) {
 }
 function readText4(path) {
   try {
-    return statSync11(path).isFile() ? readFileSync26(path, "utf8") : null;
+    return statSync12(path).isFile() ? readFileSync26(path, "utf8") : null;
   } catch {
     return null;
   }
@@ -21834,7 +22460,7 @@ function planKept(scope, row2, file) {
     return inert3(row2.path, "procedure", "kept", "procedure-shaped: left where it is, for the backfill");
   }
   const to = promotedPath(scope, row2.path);
-  if (existsSync12(to) || existsSync12(dirname11(to))) {
+  if (existsSync13(to) || existsSync13(dirname11(to))) {
     return inert3(row2.path, "procedure", "refused", `kept as a skill, but ${to} is already there`);
   }
   return {
@@ -21848,10 +22474,10 @@ function planKept(scope, row2, file) {
   };
 }
 function checkCandidate(dir, id2, text, pathDirs) {
-  const path = join40(dir, `${id2}${MARKDOWN_EXTENSION}`);
-  writeFileSync10(path, text, "utf8");
-  const report4 = checkFile(path, "instinct", { projectRoot: null, pathDirs });
-  return failureLines2(report4.issues);
+  const path = join42(dir, `${id2}${MARKDOWN_EXTENSION}`);
+  writeFileSync11(path, text, "utf8");
+  const report5 = checkFile(path, "instinct", { projectRoot: null, pathDirs });
+  return failureLines2(report5.issues);
 }
 function planDemoted(scope, row2, file, context) {
   const conversion = convertToInstinct(file, {
@@ -21869,11 +22495,11 @@ function planDemoted(scope, row2, file, context) {
   if (failures.length > 0) {
     return inert3(row2.path, "observation", "refused", `the record ${id2} fails the checker \u2014 ${failures.join("; ")}`);
   }
-  const destination = join40(scope.instinctsDir, `${id2}${MARKDOWN_EXTENSION}`);
+  const destination = join42(scope.instinctsDir, `${id2}${MARKDOWN_EXTENSION}`);
   const kept = demotedPath(scope, row2.path);
-  if (existsSync12(destination))
+  if (existsSync13(destination))
     return inert3(row2.path, "observation", "refused", `${destination} is already there`);
-  if (existsSync12(kept))
+  if (existsSync13(kept))
     return inert3(row2.path, "observation", "refused", `${kept} is already there`);
   context.taken.push(id2);
   return {
@@ -21905,7 +22531,7 @@ function planRow(scope, row2, context) {
     entries: undefined,
     absolute,
     hash,
-    mtime: statSync11(absolute).mtime.toISOString()
+    mtime: statSync12(absolute).mtime.toISOString()
   };
   return verdict === "procedure" ? planKept(scope, row2, file) : planDemoted(scope, row2, file, context);
 }
@@ -21915,18 +22541,18 @@ function countActions(actions) {
     counts[action.kind] += 1;
   return counts;
 }
-function planDemotion(report4, scope, seams = DEFAULT_APPLY_SEAMS) {
-  const temp = mkdtempSync3(join40(tmpdir3(), "rafa-demote-"));
+function planDemotion(report5, scope, seams = DEFAULT_APPLY_SEAMS) {
+  const temp = mkdtempSync3(join42(tmpdir3(), "rafa-demote-"));
   const taken = [...takenInstinctIds(scope.instinctsDir)];
   try {
-    const actions = report4.rows.map((row2) => planRow(scope, row2, { temp, taken, seams }));
+    const actions = report5.rows.map((row2) => planRow(scope, row2, { temp, taken, seams }));
     return { scope, actions, counts: countActions(actions) };
   } finally {
     rmSync3(temp, { recursive: true, force: true });
   }
 }
 function moveFile(move3) {
-  mkdirSync10(dirname11(move3.to), { recursive: true });
+  mkdirSync11(dirname11(move3.to), { recursive: true });
   try {
     renameSync(move3.from, move3.to);
   } catch {
@@ -21937,8 +22563,8 @@ function moveFile(move3) {
 function applyDemotion(plan2) {
   for (const action of plan2.actions) {
     if (action.write !== null) {
-      mkdirSync10(dirname11(action.write.path), { recursive: true });
-      writeFileSync10(action.write.path, action.write.text, "utf8");
+      mkdirSync11(dirname11(action.write.path), { recursive: true });
+      writeFileSync11(action.write.path, action.write.text, "utf8");
     }
     if (action.move !== null)
       moveFile(action.move);
@@ -22003,11 +22629,11 @@ Usage: ${DEMOTE_USAGE}`);
     throw new CommandExit(1, `\u274C Expected one directory, and read "${extra}" as a second
 Usage: ${DEMOTE_USAGE}`);
   }
-  return resolve15(cwd(), dir);
+  return resolve16(cwd(), dir);
 }
 function isDirectory4(path) {
   try {
-    return statSync12(path).isDirectory();
+    return statSync13(path).isDirectory();
   } catch {
     return false;
   }
@@ -22029,13 +22655,13 @@ function projectOf12(context) {
     throw new Error("rafa skill demote runs inside a project, and was handed none");
   return context.project;
 }
-function verdictLine2(report4) {
-  const counts = countVerdicts(report4.rows);
+function verdictLine2(report5) {
+  const counts = countVerdicts(report5.rows);
   const parts = DEMOTION_VERDICTS.map((verdict) => `${String(counts[verdict])} ${verdict}`);
-  return `${String(report4.rows.length)} file(s): ${parts.join(", ")}`;
+  return `${String(report5.rows.length)} file(s): ${parts.join(", ")}`;
 }
 function previousReport(path, context) {
-  if (!existsSync13(path))
+  if (!existsSync14(path))
     return null;
   const parsed = parseDemotionReport(readFileSync27(path, "utf8"));
   if (parsed.report !== null)
@@ -22045,17 +22671,17 @@ function previousReport(path, context) {
 }
 function runWrite(context, scope) {
   const files = selectSources(scope);
-  const report4 = buildDemotionReport(files, previousReport(scope.reportPath, context));
-  mkdirSync11(dirname12(scope.reportPath), { recursive: true });
-  writeFileSync11(scope.reportPath, writeDemotionReport(report4), "utf8");
+  const report5 = buildDemotionReport(files, previousReport(scope.reportPath, context));
+  mkdirSync12(dirname12(scope.reportPath), { recursive: true });
+  writeFileSync12(scope.reportPath, writeDemotionReport(report5), "utf8");
   const result2 = {
     applied: false,
     scope: scope.scope,
     dir: scope.dir,
     reportPath: scope.reportPath,
-    status: report4.status,
-    files: report4.rows.length,
-    counts: countVerdicts(report4.rows)
+    status: report5.status,
+    files: report5.rows.length,
+    counts: countVerdicts(report5.rows)
   };
   if (context.outputMode === "json") {
     context.output.result(result2);
@@ -22063,14 +22689,14 @@ function runWrite(context, scope) {
   }
   for (const line of [
     `${scope.scope} scope: ${scope.dir}`,
-    verdictLine2(report4),
-    `Report written to ${scope.reportPath} (status: ${report4.status}); nothing was moved`,
+    verdictLine2(report5),
+    `Report written to ${scope.reportPath} (status: ${report5.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 (!existsSync13(scope.reportPath)) {
+  if (!existsSync14(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(readFileSync27(scope.reportPath, "utf8"));
@@ -22100,8 +22726,8 @@ function renderApply(result2) {
   return [...rows, `${String(result2.actions.length)} row(s) of ${result2.reportPath}: ${parts.join(", ")}`];
 }
 function runApply2(context, scope) {
-  const report4 = reviewedReport(scope);
-  const plan2 = planDemotion(report4, scope, {
+  const report5 = reviewedReport(scope);
+  const plan2 = planDemotion(report5, scope, {
     now: () => new Date().toISOString(),
     pathDirs: pathDirectories(context.env["PATH"])
   });
@@ -22446,12 +23072,12 @@ function statusData(sections) {
 }
 
 // src/status/sections.ts
-import { existsSync as existsSync14 } from "fs";
+import { existsSync as existsSync15 } from "fs";
 
 // src/status/blocked-count.ts
 async function labelsCount(options) {
-  const report4 = await options.blockedIssues(options.gh);
-  return report4.problem === null ? { count: report4.readings.length, notes: [] } : { count: null, notes: [`the issues labelled ${SPEC_BLOCKED_LABEL} could not be read: ${report4.problem}`] };
+  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}`] };
 }
 async function nativeCount(relations, listing2) {
   try {
@@ -22614,9 +23240,9 @@ function boundedRunner(open, root, deadline) {
 }
 async function networkSection(what, deadline, work) {
   let timer;
-  const expired = new Promise((resolve16) => {
+  const expired = new Promise((resolve17) => {
     timer = setTimeout(() => {
-      resolve16(unread2(`the ${what} was not read within the ${String(deadline.ms)}ms network deadline`));
+      resolve17(unread2(`the ${what} was not read within the ${String(deadline.ms)}ms network deadline`));
     }, Math.max(0, deadline.left()));
   });
   try {
@@ -22706,7 +23332,7 @@ function nextOfPlace(current, epic, walk) {
   return epic?.members.some((member) => member.number === line.issue) === true ? line.issue : null;
 }
 function hasBoards(root, listing2) {
-  if (existsSync14(positionFilePath(root)))
+  if (existsSync15(positionFilePath(root)))
     return true;
   return listing2.some((issue2) => issue2.state === "OPEN" && issue2.labels.includes(ROADMAP_LABEL));
 }
@@ -22907,8 +23533,8 @@ function createUpdateStub(spec) {
 var board_default = createUpdateStub({ action: "board", summary: "apply the board's newest setup and its migrations", issue: 717 });
 
 // src/project/lock.ts
-import { existsSync as existsSync15, lstatSync as lstatSync2, readFileSync as readFileSync28, writeFileSync as writeFileSync12 } from "fs";
-import { join as join41 } from "path";
+import { existsSync as existsSync16, lstatSync as lstatSync2, readFileSync as readFileSync28, writeFileSync as writeFileSync13 } from "fs";
+import { join as join43 } from "path";
 var LOCK_FILE = "rafa.lock";
 var LOCKFILE_VERSION = 1;
 
@@ -22916,7 +23542,7 @@ class ProjectLockError extends Error {
   name = "ProjectLockError";
 }
 function lockPath(root) {
-  return join41(root, LOCK_FILE);
+  return join43(root, LOCK_FILE);
 }
 function projectLockText(version2) {
   const lock = { lockfileVersion: LOCKFILE_VERSION, rafa: version2 };
@@ -22949,7 +23575,7 @@ function lockOf(value) {
 }
 function readProjectLock(root) {
   const path = lockPath(root);
-  if (!existsSync15(path)) {
+  if (!existsSync16(path)) {
     if (isLink(path))
       refuse8("is a link to nothing");
     return null;
@@ -22969,15 +23595,15 @@ function readProjectLock(root) {
   return lockOf(value);
 }
 function writeProjectLock(root, version2) {
-  writeFileSync12(lockPath(root), projectLockText(version2), "utf8");
+  writeFileSync13(lockPath(root), projectLockText(version2), "utf8");
 }
 
 // src/project/update-current.ts
-import { existsSync as existsSync16 } from "fs";
-import { join as join42 } from "path";
+import { existsSync as existsSync17 } from "fs";
+import { join as join44 } from "path";
 var DEPRECATIONS = Object.freeze([]);
 function missingFolders(root) {
-  return PROJECT_TREE.map((name) => join42(SCOPE_DIR, name)).filter((relative11) => !existsSync16(join42(root, relative11)));
+  return PROJECT_TREE.map((name) => join44(SCOPE_DIR, name)).filter((relative11) => !existsSync17(join44(root, relative11)));
 }
 async function readBoard3(access) {
   if (access.gh === null)
@@ -22992,10 +23618,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;
@@ -23030,7 +23656,7 @@ class UpdateStepError extends Error {
   }
 }
 function foldersNowThere(plan2) {
-  return plan2.folders.filter((relative11) => existsSync16(join42(plan2.root, relative11)));
+  return plan2.folders.filter((relative11) => existsSync17(join44(plan2.root, relative11)));
 }
 function writeFolders(plan2) {
   if (plan2.folders.length === 0)
@@ -23058,27 +23684,29 @@ async function applyUpdatePlan(plan2, gh) {
 }
 
 // src/project/update-range.ts
-function refused2(reason, message) {
+function refused3(reason, message) {
   return { kind: "refused", reason, message };
 }
 function readCurrentRange(recorded, installed) {
   const to = parseSemanticVersion(installed);
   if (to === null)
-    return refused2("unreadable", `the installed rafa answers "${installed}", which is no version`);
+    return refused3("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 refused2("unreadable", `the project records rafa "${recorded}", which is no version`);
+    return refused3("unreadable", `the project records rafa "${recorded}", which is no version`);
   const order = compareVersions(to, from);
   if (order < 0) {
-    return refused2("older", `the installed rafa ${installed} is older than the project's ${recorded}, and no downgrade runs before 1.0.0`);
+    return refused3("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 refused2("newer-major", `the installed rafa ${installed} is a newer major than the project's ${recorded}; that move is rafa update latest`);
+    return refused3("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 refused2("newer-minor", `the installed rafa ${installed} is a newer minor than the project's ${recorded}; that move is rafa update next`);
+    return refused3("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 };
 }
@@ -23102,7 +23730,7 @@ var DEFAULT_UPDATE_CURRENT_SEAMS = Object.freeze({
   openPrompter: () => createLinePrompter(process.stdin, process.stderr),
   lockRootOf: (root) => checkoutLockRoot(root, process.cwd())
 });
-function readSwitch4(context, name) {
+function readSwitch5(context, name) {
   const value = context.flags[name];
   if (value === undefined || value === false || value === "false")
     return false;
@@ -23232,10 +23860,10 @@ async function applyAndReport(plan2, gh, context) {
   return applied;
 }
 function refusedLabels(applied) {
-  const refused3 = applied.labels.filter((part) => part.outcome === "refused");
-  if (refused3.length === 0)
+  const refused4 = applied.labels.filter((part) => part.outcome === "refused");
+  if (refused4.length === 0)
     return null;
-  return new CommandExit(1, `${String(refused3.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(refused4.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))
@@ -23246,8 +23874,8 @@ function stopLine2(plan2, dryRun) {
 }
 async function runUpdateCurrent(context, seams) {
   expectNoArgument(context.args, USAGE43);
-  const dryRun = readSwitch4(context, "dry-run");
-  const yes = readSwitch4(context, "yes");
+  const dryRun = readSwitch5(context, "dry-run");
+  const yes = readSwitch5(context, "yes");
   const project = projectOf15(context);
   const lockRoot = seams.lockRootOf(project.root);
   const range = readRange(lockRoot, seams.installed);
@@ -23283,8 +23911,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" },
@@ -23323,7 +23951,7 @@ var self_default = createUpdateStub({ action: "self", summary: "update rafa itse
 var 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" },
@@ -23358,6 +23986,7 @@ var CORE_COMMANDS = Object.freeze([
   ready_default,
   unblock_default,
   check_default2,
+  edit_default,
   current_default,
   show_default6,
   view_default,