@open-tomato/rafa 0.16.0 → 0.18.0

package/dist/{index-p901zs2p.js → index-ddf85qac.js}

@@ -1,7 +1,7 @@
 // @bun
 import {
   describeValue
-} from "./index-n3rw8rhr.js";
+} from "./index-944pncd8.js";
 
 // src/cli/spends.ts
 var SPENDS_GLYPH = "\uD83E\uDE99";

package/dist/{index-6cw1n0qy.js → index-jva32qe6.js}

@@ -9,12 +9,14 @@ import {
   PR_PROVIDERS,
   RELEASE_AUTO,
   REQUIRED_ITEM_KEYS,
+  SKILL_TIERS,
   STORE_BACKENDS,
   dayCount,
   describeValue,
   flag,
   githubLogin,
   isMapping,
+  isSkillTier,
   issueNumber,
   listOf,
   mergeMethod,
@@ -24,14 +26,209 @@ import {
   optionalPrerequisite,
   releaseEnabled,
   requiredPrerequisite,
+  routeTarget,
   subsetOf,
   text,
+  tierPin,
+  tierSwitch,
   usdAmount
-} from "./index-n3rw8rhr.js";
+} from "./index-944pncd8.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",
@@ -63,11 +260,17 @@ var CONFIG_DEFAULTS = Object.freeze({
   cleanupStaleDays: 30,
   cleanupWorktreeIdleDays: 7,
   cleanupKeep: Object.freeze([]),
-  dangerousAcceptStaleRefs: false
+  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 },
@@ -154,6 +357,15 @@ var SETTINGS = {
     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);
@@ -252,7 +464,12 @@ function readLayer(rawOf, atOf) {
     cleanupStaleDays: read("cleanupStaleDays"),
     cleanupWorktreeIdleDays: read("cleanupWorktreeIdleDays"),
     cleanupKeep: read("cleanupKeep"),
-    dangerousAcceptStaleRefs: read("dangerousAcceptStaleRefs")
+    dangerousAcceptStaleRefs: read("dangerousAcceptStaleRefs"),
+    statusNotice: read("statusNotice"),
+    tiersRafa: read("tiersRafa"),
+    tiersSkills: read("tiersSkills"),
+    tiersAgents: read("tiersAgents"),
+    routing: read("routing")
   };
   return { layer, problems, extras };
 }
@@ -321,6 +538,28 @@ function parseConfigText(text2, path) {
     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);
@@ -339,15 +578,24 @@ function resolveConfig(layers = {}) {
     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" };
-    const fromUser = user?.values[setting];
     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 warnings = [user, file].flatMap((layer) => layer === null ? [] : layer.extras.map((extra) => unknownKeyWarning(extra.key, layer.path)));
+  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])),
@@ -525,4 +773,4 @@ function activeOutputMode() {
   return activeMode;
 }
 
-export { CONFIG_FILE, CONFIG_DEFAULTS, SETTINGS, ConfigError, configFilePath, parseConfigText, resolveConfig, createTextOutput, activeOutput, activeOutputMode, RAFA_BLOCK_KINDS, isRafaBlockKind, readRafaBlocks };
+export { pinKey, pinLine, collisionMessage, readItemBytes, resolveTiers, findTierItem, DEFAULT_ROUTES, DEFAULT_ROUTING, CONFIG_FILE, CONFIG_DEFAULTS, SETTINGS, ConfigError, configFilePath, parseConfigText, resolveConfig, createTextOutput, activeOutput, activeOutputMode, RAFA_BLOCK_KINDS, isRafaBlockKind, readRafaBlocks };

package/dist/{index-qzhpqmfy.js → index-kvnggvyk.js}

@@ -4,10 +4,10 @@ import {
   commandSpelling,
   isRoutingWord,
   isTopLevel
-} from "./index-p901zs2p.js";
+} from "./index-ddf85qac.js";
 import {
   describeValue
-} from "./index-n3rw8rhr.js";
+} from "./index-944pncd8.js";
 
 // src/cli/registry.ts
 var REFUSAL = "command registry";

package/dist/index.js

