@open-tomato/rafa 0.15.0 → 0.17.0

package/dist/{index-p572cxex.js → index-64wec0k7.js}

@@ -1,10 +1,12 @@
 // @bun
 import {
   activeOutput,
-  messageOf,
-  parseTaskDeclaration,
   readRafaBlocks
-} from "./index-2256nwj0.js";
+} from "./index-ps5sac9p.js";
+import {
+  messageOf,
+  parseTaskDeclaration
+} from "./index-n3rw8rhr.js";
 // src/preflight/prerequisites-md.ts
 import { basename, dirname, join } from "path";
 var SECTION_AUTO_RE = /\[auto\]/i;
@@ -14,7 +16,7 @@ var ITEM_RE = /^-\s+\[\s*\]\s+/;
 var INLINE_AUTO_RE = /^-\s+\[\s*\]\s+\[auto\]\s+/i;
 var INLINE_HUMAN_RE = /^-\s+\[\s*\]\s+\[human\]\s+/i;
 var INLINE_START_RE = /^-\s+\[\s*\]\s+\[start\]\s+/i;
-var BACKTICK_RE = /`([^`]+)`/;
+var PROBE_RE = /:\s+`([^`]+)`\s*$/;
 var HEADING_MARKS_RE = /^#+/;
 var FENCE_RE = /^ {0,3}(`{3,}|~{3,})/;
 var NESTED_LIST_ITEM_RE = /^\s+(?:[-*+]|\d+[.)])\s/;
@@ -76,7 +78,7 @@ function isProbedTag(tag) {
   return tag === "auto" || tag === "start";
 }
 function extractProbe(description) {
-  const probe = BACKTICK_RE.exec(description)?.[1]?.trim();
+  const probe = PROBE_RE.exec(description)?.[1]?.trim();
   return probe || null;
 }
 function readItem(lines, lineIndex, inherited) {
@@ -123,24 +125,37 @@ function requiredItemsTagged(items, tag) {
   const probed = items.filter(isProbed).filter((item) => item.tag === tag);
   return Object.freeze(probed.map(requiredItem));
 }
-function reminderOf(item) {
+function namedItemOf(item) {
   return Object.freeze({ description: item.description, tag: item.tag, line: item.lineIndex + 1 });
 }
+function isMalformed(item) {
+  return isProbedTag(item.tag) && item.probe === null;
+}
 function planPrerequisites(content) {
   const items = parsePrerequisites(content);
   return Object.freeze({
     required: requiredItemsTagged(items, "auto"),
     startRequired: requiredItemsTagged(items, "start"),
-    reminders: Object.freeze(items.filter((item) => !isProbed(item)).map(reminderOf))
+    reminders: Object.freeze(items.filter((item) => !isProbedTag(item.tag)).map(namedItemOf)),
+    malformed: Object.freeze(items.filter(isMalformed).map(namedItemOf))
   });
 }
+var PROBE_ITEM_EXAMPLE = "- [ ] uv installed: `uvx --version`";
+function malformedPrerequisiteLines(file, malformed) {
+  return [
+    `${file} holds ${malformed.length} malformed [auto] or [start] item(s): no command ends the item after a final ": ".`,
+    ...malformed.map((item) => `  line ${item.line} [${item.tag}]: ${item.description}`),
+    `Write each as ${PROBE_ITEM_EXAMPLE}, its one backticked span a complete command run as written;` + " prove a tool is there with `<tool> --version`, `<tool> --help` or `which <tool>`."
+  ];
+}
 function mergePlanPrerequisites(settings, content) {
   const plan = planPrerequisites(content ?? "");
   return Object.freeze({
     required: Object.freeze([...settings.prerequisitesRequired, ...plan.required]),
     startRequired: plan.startRequired,
     optional: Object.freeze([...settings.prerequisitesOptional]),
-    reminders: plan.reminders
+    reminders: plan.reminders,
+    malformed: plan.malformed
   });
 }
 function prerequisitesPathForPlan(planPath) {
@@ -1098,4 +1113,4 @@ function renderInjection(request) {
   }
   return { requested: mode, mode, text: RENDERERS[mode](model, location.task), fallback: null };
 }
-export { isStampableStub, planStubFromPrompt, stampPrompt, planStubFromPath, REPORT_STATUSES, FINDING_KINDS, FINDING_SIGNALS, CHANGE_LEVELS, parseReport, escapeBlockerText, findNextTask, updateTrackerLine, writeTrackerBlocker, trackerPathFor, PLAN_BLOCK_KINDS, PLAN_HEADER_FIELDS, parsePlan, parsePrerequisites, planPrerequisites, mergePlanPrerequisites, prerequisitesPathForPlan, loadPlanPrerequisites, PROBE_TIMEOUT_MS, runShellProbe, runPreflight, renderInjection };
+export { isStampableStub, planStubFromPrompt, stampPrompt, planStubFromPath, REPORT_STATUSES, FINDING_KINDS, FINDING_SIGNALS, CHANGE_LEVELS, parseReport, escapeBlockerText, splitBlockerComment, findNextTask, updateTrackerLine, writeTrackerBlocker, trackerPathFor, PLAN_BLOCK_KINDS, PLAN_HEADER_FIELDS, parsePlan, parsePrerequisites, planPrerequisites, malformedPrerequisiteLines, mergePlanPrerequisites, prerequisitesPathForPlan, loadPlanPrerequisites, PROBE_TIMEOUT_MS, runShellProbe, runPreflight, renderInjection };

package/dist/{index-1x5t4t9r.js → index-7t0qz29r.js}

@@ -1,14 +1,19 @@
 // @bun
 import {
-  STORE_BACKENDS,
   activeOutput,
   activeOutputMode,
   createTextOutput,
+  readRafaBlocks
+} from "./index-ps5sac9p.js";
+import {
+  commandSpelling
+} from "./index-p901zs2p.js";
+import {
+  STORE_BACKENDS,
   describeValue,
   isMapping,
-  messageOf,
-  readRafaBlocks
-} from "./index-2256nwj0.js";
+  messageOf
+} from "./index-n3rw8rhr.js";
 
 // src/effort/store.ts
 import {
@@ -840,27 +845,6 @@ function parseSpecReview(output) {
   return judged(verdict, readGaps(document, issues), block, issues);
 }
 
-// src/cli/command.ts
-var MAX_EXIT_CODE = 255;
-
-class CommandExit extends Error {
-  exitCode;
-  constructor(exitCode, message = "") {
-    super(message);
-    if (!Number.isInteger(exitCode) || exitCode < 0 || exitCode > MAX_EXIT_CODE) {
-      throw new TypeError(`CommandExit: exit code is ${describeValue(exitCode)}, expected a whole number from 0 to ${MAX_EXIT_CODE}`);
-    }
-    this.name = "CommandExit";
-    this.exitCode = exitCode;
-  }
-}
-function isTopLevel(command) {
-  return command.subject === command.action;
-}
-function commandSpelling(command) {
-  return isTopLevel(command) ? command.subject : `${command.subject} ${command.action}`;
-}
-
 // src/cli/running.ts
 var running = null;
 function runningCommand() {
@@ -1133,7 +1117,7 @@ var REST_STATES = {
   cancelled: "closed"
 };
 function createGhRunner(options) {
-  const { cwd, command = "gh", env } = options;
+  const { cwd, command = "gh", env, timeoutMs } = options;
   return async (args) => {
     const executable = env === undefined ? command : Bun.which(command, { PATH: env.PATH ?? "", cwd });
     if (executable === null) {
@@ -1147,17 +1131,38 @@ function createGhRunner(options) {
         stdout: "pipe",
         stderr: "pipe"
       });
-      const [stdout, stderr, exitCode] = await Promise.all([
+      const finished = Promise.all([
         new Response(proc.stdout).text(),
         new Response(proc.stderr).text(),
         proc.exited
       ]);
+      const outcome = await withDeadline(finished, timeoutMs);
+      if (outcome === TIMED_OUT) {
+        proc.kill("SIGKILL");
+        await proc.exited;
+        return { ok: false, stdout: "", stderr: `${command} in ${cwd} timed out after ${timeoutMs}ms and was killed` };
+      }
+      const [stdout, stderr, exitCode] = outcome;
       return { ok: exitCode === 0, stdout, stderr };
     } catch (error) {
       return { ok: false, stdout: "", stderr: `could not run ${command} in ${cwd}: ${messageOf(error)}` };
     }
   };
 }
+var TIMED_OUT = Symbol("timed out");
+async function withDeadline(work, timeoutMs) {
+  if (timeoutMs === undefined)
+    return work;
+  let timer;
+  const deadline = new Promise((resolve2) => {
+    timer = setTimeout(() => resolve2(TIMED_OUT), timeoutMs);
+  });
+  try {
+    return await Promise.race([work, deadline]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
 function notOnPath(command, cwd, path) {
   const searched = path === undefined ? "an environment with no PATH" : `PATH ${JSON.stringify(path)}`;
   return `could not run ${command} in ${cwd}: not found on ${searched} (ENOENT)`;
@@ -1855,4 +1860,4 @@ function selectEffortStore(repoRoot, config) {
   return adapter.create({ repoRoot });
 }
 
-export { EFFORT_KEY_PROJECTIONS, openNdjsonStore, sqliteStorePath, LONE_SURROGATE, withSqliteStore, writeSqliteStore, openSqliteStore, CommandExit, commandSpelling, getClaudeUsagePercent, checkUsage, interruptClaudeSessions, runClaude, runClaudeCaptured, planFilePath, ClaudePlannerError, createGhRunner, createLocalTracker, PORT_VERSIONS, createAdapterRegistry, CORE_ADAPTER_REGISTRY, selectEffortStore };
+export { EFFORT_STORE_DIR, effortStorePath, EFFORT_KEY_PROJECTIONS, openNdjsonStore, sqliteStorePath, LONE_SURROGATE, withSqliteStore, writeSqliteStore, openSqliteStore, sessionSpawnEnv, getClaudeUsagePercent, checkUsage, claudeArgs, interruptClaudeSessions, runClaude, spawnClaudeCaptured, runClaudeCaptured, planFilePath, ClaudePlannerError, ISSUE_TYPES, ISSUE_PRIORITIES, ISSUE_STATES, GITHUB_LABELS, createGhRunner, typeOfLabels, moduleOfLabels, createLocalTracker, PORT_VERSIONS, createAdapterRegistry, CORE_ADAPTER_REGISTRY, selectEffortStore };

package/dist/index-n3rw8rhr.js

@@ -0,0 +1,397 @@
+// @bun
+var __require = import.meta.require;
+
+// 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 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 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
+  }));
+};
+
+export { __require, MERGE_METHODS, isMergeMethod, isAgentName, BUDGET_FLAG, parseBudgetUsd, parseTaskDeclaration, stripTaskDeclaration, resolveDeclarationFlags, isMapping, describeValue, messageOf, CONFIG_VERSIONS, STORE_BACKENDS, INJECT_MODES, OUTPUT_MODES, CLAUDE_SETTING_SOURCES, PR_PROVIDERS, RELEASE_AUTO, oneOf, text, flag, mergeMethod, usdAmount, issueNumber, dayCount, releaseEnabled, isGitHubLogin, githubLogin, listOf, subsetOf, PREREQUISITE_KINDS, REQUIRED_ITEM_KEYS, OPTIONAL_ITEM_KEYS, requiredPrerequisite, optionalPrerequisite, MODULE_SOURCE_KINDS, MODULE_SOURCE_KEYS, moduleSource };