brass-runtime 1.12.1 → 1.13.3

package/dist/chunk-HRVX2IYW.js

@@ -0,0 +1,2879 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkTGOMLZ65js = require('./chunk-TGOMLZ65.js');
+
+// src/agent/core/state.ts
+var initialAgentState = (goal) => ({
+  goal,
+  phase: "boot",
+  observations: [],
+  errors: [],
+  steps: 0
+});
+
+// src/agent/core/reducer.ts
+var MAX_AGENT_STEPS = 60;
+var phaseAfter = (current, observation) => {
+  switch (observation.type) {
+    case "agent.done":
+      return "done";
+    case "agent.error":
+      return current;
+    case "fs.fileRead":
+    case "fs.exists":
+    case "fs.searchResult":
+      return "discovering";
+    case "shell.result":
+      return "validating";
+    case "llm.response":
+      return "planning";
+    case "patch.proposed":
+      return "proposing";
+    case "patch.applied":
+    case "patch.rolledBack":
+      return "validating";
+  }
+};
+var reduceAgentState = (state, observation) => {
+  const steps = state.steps + 1;
+  const phase = steps >= MAX_AGENT_STEPS ? "failed" : phaseAfter(state.phase, observation);
+  return {
+    ...state,
+    phase,
+    observations: [...state.observations, observation],
+    errors: observation.type === "agent.error" ? [...state.errors, observation.error] : state.errors,
+    steps
+  };
+};
+var isTerminal = (state) => state.phase === "done" || state.phase === "failed" || state.steps >= MAX_AGENT_STEPS;
+
+// src/agent/core/contextDiscovery.ts
+var DEFAULT_CONTEXT_GLOBS = [
+  "*.ts",
+  "*.tsx",
+  "*.js",
+  "*.jsx",
+  "*.mts",
+  "*.cts",
+  "*.mjs",
+  "*.cjs",
+  "*.json",
+  "*.md",
+  "*.yml",
+  "*.yaml"
+];
+var DEFAULT_MAX_SEARCH_QUERIES = 3;
+var DEFAULT_MAX_FILES = 4;
+var DEFAULT_MAX_SEARCH_RESULTS = 40;
+var PATH_EXTENSIONS = [
+  "tsx",
+  "jsx",
+  "mts",
+  "cts",
+  "mjs",
+  "cjs",
+  "json",
+  "yaml",
+  "html",
+  "scss",
+  "ts",
+  "js",
+  "md",
+  "yml",
+  "css"
+];
+var PATH_EXTENSION_PATTERN = [...PATH_EXTENSIONS].sort((a, b) => b.length - a.length).join("|");
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "about",
+  "after",
+  "agent",
+  "because",
+  "before",
+  "brass",
+  "cannot",
+  "console",
+  "could",
+  "describe",
+  "error",
+  "expect",
+  "expected",
+  "exit",
+  "fail",
+  "failed",
+  "failing",
+  "failure",
+  "find",
+  "from",
+  "goal",
+  "have",
+  "into",
+  "name",
+  "node",
+  "only",
+  "package",
+  "please",
+  "process",
+  "repo",
+  "runtime",
+  "script",
+  "scripts",
+  "should",
+  "test",
+  "tests",
+  "that",
+  "this",
+  "throw",
+  "throws",
+  "undefined",
+  "using",
+  "with",
+  "previous",
+  "user",
+  "unrelated",
+  "validation",
+  "validacion",
+  "validaci\xF3n",
+  "discovered",
+  "remaining",
+  "rollback",
+  "rollbacks",
+  "strategy",
+  "proposed",
+  "request",
+  "relevant",
+  "context",
+  "summary",
+  "latest",
+  "patch",
+  "applied",
+  "configured",
+  "package",
+  "manager",
+  "commands",
+  "none",
+  "notes",
+  "usable",
+  "script",
+  "found",
+  "quality",
+  "loop",
+  "repairs",
+  "attempts",
+  "enabled",
+  "depth",
+  "workspace",
+  "inspect",
+  "inspection",
+  "diagnosis",
+  "diagnostic",
+  "diagn\xF3stico",
+  "plan",
+  "technology",
+  "stack",
+  "deployment",
+  "configuration",
+  "management",
+  "dependencies",
+  "observability",
+  "plugin",
+  "plugins",
+  "framework",
+  "serverless",
+  "commonjs",
+  "typescript",
+  "javascript",
+  "nodejs"
+]);
+var clampPositiveInteger = (value, fallback) => {
+  if (value === void 0 || !Number.isFinite(value)) return fallback;
+  return Math.max(0, Math.floor(value));
+};
+var configFor = (state) => ({
+  enabled: _nullishCoalesce(_optionalChain([state, 'access', _ => _.goal, 'access', _2 => _2.context, 'optionalAccess', _3 => _3.enabled]), () => ( true)),
+  maxSearchQueries: clampPositiveInteger(_optionalChain([state, 'access', _4 => _4.goal, 'access', _5 => _5.context, 'optionalAccess', _6 => _6.maxSearchQueries]), DEFAULT_MAX_SEARCH_QUERIES),
+  maxFiles: clampPositiveInteger(_optionalChain([state, 'access', _7 => _7.goal, 'access', _8 => _8.context, 'optionalAccess', _9 => _9.maxFiles]), DEFAULT_MAX_FILES),
+  maxSearchResults: clampPositiveInteger(_optionalChain([state, 'access', _10 => _10.goal, 'access', _11 => _11.context, 'optionalAccess', _12 => _12.maxSearchResults]), DEFAULT_MAX_SEARCH_RESULTS),
+  globs: _nullishCoalesce(_optionalChain([state, 'access', _13 => _13.goal, 'access', _14 => _14.context, 'optionalAccess', _15 => _15.globs]), () => ( DEFAULT_CONTEXT_GLOBS)),
+  excludeGlobs: _nullishCoalesce(_optionalChain([state, 'access', _16 => _16.goal, 'access', _17 => _17.context, 'optionalAccess', _18 => _18.excludeGlobs]), () => ( []))
+});
+var normalizeSlashes = (value) => value.replace(/\\/g, "/");
+var trimLeadingDotSlash = (value) => value.replace(/^(?:\.\/)+/, "");
+var stripLocationSuffix = (value) => value.replace(/(?:\d+){1,2}$/, "");
+var LEADING_WRAPPING_CHARS = /* @__PURE__ */ new Set([" ", "	", "\n", "\r", "(", "'", '"', "`", "<", "["]);
+var TRAILING_WRAPPING_CHARS = /* @__PURE__ */ new Set([" ", "	", "\n", "\r", ")", "'", '"', ">", ",", "]"]);
+var stripWrappingPunctuation = (value) => {
+  let start = 0;
+  let end = value.length;
+  while (start < end && LEADING_WRAPPING_CHARS.has(value[start])) {
+    start += 1;
+  }
+  while (end > start && TRAILING_WRAPPING_CHARS.has(value[end - 1])) {
+    end -= 1;
+  }
+  return value.slice(start, end);
+};
+var PROSE_FILE_LIKE_WORDS = /* @__PURE__ */ new Set([
+  "Node.js",
+  "CommonJS.js",
+  "TypeScript.ts",
+  "JavaScript.js"
+]);
+var isProseFileLikeWord = (path) => PROSE_FILE_LIKE_WORDS.has(path);
+var isIgnoredPath = (path) => {
+  const segments = path.split("/");
+  return segments.some(
+    (segment) => segment === "node_modules" || segment === ".git" || segment === "dist" || segment === "build" || segment === "coverage" || segment === ".next" || segment === ".turbo" || segment === ".cache"
+  );
+};
+var hasSupportedExtension = (path) => PATH_EXTENSIONS.some((ext) => path.toLowerCase().endsWith(`.${ext}`));
+var toWorkspaceRelativePath = (cwd, raw) => {
+  const cwdNormalized = normalizeSlashes(cwd).replace(/\/+$/, "");
+  let path = stripLocationSuffix(stripWrappingPunctuation(normalizeSlashes(raw.trim())));
+  if (path.startsWith("file://")) path = path.slice("file://".length);
+  if (path.startsWith(`${cwdNormalized}/`)) path = path.slice(cwdNormalized.length + 1);
+  if (path === cwdNormalized) return void 0;
+  path = trimLeadingDotSlash(path);
+  if (!path || path.startsWith("/") || /^[A-Za-z]:\//.test(path)) return void 0;
+  if (path.includes("\0") || path.split("/").includes("..")) return void 0;
+  if (isProseFileLikeWord(path)) return void 0;
+  if (isIgnoredPath(path)) return void 0;
+  if (!hasSupportedExtension(path)) return void 0;
+  return path;
+};
+var globToRegExp = (glob) => {
+  const escaped = glob.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "::DOUBLE_STAR::").replace(/\*/g, "[^/]*").replace(/::DOUBLE_STAR::/g, ".*");
+  return new RegExp(`^${escaped}$`);
+};
+var matchesAnyExclude = (path, excludeGlobs) => excludeGlobs.some((glob) => globToRegExp(trimLeadingDotSlash(normalizeSlashes(glob))).test(path));
+var searchGlobsFor = (config) => [
+  ...config.globs,
+  ...config.excludeGlobs.map((glob) => `!${glob}`)
+];
+var unique = (values) => {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const value of values) {
+    if (seen.has(value)) continue;
+    seen.add(value);
+    out.push(value);
+  }
+  return out;
+};
+var shellText = (state) => state.observations.filter((obs) => obs.type === "shell.result").map((obs) => [obs.command.join(" "), obs.stdout.slice(-12e3), obs.stderr.slice(-12e3)].join("\n")).join("\n");
+var discoveryCorpus = (state) => [state.goal.text, shellText(state)].filter(Boolean).join("\n");
+var extractLikelyFilePaths = (state) => {
+  const config = configFor(state);
+  const corpus = discoveryCorpus(state);
+  const pathPattern = new RegExp(
+    `(?:file://)?(?:[A-Za-z]:)?[./\\\\]?(?:[A-Za-z0-9_@.-]+[/\\\\])*[A-Za-z0-9_@.-]+\\.(?:${PATH_EXTENSIONS.join("|")})(?::\\d+){0,2}`,
+    "g"
+  );
+  const matches = _nullishCoalesce(corpus.match(pathPattern), () => ( []));
+  return unique(matches.map((match) => toWorkspaceRelativePath(state.goal.cwd, match)).filter((path) => Boolean(path)).filter((path) => !matchesAnyExclude(path, config.excludeGlobs)));
+};
+var searchedQueries = (state) => unique(state.observations.filter((obs) => obs.type === "fs.searchResult").map((obs) => obs.query));
+var readPaths = (state) => unique(state.observations.filter((obs) => obs.type === "fs.fileRead").map((obs) => obs.path));
+var existsObservations = (state) => state.observations.filter((obs) => obs.type === "fs.exists");
+var alreadyRead = (state, path) => readPaths(state).includes(path);
+var knownMissing = (state, path) => existsObservations(state).some((obs) => obs.path === path && !obs.exists);
+var knownExisting = (state, path) => existsObservations(state).some((obs) => obs.path === path && obs.exists);
+var hasExistenceProbe = (state, path) => existsObservations(state).some((obs) => obs.path === path);
+var searchMatches = (state, maxSearchResults) => state.observations.filter((obs) => obs.type === "fs.searchResult").flatMap((obs) => obs.matches).slice(0, maxSearchResults);
+var pathsFromSearchResults = (state, maxSearchResults) => {
+  const config = configFor(state);
+  return unique(searchMatches(state, maxSearchResults).map((match) => toWorkspaceRelativePath(state.goal.cwd, match.path)).filter((path) => Boolean(path)).filter((path) => !matchesAnyExclude(path, config.excludeGlobs)));
+};
+var tokenScore = (token) => {
+  let score = token.length;
+  if (/^[A-Z][A-Za-z0-9_]+$/.test(token)) score += 8;
+  if (/[A-Z][a-z]+[A-Z]/.test(token)) score += 6;
+  if (/^[a-z]+[A-Z]/.test(token)) score += 6;
+  if (/Error$/.test(token)) score += 4;
+  if (/^[A-Za-z_][A-Za-z0-9_]*$/.test(token)) score += 2;
+  return score;
+};
+var extractQuotedSignals = (text) => {
+  const out = [];
+  const regex = /["'`]([^"'`\n]{4,80})["'`]/g;
+  let match;
+  while (match = regex.exec(text)) {
+    const value = _optionalChain([match, 'access', _19 => _19[1], 'optionalAccess', _20 => _20.trim, 'call', _21 => _21()]);
+    if (!value) continue;
+    if (/\s{3,}/.test(value)) continue;
+    if (/^[A-Za-z0-9_./:-]+$/.test(value)) out.push(value);
+  }
+  return out;
+};
+var deriveContextSearchQueries = (state) => {
+  const corpus = discoveryCorpus(state);
+  const quoted = extractQuotedSignals(corpus);
+  const tokens = _nullishCoalesce(corpus.match(/[A-Za-z_][A-Za-z0-9_]{3,}/g), () => ( []));
+  const candidates = unique([...quoted, ...tokens]).map((value) => value.trim()).filter((value) => value.length >= 4 && value.length <= 80).filter((value) => !value.includes("/")).filter((value) => !STOP_WORDS.has(value.toLowerCase())).filter((value) => !/^\d+$/.test(value)).filter((value) => /^[A-Za-z0-9_]+$/.test(value));
+  return [...candidates].sort((a, b) => tokenScore(b) - tokenScore(a)).slice(0, 8);
+};
+var contextFileReadCount = (state) => readPaths(state).filter((path) => path !== "package.json").length;
+var describeContextDiscovery = (state) => {
+  const summary = summarizeContextDiscovery(state);
+  if (!summary.enabled) return "Context discovery: disabled.";
+  const searched = summary.searchedQueries.join(", ") || "none";
+  const pending = summary.pendingQueries.slice(0, 5).join(", ") || "none";
+  const paths = summary.discoveredPaths.slice(0, 8).join(", ") || "none";
+  const read = summary.readPaths.filter((path) => path !== "package.json").join(", ") || "none";
+  return [
+    `Context discovery: searched queries: ${searched}.`,
+    `Pending queries: ${pending}.`,
+    `Discovered paths: ${paths}.`,
+    `Read context files: ${read}.`,
+    `Remaining file budget: ${summary.remainingFileBudget}.`
+  ].join(" ");
+};
+var summarizeContextDiscovery = (state) => {
+  const config = configFor(state);
+  const searched = searchedQueries(state);
+  const queries = deriveContextSearchQueries(state);
+  const directPaths = extractLikelyFilePaths(state);
+  const resultPaths = pathsFromSearchResults(state, config.maxSearchResults);
+  const read = readPaths(state);
+  const remainingFileBudget = Math.max(0, config.maxFiles - contextFileReadCount(state));
+  return {
+    enabled: config.enabled,
+    searchedQueries: searched,
+    pendingQueries: queries.filter((query) => !searched.includes(query)),
+    discoveredPaths: unique([...directPaths, ...resultPaths]),
+    readPaths: read,
+    remainingFileBudget
+  };
+};
+var nextContextDiscoveryAction = (state) => {
+  const config = configFor(state);
+  if (!config.enabled) return void 0;
+  if (_optionalChain([state, 'access', _22 => _22.goal, 'access', _23 => _23.initialPatch, 'optionalAccess', _24 => _24.trim, 'call', _25 => _25()])) return void 0;
+  const searched = searchedQueries(state);
+  const readsRemaining = Math.max(0, config.maxFiles - contextFileReadCount(state));
+  const directPaths = extractLikelyFilePaths(state);
+  const resultPaths = pathsFromSearchResults(state, config.maxSearchResults);
+  if (readsRemaining > 0) {
+    const nextPath = [...directPaths, ...resultPaths].find(
+      (path) => path !== "package.json" && !alreadyRead(state, path) && !knownMissing(state, path)
+    );
+    if (nextPath) {
+      if (!hasExistenceProbe(state, nextPath)) {
+        return { type: "fs.exists", path: nextPath };
+      }
+      if (knownExisting(state, nextPath)) {
+        return { type: "fs.readFile", path: nextPath };
+      }
+    }
+  }
+  if (searched.length >= config.maxSearchQueries) return void 0;
+  const nextQuery = deriveContextSearchQueries(state).find((query) => !searched.includes(query));
+  if (!nextQuery) return void 0;
+  return {
+    type: "fs.searchText",
+    query: nextQuery,
+    globs: searchGlobsFor(config)
+  };
+};
+
+// src/agent/core/projectProfile.ts
+var PROJECT_PROFILE_PROBES = [
+  "Cargo.toml",
+  "Cargo.lock",
+  "src-tauri/tauri.conf.json",
+  "src-tauri/Cargo.toml",
+  "apps/desktop/package.json",
+  "apps/desktop/src-tauri/tauri.conf.json",
+  "apps/desktop/src-tauri/Cargo.toml",
+  "bridges/whatsmeow-bridge/Cargo.toml",
+  "bridges/whatsmeow-bridge/package.json",
+  "apps",
+  "packages",
+  "bridges",
+  "turbo.json",
+  "nx.json",
+  "pnpm-workspace.yaml"
+];
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var readPackageJsonObservation = (state) => [...state.observations].reverse().find((obs) => obs.type === "fs.fileRead" && obs.path === "package.json");
+var parsePackageJson = (state) => {
+  const observation = readPackageJsonObservation(state);
+  if (!observation) return void 0;
+  try {
+    const parsed = JSON.parse(observation.content);
+    return isRecord(parsed) ? parsed : void 0;
+  } catch (e) {
+    return void 0;
+  }
+};
+var packageScripts = (pkg) => {
+  if (!pkg || !isRecord(pkg.scripts)) return {};
+  const scripts = {};
+  for (const [name, value] of Object.entries(pkg.scripts)) {
+    if (typeof value === "string") scripts[name] = value;
+  }
+  return scripts;
+};
+var markerExists = (state, path) => state.observations.some((obs) => obs.type === "fs.exists" && obs.path === path && obs.exists);
+var hasDependencyName = (pkg, dependency) => {
+  const collections = [_optionalChain([pkg, 'optionalAccess', _26 => _26.dependencies]), _optionalChain([pkg, 'optionalAccess', _27 => _27.devDependencies]), _optionalChain([pkg, 'optionalAccess', _28 => _28.optionalDependencies])];
+  return collections.some((collection) => isRecord(collection) && typeof collection[dependency] === "string");
+};
+var hasAnyDependency = (pkg, dependencies) => dependencies.some((dependency) => hasDependencyName(pkg, dependency));
+var unique2 = (values) => [...new Set(values)];
+var scriptNamesMatching = (scripts, patterns) => {
+  const matches = [];
+  for (const name of Object.keys(scripts)) {
+    if (patterns.some((pattern) => pattern.test(name))) matches.push(name);
+  }
+  return matches;
+};
+var projectProfileProbePending = (state) => PROJECT_PROFILE_PROBES.find((path) => !state.observations.some((obs) => obs.type === "fs.exists" && obs.path === path));
+var discoverProjectProfile = (state, packageManager) => {
+  const pkg = parsePackageJson(state);
+  const scripts = packageScripts(pkg);
+  const scriptNames = Object.keys(scripts);
+  const markers = PROJECT_PROFILE_PROBES.filter((path) => markerExists(state, path));
+  const stacks = [];
+  const notes = [];
+  if (pkg) stacks.push("node");
+  const rustPresent = markerExists(state, "Cargo.toml") || markerExists(state, "Cargo.lock") || markerExists(state, "src-tauri/Cargo.toml") || markerExists(state, "apps/desktop/src-tauri/Cargo.toml") || markerExists(state, "bridges/whatsmeow-bridge/Cargo.toml");
+  if (rustPresent) stacks.push("rust");
+  const tauriPresent = markerExists(state, "src-tauri/tauri.conf.json") || markerExists(state, "apps/desktop/src-tauri/tauri.conf.json") || hasAnyDependency(pkg, ["@tauri-apps/api", "@tauri-apps/cli"]) || scriptNames.some((name) => name.includes("tauri"));
+  if (tauriPresent) stacks.push("tauri");
+  const desktopPresent = markerExists(state, "apps/desktop/package.json") || scriptNames.some((name) => name.includes("desktop"));
+  if (desktopPresent) stacks.push("desktop");
+  const bridgePresent = markerExists(state, "bridges") || markerExists(state, "bridges/whatsmeow-bridge/Cargo.toml") || markerExists(state, "bridges/whatsmeow-bridge/package.json") || scriptNames.some((name) => name.includes("bridge"));
+  if (bridgePresent) stacks.push("bridge");
+  const monorepoPresent = markerExists(state, "pnpm-workspace.yaml") || markerExists(state, "turbo.json") || markerExists(state, "nx.json") || markerExists(state, "apps") || markerExists(state, "packages") || markerExists(state, "bridges") || Array.isArray(_optionalChain([pkg, 'optionalAccess', _29 => _29.workspaces]));
+  if (monorepoPresent) stacks.push("monorepo");
+  const candidateValidationScripts = unique2([
+    ...scriptNamesMatching(scripts, [
+      /^repo:check$/,
+      /^check$/,
+      /(^|:)check($|:)/,
+      /(^|:)doctor($|:)/,
+      /(^|:)health($|:)/,
+      /(^|:)verify($|:)/,
+      /(^|:)validate($|:)/,
+      /(^|:)ci($|:)/
+    ])
+  ]);
+  const candidateValidationCommands = candidateValidationScripts.map((script) => {
+    if (packageManager === "npm" && script === "test") return "npm test";
+    if (packageManager === "pnpm" && script === "test") return "pnpm test";
+    if (packageManager === "yarn" && script === "test") return "yarn test";
+    if (packageManager === "bun") return `bun run ${script}`;
+    return `${packageManager} run ${script}`;
+  });
+  if (rustPresent && markerExists(state, "Cargo.toml")) {
+    candidateValidationCommands.push("cargo check");
+  }
+  if (candidateValidationScripts.length > 0) {
+    notes.push(`Likely health/check scripts: ${candidateValidationScripts.slice(0, 5).join(", ")}.`);
+  }
+  if (tauriPresent) notes.push("Tauri markers detected; desktop validation may involve npm scripts plus Cargo checks.");
+  if (bridgePresent) notes.push("Bridge markers detected; bridge-specific doctor/check scripts may be relevant.");
+  if (monorepoPresent) notes.push("Workspace/monorepo markers detected; prefer repo-level check scripts when available.");
+  const kind = tauriPresent && rustPresent && pkg ? "tauri" : pkg && rustPresent ? "mixed" : rustPresent ? "rust" : pkg ? "node" : "unknown";
+  const workspaceStyle = monorepoPresent && pkg && rustPresent ? "mixed" : monorepoPresent ? "monorepo" : pkg ? "single-package" : "unknown";
+  return {
+    kind,
+    packageManager,
+    stacks: unique2(stacks),
+    workspaceStyle,
+    markers,
+    scripts: scriptNames,
+    candidateValidationScripts,
+    candidateValidationCommands: unique2(candidateValidationCommands),
+    notes
+  };
+};
+var describeProjectProfile = (profile) => {
+  const stacks = profile.stacks.length > 0 ? profile.stacks.join(", ") : "none detected";
+  const markers = profile.markers.length > 0 ? profile.markers.slice(0, 8).join(", ") : "none";
+  const commands = profile.candidateValidationCommands.length > 0 ? profile.candidateValidationCommands.slice(0, 6).join("; ") : "none";
+  const notes = profile.notes.length > 0 ? ` Notes: ${profile.notes.join(" ")}` : "";
+  return `Project profile: ${profile.kind}; workspace: ${profile.workspaceStyle}; stacks: ${stacks}; markers: ${markers}; likely validation: ${commands}.${notes}`;
+};
+
+// src/agent/core/projectCommands.ts
+var PROJECT_LOCKFILE_PROBES = [
+  "pnpm-lock.yaml",
+  "yarn.lock",
+  "bun.lockb",
+  "bun.lock",
+  "package-lock.json",
+  "npm-shrinkwrap.json"
+];
+var DEFAULT_TEST_SCRIPT_NAMES = ["test", "test:ci", "test:unit"];
+var TYPECHECK_SCRIPT_NAMES = ["typecheck", "type-check", "check-types", "tsc", "check"];
+var LINT_SCRIPT_NAMES = ["lint", "lint:ci"];
+var HEALTH_SCRIPT_NAME_PATTERNS = [
+  /^repo:check$/,
+  /^check$/,
+  /(^|:)check($|:)/,
+  /(^|:)doctor($|:)/,
+  /(^|:)health($|:)/,
+  /(^|:)verify($|:)/,
+  /(^|:)validate($|:)/,
+  /(^|:)ci($|:)/
+];
+var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var readPackageJsonObservation2 = (state) => [...state.observations].reverse().find((obs) => obs.type === "fs.fileRead" && obs.path === "package.json");
+var parseProjectPackageJson = (state) => {
+  const observation = readPackageJsonObservation2(state);
+  if (!observation) return void 0;
+  try {
+    const parsed = JSON.parse(observation.content);
+    return isRecord2(parsed) ? parsed : void 0;
+  } catch (e2) {
+    return void 0;
+  }
+};
+var packageScripts2 = (pkg) => {
+  if (!pkg || !isRecord2(pkg.scripts)) return {};
+  const scripts = {};
+  for (const [name, value] of Object.entries(pkg.scripts)) {
+    if (typeof value === "string") scripts[name] = value;
+  }
+  return scripts;
+};
+var hasFsExistsObservation = (state, path) => state.observations.some((obs) => obs.type === "fs.exists" && obs.path === path);
+var nextProjectProbeAction = (state) => {
+  const project = state.goal.project;
+  if (!_optionalChain([project, 'optionalAccess', _30 => _30.validationCommands]) && (!_optionalChain([project, 'optionalAccess', _31 => _31.packageManager]) || project.packageManager === "auto")) {
+    for (const path of PROJECT_LOCKFILE_PROBES) {
+      if (!hasFsExistsObservation(state, path)) return { type: "fs.exists", path };
+    }
+  }
+  const profileProbe = projectProfileProbePending(state);
+  return profileProbe ? { type: "fs.exists", path: profileProbe } : void 0;
+};
+var packageManagerFromPackageJson = (pkg) => {
+  const raw = typeof _optionalChain([pkg, 'optionalAccess', _32 => _32.packageManager]) === "string" ? pkg.packageManager : void 0;
+  if (!raw) return void 0;
+  const name = _optionalChain([raw, 'access', _33 => _33.split, 'call', _34 => _34("@"), 'access', _35 => _35[0], 'optionalAccess', _36 => _36.trim, 'call', _37 => _37()]);
+  if (name === "npm" || name === "pnpm" || name === "yarn" || name === "bun") return name;
+  return void 0;
+};
+var lockfileExists = (state, path) => state.observations.some((obs) => obs.type === "fs.exists" && obs.path === path && obs.exists);
+var packageManagerFromLockfiles = (state) => {
+  if (lockfileExists(state, "pnpm-lock.yaml")) return "pnpm";
+  if (lockfileExists(state, "yarn.lock")) return "yarn";
+  if (lockfileExists(state, "bun.lockb") || lockfileExists(state, "bun.lock")) return "bun";
+  if (lockfileExists(state, "package-lock.json") || lockfileExists(state, "npm-shrinkwrap.json")) return "npm";
+  return void 0;
+};
+var discoverPackageManager = (state) => {
+  const configured = _optionalChain([state, 'access', _38 => _38.goal, 'access', _39 => _39.project, 'optionalAccess', _40 => _40.packageManager]);
+  if (configured && configured !== "auto") return configured;
+  return _nullishCoalesce(_nullishCoalesce(packageManagerFromPackageJson(parseProjectPackageJson(state)), () => ( packageManagerFromLockfiles(state))), () => ( "npm"));
+};
+var isPlaceholderTestScript = (script) => /no test specified/i.test(script) && /exit\s+1/.test(script);
+var firstExistingScript = (scripts, names, options = {}) => {
+  for (const name of names) {
+    const script = scripts[name];
+    if (script === void 0) continue;
+    if (options.skipPlaceholderTest && name === "test" && isPlaceholderTestScript(script)) continue;
+    return name;
+  }
+  return void 0;
+};
+var firstScriptMatching = (scripts, patterns) => {
+  for (const name of Object.keys(scripts)) {
+    if (patterns.some((pattern) => pattern.test(name))) return name;
+  }
+  return void 0;
+};
+var goalMentionsAny = (goal, words) => {
+  const lower = goal.toLowerCase();
+  return words.some((word) => lower.includes(word));
+};
+var splitCommand = (value) => {
+  const out = [];
+  let current = "";
+  let quote;
+  let escaping = false;
+  for (const char of value.trim()) {
+    if (escaping) {
+      current += char;
+      escaping = false;
+      continue;
+    }
+    if (char === "\\") {
+      escaping = true;
+      continue;
+    }
+    if (quote) {
+      if (char === quote) {
+        quote = void 0;
+      } else {
+        current += char;
+      }
+      continue;
+    }
+    if (char === "'" || char === '"') {
+      quote = char;
+      continue;
+    }
+    if (/\s/.test(char)) {
+      if (current) {
+        out.push(current);
+        current = "";
+      }
+      continue;
+    }
+    current += char;
+  }
+  if (current) out.push(current);
+  return out;
+};
+var commandText = (command) => command.join(" ");
+var dedupeCommands = (commands) => {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const command of commands) {
+    const key = commandText(command);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(command);
+  }
+  return out;
+};
+var commandForScript = (packageManager, scriptName) => {
+  switch (packageManager) {
+    case "npm":
+      return scriptName === "test" ? ["npm", "test"] : ["npm", "run", scriptName];
+    case "pnpm":
+      return scriptName === "test" ? ["pnpm", "test"] : ["pnpm", "run", scriptName];
+    case "yarn":
+      return scriptName === "test" ? ["yarn", "test"] : ["yarn", "run", scriptName];
+    case "bun":
+      return ["bun", "run", scriptName];
+  }
+};
+var configuredValidationCommands = (project) => {
+  if (!_optionalChain([project, 'optionalAccess', _41 => _41.validationCommands])) return void 0;
+  return project.validationCommands.map((command) => splitCommand(command)).filter((command) => command.length > 0);
+};
+var discoverValidationCommands = (state) => {
+  const project = state.goal.project;
+  const configured = configuredValidationCommands(project);
+  if (configured) {
+    const packageManager2 = discoverPackageManager(state);
+    const profile2 = discoverProjectProfile(state, packageManager2);
+    return {
+      packageManager: packageManager2,
+      validationCommands: configured,
+      source: "config",
+      notes: configured.length > 0 ? ["Using validation commands from project config."] : ["Project config explicitly disables validation commands."],
+      profileSummary: describeProjectProfile(profile2)
+    };
+  }
+  const pkg = parseProjectPackageJson(state);
+  const scripts = packageScripts2(pkg);
+  const packageManager = discoverPackageManager(state);
+  const profile = discoverProjectProfile(state, packageManager);
+  const commands = [];
+  const notes = [];
+  const testScript = firstExistingScript(
+    scripts,
+    _nullishCoalesce(_optionalChain([project, 'optionalAccess', _42 => _42.testScriptNames]), () => ( DEFAULT_TEST_SCRIPT_NAMES)),
+    { skipPlaceholderTest: true }
+  );
+  if (testScript) {
+    commands.push(commandForScript(packageManager, testScript));
+    notes.push(`Selected test script: ${testScript}.`);
+  } else {
+    notes.push("No usable test script found in package.json.");
+    const healthScript = firstScriptMatching(scripts, HEALTH_SCRIPT_NAME_PATTERNS);
+    if (healthScript) {
+      commands.push(commandForScript(packageManager, healthScript));
+      notes.push(`Selected project health script: ${healthScript}.`);
+    }
+  }
+  const includeTypecheck = _optionalChain([project, 'optionalAccess', _43 => _43.includeTypecheck]) === true || goalMentionsAny(state.goal.text, ["typecheck", "type-check", "type check", "types", "tsc"]) || commands.length === 0;
+  if (includeTypecheck) {
+    const typecheckScript = firstExistingScript(scripts, TYPECHECK_SCRIPT_NAMES);
+    if (typecheckScript) {
+      commands.push(commandForScript(packageManager, typecheckScript));
+      notes.push(`Selected typecheck script: ${typecheckScript}.`);
+    }
+  }
+  const includeLint = _optionalChain([project, 'optionalAccess', _44 => _44.includeLint]) === true || goalMentionsAny(state.goal.text, ["lint", "eslint"]) || commands.length === 0;
+  if (includeLint) {
+    const lintScript = firstExistingScript(scripts, LINT_SCRIPT_NAMES);
+    if (lintScript) {
+      commands.push(commandForScript(packageManager, lintScript));
+      notes.push(`Selected lint script: ${lintScript}.`);
+    }
+  }
+  if (commands.length === 0 && profile.stacks.includes("rust") && profile.markers.includes("Cargo.toml")) {
+    commands.push(["cargo", "check"]);
+    notes.push("Selected Cargo check because a root Cargo.toml was detected.");
+  }
+  const max = _nullishCoalesce(_optionalChain([project, 'optionalAccess', _45 => _45.maxValidationCommands]), () => ( 2));
+  const validationCommands = dedupeCommands(commands).slice(0, Math.max(0, max));
+  return {
+    packageManager,
+    validationCommands,
+    source: validationCommands.length > 0 ? "package-json" : "fallback",
+    notes,
+    profileSummary: describeProjectProfile(profile)
+  };
+};
+var commandsEqual = (a, b) => a.length === b.length && a.every((part, index) => part === b[index]);
+var shellResultMatches = (observation, command) => observation.type === "shell.result" && commandsEqual(observation.command, command);
+var nextUnrunValidationCommand = (commands, observations) => commands.find((command) => !observations.some((observation) => shellResultMatches(observation, command)));
+var describeCommandDiscovery = (discovery) => {
+  const commands = discovery.validationCommands.map(commandText).join("; ") || "none";
+  const notes = discovery.notes.length > 0 ? ` Notes: ${discovery.notes.join(" ")}` : "";
+  const profile = discovery.profileSummary ? ` ${discovery.profileSummary}` : "";
+  return `Package manager: ${discovery.packageManager}. Validation commands: ${commands}.${notes}${profile}`;
+};
+
+// src/agent/core/patchQuality.ts
+var DEFAULT_MAX_REPAIR_ATTEMPTS = 1;
+var clampNonNegativeInteger = (value, fallback) => {
+  if (value === void 0 || !Number.isFinite(value)) return fallback;
+  return Math.max(0, Math.floor(value));
+};
+var patchRepairAttemptsUsed = (state) => state.observations.filter((obs) => obs.type === "llm.response" && obs.purpose === "patch").length;
+var patchQualitySummary = (state) => {
+  const enabled = _nullishCoalesce(_optionalChain([state, 'access', _46 => _46.goal, 'access', _47 => _47.patchQuality, 'optionalAccess', _48 => _48.enabled]), () => ( true));
+  const maxRepairAttempts = clampNonNegativeInteger(
+    _optionalChain([state, 'access', _49 => _49.goal, 'access', _50 => _50.patchQuality, 'optionalAccess', _51 => _51.maxRepairAttempts]),
+    DEFAULT_MAX_REPAIR_ATTEMPTS
+  );
+  const repairAttemptsUsed = patchRepairAttemptsUsed(state);
+  return {
+    enabled,
+    maxRepairAttempts,
+    repairAttemptsUsed,
+    repairsRemaining: Math.max(0, maxRepairAttempts - repairAttemptsUsed),
+    exactSuppliedPatch: Boolean(_optionalChain([state, 'access', _52 => _52.goal, 'access', _53 => _53.initialPatch, 'optionalAccess', _54 => _54.trim, 'call', _55 => _55()]))
+  };
+};
+var canRequestPatchRepair = (state) => {
+  const summary = patchQualitySummary(state);
+  return summary.enabled && !summary.exactSuppliedPatch && summary.repairsRemaining > 0;
+};
+var commandsEqual2 = (a, b) => a.length === b.length && a.every((part, index) => part === b[index]);
+var shellResultsForCommands = (commands, observations) => commands.flatMap(
+  (command) => observations.filter(
+    (obs) => obs.type === "shell.result" && commandsEqual2(obs.command, command)
+  ).slice(-1)
+);
+var patchValidationStatus = (commands, observationsAfterPatch2) => {
+  if (commands.length === 0) return { type: "not-run" };
+  const results = shellResultsForCommands(commands, observationsAfterPatch2);
+  if (results.length < commands.length) {
+    return { type: "pending", completed: results.length, total: commands.length };
+  }
+  return results.some((result) => result.exitCode !== 0) ? { type: "failed", results } : { type: "passed", results };
+};
+var describePatchQuality = (state) => {
+  const summary = patchQualitySummary(state);
+  if (!summary.enabled) return "Patch quality loop: disabled.";
+  if (summary.exactSuppliedPatch) {
+    return "Patch quality loop: disabled for supplied exact patches.";
+  }
+  return [
+    `Patch quality loop: ${summary.repairAttemptsUsed}/${summary.maxRepairAttempts} repair attempts used.`,
+    `Repairs remaining: ${summary.repairsRemaining}.`
+  ].join(" ");
+};
+
+// src/agent/core/rollbackSafety.ts
+var DEFAULT_MAX_ROLLBACK_DEPTH = 8;
+var clampNonNegativeInteger2 = (value, fallback) => {
+  if (value === void 0 || !Number.isFinite(value)) return fallback;
+  return Math.max(0, Math.floor(value));
+};
+var rollbackStrategy = (value) => value === "last" ? "last" : "all";
+var rollbackSafetySummary = (state) => {
+  const rollback = state.goal.rollback;
+  const enabled = _nullishCoalesce(_optionalChain([rollback, 'optionalAccess', _56 => _56.enabled]), () => ( true));
+  const maxRollbackDepth = clampNonNegativeInteger2(_optionalChain([rollback, 'optionalAccess', _57 => _57.maxRollbackDepth]), DEFAULT_MAX_ROLLBACK_DEPTH);
+  const rollbackCount = state.observations.filter((obs) => obs.type === "patch.rolledBack").length;
+  const appliedStackDepth = unappliedPatchStack(state).length;
+  return {
+    enabled,
+    onFinalValidationFailure: _nullishCoalesce(_optionalChain([rollback, 'optionalAccess', _58 => _58.onFinalValidationFailure]), () => ( true)),
+    strategy: rollbackStrategy(_optionalChain([rollback, 'optionalAccess', _59 => _59.strategy])),
+    maxRollbackDepth,
+    runValidationAfterRollback: _nullishCoalesce(_optionalChain([rollback, 'optionalAccess', _60 => _60.runValidationAfterRollback]), () => ( true)),
+    allowForSuppliedPatches: _nullishCoalesce(_optionalChain([rollback, 'optionalAccess', _61 => _61.allowForSuppliedPatches]), () => ( false)),
+    rollbackCount,
+    appliedStackDepth,
+    exactSuppliedPatch: Boolean(_optionalChain([state, 'access', _62 => _62.goal, 'access', _63 => _63.initialPatch, 'optionalAccess', _64 => _64.trim, 'call', _65 => _65()]))
+  };
+};
+var unappliedPatchStack = (state) => {
+  const stack = [];
+  for (const [index, observation] of state.observations.entries()) {
+    if (observation.type === "patch.applied" && _optionalChain([observation, 'access', _66 => _66.patch, 'optionalAccess', _67 => _67.trim, 'call', _68 => _68()])) {
+      stack.push({
+        index,
+        patch: observation.patch,
+        changedFiles: observation.changedFiles
+      });
+      continue;
+    }
+    if (observation.type === "patch.rolledBack" && _optionalChain([observation, 'access', _69 => _69.patch, 'optionalAccess', _70 => _70.trim, 'call', _71 => _71()])) {
+      const existingIndex = [...stack].reverse().findIndex((entry) => entry.patch.trim() === _optionalChain([observation, 'access', _72 => _72.patch, 'optionalAccess', _73 => _73.trim, 'call', _74 => _74()]));
+      if (existingIndex >= 0) {
+        stack.splice(stack.length - 1 - existingIndex, 1);
+      }
+    }
+  }
+  return stack;
+};
+var latestUnappliedPatch = (state) => unappliedPatchStack(state).at(-1);
+var canAutoRollback = (state) => {
+  const summary = rollbackSafetySummary(state);
+  if (!summary.enabled) return false;
+  if (summary.rollbackCount >= summary.maxRollbackDepth) return false;
+  if (summary.exactSuppliedPatch && !summary.allowForSuppliedPatches) return false;
+  return summary.appliedStackDepth > 0;
+};
+var shouldContinueRollbackStack = (state) => {
+  const summary = rollbackSafetySummary(state);
+  const latest = state.observations.at(-1);
+  return _optionalChain([latest, 'optionalAccess', _75 => _75.type]) === "patch.rolledBack" && summary.strategy === "all" && canAutoRollback(state);
+};
+var commandsEqual3 = (a, b) => a.length === b.length && a.every((part, index) => part === b[index]);
+var shellResultsForCommands2 = (commands, observations) => commands.flatMap(
+  (command) => observations.filter(
+    (obs) => obs.type === "shell.result" && commandsEqual3(obs.command, command)
+  ).slice(-1)
+);
+var workspaceValidationStatus = (commands, observationsAfterWorkspaceChange) => {
+  if (commands.length === 0) return { type: "not-run" };
+  const results = shellResultsForCommands2(commands, observationsAfterWorkspaceChange);
+  if (results.length < commands.length) {
+    return { type: "pending", completed: results.length, total: commands.length };
+  }
+  return results.some((result) => result.exitCode !== 0) ? { type: "failed", results } : { type: "passed", results };
+};
+var describeRollbackSafety = (state) => {
+  const summary = rollbackSafetySummary(state);
+  if (!summary.enabled) return "Rollback safety: disabled.";
+  if (summary.exactSuppliedPatch && !summary.allowForSuppliedPatches) {
+    return "Rollback safety: disabled for supplied exact patches.";
+  }
+  return [
+    `Rollback safety: ${summary.onFinalValidationFailure ? "enabled" : "not configured for final validation failure"}.`,
+    `Strategy: ${summary.strategy}.`,
+    `Rollbacks used: ${summary.rollbackCount}/${summary.maxRollbackDepth}.`,
+    `Applied patch stack depth: ${summary.appliedStackDepth}.`
+  ].join(" ");
+};
+
+// src/agent/tools/patch.ts
+var FENCED_DIFF_BLOCK = /```(?:diff|patch)?\s*\n([\s\S]*?)```/g;
+var stripGitPrefix = (path) => path.replace(/^[ab]\//, "");
+var normalizePatch = (patch) => patch.replace(/\r\n/g, "\n").trim();
+var looksLikeUnifiedDiff = (content) => {
+  const normalized = normalizePatch(content);
+  return normalized.includes("+++ ") && normalized.includes("--- ");
+};
+var firstRawDiff = (content) => {
+  const normalized = normalizePatch(content);
+  const diffIndex = normalized.indexOf("diff --git ");
+  const plainIndex = normalized.indexOf("--- ");
+  const start = [diffIndex, plainIndex].filter((index) => index >= 0).sort((a, b) => a - b)[0];
+  if (start === void 0) return void 0;
+  const candidate = normalized.slice(start).trim();
+  return looksLikeUnifiedDiff(candidate) ? candidate : void 0;
+};
+var extractUnifiedDiff = (content) => {
+  const normalized = normalizePatch(content);
+  if (!normalized) return void 0;
+  const matches = normalized.matchAll(FENCED_DIFF_BLOCK);
+  for (const match of matches) {
+    const candidate = normalizePatch(_nullishCoalesce(match[1], () => ( "")));
+    if (looksLikeUnifiedDiff(candidate)) {
+      return candidate;
+    }
+  }
+  return firstRawDiff(normalized);
+};
+var extractPathToken = (line) => {
+  const token = line.trim().split(/\s+/)[0];
+  if (!token || token === "/dev/null") return void 0;
+  return stripGitPrefix(token);
+};
+var extractPatchPaths = (patch) => {
+  const normalized = normalizePatch(patch);
+  if (!normalized) return [];
+  const seen = /* @__PURE__ */ new Set();
+  const ordered = [];
+  for (const line of normalized.split("\n")) {
+    if (line.startsWith("+++ ") || line.startsWith("--- ")) {
+      const path = extractPathToken(line.slice(4));
+      if (!path || seen.has(path)) continue;
+      seen.add(path);
+      ordered.push(path);
+    }
+  }
+  return ordered;
+};
+
+// src/agent/core/redaction.ts
+var DEFAULT_SECRET_PATTERNS = [
+  /\b(?:sk|pk|rk|ghp|gho|ghu|ghs|github_pat)_[A-Za-z0-9_\-]{16,}\b/g,
+  /\bAIza[0-9A-Za-z_\-]{20,}\b/g,
+  /\b(?:xoxb|xoxp|xoxa|xoxr)-[A-Za-z0-9\-]{20,}\b/g,
+  /\b[A-Za-z0-9_-]{20,}\.[A-Za-z0-9_-]{20,}\.[A-Za-z0-9_-]{20,}\b/g,
+  /((?:api[_-]?key|token|secret|password|passwd|authorization)\s*[:=]\s*)(["']?)[^\s"']{8,}\2/gi,
+  /(Bearer\s+)[A-Za-z0-9._\-+/=]{12,}/gi
+];
+var toRegExp = (pattern) => {
+  try {
+    return new RegExp(pattern, "gi");
+  } catch (e3) {
+    return void 0;
+  }
+};
+var configuredPatterns = (config) => (_nullishCoalesce(_optionalChain([config, 'optionalAccess', _76 => _76.additionalPatterns]), () => ( []))).map(toRegExp).filter((pattern) => Boolean(pattern));
+var isRedactionEnabled = (config) => _nullishCoalesce(_optionalChain([config, 'optionalAccess', _77 => _77.enabled]), () => ( true));
+var redactText = (value, config) => {
+  if (!isRedactionEnabled(config) || !value) return value;
+  return [...DEFAULT_SECRET_PATTERNS, ...configuredPatterns(config)].reduce(
+    (current, pattern) => current.replace(pattern, (match, prefix) => {
+      if (typeof prefix === "string" && prefix.length > 0 && match.startsWith(prefix)) {
+        return `${prefix}[REDACTED]`;
+      }
+      return "[REDACTED]";
+    }),
+    value
+  );
+};
+
+// src/agent/core/language.ts
+var LANGUAGE_LABELS = {
+  en: "English",
+  es: "Spanish",
+  pt: "Portuguese",
+  fr: "French",
+  de: "German",
+  it: "Italian"
+};
+var SPANISH_HINT = /[¿¡ñáéíóúü]|\b(aca|acá|ahora|arregl|ayuda|como|cómo|consulta|cual|cuál|cuando|cuándo|dale|decime|deberia|debería|donde|dónde|errores|explica|explicame|hacer|hagamos|mejorar|porque|porqué|por que|por qué|proyecto|quiero|seria|sería|tengo|usar|vayamos)\b/i;
+var PORTUGUESE_HINT = /[ãõç]|\b(como|corrigir|erro|falha|quero|projeto|porque|você|voce)\b/i;
+var FRENCH_HINT = /[àâçéèêëîïôûùüÿœ]|\b(comment|pourquoi|corriger|erreur|projet|fichier)\b/i;
+var GERMAN_HINT = /[äöüß]|\b(warum|fehler|projekt|datei|bitte)\b/i;
+var ITALIAN_HINT = /\b(come|perché|perche|errore|progetto|file|voglio)\b/i;
+var inferUserLanguage = (text) => {
+  if (SPANISH_HINT.test(text)) return "Spanish";
+  if (PORTUGUESE_HINT.test(text)) return "Portuguese";
+  if (FRENCH_HINT.test(text)) return "French";
+  if (GERMAN_HINT.test(text)) return "German";
+  if (ITALIAN_HINT.test(text)) return "Italian";
+  return void 0;
+};
+var configuredLanguageName = (language) => {
+  const response = _nullishCoalesce(_optionalChain([language, 'optionalAccess', _78 => _78.response]), () => ( "auto"));
+  if (response === "custom") return _optionalChain([language, 'optionalAccess', _79 => _79.custom, 'optionalAccess', _80 => _80.trim, 'call', _81 => _81()]) || void 0;
+  if (response === "auto" || response === "match-user") return void 0;
+  return LANGUAGE_LABELS[response];
+};
+var responseLanguageName = (goal) => _nullishCoalesce(configuredLanguageName(goal.language), () => ( inferUserLanguage(goal.text)));
+var describeLanguagePolicy = (goal) => {
+  const configured = configuredLanguageName(goal.language);
+  const inferred = inferUserLanguage(goal.text);
+  if (configured) {
+    return [
+      `Language policy: respond in ${configured}.`,
+      "Keep code, identifiers, file paths, shell commands, logs, and unified diffs unchanged."
+    ].join(" ");
+  }
+  if (inferred) {
+    return [
+      `Language policy: the user goal appears to be in ${inferred}; respond in ${inferred}.`,
+      "Keep code, identifiers, file paths, shell commands, logs, and unified diffs unchanged."
+    ].join(" ");
+  }
+  return [
+    "Language policy: respond in the same natural language as the user's latest goal or follow-up.",
+    "If the user's goal is in Spanish, respond in Spanish.",
+    "Keep code, identifiers, file paths, shell commands, logs, and unified diffs unchanged."
+  ].join(" ");
+};
+var spanishLike = (goal) => responseLanguageName(goal) === "Spanish";
+
+// 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);
+var firstObservation = (state, type) => state.observations.find((obs) => obs.type === type);
+var lastObservationIndex = (state, type) => [...state.observations].map((obs) => obs.type).lastIndexOf(type);
+var observationsBeforePlanning = (state) => {
+  const planIndex = state.observations.findIndex((obs) => obs.type === "llm.response" && obs.purpose === "plan");
+  return planIndex < 0 ? state.observations : state.observations.slice(0, planIndex);
+};
+var observationsAfterPatch = (state) => {
+  const patchIndex = lastObservationIndex(state, "patch.applied");
+  return patchIndex < 0 ? [] : state.observations.slice(patchIndex + 1);
+};
+var latestWorkspaceChangeIndex = (state) => Math.max(lastObservationIndex(state, "patch.applied"), lastObservationIndex(state, "patch.rolledBack"));
+var observationsAfterLatestWorkspaceChange = (state) => {
+  const index = latestWorkspaceChangeIndex(state);
+  return index < 0 ? [] : state.observations.slice(index + 1);
+};
+var latestWorkspaceChange = (state) => {
+  const index = latestWorkspaceChangeIndex(state);
+  const observation = index < 0 ? void 0 : state.observations[index];
+  return _optionalChain([observation, 'optionalAccess', _82 => _82.type]) === "patch.applied" || _optionalChain([observation, 'optionalAccess', _83 => _83.type]) === "patch.rolledBack" ? observation : void 0;
+};
+var compactObservation = (obs) => {
+  switch (obs.type) {
+    case "fs.fileRead": {
+      const lower = obs.path.toLowerCase();
+      const isLockfile = lower.endsWith("package-lock.json") || lower.endsWith("npm-shrinkwrap.json") || lower.endsWith("pnpm-lock.yaml") || lower.endsWith("yarn.lock") || lower.endsWith("cargo.lock");
+      const limit = isLockfile ? 1500 : 8e3;
+      return {
+        type: obs.type,
+        path: obs.path,
+        content: obs.content.slice(0, limit),
+        omittedChars: Math.max(0, obs.content.length - limit)
+      };
+    }
+    case "fs.exists":
+      return { type: obs.type, path: obs.path, exists: obs.exists };
+    case "shell.result":
+      return {
+        type: obs.type,
+        command: obs.command,
+        exitCode: obs.exitCode,
+        stdout: obs.stdout.slice(-8e3),
+        stderr: obs.stderr.slice(-8e3)
+      };
+    case "fs.searchResult":
+      return {
+        type: obs.type,
+        query: obs.query,
+        matches: obs.matches.slice(0, 20),
+        omittedMatches: Math.max(0, obs.matches.length - 20)
+      };
+    case "patch.proposed":
+      return { type: obs.type, patch: obs.patch.slice(0, 8e3) };
+    case "patch.applied":
+      return { type: obs.type, changedFiles: obs.changedFiles };
+    case "patch.rolledBack":
+      return {
+        type: obs.type,
+        changedFiles: obs.changedFiles,
+        ...obs.automatic !== void 0 ? { automatic: obs.automatic } : {},
+        ...obs.reason ? { reason: obs.reason } : {}
+      };
+    case "agent.done":
+    case "agent.error":
+      return obs;
+    case "llm.response":
+      return { type: obs.type, purpose: obs.purpose, content: obs.content.slice(-8e3) };
+  }
+};
+var redactForPrompt = (state, value) => redactText(value, state.goal.redaction);
+var isNoiseObservationForPrompt = (obs) => obs.type === "fs.exists" && !obs.exists;
+var compactObservations = (state) => redactForPrompt(
+  state,
+  state.observations.filter((obs) => !isNoiseObservationForPrompt(obs)).map((obs) => JSON.stringify(compactObservation(obs), null, 2)).join("\n\n")
+);
+var causeMessage = (cause) => {
+  if (cause instanceof Error) return cause.message || String(cause);
+  if (typeof cause === "string") return cause;
+  if (cause && typeof cause === "object") {
+    try {
+      const json = JSON.stringify(cause);
+      if (json && json !== "{}") return json;
+    } catch (e4) {
+    }
+  }
+  return String(cause);
+};
+var errorDetail = (state, cause) => redactForPrompt(state, causeMessage(cause)).slice(0, 2e3);
+var buildPlanningPrompt = (state) => {
+  const discovery = discoverValidationCommands(state);
+  return redactForPrompt(state, [
+    "You are a coding agent running on brass-runtime.",
+    "Return a concise diagnosis and proposed plan.",
+    "If you can infer a patch, include it as a unified diff inside a ```diff fenced block.",
+    "Do not claim that you edited files unless the runtime reports patch.applied.",
+    "Prefer a single focused patch over speculative broad changes.",
+    "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),
+    "",
+    `Goal: ${state.goal.text}`,
+    `Workspace: ${state.goal.cwd}`,
+    `Project commands: ${describeCommandDiscovery(discovery)}`,
+    describeContextDiscovery(state),
+    describePatchQuality(state),
+    describeRollbackSafety(state),
+    "",
+    "Observations:",
+    compactObservations(state) || "No observations yet."
+  ].join("\n"));
+};
+var failedValidationLines = (state) => observationsAfterPatch(state).filter((obs) => obs.type === "shell.result" && obs.exitCode !== 0).map((result) => [
+  `Command: ${result.command.join(" ")}`,
+  `Exit code: ${result.exitCode}`,
+  result.stdout ? `stdout:
+${result.stdout.slice(-8e3)}` : void 0,
+  result.stderr ? `stderr:
+${result.stderr.slice(-8e3)}` : void 0
+].filter(Boolean).join("\n"));
+var buildPatchRepairPrompt = (state, reason) => {
+  const discovery = discoverValidationCommands(state);
+  const quality = patchQualitySummary(state);
+  const latestPatchError = _optionalChain([lastObservation, 'call', _84 => _84(state, "agent.error"), 'optionalAccess', _85 => _85.error]);
+  const latestPatch = lastMaterializedPatch(state);
+  return redactForPrompt(state, [
+    "You are repairing a generated patch for a coding agent running on brass-runtime.",
+    "The previous generated patch either failed to apply or failed validation.",
+    "Return a concise diagnosis and, if you can fix it, include a replacement incremental unified diff inside a ```diff fenced block.",
+    "The new diff should apply on top of the current workspace state, after any previous patch.applied observations.",
+    "Do not repeat the old patch unless it is still correct for the current workspace state.",
+    "Do not claim files were edited unless the runtime later reports patch.applied.",
+    describeLanguagePolicy(state.goal),
+    "",
+    `Goal: ${state.goal.text}`,
+    `Workspace: ${state.goal.cwd}`,
+    `Repair reason: ${reason}`,
+    `Repair attempts used: ${quality.repairAttemptsUsed}/${quality.maxRepairAttempts}`,
+    `Project commands: ${describeCommandDiscovery(discovery)}`,
+    describeContextDiscovery(state),
+    describePatchQuality(state),
+    describeRollbackSafety(state),
+    "",
+    latestPatch ? `Latest materialized patch:
+${latestPatch.slice(-8e3)}` : "Latest materialized patch: none.",
+    "",
+    failedValidationLines(state).length > 0 ? `Failed validation after latest patch:
+${failedValidationLines(state).join("\n\n")}` : "Failed validation after latest patch: none recorded.",
+    "",
+    _optionalChain([latestPatchError, 'optionalAccess', _86 => _86._tag]) === "PatchError" ? `Latest patch error during ${latestPatchError.operation}: ${String(latestPatchError.cause)}` : "Latest patch error: none.",
+    "",
+    "Recent observations:",
+    compactObservations(state) || "No observations yet."
+  ].join("\n"));
+};
+var isWritableMode = (mode) => mode === "write" || mode === "autonomous";
+var buildValidationSummary = (state) => {
+  const validationResults = observationsAfterLatestWorkspaceChange(state).filter((obs) => obs.type === "shell.result");
+  if (validationResults.length === 0) return void 0;
+  const change = latestWorkspaceChange(state);
+  const spanish = spanishLike(state.goal);
+  const label = _optionalChain([change, 'optionalAccess', _87 => _87.type]) === "patch.rolledBack" ? spanish ? "rollback" : "rollback" : spanish ? "aplicar patch" : "apply";
+  return [
+    spanish ? `Validaci\xF3n despu\xE9s de ${label}:` : `Validation after latest ${label}:`,
+    ...validationResults.map((result) => `- ${result.command.join(" ")} ${spanish ? "termin\xF3 con c\xF3digo" : "exited with"} ${result.exitCode}.`)
+  ].join("\n");
+};
+var buildCompletionSummary = (state, patch) => {
+  const plan = _nullishCoalesce(_optionalChain([firstObservation, 'call', _88 => _88(state, "llm.response"), 'optionalAccess', _89 => _89.content, 'optionalAccess', _90 => _90.trim, 'call', _91 => _91()]), () => ( "No plan was generated."));
+  const latestResponse = lastObservation(state, "llm.response");
+  const patchApplied = lastObservation(state, "patch.applied");
+  const patchRolledBack = lastObservation(state, "patch.rolledBack");
+  const patchProposed = lastObservation(state, "patch.proposed");
+  const validation = buildValidationSummary(state);
+  const spanish = spanishLike(state.goal);
+  const lines = [plan];
+  if (_optionalChain([latestResponse, 'optionalAccess', _92 => _92.purpose]) === "patch" && latestResponse.content.trim()) {
+    lines.push("", spanish ? "\xDAltima respuesta de reparaci\xF3n del patch:" : "Latest patch repair response:", latestResponse.content.trim());
+  }
+  if (patchRolledBack) {
+    lines.push(
+      "",
+      spanish ? `Patch revertido en: ${patchRolledBack.changedFiles.join(", ") || "(sin archivos reportados)"}` : `Patch rolled back for: ${patchRolledBack.changedFiles.join(", ") || "(no files reported)"}`
+    );
+  } else if (patchApplied) {
+    lines.push(
+      "",
+      spanish ? `Patch aplicado en: ${patchApplied.changedFiles.join(", ") || "(sin archivos reportados)"}` : `Patch applied to: ${patchApplied.changedFiles.join(", ") || "(no files reported)"}`
+    );
+  } else if (patchProposed) {
+    lines.push("", spanish ? "Patch propuesto, pero no aplicado en este modo." : "Patch extracted and proposed, but not applied in this mode.");
+  } else if (patch) {
+    lines.push("", spanish ? "Hab\xEDa un diff con forma de patch, pero no se materializ\xF3 como observaci\xF3n." : "A patch-shaped diff was present, but it was not materialized as an observation.");
+  }
+  if (validation) {
+    lines.push("", validation);
+  }
+  return redactForPrompt(state, lines.join("\n").trim());
+};
+var buildErrorSummary = (state) => {
+  const latestError = _optionalChain([lastObservation, 'call', _93 => _93(state, "agent.error"), 'optionalAccess', _94 => _94.error]);
+  const spanish = spanishLike(state.goal);
+  if (!latestError) return spanish ? "La ejecuci\xF3n del agente fall\xF3." : "Agent run failed.";
+  switch (latestError._tag) {
+    case "FsError":
+      return spanish ? `El agente se detuvo por un error de filesystem durante ${latestError.operation}: ${errorDetail(state, latestError.cause)}` : `Agent stopped after a filesystem error during ${latestError.operation}: ${errorDetail(state, latestError.cause)}`;
+    case "ShellError":
+      return spanish ? `El agente se detuvo por un error ejecutando ${_nullishCoalesce(_optionalChain([latestError, 'access', _95 => _95.command, 'optionalAccess', _96 => _96.join, 'call', _97 => _97(" ")]), () => ( latestError.operation))}: ${errorDetail(state, latestError.cause)}` : `Agent stopped after a shell error during ${_nullishCoalesce(_optionalChain([latestError, 'access', _98 => _98.command, 'optionalAccess', _99 => _99.join, 'call', _100 => _100(" ")]), () => ( latestError.operation))}: ${errorDetail(state, latestError.cause)}`;
+    case "LLMError":
+      return spanish ? `El agente se detuvo porque fall\xF3 la llamada al modelo: ${errorDetail(state, latestError.cause)}` : `Agent stopped because the model call failed: ${errorDetail(state, latestError.cause)}`;
+    case "PatchError":
+      return spanish ? `El agente se detuvo por un error de patch durante ${latestError.operation}: ${errorDetail(state, latestError.cause)}` : `Agent stopped after a patch error during ${latestError.operation}: ${errorDetail(state, latestError.cause)}`;
+    case "PermissionDenied":
+      return spanish ? `El agente se detuvo porque una acci\xF3n fue denegada por policy: ${latestError.reason}` : `Agent stopped because an action was denied by policy: ${latestError.reason}`;
+    case "ApprovalRejected":
+      return spanish ? `El agente se detuvo porque se rechaz\xF3 una aprobaci\xF3n: ${latestError.reason}` : `Agent stopped because an approval was rejected: ${latestError.reason}`;
+    case "ToolTimeout":
+      return spanish ? `El agente se detuvo porque una tool tard\xF3 m\xE1s de ${latestError.timeoutMs}ms.` : `Agent stopped because a tool timed out after ${latestError.timeoutMs}ms.`;
+    case "PathOutsideWorkspace":
+      return spanish ? `El agente bloque\xF3 un path fuera del workspace: ${latestError.path}` : `Agent blocked a path outside the workspace: ${latestError.path}`;
+    case "AgentLoopError":
+      return spanish ? `El agente se detuvo por un error del loop: ${latestError.message}` : `Agent stopped after an agent loop error: ${latestError.message}`;
+  }
+};
+var nextValidationActionBeforePlanning = (state) => {
+  if (state.goal.mode === "read-only") return void 0;
+  const commands = discoverValidationCommands(state).validationCommands;
+  const next = nextUnrunValidationCommand(commands, observationsBeforePlanning(state));
+  return next ? { type: "shell.exec", command: next } : void 0;
+};
+var nextValidationActionAfterPatch = (state) => {
+  const commands = discoverValidationCommands(state).validationCommands;
+  const next = nextUnrunValidationCommand(commands, observationsAfterPatch(state));
+  return next ? { type: "shell.exec", command: next } : void 0;
+};
+var nextValidationActionAfterLatestWorkspaceChange = (state) => {
+  const commands = discoverValidationCommands(state).validationCommands;
+  const next = nextUnrunValidationCommand(commands, observationsAfterLatestWorkspaceChange(state));
+  return next ? { type: "shell.exec", command: next } : void 0;
+};
+var latestLlmPatchCandidate = (state) => {
+  for (let index = state.observations.length - 1; index >= 0; index -= 1) {
+    const observation = state.observations[index];
+    if (!observation || observation.type !== "llm.response") continue;
+    const patch = extractUnifiedDiff(observation.content);
+    if (!patch) continue;
+    const materialized = state.observations.slice(index + 1).some((obs) => obs.type === "patch.applied" || obs.type === "patch.proposed");
+    if (!materialized) return { index, patch };
+    return void 0;
+  }
+  return void 0;
+};
+var latestExtractedPatch = (state) => {
+  for (let index = state.observations.length - 1; index >= 0; index -= 1) {
+    const observation = state.observations[index];
+    if (_optionalChain([observation, 'optionalAccess', _101 => _101.type]) !== "llm.response") continue;
+    const patch = extractUnifiedDiff(observation.content);
+    if (patch) return patch;
+  }
+  return void 0;
+};
+var lastMaterializedPatch = (state) => {
+  for (let index = state.observations.length - 1; index >= 0; index -= 1) {
+    const observation = state.observations[index];
+    if (_optionalChain([observation, 'optionalAccess', _102 => _102.type]) === "patch.proposed") return observation.patch;
+    if (_optionalChain([observation, 'optionalAccess', _103 => _103.type]) === "patch.applied") {
+      if (observation.patch) return observation.patch;
+      const previousLlmPatch = state.observations.slice(0, index).reverse().find((obs) => obs.type === "llm.response" && Boolean(extractUnifiedDiff(obs.content)));
+      return previousLlmPatch ? extractUnifiedDiff(previousLlmPatch.content) : state.goal.initialPatch;
+    }
+  }
+  return void 0;
+};
+var shouldRequestRepairAfterValidation = (state) => {
+  if (!isWritableMode(state.goal.mode)) return false;
+  if (_optionalChain([latestWorkspaceChange, 'call', _104 => _104(state), 'optionalAccess', _105 => _105.type]) !== "patch.applied") return false;
+  if (!canRequestPatchRepair(state)) return false;
+  const commands = discoverValidationCommands(state).validationCommands;
+  const status = patchValidationStatus(commands, observationsAfterPatch(state));
+  return status.type === "failed";
+};
+var shouldAutoRollbackAfterFinalValidationFailure = (state) => {
+  if (!isWritableMode(state.goal.mode)) return false;
+  if (_optionalChain([latestWorkspaceChange, 'call', _106 => _106(state), 'optionalAccess', _107 => _107.type]) !== "patch.applied") return false;
+  if (canRequestPatchRepair(state)) return false;
+  const summary = rollbackSafetySummary(state);
+  if (!summary.onFinalValidationFailure) return false;
+  if (!canAutoRollback(state)) return false;
+  const commands = discoverValidationCommands(state).validationCommands;
+  const status = workspaceValidationStatus(commands, observationsAfterLatestWorkspaceChange(state));
+  return status.type === "failed";
+};
+var shouldRequestRepairAfterPatchError = (state) => {
+  if (!isWritableMode(state.goal.mode)) return false;
+  if (!canRequestPatchRepair(state)) return false;
+  const latest = state.observations.at(-1);
+  return _optionalChain([latest, 'optionalAccess', _108 => _108.type]) === "agent.error" && latest.error._tag === "PatchError";
+};
+var repairAction = (state, reason) => ({
+  type: "llm.complete",
+  purpose: "patch",
+  prompt: buildPatchRepairPrompt(state, reason)
+});
+var automaticRollbackAction = (state, reason) => {
+  const candidate = latestUnappliedPatch(state);
+  if (!candidate) return void 0;
+  return {
+    type: "patch.rollback",
+    patch: candidate.patch,
+    automatic: true,
+    reason
+  };
+};
+var initialPatchFlowAction = (state, suppliedPatch) => {
+  if (isWritableMode(state.goal.mode)) {
+    if (state.goal.initialPatchMode === "rollback") {
+      if (!hasObservation(state, "patch.rolledBack")) {
+        return { type: "patch.rollback", patch: suppliedPatch };
+      }
+      return void 0;
+    }
+    if (!hasObservation(state, "patch.applied")) {
+      return { type: "patch.apply", patch: suppliedPatch };
+    }
+    return nextValidationActionAfterLatestWorkspaceChange(state);
+  }
+  if (state.goal.mode === "propose" && !hasObservation(state, "patch.proposed")) {
+    return { type: "patch.propose", patch: suppliedPatch };
+  }
+  return void 0;
+};
+var decideNextAction = (state) => {
+  const latest = state.observations.at(-1);
+  if (_optionalChain([latest, 'optionalAccess', _109 => _109.type]) === "agent.error") {
+    if (shouldRequestRepairAfterPatchError(state)) {
+      return _chunkTGOMLZ65js.asyncSucceed.call(void 0, repairAction(state, "previous patch failed to apply"));
+    }
+    return _chunkTGOMLZ65js.asyncSucceed.call(void 0, { type: "agent.finish", summary: buildErrorSummary(state) });
+  }
+  if (!hasObservation(state, "fs.fileRead")) {
+    return _chunkTGOMLZ65js.asyncSucceed.call(void 0, { type: "fs.readFile", path: "package.json" });
+  }
+  const probeAction = nextProjectProbeAction(state);
+  if (probeAction) {
+    return _chunkTGOMLZ65js.asyncSucceed.call(void 0, probeAction);
+  }
+  const suppliedPatch = _optionalChain([state, 'access', _110 => _110.goal, 'access', _111 => _111.initialPatch, 'optionalAccess', _112 => _112.trim, 'call', _113 => _113()]);
+  if (suppliedPatch) {
+    const action = initialPatchFlowAction(state, suppliedPatch);
+    if (action) return _chunkTGOMLZ65js.asyncSucceed.call(void 0, action);
+    return _chunkTGOMLZ65js.asyncSucceed.call(void 0, {
+      type: "agent.finish",
+      summary: buildCompletionSummary(state, suppliedPatch)
+    });
+  }
+  const pendingLlmPatch = latestLlmPatchCandidate(state);
+  if (pendingLlmPatch) {
+    if (isWritableMode(state.goal.mode)) {
+      return _chunkTGOMLZ65js.asyncSucceed.call(void 0, { type: "patch.apply", patch: pendingLlmPatch.patch });
+    }
+    if (state.goal.mode === "propose") {
+      return _chunkTGOMLZ65js.asyncSucceed.call(void 0, { type: "patch.propose", patch: pendingLlmPatch.patch });
+    }
+  }
+  const planResponse = state.observations.find(
+    (obs) => obs.type === "llm.response" && obs.purpose === "plan"
+  );
+  if (!planResponse) {
+    const validationAction = nextValidationActionBeforePlanning(state);
+    if (validationAction) return _chunkTGOMLZ65js.asyncSucceed.call(void 0, validationAction);
+    const contextAction = nextContextDiscoveryAction(state);
+    if (contextAction) return _chunkTGOMLZ65js.asyncSucceed.call(void 0, contextAction);
+    return _chunkTGOMLZ65js.asyncSucceed.call(void 0, {
+      type: "llm.complete",
+      purpose: "plan",
+      prompt: buildPlanningPrompt(state)
+    });
+  }
+  if (isWritableMode(state.goal.mode)) {
+    if (shouldContinueRollbackStack(state)) {
+      const rollbackAction = automaticRollbackAction(state, "continuing rollback of generated patch stack");
+      if (rollbackAction) return _chunkTGOMLZ65js.asyncSucceed.call(void 0, rollbackAction);
+    }
+    if (_optionalChain([latestWorkspaceChange, 'call', _114 => _114(state), 'optionalAccess', _115 => _115.type]) === "patch.rolledBack") {
+      const summary = rollbackSafetySummary(state);
+      if (summary.runValidationAfterRollback) {
+        const validationAction = nextValidationActionAfterLatestWorkspaceChange(state);
+        if (validationAction) return _chunkTGOMLZ65js.asyncSucceed.call(void 0, validationAction);
+      }
+    }
+    if (_optionalChain([latestWorkspaceChange, 'call', _116 => _116(state), 'optionalAccess', _117 => _117.type]) === "patch.applied") {
+      const validationAction = nextValidationActionAfterPatch(state);
+      if (validationAction) return _chunkTGOMLZ65js.asyncSucceed.call(void 0, validationAction);
+      if (shouldRequestRepairAfterValidation(state)) {
+        return _chunkTGOMLZ65js.asyncSucceed.call(void 0, repairAction(state, "validation failed after applying the generated patch"));
+      }
+      if (shouldAutoRollbackAfterFinalValidationFailure(state)) {
+        const rollbackAction = automaticRollbackAction(state, "validation failed after generated patches and no repair attempts remain");
+        if (rollbackAction) return _chunkTGOMLZ65js.asyncSucceed.call(void 0, rollbackAction);
+      }
+    }
+  }
+  const patch = latestExtractedPatch(state);
+  return _chunkTGOMLZ65js.asyncSucceed.call(void 0, {
+    type: "agent.finish",
+    summary: buildCompletionSummary(state, patch)
+  });
+};
+
+// src/agent/core/events.ts
+var nowMillis = () => _chunkTGOMLZ65js.async.call(void 0, (_env, cb) => {
+  cb({ _tag: "Success", value: Date.now() });
+});
+var emitAgentEvent = (event) => _chunkTGOMLZ65js.async.call(void 0, (env, cb) => {
+  try {
+    _optionalChain([env, 'access', _118 => _118.events, 'optionalAccess', _119 => _119.emit, 'call', _120 => _120(event)]);
+  } catch (e5) {
+  }
+  cb({ _tag: "Success", value: void 0 });
+});
+var emitAgentEvents = (events) => events.reduce(
+  (acc, event) => _chunkTGOMLZ65js.asyncFlatMap.call(void 0, acc, () => emitAgentEvent(event)),
+  _chunkTGOMLZ65js.asyncSucceed.call(void 0, void 0)
+);
+var summarizeAgentAction = (action) => {
+  switch (action.type) {
+    case "fs.readFile":
+      return `read ${action.path}`;
+    case "fs.exists":
+      return `check ${action.path}`;
+    case "fs.searchText":
+      return `search "${action.query}"`;
+    case "shell.exec":
+      return action.command.join(" ");
+    case "llm.complete":
+      return `llm.${action.purpose}`;
+    case "patch.propose":
+      return "propose patch";
+    case "patch.apply":
+      return "apply patch";
+    case "patch.rollback":
+      return "rollback patch";
+    case "agent.finish":
+      return "finish";
+    case "agent.fail":
+      return "fail";
+  }
+};
+var summarizeAgentObservation = (observation) => {
+  switch (observation.type) {
+    case "fs.fileRead":
+      return `read ${observation.path}`;
+    case "fs.exists":
+      return `${observation.exists ? "found" : "missing"} ${observation.path}`;
+    case "fs.searchResult":
+      return `search "${observation.query}" (${observation.matches.length} matches)`;
+    case "shell.result":
+      return `${observation.command.join(" ")} exited ${observation.exitCode}`;
+    case "llm.response":
+      return `llm.${observation.purpose} responded`;
+    case "patch.proposed":
+      return "patch proposed";
+    case "patch.applied":
+      return `patch applied (${observation.changedFiles.join(", ") || "no files reported"})`;
+    case "patch.rolledBack":
+      return `patch rolled back (${observation.changedFiles.join(", ") || "no files reported"})`;
+    case "agent.done":
+      return "done";
+    case "agent.error":
+      return `error ${observation.error._tag}`;
+  }
+};
+var observationStatus = (observation) => {
+  switch (observation.type) {
+    case "agent.error":
+      return "fail";
+    case "shell.result":
+      return observation.exitCode === 0 ? "ok" : "warn";
+    default:
+      return "ok";
+  }
+};
+var errorEventFor = (action, state, error, at) => {
+  switch (error._tag) {
+    case "ToolTimeout":
+      return {
+        type: "agent.tool.timeout",
+        action,
+        step: state.steps + 1,
+        phase: state.phase,
+        timeoutMs: error.timeoutMs,
+        at
+      };
+    case "PermissionDenied":
+      return {
+        type: "agent.permission.denied",
+        action,
+        step: state.steps + 1,
+        phase: state.phase,
+        reason: error.reason,
+        at
+      };
+    default:
+      return void 0;
+  }
+};
+var observationEventFor = (state, observation, at) => {
+  switch (observation.type) {
+    case "patch.applied":
+      return {
+        type: "agent.patch.applied",
+        step: state.steps,
+        phase: state.phase,
+        changedFiles: observation.changedFiles,
+        automaticRollbackEligible: Boolean(observation.patch),
+        at
+      };
+    case "patch.rolledBack":
+      return {
+        type: "agent.patch.rolledBack",
+        step: state.steps,
+        phase: state.phase,
+        changedFiles: observation.changedFiles,
+        ...observation.automatic !== void 0 ? { automatic: observation.automatic } : {},
+        ...observation.reason ? { reason: observation.reason } : {},
+        at
+      };
+    default:
+      return void 0;
+  }
+};
+var runStatusFor = (phase) => phase === "done" ? "done" : "failed";
+
+// src/agent/tools/env.ts
+var service = (key) => _chunkTGOMLZ65js.asyncSync.call(void 0, (env) => env[key]);
+
+// src/agent/tools/path.ts
+var isAbsoluteLike = (path) => path.startsWith("/") || /^[A-Za-z]:[\\/]/.test(path);
+var trimTrailingSlash = (path) => {
+  let end = path.length;
+  while (end > 0) {
+    const char = path.charCodeAt(end - 1);
+    if (char !== 47 && char !== 92) {
+      break;
+    }
+    end -= 1;
+  }
+  return end === path.length ? path : path.slice(0, end);
+};
+var trimLeadingDotSlash2 = (path) => path.replace(/^(?:\.[\\/])+/, "");
+var normalizeWorkspaceRelativePath = (inputPath) => {
+  const trimmed = inputPath.trim();
+  if (!trimmed || trimmed.includes("\0") || isAbsoluteLike(trimmed) || trimmed.split(/[\\/]+/).includes("..")) {
+    return void 0;
+  }
+  return trimLeadingDotSlash2(trimmed);
+};
+var resolveWorkspacePath = (cwd, inputPath) => {
+  const normalized = normalizeWorkspaceRelativePath(inputPath);
+  if (!normalized) {
+    return _chunkTGOMLZ65js.asyncFail.call(void 0, { _tag: "PathOutsideWorkspace", path: inputPath, cwd });
+  }
+  return _chunkTGOMLZ65js.asyncSucceed.call(void 0, `${trimTrailingSlash(cwd)}/${normalized}`);
+};
+
+// src/agent/tools/actionToEffect.ts
+var actionToEffect = (action, state) => {
+  switch (action.type) {
+    case "fs.readFile":
+      return _chunkTGOMLZ65js.asyncFlatMap.call(void 0, 
+        resolveWorkspacePath(state.goal.cwd, action.path),
+        (path) => _chunkTGOMLZ65js.asyncFlatMap.call(void 0, 
+          service("fs"),
+          (fs) => _chunkTGOMLZ65js.asyncMap.call(void 0, 
+            fs.readFile(path),
+            (content) => ({ type: "fs.fileRead", path: action.path, content })
+          )
+        )
+      );
+    case "fs.exists":
+      return _chunkTGOMLZ65js.asyncFlatMap.call(void 0, 
+        resolveWorkspacePath(state.goal.cwd, action.path),
+        (path) => _chunkTGOMLZ65js.asyncFlatMap.call(void 0, 
+          service("fs"),
+          (fs) => _chunkTGOMLZ65js.asyncMap.call(void 0, 
+            fs.exists(path),
+            (exists) => ({ type: "fs.exists", path: action.path, exists })
+          )
+        )
+      );
+    case "fs.searchText":
+      return _chunkTGOMLZ65js.asyncFlatMap.call(void 0, 
+        service("fs"),
+        (fs) => _chunkTGOMLZ65js.asyncMap.call(void 0, 
+          fs.searchText(state.goal.cwd, action.query, { globs: action.globs }),
+          (matches) => ({ type: "fs.searchResult", query: action.query, matches })
+        )
+      );
+    case "shell.exec":
+      return _chunkTGOMLZ65js.asyncFlatMap.call(void 0, 
+        service("shell"),
+        (shell) => _chunkTGOMLZ65js.asyncMap.call(void 0, 
+          shell.exec(action.command, { cwd: _nullishCoalesce(action.cwd, () => ( state.goal.cwd)) }),
+          (result) => ({
+            type: "shell.result",
+            command: action.command,
+            exitCode: result.exitCode,
+            stdout: result.stdout,
+            stderr: result.stderr
+          })
+        )
+      );
+    case "llm.complete":
+      return _chunkTGOMLZ65js.asyncFlatMap.call(void 0, 
+        service("llm"),
+        (llm) => _chunkTGOMLZ65js.asyncMap.call(void 0, 
+          llm.complete({ purpose: action.purpose, prompt: action.prompt }),
+          (response) => ({ type: "llm.response", purpose: action.purpose, content: response.content })
+        )
+      );
+    case "patch.propose":
+      return _chunkTGOMLZ65js.asyncSucceed.call(void 0, { type: "patch.proposed", patch: action.patch });
+    case "patch.apply":
+      return _chunkTGOMLZ65js.asyncFlatMap.call(void 0, 
+        service("patch"),
+        (patch) => _chunkTGOMLZ65js.asyncMap.call(void 0, 
+          patch.apply(state.goal.cwd, action.patch),
+          (result) => ({
+            type: "patch.applied",
+            changedFiles: result.changedFiles,
+            patch: action.patch
+          })
+        )
+      );
+    case "patch.rollback":
+      return _chunkTGOMLZ65js.asyncFlatMap.call(void 0, 
+        service("patch"),
+        (patch) => _chunkTGOMLZ65js.asyncMap.call(void 0, 
+          patch.rollback(state.goal.cwd, action.patch),
+          (result) => ({
+            type: "patch.rolledBack",
+            changedFiles: result.changedFiles,
+            patch: action.patch,
+            ...action.automatic !== void 0 ? { automatic: action.automatic } : {},
+            ...action.reason ? { reason: action.reason } : {}
+          })
+        )
+      );
+    case "agent.finish":
+      return _chunkTGOMLZ65js.asyncSucceed.call(void 0, { type: "agent.done", summary: action.summary });
+    case "agent.fail":
+      return _chunkTGOMLZ65js.asyncFail.call(void 0, { _tag: "AgentLoopError", message: action.reason });
+  }
+};
+
+// src/agent/tools/retry.ts
+var retry = (make, options) => {
+  const loop = (remaining) => _chunkTGOMLZ65js.asyncFold.call(void 0, 
+    make(),
+    (error) => {
+      if (remaining > 0 && options.while(error)) return loop(remaining - 1);
+      return _chunkTGOMLZ65js.asyncFail.call(void 0, error);
+    },
+    (value) => _chunkTGOMLZ65js.asyncSucceed.call(void 0, value)
+  );
+  return loop(options.times);
+};
+
+// src/agent/tools/timeout.ts
+var sleep = (ms) => _chunkTGOMLZ65js.async.call(void 0, (_env, cb) => {
+  const id = setTimeout(() => cb({ _tag: "Success", value: void 0 }), ms);
+  return () => clearTimeout(id);
+});
+var timeout = (effect, ms, scope) => _chunkTGOMLZ65js.race.call(void 0, 
+  effect,
+  _chunkTGOMLZ65js.asyncFlatMap.call(void 0, sleep(ms), () => _chunkTGOMLZ65js.asyncFail.call(void 0, { _tag: "ToolTimeout", timeoutMs: ms })),
+  scope
+);
+
+// src/agent/tools/policy.ts
+var isTransient = (error) => error._tag === "LLMError" || error._tag === "ToolTimeout";
+var defaultPolicyFor = (action) => {
+  switch (action.type) {
+    case "fs.readFile":
+    case "fs.exists":
+    case "fs.searchText":
+      return { timeoutMs: 5e3, retries: 1, retryable: isTransient };
+    case "llm.complete":
+      return { timeoutMs: 6e4, retries: 2, retryable: isTransient };
+    case "shell.exec":
+      return { timeoutMs: 12e4, retries: 0, retryable: () => false };
+    case "patch.propose":
+    case "agent.finish":
+    case "agent.fail":
+      return { timeoutMs: 1e3, retries: 0, retryable: () => false };
+    case "patch.apply":
+    case "patch.rollback":
+      return { timeoutMs: 15e3, retries: 0, retryable: () => false };
+  }
+};
+var configuredPolicyFor = (action, overrides) => {
+  const base = defaultPolicyFor(action);
+  const override = _optionalChain([overrides, 'optionalAccess', _121 => _121[action.type]]);
+  return {
+    ...base,
+    timeoutMs: _optionalChain([override, 'optionalAccess', _122 => _122.timeoutMs]) !== void 0 ? Math.max(1, Math.floor(override.timeoutMs)) : base.timeoutMs,
+    retries: _optionalChain([override, 'optionalAccess', _123 => _123.retries]) !== void 0 ? Math.max(0, Math.floor(override.retries)) : base.retries
+  };
+};
+var runAuthorizedAction = (action, state, scope) => _chunkTGOMLZ65js.asyncFlatMap.call(void 0, _chunkTGOMLZ65js.asyncSync.call(void 0, (env) => env.toolPolicies), (toolPolicies) => {
+  const policy = configuredPolicyFor(action, toolPolicies);
+  return retry(() => timeout(actionToEffect(action, state), policy.timeoutMs, scope), {
+    times: policy.retries,
+    while: policy.retryable
+  });
+});
+var rejected = (action, reason) => ({
+  _tag: "ApprovalRejected",
+  action,
+  reason
+});
+var emitApprovalResolved = (action, state, approved, reason) => _chunkTGOMLZ65js.asyncFlatMap.call(void 0, 
+  nowMillis(),
+  (at) => emitAgentEvent({
+    type: "agent.approval.resolved",
+    action,
+    step: state.steps + 1,
+    phase: state.phase,
+    approved,
+    ...reason ? { reason } : {},
+    at
+  })
+);
+var requestApproval = (action, state, decision) => {
+  const defaultAnswer = _nullishCoalesce(decision.defaultAnswer, () => ( "reject"));
+  return _chunkTGOMLZ65js.asyncFlatMap.call(void 0, 
+    nowMillis(),
+    (at) => _chunkTGOMLZ65js.asyncFlatMap.call(void 0, 
+      emitAgentEvent({
+        type: "agent.approval.requested",
+        action,
+        step: state.steps + 1,
+        phase: state.phase,
+        reason: decision.reason,
+        risk: decision.risk,
+        defaultAnswer,
+        at
+      }),
+      () => _chunkTGOMLZ65js.asyncFlatMap.call(void 0, service("approvals"), (approvals) => {
+        if (!approvals) {
+          const reason = "No approval service configured.";
+          return _chunkTGOMLZ65js.asyncFlatMap.call(void 0, 
+            emitApprovalResolved(action, state, false, reason),
+            () => _chunkTGOMLZ65js.asyncFail.call(void 0, rejected(action, reason))
+          );
+        }
+        return _chunkTGOMLZ65js.asyncFlatMap.call(void 0, 
+          approvals.request({
+            action,
+            state,
+            reason: decision.reason,
+            risk: decision.risk,
+            defaultAnswer
+          }),
+          (response) => {
+            if (response.type === "approved") {
+              return _chunkTGOMLZ65js.asyncFlatMap.call(void 0, 
+                emitApprovalResolved(action, state, true, void 0),
+                () => _chunkTGOMLZ65js.asyncSucceed.call(void 0, void 0)
+              );
+            }
+            const reason = _nullishCoalesce(response.reason, () => ( "Approval rejected."));
+            return _chunkTGOMLZ65js.asyncFlatMap.call(void 0, 
+              emitApprovalResolved(action, state, false, reason),
+              () => _chunkTGOMLZ65js.asyncFail.call(void 0, rejected(action, reason))
+            );
+          }
+        );
+      })
+    )
+  );
+};
+var invokeAction = (action, state, scope) => _chunkTGOMLZ65js.asyncFlatMap.call(void 0, 
+  service("permissions"),
+  (permissions) => _chunkTGOMLZ65js.asyncFlatMap.call(void 0, permissions.check(action, state), (decision) => {
+    if (decision.type === "deny") {
+      return _chunkTGOMLZ65js.asyncFail.call(void 0, {
+        _tag: "PermissionDenied",
+        action,
+        reason: decision.reason
+      });
+    }
+    if (decision.type === "ask") {
+      return _chunkTGOMLZ65js.asyncFlatMap.call(void 0, 
+        requestApproval(action, state, decision),
+        () => runAuthorizedAction(action, state, scope)
+      );
+    }
+    return runAuthorizedAction(action, state, scope);
+  })
+);
+
+// src/agent/core/runAgent.ts
+var executeAction = (action, state, scope) => _chunkTGOMLZ65js.asyncFlatMap.call(void 0, 
+  nowMillis(),
+  (startedAt) => _chunkTGOMLZ65js.asyncFlatMap.call(void 0, 
+    emitAgentEvent({
+      type: "agent.action.started",
+      action,
+      step: state.steps + 1,
+      phase: state.phase,
+      at: startedAt
+    }),
+    () => _chunkTGOMLZ65js.asyncFold.call(void 0, 
+      invokeAction(action, state, scope),
+      (error) => _chunkTGOMLZ65js.asyncFlatMap.call(void 0, nowMillis(), (endedAt) => {
+        const specific = errorEventFor(action, state, error, endedAt);
+        const events = [
+          ...specific ? [specific] : [],
+          {
+            type: "agent.action.failed",
+            action,
+            error,
+            step: state.steps + 1,
+            phase: state.phase,
+            durationMs: endedAt - startedAt,
+            at: endedAt
+          }
+        ];
+        return _chunkTGOMLZ65js.asyncFlatMap.call(void 0, 
+          emitAgentEvents(events),
+          () => _chunkTGOMLZ65js.asyncSucceed.call(void 0, { type: "agent.error", error })
+        );
+      }),
+      (observation) => _chunkTGOMLZ65js.asyncFlatMap.call(void 0, 
+        nowMillis(),
+        (endedAt) => _chunkTGOMLZ65js.asyncFlatMap.call(void 0, 
+          emitAgentEvent({
+            type: "agent.action.completed",
+            action,
+            observation,
+            step: state.steps + 1,
+            phase: state.phase,
+            durationMs: endedAt - startedAt,
+            at: endedAt
+          }),
+          () => _chunkTGOMLZ65js.asyncSucceed.call(void 0, observation)
+        )
+      )
+    )
+  )
+);
+var recordObservation = (next, observation) => _chunkTGOMLZ65js.asyncFlatMap.call(void 0, nowMillis(), (at) => {
+  const specific = observationEventFor(next, observation, at);
+  const events = [
+    {
+      type: "agent.observation.recorded",
+      observation,
+      step: next.steps,
+      phase: next.phase,
+      at
+    },
+    ...specific ? [specific] : []
+  ];
+  return emitAgentEvents(events);
+});
+var runLoop = (state, scope, runStartedAt) => {
+  if (isTerminal(state)) {
+    return _chunkTGOMLZ65js.asyncFlatMap.call(void 0, 
+      nowMillis(),
+      (at) => _chunkTGOMLZ65js.asyncFlatMap.call(void 0, 
+        emitAgentEvent({
+          type: "agent.run.completed",
+          goal: state.goal,
+          status: runStatusFor(state.phase),
+          phase: state.phase,
+          steps: state.steps,
+          durationMs: at - runStartedAt,
+          at
+        }),
+        () => _chunkTGOMLZ65js.asyncSucceed.call(void 0, state)
+      )
+    );
+  }
+  return _chunkTGOMLZ65js.asyncFlatMap.call(void 0, 
+    decideNextAction(state),
+    (action) => _chunkTGOMLZ65js.asyncFlatMap.call(void 0, executeAction(action, state, scope), (observation) => {
+      const next = reduceAgentState(state, observation);
+      return _chunkTGOMLZ65js.asyncFlatMap.call(void 0, 
+        recordObservation(next, observation),
+        () => runLoop(next, scope, runStartedAt)
+      );
+    })
+  );
+};
+var runAgent = (runtime, goal) => _chunkTGOMLZ65js.withScopeAsync.call(void 0, 
+  runtime,
+  (scope) => _chunkTGOMLZ65js.asyncFlatMap.call(void 0, 
+    nowMillis(),
+    (startedAt) => _chunkTGOMLZ65js.asyncFlatMap.call(void 0, 
+      emitAgentEvent({ type: "agent.run.started", goal, at: startedAt }),
+      () => runLoop(initialAgentState(goal), scope, startedAt)
+    )
+  )
+);
+
+// src/agent/core/config.ts
+var isAgentConfigMode = (value) => value === "read-only" || value === "propose" || value === "write" || value === "autonomous";
+var isAgentConfigApprovalMode = (value) => value === "auto" || value === "interactive" || value === "approve" || value === "deny";
+var isAgentConfigLLMProvider = (value) => value === "fake" || value === "google" || value === "gemini" || value === "openai" || value === "openai-compatible";
+var AGENT_CONFIG_FILE_NAMES = [".brass-agent.json", "brass-agent.config.json"];
+
+// src/agent/core/batch.ts
+var isAgentPreset = (value) => value === "fix-tests" || value === "inspect" || value === "typecheck" || value === "lint";
+var goalForAgentPreset = (preset) => {
+  switch (preset) {
+    case "fix-tests":
+      return "fix the failing tests";
+    case "inspect":
+      return "inspect this workspace and summarize the current project state";
+    case "typecheck":
+      return "run typecheck discovery and fix type errors if possible";
+    case "lint":
+      return "run lint discovery and fix lint errors if possible";
+  }
+};
+
+// src/agent/tools/permissions.ts
+var DEFAULT_SAFE_SHELL_PATTERNS = [
+  "npm test",
+  "npm run test*",
+  "npm run typecheck",
+  "npm run type-check",
+  "npm run check-types",
+  "npm run tsc",
+  "npm run check",
+  "npm run *check*",
+  "npm run *doctor*",
+  "npm run *health*",
+  "npm run *verify*",
+  "npm run *validate*",
+  "npm run repo:check",
+  "npm run lint*",
+  "pnpm test",
+  "pnpm run test*",
+  "pnpm run typecheck",
+  "pnpm run type-check",
+  "pnpm run check-types",
+  "pnpm run tsc",
+  "pnpm run check",
+  "pnpm run *check*",
+  "pnpm run *doctor*",
+  "pnpm run *health*",
+  "pnpm run *verify*",
+  "pnpm run *validate*",
+  "pnpm run repo:check",
+  "pnpm run lint*",
+  "yarn test",
+  "yarn run test*",
+  "yarn run typecheck",
+  "yarn run type-check",
+  "yarn run check-types",
+  "yarn run tsc",
+  "yarn run check",
+  "yarn run *check*",
+  "yarn run *doctor*",
+  "yarn run *health*",
+  "yarn run *verify*",
+  "yarn run *validate*",
+  "yarn run repo:check",
+  "yarn run lint*",
+  "bun run test*",
+  "bun run typecheck",
+  "bun run type-check",
+  "bun run check-types",
+  "bun run tsc",
+  "bun run check",
+  "bun run *check*",
+  "bun run *doctor*",
+  "bun run *health*",
+  "bun run *verify*",
+  "bun run *validate*",
+  "bun run repo:check",
+  "bun run lint*",
+  "cargo check",
+  "cargo test",
+  "cargo fmt --check",
+  "cargo clippy",
+  "cargo clippy *",
+  "git status",
+  "git diff",
+  "git log"
+];
+var normalizeCommandText = (value) => value.trim().replace(/\s+/g, " ");
+var shellCommandText = (command) => normalizeCommandText(command.join(" "));
+var escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+var matchesPattern = (command, pattern) => {
+  const normalizedCommand = shellCommandText(command);
+  const normalizedPattern = normalizeCommandText(pattern);
+  if (!normalizedPattern.includes("*")) return normalizedCommand === normalizedPattern;
+  const re = new RegExp(`^${normalizedPattern.split("*").map(escapeRegExp).join(".*")}$`);
+  return re.test(normalizedCommand);
+};
+var matchAny = (command, patterns) => Boolean(_optionalChain([patterns, 'optionalAccess', _124 => _124.some, 'call', _125 => _125((pattern) => matchesPattern(command, pattern))]));
+var allow = () => ({ type: "allow" });
+var deny = (reason) => ({ type: "deny", reason });
+var ask = (reason, risk, defaultAnswer = "reject") => ({ type: "ask", reason, risk, defaultAnswer });
+var describeCommand = (action) => action.type === "shell.exec" ? action.command.join(" ") : action.type;
+var shellAskRulePattern = (rule) => typeof rule === "string" ? rule : rule.pattern;
+var shellAskDecision = (command, rules) => {
+  const rule = _optionalChain([rules, 'optionalAccess', _126 => _126.find, 'call', _127 => _127((candidate) => matchesPattern(command, shellAskRulePattern(candidate)))]);
+  if (!rule) return void 0;
+  if (typeof rule === "string") {
+    return ask(`Run command: ${shellCommandText(command)}`, "high", "reject");
+  }
+  return ask(
+    _nullishCoalesce(rule.reason, () => ( `Run command: ${shellCommandText(command)}`)),
+    _nullishCoalesce(rule.risk, () => ( "high")),
+    _nullishCoalesce(rule.defaultAnswer, () => ( "reject"))
+  );
+};
+var configuredShellAllowPatterns = (config) => [
+  ..._optionalChain([config, 'optionalAccess', _128 => _128.inheritDefaults]) === false ? [] : DEFAULT_SAFE_SHELL_PATTERNS,
+  ..._nullishCoalesce(_optionalChain([config, 'optionalAccess', _129 => _129.allow]), () => ( []))
+];
+var shellDecisionFromConfig = (command, config) => {
+  if (matchAny(command, _optionalChain([config, 'optionalAccess', _130 => _130.deny]))) return deny(`Command denied by policy: ${shellCommandText(command)}`);
+  const askDecision = shellAskDecision(command, _optionalChain([config, 'optionalAccess', _131 => _131.ask]));
+  if (askDecision) return askDecision;
+  if (matchAny(command, configuredShellAllowPatterns(config))) return allow();
+  return void 0;
+};
+var defaultPatchMutationReason = (action) => action.type === "patch.rollback" ? "Reverse-apply a patch to restore the workspace." : "Apply the proposed patch to the workspace.";
+var patchApplyDecisionFromConfig = (action, config) => {
+  const defaultReason = defaultPatchMutationReason(action);
+  if (!config) return ask(defaultReason, "high", "reject");
+  const decision = typeof config === "string" ? config : _nullishCoalesce(config.decision, () => ( "ask"));
+  const reason = typeof config === "string" ? defaultReason : _nullishCoalesce(config.reason, () => ( defaultReason));
+  const risk = typeof config === "string" ? "high" : _nullishCoalesce(config.risk, () => ( "high"));
+  const defaultAnswer = typeof config === "string" ? "reject" : _nullishCoalesce(config.defaultAnswer, () => ( "reject"));
+  if (decision === "allow") return allow();
+  if (decision === "deny") return deny(reason);
+  return ask(reason, risk, defaultAnswer);
+};
+var makeConfiguredPermissions = (config = {}) => ({
+  check: (action, state) => {
+    switch (state.goal.mode) {
+      case "read-only": {
+        if (action.type === "fs.readFile" || action.type === "fs.exists" || action.type === "fs.searchText" || action.type === "llm.complete" || action.type === "agent.finish" || action.type === "agent.fail") {
+          return _chunkTGOMLZ65js.asyncSucceed.call(void 0, allow());
+        }
+        return _chunkTGOMLZ65js.asyncSucceed.call(void 0, deny(`Action ${action.type} is not allowed in read-only mode`));
+      }
+      case "propose": {
+        if (action.type === "shell.exec") {
+          const decision = shellDecisionFromConfig(action.command, config.shell);
+          return _chunkTGOMLZ65js.asyncSucceed.call(void 0, 
+            _nullishCoalesce(decision, () => ( deny(`Command not whitelisted: ${action.command.join(" ")}`)))
+          );
+        }
+        if (action.type === "patch.apply" || action.type === "patch.rollback") {
+          return _chunkTGOMLZ65js.asyncSucceed.call(void 0, deny(`${action.type} is not allowed in propose mode; use write mode or --apply.`));
+        }
+        return _chunkTGOMLZ65js.asyncSucceed.call(void 0, allow());
+      }
+      case "write": {
+        if (action.type === "shell.exec") {
+          const decision = shellDecisionFromConfig(action.command, config.shell);
+          return _chunkTGOMLZ65js.asyncSucceed.call(void 0, 
+            _nullishCoalesce(decision, () => ( deny(`Command not whitelisted: ${action.command.join(" ")}`)))
+          );
+        }
+        if (action.type === "patch.apply" || action.type === "patch.rollback") {
+          return _chunkTGOMLZ65js.asyncSucceed.call(void 0, patchApplyDecisionFromConfig(action, config.patchApply));
+        }
+        return _chunkTGOMLZ65js.asyncSucceed.call(void 0, allow());
+      }
+      case "autonomous": {
+        if (action.type === "patch.apply" || action.type === "patch.rollback") {
+          return _chunkTGOMLZ65js.asyncSucceed.call(void 0, patchApplyDecisionFromConfig(action, config.patchApply));
+        }
+        if (action.type === "shell.exec") {
+          const decision = shellDecisionFromConfig(action.command, config.shell);
+          return _chunkTGOMLZ65js.asyncSucceed.call(void 0, 
+            _nullishCoalesce(decision, () => ( ask(`Run non-whitelisted command: ${describeCommand(action)}`, "high", "reject")))
+          );
+        }
+        return _chunkTGOMLZ65js.asyncSucceed.call(void 0, allow());
+      }
+    }
+  }
+});
+var defaultPermissions = makeConfiguredPermissions();
+
+// src/agent/tools/approvals.ts
+var autoApproveApprovals = {
+  request: () => _chunkTGOMLZ65js.asyncSucceed.call(void 0, { type: "approved" })
+};
+var makeAutoDenyApprovals = (reason = "Approval denied by non-interactive policy.") => ({
+  request: () => _chunkTGOMLZ65js.asyncSucceed.call(void 0, { type: "rejected", reason })
+});
+
+// src/agent/node/nodeShell.ts
+var dynamicImport = new Function("specifier", "return import(specifier)");
+var chunkToString = (chunk) => {
+  const maybeToString = _optionalChain([chunk, 'optionalAccess', _132 => _132.toString]);
+  return typeof maybeToString === "function" ? maybeToString.call(chunk, "utf8") : String(chunk);
+};
+var NodeShell = {
+  exec: (command, options) => _chunkTGOMLZ65js.async.call(void 0, (_env, cb) => {
+    const [bin, ...args] = command;
+    if (!bin) {
+      cb(
+        _chunkTGOMLZ65js.Exit.failCause(
+          _chunkTGOMLZ65js.Cause.fail({
+            _tag: "ShellError",
+            operation: "exec",
+            command,
+            cause: new Error("Empty command")
+          })
+        )
+      );
+      return;
+    }
+    let stdout = "";
+    let stderr = "";
+    let done = false;
+    let child;
+    dynamicImport("node:child_process").then(({ spawn }) => {
+      if (done) return;
+      child = spawn(bin, args, {
+        cwd: options.cwd,
+        shell: false,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      _optionalChain([child, 'access', _133 => _133.stdout, 'optionalAccess', _134 => _134.on, 'call', _135 => _135("data", (chunk) => {
+        stdout += chunkToString(chunk);
+      })]);
+      _optionalChain([child, 'access', _136 => _136.stderr, 'optionalAccess', _137 => _137.on, 'call', _138 => _138("data", (chunk) => {
+        stderr += chunkToString(chunk);
+      })]);
+      child.on("error", (cause) => {
+        if (done) return;
+        done = true;
+        cb(
+          _chunkTGOMLZ65js.Exit.failCause(
+            _chunkTGOMLZ65js.Cause.fail({
+              _tag: "ShellError",
+              operation: "exec",
+              command,
+              cause
+            })
+          )
+        );
+      });
+      child.on("close", (code) => {
+        if (done) return;
+        done = true;
+        cb(
+          _chunkTGOMLZ65js.Exit.succeed({
+            exitCode: _nullishCoalesce(code, () => ( 1)),
+            stdout,
+            stderr
+          })
+        );
+      });
+      if (options.stdin !== void 0) {
+        _optionalChain([child, 'access', _139 => _139.stdin, 'optionalAccess', _140 => _140.end, 'call', _141 => _141(options.stdin)]);
+      } else {
+        _optionalChain([child, 'access', _142 => _142.stdin, 'optionalAccess', _143 => _143.end, 'call', _144 => _144()]);
+      }
+    }).catch((cause) => {
+      if (done) return;
+      done = true;
+      cb(
+        _chunkTGOMLZ65js.Exit.failCause(
+          _chunkTGOMLZ65js.Cause.fail({
+            _tag: "ShellError",
+            operation: "exec",
+            command,
+            cause
+          })
+        )
+      );
+    });
+    return () => {
+      if (done) return;
+      done = true;
+      _optionalChain([child, 'optionalAccess', _145 => _145.kill, 'optionalCall', _146 => _146("SIGTERM")]);
+    };
+  })
+};
+
+// src/agent/node/nodeFileSystem.ts
+var dynamicImport2 = new Function("specifier", "return import(specifier)");
+var parseRipgrep = (stdout) => stdout.split("\n").filter(Boolean).map((line) => {
+  const [path = "", lineNo = "0", ...rest] = line.split(":");
+  return { path, line: Number(lineNo), text: rest.join(":") };
+});
+var makeNodeFileSystem = (shell) => ({
+  readFile: (path) => _chunkTGOMLZ65js.fromPromiseAbortable.call(void 0, 
+    _chunkTGOMLZ65js.async.call(void 0, signal) => {
+      const { readFile } = await dynamicImport2("node:fs/promises");
+      return readFile(path, { encoding: "utf8", signal });
+    },
+    (cause) => ({ _tag: "FsError", operation: "readFile", cause })
+  ),
+  exists: (path) => _chunkTGOMLZ65js.fromPromiseAbortable.call(void 0, 
+    _chunkTGOMLZ65js.async.call(void 0, signal) => {
+      if (signal.aborted) return false;
+      const { stat } = await dynamicImport2("node:fs/promises");
+      if (signal.aborted) return false;
+      try {
+        await stat(path);
+        return true;
+      } catch (e6) {
+        return false;
+      }
+    },
+    (cause) => ({ _tag: "FsError", operation: "exists", cause })
+  ),
+  searchText: (cwd, query, options) => _chunkTGOMLZ65js.asyncFlatMap.call(void 0, 
+    shell.exec(
+      [
+        "rg",
+        "--fixed-strings",
+        "--line-number",
+        "--no-heading",
+        "--color",
+        "never",
+        "--max-count",
+        "5",
+        ..._nullishCoalesce(_optionalChain([options, 'optionalAccess', _147 => _147.globs, 'optionalAccess', _148 => _148.flatMap, 'call', _149 => _149((glob) => ["--glob", glob])]), () => ( [])),
+        "--",
+        query,
+        "."
+      ],
+      { cwd }
+    ),
+    (result) => {
+      if (result.exitCode > 1) {
+        return _chunkTGOMLZ65js.asyncFail.call(void 0, {
+          _tag: "FsError",
+          operation: "searchText",
+          cause: result.stderr
+        });
+      }
+      return _chunkTGOMLZ65js.asyncSucceed.call(void 0, parseRipgrep(result.stdout));
+    }
+  )
+});
+
+// src/agent/node/nodePatchService.ts
+var validatePatchTargets = (cwd, paths) => paths.reduce(
+  (acc, path) => _chunkTGOMLZ65js.asyncFlatMap.call(void 0, 
+    acc,
+    (validated) => _chunkTGOMLZ65js.asyncFlatMap.call(void 0, 
+      resolveWorkspacePath(cwd, path),
+      () => _chunkTGOMLZ65js.asyncSucceed.call(void 0, [...validated, path])
+    )
+  ),
+  _chunkTGOMLZ65js.asyncSucceed.call(void 0, [])
+);
+var patchFailure = (operation, cause, patch) => ({
+  _tag: "PatchError",
+  operation,
+  cause,
+  patch
+});
+var makeNodePatchService = (shell) => {
+  const runGitApply = (cwd, rawPatch, reverse) => {
+    const patch = _nullishCoalesce(extractUnifiedDiff(rawPatch), () => ( rawPatch.trim()));
+    const changedFiles = extractPatchPaths(patch);
+    const stdin = `${patch.trim()}
+`;
+    const operation = reverse ? "rollback" : "apply";
+    if (!patch || !changedFiles.length) {
+      return _chunkTGOMLZ65js.asyncFail.call(void 0, 
+        patchFailure("extract", "No unified diff with workspace-scoped paths was found.", rawPatch)
+      );
+    }
+    const applyArgs = [
+      "git",
+      "apply",
+      ...reverse ? ["--reverse"] : [],
+      "--recount",
+      "--whitespace=nowarn",
+      "-"
+    ];
+    const checkArgs = [
+      "git",
+      "apply",
+      ...reverse ? ["--reverse"] : [],
+      "--check",
+      "--recount",
+      "--whitespace=nowarn",
+      "-"
+    ];
+    return _chunkTGOMLZ65js.asyncFlatMap.call(void 0, 
+      validatePatchTargets(cwd, changedFiles),
+      () => _chunkTGOMLZ65js.asyncFlatMap.call(void 0, 
+        shell.exec(checkArgs, { cwd, stdin }),
+        (checkResult) => {
+          if (checkResult.exitCode !== 0) {
+            return _chunkTGOMLZ65js.asyncFail.call(void 0, 
+              patchFailure(
+                `${operation}.check`,
+                checkResult.stderr || checkResult.stdout || `git apply --check exited with ${checkResult.exitCode}`,
+                patch
+              )
+            );
+          }
+          return _chunkTGOMLZ65js.asyncFlatMap.call(void 0, 
+            shell.exec(applyArgs, { cwd, stdin }),
+            (applyResult) => {
+              if (applyResult.exitCode !== 0) {
+                return _chunkTGOMLZ65js.asyncFail.call(void 0, 
+                  patchFailure(
+                    operation,
+                    applyResult.stderr || applyResult.stdout || `git apply exited with ${applyResult.exitCode}`,
+                    patch
+                  )
+                );
+              }
+              return _chunkTGOMLZ65js.asyncSucceed.call(void 0, { changedFiles });
+            }
+          );
+        }
+      )
+    );
+  };
+  return {
+    apply: (cwd, rawPatch) => runGitApply(cwd, rawPatch, false),
+    rollback: (cwd, rawPatch) => runGitApply(cwd, rawPatch, true)
+  };
+};
+
+// src/agent/node/nodeAgentConfig.ts
+var dynamicImport3 = new Function("specifier", "return import(specifier)");
+var isRecord3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var assertStringArray = (value, path) => {
+  if (value === void 0) return;
+  if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
+    throw new Error(`${path} must be an array of strings.`);
+  }
+};
+var assertNumber = (value, path) => {
+  if (value === void 0) return;
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new Error(`${path} must be a finite number.`);
+  }
+};
+var assertBoolean = (value, path) => {
+  if (value === void 0) return;
+  if (typeof value !== "boolean") throw new Error(`${path} must be a boolean.`);
+};
+var assertString = (value, path) => {
+  if (value === void 0) return;
+  if (typeof value !== "string") throw new Error(`${path} must be a string.`);
+};
+var validateBatchGoal = (value, path) => {
+  if (typeof value === "string") return;
+  if (!isRecord3(value)) throw new Error(`${path} must be a string or object.`);
+  assertString(value.goal, `${path}.goal`);
+  assertString(value.cwd, `${path}.cwd`);
+  assertString(value.patchFile, `${path}.patchFile`);
+  assertString(value.saveRunDir, `${path}.saveRunDir`);
+  if (value.preset !== void 0) {
+    if (typeof value.preset !== "string" || !isAgentPreset(value.preset)) {
+      throw new Error(`${path}.preset must be one of: fix-tests, inspect, typecheck, lint.`);
+    }
+  }
+  if (value.mode !== void 0) {
+    if (typeof value.mode !== "string" || !isAgentConfigMode(value.mode)) {
+      throw new Error(`${path}.mode must be one of: read-only, propose, write, autonomous.`);
+    }
+  }
+  if (value.patchFileMode !== void 0 && value.patchFileMode !== "apply" && value.patchFileMode !== "rollback") {
+    throw new Error(`${path}.patchFileMode must be apply or rollback.`);
+  }
+  if (value.goal === void 0 && value.preset === void 0 && value.patchFile === void 0) {
+    throw new Error(`${path} must include goal, preset, or patchFile.`);
+  }
+};
+var validateAgentConfig = (config, sourcePath) => {
+  if (!isRecord3(config)) throw new Error(`Agent config at ${sourcePath} must be a JSON object.`);
+  if (config.mode !== void 0) {
+    if (typeof config.mode !== "string" || !isAgentConfigMode(config.mode)) {
+      throw new Error("config.mode must be one of: read-only, propose, write, autonomous.");
+    }
+  }
+  if (config.approval !== void 0) {
+    if (typeof config.approval !== "string" || !isAgentConfigApprovalMode(config.approval)) {
+      throw new Error("config.approval must be one of: auto, interactive, approve, deny.");
+    }
+  }
+  if (config.llm !== void 0) {
+    if (!isRecord3(config.llm)) throw new Error("config.llm must be an object.");
+    if (config.llm.provider !== void 0) {
+      if (typeof config.llm.provider !== "string" || !isAgentConfigLLMProvider(config.llm.provider)) {
+        throw new Error("config.llm.provider must be one of: fake, google, gemini, openai, openai-compatible.");
+      }
+    }
+    if ("apiKey" in config.llm) {
+      throw new Error("config.llm.apiKey is not supported. Store secrets in environment variables and use config.llm.apiKeyEnv instead.");
+    }
+    assertString(config.llm.model, "config.llm.model");
+    assertString(config.llm.endpoint, "config.llm.endpoint");
+    assertString(config.llm.baseUrl, "config.llm.baseUrl");
+    assertString(config.llm.apiVersion, "config.llm.apiVersion");
+    assertString(config.llm.apiKeyEnv, "config.llm.apiKeyEnv");
+    assertString(config.llm.systemInstruction, "config.llm.systemInstruction");
+    assertString(config.llm.fakeResponse, "config.llm.fakeResponse");
+    assertNumber(config.llm.temperature, "config.llm.temperature");
+    assertNumber(config.llm.topP, "config.llm.topP");
+    assertNumber(config.llm.topK, "config.llm.topK");
+    assertNumber(config.llm.maxOutputTokens, "config.llm.maxOutputTokens");
+  }
+  if (config.project !== void 0) {
+    if (!isRecord3(config.project)) throw new Error("config.project must be an object.");
+    if (config.project.packageManager !== void 0) {
+      if (typeof config.project.packageManager !== "string" || !["auto", "npm", "pnpm", "yarn", "bun"].includes(config.project.packageManager)) {
+        throw new Error("config.project.packageManager must be one of: auto, npm, pnpm, yarn, bun.");
+      }
+    }
+    assertStringArray(config.project.validationCommands, "config.project.validationCommands");
+    assertStringArray(config.project.testScriptNames, "config.project.testScriptNames");
+    assertBoolean(config.project.includeTypecheck, "config.project.includeTypecheck");
+    assertBoolean(config.project.includeLint, "config.project.includeLint");
+    assertNumber(config.project.maxValidationCommands, "config.project.maxValidationCommands");
+  }
+  if (config.context !== void 0) {
+    if (!isRecord3(config.context)) throw new Error("config.context must be an object.");
+    assertBoolean(config.context.enabled, "config.context.enabled");
+    assertNumber(config.context.maxSearchQueries, "config.context.maxSearchQueries");
+    assertNumber(config.context.maxFiles, "config.context.maxFiles");
+    assertNumber(config.context.maxSearchResults, "config.context.maxSearchResults");
+    assertStringArray(config.context.globs, "config.context.globs");
+    assertStringArray(config.context.excludeGlobs, "config.context.excludeGlobs");
+  }
+  if (config.patchQuality !== void 0) {
+    if (!isRecord3(config.patchQuality)) throw new Error("config.patchQuality must be an object.");
+    assertBoolean(config.patchQuality.enabled, "config.patchQuality.enabled");
+    assertNumber(config.patchQuality.maxRepairAttempts, "config.patchQuality.maxRepairAttempts");
+    if (typeof config.patchQuality.maxRepairAttempts === "number" && config.patchQuality.maxRepairAttempts < 0) {
+      throw new Error("config.patchQuality.maxRepairAttempts must be greater than or equal to 0.");
+    }
+  }
+  if (config.rollback !== void 0) {
+    if (!isRecord3(config.rollback)) throw new Error("config.rollback must be an object.");
+    assertBoolean(config.rollback.enabled, "config.rollback.enabled");
+    assertBoolean(config.rollback.onFinalValidationFailure, "config.rollback.onFinalValidationFailure");
+    assertBoolean(config.rollback.runValidationAfterRollback, "config.rollback.runValidationAfterRollback");
+    assertBoolean(config.rollback.allowForSuppliedPatches, "config.rollback.allowForSuppliedPatches");
+    assertNumber(config.rollback.maxRollbackDepth, "config.rollback.maxRollbackDepth");
+    if (typeof config.rollback.maxRollbackDepth === "number" && config.rollback.maxRollbackDepth < 0) {
+      throw new Error("config.rollback.maxRollbackDepth must be greater than or equal to 0.");
+    }
+    if (config.rollback.strategy !== void 0 && config.rollback.strategy !== "last" && config.rollback.strategy !== "all") {
+      throw new Error("config.rollback.strategy must be one of: last, all.");
+    }
+  }
+  if (config.redaction !== void 0) {
+    if (!isRecord3(config.redaction)) throw new Error("config.redaction must be an object.");
+    assertBoolean(config.redaction.enabled, "config.redaction.enabled");
+    assertStringArray(config.redaction.additionalPatterns, "config.redaction.additionalPatterns");
+  }
+  if (config.language !== void 0) {
+    if (!isRecord3(config.language)) throw new Error("config.language must be an object.");
+    if (config.language.response !== void 0) {
+      if (typeof config.language.response !== "string" || !["auto", "match-user", "en", "es", "pt", "fr", "de", "it", "custom"].includes(config.language.response)) {
+        throw new Error("config.language.response must be one of: auto, match-user, en, es, pt, fr, de, it, custom.");
+      }
+    }
+    assertString(config.language.custom, "config.language.custom");
+  }
+  if (config.permissions !== void 0) {
+    if (!isRecord3(config.permissions)) throw new Error("config.permissions must be an object.");
+    if (config.permissions.shell !== void 0) {
+      if (!isRecord3(config.permissions.shell)) throw new Error("config.permissions.shell must be an object.");
+      assertBoolean(config.permissions.shell.inheritDefaults, "config.permissions.shell.inheritDefaults");
+      assertStringArray(config.permissions.shell.allow, "config.permissions.shell.allow");
+      assertStringArray(config.permissions.shell.deny, "config.permissions.shell.deny");
+      if (config.permissions.shell.ask !== void 0) {
+        if (!Array.isArray(config.permissions.shell.ask)) throw new Error("config.permissions.shell.ask must be an array.");
+        for (const [index, rule] of config.permissions.shell.ask.entries()) {
+          if (typeof rule === "string") continue;
+          if (!isRecord3(rule)) throw new Error(`config.permissions.shell.ask[${index}] must be a string or object.`);
+          assertString(rule.pattern, `config.permissions.shell.ask[${index}].pattern`);
+          assertString(rule.reason, `config.permissions.shell.ask[${index}].reason`);
+          if (rule.risk !== void 0 && rule.risk !== "low" && rule.risk !== "medium" && rule.risk !== "high") {
+            throw new Error(`config.permissions.shell.ask[${index}].risk must be one of: low, medium, high.`);
+          }
+          if (rule.defaultAnswer !== void 0 && rule.defaultAnswer !== "approve" && rule.defaultAnswer !== "reject") {
+            throw new Error(`config.permissions.shell.ask[${index}].defaultAnswer must be approve or reject.`);
+          }
+        }
+      }
+    }
+    if (config.permissions.patchApply !== void 0) {
+      const patchApply = config.permissions.patchApply;
+      if (typeof patchApply === "string") {
+        if (patchApply !== "allow" && patchApply !== "ask" && patchApply !== "deny") {
+          throw new Error("config.permissions.patchApply must be allow, ask, deny, or an object.");
+        }
+      } else if (isRecord3(patchApply)) {
+        if (patchApply.decision !== void 0 && patchApply.decision !== "allow" && patchApply.decision !== "ask" && patchApply.decision !== "deny") {
+          throw new Error("config.permissions.patchApply.decision must be allow, ask, or deny.");
+        }
+        assertString(patchApply.reason, "config.permissions.patchApply.reason");
+        if (patchApply.risk !== void 0 && patchApply.risk !== "low" && patchApply.risk !== "medium" && patchApply.risk !== "high") {
+          throw new Error("config.permissions.patchApply.risk must be one of: low, medium, high.");
+        }
+        if (patchApply.defaultAnswer !== void 0 && patchApply.defaultAnswer !== "approve" && patchApply.defaultAnswer !== "reject") {
+          throw new Error("config.permissions.patchApply.defaultAnswer must be approve or reject.");
+        }
+      } else {
+        throw new Error("config.permissions.patchApply must be allow, ask, deny, or an object.");
+      }
+    }
+  }
+  if (config.tools !== void 0) {
+    if (!isRecord3(config.tools)) throw new Error("config.tools must be an object.");
+    for (const [name, value] of Object.entries(config.tools)) {
+      if (!isRecord3(value)) throw new Error(`config.tools.${name} must be an object.`);
+      assertNumber(value.timeoutMs, `config.tools.${name}.timeoutMs`);
+      assertNumber(value.retries, `config.tools.${name}.retries`);
+    }
+  }
+  if (config.batch !== void 0) {
+    if (!isRecord3(config.batch)) throw new Error("config.batch must be an object.");
+    assertBoolean(config.batch.stopOnFailure, "config.batch.stopOnFailure");
+    if (config.batch.goals !== void 0) {
+      if (!Array.isArray(config.batch.goals)) throw new Error("config.batch.goals must be an array.");
+      config.batch.goals.forEach((goal, index) => validateBatchGoal(goal, `config.batch.goals[${index}]`));
+    }
+  }
+  return config;
+};
+var isFile = _chunkTGOMLZ65js.async.call(void 0, path) => {
+  const { stat } = await dynamicImport3("node:fs/promises");
+  try {
+    return (await stat(path)).isFile();
+  } catch (e7) {
+    return false;
+  }
+};
+var findConfigPath = _chunkTGOMLZ65js.async.call(void 0, cwd) => {
+  const nodePath = await dynamicImport3("node:path");
+  let current = nodePath.resolve(cwd);
+  while (true) {
+    for (const fileName of AGENT_CONFIG_FILE_NAMES) {
+      const candidate = nodePath.join(current, fileName);
+      if (await isFile(candidate)) return candidate;
+    }
+    const parent = nodePath.dirname(current);
+    if (parent === current) return void 0;
+    current = parent;
+  }
+};
+var readConfigFile = _chunkTGOMLZ65js.async.call(void 0, path) => {
+  const { readFile } = await dynamicImport3("node:fs/promises");
+  const raw = String(await readFile(path, "utf8")).replace(/^\uFEFF/, "");
+  try {
+    return validateAgentConfig(JSON.parse(raw), path);
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      throw new Error(`Invalid JSON in agent config ${path}: ${error.message}`);
+    }
+    throw error;
+  }
+};
+var loadNodeAgentConfig = _chunkTGOMLZ65js.async.call(void 0, options) => {
+  if (options.noConfig) return { config: {} };
+  const nodePath = await dynamicImport3("node:path");
+  if (options.configPath) {
+    const path2 = nodePath.isAbsolute(options.configPath) ? options.configPath : nodePath.resolve(options.cwd, options.configPath);
+    if (!await isFile(path2)) throw new Error(`Agent config not found or not a file: ${path2}`);
+    return { path: path2, config: await readConfigFile(path2) };
+  }
+  const path = await findConfigPath(options.cwd);
+  if (!path) return { config: {} };
+  return { path, config: await readConfigFile(path) };
+};
+
+// src/agent/llm/openAICompatible.ts
+var extractText = (json) => _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_optionalChain([json, 'optionalAccess', _150 => _150.choices, 'optionalAccess', _151 => _151[0], 'optionalAccess', _152 => _152.message, 'optionalAccess', _153 => _153.content]), () => ( _optionalChain([json, 'optionalAccess', _154 => _154.output_text]))), () => ( _optionalChain([json, 'optionalAccess', _155 => _155.content, 'optionalAccess', _156 => _156[0], 'optionalAccess', _157 => _157.text]))), () => ( JSON.stringify(json)));
+var makeOpenAICompatibleLLM = (config) => ({
+  complete: (request) => _chunkTGOMLZ65js.fromPromiseAbortable.call(void 0, 
+    _chunkTGOMLZ65js.async.call(void 0, signal) => {
+      const res = await fetch(config.endpoint, {
+        method: "POST",
+        signal,
+        headers: {
+          "content-type": "application/json",
+          authorization: `Bearer ${config.apiKey}`
+        },
+        body: JSON.stringify({
+          model: config.model,
+          messages: [{ role: "user", content: request.prompt }]
+        })
+      });
+      if (!res.ok) throw new Error(`LLM request failed with ${res.status}`);
+      return { content: extractText(await res.json()) };
+    },
+    (cause) => ({ _tag: "LLMError", cause })
+  )
+});
+
+// src/agent/llm/googleGenerativeAI.ts
+var DEFAULT_MODEL = "gemini-2.5-flash";
+var DEFAULT_API_VERSION = "v1beta";
+var DEFAULT_BASE_URL = "https://generativelanguage.googleapis.com";
+var withoutTrailingSlash = (value) => {
+  let end = value.length;
+  while (end > 0 && value.charCodeAt(end - 1) === 47) {
+    end -= 1;
+  }
+  return end === value.length ? value : value.slice(0, end);
+};
+var normalizeModelName = (model) => model.startsWith("models/") ? model : `models/${model}`;
+var makeGenerateContentEndpoint = (config) => {
+  if (config.endpoint) return config.endpoint;
+  const baseUrl = withoutTrailingSlash(_nullishCoalesce(config.baseUrl, () => ( DEFAULT_BASE_URL)));
+  const apiVersion = _nullishCoalesce(config.apiVersion, () => ( DEFAULT_API_VERSION));
+  const model = normalizeModelName(_nullishCoalesce(config.model, () => ( DEFAULT_MODEL)));
+  return `${baseUrl}/${apiVersion}/${model}:generateContent`;
+};
+var optionalNumber = (value) => typeof value === "number" && Number.isFinite(value) ? value : void 0;
+var omitUndefined = (value) => Object.fromEntries(Object.entries(value).filter(([, field]) => field !== void 0));
+var makeRequestBody = (request, config) => {
+  const generationConfig = omitUndefined({
+    temperature: optionalNumber(config.temperature),
+    topP: optionalNumber(config.topP),
+    topK: optionalNumber(config.topK),
+    maxOutputTokens: optionalNumber(config.maxOutputTokens),
+    stopSequences: config.stopSequences,
+    responseMimeType: config.responseMimeType,
+    ..._nullishCoalesce(config.extraGenerationConfig, () => ( {}))
+  });
+  return omitUndefined({
+    contents: [
+      {
+        role: "user",
+        parts: [{ text: request.prompt }]
+      }
+    ],
+    systemInstruction: config.systemInstruction ? {
+      parts: [{ text: config.systemInstruction }]
+    } : void 0,
+    generationConfig: Object.keys(generationConfig).length > 0 ? generationConfig : void 0
+  });
+};
+var extractGoogleText = (json) => {
+  const text = _optionalChain([json, 'access', _158 => _158.candidates, 'optionalAccess', _159 => _159.flatMap, 'call', _160 => _160((candidate) => _nullishCoalesce(_optionalChain([candidate, 'access', _161 => _161.content, 'optionalAccess', _162 => _162.parts]), () => ( []))), 'access', _163 => _163.map, 'call', _164 => _164((part) => _nullishCoalesce(part.text, () => ( ""))), 'access', _165 => _165.filter, 'call', _166 => _166(Boolean), 'access', _167 => _167.join, 'call', _168 => _168("\n"), 'access', _169 => _169.trim, 'call', _170 => _170()]);
+  if (text) return text;
+  const blockReason = _optionalChain([json, 'access', _171 => _171.promptFeedback, 'optionalAccess', _172 => _172.blockReason]);
+  if (blockReason) {
+    const message = _optionalChain([json, 'access', _173 => _173.promptFeedback, 'optionalAccess', _174 => _174.blockReasonMessage]);
+    throw new Error(`Google Gemini blocked the prompt: ${blockReason}${message ? ` - ${message}` : ""}`);
+  }
+  const finishReason = _optionalChain([json, 'access', _175 => _175.candidates, 'optionalAccess', _176 => _176[0], 'optionalAccess', _177 => _177.finishReason]);
+  if (finishReason) {
+    throw new Error(`Google Gemini returned no text. finishReason=${finishReason}`);
+  }
+  if (_optionalChain([json, 'access', _178 => _178.error, 'optionalAccess', _179 => _179.message])) {
+    throw new Error(`Google Gemini error: ${json.error.message}`);
+  }
+  return JSON.stringify(json);
+};
+var responseErrorMessage = _chunkTGOMLZ65js.async.call(void 0, res) => {
+  const raw = await res.text();
+  try {
+    const json = JSON.parse(raw);
+    return _nullishCoalesce(_optionalChain([json, 'access', _180 => _180.error, 'optionalAccess', _181 => _181.message]), () => ( raw));
+  } catch (e8) {
+    return raw;
+  }
+};
+var makeGoogleGenerativeAILLM = (config) => ({
+  complete: (request) => _chunkTGOMLZ65js.fromPromiseAbortable.call(void 0, 
+    _chunkTGOMLZ65js.async.call(void 0, signal) => {
+      const res = await fetch(makeGenerateContentEndpoint(config), {
+        method: "POST",
+        signal,
+        headers: {
+          "content-type": "application/json",
+          "x-goog-api-key": config.apiKey
+        },
+        body: JSON.stringify(makeRequestBody({ prompt: request.prompt }, config))
+      });
+      if (!res.ok) {
+        const message = await responseErrorMessage(res);
+        throw new Error(`Google Gemini request failed with ${res.status}: ${message}`);
+      }
+      const json = await res.json();
+      return { content: extractGoogleText(json) };
+    },
+    (cause) => ({ _tag: "LLMError", cause })
+  )
+});
+
+// src/agent/llm/fakeLLM.ts
+var defaultContent = (request) => [
+  "Fake LLM response.",
+  "",
+  `Purpose: ${request.purpose}`,
+  "Set BRASS_LLM_PROVIDER=google with GEMINI_API_KEY/GOOGLE_API_KEY, or set BRASS_LLM_ENDPOINT and BRASS_LLM_API_KEY for an OpenAI-compatible model.",
+  "You can also set BRASS_FAKE_LLM_RESPONSE to provide a deterministic offline response, including a fenced ```diff block."
+].join("\n");
+var makeFakeLLM = (options = {}) => ({
+  complete: (request) => _chunkTGOMLZ65js.asyncSucceed.call(void 0, {
+    content: typeof options.content === "function" ? options.content(request) : _nullishCoalesce(options.content, () => ( defaultContent(request)))
+  })
+});
+
+// src/agent/node/nodeWorkspaceDiscovery.ts
+var _fs = require('fs');
+var _path = require('path');
+var WORKSPACE_MARKERS = [
+  { name: ".brass-agent.json", kind: "file" },
+  { name: "brass-agent.config.json", kind: "file" },
+  { name: "package.json", kind: "file" },
+  { name: "pnpm-workspace.yaml", kind: "file" },
+  { name: "turbo.json", kind: "file" },
+  { name: "nx.json", kind: "file" },
+  { name: ".git", kind: "directory" }
+];
+var markerExists2 = (path, kind) => {
+  try {
+    const stat = _fs.statSync.call(void 0, path);
+    return kind === "directory" ? stat.isDirectory() : stat.isFile();
+  } catch (e9) {
+    return false;
+  }
+};
+var firstMarkerIn = (cwd) => {
+  for (const marker of WORKSPACE_MARKERS) {
+    const markerPath = _path.join.call(void 0, cwd, marker.name);
+    if (markerExists2(markerPath, marker.kind)) {
+      return { marker: marker.name, markerPath };
+    }
+  }
+  return void 0;
+};
+var discoverNodeWorkspaceRoot = (cwd, options = {}) => {
+  const inputCwd = _path.resolve.call(void 0, cwd);
+  if (options.enabled === false) {
+    return {
+      inputCwd,
+      cwd: inputCwd,
+      changed: false,
+      disabled: true
+    };
+  }
+  if (!_fs.existsSync.call(void 0, inputCwd)) {
+    return {
+      inputCwd,
+      cwd: inputCwd,
+      changed: false
+    };
+  }
+  let current = inputCwd;
+  while (true) {
+    const match = firstMarkerIn(current);
+    if (match) {
+      return {
+        inputCwd,
+        cwd: current,
+        marker: match.marker,
+        markerPath: match.markerPath,
+        changed: current !== inputCwd
+      };
+    }
+    const parent = _path.dirname.call(void 0, current);
+    if (parent === current) {
+      return {
+        inputCwd,
+        cwd: inputCwd,
+        changed: false
+      };
+    }
+    current = parent;
+  }
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.initialAgentState = initialAgentState; exports.reduceAgentState = reduceAgentState; exports.isTerminal = isTerminal; exports.extractLikelyFilePaths = extractLikelyFilePaths; exports.deriveContextSearchQueries = deriveContextSearchQueries; exports.describeContextDiscovery = describeContextDiscovery; exports.summarizeContextDiscovery = summarizeContextDiscovery; exports.nextContextDiscoveryAction = nextContextDiscoveryAction; exports.PROJECT_PROFILE_PROBES = PROJECT_PROFILE_PROBES; exports.projectProfileProbePending = projectProfileProbePending; exports.discoverProjectProfile = discoverProjectProfile; exports.describeProjectProfile = describeProjectProfile; exports.PROJECT_LOCKFILE_PROBES = PROJECT_LOCKFILE_PROBES; exports.parseProjectPackageJson = parseProjectPackageJson; exports.nextProjectProbeAction = nextProjectProbeAction; exports.discoverPackageManager = discoverPackageManager; exports.splitCommand = splitCommand; exports.commandForScript = commandForScript; exports.discoverValidationCommands = discoverValidationCommands; exports.nextUnrunValidationCommand = nextUnrunValidationCommand; exports.describeCommandDiscovery = describeCommandDiscovery; exports.patchRepairAttemptsUsed = patchRepairAttemptsUsed; exports.patchQualitySummary = patchQualitySummary; exports.canRequestPatchRepair = canRequestPatchRepair; exports.patchValidationStatus = patchValidationStatus; exports.describePatchQuality = describePatchQuality; exports.rollbackSafetySummary = rollbackSafetySummary; exports.unappliedPatchStack = unappliedPatchStack; exports.latestUnappliedPatch = latestUnappliedPatch; exports.canAutoRollback = canAutoRollback; exports.shouldContinueRollbackStack = shouldContinueRollbackStack; exports.workspaceValidationStatus = workspaceValidationStatus; exports.describeRollbackSafety = describeRollbackSafety; exports.extractUnifiedDiff = extractUnifiedDiff; exports.extractPatchPaths = extractPatchPaths; exports.isRedactionEnabled = isRedactionEnabled; exports.redactText = redactText; exports.inferUserLanguage = inferUserLanguage; exports.responseLanguageName = responseLanguageName; exports.describeLanguagePolicy = describeLanguagePolicy; exports.spanishLike = spanishLike; exports.decideNextAction = decideNextAction; exports.nowMillis = nowMillis; exports.emitAgentEvent = emitAgentEvent; exports.emitAgentEvents = emitAgentEvents; exports.summarizeAgentAction = summarizeAgentAction; exports.summarizeAgentObservation = summarizeAgentObservation; exports.observationStatus = observationStatus; exports.errorEventFor = errorEventFor; exports.observationEventFor = observationEventFor; exports.runStatusFor = runStatusFor; exports.retry = retry; exports.sleep = sleep; exports.timeout = timeout; exports.invokeAction = invokeAction; exports.runAgent = runAgent; exports.isAgentConfigMode = isAgentConfigMode; exports.isAgentConfigApprovalMode = isAgentConfigApprovalMode; exports.isAgentConfigLLMProvider = isAgentConfigLLMProvider; exports.AGENT_CONFIG_FILE_NAMES = AGENT_CONFIG_FILE_NAMES; exports.isAgentPreset = isAgentPreset; exports.goalForAgentPreset = goalForAgentPreset; exports.makeConfiguredPermissions = makeConfiguredPermissions; exports.defaultPermissions = defaultPermissions; exports.autoApproveApprovals = autoApproveApprovals; exports.makeAutoDenyApprovals = makeAutoDenyApprovals; exports.NodeShell = NodeShell; exports.makeNodeFileSystem = makeNodeFileSystem; exports.makeNodePatchService = makeNodePatchService; exports.loadNodeAgentConfig = loadNodeAgentConfig; exports.makeOpenAICompatibleLLM = makeOpenAICompatibleLLM; exports.makeGoogleGenerativeAILLM = makeGoogleGenerativeAILLM; exports.makeFakeLLM = makeFakeLLM; exports.discoverNodeWorkspaceRoot = discoverNodeWorkspaceRoot;