@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-VCGSWN5M.js

@@ -0,0 +1,1300 @@
+import {
+  resolveLaunchInheritance
+} from "./chunk-6CAU7VBA.js";
+import {
+  tryResolveInstructionsImportOffer
+} from "./chunk-IYY3HQAD.js";
+import {
+  extractMockCompletionSignal,
+  parseCopilotError,
+  parseGeminiError
+} from "./chunk-MKASIKWZ.js";
+import {
+  CORE_DOCTRINE,
+  isSteeringDisabled
+} from "./chunk-HKO45NLZ.js";
+import {
+  resolveReadOnlyWorkingDir
+} from "./chunk-GWHGTG37.js";
+import {
+  providerOutputTail
+} from "./chunk-JBBB2Y47.js";
+import {
+  sanitizeDiagnosticText
+} from "./chunk-RBKLOUXA.js";
+import {
+  assertMockProvidersAllowed
+} from "./chunk-VMFZEVVX.js";
+import {
+  buildProviderExecutionEnv
+} from "./chunk-XTXYIISX.js";
+import {
+  safeRmDir
+} from "./chunk-ALDTFNZ3.js";
+import {
+  authFailureEvidence,
+  isAuthFailureError,
+  recordAuthOutcome
+} from "./chunk-PPZESPJT.js";
+import {
+  getProviderRuntimeQuirks
+} from "./chunk-Y733RB7T.js";
+import {
+  ProviderRegistry,
+  disabledBySuffix
+} from "./chunk-QJ6OEH4K.js";
+import {
+  INHERITED_SOURCES_FILENAME,
+  fingerprintInheritedSet,
+  oneLine,
+  readFrontMatter,
+  readLaunchInheritanceRecord,
+  stripFrontMatter
+} from "./chunk-BD3PGW6A.js";
+import {
+  INHERITED_AGENTS_DIRNAME,
+  INHERITED_INSTRUCTIONS_FILENAME,
+  INHERITED_SKILLS_DIRNAME,
+  INHERITED_STEERING_DIRNAME,
+  deliversBuildSet,
+  hasInheritanceDecision
+} from "./chunk-43OKHTW4.js";
+import {
+  findProjectRoot
+} from "./chunk-35J4NE6S.js";
+import {
+  USER_INSTRUCTIONS_FILENAME,
+  byteLength,
+  getShadowedLegacyInstructionsPath,
+  getUserInstructionsPath,
+  loadProjectInstructionsFile,
+  loadUserInstructionsFile,
+  sha256Text
+} from "./chunk-RIMARPCF.js";
+import {
+  ProviderExecutionError
+} from "./chunk-RRC5BL7B.js";
+import {
+  getDefaultBuildHome,
+  getStateDir,
+  getUserConfigDir
+} from "./chunk-56WPYDJH.js";
+import {
+  BUILD_CONFIG_DIR,
+  BUILD_CONFIG_DIR2,
+  BUILD_HOME,
+  BUILD_MOCK_PROVIDERS,
+  emitWarning,
+  getExecutionContext,
+  getRuntimeEnv,
+  hasExecutionContext,
+  readEnv,
+  readRawEnv
+} from "./chunk-7VRJHTGZ.js";
+
+// src/core/providers/presentation-profile.ts
+var PRESENTATION_PROFILES = /* @__PURE__ */ new Set([
+  "quiet",
+  "structured-stream",
+  "debug-stream"
+]);
+function resolvePresentationProfile(options = {}) {
+  if (options.explicit) {
+    return options.explicit;
+  }
+  if (options.verbose) {
+    return "structured-stream";
+  }
+  switch (options.entryPoint) {
+    case "compete":
+    case "pipeline":
+    case "cli":
+      return "quiet";
+    default:
+      break;
+  }
+  const envProfile = options.env?.BUILD_PRESENTATION_PROFILE;
+  if (isPresentationProfile(envProfile)) {
+    return envProfile;
+  }
+  return "quiet";
+}
+function shouldForwardStdout(profile) {
+  return profile === "structured-stream" || profile === "debug-stream";
+}
+function shouldForwardStructuredEvents(profile) {
+  return profile === "structured-stream" || profile === "debug-stream";
+}
+function isPresentationProfile(value) {
+  return value !== void 0 && PRESENTATION_PROFILES.has(value);
+}
+
+// src/core/providers/inheritance-bundle.ts
+import {
+  chmodSync,
+  copyFileSync,
+  cpSync,
+  lstatSync,
+  mkdirSync,
+  mkdtempSync,
+  readdirSync as readdirSync2,
+  readFileSync,
+  realpathSync,
+  writeFileSync
+} from "fs";
+import { dirname as dirname2, join as join2 } from "path";
+
+// src/core/steering/layout.ts
+import { readdirSync, statSync } from "fs";
+import { basename, dirname, join, resolve } from "path";
+function getUserBuildHome() {
+  const configDir = getUserConfigDir();
+  if (readRawEnv(BUILD_HOME) && !readRawEnv(BUILD_CONFIG_DIR) && basename(configDir) === "config") {
+    return dirname(configDir);
+  }
+  return getDefaultBuildHome();
+}
+function isFile(path2) {
+  try {
+    return statSync(path2).isFile();
+  } catch {
+    return false;
+  }
+}
+function listDirectory(dir) {
+  try {
+    return readdirSync(dir).sort();
+  } catch {
+    return [];
+  }
+}
+function markdownEntries(dir, kind, level) {
+  return listDirectory(dir).filter((file) => file.endsWith(".md") && file.toLowerCase() !== "readme.md").map((file) => ({ kind, level, name: file.slice(0, -".md".length), path: join(dir, file) })).filter((entry) => isFile(entry.path));
+}
+function skillEntries(dir, level) {
+  return listDirectory(dir).map((name) => ({ kind: "skills", level, name, path: join(dir, name, "SKILL.md") })).filter((entry) => isFile(entry.path));
+}
+function entriesUnder(root, level) {
+  return {
+    agents: markdownEntries(join(root, "agents"), "agents", level),
+    skills: skillEntries(join(root, "skills"), level),
+    steering: markdownEntries(join(root, "steering"), "steering", level)
+  };
+}
+function mergeByName(user, repo, replaced) {
+  const repoByName = new Map(repo.map((entry) => [entry.name, entry]));
+  const kept = user.filter((entry) => {
+    const replacement = repoByName.get(entry.name);
+    if (replacement) replaced.push({ ...entry, replacedBy: replacement.path });
+    return !replacement;
+  });
+  return [...repo, ...kept].sort((a, b) => a.name.localeCompare(b.name));
+}
+function resolveRepoRoot(cwd, userHome) {
+  const root = findProjectRoot(cwd);
+  if (!root || resolve(root, BUILD_CONFIG_DIR2) === resolve(userHome)) return void 0;
+  return root;
+}
+function repoInstructionsPath(repoRoot) {
+  return join(repoRoot, BUILD_CONFIG_DIR2, "config", USER_INSTRUCTIONS_FILENAME);
+}
+function resolveRepoInstructionsPath(cwd = process.cwd()) {
+  const repoRoot = resolveRepoRoot(cwd, getUserBuildHome());
+  const path2 = repoRoot ? repoInstructionsPath(repoRoot) : void 0;
+  return path2 && isFile(path2) ? path2 : void 0;
+}
+function resolveInheritanceLayout(cwd = process.cwd()) {
+  const userHome = getUserBuildHome();
+  const repoRoot = resolveRepoRoot(cwd, userHome);
+  const instructions = [];
+  const userInstructions = getUserInstructionsPath();
+  if (isFile(userInstructions)) {
+    instructions.push({
+      kind: "instructions",
+      level: "user",
+      name: "instructions",
+      path: userInstructions
+    });
+  }
+  const user = entriesUnder(userHome, "user");
+  let repo = { agents: [], skills: [], steering: [] };
+  if (repoRoot) {
+    const repoBuild = join(repoRoot, BUILD_CONFIG_DIR2);
+    const repoInstructions = repoInstructionsPath(repoRoot);
+    if (isFile(repoInstructions)) {
+      instructions.push({
+        kind: "instructions",
+        level: "repo",
+        name: "instructions",
+        path: repoInstructions
+      });
+    }
+    repo = entriesUnder(repoBuild, "repo");
+  }
+  const replaced = [];
+  const shadowedLegacyInstructions = getShadowedLegacyInstructionsPath();
+  return {
+    userHome,
+    ...repoRoot ? { repoRoot } : {},
+    instructions,
+    agents: mergeByName(user.agents, repo.agents, replaced),
+    skills: mergeByName(user.skills, repo.skills, replaced),
+    steering: mergeByName(user.steering, repo.steering, replaced),
+    replaced,
+    ...shadowedLegacyInstructions ? { shadowedLegacyInstructions } : {}
+  };
+}
+
+// src/core/steering/instruction-set.ts
+var INSTRUCTION_SET_PRECEDENCE_NOTE = "These instructions come from Build. They take precedence over your own user-level instructions, and later sections here take precedence over earlier ones. The repository's own instruction files take precedence over all of them.";
+function resolveBuildInstructionSet(cwd) {
+  if (isSteeringDisabled()) return void 0;
+  const parts = [INSTRUCTION_SET_PRECEDENCE_NOTE];
+  const sources = [];
+  const floorText = CORE_DOCTRINE.map((entry) => entry.text).join("\n\n");
+  if (floorText) {
+    parts.push(floorText);
+    sources.push({ kind: "floor", sha256: sha256Text(floorText), bytes: byteLength(floorText) });
+  }
+  const repoPath = resolveRepoInstructionsPath(cwd);
+  for (const loaded of [
+    loadUserInstructionsFile(),
+    repoPath ? loadProjectInstructionsFile(repoPath) : null
+  ]) {
+    if (!loaded) continue;
+    parts.push(loaded.text.trim());
+    sources.push(loaded.source);
+  }
+  const text = `${parts.join("\n\n")}
+`;
+  return { text, sha256: sha256Text(text), bytes: byteLength(text), sources };
+}
+
+// src/core/steering/steering-index.ts
+var STEERING_INDEX_INTRO = "Steering docs from Build. Each line names a doc, says what it covers, and gives its path. Before you work on something a doc covers, read that doc and follow it.";
+var SUMMARY_MAX_CHARS = 160;
+var HEADING = /^#{1,6}\s+(.*?)(?:\s+#+)?$/;
+var FIRST_SENTENCE = /^.*?[.!?](?=\s|$)/;
+function cap(text) {
+  if (text.length <= SUMMARY_MAX_CHARS) return text;
+  const cut = text.slice(0, SUMMARY_MAX_CHARS - 3);
+  const lastSpace = cut.lastIndexOf(" ");
+  return `${lastSpace > 0 ? cut.slice(0, lastSpace) : cut}...`;
+}
+function summarizeSteeringDoc(text) {
+  const description = oneLine(readFrontMatter(text).description);
+  if (description) return cap(description);
+  const paragraph = [];
+  for (const line of stripFrontMatter(text).split(/\r?\n/)) {
+    const trimmed = line.trim();
+    const heading = HEADING.exec(trimmed);
+    if (paragraph.length === 0 && heading) return cap(oneLine(heading[1]));
+    if (!trimmed || heading) {
+      if (paragraph.length > 0) break;
+      continue;
+    }
+    paragraph.push(trimmed);
+  }
+  const joined = oneLine(paragraph.join(" "));
+  return cap(FIRST_SENTENCE.exec(joined)?.[0] ?? joined);
+}
+function buildSteeringIndexText(docs) {
+  const lines = docs.map((doc) => {
+    const summary = summarizeSteeringDoc(doc.text);
+    return `- ${doc.name}${summary ? `: ${summary}` : ""} (file: ${doc.path})`;
+  });
+  return lines.length > 0 ? `${STEERING_INDEX_INTRO}
+${lines.join("\n")}
+` : "";
+}
+
+// src/core/providers/inheritance-bundle.ts
+function makeReadOnly(path2) {
+  const stat = lstatSync(path2);
+  if (stat.isSymbolicLink()) return;
+  if (stat.isDirectory()) {
+    for (const name of readdirSync2(path2)) makeReadOnly(join2(path2, name));
+    return;
+  }
+  chmodSync(path2, stat.mode & 365);
+}
+function copySkillsAndAgents(dir, layout, reads) {
+  for (const skill of reads("skills") ? layout.skills : []) {
+    const target = join2(dir, INHERITED_SKILLS_DIRNAME, skill.name);
+    cpSync(realpathSync(dirname2(skill.path)), target, { recursive: true });
+    makeReadOnly(target);
+  }
+  for (const agent of reads("agents") ? layout.agents : []) {
+    const target = join2(dir, INHERITED_AGENTS_DIRNAME, `${agent.name}.md`);
+    mkdirSync(dirname2(target), { recursive: true });
+    copyFileSync(agent.path, target);
+    makeReadOnly(target);
+  }
+}
+function copySteeringDocs(dir, layout) {
+  const docs = layout.steering.map((doc) => {
+    const text = readFileSync(doc.path, "utf8");
+    const path2 = join2(dir, INHERITED_STEERING_DIRNAME, `${doc.name}.md`);
+    mkdirSync(dirname2(path2), { recursive: true });
+    writeFileSync(path2, text, { mode: 292 });
+    return { name: doc.name, path: path2, text };
+  });
+  return buildSteeringIndexText(docs);
+}
+function setKinds(layout) {
+  const kinds = ["instructions"];
+  for (const kind of ["skills", "agents", "steering"]) {
+    if (layout[kind].length > 0) kinds.push(kind);
+  }
+  return kinds;
+}
+function createInheritanceBundle(launch, workingDir, routes) {
+  if (!hasInheritanceDecision(launch)) return void 0;
+  const cwd = workingDir ?? process.cwd();
+  const set = deliversBuildSet(launch) ? resolveBuildInstructionSet(cwd) : void 0;
+  let cleanup;
+  try {
+    const root = join2(getStateDir(), "inheritance");
+    mkdirSync(root, { recursive: true, mode: 448 });
+    const dir = mkdtempSync(join2(root, "run-"));
+    cleanup = async () => {
+      await safeRmDir(dir, { protectedPaths: [root], managedRoots: [root] }).catch(() => void 0);
+    };
+    if (!set) return { dir, cleanup };
+    const layout = resolveInheritanceLayout(cwd);
+    const prepared = { id: fingerprintInheritedSet(set.text, layout), kinds: setKinds(layout) };
+    const reads = (kind) => typeof routes?.routes[kind] === "string";
+    const steeringIndex = reads("steering") ? copySteeringDocs(dir, layout) : "";
+    if (reads("instructions")) {
+      const text = steeringIndex ? `${set.text}
+${steeringIndex}` : set.text;
+      writeFileSync(join2(dir, INHERITED_INSTRUCTIONS_FILENAME), text, { mode: 292 });
+      writeFileSync(join2(dir, INHERITED_SOURCES_FILENAME), JSON.stringify(set.sources), {
+        mode: 292
+      });
+    }
+    copySkillsAndAgents(dir, layout, reads);
+    return { dir, set: prepared, cleanup };
+  } catch (error) {
+    void cleanup?.();
+    emitWarning(
+      "CFG-001",
+      { taskId: "runtime-steering", subsystem: "steering", executionPhase: "setup" },
+      {
+        severity: "WARN" /* WARN */,
+        metadata: {
+          operation: "createInheritanceBundle",
+          error: error instanceof Error ? error.message : String(error)
+        }
+      }
+    );
+    return void 0;
+  }
+}
+
+// src/core/providers/native-mock-runner.ts
+import * as fs from "fs/promises";
+import * as path from "path";
+function getProviderEnvValue(options, key) {
+  return options.env?.[key] ?? process.env[key];
+}
+function buildMockAIJudgeOutput(prompt) {
+  if (!prompt.includes('"variants"') || !prompt.includes('"summary"') || !prompt.includes('"winner"')) {
+    return void 0;
+  }
+  const variantIds = Array.from(prompt.matchAll(/^### Variant:[^\r\n]*\(id:[ \t]*([^)\r\n]+)\)/gm)).map((match) => match[1]?.trim()).filter((id) => Boolean(id));
+  const ids = variantIds.length > 0 ? Array.from(new Set(variantIds)) : ["v1"];
+  const ranked = [...ids];
+  const variants = ranked.map((id, index) => {
+    const score = Math.max(60, 92 - index * 6);
+    return {
+      id,
+      delivery: {
+        score,
+        rationale: "Synthetic mock judge score based on available mock deliverable evidence.",
+        evidence: ["E1"]
+      },
+      correctness: {
+        score,
+        rationale: "Synthetic mock judge score for deterministic validation runs.",
+        evidence: ["E1"]
+      },
+      quality: {
+        score,
+        rationale: "Synthetic mock judge score for deterministic validation runs.",
+        evidence: ["E1"]
+      },
+      dimensions: {
+        readability: score,
+        maintainability: score,
+        security: Math.max(50, score - 4),
+        innovation: Math.max(50, score - 8)
+      },
+      limitation: {
+        summary: "Synthetic mock output cannot assess real implementation quality.",
+        evidence: []
+      },
+      os: score
+    };
+  });
+  return JSON.stringify({
+    variants,
+    summary: {
+      ranking: ranked,
+      rankingRationale: "Synthetic mock judge ranking for deterministic provider validation.",
+      confidence: ids.length > 1 ? 0.86 : 0.65,
+      confidenceRationale: "Confidence reflects deterministic mock evidence only.",
+      top2SeparationRationale: ids.length > 1 ? "Synthetic score separation between mock variants." : "N/A: single variant"
+    },
+    winner: {
+      id: ranked[0],
+      reason: "Highest synthetic mock judge score."
+    }
+  });
+}
+function throwIfAborted(provider, abortSignal) {
+  if (abortSignal?.aborted) {
+    throw createMockAbortError(provider);
+  }
+}
+function createMockAbortError(provider) {
+  return new ProviderExecutionError(`Mock ${provider} execution aborted.`, {
+    retryable: false,
+    reason: "aborted"
+  });
+}
+async function runAbortableMockIo(provider, abortSignal, operation) {
+  throwIfAborted(provider, abortSignal);
+  const promise = operation();
+  if (!abortSignal) {
+    return promise;
+  }
+  return new Promise((resolve2, reject) => {
+    const onAbort = () => reject(createMockAbortError(provider));
+    const cleanup = () => abortSignal.removeEventListener("abort", onAbort);
+    abortSignal.addEventListener("abort", onAbort, { once: true });
+    promise.then(
+      (value) => {
+        cleanup();
+        resolve2(value);
+      },
+      (error) => {
+        cleanup();
+        reject(error);
+      }
+    );
+  });
+}
+async function runMockNative(options) {
+  const { provider, prompt, workingDir, files, onData } = options;
+  const intentPipelineMockOutput = "reliability-canary-output/mock-output.txt";
+  throwIfAborted(provider, options.abortSignal);
+  if (options.executionIntent === "analysis") {
+    const mockJudgeOutput = buildMockAIJudgeOutput(prompt);
+    if (mockJudgeOutput) {
+      throwIfAborted(provider, options.abortSignal);
+      return {
+        stdout: mockJudgeOutput,
+        stderr: "",
+        exitCode: 0
+      };
+    }
+  }
+  if (getProviderEnvValue(options, "BUILD_MOCK_PROVIDER_FAILURE") === "1") {
+    const message2 = `Mock ${provider} execution failed (BUILD_MOCK_PROVIDER_FAILURE=1)`;
+    throwIfAborted(provider, options.abortSignal);
+    onData?.(`${message2}
+`);
+    return {
+      stdout: "",
+      stderr: message2,
+      exitCode: 1
+    };
+  }
+  if (getProviderEnvValue(options, "BUILD_MOCK_PROVIDER_NO_CHANGES") === "1") {
+    const message2 = `Mock ${provider} execution produced no changes (BUILD_MOCK_PROVIDER_NO_CHANGES=1)`;
+    throwIfAborted(provider, options.abortSignal);
+    onData?.(`${message2}
+`);
+    return {
+      stdout: message2,
+      stderr: "",
+      exitCode: 0
+    };
+  }
+  if (getProviderEnvValue(options, "BUILD_MOCK_INTENT_PIPELINE") === "1") {
+    if (options.executionIntent === "analysis" && (options.circuitBreakerScope?.startsWith("plan-decompose:") || prompt.includes('"subStages"'))) {
+      throwIfAborted(provider, options.abortSignal);
+      return {
+        stdout: JSON.stringify({
+          subStages: [
+            {
+              id: "canary-write",
+              type: "standard",
+              name: "Write reliability canary marker",
+              prompt: `Write a deterministic reliability canary marker to ${intentPipelineMockOutput}`,
+              deps: [],
+              estimatedCost: 0.01,
+              allowlist: ["reliability-canary-output/"]
+            },
+            {
+              id: "canary-verify",
+              type: "verify",
+              name: "Verify reliability canary marker",
+              prompt: "Verify the reliability canary marker exists",
+              deps: ["canary-write"],
+              estimatedCost: 0.01,
+              verify: {
+                commands: [`test -f ${intentPipelineMockOutput}`]
+              }
+            }
+          ],
+          rationale: "Synthetic reliability canary plan with one write stage and one verify stage.",
+          estimatedTotalCost: 0.02,
+          estimatedDurationMs: 1e3,
+          hasParallelGroups: false,
+          parallelGroups: []
+        }),
+        stderr: "",
+        exitCode: 0
+      };
+    }
+    if (options.executionIntent === "analysis" && prompt.includes('"blockers"')) {
+      throwIfAborted(provider, options.abortSignal);
+      return {
+        stdout: '{"blockers":[]}',
+        stderr: "",
+        exitCode: 0
+      };
+    }
+    if (options.executionIntent !== "analysis") {
+      if (getProviderEnvValue(options, "BUILD_MOCK_INTENT_PIPELINE_EXECUTION_FAILURE") === "1") {
+        const message3 = "Mock intent pipeline execution failed (BUILD_MOCK_INTENT_PIPELINE_EXECUTION_FAILURE=1)";
+        throwIfAborted(provider, options.abortSignal);
+        onData?.(`${message3}
+`);
+        return {
+          stdout: "",
+          stderr: message3,
+          exitCode: 1
+        };
+      }
+      const targetPath2 = path.join(workingDir, intentPipelineMockOutput);
+      await runAbortableMockIo(
+        provider,
+        options.abortSignal,
+        () => fs.mkdir(path.dirname(targetPath2), { recursive: true })
+      );
+      await runAbortableMockIo(
+        provider,
+        options.abortSignal,
+        () => fs.writeFile(targetPath2, `Synthetic reliability canary marker from ${provider}
+`, "utf8")
+      );
+      const message2 = `Mock ${provider} execution applied change to ${intentPipelineMockOutput}`;
+      throwIfAborted(provider, options.abortSignal);
+      onData?.(`${message2}
+`);
+      return {
+        stdout: message2,
+        stderr: "",
+        exitCode: 0,
+        filesModified: [intentPipelineMockOutput]
+      };
+    }
+    return {
+      stdout: "{}",
+      stderr: "",
+      exitCode: 0
+    };
+  }
+  if (options.executionIntent === "analysis") {
+    throwIfAborted(provider, options.abortSignal);
+    return {
+      stdout: "{}",
+      stderr: "",
+      exitCode: 0
+    };
+  }
+  const defaultMockOutput = "build-mock-output.txt";
+  const envMockOutput = getProviderEnvValue(options, "BUILD_MOCK_OUTPUT_FILE");
+  const safeEnvMockOutput = typeof envMockOutput === "string" && envMockOutput.replaceAll("\\", "/").startsWith(".build-project/tmp/") ? envMockOutput : void 0;
+  const promptFileMatch = prompt.match(/\bFILES?:\s*([^\s,;]+)/i);
+  const promptFileTarget = promptFileMatch?.[1]?.replace(/[.)\]}]+$/g, "");
+  const safePromptFileTarget = promptFileTarget && !path.isAbsolute(promptFileTarget) && !promptFileTarget.includes("..") && !promptFileTarget.replaceAll("\\", "/").startsWith(".build-project/") ? promptFileTarget : void 0;
+  const targetCandidate = files?.[0] ?? safePromptFileTarget ?? safeEnvMockOutput ?? defaultMockOutput;
+  const safeTarget = targetCandidate && !path.isAbsolute(targetCandidate) && !targetCandidate.includes("..") ? targetCandidate : defaultMockOutput;
+  const targetPath = path.join(workingDir, safeTarget);
+  await runAbortableMockIo(
+    provider,
+    options.abortSignal,
+    () => fs.mkdir(path.dirname(targetPath), { recursive: true })
+  );
+  const completionSignal = extractMockCompletionSignal(prompt);
+  const promptPreview = prompt.slice(0, 120).split(/\r?\n/).map((line) => line ? `// ${line}` : "//").join("\n");
+  const content = `// Mock change from ${provider} (native basic mode)
+${promptPreview}
+`;
+  await runAbortableMockIo(
+    provider,
+    options.abortSignal,
+    () => fs.writeFile(targetPath, content, { flag: "a" })
+  );
+  const message = `Mock ${provider} execution applied change to ${safeTarget}` + (completionSignal ? `
+${completionSignal}` : "");
+  throwIfAborted(provider, options.abortSignal);
+  onData?.(`${message}
+`);
+  return {
+    stdout: message,
+    stderr: "",
+    exitCode: 0,
+    filesModified: [safeTarget],
+    // The mock has already written the target, so report it as an already-applied
+    // edit. Provider-specific mock branches used to supply this, and a
+    // workspace-agent run outside a git worktree has no other discovery channel:
+    // git fallback finds nothing and the mock writes no edit-file declaration.
+    workspaceEdits: [
+      {
+        op: "writeFile",
+        path: safeTarget,
+        contents: content,
+        alreadyOnDisk: true,
+        _source: "protocol"
+      }
+    ]
+  };
+}
+
+// src/core/providers/provider-invocation-env.ts
+import { AsyncLocalStorage } from "async_hooks";
+var scope = new AsyncLocalStorage();
+function withProviderInvocationEnv(providerEnv, fn) {
+  return scope.run(providerEnv, fn);
+}
+async function applyProviderInvocationEnv(provider, env) {
+  const providerEnv = scope.getStore();
+  const overrides = providerEnv ? await providerEnv(provider) : void 0;
+  return overrides ? { ...env, ...overrides } : env;
+}
+
+// src/core/providers/provider-skip.ts
+var TRUTHY = /* @__PURE__ */ new Set(["1", "true", "yes", "on"]);
+function providerSkipEnvName(providerId) {
+  return `BUILD_SKIP_${providerId.toUpperCase().replace(/[^A-Z0-9]/g, "_")}`;
+}
+function resolveProviderSkip(providerId, env) {
+  const name = providerSkipEnvName(providerId);
+  const raw = env && Object.hasOwn(env, name) ? env[name] : getRuntimeEnv(name);
+  if (!raw || !TRUTHY.has(raw.trim().toLowerCase())) return void 0;
+  const stderr = `Provider ${providerId} skipped via ${name}`;
+  return {
+    stdout: "",
+    stderr,
+    exitCode: 1,
+    skipped: true,
+    skipReason: name,
+    commandPath: providerId,
+    argvRedacted: [],
+    stdoutTail: "",
+    stderrTail: providerOutputTail(stderr)
+  };
+}
+
+// src/core/providers/telemetry-sink.ts
+var DEFAULT_PROD_MAX_EVENTS = 5e3;
+var DEFAULT_TEST_MAX_EVENTS = 1e4;
+function resolveTelemetryRetentionPolicy(options = {}) {
+  const env = options.env ?? process.env;
+  const isTestRunner = env.NODE_ENV === "test" || env.VITEST === "true" || env.VITEST === "1";
+  let retainEvents;
+  if (options.retainEvents !== void 0) {
+    retainEvents = options.retainEvents;
+  } else {
+    const raw = env.BUILD_TELEMETRY_RETAIN_EVENTS;
+    if (raw === "0" || raw === "false") {
+      retainEvents = false;
+    } else if (raw === "1" || raw === "true") {
+      retainEvents = true;
+    } else {
+      retainEvents = true;
+    }
+  }
+  let maxRetainedEvents;
+  if (typeof options.maxRetainedEvents === "number" && options.maxRetainedEvents > 0) {
+    maxRetainedEvents = options.maxRetainedEvents;
+  } else {
+    const raw = env.BUILD_TELEMETRY_MAX_EVENTS;
+    const parsed = raw === void 0 ? NaN : Number.parseInt(raw, 10);
+    if (Number.isFinite(parsed) && parsed > 0) {
+      maxRetainedEvents = parsed;
+    } else {
+      maxRetainedEvents = isTestRunner ? DEFAULT_TEST_MAX_EVENTS : DEFAULT_PROD_MAX_EVENTS;
+    }
+  }
+  return { retainEvents, maxRetainedEvents };
+}
+var TelemetrySink = class {
+  constructor(options = {}) {
+    this.options = options;
+    this.retention = resolveTelemetryRetentionPolicy({
+      retainEvents: options.retainEvents,
+      maxRetainedEvents: options.maxRetainedEvents
+    });
+  }
+  options;
+  events = [];
+  usage = {};
+  usageSemantics;
+  usageInvalid = false;
+  retention;
+  handleStdoutLine(line, context = {}) {
+    return this.handleLine(line, { ...context, stream: "stdout" });
+  }
+  handleStderrLine(line, context = {}) {
+    return this.handleLine(line, { ...context, stream: "stderr" });
+  }
+  handleStreamEvent(event, context = {}) {
+    const telemetryEvent = this.toTelemetryEvent(event, context);
+    this.record(telemetryEvent);
+    if (event.type === "usage_delta") {
+      this.addUsage(event.usage, event.semantics);
+    }
+    return telemetryEvent;
+  }
+  getAccumulatedUsage() {
+    return this.usageInvalid ? {} : { ...this.usage };
+  }
+  getEvents() {
+    return [...this.events];
+  }
+  forwardPresentationChunk(chunk) {
+    this.options.onPresentationChunk?.(chunk);
+  }
+  forwardPresentationErrorChunk(chunk) {
+    this.options.onPresentationErrorChunk?.(chunk);
+  }
+  forwardStreamEvent(event) {
+    this.options.onStreamEvent?.(event);
+  }
+  handleLine(line, context) {
+    this.record({
+      type: "raw_event",
+      stream: context.stream ?? "stdout",
+      provider: context.provider,
+      timestamp: Date.now(),
+      line: sanitizeDiagnosticText(line)
+    });
+    const streamEvents = this.parseStreamEvents(line, context);
+    for (const event of streamEvents) {
+      this.handleStreamEvent(event, context);
+    }
+    return {
+      presentationChunk: this.formatPresentationChunk(line, context),
+      streamEvents
+    };
+  }
+  parseStreamEvents(line, context) {
+    if (!this.options.parseLine) {
+      return [];
+    }
+    try {
+      const parsed = this.options.parseLine(line, context);
+      if (!parsed) {
+        return [];
+      }
+      return Array.isArray(parsed) ? parsed : [parsed];
+    } catch (error) {
+      this.record({
+        type: "lifecycle",
+        phase: "error",
+        provider: context.provider,
+        timestamp: Date.now(),
+        message: "Failed to parse provider stream line",
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return [];
+    }
+  }
+  formatPresentationChunk(line, context) {
+    if (!this.options.formatLine) {
+      return sanitizeDiagnosticText(line);
+    }
+    const formatted = this.options.formatLine(line, context);
+    if (formatted === null || formatted === void 0) {
+      return void 0;
+    }
+    return sanitizeDiagnosticText(formatted);
+  }
+  toTelemetryEvent(event, context) {
+    switch (event.type) {
+      case "attempt_started":
+        return {
+          type: "attempt_started",
+          attempt: event.attempt,
+          provider: context.provider,
+          timestamp: Date.now(),
+          rawEventType: event.rawEventType
+        };
+      case "model_resolved":
+        return {
+          type: "model_resolved",
+          model: event.model,
+          provider: context.provider,
+          timestamp: Date.now(),
+          rawEventType: event.rawEventType
+        };
+      case "text_delta":
+      case "text_snapshot":
+        return {
+          type: "text_delta",
+          text: event.text,
+          provider: context.provider,
+          timestamp: Date.now(),
+          rawEventType: event.rawEventType
+        };
+      case "tool_event":
+        return {
+          type: "tool_event",
+          name: event.name,
+          phase: event.phase,
+          id: event.id,
+          provider: context.provider,
+          timestamp: Date.now(),
+          rawEventType: event.rawEventType
+        };
+      case "usage_delta":
+        return {
+          type: "usage_delta",
+          usage: event.usage,
+          semantics: event.semantics,
+          provider: context.provider,
+          timestamp: Date.now(),
+          rawEventType: event.rawEventType
+        };
+    }
+  }
+  addUsage(usage, semantics) {
+    if (semantics === void 0 || this.usageSemantics !== void 0 && this.usageSemantics !== semantics) {
+      this.usageInvalid = true;
+      this.record({
+        type: "lifecycle",
+        phase: "error",
+        timestamp: Date.now(),
+        message: semantics === void 0 ? "Provider usage event omitted accounting semantics" : "Provider usage event changed accounting semantics"
+      });
+      return;
+    }
+    this.usageSemantics = semantics;
+    const assign = semantics === "delta" ? addOptional : replaceOptional;
+    if (usage.inputTokens !== void 0) {
+      this.usage.inputTokens = assign(this.usage.inputTokens, usage.inputTokens);
+    }
+    if (usage.outputTokens !== void 0) {
+      this.usage.outputTokens = assign(this.usage.outputTokens, usage.outputTokens);
+    }
+    if (usage.cachedInputTokens !== void 0) {
+      this.usage.cachedInputTokens = assign(this.usage.cachedInputTokens, usage.cachedInputTokens);
+    }
+    if (usage.cacheCreationInputTokens !== void 0) {
+      this.usage.cacheCreationInputTokens = assign(
+        this.usage.cacheCreationInputTokens,
+        usage.cacheCreationInputTokens
+      );
+    }
+    if (usage.reasoningTokens !== void 0) {
+      this.usage.reasoningTokens = assign(this.usage.reasoningTokens, usage.reasoningTokens);
+    }
+    if (usage.toolTokens !== void 0) {
+      this.usage.toolTokens = assign(this.usage.toolTokens, usage.toolTokens);
+    }
+    if (usage.extraDimensions) {
+      this.usage.extraDimensions ??= {};
+      for (const [key, value] of Object.entries(usage.extraDimensions)) {
+        this.usage.extraDimensions[key] = semantics === "delta" ? (this.usage.extraDimensions[key] ?? 0) + value : value;
+      }
+    }
+    if (usage.cacheReadTokensIncludedInInput === true) {
+      this.usage.cacheReadTokensIncludedInInput = true;
+    }
+    if (usage.cacheCreationTokensIncludedInInput === true) {
+      this.usage.cacheCreationTokensIncludedInInput = true;
+    }
+  }
+  record(event) {
+    if (this.retention.retainEvents) {
+      this.events.push(event);
+      if (this.events.length > this.retention.maxRetainedEvents) {
+        this.events.splice(0, this.events.length - this.retention.maxRetainedEvents);
+      }
+    }
+    this.options.onTelemetryEvent?.(event);
+  }
+};
+function createPresentationCallbacks(sink, profile) {
+  return {
+    onData: (chunk) => {
+      const result = sink.handleStdoutLine(chunk);
+      if (shouldForwardStdout(profile) && result.presentationChunk !== void 0) {
+        sink.forwardPresentationChunk(result.presentationChunk);
+      }
+      if (shouldForwardStructuredEvents(profile)) {
+        for (const event of result.streamEvents) {
+          sink.forwardStreamEvent(event);
+        }
+      }
+    },
+    onErrorData: (chunk) => {
+      const result = sink.handleStderrLine(chunk);
+      if (shouldForwardStdout(profile) && result.presentationChunk !== void 0) {
+        sink.forwardPresentationErrorChunk(result.presentationChunk);
+      }
+      if (shouldForwardStructuredEvents(profile)) {
+        for (const event of result.streamEvents) {
+          sink.forwardStreamEvent(event);
+        }
+      }
+    },
+    onStreamEvent: (event) => {
+      sink.handleStreamEvent(event);
+      if (shouldForwardStructuredEvents(profile)) {
+        sink.forwardStreamEvent(event);
+      }
+    }
+  };
+}
+function addOptional(current, next) {
+  if (next === void 0) {
+    return current;
+  }
+  return (current ?? 0) + next;
+}
+function replaceOptional(_current, next) {
+  return next;
+}
+
+// src/core/providers/run-provider.ts
+function normalizeWorkspaceModeResult(result, requested) {
+  const workspaceModeRequested = result.workspaceModeRequested ?? result.promptModeRequested ?? requested;
+  const workspaceModeApplied = result.workspaceMode ?? result.promptMode ?? workspaceModeRequested;
+  return {
+    ...result,
+    workspaceMode: workspaceModeApplied,
+    workspaceModeRequested,
+    // Backwards compatibility
+    promptMode: result.promptMode ?? workspaceModeApplied,
+    promptModeRequested: result.promptModeRequested ?? workspaceModeRequested
+  };
+}
+function withPresentationCallbacks(options) {
+  const existing = options;
+  if (existing.__presentationCallbacksWrapped === true) {
+    return { options, sink: existing.__telemetrySink };
+  }
+  const presentationProfile = resolvePresentationProfile({
+    explicit: options.presentationProfile,
+    verbose: options.verbose,
+    entryPoint: options.entryPoint ?? "provider-native"
+  });
+  const sink = new TelemetrySink({
+    onPresentationChunk: options.onData,
+    onPresentationErrorChunk: options.onErrorData,
+    onStreamEvent: options.onStreamEvent
+  });
+  const callbacks = createPresentationCallbacks(sink, presentationProfile);
+  return {
+    options: {
+      ...options,
+      presentationProfile,
+      onData: callbacks.onData,
+      onErrorData: callbacks.onErrorData,
+      onStreamEvent: callbacks.onStreamEvent,
+      __presentationCallbacksWrapped: true,
+      __telemetrySink: sink
+    },
+    sink
+  };
+}
+function mergeSinkUsageIntoResult(result, sink) {
+  if (!sink) return result;
+  const accumulated = sink.getAccumulatedUsage();
+  const hasAny = accumulated.inputTokens !== void 0 || accumulated.outputTokens !== void 0 || accumulated.cachedInputTokens !== void 0 || accumulated.cacheCreationInputTokens !== void 0 || accumulated.reasoningTokens !== void 0 || accumulated.toolTokens !== void 0 || accumulated.extraDimensions !== void 0;
+  if (!hasAny) return result;
+  const existing = result.tokenUsage;
+  const merged = {
+    inputTokens: existing?.inputTokens ?? accumulated.inputTokens ?? 0,
+    outputTokens: existing?.outputTokens ?? accumulated.outputTokens ?? 0,
+    // Sink-accumulated usage sums every event of the run, so it is a run total.
+    eventSemantics: existing?.eventSemantics ?? "logical_run_aggregate"
+  };
+  const optional = {
+    cachedInputTokens: existing?.cachedInputTokens ?? accumulated.cachedInputTokens,
+    cacheCreationInputTokens: existing?.cacheCreationInputTokens ?? accumulated.cacheCreationInputTokens,
+    cacheReadTokensIncludedInInput: existing?.cacheReadTokensIncludedInInput ?? accumulated.cacheReadTokensIncludedInInput,
+    cacheCreationTokensIncludedInInput: existing?.cacheCreationTokensIncludedInInput ?? accumulated.cacheCreationTokensIncludedInInput,
+    reasoningTokens: existing?.reasoningTokens ?? accumulated.reasoningTokens,
+    toolTokens: existing?.toolTokens ?? accumulated.toolTokens,
+    extraDimensions: existing?.extraDimensions ?? accumulated.extraDimensions
+  };
+  for (const [key, value] of Object.entries(optional)) {
+    if (value !== void 0) {
+      Object.assign(merged, { [key]: value });
+    }
+  }
+  return { ...result, tokenUsage: merged };
+}
+function recordAuthOutcomeBestEffort(provider, result, evidence, env) {
+  void recordAuthOutcome(provider, result, evidence, { env }).catch(() => {
+  });
+}
+async function runViaProviderRegistry(options, providerEnv, workspaceModeRequested) {
+  const {
+    provider,
+    prompt,
+    workingDir,
+    model,
+    files,
+    onData,
+    onErrorData,
+    onStdoutChunk,
+    onStderrChunk,
+    timeoutMs
+  } = options;
+  const { getEngine } = await import("./factory-YCYCB7AE.js");
+  const engine = await getEngine(provider);
+  const runPayload = {
+    variantInvocation: options.variantInvocation,
+    profile: options.profile ?? "default",
+    prompt,
+    workingDir,
+    abortSignal: options.abortSignal,
+    model,
+    modelExecutionPolicy: options.modelExecutionPolicy,
+    fallbackModel: options.fallbackModel,
+    modelReasoningEffort: options.modelReasoningEffort,
+    generationSettings: options.generationSettings,
+    structuredOutput: options.structuredOutput,
+    executionIntent: options.executionIntent,
+    // Native web-search clearance. Omitting this from the
+    // engine.run field list silently drops the flag for every provider dispatched
+    // through this generic path, so a provider builder that honors it can never
+    // observe it. Every provider dispatched here depends on this line.
+    nativeWebSearch: options.nativeWebSearch,
+    isWorktreeExecution: options.isWorktreeExecution,
+    transport: options.transport,
+    executionTransport: options.executionTransport,
+    workspaceMode: workspaceModeRequested,
+    promptMode: workspaceModeRequested,
+    presentationProfile: options.presentationProfile,
+    files,
+    allowedTools: options.allowedTools,
+    tools: options.tools,
+    disallowedTools: options.disallowedTools,
+    attachments: options.attachments,
+    env: providerEnv,
+    onStreamEvent: options.onStreamEvent,
+    readOnlyWorkingDir: options.readOnlyWorkingDir,
+    delegatedSubagents: options.delegatedSubagents,
+    nativeSubagents: options.nativeSubagents,
+    cursorPromptProfile: options.cursorPromptProfile,
+    onData,
+    onErrorData,
+    onStdoutChunk,
+    onStderrChunk,
+    timeout: timeoutMs,
+    deadlineMs: options.deadlineMs,
+    idleWarnMs: options.idleWarnMs,
+    idleKillMs: options.idleKillMs,
+    allowIdleTimeoutAboveProviderDefault: options.allowIdleTimeoutAboveProviderDefault,
+    onActivity: options.onActivity,
+    onSubmittedPrompt: options.onSubmittedPrompt,
+    circuitBreakerScope: options.circuitBreakerScope,
+    recentContext: options.recentContext,
+    taskProfile: options.taskProfile,
+    retryBudget: options.retryBudget,
+    allowEmptyResults: options.allowEmptyResults,
+    permissionMode: options.permissionMode,
+    resumeSessionId: options.resumeSessionId,
+    isBasicCompetition: options.isBasicCompetition,
+    variantId: options.variantId
+  };
+  return engine.run(runPayload);
+}
+function isProviderResultAuthFailure(provider, stderr, stdout, exitCode) {
+  const exitCodeNum = typeof exitCode === "number" ? exitCode : void 0;
+  switch (provider) {
+    case "gemini": {
+      const parsed = parseGeminiError(
+        Object.assign(new Error(stderr || stdout || `exit=${exitCode}`), {
+          stderr,
+          stdout,
+          exitCode: exitCodeNum
+        })
+      );
+      return parsed.type === "auth";
+    }
+    case "copilot": {
+      const parsed = parseCopilotError(stderr, stdout, exitCodeNum);
+      return parsed.type === "auth";
+    }
+    default:
+      return isAuthFailureError(stderr || `exit=${exitCode}`);
+  }
+}
+function usesAdapterOwnedMock(options) {
+  return options.mockExecution === "adapter" && readEnv(BUILD_MOCK_PROVIDERS).value === "1" && getProviderRuntimeQuirks(options.provider)?.ownsMockExecution === true;
+}
+async function runProvider(options) {
+  if (!options.variantRequest) return runProviderInternal(options);
+  const { executeVariantRequest } = await import("./variant-execution-I4ZZUAWY.js");
+  return executeVariantRequest(options, runProviderInternal);
+}
+async function runProviderInternal(options) {
+  const wrapped = withPresentationCallbacks({
+    ...options,
+    readOnlyWorkingDir: resolveReadOnlyWorkingDir({
+      readOnlyWorkingDir: options.readOnlyWorkingDir,
+      executionIntent: options.executionIntent
+    })
+  });
+  const executionOptions = wrapped.options;
+  if (!executionOptions.provider) {
+    throw new Error("Provider is required for native execution");
+  }
+  const skipped = resolveProviderSkip(executionOptions.provider, executionOptions.env);
+  if (skipped) return skipped;
+  const mockProvidersEnabled = getProviderEnvValue(executionOptions, "BUILD_MOCK_PROVIDERS") === "1";
+  if (mockProvidersEnabled && !usesAdapterOwnedMock(executionOptions)) {
+    assertMockProvidersAllowed(executionOptions.provider, executionOptions.env);
+    return mergeSinkUsageIntoResult(
+      normalizeWorkspaceModeResult(
+        await runMockNative(executionOptions),
+        executionOptions.workspaceMode ?? executionOptions.promptMode
+      ),
+      wrapped.sink
+    );
+  }
+  if (!ProviderRegistry.isProviderEnabled(executionOptions.provider)) {
+    const suffix = disabledBySuffix(
+      ProviderRegistry.getActiveRegistry(),
+      executionOptions.provider
+    );
+    throw new Error(`Provider is disabled: ${executionOptions.provider}${suffix}`);
+  }
+  try {
+    const result = await runProviderInner(executionOptions);
+    if (mockProvidersEnabled) {
+    } else if ((result.exitCode ?? 0) === 0) {
+      recordAuthOutcomeBestEffort(
+        executionOptions.provider,
+        "ok",
+        { source: "provider-call", message: "Provider call succeeded" },
+        executionOptions.env
+      );
+    } else if (isProviderResultAuthFailure(
+      executionOptions.provider,
+      result.stderr ?? "",
+      result.stdout ?? "",
+      result.exitCode
+    )) {
+      recordAuthOutcomeBestEffort(
+        executionOptions.provider,
+        "failed",
+        {
+          source: "provider-call",
+          message: result.stderr || result.stdout || `Provider exited with code ${result.exitCode}`,
+          ...typeof result.exitCode === "number" ? { exitCode: result.exitCode } : {}
+        },
+        executionOptions.env
+      );
+    }
+    return mergeSinkUsageIntoResult(result, wrapped.sink);
+  } catch (error) {
+    if (!mockProvidersEnabled && isAuthFailureError(error)) {
+      recordAuthOutcomeBestEffort(
+        executionOptions.provider,
+        "failed",
+        authFailureEvidence(error),
+        executionOptions.env
+      );
+    }
+    throw error;
+  }
+}
+async function readInheritanceRoutes(provider) {
+  const { ensureRegistryInitialized, registry } = await import("./registry-7XG376SY.js");
+  await ensureRegistryInitialized();
+  return registry.get(provider)?.inheritance;
+}
+async function runProviderInner(options) {
+  const inheritance = resolveLaunchInheritance(
+    options.inheritanceScope ?? "automated",
+    options.workingDir
+  );
+  const routes = deliversBuildSet(inheritance) ? await readInheritanceRoutes(options.provider) : void 0;
+  const bundle = createInheritanceBundle(inheritance, options.workingDir, routes);
+  try {
+    const result = await runProviderLaunch(options, inheritance, bundle?.dir);
+    const record = readLaunchInheritanceRecord(options.provider, inheritance, bundle, routes);
+    if (!record) return result;
+    const importStatus = tryResolveInstructionsImportOffer()?.status;
+    const instructionsImport = importStatus ? { instructionsImport: { status: importStatus } } : {};
+    return { ...result, inheritance: { ...record, ...instructionsImport } };
+  } finally {
+    await bundle?.cleanup();
+  }
+}
+async function runProviderLaunch(options, inheritance, inheritanceDir) {
+  const { provider, workingDir, model } = options;
+  const workspaceModeRequested = options.workspaceMode ?? options.promptMode;
+  const contextEnv = hasExecutionContext() ? getExecutionContext().envOverrides : {};
+  const attributionEnv = Object.fromEntries(
+    [
+      "BUILD_ACTIVE_TASK_ID",
+      "BUILD_PROJECT_ID",
+      "BUILD_RUN_ID",
+      "BUILD_LAB_ID",
+      "BUILD_LAB_RUN_ID",
+      "BUILD_TELEMETRY_DIR"
+    ].filter((key) => contextEnv[key] !== void 0).map((key) => [key, contextEnv[key]])
+  );
+  const invocationEnv = Object.keys(attributionEnv).length ? { ...attributionEnv, ...options.env } : options.env;
+  const env = await applyProviderInvocationEnv(provider, invocationEnv);
+  const providerEnv = buildProviderExecutionEnv(provider, env, {
+    workingDir,
+    executionIntent: options.executionIntent,
+    inheritance,
+    inheritanceDir
+  });
+  providerEnv.BUILD_AGENT_ROLE ||= "provider";
+  if (provider === "cursor" && options.resumeSessionId) {
+    providerEnv.BUILD_CURSOR_RESUME_SESSION_ID = options.resumeSessionId;
+  }
+  const providerHandlesRateLimitToken = /* @__PURE__ */ new Set([
+    "claude",
+    "codex",
+    "cursor",
+    "opencode",
+    "copilot",
+    "grok",
+    "gemini"
+  ]);
+  if (!providerHandlesRateLimitToken.has(provider)) {
+    const { acquireRateLimitToken } = await import("./safety-E3JJVSFL.js");
+    await acquireRateLimitToken(provider, model);
+  }
+  return normalizeWorkspaceModeResult(
+    await runViaProviderRegistry(options, providerEnv, workspaceModeRequested),
+    workspaceModeRequested
+  );
+}
+
+export {
+  getUserBuildHome,
+  resolveInheritanceLayout,
+  resolvePresentationProfile,
+  withProviderInvocationEnv,
+  applyProviderInvocationEnv,
+  runProvider
+};
+//# sourceMappingURL=chunk-VCGSWN5M.js.map