@open-tomato/rafa 0.20.0 → 0.21.0

package/dist/cli.js

@@ -1773,7 +1773,7 @@ function restoreRunningCommand(previous) {
 var running = null;
 
 // package.json
-var name = "@open-tomato/rafa", version = "0.20.0";
+var name = "@open-tomato/rafa", version = "0.21.0";
 var init_package = () => {};
 
 // src/cli/version.ts
@@ -2718,6 +2718,22 @@ var init_instinct = __esm(() => {
   ];
 });
 
+// src/schema/failure-strings.ts
+function failureStringProblem(entry) {
+  if (entry.trim() === "") {
+    return {
+      code: "empty-failure-string",
+      message: "a blank failure string is found in every text, " + "so every task would read as a recurrence"
+    };
+  }
+  const length = Array.from(entry).length;
+  return length < FAILURE_STRING_MIN_LENGTH ? {
+    code: "short-failure-string",
+    message: `failure string "${entry}" is ${length} characters, under ` + `${FAILURE_STRING_MIN_LENGTH}, so it may match failures the skill does not name`
+  } : null;
+}
+var FAILURE_STRING_MIN_LENGTH = 6;
+
 // src/schema/provenance.ts
 function issue2(code, field, message) {
   return { code, field, message };
@@ -3049,6 +3065,9 @@ var init_stack = __esm(() => {
 });
 
 // src/schema/skill.ts
+function isSkillWarning(code) {
+  return SKILL_WARNING_CODES.includes(code);
+}
 function countCharacters(text2) {
   return Array.from(text2).length;
 }
@@ -3252,6 +3271,22 @@ function checkPaths(data) {
   }
   return issues;
 }