@@ -20,7 +20,7 @@ import {
   start,
   usage,
   validateManifest
-} from "./index-1vtd5fr7.js";
+} from "./index-6vkd153j.js";
 import {
   FINDING_KINDS,
   FINDING_SIGNALS,
@@ -38,7 +38,7 @@ import {
   renderInjection,
   runPreflight,
   runShellProbe
-} from "./index-krjzghpz.js";
+} from "./index-0pdsq2hy.js";
 import {
   CORE_ADAPTER_REGISTRY,
   EFFORT_KEY_PROJECTIONS,
@@ -47,7 +47,7 @@ import {
   openNdjsonStore,
   openSqliteStore,
   selectEffortStore
-} from "./index-q491ekzm.js";
+} from "./index-at9f1z2z.js";
 import {
   CONFIG_DEFAULTS,
   CONFIG_FILE,
@@ -58,9 +58,9 @@ import {
   parseConfigText,
   readRafaBlocks,
   resolveConfig
-} from "./index-6cw1n0qy.js";
-import"./index-qzhpqmfy.js";
-import"./index-p901zs2p.js";
+} from "./index-jva32qe6.js";
+import"./index-kvnggvyk.js";
+import"./index-ddf85qac.js";
 import {
   CLAUDE_SETTING_SOURCES,
   CONFIG_VERSIONS,
@@ -71,7 +71,7 @@ import {
   PR_PROVIDERS,
   RELEASE_AUTO,
   STORE_BACKENDS
-} from "./index-n3rw8rhr.js";
+} from "./index-944pncd8.js";
 export {
   validateManifest,
   usage as usageCommand,

package/dist/plan/index.js

@@ -16,15 +16,15 @@ import {
   renderInjection,
   runPreflight,
   runShellProbe
-} from "../index-krjzghpz.js";
+} from "../index-0pdsq2hy.js";
 import {
   RAFA_BLOCK_KINDS,
   isRafaBlockKind,
   readRafaBlocks
-} from "../index-6cw1n0qy.js";
+} from "../index-jva32qe6.js";
 import {
   INJECT_MODES
-} from "../index-n3rw8rhr.js";
+} from "../index-944pncd8.js";
 export {
   runShellProbe,
   runPreflight,

package/dist/plan-prompt.md

@@ -66,11 +66,15 @@ criteria — **do not execute the plan**.
   as a checklist in the PREREQUISITES.md format of the dev-planner
   specification below. Only genuinely non-automatable steps; do not duplicate
   what `README.md`/`AGENTS.md` already require of every contributor. Link to
-  it from the plan.
+  it from the plan. An `[auto]` item holds exactly one backticked span, and
+  that span is its command, ending the item after `: ` and run as written:
+  prove a tool with `<tool> --version`, `<tool> --help` or `which <tool>`.
 * Do not create or touch any tracker file — the loop derives it from the plan.
 
 {PLAN_FORMAT}
 
+{ROUTING}
+
 ## Spec
 
 {SPEC_CONTENT}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open-tomato/rafa",
-  "version": "0.16.0",
+  "version": "0.18.0",
   "description": "Alpha. Runs a plan through the ralph loop: one Claude Code session per task, one commit per task, then a pull request and a CI wait.",
   "private": false,
   "publishConfig": {
@@ -47,7 +47,7 @@
     "bun": ">=1.3.14"
   },
   "scripts": {
-    "build": "rm -rf dist && bun build src/rafa.ts --target=bun --outfile=dist/cli.js && bun build src/index.ts src/plan/index.ts src/effort/store/index.ts src/ports/index.ts --target=bun --splitting --root=src --outdir=dist && cp src/PROMPT.md src/plan-prompt.md .claude/skills/dev-planner/SKILL.md dist/ && for tree in pr/plans:plans board/templates:templates; do src=src/${tree%:*}; out=dist/${tree#*:}; [ -d \"$src\" ] || continue; mkdir -p \"$out\" && cp \"$src\"/*.md \"$out\"/ || exit 1; done",
+    "build": "rm -rf dist && bun build src/rafa.ts --target=bun --outfile=dist/cli.js && bun build src/index.ts src/plan/index.ts src/effort/store/index.ts src/ports/index.ts --target=bun --splitting --root=src --outdir=dist && cp src/PROMPT.md src/plan-prompt.md dist/ && cp -R src/bundled dist/bundled && bun build src/tools/ts-symbols/cli.ts --target=bun --outfile=dist/bundled/bin/ts-symbols && for tree in pr/plans:plans board/templates:templates; do src=src/${tree%:*}; out=dist/${tree#*:}; [ -d \"$src\" ] || continue; mkdir -p \"$out\" && cp \"$src\"/*.md \"$out\"/ || exit 1; done",
     "prepack": "bun run build",
     "test": "bun test",
     "lint": "eslint .",