@open-tomato/rafa 0.19.0 → 0.21.0

package/dist/{index-mh5hyw8g.js → index-kv51t295.js}

@@ -34,6 +34,7 @@ import {
   SESSION_ID_FLAG,
   SKILL_FILE as SKILL_FILE2,
   SKILL_SIGNALS,
+  SKILL_USE_CLI_VERSION,
   SPEC_BLOCKED_LABEL,
   SPEC_EXTENSION,
   SPEC_LABEL,
@@ -148,6 +149,7 @@ import {
   previousDir,
   projectRoot,
   provenanceBlock,
+  rankCandidates,
   readAgentDirectory,
   readAuthorTrust,
   readBlockedBy,
@@ -156,7 +158,6 @@ import {
   readChoice,
   readChoiceFlag,
   readCopyRefs,
-  readInventoryFrontmatter,
   readManifestVersion,
   readMergeRefusal,
   readNextState,
@@ -164,6 +165,7 @@ import {
   readOpenPull,
   readPlanChanges,
   readPlans,
+  readRankCandidate,
   readRecords,
   readRefsText,
   readRequiredFlag,
@@ -175,6 +177,7 @@ import {
   readTextFlag,
   readTrees,
   ready_default,
+  recordPlanCi,
   refusal,
   refuseMisplacedRuntime,
   remainingFrom,
@@ -225,7 +228,7 @@ import {
   versionLine,
   waitForChecks,
   writeSession
-} from "./index-ca0fccvr.js";
+} from "./index-pzpk59ma.js";
 import {
   PROBE_TIMEOUT_MS,
   findNextTask,
@@ -239,7 +242,7 @@ import {
   runPreflight,
   splitBlockerComment,
   trackerPathFor
-} from "./index-09p41s0n.js";
+} from "./index-21qkxk63.js";
 import {
   ACTION_HEADING,
   CAUSE_HEADING,
@@ -252,6 +255,7 @@ import {
   ISSUE_TYPES,
   MARKDOWN_EXTENSION,
   SKILL_FILE,
+  SQLITE_MIGRATIONS,
   allRecords,
   claudeArgs,
   createGhRunner,
@@ -260,6 +264,7 @@ import {
   gitRemoteUrl,
   instinctProject,
   mergeFrontmatter,
+  migrateSchema,
   moduleOfLabels,
   normalizeRemote,
   readFrontmatter,
@@ -275,7 +280,7 @@ import {
   toHeldRecords,
   typeOfLabels,
   writeFrontmatter
-} from "./index-gb51x34c.js";
+} from "./index-am92b8qp.js";
 import {
   CONFIG_DEFAULTS,
   CONFIG_FILE,
@@ -289,7 +294,7 @@ import {
   readItemBytes,
   readRafaBlocks,
   resolveTiers
-} from "./index-pqrpcfaz.js";
+} from "./index-twbp38kz.js";
 import {
   promotable
 } from "./index-d6d0942q.js";
@@ -297,10 +302,10 @@ import {
   createCommandRegistry,
   describeRegistry,
   mountKey
-} from "./index-c5cecsga.js";
+} from "./index-4a45ffqh.js";
 import {
   CommandExit
-} from "./index-vg7ycs94.js";
+} from "./index-28jzpyks.js";
 import {
   MERGE_METHODS,
   RELEASE_AUTO,
@@ -312,7 +317,7 @@ import {
   isSkillTier,
   messageOf,
   parseBudgetUsd
-} from "./index-cedghpva.js";
+} from "./index-pmkgvtfe.js";
 import {
   triggerKey
 } from "./index-wp8c28fd.js";
@@ -2287,148 +2292,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";
@@ -2851,7 +2714,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.";
@@ -2938,7 +2801,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)}`);
   }
@@ -4287,7 +4150,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;
 }
@@ -4295,7 +4158,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)}` };
   }
