brass-runtime 1.20.0 → 1.21.0

package/dist/{chunk-6BNZS2A4.mjs → chunk-Q57ENQUW.mjs}

@@ -12,6 +12,7 @@ import {
   asyncFail,
   asyncFlatMap,
   asyncFold,
+  asyncInterruptible,
   asyncMap,
   asyncSucceed,
   asyncSync
@@ -62,6 +63,187 @@ var reduceAgentState = (state, observation) => {
 };
 var isTerminal = (state) => state.phase === "done" || state.phase === "failed" || state.steps >= MAX_AGENT_STEPS;
 
+// src/agent/core/contextBudget/armExtraction.ts
+var FALLBACK_ARM_ID = "__fallback__";
+var COMPOUND_EXTENSIONS = [
+  ".test.ts",
+  ".test.tsx",
+  ".test.js",
+  ".test.jsx",
+  ".spec.ts",
+  ".spec.tsx",
+  ".spec.js",
+  ".spec.jsx",
+  ".pbt.test.ts",
+  ".pbt.test.js",
+  ".d.ts",
+  ".d.mts",
+  ".d.cts",
+  ".config.ts",
+  ".config.js",
+  ".config.mjs",
+  ".config.cjs",
+  ".module.ts",
+  ".module.css",
+  ".stories.tsx",
+  ".stories.ts"
+];
+var extractExtension = (filename) => {
+  const lower = filename.toLowerCase();
+  for (const ext of COMPOUND_EXTENSIONS) {
+    if (lower.endsWith(ext) && filename.length > ext.length) {
+      return filename.slice(filename.length - ext.length);
+    }
+  }
+  const dotIndex = filename.lastIndexOf(".");
+  if (dotIndex > 0 && dotIndex < filename.length - 1) {
+    return filename.slice(dotIndex);
+  }
+  return "";
+};
+var normalizePath = (filePath) => filePath.replace(/\\/g, "/");
+var deriveArmId = (filePath) => {
+  try {
+    if (!filePath || typeof filePath !== "string") {
+      return FALLBACK_ARM_ID;
+    }
+    const normalized = normalizePath(filePath.trim());
+    if (!normalized) {
+      return FALLBACK_ARM_ID;
+    }
+    const lastSlash = normalized.lastIndexOf("/");
+    const directory = lastSlash >= 0 ? normalized.slice(0, lastSlash) : "";
+    const filename = lastSlash >= 0 ? normalized.slice(lastSlash + 1) : normalized;
+    if (!filename) {
+      return FALLBACK_ARM_ID;
+    }
+    const extension = extractExtension(filename);
+    if (!extension) {
+      return FALLBACK_ARM_ID;
+    }
+    const glob = `*${extension}`;
+    return directory ? `${directory}/${glob}` : glob;
+  } catch {
+    return FALLBACK_ARM_ID;
+  }
+};
+var assignArm = (filePath) => {
+  const id = deriveArmId(filePath);
+  return { id, pattern: id };
+};
+var groupByArm = (candidates) => {
+  const map = /* @__PURE__ */ new Map();
+  for (const path of candidates) {
+    const arm = assignArm(path);
+    const existing = map.get(arm.id);
+    if (existing) {
+      existing.push(path);
+    } else {
+      map.set(arm.id, [path]);
+    }
+  }
+  return map;
+};
+
+// src/agent/core/contextBudget/banditEngine.ts
+var defaultArmStats = () => ({
+  alpha: 1,
+  beta: 1,
+  pulls: 0,
+  lastPulledAt: 0
+});
+var sampleBeta = (alpha, beta, rng) => {
+  const a = Math.max(alpha, 1e-3);
+  const b = Math.max(beta, 1e-3);
+  const x = sampleGamma(a, rng);
+  const y = sampleGamma(b, rng);
+  if (x + y === 0) return 0.5;
+  return x / (x + y);
+};
+var sampleGamma = (shape, rng) => {
+  if (shape < 1) {
+    const sample = sampleGamma(shape + 1, rng);
+    const u = rng();
+    return sample * Math.pow(u === 0 ? 1e-10 : u, 1 / shape);
+  }
+  const d = shape - 1 / 3;
+  const c = 1 / Math.sqrt(9 * d);
+  for (; ; ) {
+    let x;
+    let v;
+    do {
+      const u1 = rng();
+      const u2 = rng();
+      x = Math.sqrt(-2 * Math.log(u1 === 0 ? 1e-10 : u1)) * Math.cos(2 * Math.PI * u2);
+      v = 1 + c * x;
+    } while (v <= 0);
+    v = v * v * v;
+    const u = rng();
+    if (u < 1 - 0.0331 * (x * x) * (x * x)) {
+      return d * v;
+    }
+    if (Math.log(u === 0 ? 1e-10 : u) < 0.5 * x * x + d * (1 - v + Math.log(v))) {
+      return d * v;
+    }
+  }
+};
+var selectArms = (state, candidateArms, rng) => {
+  if (candidateArms.length === 0) return [];
+  const sampled = candidateArms.map((arm) => {
+    const stats = state.arms[arm.id] ?? defaultArmStats();
+    const value = sampleBeta(stats.alpha, stats.beta, rng);
+    return { arm, value };
+  });
+  sampled.sort((a, b) => b.value - a.value);
+  return sampled.map((s) => s.arm);
+};
+
+// src/agent/core/contextBudget/integration.ts
+var shouldApplyBandit = (state, contextEnabled, hasInitialPatch) => {
+  if (Object.keys(state.arms).length === 0) return false;
+  if (!contextEnabled) return false;
+  if (hasInitialPatch) return false;
+  return true;
+};
+var reorderCandidates = (candidates, state, rng) => {
+  try {
+    if (Object.keys(state.arms).length === 0) {
+      return candidates;
+    }
+    const armGroups = groupByArm(candidates);
+    const uniqueArms = [];
+    for (const armId of armGroups.keys()) {
+      uniqueArms.push({ id: armId, pattern: armId });
+    }
+    const prioritizedArms = selectArms(state, uniqueArms, rng);
+    const result = [];
+    const includedArmIds = /* @__PURE__ */ new Set();
+    for (const arm of prioritizedArms) {
+      const paths = armGroups.get(arm.id);
+      if (paths) {
+        for (const p of paths) {
+          result.push(p);
+        }
+        includedArmIds.add(arm.id);
+      }
+    }
+    for (const [armId, paths] of armGroups) {
+      if (!includedArmIds.has(armId)) {
+        for (const p of paths) {
+          result.push(p);
+        }
+      }
+    }
+    return result;
+  } catch (error) {
+    console.warn(
+      "[contextBudget] reorderCandidates failed, returning original order:",
+      error instanceof Error ? error.message : String(error)
+    );
+    return candidates;
+  }
+};
+
 // src/agent/core/contextDiscovery.ts
 var DEFAULT_CONTEXT_GLOBS = [
   "*.ts",
@@ -359,7 +541,7 @@ var summarizeContextDiscovery = (state) => {
     remainingFileBudget
   };
 };
-var nextContextDiscoveryAction = (state) => {
+var nextContextDiscoveryAction = (state, banditState) => {
   const config = configFor(state);
   if (!config.enabled) return void 0;
   if (state.goal.initialPatch?.trim()) return void 0;
@@ -367,8 +549,14 @@ var nextContextDiscoveryAction = (state) => {
   const readsRemaining = Math.max(0, config.maxFiles - contextFileReadCount(state));
   const directPaths = extractLikelyFilePaths(state);
   const resultPaths = pathsFromSearchResults(state, config.maxSearchResults);
+  const allCandidates = [...directPaths, ...resultPaths];
+  const orderedCandidates = banditState && shouldApplyBandit(
+    banditState,
+    config.enabled,
+    Boolean(state.goal.initialPatch?.trim())
+  ) ? reorderCandidates(allCandidates, banditState, Math.random) : allCandidates;
   if (readsRemaining > 0) {
-    const nextPath = [...directPaths, ...resultPaths].find(
+    const nextPath = orderedCandidates.find(
       (path) => path !== "package.json" && !alreadyRead(state, path) && !knownMissing(state, path)
     );
     if (nextPath) {
@@ -1018,6 +1206,343 @@ var describeLanguagePolicy = (goal) => {
 };
 var spanishLike = (goal) => responseLanguageName(goal) === "Spanish";
 
+// src/agent/core/patchStrategy/types.ts
+var PATCH_STRATEGIES = [
+  "direct-patch",
+  "multi-step-patch",
+  "propose-then-refine"
+];
+var DEFAULT_STRATEGY = "direct-patch";
+
+// src/agent/core/patchStrategy/thompson.ts
+var initialThompsonState = () => ({
+  algorithm: "thompson",
+  arms: {
+    "direct-patch": { alpha: 1, beta: 1 },
+    "multi-step-patch": { alpha: 1, beta: 1 },
+    "propose-then-refine": { alpha: 1, beta: 1 }
+  }
+});
+var thompsonSelect = (state, rng) => {
+  let bestArm = PATCH_STRATEGIES[0];
+  let bestSample = -Infinity;
+  for (const arm of PATCH_STRATEGIES) {
+    const { alpha, beta } = state.arms[arm];
+    const sample = rng.sampleBeta(alpha, beta);
+    if (sample > bestSample) {
+      bestSample = sample;
+      bestArm = arm;
+    }
+  }
+  return bestArm;
+};
+var thompsonUpdate = (state, arm, reward) => {
+  const clampedReward = Math.max(0, Math.min(1, reward));
+  const current = state.arms[arm];
+  const newAlpha = Math.max(1, current.alpha + clampedReward);
+  const newBeta = Math.max(1, current.beta + (1 - clampedReward));
+  return {
+    ...state,
+    arms: {
+      ...state.arms,
+      [arm]: { alpha: newAlpha, beta: newBeta }
+    }
+  };
+};
+var thompsonStateFromHistory = (history) => {
+  let state = initialThompsonState();
+  for (const entry of history) {
+    state = thompsonUpdate(state, entry.arm, entry.reward);
+  }
+  return state;
+};
+
+// src/agent/core/patchStrategy/exp3.ts
+var K = 3;
+var initialEXP3State = (gamma = 0.3) => ({
+  algorithm: "exp3",
+  arms: {
+    "direct-patch": { weight: 1 },
+    "multi-step-patch": { weight: 1 },
+    "propose-then-refine": { weight: 1 }
+  },
+  gamma: Math.max(0, Math.min(1, gamma)) || 0.3,
+  totalRounds: 0
+});
+var exp3Probabilities = (state) => {
+  const { arms, gamma } = state;
+  let weightSum = 0;
+  for (const arm of PATCH_STRATEGIES) {
+    weightSum += arms[arm].weight;
+  }
+  const probs = {};
+  let probSum = 0;
+  for (const arm of PATCH_STRATEGIES) {
+    const p = (1 - gamma) * (arms[arm].weight / weightSum) + gamma / K;
+    probs[arm] = p;
+    probSum += p;
+  }
+  for (const arm of PATCH_STRATEGIES) {
+    probs[arm] /= probSum;
+  }
+  return probs;
+};
+var exp3Select = (state, rng) => {
+  const probs = exp3Probabilities(state);
+  const r = rng.random();
+  let cumulative = 0;
+  for (const arm of PATCH_STRATEGIES) {
+    cumulative += probs[arm];
+    if (r < cumulative) {
+      return arm;
+    }
+  }
+  return PATCH_STRATEGIES[PATCH_STRATEGIES.length - 1];
+};
+var exp3Update = (state, arm, reward) => {
+  const clampedReward = Math.max(0, Math.min(1, reward));
+  const probs = exp3Probabilities(state);
+  const pSelected = probs[arm];
+  const estimatedReward = clampedReward / pSelected;
+  const currentWeight = state.arms[arm].weight;
+  const newWeight = Math.min(
+    currentWeight * Math.exp(state.gamma * estimatedReward / K),
+    1e100
+  );
+  return {
+    ...state,
+    arms: {
+      ...state.arms,
+      [arm]: { weight: newWeight }
+    },
+    totalRounds: state.totalRounds + 1
+  };
+};
+var exp3StateFromHistory = (history, gamma = 0.3) => {
+  let state = initialEXP3State(gamma);
+  for (const entry of history) {
+    state = exp3Update(state, entry.arm, entry.reward);
+  }
+  return state;
+};
+
+// src/agent/core/patchStrategy/selector.ts
+var selectStrategy = (_signals, config, history, rng) => {
+  if (config?.enabled === false) {
+    return DEFAULT_STRATEGY;
+  }
+  if (history.length === 0) {
+    return DEFAULT_STRATEGY;
+  }
+  const algorithm = config?.algorithm ?? "thompson";
+  switch (algorithm) {
+    case "thompson": {
+      const state = thompsonStateFromHistory(history);
+      return thompsonSelect(state, rng);
+    }
+    case "exp3": {
+      const rawGamma = config?.gamma ?? 0.3;
+      const gamma = Math.max(Number.EPSILON, Math.min(1, rawGamma)) || 0.3;
+      const state = exp3StateFromHistory(history, gamma);
+      return exp3Select(state, rng);
+    }
+    default: {
+      const state = thompsonStateFromHistory(history);
+      return thompsonSelect(state, rng);
+    }
+  }
+};
+
+// src/agent/core/patchStrategy/signalExtractor.ts
+var FILE_EXTENSIONS = [
+  "tsx",
+  "jsx",
+  "mts",
+  "cts",
+  "mjs",
+  "cjs",
+  "json",
+  "yaml",
+  "html",
+  "scss",
+  "ts",
+  "js",
+  "md",
+  "yml",
+  "css"
+];
+var ASCII_CASE_BIT = 32;
+var MAX_FILE_PATH_CANDIDATE_LENGTH = 512;
+var KEYWORDS = [
+  "refactor",
+  "rename",
+  "bug",
+  "fix",
+  "add",
+  "create",
+  "move",
+  "delete"
+];
+var KEYWORD_PATTERNS = new Map(
+  KEYWORDS.map((kw) => [kw, new RegExp(`\\b${kw}\\b`, "i")])
+);
+var categorizeGoalLength = (text) => {
+  const len = text.length;
+  if (len < 80) return "short";
+  if (len <= 300) return "medium";
+  return "long";
+};
+var isAsciiAlpha = (code) => code >= 65 && code <= 90 || code >= 97 && code <= 122;
+var isAsciiDigit = (code) => code >= 48 && code <= 57;
+var isPathCandidateChar = (code) => isAsciiAlpha(code) || isAsciiDigit(code) || code === 95 || // _
+code === 64 || // @
+code === 46 || // .
+code === 45 || // -
+code === 47 || // /
+code === 92 || // \
+code === 58;
+var matchesExtension = (text, start, end, extension) => {
+  if (end - start !== extension.length) return false;
+  for (let offset = 0; offset < extension.length; offset++) {
+    const textCode = text.charCodeAt(start + offset) | ASCII_CASE_BIT;
+    if (textCode !== extension.charCodeAt(offset)) {
+      return false;
+    }
+  }
+  return true;
+};
+var matchesKnownExtension = (text, start, end) => {
+  for (const extension of FILE_EXTENSIONS) {
+    if (matchesExtension(text, start, end, extension)) {
+      return true;
+    }
+  }
+  return false;
+};
+var stripTrailingPathPunctuation = (text, start, end) => {
+  let currentEnd = end;
+  while (currentEnd > start) {
+    const code = text.charCodeAt(currentEnd - 1);
+    if (code !== 46 && code !== 58) break;
+    currentEnd--;
+  }
+  return currentEnd;
+};
+var stripLineSuffixes = (text, start, end) => {
+  let currentEnd = end;
+  for (let suffixCount = 0; suffixCount < 2; suffixCount++) {
+    let cursor = currentEnd - 1;
+    if (cursor < start || !isAsciiDigit(text.charCodeAt(cursor))) break;
+    while (cursor >= start && isAsciiDigit(text.charCodeAt(cursor))) {
+      cursor--;
+    }
+    if (cursor < start || text.charCodeAt(cursor) !== 58) break;
+    currentEnd = cursor;
+  }
+  return currentEnd;
+};
+var findLastDot = (text, start, end) => {
+  for (let index = end - 1; index >= start; index--) {
+    if (text.charCodeAt(index) === 46) {
+      return index;
+    }
+  }
+  return -1;
+};
+var findFilenameStart = (text, start, dotIndex) => {
+  let filenameStart = start;
+  for (let index = start; index < dotIndex; index++) {
+    const code = text.charCodeAt(index);
+    if (code === 47 || code === 92) {
+      filenameStart = index + 1;
+    }
+  }
+  return filenameStart;
+};
+var isFilePathCandidate = (text, start, end) => {
+  const punctuationEnd = stripTrailingPathPunctuation(text, start, end);
+  const pathEnd = stripLineSuffixes(text, start, punctuationEnd);
+  const dotIndex = findLastDot(text, start, pathEnd);
+  if (dotIndex < 0 || dotIndex + 1 >= pathEnd) return false;
+  if (!matchesKnownExtension(text, dotIndex + 1, pathEnd)) return false;
+  return dotIndex > findFilenameStart(text, start, dotIndex);
+};
+var detectFilePaths = (text) => {
+  let candidateStart = -1;
+  let candidateTooLong = false;
+  for (let index = 0; index <= text.length; index++) {
+    const isCandidateChar = index < text.length && isPathCandidateChar(text.charCodeAt(index));
+    if (isCandidateChar) {
+      if (candidateStart < 0) {
+        candidateStart = index;
+      }
+      if (index + 1 - candidateStart > MAX_FILE_PATH_CANDIDATE_LENGTH) {
+        candidateTooLong = true;
+      }
+      continue;
+    }
+    if (candidateStart >= 0) {
+      if (!candidateTooLong && isFilePathCandidate(text, candidateStart, index)) {
+        return true;
+      }
+      candidateStart = -1;
+      candidateTooLong = false;
+    }
+  }
+  return false;
+};
+var detectKeywords = (text) => {
+  const result = {};
+  for (const kw of KEYWORDS) {
+    result[kw] = KEYWORD_PATTERNS.get(kw).test(text);
+  }
+  return result;
+};
+var extractContextSignals = (observations) => {
+  let hasProjectProfile = false;
+  let searchResultCount = 0;
+  let discoveredFileCount = 0;
+  for (const obs of observations) {
+    switch (obs.type) {
+      case "fs.fileRead":
+        discoveredFileCount++;
+        if (obs.path.endsWith("package.json")) {
+          hasProjectProfile = true;
+        }
+        break;
+      case "fs.searchResult":
+        searchResultCount += obs.matches.length;
+        break;
+    }
+  }
+  return {
+    hasProjectProfile,
+    searchResultCount,
+    discoveredFileCount
+  };
+};
+var extractSignals = (state) => {
+  const goalText = state.goal.text;
+  return {
+    goalLengthCategory: categorizeGoalLength(goalText),
+    hasFilePaths: detectFilePaths(goalText),
+    keywords: detectKeywords(goalText),
+    contextSignals: extractContextSignals(state.observations)
+  };
+};
+
+// src/agent/core/patchStrategy/promptStrategy.ts
+var strategyPromptFragment = (strategy) => {
+  switch (strategy) {
+    case "direct-patch":
+      return "Produce a single focused patch in one response. Do not plan multiple steps. Emit one unified diff that addresses the goal directly.";
+    case "multi-step-patch":
+      return "You may produce multiple incremental patches across responses. Start with the most critical change, then refine iteratively based on validation feedback.";
+    case "propose-then-refine":
+      return "First propose a plan describing what changes are needed and why. Do NOT include a patch in this response. After validation feedback, produce the refined patch in a follow-up.";
+  }
+};
+
 // src/agent/core/decide.ts
 var hasObservation = (state, type) => state.observations.some((obs) => obs.type === type);
 var lastObservation = (state, type) => [...state.observations].reverse().find((obs) => obs.type === type);
@@ -1108,7 +1633,7 @@ var causeMessage = (cause) => {
   return String(cause);
 };
 var errorDetail = (state, cause) => redactForPrompt(state, causeMessage(cause)).slice(0, 2e3);
-var buildPlanningPrompt = (state) => {
+var buildPlanningPrompt = (state, strategy) => {
   const discovery = discoverValidationCommands(state);
   return redactForPrompt(state, [
     "You are a coding agent running on brass-runtime.",
@@ -1119,6 +1644,7 @@ var buildPlanningPrompt = (state) => {
     "Only propose a patch when the observations are strong enough.",
     "Use the project command discovery summary as context, but do not invent commands that were not run.",
     describeLanguagePolicy(state.goal),
+    strategy ? strategyPromptFragment(strategy) : "",
     "",
     `Goal: ${state.goal.text}`,
     `Workspace: ${state.goal.cwd}`,
@@ -1354,6 +1880,9 @@ var decideNextAction = (state) => {
   const latest = state.observations.at(-1);
   if (latest?.type === "agent.error") {
     if (shouldRequestRepairAfterPatchError(state)) {
+      if (state.goal.llmAvailable === false) {
+        return asyncSucceed({ type: "agent.finish", summary: buildErrorSummary(state) });
+      }
       return asyncSucceed(repairAction(state, "previous patch failed to apply"));
     }
     return asyncSucceed({ type: "agent.finish", summary: buildErrorSummary(state) });
@@ -1389,12 +1918,25 @@ var decideNextAction = (state) => {
   if (!planResponse) {
     const validationAction = nextValidationActionBeforePlanning(state);
     if (validationAction) return asyncSucceed(validationAction);
-    const contextAction = nextContextDiscoveryAction(state);
+    const contextAction = nextContextDiscoveryAction(state, state.goal.banditState);
     if (contextAction) return asyncSucceed(contextAction);
+    if (state.goal.llmAvailable === false) {
+      return asyncSucceed({
+        type: "agent.finish",
+        summary: "No LLM provider configured. Tool-only execution complete."
+      });
+    }
+    const signals = extractSignals(state);
+    const strategy = selectStrategy(
+      signals,
+      state.goal.patchStrategy,
+      state.goal.rewardHistory ?? [],
+      { sampleBeta: (a, b) => sampleBeta(a, b, Math.random), random: Math.random }
+    );
     return asyncSucceed({
       type: "llm.complete",
       purpose: "plan",
-      prompt: buildPlanningPrompt(state)
+      prompt: buildPlanningPrompt(state, strategy)
     });
   }
   if (isWritableMode(state.goal.mode)) {
@@ -1413,6 +1955,9 @@ var decideNextAction = (state) => {
       const validationAction = nextValidationActionAfterPatch(state);
       if (validationAction) return asyncSucceed(validationAction);
       if (shouldRequestRepairAfterValidation(state)) {
+        if (state.goal.llmAvailable === false) {
+          return asyncSucceed({ type: "agent.finish", summary: buildErrorSummary(state) });
+        }
         return asyncSucceed(repairAction(state, "validation failed after applying the generated patch"));
       }
       if (shouldAutoRollbackAfterFinalValidationFailure(state)) {
@@ -1632,13 +2177,22 @@ var actionToEffect = (action, state) => {
         )
       );
     case "llm.complete":
-      return asyncFlatMap(
-        service("llm"),
-        (llm) => asyncMap(
+      return asyncFlatMap(service("llm"), (llm) => {
+        if (!llm) {
+          return asyncFail({
+            _tag: "LLMError",
+            cause: "llm_unavailable: no LLM provider is configured"
+          });
+        }
+        return asyncMap(
           llm.complete({ purpose: action.purpose, prompt: action.prompt }),
-          (response) => ({ type: "llm.response", purpose: action.purpose, content: response.content })
-        )
-      );
+          (response) => ({
+            type: "llm.response",
+            purpose: action.purpose,
+            content: response.content
+          })
+        );
+      });
     case "patch.propose":
       return asyncSucceed({ type: "patch.proposed", patch: action.patch });
     case "patch.apply":
@@ -1821,7 +2375,265 @@ var invokeAction = (action, state, scope) => asyncFlatMap(
   })
 );
 
+// src/agent/core/llmBudget/config.ts
+var DEFAULTS = {
+  overshootFraction: 0.1,
+  enabled: true
+};
+var resolveBudgetConfig = (goalBudget, configBudget) => {
+  if (goalBudget === void 0 && configBudget === void 0) {
+    return void 0;
+  }
+  const merged = {
+    ...configBudget,
+    ...goalBudget
+  };
+  if (merged.tokenBudget === void 0) {
+    return void 0;
+  }
+  return {
+    tokenBudget: merged.tokenBudget,
+    overshootFraction: merged.overshootFraction ?? DEFAULTS.overshootFraction,
+    enabled: merged.enabled ?? DEFAULTS.enabled,
+    modelTiers: merged.modelTiers
+  };
+};
+var validateBudgetConfig = (config) => {
+  if (!Number.isFinite(config.tokenBudget) || config.tokenBudget <= 0) {
+    return `tokenBudget must be a positive finite number, got ${config.tokenBudget}`;
+  }
+  if (!Number.isFinite(config.overshootFraction) || config.overshootFraction < 0 || config.overshootFraction > 1) {
+    return `overshootFraction must be between 0 and 1 inclusive, got ${config.overshootFraction}`;
+  }
+  return void 0;
+};
+
+// src/agent/core/llmBudget/state.ts
+var initBudgetState = () => ({
+  totalInputTokens: 0,
+  totalOutputTokens: 0,
+  totalTokens: 0,
+  callCount: 0,
+  calls: []
+});
+var updateBudgetState = (state, usage, tier, confidence, estimated) => {
+  const totalInputTokens = state.totalInputTokens + usage.inputTokens;
+  const totalOutputTokens = state.totalOutputTokens + usage.outputTokens;
+  return {
+    totalInputTokens,
+    totalOutputTokens,
+    totalTokens: totalInputTokens + totalOutputTokens,
+    callCount: state.callCount + 1,
+    calls: [
+      ...state.calls,
+      { usage, tier, confidence, estimated }
+    ]
+  };
+};
+var budgetStatus = (state, config) => {
+  const { totalTokens } = state;
+  const { tokenBudget, overshootFraction } = config;
+  const hardCap = tokenBudget * (1 + overshootFraction);
+  if (totalTokens <= tokenBudget) {
+    return { type: "under" };
+  }
+  if (totalTokens <= hardCap) {
+    return { type: "warning", overage: totalTokens - tokenBudget };
+  }
+  return { type: "exceeded", overage: totalTokens - tokenBudget };
+};
+var budgetAllowsCall = (state, config) => {
+  return budgetStatus(state, config).type !== "exceeded";
+};
+
+// src/agent/core/llmBudget/estimation.ts
+var estimateTokens = (promptLength, responseLength) => ({
+  inputTokens: Math.ceil(promptLength / 4),
+  outputTokens: Math.ceil(responseLength / 4)
+});
+
+// src/agent/core/llmBudget/confidence.ts
+var HEDGING_PHRASES = [
+  "i think",
+  "maybe",
+  "perhaps",
+  "not sure",
+  "might be",
+  "could be"
+];
+var hasDiffBlock = (response) => {
+  if (response.includes("```diff")) return true;
+  const lines = response.split("\n");
+  return lines.some(
+    (line) => line.startsWith("---") || line.startsWith("+++")
+  );
+};
+var isConcise = (response) => response.length < 2e3;
+var referencesGoal = (response, goal) => {
+  const words = goal.split(/\s+/).filter((w) => w.length >= 3).map((w) => w.toLowerCase());
+  const responseLower = response.toLowerCase();
+  return words.some((word) => responseLower.includes(word));
+};
+var referencesReadFiles = (response, readFiles) => {
+  if (readFiles.length === 0) return false;
+  return readFiles.some((filePath) => response.includes(filePath));
+};
+var countHedgingPhrases = (response) => {
+  const responseLower = response.toLowerCase();
+  let count = 0;
+  for (const phrase of HEDGING_PHRASES) {
+    let idx = 0;
+    while (true) {
+      const found = responseLower.indexOf(phrase, idx);
+      if (found === -1) break;
+      count++;
+      idx = found + phrase.length;
+    }
+  }
+  return count;
+};
+var extractConfidenceSignals = (response, goal, readFiles) => ({
+  hasDiffBlock: hasDiffBlock(response),
+  isConcise: isConcise(response),
+  referencesGoal: referencesGoal(response, goal),
+  referencesReadFiles: referencesReadFiles(response, readFiles),
+  hedgingCount: countHedgingPhrases(response)
+});
+var estimateConfidence = (response, goal, readFiles) => {
+  const signals = extractConfidenceSignals(response, goal, readFiles);
+  let score = 0.35;
+  if (signals.hasDiffBlock) score += 0.2;
+  if (signals.isConcise) score += 0.15;
+  if (signals.referencesGoal) score += 0.15;
+  if (signals.referencesReadFiles) score += 0.15;
+  const hedgingPenalty = Math.min(signals.hedgingCount * 0.1, 0.3);
+  score -= hedgingPenalty;
+  score = Math.max(0, Math.min(1, score));
+  return { score, signals };
+};
+
+// src/agent/core/llmBudget/router.ts
+var DEFAULT_THRESHOLDS = {
+  goalLength: 500,
+  filesRead: 5,
+  searchMatches: 30,
+  repairAttempts: 1
+};
+var extractComplexitySignals = (state) => {
+  const observations = state.observations;
+  const goalLength = state.goal.text.length;
+  let filesRead = 0;
+  let searchMatches2 = 0;
+  let hasValidationErrors = false;
+  let repairAttempts = 0;
+  for (const obs of observations) {
+    switch (obs.type) {
+      case "fs.fileRead":
+        filesRead++;
+        break;
+      case "fs.searchResult":
+        searchMatches2 += obs.matches.length;
+        break;
+      case "shell.result":
+        if (obs.exitCode !== 0) {
+          hasValidationErrors = true;
+        }
+        break;
+      case "llm.response":
+        if (obs.purpose === "patch") {
+          repairAttempts++;
+        }
+        break;
+    }
+  }
+  return {
+    goalLength,
+    filesRead,
+    searchMatches: searchMatches2,
+    hasValidationErrors,
+    repairAttempts
+  };
+};
+var routeModel = (state, _budgetState, thresholds) => {
+  const t = thresholds ?? DEFAULT_THRESHOLDS;
+  const signals = extractComplexitySignals(state);
+  if (signals.goalLength >= t.goalLength || signals.filesRead >= t.filesRead || signals.searchMatches >= t.searchMatches || signals.hasValidationErrors || signals.repairAttempts >= t.repairAttempts) {
+    return "large";
+  }
+  return "small";
+};
+
+// src/agent/core/llmBudget/events.ts
+var makeBudgetUsageEvent = (usage, cumulative, tier, remaining) => ({
+  type: "budget.usage",
+  usage,
+  cumulative,
+  tier,
+  remaining,
+  at: Date.now()
+});
+var makeBudgetRoutedEvent = (tier, signals, resolvedProvider) => ({
+  type: "budget.routed",
+  tier,
+  signals,
+  resolvedProvider,
+  at: Date.now()
+});
+var makeBudgetConfidenceEvent = (score, signals, purpose) => ({
+  type: "budget.confidence",
+  score,
+  signals,
+  purpose,
+  at: Date.now()
+});
+var makeBudgetWarningEvent = (totalTokens, tokenBudget) => ({
+  type: "budget.warning",
+  totalTokens,
+  tokenBudget,
+  at: Date.now()
+});
+var makeBudgetExceededEvent = (totalTokens, tokenBudget, overshootFraction, hardCap) => ({
+  type: "budget.exceeded",
+  totalTokens,
+  tokenBudget,
+  overshootFraction,
+  hardCap,
+  at: Date.now()
+});
+
+// src/agent/core/llmBudget/persistence.ts
+var isValidRecord = (r) => {
+  if (r === null || typeof r !== "object") return false;
+  const rec = r;
+  return typeof rec.goalId === "string" && typeof rec.totalTokens === "number" && typeof rec.callCount === "number" && (rec.tier === "small" || rec.tier === "large") && typeof rec.confidence === "number" && typeof rec.timestamp === "number";
+};
+var parseLearningStore = (json) => {
+  try {
+    const parsed = JSON.parse(json);
+    if (parsed === null || typeof parsed !== "object") {
+      return { records: [] };
+    }
+    if (!Array.isArray(parsed.records)) {
+      return { records: [] };
+    }
+    const validRecords = parsed.records.filter(isValidRecord);
+    return { records: validRecords };
+  } catch {
+    return { records: [] };
+  }
+};
+var appendRunRecord = (store, record, maxRecords = 100) => {
+  const updated = [...store.records, record];
+  if (updated.length > maxRecords) {
+    return { records: updated.slice(updated.length - maxRecords) };
+  }
+  return { records: updated };
+};
+var serializeLearningStore = (store) => JSON.stringify(store, null, 2);
+
 // src/agent/core/runAgent.ts
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { dirname } from "path";
 var executeAction = (action, state, scope) => asyncFlatMap(
   nowMillis(),
   (startedAt) => asyncFlatMap(
@@ -1885,45 +2697,197 @@ var recordObservation = (next, observation) => asyncFlatMap(nowMillis(), (at) =>
   ];
   return emitAgentEvents(events);
 });
-var runLoop = (state, scope, runStartedAt) => {
+var buildBudgetExhaustedSummary = (state) => {
+  const observations = state.observations;
+  const fileReads = observations.filter((o) => o.type === "fs.fileRead").length;
+  const llmCalls = observations.filter((o) => o.type === "llm.response").length;
+  if (state.phase === "planning") {
+    const hasPlan = observations.some((o) => o.type === "llm.response");
+    if (!hasPlan) {
+      return "Budget exhausted before planning could complete. No plan was generated within the token budget.";
+    }
+  }
+  if (state.phase === "validating") {
+    return `Budget exhausted during validation. Completed ${state.steps} steps (${fileReads} file reads, ${llmCalls} LLM calls). In-progress non-LLM validation commands were allowed to complete.`;
+  }
+  return `Budget exhausted. Completed ${state.steps} steps (${fileReads} file reads, ${llmCalls} LLM calls) before reaching the token budget hard cap.`;
+};
+var extractReadFiles = (state) => state.observations.filter((o) => o.type === "fs.fileRead").map((o) => o.path);
+var LEARNING_STORE_PATH = ".brass/llm-budget.json";
+var persistLearningRecord = (state, budgetState) => asyncFold(
+  asyncInterruptible((_env, cb) => {
+    const filePath = `${state.goal.cwd}/${LEARNING_STORE_PATH}`;
+    const run = async () => {
+      const lastCall = budgetState.calls[budgetState.calls.length - 1];
+      const tier = lastCall?.tier ?? "small";
+      const confidence = budgetState.callCount > 0 ? budgetState.calls.reduce((sum, c) => sum + c.confidence, 0) / budgetState.callCount : 0;
+      const record = {
+        goalId: state.goal.id,
+        totalTokens: budgetState.totalTokens,
+        callCount: budgetState.callCount,
+        tier,
+        confidence,
+        timestamp: Date.now()
+      };
+      let existingJson = "";
+      try {
+        existingJson = await readFile(filePath, "utf8");
+      } catch {
+      }
+      const store = parseLearningStore(existingJson);
+      const updated = appendRunRecord(store, record);
+      const serialized = serializeLearningStore(updated);
+      await mkdir(dirname(filePath), { recursive: true });
+      await writeFile(filePath, serialized, "utf8");
+    };
+    run().then(
+      () => cb({ _tag: "Success", value: void 0 }),
+      (err) => cb({ _tag: "Failure", cause: { _tag: "Fail", error: { _tag: "FsError", operation: "persistLearningStore", cause: err } } })
+    );
+  }),
+  // On failure: swallow the error silently (Requirement 7.4)
+  () => asyncSucceed(void 0),
+  // On success: pass through
+  () => asyncSucceed(void 0)
+);
+var executeBudgetGatedLLMCall = (action, state, budgetState, budgetConfig, scope) => {
+  if (!budgetAllowsCall(budgetState, budgetConfig)) {
+    const hardCap = budgetConfig.tokenBudget * (1 + budgetConfig.overshootFraction);
+    const exceededEvent = makeBudgetExceededEvent(
+      budgetState.totalTokens,
+      budgetConfig.tokenBudget,
+      budgetConfig.overshootFraction,
+      hardCap
+    );
+    return asyncFlatMap(emitAgentEvent(exceededEvent), () => {
+      const finishObservation = {
+        type: "agent.done",
+        summary: buildBudgetExhaustedSummary(state)
+      };
+      return asyncSucceed({ observation: finishObservation, budgetState });
+    });
+  }
+  const tier = routeModel(state, budgetState);
+  const signals = extractComplexitySignals(state);
+  const resolvedProvider = budgetConfig.modelTiers?.[tier]?.provider;
+  const routedEvent = makeBudgetRoutedEvent(tier, signals, resolvedProvider);
+  return asyncFlatMap(
+    emitAgentEvent(routedEvent),
+    () => (
+      // Execute the LLM call through the normal action execution path
+      // We use the LLM service directly to capture the full LLMResponse with usage
+      asyncFlatMap(asyncSync((env) => env.llm), (llm) => {
+        if (!llm) {
+          return asyncFail({
+            _tag: "LLMError",
+            cause: "llm_unavailable: no LLM provider is configured"
+          });
+        }
+        return asyncFlatMap(
+          llm.complete({ purpose: action.purpose, prompt: action.prompt }),
+          (response) => {
+            const usage = response.usage ?? estimateTokens(
+              action.prompt.length,
+              response.content.length
+            );
+            const estimated = response.usage === void 0;
+            const readFiles = extractReadFiles(state);
+            const { score: confidence, signals: confidenceSignals } = estimateConfidence(
+              response.content,
+              state.goal.text,
+              readFiles
+            );
+            const newBudgetState = updateBudgetState(budgetState, usage, tier, confidence, estimated);
+            const remaining = Math.max(0, budgetConfig.tokenBudget - newBudgetState.totalTokens);
+            const usageEvent = makeBudgetUsageEvent(
+              usage,
+              { totalTokens: newBudgetState.totalTokens, callCount: newBudgetState.callCount },
+              tier,
+              remaining
+            );
+            const confidenceEvent = makeBudgetConfidenceEvent(confidence, confidenceSignals, action.purpose);
+            const events = [usageEvent, confidenceEvent];
+            if (newBudgetState.totalTokens > budgetConfig.tokenBudget) {
+              events.push(makeBudgetWarningEvent(newBudgetState.totalTokens, budgetConfig.tokenBudget));
+            }
+            return asyncFlatMap(emitAgentEvents(events), () => {
+              const observation = {
+                type: "llm.response",
+                purpose: action.purpose,
+                content: response.content
+              };
+              return asyncSucceed({ observation, budgetState: newBudgetState });
+            });
+          }
+        );
+      })
+    )
+  );
+};
+var runLoop = (state, budgetState, budgetConfig, scope, runStartedAt) => {
   if (isTerminal(state)) {
+    const persistEffect = budgetConfig !== void 0 && budgetState !== void 0 ? persistLearningRecord(state, budgetState) : asyncSucceed(void 0);
     return asyncFlatMap(
-      nowMillis(),
-      (at) => asyncFlatMap(
-        emitAgentEvent({
-          type: "agent.run.completed",
-          goal: state.goal,
-          status: runStatusFor(state.phase),
-          phase: state.phase,
-          steps: state.steps,
-          durationMs: at - runStartedAt,
-          at
-        }),
-        () => asyncSucceed(state)
+      persistEffect,
+      () => asyncFlatMap(
+        nowMillis(),
+        (at) => asyncFlatMap(
+          emitAgentEvent({
+            type: "agent.run.completed",
+            goal: state.goal,
+            status: runStatusFor(state.phase),
+            phase: state.phase,
+            steps: state.steps,
+            durationMs: at - runStartedAt,
+            at
+          }),
+          () => asyncSucceed(state)
+        )
       )
     );
   }
-  return asyncFlatMap(
-    decideNextAction(state),
-    (action) => asyncFlatMap(executeAction(action, state, scope), (observation) => {
+  return asyncFlatMap(decideNextAction(state), (action) => {
+    if (action.type === "llm.complete" && budgetConfig !== void 0 && budgetState !== void 0) {
+      return asyncFlatMap(
+        executeBudgetGatedLLMCall(action, state, budgetState, budgetConfig, scope),
+        (result) => {
+          const next = reduceAgentState(state, result.observation);
+          return asyncFlatMap(
+            recordObservation(next, result.observation),
+            () => runLoop(next, result.budgetState, budgetConfig, scope, runStartedAt)
+          );
+        }
+      );
+    }
+    return asyncFlatMap(executeAction(action, state, scope), (observation) => {
       const next = reduceAgentState(state, observation);
       return asyncFlatMap(
         recordObservation(next, observation),
-        () => runLoop(next, scope, runStartedAt)
+        () => runLoop(next, budgetState, budgetConfig, scope, runStartedAt)
       );
-    })
-  );
+    });
+  });
 };
-var runAgent = (runtime, goal) => withScopeAsync(
-  runtime,
-  (scope) => asyncFlatMap(
-    nowMillis(),
-    (startedAt) => asyncFlatMap(
-      emitAgentEvent({ type: "agent.run.started", goal, at: startedAt }),
-      () => runLoop(initialAgentState(goal), scope, startedAt)
+var runAgent = (runtime, goal, configBudget) => {
+  const budgetConfig = resolveBudgetConfig(goal.budget, configBudget);
+  if (budgetConfig !== void 0) {
+    const validationError = validateBudgetConfig(budgetConfig);
+    if (validationError !== void 0) {
+      return asyncFail({ _tag: "AgentLoopError", message: validationError });
+    }
+  }
+  const budgetState = budgetConfig !== void 0 ? initBudgetState() : void 0;
+  return withScopeAsync(
+    runtime,
+    (scope) => asyncFlatMap(
+      nowMillis(),
+      (startedAt) => asyncFlatMap(
+        emitAgentEvent({ type: "agent.run.started", goal, at: startedAt }),
+        () => runLoop(initialAgentState(goal), budgetState, budgetConfig, scope, startedAt)
+      )
     )
-  )
-);
+  );
+};
 
 // src/agent/core/config.ts
 var isAgentConfigMode = (value) => value === "read-only" || value === "propose" || value === "write" || value === "autonomous";
@@ -1946,6 +2910,243 @@ var goalForAgentPreset = (preset) => {
   }
 };
 
+// src/agent/core/hostProfile.ts
+var deepFreeze = (obj) => {
+  Object.freeze(obj);
+  for (const name of Object.getOwnPropertyNames(obj)) {
+    const value = obj[name];
+    if (value !== null && typeof value === "object" && !Object.isFrozen(value)) {
+      deepFreeze(value);
+    }
+  }
+  return obj;
+};
+
+// src/agent/core/hostSignals.ts
+var MAX_ENV_KEYS = 256;
+var collectHostSignals = (input) => {
+  const signals = [];
+  try {
+    for (const arg of input.argv) {
+      signals.push({ source: "argv", value: arg });
+    }
+  } catch {
+  }
+  try {
+    const keys = Object.keys(input.env).sort();
+    const limit = Math.min(keys.length, MAX_ENV_KEYS);
+    for (let i = 0; i < limit; i++) {
+      signals.push({ source: "env-key", value: keys[i] });
+    }
+  } catch {
+  }
+  try {
+    signals.push({
+      source: "stdio",
+      value: input.stdoutIsTTY ? "stdout:tty" : "stdout:pipe"
+    });
+    signals.push({
+      source: "stdio",
+      value: input.stdinIsTTY ? "stdin:tty" : "stdin:pipe"
+    });
+    if (input.ttyColumns !== void 0) {
+      signals.push({ source: "stdio", value: `columns:${input.ttyColumns}` });
+    }
+  } catch {
+  }
+  try {
+    if (input.parentProcessName !== void 0) {
+      signals.push({ source: "parent-process", value: input.parentProcessName });
+    }
+  } catch {
+  }
+  try {
+    for (const marker of input.workspaceMarkers) {
+      signals.push({ source: "workspace-marker", value: marker });
+    }
+  } catch {
+  }
+  try {
+    if (input.stdinFirstLine !== void 0 && !input.stdinIsTTY) {
+      signals.push({ source: "protocol-handshake", value: input.stdinFirstLine });
+    }
+  } catch {
+  }
+  try {
+    for (const configPath of input.configPaths) {
+      signals.push({ source: "config", value: configPath });
+    }
+  } catch {
+  }
+  return deepFreeze(signals);
+};
+
+// src/agent/core/hostInference.ts
+var CI_INDICATORS = [
+  "CI",
+  "GITHUB_ACTIONS",
+  "JENKINS_URL",
+  "CIRCLECI",
+  "TRAVIS",
+  "GITLAB_CI",
+  "BUILDKITE",
+  "TF_BUILD"
+];
+var inferTransport = (signals) => {
+  const hasProtocolMcp = signals.some(
+    (s) => s.source === "protocol-handshake" && s.value.toLowerCase().includes("mcp")
+  );
+  if (hasProtocolMcp) return "mcp";
+  const extensionMarkers = [".vscode", ".cursor", ".kiro"];
+  const hasExtensionMarker = signals.some(
+    (s) => s.source === "workspace-marker" && extensionMarkers.some((m) => s.value.toLowerCase().includes(m))
+  );
+  const hasExtensionConfig = signals.some(
+    (s) => s.source === "config" && extensionMarkers.some((m) => s.value.toLowerCase().includes(m))
+  );
+  if (hasExtensionMarker || hasExtensionConfig) return "extension";
+  const hasCiEnv = signals.some(
+    (s) => s.source === "env-key" && CI_INDICATORS.some((ci) => s.value === ci)
+  );
+  if (hasCiEnv) return "ci";
+  const stdoutIsTty = signals.some(
+    (s) => s.source === "stdio" && s.value === "stdout:tty"
+  );
+  if (stdoutIsTty) return "terminal";
+  const stdoutIsPipe = signals.some(
+    (s) => s.source === "stdio" && s.value === "stdout:pipe"
+  );
+  if (stdoutIsPipe) return "stdio";
+  return "unknown";
+};
+var inferCapabilities = (signals, transport) => {
+  const hasOwnLLM = signals.some(
+    (s) => s.source === "env-key" && (s.value.toUpperCase().includes("LLM") || s.value.toUpperCase().includes("AI_API")) || s.source === "protocol-handshake" && s.value.toLowerCase().includes("llm")
+  );
+  const wantsJson = transport === "stdio" || transport === "mcp";
+  const supportsStreamingEvents = transport === "terminal" || transport === "mcp" || transport === "extension";
+  const supportsMcp = transport === "mcp";
+  const stdinIsTty = signals.some(
+    (s) => s.source === "stdio" && s.value === "stdin:tty"
+  );
+  const canAskApproval = stdinIsTty || transport === "extension" || transport === "mcp";
+  const ttyColumnsSignal = signals.find(
+    (s) => s.source === "stdio" && s.value.startsWith("columns:")
+  );
+  const ttyColumns = ttyColumnsSignal ? parseInt(ttyColumnsSignal.value.slice("columns:".length), 10) : void 0;
+  const stdoutIsTty = signals.some(
+    (s) => s.source === "stdio" && s.value === "stdout:tty"
+  );
+  const canRenderDiff = stdoutIsTty && ttyColumns !== void 0 && ttyColumns >= 80 || transport === "extension";
+  const canApplyPatch = transport === "extension" || transport === "mcp";
+  const interactiveTty = stdoutIsTty;
+  return {
+    hasOwnLLM,
+    wantsJson,
+    supportsStreamingEvents,
+    supportsMcp,
+    canAskApproval,
+    canRenderDiff,
+    canApplyPatch,
+    interactiveTty
+  };
+};
+var inferConstraints = (capabilities, transport) => {
+  const readOnlyByDefault = transport === "ci";
+  const patchPreviewRequired = capabilities.canRenderDiff === true && capabilities.canApplyPatch === false;
+  const requireNoNetwork = false;
+  return {
+    readOnlyByDefault,
+    patchPreviewRequired,
+    requireNoNetwork
+  };
+};
+var IDENTITY_PATTERNS = [
+  {
+    name: "cursor",
+    match: (signals) => {
+      if (signals.some((s) => s.source === "workspace-marker" && s.value.toLowerCase().includes(".cursor"))) {
+        return 0.8;
+      }
+      return 0;
+    }
+  },
+  {
+    name: "vscode",
+    match: (signals) => {
+      if (signals.some((s) => s.source === "workspace-marker" && s.value.toLowerCase().includes(".vscode"))) {
+        return 0.8;
+      }
+      return 0;
+    }
+  },
+  {
+    name: "kiro",
+    match: (signals) => {
+      if (signals.some((s) => s.source === "workspace-marker" && s.value.toLowerCase().includes(".kiro"))) {
+        return 0.8;
+      }
+      if (signals.some((s) => s.source === "env-key" && s.value.startsWith("KIRO_"))) {
+        return 0.7;
+      }
+      return 0;
+    }
+  },
+  {
+    name: "codex",
+    match: (signals) => {
+      if (signals.some((s) => s.source === "parent-process" && s.value.toLowerCase().includes("codex"))) {
+        return 0.9;
+      }
+      if (signals.some((s) => s.source === "env-key" && s.value.startsWith("CODEX_"))) {
+        return 0.7;
+      }
+      return 0;
+    }
+  },
+  {
+    name: "claude-code",
+    match: (signals) => {
+      if (signals.some((s) => s.source === "parent-process" && s.value.toLowerCase().includes("claude"))) {
+        return 0.9;
+      }
+      return 0;
+    }
+  }
+];
+var inferOptionalIdentity = (signals) => {
+  let bestName;
+  let bestConfidence = 0;
+  for (const pattern of IDENTITY_PATTERNS) {
+    const confidence = pattern.match(signals);
+    if (confidence > bestConfidence) {
+      bestConfidence = confidence;
+      bestName = pattern.name;
+    }
+  }
+  if (bestName === void 0 || bestConfidence <= 0) {
+    return void 0;
+  }
+  return {
+    name: bestName,
+    confidence: Math.round(bestConfidence * 100) / 100
+  };
+};
+var buildHostProfile = (input) => {
+  const signals = collectHostSignals(input);
+  const transport = inferTransport(signals);
+  const capabilities = inferCapabilities(signals, transport);
+  const constraints = inferConstraints(capabilities, transport);
+  const identity = inferOptionalIdentity(signals);
+  return deepFreeze({
+    transport,
+    capabilities,
+    constraints,
+    identity,
+    evidence: signals
+  });
+};
+
 // src/agent/tools/permissions.ts
 var DEFAULT_SAFE_SHELL_PATTERNS = [
   "npm test",
@@ -2221,8 +3422,8 @@ var parseRipgrep = (stdout) => stdout.split("\n").filter(Boolean).map((line) =>
 var makeNodeFileSystem = (shell) => ({
   readFile: (path) => fromPromiseAbortable(
     async (signal) => {
-      const { readFile } = await dynamicImport2("node:fs/promises");
-      return readFile(path, { encoding: "utf8", signal });
+      const { readFile: readFile2 } = await dynamicImport2("node:fs/promises");
+      return readFile2(path, { encoding: "utf8", signal });
     },
     (cause) => ({ _tag: "FsError", operation: "readFile", cause })
   ),
@@ -2556,6 +3757,9 @@ var validateAgentConfig = (config, sourcePath) => {
       config.batch.goals.forEach((goal, index) => validateBatchGoal(goal, `config.batch.goals[${index}]`));
     }
   }
+  if (config.budget !== void 0) {
+    if (!isRecord3(config.budget)) throw new Error("config.budget must be an object.");
+  }
   return config;
 };
 var isFile = async (path) => {
@@ -2580,8 +3784,8 @@ var findConfigPath = async (cwd) => {
   }
 };
 var readConfigFile = async (path) => {
-  const { readFile } = await dynamicImport3("node:fs/promises");
-  const raw = String(await readFile(path, "utf8")).replace(/^\uFEFF/, "");
+  const { readFile: readFile2 } = await dynamicImport3("node:fs/promises");
+  const raw = String(await readFile2(path, "utf8")).replace(/^\uFEFF/, "");
   try {
     return validateAgentConfig(JSON.parse(raw), path);
   } catch (error) {
@@ -2737,7 +3941,7 @@ var makeFakeLLM = (options = {}) => ({
 
 // src/agent/node/nodeWorkspaceDiscovery.ts
 import { existsSync, statSync } from "fs";
-import { dirname, join, resolve } from "path";
+import { dirname as dirname2, join, resolve } from "path";
 var WORKSPACE_MARKERS = [
   { name: ".brass-agent.json", kind: "file" },
   { name: "brass-agent.config.json", kind: "file" },
@@ -2793,7 +3997,7 @@ var discoverNodeWorkspaceRoot = (cwd, options = {}) => {
         changed: current !== inputCwd
       };
     }
-    const parent = dirname(current);
+    const parent = dirname2(current);
     if (parent === current) {
       return {
         inputCwd,
@@ -2809,6 +4013,7 @@ export {
   initialAgentState,
   reduceAgentState,
   isTerminal,
+  sampleBeta,
   extractLikelyFilePaths,
   deriveContextSearchQueries,
   describeContextDiscovery,
@@ -2847,6 +4052,8 @@ export {
   responseLanguageName,
   describeLanguagePolicy,
   spanishLike,
+  selectStrategy,
+  extractSignals,
   decideNextAction,
   nowMillis,
   emitAgentEvent,
@@ -2868,6 +4075,14 @@ export {
   AGENT_CONFIG_FILE_NAMES,
   isAgentPreset,
   goalForAgentPreset,
+  deepFreeze,
+  collectHostSignals,
+  CI_INDICATORS,
+  inferTransport,
+  inferCapabilities,
+  inferConstraints,
+  inferOptionalIdentity,
+  buildHostProfile,
   makeConfiguredPermissions,
   defaultPermissions,
   autoApproveApprovals,