@open-tomato/rafa 0.18.0 → 0.19.0

package/dist/{index-6vkd153j.js → index-ca0fccvr.js}

@@ -1,16 +1,11 @@
 // @bun
 import {
-  CHANGE_LEVELS,
-  FINDING_KINDS,
-  FINDING_SIGNALS,
-  REPORT_STATUSES,
   escapeBlockerText,
   findNextTask,
   isStampableStub,
   loadPlanPrerequisites,
   malformedPrerequisiteLines,
   parsePlan,
-  parseReport,
   planStubFromPath,
   planStubFromPrompt,
   prerequisitesPathForPlan,
@@ -20,30 +15,46 @@ import {
   trackerPathFor,
   updateTrackerLine,
   writeTrackerBlocker
-} from "./index-0pdsq2hy.js";
+} from "./index-09p41s0n.js";
 import {
   CORE_ADAPTER_REGISTRY,
   ClaudePlannerError,
   LONE_SURROGATE,
+  MARKDOWN_EXTENSION,
   PORT_VERSIONS,
+  SKILL_FILE,
   checkUsage,
   createGhRunner,
   createLocalTracker,
+  declaredNameIssue,
   getClaudeUsagePercent,
+  gitRemoteUrl,
   interruptClaudeSessions,
+  mergeFrontmatter,
+  normalizeRemote,
+  parseInstinct,
   planFilePath,
+  readFrontmatter,
+  readFrontmatterDocument,
   runClaude,
   runClaudeCaptured,
+  scanLayout,
   selectEffortStore,
   sqliteStorePath,
   withSqliteStore,
+  writeFrontmatter,
+  writeInstinct,
   writeSqliteStore
-} from "./index-at9f1z2z.js";
+} from "./index-gb51x34c.js";
 import {
+  CHANGE_LEVELS,
   CONFIG_DEFAULTS,
   CONFIG_FILE,
   ConfigError,
   DEFAULT_ROUTING,
+  FINDING_KINDS,
+  FINDING_SIGNALS,
+  REPORT_STATUSES,
   SETTINGS,
   activeOutput,
   activeOutputMode,
@@ -51,23 +62,27 @@ import {
   configFilePath,
   findTierItem,
   parseConfigText,
+  parseReport,
   pinKey,
   pinLine,
   readItemBytes,
   readRafaBlocks,
   resolveConfig,
   resolveTiers
-} from "./index-jva32qe6.js";
+} from "./index-pqrpcfaz.js";
+import {
+  promotable
+} from "./index-d6d0942q.js";
 import {
   DESCRIBE_BINARY,
   DESCRIBE_SCHEMA_VERSION,
   pluralOf
-} from "./index-kvnggvyk.js";
+} from "./index-c5cecsga.js";
 import {
   CommandExit,
   SPENDS_GLYPH,
   commandSpelling
-} from "./index-ddf85qac.js";
+} from "./index-vg7ycs94.js";
 import {
   BUDGET_FLAG,
   BUNDLED_SKILLS_DIR,
@@ -75,7 +90,6 @@ import {
   PREREQUISITE_KINDS,
   RELEASE_AUTO,
   SKILL_TIERS,
-  __require,
   describeValue,
   isAgentName,
   isGitHubLogin,
@@ -93,7 +107,12 @@ import {
   skillTierDirectory,
   stripTaskDeclaration,
   tierExists
-} from "./index-944pncd8.js";
+} from "./index-cedghpva.js";
+import {
+  __require,
+  actionHash,
+  triggerKey
+} from "./index-wp8c28fd.js";
 
 // src/config-load.ts
 import { existsSync, readFileSync, realpathSync } from "fs";
@@ -1914,7 +1933,7 @@ async function report(args, repoRoot) {
 
 // package.json
 var name = "@open-tomato/rafa";
-var version = "0.18.0";
+var version = "0.19.0";
 
 // src/modules/manifest.ts
 var MANIFEST_VERSION = 1;
@@ -2264,429 +2283,27 @@ import { readFileSync as readFileSync8 } from "fs";
 import { resolve as resolve4 } from "path";
 
 // src/agents/roster.ts
-import { readdirSync as readdirSync4, readFileSync as readFileSync7, statSync as statSync4 } from "fs";
-import { join as join8 } from "path";
+import { readdirSync as readdirSync3, readFileSync as readFileSync7, statSync as statSync3 } from "fs";
+import { join as join7 } from "path";
 
 // src/inventory/trees.ts
 import { readFileSync as readFileSync4 } from "fs";
-import { dirname as dirname3, join as join5, relative as relative3 } from "path";
+import { dirname as dirname3, join as join4, relative as relative2 } from "path";
 
 // src/check/run.ts
 import { readFileSync as readFileSync2, writeFileSync } from "fs";
 import { basename as basename2, dirname as dirname2 } from "path";
 
-// src/schema/frontmatter.ts
-var FRONTMATTER_FENCE = "---";
-var FRONTMATTER_INDENT = 2;
-function scanLine(text, offset) {
-  const index = text.indexOf(`
-`, offset);
-  if (index === -1) {
-    return { line: text.slice(offset), newline: "", next: text.length };
-  }
-  const carriage = index > offset && text[index - 1] === "\r";
-  const end = carriage ? index - 1 : index;
-  return {
-    line: text.slice(offset, end),
-    newline: text.slice(end, index + 1),
-    next: index + 1
-  };
-}
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function parseBlock(yaml) {
-  let parsed;
-  try {
-    parsed = Bun.YAML.parse(yaml.replace(/\r\n/g, `
-`));
-  } catch {
-    return null;
-  }
-  return isRecord(parsed) ? parsed : null;
-}
-function readFrontmatterDocument(text) {
-  const opening = scanLine(text, 0);
-  if (opening.line !== FRONTMATTER_FENCE || opening.newline === "")
-    return null;
-  let offset = opening.next;
-  while (offset < text.length) {
-    const scanned = scanLine(text, offset);
-    if (scanned.line === FRONTMATTER_FENCE) {
-      const data = parseBlock(text.slice(opening.next, offset));
-      return data === null ? null : {
-        data,
-        yaml: text.slice(opening.next, offset),
-        body: text.slice(scanned.next),
-        newline: opening.newline,
-        closingNewline: scanned.newline
-      };
-    }
-    offset = scanned.next;
-  }
-  return null;
-}
-function readFrontmatter(text) {
-  return readFrontmatterDocument(text)?.data ?? null;
-}
-function renderFrontmatter(data, newline = `
-`) {
-  return Bun.YAML.stringify(data, null, FRONTMATTER_INDENT).split(`
-`).map((line) => line.replace(/[ \t]+$/, "")).join(newline);
-}
-function mergeFrontmatter(data, changes) {
-  const merged = {};
-  for (const [key, value] of Object.entries(data)) {
-    if (!Object.hasOwn(changes, key))
-      merged[key] = value;
-    else if (changes[key] !== undefined)
-      merged[key] = changes[key];
-  }
-  for (const [key, value] of Object.entries(changes)) {
-    if (value !== undefined && !Object.hasOwn(data, key))
-      merged[key] = value;
-  }
-  return merged;
-}
-function writeFrontmatter(document, data) {
-  const block = data === undefined ? document.yaml : `${renderFrontmatter(data, document.newline)}${document.newline}`;
-  return [
-    FRONTMATTER_FENCE,
-    document.newline,
-    block,
-    FRONTMATTER_FENCE,
-    document.closingNewline,
-    document.body
-  ].join("");
-}
-
-// src/schema/instinct.ts
-import { createHash } from "crypto";
-
-// src/schema/project-id.ts
-import { spawnSync } from "child_process";
-var PROJECT_ID_LENGTH = 12;
-var PROJECT_ID_PATTERN = new RegExp(`^[0-9a-f]{${PROJECT_ID_LENGTH}}$`);
-function hasColonAfterAt(url) {
-  const at = url.indexOf("@");
-  return at !== -1 && url.lastIndexOf(":") > at;
-}
-function normalizeRemote(url) {
-  const stripped = url.replace(/:\/\/[^@]+@/, "://");
-  const network = !stripped.startsWith("file://") && (stripped.includes("://") || hasColonAfterAt(stripped));
-  const trimmed = stripped.replace(/^[A-Za-z][A-Za-z0-9+.-]*:\/\//, "").replace(/^[^@/:]+@([^:/]+):/, "$1/").replace(/\.git\/?$/, "").replace(/\/+$/, "");
-  return network ? trimmed.toLowerCase() : trimmed;
-}
-function gitRemoteUrl(dir) {
-  const result = spawnSync("git", ["remote", "get-url", "origin"], {
-    cwd: dir,
-    encoding: "utf8",
-    env: { ...process.env, LC_ALL: "C" }
-  });
-  if (result.error !== undefined || result.status !== 0)
-    return null;
-  const url = result.stdout.trim();
-  return url === "" ? null : url;
-}
-
-// src/schema/instinct.ts
-var INSTINCT_KINDS = FINDING_KINDS;
-var INSTINCT_SIGNALS = FINDING_SIGNALS;
-var INSTINCT_DOMAINS = [
-  "code-style",
-  "testing",
-  "git",
-  "debugging",
-  "workflow",
-  "security",
-  "general-best-practices"
-];
-var INSTINCT_SCOPES = ["project", "user"];
-var INSTINCT_SOURCES = ["task-report", "loop-observed", "imported", "demoted"];
-var CONFIDENCE_MIN = 0.3;
-var CONFIDENCE_MAX = 0.9;
-var DEFAULT_USAGE_COUNT = 1;
-var EVIDENCE_REQUIRED_SOURCE = "task-report";
-var ACTION_HEADING = "## Action";
-var CAUSE_HEADING = "## Cause";
-var INSTINCT_ID_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
-var TIMESTAMP_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/;
-var INSTINCT_KEY_ORDER = [
-  "id",
-  "trigger",
-  "kind",
-  "domain",
-  "confidence",
-  "usage_count",
-  "artifact",
-  "signal",
-  "scope",
-  "project_id",
-  "source",
-  "evidence",
-  "created_at",
-  "updated_at"
-];
-function actionHash(action) {
-  return createHash("sha256").update(action.trim().toLowerCase()).digest("hex");
-}
-function issue(code, field2, message) {
-  return { code, field: field2, message };
-}
-function typeName(value) {
-  if (value === null)
-    return "an empty value";
-  if (Array.isArray(value))
-    return "a list";
-  if (typeof value === "object")
-    return "a mapping";
-  if (typeof value === "boolean")
-    return "a boolean";
-  if (typeof value === "number")
-    return "a number";
-  return `a ${typeof value}`;
-}
-function requiredString(data, field2) {
-  const value = data[field2];
-  if (value === undefined || value === null) {
-    return [issue("missing-field", field2, `${field2} is required and is absent`)];
-  }
-  if (typeof value !== "string") {
-    return [issue("wrong-type", field2, `${field2} must be a string, not ${typeName(value)}`)];
-  }
-  if (value.trim() === "") {
-    return [issue("missing-field", field2, `${field2} is required and is empty`)];
-  }
-  return [];
-}
-function requiredChoice(data, field2, allowed, code) {
-  const issues = requiredString(data, field2);
-  if (issues.length > 0)
-    return issues;
-  const value = data[field2];
-  return allowed.includes(value) ? [] : [issue(code, field2, `${field2} "${value}" is not one of ${allowed.join(", ")}`)];
-}
-function checkId(data) {
-  const issues = requiredString(data, "id");
-  if (issues.length > 0)
-    return issues;
-  const id = data["id"];
-  return INSTINCT_ID_PATTERN.test(id) ? [] : [issue("invalid-id", "id", `id "${id}" is not lowercase words joined by single hyphens`)];
-}
-function checkConfidence(data) {
-  const value = data["confidence"];
-  if (value === undefined || value === null) {
-    return [issue("missing-field", "confidence", "confidence is required and is absent")];
-  }
-  if (typeof value !== "number" || Number.isNaN(value)) {
-    return [issue("wrong-type", "confidence", `confidence must be a number, not ${typeName(value)}`)];
-  }
-  return value >= CONFIDENCE_MIN && value <= CONFIDENCE_MAX ? [] : [issue("confidence-out-of-range", "confidence", `confidence ${value} is outside ${CONFIDENCE_MIN} to ${CONFIDENCE_MAX}`)];
-}
-function checkUsageCount(data) {
-  const value = data["usage_count"];
-  if (value === undefined)
-    return [];
-  if (typeof value !== "number") {
-    return [issue("wrong-type", "usage_count", `usage_count must be a number, not ${typeName(value)}`)];
-  }
-  return Number.isInteger(value) && value >= DEFAULT_USAGE_COUNT ? [] : [issue("invalid-usage-count", "usage_count", `usage_count ${value} is not a whole number of at least ${DEFAULT_USAGE_COUNT}`)];
-}
-function checkArtifact(data) {
-  const value = data["artifact"];
-  if (value === undefined || typeof value === "string")
-    return [];
-  return [issue("wrong-type", "artifact", `artifact must be a string, not ${typeName(value)}`)];
-}
-function checkProjectId(data) {
-  const value = data["project_id"];
-  if (value === undefined)
-    return [];
-  if (typeof value !== "string") {
-    return [issue("wrong-type", "project_id", `project_id must be a string, not ${typeName(value)}`)];
-  }
-  return PROJECT_ID_PATTERN.test(value) ? [] : [issue("invalid-project-id", "project_id", `project_id "${value}" is not ${PROJECT_ID_LENGTH} lowercase hex characters`)];
-}
-function checkTimestamp(data, field2) {
-  const issues = requiredString(data, field2);
-  if (issues.length > 0)
-    return issues;
-  const value = data[field2];
-  return TIMESTAMP_PATTERN.test(value) && !Number.isNaN(Date.parse(value)) ? [] : [issue("invalid-timestamp", field2, `${field2} "${value}" is not an ISO 8601 instant such as 2026-09-11T10:00:00Z`)];
-}
-function isScalar(value) {
-  return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
-}
-function checkEvidenceEntry(entry, index) {
-  const field2 = `evidence[${index}]`;
-  if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
-    return [issue("wrong-type", field2, `evidence entries must be mappings, and this one is ${typeName(entry)}`)];
-  }
-  const entries = Object.entries(entry);
-  if (entries.length === 0) {
-    return [issue("wrong-type", field2, "evidence entries must say something, and this one is empty")];
-  }
-  return entries.flatMap(([key, value]) => isScalar(value) ? [] : [issue("wrong-type", `${field2}.${key}`, `evidence values must be text, numbers or booleans, and this one is ${typeName(value)}`)]);
-}
-function checkEvidence(data) {
-  const value = data["evidence"];
-  const owed = data["source"] === EVIDENCE_REQUIRED_SOURCE;
-  if (value === undefined || value === null)
-    return owed ? [missingEvidence("is absent")] : [];
-  if (!Array.isArray(value)) {
-    return [issue("wrong-type", "evidence", `evidence must be a list, not ${typeName(value)}`)];
-  }
-  if (value.length === 0)
-    return owed ? [missingEvidence("is an empty list")] : [];
-  return value.flatMap((entry, index) => checkEvidenceEntry(entry, index));
-}
-function missingEvidence(state) {
-  return issue("missing-evidence", "evidence", `a ${EVIDENCE_REQUIRED_SOURCE} record must name what it was learned from, and evidence ${state}`);
-}
-function checkStoredHash(data) {
-  if (!Object.hasOwn(data, "action_hash"))
-    return [];
-  return [issue("stored-action-hash", "action_hash", "action_hash is computed from the Action section at read time and is never stored, " + "because a hand edit would leave a stored one stale")];
-}
-function checkInstinctFrontmatter(data) {
-  return [
-    ...checkId(data),
-    ...requiredString(data, "trigger"),
-    ...requiredChoice(data, "kind", INSTINCT_KINDS, "unknown-kind"),
-    ...requiredChoice(data, "domain", INSTINCT_DOMAINS, "unknown-domain"),
-    ...checkConfidence(data),
-    ...checkUsageCount(data),
-    ...checkArtifact(data),
-    ...requiredChoice(data, "signal", INSTINCT_SIGNALS, "unknown-signal"),
-    ...requiredChoice(data, "scope", INSTINCT_SCOPES, "unknown-scope"),
-    ...checkProjectId(data),
-    ...requiredChoice(data, "source", INSTINCT_SOURCES, "unknown-source"),
-    ...checkEvidence(data),
-    ...checkTimestamp(data, "created_at"),
-    ...checkTimestamp(data, "updated_at"),
-    ...checkStoredHash(data)
-  ];
-}
-function isFence(line) {
-  return /^\s*(?:```|~~~)/.test(line);
-}
-function sectionText(body, heading) {
-  const lines = body.split(`
-`).map((line) => line.replace(/\r$/, ""));
-  const collected = [];
-  let fenced = false;
-  let inside = false;
-  for (const line of lines) {
-    if (isFence(line))
-      fenced = !fenced;
-    else if (!fenced && /^##\s/.test(line)) {
-      if (inside)
-        break;
-      inside = line.trim() === heading;
-      continue;
-    }
-    if (inside)
-      collected.push(line);
-  }
-  return inside ? collected.join(`
-`).trim() : null;
-}
-function checkSection(body, heading) {
-  const text = sectionText(body, heading);
-  if (text === null) {
-    return [issue("missing-section", heading, `the body carries no ${heading} section`)];
-  }
-  return text === "" ? [issue("missing-section", heading, `the ${heading} section is empty`)] : [];
-}
-function checkInstinctBody(body) {
-  return [...checkSection(body, ACTION_HEADING), ...checkSection(body, CAUSE_HEADING)];
-}
-function parseInstinct(text) {
-  const document = readFrontmatterDocument(text);
-  if (document === null) {
-    return {
-      issues: [issue("missing-frontmatter", "frontmatter", "the file opens with no --- block holding a YAML mapping")],
-      instinct: null
-    };
-  }
-  const issues = [
-    ...checkInstinctFrontmatter(document.data),
-    ...checkInstinctBody(document.body)
-  ];
-  return issues.length > 0 ? { issues, instinct: null } : { issues, instinct: buildInstinct(document.data, document.body) };
-}
-function buildInstinct(data, body) {
-  const action = sectionText(body, ACTION_HEADING) ?? "";
-  const artifact = typeof data["artifact"] === "string" && data["artifact"].trim() !== "" ? data["artifact"] : null;
-  return {
-    id: data["id"],
-    trigger: data["trigger"],
-    kind: data["kind"],
-    domain: data["domain"],
-    confidence: data["confidence"],
-    usageCount: typeof data["usage_count"] === "number" ? data["usage_count"] : DEFAULT_USAGE_COUNT,
-    artifact,
-    signal: data["signal"],
-    scope: data["scope"],
-    projectId: typeof data["project_id"] === "string" ? data["project_id"] : null,
-    source: data["source"],
-    evidence: Array.isArray(data["evidence"]) ? data["evidence"] : [],
-    createdAt: data["created_at"],
-    updatedAt: data["updated_at"],
-    action,
-    cause: sectionText(body, CAUSE_HEADING) ?? "",
-    actionHash: actionHash(action)
-  };
-}
-function instinctFrontmatter(instinct) {
-  const written = {
-    id: instinct.id,
-    trigger: instinct.trigger,
-    kind: instinct.kind,
-    domain: instinct.domain,
-    confidence: instinct.confidence,
-    usage_count: instinct.usageCount,
-    signal: instinct.signal,
-    scope: instinct.scope,
-    source: instinct.source,
-    created_at: instinct.createdAt,
-    updated_at: instinct.updatedAt
-  };
-  if (instinct.artifact !== null)
-    written["artifact"] = instinct.artifact;
-  if (instinct.projectId !== null)
-    written["project_id"] = instinct.projectId;
-  if (instinct.evidence.length > 0)
-    written["evidence"] = instinct.evidence;
-  return Object.fromEntries(INSTINCT_KEY_ORDER.filter((key) => Object.hasOwn(written, key)).map((key) => [key, written[key]]));
-}
-function writeInstinct(instinct, newline = `
-`) {
-  const block = renderFrontmatter(instinctFrontmatter(instinct), newline);
-  return [
-    "---",
-    block,
-    "---",
-    "",
-    ACTION_HEADING,
-    instinct.action,
-    "",
-    CAUSE_HEADING,
-    instinct.cause,
-    ""
-  ].join(newline);
-}
-
 // src/schema/provenance.ts
 var PROVENANCE_FIELD = "provenance";
 var FIRST_PARTY = "first-party";
 var PROVENANCE_KEYS = ["origin", "license", "reviewed"];
 var REQUIRED_PROVENANCE_KEYS = ["origin", "license"];
 var REVIEWED_PATTERN = /^(\S(?:.*\S)?)\s+(\d{4}-\d{2}-\d{2})$/;
-function issue2(code, field2, message) {
+function issue(code, field2, message) {
   return { code, field: field2, message };
 }
-function typeName2(value) {
+function typeName(value) {
   if (value === null)
     return "an empty value";
   if (Array.isArray(value))
@@ -2715,13 +2332,13 @@ function requiredEntry(value, key) {
   const field2 = `${PROVENANCE_FIELD}.${key}`;
   const entry = value[key];
   if (entry === undefined || entry === null) {
-    return [issue2("missing-field", field2, `${field2} is required on a third-party item and is absent`)];
+    return [issue("missing-field", field2, `${field2} is required on a third-party item and is absent`)];
   }
   if (typeof entry !== "string") {
-    return [issue2("wrong-type", field2, `${field2} must be a string, not ${typeName2(entry)}`)];
+    return [issue("wrong-type", field2, `${field2} must be a string, not ${typeName(entry)}`)];
   }
   if (entry.trim() === "") {
-    return [issue2("missing-field", field2, `${field2} is required on a third-party item and is empty`)];
+    return [issue("missing-field", field2, `${field2} is required on a third-party item and is empty`)];
   }
   return [];
 }
@@ -2731,33 +2348,33 @@ function reviewedEntry(value) {
   const field2 = `${PROVENANCE_FIELD}.reviewed`;
   const entry = value["reviewed"];
   if (typeof entry !== "string") {
-    return [issue2("wrong-type", field2, `${field2} must be a string, not ${typeName2(entry)}`)];
+    return [issue("wrong-type", field2, `${field2} must be a string, not ${typeName(entry)}`)];
   }
   const problem = reviewProblem(entry);
-  return problem === null ? [] : [issue2("invalid-reviewed", field2, `${field2} "${entry}" ${problem}`)];
+  return problem === null ? [] : [issue("invalid-reviewed", field2, `${field2} "${entry}" ${problem}`)];
 }
 function unknownKeys(value) {
   const known = PROVENANCE_KEYS;
   const unknown = Object.keys(value).filter((key) => !known.includes(key));
-  return unknown.map((key) => issue2("unknown-provenance", `${PROVENANCE_FIELD}.${key}`, `${key} is not a provenance key; the keys are ${PROVENANCE_KEYS.join(", ")}`));
+  return unknown.map((key) => issue("unknown-provenance", `${PROVENANCE_FIELD}.${key}`, `${key} is not a provenance key; the keys are ${PROVENANCE_KEYS.join(", ")}`));
 }
 function stringProblems(value) {
   if (value.trim() === "") {
-    return [issue2("missing-field", PROVENANCE_FIELD, `${PROVENANCE_FIELD} is present and empty`)];
+    return [issue("missing-field", PROVENANCE_FIELD, `${PROVENANCE_FIELD} is present and empty`)];
   }
-  return value === FIRST_PARTY ? [] : [issue2("unknown-provenance", PROVENANCE_FIELD, `${PROVENANCE_FIELD} "${value}" is neither ${FIRST_PARTY} nor a mapping of origin and license`)];
+  return value === FIRST_PARTY ? [] : [issue("unknown-provenance", PROVENANCE_FIELD, `${PROVENANCE_FIELD} "${value}" is neither ${FIRST_PARTY} nor a mapping of origin and license`)];
 }
 function checkProvenance(data) {
   if (!Object.hasOwn(data, PROVENANCE_FIELD))
     return [];
   const value = data[PROVENANCE_FIELD];
   if (value === null) {
-    return [issue2("missing-field", PROVENANCE_FIELD, `${PROVENANCE_FIELD} is present and empty`)];
+    return [issue("missing-field", PROVENANCE_FIELD, `${PROVENANCE_FIELD} is present and empty`)];
   }
   if (typeof value === "string")
     return stringProblems(value);
   if (!isMapping2(value)) {
-    return [issue2("wrong-type", PROVENANCE_FIELD, `${PROVENANCE_FIELD} must be ${FIRST_PARTY} or a mapping, not ${typeName2(value)}`)];
+    return [issue("wrong-type", PROVENANCE_FIELD, `${PROVENANCE_FIELD} must be ${FIRST_PARTY} or a mapping, not ${typeName(value)}`)];
   }
   return [
     ...REQUIRED_PROVENANCE_KEYS.flatMap((key) => requiredEntry(value, key)),
@@ -3074,26 +2691,26 @@ function classLiteralEnd(pattern, start) {
   const negated = pattern[start + 1] === "!" || pattern[start + 1] === "^";
   return negated ? start + 2 : start + 1;
 }
-function issue3(code, field2, message) {
+function issue2(code, field2, message) {
   return { code, field: field2, message };
 }
 function isFilled(value) {
   return typeof value === "string" && value.trim() !== "";
 }
-function requiredString2(data, field2) {
+function requiredString(data, field2) {
   const value = data[field2];
   if (value === undefined || value === null) {
-    return [issue3("missing-field", field2, `${field2} is required and is absent`)];
+    return [issue2("missing-field", field2, `${field2} is required and is absent`)];
   }
   if (typeof value !== "string") {
-    return [issue3("wrong-type", field2, `${field2} must be a string, not ${typeName3(value)}`)];
+    return [issue2("wrong-type", field2, `${field2} must be a string, not ${typeName2(value)}`)];
   }
   if (value.trim() === "") {
-    return [issue3("missing-field", field2, `${field2} is required and is empty`)];
+    return [issue2("missing-field", field2, `${field2} is required and is empty`)];
   }
   return [];
 }
-function typeName3(value) {
+function typeName2(value) {
   if (value === null)
     return "an empty value";
   if (Array.isArray(value))
@@ -3107,29 +2724,29 @@ function typeName3(value) {
   return `a ${typeof value}`;
 }
 function checkName(data) {
-  const issues = requiredString2(data, "name");
+  const issues = requiredString(data, "name");
   if (issues.length > 0)
     return issues;
   const name2 = data["name"];
-  return isSkillName(name2) ? [] : [issue3("invalid-name", "name", `name "${name2}" is not lowercase words joined by single hyphens`)];
+  return isSkillName(name2) ? [] : [issue2("invalid-name", "name", `name "${name2}" is not lowercase words joined by single hyphens`)];
 }
 function checkDescription(data) {
-  const issues = requiredString2(data, "description");
+  const issues = requiredString(data, "description");
   if (issues.length > 0)
     return issues;
   const length = countCharacters(data["description"]);
-  return length < DESCRIPTION_LIMIT ? [] : [issue3("description-too-long", "description", `description is ${length} characters, and the limit is ${DESCRIPTION_LIMIT}`)];
+  return length < DESCRIPTION_LIMIT ? [] : [issue2("description-too-long", "description", `description is ${length} characters, and the limit is ${DESCRIPTION_LIMIT}`)];
 }
 function requiredStringList(data, field2) {
   const value = data[field2];
   if (value === undefined || value === null) {
-    return [issue3("missing-field", field2, `${field2} is required and is absent`)];
+    return [issue2("missing-field", field2, `${field2} is required and is absent`)];
   }
   if (!Array.isArray(value)) {
-    return [issue3("wrong-type", field2, `${field2} must be a list, not ${typeName3(value)}`)];
+    return [issue2("wrong-type", field2, `${field2} must be a list, not ${typeName2(value)}`)];
   }
   if (value.length === 0) {
-    return [issue3("missing-field", field2, `${field2} is required and is an empty list`)];
+    return [issue2("missing-field", field2, `${field2} is required and is an empty list`)];
   }
   return entryTypeIssues(value, field2);
 }
@@ -3137,7 +2754,7 @@ function entryTypeIssues(values, field2) {
   const issues = [];
   for (const [index, entry] of values.entries()) {
     if (!isFilled(entry)) {
-      issues.push(issue3("wrong-type", `${field2}[${index}]`, `${field2} entries must be non-empty strings, and this one is ${typeName3(entry)}`));
+      issues.push(issue2("wrong-type", `${field2}[${index}]`, `${field2} entries must be non-empty strings, and this one is ${typeName2(entry)}`));
     }
   }
   return issues;
@@ -3148,36 +2765,36 @@ function checkStack(data) {
     return issues;
   const values = data["stack"];
   if (values.length > 1 && values.includes(AGNOSTIC_STACK)) {
-    return [issue3("unknown-stack", "stack", `${AGNOSTIC_STACK} is either the whole stack list or no part of it`)];
+    return [issue2("unknown-stack", "stack", `${AGNOSTIC_STACK} is either the whole stack list or no part of it`)];
   }
   const unknown = new Set(unknownStacks(values));
-  return values.flatMap((name2, index) => unknown.has(name2) ? [issue3("unknown-stack", `stack[${index}]`, `stack "${name2}" is not a vocabulary name`)] : []);
+  return values.flatMap((name2, index) => unknown.has(name2) ? [issue2("unknown-stack", `stack[${index}]`, `stack "${name2}" is not a vocabulary name`)] : []);
 }
 function checkWhenToUse(data) {
   const issues = optionalString(data, "when_to_use");
   if (issues.length > 0)
     return issues;
   const length = listingLength(data);
-  return length < LISTING_LIMIT ? [] : [issue3("listing-too-long", "description + when_to_use", `description and when_to_use are ${length} characters together, ` + `and Claude Code truncates the listing at ${LISTING_LIMIT}`)];
+  return length < LISTING_LIMIT ? [] : [issue2("listing-too-long", "description + when_to_use", `description and when_to_use are ${length} characters together, ` + `and Claude Code truncates the listing at ${LISTING_LIMIT}`)];
 }
 function optionalString(data, field2) {
   if (!Object.hasOwn(data, field2))
     return [];
-  return requiredString2(data, field2);
+  return requiredString(data, field2);
 }
 function checkTrigger(data) {
   const issues = [...optionalString(data, "prevents"), ...optionalString(data, "signal")];
   const hasPrevents = Object.hasOwn(data, "prevents");
   const hasSignal = Object.hasOwn(data, "signal");
   if (hasPrevents && !hasSignal) {
-    issues.push(issue3("unpaired-prevents", "signal", "prevents names a failure, so signal must say whether it announces itself"));
+    issues.push(issue2("unpaired-prevents", "signal", "prevents names a failure, so signal must say whether it announces itself"));
   }
   if (hasSignal && !hasPrevents) {
-    issues.push(issue3("unpaired-prevents", "prevents", "signal describes a failure, so prevents must name the failure it describes"));
+    issues.push(issue2("unpaired-prevents", "prevents", "signal describes a failure, so prevents must name the failure it describes"));
   }
   const signal = stringAt(data, "signal");
   if (signal !== null && signal.trim() !== "" && !isSkillSignal(signal)) {
-    issues.push(issue3("unknown-signal", "signal", `signal "${signal}" is neither ${SKILL_SIGNALS.join(" nor ")}`));
+    issues.push(issue2("unknown-signal", "signal", `signal "${signal}" is neither ${SKILL_SIGNALS.join(" nor ")}`));
   }
   return issues;
 }
@@ -3189,29 +2806,29 @@ function checkNameList(data, field2) {
   if (value === undefined)
     return [];
   if (!Array.isArray(value)) {
-    return [issue3("wrong-type", field2, `${field2} must be a list, not ${typeName3(value)}`)];
+    return [issue2("wrong-type", field2, `${field2} must be a list, not ${typeName2(value)}`)];
   }
   const issues = entryTypeIssues(value, field2);
   if (issues.length > 0)
     return issues;
-  return value.flatMap((entry, index) => isSkillName(entry) ? [] : [issue3("invalid-name", `${field2}[${index}]`, `${field2} entry "${entry}" is not a skill name`)]);
+  return value.flatMap((entry, index) => isSkillName(entry) ? [] : [issue2("invalid-name", `${field2}[${index}]`, `${field2} entry "${entry}" is not a skill name`)]);
 }
 function checkPaths(data) {
   const value = data["paths"];
   if (value === undefined)
     return [];
   if (!Array.isArray(value)) {
-    return [issue3("wrong-type", "paths", `paths must be a list, not ${typeName3(value)}`)];
+    return [issue2("wrong-type", "paths", `paths must be a list, not ${typeName2(value)}`)];
   }
   const issues = [];
   for (const [index, entry] of value.entries()) {
     if (typeof entry !== "string") {
-      issues.push(issue3("wrong-type", `paths[${index}]`, `paths entries must be strings, and this one is ${typeName3(entry)}`));
+      issues.push(issue2("wrong-type", `paths[${index}]`, `paths entries must be strings, and this one is ${typeName2(entry)}`));
       continue;
     }
     const problem = globProblem(entry);
     if (problem !== null) {
-      issues.push(issue3("unusable-glob", `paths[${index}]`, `the glob "${entry}" ${problem}`));
+      issues.push(issue2("unusable-glob", `paths[${index}]`, `the glob "${entry}" ${problem}`));
     }
   }
   return issues;
@@ -3220,10 +2837,10 @@ function checkBoolean(data, field2) {
   const value = data[field2];
   if (value === undefined || typeof value === "boolean")
     return [];
-  return [issue3("wrong-type", field2, `${field2} must be true or false unquoted, and this is ${typeName3(value)}`)];
+  return [issue2("wrong-type", field2, `${field2} must be true or false unquoted, and this is ${typeName2(value)}`)];
 }
 function checkForbidden(data) {
-  return FORBIDDEN_SKILL_FIELDS.filter((field2) => Object.hasOwn(data, field2)).map((field2) => issue3("forbidden-field", field2, `${field2} belongs to an instinct record and never to a skill`));
+  return FORBIDDEN_SKILL_FIELDS.filter((field2) => Object.hasOwn(data, field2)).map((field2) => issue2("forbidden-field", field2, `${field2} belongs to an instinct record and never to a skill`));
 }
 function checkSkillFrontmatter(data) {
   return [
@@ -3241,248 +2858,9 @@ function checkSkillFrontmatter(data) {
   ];
 }
 
-// src/check/layout.ts
-import { readdirSync as readdirSync2, statSync as statSync2 } from "fs";
-import { join as join3, relative } from "path";
-var SKILL_FILE = "SKILL.md";
-var MARKDOWN_EXTENSION = ".md";
-var LAYOUT_SEVERITY = Object.freeze({
-  "flat-grouped-layout": "failure",
-  "nested-group-layout": "failure",
-  "loose-file": "failure",
-  "missing-skill-file": "failure",
-  "nested-instinct-file": "failure",
-  "unreadable-entry": "failure",
-  "name-mismatch": "failure",
-  "dotfile-only-directory": "warning"
-});
-function layoutIssue(code, message) {
-  return { code, severity: LAYOUT_SEVERITY[code], message };
-}
-function entryKind(path) {
-  try {
-    const stats = statSync2(path);
-    if (stats.isFile())
-      return "file";
-    if (stats.isDirectory())
-      return "directory";
-    return null;
-  } catch {
-    return null;
-  }
-}
-function visibleNames(dir) {
-  return readdirSync2(dir).filter((name2) => !name2.startsWith(".")).sort((left, right) => left.localeCompare(right));
-}
-function isMarkdown(name2) {
-  return name2.endsWith(MARKDOWN_EXTENSION);
-}
-function markdownStem(name2) {
-  return name2.slice(0, -MARKDOWN_EXTENSION.length);
-}
-function shown(root, path) {
-  return relative(root, path) || ".";
-}
-function dotfileOnlyEntry(kind, root, dir) {
-  return {
-    kind,
-    path: dir,
-    isFile: false,
-    shape: "dotfile-only",
-    name: null,
-    issues: [layoutIssue("dotfile-only-directory", `${shown(root, dir)}/ holds nothing but dotfiles, so it registers nothing`)]
-  };
-}
-function unreadableEntry(kind, root, path) {
-  return {
-    kind,
-    path,
-    isFile: false,
-    shape: "unreadable",
-    name: null,
-    issues: [layoutIssue("unreadable-entry", `${shown(root, path)} cannot be read (a broken symlink, or a path stat refuses)`)]
-  };
-}
-function skillFileEntry(path, name2) {
-  return { kind: "skill", path, isFile: true, shape: "skill-file", name: name2, issues: [] };
-}
-function flatGroupedEntry(root, path, name2) {
-  return {
-    kind: "skill",
-    path,
-    isFile: true,
-    shape: "flat-grouped",
-    name: name2,
-    issues: [layoutIssue("flat-grouped-layout", `${shown(root, path)} is the flat grouped layout <dir>/<group>/<name>.md,` + ` which does not register; move it to <dir>/${name2}/${SKILL_FILE}`)]
-  };
-}
-function nestedGroupEntry(root, path, name2) {
-  return {
-    kind: "skill",
-    path,
-    isFile: true,
-    shape: "nested-group",
-    name: name2,
-    issues: [layoutIssue("nested-group-layout", `${shown(root, path)} is the nested layout <dir>/<group>/<name>/${SKILL_FILE},` + ` which does not register; move it to <dir>/${name2}/${SKILL_FILE}`)]
-  };
-}
-function looseFileEntry(root, path, name2) {
-  return {
-    kind: "skill",
-    path,
-    isFile: true,
-    shape: "loose-file",
-    name: name2,
-    issues: [layoutIssue("loose-file", `${shown(root, path)} sits directly under the skills directory, which registers` + ` only <dir>/<name>/${SKILL_FILE}; move it to <dir>/${name2}/${SKILL_FILE}`)]
-  };
-}
-function noSkillFileEntry(root, dir) {
-  return {
-    kind: "skill",
-    path: dir,
-    isFile: false,
-    shape: "no-skill-file",
-    name: null,
-    issues: [layoutIssue("missing-skill-file", `${shown(root, dir)}/ holds no ${SKILL_FILE}, so it registers no skill`)]
-  };
-}
-function nestedInstinctEntry(root, path, name2) {
-  return {
-    kind: "instinct",
-    path,
-    isFile: true,
-    shape: "nested-instinct",
-    name: name2,
-    issues: [layoutIssue("nested-instinct-file", `${shown(root, path)} sits below the instincts directory, which is flat;` + ` move it to <dir>/${name2}${MARKDOWN_EXTENSION}`)]
-  };
-}
-function scanGroupMember(root, dir, name2) {
-  const children = visibleNames(dir);
-  if (children.length === 0)
-    return [dotfileOnlyEntry("skill", root, dir)];
-  const skillPath = join3(dir, SKILL_FILE);
-  if (children.includes(SKILL_FILE) && entryKind(skillPath) === "file") {
-    return [nestedGroupEntry(root, skillPath, name2)];
-  }
-  return [noSkillFileEntry(root, dir)];
-}
-function scanSkillGroup(root, dir, children) {
-  const entries = [];
-  for (const child of children) {
-    const path = join3(dir, child);
-    const found = entryKind(path);
-    if (found === null) {
-      entries.push(unreadableEntry("skill", root, path));
-      continue;
-    }
-    if (found === "directory") {
-      entries.push(...scanGroupMember(root, path, child));
-      continue;
-    }
-    if (isMarkdown(child))
-      entries.push(flatGroupedEntry(root, path, markdownStem(child)));
-  }
-  if (entries.length === 0)
-    return [noSkillFileEntry(root, dir)];
-  return entries;
-}
-function scanSkillDirectory(root, dir, name2) {
-  const children = visibleNames(dir);
-  if (children.length === 0)
-    return [dotfileOnlyEntry("skill", root, dir)];
-  const skillPath = join3(dir, SKILL_FILE);
-  if (children.includes(SKILL_FILE) && entryKind(skillPath) === "file") {
-    return [skillFileEntry(skillPath, name2)];
-  }
-  return scanSkillGroup(root, dir, children);
-}
-function scanSkillRoot(root) {
-  const entries = [];
-  for (const name2 of visibleNames(root)) {
-    const path = join3(root, name2);
-    const found = entryKind(path);
-    if (found === null) {
-      entries.push(unreadableEntry("skill", root, path));
-      continue;
-    }
-    if (found === "directory") {
-      entries.push(...scanSkillDirectory(root, path, name2));
-      continue;
-    }
-    if (isMarkdown(name2))
-      entries.push(looseFileEntry(root, path, markdownStem(name2)));
-  }
-  return entries;
-}
-function scanInstinctSubdirectory(root, dir) {
-  const children = visibleNames(dir);
-  if (children.length === 0)
-    return [dotfileOnlyEntry("instinct", root, dir)];
-  const entries = [];
-  for (const child of children) {
-    const path = join3(dir, child);
-    const found = entryKind(path);
-    if (found === null) {
-      entries.push(unreadableEntry("instinct", root, path));
-      continue;
-    }
-    if (found === "directory") {
-      entries.push(...scanInstinctSubdirectory(root, path));
-      continue;
-    }
-    if (isMarkdown(child))
-      entries.push(nestedInstinctEntry(root, path, markdownStem(child)));
-  }
-  return entries;
-}
-function scanInstinctRoot(root) {
-  const entries = [];
-  for (const name2 of visibleNames(root)) {
-    const path = join3(root, name2);
-    const found = entryKind(path);
-    if (found === null) {
-      entries.push(unreadableEntry("instinct", root, path));
-      continue;
-    }
-    if (found === "directory") {
-      entries.push(...scanInstinctSubdirectory(root, path));
-      continue;
-    }
-    if (!isMarkdown(name2))
-      continue;
-    entries.push({
-      kind: "instinct",
-      path,
-      isFile: true,
-      shape: "instinct-file",
-      name: markdownStem(name2),
-      issues: []
-    });
-  }
-  return entries;
-}
-function scanLayout(root, kind) {
-  if (entryKind(root) !== "directory") {
-    throw new Error(`check layout: no ${kind} directory at ${root}`);
-  }
-  const entries = kind === "skill" ? scanSkillRoot(root) : scanInstinctRoot(root);
-  return {
-    kind,
-    root,
-    entries: entries.sort((left, right) => left.path.localeCompare(right.path))
-  };
-}
-function declaredNameIssue(entry, declared) {
-  if (entry.name === null || declared === null || declared === entry.name)
-    return null;
-  const field2 = entry.kind === "skill" ? "name" : "id";
-  const source = entry.kind === "skill" ? "directory name" : "file name";
-  return layoutIssue("name-mismatch", `frontmatter ${field2} "${declared}" is not the ${source} "${entry.name}"`);
-}
-
 // src/check/references.ts
-import { existsSync as existsSync7, statSync as statSync3 } from "fs";
-import { delimiter, isAbsolute as isAbsolute3, relative as relative2, resolve as resolve2 } from "path";
+import { existsSync as existsSync7, statSync as statSync2 } from "fs";
+import { delimiter, isAbsolute as isAbsolute3, relative, resolve as resolve2 } from "path";
 
 // src/check/shell-lines.ts
 var SHELL_FENCE_LANGUAGES = ["bash", "sh", "shell", "zsh", "console"];
@@ -3702,12 +3080,12 @@ function isAbsoluteReference(token) {
   return KNOWN_ROOTS.includes(`/${first}`) || EXTENSION.test(token);
 }
 function isInside(root, target) {
-  const step = relative2(resolve2(root), resolve2(target));
+  const step = relative(resolve2(root), resolve2(target));
   return step !== "" && !step.startsWith("..") && !isAbsolute3(step);
 }
 function isExecutableFile(path) {
   try {
-    const stats = statSync3(path);
+    const stats = statSync2(path);
     return stats.isFile() && (stats.mode & 73) !== 0;
   } catch {
     return false;
@@ -3910,9 +3288,9 @@ function checkReferences(body, seams) {
     if (seen.has(key))
       continue;
     seen.add(key);
-    const issue4 = referenceIssue(ref, seams, functions);
-    if (issue4 !== null)
-      issues.push(issue4);
+    const issue3 = referenceIssue(ref, seams, functions);
+    if (issue3 !== null)
+      issues.push(issue3);
   }
   return { references, issues };
 }
@@ -3929,66 +3307,66 @@ var CHECK_STAGES = [
 var LOCALITY_CODES = ["home-path", "foreign-path"];
 var FIXABLE_FIELDS = ["tags", "stack"];
 function hasCheckFailure(issues) {
-  return issues.some((issue4) => issue4.severity === "failure");
+  return issues.some((issue3) => issue3.severity === "failure");
 }
 function failureExitCode(count) {
   return Math.min(count, FAILING_FILE_CAP);
 }
-function fromLayout(issue4) {
+function fromLayout(issue3) {
   return {
     stage: "layout",
-    code: issue4.code,
-    severity: issue4.severity,
+    code: issue3.code,
+    severity: issue3.severity,
     field: null,
     line: null,
-    message: issue4.message
+    message: issue3.message
   };
 }
-function fromSkill(issue4) {
+function fromSkill(issue3) {
   return {
     stage: "schema",
-    code: issue4.code,
+    code: issue3.code,
     severity: "failure",
-    field: issue4.field,
+    field: issue3.field,
     line: null,
-    message: issue4.message
+    message: issue3.message
   };
 }
-function fromInstinct(issue4) {
+function fromInstinct(issue3) {
   return {
     stage: "instinct",
-    code: issue4.code,
+    code: issue3.code,
     severity: "failure",
-    field: issue4.field,
+    field: issue3.field,
     line: null,
-    message: issue4.message
+    message: issue3.message
   };
 }
-function fromReference(issue4) {
+function fromReference(issue3) {
   return {
-    stage: LOCALITY_CODES.includes(issue4.code) ? "locality" : "resolution",
-    code: issue4.code,
-    severity: issue4.severity,
+    stage: LOCALITY_CODES.includes(issue3.code) ? "locality" : "resolution",
+    code: issue3.code,
+    severity: issue3.severity,
     field: null,
-    line: issue4.reference.line,
-    message: issue4.message
+    line: issue3.reference.line,
+    message: issue3.message
   };
 }
 function checkerIssue(stage, code, message) {
   return { stage, code, severity: "failure", field: null, line: null, message };
 }
-function isMarkdown2(name2) {
+function isMarkdown(name2) {
   return name2.endsWith(MARKDOWN_EXTENSION);
 }
 function fileEntry(path, kind) {
   const base = basename2(path);
-  const stem = isMarkdown2(base) ? base.slice(0, -MARKDOWN_EXTENSION.length) : base;
+  const stem = isMarkdown(base) ? base.slice(0, -MARKDOWN_EXTENSION.length) : base;
   if (kind === "instinct") {
     return {
       kind,
       path,
       isFile: true,
-      shape: isMarkdown2(base) ? "instinct-file" : "loose-file",
+      shape: isMarkdown(base) ? "instinct-file" : "loose-file",
       name: stem,
       issues: []
     };
@@ -3998,7 +3376,7 @@ function fileEntry(path, kind) {
 function unregisteredIssue(path, kind) {
   const base = basename2(path);
   if (kind === "instinct") {
-    return isMarkdown2(base) ? null : checkerIssue("layout", "unregistered-path", `${base} is not a ${MARKDOWN_EXTENSION} file, so it is no instinct record`);
+    return isMarkdown(base) ? null : checkerIssue("layout", "unregistered-path", `${base} is not a ${MARKDOWN_EXTENSION} file, so it is no instinct record`);
   }
   return base === SKILL_FILE ? null : checkerIssue("layout", "unregistered-path", `${base} is not a ${SKILL_FILE}, so it registers no skill wherever it sits`);
 }
@@ -4019,7 +3397,7 @@ function inStageOrder(issues) {
   return [...issues].sort((left, right) => CHECK_STAGES.indexOf(left.stage) - CHECK_STAGES.indexOf(right.stage));
 }
 function fixableFields(issues) {
-  const failures = issues.filter((issue4) => issue4.severity === "failure");
+  const failures = issues.filter((issue3) => issue3.severity === "failure");
   if (failures.length === 0)
     return null;
   const found = new Set;
@@ -4152,19 +3530,19 @@ function checkDirectory(root, kind, options) {
 
 // src/utils/agent-definition.ts
 import { readFileSync as readFileSync3 } from "fs";
-import { join as join4 } from "path";
-var AGENT_DEFINITION_DIR = join4(".claude", "agents");
+import { join as join3 } from "path";
+var AGENT_DEFINITION_DIR = join3(".claude", "agents");
 function agentDefinitionCandidates(name2, roots, settingSources) {
   if (!isAgentName(name2))
     return [];
   const file = `${name2}.md`;
   const project = {
     scope: "project",
-    path: join4(roots.repoRoot, AGENT_DEFINITION_DIR, file)
+    path: join3(roots.repoRoot, AGENT_DEFINITION_DIR, file)
   };
   if (!settingSources.includes("user"))
     return [project];
-  return [project, { scope: "user", path: join4(roots.home, AGENT_DEFINITION_DIR, file) }];
+  return [project, { scope: "user", path: join3(roots.home, AGENT_DEFINITION_DIR, file) }];
 }
 function readText2(path) {
   try {
@@ -4246,16 +3624,16 @@ function checkVerdict(issues) {
 }
 
 // src/inventory/trees.ts
-var BUNDLED_AGENTS_DIR = join5("bundled", "agents");
+var BUNDLED_AGENTS_DIR = join4("bundled", "agents");
 function bundledAgentsDirectory(entry) {
-  return join5(dirname3(realEntry(entry ?? Bun.main)), BUNDLED_AGENTS_DIR);
+  return join4(dirname3(realEntry(entry ?? Bun.main)), BUNDLED_AGENTS_DIR);
 }
 function agentTreeDirectory(tier, seams) {
   if (tier === "user")
-    return join5(seams.home, AGENT_DEFINITION_DIR);
+    return join4(seams.home, AGENT_DEFINITION_DIR);
   if (tier === "rafa")
     return bundledAgentsDirectory(seams.entry);
-  return seams.projectRoot === null ? null : join5(seams.projectRoot, AGENT_DEFINITION_DIR);
+  return seams.projectRoot === null ? null : join4(seams.projectRoot, AGENT_DEFINITION_DIR);
 }
 function readText3(path) {
   try {
@@ -4284,7 +3662,7 @@ function byName(items) {
   return [...items].sort((a, b) => a.name.localeCompare(b.name) || a.path.localeCompare(b.path));
 }
 function skillItem(report2, source, dir) {
-  const name2 = report2.name ?? relative3(dir, report2.path);
+  const name2 = report2.name ?? relative2(dir, report2.path);
   return sourceItem("skill", source, name2, report2.path, checkVerdict(report2.issues));
 }
 function readSkillTree(source, seams) {
@@ -4316,19 +3694,19 @@ function readTrees(seams) {
 
 // src/tiers/serve.ts
 import { cpSync, mkdirSync as mkdirSync2, readFileSync as readFileSync6, rmSync as rmSync2, writeFileSync as writeFileSync3 } from "fs";
-import { basename as basename4, dirname as dirname5, join as join7 } from "path";
+import { basename as basename4, dirname as dirname5, join as join6 } from "path";
 
 // src/loop/sessions.ts
 import {
   linkSync,
   mkdirSync,
-  readdirSync as readdirSync3,
+  readdirSync as readdirSync2,
   readFileSync as readFileSync5,
   renameSync,
   rmSync,
   writeFileSync as writeFileSync2
 } from "fs";
-import { basename as basename3, dirname as dirname4, join as join6 } from "path";
+import { basename as basename3, dirname as dirname4, join as join5 } from "path";
 var SESSION_STATES = Object.freeze(["running", "paused", "stopped", "done"]);
 var RUNS_DIR = "runs";
 var RECORD_EXTENSION = ".json";
@@ -4368,13 +3746,13 @@ function isSessionId(value) {
   return SESSION_ID_PATTERN.test(value);
 }
 function runsDir(root) {
-  return join6(scopeAt(root).dir, RUNS_DIR);
+  return join5(scopeAt(root).dir, RUNS_DIR);
 }
 function sessionFilePath(root, sessionId) {
   if (!isSessionId(sessionId)) {
     throw new Error(`session record: unusable session id ${JSON.stringify(sessionId)}`);
   }
-  return join6(runsDir(root), `${sessionId}${RECORD_EXTENSION}`);
+  return join5(runsDir(root), `${sessionId}${RECORD_EXTENSION}`);
 }
 function describeValue3(value) {
   return value === undefined ? "missing" : JSON.stringify(value) ?? String(value);
@@ -4484,7 +3862,7 @@ function readRecordFile(file) {
 }
 function recordNames(dir) {
   try {
-    return readdirSync3(dir);
+    return readdirSync2(dir);
   } catch (error) {
     if (errorCode(error) === "ENOENT")
       return [];
@@ -4497,7 +3875,7 @@ function byStart(a, b) {
 function readSessions(root, seams = {}) {
   const dir = runsDir(root);
   const isAlive = seams.isAlive ?? isPidAlive;
-  const records = recordNames(dir).filter((name2) => name2.endsWith(RECORD_EXTENSION)).map((name2) => readRecordFile(join6(dir, name2))).map((record) => Object.freeze({ ...record, state: readState(record, isAlive) }));
+  const records = recordNames(dir).filter((name2) => name2.endsWith(RECORD_EXTENSION)).map((name2) => readRecordFile(join5(dir, name2))).map((record) => Object.freeze({ ...record, state: readState(record, isAlive) }));
   return Object.freeze(records.sort(byStart));
 }
 function readSession(root, sessionId, seams = {}) {
@@ -4570,7 +3948,7 @@ var SERVED_AGENTS_FILE = "agents.json";
 var SERVED_PLUGIN_NAME = "rafa";
 var SKILL_FILE2 = "SKILL.md";
 var SERVED_SKILLS_PATH = {
-  "add-dir": join7(".claude", "skills"),
+  "add-dir": join6(".claude", "skills"),
   "plugin-dir": "skills"
 };
 var SKILL_DELIVERY_FLAG = {
@@ -4581,7 +3959,7 @@ function servedDirectory(root, run) {
   if (!isSessionId(run)) {
     throw new Error(`served directory: unusable run id ${JSON.stringify(run)}`);
   }
-  return join7(runsDir(root), run, SERVED_DIR);
+  return join6(runsDir(root), run, SERVED_DIR);
 }
 function rafaWinners(resolution) {
   return resolution.items.flatMap((item) => item.state === "served" && item.winner.source === "rafa" ? [item] : []);
@@ -4651,15 +4029,15 @@ function admit(row) {
   return block.ok ? read : block;
 }
 function copySkill(row, skills) {
-  const to = join7(skills, row.name);
+  const to = join6(skills, row.name);
   cpSync(dirname5(row.path), to, { recursive: true, dereference: true });
   return { kind: "skill", name: row.name, from: row.path, to };
 }
 function writePluginManifest(dir) {
-  const manifestDir = join7(dir, ".claude-plugin");
+  const manifestDir = join6(dir, ".claude-plugin");
   mkdirSync2(manifestDir, { recursive: true });
   const manifest = { name: SERVED_PLUGIN_NAME, description: "rafa-tier skills served to one loop session" };
-  writeFileSync3(join7(manifestDir, "plugin.json"), `${JSON.stringify(manifest, null, 2)}
+  writeFileSync3(join6(manifestDir, "plugin.json"), `${JSON.stringify(manifest, null, 2)}
 `);
 }
 function servedFlags(dir, delivery, skillCount, agents) {
@@ -4679,11 +4057,11 @@ function serveResolution(resolution, options) {
   rmSync2(dir, { recursive: true, force: true });
   mkdirSync2(dir, { recursive: true });
   const judged = rafaWinners(resolution).map((item) => ({ row: item.winner, verdict: serveVerdict(item.winner) }));
-  const skillsDir = join7(dir, SERVED_SKILLS_PATH[delivery]);
+  const skillsDir = join6(dir, SERVED_SKILLS_PATH[delivery]);
   const skills = judged.flatMap(({ row, verdict }) => verdict.ok && row.kind === "skill" ? [copySkill(row, skillsDir)] : []);
   if (skills.length > 0 && delivery === "plugin-dir")
     writePluginManifest(dir);
-  const agentsFile = join7(dir, SERVED_AGENTS_FILE);
+  const agentsFile = join6(dir, SERVED_AGENTS_FILE);
   const admitted = judged.flatMap(({ row, verdict }) => verdict.ok && verdict.value !== null ? [{ row, definition: verdict.value }] : []);
   const agentMap = Object.fromEntries(admitted.map(({ row, definition }) => [row.name, definition]));
   if (admitted.length > 0)
@@ -4720,12 +4098,12 @@ function isFileEntry(dir, entry) {
     return true;
   if (!entry.isSymbolicLink())
     return false;
-  return statSync4(join8(dir, entry.name), { throwIfNoEntry: false })?.isFile() === true;
+  return statSync3(join7(dir, entry.name), { throwIfNoEntry: false })?.isFile() === true;
 }
 function markdownFiles(dir) {
   let entries;
   try {
-    entries = readdirSync4(dir, { withFileTypes: true });
+    entries = readdirSync3(dir, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -4741,7 +4119,7 @@ function definitionName(text) {
 function readAgentDirectory(dir) {
   const found = [];
   for (const file of markdownFiles(dir)) {
-    const path = join8(dir, file);
+    const path = join7(dir, file);
     const text = readText4(path);
     if (text === null)
       continue;
@@ -4883,7 +4261,7 @@ function skillCollisionLine(colliding) {
 }
 
 // src/commands/plan/plan-files.ts
-import { statSync as statSync5 } from "fs";
+import { statSync as statSync4 } from "fs";
 import { resolve as resolve3 } from "path";
 function plansDirAt(root, planDir) {
   return { label: planDir, path: resolve3(root, planDir) };
@@ -4933,10 +4311,10 @@ function stubOfPlanFile(name2) {
   return stub !== undefined && isStampableStub(stub) ? stub : null;
 }
 function isFile(path) {
-  return statSync5(path, { throwIfNoEntry: false })?.isFile() ?? false;
+  return statSync4(path, { throwIfNoEntry: false })?.isFile() ?? false;
 }
-function issueLine(file, issue4) {
-  return `${file}:${issue4.line}: ${issue4.reason}: ${issue4.text}`;
+function issueLine(file, issue3) {
+  return `${file}:${issue3.line}: ${issue3.reason}: ${issue3.text}`;
 }
 function plural(count, noun) {
   return count === 1 ? `${count} ${noun}` : `${count} ${noun}s`;
@@ -5053,8 +4431,8 @@ function createPlanValidateCommand(workingDirectory = () => process.cwd()) {
       const { missingAgents, skillCollisions } = checkRoster(context, readFileSync8(file, "utf8"));
       const result = { ...validation, missingAgents, skillCollisions };
       if (issues.length > 0 || missingAgents.length > 0 || skillCollisions.length > 0) {
-        for (const issue4 of issues)
-          context.output.error(issueLine(typed, issue4));
+        for (const issue3 of issues)
+          context.output.error(issueLine(typed, issue3));
         for (const agent of missingAgents)
           context.output.error(`${typed}: ${missingAgentLine(agent)}`);
         for (const skill of skillCollisions)
@@ -5073,12 +4451,12 @@ function createPlanValidateCommand(workingDirectory = () => process.cwd()) {
 var validate_default = createPlanValidateCommand();
 
 // src/commands/plan/list.ts
-import { existsSync as existsSync8, readdirSync as readdirSync5, readFileSync as readFileSync9 } from "fs";
-import { join as join9 } from "path";
+import { existsSync as existsSync8, readdirSync as readdirSync4, readFileSync as readFileSync9 } from "fs";
+import { join as join8 } from "path";
 var USAGE2 = "rafa plan list";
 function listing(dir, stub) {
-  const plan = join9(dir, planFileName(stub, false));
-  const trackerPath = join9(dir, planFileName(stub, true));
+  const plan = join8(dir, planFileName(stub, false));
+  const trackerPath = join8(dir, planFileName(stub, true));
   const tracker = isFile(trackerPath) ? trackerPath : null;
   const planModel = parsePlan(readFileSync9(plan, "utf8"));
   const counted = tracker === null ? planModel : parsePlan(readFileSync9(tracker, "utf8"));
@@ -5088,7 +4466,7 @@ function listPlans(plans) {
   const dir = plans.path;
   if (!existsSync8(dir))
     return { dir, plans: [] };
-  const stubs = readdirSync5(dir).filter((name2) => isFile(join9(dir, name2))).map((name2) => stubOfPlanFile(name2)).filter((stub) => stub !== null).sort((a, b) => a.localeCompare(b));
+  const stubs = readdirSync4(dir).filter((name2) => isFile(join8(dir, name2))).map((name2) => stubOfPlanFile(name2)).filter((stub) => stub !== null).sort((a, b) => a.localeCompare(b));
   return { dir, plans: stubs.map((stub) => listing(dir, stub)) };
 }
 function rowNotes(plan) {
@@ -5142,8 +4520,8 @@ var planListCommand = {
 var list_default = Object.freeze(planListCommand);
 
 // src/board/gate.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync3, readFileSync as readFileSync10, renameSync as renameSync2, statSync as statSync6, writeFileSync as writeFileSync4 } from "fs";
-import { basename as basename5, dirname as dirname6, join as join10, resolve as resolve5 } from "path";
+import { existsSync as existsSync9, mkdirSync as mkdirSync3, readFileSync as readFileSync10, renameSync as renameSync2, statSync as statSync5, writeFileSync as writeFileSync4 } from "fs";
+import { basename as basename5, dirname as dirname6, join as join9, resolve as resolve5 } from "path";
 
 // src/board/flags.ts
 var SPEC_FLAG = "--spec";
@@ -5252,9 +4630,9 @@ function readLines2(body) {
   let fenced = false;
   raw.forEach((text, index) => {
     const number = index + 1;
-    const isFence2 = FENCE_LINE.test(text);
-    if (fenced || !carried && isFence2) {
-      fenced = !fenced || !isFence2;
+    const isFence = FENCE_LINE.test(text);
+    if (fenced || !carried && isFence) {
+      fenced = !fenced || !isFence;
       lines.push(fencedLine(number, text));
       return;
     }
@@ -5367,13 +4745,13 @@ function findReadinessGaps(body) {
 function hasSpecReadyLabel(labels) {
   return labels.some((label) => label.trim().toLowerCase() === SPEC_READY_LABEL);
 }
-function specReadyRefusalMessage(issue4) {
-  return `issue #${String(issue4)} is not marked ${SPEC_READY_LABEL}`;
+function specReadyRefusalMessage(issue3) {
+  return `issue #${String(issue3)} is not marked ${SPEC_READY_LABEL}`;
 }
-function requireSpecReadyLabel(issue4, labels) {
+function requireSpecReadyLabel(issue3, labels) {
   if (hasSpecReadyLabel(labels))
     return;
-  throw new CommandExit(READINESS_REFUSAL_EXIT, specReadyRefusalMessage(issue4));
+  throw new CommandExit(READINESS_REFUSAL_EXIT, specReadyRefusalMessage(issue3));
 }
 function describeGap(gap) {
   return `"${gap.heading}" ${gap.what}`;
@@ -5569,11 +4947,11 @@ async function readTrustedSpecReviewComment(comments, trust) {
   return { comment: null, ignored };
 }
 async function writeSpecReviewComment(options) {
-  const { body, issue: issue4, board, trust } = options;
-  const found = await readTrustedSpecReviewComment(await board.comments(issue4), trust);
+  const { body, issue: issue3, board, trust } = options;
+  const found = await readTrustedSpecReviewComment(await board.comments(issue3), trust);
   const { comment: existing, ignored } = found;
   if (existing === null) {
-    return { action: "posted", comment: await board.comment(issue4, body), ignored };
+    return { action: "posted", comment: await board.comment(issue3, body), ignored };
   }
   return { action: "edited", comment: await board.editComment(existing.id, body), ignored };
 }
@@ -5647,14 +5025,14 @@ function stampPlanField(plan, field3, value) {
     note: `line ${String(at + 1)} of the plan now records ${line}`
   };
 }
-function issueFieldLine(issue4) {
-  if (!Number.isSafeInteger(issue4) || issue4 < 1) {
-    throw new TypeError(`board plan field: issue ${String(issue4)} is no issue number, expected a positive whole one`);
+function issueFieldLine(issue3) {
+  if (!Number.isSafeInteger(issue3) || issue3 < 1) {
+    throw new TypeError(`board plan field: issue ${String(issue3)} is no issue number, expected a positive whole one`);
   }
-  return `${ISSUE_FIELD}: ${JSON.stringify(String(issue4))}`;
+  return `${ISSUE_FIELD}: ${JSON.stringify(String(issue3))}`;
 }
-function stampPlanIssue(plan, issue4) {
-  return stampPlanField(plan, ISSUE_FIELD, JSON.stringify(String(issue4)));
+function stampPlanIssue(plan, issue3) {
+  return stampPlanField(plan, ISSUE_FIELD, JSON.stringify(String(issue3)));
 }
 
 // src/board/review-stamp.ts
@@ -5701,14 +5079,14 @@ function readGateFlags(args) {
 function describeGap2(gap) {
   return `   \u2022 "${gap.heading}": ${gap.what}`;
 }
-function remedyFor(issue4) {
-  return issue4 === null ? "   Close the gaps in the spec, then plan from it again." : `   Close the gaps, label the issue ${SPEC_READY_LABEL} again, and plan from it again.`;
+function remedyFor(issue3) {
+  return issue3 === null ? "   Close the gaps in the spec, then plan from it again." : `   Close the gaps, label the issue ${SPEC_READY_LABEL} again, and plan from it again.`;
 }
-function specNotReadyMessage(source, reading, gaps, issue4 = null) {
+function specNotReadyMessage(source, reading, gaps, issue3 = null) {
   return [
     `\u274C ${source} is not ready to plan from: ${reading}`,
     ...gaps.map(describeGap2),
-    remedyFor(issue4)
+    remedyFor(issue3)
   ].join(`
 `);
 }
@@ -5728,14 +5106,14 @@ function unreadReviewMessage(source, reading, planIssues) {
 }
 function isWrittenFile(repoRoot, path) {
   const full = resolve5(repoRoot, path);
-  return existsSync9(full) && statSync6(full).isFile();
+  return existsSync9(full) && statSync5(full).isFile();
 }
 var NOT_READY_REASON = "the planner judged the spec not ready, so no plan stands.";
 var UNREAD_REASON = "no review came back and the plan does not read as written, so no plan stands.";
 var REJECTED_DIR = "rejected";
 function rejectedPath(path) {
   const parent = dirname6(path);
-  return parent === "." ? join10(REJECTED_DIR, basename5(path)) : join10(parent, REJECTED_DIR, basename5(path));
+  return parent === "." ? join9(REJECTED_DIR, basename5(path)) : join9(parent, REJECTED_DIR, basename5(path));
 }
 function moveWritten(options, output, reason) {
   for (const path of [options.planPath, options.prerequisitesPath]) {
@@ -5758,7 +5136,7 @@ function readWrittenPlan(options) {
   }
   try {
     const { issues } = validatePlan(resolve5(repoRoot, planPath));
-    return { reads: issues.length === 0, issues: issues.map((issue4) => issueLine(planPath, issue4)) };
+    return { reads: issues.length === 0, issues: issues.map((issue3) => issueLine(planPath, issue3)) };
   } catch (error) {
     return { reads: false, issues: [`${planPath}: ${messageOf(error)}`] };
   }
@@ -5796,27 +5174,27 @@ function recordAssumptions(options, gaps, output) {
   }
   output.info(`\uD83E\uDDED ${planPath} opens under the review's assumptions and records ${REVIEW_ASSUMED_LINE}.`);
 }
-async function publishGaps(issue4, gaps, body, output) {
+async function publishGaps(issue3, gaps, body, output) {
   try {
     const write = await writeSpecReviewComment({
-      issue: issue4.number,
+      issue: issue3.number,
       body: body(gaps),
-      board: issue4.board,
-      trust: issue4.trust
+      board: issue3.board,
+      trust: issue3.trust
     });
     for (const passed2 of write.ignored)
       output.warn(passed2.reason);
-    output.info(`\uD83D\uDCAC ${write.action === "posted" ? "Posted" : "Edited"} the review comment on issue #${String(issue4.number)}.`);
+    output.info(`\uD83D\uDCAC ${write.action === "posted" ? "Posted" : "Edited"} the review comment on issue #${String(issue3.number)}.`);
   } catch (error) {
-    output.warn(`the review comment on issue #${String(issue4.number)} was not written: ${messageOf(error)}`);
+    output.warn(`the review comment on issue #${String(issue3.number)} was not written: ${messageOf(error)}`);
   }
 }
-async function swapLabels(issue4, output) {
+async function swapLabels(issue3, output) {
   try {
-    await issue4.board.swapLabels(issue4.number, SPEC_READY_LABEL, SPEC_NEEDS_WORK_LABEL);
-    output.info(`\uD83C\uDFF7  Swapped ${SPEC_READY_LABEL} for ${SPEC_NEEDS_WORK_LABEL} on issue #${String(issue4.number)}.`);
+    await issue3.board.swapLabels(issue3.number, SPEC_READY_LABEL, SPEC_NEEDS_WORK_LABEL);
+    output.info(`\uD83C\uDFF7  Swapped ${SPEC_READY_LABEL} for ${SPEC_NEEDS_WORK_LABEL} on issue #${String(issue3.number)}.`);
   } catch (error) {
-    output.warn(`${SPEC_READY_LABEL} was not swapped for ${SPEC_NEEDS_WORK_LABEL} on issue` + ` #${String(issue4.number)}: ${messageOf(error)}`);
+    output.warn(`${SPEC_READY_LABEL} was not swapped for ${SPEC_NEEDS_WORK_LABEL} on issue` + ` #${String(issue3.number)}: ${messageOf(error)}`);
   }
 }
 function nothingBlocks(review) {
@@ -5825,18 +5203,18 @@ function nothingBlocks(review) {
 async function planUnderAssumptions(options, review, output) {
   output.warn(assumedReviewWarning(review.text, options.planPath));
   recordAssumptions(options, review.gaps, output);
-  const { issue: issue4 } = options;
-  if (issue4 !== null) {
+  const { issue: issue3 } = options;
+  if (issue3 !== null) {
     if (options.comment) {
-      await publishGaps(issue4, review.gaps, assumedReviewCommentBody, output);
+      await publishGaps(issue3, review.gaps, assumedReviewCommentBody, output);
     } else {
-      output.info(`\uD83D\uDCAC ${NO_COMMENT_FLAG}: the gaps were not posted on issue #${String(issue4.number)}.`);
+      output.info(`\uD83D\uDCAC ${NO_COMMENT_FLAG}: the gaps were not posted on issue #${String(issue3.number)}.`);
     }
   }
   return "assumed";
 }
 async function enforceSpecReview(options) {
-  const { review, issue: issue4 } = options;
+  const { review, issue: issue3 } = options;
   if (review === undefined)
     return "unjudged";
   if (review.ready)
@@ -5847,15 +5225,15 @@ async function enforceSpecReview(options) {
   if (nothingBlocks(review))
     return planUnderAssumptions(options, review, output);
   moveWritten(options, output, NOT_READY_REASON);
-  if (issue4 !== null) {
+  if (issue3 !== null) {
     if (options.comment) {
-      await publishGaps(issue4, review.gaps, specReviewCommentBody, output);
+      await publishGaps(issue3, review.gaps, specReviewCommentBody, output);
     } else {
-      output.info(`\uD83D\uDCAC ${NO_COMMENT_FLAG}: the gaps were not posted on issue #${String(issue4.number)}.`);
+      output.info(`\uD83D\uDCAC ${NO_COMMENT_FLAG}: the gaps were not posted on issue #${String(issue3.number)}.`);
     }
-    await swapLabels(issue4, output);
+    await swapLabels(issue3, output);
   }
-  throw new CommandExit(SPEC_NOT_READY_EXIT, specNotReadyMessage(options.source, review.text, review.gaps, issue4));
+  throw new CommandExit(SPEC_NOT_READY_EXIT, specNotReadyMessage(options.source, review.text, review.gaps, issue3));
 }
 
 // src/board/issue-board.ts
@@ -5930,8 +5308,8 @@ function createGhIssueBoard(options) {
   }
   const commentsPath = (number) => `repos/${REPO_PATH2}/issues/${number}/comments`;
   const board = {
-    comments: async (issue4) => {
-      const path = commentsPath(issueNumber(issue4, "comments"));
+    comments: async (issue3) => {
+      const path = commentsPath(issueNumber(issue3, "comments"));
       const command = `gh api ${path}`;
       const rows = parseJson(await succeed(["api", path], command), command);
       if (!Array.isArray(rows)) {
@@ -5939,8 +5317,8 @@ function createGhIssueBoard(options) {
       }
       return rows.map((row, index) => readComment(row, command, `comment ${String(index)}`));
     },
-    comment: async (issue4, body) => {
-      const path = commentsPath(issueNumber(issue4, "comment"));
+    comment: async (issue3, body) => {
+      const path = commentsPath(issueNumber(issue3, "comment"));
       const text = commentBody2(body, "comment");
       const command = `gh api -X POST ${path}`;
       const stdout = await succeed(["api", path, "-X", "POST", "-f", `body=${text}`], command);
@@ -5953,14 +5331,14 @@ function createGhIssueBoard(options) {
       const stdout = await succeed(["api", path, "-X", "PATCH", "-f", `body=${text}`], command);
       return readComment(parseJson(stdout, command), command, "the comment");
     },
-    swapLabels: async (issue4, removed, added) => {
-      const number = issueNumber(issue4, "swapLabels");
+    swapLabels: async (issue3, removed, added) => {
+      const number = issueNumber(issue3, "swapLabels");
       const off = labelName(removed, "swapLabels", "the removed label");
       const on = labelName(added, "swapLabels", "the added label");
       await succeed(["issue", "edit", number, "--remove-label", off, "--add-label", on], `gh issue edit ${number} --remove-label ${off} --add-label ${on}`);
     },
-    removeLabel: async (issue4, label) => {
-      const number = issueNumber(issue4, "removeLabel");
+    removeLabel: async (issue3, label) => {
+      const number = issueNumber(issue3, "removeLabel");
       const off = labelName(label, "removeLabel", "the label");
       await succeed(["issue", "edit", number, "--remove-label", off], `gh issue edit ${number} --remove-label ${off}`);
     }
@@ -5969,11 +5347,11 @@ function createGhIssueBoard(options) {
 }
 
 // src/board/issue.ts
-import { existsSync as existsSync10, mkdirSync as mkdirSync5, readFileSync as readFileSync11, statSync as statSync8, writeFileSync as writeFileSync5 } from "fs";
+import { existsSync as existsSync10, mkdirSync as mkdirSync5, readFileSync as readFileSync11, statSync as statSync7, writeFileSync as writeFileSync5 } from "fs";
 import { dirname as dirname7, resolve as resolve7 } from "path";
 
 // src/refs/stamp.ts
-import { createHash as createHash2 } from "crypto";
+import { createHash } from "crypto";
 var PRESENT = Object.freeze({ kind: "present" });
 var ABSENT = Object.freeze({ kind: "absent" });
 var UNREADABLE = Object.freeze({ kind: "unreadable" });
@@ -6007,7 +5385,7 @@ function normaliseIssueText(text) {
 `).trimEnd();
 }
 function sha256(text) {
-  return createHash2("sha256").update(text, "utf8").digest("hex");
+  return createHash("sha256").update(text, "utf8").digest("hex");
 }
 function sectionName(line) {
   const text = line.trim().replace(/^##/u, "").replace(/[ \t]+#+$/u, "").trim();
@@ -6034,15 +5412,15 @@ function sections(body) {
   }
   return byName2;
 }
-function issueFingerprint(issue4) {
-  const title = normaliseIssueText(issue4.title);
-  const body = normaliseIssueText(issue4.body);
+function issueFingerprint(issue3) {
+  const title = normaliseIssueText(issue3.title);
+  const body = normaliseIssueText(issue3.body);
   const headings = [...sections(body)].map(([name2, lines]) => Object.freeze({ name: name2, digest: sha256(lines.join(`
 `)) }));
   return Object.freeze({
     kind: "issue",
     digest: sha256(JSON.stringify([title, body])),
-    state: issue4.state,
+    state: issue3.state,
     headings: Object.freeze(headings)
   });
 }
@@ -6264,11 +5642,11 @@ var STOP_WORDS = new Set([
 var CLAUSE_BREAK = /[,;:([\u2013\u2014]|\s-\s/u;
 var LEADING_ID = /^\s*#?rafa[-\s]?\d+\s*[-:.\u2013\u2014]?\s*/iu;
 var NON_WORD = /[^a-z0-9]+/gu;
-function requireIssueNumber(issue4) {
-  if (!Number.isInteger(issue4) || issue4 <= 0) {
-    throw new RangeError(`An issue number must be a positive integer, not ${String(issue4)}.`);
+function requireIssueNumber(issue3) {
+  if (!Number.isInteger(issue3) || issue3 <= 0) {
+    throw new RangeError(`An issue number must be a positive integer, not ${String(issue3)}.`);
   }
-  return issue4;
+  return issue3;
 }
 function wordsOf(title) {
   return title.toLowerCase().replace(NON_WORD, " ").split(" ").filter((word) => word !== "");
@@ -6287,35 +5665,35 @@ function slugFromTitle(title) {
     return FALLBACK_SLUG;
   return chosen.slice(0, MAX_SLUG_WORDS).join("-");
 }
-function boardId(issue4) {
-  return `${ID_PREFIX}-${requireIssueNumber(issue4)}`;
+function boardId(issue3) {
+  return `${ID_PREFIX}-${requireIssueNumber(issue3)}`;
 }
-function planStub(issue4, title) {
-  return `${boardId(issue4)}-${slugFromTitle(title)}`;
+function planStub(issue3, title) {
+  return `${boardId(issue3)}-${slugFromTitle(title)}`;
 }
-function specFileName(issue4, title) {
-  return `${planStub(issue4, title)}${SPEC_EXTENSION}`;
+function specFileName(issue3, title) {
+  return `${planStub(issue3, title)}${SPEC_EXTENSION}`;
 }
-function specPath(specsDir, issue4, title) {
-  return path.join(specsDir, specFileName(issue4, title));
+function specPath(specsDir, issue3, title) {
+  return path.join(specsDir, specFileName(issue3, title));
 }
-function notesFileName(issue4) {
-  return `${boardId(issue4)}${NOTES_SUFFIX}${SPEC_EXTENSION}`;
+function notesFileName(issue3) {
+  return `${boardId(issue3)}${NOTES_SUFFIX}${SPEC_EXTENSION}`;
 }
-function notesPath(specsDir, issue4) {
-  return path.join(specsDir, notesFileName(issue4));
+function notesPath(specsDir, issue3) {
+  return path.join(specsDir, notesFileName(issue3));
 }
 
 // src/board/previous-copy.ts
-import { linkSync as linkSync2, mkdirSync as mkdirSync4, readdirSync as readdirSync6, statSync as statSync7, unlinkSync } from "fs";
-import { basename as basename6, extname, join as join11, resolve as resolve6 } from "path";
+import { linkSync as linkSync2, mkdirSync as mkdirSync4, readdirSync as readdirSync5, statSync as statSync6, unlinkSync } from "fs";
+import { basename as basename6, extname, join as join10, resolve as resolve6 } from "path";
 var PREFIX2 = "board previous copy";
 var PREVIOUS_DIR_NAME = "previous";
 var PREVIOUS_COPY_WARN_ABOVE = 50;
 var COPY_EXTENSION = ".md";
 var FIRST_SUFFIX = 2;
 function previousDir(specsDir) {
-  return join11(specsDir, PREVIOUS_DIR_NAME);
+  return join10(specsDir, PREVIOUS_DIR_NAME);
 }
 function two(value) {
   return String(value).padStart(2, "0");
@@ -6337,7 +5715,7 @@ function linkUnderFreeName(source, directory, savedName, timestamp) {
   for (let attempt = 1;; attempt += 1) {
     const name2 = previousCopyName(savedName, timestamp, attempt);
     try {
-      linkSync2(source, join11(directory, name2));
+      linkSync2(source, join10(directory, name2));
       return name2;
     } catch (error) {
       if (!isTaken(error))
@@ -6353,15 +5731,15 @@ function movePreviousCopy(options) {
   const savedName = basename6(path2);
   let name2;
   try {
-    const timestamp = previousTimestamp(statSync7(source).mtime);
+    const timestamp = previousTimestamp(statSync6(source).mtime);
     mkdirSync4(absoluteDirectory, { recursive: true });
     name2 = linkUnderFreeName(source, absoluteDirectory, savedName, timestamp);
   } catch (error) {
     throw new Error(`${PREFIX2}: ${path2} could not be moved to ${directory}: ${messageOf(error)}`, { cause: error });
   }
   const moved = {
-    path: join11(directory, name2),
-    absolute: join11(absoluteDirectory, name2)
+    path: join10(directory, name2),
+    absolute: join10(absoluteDirectory, name2)
   };
   try {
     unlinkSync(source);
@@ -6376,7 +5754,7 @@ function isMissing(error) {
 function countPreviousCopies(repoRoot, specsDir) {
   const directory = previousDir(specsDir);
   try {
-    return readdirSync6(resolve6(repoRoot, directory), { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(COPY_EXTENSION)).length;
+    return readdirSync5(resolve6(repoRoot, directory), { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(COPY_EXTENSION)).length;
   } catch (error) {
     if (isMissing(error))
       return 0;
@@ -6448,30 +5826,30 @@ function readViewedIssue(stdout, number, command) {
 }
 function createGhSpecIssueReader(options) {
   const { gh } = options;
-  return async (issue4) => {
-    const number = issueNumber2(issue4);
+  return async (issue3) => {
+    const number = issueNumber2(issue3);
     const command = `gh issue view ${number} --json ${ISSUE_VIEW_FIELDS}`;
     const result = await gh(["issue", "view", number, "--json", ISSUE_VIEW_FIELDS]);
     if (!result.ok)
       throw new Error(`${PREFIX3}: ${detailOf3(result, command)}`);
-    return readViewedIssue(result.stdout, issue4, command);
+    return readViewedIssue(result.stdout, issue3, command);
   };
 }
 function hasSpecLabel(labels) {
   return labels.some((label) => label.trim().toLowerCase() === SPEC_LABEL);
 }
-function closedIssueMessage(issue4) {
-  return `issue #${String(issue4)} is closed, and a plan is written from an issue that is open;` + " reopen it, or plan from the issue that took its place";
+function closedIssueMessage(issue3) {
+  return `issue #${String(issue3)} is closed, and a plan is written from an issue that is open;` + " reopen it, or plan from the issue that took its place";
 }
-function missingSpecLabelMessage(issue4) {
-  return `issue #${String(issue4)} is not labelled ${SPEC_LABEL}, so it is not a spec;` + ` label it ${SPEC_LABEL}, or plan from the spec issue instead`;
+function missingSpecLabelMessage(issue3) {
+  return `issue #${String(issue3)} is not labelled ${SPEC_LABEL}, so it is not a spec;` + ` label it ${SPEC_LABEL}, or plan from the spec issue instead`;
 }
-function requireSpecIssue(issue4) {
-  if (issue4.state === "CLOSED") {
-    throw new CommandExit(ISSUE_REFUSAL_EXIT, closedIssueMessage(issue4.number));
+function requireSpecIssue(issue3) {
+  if (issue3.state === "CLOSED") {
+    throw new CommandExit(ISSUE_REFUSAL_EXIT, closedIssueMessage(issue3.number));
   }
-  if (!hasSpecLabel(issue4.labels)) {
-    throw new CommandExit(ISSUE_REFUSAL_EXIT, missingSpecLabelMessage(issue4.number));
+  if (!hasSpecLabel(issue3.labels)) {
+    throw new CommandExit(ISSUE_REFUSAL_EXIT, missingSpecLabelMessage(issue3.number));
   }
 }
 function normalise(text) {
@@ -6576,7 +5954,7 @@ function readSnapshotChange(options) {
 function readIfFile(file, what) {
   if (!existsSync10(file))
     return null;
-  if (!statSync8(file).isFile()) {
+  if (!statSync7(file).isFile()) {
     throw new CommandExit(ISSUE_REFUSAL_EXIT, `${what} ${file} is not a file, and a spec is one`);
   }
   try {
@@ -6585,26 +5963,26 @@ function readIfFile(file, what) {
     throw new CommandExit(ISSUE_REFUSAL_EXIT, `${what} ${file} could not be read: ${messageOf(error)}`);
   }
 }
-function readLocalNotes(repoRoot, specsDir, issue4) {
-  return readIfFile(resolve7(repoRoot, notesPath(specsDir, issue4)), "the local notes");
+function readLocalNotes(repoRoot, specsDir, issue3) {
+  return readIfFile(resolve7(repoRoot, notesPath(specsDir, issue3)), "the local notes");
 }
-function snapshotDiffersMessage(path2, issue4) {
-  return `${path2} is a snapshot of issue #${String(issue4)} that no longer matches it:` + " the issue body, or the local notes appended to it, changed since the snapshot was written;" + ` pass ${REFRESH_FLAG} to plan from the issue as it reads now, or --spec=${path2} to plan from` + " the snapshot as it stands";
+function snapshotDiffersMessage(path2, issue3) {
+  return `${path2} is a snapshot of issue #${String(issue3)} that no longer matches it:` + " the issue body, or the local notes appended to it, changed since the snapshot was written;" + ` pass ${REFRESH_FLAG} to plan from the issue as it reads now, or --spec=${path2} to plan from` + " the snapshot as it stands";
 }
-function notesCollisionMessage(path2, issue4) {
-  return `the snapshot of issue #${String(issue4)} and its local notes are both ${path2},` + " so writing the snapshot would overwrite the notes; retitle the issue";
+function notesCollisionMessage(path2, issue3) {
+  return `the snapshot of issue #${String(issue3)} and its local notes are both ${path2},` + " so writing the snapshot would overwrite the notes; retitle the issue";
 }
 function writeSpecSnapshot(options) {
-  const { repoRoot, specsDir, issue: issue4, refresh } = options;
-  const path2 = specPath(specsDir, issue4.number, issue4.title);
-  const notes = notesPath(specsDir, issue4.number);
+  const { repoRoot, specsDir, issue: issue3, refresh } = options;
+  const path2 = specPath(specsDir, issue3.number, issue3.title);
+  const notes = notesPath(specsDir, issue3.number);
   if (path2 === notes) {
-    throw new CommandExit(ISSUE_REFUSAL_EXIT, notesCollisionMessage(path2, issue4.number));
+    throw new CommandExit(ISSUE_REFUSAL_EXIT, notesCollisionMessage(path2, issue3.number));
   }
-  const local = readLocalNotes(repoRoot, specsDir, issue4.number);
+  const local = readLocalNotes(repoRoot, specsDir, issue3.number);
   const absolute = resolve7(repoRoot, path2);
   const existing = readIfFile(absolute, "the spec snapshot");
-  const text = carryRefsBlock(existing, snapshotText(issue4.body, local));
+  const text = carryRefsBlock(existing, snapshotText(issue3.body, local));
   const written = {
     path: path2,
     absolute,
@@ -6613,11 +5991,11 @@ function writeSpecSnapshot(options) {
     previous: null,
     text
   };
-  const action = rewriteAction(existing, issue4.body, local, notes, refresh);
+  const action = rewriteAction(existing, issue3.body, local, notes, refresh);
   if (action === "unchanged")
     return { ...written, action, text: existing ?? text };
   if (action === null) {
-    throw new CommandExit(ISSUE_REFUSAL_EXIT, snapshotDiffersMessage(path2, issue4.number));
+    throw new CommandExit(ISSUE_REFUSAL_EXIT, snapshotDiffersMessage(path2, issue3.number));
   }
   const previous = action === "created" ? null : movePreviousCopy({ repoRoot, specsDir, path: path2 }).path;
   try {
@@ -6640,10 +6018,10 @@ function rewriteAction(existing, body, notes, notesFile, refresh) {
 }
 
 // src/pr/git.ts
-import { spawnSync as spawnSync2 } from "child_process";
+import { spawnSync } from "child_process";
 function createGitRunner(cwd) {
   return (args) => {
-    const result = spawnSync2("git", [...args], {
+    const result = spawnSync("git", [...args], {
       cwd,
       encoding: "utf8",
       env: { ...process.env, LC_ALL: "C" }
@@ -6787,11 +6165,11 @@ function parseRoadmapBody(body) {
     if (found === null)
       return;
     const [, box = "", digits = "", rest = ""] = found;
-    const issue4 = Number.parseInt(digits, 10);
-    if (!Number.isSafeInteger(issue4) || issue4 < 1)
+    const issue3 = Number.parseInt(digits, 10);
+    if (!Number.isSafeInteger(issue3) || issue3 < 1)
       return;
     lines = [...lines, {
-      issue: issue4,
+      issue: issue3,
       ticked: box.trim() !== "",
       why: whyOf(rest),
       lineNumber: index + 1
@@ -6856,11 +6234,11 @@ async function resolveRoadmapIssue(options) {
   if (configured !== null)
     return configured;
   const wanted = ROADMAP_TITLE.toLowerCase();
-  const titled = (await search()).filter((issue4) => issue4.title.trim().toLowerCase() === wanted);
+  const titled = (await search()).filter((issue3) => issue3.title.trim().toLowerCase() === wanted);
   if (titled.length === 0)
     throw new CommandExit(ROADMAP_REFUSAL_EXIT, noRoadmapMessage());
   if (titled.length > 1) {
-    throw new CommandExit(ROADMAP_REFUSAL_EXIT, severalRoadmapsMessage(titled.map((issue4) => issue4.number)));
+    throw new CommandExit(ROADMAP_REFUSAL_EXIT, severalRoadmapsMessage(titled.map((issue3) => issue3.number)));
   }
   return titled[0]?.number ?? 0;
 }
@@ -6881,10 +6259,10 @@ function createGhOpenPullRequests(options) {
   };
 }
 function closedIssuesIn(body) {
-  return Object.freeze([...body.matchAll(CLOSING)].map((found) => Number.parseInt(found[1] ?? "", 10)).filter((issue4) => Number.isSafeInteger(issue4) && issue4 > 0));
+  return Object.freeze([...body.matchAll(CLOSING)].map((found) => Number.parseInt(found[1] ?? "", 10)).filter((issue3) => Number.isSafeInteger(issue3) && issue3 > 0));
 }
-function branchClaims(ref, issue4) {
-  const claim = `${BRANCH_PREFIX}/${boardId(issue4)}`;
+function branchClaims(ref, issue3) {
+  const claim = `${BRANCH_PREFIX}/${boardId(issue3)}`;
   return new RegExp(`(?:^|/)${claim}(?:-|$)`, "u").test(ref);
 }
 function outputLines(stdout) {
@@ -6909,11 +6287,11 @@ function createRoadmapReadings(options) {
   const { issues, branches, pullRequests } = options;
   let open = null;
   return Object.freeze({
-    isClosed: async (issue4) => (await issues(issue4)).state === "CLOSED",
-    branchFor: (issue4) => branches.refs.find((ref) => branchClaims(ref, issue4)) ?? null,
-    pullRequestFor: async (issue4) => {
+    isClosed: async (issue3) => (await issues(issue3)).state === "CLOSED",
+    branchFor: (issue3) => branches.refs.find((ref) => branchClaims(ref, issue3)) ?? null,
+    pullRequestFor: async (issue3) => {
       open = open ?? pullRequests();
-      const closing = (await open).find((pull) => closedIssuesIn(pull.body).includes(issue4));
+      const closing = (await open).find((pull) => closedIssuesIn(pull.body).includes(issue3));
       return closing?.number ?? null;
     }
   });
@@ -7000,10 +6378,10 @@ function foreignIn(text) {
   return found;
 }
 var NAMED_NOTHING = { ids: [], foreign: [] };
-function reading(kind, issue4, found, named, unknown) {
+function reading(kind, issue3, found, named, unknown) {
   return {
     kind,
-    issue: issue4,
+    issue: issue3,
     line: found?.number ?? null,
     text: found?.text ?? null,
     blockers: named.ids,
@@ -7011,21 +6389,21 @@ function reading(kind, issue4, found, named, unknown) {
     unknown
   };
 }
-function readBlockedBy(issue4, body, known) {
+function readBlockedBy(issue3, body, known) {
   const found = findFieldLine(body);
   if (found === null)
-    return reading("no-line", issue4, null, NAMED_NOTHING, []);
+    return reading("no-line", issue3, null, NAMED_NOTHING, []);
   const foreign = foreignIn(found.text);
   const ids = idsIn(found.text.replace(FOREIGN_ID, " "));
   const named = { ids, foreign };
   if (ids.length === 0)
-    return reading("no-ids", issue4, found, named, []);
-  const unknown = known === undefined ? [] : ids.filter((id) => id !== issue4 && !known.has(id));
-  if (ids.includes(issue4))
-    return reading("self-reference", issue4, found, named, unknown);
+    return reading("no-ids", issue3, found, named, []);
+  const unknown = known === undefined ? [] : ids.filter((id) => id !== issue3 && !known.has(id));
+  if (ids.includes(issue3))
+    return reading("self-reference", issue3, found, named, unknown);
   if (unknown.length > 0)
-    return reading("unknown-issue", issue4, found, named, unknown);
-  return reading("blocked", issue4, found, named, unknown);
+    return reading("unknown-issue", issue3, found, named, unknown);
+  return reading("blocked", issue3, found, named, unknown);
 }
 function nameIds(ids) {
   return ids.map((id) => `#${String(id)}`).join(" ");
@@ -7055,17 +6433,17 @@ function blockedFaultMessage(read) {
 
 // src/board/blocked-line.ts
 function blockerStatesOf(issues) {
-  return async (issue4) => {
+  return async (issue3) => {
     try {
-      return (await issues(issue4)).state;
+      return (await issues(issue3)).state;
     } catch {
       return null;
     }
   };
 }
-function blocked(issue4, blockers, open, unread, fault) {
+function blocked(issue3, blockers, open, unread, fault) {
   return Object.freeze({
-    issue: issue4,
+    issue: issue3,
     blockers: Object.freeze([...blockers]),
     open: Object.freeze([...open]),
     unread: Object.freeze([...unread]),
@@ -7079,17 +6457,17 @@ async function heldStates(blockers, states) {
   }
   return held;
 }
-async function readBlockedLine(issue4, states) {
-  if (!hasSpecBlockedLabel(issue4.labels))
+async function readBlockedLine(issue3, states) {
+  if (!hasSpecBlockedLabel(issue3.labels))
     return null;
-  const read = readBlockedBy(issue4.number, issue4.body);
+  const read = readBlockedBy(issue3.number, issue3.body);
   if (read.kind !== "blocked") {
-    return blocked(issue4.number, read.blockers, [], [], blockedFaultMessage(read));
+    return blocked(issue3.number, read.blockers, [], [], blockedFaultMessage(read));
   }
   const held = await heldStates(read.blockers, states);
   const open = held.filter((one) => one.state === "OPEN").map((one) => one.id);
   const unread = held.filter((one) => one.state === null).map((one) => one.id);
-  return open.length + unread.length === 0 ? null : blocked(issue4.number, read.blockers, open, unread, null);
+  return open.length + unread.length === 0 ? null : blocked(issue3.number, read.blockers, open, unread, null);
 }
 function nameBlockers(line) {
   return [
@@ -7105,12 +6483,12 @@ function plannableReadings(options) {
   const states = blockerStatesOf(issues);
   return Object.freeze({
     skip: (line) => readRoadmapSkip(line, readings),
-    blocking: async (issue4) => readBlockedLine(await issues(issue4), states),
-    isReady: async (issue4) => hasSpecReadyLabel((await issues(issue4)).labels)
+    blocking: async (issue3) => readBlockedLine(await issues(issue3), states),
+    isReady: async (issue3) => hasSpecReadyLabel((await issues(issue3)).labels)
   });
 }
-function notReadySentence(issue4) {
-  return `#${String(issue4)} not ready: it carries no ${SPEC_READY_LABEL} label`;
+function notReadySentence(issue3) {
+  return `#${String(issue3)} not ready: it carries no ${SPEC_READY_LABEL} label`;
 }
 async function passOf(line, readings) {
   const skip = await readings.skip(line);
@@ -7132,40 +6510,40 @@ async function pickPlannableLine(lines, after, readings) {
   }
   return Object.freeze({ line: null, passed: Object.freeze(passed2) });
 }
-function alternativeQuestion(issue4) {
-  return `Plan #${String(issue4)} instead? [y/N] `;
+function alternativeQuestion(issue3) {
+  return `Plan #${String(issue3)} instead? [y/N] `;
 }
-function noAlternativeMessage(issue4) {
-  const number = String(issue4);
+function noAlternativeMessage(issue3) {
+  const number = String(issue3);
   return `no line under #${number} is ready, not blocked and not taken, so there is nothing to plan instead;` + ` take ${SPEC_BLOCKED_LABEL} off #${number} with rafa issue unblock ${number} once its blockers close`;
 }
-function unaskedMessage(issue4, alternative) {
+function unaskedMessage(issue3, alternative) {
   const number = String(alternative);
-  return `#${number} takes a yes and this run has nobody to ask, so nothing was planned;` + ` plan it with rafa plan create --issue=${number},` + ` or clear #${String(issue4)} with rafa issue unblock ${String(issue4)}`;
+  return `#${number} takes a yes and this run has nobody to ask, so nothing was planned;` + ` plan it with rafa plan create --issue=${number},` + ` or clear #${String(issue3)} with rafa issue unblock ${String(issue3)}`;
 }
 function declinedMessage(alternative) {
   return `#${String(alternative)} was not planned, and nothing was written`;
 }
 
 // src/board/snapshot-settle.ts
-import { existsSync as existsSync11, readFileSync as readFileSync12, statSync as statSync9 } from "fs";
+import { existsSync as existsSync11, readFileSync as readFileSync12, statSync as statSync8 } from "fs";
 import { resolve as resolve8 } from "path";
 var PREFIX5 = "board snapshot settle";
 var DATE_LENGTH = 10;
 function savedCopyDate(savedAt) {
   return savedAt.toISOString().slice(0, DATE_LENGTH);
 }
-function refreshQuestion(issue4, savedAt) {
-  return `Issue #${String(issue4)} changed since the saved copy of ${savedCopyDate(savedAt)}.` + " Plan from it as it reads now? [y/N] ";
+function refreshQuestion(issue3, savedAt) {
+  return `Issue #${String(issue3)} changed since the saved copy of ${savedCopyDate(savedAt)}.` + " Plan from it as it reads now? [y/N] ";
 }
-function notesRebuiltLine(path2, issue4, previous) {
-  return `local notes changed; rebuilt ${path2} from issue #${String(issue4)} and the notes,` + ` the old copy is at ${previous}`;
+function notesRebuiltLine(path2, issue3, previous) {
+  return `local notes changed; rebuilt ${path2} from issue #${String(issue3)} and the notes,` + ` the old copy is at ${previous}`;
 }
 function readSavedCopy(absolute, path2) {
   if (!existsSync11(absolute))
     return null;
   try {
-    const stat = statSync9(absolute);
+    const stat = statSync8(absolute);
     if (!stat.isFile())
       return null;
     return { text: readFileSync12(absolute, "utf8"), savedAt: stat.mtime };
@@ -7180,10 +6558,10 @@ function printChange(change, output) {
   }
 }
 async function settleSpecSnapshot(options) {
-  const { repoRoot, specsDir, issue: issue4, refresh, output } = options;
-  const write = (rewrite) => writeSpecSnapshot({ repoRoot, specsDir, issue: issue4, refresh: rewrite });
-  const path2 = specPath(specsDir, issue4.number, issue4.title);
-  const notes = notesPath(specsDir, issue4.number);
+  const { repoRoot, specsDir, issue: issue3, refresh, output } = options;
+  const write = (rewrite) => writeSpecSnapshot({ repoRoot, specsDir, issue: issue3, refresh: rewrite });
+  const path2 = specPath(specsDir, issue3.number, issue3.title);
+  const notes = notesPath(specsDir, issue3.number);
   if (path2 === notes)
     return write(refresh);
   const saved = readSavedCopy(resolve8(repoRoot, path2), path2);
@@ -7191,8 +6569,8 @@ async function settleSpecSnapshot(options) {
     return write(refresh);
   const change = readSnapshotChange({
     saved: saved.text,
-    body: issue4.body,
-    notes: readLocalNotes(repoRoot, specsDir, issue4.number),
+    body: issue3.body,
+    notes: readLocalNotes(repoRoot, specsDir, issue3.number),
     notesPath: notes
   });
   if (change.kind === "unchanged")
@@ -7201,15 +6579,15 @@ async function settleSpecSnapshot(options) {
   if (change.kind === "notes") {
     const rebuilt = write(refresh);
     if (rebuilt.previous !== null)
-      output.info(notesRebuiltLine(rebuilt.path, issue4.number, rebuilt.previous));
+      output.info(notesRebuiltLine(rebuilt.path, issue3.number, rebuilt.previous));
     return rebuilt;
   }
   if (refresh)
     return write(true);
   const offer = options.offerRefresh ?? null;
-  const accepted = offer !== null && await offer({ issue: issue4.number, path: path2, savedAt: saved.savedAt });
+  const accepted = offer !== null && await offer({ issue: issue3.number, path: path2, savedAt: saved.savedAt });
   if (!accepted)
-    throw new CommandExit(ISSUE_REFUSAL_EXIT, snapshotDiffersMessage(path2, issue4.number));
+    throw new CommandExit(ISSUE_REFUSAL_EXIT, snapshotDiffersMessage(path2, issue3.number));
   return write(true);
 }
 
@@ -7238,11 +6616,11 @@ function readFlagWord(args, flag) {
 }
 function issueNumberOf(word, flag) {
   const trimmed = word.trim();
-  const issue4 = Number.parseInt(trimmed, 10);
-  if (!/^\d+$/u.test(trimmed) || !Number.isSafeInteger(issue4) || issue4 < 1) {
+  const issue3 = Number.parseInt(trimmed, 10);
+  if (!/^\d+$/u.test(trimmed) || !Number.isSafeInteger(issue3) || issue3 < 1) {
     throw new CommandExit(SOURCE_REFUSAL_EXIT, notAnIssueMessage(flag, word));
   }
-  return issue4;
+  return issue3;
 }
 function requestOf(flag, word) {
   if (flag === NEXT_FLAG) {
@@ -7292,8 +6670,8 @@ function alternativeLine(line) {
   const id = `\u25B6 Ready instead: issue #${String(line.issue)}`;
   return line.why === "" ? id : `${id} \u2014 ${line.why}`;
 }
-function describeIssue(issue4) {
-  return `issue #${String(issue4.number)} "${issue4.title}"`;
+function describeIssue(issue3) {
+  return `issue #${String(issue3.number)} "${issue3.title}"`;
 }
 function dryRunLine(what) {
   return `\uD83D\uDD0E ${DRY_RUN_FLAG}: would plan from ${what}. Nothing was written.`;
@@ -7303,9 +6681,9 @@ function stopped(reason) {
 }
 function memoiseIssues(issues) {
   const read = new Map;
-  return (issue4) => {
-    const taken = read.get(issue4) ?? issues(issue4);
-    read.set(issue4, taken);
+  return (issue3) => {
+    const taken = read.get(issue3) ?? issues(issue3);
+    read.set(issue3, taken);
     return taken;
   };
 }
@@ -7429,8 +6807,8 @@ async function resolveSpecSource(options) {
 
 // src/board/plan-spec.ts
 var BOARD_REFUSAL_EXIT = 2;
-function issueSource(issue4) {
-  return `issue #${String(issue4)}`;
+function issueSource(issue3) {
+  return `issue #${String(issue3)}`;
 }
 var UNNAMED_REPO = "this repository";
 function boardRepoLabel(git) {
@@ -7438,25 +6816,25 @@ function boardRepoLabel(git) {
   const normalized = result.ok ? normalizeRemote(result.stdout.trim()) : "";
   return normalized === "" ? UNNAMED_REPO : normalized;
 }
-async function passReadyLabel(issue4, offer) {
-  if (hasSpecReadyLabel(issue4.labels))
+async function passReadyLabel(issue3, offer) {
+  if (hasSpecReadyLabel(issue3.labels))
     return;
   if (offer !== undefined) {
-    requireNoLeak(issueSource(issue4.number), issue4.body);
-    if (await offer(issue4))
+    requireNoLeak(issueSource(issue3.number), issue3.body);
+    if (await offer(issue3))
       return;
   }
-  requireSpecReadyLabel(issue4.number, issue4.labels);
+  requireSpecReadyLabel(issue3.number, issue3.labels);
 }
-async function inspectSpecIssue(issue4, trust, offer) {
-  const source = issueSource(issue4.number);
-  await requireTrustedBoardAuthor({ kind: "issue", number: issue4.number }, trust, issue4.author);
-  await passReadyLabel(issue4, offer);
-  requireNoLeak(source, issue4.body);
-  requireCompleteSpec(source, issue4.body);
+async function inspectSpecIssue(issue3, trust, offer) {
+  const source = issueSource(issue3.number);
+  await requireTrustedBoardAuthor({ kind: "issue", number: issue3.number }, trust, issue3.author);
+  await passReadyLabel(issue3, offer);
+  requireNoLeak(source, issue3.body);
+  requireCompleteSpec(source, issue3.body);
 }
-async function inspectRoadmapIssue(issue4, trust) {
-  await requireTrustedBoardAuthor({ kind: "issue", number: issue4.number }, trust, issue4.author);
+async function inspectRoadmapIssue(issue3, trust) {
+  await requireTrustedBoardAuthor({ kind: "issue", number: issue3.number }, trust, issue3.author);
 }
 function memoisePermissions(permissions) {
   const read = new Map;
@@ -7484,7 +6862,7 @@ async function resolvePlanSpec(options) {
     return board;
   };
   const offerReady = options.offerReady ?? null;
-  const offer = offerReady === null || options.dryRun ? undefined : (issue4) => offerReady({ issue: issue4, gh, trust: trust(), output });
+  const offer = offerReady === null || options.dryRun ? undefined : (issue3) => offerReady({ issue: issue3, gh, trust: trust(), output });
   const offerAlternative = options.offerAlternative ?? null;
   const alternative = offerAlternative === null || options.dryRun ? undefined : offerAlternative;
   const offerRefresh = options.dryRun ? null : options.offerRefresh ?? null;
@@ -7496,14 +6874,14 @@ async function resolvePlanSpec(options) {
     specsDir: options.specsDir,
     findSpec: options.findSpec,
     issues: createGhSpecIssueReader({ gh }),
-    inspect: (issue4) => inspectSpecIssue(issue4, trust(), offer),
+    inspect: (issue3) => inspectSpecIssue(issue3, trust(), offer),
     offerRefresh,
     roadmap: {
       configured: options.roadmapIssue,
       search: createGhRoadmapSearch({ gh }),
       git,
       pullRequests: createGhOpenPullRequests({ gh }),
-      inspectRoadmap: (issue4) => inspectRoadmapIssue(issue4, trust()),
+      inspectRoadmap: (issue3) => inspectRoadmapIssue(issue3, trust()),
       offerAlternative: alternative
     },
     output
@@ -7753,9 +7131,9 @@ function plural2(count, singular, many) {
   return count === 1 ? `1 ${singular}` : `${count} ${many}`;
 }
 function listChanges(entries) {
-  const shown2 = entries.slice(0, MAX_LISTED_CHANGES).map((entry) => `${INDENT}${entry}`);
-  const hidden = entries.length - shown2.length;
-  return hidden > 0 ? [...shown2, `${INDENT}... and ${hidden} more`] : shown2;
+  const shown = entries.slice(0, MAX_LISTED_CHANGES).map((entry) => `${INDENT}${entry}`);
+  const hidden = entries.length - shown.length;
+  return hidden > 0 ? [...shown, `${INDENT}... and ${hidden} more`] : shown;
 }
 function triagePointer(number) {
   return `Run rafa pr triage ${number} to see why.`;
@@ -7897,7 +7275,7 @@ function remainingFrom(steps, failed2) {
   return at === -1 ? Object.freeze([]) : Object.freeze(steps.slice(at));
 }
 // src/pr/none.ts
-import { spawnSync as spawnSync3 } from "child_process";
+import { spawnSync as spawnSync2 } from "child_process";
 
 // src/pr/provider.ts
 var GITHUB_HOST = "github.com";
@@ -7938,7 +7316,7 @@ function requireGhProvider(reading2) {
 // src/pr/none.ts
 var COMPARE_QUERY = "?expand=1";
 function pushBranch(dir, branch) {
-  const result = spawnSync3("git", ["push", "--set-upstream", "origin", branch], {
+  const result = spawnSync2("git", ["push", "--set-upstream", "origin", branch], {
     cwd: dir,
     encoding: "utf8",
     env: { ...process.env, LC_ALL: "C" }
@@ -8324,9 +7702,9 @@ function plural3(count, singular, many) {
   return count === 1 ? `1 ${singular}` : `${count} ${many}`;
 }
 function listChanges2(entries) {
-  const shown2 = entries.slice(0, MAX_LISTED_CHANGES2).map((entry) => `${INDENT2}${entry}`);
-  const hidden = entries.length - shown2.length;
-  return hidden > 0 ? [...shown2, `${INDENT2}... and ${hidden} more`] : shown2;
+  const shown = entries.slice(0, MAX_LISTED_CHANGES2).map((entry) => `${INDENT2}${entry}`);
+  const hidden = entries.length - shown.length;
+  return hidden > 0 ? [...shown, `${INDENT2}... and ${hidden} more`] : shown;
 }
 function trackedChanges(tree) {
   return Object.freeze(tree.entries.filter((entry) => !entry.startsWith(UNTRACKED_PREFIX)));
@@ -8525,7 +7903,7 @@ function parseArgs(argv, spec = {}) {
 // src/commands/loop/loop-sessions.ts
 import { execFileSync as execFileSync2 } from "child_process";
 import { readFileSync as readFileSync13 } from "fs";
-import { join as join12, relative as relative4 } from "path";
+import { join as join11, relative as relative3 } from "path";
 
 // src/effort/store/task-finishes.ts
 import { existsSync as existsSync12 } from "fs";
@@ -8612,7 +7990,7 @@ function readSessionIdFlag(context, usage) {
   return value;
 }
 function runsLabel(root) {
-  return `${relative4(root, runsDir(root))}/`;
+  return `${relative3(root, runsDir(root))}/`;
 }
 function readRecords(root, seams) {
   try {
@@ -8669,7 +8047,7 @@ function writeSession(root, record, change) {
   }
 }
 function readSessionChecklist(root, record) {
-  const plan = join12(root, record.plan);
+  const plan = join11(root, record.plan);
   const file = [trackerPathFor(plan), plan].find((path2) => isFile(path2));
   if (file === undefined)
     return null;
@@ -8716,9 +8094,9 @@ var DEFAULT_BASE_BRANCH = "main";
 var DEFAULT_NEXT_SOURCE_SEAMS = Object.freeze({});
 function memoiseIssues2(issues) {
   const read = new Map;
-  return (issue4) => {
-    const taken = read.get(issue4) ?? issues(issue4);
-    read.set(issue4, taken);
+  return (issue3) => {
+    const taken = read.get(issue3) ?? issues(issue3);
+    read.set(issue3, taken);
     return taken;
   };
 }
@@ -8743,8 +8121,8 @@ function ghNextBoard(options) {
         problems: branches.problems
       };
     },
-    blocking: async (issue4) => readBlockedLine(await issues(issue4), blockerStatesOf(issues)),
-    isReady: async (issue4) => hasSpecReadyLabel((await issues(issue4)).labels)
+    blocking: async (issue3) => readBlockedLine(await issues(issue3), blockerStatesOf(issues)),
+    isReady: async (issue3) => hasSpecReadyLabel((await issues(issue3)).labels)
   });
 }
 function nextProject(context) {
@@ -8942,9 +8320,9 @@ var NEXT_PRECONDITIONS = Object.freeze([
   "pulls-unusable"
 ]);
 function nameFiles(paths) {
-  const shown2 = paths.slice(0, MAX_NAMED_FILES).map((path2) => `\`${path2}\``);
-  const hidden = paths.length - shown2.length;
-  return hidden > 0 ? `${shown2.join(", ")} and ${hidden} more` : shown2.join(", ");
+  const shown = paths.slice(0, MAX_NAMED_FILES).map((path2) => `\`${path2}\``);
+  const hidden = paths.length - shown.length;
+  return hidden > 0 ? `${shown.join(", ")} and ${hidden} more` : shown.join(", ");
 }
 function oneLine2(text) {
   return text.replace(/\s+/g, " ").trim();
@@ -9111,39 +8489,39 @@ async function readIssueReady(world) {
   const picked = await world.picked();
   if (picked === null || !picked.ready || picked.blocked !== null)
     return null;
-  const { issue: issue4 } = picked.line;
+  const { issue: issue3 } = picked.line;
   return {
     id: "issue-ready",
     action: "plan",
-    reading: `#${issue4} is next on the roadmap and carries \`${SPEC_READY_LABEL}\``,
-    proposal: `create the plan for #${issue4}`,
-    issue: issue4
+    reading: `#${issue3} is next on the roadmap and carries \`${SPEC_READY_LABEL}\``,
+    proposal: `create the plan for #${issue3}`,
+    issue: issue3
   };
 }
 async function readIssueBlocked(world) {
   const picked = await world.picked();
   if (picked === null || picked.blocked === null)
     return null;
-  const { issue: issue4 } = picked.line;
+  const { issue: issue3 } = picked.line;
   return {
     id: "issue-blocked",
     action: "unblock",
     reading: blockedLineSentence(picked.blocked),
-    proposal: `re-read the blockers of #${issue4} and take \`${SPEC_BLOCKED_LABEL}\` off once they have all closed`,
-    issue: issue4
+    proposal: `re-read the blockers of #${issue3} and take \`${SPEC_BLOCKED_LABEL}\` off once they have all closed`,
+    issue: issue3
   };
 }
 async function readIssueNotReady(world) {
   const picked = await world.picked();
   if (picked === null)
     return null;
-  const { issue: issue4 } = picked.line;
+  const { issue: issue3 } = picked.line;
   return {
     id: "issue-not-ready",
     action: "ready",
-    reading: notReadySentence(issue4),
-    proposal: `check the spec of #${issue4} and mark it ready`,
-    issue: issue4
+    reading: notReadySentence(issue3),
+    proposal: `check the spec of #${issue3} and mark it ready`,
+    issue: issue3
   };
 }
 function readNothingHere(world) {
@@ -9543,26 +8921,26 @@ async function onTracker(tracker, doing, call) {
 var READY_USAGE = "rafa issue ready <n>";
 var READY_WRITE_EXIT = 1;
 var ISSUE_NUMBER = /^[1-9]\d*$/u;
-function readyQuestion(issue4) {
-  return `Mark #${String(issue4)} ${SPEC_READY_LABEL}? [y/N] `;
+function readyQuestion(issue3) {
+  return `Mark #${String(issue3)} ${SPEC_READY_LABEL}? [y/N] `;
 }
-function trustPassLine(issue4, repo, reading2) {
+function trustPassLine(issue3, repo, reading2) {
   if (!reading2.trusted) {
     throw new TypeError(`issue ready: ${reading2.login} is not trusted, and has no pass to name`);
   }
   const because = reading2.source === "allow-list" ? "listed in board.trustedAuthors" : `who has write access to ${repo}`;
-  return `#${String(issue4)} was opened by ${reading2.login}, ${because}`;
+  return `#${String(issue3)} was opened by ${reading2.login}, ${because}`;
 }
-function completeLine(issue4) {
-  return `#${String(issue4)} fills every heading the spec template asks for, with no placeholder left`;
+function completeLine(issue3) {
+  return `#${String(issue3)} fills every heading the spec template asks for, with no placeholder left`;
 }
-function unaskedMessage2(issue4) {
-  const number = String(issue4);
+function unaskedMessage2(issue3) {
+  const number = String(issue3);
   return `#${number} is ready to mark; there is no terminal to ask on, so ${SPEC_READY_LABEL} was not added.` + ` Run rafa issue ready ${number} where an answer can be typed`;
 }
-function readyReport(issue4, status, reading2, lines) {
+function readyReport(issue3, status, reading2, lines) {
   return Object.freeze({
-    issue: issue4,
+    issue: issue3,
     status,
     author: reading2.login,
     trustedBy: reading2.source,
@@ -9572,36 +8950,36 @@ function readyReport(issue4, status, reading2, lines) {
   });
 }
 async function runIssueReady(options) {
-  const { gh, issue: issue4, trust, ask } = options;
+  const { gh, issue: issue3, trust, ask } = options;
   const board = options.board ?? createGhIssueBoard({ gh });
   const readIssue = options.readIssue ?? createGhSpecIssueReader({ gh });
-  const found = await readIssue(issue4);
-  const reading2 = await requireTrustedBoardAuthor({ kind: "issue", number: issue4 }, trust, found.author);
-  requireCompleteSpec(issueSource(issue4), found.body);
-  const lines = { trust: trustPassLine(issue4, trust.repo, reading2), checked: completeLine(issue4) };
+  const found = await readIssue(issue3);
+  const reading2 = await requireTrustedBoardAuthor({ kind: "issue", number: issue3 }, trust, found.author);
+  requireCompleteSpec(issueSource(issue3), found.body);
+  const lines = { trust: trustPassLine(issue3, trust.repo, reading2), checked: completeLine(issue3) };
   if (hasSpecReadyLabel(found.labels)) {
-    return readyReport(issue4, "already", reading2, {
+    return readyReport(issue3, "already", reading2, {
       ...lines,
-      message: `#${String(issue4)} is already marked ${SPEC_READY_LABEL}`
+      message: `#${String(issue3)} is already marked ${SPEC_READY_LABEL}`
     });
   }
   if (ask === null) {
-    return readyReport(issue4, "unasked", reading2, { ...lines, message: unaskedMessage2(issue4) });
+    return readyReport(issue3, "unasked", reading2, { ...lines, message: unaskedMessage2(issue3) });
   }
-  if (!await ask(readyQuestion(issue4))) {
-    return readyReport(issue4, "declined", reading2, {
+  if (!await ask(readyQuestion(issue3))) {
+    return readyReport(issue3, "declined", reading2, {
       ...lines,
-      message: `#${String(issue4)} was left unmarked`
+      message: `#${String(issue3)} was left unmarked`
     });
   }
   try {
-    await board.swapLabels(issue4, SPEC_NEEDS_WORK_LABEL, SPEC_READY_LABEL);
+    await board.swapLabels(issue3, SPEC_NEEDS_WORK_LABEL, SPEC_READY_LABEL);
   } catch (error) {
-    throw new CommandExit(READY_WRITE_EXIT, `\u274C ${SPEC_READY_LABEL} could not be put on #${String(issue4)}: ${messageOf(error)}`);
+    throw new CommandExit(READY_WRITE_EXIT, `\u274C ${SPEC_READY_LABEL} could not be put on #${String(issue3)}: ${messageOf(error)}`);
   }
-  return readyReport(issue4, "marked", reading2, {
+  return readyReport(issue3, "marked", reading2, {
     ...lines,
-    message: `Marked #${String(issue4)} ${SPEC_READY_LABEL}, and took ${SPEC_NEEDS_WORK_LABEL} off it`
+    message: `Marked #${String(issue3)} ${SPEC_READY_LABEL}, and took ${SPEC_NEEDS_WORK_LABEL} off it`
   });
 }
 function readReadyIssue(context) {
@@ -9633,7 +9011,7 @@ function lazyPrompter(open) {
   };
 }
 async function markIssueReady(context, seams) {
-  const issue4 = readReadyIssue(context);
+  const issue3 = readReadyIssue(context);
   const project = issueProject(context);
   const config = issueSubjectConfig(project, (message) => {
     context.output.warn(message);
@@ -9652,7 +9030,7 @@ async function markIssueReady(context, seams) {
   try {
     return await runIssueReady({
       gh,
-      issue: issue4,
+      issue: issue3,
       trust,
       ask: isTerminal() ? prompter.ask : null
     });
@@ -9720,12 +9098,12 @@ function versionLine() {
 
 // src/notices/notices.ts
 import { mkdirSync as mkdirSync6, readFileSync as readFileSync14, writeFileSync as writeFileSync6 } from "fs";
-import { dirname as dirname8, join as join13 } from "path";
+import { dirname as dirname8, join as join12 } from "path";
 var NOTICE_IDS = Object.freeze(["alpha", "danger"]);
 var FEEDBACK_URL = "https://github.com/open-tomato/rafa/issues/new/choose";
 var ROADMAP_URL = "https://github.com/open-tomato/rafa/issues/31";
 function noticesPath(home) {
-  return join13(home, ".rafa", "notices.json");
+  return join12(home, ".rafa", "notices.json");
 }
 function isNoticeId(value) {
   return typeof value === "string" && NOTICE_IDS.includes(value);
@@ -9934,7 +9312,7 @@ function markBudgetExit(options) {
 }
 
 // src/utils/commit.ts
-import { spawnSync as spawnSync4 } from "child_process";
+import { spawnSync as spawnSync3 } from "child_process";
 var DEFAULT_COMMIT_TYPE = "chore";
 var TEST_NOUN_WINDOW = 40;
 var FIX_VERBS = ["fix", "repair", "correct", "resolve"];
@@ -10146,7 +9524,7 @@ function failed2(step, subject, result) {
 }
 function spawnGit(cwd) {
   return (args) => {
-    const result = spawnSync4("git", args, {
+    const result = spawnSync3("git", args, {
       cwd,
       encoding: "utf8",
       maxBuffer: MAX_GIT_BUFFER
@@ -10217,10 +9595,10 @@ function holdsOf(reading2) {
   for (const blocker of report2.blockers) {
     holds.push(`blocker: ${blocker.what ?? "an entry with no usable what"}`);
   }
-  for (const issue4 of issues) {
-    if (!DROPPED_BLOCKER_FIELD.test(issue4.field))
+  for (const issue3 of issues) {
+    if (!DROPPED_BLOCKER_FIELD.test(issue3.field))
       continue;
-    holds.push(`blocker: ${issue4.field}, an entry the report parser dropped`);
+    holds.push(`blocker: ${issue3.field}, an entry the report parser dropped`);
   }
   return holds;
 }
@@ -10293,6 +9671,411 @@ function finishCleanExit(options) {
 // src/start/dispatch.ts
 import { randomUUID as randomUUID7 } from "crypto";
 
+// src/report/lessons.ts
+import { createHash as createHash2 } from "crypto";
+
+// src/demote/classify.ts
+var LEARNED_DIRECTORY = "learned";
+var ORIGIN_FIELD = "origin";
+var DEMOTION_VERDICTS = [
+  "observation",
+  "procedure",
+  "unclassified"
+];
+var RULE_VERDICTS = Object.freeze({
+  "no-frontmatter": "unclassified",
+  "learned-without-origin": "unclassified",
+  "no-section-pair": "unclassified",
+  "repeated-section": "procedure",
+  "numbered-procedure": "procedure",
+  "referenced-script": "procedure",
+  "observation-shape": "observation"
+});
+var PROCEDURE_STEP_MINIMUM = 3;
+var PROBLEM_HEADING = /^(?:the\s+)?problem\b/i;
+var SOLUTION_HEADING = /^(?:the\s+)?solution\b/i;
+var WHEN_TO_USE_HEADING = /^when\s+to\s+use\b/i;
+var EXTRACTED_LINE = /^\s*\*\*Extracted:\*\*\s*(\S+)/m;
+var SCRIPT_EXTENSIONS = [
+  ".sh",
+  ".bash",
+  ".zsh",
+  ".py",
+  ".rb",
+  ".pl",
+  ".js",
+  ".mjs",
+  ".cjs",
+  ".ts"
+];
+var FENCE_LINE4 = /^ {0,3}(?:```|~~~)/;
+var HEADING_LINE2 = /^ {0,3}(#{1,6})\s+(.*)$/;
+var NUMBERED_ITEM = /^ {0,3}\d+[.)]\s+\S/;
+var CONTINUATION = /^ {2,}\S/;
+var DEMOTED_SOURCE = "demoted";
+var DEMOTED_CONFIDENCE = 0.5;
+var DEMOTED_KIND = "gotcha";
+var DEMOTED_SIGNAL = "silent";
+var DEMOTED_USAGE_COUNT = 1;
+var EVIDENCE_PATH_KEY = "path";
+var EVIDENCE_EXTRACTED_KEY = "extracted";
+var DEFAULT_DOMAIN = "general-best-practices";
+var DOMAIN_MARKERS = [
+  ["security", /\b(?:security|secret|credential|token|auth|csrf|xss|injection)\b/i],
+  ["testing", /\b(?:test|tests|testing|spec|assertion|assert|mock|stub|fixture|coverage)\b/i],
+  ["git", /\b(?:git|commit|rebase|worktree|branch|merge|checkout)\b/i],
+  ["debugging", /\b(?:debug|debugging|traceback|reproduce|bisect)\b/i],
+  ["code-style", /\b(?:lint|eslint|format|formatter|prettier|naming)\b/i],
+  ["workflow", /\b(?:workflow|pipeline|release|deploy|build|ci|loop|dispatch)\b/i]
+];
+var ERROR_WORDS = /\b(?:error|exception|traceback|panic|fatal|refused|denied|not found|no such|cannot|could not|failed|failure|unexpected|undefined)\b/i;
+var SENTENCE_ABBREVIATIONS = ["e.g", "i.e", "vs", "cf", "etc"];
+function isFilled2(value) {
+  return typeof value === "string" && value.trim() !== "";
+}
+function bodyLines(body) {
+  return body.split(`
+`).map((line) => line.replace(/\r$/, ""));
+}
+function bodySections(body) {
+  const lines = bodyLines(body);
+  const headings = [];
+  let fenced = false;
+  lines.forEach((line, index) => {
+    if (FENCE_LINE4.test(line)) {
+      fenced = !fenced;
+      return;
+    }
+    if (fenced)
+      return;
+    const match = HEADING_LINE2.exec(line);
+    if (match === null)
+      return;
+    const [, hashes = "", title = ""] = match;
+    headings.push({
+      level: hashes.length,
+      title: title.replace(/\s+#+\s*$/, "").trim(),
+      index
+    });
+  });
+  return headings.map((heading, position) => {
+    const next = headings.slice(position + 1).find((other) => other.level <= heading.level);
+    const end = next === undefined ? lines.length : next.index;
+    return {
+      level: heading.level,
+      title: heading.title,
+      line: heading.index + 1,
+      text: lines.slice(heading.index + 1, end).join(`
+`).trim()
+    };
+  });
+}
+function numberedRuns(body) {
+  const runs = [];
+  let fenced = false;
+  let steps = 0;
+  let line = 0;
+  const close = () => {
+    if (steps > 0)
+      runs.push({ steps, line });
+    steps = 0;
+  };
+  bodyLines(body).forEach((text, index) => {
+    if (FENCE_LINE4.test(text)) {
+      fenced = !fenced;
+      return;
+    }
+    if (fenced || text.trim() === "")
+      return;
+    if (NUMBERED_ITEM.test(text)) {
+      if (steps === 0)
+        line = index + 1;
+      steps += 1;
+      return;
+    }
+    if (CONTINUATION.test(text))
+      return;
+    close();
+  });
+  close();
+  return runs;
+}
+function isScriptPath(token) {
+  if (token.startsWith("/"))
+    return false;
+  const last = token.split("/").at(-1) ?? "";
+  return SCRIPT_EXTENSIONS.some((extension) => last.endsWith(extension));
+}
+function referencedScript(body, entries = []) {
+  const owned = new Set(entries.map((entry) => entry.replace(/^\.\//, "")));
+  for (const reference2 of collectReferences(body)) {
+    if (reference2.kind !== "path")
+      continue;
+    const token = reference2.text.replace(/^\.\//, "");
+    const [first = ""] = token.split("/");
+    if (owned.has(first) && isScriptPath(token))
+      return reference2;
+  }
+  return null;
+}
+function isLearnedFile(path2) {
+  const [first] = path2.split(/[\\/]/);
+  return first === LEARNED_DIRECTORY;
+}
+function decide(rule, reason) {
+  return { verdict: RULE_VERDICTS[rule], rule, reason };
+}
+function pairReason(problems, solutions) {
+  if (problems === 0 && solutions === 0) {
+    return "the body carries no Problem section and no Solution section";
+  }
+  return problems === 0 ? "the body carries a Solution section and no Problem section, so there is no pair" : "the body carries a Problem section and no Solution section, so there is no pair";
+}
+function repeatReason(problems, solutions) {
+  const counted2 = problems > 1 ? `${problems} Problem sections` : `${solutions} Solution sections`;
+  return `the body carries ${counted2}, and an observation carries exactly one of each`;
+}
+function classifySkill(source) {
+  const document = readFrontmatterDocument(source.text);
+  if (document === null) {
+    return decide("no-frontmatter", "the file opens with no --- block holding a YAML mapping");
+  }
+  if (isLearnedFile(source.path) && !isFilled2(document.data[ORIGIN_FIELD])) {
+    return decide("learned-without-origin", `a ${LEARNED_DIRECTORY}/ file whose frontmatter carries no ${ORIGIN_FIELD}`);
+  }
+  const sections2 = bodySections(document.body);
+  const problems = sections2.filter((section) => PROBLEM_HEADING.test(section.title));
+  const solutions = sections2.filter((section) => SOLUTION_HEADING.test(section.title));
+  if (problems.length === 0 || solutions.length === 0) {
+    return decide("no-section-pair", pairReason(problems.length, solutions.length));
+  }
+  if (problems.length > 1 || solutions.length > 1) {
+    return decide("repeated-section", repeatReason(problems.length, solutions.length));
+  }
+  const run = numberedRuns(document.body).find((each) => each.steps >= PROCEDURE_STEP_MINIMUM);
+  if (run !== undefined) {
+    return decide("numbered-procedure", `a numbered procedure of ${run.steps} consecutive steps at line ${run.line}`);
+  }
+  const script = referencedScript(document.body, source.entries ?? []);
+  if (script !== null) {
+    return decide("referenced-script", `the body names the script ${script.text} at line ${script.line}`);
+  }
+  return decide("observation-shape", "one Problem section and one Solution section, no numbered procedure of " + `${PROCEDURE_STEP_MINIMUM} or more consecutive steps, and no referenced script`);
+}
+function firstSection(sections2, heading) {
+  return sections2.find((section) => heading.test(section.title));
+}
+function withoutFences(text) {
+  const kept = [];
+  let fenced = false;
+  for (const line of bodyLines(text)) {
+    if (FENCE_LINE4.test(line)) {
+      fenced = !fenced;
+      continue;
+    }
+    if (!fenced)
+      kept.push(line);
+  }
+  return kept;
+}
+function stripMarkers(line) {
+  return line.replace(/^\s*(?:[-*+]|\d+[.)]|>)\s+/, "").replace(/\*\*|__|\*|`/g, "").trim();
+}
+function isAbbreviation(text, index) {
+  const before = text.slice(0, index);
+  return SENTENCE_ABBREVIATIONS.some((word) => before.toLowerCase().endsWith(word));
+}
+function firstSentence(text) {
+  const lines = withoutFences(text);
+  const start = lines.findIndex((line) => line.trim() !== "");
+  if (start === -1)
+    return "";
+  const collected = [lines[start] ?? ""];
+  for (const line of lines.slice(start + 1)) {
+    if (line.trim() === "" || /^\s*(?:[-*+]|\d+[.)]|#)/.test(line))
+      break;
+    collected.push(line);
+  }
+  const joined = stripMarkers(collected.join(" ")).replace(/\s+/g, " ");
+  for (let index = 0;index < joined.length; index += 1) {
+    if (!".!?".includes(joined[index] ?? ""))
+      continue;
+    if (isAbbreviation(joined, index))
+      continue;
+    const next = joined[index + 1];
+    if (next === undefined)
+      return joined.slice(0, index + 1).trim();
+    if (next === " ")
+      return joined.slice(0, index + 1).trim();
+  }
+  return joined.trim();
+}
+function demotedTrigger(sections2, data) {
+  const whenToUse = firstSection(sections2, WHEN_TO_USE_HEADING);
+  const fromSection = whenToUse === undefined ? "" : firstSentence(whenToUse.text);
+  if (fromSection !== "")
+    return fromSection;
+  const description = data["description"];
+  if (isFilled2(description))
+    return description.trim();
+  const problem = firstSection(sections2, PROBLEM_HEADING);
+  return problem === undefined ? "" : firstSentence(problem.text);
+}
+function extractedDate(body) {
+  const match = EXTRACTED_LINE.exec(body);
+  return match?.[1] ?? null;
+}
+function errorString(body) {
+  let fenced = false;
+  for (const line of bodyLines(body)) {
+    if (FENCE_LINE4.test(line)) {
+      fenced = !fenced;
+      continue;
+    }
+    if (fenced) {
+      if (ERROR_WORDS.test(line))
+        return line.trim();
+      continue;
+    }
+    for (const span of line.matchAll(/`([^`\n]+)`/g)) {
+      const inner = span[1] ?? "";
+      if (ERROR_WORDS.test(inner))
+        return inner.trim();
+    }
+  }
+  return null;
+}
+function inferDomain(name2, body) {
+  for (const [domain, pattern] of DOMAIN_MARKERS) {
+    if (pattern.test(name2))
+      return domain;
+  }
+  for (const [domain, pattern] of DOMAIN_MARKERS) {
+    if (pattern.test(body))
+      return domain;
+  }
+  return DEFAULT_DOMAIN;
+}
+function slugifyId(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function uniqueInstinctId(base, taken) {
+  const used = new Set(taken);
+  if (!used.has(base))
+    return base;
+  let suffix = 2;
+  while (used.has(`${base}-${suffix}`))
+    suffix += 1;
+  return `${base}-${suffix}`;
+}
+function sourceName(source, data) {
+  const declared = data["name"];
+  if (isFilled2(declared))
+    return slugifyId(declared);
+  const segments = source.path.split(/[\\/]/).filter((segment) => segment !== "");
+  const last = segments.at(-1) ?? "";
+  const stem = last.toUpperCase() === "SKILL.MD" ? segments.at(-2) ?? "" : last.replace(/\.md$/i, "");
+  return slugifyId(stem);
+}
+function convertToInstinct(source, options) {
+  const document = readFrontmatterDocument(source.text);
+  const data = document?.data ?? {};
+  const body = document?.body ?? source.text;
+  const sections2 = bodySections(body);
+  const action = firstSection(sections2, SOLUTION_HEADING)?.text ?? "";
+  const named = errorString(body);
+  const name2 = sourceName(source, data);
+  const draft = {
+    id: uniqueInstinctId(name2, options.takenIds ?? []),
+    trigger: demotedTrigger(sections2, data),
+    kind: DEMOTED_KIND,
+    domain: inferDomain(name2, body),
+    confidence: DEMOTED_CONFIDENCE,
+    usageCount: DEMOTED_USAGE_COUNT,
+    sources: [],
+    artifact: null,
+    signal: named === null ? DEMOTED_SIGNAL : "loud",
+    scope: options.scope,
+    projectId: options.projectId ?? null,
+    source: DEMOTED_SOURCE,
+    evidence: [{
+      [EVIDENCE_PATH_KEY]: source.path,
+      [EVIDENCE_EXTRACTED_KEY]: extractedDate(body) ?? options.mtime
+    }],
+    promotedTo: null,
+    createdAt: options.now,
+    updatedAt: options.now,
+    action,
+    cause: firstSection(sections2, PROBLEM_HEADING)?.text ?? "",
+    actionHash: actionHash(action)
+  };
+  const text = writeInstinct(draft);
+  const parsed = parseInstinct(text);
+  return parsed.instinct === null ? { instinct: null, text: null, issues: parsed.issues } : { instinct: parsed.instinct, text, issues: parsed.issues };
+}
+
+// src/report/lessons.ts
+var LESSON_CONFIDENCE = 0.5;
+var BLOCKED_LESSON_CONFIDENCE = 0.4;
+var DEFAULT_LESSON_DOMAIN = "workflow";
+var LESSON_SLUG_LENGTH = 48;
+var LESSON_HASH_LENGTH = 8;
+var LESSON_ID_FALLBACK = "lesson";
+function lessonId(trigger, action) {
+  const slug = slugifyId(trigger).slice(0, LESSON_SLUG_LENGTH).replace(/-+$/, "");
+  const digest = createHash2("sha256").update(`${triggerKey(trigger)}
+${actionHash(action)}`).digest("hex").slice(0, LESSON_HASH_LENGTH);
+  return `${slug === "" ? LESSON_ID_FALLBACK : slug}-${digest}`;
+}
+function lessonEvidence(context) {
+  const { dispatch, outcome } = context;
+  return {
+    ...dispatch.planStub === null ? {} : { plan: dispatch.planStub },
+    task: dispatch.taskLine,
+    session: dispatch.sessionId,
+    outcome
+  };
+}
+function toLesson(finding, context, at) {
+  const { trigger, kind, signal, resolution, artifact } = finding;
+  const cause = finding.cause ?? finding.what;
+  if (resolution === null || trigger === null || kind === null || signal === null)
+    return null;
+  if (cause === null)
+    return null;
+  const { sessionId } = context.dispatch;
+  return {
+    id: lessonId(trigger, resolution),
+    trigger,
+    action: resolution,
+    action_hash: actionHash(resolution),
+    confidence: context.outcome === "blocked" ? BLOCKED_LESSON_CONFIDENCE : LESSON_CONFIDENCE,
+    usage_count: 1,
+    sources: [sessionId],
+    ...artifact === null ? {} : { artifact },
+    signal,
+    status: "active",
+    created_at: at,
+    updated_at: at,
+    description: {
+      kind,
+      domain: finding.domain ?? DEFAULT_LESSON_DOMAIN,
+      scope: "project",
+      source: "task-report",
+      evidence: [lessonEvidence(context)],
+      cause,
+      projectId: null
+    }
+  };
+}
+function reportLessons(record, context, now) {
+  if (!record.present)
+    return null;
+  const at = now.toISOString();
+  const instincts = record.reading.report.findings.map((finding) => toLesson(finding, context, at)).filter((lesson) => lesson !== null);
+  return instincts.length === 0 ? null : { source_id: context.dispatch.sessionId, instincts };
+}
+
 // src/effort/store/absences.ts
 import { randomUUID as randomUUID3 } from "crypto";
 import { existsSync as existsSync13 } from "fs";
@@ -10673,7 +10456,7 @@ function describeTaskReportRecord(record) {
 
 // src/utils/progress.ts
 import { existsSync as existsSync15, writeFileSync as writeFileSync7 } from "fs";
-import { join as join14 } from "path";
+import { join as join13 } from "path";
 var PROGRESS_FILE_NAME = "progress.txt";
 var PROGRESS_CAP_BYTES = 16000;
 var LISTED_FIELDS = [
@@ -10715,7 +10498,7 @@ var ESCAPED_CODE_POINTS = new Set([
   8233
 ]);
 function progressFilePath(repoRoot) {
-  return join14(repoRoot, PROGRESS_FILE_NAME);
+  return join13(repoRoot, PROGRESS_FILE_NAME);
 }
 function escapeValue(value) {
   let escaped = "";
@@ -11073,8 +10856,8 @@ async function dispatchTask(options) {
     const note = suppressed.length === 0 ? "" : ` (${suppressed.join(", ")} left to the agent)`;
     activeOutput().info(`   Routed as: ${flags.join(" ")}${note}`);
   }
-  for (const issue4 of declaration?.issues ?? []) {
-    activeOutput().warn(`   Declaration: ignoring ${issue4.reason} \`${issue4.text}\`.`);
+  for (const issue3 of declaration?.issues ?? []) {
+    activeOutput().warn(`   Declaration: ignoring ${issue3.reason} \`${issue3.text}\`.`);
   }
   const injection = renderInjection({
     mode: options.inject,
@@ -11126,8 +10909,37 @@ function renderProgressForDispatch(repoRoot, planStub2) {
     return false;
   }
 }
-function storeTaskReport(options) {
+async function pushTaskLessons(options, record) {
+  const { learning, dispatch } = options;
+  if (learning === null)
+    return;
+  const now = options.now ?? (() => new Date);
+  const context = {
+    dispatch: { sessionId: dispatch.sessionId, planStub: options.planStub, taskLine: dispatch.taskText },
+    outcome: options.outcome
+  };
+  const payload = reportLessons(record, context, now());
+  if (payload === null)
+    return;
+  const count = payload.instincts.length;
+  try {
+    const registry = learning.registry ?? CORE_ADAPTER_REGISTRY;
+    const adapter = registry.resolve("learning", learning.kind).create({
+      repoRoot: options.repoRoot,
+      home: learning.home,
+      learningBlessMinConfidence: learning.blessMinConfidence
+    });
+    const result = await adapter.push(payload);
+    const rules = result.decisions.map((decision) => decision.rule).join(", ");
+    activeOutput().info(`   Pushed ${count} lesson(s) to the \`${learning.kind}\` learning adapter: ${rules}.`);
+  } catch (error) {
+    activeOutput().warn(`   ${count} lesson(s) of session ${dispatch.sessionId} were not pushed to the \`${learning.kind}\` learning adapter: ${messageOf3(error)}`);
+    activeOutput().warn("   The task is not failed for it: its report is stored, findings and all.");
+  }
+}
+async function storeTaskReport(options) {
   const { dispatch } = options;
+  let record;
   try {
     writeDispatch(options.repoRoot, {
       sessionId: dispatch.sessionId,
@@ -11136,7 +10948,7 @@ function storeTaskReport(options) {
       declaration: dispatch.declaration,
       flags: dispatch.flags
     });
-    const record = recordTaskReport(options.repoRoot, {
+    record = recordTaskReport(options.repoRoot, {
       dispatch: {
         sessionId: dispatch.sessionId,
         planStub: options.planStub,
@@ -11150,13 +10962,14 @@ function storeTaskReport(options) {
       activeOutput().info(`   ${note}`);
     for (const warning of warnings)
       activeOutput().warn(`   ${warning}`);
-    return true;
   } catch (error) {
     activeOutput().error(`
 \u274C The report of session ${dispatch.sessionId} was not stored: ${messageOf3(error)}`);
     activeOutput().error("   The session printed it above as it ran.");
     return false;
   }
+  await pushTaskLessons(options, record);
+  return true;
 }
 
 // src/start/pause.ts
@@ -11583,11 +11396,11 @@ function changelogDate(now) {
 }
 
 // src/release/enabled.ts
-import { statSync as statSync10 } from "fs";
+import { statSync as statSync9 } from "fs";
 import { resolve as resolve10 } from "path";
 function isRegularFile(full) {
   try {
-    return statSync10(full).isFile();
+    return statSync9(full).isFile();
   } catch {
     return false;
   }
@@ -11758,12 +11571,12 @@ function readBaseVersion(git, versionFile, options = {}) {
   if (!fetched.ok) {
     problems.push(`${branch} could not be fetched from ${remote}, so the base version is whatever this clone already holds for ${ref}: ${gitSaid(fetched)}`);
   }
-  const shown2 = git(["show", `${ref}:${path2}`]);
-  if (!shown2.ok) {
-    problems.push(`${ref}:${path2} could not be read: ${gitSaid(shown2)}`);
+  const shown = git(["show", `${ref}:${path2}`]);
+  if (!shown.ok) {
+    problems.push(`${ref}:${path2} could not be read: ${gitSaid(shown)}`);
     return { ref, path: path2, version: null, fetched: fetched.ok, problems };
   }
-  const version2 = readManifestVersion(shown2.stdout);
+  const version2 = readManifestVersion(shown.stdout);
   if (version2 === null)
     problems.push(`${ref}:${path2} declares no version`);
   return { ref, path: path2, version: version2, fetched: fetched.ok, problems };
@@ -12294,7 +12107,7 @@ import { readFileSync as readFileSync21 } from "fs";
 
 // src/plan/risk.ts
 import { readFileSync as readFileSync20 } from "fs";
-import { isAbsolute as isAbsolute4, join as join15, relative as relative5 } from "path";
+import { isAbsolute as isAbsolute4, join as join14, relative as relative4 } from "path";
 
 // src/plan/risk/accounts.ts
 var PUSH_REMOTE = "origin";
@@ -12836,9 +12649,9 @@ function toolsFinding(task, plan, seams) {
   return null;
 }
 function displayPath(path2, seams) {
-  const absolute = isAbsolute4(path2) ? path2 : join15(seams.repoRoot, path2);
+  const absolute = isAbsolute4(path2) ? path2 : join14(seams.repoRoot, path2);
   const within = (root) => {
-    const step = relative5(root, absolute);
+    const step = relative4(root, absolute);
     return step === "" || step.startsWith("..") || isAbsolute4(step) ? null : step;
   };
   const inRepo = within(seams.repoRoot);
@@ -12861,7 +12674,7 @@ function readText5(path2) {
 function findSkillFile(name2, seams) {
   const tiers = resolveSkillTiers({ home: seams.home, projectRoot: seams.repoRoot, entry: seams.entry });
   for (const { dir } of tiers) {
-    const path2 = join15(dir, name2, "SKILL.md");
+    const path2 = join14(dir, name2, "SKILL.md");
     if (readText5(path2) !== null)
       return path2;
   }
@@ -12887,8 +12700,8 @@ function commandFindings(plan, display, tasks, seams) {
       if (read.has(file))
         continue;
       read.add(file);
-      const shown2 = displayPath(file, seams);
-      found.push(...readBodyCommands(readText5(file) ?? "", paths).map((finding2) => located(finding2, shown2)));
+      const shown = displayPath(file, seams);
+      found.push(...readBodyCommands(readText5(file) ?? "", paths).map((finding2) => located(finding2, shown)));
     }
   }
   return found;
@@ -12981,10 +12794,10 @@ async function announceRiskTotal(input, seams = {}) {
 
 // src/start/session.ts
 import { randomUUID as randomUUID8 } from "crypto";
-import { relative as relative6 } from "path";
+import { relative as relative5 } from "path";
 var NOTHING_DISPATCHED = "   Nothing was checked and nothing was dispatched.";
 function recordLabel(repoRoot, sessionId) {
-  return relative6(repoRoot, sessionFilePath(repoRoot, sessionId));
+  return relative5(repoRoot, sessionFilePath(repoRoot, sessionId));
 }
 function conflictLine(repoRoot, conflict) {
   const { record } = conflict;
@@ -13014,7 +12827,7 @@ function openRefusal(repoRoot, draft, error) {
   if (!(error instanceof SessionRecordError) && !isSystemError)
     return null;
   return [
-    `\u274C Refusing to start: the session records under ${relative6(repoRoot, runsDir(repoRoot))}/ cannot be read or written.`,
+    `\u274C Refusing to start: the session records under ${relative5(repoRoot, runsDir(repoRoot))}/ cannot be read or written.`,
     `   ${messageOf(error)}`,
     NOTHING_DISPATCHED
   ].join(`
@@ -13050,7 +12863,7 @@ function openRunSession(options) {
   const draft = {
     sessionId: (seams.newSessionId ?? randomUUID8)(),
     planStub: options.planStub,
-    plan: relative6(repoRoot, options.planPath),
+    plan: relative5(repoRoot, options.planPath),
     branch: options.branch,
     pid: seams.pid ?? process.pid,
     startedAt: (seams.now ?? (() => new Date))().toISOString()
@@ -13121,17 +12934,17 @@ function announcePlanIssues(planContent) {
   const output = activeOutput();
   output.warn(`
 \u26A0\uFE0F  The plan holds ${issues.length} part(s) the loop does not read as written:`);
-  for (const issue4 of issues)
-    output.warn(`   line ${issue4.line}: ${issue4.text}`);
+  for (const issue3 of issues)
+    output.warn(`   line ${issue3.line}: ${issue3.text}`);
   return issues;
 }
 
 // src/start/runtime.ts
-import { existsSync as existsSync18, readdirSync as readdirSync7, realpathSync as realpathSync3, statSync as statSync11 } from "fs";
+import { existsSync as existsSync18, readdirSync as readdirSync6, realpathSync as realpathSync3, statSync as statSync10 } from "fs";
 import { homedir as homedir5 } from "os";
-import { isAbsolute as isAbsolute5, join as join16, relative as relative7, resolve as resolve11, sep } from "path";
+import { isAbsolute as isAbsolute5, join as join15, relative as relative6, resolve as resolve11, sep } from "path";
 var RUNTIME_FLAG = "--runtime";
-var RUNTIME_SUBDIR = join16(".rafa", "runtime");
+var RUNTIME_SUBDIR = join15(".rafa", "runtime");
 var RUNTIME_ENTRY = "cli.js";
 var SOURCE_DIR = "src";
 var RUNTIME_COMMAND = ["start"];
@@ -13158,7 +12971,7 @@ function resolveRuntime(value, places) {
     throw refusal3([`\u274C Refusing to start: \`--runtime\` names no runtime. Spell it ${SPELLING}.`]);
   }
   const isVersion = VERSION_SHAPE2.test(value);
-  const named = isVersion ? join16(places.home, RUNTIME_SUBDIR, value, RUNTIME_ENTRY) : resolve11(places.cwd, value);
+  const named = isVersion ? join15(places.home, RUNTIME_SUBDIR, value, RUNTIME_ENTRY) : resolve11(places.cwd, value);
   refuseInsideSource(value, named, places);
   const entry = entryOf(value, named, isVersion, places.home);
   const real = realpathSync3(entry);
@@ -13169,7 +12982,7 @@ function entryOf(value, named, isVersion, home) {
   if (isVersion) {
     if (isFile2(named))
       return named;
-    const root = join16(home, RUNTIME_SUBDIR);
+    const root = join15(home, RUNTIME_SUBDIR);
     const installed = installedVersions(root);
     throw refusal3([
       `\u274C Refusing to start: \`--runtime=${value}\` names no installed runtime: ${named} is no file.`,
@@ -13178,7 +12991,7 @@ function entryOf(value, named, isVersion, home) {
   }
   if (isFile2(named))
     return named;
-  const inside = join16(named, RUNTIME_ENTRY);
+  const inside = join15(named, RUNTIME_ENTRY);
   if (isDirectory(named) && isFile2(inside))
     return inside;
   throw refusal3([
@@ -13196,31 +13009,31 @@ function refuseInsideSource(value, path2, places) {
   ]);
 }
 function sourceDirs({ cwd, root }) {
-  const dirs = [join16(cwd, SOURCE_DIR), join16(root, SOURCE_DIR)];
+  const dirs = [join15(cwd, SOURCE_DIR), join15(root, SOURCE_DIR)];
   const real = dirs.filter((dir) => existsSync18(dir)).map((dir) => realpathSync3(dir));
   return [...new Set([...dirs, ...real])];
 }
 function isInside2(path2, dir) {
-  const rel = relative7(dir, path2);
+  const rel = relative6(dir, path2);
   return rel === "" || !isAbsolute5(rel) && rel !== ".." && !rel.startsWith(`..${sep}`);
 }
 function installedVersions(root) {
   try {
-    return readdirSync7(root).filter((name2) => isFile2(join16(root, name2, RUNTIME_ENTRY))).sort((a, b) => a.localeCompare(b));
+    return readdirSync6(root).filter((name2) => isFile2(join15(root, name2, RUNTIME_ENTRY))).sort((a, b) => a.localeCompare(b));
   } catch {
     return [];
   }
 }
 function isFile2(path2) {
   try {
-    return statSync11(path2).isFile();
+    return statSync10(path2).isFile();
   } catch {
     return false;
   }
 }
 function isDirectory(path2) {
   try {
-    return statSync11(path2).isDirectory();
+    return statSync10(path2).isDirectory();
   } catch {
     return false;
   }
@@ -13337,7 +13150,7 @@ function eventOf(line) {
 }
 
 // src/triage/triage.ts
-import { basename as basename8, join as join17 } from "path";
+import { basename as basename8, join as join16 } from "path";
 
 // src/effort/store/tracker-refs.ts
 import { randomUUID as randomUUID9 } from "crypto";
@@ -13365,7 +13178,7 @@ var REFUSAL_TAILS = { write: "nothing written", read: "nothing opened" };
 function refused(call, reason) {
   return new Error(`effort store: tracker ref ${call} ${reason}; ${REFUSAL_TAILS[call]}`);
 }
-function checkArtifact2(call, artifact) {
+function checkArtifact(call, artifact) {
   if (artifact === null || artifact === undefined) {
     throw refused(call, "has no artifact, the key a reference is kept under");
   }
@@ -13446,7 +13259,7 @@ function placeRef(db, path2, write, wanted, insertValues) {
 }
 function writeTrackerRef(repoRoot, write, seams = {}) {
   checkDispatch("tracker ref", write.dispatch, write.outcome);
-  checkArtifact2("write", write.artifact);
+  checkArtifact("write", write.artifact);
   const wanted = storedRefOf(write.ref);
   if (typeof wanted === "string")
     throw refused("write", `has a reference ${wanted}`);
@@ -13471,7 +13284,7 @@ function writeTrackerRef(repoRoot, write, seams = {}) {
   return { path: path2, action, stored };
 }
 function readTrackerRef(repoRoot, artifact) {
-  checkArtifact2("read", artifact);
+  checkArtifact("read", artifact);
   const path2 = sqliteStorePath(repoRoot);
   if (!existsSync19(path2))
     return null;
@@ -13519,7 +13332,7 @@ var FOREIGN_PROGRAMS = new Set([
   "yarn"
 ]);
 var CONFIG_SECTIONS = new Set(Object.values(SETTINGS).map((setting) => setting.key).filter((key) => key.includes(".")).map((key) => key.slice(0, key.indexOf("."))));
-var FENCE_LINE4 = /^ {0,3}(`{3,}|~{3,})(.*)$/u;
+var FENCE_LINE5 = /^ {0,3}(`{3,}|~{3,})(.*)$/u;
 var QUOTE_LINE = /^ {0,3}>/u;
 var CODE_SPAN4 = /(?<!`)(`+)(?!`)(.+?)(?<!`)\1(?!`)/gu;
 var CROSS_ISSUE = /(?<![\w./-])[A-Za-z0-9][A-Za-z0-9-]*\/[A-Za-z0-9._-]+#\d+(?!\w)/gu;
@@ -13532,7 +13345,7 @@ var KEY_SHAPE = /^[a-z]+\.[a-z][A-Za-z0-9]*$/u;
 var IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/u;
 var UPPER_SNAKE = /^[A-Z][A-Z0-9]*(?:_[A-Z0-9]+)+$/u;
 function openingFence(line) {
-  const found = FENCE_LINE4.exec(line);
+  const found = FENCE_LINE5.exec(line);
   if (found === null)
     return null;
   const run = found[1] ?? "";
@@ -13542,7 +13355,7 @@ function openingFence(line) {
   return { char: run.charAt(0), length: run.length };
 }
 function closesFence3(line, fence) {
-  const found = FENCE_LINE4.exec(line);
+  const found = FENCE_LINE5.exec(line);
   if (found === null)
     return false;
   const run = found[1] ?? "";
@@ -13968,7 +13781,7 @@ function createArtifactRefsVerifier(repoRoot, env) {
 }
 
 // src/triage/triage.ts
-var PRIVATE_TRIAGE_DIR = join17(".rafa", "triage", "private");
+var PRIVATE_TRIAGE_DIR = join16(".rafa", "triage", "private");
 var SECRET_ENV_NAMES = ["GITHUB_TOKEN", "ANTHROPIC_API_KEY", "LINEAR_API_KEY"];
 var TRIAGE_MODULE = "unassigned";
 var BLOCKER_SEPARATOR = "; ";
@@ -13979,7 +13792,7 @@ var MIN_FENCE_LENGTH = 3;
 var ISSUE_OPENING = "An out-of-scope bug a rafa task session reported. The loop filed it and" + " dispatches no task for it: a plan that wants it fixed declares a task.";
 var COMMENT_OPENING = "Reported again by a rafa task session.";
 function privateTriageDir(repoRoot) {
-  return join17(repoRoot, PRIVATE_TRIAGE_DIR);
+  return join16(repoRoot, PRIVATE_TRIAGE_DIR);
 }
 function createPrivateTriageTracker(repoRoot, options = {}) {
   return createLocalTracker({
@@ -14062,10 +13875,10 @@ function issueTitle(redactedWhat) {
   return `${kept.trimEnd()}${TITLE_CUT}`;
 }
 function section(heading, value, absent, redact) {
-  const shown2 = value === null ? absent : fenced(redact(value));
+  const shown = value === null ? absent : fenced(redact(value));
   return `## ${heading}
 
-${shown2}`;
+${shown}`;
 }
 function issueText(opening, values, redact) {
   return [
@@ -14262,10 +14075,10 @@ function bugLines(bug) {
     const warning = bug.ref === null ? `${name2}: not filed on ${where}: ${bug.problem}` : `${name2}: recurs in ${issueName2(bug.ref)} on ${where}, not commented on: ${bug.problem}`;
     return { notes: [], warnings: [warning] };
   }
-  const issue4 = bug.ref === null ? "an issue" : issueName2(bug.ref);
-  const note = bug.action === "filed" ? `${name2}: filed on ${where} as ${issue4}.` : `${name2}: recurs in ${issue4} on ${where}, found by ${FOUND_BY[bug.foundBy ?? "find"]}; commented on it.`;
+  const issue3 = bug.ref === null ? "an issue" : issueName2(bug.ref);
+  const note = bug.action === "filed" ? `${name2}: filed on ${where} as ${issue3}.` : `${name2}: recurs in ${issue3} on ${where}, found by ${FOUND_BY[bug.foundBy ?? "find"]}; commented on it.`;
   const problem = bug.problem === null ? [] : [`${name2}: ${bug.problem}`];
-  const conflict = bug.stored === "conflict" ? [`${name2}: the store keeps another reference for its artifact, in place of ${issue4}.`] : [];
+  const conflict = bug.stored === "conflict" ? [`${name2}: the store keeps another reference for its artifact, in place of ${issue3}.`] : [];
   return { notes: [note], warnings: [...problem, ...conflict] };
 }
 function describeStartTriage(result) {
@@ -14351,14 +14164,231 @@ function mechanicalConflictBullet() {
   return `* ${MECHANICAL_CONFLICT_SENTENCE}`;
 }
 
+// src/start/promoted-check.ts
+import { isAbsolute as isAbsolute6, posix as posix2, relative as relative7 } from "path";
+
+// src/start/promoted.ts
+var PROMOTED_BLOCK_KIND = "promoted";
+var ARROW = /\u2192|->/;
+var SKIPPED = /^skipped:/i;
+var LIST_MARKER = /^[-*]\s+/;
+var WHITESPACE2 = /\s/;
+function unquoted(text) {
+  const trimmed = text.trim();
+  return trimmed.length >= 2 && trimmed.startsWith("`") && trimmed.endsWith("`") ? trimmed.slice(1, -1).trim() : trimmed;
+}
+function wordProblem(word, what) {
+  if (word === "")
+    return `it names no ${what}`;
+  if (WHITESPACE2.test(word))
+    return `its ${what} \`${word}\` holds whitespace`;
+  return null;
+}
+function readLine2(text, line) {
+  const content = text.trim().replace(LIST_MARKER, "");
+  const arrow = ARROW.exec(content);
+  if (arrow === null)
+    return { reason: "it holds no `\u2192` or `->`" };
+  const id = unquoted(content.slice(0, arrow.index));
+  const idProblem = wordProblem(id, "id");
+  if (idProblem !== null)
+    return { reason: idProblem };
+  const right = content.slice(arrow.index + arrow[0].length).trim();
+  if (SKIPPED.test(right)) {
+    const reason = right.replace(SKIPPED, "").trim();
+    return reason === "" ? { reason: `it skips \`${id}\` without a reason` } : { answer: { kind: "skipped", id, reason, line } };
+  }
+  const path2 = unquoted(right);
+  const pathProblem = wordProblem(path2, "path");
+  return pathProblem === null ? { answer: { kind: "promoted", id, path: path2, line } } : { reason: pathProblem };
+}
+function parsePromoted(output) {
+  const block = readRafaBlocks(output).filter((found) => found.kind === PROMOTED_BLOCK_KIND).at(-1);
+  if (block === undefined)
+    return { status: "absent", answers: [], unreadable: [] };
+  if (!block.closed)
+    return { status: "unclosed", answers: [], unreadable: [] };
+  const answers = [];
+  const unreadable = [];
+  const firstLine2 = new Map;
+  block.body.split(`
+`).forEach((text, index) => {
+    if (text.trim() === "")
+      return;
+    const line = block.span.first + 1 + index;
+    const reading2 = readLine2(text, line);
+    if ("reason" in reading2) {
+      unreadable.push({ line, text, reason: reading2.reason });
+      return;
+    }
+    const { id } = reading2.answer;
+    const earlier = firstLine2.get(id);
+    if (earlier !== undefined) {
+      const reason = `\`${id}\` was already answered at line ${String(earlier)}`;
+      unreadable.push({ line, text, reason });
+      return;
+    }
+    firstLine2.set(id, line);
+    answers.push(reading2.answer);
+  });
+  return { status: "read", answers, unreadable };
+}
+
+// src/start/promoted-check.ts
+function saidClause2(result) {
+  const said = gitSaid(result).split(`
+`)[0] ?? "";
+  return said === "" ? "and git wrote nothing" : `git said: ${said}`;
+}
+function readHead(git) {
+  const result = git(["rev-parse", "--verify", "HEAD"]);
+  const head = result.stdout.trim();
+  return result.ok && head !== "" ? head : null;
+}
+function changedSince(git, head) {
+  if (head === null)
+    return { ok: false, reason: "the HEAD before the session could not be read" };
+  const result = git(["diff", "--name-only", "-z", head, "--"]);
+  if (!result.ok) {
+    return { ok: false, reason: `the changes since ${head.slice(0, 7)} could not be read, ${saidClause2(result)}` };
+  }
+  const paths = result.stdout.split("\x00").filter((path2) => path2 !== "");
+  return { ok: true, head, paths: new Set(paths) };
+}
+function repoPath(path2, repoRoot) {
+  const inside = isAbsolute6(path2) ? relative7(repoRoot, path2) : path2;
+  const normal = posix2.normalize(inside.replaceAll("\\", "/"));
+  if (normal === "." || normal === ".." || normal.startsWith("../") || isAbsolute6(normal))
+    return null;
+  return normal.replace(/^(\.\/)+/, "");
+}
+function promotedOutcome(lesson, named, changed, repoRoot) {
+  if (!changed.ok)
+    return { kind: "unchecked", id: lesson.id, path: named, reason: changed.reason };
+  const path2 = repoPath(named, repoRoot);
+  return path2 !== null && changed.paths.has(path2) ? { lesson, path: path2 } : { kind: "unchanged", id: lesson.id, path: named };
+}
+function checkPromoted(lessons, reading2, changed, repoRoot) {
+  const answers = new Map(reading2.answers.map((answer2) => [answer2.id, answer2]));
+  const listed = new Set(lessons.map((lesson) => lesson.id));
+  const promoted = [];
+  const skipped2 = [];
+  const unpromoted = [];
+  for (const lesson of lessons) {
+    const answer2 = answers.get(lesson.id);
+    if (answer2 === undefined) {
+      unpromoted.push({ kind: "unanswered", id: lesson.id });
+    } else if (answer2.kind === "skipped") {
+      skipped2.push(answer2);
+    } else {
+      const outcome = promotedOutcome(lesson, answer2.path, changed, repoRoot);
+      if ("lesson" in outcome)
+        promoted.push(outcome);
+      else
+        unpromoted.push(outcome);
+    }
+  }
+  const unlisted = reading2.answers.map((answer2) => answer2.id).filter((id) => !listed.has(id));
+  return { promoted, skipped: skipped2, unpromoted, unlisted };
+}
+function unpromotedPhrase(lesson, head) {
+  if (lesson.kind === "unanswered")
+    return `\`${lesson.id}\` (no answer in the \`rafa:promoted\` block)`;
+  if (lesson.kind === "unchecked")
+    return `\`${lesson.id}\` (names \`${lesson.path}\`, which could not be checked: ${lesson.reason})`;
+  const since = head === null ? "before the session" : head.slice(0, 7);
+  return `\`${lesson.id}\` (names \`${lesson.path}\`, which has not changed since ${since})`;
+}
+function unpromotedLine(check, head) {
+  if (check.unpromoted.length === 0)
+    return null;
+  const named = check.unpromoted.map((lesson) => unpromotedPhrase(lesson, head)).join("; ");
+  return `Lessons listed for promotion that this pull request does not carry: ${named}.`;
+}
+async function recordPromotions(learning, promoted) {
+  const problems = [];
+  for (const { lesson, path: path2 } of promoted) {
+    const sourceId = lesson.sources?.[0] ?? lesson.id;
+    try {
+      await learning.push({ source_id: sourceId, instincts: [{ ...lesson, promoted_to: path2 }] });
+    } catch (error) {
+      problems.push(`\`${lesson.id}\` is in ${path2}, but its promoted_to could not be recorded: ${messageOf(error)}`);
+    }
+  }
+  return problems;
+}
+async function reportUnpromoted(pulls, branch, line) {
+  try {
+    const found = await pulls.findOpen(branch);
+    if (found === null)
+      return { written: false, problem: `no open pull request was found for ${branch}` };
+    const detail = await pulls.get(found.number);
+    if (detail === null)
+      return { written: false, problem: `pull request #${found.number} could not be read back` };
+    if (detail.body.includes(line))
+      return { written: true, number: found.number, already: true };
+    await pulls.editBody(found.number, bodyWithSentence(detail.body, line));
+    return { written: true, number: found.number, already: false };
+  } catch (error) {
+    return { written: false, problem: `the pull request body could not be written: ${messageOf(error)}` };
+  }
+}
+function warnAboutBlock(reading2, check) {
+  const out = activeOutput();
+  if (reading2.status === "absent")
+    out.warn("   The wrap-up session wrote no `rafa:promoted` block.");
+  if (reading2.status === "unclosed")
+    out.warn("   The wrap-up session's `rafa:promoted` block is never closed, so none of it was read.");
+  for (const line of reading2.unreadable)
+    out.warn(`   \`rafa:promoted\` line ${line.line} was not read: ${line.reason}.`);
+  for (const id of check.unlisted)
+    out.warn(`   The \`rafa:promoted\` block answers \`${id}\`, which the wrap-up did not list.`);
+}
+async function recordConfirmed(input, check) {
+  const out = activeOutput();
+  if (check.promoted.length === 0)
+    return;
+  let learning;
+  try {
+    learning = input.learning();
+  } catch (error) {
+    out.warn(`   No lesson's promoted_to was recorded: the learning adapter could not be made: ${messageOf(error)}`);
+    return;
+  }
+  for (const problem of await recordPromotions(learning, check.promoted))
+    out.warn(`   ${problem}`);
+  for (const { lesson, path: path2 } of check.promoted)
+    out.info(`   Lesson \`${lesson.id}\` promoted to ${path2}.`);
+}
+async function checkWrapUpAnswer(input) {
+  const out = activeOutput();
+  const reading2 = parsePromoted(input.output);
+  const changed = changedSince(input.git, input.head);
+  const check = checkPromoted(input.lessons, reading2, changed, input.repoRoot);
+  warnAboutBlock(reading2, check);
+  if (!changed.ok && reading2.answers.some((answer2) => answer2.kind === "promoted")) {
+    out.warn(`   No promoted path could be checked: ${changed.reason}.`);
+  }
+  await recordConfirmed(input, check);
+  const line = unpromotedLine(check, input.head);
+  if (line === null)
+    return check;
+  const report2 = await reportUnpromoted(input.pulls, input.branch, line);
+  if (!report2.written) {
+    out.warn(`   This line is not in the pull request body, as ${report2.problem}: ${line}`);
+  } else if (report2.already) {
+    out.info(`   Pull request #${report2.number} already names the lessons it does not carry.`);
+  } else {
+    out.info(`   Pull request #${report2.number} now names the lessons it does not carry.`);
+  }
+  return check;
+}
+
 // src/start/wrap-up.ts
-function buildWrapUpPrompt(branch, planContent, openPullRequest = null, release = null) {
+function buildWrapUpPrompt(branch, planContent, openPullRequest = null, release = null, lessons = []) {
   return [
     "* Read `@progress.txt` in full.",
     "* `@progress.txt` above names the file `progress.txt` at the repo root; the `@` is a reference marker, never part of a path. Do not create or write a file whose name starts with `@`.",
-    "* If there's anything worth keeping, take what's generally relevant from that file into the `context/` page that owns its subject, `README.md` or a pertinent skill under `.claude/skills/`. The root `AGENTS.md` is a capped map read into every turn of every session: point at the page from there if a new one is needed, never inline the finding itself.",
-    "* Promote a finding ONLY when all three hold, and delete or keep it rather than promoting it when any one fails. It is PROJECT-SPECIFIC \u2014 a fact about THIS tree (its layout, its gates, its conventions, what a command here actually answers) and not a general technique, which belongs in a skill and not in this repo's docs. It is NOT ALREADY COVERED by a skill under `.claude/skills/` \u2014 read the skill that matches the finding's subject before writing anything, and extend that skill in place rather than restating it in a second document. And it NAMES WHAT IT REPLACES \u2014 the sentence, bullet or table row it supersedes, deleted in the SAME edit \u2014 or, when it replaces nothing, says so. A promotion landing beside the claim it should have replaced leaves two authorities on one subject, and nothing here compares two documents, so the stale one is never reported again.",
-    "* If a learn/learn-eval skill is available in this session, invoke it now so reusable patterns from this run are persisted as skills.",
     "* Find the plan's issue number `<n>`: the plan below carries it in its `rafa:plan` block as `issue: <n>`.",
     `* If the plan carries no \`issue:\` field, read the number from the branch name (${branch}), which is spelled \`feat/rafa-<n>-<slug>\`.`,
     '* Title the PR `rafa-<n>: <title>`, taking `<title>` from the plan title, e.g. "rafa-20: Add pull-request commands". Open the PR body with `Closes #<n>` \u2014 the GitHub issue number on its own, never `#rafa-<n>`, since the `rafa-` prefix is this project\'s naming convention and not a GitHub alias. If no number was found, title the PR with the plan title alone and write no closing line rather than inventing one.',
@@ -14370,6 +14400,7 @@ function buildWrapUpPrompt(branch, planContent, openPullRequest = null, release
     `* Commit these changes and push them to the CURRENT branch (${branch}). Never create a branch here: the work under review is this branch's, and a second branch splits one plan across two reviews.`,
     pullRequestStep(branch, openPullRequest),
     "* Do not include Claude attribution in the commit or PR message.",
+    ...lessonsSection(lessons),
     "",
     "The plan this run executed follows, in full.",
     "",
@@ -14377,6 +14408,39 @@ function buildWrapUpPrompt(branch, planContent, openPullRequest = null, release
   ].join(`
 `);
 }
+function oneLine4(text) {
+  return text.trim().replace(/\s+/g, " ");
+}
+function lessonLines(lesson) {
+  const artifact = lesson.artifact === undefined || oneLine4(lesson.artifact) === "" ? "none" : oneLine4(lesson.artifact);
+  return [
+    `- \`${lesson.id}\``,
+    `  - trigger: ${oneLine4(lesson.trigger)}`,
+    `  - action: ${oneLine4(lesson.action)}`,
+    `  - artifact: ${artifact}`
+  ];
+}
+function lessonsSection(lessons) {
+  if (lessons.length === 0)
+    return [];
+  return [
+    "",
+    "## Lessons to promote",
+    "",
+    "These lessons recurred across enough task sessions of this project, at a high enough confidence, to belong in its tracked docs. Handle them BEFORE the commit and push above, so the pages you write are in that commit.",
+    "",
+    ...lessons.flatMap(lessonLines),
+    "",
+    "For each lesson, EITHER write it into the tracked page that owns its subject \u2014 a `context/` page, `README.md`, or a skill under `.claude/skills/` \u2014 replacing in the same edit any sentence, bullet or table row it supersedes, OR leave it out and say why. The root `AGENTS.md` is a capped map read into every turn of every session: point at a new page from there if one is needed, never inline the lesson itself.",
+    "",
+    "Then answer every lesson listed above, and no other, in ONE `rafa:promoted` block in your final message: one line per lesson, its id, an arrow, and either the path you changed or `skipped:` and the reason. A promoted path must be a file this session changed, and a lesson the block does not answer is reported in the pull request body.",
+    "",
+    "```rafa:promoted",
+    "<id> \u2192 <path>",
+    "<id> \u2192 skipped: <reason>",
+    "```"
+  ];
+}
 function pullRequestStep(branch, openPullRequest) {
   return openPullRequest === null ? `* No open PR was found for ${branch}: open one with \`gh pr create\`. If it answers that a PR already exists, push to that PR and update its body with \`gh pr edit\`; never open a second PR from a new branch.` : `* PR #${openPullRequest} is already open for ${branch}, likely opened by the plan's close-out: push to it and update its body with \`gh pr edit ${openPullRequest}\` so the description covers the promotions this session committed.`;
 }
@@ -14421,20 +14485,61 @@ async function openPullRequestNumber(branch) {
     return null;
   }
 }
-async function preserveProgress(planContent, settingSources, release, serving) {
+function messageOf4(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function wrapUpAdapter(learning) {
+  const registry = learning.registry ?? CORE_ADAPTER_REGISTRY;
+  return registry.resolve("learning", learning.kind).create({
+    repoRoot: learning.repoRoot,
+    home: learning.home,
+    learningBlessMinConfidence: learning.blessMinConfidence
+  });
+}
+async function lessonsToPromote(learning) {
+  if (learning === null)
+    return [];
+  try {
+    const bundle = await wrapUpAdapter(learning).pullBlessed();
+    return promotable(bundle.instincts, {
+      after: learning.promoteAfter,
+      minConfidence: learning.promoteMinConfidence
+    });
+  } catch (error) {
+    activeOutput().warn(`   The wrap-up lists no lesson to promote: the \`${learning.kind}\` learning adapter answered no blessed set: ${messageOf4(error)}`);
+    return [];
+  }
+}
+async function preserveProgress(planContent, settingSources, release, serving, learning) {
   const branch = getCurrentBranch();
-  const prompt = buildWrapUpPrompt(branch, planContent, await openPullRequestNumber(branch), release);
+  const openPullRequest = await openPullRequestNumber(branch);
+  const lessons = await lessonsToPromote(learning);
+  const prompt = buildWrapUpPrompt(branch, planContent, openPullRequest, release, lessons);
   const served = serving === null ? null : serveSession(serving);
   for (const skipped2 of served?.skipped ?? [])
     activeOutput().warn(`   ${skipped2.message}`);
-  const exitCode = await runClaude(withStamp(prompt), settingSources, [], undefined, served?.flags ?? []);
-  if (exitCode !== 0) {
+  const git = learning === null || lessons.length === 0 ? null : createGitRunner(learning.repoRoot);
+  const head = git === null ? null : readHead(git);
+  const session = await runClaudeCaptured(withStamp(prompt), settingSources, [], undefined, served?.flags ?? []);
+  if (session.exitCode !== 0) {
     activeOutput().error(`
-\u274C Failed to preserve progress (exit ${exitCode}). Please try again.`);
-  } else {
-    activeOutput().info(`
-\u2705 Progress preserved; PR opened or updated on this branch.`);
+\u274C Failed to preserve progress (exit ${session.exitCode}). Please try again.`);
+    return;
   }
+  activeOutput().info(`
+\u2705 Progress preserved; PR opened or updated on this branch.`);
+  if (learning === null || git === null)
+    return;
+  await checkWrapUpAnswer({
+    lessons,
+    output: session.stdout,
+    head,
+    repoRoot: learning.repoRoot,
+    branch,
+    git,
+    pulls: ghPullRequestsIn(process.cwd()),
+    learning: () => wrapUpAdapter(learning)
+  });
 }
 
 // src/utils/schedule.ts
@@ -14593,6 +14698,17 @@ async function start(args, repoRoot) {
       }
     });
     const serving = { root: repoRoot, run: session.id, home: homedir6(), settings: runConfig.config };
+    const learning = {
+      kind: runConfig.config.learningAdapter,
+      home: homedir6(),
+      blessMinConfidence: runConfig.config.learningBlessMinConfidence
+    };
+    const wrapUpLearning = {
+      ...learning,
+      repoRoot,
+      promoteAfter: runConfig.config.learningPromoteAfter,
+      promoteMinConfidence: runConfig.config.learningPromoteMinConfidence
+    };
     const triageTask = createStartTriage({ repoRoot, config: runConfig.config });
     if (!fs.existsSync(trackerPath)) {
       activeOutput().info(`\uD83D\uDCCB Creating new plan tracker at ${path2.basename(trackerPath)}...`);
@@ -14626,7 +14742,7 @@ async function start(args, repoRoot) {
           planStub: planStub2,
           planContent
         });
-        await preserveProgress(planContent, settingSources, release, serving);
+        await preserveProgress(planContent, settingSources, release, serving, wrapUpLearning);
         await finishRelease({ repoRoot, preparation: release }, {
           readProvider: () => resolvePrProvider({
             configured: runConfig.config.prProvider ?? null,
@@ -14658,7 +14774,7 @@ async function start(args, repoRoot) {
       });
       const { exitCode } = dispatch;
       const storeReport = async (outcome) => {
-        const stored2 = storeTaskReport({ repoRoot, planStub: planStub2, dispatch, outcome });
+        const stored2 = await storeTaskReport({ repoRoot, planStub: planStub2, dispatch, outcome, learning });
         await triageTask({ trackerPath, lineNum: taskInfo.lineNum, planStub: planStub2, dispatch, outcome });
         return stored2;
       };
@@ -14766,9 +14882,9 @@ function recordMissingReview(repoRoot, planPath) {
     return;
   activeOutput().info(`\uD83D\uDD0D ${planPath} records ${REVIEW_MISSING_LINE}: the session returned no readable rafa:spec-review block.`);
 }
-function recordPlanIssue(repoRoot, planPath, issue4) {
-  const line = issueFieldLine(issue4);
-  if (!recordInPlan(repoRoot, planPath, (written) => stampPlanIssue(written, issue4), line))
+function recordPlanIssue(repoRoot, planPath, issue3) {
+  const line = issueFieldLine(issue3);
+  if (!recordInPlan(repoRoot, planPath, (written) => stampPlanIssue(written, issue3), line))
     return;
   activeOutput().info(`\uD83D\uDD16 ${planPath} records ${line}, the issue it was planned from.`);
 }
@@ -14781,8 +14897,8 @@ import { readFileSync as readFileSync23 } from "fs";
 
 // src/refs/reading.ts
 import { readFileSync as readFileSync22, writeFileSync as writeFileSync11 } from "fs";
-function unblockCommand(issue4) {
-  return `rafa issue unblock ${String(issue4)}`;
+function unblockCommand(issue3) {
+  return `rafa issue unblock ${String(issue3)}`;
 }
 function firstStamp(live) {
   return live.kind === "unreadable" || live.kind === "absent" ? null : live;
@@ -14793,7 +14909,7 @@ async function liveReadings(body, verify) {
     read.push([ref, await verify(ref)]);
   return read;
 }
-function rowOf(ref, live, stamp, heldTo, issue4) {
+function rowOf(ref, live, stamp, heldTo, issue3) {
   const { state, changedHeadings: changedHeadings2 } = compareToStamp({ live, stamp, blocker: ref.blocker });
   return Object.freeze({
     kind: ref.kind,
@@ -14803,7 +14919,7 @@ function rowOf(ref, live, stamp, heldTo, issue4) {
     fingerprint: live,
     stamp: heldTo,
     changedHeadings: changedHeadings2,
-    unblock: state === "resolved" ? unblockCommand(issue4) : null
+    unblock: state === "resolved" ? unblockCommand(issue3) : null
   });
 }
 function answer2(rows, copy, body, stamps, write) {
@@ -14957,8 +15073,8 @@ async function enforceRefsGate(options) {
 // src/commands/plan/refs-check.ts
 async function coreRoster() {
   const [{ CORE_REGISTRY }, { describeRegistry }] = await Promise.all([
-    import("./index-cvpdvmtg.js"),
-    import("./describe-vq037dyt.js")
+    import("./index-mh5hyw8g.js"),
+    import("./describe-cenk70n5.js")
   ]);
   return describeRegistry(CORE_REGISTRY, version);
 }
@@ -15056,8 +15172,8 @@ function createPlanBlockedOffer(seams = DEFAULT_BLOCKED_SEAMS) {
 
 // src/commands/plan/ready-offer.ts
 var DEFAULT_OFFER_SEAMS = Object.freeze({});
-function offerHeadLine(issue4) {
-  const number = String(issue4);
+function offerHeadLine(issue3) {
+  const number = String(issue3);
   return `\uD83C\uDFF7  issue #${number} is not marked ${SPEC_READY_LABEL} \u2014 reading it as rafa issue ready ${number} would.`;
 }
 function writeOffer(request, report2) {
@@ -15072,16 +15188,16 @@ function createPlanReadyOffer(seams = DEFAULT_OFFER_SEAMS) {
   const openPrompter = seams.openPrompter ?? (() => createLinePrompter(process.stdin, process.stderr));
   const run = seams.run ?? runIssueReady;
   return async (request) => {
-    const { issue: issue4 } = request;
-    request.output.info(offerHeadLine(issue4.number));
+    const { issue: issue3 } = request;
+    request.output.info(offerHeadLine(issue3.number));
     const prompter = lazyPrompter(openPrompter);
     try {
       const report2 = await run({
         gh: request.gh,
-        issue: issue4.number,
+        issue: issue3.number,
         trust: request.trust,
         ask: prompter.ask,
-        readIssue: () => Promise.resolve(issue4)
+        readIssue: () => Promise.resolve(issue3)
       });
       writeOffer(request, report2);
       return report2.status === "marked";
@@ -15338,4 +15454,4 @@ async function plan(args, repoRoot, registry = CORE_ADAPTER_REGISTRY) {
   }
 }
 
-export { readConfigFile, loadConfig, planStubsFromFileNames, resolvePlanStub, sessionLogDir, collectSessionRow, collect, report, name, version, MANIFEST_VERSION, FEATURE_TYPES, OUTPUT_CHANNELS, RUNNING_MANIFEST_SEAMS, validateManifest, plansDirAt, requireProject, resolvePlansDir, resolveProjectConfig, countTasks, formatCounts, checkbox, planFileName, stubOfPlanFile, isFile, issueLine, plural, expectNoArgument, expectOneArgument, expectAtMostOneArgument, readSwitch, readFrontmatterDocument, readFrontmatter, renderFrontmatter, mergeFrontmatter, writeFrontmatter, normalizeRemote, gitRemoteUrl, ACTION_HEADING, CAUSE_HEADING, actionHash, parseInstinct, writeInstinct, PROVENANCE_FIELD, isStackList, stackPaths, stacksFromEccSkillName, DESCRIPTION_LIMIT, LISTING_LIMIT, SKILL_SIGNALS, countCharacters, SKILL_FILE, MARKDOWN_EXTENSION, scanLayout, toolOf, pathDirectories, collectReferences, checkReferences, checkFile, checkDirectory, AGENT_DEFINITION_DIR, readInventoryFrontmatter, bundledAgentsDirectory, sourceItem, byName, skillItem, readTrees, SCOPE_DIR, INIT_COMMAND, DISK_FILE_SYSTEM, ScopeError, scopeAt, initHint, selfAndAncestors, resolveScope, SessionRecordError, runsDir, errorCode, readSessions, readSession, SERVE_CLI_VERSION, SKILL_FILE2 as SKILL_FILE1, provenanceBlock, serveVerdict, VENDOR_COMMAND, readAgentDirectory, resolveAgentRoster, missingPlanAgents, validate_default, SPEC_READY_LABEL, TEMPLATE_HEADINGS, findReadinessGaps, hasSpecReadyLabel, createGhPermissions, readAuthorTrust, trustRefusalClause, requireTrustedAuthor, SPEC_NEEDS_WORK_LABEL, SPEC_BLOCKED_LABEL, hasSpecBlockedLabel, readBlockedBy, blockedFaultMessage, UNREADABLE, RefsBlockError, fingerprintText, readRefsText, readCopyRefs, restampCopyRefs, createGitRunner, gitSaid, RefVerifyError, ghIssueReader, tsSymbolsOutliner, createRefVerifier, createGhIssueBoard, ID_PREFIX, BRANCH_PREFIX, SPEC_EXTENSION, boardId, notesFileName, PREVIOUS_COPY_WARN_ABOVE, previousDir, countPreviousCopies, SPEC_LABEL, createGhSpecIssueReader, ROADMAP_TITLE, ROADMAP_SETTING, ROADMAP_REFUSAL_EXIT, parseRoadmapBody, createGhRoadmapSearch, severalRoadmapsMessage, resolveRoadmapIssue, createGhOpenPullRequests, closedIssuesIn, branchClaims, scanClaimBranches, blockedLineSentence, memoiseVerifier, readPlanChanges, shellQuote, ghMissingMessage, ghUnauthenticatedMessage, ghHostOf, ghPreflightItems, resolvePrProvider, requireGhProvider, isFirstDispatch, SESSION_ID_FLAG2 as SESSION_ID_FLAG, resolveLoopSeams, sessionIdFlag, refusal2 as refusal, isLive, planLabel, sessionLine, projectRoot, readRecords, pickSession, writeSession, readSessionChecklist, checkboxAt, estimateEta, readSessionFinishes, etaLine, verdictOf, failingRows, formatRows, waitForChecks, parseWorkingTree, parseWorktrees, readMergeRefusal, cleanUpSteps, commandLine, remainingFrom, createGhPullRequests, ghPullRequestsIn, DEFAULT_BASE_BRANCH, ghNextBoard, openNextSources, createLinePrompter, REMOTE, parseBaseStanding, hasDiverged, list_default, readBranch, readPlans, readOpenPull, readBranchPlan, readNextState, commandWords, nextQuestion, NEXT_COMMAND_ACTIONS, actionInvocation, runAction, HINT_FLAG_SPEC, actionOutput, endWithNextStep, endingWith, DEFAULT_ISSUE_SEAMS, lineRefusal2 as lineRefusal, expectTwoArguments, readTextFlag, readNonBlankFlag, readRequiredFlag, readChoice, readChoiceFlag, issueProject, issueSubjectConfig, resolveIssueTracker, issueRef, issueName, urlLines, onTracker, lazyPrompter, ready_default, versionLine, DEFAULT_PLAN_FILE, resolvePlanPath, assessPlanRisk, renderRiskText, announceRiskTotal, resolveCreateSpec, resolveReleaseEnabled, TRIAGE_MODULE, DEFAULT_CI_TIMEOUT_MIN, CI_POLL_INTERVAL_MS, DEFAULT_CI_ATTEMPTS, RUNTIME_SUBDIR, RUNTIME_ENTRY, VERSION_SHAPE2 as VERSION_SHAPE, refuseMisplacedRuntime, groupChangeNotes, renderNoteLines, highestChangeLevel, parseSemanticVersion, readManifestVersion, MECHANICAL_CONFLICT_SENTENCE, start, usage, coreRoster, createPlanRefsVerifier, plan };
+export { readConfigFile, loadConfig, planStubsFromFileNames, resolvePlanStub, sessionLogDir, collectSessionRow, collect, report, name, version, MANIFEST_VERSION, FEATURE_TYPES, OUTPUT_CHANNELS, RUNNING_MANIFEST_SEAMS, validateManifest, plansDirAt, requireProject, resolvePlansDir, resolveProjectConfig, countTasks, formatCounts, checkbox, planFileName, stubOfPlanFile, isFile, issueLine, plural, expectNoArgument, expectOneArgument, expectAtMostOneArgument, readSwitch, PROVENANCE_FIELD, isStackList, stackPaths, stacksFromEccSkillName, DESCRIPTION_LIMIT, LISTING_LIMIT, SKILL_SIGNALS, countCharacters, toolOf, pathDirectories, checkReferences, checkFile, checkDirectory, AGENT_DEFINITION_DIR, readInventoryFrontmatter, bundledAgentsDirectory, sourceItem, byName, skillItem, readTrees, SCOPE_DIR, INIT_COMMAND, DISK_FILE_SYSTEM, ScopeError, scopeAt, initHint, selfAndAncestors, resolveScope, SessionRecordError, runsDir, errorCode, readSessions, readSession, SERVE_CLI_VERSION, SKILL_FILE2 as SKILL_FILE, provenanceBlock, serveVerdict, VENDOR_COMMAND, readAgentDirectory, resolveAgentRoster, missingPlanAgents, validate_default, SPEC_READY_LABEL, TEMPLATE_HEADINGS, findReadinessGaps, hasSpecReadyLabel, createGhPermissions, readAuthorTrust, trustRefusalClause, requireTrustedAuthor, SPEC_NEEDS_WORK_LABEL, SPEC_BLOCKED_LABEL, hasSpecBlockedLabel, readBlockedBy, blockedFaultMessage, UNREADABLE, RefsBlockError, fingerprintText, readRefsText, readCopyRefs, restampCopyRefs, createGitRunner, gitSaid, RefVerifyError, ghIssueReader, tsSymbolsOutliner, createRefVerifier, createGhIssueBoard, ID_PREFIX, BRANCH_PREFIX, SPEC_EXTENSION, boardId, notesFileName, PREVIOUS_COPY_WARN_ABOVE, previousDir, countPreviousCopies, SPEC_LABEL, createGhSpecIssueReader, ROADMAP_TITLE, ROADMAP_SETTING, ROADMAP_REFUSAL_EXIT, parseRoadmapBody, createGhRoadmapSearch, severalRoadmapsMessage, resolveRoadmapIssue, createGhOpenPullRequests, closedIssuesIn, branchClaims, scanClaimBranches, blockedLineSentence, memoiseVerifier, LEARNED_DIRECTORY, ORIGIN_FIELD, DEMOTION_VERDICTS, WHEN_TO_USE_HEADING, bodySections, classifySkill, firstSentence, convertToInstinct, readPlanChanges, shellQuote, ghMissingMessage, ghUnauthenticatedMessage, ghHostOf, ghPreflightItems, resolvePrProvider, requireGhProvider, isFirstDispatch, SESSION_ID_FLAG2 as SESSION_ID_FLAG, resolveLoopSeams, sessionIdFlag, refusal2 as refusal, isLive, planLabel, sessionLine, projectRoot, readRecords, pickSession, writeSession, readSessionChecklist, checkboxAt, estimateEta, readSessionFinishes, etaLine, verdictOf, failingRows, formatRows, waitForChecks, parseWorkingTree, parseWorktrees, readMergeRefusal, cleanUpSteps, commandLine, remainingFrom, createGhPullRequests, ghPullRequestsIn, DEFAULT_BASE_BRANCH, ghNextBoard, openNextSources, createLinePrompter, REMOTE, parseBaseStanding, hasDiverged, list_default, readBranch, readPlans, readOpenPull, readBranchPlan, readNextState, commandWords, nextQuestion, NEXT_COMMAND_ACTIONS, actionInvocation, runAction, HINT_FLAG_SPEC, actionOutput, endWithNextStep, endingWith, DEFAULT_ISSUE_SEAMS, lineRefusal2 as lineRefusal, expectTwoArguments, readTextFlag, readNonBlankFlag, readRequiredFlag, readChoice, readChoiceFlag, issueProject, issueSubjectConfig, resolveIssueTracker, issueRef, issueName, urlLines, onTracker, lazyPrompter, ready_default, versionLine, DEFAULT_PLAN_FILE, resolvePlanPath, assessPlanRisk, renderRiskText, announceRiskTotal, resolveCreateSpec, resolveReleaseEnabled, TRIAGE_MODULE, DEFAULT_CI_TIMEOUT_MIN, CI_POLL_INTERVAL_MS, DEFAULT_CI_ATTEMPTS, RUNTIME_SUBDIR, RUNTIME_ENTRY, VERSION_SHAPE2 as VERSION_SHAPE, refuseMisplacedRuntime, groupChangeNotes, renderNoteLines, highestChangeLevel, parseSemanticVersion, readManifestVersion, MECHANICAL_CONFLICT_SENTENCE, start, usage, coreRoster, createPlanRefsVerifier, plan };