+function checkFailureStrings(data) {
+  const value = data["failure_strings"];
+  if (value === undefined)
+    return [];
+  if (!Array.isArray(value)) {
+    return [issue3("wrong-type", "failure_strings", `failure_strings must be a list, not ${typeName3(value)}`)];
+  }
+  return value.flatMap((entry, index) => {
+    const field = `failure_strings[${index}]`;
+    if (typeof entry !== "string") {
+      return [issue3("wrong-type", field, `failure_strings entries must be strings, and this one is ${typeName3(entry)}`)];
+    }
+    const problem = failureStringProblem(entry);
+    return problem === null ? [] : [issue3(problem.code, field, problem.message)];
+  });
+}
 function checkBoolean(data, field) {
   const value = data[field];
   if (value === undefined || typeof value === "boolean")
@@ -3269,6 +3304,7 @@ function checkSkillFrontmatter(data) {
     ...checkStack(data),
     ...checkWhenToUse(data),
     ...checkTrigger(data),
+    ...checkFailureStrings(data),
     ...SKILL_NAME_LIST_FIELDS.flatMap((field) => checkNameList(data, field)),
     ...checkPaths(data),
     ...SKILL_BOOLEAN_FIELDS.flatMap((field) => checkBoolean(data, field)),
@@ -3276,7 +3312,7 @@ function checkSkillFrontmatter(data) {
     ...checkForbidden(data)
   ];
 }
-var DESCRIPTION_LIMIT = 130, LISTING_LIMIT = 1536, SKILL_SIGNALS, FORBIDDEN_SKILL_FIELDS, SKILL_BOOLEAN_FIELDS, SKILL_NAME_LIST_FIELDS, SKILL_NAME_PATTERN;
+var DESCRIPTION_LIMIT = 130, LISTING_LIMIT = 1536, SKILL_SIGNALS, FORBIDDEN_SKILL_FIELDS, SKILL_BOOLEAN_FIELDS, SKILL_NAME_LIST_FIELDS, SKILL_NAME_PATTERN, SKILL_WARNING_CODES;
 var init_skill = __esm(() => {
   init_provenance();
   init_stack();
@@ -3285,6 +3321,7 @@ var init_skill = __esm(() => {
   SKILL_BOOLEAN_FIELDS = ["disable-model-invocation", "user-invocable"];
   SKILL_NAME_LIST_FIELDS = ["relates", "supersedes"];
   SKILL_NAME_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+  SKILL_WARNING_CODES = ["short-failure-string"];
 });
 
 // src/check/layout.ts
@@ -3989,11 +4026,14 @@ function fromLayout(issue4) {
     message: issue4.message
   };
 }
+function skillSeverity(code) {
+  return isSkillWarning(code) ? "warning" : "failure";
+}
 function fromSkill(issue4) {
   return {
     stage: "schema",
     code: issue4.code,
-    severity: "failure",
+    severity: skillSeverity(issue4.code),
     field: issue4.field,
     line: null,
     message: issue4.message
@@ -5744,131 +5784,9 @@ var init_ndjson = __esm(() => {
   init_types2();
 });
 
-// src/effort/store/sqlite.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync4 } from "fs";
-import { dirname as dirname8, join as join13 } from "path";
-import { Database } from "bun:sqlite";
-function sqliteStorePath(repoRoot) {
-  return join13(repoRoot, EFFORT_STORE_DIR, STORE_FILE_NAME);
-}
-function hasKey(entry) {
-  return entry.key !== null;
-}
-function refused2(index, length, reason) {
-  return new Error(`effort store: row ${index} of ${length} ${reason}; batch refused`);
-}
-function batchEntries(kind, rows2) {
-  const keyOf = EFFORT_KEY_PROJECTIONS[kind];
-  const projected = rows2.map((row2) => ({ key: keyOf(row2), row: row2 }));
-  const keyed = projected.filter(hasKey);
-  if (keyed.length < projected.length) {
-    const keylessAt = projected.findIndex((entry) => !hasKey(entry));
-    throw refused2(keylessAt, rows2.length, "carries no key");
-  }
-  const unholdableAt = keyed.findIndex(({ key }) => LONE_SURROGATE.test(key));
-  if (unholdableAt !== -1) {
-    const reason = "carries a key with a lone UTF-16 surrogate," + " which SQLite text cannot hold";
-    throw refused2(unholdableAt, rows2.length, reason);
-  }
-  return keyed.map(({ key, row: row2 }) => ({ key, body: JSON.stringify(row2) }));
-}
-function userVersion(db) {
-  const row2 = db.query("PRAGMA user_version").get();
-  return row2?.user_version ?? 0;
-}
-function checkedVersion(db, path, latest) {
-  const version2 = userVersion(db);
-  if (version2 > latest) {
-    throw new Error(`effort store: ${path} is at schema version ${version2}, past the` + ` ${latest} this rafa knows; refusing to read or write it`);
-  }
-  return version2;
-}
-function migrateSchema(db, path, migrations = SQLITE_MIGRATIONS) {
-  const latest = migrations.length;
-  if (checkedVersion(db, path, latest) === latest)
-    return;
-  const applyPending = db.transaction(() => {
-    const from = checkedVersion(db, path, latest);
-    for (const sql of migrations.slice(from))
-      db.run(sql);
-    db.run(`PRAGMA user_version = ${latest}`);
-  });
-  applyPending.immediate();
-}
-function withSqliteStore(path, create, use) {
-  if (create)
-    mkdirSync4(dirname8(path), { recursive: true });
-  const db = new Database(path, { readwrite: true, create });
-  try {
-    migrateSchema(db, path);
-    return use(db);
-  } finally {
-    db.close();
-  }
-}
-function insertBatch(db, table2, entries) {
-  const insert = db.query(`INSERT INTO ${table2.name} (${table2.keyColumn}, row_json) VALUES (?, ?)` + ` ON CONFLICT (${table2.keyColumn}) DO NOTHING`);
-  const insertAll = db.transaction(() => entries.reduce((appended, { key, body }) => appended + insert.run(key, body).changes, 0));
-  return insertAll.immediate();
-}
-function writeSqliteStore(path, rowCount, empty, insert) {
-  const exists = existsSync6(path);
-  if (rowCount > 0)
-    return withSqliteStore(path, !exists, insert);
-  if (exists)
-    withSqliteStore(path, false, () => {
-      return;
-    });
-  return empty;
-}
-function appendKind2(path, kind, rows2) {
-  const entries = batchEntries(kind, rows2);
-  const table2 = KIND_TABLES[kind];
-  const appended = writeSqliteStore(path, entries.length, 0, (db) => insertBatch(db, table2, entries));
-  return { path, appended, skipped: entries.length - appended };
-}
-function keysOfKind2(path, kind) {
-  if (!existsSync6(path))
-    return new Set;
-  const { name: name2, keyColumn } = KIND_TABLES[kind];
-  const keys = withSqliteStore(path, false, (db) => db.query(`SELECT ${keyColumn} AS key FROM ${name2} ORDER BY seq`).all());
-  return new Set(keys.map(({ key }) => key));
-}
-function parsedObject(body) {
-  try {
-    const value = JSON.parse(body);
-    return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
-  } catch {
-    return null;
-  }
-}
-function rowOf(body, where) {
-  const value = parsedObject(body);
-  if (value === null) {
-    throw new Error(`effort store: ${where} does not hold a JSON object;` + " no append writes one");
-  }
-  return value;
-}
-function readKind2(path, kind) {
-  if (!existsSync6(path))
-    return [];
-  const { name: name2 } = KIND_TABLES[kind];
-  const stored = withSqliteStore(path, false, (db) => db.query(`SELECT seq, row_json AS body FROM ${name2} ORDER BY seq`).all());
-  return stored.map(({ seq, body }) => rowOf(body, `${path}: ${name2} row ${seq}`));
-}
-function openSqliteStore(repoRoot) {
-  const path = sqliteStorePath(repoRoot);
-  return {
-    append: (kind, rows2) => appendKind2(path, kind, rows2),
-    keys: (kind) => keysOfKind2(path, kind),
-    read: (kind) => readKind2(path, kind),
-    path: () => path
-  };
-}
-var STORE_FILE_NAME = "effort.sqlite", SQLITE_MIGRATIONS, SQLITE_SCHEMA_VERSION, KIND_TABLES, LONE_SURROGATE;
-var init_sqlite = __esm(() => {
-  init_store();
-  init_types2();
+// src/effort/store/migrations.ts
+var SQLITE_MIGRATIONS, SQLITE_SCHEMA_VERSION;
+var init_migrations = __esm(() => {
   SQLITE_MIGRATIONS = [
     `
   CREATE TABLE sessions (
@@ -6044,9 +5962,155 @@ var init_sqlite = __esm(() => {
 
   CREATE UNIQUE INDEX skill_invocations_by_use
     ON skill_invocations (session_id, ifnull(name, ''), ifnull(sidechain, -1));
+  `,
+    `
+  ALTER TABLE task_reports
+    ADD COLUMN skills_used TEXT CHECK (skills_used IS NULL OR json_type(skills_used) = 'array');
+  `,
+    `
+  CREATE TABLE plan_ci (
+    seq       INTEGER PRIMARY KEY,
+    plan_stub TEXT NOT NULL CHECK (plan_stub <> ''),
+    pr        INTEGER NOT NULL CHECK (typeof(pr) = 'integer' AND pr > 0),
+    head_sha  TEXT NOT NULL CHECK (head_sha <> ''),
+    verdict   TEXT NOT NULL CHECK (verdict IN ('green', 'red', 'none')),
+    failing   TEXT NOT NULL CHECK (json_valid(failing) AND json_type(failing) = 'array'),
+    read_at   TEXT NOT NULL CHECK (read_at <> ''),
+    UNIQUE (pr, head_sha, read_at),
+    CHECK ((verdict = 'red') = (json_array_length(failing) > 0))
+  );
   `
   ];
   SQLITE_SCHEMA_VERSION = SQLITE_MIGRATIONS.length;
+});
+
+// src/effort/store/sqlite.ts
+import { existsSync as existsSync6, mkdirSync as mkdirSync4 } from "fs";
+import { dirname as dirname8, join as join13 } from "path";
+import { Database } from "bun:sqlite";
+function sqliteStorePath(repoRoot) {
+  return join13(repoRoot, EFFORT_STORE_DIR, STORE_FILE_NAME);
+}
+function hasKey(entry) {
+  return entry.key !== null;
+}
+function refused2(index, length, reason) {
+  return new Error(`effort store: row ${index} of ${length} ${reason}; batch refused`);
+}
+function batchEntries(kind, rows2) {
+  const keyOf = EFFORT_KEY_PROJECTIONS[kind];
+  const projected = rows2.map((row2) => ({ key: keyOf(row2), row: row2 }));
+  const keyed = projected.filter(hasKey);
+  if (keyed.length < projected.length) {
+    const keylessAt = projected.findIndex((entry) => !hasKey(entry));
+    throw refused2(keylessAt, rows2.length, "carries no key");
+  }
+  const unholdableAt = keyed.findIndex(({ key }) => LONE_SURROGATE.test(key));
+  if (unholdableAt !== -1) {
+    const reason = "carries a key with a lone UTF-16 surrogate," + " which SQLite text cannot hold";
+    throw refused2(unholdableAt, rows2.length, reason);
+  }
+  return keyed.map(({ key, row: row2 }) => ({ key, body: JSON.stringify(row2) }));
+}
+function userVersion(db) {
+  const row2 = db.query("PRAGMA user_version").get();
+  return row2?.user_version ?? 0;
+}
+function checkedVersion(db, path, latest) {
+  const version2 = userVersion(db);
+  if (version2 > latest) {
+    throw new Error(`effort store: ${path} is at schema version ${version2}, past the` + ` ${latest} this rafa knows; refusing to read or write it`);
+  }
+  return version2;
+}
+function migrateSchema(db, path, migrations = SQLITE_MIGRATIONS) {
+  const latest = migrations.length;
+  if (checkedVersion(db, path, latest) === latest)
+    return;
+  const applyPending = db.transaction(() => {
+    const from = checkedVersion(db, path, latest);
+    for (const sql of migrations.slice(from))
+      db.run(sql);
+    db.run(`PRAGMA user_version = ${latest}`);
+  });
+  applyPending.immediate();
+}
+function withSqliteStore(path, create, use) {
+  if (create)
+    mkdirSync4(dirname8(path), { recursive: true });
+  const db = new Database(path, { readwrite: true, create });
+  try {
+    migrateSchema(db, path);
+    return use(db);
+  } finally {
+    db.close();
+  }
+}
+function insertBatch(db, table2, entries) {
+  const insert = db.query(`INSERT INTO ${table2.name} (${table2.keyColumn}, row_json) VALUES (?, ?)` + ` ON CONFLICT (${table2.keyColumn}) DO NOTHING`);
+  const insertAll = db.transaction(() => entries.reduce((appended, { key, body }) => appended + insert.run(key, body).changes, 0));
+  return insertAll.immediate();
+}
+function writeSqliteStore(path, rowCount, empty, insert) {
+  const exists = existsSync6(path);
+  if (rowCount > 0)
+    return withSqliteStore(path, !exists, insert);
+  if (exists)
+    withSqliteStore(path, false, () => {
+      return;
+    });
+  return empty;
+}
+function appendKind2(path, kind, rows2) {
+  const entries = batchEntries(kind, rows2);
+  const table2 = KIND_TABLES[kind];
+  const appended = writeSqliteStore(path, entries.length, 0, (db) => insertBatch(db, table2, entries));
+  return { path, appended, skipped: entries.length - appended };
+}
+function keysOfKind2(path, kind) {
+  if (!existsSync6(path))
+    return new Set;
+  const { name: name2, keyColumn } = KIND_TABLES[kind];
+  const keys = withSqliteStore(path, false, (db) => db.query(`SELECT ${keyColumn} AS key FROM ${name2} ORDER BY seq`).all());
+  return new Set(keys.map(({ key }) => key));
+}
+function parsedObject(body) {
+  try {
+    const value = JSON.parse(body);
+    return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+  } catch {
+    return null;
+  }
+}
+function rowOf(body, where) {
+  const value = parsedObject(body);
+  if (value === null) {
+    throw new Error(`effort store: ${where} does not hold a JSON object;` + " no append writes one");
+  }
+  return value;
+}
+function readKind2(path, kind) {
+  if (!existsSync6(path))
+    return [];
+  const { name: name2 } = KIND_TABLES[kind];
+  const stored = withSqliteStore(path, false, (db) => db.query(`SELECT seq, row_json AS body FROM ${name2} ORDER BY seq`).all());
+  return stored.map(({ seq, body }) => rowOf(body, `${path}: ${name2} row ${seq}`));
+}
+function openSqliteStore(repoRoot) {
+  const path = sqliteStorePath(repoRoot);
+  return {
+    append: (kind, rows2) => appendKind2(path, kind, rows2),
+    keys: (kind) => keysOfKind2(path, kind),
+    read: (kind) => readKind2(path, kind),
+    path: () => path
+  };
+}
+var STORE_FILE_NAME = "effort.sqlite", KIND_TABLES, LONE_SURROGATE;
+var init_sqlite = __esm(() => {
+  init_store();
+  init_migrations();
+  init_types2();
+  init_migrations();
   KIND_TABLES = {
     sessions: { name: "sessions", keyColumn: "session_id" },
     commits: { name: "commits", keyColumn: "sha" }
@@ -12488,9 +12552,21 @@ function checkStatus(status) {
   const expected2 = REPORT_STATUSES.join(", ");
   throw refusedWrite5(`has status ${describeValue7(status)}, not null or one of ${expected2}`);
 }
+function checkSkillsUsed(skills) {
+  if (skills === undefined || skills === null)
+    return;
+  const isName = (name2) => typeof name2 === "string" && name2.trim().length > 0;
+  if (Array.isArray(skills) && skills.every(isName))
+    return;
+  throw refusedWrite5(`has skills used ${describeValue7(skills)}, not null or a list of non-blank strings`);
+}
+function skillsUsedJson(skills) {
+  return skills === undefined || skills === null ? null : JSON.stringify(skills);
+}
 function writeTaskReport(repoRoot, write, seams = {}) {
   checkDispatch("task report", write.dispatch, write.outcome);
   checkStatus(write.report.status);
+  checkSkillsUsed(write.report.skillsUsed);
   const path = sqliteStorePath(repoRoot);
   const { sessionId, planStub, taskLine: taskLine2 } = write.dispatch;
   const collectedAt = (seams.now ?? (() => new Date))().toISOString();
@@ -12502,7 +12578,8 @@ function writeTaskReport(repoRoot, write, seams = {}) {
     taskLine2,
     write.report.status,
     write.outcome,
-    collectedAt
+    collectedAt,
+    skillsUsedJson(write.report.skillsUsed)
   ];
   const appended = writeSqliteStore(path, ROWS_PER_WRITE2, 0, (db) => db.query(INSERT_REPORT).run(...values).changes);
   return { path, appended, skipped: ROWS_PER_WRITE2 - appended };
@@ -12519,19 +12596,45 @@ function readTaskReportTallies(repoRoot) {
     reports: row2.reports
   }));
 }
+function parseSkillsUsed(sessionId, json) {
+  if (json === null)
+    return null;
+  const list = JSON.parse(json);
+  if (Array.isArray(list) && list.every((name2) => typeof name2 === "string"))
+    return list;
+  throw new Error(`effort store: task report of session ${sessionId} holds skills_used ${json}, not a list of names`);
+}
+function readReportedSkills(repoRoot) {
+  const path = sqliteStorePath(repoRoot);
+  if (!existsSync14(path))
+    return [];
+  const rows2 = withSqliteStore(path, false, (db) => db.query(SELECT_REPORTED_SKILLS).all());
+  return rows2.map((row2) => ({
+    sessionId: row2.session_id,
+    planStub: row2.plan_stub,
+    taskLine: row2.task_line,
+    outcome: row2.outcome,
+    skillsUsed: parseSkillsUsed(row2.session_id, row2.skills_used)
+  }));
+}
 var ROWS_PER_WRITE2 = 1, INSERT_REPORT = `
   INSERT INTO task_reports (
     id, session_id, plan_stub, task_line,
     status,
-    outcome, collected_at
+    outcome, collected_at,
+    skills_used
   )
-  VALUES (?, ?, ?, ?, ?, ?, ?)
+  VALUES (?, ?, ?, ?, ?, ?, ?, ?)
   ON CONFLICT (session_id) DO NOTHING
 `, SELECT_TALLIES = `
   SELECT plan_stub, status, outcome, COUNT(*) AS reports
   FROM task_reports
   GROUP BY plan_stub, status, outcome
   ORDER BY plan_stub, status, outcome
+`, SELECT_REPORTED_SKILLS = `
+  SELECT session_id, plan_stub, task_line, outcome, skills_used
+  FROM task_reports
+  ORDER BY seq
 `;
 var init_reports = __esm(() => {
   init_parse();
@@ -25888,6 +25991,80 @@ var init_fix_schema2 = __esm(() => {
   fix_schema_default = createFixSchemaCommand();
 });
 
+// src/effort/report-args.ts
+function splitList(raw) {
+  return raw.split(",").map((part) => part.trim()).filter((part) => part.length > 0);
+}
+function asSessionKind(value) {
+  return SESSION_KINDS.find((kind) => kind === value) ?? null;
+}
+function combinationErrors(skills, planTyped, filters) {
+  if (!skills) {
+    return planTyped ? ["--plan narrows the skills report and needs --skills"] : [];
+  }
+  return filters.map((flag2) => `${flag2} narrows the session tables, which --skills does not print`);
+}
+function parseReportArgs(args) {
+  const errors = [];
+  const kinds = [];
+  const entrypoints = [];
+  const plans = [];
+  const filters = [];
+  let json = false;
+  let skills = false;
+  let planTyped = false;
+  for (const arg of args) {
+    if (arg === "--json") {
+      json = true;
+    } else if (arg === "--skills") {
+      skills = true;
+    } else if (arg === "--kind" || arg === "--entrypoint" || arg === "--plan") {
+      errors.push(`${arg} takes a value, as ${arg}=<value>`);
+    } else if (arg.startsWith("--plan=")) {
+      planTyped = true;
+      const stubs = splitList(arg.slice("--plan=".length));
+      if (stubs.length === 0)
+        errors.push(`--plan names no plan stub: ${arg}`);
+      for (const stub of stubs) {
+        if (!plans.includes(stub))
+          plans.push(stub);
+      }
+    } else if (arg.startsWith("--kind=")) {
+      if (!filters.includes("--kind"))
+        filters.push("--kind");
+      for (const value of splitList(arg.slice("--kind=".length))) {
+        const kind = asSessionKind(value);
+        if (kind === null) {
+          errors.push(`--kind value is not a session kind: ${value}` + ` (one of ${SESSION_KINDS.join(", ")})`);
+        } else if (!kinds.includes(kind)) {
+          kinds.push(kind);
+        }
+      }
+    } else if (arg.startsWith("--entrypoint=")) {
+      if (!filters.includes("--entrypoint"))
+        filters.push("--entrypoint");
+      for (const value of splitList(arg.slice("--entrypoint=".length))) {
+        if (!entrypoints.includes(value))
+          entrypoints.push(value);
+      }
+    } else {
+      errors.push(`unrecognised argument: ${arg}`);
+    }
+  }
+  errors.push(...combinationErrors(skills, planTyped, filters));
+  return {
+    json,
+    kinds: kinds.length === 0 ? null : kinds,
+    entrypoints: entrypoints.length === 0 ? null : entrypoints,
+    skills,
+    plans: plans.length === 0 ? null : plans,
+    errors
+  };
+}
+var init_report_args = __esm(() => {
+  init_report();
+});
+
 // src/effort/report-budgets.ts
 function usageOf2(row3) {
   const { usage } = row3;
@@ -26110,6 +26287,607 @@ var init_report_format = __esm(() => {
   BUDGET_RIGHT_ALIGNED = new Set(BUDGET_COLUMNS.slice(2));
 });
 
+// src/effort/report-skills-format.ts
+function matchedCell(matches) {
+  const texts = [...new Set(matches.map(({ text: text2 }) => oneLine5(text2)))];
+  return texts.length === 0 ? "-" : texts.join(" / ");
+}
+function skillSignalCell(row3) {
+  if (row3.signal === null)
+    return "unknown";
+  if (row3.signal === "unmeasured")
+    return `invoked ${row3.uptake}/${row3.offered}, recurrence not declared`;
+  return row3.signal;
+}
+function skillCells(row3) {
+  return [
+    row3.name,
+    formatCount(row3.offered),
+    formatCount(row3.invoked),
+    formatCount(row3.reported),
+    formatCount(row3.recurred),
+    matchedCell(row3.matches),
+    skillSignalCell(row3)
+  ];
+}
+function lessonCells(row3) {
+  return [
+    row3.id,
+    row3.artifact === null ? "unknown" : oneLine5(row3.artifact),
+    formatCount(row3.injected),
+    formatCount(row3.recurred),
+    matchedCell(row3.matches),
+    row3.signal
+  ];
+}
+function neverOfferedLine(tallies) {
+  if (tallies.length === 0)
+    return "never offered: none";
+  const entries = tallies.map((tally2) => `${tally2.name} (invoked ${formatCount(tally2.invoked)}, recurred ${formatCount(tally2.recurred)})`);
+  return `never offered: ${entries.join(", ")}`;
+}
+function formatMetric(value) {
+  const percent = value.percent === null ? "-" : `${value.percent.toFixed(PERCENT_DECIMALS)}%`;
+  return `${formatCount(value.numerator)}/${formatCount(value.denominator)}, ${percent}`;
+}
+function formatPlanCi(reading2) {
+  if (reading2 === null)
+    return `${PLAN_CI_LABEL}: not read`;
+  const failing = reading2.failing.length === 0 ? "" : `, failing: ${reading2.failing.map(oneLine5).join(", ")}`;
+  const sha = reading2.headSha.slice(0, SHORT_SHA_LENGTH);
+  return `${PLAN_CI_LABEL}: ${reading2.verdict} on #${reading2.pr} at ${sha}, read ${reading2.readAt}${failing}`;
+}
+function resolverName(resolver) {
+  return resolver ?? "not recorded";
+}
+function formatSkillsArm(arm) {
+  const skills = arm.skills.length === 0 ? ["skills: none offered"] : alignRows(SKILL_COLUMNS, arm.skills.map(skillCells), COUNT_COLUMNS);
+  const lessons = arm.lessons.length === 0 ? ["lessons: none injected"] : alignRows(LESSON_COLUMNS, arm.lessons.map(lessonCells), COUNT_COLUMNS);
+  const unknown = arm.unknownSessions === 0 ? [] : [`note: ${formatCount(arm.unknownSessions)} of ${formatCount(arm.sessions)} sessions have unknown invocations, left out of M1 and M2`];
+  return [
+    ...skills,
+    neverOfferedLine(arm.neverOffered),
+    "",
+    ...lessons,
+    "",
+    `M1  ${formatMetric(arm.m1)} (task lines invoking a skill)`,
+    `M2  ${formatMetric(arm.m2)} (offered skills invoked)`,
+    ...unknown
+  ];
+}
+function indented(indent, line) {
+  return line === "" ? "" : `${indent}${line}`;
+}
+function formatSkillsPlan(plan) {
+  const name2 = plan.planStub === null ? "no plan" : `plan ${plan.planStub}`;
+  const sessions = `${formatCount(plan.sessions)} sessions`;
+  const [only] = plan.resolvers;
+  if (plan.resolvers.length === 1 && only !== undefined) {
+    return [
+      `${name2}: ${sessions}, resolver ${resolverName(only.resolver)}`,
+      formatPlanCi(plan.planCi),
+      "",
+      ...formatSkillsArm(only)
+    ];
+  }
+  const arms = plan.resolvers.flatMap((arm) => [
+    "",
+    `${ARM_INDENT}resolver ${resolverName(arm.resolver)}: ${formatCount(arm.sessions)} sessions`,
+    ...formatSkillsArm(arm).map((line) => indented(`${ARM_INDENT}${ARM_INDENT}`, line))
+  ]);
+  return [`${name2}: ${sessions}, ${plan.resolvers.length} resolvers`, formatPlanCi(plan.planCi), ...arms];
+}
+function formatSkillsReport(report) {
+  const plans = report.plans.length === 0 ? ["", "no task sessions recorded for the plans read"] : report.plans.flatMap((plan) => ["", ...formatSkillsPlan(plan)]);
+  return [SKILLS_REPORT_HEADER, ...plans, "", ...PROBE_FOOTNOTE];
+}
+var SKILLS_REPORT_HEADER = "Co-occurrence, not cause: a skill can be invoked and its failure recur for reasons the skill does not cover.", PROBE_FOOTNOTE, PLAN_CI_LABEL = "plan CI", SKILL_COLUMNS, LESSON_COLUMNS, COUNT_COLUMNS, SHORT_SHA_LENGTH = 7, PERCENT_DECIMALS = 1, ARM_INDENT = "  ";
+var init_report_skills_format = __esm(() => {
+  init_report_format();
+  PROBE_FOOTNOTE = [
+    "note: invoked counts are read from each session's own log. Claude Code's",
+    "      own usage record (pluginUsage in ~/.claude/.claude.json) counts per",
+    "      plugin and never a project skill, so it has no count to agree with."
+  ];
+  SKILL_COLUMNS = ["skill", "offered", "invoked", "reported", "recurred", "matched", "signal"];
+  LESSON_COLUMNS = ["lesson", "artifact", "injected", "recurred", "matched", "signal"];
+  COUNT_COLUMNS = new Set(["offered", "invoked", "reported", "recurred", "injected"]);
+});
+
+// src/effort/recurrence.ts
+function findingTexts(fact, finding2) {
+  return FINDING_FIELDS.map((field5) => ({
+    source: "finding",
+    sessionId: fact.sessionId,
+    taskLine: fact.taskLine,
+    field: field5,
+    text: finding2[field5]
+  }));
+}
+function entryTexts(fact, source, entry) {
+  return ENTRY_FIELDS.map((field5) => ({
+    source,
+    sessionId: fact.sessionId,
+    taskLine: fact.taskLine,
+    field: field5,
+    text: entry[field5]
+  }));
+}
+function taskTexts(fact) {
+  return [
+    ...fact.findings.flatMap((finding2) => findingTexts(fact, finding2)),
+    ...fact.blockers.flatMap((entry) => entryTexts(fact, "blocker", entry)),
+    ...fact.outOfScopeBugs.flatMap((entry) => entryTexts(fact, "out-of-scope-bug", entry))
+  ];
+}
+function tasksFrom(facts, fromIndex) {
+  const task = facts[fromIndex];
+  if (!Number.isInteger(fromIndex) || task === undefined) {
+    throw new RangeError(`recurrence: fromIndex ${fromIndex} is not a row of ${facts.length} fact rows`);
+  }
+  if (task.planStub === null)
+    return [task];
+  return facts.slice(fromIndex).filter(({ planStub: planStub2 }) => planStub2 === task.planStub);
+}
+function failingNames(planStub2, planCi) {
+  if (planStub2 === null)
+    return [];
+  const names = new Set(planCi.filter((row3) => row3.planStub === planStub2).flatMap(({ failing }) => failing));
+  return [...names].map((text2) => ({ source: "plan-ci", sessionId: null, taskLine: null, field: "failing", text: text2 }));
+}
+function findRecurrences(strings, facts, fromIndex, planCi) {
+  const tasks = tasksFrom(facts, fromIndex);
+  const searched = [...new Set(strings)].filter((string) => string !== "");
+  const haystacks = [...tasks.flatMap(taskTexts), ...failingNames(tasks[0]?.planStub ?? null, planCi)];
+  return haystacks.flatMap(({ text: text2, ...where }) => {
+    if (text2 === null)
+      return [];
+    return searched.filter((string) => text2.includes(string)).map((string) => ({ string, ...where, text: text2 }));
+  });
+}
+var FINDING_FIELDS, ENTRY_FIELDS;
+var init_recurrence = __esm(() => {
+  FINDING_FIELDS = ["trigger", "what", "cause", "artifact"];
+  ENTRY_FIELDS = ["what", "artifact"];
+});
+
+// src/effort/store/plan-ci.ts
+import { existsSync as existsSync29, readdirSync as readdirSync10 } from "fs";
+import { resolve as resolve17 } from "path";
+function refusedWrite7(reason) {
+  return new Error(`effort store: plan CI write ${reason}; nothing written`);
+}
+function checkText3(name2, value) {
+  const problem = value === null ? "is null" : textProblem(value);
+  if (problem !== null)
+    throw refusedWrite7(`has a ${name2} that ${problem}`);
+}
+function checkRow(row3) {
+  checkText3("plan stub", row3.planStub);
+  checkText3("head sha", row3.headSha);
+  checkText3("read time", row3.readAt);
+  if (!Number.isSafeInteger(row3.pr) || row3.pr <= 0) {
+    throw refusedWrite7(`has pull request ${describeValue7(row3.pr)}, not a whole number above zero`);
+  }
+  const verdict = row3.verdict;
+  if (!PLAN_CI_VERDICTS.some((known) => known === verdict)) {
+    throw refusedWrite7(`has verdict ${describeValue7(verdict)}, not one of ${PLAN_CI_VERDICTS.join(", ")}`);
+  }
+  const failing = row3.failing;
+  if (!Array.isArray(failing))
+    throw refusedWrite7(`has failing ${describeValue7(failing)}, not a list`);
+  for (const name2 of failing)
+    checkText3("failing check name", name2);
+  if (row3.verdict === "red" !== failing.length > 0) {
+    throw refusedWrite7(`has verdict ${row3.verdict} beside ${failing.length} failing checks`);
+  }
+}
+function planStubOfBranch(headRefName, planStubs) {
+  const branchStub = attributeBranch(headRefName).stub;
+  if (branchStub === null)
+    return null;
+  const resolution = resolvePlanStub(branchStub, planStubs);
+  if (resolution.stub !== null)
+    return resolution.stub;
+  return resolution.match === "ambiguous" ? null : branchStub;
+}
+function planCiReading(pullRequest, rows2, planStubs, readAt) {
+  const verdict = verdictOf2(rows2);
+  if (verdict === "pending") {
+    return { row: null, skipped: `the checks of #${pullRequest.number} are still running` };
+  }
+  const planStub2 = planStubOfBranch(pullRequest.headRefName, planStubs);
+  if (planStub2 === null) {
+    return { row: null, skipped: `the branch "${pullRequest.headRefName}" of #${pullRequest.number} resolves to no plan` };
+  }
+  const failing = failingRows(rows2).map(({ name: name2 }) => name2);
+  return {
+    row: { planStub: planStub2, pr: pullRequest.number, headSha: pullRequest.headRefOid, verdict, failing, readAt },
+    skipped: null
+  };
+}
+function writePlanCi(repoRoot, row3) {
+  checkRow(row3);
+  const path4 = sqliteStorePath(repoRoot);
+  const values = [row3.planStub, row3.pr, row3.headSha, row3.verdict, JSON.stringify(row3.failing), row3.readAt];
+  const appended2 = writeSqliteStore(path4, 1, 0, (db) => db.query(INSERT_PLAN_CI).run(...values).changes);
+  return { path: path4, appended: appended2 };
+}
+function rowOf4(stored) {
+  const failing = JSON.parse(stored.failing);
+  return {
+    planStub: stored.plan_stub,
+    pr: stored.pr,
+    headSha: stored.head_sha,
+    verdict: stored.verdict,
+    failing: Array.isArray(failing) ? failing.map(String) : [],
+    readAt: stored.read_at
+  };
+}
+function readPlanCi(repoRoot, planStub2) {
+  const path4 = sqliteStorePath(repoRoot);
+  if (!existsSync29(path4))
+    return [];
+  const rows2 = withSqliteStore(path4, false, (db) => planStub2 === undefined ? db.query(`${SELECT_COLUMNS} ORDER BY seq`).all() : db.query(`${SELECT_COLUMNS} WHERE plan_stub = ? ORDER BY seq`).all(planStub2));
+  return rows2.map(rowOf4);
+}
+function planStubsUnder(repoRoot, planDir) {
+  const dir = resolve17(repoRoot, planDir);
+  return existsSync29(dir) ? planStubsFromFileNames(readdirSync10(dir)) : [];
+}
+function messageOf12(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function recordPlanCi(input) {
+  const now = input.now ?? (() => new Date);
+  let row3 = null;
+  try {
+    const planStubs = planStubsUnder(input.repoRoot, input.planDir);
+    const reading2 = planCiReading(input.pullRequest, input.rows, planStubs, now().toISOString());
+    if (reading2.row === null)
+      return { row: null, skipped: reading2.skipped, appended: 0, problem: null };
+    row3 = reading2.row;
+    const { appended: appended2 } = writePlanCi(input.repoRoot, row3);
+    return { row: row3, skipped: null, appended: appended2, problem: null };
+  } catch (error) {
+    const problem = `the CI reading of #${input.pullRequest.number} was not stored: ${messageOf12(error)}`;
+    input.warn(problem);
+    return { row: row3, skipped: null, appended: 0, problem };
+  }
+}
+var PLAN_CI_VERDICTS, INSERT_PLAN_CI = `
+  INSERT INTO plan_ci (plan_stub, pr, head_sha, verdict, failing, read_at)
+  VALUES (?, ?, ?, ?, ?, ?)
+  ON CONFLICT (pr, head_sha, read_at) DO NOTHING
+`, SELECT_COLUMNS = "SELECT plan_stub, pr, head_sha, verdict, failing, read_at FROM plan_ci";
+var init_plan_ci = __esm(() => {
+  init_checks();
+  init_attribution();
+  init_findings();
+  init_sqlite();
+  PLAN_CI_VERDICTS = ["green", "red", "none"];
+});
+
+// src/effort/skill-facts.ts
+import { existsSync as existsSync30 } from "fs";
+function selectEntries(table2) {
+  return `SELECT session_id, what, artifact FROM ${table2} ORDER BY seq`;
+}
+function parseNames(column, sessionId, json) {
+  if (json === null)
+    return null;
+  const list = JSON.parse(json);
+  if (Array.isArray(list) && list.every((name2) => typeof name2 === "string"))
+    return list;
+  throw new Error(`effort store: ${column} of session ${sessionId} holds ${json}, not a list of names`);
+}
+function bySession(rows2, toEntry) {
+  const groups = new Map;
+  for (const row3 of rows2) {
+    const group = groups.get(row3.session_id) ?? [];
+    groups.set(row3.session_id, [...group, toEntry(row3)]);
+  }
+  return groups;
+}
+function entryOf({ what, artifact }) {
+  return { what, artifact };
+}
+function findingOf(row3) {
+  return {
+    kind: row3.kind,
+    trigger: row3.trigger,
+    what: row3.what,
+    cause: row3.cause,
+    resolution: row3.resolution,
+    artifact: row3.artifact,
+    signal: row3.signal
+  };
+}
+function readSessionRows(path4) {
+  return withSqliteStore(path4, false, (db) => {
+    const offers = db.query(SELECT_OFFERS).all();
+    return {
+      offers: new Map(offers.map((row3) => [row3.session_id, {
+        resolver: row3.resolver,
+        skillsOffered: parseNames("skills_offered", row3.session_id, row3.skills_offered),
+        lessonsOffered: parseNames("lessons_offered", row3.session_id, row3.lessons_offered)
+      }])),
+      findings: bySession(db.query(SELECT_FINDINGS2).all(), findingOf),
+      blockers: bySession(db.query(selectEntries("blockers")).all(), entryOf),
+      outOfScopeBugs: bySession(db.query(selectEntries("out_of_scope_bugs")).all(), entryOf)
+    };
+  });
+}
+function invocationsBySession(invocations) {
+  const sessions = new Map;
+  for (const invocation of invocations) {
+    const held = sessions.get(invocation.sessionId) ?? [];
+    if (held === UNKNOWN_SKILL_COUNT || invocation.count === UNKNOWN_SKILL_COUNT) {
+      sessions.set(invocation.sessionId, UNKNOWN_SKILL_COUNT);
+      continue;
+    }
+    const { name: name2, count: count2 } = invocation;
+    const counted5 = held.some((use) => use.name === name2) ? held.map((use) => use.name === name2 ? { name: name2, count: use.count + count2 } : use) : [...held, { name: name2, count: count2 }];
+    sessions.set(invocation.sessionId, counted5);
+  }
+  return sessions;
+}
+function bareNames(names) {
+  return names === null ? null : [...new Set(names.map((name2) => bareSkillName(name2)))];
+}
+function orderedReports(reports, plans) {
+  const order = plans === undefined ? [...new Set(reports.map(({ planStub: planStub2 }) => planStub2))] : [...new Set(plans)];
+  return order.flatMap((plan) => reports.filter(({ planStub: planStub2 }) => planStub2 === plan));
+}
+function readSkillFacts(repoRoot, plans) {
+  if (!existsSync30(sqliteStorePath(repoRoot)))
+    return [];
+  const reports = orderedReports(readReportedSkills(repoRoot), plans);
+  if (reports.length === 0)
+    return [];
+  const rows2 = readSessionRows(sqliteStorePath(repoRoot));
+  const invoked = invocationsBySession(readSkillInvocations(repoRoot));
+  const planCi = new Map;
+  for (const row3 of readPlanCi(repoRoot))
+    planCi.set(row3.planStub, [...planCi.get(row3.planStub) ?? [], row3]);
+  return reports.map((report) => {
+    const offer = rows2.offers.get(report.sessionId);
+    return {
+      sessionId: report.sessionId,
+      planStub: report.planStub,
+      taskLine: report.taskLine,
+      outcome: report.outcome,
+      skillsUsed: bareNames(report.skillsUsed),
+      resolver: offer?.resolver ?? null,
+      skillsOffered: offer?.skillsOffered ?? null,
+      lessonsOffered: offer?.lessonsOffered ?? null,
+      invoked: invoked.get(report.sessionId) ?? [],
+      findings: rows2.findings.get(report.sessionId) ?? [],
+      blockers: rows2.blockers.get(report.sessionId) ?? [],
+      outOfScopeBugs: rows2.outOfScopeBugs.get(report.sessionId) ?? [],
+      planCi: report.planStub === null ? [] : planCi.get(report.planStub) ?? []
+    };
+  });
+}
+var SELECT_OFFERS = "SELECT session_id, resolver, skills_offered, lessons_offered FROM dispatches ORDER BY seq", SELECT_FINDINGS2 = `
+  SELECT session_id, kind, trigger, what, cause, resolution, artifact, signal
+  FROM findings
+  ORDER BY seq
+`;
+var init_skill_facts = __esm(() => {
+  init_skill_names();
+  init_plan_ci();
+  init_reports();
+  init_skill_invocations();
+  init_sqlite();
+});
+
+// src/effort/skill-signals.ts
+function invokedNames(fact) {
+  return fact.invoked === UNKNOWN_SKILL_COUNT ? [] : fact.invoked.map(({ name: name2 }) => name2);
+}
+function unique(names) {
+  return [...new Set(names)];
+}
+function rowsWhere(facts, holds) {
+  return facts.filter(holds).length;
+}
+function indicesWhere(facts, holds) {
+  return facts.flatMap((fact, index) => holds(fact) ? [index] : []);
+}
+function recurrencesFrom(strings, facts, from, match) {
+  if (strings.length === 0)
+    return { recurred: 0, matches: [] };
+  const found = from.map((index) => match(strings, facts, index, facts[index]?.planCi ?? []));
+  const matches = new Map;
+  for (const recurrence of found.flat()) {
+    const { string, source, sessionId, field: field5, text: text2 } = recurrence;
+    const key = JSON.stringify([string, source, sessionId, field5, text2]);
+    if (!matches.has(key))
+      matches.set(key, recurrence);
+  }
+  return {
+    recurred: found.filter((answer3) => answer3.length > 0).length,
+    matches: [...matches.values()]
+  };
+}
+function tallySkill(name2, facts, strings, match) {
+  const offers = (fact) => fact.skillsOffered?.includes(name2) ?? false;
+  const invokes = (fact) => invokedNames(fact).includes(name2);
+  return {
+    name: name2,
+    offered: rowsWhere(facts, offers),
+    invoked: rowsWhere(facts, invokes),
+    uptake: rowsWhere(facts, (fact) => offers(fact) && invokes(fact)),
+    reported: rowsWhere(facts, (fact) => fact.skillsUsed?.includes(name2) ?? false),
+    unknown: rowsWhere(facts, (fact) => offers(fact) && fact.invoked === UNKNOWN_SKILL_COUNT),
+    ...recurrencesFrom(strings, facts, indicesWhere(facts, invokes), match)
+  };
+}
+function skillSignalOf(tally2, declared) {
+  if (tally2.recurred > 0)
+    return "recurring";
+  if (tally2.invoked > 0 && !declared)
+    return "unmeasured";
+  if (tally2.invoked > 0)
+    return "earning";
+  if (tally2.unknown > 0)
+    return null;
+  return "ignored";
+}
+function skillSignals(facts, match, failureStrings) {
+  const names = unique(facts.flatMap((fact) => [...fact.skillsOffered ?? [], ...invokedNames(fact)]));
+  const tallies = names.map((name2) => tallySkill(name2, facts, failureStrings.get(name2) ?? [], match));
+  return {
+    skills: tallies.filter(({ offered: offered2 }) => offered2 > 0).map((tally2) => ({
+      ...tally2,
+      signal: skillSignalOf(tally2, (failureStrings.get(tally2.name) ?? []).length > 0)
+    })),
+    neverOffered: tallies.filter(({ offered: offered2 }) => offered2 === 0)
+  };
+}
+function lessonSignals(facts, match, artifacts) {
+  const ids = unique(facts.flatMap((fact) => fact.lessonsOffered ?? []));
+  return ids.map((id) => {
+    const artifact = artifacts.get(id) ?? null;
+    const injects = (fact) => fact.lessonsOffered?.includes(id) ?? false;
+    const found = recurrencesFrom(artifact === null ? [] : [artifact], facts, indicesWhere(facts, injects), match);
+    return {
+      id,
+      artifact,
+      injected: rowsWhere(facts, injects),
+      ...found,
+      signal: found.recurred > 0 ? "injected-recurring" : "injected"
+    };
+  });
+}
+var init_skill_signals = __esm(() => {
+  init_skill_invocations();
+});
+
+// src/effort/report-skills.ts
+import { readFileSync as readFileSync33 } from "fs";
+function readTextFile2(path4) {
+  try {
+    return readFileSync33(path4, "utf8");
+  } catch {
+    return null;
+  }
+}
+function declaredStrings(text2) {
+  const data = text2 === null ? null : readFrontmatter(text2);
+  const value = data?.[FAILURE_STRINGS_KEY];
+  if (!Array.isArray(value))
+    return [];
+  return value.filter((entry) => typeof entry === "string" && entry !== "");
+}
+function failureStringsOf(resolution, readText7 = readTextFile2) {
+  const declared = new Map;
+  for (const item of resolution.items) {
+    if (item.kind !== "skill" || item.state !== "served")
+      continue;
+    const strings = declaredStrings(readText7(item.winner.path));
+    if (strings.length > 0)
+      declared.set(item.name, strings);
+  }
+  return declared;
+}
+function lessonArtifactsOf(lessons) {
+  const artifacts = new Map;
+  const seen = new Set;
+  for (const { id, artifact } of lessons) {
+    if (seen.has(id))
+      continue;
+    seen.add(id);
+    if (artifact !== null)
+      artifacts.set(id, artifact);
+  }
+  return artifacts;
+}
+function readHeldLessons(seams) {
+  return readScopes(seams).flatMap((listing2) => listing2.records.flatMap(({ instinct }) => instinct === null ? [] : [{ id: instinct.id, artifact: instinct.artifact }]));
+}
+function groupBy(values, key) {
+  const groups = new Map;
+  for (const value of values) {
+    const group = groups.get(key(value)) ?? [];
+    groups.set(key(value), [...group, value]);
+  }
+  return groups;
+}
+function metric(numerator, denominator) {
+  return {
+    numerator,
+    denominator,
+    percent: denominator === 0 ? null : numerator / denominator * 100
+  };
+}
+function invokedNames2(fact) {
+  return fact.invoked === UNKNOWN_SKILL_COUNT ? [] : [...new Set(fact.invoked.map(({ name: name2 }) => name2))];
+}
+function m1Of(known) {
+  const pairs = new Set(known.flatMap((fact) => invokedNames2(fact).map((name2) => JSON.stringify([fact.taskLine, name2]))));
+  return metric(pairs.size, new Set(known.map(({ taskLine: taskLine2 }) => taskLine2)).size);
+}
+function m2Of(known) {
+  const offered2 = known.flatMap((fact) => [...new Set(fact.skillsOffered ?? [])].map((name2) => ({ fact, name: name2 })));
+  const taken = offered2.filter(({ fact, name: name2 }) => invokedNames2(fact).includes(name2));
+  return metric(taken.length, offered2.length);
+}
+function planMatcher(planFacts) {
+  const indices = new Map(planFacts.map((fact, index) => [fact, index]));
+  return (strings, facts, fromIndex, planCi) => {
+    const row3 = facts[fromIndex];
+    const index = row3 === undefined ? undefined : indices.get(row3);
+    if (index === undefined) {
+      throw new RangeError(`skills report: fromIndex ${fromIndex} is not a row of the plan's ${planFacts.length}`);
+    }
+    return findRecurrences(strings, planFacts, index, planCi);
+  };
+}
+function armOf(resolver, facts, match, failureStrings, artifacts) {
+  const known = facts.filter((fact) => fact.invoked !== UNKNOWN_SKILL_COUNT);
+  const { skills, neverOffered } = skillSignals(facts, match, failureStrings);
+  return {
+    resolver,
+    sessions: facts.length,
+    unknownSessions: facts.length - known.length,
+    skills,
+    neverOffered,
+    lessons: lessonSignals(facts, match, artifacts),
+    m1: m1Of(known),
+    m2: m2Of(known)
+  };
+}
+function latestReading(readings) {
+  return readings.reduce((latest, reading2) => latest === null || reading2.readAt >= latest.readAt ? reading2 : latest, null);
+}
+function skillsReportOf(facts, failureStrings, artifacts) {
+  const plans = [...groupBy(facts, ({ planStub: planStub2 }) => planStub2)].map(([planStub2, planFacts]) => {
+    const match = planMatcher(planFacts);
+    const arms = [...groupBy(planFacts, ({ resolver }) => resolver)];
+    return {
+      planStub: planStub2,
+      sessions: planFacts.length,
+      planCi: latestReading(planFacts[0]?.planCi ?? []),
+      resolvers: arms.map(([resolver, armFacts]) => armOf(resolver, armFacts, match, failureStrings, artifacts))
+    };
+  });
+  return { plans };
+}
+function buildSkillsReport(input) {
+  const facts = readSkillFacts(input.repoRoot, input.plans);
+  return skillsReportOf(facts, failureStringsOf(input.resolution, input.readText ?? readTextFile2), lessonArtifactsOf(input.lessons));
+}
+var FAILURE_STRINGS_KEY = "failure_strings";
+var init_report_skills = __esm(() => {
+  init_instinct_records();
+  init_recurrence();
+  init_skill_facts();
+  init_skill_signals();
+  init_skill_invocations();
+});
+
 // src/effort/report.ts
 import { homedir as homedir5 } from "os";
 function asReportRows(rows2) {
@@ -26270,47 +27048,6 @@ function summariseSessions(rows2, filters = { kinds: null, entrypoints: null },
     budgets: budgetedSessions(rows2, budgets)
   };
 }
-function splitList(raw) {
-  return raw.split(",").map((part) => part.trim()).filter((part) => part.length > 0);
-}
-function asSessionKind(value) {
-  return SESSION_KINDS.find((kind) => kind === value) ?? null;
-}
-function parseReportArgs(args) {
-  const errors = [];
-  const kinds = [];
-  const entrypoints = [];
-  let json = false;
-  for (const arg of args) {
-    if (arg === "--json") {
-      json = true;
-    } else if (arg === "--kind" || arg === "--entrypoint") {
-      errors.push(`${arg} takes a value, as ${arg}=<value>`);
-    } else if (arg.startsWith("--kind=")) {
-      for (const value of splitList(arg.slice("--kind=".length))) {
-        const kind = asSessionKind(value);
-        if (kind === null) {
-          errors.push(`--kind value is not a session kind: ${value}` + ` (one of ${SESSION_KINDS.join(", ")})`);
-        } else if (!kinds.includes(kind)) {
-          kinds.push(kind);
-        }
-      }
-    } else if (arg.startsWith("--entrypoint=")) {
-      for (const value of splitList(arg.slice("--entrypoint=".length))) {
-        if (!entrypoints.includes(value))
-          entrypoints.push(value);
-      }
-    } else {
-      errors.push(`unrecognised argument: ${arg}`);
-    }
-  }
-  return {
-    json,
-    kinds: kinds.length === 0 ? null : kinds,
-    entrypoints: entrypoints.length === 0 ? null : entrypoints,
-    errors
-  };
-}
 function resolveStore(store, roots) {
   if (store !== undefined)
     return store;
@@ -26325,14 +27062,50 @@ function buildReport(options) {
     entrypoints: options.entrypoints ?? null
   }, readTaskReportTallies(repoRoot), readPreflightHalts(repoRoot), readSessionBudgets(repoRoot));
 }
+function readSkillsReport(options) {
+  const { repoRoot: root, home, entry } = options;
+  const { config } = loadConfig({ root, home });
+  const pinned = entry === undefined ? {} : { entry };
+  return buildSkillsReport({
+    repoRoot: root,
+    ...options.plans === null || options.plans === undefined ? {} : { plans: options.plans },
+    resolution: resolveSessionTiers({ root, home, settings: config, ...pinned }),
+    lessons: readHeldLessons({ home, projectRoot: root, ...pinned })
+  });
+}
 function refuse4(problems) {
   throw new CommandExit(1, problems.map((problem) => `rafa effort report: ${problem}`).join(`
 `));
 }
+function writeSkillsReport(plans, json, repoRoot) {
+  let built;
+  try {
+    built = readSkillsReport({ repoRoot, home: homedir5(), plans });
+  } catch (error) {
+    if (!(error instanceof ConfigError))
+      throw error;
+    refuse4(error.problems);
+  }
+  const output = activeOutput();
+  if (activeOutputMode() === "json") {
+    output.result(built);
+    return;
+  }
+  if (json) {
+    output.info(JSON.stringify(built, null, 2));
+    return;
+  }
+  for (const line of formatSkillsReport(built))
+    output.info(line);
+}
 async function report(args, repoRoot) {
   const parsed = parseReportArgs(args);
   if (parsed.errors.length > 0)
     refuse4(parsed.errors);
+  if (parsed.skills) {
+    writeSkillsReport(parsed.plans, parsed.json, repoRoot);
+    return;
+  }
   let built;
   try {
     built = buildReport({
@@ -26372,9 +27145,13 @@ var init_report = __esm(() => {
   init_command();
   init_config_load();
   init_config();
+  init_serving();
   init_classify();
   init_commits();
+  init_report_args();
   init_report_format();
+  init_report_skills_format();
+  init_report_skills();
   init_dispatches();
   init_store2();
   init_preflight();
@@ -26394,7 +27171,7 @@ var init_report2 = __esm(() => {
     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: [
       {
@@ -26407,6 +27184,16 @@ var init_report2 = __esm(() => {
         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.",
@@ -26419,6 +27206,10 @@ var init_report2 = __esm(() => {
         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."
@@ -26429,12 +27220,12 @@ var init_report2 = __esm(() => {
 });
 
 // src/agents/vendorable.ts
-import { readdirSync as readdirSync10, readFileSync as readFileSync33 } from "fs";
+import { readdirSync as readdirSync11, readFileSync as readFileSync34 } from "fs";
 import { isAbsolute as isAbsolute10, join as join41 } from "path";
 function planFiles(dir) {
   let entries;
   try {
-    entries = readdirSync10(dir, { withFileTypes: true });
+    entries = readdirSync11(dir, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -26442,7 +27233,7 @@ function planFiles(dir) {
 }
 function readText7(path4) {
   try {
-    return readFileSync33(path4, "utf8");
+    return readFileSync34(path4, "utf8");
   } catch {
     return null;
   }
@@ -26491,7 +27282,7 @@ var init_vendorable = __esm(() => {
 
 // src/project/gitignore.ts
 import { createHash as createHash5 } from "crypto";
-import { existsSync as existsSync29, mkdirSync as mkdirSync11, readFileSync as readFileSync34, writeFileSync as writeFileSync10 } from "fs";
+import { existsSync as existsSync31, mkdirSync as mkdirSync11, readFileSync as readFileSync35, writeFileSync as writeFileSync10 } from "fs";
 import { dirname as dirname15, isAbsolute as isAbsolute11, join as join42 } from "path";
 function trackingEntry(flags) {
   if (flags.trackingAll) {
@@ -26561,9 +27352,9 @@ function attempt2(file, failure6, act) {
   }
 }
 function readIfPresent4(file) {
-  if (!existsSync29(file))
+  if (!existsSync31(file))
     return null;
-  return attempt2(file, "cannot be read", () => readFileSync34(file, "utf8"));
+  return attempt2(file, "cannot be read", () => readFileSync35(file, "utf8"));
 }
 function writeTrackingGitignore(root, flags) {
   requireAbsolute2(root);
@@ -26640,8 +27431,8 @@ var init_gitignore = __esm(() => {
 
 // src/project/roots.ts
 import { spawnSync as spawnSync4 } from "child_process";
-import { accessSync, constants, readFileSync as readFileSync35, statSync as statSync19 } from "fs";
-import { isAbsolute as isAbsolute12, join as join43, resolve as resolve17 } from "path";
+import { accessSync, constants, readFileSync as readFileSync36, statSync as statSync19 } from "fs";
+import { isAbsolute as isAbsolute12, join as join43, resolve as resolve18 } from "path";
 function gitToplevel(dir) {
   const result = spawnSync4("git", ["rev-parse", "--show-toplevel"], {
     cwd: dir,
@@ -26674,7 +27465,7 @@ function realOrSpelled(path4, fs3) {
   try {
     return fs3.realpath(path4);
   } catch {
-    return resolve17(path4);
+    return resolve18(path4);
   }
 }
 function namedRoots(home, fs3) {
@@ -26716,7 +27507,7 @@ function writeRefusal(given, real, fs3) {
 }
 function refusalOf2(given, named, fs3) {
   const resolved = resolveReal(given, fs3);
-  const byName2 = namedRefusal(given, resolved.real ?? resolve17(given), named);
+  const byName2 = namedRefusal(given, resolved.real ?? resolve18(given), named);
   if (byName2 !== null)
     return byName2;
   if (resolved.real === null) {
@@ -26797,7 +27588,7 @@ var init_roots = __esm(() => {
   ]);
   DISK_ROOTS_FILE_SYSTEM = Object.freeze({
     ...DISK_FILE_SYSTEM,
-    readFile: (path4) => readFileSync35(path4, "utf8"),
+    readFile: (path4) => readFileSync36(path4, "utf8"),
     isDirectory: (path4) => statSync19(path4).isDirectory(),
     assertWritable: (path4) => accessSync(path4, constants.W_OK)
   });
@@ -26810,7 +27601,7 @@ var init_roots = __esm(() => {
 });
 
 // src/project/root-choice.ts
-import { resolve as resolve18 } from "path";
+import { resolve as resolve19 } from "path";
 function chosen(path4, source) {
   return { root: { path: path4, source }, problem: null };
 }
@@ -26843,7 +27634,7 @@ function firstCandidate(found) {
   return first.refusal === null ? chosen(first.path, first.source) : problem(first.refusal.reason);
 }
 function namedRoot(typed, start, source, seams) {
-  const path4 = resolve18(start, typed);
+  const path4 = resolve19(start, typed);
   const refusal5 = rootRefusal(path4, seams);
   if (refusal5 !== null)
     return problem(refusal5.reason);
@@ -26893,7 +27684,7 @@ var init_root_choice = __esm(() => {
 });
 
 // src/project/scaffold.ts
-import { existsSync as existsSync30, lstatSync as lstatSync2, mkdirSync as mkdirSync12, statSync as statSync20, writeFileSync as writeFileSync11 } from "fs";
+import { existsSync as existsSync32, lstatSync as lstatSync2, mkdirSync as mkdirSync12, statSync as statSync20, writeFileSync as writeFileSync11 } from "fs";
 import { join as join44 } from "path";
 function configText(header) {
   return [...header, VERSION_LINE, ...CONFIG_SETTINGS_LINES, ""].join(`
@@ -26918,7 +27709,7 @@ function isDirectory2(path4) {
 function directoryConflict(dir) {
   if (!occupied(dir) || isDirectory2(dir))
     return null;
-  return existsSync30(dir) ? `${dir} is not a directory` : `${dir} is a link to nothing`;
+  return existsSync32(dir) ? `${dir} is not a directory` : `${dir} is a link to nothing`;
 }
 function layoutConflicts(layout) {
   const [scopeDir, ...tree] = layout.dirs;
@@ -26926,7 +27717,7 @@ function layoutConflicts(layout) {
   if (opening !== null)
     return [opening];
   const dirs = tree.flatMap((dir) => directoryConflict(dir) ?? []);
-  const file = occupied(layout.configFile) && !existsSync30(layout.configFile) ? [`${layout.configFile} is a link to nothing`] : [];
+  const file = occupied(layout.configFile) && !existsSync32(layout.configFile) ? [`${layout.configFile} is a link to nothing`] : [];
   return [...dirs, ...file];
 }
 function scaffoldConflicts(root, home) {
@@ -26940,7 +27731,7 @@ function attempt3(path4, failure6, act) {
   }
 }
 function ensureDirectory(path4) {
-  if (existsSync30(path4))
+  if (existsSync32(path4))
     return { path: path4, kind: "directory", change: "unchanged" };
   attempt3(path4, "cannot be created", () => {
     mkdirSync12(path4, { recursive: true });
@@ -26948,7 +27739,7 @@ function ensureDirectory(path4) {
   return { path: path4, kind: "directory", change: "created" };
 }
 function ensureFile(path4, text2) {
-  if (existsSync30(path4))
+  if (existsSync32(path4))
     return { path: path4, kind: "file", change: "unchanged" };
   attempt3(path4, "cannot be written", () => {
     writeFileSync11(path4, text2, { encoding: "utf8", flag: "wx" });
@@ -27063,7 +27854,7 @@ var init_scaffold = __esm(() => {
 
 // src/release/enabled.ts
 import { statSync as statSync21 } from "fs";
-import { resolve as resolve19 } from "path";
+import { resolve as resolve20 } from "path";
 function isRegularFile(full) {
   try {
     return statSync21(full).isFile();
@@ -27072,7 +27863,7 @@ function isRegularFile(full) {
   }
 }
 function readFile5(repoRoot, path4) {
-  const resolved = resolve19(repoRoot, path4);
+  const resolved = resolve20(repoRoot, path4);
   return { path: path4, resolved, present: isRegularFile(resolved) };
 }
 function resolveReleaseEnabled(settings, repoRoot) {
@@ -27093,7 +27884,7 @@ var init_enabled = __esm(() => {
 });
 
 // src/release/setting.ts
-import { readFileSync as readFileSync36 } from "fs";
+import { readFileSync as readFileSync37 } from "fs";
 function releaseEnabledIn(text2, path4) {
   return parseConfigText(text2, path4).values.releaseEnabled ?? null;
 }
@@ -27101,7 +27892,7 @@ function readReleaseSetting(root) {
   const path4 = configFilePath(root);
   let text2;
   try {
-    text2 = readFileSync36(path4, "utf8");
+    text2 = readFileSync37(path4, "utf8");
   } catch (error) {
     return { enabled: null, text: "", problem: `${path4} could not be read: ${messageOf(error)}` };
   }
@@ -27281,7 +28072,7 @@ var init_init_release = __esm(() => {
 });
 
 // src/commands/init.ts
-import { existsSync as existsSync31, readFileSync as readFileSync37 } from "fs";
+import { existsSync as existsSync33, readFileSync as readFileSync38 } from "fs";
 import { homedir as homedir6 } from "os";
 import { join as join45, relative as relative11, sep as sep4 } from "path";
 function refusal5(lines2) {
@@ -27374,7 +28165,7 @@ function resolvedConfig3(root, home, warn) {
 function checkGitignore(root, flags) {
   const file = join45(root, GITIGNORE_FILE);
   try {
-    const text2 = existsSync31(file) ? readFileSync37(file, "utf8") : null;
+    const text2 = existsSync33(file) ? readFileSync38(file, "utf8") : null;
     withTrackingBlock(text2, flags, file);
   } catch (error) {
     const message = error instanceof GitignoreError ? error.message : `rafa init: ${file} cannot be read (${messageOf(error)})`;
@@ -27405,8 +28196,8 @@ function initialise(root, start, home, context, entry) {
   checkConflicts(root.path, home);
   const config = resolvedConfig3(root.path, home, warn);
   checkGitignore(root.path, config);
-  const configExisted = existsSync31(configFilePath(root.path));
-  const digestExisted = existsSync31(join45(root.path, TRACKING_DIGEST_FILE));
+  const configExisted = existsSync33(configFilePath(root.path));
+  const digestExisted = existsSync33(join45(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)];
@@ -27597,7 +28388,7 @@ var init_init = __esm(() => {
 });
 
 // src/commands/check-report.ts
-import { resolve as resolve20 } from "path";
+import { resolve as resolve21 } from "path";
 function readCheckDirectory(args, usage, cwd) {
   const [dir, extra] = args;
   if (dir === undefined) {
@@ -27608,7 +28399,7 @@ Usage: ${usage}`);
     throw new CommandExit(1, `\u274C Expected one directory, and read "${extra}" as a second
 Usage: ${usage}`);
   }
-  return resolve20(cwd(), dir);
+  return resolve21(cwd(), dir);
 }
 function readFix(value, usage) {
   if (value === undefined || value === false || value === "false")
@@ -27625,7 +28416,7 @@ function readProjectRoot(value, usage, cwd) {
     throw new CommandExit(1, `\u274C --project needs a path, and the line gave it none
 Usage: ${usage}`);
   }
-  return resolve20(cwd(), value);
+  return resolve21(cwd(), value);
 }
 function reportMarker(report2) {
   if (report2.failed)
@@ -28297,8 +29088,8 @@ var init_show3 = __esm(() => {
 });
 
 // src/commands/issue/check.ts
-import { readdirSync as readdirSync11, readFileSync as readFileSync38, statSync as statSync22 } from "fs";
-import { join as join46, resolve as resolve21 } from "path";
+import { readdirSync as readdirSync12, readFileSync as readFileSync39, statSync as statSync22 } from "fs";
+import { join as join46, resolve as resolve22 } from "path";
 function readCheckIssue(args) {
   if (args.length > 1) {
     throw lineRefusal2(`Expected one issue number, got ${String(args.length)}: ${args.join(" ")}`, CHECK_USAGE);
@@ -28318,7 +29109,7 @@ function missingCopyMessage(issue4, specsDir) {
 function copyNames(dir, issue4) {
   let names;
   try {
-    names = readdirSync11(dir);
+    names = readdirSync12(dir);
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === "ENOENT")
       return [];
@@ -28329,7 +29120,7 @@ function copyNames(dir, issue4) {
   return names.filter((name2) => name2.startsWith(prefix) && name2.endsWith(SPEC_EXTENSION) && name2 !== notes).filter((name2) => name2.length > prefix.length + SPEC_EXTENSION.length).filter((name2) => statSync22(join46(dir, name2)).isFile()).sort();
 }
 function findSavedCopy(root, specsDir, issue4) {
-  const names = copyNames(resolve21(root, specsDir), issue4);
+  const names = copyNames(resolve22(root, specsDir), issue4);
   const [only] = names;
   if (only === undefined)
     throw new CommandExit(1, missingCopyMessage(issue4, specsDir));
@@ -28341,7 +29132,7 @@ function findSavedCopy(root, specsDir, issue4) {
 `));
   }
   const path4 = join46(specsDir, only);
-  return { path: path4, absolute: resolve21(root, path4) };
+  return { path: path4, absolute: resolve22(root, path4) };
 }
 function liveText(live) {
   return live.kind === "unreadable" ? "unreadable" : fingerprintText(live);
@@ -28389,7 +29180,7 @@ async function readReferences(absolute, issue4, verify, stamp2) {
     return rows2.map((row3) => checkedRef(row3, row3.stamp));
   }
   const once2 = memoiseVerifier(verify);
-  const before = await readRefsText({ copy: readFileSync38(absolute, "utf8"), issue: issue4, verify: once2 });
+  const before = await readRefsText({ copy: readFileSync39(absolute, "utf8"), issue: issue4, verify: once2 });
   const after = await restampCopyRefs({ path: absolute, issue: issue4, verify: once2 });
   return before.rows.map((row3, index) => checkedRef(row3, after.rows[index]?.stamp ?? null));
 }
@@ -28541,7 +29332,7 @@ var init_comment = __esm(() => {
 
 // src/effort/store/tracker-refs.ts
 import { randomUUID as randomUUID9 } from "crypto";
-import { existsSync as existsSync32 } from "fs";
+import { existsSync as existsSync34 } from "fs";
 function refused3(call, reason) {
   return new Error(`effort store: tracker ref ${call} ${reason}; ${REFUSAL_TAILS[call]}`);
 }
@@ -28636,7 +29427,7 @@ function writeTrackerRef(repoRoot, write, seams = {}) {
     wanted.json,
     collectedAt
   ];
-  const [action, stored] = withSqliteStore(path4, !existsSync32(path4), (db) => {
+  const [action, stored] = withSqliteStore(path4, !existsSync34(path4), (db) => {
     const place2 = db.transaction(() => placeRef(db, path4, write, wanted, insertValues));
     return place2.immediate();
   });
@@ -28645,7 +29436,7 @@ function writeTrackerRef(repoRoot, write, seams = {}) {
 function readTrackerRef(repoRoot, artifact) {
   checkArtifact2("read", artifact);
   const path4 = sqliteStorePath(repoRoot);
-  if (!existsSync32(path4))
+  if (!existsSync34(path4))
     return null;
   const oldest = withSqliteStore(path4, false, (db) => db.query(SELECT_OLDEST).get(artifact));
   return oldest === null ? null : heldRefOf(path4, oldest.seq, oldest.tracker_ref).ref;
@@ -29184,14 +29975,14 @@ var init_roadmap_board = __esm(() => {
 });
 
 // src/board/roadmap-rows.ts
-import { readdirSync as readdirSync12 } from "fs";
+import { readdirSync as readdirSync13 } from "fs";
 function isMissing2(error) {
   return error instanceof Error && "code" in error && error.code === "ENOENT";
 }
 function createPlanDirNames(dir) {
   return () => {
     try {
-      return Object.freeze(readdirSync12(dir));
+      return Object.freeze(readdirSync13(dir));
     } catch (error) {
       if (isMissing2(error))
         return Object.freeze([]);
@@ -29302,7 +30093,7 @@ function viewOf3(issues) {
     known: new Set(issues.map((issue4) => issue4.number))
   };
 }
-function rowOf4(line, board, has, refs) {
+function rowOf5(line, board, has, refs) {
   const issue4 = board?.byNumber.get(line.issue);
   if (board === null || issue4 === undefined) {
     return Object.freeze({ line, issue: null, spec: null, blocked: null, blockers: Object.freeze([]), has, refs });
@@ -29329,7 +30120,7 @@ async function readRoadmapRows2(options) {
   const refs = await readOrWarn(() => options.refs(issues), new Map, "the saved copies could not be read, so the refs column is empty");
   const board = viewOf3(listed3.issues);
   const sources = { planNames: plans.value, refs: scan2.refs, pulls: pulls.value };
-  const rows2 = lines2.map((line) => rowOf4(line, board, readHasColumn(line.issue, sources), refs.value.get(line.issue) ?? null));
+  const rows2 = lines2.map((line) => rowOf5(line, board, readHasColumn(line.issue, sources), refs.value.get(line.issue) ?? null));
   const warnings = [listed3.warning, ...scan2.problems, pulls.warning, plans.warning, refs.warning, ...refsWarnings(refs.value)].filter((warning) => warning !== null);
   return Object.freeze({ roadmap, rows: Object.freeze(rows2), warnings: Object.freeze(warnings) });
 }
@@ -30663,9 +31454,9 @@ var init_run_config = __esm(() => {
 });
 
 // src/start/runtime.ts
-import { existsSync as existsSync33, readdirSync as readdirSync13, realpathSync as realpathSync8, statSync as statSync23 } from "fs";
+import { existsSync as existsSync35, readdirSync as readdirSync14, realpathSync as realpathSync8, statSync as statSync23 } from "fs";
 import { homedir as homedir7 } from "os";
-import { isAbsolute as isAbsolute13, join as join48, relative as relative13, resolve as resolve22, sep as sep5 } from "path";
+import { isAbsolute as isAbsolute13, join as join48, relative as relative13, resolve as resolve23, sep as sep5 } from "path";
 function runtimeFlagValue(args) {
   return args.includes(RUNTIME_FLAG) ? "" : argValue(args, RUNTIME_FLAG);
 }
@@ -30687,14 +31478,14 @@ function resolveRuntime(value, places) {
     throw refusal6([`\u274C Refusing to start: \`--runtime\` names no runtime. Spell it ${SPELLING}.`]);
   }
   const isVersion = VERSION_SHAPE.test(value);
-  const named = isVersion ? join48(places.home, RUNTIME_SUBDIR, value, RUNTIME_ENTRY) : resolve22(places.cwd, value);
+  const named = isVersion ? join48(places.home, RUNTIME_SUBDIR, value, RUNTIME_ENTRY) : resolve23(places.cwd, value);
   refuseInsideSource(value, named, places);
-  const entry = entryOf(value, named, isVersion, places.home);
+  const entry = entryOf2(value, named, isVersion, places.home);
   const real = realpathSync8(entry);
   refuseInsideSource(value, real, places);
   return real;
 }
-function entryOf(value, named, isVersion, home) {
+function entryOf2(value, named, isVersion, home) {
   if (isVersion) {
     if (isFile3(named))
       return named;
@@ -30726,7 +31517,7 @@ function refuseInsideSource(value, path4, places) {
 }
 function sourceDirs({ cwd, root }) {
   const dirs = [join48(cwd, SOURCE_DIR), join48(root, SOURCE_DIR)];
-  const real = dirs.filter((dir) => existsSync33(dir)).map((dir) => realpathSync8(dir));
+  const real = dirs.filter((dir) => existsSync35(dir)).map((dir) => realpathSync8(dir));
   return [...new Set([...dirs, ...real])];
 }
 function isInside3(path4, dir) {
@@ -30735,7 +31526,7 @@ function isInside3(path4, dir) {
 }
 function installedVersions(root) {
   try {
-    return readdirSync13(root).filter((name2) => isFile3(join48(root, name2, RUNTIME_ENTRY))).sort((a, b) => a.localeCompare(b));
+    return readdirSync14(root).filter((name2) => isFile3(join48(root, name2, RUNTIME_ENTRY))).sort((a, b) => a.localeCompare(b));
   } catch {
     return [];
   }
@@ -30780,7 +31571,7 @@ function realOrResolved(path4) {
   try {
     return realpathSync8(path4);
   } catch {
-    return resolve22(path4);
+    return resolve23(path4);
   }
 }
 async function runRuntime(entry, words, run) {
@@ -30877,7 +31668,7 @@ var init_runtime = __esm(() => {
 });
 
 // src/notices/notices.ts
-import { mkdirSync as mkdirSync13, readFileSync as readFileSync39, writeFileSync as writeFileSync13 } from "fs";
+import { mkdirSync as mkdirSync13, readFileSync as readFileSync40, writeFileSync as writeFileSync13 } from "fs";
 import { dirname as dirname16, join as join49 } from "path";
 function noticesPath(home) {
   return join49(home, ".rafa", "notices.json");
@@ -30888,7 +31679,7 @@ function isNoticeId(value) {
 function readDismissed(home) {
   let raw;
   try {
-    raw = readFileSync39(noticesPath(home), "utf8");
+    raw = readFileSync40(noticesPath(home), "utf8");
   } catch {
     return [];
   }
@@ -31729,7 +32520,7 @@ var init_level = __esm(() => {
 });
 
 // src/release/version.ts
-import { readFileSync as readFileSync40, writeFileSync as writeFileSync14 } from "fs";
+import { readFileSync as readFileSync41, writeFileSync as writeFileSync14 } from "fs";
 function parseSemanticVersion(raw) {
   const found = VERSION_SHAPE2.exec(raw);
   if (found === null)
@@ -31817,7 +32608,7 @@ function writeManifestVersion(path4, next) {
   const unwritten = { path: path4, written: false, previous: null, version: next };
   let text2;
   try {
-    text2 = readFileSync40(path4, "utf8");
+    text2 = readFileSync41(path4, "utf8");
   } catch (error) {
     return { ...unwritten, problem: `${path4} could not be read: ${messageOf(error)}` };
   }
@@ -31872,7 +32663,7 @@ var init_version2 = __esm(() => {
 });
 
 // src/release/prepare.ts
-import { readFileSync as readFileSync41, writeFileSync as writeFileSync15 } from "fs";
+import { readFileSync as readFileSync42, writeFileSync as writeFileSync15 } from "fs";
 function levelFields(reading2) {
   return { level: reading2.level, levelSource: reading2.source, notesLevel: reading2.notesLevel };
 }
@@ -31928,7 +32719,7 @@ function planVersion(input, versionFile, level) {
 }
 function textOf(path4) {
   try {
-    return readFileSync41(path4, "utf8");
+    return readFileSync42(path4, "utf8");
   } catch {
     return null;
   }
@@ -32048,7 +32839,7 @@ var init_prepare = __esm(() => {
 });
 
 // src/release/verify.ts
-import { readFileSync as readFileSync42, writeFileSync as writeFileSync16 } from "fs";
+import { readFileSync as readFileSync43, writeFileSync as writeFileSync16 } from "fs";
 function changelogInsertionSpan(before, after) {
   const beforeLines = before.split(`
 `);
@@ -32065,7 +32856,7 @@ function changelogInsertionSpan(before, after) {
 }
 function textOf2(path4) {
   try {
-    return readFileSync42(path4, "utf8");
+    return readFileSync43(path4, "utf8");
   } catch {
     return null;
   }
@@ -32465,9 +33256,9 @@ function describeStartTriage(result) {
   };
 }
 async function resolvePublicTracker(options, redact) {
-  const resolve23 = options.resolve ?? resolveTracker;
+  const resolve24 = options.resolve ?? resolveTracker;
   try {
-    const { tracker, attempts } = await resolve23({
+    const { tracker, attempts } = await resolve24({
       config: options.config,
       context: { repoRoot: options.repoRoot }
     });
@@ -32877,7 +33668,7 @@ async function openPullRequestNumber(branch) {
     return null;
   }
 }
-function messageOf12(error) {
+function messageOf13(error) {
   return error instanceof Error ? error.message : String(error);
 }
 function wrapUpAdapter(learning) {
@@ -32898,7 +33689,7 @@ async function lessonsToPromote(learning) {
       minConfidence: learning.promoteMinConfidence
     });
   } catch (error) {
-    activeOutput().warn(`   The wrap-up lists no lesson to promote: the \`${learning.kind}\` learning adapter answered no blessed set: ${messageOf12(error)}`);
+    activeOutput().warn(`   The wrap-up lists no lesson to promote: the \`${learning.kind}\` learning adapter answered no blessed set: ${messageOf13(error)}`);
     return [];
   }
 }
@@ -32964,8 +33755,8 @@ function msUntil(startAt, now = new Date) {
   return target.getTime() - now.getTime();
 }
 function sleepFor(ms) {
-  return new Promise((resolve23) => {
-    setTimeout(resolve23, ms);
+  return new Promise((resolve24) => {
+    setTimeout(resolve24, ms);
   });
 }
 async function deferUntil(startAt, now = new Date, sleep = sleepFor) {
@@ -34459,8 +35250,8 @@ var init_create2 = __esm(() => {
 });
 
 // src/commands/plan/risk.ts
-import { readFileSync as readFileSync43 } from "fs";
-import { resolve as resolve23 } from "path";
+import { readFileSync as readFileSync44 } from "fs";
+import { resolve as resolve24 } from "path";
 function spawningRunners2(root) {
   return { git: createGitRunner(root), gh: createGhRunner({ cwd: root }) };
 }
@@ -34470,7 +35261,7 @@ function riskPlanPath(root, planDir, typed) {
     return path7;
   if (typed !== null)
     throw new CommandExit(1, `\u274C Plan file not found: ${path7}`);
-  const lookedFor = [...new Set([resolve23(root, planDir, DEFAULT_PLAN_FILE), resolve23(root, DEFAULT_PLAN_FILE)])];
+  const lookedFor = [...new Set([resolve24(root, planDir, DEFAULT_PLAN_FILE), resolve24(root, DEFAULT_PLAN_FILE)])];
   throw new CommandExit(1, `\u274C No plan named, and no default plan at ${lookedFor.join(" or ")}
 Usage: ${USAGE24}`);
 }
@@ -34484,7 +35275,7 @@ function strictRefusal(report2) {
 }
 async function readRisk(path7, project, config, context, seams) {
   const makeRunners = seams.runners ?? spawningRunners2;
-  return assessPlanRisk({ path: path7, text: readFileSync43(path7, "utf8") }, {
+  return assessPlanRisk({ path: path7, text: readFileSync44(path7, "utf8") }, {
     repoRoot: project.root,
     home: project.home,
     settingSources: config.settingSources,
@@ -34577,7 +35368,7 @@ var init_risk2 = __esm(() => {
 });
 
 // src/commands/plan/show.ts
-import { readFileSync as readFileSync44 } from "fs";
+import { readFileSync as readFileSync45 } from "fs";
 import { join as join50 } from "path";
 function readTrackerFlag(value) {
   if (value === undefined || value === false || value === "false")
@@ -34597,7 +35388,7 @@ function showPlan(plans, stub, tracker) {
   const file = join50(plans.path, name2);
   if (!isFile2(file))
     throw new CommandExit(1, missingText(stub, tracker, join50(plans.label, name2)));
-  const model = parsePlan(readFileSync44(file, "utf8"));
+  const model = parsePlan(readFileSync45(file, "utf8"));
   const { header } = model;
   return {
     stub,
@@ -34771,6 +35562,7 @@ function openPrContext(context, seams = DEFAULT_PR_SEAMS) {
     resolveBudget: config.prResolveBudget,
     trustedAuthors: config.boardTrustedAuthors,
     roadmapIssue: config.roadmapIssue,
+    planDir: config.planDir,
     readBranch: () => readBranch2(project.root)
   };
 }
@@ -34992,7 +35784,7 @@ async function probe(call) {
     return { value: null, problem: messageOf(error) };
   }
 }
-async function rowOf5(pulls, pull) {
+async function rowOf6(pulls, pull) {
   const [checks, detail] = await Promise.all([
     probe(() => pulls.checks(pull.number)),
     probe(() => pulls.get(pull.number))
@@ -35010,7 +35802,7 @@ async function readList2(context, seams, now) {
   expectNoArguments(context.args, USAGE27);
   const pr = openPrContext(context, seams);
   const open = await onProvider("list the open pull requests", () => pr.pulls.list());
-  const rows2 = await mapWithLimit(open, PROBE_LIMIT, (pull) => rowOf5(pr.pulls, pull));
+  const rows2 = await mapWithLimit(open, PROBE_LIMIT, (pull) => rowOf6(pr.pulls, pull));
   return { rows: rows2, text: renderList(rows2, now) };
 }
 function createPrListCommand(seams = DEFAULT_PR_SEAMS) {
@@ -35209,17 +36001,17 @@ var init_roadmap_tick = __esm(() => {
 import {
   chmodSync,
   copyFileSync as copyFileSync3,
-  existsSync as existsSync34,
+  existsSync as existsSync36,
   mkdirSync as mkdirSync14,
-  readdirSync as readdirSync14,
-  readFileSync as readFileSync45,
+  readdirSync as readdirSync15,
+  readFileSync as readFileSync46,
   realpathSync as realpathSync9,
   renameSync as renameSync4,
   rmSync as rmSync5,
   statSync as statSync24,
   symlinkSync
 } from "fs";
-import { basename as basename16, delimiter as delimiter4, dirname as dirname17, join as join51, relative as relative15, resolve as resolve24 } from "path";
+import { basename as basename16, delimiter as delimiter4, dirname as dirname17, join as join51, relative as relative15, resolve as resolve25 } from "path";
 function exitCodeFor(outcome2) {
   switch (outcome2.kind) {
     case "done":
@@ -35257,17 +36049,17 @@ function runtimeRefusalLines(runtimeDir, version2) {
   ];
 }
 function listTrackers(repoRoot, planDir) {
-  const dir = resolve24(repoRoot, planDir);
+  const dir = resolve25(repoRoot, planDir);
   return entryNames(dir).filter((entry) => TRACKER_NAME.test(entry)).sort((a, b) => a.localeCompare(b)).map((entry) => join51(dir, entry)).filter((path7) => statSync24(path7).isFile()).map((path7) => relative15(repoRoot, path7));
 }
 function openTrackers(repoRoot, planDir) {
   return listTrackers(repoRoot, planDir).flatMap((path7) => {
-    const task = findNextTask(readFileSync45(join51(repoRoot, path7), "utf8"));
+    const task = findNextTask(readFileSync46(join51(repoRoot, path7), "utf8"));
     return task ? [{ path: path7, task }] : [];
   });
 }
 function readManifestVersion2(repoRoot) {
-  const manifest = JSON.parse(readFileSync45(join51(repoRoot, "package.json"), "utf8"));
+  const manifest = JSON.parse(readFileSync46(join51(repoRoot, "package.json"), "utf8"));
   const record = typeof manifest === "object" && manifest !== null ? manifest : {};
   if (record["name"] !== name) {
     throw new Error(`${join51(repoRoot, "package.json")} names ${JSON.stringify(record["name"])}, not ${name}: this is no rafa checkout`);
@@ -35281,7 +36073,7 @@ function readManifestVersion2(repoRoot) {
 function copyTree(from, to) {
   mkdirSync14(to, { recursive: true });
   let copied = 0;
-  const entries = readdirSync14(from, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+  const entries = readdirSync15(from, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
   for (const entry of entries) {
     const source = join51(from, entry.name);
     const target = join51(to, entry.name);
@@ -35309,7 +36101,7 @@ function replaceTree(from, to) {
   }
 }
 function swapIn2(staging, to) {
-  if (!existsSync34(to)) {
+  if (!existsSync36(to)) {
     renameSync4(staging, to);
     return;
   }
@@ -35385,14 +36177,14 @@ function runInstall(seams, options) {
   log(`runtime root: ${runtimeRoot}`);
   log(`link: ${linkPath}`);
   const version2 = inStage("manifest", () => readManifestVersion2(repoRoot));
-  const planDir = inStage("config", () => resolve24(repoRoot, loadConfig({ root: repoRoot, home }, {}, seams.warn).config.planDir));
+  const planDir = inStage("config", () => resolve25(repoRoot, loadConfig({ root: repoRoot, home }, {}, seams.warn).config.planDir));
   log(`plan dir: ${planDir}`);
   const open = inStage("trackers", () => openTrackers(repoRoot, planDir));
   if (open.length > 0)
     return { kind: "refused", reason: "trackers", planDir, trackers: open };
   const distDir = join51(repoRoot, "dist");
   const runtimeDir = join51(runtimeRoot, version2);
-  const installed = existsSync34(runtimeDir);
+  const installed = existsSync36(runtimeDir);
   if (installed && options.force !== true) {
     return { kind: "refused", reason: "runtime-exists", version: version2, runtimeDir };
   }
@@ -35400,7 +36192,7 @@ function runInstall(seams, options) {
   const code = inStage("build", () => seams.build(repoRoot));
   if (code !== 0)
     throw new StageFailure("build", `the build exited ${code}`);
-  if (!existsSync34(join51(distDir, RUNTIME_ENTRY))) {
+  if (!existsSync36(join51(distDir, RUNTIME_ENTRY))) {
     throw new StageFailure("build", `the build exited 0 and left no ${join51(distDir, RUNTIME_ENTRY)}`);
   }
   log(installed ? `copying ${distDir} over ${runtimeDir}, replacing it whole` : `copying ${distDir} into ${runtimeDir}`);
@@ -35421,7 +36213,7 @@ function inStage(stage, run) {
 }
 function entryNames(dir) {
   try {
-    return readdirSync14(dir);
+    return readdirSync15(dir);
   } catch (err) {
     if (typeof err === "object" && err !== null && "code" in err && err.code === "ENOENT")
       return [];
@@ -35692,7 +36484,7 @@ var init_merge_unchecked = __esm(() => {
 });
 
 // src/commands/pr/merge.ts
-import { existsSync as existsSync35, readFileSync as readFileSync46 } from "fs";
+import { existsSync as existsSync37, readFileSync as readFileSync47 } from "fs";
 import { join as join52 } from "path";
 function refusal8(lines2) {
   return new CommandExit(1, lines2.join(`
@@ -35770,7 +36562,7 @@ function remoteHoldsBranch(git, branch, warn) {
 }
 function textOf3(path7) {
   try {
-    return readFileSync46(path7, "utf8");
+    return readFileSync47(path7, "utf8");
   } catch {
     return "";
   }
@@ -35784,7 +36576,7 @@ function followUpsFor(pr, git) {
     version: facts.version,
     tagged: tags.ok && tags.stdout.trim() !== "",
     rafaCheckout: facts.rafaCheckout,
-    runtimeInstalled: existsSync35(join52(pr.project.home, RUNTIME_SUBDIR, facts.version))
+    runtimeInstalled: existsSync37(join52(pr.project.home, RUNTIME_SUBDIR, facts.version))
   });
 }
 function openGh(pr, seams) {
@@ -35909,6 +36701,15 @@ async function runMerge(context, seams) {
     throw lineRefusal4(`No pull request #${pick.number} at ${pr.project.root}`, USAGE28);
   }
   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 answer4 = await askToMerge(context, pr, seams, { number: detail.number, summary, yes, skipChecks });
@@ -36030,6 +36831,7 @@ var init_merge3 = __esm(() => {
   init_roadmap_tick();
   init_command();
   init_confirm();
+  init_plan_ci();
   init_ending();
   init_pr();
   init_runtime();
@@ -37010,8 +37812,8 @@ function describeAge(updatedAt, now) {
     return `${plural6(hours, "hour", "hours")} ago`;
   return `${plural6(Math.floor(age / DAY_MS2), "day", "days")} ago`;
 }
-function triageCommand(number, resolve25 = false) {
-  return resolve25 ? `rafa pr triage ${number} --resolve` : `rafa pr triage ${number}`;
+function triageCommand(number, resolve26 = false) {
+  return resolve26 ? `rafa pr triage ${number} --resolve` : `rafa pr triage ${number}`;
 }
 function joinNumbers(pulls) {
   const names = pulls.map((pull) => `#${pull.number}`);
@@ -37022,14 +37824,14 @@ function joinNumbers(pulls) {
 function byNumber(pulls) {
   return Object.freeze([...pulls].sort((left, right) => left.number - right.number));
 }
-function skipped2(pull, now, resolve25) {
+function skipped2(pull, now, resolve26) {
   return Object.freeze({
     number: pull.number,
     title: pull.title,
     updatedAt: pull.updatedAt,
     age: describeAge(pull.updatedAt, now),
     fresh: isFreshCandidate(pull.updatedAt, now),
-    command: triageCommand(pull.number, resolve25)
+    command: triageCommand(pull.number, resolve26)
   });
 }
 function skippedLine(one) {
@@ -37073,15 +37875,15 @@ function listReading(rest, count2) {
   return listing2("list", Object.freeze([]), rest, headline);
 }
 function selectTriagePullRequests(input) {
-  const resolve25 = input.resolve === true;
+  const resolve26 = input.resolve === true;
   const { current, now } = input;
   if (current !== null) {
     return plain("branch", Object.freeze([current]), `assessing #${current.number}, the pull request open on ${current.headRefName}`);
   }
   const candidates = byNumber(input.candidates);
   const count2 = candidates.length;
-  const lines2 = candidates.map((pull) => skipped2(pull, now, resolve25));
-  if (resolve25 && count2 > 1)
+  const lines2 = candidates.map((pull) => skipped2(pull, now, resolve26));
+  if (resolve26 && count2 > 1)
     return refusal9(lines2, count2);
   if (count2 === 0) {
     return plain("none", Object.freeze([]), "no red pull request to triage, and no pull request on the current branch");
@@ -37442,7 +38244,7 @@ var init_budget2 = __esm(() => {
 });
 
 // src/pr/plans/load.ts
-import { existsSync as existsSync36, readFileSync as readFileSync47 } from "fs";
+import { existsSync as existsSync38, readFileSync as readFileSync48 } from "fs";
 import { dirname as dirname18, join as join53 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 function pinnedPlanFileName(triageClass) {
@@ -37463,11 +38265,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) => existsSync36(candidate));
+  const found = candidates.find((candidate) => existsSync38(candidate));
   if (found === undefined) {
     throw new Error(`The pinned resolve plan for ${triageClass} is missing: ` + `no file at ${candidates.join(" or ")}`);
   }
-  return readFileSync47(found, "utf8");
+  return readFileSync48(found, "utf8");
 }
 function fillPinnedPlan(template, values) {
   const missing2 = [];
@@ -38044,16 +38846,16 @@ async function redPullRequests(pr) {
   }
   return red;
 }
-async function selectTargets(pr, warn, now, resolve25) {
+async function selectTargets(pr, warn, now, resolve26) {
   const branch = readBranchOrNone(pr, warn);
   const current = branch === null ? null : await onProvider(`read the open pull request for the branch "${branch}"`, () => pr.pulls.findOpen(branch));
   if (current !== null)
-    return selectTriagePullRequests({ current, candidates: [], now, resolve: resolve25 });
+    return selectTriagePullRequests({ current, candidates: [], now, resolve: resolve26 });
   return selectTriagePullRequests({
     current: null,
     candidates: await redPullRequests(pr),
     now,
-    resolve: resolve25
+    resolve: resolve26
   });
 }
 async function detailOf12(pr, number) {
@@ -38115,6 +38917,14 @@ async function assessOne(options) {
   const { git, maxAttempts, number, pr } = options;
   const detail = await detailOf12(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({
@@ -38174,7 +38984,7 @@ async function runTriage(context, seams) {
   }
   const numbers = asked === null ? (selection?.assess ?? []).map((one) => one.number) : [asked];
   const readings = [];
-  let resolve25 = null;
+  let resolve26 = null;
   for (const number of numbers) {
     const assess = () => assessOne({
       pr,
@@ -38183,14 +38993,17 @@ async function runTriage(context, seams) {
       wantsComment,
       maxAttempts,
       at: now(),
-      permissions
+      permissions,
+      warn: (message) => {
+        context.output.warn(message);
+      }
     });
     const reading2 = await assess();
     if (!wantsResolve) {
       readings.push(reading2);
       continue;
     }
-    resolve25 = await resolvePullRequest({
+    resolve26 = await resolvePullRequest({
       trust: {
         permissions,
         trustedAuthors: pr.trustedAuthors,
@@ -38211,16 +39024,16 @@ async function runTriage(context, seams) {
       ...seams.clock === undefined ? {} : { clock: seams.clock },
       ...seams.sleep === undefined ? {} : { sleep: seams.sleep }
     });
-    readings.push(resolve25.reading);
+    readings.push(resolve26.reading);
   }
   const text2 = [
     ...selection === null ? [] : [selection.message],
     ...readings.length === 0 ? [] : [renderTriages(readings)],
-    ...resolve25 === null ? [] : resolve25.lines
+    ...resolve26 === null ? [] : resolve26.lines
   ].join(`
 
 `);
-  return { selection, readings, resolve: resolve25, text: text2, exitCode: resolve25?.exitCode ?? 0 };
+  return { selection, readings, resolve: resolve26, text: text2, exitCode: resolve26?.exitCode ?? 0 };
 }
 function createPrTriageCommand(seams = DEFAULT_TRIAGE_SEAMS) {
   const command = {
@@ -38295,6 +39108,7 @@ var USAGE30, DEFAULT_MAX_ATTEMPTS = 2, DETACHED_HEAD2 = "HEAD", RESOLVED = false
 var init_triage4 = __esm(() => {
   init_command();
   init_config_sections();
+  init_plan_ci();
   init_ending();
   init_pr();
   init_classify3();
@@ -38539,7 +39353,7 @@ var init_wait = __esm(() => {
 });
 
 // src/commands/release/status.ts
-import { existsSync as existsSync37, readdirSync as readdirSync15, readFileSync as readFileSync48 } from "fs";
+import { existsSync as existsSync39, readdirSync as readdirSync16, readFileSync as readFileSync49 } from "fs";
 import { join as join55 } from "path";
 function compareIdentifiers(left, right) {
   const leftNumeric = NUMERIC_IDENTIFIER.test(left);
@@ -38630,7 +39444,7 @@ function untaggedVersions(released, tags) {
 }
 function textOf4(path7) {
   try {
-    return readFileSync48(path7, "utf8");
+    return readFileSync49(path7, "utf8");
   } catch {
     return null;
   }
@@ -38671,12 +39485,12 @@ function readBranch2(git) {
   const branch = result.stdout.trim();
   return result.ok && branch !== "" && branch !== "HEAD" ? branch : null;
 }
-function planStubsUnder(root, planDir) {
+function planStubsUnder2(root, planDir) {
   const resolved = join55(root, planDir);
-  if (!existsSync37(resolved))
+  if (!existsSync39(resolved))
     return [];
   try {
-    return planStubsFromFileNames(readdirSync15(resolved));
+    return planStubsFromFileNames(readdirSync16(resolved));
   } catch {
     return [];
   }
@@ -38829,7 +39643,7 @@ function readStatus(context, seams = DEFAULT_RELEASE_SEAMS) {
     versionFile: readVersionFile(project.root, config.versionFile),
     tags,
     untagged: readUntagged(project.root, config.changelog, tags.tags),
-    plan: readPending(project.root, asked, readBranch2(git), planStubsUnder(project.root, config.planDir), readNotes)
+    plan: readPending(project.root, asked, readBranch2(git), planStubsUnder2(project.root, config.planDir), readNotes)
   };
   return { reading: reading2, text: renderStatus2(reading2) };
 }
@@ -38893,7 +39707,7 @@ var init_status3 = __esm(() => {
 });
 
 // src/commands/release/tag.ts
-import { readFileSync as readFileSync49 } from "fs";
+import { readFileSync as readFileSync50 } from "fs";
 import { join as join56 } from "path";
 function readBranch3(git) {
   const result = git(["rev-parse", "--abbrev-ref", "HEAD"]);
@@ -38908,7 +39722,7 @@ function readBranch3(git) {
 }
 function textOf5(path7) {
   try {
-    return readFileSync49(path7, "utf8");
+    return readFileSync50(path7, "utf8");
   } catch {
     return null;
   }
@@ -39244,7 +40058,7 @@ var init_self_update = __esm(() => {
 });
 
 // src/backfill/proposal-file.ts
-import { readdirSync as readdirSync16, readFileSync as readFileSync50 } from "fs";
+import { readdirSync as readdirSync17, readFileSync as readFileSync51 } from "fs";
 import { join as join57 } from "path";
 function proposalPath(dir, batch) {
   return join57(dir, `${PROPOSAL_FILE_PREFIX}${String(batch).padStart(2, "0")}${PROPOSAL_FILE_EXTENSION}`);
@@ -39378,14 +40192,14 @@ function parseProposalFile(text2) {
 function readProposalFiles(dir) {
   let names;
   try {
-    names = readdirSync16(dir);
+    names = readdirSync17(dir);
   } catch {
     return [];
   }
   return names.filter((name2) => isProposalFileName(name2)).sort((left, right) => left.localeCompare(right)).map((name2) => {
     const path7 = join57(dir, name2);
     try {
-      return { path: path7, result: parseProposalFile(readFileSync50(path7, "utf8")) };
+      return { path: path7, result: parseProposalFile(readFileSync51(path7, "utf8")) };
     } catch (error) {
       return { path: path7, result: unreadable2(`the file cannot be read (${error instanceof Error ? error.message : String(error)})`) };
     }
@@ -39416,19 +40230,19 @@ var init_proposal_file = __esm(() => {
 });
 
 // src/backfill/backup.ts
-import { copyFileSync as copyFileSync4, existsSync as existsSync38, mkdirSync as mkdirSync16 } from "fs";
-import { dirname as dirname19, isAbsolute as isAbsolute15, join as join58, relative as relative16, resolve as resolve25, sep as sep6 } from "path";
+import { copyFileSync as copyFileSync4, existsSync as existsSync40, mkdirSync as mkdirSync16 } from "fs";
+import { dirname as dirname19, isAbsolute as isAbsolute15, join as join58, relative as relative16, resolve as resolve26, sep as sep6 } from "path";
 function backupDirectory(base) {
   return join58(base, BACKUP_PATH);
 }
 function isUnder(root, path7) {
-  const step2 = relative16(resolve25(root), resolve25(path7));
+  const step2 = relative16(resolve26(root), resolve26(path7));
   return step2 === "" || !step2.startsWith(`..${sep6}`) && step2 !== ".." && !isAbsolute15(step2);
 }
 function backupPathFor(path7, root, backupDir) {
   if (!isUnder(root, path7))
     return null;
-  return join58(backupDir, relative16(resolve25(root), resolve25(path7)));
+  return join58(backupDir, relative16(resolve26(root), resolve26(path7)));
 }
 function backupFile(path7, options) {
   if (options.repoRoot !== null && isUnder(options.repoRoot, path7)) {
@@ -39437,9 +40251,9 @@ function backupFile(path7, options) {
   const backup = backupPathFor(path7, options.root, options.backupDir);
   if (backup === null)
     return { path: path7, kind: "outside", backup: null };
-  if (!existsSync38(path7))
+  if (!existsSync40(path7))
     return { path: path7, kind: "missing", backup: null };
-  if (existsSync38(backup))
+  if (existsSync40(backup))
     return { path: path7, kind: "kept", backup };
   mkdirSync16(dirname19(backup), { recursive: true });
   copyFileSync4(path7, backup);
@@ -39470,7 +40284,7 @@ var init_backup = __esm(() => {
 });
 
 // src/backfill/derive.ts
-import { readFileSync as readFileSync51, writeFileSync as writeFileSync18 } from "fs";
+import { readFileSync as readFileSync52, writeFileSync as writeFileSync18 } from "fs";
 import { basename as basename17 } from "path";
 function renderWhenToUse(trigger, prevents) {
   return `${sentenceEnded(trigger)} Prevents: ${prevents}`;
@@ -39589,7 +40403,7 @@ function planFile(entry, options) {
   }
   let original;
   try {
-    original = readFileSync51(entry.path, "utf8");
+    original = readFileSync52(entry.path, "utf8");
   } catch (error) {
     return inert(entry, "skipped", `the file cannot be read (${error instanceof Error ? error.message : String(error)})`);
   }
@@ -39633,7 +40447,7 @@ function planDerivation(root, options) {
 function applyFile(action, options) {
   if (action.text === null || action.original === null)
     return action;
-  const current = readFileSync51(action.path, "utf8");
+  const current = readFileSync52(action.path, "utf8");
   if (current !== action.original) {
     return {
       ...action,
@@ -39911,7 +40725,7 @@ var init_report3 = __esm(() => {
 });
 
 // src/backfill/proposal-batch.ts
-import { readFileSync as readFileSync52 } from "fs";
+import { readFileSync as readFileSync53 } from "fs";
 import { relative as relative17 } from "path";
 function candidateNeeds(data, body) {
   const needs = [];
@@ -39936,7 +40750,7 @@ function readCandidate(root, entry) {
     return null;
   let text2;
   try {
-    text2 = readFileSync52(entry.path, "utf8");
+    text2 = readFileSync53(entry.path, "utf8");
   } catch {
     return null;
   }
@@ -40086,8 +40900,8 @@ The files:
 });
 
 // src/backfill/propose.ts
-import { mkdirSync as mkdirSync17, readFileSync as readFileSync53, writeFileSync as writeFileSync19 } from "fs";
-import { join as join59, resolve as resolve26 } from "path";
+import { mkdirSync as mkdirSync17, readFileSync as readFileSync54, writeFileSync as writeFileSync19 } from "fs";
+import { join as join59, resolve as resolve27 } from "path";
 function unanswered(candidate, note) {
   return {
     path: candidate.relative,
@@ -40239,7 +41053,7 @@ function applyRow(root, row3, options) {
   }
   let original;
   try {
-    original = readFileSync53(path7, "utf8");
+    original = readFileSync54(path7, "utf8");
   } catch {
     return inert2(path7, row3, "refused", "the file the row names is gone");
   }
@@ -40253,7 +41067,7 @@ function fileRefusal(file, root) {
   if (file.status !== REVIEWED_FILE) {
     return `the proposal file is still marked ${file.status}: review it and mark it ${REVIEWED_FILE}`;
   }
-  return resolve26(file.skills) === resolve26(root) ? null : `the proposal file names the skills directory ${file.skills}, not ${root}`;
+  return resolve27(file.skills) === resolve27(root) ? null : `the proposal file names the skills directory ${file.skills}, not ${root}`;
 }
 function countProposalActions(actions) {
   const counts = Object.fromEntries(PROPOSAL_ACTION_KINDS.map((kind) => [kind, 0]));
@@ -40294,7 +41108,7 @@ var init_propose = __esm(() => {
 });
 
 // src/demote/select.ts
-import { readdirSync as readdirSync17, readFileSync as readFileSync54, realpathSync as realpathSync10, statSync as statSync25 } from "fs";
+import { readdirSync as readdirSync18, readFileSync as readFileSync55, realpathSync as realpathSync10, statSync as statSync25 } from "fs";
 import { basename as basename18, dirname as dirname20, join as join60 } from "path";
 function realOrSelf(path7) {
   try {
@@ -40341,7 +41155,7 @@ function entryKind2(path7) {
 }
 function visibleNames2(dir) {
   try {
-    return readdirSync17(dir).filter((name2) => !name2.startsWith(".")).sort((left, right) => left.localeCompare(right));
+    return readdirSync18(dir).filter((name2) => !name2.startsWith(".")).sort((left, right) => left.localeCompare(right));
   } catch {
     return [];
   }
@@ -40350,7 +41164,7 @@ function readSelected(absolute, path7, entries) {
   let text2;
   let mtime;
   try {
-    text2 = readFileSync54(absolute, "utf8");
+    text2 = readFileSync55(absolute, "utf8");
     mtime = statSync25(absolute).mtime.toISOString();
   } catch {
     return null;
@@ -40413,7 +41227,7 @@ var init_select3 = __esm(() => {
 
 // src/commands/skill/backfill.ts
 import { statSync as statSync26 } from "fs";
-import { join as join61, resolve as resolve27 } from "path";
+import { join as join61, resolve as resolve28 } from "path";
 function readSwitch3(name2, value) {
   if (value === undefined || value === false || value === "false")
     return false;
@@ -40443,7 +41257,7 @@ Usage: ${BACKFILL_USAGE}`);
     throw new CommandExit(1, `\u274C Expected one directory, and read "${extra}" as a second
 Usage: ${BACKFILL_USAGE}`);
   }
-  return resolve27(cwd(), dir);
+  return resolve28(cwd(), dir);
 }
 function readConsumerRoot(value, cwd) {
   if (value === undefined || value === false)
@@ -40452,7 +41266,7 @@ function readConsumerRoot(value, cwd) {
     throw new CommandExit(1, `\u274C --project needs a path, and the line gave it none
 Usage: ${BACKFILL_USAGE}`);
   }
-  return resolve27(cwd(), value);
+  return resolve28(cwd(), value);
 }
 function isDirectory4(path7) {
   try {
@@ -40759,7 +41573,7 @@ var init_check3 = __esm(() => {
 });
 
 // src/demote/apply.ts
-import { copyFileSync as copyFileSync5, existsSync as existsSync39, mkdirSync as mkdirSync18, mkdtempSync as mkdtempSync2, readdirSync as readdirSync18, readFileSync as readFileSync55, renameSync as renameSync5, rmSync as rmSync6, statSync as statSync27, unlinkSync as unlinkSync2, writeFileSync as writeFileSync20 } from "fs";
+import { copyFileSync as copyFileSync5, existsSync as existsSync41, mkdirSync as mkdirSync18, mkdtempSync as mkdtempSync2, readdirSync as readdirSync19, readFileSync as readFileSync56, renameSync as renameSync5, rmSync as rmSync6, statSync as statSync27, unlinkSync as unlinkSync2, writeFileSync as writeFileSync20 } from "fs";
 import { tmpdir as tmpdir2 } from "os";
 import { dirname as dirname21, join as join62 } from "path";
 function isLearnedPath(path7) {
@@ -40782,7 +41596,7 @@ function promotedPath(scope, path7) {
 function takenInstinctIds(dir) {
   let names;
   try {
-    names = readdirSync18(dir);
+    names = readdirSync19(dir);
   } catch {
     return [];
   }
@@ -40790,7 +41604,7 @@ function takenInstinctIds(dir) {
 }
 function readText9(path7) {
   try {
-    return statSync27(path7).isFile() ? readFileSync55(path7, "utf8") : null;
+    return statSync27(path7).isFile() ? readFileSync56(path7, "utf8") : null;
   } catch {
     return null;
   }
@@ -40818,7 +41632,7 @@ function planKept(scope, row3, file) {
     return inert3(row3.path, "procedure", "kept", "procedure-shaped: left where it is, for the backfill");
   }
   const to = promotedPath(scope, row3.path);
-  if (existsSync39(to) || existsSync39(dirname21(to))) {
+  if (existsSync41(to) || existsSync41(dirname21(to))) {
     return inert3(row3.path, "procedure", "refused", `kept as a skill, but ${to} is already there`);
   }
   return {
@@ -40855,9 +41669,9 @@ function planDemoted(scope, row3, file, context) {
   }
   const destination = join62(scope.instinctsDir, `${id}${MARKDOWN_EXTENSION}`);
   const kept = demotedPath(scope, row3.path);
-  if (existsSync39(destination))
+  if (existsSync41(destination))
     return inert3(row3.path, "observation", "refused", `${destination} is already there`);
-  if (existsSync39(kept))
+  if (existsSync41(kept))
     return inert3(row3.path, "observation", "refused", `${kept} is already there`);
   context.taken.push(id);
   return {
@@ -40986,8 +41800,8 @@ var init_draft = __esm(() => {
 });
 
 // src/commands/skill/demote.ts
-import { existsSync as existsSync40, mkdirSync as mkdirSync19, readFileSync as readFileSync56, statSync as statSync28, writeFileSync as writeFileSync21 } from "fs";
-import { dirname as dirname22, resolve as resolve28 } from "path";
+import { existsSync as existsSync42, mkdirSync as mkdirSync19, readFileSync as readFileSync57, statSync as statSync28, writeFileSync as writeFileSync21 } from "fs";
+import { dirname as dirname22, resolve as resolve29 } from "path";
 function readApply(value) {
   if (value === undefined || value === false || value === "false")
     return false;
@@ -41006,7 +41820,7 @@ Usage: ${DEMOTE_USAGE}`);
     throw new CommandExit(1, `\u274C Expected one directory, and read "${extra}" as a second
 Usage: ${DEMOTE_USAGE}`);
   }
-  return resolve28(cwd(), dir);
+  return resolve29(cwd(), dir);
 }
 function isDirectory5(path7) {
   try {
@@ -41038,9 +41852,9 @@ function verdictLine(report3) {
   return `${String(report3.rows.length)} file(s): ${parts.join(", ")}`;
 }
 function previousReport(path7, context) {
-  if (!existsSync40(path7))
+  if (!existsSync42(path7))
     return null;
-  const parsed = parseDemotionReport(readFileSync56(path7, "utf8"));
+  const parsed = parseDemotionReport(readFileSync57(path7, "utf8"));
   if (parsed.report !== null)
     return parsed.report;
   context.output.warn(`the report already at ${path7} does not parse, so no override in it is carried forward:` + ` ${parsed.issues.map((issue5) => `line ${String(issue5.line)} ${issue5.code}`).join(", ")}`);
@@ -41073,10 +41887,10 @@ function runWrite(context, scope) {
     context.output.info(line);
 }
 function reviewedReport(scope) {
-  if (!existsSync40(scope.reportPath)) {
+  if (!existsSync42(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(readFileSync56(scope.reportPath, "utf8"));
+  const parsed = parseDemotionReport(readFileSync57(scope.reportPath, "utf8"));
   if (parsed.report === null) {
     const lines2 = parsed.issues.map((issue5) => `   line ${String(issue5.line)} ${issue5.code}: ${issue5.message}`);
     throw new CommandExit(1, [`\u274C ${scope.reportPath} does not parse:`, ...lines2].join(`
@@ -41434,9 +42248,9 @@ function boundedRunner(open, root, deadline) {
 }
 async function networkSection(what, deadline, work) {
   let timer;
-  const expired = new Promise((resolve29) => {
+  const expired = new Promise((resolve30) => {
     timer = setTimeout(() => {
-      resolve29(unread2(`the ${what} was not read within the ${String(deadline.ms)}ms network deadline`));
+      resolve30(unread2(`the ${what} was not read within the ${String(deadline.ms)}ms network deadline`));
     }, Math.max(0, deadline.left()));
   });
   try {
@@ -42414,7 +43228,7 @@ init_config_sections();
 init_sessions();
 init_scope();
 init_sections2();
-import { mkdirSync as mkdirSync20, readFileSync as readFileSync57, renameSync as renameSync6, writeFileSync as writeFileSync22 } from "fs";
+import { mkdirSync as mkdirSync20, readFileSync as readFileSync58, renameSync as renameSync6, writeFileSync as writeFileSync22 } from "fs";
 import { dirname as dirname23, join as join63 } from "path";
 var SEEN_FILE = "status-seen.json";
 var SEEN_VERSION = 1;
@@ -42474,7 +43288,7 @@ function asSnapshot(value) {
 function readSeenFile(root) {
   let text2;
   try {
-    text2 = readFileSync57(seenFilePath(root), "utf8");
+    text2 = readFileSync58(seenFilePath(root), "utf8");
   } catch {
     return null;
   }