@open-tomato/rafa 0.33.0 → 0.34.1

package/dist/{index-13caphhp.js → index-nr4hdb35.js}

@@ -321,6 +321,7 @@ import {
   sessionLine,
   sessionLogDir,
   setUpBoard,
+  setUpLabels,
   severalRoadmapsMessage,
   shellQuote,
   show_default,
@@ -356,7 +357,7 @@ import {
   worktreeAt,
   writeSession,
   writeShippedFile
-} from "./index-w3vyb08t.js";
+} from "./index-s8ff86xt.js";
 import {
   PROBE_TIMEOUT_MS,
   loadPlanPrerequisites,
@@ -368,7 +369,7 @@ import {
   runPreflight,
   splitBlockerComment,
   trackerPathFor
-} from "./index-zn08ywsv.js";
+} from "./index-v8d7c6sw.js";
 import {
   ACTION_HEADING,
   CAUSE_HEADING,
@@ -388,6 +389,7 @@ import {
   MOVE_TO_SQLITE,
   MergeRefusal,
   POSITION_FILE,
+  RAFA_VERSION,
   RebuildRefusal,
   SCOPE_DIR,
   SKILL_FILE,
@@ -421,6 +423,7 @@ import {
   isFile,
   issueLine,
   loadConfig,
+  mainCheckoutOf,
   mergeFrontmatter,
   mergeStore,
   migrateStore,
@@ -461,7 +464,7 @@ import {
   versionLine,
   writeFrontmatter,
   writePositionFile
-} from "./index-kz7e4gtt.js";
+} from "./index-bebv92ha.js";
 import {
   CONFIG_DEFAULTS,
   CONFIG_FILE,
@@ -476,7 +479,7 @@ import {
   readItemBytes,
   readRafaBlocks,
   resolveTiers
-} from "./index-dv0ycmp8.js";
+} from "./index-vp0xghk2.js";
 import {
   promotable
 } from "./index-d6d0942q.js";
@@ -10584,6 +10587,9 @@ function bugLine(criterion, bug) {
     case "commented": {
       return { text: `${which}: recurs in ${bug.ref === null ? "an issue" : issueName2(bug.ref)} on the ${bug.channel} tracker; commented on it.`, warn: false };
     }
+    case "inherited": {
+      return { text: `${which}: not filed: a test failure the run started with.`, warn: false };
+    }
     case "skipped": {
       return { text: `${which}: not filed: ${bug.problem ?? "no reason given"}.`, warn: true };
     }
@@ -10621,7 +10627,8 @@ async function fileFailures(run, epic, failures, commit) {
         tracker,
         privateTracker: run.seams.privateTracker,
         secrets,
-        seams: run.seams.findings
+        seams: run.seams.findings,
+        similarity: run.config
       });
       for (const bug of result2.bugs) {
         const line = bugLine(criterion, bug);
@@ -11682,6 +11689,10 @@ var CONFIG_SETTINGS_LINES = Object.freeze([
   "# claims:",
   `#   staleAfter: ${CONFIG_DEFAULTS.claimsStaleAfter}                # 36h | 3d | disabled; how long a rafa:claimed claim stands before a takeover`,
   `#   ahead: ${CONFIG_DEFAULTS.claimsAhead}                     # off | allow; whether a claim may reach one issue ahead`,
+  "# triage:",
+  "#   similarity:",
+  `#     threshold: ${String(CONFIG_DEFAULTS.triageSimilarityThreshold)}             # above 0 and at most 1 | false; the least score at which triage comments on the nearest open bug`,
+  `#     candidates: ${String(CONFIG_DEFAULTS.triageSimilarityCandidates)}              # 1..10, the nearest issues a new bug lists as Possible duplicates`,
   "# release:",
   `#   enabled: ${String(CONFIG_DEFAULTS.releaseEnabled)}               # true | false | auto, which is on when both files below exist`,
   `#   versionFile: ${CONFIG_DEFAULTS.releaseVersionFile}`,
@@ -15209,8 +15220,16 @@ async function guardBeforeMerge(step) {
 var NO_WORKFLOW_WARNING = "nothing on GitHub has tested this branch; you are relying on the checks run locally";
 var WORKFLOWS_EXIST_WARNING = "CI may not have started (a path filter, a draft, Actions disabled, or it has not registered yet); this is probably not what you want";
 var UNCHECKED_MERGE_SENTENCE = "Merged with no checks reported, by rafa pr merge --skip-checks.";
-function uncheckedCaseOf(workflowCount) {
-  return workflowCount === 0 ? "no-workflow" : "workflows-exist";
+function uncheckedCaseOf(workflowCount, baseWorkflows = null) {
+  if (workflowCount === 0)
+    return "no-workflow";
+  if (workflowCount !== null && baseWorkflows !== null && !baseWorkflows.runsOnPullRequests) {
+    return "no-pull-request-workflow";
+  }
+  return "workflows-exist";
+}
+function noPullRequestWorkflowLine(base) {
+  return `no workflow runs on pull requests into ${base}`;
 }
 function workflowCountLine(workflowCount) {
   if (workflowCount === null)
@@ -15224,26 +15243,181 @@ function skipChecksCommand(number) {
 function uncheckedQuestion(number) {
   return `Merge #${number} with no checks? [y/N]`;
 }
-function uncheckedComment(workflowCount) {
-  return `${UNCHECKED_MERGE_SENTENCE}
+function uncheckedComment(workflowCount, baseLine = null) {
+  const countLine2 = workflowCountLine(workflowCount);
+  const paragraphs = baseLine === null ? [UNCHECKED_MERGE_SENTENCE, countLine2] : [UNCHECKED_MERGE_SENTENCE, countLine2, baseLine];
+  return paragraphs.join(`
 
-${workflowCountLine(workflowCount)}`;
+`);
 }
-function readUnchecked(number, workflowCount) {
-  const which = uncheckedCaseOf(workflowCount);
-  const warning = which === "no-workflow" ? NO_WORKFLOW_WARNING : WORKFLOWS_EXIST_WARNING;
+function warningOf(which, baseWorkflows) {
+  if (which === "no-workflow")
+    return NO_WORKFLOW_WARNING;
+  if (which === "no-pull-request-workflow" && baseWorkflows !== null)
+    return noPullRequestWorkflowLine(baseWorkflows.base);
+  return WORKFLOWS_EXIST_WARNING;
+}
+function readUnchecked(number, workflowCount, baseWorkflows = null) {
+  const which = uncheckedCaseOf(workflowCount, baseWorkflows);
+  const warning = warningOf(which, baseWorkflows);
+  const isBaseCase = which === "no-pull-request-workflow";
   return Object.freeze({
     case: which,
     warning: Object.freeze([workflowCountLine(workflowCount), warning]),
-    yesMayAnswer: which === "no-workflow",
+    yesMayAnswer: which !== "workflows-exist",
     question: uncheckedQuestion(number),
-    comment: uncheckedComment(workflowCount)
+    comment: uncheckedComment(workflowCount, isBaseCase ? warning : null)
   });
 }
 
+// src/pr/workflow-triggers.ts
+var PULL_REQUEST_EVENT = "pull_request";
+var UNKNOWN = "unknown";
+var BRACKET_BODY = /^[A-Za-z0-9-]+$/;
+var REGEX_SPECIAL = /[.*+?^${}()|[\]\\/]/g;
+function workflowsRunOnPullRequestsInto(workflowTexts, base) {
+  return workflowTexts.some((text) => workflowNamesBase(text, base));
+}
+function workflowNamesBase(workflowText, base) {
+  let document;
+  try {
+    document = Bun.YAML.parse(workflowText);
+  } catch {
+    return true;
+  }
+  return readWorkflow(document, base) !== false;
+}
+function readWorkflow(document, base) {
+  if (!isPlainObject(document) || !("on" in document))
+    return UNKNOWN;
+  const on = document.on;
+  if (typeof on === "string")
+    return on === PULL_REQUEST_EVENT;
+  if (Array.isArray(on)) {
+    if (!on.every((event) => typeof event === "string"))
+      return UNKNOWN;
+    return on.includes(PULL_REQUEST_EVENT);
+  }
+  if (!isPlainObject(on))
+    return UNKNOWN;
+  if (!(PULL_REQUEST_EVENT in on))
+    return false;
+  return readPullRequestTrigger(on[PULL_REQUEST_EVENT], base);
+}
+function readPullRequestTrigger(trigger, base) {
+  if (trigger === null || trigger === undefined)
+    return true;
+  if (!isPlainObject(trigger))
+    return UNKNOWN;
+  const branches = trigger.branches;
+  const ignored = trigger["branches-ignore"];
+  if (branches !== undefined && ignored !== undefined)
+    return UNKNOWN;
+  if (branches !== undefined)
+    return readBranches(branches, base);
+  if (ignored !== undefined)
+    return readBranchesIgnore(ignored, base);
+  return true;
+}
+function readBranches(filter, base) {
+  const patterns = patternListOf(filter);
+  if (patterns === null)
+    return UNKNOWN;
+  let named2 = false;
+  for (const pattern of patterns) {
+    const negated = pattern.startsWith("!");
+    const matches = branchPatternMatches(negated ? pattern.slice(1) : pattern, base);
+    if (matches === null)
+      return UNKNOWN;
+    if (matches)
+      named2 = !negated;
+  }
+  return named2;
+}
+function readBranchesIgnore(filter, base) {
+  const patterns = patternListOf(filter);
+  if (patterns === null || patterns.some((pattern) => pattern.startsWith("!")))
+    return UNKNOWN;
+  let anyMatch = false;
+  for (const pattern of patterns) {
+    const matches = branchPatternMatches(pattern, base);
+    if (matches === null)
+      return UNKNOWN;
+    anyMatch = anyMatch || matches;
+  }
+  return !anyMatch;
+}
+function patternListOf(filter) {
+  if (typeof filter === "string")
+    return [filter];
+  if (Array.isArray(filter) && filter.every((pattern) => typeof pattern === "string"))
+    return filter;
+  return null;
+}
+function branchPatternMatches(pattern, branch) {
+  const source = regexSourceOf(pattern);
+  if (source === null)
+    return null;
+  try {
+    return new RegExp(`^${source}$`).test(branch);
+  } catch {
+    return null;
+  }
+}
+function regexSourceOf(pattern) {
+  let source = "";
+  let quantifiable = false;
+  let index = 0;
+  while (index < pattern.length) {
+    const char = pattern.charAt(index);
+    if (char === "*") {
+      const isDouble = pattern.charAt(index + 1) === "*";
+      source += isDouble ? ".*" : "[^/]*";
+      index += isDouble ? 2 : 1;
+      quantifiable = false;
+    } else if (char === "?" || char === "+") {
+      if (!quantifiable)
+        return null;
+      source += char;
+      index += 1;
+      quantifiable = false;
+    } else if (char === "[") {
+      const close = pattern.indexOf("]", index + 1);
+      if (close === -1)
+        return null;
+      const body = pattern.slice(index + 1, close);
+      if (!BRACKET_BODY.test(body))
+        return null;
+      source += `[${body}]`;
+      index = close + 1;
+      quantifiable = true;
+    } else if (char === "\\") {
+      if (index + 1 >= pattern.length)
+        return null;
+      source += escapeRegex(pattern.charAt(index + 1));
+      index += 2;
+      quantifiable = true;
+    } else {
+      source += escapeRegex(char);
+      index += 1;
+      quantifiable = true;
+    }
+  }
+  return source;
+}
+function escapeRegex(char) {
+  return char.replace(REGEX_SPECIAL, "\\$&");
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
 // src/commands/pr/merge-unchecked.ts
 var INDENT4 = "   ";
 var YES_ANSWERS3 = ["y", "yes"];
+var WORKFLOWS_DIR = ".github/workflows/";
+var WORKFLOW_ENDINGS = [".yml", ".yaml"];
+var LS_TREE_ENTRY = /^\d+ (\w+) ([0-9a-f]+)\t(.+)$/s;
 function refusal10(head, reading, summary, tail) {
   return new CommandExit(1, [
     `\u274C ${head}`,
@@ -15260,10 +15434,37 @@ async function workflowCountOf(pulls) {
     return null;
   }
 }
+function workflowBlobsOf(listing) {
+  return listing.split("\x00").map((entry) => LS_TREE_ENTRY.exec(entry)).filter((match) => match !== null).filter(([, type, , path]) => type === "blob" && WORKFLOW_ENDINGS.some((ending) => path?.endsWith(ending) === true)).map(([, , oid]) => oid ?? "");
+}
+function readBaseWorkflows(git, base) {
+  if (base === "" || base.startsWith("-"))
+    return null;
+  if (!git(["fetch", "origin", base]).ok)
+    return null;
+  const listed2 = git(["ls-tree", "--full-tree", "-z", `origin/${base}`, WORKFLOWS_DIR]);
+  if (!listed2.ok)
+    return null;
+  const blobs = workflowBlobsOf(listed2.stdout);
+  if (blobs.length === 0)
+    return null;
+  const shown = blobs.map((oid) => git(["cat-file", "blob", oid]));
+  if (shown.some((result2) => !result2.ok))
+    return null;
+  const texts = shown.map((result2) => result2.stdout);
+  return Object.freeze({ base, runsOnPullRequests: workflowsRunOnPullRequestsInto(texts, base) });
+}
+function baseWorkflowsOf(options, workflowCount) {
+  const { git, base } = options;
+  if (workflowCount === null || workflowCount === 0 || git === undefined || base === undefined)
+    return null;
+  return readBaseWorkflows(git, base);
+}
 async function readUncheckedMerge(options) {
   const { pulls, number, yes, summary } = options;
   const workflowCount = await workflowCountOf(pulls);
-  const reading = readUnchecked(number, workflowCount);
+  const baseWorkflows = baseWorkflowsOf(options, workflowCount);
+  const reading = readUnchecked(number, workflowCount, baseWorkflows);
   if (yes && !reading.yesMayAnswer) {
     throw refusal10(`rafa pr merge refuses --yes for #${number} with no checks: workflows exist, or their count could not be read.`, reading, summary, "That is more likely a fault than a choice, so a person has to answer. Run it again without --yes on a terminal.");
   }
@@ -15272,7 +15473,7 @@ async function readUncheckedMerge(options) {
     const tail = reading.yesMayAnswer ? "Merge it without the question with --yes." : "--yes is refused here, so run it on a terminal and answer it.";
     throw refusal10(`rafa pr merge asks before merging #${number} with no checks, and standard input is no terminal.`, reading, summary, tail);
   }
-  return Object.freeze({ workflowCount, reading, yes });
+  return Object.freeze({ workflowCount, baseWorkflows, reading, yes });
 }
 function isYes(answer2) {
   return answer2 !== null && YES_ANSWERS3.includes(answer2.trim().toLowerCase());
@@ -15454,8 +15655,8 @@ async function reportAfterCleanUp(context, pr, seams, detail) {
   return { unblocked: null, freed };
 }
 async function askToMerge(context, pr, seams, ask) {
-  const { number, summary, yes, skipChecks } = ask;
-  const unchecked = skipChecks ? await readUncheckedMerge({ pulls: pr.pulls, number, yes, summary, isTerminal: seams.isTerminal }) : null;
+  const { number, summary, yes, skipChecks, base, git } = ask;
+  const unchecked = skipChecks ? await readUncheckedMerge({ pulls: pr.pulls, number, yes, summary, isTerminal: seams.isTerminal, base, git }) : null;
   if (unchecked === null && !yes)
     requireTerminal(seams, summary);
   context.output.info(summary);
@@ -15520,7 +15721,7 @@ async function runMerge2(context, seams) {
     openPrompter: prompterOf(seams)
   });
   const summary = summaryLine2(detail, method);
-  const answer2 = guard.go ? await askToMerge(context, pr, seams, { number: detail.number, summary, yes, skipChecks }) : { go: false, unchecked: null };
+  const answer2 = guard.go ? await askToMerge(context, pr, seams, { number: detail.number, summary, yes, skipChecks, base: detail.baseRefName, git }) : { go: false, unchecked: null };
   const answered3 = {
     number: detail.number,
     source: pick.source,
@@ -15584,7 +15785,7 @@ function createPrMergeCommand(seams = DEFAULT_MERGE_SEAMS) {
     subject: "pr",
     action: "merge",
     summary: "merge a pull request and clean up both branches",
-    description: "Merges one pull request through the GitHub CLI and then, in code, switches to the base branch," + " pulls it fast-forward only, deletes the head branch locally and on the remote where it is still there," + " and prunes, reporting each step; a head branch this checkout has no local branch for is reported as a" + " skipped local delete, and the rest still run. Refuses before it asks anything on a dirty working tree, on a pull" + " request that is not green or does not merge, and on a head branch checked out in another worktree. It" + " shows the pull request, its branches and the method and asks `Merge? [y/N]`; `--yes` skips the question," + " and without a terminal and without `--yes` it refuses. A pull request that reports no checks at all is" + " refused unless `--skip-checks` is given, which is refused on any pull request that does report checks;" + " with it the command reads how many workflows the repository defines, prints a warning for that case, asks" + " `Merge #<n> with no checks? [y/N]` (which `--yes` answers only where the repository defines no workflow)," + " and after the merge posts one comment on the pull request saying so. Where the release runs, the release" + " guard reads the branch before the question: a `collision` is refused unless" + " `dangerous.acceptVersionCollision` is true, and `pr.versionCollision` sets whether a `missing` or" + " `stale` branch merges silently, with a warning, after its own question, or not at all. A step that fails never undoes the merge: it" + " prints what is left as commands to paste and exits 1. After the merge it ticks the `Closes #<n>` line of" + " every issue the pull request closes on every open board whose checklist lists it, or on the roadmap issue while no issue carries `type:roadmap`, warning rather than failing when that write" + ' does not land. It ends by reading every open issue whose "Blocked by:" line names an issue this pull' + " request closes, asking whether to remove `spec:blocked` from each one whose blockers have all closed;" + " `--yes` does not answer that question, and every failure of that reading is a warning. With" + " board.relationships set to native it ticks no epic checklist and, in place of that reading, prints the" + " open issues the merge freed, whose blockers GitHub clears by itself, asking nothing and writing nothing. With" + " `--output=json` the pull request, the method, the steps that ran, the follow-ups, the roadmap tick and" + " the unblock reading, or the freed issues in native mode, are the data of the terminal result event. Refuses with exit code 2 where" + " `pr.provider` is not `gh`.",
+    description: "Merges one pull request through the GitHub CLI and then, in code, switches to the base branch," + " pulls it fast-forward only, deletes the head branch locally and on the remote where it is still there," + " and prunes, reporting each step; a head branch this checkout has no local branch for is reported as a" + " skipped local delete, and the rest still run. Refuses before it asks anything on a dirty working tree, on a pull" + " request that is not green or does not merge, and on a head branch checked out in another worktree. It" + " shows the pull request, its branches and the method and asks `Merge? [y/N]`; `--yes` skips the question," + " and without a terminal and without `--yes` it refuses. A pull request that reports no checks at all is" + " refused unless `--skip-checks` is given, which is refused on any pull request that does report checks;" + " with it the command reads how many workflows the repository defines, prints a warning for that case, asks" + " `Merge #<n> with no checks? [y/N]` (which `--yes` answers only where the repository defines no workflow, or" + " where no workflow file on the base has a `pull_request` trigger naming it)," + " and after the merge posts one comment on the pull request saying so. Where the release runs, the release" + " guard reads the branch before the question: a `collision` is refused unless" + " `dangerous.acceptVersionCollision` is true, and `pr.versionCollision` sets whether a `missing` or" + " `stale` branch merges silently, with a warning, after its own question, or not at all. A step that fails never undoes the merge: it" + " prints what is left as commands to paste and exits 1. After the merge it ticks the `Closes #<n>` line of" + " every issue the pull request closes on every open board whose checklist lists it, or on the roadmap issue while no issue carries `type:roadmap`, warning rather than failing when that write" + ' does not land. It ends by reading every open issue whose "Blocked by:" line names an issue this pull' + " request closes, asking whether to remove `spec:blocked` from each one whose blockers have all closed;" + " `--yes` does not answer that question, and every failure of that reading is a warning. With" + " board.relationships set to native it ticks no epic checklist and, in place of that reading, prints the" + " open issues the merge freed, whose blockers GitHub clears by itself, asking nothing and writing nothing. With" + " `--output=json` the pull request, the method, the steps that ran, the follow-ups, the roadmap tick and" + " the unblock reading, or the freed issues in native mode, are the data of the terminal result event. Refuses with exit code 2 where" + " `pr.provider` is not `gh`.",
     args: [
       {
         name: "n",
@@ -15600,7 +15801,7 @@ function createPrMergeCommand(seams = DEFAULT_MERGE_SEAMS) {
       },
       {
         name: "skip-checks",
-        description: "Merge a pull request that reports no checks at all, after a warning and its own question." + " Refused where the pull request reports any check; `--yes` beside it is refused where the repository" + " defines a workflow or its workflow count could not be read.",
+        description: "Merge a pull request that reports no checks at all, after a warning and its own question." + " Refused where the pull request reports any check; `--yes` beside it is refused where the repository" + " defines a workflow that may run on pull requests into the base, or its workflow count could not be read.",
         type: "boolean"
       },
       {
@@ -21880,6 +22081,445 @@ function createStatusCommand(seams = DEFAULT_STATUS_SEAMS) {
 }
 var status_default3 = createStatusCommand();
 
+// src/commands/update/stub.ts
+var ISSUES_URL = "https://github.com/open-tomato/rafa/issues";
+function stubMessage(action, issue2) {
+  return `rafa update ${action} is a feature in development, tracked in ${ISSUES_URL}/${String(issue2)}.` + " Nothing was changed.";
+}
+function createUpdateStub(spec) {
+  const command = {
+    name: `update ${spec.action}`,
+    subject: "update",
+    action: spec.action,
+    summary: `${spec.summary} (in development, #${String(spec.issue)})`,
+    description: `${spec.summary}. In development: it refuses with exit code 1, naming #${String(spec.issue)},` + " and changes nothing.",
+    args: [],
+    flags: [],
+    examples: [{ cmd: `rafa update ${spec.action}`, note: `Refuses, naming #${String(spec.issue)}; changes nothing.` }],
+    outputs: ["text", "json"],
+    needsProject: false,
+    ...spec.hidden === true ? { hidden: true } : {},
+    run: () => Promise.reject(new CommandExit(1, stubMessage(spec.action, spec.issue)))
+  };
+  return Object.freeze(command);
+}
+
+// src/commands/update/board.ts
+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 join40 } from "path";
+var LOCK_FILE = "rafa.lock";
+var LOCKFILE_VERSION = 1;
+
+class ProjectLockError extends Error {
+  name = "ProjectLockError";
+}
+function lockPath(root) {
+  return join40(root, LOCK_FILE);
+}
+function projectLockText(version2) {
+  const lock = { lockfileVersion: LOCKFILE_VERSION, rafa: version2 };
+  return `${JSON.stringify(lock, null, 2)}
+`;
+}
+function isLink(path) {
+  try {
+    return lstatSync2(path).isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+function refuse8(problem2) {
+  throw new ProjectLockError(`${LOCK_FILE} ${problem2}`);
+}
+function lockOf(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    refuse8("holds no JSON object");
+  const record = value;
+  const format = record["lockfileVersion"];
+  if (format !== LOCKFILE_VERSION) {
+    refuse8(`is in lockfileVersion ${String(format)}, and this rafa reads ${String(LOCKFILE_VERSION)}: a newer rafa wrote it`);
+  }
+  const rafa = record["rafa"];
+  if (typeof rafa !== "string" || parseSemanticVersion(rafa) === null) {
+    refuse8(`names rafa ${JSON.stringify(rafa)}, which is no version`);
+  }
+  return { lockfileVersion: LOCKFILE_VERSION, rafa };
+}
+function readProjectLock(root) {
+  const path = lockPath(root);
+  if (!existsSync15(path)) {
+    if (isLink(path))
+      refuse8("is a link to nothing");
+    return null;
+  }
+  let text;
+  try {
+    text = readFileSync28(path, "utf8");
+  } catch (error) {
+    refuse8(`could not be read: ${messageOf(error)}`);
+  }
+  let value;
+  try {
+    value = JSON.parse(text);
+  } catch {
+    refuse8("is not JSON");
+  }
+  return lockOf(value);
+}
+function writeProjectLock(root, version2) {
+  writeFileSync12(lockPath(root), projectLockText(version2), "utf8");
+}
+
+// src/project/update-current.ts
+import { existsSync as existsSync16 } from "fs";
+import { join as join41 } from "path";
+var DEPRECATIONS = Object.freeze([]);
+function missingFolders(root) {
+  return PROJECT_TREE.map((name) => join41(SCOPE_DIR, name)).filter((relative9) => !existsSync16(join41(root, relative9)));
+}
+async function readBoard3(access) {
+  if (access.gh === null)
+    return { kind: "skipped", reason: access.reason };
+  try {
+    const held = await listBoardLabels(access.gh);
+    return { kind: "labels", missing: missingBoardLabels(held).map((label) => label.name) };
+  } catch (error) {
+    return { kind: "skipped", reason: messageOf(error) };
+  }
+}
+function lockChangeOf(range) {
+  if (range.kind === "adopt")
+    return "created";
+  return range.kind === "patch" ? "updated" : "unchanged";
+}
+function fromOf(range) {
+  if (range.kind === "patch")
+    return range.from;
+  if (range.kind === "same")
+    return range.to;
+  return null;
+}
+async function readUpdatePlan(roots, range, board) {
+  const { root, lockRoot } = roots;
+  return {
+    root,
+    lockRoot,
+    from: fromOf(range),
+    to: range.to,
+    folders: missingFolders(root),
+    board: await readBoard3(board),
+    deprecations: DEPRECATIONS,
+    lock: lockChangeOf(range)
+  };
+}
+function planChanges(plan2) {
+  const labels = plan2.board.kind === "labels" ? plan2.board.missing.length : 0;
+  return plan2.folders.length > 0 || labels > 0 || plan2.deprecations.length > 0 || plan2.lock !== "unchanged";
+}
+
+class UpdateStepError extends Error {
+  step;
+  written;
+  name = "UpdateStepError";
+  constructor(step, message, written) {
+    super(message);
+    this.step = step;
+    this.written = written;
+  }
+}
+function foldersNowThere(plan2) {
+  return plan2.folders.filter((relative9) => existsSync16(join41(plan2.root, relative9)));
+}
+function writeFolders(plan2) {
+  if (plan2.folders.length === 0)
+    return [];
+  try {
+    return writeProjectScope(plan2.root).filter((write) => write.change === "created").map((write) => write.path);
+  } catch (error) {
+    throw new UpdateStepError("folders", messageOf(error), foldersNowThere(plan2));
+  }
+}
+function createdLabels(parts) {
+  return parts.filter((part) => part.outcome === "created").map((part) => `label ${part.name}`);
+}
+async function applyUpdatePlan(plan2, gh) {
+  const folders = writeFolders(plan2);
+  const labels = gh !== null && plan2.board.kind === "labels" && plan2.board.missing.length > 0 ? await setUpLabels(gh) : [];
+  if (plan2.lock !== "unchanged") {
+    try {
+      writeProjectLock(plan2.lockRoot, plan2.to);
+    } catch (error) {
+      throw new UpdateStepError("lock", messageOf(error), [...folders, ...createdLabels(labels)]);
+    }
+  }
+  return { folders, labels, lock: plan2.lock };
+}
+
+// src/project/update-range.ts
+function refused2(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`);
+  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`);
+  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`);
+  }
+  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`);
+  }
+  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 order === 0 ? { kind: "same", to: installed } : { kind: "patch", from: recorded, to: installed };
+}
+
+// src/commands/update/current.ts
+var USAGE42 = "rafa update current [--dry-run] [--yes]";
+var APPLY_QUESTION = "Apply these changes? [y/N] ";
+var YES_ANSWERS5 = ["y", "yes"];
+function checkoutLockRoot(root, dir) {
+  const run = Bun.spawnSync(["git", "rev-parse", "--show-toplevel"], { cwd: dir, stdout: "pipe", stderr: "pipe" });
+  if (run.exitCode !== 0)
+    return root;
+  const top = run.stdout.toString().trim();
+  return top !== "" && mainCheckoutOf(top) === root ? top : root;
+}
+var DEFAULT_UPDATE_CURRENT_SEAMS = Object.freeze({
+  installed: RAFA_VERSION,
+  openGh: (root) => createGhRunner({ cwd: root }),
+  readRemote: gitRemoteUrl,
+  isTerminal: () => process.stdin.isTTY === true,
+  openPrompter: () => createLinePrompter(process.stdin, process.stderr),
+  lockRootOf: (root) => checkoutLockRoot(root, process.cwd())
+});
+function readSwitch4(context, name) {
+  const value = context.flags[name];
+  if (value === undefined || value === false || value === "false")
+    return false;
+  if (value === true || value === "true")
+    return true;
+  throw new CommandExit(1, `\u274C --${name} takes no value, and read "${String(value)}" as one
+Usage: ${USAGE42}`);
+}
+function couldNotRun(problem2) {
+  return new CommandExit(2, `FAIL \u2014 ${problem2}
+nothing was changed.`);
+}
+function projectOf15(context) {
+  if (context.project === null)
+    throw new Error("rafa update current runs inside a project, and was handed none");
+  return context.project;
+}
+function boardAccess(project, seams) {
+  let configured;
+  try {
+    configured = loadConfig({ root: project.root, home: project.home }, {}, () => {}).config.prProvider;
+  } catch (error) {
+    throw couldNotRun(`config: ${messageOf(error)}`);
+  }
+  const provider = resolvePrProvider({ configured, dir: project.root, readRemote: seams.readRemote }).provider;
+  return provider === "gh" ? { gh: seams.openGh(project.root), reason: "" } : { gh: null, reason: `pr.provider is ${provider}, so there is no GitHub board` };
+}
+function foldersText(plan2) {
+  if (plan2.folders.length === 0)
+    return "nothing missing";
+  return `create ${plan2.folders.join(", ")}`;
+}
+function boardText2(plan2) {
+  if (plan2.board.kind === "skipped")
+    return `skipped: ${plan2.board.reason}`;
+  if (plan2.board.missing.length === 0)
+    return "every label present";
+  return `create labels ${plan2.board.missing.join(", ")}`;
+}
+function deprecationsText(plan2) {
+  if (plan2.deprecations.length === 0)
+    return "none registered yet (#718)";
+  return `${String(plan2.deprecations.length)} to run`;
+}
+function lockText(plan2) {
+  const where = plan2.lockRoot === plan2.root ? "" : ` in ${plan2.lockRoot}`;
+  if (plan2.lock === "unchanged")
+    return `unchanged at ${plan2.to}${where}`;
+  if (plan2.lock === "created")
+    return `create at ${plan2.to}${where}`;
+  return `update ${String(plan2.from)} \u2192 ${plan2.to}${where}`;
+}
+function planLines2(plan2) {
+  const from = plan2.from ?? `no ${LOCK_FILE}`;
+  return [
+    `rafa update current: ${plan2.root}, from ${from} to ${plan2.to}`,
+    `  folders       ${foldersText(plan2)}`,
+    `  board         ${boardText2(plan2)}`,
+    `  deprecations  ${deprecationsText(plan2)}`,
+    `  ${LOCK_FILE}     ${lockText(plan2)}`
+  ];
+}
+function appliedLines(applied, plan2, context) {
+  for (const path of applied.folders)
+    context.output.info(`created ${path}`);
+  for (const part of applied.labels) {
+    if (part.outcome === "created")
+      context.output.info(`created label ${part.name}`);
+    if (part.outcome === "refused")
+      context.output.warn(`label ${part.name} was not created: ${part.detail}`);
+  }
+  if (applied.lock !== "unchanged")
+    context.output.info(`wrote ${LOCK_FILE} at ${plan2.to}`);
+}
+async function confirmed2(yes, seams) {
+  if (yes)
+    return true;
+  if (!seams.isTerminal()) {
+    throw new CommandExit(1, "REFUSED \u2014 rafa update current asks before it changes anything, and there is no" + " terminal to ask on. Run it with --dry-run to see the changes, then with --yes to apply them." + `
+nothing was changed.`);
+  }
+  const prompter = seams.openPrompter();
+  try {
+    const answer2 = await prompter.ask(APPLY_QUESTION);
+    return answer2 !== null && YES_ANSWERS5.includes(answer2.trim().toLowerCase());
+  } finally {
+    prompter.close();
+  }
+}
+function readRange(root, installed) {
+  let recorded;
+  try {
+    recorded = readProjectLock(root)?.rafa ?? null;
+  } catch (error) {
+    throw couldNotRun(messageOf(error));
+  }
+  const range = readCurrentRange(recorded, installed);
+  if (range.kind === "refused")
+    throw new CommandExit(1, `REFUSED \u2014 ${range.message}
+nothing was changed.`);
+  return range;
+}
+function refuseConflicts(project) {
+  const conflicts2 = scaffoldConflicts(project.root, project.home);
+  if (conflicts2.length === 0)
+    return;
+  throw couldNotRun(`the project scope cannot be written:
+${conflicts2.map((conflict) => `  ${conflict}`).join(`
+`)}`);
+}
+function stoppedPartWay(error) {
+  const kept = error.written.length === 0 ? "Nothing was written before it." : `Already written, and kept: ${error.written.join(", ")}.`;
+  return new CommandExit(2, `FAIL \u2014 ${error.step}: ${error.message}
+stopped part-way. ${kept}` + `
+Fix the cause and run rafa update current again: each step writes only what is missing.`);
+}
+async function applyAndReport(plan2, gh, context) {
+  let applied;
+  try {
+    applied = await applyUpdatePlan(plan2, gh);
+  } catch (error) {
+    if (error instanceof UpdateStepError)
+      throw stoppedPartWay(error);
+    throw error;
+  }
+  appliedLines(applied, plan2, context);
+  return applied;
+}
+function refusedLabels(applied) {
+  const refused3 = applied.labels.filter((part) => part.outcome === "refused");
+  if (refused3.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.");
+}
+function stopLine2(plan2, dryRun) {
+  if (!planChanges(plan2))
+    return "Nothing to change.";
+  if (dryRun)
+    return "Dry run: nothing was written. Run rafa update current to apply it.";
+  return null;
+}
+async function runUpdateCurrent(context, seams) {
+  expectNoArgument(context.args, USAGE42);
+  const dryRun = readSwitch4(context, "dry-run");
+  const yes = readSwitch4(context, "yes");
+  const project = projectOf15(context);
+  const lockRoot = seams.lockRootOf(project.root);
+  const range = readRange(lockRoot, seams.installed);
+  refuseConflicts(project);
+  const access = boardAccess(project, seams);
+  const plan2 = await readUpdatePlan({ root: project.root, lockRoot }, range, access);
+  for (const line of planLines2(plan2))
+    context.output.info(line);
+  const finish = (applied2) => {
+    if (context.outputMode === "json")
+      context.output.result({ plan: plan2, applied: applied2 });
+  };
+  const stop = stopLine2(plan2, dryRun);
+  if (stop !== null) {
+    context.output.info(stop);
+    finish(null);
+    return;
+  }
+  context.output.warn("rafa cannot roll these changes back. Run it with --dry-run first to only see them.");
+  if (!await confirmed2(yes, seams)) {
+    context.output.info("Nothing was changed.");
+    finish(null);
+    return;
+  }
+  const applied = await applyAndReport(plan2, access.gh, context);
+  finish(applied);
+  const refusal13 = refusedLabels(applied);
+  if (refusal13 !== null)
+    throw refusal13;
+}
+function createUpdateCurrentCommand(seams = DEFAULT_UPDATE_CURRENT_SEAMS) {
+  const command = {
+    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.",
+    args: [],
+    flags: [
+      { name: "dry-run", description: "Print every change and write nothing.", type: "boolean" },
+      { name: "yes", description: "Apply the changes without asking.", type: "boolean" }
+    ],
+    examples: [
+      { cmd: "rafa update current --dry-run", note: "Lists the folders, labels and lock it would write, and writes nothing." },
+      { cmd: "rafa update current --yes", note: "Applies them without asking, as a script or a loop host runs it." }
+    ],
+    outputs: ["text", "json"],
+    run: async (context) => runUpdateCurrent(context, seams)
+  };
+  return Object.freeze(command);
+}
+var current_default2 = createUpdateCurrentCommand();
+
+// src/commands/update/latest.ts
+var latest_default = createUpdateStub({ action: "latest", summary: "move this project to the newest version", issue: 716 });
+
+// src/commands/update/next.ts
+var next_default2 = createUpdateStub({ action: "next", summary: "move this project to the newest minor of its major", issue: 716 });
+
+// src/commands/update/port.ts
+var port_default = createUpdateStub({ action: "port", summary: "move this project to a version, as update project does", issue: 716, hidden: true });
+
+// src/commands/update/project.ts
+var project_default = createUpdateStub({ action: "project", summary: "move this project to a version, with its migrations", issue: 716 });
+
+// src/commands/update/rafa.ts
+var rafa_default = createUpdateStub({ action: "rafa", summary: "move this project to a version, as update project does", issue: 716, hidden: true });
+
+// src/commands/update/self.ts
+var self_default = createUpdateStub({ action: "self", summary: "update rafa itself, from npm, a pinned version or another source", issue: 715 });
+
 // src/commands/usage.ts
 var usage_default = wrapPhaseZeroCommand({
   name: "usage",
@@ -21912,7 +22552,8 @@ var CORE_SUBJECTS = Object.freeze([
   { name: "release", summary: "read the release state of the project; settle the waiting fragments into a version; tag the commit that set it" },
   { name: "board", summary: "list the boards with their owner, epic count, and which is current and home" },
   { name: "epic", summary: "show one epic's issues as the Roadmap table; create an epic; defer or promote it; move an issue to it; close it through the gate or cancel it" },
-  { name: "claim", summary: "give up this device's claim on an issue; hand it to another store or withdraw the offer; accept a handover; take over a stale claim" }
+  { name: "claim", summary: "give up this device's claim on an issue; hand it to another store or withdraw the offer; accept a handover; take over a stale claim" },
+  { name: "update", summary: "bring this project to the installed rafa; the other updates are in development" }
 ]);
 var CORE_COMMANDS = Object.freeze([
   create_default2,
@@ -21984,6 +22625,14 @@ var CORE_COMMANDS = Object.freeze([
   hand_default,
   accept_default,
   take_default,
+  current_default2,
+  self_default,
+  project_default,
+  rafa_default,
+  port_default,
+  board_default,
+  next_default2,
+  latest_default,
   status_default3,
   next_default,
   roadmap_default,