@open-tomato/rafa 0.18.0 → 0.20.0

package/dist/{index-cvpdvmtg.js → index-zhh1h3h9.js}

@@ -1,23 +1,23 @@
 // @bun
 import {
-  ACTION_HEADING,
   AGENT_DEFINITION_DIR,
   BRANCH_PREFIX,
-  CAUSE_HEADING,
   CI_POLL_INTERVAL_MS,
   DEFAULT_BASE_BRANCH,
   DEFAULT_CI_ATTEMPTS,
   DEFAULT_CI_TIMEOUT_MIN,
   DEFAULT_ISSUE_SEAMS,
   DEFAULT_PLAN_FILE,
+  DEMOTION_VERDICTS,
   DESCRIPTION_LIMIT,
   DISK_FILE_SYSTEM,
   HINT_FLAG_SPEC,
   ID_PREFIX,
+  LEARNED_DIRECTORY,
   LISTING_LIMIT,
-  MARKDOWN_EXTENSION,
   MECHANICAL_CONFLICT_SENTENCE,
   NEXT_COMMAND_ACTIONS,
+  ORIGIN_FIELD,
   PREVIOUS_COPY_WARN_ABOVE,
   PROVENANCE_FIELD,
   REMOTE,
@@ -32,9 +32,9 @@ import {
   SCOPE_DIR,
   SERVE_CLI_VERSION,
   SESSION_ID_FLAG,
-  SKILL_FILE,
-  SKILL_FILE1 as SKILL_FILE2,
+  SKILL_FILE as SKILL_FILE2,
   SKILL_SIGNALS,
+  SKILL_USE_CLI_VERSION,
   SPEC_BLOCKED_LABEL,
   SPEC_EXTENSION,
   SPEC_LABEL,
@@ -46,7 +46,7 @@ import {
   UNREADABLE,
   VENDOR_COMMAND,
   VERSION_SHAPE,
-  actionHash,
+  WHEN_TO_USE_HEADING,
   actionInvocation,
   actionOutput,
   announceRiskTotal,
@@ -54,6 +54,7 @@ import {
   blockedFaultMessage,
   blockedLineSentence,
   boardId,
+  bodySections,
   branchClaims,
   bundledAgentsDirectory,
   byName,
@@ -62,13 +63,14 @@ import {
   checkReferences,
   checkbox,
   checkboxAt,
+  classifySkill,
   cleanUpSteps,
   closedIssuesIn,
   collect,
-  collectReferences,
   collectSessionRow,
   commandLine,
   commandWords,
+  convertToInstinct,
   coreRoster,
   countCharacters,
   countPreviousCopies,
@@ -95,6 +97,7 @@ import {
   failingRows,
   findReadinessGaps,
   fingerprintText,
+  firstSentence,
   formatCounts,
   formatRows,
   ghHostOf,
@@ -104,7 +107,6 @@ import {
   ghPreflightItems,
   ghPullRequestsIn,
   ghUnauthenticatedMessage,
-  gitRemoteUrl,
   gitSaid,
   groupChangeNotes,
   hasDiverged,
@@ -125,16 +127,13 @@ import {
   list_default,
   loadConfig,
   memoiseVerifier,
-  mergeFrontmatter,
   missingPlanAgents,
   name,
   nextQuestion,
-  normalizeRemote,
   notesFileName,
   onTracker,
   openNextSources,
   parseBaseStanding,
-  parseInstinct,
   parseRoadmapBody,
   parseSemanticVersion,
   parseWorkingTree,
@@ -150,6 +149,7 @@ import {
   previousDir,
   projectRoot,
   provenanceBlock,
+  rankCandidates,
   readAgentDirectory,
   readAuthorTrust,
   readBlockedBy,
@@ -158,9 +158,6 @@ import {
   readChoice,
   readChoiceFlag,
   readCopyRefs,
-  readFrontmatter,
-  readFrontmatterDocument,
-  readInventoryFrontmatter,
   readManifestVersion,
   readMergeRefusal,
   readNextState,
@@ -168,6 +165,7 @@ import {
   readOpenPull,
   readPlanChanges,
   readPlans,
+  readRankCandidate,
   readRecords,
   readRefsText,
   readRequiredFlag,
@@ -182,7 +180,6 @@ import {
   refusal,
   refuseMisplacedRuntime,
   remainingFrom,
-  renderFrontmatter,
   renderNoteLines,
   renderRiskText,
   report,
@@ -204,7 +201,6 @@ import {
   runAction,
   runsDir,
   scanClaimBranches,
-  scanLayout,
   scopeAt,
   selfAndAncestors,
   serveVerdict,
@@ -230,10 +226,8 @@ import {
   version,
   versionLine,
   waitForChecks,
-  writeFrontmatter,
-  writeInstinct,
   writeSession
-} from "./index-6vkd153j.js";
+} from "./index-02fx0mzf.js";
 import {
   PROBE_TIMEOUT_MS,
   findNextTask,
@@ -247,8 +241,10 @@ import {
   runPreflight,
   splitBlockerComment,
   trackerPathFor
-} from "./index-0pdsq2hy.js";
+} from "./index-21qkxk63.js";
 import {
+  ACTION_HEADING,
+  CAUSE_HEADING,
   CLAUDE_BIN,
   CORE_ADAPTER_REGISTRY,
   EFFORT_STORE_DIR,
@@ -256,17 +252,34 @@ import {
   ISSUE_PRIORITIES,
   ISSUE_STATES,
   ISSUE_TYPES,
+  MARKDOWN_EXTENSION,
+  SKILL_FILE,
+  SQLITE_MIGRATIONS,
+  allRecords,
   claudeArgs,
   createGhRunner,
   effortStorePath,
+  findRecords,
+  gitRemoteUrl,
+  instinctProject,
+  mergeFrontmatter,
+  migrateSchema,
   moduleOfLabels,
+  normalizeRemote,
+  readFrontmatter,
+  readFrontmatterDocument,
+  readScopes,
+  renderFrontmatter,
   runClaudeCaptured,
+  scanLayout,
   selectEffortStore,
   sessionSpawnEnv,
   spawnClaudeCaptured,
   sqliteStorePath,
-  typeOfLabels
-} from "./index-at9f1z2z.js";
+  toHeldRecords,
+  typeOfLabels,
+  writeFrontmatter
+} from "./index-afersvp3.js";
 import {
   CONFIG_DEFAULTS,
   CONFIG_FILE,
@@ -280,15 +293,18 @@ import {
   readItemBytes,
   readRafaBlocks,
   resolveTiers
-} from "./index-jva32qe6.js";
+} from "./index-twbp38kz.js";
+import {
+  promotable
+} from "./index-d6d0942q.js";
 import {
   createCommandRegistry,
   describeRegistry,
   mountKey
-} from "./index-kvnggvyk.js";
+} from "./index-4a45ffqh.js";
 import {
   CommandExit
-} from "./index-ddf85qac.js";
+} from "./index-28jzpyks.js";
 import {
   MERGE_METHODS,
   RELEASE_AUTO,
@@ -299,10 +315,11 @@ import {
   isMergeMethod,
   isSkillTier,
   messageOf,
-  parseBudgetUsd,
-  resolveInstinctScopes,
-  tierExists
-} from "./index-944pncd8.js";
+  parseBudgetUsd
+} from "./index-pmkgvtfe.js";
+import {
+  triggerKey
+} from "./index-wp8c28fd.js";
 
 // src/inventory/disabled.ts
 import { readFileSync } from "fs";
@@ -2274,148 +2291,6 @@ async function checkQuotes(matches, files) {
   return { kept, dropped: matches.length - kept.length };
 }
 
-// src/inventory/search/rank.ts
-import { readFileSync as readFileSync5 } from "fs";
-var SEARCH_LIMIT = 12;
-var MIN_WORD_LENGTH = 2;
-var MIN_PREFIX_LENGTH = 4;
-var FIELD_WEIGHTS = {
-  tags: 4,
-  prevents: 3,
-  whenToUse: 3,
-  description: 2,
-  body: 1
-};
-var FIELDS = ["tags", "prevents", "whenToUse", "description", "body"];
-var STOP_WORDS = new Set([
-  "a",
-  "about",
-  "an",
-  "and",
-  "any",
-  "are",
-  "as",
-  "at",
-  "be",
-  "by",
-  "can",
-  "could",
-  "do",
-  "does",
-  "for",
-  "from",
-  "has",
-  "have",
-  "how",
-  "if",
-  "in",
-  "into",
-  "is",
-  "it",
-  "its",
-  "me",
-  "my",
-  "of",
-  "on",
-  "or",
-  "should",
-  "so",
-  "that",
-  "the",
-  "their",
-  "there",
-  "this",
-  "to",
-  "use",
-  "was",
-  "we",
-  "what",
-  "when",
-  "where",
-  "which",
-  "who",
-  "why",
-  "will",
-  "with",
-  "would",
-  "you",
-  "your",
-  "agent",
-  "agents",
-  "skill",
-  "skills"
-]);
-function wordsOf(text) {
-  return text.toLowerCase().match(/[\p{L}\p{N}]+/gu) ?? [];
-}
-function questionWords(question) {
-  const kept = wordsOf(question).filter((word) => word.length >= MIN_WORD_LENGTH && !STOP_WORDS.has(word));
-  return [...new Set(kept)];
-}
-function wordsMatch(word, other) {
-  if (word === other)
-    return true;
-  const [shorter, longer] = word.length <= other.length ? [word, other] : [other, word];
-  return shorter.length >= MIN_PREFIX_LENGTH && longer.startsWith(shorter);
-}
-function fieldWords(candidate) {
-  const { record } = candidate;
-  const texts = {
-    tags: record.tags.join(" "),
-    prevents: record.prevents ?? "",
-    whenToUse: record.whenToUse ?? "",
-    description: candidate.description ?? "",
-    body: candidate.body
-  };
-  return new Map(FIELDS.map((field) => [field, [...new Set(wordsOf(texts[field]))]]));
-}
-function scoreCandidate(candidate, words) {
-  const byField = fieldWords(candidate);
-  const matchedWords = new Set;
-  const matchedFields = new Set;
-  let score = 0;
-  for (const word of words) {
-    for (const field of FIELDS) {
-      const found = (byField.get(field) ?? []).some((other) => wordsMatch(word, other));
-      if (!found)
-        continue;
-      score += FIELD_WEIGHTS[field];
-      matchedWords.add(word);
-      matchedFields.add(field);
-    }
-  }
-  return {
-    record: candidate.record,
-    score,
-    words: words.filter((word) => matchedWords.has(word)),
-    fields: FIELDS.filter((field) => matchedFields.has(field))
-  };
-}
-function rankCandidates(question, candidates, limit = SEARCH_LIMIT) {
-  const words = questionWords(question);
-  if (words.length === 0)
-    return [];
-  return candidates.map((candidate) => scoreCandidate(candidate, words)).filter((ranked) => ranked.score > 0).sort((a, b) => b.score - a.score).slice(0, limit);
-}
-function readRankCandidate(record, read = (path) => readFileSync5(path, "utf8")) {
-  let text;
-  try {
-    text = read(record.path);
-  } catch {
-    return {
-      record,
-      description: record.summary === "" ? null : record.summary,
-      body: ""
-    };
-  }
-  const document = readFrontmatterDocument(text);
-  return {
-    record,
-    description: readInventoryFrontmatter(document?.data ?? null).description,
-    body: document?.body ?? text
-  };
-}
-
 // src/inventory/search/scratch.ts
 import { copyFileSync, mkdirSync, mkdtempSync, rmSync } from "fs";
 import { tmpdir } from "os";
@@ -2838,7 +2713,7 @@ function createAgentShowCommand(seams = DEFAULT_AGENT_SHOW_SEAMS) {
 var show_default = createAgentShowCommand();
 
 // src/commands/agent/vendor.ts
-import { copyFileSync as copyFileSync2, existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync6, writeFileSync } from "fs";
+import { copyFileSync as copyFileSync2, existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync5, writeFileSync } from "fs";
 import { basename as basename2, join as join6 } from "path";
 var USAGE4 = "rafa agent vendor <name>... [--force]";
 var NOTHING_WRITTEN = "Nothing was written.";
@@ -2925,7 +2800,7 @@ function planCopies(names, project, force, entry) {
 function copyOne(copy, date) {
   try {
     copyFileSync2(copy.from, copy.to);
-    writeFileSync(copy.to, withSourceHeader(readFileSync6(copy.to, "utf8"), copy.from, date), "utf8");
+    writeFileSync(copy.to, withSourceHeader(readFileSync5(copy.to, "utf8"), copy.from, date), "utf8");
   } catch (error) {
     throw new CommandExit(1, `\u274C ${USAGE4}: agent "${copy.name}" could not be written to ${copy.to}: ${String(error)}`);
   }
@@ -4274,7 +4149,7 @@ import { statSync as statSync5 } from "fs";
 import { join as join10 } from "path";
 
 // src/board/setup-config.ts
-import { readFileSync as readFileSync7 } from "fs";
+import { readFileSync as readFileSync6 } from "fs";
 function roadmapIssueIn(text, path) {
   return parseConfigText(text, path).values.roadmapIssue ?? null;
 }
@@ -4282,7 +4157,7 @@ function readRoadmapSetting(root) {
   const path = configFilePath(root);
   let text;
   try {
-    text = readFileSync7(path, "utf8");
+    text = readFileSync6(path, "utf8");
   } catch (error) {
     return { issue: null, text: "", problem: `${path} could not be read: ${messageOf(error)}` };
   }
@@ -4331,7 +4206,7 @@ function withRoadmapIssue(text, issue) {
 }
 
 // src/board/setup.ts
-import { existsSync as existsSync4, lstatSync, mkdirSync as mkdirSync3, readFileSync as readFileSync8, statSync as statSync4, writeFileSync as writeFileSync2 } from "fs";
+import { existsSync as existsSync4, lstatSync, mkdirSync as mkdirSync3, readFileSync as readFileSync7, statSync as statSync4, writeFileSync as writeFileSync2 } from "fs";
 import { dirname, join as join9 } from "path";
 import { fileURLToPath } from "url";
 var PREFIX = "board setup";
@@ -4466,7 +4341,7 @@ function readSpecTemplate(moduleDir = MODULE_DIR) {
   if (!existsSync4(source)) {
     throw new Error(`${PREFIX}: the spec issue template is missing: no file at ${source}`);
   }
-  return readFileSync8(source, "utf8");
+  return readFileSync7(source, "utf8");
 }
 function writeSpecTemplate(root, moduleDir = MODULE_DIR) {
   const path = join9(root, SPEC_TEMPLATE_PATH);
@@ -4956,7 +4831,7 @@ function readScope2(scope, path, loaded) {
   }
   return { read: { scope, path, loaded, entries }, warnings };
 }
-function readScopes(seams) {
+function readScopes2(seams) {
   const read = OVERRIDE_SCOPES.flatMap((scope) => {
     const path = overrideSettingsPath(scope, { home: seams.home, projectRoot: seams.projectRoot });
     return path === null ? [] : [readScope2(scope, path, seams.settingSources.includes(scope))];
@@ -5009,7 +4884,7 @@ function pathDifference(shell, session, layer) {
   return Object.freeze({ layer, added: Object.freeze(added), removed: Object.freeze(removed), reordered });
 }
 function readSessionEnv(seams) {
-  const { scopes, warnings } = readScopes(seams);
+  const { scopes, warnings } = readScopes2(seams);
   const { env, layers } = overlay(sessionSpawnEnv(seams.env), seams.env, scopes);
   return Object.freeze({
     env: Object.freeze(env),
@@ -6426,7 +6301,7 @@ function writeInstall(context, install) {
 }
 
 // src/commands/doctor-refs.ts
-import { readdirSync, readFileSync as readFileSync9, statSync as statSync8 } from "fs";
+import { readdirSync, readFileSync as readFileSync8, statSync as statSync8 } from "fs";
 import { join as join16, resolve as resolve5 } from "path";
 function issueCheckCommand(issue) {
   return `rafa issue check ${String(issue)}`;
@@ -6496,7 +6371,7 @@ async function readCopy(file, input, verify) {
   const path = join16(input.specsDir, file.name);
   const empty = { issue: file.issue, path, suspect: 0, dangling: 0, unknown: 0 };
   try {
-    const copy = readFileSync9(resolve5(input.root, path), "utf8");
+    const copy = readFileSync8(resolve5(input.root, path), "utf8");
     const { rows } = await readRefsText({ copy, issue: file.issue, verify: await verify() });
     const states = rows.map((row) => row.state);
     return Object.freeze({
@@ -6788,14 +6663,14 @@ function renderBoard(board) {
 }
 
 // src/commands/doctor-tiers.ts
-import { readFileSync as readFileSync10, realpathSync as realpathSync4 } from "fs";
+import { readFileSync as readFileSync9, realpathSync as realpathSync4 } from "fs";
 import { basename as basename5, 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 readFileSync10(path, "utf8");
+    return readFileSync9(path, "utf8");
   } catch {
     return null;
   }
@@ -6882,12 +6757,18 @@ function cliVersionRows(installed, pinned = SERVE_CLI_VERSION) {
   }
   return [row("cli-version", "warn", name2, `${installed} is installed, and skill delivery was probed against ${pinned}`, 'run the delivery probe again (context/inventory.md, "Serving") before trusting SERVE_CLI_VERSION')];
 }
+function skillUseVersionRows(installed, pinned = SKILL_USE_CLI_VERSION) {
+  if (installed === null || installed === pinned)
+    return [];
+  return [row("skill-use-version", "warn", "Claude Code", `${installed} is installed, and the skill-use collector reads logs of ${pinned}, ` + "so skill_invocations stores the skill counts of the sessions it logs as unknown", "record the skill-use fixture again under the installed version (src/effort/skill-use.ts) before moving SKILL_USE_CLI_VERSION")];
+}
 function doctorTierRows(inventory, installed, readers = {}) {
   const readText2 = readers.readText ?? readTextFile;
   return [
     ...collisionRows(inventory.resolution.collisions),
     ...unreviewedRows(inventory.records, readText2),
     ...cliVersionRows(installed),
+    ...skillUseVersionRows(installed),
     ...copyRows(inventory.resolution.items, readers.realPath ?? realPathOf),
     ...noProvenanceRows(inventory, readText2)
   ];
@@ -7243,7 +7124,7 @@ var collect_default = wrapPhaseZeroCommand({
   subject: "effort",
   action: "collect",
   summary: "collect session and commit rows into the effort store",
-  description: "Reads the Claude Code session logs of this repo and its commit history, and appends every" + " session and commit the effort store does not hold yet to the store `store` in" + " `.rafa/config.yaml` selects. A run over an unchanged history appends nothing. An unrecognised" + " argument, a `--since` that is no date and a config the loop cannot run on are each refused," + " one line per problem.",
+  description: "Reads the Claude Code session logs of this repo and its commit history, and appends every" + " session and commit the effort store does not hold yet to the store `store` in" + " `.rafa/config.yaml` selects, then counts the skills each appended session invoked into" + " `effort.sqlite`. A run over an unchanged history appends nothing. An unrecognised" + " argument, a `--since` that is no date and a config the loop cannot run on are each refused," + " one line per problem.",
   args: [],
   flags: [
     {
@@ -7259,10 +7140,15 @@ var collect_default = wrapPhaseZeroCommand({
     },
     {
       name: "sessions",
-      description: "Collects session rows; `--no-sessions` skips them. Refused beside `--no-git`," + " which would leave nothing to collect.",
+      description: "Collects session rows; `--no-sessions` skips them. Refused beside `--no-git`," + " which would leave nothing to collect, unless `--skills` is given.",
       type: "boolean",
       default: true
     },
+    {
+      name: "skills",
+      description: "Counts the `Skill` calls of every session the store already holds, not only the ones" + " this run appends. Lifts the refusal of `--no-git` beside `--no-sessions`.",
+      type: "boolean"
+    },
     {
       name: "verbose",
       description: "Prints what each half found before the summary: the logs and plan stubs it read," + " each session read, and the commits parsed.",
@@ -7282,6 +7168,275 @@ var collect_default = wrapPhaseZeroCommand({
   outputs: ["text", "json"]
 }, collect);
 
+// src/effort/store/fix-schema.ts
+import { existsSync as existsSync5, renameSync, rmSync as rmSync2 } from "fs";
+import { Database } from "bun:sqlite";
+class SchemaFixRefusal extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SchemaFixRefusal";
+  }
+}
+var LIVE = "live";
+function quoted(name2) {
+  return `"${name2.replaceAll('"', '""')}"`;
+}
+function tableNames(db, schema) {
+  return db.query(`SELECT name FROM ${schema}.sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%' ORDER BY name`).all().map((row2) => row2.name);
+}
+function columnNames(db, schema, table) {
+  return db.query("SELECT name FROM pragma_table_info(?, ?)").all(table, schema).map((row2) => row2.name);
+}
+function count(db, sql) {
+  return db.query(sql).get()?.n ?? 0;
+}
+function versionOf(path) {
+  const db = new Database(path, { readonly: true });
+  try {
+    return db.query("PRAGMA user_version").get()?.user_version ?? 0;
+  } finally {
+    db.close();
+  }
+}
+function refuseInFlight(path) {
+  for (const suffix of ["-journal", "-wal"]) {
+    if (existsSync5(`${path}${suffix}`)) {
+      throw new SchemaFixRefusal(`${path}${suffix} is there, so a write is in flight or was interrupted; stop whatever uses the store` + " and open it once with rafa before repairing it");
+    }
+  }
+}
+function refuseRemoved(db, known, live) {
+  for (const table of known) {
+    if (!live.has(table)) {
+      throw new SchemaFixRefusal(`the store holds no table ${table}, which this rafa writes; its newer schema is not additive`);
+    }
+    const liveColumns = new Set(columnNames(db, LIVE, table));
+    const missing = columnNames(db, "main", table).filter((column) => !liveColumns.has(column));
+    if (missing.length > 0) {
+      throw new SchemaFixRefusal(`the store holds no column ${missing.map((column) => `${table}.${column}`).join(", ")}, which this rafa` + " writes; its newer schema is not additive");
+    }
+  }
+}
+function copyKnown(db, known) {
+  db.transaction(() => {
+    for (const table of known) {
+      const columns2 = columnNames(db, "main", table).map(quoted).join(", ");
+      db.run(`INSERT INTO main.${quoted(table)} (${columns2}) SELECT ${columns2} FROM ${LIVE}.${quoted(table)}`);
+    }
+  })();
+}
+function checkedCounts(db, known) {
+  return known.map((table) => {
+    const rows = count(db, `SELECT count(*) AS n FROM main.${quoted(table)}`);
+    const liveRows = count(db, `SELECT count(*) AS n FROM ${LIVE}.${quoted(table)}`);
+    if (rows !== liveRows) {
+      throw new SchemaFixRefusal(`the rebuilt ${table} holds ${String(rows)} rows, the store ${String(liveRows)}`);
+    }
+    return { table, rows };
+  });
+}
+function leftBehind(db, known, live) {
+  const leftTables = live.filter((table) => !known.has(table)).map((table) => ({ table, rows: count(db, `SELECT count(*) AS n FROM ${LIVE}.${quoted(table)}`) }));
+  const leftColumns = live.filter((table) => known.has(table)).flatMap((table) => {
+    const kept = new Set(columnNames(db, "main", table));
+    return columnNames(db, LIVE, table).filter((column) => !kept.has(column)).map((column) => ({
+      table,
+      column,
+      values: count(db, `SELECT count(*) AS n FROM ${LIVE}.${quoted(table)} WHERE ${quoted(column)} IS NOT NULL`)
+    }));
+  });
+  return { leftTables, leftColumns };
+}
+function refuseCorrupt(db) {
+  const answer = db.query("PRAGMA main.integrity_check").get()?.integrity_check;
+  if (answer !== "ok")
+    throw new SchemaFixRefusal(`the rebuilt store failed integrity_check: ${answer ?? "no answer"}`);
+}
+function buildParallel(path, parallelPath, migrations) {
+  const db = new Database(parallelPath, { create: true, readwrite: true });
+  try {
+    migrateSchema(db, parallelPath, migrations);
+    db.run(`ATTACH DATABASE ? AS ${LIVE}`, [path]);
+    const known = tableNames(db, "main");
+    const live = tableNames(db, LIVE);
+    refuseRemoved(db, known, new Set(live));
+    copyKnown(db, known);
+    const kept = checkedCounts(db, known);
+    const left = leftBehind(db, new Set(known), live);
+    db.run(`DETACH DATABASE ${LIVE}`);
+    refuseCorrupt(db);
+    return { kept, ...left };
+  } finally {
+    db.close();
+  }
+}
+function removeParallel(parallelPath) {
+  rmSync2(parallelPath, { force: true });
+  rmSync2(`${parallelPath}-journal`, { force: true });
+}
+function swapIn(path, parallelPath, backupPath) {
+  renameSync(path, backupPath);
+  try {
+    renameSync(parallelPath, path);
+  } catch (error) {
+    renameSync(backupPath, path);
+    throw error;
+  }
+}
+function freshPaths(path, version2, stamp) {
+  const parallelPath = `${path}.fix-${stamp}`;
+  const backupPath = `${path}.v${String(version2)}-${stamp}.bak`;
+  for (const taken of [parallelPath, backupPath]) {
+    if (existsSync5(taken))
+      throw new SchemaFixRefusal(`${taken} is already there; move it aside or pass another stamp`);
+  }
+  return { parallelPath, backupPath };
+}
+function fixStoreSchema(options) {
+  const { path, dryRun, stamp } = options;
+  const migrations = options.migrations ?? SQLITE_MIGRATIONS;
+  const knownVersion = migrations.length;
+  const nothing = { kept: [], leftTables: [], leftColumns: [], backupPath: null };
+  if (!existsSync5(path))
+    return { path, status: "missing", storeVersion: null, knownVersion, ...nothing };
+  refuseInFlight(path);
+  const storeVersion = versionOf(path);
+  if (storeVersion === knownVersion)
+    return { path, status: "current", storeVersion, knownVersion, ...nothing };
+  if (storeVersion < knownVersion)
+    return { path, status: "behind", storeVersion, knownVersion, ...nothing };
+  const { parallelPath, backupPath } = freshPaths(path, storeVersion, stamp);
+  let built;
+  try {
+    built = buildParallel(path, parallelPath, migrations);
+  } catch (error) {
+    removeParallel(parallelPath);
+    throw error;
+  }
+  if (dryRun) {
+    removeParallel(parallelPath);
+    return { path, status: "would-rebuild", storeVersion, knownVersion, ...built, backupPath: null };
+  }
+  swapIn(path, parallelPath, backupPath);
+  return { path, status: "rebuilt", storeVersion, knownVersion, ...built, backupPath };
+}
+
+// src/commands/effort/fix-schema.ts
+var COMMAND_NAME5 = "rafa effort fix-schema";
+var FIX_SCHEMA_USAGE = "rafa effort fix-schema [--dry-run]";
+var DRY_RUN_FLAG2 = "dry-run";
+function fileStamp(date) {
+  return date.toISOString().replace(/[-:]/g, "").replace(/\.\d{3}Z$/, "Z");
+}
+function refuseLiveLoop(root, isAlive) {
+  let records;
+  try {
+    records = readSessions(root, isAlive === undefined ? {} : { isAlive });
+  } catch (error) {
+    throw new CommandExit(1, `\u274C ${COMMAND_NAME5}: the loop's run records cannot be read, so a live loop cannot be ruled out: ${String(error)}`);
+  }
+  const live = records.find((record) => record.state === "running" || record.state === "paused");
+  if (live === undefined)
+    return;
+  throw new CommandExit(1, `\u274C ${COMMAND_NAME5}: loop session ${live.sessionId} on ${live.branch} is ${live.state} and writes the store;` + ` stop it with \`rafa loop stop -s ${live.sessionId}\` first. \`--dry-run\` runs beside it.`);
+}
+function rebuildLines(result) {
+  const rows = result.kept.reduce((sum, table) => sum + table.rows, 0);
+  const kept = result.kept.map((table) => `${table.table} ${String(table.rows)}`).join(", ");
+  const left = [
+    ...result.leftTables.map((table) => `table ${table.table} (${String(table.rows)} rows)`),
+    ...result.leftColumns.map((column) => `column ${column.table}.${column.column} (${String(column.values)} values)`)
+  ];
+  return [
+    `${result.path} is at schema version ${String(result.storeVersion)}, past the ${String(result.knownVersion)} this rafa knows.`,
+    `Keeps ${String(result.kept.length)} tables, ${String(rows)} rows: ${kept}.`,
+    left.length === 0 ? "Leaves nothing behind." : `Leaves behind, kept only in the backup: ${left.join("; ")}.`
+  ];
+}
+function renderFixSchema(result) {
+  switch (result.status) {
+    case "missing":
+      return [`No effort store at ${result.path}: nothing to repair.`];
+    case "current":
+      return [`\u2705 ${result.path} is at schema version ${String(result.knownVersion)}, the one this rafa knows: nothing to repair.`];
+    case "behind":
+      return [
+        `${result.path} is at schema version ${String(result.storeVersion)}, behind the ${String(result.knownVersion)} this rafa` + " knows; the next command that opens it migrates it. Nothing to repair."
+      ];
+    case "would-rebuild":
+      return [
+        ...rebuildLines(result),
+        `\uD83D\uDD0D Dry run: the rebuild at version ${String(result.knownVersion)} was built, checked (row counts, integrity_check)` + " and deleted. Run without `--dry-run` to swap it in."
+      ];
+    case "rebuilt":
+      return [
+        ...rebuildLines(result),
+        `\u2705 Rebuilt at version ${String(result.knownVersion)}. The original is kept whole at ${String(result.backupPath)};` + " rename it back to undo."
+      ];
+  }
+}
+function runFixSchema(context, seams) {
+  expectNoArgument(context.args, FIX_SCHEMA_USAGE);
+  const dryRun = readSwitch(DRY_RUN_FLAG2, context.flags[DRY_RUN_FLAG2], `Usage: ${FIX_SCHEMA_USAGE}`);
+  if (context.project === null)
+    throw new Error(`${COMMAND_NAME5} runs inside a project, and was handed none`);
+  const root = context.project.root;
+  if (!dryRun)
+    refuseLiveLoop(root, seams.isAlive);
+  let result;
+  try {
+    result = fixStoreSchema({
+      path: sqliteStorePath(root),
+      dryRun,
+      stamp: fileStamp((seams.now ?? (() => new Date))())
+    });
+  } catch (error) {
+    if (error instanceof SchemaFixRefusal)
+      throw new CommandExit(1, `\u274C ${COMMAND_NAME5}: ${error.message}`);
+    throw error;
+  }
+  if (context.outputMode === "json") {
+    context.output.result(result);
+    return;
+  }
+  for (const line of renderFixSchema(result))
+    context.output.info(line);
+}
+function createFixSchemaCommand(seams = {}) {
+  const command = {
+    name: "effort fix-schema",
+    subject: "effort",
+    action: "fix-schema",
+    summary: "rebuild an effort store a newer rafa migrated at the version this rafa knows, keeping the original",
+    description: "Repairs `.rafa/effort/effort.sqlite` when it is past the schema version this rafa knows, which" + " happens when newer code opens it, such as a plan's own branch code run while an older installed rafa" + " drives the loop. It builds a parallel store beside it at this rafa's version, copies every table and" + " column this rafa knows, checks the row counts and SQLite's integrity_check, and lists what only the" + " newer schema holds. Then it renames the original to `effort.sqlite.v<version>-<stamp>.bak`, whole, and" + " moves the rebuild into its place. A store at or behind this version, or no store, is left alone. It" + " refuses, changing nothing, while a loop session under the project is running or paused, while a" + " journal beside the store shows a write in flight, and when the newer schema lacks a table or column" + " this rafa writes. With `--output=json` the outcome is the data of the terminal result event. Starts no" + " session.",
+    args: [],
+    flags: [
+      {
+        name: DRY_RUN_FLAG2,
+        description: "Build and check the rebuild, print what it keeps and leaves behind, then delete it. The" + " live store is only read, so this runs beside a live loop and can be repeated.",
+        type: "boolean"
+      }
+    ],
+    examples: [
+      {
+        cmd: "rafa effort fix-schema --dry-run",
+        note: "Prints what a rebuild would keep and leave behind, changing nothing."
+      },
+      {
+        cmd: "rafa effort fix-schema",
+        note: "Swaps the rebuild in and prints where the original was kept."
+      }
+    ],
+    outputs: ["text", "json"],
+    run: async (context) => {
+      runFixSchema(context, seams);
+      await Promise.resolve();
+    }
+  };
+  return Object.freeze(command);
+}
+var fix_schema_default = createFixSchemaCommand();
+
 // src/commands/effort/report.ts
 var report_default = wrapPhaseZeroCommand({
   name: "effort report",
@@ -7322,12 +7477,12 @@ var report_default = wrapPhaseZeroCommand({
 }, report);
 
 // src/commands/init.ts
-import { existsSync as existsSync7, readFileSync as readFileSync15 } from "fs";
+import { existsSync as existsSync8, readFileSync as readFileSync14 } from "fs";
 import { homedir } from "os";
 import { join as join21, relative as relative6, sep as sep4 } from "path";
 
 // src/agents/vendorable.ts
-import { readdirSync as readdirSync2, readFileSync as readFileSync11 } from "fs";
+import { readdirSync as readdirSync2, readFileSync as readFileSync10 } from "fs";
 import { isAbsolute as isAbsolute5, join as join17 } from "path";
 function planFiles(dir) {
   let entries;
@@ -7340,7 +7495,7 @@ function planFiles(dir) {
 }
 function readText2(path) {
   try {
-    return readFileSync11(path, "utf8");
+    return readFileSync10(path, "utf8");
   } catch {
     return null;
   }
@@ -7385,7 +7540,7 @@ function vendorableAgentWarnings(agents, root) {
 
 // src/project/gitignore.ts
 import { createHash } from "crypto";
-import { existsSync as existsSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync12, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync11, writeFileSync as writeFileSync3 } from "fs";
 import { dirname as dirname3, isAbsolute as isAbsolute6, join as join18 } from "path";
 var GITIGNORE_FILE = ".gitignore";
 var DIGEST_NAME = "tracking.digest";
@@ -7472,9 +7627,9 @@ function attempt(file, failure3, act) {
   }
 }
 function readIfPresent2(file) {
-  if (!existsSync5(file))
+  if (!existsSync6(file))
     return null;
-  return attempt(file, "cannot be read", () => readFileSync12(file, "utf8"));
+  return attempt(file, "cannot be read", () => readFileSync11(file, "utf8"));
 }
 function writeTrackingGitignore(root, flags) {
   requireAbsolute(root);
@@ -7537,7 +7692,7 @@ import { resolve as resolve8 } from "path";
 
 // src/project/roots.ts
 import { spawnSync } from "child_process";
-import { accessSync, constants, readFileSync as readFileSync13, statSync as statSync9 } from "fs";
+import { accessSync, constants, readFileSync as readFileSync12, statSync as statSync9 } from "fs";
 import { isAbsolute as isAbsolute7, join as join19, resolve as resolve7 } from "path";
 var REFUSED_ROOTS = Object.freeze([
   { path: "/", why: "is the filesystem root" },
@@ -7558,7 +7713,7 @@ var PACKAGE_JSON = "package.json";
 var NOT_A_REPOSITORY = "fatal: not a git repository (or any ";
 var DISK_ROOTS_FILE_SYSTEM = Object.freeze({
   ...DISK_FILE_SYSTEM,
-  readFile: (path) => readFileSync13(path, "utf8"),
+  readFile: (path) => readFileSync12(path, "utf8"),
   isDirectory: (path) => statSync9(path).isDirectory(),
   assertWritable: (path) => accessSync(path, constants.W_OK)
 });
@@ -7750,10 +7905,10 @@ function namedRoot(typed, start2, source, seams) {
   return chosen(fs.realpath(path), source);
 }
 function numberedCandidate(digits, found) {
-  const count = found.candidates.length;
+  const count2 = found.candidates.length;
   const candidate = found.candidates[Number(digits) - 1];
   if (candidate === undefined) {
-    return problem(`no candidate is numbered ${digits}; type 1 to ${String(count)}, or a path`);
+    return problem(`no candidate is numbered ${digits}; type 1 to ${String(count2)}, or a path`);
   }
   return candidate.refusal === null ? chosen(candidate.path, candidate.source) : problem(candidate.refusal.reason);
 }
@@ -7783,7 +7938,7 @@ async function promptForRoot(found, prompter, seams) {
 }
 
 // src/project/scaffold.ts
-import { existsSync as existsSync6, lstatSync as lstatSync2, mkdirSync as mkdirSync5, statSync as statSync10, writeFileSync as writeFileSync4 } from "fs";
+import { existsSync as existsSync7, lstatSync as lstatSync2, mkdirSync as mkdirSync5, statSync as statSync10, writeFileSync as writeFileSync4 } from "fs";
 import { join as join20 } from "path";
 var PROJECT_TREE = Object.freeze(["specs", "plans", "runs", "effort", "instincts"]);
 var USER_TREE = Object.freeze(["instincts"]);
@@ -7799,6 +7954,11 @@ var CONFIG_SETTINGS_LINES = Object.freeze([
   `#   fallback: [${CONFIG_DEFAULTS.trackerFallback.join(", ")}]`,
   "# learning:",
   `#   adapter: ${CONFIG_DEFAULTS.learningAdapter}`,
+  "#   bless:",
+  `#     minConfidence: ${String(CONFIG_DEFAULTS.learningBlessMinConfidence)}         # 0.3..0.9, the least confidence of a lesson tasks may use`,
+  "#   promote:",
+  `#     after: ${String(CONFIG_DEFAULTS.learningPromoteAfter)}                   # distinct sources a lesson needs before the wrap-up promotes it`,
+  `#     minConfidence: ${String(CONFIG_DEFAULTS.learningPromoteMinConfidence)}         # 0.3..0.9, the least confidence of a lesson to promote`,
   "# output:",
   `#   mode: ${CONFIG_DEFAULTS.outputMode}                   # text | json`,
   "# prerequisites:",
@@ -7839,7 +7999,10 @@ var CONFIG_SETTINGS_LINES = Object.freeze([
   "#   skills: {}                   # name: false turns a skill off; name: project | rafa | user pins its tier",
   "#   agents: {}                   # name: false turns an agent off; name: project | rafa | user pins its tier",
   "# routing:",
-  ...DEFAULT_ROUTES.map(([shape, agent]) => `#   ${shape}: ${agent}`)
+  ...DEFAULT_ROUTES.map(([shape, agent]) => `#   ${shape}: ${agent}`),
+  "# task:",
+  `#   skills: ${CONFIG_DEFAULTS.taskSkills}                # planner | tag | none, the resolver that picks a task's skills`,
+  `#   lessons: ${CONFIG_DEFAULTS.taskLessons}                    # on | off, whether blessed lessons join a task's prompt`
 ]);
 var VERSION_LINE = `version: ${String(CONFIG_DEFAULTS.version)}`;
 var PROJECT_HEADER = Object.freeze([
@@ -7888,7 +8051,7 @@ function isDirectory2(path) {
 function directoryConflict(dir) {
   if (!occupied(dir) || isDirectory2(dir))
     return null;
-  return existsSync6(dir) ? `${dir} is not a directory` : `${dir} is a link to nothing`;
+  return existsSync7(dir) ? `${dir} is not a directory` : `${dir} is a link to nothing`;
 }
 function layoutConflicts(layout) {
   const [scopeDir, ...tree] = layout.dirs;
@@ -7896,7 +8059,7 @@ function layoutConflicts(layout) {
   if (opening !== null)
     return [opening];
   const dirs = tree.flatMap((dir) => directoryConflict(dir) ?? []);
-  const file = occupied(layout.configFile) && !existsSync6(layout.configFile) ? [`${layout.configFile} is a link to nothing`] : [];
+  const file = occupied(layout.configFile) && !existsSync7(layout.configFile) ? [`${layout.configFile} is a link to nothing`] : [];
   return [...dirs, ...file];
 }
 function scaffoldConflicts(root, home) {
@@ -7910,7 +8073,7 @@ function attempt2(path, failure3, act) {
   }
 }
 function ensureDirectory(path) {
-  if (existsSync6(path))
+  if (existsSync7(path))
     return { path, kind: "directory", change: "unchanged" };
   attempt2(path, "cannot be created", () => {
     mkdirSync5(path, { recursive: true });
@@ -7918,7 +8081,7 @@ function ensureDirectory(path) {
   return { path, kind: "directory", change: "created" };
 }
 function ensureFile(path, text) {
-  if (existsSync6(path))
+  if (existsSync7(path))
     return { path, kind: "file", change: "unchanged" };
   attempt2(path, "cannot be written", () => {
     writeFileSync4(path, text, { encoding: "utf8", flag: "wx" });
@@ -7941,7 +8104,7 @@ function writeUserScope(home) {
 import { writeFileSync as writeFileSync5 } from "fs";
 
 // src/release/setting.ts
-import { readFileSync as readFileSync14 } from "fs";
+import { readFileSync as readFileSync13 } from "fs";
 var RELEASE_ENABLED_SETTING = "release.enabled";
 function releaseEnabledIn(text, path) {
   return parseConfigText(text, path).values.releaseEnabled ?? null;
@@ -7950,7 +8113,7 @@ function readReleaseSetting(root) {
   const path = configFilePath(root);
   let text;
   try {
-    text = readFileSync14(path, "utf8");
+    text = readFileSync13(path, "utf8");
   } catch (error) {
     return { enabled: null, text: "", problem: `${path} could not be read: ${messageOf(error)}` };
   }
@@ -8227,7 +8390,7 @@ function resolvedConfig2(root, home, warn) {
 function checkGitignore(root, flags) {
   const file = join21(root, GITIGNORE_FILE);
   try {
-    const text = existsSync7(file) ? readFileSync15(file, "utf8") : null;
+    const text = existsSync8(file) ? readFileSync14(file, "utf8") : null;
     withTrackingBlock(text, flags, file);
   } catch (error) {
     const message = error instanceof GitignoreError ? error.message : `rafa init: ${file} cannot be read (${messageOf(error)})`;
@@ -8258,8 +8421,8 @@ function initialise(root, start2, home, context, entry) {
   checkConflicts(root.path, home);
   const config = resolvedConfig2(root.path, home, warn);
   checkGitignore(root.path, config);
-  const configExisted = existsSync7(configFilePath(root.path));
-  const digestExisted = existsSync7(join21(root.path, TRACKING_DIGEST_FILE));
+  const configExisted = existsSync8(configFilePath(root.path));
+  const digestExisted = existsSync8(join21(root.path, TRACKING_DIGEST_FILE));
   const project = writeProjectScope(root.path);
   const tracking = applyTracking(root.path, config, warn);
   const writes = [...project, ...trackingWrites(tracking, digestExisted), ...writeUserScope(home)];
@@ -8558,72 +8721,196 @@ function createInstinctCheckCommand(seams = DEFAULT_CHECK_SEAMS) {
 }
 var check_default = createInstinctCheckCommand();
 
-// src/commands/instinct/instinct-records.ts
-import { readdirSync as readdirSync3, readFileSync as readFileSync16, statSync as statSync11 } from "fs";
-import { join as join22 } from "path";
-function isRecordFile(name2) {
-  return !name2.startsWith(".") && name2.endsWith(MARKDOWN_EXTENSION) && name2 !== MARKDOWN_EXTENSION;
-}
-function recordId(name2) {
-  return name2.slice(0, -MARKDOWN_EXTENSION.length);
+// src/commands/instinct/flag.ts
+var NAME = "rafa instinct flag";
+var USAGE6 = "rafa instinct flag <id> <reason>";
+function refusedFlagMessage(id, kind, reason) {
+  return [
+    `\u274C ${NAME}: the \`${kind}\` learning adapter did not flag "${id}": ${reason}`,
+    "Run `rafa instinct list` to see the ids the project holds."
+  ].join(`
+`);
 }
-function unreadableIssue(message) {
-  return { code: "missing-frontmatter", field: "file", message: `the file could not be read: ${message}` };
+function blankReasonMessage(id) {
+  return `\u274C ${NAME}: the reason to flag "${id}" is blank; say why the lesson is wrong.
+Usage: ${USAGE6}`;
 }
-function readRecord(path, scope, id) {
-  let text;
+function makeAdapter(registry, kind, context) {
   try {
-    text = readFileSync16(path, "utf8");
+    return registry.resolve("learning", kind).create({
+      repoRoot: context.repoRoot,
+      home: context.home,
+      learningBlessMinConfidence: context.minConfidence
+    });
   } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return { scope, path, id, instinct: null, issues: [unreadableIssue(message)] };
+    throw new CommandExit(1, `\u274C ${NAME}: the \`${kind}\` learning adapter cannot be made: ${messageOf(error)}`);
   }
-  const parsed = parseInstinct(text);
-  return { scope, path, id, instinct: parsed.instinct, issues: parsed.issues };
 }
-function isFile2(path) {
+async function flagInstinct(context, seams) {
+  const [id, reason] = expectTwoArguments(context.args, USAGE6);
+  if (reason.trim() === "")
+    throw new CommandExit(1, blankReasonMessage(id));
+  const project = requireProject(context, NAME);
+  const config = resolveProjectConfig(project, NAME, (message) => {
+    context.output.warn(message);
+  });
+  const kind = config.learningAdapter;
+  const adapter = makeAdapter(seams.registry ?? CORE_ADAPTER_REGISTRY, kind, {
+    repoRoot: project.root,
+    home: project.home,
+    minConfidence: config.learningBlessMinConfidence
+  });
   try {
-    return statSync11(path).isFile();
-  } catch {
-    return false;
+    await adapter.flag(id, reason);
+  } catch (error) {
+    throw new CommandExit(1, refusedFlagMessage(id, kind, messageOf(error)));
   }
+  return { id, reason, adapter: kind };
 }
-function recordFiles(dir) {
-  return readdirSync3(dir).filter((name2) => isRecordFile(name2) && isFile2(join22(dir, name2))).sort((left, right) => left.localeCompare(right));
-}
-function readScope3(scope, dir) {
-  if (!tierExists(dir))
-    return { scope, dir, exists: false, records: [] };
-  return {
-    scope,
-    dir,
-    exists: true,
-    records: recordFiles(dir).map((name2) => readRecord(join22(dir, name2), scope, recordId(name2)))
+function createInstinctFlagCommand(seams = {}) {
+  const command = {
+    name: "instinct flag",
+    subject: "instinct",
+    action: "flag",
+    summary: "flag one held lesson as wrong, so no later bundle blesses it",
+    description: "Flags one lesson the project holds as wrong, through the learning adapter" + " `learning.adapter` names in `.rafa/config.yaml`. A flagged id is left out of every bundle the" + " loop pulls afterwards, whatever a later merge writes under it; under the `local` adapter the" + " flag is one line appended to `.rafa/instincts/flags.ndjson` and no record file changes. An id" + " no held record carries is refused with exit code 1 in the adapter's words, a user-scope id" + " included, as is a blank reason. With `--output=json` the id, the reason and the adapter kind" + " are the data of the terminal result event.",
+    args: [
+      {
+        name: "id",
+        description: "The id of a lesson the project holds, as `rafa instinct list` prints it.",
+        type: "string",
+        required: true
+      },
+      {
+        name: "reason",
+        description: "Why the lesson is wrong, quoted as one word; stored beside the flag.",
+        type: "string",
+        required: true
+      }
+    ],
+    flags: [],
+    examples: [
+      {
+        cmd: 'rafa instinct flag worktree-missing-node-modules "bun install runs on fork since 0.9"',
+        note: "Keeps that lesson out of every bundle the loop pulls from now on."
+      },
+      {
+        cmd: 'rafa instinct flag worktree-missing-node-modules "stale" --output=json',
+        note: "Gives the id, the reason and the adapter kind as the data of the terminal result event."
+      }
+    ],
+    outputs: ["text", "json"],
+    run: async (context) => {
+      const result = await flagInstinct(context, seams);
+      if (context.outputMode === "json") {
+        context.output.result(result);
+        return;
+      }
+      context.output.info(`\uD83D\uDEA9 Flagged ${result.id}: ${result.reason}`);
+      context.output.info(`   The \`${result.adapter}\` learning adapter leaves it out of every later bundle.`);
+    }
   };
+  return Object.freeze(command);
 }
-function readScopes2(seams) {
-  return resolveInstinctScopes(seams).map((location) => readScope3(location.scope, location.dir));
+var flag_default = createInstinctFlagCommand();
+
+// src/commands/instinct/promote.ts
+var NAME2 = "rafa instinct promote";
+var USAGE7 = "rafa instinct promote";
+var CONFIDENCE_DIGITS = 2;
+function refusedPullMessage(kind, reason, name2 = NAME2) {
+  return `\u274C ${name2}: the \`${kind}\` learning adapter answered no blessed set: ${reason}`;
 }
-function allRecords(listings) {
-  return listings.flatMap((listing) => listing.records);
+function makeLearningAdapter(registry, kind, context, name2 = NAME2) {
+  try {
+    return registry.resolve("learning", kind).create({
+      repoRoot: context.repoRoot,
+      home: context.home,
+      learningBlessMinConfidence: context.minConfidence
+    });
+  } catch (error) {
+    throw new CommandExit(1, `\u274C ${name2}: the \`${kind}\` learning adapter cannot be made: ${messageOf(error)}`);
+  }
 }
-function findRecords(listings, id) {
-  return allRecords(listings).filter((entry) => entry.id === id);
+async function promotableLessons(context, seams) {
+  expectNoArgument(context.args, USAGE7);
+  const project = requireProject(context, NAME2);
+  const config = resolveProjectConfig(project, NAME2, (message) => {
+    context.output.warn(message);
+  });
+  const kind = config.learningAdapter;
+  const adapter = makeLearningAdapter(seams.registry ?? CORE_ADAPTER_REGISTRY, kind, {
+    repoRoot: project.root,
+    home: project.home,
+    minConfidence: config.learningBlessMinConfidence
+  });
+  const after = config.learningPromoteAfter;
+  const minConfidence = config.learningPromoteMinConfidence;
+  let blessed;
+  try {
+    blessed = (await adapter.pullBlessed()).instincts;
+  } catch (error) {
+    throw new CommandExit(1, refusedPullMessage(kind, messageOf(error)));
+  }
+  return { adapter: kind, after, minConfidence, lessons: promotable(blessed, { after, minConfidence }) };
 }
-function instinctProject(context, name2) {
-  if (context.project === null)
-    throw new Error(`${name2} runs inside a project, and was handed none`);
-  return context.project;
+function renderPromotable(result) {
+  const keys = `learning.promote.after ${String(result.after)},` + ` learning.promote.minConfidence ${result.minConfidence.toFixed(CONFIDENCE_DIGITS)}`;
+  if (result.lessons.length === 0) {
+    return [`No lesson the \`${result.adapter}\` learning adapter holds is promotable at ${keys}.`];
+  }
+  return [
+    `${String(result.lessons.length)} lesson(s) to promote from the \`${result.adapter}\` learning adapter, at ${keys}:`,
+    ...result.lessons.flatMap((lesson) => [
+      `  ${lesson.id}  ${lesson.confidence.toFixed(CONFIDENCE_DIGITS)}  used ${String(lesson.usage_count)}  ${lesson.trigger}`,
+      `      ${lesson.action}`
+    ])
+  ];
 }
+function createInstinctPromoteCommand(seams = {}) {
+  const command = {
+    name: "instinct promote",
+    subject: "instinct",
+    action: "promote",
+    summary: "print the lessons that recurred enough to promote, writing nothing",
+    description: "Prints the lessons the project holds that recurred enough to promote: the blessed set" + " of the learning adapter `learning.adapter` names in `.rafa/config.yaml`, narrowed to the" + " lessons at least `learning.promote.after` distinct sources confirmed at a confidence of at least" + " `learning.promote.minConfidence`, most trusted first. It is the list the next wrap-up session" + " would be asked to promote. Nothing is written: no lesson is marked promoted and no file" + " changes. A kind no registry holds, an adapter that cannot be made or a pull it refuses is exit" + " code 1. With `--output=json` the adapter kind, the two keys' values and the lessons are the" + " data of the terminal result event.",
+    args: [],
+    flags: [],
+    examples: [
+      {
+        cmd: "rafa instinct promote",
+        note: "Lists each promotable lesson with its confidence, usage, trigger and action."
+      },
+      {
+        cmd: "rafa instinct promote --output=json",
+        note: "Gives the adapter kind, the two keys' values and the lessons as the data of the terminal result event."
+      }
+    ],
+    outputs: ["text", "json"],
+    run: async (context) => {
+      const result = await promotableLessons(context, seams);
+      if (context.outputMode === "json") {
+        context.output.result(result);
+        return;
+      }
+      for (const line of renderPromotable(result))
+        context.output.info(line);
+    }
+  };
+  return Object.freeze(command);
+}
+var promote_default = createInstinctPromoteCommand();
 
 // src/commands/instinct/list.ts
-var USAGE6 = "rafa instinct list";
-var CONFIDENCE_DIGITS = 2;
+var NAME3 = "rafa instinct list";
+var USAGE8 = "rafa instinct list [--blessed | --conflicts]";
+var CONFIDENCE_DIGITS2 = 2;
+var HUNDREDTHS = 100;
 function instinctRowLine(entry) {
   const record = entry.instinct;
   if (record === null)
     return `    \u274C ${entry.id}  ${String(entry.issues.length)} issue(s)`;
-  const confidence = record.confidence.toFixed(CONFIDENCE_DIGITS);
+  const confidence = record.confidence.toFixed(CONFIDENCE_DIGITS2);
   return `    \u2705 ${entry.id}  ${record.kind}/${record.domain}  ${record.signal}` + `  ${confidence}  ${record.trigger}`;
 }
 function scopeLines(listing) {
@@ -8643,38 +8930,171 @@ function renderInstinctList(result) {
     `${String(result.total)} instinct(s): ${String(result.clean)} read as records,` + ` ${String(result.total - result.clean)} do not`
   ];
 }
-function runList4(context) {
-  expectNoArgument(context.args, USAGE6);
-  const project = instinctProject(context, "rafa instinct list");
-  const scopes = readScopes2({ home: project.home, projectRoot: project.root });
+function readViewFlag(name2, value) {
+  if (value === undefined || value === false || value === "false")
+    return false;
+  if (value === true || value === "true")
+    return true;
+  throw new CommandExit(1, `\u274C --${name2} takes no value, and read "${value}" as one
+Usage: ${USAGE8}`);
+}
+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: ${USAGE8}`);
+  }
+  if (blessed)
+    return "blessed";
+  return conflicts ? "conflicts" : "all";
+}
+function oneLine(text) {
+  return text.trim().replace(/\s+/gu, " ");
+}
+function byConfidence(left, right) {
+  const gap = Math.round(right.confidence * HUNDREDTHS) - Math.round(left.confidence * HUNDREDTHS);
+  if (gap !== 0)
+    return gap;
+  if (left.id < right.id)
+    return -1;
+  return left.id > right.id ? 1 : 0;
+}
+function scopeConflicts(listing) {
+  const clean = listing.records.map((entry) => entry.instinct).filter((instinct) => instinct !== null);
+  const groups = new Map;
+  for (const record of toHeldRecords(clean)) {
+    if (record.status !== "flagged")
+      continue;
+    const key = triggerKey(record.trigger);
+    groups.set(key, [...groups.get(key) ?? [], record]);
+  }
+  return [...groups.values()].map((records) => ({
+    scope: listing.scope,
+    trigger: records[0].trigger,
+    records: [...records].sort(byConfidence)
+  }));
+}
+function lessonLine(indent, record, width, tail) {
+  return `${indent}${record.id.padEnd(width)}  ${record.confidence.toFixed(CONFIDENCE_DIGITS2)}` + `  used ${String(record.usage_count)}  ${tail}`;
+}
+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, oneLine(record.action)))
+  ];
+}
+function renderConflicts(result) {
+  if (result.conflicts.length === 0) {
+    return [`No trigger either instinct scope holds carries more than one action (project: ${result.projectRoot}).`];
+  }
+  return [
+    `Triggers held with more than one action (project: ${result.projectRoot}):`,
+    ...result.conflicts.flatMap((conflict) => conflictLines(conflict)),
+    `${String(result.conflicts.length)} flagged trigger(s): no bundle blesses any of their actions`
+  ];
+}
+function renderBlessed(result) {
+  const floor = `learning.bless.minConfidence ${result.minConfidence.toFixed(CONFIDENCE_DIGITS2)}`;
+  if (result.lessons.length === 0) {
+    return [`No lesson the \`${result.adapter}\` learning adapter holds is blessed at ${floor}.`];
+  }
+  return [
+    `${String(result.lessons.length)} lesson(s) blessed by the \`${result.adapter}\` learning adapter, at ${floor}:`,
+    ...result.lessons.flatMap((lesson) => [
+      lessonLine("  ", lesson, 0, lesson.trigger),
+      `      ${lesson.action}`
+    ])
+  ];
+}
+async function blessedLessons(context, seams) {
+  const project = instinctProject(context, NAME3);
+  const config = resolveProjectConfig(project, NAME3, (message) => {
+    context.output.warn(message);
+  });
+  const kind = config.learningAdapter;
+  const minConfidence = config.learningBlessMinConfidence;
+  const adapter = makeLearningAdapter(seams.registry ?? CORE_ADAPTER_REGISTRY, kind, { repoRoot: project.root, home: project.home, minConfidence }, NAME3);
+  try {
+    return { adapter: kind, minConfidence, lessons: (await adapter.pullBlessed()).instincts };
+  } catch (error) {
+    throw new CommandExit(1, refusedPullMessage(kind, messageOf(error), NAME3));
+  }
+}
+function conflicts(context) {
+  const project = instinctProject(context, NAME3);
+  const scopes = readScopes({ home: project.home, projectRoot: project.root });
+  return { projectRoot: project.root, conflicts: scopes.flatMap((listing) => scopeConflicts(listing)) };
+}
+function everyRecord(context) {
+  const project = instinctProject(context, NAME3);
+  const scopes = readScopes({ home: project.home, projectRoot: project.root });
   const records = allRecords(scopes);
-  const result = {
+  return {
     projectRoot: project.root,
     scopes,
     total: records.length,
     clean: records.filter((entry) => entry.instinct !== null).length
   };
+}
+function answer(context, result, lines2) {
   if (context.outputMode === "json") {
     context.output.result(result);
     return;
   }
-  for (const line of renderInstinctList(result))
+  for (const line of lines2())
     context.output.info(line);
 }
-function createInstinctListCommand() {
+async function runList4(context, seams) {
+  expectNoArgument(context.args, USAGE8);
+  const view = readListView(context.flags);
+  if (view === "blessed") {
+    const result2 = await blessedLessons(context, seams);
+    answer(context, result2, () => renderBlessed(result2));
+    return;
+  }
+  if (view === "conflicts") {
+    const result2 = conflicts(context);
+    answer(context, result2, () => renderConflicts(result2));
+    return;
+  }
+  const result = everyRecord(context);
+  answer(context, result, () => renderInstinctList(result));
+}
+function createInstinctListCommand(seams = {}) {
   const command = {
     name: "instinct list",
     subject: "instinct",
     action: "list",
     summary: "list the records the project and user instinct scopes hold",
-    description: "Lists every instinct record the two scopes hold \u2014 this project's `.rafa/instincts` and" + " `~/.rafa/instincts` \u2014 with, for each, the id its file name gives it, its `kind/domain` pair, its" + " `signal`, its `confidence` and its `trigger`. A record that breaks a rule of the instinct schema" + " shows the number of rules it broke instead, which `rafa instinct check` then names. The local" + " Learning adapter's `instincts.ndjson` and `flags.ndjson` are its store and no records, and are" + " passed over. A scope whose directory is not there says so. The exit code is 0 whatever the rows" + " say: this command reports and `rafa instinct check` gates. With `--output=json` the scopes and" + " their records are the data of the terminal result event.",
+    description: "Lists every instinct record the two scopes hold \u2014 this project's `.rafa/instincts` and" + " `~/.rafa/instincts` \u2014 with, for each, the id its file name gives it, its `kind/domain` pair, its" + " `signal`, its `confidence` and its `trigger`. A record that breaks a rule of the instinct schema" + " shows the number of rules it broke instead, which `rafa instinct check` then names. The local" + " Learning adapter's `instincts.ndjson` and `flags.ndjson` are its store and no records, and are" + " passed over. A scope whose directory is not there says so. The exit code is 0 whatever the rows" + " say: this command reports and `rafa instinct check` gates. `--blessed` lists instead the lessons" + " the learning adapter `learning.adapter` names would hand a task, at `learning.bless.minConfidence`," + " most trusted first, writing nothing; an adapter that cannot be made or a pull it refuses is exit" + " code 1. `--conflicts` lists instead each trigger a scope holds with more than one action, which a" + " merge flagged and no bundle blesses, its actions side by side with their confidence and usage." + " The two views are one at a time. With `--output=json` the scopes and their records, or the view" + " asked for, are the data of the terminal result event.",
     args: [],
-    flags: [],
+    flags: [
+      {
+        name: "blessed",
+        description: "List the lessons the configured learning adapter blesses, each with its confidence, usage," + " trigger and action, instead of every record. Takes no value.",
+        type: "boolean"
+      },
+      {
+        name: "conflicts",
+        description: "List each trigger held with more than one action, its actions side by side with their" + " confidence and usage, instead of every record. Takes no value.",
+        type: "boolean"
+      }
+    ],
     examples: [
       {
         cmd: "rafa instinct list",
         note: "Lists both scopes, each record with what it is about."
       },
+      {
+        cmd: "rafa instinct list --blessed",
+        note: "Lists the lessons a task would be handed, most trusted first."
+      },
+      {
+        cmd: "rafa instinct list --conflicts",
+        note: "Lists each flagged trigger with its actions side by side."
+      },
       {
         cmd: "rafa instinct list --output=json",
         note: "Gives the scopes and every record parsed as the data of the terminal result event."
@@ -8682,7 +9102,7 @@ function createInstinctListCommand() {
     ],
     outputs: ["text", "json"],
     run: async (context) => {
-      runList4(context);
+      await runList4(context, seams);
     }
   };
   return Object.freeze(command);
@@ -8690,7 +9110,7 @@ function createInstinctListCommand() {
 var list_default4 = createInstinctListCommand();
 
 // src/commands/instinct/show.ts
-var USAGE7 = "rafa instinct show <id>";
+var USAGE9 = "rafa instinct show <id>";
 var FIELD_ORDER = [
   "trigger",
   "kind",
@@ -8762,13 +9182,13 @@ function unreadableMessage(entry) {
 }
 function unknownIdMessage(id, scopes) {
   const looked = scopes.map((listing) => `  ${listing.scope}  ${listing.dir}${listing.exists ? "" : "  (no such directory)"}`);
-  return [`\u274C No instinct is filed under "${id}". Looked in:`, ...looked, `Usage: ${USAGE7}`].join(`
+  return [`\u274C No instinct is filed under "${id}". Looked in:`, ...looked, `Usage: ${USAGE9}`].join(`
 `);
 }
 function runShow2(context) {
-  const id = expectOneArgument(context.args, USAGE7);
+  const id = expectOneArgument(context.args, USAGE9);
   const project = instinctProject(context, "rafa instinct show");
-  const scopes = readScopes2({ home: project.home, projectRoot: project.root });
+  const scopes = readScopes({ home: project.home, projectRoot: project.root });
   const found = findRecords(scopes, id);
   if (found.length === 0)
     throw new CommandExit(1, unknownIdMessage(id, scopes));
@@ -8825,8 +9245,8 @@ function createInstinctShowCommand() {
 var show_default2 = createInstinctShowCommand();
 
 // src/commands/issue/check.ts
-import { readdirSync as readdirSync4, readFileSync as readFileSync17, statSync as statSync12 } from "fs";
-import { join as join23, resolve as resolve10 } from "path";
+import { readdirSync as readdirSync3, readFileSync as readFileSync15, statSync as statSync11 } from "fs";
+import { join as join22, resolve as resolve10 } from "path";
 var CHECK_USAGE = "rafa issue check <n> [--stamp]";
 var STAMP_FLAG = "stamp";
 var ISSUE_NUMBER = /^[1-9]\d*$/u;
@@ -8850,7 +9270,7 @@ function missingCopyMessage(issue, specsDir) {
 function copyNames(dir, issue) {
   let names;
   try {
-    names = readdirSync4(dir);
+    names = readdirSync3(dir);
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === "ENOENT")
       return [];
@@ -8858,7 +9278,7 @@ function copyNames(dir, issue) {
   }
   const prefix = `${boardId(issue)}-`;
   const notes = notesFileName(issue);
-  return names.filter((name2) => name2.startsWith(prefix) && name2.endsWith(SPEC_EXTENSION) && name2 !== notes).filter((name2) => name2.length > prefix.length + SPEC_EXTENSION.length).filter((name2) => statSync12(join23(dir, name2)).isFile()).sort();
+  return names.filter((name2) => name2.startsWith(prefix) && name2.endsWith(SPEC_EXTENSION) && name2 !== notes).filter((name2) => name2.length > prefix.length + SPEC_EXTENSION.length).filter((name2) => statSync11(join22(dir, name2)).isFile()).sort();
 }
 function findSavedCopy(root, specsDir, issue) {
   const names = copyNames(resolve10(root, specsDir), issue);
@@ -8868,11 +9288,11 @@ function findSavedCopy(root, specsDir, issue) {
   if (names.length > 1) {
     throw new CommandExit(1, [
       `\u274C Issue #${String(issue)} has ${String(names.length)} saved copies under ${specsDir}; remove the stale one:`,
-      ...names.map((name2) => `   ${join23(specsDir, name2)}`)
+      ...names.map((name2) => `   ${join22(specsDir, name2)}`)
     ].join(`
 `));
   }
-  const path = join23(specsDir, only);
+  const path = join22(specsDir, only);
   return { path, absolute: resolve10(root, path) };
 }
 function liveText(live) {
@@ -8902,7 +9322,7 @@ function checkedRefLine(ref) {
 }
 function countLine(references) {
   const noun = references.length === 1 ? "reference" : "references";
-  const counts = STATE_ORDER.map((state) => [state, references.filter((ref) => ref.state === state).length]).filter(([, count]) => count > 0).map(([state, count]) => `${String(count)} ${state}`);
+  const counts = STATE_ORDER.map((state) => [state, references.filter((ref) => ref.state === state).length]).filter(([, count2]) => count2 > 0).map(([state, count2]) => `${String(count2)} ${state}`);
   return counts.length === 0 ? "No references." : `${String(references.length)} ${noun}: ${counts.join(", ")}`;
 }
 function renderCheck2(result) {
@@ -8921,7 +9341,7 @@ async function readReferences(absolute, issue, verify, stamp) {
     return rows.map((row2) => checkedRef(row2, row2.stamp));
   }
   const once = memoiseVerifier(verify);
-  const before = await readRefsText({ copy: readFileSync17(absolute, "utf8"), issue, verify: once });
+  const before = await readRefsText({ copy: readFileSync15(absolute, "utf8"), issue, verify: once });
   const after = await restampCopyRefs({ path: absolute, issue, verify: once });
   return before.rows.map((row2, index) => checkedRef(row2, after.rows[index]?.stamp ?? null));
 }
@@ -8996,10 +9416,10 @@ function createIssueCheckCommand(seams = {}) {
 var check_default2 = createIssueCheckCommand();
 
 // src/commands/issue/comment.ts
-var USAGE8 = "rafa issue comment <id> --body=<text>";
+var USAGE10 = "rafa issue comment <id> --body=<text>";
 async function commentOnIssue(context, seams) {
-  const id = expectOneArgument(context.args, USAGE8);
-  const body = readRequiredFlag(context.flags, "body", USAGE8);
+  const id = expectOneArgument(context.args, USAGE10);
+  const body = readRequiredFlag(context.flags, "body", USAGE10);
   const { tracker, data } = await resolveIssueTracker(context, seams);
   const ref = issueRef(tracker, id);
   await onTracker(tracker, `comment on issue ${id}`, () => tracker.comment(ref, body));
@@ -9053,16 +9473,16 @@ function createIssueCommentCommand(seams = DEFAULT_ISSUE_SEAMS) {
 var comment_default = createIssueCommentCommand();
 
 // src/commands/issue/create.ts
-var USAGE9 = "rafa issue create --title=<text> [--body=<text>] [--type=<type>] [--module=<name>] [--priority=<priority>]";
+var USAGE11 = "rafa issue create --title=<text> [--body=<text>] [--type=<type>] [--module=<name>] [--priority=<priority>]";
 var DEFAULT_ISSUE_TYPE = "code";
 function readIssueDraft(flags) {
   return {
     opt: 0,
-    title: readRequiredFlag(flags, "title", USAGE9),
-    body: readTextFlag(flags, "body", USAGE9) ?? "",
-    type: readChoiceFlag(flags, "type", ISSUE_TYPES, USAGE9) ?? DEFAULT_ISSUE_TYPE,
-    module: readNonBlankFlag(flags, "module", USAGE9) ?? TRIAGE_MODULE,
-    priority: readChoiceFlag(flags, "priority", ISSUE_PRIORITIES, USAGE9) ?? null,
+    title: readRequiredFlag(flags, "title", USAGE11),
+    body: readTextFlag(flags, "body", USAGE11) ?? "",
+    type: readChoiceFlag(flags, "type", ISSUE_TYPES, USAGE11) ?? DEFAULT_ISSUE_TYPE,
+    module: readNonBlankFlag(flags, "module", USAGE11) ?? TRIAGE_MODULE,
+    priority: readChoiceFlag(flags, "priority", ISSUE_PRIORITIES, USAGE11) ?? null,
     project: null,
     blockedBy: []
   };
@@ -9071,7 +9491,7 @@ function renderCreated(ref) {
   return [`Created ${issueName(ref)}.`, ...urlLines(ref)];
 }
 async function createIssue(context, seams) {
-  expectNoArgument(context.args, USAGE9);
+  expectNoArgument(context.args, USAGE11);
   const draft = readIssueDraft(context.flags);
   const { tracker, data } = await resolveIssueTracker(context, seams);
   const ref = await onTracker(tracker, "create the issue", () => tracker.create(draft));
@@ -9223,7 +9643,7 @@ function createGhBoardListing(options) {
 }
 
 // src/board/roadmap-rows.ts
-import { readdirSync as readdirSync5 } from "fs";
+import { readdirSync as readdirSync4 } from "fs";
 var OUTLINE_HEADINGS = 3;
 var UNKNOWN_STATE = "unknown";
 function isMissing(error) {
@@ -9232,7 +9652,7 @@ function isMissing(error) {
 function createPlanDirNames(dir) {
   return () => {
     try {
-      return Object.freeze(readdirSync5(dir));
+      return Object.freeze(readdirSync4(dir));
     } catch (error) {
       if (isMissing(error))
         return Object.freeze([]);
@@ -9463,24 +9883,24 @@ function renderRoadmapTable(rows, width) {
 }
 
 // src/commands/issue/list.ts
-var USAGE10 = "rafa issue list [--roadmap [--all]] [--state=<state>] [--type=<type>] [--module=<name>]" + " [--search=<text>] [--limit=<n>]";
-var SWITCH_HINT = `Type it bare: ${USAGE10}`;
+var USAGE12 = "rafa issue list [--roadmap [--all]] [--state=<state>] [--type=<type>] [--module=<name>]" + " [--search=<text>] [--limit=<n>]";
+var SWITCH_HINT = `Type it bare: ${USAGE12}`;
 var LIMIT = /^[1-9]\d*$/;
 function readLimit(flags) {
-  const value = readTextFlag(flags, "limit", USAGE10);
+  const value = readTextFlag(flags, "limit", USAGE12);
   if (value === undefined)
     return;
   const limit = Number(value);
   if (LIMIT.test(value) && Number.isSafeInteger(limit))
     return limit;
-  throw lineRefusal(`--limit is "${value}", expected a positive whole number`, USAGE10);
+  throw lineRefusal(`--limit is "${value}", expected a positive whole number`, USAGE12);
 }
 function readIssueQuery(flags) {
   const narrowed = {
-    state: readChoiceFlag(flags, "state", ISSUE_STATES, USAGE10),
-    type: readChoiceFlag(flags, "type", ISSUE_TYPES, USAGE10),
-    module: readNonBlankFlag(flags, "module", USAGE10),
-    text: readNonBlankFlag(flags, "search", USAGE10),
+    state: readChoiceFlag(flags, "state", ISSUE_STATES, USAGE12),
+    type: readChoiceFlag(flags, "type", ISSUE_TYPES, USAGE12),
+    module: readNonBlankFlag(flags, "module", USAGE12),
+    text: readNonBlankFlag(flags, "search", USAGE12),
     limit: readLimit(flags)
   };
   return Object.fromEntries(Object.entries(narrowed).filter(([, value]) => value !== undefined));
@@ -9489,10 +9909,10 @@ function readIssueListLine(flags) {
   const roadmap = readSwitch("roadmap", flags["roadmap"], SWITCH_HINT);
   const all = readSwitch("all", flags["all"], SWITCH_HINT);
   if (roadmap && flags["state"] !== undefined) {
-    throw lineRefusal("--state cannot narrow --roadmap: the Roadmap is read off the GitHub board, which holds an issue open or" + " closed and so no state of the tracker", USAGE10);
+    throw lineRefusal("--state cannot narrow --roadmap: the Roadmap is read off the GitHub board, which holds an issue open or" + " closed and so no state of the tracker", USAGE12);
   }
   if (all && !roadmap)
-    throw lineRefusal("--all keeps the ticked Roadmap lines, so it needs --roadmap", USAGE10);
+    throw lineRefusal("--all keeps the ticked Roadmap lines, so it needs --roadmap", USAGE12);
   return { roadmap, all };
 }
 function renderIssueList(kind, issues) {
@@ -9571,7 +9991,7 @@ async function listRoadmap(context, seams, all, filter) {
   });
 }
 async function listIssues(context, seams) {
-  expectNoArgument(context.args, USAGE10);
+  expectNoArgument(context.args, USAGE12);
   const query = readIssueQuery(context.flags);
   const { tracker, data } = await resolveIssueTracker(context, seams);
   const refs = await onTracker(tracker, "list issues", () => tracker.find(query));
@@ -9590,7 +10010,7 @@ async function runIssueList(context, seams) {
       context.output.info(text);
     return;
   }
-  expectNoArgument(context.args, USAGE10);
+  expectNoArgument(context.args, USAGE12);
   const filter = readIssueQuery(context.flags);
   const listed2 = await listRoadmap(context, seams, line.all, filter);
   if (context.outputMode === "json") {
@@ -9677,10 +10097,10 @@ function createIssueListCommand(seams = DEFAULT_ISSUE_SEAMS) {
 var list_default5 = createIssueListCommand();
 
 // src/commands/issue/move.ts
-var USAGE11 = "rafa issue move <id> <state>";
+var USAGE13 = "rafa issue move <id> <state>";
 async function moveIssue(context, seams) {
-  const [id, word] = expectTwoArguments(context.args, USAGE11);
-  const state = readChoice(word, "The state", ISSUE_STATES, USAGE11);
+  const [id, word] = expectTwoArguments(context.args, USAGE13);
+  const state = readChoice(word, "The state", ISSUE_STATES, USAGE13);
   const { tracker, data } = await resolveIssueTracker(context, seams);
   const ref = issueRef(tracker, id);
   const moved = await onTracker(tracker, `move issue ${id} to ${state}`, () => tracker.transition(ref, state));
@@ -9739,7 +10159,7 @@ function createIssueMoveCommand(seams = DEFAULT_ISSUE_SEAMS) {
 var move_default = createIssueMoveCommand();
 
 // src/commands/issue/show.ts
-var USAGE12 = "rafa issue show <id>";
+var USAGE14 = "rafa issue show <id>";
 var NO_PRIORITY = "needs-triage";
 function renderIssue(kind, issue) {
   const project = issue.project === null ? [] : [`Project: ${issue.project}`];
@@ -9761,7 +10181,7 @@ function renderIssue(kind, issue) {
   ];
 }
 async function showIssue(context, seams) {
-  const id = expectOneArgument(context.args, USAGE12);
+  const id = expectOneArgument(context.args, USAGE14);
   const { tracker, data } = await resolveIssueTracker(context, seams);
   const issue = await onTracker(tracker, `read issue ${id}`, () => tracker.get(issueRef(tracker, id)));
   return { tracker: data, issue };
@@ -10050,8 +10470,8 @@ function projectRoot2(context) {
     throw new Error("rafa issue unblock runs inside a project, and was handed none");
   return context.project.root;
 }
-function isYes(answer) {
-  return answer !== null && YES_ANSWERS2.includes(answer.trim().toLowerCase());
+function isYes(answer2) {
+  return answer2 !== null && YES_ANSWERS2.includes(answer2.trim().toLowerCase());
 }
 function lazyPrompter2(open) {
   let prompter = null;
@@ -10151,7 +10571,7 @@ function createIssueUnblockCommand(seams = DEFAULT_UNBLOCK_SEAMS) {
 var unblock_default = createIssueUnblockCommand();
 
 // src/commands/loop/list.ts
-var USAGE13 = "rafa loop list";
+var USAGE15 = "rafa loop list";
 function renderSessionList(list) {
   if (list.sessions.length === 0)
     return ["No running sessions."];
@@ -10161,7 +10581,7 @@ function renderSessionList(list) {
   ];
 }
 async function runList5(context, seams) {
-  expectNoArgument(context.args, USAGE13);
+  expectNoArgument(context.args, USAGE15);
   const root = projectRoot(context);
   const sessions = readRecords(root, seams).filter(isLive).map((session) => {
     const checklist = readSessionChecklist(root, session);
@@ -10206,7 +10626,7 @@ function createLoopListCommand(seams = {}) {
 var list_default6 = createLoopListCommand();
 
 // src/commands/loop/pause.ts
-var USAGE14 = "rafa loop pause [-s|--session-id=<id>]";
+var USAGE16 = "rafa loop pause [-s|--session-id=<id>]";
 function renderPause(result) {
   const { session } = result;
   if (!result.changed)
@@ -10215,8 +10635,8 @@ function renderPause(result) {
   return [when, "  Nothing is marked. `rafa loop resume` goes on, and `rafa loop stop` ends the run."];
 }
 async function runPause(context, seams) {
-  expectNoArgument(context.args, USAGE14);
-  const { root, record } = pickSession(context, USAGE14, "live", seams);
+  expectNoArgument(context.args, USAGE16);
+  const { root, record } = pickSession(context, USAGE16, "live", seams);
   if (!isLive(record)) {
     throw refusal(`Session ${record.sessionId} reads ${record.state}: no run is left to pause.`);
   }
@@ -10256,7 +10676,7 @@ function createLoopPauseCommand(seams = {}) {
 var pause_default = createLoopPauseCommand();
 
 // src/commands/loop/resume.ts
-var USAGE15 = "rafa loop resume [-s|--session-id=<id>]";
+var USAGE17 = "rafa loop resume [-s|--session-id=<id>]";
 function renderResume(result) {
   const { session } = result;
   if (!result.changed)
@@ -10264,8 +10684,8 @@ function renderResume(result) {
   return [session.task === null ? `Resumed session ${session.sessionId}: it goes on with its next task.` : `Resumed session ${session.sessionId}: it goes on past its running task, line ${session.task.line}, ${session.task.text}`];
 }
 async function runResume(context, seams) {
-  expectNoArgument(context.args, USAGE15);
-  const { root, record } = pickSession(context, USAGE15, "live", seams);
+  expectNoArgument(context.args, USAGE17);
+  const { root, record } = pickSession(context, USAGE17, "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.`);
   }
@@ -10328,6 +10748,11 @@ var wrapped = wrapPhaseZeroCommand({
       description: "How much of the plan each task session is handed: `full`, `stage` or `task`." + " Outranks `plan.inject` in `.rafa/config.yaml`. The wrap-up is handed the whole plan.",
       type: "string"
     },
+    {
+      name: "skills-resolver",
+      description: "The resolver that picks the skills each task session is handed: `planner`, `tag`" + " or `none`. Outranks `task.skills` in `.rafa/config.yaml` for this run only.",
+      type: "string"
+    },
     {
       name: "runtime",
       description: "The installed rafa the run goes on in: a version under `~/.rafa/runtime/`, or a path" + " against the working directory to a `cli.js` or the directory holding it. Refused inside the" + " `src/` of the working directory or the project root. Typed after `loop start`.",
@@ -10400,7 +10825,7 @@ var loopStart = Object.freeze({
 var start_default = endingWith(loopStart);
 
 // src/commands/loop/status.ts
-var USAGE16 = "rafa loop status [-s|--session-id=<id>]";
+var USAGE18 = "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) {
@@ -10436,8 +10861,8 @@ function renderStatus(status) {
   ];
 }
 async function runStatus(context, seams) {
-  expectNoArgument(context.args, USAGE16);
-  const { root, record } = pickSession(context, USAGE16, "live-or-newest", seams);
+  expectNoArgument(context.args, USAGE18);
+  const { root, record } = pickSession(context, USAGE18, "live-or-newest", seams);
   const checklist = readSessionChecklist(root, record);
   const tasks = checklist === null ? null : countTasks(checklist.tasks);
   let eta = null;
@@ -10490,7 +10915,7 @@ function createLoopStatusCommand(seams = {}) {
 var status_default = createLoopStatusCommand();
 
 // src/commands/loop/stop.ts
-var USAGE17 = "rafa loop stop [-s|--session-id=<id>]";
+var USAGE19 = "rafa loop stop [-s|--session-id=<id>]";
 function signalRun(record, interrupt) {
   try {
     interrupt(record.pid);
@@ -10543,8 +10968,8 @@ function renderStop(result) {
   ];
 }
 async function runStop(context, seams) {
-  expectNoArgument(context.args, USAGE17);
-  const { root, record } = pickSession(context, USAGE17, "live", seams);
+  expectNoArgument(context.args, USAGE19);
+  const { root, record } = pickSession(context, USAGE19, "live", seams);
   if (!isLive(record)) {
     throw refusal(`Session ${record.sessionId} reads ${record.state}: no run is left to stop.`);
   }
@@ -10595,7 +11020,7 @@ function createLoopStopCommand(seams = {}) {
 var stop_default = createLoopStopCommand();
 
 // src/commands/module/exec.ts
-var USAGE18 = "rafa module exec <module> <action> [args] [flags]";
+var USAGE20 = "rafa module exec <module> <action> [args] [flags]";
 var execCommand = {
   name: "module exec",
   subject: "module",
@@ -10624,13 +11049,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: ${USAGE18}`);
+Usage: ${USAGE20}`);
   }
 };
 var exec_default = Object.freeze(execCommand);
 
 // src/commands/module/list.ts
-var USAGE19 = "rafa module list";
+var USAGE21 = "rafa module list";
 function sourceText(source) {
   const ref = source.ref === null ? "" : `@${source.ref}`;
   return `${source.kind} ${source.location}${ref}`;
@@ -10651,10 +11076,10 @@ function renderModuleList(list) {
   return ["Modules:", ...list.modules.flatMap(moduleLines)];
 }
 async function runList6(context, seams) {
-  expectNoArgument(context.args, USAGE19);
+  expectNoArgument(context.args, USAGE21);
   const { project } = context;
   if (project === null)
-    throw new CommandExit(1, `\u274C ${USAGE19} runs inside a project`);
+    throw new CommandExit(1, `\u274C ${USAGE21} runs inside a project`);
   let loaded;
   try {
     const resolved = loadConfig({ root: project.root, home: project.home });
@@ -10807,7 +11232,7 @@ function fastForwardBase(git, plan2) {
 
 // src/commands/next.ts
 var NEXT_USAGE = "rafa next [--dry-run] [--yes[=<action ids>]]";
-var DRY_RUN_FLAG2 = "dry-run";
+var DRY_RUN_FLAG3 = "dry-run";
 var STATE_MARK = "\uD83D\uDCCD";
 var PROPOSAL_MARK = "\uD83D\uDC49";
 var STOP_MARK = "\u23F9";
@@ -10828,7 +11253,7 @@ function dryRunLine(dryRun) {
   if (dryRun === "no-terminal") {
     return `${STOP_MARK} There is no terminal to answer on, so nothing ran; run rafa next where you can answer,` + ` or type --${YES_FLAG}=${BARE_YES_ACTIONS.join(",")} to allow those steps unasked.`;
   }
-  return `${STOP_MARK} --${DRY_RUN_FLAG2}: nothing ran.`;
+  return `${STOP_MARK} --${DRY_RUN_FLAG3}: nothing ran.`;
 }
 function stopLine(stop, state, ceiling, dryRun) {
   if (stop === "dry-run")
@@ -10924,14 +11349,14 @@ function lineRefusal2(problem2) {
 Usage: ${NEXT_USAGE}`);
 }
 function readDryRun(flags) {
-  const value = flags[DRY_RUN_FLAG2];
+  const value = flags[DRY_RUN_FLAG3];
   if (value === undefined)
     return false;
   if (typeof value === "boolean")
     return value;
   if (value === "true" || value === "false")
     return value === "true";
-  throw lineRefusal2(`--${DRY_RUN_FLAG2} takes no value, and read "${value}" as one`);
+  throw lineRefusal2(`--${DRY_RUN_FLAG3} takes no value, and read "${value}" as one`);
 }
 function dryRunOf(flag, ceiling, hasTerminal) {
   if (flag)
@@ -10983,7 +11408,7 @@ async function runNext(context, seams) {
 var YES_ID_LIST = YES_ACTIONS.join(", ");
 var NEXT_FLAGS = Object.freeze([
   {
-    name: DRY_RUN_FLAG2,
+    name: DRY_RUN_FLAG3,
     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"
   },
@@ -11120,10 +11545,10 @@ var wrapped2 = wrapPhaseZeroCommand({
 var create_default2 = endingWith(wrapped2);
 
 // src/commands/plan/risk.ts
-import { readFileSync as readFileSync18 } from "fs";
+import { readFileSync as readFileSync16 } from "fs";
 import { resolve as resolve11 } from "path";
 var COMMAND2 = "rafa plan risk";
-var USAGE20 = "rafa plan risk [<plan>] [--strict]";
+var USAGE22 = "rafa plan risk [<plan>] [--strict]";
 var STRICT_HINT = `Type the plan first: ${COMMAND2} <plan> --strict`;
 function spawningRunners(root) {
   return { git: createGitRunner(root), gh: createGhRunner({ cwd: root }) };
@@ -11136,7 +11561,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: ${USAGE20}`);
+Usage: ${USAGE22}`);
 }
 function riskLine(finding) {
   const line = finding.line === undefined ? "" : `:${String(finding.line)}`;
@@ -11148,7 +11573,7 @@ function strictRefusal(report2) {
 }
 async function readRisk(path, project, config, context, seams) {
   const makeRunners = seams.runners ?? spawningRunners;
-  return assessPlanRisk({ path, text: readFileSync18(path, "utf8") }, {
+  return assessPlanRisk({ path, text: readFileSync16(path, "utf8") }, {
     repoRoot: project.root,
     home: project.home,
     settingSources: config.settingSources,
@@ -11200,7 +11625,7 @@ function createPlanRiskCommand(seams = {}) {
     outputs: ["text", "json"],
     run: async (context) => {
       const strict = readSwitch("strict", context.flags["strict"], STRICT_HINT);
-      const typed = expectAtMostOneArgument(context.args, USAGE20);
+      const typed = expectAtMostOneArgument(context.args, USAGE22);
       const project = requireProject(context, COMMAND2);
       const config = resolveProjectConfig(project, COMMAND2, (message) => {
         context.output.warn(message);
@@ -11231,9 +11656,9 @@ function createPlanRiskCommand(seams = {}) {
 var risk_default = createPlanRiskCommand();
 
 // src/commands/plan/show.ts
-import { readFileSync as readFileSync19 } from "fs";
-import { join as join24 } from "path";
-var USAGE21 = "rafa plan show <stub> [--tracker]";
+import { readFileSync as readFileSync17 } from "fs";
+import { join as join23 } from "path";
+var USAGE23 = "rafa plan show <stub> [--tracker]";
 var COMMAND3 = "rafa plan show";
 function readTrackerFlag(value) {
   if (value === undefined || value === false || value === "false")
@@ -11250,10 +11675,10 @@ function showPlan(plans, stub, tracker) {
     throw new CommandExit(1, `\u274C "${stub}" is no plan stub: a stub is letters, digits, ".", "_" and "-"`);
   }
   const name2 = planFileName(stub, tracker);
-  const file = join24(plans.path, name2);
+  const file = join23(plans.path, name2);
   if (!isFile(file))
-    throw new CommandExit(1, missingText(stub, tracker, join24(plans.label, name2)));
-  const model = parsePlan(readFileSync19(file, "utf8"));
+    throw new CommandExit(1, missingText(stub, tracker, join23(plans.label, name2)));
+  const model = parsePlan(readFileSync17(file, "utf8"));
   const { header } = model;
   return {
     stub,
@@ -11276,7 +11701,7 @@ function taskLine(task) {
   return `  ${checkbox(task.status)} ${task.text}`;
 }
 function renderShownPlan(shown, dirLabel) {
-  const relative7 = join24(dirLabel, planFileName(shown.stub, shown.tracker));
+  const relative7 = join23(dirLabel, planFileName(shown.stub, shown.tracker));
   const fileLabel = shown.tracker ? "Tracker" : "File";
   const lines2 = [`Plan: ${shown.stub}`, `${fileLabel}: ${relative7}`];
   if (shown.header.issue !== null)
@@ -11329,7 +11754,7 @@ var planShowCommand = {
   outputs: ["text", "json"],
   run: async (context) => {
     const tracker = readTrackerFlag(context.flags.tracker);
-    const stub = expectOneArgument(context.args, USAGE21);
+    const stub = expectOneArgument(context.args, USAGE23);
     const plans = resolvePlansDir(requireProject(context, COMMAND3), COMMAND3, (message) => {
       context.output.warn(message);
     });
@@ -11468,7 +11893,7 @@ Run rafa pr list to see the open pull requests.`, usage2);
 }
 
 // src/commands/pr/current.ts
-var USAGE22 = PR_USAGE.current;
+var USAGE24 = PR_USAGE.current;
 var SEPARATOR = " \u2014 ";
 function trimmedOrNull(value) {
   const trimmed = value.trim();
@@ -11499,9 +11924,9 @@ async function probeChecks(pulls, number) {
   }
 }
 async function readCurrent(context, seams) {
-  expectNoArguments(context.args, USAGE22);
+  expectNoArguments(context.args, USAGE24);
   const pr = openPrContext(context, seams);
-  const pick = await pickPullRequest(pr, null, USAGE22);
+  const pick = await pickPullRequest(pr, null, USAGE24);
   const summary = pick.summary;
   const probe = await probeChecks(pr.pulls, pick.number);
   const reading = {
@@ -11554,7 +11979,7 @@ function createPrCurrentCommand(seams = DEFAULT_PR_SEAMS) {
 var current_default = createPrCurrentCommand();
 
 // src/commands/pr/list.ts
-var USAGE23 = PR_USAGE.list;
+var USAGE25 = PR_USAGE.list;
 var UNREADABLE2 = "?";
 var PROBE_LIMIT = 6;
 var TITLE_WIDTH = 60;
@@ -11597,8 +12022,8 @@ function titleCell(title) {
     return "(no title)";
   return trimmed.length > TITLE_WIDTH ? `${trimmed.slice(0, TITLE_WIDTH - CUT.length)}${CUT}` : trimmed;
 }
-function headLine3(count) {
-  return count === 1 ? "1 open pull request" : `${count} open pull requests`;
+function headLine3(count2) {
+  return count2 === 1 ? "1 open pull request" : `${count2} open pull requests`;
 }
 function cellsOf(row2, now) {
   return [
@@ -11655,7 +12080,7 @@ async function rowOf3(pulls, pull) {
   };
 }
 async function readList(context, seams, now) {
-  expectNoArguments(context.args, USAGE23);
+  expectNoArguments(context.args, USAGE25);
   const pr = openPrContext(context, seams);
   const open = await onProvider("list the open pull requests", () => pr.pulls.list());
   const rows = await mapWithLimit(open, PROBE_LIMIT, (pull) => rowOf3(pr.pulls, pull));
@@ -11695,8 +12120,8 @@ function createPrListCommand(seams = DEFAULT_PR_SEAMS) {
 var list_default8 = createPrListCommand();
 
 // src/commands/pr/merge.ts
-import { existsSync as existsSync9, readFileSync as readFileSync21 } from "fs";
-import { join as join26 } from "path";
+import { existsSync as existsSync10, readFileSync as readFileSync19 } from "fs";
+import { join as join25 } from "path";
 
 // src/board/roadmap-tick.ts
 var PREFIX5 = "board roadmap";
@@ -11851,17 +12276,17 @@ function tickSentence(result) {
 import {
   chmodSync,
   copyFileSync as copyFileSync3,
-  existsSync as existsSync8,
+  existsSync as existsSync9,
   mkdirSync as mkdirSync6,
-  readdirSync as readdirSync6,
-  readFileSync as readFileSync20,
+  readdirSync as readdirSync5,
+  readFileSync as readFileSync18,
   realpathSync as realpathSync5,
-  renameSync,
-  rmSync as rmSync2,
-  statSync as statSync13,
+  renameSync as renameSync2,
+  rmSync as rmSync3,
+  statSync as statSync12,
   symlinkSync
 } from "fs";
-import { basename as basename7, delimiter as delimiter2, dirname as dirname4, join as join25, relative as relative7, resolve as resolve12 } from "path";
+import { basename as basename7, delimiter as delimiter2, dirname as dirname4, join as join24, relative as relative7, resolve as resolve12 } from "path";
 var LINK_NAME = "rafa";
 var FORCE_FLAG = "--force";
 var EXIT_DONE = 0;
@@ -11923,19 +12348,19 @@ function runtimeRefusalLines(runtimeDir, version2) {
 }
 function listTrackers(repoRoot, planDir) {
   const dir = resolve12(repoRoot, planDir);
-  return entryNames(dir).filter((entry) => TRACKER_NAME.test(entry)).sort((a, b) => a.localeCompare(b)).map((entry) => join25(dir, entry)).filter((path) => statSync13(path).isFile()).map((path) => relative7(repoRoot, path));
+  return entryNames(dir).filter((entry) => TRACKER_NAME.test(entry)).sort((a, b) => a.localeCompare(b)).map((entry) => join24(dir, entry)).filter((path) => statSync12(path).isFile()).map((path) => relative7(repoRoot, path));
 }
 function openTrackers(repoRoot, planDir) {
   return listTrackers(repoRoot, planDir).flatMap((path) => {
-    const task = findNextTask(readFileSync20(join25(repoRoot, path), "utf8"));
+    const task = findNextTask(readFileSync18(join24(repoRoot, path), "utf8"));
     return task ? [{ path, task }] : [];
   });
 }
 function readManifestVersion2(repoRoot) {
-  const manifest = JSON.parse(readFileSync20(join25(repoRoot, "package.json"), "utf8"));
+  const manifest = JSON.parse(readFileSync18(join24(repoRoot, "package.json"), "utf8"));
   const record = typeof manifest === "object" && manifest !== null ? manifest : {};
   if (record["name"] !== name) {
-    throw new Error(`${join25(repoRoot, "package.json")} names ${JSON.stringify(record["name"])}, not ${name}: this is no rafa checkout`);
+    throw new Error(`${join24(repoRoot, "package.json")} names ${JSON.stringify(record["name"])}, not ${name}: this is no rafa checkout`);
   }
   const version2 = record["version"];
   if (typeof version2 !== "string" || !VERSION_SHAPE.test(version2)) {
@@ -11946,10 +12371,10 @@ function readManifestVersion2(repoRoot) {
 function copyTree(from, to) {
   mkdirSync6(to, { recursive: true });
   let copied = 0;
-  const entries = readdirSync6(from, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+  const entries = readdirSync5(from, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
   for (const entry of entries) {
-    const source = join25(from, entry.name);
-    const target = join25(to, entry.name);
+    const source = join24(from, entry.name);
+    const target = join24(to, entry.name);
     if (entry.isDirectory()) {
       copied += copyTree(source, target);
     } else if (entry.isFile()) {
@@ -11963,41 +12388,41 @@ function copyTree(from, to) {
 }
 function replaceTree(from, to) {
   const staging = temporaryName(to);
-  rmSync2(staging, { recursive: true, force: true });
+  rmSync3(staging, { recursive: true, force: true });
   try {
     const copied = copyTree(from, staging);
-    swapIn(staging, to);
+    swapIn2(staging, to);
     return copied;
   } catch (err) {
-    rmSync2(staging, { recursive: true, force: true });
+    rmSync3(staging, { recursive: true, force: true });
     throw err;
   }
 }
-function swapIn(staging, to) {
-  if (!existsSync8(to)) {
-    renameSync(staging, to);
+function swapIn2(staging, to) {
+  if (!existsSync9(to)) {
+    renameSync2(staging, to);
     return;
   }
   const outgoing = `${temporaryName(to)}.outgoing`;
-  rmSync2(outgoing, { recursive: true, force: true });
-  renameSync(to, outgoing);
+  rmSync3(outgoing, { recursive: true, force: true });
+  renameSync2(to, outgoing);
   try {
-    renameSync(staging, to);
+    renameSync2(staging, to);
   } catch (err) {
-    renameSync(outgoing, to);
+    renameSync2(outgoing, to);
     throw err;
   }
-  rmSync2(outgoing, { recursive: true, force: true });
+  rmSync3(outgoing, { recursive: true, force: true });
 }
 function relink(linkPath, target) {
   mkdirSync6(dirname4(linkPath), { recursive: true });
   const temporary = temporaryName(linkPath);
-  rmSync2(temporary, { force: true });
+  rmSync3(temporary, { force: true });
   try {
     symlinkSync(target, temporary);
-    renameSync(temporary, linkPath);
+    renameSync2(temporary, linkPath);
   } catch (err) {
-    rmSync2(temporary, { force: true });
+    rmSync3(temporary, { force: true });
     throw err;
   }
   const resolved = realpathSync5(linkPath);
@@ -12044,8 +12469,8 @@ function installRuntime(seams, options = {}) {
 }
 function runInstall(seams, options) {
   const { repoRoot, home, log } = seams;
-  const runtimeRoot = join25(home, RUNTIME_SUBDIR);
-  const linkPath = join25(home, RAFA_BIN_DIR, LINK_NAME);
+  const runtimeRoot = join24(home, RUNTIME_SUBDIR);
+  const linkPath = join24(home, RAFA_BIN_DIR, LINK_NAME);
   log(`repo root: ${repoRoot}`);
   log(`runtime root: ${runtimeRoot}`);
   log(`link: ${linkPath}`);
@@ -12055,9 +12480,9 @@ function runInstall(seams, options) {
   const open = inStage("trackers", () => openTrackers(repoRoot, planDir));
   if (open.length > 0)
     return { kind: "refused", reason: "trackers", planDir, trackers: open };
-  const distDir = join25(repoRoot, "dist");
-  const runtimeDir = join25(runtimeRoot, version2);
-  const installed = existsSync8(runtimeDir);
+  const distDir = join24(repoRoot, "dist");
+  const runtimeDir = join24(runtimeRoot, version2);
+  const installed = existsSync9(runtimeDir);
   if (installed && options.force !== true) {
     return { kind: "refused", reason: "runtime-exists", version: version2, runtimeDir };
   }
@@ -12065,13 +12490,13 @@ function runInstall(seams, options) {
   const code = inStage("build", () => seams.build(repoRoot));
   if (code !== 0)
     throw new StageFailure("build", `the build exited ${code}`);
-  if (!existsSync8(join25(distDir, RUNTIME_ENTRY))) {
-    throw new StageFailure("build", `the build exited 0 and left no ${join25(distDir, RUNTIME_ENTRY)}`);
+  if (!existsSync9(join24(distDir, RUNTIME_ENTRY))) {
+    throw new StageFailure("build", `the build exited 0 and left no ${join24(distDir, RUNTIME_ENTRY)}`);
   }
   log(installed ? `copying ${distDir} over ${runtimeDir}, replacing it whole` : `copying ${distDir} into ${runtimeDir}`);
   const copied = inStage("copy", () => replaceTree(distDir, runtimeDir));
   log(`copied ${copied} file(s)`);
-  const resolved = inStage("link", () => relink(linkPath, join25(runtimeDir, RUNTIME_ENTRY)));
+  const resolved = inStage("link", () => relink(linkPath, join24(runtimeDir, RUNTIME_ENTRY)));
   log(`${linkPath} resolves to ${resolved}`);
   return { kind: "done", version: version2, runtimeDir, linkPath, resolved, copied };
 }
@@ -12086,7 +12511,7 @@ function inStage(stage, run) {
 }
 function entryNames(dir) {
   try {
-    return readdirSync6(dir);
+    return readdirSync5(dir);
   } catch (err) {
     if (typeof err === "object" && err !== null && "code" in err && err.code === "ENOENT")
       return [];
@@ -12097,15 +12522,15 @@ function replaceFile(source, target) {
   const temporary = temporaryName(target);
   try {
     copyFileSync3(source, temporary);
-    chmodSync(temporary, statSync13(source).mode & 4095);
-    renameSync(temporary, target);
+    chmodSync(temporary, statSync12(source).mode & 4095);
+    renameSync2(temporary, target);
   } catch (err) {
-    rmSync2(temporary, { force: true });
+    rmSync3(temporary, { force: true });
     throw err;
   }
 }
 function temporaryName(path) {
-  return join25(dirname4(path), `.${basename7(path)}.snapshot-${process.pid}`);
+  return join24(dirname4(path), `.${basename7(path)}.snapshot-${process.pid}`);
 }
 
 // src/commands/pr/merge-followups.ts
@@ -12281,8 +12706,8 @@ async function readUncheckedMerge(options) {
   }
   return Object.freeze({ workflowCount, reading, yes });
 }
-function isYes2(answer) {
-  return answer !== null && YES_ANSWERS3.includes(answer.trim().toLowerCase());
+function isYes2(answer2) {
+  return answer2 !== null && YES_ANSWERS3.includes(answer2.trim().toLowerCase());
 }
 async function confirmUncheckedMerge(unchecked, options) {
   for (const line of unchecked.reading.warning)
@@ -12298,11 +12723,11 @@ async function confirmUncheckedMerge(unchecked, options) {
   }
 }
 function commentProblemLine(number, problem2, body) {
-  const quoted = body.split(`
+  const quoted2 = body.split(`
 `).map((line) => `${INDENT3}${line}`).join(`
 `);
   return `the unchecked-merge comment was not posted on #${number}: ${problem2}. Post it yourself:
-${quoted}`;
+${quoted2}`;
 }
 async function postUncheckedComment(pulls, number, unchecked, warn) {
   const body = unchecked.reading.comment;
@@ -12315,7 +12740,7 @@ async function postUncheckedComment(pulls, number, unchecked, warn) {
 }
 
 // src/commands/pr/merge.ts
-var USAGE24 = PR_USAGE.merge;
+var USAGE26 = PR_USAGE.merge;
 var REMOTE3 = "origin";
 var INDENT4 = "   ";
 var YES_ANSWERS4 = ["y", "yes"];
@@ -12373,8 +12798,8 @@ function requireTerminal(seams, summary) {
     "Merge it without the question with --yes."
   ]);
 }
-function isYes3(answer) {
-  return answer !== null && YES_ANSWERS4.includes(answer.trim().toLowerCase());
+function isYes3(answer2) {
+  return answer2 !== null && YES_ANSWERS4.includes(answer2.trim().toLowerCase());
 }
 function prompterOf(seams) {
   return seams.openPrompter ?? (() => createLinePrompter(process.stdin, process.stderr));
@@ -12396,13 +12821,13 @@ function remoteHoldsBranch(git, branch, warn) {
 }
 function textOf(path) {
   try {
-    return readFileSync21(path, "utf8");
+    return readFileSync19(path, "utf8");
   } catch {
     return "";
   }
 }
 function followUpsFor(pr, git) {
-  const facts = readPackageFacts(textOf(join26(pr.project.root, "package.json")));
+  const facts = readPackageFacts(textOf(join25(pr.project.root, "package.json")));
   if (facts.version === null)
     return [];
   const tags = git(["tag", "--list", versionTag(facts.version)]);
@@ -12410,7 +12835,7 @@ function followUpsFor(pr, git) {
     version: facts.version,
     tagged: tags.ok && tags.stdout.trim() !== "",
     rafaCheckout: facts.rafaCheckout,
-    runtimeInstalled: existsSync9(join26(pr.project.home, RUNTIME_SUBDIR, facts.version))
+    runtimeInstalled: existsSync10(join25(pr.project.home, RUNTIME_SUBDIR, facts.version))
   });
 }
 function openGh(pr, seams) {
@@ -12522,22 +12947,22 @@ async function commentIfUnchecked(context, pr, number, unchecked) {
   return posted.url;
 }
 async function runMerge(context, seams) {
-  const yes = readBooleanFlag(context.flags, "yes", USAGE24);
-  const skipChecks = readBooleanFlag(context.flags, "skip-checks", USAGE24);
-  const wanted = readMethodFlag(context.flags, USAGE24);
-  const asked = readPullArgument(context.args, USAGE24);
+  const yes = readBooleanFlag(context.flags, "yes", USAGE26);
+  const skipChecks = readBooleanFlag(context.flags, "skip-checks", USAGE26);
+  const wanted = readMethodFlag(context.flags, USAGE26);
+  const asked = readPullArgument(context.args, USAGE26);
   const pr = openPrContext(context, seams);
   const git = (seams.git ?? createGitRunner)(pr.project.root);
   const method = wanted ?? pr.mergeMethod;
-  const pick = await pickPullRequest(pr, asked, USAGE24);
+  const pick = await pickPullRequest(pr, asked, USAGE26);
   const detail = await onProvider(`read pull request #${pick.number}`, () => pr.pulls.get(pick.number));
   if (detail === null) {
-    throw lineRefusal3(`No pull request #${pick.number} at ${pr.project.root}`, USAGE24);
+    throw lineRefusal3(`No pull request #${pick.number} at ${pr.project.root}`, USAGE26);
   }
   const checks = await onProvider(`read the checks of #${pick.number}`, () => pr.pulls.checks(pick.number));
   refuseFromGit(git, detail, checks, skipChecks);
   const summary = summaryLine2(detail, method);
-  const answer = await askToMerge(context, pr, seams, { number: detail.number, summary, yes, skipChecks });
+  const answer2 = await askToMerge(context, pr, seams, { number: detail.number, summary, yes, skipChecks });
   const answered3 = {
     number: detail.number,
     source: pick.source,
@@ -12552,9 +12977,9 @@ async function runMerge(context, seams) {
     followUps: [],
     roadmapTick: null,
     unblocked: null,
-    unchecked: uncheckedReport(answer.unchecked, null)
+    unchecked: uncheckedReport(answer2.unchecked, null)
   };
-  if (!answer.go) {
+  if (!answer2.go) {
     context.output.info("Nothing was merged.");
     return answered3;
   }
@@ -12563,7 +12988,7 @@ async function runMerge(context, seams) {
     throw refusal5([`\u274C ${pr.pulls.kind} would not merge #${detail.number}: ${outcome2.detail}`]);
   }
   context.output.info(`Merged #${detail.number} into ${detail.baseRefName} (${method}).`);
-  const commentUrl = await commentIfUnchecked(context, pr, detail.number, answer.unchecked);
+  const commentUrl = await commentIfUnchecked(context, pr, detail.number, answer2.unchecked);
   const roadmapTick = await reportTick(context, pr, seams, detail);
   const remoteBranchPresent = remoteHoldsBranch(git, detail.headRefName, (message) => {
     context.output.warn(message);
@@ -12586,7 +13011,7 @@ async function runMerge(context, seams) {
     followUps,
     roadmapTick,
     unblocked,
-    unchecked: uncheckedReport(answer.unchecked, commentUrl)
+    unchecked: uncheckedReport(answer2.unchecked, commentUrl)
   };
 }
 function createPrMergeCommand(seams = DEFAULT_MERGE_SEAMS) {
@@ -12791,8 +13216,8 @@ function fencedBlock(body, language) {
   return `${fence}${language}
 ${text}${fence}`;
 }
-function counted2(count, noun) {
-  return count === 1 ? `1 ${noun}` : `${count} ${noun}s`;
+function counted2(count2, noun) {
+  return count2 === 1 ? `1 ${noun}` : `${count2} ${noun}s`;
 }
 function excerptCaption(reading) {
   const shown = counted2(reading.lines.length, "line");
@@ -12961,17 +13386,17 @@ function readTriageBlock(body) {
   }
   return readFields(document);
 }
-function quoted(value) {
+function quoted2(value) {
   return JSON.stringify(value);
 }
 function writeTriageBlock(fields) {
   return [
-    `head: ${quoted(fields.head)}`,
-    `at: ${quoted(fields.at)}`,
-    `class: ${quoted(fields.triageClass)}`,
+    `head: ${quoted2(fields.head)}`,
+    `at: ${quoted2(fields.at)}`,
+    `class: ${quoted2(fields.triageClass)}`,
     `simple: ${String(fields.simple)}`,
     `attempts: ${String(fields.attempts)}`,
-    `files: [${fields.files.map((file) => quoted(file)).join(", ")}]`
+    `files: [${fields.files.map((file) => quoted2(file)).join(", ")}]`
   ].join(`
 `);
 }
@@ -13001,10 +13426,10 @@ function noChecksLines(input) {
     return [];
   const number = input.pr.number;
   const unchecked = readUnchecked(number, input.workflowCount ?? null);
-  const [count = "", warning = ""] = unchecked.warning;
+  const [count2 = "", warning = ""] = unchecked.warning;
   const yes = unchecked.yesMayAnswer ? "`--yes` may answer it" : "`--yes` is refused, so a person must answer it";
   return [
-    `- Workflows: ${count}`,
+    `- Workflows: ${count2}`,
     `- Warning: ${warning}`,
     `- To merge it anyway: \`${skipChecksCommand(number)}\` (it asks first; ${yes})`
   ];
@@ -13088,7 +13513,7 @@ function readLastTriage(comments) {
 }
 
 // src/commands/pr/show.ts
-var USAGE25 = PR_USAGE.show;
+var USAGE27 = PR_USAGE.show;
 var INDENT5 = "   ";
 var SHORT_SHA = 7;
 function headLine4(detail) {
@@ -13186,12 +13611,12 @@ async function probe2(call) {
   }
 }
 async function readShow(context, seams) {
-  const asked = readPullArgument(context.args, USAGE25);
+  const asked = readPullArgument(context.args, USAGE27);
   const pr = openPrContext(context, seams);
-  const pick = await pickPullRequest(pr, asked, USAGE25);
+  const pick = await pickPullRequest(pr, asked, USAGE27);
   const detail = await onProvider(`read pull request #${pick.number}`, () => pr.pulls.get(pick.number));
   if (detail === null) {
-    throw lineRefusal3(`No pull request #${pick.number} in the repository at ${pr.project.root}`, USAGE25);
+    throw lineRefusal3(`No pull request #${pick.number} in the repository at ${pr.project.root}`, USAGE27);
   }
   const checks = await probe2(() => pr.pulls.checks(pick.number));
   const comments = await probe2(() => pr.pulls.comments(pick.number));
@@ -13396,8 +13821,8 @@ function readsAsConflicting(pr, conflictFiles) {
     return true;
   return conflictFiles.length > 0;
 }
-function checkCount(count) {
-  return count === 1 ? "1 check" : `${count} checks`;
+function checkCount(count2) {
+  return count2 === 1 ? "1 check" : `${count2} checks`;
 }
 function fileList(files) {
   const shown = files.slice(0, REASON_FILE_LIMIT).join(", ");
@@ -13408,12 +13833,12 @@ function conflictReason(files) {
   return files.length === 0 ? "the head conflicts with the base and no conflicting file was read" : `the head conflicts with the base on ${fileList(files)}`;
 }
 function failureReason(step, failing) {
-  const count = checkCount(failing.length);
-  return step === undefined ? `${count} failing, and no failing step was named` : `${count} failing, the failing step being "${step.name}"`;
+  const count2 = checkCount(failing.length);
+  return step === undefined ? `${count2} failing, and no failing step was named` : `${count2} failing, the failing step being "${step.name}"`;
 }
 function noChecksReason(number, workflowCount) {
-  const count = workflowCountLine(workflowCount).replace(/\.$/, "");
-  return `the head reports no checks at all; ${count.charAt(0).toLowerCase()}${count.slice(1)};` + ` to merge it anyway, run rafa pr merge ${number} --skip-checks`;
+  const count2 = workflowCountLine(workflowCount).replace(/\.$/, "");
+  return `the head reports no checks at all; ${count2.charAt(0).toLowerCase()}${count2.slice(1)};` + ` to merge it anyway, run rafa pr merge ${number} --skip-checks`;
 }
 function decideClass(input, verdict, conflicting) {
   const { conflictFiles, rows, step } = input;
@@ -13495,8 +13920,8 @@ function isSameHead(stored, head) {
 function shortHead(head) {
   return head.trim().slice(0, HEADLINE_HEAD_LENGTH);
 }
-function checkCount2(count) {
-  return count === 1 ? "1 check" : `${count} checks`;
+function checkCount2(count2) {
+  return count2 === 1 ? "1 check" : `${count2} checks`;
 }
 function storedTime(comment, block) {
   if (comment === null)
@@ -13598,8 +14023,8 @@ function isFreshCandidate(updatedAt, now) {
   const age = ageMs(updatedAt, now);
   return age !== null && age <= TRIAGE_FRESH_WINDOW_MS;
 }
-function plural4(count, singular, many) {
-  return count === 1 ? `1 ${singular}` : `${count} ${many}`;
+function plural4(count2, singular, many) {
+  return count2 === 1 ? `1 ${singular}` : `${count2} ${many}`;
 }
 function describeAge(updatedAt, now) {
   const age = ageMs(updatedAt, now);
@@ -13663,17 +14088,17 @@ function listing(decision, assess, rest, headline, exitCode = 0) {
 `)
   });
 }
-function refusal6(rest, count) {
-  const headline = `${REFUSAL_PREFIX2}: ${plural4(count, "red pull request", "red pull requests")}, ` + "and --resolve acts on one. Run one of:";
+function refusal6(rest, count2) {
+  const headline = `${REFUSAL_PREFIX2}: ${plural4(count2, "red pull request", "red pull requests")}, ` + "and --resolve acts on one. Run one of:";
   return listing("refuse", Object.freeze([]), rest, headline, REFUSE_EXIT_CODE);
 }
-function someReading(fresh, stale, count) {
+function someReading(fresh, stale, count2) {
   const older = stale.length === 0 ? "" : `; ${plural4(stale.length, "older one is", "older ones are")} skipped`;
-  const headline = `${count} red: assessing ${joinNumbers(fresh)}${older}`;
+  const headline = `${count2} red: assessing ${joinNumbers(fresh)}${older}`;
   return listing("some", fresh, stale, headline);
 }
-function listReading(rest, count) {
-  const headline = count > MAX_TRIAGE_CANDIDATES ? `${count} red, more than the ${MAX_TRIAGE_CANDIDATES} a bare rafa pr triage assesses at once. ` + "Run one of:" : `${count} red, none moved in the last ${TRIAGE_FRESH_HOURS} hours. Run one of:`;
+function listReading(rest, count2) {
+  const headline = count2 > MAX_TRIAGE_CANDIDATES ? `${count2} red, more than the ${MAX_TRIAGE_CANDIDATES} a bare rafa pr triage assesses at once. ` + "Run one of:" : `${count2} red, none moved in the last ${TRIAGE_FRESH_HOURS} hours. Run one of:`;
   return listing("list", Object.freeze([]), rest, headline);
 }
 function selectTriagePullRequests(input) {
@@ -13683,24 +14108,24 @@ function selectTriagePullRequests(input) {
     return plain("branch", Object.freeze([current]), `assessing #${current.number}, the pull request open on ${current.headRefName}`);
   }
   const candidates = byNumber(input.candidates);
-  const count = candidates.length;
+  const count2 = candidates.length;
   const lines2 = candidates.map((pull) => skipped(pull, now, resolve13));
-  if (resolve13 && count > 1)
-    return refusal6(lines2, count);
-  if (count === 0) {
+  if (resolve13 && count2 > 1)
+    return refusal6(lines2, count2);
+  if (count2 === 0) {
     return plain("none", Object.freeze([]), "no red pull request to triage, and no pull request on the current branch");
   }
-  if (count === 1) {
+  if (count2 === 1) {
     const only = candidates[0];
     return plain("single", Object.freeze([only]), `1 red: assessing #${only.number}, last moved ${describeAge(only.updatedAt, now)}`);
   }
-  if (count > MAX_TRIAGE_CANDIDATES)
-    return listReading(lines2, count);
+  if (count2 > MAX_TRIAGE_CANDIDATES)
+    return listReading(lines2, count2);
   const fresh = candidates.filter((pull) => isFreshCandidate(pull.updatedAt, now));
   const stale = lines2.filter((one) => !one.fresh);
   if (fresh.length === 0)
-    return listReading(stale, count);
-  return someReading(Object.freeze(fresh), stale, count);
+    return listReading(stale, count2);
+  return someReading(Object.freeze(fresh), stale, count2);
 }
 
 // src/pr/triage/conflict.ts
@@ -13719,10 +14144,10 @@ function parseMessages(records, from) {
     const countRecord = records[at];
     if (countRecord === undefined || countRecord === "")
       break;
-    const count = Number(countRecord);
-    if (!Number.isInteger(count) || count < 0)
+    const count2 = Number(countRecord);
+    if (!Number.isInteger(count2) || count2 < 0)
       break;
-    const typeAt = at + 1 + count;
+    const typeAt = at + 1 + count2;
     const messageAt = typeAt + 1;
     const type = records[typeAt];
     const message = records[messageAt];
@@ -13901,10 +14326,10 @@ function noChecksLines2(reading, assessment) {
     return [];
   const number = reading.detail.number;
   const unchecked = readUnchecked(number, workflowCountOf2(reading) ?? null);
-  const [count = "", warning = ""] = unchecked.warning;
+  const [count2 = "", warning = ""] = unchecked.warning;
   const yes = unchecked.yesMayAnswer ? "--yes may answer it" : "--yes is refused, so a person must answer it";
   return [
-    `${INDENT7}Workflows: ${count}`,
+    `${INDENT7}Workflows: ${count2}`,
     `${INDENT7}Warning: ${warning}`,
     `${INDENT7}To merge it anyway: ${skipChecksCommand(number)} (it asks first; ${yes})`
   ];
@@ -14020,8 +14445,8 @@ function withTaskBudget(plan2, usd) {
 }
 
 // src/pr/plans/load.ts
-import { existsSync as existsSync10, readFileSync as readFileSync22 } from "fs";
-import { dirname as dirname5, join as join27 } from "path";
+import { existsSync as existsSync11, readFileSync as readFileSync20 } from "fs";
+import { dirname as dirname5, join as join26 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 var MODULE_DIR2 = dirname5(fileURLToPath2(import.meta.url));
 var PINNED_PLANS_DIRNAME = "plans";
@@ -14038,8 +14463,8 @@ function hasPinnedPlan(triageClass) {
 function pinnedPlanCandidates(moduleDir, triageClass) {
   const name2 = pinnedPlanFileName(triageClass);
   return [
-    join27(moduleDir, PINNED_PLANS_DIRNAME, name2),
-    join27(moduleDir, name2)
+    join26(moduleDir, PINNED_PLANS_DIRNAME, name2),
+    join26(moduleDir, name2)
   ];
 }
 function readPinnedPlan(triageClass, lookup = {}) {
@@ -14047,11 +14472,11 @@ function readPinnedPlan(triageClass, lookup = {}) {
     throw new Error(`No pinned resolve plan ships for ${triageClass}; ` + `one ships for ${PINNED_PLAN_CLASSES.join(", ")}`);
   }
   const candidates = pinnedPlanCandidates(lookup.moduleDir ?? MODULE_DIR2, triageClass);
-  const found = candidates.find((candidate) => existsSync10(candidate));
+  const found = candidates.find((candidate) => existsSync11(candidate));
   if (found === undefined) {
     throw new Error(`The pinned resolve plan for ${triageClass} is missing: ` + `no file at ${candidates.join(" or ")}`);
   }
-  return readFileSync22(found, "utf8");
+  return readFileSync20(found, "utf8");
 }
 var SLOT_PATTERN = /\{[A-Z][A-Z0-9_]*\}/g;
 var CONFLICT_SENTENCE_SLOT = "CONFLICT_SENTENCE";
@@ -14192,19 +14617,19 @@ function readAttemptRepeat(input) {
 
 // src/commands/pr/resolve-loop.ts
 import { mkdirSync as mkdirSync7, writeFileSync as writeFileSync6 } from "fs";
-import { join as join28 } from "path";
-var RESOLVE_SUBDIR = join28(".rafa", "resolve");
+import { join as join27 } from "path";
+var RESOLVE_SUBDIR = join27(".rafa", "resolve");
 var RUN_PREFIX = "pr-";
 var ATTEMPT_PREFIX = "attempt-";
 var LOOP_WORDS = Object.freeze(["loop", "start"]);
 var CHILD_OUTPUT = "text";
 function resolveRunDir(home, number, attempt3) {
-  return join28(home, RESOLVE_SUBDIR, `${RUN_PREFIX}${number}`, `${ATTEMPT_PREFIX}${attempt3}`);
+  return join27(home, RESOLVE_SUBDIR, `${RUN_PREFIX}${number}`, `${ATTEMPT_PREFIX}${attempt3}`);
 }
 function writeResolvePlan(write) {
   const dir = resolveRunDir(write.home, write.number, write.attempt);
   mkdirSync7(dir, { recursive: true });
-  const path = join28(dir, pinnedPlanFileName(write.triageClass));
+  const path = join27(dir, pinnedPlanFileName(write.triageClass));
   writeFileSync6(path, write.plan, "utf8");
   return path;
 }
@@ -14563,7 +14988,7 @@ async function runAttempts(run, detail, first) {
 }
 
 // src/commands/pr/triage.ts
-var USAGE26 = PR_USAGE.triage;
+var USAGE28 = PR_USAGE.triage;
 var DEFAULT_MAX_ATTEMPTS = 2;
 var DETACHED_HEAD2 = "HEAD";
 var RESOLVED = false;
@@ -14573,11 +14998,11 @@ function readMaxAttempts(flags, usage2) {
   if (value === undefined)
     return DEFAULT_MAX_ATTEMPTS;
   const spelled = typeof value === "boolean" ? "--max-attempts with no value" : `"${value}"`;
-  const count = typeof value === "string" ? Number(value) : Number.NaN;
-  if (!Number.isSafeInteger(count) || count < 1) {
+  const count2 = typeof value === "string" ? Number(value) : Number.NaN;
+  if (!Number.isSafeInteger(count2) || count2 < 1) {
     throw lineRefusal3(`${spelled} is no attempt count, which is a whole number from 1;` + " type the pull request number before the flags", usage2);
   }
-  return count;
+  return count2;
 }
 function readBranchOrNone(pr, warn) {
   const fallback = "so the red pull requests are the candidates";
@@ -14619,7 +15044,7 @@ async function selectTargets(pr, warn, now, resolve13) {
 async function detailOf6(pr, number) {
   const detail = await onProvider(`read pull request #${number}`, () => pr.pulls.get(number));
   if (detail === null) {
-    throw lineRefusal3(`No pull request #${number} in the repository at ${pr.project.root}`, USAGE26);
+    throw lineRefusal3(`No pull request #${number} in the repository at ${pr.project.root}`, USAGE28);
   }
   return detail;
 }
@@ -14714,14 +15139,14 @@ async function assessOne(options) {
 function refuseResolveWithoutComment(wantsResolve, wantsComment) {
   if (!wantsResolve || wantsComment)
     return;
-  throw lineRefusal3("--resolve writes the attempt count into the triage comment, and --no-comment writes none;" + " run one or the other", USAGE26);
+  throw lineRefusal3("--resolve writes the attempt count into the triage comment, and --no-comment writes none;" + " run one or the other", USAGE28);
 }
 async function runTriage(context, seams) {
-  const wantsComment = readBooleanFlag(context.flags, "comment", USAGE26, true);
-  const wantsResolve = readBooleanFlag(context.flags, "resolve", USAGE26, false);
-  const maxAttempts = readMaxAttempts(context.flags, USAGE26);
+  const wantsComment = readBooleanFlag(context.flags, "comment", USAGE28, true);
+  const wantsResolve = readBooleanFlag(context.flags, "resolve", USAGE28, false);
+  const maxAttempts = readMaxAttempts(context.flags, USAGE28);
   refuseResolveWithoutComment(wantsResolve, wantsComment);
-  const asked = readPullArgument(context.args, USAGE26);
+  const asked = readPullArgument(context.args, USAGE28);
   const pr = openPrContext(context, seams);
   const git = (seams.git ?? createGitRunner)(pr.project.root);
   const permissions = (seams.permissions ?? ghPermissionsIn)(pr.project.root);
@@ -14854,7 +15279,7 @@ function createPrTriageCommand(seams = DEFAULT_TRIAGE_SEAMS) {
 var triage_default = createPrTriageCommand();
 
 // src/commands/pr/view.ts
-var USAGE27 = PR_USAGE.view;
+var USAGE29 = PR_USAGE.view;
 function trimmedOrNull3(value) {
   const trimmed = value.trim();
   return trimmed === "" ? null : trimmed;
@@ -14864,9 +15289,9 @@ function renderView(number, url) {
   return url === null ? opened : `${opened}${SEPARATOR}${url}`;
 }
 async function runView2(context, seams) {
-  const asked = readPullArgument(context.args, USAGE27);
+  const asked = readPullArgument(context.args, USAGE29);
   const pr = openPrContext(context, seams);
-  const pick = await pickPullRequest(pr, asked, USAGE27);
+  const pick = await pickPullRequest(pr, asked, USAGE29);
   await onProvider(`open pull request #${pick.number} in the browser`, () => pr.pulls.browse(pick.number));
   const url = trimmedOrNull3(pick.summary?.url ?? "");
   return {
@@ -14921,7 +15346,7 @@ function createPrViewCommand(seams = DEFAULT_PR_SEAMS) {
 var view_default = createPrViewCommand();
 
 // src/commands/pr/wait.ts
-var USAGE28 = PR_USAGE.wait;
+var USAGE30 = PR_USAGE.wait;
 var TIMEOUT_FLAG = "timeout";
 var DEFAULT_WAIT_TIMEOUT_MIN = DEFAULT_CI_TIMEOUT_MIN;
 var MS_PER_MIN = 60000;
@@ -14987,10 +15412,10 @@ function renderWait(reading) {
 `);
 }
 async function runWait(context, seams) {
-  const minutes = readTimeoutMinutes(context.flags, USAGE28);
-  const asked = readPullArgument(context.args, USAGE28);
+  const minutes = readTimeoutMinutes(context.flags, USAGE30);
+  const asked = readPullArgument(context.args, USAGE30);
   const pr = openPrContext(context, seams);
-  const pick = await pickPullRequest(pr, asked, USAGE28);
+  const pick = await pickPullRequest(pr, asked, USAGE30);
   const timeoutMs = minutes * MS_PER_MIN;
   context.output.info(`Waiting for the checks of #${pick.number}, up to ${minutes} min.`);
   const waited = await waitForChecks({
@@ -15069,8 +15494,8 @@ function createPrWaitCommand(seams = DEFAULT_WAIT_SEAMS) {
 var wait_default = createPrWaitCommand();
 
 // src/commands/release/status.ts
-import { existsSync as existsSync11, readdirSync as readdirSync7, readFileSync as readFileSync23 } from "fs";
-import { join as join29 } from "path";
+import { existsSync as existsSync12, readdirSync as readdirSync6, readFileSync as readFileSync21 } from "fs";
+import { join as join28 } from "path";
 var RELEASE_STATUS_USAGE = "rafa release status [--plan=<stub>]";
 var UNREADABLE3 = "?";
 var NOTHING = "none";
@@ -15171,13 +15596,13 @@ function untaggedVersions(released, tags) {
 }
 function textOf2(path) {
   try {
-    return readFileSync23(path, "utf8");
+    return readFileSync21(path, "utf8");
   } catch {
     return null;
   }
 }
 function readVersionFile(root, configured) {
-  const resolved = join29(root, configured);
+  const resolved = join28(root, configured);
   const text = textOf2(resolved);
   if (text === null) {
     return { path: configured, version: null, problem: `the version file could not be read at ${resolved}` };
@@ -15194,7 +15619,7 @@ function readTags(git) {
   return { tags, latest: tags[0] ?? null, problem: null };
 }
 function readUntagged(root, configured, tags) {
-  const resolved = join29(root, configured);
+  const resolved = join28(root, configured);
   const text = textOf2(resolved);
   if (text === null) {
     return {
@@ -15213,11 +15638,11 @@ function readBranch2(git) {
   return result.ok && branch !== "" && branch !== "HEAD" ? branch : null;
 }
 function planStubsUnder(root, planDir) {
-  const resolved = join29(root, planDir);
-  if (!existsSync11(resolved))
+  const resolved = join28(root, planDir);
+  if (!existsSync12(resolved))
     return [];
   try {
-    return planStubsFromFileNames(readdirSync7(resolved));
+    return planStubsFromFileNames(readdirSync6(resolved));
   } catch {
     return [];
   }
@@ -15285,10 +15710,10 @@ function levelPhrase(level) {
 function pendingCell(reading) {
   if (reading.stub === null)
     return `${NOTHING}: no current plan`;
-  const count = reading.notes.length === 1 ? "1 note" : `${reading.notes.length} notes`;
+  const count2 = reading.notes.length === 1 ? "1 note" : `${reading.notes.length} notes`;
   if (reading.notes.length === 0)
     return `${NOTHING} for ${reading.stub}`;
-  return `${count} for ${reading.stub}, ${levelPhrase(reading.level ?? "none")}`;
+  return `${count2} for ${reading.stub}, ${levelPhrase(reading.level ?? "none")}`;
 }
 function pendingLines(reading) {
   return renderNoteLines(groupChangeNotes(reading.notes));
@@ -15415,8 +15840,8 @@ function createReleaseStatusCommand(seams = DEFAULT_RELEASE_SEAMS) {
 var status_default2 = createReleaseStatusCommand();
 
 // src/commands/release/tag.ts
-import { readFileSync as readFileSync24 } from "fs";
-import { join as join30 } from "path";
+import { readFileSync as readFileSync22 } from "fs";
+import { join as join29 } from "path";
 var RELEASE_TAG_USAGE = "rafa release tag";
 var DEFAULT_RELEASE_BRANCH = "main";
 var DEFAULT_REGISTRY = "https://registry.npmjs.org";
@@ -15435,13 +15860,13 @@ function readBranch3(git) {
 }
 function textOf3(path) {
   try {
-    return readFileSync24(path, "utf8");
+    return readFileSync22(path, "utf8");
   } catch {
     return null;
   }
 }
 function readVersion(root, configured) {
-  const resolved = join30(root, configured);
+  const resolved = join29(root, configured);
   const text = textOf3(resolved);
   if (text === null) {
     return {
@@ -15455,7 +15880,7 @@ function readVersion(root, configured) {
   return version2 === null ? { path: configured, text, version: null, problem: `${resolved} declares no version this can read` } : { path: configured, text, version: version2, problem: null };
 }
 function readNewestRelease(root, configured) {
-  const resolved = join30(root, configured);
+  const resolved = join29(root, configured);
   const text = textOf3(resolved);
   if (text === null) {
     return { path: configured, version: null, problem: `the changelog could not be read at ${resolved}` };
@@ -15676,14 +16101,14 @@ var roadmap_default = createRoadmapCommand();
 
 // src/commands/self-update.ts
 var DEFAULT_SELF_UPDATE_SEAMS = Object.freeze({ build: runBuild });
-var USAGE29 = "rafa self-update [--force]";
+var USAGE31 = "rafa self-update [--force]";
 function readForceFlag(value) {
   if (value === undefined || value === false || value === "false")
     return false;
   if (value === true || value === "true")
     return true;
   throw new CommandExit(1, `\u274C --force takes no value, and read "${value}" as one
-Usage: ${USAGE29}`);
+Usage: ${USAGE31}`);
 }
 function projectOf11(context) {
   if (context.project === null)
@@ -15691,7 +16116,7 @@ function projectOf11(context) {
   return context.project;
 }
 async function runSelfUpdate(context, seams) {
-  expectNoArgument(context.args, USAGE29);
+  expectNoArgument(context.args, USAGE31);
   const force = readForceFlag(context.flags["force"]);
   const project = projectOf11(context);
   const info = (line) => context.output.info(line);
@@ -15749,17 +16174,17 @@ function createSelfUpdateCommand(seams = DEFAULT_SELF_UPDATE_SEAMS) {
 var self_update_default = createSelfUpdateCommand();
 
 // src/commands/skill/backfill.ts
-import { statSync as statSync15 } from "fs";
-import { join as join35, resolve as resolve15 } from "path";
+import { statSync as statSync14 } from "fs";
+import { join as join34, resolve as resolve15 } from "path";
 
 // src/backfill/backup.ts
-import { copyFileSync as copyFileSync4, existsSync as existsSync12, mkdirSync as mkdirSync8 } from "fs";
-import { dirname as dirname6, isAbsolute as isAbsolute8, join as join32, relative as relative8, resolve as resolve13, sep as sep5 } from "path";
+import { copyFileSync as copyFileSync4, existsSync as existsSync13, mkdirSync as mkdirSync8 } from "fs";
+import { dirname as dirname6, isAbsolute as isAbsolute8, join as join31, relative as relative8, resolve as resolve13, sep as sep5 } from "path";
 
 // src/backfill/proposal-file.ts
-import { readdirSync as readdirSync8, readFileSync as readFileSync25 } from "fs";
-import { join as join31 } from "path";
-var BACKFILL_PATH = join31(".rafa", "backfill");
+import { readdirSync as readdirSync7, readFileSync as readFileSync23 } from "fs";
+import { join as join30 } from "path";
+var BACKFILL_PATH = join30(".rafa", "backfill");
 var PROPOSAL_FILE_PREFIX = "proposals-";
 var PROPOSAL_FILE_EXTENSION = ".yaml";
 var SHA256_PATTERN = /^[0-9a-f]{64}$/;
@@ -15785,7 +16210,7 @@ var PROPOSAL_FILE_HEADER = [
 ].join(`
 `);
 function proposalPath(dir, batch) {
-  return join31(dir, `${PROPOSAL_FILE_PREFIX}${String(batch).padStart(2, "0")}${PROPOSAL_FILE_EXTENSION}`);
+  return join30(dir, `${PROPOSAL_FILE_PREFIX}${String(batch).padStart(2, "0")}${PROPOSAL_FILE_EXTENSION}`);
 }
 function isProposalFileName(name2) {
   return name2.startsWith(PROPOSAL_FILE_PREFIX) && name2.endsWith(PROPOSAL_FILE_EXTENSION);
@@ -15916,14 +16341,14 @@ function parseProposalFile(text) {
 function readProposalFiles(dir) {
   let names;
   try {
-    names = readdirSync8(dir);
+    names = readdirSync7(dir);
   } catch {
     return [];
   }
   return names.filter((name2) => isProposalFileName(name2)).sort((left, right) => left.localeCompare(right)).map((name2) => {
-    const path = join31(dir, name2);
+    const path = join30(dir, name2);
     try {
-      return { path, result: parseProposalFile(readFileSync25(path, "utf8")) };
+      return { path, result: parseProposalFile(readFileSync23(path, "utf8")) };
     } catch (error) {
       return { path, result: unreadable(`the file cannot be read (${error instanceof Error ? error.message : String(error)})`) };
     }
@@ -15931,10 +16356,10 @@ function readProposalFiles(dir) {
 }
 
 // src/backfill/backup.ts
-var BACKUP_PATH = join32(BACKFILL_PATH, "backup");
+var BACKUP_PATH = join31(BACKFILL_PATH, "backup");
 var BACKUP_KINDS = ["copied", "kept", "tracked", "outside", "missing"];
 function backupDirectory(base) {
-  return join32(base, BACKUP_PATH);
+  return join31(base, BACKUP_PATH);
 }
 function isUnder(root, path) {
   const step = relative8(resolve13(root), resolve13(path));
@@ -15943,7 +16368,7 @@ function isUnder(root, path) {
 function backupPathFor(path, root, backupDir) {
   if (!isUnder(root, path))
     return null;
-  return join32(backupDir, relative8(resolve13(root), resolve13(path)));
+  return join31(backupDir, relative8(resolve13(root), resolve13(path)));
 }
 function backupFile(path, options) {
   if (options.repoRoot !== null && isUnder(options.repoRoot, path)) {
@@ -15952,9 +16377,9 @@ function backupFile(path, options) {
   const backup = backupPathFor(path, options.root, options.backupDir);
   if (backup === null)
     return { path, kind: "outside", backup: null };
-  if (!existsSync12(path))
+  if (!existsSync13(path))
     return { path, kind: "missing", backup: null };
-  if (existsSync12(backup))
+  if (existsSync13(backup))
     return { path, kind: "kept", backup };
   mkdirSync8(dirname6(backup), { recursive: true });
   copyFileSync4(path, backup);
@@ -15979,348 +16404,8 @@ function countBackups(results) {
 }
 
 // src/backfill/derive.ts
-import { readFileSync as readFileSync26, writeFileSync as writeFileSync7 } from "fs";
+import { readFileSync as readFileSync24, writeFileSync as writeFileSync7 } from "fs";
 import { basename as basename8 } from "path";
-
-// src/demote/classify.ts
-var LEARNED_DIRECTORY = "learned";
-var ORIGIN_FIELD = "origin";
-var DEMOTION_VERDICTS = [
-  "observation",
-  "procedure",
-  "unclassified"
-];
-var RULE_VERDICTS = Object.freeze({
-  "no-frontmatter": "unclassified",
-  "learned-without-origin": "unclassified",
-  "no-section-pair": "unclassified",
-  "repeated-section": "procedure",
-  "numbered-procedure": "procedure",
-  "referenced-script": "procedure",
-  "observation-shape": "observation"
-});
-var PROCEDURE_STEP_MINIMUM = 3;
-var PROBLEM_HEADING = /^(?:the\s+)?problem\b/i;
-var SOLUTION_HEADING = /^(?:the\s+)?solution\b/i;
-var WHEN_TO_USE_HEADING = /^when\s+to\s+use\b/i;
-var EXTRACTED_LINE = /^\s*\*\*Extracted:\*\*\s*(\S+)/m;
-var SCRIPT_EXTENSIONS = [
-  ".sh",
-  ".bash",
-  ".zsh",
-  ".py",
-  ".rb",
-  ".pl",
-  ".js",
-  ".mjs",
-  ".cjs",
-  ".ts"
-];
-var FENCE_LINE = /^ {0,3}(?:```|~~~)/;
-var HEADING_LINE = /^ {0,3}(#{1,6})\s+(.*)$/;
-var NUMBERED_ITEM = /^ {0,3}\d+[.)]\s+\S/;
-var CONTINUATION = /^ {2,}\S/;
-var DEMOTED_SOURCE = "demoted";
-var DEMOTED_CONFIDENCE = 0.5;
-var DEMOTED_KIND = "gotcha";
-var DEMOTED_SIGNAL = "silent";
-var DEMOTED_USAGE_COUNT = 1;
-var EVIDENCE_PATH_KEY = "path";
-var EVIDENCE_EXTRACTED_KEY = "extracted";
-var DEFAULT_DOMAIN = "general-best-practices";
-var DOMAIN_MARKERS = [
-  ["security", /\b(?:security|secret|credential|token|auth|csrf|xss|injection)\b/i],
-  ["testing", /\b(?:test|tests|testing|spec|assertion|assert|mock|stub|fixture|coverage)\b/i],
-  ["git", /\b(?:git|commit|rebase|worktree|branch|merge|checkout)\b/i],
-  ["debugging", /\b(?:debug|debugging|traceback|reproduce|bisect)\b/i],
-  ["code-style", /\b(?:lint|eslint|format|formatter|prettier|naming)\b/i],
-  ["workflow", /\b(?:workflow|pipeline|release|deploy|build|ci|loop|dispatch)\b/i]
-];
-var ERROR_WORDS = /\b(?:error|exception|traceback|panic|fatal|refused|denied|not found|no such|cannot|could not|failed|failure|unexpected|undefined)\b/i;
-var SENTENCE_ABBREVIATIONS = ["e.g", "i.e", "vs", "cf", "etc"];
-function isFilled(value) {
-  return typeof value === "string" && value.trim() !== "";
-}
-function bodyLines2(body) {
-  return body.split(`
-`).map((line) => line.replace(/\r$/, ""));
-}
-function bodySections(body) {
-  const lines2 = bodyLines2(body);
-  const headings = [];
-  let fenced = false;
-  lines2.forEach((line, index) => {
-    if (FENCE_LINE.test(line)) {
-      fenced = !fenced;
-      return;
-    }
-    if (fenced)
-      return;
-    const match = HEADING_LINE.exec(line);
-    if (match === null)
-      return;
-    const [, hashes = "", title = ""] = match;
-    headings.push({
-      level: hashes.length,
-      title: title.replace(/\s+#+\s*$/, "").trim(),
-      index
-    });
-  });
-  return headings.map((heading, position) => {
-    const next = headings.slice(position + 1).find((other) => other.level <= heading.level);
-    const end = next === undefined ? lines2.length : next.index;
-    return {
-      level: heading.level,
-      title: heading.title,
-      line: heading.index + 1,
-      text: lines2.slice(heading.index + 1, end).join(`
-`).trim()
-    };
-  });
-}
-function numberedRuns(body) {
-  const runs = [];
-  let fenced = false;
-  let steps = 0;
-  let line = 0;
-  const close = () => {
-    if (steps > 0)
-      runs.push({ steps, line });
-    steps = 0;
-  };
-  bodyLines2(body).forEach((text, index) => {
-    if (FENCE_LINE.test(text)) {
-      fenced = !fenced;
-      return;
-    }
-    if (fenced || text.trim() === "")
-      return;
-    if (NUMBERED_ITEM.test(text)) {
-      if (steps === 0)
-        line = index + 1;
-      steps += 1;
-      return;
-    }
-    if (CONTINUATION.test(text))
-      return;
-    close();
-  });
-  close();
-  return runs;
-}
-function isScriptPath(token) {
-  if (token.startsWith("/"))
-    return false;
-  const last = token.split("/").at(-1) ?? "";
-  return SCRIPT_EXTENSIONS.some((extension) => last.endsWith(extension));
-}
-function referencedScript(body, entries = []) {
-  const owned = new Set(entries.map((entry) => entry.replace(/^\.\//, "")));
-  for (const reference of collectReferences(body)) {
-    if (reference.kind !== "path")
-      continue;
-    const token = reference.text.replace(/^\.\//, "");
-    const [first = ""] = token.split("/");
-    if (owned.has(first) && isScriptPath(token))
-      return reference;
-  }
-  return null;
-}
-function isLearnedFile(path) {
-  const [first] = path.split(/[\\/]/);
-  return first === LEARNED_DIRECTORY;
-}
-function decide2(rule, reason) {
-  return { verdict: RULE_VERDICTS[rule], rule, reason };
-}
-function pairReason(problems, solutions) {
-  if (problems === 0 && solutions === 0) {
-    return "the body carries no Problem section and no Solution section";
-  }
-  return problems === 0 ? "the body carries a Solution section and no Problem section, so there is no pair" : "the body carries a Problem section and no Solution section, so there is no pair";
-}
-function repeatReason(problems, solutions) {
-  const counted3 = problems > 1 ? `${problems} Problem sections` : `${solutions} Solution sections`;
-  return `the body carries ${counted3}, and an observation carries exactly one of each`;
-}
-function classifySkill(source) {
-  const document = readFrontmatterDocument(source.text);
-  if (document === null) {
-    return decide2("no-frontmatter", "the file opens with no --- block holding a YAML mapping");
-  }
-  if (isLearnedFile(source.path) && !isFilled(document.data[ORIGIN_FIELD])) {
-    return decide2("learned-without-origin", `a ${LEARNED_DIRECTORY}/ file whose frontmatter carries no ${ORIGIN_FIELD}`);
-  }
-  const sections = bodySections(document.body);
-  const problems = sections.filter((section) => PROBLEM_HEADING.test(section.title));
-  const solutions = sections.filter((section) => SOLUTION_HEADING.test(section.title));
-  if (problems.length === 0 || solutions.length === 0) {
-    return decide2("no-section-pair", pairReason(problems.length, solutions.length));
-  }
-  if (problems.length > 1 || solutions.length > 1) {
-    return decide2("repeated-section", repeatReason(problems.length, solutions.length));
-  }
-  const run = numberedRuns(document.body).find((each) => each.steps >= PROCEDURE_STEP_MINIMUM);
-  if (run !== undefined) {
-    return decide2("numbered-procedure", `a numbered procedure of ${run.steps} consecutive steps at line ${run.line}`);
-  }
-  const script = referencedScript(document.body, source.entries ?? []);
-  if (script !== null) {
-    return decide2("referenced-script", `the body names the script ${script.text} at line ${script.line}`);
-  }
-  return decide2("observation-shape", "one Problem section and one Solution section, no numbered procedure of " + `${PROCEDURE_STEP_MINIMUM} or more consecutive steps, and no referenced script`);
-}
-function firstSection(sections, heading) {
-  return sections.find((section) => heading.test(section.title));
-}
-function withoutFences(text) {
-  const kept = [];
-  let fenced = false;
-  for (const line of bodyLines2(text)) {
-    if (FENCE_LINE.test(line)) {
-      fenced = !fenced;
-      continue;
-    }
-    if (!fenced)
-      kept.push(line);
-  }
-  return kept;
-}
-function stripMarkers(line) {
-  return line.replace(/^\s*(?:[-*+]|\d+[.)]|>)\s+/, "").replace(/\*\*|__|\*|`/g, "").trim();
-}
-function isAbbreviation(text, index) {
-  const before = text.slice(0, index);
-  return SENTENCE_ABBREVIATIONS.some((word) => before.toLowerCase().endsWith(word));
-}
-function firstSentence(text) {
-  const lines2 = withoutFences(text);
-  const start2 = lines2.findIndex((line) => line.trim() !== "");
-  if (start2 === -1)
-    return "";
-  const collected = [lines2[start2] ?? ""];
-  for (const line of lines2.slice(start2 + 1)) {
-    if (line.trim() === "" || /^\s*(?:[-*+]|\d+[.)]|#)/.test(line))
-      break;
-    collected.push(line);
-  }
-  const joined2 = stripMarkers(collected.join(" ")).replace(/\s+/g, " ");
-  for (let index = 0;index < joined2.length; index += 1) {
-    if (!".!?".includes(joined2[index] ?? ""))
-      continue;
-    if (isAbbreviation(joined2, index))
-      continue;
-    const next = joined2[index + 1];
-    if (next === undefined)
-      return joined2.slice(0, index + 1).trim();
-    if (next === " ")
-      return joined2.slice(0, index + 1).trim();
-  }
-  return joined2.trim();
-}
-function demotedTrigger(sections, data) {
-  const whenToUse = firstSection(sections, WHEN_TO_USE_HEADING);
-  const fromSection = whenToUse === undefined ? "" : firstSentence(whenToUse.text);
-  if (fromSection !== "")
-    return fromSection;
-  const description = data["description"];
-  if (isFilled(description))
-    return description.trim();
-  const problem2 = firstSection(sections, PROBLEM_HEADING);
-  return problem2 === undefined ? "" : firstSentence(problem2.text);
-}
-function extractedDate(body) {
-  const match = EXTRACTED_LINE.exec(body);
-  return match?.[1] ?? null;
-}
-function errorString(body) {
-  let fenced = false;
-  for (const line of bodyLines2(body)) {
-    if (FENCE_LINE.test(line)) {
-      fenced = !fenced;
-      continue;
-    }
-    if (fenced) {
-      if (ERROR_WORDS.test(line))
-        return line.trim();
-      continue;
-    }
-    for (const span of line.matchAll(/`([^`\n]+)`/g)) {
-      const inner = span[1] ?? "";
-      if (ERROR_WORDS.test(inner))
-        return inner.trim();
-    }
-  }
-  return null;
-}
-function inferDomain(name2, body) {
-  for (const [domain, pattern] of DOMAIN_MARKERS) {
-    if (pattern.test(name2))
-      return domain;
-  }
-  for (const [domain, pattern] of DOMAIN_MARKERS) {
-    if (pattern.test(body))
-      return domain;
-  }
-  return DEFAULT_DOMAIN;
-}
-function slugifyId(value) {
-  return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
-}
-function uniqueInstinctId(base, taken) {
-  const used = new Set(taken);
-  if (!used.has(base))
-    return base;
-  let suffix = 2;
-  while (used.has(`${base}-${suffix}`))
-    suffix += 1;
-  return `${base}-${suffix}`;
-}
-function sourceName(source, data) {
-  const declared = data["name"];
-  if (isFilled(declared))
-    return slugifyId(declared);
-  const segments = source.path.split(/[\\/]/).filter((segment) => segment !== "");
-  const last = segments.at(-1) ?? "";
-  const stem = last.toUpperCase() === "SKILL.MD" ? segments.at(-2) ?? "" : last.replace(/\.md$/i, "");
-  return slugifyId(stem);
-}
-function convertToInstinct(source, options) {
-  const document = readFrontmatterDocument(source.text);
-  const data = document?.data ?? {};
-  const body = document?.body ?? source.text;
-  const sections = bodySections(body);
-  const action = firstSection(sections, SOLUTION_HEADING)?.text ?? "";
-  const named3 = errorString(body);
-  const name2 = sourceName(source, data);
-  const draft = {
-    id: uniqueInstinctId(name2, options.takenIds ?? []),
-    trigger: demotedTrigger(sections, data),
-    kind: DEMOTED_KIND,
-    domain: inferDomain(name2, body),
-    confidence: DEMOTED_CONFIDENCE,
-    usageCount: DEMOTED_USAGE_COUNT,
-    artifact: null,
-    signal: named3 === null ? DEMOTED_SIGNAL : "loud",
-    scope: options.scope,
-    projectId: options.projectId ?? null,
-    source: DEMOTED_SOURCE,
-    evidence: [{
-      [EVIDENCE_PATH_KEY]: source.path,
-      [EVIDENCE_EXTRACTED_KEY]: extractedDate(body) ?? options.mtime
-    }],
-    createdAt: options.now,
-    updatedAt: options.now,
-    action,
-    cause: firstSection(sections, PROBLEM_HEADING)?.text ?? "",
-    actionHash: actionHash(action)
-  };
-  const text = writeInstinct(draft);
-  const parsed = parseInstinct(text);
-  return parsed.instinct === null ? { instinct: null, text: null, issues: parsed.issues } : { instinct: parsed.instinct, text, issues: parsed.issues };
-}
-
-// src/backfill/derive.ts
 var DERIVED_FIELDS = ["stack", "paths", "when_to_use"];
 function renderWhenToUse(trigger, prevents) {
   return `${sentenceEnded(trigger)} Prevents: ${prevents}`;
@@ -16445,7 +16530,7 @@ function planFile(entry, options) {
   }
   let original;
   try {
-    original = readFileSync26(entry.path, "utf8");
+    original = readFileSync24(entry.path, "utf8");
   } catch (error) {
     return inert(entry, "skipped", `the file cannot be read (${error instanceof Error ? error.message : String(error)})`);
   }
@@ -16489,7 +16574,7 @@ function planDerivation(root, options) {
 function applyFile(action, options) {
   if (action.text === null || action.original === null)
     return action;
-  const current = readFileSync26(action.path, "utf8");
+  const current = readFileSync24(action.path, "utf8");
   if (current !== action.original) {
     return {
       ...action,
@@ -16520,7 +16605,7 @@ function applyDerivation(plan2, options) {
 }
 
 // src/backfill/proposal-batch.ts
-import { readFileSync as readFileSync27 } from "fs";
+import { readFileSync as readFileSync25 } from "fs";
 import { relative as relative9 } from "path";
 
 // src/demote/report.ts
@@ -16819,7 +16904,7 @@ function readCandidate(root, entry) {
     return null;
   let text;
   try {
-    text = readFileSync27(entry.path, "utf8");
+    text = readFileSync25(entry.path, "utf8");
   } catch {
     return null;
   }
@@ -16925,8 +17010,8 @@ function parseSessionAnswer(stdout) {
 }
 
 // src/backfill/propose.ts
-import { mkdirSync as mkdirSync9, readFileSync as readFileSync28, writeFileSync as writeFileSync8 } from "fs";
-import { join as join33, resolve as resolve14 } from "path";
+import { mkdirSync as mkdirSync9, readFileSync as readFileSync26, writeFileSync as writeFileSync8 } from "fs";
+import { join as join32, resolve as resolve14 } from "path";
 var PROPOSAL_ACTION_KINDS = [
   "applied",
   "unchanged",
@@ -16947,47 +17032,47 @@ function unanswered(candidate, note) {
     note
   };
 }
-function answerProblem(needs, answer) {
+function answerProblem(needs, answer2) {
   if (needs.includes("prevents")) {
-    if (answer.prevents === null)
+    if (answer2.prevents === null)
       return "the answer carries no prevents";
-    if (answer.signal === null)
+    if (answer2.signal === null)
       return "the answer carries prevents with no signal";
-    if (!isSkillSignal(answer.signal)) {
-      return `the answer signal ${answer.signal} is neither ${SKILL_SIGNALS.join(" nor ")}`;
+    if (!isSkillSignal(answer2.signal)) {
+      return `the answer signal ${answer2.signal} is neither ${SKILL_SIGNALS.join(" nor ")}`;
     }
   }
-  if (needs.includes("trigger") && answer.trigger === null) {
+  if (needs.includes("trigger") && answer2.trigger === null) {
     return "the answer carries no trigger sentence";
   }
   if (needs.includes("description")) {
-    if (answer.description === null)
+    if (answer2.description === null)
       return "the answer carries no description";
-    if (countCharacters(answer.description) >= DESCRIPTION_LIMIT) {
-      return `the answer description is ${countCharacters(answer.description)} characters, at or over the ${DESCRIPTION_LIMIT} cap`;
+    if (countCharacters(answer2.description) >= DESCRIPTION_LIMIT) {
+      return `the answer description is ${countCharacters(answer2.description)} characters, at or over the ${DESCRIPTION_LIMIT} cap`;
     }
   }
   return null;
 }
-function proposalRow(candidate, answer) {
-  if (answer === undefined) {
+function proposalRow(candidate, answer2) {
+  if (answer2 === undefined) {
     return unanswered(candidate, "the session answered nothing about this file");
   }
-  const problem2 = answerProblem(candidate.needs, answer);
+  const problem2 = answerProblem(candidate.needs, answer2);
   if (problem2 !== null)
     return unanswered(candidate, problem2);
   const wants = (need) => candidate.needs.includes(need);
-  const signal = answer.signal;
+  const signal = answer2.signal;
   return {
     path: candidate.relative,
     name: candidate.name,
     hash: candidate.hash,
     needs: candidate.needs,
     status: ANSWERED_ROW,
-    prevents: wants("prevents") ? answer.prevents : null,
+    prevents: wants("prevents") ? answer2.prevents : null,
     signal: wants("prevents") && signal !== null && isSkillSignal(signal) ? signal : null,
-    trigger: wants("trigger") ? answer.trigger : null,
-    description: wants("description") ? answer.description : null,
+    trigger: wants("trigger") ? answer2.trigger : null,
+    description: wants("description") ? answer2.description : null,
     note: null
   };
 }
@@ -17075,7 +17160,7 @@ function writeRow(path, row2, original, options) {
   };
 }
 function applyRow(root, row2, options) {
-  const path = join33(root, ...row2.path.split("/"));
+  const path = join32(root, ...row2.path.split("/"));
   if (row2.status === UNANSWERED_ROW) {
     return inert2(path, row2, "unanswered", row2.note ?? "the row carries no answer");
   }
@@ -17084,7 +17169,7 @@ function applyRow(root, row2, options) {
   }
   let original;
   try {
-    original = readFileSync28(path, "utf8");
+    original = readFileSync26(path, "utf8");
   } catch {
     return inert2(path, row2, "refused", "the file the row names is gone");
   }
@@ -17112,7 +17197,7 @@ function applyProposals(files, root, options) {
   for (const file of files) {
     const refusal7 = fileRefusal(file, root);
     for (const row2 of file.rows) {
-      const action = refusal7 === null ? applyRow(root, row2, options) : inert2(join33(root, ...row2.path.split("/")), row2, "refused", refusal7);
+      const action = refusal7 === null ? applyRow(root, row2, options) : inert2(join32(root, ...row2.path.split("/")), row2, "refused", refusal7);
       actions.push(action);
       if (row2.trigger !== null && action.kind !== "refused" && action.kind !== "unanswered") {
         triggers[row2.name] = row2.trigger;
@@ -17123,13 +17208,13 @@ function applyProposals(files, root, options) {
 }
 
 // src/demote/select.ts
-import { readdirSync as readdirSync9, readFileSync as readFileSync29, realpathSync as realpathSync6, statSync as statSync14 } from "fs";
-import { basename as basename9, dirname as dirname7, join as join34 } from "path";
+import { readdirSync as readdirSync8, readFileSync as readFileSync27, realpathSync as realpathSync6, statSync as statSync13 } from "fs";
+import { basename as basename9, dirname as dirname7, join as join33 } from "path";
 var SKILLS_DIRECTORY = "skills";
 var CLAUDE_DIRECTORY = ".claude";
 var AUTO_EXTRACTED_ORIGIN = "auto-extracted";
-var DEMOTED_PATH = join34(".rafa", "demoted");
-var INSTINCTS_PATH = join34(".rafa", "instincts");
+var DEMOTED_PATH = join33(".rafa", "demoted");
+var INSTINCTS_PATH = join33(".rafa", "instincts");
 var REPORT_FILE = "report.md";
 function realOrSelf(path) {
   try {
@@ -17152,19 +17237,19 @@ function resolveDemotionScope(dir, home) {
   if (basename9(claude) !== CLAUDE_DIRECTORY)
     return null;
   const base = dirname7(claude);
-  const demotedDir = join34(base, DEMOTED_PATH);
+  const demotedDir = join33(base, DEMOTED_PATH);
   return {
     scope: samePath(base, home) ? "user" : "project",
     dir,
     base,
     demotedDir,
-    instinctsDir: join34(base, INSTINCTS_PATH),
-    reportPath: join34(demotedDir, REPORT_FILE)
+    instinctsDir: join33(base, INSTINCTS_PATH),
+    reportPath: join33(demotedDir, REPORT_FILE)
   };
 }
 function entryKind(path) {
   try {
-    const stats = statSync14(path);
+    const stats = statSync13(path);
     if (stats.isFile())
       return "file";
     if (stats.isDirectory())
@@ -17176,7 +17261,7 @@ function entryKind(path) {
 }
 function visibleNames(dir) {
   try {
-    return readdirSync9(dir).filter((name2) => !name2.startsWith(".")).sort((left, right) => left.localeCompare(right));
+    return readdirSync8(dir).filter((name2) => !name2.startsWith(".")).sort((left, right) => left.localeCompare(right));
   } catch {
     return [];
   }
@@ -17185,8 +17270,8 @@ function readSelected(absolute, path, entries) {
   let text;
   let mtime;
   try {
-    text = readFileSync29(absolute, "utf8");
-    mtime = statSync14(absolute).mtime.toISOString();
+    text = readFileSync27(absolute, "utf8");
+    mtime = statSync13(absolute).mtime.toISOString();
   } catch {
     return null;
   }
@@ -17201,14 +17286,14 @@ function selectsLearned(text, scope) {
   return origin === AUTO_EXTRACTED_ORIGIN;
 }
 function selectLearned(scope) {
-  const dir = join34(scope.dir, LEARNED_DIRECTORY);
+  const dir = join33(scope.dir, LEARNED_DIRECTORY);
   if (entryKind(dir) !== "directory")
     return [];
   const selected = [];
   for (const name2 of visibleNames(dir)) {
     if (!name2.endsWith(MARKDOWN_EXTENSION) || name2 === MARKDOWN_EXTENSION)
       continue;
-    const absolute = join34(dir, name2);
+    const absolute = join33(dir, name2);
     if (entryKind(absolute) !== "file")
       continue;
     const file = readSelected(absolute, `${LEARNED_DIRECTORY}/${name2}`, undefined);
@@ -17222,10 +17307,10 @@ function selectSkillFiles(scope) {
   for (const name2 of visibleNames(scope.dir)) {
     if (name2 === LEARNED_DIRECTORY)
       continue;
-    const skillDir = join34(scope.dir, name2);
+    const skillDir = join33(scope.dir, name2);
     if (entryKind(skillDir) !== "directory")
       continue;
-    const absolute = join34(skillDir, SKILL_FILE);
+    const absolute = join33(skillDir, SKILL_FILE);
     if (entryKind(absolute) !== "file")
       continue;
     const file = readSelected(absolute, `${name2}/${SKILL_FILE}`, visibleNames(skillDir));
@@ -17286,7 +17371,7 @@ Usage: ${BACKFILL_USAGE}`);
 }
 function isDirectory3(path) {
   try {
-    return statSync15(path).isDirectory();
+    return statSync14(path).isDirectory();
   } catch {
     return false;
   }
@@ -17410,7 +17495,7 @@ function reviewedProposals(dir) {
   return read2.flatMap((entry) => entry.result.file === null ? [] : [entry.result.file]);
 }
 function rowPaths(files, root) {
-  return files.flatMap((file) => file.status !== REVIEWED_FILE ? [] : file.rows.filter((row2) => row2.status === ANSWERED_ROW).map((row2) => join35(root, ...row2.path.split("/"))));
+  return files.flatMap((file) => file.status !== REVIEWED_FILE ? [] : file.rows.filter((row2) => row2.status === ANSWERED_ROW).map((row2) => join34(root, ...row2.path.split("/"))));
 }
 function runApply(context, scope, backfillDir, projectRoot3) {
   const options = checkOptions(context, projectRoot3);
@@ -17456,7 +17541,7 @@ async function runBackfill(context, seams) {
   const dir = readBackfillDirectory(context.args, seams.cwd);
   const projectRoot3 = readConsumerRoot(context.flags["project"], seams.cwd);
   const scope = backfillScopeOf(dir, projectOf12(context).home);
-  const backfillDir = join35(scope.base, BACKFILL_PATH);
+  const backfillDir = join34(scope.base, BACKFILL_PATH);
   if (mode === "propose") {
     await runPropose(context, scope, backfillDir, seams);
     return;
@@ -17570,13 +17655,13 @@ function createSkillCheckCommand(seams = DEFAULT_CHECK_SEAMS) {
 var check_default3 = createSkillCheckCommand();
 
 // src/commands/skill/demote.ts
-import { existsSync as existsSync14, mkdirSync as mkdirSync11, readFileSync as readFileSync31, statSync as statSync17, writeFileSync as writeFileSync10 } from "fs";
+import { existsSync as existsSync15, mkdirSync as mkdirSync11, readFileSync as readFileSync29, statSync as statSync16, writeFileSync as writeFileSync10 } from "fs";
 import { dirname as dirname9, resolve as resolve16 } from "path";
 
 // src/demote/apply.ts
-import { copyFileSync as copyFileSync5, existsSync as existsSync13, mkdirSync as mkdirSync10, mkdtempSync as mkdtempSync2, readdirSync as readdirSync10, readFileSync as readFileSync30, renameSync as renameSync2, rmSync as rmSync3, statSync as statSync16, unlinkSync, writeFileSync as writeFileSync9 } from "fs";
+import { copyFileSync as copyFileSync5, existsSync as existsSync14, mkdirSync as mkdirSync10, mkdtempSync as mkdtempSync2, readdirSync as readdirSync9, readFileSync as readFileSync28, renameSync as renameSync3, rmSync as rmSync4, statSync as statSync15, unlinkSync, writeFileSync as writeFileSync9 } from "fs";
 import { tmpdir as tmpdir2 } from "os";
-import { dirname as dirname8, join as join36 } from "path";
+import { dirname as dirname8, join as join35 } from "path";
 var DEMOTION_ACTION_KINDS = [
   "demoted",
   "kept",
@@ -17597,18 +17682,18 @@ function learnedSkillName(path) {
   return base.slice(0, -MARKDOWN_EXTENSION.length);
 }
 function sourcePath(scope, path) {
-  return join36(scope.dir, ...path.split("/"));
+  return join35(scope.dir, ...path.split("/"));
 }
 function demotedPath(scope, path) {
-  return join36(scope.demotedDir, ...path.split("/"));
+  return join35(scope.demotedDir, ...path.split("/"));
 }
 function promotedPath(scope, path) {
-  return join36(scope.dir, learnedSkillName(path), SKILL_FILE);
+  return join35(scope.dir, learnedSkillName(path), SKILL_FILE);
 }
 function takenInstinctIds(dir) {
   let names;
   try {
-    names = readdirSync10(dir);
+    names = readdirSync9(dir);
   } catch {
     return [];
   }
@@ -17616,7 +17701,7 @@ function takenInstinctIds(dir) {
 }
 function readText4(path) {
   try {
-    return statSync16(path).isFile() ? readFileSync30(path, "utf8") : null;
+    return statSync15(path).isFile() ? readFileSync28(path, "utf8") : null;
   } catch {
     return null;
   }
@@ -17644,7 +17729,7 @@ function planKept(scope, row2, file) {
     return inert3(row2.path, "procedure", "kept", "procedure-shaped: left where it is, for the backfill");
   }
   const to = promotedPath(scope, row2.path);
-  if (existsSync13(to) || existsSync13(dirname8(to))) {
+  if (existsSync14(to) || existsSync14(dirname8(to))) {
     return inert3(row2.path, "procedure", "refused", `kept as a skill, but ${to} is already there`);
   }
   return {
@@ -17658,7 +17743,7 @@ function planKept(scope, row2, file) {
   };
 }
 function checkCandidate(dir, id, text, pathDirs) {
-  const path = join36(dir, `${id}${MARKDOWN_EXTENSION}`);
+  const path = join35(dir, `${id}${MARKDOWN_EXTENSION}`);
   writeFileSync9(path, text, "utf8");
   const report3 = checkFile(path, "instinct", { projectRoot: null, pathDirs });
   return failureLines2(report3.issues);
@@ -17679,11 +17764,11 @@ function planDemoted(scope, row2, file, context) {
   if (failures.length > 0) {
     return inert3(row2.path, "observation", "refused", `the record ${id} fails the checker \u2014 ${failures.join("; ")}`);
   }
-  const destination = join36(scope.instinctsDir, `${id}${MARKDOWN_EXTENSION}`);
+  const destination = join35(scope.instinctsDir, `${id}${MARKDOWN_EXTENSION}`);
   const kept = demotedPath(scope, row2.path);
-  if (existsSync13(destination))
+  if (existsSync14(destination))
     return inert3(row2.path, "observation", "refused", `${destination} is already there`);
-  if (existsSync13(kept))
+  if (existsSync14(kept))
     return inert3(row2.path, "observation", "refused", `${kept} is already there`);
   context.taken.push(id);
   return {
@@ -17715,7 +17800,7 @@ function planRow(scope, row2, context) {
     entries: undefined,
     absolute,
     hash,
-    mtime: statSync16(absolute).mtime.toISOString()
+    mtime: statSync15(absolute).mtime.toISOString()
   };
   return verdict === "procedure" ? planKept(scope, row2, file) : planDemoted(scope, row2, file, context);
 }
@@ -17726,19 +17811,19 @@ function countActions(actions) {
   return counts;
 }
 function planDemotion(report3, scope, seams = DEFAULT_APPLY_SEAMS) {
-  const temp = mkdtempSync2(join36(tmpdir2(), "rafa-demote-"));
+  const temp = mkdtempSync2(join35(tmpdir2(), "rafa-demote-"));
   const taken = [...takenInstinctIds(scope.instinctsDir)];
   try {
     const actions = report3.rows.map((row2) => planRow(scope, row2, { temp, taken, seams }));
     return { scope, actions, counts: countActions(actions) };
   } finally {
-    rmSync3(temp, { recursive: true, force: true });
+    rmSync4(temp, { recursive: true, force: true });
   }
 }
 function moveFile(move3) {
   mkdirSync10(dirname8(move3.to), { recursive: true });
   try {
-    renameSync2(move3.from, move3.to);
+    renameSync3(move3.from, move3.to);
   } catch {
     copyFileSync5(move3.from, move3.to);
     unlinkSync(move3.from);
@@ -17817,7 +17902,7 @@ Usage: ${DEMOTE_USAGE}`);
 }
 function isDirectory4(path) {
   try {
-    return statSync17(path).isDirectory();
+    return statSync16(path).isDirectory();
   } catch {
     return false;
   }
@@ -17845,9 +17930,9 @@ function verdictLine(report3) {
   return `${String(report3.rows.length)} file(s): ${parts.join(", ")}`;
 }
 function previousReport(path, context) {
-  if (!existsSync14(path))
+  if (!existsSync15(path))
     return null;
-  const parsed = parseDemotionReport(readFileSync31(path, "utf8"));
+  const parsed = parseDemotionReport(readFileSync29(path, "utf8"));
   if (parsed.report !== null)
     return parsed.report;
   context.output.warn(`the report already at ${path} does not parse, so no override in it is carried forward:` + ` ${parsed.issues.map((issue2) => `line ${String(issue2.line)} ${issue2.code}`).join(", ")}`);
@@ -17880,10 +17965,10 @@ function runWrite(context, scope) {
     context.output.info(line);
 }
 function reviewedReport(scope) {
-  if (!existsSync14(scope.reportPath)) {
+  if (!existsSync15(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(readFileSync31(scope.reportPath, "utf8"));
+  const parsed = parseDemotionReport(readFileSync29(scope.reportPath, "utf8"));
   if (parsed.report === null) {
     const lines2 = parsed.issues.map((issue2) => `   line ${String(issue2.line)} ${issue2.code}: ${issue2.message}`);
     throw new CommandExit(1, [`\u274C ${scope.reportPath} does not parse:`, ...lines2].join(`
@@ -17989,8 +18074,8 @@ var demote_default = createSkillDemoteCommand();
 
 // src/commands/skill/show.ts
 var DEFAULT_SKILL_SHOW_SEAMS = DEFAULT_SKILL_LIST_SEAMS;
-var COMMAND_NAME5 = "rafa skill show";
-var USAGE30 = "rafa skill show <name> [--full]";
+var COMMAND_NAME6 = "rafa skill show";
+var USAGE32 = "rafa skill show <name> [--full]";
 function unknownSkillMessage(name2, inventory) {
   const agent = findShown(inventory.records, "agent", name2);
   const hint = agent === null ? [] : [`An agent is named "${name2}" (${agent.source}): rafa agent show ${name2}`];
@@ -17998,7 +18083,7 @@ function unknownSkillMessage(name2, inventory) {
     `\u274C No skill is named "${name2}".`,
     ...hint,
     "Run `rafa skill list` to see every skill and where it comes from.",
-    `Usage: ${USAGE30}`
+    `Usage: ${USAGE32}`
   ].join(`
 `);
 }
@@ -18014,10 +18099,10 @@ function projectOf14(context) {
   return context.project;
 }
 async function runShow3(context, seams) {
-  const full = readSwitch("full", context.flags["full"], `Type the name ahead of it: ${USAGE30}`);
-  const name2 = expectOneArgument(context.args, USAGE30);
+  const full = readSwitch("full", context.flags["full"], `Type the name ahead of it: ${USAGE32}`);
+  const name2 = expectOneArgument(context.args, USAGE32);
   const project = projectOf14(context);
-  const { inventory, settingSources } = await projectInventory(project, context, seams, COMMAND_NAME5);
+  const { inventory, settingSources } = await projectInventory(project, context, seams, COMMAND_NAME6);
   const warnings = warningLines(inventory);
   for (const warning of warnings)
     context.output.warn(warning);
@@ -18095,8 +18180,8 @@ var VERDICT_WORDS = Object.freeze({
   pending: "checks pending",
   none: "no checks"
 });
-function counted3(count, noun, plural5 = `${noun}s`) {
-  return `${String(count)} ${count === 1 ? noun : plural5}`;
+function counted3(count2, noun, plural5 = `${noun}s`) {
+  return `${String(count2)} ${count2 === 1 ? noun : plural5}`;
 }
 function info(text) {
   return { level: "info", text };
@@ -18344,7 +18429,7 @@ async function readStatusSections(input, seams = {}) {
 }
 
 // src/commands/status.ts
-var COMMAND_NAME6 = "rafa status";
+var COMMAND_NAME7 = "rafa status";
 var STATUS_USAGE = "rafa status";
 var STATUS_ARGUMENT_EXIT = 2;
 var DEFAULT_STATUS_SEAMS = Object.freeze({});
@@ -18356,13 +18441,13 @@ function projectOf15(context) {
 function expectNoWord(args) {
   if (args.length === 0)
     return;
-  throw new CommandExit(STATUS_ARGUMENT_EXIT, `\u274C ${COMMAND_NAME6}: expected no argument, got ${String(args.length)}: ${args.join(" ")}
+  throw new CommandExit(STATUS_ARGUMENT_EXIT, `\u274C ${COMMAND_NAME7}: expected no argument, got ${String(args.length)}: ${args.join(" ")}
 Usage: ${STATUS_USAGE}`);
 }
 async function runStatus2(context, seams) {
   expectNoWord(context.args);
   const project = projectOf15(context);
-  const config = resolveProjectConfig(project, COMMAND_NAME6, (message) => {
+  const config = resolveProjectConfig(project, COMMAND_NAME7, (message) => {
     context.output.warn(message);
   });
   const read3 = seams.read ?? ((input) => readStatusSections(input));
@@ -18428,11 +18513,11 @@ var CORE_SUBJECTS = Object.freeze([
   { name: "loop", summary: "start a plan; stop, pause, resume, show and list its sessions" },
   { name: "issue", summary: "the tracker: list, show, create, comment on and move issues; mark one ready, unblock it and check its references" },
   { name: "pr", summary: "the pull request of a branch: one line, in full or in the browser; list, wait on, merge and triage them" },
-  { name: "effort", summary: "collect session and commit rows; report per plan" },
+  { name: "effort", summary: "collect session and commit rows; report per plan; repair a store a newer rafa migrated" },
   { name: "module", summary: "list the configured modules; run an action a module provides" },
   { name: "agent", summary: "copy an agent definition into the project; list what a session sees" },
   { name: "skill", summary: "check a skills directory; list each tier; demote and backfill it" },
-  { name: "instinct", summary: "check an instincts directory; list and show its records" },
+  { name: "instinct", summary: "check an instincts directory; list, show, flag and promote its records" },
   { name: "release", summary: "read the release state of the project; tag the release branch's HEAD" }
 ]);
 var CORE_COMMANDS = Object.freeze([
@@ -18465,6 +18550,7 @@ var CORE_COMMANDS = Object.freeze([
   triage_default,
   collect_default,
   report_default,
+  fix_schema_default,
   list_default7,
   exec_default,
   vendor_default,
@@ -18480,6 +18566,8 @@ var CORE_COMMANDS = Object.freeze([
   check_default,
   list_default4,
   show_default2,
+  flag_default,
+  promote_default,
   status_default2,
   tag_default,
   status_default3,