@open-tomato/rafa 0.37.0 → 0.38.0

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

@@ -4,6 +4,7 @@ import {
   BLOCKED_BY_FIELD,
   BOARD_LABELS,
   BOARD_LISTING_LIMIT,
+  BOARD_SYNC_FIX,
   BRANCH_PREFIX,
   CI_POLL_INTERVAL_MS,
   CLAIMED_LABEL,
@@ -38,6 +39,8 @@ import {
   NoSessionRefusal,
   ORIGIN_FIELD,
   PREVIOUS_COPY_WARN_ABOVE,
+  PROJECT_SCOPE_FIX,
+  PROJECT_WRITE_PAUSE_MS,
   PROVENANCE_FIELD,
   REASON_FLAG,
   RELEASE_BASE_BRANCH,
@@ -117,6 +120,7 @@ import {
   createGhBoardListing,
   createGhIssueBoard,
   createGhOpenPullRequests,
+  createGhProjectPort,
   createGhPullRequests,
   createGhRoadmapBody,
   createGhRoadmapSearch,
@@ -181,6 +185,7 @@ import {
   invalidateRows,
   isFirstDispatch,
   isLive,
+  isMissingProjectScope,
   isNotPlanned,
   isStackList,
   isWaiting,
@@ -199,6 +204,7 @@ import {
   localDay,
   localPlanNotes,
   makeOwnershipCommit,
+  matchProjectFields,
   memoiseVerifier,
   mergeGuardSettings,
   missingBoardLabels,
@@ -212,6 +218,7 @@ import {
   nextQuestion,
   noBoardListsLine,
   normaliseReason,
+  notFoundWarning,
   notesFileName,
   onTracker,
   openBoards,
@@ -237,6 +244,8 @@ import {
   pushOwnershipCommit,
   pushResolved,
   rankCandidates,
+  rankOf,
+  rateLimitWarning,
   readAgentDirectory,
   readBinPath,
   readBlockedBy,
@@ -260,6 +269,7 @@ import {
   readEpics,
   readGuard,
   readHomeAfterLoop,
+  readIssueFacts,
   readListedEpics,
   readManifestVersion,
   readMergeGuard,
@@ -272,6 +282,7 @@ import {
   readReason,
   readReceiptVerdict,
   readRecords,
+  readRefreshBoard,
   readRefsText,
   readRequiredFlag,
   readRoadmapSetting,
@@ -289,6 +300,9 @@ import {
   ready_default,
   receiptProblem,
   recordPlanCi,
+  refreshFailedWarning,
+  refreshIssueItems,
+  refreshProjectItems,
   refusal,
   refuseMisplacedRuntime,
   releaseCommitSubject,
@@ -329,6 +343,7 @@ import {
   runIssueList,
   samePlace,
   scanClaimBranches,
+  scopeWarning,
   selectBoardRelations,
   self_update_default,
   serializeFragment,
@@ -345,6 +360,7 @@ import {
   sourceItem,
   stackPaths,
   stacksFromEccSkillName,
+  stageOf,
   start,
   status_default,
   tickLine,
@@ -374,7 +390,7 @@ import {
   worktreesHolding,
   writeSession,
   writeShippedFile
-} from "./index-35ze56rz.js";
+} from "./index-e3vhhfka.js";
 import {
   PROBE_TIMEOUT_MS,
   loadPlanPrerequisites,
@@ -386,7 +402,7 @@ import {
   runPreflight,
   splitBlockerComment,
   trackerPathFor
-} from "./index-7bb0fdb7.js";
+} from "./index-zdz0mp63.js";
 import {
   ACTION_HEADING,
   CAUSE_HEADING,
@@ -492,7 +508,7 @@ import {
   versionLine,
   writeFrontmatter,
   writePositionFile
-} from "./index-1mxv55ec.js";
+} from "./index-74btmn1e.js";
 import {
   CONFIG_DEFAULTS,
   CONFIG_FILE,
@@ -507,7 +523,7 @@ import {
   readItemBytes,
   readRafaBlocks,
   resolveTiers
-} from "./index-jfas157k.js";
+} from "./index-w9naz372.js";
 import {
   promotable
 } from "./index-d6d0942q.js";
@@ -515,10 +531,10 @@ import {
   createCommandRegistry,
   describeRegistry,
   mountKey
-} from "./index-k6sd4ym5.js";
+} from "./index-eyjq63mx.js";
 import {
   CommandExit
-} from "./index-3mzw3kzh.js";
+} from "./index-sr3kc4mf.js";
 import {
   CLAIMS_STALE_DISABLED,
   MERGE_METHODS,
@@ -531,7 +547,7 @@ import {
   isSkillTier,
   messageOf,
   parseBudgetUsd
-} from "./index-fzhd3d4y.js";
+} from "./index-m2ahxjw8.js";
 import {
   triggerKey
 } from "./index-wp8c28fd.js";
@@ -3261,8 +3277,187 @@ function createBoardListCommand(seams = {}) {
 }
 var list_default5 = createBoardListCommand();
 
+// src/board/project/sync.ts
+var WHOLE_PROJECT = Object.freeze({ everyItem: true, openIssues: true });
+function addedWrites(first, second) {
+  return {
+    written: first.written + second.written,
+    notUpdated: first.notUpdated + second.notUpdated,
+    rateLimited: first.rateLimited || second.rateLimited,
+    detail: [first.detail, second.detail].filter((detail) => detail !== "").join(`
+`)
+  };
+}
+async function addIssues(options, ref, issues) {
+  const repository = await readBoardRepository(options.gh);
+  const port = createGhProjectPort(options.gh);
+  const project = await port.find(ref);
+  if (project === null)
+    return null;
+  for (const number of issues)
+    await port.addItem(project.id, { repository, number });
+  return issues;
+}
+async function addMissing(options, first, synced) {
+  if (synced.dryRun || first.missing.length === 0 || first.writes.rateLimited)
+    return synced;
+  try {
+    const added = await addIssues(options, first.project, first.missing);
+    if (added === null)
+      return { kind: "not-found", project: first.project, warnings: [notFoundWarning(first.project)] };
+    const second = await refreshProjectItems(options, added);
+    if (second.kind !== "refreshed")
+      return second;
+    return {
+      ...synced,
+      changes: [...first.changes, ...second.changes],
+      added,
+      writes: addedWrites(first.writes, second.writes),
+      warnings: [...first.warnings, ...second.warnings.filter((line) => !first.warnings.includes(line))]
+    };
+  } catch (error) {
+    if (isMissingProjectScope(error))
+      return { kind: "refused", reason: "scope", project: first.project, warnings: [scopeWarning()] };
+    throw error;
+  }
+}
+async function syncProject(options) {
+  const first = await refreshProjectItems(options, [], WHOLE_PROJECT);
+  if (first.kind !== "refreshed")
+    return first;
+  return addMissing(options, first, {
+    kind: "synced",
+    project: first.project,
+    dryRun: options.dryRun === true,
+    changes: first.changes,
+    missing: first.missing,
+    added: [],
+    writes: first.writes,
+    warnings: first.warnings
+  });
+}
+
+// src/commands/board/sync.ts
+var USAGE7 = "rafa board sync [--dry-run]";
+var DRY_RUN_FLAG = "dry-run";
+var BOARD_SYNC_REFUSAL_EXIT = 2;
+var PROJECT_INIT_FIX = "rafa init --board --project";
+var EMPTY_VALUE = "(empty)";
+function counted(count, noun) {
+  return count === 1 ? `1 ${noun}` : `${String(count)} ${noun}s`;
+}
+function changeLine(change) {
+  return `#${String(change.issue)} ${change.name}: ${change.from ?? EMPTY_VALUE} \u2192 ${change.to ?? EMPTY_VALUE}`;
+}
+function closingLine(result) {
+  const project = `project #${String(result.project.number)}`;
+  const adds = result.dryRun ? result.missing : result.added;
+  const changes = counted(result.changes.length, "change");
+  const issues = counted(adds.length, "issue");
+  if (result.dryRun) {
+    return result.changes.length === 0 && adds.length === 0 ? `Dry run on ${project}: in step, nothing to change.` : `Dry run on ${project}: ${changes} and ${issues} to add; nothing written.`;
+  }
+  if (result.rateLimited)
+    return `Stopped on ${project}: ${String(result.written)} of ${changes} written; the rate limit refused the rest.`;
+  return result.changes.length === 0 && adds.length === 0 ? `Synced ${project}: in step, nothing to change.` : `Synced ${project}: ${changes} written and ${issues} added.`;
+}
+function syncLines(result) {
+  const adds = result.dryRun ? result.missing.map((issue) => `#${String(issue)} is not on the project: would be added`) : result.added.map((issue) => `#${String(issue)} added to the project`);
+  return [...result.changes.map(changeLine), ...adds, closingLine(result)];
+}
+function plainChange(change) {
+  return { issue: change.issue, field: change.field, name: change.name, from: change.from, to: change.to };
+}
+function syncResultOf(synced) {
+  return {
+    project: synced.project,
+    dryRun: synced.dryRun,
+    changes: synced.changes.map(plainChange),
+    missing: synced.missing,
+    added: synced.added,
+    written: synced.writes.written,
+    rateLimited: synced.writes.rateLimited,
+    notUpdated: synced.writes.notUpdated,
+    warnings: synced.warnings
+  };
+}
+async function runBoardSync(context, seams) {
+  if (context.args.length > 0) {
+    throw lineRefusal(`Expected no arguments, got ${String(context.args.length)}: ${context.args.join(" ")}`, USAGE7);
+  }
+  const project = issueProject(context);
+  const config = issueSubjectConfig(project, (message) => {
+    context.output.warn(message);
+  });
+  if (config.boardProjectNumber === null) {
+    throw new CommandExit(1, `\u274C board.project.number is not set, so there is no project to sync. Run \`${PROJECT_INIT_FIX}\` to create one.`);
+  }
+  const gh = seams.gh ?? createGhRunner({ cwd: project.root });
+  const dryRun = context.flags[DRY_RUN_FLAG] === true;
+  const synced = await syncProject(seams.sleep === undefined ? { config, gh, dryRun } : { config, gh, dryRun, sleep: seams.sleep }).catch((error) => {
+    throw new CommandExit(BOARD_SYNC_REFUSAL_EXIT, `\u274C Could not sync the project: ${messageOf(error)}`);
+  });
+  if (synced.kind !== "synced") {
+    throw new CommandExit(BOARD_SYNC_REFUSAL_EXIT, `\u274C ${synced.warnings.join(`
+`)}`);
+  }
+  return syncResultOf(synced);
+}
+function writeResult(context, result) {
+  const refusal3 = rateLimitWarning(result.notUpdated);
+  if (context.outputMode !== "json") {
+    for (const line of syncLines(result))
+      context.output.info(line);
+  }
+  for (const line of result.warnings) {
+    if (!result.rateLimited || line !== refusal3)
+      context.output.warn(line);
+  }
+  if (result.rateLimited)
+    throw new CommandExit(BOARD_SYNC_REFUSAL_EXIT, `\u274C ${refusal3}`);
+  if (context.outputMode === "json")
+    context.output.result(result);
+}
+function createBoardSyncCommand(seams = {}) {
+  const command = {
+    name: "sync",
+    subject: "board",
+    action: "sync",
+    summary: "bring the repository's GitHub project in step with its issues",
+    description: "Refreshes every item of this repository on the GitHub project board.project.number names, writing" + " only the Stage, Horizon, Rank, Blocked by and Progress values that differ from what rafa reads of the" + " issues, then adds every open issue missing from the project and fills its fields. It repairs what changed" + " outside rafa: a label edited in the web UI, an issue closed by hand, the Roadmap issue's order edited in" + " its body. Prints one line per change and per issue added, then a closing count. With `--dry-run` it" + " prints the same lines and writes nothing. With `--output=json` the changes are the data of the terminal" + " result event. Refused with exit code 1 when board.project.number is unset, and with exit code 2 when the" + " token lacks the project scope, the number names no project, or the rate limit stopped the writes.",
+    args: [],
+    flags: [
+      {
+        name: DRY_RUN_FLAG,
+        description: "Print each change the sync would make and each issue it would add, and write nothing.",
+        type: "boolean"
+      }
+    ],
+    examples: [
+      {
+        cmd: "rafa board sync --dry-run",
+        note: "Shows what drifted on the project since rafa last wrote it, writing nothing."
+      },
+      {
+        cmd: "rafa board sync",
+        note: "Writes those changes and adds the open issues the project lacks."
+      },
+      {
+        cmd: "rafa board sync --output=json",
+        note: "Gives the changes, the issues added and the counts as the terminal result."
+      }
+    ],
+    outputs: ["text", "json"],
+    run: async (context) => {
+      writeResult(context, await runBoardSync(context, seams));
+    }
+  };
+  return Object.freeze(command);
+}
+var sync_default = createBoardSyncCommand();
+
 // src/commands/claim/release.ts
-var USAGE7 = "rafa claim release <n>";
+var USAGE8 = "rafa claim release <n>";
 var COMMAND = "rafa claim release";
 var ISSUE_NUMBER2 = /^[1-9]\d*$/;
 var RELEASING = { during: "was being released", nothing: "nothing was released" };
@@ -3344,7 +3539,7 @@ function pushOnClaimTip(git, reading, record, refuseWith, doing) {
   return made.sha;
 }
 async function releaseClaim(context, makeSeams) {
-  const issue = readIssueArgument(context.args, USAGE7);
+  const issue = readIssueArgument(context.args, USAGE8);
   const project = requireProject(context, COMMAND);
   const config = resolveProjectConfig(project, COMMAND, (message) => context.output.warn(message));
   const seams = makeSeams(project.root, config);
@@ -3402,7 +3597,7 @@ function createClaimReleaseCommand(makeSeams = DEFAULT_SEAMS) {
 var release_default = createClaimReleaseCommand();
 
 // src/commands/claim/accept.ts
-var USAGE8 = "rafa claim accept <n>";
+var USAGE9 = "rafa claim accept <n>";
 var COMMAND2 = "rafa claim accept";
 var ACCEPTING = { during: "was being accepted", nothing: "nothing was accepted" };
 function refuse2(message) {
@@ -3475,7 +3670,7 @@ ${reasons.map((reason) => `   ${reason}`).join(`
 `)}`);
 }
 function acceptClaim(context, makeSeams) {
-  const issue = readIssueArgument(context.args, USAGE8);
+  const issue = readIssueArgument(context.args, USAGE9);
   const project = requireProject(context, COMMAND2);
   const config = resolveProjectConfig(project, COMMAND2, (message) => context.output.warn(message));
   const seams = makeSeams(project.root, config);
@@ -3530,7 +3725,7 @@ function createClaimAcceptCommand(makeSeams = DEFAULT_SEAMS2) {
 var accept_default = createClaimAcceptCommand();
 
 // src/commands/claim/hand.ts
-var USAGE9 = "rafa claim hand <n> --to=<store id> | rafa claim hand <n> --withdraw";
+var USAGE10 = "rafa claim hand <n> --to=<store id> | rafa claim hand <n> --withdraw";
 var COMMAND3 = "rafa claim hand";
 var TO_FLAG = "to";
 var WITHDRAW_FLAG = "withdraw";
@@ -3541,7 +3736,7 @@ function refuse3(message) {
 }
 function lineRefusal3(message) {
   return refuse3(`${message}
-Usage: ${USAGE9}`);
+Usage: ${USAGE10}`);
 }
 function readWithdraw(flags) {
   const value = flags[WITHDRAW_FLAG];
@@ -3594,7 +3789,7 @@ function recordFor(reading, request, issue, storeId) {
 }
 function handClaim(context, makeSeams) {
   const request = readHandRequest(context.flags);
-  const issue = readIssueArgument(context.args, USAGE9);
+  const issue = readIssueArgument(context.args, USAGE10);
   const project = requireProject(context, COMMAND3);
   const config = resolveProjectConfig(project, COMMAND3, (message) => context.output.warn(message));
   const seams = makeSeams(project.root, config);
@@ -3669,7 +3864,7 @@ function createClaimHandCommand(makeSeams = DEFAULT_SEAMS3) {
 var hand_default = createClaimHandCommand();
 
 // src/commands/claim/take.ts
-var USAGE10 = "rafa claim take <n> [--stale]";
+var USAGE11 = "rafa claim take <n> [--stale]";
 var COMMAND4 = "rafa claim take";
 var STALE_FLAG = "stale";
 var TAKING = { during: "was being taken over", nothing: "nothing was taken" };
@@ -3683,7 +3878,7 @@ function readStaleFlag(flags) {
   if (typeof value === "boolean")
     return value;
   throw refuse4(`--${STALE_FLAG} takes no value, and read "${value}" as one; type the issue number before the flags
-Usage: ${USAGE10}`);
+Usage: ${USAGE11}`);
 }
 function labelNote(weights) {
   return weights.labelWarning === null ? "" : ` (${weights.labelWarning}, so it reads as in development)`;
@@ -3766,7 +3961,7 @@ ${reasons.map((reason) => `   ${reason}`).join(`
 }
 async function takeClaim(context, makeSeams) {
   const stale = readStaleFlag(context.flags);
-  const issue = readIssueArgument(context.args, USAGE10);
+  const issue = readIssueArgument(context.args, USAGE11);
   const project = requireProject(context, COMMAND4);
   const config = resolveProjectConfig(project, COMMAND4, (message) => context.output.warn(message));
   const seams = makeSeams(project.root, config);
@@ -4199,7 +4394,7 @@ function worktreeData(row) {
 // src/commands/cleanup.ts
 var COMMAND_NAME4 = "rafa cleanup";
 var CLEANUP_USAGE = "rafa cleanup [--dry-run]";
-var DRY_RUN_FLAG = "dry-run";
+var DRY_RUN_FLAG2 = "dry-run";
 var CLEANUP_MESSAGE = "Tick what to remove (space ticks, a ticks a group, enter goes on)";
 var NOTHING_LISTED_TEXT = "Nothing to clean up: no branch or worktree is listed.";
 var NOTHING_REMOVED_TEXT = "Nothing removed.";
@@ -4207,14 +4402,14 @@ var DEFAULT_CLEANUP_SEAMS = Object.freeze({});
 function isBranchRow(row) {
   return "group" in row;
 }
-function counted(count, noun, pluralNoun) {
+function counted2(count, noun, pluralNoun) {
   return count === 1 ? `1 ${noun}` : `${String(count)} ${pluralNoun}`;
 }
 function cleanupQuestion(branches, worktrees) {
-  return `Delete ${counted(branches, "branch", "branches")} and remove ${counted(worktrees, "worktree", "worktrees")}? [y/N] `;
+  return `Delete ${counted2(branches, "branch", "branches")} and remove ${counted2(worktrees, "worktree", "worktrees")}? [y/N] `;
 }
 function notPushedQuestion(row) {
-  const commits = counted(row.commits, "commit", "commits");
+  const commits = counted2(row.commits, "commit", "commits");
   return `${row.branch.name} holds ${commits} no remote has, which deleting it loses. Delete ${row.branch.name}? [y/N] `;
 }
 function worktreeLabel(row, width) {
@@ -4286,7 +4481,7 @@ function writeOutcomes(context, outcomes) {
   const failed = outcomes.filter((outcome) => !outcome.ok).length;
   if (failed === 0)
     return;
-  throw new CommandExit(1, `\u274C ${COMMAND_NAME4}: ${counted(failed, "step", "steps")} of ${String(outcomes.length)} did not run clean; each is named above.`);
+  throw new CommandExit(1, `\u274C ${COMMAND_NAME4}: ${counted2(failed, "step", "steps")} of ${String(outcomes.length)} did not run clean; each is named above.`);
 }
 async function askAndRemove(run) {
   const { context, read, seams } = run;
@@ -4338,7 +4533,7 @@ async function readOrRefuse(seams, cleanup, settings) {
 }
 async function runCleanup(context, seams) {
   expectNoArgument(context.args, CLEANUP_USAGE);
-  const dryRun = readSwitch(DRY_RUN_FLAG, context.flags[DRY_RUN_FLAG], `Usage: ${CLEANUP_USAGE}`);
+  const dryRun = readSwitch(DRY_RUN_FLAG2, context.flags[DRY_RUN_FLAG2], `Usage: ${CLEANUP_USAGE}`);
   const project = projectOf6(context);
   const config = resolveProjectConfig(project, COMMAND_NAME4, (message) => {
     context.output.warn(message);
@@ -4379,7 +4574,7 @@ function createCleanupCommand(seams = DEFAULT_CLEANUP_SEAMS) {
     args: [],
     flags: [
       {
-        name: DRY_RUN_FLAG,
+        name: DRY_RUN_FLAG2,
         description: "Show the checklist and ask as usual, then print the `git` commands the answer would run" + " instead of running them. Removes nothing.",
         type: "boolean"
       }
@@ -6136,7 +6331,7 @@ function isUnmet(need) {
 // src/commands/plan/needs.ts
 import { isAbsolute as isAbsolute2, relative as relative4, resolve as resolve2 } from "path";
 var COMMAND5 = "rafa plan needs";
-var USAGE11 = "rafa plan needs [<plan> | --spec=<file> | --issue=<n>] [--missing] [--source=<source>]";
+var USAGE12 = "rafa plan needs [<plan> | --spec=<file> | --issue=<n>] [--missing] [--source=<source>]";
 var MISSING_HINT = `Type the plan first: ${COMMAND5} <plan> --missing`;
 var MET_MARK = "\u2713";
 var UNMET_MARK = "\u2717";
@@ -6151,7 +6346,7 @@ function readNeedsSource(value) {
     return value;
   const shown = typeof value === "string" ? `"${value}"` : "given no value";
   throw new CommandExit(1, `\u274C --source is ${shown}, expected one of: project, rafa, user, plugin:<name>, addon:<name>` + `
-Usage: ${USAGE11}`);
+Usage: ${USAGE12}`);
 }
 function specRouteWords(flags) {
   const words = ["spec", "issue"].flatMap((name) => {
@@ -6174,7 +6369,7 @@ function needsPlanPath(root, planDir, typed) {
     throw new CommandExit(1, `\u274C Plan file not found: ${path}`);
   const lookedFor = [...new Set([resolve2(root, planDir, DEFAULT_PLAN_FILE), resolve2(root, DEFAULT_PLAN_FILE)])];
   throw new CommandExit(1, `\u274C No plan named, and no default plan at ${lookedFor.join(" or ")}
-Usage: ${USAGE11}`);
+Usage: ${USAGE12}`);
 }
 function fromSource(need, source) {
   if (source === null)
@@ -6319,11 +6514,11 @@ async function routedSpec(words, project, config, seams) {
 async function runNeeds(context, seams) {
   const missing = readSwitch("missing", context.flags["missing"], MISSING_HINT);
   const source = readNeedsSource(context.flags["source"]);
-  const typed = expectAtMostOneArgument(context.args, USAGE11);
+  const typed = expectAtMostOneArgument(context.args, USAGE12);
   const words = specRouteWords(context.flags);
   if (typed !== null && words !== null) {
     throw new CommandExit(1, `\u274C ${typed} and ${words.join(" and ")} each name what to read; give one
-Usage: ${USAGE11}`);
+Usage: ${USAGE12}`);
   }
   const project = requireProject(context, COMMAND5);
   const { config, needs } = await readMachine(project, context, seams);
@@ -6934,7 +7129,7 @@ function renderDeep(reading) {
 }
 
 // src/commands/doctor-description.ts
-var DOCTOR_DESCRIPTION = "Checks the prerequisites `rafa loop start` checks before its first session and prints each" + " check, starting no run and storing nothing: the required and optional items of" + " `.rafa/config.yaml`, with the `PREREQUISITES-<stub>.md` beside the plan merged in, and, when the" + " repository resolves to `pr.provider: gh`, the two required items that provider adds ahead of them:" + " `gh` on PATH and `gh auth status` for the remote's host. A plan's `[start]` items are checked" + " after those and ahead of the configured tiers, on a first dispatch alone: a" + " `PLAN_TRACKER-<stub>.md` beside the plan already holding a ticked task makes the next run a" + " resume, which checks none of them and says in one line how many it passed over." + " The plan is the" + " one `--plan=<file>` names, relative to the project root, or the default plan `rafa loop start`" + ` runs. Each probe runs in the project root with stdin closed and a ${String(PROBE_TIMEOUT_MS / 1000)}-second` + " timeout. It exits 1 when a required item fails, naming the item, its probe and its exit code or" + " first line of stderr, where `rafa loop start` would halt. It reads the effort store as" + " `rafa effort schema --check` does, changing nothing, and prints its `effort store schema` row:" + " it exits 1 where that check fails, naming the next safe step, and warns on a migration this rafa" + " does not know that is additive and on one the project's own store logs as applied by a development" + " build. It prints its `effort sync` row, the strategy `effort.sync` names (`local` when unset) and" + " whether core or a loaded module serves it, and exits 1 when no adapter serves it, naming for" + " `git`, `service` and `p2p` the `modules:` and `allowList:` lines that load a module providing it." + " It exits 0 otherwise. It warns when" + " `.ralph/effort/` holds an effort store and `.rafa/effort/` holds none, and when `~/.rafa/bin` is" + " not on PATH ahead of `~/.bun/bin`, and when `previous/` under `specs.dir` holds more than fifty" + " previous copies of issue specs, which are safe to delete; a warning never changes the exit code. On a repository whose" + " provider is `gh` it also reads the GitHub board `rafa init --board` sets up and prints one row per" + " part \u2014 the seven labels, the spec issue template, the Roadmap issue and `roadmap.issue` \u2014 as present," + " missing, or unknown for a reading that failed, naming `rafa init --board` as the fix; it writes" + " nothing to the board and a row never changes the exit code. It then names, under `Blocked" + " issues:`, every open issue labelled `spec:blocked` whose `Blocked by:` line is missing, names no" + " issue, names itself, or names an id the board has no issue for, with what an author does about" + " it; that reading writes nothing and never changes the exit code either. It then names, under" + " `Epic labels:`, every issue carrying two `epic:` labels and every `epic:` label no `type:epic` issue" + " carries, read off one board listing, writing nothing and never changing the exit code. It then names, under" + " `Boards:`, every type:roadmap board whose Owner: handle resolves to nobody GitHub shows, every open issue titled" + ` "Roadmap" without type:roadmap while labelled boards exist, and every slot of this checkout's position on a` + " board or epic that is closed, unlabelled or gone, read off that same listing and printing nothing when there is" + " none; it writes nothing and never changes the exit code. It then counts, without" + " fetching, the branches and worktrees `rafa cleanup` would list, and prints them in one row naming" + " `rafa cleanup` when any group holds one. It then counts the suspect, dangling and unknown references" + " of every saved copy under `specs.dir`, writing nothing, and names `rafa issue check <n>` for each" + " copy holding a suspect or dangling one. Where the release is on, it then prints one `Release:` row naming" + " the version `origin/<pr.base>` declares as last fetched, the latest release tag, the version the changelog's" + " top heading names and the change fragments waiting on the base, as a warning naming `rafa release settle`" + " while any wait; it fetches nothing and never changes the exit code." + " It then prints, under `Skill tiers`, a warning per" + " skill or agent name two tiers hold with different contents, per unreviewed third-party rafa or" + " add-on item, and for an installed Claude Code other than the version skill serving was probed" + " against, and a note per byte-identical copy that can be deleted and per user-tier item with no" + " `provenance`; none changes the exit code. With `--output=json` the" + " checks, both readings, those rows, those issues, those labels and those boards are the data of the terminal result event," + " unless a required item failed. A plan `--plan` names also gets the one-line risk total" + " `rafa loop start` prints before its notices, which never changes the exit code. With `--deep` it" + " also prints the machine as a loop session sees it, starting no session: the session's" + " Environment and working directory against the shell's, the Settings each agent, skill and MCP" + " server is read from and whether a session sees it, the Providers `gh` answers under the session's" + " environment, and the Stack tools the project's stack needs, with Plan needs for a plan `--plan`" + " names; each row is ok, warn or note with its fix, printed after the blocked issues and before a" + " refusal, and none changes the exit code. With `--output=json` they are the `deep` of the data.";
+var DOCTOR_DESCRIPTION = "Checks the prerequisites `rafa loop start` checks before its first session and prints each" + " check, starting no run and storing nothing: the required and optional items of" + " `.rafa/config.yaml`, with the `PREREQUISITES-<stub>.md` beside the plan merged in, and, when the" + " repository resolves to `pr.provider: gh`, the two required items that provider adds ahead of them:" + " `gh` on PATH and `gh auth status` for the remote's host. A plan's `[start]` items are checked" + " after those and ahead of the configured tiers, on a first dispatch alone: a" + " `PLAN_TRACKER-<stub>.md` beside the plan already holding a ticked task makes the next run a" + " resume, which checks none of them and says in one line how many it passed over." + " The plan is the" + " one `--plan=<file>` names, relative to the project root, or the default plan `rafa loop start`" + ` runs. Each probe runs in the project root with stdin closed and a ${String(PROBE_TIMEOUT_MS / 1000)}-second` + " timeout. It exits 1 when a required item fails, naming the item, its probe and its exit code or" + " first line of stderr, where `rafa loop start` would halt. It reads the effort store as" + " `rafa effort schema --check` does, changing nothing, and prints its `effort store schema` row:" + " it exits 1 where that check fails, naming the next safe step, and warns on a migration this rafa" + " does not know that is additive and on one the project's own store logs as applied by a development" + " build. It prints its `effort sync` row, the strategy `effort.sync` names (`local` when unset) and" + " whether core or a loaded module serves it, and exits 1 when no adapter serves it, naming for" + " `git`, `service` and `p2p` the `modules:` and `allowList:` lines that load a module providing it." + " It exits 0 otherwise. It warns when" + " `.ralph/effort/` holds an effort store and `.rafa/effort/` holds none, and when `~/.rafa/bin` is" + " not on PATH ahead of `~/.bun/bin`, and when `previous/` under `specs.dir` holds more than fifty" + " previous copies of issue specs, which are safe to delete; a warning never changes the exit code. On a repository whose" + " provider is `gh` it also reads the GitHub board `rafa init --board` sets up and prints one row per" + " part \u2014 the seven labels, the spec issue template, the Roadmap issue and `roadmap.issue` \u2014 as present," + " missing, or unknown for a reading that failed, naming `rafa init --board` as the fix; it writes" + " nothing to the board and a row never changes the exit code. It then names, under `Blocked" + " issues:`, every open issue labelled `spec:blocked` whose `Blocked by:` line is missing, names no" + " issue, names itself, or names an id the board has no issue for, with what an author does about" + " it; that reading writes nothing and never changes the exit code either. It then names, under" + " `Epic labels:`, every issue carrying two `epic:` labels and every `epic:` label no `type:epic` issue" + " carries, read off one board listing, writing nothing and never changing the exit code. It then names, under" + " `Boards:`, every type:roadmap board whose Owner: handle resolves to nobody GitHub shows, every open issue titled" + ` "Roadmap" without type:roadmap while labelled boards exist, and every slot of this checkout's position on a` + " board or epic that is closed, unlabelled or gone, read off that same listing and printing nothing when there is" + " none; it writes nothing and never changes the exit code. Where `board.project.number` is set, it then" + " prints, under `GitHub project:`, the `project` scope, the project at that number and its five fields as" + " present, missing or unknown, each one not present naming its fix and a project in place naming" + " `rafa board sync --dry-run`; it reads no item and never changes the exit code. It then counts, without" + " fetching, the branches and worktrees `rafa cleanup` would list, and prints them in one row naming" + " `rafa cleanup` when any group holds one. It then counts the suspect, dangling and unknown references" + " of every saved copy under `specs.dir`, writing nothing, and names `rafa issue check <n>` for each" + " copy holding a suspect or dangling one. Where the release is on, it then prints one `Release:` row naming" + " the version `origin/<pr.base>` declares as last fetched, the latest release tag, the version the changelog's" + " top heading names and the change fragments waiting on the base, as a warning naming `rafa release settle`" + " while any wait; it fetches nothing and never changes the exit code." + " It then prints, under `Skill tiers`, a warning per" + " skill or agent name two tiers hold with different contents, per unreviewed third-party rafa or" + " add-on item, and for an installed Claude Code other than the version skill serving was probed" + " against, and a note per byte-identical copy that can be deleted and per user-tier item with no" + " `provenance`; none changes the exit code. With `--output=json` the" + " checks, both readings, those rows, those issues, those labels and those boards are the data of the terminal result event," + " unless a required item failed. A plan `--plan` names also gets the one-line risk total" + " `rafa loop start` prints before its notices, which never changes the exit code. With `--deep` it" + " also prints the machine as a loop session sees it, starting no session: the session's" + " Environment and working directory against the shell's, the Settings each agent, skill and MCP" + " server is read from and whether a session sees it, the Providers `gh` answers under the session's" + " environment, and the Stack tools the project's stack needs, with Plan needs for a plan `--plan`" + " names; each row is ok, warn or note with its fix, printed after the blocked issues and before a" + " refusal, and none changes the exit code. With `--output=json` they are the `deep` of the data.";
 
 // src/commands/doctor-effort-schema.ts
 import { join as join12 } from "path";
@@ -7135,15 +7330,485 @@ function writeInstall(context, install) {
   }
 }
 
+// src/commands/init-board-project-setting.ts
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync2 } from "fs";
+var PROJECT_NUMBER_SETTING = "board.project.number";
+var BOARD_KEY = /^board:\s*$/u;
+var PROJECT_KEY = /^ {2}project:\s*$/u;
+var ANY_PROJECT_KEY = /^ {2}project:/u;
+var NUMBER_KEY = /^ {4}number:/u;
+var COMMENTED_BOARD_KEY = /^#\s*board:\s*$/u;
+var COMMENTED_CHILD = /^# {2,}\S/u;
+var TOP_LEVEL = /^[^\s#]/u;
+var ABOVE_SECOND_LEVEL = /^ {0,3}[^\s#]/u;
+function settingLines(number, withProject) {
+  return withProject ? ["  project:", numberLine(number)] : [numberLine(number)];
+}
+function insertedAfter(lines, at, inserted) {
+  return [...lines.slice(0, at + 1), ...inserted, ...lines.slice(at + 1)];
+}
+function replacedAt(lines, at, line) {
+  return lines.map((held, index) => index === at ? line : held);
+}
+function matching(pattern) {
+  return (line) => pattern.test(line);
+}
+function matchingUncommented(pattern) {
+  return (line) => pattern.test(line.replace(/^# /u, ""));
+}
+function indexAfter(lines, from, end, test) {
+  const found = lines.slice(from + 1, end).findIndex(test);
+  return found < 0 ? -1 : from + 1 + found;
+}
+function blockEnd(lines, open, end, closes) {
+  const found = indexAfter(lines, open, end, closes);
+  return found < 0 ? end : found;
+}
+function numberLine(number) {
+  return `    number: ${String(number)}`;
+}
+function underOpenBoard(lines, open, number) {
+  const end = blockEnd(lines, open, lines.length, matching(TOP_LEVEL));
+  const project = indexAfter(lines, open, end, matching(PROJECT_KEY));
+  if (project < 0) {
+    return indexAfter(lines, open, end, matching(ANY_PROJECT_KEY)) < 0 ? insertedAfter(lines, open, settingLines(number, true)) : null;
+  }
+  const projectEnd = blockEnd(lines, project, end, matching(ABOVE_SECOND_LEVEL));
+  const held = indexAfter(lines, project, projectEnd, matching(NUMBER_KEY));
+  return held < 0 ? insertedAfter(lines, project, settingLines(number, false)) : replacedAt(lines, held, numberLine(number));
+}
+function underCommentedBoard(lines, open, number) {
+  const opened = replacedAt(lines, open, "board:");
+  const end = blockEnd(lines, open, lines.length, (line) => !COMMENTED_CHILD.test(line));
+  const project = indexAfter(lines, open, end, matchingUncommented(PROJECT_KEY));
+  if (project < 0)
+    return insertedAfter(opened, open, settingLines(number, true));
+  const projectEnd = blockEnd(lines, project, end, matchingUncommented(ABOVE_SECOND_LEVEL));
+  const held = indexAfter(lines, project, projectEnd, matchingUncommented(NUMBER_KEY));
+  const withProject = replacedAt(opened, project, "  project:");
+  return held < 0 ? insertedAfter(withProject, project, settingLines(number, false)) : replacedAt(withProject, held, numberLine(number));
+}
+function namesBoard(text) {
+  let document;
+  try {
+    document = Bun.YAML.parse(text);
+  } catch {
+    return false;
+  }
+  return isMapping(document) && Object.hasOwn(document, "board");
+}
+function appended(lines, block) {
+  const body = lines.at(-1) === "" ? lines.slice(0, -1) : [...lines];
+  return [...body, ...block, ""];
+}
+function withProjectNumber(text, number) {
+  const lines = text.split(`
+`);
+  const open = lines.findIndex((line) => BOARD_KEY.test(line));
+  if (open >= 0)
+    return underOpenBoard(lines, open, number)?.join(`
+`) ?? null;
+  if (namesBoard(text))
+    return null;
+  const commented = lines.findIndex((line) => COMMENTED_BOARD_KEY.test(line));
+  if (commented >= 0)
+    return underCommentedBoard(lines, commented, number).join(`
+`);
+  return appended(lines, ["board:", ...settingLines(number, true)]).join(`
+`);
+}
+function projectNumberIn(text, path) {
+  return parseConfigText(text, path).values.boardProjectNumber ?? null;
+}
+function readBackProblem(text, written, path, number) {
+  let before;
+  let after;
+  try {
+    before = parseConfigText(text, path);
+    after = parseConfigText(written, path);
+  } catch (error) {
+    return `does not parse: ${messageOf(error)}`;
+  }
+  const read = after.values.boardProjectNumber ?? null;
+  if (read !== number)
+    return `reads ${PROJECT_NUMBER_SETTING} as ${describeValue(read)}`;
+  const others = (file) => ({ values: { ...file.values, boardProjectNumber: null }, extras: file.extras });
+  return Bun.deepEquals(others(before), others(after), true) ? null : `reads a setting other than ${PROJECT_NUMBER_SETTING} differently, or a key no setting names`;
+}
+function settingPart(outcome, detail) {
+  return { kind: "setting", name: PROJECT_NUMBER_SETTING, outcome, detail };
+}
+function writeProjectNumber(root, number) {
+  const path = configFilePath(root);
+  let text;
+  let held;
+  try {
+    text = readFileSync6(path, "utf8");
+    held = projectNumberIn(text, path);
+  } catch (error) {
+    return settingPart("refused", `${path} could not be read: ${messageOf(error)}`);
+  }
+  if (held === number)
+    return settingPart("present", `${path} names project ${String(number)}`);
+  const written = withProjectNumber(text, number);
+  if (written === null) {
+    const why = `it spells board or board.project in a shape this command does not edit, so set ${PROJECT_NUMBER_SETTING}: ${String(number)} by hand`;
+    return settingPart("refused", `${path} was left as it was: ${why}`);
+  }
+  const problem = readBackProblem(text, written, path, number);
+  if (problem !== null)
+    return settingPart("refused", `${path} was left as it was: the file this run would have written ${problem}`);
+  try {
+    writeFileSync2(path, written, "utf8");
+  } catch (error) {
+    return settingPart("refused", `${path} could not be written: ${messageOf(error)}`);
+  }
+  return settingPart("created", `${path} now names project ${String(number)}`);
+}
+
+// src/commands/init-board-project.ts
+var PROJECT_STEP_FIX = "rafa init --board --project";
+var SCOPE_PART = "project scope";
+var COPY_PART = "project";
+var ITEMS_PART = "project issues";
+var FIELDS_PART = "project fields";
+var PROJECT_SCOPE = "project";
+var SCOPE_ARGS = Object.freeze(["auth", "status", "--active", "--json", "hosts"]);
+var LOGGED_IN = "success";
+function partOf(kind, name, outcome, detail) {
+  return { kind, name, outcome, detail };
+}
+function notTried(kinds, why) {
+  const names = {
+    scope: SCOPE_PART,
+    project: COPY_PART,
+    items: ITEMS_PART,
+    fields: FIELDS_PART,
+    setting: PROJECT_NUMBER_SETTING
+  };
+  return kinds.map((kind) => partOf(kind, names[kind], "refused", `not tried: ${why}`));
+}
+function scopeDetail() {
+  return `the gh token has no \`${PROJECT_SCOPE}\` scope; run \`${PROJECT_SCOPE_FIX}\`, then \`${PROJECT_STEP_FIX}\``;
+}
+function refusalOf(error) {
+  return isMissingProjectScope(error) ? scopeDetail() : messageOf(error);
+}
+function holdsProjectScope(hosts) {
+  if (!isMapping(hosts))
+    return false;
+  return Object.values(hosts).some((accounts) => Array.isArray(accounts) && accounts.some((account) => isMapping(account) && account["active"] === true && account["state"] === LOGGED_IN && typeof account["scopes"] === "string" && account["scopes"].split(",").map((scope) => scope.trim()).includes(PROJECT_SCOPE)));
+}
+async function readScopePart(gh) {
+  const command = `gh ${SCOPE_ARGS.join(" ")}`;
+  const result2 = await gh(SCOPE_ARGS);
+  if (!result2.ok) {
+    const written = result2.stderr.trim() || result2.stdout.trim() || "it wrote nothing";
+    return partOf("scope", SCOPE_PART, "refused", `${command} failed: ${written}; ${scopeDetail()}`);
+  }
+  let payload;
+  try {
+    payload = JSON.parse(result2.stdout);
+  } catch (error) {
+    return partOf("scope", SCOPE_PART, "refused", `${command} wrote output that is not JSON: ${messageOf(error)}`);
+  }
+  const hosts = isMapping(payload) ? payload["hosts"] : null;
+  return holdsProjectScope(hosts) ? partOf("scope", SCOPE_PART, "present", `the gh token holds the \`${PROJECT_SCOPE}\` scope`) : partOf("scope", SCOPE_PART, "refused", scopeDetail());
+}
+function projectRefOf(url) {
+  const match = /^https:\/\/github\.com\/(?:orgs|users)\/([A-Za-z0-9][A-Za-z0-9-]*)\/projects\/([1-9]\d*)$/u.exec(url);
+  if (match === null)
+    return null;
+  return { owner: match[1] ?? "", number: Number.parseInt(match[2] ?? "", 10) };
+}
+async function copyTemplate(port, config, repository, owner) {
+  const template = config.boardProjectTemplate;
+  const ref2 = projectRefOf(template);
+  if (ref2 === null) {
+    return { part: partOf("project", COPY_PART, "refused", `board.project.template is ${template}, not a project URL`), project: null };
+  }
+  const found = await port.find(ref2);
+  if (found === null) {
+    const why = `the template ${template} was not found; set board.project.template to a project the gh account can read`;
+    return { part: partOf("project", COPY_PART, "refused", why), project: null };
+  }
+  const title = repository.split("/")[1] ?? repository;
+  const project = await port.copy({ templateId: found.id, owner, title });
+  const copied = `copied ${template} to ${project.url}, titled ${title}`;
+  try {
+    await port.link(project.id, repository);
+  } catch (error) {
+    return { part: partOf("project", COPY_PART, "refused", `${copied}, but ${repository} was not linked: ${refusalOf(error)}`), project };
+  }
+  return { part: partOf("project", COPY_PART, "created", `${copied}, and linked ${repository}`), project };
+}
+async function copyStep(port, config, repository) {
+  const owner = repository.split("/")[0] ?? "";
+  try {
+    const number = config.boardProjectNumber;
+    const held = number === null ? null : await port.find({ owner, number });
+    if (held !== null)
+      return { part: partOf("project", COPY_PART, "present", held.url), project: held };
+    return await copyTemplate(port, config, repository, owner);
+  } catch (error) {
+    return { part: partOf("project", COPY_PART, "refused", refusalOf(error)), project: null };
+  }
+}
+function heldIssues(items, repository) {
+  const wanted = repository.toLowerCase();
+  return new Set(items.flatMap(({ content }) => content.kind === "issue" && content.repository.toLowerCase() === wanted ? [content.number] : []));
+}
+function issueCount(count) {
+  return count === 1 ? "1 issue" : `${String(count)} issues`;
+}
+async function missingIssues(options, repository, project) {
+  const { config, gh } = options;
+  const board = await readRefreshBoard(config, gh, repository);
+  const held = heldIssues(await createGhProjectPort(gh).items(project.id), repository);
+  const ranked = board.closed.filter((issue) => rankOf(board.ranks, issue) !== null);
+  const unread = board.closed.filter((issue) => rankOf(board.ranks, issue) === null && !held.has(issue));
+  const facts = await readIssueFacts({ gh, fragments: config.releaseFragments }, unread);
+  const inReview = unread.filter((issue) => {
+    const read = facts.get(issue);
+    return read !== undefined && stageOf(read) === "In review";
+  });
+  return [...new Set([...board.open, ...ranked, ...inReview])].filter((issue) => !held.has(issue)).sort((a, b) => a - b);
+}
+async function itemsStep(options, repository, project) {
+  const sleep = options.sleep ?? ((ms) => Bun.sleep(ms));
+  let missing;
+  try {
+    missing = await missingIssues(options, repository, project);
+  } catch (error) {
+    return partOf("items", ITEMS_PART, "refused", `the issues to add could not be read: ${refusalOf(error)}`);
+  }
+  if (missing.length === 0)
+    return partOf("items", ITEMS_PART, "present", "the project holds every issue it shows");
+  const port = createGhProjectPort(options.gh);
+  let added = 0;
+  try {
+    for (const number of missing) {
+      if (added > 0)
+        await sleep(PROJECT_WRITE_PAUSE_MS);
+      await port.addItem(project.id, { repository, number });
+      added += 1;
+    }
+  } catch (error) {
+    const went = `${issueCount(added)} of ${String(missing.length)} added`;
+    return partOf("items", ITEMS_PART, "refused", `${went}, then #${String(missing[added])} was refused: ${refusalOf(error)}; run \`${PROJECT_STEP_FIX}\` to add the rest`);
+  }
+  return partOf("items", ITEMS_PART, "created", `added ${issueCount(added)} to the project`);
+}
+async function fieldsStep(options, project) {
+  const config = { ...options.config, boardProjectNumber: project.number };
+  const refreshOptions = options.sleep === undefined ? { config, gh: options.gh } : { config, gh: options.gh, sleep: options.sleep };
+  let refreshed;
+  try {
+    refreshed = await refreshProjectItems(refreshOptions, [], { everyItem: true });
+  } catch (error) {
+    return { part: partOf("fields", FIELDS_PART, "refused", refusalOf(error)), problems: [] };
+  }
+  if (refreshed.kind === "refused")
+    return { part: partOf("fields", FIELDS_PART, "refused", scopeDetail()), problems: [] };
+  if (refreshed.kind !== "refreshed") {
+    return { part: partOf("fields", FIELDS_PART, "refused", refreshed.warnings.join(" ") || "the refresh sent no call"), problems: [] };
+  }
+  const { writes, changes, skipped } = refreshed;
+  const problems = refreshed.warnings.slice(writes.rateLimited ? 1 : 0);
+  if (writes.rateLimited) {
+    return { part: partOf("fields", FIELDS_PART, "refused", rateLimitWarning(writes.notUpdated)), problems };
+  }
+  if (changes.length === 0) {
+    const held = skipped.length === 0 ? "every value is as the rules give it" : "every value written is as the rules give it";
+    return { part: partOf("fields", FIELDS_PART, "present", held), problems };
+  }
+  const issues = new Set(changes.map(({ issue }) => issue)).size;
+  const values = writes.written === 1 ? "1 value" : `${String(writes.written)} values`;
+  return { part: partOf("fields", FIELDS_PART, "created", `wrote ${values} to ${issueCount(issues)}`), problems };
+}
+async function onProject(options, repository, project) {
+  const items = await itemsStep(options, repository, project);
+  const fields = await fieldsStep(options, project);
+  const setting = writeProjectNumber(options.root, project.number);
+  return { parts: [items, fields.part, setting], problems: fields.problems };
+}
+async function setUpProject(options) {
+  const { gh, config } = options;
+  const scope = await readScopePart(gh);
+  if (scope.outcome === "refused") {
+    return { parts: [scope, ...notTried(["project", "items", "fields", "setting"], "the gh token has no project scope")], project: null, problems: [] };
+  }
+  let repository;
+  try {
+    repository = await readBoardRepository(gh);
+  } catch (error) {
+    const why = messageOf(error);
+    return { parts: [scope, partOf("project", COPY_PART, "refused", why), ...notTried(["items", "fields", "setting"], "no project")], project: null, problems: [] };
+  }
+  const copied = await copyStep(createGhProjectPort(gh), config, repository);
+  if (copied.project === null) {
+    return { parts: [scope, copied.part, ...notTried(["items", "fields", "setting"], "no project")], project: null, problems: [] };
+  }
+  const { project } = copied;
+  const rest = await onProject(options, repository, project);
+  return {
+    parts: [scope, copied.part, ...rest.parts],
+    project: { owner: project.owner, number: project.number, url: project.url },
+    problems: rest.problems
+  };
+}
+function projectSetupChanged(report2) {
+  return report2.parts.some((part) => part.outcome === "created");
+}
+var PROJECT_HEADING = "GitHub project:";
+var OUTCOME_WIDTH3 = 7;
+function projectPartLine(part) {
+  const row = `  ${part.outcome.padEnd(OUTCOME_WIDTH3, " ")}  ${part.name}`;
+  return part.outcome === "present" ? row : `${row}: ${part.detail}`;
+}
+function renderProjectSetup(report2) {
+  return [PROJECT_HEADING, ...report2.parts.map((part) => projectPartLine(part)), ...report2.problems];
+}
+var PROJECT_QUESTION = "Also create a GitHub project with roadmap and kanban views? [y/N] ";
+var PROJECT_NO_BOARD_WARNING = "--project creates the GitHub project with the GitHub board," + ` and the board step did not run, so no project was created; run ${PROJECT_STEP_FIX}.`;
+function noProject(status, asked, warnings = []) {
+  return { status, asked, report: null, warnings: Object.freeze([...warnings]) };
+}
+async function askProject(openPrompter) {
+  const prompter = openPrompter();
+  try {
+    const answer = await prompter.ask(PROJECT_QUESTION);
+    return answer !== null && YES_ANSWERS.includes(answer.trim().toLowerCase());
+  } finally {
+    prompter.close();
+  }
+}
+function withWrittenRoadmap(root, config) {
+  const written = readRoadmapSetting(root).issue;
+  return written === null ? config : { ...config, roadmapIssue: written };
+}
+async function runProjectStep(options) {
+  const { wanted, board, root, isTerminal, openPrompter } = options;
+  if (board.status !== "ran") {
+    return noProject("not-run", false, wanted === true ? [PROJECT_NO_BOARD_WARNING] : []);
+  }
+  if (wanted === false)
+    return noProject("declined", false);
+  const run = async (asked) => {
+    const setUp = options.setUp ?? setUpProject;
+    const report2 = await setUp({ root, config: withWrittenRoadmap(root, options.config), gh: options.openGh() });
+    return { status: "ran", asked, report: report2, warnings: [] };
+  };
+  if (wanted === true)
+    return run(false);
+  if (!isTerminal())
+    return noProject("unasked", false);
+  return await askProject(openPrompter) ? run(true) : noProject("declined", true);
+}
+function projectStepChanged(result2) {
+  return result2.report !== null && projectSetupChanged(result2.report);
+}
+function renderProjectStep(result2) {
+  if (result2.report !== null)
+    return renderProjectSetup(result2.report);
+  if (result2.status === "declined")
+    return [`The GitHub project was left out; run ${PROJECT_STEP_FIX} to create it.`];
+  if (result2.status === "unasked")
+    return [`The GitHub project question needs a terminal; run ${PROJECT_STEP_FIX} to create it.`];
+  return [];
+}
+
+// src/commands/doctor-project.ts
+var SCOPE_ROW = "project scope";
+var PROJECT_ROW = "project";
+var FIELDS_ROW = "project fields";
+var DRIFT_CHECK = "rafa board sync --dry-run";
+var OUTCOME_WIDTH4 = 7;
+function rowOf2(kind, name, outcome, detail) {
+  return { kind, name, outcome, detail };
+}
+function noScope() {
+  return `the gh token has no \`${PROJECT_SCOPE}\` scope; run \`${PROJECT_SCOPE_FIX}\``;
+}
+async function readScopeRow(gh) {
+  const command = `gh ${SCOPE_ARGS.join(" ")}`;
+  const result2 = await gh(SCOPE_ARGS);
+  if (!result2.ok) {
+    const written = result2.stderr.trim() || result2.stdout.trim() || "it wrote nothing";
+    return rowOf2("scope", SCOPE_ROW, "unknown", `${command} failed: ${written}`);
+  }
+  let payload;
+  try {
+    payload = JSON.parse(result2.stdout);
+  } catch (error) {
+    return rowOf2("scope", SCOPE_ROW, "unknown", `${command} wrote output that is not JSON: ${messageOf(error)}`);
+  }
+  const hosts = isMapping(payload) ? payload["hosts"] : null;
+  return holdsProjectScope(hosts) ? rowOf2("scope", SCOPE_ROW, "present", `the gh token holds the \`${PROJECT_SCOPE}\` scope`) : rowOf2("scope", SCOPE_ROW, "missing", noScope());
+}
+function notRead(kind, name, before) {
+  return rowOf2(kind, name, "unknown", `not read: the ${before.name} row is ${before.outcome}`);
+}
+async function readProjectStep(gh, number) {
+  const name = `${PROJECT_ROW} ${String(number)}`;
+  try {
+    const owner = (await readBoardRepository(gh)).split("/")[0] ?? "";
+    const project = await createGhProjectPort(gh).find({ owner, number });
+    if (project === null) {
+      const why = `board.project.number ${String(number)} names no project of ${owner}; run \`${PROJECT_STEP_FIX}\` to make one`;
+      return { row: rowOf2("project", name, "missing", why), project: null };
+    }
+    return { row: rowOf2("project", name, "present", project.url), project };
+  } catch (error) {
+    const row = isMissingProjectScope(error) ? rowOf2("project", name, "missing", noScope()) : rowOf2("project", name, "unknown", messageOf(error));
+    return { row, project: null };
+  }
+}
+function fieldsRow(project, template) {
+  const { mismatched } = matchProjectFields(project);
+  if (mismatched.length === 0)
+    return rowOf2("fields", FIELDS_ROW, "present", "the five fields carry the template's names and options");
+  const sentences = mismatched.map((mismatch) => mismatch.sentence).join(" ");
+  const skipped = mismatched.length === 1 ? "that field" : "those fields";
+  const fix = `Give the project the fields and options of board.project.template (${template}); until then the refresh skips ${skipped}.`;
+  return rowOf2("fields", FIELDS_ROW, "missing", `${sentences} ${fix}`);
+}
+async function readDoctorProject(input) {
+  const { gh, number, template } = input;
+  if (gh === null || number === null)
+    return null;
+  const scope = await readScopeRow(gh);
+  if (scope.outcome !== "present") {
+    const project = notRead("project", `${PROJECT_ROW} ${String(number)}`, scope);
+    return { number, rows: [scope, project, notRead("fields", FIELDS_ROW, project)] };
+  }
+  const step = await readProjectStep(gh, number);
+  const fields = step.project === null ? notRead("fields", FIELDS_ROW, step.row) : fieldsRow(step.project, template);
+  return { number, rows: [scope, step.row, fields] };
+}
+function projectRowLine(row) {
+  const line = `  ${row.outcome.padEnd(OUTCOME_WIDTH4, " ")}  ${row.name}`;
+  if (row.outcome !== "present")
+    return `${line}: ${row.detail}`;
+  return row.kind === "project" ? `${line}: ${row.detail}` : line;
+}
+function renderDoctorProject(reading) {
+  if (reading === null)
+    return [];
+  const inPlace = reading.rows.every((row) => row.outcome === "present");
+  const drift = inPlace ? [`Run ${DRIFT_CHECK} to check the project for drift.`] : [];
+  return [PROJECT_HEADING, ...reading.rows.map(projectRowLine), ...drift];
+}
+
 // src/commands/doctor-release.ts
-import { readFileSync as readFileSync6 } from "fs";
+import { readFileSync as readFileSync7 } from "fs";
 import { join as join14 } from "path";
 var SETTLE_COMMAND = "rafa release settle";
 var UNREAD = "?";
 function readTopHeading(root, configured) {
   const resolved = join14(root, configured);
   try {
-    const text = readFileSync6(resolved, "utf8");
+    const text = readFileSync7(resolved, "utf8");
     return { path: configured, version: changelogVersions(text)[0] ?? null, problem: null };
   } catch {
     return { path: configured, version: null, problem: `the changelog could not be read at ${resolved}` };
@@ -7186,8 +7851,8 @@ function waitingPart(waiting) {
     return "no fragment waits";
   const ids = waiting.fragments.map((each) => each.id);
   const named = ids.length === 0 ? "" : ` (${ids.join(", ")})`;
-  const counted2 = count === 1 ? "1 fragment waits" : `${String(count)} fragments wait`;
-  return `${counted2}${named}: ${forecastPhrase(waiting)}; run ${SETTLE_COMMAND} to fold them into one version`;
+  const counted3 = count === 1 ? "1 fragment waits" : `${String(count)} fragments wait`;
+  return `${counted3}${named}: ${forecastPhrase(waiting)}; run ${SETTLE_COMMAND} to fold them into one version`;
 }
 function releaseRow(reading) {
   const { waiting } = reading;
@@ -7225,14 +7890,14 @@ function writeDoctorRelease(context, reading) {
 }
 
 // src/commands/doctor-tiers.ts
-import { readFileSync as readFileSync7, realpathSync as realpathSync2 } from "fs";
+import { readFileSync as readFileSync8, realpathSync as realpathSync2 } from "fs";
 import { basename as basename4, dirname as dirname2 } from "path";
 var TIERS_SECTION_TITLE = "Skill tiers";
 var CLAUDE_VERSION_TIMEOUT_MS = 1e4;
 var VERSION_PATTERN = /^\s*(\d+\.\d+\.\d+)/;
 function readTextFile(path) {
   try {
-    return readFileSync7(path, "utf8");
+    return readFileSync8(path, "utf8");
   } catch {
     return null;
   }
@@ -7531,6 +8196,7 @@ function resultOf(preflight, install, readings, deep) {
     epics: readings.epics,
     boards: readings.boards,
     ...relationsResultOf(readings),
+    project: readings.project,
     cleanup: readings.cleanup,
     refs: readings.refs,
     release: readings.release,
@@ -7575,10 +8241,12 @@ async function runDoctor(context, seams) {
     const effortSync = await readDoctorEffortSync({ root: project.root, home: project.home, resolved: preflight.resolved }, seams);
     const modeSet = preflight.resolved.sources.boardRelationships !== "default";
     const board = await readDoctorBoard(gh, project.root, preflight.config.roadmapIssue, preflight.config.boardRelationships, modeSet);
-    const readings = { ...board, cleanup, refs, release, tiers, effortSchema, effortSync };
+    const { boardProjectNumber: number, boardProjectTemplate: template } = preflight.config;
+    const projectRows = await readDoctorProject({ gh, number, template });
+    const readings = { ...board, project: projectRows, cleanup, refs, release, tiers, effortSchema, effortSync };
     writeText(context, renderDoctor(preflight));
     await announceRisk(context, preflight, seams);
-    const repository = [...renderDoctorBoard(readings), ...renderDoctorCleanup(readings.cleanup)];
+    const repository = [...renderDoctorBoard(readings), ...renderDoctorProject(projectRows), ...renderDoctorCleanup(readings.cleanup)];
     writeText(context, [...repository, ...renderDoctorRefs(readings.refs)]);
     writeDoctorRelease(context, release);
     writeText(context, renderDoctorTiers(readings.tiers));
@@ -8054,10 +8722,10 @@ function readDashboard(options) {
 
 // src/commands/effort/dashboard.ts
 var COMMAND_NAME6 = "rafa effort dashboard";
-var USAGE12 = "rafa effort dashboard [--days=<n>] [--recent=<n>] [--loops=<n>] [--by=effort|model|agent]";
+var USAGE13 = "rafa effort dashboard [--days=<n>] [--recent=<n>] [--loops=<n>] [--by=effort|model|agent]";
 var TREND_FLAGS = ["days", "recent", "loops", "by"];
 function refuse5(problems) {
-  throw new CommandExit(1, [...problems.map((problem) => `\u274C ${COMMAND_NAME6}: ${problem}`), `Usage: ${USAGE12}`].join(`
+  throw new CommandExit(1, [...problems.map((problem) => `\u274C ${COMMAND_NAME6}: ${problem}`), `Usage: ${USAGE13}`].join(`
 `));
 }
 function trendOptionsOf(context) {
@@ -8073,7 +8741,7 @@ function trendOptionsOf(context) {
   return parsed.trend;
 }
 function runDashboard(context, seams) {
-  expectNoArgument(context.args, USAGE12);
+  expectNoArgument(context.args, USAGE13);
   const root = requireProject(context, COMMAND_NAME6).root;
   const trend = trendOptionsOf(context);
   let dashboard;
@@ -8150,7 +8818,7 @@ import { resolve as resolve6 } from "path";
 import { join as join16, resolve as resolve5 } from "path";
 var COMMAND_NAME7 = "rafa effort merge";
 var MERGE_USAGE = "rafa effort merge <file> [--dry-run]";
-var DRY_RUN_FLAG2 = "dry-run";
+var DRY_RUN_FLAG3 = "dry-run";
 var REFUSED_EXIT2 = 1;
 var UNMERGEABLE_EXIT = 2;
 var UNMERGEABLE_REASONS = new Set(["other-project", "ndjson"]);
@@ -8167,7 +8835,7 @@ function tableLine(entry) {
   ];
   return `  ${entry.table}: ${counts.join(", ")}`;
 }
-function closingLine(result2, command) {
+function closingLine2(result2, command) {
   if (result2.status === "would-merge") {
     return "\uD83D\uDD0D Dry run: the merged store was built beside it, checked (row counts, integrity_check, this rafa's" + ` schema plan) and deleted. Run \`${command} ${result2.otherPath}\` to swap it in; the original would be` + ` kept whole at ${result2.path}.before-merge-<stamp>.bak.`;
   }
@@ -8181,7 +8849,7 @@ function renderMerge(result2, command = COMMAND_NAME7) {
     ...forward,
     ...result2.tables.map(tableLine),
     `Total: ${String(result2.rowsAdded)} added, ${String(result2.rowsSkipped)} skipped,` + ` ${String(result2.rowsInConflict)} in conflict; ${String(result2.gapsRewritten)} commit gaps recomputed.`,
-    closingLine(result2, command)
+    closingLine2(result2, command)
   ];
 }
 function mergeTargetPath(context, root, command = COMMAND_NAME7) {
@@ -8210,7 +8878,7 @@ function probeSeams(seams) {
 }
 function runMerge(context, seams) {
   const file = expectOneArgument(context.args, MERGE_USAGE);
-  const dryRun = readSwitch(DRY_RUN_FLAG2, context.flags[DRY_RUN_FLAG2], `Usage: ${MERGE_USAGE}`);
+  const dryRun = readSwitch(DRY_RUN_FLAG3, context.flags[DRY_RUN_FLAG3], `Usage: ${MERGE_USAGE}`);
   const project = requireProject(context, COMMAND_NAME7);
   const path = mergeTargetPath(context, project.root);
   const backend = resolveProjectConfig(project, COMMAND_NAME7, (message) => context.output.warn(message)).store;
@@ -8246,7 +8914,7 @@ function createMergeCommand(seams = {}) {
     ],
     flags: [
       {
-        name: DRY_RUN_FLAG2,
+        name: DRY_RUN_FLAG3,
         description: "Build and check the merged store, print what it would add, then delete it. This store is" + " only read, so this runs beside a live loop and from a development build, and can be repeated.",
         type: "boolean"
       }
@@ -8274,7 +8942,7 @@ var merge_default = createMergeCommand();
 // src/commands/effort/import.ts
 var COMMAND_NAME8 = "rafa effort import";
 var IMPORT_USAGE = "rafa effort import <file> [--dry-run]";
-var DRY_RUN_FLAG3 = "dry-run";
+var DRY_RUN_FLAG4 = "dry-run";
 function syncOptions(context, repoRoot, backend, seams) {
   const optional = {
     now: seams.now,
@@ -8301,7 +8969,7 @@ async function pull(sync, otherPath, dryRun) {
 }
 async function runImport(context, seams) {
   const file = expectOneArgument(context.args, IMPORT_USAGE);
-  const dryRun = readSwitch(DRY_RUN_FLAG3, context.flags[DRY_RUN_FLAG3], `Usage: ${IMPORT_USAGE}`);
+  const dryRun = readSwitch(DRY_RUN_FLAG4, context.flags[DRY_RUN_FLAG4], `Usage: ${IMPORT_USAGE}`);
   const project = requireProject(context, COMMAND_NAME8);
   mergeTargetPath(context, project.root, COMMAND_NAME8);
   const backend = resolveProjectConfig(project, COMMAND_NAME8, (message) => context.output.warn(message)).store;
@@ -8332,7 +9000,7 @@ function createImportCommand(seams = {}) {
     ],
     flags: [
       {
-        name: DRY_RUN_FLAG3,
+        name: DRY_RUN_FLAG4,
         description: "Build and check the merged store, print what it would add, then delete it. This store is" + " only read, so this runs beside a live loop and from a development build, and can be repeated.",
         type: "boolean"
       }
@@ -8360,7 +9028,7 @@ var import_default = createImportCommand();
 import { join as join17 } from "path";
 var COMMAND_NAME9 = "rafa effort migrate";
 var MIGRATE_USAGE = "rafa effort migrate [--dry-run]";
-var DRY_RUN_FLAG4 = "dry-run";
+var DRY_RUN_FLAG5 = "dry-run";
 var REFUSED_EXIT3 = 1;
 function builtLines(result2) {
   const rows = result2.counted.reduce((sum, table) => sum + table.rows, 0);
@@ -8397,7 +9065,7 @@ function storePath(context, root) {
 }
 function runMigrate(context, seams) {
   expectNoArgument(context.args, MIGRATE_USAGE);
-  const dryRun = readSwitch(DRY_RUN_FLAG4, context.flags[DRY_RUN_FLAG4], `Usage: ${MIGRATE_USAGE}`);
+  const dryRun = readSwitch(DRY_RUN_FLAG5, context.flags[DRY_RUN_FLAG5], `Usage: ${MIGRATE_USAGE}`);
   const path = storePath(context, requireProject(context, COMMAND_NAME9).root);
   const now = seams.now ?? (() => new Date);
   let result2;
@@ -8435,7 +9103,7 @@ function createMigrateCommand(seams = {}) {
     args: [],
     flags: [
       {
-        name: DRY_RUN_FLAG4,
+        name: DRY_RUN_FLAG5,
         description: "Build and check the migrated store, print what it applies, then delete it. The live store" + " is only read, so this runs beside a live loop and from a development build, and can be repeated.",
         type: "boolean"
       }
@@ -8461,7 +9129,7 @@ function createMigrateCommand(seams = {}) {
 var migrate_default = createMigrateCommand();
 
 // src/effort/store/move.ts
-import { readFileSync as readFileSync8, writeFileSync as writeFileSync2 } from "fs";
+import { readFileSync as readFileSync9, writeFileSync as writeFileSync3 } from "fs";
 var MOVED_KINDS = Object.freeze(["sessions", "commits"]);
 var MOVE_TARGET = "sqlite";
 var STORE_LINE = `store: ${MOVE_TARGET}`;
@@ -8503,7 +9171,7 @@ function withSqliteStoreSetting(text) {
 function plannedConfig(path) {
   let text;
   try {
-    text = readFileSync8(path, "utf8");
+    text = readFileSync9(path, "utf8");
   } catch (error) {
     throw new MoveRefusal("config", `${path} could not be read: ${messageOf(error)}. Nothing was moved.`);
   }
@@ -8543,22 +9211,22 @@ function moveKind(kind, source, target) {
   const { keyed, unkeyed } = keyedRows(kind, reading.rows);
   const project = EFFORT_KEY_PROJECTIONS[kind];
   const before = target.keys(kind).size;
-  const appended = target.append(kind, keyed);
+  const appended2 = target.append(kind, keyed);
   const keys = keyed.map((row2) => project(row2) ?? "");
-  checkCounts(kind, before, appended.appended, keys, target.keys(kind));
+  checkCounts(kind, before, appended2.appended, keys, target.keys(kind));
   return {
     kind,
     from: source.path(kind),
     read: keyed.length,
-    added: appended.appended,
-    skipped: appended.skipped,
+    added: appended2.appended,
+    skipped: appended2.skipped,
     unkeyed,
     unparsed: reading.unparsedLineCount
   };
 }
 function writeConfig(path, text) {
   try {
-    writeFileSync2(path, text, "utf8");
+    writeFileSync3(path, text, "utf8");
   } catch (error) {
     throw new MoveRefusal("config", `${path} could not be written (${messageOf(error)}). The rows were moved and checked; set ${STORE_LINE}` + " there by hand, or run the move again, which adds nothing.");
   }
@@ -8884,6 +9552,93 @@ function keptLinksLine(issue, waitsOn) {
   return `${ref2(issue)} keeps its blocked-by ${links} to ${waitsOn.map(ref2).join(" ")}: in native mode the cancel clears` + " nothing, and GitHub stops holding an issue back once its blocker closes.";
 }
 
+// src/board/project/add-issue.ts
+async function addItem(gh, number, issue) {
+  const repository = await readBoardRepository(gh);
+  const ref3 = { owner: repository.split("/")[0] ?? "", number };
+  const port = createGhProjectPort(gh);
+  const project = await port.find(ref3);
+  if (project === null)
+    return notFoundWarning(ref3);
+  await port.addItem(project.id, { repository, number: issue });
+  return null;
+}
+async function addAndRefreshIssue(options, issue) {
+  const { config, openGh, refresh = refreshProjectItems } = options;
+  if (config.boardProjectNumber === null)
+    return [];
+  const gh = openGh();
+  try {
+    const refused = await addItem(gh, config.boardProjectNumber, issue);
+    if (refused !== null)
+      return [refused];
+    const refreshOptions = options.sleep === undefined ? { config, gh } : { config, gh, sleep: options.sleep };
+    return (await refresh(refreshOptions, [issue])).warnings;
+  } catch (error) {
+    return isMissingProjectScope(error) ? [scopeWarning()] : [refreshFailedWarning(issue, error)];
+  }
+}
+
+// src/commands/epic/epic-project.ts
+function oneLine2(message) {
+  return message.replace(/^\u274C\s*/u, "").split(`
+`).map((line) => line.trim()).filter((line) => line !== "").join(" ");
+}
+function epicProjectProblemLine(issues, problem) {
+  const named = issues.map((issue) => `#${String(issue)}`).join(", ");
+  return `The project was not updated for ${named}: ${oneLine2(problem)}. Run \`${BOARD_SYNC_FIX}\` to catch up.`;
+}
+function newEpicTarget(result2) {
+  return { epics: [result2.epic.number], issues: [], added: result2.epic.number };
+}
+function horizonTarget(result2) {
+  return result2.status === "moved" ? { epics: [result2.epic], issues: [], added: null } : null;
+}
+function moveTarget(result2) {
+  return result2.outcome === null ? null : { epics: [result2.from, result2.to], issues: [result2.issue], added: null };
+}
+function cancelTarget(result2) {
+  if (result2.status !== "cancelled")
+    return null;
+  const moves = result2.applied.flatMap(({ answer }) => answer.kind === "moved" ? [answer.from, answer.to] : []);
+  return { epics: [result2.epic, ...moves], issues: result2.applied.map(({ issue }) => issue), added: null };
+}
+function closeTarget(result2) {
+  return { epics: [result2.epic], issues: [], added: null };
+}
+async function refreshLines(config, openGh, refresh, target, named) {
+  const widening = { membersOf: target.epics, shiftedRanks: true };
+  if (target.added !== null) {
+    return addAndRefreshIssue({ config, openGh, refresh: (options, issues) => refresh(options, [...new Set([...issues, ...named])], widening) }, target.added);
+  }
+  try {
+    return (await refresh({ config, gh: openGh() }, named, widening)).warnings;
+  } catch (error) {
+    return [epicProjectProblemLine(named, messageOf(error))];
+  }
+}
+async function refreshProjectAfterEpic(context, seams, target) {
+  if (target === null)
+    return null;
+  const project = issueProject(context);
+  const named = [...new Set([...target.epics, ...target.issues])];
+  let warnings;
+  try {
+    const config = issueSubjectConfig(project, () => {
+      return;
+    });
+    if (config.boardProjectNumber === null)
+      return null;
+    const openGh = () => seams.gh ?? createGhRunner({ cwd: project.root });
+    warnings = await refreshLines(config, openGh, seams.projectRefresh ?? refreshIssueItems, target, named);
+  } catch (error) {
+    warnings = [epicProjectProblemLine(named, messageOf(error))];
+  }
+  for (const line of warnings)
+    context.output.warn(line);
+  return { issues: named, membersOf: target.epics, added: target.added, warnings };
+}
+
 // src/board/epic-horizon.ts
 var EPIC_HORIZON_REFUSAL_EXIT = 2;
 var BRANCH_REF = /^refs\/(?:heads\/|remotes\/[^/]+\/)/u;
@@ -9019,11 +9774,11 @@ function readHorizonLine(context, action) {
   const reason = readTextFlag(flags, REASON_FLAG, action.usage) ?? null;
   return Object.freeze({ epic: Number(word), to, reason });
 }
-function rankOf(horizon) {
+function rankOf2(horizon) {
   return HORIZONS.indexOf(horizon);
 }
 function wrongDirection(action, change) {
-  const later = rankOf(change.to) > rankOf(change.from);
+  const later = rankOf2(change.to) > rankOf2(change.from);
   if (later === (action.name === "defer"))
     return null;
   const other = action.name === "defer" ? "promote" : "defer";
@@ -9176,25 +9931,24 @@ function closeFailure(result2) {
 async function runEpicHorizon(context, action, seams) {
   const result2 = await changeEpicHorizon(context, action, seams);
   const failure = closeFailure(result2);
-  if (context.outputMode === "json") {
-    if (failure !== null)
-      throw failure;
-    context.output.result(result2);
-    return;
-  }
-  for (const line of renderEpicHorizon(result2)) {
-    if (line.warn)
-      context.output.warn(line.text);
-    else
-      context.output.info(line.text);
+  if (context.outputMode !== "json") {
+    for (const line of renderEpicHorizon(result2)) {
+      if (line.warn)
+        context.output.warn(line.text);
+      else
+        context.output.info(line.text);
+    }
   }
+  await refreshProjectAfterEpic(context, seams, horizonTarget(result2));
   if (failure !== null)
     throw failure;
+  if (context.outputMode === "json")
+    context.output.result(result2);
 }
 
 // src/commands/epic/move.ts
 var EPIC_MOVE_REFUSAL_EXIT = 2;
-var USAGE13 = 'rafa epic move <issue> --to=<epic> [--reason="<why>"]';
+var USAGE14 = 'rafa epic move <issue> --to=<epic> [--reason="<why>"]';
 var ISSUE_NUMBER4 = /^[1-9]\d*$/u;
 function isNativeReading(reading) {
   return "relationships" in reading;
@@ -9207,7 +9961,7 @@ function refusal5(message) {
 }
 function issueNumber(word, what) {
   if (!ISSUE_NUMBER4.test(word))
-    throw lineRefusal(`"${word}" is no ${what}, which is a whole number from 1`, USAGE13);
+    throw lineRefusal(`"${word}" is no ${what}, which is a whole number from 1`, USAGE14);
   return Number(word);
 }
 function readMoveLine(context) {
@@ -9215,14 +9969,14 @@ function readMoveLine(context) {
   const [word] = args;
   if (args.length !== 1 || word === undefined) {
     const got = args.length === 0 ? "none" : `${String(args.length)}: ${args.join(" ")}`;
-    throw lineRefusal(`Expected one issue number, got ${got}`, USAGE13);
+    throw lineRefusal(`Expected one issue number, got ${got}`, USAGE14);
   }
   const issue = issueNumber(word, "issue number");
-  const target = readTextFlag(flags, TO_FLAG4, USAGE13);
+  const target = readTextFlag(flags, TO_FLAG4, USAGE14);
   if (target === undefined)
-    throw lineRefusal(`--${TO_FLAG4} is required: --${TO_FLAG4}=<epic>`, USAGE13);
+    throw lineRefusal(`--${TO_FLAG4} is required: --${TO_FLAG4}=<epic>`, USAGE14);
   const to = issueNumber(target, "epic number");
-  const reason = readTextFlag(flags, REASON_FLAG, USAGE13) ?? null;
+  const reason = readTextFlag(flags, REASON_FLAG, USAGE14) ?? null;
   return Object.freeze({ issue, to, reason });
 }
 function memberRow(issues, number) {
@@ -9504,20 +10258,19 @@ function moveFailure(result2) {
 async function runEpicMove(context, seams) {
   const result2 = await moveEpicIssue(context, seams);
   const failure = moveFailure(result2);
-  if (context.outputMode === "json") {
-    if (failure !== null)
-      throw failure;
-    context.output.result(result2);
-    return;
-  }
-  for (const out of renderEpicMove(result2)) {
-    if (out.warn)
-      context.output.warn(out.text);
-    else
-      context.output.info(out.text);
+  if (context.outputMode !== "json") {
+    for (const out of renderEpicMove(result2)) {
+      if (out.warn)
+        context.output.warn(out.text);
+      else
+        context.output.info(out.text);
+    }
   }
+  await refreshProjectAfterEpic(context, seams, moveTarget(result2));
   if (failure !== null)
     throw failure;
+  if (context.outputMode === "json")
+    context.output.result(result2);
 }
 function createEpicMoveCommand(seams = {}) {
   const command = {
@@ -9562,7 +10315,7 @@ var move_default2 = createEpicMoveCommand();
 
 // src/commands/epic/cancel.ts
 var EPIC_CANCEL_REFUSAL_EXIT = 2;
-var USAGE14 = 'rafa epic cancel <n> [--reason="<why>"]';
+var USAGE15 = 'rafa epic cancel <n> [--reason="<why>"]';
 var ISSUE_NUMBER5 = /^[1-9]\d*$/u;
 var EPIC_ANSWER = /^#?([1-9]\d*)$/u;
 var LINE_BREAK = /\r\n|\n|\r/u;
@@ -9581,11 +10334,11 @@ function readCancelLine(context) {
   const [word] = args;
   if (args.length !== 1 || word === undefined) {
     const got = args.length === 0 ? "none" : `${String(args.length)}: ${args.join(" ")}`;
-    throw lineRefusal(`Expected one epic number, got ${got}`, USAGE14);
+    throw lineRefusal(`Expected one epic number, got ${got}`, USAGE15);
   }
   if (!ISSUE_NUMBER5.test(word))
-    throw lineRefusal(`"${word}" is no epic number, which is a whole number from 1`, USAGE14);
-  const reason = readTextFlag(flags, REASON_FLAG, USAGE14) ?? null;
+    throw lineRefusal(`"${word}" is no epic number, which is a whole number from 1`, USAGE15);
+  const reason = readTextFlag(flags, REASON_FLAG, USAGE15) ?? null;
   return Object.freeze({ epic: Number(word), reason });
 }
 function readEpicToCancel(issues, number, relations = LABELS_READS) {
@@ -9711,7 +10464,7 @@ async function commentOn(writes, issue, body) {
 }
 async function applyMove(input, dependent, reading) {
   const { change } = reading;
-  const base = { issue: change.issue, waitsOn: dependent.waitsOn, answer: { kind: "moved", to: change.to } };
+  const base = { issue: change.issue, waitsOn: dependent.waitsOn, answer: { kind: "moved", from: change.from, to: change.to } };
   try {
     const writes = { board: input.writes.board, relations: input.writes.moves, issues: input.issues };
     const outcome = await applyEpicMove(writes, reading, cancelMoveReason(input.epic));
@@ -9921,6 +10674,7 @@ function cancelFailure(result2) {
 }
 async function runEpicCancel(context, seams) {
   const result2 = await cancelEpic(context, seams);
+  await refreshProjectAfterEpic(context, seams, cancelTarget(result2));
   const failure = cancelFailure(result2);
   if (failure !== null)
     throw failure;
@@ -9967,7 +10721,7 @@ import { randomUUID as randomUUID3 } from "crypto";
 import { join as join22 } from "path";
 
 // src/board/epic-template.ts
-import { existsSync as existsSync4, readFileSync as readFileSync9 } from "fs";
+import { existsSync as existsSync4, readFileSync as readFileSync10 } from "fs";
 import { dirname as dirname3, join as join19 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 var MODULE_DIR2 = dirname3(fileURLToPath2(import.meta.url));
@@ -9984,7 +10738,7 @@ function readEpicTemplate(moduleDir = MODULE_DIR2) {
   if (!existsSync4(source)) {
     throw new Error(`epic template: the epic issue template is missing: no file at ${source}`);
   }
-  return readFileSync9(source, "utf8");
+  return readFileSync10(source, "utf8");
 }
 function placeholderCriteria(criteria) {
   if (criteria === null)
@@ -10075,7 +10829,7 @@ function renderEpicCost(cost, estimate) {
 }
 
 // src/epic/verify-plan.ts
-import { existsSync as existsSync5, readFileSync as readFileSync10 } from "fs";
+import { existsSync as existsSync5, readFileSync as readFileSync11 } from "fs";
 import { dirname as dirname4, join as join20 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 var MODULE_DIR3 = dirname4(fileURLToPath3(import.meta.url));
@@ -10141,7 +10895,7 @@ function readVerifyPrompt(moduleDir = MODULE_DIR3) {
   if (found === undefined) {
     throw new Error(`epic verify prompt: the verification prompt is missing: no file at ${candidates.join(" or ")}`);
   }
-  return readFileSync10(found, "utf8");
+  return readFileSync11(found, "utf8");
 }
 function fenceFor2(text) {
   const longestRun = Math.max(0, ...(text.match(/`+/gu) ?? []).map((run) => run.length));
@@ -10467,16 +11221,16 @@ async function runVerification(options) {
 var EPIC_CLOSE_REFUSAL_EXIT = 2;
 var ACCEPT_UNCHECKED_FLAG = "accept-unchecked";
 var PLAN_TOOLS = ["Read", "Grep", "Glob"];
-var USAGE15 = `rafa epic close <n> [--${ACCEPT_UNCHECKED_FLAG}]`;
+var USAGE16 = `rafa epic close <n> [--${ACCEPT_UNCHECKED_FLAG}]`;
 var ISSUE_NUMBER6 = /^[1-9]\d*$/u;
 function ref7(issue) {
   return `#${String(issue)}`;
 }
-function oneLine2(text) {
+function oneLine3(text) {
   return text.replace(/\s+/gu, " ").trim();
 }
 function criterionName(criterion) {
-  return `criterion ${String(criterion.number)}: ${oneLine2(criterion.text)}`;
+  return `criterion ${String(criterion.number)}: ${oneLine3(criterion.text)}`;
 }
 function criteria(count) {
   return count === 1 ? "1 criterion" : `${String(count)} criteria`;
@@ -10489,10 +11243,10 @@ function readCloseLine(context) {
   const [word] = args;
   if (args.length !== 1 || word === undefined) {
     const got = args.length === 0 ? "none" : `${String(args.length)}: ${args.join(" ")}`;
-    throw lineRefusal(`Expected one epic number, got ${got}`, USAGE15);
+    throw lineRefusal(`Expected one epic number, got ${got}`, USAGE16);
   }
   if (!ISSUE_NUMBER6.test(word))
-    throw lineRefusal(`"${word}" is no epic number, which is a whole number from 1`, USAGE15);
+    throw lineRefusal(`"${word}" is no epic number, which is a whole number from 1`, USAGE16);
   const acceptUnchecked = readSwitch(ACCEPT_UNCHECKED_FLAG, flags[ACCEPT_UNCHECKED_FLAG], `Write it after the epic number: rafa epic close <n> --${ACCEPT_UNCHECKED_FLAG}.`);
   return Object.freeze({ epic: Number(word), acceptUnchecked });
 }
@@ -10500,7 +11254,7 @@ function refuseOpenMembers(number, members) {
   const open = members.filter((member) => member.state === "OPEN");
   if (open.length === 0)
     return;
-  const named = open.map((member) => `${ref7(member.number)} ${oneLine2(member.title)}`).join(", ");
+  const named = open.map((member) => `${ref7(member.number)} ${oneLine3(member.title)}`).join(", ");
   throw refusal7(`Epic ${ref7(number)} has ${String(open.length)} open ${open.length === 1 ? "member" : "members"}: ${named}. The gate checks an epic only once every member is closed: close them, or move them` + " out with rafa epic move <issue> --to=<epic>. No session was started");
 }
 function labelsEpicToClose(issues, epic) {
@@ -10572,7 +11326,7 @@ function closeTriageFile(root, epic) {
   return join22(root, ".rafa", `epic-${String(epic)}-close`);
 }
 function failedCheckArtifact(epic, criterion) {
-  return `epic ${ref7(epic)} acceptance criterion: ${oneLine2(criterion.text)}`;
+  return `epic ${ref7(epic)} acceptance criterion: ${oneLine3(criterion.text)}`;
 }
 function failedCheckReport(epic, failure, commit) {
   const { criterion } = failure.check;
@@ -10596,7 +11350,7 @@ function failedCheckReport(epic, failure, commit) {
     skillsUsed: [],
     blockers: [],
     outOfScopeBugs: [Object.freeze({
-      what: `Epic ${ref7(epic)} acceptance criterion ${String(criterion.number)} fails against main: ${oneLine2(criterion.text)}`,
+      what: `Epic ${ref7(epic)} acceptance criterion ${String(criterion.number)} fails against main: ${oneLine3(criterion.text)}`,
       artifact: failedCheckArtifact(epic, criterion),
       security: false,
       extras: []
@@ -10689,9 +11443,9 @@ async function weighResults(run, epic, ran) {
     if (result2.kind === "unanswered")
       warn2(run, `No answer for ${name} \u2014 ${result2.reason}`);
     else if (result2.result === "pass")
-      say(run, `\u2713 Passed ${name} \u2014 ${oneLine2(result2.evidence)}`);
+      say(run, `\u2713 Passed ${name} \u2014 ${oneLine3(result2.evidence)}`);
     else
-      warn2(run, `\u2717 Failed ${name} \u2014 ${oneLine2(result2.evidence)}`);
+      warn2(run, `\u2717 Failed ${name} \u2014 ${oneLine3(result2.evidence)}`);
   }
   if (!ran.removal.ok) {
     const said = ran.removal.said === "" ? "git said nothing" : ran.removal.said;
@@ -10788,6 +11542,7 @@ async function closeEpic(context, seams) {
 }
 async function runEpicClose(context, seams) {
   const result2 = await closeEpic(context, seams);
+  await refreshProjectAfterEpic(context, seams, closeTarget(result2));
   if (context.outputMode === "json")
     context.output.result(result2);
 }
@@ -10874,7 +11629,7 @@ function createEpicDeferCommand(seams = {}) {
 var defer_default = createEpicDeferCommand();
 
 // src/commands/epic/new.ts
-var USAGE16 = 'rafa epic new "<title>" --slug=<slug> [--horizon=now|next|later]';
+var USAGE17 = 'rafa epic new "<title>" --slug=<slug> [--horizon=now|next|later]';
 var EPIC_NEW_REFUSAL_EXIT = 2;
 var DEFAULT_HORIZON = "later";
 var KEBAB_SLUG = /^[a-z0-9]+(?:-[a-z0-9]+)*$/u;
@@ -10912,26 +11667,26 @@ function readTitle(args) {
   const [title] = args;
   if (args.length !== 1 || title === undefined) {
     const got = args.length === 0 ? "none" : `${String(args.length)}: ${args.join(" ")}`;
-    throw lineRefusal(`Expected one title, quoted, got ${got}`, USAGE16);
+    throw lineRefusal(`Expected one title, quoted, got ${got}`, USAGE17);
   }
   if (title.trim() === "" || LINE_BREAK2.test(title)) {
-    throw lineRefusal("The title has to be one line holding some text", USAGE16);
+    throw lineRefusal("The title has to be one line holding some text", USAGE17);
   }
   return title.trim();
 }
 function readEpicDraft(args, flags) {
   const title = readTitle(args);
-  const slug = readRequiredFlag(flags, "slug", USAGE16);
-  const horizon = readChoiceFlag(flags, "horizon", HORIZONS, USAGE16) ?? DEFAULT_HORIZON;
+  const slug = readRequiredFlag(flags, "slug", USAGE17);
+  const horizon = readChoiceFlag(flags, "horizon", HORIZONS, USAGE17) ?? DEFAULT_HORIZON;
   if (!KEBAB_SLUG.test(slug)) {
     throw refusal8(`--slug is "${slug}", which is not a kebab word: lowercase letters and digits` + ` joined by single hyphens, as sign-in
-Usage: ${USAGE16}`);
+Usage: ${USAGE17}`);
   }
   return Object.freeze({ title, slug, horizon });
 }
 function readNativeEpicDraft(args, flags) {
   const title = readTitle(args);
-  const horizon = readChoiceFlag(flags, "horizon", HORIZONS, USAGE16) ?? DEFAULT_HORIZON;
+  const horizon = readChoiceFlag(flags, "horizon", HORIZONS, USAGE17) ?? DEFAULT_HORIZON;
   return Object.freeze({ title, horizon });
 }
 function sameLabel(label, name) {
@@ -11074,12 +11829,13 @@ function renderEpicNew(result2) {
 }
 async function runEpicNew(context, seams) {
   const result2 = await createEpic(context, seams);
-  if (context.outputMode === "json") {
-    context.output.result(result2);
-    return;
+  if (context.outputMode !== "json") {
+    for (const text of renderEpicNew(result2))
+      context.output.info(text);
   }
-  for (const text of renderEpicNew(result2))
-    context.output.info(text);
+  await refreshProjectAfterEpic(context, seams, newEpicTarget(result2));
+  if (context.outputMode === "json")
+    context.output.result(result2);
 }
 function createEpicNewCommand(seams = {}) {
   const command = {
@@ -11170,12 +11926,12 @@ function createEpicPromoteCommand(seams = {}) {
 var promote_default = createEpicPromoteCommand();
 
 // src/commands/init.ts
-import { existsSync as existsSync8, readFileSync as readFileSync14 } from "fs";
+import { existsSync as existsSync8, readFileSync as readFileSync15 } from "fs";
 import { homedir as homedir2 } from "os";
 import { join as join26, relative as relative5, sep as sep3 } from "path";
 
 // src/agents/vendorable.ts
-import { readdirSync, readFileSync as readFileSync11 } from "fs";
+import { readdirSync, readFileSync as readFileSync12 } from "fs";
 import { isAbsolute as isAbsolute3, join as join23 } from "path";
 function planFiles(dir) {
   let entries;
@@ -11188,7 +11944,7 @@ function planFiles(dir) {
 }
 function readText2(path) {
   try {
-    return readFileSync11(path, "utf8");
+    return readFileSync12(path, "utf8");
   } catch {
     return null;
   }
@@ -11233,7 +11989,7 @@ function vendorableAgentWarnings(agents, root) {
 
 // src/project/gitignore.ts
 import { createHash } from "crypto";
-import { existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync12, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync13, writeFileSync as writeFileSync4 } from "fs";
 import { dirname as dirname5, isAbsolute as isAbsolute4, join as join24 } from "path";
 var GITIGNORE_FILE = ".gitignore";
 var DIGEST_NAME = "tracking.digest";
@@ -11330,7 +12086,7 @@ function attempt(file, failure, act) {
 function readIfPresent2(file) {
   if (!existsSync6(file))
     return null;
-  return attempt(file, "cannot be read", () => readFileSync12(file, "utf8"));
+  return attempt(file, "cannot be read", () => readFileSync13(file, "utf8"));
 }
 function writeTrackingGitignore(root, flags) {
   requireAbsolute(root);
@@ -11340,7 +12096,7 @@ function writeTrackingGitignore(root, flags) {
   if (next === text)
     return { file, change: "unchanged" };
   attempt(file, "cannot be written", () => {
-    writeFileSync3(file, next);
+    writeFileSync4(file, next);
   });
   const change = text === null ? "created" : "updated";
   return { file, change };
@@ -11379,7 +12135,7 @@ function noticeTrackingChange(root, flags, print2 = printWarning) {
     print2(exposureNotice(root));
   attempt(digestFile, "cannot be written", () => {
     mkdirSync3(dirname5(digestFile), { recursive: true });
-    writeFileSync3(digestFile, recorded);
+    writeFileSync4(digestFile, recorded);
   });
   return { digestFile, changed: true, printed: flags.trackingAll };
 }
@@ -11468,14 +12224,14 @@ async function promptForRoot(found, prompter, seams) {
 }
 
 // src/project/scaffold.ts
-import { existsSync as existsSync7, lstatSync, mkdirSync as mkdirSync4, statSync as statSync6, writeFileSync as writeFileSync5 } from "fs";
+import { existsSync as existsSync7, lstatSync, mkdirSync as mkdirSync4, statSync as statSync6, writeFileSync as writeFileSync6 } from "fs";
 import { join as join25 } from "path";
 
 // src/commands/init-release.ts
-import { writeFileSync as writeFileSync4 } from "fs";
+import { writeFileSync as writeFileSync5 } from "fs";
 
 // src/release/setting.ts
-import { readFileSync as readFileSync13 } from "fs";
+import { readFileSync as readFileSync14 } from "fs";
 var RELEASE_ENABLED_SETTING = "release.enabled";
 function releaseEnabledIn(text, path) {
   return parseConfigText(text, path).values.releaseEnabled ?? null;
@@ -11484,7 +12240,7 @@ function readReleaseSetting(root) {
   const path = configFilePath(root);
   let text;
   try {
-    text = readFileSync13(path, "utf8");
+    text = readFileSync14(path, "utf8");
   } catch (error) {
     return { enabled: null, text: "", problem: `${path} could not be read: ${messageOf(error)}` };
   }
@@ -11511,7 +12267,7 @@ function enabledLineIn(lines, open) {
   }
   return null;
 }
-function appended(lines, block) {
+function appended2(lines, block) {
   const body = lines.at(-1) === "" ? lines.slice(0, -1) : [...lines];
   return [...body, ...block, ""];
 }
@@ -11547,7 +12303,7 @@ function withReleaseEnabled(text, enabled) {
   }
   if (namesRelease(text))
     return null;
-  return appended(lines, ["release:", setting]).join(`
+  return appended2(lines, ["release:", setting]).join(`
 `);
 }
 
@@ -11613,7 +12369,7 @@ function writeSetting(root, text, enabled) {
     return `the file this run would have written reads ${RELEASE_ENABLED_SETTING} as ${describeValue(read)}`;
   }
   try {
-    writeFileSync4(path, written, "utf8");
+    writeFileSync5(path, written, "utf8");
   } catch (error) {
     return `it could not be written: ${messageOf(error)}`;
   }
@@ -11714,6 +12470,9 @@ var CONFIG_SETTINGS_LINES = Object.freeze([
   "# board:",
   "#   trustedAuthors: []           # logins trusted with board text besides the repo write-holders",
   `#   relationships: ${CONFIG_DEFAULTS.boardRelationships}        # labels | native, where epics and blockers are recorded`,
+  "#   project:",
+  `#     template: ${CONFIG_DEFAULTS.boardProjectTemplate}   # the project URL rafa init --board --project copies`,
+  "#     number:                    # the project rafa mirrors the board to; unset until rafa init --board --project",
   "# roadmap:",
   "#   issue:                       # the issue plan create --next reads; unset is the one titled Roadmap",
   "# claims:",
@@ -11834,7 +12593,7 @@ function ensureFile(path, text) {
   if (existsSync7(path))
     return { path, kind: "file", change: "unchanged" };
   attempt2(path, "cannot be written", () => {
-    writeFileSync5(path, text, { encoding: "utf8", flag: "wx" });
+    writeFileSync6(path, text, { encoding: "utf8", flag: "wx" });
   });
   return { path, kind: "file", change: "created" };
 }
@@ -11905,6 +12664,15 @@ function readEpicGuardFlag(value) {
     return false;
   throw refusal9([`rafa init: --epic-guard takes no value, and read "${value}" as one;` + " install the workflow with --epic-guard, or leave it out with --no-epic-guard"]);
 }
+function readProjectFlag(value) {
+  if (value === undefined)
+    return null;
+  if (value === true || value === "true")
+    return true;
+  if (value === false || value === "false")
+    return false;
+  throw refusal9([`rafa init: --project takes no value, and read "${value}" as one;` + " create the GitHub project with --project, or leave it out with --no-project"]);
+}
 function readReleaseFlag(value) {
   if (value === undefined)
     return null;
@@ -11969,7 +12737,7 @@ function resolvedConfig2(root, home, warn3) {
 function checkGitignore(root, flags) {
   const file = join26(root, GITIGNORE_FILE);
   try {
-    const text = existsSync8(file) ? readFileSync14(file, "utf8") : null;
+    const text = existsSync8(file) ? readFileSync15(file, "utf8") : null;
     withTrackingBlock(text, flags, file);
   } catch (error) {
     const message = error instanceof GitignoreError ? error.message : `rafa init: ${file} cannot be read (${messageOf(error)})`;
@@ -12066,7 +12834,8 @@ function renderInit(result2) {
     ...renderReleaseStep(result2.release),
     ...renderBoardStep(result2.board),
     ...renderEpicGuardStep(result2.epicGuard),
-    ...renderRelationsMoveStep(result2.relationsMove ?? null)
+    ...renderRelationsMoveStep(result2.relationsMove ?? null),
+    ...renderProjectStep(result2.project)
   ];
   return result2.changed ? [head, ...changed, ...steps] : [head, ...steps, "Nothing changed."];
 }
@@ -12075,6 +12844,7 @@ async function runInit(context, seams) {
   const wantsBoard = readBoardFlag(context.flags["board"]);
   const wantsGuard = readEpicGuardFlag(context.flags["epic-guard"]);
   const wantsRelease = readReleaseFlag(context.flags["release"]);
+  const wantsProject = readProjectFlag(context.flags["project"]);
   const yes = readYesFlag(context.flags["yes"]);
   const start2 = seams.cwd();
   const home = seams.home();
@@ -12098,13 +12868,23 @@ async function runInit(context, seams) {
     isTerminal: seams.isTerminal,
     openPrompter: seams.openPrompter
   });
+  const project = await runProjectStep({
+    wanted: wantsProject,
+    board,
+    root: scopes.written.root,
+    config: scopes.config,
+    openGh: () => seams.gh(scopes.written.root),
+    isTerminal: seams.isTerminal,
+    openPrompter: seams.openPrompter
+  });
   const result2 = {
     ...scopes.written,
-    changed: scopes.written.changed || release.changed || boardStepChanged(board) || epicGuardChanged(epicGuard) || relationsMoveChanged(relationsMove),
+    changed: scopes.written.changed || release.changed || boardStepChanged(board) || epicGuardChanged(epicGuard) || relationsMoveChanged(relationsMove) || projectStepChanged(project),
     release,
     board,
     epicGuard,
-    ...relationsMove === null ? {} : { relationsMove }
+    ...relationsMove === null ? {} : { relationsMove },
+    project
   };
   if (context.outputMode === "json")
     context.output.result(result2);
@@ -12121,6 +12901,8 @@ async function runInit(context, seams) {
     context.output.warn(line);
   for (const line of relationsMove?.warnings ?? [])
     context.output.warn(line);
+  for (const line of project.warnings)
+    context.output.warn(line);
   for (const line of vendorableAgentWarnings(result2.vendorableAgents, result2.root))
     context.output.warn(line);
 }
@@ -12130,7 +12912,7 @@ function createInitCommand(seams = DEFAULT_INIT_SEAMS) {
     subject: "init",
     action: "init",
     summary: "set up a rafa project: its root, .rafa/config.yaml, the tree and the .gitignore entry",
-    description: "Sets up a rafa project. On a terminal it lists the root candidates, the git toplevel or" + " the working directory outside a repository and then the outermost monorepo root above it, each" + " refused one with its reason, and reads a candidate number or a path typed freely. `--root=<path>`" + " names the root instead, absolute or relative to the working directory, and `--yes` takes the" + " first candidate; without a terminal one of the two is needed. Under the root it writes" + " `.rafa/config.yaml` with every setting commented out at its default, the tree `specs/`, `plans/`," + " `runs/`, `effort/` and `instincts/` under `.rafa/`, and the rafa block in `.gitignore` from the" + " `tracking` settings; under the home it writes `~/.rafa/config.yaml` and `~/.rafa/instincts/` when" + " they are missing. Only what is missing or stale is written, so a rerun changes no byte and says" + " so. It warns when `~/.rafa/bin` is not on PATH ahead of `~/.bun/bin`, and when a plan under" + " `plan.dir` routes to an agent that resolves only in `~/.claude/agents` and rafa does not ship," + " naming `rafa agent vendor <name>`; it writes nothing under `.claude/` itself. A repository whose pull request provider is `gh` ends with one" + " question about setting up the GitHub board, which `--board` and `--no-board` answer for a" + " script, and then, once the board has run, one question about installing the epic guard" + " workflow `.github/workflows/epic-guard.yml`, which removes a second `epic:` label from an issue" + " and comments why; `--epic-guard` and `--no-epic-guard` answer that one. When `board.relationships`" + " is set, the board is then read for relationships held in the other mode: every write that moves" + " them into the configured one is printed and a terminal is asked once, nothing is written on a no," + " and once every write went through a second question asks whether to remove the old marks. On a terminal it also asks once whether every pull request bumps the version and gains" + " a changelog entry, and writes the answer as `release.enabled`; `--release` and `--no-release`" + " answer that one, and `--yes` leaves it unset. With `--output=json` the" + " root and every path checked are the data of the terminal result event.",
+    description: "Sets up a rafa project. On a terminal it lists the root candidates, the git toplevel or" + " the working directory outside a repository and then the outermost monorepo root above it, each" + " refused one with its reason, and reads a candidate number or a path typed freely. `--root=<path>`" + " names the root instead, absolute or relative to the working directory, and `--yes` takes the" + " first candidate; without a terminal one of the two is needed. Under the root it writes" + " `.rafa/config.yaml` with every setting commented out at its default, the tree `specs/`, `plans/`," + " `runs/`, `effort/` and `instincts/` under `.rafa/`, and the rafa block in `.gitignore` from the" + " `tracking` settings; under the home it writes `~/.rafa/config.yaml` and `~/.rafa/instincts/` when" + " they are missing. Only what is missing or stale is written, so a rerun changes no byte and says" + " so. It warns when `~/.rafa/bin` is not on PATH ahead of `~/.bun/bin`, and when a plan under" + " `plan.dir` routes to an agent that resolves only in `~/.claude/agents` and rafa does not ship," + " naming `rafa agent vendor <name>`; it writes nothing under `.claude/` itself. A repository whose pull request provider is `gh` ends with one" + " question about setting up the GitHub board, which `--board` and `--no-board` answer for a" + " script, and then, once the board has run, one question about installing the epic guard" + " workflow `.github/workflows/epic-guard.yml`, which removes a second `epic:` label from an issue" + " and comments why; `--epic-guard` and `--no-epic-guard` answer that one. When `board.relationships`" + " is set, the board is then read for relationships held in the other mode: every write that moves" + " them into the configured one is printed and a terminal is asked once, nothing is written on a no," + " and once every write went through a second question asks whether to remove the old marks. Last, once the" + " board has run, one question asks whether to copy the GitHub project template to the repository's" + " owner, link it, add the issues and fill their fields; `--project` and `--no-project` answer that one." + " On a terminal it also asks once whether every pull request bumps the version and gains" + " a changelog entry, and writes the answer as `release.enabled`; `--release` and `--no-release`" + " answer that one, and `--yes` leaves it unset. With `--output=json` the" + " root and every path checked are the data of the terminal result event.",
     args: [],
     flags: [
       {
@@ -12153,6 +12935,11 @@ function createInitCommand(seams = DEFAULT_INIT_SEAMS) {
         description: "Install the epic guard workflow without asking, once the board has run:" + " `.github/workflows/epic-guard.yml`, which removes a second `epic:` label from an issue and" + " comments why. `--no-epic-guard` leaves it out. Without either, a terminal is asked once and a" + " run with no terminal leaves it out. A file already at that path is left as it is.",
         type: "boolean"
       },
+      {
+        name: "project",
+        description: "Create the GitHub project without asking, once the board has run: copy" + " `board.project.template` to the repository's owner, link the repository, add its issues, fill" + " their fields and save `board.project.number`. `--no-project` leaves it out. Without either, a" + " terminal is asked once and a run with no terminal leaves it out.",
+        type: "boolean"
+      },
       {
         name: "release",
         description: "Write `release.enabled: true` without asking, so every pull request bumps" + " `release.versionFile` and gains a `release.changelog` entry. `--no-release` writes `false`." + " Without either, a terminal is asked once, and `--yes` or a run with no terminal leaves the" + " setting unset at its default `auto`.",
@@ -12183,6 +12970,10 @@ function createInitCommand(seams = DEFAULT_INIT_SEAMS) {
       {
         cmd: "rafa init --yes --board --epic-guard",
         note: "Sets up the GitHub board and installs the epic guard workflow, asking nothing."
+      },
+      {
+        cmd: "rafa init --yes --board --project",
+        note: "Sets up the GitHub board and its GitHub project, asking nothing. A second run writes nothing."
       }
     ],
     outputs: ["text", "json"],
@@ -12341,7 +13132,7 @@ var check_default = createInstinctCheckCommand();
 
 // src/commands/instinct/flag.ts
 var NAME = "rafa instinct flag";
-var USAGE17 = "rafa instinct flag <id> <reason>";
+var USAGE18 = "rafa instinct flag <id> <reason>";
 function refusedFlagMessage(id2, kind, reason) {
   return [
     `\u274C ${NAME}: the \`${kind}\` learning adapter did not flag "${id2}": ${reason}`,
@@ -12351,7 +13142,7 @@ function refusedFlagMessage(id2, kind, reason) {
 }
 function blankReasonMessage2(id2) {
   return `\u274C ${NAME}: the reason to flag "${id2}" is blank; say why the lesson is wrong.
-Usage: ${USAGE17}`;
+Usage: ${USAGE18}`;
 }
 function makeAdapter(registry, kind, context) {
   try {
@@ -12365,7 +13156,7 @@ function makeAdapter(registry, kind, context) {
   }
 }
 async function flagInstinct(context, seams) {
-  const [id2, reason] = expectTwoArguments(context.args, USAGE17);
+  const [id2, reason] = expectTwoArguments(context.args, USAGE18);
   if (reason.trim() === "")
     throw new CommandExit(1, blankReasonMessage2(id2));
   const project = requireProject(context, NAME);
@@ -12434,7 +13225,7 @@ var flag_default = createInstinctFlagCommand();
 
 // src/commands/instinct/promote.ts
 var NAME2 = "rafa instinct promote";
-var USAGE18 = "rafa instinct promote";
+var USAGE19 = "rafa instinct promote";
 var CONFIDENCE_DIGITS = 2;
 function refusedPullMessage(kind, reason, name = NAME2) {
   return `\u274C ${name}: the \`${kind}\` learning adapter answered no blessed set: ${reason}`;
@@ -12451,7 +13242,7 @@ function makeLearningAdapter(registry, kind, context, name = NAME2) {
   }
 }
 async function promotableLessons(context, seams) {
-  expectNoArgument(context.args, USAGE18);
+  expectNoArgument(context.args, USAGE19);
   const project = requireProject(context, NAME2);
   const config = resolveProjectConfig(project, NAME2, (message) => {
     context.output.warn(message);
@@ -12521,7 +13312,7 @@ var promote_default2 = createInstinctPromoteCommand();
 
 // src/commands/instinct/list.ts
 var NAME3 = "rafa instinct list";
-var USAGE19 = "rafa instinct list [--blessed | --conflicts]";
+var USAGE20 = "rafa instinct list [--blessed | --conflicts]";
 var CONFIDENCE_DIGITS2 = 2;
 var HUNDREDTHS = 100;
 function instinctRowLine(entry) {
@@ -12554,20 +13345,20 @@ function readViewFlag(name, value) {
   if (value === true || value === "true")
     return true;
   throw new CommandExit(1, `\u274C --${name} takes no value, and read "${value}" as one
-Usage: ${USAGE19}`);
+Usage: ${USAGE20}`);
 }
 function readListView(flags) {
   const blessed = readViewFlag("blessed", flags["blessed"]);
   const conflicts = readViewFlag("conflicts", flags["conflicts"]);
   if (blessed && conflicts) {
     throw new CommandExit(1, `\u274C --blessed and --conflicts are two views; give one
-Usage: ${USAGE19}`);
+Usage: ${USAGE20}`);
   }
   if (blessed)
     return "blessed";
   return conflicts ? "conflicts" : "all";
 }
-function oneLine3(text) {
+function oneLine4(text) {
   return text.trim().replace(/\s+/gu, " ");
 }
 function byConfidence(left, right) {
@@ -12600,7 +13391,7 @@ function conflictLines(conflict) {
   const width = Math.max(...conflict.records.map((record) => record.id.length));
   return [
     `  ${conflict.scope}  ${conflict.trigger}`,
-    ...conflict.records.map((record) => lessonLine("    ", record, width, oneLine3(record.action)))
+    ...conflict.records.map((record) => lessonLine("    ", record, width, oneLine4(record.action)))
   ];
 }
 function renderConflicts(result2) {
@@ -12665,7 +13456,7 @@ function answer(context, result2, lines) {
     context.output.info(line);
 }
 async function runList4(context, seams) {
-  expectNoArgument(context.args, USAGE19);
+  expectNoArgument(context.args, USAGE20);
   const view = readListView(context.flags);
   if (view === "blessed") {
     const result3 = await blessedLessons(context, seams);
@@ -12728,7 +13519,7 @@ function createInstinctListCommand(seams = {}) {
 var list_default6 = createInstinctListCommand();
 
 // src/commands/instinct/show.ts
-var USAGE20 = "rafa instinct show <id>";
+var USAGE21 = "rafa instinct show <id>";
 var FIELD_ORDER = [
   "trigger",
   "kind",
@@ -12800,11 +13591,11 @@ function unreadableMessage(entry) {
 }
 function unknownIdMessage(id2, scopes) {
   const looked = scopes.map((listing) => `  ${listing.scope}  ${listing.dir}${listing.exists ? "" : "  (no such directory)"}`);
-  return [`\u274C No instinct is filed under "${id2}". Looked in:`, ...looked, `Usage: ${USAGE20}`].join(`
+  return [`\u274C No instinct is filed under "${id2}". Looked in:`, ...looked, `Usage: ${USAGE21}`].join(`
 `);
 }
 function runShow2(context) {
-  const id2 = expectOneArgument(context.args, USAGE20);
+  const id2 = expectOneArgument(context.args, USAGE21);
   const project = instinctProject(context, "rafa instinct show");
   const scopes = readScopes({ home: project.home, projectRoot: project.root });
   const found = findRecords(scopes, id2);
@@ -12863,7 +13654,7 @@ function createInstinctShowCommand() {
 var show_default3 = createInstinctShowCommand();
 
 // src/commands/issue/check.ts
-import { readdirSync as readdirSync2, readFileSync as readFileSync15, statSync as statSync7 } from "fs";
+import { readdirSync as readdirSync2, readFileSync as readFileSync16, statSync as statSync7 } from "fs";
 import { join as join27, resolve as resolve9 } from "path";
 var CHECK_USAGE = "rafa issue check <n> [--stamp]";
 var STAMP_FLAG = "stamp";
@@ -12963,7 +13754,7 @@ async function readReferences(absolute, issue, verify, stamp) {
     return rows.map((row2) => checkedRef(row2, row2.stamp));
   }
   const once2 = memoiseVerifier(verify);
-  const before = await readRefsText({ copy: readFileSync15(absolute, "utf8"), issue, verify: once2 });
+  const before = await readRefsText({ copy: readFileSync16(absolute, "utf8"), issue, verify: once2 });
   const after = await restampCopyRefs({ path: absolute, issue, verify: once2 });
   return before.rows.map((row2, index) => checkedRef(row2, after.rows[index]?.stamp ?? null));
 }
@@ -13038,10 +13829,10 @@ function createIssueCheckCommand(seams = {}) {
 var check_default2 = createIssueCheckCommand();
 
 // src/commands/issue/comment.ts
-var USAGE21 = "rafa issue comment <id> --body=<text>";
+var USAGE22 = "rafa issue comment <id> --body=<text>";
 async function commentOnIssue(context, seams) {
-  const id2 = expectOneArgument(context.args, USAGE21);
-  const body = readRequiredFlag(context.flags, "body", USAGE21);
+  const id2 = expectOneArgument(context.args, USAGE22);
+  const body = readRequiredFlag(context.flags, "body", USAGE22);
   const { tracker, data } = await resolveIssueTracker(context, seams);
   const ref8 = issueRef(tracker, id2);
   await onTracker(tracker, `comment on issue ${id2}`, () => tracker.comment(ref8, body));
@@ -13166,24 +13957,24 @@ async function settleSpecLine(draft, tracker) {
 }
 
 // src/commands/issue/create.ts
-var USAGE22 = "rafa issue create --title=<text> [--body=<text> | --body-file=<path>] [--type=<type>] [--module=<name>] [--priority=<priority>]";
+var USAGE23 = "rafa issue create --title=<text> [--body=<text> | --body-file=<path>] [--type=<type>] [--module=<name>] [--priority=<priority>]";
 var STDIN_PATH = "-";
 var DEFAULT_ISSUE_TYPE = "code";
 function readBodyFileFlag(flags) {
-  const path = readNonBlankFlag(flags, "body-file", USAGE22);
+  const path = readNonBlankFlag(flags, "body-file", USAGE23);
   if (path === undefined || flags.body === undefined)
     return path;
-  throw lineRefusal("--body and --body-file cannot be used together: name the body one way", USAGE22);
+  throw lineRefusal("--body and --body-file cannot be used together: name the body one way", USAGE23);
 }
 function readIssueDraft(flags) {
   readBodyFileFlag(flags);
   return {
     opt: 0,
-    title: readRequiredFlag(flags, "title", USAGE22),
-    body: readTextFlag(flags, "body", USAGE22) ?? "",
-    type: readChoiceFlag(flags, "type", ISSUE_TYPES, USAGE22) ?? DEFAULT_ISSUE_TYPE,
-    module: readNonBlankFlag(flags, "module", USAGE22) ?? TRIAGE_MODULE,
-    priority: readChoiceFlag(flags, "priority", ISSUE_PRIORITIES, USAGE22) ?? null,
+    title: readRequiredFlag(flags, "title", USAGE23),
+    body: readTextFlag(flags, "body", USAGE23) ?? "",
+    type: readChoiceFlag(flags, "type", ISSUE_TYPES, USAGE23) ?? DEFAULT_ISSUE_TYPE,
+    module: readNonBlankFlag(flags, "module", USAGE23) ?? TRIAGE_MODULE,
+    priority: readChoiceFlag(flags, "priority", ISSUE_PRIORITIES, USAGE23) ?? null,
     project: null,
     blockedBy: []
   };
@@ -13194,7 +13985,7 @@ async function readBodyFile(path, seams) {
     return await read();
   } catch (error) {
     const where = path === STDIN_PATH ? "standard input" : `"${path}"`;
-    throw lineRefusal(`--body-file cannot read ${where}: ${messageOf(error)}`, USAGE22);
+    throw lineRefusal(`--body-file cannot read ${where}: ${messageOf(error)}`, USAGE23);
   }
 }
 async function readIssueLine(flags, seams) {
@@ -13206,7 +13997,7 @@ function renderCreated(ref8) {
   return [`Created ${issueName(ref8)}.`, ...urlLines(ref8)];
 }
 async function createIssue(context, seams) {
-  expectNoArgument(context.args, USAGE22);
+  expectNoArgument(context.args, USAGE23);
   const read = await readIssueLine(context.flags, seams);
   const blockedLine = readSpecLine(read);
   const { tracker, data } = await resolveIssueTracker(context, seams);
@@ -13220,13 +14011,34 @@ async function settledDraft(read, tracker, context) {
     context.output.warn(`issue create: ${settled.unchecked}`);
   return settled.draft;
 }
+function projectIssueNumber(ref8) {
+  if (ref8.kind !== "github" || !/^[1-9]\d*$/u.test(ref8.externalId))
+    return null;
+  const number = Number(ref8.externalId);
+  return Number.isSafeInteger(number) ? number : null;
+}
+async function addCreatedToProject(context, seams, ref8) {
+  const issue = projectIssueNumber(ref8);
+  if (issue === null)
+    return;
+  const project = issueProject(context);
+  const config = issueSubjectConfig(project, () => {
+    return;
+  });
+  const lines = await addAndRefreshIssue({
+    config,
+    openGh: () => seams.gh ?? createGhRunner({ cwd: project.root })
+  }, issue);
+  for (const line of lines)
+    context.output.warn(line);
+}
 function createIssueCreateCommand(seams = DEFAULT_ISSUE_SEAMS) {
   const command = {
     name: "issue create",
     subject: "issue",
     action: "create",
     summary: "create an issue on the tracker from a title and a body",
-    description: "Files one issue on the tracker `tracker.default` names in `.rafa/config.yaml`, or on the first" + " `tracker.fallback` kind whose preflight passes when it fails, each kind passed over warned about." + " `--title` is required. The issue is of type `code` and module `unassigned` unless `--type` and" + " `--module` say otherwise, and with no `--priority` the tracker marks it needs-triage. The body is" + " `--body`, or what the file `--body-file` names holds, standard input for `-`. A spec whose body" + " carries a `Blocked by: #24` line is filed blocked, and refused when the line names no issue, the" + " issue itself or an issue the board does not hold. Prints the" + " tracker and id of the issue filed, and its URL when there is one. With `--output=json` the tracker" + " and the ref are the data of the terminal result event.",
+    description: "Files one issue on the tracker `tracker.default` names in `.rafa/config.yaml`, or on the first" + " `tracker.fallback` kind whose preflight passes when it fails, each kind passed over warned about." + " `--title` is required. The issue is of type `code` and module `unassigned` unless `--type` and" + " `--module` say otherwise, and with no `--priority` the tracker marks it needs-triage. The body is" + " `--body`, or what the file `--body-file` names holds, standard input for `-`. A spec whose body" + " carries a `Blocked by: #24` line is filed blocked, and refused when the line names no issue, the" + " issue itself or an issue the board does not hold. With `board.project.number` set, a GitHub issue is" + " added to the project and its fields filled, any failure there a warning that keeps the exit code. Prints the" + " tracker and id of the issue filed, and its URL when there is one. With `--output=json` the tracker" + " and the ref are the data of the terminal result event.",
     args: [],
     flags: [
       {
@@ -13282,12 +14094,12 @@ function createIssueCreateCommand(seams = DEFAULT_ISSUE_SEAMS) {
       const created = await createIssue(context, seams);
       if (created.ref.warning !== undefined)
         context.output.warn(`${issueName(created.ref)}: ${created.ref.warning}`);
-      if (context.outputMode === "json") {
+      if (context.outputMode === "json")
         context.output.result(created);
-        return;
-      }
-      for (const line of renderCreated(created.ref))
-        context.output.info(line);
+      else
+        for (const line of renderCreated(created.ref))
+          context.output.info(line);
+      await addCreatedToProject(context, seams, created.ref);
     }
   };
   return Object.freeze(command);
@@ -13295,7 +14107,7 @@ function createIssueCreateCommand(seams = DEFAULT_ISSUE_SEAMS) {
 var create_default = createIssueCreateCommand();
 
 // src/commands/issue/edit-run.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync5, writeFileSync as writeFileSync6 } from "fs";
+import { existsSync as existsSync9, mkdirSync as mkdirSync5, writeFileSync as writeFileSync7 } from "fs";
 import { join as join29 } from "path";
 
 // src/board/issue-edit-body.ts
@@ -13709,8 +14521,8 @@ function saveConflictBodies(root, issue, now, before, after) {
     attempt3 += 1;
     paths = conflictPaths(issue, stamp, attempt3);
   }
-  writeFileSync6(join29(root, paths.before), before, { flag: "wx" });
-  writeFileSync6(join29(root, paths.after), after, { flag: "wx" });
+  writeFileSync7(join29(root, paths.before), before, { flag: "wx" });
+  writeFileSync7(join29(root, paths.after), after, { flag: "wx" });
   return paths;
 }
 function heldOutcome(request, state) {
@@ -13903,16 +14715,43 @@ function createIssueEditCommand(seams = DEFAULT_EDIT_SEAMS) {
 }
 var edit_default = createIssueEditCommand();
 
+// src/commands/issue/move-project.ts
+function issueNumberOf(externalId) {
+  const number = Number(externalId);
+  return Number.isSafeInteger(number) && number >= 1 ? number : null;
+}
+async function refreshMovedIssue(tracker, externalId, options) {
+  const issue = issueNumberOf(externalId);
+  if (tracker !== "github" || issue === null || options.config.boardProjectNumber === null)
+    return [];
+  const refresh = options.refresh ?? refreshIssueItems;
+  try {
+    return (await refresh({ config: options.config, gh: options.openGh() }, [issue])).warnings;
+  } catch (error) {
+    return [refreshFailedWarning(issue, error)];
+  }
+}
+
 // src/commands/issue/move.ts
-var USAGE23 = "rafa issue move <id> <state>";
+var USAGE24 = "rafa issue move <id> <state>";
 async function moveIssue(context, seams) {
-  const [id2, word] = expectTwoArguments(context.args, USAGE23);
-  const state = readChoice(word, "The state", ISSUE_STATES, USAGE23);
+  const [id2, word] = expectTwoArguments(context.args, USAGE24);
+  const state = readChoice(word, "The state", ISSUE_STATES, USAGE24);
   const { tracker, data } = await resolveIssueTracker(context, seams);
   const ref8 = issueRef(tracker, id2);
   const moved = await onTracker(tracker, `move issue ${id2} to ${state}`, () => tracker.transition(ref8, state));
   return { tracker: data, ref: ref8, state, warning: moved.warning ?? null };
 }
+function moveProjectOptions(context, seams) {
+  const project = issueProject(context);
+  const { gh } = seams;
+  return {
+    config: issueSubjectConfig(project, () => {
+      return;
+    }),
+    openGh: () => gh ?? createGhRunner({ cwd: project.root })
+  };
+}
 function createIssueMoveCommand(seams = DEFAULT_ISSUE_SEAMS) {
   const command = {
     name: "issue move",
@@ -13948,9 +14787,12 @@ function createIssueMoveCommand(seams = DEFAULT_ISSUE_SEAMS) {
     outputs: ["text", "json"],
     run: async (context) => {
       const moved = await moveIssue(context, seams);
+      const refreshed = await refreshMovedIssue(moved.tracker.kind, moved.ref.externalId, moveProjectOptions(context, seams));
       const warn3 = () => {
         if (moved.warning !== null)
           context.output.warn(`${issueName(moved.ref)}: ${moved.warning}`);
+        for (const line of refreshed)
+          context.output.warn(line);
       };
       if (context.outputMode === "json") {
         warn3();
@@ -13966,7 +14808,7 @@ function createIssueMoveCommand(seams = DEFAULT_ISSUE_SEAMS) {
 var move_default3 = createIssueMoveCommand();
 
 // src/commands/issue/show.ts
-var USAGE24 = "rafa issue show <id>";
+var USAGE25 = "rafa issue show <id>";
 var NO_PRIORITY = "needs-triage";
 function renderIssue(kind, issue) {
   const project = issue.project === null ? [] : [`Project: ${issue.project}`];
@@ -13988,7 +14830,7 @@ function renderIssue(kind, issue) {
   ];
 }
 async function showIssue(context, seams) {
-  const id2 = expectOneArgument(context.args, USAGE24);
+  const id2 = expectOneArgument(context.args, USAGE25);
   const { tracker, data } = await resolveIssueTracker(context, seams);
   const issue = await onTracker(tracker, `read issue ${id2}`, () => tracker.get(issueRef(tracker, id2)));
   return { tracker: data, issue };
@@ -14036,7 +14878,7 @@ var show_default4 = createIssueShowCommand();
 
 // src/commands/loop/list.ts
 import { isAbsolute as isAbsolute5, relative as relative6 } from "path";
-var USAGE25 = "rafa loop list";
+var USAGE26 = "rafa loop list";
 function worktreeLabel2(root, worktree) {
   const under = relative6(root, worktree);
   return under === "" || under.startsWith("..") || isAbsolute5(under) ? worktree : under;
@@ -14056,7 +14898,7 @@ function renderSessionList(root, list) {
   ];
 }
 async function runList5(context, seams) {
-  expectNoArgument(context.args, USAGE25);
+  expectNoArgument(context.args, USAGE26);
   const root = projectRoot(context);
   const sessions = readRecords(root, seams).filter(isLive).map((session) => {
     const checklist = readSessionChecklist(root, session);
@@ -14102,7 +14944,7 @@ function createLoopListCommand(seams = {}) {
 var list_default7 = createLoopListCommand();
 
 // src/commands/loop/pause.ts
-var USAGE26 = "rafa loop pause [-s|--session-id=<id>]";
+var USAGE27 = "rafa loop pause [-s|--session-id=<id>]";
 function renderPause(result2) {
   const { session } = result2;
   if (!result2.changed)
@@ -14111,8 +14953,8 @@ function renderPause(result2) {
   return [when, "  Nothing is marked. `rafa loop resume` goes on, and `rafa loop stop` ends the run."];
 }
 async function runPause(context, seams) {
-  expectNoArgument(context.args, USAGE26);
-  const { root, record } = pickSession(context, USAGE26, "live", seams);
+  expectNoArgument(context.args, USAGE27);
+  const { root, record } = pickSession(context, USAGE27, "live", seams);
   if (!isLive(record)) {
     throw refusal(`Session ${record.sessionId} reads ${record.state}: no run is left to pause.`);
   }
@@ -14152,7 +14994,7 @@ function createLoopPauseCommand(seams = {}) {
 var pause_default = createLoopPauseCommand();
 
 // src/commands/loop/resume.ts
-var USAGE27 = "rafa loop resume [-s|--session-id=<id>]";
+var USAGE28 = "rafa loop resume [-s|--session-id=<id>]";
 function renderResume(result2) {
   const { session } = result2;
   if (!result2.changed)
@@ -14160,8 +15002,8 @@ function renderResume(result2) {
   return [session.task === null ? `Resumed session ${session.sessionId}: it goes on with its next task.` : `Resumed session ${session.sessionId}: it goes on past its running task, line ${session.task.line}, ${session.task.text}`];
 }
 async function runResume(context, seams) {
-  expectNoArgument(context.args, USAGE27);
-  const { root, record } = pickSession(context, USAGE27, "live", seams);
+  expectNoArgument(context.args, USAGE28);
+  const { root, record } = pickSession(context, USAGE28, "live", seams);
   if (!isLive(record)) {
     throw refusal(`Session ${record.sessionId} reads ${record.state}: its run has ended, so there is nothing to resume.`, `\`rafa loop start --plan=${record.plan}\` runs its plan again as a new session, its blocked tasks first.`);
   }
@@ -14311,7 +15153,7 @@ var loopStart = Object.freeze({
 var start_default = endingWith(loopStart);
 
 // src/commands/loop/status.ts
-var USAGE28 = "rafa loop status [-s|--session-id=<id>]";
+var USAGE29 = "rafa loop status [-s|--session-id=<id>]";
 var BLOCKED_TASK_LINE = /^- \[BLOCKED\] (.+)/;
 var NO_BLOCKER = "the line trails no blocker comment";
 function blockerAt(checklist, lineNum) {
@@ -14347,8 +15189,8 @@ function renderStatus(status) {
   ];
 }
 async function runStatus(context, seams) {
-  expectNoArgument(context.args, USAGE28);
-  const { root, record } = pickSession(context, USAGE28, "live-or-newest", seams);
+  expectNoArgument(context.args, USAGE29);
+  const { root, record } = pickSession(context, USAGE29, "live-or-newest", seams);
   const checklist = readSessionChecklist(root, record);
   const tasks = checklist === null ? null : countTasks(checklist.tasks);
   let eta = null;
@@ -14402,7 +15244,7 @@ function createLoopStatusCommand(seams = {}) {
 var status_default2 = createLoopStatusCommand();
 
 // src/commands/loop/stop.ts
-var USAGE29 = "rafa loop stop [-s|--session-id=<id>]";
+var USAGE30 = "rafa loop stop [-s|--session-id=<id>]";
 function signalRun(record, interrupt) {
   try {
     interrupt(record.pid);
@@ -14455,8 +15297,8 @@ function renderStop(result2) {
   ];
 }
 async function runStop(context, seams) {
-  expectNoArgument(context.args, USAGE29);
-  const { root, record } = pickSession(context, USAGE29, "live", seams);
+  expectNoArgument(context.args, USAGE30);
+  const { root, record } = pickSession(context, USAGE30, "live", seams);
   if (!isLive(record)) {
     throw refusal(`Session ${record.sessionId} reads ${record.state}: no run is left to stop.`);
   }
@@ -14647,14 +15489,14 @@ class WaitUntilError extends Error {
     this.entry = entry;
   }
 }
-function rowOf2(reason) {
+function rowOf3(reason) {
   const row2 = WAIT_REASONS.find((candidate) => candidate.reason === reason);
   if (row2 === undefined)
     throw new Error(`wait reasons: no row for ${reason}`);
   return row2;
 }
 function waitExitCode(reason) {
-  return rowOf2(reason).exit;
+  return rowOf3(reason).exit;
 }
 function isPlainReason(entry) {
   return WAIT_REASONS.some((row2) => row2.reason === entry && row2.reason !== "quiet");
@@ -14711,7 +15553,7 @@ function matchQuiet(awakeMinutes, until) {
 }
 
 // src/commands/loop/wait.ts
-var USAGE30 = "rafa loop wait [-s|--session-id=<id>] [--until=<reasons>] [--timeout=<minutes>]";
+var USAGE31 = "rafa loop wait [-s|--session-id=<id>] [--until=<reasons>] [--timeout=<minutes>]";
 var WAIT_POLL_MS = 5000;
 var UNTIL_FLAG = "until";
 var TIMEOUT_FLAG = "timeout";
@@ -14732,12 +15574,12 @@ function readUntil(context) {
   if (value === undefined)
     return DEFAULT_WAIT_UNTIL;
   if (typeof value !== "string")
-    throw lineRefusal2(`--${UNTIL_FLAG} needs a value: --${UNTIL_FLAG}=<reasons>`, USAGE30);
+    throw lineRefusal2(`--${UNTIL_FLAG} needs a value: --${UNTIL_FLAG}=<reasons>`, USAGE31);
   try {
     return parseWaitUntil(value);
   } catch (error) {
     if (error instanceof WaitUntilError)
-      throw lineRefusal2(error.message, USAGE30);
+      throw lineRefusal2(error.message, USAGE31);
     throw error;
   }
 }
@@ -14748,7 +15590,7 @@ function readTimeout(context) {
   const minutes = typeof value === "string" ? Number(value) : Number.NaN;
   if (typeof value !== "string" || !/^[1-9]\d*$/.test(value) || !Number.isSafeInteger(minutes)) {
     const spelled = typeof value === "string" ? JSON.stringify(value) : `--${TIMEOUT_FLAG} with no value`;
-    throw lineRefusal2(`${spelled} is no timeout, which is a whole number of minutes from 1`, USAGE30);
+    throw lineRefusal2(`${spelled} is no timeout, which is a whole number of minutes from 1`, USAGE31);
   }
   return minutes;
 }
@@ -14857,7 +15699,7 @@ function resultOf5(found, following, seams) {
 }
 function pickOrNoSession(context, seams) {
   try {
-    return pickSession(context, USAGE30, "live-or-newest", {
+    return pickSession(context, USAGE31, "live-or-newest", {
       ...resolveLoopSeams(),
       readBranch: seams.readBranch,
       isAlive: seams.isAlive
@@ -14869,7 +15711,7 @@ function pickOrNoSession(context, seams) {
   }
 }
 async function runLoopWait(context, seams = {}) {
-  expectNoArgument(context.args, USAGE30);
+  expectNoArgument(context.args, USAGE31);
   const until = readUntil(context);
   const timeout = readTimeout(context);
   const resolved = resolveWaitSeams(seams);
@@ -14956,7 +15798,7 @@ function createLoopWaitCommand(seams = {}) {
 var wait_default = createLoopWaitCommand();
 
 // src/commands/module/exec.ts
-var USAGE31 = "rafa module exec <module> <action> [args] [flags]";
+var USAGE32 = "rafa module exec <module> <action> [args] [flags]";
 var execCommand = {
   name: "module exec",
   subject: "module",
@@ -14985,13 +15827,13 @@ var execCommand = {
     const mounts = context.registry.mounts();
     const mounted = mounts.length === 0 ? "none is mounted; a module is mounted when allowList: names it and modules: gives its path source" : mounts.map((mount) => `${mount.name} (${context.registry.actionsOf(mountKey(mount.name)).map((held) => held.action).join(", ")})`).join(", ");
     throw new CommandExit(1, `\u274C Expected a module and one of its actions; mounted: ${mounted}
-Usage: ${USAGE31}`);
+Usage: ${USAGE32}`);
   }
 };
 var exec_default = Object.freeze(execCommand);
 
 // src/commands/module/list.ts
-var USAGE32 = "rafa module list";
+var USAGE33 = "rafa module list";
 function sourceText(source) {
   const ref8 = source.ref === null ? "" : `@${source.ref}`;
   return `${source.kind} ${source.location}${ref8}`;
@@ -15012,10 +15854,10 @@ function renderModuleList(list) {
   return ["Modules:", ...list.modules.flatMap(moduleLines)];
 }
 async function runList6(context, seams) {
-  expectNoArgument(context.args, USAGE32);
+  expectNoArgument(context.args, USAGE33);
   const { project } = context;
   if (project === null)
-    throw new CommandExit(1, `\u274C ${USAGE32} runs inside a project`);
+    throw new CommandExit(1, `\u274C ${USAGE33} runs inside a project`);
   let loaded;
   try {
     const resolved = loadConfig({ root: project.root, home: project.home });
@@ -15139,7 +15981,7 @@ function allowedUnasked(action, ceiling) {
 
 // src/next/lines.ts
 var NEXT_USAGE = "rafa next [--dry-run] [--roadmap [--claim-ahead]] [--yes[=<action ids>]]";
-var DRY_RUN_FLAG5 = "dry-run";
+var DRY_RUN_FLAG6 = "dry-run";
 var ROADMAP_FLAG = "roadmap";
 var CLAIM_AHEAD_FLAG = "claim-ahead";
 var STATE_MARK = "\uD83D\uDCCD";
@@ -15164,7 +16006,7 @@ function dryRunLine(dryRun, roadmap) {
   if (dryRun === "no-terminal") {
     return `${STOP_MARK} There is no terminal to answer on, so nothing ran; run rafa next where you can answer,` + ` or type --${YES_FLAG}=${shownIds(BARE_YES_ACTIONS, roadmap).join(",")} to allow those steps unasked.`;
   }
-  return `${STOP_MARK} --${DRY_RUN_FLAG5}: nothing ran.`;
+  return `${STOP_MARK} --${DRY_RUN_FLAG6}: nothing ran.`;
 }
 function stopLine(stop, state, ceiling, dryRun, roadmap = false) {
   if (stop === "dry-run")
@@ -15194,7 +16036,7 @@ function lineRefusal4(problem2) {
 Usage: ${NEXT_USAGE}`);
 }
 function readDryRun(flags) {
-  return readBareFlag(flags, DRY_RUN_FLAG5);
+  return readBareFlag(flags, DRY_RUN_FLAG6);
 }
 function readRoadmap(flags) {
   return readBareFlag(flags, ROADMAP_FLAG);
@@ -15243,19 +16085,19 @@ function trackingOf(plan2) {
 function fastForwardBase(git, plan2) {
   const { base } = plan2;
   const tracking = trackingOf(plan2);
-  const counted2 = git(["rev-list", "--left-right", "--count", `${base}...${tracking}`]);
-  if (!counted2.ok) {
+  const counted3 = git(["rev-list", "--left-right", "--count", `${base}...${tracking}`]);
+  if (!counted3.ok) {
     return refuse6([
       `\u274C Could not read how ${base} stands against ${tracking}.`,
-      ...quotedLines(gitSaid(counted2)),
+      ...quotedLines(gitSaid(counted3)),
       stillAt(base)
     ]);
   }
-  const standing = parseBaseStanding(counted2.stdout);
+  const standing = parseBaseStanding(counted3.stdout);
   if (standing === null) {
     return refuse6([
       `\u274C Could not read how ${base} stands against ${tracking}.`,
-      `${INDENT2}git answered ${JSON.stringify(counted2.stdout)}, which is no pair of counts.`,
+      `${INDENT2}git answered ${JSON.stringify(counted3.stdout)}, which is no pair of counts.`,
       stillAt(base)
     ]);
   }
@@ -15443,7 +16285,7 @@ async function runNext(context, seams) {
 var YES_ID_LIST = YES_ACTIONS.join(", ");
 var NEXT_FLAGS = Object.freeze([
   {
-    name: DRY_RUN_FLAG5,
+    name: DRY_RUN_FLAG6,
     description: "Print where the project stands and what to do about it, and stop without asking or running it." + " A run with no terminal to answer on and no --yes does this whether or not the flag is typed.",
     type: "boolean"
   },
@@ -15616,10 +16458,10 @@ var wrapped2 = wrapPhaseZeroCommand({
 var create_default2 = endingWith(wrapped2);
 
 // src/commands/plan/risk.ts
-import { readFileSync as readFileSync16 } from "fs";
+import { readFileSync as readFileSync17 } from "fs";
 import { resolve as resolve11 } from "path";
 var COMMAND6 = "rafa plan risk";
-var USAGE33 = "rafa plan risk [<plan>] [--strict]";
+var USAGE34 = "rafa plan risk [<plan>] [--strict]";
 var STRICT_HINT = `Type the plan first: ${COMMAND6} <plan> --strict`;
 function spawningRunners(root) {
   return { git: createGitRunner(root), gh: createGhRunner({ cwd: root }) };
@@ -15632,7 +16474,7 @@ function riskPlanPath(root, planDir, typed) {
     throw new CommandExit(1, `\u274C Plan file not found: ${path}`);
   const lookedFor = [...new Set([resolve11(root, planDir, DEFAULT_PLAN_FILE), resolve11(root, DEFAULT_PLAN_FILE)])];
   throw new CommandExit(1, `\u274C No plan named, and no default plan at ${lookedFor.join(" or ")}
-Usage: ${USAGE33}`);
+Usage: ${USAGE34}`);
 }
 function riskLine(finding) {
   const line = finding.line === undefined ? "" : `:${String(finding.line)}`;
@@ -15644,7 +16486,7 @@ function strictRefusal(report3) {
 }
 async function readRisk(path, project, config, context, seams) {
   const makeRunners = seams.runners ?? spawningRunners;
-  return assessPlanRisk({ path, text: readFileSync16(path, "utf8") }, {
+  return assessPlanRisk({ path, text: readFileSync17(path, "utf8") }, {
     repoRoot: project.root,
     home: project.home,
     settingSources: config.settingSources,
@@ -15696,7 +16538,7 @@ function createPlanRiskCommand(seams = {}) {
     outputs: ["text", "json"],
     run: async (context) => {
       const strict = readSwitch("strict", context.flags["strict"], STRICT_HINT);
-      const typed = expectAtMostOneArgument(context.args, USAGE33);
+      const typed = expectAtMostOneArgument(context.args, USAGE34);
       const project = requireProject(context, COMMAND6);
       const config = resolveProjectConfig(project, COMMAND6, (message) => {
         context.output.warn(message);
@@ -15727,9 +16569,9 @@ function createPlanRiskCommand(seams = {}) {
 var risk_default = createPlanRiskCommand();
 
 // src/commands/plan/show.ts
-import { readFileSync as readFileSync17 } from "fs";
+import { readFileSync as readFileSync18 } from "fs";
 import { join as join30 } from "path";
-var USAGE34 = "rafa plan show <stub> [--tracker]";
+var USAGE35 = "rafa plan show <stub> [--tracker]";
 var COMMAND7 = "rafa plan show";
 function readTrackerFlag(value) {
   if (value === undefined || value === false || value === "false")
@@ -15749,7 +16591,7 @@ function showPlan(plans, stub, tracker) {
   const file = join30(plans.path, name);
   if (!isFile(file))
     throw new CommandExit(1, missingText(stub, tracker, join30(plans.label, name)));
-  const model = parsePlan(readFileSync17(file, "utf8"));
+  const model = parsePlan(readFileSync18(file, "utf8"));
   const { header } = model;
   return {
     stub,
@@ -15825,7 +16667,7 @@ var planShowCommand = {
   outputs: ["text", "json"],
   run: async (context) => {
     const tracker = readTrackerFlag(context.flags.tracker);
-    const stub = expectOneArgument(context.args, USAGE34);
+    const stub = expectOneArgument(context.args, USAGE35);
     const plans = resolvePlansDir(requireProject(context, COMMAND7), COMMAND7, (message) => {
       context.output.warn(message);
     });
@@ -15932,7 +16774,13 @@ function openPrContext(context, seams = DEFAULT_PR_SEAMS) {
     planDir: config.planDir,
     worktreeDir: config.loopWorktreeDir,
     readBranch: () => readBranch2(project.root),
-    versionGuard: mergeGuardSettings(config)
+    versionGuard: mergeGuardSettings(config),
+    projectRefresh: {
+      boardProjectNumber: config.boardProjectNumber,
+      boardRelationships: config.boardRelationships,
+      roadmapIssue: config.roadmapIssue,
+      releaseFragments: config.releaseFragments
+    }
   };
 }
 async function onProvider(doing, call) {
@@ -15968,7 +16816,7 @@ Run rafa pr list to see the open pull requests.`, usage);
 }
 
 // src/commands/pr/current.ts
-var USAGE35 = PR_USAGE.current;
+var USAGE36 = PR_USAGE.current;
 var SEPARATOR2 = " \u2014 ";
 function trimmedOrNull(value) {
   const trimmed = value.trim();
@@ -15999,9 +16847,9 @@ async function probeChecks(pulls, number) {
   }
 }
 async function readCurrent(context, seams) {
-  expectNoArguments(context.args, USAGE35);
+  expectNoArguments(context.args, USAGE36);
   const pr = openPrContext(context, seams);
-  const pick = await pickPullRequest(pr, null, USAGE35);
+  const pick = await pickPullRequest(pr, null, USAGE36);
   const summary = pick.summary;
   const probe = await probeChecks(pr.pulls, pick.number);
   const reading = {
@@ -16166,7 +17014,7 @@ function forecastLine(number, forecast) {
 }
 
 // src/commands/pr/list.ts
-var USAGE36 = PR_USAGE.list;
+var USAGE37 = PR_USAGE.list;
 var UNREADABLE = "?";
 var PROBE_LIMIT = 6;
 var TITLE_WIDTH = 60;
@@ -16254,7 +17102,7 @@ async function probe(call) {
     return { value: null, problem: messageOf(error) };
   }
 }
-async function rowOf3(pulls, pull2, readBaseOf) {
+async function rowOf4(pulls, pull2, readBaseOf) {
   const [checks, detail] = await Promise.all([
     probe(() => pulls.checks(pull2.number)),
     probe(() => pulls.get(pull2.number))
@@ -16270,12 +17118,12 @@ async function rowOf3(pulls, pull2, readBaseOf) {
   };
 }
 async function readList(context, seams, now) {
-  expectNoArguments(context.args, USAGE36);
+  expectNoArguments(context.args, USAGE37);
   const pr = openPrContext(context, seams);
   const open = await onProvider("list the open pull requests", () => pr.pulls.list());
   const root = pr.project.root;
   const readBaseOf = resolveReleaseEnabled(pr.versionGuard, root).enabled ? createBaseReader((seams.git ?? createGitRunner)(root), pr.versionGuard) : null;
-  const rows = await mapWithLimit(open, PROBE_LIMIT, (pull2) => rowOf3(pr.pulls, pull2, readBaseOf));
+  const rows = await mapWithLimit(open, PROBE_LIMIT, (pull2) => rowOf4(pr.pulls, pull2, readBaseOf));
   return { rows, text: renderList(rows, now) };
 }
 function createPrListCommand(seams = DEFAULT_PR_SEAMS) {
@@ -16597,6 +17445,55 @@ function plural2(count, noun) {
   return count === 1 ? `1 ${noun}` : `${String(count)} ${noun}s`;
 }
 
+// src/commands/pr/merge-project.ts
+function named2(issues) {
+  return issues.map((issue) => `#${String(issue)}`).join(", ");
+}
+function blockingProblemLine(closed, problem2) {
+  return `The project was not updated for the issues ${named2(closed)} were blocking: ${problem2}.` + ` Run \`${BOARD_SYNC_FIX}\` to catch up.`;
+}
+function refreshProblemLine(issues, problem2) {
+  return `The project was not updated for ${named2(issues)}: ${problem2}. Run \`${BOARD_SYNC_FIX}\` to catch up.`;
+}
+function waitsOnOneOf(blockers, closed) {
+  return blockers.kind === "blocked" && blockers.blockers.some((blocker) => blocker.repository === null && closed.has(blocker.number));
+}
+async function readBlocking(config, gh, closed) {
+  const repository = config.boardRelationships === "native" ? await readBoardRepository(gh) : "";
+  const relations = selectBoardRelations(config, { gh, repository });
+  const listing = await createGhBoardListing({ gh, mode: relations.mode })();
+  const reading = relations.read(listing);
+  return listing.filter((row2) => waitsOnOneOf(reading.blockersOf(row2), closed)).map((row2) => row2.number);
+}
+function consideredBlocking(unblocked, closed) {
+  return (unblocked?.issues ?? []).filter((outcome) => outcome.blockers.some((blocker) => closed.has(blocker))).map((outcome) => outcome.issue);
+}
+async function refreshProjectAfterMerge(options) {
+  const { config, warn: warn3, refresh = refreshIssueItems } = options;
+  const closed = [...new Set(closedIssuesIn(options.body))];
+  if (config.boardProjectNumber === null || closed.length === 0)
+    return null;
+  const gh = options.openGh();
+  const wanted = new Set(closed);
+  const warnings = [];
+  let listed2 = [];
+  try {
+    listed2 = await readBlocking(config, gh, wanted);
+  } catch (error) {
+    warnings.push(blockingProblemLine(closed, messageOf(error)));
+  }
+  const blocking = [...new Set([...listed2, ...consideredBlocking(options.unblocked, wanted)])].filter((issue) => !wanted.has(issue)).sort((a, b) => a - b);
+  const issues = [...closed, ...blocking];
+  try {
+    warnings.push(...(await refresh({ config, gh }, issues)).warnings);
+  } catch (error) {
+    warnings.push(refreshProblemLine(issues, messageOf(error)));
+  }
+  for (const line of warnings)
+    warn3(line);
+  return { closed, blocking, warnings };
+}
+
 // src/pr/unchecked.ts
 var NO_WORKFLOW_WARNING = "nothing on GitHub has tested this branch; you are relying on the checks run locally";
 var WORKFLOWS_EXIST_WARNING = "CI may not have started (a path filter, a draft, Actions disabled, or it has not registered yet); this is probably not what you want";
@@ -16704,16 +17601,16 @@ function readBranches(filter, base) {
   const patterns = patternListOf(filter);
   if (patterns === null)
     return UNKNOWN;
-  let named2 = false;
+  let named3 = false;
   for (const pattern of patterns) {
     const negated = pattern.startsWith("!");
     const matches = branchPatternMatches(negated ? pattern.slice(1) : pattern, base);
     if (matches === null)
       return UNKNOWN;
     if (matches)
-      named2 = !negated;
+      named3 = !negated;
   }
-  return named2;
+  return named3;
 }
 function readBranchesIgnore(filter, base) {
   const patterns = patternListOf(filter);
@@ -16888,9 +17785,21 @@ async function postUncheckedComment(pulls, number, unchecked, warn3) {
     return null;
   }
 }
+function uncheckedReport(unchecked, commentUrl) {
+  return unchecked === null ? null : { workflowCount: unchecked.workflowCount, case: unchecked.reading.case, commentUrl };
+}
+async function commentIfUnchecked(pulls, number, unchecked, report4) {
+  if (unchecked === null)
+    return null;
+  const posted = await postUncheckedComment(pulls, number, unchecked, report4.warn);
+  if (posted === null)
+    return null;
+  report4.info(`Commented on #${number} that it was merged with no checks: ${posted.url}`);
+  return posted.url;
+}
 
 // src/commands/pr/merge.ts
-var USAGE37 = PR_USAGE.merge;
+var USAGE38 = PR_USAGE.merge;
 var YES_ANSWERS4 = ["y", "yes"];
 var DEFAULT_MERGE_SEAMS = Object.freeze({});
 function refusal11(lines) {
@@ -17059,32 +17968,18 @@ async function askToMerge(context, pr, seams, ask) {
   }
   return { go: yes || await confirmed(seams), unchecked };
 }
-function uncheckedReport(unchecked, commentUrl) {
-  return unchecked === null ? null : { workflowCount: unchecked.workflowCount, case: unchecked.reading.case, commentUrl };
-}
-async function commentIfUnchecked(context, pr, number, unchecked) {
-  if (unchecked === null)
-    return null;
-  const posted = await postUncheckedComment(pr.pulls, number, unchecked, (message) => {
-    context.output.warn(message);
-  });
-  if (posted === null)
-    return null;
-  context.output.info(`Commented on #${number} that it was merged with no checks: ${posted.url}`);
-  return posted.url;
-}
 async function runMerge2(context, seams) {
-  const yes = readBooleanFlag(context.flags, "yes", USAGE37);
-  const skipChecks = readBooleanFlag(context.flags, "skip-checks", USAGE37);
-  const wanted = readMethodFlag(context.flags, USAGE37);
-  const asked = readPullArgument(context.args, USAGE37);
+  const yes = readBooleanFlag(context.flags, "yes", USAGE38);
+  const skipChecks = readBooleanFlag(context.flags, "skip-checks", USAGE38);
+  const wanted = readMethodFlag(context.flags, USAGE38);
+  const asked = readPullArgument(context.args, USAGE38);
   const pr = openPrContext(context, seams);
   const git = (seams.git ?? createGitRunner)(pr.project.root);
   const method = wanted ?? pr.mergeMethod;
-  const pick = await pickPullRequest(pr, asked, USAGE37);
+  const pick = await pickPullRequest(pr, asked, USAGE38);
   const detail = await onProvider(`read pull request #${pick.number}`, () => pr.pulls.get(pick.number));
   if (detail === null) {
-    throw lineRefusal5(`No pull request #${pick.number} at ${pr.project.root}`, USAGE37);
+    throw lineRefusal5(`No pull request #${pick.number} at ${pr.project.root}`, USAGE38);
   }
   const checks = await onProvider(`read the checks of #${pick.number}`, () => pr.pulls.checks(pick.number));
   recordPlanCi({
@@ -17140,16 +18035,17 @@ async function runMerge2(context, seams) {
     throw refusal11([`\u274C ${pr.pulls.kind} would not merge #${detail.number}: ${outcome.detail}`]);
   }
   context.output.info(`Merged #${detail.number} into ${detail.baseRefName} (${method}).`);
-  const commentUrl = await commentIfUnchecked(context, pr, detail.number, answer2.unchecked);
-  const roadmapTicks = await reportTick(context, pr, seams, detail);
   const warn3 = (message) => {
     context.output.warn(message);
   };
   const info2 = (message) => {
     context.output.info(message);
   };
+  const commentUrl = await commentIfUnchecked(pr.pulls, detail.number, answer2.unchecked, { info: info2, warn: warn3 });
+  const roadmapTicks = await reportTick(context, pr, seams, detail);
   const steps = cleanUpAfterMerge(git, detail, { info: info2, warn: warn3 });
   const board = await reportAfterCleanUp(context, pr, seams, detail);
+  await refreshProjectAfterMerge({ body: detail.body, config: pr.projectRefresh, openGh: () => openGh(pr, seams), unblocked: board.unblocked, warn: warn3 });
   const followUps = reportFollowUps({
     root: pr.project.root,
     home: pr.project.home,
@@ -17243,11 +18139,11 @@ var BOM = "\uFEFF";
 var TIMESTAMP = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z /;
 var COLOUR = new RegExp(`(?:${String.fromCharCode(27)}|\\^\\[)\\[[0-9;]*m`, "g");
 var PREFIX2 = "pr triage evidence";
-function named2(value) {
+function named3(value) {
   return value === "" ? undefined : value;
 }
 function stepColumn(value) {
-  return value === UNKNOWN_STEP ? undefined : named2(value);
+  return value === UNKNOWN_STEP ? undefined : named3(value);
 }
 function stripText(text) {
   const withoutBom = text.startsWith(BOM) ? text.slice(BOM.length) : text;
@@ -17256,7 +18152,7 @@ function stripText(text) {
 function groupStep(text) {
   if (!text.startsWith(GROUP_STEP_PREFIX))
     return;
-  return named2(text.slice(GROUP_STEP_PREFIX.length).trim());
+  return named3(text.slice(GROUP_STEP_PREFIX.length).trim());
 }
 function parseFailedLogLine(line) {
   const firstTab = line.indexOf(COLUMN);
@@ -17265,7 +18161,7 @@ function parseFailedLogLine(line) {
     return { job: undefined, step: undefined, text: stripText(line) };
   }
   return {
-    job: named2(line.slice(0, firstTab)),
+    job: named3(line.slice(0, firstTab)),
     step: stepColumn(line.slice(firstTab + 1, secondTab)),
     text: stripText(line.slice(secondTab + 1))
   };
@@ -17373,12 +18269,12 @@ function fencedBlock(body, language) {
   return `${fence}${language}
 ${text}${fence}`;
 }
-function counted2(count, noun) {
+function counted3(count, noun) {
   return count === 1 ? `1 ${noun}` : `${count} ${noun}s`;
 }
 function excerptCaption(reading) {
-  const shown = counted2(reading.lines.length, "line");
-  return reading.omitted === 0 ? `The failing job log, all ${shown} of it.` : `The last ${shown} of the failing job log, ${counted2(reading.omitted, "earlier line")}` + ` omitted of ${reading.total} in all.`;
+  const shown = counted3(reading.lines.length, "line");
+  return reading.omitted === 0 ? `The failing job log, all ${shown} of it.` : `The last ${shown} of the failing job log, ${counted3(reading.omitted, "earlier line")}` + ` omitted of ${reading.total} in all.`;
 }
 function pullRequestSection(pr) {
   const fork = pr.isCrossRepository ? `
@@ -17391,7 +18287,7 @@ function pullRequestSection(pr) {
 function classSection(assessment) {
   const eligibility = assessment.simple ? "simple, so a pinned resolve plan covers it" : "not simple, so the fix needs judgement about what this pull request is for";
   const bump = assessment.dependencyBump ? "yes" : "no";
-  const failing = counted2(assessment.failing.length, "failing row");
+  const failing = counted3(assessment.failing.length, "failing row");
   return `- Class: \`${assessment.triageClass}\` (${eligibility})
 ` + `- Why: ${assessment.reason}
 ` + `- Checks verdict: \`${assessment.verdict}\`, ${failing} in the rollup
@@ -17419,7 +18315,7 @@ function excerptSection(input) {
   const reading = excerptLines(evidence, input.maxExcerptLines);
   if (reading.lines.length === 0)
     return NO_EXCERPT;
-  const jobs = evidence.jobs.length === 0 ? "" : `${counted2(evidence.jobs.length, "failing job")}: ` + `${evidence.jobs.map((job) => `\`${job}\``).join(", ")}.
+  const jobs = evidence.jobs.length === 0 ? "" : `${counted3(evidence.jobs.length, "failing job")}: ` + `${evidence.jobs.map((job) => `\`${job}\``).join(", ")}.
 `;
   return `${jobs}${excerptCaption(reading)}
 
@@ -17670,7 +18566,7 @@ function readLastTriage(comments) {
 }
 
 // src/commands/pr/show.ts
-var USAGE38 = PR_USAGE.show;
+var USAGE39 = PR_USAGE.show;
 var INDENT6 = "   ";
 var SHORT_SHA = 7;
 var NOT_IN_BODY = "not named by the body";
@@ -17708,19 +18604,19 @@ function factsLine(detail) {
 function repositoryOf(detail) {
   return PULL_URL_REPOSITORY.exec(detail.url.trim())?.[1] ?? null;
 }
-function linkedWord(issue, own, named3) {
+function linkedWord(issue, own, named4) {
   if (own !== null && issue.repository !== own) {
     return `${issue.repository}#${issue.number} (${OTHER_REPOSITORY})`;
   }
-  return named3.has(issue.number) ? `#${issue.number}` : `#${issue.number} (${NOT_IN_BODY})`;
+  return named4.has(issue.number) ? `#${issue.number}` : `#${issue.number} (${NOT_IN_BODY})`;
 }
 function closesLine(reading) {
   const own = repositoryOf(reading.detail);
-  const named3 = new Set(reading.bodyCloses);
+  const named4 = new Set(reading.bodyCloses);
   const linked = new Set(reading.detail.closes.filter((issue) => own === null || issue.repository === own).map((issue) => issue.number));
   const words = [
-    ...reading.detail.closes.map((issue) => linkedWord(issue, own, named3)),
-    ...[...named3].filter((number) => !linked.has(number)).map((number) => `#${number} (${KEYWORD_ONLY})`)
+    ...reading.detail.closes.map((issue) => linkedWord(issue, own, named4)),
+    ...[...named4].filter((number) => !linked.has(number)).map((number) => `#${number} (${KEYWORD_ONLY})`)
   ];
   return words.length === 0 ? "closes none" : `closes ${words.join(", ")}`;
 }
@@ -17801,12 +18697,12 @@ async function probe2(call) {
   }
 }
 async function readShow(context, seams) {
-  const asked = readPullArgument(context.args, USAGE38);
+  const asked = readPullArgument(context.args, USAGE39);
   const pr = openPrContext(context, seams);
-  const pick = await pickPullRequest(pr, asked, USAGE38);
+  const pick = await pickPullRequest(pr, asked, USAGE39);
   const detail = await onProvider(`read pull request #${pick.number}`, () => pr.pulls.get(pick.number));
   if (detail === null) {
-    throw lineRefusal5(`No pull request #${pick.number} in the repository at ${pr.project.root}`, USAGE38);
+    throw lineRefusal5(`No pull request #${pick.number} in the repository at ${pr.project.root}`, USAGE39);
   }
   const checks = await probe2(() => pr.pulls.checks(pick.number));
   const comments = await probe2(() => pr.pulls.comments(pick.number));
@@ -18690,7 +19586,7 @@ function withTaskBudget(plan2, usd) {
 }
 
 // src/pr/plans/load.ts
-import { existsSync as existsSync10, readFileSync as readFileSync18 } from "fs";
+import { existsSync as existsSync10, readFileSync as readFileSync19 } from "fs";
 import { dirname as dirname7, join as join32 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 var MODULE_DIR4 = dirname7(fileURLToPath4(import.meta.url));
@@ -18721,7 +19617,7 @@ function readPinnedPlan(triageClass, lookup = {}) {
   if (found === undefined) {
     throw new Error(`The pinned resolve plan for ${triageClass} is missing: ` + `no file at ${candidates.join(" or ")}`);
   }
-  return readFileSync18(found, "utf8");
+  return readFileSync19(found, "utf8");
 }
 var SLOT_PATTERN2 = /\{[A-Z][A-Z0-9_]*\}/g;
 var CONFLICT_SENTENCE_SLOT = "CONFLICT_SENTENCE";
@@ -18861,7 +19757,7 @@ function readAttemptRepeat(input) {
 }
 
 // src/commands/pr/resolve-loop.ts
-import { mkdirSync as mkdirSync7, writeFileSync as writeFileSync7 } from "fs";
+import { mkdirSync as mkdirSync7, writeFileSync as writeFileSync8 } from "fs";
 import { join as join33 } from "path";
 var RESOLVE_SUBDIR = join33(".rafa", "resolve");
 var RUN_PREFIX = "pr-";
@@ -18875,7 +19771,7 @@ function writeResolvePlan(write) {
   const dir = resolveRunDir(write.home, write.number, write.attempt);
   mkdirSync7(dir, { recursive: true });
   const path = join33(dir, pinnedPlanFileName(write.triageClass));
-  writeFileSync7(path, write.plan, "utf8");
+  writeFileSync8(path, write.plan, "utf8");
   return path;
 }
 function resolveLoopArgv(planPath) {
@@ -18915,7 +19811,7 @@ async function runResolveLoop(run, seams = {}) {
 }
 
 // src/pr/triage/version-convert.ts
-import { mkdirSync as mkdirSync8, readFileSync as readFileSync19, writeFileSync as writeFileSync8 } from "fs";
+import { mkdirSync as mkdirSync8, readFileSync as readFileSync20, writeFileSync as writeFileSync9 } from "fs";
 import { dirname as dirname8, join as join34, posix } from "path";
 var FALLBACK_PLAN_PREFIX = "pr-";
 var UNUSABLE_PLAN_CHARACTERS = /[^A-Za-z0-9._-]+/g;
@@ -19028,7 +19924,7 @@ function planConversion(input, problems) {
   }
   let branchVersionText;
   try {
-    branchVersionText = readFileSync19(join34(input.worktree, settings.releaseVersionFile), "utf8");
+    branchVersionText = readFileSync20(join34(input.worktree, settings.releaseVersionFile), "utf8");
   } catch (error) {
     return refused2(`${settings.releaseVersionFile} could not be read in the worktree: ${messageOf(error)}`, problems);
   }
@@ -19057,7 +19953,7 @@ function writeConversion(input, plan2) {
     const target = join34(input.worktree, path);
     try {
       mkdirSync8(dirname8(target), { recursive: true });
-      writeFileSync8(target, text);
+      writeFileSync9(target, text);
     } catch (error) {
       return `${path} could not be written in the worktree, which may hold part of the conversion: ${messageOf(error)}`;
     }
@@ -19154,9 +20050,9 @@ function ghPermissionsIn(root) {
   return createGhPermissions({ gh: createGhRunner({ cwd: root }) });
 }
 function repoLabel(url, remote) {
-  const named3 = PULL_URL.exec(url.trim())?.[1];
-  if (named3 !== undefined)
-    return named3;
+  const named4 = PULL_URL.exec(url.trim())?.[1];
+  if (named4 !== undefined)
+    return named4;
   const normalized = remote === null ? "" : normalizeRemote(remote.trim());
   return normalized === "" ? UNNAMED_REPO : normalized;
 }
@@ -19483,7 +20379,7 @@ async function runAttempts(run, detail, first) {
 }
 
 // src/commands/pr/triage.ts
-var USAGE39 = PR_USAGE.triage;
+var USAGE40 = PR_USAGE.triage;
 var DEFAULT_MAX_ATTEMPTS = 2;
 var DETACHED_HEAD2 = "HEAD";
 var RESOLVED = false;
@@ -19539,7 +20435,7 @@ async function selectTargets(pr, warn3, now, resolve13) {
 async function detailOf2(pr, number) {
   const detail = await onProvider(`read pull request #${number}`, () => pr.pulls.get(number));
   if (detail === null) {
-    throw lineRefusal5(`No pull request #${number} in the repository at ${pr.project.root}`, USAGE39);
+    throw lineRefusal5(`No pull request #${number} in the repository at ${pr.project.root}`, USAGE40);
   }
   return detail;
 }
@@ -19650,14 +20546,14 @@ async function assessOne(options) {
 function refuseResolveWithoutComment(wantsResolve, wantsComment) {
   if (!wantsResolve || wantsComment)
     return;
-  throw lineRefusal5("--resolve writes the attempt count into the triage comment, and --no-comment writes none;" + " run one or the other", USAGE39);
+  throw lineRefusal5("--resolve writes the attempt count into the triage comment, and --no-comment writes none;" + " run one or the other", USAGE40);
 }
 async function runTriage(context, seams) {
-  const wantsComment = readBooleanFlag(context.flags, "comment", USAGE39, true);
-  const wantsResolve = readBooleanFlag(context.flags, "resolve", USAGE39, false);
-  const maxAttempts = readMaxAttempts(context.flags, USAGE39);
+  const wantsComment = readBooleanFlag(context.flags, "comment", USAGE40, true);
+  const wantsResolve = readBooleanFlag(context.flags, "resolve", USAGE40, false);
+  const maxAttempts = readMaxAttempts(context.flags, USAGE40);
   refuseResolveWithoutComment(wantsResolve, wantsComment);
-  const asked = readPullArgument(context.args, USAGE39);
+  const asked = readPullArgument(context.args, USAGE40);
   const pr = openPrContext(context, seams);
   const git = (seams.git ?? createGitRunner)(pr.project.root);
   const permissions = (seams.permissions ?? ghPermissionsIn)(pr.project.root);
@@ -19795,7 +20691,7 @@ function createPrTriageCommand(seams = DEFAULT_TRIAGE_SEAMS) {
 var triage_default = createPrTriageCommand();
 
 // src/commands/pr/view.ts
-var USAGE40 = PR_USAGE.view;
+var USAGE41 = PR_USAGE.view;
 function trimmedOrNull2(value) {
   const trimmed = value.trim();
   return trimmed === "" ? null : trimmed;
@@ -19805,9 +20701,9 @@ function renderView(number, url) {
   return url === null ? opened : `${opened}${SEPARATOR2}${url}`;
 }
 async function runView2(context, seams) {
-  const asked = readPullArgument(context.args, USAGE40);
+  const asked = readPullArgument(context.args, USAGE41);
   const pr = openPrContext(context, seams);
-  const pick = await pickPullRequest(pr, asked, USAGE40);
+  const pick = await pickPullRequest(pr, asked, USAGE41);
   await onProvider(`open pull request #${pick.number} in the browser`, () => pr.pulls.browse(pick.number));
   const url = trimmedOrNull2(pick.summary?.url ?? "");
   return {
@@ -19862,7 +20758,7 @@ function createPrViewCommand(seams = DEFAULT_PR_SEAMS) {
 var view_default = createPrViewCommand();
 
 // src/commands/pr/wait.ts
-var USAGE41 = PR_USAGE.wait;
+var USAGE42 = PR_USAGE.wait;
 var TIMEOUT_FLAG2 = "timeout";
 var DEFAULT_WAIT_TIMEOUT_MIN = DEFAULT_CI_TIMEOUT_MIN;
 var MS_PER_MIN = 60000;
@@ -19928,10 +20824,10 @@ function renderWait(reading) {
 `);
 }
 async function runWait(context, seams) {
-  const minutes = readTimeoutMinutes(context.flags, USAGE41);
-  const asked = readPullArgument(context.args, USAGE41);
+  const minutes = readTimeoutMinutes(context.flags, USAGE42);
+  const asked = readPullArgument(context.args, USAGE42);
   const pr = openPrContext(context, seams);
-  const pick = await pickPullRequest(pr, asked, USAGE41);
+  const pick = await pickPullRequest(pr, asked, USAGE42);
   const timeoutMs = minutes * MS_PER_MIN;
   context.output.info(`Waiting for the checks of #${pick.number}, up to ${minutes} min.`);
   const waited = await waitForChecks({
@@ -20037,11 +20933,11 @@ function releasePullBody(build, base) {
 `);
 }
 function foreignSentence(pull2, base) {
-  const named3 = `pull request #${pull2.number} from ${RELEASE_PR_BRANCH}`;
+  const named4 = `pull request #${pull2.number} from ${RELEASE_PR_BRANCH}`;
   if (pull2.isCrossRepository)
-    return `${named3} comes from a fork, so settle will not replace the branch under it; close it and settle again`;
+    return `${named4} comes from a fork, so settle will not replace the branch under it; close it and settle again`;
   if (pull2.baseRefName !== base) {
-    return `${named3} goes into ${pull2.baseRefName}, not ${base}, so settle will not replace the branch under it; close it, or settle with pr.base ${pull2.baseRefName}`;
+    return `${named4} goes into ${pull2.baseRefName}, not ${base}, so settle will not replace the branch under it; close it, or settle with pr.base ${pull2.baseRefName}`;
   }
   return null;
 }
@@ -20363,10 +21259,152 @@ async function withSettleWorktree(options, body) {
   return { ok: true, value, ref: worktree.ref, commit: worktree.commit, leftover };
 }
 
+// src/commands/release/settle-project.ts
+var COMMIT_BATCH = 20;
+var COMMIT_PULL_LIMIT = 10;
+var CLOSING_LIMIT = 100;
+var PREFIX5 = "release settle project";
+function named4(issues) {
+  return issues.map((issue) => `#${String(issue)}`).join(", ");
+}
+function settleProblemLine(issues, problem2) {
+  const which = issues.length === 0 ? "the issues this release closes" : named4(issues);
+  return `The project was not updated for ${which}: ${problem2}. Run \`${BOARD_SYNC_FIX}\` to catch up.`;
+}
+function commitAlias(index) {
+  return `c${String(index)}`;
+}
+function commitPullsArgs(commits) {
+  const declared = commits.map((_, index) => `, $${commitAlias(index)}: GitObjectID!`).join("");
+  const objects = commits.map((_, index) => ` ${commitAlias(index)}: object(oid: $${commitAlias(index)})` + ` { ... on Commit { associatedPullRequests(first: ${String(COMMIT_PULL_LIMIT)})` + " { pageInfo { hasNextPage } nodes { number state baseRefName body mergeCommit { oid }" + ` closingIssuesReferences(first: ${String(CLOSING_LIMIT)}) { pageInfo { hasNextPage }` + " nodes { number repository { nameWithOwner } } } } } } }").join("");
+  const query = `query($owner: String!, $repo: String!${declared}) { repository(owner: $owner, name: $repo) { nameWithOwner${objects} } }`;
+  return Object.freeze([
+    "api",
+    "graphql",
+    "-F",
+    "owner={owner}",
+    "-F",
+    "repo={repo}",
+    ...commits.flatMap((commit, index) => ["-f", `${commitAlias(index)}=${commit}`]),
+    "-f",
+    `query=${query}`
+  ]);
+}
+function refuse7(problem2) {
+  throw new Error(`${PREFIX5}: ${problem2}`);
+}
+function readMapping2(value, where) {
+  if (!isMapping(value))
+    refuse7(`${where} is ${describeValue(value)}, expected a mapping`);
+  return value;
+}
+function readList2(value, where) {
+  if (!Array.isArray(value))
+    refuse7(`${where} is ${describeValue(value)}, expected a list`);
+  return value;
+}
+function readNumber(value, where) {
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 1) {
+    refuse7(`${where} is ${describeValue(value)}, expected a positive whole number`);
+  }
+  return value;
+}
+function readString(value, where) {
+  if (typeof value !== "string")
+    refuse7(`${where} is ${describeValue(value)}, expected a string`);
+  return value;
+}
+function readOnePage(value, where) {
+  const connection = readMapping2(value, where);
+  if (readMapping2(connection["pageInfo"], `${where}.pageInfo`)["hasNextPage"] !== false) {
+    refuse7(`${where} holds more entries than one page`);
+  }
+  return readList2(connection["nodes"], `${where}.nodes`);
+}
+function readPull(value, where, repository) {
+  const pull2 = readMapping2(value, where);
+  if (pull2["state"] !== "MERGED")
+    return null;
+  const merge = pull2["mergeCommit"];
+  const linked = readOnePage(pull2["closingIssuesReferences"], `${where}.closingIssuesReferences`).flatMap((node, index) => {
+    const at = `${where}.closingIssuesReferences[${String(index)}]`;
+    const issue = readMapping2(node, at);
+    const owner = readString(readMapping2(issue["repository"], `${at}.repository`)["nameWithOwner"], `${at}.repository.nameWithOwner`);
+    return owner.toLowerCase() === repository.toLowerCase() ? [readNumber(issue["number"], `${at}.number`)] : [];
+  });
+  return {
+    number: readNumber(pull2["number"], `${where}.number`),
+    baseRefName: readString(pull2["baseRefName"], `${where}.baseRefName`),
+    mergeCommit: isMapping(merge) ? readString(merge["oid"], `${where}.mergeCommit.oid`) : null,
+    issues: [...linked, ...closedIssuesIn(readString(pull2["body"], `${where}.body`))]
+  };
+}
+function broughtBy(pulls, commit, branch) {
+  const merged2 = pulls.filter((pull2) => pull2.mergeCommit === commit);
+  return merged2.length > 0 ? merged2 : pulls.filter((pull2) => pull2.baseRefName === branch);
+}
+async function readBatch(gh, commits, branch) {
+  const result2 = await gh(commitPullsArgs(commits));
+  if (!result2.ok)
+    refuse7(`gh api graphql failed: ${result2.stderr.trim() || result2.stdout.trim()}`);
+  let parsed;
+  try {
+    parsed = JSON.parse(result2.stdout);
+  } catch {
+    refuse7("gh api graphql answered text that is not JSON");
+  }
+  const data = readMapping2(readMapping2(parsed, "the answer")["data"], "data");
+  const answer2 = readMapping2(data["repository"], "data.repository");
+  const repository = readString(answer2["nameWithOwner"], "data.repository.nameWithOwner");
+  return commits.flatMap((commit, index) => {
+    const where = `commit ${commit}`;
+    const object = answer2[commitAlias(index)];
+    if (object === null || object === undefined)
+      return [];
+    const pulls = readOnePage(readMapping2(object, where)["associatedPullRequests"], `${where}.associatedPullRequests`).map((pull2, at) => readPull(pull2, `${where}.associatedPullRequests[${String(at)}]`, repository)).filter((pull2) => pull2 !== null);
+    return broughtBy(pulls, commit, branch);
+  });
+}
+async function readPulls(gh, commits, branch) {
+  const pulls = [];
+  for (let start2 = 0;start2 < commits.length; start2 += COMMIT_BATCH) {
+    pulls.push(...await readBatch(gh, commits.slice(start2, start2 + COMMIT_BATCH), branch));
+  }
+  return pulls;
+}
+function releasedCommits(delivered) {
+  const { outcome } = delivered;
+  if (outcome.outcome !== "pushed" && outcome.outcome !== "superseded")
+    return null;
+  return [...new Set(outcome.build.fragments.map((fragment) => fragment.commit))];
+}
+async function refreshProjectAfterSettle(options) {
+  const { config, branch, refresh = refreshIssueItems } = options;
+  const commits = releasedCommits(options.delivered);
+  if (config.boardProjectNumber === null || commits === null || commits.length === 0)
+    return null;
+  const gh = options.openGh();
+  let pulls;
+  try {
+    pulls = await readPulls(gh, commits, branch);
+  } catch (error) {
+    return { commits, pullRequests: [], issues: [], warnings: [settleProblemLine([], messageOf(error))] };
+  }
+  const pullRequests = [...new Set(pulls.map((pull2) => pull2.number))];
+  const issues = [...new Set(pulls.flatMap((pull2) => pull2.issues))];
+  if (issues.length === 0)
+    return { commits, pullRequests, issues, warnings: [] };
+  try {
+    return { commits, pullRequests, issues, warnings: (await refresh({ config, gh }, issues)).warnings };
+  } catch (error) {
+    return { commits, pullRequests, issues, warnings: [settleProblemLine(issues, messageOf(error))] };
+  }
+}
+
 // src/commands/release/settle.ts
 var RELEASE_SETTLE_USAGE = "rafa release settle [--dry-run]";
 var COMMAND_NAME12 = "rafa release settle";
-var DRY_RUN_FLAG6 = "dry-run";
+var DRY_RUN_FLAG7 = "dry-run";
 var INDENT9 = "  ";
 var SHORT_HASH4 = 12;
 var DEFAULT_RELEASE_SETTLE_SEAMS = Object.freeze({});
@@ -20423,7 +21461,7 @@ function unwrittenEnding(reading) {
 }
 function resultOf6(base, lines, problem2) {
   const exitCode = problem2 === null ? 0 : 1;
-  return { ...base, lines, problem: problem2, exitCode };
+  return { ...base, lines, problem: problem2, exitCode, project: null };
 }
 function dryRunResult(reading, ref8, branch) {
   const base = { dryRun: true, delivery: null, reading, delivered: null, tag: null };
@@ -20481,7 +21519,7 @@ function providerFor(project, config, seams) {
 }
 async function runSettle(context, seams = DEFAULT_RELEASE_SETTLE_SEAMS) {
   expectNoArgument(context.args, RELEASE_SETTLE_USAGE);
-  const dryRun = readSwitch(DRY_RUN_FLAG6, context.flags[DRY_RUN_FLAG6], `Usage: ${RELEASE_SETTLE_USAGE}`);
+  const dryRun = readSwitch(DRY_RUN_FLAG7, context.flags[DRY_RUN_FLAG7], `Usage: ${RELEASE_SETTLE_USAGE}`);
   const project = projectOf9(context);
   const config = resolveProjectConfig(project, COMMAND_NAME12, (message) => {
     context.output.warn(message);
@@ -20505,7 +21543,16 @@ async function runSettle(context, seams = DEFAULT_RELEASE_SETTLE_SEAMS) {
     context.output.warn(`The settle worktree was not fully removed: ${ran.leftover}`);
   if (!ran.ok)
     throw new CommandExit(1, `\u274C ${ran.problem}`);
-  return ran.value;
+  if (ran.value.delivered === null)
+    return ran.value;
+  const refreshed = await refreshProjectAfterSettle({
+    delivered: ran.value.delivered,
+    branch,
+    config,
+    openGh: () => (seams.gh ?? ((cwd) => createGhRunner({ cwd })))(project.root),
+    refresh: seams.refresh
+  });
+  return { ...ran.value, project: refreshed };
 }
 function createReleaseSettleCommand(seams = DEFAULT_RELEASE_SETTLE_SEAMS) {
   const command = {
@@ -20517,7 +21564,7 @@ function createReleaseSettleCommand(seams = DEFAULT_RELEASE_SETTLE_SEAMS) {
     args: [],
     flags: [
       {
-        name: DRY_RUN_FLAG6,
+        name: DRY_RUN_FLAG7,
         description: "Print the fragments, their order, the strategy and the version, and write nothing:" + " no commit, no push, no tag.",
         type: "boolean"
       }
@@ -20539,7 +21586,12 @@ function createReleaseSettleCommand(seams = DEFAULT_RELEASE_SETTLE_SEAMS) {
     outputs: ["text", "json"],
     run: async (context) => {
       const result2 = await runSettle(context, seams);
+      const warnProject = () => {
+        for (const line of result2.project?.warnings ?? [])
+          context.output.warn(line);
+      };
       if (context.outputMode === "json") {
+        warnProject();
         if (result2.problem !== null)
           throw new CommandExit(1, result2.problem);
         context.output.result(result2);
@@ -20547,6 +21599,7 @@ function createReleaseSettleCommand(seams = DEFAULT_RELEASE_SETTLE_SEAMS) {
       }
       for (const line of result2.lines)
         context.output.info(line);
+      warnProject();
       if (result2.problem !== null)
         throw new CommandExit(1, result2.problem);
     }
@@ -20556,7 +21609,7 @@ function createReleaseSettleCommand(seams = DEFAULT_RELEASE_SETTLE_SEAMS) {
 var settle_default = createReleaseSettleCommand();
 
 // src/commands/release/tag.ts
-import { readFileSync as readFileSync20 } from "fs";
+import { readFileSync as readFileSync21 } from "fs";
 import { join as join36 } from "path";
 
 // src/commands/release/release-commit.ts
@@ -20615,7 +21668,7 @@ function readBranch2(git) {
 }
 function textOf(path) {
   try {
-    return readFileSync20(path, "utf8");
+    return readFileSync21(path, "utf8");
   } catch {
     return null;
   }
@@ -20694,24 +21747,24 @@ function followUpsFor(tag, version2, target, publish, place2 = ON_HEAD) {
     }
   ];
 }
-function refuse7(reason, message) {
+function refuse8(reason, message) {
   return { kind: "refused", reason, message };
 }
 function branchRefusal(inputs) {
   const { branch, problem: problem2 } = inputs.branch;
   if (branch === null) {
-    return refuse7("branch", `${problem2 ?? "no branch is checked out"}, and a release is tagged` + ` on ${inputs.releaseBranch}`);
+    return refuse8("branch", `${problem2 ?? "no branch is checked out"}, and a release is tagged` + ` on ${inputs.releaseBranch}`);
   }
-  return branch === inputs.releaseBranch ? null : refuse7("branch", `a release is tagged on ${inputs.releaseBranch}, and ${branch} is checked out`);
+  return branch === inputs.releaseBranch ? null : refuse8("branch", `a release is tagged on ${inputs.releaseBranch}, and ${branch} is checked out`);
 }
 function changelogRefusal(inputs, version2) {
   const { path, version: newest, problem: problem2 } = inputs.changelog;
   if (problem2 !== null)
-    return refuse7("changelog", problem2);
+    return refuse8("changelog", problem2);
   if (newest === null) {
-    return refuse7("changelog", `${path} names no release, so nothing says ${version2} is the version to tag`);
+    return refuse8("changelog", `${path} names no release, so nothing says ${version2} is the version to tag`);
   }
-  return newest === version2 ? null : refuse7("changelog", `${inputs.version.path} says ${version2} and the newest section of ${path}` + ` says ${newest}`);
+  return newest === version2 ? null : refuse8("changelog", `${inputs.version.path} says ${version2} and the newest section of ${path}` + ` says ${newest}`);
 }
 function decideTag(inputs) {
   const onBranch = branchRefusal(inputs);
@@ -20719,13 +21772,13 @@ function decideTag(inputs) {
     return onBranch;
   const version2 = inputs.version.version;
   if (version2 === null) {
-    return refuse7("version", inputs.version.problem ?? `${inputs.version.path} declares no version`);
+    return refuse8("version", inputs.version.problem ?? `${inputs.version.path} declares no version`);
   }
   if (inputs.tags.problem !== null)
-    return refuse7("git", inputs.tags.problem);
+    return refuse8("git", inputs.tags.problem);
   const held = inputs.tags.tags.find((candidate) => candidate.version === version2);
   if (held !== undefined) {
-    return refuse7("tagged", `${held.tag} already names ${version2}, so there is nothing to tag`);
+    return refuse8("tagged", `${held.tag} already names ${version2}, so there is nothing to tag`);
   }
   const disagrees = changelogRefusal(inputs, version2);
   if (disagrees !== null)
@@ -20733,14 +21786,14 @@ function decideTag(inputs) {
   const path = inputs.changelog.path;
   const unreceipted = inputs.receipt === null ? `${path} was not read for the receipt of ${version2}` : receiptProblem(inputs.receipt, version2, path);
   if (unreceipted !== null)
-    return refuse7("receipt", unreceipted);
+    return refuse8("receipt", unreceipted);
   const release = inputs.release;
   if (release === null)
-    return refuse7("version", `${inputs.version.path} was not looked up in the history`);
+    return refuse8("version", `${inputs.version.path} was not looked up in the history`);
   if (release.problem !== null)
-    return refuse7(release.problem.reason, release.problem.message);
+    return refuse8(release.problem.reason, release.problem.message);
   if (release.commit === null)
-    return refuse7("git", `no commit could be named for ${version2}`);
+    return refuse8("git", `no commit could be named for ${version2}`);
   return { kind: "ready", version: version2, tag: versionTag(version2), commit: release.commit, ahead: release.ahead };
 }
 function projectOf10(context) {
@@ -20913,7 +21966,7 @@ import { copyFileSync as copyFileSync4, existsSync as existsSync12, mkdirSync as
 import { dirname as dirname9, isAbsolute as isAbsolute7, join as join38, relative as relative9, resolve as resolve13, sep as sep5 } from "path";
 
 // src/backfill/proposal-file.ts
-import { readdirSync as readdirSync4, readFileSync as readFileSync21 } from "fs";
+import { readdirSync as readdirSync4, readFileSync as readFileSync22 } from "fs";
 import { join as join37 } from "path";
 var BACKFILL_PATH = join37(".rafa", "backfill");
 var PROPOSAL_FILE_PREFIX = "proposals-";
@@ -21079,7 +22132,7 @@ function readProposalFiles(dir) {
   return names.filter((name) => isProposalFileName(name)).sort((left, right) => left.localeCompare(right)).map((name) => {
     const path = join37(dir, name);
     try {
-      return { path, result: parseProposalFile(readFileSync21(path, "utf8")) };
+      return { path, result: parseProposalFile(readFileSync22(path, "utf8")) };
     } catch (error) {
       return { path, result: unreadable2(`the file cannot be read (${error instanceof Error ? error.message : String(error)})`) };
     }
@@ -21135,7 +22188,7 @@ function countBackups(results) {
 }
 
 // src/backfill/derive.ts
-import { readFileSync as readFileSync22, writeFileSync as writeFileSync9 } from "fs";
+import { readFileSync as readFileSync23, writeFileSync as writeFileSync10 } from "fs";
 import { basename as basename6 } from "path";
 var DERIVED_FIELDS = ["stack", "paths", "when_to_use"];
 function renderWhenToUse(trigger, prevents) {
@@ -21261,7 +22314,7 @@ function planFile(entry, options) {
   }
   let original;
   try {
-    original = readFileSync22(entry.path, "utf8");
+    original = readFileSync23(entry.path, "utf8");
   } catch (error) {
     return inert(entry, "skipped", `the file cannot be read (${error instanceof Error ? error.message : String(error)})`);
   }
@@ -21305,7 +22358,7 @@ function planDerivation(root, options) {
 function applyFile(action, options) {
   if (action.text === null || action.original === null)
     return action;
-  const current = readFileSync22(action.path, "utf8");
+  const current = readFileSync23(action.path, "utf8");
   if (current !== action.original) {
     return {
       ...action,
@@ -21314,7 +22367,7 @@ function applyFile(action, options) {
       text: null
     };
   }
-  writeFileSync9(action.path, action.text, "utf8");
+  writeFileSync10(action.path, action.text, "utf8");
   const after = failureLines(checkFile(action.path, "skill", {
     projectRoot: options.projectRoot,
     pathDirs: options.pathDirs
@@ -21322,7 +22375,7 @@ function applyFile(action, options) {
   const added = addedFailures(action.before, after);
   if (added.length === 0)
     return action;
-  writeFileSync9(action.path, action.original, "utf8");
+  writeFileSync10(action.path, action.original, "utf8");
   return {
     ...action,
     kind: "refused",
@@ -21336,7 +22389,7 @@ function applyDerivation(plan2, options) {
 }
 
 // src/backfill/proposal-batch.ts
-import { readFileSync as readFileSync23 } from "fs";
+import { readFileSync as readFileSync24 } from "fs";
 import { relative as relative10 } from "path";
 
 // src/demote/report.ts
@@ -21635,7 +22688,7 @@ function readCandidate(root, entry) {
     return null;
   let text;
   try {
-    text = readFileSync23(entry.path, "utf8");
+    text = readFileSync24(entry.path, "utf8");
   } catch {
     return null;
   }
@@ -21741,7 +22794,7 @@ function parseSessionAnswer(stdout) {
 }
 
 // src/backfill/propose.ts
-import { mkdirSync as mkdirSync10, readFileSync as readFileSync24, writeFileSync as writeFileSync10 } from "fs";
+import { mkdirSync as mkdirSync10, readFileSync as readFileSync25, writeFileSync as writeFileSync11 } from "fs";
 import { join as join39, resolve as resolve14 } from "path";
 var PROPOSAL_ACTION_KINDS = [
   "applied",
@@ -21826,7 +22879,7 @@ async function runProposalPass(options) {
     const number = index + 1;
     const file = await runProposalBatch(number, batch, options);
     const path = proposalPath(options.backfillDir, number);
-    writeFileSync10(path, renderProposalFile(file), "utf8");
+    writeFileSync11(path, renderProposalFile(file), "utf8");
     written.push({ path, file });
   }
   return { written, candidates: candidates.length };
@@ -21868,7 +22921,7 @@ function writeRow(path, row2, original, options) {
     return inert2(path, row2, "unchanged", "every field the row proposes is already what the file carries");
   }
   const before = checkLines(path, options);
-  writeFileSync10(path, writeFrontmatter(document, mergeFrontmatter(document.data, changes)), "utf8");
+  writeFileSync11(path, writeFrontmatter(document, mergeFrontmatter(document.data, changes)), "utf8");
   const added = addedFailures(before, checkLines(path, options));
   if (added.length === 0) {
     return {
@@ -21880,7 +22933,7 @@ function writeRow(path, row2, original, options) {
       added: []
     };
   }
-  writeFileSync10(path, original, "utf8");
+  writeFileSync11(path, original, "utf8");
   return {
     path,
     relative: row2.path,
@@ -21900,7 +22953,7 @@ function applyRow(root, row2, options) {
   }
   let original;
   try {
-    original = readFileSync24(path, "utf8");
+    original = readFileSync25(path, "utf8");
   } catch {
     return inert2(path, row2, "refused", "the file the row names is gone");
   }
@@ -21939,7 +22992,7 @@ function applyProposals(files, root, options) {
 }
 
 // src/demote/select.ts
-import { readdirSync as readdirSync5, readFileSync as readFileSync25, realpathSync as realpathSync5, statSync as statSync10 } from "fs";
+import { readdirSync as readdirSync5, readFileSync as readFileSync26, realpathSync as realpathSync5, statSync as statSync10 } from "fs";
 import { basename as basename7, dirname as dirname10, join as join40 } from "path";
 var SKILLS_DIRECTORY = "skills";
 var CLAUDE_DIRECTORY = ".claude";
@@ -22001,7 +23054,7 @@ function readSelected(absolute, path, entries) {
   let text;
   let mtime;
   try {
-    text = readFileSync25(absolute, "utf8");
+    text = readFileSync26(absolute, "utf8");
     mtime = statSync10(absolute).mtime.toISOString();
   } catch {
     return null;
@@ -22386,11 +23439,11 @@ function createSkillCheckCommand(seams = DEFAULT_CHECK_SEAMS) {
 var check_default3 = createSkillCheckCommand();
 
 // src/commands/skill/demote.ts
-import { existsSync as existsSync14, mkdirSync as mkdirSync12, readFileSync as readFileSync27, statSync as statSync13, writeFileSync as writeFileSync12 } from "fs";
+import { existsSync as existsSync14, mkdirSync as mkdirSync12, readFileSync as readFileSync28, statSync as statSync13, writeFileSync as writeFileSync13 } from "fs";
 import { dirname as dirname12, resolve as resolve16 } from "path";
 
 // src/demote/apply.ts
-import { copyFileSync as copyFileSync5, existsSync as existsSync13, mkdirSync as mkdirSync11, mkdtempSync as mkdtempSync3, readdirSync as readdirSync6, readFileSync as readFileSync26, renameSync, rmSync as rmSync3, statSync as statSync12, unlinkSync, writeFileSync as writeFileSync11 } from "fs";
+import { copyFileSync as copyFileSync5, existsSync as existsSync13, mkdirSync as mkdirSync11, mkdtempSync as mkdtempSync3, readdirSync as readdirSync6, readFileSync as readFileSync27, renameSync, rmSync as rmSync3, statSync as statSync12, unlinkSync, writeFileSync as writeFileSync12 } from "fs";
 import { tmpdir as tmpdir3 } from "os";
 import { dirname as dirname11, join as join42 } from "path";
 var DEMOTION_ACTION_KINDS = [
@@ -22432,7 +23485,7 @@ function takenInstinctIds(dir) {
 }
 function readText4(path) {
   try {
-    return statSync12(path).isFile() ? readFileSync26(path, "utf8") : null;
+    return statSync12(path).isFile() ? readFileSync27(path, "utf8") : null;
   } catch {
     return null;
   }
@@ -22475,7 +23528,7 @@ function planKept(scope, row2, file) {
 }
 function checkCandidate(dir, id2, text, pathDirs) {
   const path = join42(dir, `${id2}${MARKDOWN_EXTENSION}`);
-  writeFileSync11(path, text, "utf8");
+  writeFileSync12(path, text, "utf8");
   const report5 = checkFile(path, "instinct", { projectRoot: null, pathDirs });
   return failureLines2(report5.issues);
 }
@@ -22564,7 +23617,7 @@ function applyDemotion(plan2) {
   for (const action of plan2.actions) {
     if (action.write !== null) {
       mkdirSync11(dirname11(action.write.path), { recursive: true });
-      writeFileSync11(action.write.path, action.write.text, "utf8");
+      writeFileSync12(action.write.path, action.write.text, "utf8");
     }
     if (action.move !== null)
       moveFile(action.move);
@@ -22663,7 +23716,7 @@ function verdictLine2(report5) {
 function previousReport(path, context) {
   if (!existsSync14(path))
     return null;
-  const parsed = parseDemotionReport(readFileSync27(path, "utf8"));
+  const parsed = parseDemotionReport(readFileSync28(path, "utf8"));
   if (parsed.report !== null)
     return parsed.report;
   context.output.warn(`the report already at ${path} does not parse, so no override in it is carried forward:` + ` ${parsed.issues.map((issue2) => `line ${String(issue2.line)} ${issue2.code}`).join(", ")}`);
@@ -22673,7 +23726,7 @@ function runWrite(context, scope) {
   const files = selectSources(scope);
   const report5 = buildDemotionReport(files, previousReport(scope.reportPath, context));
   mkdirSync12(dirname12(scope.reportPath), { recursive: true });
-  writeFileSync12(scope.reportPath, writeDemotionReport(report5), "utf8");
+  writeFileSync13(scope.reportPath, writeDemotionReport(report5), "utf8");
   const result2 = {
     applied: false,
     scope: scope.scope,
@@ -22699,7 +23752,7 @@ function reviewedReport(scope) {
   if (!existsSync14(scope.reportPath)) {
     throw new CommandExit(1, `\u274C No report at ${scope.reportPath}; run "rafa skill demote ${scope.dir}" first, then review it`);
   }
-  const parsed = parseDemotionReport(readFileSync27(scope.reportPath, "utf8"));
+  const parsed = parseDemotionReport(readFileSync28(scope.reportPath, "utf8"));
   if (parsed.report === null) {
     const lines = parsed.issues.map((issue2) => `   line ${String(issue2.line)} ${issue2.code}: ${issue2.message}`);
     throw new CommandExit(1, [`\u274C ${scope.reportPath} does not parse:`, ...lines].join(`
@@ -22806,7 +23859,7 @@ var demote_default = createSkillDemoteCommand();
 // src/commands/skill/show.ts
 var DEFAULT_SKILL_SHOW_SEAMS = DEFAULT_SKILL_LIST_SEAMS;
 var COMMAND_NAME13 = "rafa skill show";
-var USAGE42 = "rafa skill show <name> [--full]";
+var USAGE43 = "rafa skill show <name> [--full]";
 function unknownSkillMessage(name, inventory) {
   const agent = findShown(inventory.records, "agent", name);
   const hint = agent === null ? [] : [`An agent is named "${name}" (${agent.source}): rafa agent show ${name}`];
@@ -22814,7 +23867,7 @@ function unknownSkillMessage(name, inventory) {
     `\u274C No skill is named "${name}".`,
     ...hint,
     "Run `rafa skill list` to see every skill and where it comes from.",
-    `Usage: ${USAGE42}`
+    `Usage: ${USAGE43}`
   ].join(`
 `);
 }
@@ -22830,8 +23883,8 @@ function projectOf13(context) {
   return context.project;
 }
 async function runShow3(context, seams) {
-  const full = readSwitch("full", context.flags["full"], `Type the name ahead of it: ${USAGE42}`);
-  const name = expectOneArgument(context.args, USAGE42);
+  const full = readSwitch("full", context.flags["full"], `Type the name ahead of it: ${USAGE43}`);
+  const name = expectOneArgument(context.args, USAGE43);
   const project = projectOf13(context);
   const { inventory, settingSources } = await projectInventory(project, context, seams, COMMAND_NAME13);
   const warnings = warningLines(inventory);
@@ -22943,7 +23996,7 @@ var VERDICT_WORDS = Object.freeze({
   pending: "checks pending",
   none: "no checks"
 });
-function counted3(count, noun, plural4 = `${noun}s`) {
+function counted4(count, noun, plural4 = `${noun}s`) {
   return `${String(count)} ${count === 1 ? noun : plural4}`;
 }
 function info2(text) {
@@ -22958,7 +24011,7 @@ function blockedTaskCount(blocked) {
 }
 function loopsText(reading) {
   const tasks = blockedTaskCount(reading.blocked);
-  return `${String(reading.live.length)} running, ${counted3(tasks, "task")} blocked`;
+  return `${String(reading.live.length)} running, ${counted4(tasks, "task")} blocked`;
 }
 function loopsBody(reading) {
   const running = reading.live.map((record) => info2(`${INDENT11}${sessionLine(record)}`));
@@ -22977,9 +24030,9 @@ function pullText(reading) {
 function blockedText(reading) {
   const { blockedIssues } = reading;
   if (reading.mode === "native") {
-    return blockedIssues === null ? "the issues with an open blocker were not read" : `${counted3(blockedIssues, "issue")} with an open blocker`;
+    return blockedIssues === null ? "the issues with an open blocker were not read" : `${counted4(blockedIssues, "issue")} with an open blocker`;
   }
-  return blockedIssues === null ? `the ${SPEC_BLOCKED_LABEL} issues were not read` : `${counted3(blockedIssues, "issue")} labelled ${SPEC_BLOCKED_LABEL}`;
+  return blockedIssues === null ? `the ${SPEC_BLOCKED_LABEL} issues were not read` : `${counted4(blockedIssues, "issue")} labelled ${SPEC_BLOCKED_LABEL}`;
 }
 function boardText(reading) {
   const roadmap = `roadmap #${String(reading.roadmap)}`;
@@ -23008,7 +24061,7 @@ function claimsText(reading) {
   if (claims.length === 0)
     return "none on origin as last fetched";
   const count = (states) => claims.filter((row2) => states.includes(row2.state)).length;
-  return `${counted3(claims.length, "claim branch", "claim branches")} on origin as last fetched:` + ` ${String(count(["held"]))} held, ${String(count(["stale-claimed", "stale-in-development"]))} stale,` + ` ${String(count(["released"]))} released`;
+  return `${counted4(claims.length, "claim branch", "claim branches")} on origin as last fetched:` + ` ${String(count(["held"]))} held, ${String(count(["stale-claimed", "stale-in-development"]))} stale,` + ` ${String(count(["released"]))} released`;
 }
 function claimHolder(row2) {
   if (row2.owner === null)
@@ -23037,7 +24090,7 @@ function claimsBody(reading) {
 }
 function housekeepingText(reading) {
   const { merged: merged2, stale, notPushed, worktrees } = reading.counts;
-  return `${String(merged2)} merged, ${String(stale)} stale, ${String(notPushed)} not pushed,` + ` ${counted3(worktrees, "worktree")} (${String(reading.idleWorktrees)} idle)`;
+  return `${String(merged2)} merged, ${String(stale)} stale, ${String(notPushed)} not pushed,` + ` ${counted4(worktrees, "worktree")} (${String(reading.idleWorktrees)} idle)`;
 }
 function sectionLines(key, section, text, body = () => []) {
   const title = STATUS_SECTION_TITLES[key];
@@ -23115,7 +24168,7 @@ function readClaimBranches(git) {
 function isClaim(reading) {
   return reading.state === "found" && reading.ownership.state !== "none";
 }
-function stageOf(labels) {
+function stageOf2(labels) {
   return STAGE_LABELS.filter((label) => labels.includes(label));
 }
 function labelsOf2(labels, issue2) {
@@ -23123,7 +24176,7 @@ function labelsOf2(labels, issue2) {
     return null;
   return labels.issues.find((one) => one.number === issue2)?.labels ?? null;
 }
-function rowOf4(reading, input) {
+function rowOf5(reading, input) {
   const { ownership, tipCommittedAt, branch } = reading;
   const issue2 = claimBranchIssue(branch) ?? 0;
   const labels = labelsOf2(input.labels, issue2);
@@ -23135,7 +24188,7 @@ function rowOf4(reading, input) {
     owner: ownership.state === "held" ? ownership.owner : null,
     handingTo: ownership.state === "held" ? ownership.pending?.to ?? null : null,
     releasedBy: ownership.state === "released" ? ownership.releasedBy : null,
-    stage: labels === null ? null : stageOf(labels),
+    stage: labels === null ? null : stageOf2(labels),
     state: state.state,
     tipCommittedAt: tipCommittedAt.toISOString(),
     idleMs: Number.isFinite(elapsed) ? Math.max(0, elapsed) : 0
@@ -23149,7 +24202,7 @@ function labelNotes(rows, labels) {
   return rows.filter((row2) => row2.stage === null).map((row2) => `#${String(row2.issue)} is not in the board listing, so its stage labels were not read`);
 }
 function readClaims2(input) {
-  const claims = input.branches.found.map((reading) => rowOf4(reading, input));
+  const claims = input.branches.found.map((reading) => rowOf5(reading, input));
   return { claims, notes: [...input.branches.notes, ...labelNotes(claims, input.labels)] };
 }
 
@@ -23295,9 +24348,9 @@ function pullSection(sources, branch, provider, deadline) {
   if (!branch.read) {
     return Promise.resolve(unread2(`no pull request was looked for, as the branch was not read: ${branch.problem}`));
   }
-  return networkSection("pull request", deadline, () => readPull(sources, branch.branch));
+  return networkSection("pull request", deadline, () => readPull2(sources, branch.branch));
 }
-async function readPull(sources, branch) {
+async function readPull2(sources, branch) {
   let notes = [];
   const pull2 = await readOpenPull(sources, branch, (problem2) => {
     notes = [...notes, problem2];
@@ -23361,7 +24414,7 @@ async function placeOrNote(sources, walk, listing2) {
   }
 }
 async function readBoard2(sources, board, listing2, blocked, native) {
-  const [walk, counted4] = await Promise.all([board.next(), blocked]);
+  const [walk, counted5] = await Promise.all([board.next(), blocked]);
   const { line } = walk;
   const next = line === null ? null : { line, ready: await board.isReady(line.issue), blocked: await board.blocking(line.issue) };
   const { place: place2, notes } = await placeOrNote(sources, walk, listing2);
@@ -23369,8 +24422,8 @@ async function readBoard2(sources, board, listing2, blocked, native) {
     roadmap: walk.roadmap,
     next,
     passed: walk.passed,
-    blockedIssues: counted4.count,
-    notes: [...walk.problems, ...counted4.notes, ...notes]
+    blockedIssues: counted5.count,
+    notes: [...walk.problems, ...counted5.notes, ...notes]
   };
   const reading = native ? { ...read3, mode: "native" } : read3;
   return place2 === null ? reading : { ...reading, place: place2 };
@@ -23533,7 +24586,7 @@ function createUpdateStub(spec) {
 var board_default = createUpdateStub({ action: "board", summary: "apply the board's newest setup and its migrations", issue: 717 });
 
 // src/project/lock.ts
-import { existsSync as existsSync16, lstatSync as lstatSync2, readFileSync as readFileSync28, writeFileSync as writeFileSync13 } from "fs";
+import { existsSync as existsSync16, lstatSync as lstatSync2, readFileSync as readFileSync29, writeFileSync as writeFileSync14 } from "fs";
 import { join as join43 } from "path";
 var LOCK_FILE = "rafa.lock";
 var LOCKFILE_VERSION = 1;
@@ -23556,20 +24609,20 @@ function isLink(path) {
     return false;
   }
 }
-function refuse8(problem2) {
+function refuse9(problem2) {
   throw new ProjectLockError(`${LOCK_FILE} ${problem2}`);
 }
 function lockOf(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value))
-    refuse8("holds no JSON object");
+    refuse9("holds no JSON object");
   const record = value;
   const format = record["lockfileVersion"];
   if (format !== LOCKFILE_VERSION) {
-    refuse8(`is in lockfileVersion ${String(format)}, and this rafa reads ${String(LOCKFILE_VERSION)}: a newer rafa wrote it`);
+    refuse9(`is in lockfileVersion ${String(format)}, and this rafa reads ${String(LOCKFILE_VERSION)}: a newer rafa wrote it`);
   }
   const rafa = record["rafa"];
   if (typeof rafa !== "string" || parseSemanticVersion(rafa) === null) {
-    refuse8(`names rafa ${JSON.stringify(rafa)}, which is no version`);
+    refuse9(`names rafa ${JSON.stringify(rafa)}, which is no version`);
   }
   return { lockfileVersion: LOCKFILE_VERSION, rafa };
 }
@@ -23577,25 +24630,25 @@ function readProjectLock(root) {
   const path = lockPath(root);
   if (!existsSync16(path)) {
     if (isLink(path))
-      refuse8("is a link to nothing");
+      refuse9("is a link to nothing");
     return null;
   }
   let text;
   try {
-    text = readFileSync28(path, "utf8");
+    text = readFileSync29(path, "utf8");
   } catch (error) {
-    refuse8(`could not be read: ${messageOf(error)}`);
+    refuse9(`could not be read: ${messageOf(error)}`);
   }
   let value;
   try {
     value = JSON.parse(text);
   } catch {
-    refuse8("is not JSON");
+    refuse9("is not JSON");
   }
   return lockOf(value);
 }
 function writeProjectLock(root, version2) {
-  writeFileSync13(lockPath(root), projectLockText(version2), "utf8");
+  writeFileSync14(lockPath(root), projectLockText(version2), "utf8");
 }
 
 // src/project/update-current.ts
@@ -23712,7 +24765,7 @@ function readCurrentRange(recorded, installed) {
 }
 
 // src/commands/update/current.ts
-var USAGE43 = "rafa update current [--dry-run] [--yes]";
+var USAGE44 = "rafa update current [--dry-run] [--yes]";
 var APPLY_QUESTION = "Apply these changes? [y/N] ";
 var YES_ANSWERS5 = ["y", "yes"];
 function checkoutLockRoot(root, dir) {
@@ -23737,7 +24790,7 @@ function readSwitch5(context, name) {
   if (value === true || value === "true")
     return true;
   throw new CommandExit(1, `\u274C --${name} takes no value, and read "${String(value)}" as one
-Usage: ${USAGE43}`);
+Usage: ${USAGE44}`);
 }
 function couldNotRun(problem2) {
   return new CommandExit(2, `FAIL \u2014 ${problem2}
@@ -23873,7 +24926,7 @@ function stopLine2(plan2, dryRun) {
   return null;
 }
 async function runUpdateCurrent(context, seams) {
-  expectNoArgument(context.args, USAGE43);
+  expectNoArgument(context.args, USAGE44);
   const dryRun = readSwitch5(context, "dry-run");
   const yes = readSwitch5(context, "yes");
   const project = projectOf15(context);
@@ -23959,7 +25012,7 @@ var CORE_SUBJECTS = Object.freeze([
   { name: "skill", summary: "check a skills directory; list each tier; demote and backfill it" },
   { name: "instinct", summary: "check an instincts directory; list, show, flag and promote its records" },
   { name: "release", summary: "read the release state of the project; settle the waiting fragments into a version; tag the commit that set it" },
-  { name: "board", summary: "list the boards with their owner, epic count, and which is current and home" },
+  { name: "board", summary: "list the boards with their owner, epic count, and which is current and home; sync the GitHub project" },
   { name: "epic", summary: "show one epic's issues as the Roadmap table; create an epic; defer or promote it; move an issue to it; close it through the gate or cancel it" },
   { name: "claim", summary: "give up this device's claim on an issue; hand it to another store or withdraw the offer; accept a handover; take over a stale claim" },
   { name: "update", summary: "bring this project to the installed rafa; the other updates are in development" }
@@ -24025,6 +25078,7 @@ var CORE_COMMANDS = Object.freeze([
   settle_default,
   tag_default,
   list_default5,
+  sync_default,
   show_default,
   new_default,
   defer_default,