@@ -4344,7 +4207,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";
@@ -4479,7 +4342,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);
@@ -6439,7 +6302,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)}`;
@@ -6509,7 +6372,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({
@@ -6801,14 +6664,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;
   }
@@ -6895,12 +6758,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)
   ];
@@ -7256,7 +7125,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: [
     {
@@ -7272,10 +7141,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.",
@@ -7295,13 +7169,282 @@ 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",
   subject: "effort",
   action: "report",
   summary: "roll the stored session rows up per plan, then tally the task reports and list preflight halts",
-  description: "Rolls the session rows `rafa effort collect` stored up per plan, or per branch for a" + " session no plan claims, then tallies the stored task reports by plan, status and outcome, and" + " lists the runs whose preflight halted, one row per required item that failed. It" + " reads only what is stored, so two runs over an unchanged store print the same bytes. With" + " `--output=json` the report is the data of the terminal result event. An unrecognised argument" + " and a config the loop cannot run on are each refused, one line per problem.",
+  description: "Rolls the session rows `rafa effort collect` stored up per plan, or per branch for a" + " session no plan claims, then tallies the stored task reports by plan, status and outcome, and" + " lists the runs whose preflight halted, one row per required item that failed. It" + " reads only what is stored, so two runs over an unchanged store print the same bytes. With" + " `--output=json` the report is the data of the terminal result event. With `--skills` it prints" + " the skills report instead: per plan, and per resolver within one, whether each offered skill and" + " injected lesson co-occurred with a recurrence of the failure it should prevent, read from the stored" + " rows and the skills' frontmatter, never from a session log. An unrecognised argument" + " and a config the loop cannot run on are each refused, one line per problem.",
   args: [],
   flags: [
     {
@@ -7314,6 +7457,16 @@ var report_default = wrapPhaseZeroCommand({
       description: "Keeps only the sessions whose dominant entrypoint is one of these, comma-separated." + " `sdk-cli` is the loop.",
       type: "string"
     },
+    {
+      name: "skills",
+      description: "Prints the skills report in place of the session tables: per plan and per resolver," + " each skill's and lesson's signal, the skills invoked and never offered, M1, M2 and plan CI." + " Refused beside `--kind` or `--entrypoint`, which narrow session rows it does not read.",
+      type: "boolean"
+    },
+    {
+      name: "plan",
+      description: "Keeps only these plan stubs in the skills report, comma-separated, and may be" + " repeated. A stub the store holds no row for reads as no plan. Refused without `--skills`.",
+      type: "string"
+    },
     {
       name: "json",
       description: "Deprecated: the phase 0 spelling of `--output=json`, read as that flag after one" + " deprecation line on stderr.",
@@ -7326,6 +7479,10 @@ var report_default = wrapPhaseZeroCommand({
       cmd: "rafa effort report",
       note: "Prints the per-plan tables, the task report tallies, then the preflight halts."
     },
+    {
+      cmd: "rafa effort report --skills --plan=rafa-24-know-which-skills-earn",
+      note: "Prints one plan's skills and lessons with their signals, per resolver, under the fixed" + " co-occurrence line."
+    },
     {
       cmd: "rafa effort report --entrypoint=sdk-cli --kind=task --output=json",
       note: "Writes a start event, then a result event whose data is the report of the task sessions" + " the loop ran."
@@ -7335,12 +7492,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;
@@ -7353,7 +7510,7 @@ function planFiles(dir) {
 }
 function readText2(path) {
   try {
-    return readFileSync11(path, "utf8");
+    return readFileSync10(path, "utf8");
   } catch {
     return null;
   }
@@ -7398,7 +7555,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";
@@ -7485,9 +7642,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);
@@ -7550,7 +7707,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" },
@@ -7571,7 +7728,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)
 });
@@ -7763,10 +7920,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);
 }
@@ -7796,7 +7953,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"]);
@@ -7857,7 +8014,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([
@@ -7906,7 +8066,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;
@@ -7914,7 +8074,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) {
@@ -7928,7 +8088,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 });
@@ -7936,7 +8096,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" });
@@ -7959,7 +8119,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;
@@ -7968,7 +8128,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)}` };
   }
