@open-tomato/rafa 0.26.0 → 0.28.0

package/dist/{index-59x3zsh4.js → index-6jkj0dcx.js}

@@ -14,6 +14,7 @@ import {
   writeTrackerBlocker
 } from "./index-p1265xgj.js";
 import {
+  ACROSS_STORES_ORDER,
   CORE_ADAPTER_REGISTRY,
   ClaudePlannerError,
   DEVELOPMENT_MARK,
@@ -33,6 +34,7 @@ import {
   SKILL_FILE,
   SQLITE_MIGRATIONS,
   SQLITE_STORE_FILE_NAME,
+  STAMPED_COLUMNS,
   SessionConflictError,
   SessionRecordError,
   SessionStateError,
@@ -40,13 +42,17 @@ import {
   beginSession,
   checkUsage,
   createGhRunner,
+  createGitRunner,
   createLocalTracker,
   declaredNameIssue,
   effortStoreDir,
   errorCode,
   getClaudeUsagePercent,
   gitRemoteUrl,
+  gitSaid,
+  goHome,
   guardTestProcess,
+  hopFilePath,
   interruptClaudeSessions,
   isPidAlive,
   isSessionId,
@@ -56,8 +62,12 @@ import {
   parseInstinct,
   planFilePath,
   planSchema,
+  positionAt,
+  positionFilePath,
   readFrontmatter,
   readFrontmatterDocument,
+  readHopRecord,
+  readPositionFile,
   readScopes,
   readSession,
   readSessions,
@@ -67,21 +77,24 @@ import {
   runClaudeCaptured,
   runsDir,
   scanLayout,
-  scopeAt,
   selectEffortStore,
   sessionFilePath,
   setActiveStoreSettings,
   sqliteCatalogue,
   sqliteStorePath,
+  staleAgainst,
+  stampedValues,
   typeOfLabels,
   updateSession,
   version,
   withSqliteStore,
   writeFrontmatter,
+  writeHopRecord,
   writeInstinct,
   writeNames,
+  writePositionFile,
   writeSqliteStore
-} from "./index-azptzvp3.js";
+} from "./index-4rwvr6t4.js";
 import {
   CHANGE_LEVELS,
   CONFIG_DEFAULTS,
@@ -967,9 +980,10 @@ var INSERT_FINDING = `
   INSERT INTO findings (
     id, session_id, plan_stub, task_line,
     kind, trigger, what, cause, resolution, artifact, signal,
-    outcome, tracker_ref, collected_at
+    outcome, tracker_ref, collected_at,
+    ${STAMPED_COLUMNS}
   )
-  VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, ?)
+  VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, ?, ${stampedValues("findings")})
   ON CONFLICT (session_id, artifact) WHERE artifact IS NOT NULL DO NOTHING
   ON CONFLICT (session_id, trigger, what) WHERE artifact IS NULL DO NOTHING
 `;
@@ -1096,8 +1110,8 @@ function writeFindings(repoRoot, write, seams = {}) {
 // src/effort/store/skill-invocations.ts
 var UNKNOWN_SKILL_COUNT = "unknown";
 var INSERT_INVOCATION = `
-  INSERT INTO skill_invocations (session_id, name, sidechain, count)
-  VALUES (?, ?, ?, ?)
+  INSERT INTO skill_invocations (session_id, name, sidechain, count, ${STAMPED_COLUMNS})
+  VALUES (?, ?, ?, ?, ${stampedValues("skill_invocations")})
 `;
 var SELECT_HELD = "SELECT 1 AS held FROM skill_invocations WHERE session_id = ? LIMIT 1";
 var SELECT_ALL = "SELECT session_id, name, sidechain, count FROM skill_invocations ORDER BY seq";
@@ -3812,8 +3826,8 @@ async function waitForChecks(options) {
 // src/effort/store/plan-ci.ts
 var PLAN_CI_VERDICTS = ["green", "red", "none"];
 var INSERT_PLAN_CI = `
-  INSERT INTO plan_ci (plan_stub, pr, head_sha, verdict, failing, read_at)
-  VALUES (?, ?, ?, ?, ?, ?)
+  INSERT INTO plan_ci (plan_stub, pr, head_sha, verdict, failing, read_at, ${STAMPED_COLUMNS})
+  VALUES (?, ?, ?, ?, ?, ?, ${stampedValues("plan_ci")})
   ON CONFLICT (pr, head_sha, read_at) DO NOTHING
 `;
 var SELECT_COLUMNS = "SELECT plan_stub, pr, head_sha, verdict, failing, read_at FROM plan_ci";
@@ -3928,9 +3942,10 @@ var INSERT_REPORT = `
     id, session_id, plan_stub, task_line,
     status,
     outcome, collected_at,
-    skills_used
+    skills_used,
+    ${STAMPED_COLUMNS}
   )
-  VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+  VALUES (?, ?, ?, ?, ?, ?, ?, ?, ${stampedValues("task_reports")})
   ON CONFLICT (session_id) DO NOTHING
 `;
 function refusedWrite4(reason) {
@@ -3995,7 +4010,7 @@ function readTaskReportTallies(repoRoot) {
 var SELECT_REPORTED_SKILLS = `
   SELECT session_id, plan_stub, task_line, outcome, skills_used
   FROM task_reports
-  ORDER BY seq
+  ORDER BY ${ACROSS_STORES_ORDER}
 `;
 function parseSkillsUsed(sessionId, json) {
   if (json === null)
@@ -4020,14 +4035,14 @@ function readReportedSkills(repoRoot) {
 }
 
 // src/effort/skill-facts.ts
-var SELECT_OFFERS = "SELECT session_id, resolver, skills_offered, lessons_offered FROM dispatches ORDER BY seq";
+var SELECT_OFFERS = `SELECT session_id, resolver, skills_offered, lessons_offered FROM dispatches ORDER BY ${ACROSS_STORES_ORDER}`;
 var SELECT_FINDINGS = `
   SELECT session_id, kind, trigger, what, cause, resolution, artifact, signal
   FROM findings
-  ORDER BY seq
+  ORDER BY ${ACROSS_STORES_ORDER}
 `;
 function selectEntries(table) {
-  return `SELECT session_id, what, artifact FROM ${table} ORDER BY seq`;
+  return `SELECT session_id, what, artifact FROM ${table} ORDER BY ${ACROSS_STORES_ORDER}`;
 }
 function parseNames(column, sessionId, json) {
   if (json === null)
@@ -4329,9 +4344,10 @@ var INSERT_DISPATCH = `
   INSERT INTO dispatches (
     session_id, plan_stub, task_line,
     declaration, agent, model, effort, budget_usd, tools,
-    flags, resolver, skills_offered, lessons_offered, collected_at
+    flags, resolver, skills_offered, lessons_offered, collected_at,
+    ${STAMPED_COLUMNS}
   )
-  VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ${stampedValues("dispatches")})
   ON CONFLICT (session_id) DO NOTHING
 `;
 function refusedWrite5(reason) {
@@ -4472,9 +4488,10 @@ var INSERT_CHECK = `
     run_id, position,
     tier, kind, item, probe,
     outcome, duration_ms, failure,
-    collected_at
+    collected_at,
+    ${STAMPED_COLUMNS}
   )
-  VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ${stampedValues("preflight")})
 `;
 function refusedWrite6(reason) {
   return new Error(`effort store: preflight write ${reason}; nothing written`);
@@ -6297,6 +6314,7 @@ var SPEC_FLAG = "--spec";
 var ISSUE_FLAG = "--issue";
 var NEXT_FLAG = "--next";
 var REFRESH_FLAG = "--refresh";
+var ROADMAP_FLAG = "--roadmap";
 var DRY_RUN_FLAG = "--dry-run";
 var SKIP_REVIEW_FLAG = "--skip-review";
 var NO_COMMENT_FLAG = "--no-comment";
@@ -8627,26 +8645,6 @@ var GLOBAL_FLAGS = Object.freeze([
 ]);
 var SPENDS_LEGEND = `${SPENDS_GLYPH}  starts Claude Code sessions, which spend your Claude usage`;
 
-// src/pr/git.ts
-import { spawnSync } from "child_process";
-function createGitRunner(cwd) {
-  return (args) => {
-    const result = spawnSync("git", [...args], {
-      cwd,
-      encoding: "utf8",
-      env: { ...process.env, LC_ALL: "C" }
-    });
-    if (result.error !== undefined) {
-      return { ok: false, stdout: "", stderr: `could not run git in ${cwd}: ${messageOf(result.error)}` };
-    }
-    return { ok: result.status === 0, stdout: result.stdout ?? "", stderr: result.stderr ?? "" };
-  };
-}
-function gitSaid(result) {
-  return [result.stderr, result.stdout].map((stream) => stream.trim()).filter((stream) => stream !== "").join(`
-`);
-}
-
 // src/refs/verify.ts
 class RefVerifyError extends Error {
   constructor(problem) {
@@ -9406,9 +9404,81 @@ function dryEpicSentence(epic) {
   const { done, total } = epic.progress;
   return `epic #${String(epic.number)} ${epic.title} has run dry: every line of its checklist and every open member it labels` + ` is done or taken, though the epic is not done (${String(done)}/${String(total)});` + " the walk stops here and does not move on to another epic";
 }
+function rowOnListing(number, listing, what) {
+  const row = listing.find((issue3) => issue3.number === number);
+  if (row === undefined) {
+    throw new Error(`${PREFIX9}: ${what} #${String(number)} is not on the board listing, so the next ${NOW_HORIZON_LABEL} epic` + " cannot be read; the listing reads the newest issues only, and a line it leaves out is not passed as if it were none");
+  }
+  return row;
+}
+async function hasPickableLine(epic, row, readings) {
+  const pick = await pickNextRoadmapLine(epicLines(epic, row).lines, readings);
+  return pick.line !== null;
+}
+async function nowEpicOf(line, listing, readings) {
+  if (line.ticked)
+    return null;
+  const row = rowOnListing(line.issue, listing, "checklist line");
+  if (row.type !== "epic" || row.state !== "OPEN" || !isNowEpic(row.labels))
+    return null;
+  const { epic } = epicOnListing(line.issue, listing);
+  if (epic.state === "done")
+    return null;
+  return await hasPickableLine(epic, row, readings) ? epic : null;
+}
+async function nextNowEpic(request) {
+  const { after, board, listing, readings } = request;
+  const lines = parseRoadmapBody(rowOnListing(board, listing, "board").body);
+  const at = lines.findIndex((line) => line.issue === after);
+  if (at === -1)
+    return null;
+  for (const line of lines.slice(at + 1)) {
+    const epic = await nowEpicOf(line, listing, readings);
+    if (epic === null)
+      continue;
+    return Object.freeze({
+      number: epic.number,
+      title: epic.title,
+      slug: epic.slug,
+      board,
+      line,
+      progress: epic.progress
+    });
+  }
+  return null;
+}
 
 // src/board/spec-source-roadmap.ts
 var PREFIX10 = "board spec source roadmap";
+function hopHeaderLine(away) {
+  const { record, target } = away;
+  return `\uD83E\uDDED Away on a hop: issue #${String(target)}, the blocker of #${String(record.blocked)},` + ` in epic #${String(record.targetEpic)} on board #${String(record.targetBoard)}`;
+}
+function hopPickLine(target) {
+  return `\u25B6 Next on the hop: issue #${String(target)}`;
+}
+function hopBlockedMessage(target) {
+  return `issue #${String(target)} is the hop's target and still has an open blocker, so nothing is planned;` + " a hop follows one blocker, never a second, and `rafa next --roadmap` goes home from here";
+}
+function unfollowedHopNotice(detail) {
+  return `${detail}, so no hop is followed and --next picks as it does without --roadmap`;
+}
+function readAwayHop(root) {
+  const hop = readHopRecord(root);
+  if (!hop.set) {
+    return {
+      away: null,
+      notices: hop.reason === "absent" ? [] : [unfollowedHopNotice(hop.detail)]
+    };
+  }
+  const { record } = hop;
+  const placed = readPositionFile(root);
+  if (!placed.set || staleAgainst(record, placed.position))
+    return { away: null, notices: [] };
+  if (record.state !== "away" || record.kind !== "blocker" || record.target === null)
+    return { away: null, notices: [] };
+  return { away: Object.freeze({ record, target: record.target }), notices: [] };
+}
 function roadmapHeaderLine(roadmap) {
   return `\uD83D\uDDFA  Reading the roadmap, issue #${String(roadmap)}, for the next spec...`;
 }
@@ -9487,6 +9557,12 @@ async function walkPlaceEpic(number, listing, readings) {
 }
 async function pickRoadmapIssue(options) {
   const { seams, issues, output } = options;
+  if (options.followHop === true) {
+    const hop = readAwayHop(options.root);
+    hop.notices.forEach((notice) => output.warn(notice));
+    if (hop.away !== null)
+      return await pickHopTarget(hop.away, issues, output);
+  }
   const listing = listOnce2(seams.listing);
   const start = await startingPlace(options, listing);
   start.notices.forEach((notice) => output.warn(notice));
@@ -9515,6 +9591,17 @@ async function pickRoadmapIssue(options) {
   output.info(pickLine(pick.line));
   return settlePick(pick.line, { lines: descent.lines, issues, readings, seams, output });
 }
+async function pickHopTarget(away, issues, output) {
+  output.info(hopHeaderLine(away));
+  const blocked2 = await readBlockedLine(await issues(away.target), blockerStatesOf(issues));
+  if (blocked2 !== null) {
+    output.info(blockedPickLine(blocked2));
+    output.info(hopBlockedMessage(away.target));
+    return { stop: "blocked" };
+  }
+  output.info(hopPickLine(away.target));
+  return { issue: away.target };
+}
 function printDescent(walked, output) {
   const { descent, pick } = walked;
   descent.passed.forEach((pass) => output.info(descentPassLine(pass)));
@@ -9565,6 +9652,7 @@ async function settleBlockedPick(options) {
 var PREFIX11 = "board spec source";
 var SOURCE_FLAGS = [SPEC_FLAG, ISSUE_FLAG, NEXT_FLAG];
 var SOURCE_REFUSAL_EXIT = 1;
+var ROADMAP_REFUSAL_EXIT2 = 2;
 function severalSourcesMessage(given) {
   const named = given.join(" and ");
   return `${named} each name a spec, and a run plans from one; drop all but one of them`;
@@ -9572,6 +9660,9 @@ function severalSourcesMessage(given) {
 function noSourceMessage(specsDir) {
   return `no spec was named: pass ${SPEC_FLAG}=<file>.md, read against the project root` + ` or under specs.dir (${specsDir}), ${ISSUE_FLAG}=<n> to plan from an issue,` + ` or ${NEXT_FLAG} to take the first undone line of the roadmap`;
 }
+function roadmapWithoutNextMessage() {
+  return `${ROADMAP_FLAG} follows a hop to the spec ${NEXT_FLAG} would plan, and this line gives no ${NEXT_FLAG};` + ` write ${NEXT_FLAG} ${ROADMAP_FLAG}, or drop ${ROADMAP_FLAG}`;
+}
 function missingValueMessage(flag, wants) {
   return `${flag} was given no value; write ${flag}=${wants}`;
 }
@@ -9607,6 +9698,14 @@ function requestOf(flag, word) {
   }
   return flag === SPEC_FLAG ? { kind: "spec", spec: word.value } : { kind: "issue", issue: issueNumberOf(word.value, ISSUE_FLAG) };
 }
+function withRoadmap(args, request) {
+  if (!readFlagWord(args, ROADMAP_FLAG).given)
+    return request;
+  if (request?.kind !== "next") {
+    throw new CommandExit(ROADMAP_REFUSAL_EXIT2, roadmapWithoutNextMessage());
+  }
+  return { ...request, followHop: true };
+}
 function readSpecSourceFlags(args) {
   const words = SOURCE_FLAGS.map((flag) => ({ flag, word: readFlagWord(args, flag) }));
   const given = words.filter((entry) => entry.word.given);
@@ -9614,8 +9713,9 @@ function readSpecSourceFlags(args) {
     throw new CommandExit(SOURCE_REFUSAL_EXIT, severalSourcesMessage(given.map((entry) => entry.flag)));
   }
   const [only] = given;
+  const request = only === undefined ? null : requestOf(only.flag, only.word);
   return Object.freeze({
-    request: only === undefined ? null : requestOf(only.flag, only.word),
+    request: withRoadmap(args, request),
     refresh: args.includes(REFRESH_FLAG),
     dryRun: args.includes(DRY_RUN_FLAG)
   });
@@ -9670,7 +9770,8 @@ async function resolveSpecSource(options) {
     seams: requireRoadmapSeams(options.roadmap),
     root: repoRoot,
     issues,
-    output
+    output,
+    ...request.followHop === true ? { followHop: true } : {}
   });
   if ("stop" in picked)
     return stopped(picked.stop);
@@ -9954,7 +10055,7 @@ function withOutlineCache(outline, root) {
 import path2 from "path";
 async function coreRoster() {
   const [{ CORE_REGISTRY }, { describeRegistry }] = await Promise.all([
-    import("./index-2yd8bber.js"),
+    import("./index-em1vd7kd.js"),
     import("./describe-vbwqxj1f.js")
   ]);
   return describeRegistry(CORE_REGISTRY, version);
@@ -10185,78 +10286,6 @@ function renderDoctorRefs(reading2) {
   return [headLine(reading2), ...reading2.copies.flatMap(copyLine)];
 }
 
-// src/project/position.ts
-import { randomUUID as randomUUID3 } from "crypto";
-import { mkdirSync as mkdirSync8, readFileSync as readFileSync19, renameSync as renameSync4, rmSync as rmSync2, writeFileSync as writeFileSync9 } from "fs";
-import { dirname as dirname9, join as join13 } from "path";
-var POSITION_FILE = "position.json";
-function positionFilePath(root) {
-  return join13(scopeAt(root).dir, POSITION_FILE);
-}
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isIssueNumber(value) {
-  return typeof value === "number" && Number.isInteger(value) && value > 0;
-}
-function asPlace(value) {
-  if (!isRecord(value) || !isIssueNumber(value.board))
-    return null;
-  if (value.epic !== null && !isIssueNumber(value.epic))
-    return null;
-  return { board: value.board, epic: value.epic };
-}
-function asPosition(value) {
-  if (!isRecord(value))
-    return null;
-  const current = asPlace(value.current);
-  const home = asPlace(value.home);
-  const previous = value.previous === null ? null : asPlace(value.previous);
-  if (current === null || home === null)
-    return null;
-  if (previous === null && value.previous !== null)
-    return null;
-  return { current, previous, home };
-}
-function readPositionFile(root) {
-  const file = positionFilePath(root);
-  let text;
-  try {
-    text = readFileSync19(file, "utf8");
-  } catch (error) {
-    const code = error.code;
-    return code === "ENOENT" ? { set: false, reason: "absent", detail: `No position file at ${file}` } : { set: false, reason: "unreadable", detail: `Cannot read ${file}: ${messageOf(error)}` };
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(text);
-  } catch (error) {
-    return { set: false, reason: "invalid-json", detail: `${file} holds no JSON: ${messageOf(error)}` };
-  }
-  const position = asPosition(parsed);
-  return position === null ? { set: false, reason: "wrong-shape", detail: `${file} does not hold a current, previous and home place` } : { set: true, position };
-}
-function writePositionFile(root, position) {
-  const file = positionFilePath(root);
-  mkdirSync8(dirname9(file), { recursive: true });
-  const temporary = `${file}.${String(process.pid)}.${randomUUID3()}.tmp`;
-  const { current, previous, home } = position;
-  try {
-    writeFileSync9(temporary, `${JSON.stringify({ current, previous, home }, null, 2)}
-`);
-    renameSync4(temporary, file);
-  } catch (error) {
-    rmSync2(temporary, { force: true });
-    throw error;
-  }
-}
-function rehome(position, place) {
-  return { current: place, previous: position.current, home: place };
-}
-function hop(position, place) {
-  return { current: place, previous: position.current, home: position.home };
-}
-
 // src/adapters/tracker/resolve.ts
 var PREFIX12 = "tracker chain";
 var FAILURE_SEPARATOR = "; ";
@@ -11636,19 +11665,20 @@ function createIssueListCommand(seams = DEFAULT_ISSUE_SEAMS) {
 var list_default = createIssueListCommand();
 
 // src/commands/release/status.ts
-import { existsSync as existsSync17, readdirSync as readdirSync8, readFileSync as readFileSync21 } from "fs";
-import { join as join14 } from "path";
+import { existsSync as existsSync17, readdirSync as readdirSync8, readFileSync as readFileSync20 } from "fs";
+import { join as join13 } from "path";
 
 // src/effort/store/changes.ts
-import { randomUUID as randomUUID4 } from "crypto";
+import { randomUUID as randomUUID3 } from "crypto";
 import { existsSync as existsSync16 } from "fs";
 var INSERT_CHANGE = `
   INSERT INTO changes (
     id, session_id, plan_stub, task_line,
     level, area, summary,
-    collected_at
+    collected_at,
+    ${STAMPED_COLUMNS}
   )
-  VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+  VALUES (?, ?, ?, ?, ?, ?, ?, ?, ${stampedValues("changes")})
   ON CONFLICT (session_id, level, ifnull(area, ''), summary) DO NOTHING
 `;
 function optionalText(value) {
@@ -11707,7 +11737,7 @@ function writeChanges(repoRoot, write, seams = {}) {
       rejected.push(rejection);
   }
   const collectedAt = (seams.now ?? (() => new Date))().toISOString();
-  const newId = seams.newId ?? randomUUID4;
+  const newId = seams.newId ?? randomUUID3;
   const rows = stored.map((change) => rowValues2(change, write.dispatch, newId(), collectedAt));
   const appended2 = writeSqliteStore(path3, rows.length, 0, (db) => insertRows3(db, rows));
   return { path: path3, appended: appended2, skipped: stored.length - appended2, rejected };
@@ -11716,7 +11746,7 @@ var SELECT_PLAN_CHANGES = `
   SELECT session_id, task_line, level, area, summary, collected_at
   FROM changes
   WHERE plan_stub IS ?
-  ORDER BY seq
+  ORDER BY ${ACROSS_STORES_ORDER}
 `;
 function readPlanChanges(repoRoot, planStub2) {
   const path3 = sqliteStorePath(repoRoot);
@@ -11973,7 +12003,7 @@ function remainingFrom(steps, failed2) {
   return at === -1 ? Object.freeze([]) : Object.freeze(steps.slice(at).filter((step) => step.skip === undefined));
 }
 // src/pr/none.ts
-import { spawnSync as spawnSync2 } from "child_process";
+import { spawnSync } from "child_process";
 
 // src/pr/provider.ts
 var GITHUB_HOST = "github.com";
@@ -12014,7 +12044,7 @@ function requireGhProvider(reading2) {
 // src/pr/none.ts
 var COMPARE_QUERY = "?expand=1";
 function pushBranch(dir, branch) {
-  const result = spawnSync2("git", ["push", "--set-upstream", "origin", branch], {
+  const result = spawnSync("git", ["push", "--set-upstream", "origin", branch], {
     cwd: dir,
     encoding: "utf8",
     env: { ...process.env, LC_ALL: "C" }
@@ -12048,6 +12078,8 @@ var SUMMARY_FIELDS = "author,baseRefName,headRefName,isCrossRepository,number,st
 var DETAIL_FIELDS = `${SUMMARY_FIELDS},body,headRefOid,labels,mergeStateStatus,mergeable`;
 var CHECK_FIELDS = "name,state,link";
 var MERGED_FIELDS = "headRefName,headRefOid,mergedAt,number";
+var FILES_FIELDS = "changedFiles,files";
+var REVIEW_FIELDS = "reviews";
 var WORKFLOWS_PATH = `repos/${REPO_PATH3}/actions/workflows`;
 var LIST_LIMIT = 30;
 var MERGED_LIMIT = 100;
@@ -12182,6 +12214,33 @@ function readComment2(value, command, where) {
     url: readString2(comment["html_url"], command, `${where}.html_url`)
   };
 }
+function readCount(value, command, where) {
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
+    refuse3(command, `${where} is ${describeValue(value)}, expected a whole number of zero or more`);
+  }
+  return value;
+}
+function readChangedFiles(value, command) {
+  const pull = readMapping(value, command, "its output");
+  const count = readCount(pull["changedFiles"], command, "changedFiles");
+  const paths = readList(pull["files"], command, "files").map((file, index) => {
+    const named = readMapping(file, command, `files[${index}]`);
+    return readString2(named["path"], command, `files[${index}].path`);
+  });
+  if (paths.length !== count) {
+    refuse3(command, `${paths.length} paths for ${count} changed files, so the list is not the whole of it`);
+  }
+  return paths;
+}
+function readReview(value, command, where) {
+  const review = readMapping(value, command, where);
+  const author = readMapping(review["author"], command, `${where}.author`);
+  return {
+    login: readString2(author["login"], command, `${where}.author.login`),
+    state: readString2(review["state"], command, `${where}.state`),
+    submittedAt: readString2(review["submittedAt"], command, `${where}.submittedAt`)
+  };
+}
 function readWorkflowCount(stdout) {
   let payload;
   try {
@@ -12277,6 +12336,20 @@ function createGhPullRequests(options) {
       const rows = parseChecks(result.stdout);
       return { rows, verdict: verdictOf(rows) };
     },
+    changedFiles: async (number) => {
+      const target = pullNumber(number, "changedFiles");
+      const command = `gh pr view ${target} --json ${FILES_FIELDS}`;
+      const stdout = await succeed(["pr", "view", target, "--json", FILES_FIELDS], command);
+      return readChangedFiles(parseJson2(stdout, command), command);
+    },
+    reviews: async (number) => {
+      const target = pullNumber(number, "reviews");
+      const command = `gh pr view ${target} --json ${REVIEW_FIELDS}`;
+      const stdout = await succeed(["pr", "view", target, "--json", REVIEW_FIELDS], command);
+      const pull = readMapping(parseJson2(stdout, command), command, "its output");
+      const rows = readList(pull["reviews"], command, "reviews");
+      return rows.map((row, index) => readReview(row, command, `reviews[${index}]`));
+    },
     browse: async (number) => {
       const target = pullNumber(number, "browse");
       await succeed(["pr", "view", target, "--web"], `gh pr view ${target} --web`);
@@ -12546,7 +12619,7 @@ function resolveReleaseLevel(declared, notes) {
 }
 
 // src/release/version.ts
-import { readFileSync as readFileSync20, writeFileSync as writeFileSync10 } from "fs";
+import { readFileSync as readFileSync19, writeFileSync as writeFileSync9 } from "fs";
 var RELEASE_REMOTE = "origin";
 var RELEASE_BASE_BRANCH = "main";
 var VERSION_SHAPE = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([0-9A-Za-z.-]+))?(?:\+([0-9A-Za-z.-]+))?$/;
@@ -12638,7 +12711,7 @@ function writeManifestVersion(path3, next) {
   const unwritten = { path: path3, written: false, previous: null, version: next };
   let text;
   try {
-    text = readFileSync20(path3, "utf8");
+    text = readFileSync19(path3, "utf8");
   } catch (error) {
     return { ...unwritten, problem: `${path3} could not be read: ${messageOf(error)}` };
   }
@@ -12652,7 +12725,7 @@ function writeManifestVersion(path3, next) {
     };
   }
   try {
-    writeFileSync10(path3, rewritten.text);
+    writeFileSync9(path3, rewritten.text);
   } catch (error) {
     return { ...unwritten, previous: rewritten.previous, problem: `${path3} could not be written: ${messageOf(error)}` };
   }
@@ -12786,13 +12859,13 @@ function untaggedVersions(released, tags) {
 }
 function textOf(path3) {
   try {
-    return readFileSync21(path3, "utf8");
+    return readFileSync20(path3, "utf8");
   } catch {
     return null;
   }
 }
 function readVersionFile(root, configured) {
-  const resolved = join14(root, configured);
+  const resolved = join13(root, configured);
   const text = textOf(resolved);
   if (text === null) {
     return { path: configured, version: null, problem: `the version file could not be read at ${resolved}` };
@@ -12809,7 +12882,7 @@ function readTags(git) {
   return { tags, latest: tags[0] ?? null, problem: null };
 }
 function readUntagged(root, configured, tags) {
-  const resolved = join14(root, configured);
+  const resolved = join13(root, configured);
   const text = textOf(resolved);
   if (text === null) {
     return {
@@ -12828,7 +12901,7 @@ function readBranch(git) {
   return result.ok && branch !== "" && branch !== "HEAD" ? branch : null;
 }
 function planStubsUnder2(root, planDir) {
-  const resolved = join14(root, planDir);
+  const resolved = join13(root, planDir);
   if (!existsSync17(resolved))
     return [];
   try {
@@ -13030,23 +13103,23 @@ function createReleaseStatusCommand(seams = DEFAULT_RELEASE_SEAMS) {
 var status_default = createReleaseStatusCommand();
 
 // src/commands/plan/list.ts
-import { existsSync as existsSync18, readdirSync as readdirSync9, readFileSync as readFileSync22 } from "fs";
-import { join as join15 } from "path";
+import { existsSync as existsSync18, readdirSync as readdirSync9, readFileSync as readFileSync21 } from "fs";
+import { join as join14 } from "path";
 var USAGE4 = "rafa plan list";
 var OPEN_HINT = "Type it bare: rafa plan list --open";
 function listing(dir, stub) {
-  const plan = join15(dir, planFileName(stub, false));
-  const trackerPath = join15(dir, planFileName(stub, true));
+  const plan = join14(dir, planFileName(stub, false));
+  const trackerPath = join14(dir, planFileName(stub, true));
   const tracker = isFile(trackerPath) ? trackerPath : null;
-  const planModel = parsePlan(readFileSync22(plan, "utf8"));
-  const counted2 = tracker === null ? planModel : parsePlan(readFileSync22(tracker, "utf8"));
+  const planModel = parsePlan(readFileSync21(plan, "utf8"));
+  const counted2 = tracker === null ? planModel : parsePlan(readFileSync21(tracker, "utf8"));
   return { stub, plan, tracker, tasks: countTasks(counted2.tasks), issues: planModel.issues.length };
 }
 function listPlans(plans) {
   const dir = plans.path;
   if (!existsSync18(dir))
     return { dir, plans: [] };
-  const stubs = readdirSync9(dir).filter((name) => isFile(join15(dir, name))).map((name) => stubOfPlanFile(name)).filter((stub) => stub !== null).sort((a, b) => a.localeCompare(b));
+  const stubs = readdirSync9(dir).filter((name) => isFile(join14(dir, name))).map((name) => stubOfPlanFile(name)).filter((stub) => stub !== null).sort((a, b) => a.localeCompare(b));
   return { dir, plans: stubs.map((stub) => listing(dir, stub)) };
 }
 function isOpen(plan) {
@@ -13415,8 +13488,8 @@ function parseArgs(argv, spec = {}) {
 
 // src/commands/loop/loop-sessions.ts
 import { execFileSync as execFileSync2 } from "child_process";
-import { readFileSync as readFileSync23 } from "fs";
-import { join as join16, relative as relative3 } from "path";
+import { readFileSync as readFileSync22 } from "fs";
+import { join as join15, relative as relative3 } from "path";
 
 // src/effort/store/task-finishes.ts
 import { existsSync as existsSync19 } from "fs";
@@ -13560,11 +13633,11 @@ function writeSession(root, record, change) {
   }
 }
 function readSessionChecklist(root, record) {
-  const plan = join16(root, record.plan);
+  const plan = join15(root, record.plan);
   const file = [trackerPathFor(plan), plan].find((path3) => isFile(path3));
   if (file === undefined)
     return null;
-  const content = readFileSync23(file, "utf8");
+  const content = readFileSync22(file, "utf8");
   return { file, tasks: parsePlan(content).tasks, lines: content.split(`
 `) };
 }
@@ -13655,6 +13728,668 @@ function watchDryEpic() {
   };
 }
 
+// src/board/epic-board.ts
+function openBoards(listing2) {
+  return listing2.filter((issue3) => issue3.state === "OPEN" && issue3.labels.includes(ROADMAP_LABEL)).sort((a, b) => a.number - b.number);
+}
+function boardListsEpic(number, epic, view) {
+  const row = view.rows.get(number);
+  if (row?.state !== "OPEN")
+    return false;
+  return parseRoadmapBody(row.body).some((line) => line.issue === epic);
+}
+async function boardOfEpic(epic, current, view) {
+  if (boardListsEpic(current.board, epic, view))
+    return current.board;
+  const fallback = await view.defaultBoard();
+  if (boardListsEpic(fallback, epic, view))
+    return fallback;
+  return openBoards(view.listing).find((row) => boardListsEpic(row.number, epic, view))?.number ?? fallback;
+}
+
+// src/board/blocker-epic.ts
+var REASON_SENTENCES = Object.freeze({
+  "cross-repository": "is on another repository, which the board listing does not read",
+  "not-on-listing": "is not on the board listing",
+  "no-epic-label": `carries no ${EPIC_LABEL_PREFIX}<slug> label, so no epic holds it`,
+  "same-epic": "is in the home epic, so there is no other epic to hop to",
+  "no-epic": "carries an epic label no epic issue owns",
+  "closed-epic": "is in a closed epic",
+  "no-open-board": "is in an epic no open board lists"
+});
+function noHopSentence(answer2) {
+  const name = typeof answer2.blocker === "number" ? `#${String(answer2.blocker)}` : answer2.blocker;
+  const epic = answer2.epic === null ? "" : ` (epic #${String(answer2.epic)})`;
+  return `${name}${epic} ${REASON_SENTENCES[answer2.reason]}`;
+}
+function epicOfSlug(slug, listing2) {
+  return listing2.filter((row) => row.type === "epic" && epicSlugsOf(row.labels)[0] === slug).sort((a, b) => a.number - b.number)[0];
+}
+function noHop(blocker, reason, epic = null) {
+  return Object.freeze({ kind: "no-hop", blocker, reason, epic });
+}
+async function locateBlockerEpic(request) {
+  const { blocker, home, view } = request;
+  if (typeof blocker === "string")
+    return noHop(blocker, "cross-repository");
+  const row = view.rows.get(blocker);
+  if (row === undefined)
+    return noHop(blocker, "not-on-listing");
+  const slugs = epicSlugsOf(row.labels);
+  if (slugs.length === 0)
+    return noHop(blocker, "no-epic-label");
+  const epics = slugs.map((slug2) => ({ slug: slug2, epic: epicOfSlug(slug2, view.listing) }));
+  if (home.epic !== null && epics.some(({ epic: epic2 }) => epic2?.number === home.epic)) {
+    return noHop(blocker, "same-epic", home.epic);
+  }
+  const [first] = epics;
+  if (first?.epic === undefined)
+    return noHop(blocker, "no-epic");
+  const { slug, epic } = first;
+  if (epic.state === "CLOSED")
+    return noHop(blocker, "closed-epic", epic.number);
+  const board = await boardOfEpic(epic.number, home, view);
+  if (!boardListsEpic(board, epic.number, view))
+    return noHop(blocker, "no-open-board", epic.number);
+  return Object.freeze({ kind: "located", blocker, epic: epic.number, slug, board });
+}
+
+// src/next/hop-chain.ts
+function oneHopAllows(from, to, home) {
+  return samePlace(from, home) || samePlace(to, home);
+}
+function chainText(chain) {
+  const head = `#${String(chain.blocked)} \u2190 #${String(chain.blocker)}`;
+  return chain.next.length === 0 ? head : `${head} \u2190 ${chain.next.map((id2) => `#${String(id2)}`).join(", ")}`;
+}
+function placeText(place) {
+  return place.epic === null ? `board #${String(place.board)}` : `epic #${String(place.epic)} on board #${String(place.board)}`;
+}
+function leftText(place) {
+  return place.epic === null ? `board #${String(place.board)}` : `epic #${String(place.epic)}`;
+}
+function hopMoveSentence(move) {
+  return `hop from ${leftText(move.from)}: #${String(move.blocked)} blocked by #${String(move.blocker)}, in epic #${String(move.epic)}`;
+}
+function haltSentence(halt) {
+  const chain = `halt: ${chainText(halt.chain)}`;
+  if (halt.reason === "both-away") {
+    return `${chain}: the move from ${placeText(halt.from)} to ${placeText(halt.to)} has neither end at home`;
+  }
+  if (halt.fault !== null)
+    return `${chain}: ${halt.fault}`;
+  return halt.chain.mutual ? `${chain}: #${String(halt.chain.blocked)} and #${String(halt.chain.blocker)} block each other` : `${chain}: #${String(halt.chain.blocker)} is blocked in turn`;
+}
+function takenText(taken) {
+  return taken.by === "branch" ? `branch ${taken.branch} exists` : `PR #${String(taken.pullRequest)} open`;
+}
+function hopDecisionSentence(decision) {
+  if (decision.kind === "hop")
+    return hopMoveSentence(decision);
+  if (decision.kind === "wait") {
+    return `#${String(decision.blocked)} waits on #${String(decision.blocker)}, taken: ${takenText(decision.taken)}`;
+  }
+  if (decision.kind === "halt")
+    return haltSentence(decision);
+  return `#${String(decision.blocked)} stays: ${noHopSentence(decision.located)}`;
+}
+async function takenBy(blocker, taken) {
+  const branch = taken.branchFor(blocker);
+  if (branch !== null)
+    return { by: "branch", branch };
+  const pullRequest = await taken.pullRequestFor(blocker);
+  return pullRequest === null ? null : { by: "pull-request", pullRequest };
+}
+function blockerLine(blocker, view) {
+  const row = view.rows.get(blocker);
+  if (row === undefined)
+    return Promise.resolve(null);
+  const states = (issue3) => Promise.resolve(view.rows.get(issue3)?.state ?? null);
+  return readBlockedLine({ ...row, author: "" }, states);
+}
+function chainOf(blocked2, blocker, next) {
+  return Object.freeze({ blocked: blocked2, blocker, next: Object.freeze([...next]), mutual: next.includes(blocked2) });
+}
+function halt(reason, chain, from, to, fault = null) {
+  return Object.freeze({ kind: "halt", reason, chain, from, to, fault });
+}
+async function decideHop(request) {
+  const { blocked: blocked2, blocker, position, view } = request;
+  const from = position.current;
+  const located = await locateBlockerEpic({ blocker, home: from, view });
+  if (located.kind === "no-hop")
+    return Object.freeze({ kind: "stay", blocked: blocked2, located });
+  const to = Object.freeze({ board: located.board, epic: located.epic });
+  if (!oneHopAllows(from, to, position.home)) {
+    return halt("both-away", chainOf(blocked2, located.blocker, []), from, to);
+  }
+  const taken = await takenBy(located.blocker, request.taken);
+  if (taken !== null) {
+    return Object.freeze({
+      kind: "wait",
+      blocked: blocked2,
+      blocker: located.blocker,
+      epic: located.epic,
+      board: located.board,
+      taken: Object.freeze(taken)
+    });
+  }
+  const line = await blockerLine(located.blocker, view);
+  if (line !== null) {
+    const held = line.blockers.filter((id2) => line.open.includes(id2) || line.unread.includes(id2));
+    const chain = chainOf(blocked2, located.blocker, held);
+    return halt("blocked-blocker", chain, from, to, line.fault);
+  }
+  return Object.freeze({
+    kind: "hop",
+    blocked: blocked2,
+    blocker: located.blocker,
+    epic: located.epic,
+    slug: located.slug,
+    board: located.board,
+    from,
+    to
+  });
+}
+
+// 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_SEPARATOR2 = /[\s,]+/u;
+function undressed(text) {
+  return text.replaceAll("`", " ").trim();
+}
+function normaliseFolder(folder) {
+  let path3 = folder;
+  while (path3.startsWith("./"))
+    path3 = path3.slice(2);
+  while (path3.endsWith("/"))
+    path3 = path3.slice(0, -1);
+  return path3;
+}
+function isRepoRelative(path3) {
+  if (path3 === "" || path3 === "." || path3.startsWith("/"))
+    return false;
+  return !path3.split("/").includes("..");
+}
+function ownedFolders2(text) {
+  const named = undressed(text).split(OWNS_SEPARATOR2).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: [] } : ownedFolders2(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/codeowners.ts
+import { readFileSync as readFileSync23, statSync as statSync11 } from "fs";
+import { join as join16 } from "path";
+var CODEOWNERS_LOCATIONS = Object.freeze([
+  ".github/CODEOWNERS",
+  "CODEOWNERS",
+  "docs/CODEOWNERS"
+]);
+var HANDLE2 = /^@[^\s@/]+(?:\/[^\s@/]+)?$/u;
+var EMAIL = /^[^\s@]+@[^\s@]+$/u;
+var WORDS = /\s+/u;
+var REGEX_SYNTAX = /[.*+?^${}()|[\]\\/]/gu;
+function isOwner(owner) {
+  return HANDLE2.test(owner) || EMAIL.test(owner);
+}
+function skipReason(pattern, owners) {
+  if (pattern.startsWith("!"))
+    return "negation";
+  if (pattern.includes("[") || pattern.includes("]"))
+    return "character-range";
+  if (pattern.includes("***"))
+    return "triple-asterisk";
+  if (!owners.every(isOwner))
+    return "malformed-owner";
+  return null;
+}
+function parseCodeowners(text) {
+  const rules = [];
+  const skipped2 = [];
+  text.split(/\r?\n/u).forEach((raw, index) => {
+    const trimmed = raw.trim();
+    if (trimmed === "" || trimmed.startsWith("#"))
+      return;
+    const words = trimmed.split(WORDS);
+    const comment = words.findIndex((word) => word.startsWith("#"));
+    const [pattern = "", ...owners] = comment === -1 ? words : words.slice(0, comment);
+    const line = index + 1;
+    const reason = skipReason(pattern, owners);
+    if (reason === null) {
+      rules.push(Object.freeze({ pattern, owners: Object.freeze(owners), line }));
+    } else {
+      skipped2.push(Object.freeze({ line, text: trimmed, reason }));
+    }
+  });
+  return { rules: Object.freeze(rules), skipped: Object.freeze(skipped2) };
+}
+function isFile2(path3) {
+  try {
+    return statSync11(path3).isFile();
+  } catch {
+    return false;
+  }
+}
+function findCodeowners(root) {
+  return CODEOWNERS_LOCATIONS.find((location) => isFile2(join16(root, location))) ?? null;
+}
+function readCodeowners(root) {
+  const path3 = findCodeowners(root);
+  if (path3 === null)
+    return null;
+  let text;
+  try {
+    text = readFileSync23(join16(root, path3), "utf8");
+  } catch (error) {
+    const why = error instanceof Error ? error.message : String(error);
+    throw new Error(`Cannot read ${path3}: ${why}`, { cause: error });
+  }
+  return Object.freeze({ path: path3, ...parseCodeowners(text) });
+}
+function segmentSource(segment) {
+  let source = "";
+  let isEscaped = false;
+  for (const char of segment) {
+    if (isEscaped) {
+      source += char.replace(REGEX_SYNTAX, "\\$&");
+      isEscaped = false;
+    } else if (char === "\\") {
+      isEscaped = true;
+    } else if (char === "*") {
+      source += "[^/]*";
+    } else if (char === "?") {
+      source += "[^/]";
+    } else {
+      source += char.replace(REGEX_SYNTAX, "\\$&");
+    }
+  }
+  return source;
+}
+function patternSegments(pattern) {
+  const split = pattern.split("/");
+  const isSingle = split.length === 1 || split.length === 2 && split[1] === "";
+  const anchored = split[0] === "" ? split.slice(1) : split;
+  const floating = split[0] !== "" && isSingle && split[0] !== "**" ? ["**", ...anchored] : anchored;
+  return floating.length > 1 && floating.at(-1) === "" ? [...floating.slice(0, -1), "**"] : floating;
+}
+function globstarSource(index, last) {
+  if (index === 0) {
+    return index === last ? ".+" : "(?:.+/)?";
+  }
+  return index === last ? "/.*" : "(?:/.+)?";
+}
+function patternRegex(pattern) {
+  if (pattern === "/")
+    return /^$/u;
+  const segments = patternSegments(pattern);
+  const last = segments.length - 1;
+  let source = "";
+  let needsSlash = false;
+  segments.forEach((segment, index) => {
+    if (segment === "**") {
+      source += globstarSource(index, last);
+      needsSlash = index !== 0;
+      return;
+    }
+    const slash = needsSlash ? "/" : "";
+    if (segment === "*") {
+      source += `${slash}[^/]+`;
+    } else {
+      const under = index === last ? "(?:/.*)?" : "";
+      source += `${slash}${segmentSource(segment)}${under}`;
+    }
+    needsSlash = true;
+  });
+  return new RegExp(`^${source}$`, "u");
+}
+function repoRelative(path3) {
+  let relative4 = path3;
+  while (relative4.startsWith("./") || relative4.startsWith("/")) {
+    relative4 = relative4.startsWith("/") ? relative4.slice(1) : relative4.slice(2);
+  }
+  return relative4;
+}
+function matchesPattern(pattern, path3) {
+  return pattern !== "" && patternRegex(pattern).test(repoRelative(path3));
+}
+function lastMatchingRule(file, path3) {
+  const matching = file.rules.filter((rule) => matchesPattern(rule.pattern, path3));
+  return matching.at(-1) ?? null;
+}
+function rulesNaming(file, owner) {
+  const wanted = owner.toLowerCase();
+  return Object.freeze(file.rules.filter((rule) => rule.owners.some((named) => named.toLowerCase() === wanted)));
+}
+
+// src/board/board-owns.ts
+function ownedBoard(issue3) {
+  const { owner, owns } = readBoardBody(issue3.body);
+  return Object.freeze({ number: issue3.number, owner, owns });
+}
+function boardFolders(board, codeowners) {
+  if (codeowners !== null && board.owner !== null) {
+    const folders = rulesNaming(codeowners, board.owner).map((rule) => rule.pattern);
+    return Object.freeze({ board: board.number, source: "codeowners", folders: Object.freeze(folders) });
+  }
+  if (codeowners === null && board.owns.length > 0) {
+    return Object.freeze({ board: board.number, source: "owns", folders: Object.freeze([...board.owns]) });
+  }
+  return Object.freeze({ board: board.number, source: "repository", folders: Object.freeze([]) });
+}
+function repoPath(path3) {
+  let relative4 = path3;
+  while (relative4.startsWith("./") || relative4.startsWith("/")) {
+    relative4 = relative4.startsWith("/") ? relative4.slice(1) : relative4.slice(2);
+  }
+  while (relative4.endsWith("/"))
+    relative4 = relative4.slice(0, -1);
+  return relative4;
+}
+function holds(folder, path3) {
+  return path3 === folder || path3.startsWith(`${folder}/`);
+}
+function byNumber2(boards) {
+  return [...boards].sort((a, b) => a.board - b.board);
+}
+function codeownersOwner(path3, boards, folders, codeowners) {
+  const rule = lastMatchingRule(codeowners, path3);
+  if (rule === null)
+    return null;
+  const ranked = byNumber2(folders.filter((entry) => entry.source === "codeowners"));
+  const ownerOf = new Map(boards.map((board) => [board.number, board.owner?.toLowerCase() ?? null]));
+  for (const named of rule.owners) {
+    const wanted = named.toLowerCase();
+    const board = ranked.find((entry) => ownerOf.get(entry.board) === wanted);
+    if (board !== undefined)
+      return Object.freeze({ board: board.board, source: "codeowners", match: rule.pattern });
+  }
+  return null;
+}
+function ownsOwner(path3, folders) {
+  let best = null;
+  for (const entry of byNumber2(folders.filter((candidate) => candidate.source === "owns"))) {
+    for (const folder of entry.folders) {
+      const depth = folder.split("/").length;
+      if (holds(folder, path3) && (best === null || depth > best.depth)) {
+        best = { board: entry.board, folder, depth };
+      }
+    }
+  }
+  return best === null ? null : Object.freeze({ board: best.board, source: "owns", match: best.folder });
+}
+function owningBoard(path3, boards, codeowners) {
+  const relative4 = repoPath(path3);
+  const folders = boards.map((board) => boardFolders(board, codeowners));
+  const specific = codeowners === null ? ownsOwner(relative4, folders) : codeownersOwner(relative4, boards, folders, codeowners);
+  if (specific !== null)
+    return specific;
+  const [whole] = byNumber2(folders.filter((entry) => entry.source === "repository"));
+  return whole === undefined ? null : Object.freeze({ board: whole.board, source: "repository", match: 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((answer2) => ({ ...answer2, handle }));
+    }
+    const pending = lookUp(gh, handle);
+    answers.set(key, pending);
+    return pending;
+  };
+}
+
+// src/pr/owner-approval.ts
+var APPROVED = "APPROVED";
+var NOT_FOUND2 = "(HTTP 404)";
+var SEVERITY = Object.freeze(["unresolved", "unknown", "waiting"]);
+function messageOf5(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function folded(handle) {
+  return handle === null ? null : handle.toLowerCase();
+}
+function teamMembershipArgs(team, login) {
+  const isTeam = isOwnerHandle(team) && team.includes("/");
+  const isLogin = isOwnerHandle(`@${login}`) && !login.includes("/");
+  if (!isTeam || !isLogin)
+    return null;
+  const [org = "", slug = ""] = team.slice(1).split("/");
+  return ["api", `orgs/${org}/teams/${slug}/memberships/${login}`];
+}
+function failureReason2(result, command) {
+  const written = result.stderr.trim() || result.stdout.trim();
+  return written === "" ? `${command} failed and wrote nothing` : `${command} failed: ${written}`;
+}
+function readMembership(stdout, command) {
+  let parsed;
+  try {
+    parsed = JSON.parse(stdout);
+  } catch {
+    return { state: "unknown", reason: `${command} wrote something that is not JSON` };
+  }
+  const state = typeof parsed === "object" && parsed !== null ? parsed["state"] : undefined;
+  if (state === "active" || state === "pending")
+    return { state };
+  return { state: "unknown", reason: `${command} answered membership state ${JSON.stringify(state) ?? "undefined"}` };
+}
+function createGhTeamMembership(options) {
+  const { gh } = options;
+  return async (team, login) => {
+    const args = teamMembershipArgs(team, login);
+    if (args === null) {
+      return {
+        state: "unknown",
+        reason: `${JSON.stringify(login)} in team ${JSON.stringify(team)} is not a login and a team handle, so nothing was asked`
+      };
+    }
+    const command = `gh ${args.join(" ")}`;
+    const result = await gh(args);
+    if (result.ok)
+      return readMembership(result.stdout, command);
+    return result.stderr.includes(NOT_FOUND2) ? { state: "not-member" } : { state: "unknown", reason: failureReason2(result, command) };
+  };
+}
+function ref3(number) {
+  return `#${String(number)}`;
+}
+function ownerName(owner) {
+  const boards = owner.boards.map(ref3).join(", ");
+  const noun = owner.boards.length === 1 ? "board" : "boards";
+  return owner.handle === null ? `${noun} ${boards}` : `owner ${owner.handle} of ${noun} ${boards}`;
+}
+function gatedOwners(paths, request) {
+  const byNumber3 = new Map(request.boards.map((board) => [board.number, board]));
+  const foreign = new Set;
+  for (const path3 of paths) {
+    const owner = owningBoard(path3, request.boards, request.codeowners);
+    if (owner !== null && owner.board !== request.home)
+      foreign.add(owner.board);
+  }
+  if (foreign.size === 0)
+    return [];
+  const home = byNumber3.get(request.home);
+  if (home === undefined)
+    return null;
+  const groups = new Map;
+  for (const number of [...foreign].sort((a, b) => a - b)) {
+    const handle = byNumber3.get(number)?.owner ?? null;
+    if (folded(handle) === folded(home.owner))
+      continue;
+    const key = folded(handle) ?? `board ${String(number)}`;
+    const group = groups.get(key) ?? { handle, boards: [] };
+    groups.set(key, { handle: group.handle, boards: [...group.boards, number] });
+  }
+  return [...groups.values()].map((group) => Object.freeze({ handle: group.handle, boards: Object.freeze(group.boards) }));
+}
+function blocked2(state, reason, owners) {
+  return Object.freeze({ state, reason, owners: Object.freeze([...owners]) });
+}
+function mostSevere(answers) {
+  const refusals = answers.filter((answer2) => answer2 !== null && answer2.state !== "approved");
+  for (const state of SEVERITY) {
+    const found = refusals.find((refusal3) => refusal3.state === state);
+    if (found !== undefined)
+      return found;
+  }
+  return null;
+}
+function latestReviews(reviews) {
+  const ordered = [...reviews].sort((a, b) => {
+    const difference = Date.parse(a.submittedAt) - Date.parse(b.submittedAt);
+    return Number.isNaN(difference) ? 0 : difference;
+  });
+  return new Map(ordered.map((review) => [review.login.toLowerCase(), review]));
+}
+async function resolutionRefusal(owner, seams) {
+  const name = ownerName(owner);
+  if (owner.handle === null) {
+    return { state: "unresolved", reason: `${name} names no Owner:, so nobody can approve its paths` };
+  }
+  const resolution = await seams.resolveOwner(owner.handle);
+  if (resolution.state === "unresolved") {
+    return { state: "unresolved", reason: `${name} does not resolve to an account or team GitHub knows` };
+  }
+  return resolution.state === "unknown" ? { state: "unknown", reason: `could not resolve ${name}: ${resolution.reason}` } : null;
+}
+async function ownerApproval(owner, latest, membership, pullRequest) {
+  const name = ownerName(owner);
+  if (!owner.handle.includes("/")) {
+    const review = latest.get(owner.handle.slice(1).toLowerCase());
+    return review?.state === APPROVED ? { state: "approved", approvedBy: review.login } : { state: "waiting", reason: `${name} has not approved ${ref3(pullRequest)}` };
+  }
+  const failures = [];
+  for (const review of [...latest.values()].filter((latestReview) => latestReview.state === APPROVED)) {
+    const answer2 = await membership(owner.handle, review.login);
+    if (answer2.state === "active")
+      return { state: "approved", approvedBy: review.login };
+    if (answer2.state === "unknown")
+      failures.push(answer2.reason);
+  }
+  return failures.length === 0 ? { state: "waiting", reason: `no active member of ${name} has approved ${ref3(pullRequest)}` } : { state: "unknown", reason: `could not tell whether ${name} approved ${ref3(pullRequest)}: ${failures.join("; ")}` };
+}
+function isHandled(owner) {
+  return owner.handle !== null;
+}
+async function readOwnerApproval(request, seams) {
+  const pull = ref3(request.pullRequest);
+  let paths;
+  try {
+    paths = await seams.pullRequests.changedFiles(request.pullRequest);
+  } catch (error) {
+    return blocked2("unknown", `could not read the changed files of ${pull}: ${messageOf5(error)}`, []);
+  }
+  const owners = gatedOwners(paths, request);
+  if (owners === null) {
+    return blocked2("unknown", `home board ${ref3(request.home)} is not among the boards read, so its owner is unknown`, []);
+  }
+  if (owners.length === 0)
+    return Object.freeze({ state: "not-gated" });
+  const unresolved = mostSevere(await Promise.all(owners.map((owner) => resolutionRefusal(owner, seams))));
+  if (unresolved !== null)
+    return blocked2(unresolved.state, unresolved.reason, owners);
+  let latest;
+  try {
+    latest = latestReviews(await seams.pullRequests.reviews(request.pullRequest));
+  } catch (error) {
+    return blocked2("unknown", `could not read the reviews of ${pull}: ${messageOf5(error)}`, owners);
+  }
+  const handled = owners.filter(isHandled);
+  const answers = await Promise.all(handled.map((owner) => ownerApproval(owner, latest, seams.membership, request.pullRequest)));
+  const refused = mostSevere(answers);
+  if (refused !== null)
+    return blocked2(refused.state, refused.reason, owners);
+  const given = handled.flatMap((owner, index) => {
+    const answer2 = answers[index];
+    return answer2?.state === "approved" ? [Object.freeze({ ...owner, approvedBy: answer2.approvedBy })] : [];
+  });
+  return Object.freeze({ state: "approved", owners: Object.freeze(given) });
+}
+
+// src/next/owner-gate.ts
+async function homeBoard(options) {
+  const reading2 = readPositionFile(options.root);
+  if (reading2.set)
+    return reading2.position.home.board;
+  const { gh, configured } = options;
+  const board = await resolveDefaultBoard({
+    configured,
+    listBoards: createGhBoardLister({ gh }),
+    search: createGhRoadmapSearch({ gh })
+  });
+  return board.number;
+}
+function gateBoards(listing2, home) {
+  const labelled = openBoards(listing2);
+  const unlabelledHome = labelled.some((board) => board.number === home) ? undefined : listing2.find((issue3) => issue3.number === home && issue3.state === "OPEN");
+  const boards = unlabelledHome === undefined ? labelled : [...labelled, unlabelledHome].sort((a, b) => a.number - b.number);
+  return Object.freeze(boards.map(ownedBoard));
+}
+function nextOwnerGate(options) {
+  const { gh, root, pulls } = options;
+  const listing2 = options.listing ?? createGhBoardListing({ gh });
+  const resolveOwner = createOwnerResolver({ gh });
+  const membership = createGhTeamMembership({ gh });
+  return async (pullRequest) => {
+    const home = await homeBoard(options);
+    const boards = gateBoards(await listing2(), home);
+    return readOwnerApproval({ pullRequest, home, boards, codeowners: readCodeowners(root) }, { pullRequests: pulls, resolveOwner, membership });
+  };
+}
+
 // src/next/sources.ts
 var PREFIX14 = "rafa next";
 var DEFAULT_BASE_BRANCH = "main";
@@ -13681,20 +14416,143 @@ async function cancelledNotices(listing2) {
     return [];
   }
 }
-async function walkEpic(epic, listing2, readings) {
+var plainPick = async (lines, readings) => {
+  const pick = await pickNextRoadmapLine(lines, readings);
+  return { line: pick.line, passed: pick.skipped.length, waiting: [] };
+};
+async function everyBlockerTaken(blocked3, readings) {
+  if (blocked3 === null || blocked3.fault !== null)
+    return null;
+  const held = blocked3.blockers.filter((id2) => blocked3.open.includes(id2) || blocked3.unread.includes(id2));
+  if (held.length === 0)
+    return null;
+  let taken = [];
+  for (const issue3 of held) {
+    const by = await takenBy(issue3, readings);
+    if (by === null)
+      return null;
+    taken = [...taken, Object.freeze({ issue: issue3, taken: Object.freeze(by) })];
+  }
+  return Object.freeze(taken);
+}
+function waitingPick(blocking) {
+  const pick = async (lines, readings, before) => {
+    const next = await pickNextRoadmapLine(lines, readings);
+    const passed2 = before.passed + next.skipped.length;
+    if (next.line === null)
+      return { line: null, passed: passed2, waiting: before.waiting };
+    const blockers = await everyBlockerTaken(await blocking(next.line.issue), readings);
+    if (blockers === null)
+      return { line: next.line, passed: passed2, waiting: before.waiting };
+    const waiting = [...before.waiting, Object.freeze({ line: next.line, blockers })];
+    return pick(lines.slice(lines.indexOf(next.line) + 1), readings, { line: null, passed: passed2 + 1, waiting });
+  };
+  return (lines, readings) => pick(lines, readings, { line: null, passed: 0, waiting: [] });
+}
+async function walkEpic(epic, listing2, readings, picker) {
   const rows = await listing2();
   const read = readEpics({ issues: rows, claims: new Set, today: new Date(0) }).epics.find((candidate) => candidate.number === epic);
   const row = rows.find((issue3) => issue3.number === epic);
   if (read === undefined || row === undefined) {
     throw new Error(`${PREFIX14}: epic #${String(epic)}, the current place, is not on the board listing, so its members cannot be read`);
   }
-  const pick = await pickNextRoadmapLine(epicLines(read, row).lines, readings);
+  const pick = await picker(epicLines(read, row).lines, readings);
   return {
     line: pick.line,
-    passed: pick.skipped.length,
-    dry: pick.line === null ? { number: read.number, title: read.title } : null
+    passed: pick.passed,
+    dry: pick.line === null ? { number: read.number, title: read.title } : null,
+    epic,
+    waiting: pick.waiting
+  };
+}
+function followHopRecord(root) {
+  if (root === undefined)
+    return { record: null, stale: null, position: null, problems: [] };
+  const placed = readPositionFile(root);
+  const position = placed.set ? placed.position : null;
+  const hop = readHopRecord(root);
+  if (!hop.set) {
+    const problems = hop.reason === "absent" ? [] : [`${hop.detail}, so no hop is followed`];
+    return { record: null, stale: null, position, problems };
+  }
+  return position === null || staleAgainst(hop.record, position) ? { record: null, stale: hop.record, position, problems: [] } : { record: hop.record, stale: null, position, problems: [] };
+}
+function awayTargetOf(record) {
+  if (record?.state !== "away" || record.kind !== "blocker")
+    return null;
+  return record.target;
+}
+async function walkTarget(record, target, readings) {
+  const closed = await readings.isClosed(target);
+  const pullRequest = closed ? null : await readings.pullRequestFor(target);
+  const line = closed || pullRequest !== null ? null : Object.freeze({ issue: target, ticked: false, why: "", lineNumber: 0 });
+  return {
+    walk: { line, passed: 0, dry: null, epic: record.targetEpic, waiting: [] },
+    target: Object.freeze({ issue: target, closed, pullRequest })
+  };
+}
+var NOTHING_TAKEN = Object.freeze({
+  branchFor: () => null,
+  pullRequestFor: () => Promise.resolve(null)
+});
+async function boardView(seams) {
+  const listing2 = await seams.listing();
+  return {
+    listing: listing2,
+    rows: new Map(listing2.map((row) => [row.number, row])),
+    defaultBoard: () => Promise.resolve(seams.fallback)
+  };
+}
+async function decideAtHome(line, places, seams) {
+  const blocked3 = await seams.blocking(line.issue);
+  if (blocked3 === null || blocked3.fault !== null)
+    return null;
+  const held = blocked3.blockers.filter((id2) => blocked3.open.includes(id2) || blocked3.unread.includes(id2));
+  const view = await boardView(seams);
+  let last = null;
+  for (const blocker of held) {
+    last = await decideHop({ blocked: line.issue, blocker, position: places, view, taken: seams.readings });
+    if (last.kind !== "wait")
+      return last;
+  }
+  return last;
+}
+async function decideAway(record, target, seams) {
+  if (record.blocked === null || await seams.blocking(target) === null)
+    return null;
+  return decideHop({
+    blocked: record.blocked,
+    blocker: target,
+    position: { current: record.from, home: record.home },
+    view: await boardView(seams),
+    taken: NOTHING_TAKEN
+  });
+}
+function placesOf(walk, roadmap, position) {
+  const current = { board: roadmap, epic: walk.epic };
+  const away = position !== null && !samePlace(position.current, position.home);
+  return {
+    current,
+    home: away ? position.home : current
   };
 }
+async function decisionFor(walk, followed, seams) {
+  if (walk.line === null)
+    return null;
+  const target = awayTargetOf(followed.record);
+  if (followed.record !== null && target !== null)
+    return decideAway(followed.record, target, seams);
+  return decideAtHome(walk.line, placesOf(walk, seams.roadmap, followed.position), seams);
+}
+async function readHopAnswer(walk, followed, seams) {
+  try {
+    const decision = await decisionFor(walk, followed, seams);
+    const nextEpic = walk.dry === null ? null : await nextNowEpic({ after: walk.dry.number, board: seams.roadmap, listing: await seams.listing(), readings: seams.readings });
+    return { decision, nextEpic, problems: [] };
+  } catch (error) {
+    return { decision: null, nextEpic: null, problems: [`the hop could not be read, so none is proposed: ${messageOf(error)}`] };
+  }
+}
 function ghNextBoard(options) {
   const { gh, git, configured, remote, root } = options;
   const listed = options.listing ?? createGhBoardListing({ gh });
@@ -13704,6 +14562,10 @@ function ghNextBoard(options) {
     return listed();
   });
   const issues = memoiseIssues2(createGhSpecIssueReader({ gh }));
+  const board = {
+    blocking: async (issue3) => readBlockedLine(await issues(issue3), blockerStatesOf(issues)),
+    isReady: async (issue3) => hasSpecReadyLabel((await issues(issue3)).labels)
+  };
   return Object.freeze({
     next: async () => {
       const { number: fallback } = await resolveDefaultBoard({
@@ -13720,27 +14582,47 @@ function ghNextBoard(options) {
         branches,
         pullRequests: createGhOpenPullRequests({ gh })
       });
-      const walk = epic === null ? await walkBoard(roadmap, { issues, readings, listing: listing2 }) : await walkEpic(epic, listing2, readings);
+      const followed = options.roadmap === true ? followHopRecord(root) : null;
+      const picker = followed === null ? plainPick : waitingPick(board.blocking);
+      const record = followed?.record ?? null;
+      const target = awayTargetOf(record);
+      const away = record !== null && target !== null ? await walkTarget(record, target, readings) : null;
+      const walk = away?.walk ?? (epic === null ? await walkBoard(roadmap, { issues, readings, listing: listing2 }, picker) : await walkEpic(epic, listing2, readings, picker));
+      const answer2 = followed === null ? null : await readHopAnswer(walk, followed, { blocking: board.blocking, readings, listing: listing2, fallback, roadmap });
       const cancelled = options.noticeCancelled === true && asked ? await cancelledNotices(listing2) : [];
       return {
         roadmap,
         line: walk.line,
         passed: walk.passed,
-        problems: [...current?.notices ?? [], ...cancelled, ...branches.problems],
-        ...walk.dry === null ? {} : { dryEpic: walk.dry }
+        problems: [...current?.notices ?? [], ...cancelled, ...branches.problems, ...followed?.problems ?? [], ...answer2?.problems ?? []],
+        ...walk.dry === null ? {} : { dryEpic: walk.dry },
+        ...followed === null || answer2 === null ? {} : {
+          hop: Object.freeze({
+            record: followed.record,
+            stale: followed.stale,
+            position: followed.position,
+            target: away?.target ?? null,
+            waiting: walk.waiting,
+            decision: answer2.decision,
+            nextEpic: answer2.nextEpic
+          })
+        }
       };
     },
-    blocking: async (issue3) => readBlockedLine(await issues(issue3), blockerStatesOf(issues)),
-    isReady: async (issue3) => hasSpecReadyLabel((await issues(issue3)).labels)
+    blocking: board.blocking,
+    isReady: board.isReady
   });
 }
-async function walkBoard(roadmap, seams) {
+async function walkBoard(roadmap, seams, picker) {
   const read = await seams.issues(roadmap);
-  const { descent, pick, dry } = await pickDescendedLine(parseRoadmapBody(read.body), seams);
+  const descent = await descendRoadmap(parseRoadmapBody(read.body), seams);
+  const pick = await picker(descent.lines, seams.readings);
   return {
     line: pick.line,
-    passed: descent.passed.length + pick.skipped.length,
-    dry: dry && descent.epic !== null ? { number: descent.epic.number, title: descent.epic.title } : null
+    passed: descent.passed.length + pick.passed,
+    dry: descent.epic !== null && pick.line === null ? { number: descent.epic.number, title: descent.epic.title } : null,
+    epic: descent.epic?.number ?? null,
+    waiting: pick.waiting
   };
 }
 function nextProject(context) {
@@ -13761,7 +14643,7 @@ function nextConfig(project, warn) {
 `));
   }
 }
-function openNextSources(context, seams = DEFAULT_NEXT_SOURCE_SEAMS) {
+function openNextSources(context, seams = DEFAULT_NEXT_SOURCE_SEAMS, options = {}) {
   const project = nextProject(context);
   const config = nextConfig(project, (message) => {
     context.output.warn(message);
@@ -13774,13 +14656,23 @@ function openNextSources(context, seams = DEFAULT_NEXT_SOURCE_SEAMS) {
   const git = (seams.openGit ?? createGitRunner)(project.root);
   const gh = (seams.openGh ?? ((root) => createGhRunner({ cwd: root })))(project.root);
   const loop = resolveLoopSeams({ isAlive: seams.isAlive });
-  const board = () => ghNextBoard({ gh, git, configured: config.roadmapIssue, root: project.root, noticeCancelled: true });
+  const roadmap = options.roadmap === true;
+  const board = () => ghNextBoard({
+    gh,
+    git,
+    configured: config.roadmapIssue,
+    root: project.root,
+    noticeCancelled: true,
+    ...roadmap ? { roadmap } : {}
+  });
+  const pulls = (seams.pullRequests ?? ghPullRequestsIn)(project.root);
   const held = {
     base: config.prBase ?? DEFAULT_BASE_BRANCH,
     plans: plansDirAt(project.root, config.planDir),
     runs: () => readRecords(project.root, loop),
     git,
-    pulls: (seams.pullRequests ?? ghPullRequestsIn)(project.root)
+    pulls,
+    ...roadmap ? { roadmap: Object.freeze({ ownerApproval: nextOwnerGate({ gh, root: project.root, pulls, configured: config.roadmapIssue }) }) } : {}
   };
   return Object.freeze({
     ...held,
@@ -13880,7 +14772,7 @@ function hasRun(records, stub) {
 }
 function hasBranch(refs, stub) {
   const branch = `${BRANCH_PREFIX2}${stub}`;
-  return refs.some((ref3) => ref3 === branch || ref3.endsWith(`/${branch}`));
+  return refs.some((ref4) => ref4 === branch || ref4.endsWith(`/${branch}`));
 }
 function openWorld(sources) {
   let problems = [];
@@ -13931,6 +14823,221 @@ function branchLabel(world) {
   return branch === "" ? "this checkout" : `\`${branch}\``;
 }
 
+// src/next/hop-rows.ts
+function oneLine2(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+function ref4(issue3) {
+  return `#${String(issue3)}`;
+}
+function placeText2(place) {
+  return place.epic === null ? `board ${ref4(place.board)}` : `epic ${ref4(place.epic)} on board ${ref4(place.board)}`;
+}
+function dryHopSentence(dry, next) {
+  return `hop from epic ${ref4(dry.number)}: it ran dry, next \`now\` epic ${ref4(next.number)} on board ${ref4(next.board)}`;
+}
+async function hopView(world) {
+  if (!onBase(world))
+    return null;
+  const reading2 = await world.roadmap();
+  return reading2.hop === undefined ? null : { reading: reading2, hop: reading2.hop };
+}
+function awayRecord(hop) {
+  return hop.record?.state === "away" ? hop.record : null;
+}
+function homeOf(view) {
+  return view.hop.position?.home ?? { board: view.reading.roadmap, epic: null };
+}
+function homeAnswer(id2, reading2, step, issue3) {
+  return {
+    id: id2,
+    action: "home",
+    reading: reading2,
+    proposal: `go back home to ${placeText2(step.home)}`,
+    ...issue3 === null ? {} : { issue: issue3 },
+    ...step.pullRequest === null ? {} : { pullRequest: step.pullRequest },
+    hop: Object.freeze(step)
+  };
+}
+async function readGate(roadmap, pullRequest) {
+  try {
+    return await roadmap.ownerApproval(pullRequest);
+  } catch (error) {
+    return {
+      state: "unknown",
+      reason: `could not read the owner gate of ${ref4(pullRequest)}: ${oneLine2(messageOf(error))}`,
+      owners: []
+    };
+  }
+}
+async function waitingIssue(world, pullRequest) {
+  let hop;
+  try {
+    hop = (await world.roadmap()).hop;
+  } catch {
+    return null;
+  }
+  const record = hop?.record ?? null;
+  if (record?.target === null || record === null)
+    return null;
+  const named = record.pullRequest === pullRequest || hop?.target?.pullRequest === pullRequest;
+  return named ? record.target : null;
+}
+async function readPrOwnerReview(world) {
+  const { roadmap } = world.sources;
+  if (roadmap === undefined)
+    return null;
+  const open = await world.openPull();
+  if (open === null || open.mergeable !== "mergeable")
+    return null;
+  if (open.verdict !== "green" && open.verdict !== "none")
+    return null;
+  const pullRequest = open.summary.number;
+  const gate = await readGate(roadmap, pullRequest);
+  if (gate.state === "not-gated" || gate.state === "approved")
+    return null;
+  const issue3 = await waitingIssue(world, pullRequest);
+  return {
+    id: "pr-owner-review",
+    action: "none",
+    reading: `waiting on ${ref4(issue3 ?? pullRequest)} (owner review)`,
+    proposal: `leave ${ref4(pullRequest)} to its owner's review, which rafa does not merge past: ${oneLine2(gate.reason)}`,
+    pullRequest,
+    ...issue3 === null ? {} : { issue: issue3 }
+  };
+}
+function dryEnded(view, record) {
+  const { dryEpic, line } = view.reading;
+  if (line !== null || dryEpic === undefined)
+    return null;
+  const step = { action: "home", home: record.home, closing: "halted", pullRequest: null };
+  const reading2 = `epic ${ref4(dryEpic.number)}, where the dry hop went, has no line left, and a second hop would leave home behind`;
+  return homeAnswer("away-ended", reading2, step, null);
+}
+async function notReadyEnded(world, record, target) {
+  const picked = await world.picked();
+  if (picked === null || picked.line.issue !== target || picked.ready || picked.blocked !== null)
+    return null;
+  const step = { action: "home", home: record.home, closing: "halted", pullRequest: null };
+  const reading2 = `${ref4(target)}, the hop's target in epic ${ref4(record.targetEpic)}, carries no \`${SPEC_READY_LABEL}\`, so its spec is refused as not ready`;
+  return homeAnswer("away-ended", reading2, step, target);
+}
+async function readAwayEnded(world) {
+  const view = await hopView(world);
+  const record = view === null ? null : awayRecord(view.hop);
+  if (view === null || record === null)
+    return null;
+  if (record.kind === "dry")
+    return dryEnded(view, record);
+  const target = view.hop.target;
+  if (target === null)
+    return null;
+  const where = `${ref4(target.issue)}, the hop's target in epic ${ref4(record.targetEpic)}`;
+  if (target.closed) {
+    const step = { action: "home", home: record.home, closing: "merged", pullRequest: null };
+    return homeAnswer("away-ended", `${where}, is closed`, step, target.issue);
+  }
+  if (target.pullRequest !== null) {
+    const step = { action: "home", home: record.home, closing: "waiting", pullRequest: target.pullRequest };
+    return homeAnswer("away-ended", `${where}, has pull request ${ref4(target.pullRequest)} open`, step, target.issue);
+  }
+  return notReadyEnded(world, record, target.issue);
+}
+function decisionOf(view, kind) {
+  const decision = view?.hop.decision ?? null;
+  return decision?.kind === kind ? decision : null;
+}
+async function readHopHalt(world) {
+  const view = await hopView(world);
+  const halt2 = decisionOf(view, "halt");
+  if (view === null || halt2 === null)
+    return null;
+  const home = view.hop.record?.home ?? view.hop.position?.home ?? halt2.from;
+  const step = { action: "home", home, closing: "halted", pullRequest: null };
+  return homeAnswer("hop-halt", hopDecisionSentence(halt2), step, halt2.chain.blocked);
+}
+async function readHopBlocked(world) {
+  const view = await hopView(world);
+  const move = decisionOf(view, "hop");
+  if (view === null || move === null || awayRecord(view.hop) !== null)
+    return null;
+  const opening = {
+    kind: "blocker",
+    home: homeOf(view),
+    from: move.from,
+    blocked: move.blocked,
+    target: move.blocker,
+    targetEpic: move.epic,
+    targetBoard: move.board
+  };
+  return {
+    id: "hop-blocked",
+    action: "hop",
+    reading: hopDecisionSentence(move),
+    proposal: `hop to ${placeText2(move.to)} and work ${ref4(move.blocker)}, keeping home`,
+    issue: move.blocker,
+    hop: Object.freeze({ action: "hop", opening: Object.freeze(opening) })
+  };
+}
+function dryPlaces(view, dry) {
+  const from = { board: view.reading.roadmap, epic: dry.number };
+  const { position } = view.hop;
+  return {
+    from,
+    home: position === null || samePlace(position.current, position.home) ? from : position.home
+  };
+}
+async function readHopDry(world) {
+  const view = await hopView(world);
+  if (view === null || awayRecord(view.hop) !== null)
+    return null;
+  const { dryEpic, line } = view.reading;
+  const next = view.hop.nextEpic;
+  if (line !== null || dryEpic === undefined || next === null)
+    return null;
+  const { from, home } = dryPlaces(view, dryEpic);
+  const to = { board: next.board, epic: next.number };
+  if (!oneHopAllows(from, to, home))
+    return null;
+  const opening = {
+    kind: "dry",
+    home: homeOf(view),
+    from,
+    blocked: null,
+    target: null,
+    targetEpic: next.number,
+    targetBoard: next.board
+  };
+  return {
+    id: "hop-dry",
+    action: "hop",
+    reading: dryHopSentence(dryEpic, next),
+    proposal: `hop to ${placeText2(to)}, keeping home`,
+    hop: Object.freeze({ action: "hop", opening: Object.freeze(opening) })
+  };
+}
+function loopEnding(record, target) {
+  const home = (closing, pullRequest) => ({ action: "home", home: record.home, closing, pullRequest });
+  const epic = ref4(record.targetEpic);
+  if (record.kind === "dry" || record.target === null) {
+    return { reading: `the loop has run in epic ${epic}, where the dry hop went`, step: home("halted", null) };
+  }
+  const where = `${ref4(record.target)}, the hop's target in epic ${epic},`;
+  if (target?.closed === true)
+    return { reading: `${where} is closed`, step: home("merged", null) };
+  if (target !== null && target.pullRequest !== null) {
+    return { reading: `${where} has pull request ${ref4(target.pullRequest)} open`, step: home("waiting", target.pullRequest) };
+  }
+  return { reading: `${where} has no pull request open after the loop`, step: home("halted", null) };
+}
+function homeAfterLoop(reading2) {
+  const record = reading2.hop === undefined ? null : awayRecord(reading2.hop);
+  if (record === null)
+    return null;
+  const ending = loopEnding(record, reading2.hop?.target ?? null);
+  return homeAnswer("away-ended", ending.reading, ending.step, record.target);
+}
+
 // src/next/state.ts
 var PREFIX15 = "rafa next";
 var MAX_NAMED_FILES = 5;
@@ -13943,7 +15050,7 @@ function nameFiles(paths) {
   const hidden = paths.length - shown.length;
   return hidden > 0 ? `${shown.join(", ")} and ${hidden} more` : shown.join(", ");
 }
-function oneLine2(text) {
+function oneLine3(text) {
   return text.replace(/\s+/g, " ").trim();
 }
 function readTreeModified(world) {
@@ -13965,7 +15072,7 @@ async function readPullsUnusable(world) {
     return {
       id: "pulls-unusable",
       action: "none",
-      reading: `the \`${world.sources.pulls.kind}\` pull request provider could not be asked: ${oneLine2(messageOf(error))}`,
+      reading: `the \`${world.sources.pulls.kind}\` pull request provider could not be asked: ${oneLine3(messageOf(error))}`,
       proposal: "run `rafa doctor` to see what the provider needs, then read the state again"
     };
   }
@@ -14182,6 +15289,14 @@ var ROWS = Object.freeze([
   { id: "nothing-left", read: readNothingLeft }
 ]);
 var NEXT_STATES = Object.freeze(ROWS.map((row) => row.id));
+var HOP_ROWS_AHEAD_OF = Object.freeze({
+  "pr-no-checks": [{ id: "pr-owner-review", read: readPrOwnerReview, pulls: true }],
+  "plan-unstarted": [{ id: "away-ended", read: readAwayEnded }],
+  "issue-blocked": [{ id: "hop-halt", read: readHopHalt }, { id: "hop-blocked", read: readHopBlocked }],
+  "nothing-left": [{ id: "hop-dry", read: readHopDry }]
+});
+var ROADMAP_ROWS = Object.freeze(ROWS.flatMap((row) => [...HOP_ROWS_AHEAD_OF[row.id] ?? [], row]));
+var NEXT_ROADMAP_STATES = Object.freeze(ROADMAP_ROWS.map((row) => row.id));
 function answer2(row, problems) {
   return Object.freeze({
     id: row.id,
@@ -14192,15 +15307,17 @@ function answer2(row, problems) {
     issue: row.issue ?? null,
     planStub: row.planStub ?? null,
     planPath: row.planPath ?? null,
-    problems: Object.freeze([...problems])
+    problems: Object.freeze([...problems]),
+    ...row.hop === undefined ? {} : { hop: row.hop }
   });
 }
 async function readNextState(sources) {
   const world = openWorld(sources);
+  const rows = sources.roadmap === undefined ? ROWS : ROADMAP_ROWS;
   const modified = readTreeModified(world);
   if (modified !== null)
     return answer2(modified, world.problems());
-  for (const row of ROWS) {
+  for (const row of rows) {
     if (row.pulls === true) {
       const unusable = await readPullsUnusable(world);
       if (unusable !== null)
@@ -14212,6 +15329,13 @@ async function readNextState(sources) {
   }
   throw new Error(`${PREFIX15}: no row of the table answered, and the last row answers for every reading`);
 }
+async function readHomeAfterLoop(sources) {
+  if (sources.roadmap === undefined)
+    return null;
+  const reading2 = await sources.board.next();
+  const found = homeAfterLoop(reading2);
+  return found === null ? null : answer2(found, reading2.problems);
+}
 
 // src/next/hint.ts
 var HINT_FLAG = "hint";
@@ -14290,8 +15414,108 @@ async function nextStepHint(context, seams = DEFAULT_HINT_SEAMS) {
   }
 }
 
+// src/next/hop-action.ts
+import { rmSync as rmSync2 } from "fs";
+var NO_REHOME = "--no-rehome";
+function hopLogLine(opening) {
+  const { from, blocked: blocked3, target, targetEpic, targetBoard } = opening;
+  if (opening.kind === "dry" || blocked3 === null || target === null) {
+    return dryHopSentence({ number: from.epic ?? from.board }, { number: targetEpic, board: targetBoard });
+  }
+  return hopMoveSentence({ from, blocked: blocked3, blocker: target, epic: targetEpic });
+}
+function homeLogLine(home) {
+  return `back home: ${placeText2(home)}`;
+}
+function openedRecord(opening, now) {
+  return {
+    ...opening,
+    state: "away",
+    pullRequest: null,
+    startedAt: now.toISOString()
+  };
+}
+function writeRecord(root, record) {
+  try {
+    writeHopRecord(root, record);
+  } catch (error) {
+    throw new CommandExit(1, `\u274C Could not write ${hopFilePath(root)}: ${messageOf(error)}`);
+  }
+}
+function restoreRecord(root, before) {
+  if (before.set)
+    writeHopRecord(root, before.record);
+  else
+    rmSync2(hopFilePath(root), { force: true });
+}
+async function runHop(world, step) {
+  const { opening } = step;
+  const before = readHopRecord(world.root);
+  const record = openedRecord(opening, world.now());
+  writeRecord(world.root, record);
+  try {
+    await world.switchTo([String(opening.targetEpic), NO_REHOME]);
+  } catch (error) {
+    restoreRecord(world.root, before);
+    throw error;
+  }
+  world.info(hopLogLine(opening));
+  return record;
+}
+function writePosition(root, position) {
+  try {
+    writePositionFile(root, position);
+  } catch (error) {
+    throw new CommandExit(1, `\u274C Could not write ${positionFilePath(root)}: ${messageOf(error)}`);
+  }
+}
+function movedHome(world, step) {
+  const reading2 = readPositionFile(world.root);
+  if (reading2.set) {
+    if (samePlace(reading2.position.current, reading2.position.home))
+      return { now: reading2.position, written: false };
+    return { now: goHome(reading2.position), written: true };
+  }
+  if (reading2.reason === "absent")
+    return { now: null, written: false };
+  world.warn(`${reading2.detail}, so it is written afresh at home`);
+  return { now: positionAt(step.home), written: true };
+}
+function awayToClose(world, position) {
+  const reading2 = readHopRecord(world.root);
+  if (!reading2.set) {
+    if (reading2.reason !== "absent")
+      world.warn(`${reading2.detail}, so no hop record is closed`);
+    return null;
+  }
+  const { record } = reading2;
+  if (record.state !== "away" || position === null)
+    return null;
+  return staleAgainst(record, position) ? null : record;
+}
+function runHome(world, step) {
+  const moved = movedHome(world, step);
+  if (moved.written && moved.now !== null)
+    writePosition(world.root, moved.now);
+  const away = awayToClose(world, moved.now);
+  const closed = away === null ? null : { ...away, state: step.closing, pullRequest: step.pullRequest ?? away.pullRequest };
+  if (closed !== null)
+    writeRecord(world.root, closed);
+  const line = homeLogLine(moved.now?.home ?? step.home);
+  world.info(line);
+  return Object.freeze({
+    position: moved.written ? moved.now : null,
+    record: closed,
+    line
+  });
+}
+
 // src/next/actions.ts
 var PREFIX16 = "rafa next";
+var NEXT_IN_PROCESS_ACTIONS = Object.freeze(["sync", "hop", "home"]);
+var SWITCH_COMMAND = Object.freeze({ subject: "switch", action: "switch" });
+var ROADMAP_WORD = "--roadmap";
+var ROADMAP_PASSED_ACTIONS = new Set(["plan", "start", "resume"]);
 function needed(state, value, what) {
   if (value === null) {
     throw new Error(`${PREFIX16}: state "${state.id}" proposes "${state.action}" and names no ${what}`);
@@ -14322,14 +15546,15 @@ var NEXT_COMMAND_ACTIONS = Object.freeze(Object.keys(ACTION_COMMANDS));
 function runsCommand(action) {
   return NEXT_COMMAND_ACTIONS.includes(action);
 }
-function actionInvocation(state) {
+function actionInvocation(state, options = {}) {
   if (!runsCommand(state.action))
     return null;
   const spec = ACTION_COMMANDS[state.action];
+  const passes = options.roadmap === true && ROADMAP_PASSED_ACTIONS.has(state.action);
   return Object.freeze({
     action: state.action,
     command: commandSpelling(spec),
-    argv: Object.freeze(spec.argv(state))
+    argv: Object.freeze(passes ? [...spec.argv(state), ROADMAP_WORD] : spec.argv(state))
   });
 }
 function actionContext(caller, command, argv) {
@@ -14341,17 +15566,52 @@ function actionContext(caller, command, argv) {
     argv: Object.freeze([...argv])
   });
 }
-async function runAction(caller, state) {
-  const invocation = actionInvocation(state);
+async function runRegistered(caller, name, argv, step) {
+  const command = caller.registry.find(name.subject, name.action);
+  if (command === undefined) {
+    throw new CommandExit(1, `\u274C ${PREFIX16}: the "${step}" step runs "rafa ${commandSpelling(name)}", which is registered by nothing`);
+  }
+  await command.run(actionContext(caller, command, argv));
+}
+function hopWorld(caller, state) {
+  if (caller.project === null) {
+    throw new Error(`${PREFIX16}: the action "${state.action}" of state "${state.id}" runs inside a project, and was handed none`);
+  }
+  return {
+    root: caller.project.root,
+    switchTo: (argv) => runRegistered(caller, SWITCH_COMMAND, argv, state.action),
+    info: (line) => {
+      caller.output.info(line);
+    },
+    warn: (line) => {
+      caller.output.warn(line);
+    },
+    now: () => new Date
+  };
+}
+function noStep(state) {
+  return new Error(`${PREFIX16}: state "${state.id}" proposes "${state.action}" and carries no ${state.action} step`);
+}
+async function runHopStep(caller, state) {
+  const step = state.hop;
+  if (step?.action !== state.action)
+    throw noStep(state);
+  if (step.action === "hop") {
+    await runHop(hopWorld(caller, state), step);
+    return;
+  }
+  runHome(hopWorld(caller, state), step);
+}
+async function runAction(caller, state, options = {}) {
+  if (state.action === "hop" || state.action === "home") {
+    await runHopStep(caller, state);
+    return;
+  }
+  const invocation = actionInvocation(state, options);
   if (invocation === null) {
     throw new Error(`${PREFIX16}: the action "${state.action}" of state "${state.id}" runs no registered command`);
   }
-  const spec = ACTION_COMMANDS[invocation.action];
-  const command = caller.registry.find(spec.subject, spec.action);
-  if (command === undefined) {
-    throw new CommandExit(1, `\u274C ${PREFIX16}: the "${invocation.action}" step runs "rafa ${invocation.command}", which is registered by nothing`);
-  }
-  await command.run(actionContext(caller, command, invocation.argv));
+  await runRegistered(caller, ACTION_COMMANDS[invocation.action], invocation.argv, invocation.action);
 }
 
 // src/next/ending.ts
@@ -14587,8 +15847,8 @@ import { fileURLToPath as fileURLToPath2 } from "url";
 import { homedir as homedir3 } from "os";
 
 // src/notices/notices.ts
-import { mkdirSync as mkdirSync9, readFileSync as readFileSync24, writeFileSync as writeFileSync11 } from "fs";
-import { dirname as dirname10, join as join17 } from "path";
+import { mkdirSync as mkdirSync8, readFileSync as readFileSync24, writeFileSync as writeFileSync10 } from "fs";
+import { dirname as dirname9, join as join17 } from "path";
 var NOTICE_IDS = Object.freeze(["alpha", "danger"]);
 var FEEDBACK_URL = "https://github.com/open-tomato/rafa/issues/new/choose";
 var ROADMAP_URL = "https://github.com/open-tomato/rafa/issues/31";
@@ -14620,8 +15880,8 @@ function readDismissed(home) {
 function writeDismissed(home, ids) {
   const all = NOTICE_IDS.filter((id2) => ids.includes(id2) || readDismissed(home).includes(id2));
   const path3 = noticesPath(home);
-  mkdirSync9(dirname10(path3), { recursive: true });
-  writeFileSync11(path3, `${JSON.stringify({ dismissed: all }, null, 2)}
+  mkdirSync8(dirname9(path3), { recursive: true });
+  writeFileSync10(path3, `${JSON.stringify({ dismissed: all }, null, 2)}
 `);
 }
 function pendingNotices(dismissed) {
@@ -14698,8 +15958,8 @@ async function requireNoticesAnswered() {
 // src/start/branch.ts
 var INDENT4 = "   ";
 var DEFAULT_BRANCH_SEAMS = Object.freeze({});
-function refExists(git, ref3) {
-  return git(["show-ref", "--verify", "--quiet", ref3]).ok;
+function refExists(git, ref5) {
+  return git(["show-ref", "--verify", "--quiet", ref5]).ok;
 }
 function terminalReading(seams) {
   return seams.isTerminal ?? (() => process.stdin.isTTY === true);
@@ -14802,7 +16062,7 @@ function markBudgetExit(options) {
 }
 
 // src/utils/commit.ts
-import { spawnSync as spawnSync3 } from "child_process";
+import { spawnSync as spawnSync2 } from "child_process";
 var DEFAULT_COMMIT_TYPE = "chore";
 var TEST_NOUN_WINDOW = 40;
 var FIX_VERBS = ["fix", "repair", "correct", "resolve"];
@@ -15014,7 +16274,7 @@ function failed2(step, subject, result) {
 }
 function spawnGit(cwd) {
   return (args) => {
-    const result = spawnSync3("git", args, {
+    const result = spawnSync2("git", args, {
       cwd,
       encoding: "utf8",
       maxBuffer: MAX_GIT_BUFFER
@@ -15079,24 +16339,24 @@ function indentBlock(text) {
 }
 function holdsOf(reading2) {
   const { report: report2, issues } = reading2;
-  const holds = [];
+  const holds2 = [];
   if (report2.status === "blocked")
-    holds.push("status: blocked");
+    holds2.push("status: blocked");
   for (const blocker of report2.blockers) {
-    holds.push(`blocker: ${blocker.what ?? "an entry with no usable what"}`);
+    holds2.push(`blocker: ${blocker.what ?? "an entry with no usable what"}`);
   }
   for (const issue3 of issues) {
     if (!DROPPED_BLOCKER_FIELD.test(issue3.field))
       continue;
-    holds.push(`blocker: ${issue3.field}, an entry the report parser dropped`);
+    holds2.push(`blocker: ${issue3.field}, an entry the report parser dropped`);
   }
-  return holds;
+  return holds2;
 }
 function leftNothingBehind(attempt2, reported) {
   return !reported && attempt2.outcome === "nothing-to-commit";
 }
-function holdsAfterCommit(holds, silent) {
-  return silent ? [...holds, NO_REPORT_HOLD, NO_COMMIT_HOLD] : holds;
+function holdsAfterCommit(holds2, silent) {
+  return silent ? [...holds2, NO_REPORT_HOLD, NO_COMMIT_HOLD] : holds2;
 }
 function commitFinishedTask(options) {
   const { taskInfo, trackerPath } = options;
@@ -15117,8 +16377,8 @@ function commitFinishedTask(options) {
     return attempt2;
   }
   const silent = leftNothingBehind(attempt2, reported);
-  const holds = holdsAfterCommit(reportHolds, silent);
-  const held = holds.length > 0;
+  const holds2 = holdsAfterCommit(reportHolds, silent);
+  const held = holds2.length > 0;
   const marked = silent && writeTrackerBlocker(trackerPath, taskInfo.lineNum, NOTHING_REPORTED_OR_COMMITTED);
   if (!marked) {
     updateTrackerLine(trackerPath, taskInfo.lineNum, held ? "blocked" : "done");
@@ -15127,7 +16387,7 @@ function commitFinishedTask(options) {
     out.error(silent ? `
 \u26D4 Task held: its session left neither a report nor a commit: ${taskText}` : `
 \u26D4 Task blocked by its own report: ${taskText}`);
-    for (const hold of holds)
+    for (const hold of holds2)
       out.error(indentBlock(hold));
   } else {
     out.info(`\u2705 Task done: ${taskText}`);
@@ -15149,17 +16409,17 @@ function finishCleanExit(options) {
   const reported = reading2.present;
   const reportHolds = reported ? holdsOf(reading2) : [];
   const attempt2 = commitFinishedTask({ ...task, holds: reportHolds, reported });
-  const holds = holdsAfterCommit(reportHolds, leftNothingBehind(attempt2, reported));
-  const blocked2 = attempt2.outcome === "failed" || holds.length > 0;
+  const holds2 = holdsAfterCommit(reportHolds, leftNothingBehind(attempt2, reported));
+  const blocked3 = attempt2.outcome === "failed" || holds2.length > 0;
   return {
     attempt: attempt2,
-    holds,
-    outcome: blocked2 ? "blocked" : "done"
+    holds: holds2,
+    outcome: blocked3 ? "blocked" : "done"
   };
 }
 
 // src/start/dispatch.ts
-import { randomUUID as randomUUID8 } from "crypto";
+import { randomUUID as randomUUID7 } from "crypto";
 
 // src/report/lessons.ts
 import { createHash as createHash3 } from "crypto";
@@ -15567,7 +16827,7 @@ function reportLessons(record, context, now) {
 }
 
 // src/effort/store/absences.ts
-import { randomUUID as randomUUID5 } from "crypto";
+import { randomUUID as randomUUID4 } from "crypto";
 import { existsSync as existsSync20 } from "fs";
 var ABSENCE_REASONS = {
   "no-block": true,
@@ -15579,9 +16839,10 @@ var INSERT_ABSENCE = `
   INSERT INTO report_absences (
     id, session_id, plan_stub, task_line,
     reason, detail, block_body,
-    outcome, collected_at
+    outcome, collected_at,
+    ${STAMPED_COLUMNS}
   )
-  VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+  VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ${stampedValues("report_absences")})
   ON CONFLICT (session_id) DO NOTHING
 `;
 function refusedWrite7(reason) {
@@ -15615,7 +16876,7 @@ function writeReportAbsence(repoRoot, write, seams = {}) {
   const { sessionId, planStub: planStub2, taskLine } = write.dispatch;
   const { reason, text, block } = write.absence;
   const collectedAt = (seams.now ?? (() => new Date))().toISOString();
-  const id2 = (seams.newId ?? randomUUID5)();
+  const id2 = (seams.newId ?? randomUUID4)();
   const values = [
     id2,
     sessionId,
@@ -15632,7 +16893,7 @@ function writeReportAbsence(repoRoot, write, seams = {}) {
 }
 
 // src/effort/store/triage.ts
-import { randomUUID as randomUUID6 } from "crypto";
+import { randomUUID as randomUUID5 } from "crypto";
 
 // src/triage/machine-fault.ts
 var BUILD_FAILURE = /\b(?:abort(?:ed|s)?|broke|broken|crash(?:ed|es)?|error|errors|fail(?:ed|ing|s|ure|ures)?|unusable)\b/iu;
@@ -15714,9 +16975,10 @@ var BLOCKERS = {
     INSERT INTO blockers (
       id, session_id, plan_stub, task_line,
       what, artifact,
-      outcome, collected_at
+      outcome, collected_at,
+      ${STAMPED_COLUMNS}
     )
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ${stampedValues("blockers")})
     ON CONFLICT (session_id, what, ifnull(artifact, '')) DO NOTHING
   `,
   values: ({ what, artifact }) => [what, artifact]
@@ -15731,9 +16993,10 @@ var OUT_OF_SCOPE_BUGS = {
     INSERT INTO out_of_scope_bugs (
       id, session_id, plan_stub, task_line,
       what, artifact, security, scope,
-      outcome, collected_at
+      outcome, collected_at,
+      ${STAMPED_COLUMNS}
     )
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ${stampedValues("out_of_scope_bugs")})
     ON CONFLICT (session_id, what, ifnull(artifact, ''), ifnull(security, -1)) DO NOTHING
   `,
   values: (entry) => [
@@ -15797,7 +17060,7 @@ function writeTriage(repoRoot, write, seams = {}) {
   const blockers = checkList(BLOCKERS, write.blockers);
   const bugs = checkList(OUT_OF_SCOPE_BUGS, write.outOfScopeBugs);
   const collectedAt = (seams.now ?? (() => new Date))().toISOString();
-  const newId = seams.newId ?? randomUUID6;
+  const newId = seams.newId ?? randomUUID5;
   const blockerRows = rowsOf2(BLOCKERS, blockers.stored, write, newId, collectedAt);
   const bugRows = rowsOf2(OUT_OF_SCOPE_BUGS, bugs.stored, write, newId, collectedAt);
   const [blockersAdded, bugsAdded] = writeSqliteStore(path3, blockerRows.length + bugRows.length, [0, 0], (db) => insertBoth(db, blockerRows, bugRows));
@@ -15854,12 +17117,12 @@ function describeTaskReportRecord(record) {
 var SKILLS_HEADING = "## Skills for this task";
 var SKILLS_INSTRUCTION = "Invoke each with the Skill tool before you change anything it covers.";
 var LESSONS_HEADING = "## Lessons from earlier tasks";
-function oneLine3(text) {
+function oneLine4(text) {
   return text.replace(/\s+/g, " ").trim();
 }
 function skillLine(skill, delivery = SKILL_DELIVERY) {
   const name = `\`${sessionSkillName(skill.name, delivery)}\``;
-  const description = oneLine3(skill.description);
+  const description = oneLine4(skill.description);
   return description === "" ? `- ${name}` : `- ${name}: ${description}`;
 }
 function renderSkillsSection(skills, delivery = SKILL_DELIVERY) {
@@ -15869,7 +17132,7 @@ function renderSkillsSection(skills, delivery = SKILL_DELIVERY) {
 `);
 }
 function triggerClause(trigger) {
-  return oneLine3(trigger).replace(/^when\b\s*/i, "");
+  return oneLine4(trigger).replace(/^when\b\s*/i, "");
 }
 function lessonTaskCount(lesson) {
   return lesson.sources === undefined ? lesson.usage_count : lesson.sources.length;
@@ -15878,7 +17141,7 @@ function lessonLine(lesson) {
   const count = lessonTaskCount(lesson);
   const tasks = count === 1 ? "1 task" : `${count} tasks`;
   const evidence = `confidence ${lesson.confidence.toFixed(2)}, from ${tasks}, lesson ${lesson.id}`;
-  return `- When ${triggerClause(lesson.trigger)}: ${oneLine3(lesson.action)} (${evidence})`;
+  return `- When ${triggerClause(lesson.trigger)}: ${oneLine4(lesson.action)} (${evidence})`;
 }
 function renderLessonsSection(lessons) {
   if (lessons.length === 0)
@@ -15888,7 +17151,7 @@ function renderLessonsSection(lessons) {
 }
 
 // src/utils/progress.ts
-import { existsSync as existsSync21, writeFileSync as writeFileSync12 } from "fs";
+import { existsSync as existsSync21, writeFileSync as writeFileSync11 } from "fs";
 import { join as join18 } from "path";
 var PROGRESS_FILE_NAME = "progress.txt";
 var PROGRESS_CAP_BYTES = 16000;
@@ -16013,7 +17276,7 @@ function readProgressFindings(repoRoot, planStub2) {
 function writeProgress(repoRoot, planStub2) {
   const render = renderProgressText(readProgressFindings(repoRoot, planStub2));
   const path3 = progressFilePath(repoRoot);
-  writeFileSync12(path3, render.text, "utf8");
+  writeFileSync11(path3, render.text, "utf8");
   return { ...render, path: path3, storePath: sqliteStorePath(repoRoot) };
 }
 
@@ -16166,7 +17429,7 @@ var SEPARATOR = " \u2014 ";
 function moreLine(dropped) {
   return `${dropped} more: rafa skill list`;
 }
-function oneLine4(text) {
+function oneLine5(text) {
   return text.replace(/\s+/g, " ").trim();
 }
 function cutLine(line) {
@@ -16183,9 +17446,9 @@ function isDisabled(row) {
 }
 function skillIndexLine(item) {
   const fields = fieldsOf2(item.winner);
-  const tags = (fields.tags ?? []).map(oneLine4).filter((tag) => tag !== "").join(", ");
-  const prevents = oneLine4(fields.prevents ?? "");
-  const about = prevents === "" ? oneLine4(fields.summary ?? "") : prevents;
+  const tags = (fields.tags ?? []).map(oneLine5).filter((tag) => tag !== "").join(", ");
+  const prevents = oneLine5(fields.prevents ?? "");
+  const about = prevents === "" ? oneLine5(fields.summary ?? "") : prevents;
   const parts = [item.name, tags, about].filter((part) => part !== "");
   return cutLine(parts.join(SEPARATOR));
 }
@@ -16341,14 +17604,14 @@ function taskInputFor(taskInfo, text, declaration, planContent) {
     stageContext: stageContextOf(taskInfo, planContent)
   };
 }
-function messageOf5(error) {
+function messageOf6(error) {
   return error instanceof Error ? error.message : String(error);
 }
 async function pullBundle(learning, repoRoot) {
   try {
     return await taskLearningAdapter(learning, repoRoot).pullBlessed();
   } catch (error) {
-    activeOutput().warn(`   Lessons: none handed to this task: the \`${learning.kind}\` learning adapter answered no blessed set: ${messageOf5(error)}`);
+    activeOutput().warn(`   Lessons: none handed to this task: the \`${learning.kind}\` learning adapter answered no blessed set: ${messageOf6(error)}`);
     activeOutput().warn("   The task is not failed for it: it is dispatched without a lessons section.");
     return null;
   }
@@ -16368,7 +17631,7 @@ async function handOut(handout, task, resolution, repoRoot) {
 }
 
 // src/start/preflight.ts
-import { randomUUID as randomUUID7 } from "crypto";
+import { randomUUID as randomUUID6 } from "crypto";
 import { existsSync as existsSync23, readFileSync as readFileSync27 } from "fs";
 import { homedir as homedir4 } from "os";
 import { basename as basename7, join as join19 } from "path";
@@ -16678,10 +17941,10 @@ function storeChecks(options, runId, report2) {
     return messageOf(error);
   }
 }
-function refusalOf(runId, halt, storeProblem) {
-  if (halt === null && storeProblem === null)
+function refusalOf(runId, halt2, storeProblem) {
+  if (halt2 === null && storeProblem === null)
     return null;
-  if (halt === null) {
+  if (halt2 === null) {
     return [
       `\u274C The preflight checks of run ${runId} could not be stored: ${storeProblem}`,
       "   Nothing was dispatched. Make the store writable, then run again."
@@ -16690,11 +17953,11 @@ function refusalOf(runId, halt, storeProblem) {
   }
   const where = storeProblem === null ? `   Nothing was dispatched. The checks are stored under run ${runId},
    and \`rafa effort report\` lists the halt.` : `   Nothing was dispatched. The checks of run ${runId} were not stored: ${storeProblem}`;
-  return `\u274C ${halt}
+  return `\u274C ${halt2}
 ${where}`;
 }
 async function runStartPreflight(options) {
-  const runId = (options.newRunId ?? randomUUID7)();
+  const runId = (options.newRunId ?? randomUUID6)();
   refuseUnresolvableAgents(options);
   refuseStoreRuleBreaks(options.planPath);
   const items = await loadItems(options);
@@ -16798,7 +18061,7 @@ async function dispatchTask(options) {
   const handed = await handOut(options.handout, task, resolution, options.repoRoot);
   const prompt = withStamp(buildTaskPrompt(taskText, options.promptContent, injection.text, options.knownMissing, taskInfo.blocker ?? null, { skills: renderSkillsSection(handed.skills), lessons: renderLessonsSection(handed.lessons) }));
   const served = serveForSession(options.serving, resolution);
-  const sessionId = (options.newSessionId ?? randomUUID8)();
+  const sessionId = (options.newSessionId ?? randomUUID7)();
   const session = await run(prompt, flags, sessionId, options.settingSources, served);
   return {
     taskText,
@@ -16823,7 +18086,7 @@ function serveForSession(serving, resolution) {
     activeOutput().warn(`   ${skipped2.message}`);
   return served.flags;
 }
-function messageOf6(error) {
+function messageOf7(error) {
   return error instanceof Error ? error.message : String(error);
 }
 function renderProgressForDispatch(repoRoot, planStub2) {
@@ -16836,7 +18099,7 @@ function renderProgressForDispatch(repoRoot, planStub2) {
     return true;
   } catch (error) {
     activeOutput().error(`
-\u274C progress.txt could not be rendered from the findings store: ${messageOf6(error)}`);
+\u274C progress.txt could not be rendered from the findings store: ${messageOf7(error)}`);
     activeOutput().error("   Nothing was dispatched. Make the store readable, then run again.");
     return false;
   }
@@ -16860,7 +18123,7 @@ async function pushTaskLessons(options, record) {
     const rules = result.decisions.map((decision) => decision.rule).join(", ");
     activeOutput().info(`   Pushed ${count} lesson(s) to the \`${learning.kind}\` learning adapter: ${rules}.`);
   } catch (error) {
-    activeOutput().warn(`   ${count} lesson(s) of session ${dispatch.sessionId} were not pushed to the \`${learning.kind}\` learning adapter: ${messageOf6(error)}`);
+    activeOutput().warn(`   ${count} lesson(s) of session ${dispatch.sessionId} were not pushed to the \`${learning.kind}\` learning adapter: ${messageOf7(error)}`);
     activeOutput().warn("   The task is not failed for it: its report is stored, findings and all.");
   }
 }
@@ -16894,7 +18157,7 @@ async function storeTaskReport(options) {
       activeOutput().warn(`   ${warning}`);
   } catch (error) {
     activeOutput().error(`
-\u274C The report of session ${dispatch.sessionId} was not stored: ${messageOf6(error)}`);
+\u274C The report of session ${dispatch.sessionId} was not stored: ${messageOf7(error)}`);
     activeOutput().error("   The session printed it above as it ran.");
     return false;
   }
@@ -17141,14 +18404,14 @@ async function handleRedChecks(io, branch, prNumber, rows) {
 }
 
 // src/release/prepare.ts
-import { readFileSync as readFileSync28, writeFileSync as writeFileSync13 } from "fs";
+import { readFileSync as readFileSync28, writeFileSync as writeFileSync12 } from "fs";
 
 // src/release/enabled.ts
-import { statSync as statSync11 } from "fs";
+import { statSync as statSync12 } from "fs";
 import { resolve as resolve13 } from "path";
 function isRegularFile(full) {
   try {
-    return statSync11(full).isFile();
+    return statSync12(full).isFile();
   } catch {
     return false;
   }
@@ -17234,7 +18497,7 @@ function textOf2(path3) {
 }
 function writeText(path3, text) {
   try {
-    writeFileSync13(path3, text);
+    writeFileSync12(path3, text);
     return null;
   } catch (error) {
     return `${path3} could not be written: ${messageOf(error)}`;
@@ -17340,7 +18603,7 @@ function changelogFailure(failed3, versionEdit, restored) {
 }
 
 // src/release/verify.ts
-import { readFileSync as readFileSync29, writeFileSync as writeFileSync14 } from "fs";
+import { readFileSync as readFileSync29, writeFileSync as writeFileSync13 } from "fs";
 function changelogInsertionSpan(before, after) {
   const beforeLines = before.split(`
 `);
@@ -17388,7 +18651,7 @@ function changedOutside(current, before, span) {
 }
 function restoreFile(file) {
   try {
-    writeFileSync14(file.resolved, file.after);
+    writeFileSync13(file.resolved, file.after);
     return { path: file.path, restored: true, problem: null };
   } catch (error) {
     return {
@@ -18382,7 +19645,7 @@ async function announceRiskTotal(input, seams = {}) {
 }
 
 // src/start/session.ts
-import { randomUUID as randomUUID9 } from "crypto";
+import { randomUUID as randomUUID8 } from "crypto";
 import { relative as relative5 } from "path";
 var NOTHING_DISPATCHED = "   Nothing was checked and nothing was dispatched.";
 function recordLabel(repoRoot, sessionId) {
@@ -18446,16 +19709,37 @@ function sessionHandle(repoRoot, sessionId) {
     })
   });
 }
+function awayHopOf(options) {
+  if (options.roadmap !== true)
+    return {};
+  const hop = readAwayHopStamp(options.repoRoot);
+  return hop === null ? {} : { hop };
+}
+function readAwayHopStamp(repoRoot) {
+  const reading2 = readHopRecord(repoRoot);
+  if (!reading2.set) {
+    if (reading2.reason !== "absent") {
+      activeOutput().warn(`\u26A0\uFE0F  --roadmap: no hop is stamped on the session record: ${reading2.detail}`);
+    }
+    return null;
+  }
+  const { record } = reading2;
+  if (record.state !== "away")
+    return null;
+  const placed = readPositionFile(repoRoot);
+  return placed.set && !staleAgainst(record, placed.position) ? record : null;
+}
 function openRunSession(options) {
   const { repoRoot } = options;
   const seams = options.seams ?? {};
   const draft = {
-    sessionId: (seams.newSessionId ?? randomUUID9)(),
+    sessionId: (seams.newSessionId ?? randomUUID8)(),
     planStub: options.planStub,
     plan: relative5(repoRoot, options.planPath),
     branch: options.branch,
     pid: seams.pid ?? process.pid,
-    startedAt: (seams.now ?? (() => new Date))().toISOString()
+    startedAt: (seams.now ?? (() => new Date))().toISOString(),
+    ...awayHopOf(options)
   };
   try {
     beginSession(repoRoot, draft, { isAlive: seams.isAlive });
@@ -18543,7 +19827,7 @@ function announcePlanIssues(planContent) {
 }
 
 // src/start/runtime.ts
-import { existsSync as existsSync25, readdirSync as readdirSync10, realpathSync as realpathSync2, statSync as statSync12 } from "fs";
+import { existsSync as existsSync25, readdirSync as readdirSync10, realpathSync as realpathSync2, statSync as statSync13 } from "fs";
 import { homedir as homedir5 } from "os";
 import { isAbsolute as isAbsolute4, join as join21, relative as relative6, resolve as resolve14, sep } from "path";
 var RUNTIME_FLAG = "--runtime";
@@ -18583,7 +19867,7 @@ function resolveRuntime(value, places) {
 }
 function entryOf2(value, named, isVersion, home) {
   if (isVersion) {
-    if (isFile2(named))
+    if (isFile3(named))
       return named;
     const root = join21(home, RUNTIME_SUBDIR);
     const installed = installedVersions(root);
@@ -18592,10 +19876,10 @@ function entryOf2(value, named, isVersion, home) {
       installed.length === 0 ? `   ${root} holds no version.` : `   ${root} holds ${installed.join(", ")}.`
     ]);
   }
-  if (isFile2(named))
+  if (isFile3(named))
     return named;
   const inside = join21(named, RUNTIME_ENTRY);
-  if (isDirectory(named) && isFile2(inside))
+  if (isDirectory(named) && isFile3(inside))
     return inside;
   throw refusal3([
     `\u274C Refusing to start: \`--runtime=${value}\` names no runtime: ${named} is neither a file nor a directory holding \`${RUNTIME_ENTRY}\`.`,
@@ -18622,21 +19906,21 @@ function isInside2(path3, dir) {
 }
 function installedVersions(root) {
   try {
-    return readdirSync10(root).filter((name) => isFile2(join21(root, name, RUNTIME_ENTRY))).sort((a, b) => a.localeCompare(b));
+    return readdirSync10(root).filter((name) => isFile3(join21(root, name, RUNTIME_ENTRY))).sort((a, b) => a.localeCompare(b));
   } catch {
     return [];
   }
 }
-function isFile2(path3) {
+function isFile3(path3) {
   try {
-    return statSync12(path3).isFile();
+    return statSync13(path3).isFile();
   } catch {
     return false;
   }
 }
 function isDirectory(path3) {
   try {
-    return statSync12(path3).isDirectory();
+    return statSync13(path3).isDirectory();
   } catch {
     return false;
   }
@@ -18756,7 +20040,7 @@ function eventOf(line) {
 import { basename as basename8, join as join22 } from "path";
 
 // src/effort/store/tracker-refs.ts
-import { randomUUID as randomUUID10 } from "crypto";
+import { randomUUID as randomUUID9 } from "crypto";
 import { existsSync as existsSync26 } from "fs";
 var SELECT_HELD2 = `
   SELECT seq, tracker_ref FROM findings
@@ -18766,9 +20050,10 @@ var INSERT_REF = `
   INSERT INTO findings (
     id, session_id, plan_stub, task_line,
     artifact,
-    outcome, tracker_ref, collected_at
+    outcome, tracker_ref, collected_at,
+    ${STAMPED_COLUMNS}
   )
-  VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+  VALUES (?, ?, ?, ?, ?, ?, ?, ?, ${stampedValues("findings")})
 `;
 var ATTACH_REF = "UPDATE findings SET tracker_ref = ? WHERE seq = ? AND tracker_ref IS NULL";
 var SELECT_OLDEST = `
@@ -18823,17 +20108,17 @@ function storedRefOf(value) {
     if (problem !== null)
       return `whose ${field4} ${problem}`;
   }
-  const ref3 = {
+  const ref5 = {
     opt: fields.opt,
     kind: fields.kind,
     externalId: fields.externalId,
     url: fields.url
   };
   if (typeof fields.module === "string")
-    ref3.module = fields.module;
+    ref5.module = fields.module;
   if (typeof fields.repo === "string")
-    ref3.repo = fields.repo;
-  return { ref: ref3, json: JSON.stringify(ref3) };
+    ref5.repo = fields.repo;
+  return { ref: ref5, json: JSON.stringify(ref5) };
 }
 function heldRefOf(path3, seq, text) {
   let parsed;
@@ -18869,7 +20154,7 @@ function writeTrackerRef(repoRoot, write, seams = {}) {
   const path3 = sqliteStorePath(repoRoot);
   const { sessionId, planStub: planStub2, taskLine } = write.dispatch;
   const collectedAt = (seams.now ?? (() => new Date))().toISOString();
-  const newId = seams.newId ?? randomUUID10;
+  const newId = seams.newId ?? randomUUID9;
   const insertValues = () => [
     newId(),
     sessionId,
@@ -18901,28 +20186,28 @@ var ARTIFACT_REF_KINDS = new Set(["path", "symbol"]);
 var UNREAD_STAMP = "unread";
 var REFS_INTRO = "The paths and symbols the artifact names, each with its target's" + " fingerprint when this bug was filed.";
 function artifactRefs(artifact) {
-  return extractRefs(artifact).filter((ref3) => ARTIFACT_REF_KINDS.has(ref3.kind));
+  return extractRefs(artifact).filter((ref5) => ARTIFACT_REF_KINDS.has(ref5.kind));
 }
 function stampWord(live) {
   return live.kind === "unreadable" ? UNREAD_STAMP : fingerprintText(live);
 }
 async function stampArtifactRefs(artifact, verify) {
   const stamps = [];
-  for (const ref3 of artifactRefs(artifact)) {
+  for (const ref5 of artifactRefs(artifact)) {
     let stamp;
     try {
-      stamp = stampWord(await verify({ kind: ref3.kind, text: ref3.text }));
+      stamp = stampWord(await verify({ kind: ref5.kind, text: ref5.text }));
     } catch {
       stamp = UNREAD_STAMP;
     }
-    stamps.push(Object.freeze({ kind: ref3.kind, text: ref3.text, stamp }));
+    stamps.push(Object.freeze({ kind: ref5.kind, text: ref5.text, stamp }));
   }
   return Object.freeze(stamps);
 }
 function refsSection(stamps) {
   if (stamps.length === 0)
     return null;
-  const lines = stamps.map((ref3) => `- ${ref3.kind} \`${ref3.text}\`: \`${ref3.stamp}\``);
+  const lines = stamps.map((ref5) => `- ${ref5.kind} \`${ref5.text}\`: \`${ref5.stamp}\``);
   return [`## ${REFS_HEADING}`, REFS_INTRO, lines.join(`
 `)].join(`
 
@@ -18945,14 +20230,14 @@ async function noIssues() {
 }
 function createArtifactRefsVerifier(repoRoot, env) {
   let made = null;
-  return async (ref3) => {
+  return async (ref5) => {
     made ??= createRefVerifier({
       issues: noIssues,
       git: createGitRunner(repoRoot),
       outline: tsSymbolsOutliner({ cwd: repoRoot, env }),
       roster: EMPTY_ROSTER
     });
-    return made(ref3);
+    return made(ref5);
   };
 }
 
@@ -19027,11 +20312,11 @@ function triageBlockers(options) {
 function artifactOf(bug) {
   return hasText2(bug.artifact) && textProblem(bug.artifact) === null ? bug.artifact : null;
 }
-function oneLine5(text) {
+function oneLine6(text) {
   return text.replace(/\s+/g, " ").trim();
 }
 function bugKeyOf(trackerPath, artifact) {
-  return `${basename8(trackerPath)}${KEY_SEPARATOR}${oneLine5(artifact)}`;
+  return `${basename8(trackerPath)}${KEY_SEPARATOR}${oneLine6(artifact)}`;
 }
 function fenced(value) {
   const runs = Array.from(value.matchAll(/`+/g), (run) => run[0].length);
@@ -19043,7 +20328,7 @@ function fenced(value) {
 ${body}${fence}`;
 }
 function issueTitle2(redactedWhat) {
-  const line = oneLine5(redactedWhat);
+  const line = oneLine6(redactedWhat);
   const points = Array.from(line);
   if (points.length <= TITLE_MAX_LENGTH)
     return line;
@@ -19119,23 +20404,23 @@ function resultOf(run, action, fields = {}) {
     ...fields
   };
 }
-async function settle(run, action, ref3, foundBy) {
+async function settle(run, action, ref5, foundBy) {
   const { store } = run.route;
   const { key } = run.filing;
   if (store === null || key === null)
-    return resultOf(run, action, { ref: ref3, foundBy });
-  const stored = await step(run, "storing the reference", () => store(key, ref3));
-  return stored.ok ? resultOf(run, action, { ref: ref3, foundBy, stored: stored.value }) : resultOf(run, action, { ref: ref3, foundBy, problem: stored.problem });
+    return resultOf(run, action, { ref: ref5, foundBy });
+  const stored = await step(run, "storing the reference", () => store(key, ref5));
+  return stored.ok ? resultOf(run, action, { ref: ref5, foundBy, stored: stored.value }) : resultOf(run, action, { ref: ref5, foundBy, problem: stored.problem });
 }
 async function fileNew(run) {
   const created = await step(run, `the ${run.route.channel} tracker create`, () => run.route.tracker.create(run.filing.draft));
   return created.ok ? settle(run, "filed", created.value, null) : resultOf(run, "failed", { problem: created.problem });
 }
-async function commentOn(run, ref3, foundBy) {
-  const commented = await step(run, `the ${run.route.channel} tracker comment`, () => run.route.tracker.comment(ref3, run.filing.comment));
+async function commentOn(run, ref5, foundBy) {
+  const commented = await step(run, `the ${run.route.channel} tracker comment`, () => run.route.tracker.comment(ref5, run.filing.comment));
   if (!commented.ok)
-    return resultOf(run, "failed", { ref: ref3, foundBy, problem: commented.problem });
-  return foundBy === "store" ? resultOf(run, "commented", { ref: ref3, foundBy }) : settle(run, "commented", ref3, foundBy);
+    return resultOf(run, "failed", { ref: ref5, foundBy, problem: commented.problem });
+  return foundBy === "store" ? resultOf(run, "commented", { ref: ref5, foundBy }) : settle(run, "commented", ref5, foundBy);
 }
 async function triageBug(run) {
   const { route, filing } = run;
@@ -19183,11 +20468,11 @@ async function triageReport(options) {
       channel: "public",
       tracker: options.tracker,
       readStored: (key) => readTrackerRef(repoRoot, key),
-      store: (key, ref3) => writeTrackerRef(repoRoot, {
+      store: (key, ref5) => writeTrackerRef(repoRoot, {
         dispatch: options.dispatch,
         outcome: options.outcome,
         artifact: key,
-        ref: ref3
+        ref: ref5
       }, options.seams).action
     },
     private: { channel: "private", tracker: privateTracker, readStored: null, store: null }
@@ -19238,8 +20523,8 @@ function filesPublicly(bug) {
 function hasTriage(report2) {
   return blockerTextOf(report2.blockers) !== null || report2.outOfScopeBugs.length > 0;
 }
-function issueName2(ref3) {
-  return ref3.url ?? `${ref3.kind} issue ${ref3.externalId}`;
+function issueName2(ref5) {
+  return ref5.url ?? `${ref5.kind} issue ${ref5.externalId}`;
 }
 function bugLines(bug) {
   const name = `out_of_scope_bugs[${bug.index}]`;
@@ -19431,7 +20716,7 @@ function changedSince(git, head) {
   const paths = result.stdout.split("\x00").filter((path3) => path3 !== "");
   return { ok: true, head, paths: new Set(paths) };
 }
-function repoPath(path3, repoRoot) {
+function repoPath2(path3, repoRoot) {
   const inside = isAbsolute5(path3) ? relative7(repoRoot, path3) : path3;
   const normal = posix2.normalize(inside.replaceAll("\\", "/"));
   if (normal === "." || normal === ".." || normal.startsWith("../") || isAbsolute5(normal))
@@ -19441,7 +20726,7 @@ function repoPath(path3, repoRoot) {
 function promotedOutcome(lesson, named, changed, repoRoot) {
   if (!changed.ok)
     return { kind: "unchecked", id: lesson.id, path: named, reason: changed.reason };
-  const path3 = repoPath(named, repoRoot);
+  const path3 = repoPath2(named, repoRoot);
   return path3 !== null && changed.paths.has(path3) ? { lesson, path: path3 } : { kind: "unchanged", id: lesson.id, path: named };
 }
 function checkPromoted(lessons, reading2, changed, repoRoot) {
@@ -19584,15 +20869,15 @@ function buildWrapUpPrompt(branch, planContent, openPullRequest = null, release
   ].join(`
 `);
 }
-function oneLine6(text) {
+function oneLine7(text) {
   return text.trim().replace(/\s+/g, " ");
 }
 function lessonLines(lesson) {
-  const artifact = lesson.artifact === undefined || oneLine6(lesson.artifact) === "" ? "none" : oneLine6(lesson.artifact);
+  const artifact = lesson.artifact === undefined || oneLine7(lesson.artifact) === "" ? "none" : oneLine7(lesson.artifact);
   return [
     `- \`${lesson.id}\``,
-    `  - trigger: ${oneLine6(lesson.trigger)}`,
-    `  - action: ${oneLine6(lesson.action)}`,
+    `  - trigger: ${oneLine7(lesson.trigger)}`,
+    `  - action: ${oneLine7(lesson.action)}`,
     `  - artifact: ${artifact}`
   ];
 }
@@ -19661,7 +20946,7 @@ async function openPullRequestNumber(branch) {
     return null;
   }
 }
-function messageOf7(error) {
+function messageOf8(error) {
   return error instanceof Error ? error.message : String(error);
 }
 function wrapUpAdapter(learning) {
@@ -19682,7 +20967,7 @@ async function lessonsToPromote(learning) {
       minConfidence: learning.promoteMinConfidence
     });
   } catch (error) {
-    activeOutput().warn(`   The wrap-up lists no lesson to promote: the \`${learning.kind}\` learning adapter answered no blessed set: ${messageOf7(error)}`);
+    activeOutput().warn(`   The wrap-up lists no lesson to promote: the \`${learning.kind}\` learning adapter answered no blessed set: ${messageOf8(error)}`);
     return [];
   }
 }
@@ -19753,6 +21038,7 @@ var interrupted = false;
 var DEFAULT_BRANCHES = ["main", "master"];
 var ANY_BRANCH_FLAG = "--any-branch";
 var CREATE_BRANCH_FLAG = "--create-branch";
+var ROADMAP_FLAG2 = "--roadmap";
 var UNNAMED_PLAN = "this-plan";
 async function resolveRunBranch(request, seams = DEFAULT_BRANCH_SEAMS) {
   const { args, base } = request;
@@ -19854,7 +21140,7 @@ async function start(args, repoRoot) {
   });
   await requireNoticesAnswered();
   setActivePlanStub(planStub2);
-  const session = openRunSession({ repoRoot, planPath, planStub: planStub2, branch });
+  const session = openRunSession({ repoRoot, planPath, planStub: planStub2, branch, roadmap: args.includes(ROADMAP_FLAG2) });
   try {
     const planContent = fs.readFileSync(planPath, "utf8");
     const promptContent = fs.readFileSync(promptPath, "utf8");
@@ -20544,4 +21830,4 @@ async function plan(args, repoRoot, registry = CORE_ADAPTER_REGISTRY) {
   }
 }
 
-export { readConfigFile, loadConfig, SERVE_CLI_VERSION, PROVENANCE_FIELD, SKILL_FILE2 as SKILL_FILE, provenanceBlock, serveVerdict, SKILL_USE_CLI_VERSION, minutesBetween, sessionLogDir, collectSessionRow, collect, AGENT_DEFINITION_DIR, VENDOR_COMMAND, readAgentDirectory, resolveAgentRoster, missingPlanAgents, isStackList, stackPaths, stacksFromEccSkillName, DESCRIPTION_LIMIT, LISTING_LIMIT, SKILL_SIGNALS, countCharacters, toolOf, pathDirectories, checkReferences, checkFile, checkDirectory, bundledAgentsDirectory, sourceItem, byName, skillItem, readTrees, formatCount, verdictOf, failingRows, formatRows, waitForChecks, recordPlanCi, report, MANIFEST_VERSION, FEATURE_TYPES, OUTPUT_CHANNELS, RUNNING_MANIFEST_SEAMS, validateManifest, SPEC_EXTENSION, boardId, notesFileName, ROADMAP_TITLE, ROADMAP_SETTING, parseRoadmapBody, createGhRoadmapSearch, severalRoadmapsMessage, createGhOpenPullRequests, closedIssuesIn, branchClaims, scanClaimBranches, bodyLines, findField, readEpicBody, SPEC_BLOCKED_LABEL, hasSpecBlockedLabel, readBlockedBy, blockedFaultMessage, EPIC_LABEL_PREFIX, epicSlugsOf, isNotPlanned, groupByEpicLabel, localDay, readEpics, BOARD_LISTING_LIMIT, createGhBoardListing, EPIC_TYPE_LABEL, plansDirAt, requireProject, resolvePlansDir, resolveProjectConfig, countTasks, formatCounts, checkbox, planFileName, isFile, issueLine, plural, expectNoArgument, expectOneArgument, expectAtMostOneArgument, readSwitch, validate_default, createGhPermissions, readAuthorTrust, trustRefusalClause, requireTrustedAuthor, RefsBlockError, fingerprintText, readRefsText, readCopyRefs, restampCopyRefs, createGitRunner, gitSaid, RefVerifyError, PREVIOUS_COPY_WARN_ABOVE, previousDir, countPreviousCopies, createGhSpecIssueReader, readRoadmapSetting, ROADMAP_LABEL, BOARD_LABELS, LABEL_LIST_LIMIT, SPEC_TEMPLATE_PATH, TEMPLATES_DIRNAME, boardChanged, listBoardLabels, missingBoardLabels, anythingAt, writeShippedFile, setUpBoard, createGhBoardLister, resolveDefaultBoard, unlabelledRoadmapMessage, createGhIssueBoard, blockedLineSentence, HORIZON_LABEL_PREFIX, readEpicProblems, epicProblemMessage, readDoctorRefs, renderDoctorRefs, POSITION_FILE, positionFilePath, readPositionFile, writePositionFile, rehome, hop, readEpicDependents, REASON_FLAG, renderHorizonComment, renderParkedPullRequestComment, renderMoveComment, renderCloseComment, renderCancelComment, cancelMoveReason, renderDependentComment, renderUnblockNote, readReason, unaskedReasonMessage, blankReasonMessage, HORIZONS, horizonOf, resolveTracker, DEFAULT_ISSUE_SEAMS, lineRefusal, expectTwoArguments, readTextFlag, readNonBlankFlag, readRequiredFlag, readChoice, readChoiceFlag, issueProject, issueSubjectConfig, resolveIssueTracker, issueRef, issueName, urlLines, onTracker, runIssueList, ISSUE_LIST_FLAGS, list_default, firstNowEpic, show_default, samePlace, resolvePlace, createPlanDirNames, hasPlanFor, memoiseVerifier, LEARNED_DIRECTORY, ORIGIN_FIELD, DEMOTION_VERDICTS, WHEN_TO_USE_HEADING, bodySections, classifySkill, firstSentence, convertToInstinct, rankCandidates, readRankCandidate, NO_NEXT_STEP, readSchemaReport, gateMeaning, unknownAdditive, unknownAdditiveWarning, developmentApplied, shellQuote, ghMissingMessage, ghUnauthenticatedMessage, ghHostOf, ghPreflightItems, resolvePrProvider, requireGhProvider, isFirstDispatch, SESSION_ID_FLAG2 as SESSION_ID_FLAG, resolveLoopSeams, sessionIdFlag, refusal2 as refusal, isLive, planLabel, sessionLine, projectRoot, readRecords, pickSession, writeSession, readSessionChecklist, checkboxAt, estimateEta, readSessionFinishes, formatDuration, etaLine, parseWorkingTree, parseWorktrees, readMergeRefusal, cleanUpSteps, commandLine, remainingFrom, createGhPullRequests, ghPullRequestsIn, readManifestVersion, DEFAULT_RELEASE_SEAMS, changelogVersions, readTags, status_default, epicEndLines, watchDryEpic, DEFAULT_BASE_BRANCH, ghNextBoard, openNextSources, createLinePrompter, REMOTE, parseBaseStanding, hasDiverged, list_default2 as list_default1, readBranch2 as readBranch, readPlans, readOpenPull, readBranchPlan, readNextState, commandWords, nextQuestion, NEXT_COMMAND_ACTIONS, actionInvocation, runAction, HINT_FLAG_SPEC, actionOutput, endWithNextStep, endingWith, lazyPrompter, ready_default, DEFAULT_PLAN_FILE, resolvePlanPath, assessPlanRisk, renderRiskText, announceRiskTotal, resolveCreateSpec, TRIAGE_MODULE, namedSecrets, triageReport, unresolvedTracker, resolveReleaseEnabled, DEFAULT_CI_TIMEOUT_MIN, CI_POLL_INTERVAL_MS, DEFAULT_CI_ATTEMPTS, RUNTIME_SUBDIR, RUNTIME_ENTRY, VERSION_SHAPE2 as VERSION_SHAPE, refuseMisplacedRuntime, MECHANICAL_CONFLICT_SENTENCE, start, usage, createPlanRefsVerifier, plan };
+export { readConfigFile, loadConfig, SERVE_CLI_VERSION, PROVENANCE_FIELD, SKILL_FILE2 as SKILL_FILE, provenanceBlock, serveVerdict, SKILL_USE_CLI_VERSION, minutesBetween, sessionLogDir, collectSessionRow, collect, AGENT_DEFINITION_DIR, VENDOR_COMMAND, readAgentDirectory, resolveAgentRoster, missingPlanAgents, isStackList, stackPaths, stacksFromEccSkillName, DESCRIPTION_LIMIT, LISTING_LIMIT, SKILL_SIGNALS, countCharacters, toolOf, pathDirectories, checkReferences, checkFile, checkDirectory, bundledAgentsDirectory, sourceItem, byName, skillItem, readTrees, formatCount, verdictOf, failingRows, formatRows, waitForChecks, recordPlanCi, report, MANIFEST_VERSION, FEATURE_TYPES, OUTPUT_CHANNELS, RUNNING_MANIFEST_SEAMS, validateManifest, SPEC_EXTENSION, boardId, notesFileName, ROADMAP_TITLE, ROADMAP_SETTING, parseRoadmapBody, createGhRoadmapSearch, severalRoadmapsMessage, createGhOpenPullRequests, closedIssuesIn, branchClaims, scanClaimBranches, readEpicBody, SPEC_BLOCKED_LABEL, hasSpecBlockedLabel, readBlockedBy, blockedFaultMessage, EPIC_LABEL_PREFIX, epicSlugsOf, isNotPlanned, groupByEpicLabel, localDay, readEpics, BOARD_LISTING_LIMIT, createGhBoardListing, EPIC_TYPE_LABEL, plansDirAt, requireProject, resolvePlansDir, resolveProjectConfig, countTasks, formatCounts, checkbox, planFileName, isFile, issueLine, plural, expectNoArgument, expectOneArgument, expectAtMostOneArgument, readSwitch, validate_default, createGhPermissions, readAuthorTrust, trustRefusalClause, requireTrustedAuthor, RefsBlockError, fingerprintText, readRefsText, readCopyRefs, restampCopyRefs, RefVerifyError, PREVIOUS_COPY_WARN_ABOVE, previousDir, countPreviousCopies, createGhSpecIssueReader, readRoadmapSetting, ROADMAP_LABEL, BOARD_LABELS, LABEL_LIST_LIMIT, SPEC_TEMPLATE_PATH, TEMPLATES_DIRNAME, boardChanged, listBoardLabels, missingBoardLabels, anythingAt, writeShippedFile, setUpBoard, createGhBoardLister, resolveDefaultBoard, unlabelledRoadmapMessage, createGhIssueBoard, blockedLineSentence, HORIZON_LABEL_PREFIX, readEpicProblems, epicProblemMessage, readDoctorRefs, renderDoctorRefs, readEpicDependents, REASON_FLAG, renderHorizonComment, renderParkedPullRequestComment, renderMoveComment, renderCloseComment, renderCancelComment, cancelMoveReason, renderDependentComment, renderUnblockNote, readReason, unaskedReasonMessage, blankReasonMessage, HORIZONS, horizonOf, resolveTracker, DEFAULT_ISSUE_SEAMS, lineRefusal, expectTwoArguments, readTextFlag, readNonBlankFlag, readRequiredFlag, readChoice, readChoiceFlag, issueProject, issueSubjectConfig, resolveIssueTracker, issueRef, issueName, urlLines, onTracker, runIssueList, ISSUE_LIST_FLAGS, list_default, firstNowEpic, show_default, samePlace, resolvePlace, createPlanDirNames, hasPlanFor, memoiseVerifier, LEARNED_DIRECTORY, ORIGIN_FIELD, DEMOTION_VERDICTS, WHEN_TO_USE_HEADING, bodySections, classifySkill, firstSentence, convertToInstinct, rankCandidates, readRankCandidate, NO_NEXT_STEP, readSchemaReport, gateMeaning, unknownAdditive, unknownAdditiveWarning, developmentApplied, shellQuote, ghMissingMessage, ghUnauthenticatedMessage, ghHostOf, ghPreflightItems, resolvePrProvider, requireGhProvider, isFirstDispatch, SESSION_ID_FLAG2 as SESSION_ID_FLAG, readBoardBody, openBoards, boardOfEpic, createOwnerResolver, resolveLoopSeams, sessionIdFlag, refusal2 as refusal, isLive, planLabel, sessionLine, projectRoot, readRecords, pickSession, writeSession, readSessionChecklist, checkboxAt, estimateEta, readSessionFinishes, formatDuration, etaLine, parseWorkingTree, parseWorktrees, readMergeRefusal, cleanUpSteps, commandLine, remainingFrom, createGhPullRequests, ghPullRequestsIn, readManifestVersion, DEFAULT_RELEASE_SEAMS, changelogVersions, readTags, status_default, epicEndLines, watchDryEpic, nextOwnerGate, DEFAULT_BASE_BRANCH, ghNextBoard, openNextSources, createLinePrompter, REMOTE, parseBaseStanding, hasDiverged, list_default2 as list_default1, readBranch2 as readBranch, readPlans, readOpenPull, readBranchPlan, readNextState, readHomeAfterLoop, commandWords, nextQuestion, NEXT_COMMAND_ACTIONS, actionInvocation, runAction, HINT_FLAG_SPEC, actionOutput, endWithNextStep, endingWith, lazyPrompter, ready_default, DEFAULT_PLAN_FILE, resolvePlanPath, assessPlanRisk, renderRiskText, announceRiskTotal, resolveCreateSpec, TRIAGE_MODULE, namedSecrets, triageReport, unresolvedTracker, resolveReleaseEnabled, DEFAULT_CI_TIMEOUT_MIN, CI_POLL_INTERVAL_MS, DEFAULT_CI_ATTEMPTS, RUNTIME_SUBDIR, RUNTIME_ENTRY, VERSION_SHAPE2 as VERSION_SHAPE, refuseMisplacedRuntime, MECHANICAL_CONFLICT_SENTENCE, start, usage, createPlanRefsVerifier, plan };