@open-tomato/rafa 0.24.0 → 0.26.0

package/dist/{index-zzvc0gkb.js → index-2yd8bber.js}

@@ -12,17 +12,18 @@ import {
   DEFAULT_RELEASE_SEAMS,
   DEMOTION_VERDICTS,
   DESCRIPTION_LIMIT,
-  DISK_FILE_SYSTEM,
   EPIC_LABEL_PREFIX,
   EPIC_TYPE_LABEL,
   HINT_FLAG_SPEC,
   HORIZONS,
   HORIZON_LABEL_PREFIX,
+  ISSUE_LIST_FLAGS,
   LABEL_LIST_LIMIT,
   LEARNED_DIRECTORY,
   LISTING_LIMIT,
   MECHANICAL_CONFLICT_SENTENCE,
   NEXT_COMMAND_ACTIONS,
+  NO_NEXT_STEP,
   ORIGIN_FIELD,
   POSITION_FILE,
   PREVIOUS_COPY_WARN_ABOVE,
@@ -30,7 +31,6 @@ import {
   REASON_FLAG,
   REMOTE,
   ROADMAP_LABEL,
-  ROADMAP_REFUSAL_EXIT,
   ROADMAP_SETTING,
   ROADMAP_TITLE,
   RUNNING_MANIFEST_SEAMS,
@@ -38,7 +38,6 @@ import {
   RUNTIME_SUBDIR,
   RefVerifyError,
   RefsBlockError,
-  SCOPE_DIR,
   SERVE_CLI_VERSION,
   SESSION_ID_FLAG,
   SKILL_FILE as SKILL_FILE2,
@@ -47,7 +46,6 @@ import {
   SPEC_BLOCKED_LABEL,
   SPEC_EXTENSION,
   SPEC_TEMPLATE_PATH,
-  SessionRecordError,
   TEMPLATES_DIRNAME,
   TRIAGE_MODULE,
   VENDOR_COMMAND,
@@ -98,12 +96,12 @@ import {
   createLinePrompter,
   createPlanDirNames,
   createPlanRefsVerifier,
+  developmentApplied,
   endWithNextStep,
   endingWith,
   epicEndLines,
   epicProblemMessage,
   epicSlugsOf,
-  errorCode,
   estimateEta,
   etaLine,
   expectAtMostOneArgument,
@@ -119,6 +117,7 @@ import {
   formatCounts,
   formatDuration,
   formatRows,
+  gateMeaning,
   ghHostOf,
   ghMissingMessage,
   ghNextBoard,
@@ -128,7 +127,6 @@ import {
   gitSaid,
   groupByEpicLabel,
   hasDiverged,
-  hasEpicLines,
   hasPlanFor,
   hasSpecBlockedLabel,
   hop,
@@ -147,13 +145,13 @@ import {
   lineRefusal,
   listBoardLabels,
   list_default,
+  list_default1 as list_default2,
   loadConfig,
   localDay,
   memoiseVerifier,
   minutesBetween,
   missingBoardLabels,
   missingPlanAgents,
-  name,
   namedSecrets,
   nextQuestion,
   notesFileName,
@@ -200,12 +198,10 @@ import {
   readRecords,
   readRefsText,
   readRequiredFlag,
-  readRoadmapEpicRows,
   readRoadmapSetting,
-  readSession,
+  readSchemaReport,
   readSessionChecklist,
   readSessionFinishes,
-  readSessions,
   readSwitch,
   readTags,
   readTextFlag,
@@ -220,12 +216,10 @@ import {
   renderCloseComment,
   renderDependentComment,
   renderDoctorRefs,
-  renderEpicTable,
   renderHorizonComment,
   renderMoveComment,
   renderParkedPullRequestComment,
   renderRiskText,
-  renderRoadmapTable,
   renderUnblockNote,
   report,
   requireGhProvider,
@@ -244,13 +238,10 @@ import {
   resolveReleaseEnabled,
   resolveTracker,
   restampCopyRefs,
-  roadmapRefsCells,
   runAction,
-  runsDir,
+  runIssueList,
   samePlace,
   scanClaimBranches,
-  scopeAt,
-  selfAndAncestors,
   serveVerdict,
   sessionIdFlag,
   sessionLine,
@@ -269,6 +260,8 @@ import {
   triageReport,
   trustRefusalClause,
   unaskedReasonMessage,
+  unknownAdditive,
+  unknownAdditiveWarning,
   unlabelledRoadmapMessage,
   unresolvedTracker,
   urlLines,
@@ -276,18 +269,15 @@ import {
   validateManifest,
   validate_default,
   verdictOf,
-  version,
-  versionLine,
   waitForChecks,
   watchDryEpic,
   writePositionFile,
   writeSession,
   writeShippedFile
-} from "./index-gt9acb1y.js";
+} from "./index-59x3zsh4.js";
 import {
   PROBE_TIMEOUT_MS,
   findNextTask,
-  isStampableStub,
   loadPlanPrerequisites,
   malformedPrerequisiteLines,
   mergePlanPrerequisites,
@@ -297,42 +287,71 @@ import {
   runPreflight,
   splitBlockerComment,
   trackerPathFor
-} from "./index-21qkxk63.js";
+} from "./index-p1265xgj.js";
 import {
   ACTION_HEADING,
+  ADOPTION_NAME,
   CAUSE_HEADING,
   CLAUDE_BIN,
   CORE_ADAPTER_REGISTRY,
+  DISK_FILE_SYSTEM,
+  DevelopmentBuildRefusedError,
+  EFFORT_DIR_VARIABLE,
   EFFORT_STORE_DIR,
   ISSUE_PRIORITIES,
   ISSUE_STATES,
   ISSUE_TYPES,
   MARKDOWN_EXTENSION,
+  MIGRATION_LOG_TABLE,
+  SCOPE_DIR,
   SKILL_FILE,
   SQLITE_MIGRATIONS,
+  SQLITE_STORE_FILE_NAME,
+  SessionRecordError,
+  activeStoreSettings,
   allRecords,
+  appliedByName,
+  bringForward,
   claudeArgs,
   createGhRunner,
-  effortStorePath,
+  effortStoreDir,
+  effortStoreFileName,
+  errorCode,
   findRecords,
   gitRemoteUrl,
+  guardTestProcess,
   instinctProject,
+  isPidAlive,
   mergeFrontmatter,
-  migrateSchema,
+  name,
   normalizeRemote,
+  planSchema,
   readFrontmatter,
   readFrontmatterDocument,
+  readRuntimeIdentity,
   readScopes,
+  readSession,
+  readSessions,
+  readStoreSchema,
+  refuseUnownedDevelopmentWrite,
   renderFrontmatter,
   runClaudeCaptured,
+  runsDir,
   scanLayout,
+  scopeAt,
   selectEffortStore,
+  selfAndAncestors,
   sessionSpawnEnv,
   spawnClaudeCaptured,
+  sqliteCatalogue,
   sqliteStorePath,
+  storeProjectRoot,
   toHeldRecords,
-  writeFrontmatter
-} from "./index-7qgng1rf.js";
+  version,
+  versionLine,
+  writeFrontmatter,
+  writeNames
+} from "./index-azptzvp3.js";
 import {
   CONFIG_DEFAULTS,
   CONFIG_FILE,
@@ -341,12 +360,13 @@ import {
   activeOutput,
   configFilePath,
   findTierItem,
+  isStampableStub,
   parseConfigText,
   pinKey,
   readItemBytes,
   readRafaBlocks,
   resolveTiers
-} from "./index-twbp38kz.js";
+} from "./index-rv7y8y1j.js";
 import {
   promotable
 } from "./index-d6d0942q.js";
@@ -354,10 +374,10 @@ import {
   createCommandRegistry,
   describeRegistry,
   mountKey
-} from "./index-w1dnwja1.js";
+} from "./index-xwr54rzt.js";
 import {
   CommandExit
-} from "./index-4fwgqveh.js";
+} from "./index-4j1e3h26.js";
 import {
   MERGE_METHODS,
   RELEASE_AUTO,
@@ -369,7 +389,7 @@ import {
   isSkillTier,
   messageOf,
   parseBudgetUsd
-} from "./index-pmkgvtfe.js";
+} from "./index-sf2brh4w.js";
 import {
   triggerKey
 } from "./index-wp8c28fd.js";
@@ -1929,7 +1949,7 @@ function createSkillListCommand(seams = DEFAULT_SKILL_LIST_SEAMS) {
   };
   return Object.freeze(command);
 }
-var list_default2 = createSkillListCommand();
+var list_default3 = createSkillListCommand();
 
 // src/commands/agent/list.ts
 var DEFAULT_AGENT_LIST_SEAMS = Object.freeze({
@@ -2131,7 +2151,7 @@ function createAgentListCommand(seams = DEFAULT_AGENT_LIST_SEAMS) {
   };
   return Object.freeze(command);
 }
-var list_default3 = createAgentListCommand();
+var list_default4 = createAgentListCommand();
 
 // src/inventory/search/index.ts
 import { randomUUID } from "crypto";
@@ -3362,7 +3382,7 @@ function createBoardListCommand(seams = {}) {
   };
   return Object.freeze(command);
 }
-var list_default4 = createBoardListCommand();
+var list_default5 = createBoardListCommand();
 
 // src/cleanup/branches.ts
 var BRANCH_FORMAT = [
@@ -4634,7 +4654,7 @@ var describeCommand = {
 var describe_default = Object.freeze(describeCommand);
 
 // src/commands/doctor.ts
-import { basename as basename6, resolve as resolve5 } from "path";
+import { basename as basename5, resolve as resolve5 } from "path";
 
 // src/board/status.ts
 import { statSync as statSync4 } from "fs";
@@ -6676,14 +6696,77 @@ function renderDeep(reading) {
   return deepSections(reading).flatMap(renderDeepSection);
 }
 
+// src/commands/doctor-effort-schema.ts
+import { join as join15 } from "path";
+var EFFORT_SCHEMA_ROW = "effort store schema";
+var SCHEMA_COMMAND = "rafa effort schema";
+function developmentAppliedWarning(path, id2, appliedBy) {
+  return `\u26A0 effort store ${path} logs migration ${id2} applied by a development build (${appliedBy});` + ` a development build migrates only a copy. Read the log with ${SCHEMA_COMMAND}.`;
+}
+function unreadable(path, live, problem) {
+  return { outcome: "fail", path, live, status: "unreadable", problem, warnings: [], nextStep: NO_NEXT_STEP };
+}
+function readingOf(report2, live) {
+  const { path, status, nextStep } = report2;
+  if (report2.refused) {
+    const problem = `this rafa refuses ${path} (${status}): ${String(report2.refusal)}`;
+    return { outcome: "fail", path, live, status, problem, warnings: [], nextStep };
+  }
+  const developed = live ? developmentApplied(report2).map(({ id: id2, appliedBy }) => developmentAppliedWarning(path, id2, appliedBy)) : [];
+  const warnings = [...unknownAdditive(report2).map(unknownAdditiveWarning), ...developed];
+  const outcome = warnings.length === 0 ? "ok" : "warn";
+  return { outcome, path, live, status, problem: null, warnings, nextStep };
+}
+function readDoctorEffortSchema(root, env, options = {}) {
+  const override = env[EFFORT_DIR_VARIABLE];
+  const live = override === undefined || override === "";
+  let path;
+  try {
+    path = join15(effortStoreDir(root, env), SQLITE_STORE_FILE_NAME);
+  } catch (error) {
+    return unreadable(null, live, messageOf(error));
+  }
+  try {
+    return readingOf(readSchemaReport(path, options), live);
+  } catch (error) {
+    return unreadable(path, live, `${path} cannot be read as an effort store: ${messageOf(error)}`);
+  }
+}
+function wayOut(reading) {
+  return reading.nextStep === NO_NEXT_STEP ? "" : ` Next safe step: ${reading.nextStep}`;
+}
+function renderDoctorEffortSchema(reading) {
+  if (reading.outcome === "ok" && reading.status === "absent")
+    return [];
+  const where = reading.path === null ? "" : ` (${reading.path})`;
+  const row = `Effort store schema: ${reading.outcome}, ${reading.status}${where}`;
+  if (reading.problem === null)
+    return [row];
+  const next = reading.nextStep === NO_NEXT_STEP ? [] : [`  Next safe step: ${reading.nextStep}`];
+  return [row, `  ${reading.problem}`, ...next];
+}
+function writeDoctorEffortSchema(context, reading) {
+  if (context.outputMode !== "json") {
+    for (const line of renderDoctorEffortSchema(reading))
+      context.output.info(line);
+  }
+  for (const warning of reading.warnings)
+    context.output.warn(warning);
+}
+function effortSchemaRefusal(reading) {
+  if (reading.outcome !== "fail")
+    return null;
+  return `rafa doctor: ${EFFORT_SCHEMA_ROW}: ${String(reading.problem)}${wayOut(reading)}`;
+}
+
 // src/effort/store/legacy.ts
 import { statSync as statSync6 } from "fs";
-import { basename as basename4, join as join15 } from "path";
-var LEGACY_EFFORT_STORE_DIR = join15(".ralph", "effort");
+import { join as join16 } from "path";
+var LEGACY_EFFORT_STORE_DIR = join16(".ralph", "effort");
 var NDJSON_KINDS = { sessions: true, commits: true };
 var STORE_FILE_NAMES = Object.freeze([
-  basename4(sqliteStorePath("")),
-  ...Object.keys(NDJSON_KINDS).map((kind) => basename4(effortStorePath("", kind)))
+  SQLITE_STORE_FILE_NAME,
+  ...Object.keys(NDJSON_KINDS).map((kind) => effortStoreFileName(kind))
 ]);
 function isAbsence(error) {
   if (typeof error !== "object" || error === null || !("code" in error))
@@ -6700,7 +6783,7 @@ function isStoreFile(path) {
   }
 }
 function storeFilesIn(dir) {
-  return Object.freeze(STORE_FILE_NAMES.filter((name2) => isStoreFile(join15(dir, name2))));
+  return Object.freeze(STORE_FILE_NAMES.filter((name2) => isStoreFile(join16(dir, name2))));
 }
 function shellQuoted(path) {
   return `'${path.replaceAll("'", "'\\''")}'`;
@@ -6710,8 +6793,8 @@ function legacyWarning(legacyDir, storeDir, legacyFiles) {
   return `${legacyDir} holds an effort store (${legacyFiles.join(", ")}) and ${storeDir} holds none;` + ` rafa reads ${storeDir} alone, so its reports start from an empty store. Once no loop is running,` + ` move it: ${move3}`;
 }
 function readLegacyStore(root) {
-  const legacyDir = join15(root, LEGACY_EFFORT_STORE_DIR);
-  const storeDir = join15(root, EFFORT_STORE_DIR);
+  const legacyDir = join16(root, LEGACY_EFFORT_STORE_DIR);
+  const storeDir = join16(root, EFFORT_STORE_DIR);
   const legacyFiles = storeFilesIn(legacyDir);
   const storeFiles = storeFilesIn(storeDir);
   const warning = legacyFiles.length > 0 && storeFiles.length === 0 ? legacyWarning(legacyDir, storeDir, legacyFiles) : null;
@@ -6719,9 +6802,9 @@ function readLegacyStore(root) {
 }
 
 // src/project/bin-path.ts
-import { delimiter, isAbsolute as isAbsolute4, join as join16, resolve as resolve4 } from "path";
-var RAFA_BIN_DIR = join16(SCOPE_DIR, "bin");
-var BUN_BIN_DIR = join16(".bun", "bin");
+import { delimiter, isAbsolute as isAbsolute4, join as join17, resolve as resolve4 } from "path";
+var RAFA_BIN_DIR = join17(SCOPE_DIR, "bin");
+var BUN_BIN_DIR = join17(".bun", "bin");
 function exportLine(rafaBin) {
   return `export PATH="${rafaBin}:$PATH"`;
 }
@@ -6754,8 +6837,8 @@ function stateOf(rafaIndex, bunIndex) {
   return "ahead";
 }
 function readBinPath(pathValue, home, fs = DISK_FILE_SYSTEM) {
-  const rafaBin = join16(home, RAFA_BIN_DIR);
-  const bunBin = join16(home, BUN_BIN_DIR);
+  const rafaBin = join17(home, RAFA_BIN_DIR);
+  const bunBin = join17(home, BUN_BIN_DIR);
   const entries = (pathValue ?? "").split(delimiter);
   const rafaIndex = indexOf(entries, rafaBin, fs);
   const bunIndex = indexOf(entries, bunBin, fs);
@@ -6859,7 +6942,7 @@ function writeInstall(context, install) {
 
 // src/commands/doctor-tiers.ts
 import { readFileSync as readFileSync7, realpathSync as realpathSync4 } from "fs";
-import { basename as basename5, dirname as dirname2 } from "path";
+import { basename as basename4, dirname as dirname2 } from "path";
 var TIERS_SECTION_TITLE = "Skill tiers";
 var CLAUDE_VERSION_TIMEOUT_MS = 1e4;
 var VERSION_PATTERN = /^\s*(\d+\.\d+\.\d+)/;
@@ -6920,7 +7003,7 @@ function keptHolder(item) {
   return [item.winner, ...item.copies].find((holder) => holder.source === "rafa") ?? item.winner;
 }
 function deletion(holder) {
-  return holder.kind === "skill" && basename5(holder.path) === SKILL_FILE2 ? `delete ${dirname2(holder.path)} (only its ${SKILL_FILE2} was compared)` : `delete ${holder.path}`;
+  return holder.kind === "skill" && basename4(holder.path) === SKILL_FILE2 ? `delete ${dirname2(holder.path)} (only its ${SKILL_FILE2} was compared)` : `delete ${holder.path}`;
 }
 function copyRows(items, realPath = realPathOf) {
   return items.flatMap((item) => {
@@ -7064,7 +7147,7 @@ async function loadItems(plan2, config) {
 function refuseMalformedItems(plan2, items) {
   if (plan2 === null || items.malformed.length === 0)
     return;
-  const file = basename6(prerequisitesPathForPlan(plan2) ?? plan2);
+  const file = basename5(prerequisitesPathForPlan(plan2) ?? plan2);
   const [head = "", ...rest] = malformedPrerequisiteLines(file, items.malformed);
   throw refusal3([
     `rafa doctor: ${head}`,
@@ -7091,7 +7174,7 @@ function readStartTier(plan2, items) {
     return { tier: NO_START_TIER, items: NO_ITEMS };
   if (isFirstDispatch(plan2))
     return { tier: { checked: start2.length, skipped: 0, tracker: null }, items: start2 };
-  const tracker = basename6(trackerPathFor(plan2));
+  const tracker = basename5(trackerPathFor(plan2));
   return { tier: { checked: 0, skipped: start2.length, tracker }, items: NO_ITEMS };
 }
 async function checkPreflight(context, project, seams) {
@@ -7128,11 +7211,15 @@ async function checkPreflight(context, project, seams) {
     deep
   });
 }
-function haltRefusal(halt) {
-  return new CommandExit(1, [
+function doctorRefusal(halt, schema) {
+  if (halt === null) {
+    return schema === null ? null : new CommandExit(1, schema);
+  }
+  const lines2 = [
     `rafa doctor: ${halt}`,
     "rafa loop start would halt here, before any session. No run was started and nothing was stored."
-  ].join(`
+  ];
+  return new CommandExit(1, [...lines2, ...schema === null ? [] : [schema]].join(`
 `));
 }
 async function checkDeep(context, preflight, seams) {
@@ -7162,6 +7249,7 @@ function resultOf(preflight, install, readings, deep) {
     cleanup: readings.cleanup,
     refs: readings.refs,
     tiers: readings.tiers,
+    effortSchema: readings.effortSchema,
     deep
   };
 }
@@ -7195,16 +7283,20 @@ async function runDoctor(context, seams) {
     const cleanup = await readDoctorCleanup({ root: project.root, home: project.home, config: preflight.config, gh }, seams);
     const refs = await readDoctorRefs({ root: project.root, specsDir: preflight.config.specsDir, gh, env: context.env }, seams);
     const tiers = await checkDoctorTiers({ project, env: context.env, resolved: preflight.resolved, plan: null }, seams);
-    const readings = { ...await readDoctorBoard(gh, project.root, preflight.config.roadmapIssue), cleanup, refs, tiers };
+    const effortSchema = readDoctorEffortSchema(project.root, context.env);
+    const board = await readDoctorBoard(gh, project.root, preflight.config.roadmapIssue);
+    const readings = { ...board, cleanup, refs, tiers, effortSchema };
     writeText(context, renderDoctor(preflight));
     await announceRisk(context, preflight, seams);
     const repository = [...renderDoctorBoard(readings), ...renderDoctorCleanup(readings.cleanup)];
     writeText(context, [...repository, ...renderDoctorRefs(readings.refs)]);
     writeText(context, renderDoctorTiers(readings.tiers));
+    writeDoctorEffortSchema(context, effortSchema);
     const deep = await checkDeep(context, preflight, seams);
     writeText(context, deep === null ? [] : renderDeep(deep));
-    if (preflight.report.halt !== null)
-      throw haltRefusal(preflight.report.halt);
+    const refusal4 = doctorRefusal(preflight.report.halt, effortSchemaRefusal(effortSchema));
+    if (refusal4 !== null)
+      throw refusal4;
     if (context.outputMode === "json")
       context.output.result(resultOf(preflight, install, readings, deep));
   } finally {
@@ -7217,7 +7309,7 @@ function createDoctorCommand(seams = DEFAULT_DOCTOR_SEAMS) {
     subject: "doctor",
     action: "doctor",
     summary: "check the prerequisites rafa loop start checks, and the install, starting no run",
-    description: "Checks the prerequisites `rafa loop start` checks before its first session and prints each" + " check, starting no run and storing nothing: the required and optional items of" + " `.rafa/config.yaml`, with the `PREREQUISITES-<stub>.md` beside the plan merged in, and, when the" + " repository resolves to `pr.provider: gh`, the two required items that provider adds ahead of them:" + " `gh` on PATH and `gh auth status` for the remote's host. A plan's `[start]` items are checked" + " after those and ahead of the configured tiers, on a first dispatch alone: a" + " `PLAN_TRACKER-<stub>.md` beside the plan already holding a ticked task makes the next run a" + " resume, which checks none of them and says in one line how many it passed over." + " The plan is the" + " one `--plan=<file>` names, relative to the project root, or the default plan `rafa loop start`" + ` runs. Each probe runs in the project root with stdin closed and a ${String(PROBE_TIMEOUT_MS / 1000)}-second` + " timeout. It exits 1 when a required item fails, naming the item, its probe and its exit code or" + " first line of stderr, where `rafa loop start` would halt, and 0 otherwise. It warns when" + " `.ralph/effort/` holds an effort store and `.rafa/effort/` holds none, and when `~/.rafa/bin` is" + " not on PATH ahead of `~/.bun/bin`, and when `previous/` under `specs.dir` holds more than fifty" + " previous copies of issue specs, which are safe to delete; a warning never changes the exit code. On a repository whose" + " provider is `gh` it also reads the GitHub board `rafa init --board` sets up and prints one row per" + " part \u2014 the seven labels, the spec issue template, the Roadmap issue and `roadmap.issue` \u2014 as present," + " missing, or unknown for a reading that failed, naming `rafa init --board` as the fix; it writes" + " nothing to the board and a row never changes the exit code. It then names, under `Blocked" + " issues:`, every open issue labelled `spec:blocked` whose `Blocked by:` line is missing, names no" + " issue, names itself, or names an id the board has no issue for, with what an author does about" + " it; that reading writes nothing and never changes the exit code either. It then names, under" + " `Epic labels:`, every issue carrying two `epic:` labels and every `epic:` label no `type:epic` issue" + " carries, read off one board listing, writing nothing and never changing the exit code. It then names, under" + " `Boards:`, every type:roadmap board whose Owner: handle resolves to nobody GitHub shows, every open issue titled" + ` "Roadmap" without type:roadmap while labelled boards exist, and every slot of this checkout's position on a` + " board or epic that is closed, unlabelled or gone, read off that same listing and printing nothing when there is" + " none; it writes nothing and never changes the exit code. It then counts, without" + " fetching, the branches and worktrees `rafa cleanup` would list, and prints them in one row naming" + " `rafa cleanup` when any group holds one. It then counts the suspect, dangling and unknown references" + " of every saved copy under `specs.dir`, writing nothing, and names `rafa issue check <n>` for each" + " copy holding a suspect or dangling one. It then prints, under `Skill tiers`, a warning per" + " skill or agent name two tiers hold with different contents, per unreviewed third-party rafa or" + " add-on item, and for an installed Claude Code other than the version skill serving was probed" + " against, and a note per byte-identical copy that can be deleted and per user-tier item with no" + " `provenance`; none changes the exit code. With `--output=json` the" + " checks, both readings, those rows, those issues, those labels and those boards are the data of the terminal result event," + " unless a required item failed. A plan `--plan` names also gets the one-line risk total" + " `rafa loop start` prints before its notices, which never changes the exit code. With `--deep` it" + " also prints the machine as a loop session sees it, starting no session: the session's" + " Environment and working directory against the shell's, the Settings each agent, skill and MCP" + " server is read from and whether a session sees it, the Providers `gh` answers under the session's" + " environment, and the Stack tools the project's stack needs, with Plan needs for a plan `--plan`" + " names; each row is ok, warn or note with its fix, printed after the blocked issues and before a" + " refusal, and none changes the exit code. With `--output=json` they are the `deep` of the data.",
+    description: "Checks the prerequisites `rafa loop start` checks before its first session and prints each" + " check, starting no run and storing nothing: the required and optional items of" + " `.rafa/config.yaml`, with the `PREREQUISITES-<stub>.md` beside the plan merged in, and, when the" + " repository resolves to `pr.provider: gh`, the two required items that provider adds ahead of them:" + " `gh` on PATH and `gh auth status` for the remote's host. A plan's `[start]` items are checked" + " after those and ahead of the configured tiers, on a first dispatch alone: a" + " `PLAN_TRACKER-<stub>.md` beside the plan already holding a ticked task makes the next run a" + " resume, which checks none of them and says in one line how many it passed over." + " The plan is the" + " one `--plan=<file>` names, relative to the project root, or the default plan `rafa loop start`" + ` runs. Each probe runs in the project root with stdin closed and a ${String(PROBE_TIMEOUT_MS / 1000)}-second` + " timeout. It exits 1 when a required item fails, naming the item, its probe and its exit code or" + " first line of stderr, where `rafa loop start` would halt. It reads the effort store as" + " `rafa effort schema --check` does, changing nothing, and prints its `effort store schema` row:" + " it exits 1 where that check fails, naming the next safe step, and warns on a migration this rafa" + " does not know that is additive and on one the project's own store logs as applied by a development" + " build. It exits 0 otherwise. It warns when" + " `.ralph/effort/` holds an effort store and `.rafa/effort/` holds none, and when `~/.rafa/bin` is" + " not on PATH ahead of `~/.bun/bin`, and when `previous/` under `specs.dir` holds more than fifty" + " previous copies of issue specs, which are safe to delete; a warning never changes the exit code. On a repository whose" + " provider is `gh` it also reads the GitHub board `rafa init --board` sets up and prints one row per" + " part \u2014 the seven labels, the spec issue template, the Roadmap issue and `roadmap.issue` \u2014 as present," + " missing, or unknown for a reading that failed, naming `rafa init --board` as the fix; it writes" + " nothing to the board and a row never changes the exit code. It then names, under `Blocked" + " issues:`, every open issue labelled `spec:blocked` whose `Blocked by:` line is missing, names no" + " issue, names itself, or names an id the board has no issue for, with what an author does about" + " it; that reading writes nothing and never changes the exit code either. It then names, under" + " `Epic labels:`, every issue carrying two `epic:` labels and every `epic:` label no `type:epic` issue" + " carries, read off one board listing, writing nothing and never changing the exit code. It then names, under" + " `Boards:`, every type:roadmap board whose Owner: handle resolves to nobody GitHub shows, every open issue titled" + ` "Roadmap" without type:roadmap while labelled boards exist, and every slot of this checkout's position on a` + " board or epic that is closed, unlabelled or gone, read off that same listing and printing nothing when there is" + " none; it writes nothing and never changes the exit code. It then counts, without" + " fetching, the branches and worktrees `rafa cleanup` would list, and prints them in one row naming" + " `rafa cleanup` when any group holds one. It then counts the suspect, dangling and unknown references" + " of every saved copy under `specs.dir`, writing nothing, and names `rafa issue check <n>` for each" + " copy holding a suspect or dangling one. It then prints, under `Skill tiers`, a warning per" + " skill or agent name two tiers hold with different contents, per unreviewed third-party rafa or" + " add-on item, and for an installed Claude Code other than the version skill serving was probed" + " against, and a note per byte-identical copy that can be deleted and per user-tier item with no" + " `provenance`; none changes the exit code. With `--output=json` the" + " checks, both readings, those rows, those issues, those labels and those boards are the data of the terminal result event," + " unless a required item failed. A plan `--plan` names also gets the one-line risk total" + " `rafa loop start` prints before its notices, which never changes the exit code. With `--deep` it" + " also prints the machine as a loop session sees it, starting no session: the session's" + " Environment and working directory against the shell's, the Settings each agent, skill and MCP" + " server is read from and whether a session sees it, the Providers `gh` answers under the session's" + " environment, and the Stack tools the project's stack needs, with Plan needs for a plan `--plan`" + " names; each row is ok, warn or note with its fix, printed after the blocked issues and before a" + " refusal, and none changes the exit code. With `--output=json` they are the `deep` of the data.",
     args: [],
     flags: [
       {
@@ -7349,52 +7441,209 @@ var collect_default = wrapPhaseZeroCommand({
   outputs: ["text", "json"]
 }, collect);
 
-// src/effort/store/fix-schema.ts
-import { existsSync as existsSync5, renameSync, rmSync as rmSync2 } from "fs";
+// src/commands/effort/copy.ts
+import { join as join19, resolve as resolve7 } from "path";
+
+// src/effort/store/copy.ts
+import { copyFileSync as copyFileSync3, constants, existsSync as existsSync5, mkdirSync as mkdirSync3, readdirSync, rmSync as rmSync2, statSync as statSync7 } from "fs";
+import { join as join18, resolve as resolve6 } from "path";
 import { Database } from "bun:sqlite";
-class SchemaFixRefusal extends Error {
+var NDJSON_KINDS2 = { sessions: true, commits: true };
+var EFFORT_COPY_FILE_NAMES = [
+  SQLITE_STORE_FILE_NAME,
+  ...Object.keys(NDJSON_KINDS2).map((kind) => effortStoreFileName(kind))
+];
+
+class EffortCopyRefusal extends Error {
+  name = "EffortCopyRefusal";
+}
+
+class EffortCopyFailure extends Error {
+  name = "EffortCopyFailure";
+}
+function refuseUsedTarget(target) {
+  if (!existsSync5(target))
+    return;
+  let entries;
+  try {
+    if (!statSync7(target).isDirectory()) {
+      throw new EffortCopyRefusal(`${target} is a file, not a directory; name an empty or absent directory with --to=<dir>.`);
+    }
+    entries = readdirSync(target);
+  } catch (error) {
+    if (error instanceof EffortCopyRefusal)
+      throw error;
+    throw new EffortCopyFailure(`${target} cannot be read: ${String(error)}`);
+  }
+  if (entries.length === 0)
+    return;
+  throw new EffortCopyRefusal(`${target} is not empty (${String(entries.length)} entries); nothing was copied.` + " Name an empty or absent directory with --to=<dir>.");
+}
+function vacuumInto(source, target) {
+  const db = new Database(source, { readonly: true });
+  try {
+    db.run(`PRAGMA busy_timeout = ${String(activeStoreSettings().busyTimeoutMs)}`);
+    db.run("VACUUM INTO ?", [target]);
+  } finally {
+    db.close();
+  }
+}
+function copyOne2(name2, source, target) {
+  if (name2 === SQLITE_STORE_FILE_NAME) {
+    vacuumInto(join18(source, name2), join18(target, name2));
+    return;
+  }
+  copyFileSync3(join18(source, name2), join18(target, name2), constants.COPYFILE_EXCL);
+}
+function undo(target, written, madeDir) {
+  try {
+    if (madeDir === undefined) {
+      for (const name2 of written)
+        rmSync2(join18(target, name2), { force: true });
+    } else {
+      rmSync2(madeDir, { recursive: true, force: true });
+    }
+    return "";
+  } catch (error) {
+    return ` Removing what it made failed too: ${String(error)}`;
+  }
+}
+function copyEffortStore(request) {
+  const source = resolve6(request.source);
+  const target = resolve6(request.target);
+  guardTestProcess(source);
+  guardTestProcess(target);
+  const files = EFFORT_COPY_FILE_NAMES.filter((name2) => existsSync5(join18(source, name2)));
+  if (files.length === 0) {
+    throw new EffortCopyRefusal(`no effort store at ${source}: it holds none of ${EFFORT_COPY_FILE_NAMES.join(", ")}. Nothing to copy.`);
+  }
+  refuseUsedTarget(target);
+  const written = [];
+  let madeDir;
+  try {
+    madeDir = mkdirSync3(target, { recursive: true });
+    for (const name2 of files) {
+      written.push(name2);
+      copyOne2(name2, source, target);
+    }
+  } catch (error) {
+    const left = undo(target, written, madeDir);
+    throw new EffortCopyFailure(`copying ${source} to ${target} failed: ${String(error)}.${left}`);
+  }
+  return Object.freeze({ source, directory: target, files: Object.freeze(files) });
+}
+
+// src/effort/store/fix-schema.ts
+import { existsSync as existsSync7 } from "fs";
+import { Database as Database2 } from "bun:sqlite";
+
+// src/effort/store/rebuild-aside.ts
+import { existsSync as existsSync6, renameSync, rmSync as rmSync3 } from "fs";
+
+class RebuildRefusal extends Error {
   constructor(message) {
     super(message);
-    this.name = "SchemaFixRefusal";
+    this.name = "RebuildRefusal";
   }
 }
-var LIVE = "live";
 function quoted(name2) {
   return `"${name2.replaceAll('"', '""')}"`;
 }
+function count(db, sql) {
+  return db.query(sql).get()?.n ?? 0;
+}
+function refuseInFlight(path) {
+  for (const suffix of ["-journal", "-wal"]) {
+    if (existsSync6(`${path}${suffix}`)) {
+      throw new RebuildRefusal(`${path}${suffix} is there, so a write is in flight or was interrupted; stop whatever uses the store` + " and open it once with rafa before repairing it");
+    }
+  }
+}
+function checkedCounts(db, tables, original) {
+  return tables.map((table) => {
+    const rows = count(db, `SELECT count(*) AS n FROM main.${quoted(table)}`);
+    const originalRows = count(db, `SELECT count(*) AS n FROM ${original}.${quoted(table)}`);
+    if (rows !== originalRows) {
+      throw new RebuildRefusal(`the rebuilt ${table} holds ${String(rows)} rows, the store ${String(originalRows)}`);
+    }
+    return { table, rows };
+  });
+}
+function refuseCorrupt(db) {
+  const answer = db.query("PRAGMA main.integrity_check").get()?.integrity_check;
+  if (answer !== "ok")
+    throw new RebuildRefusal(`the rebuilt store failed integrity_check: ${answer ?? "no answer"}`);
+}
+function removeParallel(parallelPath) {
+  rmSync3(parallelPath, { force: true });
+  rmSync3(`${parallelPath}-journal`, { force: true });
+}
+function swapIn(path, parallelPath, backupPath) {
+  renameSync(path, backupPath);
+  try {
+    renameSync(parallelPath, path);
+  } catch (error) {
+    renameSync(backupPath, path);
+    throw error;
+  }
+}
+function refuseTaken(paths) {
+  for (const taken of paths) {
+    if (existsSync6(taken))
+      throw new RebuildRefusal(`${taken} is already there; move it aside or pass another stamp`);
+  }
+}
+function rebuildAside(options) {
+  const { path, parallelPath, backupPath, dryRun, build } = options;
+  refuseInFlight(path);
+  refuseTaken([parallelPath, backupPath]);
+  let built;
+  try {
+    built = build(parallelPath);
+  } catch (error) {
+    removeParallel(parallelPath);
+    throw error;
+  }
+  if (dryRun) {
+    removeParallel(parallelPath);
+    return { built, backupPath: null };
+  }
+  swapIn(path, parallelPath, backupPath);
+  return { built, backupPath };
+}
+
+// src/effort/store/fix-schema.ts
+var REPAIRABLE_REASONS = [
+  "pre-log-unreleased",
+  "gate-mismatch",
+  "edited",
+  "unknown-breaks-readers",
+  "unknown-breaks-writers"
+];
+var LIVE = "live";
 function tableNames(db, schema) {
-  return db.query(`SELECT name FROM ${schema}.sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%' ORDER BY name`).all().map((row2) => row2.name);
+  return db.query(`SELECT name FROM ${schema}.sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%' AND name <> ? ORDER BY name`).all(MIGRATION_LOG_TABLE).map((row2) => row2.name);
 }
 function columnNames(db, schema, table) {
   return db.query("SELECT name FROM pragma_table_info(?, ?)").all(table, schema).map((row2) => row2.name);
 }
-function count(db, sql) {
-  return db.query(sql).get()?.n ?? 0;
-}
-function versionOf(path) {
-  const db = new Database(path, { readonly: true });
+function readOnlySchema(path) {
+  const db = new Database2(path, { readonly: true });
   try {
-    return db.query("PRAGMA user_version").get()?.user_version ?? 0;
+    return readStoreSchema(db, path);
   } finally {
     db.close();
   }
 }
-function refuseInFlight(path) {
-  for (const suffix of ["-journal", "-wal"]) {
-    if (existsSync5(`${path}${suffix}`)) {
-      throw new SchemaFixRefusal(`${path}${suffix} is there, so a write is in flight or was interrupted; stop whatever uses the store` + " and open it once with rafa before repairing it");
-    }
-  }
-}
 function refuseRemoved(db, known, live) {
   for (const table of known) {
     if (!live.has(table)) {
-      throw new SchemaFixRefusal(`the store holds no table ${table}, which this rafa writes; its newer schema is not additive`);
+      throw new RebuildRefusal(`the store holds no table ${table}, which this rafa writes; its newer schema is not additive`);
     }
     const liveColumns = new Set(columnNames(db, LIVE, table));
     const missing = columnNames(db, "main", table).filter((column) => !liveColumns.has(column));
     if (missing.length > 0) {
-      throw new SchemaFixRefusal(`the store holds no column ${missing.map((column) => `${table}.${column}`).join(", ")}, which this rafa` + " writes; its newer schema is not additive");
+      throw new RebuildRefusal(`the store holds no column ${missing.map((column) => `${table}.${column}`).join(", ")}, which this rafa` + " writes; its newer schema is not additive");
     }
   }
 }
@@ -7406,16 +7655,6 @@ function copyKnown(db, known) {
     }
   })();
 }
-function checkedCounts(db, known) {
-  return known.map((table) => {
-    const rows = count(db, `SELECT count(*) AS n FROM main.${quoted(table)}`);
-    const liveRows = count(db, `SELECT count(*) AS n FROM ${LIVE}.${quoted(table)}`);
-    if (rows !== liveRows) {
-      throw new SchemaFixRefusal(`the rebuilt ${table} holds ${String(rows)} rows, the store ${String(liveRows)}`);
-    }
-    return { table, rows };
-  });
-}
 function leftBehind(db, known, live) {
   const leftTables = live.filter((table) => !known.has(table)).map((table) => ({ table, rows: count(db, `SELECT count(*) AS n FROM ${LIVE}.${quoted(table)}`) }));
   const leftColumns = live.filter((table) => known.has(table)).flatMap((table) => {
@@ -7428,78 +7667,91 @@ function leftBehind(db, known, live) {
   });
   return { leftTables, leftColumns };
 }
-function refuseCorrupt(db) {
-  const answer = db.query("PRAGMA main.integrity_check").get()?.integrity_check;
-  if (answer !== "ok")
-    throw new SchemaFixRefusal(`the rebuilt store failed integrity_check: ${answer ?? "no answer"}`);
+function refuseUnusable(db, parallelPath, migrations) {
+  const plan2 = planSchema(readStoreSchema(db, parallelPath), sqliteCatalogue(migrations), "write", "open");
+  if (plan2.verdict === "refuse")
+    throw new RebuildRefusal(`the rebuilt store is refused as ${plan2.reason}: ${plan2.message}`);
+  const needs = writeNames(plan2);
+  if (needs.length > 0)
+    throw new RebuildRefusal(`the rebuilt store still needs ${needs.join(", ")}`);
 }
-function buildParallel(path, parallelPath, migrations) {
-  const db = new Database(parallelPath, { create: true, readwrite: true });
+function buildParallel(path, parallelPath, migrations, stamp) {
+  const db = new Database2(parallelPath, { create: true, readwrite: true });
   try {
-    migrateSchema(db, parallelPath, migrations);
+    bringForward(db, parallelPath, "write", "open", { migrations, ...stamp, builtAside: true });
     db.run(`ATTACH DATABASE ? AS ${LIVE}`, [path]);
     const known = tableNames(db, "main");
     const live = tableNames(db, LIVE);
     refuseRemoved(db, known, new Set(live));
     copyKnown(db, known);
-    const kept = checkedCounts(db, known);
+    const kept = checkedCounts(db, known, LIVE);
     const left = leftBehind(db, new Set(known), live);
     db.run(`DETACH DATABASE ${LIVE}`);
     refuseCorrupt(db);
+    refuseUnusable(db, parallelPath, migrations);
     return { kept, ...left };
   } finally {
     db.close();
   }
 }
-function removeParallel(parallelPath) {
-  rmSync2(parallelPath, { force: true });
-  rmSync2(`${parallelPath}-journal`, { force: true });
+function asidePaths(path, version2, stamp) {
+  return { parallelPath: `${path}.fix-${stamp}`, backupPath: `${path}.v${String(version2)}-${stamp}.bak` };
 }
-function swapIn(path, parallelPath, backupPath) {
-  renameSync(path, backupPath);
-  try {
-    renameSync(parallelPath, path);
-  } catch (error) {
-    renameSync(backupPath, path);
-    throw error;
-  }
+function isRepairable(reason) {
+  return REPAIRABLE_REASONS.includes(reason);
 }
-function freshPaths(path, version2, stamp) {
-  const parallelPath = `${path}.fix-${stamp}`;
-  const backupPath = `${path}.v${String(version2)}-${stamp}.bak`;
-  for (const taken of [parallelPath, backupPath]) {
-    if (existsSync5(taken))
-      throw new SchemaFixRefusal(`${taken} is already there; move it aside or pass another stamp`);
-  }
-  return { parallelPath, backupPath };
+function refuseDevelopmentSwap(path, reason, identity) {
+  if (identity.kind !== "development")
+    return;
+  throw new RebuildRefusal(`${path} needs a rebuild (${reason}), and this rafa is a development build (${identity.checkout}), whose` + " migrations may be a branch's; a development build never swaps a rebuild in. Nothing was changed, and" + " --dry-run runs from here. Run the swap from an installed rafa. Next safe step: rafa effort fix-schema");
 }
 function fixStoreSchema(options) {
   const { path, dryRun, stamp } = options;
+  guardTestProcess(path);
   const migrations = options.migrations ?? SQLITE_MIGRATIONS;
-  const knownVersion = migrations.length;
-  const nothing = { kept: [], leftTables: [], leftColumns: [], backupPath: null };
-  if (!existsSync5(path))
-    return { path, status: "missing", storeVersion: null, knownVersion, ...nothing };
+  const identity = options.identity ?? readRuntimeIdentity();
+  const appliedBy = appliedByName(identity);
+  const known = migrations.map(({ id: id2 }) => id2);
+  const nothing = { known, appliedBy, pending: [], kept: [], leftTables: [], leftColumns: [], backupPath: null };
+  if (!existsSync7(path)) {
+    return { path, status: "missing", storeVersion: null, logged: false, reason: null, refusal: null, unknown: [], ...nothing };
+  }
   refuseInFlight(path);
-  const storeVersion = versionOf(path);
-  if (storeVersion === knownVersion)
-    return { path, status: "current", storeVersion, knownVersion, ...nothing };
-  if (storeVersion < knownVersion)
-    return { path, status: "behind", storeVersion, knownVersion, ...nothing };
-  const { parallelPath, backupPath } = freshPaths(path, storeVersion, stamp);
-  let built;
-  try {
-    built = buildParallel(path, parallelPath, migrations);
-  } catch (error) {
-    removeParallel(parallelPath);
-    throw error;
+  const store = readOnlySchema(path);
+  const knownIds = new Set(known);
+  const found = {
+    path,
+    storeVersion: store.userVersion,
+    logged: store.log !== null,
+    unknown: (store.log ?? []).filter(({ id: id2 }) => !knownIds.has(id2))
+  };
+  const plan2 = planSchema(store, sqliteCatalogue(migrations), "write", "open");
+  if (plan2.verdict === "use") {
+    const pending = writeNames(plan2);
+    const status2 = pending.length === 0 ? "current" : "behind";
+    return { ...found, ...nothing, status: status2, reason: null, refusal: null, pending };
   }
-  if (dryRun) {
-    removeParallel(parallelPath);
-    return { path, status: "would-rebuild", storeVersion, knownVersion, ...built, backupPath: null };
+  if (!isRepairable(plan2.reason)) {
+    throw new RebuildRefusal(`a rebuild at this rafa's migrations does not repair ${plan2.reason}. ${plan2.message}`);
   }
-  swapIn(path, parallelPath, backupPath);
-  return { path, status: "rebuilt", storeVersion, knownVersion, ...built, backupPath };
+  if (!dryRun)
+    refuseDevelopmentSwap(path, plan2.reason, identity);
+  const { built, backupPath } = rebuildAside({
+    path,
+    ...asidePaths(path, store.userVersion, stamp),
+    dryRun,
+    build: (parallelPath) => buildParallel(path, parallelPath, migrations, {
+      appliedBy,
+      now: options.now ?? (() => new Date)
+    })
+  });
+  const status = dryRun ? "would-rebuild" : "rebuilt";
+  const refusal4 = withoutWayOut(plan2.message, plan2.nextStep);
+  return { ...found, ...nothing, status, reason: plan2.reason, refusal: refusal4, ...built, backupPath };
+}
+function withoutWayOut(message, nextStep) {
+  const ending = ` Next safe step: ${nextStep}`;
+  return message.endsWith(ending) ? message.slice(0, -ending.length) : message;
 }
 
 // src/commands/effort/fix-schema.ts
@@ -7521,102 +7773,401 @@ function refuseLiveLoop(root, isAlive) {
     return;
   throw new CommandExit(1, `\u274C ${COMMAND_NAME5}: loop session ${live.sessionId} on ${live.branch} is ${live.state} and writes the store;` + ` stop it with \`rafa loop stop -s ${live.sessionId}\` first. \`--dry-run\` runs beside it.`);
 }
+function migrationNames(result) {
+  return result.unknown.map(({ id: id2, appliedBy }) => `${id2} (applied by ${appliedBy})`).join(", ");
+}
 function rebuildLines(result) {
   const rows = result.kept.reduce((sum, table) => sum + table.rows, 0);
   const kept = result.kept.map((table) => `${table.table} ${String(table.rows)}`).join(", ");
   const left = [
+    ...result.unknown.map(({ id: id2, appliedBy }) => `migration ${id2} (applied by ${appliedBy})`),
     ...result.leftTables.map((table) => `table ${table.table} (${String(table.rows)} rows)`),
     ...result.leftColumns.map((column) => `column ${column.table}.${column.column} (${String(column.values)} values)`)
   ];
+  const newer = result.unknown.length === 0 ? [] : [`A rafa that knows ${result.unknown.map(({ id: id2 }) => id2).join(", ")} uses the store as it is and keeps that data` + " in it; install one instead where you can."];
+  return [
+    `Refused as ${String(result.reason)}: ${String(result.refusal)}`,
+    `Rebuilds it at the ${String(result.known.length)} migrations this rafa knows, logged as applied by ${result.appliedBy}.`,
+    `Keeps ${String(result.kept.length)} tables, ${String(rows)} rows: ${kept}.`,
+    left.length === 0 ? "Leaves nothing behind." : `Leaves behind, kept only in the backup: ${left.join("; ")}.`,
+    ...newer
+  ];
+}
+function unknownAdditiveLines(result) {
+  return result.unknown.length === 0 ? [] : [`It logs ${migrationNames(result)}, which this rafa does not know; each is additive, so this rafa uses the store` + " through them."];
+}
+function renderFixSchema(result) {
+  switch (result.status) {
+    case "missing":
+      return [`No effort store at ${result.path}: nothing to repair.`];
+    case "current":
+      return [
+        `\u2705 ${result.path} is current: this rafa reads and writes it as it is. Nothing to repair.`,
+        ...unknownAdditiveLines(result)
+      ];
+    case "behind":
+      return [
+        `${result.path} is behind this rafa's migrations; the next command that opens it records` + ` ${result.pending.join(", ")}. Nothing to repair.`,
+        ...unknownAdditiveLines(result)
+      ];
+    case "would-rebuild":
+      return [
+        ...rebuildLines(result),
+        "\uD83D\uDD0D Dry run: the rebuild was built, checked (row counts, integrity_check, this rafa's schema plan) and" + " deleted. Run without `--dry-run` to swap it in."
+      ];
+    case "rebuilt":
+      return [
+        ...rebuildLines(result),
+        `\u2705 Rebuilt at this rafa's migrations. The original is kept whole at ${String(result.backupPath)};` + " rename it back to undo."
+      ];
+  }
+}
+function runFixSchema(context, seams) {
+  expectNoArgument(context.args, FIX_SCHEMA_USAGE);
+  const dryRun = readSwitch(DRY_RUN_FLAG2, context.flags[DRY_RUN_FLAG2], `Usage: ${FIX_SCHEMA_USAGE}`);
+  if (context.project === null)
+    throw new Error(`${COMMAND_NAME5} runs inside a project, and was handed none`);
+  const root = context.project.root;
+  if (!dryRun)
+    refuseLiveLoop(root, seams.isAlive);
+  const now = seams.now ?? (() => new Date);
+  let result;
+  try {
+    result = fixStoreSchema({
+      path: sqliteStorePath(root),
+      dryRun,
+      stamp: fileStamp(now()),
+      now,
+      ...seams.identity === undefined ? {} : { identity: seams.identity }
+    });
+  } catch (error) {
+    if (error instanceof RebuildRefusal)
+      throw new CommandExit(1, `\u274C ${COMMAND_NAME5}: ${error.message}`);
+    throw error;
+  }
+  if (context.outputMode === "json") {
+    context.output.result(result);
+    return;
+  }
+  for (const line of renderFixSchema(result))
+    context.output.info(line);
+}
+function createFixSchemaCommand(seams = {}) {
+  const command = {
+    name: "effort fix-schema",
+    subject: "effort",
+    action: "fix-schema",
+    summary: "rebuild an effort store this rafa refuses at the migrations it knows, keeping the original",
+    description: "Repairs `.rafa/effort/effort.sqlite`, or the store under `RAFA_EFFORT_DIR`, when this rafa refuses" + " it for a reason a rebuild repairs: no migration log past the legacy entries (pre-log-unreleased), a log" + " with a schema version it does not match (gate-mismatch), a logged checksum this rafa holds otherwise" + " (edited), or a logged migration this rafa does not know that breaks older readers or writers" + " (unknown-breaks-readers, unknown-breaks-writers). Installing a rafa that knows the store's migrations" + " comes first where one exists. It builds a parallel store beside it at this rafa's migrations, with a" + " migration log naming this rafa, copies every table and column this rafa knows, checks the row counts," + " SQLite's integrity_check and the schema plan, and lists what only the newer schema holds, unknown" + " migrations included. Then it renames the original to `effort.sqlite.v<user_version>-<stamp>.bak`," + " whole, and moves the rebuild into its place. A store this rafa uses, current or behind, or no store, is" + " left alone. It refuses, changing nothing, while a loop session under the project is running or paused," + " from a development build, while a journal beside the store shows a write in flight, when the newer" + " schema lacks a table or column this rafa writes, and on a refusal a rebuild does not repair. With" + " `--output=json` the outcome is the data of the terminal result event. Starts no session.",
+    args: [],
+    flags: [
+      {
+        name: DRY_RUN_FLAG2,
+        description: "Build and check the rebuild, print what it keeps and leaves behind, then delete it. The" + " live store is only read, so this runs beside a live loop and from a development build, and can be" + " repeated.",
+        type: "boolean"
+      }
+    ],
+    examples: [
+      {
+        cmd: "rafa effort fix-schema --dry-run",
+        note: "Prints what a rebuild would keep and leave behind, changing nothing."
+      },
+      {
+        cmd: "rafa effort fix-schema",
+        note: "Swaps the rebuild in and prints where the original was kept."
+      }
+    ],
+    outputs: ["text", "json"],
+    run: async (context) => {
+      runFixSchema(context, seams);
+      await Promise.resolve();
+    }
+  };
+  return Object.freeze(command);
+}
+var fix_schema_default = createFixSchemaCommand();
+
+// src/commands/effort/copy.ts
+var COMMAND_NAME6 = "rafa effort copy";
+var COPY_USAGE = "rafa effort copy [--to=<dir>]";
+var TO_FLAG = "to";
+var REFUSED_EXIT = 1;
+var FAILED_EXIT = 2;
+var SCRATCH_DIR = join19(".rafa", "scratch");
+function effortDirLine(directory) {
+  return `${EFFORT_DIR_VARIABLE}=${directory}`;
+}
+function readTarget(context, root) {
+  const value = context.flags[TO_FLAG];
+  if (value === undefined)
+    return null;
+  if (typeof value !== "string" || value === "") {
+    throw new CommandExit(REFUSED_EXIT, `\u274C --${TO_FLAG} takes a directory: --${TO_FLAG}=<dir>
+Usage: ${COPY_USAGE}`);
+  }
+  return resolve7(root, value);
+}
+function refuseEffortDirOverride(context) {
+  const value = context.env[EFFORT_DIR_VARIABLE];
+  if (value === undefined || value === "")
+    return;
+  throw new CommandExit(REFUSED_EXIT, `\u274C ${COMMAND_NAME6}: ${EFFORT_DIR_VARIABLE} is set (${value}); a copy is taken from the project's own store.` + ` Nothing was copied. Unset it and run again: ${EFFORT_DIR_VARIABLE}= ${COMMAND_NAME6}`);
+}
+function renderCopy(result) {
+  return [
+    `\u2705 Copied ${result.files.join(", ")} from ${result.source} to ${result.directory}.`,
+    "Put this in front of each command that should use the copy, on the same line:",
+    effortDirLine(result.directory)
+  ];
+}
+function runCopy(context, seams) {
+  expectNoArgument(context.args, COPY_USAGE);
+  const root = requireProject(context, COMMAND_NAME6).root;
+  const named = readTarget(context, root);
+  refuseEffortDirOverride(context);
+  const target = named ?? join19(root, SCRATCH_DIR, `effort-${fileStamp((seams.now ?? (() => new Date))())}`);
+  let result;
+  try {
+    result = copyEffortStore({ source: join19(root, EFFORT_STORE_DIR), target });
+  } catch (error) {
+    if (error instanceof EffortCopyRefusal)
+      throw new CommandExit(REFUSED_EXIT, `\u274C ${COMMAND_NAME6}: ${error.message}`);
+    if (error instanceof EffortCopyFailure)
+      throw new CommandExit(FAILED_EXIT, `\u274C ${COMMAND_NAME6}: ${error.message}`);
+    throw error;
+  }
+  if (context.outputMode === "json") {
+    context.output.result({ ...result, env: effortDirLine(result.directory) });
+    return;
+  }
+  for (const line of renderCopy(result))
+    context.output.info(line);
+}
+function createCopyCommand(seams = {}) {
+  const command = {
+    name: "effort copy",
+    subject: "effort",
+    action: "copy",
+    summary: "copy the effort store into a scratch directory and print the RAFA_EFFORT_DIR= line that points a command at it",
+    description: "Copies `.rafa/effort/` into a directory of its own: the SQLite file through `VACUUM INTO`, which only" + " reads the store and keeps its schema version and migration log, and the NDJSON files by file copy. The" + " copy lands in `--to`, or in `.rafa/scratch/effort-<stamp>/`. It prints the directory and the" + " `RAFA_EFFORT_DIR=` line to put in front of each command that should run over the copy instead of the" + " live store. It plans no schema, so a development build may run it and a running loop is not disturbed." + " Exit code 1, making nothing, when `RAFA_EFFORT_DIR` is set, when there is no store, or when the target" + " is not empty; exit code 2 when a read or write failed, with what it made removed. With `--output=json`" + " the copy is the data of the terminal result event. Starts no session.",
+    args: [],
+    flags: [
+      {
+        name: TO_FLAG,
+        description: "The directory to copy into, absent or empty; a relative one is read from the project root." + " Defaults to `.rafa/scratch/effort-<stamp>/`.",
+        type: "string"
+      }
+    ],
+    examples: [
+      {
+        cmd: "rafa effort copy",
+        note: "Copies the store into `.rafa/scratch/effort-<stamp>/` and prints the `RAFA_EFFORT_DIR=` line."
+      },
+      {
+        cmd: "rafa effort copy --to=.rafa/scratch/rafa-234-effort",
+        note: "Copies the store into a directory a plan names."
+      }
+    ],
+    outputs: ["text", "json"],
+    run: async (context) => {
+      runCopy(context, seams);
+      await Promise.resolve();
+    }
+  };
+  return Object.freeze(command);
+}
+var copy_default = createCopyCommand();
+
+// src/commands/effort/migrate.ts
+import { join as join20 } from "path";
+
+// src/effort/store/migrate.ts
+import { existsSync as existsSync8 } from "fs";
+import { Database as Database3 } from "bun:sqlite";
+var LIVE2 = "live";
+function asidePaths2(path, first, stamp) {
+  return { parallelPath: `${path}.migrate-${stamp}`, backupPath: `${path}.before-${first}-${stamp}.bak` };
+}
+function liveLoop(path, options) {
+  const root = storeProjectRoot(path);
+  if (root === null)
+    return;
+  let records;
+  try {
+    records = readSessions(root, { isAlive: options.isAlive ?? isPidAlive });
+  } catch (error) {
+    throw new RebuildRefusal(`the loop's run records cannot be read, so a live loop on ${path} cannot be ruled out` + ` (${messageOf(error)}). Nothing was migrated.`);
+  }
+  return records.find((record) => record.state === "running" || record.state === "paused");
+}
+function refuseLiveLoop2(path, breaking, options) {
+  const loop = liveLoop(path, options);
+  if (loop === undefined)
+    return;
+  const named = `loop ${loop.sessionId} (pid ${String(loop.pid)}, plan ${loop.planStub ?? loop.plan}) is running on this store`;
+  const [first] = breaking;
+  const opening = first === undefined ? `REFUSED \u2014 ${named}, and swapping the migrated store in under it would lose what it writes.` : `REFUSED \u2014 migration ${first} breaks older runtimes, and ${named}.`;
+  throw new RebuildRefusal(`${opening} Nothing was migrated. Finish or stop that loop, then run it again.`);
+}
+function buildMigrated(path, parallelPath, migrations, stamp) {
+  vacuumInto(path, parallelPath);
+  const db = new Database3(parallelPath, { readwrite: true });
+  try {
+    const brought = bringForward(db, parallelPath, "write", "migrate", { migrations, ...stamp, builtAside: true });
+    db.run(`ATTACH DATABASE ? AS ${LIVE2}`, [path]);
+    const live = new Set(tableNames(db, LIVE2));
+    const counted2 = checkedCounts(db, tableNames(db, "main").filter((table) => live.has(table)), LIVE2);
+    db.run(`DETACH DATABASE ${LIVE2}`);
+    refuseCorrupt(db);
+    refuseUnusable(db, parallelPath, migrations);
+    return { userVersion: brought.userVersion, counted: counted2 };
+  } finally {
+    db.close();
+  }
+}
+function migrateStore(options) {
+  const { path, dryRun, stamp } = options;
+  guardTestProcess(path);
+  const migrations = options.migrations ?? SQLITE_MIGRATIONS;
+  const appliedBy = appliedByName(options.identity ?? readRuntimeIdentity());
+  const nothing = { applying: [], breaking: [], unknown: [], userVersion: null, counted: [], backupPath: null };
+  if (!existsSync8(path)) {
+    return { path, status: "missing", storeVersion: null, logged: false, appliedBy, ...nothing };
+  }
+  refuseInFlight(path);
+  const store = readOnlySchema(path);
+  const found = { path, storeVersion: store.userVersion, logged: store.log !== null, appliedBy };
+  const plan2 = planSchema(store, sqliteCatalogue(migrations), "write", "migrate");
+  if (plan2.verdict === "refuse")
+    throw new RebuildRefusal(plan2.message);
+  const applying = writeNames(plan2);
+  const planned = {
+    applying,
+    breaking: plan2.pending.filter(({ breaks }) => breaks.length > 0).map(({ id: id2 }) => id2),
+    unknown: plan2.unknown
+  };
+  if (applying.length === 0)
+    return { ...found, ...nothing, ...planned, status: "current" };
+  if (!dryRun) {
+    refuseUnownedDevelopmentWrite(path, applying, options);
+    refuseLiveLoop2(path, planned.breaking, options);
+  }
+  const first = plan2.pending[0]?.id ?? ADOPTION_NAME;
+  const { built, backupPath } = rebuildAside({
+    path,
+    ...asidePaths2(path, first, stamp),
+    dryRun,
+    build: (parallelPath) => buildMigrated(path, parallelPath, migrations, {
+      appliedBy,
+      now: options.now ?? (() => new Date)
+    })
+  });
+  const status = dryRun ? "would-migrate" : "migrated";
+  return { ...found, ...planned, ...built, status, backupPath };
+}
+
+// src/commands/effort/migrate.ts
+var COMMAND_NAME7 = "rafa effort migrate";
+var MIGRATE_USAGE = "rafa effort migrate [--dry-run]";
+var DRY_RUN_FLAG3 = "dry-run";
+var REFUSED_EXIT2 = 1;
+function builtLines(result) {
+  const rows = result.counted.reduce((sum, table) => sum + table.rows, 0);
+  const breaking = result.breaking.length === 0 ? "Every one is additive." : `${result.breaking.join(", ")} breaks older runtimes: a rafa that does not know it refuses the store once it runs.`;
   return [
-    `${result.path} is at schema version ${String(result.storeVersion)}, past the ${String(result.knownVersion)} this rafa knows.`,
-    `Keeps ${String(result.kept.length)} tables, ${String(rows)} rows: ${kept}.`,
-    left.length === 0 ? "Leaves nothing behind." : `Leaves behind, kept only in the backup: ${left.join("; ")}.`
+    `Applies ${result.applying.join(", ")} to ${result.path}, logged as applied by ${result.appliedBy}. ${breaking}`,
+    `Row counts match in ${String(result.counted.length)} tables, ${String(rows)} rows; integrity_check ok;` + ` schema version ${String(result.userVersion)} after.`
   ];
 }
-function renderFixSchema(result) {
+function renderMigrate(result) {
   switch (result.status) {
     case "missing":
-      return [`No effort store at ${result.path}: nothing to repair.`];
+      return [`No effort store at ${result.path}: nothing to migrate.`];
     case "current":
-      return [`\u2705 ${result.path} is at schema version ${String(result.knownVersion)}, the one this rafa knows: nothing to repair.`];
-    case "behind":
-      return [
-        `${result.path} is at schema version ${String(result.storeVersion)}, behind the ${String(result.knownVersion)} this rafa` + " knows; the next command that opens it migrates it. Nothing to repair."
-      ];
-    case "would-rebuild":
+      return [`\u2705 ${result.path} is current: no migration is pending. Nothing to migrate.`];
+    case "would-migrate":
       return [
-        ...rebuildLines(result),
-        `\uD83D\uDD0D Dry run: the rebuild at version ${String(result.knownVersion)} was built, checked (row counts, integrity_check)` + " and deleted. Run without `--dry-run` to swap it in."
+        ...builtLines(result),
+        "\uD83D\uDD0D Dry run: the migrated store was built beside it, checked (row counts, integrity_check, this rafa's" + " schema plan) and deleted. Run `rafa effort migrate` to swap it in."
       ];
-    case "rebuilt":
+    case "migrated":
       return [
-        ...rebuildLines(result),
-        `\u2705 Rebuilt at version ${String(result.knownVersion)}. The original is kept whole at ${String(result.backupPath)};` + " rename it back to undo."
+        ...builtLines(result),
+        `\u2705 Migrated. The original is kept whole at ${String(result.backupPath)}; rename it back to undo.`
       ];
   }
 }
-function runFixSchema(context, seams) {
-  expectNoArgument(context.args, FIX_SCHEMA_USAGE);
-  const dryRun = readSwitch(DRY_RUN_FLAG2, context.flags[DRY_RUN_FLAG2], `Usage: ${FIX_SCHEMA_USAGE}`);
-  if (context.project === null)
-    throw new Error(`${COMMAND_NAME5} runs inside a project, and was handed none`);
-  const root = context.project.root;
-  if (!dryRun)
-    refuseLiveLoop(root, seams.isAlive);
+function storePath(context, root) {
+  try {
+    return join20(effortStoreDir(root, context.env), SQLITE_STORE_FILE_NAME);
+  } catch (error) {
+    throw new CommandExit(REFUSED_EXIT2, `\u274C ${COMMAND_NAME7}: ${messageOf(error)}`);
+  }
+}
+function runMigrate(context, seams) {
+  expectNoArgument(context.args, MIGRATE_USAGE);
+  const dryRun = readSwitch(DRY_RUN_FLAG3, context.flags[DRY_RUN_FLAG3], `Usage: ${MIGRATE_USAGE}`);
+  const path = storePath(context, requireProject(context, COMMAND_NAME7).root);
+  const now = seams.now ?? (() => new Date);
   let result;
   try {
-    result = fixStoreSchema({
-      path: sqliteStorePath(root),
+    result = migrateStore({
+      path,
       dryRun,
-      stamp: fileStamp((seams.now ?? (() => new Date))())
+      stamp: fileStamp(now()),
+      now,
+      env: context.env,
+      ...seams.identity === undefined ? {} : { identity: seams.identity },
+      ...seams.isAlive === undefined ? {} : { isAlive: seams.isAlive },
+      ...seams.migrations === undefined ? {} : { migrations: seams.migrations }
     });
   } catch (error) {
-    if (error instanceof SchemaFixRefusal)
-      throw new CommandExit(1, `\u274C ${COMMAND_NAME5}: ${error.message}`);
+    if (error instanceof RebuildRefusal || error instanceof DevelopmentBuildRefusedError) {
+      throw new CommandExit(REFUSED_EXIT2, `\u274C ${COMMAND_NAME7}: ${error.message}`);
+    }
     throw error;
   }
   if (context.outputMode === "json") {
     context.output.result(result);
     return;
   }
-  for (const line of renderFixSchema(result))
+  for (const line of renderMigrate(result))
     context.output.info(line);
 }
-function createFixSchemaCommand(seams = {}) {
+function createMigrateCommand(seams = {}) {
   const command = {
-    name: "effort fix-schema",
+    name: "effort migrate",
     subject: "effort",
-    action: "fix-schema",
-    summary: "rebuild an effort store a newer rafa migrated at the version this rafa knows, keeping the original",
-    description: "Repairs `.rafa/effort/effort.sqlite` when it is past the schema version this rafa knows, which" + " happens when newer code opens it, such as a plan's own branch code run while an older installed rafa" + " drives the loop. It builds a parallel store beside it at this rafa's version, copies every table and" + " column this rafa knows, checks the row counts and SQLite's integrity_check, and lists what only the" + " newer schema holds. Then it renames the original to `effort.sqlite.v<version>-<stamp>.bak`, whole, and" + " moves the rebuild into its place. A store at or behind this version, or no store, is left alone. It" + " refuses, changing nothing, while a loop session under the project is running or paused, while a" + " journal beside the store shows a write in flight, and when the newer schema lacks a table or column" + " this rafa writes. With `--output=json` the outcome is the data of the terminal result event. Starts no" + " session.",
+    action: "migrate",
+    summary: "apply the effort store's pending migrations, one that breaks older runtimes included, keeping the original",
+    description: "Brings `.rafa/effort/effort.sqlite`, or the store under `RAFA_EFFORT_DIR`, to the migrations this" + " rafa knows, including one that breaks older runtimes, which no ordinary open applies. It writes the" + " store to `effort.sqlite.migrate-<stamp>` beside it with `VACUUM INTO`, applies the pending migrations" + " there with log rows naming this rafa, checks the row count of every table against the store," + " SQLite's integrity_check and the schema plan, then renames the original to" + " `effort.sqlite.before-<id>-<stamp>.bak`, whole, and moves the migrated file into its place. A store" + " with nothing pending, or no store, is left alone. It refuses, changing nothing, while a loop session" + " under the project is running or paused, from a development build over any store but a copy under" + " `RAFA_EFFORT_DIR`, while a journal beside the store shows a write in flight, when a row count" + " changes, and on any refusal of the schema plan, whose text ends with the next safe step. With" + " `--output=json` the outcome is the data of the terminal result event. Starts no session.",
     args: [],
     flags: [
       {
-        name: DRY_RUN_FLAG2,
-        description: "Build and check the rebuild, print what it keeps and leaves behind, then delete it. The" + " live store is only read, so this runs beside a live loop and can be repeated.",
+        name: DRY_RUN_FLAG3,
+        description: "Build and check the migrated store, print what it applies, then delete it. The live store" + " is only read, so this runs beside a live loop and from a development build, and can be repeated.",
         type: "boolean"
       }
     ],
     examples: [
       {
-        cmd: "rafa effort fix-schema --dry-run",
-        note: "Prints what a rebuild would keep and leave behind, changing nothing."
+        cmd: "rafa effort migrate --dry-run",
+        note: "Prints what the migration applies and how it checked, changing nothing."
       },
       {
-        cmd: "rafa effort fix-schema",
-        note: "Swaps the rebuild in and prints where the original was kept."
+        cmd: "rafa effort migrate",
+        note: "Swaps the migrated store in and prints where the original was kept."
       }
     ],
     outputs: ["text", "json"],
     run: async (context) => {
-      runFixSchema(context, seams);
+      runMigrate(context, seams);
       await Promise.resolve();
     }
   };
   return Object.freeze(command);
 }
-var fix_schema_default = createFixSchemaCommand();
+var migrate_default = createMigrateCommand();
 
 // src/commands/effort/report.ts
 var report_default = wrapPhaseZeroCommand({
@@ -7671,6 +8222,113 @@ var report_default = wrapPhaseZeroCommand({
   outputs: ["text", "json"]
 }, report);
 
+// src/commands/effort/schema.ts
+import { join as join21 } from "path";
+var COMMAND_NAME8 = "rafa effort schema";
+var SCHEMA_USAGE = "rafa effort schema [--check]";
+var CHECK_FLAG = "check";
+var REFUSED_EXIT3 = 1;
+var FAILED_EXIT2 = 2;
+function listLine(name2, items) {
+  const shown = items.length === 0 ? "none" : items.join(", ");
+  return `${name2} (${String(items.length)}): ${shown}`;
+}
+function gateLine(report2) {
+  const held = report2.userVersion ?? 0;
+  const now = report2.logged ? `${String(held)} (${gateMeaning(held)})` : `${String(held)} (a count of legacy migrations: no log yet)`;
+  const next = report2.gate === null || report2.gate === report2.userVersion ? "" : `; ${String(report2.gate)} (${gateMeaning(report2.gate)}) once the next open brings it forward`;
+  return `Gate (user_version): ${now}${next}`;
+}
+function verdictLine(report2) {
+  switch (report2.status) {
+    case "absent":
+      return "No store yet: the first write creates it at this rafa's migrations.";
+    case "current":
+      return "\u2705 Current: this rafa reads and writes the store as it is.";
+    case "behind":
+      return "\u2705 Behind: the next command that opens the store brings it forward in one transaction.";
+    default:
+      return `\u274C Refused (${report2.status}): ${String(report2.refusal)}`;
+  }
+}
+function renderSchema(report2) {
+  if (!report2.exists)
+    return [`Effort store: ${report2.path}`, verdictLine(report2), `Next safe step: ${report2.nextStep}`];
+  const log = report2.logged ? "Migration log: present." : "Migration log: none; a release before the log wrote this store, and the next open adopts it.";
+  return [
+    `Effort store: ${report2.path}`,
+    log,
+    gateLine(report2),
+    listLine("Applied", report2.applied.map(({ id: id2, appliedBy }) => appliedBy === null ? id2 : `${id2} (${appliedBy})`)),
+    listLine("Pending", report2.pending),
+    listLine("Unknown", report2.unknown.map(({ id: id2, breaks, appliedBy, appliedAt }) => `${id2} (breaks ${breaks.length === 0 ? "nothing" : breaks.join(" and ")}; applied by ${appliedBy} on ${appliedAt})`)),
+    listLine("Edited", report2.edited.map(({ id: id2, recorded, expected }) => `${id2} (store ${recorded}, this rafa ${expected})`)),
+    verdictLine(report2),
+    `Next safe step: ${report2.nextStep}`
+  ];
+}
+function storePath2(context, root) {
+  try {
+    return join21(effortStoreDir(root, context.env), SQLITE_STORE_FILE_NAME);
+  } catch (error) {
+    throw new CommandExit(REFUSED_EXIT3, `\u274C ${COMMAND_NAME8}: ${messageOf(error)}`);
+  }
+}
+function runSchema(context, seams) {
+  expectNoArgument(context.args, SCHEMA_USAGE);
+  const check = readSwitch(CHECK_FLAG, context.flags[CHECK_FLAG], `Usage: ${SCHEMA_USAGE}`);
+  const path = storePath2(context, requireProject(context, COMMAND_NAME8).root);
+  let report2;
+  try {
+    report2 = readSchemaReport(path, seams);
+  } catch (error) {
+    throw new CommandExit(FAILED_EXIT2, `\u274C ${COMMAND_NAME8}: ${path} cannot be read as an effort store: ${messageOf(error)}`);
+  }
+  if (context.outputMode !== "json") {
+    for (const line of renderSchema(report2))
+      context.output.info(line);
+  }
+  if (check && report2.refused) {
+    throw new CommandExit(REFUSED_EXIT3, `\u274C ${COMMAND_NAME8} --check: this rafa refuses ${path} (${report2.status}). Next safe step: ${report2.nextStep}`);
+  }
+  if (context.outputMode === "json")
+    context.output.result(report2);
+}
+function createSchemaCommand(seams = {}) {
+  const command = {
+    name: "effort schema",
+    subject: "effort",
+    action: "schema",
+    summary: "say whether this rafa can read and write the effort store, and what to run next when it cannot",
+    description: "Opens the SQLite effort store read-only, the one under `RAFA_EFFORT_DIR` when it is set, and" + " migrates nothing. Prints the migrations it holds that this rafa knows (applied), the ones it lacks" + " (pending), the ones this rafa does not know with what they break (unknown), and the ones recorded under" + " another checksum (edited), then the legacy gate `user_version` holds and whether this rafa would use" + " the store or refuse it, and why. It ends with `Next safe step: <command>`, the command the matching" + " refusal names, or `none`. With `--check` it exits 1 when this rafa would refuse to read or to write" + " the store. Exit code 2 when the file cannot be read as a store. With `--output=json` the report, with" + " its `nextStep`, is the data of the terminal result event. Starts no session.",
+    args: [],
+    flags: [
+      {
+        name: CHECK_FLAG,
+        description: "Exit 1 when this rafa would refuse to read or to write the store; exit 0 otherwise.",
+        type: "boolean"
+      }
+    ],
+    examples: [
+      {
+        cmd: "rafa effort schema",
+        note: "Prints the store's migrations, the gate and the verdict, ending with the next safe step."
+      },
+      {
+        cmd: "rafa effort schema --check",
+        note: "The same report, exiting 1 when this rafa would refuse the store."
+      }
+    ],
+    outputs: ["text", "json"],
+    run: async (context) => {
+      runSchema(context, seams);
+      await Promise.resolve();
+    }
+  };
+  return Object.freeze(command);
+}
+var schema_default = createSchemaCommand();
+
 // src/board/roadmap-tick.ts
 var PREFIX2 = "board roadmap";
 var REPO_PATH = "{owner}/{repo}";
@@ -8037,7 +8695,7 @@ async function applyHorizonChange(board, reading, reason) {
 }
 
 // src/commands/epic/horizon-change.ts
-var TO_FLAG = "to";
+var TO_FLAG2 = "to";
 var ISSUE_NUMBER2 = /^[1-9]\d*$/u;
 var NO_ANSWERS = ["n", "no"];
 var DEFER_ACTION = Object.freeze({
@@ -8063,9 +8721,9 @@ function readHorizonLine(context, action) {
   if (!ISSUE_NUMBER2.test(word)) {
     throw lineRefusal(`"${word}" is no epic number, which is a whole number from 1`, action.usage);
   }
-  const to = readChoiceFlag(flags, TO_FLAG, action.targets, action.usage);
+  const to = readChoiceFlag(flags, TO_FLAG2, action.targets, action.usage);
   if (to === undefined)
-    throw lineRefusal(`--${TO_FLAG} is required: --${TO_FLAG}=<horizon>`, action.usage);
+    throw lineRefusal(`--${TO_FLAG2} is required: --${TO_FLAG2}=<horizon>`, action.usage);
   const reason = readTextFlag(flags, REASON_FLAG, action.usage) ?? null;
   return Object.freeze({ epic: Number(word), to, reason });
 }
@@ -8078,7 +8736,7 @@ function wrongDirection(action, change) {
     return null;
   const other = action.name === "defer" ? "promote" : "defer";
   const verb = later ? "a deferral" : "a promotion";
-  return new CommandExit(EPIC_HORIZON_REFUSAL_EXIT, `\u274C Epic ${ref2(change.epic)} stands on ${change.from}, so ${change.from} \u2192 ${change.to} is ${verb};` + ` run rafa epic ${other} ${String(change.epic)} --${TO_FLAG}=${change.to}. Nothing was changed`);
+  return new CommandExit(EPIC_HORIZON_REFUSAL_EXIT, `\u274C Epic ${ref2(change.epic)} stands on ${change.from}, so ${change.from} \u2192 ${change.to} is ${verb};` + ` run rafa epic ${other} ${String(change.epic)} --${TO_FLAG2}=${change.to}. Nothing was changed`);
 }
 function workPhrase(work) {
   return [
@@ -8265,9 +8923,9 @@ function readMoveLine(context) {
     throw lineRefusal(`Expected one issue number, got ${got}`, USAGE8);
   }
   const issue = issueNumber(word, "issue number");
-  const target = readTextFlag(flags, TO_FLAG, USAGE8);
+  const target = readTextFlag(flags, TO_FLAG2, USAGE8);
   if (target === undefined)
-    throw lineRefusal(`--${TO_FLAG} is required: --${TO_FLAG}=<epic>`, USAGE8);
+    throw lineRefusal(`--${TO_FLAG2} is required: --${TO_FLAG2}=<epic>`, USAGE8);
   const to = issueNumber(target, "epic number");
   const reason = readTextFlag(flags, REASON_FLAG, USAGE8) ?? null;
   return Object.freeze({ issue, to, reason });
@@ -8526,7 +9184,7 @@ function createEpicMoveCommand(seams = {}) {
     ],
     flags: [
       {
-        name: TO_FLAG,
+        name: TO_FLAG2,
         description: "The number of the open epic it moves to. Required.",
         type: "string",
         required: true
@@ -8955,11 +9613,11 @@ var cancel_default = createEpicCancelCommand();
 
 // src/commands/epic/close.ts
 import { randomUUID as randomUUID3 } from "crypto";
-import { join as join20 } from "path";
+import { join as join25 } from "path";
 
 // src/board/epic-template.ts
-import { existsSync as existsSync6, readFileSync as readFileSync8 } from "fs";
-import { dirname as dirname3, join as join17 } from "path";
+import { existsSync as existsSync9, readFileSync as readFileSync8 } from "fs";
+import { dirname as dirname3, join as join22 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 var MODULE_DIR2 = dirname3(fileURLToPath2(import.meta.url));
 var EPIC_TEMPLATE_FILE = "epic.md";
@@ -8968,11 +9626,11 @@ var CRITERIA_PLACEHOLDERS = Object.freeze([
 ]);
 var PLACEHOLDER_REASON = "the line is still the epic template's placeholder, so there is nothing to check";
 function epicTemplateSource(moduleDir = MODULE_DIR2) {
-  return join17(moduleDir, TEMPLATES_DIRNAME, EPIC_TEMPLATE_FILE);
+  return join22(moduleDir, TEMPLATES_DIRNAME, EPIC_TEMPLATE_FILE);
 }
 function readEpicTemplate(moduleDir = MODULE_DIR2) {
   const source = epicTemplateSource(moduleDir);
-  if (!existsSync6(source)) {
+  if (!existsSync9(source)) {
     throw new Error(`epic template: the epic issue template is missing: no file at ${source}`);
   }
   return readFileSync8(source, "utf8");
@@ -9066,8 +9724,8 @@ function renderEpicCost(cost, estimate) {
 }
 
 // src/epic/verify-plan.ts
-import { existsSync as existsSync7, readFileSync as readFileSync9 } from "fs";
-import { dirname as dirname4, join as join18 } from "path";
+import { existsSync as existsSync10, readFileSync as readFileSync9 } from "fs";
+import { dirname as dirname4, join as join23 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 var MODULE_DIR3 = dirname4(fileURLToPath3(import.meta.url));
 var VERIFY_PROMPT_FILE = "epic-verify-prompt.md";
@@ -9124,11 +9782,11 @@ function criteriaToAsk(criteria) {
   return Object.freeze(criteria.filter((criterion) => !criterion.placeholder));
 }
 function verifyPromptCandidates(moduleDir = MODULE_DIR3) {
-  return [join18(moduleDir, VERIFY_PROMPT_FILE), join18(dirname4(moduleDir), VERIFY_PROMPT_FILE)];
+  return [join23(moduleDir, VERIFY_PROMPT_FILE), join23(dirname4(moduleDir), VERIFY_PROMPT_FILE)];
 }
 function readVerifyPrompt(moduleDir = MODULE_DIR3) {
   const candidates = verifyPromptCandidates(moduleDir);
-  const found = candidates.find((candidate) => existsSync7(candidate));
+  const found = candidates.find((candidate) => existsSync10(candidate));
   if (found === undefined) {
     throw new Error(`epic verify prompt: the verification prompt is missing: no file at ${candidates.join(" or ")}`);
   }
@@ -9269,7 +9927,7 @@ function parseVerifyPlan(output, criteria) {
 
 // src/epic/verify-run.ts
 import { randomUUID as randomUUID2 } from "crypto";
-import { join as join19 } from "path";
+import { join as join24 } from "path";
 var CHECK_TOOLS = ["Read", "Grep", "Glob", "Bash"];
 var DEFAULT_VERIFY_REMOTE = "origin";
 var CHECK_PROMPT_PREFIX = "# Epic acceptance check instructions";
@@ -9278,7 +9936,7 @@ var CHECK_RESULTS = ["pass", "fail"];
 var WORKTREE_PREFIX2 = "epic-";
 var VERDICT_KIND = VERDICT_BLOCK_FENCE.slice("rafa:".length);
 function verifyWorktreePath(home, epic) {
-  return join19(home, WORKTREES_SUBDIR, `${WORKTREE_PREFIX2}${String(epic)}`);
+  return join24(home, WORKTREES_SUBDIR, `${WORKTREE_PREFIX2}${String(epic)}`);
 }
 function fetchStep(remote) {
   return { id: "fetch", args: ["fetch", remote] };
@@ -9538,7 +10196,7 @@ async function planVerification(input) {
   return Object.freeze({ status: "planned", sessionId, verdicts: reading.verdicts, issues: reading.issues });
 }
 function closeTriageFile(root, epic) {
-  return join20(root, ".rafa", `epic-${String(epic)}-close`);
+  return join25(root, ".rafa", `epic-${String(epic)}-close`);
 }
 function failedCheckArtifact(epic, criterion) {
   return `epic ${ref5(epic)} acceptance criterion: ${oneLine(criterion.text)}`;
@@ -9814,7 +10472,7 @@ function createEpicDeferCommand(seams = {}) {
     ],
     flags: [
       {
-        name: TO_FLAG,
+        name: TO_FLAG2,
         description: `The horizon it moves to: one of ${DEFER_ACTION.targets.join(", ")}. Required.`,
         type: "string",
         required: true
@@ -10050,7 +10708,7 @@ function createEpicPromoteCommand(seams = {}) {
     ],
     flags: [
       {
-        name: TO_FLAG,
+        name: TO_FLAG2,
         description: `The horizon it moves to: one of ${PROMOTE_ACTION.targets.join(", ")}. Required.`,
         type: "string",
         required: true
@@ -10075,17 +10733,17 @@ function createEpicPromoteCommand(seams = {}) {
 var promote_default = createEpicPromoteCommand();
 
 // src/commands/init.ts
-import { existsSync as existsSync10, readFileSync as readFileSync14 } from "fs";
+import { existsSync as existsSync13, readFileSync as readFileSync14 } from "fs";
 import { homedir } from "os";
-import { join as join25, relative as relative6, sep as sep4 } from "path";
+import { join as join30, relative as relative6, sep as sep4 } from "path";
 
 // src/agents/vendorable.ts
-import { readdirSync, readFileSync as readFileSync10 } from "fs";
-import { isAbsolute as isAbsolute5, join as join21 } from "path";
+import { readdirSync as readdirSync2, readFileSync as readFileSync10 } from "fs";
+import { isAbsolute as isAbsolute5, join as join26 } from "path";
 function planFiles(dir) {
   let entries;
   try {
-    entries = readdirSync(dir, { withFileTypes: true });
+    entries = readdirSync2(dir, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -10103,7 +10761,7 @@ function rafaHolds(roster, name2) {
   return item?.holders.some((holder) => holder.source === "rafa") === true;
 }
 function vendorableAgents(scan) {
-  const dir = isAbsolute5(scan.planDir) ? scan.planDir : join21(scan.repoRoot, scan.planDir);
+  const dir = isAbsolute5(scan.planDir) ? scan.planDir : join26(scan.repoRoot, scan.planDir);
   const roots = {
     repoRoot: scan.repoRoot,
     home: scan.home,
@@ -10112,7 +10770,7 @@ function vendorableAgents(scan) {
   const roster = resolveAgentRoster(roots, scan.settings);
   const found = [];
   for (const file of planFiles(dir)) {
-    const path = join21(dir, file);
+    const path = join26(dir, file);
     const markdown = readText2(path);
     if (markdown === null)
       continue;
@@ -10138,12 +10796,13 @@ function vendorableAgentWarnings(agents, root) {
 
 // src/project/gitignore.ts
 import { createHash } from "crypto";
-import { existsSync as existsSync8, mkdirSync as mkdirSync3, readFileSync as readFileSync11, writeFileSync as writeFileSync2 } from "fs";
-import { dirname as dirname5, isAbsolute as isAbsolute6, join as join22 } from "path";
+import { existsSync as existsSync11, mkdirSync as mkdirSync4, readFileSync as readFileSync11, writeFileSync as writeFileSync2 } from "fs";
+import { dirname as dirname5, isAbsolute as isAbsolute6, join as join27 } from "path";
 var GITIGNORE_FILE = ".gitignore";
 var DIGEST_NAME = "tracking.digest";
 var PRIVATE_TRIAGE = "triage/private";
-var TRACKING_DIGEST_FILE = join22(SCOPE_DIR, DIGEST_NAME);
+var CACHE_DIR = "cache";
+var TRACKING_DIGEST_FILE = join27(SCOPE_DIR, DIGEST_NAME);
 var BLOCK_BEGIN = "# >>> rafa tracking: rafa rewrites the lines up to the end marker";
 var BLOCK_END = "# <<< rafa tracking";
 var SUB_PATHS = [
@@ -10163,7 +10822,8 @@ function trackingEntry(flags) {
       `!/${SCOPE_DIR}/`,
       `${SCOPE_DIR}/${PRIVATE_TRIAGE}/`,
       `${SCOPE_DIR}/${DIGEST_NAME}`,
-      `${SCOPE_DIR}/${POSITION_FILE}`
+      `${SCOPE_DIR}/${POSITION_FILE}`,
+      `${SCOPE_DIR}/${CACHE_DIR}/`
     ];
   }
   const tracked = SUB_PATHS.filter((sub) => flags[sub.flag]).map((sub) => `!${SCOPE_DIR}/${sub.dir}/`);
@@ -10230,13 +10890,13 @@ function attempt(file, failure3, act) {
   }
 }
 function readIfPresent2(file) {
-  if (!existsSync8(file))
+  if (!existsSync11(file))
     return null;
   return attempt(file, "cannot be read", () => readFileSync11(file, "utf8"));
 }
 function writeTrackingGitignore(root, flags) {
   requireAbsolute(root);
-  const file = join22(root, GITIGNORE_FILE);
+  const file = join27(root, GITIGNORE_FILE);
   const text = readIfPresent2(file);
   const next = withTrackingBlock(text, flags, file);
   if (next === text)
@@ -10258,7 +10918,7 @@ function trackingDigest(flags) {
 }
 function exposureNotice(root) {
   return [
-    `tracking.all is true, so ${join22(root, GITIGNORE_FILE)} no longer ignores ${SCOPE_DIR}/` + " and a commit can carry what it holds, including:",
+    `tracking.all is true, so ${join27(root, GITIGNORE_FILE)} no longer ignores ${SCOPE_DIR}/` + " and a commit can carry what it holds, including:",
     "  - unpatched issues described in specs and plans",
     "  - effort rows with model names and token counts",
     "  - instincts that may quote error output",
@@ -10271,7 +10931,7 @@ function printWarning(message) {
 }
 function noticeTrackingChange(root, flags, print2 = printWarning) {
   requireAbsolute(root);
-  const digestFile = join22(root, TRACKING_DIGEST_FILE);
+  const digestFile = join27(root, TRACKING_DIGEST_FILE);
   const recorded = `${trackingDigest(flags)}
 `;
   if (readIfPresent2(digestFile) === recorded) {
@@ -10280,7 +10940,7 @@ function noticeTrackingChange(root, flags, print2 = printWarning) {
   if (flags.trackingAll)
     print2(exposureNotice(root));
   attempt(digestFile, "cannot be written", () => {
-    mkdirSync3(dirname5(digestFile), { recursive: true });
+    mkdirSync4(dirname5(digestFile), { recursive: true });
     writeFileSync2(digestFile, recorded);
   });
   return { digestFile, changed: true, printed: flags.trackingAll };
@@ -10291,12 +10951,12 @@ function applyTracking(root, flags, print2 = printWarning) {
 }
 
 // src/project/root-choice.ts
-import { resolve as resolve7 } from "path";
+import { resolve as resolve9 } from "path";
 
 // src/project/roots.ts
 import { spawnSync } from "child_process";
-import { accessSync, constants, readFileSync as readFileSync12, statSync as statSync7 } from "fs";
-import { isAbsolute as isAbsolute7, join as join23, resolve as resolve6 } from "path";
+import { accessSync, constants as constants2, readFileSync as readFileSync12, statSync as statSync8 } from "fs";
+import { isAbsolute as isAbsolute7, join as join28, resolve as resolve8 } from "path";
 var REFUSED_ROOTS = Object.freeze([
   { path: "/", why: "is the filesystem root" },
   { path: "/var", why: "holds system state" },
@@ -10317,8 +10977,8 @@ var NOT_A_REPOSITORY = "fatal: not a git repository (or any ";
 var DISK_ROOTS_FILE_SYSTEM = Object.freeze({
   ...DISK_FILE_SYSTEM,
   readFile: (path) => readFileSync12(path, "utf8"),
-  isDirectory: (path) => statSync7(path).isDirectory(),
-  assertWritable: (path) => accessSync(path, constants.W_OK)
+  isDirectory: (path) => statSync8(path).isDirectory(),
+  assertWritable: (path) => accessSync(path, constants2.W_OK)
 });
 
 class RootsError extends Error {
@@ -10359,7 +11019,7 @@ function realOrSpelled(path, fs) {
   try {
     return fs.realpath(path);
   } catch {
-    return resolve6(path);
+    return resolve8(path);
   }
 }
 function namedRoots(home, fs) {
@@ -10401,7 +11061,7 @@ function writeRefusal(given, real, fs) {
 }
 function refusalOf(given, named2, fs) {
   const resolved = resolveReal(given, fs);
-  const byName2 = namedRefusal(given, resolved.real ?? resolve6(given), named2);
+  const byName2 = namedRefusal(given, resolved.real ?? resolve8(given), named2);
   if (byName2 !== null)
     return byName2;
   if (resolved.real === null) {
@@ -10429,8 +11089,8 @@ function readManifest2(file, fs) {
   }
 }
 function readDir(dir, fs) {
-  const manifest = readManifest2(join23(dir, PACKAGE_JSON), fs);
-  const files = MONOREPO_MARKER_FILES.filter((name2) => fs.exists(join23(dir, name2)));
+  const manifest = readManifest2(join28(dir, PACKAGE_JSON), fs);
+  const files = MONOREPO_MARKER_FILES.filter((name2) => fs.exists(join28(dir, name2)));
   const markers = manifest.marks ? [PACKAGE_JSON, ...files] : files;
   return { ...manifest, dir, markers };
 }
@@ -10500,7 +11160,7 @@ function firstCandidate(found) {
   return first.refusal === null ? chosen(first.path, first.source) : problem(first.refusal.reason);
 }
 function namedRoot(typed, start2, source, seams) {
-  const path = resolve7(start2, typed);
+  const path = resolve9(start2, typed);
   const refusal9 = rootRefusal(path, seams);
   if (refusal9 !== null)
     return problem(refusal9.reason);
@@ -10541,12 +11201,14 @@ async function promptForRoot(found, prompter, seams) {
 }
 
 // src/project/scaffold.ts
-import { existsSync as existsSync9, lstatSync, mkdirSync as mkdirSync4, statSync as statSync8, writeFileSync as writeFileSync3 } from "fs";
-import { join as join24 } from "path";
+import { existsSync as existsSync12, lstatSync, mkdirSync as mkdirSync5, statSync as statSync9, writeFileSync as writeFileSync3 } from "fs";
+import { join as join29 } from "path";
 var PROJECT_TREE = Object.freeze(["specs", "plans", "runs", "effort", "instincts"]);
 var USER_TREE = Object.freeze(["instincts"]);
 var CONFIG_SETTINGS_LINES = Object.freeze([
   `# store: ${CONFIG_DEFAULTS.store}                  # sqlite | ndjson`,
+  "# effort:",
+  `#   busyTimeoutMs: ${String(CONFIG_DEFAULTS.effortBusyTimeoutMs)}          # 1..60000 ms; how long a store open waits for another process's lock`,
   "# plan:",
   `#   inject: ${CONFIG_DEFAULTS.inject}                # full | stage | task`,
   `#   dir: ${CONFIG_DEFAULTS.planDir}`,
@@ -10643,18 +11305,18 @@ class ScaffoldError extends Error {
 }
 function layoutOf2(base, tree) {
   const scope = scopeAt(base);
-  return { dirs: [scope.dir, ...tree.map((name2) => join24(scope.dir, name2))], configFile: configFilePath(base) };
+  return { dirs: [scope.dir, ...tree.map((name2) => join29(scope.dir, name2))], configFile: configFilePath(base) };
 }
 function occupied(path) {
   return lstatSync(path, { throwIfNoEntry: false }) !== undefined;
 }
 function isDirectory2(path) {
-  return statSync8(path, { throwIfNoEntry: false })?.isDirectory() === true;
+  return statSync9(path, { throwIfNoEntry: false })?.isDirectory() === true;
 }
 function directoryConflict(dir) {
   if (!occupied(dir) || isDirectory2(dir))
     return null;
-  return existsSync9(dir) ? `${dir} is not a directory` : `${dir} is a link to nothing`;
+  return existsSync12(dir) ? `${dir} is not a directory` : `${dir} is a link to nothing`;
 }
 function layoutConflicts(layout) {
   const [scopeDir, ...tree] = layout.dirs;
@@ -10662,7 +11324,7 @@ function layoutConflicts(layout) {
   if (opening !== null)
     return [opening];
   const dirs = tree.flatMap((dir) => directoryConflict(dir) ?? []);
-  const file = occupied(layout.configFile) && !existsSync9(layout.configFile) ? [`${layout.configFile} is a link to nothing`] : [];
+  const file = occupied(layout.configFile) && !existsSync12(layout.configFile) ? [`${layout.configFile} is a link to nothing`] : [];
   return [...dirs, ...file];
 }
 function scaffoldConflicts(root, home) {
@@ -10676,15 +11338,15 @@ function attempt2(path, failure3, act) {
   }
 }
 function ensureDirectory(path) {
-  if (existsSync9(path))
+  if (existsSync12(path))
     return { path, kind: "directory", change: "unchanged" };
   attempt2(path, "cannot be created", () => {
-    mkdirSync4(path, { recursive: true });
+    mkdirSync5(path, { recursive: true });
   });
   return { path, kind: "directory", change: "created" };
 }
 function ensureFile(path, text) {
-  if (existsSync9(path))
+  if (existsSync12(path))
     return { path, kind: "file", change: "unchanged" };
   attempt2(path, "cannot be written", () => {
     writeFileSync3(path, text, { encoding: "utf8", flag: "wx" });
@@ -11000,9 +11662,9 @@ function resolvedConfig2(root, home, warn3) {
   }
 }
 function checkGitignore(root, flags) {
-  const file = join25(root, GITIGNORE_FILE);
+  const file = join30(root, GITIGNORE_FILE);
   try {
-    const text = existsSync10(file) ? readFileSync14(file, "utf8") : null;
+    const text = existsSync13(file) ? readFileSync14(file, "utf8") : null;
     withTrackingBlock(text, flags, file);
   } catch (error) {
     const message = error instanceof GitignoreError ? error.message : `rafa init: ${file} cannot be read (${messageOf(error)})`;
@@ -11033,8 +11695,8 @@ function initialise(root, start2, home, context, entry) {
   checkConflicts(root.path, home);
   const config = resolvedConfig2(root.path, home, warn3);
   checkGitignore(root.path, config);
-  const configExisted = existsSync10(configFilePath(root.path));
-  const digestExisted = existsSync10(join25(root.path, TRACKING_DIGEST_FILE));
+  const configExisted = existsSync13(configFilePath(root.path));
+  const digestExisted = existsSync13(join30(root.path, TRACKING_DIGEST_FILE));
   const project = writeProjectScope(root.path);
   const tracking = applyTracking(root.path, config, warn3);
   const writes = [...project, ...trackingWrites(tracking, digestExisted), ...writeUserScope(home)];
@@ -11212,7 +11874,7 @@ function createInitCommand(seams = DEFAULT_INIT_SEAMS) {
 var init_default = createInitCommand();
 
 // src/commands/check-report.ts
-import { resolve as resolve8 } from "path";
+import { resolve as resolve10 } from "path";
 var DEFAULT_CHECK_SEAMS = Object.freeze({
   cwd: () => process.cwd()
 });
@@ -11228,7 +11890,7 @@ Usage: ${usage2}`);
     throw new CommandExit(1, `\u274C Expected one directory, and read "${extra}" as a second
 Usage: ${usage2}`);
   }
-  return resolve8(cwd(), dir);
+  return resolve10(cwd(), dir);
 }
 function readFix(value, usage2) {
   if (value === undefined || value === false || value === "false")
@@ -11245,7 +11907,7 @@ function readProjectRoot(value, usage2, cwd) {
     throw new CommandExit(1, `\u274C --project needs a path, and the line gave it none
 Usage: ${usage2}`);
   }
-  return resolve8(cwd(), value);
+  return resolve10(cwd(), value);
 }
 function reportMarker(report2) {
   if (report2.failed)
@@ -11743,7 +12405,7 @@ function createInstinctListCommand(seams = {}) {
   };
   return Object.freeze(command);
 }
-var list_default5 = createInstinctListCommand();
+var list_default6 = createInstinctListCommand();
 
 // src/commands/instinct/show.ts
 var USAGE15 = "rafa instinct show <id>";
@@ -11881,8 +12543,8 @@ function createInstinctShowCommand() {
 var show_default3 = createInstinctShowCommand();
 
 // src/commands/issue/check.ts
-import { readdirSync as readdirSync2, readFileSync as readFileSync15, statSync as statSync9 } from "fs";
-import { join as join26, resolve as resolve9 } from "path";
+import { readdirSync as readdirSync3, readFileSync as readFileSync15, statSync as statSync10 } from "fs";
+import { join as join31, resolve as resolve11 } from "path";
 var CHECK_USAGE = "rafa issue check <n> [--stamp]";
 var STAMP_FLAG = "stamp";
 var ISSUE_NUMBER6 = /^[1-9]\d*$/u;
@@ -11906,7 +12568,7 @@ function missingCopyMessage(issue, specsDir) {
 function copyNames(dir, issue) {
   let names;
   try {
-    names = readdirSync2(dir);
+    names = readdirSync3(dir);
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === "ENOENT")
       return [];
@@ -11914,22 +12576,22 @@ function copyNames(dir, issue) {
   }
   const prefix = `${boardId(issue)}-`;
   const notes = notesFileName(issue);
-  return names.filter((name2) => name2.startsWith(prefix) && name2.endsWith(SPEC_EXTENSION) && name2 !== notes).filter((name2) => name2.length > prefix.length + SPEC_EXTENSION.length).filter((name2) => statSync9(join26(dir, name2)).isFile()).sort();
+  return names.filter((name2) => name2.startsWith(prefix) && name2.endsWith(SPEC_EXTENSION) && name2 !== notes).filter((name2) => name2.length > prefix.length + SPEC_EXTENSION.length).filter((name2) => statSync10(join31(dir, name2)).isFile()).sort();
 }
 function findSavedCopy(root, specsDir, issue) {
-  const names = copyNames(resolve9(root, specsDir), issue);
+  const names = copyNames(resolve11(root, specsDir), issue);
   const [only] = names;
   if (only === undefined)
     throw new CommandExit(1, missingCopyMessage(issue, specsDir));
   if (names.length > 1) {
     throw new CommandExit(1, [
       `\u274C Issue #${String(issue)} has ${String(names.length)} saved copies under ${specsDir}; remove the stale one:`,
-      ...names.map((name2) => `   ${join26(specsDir, name2)}`)
+      ...names.map((name2) => `   ${join31(specsDir, name2)}`)
     ].join(`
 `));
   }
-  const path = join26(specsDir, only);
-  return { path, absolute: resolve9(root, path) };
+  const path = join31(specsDir, only);
+  return { path, absolute: resolve11(root, path) };
 }
 function liveText(live) {
   return live.kind === "unreadable" ? "unreadable" : fingerprintText(live);
@@ -12198,279 +12860,11 @@ function createIssueCreateCommand(seams = DEFAULT_ISSUE_SEAMS) {
 }
 var create_default = createIssueCreateCommand();
 
-// src/commands/issue/roadmap-check.ts
-var EPIC_CHECK_EXIT = 1;
-function checkHead(count2) {
-  return count2 === 1 ? "\u274C 1 epic's stored state disagrees with its computed one:" : `\u274C ${String(count2)} epics' stored states disagree with their computed ones:`;
-}
-function epicCheckFailure(epics) {
-  if (epics.unknown !== null)
-    return `\u274C Could not check the epics: ${epics.unknown}`;
-  const lines2 = epics.epics.flatMap((epic) => epic.disagreement === null ? [] : [`  ${epic.disagreement}`]);
-  if (lines2.length === 0)
-    return null;
-  return [checkHead(lines2.length), ...lines2].join(`
-`);
-}
-
-// src/commands/issue/list.ts
-var USAGE18 = "rafa issue list [--roadmap [--all] [--full] [--check]] [--state=<state>] [--type=<type>] [--module=<name>]" + " [--search=<text>] [--limit=<n>]";
-var SWITCH_HINT = `Type it bare: ${USAGE18}`;
-var LIMIT = /^[1-9]\d*$/;
-function readLimit(flags) {
-  const value = readTextFlag(flags, "limit", USAGE18);
-  if (value === undefined)
-    return;
-  const limit = Number(value);
-  if (LIMIT.test(value) && Number.isSafeInteger(limit))
-    return limit;
-  throw lineRefusal(`--limit is "${value}", expected a positive whole number`, USAGE18);
-}
-function readIssueQuery(flags) {
-  const narrowed = {
-    state: readChoiceFlag(flags, "state", ISSUE_STATES, USAGE18),
-    type: readChoiceFlag(flags, "type", ISSUE_TYPES, USAGE18),
-    module: readNonBlankFlag(flags, "module", USAGE18),
-    text: readNonBlankFlag(flags, "search", USAGE18),
-    limit: readLimit(flags)
-  };
-  return Object.fromEntries(Object.entries(narrowed).filter(([, value]) => value !== undefined));
-}
-function readIssueListLine(flags) {
-  const roadmap = readSwitch("roadmap", flags["roadmap"], SWITCH_HINT);
-  const all = readSwitch("all", flags["all"], SWITCH_HINT);
-  const full = readSwitch("full", flags["full"], SWITCH_HINT);
-  const check = readSwitch("check", flags["check"], SWITCH_HINT);
-  if (roadmap && flags["state"] !== undefined) {
-    throw lineRefusal("--state cannot narrow --roadmap: the Roadmap is read off the GitHub board, which holds an issue open or" + " closed and so no state of the tracker", USAGE18);
-  }
-  if (all && !roadmap)
-    throw lineRefusal("--all keeps the ticked Roadmap lines, so it needs --roadmap", USAGE18);
-  if (full && !roadmap)
-    throw lineRefusal("--full prints the issues of each Roadmap epic, so it needs --roadmap", USAGE18);
-  if (check && !roadmap)
-    throw lineRefusal("--check weighs the epics the board read finds, so it needs --roadmap", USAGE18);
-  return { roadmap, all, full, check };
-}
-function renderIssueList(kind, issues) {
-  const head = `Tracker: ${kind}`;
-  if (issues.length === 0)
-    return [head, "No issues."];
-  const widest = (column) => Math.max(...issues.map((issue) => column(issue).length));
-  const idWidth = widest((issue) => issue.ref.externalId);
-  const stateWidth = widest((issue) => issue.state);
-  const typeWidth = widest((issue) => issue.type);
-  const rows = issues.map((issue) => [
-    issue.ref.externalId.padStart(idWidth),
-    issue.state.padEnd(stateWidth),
-    issue.type.padEnd(typeWidth),
-    issue.title
-  ].join("  "));
-  return [head, ...rows.map((row2) => `  ${row2}`)];
-}
-function matchesFilter(row2, filter) {
-  const { issue } = row2;
-  if (filter.type !== undefined && issue?.type !== filter.type)
-    return false;
-  if (filter.module !== undefined && issue?.module !== filter.module)
-    return false;
-  if (filter.text === undefined)
-    return true;
-  const text = issue === null ? row2.line.why : `${issue.title}
-${issue.body}`;
-  return text.toLowerCase().includes(filter.text.toLowerCase());
-}
-function narrowRoadmapRows(rows, filter) {
-  const kept = rows.filter((row2) => matchesFilter(row2, filter));
-  return Object.freeze(filter.limit === undefined ? kept : kept.slice(0, filter.limit));
-}
-function renderRoadmapList(listed2, width, full = false) {
-  if (listed2.epics !== undefined) {
-    return renderEpicTable({ ...listed2.epics, roadmap: listed2.roadmap, specs: listed2.rows }, width, full);
-  }
-  const head = `Roadmap: #${String(listed2.roadmap)}`;
-  if (listed2.rows.length === 0)
-    return [head, "No issues."];
-  return [head, ...renderRoadmapTable(listed2.rows, width)];
-}
-async function listRoadmap(context, seams, all, filter) {
-  const project = issueProject(context);
-  const warn3 = (message) => {
-    context.output.warn(message);
-  };
-  const config = issueSubjectConfig(project, warn3);
-  const gh = seams.gh ?? createGhRunner({ cwd: project.root });
-  const plans = plansDirAt(project.root, config.planDir);
-  const planNames = (seams.planNames ?? createPlanDirNames)(plans.path);
-  const refs2 = async (issues) => roadmapRefsCells(await readDoctorRefs({ root: project.root, specsDir: config.specsDir, gh, env: context.env, issues }, { refsVerifier: seams.refsVerifier }));
-  let read;
-  try {
-    read = await readRoadmapEpicRows({
-      configured: config.roadmapIssue,
-      listBoards: createGhBoardLister({ gh }),
-      search: createGhRoadmapSearch({ gh }),
-      issues: createGhSpecIssueReader({ gh }),
-      board: createGhBoardListing({ gh }),
-      git: seams.git ?? createGitRunner(project.root),
-      pullRequests: createGhOpenPullRequests({ gh }),
-      planNames,
-      refs: refs2,
-      all,
-      root: project.root
-    });
-  } catch (error) {
-    const code = error instanceof CommandExit ? error.exitCode : ROADMAP_REFUSAL_EXIT;
-    throw new CommandExit(code, `\u274C Could not read the roadmap: ${messageOf(error)}`);
-  }
-  for (const warning of read.warnings)
-    warn3(warning);
-  const listed2 = {
-    roadmap: read.roadmap,
-    all,
-    filter,
-    rows: narrowRoadmapRows(read.specs, filter),
-    warnings: read.warnings
-  };
-  if (!hasEpicLines(read) && read.unknown === null)
-    return Object.freeze({ result: Object.freeze(listed2), epics: read.epics });
-  const { groups, hidden, unknown, problems } = read;
-  const result = Object.freeze({ ...listed2, epics: Object.freeze({ groups, hidden, unknown, problems }) });
-  return Object.freeze({ result, epics: read.epics });
-}
-async function listIssues(context, seams) {
-  expectNoArgument(context.args, USAGE18);
-  const query = readIssueQuery(context.flags);
-  const { tracker, data } = await resolveIssueTracker(context, seams);
-  const refs2 = await onTracker(tracker, "list issues", () => tracker.find(query));
-  const issues = await onTracker(tracker, "read the issues listed", () => Promise.all(refs2.map((ref6) => tracker.get(ref6))));
-  return { tracker: data, query, issues };
-}
-async function runIssueList(context, seams) {
-  const line = readIssueListLine(context.flags);
-  if (!line.roadmap) {
-    const listed2 = await listIssues(context, seams);
-    if (context.outputMode === "json") {
-      context.output.result(listed2);
-      return;
-    }
-    for (const text of renderIssueList(listed2.tracker.kind, listed2.issues))
-      context.output.info(text);
-    return;
-  }
-  expectNoArgument(context.args, USAGE18);
-  const filter = readIssueQuery(context.flags);
-  const { result, epics } = await listRoadmap(context, seams, line.all, filter);
-  const failure3 = line.check ? epicCheckFailure(epics) : null;
-  if (context.outputMode === "json") {
-    if (failure3 !== null)
-      throw new CommandExit(EPIC_CHECK_EXIT, failure3);
-    context.output.result(result);
-    return;
-  }
-  const width = (seams.terminalWidth ?? (() => process.stdout.columns))();
-  for (const text of renderRoadmapList(result, width, line.full))
-    context.output.info(text);
-  if (failure3 !== null)
-    throw new CommandExit(EPIC_CHECK_EXIT, failure3);
-}
-var ISSUE_LIST_FLAGS = Object.freeze([
-  {
-    name: "roadmap",
-    description: "List the unticked lines of the Roadmap issue instead, in its order, with the spec, blocked by," + " has and refs columns, and the epics it names grouped by horizon. Reads the GitHub board whatever" + " tracker the chain lands on.",
-    type: "boolean"
-  },
-  {
-    name: "all",
-    description: "With --roadmap, keep the ticked lines too, each in its place, and show the epics of every" + " horizon, not only now. Refused without --roadmap.",
-    type: "boolean"
-  },
-  {
-    name: "full",
-    description: "With --roadmap, print each epic's issues under its row, on two rows each: number, state and" + " title, then labels and blockers. Refused without --roadmap.",
-    type: "boolean"
-  },
-  {
-    name: "check",
-    description: "With --roadmap, exit 1 when any type:epic issue on the board is open with its work done, or" + " closed with it not done, or when the board could not be read, naming each. Refused without --roadmap.",
-    type: "boolean"
-  },
-  {
-    name: "state",
-    description: `Only issues in this state: one of ${ISSUE_STATES.join(", ")}. Refused on the github tracker` + " and beside --roadmap.",
-    type: "string"
-  },
-  {
-    name: "type",
-    description: `Only issues of this type: one of ${ISSUE_TYPES.join(", ")}.`,
-    type: "string"
-  },
-  {
-    name: "module",
-    description: "Only issues of this module.",
-    type: "string"
-  },
-  {
-    name: "search",
-    description: "Only issues whose title or body holds this text.",
-    type: "string"
-  },
-  {
-    name: "limit",
-    description: "At most this many issues, a positive whole number. The limit of the tracker when left out," + " and none under --roadmap.",
-    type: "number"
-  }
-]);
-function createIssueListCommand(seams = DEFAULT_ISSUE_SEAMS) {
-  const command = {
-    name: "issue list",
-    subject: "issue",
-    action: "list",
-    summary: "list the issues on the tracker, or the Roadmap's lines in its order, narrowed by type, module or text",
-    description: "Lists the issues on the tracker `tracker.default` names in `.rafa/config.yaml`, or on the first" + " `tracker.fallback` kind whose preflight passes when it fails, each kind passed over warned about." + " Prints the tracker, then one row per issue: its id, state, type and title. Each flag narrows the" + " list, and a flag left out narrows by nothing. The github tracker holds an issue open or closed, so" + " it refuses `--state`, and lists 30 issues unless `--limit` says otherwise. With `--roadmap` it lists" + " the unticked lines of the Roadmap issue (`roadmap.issue`, else the lowest-numbered open type:roadmap" + " board, else the open issue titled Roadmap) in its" + " order instead, read off the GitHub board, as a table adding four columns: spec, whether the body" + " passes the readiness gate; blocked by, each blocker and whether it is open; has, a plan, a branch" + " or a pull request already made for it; and refs, how many references of the issue's saved copy under" + " `specs.dir` read suspect or dangling, `-` with no copy. A line naming an epic prints as an epic row" + " instead, grouped by horizon under a `Roadmap #<n> \xB7 <horizon>` heading with the columns #, state," + " done/total, blocked, title and date, the now horizon only unless `--all`, and the spec rows follow" + " under Specs; `--full` prints each epic's issues under its row, on two rows each: number, state and" + " title, then labels and blockers; `--check` exits 1 when any type:epic issue's stored state" + " disagrees with its computed one. `--type`, `--module`, `--search` and `--limit` then narrow the spec rows, keeping their" + " order, and an unreachable board is warned about with the rows still printed. With `--output=json`" + " the tracker, the query and every issue, or under `--roadmap` the roadmap, the rows, the epics and the" + " warnings, are the data of the terminal result event.",
-    args: [],
-    flags: [...ISSUE_LIST_FLAGS],
-    examples: [
-      {
-        cmd: "rafa issue list",
-        note: "Lists the issues on the tracker the chain lands on, one row each."
-      },
-      {
-        cmd: "rafa issue list --type=bug --search=timeout",
-        note: "Lists the bugs whose title or body holds the word timeout."
-      },
-      {
-        cmd: "rafa issue list --limit=5 --output=json",
-        note: "Writes a start event, then a result event whose data holds the tracker, the query and five issues at most."
-      },
-      {
-        cmd: "rafa issue list --roadmap",
-        note: "Prints the Roadmap's unticked lines in its order, with the spec, blocked by, has and refs of each."
-      },
-      {
-        cmd: "rafa issue list --roadmap --full",
-        note: "Prints the Roadmap's now epics with each epic's issues underneath, then its spec lines."
-      },
-      {
-        cmd: "rafa issue list --roadmap --check",
-        note: "Prints the Roadmap, then exits 1 when an epic is open with its work done or closed with it not done."
-      },
-      {
-        cmd: "rafa issue list --roadmap --all --type=bug",
-        note: "Prints the bugs on the Roadmap, ticked lines included, in the Roadmap's order, beside its epics of every horizon."
-      }
-    ],
-    outputs: ["text", "json"],
-    run: (context) => runIssueList(context, seams)
-  };
-  return Object.freeze(command);
-}
-var list_default6 = createIssueListCommand();
-
 // src/commands/issue/move.ts
-var USAGE19 = "rafa issue move <id> <state>";
+var USAGE18 = "rafa issue move <id> <state>";
 async function moveIssue(context, seams) {
-  const [id2, word] = expectTwoArguments(context.args, USAGE19);
-  const state = readChoice(word, "The state", ISSUE_STATES, USAGE19);
+  const [id2, word] = expectTwoArguments(context.args, USAGE18);
+  const state = readChoice(word, "The state", ISSUE_STATES, USAGE18);
   const { tracker, data } = await resolveIssueTracker(context, seams);
   const ref6 = issueRef(tracker, id2);
   const moved = await onTracker(tracker, `move issue ${id2} to ${state}`, () => tracker.transition(ref6, state));
@@ -12529,7 +12923,7 @@ function createIssueMoveCommand(seams = DEFAULT_ISSUE_SEAMS) {
 var move_default2 = createIssueMoveCommand();
 
 // src/commands/issue/show.ts
-var USAGE20 = "rafa issue show <id>";
+var USAGE19 = "rafa issue show <id>";
 var NO_PRIORITY = "needs-triage";
 function renderIssue(kind, issue) {
   const project = issue.project === null ? [] : [`Project: ${issue.project}`];
@@ -12551,7 +12945,7 @@ function renderIssue(kind, issue) {
   ];
 }
 async function showIssue(context, seams) {
-  const id2 = expectOneArgument(context.args, USAGE20);
+  const id2 = expectOneArgument(context.args, USAGE19);
   const { tracker, data } = await resolveIssueTracker(context, seams);
   const issue = await onTracker(tracker, `read issue ${id2}`, () => tracker.get(issueRef(tracker, id2)));
   return { tracker: data, issue };
@@ -12941,7 +13335,7 @@ function createIssueUnblockCommand(seams = DEFAULT_UNBLOCK_SEAMS) {
 var unblock_default = createIssueUnblockCommand();
 
 // src/commands/loop/list.ts
-var USAGE21 = "rafa loop list";
+var USAGE20 = "rafa loop list";
 function renderSessionList(list) {
   if (list.sessions.length === 0)
     return ["No running sessions."];
@@ -12951,7 +13345,7 @@ function renderSessionList(list) {
   ];
 }
 async function runList5(context, seams) {
-  expectNoArgument(context.args, USAGE21);
+  expectNoArgument(context.args, USAGE20);
   const root = projectRoot(context);
   const sessions = readRecords(root, seams).filter(isLive).map((session) => {
     const checklist = readSessionChecklist(root, session);
@@ -12996,7 +13390,7 @@ function createLoopListCommand(seams = {}) {
 var list_default7 = createLoopListCommand();
 
 // src/commands/loop/pause.ts
-var USAGE22 = "rafa loop pause [-s|--session-id=<id>]";
+var USAGE21 = "rafa loop pause [-s|--session-id=<id>]";
 function renderPause(result) {
   const { session } = result;
   if (!result.changed)
@@ -13005,8 +13399,8 @@ function renderPause(result) {
   return [when, "  Nothing is marked. `rafa loop resume` goes on, and `rafa loop stop` ends the run."];
 }
 async function runPause(context, seams) {
-  expectNoArgument(context.args, USAGE22);
-  const { root, record } = pickSession(context, USAGE22, "live", seams);
+  expectNoArgument(context.args, USAGE21);
+  const { root, record } = pickSession(context, USAGE21, "live", seams);
   if (!isLive(record)) {
     throw refusal(`Session ${record.sessionId} reads ${record.state}: no run is left to pause.`);
   }
@@ -13046,7 +13440,7 @@ function createLoopPauseCommand(seams = {}) {
 var pause_default = createLoopPauseCommand();
 
 // src/commands/loop/resume.ts
-var USAGE23 = "rafa loop resume [-s|--session-id=<id>]";
+var USAGE22 = "rafa loop resume [-s|--session-id=<id>]";
 function renderResume(result) {
   const { session } = result;
   if (!result.changed)
@@ -13054,8 +13448,8 @@ function renderResume(result) {
   return [session.task === null ? `Resumed session ${session.sessionId}: it goes on with its next task.` : `Resumed session ${session.sessionId}: it goes on past its running task, line ${session.task.line}, ${session.task.text}`];
 }
 async function runResume(context, seams) {
-  expectNoArgument(context.args, USAGE23);
-  const { root, record } = pickSession(context, USAGE23, "live", seams);
+  expectNoArgument(context.args, USAGE22);
+  const { root, record } = pickSession(context, USAGE22, "live", seams);
   if (!isLive(record)) {
     throw refusal(`Session ${record.sessionId} reads ${record.state}: its run has ended, so there is nothing to resume.`, `\`rafa loop start --plan=${record.plan}\` runs its plan again as a new session, its blocked tasks first.`);
   }
@@ -13100,7 +13494,7 @@ var wrapped = wrapPhaseZeroCommand({
   subject: "loop",
   action: "start",
   summary: "run a plan task by task, then wrap up, open the PR and wait for CI",
-  description: "Walks the tracker of a plan one task at a time, each in a Claude Code session whose work" + " is committed once it exits, and retries blocked tasks first. After the last task a wrap-up" + " session promotes findings, syncs with main, pushes and opens or updates the PR, and the loop" + " then waits on its checks, spending repair sessions on a red or conflicting PR. With no" + " `--plan` it runs `PLAN.md` in `plan.dir`, `.rafa/plans` unless the config names another, or" + " `PLAN.md` at the project root when that one does not exist. Before any session it checks the" + " prerequisites the config and the plan's `PREREQUISITES-<stub>.md` name, halting when a required" + " one fails and naming each failed optional one known-missing in every task prompt. Started on" + " `main` or `master` it offers to create the plan's `feat/<stub>` from the latest" + " `origin/<base>` and run there, `--create-branch` answering that without asking, and refuses" + " the run when the offer is not taken. Each run writes its session record to `.rafa/runs/<session-id>.json`:" + " the plan, the branch, the pid, the start, the state and the running task. It refuses a plan whose" + " record names another branch, and a plan a session is still running. `rafa loop stop`, `pause`," + " `resume`, `status` and `list` reach the run through that record. A run holds its terminal: until" + " phase 6 it refuses `--detached`. With `--runtime` the whole run goes on in that installed rafa," + " never in a `src/` directory.",
+  description: "Walks the tracker of a plan one task at a time, each in a Claude Code session whose work" + " is committed once it exits, and retries blocked tasks first. After the last task a wrap-up" + " session promotes findings, syncs with main, pushes and opens or updates the PR, and the loop" + " then waits on its checks, spending repair sessions on a red or conflicting PR. With no" + " `--plan` it runs `PLAN.md` in `plan.dir`, `.rafa/plans` unless the config names another, or" + " `PLAN.md` at the project root when that one does not exist. Before any session it checks the" + " prerequisites the config and the plan's `PREREQUISITES-<stub>.md` name, halting when a required" + " one fails and naming each failed optional one known-missing in every task prompt, and warns once" + " for each migration the effort store holds that this rafa does not know and that is additive. It" + " refuses to start while `RAFA_EFFORT_DIR` is set, since a loop records to the project's own" + " store. Started on" + " `main` or `master` it offers to create the plan's `feat/<stub>` from the latest" + " `origin/<base>` and run there, `--create-branch` answering that without asking, and refuses" + " the run when the offer is not taken. Each run writes its session record to `.rafa/runs/<session-id>.json`:" + " the plan, the branch, the pid, the start, the state and the running task. It refuses a plan whose" + " record names another branch, and a plan a session is still running. `rafa loop stop`, `pause`," + " `resume`, `status` and `list` reach the run through that record. A run holds its terminal: until" + " phase 6 it refuses `--detached`. With `--runtime` the whole run goes on in that installed rafa," + " never in a `src/` directory.",
   args: [],
   flags: [
     {
@@ -13195,7 +13589,7 @@ var loopStart = Object.freeze({
 var start_default = endingWith(loopStart);
 
 // src/commands/loop/status.ts
-var USAGE24 = "rafa loop status [-s|--session-id=<id>]";
+var USAGE23 = "rafa loop status [-s|--session-id=<id>]";
 var BLOCKED_TASK_LINE = /^- \[BLOCKED\] (.+)/;
 var NO_BLOCKER = "the line trails no blocker comment";
 function blockerAt(checklist, lineNum) {
@@ -13231,8 +13625,8 @@ function renderStatus(status) {
   ];
 }
 async function runStatus(context, seams) {
-  expectNoArgument(context.args, USAGE24);
-  const { root, record } = pickSession(context, USAGE24, "live-or-newest", seams);
+  expectNoArgument(context.args, USAGE23);
+  const { root, record } = pickSession(context, USAGE23, "live-or-newest", seams);
   const checklist = readSessionChecklist(root, record);
   const tasks = checklist === null ? null : countTasks(checklist.tasks);
   let eta = null;
@@ -13285,7 +13679,7 @@ function createLoopStatusCommand(seams = {}) {
 var status_default2 = createLoopStatusCommand();
 
 // src/commands/loop/stop.ts
-var USAGE25 = "rafa loop stop [-s|--session-id=<id>]";
+var USAGE24 = "rafa loop stop [-s|--session-id=<id>]";
 function signalRun(record, interrupt) {
   try {
     interrupt(record.pid);
@@ -13338,8 +13732,8 @@ function renderStop(result) {
   ];
 }
 async function runStop(context, seams) {
-  expectNoArgument(context.args, USAGE25);
-  const { root, record } = pickSession(context, USAGE25, "live", seams);
+  expectNoArgument(context.args, USAGE24);
+  const { root, record } = pickSession(context, USAGE24, "live", seams);
   if (!isLive(record)) {
     throw refusal(`Session ${record.sessionId} reads ${record.state}: no run is left to stop.`);
   }
@@ -13390,7 +13784,7 @@ function createLoopStopCommand(seams = {}) {
 var stop_default = createLoopStopCommand();
 
 // src/commands/module/exec.ts
-var USAGE26 = "rafa module exec <module> <action> [args] [flags]";
+var USAGE25 = "rafa module exec <module> <action> [args] [flags]";
 var execCommand = {
   name: "module exec",
   subject: "module",
@@ -13419,13 +13813,13 @@ var execCommand = {
     const mounts = context.registry.mounts();
     const mounted = mounts.length === 0 ? "none is mounted; a module is mounted when allowList: names it and modules: gives its path source" : mounts.map((mount) => `${mount.name} (${context.registry.actionsOf(mountKey(mount.name)).map((held) => held.action).join(", ")})`).join(", ");
     throw new CommandExit(1, `\u274C Expected a module and one of its actions; mounted: ${mounted}
-Usage: ${USAGE26}`);
+Usage: ${USAGE25}`);
   }
 };
 var exec_default = Object.freeze(execCommand);
 
 // src/commands/module/list.ts
-var USAGE27 = "rafa module list";
+var USAGE26 = "rafa module list";
 function sourceText(source) {
   const ref6 = source.ref === null ? "" : `@${source.ref}`;
   return `${source.kind} ${source.location}${ref6}`;
@@ -13446,10 +13840,10 @@ function renderModuleList(list) {
   return ["Modules:", ...list.modules.flatMap(moduleLines)];
 }
 async function runList6(context, seams) {
-  expectNoArgument(context.args, USAGE27);
+  expectNoArgument(context.args, USAGE26);
   const { project } = context;
   if (project === null)
-    throw new CommandExit(1, `\u274C ${USAGE27} runs inside a project`);
+    throw new CommandExit(1, `\u274C ${USAGE26} runs inside a project`);
   let loaded;
   try {
     const resolved = loadConfig({ root: project.root, home: project.home });
@@ -13602,7 +13996,7 @@ function fastForwardBase(git, plan2) {
 
 // src/commands/next.ts
 var NEXT_USAGE = "rafa next [--dry-run] [--yes[=<action ids>]]";
-var DRY_RUN_FLAG3 = "dry-run";
+var DRY_RUN_FLAG4 = "dry-run";
 var STATE_MARK = "\uD83D\uDCCD";
 var PROPOSAL_MARK = "\uD83D\uDC49";
 var STOP_MARK = "\u23F9";
@@ -13623,7 +14017,7 @@ function dryRunLine(dryRun) {
   if (dryRun === "no-terminal") {
     return `${STOP_MARK} There is no terminal to answer on, so nothing ran; run rafa next where you can answer,` + ` or type --${YES_FLAG}=${BARE_YES_ACTIONS.join(",")} to allow those steps unasked.`;
   }
-  return `${STOP_MARK} --${DRY_RUN_FLAG3}: nothing ran.`;
+  return `${STOP_MARK} --${DRY_RUN_FLAG4}: nothing ran.`;
 }
 function stopLine(stop, state, ceiling, dryRun) {
   if (stop === "dry-run")
@@ -13719,14 +14113,14 @@ function lineRefusal2(problem2) {
 Usage: ${NEXT_USAGE}`);
 }
 function readDryRun(flags) {
-  const value = flags[DRY_RUN_FLAG3];
+  const value = flags[DRY_RUN_FLAG4];
   if (value === undefined)
     return false;
   if (typeof value === "boolean")
     return value;
   if (value === "true" || value === "false")
     return value === "true";
-  throw lineRefusal2(`--${DRY_RUN_FLAG3} takes no value, and read "${value}" as one`);
+  throw lineRefusal2(`--${DRY_RUN_FLAG4} takes no value, and read "${value}" as one`);
 }
 function dryRunOf(flag, ceiling, hasTerminal) {
   if (flag)
@@ -13790,7 +14184,7 @@ async function runNext(context, seams) {
 var YES_ID_LIST = YES_ACTIONS.join(", ");
 var NEXT_FLAGS = Object.freeze([
   {
-    name: DRY_RUN_FLAG3,
+    name: DRY_RUN_FLAG4,
     description: "Print where the project stands and what to do about it, and stop without asking or running it." + " A run with no terminal to answer on and no --yes does this whether or not the flag is typed.",
     type: "boolean"
   },
@@ -13928,9 +14322,9 @@ 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 resolve12 } from "path";
 var COMMAND2 = "rafa plan risk";
-var USAGE28 = "rafa plan risk [<plan>] [--strict]";
+var USAGE27 = "rafa plan risk [<plan>] [--strict]";
 var STRICT_HINT = `Type the plan first: ${COMMAND2} <plan> --strict`;
 function spawningRunners(root) {
   return { git: createGitRunner(root), gh: createGhRunner({ cwd: root }) };
@@ -13941,9 +14335,9 @@ 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([resolve12(root, planDir, DEFAULT_PLAN_FILE), resolve12(root, DEFAULT_PLAN_FILE)])];
   throw new CommandExit(1, `\u274C No plan named, and no default plan at ${lookedFor.join(" or ")}
-Usage: ${USAGE28}`);
+Usage: ${USAGE27}`);
 }
 function riskLine(finding) {
   const line = finding.line === undefined ? "" : `:${String(finding.line)}`;
@@ -14007,7 +14401,7 @@ function createPlanRiskCommand(seams = {}) {
     outputs: ["text", "json"],
     run: async (context) => {
       const strict = readSwitch("strict", context.flags["strict"], STRICT_HINT);
-      const typed = expectAtMostOneArgument(context.args, USAGE28);
+      const typed = expectAtMostOneArgument(context.args, USAGE27);
       const project = requireProject(context, COMMAND2);
       const config = resolveProjectConfig(project, COMMAND2, (message) => {
         context.output.warn(message);
@@ -14039,8 +14433,8 @@ var risk_default = createPlanRiskCommand();
 
 // src/commands/plan/show.ts
 import { readFileSync as readFileSync17 } from "fs";
-import { join as join27 } from "path";
-var USAGE29 = "rafa plan show <stub> [--tracker]";
+import { join as join32 } from "path";
+var USAGE28 = "rafa plan show <stub> [--tracker]";
 var COMMAND3 = "rafa plan show";
 function readTrackerFlag(value) {
   if (value === undefined || value === false || value === "false")
@@ -14057,9 +14451,9 @@ function showPlan(plans, stub, tracker) {
     throw new CommandExit(1, `\u274C "${stub}" is no plan stub: a stub is letters, digits, ".", "_" and "-"`);
   }
   const name2 = planFileName(stub, tracker);
-  const file = join27(plans.path, name2);
+  const file = join32(plans.path, name2);
   if (!isFile(file))
-    throw new CommandExit(1, missingText(stub, tracker, join27(plans.label, name2)));
+    throw new CommandExit(1, missingText(stub, tracker, join32(plans.label, name2)));
   const model = parsePlan(readFileSync17(file, "utf8"));
   const { header } = model;
   return {
@@ -14083,7 +14477,7 @@ function taskLine(task) {
   return `  ${checkbox(task.status)} ${task.text}`;
 }
 function renderShownPlan(shown, dirLabel) {
-  const relative7 = join27(dirLabel, planFileName(shown.stub, shown.tracker));
+  const relative7 = join32(dirLabel, planFileName(shown.stub, shown.tracker));
   const fileLabel = shown.tracker ? "Tracker" : "File";
   const lines2 = [`Plan: ${shown.stub}`, `${fileLabel}: ${relative7}`];
   if (shown.header.issue !== null)
@@ -14136,7 +14530,7 @@ var planShowCommand = {
   outputs: ["text", "json"],
   run: async (context) => {
     const tracker = readTrackerFlag(context.flags.tracker);
-    const stub = expectOneArgument(context.args, USAGE29);
+    const stub = expectOneArgument(context.args, USAGE28);
     const plans = resolvePlansDir(requireProject(context, COMMAND3), COMMAND3, (message) => {
       context.output.warn(message);
     });
@@ -14276,7 +14670,7 @@ Run rafa pr list to see the open pull requests.`, usage2);
 }
 
 // src/commands/pr/current.ts
-var USAGE30 = PR_USAGE.current;
+var USAGE29 = PR_USAGE.current;
 var SEPARATOR2 = " \u2014 ";
 function trimmedOrNull(value) {
   const trimmed = value.trim();
@@ -14307,9 +14701,9 @@ async function probeChecks(pulls, number) {
   }
 }
 async function readCurrent(context, seams) {
-  expectNoArguments(context.args, USAGE30);
+  expectNoArguments(context.args, USAGE29);
   const pr = openPrContext(context, seams);
-  const pick = await pickPullRequest(pr, null, USAGE30);
+  const pick = await pickPullRequest(pr, null, USAGE29);
   const summary = pick.summary;
   const probe = await probeChecks(pr.pulls, pick.number);
   const reading = {
@@ -14362,7 +14756,7 @@ function createPrCurrentCommand(seams = DEFAULT_PR_SEAMS) {
 var current_default = createPrCurrentCommand();
 
 // src/commands/pr/list.ts
-var USAGE31 = PR_USAGE.list;
+var USAGE30 = PR_USAGE.list;
 var UNREADABLE = "?";
 var PROBE_LIMIT = 6;
 var TITLE_WIDTH = 60;
@@ -14463,7 +14857,7 @@ async function rowOf2(pulls, pull) {
   };
 }
 async function readList(context, seams, now) {
-  expectNoArguments(context.args, USAGE31);
+  expectNoArguments(context.args, USAGE30);
   const pr = openPrContext(context, seams);
   const open = await onProvider("list the open pull requests", () => pr.pulls.list());
   const rows = await mapWithLimit(open, PROBE_LIMIT, (pull) => rowOf2(pr.pulls, pull));
@@ -14503,24 +14897,24 @@ function createPrListCommand(seams = DEFAULT_PR_SEAMS) {
 var list_default9 = createPrListCommand();
 
 // src/commands/pr/merge.ts
-import { existsSync as existsSync12, readFileSync as readFileSync19 } from "fs";
-import { join as join29 } from "path";
+import { existsSync as existsSync15, readFileSync as readFileSync19 } from "fs";
+import { join as join34 } from "path";
 
 // src/runtime/install.ts
 import {
   chmodSync,
-  copyFileSync as copyFileSync3,
-  existsSync as existsSync11,
-  mkdirSync as mkdirSync5,
-  readdirSync as readdirSync3,
+  copyFileSync as copyFileSync4,
+  existsSync as existsSync14,
+  mkdirSync as mkdirSync6,
+  readdirSync as readdirSync4,
   readFileSync as readFileSync18,
   realpathSync as realpathSync5,
   renameSync as renameSync2,
-  rmSync as rmSync3,
-  statSync as statSync10,
+  rmSync as rmSync4,
+  statSync as statSync11,
   symlinkSync
 } from "fs";
-import { basename as basename7, delimiter as delimiter2, dirname as dirname6, join as join28, relative as relative7, resolve as resolve11 } from "path";
+import { basename as basename6, delimiter as delimiter2, dirname as dirname6, join as join33, relative as relative7, resolve as resolve13 } from "path";
 var LINK_NAME = "rafa";
 var FORCE_FLAG = "--force";
 var EXIT_DONE = 0;
@@ -14581,20 +14975,20 @@ function runtimeRefusalLines(runtimeDir, version2) {
   ];
 }
 function listTrackers(repoRoot, planDir) {
-  const dir = resolve11(repoRoot, planDir);
-  return entryNames(dir).filter((entry) => TRACKER_NAME.test(entry)).sort((a, b) => a.localeCompare(b)).map((entry) => join28(dir, entry)).filter((path) => statSync10(path).isFile()).map((path) => relative7(repoRoot, path));
+  const dir = resolve13(repoRoot, planDir);
+  return entryNames(dir).filter((entry) => TRACKER_NAME.test(entry)).sort((a, b) => a.localeCompare(b)).map((entry) => join33(dir, entry)).filter((path) => statSync11(path).isFile()).map((path) => relative7(repoRoot, path));
 }
 function openTrackers(repoRoot, planDir) {
   return listTrackers(repoRoot, planDir).flatMap((path) => {
-    const task = findNextTask(readFileSync18(join28(repoRoot, path), "utf8"));
+    const task = findNextTask(readFileSync18(join33(repoRoot, path), "utf8"));
     return task ? [{ path, task }] : [];
   });
 }
 function readManifestVersion2(repoRoot) {
-  const manifest = JSON.parse(readFileSync18(join28(repoRoot, "package.json"), "utf8"));
+  const manifest = JSON.parse(readFileSync18(join33(repoRoot, "package.json"), "utf8"));
   const record = typeof manifest === "object" && manifest !== null ? manifest : {};
   if (record["name"] !== name) {
-    throw new Error(`${join28(repoRoot, "package.json")} names ${JSON.stringify(record["name"])}, not ${name}: this is no rafa checkout`);
+    throw new Error(`${join33(repoRoot, "package.json")} names ${JSON.stringify(record["name"])}, not ${name}: this is no rafa checkout`);
   }
   const version2 = record["version"];
   if (typeof version2 !== "string" || !VERSION_SHAPE.test(version2)) {
@@ -14603,12 +14997,12 @@ function readManifestVersion2(repoRoot) {
   return version2;
 }
 function copyTree(from, to) {
-  mkdirSync5(to, { recursive: true });
+  mkdirSync6(to, { recursive: true });
   let copied = 0;
-  const entries = readdirSync3(from, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+  const entries = readdirSync4(from, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
   for (const entry of entries) {
-    const source = join28(from, entry.name);
-    const target = join28(to, entry.name);
+    const source = join33(from, entry.name);
+    const target = join33(to, entry.name);
     if (entry.isDirectory()) {
       copied += copyTree(source, target);
     } else if (entry.isFile()) {
@@ -14622,23 +15016,23 @@ function copyTree(from, to) {
 }
 function replaceTree(from, to) {
   const staging = temporaryName(to);
-  rmSync3(staging, { recursive: true, force: true });
+  rmSync4(staging, { recursive: true, force: true });
   try {
     const copied = copyTree(from, staging);
     swapIn2(staging, to);
     return copied;
   } catch (err) {
-    rmSync3(staging, { recursive: true, force: true });
+    rmSync4(staging, { recursive: true, force: true });
     throw err;
   }
 }
 function swapIn2(staging, to) {
-  if (!existsSync11(to)) {
+  if (!existsSync14(to)) {
     renameSync2(staging, to);
     return;
   }
   const outgoing = `${temporaryName(to)}.outgoing`;
-  rmSync3(outgoing, { recursive: true, force: true });
+  rmSync4(outgoing, { recursive: true, force: true });
   renameSync2(to, outgoing);
   try {
     renameSync2(staging, to);
@@ -14646,17 +15040,17 @@ function swapIn2(staging, to) {
     renameSync2(outgoing, to);
     throw err;
   }
-  rmSync3(outgoing, { recursive: true, force: true });
+  rmSync4(outgoing, { recursive: true, force: true });
 }
 function relink(linkPath, target) {
-  mkdirSync5(dirname6(linkPath), { recursive: true });
+  mkdirSync6(dirname6(linkPath), { recursive: true });
   const temporary = temporaryName(linkPath);
-  rmSync3(temporary, { force: true });
+  rmSync4(temporary, { force: true });
   try {
     symlinkSync(target, temporary);
     renameSync2(temporary, linkPath);
   } catch (err) {
-    rmSync3(temporary, { force: true });
+    rmSync4(temporary, { force: true });
     throw err;
   }
   const resolved = realpathSync5(linkPath);
@@ -14703,20 +15097,20 @@ function installRuntime(seams, options = {}) {
 }
 function runInstall(seams, options) {
   const { repoRoot, home, log } = seams;
-  const runtimeRoot = join28(home, RUNTIME_SUBDIR);
-  const linkPath = join28(home, RAFA_BIN_DIR, LINK_NAME);
+  const runtimeRoot = join33(home, RUNTIME_SUBDIR);
+  const linkPath = join33(home, RAFA_BIN_DIR, LINK_NAME);
   log(`repo root: ${repoRoot}`);
   log(`runtime root: ${runtimeRoot}`);
   log(`link: ${linkPath}`);
   const version2 = inStage("manifest", () => readManifestVersion2(repoRoot));
-  const planDir = inStage("config", () => resolve11(repoRoot, loadConfig({ root: repoRoot, home }, {}, seams.warn).config.planDir));
+  const planDir = inStage("config", () => resolve13(repoRoot, loadConfig({ root: repoRoot, home }, {}, seams.warn).config.planDir));
   log(`plan dir: ${planDir}`);
   const open = inStage("trackers", () => openTrackers(repoRoot, planDir));
   if (open.length > 0)
     return { kind: "refused", reason: "trackers", planDir, trackers: open };
-  const distDir = join28(repoRoot, "dist");
-  const runtimeDir = join28(runtimeRoot, version2);
-  const installed = existsSync11(runtimeDir);
+  const distDir = join33(repoRoot, "dist");
+  const runtimeDir = join33(runtimeRoot, version2);
+  const installed = existsSync14(runtimeDir);
   if (installed && options.force !== true) {
     return { kind: "refused", reason: "runtime-exists", version: version2, runtimeDir };
   }
@@ -14724,13 +15118,13 @@ function runInstall(seams, options) {
   const code = inStage("build", () => seams.build(repoRoot));
   if (code !== 0)
     throw new StageFailure("build", `the build exited ${code}`);
-  if (!existsSync11(join28(distDir, RUNTIME_ENTRY))) {
-    throw new StageFailure("build", `the build exited 0 and left no ${join28(distDir, RUNTIME_ENTRY)}`);
+  if (!existsSync14(join33(distDir, RUNTIME_ENTRY))) {
+    throw new StageFailure("build", `the build exited 0 and left no ${join33(distDir, RUNTIME_ENTRY)}`);
   }
   log(installed ? `copying ${distDir} over ${runtimeDir}, replacing it whole` : `copying ${distDir} into ${runtimeDir}`);
   const copied = inStage("copy", () => replaceTree(distDir, runtimeDir));
   log(`copied ${copied} file(s)`);
-  const resolved = inStage("link", () => relink(linkPath, join28(runtimeDir, RUNTIME_ENTRY)));
+  const resolved = inStage("link", () => relink(linkPath, join33(runtimeDir, RUNTIME_ENTRY)));
   log(`${linkPath} resolves to ${resolved}`);
   return { kind: "done", version: version2, runtimeDir, linkPath, resolved, copied };
 }
@@ -14745,7 +15139,7 @@ function inStage(stage, run) {
 }
 function entryNames(dir) {
   try {
-    return readdirSync3(dir);
+    return readdirSync4(dir);
   } catch (err) {
     if (typeof err === "object" && err !== null && "code" in err && err.code === "ENOENT")
       return [];
@@ -14755,16 +15149,16 @@ function entryNames(dir) {
 function replaceFile(source, target) {
   const temporary = temporaryName(target);
   try {
-    copyFileSync3(source, temporary);
-    chmodSync(temporary, statSync10(source).mode & 4095);
+    copyFileSync4(source, temporary);
+    chmodSync(temporary, statSync11(source).mode & 4095);
     renameSync2(temporary, target);
   } catch (err) {
-    rmSync3(temporary, { force: true });
+    rmSync4(temporary, { force: true });
     throw err;
   }
 }
 function temporaryName(path) {
-  return join28(dirname6(path), `.${basename7(path)}.snapshot-${process.pid}`);
+  return join33(dirname6(path), `.${basename6(path)}.snapshot-${process.pid}`);
 }
 
 // src/commands/pr/merge-followups.ts
@@ -15070,7 +15464,7 @@ async function postUncheckedComment(pulls, number, unchecked, warn3) {
 }
 
 // src/commands/pr/merge.ts
-var USAGE32 = PR_USAGE.merge;
+var USAGE31 = PR_USAGE.merge;
 var REMOTE3 = "origin";
 var INDENT4 = "   ";
 var YES_ANSWERS4 = ["y", "yes"];
@@ -15149,6 +15543,16 @@ function remoteHoldsBranch(git, branch, warn3) {
   warn3(`${REMOTE3} could not be asked whether it still holds ${branch}, so it is left alone: ${gitSaid(probe2)}`);
   return false;
 }
+function localHoldsBranch(git, branch, warn3) {
+  const probe2 = git(["show-ref", "--verify", "--quiet", `refs/heads/${branch}`]);
+  if (probe2.ok)
+    return true;
+  const said = gitSaid(probe2);
+  if (said === "")
+    return false;
+  warn3(`could not read whether this checkout holds a local branch ${branch}, so its delete runs: ${said}`);
+  return true;
+}
 function textOf(path) {
   try {
     return readFileSync19(path, "utf8");
@@ -15157,7 +15561,7 @@ function textOf(path) {
   }
 }
 function followUpsFor(pr, git) {
-  const facts = readPackageFacts(textOf(join29(pr.project.root, "package.json")));
+  const facts = readPackageFacts(textOf(join34(pr.project.root, "package.json")));
   if (facts.version === null)
     return [];
   const tags = git(["tag", "--list", versionTag(facts.version)]);
@@ -15165,7 +15569,7 @@ function followUpsFor(pr, git) {
     version: facts.version,
     tagged: tags.ok && tags.stdout.trim() !== "",
     rafaCheckout: facts.rafaCheckout,
-    runtimeInstalled: existsSync12(join29(pr.project.home, RUNTIME_SUBDIR, facts.version))
+    runtimeInstalled: existsSync15(join34(pr.project.home, RUNTIME_SUBDIR, facts.version))
   });
 }
 function openGh(pr, seams) {
@@ -15226,25 +15630,34 @@ async function reportTick(context, pr, seams, detail) {
   }
   return tick;
 }
-function readyLine(base, branch, remoteBranchPresent) {
-  const remote = remoteBranchPresent ? `and ${branch} is gone locally and on ${REMOTE3}.` : `and ${branch} is gone locally; ${REMOTE3} had already deleted it.`;
-  return `${base} is checked out and pulled, ${remote}`;
+function readyLine(base, branch, present) {
+  const pulled = `${base} is checked out and pulled`;
+  if (present.local) {
+    return present.remote ? `${pulled}, and ${branch} is gone locally and on ${REMOTE3}.` : `${pulled}, and ${branch} is gone locally; ${REMOTE3} had already deleted it.`;
+  }
+  return present.remote ? `${pulled}, and ${branch} is gone on ${REMOTE3}; there was no local branch to delete.` : `${pulled}; ${branch} had no local branch, and ${REMOTE3} had already deleted it.`;
 }
 function quotedLines2(said) {
   return said === "" ? [] : said.split(`
 `).map((line) => `${INDENT4}${line}`);
 }
-function runCleanUp(context, git, detail, remoteBranchPresent) {
+function runCleanUp(context, git, detail, present) {
   const steps = cleanUpSteps({
     branch: detail.headRefName,
     base: detail.baseRefName,
     remote: REMOTE3,
-    remoteBranchPresent
+    localBranchPresent: present.local,
+    remoteBranchPresent: present.remote
   });
   const reports = [];
   for (const step of steps) {
+    if (step.skip !== undefined) {
+      reports.push({ id: step.id, label: step.label, command: commandLine(step), ok: true, skipped: true });
+      context.output.info(`${step.label}: skipped \u2014 ${step.skip}`);
+      continue;
+    }
     const result = git(step.argv.slice(1));
-    reports.push({ id: step.id, label: step.label, command: commandLine(step), ok: result.ok });
+    reports.push({ id: step.id, label: step.label, command: commandLine(step), ok: result.ok, skipped: false });
     if (result.ok) {
       context.output.info(`${step.label}: done`);
       continue;
@@ -15287,17 +15700,17 @@ async function commentIfUnchecked(context, pr, number, unchecked) {
   return posted.url;
 }
 async function runMerge(context, seams) {
-  const yes = readBooleanFlag(context.flags, "yes", USAGE32);
-  const skipChecks = readBooleanFlag(context.flags, "skip-checks", USAGE32);
-  const wanted = readMethodFlag(context.flags, USAGE32);
-  const asked = readPullArgument(context.args, USAGE32);
+  const yes = readBooleanFlag(context.flags, "yes", USAGE31);
+  const skipChecks = readBooleanFlag(context.flags, "skip-checks", USAGE31);
+  const wanted = readMethodFlag(context.flags, USAGE31);
+  const asked = readPullArgument(context.args, USAGE31);
   const pr = openPrContext(context, seams);
   const git = (seams.git ?? createGitRunner)(pr.project.root);
   const method = wanted ?? pr.mergeMethod;
-  const pick = await pickPullRequest(pr, asked, USAGE32);
+  const pick = await pickPullRequest(pr, asked, USAGE31);
   const detail = await onProvider(`read pull request #${pick.number}`, () => pr.pulls.get(pick.number));
   if (detail === null) {
-    throw lineRefusal3(`No pull request #${pick.number} at ${pr.project.root}`, USAGE32);
+    throw lineRefusal3(`No pull request #${pick.number} at ${pr.project.root}`, USAGE31);
   }
   const checks = await onProvider(`read the checks of #${pick.number}`, () => pr.pulls.checks(pick.number));
   recordPlanCi({
@@ -15340,11 +15753,15 @@ async function runMerge(context, seams) {
   context.output.info(`Merged #${detail.number} into ${detail.baseRefName} (${method}).`);
   const commentUrl = await commentIfUnchecked(context, pr, detail.number, answer2.unchecked);
   const roadmapTicks = await reportTick(context, pr, seams, detail);
-  const remoteBranchPresent = remoteHoldsBranch(git, detail.headRefName, (message) => {
+  const warn3 = (message) => {
     context.output.warn(message);
-  });
-  const steps = runCleanUp(context, git, detail, remoteBranchPresent);
-  context.output.info(readyLine(detail.baseRefName, detail.headRefName, remoteBranchPresent));
+  };
+  const present = {
+    remote: remoteHoldsBranch(git, detail.headRefName, warn3),
+    local: localHoldsBranch(git, detail.headRefName, warn3)
+  };
+  const steps = runCleanUp(context, git, detail, present);
+  context.output.info(readyLine(detail.baseRefName, detail.headRefName, present));
   const followUps = followUpsFor(pr, git);
   if (followUps.length > 0) {
     context.output.info("Follow-ups:");
@@ -15371,7 +15788,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. 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. 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" + " `--output=json` the pull request, the method, the steps that ran, the follow-ups, the roadmap tick and" + " the unblock reading 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)," + " and after the merge posts one comment on the pull request saying so. 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" + " `--output=json` the pull request, the method, the steps that ran, the follow-ups, the roadmap tick and" + " the unblock reading are the data of the terminal result event. Refuses with exit code 2 where" + " `pr.provider` is not `gh`.",
     args: [
       {
         name: "n",
@@ -15864,7 +16281,7 @@ function readLastTriage(comments) {
 }
 
 // src/commands/pr/show.ts
-var USAGE33 = PR_USAGE.show;
+var USAGE32 = PR_USAGE.show;
 var INDENT5 = "   ";
 var SHORT_SHA = 7;
 function headLine3(detail) {
@@ -15962,12 +16379,12 @@ async function probe2(call) {
   }
 }
 async function readShow(context, seams) {
-  const asked = readPullArgument(context.args, USAGE33);
+  const asked = readPullArgument(context.args, USAGE32);
   const pr = openPrContext(context, seams);
-  const pick = await pickPullRequest(pr, asked, USAGE33);
+  const pick = await pickPullRequest(pr, asked, USAGE32);
   const detail = await onProvider(`read pull request #${pick.number}`, () => pr.pulls.get(pick.number));
   if (detail === null) {
-    throw lineRefusal3(`No pull request #${pick.number} in the repository at ${pr.project.root}`, USAGE33);
+    throw lineRefusal3(`No pull request #${pick.number} in the repository at ${pr.project.root}`, USAGE32);
   }
   const checks = await probe2(() => pr.pulls.checks(pick.number));
   const comments = await probe2(() => pr.pulls.comments(pick.number));
@@ -16390,8 +16807,8 @@ function describeAge(updatedAt, now) {
     return `${plural4(hours, "hour", "hours")} ago`;
   return `${plural4(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, resolve14 = false) {
+  return resolve14 ? `rafa pr triage ${number} --resolve` : `rafa pr triage ${number}`;
 }
 function joinNumbers(pulls) {
   const names = pulls.map((pull) => `#${pull.number}`);
@@ -16402,14 +16819,14 @@ function joinNumbers(pulls) {
 function byNumber(pulls) {
   return Object.freeze([...pulls].sort((left, right) => left.number - right.number));
 }
-function skipped(pull, now, resolve12) {
+function skipped(pull, now, resolve14) {
   return Object.freeze({
     number: pull.number,
     title: pull.title,
     updatedAt: pull.updatedAt,
     age: describeAge(pull.updatedAt, now),
     fresh: isFreshCandidate(pull.updatedAt, now),
-    command: triageCommand(pull.number, resolve12)
+    command: triageCommand(pull.number, resolve14)
   });
 }
 function skippedLine(one) {
@@ -16453,15 +16870,15 @@ function listReading(rest, count2) {
   return listing("list", Object.freeze([]), rest, headline);
 }
 function selectTriagePullRequests(input) {
-  const resolve12 = input.resolve === true;
+  const resolve14 = input.resolve === true;
   const { current, now } = input;
   if (current !== null) {
     return plain("branch", Object.freeze([current]), `assessing #${current.number}, the pull request open on ${current.headRefName}`);
   }
   const candidates = byNumber(input.candidates);
   const count2 = candidates.length;
-  const lines2 = candidates.map((pull) => skipped(pull, now, resolve12));
-  if (resolve12 && count2 > 1)
+  const lines2 = candidates.map((pull) => skipped(pull, now, resolve14));
+  if (resolve14 && count2 > 1)
     return refusal12(lines2, count2);
   if (count2 === 0) {
     return plain("none", Object.freeze([]), "no red pull request to triage, and no pull request on the current branch");
@@ -16796,8 +17213,8 @@ function withTaskBudget(plan2, usd) {
 }
 
 // src/pr/plans/load.ts
-import { existsSync as existsSync13, readFileSync as readFileSync20 } from "fs";
-import { dirname as dirname7, join as join30 } from "path";
+import { existsSync as existsSync16, readFileSync as readFileSync20 } from "fs";
+import { dirname as dirname7, join as join35 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 var MODULE_DIR4 = dirname7(fileURLToPath4(import.meta.url));
 var PINNED_PLANS_DIRNAME = "plans";
@@ -16814,8 +17231,8 @@ function hasPinnedPlan(triageClass) {
 function pinnedPlanCandidates(moduleDir, triageClass) {
   const name2 = pinnedPlanFileName(triageClass);
   return [
-    join30(moduleDir, PINNED_PLANS_DIRNAME, name2),
-    join30(moduleDir, name2)
+    join35(moduleDir, PINNED_PLANS_DIRNAME, name2),
+    join35(moduleDir, name2)
   ];
 }
 function readPinnedPlan(triageClass, lookup = {}) {
@@ -16823,7 +17240,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) => existsSync13(candidate));
+  const found = candidates.find((candidate) => existsSync16(candidate));
   if (found === undefined) {
     throw new Error(`The pinned resolve plan for ${triageClass} is missing: ` + `no file at ${candidates.join(" or ")}`);
   }
@@ -16967,20 +17384,20 @@ function readAttemptRepeat(input) {
 }
 
 // src/commands/pr/resolve-loop.ts
-import { mkdirSync as mkdirSync6, writeFileSync as writeFileSync5 } from "fs";
-import { join as join31 } from "path";
-var RESOLVE_SUBDIR = join31(".rafa", "resolve");
+import { mkdirSync as mkdirSync7, writeFileSync as writeFileSync5 } from "fs";
+import { join as join36 } from "path";
+var RESOLVE_SUBDIR = join36(".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 join36(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));
+  mkdirSync7(dir, { recursive: true });
+  const path = join36(dir, pinnedPlanFileName(write.triageClass));
   writeFileSync5(path, write.plan, "utf8");
   return path;
 }
@@ -17339,7 +17756,7 @@ async function runAttempts(run, detail, first) {
 }
 
 // src/commands/pr/triage.ts
-var USAGE34 = PR_USAGE.triage;
+var USAGE33 = PR_USAGE.triage;
 var DEFAULT_MAX_ATTEMPTS = 2;
 var DETACHED_HEAD2 = "HEAD";
 var RESOLVED = false;
@@ -17380,22 +17797,22 @@ async function redPullRequests(pr) {
   }
   return red;
 }
-async function selectTargets(pr, warn3, now, resolve12) {
+async function selectTargets(pr, warn3, now, resolve14) {
   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: resolve14 });
   return selectTriagePullRequests({
     current: null,
     candidates: await redPullRequests(pr),
     now,
-    resolve: resolve12
+    resolve: resolve14
   });
 }
 async function detailOf4(pr, number) {
   const detail = await onProvider(`read pull request #${number}`, () => pr.pulls.get(number));
   if (detail === null) {
-    throw lineRefusal3(`No pull request #${number} in the repository at ${pr.project.root}`, USAGE34);
+    throw lineRefusal3(`No pull request #${number} in the repository at ${pr.project.root}`, USAGE33);
   }
   return detail;
 }
@@ -17498,14 +17915,14 @@ async function assessOne(options) {
 function refuseResolveWithoutComment(wantsResolve, wantsComment) {
   if (!wantsResolve || wantsComment)
     return;
-  throw lineRefusal3("--resolve writes the attempt count into the triage comment, and --no-comment writes none;" + " run one or the other", USAGE34);
+  throw lineRefusal3("--resolve writes the attempt count into the triage comment, and --no-comment writes none;" + " run one or the other", USAGE33);
 }
 async function runTriage(context, seams) {
-  const wantsComment = readBooleanFlag(context.flags, "comment", USAGE34, true);
-  const wantsResolve = readBooleanFlag(context.flags, "resolve", USAGE34, false);
-  const maxAttempts = readMaxAttempts(context.flags, USAGE34);
+  const wantsComment = readBooleanFlag(context.flags, "comment", USAGE33, true);
+  const wantsResolve = readBooleanFlag(context.flags, "resolve", USAGE33, false);
+  const maxAttempts = readMaxAttempts(context.flags, USAGE33);
   refuseResolveWithoutComment(wantsResolve, wantsComment);
-  const asked = readPullArgument(context.args, USAGE34);
+  const asked = readPullArgument(context.args, USAGE33);
   const pr = openPrContext(context, seams);
   const git = (seams.git ?? createGitRunner)(pr.project.root);
   const permissions = (seams.permissions ?? ghPermissionsIn)(pr.project.root);
@@ -17518,7 +17935,7 @@ async function runTriage(context, seams) {
   }
   const numbers = asked === null ? (selection?.assess ?? []).map((one) => one.number) : [asked];
   const readings = [];
-  let resolve12 = null;
+  let resolve14 = null;
   for (const number of numbers) {
     const assess = () => assessOne({
       pr,
@@ -17537,7 +17954,7 @@ async function runTriage(context, seams) {
       readings.push(reading);
       continue;
     }
-    resolve12 = await resolvePullRequest({
+    resolve14 = await resolvePullRequest({
       trust: {
         permissions,
         trustedAuthors: pr.trustedAuthors,
@@ -17558,16 +17975,16 @@ async function runTriage(context, seams) {
       ...seams.clock === undefined ? {} : { clock: seams.clock },
       ...seams.sleep === undefined ? {} : { sleep: seams.sleep }
     });
-    readings.push(resolve12.reading);
+    readings.push(resolve14.reading);
   }
   const text = [
     ...selection === null ? [] : [selection.message],
     ...readings.length === 0 ? [] : [renderTriages(readings)],
-    ...resolve12 === null ? [] : resolve12.lines
+    ...resolve14 === null ? [] : resolve14.lines
   ].join(`
 
 `);
-  return { selection, readings, resolve: resolve12, text, exitCode: resolve12?.exitCode ?? 0 };
+  return { selection, readings, resolve: resolve14, text, exitCode: resolve14?.exitCode ?? 0 };
 }
 function createPrTriageCommand(seams = DEFAULT_TRIAGE_SEAMS) {
   const command = {
@@ -17641,7 +18058,7 @@ function createPrTriageCommand(seams = DEFAULT_TRIAGE_SEAMS) {
 var triage_default = createPrTriageCommand();
 
 // src/commands/pr/view.ts
-var USAGE35 = PR_USAGE.view;
+var USAGE34 = PR_USAGE.view;
 function trimmedOrNull3(value) {
   const trimmed = value.trim();
   return trimmed === "" ? null : trimmed;
@@ -17651,9 +18068,9 @@ function renderView(number, url) {
   return url === null ? opened : `${opened}${SEPARATOR2}${url}`;
 }
 async function runView2(context, seams) {
-  const asked = readPullArgument(context.args, USAGE35);
+  const asked = readPullArgument(context.args, USAGE34);
   const pr = openPrContext(context, seams);
-  const pick = await pickPullRequest(pr, asked, USAGE35);
+  const pick = await pickPullRequest(pr, asked, USAGE34);
   await onProvider(`open pull request #${pick.number} in the browser`, () => pr.pulls.browse(pick.number));
   const url = trimmedOrNull3(pick.summary?.url ?? "");
   return {
@@ -17708,7 +18125,7 @@ function createPrViewCommand(seams = DEFAULT_PR_SEAMS) {
 var view_default = createPrViewCommand();
 
 // src/commands/pr/wait.ts
-var USAGE36 = PR_USAGE.wait;
+var USAGE35 = PR_USAGE.wait;
 var TIMEOUT_FLAG = "timeout";
 var DEFAULT_WAIT_TIMEOUT_MIN = DEFAULT_CI_TIMEOUT_MIN;
 var MS_PER_MIN = 60000;
@@ -17774,10 +18191,10 @@ function renderWait(reading) {
 `);
 }
 async function runWait(context, seams) {
-  const minutes = readTimeoutMinutes(context.flags, USAGE36);
-  const asked = readPullArgument(context.args, USAGE36);
+  const minutes = readTimeoutMinutes(context.flags, USAGE35);
+  const asked = readPullArgument(context.args, USAGE35);
   const pr = openPrContext(context, seams);
-  const pick = await pickPullRequest(pr, asked, USAGE36);
+  const pick = await pickPullRequest(pr, asked, USAGE35);
   const timeoutMs = minutes * MS_PER_MIN;
   context.output.info(`Waiting for the checks of #${pick.number}, up to ${minutes} min.`);
   const waited = await waitForChecks({
@@ -17857,12 +18274,51 @@ var wait_default = createPrWaitCommand();
 
 // src/commands/release/tag.ts
 import { readFileSync as readFileSync21 } from "fs";
-import { join as join32 } from "path";
+import { join as join37 } from "path";
+
+// src/commands/release/release-commit.ts
+function unread2(reason, message) {
+  return { commit: null, ahead: 0, problem: { reason, message } };
+}
+function versionAt(git, commit, path) {
+  const shown = git(["show", `${commit}:./${path}`]);
+  return shown.ok ? readManifestVersion(shown.stdout) : null;
+}
+function readReleaseCommit(git, path, version2) {
+  const log = git(["log", "--first-parent", "--format=%H", "HEAD", "--", `./${path}`]);
+  if (!log.ok)
+    return unread2("git", `the history of ${path} could not be read: ${gitSaid(log)}`);
+  const changed = log.stdout.split(`
+`).map((line) => line.trim()).filter((line) => line !== "");
+  if (changed.length === 0) {
+    return unread2("version", `no commit on this branch holds ${path}; commit it before tagging`);
+  }
+  let release = null;
+  let newest;
+  for (const commit of changed) {
+    const declared = versionAt(git, commit, path);
+    if (newest === undefined)
+      newest = declared;
+    if (declared !== version2)
+      break;
+    release = commit;
+  }
+  if (release === null) {
+    return unread2("version", `${path} says ${version2}, and the last commit on this branch that changed it` + ` says ${newest ?? "no version"}; commit the version before tagging it`);
+  }
+  const count2 = git(["rev-list", "--count", "--first-parent", `${release}..HEAD`]);
+  if (!count2.ok)
+    return unread2("git", `the commits past ${release} could not be counted: ${gitSaid(count2)}`);
+  return { commit: release, ahead: Number.parseInt(count2.stdout.trim(), 10), problem: null };
+}
+
+// src/commands/release/tag.ts
 var RELEASE_TAG_USAGE = "rafa release tag";
 var DEFAULT_RELEASE_BRANCH = "main";
 var DEFAULT_REGISTRY = "https://registry.npmjs.org";
 var RELEASE_REMOTE = "origin";
 var INDENT8 = "  ";
+var SHORT_COMMIT = 7;
 function readBranch2(git) {
   const result = git(["rev-parse", "--abbrev-ref", "HEAD"]);
   if (!result.ok) {
@@ -17882,7 +18338,7 @@ function textOf2(path) {
   }
 }
 function readVersion(root, configured) {
-  const resolved = join32(root, configured);
+  const resolved = join37(root, configured);
   const text = textOf2(resolved);
   if (text === null) {
     return {
@@ -17896,7 +18352,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 = join32(root, configured);
+  const resolved = join37(root, configured);
   const text = textOf2(resolved);
   if (text === null) {
     return { path: configured, version: null, problem: `the changelog could not be read at ${resolved}` };
@@ -17939,18 +18395,22 @@ function readPublishTarget(text) {
     isPrivate: fields["private"] === true
   };
 }
-function followUpsFor2(tag, version2, target) {
+var ON_HEAD = Object.freeze({ ahead: 0, branch: DEFAULT_RELEASE_BRANCH });
+function followUpsFor2(tag, version2, target, place2 = ON_HEAD) {
   const push = {
     command: `git push ${RELEASE_REMOTE} ${tag}`,
     why: `the tag is local until ${RELEASE_REMOTE} has it`
   };
   if (target.name === null || target.isPrivate)
     return [push];
+  const publishes = `publishes ${target.name}@${version2} to ${target.registry}`;
+  if (place2.ahead === 0)
+    return [push, { command: `${target.manager} publish`, why: publishes }];
   return [
     push,
     {
-      command: `${target.manager} publish`,
-      why: `publishes ${target.name}@${version2} to ${target.registry}`
+      command: `git switch --detach ${tag} && ${target.manager} publish && git switch ${place2.branch}`,
+      why: `${publishes} from the tagged commit, not HEAD; skip it if ${target.registry} has that version already`
     }
   ];
 }
@@ -17990,7 +18450,14 @@ function decideTag(inputs) {
   const disagrees = changelogRefusal(inputs, version2);
   if (disagrees !== null)
     return disagrees;
-  return { kind: "ready", version: version2, tag: versionTag(version2) };
+  const release = inputs.release;
+  if (release === null)
+    return refuse2("version", `${inputs.version.path} was not looked up in the history`);
+  if (release.problem !== null)
+    return refuse2(release.problem.reason, release.problem.message);
+  if (release.commit === null)
+    return refuse2("git", `no commit could be named for ${version2}`);
+  return { kind: "ready", version: version2, tag: versionTag(version2), commit: release.commit, ahead: release.ahead };
 }
 function projectOf9(context) {
   if (context.project === null)
@@ -18013,23 +18480,34 @@ function tagConfig(project, warn3) {
   }
 }
 function readTagInputs(root, git, config) {
+  const branch = readBranch2(git);
+  const version2 = readVersion(root, config.versionFile);
+  const walkable = version2.version !== null && branch.branch === config.releaseBranch;
   return {
     releaseBranch: config.releaseBranch,
-    branch: readBranch2(git),
-    version: readVersion(root, config.versionFile),
+    branch,
+    version: version2,
     changelog: readNewestRelease(root, config.changelog),
-    tags: readTags(git)
+    tags: readTags(git),
+    release: walkable && version2.version !== null ? readReleaseCommit(git, config.versionFile, version2.version) : null
   };
 }
-function writeTag(git, tag) {
-  const result = git(["tag", tag, "HEAD"]);
+function writeTag(git, tag, commit) {
+  const result = git(["tag", tag, commit]);
   if (result.ok)
     return;
   throw new CommandExit(1, `\u274C ${tag} could not be written: ${gitSaid(result)}`);
 }
+function pastReleaseWarning(written, branch) {
+  if (written.ahead === 0)
+    return null;
+  const commits = written.ahead === 1 ? "1 commit" : `${String(written.ahead)} commits`;
+  return `HEAD of ${branch} is ${commits} past ${written.commit.slice(0, SHORT_COMMIT)}, where ${written.version}` + ` was set; they are not in ${written.tag}.`;
+}
 function renderTagged(written, branch, followUps) {
+  const where = written.ahead === 0 ? `the HEAD of ${branch}` : `${written.commit.slice(0, SHORT_COMMIT)}, the commit of ${branch} that set ${written.version}`;
   return [
-    `\u2705 Tagged ${written.tag} at the HEAD of ${branch}.`,
+    `\u2705 Tagged ${written.tag} at ${where}.`,
     "Next:",
     ...followUps.map((followUp2) => `${INDENT8}${followUp2.command} \u2014 ${followUp2.why}`)
   ];
@@ -18047,8 +18525,9 @@ function runTag(context, seams = DEFAULT_RELEASE_SEAMS) {
     throw new CommandExit(1, `\u274C ${decision.message}
 Usage: ${RELEASE_TAG_USAGE}`);
   }
-  writeTag(git, decision.tag);
-  const followUps = followUpsFor2(decision.tag, decision.version, readPublishTarget(inputs.version.text));
+  writeTag(git, decision.tag, decision.commit);
+  const place2 = { ahead: decision.ahead, branch: config.releaseBranch };
+  const followUps = followUpsFor2(decision.tag, decision.version, readPublishTarget(inputs.version.text), place2);
   return { inputs, written: decision, followUps };
 }
 function createReleaseTagCommand(seams = DEFAULT_RELEASE_SEAMS) {
@@ -18056,8 +18535,8 @@ function createReleaseTagCommand(seams = DEFAULT_RELEASE_SEAMS) {
     name: "release tag",
     subject: "release",
     action: "tag",
-    summary: "tag the release branch's HEAD with the version both release files agree on",
-    description: "Writes `v<version>` on the HEAD of the release branch \u2014 `pr.base`, or `main` \u2014 when the" + " version `release.versionFile` declares is the one the newest section of `release.changelog` names." + " It refuses, and writes nothing, when another branch is checked out, when a tag already names that" + " version, when the two files disagree, and when either the version file or the tag list could not" + " be read. After the tag it prints what to run next: the push that puts the tag on the remote, and" + " the publish line for the registry the version file configures, which it does not run. With" + " `--output=json` the readings, the decision and the follow-ups are the data of the terminal result" + " event.",
+    summary: "tag the commit that set the version both release files agree on",
+    description: "Writes `v<version>` on the release branch \u2014 `pr.base`, or `main` \u2014 when the" + " version `release.versionFile` declares is the one the newest section of `release.changelog` names." + " The tag goes on the commit that set that version: HEAD, or, where later commits landed on the branch," + " the earlier commit, with a warning naming how many commits HEAD is past it." + " It refuses, and writes nothing, when another branch is checked out, when a tag already names that" + " version, when the two files disagree, when no commit holds the version yet, and when the version" + " file, the tag list or the history could not be read. After the tag it prints what to run next: the" + " push that puts the tag on the remote, and the publish line for the registry the version file" + " configures, spelled to publish from the tag when HEAD is past it, which it does not run. With" + " `--output=json` the readings, the decision and the follow-ups are the data of the terminal result" + " event.",
     args: [],
     flags: [],
     examples: [
@@ -18073,6 +18552,9 @@ function createReleaseTagCommand(seams = DEFAULT_RELEASE_SEAMS) {
     outputs: ["text", "json"],
     run: async (context) => {
       const result = runTag(context, seams);
+      const past = pastReleaseWarning(result.written, result.inputs.releaseBranch);
+      if (past !== null)
+        context.output.warn(past);
       if (context.outputMode === "json") {
         context.output.result(result);
         return;
@@ -18095,7 +18577,7 @@ function createRoadmapCommand(seams = DEFAULT_ISSUE_SEAMS) {
     subject: "roadmap",
     action: "roadmap",
     summary: "list the Roadmap's lines in its order, with spec, blocked by, has and refs",
-    description: "Runs `rafa issue list --roadmap` with the flags typed: the unticked lines of the Roadmap issue" + " (the current place's board, the one `rafa switch` moved to; with no position file `roadmap.issue`," + " else the lowest-numbered open type:roadmap board, else the open issue titled Roadmap) in its order," + " read off the GitHub board, as a" + " table with four columns the plain list has not got: spec, whether the body passes the readiness" + " gate; blocked by, each blocker and whether it is open; has, a plan, a branch or a pull request" + " already made for it; and refs, how many references of the issue's saved copy under `specs.dir` read" + " suspect or dangling, `-` with no copy. A line naming an epic prints as an epic row instead, grouped" + " by horizon under a `Roadmap #<n> \xB7 <horizon>` heading with the columns #, state, done/total, blocked," + " title and date, and the spec rows follow under Specs. `--full` prints each epic's issues under its" + " row, on two rows each: number, state and title, then labels and blockers. `--check` exits 1 when any" + " type:epic issue's stored state disagrees with its computed one, or the board could not be read, so CI" + " can run it. `--all` keeps the ticked lines and shows the" + " epics of every horizon, not only now, and `--type`, `--module`, `--search` and `--limit` narrow the" + " spec rows, keeping their order. An unreachable board is warned about with the rows still printed." + " With `--output=json` the roadmap, the rows, the epics and the warnings are the data of the terminal" + " result event.",
+    description: "Runs `rafa issue list --roadmap` with the flags typed: the unticked lines of the Roadmap issue" + " (the current place's board, the one `rafa switch` moved to; with no position file `roadmap.issue`," + " else the lowest-numbered open type:roadmap board, else the open issue titled Roadmap) in its order," + " read off the GitHub board, as a" + " table with four columns the plain list has not got: spec, whether the issue can be planned (every" + " section of the spec template filled, and the spec:ready label on it), as a symbol; blocked by, the" + " blockers grouped by whether they are still open; has, a plan, a branch" + " or a pull request already made for it; and refs, how many references of the issue's saved copy under" + " `specs.dir` read suspect or dangling, `-` with no copy. A legend under the table names each symbol" + " in plain words, one line per column," + " and `--texts` (`-t`) spells both columns in words instead. Labels are no column: `--labels` prints" + " them on a row under each issue. A Roadmap naming epics prints them alone, grouped by horizon under a" + " `Roadmap #<n> \xB7 <horizon>` heading with the columns #, state, done/total, blocked, date and title," + " and one line counts the lines naming no epic. `--full` prints each epic's issues under its row, a" + " second row led by \u2514\u2192 for a member's blockers, and the lines naming no epic as the issue table. The" + " board listing is kept under .rafa/cache/ and read for what changed since; `--refresh` reads the whole" + " board again. `--check` exits 1 when any" + " type:epic issue's stored state disagrees with its computed one, or the board could not be read, so CI" + " can run it. `--all` keeps the ticked lines and shows the" + " epics of every horizon, not only now, and `--type`, `--module`, `--search` and `--limit` narrow the" + " spec rows, keeping their order. An unreachable board is warned about with the rows still printed." + " With `--output=json` the roadmap, the rows, the epics and the warnings are the data of the terminal" + " result event.",
     args: [],
     flags: [...ROADMAP_FLAGS],
     examples: [
@@ -18111,6 +18593,14 @@ function createRoadmapCommand(seams = DEFAULT_ISSUE_SEAMS) {
         cmd: "rafa roadmap --full",
         note: "Prints the now epics with each epic's issues underneath, then the spec lines."
       },
+      {
+        cmd: "rafa roadmap --labels --texts",
+        note: "Prints each line's labels on a row under it, and the spec and blocked by columns in words."
+      },
+      {
+        cmd: "rafa roadmap --refresh",
+        note: "Reads the whole board again instead of only what changed since the kept listing."
+      },
       {
         cmd: "rafa roadmap --check",
         note: "Prints the Roadmap, then exits 1 when an epic is open with its work done or closed with it not done."
@@ -18129,14 +18619,14 @@ var roadmap_default = createRoadmapCommand();
 
 // src/commands/self-update.ts
 var DEFAULT_SELF_UPDATE_SEAMS = Object.freeze({ build: runBuild });
-var USAGE37 = "rafa self-update [--force]";
+var USAGE36 = "rafa self-update [--force]";
 function readForceFlag(value) {
   if (value === undefined || value === false || value === "false")
     return false;
   if (value === true || value === "true")
     return true;
   throw new CommandExit(1, `\u274C --force takes no value, and read "${value}" as one
-Usage: ${USAGE37}`);
+Usage: ${USAGE36}`);
 }
 function projectOf10(context) {
   if (context.project === null)
@@ -18144,7 +18634,7 @@ function projectOf10(context) {
   return context.project;
 }
 async function runSelfUpdate(context, seams) {
-  expectNoArgument(context.args, USAGE37);
+  expectNoArgument(context.args, USAGE36);
   const force = readForceFlag(context.flags["force"]);
   const project = projectOf10(context);
   const info2 = (line) => context.output.info(line);
@@ -18202,17 +18692,17 @@ function createSelfUpdateCommand(seams = DEFAULT_SELF_UPDATE_SEAMS) {
 var self_update_default = createSelfUpdateCommand();
 
 // src/commands/skill/backfill.ts
-import { statSync as statSync12 } from "fs";
-import { join as join37, resolve as resolve14 } from "path";
+import { statSync as statSync13 } from "fs";
+import { join as join42, resolve as resolve16 } from "path";
 
 // src/backfill/backup.ts
-import { copyFileSync as copyFileSync4, existsSync as existsSync14, mkdirSync as mkdirSync7 } from "fs";
-import { dirname as dirname8, isAbsolute as isAbsolute8, join as join34, relative as relative8, resolve as resolve12, sep as sep5 } from "path";
+import { copyFileSync as copyFileSync5, existsSync as existsSync17, mkdirSync as mkdirSync8 } from "fs";
+import { dirname as dirname8, isAbsolute as isAbsolute8, join as join39, relative as relative8, resolve as resolve14, sep as sep5 } from "path";
 
 // src/backfill/proposal-file.ts
-import { readdirSync as readdirSync4, readFileSync as readFileSync22 } from "fs";
-import { join as join33 } from "path";
-var BACKFILL_PATH = join33(".rafa", "backfill");
+import { readdirSync as readdirSync5, readFileSync as readFileSync22 } from "fs";
+import { join as join38 } from "path";
+var BACKFILL_PATH = join38(".rafa", "backfill");
 var PROPOSAL_FILE_PREFIX = "proposals-";
 var PROPOSAL_FILE_EXTENSION = ".yaml";
 var SHA256_PATTERN = /^[0-9a-f]{64}$/;
@@ -18238,7 +18728,7 @@ var PROPOSAL_FILE_HEADER = [
 ].join(`
 `);
 function proposalPath(dir, batch) {
-  return join33(dir, `${PROPOSAL_FILE_PREFIX}${String(batch).padStart(2, "0")}${PROPOSAL_FILE_EXTENSION}`);
+  return join38(dir, `${PROPOSAL_FILE_PREFIX}${String(batch).padStart(2, "0")}${PROPOSAL_FILE_EXTENSION}`);
 }
 function isProposalFileName(name2) {
   return name2.startsWith(PROPOSAL_FILE_PREFIX) && name2.endsWith(PROPOSAL_FILE_EXTENSION);
@@ -18325,7 +18815,7 @@ function parseRow(value, index) {
     note: filledStringAt(value, "note")
   };
 }
-function unreadable(problem2) {
+function unreadable2(problem2) {
   return { file: null, problem: problem2 };
 }
 function parseHeader(data) {
@@ -18344,15 +18834,15 @@ function numberAt(data, key) {
 function parseProposalFile(text) {
   const parsed = readYamlMapping(text);
   if (parsed === null)
-    return unreadable("the file holds no YAML mapping");
+    return unreadable2("the file holds no YAML mapping");
   const headerProblem = parseHeader(parsed);
   if (headerProblem !== null)
-    return unreadable(headerProblem);
+    return unreadable2(headerProblem);
   const rows = [];
   for (const [index, value] of parsed["rows"].entries()) {
     const row2 = parseRow(value, index);
     if (typeof row2 === "string")
-      return unreadable(row2);
+      return unreadable2(row2);
     rows.push(row2);
   }
   return {
@@ -18369,34 +18859,34 @@ function parseProposalFile(text) {
 function readProposalFiles(dir) {
   let names;
   try {
-    names = readdirSync4(dir);
+    names = readdirSync5(dir);
   } catch {
     return [];
   }
   return names.filter((name2) => isProposalFileName(name2)).sort((left, right) => left.localeCompare(right)).map((name2) => {
-    const path = join33(dir, name2);
+    const path = join38(dir, name2);
     try {
       return { path, result: parseProposalFile(readFileSync22(path, "utf8")) };
     } catch (error) {
-      return { path, result: unreadable(`the file cannot be read (${error instanceof Error ? error.message : String(error)})`) };
+      return { path, result: unreadable2(`the file cannot be read (${error instanceof Error ? error.message : String(error)})`) };
     }
   });
 }
 
 // src/backfill/backup.ts
-var BACKUP_PATH = join34(BACKFILL_PATH, "backup");
+var BACKUP_PATH = join39(BACKFILL_PATH, "backup");
 var BACKUP_KINDS = ["copied", "kept", "tracked", "outside", "missing"];
 function backupDirectory(base) {
-  return join34(base, BACKUP_PATH);
+  return join39(base, BACKUP_PATH);
 }
 function isUnder(root, path) {
-  const step = relative8(resolve12(root), resolve12(path));
+  const step = relative8(resolve14(root), resolve14(path));
   return step === "" || !step.startsWith(`..${sep5}`) && step !== ".." && !isAbsolute8(step);
 }
 function backupPathFor(path, root, backupDir) {
   if (!isUnder(root, path))
     return null;
-  return join34(backupDir, relative8(resolve12(root), resolve12(path)));
+  return join39(backupDir, relative8(resolve14(root), resolve14(path)));
 }
 function backupFile(path, options) {
   if (options.repoRoot !== null && isUnder(options.repoRoot, path)) {
@@ -18405,12 +18895,12 @@ function backupFile(path, options) {
   const backup = backupPathFor(path, options.root, options.backupDir);
   if (backup === null)
     return { path, kind: "outside", backup: null };
-  if (!existsSync14(path))
+  if (!existsSync17(path))
     return { path, kind: "missing", backup: null };
-  if (existsSync14(backup))
+  if (existsSync17(backup))
     return { path, kind: "kept", backup };
-  mkdirSync7(dirname8(backup), { recursive: true });
-  copyFileSync4(path, backup);
+  mkdirSync8(dirname8(backup), { recursive: true });
+  copyFileSync5(path, backup);
   return { path, kind: "copied", backup };
 }
 function backupFiles(paths, options) {
@@ -18433,7 +18923,7 @@ function countBackups(results) {
 
 // src/backfill/derive.ts
 import { readFileSync as readFileSync23, writeFileSync as writeFileSync6 } from "fs";
-import { basename as basename8 } from "path";
+import { basename as basename7 } from "path";
 var DERIVED_FIELDS = ["stack", "paths", "when_to_use"];
 function renderWhenToUse(trigger, prevents) {
   return `${sentenceEnded(trigger)} Prevents: ${prevents}`;
@@ -18550,8 +19040,8 @@ function fileChanges(name2, data, body, options) {
   return { changes, notes };
 }
 function planFile(entry, options) {
-  if (basename8(entry.path) !== SKILL_FILE) {
-    return inert(entry, "skipped", `${basename8(entry.path)} is no ${SKILL_FILE}, so it registers no skill`);
+  if (basename7(entry.path) !== SKILL_FILE) {
+    return inert(entry, "skipped", `${basename7(entry.path)} is no ${SKILL_FILE}, so it registers no skill`);
   }
   if (entry.name === null) {
     return inert(entry, "skipped", "its place implies no skill name, so no stack can be derived from it");
@@ -19038,8 +19528,8 @@ function parseSessionAnswer(stdout) {
 }
 
 // src/backfill/propose.ts
-import { mkdirSync as mkdirSync8, readFileSync as readFileSync25, writeFileSync as writeFileSync7 } from "fs";
-import { join as join35, resolve as resolve13 } from "path";
+import { mkdirSync as mkdirSync9, readFileSync as readFileSync25, writeFileSync as writeFileSync7 } from "fs";
+import { join as join40, resolve as resolve15 } from "path";
 var PROPOSAL_ACTION_KINDS = [
   "applied",
   "unchanged",
@@ -19118,7 +19608,7 @@ async function runProposalPass(options) {
   const batches = batchCandidates(candidates);
   const written = [];
   if (batches.length > 0)
-    mkdirSync8(options.backfillDir, { recursive: true });
+    mkdirSync9(options.backfillDir, { recursive: true });
   for (const [index, batch] of batches.entries()) {
     const number = index + 1;
     const file = await runProposalBatch(number, batch, options);
@@ -19188,7 +19678,7 @@ function writeRow(path, row2, original, options) {
   };
 }
 function applyRow(root, row2, options) {
-  const path = join35(root, ...row2.path.split("/"));
+  const path = join40(root, ...row2.path.split("/"));
   if (row2.status === UNANSWERED_ROW) {
     return inert2(path, row2, "unanswered", row2.note ?? "the row carries no answer");
   }
@@ -19211,7 +19701,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 resolve15(file.skills) === resolve15(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]));
@@ -19225,7 +19715,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(join35(root, ...row2.path.split("/")), row2, "refused", refusal13);
+      const action = refusal13 === null ? applyRow(root, row2, options) : inert2(join40(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;
@@ -19236,13 +19726,13 @@ function applyProposals(files, root, options) {
 }
 
 // src/demote/select.ts
-import { readdirSync as readdirSync5, readFileSync as readFileSync26, realpathSync as realpathSync6, statSync as statSync11 } from "fs";
-import { basename as basename9, dirname as dirname9, join as join36 } from "path";
+import { readdirSync as readdirSync6, readFileSync as readFileSync26, realpathSync as realpathSync6, statSync as statSync12 } from "fs";
+import { basename as basename8, dirname as dirname9, join as join41 } from "path";
 var SKILLS_DIRECTORY = "skills";
 var CLAUDE_DIRECTORY = ".claude";
 var AUTO_EXTRACTED_ORIGIN = "auto-extracted";
-var DEMOTED_PATH = join36(".rafa", "demoted");
-var INSTINCTS_PATH = join36(".rafa", "instincts");
+var DEMOTED_PATH = join41(".rafa", "demoted");
+var INSTINCTS_PATH = join41(".rafa", "instincts");
 var REPORT_FILE = "report.md";
 function realOrSelf(path) {
   try {
@@ -19259,25 +19749,25 @@ function samePath(left, right) {
   return resolved === other || resolved.toLowerCase() === other.toLowerCase();
 }
 function resolveDemotionScope(dir, home) {
-  if (basename9(dir) !== SKILLS_DIRECTORY)
+  if (basename8(dir) !== SKILLS_DIRECTORY)
     return null;
   const claude = dirname9(dir);
-  if (basename9(claude) !== CLAUDE_DIRECTORY)
+  if (basename8(claude) !== CLAUDE_DIRECTORY)
     return null;
   const base = dirname9(claude);
-  const demotedDir = join36(base, DEMOTED_PATH);
+  const demotedDir = join41(base, DEMOTED_PATH);
   return {
     scope: samePath(base, home) ? "user" : "project",
     dir,
     base,
     demotedDir,
-    instinctsDir: join36(base, INSTINCTS_PATH),
-    reportPath: join36(demotedDir, REPORT_FILE)
+    instinctsDir: join41(base, INSTINCTS_PATH),
+    reportPath: join41(demotedDir, REPORT_FILE)
   };
 }
 function entryKind(path) {
   try {
-    const stats = statSync11(path);
+    const stats = statSync12(path);
     if (stats.isFile())
       return "file";
     if (stats.isDirectory())
@@ -19289,7 +19779,7 @@ function entryKind(path) {
 }
 function visibleNames(dir) {
   try {
-    return readdirSync5(dir).filter((name2) => !name2.startsWith(".")).sort((left, right) => left.localeCompare(right));
+    return readdirSync6(dir).filter((name2) => !name2.startsWith(".")).sort((left, right) => left.localeCompare(right));
   } catch {
     return [];
   }
@@ -19299,7 +19789,7 @@ function readSelected(absolute, path, entries) {
   let mtime;
   try {
     text = readFileSync26(absolute, "utf8");
-    mtime = statSync11(absolute).mtime.toISOString();
+    mtime = statSync12(absolute).mtime.toISOString();
   } catch {
     return null;
   }
@@ -19314,14 +19804,14 @@ function selectsLearned(text, scope) {
   return origin === AUTO_EXTRACTED_ORIGIN;
 }
 function selectLearned(scope) {
-  const dir = join36(scope.dir, LEARNED_DIRECTORY);
+  const dir = join41(scope.dir, LEARNED_DIRECTORY);
   if (entryKind(dir) !== "directory")
     return [];
   const selected = [];
   for (const name2 of visibleNames(dir)) {
     if (!name2.endsWith(MARKDOWN_EXTENSION) || name2 === MARKDOWN_EXTENSION)
       continue;
-    const absolute = join36(dir, name2);
+    const absolute = join41(dir, name2);
     if (entryKind(absolute) !== "file")
       continue;
     const file = readSelected(absolute, `${LEARNED_DIRECTORY}/${name2}`, undefined);
@@ -19335,10 +19825,10 @@ function selectSkillFiles(scope) {
   for (const name2 of visibleNames(scope.dir)) {
     if (name2 === LEARNED_DIRECTORY)
       continue;
-    const skillDir = join36(scope.dir, name2);
+    const skillDir = join41(scope.dir, name2);
     if (entryKind(skillDir) !== "directory")
       continue;
-    const absolute = join36(skillDir, SKILL_FILE);
+    const absolute = join41(skillDir, SKILL_FILE);
     if (entryKind(absolute) !== "file")
       continue;
     const file = readSelected(absolute, `${name2}/${SKILL_FILE}`, visibleNames(skillDir));
@@ -19386,7 +19876,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 resolve16(cwd(), dir);
 }
 function readConsumerRoot(value, cwd) {
   if (value === undefined || value === false)
@@ -19395,11 +19885,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 resolve16(cwd(), value);
 }
 function isDirectory3(path) {
   try {
-    return statSync12(path).isDirectory();
+    return statSync13(path).isDirectory();
   } catch {
     return false;
   }
@@ -19523,7 +20013,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) => join37(root, ...row2.path.split("/"))));
+  return files.flatMap((file) => file.status !== REVIEWED_FILE ? [] : file.rows.filter((row2) => row2.status === ANSWERED_ROW).map((row2) => join42(root, ...row2.path.split("/"))));
 }
 function runApply(context, scope, backfillDir, projectRoot3) {
   const options = checkOptions(context, projectRoot3);
@@ -19569,7 +20059,7 @@ async function runBackfill(context, seams) {
   const dir = readBackfillDirectory(context.args, seams.cwd);
   const projectRoot3 = readConsumerRoot(context.flags["project"], seams.cwd);
   const scope = backfillScopeOf(dir, projectOf11(context).home);
-  const backfillDir = join37(scope.base, BACKFILL_PATH);
+  const backfillDir = join42(scope.base, BACKFILL_PATH);
   if (mode === "propose") {
     await runPropose(context, scope, backfillDir, seams);
     return;
@@ -19683,13 +20173,13 @@ function createSkillCheckCommand(seams = DEFAULT_CHECK_SEAMS) {
 var check_default3 = createSkillCheckCommand();
 
 // src/commands/skill/demote.ts
-import { existsSync as existsSync16, mkdirSync as mkdirSync10, readFileSync as readFileSync28, statSync as statSync14, writeFileSync as writeFileSync9 } from "fs";
-import { dirname as dirname11, resolve as resolve15 } from "path";
+import { existsSync as existsSync19, mkdirSync as mkdirSync11, readFileSync as readFileSync28, statSync as statSync15, writeFileSync as writeFileSync9 } from "fs";
+import { dirname as dirname11, resolve as resolve17 } from "path";
 
 // src/demote/apply.ts
-import { copyFileSync as copyFileSync5, existsSync as existsSync15, mkdirSync as mkdirSync9, mkdtempSync as mkdtempSync2, readdirSync as readdirSync6, readFileSync as readFileSync27, renameSync as renameSync3, rmSync as rmSync4, statSync as statSync13, unlinkSync, writeFileSync as writeFileSync8 } from "fs";
+import { copyFileSync as copyFileSync6, existsSync as existsSync18, mkdirSync as mkdirSync10, mkdtempSync as mkdtempSync2, readdirSync as readdirSync7, readFileSync as readFileSync27, renameSync as renameSync3, rmSync as rmSync5, statSync as statSync14, unlinkSync, writeFileSync as writeFileSync8 } from "fs";
 import { tmpdir as tmpdir2 } from "os";
-import { dirname as dirname10, join as join38 } from "path";
+import { dirname as dirname10, join as join43 } from "path";
 var DEMOTION_ACTION_KINDS = [
   "demoted",
   "kept",
@@ -19710,18 +20200,18 @@ function learnedSkillName(path) {
   return base.slice(0, -MARKDOWN_EXTENSION.length);
 }
 function sourcePath(scope, path) {
-  return join38(scope.dir, ...path.split("/"));
+  return join43(scope.dir, ...path.split("/"));
 }
 function demotedPath(scope, path) {
-  return join38(scope.demotedDir, ...path.split("/"));
+  return join43(scope.demotedDir, ...path.split("/"));
 }
 function promotedPath(scope, path) {
-  return join38(scope.dir, learnedSkillName(path), SKILL_FILE);
+  return join43(scope.dir, learnedSkillName(path), SKILL_FILE);
 }
 function takenInstinctIds(dir) {
   let names;
   try {
-    names = readdirSync6(dir);
+    names = readdirSync7(dir);
   } catch {
     return [];
   }
@@ -19729,7 +20219,7 @@ function takenInstinctIds(dir) {
 }
 function readText4(path) {
   try {
-    return statSync13(path).isFile() ? readFileSync27(path, "utf8") : null;
+    return statSync14(path).isFile() ? readFileSync27(path, "utf8") : null;
   } catch {
     return null;
   }
@@ -19757,7 +20247,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 (existsSync15(to) || existsSync15(dirname10(to))) {
+  if (existsSync18(to) || existsSync18(dirname10(to))) {
     return inert3(row2.path, "procedure", "refused", `kept as a skill, but ${to} is already there`);
   }
   return {
@@ -19771,7 +20261,7 @@ function planKept(scope, row2, file) {
   };
 }
 function checkCandidate(dir, id2, text, pathDirs) {
-  const path = join38(dir, `${id2}${MARKDOWN_EXTENSION}`);
+  const path = join43(dir, `${id2}${MARKDOWN_EXTENSION}`);
   writeFileSync8(path, text, "utf8");
   const report3 = checkFile(path, "instinct", { projectRoot: null, pathDirs });
   return failureLines2(report3.issues);
@@ -19792,11 +20282,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 = join38(scope.instinctsDir, `${id2}${MARKDOWN_EXTENSION}`);
+  const destination = join43(scope.instinctsDir, `${id2}${MARKDOWN_EXTENSION}`);
   const kept = demotedPath(scope, row2.path);
-  if (existsSync15(destination))
+  if (existsSync18(destination))
     return inert3(row2.path, "observation", "refused", `${destination} is already there`);
-  if (existsSync15(kept))
+  if (existsSync18(kept))
     return inert3(row2.path, "observation", "refused", `${kept} is already there`);
   context.taken.push(id2);
   return {
@@ -19828,7 +20318,7 @@ function planRow(scope, row2, context) {
     entries: undefined,
     absolute,
     hash,
-    mtime: statSync13(absolute).mtime.toISOString()
+    mtime: statSync14(absolute).mtime.toISOString()
   };
   return verdict === "procedure" ? planKept(scope, row2, file) : planDemoted(scope, row2, file, context);
 }
@@ -19839,28 +20329,28 @@ function countActions(actions) {
   return counts;
 }
 function planDemotion(report3, scope, seams = DEFAULT_APPLY_SEAMS) {
-  const temp = mkdtempSync2(join38(tmpdir2(), "rafa-demote-"));
+  const temp = mkdtempSync2(join43(tmpdir2(), "rafa-demote-"));
   const taken = [...takenInstinctIds(scope.instinctsDir)];
   try {
     const actions = report3.rows.map((row2) => planRow(scope, row2, { temp, taken, seams }));
     return { scope, actions, counts: countActions(actions) };
   } finally {
-    rmSync4(temp, { recursive: true, force: true });
+    rmSync5(temp, { recursive: true, force: true });
   }
 }
 function moveFile(move3) {
-  mkdirSync9(dirname10(move3.to), { recursive: true });
+  mkdirSync10(dirname10(move3.to), { recursive: true });
   try {
     renameSync3(move3.from, move3.to);
   } catch {
-    copyFileSync5(move3.from, move3.to);
+    copyFileSync6(move3.from, move3.to);
     unlinkSync(move3.from);
   }
 }
 function applyDemotion(plan2) {
   for (const action of plan2.actions) {
     if (action.write !== null) {
-      mkdirSync9(dirname10(action.write.path), { recursive: true });
+      mkdirSync10(dirname10(action.write.path), { recursive: true });
       writeFileSync8(action.write.path, action.write.text, "utf8");
     }
     if (action.move !== null)
@@ -19926,11 +20416,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 resolve17(cwd(), dir);
 }
 function isDirectory4(path) {
   try {
-    return statSync14(path).isDirectory();
+    return statSync15(path).isDirectory();
   } catch {
     return false;
   }
@@ -19952,13 +20442,13 @@ function projectOf12(context) {
     throw new Error("rafa skill demote runs inside a project, and was handed none");
   return context.project;
 }
-function verdictLine(report3) {
+function verdictLine2(report3) {
   const counts = countVerdicts(report3.rows);
   const parts = DEMOTION_VERDICTS.map((verdict) => `${String(counts[verdict])} ${verdict}`);
   return `${String(report3.rows.length)} file(s): ${parts.join(", ")}`;
 }
 function previousReport(path, context) {
-  if (!existsSync16(path))
+  if (!existsSync19(path))
     return null;
   const parsed = parseDemotionReport(readFileSync28(path, "utf8"));
   if (parsed.report !== null)
@@ -19969,7 +20459,7 @@ function previousReport(path, context) {
 function runWrite(context, scope) {
   const files = selectSources(scope);
   const report3 = buildDemotionReport(files, previousReport(scope.reportPath, context));
-  mkdirSync10(dirname11(scope.reportPath), { recursive: true });
+  mkdirSync11(dirname11(scope.reportPath), { recursive: true });
   writeFileSync9(scope.reportPath, writeDemotionReport(report3), "utf8");
   const result = {
     applied: false,
@@ -19986,14 +20476,14 @@ function runWrite(context, scope) {
   }
   for (const line of [
     `${scope.scope} scope: ${scope.dir}`,
-    verdictLine(report3),
+    verdictLine2(report3),
     `Report written to ${scope.reportPath} (status: ${report3.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 (!existsSync16(scope.reportPath)) {
+  if (!existsSync19(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(readFileSync28(scope.reportPath, "utf8"));
@@ -20102,8 +20592,8 @@ var demote_default = createSkillDemoteCommand();
 
 // src/commands/skill/show.ts
 var DEFAULT_SKILL_SHOW_SEAMS = DEFAULT_SKILL_LIST_SEAMS;
-var COMMAND_NAME6 = "rafa skill show";
-var USAGE38 = "rafa skill show <name> [--full]";
+var COMMAND_NAME9 = "rafa skill show";
+var USAGE37 = "rafa skill show <name> [--full]";
 function unknownSkillMessage(name2, inventory) {
   const agent = findShown(inventory.records, "agent", name2);
   const hint = agent === null ? [] : [`An agent is named "${name2}" (${agent.source}): rafa agent show ${name2}`];
@@ -20111,7 +20601,7 @@ function unknownSkillMessage(name2, inventory) {
     `\u274C No skill is named "${name2}".`,
     ...hint,
     "Run `rafa skill list` to see every skill and where it comes from.",
-    `Usage: ${USAGE38}`
+    `Usage: ${USAGE37}`
   ].join(`
 `);
 }
@@ -20127,10 +20617,10 @@ function projectOf13(context) {
   return context.project;
 }
 async function runShow3(context, seams) {
-  const full = readSwitch("full", context.flags["full"], `Type the name ahead of it: ${USAGE38}`);
-  const name2 = expectOneArgument(context.args, USAGE38);
+  const full = readSwitch("full", context.flags["full"], `Type the name ahead of it: ${USAGE37}`);
+  const name2 = expectOneArgument(context.args, USAGE37);
   const project = projectOf13(context);
-  const { inventory, settingSources } = await projectInventory(project, context, seams, COMMAND_NAME6);
+  const { inventory, settingSources } = await projectInventory(project, context, seams, COMMAND_NAME9);
   const warnings = warningLines(inventory);
   for (const warning of warnings)
     context.output.warn(warning);
@@ -20323,12 +20813,12 @@ function statusData(sections) {
 }
 
 // src/status/sections.ts
-import { existsSync as existsSync17 } from "fs";
+import { existsSync as existsSync20 } from "fs";
 var STATUS_NETWORK_TIMEOUT_MS = 5000;
 function isIdleWorktree(row2) {
   return !row2.blockers.some((blocker) => blocker.kind === "recent");
 }
-function unread2(problem2) {
+function unread3(problem2) {
   return { read: false, problem: problem2 };
 }
 function read2(reading) {
@@ -20339,7 +20829,7 @@ function localSection(work) {
     const reading = work();
     return isUnread(reading) ? reading : read2(reading);
   } catch (error) {
-    return unread2(messageOf(error));
+    return unread3(messageOf(error));
   }
 }
 function isUnread(value) {
@@ -20370,15 +20860,15 @@ function boundedRunner(open, root, deadline) {
 }
 async function networkSection(what, deadline, work) {
   let timer;
-  const expired = new Promise((resolve16) => {
+  const expired = new Promise((resolve18) => {
     timer = setTimeout(() => {
-      resolve16(unread2(`the ${what} was not read within the ${String(deadline.ms)}ms network deadline`));
+      resolve18(unread3(`the ${what} was not read within the ${String(deadline.ms)}ms network deadline`));
     }, Math.max(0, deadline.left()));
   });
   try {
     return await Promise.race([work().then((reading) => read2(reading)), expired]);
   } catch (error) {
-    return unread2(messageOf(error));
+    return unread3(messageOf(error));
   } finally {
     clearTimeout(timer);
   }
@@ -20394,7 +20884,7 @@ function readBranchSection(sources) {
   };
   const branch = readBranch(sources, note);
   if (branch === "") {
-    return unread2(notes.join("; ") || "the branch at the project root could not be read");
+    return unread3(notes.join("; ") || "the branch at the project root could not be read");
   }
   const plans = readPlans(sources, note);
   return { branch, plan: readBranchPlan(branch, plans), notes };
@@ -20421,9 +20911,9 @@ function readLoopsSection(root, sources) {
 }
 function pullSection(sources, branch, provider, deadline) {
   if (provider.provider !== "gh")
-    return Promise.resolve(unread2(notGhProblem("pull request", provider)));
+    return Promise.resolve(unread3(notGhProblem("pull request", provider)));
   if (!branch.read) {
-    return Promise.resolve(unread2(`no pull request was looked for, as the branch was not read: ${branch.problem}`));
+    return Promise.resolve(unread3(`no pull request was looked for, as the branch was not read: ${branch.problem}`));
   }
   return networkSection("pull request", deadline, () => readPull(sources, branch.branch));
 }
@@ -20462,7 +20952,7 @@ function nextOfPlace(current, epic, walk) {
   return epic?.members.some((member) => member.number === line.issue) === true ? line.issue : null;
 }
 function hasBoards(root, listing2) {
-  if (existsSync17(positionFilePath(root)))
+  if (existsSync20(positionFilePath(root)))
     return true;
   return listing2.some((issue2) => issue2.state === "OPEN" && issue2.labels.includes(ROADMAP_LABEL));
 }
@@ -20507,11 +20997,11 @@ async function readHousekeeping(input, cleanup, now) {
     const settings = doctorCleanupSettings({ root: input.root, home: input.home, config: input.config, gh: null }, now);
     const reading = await readCleanup(cleanup, settings);
     if (!reading.ok)
-      return unread2(reading.detail);
+      return unread3(reading.detail);
     const idle = reading.worktrees.filter((row2) => isIdleWorktree(row2));
     return read2({ counts: cleanupCounts(reading), idleWorktrees: idle.length, notes: reading.notes });
   } catch (error) {
-    return unread2(messageOf(error));
+    return unread3(messageOf(error));
   }
 }
 async function readStatusSections(input, seams = {}) {
@@ -20540,7 +21030,7 @@ async function readStatusSections(input, seams = {}) {
   const blockedIssues = seams.blockedIssues ?? ((runner) => readBlockedIssues({ gh: runner }));
   deadline.start();
   const pull = pullSection(sources, branch, provider, deadline);
-  const boardSection = isGh ? networkSection("board", deadline, () => readBoard(root, board, listing2, blockedIssues(gh))) : Promise.resolve(unread2(notGhProblem("board", provider)));
+  const boardSection = isGh ? networkSection("board", deadline, () => readBoard(root, board, listing2, blockedIssues(gh))) : Promise.resolve(unread3(notGhProblem("board", provider)));
   const housekeeping = readHousekeeping(input, cleanup, now);
   return {
     branch,
@@ -20552,7 +21042,7 @@ async function readStatusSections(input, seams = {}) {
 }
 
 // src/commands/status.ts
-var COMMAND_NAME7 = "rafa status";
+var COMMAND_NAME10 = "rafa status";
 var STATUS_USAGE = "rafa status";
 var STATUS_ARGUMENT_EXIT = 2;
 var DEFAULT_STATUS_SEAMS = Object.freeze({});
@@ -20564,13 +21054,13 @@ function projectOf14(context) {
 function expectNoWord(args) {
   if (args.length === 0)
     return;
-  throw new CommandExit(STATUS_ARGUMENT_EXIT, `\u274C ${COMMAND_NAME7}: expected no argument, got ${String(args.length)}: ${args.join(" ")}
+  throw new CommandExit(STATUS_ARGUMENT_EXIT, `\u274C ${COMMAND_NAME10}: expected no argument, got ${String(args.length)}: ${args.join(" ")}
 Usage: ${STATUS_USAGE}`);
 }
 async function runStatus2(context, seams) {
   expectNoWord(context.args);
   const project = projectOf14(context);
-  const config = resolveProjectConfig(project, COMMAND_NAME7, (message) => {
+  const config = resolveProjectConfig(project, COMMAND_NAME10, (message) => {
     context.output.warn(message);
   });
   const read3 = seams.read ?? ((input) => readStatusSections(input));
@@ -20636,18 +21126,18 @@ var CORE_SUBJECTS = Object.freeze([
   { 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: "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; repair a store a newer rafa migrated" },
+  { 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" },
   { name: "module", summary: "list the configured modules; run an action a module provides" },
   { name: "agent", summary: "copy an agent definition into the project; list what a session sees" },
   { name: "skill", summary: "check a skills directory; list each tier; demote and backfill it" },
   { name: "instinct", summary: "check an instincts directory; list, show, flag and promote its records" },
-  { name: "release", summary: "read the release state of the project; tag the release branch's HEAD" },
+  { name: "release", summary: "read the release state of the project; tag the commit that set the version" },
   { 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" }
 ]);
 var CORE_COMMANDS = Object.freeze([
   create_default2,
-  list_default,
+  list_default2,
   show_default5,
   validate_default,
   risk_default,
@@ -20658,7 +21148,7 @@ var CORE_COMMANDS = Object.freeze([
   resume_default,
   status_default2,
   list_default7,
-  list_default6,
+  list_default,
   show_default4,
   create_default,
   comment_default,
@@ -20676,26 +21166,29 @@ var CORE_COMMANDS = Object.freeze([
   collect_default,
   report_default,
   fix_schema_default,
+  copy_default,
+  schema_default,
+  migrate_default,
   list_default8,
   exec_default,
   vendor_default,
-  list_default3,
+  list_default4,
   show_default2,
   search_default2,
   check_default3,
-  list_default2,
+  list_default3,
   show_default7,
   search_default,
   demote_default,
   backfill_default,
   check_default,
-  list_default5,
+  list_default6,
   show_default3,
   flag_default,
   promote_default2,
   status_default,
   tag_default,
-  list_default4,
+  list_default5,
   show_default,
   new_default,
   defer_default,