@open-tomato/rafa 0.17.0 → 0.19.0

package/dist/index-pqrpcfaz.js

@@ -0,0 +1,1020 @@
+// @bun
+import {
+  CLAUDE_SETTING_SOURCES,
+  CONFIG_VERSIONS,
+  INJECT_MODES,
+  MODULE_SOURCE_KEYS,
+  OPTIONAL_ITEM_KEYS,
+  OUTPUT_MODES,
+  PR_PROVIDERS,
+  RELEASE_AUTO,
+  REQUIRED_ITEM_KEYS,
+  SKILL_TIERS,
+  STORE_BACKENDS,
+  confidence,
+  dayCount,
+  describeValue,
+  flag,
+  githubLogin,
+  isMapping,
+  isSkillTier,
+  issueNumber,
+  listOf,
+  mergeMethod,
+  messageOf,
+  moduleSource,
+  oneOf,
+  optionalPrerequisite,
+  recurrenceCount,
+  releaseEnabled,
+  requiredPrerequisite,
+  routeTarget,
+  subsetOf,
+  text,
+  tierPin,
+  tierSwitch,
+  usdAmount
+} from "./index-cedghpva.js";
+
+// src/config-schema.ts
+import { join } from "path";
+
+// src/tiers/resolve.ts
+import { readFileSync } from "fs";
+var VENDORED_HEADER = /^<!-- vendored by rafa from .* on \d{4}-\d{2}-\d{2} -->$/;
+var CLAUDE_SKILL_ORDER = ["user", "project", "rafa"];
+var KIND_ORDER = ["skill", "agent"];
+var PLAIN_NAME = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+function loadedTiers(settings) {
+  return SKILL_TIERS.filter((tier) => tier === "project" || tier === "rafa" && settings.tiersRafa !== "off" || tier === "user" && settings.settingSources.includes("user"));
+}
+function pinKey(kind) {
+  return kind === "skill" ? "tiers.skills" : "tiers.agents";
+}
+function pinLine(kind, name, tier) {
+  const key = PLAIN_NAME.test(name) ? name : JSON.stringify(name);
+  return `${pinKey(kind)}: { ${key}: ${tier} }`;
+}
+function collisionMessage(collision) {
+  const places = collision.holders.map((holder) => `${holder.source} ${holder.path}`).join(" and ");
+  const held = `${collision.kind} ${collision.name} is held by ${collision.holders.length} loaded tiers ` + `with different contents: ${places}; `;
+  const tier = collision.setAsidePin;
+  if (tier === null)
+    return `${held}pin the tier that serves it: ${collision.pinLine}`;
+  const over = collision.outrankedBy;
+  const tiers = over.map((holder) => holder.source).join(" and ");
+  const copies = over.length === 1 ? "copy" : "copies";
+  const paths = over.map((holder) => holder.path).join(" and ");
+  return `${held}${pinLine(collision.kind, collision.name, tier)} has no effect, because Claude Code loads ` + `the ${tiers} ${copies} over the ${tier} copy: pin the copy it loads (${collision.pinLine}), ` + `or delete or rename ${paths} to let the ${tier} copy serve`;
+}
+function readItemBytes(path) {
+  try {
+    return readFileSync(path);
+  } catch {
+    return null;
+  }
+}
+function comparableText(bytes) {
+  return Buffer.from(bytes).toString("latin1").split(`
+`).filter((line) => !VENDORED_HEADER.test(line)).join(`
+`);
+}
+function tierIndex(row) {
+  return SKILL_TIERS.indexOf(row.source);
+}
+function groupByName(rows) {
+  const groups = new Map;
+  for (const row of rows) {
+    if (!isSkillTier(row.source))
+      continue;
+    const key = `${row.kind}\x00${row.name}`;
+    groups.set(key, [...groups.get(key) ?? [], row]);
+  }
+  return new Map([...groups].map(([key, group]) => [
+    key,
+    [...group].sort((a, b) => tierIndex(a) - tierIndex(b))
+  ]));
+}
+function loadedHolders(holders, tiers) {
+  return tiers.flatMap((tier) => {
+    const holder = holders.find((row) => row.source === tier);
+    return holder === undefined ? [] : [holder];
+  });
+}
+function sameItemGroups(holders, read) {
+  if (holders.length < 2)
+    return [holders];
+  const groups = [];
+  for (const row of holders) {
+    const bytes = read(row.path);
+    const text2 = bytes === null ? null : comparableText(bytes);
+    const group = text2 === null ? undefined : groups.find((candidate) => candidate.text === text2);
+    if (group === undefined)
+      groups.push({ text: text2, rows: [row] });
+    else
+      group.rows.push(row);
+  }
+  return groups.map((group) => group.rows);
+}
+function served(base, winner, decidedBy, groups) {
+  const same = groups.find((group) => group.includes(winner)) ?? [winner];
+  return {
+    ...base,
+    state: "served",
+    winner,
+    decidedBy,
+    copies: same.filter((row) => row !== winner),
+    overridden: base.loaded.filter((row) => !same.includes(row))
+  };
+}
+function claudeRank(row) {
+  return CLAUDE_SKILL_ORDER.indexOf(row.source);
+}
+function outrankingHolders(pinned, loaded, groups) {
+  if (pinned.kind !== "skill")
+    return [];
+  const same = groups.find((group) => group.includes(pinned)) ?? [pinned];
+  return loaded.filter((row) => claudeRank(row) < claudeRank(pinned) && !same.includes(row)).sort((a, b) => claudeRank(a) - claudeRank(b));
+}
+function workingPinTier(kind, loaded) {
+  const [first] = kind === "skill" ? [...loaded].sort((a, b) => claudeRank(a) - claudeRank(b)) : loaded;
+  return first !== undefined && isSkillTier(first.source) ? first.source : "project";
+}
+function resolveItem(holders, settings, tiers, read) {
+  const [first] = holders;
+  if (first === undefined)
+    throw new Error("resolveItem: a name with no holder");
+  const { kind, name } = first;
+  const pins = kind === "skill" ? settings.tiersSkills : settings.tiersAgents;
+  const base = {
+    kind,
+    name,
+    holders,
+    loaded: loadedHolders(holders, tiers),
+    pin: pins.get(name) ?? null
+  };
+  if (base.pin === false)
+    return { ...base, state: "off" };
+  const [nearest] = base.loaded;
+  if (nearest === undefined)
+    return { ...base, state: "unloaded" };
+  const groups = sameItemGroups(base.loaded, read);
+  const pinned = base.loaded.find((row) => row.source === base.pin);
+  const outrankedBy = pinned === undefined ? [] : outrankingHolders(pinned, base.loaded, groups);
+  if (pinned !== undefined && outrankedBy.length === 0)
+    return served(base, pinned, "pin", groups);
+  if (groups.length === 1)
+    return served(base, nearest, "order", groups);
+  const distinct = groups.flatMap((group) => group.slice(0, 1));
+  const setAsidePin = pinned !== undefined && isSkillTier(pinned.source) ? pinned.source : null;
+  return {
+    ...base,
+    state: "collision",
+    collision: {
+      kind,
+      name,
+      holders: distinct,
+      pinLine: pinLine(kind, name, workingPinTier(kind, base.loaded)),
+      setAsidePin,
+      outrankedBy
+    }
+  };
+}
+function resolveTiers(rows, settings, read) {
+  const tiers = loadedTiers(settings);
+  const items = [...groupByName(rows).values()].map((holders) => resolveItem(holders, settings, tiers, read)).sort((a, b) => KIND_ORDER.indexOf(a.kind) - KIND_ORDER.indexOf(b.kind) || a.name.localeCompare(b.name));
+  return {
+    loadedTiers: tiers,
+    items,
+    collisions: items.flatMap((item) => item.state === "collision" ? [item.collision] : [])
+  };
+}
+function findTierItem(resolution, kind, name) {
+  return resolution.items.find((item) => item.kind === kind && item.name === name);
+}
+
+// src/tiers/routing.ts
+var DEFAULT_ROUTES = Object.freeze([
+  Object.freeze(["prose", "doc-updater"]),
+  Object.freeze(["tests", "tdd-guide"]),
+  Object.freeze(["repair", "build-error-resolver"]),
+  Object.freeze(["review", "code-reviewer"]),
+  Object.freeze(["implementation", "loop-implementer"])
+]);
+var DEFAULT_ROUTING = new Map(DEFAULT_ROUTES);
+
+// src/config-schema.ts
+var CONFIG_FILE = join(".rafa", "config.yaml");
+function mapOf(value, expected) {
+  return (raw, at) => {
+    if (!isMapping(raw)) {
+      const problem = `${at.label} is ${describeValue(raw)}, expected a mapping of names to ${expected}`;
+      return { value: undefined, problems: [problem], extras: [] };
+    }
+    const readings = Object.entries(raw).map(([name, entry]) => [
+      name,
+      name.trim() === "" ? {
+        value: undefined,
+        problems: [`${at.label} names ${JSON.stringify(name)}, expected a non-empty name`],
+        extras: []
+      } : value(entry, { label: `${at.label}.${name}`, key: `${at.key}.${name}` })
+    ]);
+    const problems = readings.flatMap(([, reading]) => reading.problems);
+    const extras = readings.flatMap(([, reading]) => reading.extras);
+    if (problems.length > 0)
+      return { value: undefined, problems, extras };
+    const read = new Map;
+    for (const [name, reading] of readings) {
+      if (reading.value !== undefined)
+        read.set(name, reading.value);
+    }
+    return { value: read, problems, extras };
+  };
+}
+var CONFIG_DEFAULTS = Object.freeze({
+  version: 1,
+  store: "sqlite",
+  inject: "stage",
+  planDir: join(".rafa", "plans"),
+  specsDir: join(".rafa", "specs"),
+  trackerDefault: "github",
+  trackerFallback: Object.freeze(["local"]),
+  learningAdapter: "local",
+  learningBlessMinConfidence: 0.5,
+  learningPromoteAfter: 3,
+  learningPromoteMinConfidence: 0.7,
+  outputMode: "text",
+  prerequisitesRequired: Object.freeze([]),
+  prerequisitesOptional: Object.freeze([]),
+  trackingSpecs: false,
+  trackingPlans: false,
+  trackingAll: false,
+  modules: Object.freeze([]),
+  allowList: Object.freeze([]),
+  settingSources: Object.freeze(["project", "local"]),
+  prProvider: null,
+  prMergeMethod: "squash",
+  prBase: null,
+  prResolveBudget: 2,
+  boardTrustedAuthors: Object.freeze([]),
+  roadmapIssue: null,
+  releaseEnabled: RELEASE_AUTO,
+  releaseVersionFile: "package.json",
+  releaseChangelog: "CHANGELOG.md",
+  releaseHeading: "## {version} \u2014 {date}, {title}",
+  cleanupStaleDays: 30,
+  cleanupWorktreeIdleDays: 7,
+  cleanupKeep: Object.freeze([]),
+  dangerousAcceptStaleRefs: false,
+  statusNotice: true,
+  tiersRafa: "on",
+  tiersSkills: new Map,
+  tiersAgents: new Map,
+  routing: DEFAULT_ROUTING
+});
+var directory = text("a directory path");
+var trackerKind = text("a tracker kind name");
+var releaseFile = text("a file path");
+var tierPins = mapOf(tierPin, "false or a tier");
+var SETTINGS = {
+  version: { key: "version", read: oneOf(CONFIG_VERSIONS), cli: false },
+  store: { key: "store", read: oneOf(STORE_BACKENDS), cli: true },
+  inject: { key: "plan.inject", read: oneOf(INJECT_MODES), cli: true },
+  planDir: { key: "plan.dir", read: directory, cli: true },
+  specsDir: { key: "specs.dir", read: directory, cli: true },
+  trackerDefault: { key: "tracker.default", read: trackerKind, cli: true },
+  trackerFallback: {
+    key: "tracker.fallback",
+    read: listOf(trackerKind, "tracker kind names"),
+    cli: false
+  },
+  learningAdapter: {
+    key: "learning.adapter",
+    read: text("a learning adapter name"),
+    cli: true
+  },
+  learningBlessMinConfidence: { key: "learning.bless.minConfidence", read: confidence, cli: false },
+  learningPromoteAfter: { key: "learning.promote.after", read: recurrenceCount, cli: false },
+  learningPromoteMinConfidence: { key: "learning.promote.minConfidence", read: confidence, cli: false },
+  outputMode: { key: "output.mode", read: oneOf(OUTPUT_MODES), cli: true },
+  prerequisitesRequired: {
+    key: "prerequisites.required",
+    read: listOf(requiredPrerequisite, "prerequisite items"),
+    cli: false,
+    itemKeys: REQUIRED_ITEM_KEYS
+  },
+  prerequisitesOptional: {
+    key: "prerequisites.optional",
+    read: listOf(optionalPrerequisite, "prerequisite items"),
+    cli: false,
+    itemKeys: OPTIONAL_ITEM_KEYS
+  },
+  trackingSpecs: { key: "tracking.specs", read: flag, cli: false },
+  trackingPlans: { key: "tracking.plans", read: flag, cli: false },
+  trackingAll: { key: "tracking.all", read: flag, cli: false },
+  modules: {
+    key: "modules",
+    read: listOf(moduleSource, "module sources"),
+    cli: false,
+    itemKeys: MODULE_SOURCE_KEYS
+  },
+  allowList: {
+    key: "allowList",
+    read: listOf(text("a module name"), "module names"),
+    cli: false
+  },
+  settingSources: {
+    key: "loop.settingSources",
+    read: subsetOf(CLAUDE_SETTING_SOURCES),
+    cli: true
+  },
+  prProvider: { key: "pr.provider", read: oneOf(PR_PROVIDERS), cli: false },
+  prMergeMethod: { key: "pr.mergeMethod", read: mergeMethod, cli: false },
+  prBase: { key: "pr.base", read: text("a branch name"), cli: false },
+  prResolveBudget: { key: "pr.resolveBudget", read: usdAmount, cli: false },
+  boardTrustedAuthors: {
+    key: "board.trustedAuthors",
+    read: listOf(githubLogin, "GitHub logins"),
+    cli: false
+  },
+  roadmapIssue: { key: "roadmap.issue", read: issueNumber, cli: false },
+  releaseEnabled: { key: "release.enabled", read: releaseEnabled, cli: false },
+  releaseVersionFile: {
+    key: "release.versionFile",
+    read: releaseFile,
+    cli: false
+  },
+  releaseChangelog: { key: "release.changelog", read: releaseFile, cli: false },
+  releaseHeading: {
+    key: "release.heading",
+    read: text("a changelog heading template"),
+    cli: false
+  },
+  cleanupStaleDays: { key: "cleanup.staleDays", read: dayCount, cli: false },
+  cleanupWorktreeIdleDays: {
+    key: "cleanup.worktreeIdleDays",
+    read: dayCount,
+    cli: false
+  },
+  cleanupKeep: {
+    key: "cleanup.keep",
+    read: listOf(text("a glob pattern"), "glob patterns"),
+    cli: false
+  },
+  dangerousAcceptStaleRefs: {
+    key: "dangerous.acceptStaleRefs",
+    read: flag,
+    cli: false
+  },
+  statusNotice: { key: "status.notice", read: flag, cli: false },
+  tiersRafa: { key: "tiers.rafa", read: tierSwitch, cli: false },
+  tiersSkills: { key: "tiers.skills", read: tierPins, cli: false },
+  tiersAgents: { key: "tiers.agents", read: tierPins, cli: false },
+  routing: {
+    key: "routing",
+    read: mapOf(routeTarget, "false or an agent name"),
+    cli: false
+  }
+};
+var SETTING_NAMES = Object.keys(SETTINGS);
+var SETTING_BY_KEY = new Map(SETTING_NAMES.map((setting) => [
+  SETTINGS[setting].key,
+  setting
+]));
+function isCommandLineSetting(setting) {
+  return SETTINGS[setting].cli;
+}
+function sectionsOf(key) {
+  const parts = key.split(".");
+  return parts.slice(1).map((_, index) => parts.slice(0, index + 1).join("."));
+}
+var SECTIONS = new Set([...SETTING_BY_KEY.keys()].flatMap(sectionsOf));
+function parentOf(key) {
+  const cut = key.lastIndexOf(".");
+  return cut < 0 ? "" : key.slice(0, cut);
+}
+var TRAILING_INDEX = /\[\d+\]$/;
+var KNOWN_UNDER = (() => {
+  const known = new Map;
+  const add = (parent, name) => {
+    const names = known.get(parent) ?? [];
+    if (!names.includes(name))
+      known.set(parent, [...names, name]);
+  };
+  for (const setting of SETTING_NAMES) {
+    const { key, itemKeys } = SETTINGS[setting];
+    const parts = key.split(".");
+    parts.forEach((part, index) => add(parts.slice(0, index).join("."), part));
+    for (const name of itemKeys ?? [])
+      add(`${key}[]`, name);
+  }
+  return known;
+})();
+function knownKeysAbove(key) {
+  for (let parent = parentOf(key);parent !== ""; parent = parentOf(parent)) {
+    const names = KNOWN_UNDER.get(parent.replace(TRAILING_INDEX, "[]"));
+    if (names !== undefined)
+      return [parent, names];
+  }
+  return ["", KNOWN_UNDER.get("") ?? []];
+}
+
+// src/config.ts
+import { join as join2 } from "path";
+class ConfigError extends Error {
+  problems;
+  constructor(problems, options) {
+    super(`rafa config: ${problems.join("; ")}`, options);
+    this.name = "ConfigError";
+    this.problems = problems;
+  }
+}
+function readLayer(rawOf, atOf) {
+  const problems = [];
+  const extras = [];
+  const read = (setting) => {
+    const raw = rawOf(setting);
+    if (raw === undefined)
+      return;
+    const reading = SETTINGS[setting].read(raw, atOf(setting));
+    problems.push(...reading.problems);
+    extras.push(...reading.extras);
+    return reading.value;
+  };
+  const layer = {
+    version: read("version"),
+    store: read("store"),
+    inject: read("inject"),
+    planDir: read("planDir"),
+    specsDir: read("specsDir"),
+    trackerDefault: read("trackerDefault"),
+    trackerFallback: read("trackerFallback"),
+    learningAdapter: read("learningAdapter"),
+    learningBlessMinConfidence: read("learningBlessMinConfidence"),
+    learningPromoteAfter: read("learningPromoteAfter"),
+    learningPromoteMinConfidence: read("learningPromoteMinConfidence"),
+    outputMode: read("outputMode"),
+    prerequisitesRequired: read("prerequisitesRequired"),
+    prerequisitesOptional: read("prerequisitesOptional"),
+    trackingSpecs: read("trackingSpecs"),
+    trackingPlans: read("trackingPlans"),
+    trackingAll: read("trackingAll"),
+    modules: read("modules"),
+    allowList: read("allowList"),
+    settingSources: read("settingSources"),
+    prProvider: read("prProvider"),
+    prMergeMethod: read("prMergeMethod"),
+    prBase: read("prBase"),
+    prResolveBudget: read("prResolveBudget"),
+    boardTrustedAuthors: read("boardTrustedAuthors"),
+    roadmapIssue: read("roadmapIssue"),
+    releaseEnabled: read("releaseEnabled"),
+    releaseVersionFile: read("releaseVersionFile"),
+    releaseChangelog: read("releaseChangelog"),
+    releaseHeading: read("releaseHeading"),
+    cleanupStaleDays: read("cleanupStaleDays"),
+    cleanupWorktreeIdleDays: read("cleanupWorktreeIdleDays"),
+    cleanupKeep: read("cleanupKeep"),
+    dangerousAcceptStaleRefs: read("dangerousAcceptStaleRefs"),
+    statusNotice: read("statusNotice"),
+    tiersRafa: read("tiersRafa"),
+    tiersSkills: read("tiersSkills"),
+    tiersAgents: read("tiersAgents"),
+    routing: read("routing")
+  };
+  return { layer, problems, extras };
+}
+function* entriesOf(mapping, prefix) {
+  for (const [name, value] of Object.entries(mapping)) {
+    const key = prefix === "" ? name : `${prefix}.${name}`;
+    if (SECTIONS.has(key) && isMapping(value))
+      yield* entriesOf(value, key);
+    else
+      yield { key, value };
+  }
+}
+function sortKeys(document, path) {
+  const named = new Map;
+  const seen = new Set;
+  const extras = [];
+  const problems = [];
+  for (const entry of entriesOf(document, "")) {
+    const setting = SETTING_BY_KEY.get(entry.key);
+    if (setting !== undefined) {
+      if (seen.has(setting)) {
+        problems.push(`${path}: ${entry.key} is given more than once`);
+      } else if (entry.value !== null) {
+        named.set(setting, entry.value);
+      }
+      seen.add(setting);
+      continue;
+    }
+    if (!SECTIONS.has(entry.key)) {
+      extras.push(entry);
+      continue;
+    }
+    if (entry.value !== null) {
+      const found = describeValue(entry.value);
+      problems.push(`${path}: ${entry.key} must be a mapping, found ${found}`);
+    }
+  }
+  return { named, extras, problems };
+}
+function parseYaml(text2, path) {
+  try {
+    return Bun.YAML.parse(text2);
+  } catch (error) {
+    const problem = `${path}: not valid YAML (${messageOf(error)})`;
+    throw new ConfigError([problem], { cause: error });
+  }
+}
+function configFilePath(root) {
+  return join2(root, CONFIG_FILE);
+}
+function parseConfigText(text2, path) {
+  const document = parseYaml(text2, path) ?? {};
+  if (!isMapping(document)) {
+    const found = describeValue(document);
+    throw new ConfigError([
+      `${path}: expected a mapping at the top level, found ${found}`
+    ]);
+  }
+  const sorted = sortKeys(document, path);
+  const read = readLayer((setting) => sorted.named.get(setting), (setting) => ({
+    label: `${path}: ${SETTINGS[setting].key}`,
+    key: SETTINGS[setting].key
+  }));
+  const all = [...sorted.problems, ...read.problems];
+  if (all.length > 0)
+    throw new ConfigError(all);
+  return { path, values: read.layer, extras: [...sorted.extras, ...read.extras] };
+}
+var MAP_SETTINGS = new Set([
+  "tiersSkills",
+  "tiersAgents",
+  "routing"
+]);
+function mergeMaps(...layers) {
+  const merged = new Map;
+  for (const layer of layers) {
+    if (!(layer instanceof Map))
+      continue;
+    for (const [name, value] of layer)
+      merged.set(name, value);
+  }
+  return merged;
+}
+function unloadedPinWarnings(layer) {
+  const pins = [
+    ["tiers.skills", layer.values.tiersSkills],
+    ["tiers.agents", layer.values.tiersAgents]
+  ];
+  return pins.flatMap(([key, map]) => [...map ?? []].filter(([, pin]) => pin === "rafa").map(([name]) => `rafa config: ${key}.${name} in ${layer.path} pins the rafa tier, ` + "which is not loaded (tiers.rafa is off), so the pin has no effect"));
+}
+function unknownKeyWarning(key, path) {
+  const quoted = JSON.stringify(key);
+  const [under, names] = knownKeysAbove(key);
+  const where = under === "" ? "" : ` under ${under}`;
+  return `rafa config: unknown key ${quoted} in ${path} has no effect ` + `in this version (known keys${where}: ${names.join(", ")})`;
+}
+function resolveConfig(layers = {}) {
+  const file = layers.file ?? null;
+  const user = layers.user ?? null;
+  const overrides = layers.cli ?? {};
+  const { layer: cli, problems } = readLayer((setting) => isCommandLineSetting(setting) ? overrides[setting] : undefined, (setting) => ({ label: `command line: ${setting}`, key: setting }));
+  if (problems.length > 0)
+    throw new ConfigError(problems);
+  const rank = (setting) => {
+    const fromCli = cli[setting];
+    if (fromCli !== undefined)
+      return { value: fromCli, source: "cli" };
+    const fromFile = file?.values[setting];
+    const fromUser = user?.values[setting];
+    if (MAP_SETTINGS.has(setting)) {
+      const merged = mergeMaps(CONFIG_DEFAULTS[setting], fromUser, fromFile);
+      const source = fromFile !== undefined ? "file" : fromUser !== undefined ? "user" : "default";
+      return { value: merged, source };
+    }
+    if (fromFile !== undefined)
+      return { value: fromFile, source: "file" };
+    if (fromUser !== undefined)
+      return { value: fromUser, source: "user" };
+    return { value: CONFIG_DEFAULTS[setting], source: "default" };
+  };
+  const ranked = SETTING_NAMES.map((setting) => [setting, rank(setting)]);
+  const rafaLoaded = ranked.find(([setting]) => setting === "tiersRafa")?.[1].value !== "off";
+  const warnings = [user, file].flatMap((layer) => layer === null ? [] : [
+    ...layer.extras.map((extra) => unknownKeyWarning(extra.key, layer.path)),
+    ...rafaLoaded ? [] : unloadedPinWarnings(layer)
+  ]);
+  return {
+    config: Object.fromEntries(ranked.map(([setting, { value }]) => [setting, value])),
+    sources: Object.fromEntries(ranked.map(([setting, { source }]) => [setting, source])),
+    path: file?.path ?? null,
+    userPath: user?.path ?? null,
+    extras: file?.extras ?? [],
+    userExtras: user?.extras ?? [],
+    warnings
+  };
+}
+
+// src/plan/blocks.ts
+var RAFA_BLOCK_KINDS = [
+  "plan",
+  "context",
+  "stage-context",
+  "report"
+];
+var RAFA_PREFIX = "rafa:";
+var FENCE_RUN = /^( {0,3})(`{3,}|~{3,})/;
+var CLOSING_FENCE = /^ {0,3}(`{3,}|~{3,})[ \t]*$/;
+function isRafaBlockKind(kind) {
+  return RAFA_BLOCK_KINDS.includes(kind);
+}
+function linesOf(markdown) {
+  const lines = markdown.split(`
+`);
+  if (lines[lines.length - 1] === "")
+    lines.pop();
+  return lines.map((line) => line.endsWith("\r") ? line.slice(0, -1) : line);
+}
+function kindOf(info) {
+  const word = info.trim().split(/\s+/)[0] ?? "";
+  return word.startsWith(RAFA_PREFIX) ? word.slice(RAFA_PREFIX.length) : null;
+}
+function openingFence(line) {
+  const match = FENCE_RUN.exec(line);
+  const opener = match?.[0];
+  const indent = match?.[1];
+  const run = match?.[2];
+  if (opener === undefined || indent === undefined || run === undefined) {
+    return null;
+  }
+  const marker = run.charAt(0);
+  const info = line.slice(opener.length);
+  if (marker === "`" && info.includes("`"))
+    return null;
+  return { marker, length: run.length, indent: indent.length, kind: kindOf(info) };
+}
+function closes(line, fence) {
+  const run = CLOSING_FENCE.exec(line)?.[1];
+  return run !== undefined && run.charAt(0) === fence.marker && run.length >= fence.length;
+}
+function closingIndex(lines, from, fence) {
+  for (let index = from;index < lines.length; index += 1) {
+    if (closes(lines[index] ?? "", fence))
+      return index;
+  }
+  return lines.length;
+}
+function dedent(line, indent) {
+  let cut = 0;
+  while (cut < indent && line.charAt(cut) === " ")
+    cut += 1;
+  return line.slice(cut);
+}
+function readRafaBlocks(markdown) {
+  const lines = linesOf(markdown);
+  const blocks = [];
+  let index = 0;
+  while (index < lines.length) {
+    const fence = openingFence(lines[index] ?? "");
+    if (fence === null) {
+      index += 1;
+      continue;
+    }
+    const closing = closingIndex(lines, index + 1, fence);
+    const closed = closing < lines.length;
+    if (fence.kind !== null) {
+      const body = lines.slice(index + 1, closing).map((line) => dedent(line, fence.indent)).join(`
+`);
+      const last = closed ? closing + 1 : lines.length;
+      blocks.push({ kind: fence.kind, body, span: { first: index + 1, last }, closed });
+    }
+    index = closing + 1;
+  }
+  return blocks;
+}
+
+// src/report/parse.ts
+var REPORT_STATUSES = ["done", "blocked"];
+var FINDING_KINDS = ["gotcha", "pattern", "location", "skill-suggestion"];
+var FINDING_SIGNALS = ["loud", "silent"];
+var FINDING_DOMAINS = [
+  "code-style",
+  "testing",
+  "git",
+  "debugging",
+  "workflow",
+  "security",
+  "general-best-practices"
+];
+var CHANGE_LEVELS = ["patch", "minor", "major", "none"];
+var REPORT_KIND = "report";
+var REQUIRED = true;
+var OPTIONAL = false;
+var REPORT_KEYS = [
+  "status",
+  "feedback",
+  "findings",
+  "skills_used",
+  "blockers",
+  "out_of_scope_bugs",
+  "changes"
+];
+var FINDING_KEYS = [
+  "trigger",
+  "kind",
+  "what",
+  "cause",
+  "resolution",
+  "artifact",
+  "signal",
+  "domain"
+];
+var BLOCKER_KEYS = ["what", "artifact"];
+var BUG_KEYS = ["what", "artifact", "security"];
+var CHANGE_KEYS = ["level", "area", "summary"];
+function isMapping2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isOneOf(choices, value) {
+  return choices.includes(value);
+}
+function describeValue2(value) {
+  if (typeof value === "string")
+    return JSON.stringify(value);
+  if (value === null)
+    return "nothing";
+  if (Array.isArray(value))
+    return "a list";
+  if (typeof value === "object")
+    return "a mapping";
+  return `the ${typeof value} ${String(value)}`;
+}
+function messageOf2(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function reportIssue(reason, field, text2) {
+  return { reason, field, text: text2 };
+}
+function absent(reason, block, text2) {
+  return { present: false, reason, block, text: text2 };
+}
+function scopeOf(mapping, keys, prefix, issues) {
+  const fields = new Map;
+  const extras = [];
+  for (const [key, value] of Object.entries(mapping)) {
+    if (keys.includes(key))
+      fields.set(key, value);
+    else
+      extras.push({ key, value });
+  }
+  return { fields, extras, prefix, issues };
+}
+function valueOf(scope, key, required) {
+  const value = scope.fields.get(key) ?? null;
+  if (value === null && required) {
+    const field = `${scope.prefix}${key}`;
+    scope.issues.push(reportIssue("missing-field", field, `${field} is missing`));
+  }
+  return value;
+}
+function unusable(scope, key, why) {
+  const field = `${scope.prefix}${key}`;
+  scope.issues.push(reportIssue("unusable-field", field, `${field} ${why}`));
+  return null;
+}
+function stringProblem(value) {
+  if (typeof value !== "string")
+    return `is ${describeValue2(value)}, not a string; quote it`;
+  if (value.trim().length === 0)
+    return "is blank";
+  return null;
+}
+function stringField(scope, key, required) {
+  const value = valueOf(scope, key, required);
+  if (value === null)
+    return null;
+  const problem = stringProblem(value);
+  return problem === null ? value : unusable(scope, key, problem);
+}
+function choiceField(scope, key, choices, required) {
+  const value = valueOf(scope, key, required);
+  if (value === null || isOneOf(choices, value))
+    return value;
+  return unusable(scope, key, `is ${describeValue2(value)}, not one of ${choices.join(", ")}`);
+}
+function booleanField(scope, key, required) {
+  const value = valueOf(scope, key, required);
+  if (value === null || typeof value === "boolean")
+    return value;
+  return unusable(scope, key, `is ${describeValue2(value)}, not true or false; write it unquoted`);
+}
+function listField(scope, key, readEntry) {
+  const value = valueOf(scope, key, OPTIONAL);
+  if (value === null)
+    return [];
+  if (!Array.isArray(value)) {
+    unusable(scope, key, `is ${describeValue2(value)}, not a list`);
+    return [];
+  }
+  const entries = [];
+  const items = value;
+  for (const [index, item] of items.entries()) {
+    const entry = readEntry(item, `${scope.prefix}${key}[${index}]`, scope.issues);
+    if (entry !== null)
+      entries.push(entry);
+  }
+  return entries;
+}
+function entryScope(item, field, keys, issues) {
+  if (isMapping2(item))
+    return scopeOf(item, keys, `${field}.`, issues);
+  const text2 = `${field} is ${describeValue2(item)}, not a mapping of ${keys.join(", ")}; dropped`;
+  issues.push(reportIssue("unusable-field", field, text2));
+  return null;
+}
+function readSkill(item, field, issues) {
+  const problem = stringProblem(item);
+  if (problem === null)
+    return item;
+  issues.push(reportIssue("unusable-field", field, `${field} ${problem}; dropped`));
+  return null;
+}
+function readFinding(item, field, issues) {
+  const scope = entryScope(item, field, FINDING_KEYS, issues);
+  if (scope === null)
+    return null;
+  return {
+    trigger: stringField(scope, "trigger", REQUIRED),
+    kind: choiceField(scope, "kind", FINDING_KINDS, REQUIRED),
+    what: stringField(scope, "what", REQUIRED),
+    cause: stringField(scope, "cause", OPTIONAL),
+    resolution: stringField(scope, "resolution", OPTIONAL),
+    artifact: stringField(scope, "artifact", OPTIONAL),
+    signal: choiceField(scope, "signal", FINDING_SIGNALS, REQUIRED),
+    domain: choiceField(scope, "domain", FINDING_DOMAINS, OPTIONAL),
+    extras: scope.extras
+  };
+}
+function readBlocker(item, field, issues) {
+  const scope = entryScope(item, field, BLOCKER_KEYS, issues);
+  if (scope === null)
+    return null;
+  return {
+    what: stringField(scope, "what", REQUIRED),
+    artifact: stringField(scope, "artifact", OPTIONAL),
+    extras: scope.extras
+  };
+}
+function readBug(item, field, issues) {
+  const scope = entryScope(item, field, BUG_KEYS, issues);
+  if (scope === null)
+    return null;
+  return {
+    what: stringField(scope, "what", REQUIRED),
+    artifact: stringField(scope, "artifact", OPTIONAL),
+    security: booleanField(scope, "security", REQUIRED),
+    extras: scope.extras
+  };
+}
+function readChange(item, field, issues) {
+  const scope = entryScope(item, field, CHANGE_KEYS, issues);
+  if (scope === null)
+    return null;
+  return {
+    level: choiceField(scope, "level", CHANGE_LEVELS, REQUIRED),
+    area: stringField(scope, "area", OPTIONAL),
+    summary: stringField(scope, "summary", REQUIRED),
+    extras: scope.extras
+  };
+}
+function readReport(document, issues) {
+  const scope = scopeOf(document, REPORT_KEYS, "", issues);
+  return {
+    status: choiceField(scope, "status", REPORT_STATUSES, REQUIRED),
+    feedback: stringField(scope, "feedback", OPTIONAL),
+    findings: listField(scope, "findings", readFinding),
+    skillsUsed: listField(scope, "skills_used", readSkill),
+    blockers: listField(scope, "blockers", readBlocker),
+    outOfScopeBugs: listField(scope, "out_of_scope_bugs", readBug),
+    changes: listField(scope, "changes", readChange),
+    extras: scope.extras
+  };
+}
+function parseReport(output) {
+  const reports = readRafaBlocks(output).filter((block2) => block2.kind === REPORT_KIND);
+  const block = reports.at(-1);
+  if (block === undefined) {
+    return absent("no-block", null, "the session output holds no rafa:report block");
+  }
+  const line = block.span.first;
+  if (!block.closed) {
+    return absent("unclosed-block", block, `rafa:report block at line ${line} is never closed, so its body may have been cut short ` + "and is not read");
+  }
+  let document;
+  try {
+    document = Bun.YAML.parse(block.body);
+  } catch (error) {
+    const text2 = `rafa:report block at line ${line} is not valid YAML (${messageOf2(error)})`;
+    return absent("malformed-block", block, text2);
+  }
+  if (!isMapping2(document)) {
+    const text2 = `rafa:report block at line ${line} holds ${describeValue2(document)}, ` + "not a mapping of report fields";
+    return absent("malformed-block", block, text2);
+  }
+  const issues = [];
+  const report = readReport(document, issues);
+  return { present: true, report, block, issues };
+}
+
+// src/adapters/output/text.ts
+var DEBUG_VERBOSITY = 2;
+function formatPayload(payload) {
+  return typeof payload === "string" ? payload : JSON.stringify(payload);
+}
+function resultLine(event) {
+  if (event.ok) {
+    return event.data === undefined ? "result: ok" : `result: ok ${formatPayload(event.data)}`;
+  }
+  const code = event.error?.code ?? "unknown";
+  const message = event.error?.message ?? "";
+  return message === "" ? `result: error ${code}` : `result: error ${code}: ${message}`;
+}
+function createTextOutput({ verbosity, stream }) {
+  const writeLine = (line) => {
+    stream.write(`${line}
+`);
+  };
+  const debug = (message) => {
+    if (verbosity >= DEBUG_VERBOSITY)
+      writeLine(`debug: ${message}`);
+  };
+  const info = (message) => {
+    writeLine(message);
+  };
+  const warn = (message) => {
+    writeLine(`warn: ${message}`);
+  };
+  const error = (message) => {
+    writeLine(`error: ${message}`);
+  };
+  const result = (payload) => {
+    writeLine(`result: ${formatPayload(payload)}`);
+  };
+  const writeLog = (event) => {
+    switch (event.level) {
+      case "debug": {
+        debug(event.message);
+        return;
+      }
+      case "info": {
+        info(event.message);
+        return;
+      }
+      case "warn": {
+        warn(event.message);
+        return;
+      }
+      case "error": {
+        error(event.message);
+        return;
+      }
+    }
+  };
+  const emit = (event) => {
+    switch (event.type) {
+      case "start": {
+        writeLine(`start: ${event.command}`);
+        return;
+      }
+      case "step": {
+        writeLine(`step: ${event.name}`);
+        return;
+      }
+      case "log": {
+        writeLog(event);
+        return;
+      }
+      case "result": {
+        writeLine(resultLine(event));
+        return;
+      }
+    }
+  };
+  return Object.freeze({ info, warn, error, debug, emit, result });
+}
+
+// src/adapters/output/active.ts
+var DEFAULT_OUTPUT = createTextOutput({ verbosity: 0, stream: process.stdout });
+var active = DEFAULT_OUTPUT;
+var activeMode = "text";
+function activeOutput() {
+  return active;
+}
+function activeOutputMode() {
+  return activeMode;
+}
+
+export { pinKey, pinLine, collisionMessage, readItemBytes, resolveTiers, findTierItem, DEFAULT_ROUTES, DEFAULT_ROUTING, CONFIG_FILE, CONFIG_DEFAULTS, SETTINGS, ConfigError, configFilePath, parseConfigText, resolveConfig, RAFA_BLOCK_KINDS, isRafaBlockKind, readRafaBlocks, REPORT_STATUSES, FINDING_KINDS, FINDING_SIGNALS, FINDING_DOMAINS, CHANGE_LEVELS, parseReport, createTextOutput, activeOutput, activeOutputMode };