@open-tomato/rafa 0.43.0 → 0.45.0

package/dist/index-mgh2s9bj.js

@@ -0,0 +1,937 @@
+// @bun
+import {
+  CONFIDENCE_MAX,
+  CONFIDENCE_MIN
+} from "./index-hf2k497d.js";
+
+// src/pr/types.ts
+var MERGE_METHODS = Object.freeze([
+  "squash",
+  "merge",
+  "rebase"
+]);
+function isMergeMethod(value) {
+  return typeof value === "string" && MERGE_METHODS.includes(value);
+}
+
+// src/schema/tiers.ts
+import { existsSync, realpathSync } from "fs";
+import { dirname, join } from "path";
+var SKILL_TIERS = ["project", "rafa", "user"];
+var INSTINCT_SCOPES = ["project", "user"];
+var CLAUDE_SKILLS_PATH = join(".claude", "skills");
+var RAFA_INSTINCTS_PATH = join(".rafa", "instincts");
+var BUNDLED_SKILLS_DIR = join("bundled", "skills");
+var BUNDLED_BIN_DIR = join("bundled", "bin");
+function isSkillTier(value) {
+  return SKILL_TIERS.includes(value);
+}
+function realEntry(entry) {
+  try {
+    return realpathSync(entry);
+  } catch {
+    return entry;
+  }
+}
+function bundledSkillsDirectory(entry) {
+  return join(dirname(realEntry(entry ?? Bun.main)), BUNDLED_SKILLS_DIR);
+}
+function bundledBinDirectory(entry) {
+  return join(dirname(realEntry(entry ?? Bun.main)), BUNDLED_BIN_DIR);
+}
+function skillTierDirectory(tier, seams) {
+  if (tier === "user")
+    return join(seams.home, CLAUDE_SKILLS_PATH);
+  if (tier === "rafa")
+    return bundledSkillsDirectory(seams.entry);
+  return seams.projectRoot === null ? null : join(seams.projectRoot, CLAUDE_SKILLS_PATH);
+}
+function resolveSkillTiers(seams) {
+  const located = [];
+  for (const tier of SKILL_TIERS) {
+    const dir = skillTierDirectory(tier, seams);
+    if (dir !== null)
+      located.push({ tier, dir });
+  }
+  return located;
+}
+function instinctScopeDirectory(scope, seams) {
+  if (scope === "user")
+    return join(seams.home, RAFA_INSTINCTS_PATH);
+  return seams.projectRoot === null ? null : join(seams.projectRoot, RAFA_INSTINCTS_PATH);
+}
+function resolveInstinctScopes(seams) {
+  const located = [];
+  for (const scope of INSTINCT_SCOPES) {
+    const dir = instinctScopeDirectory(scope, seams);
+    if (dir !== null)
+      located.push({ scope, dir });
+  }
+  return located;
+}
+function tierExists(dir) {
+  return existsSync(dir);
+}
+
+// src/utils/declaration.ts
+var DECLARATION_KEYS = [
+  "agent",
+  "model",
+  "effort",
+  "budget",
+  "tools",
+  "skills",
+  "tests"
+];
+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 TEST_SCOPES = ["affected", "module", "full"];
+var DEFAULT_TEST_SCOPE = "affected";
+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 isTestScope(value) {
+  return TEST_SCOPES.includes(value);
+}
+function readTestScope(declaration) {
+  return declaration?.tests ?? DEFAULT_TEST_SCOPE;
+}
+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;
+  let tests = 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;
+    }
+    if (key === "tests") {
+      if (isTestScope(value))
+        tests = value;
+      else
+        issues.push(unusableValue(key, token));
+      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,
+    tests
+  };
+}
+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/core/config/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 SYNC_STRATEGIES = ["local", "file", "git", "service", "p2p"];
+var BOARD_RELATIONSHIP_MODES = ["labels", "native"];
+var INJECT_MODES = ["full", "stage", "task"];
+var OUTPUT_MODES = ["text", "json", "events"];
+var CLAUDE_SETTING_SOURCES = ["user", "project", "local"];
+var PR_PROVIDERS = ["gh", "none"];
+var RELEASE_AUTO = "auto";
+var TIER_SWITCHES = ["on", "off"];
+var SKILL_RESOLVERS = ["planner", "tag", "none"];
+var LESSON_SWITCHES = ["on", "off"];
+var CLAIMS_STALE_DISABLED = "disabled";
+var CLAIMS_AHEAD = ["off", "allow"];
+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 dayCount = (raw, at) => typeof raw === "number" && Number.isSafeInteger(raw) && raw > 0 ? accepted(raw) : refused(at, raw, "a number of days, a whole number above zero");
+var BUSY_TIMEOUT_MIN_MS = 1;
+var BUSY_TIMEOUT_MAX_MS = 60000;
+function isBusyTimeoutMs(raw) {
+  return typeof raw === "number" && Number.isSafeInteger(raw) && raw >= BUSY_TIMEOUT_MIN_MS && raw <= BUSY_TIMEOUT_MAX_MS;
+}
+var busyTimeoutMs = (raw, at) => isBusyTimeoutMs(raw) ? accepted(raw) : refused(at, raw, `a lock wait in milliseconds, a whole number from ${String(BUSY_TIMEOUT_MIN_MS)} to ${String(BUSY_TIMEOUT_MAX_MS)}`);
+var confidence = (raw, at) => typeof raw === "number" && Number.isFinite(raw) && toHundredths(raw) >= toHundredths(CONFIDENCE_MIN) && toHundredths(raw) <= toHundredths(CONFIDENCE_MAX) ? accepted(raw) : refused(at, raw, `a confidence from ${String(CONFIDENCE_MIN)} to ${String(CONFIDENCE_MAX)}`);
+function toHundredths(value) {
+  return Math.round(value * 100);
+}
+var recurrenceCount = (raw, at) => typeof raw === "number" && Number.isSafeInteger(raw) && raw >= 1 ? accepted(raw) : refused(at, raw, "a count, a whole number of 1 or more");
+var releaseEnabled = (raw, at) => typeof raw === "boolean" || raw === RELEASE_AUTO ? accepted(raw) : refused(at, raw, `true, false or ${RELEASE_AUTO}`);
+var tierSwitch = oneOf(TIER_SWITCHES);
+var tierPin = (raw, at) => {
+  if (raw === false)
+    return accepted(false);
+  const tier = SKILL_TIERS.find((name) => name === raw);
+  return tier === undefined ? refused(at, raw, `false or one of: ${SKILL_TIERS.join(", ")}`) : accepted(tier);
+};
+var routeTarget = (raw, at) => raw === false || typeof raw === "string" && raw.trim() !== "" ? accepted(raw) : refused(at, raw, "false or an agent name");
+var skillResolverName = oneOf(SKILL_RESOLVERS);
+var lessonSwitch = oneOf(LESSON_SWITCHES);
+var CLAIM_DURATION = /^(\d+)([hd])$/;
+var HOURS_PER_DAY = 24;
+function claimDurationHours(raw) {
+  const match = typeof raw === "string" ? CLAIM_DURATION.exec(raw) : null;
+  if (match === null)
+    return null;
+  const hours = Number(match[1]) * (match[2] === "d" ? HOURS_PER_DAY : 1);
+  return Number.isSafeInteger(hours) && hours > 0 ? hours : null;
+}
+var claimsStaleAfter = (raw, at) => raw === CLAIMS_STALE_DISABLED || claimDurationHours(raw) !== null ? accepted(raw) : refused(at, raw, `a duration of whole hours or days above zero, such as 36h or 3d, or ${CLAIMS_STALE_DISABLED}`);
+var claimsAhead = oneOf(CLAIMS_AHEAD);
+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");
+var BOARD_PROJECT_TEMPLATE_DEFAULT = "https://github.com/orgs/open-tomato/projects/6";
+var PROJECT_URL = /^https:\/\/github\.com\/(?:orgs|users)\/[A-Za-z0-9][A-Za-z0-9-]*\/projects\/[1-9]\d*$/;
+var projectUrl = (raw, at) => typeof raw === "string" && PROJECT_URL.test(raw) ? accepted(raw) : refused(at, raw, "a GitHub project URL, https://github.com/orgs/<owner>/projects/<number> or /users/<owner>/\u2026");
+var projectNumber = (raw, at) => typeof raw === "number" && Number.isSafeInteger(raw) && raw > 0 ? accepted(raw) : refused(at, raw, "a project number, a whole number above zero");
+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));
+  };
+}
+
+// src/core/config/config-readers.ts
+import { isAbsolute, normalize } from "path";
+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 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 routeTable = mapOf(routeTarget, "false or an agent name");
+var RELEASE_STRATEGIES = ["semver-by-level"];
+var RELEASE_SETTLE_MODES = ["push", "pr"];
+var RELEASE_TAG_MODES = ["manual", "settle"];
+var VERSION_COLLISION_MODES = ["allow", "report", "ask", "refuse"];
+var releaseStrategy = oneOf(RELEASE_STRATEGIES);
+var releaseSettleMode = oneOf(RELEASE_SETTLE_MODES);
+var releaseTagMode = oneOf(RELEASE_TAG_MODES);
+var versionCollisionMode = oneOf(VERSION_COLLISION_MODES);
+var UNTRACKED_DIRECTORY = ".rafa";
+var FRAGMENTS_EXPECTED = `a relative directory path not under ${UNTRACKED_DIRECTORY}/`;
+function isUnderUntracked(path) {
+  const [first] = normalize(path).split(/[\\/]/);
+  return first === UNTRACKED_DIRECTORY;
+}
+var fragmentsDirectory = (raw, at) => {
+  const reading = text(FRAGMENTS_EXPECTED)(raw, at);
+  const path = reading.value;
+  if (path === undefined || !isAbsolute(path) && !isUnderUntracked(path))
+    return reading;
+  const problem = `${at.label} is ${describeValue(raw)}, expected ${FRAGMENTS_EXPECTED}`;
+  return { value: undefined, problems: [problem], extras: [] };
+};
+// src/core/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;
+      }
+      case "event": {
+        return;
+      }
+    }
+  };
+  return Object.freeze({ info, warn, error, debug, emit, result });
+}
+
+// src/core/output/active.ts
+import { AsyncLocalStorage } from "async_hooks";
+var scopes = new AsyncLocalStorage;
+var DEFAULT_OUTPUT = createTextOutput({ verbosity: 0, stream: process.stdout });
+var active = DEFAULT_OUTPUT;
+var activeMode = "text";
+function activeOutput() {
+  return scopes.getStore()?.output ?? active;
+}
+function activeOutputMode() {
+  return scopes.getStore()?.mode ?? activeMode;
+}
+// src/utils/plan-stamp.ts
+var STUB_PATTERN = "[A-Za-z0-9._-]+";
+var STAMP_PATTERN = new RegExp(`<!--\\s*ralph:plan=(${STUB_PATTERN})\\s*-->`);
+function isStampableStub(stub) {
+  return new RegExp(`^${STUB_PATTERN}$`).test(stub);
+}
+function planStampLine(stub) {
+  if (!isStampableStub(stub)) {
+    throw new Error(`rafa plan stamp: unusable stub ${JSON.stringify(stub)}`);
+  }
+  return `<!-- ralph:plan=${stub} -->`;
+}
+function planStubFromPrompt(content) {
+  if (typeof content !== "string" || content.length === 0)
+    return null;
+  const match = STAMP_PATTERN.exec(content);
+  const stub = match?.[1];
+  return stub !== undefined && isStampableStub(stub) ? stub : null;
+}
+function stampPrompt(stub, prompt) {
+  return `${prompt}
+${planStampLine(stub)}`;
+}
+function planStubFromPath(planPath) {
+  const base = planPath.split("/").pop() ?? planPath;
+  const match = /^PLAN(?:_TRACKER)?-(.+)\.md$/.exec(base);
+  const stub = match?.[1];
+  return stub !== undefined && isStampableStub(stub) ? stub : null;
+}
+
+export { MERGE_METHODS, isMergeMethod, SKILL_TIERS, RAFA_INSTINCTS_PATH, BUNDLED_SKILLS_DIR, isSkillTier, realEntry, bundledBinDirectory, skillTierDirectory, resolveSkillTiers, resolveInstinctScopes, tierExists, TEST_SCOPES, isAgentName, BUDGET_FLAG, readTestScope, parseTaskDeclaration, stripTaskDeclaration, resolveDeclarationFlags, isMapping, describeValue, messageOf, CONFIG_VERSIONS, STORE_BACKENDS, SYNC_STRATEGIES, BOARD_RELATIONSHIP_MODES, INJECT_MODES, OUTPUT_MODES, CLAUDE_SETTING_SOURCES, PR_PROVIDERS, RELEASE_AUTO, SKILL_RESOLVERS, CLAIMS_STALE_DISABLED, refused, refusedWith, mapReading, below, oneOf, text, flag, mergeMethod, usdAmount, issueNumber, dayCount, BUSY_TIMEOUT_MIN_MS, BUSY_TIMEOUT_MAX_MS, isBusyTimeoutMs, busyTimeoutMs, confidence, recurrenceCount, releaseEnabled, tierSwitch, skillResolverName, lessonSwitch, claimDurationHours, claimsStaleAfter, claimsAhead, isGitHubLogin, githubLogin, BOARD_PROJECT_TEMPLATE_DEFAULT, projectUrl, projectNumber, listOf, subsetOf, mapOf, directory, trackerKind, releaseFile, tierPins, routeTable, releaseStrategy, releaseSettleMode, releaseTagMode, versionCollisionMode, fragmentsDirectory, createTextOutput, activeOutput, activeOutputMode, RAFA_BLOCK_KINDS, isRafaBlockKind, readRafaBlocks, REPORT_STATUSES, FINDING_KINDS, FINDING_SIGNALS, FINDING_DOMAINS, CHANGE_LEVELS, parseReport, isStampableStub, planStubFromPrompt, stampPrompt, planStubFromPath };