@open-tomato/rafa 0.18.0 → 0.20.0

package/dist/{index-at9f1z2z.js → index-afersvp3.js}

@@ -1,20 +1,38 @@
 // @bun
 import {
+  CONFIG_DEFAULTS,
+  FINDING_DOMAINS,
+  FINDING_KINDS,
+  FINDING_SIGNALS,
   activeOutput,
   activeOutputMode,
   createTextOutput,
   readRafaBlocks
-} from "./index-jva32qe6.js";
+} from "./index-twbp38kz.js";
+import {
+  bless,
+  merge
+} from "./index-d6d0942q.js";
 import {
   commandSpelling
-} from "./index-ddf85qac.js";
+} from "./index-28jzpyks.js";
 import {
+  RAFA_INSTINCTS_PATH,
   STORE_BACKENDS,
   bundledBinDirectory,
   describeValue,
   isMapping,
-  messageOf
-} from "./index-944pncd8.js";
+  messageOf,
+  resolveInstinctScopes,
+  tierExists
+} from "./index-pmkgvtfe.js";
+import {
+  actionHash,
+  triggerKey
+} from "./index-wp8c28fd.js";
+
+// src/adapters/registry.ts
+import { homedir } from "os";
 
 // src/effort/store.ts
 import {
@@ -316,6 +334,27 @@ var SQLITE_MIGRATIONS = [
   `
   ALTER TABLE out_of_scope_bugs
     ADD COLUMN scope TEXT CHECK (scope IN ('machine', 'rafa'));
+  `,
+  `
+  ALTER TABLE dispatches
+    ADD COLUMN resolver TEXT CHECK (resolver IN ('planner', 'tag', 'none'));
+  ALTER TABLE dispatches
+    ADD COLUMN skills_offered TEXT CHECK (skills_offered IS NULL OR json_type(skills_offered) = 'array');
+  ALTER TABLE dispatches
+    ADD COLUMN lessons_offered TEXT CHECK (lessons_offered IS NULL OR json_type(lessons_offered) = 'array');
+  `,
+  `
+  CREATE TABLE skill_invocations (
+    seq        INTEGER PRIMARY KEY,
+    session_id TEXT NOT NULL CHECK (session_id <> ''),
+    name       TEXT CHECK (name <> ''),
+    sidechain  INTEGER CHECK (sidechain IN (0, 1)),
+    count      INTEGER CHECK (count IS NULL OR (typeof(count) = 'integer' AND count > 0)),
+    CHECK ((name IS NULL) = (count IS NULL) AND (name IS NULL) = (sidechain IS NULL))
+  );
+
+  CREATE UNIQUE INDEX skill_invocations_by_use
+    ON skill_invocations (session_id, ifnull(name, ''), ifnull(sidechain, -1));
   `
 ];
 var SQLITE_SCHEMA_VERSION = SQLITE_MIGRATIONS.length;
@@ -440,11 +479,812 @@ function openSqliteStore(repoRoot) {
 }
 
 // src/adapters/learning/local.ts
-import { appendFile, mkdir, readFile } from "fs/promises";
-import { join as join3 } from "path";
+import { appendFile, mkdir, readFile, rm, writeFile } from "fs/promises";
+import { join as join5 } from "path";
+
+// src/commands/instinct/instinct-records.ts
+import { readdirSync as readdirSync2, readFileSync as readFileSync2, statSync as statSync2 } from "fs";
+import { join as join4 } from "path";
+
+// src/check/layout.ts
+import { readdirSync, statSync } 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 = statSync(path);
+    if (stats.isFile())
+      return "file";
+    if (stats.isDirectory())
+      return "directory";
+    return null;
+  } catch {
+    return null;
+  }
+}
+function visibleNames(dir) {
+  return readdirSync(dir).filter((name) => !name.startsWith(".")).sort((left, right) => left.localeCompare(right));
+}
+function isMarkdown(name) {
+  return name.endsWith(MARKDOWN_EXTENSION);
+}
+function markdownStem(name) {
+  return name.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, name) {
+  return { kind: "skill", path, isFile: true, shape: "skill-file", name, issues: [] };
+}
+function flatGroupedEntry(root, path, name) {
+  return {
+    kind: "skill",
+    path,
+    isFile: true,
+    shape: "flat-grouped",
+    name,
+    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>/${name}/${SKILL_FILE}`)]
+  };
+}
+function nestedGroupEntry(root, path, name) {
+  return {
+    kind: "skill",
+    path,
+    isFile: true,
+    shape: "nested-group",
+    name,
+    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>/${name}/${SKILL_FILE}`)]
+  };
+}
+function looseFileEntry(root, path, name) {
+  return {
+    kind: "skill",
+    path,
+    isFile: true,
+    shape: "loose-file",
+    name,
+    issues: [layoutIssue("loose-file", `${shown(root, path)} sits directly under the skills directory, which registers` + ` only <dir>/<name>/${SKILL_FILE}; move it to <dir>/${name}/${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, name) {
+  return {
+    kind: "instinct",
+    path,
+    isFile: true,
+    shape: "nested-instinct",
+    name,
+    issues: [layoutIssue("nested-instinct-file", `${shown(root, path)} sits below the instincts directory, which is flat;` + ` move it to <dir>/${name}${MARKDOWN_EXTENSION}`)]
+  };
+}
+function scanGroupMember(root, dir, name) {
+  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, name)];
+  }
+  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, name) {
+  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, name)];
+  }
+  return scanSkillGroup(root, dir, children);
+}
+function scanSkillRoot(root) {
+  const entries = [];
+  for (const name of visibleNames(root)) {
+    const path = join3(root, name);
+    const found = entryKind(path);
+    if (found === null) {
+      entries.push(unreadableEntry("skill", root, path));
+      continue;
+    }
+    if (found === "directory") {
+      entries.push(...scanSkillDirectory(root, path, name));
+      continue;
+    }
+    if (isMarkdown(name))
+      entries.push(looseFileEntry(root, path, markdownStem(name)));
+  }
+  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 name of visibleNames(root)) {
+    const path = join3(root, name);
+    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(name))
+      continue;
+    entries.push({
+      kind: "instinct",
+      path,
+      isFile: true,
+      shape: "instinct-file",
+      name: markdownStem(name),
+      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 field = entry.kind === "skill" ? "name" : "id";
+  const source = entry.kind === "skill" ? "directory name" : "file name";
+  return layoutIssue("name-mismatch", `frontmatter ${field} "${declared}" is not the ${source} "${entry.name}"`);
+}
+
+// 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/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 = FINDING_DOMAINS;
+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",
+  "sources",
+  "artifact",
+  "signal",
+  "scope",
+  "project_id",
+  "source",
+  "evidence",
+  "promoted_to",
+  "created_at",
+  "updated_at"
+];
+function issue(code, field, message) {
+  return { code, field, 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, field) {
+  const value = data[field];
+  if (value === undefined || value === null) {
+    return [issue("missing-field", field, `${field} is required and is absent`)];
+  }
+  if (typeof value !== "string") {
+    return [issue("wrong-type", field, `${field} must be a string, not ${typeName(value)}`)];
+  }
+  if (value.trim() === "") {
+    return [issue("missing-field", field, `${field} is required and is empty`)];
+  }
+  return [];
+}
+function requiredChoice(data, field, allowed, code) {
+  const issues = requiredString(data, field);
+  if (issues.length > 0)
+    return issues;
+  const value = data[field];
+  return allowed.includes(value) ? [] : [issue(code, field, `${field} "${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 checkSources(data) {
+  const value = data["sources"];
+  if (value === undefined)
+    return [];
+  if (!Array.isArray(value)) {
+    return [issue("wrong-type", "sources", `sources must be a list, not ${typeName(value)}`)];
+  }
+  return value.flatMap((entry, index) => {
+    const field = `sources[${index}]`;
+    if (typeof entry !== "string") {
+      return [issue("wrong-type", field, `sources entries must be strings, and this one is ${typeName(entry)}`)];
+    }
+    return entry.trim() === "" ? [issue("wrong-type", field, "sources entries must name a source, and this one is blank")] : [];
+  });
+}
+function checkPromotedTo(data) {
+  const value = data["promoted_to"];
+  if (value === undefined)
+    return [];
+  if (typeof value !== "string") {
+    return [issue("wrong-type", "promoted_to", `promoted_to must be a string, not ${typeName(value)}`)];
+  }
+  const absolute = /^(?:[/\\]|[A-Za-z]:)/.test(value);
+  const climbs = value.split(/[/\\]/).includes("..");
+  return value.trim() !== "" && !absolute && !climbs ? [] : [issue("invalid-promoted-to", "promoted_to", `promoted_to "${value}" is not a path inside the repository such as context/source.md`)];
+}
+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, field) {
+  const issues = requiredString(data, field);
+  if (issues.length > 0)
+    return issues;
+  const value = data[field];
+  return TIMESTAMP_PATTERN.test(value) && !Number.isNaN(Date.parse(value)) ? [] : [issue("invalid-timestamp", field, `${field} "${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 field = `evidence[${index}]`;
+  if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
+    return [issue("wrong-type", field, `evidence entries must be mappings, and this one is ${typeName(entry)}`)];
+  }
+  const entries = Object.entries(entry);
+  if (entries.length === 0) {
+    return [issue("wrong-type", field, "evidence entries must say something, and this one is empty")];
+  }
+  return entries.flatMap(([key, value]) => isScalar(value) ? [] : [issue("wrong-type", `${field}.${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),
+    ...checkSources(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),
+    ...checkPromotedTo(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,
+    sources: Array.isArray(data["sources"]) ? data["sources"] : [],
+    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"] : [],
+    promotedTo: typeof data["promoted_to"] === "string" ? data["promoted_to"] : null,
+    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;
+  if (instinct.sources.length > 0)
+    written["sources"] = instinct.sources;
+  if (instinct.promotedTo !== null)
+    written["promoted_to"] = instinct.promotedTo;
+  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/commands/instinct/instinct-records.ts
+function isRecordFile(name) {
+  return !name.startsWith(".") && name.endsWith(MARKDOWN_EXTENSION) && name !== MARKDOWN_EXTENSION;
+}
+function recordId(name) {
+  return name.slice(0, -MARKDOWN_EXTENSION.length);
+}
+function unreadableIssue(message) {
+  return { code: "missing-frontmatter", field: "file", message: `the file could not be read: ${message}` };
+}
+function readRecord(path, scope, id) {
+  let text;
+  try {
+    text = readFileSync2(path, "utf8");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { scope, path, id, instinct: null, issues: [unreadableIssue(message)] };
+  }
+  const parsed = parseInstinct(text);
+  return { scope, path, id, instinct: parsed.instinct, issues: parsed.issues };
+}
+function isFile(path) {
+  try {
+    return statSync2(path).isFile();
+  } catch {
+    return false;
+  }
+}
+function recordFiles(dir) {
+  return readdirSync2(dir).filter((name) => isRecordFile(name) && isFile(join4(dir, name))).sort((left, right) => left.localeCompare(right));
+}
+function readScope(scope, dir) {
+  if (!tierExists(dir))
+    return { scope, dir, exists: false, records: [] };
+  return {
+    scope,
+    dir,
+    exists: true,
+    records: recordFiles(dir).map((name) => readRecord(join4(dir, name), scope, recordId(name)))
+  };
+}
+function readScopes(seams) {
+  return resolveInstinctScopes(seams).map((location) => readScope(location.scope, location.dir));
+}
+function allRecords(listings) {
+  return listings.flatMap((listing) => listing.records);
+}
+function findRecords(listings, id) {
+  return allRecords(listings).filter((entry) => entry.id === id);
+}
+function instinctProject(context, name) {
+  if (context.project === null)
+    throw new Error(`${name} runs inside a project, and was handed none`);
+  return context.project;
+}
+
+// src/adapters/learning/held.ts
+function compareText(left, right) {
+  if (left < right) {
+    return -1;
+  }
+  if (left > right) {
+    return 1;
+  }
+  return 0;
+}
+function byAge(left, right) {
+  return compareText(left.createdAt, right.createdAt) || compareText(left.id, right.id);
+}
+function toHeldRecord(instinct) {
+  return {
+    id: instinct.id,
+    trigger: instinct.trigger,
+    action: instinct.action,
+    action_hash: instinct.actionHash,
+    confidence: instinct.confidence,
+    usage_count: instinct.usageCount,
+    ...instinct.sources.length > 0 ? { sources: [...instinct.sources] } : {},
+    ...instinct.artifact === null ? {} : { artifact: instinct.artifact },
+    signal: instinct.signal,
+    status: "active",
+    ...instinct.promotedTo === null ? {} : { promoted_to: instinct.promotedTo },
+    created_at: instinct.createdAt,
+    updated_at: instinct.updatedAt
+  };
+}
+function toHeldRecords(held) {
+  const actions = new Map;
+  for (const instinct of held) {
+    const key = triggerKey(instinct.trigger);
+    actions.set(key, (actions.get(key) ?? new Set).add(instinct.actionHash));
+  }
+  return held.map((instinct) => {
+    const record = toHeldRecord(instinct);
+    return actions.get(triggerKey(instinct.trigger)).size > 1 ? { ...record, status: "flagged" } : record;
+  });
+}
+function earliestHeldMember(record, held) {
+  const key = triggerKey(record.trigger);
+  const members = held.filter((instinct) => instinct.actionHash === record.action_hash && triggerKey(instinct.trigger) === key);
+  return [...members].sort(byAge)[0] ?? null;
+}
+function toHeldInstinct(record, held, fallback) {
+  const description = earliestHeldMember(record, held) ?? fallback;
+  if (description === undefined) {
+    return null;
+  }
+  return {
+    id: record.id,
+    trigger: record.trigger,
+    kind: description.kind,
+    domain: description.domain,
+    confidence: record.confidence,
+    usageCount: record.usage_count,
+    sources: [...record.sources ?? []],
+    artifact: record.artifact ?? null,
+    signal: record.signal,
+    scope: description.scope,
+    projectId: description.projectId,
+    source: description.source,
+    evidence: [...description.evidence],
+    promotedTo: record.promoted_to ?? null,
+    createdAt: record.created_at,
+    updatedAt: record.updated_at,
+    action: record.action,
+    cause: description.cause,
+    actionHash: actionHash(record.action)
+  };
+}
+
+// src/adapters/learning/local.ts
 var PREFIX = "local learning";
+var PUSH_REFUSAL = `${PREFIX}: refused to store a push`;
 var INSTINCTS_FILE = "instincts.ndjson";
 var FLAGS_FILE = "flags.ndjson";
+var RECORD_EXTENSION = ".md";
 var MIN_CONFIDENCE = 0.3;
 var MAX_CONFIDENCE = 0.9;
 var SIGNALS = ["loud", "silent"];
@@ -471,20 +1311,30 @@ var INSTINCT_CHECKS = {
     (value) => typeof value === "number" && Number.isSafeInteger(value) && value >= 0,
     "a whole number from 0"
   ],
+  sources: [
+    (value) => value === undefined || Array.isArray(value) && value.every(isNonEmptyString),
+    "a list of non-empty strings when present"
+  ],
   artifact: [(value) => value === undefined || typeof value === "string", "a string when present"],
   signal: [oneOf(SIGNALS), `one of: ${SIGNALS.join(", ")}`],
   status: [oneOf(STATUSES), `one of: ${STATUSES.join(", ")}`],
+  promoted_to: [(value) => value === undefined || typeof value === "string", "a string when present"],
   created_at: [isString, "a string"],
   updated_at: [isString, "a string"]
 };
+var DESCRIPTION_CHECKS = {
+  kind: [oneOf(INSTINCT_KINDS), `one of: ${INSTINCT_KINDS.join(", ")}`],
+  domain: [oneOf(INSTINCT_DOMAINS), `one of: ${INSTINCT_DOMAINS.join(", ")}`],
+  scope: [oneOf(INSTINCT_SCOPES), `one of: ${INSTINCT_SCOPES.join(", ")}`],
+  source: [oneOf(INSTINCT_SOURCES), `one of: ${INSTINCT_SOURCES.join(", ")}`],
+  evidence: [(value) => Array.isArray(value) && value.every(isMapping), "a list of mappings"],
+  cause: [isString, "a string"],
+  projectId: [(value) => value === null || typeof value === "string", "a string or null"]
+};
 var PAYLOAD_CHECKS = {
   source_id: [isNonEmptyString, "a non-empty string"],
   instincts: [Array.isArray, "a list"]
 };
-var HELD_INSTINCT_CHECKS = {
-  source_id: [isNonEmptyString, "a non-empty string"],
-  instinct: [isMapping, "a mapping"]
-};
 var FLAG_CHECKS = {
   id: [isNonEmptyString, "a non-empty string"],
   reason: [isString, "a string"],
@@ -501,21 +1351,29 @@ function fieldsProblem(value, checks, at) {
   }
   return null;
 }
+function recordProblem(record, index) {
+  const at = `instincts[${index}]`;
+  const problem = fieldsProblem(record, INSTINCT_CHECKS, at);
+  if (problem !== null)
+    return problem;
+  const { action, action_hash: hash, description } = record;
+  if (hash !== actionHash(action)) {
+    return `action_hash is ${describeValue(hash)} in ${at}, expected the sha256 of its trimmed, lower-cased action`;
+  }
+  return description === undefined ? null : fieldsProblem(description, DESCRIPTION_CHECKS, `${at}.description`);
+}
 function payloadProblem(payload) {
   const problem = fieldsProblem(payload, PAYLOAD_CHECKS, "the payload");
   if (problem !== null)
     return problem;
   const { instincts } = payload;
-  return instincts.map((record, index) => fieldsProblem(record, INSTINCT_CHECKS, `instincts[${index}]`)).find((found) => found !== null) ?? null;
-}
-function heldInstinctProblem(value) {
-  return fieldsProblem(value, HELD_INSTINCT_CHECKS, "the line") ?? fieldsProblem(value.instinct, INSTINCT_CHECKS, "the instinct");
+  return instincts.map(recordProblem).find((found) => found !== null) ?? null;
 }
 function flagProblem(value) {
   return fieldsProblem(value, FLAG_CHECKS, "the flag");
 }
 function copyInstinct(record) {
-  const { artifact } = record;
+  const { sources, artifact, promoted_to: promotedTo } = record;
   return {
     id: record.id,
     trigger: record.trigger,
@@ -523,13 +1381,29 @@ function copyInstinct(record) {
     action_hash: record.action_hash,
     confidence: record.confidence,
     usage_count: record.usage_count,
+    ...sources === undefined ? {} : { sources: [...sources] },
     ...artifact === undefined ? {} : { artifact },
     signal: record.signal,
     status: record.status,
+    ...promotedTo === undefined ? {} : { promoted_to: promotedTo },
     created_at: record.created_at,
     updated_at: record.updated_at
   };
 }
+function copyDescription(description) {
+  return {
+    kind: description.kind,
+    domain: description.domain,
+    scope: description.scope,
+    source: description.source,
+    evidence: description.evidence.map((entry) => ({ ...entry })),
+    cause: description.cause,
+    projectId: description.projectId
+  };
+}
+function loggedIncoming(record) {
+  return record.description === undefined ? copyInstinct(record) : { ...copyInstinct(record), description: copyDescription(record.description) };
+}
 function hasCode(error, code) {
   return typeof error === "object" && error !== null && "code" in error && error.code === code;
 }
@@ -568,24 +1442,116 @@ function readLine(line, problemOf) {
 function warnThroughActiveOutput(message) {
   activeOutput().warn(message);
 }
+function unflagged(records, flagged) {
+  return records.filter((record) => !flagged.has(record.id));
+}
+function userAdditions(userBlessed, projectHeld, flagged) {
+  const heldTriggers = new Set(projectHeld.map((record) => triggerKey(record.trigger)));
+  const heldIds = new Set(projectHeld.map((record) => record.id));
+  return unflagged(userBlessed, flagged).filter((record) => !heldTriggers.has(triggerKey(record.trigger)) && !heldIds.has(record.id));
+}
+function byAge2(left, right) {
+  if (left.created_at !== right.created_at) {
+    return left.created_at < right.created_at ? -1 : 1;
+  }
+  if (left.id === right.id)
+    return 0;
+  return left.id < right.id ? -1 : 1;
+}
+function payloadDescription(record, described) {
+  const key = triggerKey(record.trigger);
+  const members = described.filter((candidate) => candidate.description !== undefined && candidate.action_hash === record.action_hash && triggerKey(candidate.trigger) === key);
+  return [...members].sort(byAge2)[0]?.description;
+}
+function producedRecords(result) {
+  const byId = new Map;
+  for (const record of result.decisions.flatMap((decision) => decision.produced)) {
+    const found = byId.get(record.id);
+    if (found !== undefined && found !== record) {
+      throw new Error(`${PUSH_REFUSAL}: two records would be written to ${record.id}${RECORD_EXTENSION}`);
+    }
+    byId.set(record.id, record);
+  }
+  return [...byId.values()];
+}
+function heldChanges(dir, held, result, described) {
+  const heldInstincts = held.files.map((file) => file.instinct);
+  const heldAt = new Map(held.files.map((file) => [file.path, file.instinct]));
+  const writes = [];
+  const kept = new Set;
+  for (const record of producedRecords(result)) {
+    const file = `${record.id}${RECORD_EXTENSION}`;
+    const instinct = toHeldInstinct(record, heldInstincts, payloadDescription(record, described));
+    if (instinct === null) {
+      throw new Error(`${PUSH_REFUSAL}: ${file} has no held member and no payload description to be written with`);
+    }
+    const text = writeInstinct(instinct);
+    const [issue2] = parseInstinct(text).issues;
+    if (issue2 !== undefined) {
+      throw new Error(`${PUSH_REFUSAL}: ${file} would not read back: ${issue2.field}: ${issue2.message}`);
+    }
+    const path = join5(dir, file);
+    if (held.unreadable.has(path)) {
+      throw new Error(`${PUSH_REFUSAL}: it would overwrite ${path}, which could not be read`);
+    }
+    const before = heldAt.get(path);
+    if (before !== undefined && triggerKey(before.trigger) !== triggerKey(record.trigger)) {
+      throw new Error(`${PUSH_REFUSAL}: it would overwrite ${path}, which holds another trigger`);
+    }
+    kept.add(path);
+    if (before === undefined || writeInstinct(before) !== text)
+      writes.push({ path, text });
+  }
+  const touched = new Set(result.decisions.map((decision) => triggerKey(decision.incoming.trigger)));
+  const removals = held.files.filter((file) => touched.has(triggerKey(file.instinct.trigger)) && !kept.has(file.path)).map((file) => file.path);
+  return { writes, removals };
+}
+function pushLogLines(sourceId, described, result) {
+  return result.decisions.map((decision, index) => {
+    const key = triggerKey(decision.incoming.trigger);
+    const line = {
+      source_id: sourceId,
+      rule: decision.rule,
+      incoming: loggedIncoming(described[index]),
+      produced: decision.produced.map((record) => record.id),
+      discarded: result.discarded.filter((record) => triggerKey(record.trigger) === key).map((record) => record.id)
+    };
+    return JSON.stringify(line);
+  });
+}
 function localInstinctsDir(repoRoot) {
-  return join3(repoRoot, ".rafa", "instincts");
+  return join5(repoRoot, RAFA_INSTINCTS_PATH);
+}
+function userInstinctsDir(home) {
+  return join5(home, RAFA_INSTINCTS_PATH);
 }
 function createLocalLearning(options) {
-  const { instinctsDir } = options;
+  const { instinctsDir, minConfidence } = options;
+  const userDir = userInstinctsDir(options.home);
   const now = options.now ?? (() => new Date().toISOString());
   const warn = options.warn ?? warnThroughActiveOutput;
-  const instinctsPath = join3(instinctsDir, INSTINCTS_FILE);
-  const flagsPath = join3(instinctsDir, FLAGS_FILE);
-  async function heldInstincts() {
-    const lines = numberedLines(await readIfPresent(instinctsPath));
-    return lines.flatMap(([number, line]) => {
-      const reading = readLine(line, heldInstinctProblem);
-      if (reading.ok)
-        return [copyInstinct(reading.value.instinct)];
-      warn(`${PREFIX}: line ${number} of ${instinctsPath} is not a held instinct, so it was skipped: ${reading.problem}`);
-      return [];
-    });
+  const instinctsPath = join5(instinctsDir, INSTINCTS_FILE);
+  const flagsPath = join5(instinctsDir, FLAGS_FILE);
+  function readHeld(scope, dir) {
+    const { records } = readScope(scope, dir);
+    const unreadable = new Set;
+    const files = [];
+    for (const entry of records) {
+      if (entry.instinct === null) {
+        unreadable.add(entry.path);
+        const problems = entry.issues.map((issue2) => `${issue2.field}: ${issue2.message}`).join("; ");
+        warn(`${PREFIX}: ${entry.path} is not a held instinct, so it was skipped: ${problems}`);
+      } else {
+        files.push({ path: entry.path, instinct: entry.instinct });
+      }
+    }
+    return { files, unreadable };
+  }
+  function heldSet() {
+    return readHeld("project", instinctsDir);
+  }
+  function heldRecords(held) {
+    return toHeldRecords(held.files.map((file) => file.instinct));
   }
   async function flaggedIds() {
     const lines = numberedLines(await readIfPresent(flagsPath));
@@ -600,27 +1566,31 @@ function createLocalLearning(options) {
     push: async (payload) => {
       const problem = payloadProblem(payload);
       if (problem !== null) {
-        throw new TypeError(`${PREFIX}: refused to store a push: ${problem}`);
+        throw new TypeError(`${PUSH_REFUSAL}: ${problem}`);
       }
-      const decisions = payload.instincts.map((incoming) => ({
-        incoming,
-        rule: "new-trigger",
-        produced: [copyInstinct(incoming)]
-      }));
-      const lines = decisions.flatMap(({ produced }) => produced.map((instinct) => JSON.stringify({
-        source_id: payload.source_id,
-        instinct
-      })));
+      const described = payload.instincts;
+      const held = heldSet();
+      const result = merge(toHeldRecords(held.files.map((file) => file.instinct)), { source_id: payload.source_id, instincts: described.map(copyInstinct) }, now());
+      const changes = heldChanges(instinctsDir, held, result, described);
+      const lines = pushLogLines(payload.source_id, described, result);
       if (lines.length > 0) {
         await mkdir(instinctsDir, { recursive: true });
         await appendLines(instinctsPath, lines);
       }
-      return { decisions, discarded: [] };
+      for (const { path, text } of changes.writes) {
+        await writeFile(path, text, "utf8");
+      }
+      for (const path of changes.removals) {
+        await rm(path, { force: true });
+      }
+      return result;
     },
     pullBlessed: async () => {
       const flagged = await flaggedIds();
-      const instincts = (await heldInstincts()).filter((instinct) => instinct.status === "active" && !flagged.has(instinct.id));
-      return { version: now(), instincts };
+      const projectHeld = heldRecords(heldSet());
+      const project = bless(unflagged(projectHeld, flagged), { minConfidence }).instincts;
+      const user = bless(heldRecords(readHeld("user", userDir)), { minConfidence }).instincts;
+      return { version: now(), instincts: [...project, ...userAdditions(user, projectHeld, flagged)] };
     },
     flag: async (id, reason) => {
       const flag = { id, reason, flagged_at: now() };
@@ -628,8 +1598,7 @@ function createLocalLearning(options) {
       if (problem !== null) {
         throw new TypeError(`${PREFIX}: refused to write an invalid flag: ${problem}`);
       }
-      const held = await heldInstincts();
-      if (!held.some((instinct) => instinct.id === id)) {
+      if (!heldSet().files.some((file) => file.instinct.id === id)) {
         throw new Error(`${PREFIX}: no instinct ${describeValue(id)} is held under ${instinctsDir}`);
       }
       await appendLines(flagsPath, [JSON.stringify(flag)]);
@@ -1465,8 +2434,8 @@ function createGithubTracker(options) {
 }
 
 // src/adapters/tracker/local.ts
-import { mkdir as mkdir3, readdir, readFile as readFile3, writeFile } from "fs/promises";
-import { join as join4 } from "path";
+import { mkdir as mkdir3, readdir, readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
+import { join as join6 } from "path";
 var PREFIX3 = "local tracker";
 var FRONTMATTER = /^---\n([\s\S]*?)\n---\n([\s\S]*)$/;
 var ISSUE_NUMBER2 = /^[1-9]\d*$/;
@@ -1523,7 +2492,7 @@ function issueNumberOfFile(name) {
   return name.endsWith(ISSUE_EXTENSION) ? parseIssueNumber(name.slice(0, -ISSUE_EXTENSION.length)) : null;
 }
 function issuePath(issuesDir, number) {
-  return join4(issuesDir, `${number}${ISSUE_EXTENSION}`);
+  return join6(issuesDir, `${number}${ISSUE_EXTENSION}`);
 }
 async function issueNumbers(issuesDir) {
   let names;
@@ -1537,7 +2506,7 @@ async function issueNumbers(issuesDir) {
   return names.map(issueNumberOfFile).filter((number) => number !== null).sort((a, b) => a - b);
 }
 function localIssuesDir(repoRoot) {
-  return join4(repoRoot, ".rafa", "issues");
+  return join6(repoRoot, ".rafa", "issues");
 }
 function renderLocalIssue(record) {
   const { draft } = record;
@@ -1663,7 +2632,7 @@ function createLocalTracker(options) {
   }
   async function rewrite(number, record) {
     const contents = renderLocalIssue(record);
-    await writeFile(issuePath(issuesDir, number), contents, "utf8");
+    await writeFile2(issuePath(issuesDir, number), contents, "utf8");
   }
   const tracker = {
     kind: "local",
@@ -1685,7 +2654,7 @@ function createLocalTracker(options) {
       const held = await issueNumbers(issuesDir);
       for (let number = (held.at(-1) ?? 0) + 1;Number.isSafeInteger(number); number += 1) {
         try {
-          await writeFile(issuePath(issuesDir, number), contents, { encoding: "utf8", flag: "wx" });
+          await writeFile2(issuePath(issuesDir, number), contents, { encoding: "utf8", flag: "wx" });
           return refFor(number, draft.opt);
         } catch (error) {
           if (!hasCode2(error, "EEXIST"))
@@ -1827,7 +2796,15 @@ var CORE_ADAPTERS = [
     port: "learning",
     kind: "local",
     portVersion: PORT_VERSIONS.learning,
-    create: ({ repoRoot }) => createLocalLearning({ instinctsDir: localInstinctsDir(repoRoot) })
+    create: ({
+      repoRoot,
+      home = homedir(),
+      learningBlessMinConfidence = CONFIG_DEFAULTS.learningBlessMinConfidence
+    }) => createLocalLearning({
+      instinctsDir: localInstinctsDir(repoRoot),
+      home,
+      minConfidence: learningBlessMinConfidence
+    })
   },
   {
     port: "planner",
@@ -1866,4 +2843,4 @@ function selectEffortStore(repoRoot, config) {
   return adapter.create({ repoRoot });
 }
 
-export { EFFORT_STORE_DIR, effortStorePath, EFFORT_KEY_PROJECTIONS, openNdjsonStore, sqliteStorePath, LONE_SURROGATE, withSqliteStore, writeSqliteStore, openSqliteStore, sessionSpawnEnv, getClaudeUsagePercent, checkUsage, CLAUDE_BIN, claudeArgs, interruptClaudeSessions, runClaude, spawnClaudeCaptured, runClaudeCaptured, planFilePath, ClaudePlannerError, ISSUE_TYPES, ISSUE_PRIORITIES, ISSUE_STATES, GITHUB_LABELS, createGhRunner, typeOfLabels, moduleOfLabels, createLocalTracker, PORT_VERSIONS, createAdapterRegistry, CORE_ADAPTER_REGISTRY, selectEffortStore };
+export { EFFORT_STORE_DIR, effortStorePath, EFFORT_KEY_PROJECTIONS, openNdjsonStore, sqliteStorePath, SQLITE_MIGRATIONS, LONE_SURROGATE, migrateSchema, withSqliteStore, writeSqliteStore, openSqliteStore, SKILL_FILE, MARKDOWN_EXTENSION, scanLayout, declaredNameIssue, readFrontmatterDocument, readFrontmatter, renderFrontmatter, mergeFrontmatter, writeFrontmatter, normalizeRemote, gitRemoteUrl, ACTION_HEADING, CAUSE_HEADING, parseInstinct, writeInstinct, readScopes, allRecords, findRecords, instinctProject, toHeldRecords, sessionSpawnEnv, getClaudeUsagePercent, checkUsage, CLAUDE_BIN, claudeArgs, interruptClaudeSessions, runClaude, spawnClaudeCaptured, runClaudeCaptured, planFilePath, ClaudePlannerError, ISSUE_TYPES, ISSUE_PRIORITIES, ISSUE_STATES, GITHUB_LABELS, createGhRunner, typeOfLabels, moduleOfLabels, createLocalTracker, PORT_VERSIONS, createAdapterRegistry, CORE_ADAPTER_REGISTRY, selectEffortStore };