@open-tomato/rafa 0.26.0 → 0.28.0

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

@@ -25,7 +25,6 @@ import {
   NEXT_COMMAND_ACTIONS,
   NO_NEXT_STEP,
   ORIGIN_FIELD,
-  POSITION_FILE,
   PREVIOUS_COPY_WARN_ABOVE,
   PROVENANCE_FIELD,
   REASON_FLAG,
@@ -61,7 +60,7 @@ import {
   blockedLineSentence,
   boardChanged,
   boardId,
-  bodyLines,
+  boardOfEpic,
   bodySections,
   branchClaims,
   bundledAgentsDirectory,
@@ -92,8 +91,8 @@ import {
   createGhPullRequests,
   createGhRoadmapSearch,
   createGhSpecIssueReader,
-  createGitRunner,
   createLinePrompter,
+  createOwnerResolver,
   createPlanDirNames,
   createPlanRefsVerifier,
   developmentApplied,
@@ -109,7 +108,6 @@ import {
   expectOneArgument,
   expectTwoArguments,
   failingRows,
-  findField,
   fingerprintText,
   firstNowEpic,
   firstSentence,
@@ -124,12 +122,10 @@ import {
   ghPreflightItems,
   ghPullRequestsIn,
   ghUnauthenticatedMessage,
-  gitSaid,
   groupByEpicLabel,
   hasDiverged,
   hasPlanFor,
   hasSpecBlockedLabel,
-  hop,
   horizonOf,
   isFile,
   isFirstDispatch,
@@ -153,9 +149,11 @@ import {
   missingBoardLabels,
   missingPlanAgents,
   namedSecrets,
+  nextOwnerGate,
   nextQuestion,
   notesFileName,
   onTracker,
+  openBoards,
   openNextSources,
   parseBaseStanding,
   parseRoadmapBody,
@@ -168,7 +166,6 @@ import {
   planLabel,
   plansDirAt,
   plural,
-  positionFilePath,
   previousDir,
   projectRoot,
   provenanceBlock,
@@ -176,6 +173,7 @@ import {
   readAgentDirectory,
   readAuthorTrust,
   readBlockedBy,
+  readBoardBody,
   readBranch,
   readBranchPlan,
   readChoice,
@@ -186,13 +184,13 @@ import {
   readEpicDependents,
   readEpicProblems,
   readEpics,
+  readHomeAfterLoop,
   readManifestVersion,
   readMergeRefusal,
   readNextState,
   readNonBlankFlag,
   readOpenPull,
   readPlans,
-  readPositionFile,
   readRankCandidate,
   readReason,
   readRecords,
@@ -210,7 +208,6 @@ import {
   recordPlanCi,
   refusal,
   refuseMisplacedRuntime,
-  rehome,
   remainingFrom,
   renderCancelComment,
   renderCloseComment,
@@ -271,10 +268,9 @@ import {
   verdictOf,
   waitForChecks,
   watchDryEpic,
-  writePositionFile,
   writeSession,
   writeShippedFile
-} from "./index-59x3zsh4.js";
+} from "./index-6jkj0dcx.js";
 import {
   PROBE_TIMEOUT_MS,
   findNextTask,
@@ -297,16 +293,20 @@ import {
   DISK_FILE_SYSTEM,
   DevelopmentBuildRefusedError,
   EFFORT_DIR_VARIABLE,
+  EFFORT_KEY_PROJECTIONS,
   EFFORT_STORE_DIR,
+  HOP_FILE,
   ISSUE_PRIORITIES,
   ISSUE_STATES,
   ISSUE_TYPES,
   MARKDOWN_EXTENSION,
   MIGRATION_LOG_TABLE,
+  POSITION_FILE,
   SCOPE_DIR,
   SKILL_FILE,
   SQLITE_MIGRATIONS,
   SQLITE_STORE_FILE_NAME,
+  SchemaRefusedError,
   SessionRecordError,
   activeStoreSettings,
   allRecords,
@@ -314,26 +314,37 @@ import {
   bringForward,
   claudeArgs,
   createGhRunner,
+  createGitRunner,
   effortStoreDir,
   effortStoreFileName,
   errorCode,
   findRecords,
   gitRemoteUrl,
+  gitSaid,
   guardTestProcess,
+  hop,
   instinctProject,
   isPidAlive,
   mergeFrontmatter,
   name,
   normalizeRemote,
+  openNdjsonStore,
+  openSqliteStore,
   planSchema,
+  positionFilePath,
   readFrontmatter,
   readFrontmatterDocument,
+  readHopRecord,
+  readPositionFile,
+  readProjectIdentity,
   readRuntimeIdentity,
   readScopes,
   readSession,
   readSessions,
+  readStoreMeta,
   readStoreSchema,
   refuseUnownedDevelopmentWrite,
+  rehome,
   renderFrontmatter,
   runClaudeCaptured,
   runsDir,
@@ -345,13 +356,15 @@ import {
   spawnClaudeCaptured,
   sqliteCatalogue,
   sqliteStorePath,
+  staleAgainst,
   storeProjectRoot,
   toHeldRecords,
   version,
   versionLine,
   writeFrontmatter,
-  writeNames
-} from "./index-azptzvp3.js";
+  writeNames,
+  writePositionFile
+} from "./index-4rwvr6t4.js";
 import {
   CONFIG_DEFAULTS,
   CONFIG_FILE,
@@ -2545,7 +2558,7 @@ function headingOf(search, question, projectRoot2) {
   const how = search.status === "ranked" ? "; keyword ranking, no session" : "";
   return `${plural2} for "${question}" (project: ${projectRoot2}${how}):`;
 }
-function bodyLines2(search) {
+function bodyLines(search) {
   switch (search.status) {
     case "no-candidates":
       return [`  (no ${search.kind} ranks for these words)`];
@@ -2570,7 +2583,7 @@ function searchWarnings(search) {
   return [...notice, ...issues, ...effort];
 }
 function renderKindSearch(search, question, projectRoot2) {
-  return [headingOf(search, question, projectRoot2), ...bodyLines2(search)];
+  return [headingOf(search, question, projectRoot2), ...bodyLines(search)];
 }
 function projectOf3(context, kind) {
   if (context.project === null)
@@ -2945,96 +2958,6 @@ function createAgentVendorCommand(now = () => new Date, entry = () => Bun.main)
 }
 var vendor_default = createAgentVendorCommand();
 
-// src/board/board-body.ts
-var OWNER_FIELD = "Owner";
-var BOARD_OWNS_FIELD = "Owns";
-var LOGIN = "[A-Za-z0-9](?:[A-Za-z0-9]|-(?=[A-Za-z0-9])){0,38}";
-var TEAM = "[A-Za-z0-9][A-Za-z0-9_.-]*";
-var HANDLE = new RegExp(`^@${LOGIN}(?:/${TEAM})?$`, "u");
-function isOwnerHandle(text) {
-  return HANDLE.test(text);
-}
-var OWNS_SEPARATOR = /[\s,]+/u;
-function undressed(text) {
-  return text.replaceAll("`", " ").trim();
-}
-function normaliseFolder(folder) {
-  let path = folder;
-  while (path.startsWith("./"))
-    path = path.slice(2);
-  while (path.endsWith("/"))
-    path = path.slice(0, -1);
-  return path;
-}
-function isRepoRelative(path) {
-  if (path === "" || path === "." || path.startsWith("/"))
-    return false;
-  return !path.split("/").includes("..");
-}
-function ownedFolders(text) {
-  const named = undressed(text).split(OWNS_SEPARATOR).filter((folder) => folder !== "");
-  const owns = named.map(normaliseFolder).filter(isRepoRelative);
-  const rejected = named.filter((folder) => !isRepoRelative(normaliseFolder(folder)));
-  return { owns: [...new Set(owns)], rejected };
-}
-function readBoardBody(body) {
-  const lines = bodyLines(body);
-  const ownerLine = findField(lines, OWNER_FIELD);
-  const ownsLine = findField(lines, BOARD_OWNS_FIELD);
-  const handle = ownerLine === null ? null : undressed(ownerLine.text);
-  const isOwned = handle !== null && isOwnerHandle(handle);
-  const folders = ownsLine === null ? { owns: [], rejected: [] } : ownedFolders(ownsLine.text);
-  const problems = [
-    ownerLine === null || isOwned ? null : { kind: "malformed-owner", line: ownerLine.number, text: ownerLine.text, rejected: Object.freeze([]) },
-    ownsLine === null || folders.rejected.length === 0 ? null : { kind: "malformed-owns", line: ownsLine.number, text: ownsLine.text, rejected: Object.freeze(folders.rejected) }
-  ];
-  return Object.freeze({
-    lines: parseRoadmapBody(body),
-    owner: isOwned ? handle : null,
-    owns: Object.freeze(folders.owns),
-    problems: Object.freeze(problems.filter((problem) => problem !== null))
-  });
-}
-
-// src/board/owner-resolve.ts
-var NOT_FOUND = "(HTTP 404)";
-function ownerLookupArgs(handle) {
-  if (!isOwnerHandle(handle)) {
-    return null;
-  }
-  const [account = "", slug] = handle.slice(1).split("/");
-  return slug === undefined ? ["api", `users/${account}`] : ["api", `orgs/${account}/teams/${slug}`];
-}
-function failureReason(result, command) {
-  const written = result.stderr.trim() || result.stdout.trim();
-  return written === "" ? `${command} failed and wrote nothing` : `${command} failed: ${written}`;
-}
-async function lookUp(gh, handle) {
-  const args = ownerLookupArgs(handle);
-  if (args === null) {
-    return { handle, state: "unknown", reason: `${JSON.stringify(handle)} is not an @login or @org/team handle, so nothing was asked` };
-  }
-  const result = await gh(args);
-  if (result.ok) {
-    return { handle, state: "resolved" };
-  }
-  return result.stderr.includes(NOT_FOUND) ? { handle, state: "unresolved" } : { handle, state: "unknown", reason: failureReason(result, `gh ${args.join(" ")}`) };
-}
-function createOwnerResolver(options) {
-  const { gh } = options;
-  const answers = new Map;
-  return (handle) => {
-    const key = handle.toLowerCase();
-    const known = answers.get(key);
-    if (known !== undefined) {
-      return known.then((answer) => ({ ...answer, handle }));
-    }
-    const pending = lookUp(gh, handle);
-    answers.set(key, pending);
-    return pending;
-  };
-}
-
 // src/commands/switch.ts
 var USAGE5 = "rafa switch <n | -> [--no-rehome]";
 var SWITCH_REFUSAL_EXIT = 2;
@@ -3068,9 +2991,6 @@ function readRehome(flags) {
     return value;
   throw lineRefusal(`--${REHOME_FLAG} takes no value, and read "${value}" as one; type the target before the flags`, USAGE5);
 }
-function openBoards(listing) {
-  return listing.filter((issue) => issue.state === "OPEN" && issue.labels.includes(ROADMAP_LABEL)).sort((a, b) => a.number - b.number);
-}
 async function kindOf(number, board) {
   const row = board.rows.get(number);
   if (row === undefined) {
@@ -3087,20 +3007,6 @@ async function kindOf(number, board) {
     return { why: `${id(number)} is neither a board nor an epic: it carries neither ${ROADMAP_LABEL} nor type:epic` };
   return row.state === "CLOSED" ? { why: `${id(number)} is a closed ${kind}` } : { kind };
 }
-function lists(number, epic, board) {
-  const row = board.rows.get(number);
-  if (row?.state !== "OPEN")
-    return false;
-  return parseRoadmapBody(row.body).some((line) => line.issue === epic);
-}
-async function boardOfEpic(epic, current, board) {
-  if (lists(current.board, epic, board))
-    return current.board;
-  const fallback = await board.defaultBoard();
-  if (lists(fallback, epic, board))
-    return fallback;
-  return openBoards(board.listing).find((row) => lists(row.number, epic, board))?.number ?? fallback;
-}
 function boardPlace(number, board, epics) {
   const row = board.rows.get(number);
   const epic = row === undefined ? null : firstNowEpic(parseRoadmapBody(row.body), board.listing, epics)?.number ?? null;
@@ -7559,12 +7465,14 @@ function refuseInFlight(path) {
     }
   }
 }
-function checkedCounts(db, tables, original) {
+function checkedCounts(db, tables, original, added = {}) {
   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)}`);
+    const addedRows = added[table] ?? 0;
+    if (rows !== originalRows + addedRows) {
+      const plus = addedRows === 0 ? "" : ` plus ${String(addedRows)} added`;
+      throw new RebuildRefusal(`the rebuilt ${table} holds ${String(rows)} rows, the store ${String(originalRows)}${plus}`);
     }
     return { table, rows };
   });
@@ -7978,8 +7886,291 @@ function createCopyCommand(seams = {}) {
 }
 var copy_default = createCopyCommand();
 
-// src/commands/effort/migrate.ts
-import { join as join20 } from "path";
+// src/commands/effort/merge.ts
+import { join as join21, resolve as resolve8 } from "path";
+
+// src/effort/store/merge-store.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { existsSync as existsSync9, mkdtempSync as mkdtempSync2, rmSync as rmSync4 } from "fs";
+import { tmpdir as tmpdir2 } from "os";
+import { dirname as dirname3, join as join20 } from "path";
+import { Database as Database4, SQLiteError as SQLiteError2 } from "bun:sqlite";
+
+// src/effort/store/merge-commit-gaps.ts
+var GAP_FIELD = "minutesSincePrevious";
+var UPDATE_GAP = "UPDATE commits SET row_json = ? WHERE seq = ?";
+function parsedObject(text) {
+  try {
+    const value = JSON.parse(text);
+    return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+  } catch {
+    return null;
+  }
+}
+function withoutGap(rowJson) {
+  const row2 = parsedObject(rowJson);
+  if (row2 === null)
+    return rowJson;
+  const rest = Object.fromEntries(Object.entries(row2).filter(([key]) => key !== GAP_FIELD));
+  return JSON.stringify(rest);
+}
+function readCommits(db) {
+  return db.query("SELECT seq, sha, row_json FROM commits").all().map(({ seq, sha, row_json: rowJson }) => {
+    const row2 = parsedObject(rowJson);
+    const timestamp = typeof row2?.timestamp === "string" ? row2.timestamp : null;
+    return { seq, sha, row: row2, timestamp, epoch: timestamp === null ? Number.NaN : Date.parse(timestamp) };
+  });
+}
+function timeOrder(entries) {
+  return entries.filter((entry) => !Number.isNaN(entry.epoch)).sort((left, right) => left.epoch - right.epoch || compareText(left.sha, right.sha));
+}
+function compareText(left, right) {
+  if (left === right)
+    return 0;
+  return left < right ? -1 : 1;
+}
+function storedGap(entry) {
+  const value = entry.row?.[GAP_FIELD];
+  return typeof value === "number" ? value : null;
+}
+function namedRows(inserted, positions, order) {
+  const position = positions.get(inserted.seq);
+  if (position === undefined)
+    return [inserted.seq];
+  const next = order[position + 1];
+  return next === undefined ? [inserted.seq] : [inserted.seq, next.seq];
+}
+function recomputedGap(entry, positions, order) {
+  const position = positions.get(entry.seq);
+  if (position === undefined || position === 0)
+    return null;
+  const previous = order[position - 1];
+  if (previous?.timestamp == null || entry.timestamp === null)
+    return null;
+  return minutesBetween(previous.timestamp, entry.timestamp);
+}
+function recomputeCommitGaps(db, inserted) {
+  return db.transaction(() => {
+    const entries = readCommits(db);
+    const bySeq = new Map(entries.map((entry) => [entry.seq, entry]));
+    const order = timeOrder(entries);
+    const positions = new Map(order.map((entry, position) => [entry.seq, position]));
+    const named = new Set(inserted.flatMap((seq) => {
+      const entry = bySeq.get(seq);
+      return entry === undefined ? [] : namedRows(entry, positions, order);
+    }));
+    const targets = [...named].map((seq) => bySeq.get(seq)).filter((entry) => entry?.row != null).sort((left, right) => (positions.get(left.seq) ?? -1) - (positions.get(right.seq) ?? -1));
+    return targets.flatMap((entry) => {
+      const before = storedGap(entry);
+      const after = recomputedGap(entry, positions, order);
+      if (before === after && entry.row !== null && Object.hasOwn(entry.row, GAP_FIELD))
+        return [];
+      db.query(UPDATE_GAP).run(JSON.stringify({ ...entry.row, [GAP_FIELD]: after }), entry.seq);
+      return [{ seq: entry.seq, sha: entry.sha, before, after }];
+    });
+  })();
+}
+
+// src/effort/store/merge-rules.ts
+var SET_ONCE = "set-once";
+var RECOMPUTED = "recomputed";
+var APPEND_ONLY = {};
+function appendOnly(...identity) {
+  return { scope: "merged", identity, edited: APPEND_ONLY };
+}
+var MERGE_RULES = {
+  sessions: appendOnly("session_id"),
+  commits: { scope: "merged", identity: ["sha"], edited: { row_json: RECOMPUTED } },
+  findings: { scope: "merged", identity: ["id"], edited: { tracker_ref: SET_ONCE } },
+  blockers: appendOnly("id"),
+  out_of_scope_bugs: appendOnly("id"),
+  report_absences: appendOnly("id"),
+  task_reports: appendOnly("id"),
+  preflight: appendOnly("run_id", "position"),
+  dispatches: appendOnly("session_id"),
+  changes: appendOnly("id"),
+  skill_invocations: appendOnly("session_id", "name", "sidechain"),
+  plan_ci: appendOnly("pr", "head_sha", "read_at"),
+  schema_migrations: { scope: "local" },
+  store_meta: { scope: "local" },
+  merges: { scope: "local" },
+  merge_conflicts: { scope: "local" }
+};
+
+// src/effort/store/merge-union.ts
+import { SQLiteError } from "bun:sqlite";
+class UnionSchemaMismatch extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "UnionSchemaMismatch";
+  }
+}
+var UNIQUE_REFUSAL = "SQLITE_CONSTRAINT_UNIQUE";
+function mergedTables() {
+  return Object.entries(MERGE_RULES).flatMap(([table, rule]) => rule.scope === "merged" ? [{ table, identity: rule.identity }] : []);
+}
+function carriedColumns(db, table) {
+  return db.query(`PRAGMA table_info(${quoted(table)})`).all().map(({ name: name2 }) => name2).filter((name2) => name2 !== "seq");
+}
+function refuseColumnMismatch(local, other, tables) {
+  const faults = tables.flatMap(({ table }) => {
+    const here = new Set(carriedColumns(local, table));
+    const there = new Set(carriedColumns(other, table));
+    const onlyHere = [...here].filter((column) => !there.has(column)).map((column) => `${table}.${column} only here`);
+    const onlyThere = [...there].filter((column) => !here.has(column)).map((column) => `${table}.${column} only there`);
+    return [...onlyHere, ...onlyThere];
+  });
+  if (faults.length > 0) {
+    throw new UnionSchemaMismatch(`the two stores hold different columns (${faults.join(", ")}); bring both to the same migrations first`);
+  }
+}
+function valueOf(row2, column) {
+  return row2[column] ?? null;
+}
+function byOrigin(local, table, row2) {
+  const store = valueOf(row2, "origin_store");
+  const seq = valueOf(row2, "origin_seq");
+  if (store === null || seq === null)
+    return null;
+  return local.query(`SELECT seq FROM ${quoted(table)} WHERE origin_store = ? AND origin_seq = ?`).get(store, seq)?.seq ?? null;
+}
+function byIdentity(local, { table, identity }, row2) {
+  const where = identity.map((column) => `${quoted(column)} IS ?`).join(" AND ");
+  return local.query(`SELECT seq FROM ${quoted(table)} WHERE ${where} ORDER BY seq LIMIT 1`).get(...identity.map((column) => valueOf(row2, column)))?.seq ?? null;
+}
+function insertRow(local, table, columns2, row2, incomingSeq) {
+  const columnList = columns2.map(quoted).join(", ");
+  const placeholders = columns2.map(() => "?").join(", ");
+  const nextSeq = `(SELECT COALESCE(MAX(seq), 0) + 1 FROM ${quoted(table)})`;
+  try {
+    const inserted = local.query(`INSERT INTO ${quoted(table)} (seq, ${columnList}) VALUES (${nextSeq}, ${placeholders}) RETURNING seq`).get(...columns2.map((column) => valueOf(row2, column)));
+    if (inserted === null)
+      throw new Error(`the insert into ${table} returned no seq`);
+    return { kind: "added", localSeq: inserted.seq };
+  } catch (error) {
+    if (!(error instanceof SQLiteError) || error.code !== UNIQUE_REFUSAL)
+      throw error;
+    return { kind: "collided", collision: { incomingSeq, reason: error.message } };
+  }
+}
+function placeRow(local, merged2, columns2, row2) {
+  const incomingSeq = Number(valueOf(row2, "seq"));
+  const origin = byOrigin(local, merged2.table, row2);
+  if (origin !== null)
+    return { kind: "matched", match: { localSeq: origin, incomingSeq, by: "origin" } };
+  const identity = byIdentity(local, merged2, row2);
+  if (identity !== null)
+    return { kind: "matched", match: { localSeq: identity, incomingSeq, by: "identity" } };
+  return insertRow(local, merged2.table, columns2, row2, incomingSeq);
+}
+function unionTable(local, other, merged2) {
+  const columns2 = carriedColumns(local, merged2.table);
+  const incoming = other.query(`SELECT seq, ${columns2.map(quoted).join(", ")} FROM ${quoted(merged2.table)} ORDER BY seq`).all();
+  const outcomes = incoming.map((row2) => placeRow(local, merged2, columns2, row2));
+  return {
+    table: merged2.table,
+    added: outcomes.flatMap((outcome) => outcome.kind === "added" ? [outcome.localSeq] : []),
+    matched: outcomes.flatMap((outcome) => outcome.kind === "matched" ? [outcome.match] : []),
+    collided: outcomes.flatMap((outcome) => outcome.kind === "collided" ? [outcome.collision] : [])
+  };
+}
+function unionStores(local, other) {
+  const tables = mergedTables();
+  refuseColumnMismatch(local, other, tables);
+  return local.transaction(() => tables.map((merged2) => unionTable(local, other, merged2)))();
+}
+
+// src/effort/store/merge-conflicts.ts
+var SET_ONCE_FILLS = {
+  "findings.tracker_ref": "UPDATE findings SET tracker_ref = ? WHERE seq = ? AND tracker_ref IS NULL"
+};
+var RECOMPUTED_COMPARISONS = {
+  "commits.row_json": withoutGap
+};
+var NOT_CONTENT = new Set(["seq", "origin_store", "origin_seq"]);
+var INSERT_CONFLICT = `INSERT INTO merge_conflicts (merge_id, table_name, local_seq, field, incoming, recorded_at)
+  VALUES (?, ?, ?, ?, ?, ?)`;
+function rowAt(db, table, columns2, seq, side) {
+  const row2 = db.query(`SELECT seq, ${columns2.map(quoted).join(", ")} FROM ${quoted(table)} WHERE seq = ?`).get(seq);
+  if (row2 === null)
+    throw new Error(`the union matched ${table} row ${seq} ${side}, which that store does not hold`);
+  return row2;
+}
+function sameValue(left, right) {
+  if (left instanceof Uint8Array && right instanceof Uint8Array)
+    return Buffer.from(left).equals(right);
+  return (left ?? null) === (right ?? null);
+}
+function fillStatement(table, field) {
+  const statement = SET_ONCE_FILLS[`${table}.${field}`];
+  if (statement === undefined) {
+    throw new Error(`${table}.${field} is set-once in MERGE_RULES and has no statement in SET_ONCE_FILLS`);
+  }
+  return statement;
+}
+function settleSetOnce(local, table, field, here, there) {
+  const incoming = there[field] ?? null;
+  if (incoming === null)
+    return { skipped: true, filled: [], conflictFields: [] };
+  if ((here[field] ?? null) !== null)
+    return { skipped: false, filled: [], conflictFields: [field] };
+  local.query(fillStatement(table, field)).run(incoming, Number(here.seq));
+  return { skipped: true, filled: [field], conflictFields: [] };
+}
+function settleRecomputed(table, field, here, there) {
+  const comparable = RECOMPUTED_COMPARISONS[`${table}.${field}`];
+  if (comparable === undefined) {
+    throw new Error(`${table}.${field} is recomputed in MERGE_RULES and has no entry in RECOMPUTED_COMPARISONS`);
+  }
+  const hereValue = here[field];
+  const thereValue = there[field];
+  const same = typeof hereValue === "string" && typeof thereValue === "string" && comparable(hereValue) === comparable(thereValue);
+  return same ? { skipped: true, filled: [], conflictFields: [] } : { skipped: false, filled: [], conflictFields: [null] };
+}
+function settlePair(local, table, edited, here, there) {
+  const differing = Object.keys(here).filter((column) => !NOT_CONTENT.has(column) && !sameValue(here[column], there[column]));
+  if (differing.length === 0)
+    return { skipped: true, filled: [], conflictFields: [] };
+  if (differing.some((column) => !Object.hasOwn(edited, column)))
+    return { skipped: false, filled: [], conflictFields: [null] };
+  const outcomes = differing.map((field) => {
+    if (edited[field] === SET_ONCE)
+      return settleSetOnce(local, table, field, here, there);
+    if (edited[field] === RECOMPUTED)
+      return settleRecomputed(table, field, here, there);
+    throw new Error(`${table}.${field} has the rule ${edited[field]}, which the merge does not apply`);
+  });
+  return {
+    skipped: outcomes.every((outcome) => outcome.skipped),
+    filled: outcomes.flatMap((outcome) => outcome.filled),
+    conflictFields: outcomes.flatMap((outcome) => outcome.conflictFields)
+  };
+}
+function settleTable(local, other, union, trail) {
+  const rule = MERGE_RULES[union.table];
+  if (rule?.scope !== "merged")
+    throw new Error(`${union.table} is not a merged table in MERGE_RULES`);
+  const columns2 = carriedColumns(local, union.table);
+  const settled = union.matched.map((match) => {
+    const here = rowAt(local, union.table, columns2, match.localSeq, "here");
+    const there = rowAt(other, union.table, columns2, match.incomingSeq, "in the other store");
+    const outcome = settlePair(local, union.table, rule.edited, here, there);
+    const conflicts = outcome.conflictFields.map((field) => {
+      local.query(INSERT_CONFLICT).run(trail.mergeId, union.table, match.localSeq, field, JSON.stringify(there), trail.recordedAt);
+      return { localSeq: match.localSeq, incomingSeq: match.incomingSeq, field };
+    });
+    return { match, outcome, conflicts };
+  });
+  return {
+    table: union.table,
+    skipped: settled.flatMap(({ match, outcome }) => outcome.skipped ? [match.localSeq] : []),
+    filled: settled.flatMap(({ match, outcome }) => outcome.filled.map((field) => ({ localSeq: match.localSeq, field }))),
+    conflicts: settled.flatMap(({ conflicts }) => conflicts)
+  };
+}
+function settleMatches(local, other, unions, trail) {
+  return local.transaction(() => unions.map((union) => settleTable(local, other, union, trail)))();
+}
 
 // src/effort/store/migrate.ts
 import { existsSync as existsSync8 } from "fs";
@@ -7988,7 +8179,7 @@ var LIVE2 = "live";
 function asidePaths2(path, first, stamp) {
   return { parallelPath: `${path}.migrate-${stamp}`, backupPath: `${path}.before-${first}-${stamp}.bak` };
 }
-function liveLoop(path, options) {
+function liveLoop(path, options, nothingDone = "Nothing was migrated.") {
   const root = storeProjectRoot(path);
   if (root === null)
     return;
@@ -7996,7 +8187,7 @@ function liveLoop(path, options) {
   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.`);
+    throw new RebuildRefusal(`the loop's run records cannot be read, so a live loop on ${path} cannot be ruled out` + ` (${messageOf(error)}). ${nothingDone}`);
   }
   return records.find((record) => record.state === "running" || record.state === "paused");
 }
@@ -8065,109 +8256,629 @@ function migrateStore(options) {
   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.`;
+
+// src/effort/store/merge-store.ts
+var MOVE_TO_SQLITE = "rafa effort move --to=sqlite";
+
+class MergeRefusal extends RebuildRefusal {
+  reason;
+  constructor(reason, message) {
+    super(message);
+    this.name = "MergeRefusal";
+    this.reason = reason;
+  }
+}
+var LIVE3 = "live";
+var MERGES_TABLE = "merges";
+var INSERT_MERGE = `INSERT INTO merges (id, other_store, merged_at, rows_added, rows_skipped, rows_in_conflict)
+  VALUES (?, ?, ?, ?, ?, ?)`;
+var NOTHING_MERGED = "Nothing was merged.";
+function refuseNdjson(backend) {
+  if (backend !== "ndjson")
+    return;
+  throw new MergeRefusal("ndjson", `REFUSED \u2014 this project keeps its sessions and commits as NDJSON (store: ndjson), and a merge needs the SQLite store. ${NOTHING_MERGED}` + ` Next safe step: ${MOVE_TO_SQLITE}`);
+}
+function refuseMissing(path, which) {
+  if (existsSync9(path))
+    return;
+  throw new MergeRefusal("missing", `REFUSED \u2014 ${which} ${path} is not there. ${NOTHING_MERGED}`);
+}
+function refuseDamaged(path) {
+  let answers;
+  try {
+    const db = new Database4(path, { readonly: true });
+    try {
+      answers = db.query("PRAGMA integrity_check").all().map((row2) => row2.integrity_check);
+    } finally {
+      db.close();
+    }
+  } catch (error) {
+    if (!(error instanceof SQLiteError2))
+      throw error;
+    throw new MergeRefusal("damaged", `REFUSED \u2014 ${path} cannot be read as a SQLite store (${error.message}). ${NOTHING_MERGED}` + " Take a consistent copy on its device with rafa effort copy, and merge that.");
+  }
+  if (answers.length === 1 && answers[0] === "ok")
+    return;
+  throw new MergeRefusal("damaged", `REFUSED \u2014 ${path} failed integrity_check: ${answers.join("; ")}. ${NOTHING_MERGED}` + " Take a consistent copy on its device with rafa effort copy, and merge that.");
+}
+function writablePlan(path, migrations) {
+  const plan2 = planSchema(readOnlySchema(path), sqliteCatalogue(migrations), "write", "open");
+  if (plan2.verdict === "refuse")
+    throw new MergeRefusal("schema", `REFUSED \u2014 ${path}: ${plan2.message}`);
+  return plan2;
+}
+function recordedMeta(path) {
+  const db = new Database4(path, { readonly: true });
+  try {
+    const hasTable = db.query("SELECT count(*) AS n FROM sqlite_master WHERE type = 'table' AND name = 'store_meta'").get()?.n === 1;
+    return hasTable ? readStoreMeta(db) : null;
+  } finally {
+    db.close();
+  }
+}
+function refuseOtherProject(options) {
+  const other = recordedMeta(options.otherPath);
+  const here = recordedMeta(options.path)?.projectRootCommit ?? (options.readProject ?? readProjectIdentity)(dirname3(options.path)).rootCommit;
+  const there = other?.projectRootCommit ?? null;
+  if (here !== null && there !== null && here !== there) {
+    throw new MergeRefusal("other-project", `REFUSED \u2014 ${options.otherPath} is the effort store of another project (root commit ${there});` + ` this store's project has root commit ${here}. ${NOTHING_MERGED}`);
+  }
+  return other?.storeId ?? null;
+}
+function refuseLiveLoop3(path, options) {
+  const loop = liveLoop(path, options, NOTHING_MERGED);
+  if (loop === undefined)
+    return;
+  throw new MergeRefusal("live-loop", `REFUSED \u2014 loop ${loop.sessionId} (pid ${String(loop.pid)}, plan ${loop.planStub ?? loop.plan}) is running on this store,` + ` and swapping the merged store in under it would lose what it writes. ${NOTHING_MERGED}` + " Finish or stop that loop, then run it again.");
+}
+function openOther(otherPath, plan2, stamp) {
+  const needs = writeNames(plan2);
+  if (needs.length === 0) {
+    const db = new Database4(otherPath, { readonly: true });
+    return { db, broughtForward: [], release: () => db.close() };
+  }
+  const dir = mkdtempSync2(join20(tmpdir2(), "rafa-merge-other-"));
+  const release = (db) => {
+    db?.close();
+    rmSync4(dir, { recursive: true, force: true });
+  };
+  try {
+    const copyPath = join20(dir, "other.sqlite");
+    vacuumInto(otherPath, copyPath);
+    const db = new Database4(copyPath, { readwrite: true });
+    try {
+      bringForward(db, copyPath, "write", "open", { ...stamp, builtAside: true });
+    } catch (error) {
+      release(db);
+      throw error;
+    }
+    return { db, broughtForward: needs, release: () => release(db) };
+  } catch (error) {
+    release();
+    throw error;
+  }
+}
+function mergeInto(db, other, mergeId, otherStore, mergedAt) {
+  return db.transaction(() => {
+    const unions = unionStores(db, other);
+    const settlements = settleMatches(db, other, unions, { mergeId, recordedAt: mergedAt });
+    const gaps = recomputeCommitGaps(db, unions.find(({ table }) => table === "commits")?.added ?? []);
+    const tables = unions.map((union, index) => {
+      const settled = settlements[index];
+      return {
+        table: union.table,
+        added: union.added.length,
+        skipped: settled?.skipped.length ?? 0,
+        inConflict: settled?.conflicts.length ?? 0,
+        filled: settled?.filled.length ?? 0,
+        collided: union.collided.length
+      };
+    });
+    const sum = (field) => tables.reduce((total, entry) => total + entry[field], 0);
+    const totals = { rowsAdded: sum("added"), rowsSkipped: sum("skipped"), rowsInConflict: sum("inConflict") };
+    db.query(INSERT_MERGE).run(mergeId, otherStore, mergedAt, totals.rowsAdded, totals.rowsSkipped, totals.rowsInConflict);
+    return { tables, ...totals, gapsRewritten: gaps.length };
+  })();
+}
+function addedRows(merged2) {
+  return {
+    ...Object.fromEntries(merged2.tables.map(({ table, added }) => [table, added])),
+    [MERGES_TABLE]: 1,
+    merge_conflicts: merged2.rowsInConflict
+  };
+}
+function buildMerged(path, parallelPath, other, merge) {
+  vacuumInto(path, parallelPath);
+  const db = new Database4(parallelPath, { readwrite: true });
+  try {
+    bringForward(db, parallelPath, "write", "open", { ...merge.stamp, builtAside: true });
+    const merged2 = mergeInto(db, other, merge.id, merge.otherStore, merge.stamp.now().toISOString());
+    db.run(`ATTACH DATABASE ? AS ${LIVE3}`, [path]);
+    const live = new Set(tableNames(db, LIVE3));
+    checkedCounts(db, tableNames(db, "main").filter((table) => live.has(table)), LIVE3, addedRows(merged2));
+    db.run(`DETACH DATABASE ${LIVE3}`);
+    refuseCorrupt(db);
+    refuseUnusable(db, parallelPath, merge.stamp.migrations);
+    return merged2;
+  } finally {
+    db.close();
+  }
+}
+function refuseUnmergeable(options, migrations) {
+  const { path, otherPath } = options;
+  refuseNdjson(options.backend);
+  refuseMissing(path, "this store");
+  refuseMissing(otherPath, "the other store");
+  refuseInFlight(path);
+  refuseInFlight(otherPath);
+  refuseDamaged(otherPath);
+  const otherPlan = writablePlan(otherPath, migrations);
+  const localPlan = writablePlan(path, migrations);
+  const otherStore = refuseOtherProject(options);
+  if (!options.dryRun) {
+    refuseUnownedDevelopmentWrite(path, [...writeNames(localPlan), MERGES_TABLE], options);
+    refuseLiveLoop3(path, options);
+  }
+  return { otherPlan, otherStore };
+}
+function mergeStore(options) {
+  const { path, otherPath, dryRun, stamp } = options;
+  guardTestProcess(path);
+  guardTestProcess(otherPath);
+  const migrations = options.migrations ?? SQLITE_MIGRATIONS;
+  const { otherPlan, otherStore } = refuseUnmergeable(options, migrations);
+  const mergeStamp = {
+    migrations,
+    appliedBy: appliedByName(options.identity ?? readRuntimeIdentity()),
+    now: options.now ?? (() => new Date)
+  };
+  const mergeId = (options.newMergeId ?? randomUUID2)();
+  const other = openOther(otherPath, otherPlan, mergeStamp);
+  try {
+    const { built, backupPath } = rebuildAside({
+      path,
+      parallelPath: `${path}.merge-${stamp}`,
+      backupPath: `${path}.before-merge-${stamp}.bak`,
+      dryRun,
+      build: (parallelPath) => buildMerged(path, parallelPath, other.db, { id: mergeId, otherStore, stamp: mergeStamp })
+    });
+    const status = dryRun ? "would-merge" : "merged";
+    return { path, otherPath, status, mergeId, otherStore, otherBroughtForward: other.broughtForward, ...built, backupPath };
+  } finally {
+    other.release();
+  }
+}
+
+// src/commands/effort/merge.ts
+var COMMAND_NAME7 = "rafa effort merge";
+var MERGE_USAGE = "rafa effort merge <file> [--dry-run]";
+var DRY_RUN_FLAG3 = "dry-run";
+var REFUSED_EXIT2 = 1;
+var UNMERGEABLE_EXIT = 2;
+var UNMERGEABLE_REASONS = new Set(["other-project", "ndjson"]);
+function tableLine(entry) {
+  const extra = [
+    ...entry.filled === 0 ? [] : [`${String(entry.filled)} filled`],
+    ...entry.collided === 0 ? [] : [`${String(entry.collided)} refused by another unique key, kept in the other file only`]
+  ];
+  const counts = [
+    `${String(entry.added)} added`,
+    `${String(entry.skipped)} skipped`,
+    `${String(entry.inConflict)} in conflict`,
+    ...extra
+  ];
+  return `  ${entry.table}: ${counts.join(", ")}`;
+}
+function closingLine(result) {
+  if (result.status === "would-merge") {
+    return "\uD83D\uDD0D Dry run: the merged store was built beside it, checked (row counts, integrity_check, this rafa's" + ` schema plan) and deleted. Run \`${COMMAND_NAME7} ${result.otherPath}\` to swap it in; the original would be` + ` kept whole at ${result.path}.before-merge-<stamp>.bak.`;
+  }
+  return `\u2705 Merged. The original is kept whole at ${String(result.backupPath)}; rename it back to undo.`;
+}
+function renderMerge(result) {
+  const other = result.otherStore === null ? "a store that names no origin" : `store ${result.otherStore}`;
+  const forward = result.otherBroughtForward.length === 0 ? [] : [`A copy of the other store was brought forward through ${result.otherBroughtForward.join(", ")}; the file itself was only read.`];
+  return [
+    `Merges ${result.otherPath} (${other}) into ${result.path}, as merge ${result.mergeId}.`,
+    ...forward,
+    ...result.tables.map(tableLine),
+    `Total: ${String(result.rowsAdded)} added, ${String(result.rowsSkipped)} skipped,` + ` ${String(result.rowsInConflict)} in conflict; ${String(result.gapsRewritten)} commit gaps recomputed.`,
+    closingLine(result)
+  ];
+}
+function storePath(context, root) {
+  try {
+    return join21(effortStoreDir(root, context.env), SQLITE_STORE_FILE_NAME);
+  } catch (error) {
+    throw new CommandExit(REFUSED_EXIT2, `\u274C ${COMMAND_NAME7}: ${messageOf(error)}`);
+  }
+}
+function refusalExit(error) {
+  if (error instanceof MergeRefusal) {
+    const code = UNMERGEABLE_REASONS.has(error.reason) ? UNMERGEABLE_EXIT : REFUSED_EXIT2;
+    return new CommandExit(code, `\u274C ${COMMAND_NAME7}: ${error.message}`);
+  }
+  const known = error instanceof RebuildRefusal || error instanceof DevelopmentBuildRefusedError || error instanceof UnionSchemaMismatch;
+  return known ? new CommandExit(REFUSED_EXIT2, `\u274C ${COMMAND_NAME7}: ${error.message}`) : null;
+}
+function probeSeams(seams) {
+  return {
+    ...seams.isAlive === undefined ? {} : { isAlive: seams.isAlive },
+    ...seams.identity === undefined ? {} : { identity: seams.identity },
+    ...seams.migrations === undefined ? {} : { migrations: seams.migrations },
+    ...seams.newMergeId === undefined ? {} : { newMergeId: seams.newMergeId },
+    ...seams.readProject === undefined ? {} : { readProject: seams.readProject }
+  };
+}
+function runMerge(context, seams) {
+  const file = expectOneArgument(context.args, MERGE_USAGE);
+  const dryRun = readSwitch(DRY_RUN_FLAG3, context.flags[DRY_RUN_FLAG3], `Usage: ${MERGE_USAGE}`);
+  const project = requireProject(context, COMMAND_NAME7);
+  const path = storePath(context, project.root);
+  const backend = resolveProjectConfig(project, COMMAND_NAME7, (message) => context.output.warn(message)).store;
+  const now = seams.now ?? (() => new Date);
+  const otherPath = resolve8((seams.cwd ?? (() => process.cwd()))(), file);
+  let result;
+  try {
+    result = mergeStore({ path, otherPath, backend, dryRun, stamp: fileStamp(now()), now, env: context.env, ...probeSeams(seams) });
+  } catch (error) {
+    throw refusalExit(error) ?? error;
+  }
+  if (context.outputMode === "json") {
+    context.output.result(result);
+    return;
+  }
+  for (const line of renderMerge(result))
+    context.output.info(line);
+}
+function createMergeCommand(seams = {}) {
+  const command = {
+    name: "effort merge",
+    subject: "effort",
+    action: "merge",
+    summary: "merge another device's effort store file into this one, keeping every row and the original",
+    description: "Adds to `.rafa/effort/effort.sqlite`, or the store under `RAFA_EFFORT_DIR`, every row another" + " device's store file holds that this one lacks. A row matches on its origin pair, or on its table's" + " identity columns when either side has no origin; an equal pair is skipped, a set-once field NULL here" + " is filled, and any other difference is kept on both sides and recorded in `merge_conflicts`. The gap" + " of each commit brought in, and of the commit after it, is recomputed. The other file is only read." + " The merged store is built beside this one, checked (each table's count plus the rows added," + " integrity_check, the schema plan), and swapped in with the original kept whole as" + " `effort.sqlite.before-merge-<stamp>.bak`. It prints the rows added, skipped and in conflict per table" + " and the backup's name. Exit code 2 for another project's store, and for a `store: ndjson` project," + " naming `rafa effort move --to=sqlite`; exit code 1, changing nothing, for a missing or damaged file," + " a write in flight, a loop session running or paused, and a development build over a store it does not" + " own. With `--output=json` the outcome is the data of the terminal result event. Starts no session.",
+    args: [
+      {
+        name: "file",
+        description: "The other device's `effort.sqlite`, a consistent copy such as `rafa effort copy` makes;" + " a relative path is read from the directory the command runs in.",
+        type: "string",
+        required: true
+      }
+    ],
+    flags: [
+      {
+        name: DRY_RUN_FLAG3,
+        description: "Build and check the merged store, print what it would add, then delete it. This 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 merge ../laptop-effort/effort.sqlite --dry-run",
+        note: "Prints what the merge would add, skip and record as conflicts, changing nothing."
+      },
+      {
+        cmd: "rafa effort merge ../laptop-effort/effort.sqlite",
+        note: "Swaps the merged store in and prints where the original was kept."
+      }
+    ],
+    outputs: ["text", "json"],
+    run: async (context) => {
+      runMerge(context, seams);
+      await Promise.resolve();
+    }
+  };
+  return Object.freeze(command);
+}
+var merge_default = createMergeCommand();
+
+// src/commands/effort/migrate.ts
+import { join as join22 } from "path";
+var COMMAND_NAME8 = "rafa effort migrate";
+var MIGRATE_USAGE = "rafa effort migrate [--dry-run]";
+var DRY_RUN_FLAG4 = "dry-run";
+var REFUSED_EXIT3 = 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 [
+    `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 renderMigrate(result) {
+  switch (result.status) {
+    case "missing":
+      return [`No effort store at ${result.path}: nothing to migrate.`];
+    case "current":
+      return [`\u2705 ${result.path} is current: no migration is pending. Nothing to migrate.`];
+    case "would-migrate":
+      return [
+        ...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 "migrated":
+      return [
+        ...builtLines(result),
+        `\u2705 Migrated. The original is kept whole at ${String(result.backupPath)}; rename it back to undo.`
+      ];
+  }
+}
+function storePath2(context, root) {
+  try {
+    return join22(effortStoreDir(root, context.env), SQLITE_STORE_FILE_NAME);
+  } catch (error) {
+    throw new CommandExit(REFUSED_EXIT3, `\u274C ${COMMAND_NAME8}: ${messageOf(error)}`);
+  }
+}
+function runMigrate(context, seams) {
+  expectNoArgument(context.args, MIGRATE_USAGE);
+  const dryRun = readSwitch(DRY_RUN_FLAG4, context.flags[DRY_RUN_FLAG4], `Usage: ${MIGRATE_USAGE}`);
+  const path = storePath2(context, requireProject(context, COMMAND_NAME8).root);
+  const now = seams.now ?? (() => new Date);
+  let result;
+  try {
+    result = migrateStore({
+      path,
+      dryRun,
+      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 RebuildRefusal || error instanceof DevelopmentBuildRefusedError) {
+      throw new CommandExit(REFUSED_EXIT3, `\u274C ${COMMAND_NAME8}: ${error.message}`);
+    }
+    throw error;
+  }
+  if (context.outputMode === "json") {
+    context.output.result(result);
+    return;
+  }
+  for (const line of renderMigrate(result))
+    context.output.info(line);
+}
+function createMigrateCommand(seams = {}) {
+  const command = {
+    name: "effort migrate",
+    subject: "effort",
+    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_FLAG4,
+        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 migrate --dry-run",
+        note: "Prints what the migration applies and how it checked, changing nothing."
+      },
+      {
+        cmd: "rafa effort migrate",
+        note: "Swaps the migrated store in and prints where the original was kept."
+      }
+    ],
+    outputs: ["text", "json"],
+    run: async (context) => {
+      runMigrate(context, seams);
+      await Promise.resolve();
+    }
+  };
+  return Object.freeze(command);
+}
+var migrate_default = createMigrateCommand();
+
+// src/effort/store/move.ts
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync2 } from "fs";
+var MOVED_KINDS = Object.freeze(["sessions", "commits"]);
+var MOVE_TARGET = "sqlite";
+var STORE_LINE = `store: ${MOVE_TARGET}`;
+var STORE_KEY = /^store\s*:/u;
+var COMMENTED_STORE_KEY = /^#\s*store\s*:/u;
+
+class MoveRefusal extends Error {
+  reason;
+  constructor(reason, message) {
+    super(message);
+    this.name = "MoveRefusal";
+    this.reason = reason;
+  }
+}
+function namesStore(text) {
+  let document;
+  try {
+    document = Bun.YAML.parse(text);
+  } catch {
+    return false;
+  }
+  return isMapping(document) && Object.hasOwn(document, "store");
+}
+function withSqliteStoreSetting(text) {
+  const lines2 = text.split(`
+`);
+  const at = lines2.findIndex((line) => STORE_KEY.test(line));
+  const commented = lines2.findIndex((line) => COMMENTED_STORE_KEY.test(line));
+  const target = at >= 0 ? at : commented;
+  if (target >= 0)
+    return [...lines2.slice(0, target), STORE_LINE, ...lines2.slice(target + 1)].join(`
+`);
+  if (namesStore(text))
+    return null;
+  const body = lines2.at(-1) === "" ? lines2.slice(0, -1) : lines2;
+  return [...body, STORE_LINE, ""].join(`
+`);
+}
+function plannedConfig(path) {
+  let text;
+  try {
+    text = readFileSync8(path, "utf8");
+  } catch (error) {
+    throw new MoveRefusal("config", `${path} could not be read: ${messageOf(error)}. Nothing was moved.`);
+  }
+  const refuse = (why) => new MoveRefusal("config", `${path} ${why}, so this move cannot set ${STORE_LINE}. Nothing was moved. Set it by hand, then run the move again.`);
+  try {
+    if (parseConfigText(text, path).values.store === MOVE_TARGET)
+      return null;
+  } catch (error) {
+    throw refuse(`cannot be read as a config (${messageOf(error)})`);
+  }
+  const written = withSqliteStoreSetting(text);
+  if (written === null)
+    throw refuse("spells store in a shape this command does not edit");
+  let read;
+  try {
+    read = parseConfigText(written, path).values.store;
+  } catch (error) {
+    throw refuse(`would not parse once edited (${messageOf(error)})`);
+  }
+  if (read !== MOVE_TARGET)
+    throw refuse(`would read store as ${String(read)} once edited`);
+  return written;
+}
+function keyedRows(kind, rows) {
+  const project = EFFORT_KEY_PROJECTIONS[kind];
+  const keyed = rows.filter((row2) => project(row2) !== null);
+  return { keyed, unkeyed: rows.length - keyed.length };
+}
+function checkCounts(kind, before, added, read, after) {
+  const missing = read.filter((key) => !after.has(key));
+  if (after.size === before + added && missing.length === 0)
+    return;
+  throw new MoveRefusal("count", `the ${kind} check failed: the SQLite store held ${String(before)}, ${String(added)} were appended, and it now holds` + ` ${String(after.size)}, missing ${String(missing.length)} of the keys read. The config was not changed, so the` + " project still reads its NDJSON files.");
+}
+function moveKind(kind, source, target) {
+  const reading = source.readRows(kind);
+  const { keyed, unkeyed } = keyedRows(kind, reading.rows);
+  const project = EFFORT_KEY_PROJECTIONS[kind];
+  const before = target.keys(kind).size;
+  const appended = target.append(kind, keyed);
+  const keys = keyed.map((row2) => project(row2) ?? "");
+  checkCounts(kind, before, appended.appended, keys, target.keys(kind));
+  return {
+    kind,
+    from: source.path(kind),
+    read: keyed.length,
+    added: appended.appended,
+    skipped: appended.skipped,
+    unkeyed,
+    unparsed: reading.unparsedLineCount
+  };
+}
+function writeConfig(path, text) {
+  try {
+    writeFileSync2(path, text, "utf8");
+  } catch (error) {
+    throw new MoveRefusal("config", `${path} could not be written (${messageOf(error)}). The rows were moved and checked; set ${STORE_LINE}` + " there by hand, or run the move again, which adds nothing.");
+  }
+}
+function moveToSqlite(options) {
+  const source = options.source ?? openNdjsonStore(options.root);
+  const target = options.target ?? openSqliteStore(options.root);
+  const configPath = configFilePath(options.root);
+  const config = plannedConfig(configPath);
+  const kinds = MOVED_KINDS.map((kind) => moveKind(kind, source, target));
+  if (config !== null)
+    writeConfig(configPath, config);
+  return { to: target.path("sessions"), kinds, configPath, configChanged: config !== null };
+}
+
+// src/commands/effort/move.ts
+var COMMAND_NAME9 = "rafa effort move";
+var MOVE_USAGE = MOVE_TO_SQLITE;
+var TO_FLAG2 = "to";
+var REFUSED_EXIT4 = 1;
+function readTarget2(context) {
+  const value = context.flags[TO_FLAG2];
+  if (value === MOVE_TARGET)
+    return;
+  const found = value === undefined ? "no --to" : `--${TO_FLAG2}=${String(value)}`;
+  throw new CommandExit(REFUSED_EXIT4, `\u274C ${COMMAND_NAME9}: ${found}; a move writes to ${MOVE_TARGET} and nothing else. Nothing was moved.
+Usage: ${MOVE_USAGE}`);
+}
+function kindLine(move3) {
+  const extra = [
+    ...move3.unkeyed === 0 ? [] : [`${String(move3.unkeyed)} without a key, not moved`],
+    ...move3.unparsed === 0 ? [] : [`${String(move3.unparsed)} unparsed lines, not moved`]
+  ];
+  const counts = [`${String(move3.read)} read`, `${String(move3.added)} added`, `${String(move3.skipped)} already held`, ...extra];
+  return `  ${move3.kind}: ${counts.join(", ")} (from ${move3.from})`;
+}
+function renderMove(result) {
+  const config = result.configChanged ? `\u2705 Set store: ${MOVE_TARGET} in ${result.configPath}.` : `\u2705 ${result.configPath} already reads store: ${MOVE_TARGET}; left as it was.`;
   return [
-    `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.`
+    `Moves the NDJSON sessions and commits into ${result.to}.`,
+    ...result.kinds.map(kindLine),
+    "Checked: the SQLite store holds every key read, and its count is the old count plus the rows added.",
+    config,
+    "The NDJSON files are left where they are; running the move again adds nothing."
   ];
 }
-function renderMigrate(result) {
-  switch (result.status) {
-    case "missing":
-      return [`No effort store at ${result.path}: nothing to migrate.`];
-    case "current":
-      return [`\u2705 ${result.path} is current: no migration is pending. Nothing to migrate.`];
-    case "would-migrate":
-      return [
-        ...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 "migrated":
-      return [
-        ...builtLines(result),
-        `\u2705 Migrated. The original is kept whole at ${String(result.backupPath)}; rename it back to undo.`
-      ];
-  }
+function refusalExit2(error) {
+  const known = error instanceof MoveRefusal || error instanceof SchemaRefusedError || error instanceof DevelopmentBuildRefusedError;
+  return known ? new CommandExit(REFUSED_EXIT4, `\u274C ${COMMAND_NAME9}: ${error.message}`) : null;
 }
-function storePath(context, root) {
+function runMove(context) {
+  expectNoArgument(context.args, MOVE_USAGE);
+  readTarget2(context);
+  const project = requireProject(context, COMMAND_NAME9);
+  resolveProjectConfig(project, COMMAND_NAME9, (message) => context.output.warn(message));
   try {
-    return join20(effortStoreDir(root, context.env), SQLITE_STORE_FILE_NAME);
+    effortStoreDir(project.root, context.env);
   } catch (error) {
-    throw new CommandExit(REFUSED_EXIT2, `\u274C ${COMMAND_NAME7}: ${messageOf(error)}`);
+    throw new CommandExit(REFUSED_EXIT4, `\u274C ${COMMAND_NAME9}: ${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 = migrateStore({
-      path,
-      dryRun,
-      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 }
-    });
+    result = moveToSqlite({ root: project.root });
   } catch (error) {
-    if (error instanceof RebuildRefusal || error instanceof DevelopmentBuildRefusedError) {
-      throw new CommandExit(REFUSED_EXIT2, `\u274C ${COMMAND_NAME7}: ${error.message}`);
-    }
-    throw error;
+    throw refusalExit2(error) ?? error;
   }
   if (context.outputMode === "json") {
     context.output.result(result);
     return;
   }
-  for (const line of renderMigrate(result))
+  for (const line of renderMove(result))
     context.output.info(line);
 }
-function createMigrateCommand(seams = {}) {
+function createMoveCommand() {
   const command = {
-    name: "effort migrate",
+    name: "effort move",
     subject: "effort",
-    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.",
+    action: "move",
+    summary: "move a store: ndjson project's sessions and commits into the SQLite store and switch to it",
+    description: "Appends every session and commit row the NDJSON files under `.rafa/effort/`, or under" + " `RAFA_EFFORT_DIR`, hold to the SQLite store beside them, through the store port, so each row is" + " deduplicated by its key as `rafa effort collect` would. It then checks that the SQLite store holds" + " every key read and that its count is the old count plus the rows added, and only then sets" + " `store: sqlite` in `.rafa/config.yaml`, keeping every other line. The NDJSON files are left where" + " they are, and a move run again adds nothing, so it can be repeated once a loop started before it" + " has ended. Exit code 1, with nothing moved, for a `--to` other than `sqlite`, a config it cannot" + " edit, and a development build over a store it does not own; a failed count check is exit code 1" + " with the config left as it was. With `--output=json` the outcome is the data of the terminal" + " result event. Starts no session.",
     args: [],
     flags: [
       {
-        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"
+        name: TO_FLAG2,
+        description: "The store to move to; `sqlite` is the one value it takes, and it is required.",
+        type: "string"
       }
     ],
     examples: [
       {
-        cmd: "rafa effort migrate --dry-run",
-        note: "Prints what the migration applies and how it checked, changing nothing."
-      },
-      {
-        cmd: "rafa effort migrate",
-        note: "Swaps the migrated store in and prints where the original was kept."
+        cmd: MOVE_USAGE,
+        note: "Moves the NDJSON rows into the SQLite store, checks the counts and sets store: sqlite."
       }
     ],
     outputs: ["text", "json"],
     run: async (context) => {
-      runMigrate(context, seams);
+      runMove(context);
       await Promise.resolve();
     }
   };
   return Object.freeze(command);
 }
-var migrate_default = createMigrateCommand();
+var move_default = createMoveCommand();
 
 // src/commands/effort/report.ts
 var report_default = wrapPhaseZeroCommand({
@@ -8223,11 +8934,11 @@ var report_default = wrapPhaseZeroCommand({
 }, report);
 
 // src/commands/effort/schema.ts
-import { join as join21 } from "path";
-var COMMAND_NAME8 = "rafa effort schema";
+import { join as join23 } from "path";
+var COMMAND_NAME10 = "rafa effort schema";
 var SCHEMA_USAGE = "rafa effort schema [--check]";
 var CHECK_FLAG = "check";
-var REFUSED_EXIT3 = 1;
+var REFUSED_EXIT5 = 1;
 var FAILED_EXIT2 = 2;
 function listLine(name2, items) {
   const shown = items.length === 0 ? "none" : items.join(", ");
@@ -8267,29 +8978,29 @@ function renderSchema(report2) {
     `Next safe step: ${report2.nextStep}`
   ];
 }
-function storePath2(context, root) {
+function storePath3(context, root) {
   try {
-    return join21(effortStoreDir(root, context.env), SQLITE_STORE_FILE_NAME);
+    return join23(effortStoreDir(root, context.env), SQLITE_STORE_FILE_NAME);
   } catch (error) {
-    throw new CommandExit(REFUSED_EXIT3, `\u274C ${COMMAND_NAME8}: ${messageOf(error)}`);
+    throw new CommandExit(REFUSED_EXIT5, `\u274C ${COMMAND_NAME10}: ${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);
+  const path = storePath3(context, requireProject(context, COMMAND_NAME10).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)}`);
+    throw new CommandExit(FAILED_EXIT2, `\u274C ${COMMAND_NAME10}: ${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}`);
+    throw new CommandExit(REFUSED_EXIT5, `\u274C ${COMMAND_NAME10} --check: this rafa refuses ${path} (${report2.status}). Next safe step: ${report2.nextStep}`);
   }
   if (context.outputMode === "json")
     context.output.result(report2);
@@ -8695,7 +9406,7 @@ async function applyHorizonChange(board, reading, reason) {
 }
 
 // src/commands/epic/horizon-change.ts
-var TO_FLAG2 = "to";
+var TO_FLAG3 = "to";
 var ISSUE_NUMBER2 = /^[1-9]\d*$/u;
 var NO_ANSWERS = ["n", "no"];
 var DEFER_ACTION = Object.freeze({
@@ -8721,9 +9432,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_FLAG2, action.targets, action.usage);
+  const to = readChoiceFlag(flags, TO_FLAG3, action.targets, action.usage);
   if (to === undefined)
-    throw lineRefusal(`--${TO_FLAG2} is required: --${TO_FLAG2}=<horizon>`, action.usage);
+    throw lineRefusal(`--${TO_FLAG3} is required: --${TO_FLAG3}=<horizon>`, action.usage);
   const reason = readTextFlag(flags, REASON_FLAG, action.usage) ?? null;
   return Object.freeze({ epic: Number(word), to, reason });
 }
@@ -8736,7 +9447,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_FLAG2}=${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_FLAG3}=${change.to}. Nothing was changed`);
 }
 function workPhrase(work) {
   return [
@@ -8923,9 +9634,9 @@ function readMoveLine(context) {
     throw lineRefusal(`Expected one issue number, got ${got}`, USAGE8);
   }
   const issue = issueNumber(word, "issue number");
-  const target = readTextFlag(flags, TO_FLAG2, USAGE8);
+  const target = readTextFlag(flags, TO_FLAG3, USAGE8);
   if (target === undefined)
-    throw lineRefusal(`--${TO_FLAG2} is required: --${TO_FLAG2}=<epic>`, USAGE8);
+    throw lineRefusal(`--${TO_FLAG3} is required: --${TO_FLAG3}=<epic>`, USAGE8);
   const to = issueNumber(target, "epic number");
   const reason = readTextFlag(flags, REASON_FLAG, USAGE8) ?? null;
   return Object.freeze({ issue, to, reason });
@@ -9184,7 +9895,7 @@ function createEpicMoveCommand(seams = {}) {
     ],
     flags: [
       {
-        name: TO_FLAG2,
+        name: TO_FLAG3,
         description: "The number of the open epic it moves to. Required.",
         type: "string",
         required: true
@@ -9206,7 +9917,7 @@ function createEpicMoveCommand(seams = {}) {
   };
   return Object.freeze(command);
 }
-var move_default = createEpicMoveCommand();
+var move_default2 = createEpicMoveCommand();
 
 // src/commands/epic/cancel.ts
 var EPIC_CANCEL_REFUSAL_EXIT = 2;
@@ -9612,28 +10323,28 @@ function createEpicCancelCommand(seams = {}) {
 var cancel_default = createEpicCancelCommand();
 
 // src/commands/epic/close.ts
-import { randomUUID as randomUUID3 } from "crypto";
-import { join as join25 } from "path";
+import { randomUUID as randomUUID4 } from "crypto";
+import { join as join27 } from "path";
 
 // src/board/epic-template.ts
-import { existsSync as existsSync9, readFileSync as readFileSync8 } from "fs";
-import { dirname as dirname3, join as join22 } from "path";
+import { existsSync as existsSync10, readFileSync as readFileSync9 } from "fs";
+import { dirname as dirname4, join as join24 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
-var MODULE_DIR2 = dirname3(fileURLToPath2(import.meta.url));
+var MODULE_DIR2 = dirname4(fileURLToPath2(import.meta.url));
 var EPIC_TEMPLATE_FILE = "epic.md";
 var CRITERIA_PLACEHOLDERS = Object.freeze([
   "- Placeholder: one line per thing that makes this epic finished," + " written so a check against main can tell whether it holds."
 ]);
 var PLACEHOLDER_REASON = "the line is still the epic template's placeholder, so there is nothing to check";
 function epicTemplateSource(moduleDir = MODULE_DIR2) {
-  return join22(moduleDir, TEMPLATES_DIRNAME, EPIC_TEMPLATE_FILE);
+  return join24(moduleDir, TEMPLATES_DIRNAME, EPIC_TEMPLATE_FILE);
 }
 function readEpicTemplate(moduleDir = MODULE_DIR2) {
   const source = epicTemplateSource(moduleDir);
-  if (!existsSync9(source)) {
+  if (!existsSync10(source)) {
     throw new Error(`epic template: the epic issue template is missing: no file at ${source}`);
   }
-  return readFileSync8(source, "utf8");
+  return readFileSync9(source, "utf8");
 }
 function placeholderCriteria(criteria) {
   if (criteria === null)
@@ -9724,10 +10435,10 @@ function renderEpicCost(cost, estimate) {
 }
 
 // src/epic/verify-plan.ts
-import { existsSync as existsSync10, readFileSync as readFileSync9 } from "fs";
-import { dirname as dirname4, join as join23 } from "path";
+import { existsSync as existsSync11, readFileSync as readFileSync10 } from "fs";
+import { dirname as dirname5, join as join25 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
-var MODULE_DIR3 = dirname4(fileURLToPath3(import.meta.url));
+var MODULE_DIR3 = dirname5(fileURLToPath3(import.meta.url));
 var VERIFY_PROMPT_FILE = "epic-verify-prompt.md";
 var VERIFY_BLOCK_FENCE = "rafa:verify";
 var VERIFY_PROMPT_SLOTS = ["EPIC_NUMBER", "EPIC_TITLE", "CRITERIA"];
@@ -9782,15 +10493,15 @@ function criteriaToAsk(criteria) {
   return Object.freeze(criteria.filter((criterion) => !criterion.placeholder));
 }
 function verifyPromptCandidates(moduleDir = MODULE_DIR3) {
-  return [join23(moduleDir, VERIFY_PROMPT_FILE), join23(dirname4(moduleDir), VERIFY_PROMPT_FILE)];
+  return [join25(moduleDir, VERIFY_PROMPT_FILE), join25(dirname5(moduleDir), VERIFY_PROMPT_FILE)];
 }
 function readVerifyPrompt(moduleDir = MODULE_DIR3) {
   const candidates = verifyPromptCandidates(moduleDir);
-  const found = candidates.find((candidate) => existsSync10(candidate));
+  const found = candidates.find((candidate) => existsSync11(candidate));
   if (found === undefined) {
     throw new Error(`epic verify prompt: the verification prompt is missing: no file at ${candidates.join(" or ")}`);
   }
-  return readFileSync9(found, "utf8");
+  return readFileSync10(found, "utf8");
 }
 function fenceFor2(text) {
   const longestRun = Math.max(0, ...(text.match(/`+/gu) ?? []).map((run) => run.length));
@@ -9926,8 +10637,8 @@ function parseVerifyPlan(output, criteria) {
 }
 
 // src/epic/verify-run.ts
-import { randomUUID as randomUUID2 } from "crypto";
-import { join as join24 } from "path";
+import { randomUUID as randomUUID3 } from "crypto";
+import { join as join26 } from "path";
 var CHECK_TOOLS = ["Read", "Grep", "Glob", "Bash"];
 var DEFAULT_VERIFY_REMOTE = "origin";
 var CHECK_PROMPT_PREFIX = "# Epic acceptance check instructions";
@@ -9936,7 +10647,7 @@ var CHECK_RESULTS = ["pass", "fail"];
 var WORKTREE_PREFIX2 = "epic-";
 var VERDICT_KIND = VERDICT_BLOCK_FENCE.slice("rafa:".length);
 function verifyWorktreePath(home, epic) {
-  return join24(home, WORKTREES_SUBDIR, `${WORKTREE_PREFIX2}${String(epic)}`);
+  return join26(home, WORKTREES_SUBDIR, `${WORKTREE_PREFIX2}${String(epic)}`);
 }
 function fetchStep(remote) {
   return { id: "fetch", args: ["fetch", remote] };
@@ -10073,7 +10784,7 @@ function readCheck(check, sessionId, session) {
 }
 async function runChecks(options, worktree, prompt) {
   const spawn = options.spawn ?? spawnClaudeCaptured;
-  const pickId = options.sessionId ?? randomUUID2;
+  const pickId = options.sessionId ?? randomUUID3;
   const results = [];
   for (const check of options.checks) {
     const sessionId = pickId();
@@ -10196,7 +10907,7 @@ async function planVerification(input) {
   return Object.freeze({ status: "planned", sessionId, verdicts: reading.verdicts, issues: reading.issues });
 }
 function closeTriageFile(root, epic) {
-  return join25(root, ".rafa", `epic-${String(epic)}-close`);
+  return join27(root, ".rafa", `epic-${String(epic)}-close`);
 }
 function failedCheckArtifact(epic, criterion) {
   return `epic ${ref5(epic)} acceptance criterion: ${oneLine(criterion.text)}`;
@@ -10365,7 +11076,7 @@ async function closeEpic(context, seams) {
     config,
     seams,
     spawn: seams.spawn ?? spawnClaudeCaptured,
-    sessionId: seams.sessionId ?? randomUUID3
+    sessionId: seams.sessionId ?? randomUUID4
   };
   const gh = seams.gh ?? createGhRunner({ cwd: project.root });
   let listing;
@@ -10472,7 +11183,7 @@ function createEpicDeferCommand(seams = {}) {
     ],
     flags: [
       {
-        name: TO_FLAG2,
+        name: TO_FLAG3,
         description: `The horizon it moves to: one of ${DEFER_ACTION.targets.join(", ")}. Required.`,
         type: "string",
         required: true
@@ -10708,7 +11419,7 @@ function createEpicPromoteCommand(seams = {}) {
     ],
     flags: [
       {
-        name: TO_FLAG2,
+        name: TO_FLAG3,
         description: `The horizon it moves to: one of ${PROMOTE_ACTION.targets.join(", ")}. Required.`,
         type: "string",
         required: true
@@ -10733,13 +11444,13 @@ function createEpicPromoteCommand(seams = {}) {
 var promote_default = createEpicPromoteCommand();
 
 // src/commands/init.ts
-import { existsSync as existsSync13, readFileSync as readFileSync14 } from "fs";
+import { existsSync as existsSync14, readFileSync as readFileSync15 } from "fs";
 import { homedir } from "os";
-import { join as join30, relative as relative6, sep as sep4 } from "path";
+import { join as join32, relative as relative6, sep as sep4 } from "path";
 
 // src/agents/vendorable.ts
-import { readdirSync as readdirSync2, readFileSync as readFileSync10 } from "fs";
-import { isAbsolute as isAbsolute5, join as join26 } from "path";
+import { readdirSync as readdirSync2, readFileSync as readFileSync11 } from "fs";
+import { isAbsolute as isAbsolute5, join as join28 } from "path";
 function planFiles(dir) {
   let entries;
   try {
@@ -10751,7 +11462,7 @@ function planFiles(dir) {
 }
 function readText2(path) {
   try {
-    return readFileSync10(path, "utf8");
+    return readFileSync11(path, "utf8");
   } catch {
     return null;
   }
@@ -10761,7 +11472,7 @@ function rafaHolds(roster, name2) {
   return item?.holders.some((holder) => holder.source === "rafa") === true;
 }
 function vendorableAgents(scan) {
-  const dir = isAbsolute5(scan.planDir) ? scan.planDir : join26(scan.repoRoot, scan.planDir);
+  const dir = isAbsolute5(scan.planDir) ? scan.planDir : join28(scan.repoRoot, scan.planDir);
   const roots = {
     repoRoot: scan.repoRoot,
     home: scan.home,
@@ -10770,7 +11481,7 @@ function vendorableAgents(scan) {
   const roster = resolveAgentRoster(roots, scan.settings);
   const found = [];
   for (const file of planFiles(dir)) {
-    const path = join26(dir, file);
+    const path = join28(dir, file);
     const markdown = readText2(path);
     if (markdown === null)
       continue;
@@ -10796,13 +11507,13 @@ function vendorableAgentWarnings(agents, root) {
 
 // src/project/gitignore.ts
 import { createHash } from "crypto";
-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";
+import { existsSync as existsSync12, mkdirSync as mkdirSync4, readFileSync as readFileSync12, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname6, isAbsolute as isAbsolute6, join as join29 } from "path";
 var GITIGNORE_FILE = ".gitignore";
 var DIGEST_NAME = "tracking.digest";
 var PRIVATE_TRIAGE = "triage/private";
 var CACHE_DIR = "cache";
-var TRACKING_DIGEST_FILE = join27(SCOPE_DIR, DIGEST_NAME);
+var TRACKING_DIGEST_FILE = join29(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 = [
@@ -10823,6 +11534,7 @@ function trackingEntry(flags) {
       `${SCOPE_DIR}/${PRIVATE_TRIAGE}/`,
       `${SCOPE_DIR}/${DIGEST_NAME}`,
       `${SCOPE_DIR}/${POSITION_FILE}`,
+      `${SCOPE_DIR}/${HOP_FILE}`,
       `${SCOPE_DIR}/${CACHE_DIR}/`
     ];
   }
@@ -10890,19 +11602,19 @@ function attempt(file, failure3, act) {
   }
 }
 function readIfPresent2(file) {
-  if (!existsSync11(file))
+  if (!existsSync12(file))
     return null;
-  return attempt(file, "cannot be read", () => readFileSync11(file, "utf8"));
+  return attempt(file, "cannot be read", () => readFileSync12(file, "utf8"));
 }
 function writeTrackingGitignore(root, flags) {
   requireAbsolute(root);
-  const file = join27(root, GITIGNORE_FILE);
+  const file = join29(root, GITIGNORE_FILE);
   const text = readIfPresent2(file);
   const next = withTrackingBlock(text, flags, file);
   if (next === text)
     return { file, change: "unchanged" };
   attempt(file, "cannot be written", () => {
-    writeFileSync2(file, next);
+    writeFileSync3(file, next);
   });
   const change = text === null ? "created" : "updated";
   return { file, change };
@@ -10918,7 +11630,7 @@ function trackingDigest(flags) {
 }
 function exposureNotice(root) {
   return [
-    `tracking.all is true, so ${join27(root, GITIGNORE_FILE)} no longer ignores ${SCOPE_DIR}/` + " and a commit can carry what it holds, including:",
+    `tracking.all is true, so ${join29(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",
@@ -10931,7 +11643,7 @@ function printWarning(message) {
 }
 function noticeTrackingChange(root, flags, print2 = printWarning) {
   requireAbsolute(root);
-  const digestFile = join27(root, TRACKING_DIGEST_FILE);
+  const digestFile = join29(root, TRACKING_DIGEST_FILE);
   const recorded = `${trackingDigest(flags)}
 `;
   if (readIfPresent2(digestFile) === recorded) {
@@ -10940,8 +11652,8 @@ function noticeTrackingChange(root, flags, print2 = printWarning) {
   if (flags.trackingAll)
     print2(exposureNotice(root));
   attempt(digestFile, "cannot be written", () => {
-    mkdirSync4(dirname5(digestFile), { recursive: true });
-    writeFileSync2(digestFile, recorded);
+    mkdirSync4(dirname6(digestFile), { recursive: true });
+    writeFileSync3(digestFile, recorded);
   });
   return { digestFile, changed: true, printed: flags.trackingAll };
 }
@@ -10951,12 +11663,12 @@ function applyTracking(root, flags, print2 = printWarning) {
 }
 
 // src/project/root-choice.ts
-import { resolve as resolve9 } from "path";
+import { resolve as resolve10 } from "path";
 
 // src/project/roots.ts
 import { spawnSync } from "child_process";
-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";
+import { accessSync, constants as constants2, readFileSync as readFileSync13, statSync as statSync8 } from "fs";
+import { isAbsolute as isAbsolute7, join as join30, resolve as resolve9 } from "path";
 var REFUSED_ROOTS = Object.freeze([
   { path: "/", why: "is the filesystem root" },
   { path: "/var", why: "holds system state" },
@@ -10976,7 +11688,7 @@ var PACKAGE_JSON = "package.json";
 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"),
+  readFile: (path) => readFileSync13(path, "utf8"),
   isDirectory: (path) => statSync8(path).isDirectory(),
   assertWritable: (path) => accessSync(path, constants2.W_OK)
 });
@@ -11019,7 +11731,7 @@ function realOrSpelled(path, fs) {
   try {
     return fs.realpath(path);
   } catch {
-    return resolve8(path);
+    return resolve9(path);
   }
 }
 function namedRoots(home, fs) {
@@ -11061,7 +11773,7 @@ function writeRefusal(given, real, fs) {
 }
 function refusalOf(given, named2, fs) {
   const resolved = resolveReal(given, fs);
-  const byName2 = namedRefusal(given, resolved.real ?? resolve8(given), named2);
+  const byName2 = namedRefusal(given, resolved.real ?? resolve9(given), named2);
   if (byName2 !== null)
     return byName2;
   if (resolved.real === null) {
@@ -11089,8 +11801,8 @@ function readManifest2(file, fs) {
   }
 }
 function readDir(dir, fs) {
-  const manifest = readManifest2(join28(dir, PACKAGE_JSON), fs);
-  const files = MONOREPO_MARKER_FILES.filter((name2) => fs.exists(join28(dir, name2)));
+  const manifest = readManifest2(join30(dir, PACKAGE_JSON), fs);
+  const files = MONOREPO_MARKER_FILES.filter((name2) => fs.exists(join30(dir, name2)));
   const markers = manifest.marks ? [PACKAGE_JSON, ...files] : files;
   return { ...manifest, dir, markers };
 }
@@ -11160,7 +11872,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 = resolve9(start2, typed);
+  const path = resolve10(start2, typed);
   const refusal9 = rootRefusal(path, seams);
   if (refusal9 !== null)
     return problem(refusal9.reason);
@@ -11201,8 +11913,8 @@ async function promptForRoot(found, prompter, seams) {
 }
 
 // src/project/scaffold.ts
-import { existsSync as existsSync12, lstatSync, mkdirSync as mkdirSync5, statSync as statSync9, writeFileSync as writeFileSync3 } from "fs";
-import { join as join29 } from "path";
+import { existsSync as existsSync13, lstatSync, mkdirSync as mkdirSync5, statSync as statSync9, writeFileSync as writeFileSync4 } from "fs";
+import { join as join31 } from "path";
 var PROJECT_TREE = Object.freeze(["specs", "plans", "runs", "effort", "instincts"]);
 var USER_TREE = Object.freeze(["instincts"]);
 var CONFIG_SETTINGS_LINES = Object.freeze([
@@ -11305,7 +12017,7 @@ class ScaffoldError extends Error {
 }
 function layoutOf2(base, tree) {
   const scope = scopeAt(base);
-  return { dirs: [scope.dir, ...tree.map((name2) => join29(scope.dir, name2))], configFile: configFilePath(base) };
+  return { dirs: [scope.dir, ...tree.map((name2) => join31(scope.dir, name2))], configFile: configFilePath(base) };
 }
 function occupied(path) {
   return lstatSync(path, { throwIfNoEntry: false }) !== undefined;
@@ -11316,7 +12028,7 @@ function isDirectory2(path) {
 function directoryConflict(dir) {
   if (!occupied(dir) || isDirectory2(dir))
     return null;
-  return existsSync12(dir) ? `${dir} is not a directory` : `${dir} is a link to nothing`;
+  return existsSync13(dir) ? `${dir} is not a directory` : `${dir} is a link to nothing`;
 }
 function layoutConflicts(layout) {
   const [scopeDir, ...tree] = layout.dirs;
@@ -11324,7 +12036,7 @@ function layoutConflicts(layout) {
   if (opening !== null)
     return [opening];
   const dirs = tree.flatMap((dir) => directoryConflict(dir) ?? []);
-  const file = occupied(layout.configFile) && !existsSync12(layout.configFile) ? [`${layout.configFile} is a link to nothing`] : [];
+  const file = occupied(layout.configFile) && !existsSync13(layout.configFile) ? [`${layout.configFile} is a link to nothing`] : [];
   return [...dirs, ...file];
 }
 function scaffoldConflicts(root, home) {
@@ -11338,7 +12050,7 @@ function attempt2(path, failure3, act) {
   }
 }
 function ensureDirectory(path) {
-  if (existsSync12(path))
+  if (existsSync13(path))
     return { path, kind: "directory", change: "unchanged" };
   attempt2(path, "cannot be created", () => {
     mkdirSync5(path, { recursive: true });
@@ -11346,10 +12058,10 @@ function ensureDirectory(path) {
   return { path, kind: "directory", change: "created" };
 }
 function ensureFile(path, text) {
-  if (existsSync12(path))
+  if (existsSync13(path))
     return { path, kind: "file", change: "unchanged" };
   attempt2(path, "cannot be written", () => {
-    writeFileSync3(path, text, { encoding: "utf8", flag: "wx" });
+    writeFileSync4(path, text, { encoding: "utf8", flag: "wx" });
   });
   return { path, kind: "file", change: "created" };
 }
@@ -11366,10 +12078,10 @@ function writeUserScope(home) {
 }
 
 // src/commands/init-release.ts
-import { writeFileSync as writeFileSync4 } from "fs";
+import { writeFileSync as writeFileSync5 } from "fs";
 
 // src/release/setting.ts
-import { readFileSync as readFileSync13 } from "fs";
+import { readFileSync as readFileSync14 } from "fs";
 var RELEASE_ENABLED_SETTING = "release.enabled";
 function releaseEnabledIn(text, path) {
   return parseConfigText(text, path).values.releaseEnabled ?? null;
@@ -11378,7 +12090,7 @@ function readReleaseSetting(root) {
   const path = configFilePath(root);
   let text;
   try {
-    text = readFileSync13(path, "utf8");
+    text = readFileSync14(path, "utf8");
   } catch (error) {
     return { enabled: null, text: "", problem: `${path} could not be read: ${messageOf(error)}` };
   }
@@ -11499,7 +12211,7 @@ function writeSetting(root, text, enabled) {
     return `the file this run would have written reads ${RELEASE_ENABLED_SETTING} as ${describeValue(read)}`;
   }
   try {
-    writeFileSync4(path, written, "utf8");
+    writeFileSync5(path, written, "utf8");
   } catch (error) {
     return `it could not be written: ${messageOf(error)}`;
   }
@@ -11662,9 +12374,9 @@ function resolvedConfig2(root, home, warn3) {
   }
 }
 function checkGitignore(root, flags) {
-  const file = join30(root, GITIGNORE_FILE);
+  const file = join32(root, GITIGNORE_FILE);
   try {
-    const text = existsSync13(file) ? readFileSync14(file, "utf8") : null;
+    const text = existsSync14(file) ? readFileSync15(file, "utf8") : null;
     withTrackingBlock(text, flags, file);
   } catch (error) {
     const message = error instanceof GitignoreError ? error.message : `rafa init: ${file} cannot be read (${messageOf(error)})`;
@@ -11695,8 +12407,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 = existsSync13(configFilePath(root.path));
-  const digestExisted = existsSync13(join30(root.path, TRACKING_DIGEST_FILE));
+  const configExisted = existsSync14(configFilePath(root.path));
+  const digestExisted = existsSync14(join32(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)];
@@ -11874,7 +12586,7 @@ function createInitCommand(seams = DEFAULT_INIT_SEAMS) {
 var init_default = createInitCommand();
 
 // src/commands/check-report.ts
-import { resolve as resolve10 } from "path";
+import { resolve as resolve11 } from "path";
 var DEFAULT_CHECK_SEAMS = Object.freeze({
   cwd: () => process.cwd()
 });
@@ -11890,7 +12602,7 @@ Usage: ${usage2}`);
     throw new CommandExit(1, `\u274C Expected one directory, and read "${extra}" as a second
 Usage: ${usage2}`);
   }
-  return resolve10(cwd(), dir);
+  return resolve11(cwd(), dir);
 }
 function readFix(value, usage2) {
   if (value === undefined || value === false || value === "false")
@@ -11907,7 +12619,7 @@ function readProjectRoot(value, usage2, cwd) {
     throw new CommandExit(1, `\u274C --project needs a path, and the line gave it none
 Usage: ${usage2}`);
   }
-  return resolve10(cwd(), value);
+  return resolve11(cwd(), value);
 }
 function reportMarker(report2) {
   if (report2.failed)
@@ -12543,8 +13255,8 @@ function createInstinctShowCommand() {
 var show_default3 = createInstinctShowCommand();
 
 // src/commands/issue/check.ts
-import { readdirSync as readdirSync3, readFileSync as readFileSync15, statSync as statSync10 } from "fs";
-import { join as join31, resolve as resolve11 } from "path";
+import { readdirSync as readdirSync3, readFileSync as readFileSync16, statSync as statSync10 } from "fs";
+import { join as join33, resolve as resolve12 } from "path";
 var CHECK_USAGE = "rafa issue check <n> [--stamp]";
 var STAMP_FLAG = "stamp";
 var ISSUE_NUMBER6 = /^[1-9]\d*$/u;
@@ -12576,22 +13288,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) => statSync10(join31(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(join33(dir, name2)).isFile()).sort();
 }
 function findSavedCopy(root, specsDir, issue) {
-  const names = copyNames(resolve11(root, specsDir), issue);
+  const names = copyNames(resolve12(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) => `   ${join31(specsDir, name2)}`)
+      ...names.map((name2) => `   ${join33(specsDir, name2)}`)
     ].join(`
 `));
   }
-  const path = join31(specsDir, only);
-  return { path, absolute: resolve11(root, path) };
+  const path = join33(specsDir, only);
+  return { path, absolute: resolve12(root, path) };
 }
 function liveText(live) {
   return live.kind === "unreadable" ? "unreadable" : fingerprintText(live);
@@ -12639,7 +13351,7 @@ async function readReferences(absolute, issue, verify, stamp) {
     return rows.map((row2) => checkedRef(row2, row2.stamp));
   }
   const once2 = memoiseVerifier(verify);
-  const before = await readRefsText({ copy: readFileSync15(absolute, "utf8"), issue, verify: once2 });
+  const before = await readRefsText({ copy: readFileSync16(absolute, "utf8"), issue, verify: once2 });
   const after = await restampCopyRefs({ path: absolute, issue, verify: once2 });
   return before.rows.map((row2, index) => checkedRef(row2, after.rows[index]?.stamp ?? null));
 }
@@ -12920,7 +13632,7 @@ function createIssueMoveCommand(seams = DEFAULT_ISSUE_SEAMS) {
   };
   return Object.freeze(command);
 }
-var move_default2 = createIssueMoveCommand();
+var move_default3 = createIssueMoveCommand();
 
 // src/commands/issue/show.ts
 var USAGE19 = "rafa issue show <id>";
@@ -13494,7 +14206,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, 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.",
+  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, and under `--roadmap`" + " the hop away, when one is. 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: [
     {
@@ -13550,6 +14262,11 @@ var wrapped = wrapPhaseZeroCommand({
       description: "Runs on `main` or `master`, which the loop otherwise refuses.",
       type: "boolean"
     },
+    {
+      name: "roadmap",
+      description: "Stamps the hop `rafa next --roadmap` is away on, when one is, on the session record as" + " its `hop`: the hop record `.rafa/hop.json` holds, still `away` and its home still the" + " position's. What `rafa next --roadmap` passes to the loop it starts.",
+      type: "boolean"
+    },
     {
       name: "detached",
       description: "Runs the loop in the background. Refused until phase 6, before anything is read:" + " until then a run holds the terminal it starts in.",
@@ -13904,15 +14621,18 @@ function isAlwaysAsked(action) {
   return ALWAYS_ASKED.has(action);
 }
 var CEILING_REFUSAL_EXIT = 2;
+var ROADMAP_ACTIONS = new Set(["hop", "home"]);
 var YES_ACTIONS = Object.freeze([
   "sync",
-  ...NEXT_COMMAND_ACTIONS.filter((action) => !ALWAYS_ASKED.has(action))
+  ...NEXT_COMMAND_ACTIONS.filter((action) => !ALWAYS_ASKED.has(action)),
+  ...ROADMAP_ACTIONS
 ]);
 var BARE_YES_ACTIONS = Object.freeze([
   "sync",
   "wait",
   "unblock",
-  "plan"
+  "plan",
+  "home"
 ]);
 function ceilingRefusal(problem2, usage2) {
   return new CommandExit(CEILING_REFUSAL_EXIT, `\u274C ${problem2}
@@ -13941,6 +14661,85 @@ function allowedUnasked(action, ceiling) {
   return ceiling.includes(action);
 }
 
+// src/next/lines.ts
+var NEXT_USAGE = "rafa next [--dry-run] [--roadmap] [--yes[=<action ids>]]";
+var DRY_RUN_FLAG5 = "dry-run";
+var ROADMAP_FLAG = "roadmap";
+var STATE_MARK = "\uD83D\uDCCD";
+var PROPOSAL_MARK = "\uD83D\uDC49";
+var STOP_MARK = "\u23F9";
+var MAX_ACTIONS = 12;
+function stateLine(state) {
+  return `${STATE_MARK} ${state.reading}.`;
+}
+function proposalLine(state, invocation) {
+  const runs = invocation === null ? "" : ` \u2014 rafa ${commandWords(invocation)}`;
+  return `${PROPOSAL_MARK} ${state.proposal}${runs}`;
+}
+function shownIds(ids, roadmap) {
+  return roadmap ? ids : ids.filter((action) => !ROADMAP_ACTIONS.has(action));
+}
+function namedIds(ceiling, roadmap) {
+  const shown = shownIds(ceiling, roadmap);
+  return shown.length === 0 ? "no action" : shown.join(", ");
+}
+function dryRunLine(dryRun, roadmap) {
+  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}=${shownIds(BARE_YES_ACTIONS, roadmap).join(",")} to allow those steps unasked.`;
+  }
+  return `${STOP_MARK} --${DRY_RUN_FLAG5}: nothing ran.`;
+}
+function stopLine(stop, state, ceiling, dryRun, roadmap = false) {
+  if (stop === "dry-run")
+    return dryRunLine(dryRun, roadmap);
+  if (stop === "declined")
+    return `${STOP_MARK} Nothing ran.`;
+  if (stop === "unasked") {
+    const allows = `${STOP_MARK} --${YES_FLAG} allows ${namedIds(ceiling ?? [], roadmap)}, and this step is ${state.action},` + " so nothing ran;";
+    if (ALWAYS_ASKED.has(state.action)) {
+      return `${allows} no --${YES_FLAG} list allows it, so drop --${YES_FLAG} to be asked.`;
+    }
+    return `${allows} type --${YES_FLAG}=${[...shownIds(ceiling ?? [], roadmap), state.action].join(",")} to allow it,` + ` or drop --${YES_FLAG} to be asked.`;
+  }
+  if (stop === "loop-started") {
+    return `${STOP_MARK} The loop has run; rafa next reads where it left the project.`;
+  }
+  if (stop === "unchanged") {
+    return `${STOP_MARK} That last step left the project where it was, so the chain stops rather than repeating it.`;
+  }
+  if (stop === "capped") {
+    return `${STOP_MARK} ${MAX_ACTIONS} actions have run, which is as many as one chain runs; run rafa next again.`;
+  }
+  return null;
+}
+function lineRefusal2(problem2) {
+  return new CommandExit(1, `\u274C ${problem2}
+Usage: ${NEXT_USAGE}`);
+}
+function readDryRun(flags) {
+  return readBareFlag(flags, DRY_RUN_FLAG5);
+}
+function readRoadmap(flags) {
+  return readBareFlag(flags, ROADMAP_FLAG);
+}
+function readBareFlag(flags, name2) {
+  const value = flags[name2];
+  if (value === undefined)
+    return false;
+  if (typeof value === "boolean")
+    return value;
+  if (value === "true" || value === "false")
+    return value === "true";
+  throw lineRefusal2(`--${name2} takes no value, and read "${value}" as one`);
+}
+function dryRunOf(flag, ceiling, hasTerminal) {
+  if (flag)
+    return "flag";
+  if (ceiling === null && !hasTerminal)
+    return "no-terminal";
+  return null;
+}
+
 // src/next/sync.ts
 var INDENT = "   ";
 function refuse(lines2) {
@@ -13995,53 +14794,8 @@ function fastForwardBase(git, plan2) {
 }
 
 // src/commands/next.ts
-var NEXT_USAGE = "rafa next [--dry-run] [--yes[=<action ids>]]";
-var DRY_RUN_FLAG4 = "dry-run";
-var STATE_MARK = "\uD83D\uDCCD";
-var PROPOSAL_MARK = "\uD83D\uDC49";
-var STOP_MARK = "\u23F9";
-var MAX_ACTIONS = 12;
 var LOOP_ACTIONS = Object.freeze(["start", "resume"]);
 var QUESTION_HANDED_OVER = new Set(["merge-unchecked"]);
-function stateLine(state) {
-  return `${STATE_MARK} ${state.reading}.`;
-}
-function proposalLine(state, invocation) {
-  const runs = invocation === null ? "" : ` \u2014 rafa ${commandWords(invocation)}`;
-  return `${PROPOSAL_MARK} ${state.proposal}${runs}`;
-}
-function namedIds(ceiling) {
-  return ceiling.length === 0 ? "no action" : ceiling.join(", ");
-}
-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_FLAG4}: nothing ran.`;
-}
-function stopLine(stop, state, ceiling, dryRun) {
-  if (stop === "dry-run")
-    return dryRunLine(dryRun);
-  if (stop === "declined")
-    return `${STOP_MARK} Nothing ran.`;
-  if (stop === "unasked") {
-    const allows = `${STOP_MARK} --${YES_FLAG} allows ${namedIds(ceiling ?? [])}, and this step is ${state.action},` + " so nothing ran;";
-    if (ALWAYS_ASKED.has(state.action)) {
-      return `${allows} no --${YES_FLAG} list allows it, so drop --${YES_FLAG} to be asked.`;
-    }
-    return `${allows} type --${YES_FLAG}=${[...ceiling ?? [], state.action].join(",")} to allow it,` + ` or drop --${YES_FLAG} to be asked.`;
-  }
-  if (stop === "loop-started") {
-    return `${STOP_MARK} The loop has run; rafa next reads where it left the project.`;
-  }
-  if (stop === "unchanged") {
-    return `${STOP_MARK} That last step left the project where it was, so the chain stops rather than repeating it.`;
-  }
-  if (stop === "capped") {
-    return `${STOP_MARK} ${MAX_ACTIONS} actions have run, which is as many as one chain runs; run rafa next again.`;
-  }
-  return null;
-}
 function repeats(previous, state) {
   if (previous === null)
     return false;
@@ -14057,82 +14811,74 @@ function stepOf2(state, invocation, over = {}) {
     ...over
   });
 }
-function ended(steps, step, stop) {
-  return Object.freeze({ steps: Object.freeze([...steps, step]), stop });
+async function playTurn(options, state, previous) {
+  const { run, ask, handOver, ceiling, dryRun, info: info2, warn: warn3, roadmap } = options;
+  for (const problem2 of state.problems)
+    warn3(problem2);
+  const invocation = actionInvocation(state, { roadmap: roadmap !== undefined });
+  info2(stateLine(state));
+  info2(proposalLine(state, invocation));
+  const halt = (stop, over = {}) => ({ stop, step: stepOf2(state, invocation, over) });
+  if (dryRun !== null)
+    return halt("dry-run");
+  if (state.action === "none")
+    return halt("nothing-to-run");
+  if (repeats(previous, state))
+    return halt("unchanged");
+  const unasked = allowedUnasked(state.action, ceiling);
+  if (!unasked && ceiling !== null)
+    return halt("unasked");
+  const handedOver = QUESTION_HANDED_OVER.has(state.action);
+  const asks = !unasked && !handedOver;
+  if (asks && !await ask(nextQuestion(state)))
+    return halt("declined", { asked: true });
+  if (handedOver)
+    handOver?.();
+  await run(state);
+  return { stop: null, step: stepOf2(state, invocation, { asked: asks, ran: true }) };
 }
 async function runNextChain(options) {
-  const { read, run, ask, handOver, ceiling, dryRun, info: info2, warn: warn3 } = options;
+  const { read, ceiling, dryRun, info: info2, roadmap } = options;
   let steps = [];
+  let hops = [];
   let previous = null;
+  const report2 = (stop) => Object.freeze({
+    steps: Object.freeze([...steps]),
+    stop,
+    ...roadmap === undefined ? {} : { hops: Object.freeze([...hops]) }
+  });
+  const stopOn = (stop, state) => {
+    const line = stopLine(stop, state, ceiling, dryRun, roadmap !== undefined);
+    if (line !== null)
+      info2(line);
+    return report2(stop);
+  };
+  const turn = async (state, before) => {
+    const end = await playTurn(options, state, before);
+    steps = [...steps, end.step];
+    if (end.stop === null && state.hop !== undefined)
+      hops = [...hops, state.hop];
+    return end.stop;
+  };
   for (;; ) {
     const state = await read();
-    for (const problem2 of state.problems)
-      warn3(problem2);
-    const invocation = actionInvocation(state);
-    info2(stateLine(state));
-    info2(proposalLine(state, invocation));
-    const announce = (stop) => {
-      const line = stopLine(stop, state, ceiling, dryRun);
-      if (line !== null)
-        info2(line);
-    };
-    const stopHere = (stop, over = {}) => {
-      announce(stop);
-      return ended(steps, stepOf2(state, invocation, over), stop);
-    };
-    const stopAfter = (stop) => {
-      announce(stop);
-      return Object.freeze({ steps, stop });
-    };
-    if (dryRun !== null)
-      return stopHere("dry-run");
-    if (state.action === "none")
-      return stopHere("nothing-to-run");
-    if (repeats(previous, state))
-      return stopHere("unchanged");
-    const unasked = allowedUnasked(state.action, ceiling);
-    if (!unasked && ceiling !== null)
-      return stopHere("unasked");
-    const handedOver = QUESTION_HANDED_OVER.has(state.action);
-    const asks = !unasked && !handedOver;
-    if (asks && !await ask(nextQuestion(state)))
-      return stopHere("declined", { asked: true });
-    if (handedOver)
-      handOver?.();
-    await run(state);
-    steps = [...steps, stepOf2(state, invocation, { asked: asks, ran: true })];
-    if (LOOP_ACTIONS.includes(state.action))
-      return stopAfter("loop-started");
+    const stop = await turn(state, previous);
+    if (stop !== null)
+      return stopOn(stop, state);
+    if (LOOP_ACTIONS.includes(state.action)) {
+      const home = roadmap === undefined ? null : await roadmap.afterLoop();
+      const homeStop = home === null ? null : await turn(home, null);
+      return homeStop === null ? stopOn("loop-started", state) : stopOn(homeStop, home ?? state);
+    }
     if (steps.length >= MAX_ACTIONS)
-      return stopAfter("capped");
+      return stopOn("capped", state);
     previous = state;
   }
 }
-function lineRefusal2(problem2) {
-  return new CommandExit(1, `\u274C ${problem2}
-Usage: ${NEXT_USAGE}`);
-}
-function readDryRun(flags) {
-  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_FLAG4} takes no value, and read "${value}" as one`);
-}
-function dryRunOf(flag, ceiling, hasTerminal) {
-  if (flag)
-    return "flag";
-  if (ceiling === null && !hasTerminal)
-    return "no-terminal";
-  return null;
-}
 var DEFAULT_NEXT_SEAMS = Object.freeze({});
 async function runStateAction(context, sources, state) {
   if (state.action !== "sync") {
-    await runAction({ ...context, output: actionOutput(context.output) }, state);
+    await runAction({ ...context, output: actionOutput(context.output) }, state, { roadmap: sources.roadmap !== undefined });
     return;
   }
   const outcome2 = fastForwardBase(sources.git, { base: sources.base, remote: sources.remote ?? REMOTE });
@@ -14150,13 +14896,22 @@ function endOfEpic(context, sources, report2, epic) {
   for (const line of epicEndLines(epic, release))
     context.output.info(line);
 }
+async function homeAfterLoop(context, sources) {
+  try {
+    return await readHomeAfterLoop(sources.answer());
+  } catch (error) {
+    context.output.warn(`the hop could not be read after the loop, so rafa next does not go home: ${messageOf(error)}`);
+    return null;
+  }
+}
 async function runNext(context, seams) {
   expectNoArgument(context.args, NEXT_USAGE);
   const flagged = readDryRun(context.flags);
+  const roadmap = readRoadmap(context.flags);
   const ceiling = readYesCeiling(context.flags, NEXT_USAGE);
   const isTerminal = seams.isTerminal ?? (() => process.stdin.isTTY === true);
   const dryRun = dryRunOf(flagged, ceiling, isTerminal());
-  const sources = openNextSources(context, seams);
+  const sources = openNextSources(context, seams, roadmap ? { roadmap } : {});
   const openPrompter = seams.openPrompter ?? (() => createLinePrompter(process.stdin, process.stderr));
   const prompter = lazyPrompter(openPrompter);
   const dry = watchDryEpic();
@@ -14173,7 +14928,8 @@ async function runNext(context, seams) {
       },
       warn: (line) => {
         context.output.warn(line);
-      }
+      },
+      ...roadmap ? { roadmap: { afterLoop: () => homeAfterLoop(context, sources) } } : {}
     });
     endOfEpic(context, sources, report2, dry.last());
     return report2;
@@ -14184,10 +14940,15 @@ async function runNext(context, seams) {
 var YES_ID_LIST = YES_ACTIONS.join(", ");
 var NEXT_FLAGS = Object.freeze([
   {
-    name: DRY_RUN_FLAG4,
+    name: DRY_RUN_FLAG5,
     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"
   },
+  {
+    name: ROADMAP_FLAG,
+    description: "Follow one blocker into another epic or board and come home: where the walk stops at an issue" + " blocked by one in another epic, or at an epic with no line left, propose the hop there, pass" + " --roadmap to plan create and loop start, and go home once the loop has run. A blocker that is" + " itself blocked halts with the chain instead, and a pull request whose owner has not approved is" + " not merged.",
+    type: "boolean"
+  },
   {
     name: YES_FLAG,
     description: "Run the actions named without asking, as a comma list of action ids, and stop at the first" + ` action the list leaves out. Bare it names ${BARE_YES_ACTIONS.join(", ")}. The ids are ${YES_ID_LIST};` + ` a list naming ${[...ALWAYS_ASKED].join(" or ")}, which are always asked, or a word that is no id at all` + " is refused.",
@@ -14200,7 +14961,7 @@ function createNextCommand(seams = DEFAULT_NEXT_SEAMS) {
     subject: "next",
     action: "next",
     summary: "say where the project stands, propose the one next step, and run it on a yes",
-    description: "Reads the project once \u2014 the running loops, the branch and its base, the plans and their" + " trackers, the open pull request and its checks, and the roadmap \u2014 and prints where it stands on one" + " line and the one thing to do about it on the next. On a yes it runs that action by calling the" + " command that does it, then reads the project again and proposes what follows. It stops when the" + " answer is no, when an action fails, when there is nothing to run, and once a loop has started. A" + " working tree with changes to tracked files and a pull request provider that cannot be asked are" + " reported in place of a proposal. A pull request no check has reported on is proposed as" + " `rafa pr merge <n> --skip-checks`, which asks its own question after the warning it prints, so" + " rafa next asks none before it. `--dry-run` prints the two lines and stops, and so does a run" + " with no terminal to answer on and no `--yes`, since there is nobody to put the question to." + " With `--output=json`" + " the steps and why the chain stopped are the data of the terminal result event.",
+    description: "Reads the project once \u2014 the running loops, the branch and its base, the plans and their" + " trackers, the open pull request and its checks, and the roadmap \u2014 and prints where it stands on one" + " line and the one thing to do about it on the next. On a yes it runs that action by calling the" + " command that does it, then reads the project again and proposes what follows. It stops when the" + " answer is no, when an action fails, when there is nothing to run, and once a loop has started. A" + " working tree with changes to tracked files and a pull request provider that cannot be asked are" + " reported in place of a proposal. A pull request no check has reported on is proposed as" + " `rafa pr merge <n> --skip-checks`, which asks its own question after the warning it prints, so" + " rafa next asks none before it. `--dry-run` prints the two lines and stops, and so does a run" + " with no terminal to answer on and no `--yes`, since there is nobody to put the question to." + " With `--roadmap` it follows one blocker into another epic or board, works it up to its pull" + " request and comes home, halting where that blocker is blocked in turn." + " With `--output=json`" + " the steps and why the chain stopped are the data of the terminal result event, and under" + " `--roadmap` the hops that ran as well.",
     args: [],
     flags: [...NEXT_FLAGS],
     examples: [
@@ -14215,6 +14976,10 @@ function createNextCommand(seams = DEFAULT_NEXT_SEAMS) {
       {
         cmd: "rafa next --yes=sync,plan",
         note: "Fast-forwards the base and creates the next plan unasked, stopping at any other step."
+      },
+      {
+        cmd: "rafa next --roadmap --yes=hop,plan,start,home",
+        note: "Hops to the epic holding the blocker, plans and runs it, and comes home unasked."
       }
     ],
     outputs: ["text", "json"],
@@ -14253,6 +15018,11 @@ var wrapped2 = wrapPhaseZeroCommand({
       description: "Plans the first line of the roadmap issue that is neither done nor taken, then as" + " `--issue`. The roadmap is `roadmap.issue` in the config, else the pinned issue titled `Roadmap`;" + " `--next=<n>` reads issue `<n>` as the roadmap instead.",
       type: "boolean"
     },
+    {
+      name: "roadmap",
+      description: "With `--next`, plans the target of the `rafa next --roadmap` hop under way, the blocker it" + " went to another epic or board for, through the same checks as any line; with no hop away it picks" + " as `--next` does. Refused with exit 2 without `--next`.",
+      type: "boolean"
+    },
     {
       name: "refresh",
       description: "Rebuilds a snapshot that no longer matches the issue without asking; the old copy moves under" + " `previous/`.",
@@ -14309,6 +15079,10 @@ var wrapped2 = wrapPhaseZeroCommand({
       cmd: "rafa plan create --next --dry-run",
       note: "Prints the first roadmap line that is neither done nor taken, with what it skipped to reach" + " it, and stops without writing a snapshot or starting a session."
     },
+    {
+      cmd: "rafa plan create --next --roadmap",
+      note: "While a rafa next --roadmap hop is away, plans the blocker it went for on that blocker's own" + " board; with none away, plans as rafa plan create --next does."
+    },
     {
       cmd: "rafa plan create --issue=20 --refresh --skip-review --no-comment",
       note: "Takes issue 20 as it reads now over the snapshot already there, plans without the planner" + " judging the spec first, and keeps any gaps off the board."
@@ -14321,8 +15095,8 @@ var wrapped2 = wrapPhaseZeroCommand({
 var create_default2 = endingWith(wrapped2);
 
 // src/commands/plan/risk.ts
-import { readFileSync as readFileSync16 } from "fs";
-import { resolve as resolve12 } from "path";
+import { readFileSync as readFileSync17 } from "fs";
+import { resolve as resolve13 } from "path";
 var COMMAND2 = "rafa plan risk";
 var USAGE27 = "rafa plan risk [<plan>] [--strict]";
 var STRICT_HINT = `Type the plan first: ${COMMAND2} <plan> --strict`;
@@ -14335,7 +15109,7 @@ function riskPlanPath(root, planDir, typed) {
     return path;
   if (typed !== null)
     throw new CommandExit(1, `\u274C Plan file not found: ${path}`);
-  const lookedFor = [...new Set([resolve12(root, planDir, DEFAULT_PLAN_FILE), resolve12(root, DEFAULT_PLAN_FILE)])];
+  const lookedFor = [...new Set([resolve13(root, planDir, DEFAULT_PLAN_FILE), resolve13(root, DEFAULT_PLAN_FILE)])];
   throw new CommandExit(1, `\u274C No plan named, and no default plan at ${lookedFor.join(" or ")}
 Usage: ${USAGE27}`);
 }
@@ -14349,7 +15123,7 @@ function strictRefusal(report2) {
 }
 async function readRisk(path, project, config, context, seams) {
   const makeRunners = seams.runners ?? spawningRunners;
-  return assessPlanRisk({ path, text: readFileSync16(path, "utf8") }, {
+  return assessPlanRisk({ path, text: readFileSync17(path, "utf8") }, {
     repoRoot: project.root,
     home: project.home,
     settingSources: config.settingSources,
@@ -14432,8 +15206,8 @@ function createPlanRiskCommand(seams = {}) {
 var risk_default = createPlanRiskCommand();
 
 // src/commands/plan/show.ts
-import { readFileSync as readFileSync17 } from "fs";
-import { join as join32 } from "path";
+import { readFileSync as readFileSync18 } from "fs";
+import { join as join34 } from "path";
 var USAGE28 = "rafa plan show <stub> [--tracker]";
 var COMMAND3 = "rafa plan show";
 function readTrackerFlag(value) {
@@ -14451,10 +15225,10 @@ function showPlan(plans, stub, tracker) {
     throw new CommandExit(1, `\u274C "${stub}" is no plan stub: a stub is letters, digits, ".", "_" and "-"`);
   }
   const name2 = planFileName(stub, tracker);
-  const file = join32(plans.path, name2);
+  const file = join34(plans.path, name2);
   if (!isFile(file))
-    throw new CommandExit(1, missingText(stub, tracker, join32(plans.label, name2)));
-  const model = parsePlan(readFileSync17(file, "utf8"));
+    throw new CommandExit(1, missingText(stub, tracker, join34(plans.label, name2)));
+  const model = parsePlan(readFileSync18(file, "utf8"));
   const { header } = model;
   return {
     stub,
@@ -14477,7 +15251,7 @@ function taskLine(task) {
   return `  ${checkbox(task.status)} ${task.text}`;
 }
 function renderShownPlan(shown, dirLabel) {
-  const relative7 = join32(dirLabel, planFileName(shown.stub, shown.tracker));
+  const relative7 = join34(dirLabel, planFileName(shown.stub, shown.tracker));
   const fileLabel = shown.tracker ? "Tracker" : "File";
   const lines2 = [`Plan: ${shown.stub}`, `${fileLabel}: ${relative7}`];
   if (shown.header.issue !== null)
@@ -14897,24 +15671,24 @@ function createPrListCommand(seams = DEFAULT_PR_SEAMS) {
 var list_default9 = createPrListCommand();
 
 // src/commands/pr/merge.ts
-import { existsSync as existsSync15, readFileSync as readFileSync19 } from "fs";
-import { join as join34 } from "path";
+import { existsSync as existsSync16, readFileSync as readFileSync20 } from "fs";
+import { join as join36 } from "path";
 
 // src/runtime/install.ts
 import {
   chmodSync,
   copyFileSync as copyFileSync4,
-  existsSync as existsSync14,
+  existsSync as existsSync15,
   mkdirSync as mkdirSync6,
   readdirSync as readdirSync4,
-  readFileSync as readFileSync18,
+  readFileSync as readFileSync19,
   realpathSync as realpathSync5,
   renameSync as renameSync2,
-  rmSync as rmSync4,
+  rmSync as rmSync5,
   statSync as statSync11,
   symlinkSync
 } from "fs";
-import { basename as basename6, delimiter as delimiter2, dirname as dirname6, join as join33, relative as relative7, resolve as resolve13 } from "path";
+import { basename as basename6, delimiter as delimiter2, dirname as dirname7, join as join35, relative as relative7, resolve as resolve14 } from "path";
 var LINK_NAME = "rafa";
 var FORCE_FLAG = "--force";
 var EXIT_DONE = 0;
@@ -14975,20 +15749,20 @@ function runtimeRefusalLines(runtimeDir, version2) {
   ];
 }
 function listTrackers(repoRoot, planDir) {
-  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));
+  const dir = resolve14(repoRoot, planDir);
+  return entryNames(dir).filter((entry) => TRACKER_NAME.test(entry)).sort((a, b) => a.localeCompare(b)).map((entry) => join35(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(join33(repoRoot, path), "utf8"));
+    const task = findNextTask(readFileSync19(join35(repoRoot, path), "utf8"));
     return task ? [{ path, task }] : [];
   });
 }
 function readManifestVersion2(repoRoot) {
-  const manifest = JSON.parse(readFileSync18(join33(repoRoot, "package.json"), "utf8"));
+  const manifest = JSON.parse(readFileSync19(join35(repoRoot, "package.json"), "utf8"));
   const record = typeof manifest === "object" && manifest !== null ? manifest : {};
   if (record["name"] !== name) {
-    throw new Error(`${join33(repoRoot, "package.json")} names ${JSON.stringify(record["name"])}, not ${name}: this is no rafa checkout`);
+    throw new Error(`${join35(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)) {
@@ -15001,8 +15775,8 @@ function copyTree(from, to) {
   let copied = 0;
   const entries = readdirSync4(from, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
   for (const entry of entries) {
-    const source = join33(from, entry.name);
-    const target = join33(to, entry.name);
+    const source = join35(from, entry.name);
+    const target = join35(to, entry.name);
     if (entry.isDirectory()) {
       copied += copyTree(source, target);
     } else if (entry.isFile()) {
@@ -15016,23 +15790,23 @@ function copyTree(from, to) {
 }
 function replaceTree(from, to) {
   const staging = temporaryName(to);
-  rmSync4(staging, { recursive: true, force: true });
+  rmSync5(staging, { recursive: true, force: true });
   try {
     const copied = copyTree(from, staging);
     swapIn2(staging, to);
     return copied;
   } catch (err) {
-    rmSync4(staging, { recursive: true, force: true });
+    rmSync5(staging, { recursive: true, force: true });
     throw err;
   }
 }
 function swapIn2(staging, to) {
-  if (!existsSync14(to)) {
+  if (!existsSync15(to)) {
     renameSync2(staging, to);
     return;
   }
   const outgoing = `${temporaryName(to)}.outgoing`;
-  rmSync4(outgoing, { recursive: true, force: true });
+  rmSync5(outgoing, { recursive: true, force: true });
   renameSync2(to, outgoing);
   try {
     renameSync2(staging, to);
@@ -15040,17 +15814,17 @@ function swapIn2(staging, to) {
     renameSync2(outgoing, to);
     throw err;
   }
-  rmSync4(outgoing, { recursive: true, force: true });
+  rmSync5(outgoing, { recursive: true, force: true });
 }
 function relink(linkPath, target) {
-  mkdirSync6(dirname6(linkPath), { recursive: true });
+  mkdirSync6(dirname7(linkPath), { recursive: true });
   const temporary = temporaryName(linkPath);
-  rmSync4(temporary, { force: true });
+  rmSync5(temporary, { force: true });
   try {
     symlinkSync(target, temporary);
     renameSync2(temporary, linkPath);
   } catch (err) {
-    rmSync4(temporary, { force: true });
+    rmSync5(temporary, { force: true });
     throw err;
   }
   const resolved = realpathSync5(linkPath);
@@ -15066,7 +15840,7 @@ function runBuild(repoRoot, lines2) {
     cwd: repoRoot,
     env: {
       ...process.env,
-      PATH: [dirname6(process.execPath), process.env["PATH"] ?? ""].join(delimiter2)
+      PATH: [dirname7(process.execPath), process.env["PATH"] ?? ""].join(delimiter2)
     },
     stdin: "ignore",
     stdout: stdio,
@@ -15097,20 +15871,20 @@ function installRuntime(seams, options = {}) {
 }
 function runInstall(seams, options) {
   const { repoRoot, home, log } = seams;
-  const runtimeRoot = join33(home, RUNTIME_SUBDIR);
-  const linkPath = join33(home, RAFA_BIN_DIR, LINK_NAME);
+  const runtimeRoot = join35(home, RUNTIME_SUBDIR);
+  const linkPath = join35(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", () => resolve13(repoRoot, loadConfig({ root: repoRoot, home }, {}, seams.warn).config.planDir));
+  const planDir = inStage("config", () => resolve14(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 = join33(repoRoot, "dist");
-  const runtimeDir = join33(runtimeRoot, version2);
-  const installed = existsSync14(runtimeDir);
+  const distDir = join35(repoRoot, "dist");
+  const runtimeDir = join35(runtimeRoot, version2);
+  const installed = existsSync15(runtimeDir);
   if (installed && options.force !== true) {
     return { kind: "refused", reason: "runtime-exists", version: version2, runtimeDir };
   }
@@ -15118,13 +15892,13 @@ function runInstall(seams, options) {
   const code = inStage("build", () => seams.build(repoRoot));
   if (code !== 0)
     throw new StageFailure("build", `the build exited ${code}`);
-  if (!existsSync14(join33(distDir, RUNTIME_ENTRY))) {
-    throw new StageFailure("build", `the build exited 0 and left no ${join33(distDir, RUNTIME_ENTRY)}`);
+  if (!existsSync15(join35(distDir, RUNTIME_ENTRY))) {
+    throw new StageFailure("build", `the build exited 0 and left no ${join35(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, join33(runtimeDir, RUNTIME_ENTRY)));
+  const resolved = inStage("link", () => relink(linkPath, join35(runtimeDir, RUNTIME_ENTRY)));
   log(`${linkPath} resolves to ${resolved}`);
   return { kind: "done", version: version2, runtimeDir, linkPath, resolved, copied };
 }
@@ -15153,12 +15927,12 @@ function replaceFile(source, target) {
     chmodSync(temporary, statSync11(source).mode & 4095);
     renameSync2(temporary, target);
   } catch (err) {
-    rmSync4(temporary, { force: true });
+    rmSync5(temporary, { force: true });
     throw err;
   }
 }
 function temporaryName(path) {
-  return join33(dirname6(path), `.${basename6(path)}.snapshot-${process.pid}`);
+  return join35(dirname7(path), `.${basename6(path)}.snapshot-${process.pid}`);
 }
 
 // src/commands/pr/merge-followups.ts
@@ -15555,13 +16329,13 @@ function localHoldsBranch(git, branch, warn3) {
 }
 function textOf(path) {
   try {
-    return readFileSync19(path, "utf8");
+    return readFileSync20(path, "utf8");
   } catch {
     return "";
   }
 }
 function followUpsFor(pr, git) {
-  const facts = readPackageFacts(textOf(join34(pr.project.root, "package.json")));
+  const facts = readPackageFacts(textOf(join36(pr.project.root, "package.json")));
   if (facts.version === null)
     return [];
   const tags = git(["tag", "--list", versionTag(facts.version)]);
@@ -15569,7 +16343,7 @@ function followUpsFor(pr, git) {
     version: facts.version,
     tagged: tags.ok && tags.stdout.trim() !== "",
     rafaCheckout: facts.rafaCheckout,
-    runtimeInstalled: existsSync15(join34(pr.project.home, RUNTIME_SUBDIR, facts.version))
+    runtimeInstalled: existsSync16(join36(pr.project.home, RUNTIME_SUBDIR, facts.version))
   });
 }
 function openGh(pr, seams) {
@@ -15699,7 +16473,7 @@ async function commentIfUnchecked(context, pr, number, unchecked) {
   context.output.info(`Commented on #${number} that it was merged with no checks: ${posted.url}`);
   return posted.url;
 }
-async function runMerge(context, seams) {
+async function runMerge2(context, seams) {
   const yes = readBooleanFlag(context.flags, "yes", USAGE31);
   const skipChecks = readBooleanFlag(context.flags, "skip-checks", USAGE31);
   const wanted = readMethodFlag(context.flags, USAGE31);
@@ -15834,7 +16608,7 @@ function createPrMergeCommand(seams = DEFAULT_MERGE_SEAMS) {
     ],
     outputs: ["text", "json"],
     run: async (context) => {
-      const merged2 = await runMerge(context, seams);
+      const merged2 = await runMerge2(context, seams);
       if (context.outputMode === "json")
         context.output.result(merged2);
       if (merged2.merged)
@@ -15843,7 +16617,7 @@ function createPrMergeCommand(seams = DEFAULT_MERGE_SEAMS) {
   };
   return Object.freeze(command);
 }
-var merge_default = createPrMergeCommand();
+var merge_default2 = createPrMergeCommand();
 
 // src/pr/triage/evidence.ts
 var FAILED_LOG_TAIL_LINES = 40;
@@ -16600,7 +17374,7 @@ function fileList(files) {
 function conflictReason(files) {
   return files.length === 0 ? "the head conflicts with the base and no conflicting file was read" : `the head conflicts with the base on ${fileList(files)}`;
 }
-function failureReason2(step, failing) {
+function failureReason(step, failing) {
   const count2 = checkCount(failing.length);
   return step === undefined ? `${count2} failing, and no failing step was named` : `${count2} failing, the failing step being "${step.name}"`;
 }
@@ -16632,7 +17406,7 @@ function decideClass(input, verdict, conflicting) {
       triageClass: classifyFailedStep(step?.name),
       files: [],
       step,
-      reason: failureReason2(step, failingRows(rows))
+      reason: failureReason(step, failingRows(rows))
     };
   }
   if (verdict === "none") {
@@ -16807,8 +17581,8 @@ function describeAge(updatedAt, now) {
     return `${plural4(hours, "hour", "hours")} ago`;
   return `${plural4(Math.floor(age / DAY_MS2), "day", "days")} ago`;
 }
-function triageCommand(number, resolve14 = false) {
-  return resolve14 ? `rafa pr triage ${number} --resolve` : `rafa pr triage ${number}`;
+function triageCommand(number, resolve15 = false) {
+  return resolve15 ? `rafa pr triage ${number} --resolve` : `rafa pr triage ${number}`;
 }
 function joinNumbers(pulls) {
   const names = pulls.map((pull) => `#${pull.number}`);
@@ -16819,14 +17593,14 @@ function joinNumbers(pulls) {
 function byNumber(pulls) {
   return Object.freeze([...pulls].sort((left, right) => left.number - right.number));
 }
-function skipped(pull, now, resolve14) {
+function skipped(pull, now, resolve15) {
   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, resolve14)
+    command: triageCommand(pull.number, resolve15)
   });
 }
 function skippedLine(one) {
@@ -16870,15 +17644,15 @@ function listReading(rest, count2) {
   return listing("list", Object.freeze([]), rest, headline);
 }
 function selectTriagePullRequests(input) {
-  const resolve14 = input.resolve === true;
+  const resolve15 = 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, resolve14));
-  if (resolve14 && count2 > 1)
+  const lines2 = candidates.map((pull) => skipped(pull, now, resolve15));
+  if (resolve15 && 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");
@@ -17213,10 +17987,10 @@ function withTaskBudget(plan2, usd) {
 }
 
 // src/pr/plans/load.ts
-import { existsSync as existsSync16, readFileSync as readFileSync20 } from "fs";
-import { dirname as dirname7, join as join35 } from "path";
+import { existsSync as existsSync17, readFileSync as readFileSync21 } from "fs";
+import { dirname as dirname8, join as join37 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
-var MODULE_DIR4 = dirname7(fileURLToPath4(import.meta.url));
+var MODULE_DIR4 = dirname8(fileURLToPath4(import.meta.url));
 var PINNED_PLANS_DIRNAME = "plans";
 var PINNED_PLAN_CLASSES = Object.freeze([
   ...SIMPLE_TRIAGE_CLASSES,
@@ -17231,8 +18005,8 @@ function hasPinnedPlan(triageClass) {
 function pinnedPlanCandidates(moduleDir, triageClass) {
   const name2 = pinnedPlanFileName(triageClass);
   return [
-    join35(moduleDir, PINNED_PLANS_DIRNAME, name2),
-    join35(moduleDir, name2)
+    join37(moduleDir, PINNED_PLANS_DIRNAME, name2),
+    join37(moduleDir, name2)
   ];
 }
 function readPinnedPlan(triageClass, lookup = {}) {
@@ -17240,11 +18014,11 @@ function readPinnedPlan(triageClass, lookup = {}) {
     throw new Error(`No pinned resolve plan ships for ${triageClass}; ` + `one ships for ${PINNED_PLAN_CLASSES.join(", ")}`);
   }
   const candidates = pinnedPlanCandidates(lookup.moduleDir ?? MODULE_DIR4, triageClass);
-  const found = candidates.find((candidate) => existsSync16(candidate));
+  const found = candidates.find((candidate) => existsSync17(candidate));
   if (found === undefined) {
     throw new Error(`The pinned resolve plan for ${triageClass} is missing: ` + `no file at ${candidates.join(" or ")}`);
   }
-  return readFileSync20(found, "utf8");
+  return readFileSync21(found, "utf8");
 }
 var SLOT_PATTERN2 = /\{[A-Z][A-Z0-9_]*\}/g;
 var CONFLICT_SENTENCE_SLOT = "CONFLICT_SENTENCE";
@@ -17384,21 +18158,21 @@ function readAttemptRepeat(input) {
 }
 
 // src/commands/pr/resolve-loop.ts
-import { mkdirSync as mkdirSync7, writeFileSync as writeFileSync5 } from "fs";
-import { join as join36 } from "path";
-var RESOLVE_SUBDIR = join36(".rafa", "resolve");
+import { mkdirSync as mkdirSync7, writeFileSync as writeFileSync6 } from "fs";
+import { join as join38 } from "path";
+var RESOLVE_SUBDIR = join38(".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 join36(home, RESOLVE_SUBDIR, `${RUN_PREFIX}${number}`, `${ATTEMPT_PREFIX}${attempt3}`);
+  return join38(home, RESOLVE_SUBDIR, `${RUN_PREFIX}${number}`, `${ATTEMPT_PREFIX}${attempt3}`);
 }
 function writeResolvePlan(write) {
   const dir = resolveRunDir(write.home, write.number, write.attempt);
   mkdirSync7(dir, { recursive: true });
-  const path = join36(dir, pinnedPlanFileName(write.triageClass));
-  writeFileSync5(path, write.plan, "utf8");
+  const path = join38(dir, pinnedPlanFileName(write.triageClass));
+  writeFileSync6(path, write.plan, "utf8");
   return path;
 }
 function resolveLoopArgv(planPath) {
@@ -17661,7 +18435,7 @@ async function resolvePullRequest(run) {
     throw new CommandExit(RESOLVE_REFUSE_EXIT, `\u274C ${refusal13}`);
   return runAttempts(run, detail, first);
 }
-function ended2(run, state, parts) {
+function ended(run, state, parts) {
   return {
     ran: parts.ran,
     resolved: parts.resolved,
@@ -17689,7 +18463,7 @@ async function runAttempts(run, detail, first) {
     if (start2.stopped) {
       await writeResolveComment(run, detail, state.assessment, state.spent, false, workflowCountOf2(state.reading));
       const removal2 = closeWorktree(run, resolveWorktreePath(run.home, run.number));
-      return ended2(run, state, {
+      return ended(run, state, {
         ran: state.lines.length > 0,
         resolved: false,
         stop: start2.stop,
@@ -17721,7 +18495,7 @@ async function runAttempts(run, detail, first) {
     state.evidence = end.evidence;
     if (end.green) {
       await writeResolveComment(run, detail, state.assessment, state.spent, true, workflowCountOf2(state.reading));
-      return ended2(run, state, {
+      return ended(run, state, {
         ran: true,
         resolved: true,
         stop: null,
@@ -17745,7 +18519,7 @@ async function runAttempts(run, detail, first) {
       continue;
     await writeResolveComment(run, detail, state.assessment, state.spent, false, workflowCountOf2(state.reading));
     const removal = closeWorktree(run, worktree);
-    return ended2(run, state, {
+    return ended(run, state, {
       ran: true,
       resolved: false,
       stop: repeat.stop,
@@ -17797,16 +18571,16 @@ async function redPullRequests(pr) {
   }
   return red;
 }
-async function selectTargets(pr, warn3, now, resolve14) {
+async function selectTargets(pr, warn3, now, resolve15) {
   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: resolve14 });
+    return selectTriagePullRequests({ current, candidates: [], now, resolve: resolve15 });
   return selectTriagePullRequests({
     current: null,
     candidates: await redPullRequests(pr),
     now,
-    resolve: resolve14
+    resolve: resolve15
   });
 }
 async function detailOf4(pr, number) {
@@ -17935,7 +18709,7 @@ async function runTriage(context, seams) {
   }
   const numbers = asked === null ? (selection?.assess ?? []).map((one) => one.number) : [asked];
   const readings = [];
-  let resolve14 = null;
+  let resolve15 = null;
   for (const number of numbers) {
     const assess = () => assessOne({
       pr,
@@ -17954,7 +18728,7 @@ async function runTriage(context, seams) {
       readings.push(reading);
       continue;
     }
-    resolve14 = await resolvePullRequest({
+    resolve15 = await resolvePullRequest({
       trust: {
         permissions,
         trustedAuthors: pr.trustedAuthors,
@@ -17975,16 +18749,16 @@ async function runTriage(context, seams) {
       ...seams.clock === undefined ? {} : { clock: seams.clock },
       ...seams.sleep === undefined ? {} : { sleep: seams.sleep }
     });
-    readings.push(resolve14.reading);
+    readings.push(resolve15.reading);
   }
   const text = [
     ...selection === null ? [] : [selection.message],
     ...readings.length === 0 ? [] : [renderTriages(readings)],
-    ...resolve14 === null ? [] : resolve14.lines
+    ...resolve15 === null ? [] : resolve15.lines
   ].join(`
 
 `);
-  return { selection, readings, resolve: resolve14, text, exitCode: resolve14?.exitCode ?? 0 };
+  return { selection, readings, resolve: resolve15, text, exitCode: resolve15?.exitCode ?? 0 };
 }
 function createPrTriageCommand(seams = DEFAULT_TRIAGE_SEAMS) {
   const command = {
@@ -18273,8 +19047,8 @@ function createPrWaitCommand(seams = DEFAULT_WAIT_SEAMS) {
 var wait_default = createPrWaitCommand();
 
 // src/commands/release/tag.ts
-import { readFileSync as readFileSync21 } from "fs";
-import { join as join37 } from "path";
+import { readFileSync as readFileSync22 } from "fs";
+import { join as join39 } from "path";
 
 // src/commands/release/release-commit.ts
 function unread2(reason, message) {
@@ -18332,13 +19106,13 @@ function readBranch2(git) {
 }
 function textOf2(path) {
   try {
-    return readFileSync21(path, "utf8");
+    return readFileSync22(path, "utf8");
   } catch {
     return null;
   }
 }
 function readVersion(root, configured) {
-  const resolved = join37(root, configured);
+  const resolved = join39(root, configured);
   const text = textOf2(resolved);
   if (text === null) {
     return {
@@ -18352,7 +19126,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 = join37(root, configured);
+  const resolved = join39(root, configured);
   const text = textOf2(resolved);
   if (text === null) {
     return { path: configured, version: null, problem: `the changelog could not be read at ${resolved}` };
@@ -18693,16 +19467,16 @@ var self_update_default = createSelfUpdateCommand();
 
 // src/commands/skill/backfill.ts
 import { statSync as statSync13 } from "fs";
-import { join as join42, resolve as resolve16 } from "path";
+import { join as join44, resolve as resolve17 } from "path";
 
 // src/backfill/backup.ts
-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";
+import { copyFileSync as copyFileSync5, existsSync as existsSync18, mkdirSync as mkdirSync8 } from "fs";
+import { dirname as dirname9, isAbsolute as isAbsolute8, join as join41, relative as relative8, resolve as resolve15, sep as sep5 } from "path";
 
 // src/backfill/proposal-file.ts
-import { readdirSync as readdirSync5, readFileSync as readFileSync22 } from "fs";
-import { join as join38 } from "path";
-var BACKFILL_PATH = join38(".rafa", "backfill");
+import { readdirSync as readdirSync5, readFileSync as readFileSync23 } from "fs";
+import { join as join40 } from "path";
+var BACKFILL_PATH = join40(".rafa", "backfill");
 var PROPOSAL_FILE_PREFIX = "proposals-";
 var PROPOSAL_FILE_EXTENSION = ".yaml";
 var SHA256_PATTERN = /^[0-9a-f]{64}$/;
@@ -18728,7 +19502,7 @@ var PROPOSAL_FILE_HEADER = [
 ].join(`
 `);
 function proposalPath(dir, batch) {
-  return join38(dir, `${PROPOSAL_FILE_PREFIX}${String(batch).padStart(2, "0")}${PROPOSAL_FILE_EXTENSION}`);
+  return join40(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);
@@ -18864,9 +19638,9 @@ function readProposalFiles(dir) {
     return [];
   }
   return names.filter((name2) => isProposalFileName(name2)).sort((left, right) => left.localeCompare(right)).map((name2) => {
-    const path = join38(dir, name2);
+    const path = join40(dir, name2);
     try {
-      return { path, result: parseProposalFile(readFileSync22(path, "utf8")) };
+      return { path, result: parseProposalFile(readFileSync23(path, "utf8")) };
     } catch (error) {
       return { path, result: unreadable2(`the file cannot be read (${error instanceof Error ? error.message : String(error)})`) };
     }
@@ -18874,19 +19648,19 @@ function readProposalFiles(dir) {
 }
 
 // src/backfill/backup.ts
-var BACKUP_PATH = join39(BACKFILL_PATH, "backup");
+var BACKUP_PATH = join41(BACKFILL_PATH, "backup");
 var BACKUP_KINDS = ["copied", "kept", "tracked", "outside", "missing"];
 function backupDirectory(base) {
-  return join39(base, BACKUP_PATH);
+  return join41(base, BACKUP_PATH);
 }
 function isUnder(root, path) {
-  const step = relative8(resolve14(root), resolve14(path));
+  const step = relative8(resolve15(root), resolve15(path));
   return step === "" || !step.startsWith(`..${sep5}`) && step !== ".." && !isAbsolute8(step);
 }
 function backupPathFor(path, root, backupDir) {
   if (!isUnder(root, path))
     return null;
-  return join39(backupDir, relative8(resolve14(root), resolve14(path)));
+  return join41(backupDir, relative8(resolve15(root), resolve15(path)));
 }
 function backupFile(path, options) {
   if (options.repoRoot !== null && isUnder(options.repoRoot, path)) {
@@ -18895,11 +19669,11 @@ function backupFile(path, options) {
   const backup = backupPathFor(path, options.root, options.backupDir);
   if (backup === null)
     return { path, kind: "outside", backup: null };
-  if (!existsSync17(path))
+  if (!existsSync18(path))
     return { path, kind: "missing", backup: null };
-  if (existsSync17(backup))
+  if (existsSync18(backup))
     return { path, kind: "kept", backup };
-  mkdirSync8(dirname8(backup), { recursive: true });
+  mkdirSync8(dirname9(backup), { recursive: true });
   copyFileSync5(path, backup);
   return { path, kind: "copied", backup };
 }
@@ -18922,7 +19696,7 @@ function countBackups(results) {
 }
 
 // src/backfill/derive.ts
-import { readFileSync as readFileSync23, writeFileSync as writeFileSync6 } from "fs";
+import { readFileSync as readFileSync24, writeFileSync as writeFileSync7 } from "fs";
 import { basename as basename7 } from "path";
 var DERIVED_FIELDS = ["stack", "paths", "when_to_use"];
 function renderWhenToUse(trigger, prevents) {
@@ -19048,7 +19822,7 @@ function planFile(entry, options) {
   }
   let original;
   try {
-    original = readFileSync23(entry.path, "utf8");
+    original = readFileSync24(entry.path, "utf8");
   } catch (error) {
     return inert(entry, "skipped", `the file cannot be read (${error instanceof Error ? error.message : String(error)})`);
   }
@@ -19092,7 +19866,7 @@ function planDerivation(root, options) {
 function applyFile(action, options) {
   if (action.text === null || action.original === null)
     return action;
-  const current = readFileSync23(action.path, "utf8");
+  const current = readFileSync24(action.path, "utf8");
   if (current !== action.original) {
     return {
       ...action,
@@ -19101,7 +19875,7 @@ function applyFile(action, options) {
       text: null
     };
   }
-  writeFileSync6(action.path, action.text, "utf8");
+  writeFileSync7(action.path, action.text, "utf8");
   const after = failureLines(checkFile(action.path, "skill", {
     projectRoot: options.projectRoot,
     pathDirs: options.pathDirs
@@ -19109,7 +19883,7 @@ function applyFile(action, options) {
   const added = addedFailures(action.before, after);
   if (added.length === 0)
     return action;
-  writeFileSync6(action.path, action.original, "utf8");
+  writeFileSync7(action.path, action.original, "utf8");
   return {
     ...action,
     kind: "refused",
@@ -19123,7 +19897,7 @@ function applyDerivation(plan2, options) {
 }
 
 // src/backfill/proposal-batch.ts
-import { readFileSync as readFileSync24 } from "fs";
+import { readFileSync as readFileSync25 } from "fs";
 import { relative as relative9 } from "path";
 
 // src/demote/report.ts
@@ -19159,7 +19933,7 @@ function countVerdicts(rows) {
 function escapeCell(value) {
   return value.replace(/\s+/g, " ").trim().replace(/\\/g, "\\\\").replace(/\|/g, "\\|");
 }
-function tableLine(cells) {
+function tableLine2(cells) {
   return `| ${cells.join(" | ")} |`;
 }
 function splitTableRow(line) {
@@ -19214,7 +19988,7 @@ function summaryLine3(rows) {
   return `${files}: ${parts.join(", ")}.`;
 }
 function writeDemotionReport(report2) {
-  const rows = report2.rows.map((row2) => tableLine([
+  const rows = report2.rows.map((row2) => tableLine2([
     escapeCell(row2.path),
     escapeCell(row2.hash),
     escapeCell(row2.verdict),
@@ -19229,8 +20003,8 @@ function writeDemotionReport(report2) {
     "",
     summaryLine3(report2.rows),
     "",
-    tableLine(DEMOTION_REPORT_COLUMNS),
-    tableLine(DEMOTION_REPORT_COLUMNS.map(() => "---")),
+    tableLine2(DEMOTION_REPORT_COLUMNS),
+    tableLine2(DEMOTION_REPORT_COLUMNS.map(() => "---")),
     ...rows,
     ""
   ].join(`
@@ -19422,7 +20196,7 @@ function readCandidate(root, entry) {
     return null;
   let text;
   try {
-    text = readFileSync24(entry.path, "utf8");
+    text = readFileSync25(entry.path, "utf8");
   } catch {
     return null;
   }
@@ -19528,8 +20302,8 @@ function parseSessionAnswer(stdout) {
 }
 
 // src/backfill/propose.ts
-import { mkdirSync as mkdirSync9, readFileSync as readFileSync25, writeFileSync as writeFileSync7 } from "fs";
-import { join as join40, resolve as resolve15 } from "path";
+import { mkdirSync as mkdirSync9, readFileSync as readFileSync26, writeFileSync as writeFileSync8 } from "fs";
+import { join as join42, resolve as resolve16 } from "path";
 var PROPOSAL_ACTION_KINDS = [
   "applied",
   "unchanged",
@@ -19613,7 +20387,7 @@ async function runProposalPass(options) {
     const number = index + 1;
     const file = await runProposalBatch(number, batch, options);
     const path = proposalPath(options.backfillDir, number);
-    writeFileSync7(path, renderProposalFile(file), "utf8");
+    writeFileSync8(path, renderProposalFile(file), "utf8");
     written.push({ path, file });
   }
   return { written, candidates: candidates.length };
@@ -19655,7 +20429,7 @@ function writeRow(path, row2, original, options) {
     return inert2(path, row2, "unchanged", "every field the row proposes is already what the file carries");
   }
   const before = checkLines(path, options);
-  writeFileSync7(path, writeFrontmatter(document, mergeFrontmatter(document.data, changes)), "utf8");
+  writeFileSync8(path, writeFrontmatter(document, mergeFrontmatter(document.data, changes)), "utf8");
   const added = addedFailures(before, checkLines(path, options));
   if (added.length === 0) {
     return {
@@ -19667,7 +20441,7 @@ function writeRow(path, row2, original, options) {
       added: []
     };
   }
-  writeFileSync7(path, original, "utf8");
+  writeFileSync8(path, original, "utf8");
   return {
     path,
     relative: row2.path,
@@ -19678,7 +20452,7 @@ function writeRow(path, row2, original, options) {
   };
 }
 function applyRow(root, row2, options) {
-  const path = join40(root, ...row2.path.split("/"));
+  const path = join42(root, ...row2.path.split("/"));
   if (row2.status === UNANSWERED_ROW) {
     return inert2(path, row2, "unanswered", row2.note ?? "the row carries no answer");
   }
@@ -19687,7 +20461,7 @@ function applyRow(root, row2, options) {
   }
   let original;
   try {
-    original = readFileSync25(path, "utf8");
+    original = readFileSync26(path, "utf8");
   } catch {
     return inert2(path, row2, "refused", "the file the row names is gone");
   }
@@ -19701,7 +20475,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 resolve15(file.skills) === resolve15(root) ? null : `the proposal file names the skills directory ${file.skills}, not ${root}`;
+  return resolve16(file.skills) === resolve16(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]));
@@ -19715,7 +20489,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(join40(root, ...row2.path.split("/")), row2, "refused", refusal13);
+      const action = refusal13 === null ? applyRow(root, row2, options) : inert2(join42(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;
@@ -19726,13 +20500,13 @@ function applyProposals(files, root, options) {
 }
 
 // src/demote/select.ts
-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";
+import { readdirSync as readdirSync6, readFileSync as readFileSync27, realpathSync as realpathSync6, statSync as statSync12 } from "fs";
+import { basename as basename8, dirname as dirname10, join as join43 } from "path";
 var SKILLS_DIRECTORY = "skills";
 var CLAUDE_DIRECTORY = ".claude";
 var AUTO_EXTRACTED_ORIGIN = "auto-extracted";
-var DEMOTED_PATH = join41(".rafa", "demoted");
-var INSTINCTS_PATH = join41(".rafa", "instincts");
+var DEMOTED_PATH = join43(".rafa", "demoted");
+var INSTINCTS_PATH = join43(".rafa", "instincts");
 var REPORT_FILE = "report.md";
 function realOrSelf(path) {
   try {
@@ -19751,18 +20525,18 @@ function samePath(left, right) {
 function resolveDemotionScope(dir, home) {
   if (basename8(dir) !== SKILLS_DIRECTORY)
     return null;
-  const claude = dirname9(dir);
+  const claude = dirname10(dir);
   if (basename8(claude) !== CLAUDE_DIRECTORY)
     return null;
-  const base = dirname9(claude);
-  const demotedDir = join41(base, DEMOTED_PATH);
+  const base = dirname10(claude);
+  const demotedDir = join43(base, DEMOTED_PATH);
   return {
     scope: samePath(base, home) ? "user" : "project",
     dir,
     base,
     demotedDir,
-    instinctsDir: join41(base, INSTINCTS_PATH),
-    reportPath: join41(demotedDir, REPORT_FILE)
+    instinctsDir: join43(base, INSTINCTS_PATH),
+    reportPath: join43(demotedDir, REPORT_FILE)
   };
 }
 function entryKind(path) {
@@ -19788,7 +20562,7 @@ function readSelected(absolute, path, entries) {
   let text;
   let mtime;
   try {
-    text = readFileSync26(absolute, "utf8");
+    text = readFileSync27(absolute, "utf8");
     mtime = statSync12(absolute).mtime.toISOString();
   } catch {
     return null;
@@ -19804,14 +20578,14 @@ function selectsLearned(text, scope) {
   return origin === AUTO_EXTRACTED_ORIGIN;
 }
 function selectLearned(scope) {
-  const dir = join41(scope.dir, LEARNED_DIRECTORY);
+  const dir = join43(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 = join41(dir, name2);
+    const absolute = join43(dir, name2);
     if (entryKind(absolute) !== "file")
       continue;
     const file = readSelected(absolute, `${LEARNED_DIRECTORY}/${name2}`, undefined);
@@ -19825,10 +20599,10 @@ function selectSkillFiles(scope) {
   for (const name2 of visibleNames(scope.dir)) {
     if (name2 === LEARNED_DIRECTORY)
       continue;
-    const skillDir = join41(scope.dir, name2);
+    const skillDir = join43(scope.dir, name2);
     if (entryKind(skillDir) !== "directory")
       continue;
-    const absolute = join41(skillDir, SKILL_FILE);
+    const absolute = join43(skillDir, SKILL_FILE);
     if (entryKind(absolute) !== "file")
       continue;
     const file = readSelected(absolute, `${name2}/${SKILL_FILE}`, visibleNames(skillDir));
@@ -19876,7 +20650,7 @@ Usage: ${BACKFILL_USAGE}`);
     throw new CommandExit(1, `\u274C Expected one directory, and read "${extra}" as a second
 Usage: ${BACKFILL_USAGE}`);
   }
-  return resolve16(cwd(), dir);
+  return resolve17(cwd(), dir);
 }
 function readConsumerRoot(value, cwd) {
   if (value === undefined || value === false)
@@ -19885,7 +20659,7 @@ function readConsumerRoot(value, cwd) {
     throw new CommandExit(1, `\u274C --project needs a path, and the line gave it none
 Usage: ${BACKFILL_USAGE}`);
   }
-  return resolve16(cwd(), value);
+  return resolve17(cwd(), value);
 }
 function isDirectory3(path) {
   try {
@@ -20013,7 +20787,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) => join42(root, ...row2.path.split("/"))));
+  return files.flatMap((file) => file.status !== REVIEWED_FILE ? [] : file.rows.filter((row2) => row2.status === ANSWERED_ROW).map((row2) => join44(root, ...row2.path.split("/"))));
 }
 function runApply(context, scope, backfillDir, projectRoot3) {
   const options = checkOptions(context, projectRoot3);
@@ -20059,7 +20833,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 = join42(scope.base, BACKFILL_PATH);
+  const backfillDir = join44(scope.base, BACKFILL_PATH);
   if (mode === "propose") {
     await runPropose(context, scope, backfillDir, seams);
     return;
@@ -20173,13 +20947,13 @@ function createSkillCheckCommand(seams = DEFAULT_CHECK_SEAMS) {
 var check_default3 = createSkillCheckCommand();
 
 // src/commands/skill/demote.ts
-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";
+import { existsSync as existsSync20, mkdirSync as mkdirSync11, readFileSync as readFileSync29, statSync as statSync15, writeFileSync as writeFileSync10 } from "fs";
+import { dirname as dirname12, resolve as resolve18 } from "path";
 
 // src/demote/apply.ts
-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 join43 } from "path";
+import { copyFileSync as copyFileSync6, existsSync as existsSync19, mkdirSync as mkdirSync10, mkdtempSync as mkdtempSync3, readdirSync as readdirSync7, readFileSync as readFileSync28, renameSync as renameSync3, rmSync as rmSync6, statSync as statSync14, unlinkSync, writeFileSync as writeFileSync9 } from "fs";
+import { tmpdir as tmpdir3 } from "os";
+import { dirname as dirname11, join as join45 } from "path";
 var DEMOTION_ACTION_KINDS = [
   "demoted",
   "kept",
@@ -20200,13 +20974,13 @@ function learnedSkillName(path) {
   return base.slice(0, -MARKDOWN_EXTENSION.length);
 }
 function sourcePath(scope, path) {
-  return join43(scope.dir, ...path.split("/"));
+  return join45(scope.dir, ...path.split("/"));
 }
 function demotedPath(scope, path) {
-  return join43(scope.demotedDir, ...path.split("/"));
+  return join45(scope.demotedDir, ...path.split("/"));
 }
 function promotedPath(scope, path) {
-  return join43(scope.dir, learnedSkillName(path), SKILL_FILE);
+  return join45(scope.dir, learnedSkillName(path), SKILL_FILE);
 }
 function takenInstinctIds(dir) {
   let names;
@@ -20219,7 +20993,7 @@ function takenInstinctIds(dir) {
 }
 function readText4(path) {
   try {
-    return statSync14(path).isFile() ? readFileSync27(path, "utf8") : null;
+    return statSync14(path).isFile() ? readFileSync28(path, "utf8") : null;
   } catch {
     return null;
   }
@@ -20247,7 +21021,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 (existsSync18(to) || existsSync18(dirname10(to))) {
+  if (existsSync19(to) || existsSync19(dirname11(to))) {
     return inert3(row2.path, "procedure", "refused", `kept as a skill, but ${to} is already there`);
   }
   return {
@@ -20261,8 +21035,8 @@ function planKept(scope, row2, file) {
   };
 }
 function checkCandidate(dir, id2, text, pathDirs) {
-  const path = join43(dir, `${id2}${MARKDOWN_EXTENSION}`);
-  writeFileSync8(path, text, "utf8");
+  const path = join45(dir, `${id2}${MARKDOWN_EXTENSION}`);
+  writeFileSync9(path, text, "utf8");
   const report3 = checkFile(path, "instinct", { projectRoot: null, pathDirs });
   return failureLines2(report3.issues);
 }
@@ -20282,11 +21056,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 = join43(scope.instinctsDir, `${id2}${MARKDOWN_EXTENSION}`);
+  const destination = join45(scope.instinctsDir, `${id2}${MARKDOWN_EXTENSION}`);
   const kept = demotedPath(scope, row2.path);
-  if (existsSync18(destination))
+  if (existsSync19(destination))
     return inert3(row2.path, "observation", "refused", `${destination} is already there`);
-  if (existsSync18(kept))
+  if (existsSync19(kept))
     return inert3(row2.path, "observation", "refused", `${kept} is already there`);
   context.taken.push(id2);
   return {
@@ -20329,17 +21103,17 @@ function countActions(actions) {
   return counts;
 }
 function planDemotion(report3, scope, seams = DEFAULT_APPLY_SEAMS) {
-  const temp = mkdtempSync2(join43(tmpdir2(), "rafa-demote-"));
+  const temp = mkdtempSync3(join45(tmpdir3(), "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 {
-    rmSync5(temp, { recursive: true, force: true });
+    rmSync6(temp, { recursive: true, force: true });
   }
 }
 function moveFile(move3) {
-  mkdirSync10(dirname10(move3.to), { recursive: true });
+  mkdirSync10(dirname11(move3.to), { recursive: true });
   try {
     renameSync3(move3.from, move3.to);
   } catch {
@@ -20350,8 +21124,8 @@ function moveFile(move3) {
 function applyDemotion(plan2) {
   for (const action of plan2.actions) {
     if (action.write !== null) {
-      mkdirSync10(dirname10(action.write.path), { recursive: true });
-      writeFileSync8(action.write.path, action.write.text, "utf8");
+      mkdirSync10(dirname11(action.write.path), { recursive: true });
+      writeFileSync9(action.write.path, action.write.text, "utf8");
     }
     if (action.move !== null)
       moveFile(action.move);
@@ -20416,7 +21190,7 @@ Usage: ${DEMOTE_USAGE}`);
     throw new CommandExit(1, `\u274C Expected one directory, and read "${extra}" as a second
 Usage: ${DEMOTE_USAGE}`);
   }
-  return resolve17(cwd(), dir);
+  return resolve18(cwd(), dir);
 }
 function isDirectory4(path) {
   try {
@@ -20448,9 +21222,9 @@ function verdictLine2(report3) {
   return `${String(report3.rows.length)} file(s): ${parts.join(", ")}`;
 }
 function previousReport(path, context) {
-  if (!existsSync19(path))
+  if (!existsSync20(path))
     return null;
-  const parsed = parseDemotionReport(readFileSync28(path, "utf8"));
+  const parsed = parseDemotionReport(readFileSync29(path, "utf8"));
   if (parsed.report !== null)
     return parsed.report;
   context.output.warn(`the report already at ${path} does not parse, so no override in it is carried forward:` + ` ${parsed.issues.map((issue2) => `line ${String(issue2.line)} ${issue2.code}`).join(", ")}`);
@@ -20459,8 +21233,8 @@ function previousReport(path, context) {
 function runWrite(context, scope) {
   const files = selectSources(scope);
   const report3 = buildDemotionReport(files, previousReport(scope.reportPath, context));
-  mkdirSync11(dirname11(scope.reportPath), { recursive: true });
-  writeFileSync9(scope.reportPath, writeDemotionReport(report3), "utf8");
+  mkdirSync11(dirname12(scope.reportPath), { recursive: true });
+  writeFileSync10(scope.reportPath, writeDemotionReport(report3), "utf8");
   const result = {
     applied: false,
     scope: scope.scope,
@@ -20483,10 +21257,10 @@ function runWrite(context, scope) {
     context.output.info(line);
 }
 function reviewedReport(scope) {
-  if (!existsSync19(scope.reportPath)) {
+  if (!existsSync20(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"));
+  const parsed = parseDemotionReport(readFileSync29(scope.reportPath, "utf8"));
   if (parsed.report === null) {
     const lines2 = parsed.issues.map((issue2) => `   line ${String(issue2.line)} ${issue2.code}: ${issue2.message}`);
     throw new CommandExit(1, [`\u274C ${scope.reportPath} does not parse:`, ...lines2].join(`
@@ -20592,7 +21366,7 @@ var demote_default = createSkillDemoteCommand();
 
 // src/commands/skill/show.ts
 var DEFAULT_SKILL_SHOW_SEAMS = DEFAULT_SKILL_LIST_SEAMS;
-var COMMAND_NAME9 = "rafa skill show";
+var COMMAND_NAME11 = "rafa skill show";
 var USAGE37 = "rafa skill show <name> [--full]";
 function unknownSkillMessage(name2, inventory) {
   const agent = findShown(inventory.records, "agent", name2);
@@ -20620,7 +21394,7 @@ async function runShow3(context, seams) {
   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_NAME9);
+  const { inventory, settingSources } = await projectInventory(project, context, seams, COMMAND_NAME11);
   const warnings = warningLines(inventory);
   for (const warning of warnings)
     context.output.warn(warning);
@@ -20704,6 +21478,10 @@ function awayLine(current, home) {
     return null;
   return `${AWAY_PREFIX}: working ${id2(placeNumber(current))} for ${id2(placeNumber(home))}`;
 }
+var WAITING_ON = "owner review";
+function waitingLine(issue2) {
+  return `waiting on ${id2(issue2)} (${WAITING_ON})`;
+}
 
 // src/status/render.ts
 var STATUS_SECTION_TITLES = Object.freeze({
@@ -20770,6 +21548,7 @@ function boardBody(reading) {
   return [
     info2(`${INDENT9}${placeLine2(place2.view)}`),
     ...away === null ? [] : [info2(`${INDENT9}${away}`)],
+    ...place2.waiting === undefined ? [] : [info2(`${INDENT9}${waitingLine(place2.waiting.issue)}`)],
     ...place2.notices.map((notice) => ({ level: "warn", text: `${INDENT9}${notice}` }))
   ];
 }
@@ -20813,7 +21592,7 @@ function statusData(sections) {
 }
 
 // src/status/sections.ts
-import { existsSync as existsSync20 } from "fs";
+import { existsSync as existsSync21 } from "fs";
 var STATUS_NETWORK_TIMEOUT_MS = 5000;
 function isIdleWorktree(row2) {
   return !row2.blockers.some((blocker) => blocker.kind === "recent");
@@ -20860,9 +21639,9 @@ function boundedRunner(open, root, deadline) {
 }
 async function networkSection(what, deadline, work) {
   let timer;
-  const expired = new Promise((resolve18) => {
+  const expired = new Promise((resolve19) => {
     timer = setTimeout(() => {
-      resolve18(unread3(`the ${what} was not read within the ${String(deadline.ms)}ms network deadline`));
+      resolve19(unread3(`the ${what} was not read within the ${String(deadline.ms)}ms network deadline`));
     }, Math.max(0, deadline.left()));
   });
   try {
@@ -20952,13 +21731,52 @@ function nextOfPlace(current, epic, walk) {
   return epic?.members.some((member) => member.number === line.issue) === true ? line.issue : null;
 }
 function hasBoards(root, listing2) {
-  if (existsSync20(positionFilePath(root)))
+  if (existsSync21(positionFilePath(root)))
     return true;
   return listing2.some((issue2) => issue2.state === "OPEN" && issue2.labels.includes(ROADMAP_LABEL));
 }
-async function readPlace(root, walk, listing2) {
+var NOT_WAITING = { waiting: null, notes: [] };
+function ref6(number) {
+  return `#${String(number)}`;
+}
+async function readGate(sources, pullRequest) {
+  try {
+    return await sources.ownerGate()(pullRequest);
+  } catch (error) {
+    return { state: "unknown", reason: `could not read the owner gate of ${ref6(pullRequest)}: ${messageOf(error)}`, owners: [] };
+  }
+}
+async function openPullGate(sources, pullRequest) {
+  let detail;
+  try {
+    detail = await sources.pulls.get(pullRequest);
+  } catch (error) {
+    return { state: "unknown", reason: `could not read pull request ${ref6(pullRequest)}: ${messageOf(error)}`, owners: [] };
+  }
+  return detail?.state === "open" ? readGate(sources, pullRequest) : null;
+}
+async function readWaiting(sources) {
+  const hop2 = readHopRecord(sources.root);
+  if (!hop2.set) {
+    return hop2.reason === "absent" ? NOT_WAITING : { waiting: null, notes: [`${hop2.detail}, so no waiting pull request is read`] };
+  }
+  const { record } = hop2;
+  const { pullRequest } = record;
+  if (record.state !== "waiting" || pullRequest === null)
+    return NOT_WAITING;
+  const placed = readPositionFile(sources.root);
+  if (!placed.set || staleAgainst(record, placed.position))
+    return NOT_WAITING;
+  const gate = await openPullGate(sources, pullRequest);
+  if (gate === null || gate.state === "approved" || gate.state === "not-gated")
+    return NOT_WAITING;
+  const waiting = { issue: record.target ?? pullRequest, pullRequest, gate: gate.state, reason: gate.reason };
+  return { waiting, notes: [] };
+}
+async function readPlace(sources, walk, listing2) {
+  const { root } = sources;
   if (!hasBoards(root, listing2))
-    return null;
+    return { place: null, notes: [] };
   const resolved = await resolvePlace({ root, listing: listing2, defaultBoard: () => Promise.resolve(walk.roadmap) });
   const { current, home } = resolved;
   const epic = current.epic === null ? undefined : readEpics({ issues: listing2, claims: new Set, today: new Date }).epics.find((one) => one.number === current.epic);
@@ -20968,21 +21786,23 @@ async function readPlace(root, walk, listing2) {
     next: nextOfPlace(current, epic, walk)
   };
   const notices = resolved.notices.filter((notice) => notice.kind === "lost" || notice.reason !== "absent").map((notice) => notice.message);
-  return { current, home, view, notices };
+  const place2 = { current, home, view, notices };
+  const { waiting, notes } = await readWaiting(sources);
+  return waiting === null ? { place: place2, notes } : { place: { ...place2, waiting }, notes };
 }
-async function placeOrNote(root, walk, listing2) {
+async function placeOrNote(sources, walk, listing2) {
   try {
-    return { place: await readPlace(root, walk, await listing2()), notes: [] };
+    return await readPlace(sources, walk, await listing2());
   } catch (error) {
     return { place: null, notes: [`the current place could not be read: ${messageOf(error)}`] };
   }
 }
-async function readBoard(root, board, listing2, blocked) {
+async function readBoard(sources, board, listing2, blocked) {
   const [walk, report3] = await Promise.all([board.next(), blocked]);
   const { line } = walk;
   const next = line === null ? null : { line, ready: await board.isReady(line.issue), blocked: await board.blocking(line.issue) };
   const listed2 = report3.problem === null ? [] : [`the issues labelled ${SPEC_BLOCKED_LABEL} could not be read: ${report3.problem}`];
-  const { place: place2, notes } = await placeOrNote(root, walk, listing2);
+  const { place: place2, notes } = await placeOrNote(sources, walk, listing2);
   const reading = {
     roadmap: walk.roadmap,
     next,
@@ -21013,6 +21833,12 @@ async function readStatusSections(input, seams = {}) {
   const pulls = (seams.pullRequests ?? ((runner) => createGhPullRequests({ gh: runner })))(gh);
   const listing2 = once2((seams.listing ?? ((runner) => createGhBoardListing({ gh: runner })))(gh));
   const board = (seams.board ?? ghNextBoard)({ gh, git, configured: config.roadmapIssue, listing: listing2 });
+  const openGate = seams.ownerGate ?? nextOwnerGate;
+  const place2 = {
+    root,
+    pulls,
+    ownerGate: () => openGate({ gh, root, pulls, configured: config.roadmapIssue, listing: listing2 })
+  };
   const sources = {
     base: config.prBase ?? DEFAULT_BASE_BRANCH,
     plans: plansDirAt(root, config.planDir),
@@ -21030,7 +21856,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(unread3(notGhProblem("board", provider)));
+  const boardSection = isGh ? networkSection("board", deadline, () => readBoard(place2, board, listing2, blockedIssues(gh))) : Promise.resolve(unread3(notGhProblem("board", provider)));
   const housekeeping = readHousekeeping(input, cleanup, now);
   return {
     branch,
@@ -21042,7 +21868,7 @@ async function readStatusSections(input, seams = {}) {
 }
 
 // src/commands/status.ts
-var COMMAND_NAME10 = "rafa status";
+var COMMAND_NAME12 = "rafa status";
 var STATUS_USAGE = "rafa status";
 var STATUS_ARGUMENT_EXIT = 2;
 var DEFAULT_STATUS_SEAMS = Object.freeze({});
@@ -21054,13 +21880,13 @@ function projectOf14(context) {
 function expectNoWord(args) {
   if (args.length === 0)
     return;
-  throw new CommandExit(STATUS_ARGUMENT_EXIT, `\u274C ${COMMAND_NAME10}: expected no argument, got ${String(args.length)}: ${args.join(" ")}
+  throw new CommandExit(STATUS_ARGUMENT_EXIT, `\u274C ${COMMAND_NAME12}: 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_NAME10, (message) => {
+  const config = resolveProjectConfig(project, COMMAND_NAME12, (message) => {
     context.output.warn(message);
   });
   const read3 = seams.read ?? ((input) => readStatusSections(input));
@@ -21126,7 +21952,7 @@ 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; read and repair the store: its schema, a copy for testing, migrations, and fixes" },
+  { name: "effort", summary: "collect session and commit rows; report per plan; read and repair the store: its schema, a copy for testing, migrations, and fixes; merge another device's store; move an NDJSON store to SQLite" },
   { 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" },
@@ -21152,7 +21978,7 @@ var CORE_COMMANDS = Object.freeze([
   show_default4,
   create_default,
   comment_default,
-  move_default2,
+  move_default3,
   ready_default,
   unblock_default,
   check_default2,
@@ -21161,7 +21987,7 @@ var CORE_COMMANDS = Object.freeze([
   view_default,
   list_default9,
   wait_default,
-  merge_default,
+  merge_default2,
   triage_default,
   collect_default,
   report_default,
@@ -21169,6 +21995,8 @@ var CORE_COMMANDS = Object.freeze([
   copy_default,
   schema_default,
   migrate_default,
+  merge_default,
+  move_default,
   list_default8,
   exec_default,
   vendor_default,
@@ -21193,7 +22021,7 @@ var CORE_COMMANDS = Object.freeze([
   new_default,
   defer_default,
   promote_default,
-  move_default,
+  move_default2,
   close_default,
   cancel_default,
   status_default3,