@@ -8245,7 +8405,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)})`;
@@ -8276,8 +8436,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)];
@@ -9100,7 +9260,7 @@ function createInstinctShowCommand() {
 var show_default2 = createInstinctShowCommand();
 
 // src/commands/issue/check.ts
-import { readdirSync as readdirSync3, readFileSync as readFileSync16, statSync as statSync11 } from "fs";
+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";
@@ -9177,7 +9337,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) {
@@ -9196,7 +9356,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: readFileSync16(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));
 }
@@ -10603,6 +10763,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`.",
@@ -11082,7 +11247,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";
@@ -11103,7 +11268,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")
@@ -11199,14 +11364,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)
@@ -11258,7 +11423,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"
   },
@@ -11395,7 +11560,7 @@ var wrapped2 = wrapPhaseZeroCommand({
 var create_default2 = endingWith(wrapped2);
 
 // src/commands/plan/risk.ts
-import { readFileSync as readFileSync17 } from "fs";
+import { readFileSync as readFileSync16 } from "fs";
 import { resolve as resolve11 } from "path";
 var COMMAND2 = "rafa plan risk";
 var USAGE22 = "rafa plan risk [<plan>] [--strict]";
@@ -11423,7 +11588,7 @@ function strictRefusal(report2) {
 }
 async function readRisk(path, project, config, context, seams) {
   const makeRunners = seams.runners ?? spawningRunners;
-  return assessPlanRisk({ path, text: readFileSync17(path, "utf8") }, {
+  return assessPlanRisk({ path, text: readFileSync16(path, "utf8") }, {
     repoRoot: project.root,
     home: project.home,
     settingSources: config.settingSources,
@@ -11506,7 +11671,7 @@ function createPlanRiskCommand(seams = {}) {
 var risk_default = createPlanRiskCommand();
 
 // src/commands/plan/show.ts
-import { readFileSync as readFileSync18 } from "fs";
+import { readFileSync as readFileSync17 } from "fs";
 import { join as join23 } from "path";
 var USAGE23 = "rafa plan show <stub> [--tracker]";
 var COMMAND3 = "rafa plan show";
@@ -11528,7 +11693,7 @@ function showPlan(plans, stub, tracker) {
   const file = join23(plans.path, name2);
   if (!isFile(file))
     throw new CommandExit(1, missingText(stub, tracker, join23(plans.label, name2)));
-  const model = parsePlan(readFileSync18(file, "utf8"));
+  const model = parsePlan(readFileSync17(file, "utf8"));
   const { header } = model;
   return {
     stub,
@@ -11707,6 +11872,7 @@ function openPrContext(context, seams = DEFAULT_PR_SEAMS) {
     resolveBudget: config.prResolveBudget,
     trustedAuthors: config.boardTrustedAuthors,
     roadmapIssue: config.roadmapIssue,
+    planDir: config.planDir,
     readBranch: () => readBranch2(project.root)
   };
 }
@@ -11872,8 +12038,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 [
@@ -11970,7 +12136,7 @@ function createPrListCommand(seams = DEFAULT_PR_SEAMS) {
 var list_default8 = createPrListCommand();
 
 // src/commands/pr/merge.ts
-import { existsSync as existsSync9, readFileSync as readFileSync20 } from "fs";
+import { existsSync as existsSync10, readFileSync as readFileSync19 } from "fs";
 import { join as join25 } from "path";
 
 // src/board/roadmap-tick.ts
@@ -12126,13 +12292,13 @@ function tickSentence(result) {
 import {
   chmodSync,
   copyFileSync as copyFileSync3,
-  existsSync as existsSync8,
+  existsSync as existsSync9,
   mkdirSync as mkdirSync6,
   readdirSync as readdirSync5,
-  readFileSync as readFileSync19,
+  readFileSync as readFileSync18,
   realpathSync as realpathSync5,
-  renameSync,
-  rmSync as rmSync2,
+  renameSync as renameSync2,
+  rmSync as rmSync3,
   statSync as statSync12,
   symlinkSync
 } from "fs";
@@ -12202,12 +12368,12 @@ function listTrackers(repoRoot, planDir) {
 }
 function openTrackers(repoRoot, planDir) {
   return listTrackers(repoRoot, planDir).flatMap((path) => {
-    const task = findNextTask(readFileSync19(join24(repoRoot, path), "utf8"));
+    const task = findNextTask(readFileSync18(join24(repoRoot, path), "utf8"));
     return task ? [{ path, task }] : [];
   });
 }
 function readManifestVersion2(repoRoot) {
-  const manifest = JSON.parse(readFileSync19(join24(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(`${join24(repoRoot, "package.json")} names ${JSON.stringify(record["name"])}, not ${name}: this is no rafa checkout`);
@@ -12238,41 +12404,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);
@@ -12332,7 +12498,7 @@ function runInstall(seams, options) {
     return { kind: "refused", reason: "trackers", planDir, trackers: open };
   const distDir = join24(repoRoot, "dist");
   const runtimeDir = join24(runtimeRoot, version2);
-  const installed = existsSync8(runtimeDir);
+  const installed = existsSync9(runtimeDir);
   if (installed && options.force !== true) {
     return { kind: "refused", reason: "runtime-exists", version: version2, runtimeDir };
   }
@@ -12340,7 +12506,7 @@ function runInstall(seams, options) {
   const code = inStage("build", () => seams.build(repoRoot));
   if (code !== 0)
     throw new StageFailure("build", `the build exited ${code}`);
-  if (!existsSync8(join24(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}`);
@@ -12373,9 +12539,9 @@ function replaceFile(source, target) {
   try {
     copyFileSync3(source, temporary);
     chmodSync(temporary, statSync12(source).mode & 4095);
-    renameSync(temporary, target);
+    renameSync2(temporary, target);
   } catch (err) {
-    rmSync2(temporary, { force: true });
+    rmSync3(temporary, { force: true });
     throw err;
   }
 }
@@ -12573,11 +12739,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;
@@ -12671,7 +12837,7 @@ function remoteHoldsBranch(git, branch, warn) {
 }
 function textOf(path) {
   try {
-    return readFileSync20(path, "utf8");
+    return readFileSync19(path, "utf8");
   } catch {
     return "";
   }
@@ -12685,7 +12851,7 @@ function followUpsFor(pr, git) {
     version: facts.version,
     tagged: tags.ok && tags.stdout.trim() !== "",
     rafaCheckout: facts.rafaCheckout,
-    runtimeInstalled: existsSync9(join25(pr.project.home, RUNTIME_SUBDIR, facts.version))
+    runtimeInstalled: existsSync10(join25(pr.project.home, RUNTIME_SUBDIR, facts.version))
   });
 }
 function openGh(pr, seams) {
@@ -12810,6 +12976,15 @@ async function runMerge(context, seams) {
     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));
+  recordPlanCi({
+    repoRoot: pr.project.root,
+    planDir: pr.planDir,
+    pullRequest: detail,
+    rows: checks.rows,
+    warn: (message) => {
+      context.output.warn(message);
+    }
+  });
   refuseFromGit(git, detail, checks, skipChecks);
   const summary = summaryLine2(detail, method);
   const answer2 = await askToMerge(context, pr, seams, { number: detail.number, summary, yes, skipChecks });
@@ -13066,8 +13241,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");
@@ -13236,17 +13411,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(`
 `);
 }
@@ -13276,10 +13451,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})`
   ];
@@ -13671,8 +13846,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(", ");
@@ -13683,12 +13858,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;
@@ -13770,8 +13945,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)
@@ -13873,8 +14048,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);
@@ -13938,17 +14113,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) {
@@ -13958,24 +14133,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
@@ -13994,10 +14169,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];
@@ -14176,10 +14351,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})`
   ];
@@ -14295,7 +14470,7 @@ function withTaskBudget(plan2, usd) {
 }
 
 // src/pr/plans/load.ts
-import { existsSync as existsSync10, readFileSync as readFileSync21 } from "fs";
+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));
@@ -14322,11 +14497,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 readFileSync21(found, "utf8");
+  return readFileSync20(found, "utf8");
 }
 var SLOT_PATTERN = /\{[A-Z][A-Z0-9_]*\}/g;
 var CONFLICT_SENTENCE_SLOT = "CONFLICT_SENTENCE";
@@ -14848,11 +15023,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";
@@ -14950,6 +15125,14 @@ async function assessOne(options) {
   const { git, maxAttempts, number, pr } = options;
   const detail = await detailOf6(pr, number);
   const checks = await onProvider(`read the checks of #${number}`, () => pr.pulls.checks(number));
+  recordPlanCi({
+    repoRoot: pr.project.root,
+    planDir: pr.planDir,
+    pullRequest: detail,
+    rows: checks.rows,
+    warn: options.warn,
+    now: () => new Date(options.at)
+  });
   const found = await triageCommentOf(options, detail);
   const existing = found.comment;
   const rerun = readTriageRerun({
@@ -15018,7 +15201,10 @@ async function runTriage(context, seams) {
       wantsComment,
       maxAttempts,
       at: now(),
-      permissions
+      permissions,
+      warn: (message) => {
+        context.output.warn(message);
+      }
     });
     const reading = await assess();
     if (!wantsResolve) {
@@ -15344,7 +15530,7 @@ function createPrWaitCommand(seams = DEFAULT_WAIT_SEAMS) {
 var wait_default = createPrWaitCommand();
 
 // src/commands/release/status.ts
-import { existsSync as existsSync11, readdirSync as readdirSync6, readFileSync as readFileSync22 } from "fs";
+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 = "?";
@@ -15446,7 +15632,7 @@ function untaggedVersions(released, tags) {
 }
 function textOf2(path) {
   try {
-    return readFileSync22(path, "utf8");
+    return readFileSync21(path, "utf8");
   } catch {
     return null;
   }
@@ -15489,7 +15675,7 @@ function readBranch2(git) {
 }
 function planStubsUnder(root, planDir) {
   const resolved = join28(root, planDir);
-  if (!existsSync11(resolved))
+  if (!existsSync12(resolved))
     return [];
   try {
     return planStubsFromFileNames(readdirSync6(resolved));
@@ -15560,10 +15746,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));
@@ -15690,7 +15876,7 @@ function createReleaseStatusCommand(seams = DEFAULT_RELEASE_SEAMS) {
 var status_default2 = createReleaseStatusCommand();
 
 // src/commands/release/tag.ts
-import { readFileSync as readFileSync23 } from "fs";
+import { readFileSync as readFileSync22 } from "fs";
 import { join as join29 } from "path";
 var RELEASE_TAG_USAGE = "rafa release tag";
 var DEFAULT_RELEASE_BRANCH = "main";
@@ -15710,7 +15896,7 @@ function readBranch3(git) {
 }
 function textOf3(path) {
   try {
-    return readFileSync23(path, "utf8");
+    return readFileSync22(path, "utf8");
   } catch {
     return null;
   }
@@ -16028,11 +16214,11 @@ 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 { 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 readdirSync7, readFileSync as readFileSync24 } from "fs";
+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-";
@@ -16198,7 +16384,7 @@ function readProposalFiles(dir) {
   return names.filter((name2) => isProposalFileName(name2)).sort((left, right) => left.localeCompare(right)).map((name2) => {
     const path = join30(dir, name2);
     try {
-      return { path, result: parseProposalFile(readFileSync24(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)})`) };
     }
@@ -16227,9 +16413,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);
@@ -16254,7 +16440,7 @@ function countBackups(results) {
 }
 
 // src/backfill/derive.ts
-import { readFileSync as readFileSync25, writeFileSync as writeFileSync7 } from "fs";
+import { readFileSync as readFileSync24, writeFileSync as writeFileSync7 } from "fs";
 import { basename as basename8 } from "path";
 var DERIVED_FIELDS = ["stack", "paths", "when_to_use"];
 function renderWhenToUse(trigger, prevents) {
@@ -16380,7 +16566,7 @@ function planFile(entry, options) {
   }
   let original;
   try {
-    original = readFileSync25(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)})`);
   }
@@ -16424,7 +16610,7 @@ function planDerivation(root, options) {
 function applyFile(action, options) {
   if (action.text === null || action.original === null)
     return action;
-  const current = readFileSync25(action.path, "utf8");
+  const current = readFileSync24(action.path, "utf8");
   if (current !== action.original) {
     return {
       ...action,
@@ -16455,7 +16641,7 @@ function applyDerivation(plan2, options) {
 }
 
 // src/backfill/proposal-batch.ts
-import { readFileSync as readFileSync26 } from "fs";
+import { readFileSync as readFileSync25 } from "fs";
 import { relative as relative9 } from "path";
 
 // src/demote/report.ts
@@ -16754,7 +16940,7 @@ function readCandidate(root, entry) {
     return null;
   let text;
   try {
-    text = readFileSync26(entry.path, "utf8");
+    text = readFileSync25(entry.path, "utf8");
   } catch {
     return null;
   }
@@ -16860,7 +17046,7 @@ function parseSessionAnswer(stdout) {
 }
 
 // src/backfill/propose.ts
-import { mkdirSync as mkdirSync9, readFileSync as readFileSync27, writeFileSync as writeFileSync8 } from "fs";
+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",
@@ -17019,7 +17205,7 @@ function applyRow(root, row2, options) {
   }
   let original;
   try {
-    original = readFileSync27(path, "utf8");
+    original = readFileSync26(path, "utf8");
   } catch {
     return inert2(path, row2, "refused", "the file the row names is gone");
   }
@@ -17058,7 +17244,7 @@ function applyProposals(files, root, options) {
 }
 
 // src/demote/select.ts
-import { readdirSync as readdirSync8, readFileSync as readFileSync28, realpathSync as realpathSync6, statSync as statSync13 } from "fs";
+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";
@@ -17120,7 +17306,7 @@ function readSelected(absolute, path, entries) {
   let text;
   let mtime;
   try {
-    text = readFileSync28(absolute, "utf8");
+    text = readFileSync27(absolute, "utf8");
     mtime = statSync13(absolute).mtime.toISOString();
   } catch {
     return null;
@@ -17505,11 +17691,11 @@ function createSkillCheckCommand(seams = DEFAULT_CHECK_SEAMS) {
 var check_default3 = createSkillCheckCommand();
 
 // src/commands/skill/demote.ts
-import { existsSync as existsSync14, mkdirSync as mkdirSync11, readFileSync as readFileSync30, statSync as statSync16, 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 readdirSync9, readFileSync as readFileSync29, renameSync as renameSync2, rmSync as rmSync3, statSync as statSync15, 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 join35 } from "path";
 var DEMOTION_ACTION_KINDS = [
@@ -17551,7 +17737,7 @@ function takenInstinctIds(dir) {
 }
 function readText4(path) {
   try {
-    return statSync15(path).isFile() ? readFileSync29(path, "utf8") : null;
+    return statSync15(path).isFile() ? readFileSync28(path, "utf8") : null;
   } catch {
     return null;
   }
@@ -17579,7 +17765,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 {
@@ -17616,9 +17802,9 @@ function planDemoted(scope, row2, file, context) {
   }
   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 {
@@ -17667,13 +17853,13 @@ function planDemotion(report3, scope, seams = DEFAULT_APPLY_SEAMS) {
     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);
@@ -17780,9 +17966,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(readFileSync30(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(", ")}`);
@@ -17815,10 +18001,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(readFileSync30(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(`
@@ -17924,7 +18110,7 @@ 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 COMMAND_NAME6 = "rafa skill show";
 var USAGE32 = "rafa skill show <name> [--full]";
 function unknownSkillMessage(name2, inventory) {
   const agent = findShown(inventory.records, "agent", name2);
@@ -17952,7 +18138,7 @@ async function runShow3(context, seams) {
   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);
@@ -18030,8 +18216,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 };
@@ -18279,7 +18465,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({});
@@ -18291,13 +18477,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));
@@ -18363,7 +18549,7 @@ var CORE_SUBJECTS = Object.freeze([
   { name: "loop", summary: "start a plan; stop, pause, resume, show and list its sessions" },
   { name: "issue", summary: "the tracker: list, show, create, comment on and move issues; mark one ready, unblock it and check its references" },
   { name: "pr", summary: "the pull request of a branch: one line, in full or in the browser; list, wait on, merge and triage them" },
-  { name: "effort", summary: "collect session and commit rows; report per plan" },
+  { 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" },
@@ -18400,6 +18586,7 @@ var CORE_COMMANDS = Object.freeze([
   triage_default,
   collect_default,
   report_default,
+  fix_schema_default,
   list_default7,
   exec_default,
   vendor_default,