@open-tomato/rafa 0.7.1

package/dist/index-akz06erg.js

@@ -0,0 +1,866 @@
+// @bun
+// src/pr/types.ts
+var MERGE_METHODS = Object.freeze([
+  "squash",
+  "merge",
+  "rebase"
+]);
+function isMergeMethod(value) {
+  return typeof value === "string" && MERGE_METHODS.includes(value);
+}
+
+// src/utils/declaration.ts
+var DECLARATION_KEYS = [
+  "agent",
+  "model",
+  "effort",
+  "budget",
+  "tools",
+  "skills"
+];
+var GRANULAR_KEYS = ["model", "effort", "tools"];
+var AGENT_OWNED_KEYS = ["model", "tools"];
+var MODEL_ALIASES = ["opus", "sonnet", "haiku", "fable"];
+var EFFORT_LEVELS = [
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max"
+];
+var DECLARATION_BLOCK = /\{([^{}]*)\}$/;
+var ENTRY_TOKEN = /^([A-Za-z_][A-Za-z0-9_-]*)=(.*)$/;
+var FULL_MODEL_NAME = /^claude-[a-z0-9][a-z0-9.-]*$/;
+var AGENT_NAME = /^[A-Za-z0-9][A-Za-z0-9_-]*$/;
+function isAgentName(value) {
+  return AGENT_NAME.test(value);
+}
+var TOOL_NAME = /^[A-Za-z][A-Za-z0-9_-]*$/;
+var SKILL_NAME = /^[A-Za-z0-9][A-Za-z0-9_-]*$/;
+var BUDGET_FLAG = "--max-budget-usd";
+var BUDGET_VALUE = /^(?:0|[1-9]\d{0,5})(?:\.\d{1,6})?$/;
+function parseBudgetUsd(value) {
+  if (!BUDGET_VALUE.test(value))
+    return null;
+  const usd = Number(value);
+  return usd > 0 ? usd : null;
+}
+function isEffortLevel(value) {
+  return EFFORT_LEVELS.includes(value);
+}
+function isModelValue(value) {
+  if (MODEL_ALIASES.includes(value))
+    return true;
+  return FULL_MODEL_NAME.test(value);
+}
+function parseToolList(value) {
+  const parts = value.split(",");
+  if (parts.length === 0)
+    return null;
+  const tools = [];
+  for (const part of parts) {
+    if (!TOOL_NAME.test(part))
+      return null;
+    if (!tools.includes(part))
+      tools.push(part);
+  }
+  return tools;
+}
+function parseSkillList(value) {
+  const parts = value.split(",");
+  if (parts.length === 0)
+    return null;
+  const skills = [];
+  for (const part of parts) {
+    if (!SKILL_NAME.test(part))
+      return null;
+    if (!skills.includes(part))
+      skills.push(part);
+  }
+  return skills;
+}
+function unusableValue(key, token) {
+  return { reason: "unusable-value", key, text: token };
+}
+function isDeclarationKey(key) {
+  return DECLARATION_KEYS.includes(key);
+}
+function tokenise(body) {
+  const trimmed = body.trim();
+  if (trimmed.length === 0)
+    return [];
+  return trimmed.split(/\s+/);
+}
+function readBlock(raw, body) {
+  const entries = [];
+  const extras = [];
+  const issues = [];
+  const seen = new Set;
+  let agent = null;
+  let model = null;
+  let effort = null;
+  let budget = null;
+  let tools = null;
+  let skills = null;
+  for (const token of tokenise(body)) {
+    const match = token.match(ENTRY_TOKEN);
+    const key = match?.[1];
+    const value = match?.[2];
+    if (key === undefined || value === undefined) {
+      issues.push({ reason: "stray-token", key: "", text: token });
+      continue;
+    }
+    const entry = { key, value };
+    entries.push(entry);
+    if (!isDeclarationKey(key)) {
+      extras.push(entry);
+      continue;
+    }
+    if (seen.has(key)) {
+      issues.push({ reason: "duplicate-key", key, text: token });
+      continue;
+    }
+    seen.add(key);
+    if (key === "agent") {
+      if (AGENT_NAME.test(value))
+        agent = value;
+      else
+        issues.push(unusableValue(key, token));
+      continue;
+    }
+    if (key === "model") {
+      if (isModelValue(value))
+        model = value;
+      else
+        issues.push(unusableValue(key, token));
+      continue;
+    }
+    if (key === "effort") {
+      if (isEffortLevel(value))
+        effort = value;
+      else
+        issues.push(unusableValue(key, token));
+      continue;
+    }
+    if (key === "budget") {
+      const usd = parseBudgetUsd(value);
+      if (usd === null)
+        issues.push(unusableValue(key, token));
+      else
+        budget = usd;
+      continue;
+    }
+    if (key === "tools") {
+      const parsed = parseToolList(value);
+      if (parsed === null)
+        issues.push(unusableValue(key, token));
+      else
+        tools = parsed;
+      continue;
+    }
+    const named = parseSkillList(value);
+    if (named === null)
+      issues.push(unusableValue(key, token));
+    else
+      skills = named;
+  }
+  if (seen.size === 0)
+    return null;
+  return {
+    raw,
+    entries,
+    extras,
+    issues,
+    agent,
+    model,
+    effort,
+    budget,
+    tools,
+    skills
+  };
+}
+function parseTaskDeclaration(taskText) {
+  const trimmed = taskText.trimEnd();
+  const match = trimmed.match(DECLARATION_BLOCK);
+  const raw = match?.[0];
+  const body = match?.[1];
+  if (raw === undefined || body === undefined) {
+    return { text: taskText, declaration: null };
+  }
+  const before = trimmed.slice(0, trimmed.length - raw.length).trimEnd();
+  if (before.length === 0)
+    return { text: taskText, declaration: null };
+  const declaration = readBlock(raw, body);
+  if (declaration === null)
+    return { text: taskText, declaration: null };
+  return { text: before, declaration };
+}
+function stripTaskDeclaration(taskText) {
+  return parseTaskDeclaration(taskText).text;
+}
+function budgetArgs(budget) {
+  return budget === null ? [] : [BUDGET_FLAG, String(budget)];
+}
+function resolveDeclarationFlags(declaration, agentDeclaresEffort) {
+  if (declaration === null)
+    return { args: [], suppressed: [] };
+  const { agent, effort } = declaration;
+  const isPresent = (key) => declaration[key] !== null;
+  const budget = budgetArgs(declaration.budget);
+  if (agent !== null) {
+    if (effort === null || agentDeclaresEffort(agent)) {
+      return { args: ["--agent", agent, ...budget], suppressed: GRANULAR_KEYS.filter(isPresent) };
+    }
+    return {
+      args: ["--agent", agent, "--effort", effort, ...budget],
+      suppressed: AGENT_OWNED_KEYS.filter(isPresent)
+    };
+  }
+  const args = [];
+  if (declaration.model !== null)
+    args.push("--model", declaration.model);
+  if (declaration.effort !== null)
+    args.push("--effort", declaration.effort);
+  args.push(...budget);
+  if (declaration.tools !== null) {
+    args.push("--tools", declaration.tools.join(","));
+  }
+  return { args, suppressed: [] };
+}
+
+// src/config-sections.ts
+function isMapping(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function describeValue(value) {
+  if (typeof value === "string")
+    return JSON.stringify(value);
+  if (value === null)
+    return "null";
+  if (Array.isArray(value))
+    return "a list";
+  if (typeof value === "object")
+    return "a mapping";
+  return String(value);
+}
+function messageOf(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+var CONFIG_VERSIONS = [1];
+var STORE_BACKENDS = ["sqlite", "ndjson"];
+var INJECT_MODES = ["full", "stage", "task"];
+var OUTPUT_MODES = ["text", "json"];
+var CLAUDE_SETTING_SOURCES = ["user", "project", "local"];
+var PR_PROVIDERS = ["gh", "none"];
+var RELEASE_AUTO = "auto";
+function accepted(value) {
+  return { value, problems: [], extras: [] };
+}
+function refused(at, raw, expected) {
+  const problem = `${at.label} is ${describeValue(raw)}, expected ${expected}`;
+  return { value: undefined, problems: [problem], extras: [] };
+}
+function refusedWith(problems) {
+  return { value: undefined, problems, extras: [] };
+}
+function mapReading(reading, map) {
+  return reading.value === undefined ? { ...reading, value: undefined } : { ...reading, value: map(reading.value) };
+}
+function below(at, step) {
+  return { label: `${at.label}${step}`, key: `${at.key}${step}` };
+}
+function oneOf(values) {
+  const expected = `one of: ${values.join(", ")}`;
+  return (raw, at) => {
+    const hit = values.find((value) => value === raw);
+    return hit === undefined ? refused(at, raw, expected) : accepted(hit);
+  };
+}
+function text(expected) {
+  return (raw, at) => typeof raw === "string" && raw.trim() !== "" ? accepted(raw) : refused(at, raw, expected);
+}
+var flag = (raw, at) => typeof raw === "boolean" ? accepted(raw) : refused(at, raw, "true or false");
+var mergeMethod = oneOf(MERGE_METHODS);
+var usdAmount = (raw, at) => {
+  const usd = typeof raw === "number" ? parseBudgetUsd(String(raw)) : null;
+  return usd === null ? refused(at, raw, "a number of US dollars above zero, at most six digits either side of the point") : accepted(usd);
+};
+var issueNumber = (raw, at) => typeof raw === "number" && Number.isSafeInteger(raw) && raw > 0 ? accepted(raw) : refused(at, raw, "an issue number, a whole number above zero");
+var releaseEnabled = (raw, at) => typeof raw === "boolean" || raw === RELEASE_AUTO ? accepted(raw) : refused(at, raw, `true, false or ${RELEASE_AUTO}`);
+var GITHUB_LOGIN = /^[A-Za-z0-9][A-Za-z0-9-]*(?:\[bot\])?$/;
+function isGitHubLogin(value) {
+  return typeof value === "string" && GITHUB_LOGIN.test(value);
+}
+var githubLogin = (raw, at) => isGitHubLogin(raw) ? accepted(raw) : refused(at, raw, "a GitHub login");
+function listOf(item, expected) {
+  return (raw, at) => {
+    if (!Array.isArray(raw))
+      return refused(at, raw, `a list of ${expected}`);
+    const readings = raw.map((entry, index) => item(entry, below(at, `[${index}]`)));
+    const problems = readings.flatMap((reading) => reading.problems);
+    const extras = readings.flatMap((reading) => reading.extras);
+    if (problems.length > 0)
+      return { value: undefined, problems, extras };
+    const values = readings.flatMap((reading) => reading.value === undefined ? [] : [reading.value]);
+    return { value: Object.freeze(values), problems, extras };
+  };
+}
+function subsetOf(values) {
+  const expected = `a comma-separated subset of: ${values.join(", ")}`;
+  return (raw, at) => {
+    if (typeof raw !== "string")
+      return refused(at, raw, expected);
+    const named = [];
+    for (const entry of raw.split(",")) {
+      const hit = values.find((value) => value === entry.trim());
+      if (hit === undefined || named.includes(hit))
+        return refused(at, raw, expected);
+      named.push(hit);
+    }
+    return accepted(Object.freeze(named));
+  };
+}
+var itemText = text("a non-empty string");
+function readKeyedItem(shape, raw, at) {
+  const choices = shape.kinds.join(", ");
+  if (!isMapping(raw))
+    return refused(at, raw, `a mapping naming one of: ${choices}`);
+  const entries = Object.entries(raw);
+  const kinds = shape.kinds.filter((kind2) => entries.some(([name]) => name === kind2));
+  const [kind] = kinds;
+  if (kind === undefined)
+    return refusedWith([`${at.label} names none of: ${choices}`]);
+  if (kinds.length > 1) {
+    const named2 = kinds.join(" and ");
+    return refusedWith([`${at.label} names ${named2}, expected exactly one of: ${choices}`]);
+  }
+  const optionalKeys = shape.optionalFor(kind);
+  const problems = [];
+  const extras = [];
+  const optional = new Map;
+  let named;
+  for (const [name, value] of entries) {
+    if (name !== kind && !optionalKeys.includes(name)) {
+      extras.push({ key: `${at.key}.${name}`, value });
+      continue;
+    }
+    if (name !== kind && value === null)
+      continue;
+    const reading = itemText(value, below(at, `.${name}`));
+    problems.push(...reading.problems);
+    if (reading.value === undefined)
+      continue;
+    if (name === kind)
+      named = reading.value;
+    else
+      optional.set(name, reading.value);
+  }
+  return problems.length > 0 || named === undefined ? { value: undefined, problems, extras } : { value: { kind, named, optional }, problems, extras };
+}
+var PREREQUISITE_KINDS = ["tool", "env", "service", "lsp"];
+var REQUIRED_ITEM_KEYS = [...PREREQUISITE_KINDS, "probe"];
+var OPTIONAL_ITEM_KEYS = [...REQUIRED_ITEM_KEYS, "reason"];
+var requiredPrerequisite = (raw, at) => {
+  const shape = { kinds: PREREQUISITE_KINDS, optionalFor: () => ["probe"] };
+  return mapReading(readKeyedItem(shape, raw, at), (item) => Object.freeze({
+    kind: item.kind,
+    name: item.named,
+    probe: item.optional.get("probe") ?? null
+  }));
+};
+var optionalPrerequisite = (raw, at) => {
+  const shape = { kinds: PREREQUISITE_KINDS, optionalFor: () => ["probe", "reason"] };
+  return mapReading(readKeyedItem(shape, raw, at), (item) => Object.freeze({
+    kind: item.kind,
+    name: item.named,
+    probe: item.optional.get("probe") ?? null,
+    reason: item.optional.get("reason") ?? null
+  }));
+};
+var MODULE_SOURCE_KINDS = ["npm", "github", "path"];
+var MODULE_SOURCE_KEYS = [...MODULE_SOURCE_KINDS, "ref"];
+var moduleSource = (raw, at) => {
+  const shape = {
+    kinds: MODULE_SOURCE_KINDS,
+    optionalFor: (kind) => kind === "github" ? ["ref"] : []
+  };
+  return mapReading(readKeyedItem(shape, raw, at), (item) => Object.freeze({
+    kind: item.kind,
+    location: item.named,
+    ref: item.optional.get("ref") ?? null
+  }));
+};
+
+// src/config-schema.ts
+import { join } from "path";
+var CONFIG_FILE = join(".rafa", "config.yaml");
+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",
+  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}"
+});
+var directory = text("a directory path");
+var trackerKind = text("a tracker kind name");
+var releaseFile = text("a file path");
+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
+  },
+  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
+  }
+};
+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"),
+    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")
+  };
+  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] };
+}
+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];
+    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)));
+  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/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 { MERGE_METHODS, isMergeMethod, isAgentName, BUDGET_FLAG, parseTaskDeclaration, stripTaskDeclaration, resolveDeclarationFlags, isMapping, describeValue, messageOf, CONFIG_VERSIONS, STORE_BACKENDS, INJECT_MODES, OUTPUT_MODES, CLAUDE_SETTING_SOURCES, PR_PROVIDERS, RELEASE_AUTO, listOf, PREREQUISITE_KINDS, requiredPrerequisite, optionalPrerequisite, MODULE_SOURCE_KINDS, CONFIG_FILE, CONFIG_DEFAULTS, ConfigError, configFilePath, parseConfigText, resolveConfig, createTextOutput, activeOutput, activeOutputMode, RAFA_BLOCK_KINDS, isRafaBlockKind, readRafaBlocks };