@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/runner-PIS2BW7Y.js

@@ -0,0 +1,1801 @@
+import {
+  canonicalizeOpencodeModelId
+} from "./chunk-Q3DHEZA5.js";
+import {
+  aggregateCredentialResidueErrors,
+  contextualizeCredentialCleanupError,
+  markRunOwnedRoot,
+  normalizeOpencodeReasoningEffort,
+  notifySubmittedPrompt,
+  opencodeNativeVariant,
+  removeAndVerifyRunOwnedRoot,
+  reportOutputDrift,
+  resolveCallerOwnedPath,
+  resolveOpencodeReasoningEffort
+} from "./chunk-GIJWHUWF.js";
+import {
+  assembleSteering,
+  detectQuotaExhaustion,
+  formatQuotaExhaustedMessage,
+  omitsUserInstructions
+} from "./chunk-HKO45NLZ.js";
+import {
+  executeOpencodeCommandWithBootstrapRetry,
+  extractUnstructuredOpencodeStdout,
+  formatCacheAge,
+  getCachedOpencodeModelIds,
+  getOpencodeModelsCacheInfo,
+  parseOpencodeProviderOutput,
+  resolveOpencodeModelsCacheDir
+} from "./chunk-3LOY6YZI.js";
+import {
+  DEFAULT_PROVIDER_CIRCUIT_BREAKER_OPTIONS,
+  RetryBudget,
+  assertWorkspaceRetryIsSafe,
+  captureGitBaseline,
+  captureWorkspaceRetryState,
+  detectGitChangedFiles,
+  executeWithResilience,
+  getGitHead,
+  measurePromptRequestBytes,
+  recordInvocationTiming,
+  rejectUnsafeFullPromptRetry
+} from "./chunk-D37WY7SH.js";
+import "./chunk-Z7CDQNH3.js";
+import "./chunk-PRDHI2L5.js";
+import {
+  resolveProviderTimeoutMs
+} from "./chunk-URMSZXAD.js";
+import {
+  acquireRateLimitToken
+} from "./chunk-JVHGMURQ.js";
+import "./chunk-JYXS47FQ.js";
+import "./chunk-B7PYTV72.js";
+import "./chunk-4QKP6I4C.js";
+import {
+  clampAttemptTimeoutToDeadline
+} from "./chunk-GWHGTG37.js";
+import {
+  inferProviderFailurePhase,
+  recordProviderRunFailure,
+  recordProviderRunSuccess
+} from "./chunk-CRPRVNQ4.js";
+import {
+  metadata
+} from "./chunk-WEIUS5NT.js";
+import {
+  getOpencodeRunCapabilities,
+  isOpencode2Version
+} from "./chunk-S47ISY27.js";
+import {
+  isUnknownErrorRetryable
+} from "./chunk-3P5IN5E7.js";
+import "./chunk-WEI3ZDZH.js";
+import "./chunk-H6MJGKAW.js";
+import "./chunk-67YRJPJO.js";
+import {
+  prepareVariantCommand
+} from "./chunk-633XZ7UF.js";
+import "./chunk-SF6YK3JI.js";
+import {
+  providerOutputTail,
+  redactProviderArgv
+} from "./chunk-JBBB2Y47.js";
+import "./chunk-WJAL4JL3.js";
+import {
+  PUBLIC_DIAGNOSTICS_STRING_MAX,
+  sanitizeDiagnosticOutput
+} from "./chunk-RBKLOUXA.js";
+import "./chunk-4EBSXZ73.js";
+import "./chunk-PFCXFO7A.js";
+import "./chunk-SDPIFNLD.js";
+import "./chunk-GO6DRECI.js";
+import "./chunk-XIBVFMLQ.js";
+import "./chunk-QWMQ74KD.js";
+import "./chunk-GAFJEYLK.js";
+import "./chunk-YKC75XK4.js";
+import "./chunk-T7E5JS6N.js";
+import "./chunk-ZJB6SQPA.js";
+import "./chunk-GZK62I3N.js";
+import "./chunk-GC4CRMTS.js";
+import "./chunk-P7CQGPLS.js";
+import "./chunk-C3DH3NCY.js";
+import "./chunk-IVZEONFC.js";
+import {
+  buildProviderExecutionEnv
+} from "./chunk-XTXYIISX.js";
+import "./chunk-MEMSY6VY.js";
+import "./chunk-VBNCKCCI.js";
+import "./chunk-33IGPPUI.js";
+import "./chunk-UPHU64NB.js";
+import "./chunk-JLS65NUQ.js";
+import "./chunk-FRBPKBFE.js";
+import "./chunk-BAWJNMWF.js";
+import "./chunk-LX4F24ZH.js";
+import "./chunk-BBPIILO2.js";
+import "./chunk-2NMNFUQA.js";
+import "./chunk-I7SCBHJN.js";
+import {
+  applyWorkspaceMode,
+  logReasoningEffortResolution,
+  resolveEffectiveMode
+} from "./chunk-TGXXYDL4.js";
+import "./chunk-D2M2Y5ID.js";
+import "./chunk-UJP3XM54.js";
+import "./chunk-MULMXX4V.js";
+import "./chunk-UTDEOPKV.js";
+import "./chunk-RFDVSI4N.js";
+import "./chunk-M4BUEXXF.js";
+import "./chunk-ZH4G3FU5.js";
+import "./chunk-726G6WDL.js";
+import "./chunk-EP22ZMFO.js";
+import "./chunk-5UBIFVRD.js";
+import "./chunk-O7FE75QZ.js";
+import "./chunk-Q64IR2Z2.js";
+import {
+  deriveOpencodePrefixes
+} from "./chunk-YVCMDVBB.js";
+import "./chunk-7HPCIOMA.js";
+import "./chunk-P6SSWAKY.js";
+import "./chunk-ETAD4NKD.js";
+import "./chunk-XQPEWJPI.js";
+import "./chunk-7YAOUUKK.js";
+import "./chunk-SKTFRFQ7.js";
+import "./chunk-O5X6BKAO.js";
+import "./chunk-R2CKS6WT.js";
+import "./chunk-3OPP2OZB.js";
+import "./chunk-EPRMH6HO.js";
+import "./chunk-XHOI4V62.js";
+import "./chunk-S2VQCZO4.js";
+import "./chunk-6TBEX4R4.js";
+import "./chunk-PXKERBKX.js";
+import "./chunk-QYQOVOLR.js";
+import "./chunk-QFLBRWCJ.js";
+import "./chunk-AEQWV746.js";
+import "./chunk-SVUNZOPG.js";
+import "./chunk-KUEWV2JH.js";
+import "./chunk-R2TIYG7U.js";
+import "./chunk-5FKHIKTS.js";
+import "./chunk-S2E632FQ.js";
+import "./chunk-XJ2E7YEJ.js";
+import {
+  requireActivePolicyBoundary,
+  requireActiveSandboxBoundary
+} from "./chunk-B7YRSULE.js";
+import "./chunk-4U6XK2DG.js";
+import "./chunk-BY6ODHNZ.js";
+import "./chunk-3H4MWYIC.js";
+import "./chunk-DP7FKP6W.js";
+import "./chunk-VIFHYTI5.js";
+import "./chunk-XGU6PBO5.js";
+import "./chunk-F55YABKV.js";
+import "./chunk-YO5BAJ55.js";
+import "./chunk-EVE3OD2W.js";
+import {
+  mkBuildTempDir
+} from "./chunk-D6WTZMZB.js";
+import "./chunk-5EQN56OZ.js";
+import "./chunk-RBBTBCHX.js";
+import "./chunk-4DJL2VXA.js";
+import "./chunk-AHU3FKPA.js";
+import {
+  stripAnsiSequences
+} from "./chunk-TUQMMFEQ.js";
+import "./chunk-EPAMVGI3.js";
+import "./chunk-6CB3KJRY.js";
+import "./chunk-L2S235CU.js";
+import "./chunk-D4VJFCGZ.js";
+import "./chunk-RPIMAMV7.js";
+import {
+  safeRmDir
+} from "./chunk-ALDTFNZ3.js";
+import "./chunk-QOIASNEJ.js";
+import "./chunk-2VUEDIUM.js";
+import "./chunk-MJ6WNSIX.js";
+import "./chunk-5KQETTNS.js";
+import "./chunk-J2ICMYDA.js";
+import "./chunk-2VLJUXJU.js";
+import "./chunk-PPZESPJT.js";
+import "./chunk-XCOIBNET.js";
+import {
+  getProviderRuntimeQuirks
+} from "./chunk-Y733RB7T.js";
+import "./chunk-H3HGMISG.js";
+import "./chunk-FAZBRHGG.js";
+import "./chunk-CJBSZX3F.js";
+import "./chunk-C3KCMAJP.js";
+import "./chunk-FKCG7K6H.js";
+import "./chunk-AJN5Y5YZ.js";
+import "./chunk-MHLEZQQI.js";
+import "./chunk-HEP3ILP4.js";
+import "./chunk-BQJOGAWT.js";
+import "./chunk-WV3KQDPE.js";
+import "./chunk-VSWC5ZXI.js";
+import "./chunk-XV7NZL4B.js";
+import {
+  resolveProviderCliCommand
+} from "./chunk-KKQKWAMF.js";
+import "./chunk-RWQQIKIC.js";
+import "./chunk-GVJGSSKM.js";
+import "./chunk-QJ6OEH4K.js";
+import {
+  readFrontMatter,
+  readInheritedSet,
+  recordAuthCopySeed,
+  recordInheritedKind,
+  stripFrontMatter,
+  writeBackRefreshedAuth
+} from "./chunk-BD3PGW6A.js";
+import {
+  INHERITED_AGENTS_DIRNAME,
+  INHERITED_INSTRUCTIONS_FILENAME,
+  INHERITED_SKILLS_DIRNAME,
+  excludesAgentGlobals,
+  readLaunchInheritance
+} from "./chunk-43OKHTW4.js";
+import "./chunk-MNOVBYFU.js";
+import "./chunk-QXBKTJT6.js";
+import "./chunk-4BTDUT2S.js";
+import "./chunk-35J4NE6S.js";
+import "./chunk-RIMARPCF.js";
+import "./chunk-HGFXODKO.js";
+import "./chunk-N5DX4JAK.js";
+import "./chunk-V2TVPO3X.js";
+import {
+  CredentialResidueError,
+  ProviderExecutionError
+} from "./chunk-RRC5BL7B.js";
+import "./chunk-352PCJLK.js";
+import "./chunk-RCP2Y6DQ.js";
+import {
+  hostTerminationMetadataFromUnknown,
+  isCapacityError,
+  isContextOverflowError,
+  isRateLimitError,
+  parseHostTermination
+} from "./chunk-M6UHOC4I.js";
+import "./chunk-PSTKWHHN.js";
+import "./chunk-KTMW65UX.js";
+import "./chunk-3JKNRYEE.js";
+import "./chunk-MT2WAIR3.js";
+import "./chunk-WGQAXLNA.js";
+import "./chunk-ONHAMBN6.js";
+import "./chunk-XSJTIFUY.js";
+import "./chunk-XWIZ6B5S.js";
+import "./chunk-U4DRS6ZW.js";
+import "./chunk-I56TH7VM.js";
+import "./chunk-Z5WGNULV.js";
+import "./chunk-O26L6F7F.js";
+import "./chunk-RJ6RSNT6.js";
+import "./chunk-ZORW64QH.js";
+import "./chunk-TAJPCXSB.js";
+import "./chunk-56WPYDJH.js";
+import "./chunk-RSYTSBOO.js";
+import "./chunk-STW7OFOA.js";
+import "./chunk-CHA2HDE5.js";
+import "./chunk-JNMWYMC6.js";
+import {
+  BUILD_OPENCODE_TRANSIENT_AGENT,
+  BUILD_OPENCODE_XDG_CACHE_HOME,
+  BUILD_OPENCODE_XDG_CONFIG_HOME,
+  BUILD_OPENCODE_XDG_DATA_HOME,
+  BUILD_OPENCODE_XDG_STATE_HOME,
+  BUILD_TEST_FAST_RETRY,
+  debugLog,
+  getExecutionContext,
+  isDebugMode,
+  readEnv,
+  readRawEnv
+} from "./chunk-7VRJHTGZ.js";
+import "./chunk-XDM65LBX.js";
+import "./chunk-CPSVQR2I.js";
+import "./chunk-PZ5AY32C.js";
+
+// src/core/providers/opencode/execution/runner.ts
+import * as fs3 from "fs/promises";
+import { homedir as homedir2, tmpdir as tmpdir2 } from "os";
+import * as path3 from "path";
+
+// src/core/steering/transport/opencode.ts
+import { writeFile } from "fs/promises";
+import { tmpdir } from "os";
+import { join } from "path";
+function buildOpencodeSteering(options) {
+  return assembleSteering({
+    provider: "opencode",
+    guidance: options.guidance,
+    omitInstructionSet: options.omitInstructionSet,
+    omitUserInstructions: omitsUserInstructions(options.env)
+  });
+}
+function buildOpencodeInstructionsConfig(instructions) {
+  return JSON.stringify({ $schema: "https://opencode.ai/config.json", instructions });
+}
+async function stageOpencodeSteeringInstructions(payload) {
+  if (!payload.systemChannel) return void 0;
+  const dir = await mkBuildTempDir("opencode-steering");
+  const cleanup = async () => {
+    try {
+      await safeRmDir(dir, { protectedPaths: [tmpdir()], managedRoots: [tmpdir()] });
+    } catch (error) {
+      debugLog(
+        `[OpenCode] Failed to clean steering instructions ${dir}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  };
+  const filePath = join(dir, "build-steering.md");
+  try {
+    await writeFile(filePath, payload.systemChannel, "utf8");
+  } catch (error) {
+    await cleanup();
+    throw error;
+  }
+  return { configContent: buildOpencodeInstructionsConfig([filePath]), filePath, cleanup };
+}
+function applyOpencodePreambleFallback(payload, userPrompt) {
+  if (!payload.systemChannel) return userPrompt;
+  return `${payload.systemChannel}
+
+${userPrompt}`;
+}
+
+// src/core/providers/opencode/error-parser.ts
+var OPENCODE_UNKNOWN_ERROR_POLICY = "fail";
+var MODEL_NOT_FOUND_PATTERN = /\bmodel_not_found\b|providermodelnotfound|\bmodel not found\b|\bunknown model\b|no such model|model\s+["'`][^"'`]+["'`]\s+not found|\bmodel unavailable\b/i;
+function extractRequestedModelId(...texts) {
+  const combined = texts.filter(Boolean).join("\n");
+  const patterns = [
+    /model[_\s-]?not[_\s-]?found[:\s]+["'`]?([A-Za-z0-9._/:-]+)/i,
+    /unknown model[:\s]+["'`]?([A-Za-z0-9._/:-]+)/i,
+    /model ["'`]([^"'`]+)["'`]/i,
+    /--model\s+([A-Za-z0-9._/:-]+)/i
+  ];
+  for (const pattern of patterns) {
+    const match = combined.match(pattern);
+    const id = match?.[1]?.trim();
+    if (id) return id;
+  }
+  return void 0;
+}
+function buildOpencodeModelNotFoundUserMessage(context = {}) {
+  const requested = context.requestedModel?.trim() || "unknown";
+  const cliVersion = context.cliVersion?.trim() || "unknown";
+  const inventoryAge = context.inventoryAgeMs === void 0 ? "unknown" : formatCacheAge(context.inventoryAgeMs);
+  const parts = [
+    `OpenCode could not resolve model "${requested}".`,
+    `CLI version: ${cliVersion}. Inventory age: ${inventoryAge}.`
+  ];
+  const inventory = context.inventoryModelIds;
+  if (inventory === void 0) {
+    parts.push(
+      "The local OpenCode model inventory is unavailable, so Build could not compare the requested model with it."
+    );
+  } else if (inventory.length === 0) {
+    parts.push("The local OpenCode model inventory is available but empty.");
+  } else {
+    const canonicalRequested = canonicalizeOpencodeModelId(requested, [...inventory]);
+    if (canonicalRequested !== requested) {
+      parts.push(`Canonical inventory model: "${canonicalRequested}".`);
+    }
+    if (inventory.includes(canonicalRequested)) {
+      parts.push(
+        "The local inventory lists that model; the OpenCode execution error remains authoritative."
+      );
+    } else {
+      const [requestedPrefix] = deriveOpencodePrefixes([canonicalRequested]);
+      const inventoryPrefixes = deriveOpencodePrefixes(inventory);
+      if (requestedPrefix && !inventoryPrefixes.has(requestedPrefix)) {
+        parts.push(
+          `The local inventory does not list models for provider prefix "${requestedPrefix}".`
+        );
+      } else if (requestedPrefix) {
+        parts.push(
+          `The local inventory lists provider prefix "${requestedPrefix}" but does not list model "${canonicalRequested}".`
+        );
+      } else {
+        parts.push(`The local inventory does not list model "${canonicalRequested}".`);
+      }
+    }
+  }
+  parts.push(
+    isOpencode2Version(context.cliVersion) ? "Check the models OpenCode lists with `opencode models --standalone`." : "Refresh the local inventory with `opencode models --refresh`."
+  );
+  return parts.join(" ");
+}
+function parseOpencodeError(error, context = {}) {
+  const message = error instanceof Error ? error.message : String(error);
+  const providerError = error instanceof ProviderExecutionError ? error : void 0;
+  const stderr = providerError?.stderr ?? "";
+  const stdout = providerError?.stdout ?? "";
+  const exitCode = providerError?.exitCode;
+  const reason = providerError?.reason;
+  const fullStderr = providerError?.rawStderr ?? stderr;
+  const fullStdout = providerError?.rawStdout ?? stdout;
+  const diagnosticMessage = reason === "non_zero_exit" ? "" : message;
+  const diagnosticStdout = [
+    ...(parseOpencodeProviderOutput(fullStdout, "").errorEvents ?? []).map(
+      (event) => event.message
+    ),
+    extractUnstructuredOpencodeStdout(fullStdout)
+  ].join("\n");
+  const diagnostics = `${diagnosticMessage}
+${fullStderr}
+${diagnosticStdout}`;
+  const combined = diagnostics.toLowerCase();
+  const hostParsed = parseHostTermination(
+    hostTerminationMetadataFromUnknown(error),
+    diagnostics,
+    exitCode
+  );
+  if (hostParsed) {
+    return {
+      type: hostParsed.type,
+      retryable: hostParsed.retryable,
+      userMessage: hostParsed.userMessage,
+      original: { message, stderr, stdout, exitCode, reason }
+    };
+  }
+  const hasHttpStatusContext = /\b(?:http|status|response|error|code)\s*(?:[:=]|\bis\b)?\s*(401|403|429|500|502|503|504|400)\b/i.test(
+    combined
+  );
+  const hasAuthSignal = /unauthorized|unauthenticated|authentication required|login required|invalid api key|api key has been revoked|(?:api|access|authorization|account).*permission denied|permission denied.*(?:api|key|token|account)|forbidden|not authenticated|session expired|credentials invalid|could not load credentials|load credentials/i.test(
+    combined
+  );
+  const isFilesystemPermissionError = /(?:eacces|eperm|operation not permitted|read-only file system|permission denied)/i.test(
+    combined
+  ) && /(?:file|directory|path|mkdir|open|write|rename|unlink|chmod|stat)\b/i.test(combined);
+  if (reason === "command_not_found" || /\bcommand not found\b/i.test(combined) || /spawn .* enoent/i.test(combined)) {
+    return {
+      type: "command_not_found",
+      retryable: false,
+      userMessage: "OpenCode CLI not found. Install with `curl -fsSL https://opencode.ai/install | bash` or `npm install -g opencode-ai`, then run `opencode auth login`.",
+      original: { message, stderr, stdout, exitCode, reason }
+    };
+  }
+  if ((hasAuthSignal || hasHttpStatusContext && /\b401\b|\b403\b/.test(combined)) && !isFilesystemPermissionError) {
+    return {
+      type: "auth",
+      retryable: false,
+      userMessage: "OpenCode authentication failed. Run `opencode auth login` to re-authenticate.",
+      original: { message, stderr, stdout, exitCode, reason }
+    };
+  }
+  const quotaExhaustion = detectQuotaExhaustion(combined);
+  if (quotaExhaustion) {
+    return {
+      type: "rate_limit",
+      retryable: false,
+      userMessage: formatQuotaExhaustedMessage("OpenCode", quotaExhaustion),
+      original: { message, stderr, stdout, exitCode, reason }
+    };
+  }
+  if (isRateLimitError(combined) || hasHttpStatusContext && /\b429\b/.test(combined)) {
+    return {
+      type: "rate_limit",
+      retryable: true,
+      userMessage: "OpenCode rate limit or quota exceeded. Retrying may succeed after backoff.",
+      original: { message, stderr, stdout, exitCode, reason }
+    };
+  }
+  if (isCapacityError(combined) || hasHttpStatusContext && /\b503\b|\b502\b|\b500\b|\b504\b/.test(combined)) {
+    return {
+      type: "capacity",
+      retryable: true,
+      userMessage: "OpenCode service temporarily unavailable. Retrying may succeed.",
+      original: { message, stderr, stdout, exitCode, reason }
+    };
+  }
+  if (/performing one time database migration/i.test(combined)) {
+    return {
+      type: "bootstrap",
+      retryable: true,
+      userMessage: "OpenCode is performing first-run setup. Retrying may succeed.",
+      original: { message, stderr, stdout, exitCode, reason }
+    };
+  }
+  if (reason === "timeout" || /execution timed out/i.test(combined)) {
+    return {
+      type: "timeout",
+      retryable: false,
+      userMessage: "OpenCode execution timed out. Consider increasing timeout or simplifying the task.",
+      original: { message, stderr, stdout, exitCode, reason }
+    };
+  }
+  if (/econnreset|econnrefused|enotfound|enetunreach|etimedout|eai_again|socket hang up|fetch failed|network error|getaddrinfo|connection.*timeout/i.test(
+    combined
+  )) {
+    return {
+      type: "network",
+      retryable: true,
+      userMessage: "Network error connecting to OpenCode. Retrying may succeed.",
+      original: { message, stderr, stdout, exitCode, reason }
+    };
+  }
+  if (MODEL_NOT_FOUND_PATTERN.test(combined)) {
+    const requestedModel = context.requestedModel?.trim() || extractRequestedModelId(message, stderr, stdout) || void 0;
+    return {
+      type: "model_not_found",
+      retryable: false,
+      userMessage: buildOpencodeModelNotFoundUserMessage({
+        requestedModel,
+        cliVersion: context.cliVersion,
+        inventoryModelIds: context.inventoryModelIds,
+        inventoryAgeMs: context.inventoryAgeMs
+      }),
+      original: { message, stderr, stdout, exitCode, reason }
+    };
+  }
+  if (isContextOverflowError(combined)) {
+    return {
+      type: "validation",
+      retryable: false,
+      userMessage: "OpenCode request is too large for the model context window.",
+      original: { message, stderr, stdout, exitCode, reason }
+    };
+  }
+  if (/invalid arguments|unknown option|unrecognized|usage:|bad request/i.test(combined) || hasHttpStatusContext && /\b400\b/.test(combined)) {
+    return {
+      type: "validation",
+      retryable: false,
+      userMessage: "Invalid request to OpenCode CLI. This may be a Build configuration bug.",
+      original: { message, stderr, stdout, exitCode, reason }
+    };
+  }
+  return {
+    type: "unknown",
+    retryable: isUnknownErrorRetryable(OPENCODE_UNKNOWN_ERROR_POLICY),
+    userMessage: "OpenCode execution failed with an unknown error.",
+    original: { message, stderr, stdout, exitCode, reason }
+  };
+}
+
+// src/core/providers/opencode/inherited-config.ts
+import { existsSync, readFileSync } from "fs";
+import * as fs from "fs/promises";
+import { homedir } from "os";
+import * as path from "path";
+import { applyEdits, modify, parse as parseJsonc } from "jsonc-parser";
+import { stringify as stringifyYaml } from "yaml";
+var OPENCODE_USER_CONFIG_FILES = ["opencode.json", "opencode.jsonc", "config.json"];
+var OPENCODE_USER_CONFIG_DIRS = ["agent"];
+var OPENCODE_BUILT_IN_AGENTS = /* @__PURE__ */ new Set([
+  "build",
+  "plan",
+  "general",
+  "explore",
+  "compaction",
+  "title",
+  "summary"
+]);
+var USER_GLOBAL_SETTINGS = ["instructions", "default_agent"];
+async function dropUserGlobalSettings(file) {
+  let text = await fs.readFile(file, "utf8");
+  const original = text;
+  for (const key of USER_GLOBAL_SETTINGS) {
+    let edits;
+    try {
+      edits = modify(text, [key], void 0, {});
+    } catch {
+      return;
+    }
+    text = applyEdits(text, edits);
+  }
+  if (text !== original) await fs.writeFile(file, text);
+}
+async function seedOpencodeUserConfig(sourceConfigHome, destinationConfigHome, options = {}) {
+  if (path.resolve(sourceConfigHome) === path.resolve(destinationConfigHome)) {
+    return;
+  }
+  const sourceDir = path.join(sourceConfigHome, "opencode");
+  const destinationDir = path.join(destinationConfigHome, "opencode");
+  try {
+    await fs.access(sourceDir);
+  } catch {
+    return;
+  }
+  try {
+    await fs.mkdir(destinationDir, { recursive: true });
+  } catch (error) {
+    throw new Error(
+      `Failed to create isolated OpenCode config directory: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  for (const fileName of OPENCODE_USER_CONFIG_FILES) {
+    const src = path.join(sourceDir, fileName);
+    const dst = path.join(destinationDir, fileName);
+    try {
+      await fs.copyFile(src, dst);
+      if (options.excludeGlobals) await dropUserGlobalSettings(dst);
+    } catch (error) {
+      const code = error.code;
+      if (code !== "ENOENT") {
+        throw new Error(
+          `Failed to seed OpenCode ${fileName} into isolated XDG_CONFIG_HOME: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  }
+  for (const dirName of options.excludeGlobals ? [] : OPENCODE_USER_CONFIG_DIRS) {
+    const src = path.join(sourceDir, dirName);
+    const dst = path.join(destinationDir, dirName);
+    try {
+      await fs.cp(src, dst, {
+        recursive: true,
+        errorOnExist: false,
+        force: true,
+        dereference: true
+      });
+    } catch (error) {
+      const code = error.code;
+      if (code !== "ENOENT") {
+        throw new Error(
+          `Failed to seed OpenCode ${dirName}/ into isolated XDG_CONFIG_HOME: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  }
+}
+function opencodeAgentText(text) {
+  const fields = readFrontMatter(text);
+  const frontMatter = {
+    ...typeof fields.name === "string" ? { name: fields.name } : {},
+    ...typeof fields.description === "string" ? { description: fields.description } : {},
+    mode: "subagent"
+  };
+  return `---
+${stringifyYaml(frontMatter)}---
+${stripFrontMatter(text).trimStart()}`;
+}
+async function writeOpencodeAgents(configDir, set) {
+  const source = path.join(set.dir, INHERITED_AGENTS_DIRNAME);
+  const target = path.join(configDir, "agent");
+  await fs.mkdir(target, { recursive: true });
+  for (const name of await fs.readdir(source)) {
+    if (!name.endsWith(".md")) continue;
+    const text = await fs.readFile(path.join(source, name), "utf8");
+    await fs.writeFile(path.join(target, name), opencodeAgentText(text));
+  }
+}
+function seededConfigDefinesAgents(configDir) {
+  return OPENCODE_USER_CONFIG_FILES.some((name) => {
+    let agents;
+    try {
+      agents = parseJsonc(readFileSync(path.join(configDir, name), "utf8"))?.agent;
+    } catch {
+      return false;
+    }
+    if (!agents || typeof agents !== "object") return false;
+    return Object.entries(agents).some(
+      ([agent, value]) => !OPENCODE_BUILT_IN_AGENTS.has(agent) && value?.disable !== true
+    );
+  });
+}
+function globalsStillLoading(options) {
+  const { callerOwned, configDir, home } = options;
+  const all = [
+    ...callerOwned ? ["the caller's config folder"] : [],
+    ...existsSync(path.join(home, ".opencode")) ? ["~/.opencode"] : []
+  ];
+  const claudeFileLoads = callerOwned && !existsSync(path.join(configDir, "AGENTS.md")) && existsSync(path.join(home, ".claude", "CLAUDE.md"));
+  return {
+    instructions: claudeFileLoads ? [...all, "~/.claude/CLAUDE.md"] : all,
+    skills: existsSync(path.join(home, ".agents", "skills")) ? [...all, "~/.agents/skills"] : all,
+    agents: !callerOwned && seededConfigDefinesAgents(configDir) ? [...all, "the agents in the user's config"] : all
+  };
+}
+function coverageBeside(stillLoading) {
+  if (!stillLoading?.length) return { coverage: "full" };
+  return { coverage: "partial", detail: `OpenCode also loads ${stillLoading.join(" and ")}` };
+}
+function recordOpencodeSet(set, options) {
+  const left = options.excludeGlobals ? globalsStillLoading(options) : {};
+  recordInheritedKind(set.dir, "instructions", {
+    route: "instructions",
+    text: set.text,
+    ...coverageBeside(left.instructions)
+  });
+  recordInheritedKind(set.dir, "steering", { route: "instructions", coverage: "full" });
+  for (const kind of ["skills", "agents"]) {
+    recordInheritedKind(
+      set.dir,
+      kind,
+      options.callerOwned ? { route: "config-dir", coverage: "none", detail: "the caller supplied the config folder" } : { route: "config-dir", ...coverageBeside(left[kind]) }
+    );
+  }
+}
+async function prepareOpencodeRunConfig(options) {
+  const { set, callerOwned } = options;
+  const excludeGlobals = excludesAgentGlobals(readLaunchInheritance(options.env));
+  const configDir = path.join(options.configHome, "opencode");
+  const env = {};
+  if (excludeGlobals) env.OPENCODE_DISABLE_CLAUDE_CODE_SKILLS = "1";
+  if (!callerOwned && (excludeGlobals || set?.has.skills || set?.has.agents)) {
+    await fs.mkdir(configDir, { recursive: true });
+    if (excludeGlobals) await fs.writeFile(path.join(configDir, "AGENTS.md"), "");
+    if (set?.has.skills) {
+      await fs.symlink(
+        path.join(set.dir, INHERITED_SKILLS_DIRNAME),
+        path.join(configDir, "skills"),
+        "dir"
+      );
+    }
+    if (set?.has.agents) await writeOpencodeAgents(configDir, set);
+  }
+  const instructions = [
+    ...set ? [path.join(set.dir, INHERITED_INSTRUCTIONS_FILENAME)] : [],
+    ...options.steeringFile ? [options.steeringFile] : []
+  ];
+  if (instructions.length > 0) {
+    env.OPENCODE_CONFIG_CONTENT = buildOpencodeInstructionsConfig(instructions);
+  }
+  if (set) {
+    const home = options.env?.HOME?.trim() || homedir();
+    recordOpencodeSet(set, { excludeGlobals, callerOwned, configDir, home });
+  }
+  return env;
+}
+
+// src/core/providers/opencode/log-diagnostics.ts
+import * as fs2 from "fs/promises";
+import * as path2 from "path";
+var MAX_OPENCODE_LOG_ERRORS = 5;
+var MAX_OPENCODE_LOG_BYTES = 256 * 1024;
+var LOG_FIELD_PATTERN = /(?:^|\s)(providerID|modelID|message|error(?:\.error)?)=("(?:\\.|[^"])*"|[^\s]+)/g;
+function decodeLogValue(raw) {
+  if (!raw.startsWith('"')) return raw;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return raw.slice(1, -1);
+  }
+}
+function extractOpencodeLogErrors(logText) {
+  const summaries = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const line of logText.split(/\r?\n/)) {
+    if (!/\blevel=ERROR\b/.test(line)) continue;
+    const fields = /* @__PURE__ */ new Map();
+    for (const match of line.matchAll(LOG_FIELD_PATTERN)) {
+      const key = match[1];
+      const value = match[2];
+      if (key && value) fields.set(key, decodeLogValue(value));
+    }
+    const error = fields.get("error.error") ?? fields.get("error");
+    const parts = [
+      fields.get("providerID") ? `provider=${fields.get("providerID")}` : void 0,
+      fields.get("modelID") ? `model=${fields.get("modelID")}` : void 0,
+      fields.get("message") ? `message=${fields.get("message")}` : void 0,
+      error ? `error=${error}` : void 0
+    ].filter(Boolean);
+    if (parts.length === 0) continue;
+    const summary = sanitizeDiagnosticOutput(`OpenCode log error: ${parts.join(" ")}`, 500);
+    if (!summary || seen.has(summary)) continue;
+    seen.add(summary);
+    summaries.push(summary);
+  }
+  return summaries.slice(-MAX_OPENCODE_LOG_ERRORS);
+}
+async function captureOpencodeLogCheckpoint(dataHome) {
+  const logPath = path2.join(dataHome, "opencode", "log", "opencode.log");
+  try {
+    const stat3 = await fs2.stat(logPath);
+    return { path: logPath, offset: stat3.size };
+  } catch {
+    return { path: logPath, offset: 0 };
+  }
+}
+async function readOpencodeLogErrorsSince(checkpoint) {
+  let handle;
+  try {
+    const stat3 = await fs2.stat(checkpoint.path);
+    if (stat3.size <= checkpoint.offset) return [];
+    const start = Math.max(checkpoint.offset, stat3.size - MAX_OPENCODE_LOG_BYTES);
+    const length = stat3.size - start;
+    const buffer = Buffer.alloc(length);
+    handle = await fs2.open(checkpoint.path, "r");
+    const { bytesRead } = await handle.read(buffer, 0, length, start);
+    return extractOpencodeLogErrors(buffer.subarray(0, bytesRead).toString("utf8"));
+  } catch {
+    return [];
+  } finally {
+    await handle?.close().catch(() => {
+    });
+  }
+}
+
+// src/core/providers/opencode/prompt-adapter.ts
+function adaptPromptForOpencode(prompt, options = {}) {
+  const effectiveMode = resolveEffectiveMode(
+    options.promptMode ?? null,
+    options.globalWorkspaceMode ?? null,
+    "opencode"
+  );
+  if (effectiveMode === "passthrough") {
+    return {
+      original: prompt,
+      adapted: prompt,
+      adaptations: ["Passthrough prompt for native OpenCode CLI parity"],
+      promptMode: effectiveMode
+    };
+  }
+  const composed = applyWorkspaceMode(prompt, {
+    mode: effectiveMode,
+    provider: "OPENCODE",
+    executionIntent: options.executionIntent ?? "mixed",
+    targetFiles: options.files,
+    projectRoot: options.projectRoot
+  });
+  return {
+    original: prompt,
+    adapted: composed.adapted,
+    adaptations: composed.operations,
+    promptMode: composed.mode,
+    completionSignalVariant: composed.completionSignalVariant
+  };
+}
+function formatAdaptations(adaptation) {
+  const lines = [];
+  lines.push("[PromptAdapter] OpenCode prompt adapted");
+  lines.push(`  - Mode: ${adaptation.promptMode}`);
+  lines.push(`  - Original length: ${adaptation.original.length} chars`);
+  lines.push(`  - Adapted length: ${adaptation.adapted.length} chars`);
+  lines.push(`  - Transformations applied: ${adaptation.adaptations.length}`);
+  if (adaptation.adaptations.length > 0) {
+    lines.push("  - Applied:");
+    for (const item of adaptation.adaptations) {
+      lines.push(`    - ${item}`);
+    }
+  }
+  if (isDebugMode()) {
+    lines.push(`  - Size delta: ${adaptation.adapted.length - adaptation.original.length} chars`);
+  }
+  return lines.join("\n");
+}
+
+// src/core/providers/opencode/execution/commands.ts
+function explicitModel(model) {
+  return model && model !== "auto" ? model : void 0;
+}
+function usesModelVariantSuffix(model, support) {
+  const id = explicitModel(model);
+  return !support.supportsVariant && support.supportsModelVariant === true && !!id && !id.includes("#");
+}
+function canEmitOpencodeVariant(model, support) {
+  return support.supportsVariant || usesModelVariantSuffix(model, support);
+}
+function appendOpencodeExecutionSettings(args, options) {
+  const model = explicitModel(options.model);
+  const suffix = usesModelVariantSuffix(model, options);
+  const variant = canEmitOpencodeVariant(model, options) ? options.variant : void 0;
+  if (model) args.push("--model", suffix && variant ? `${model}#${variant}` : model);
+  if (variant && !suffix) args.push("--variant", variant);
+  return prepareVariantCommand(args, model, variant);
+}
+function opencodeRunServerArgs(capabilities) {
+  if (isOpencode2Version(capabilities.cliVersion) && !capabilities.supportsStandalone) {
+    throw new ProviderExecutionError(
+      `${capabilities.cliVersion} does not list --standalone in \`opencode run --help\`. Build does not run OpenCode 2 through its shared background service, which runs tools outside Build's sandbox.`,
+      { retryable: false, reason: "unsupported_option", prelaunch: true, providerName: metadata.id }
+    );
+  }
+  if (!capabilities.supportsStandalone) return [];
+  return capabilities.supportsAuto ? ["--standalone", "--auto"] : ["--standalone"];
+}
+
+// src/core/providers/opencode/execution/error-events.ts
+function summarizeOpencodeErrorEvents(errorEvents) {
+  return errorEvents.slice(0, 3).map((event) => {
+    const type = event.errorType ? ` (${event.errorType})` : "";
+    const retryable = event.retryable === false ? "hard" : "retryable/degraded";
+    return `OpenCode error event${type} [${retryable}]: ${event.message}`;
+  }).join("\n");
+}
+function leadWithOpencodeErrorEvents(error) {
+  if (!(error instanceof Error)) return;
+  const carrier = error;
+  const stdout = typeof carrier.rawStdout === "string" ? carrier.rawStdout : carrier.stdout;
+  if (typeof stdout !== "string") return;
+  const errorEvents = parseOpencodeProviderOutput(stdout, "").errorEvents;
+  if (!errorEvents?.length) return;
+  const summary = sanitizeDiagnosticOutput(
+    summarizeOpencodeErrorEvents(errorEvents),
+    PUBLIC_DIAGNOSTICS_STRING_MAX
+  );
+  if (summary) error.message = `${summary}
+${error.message}`;
+}
+
+// src/core/providers/opencode/execution/runner.ts
+var OPENCODE_CIRCUIT_BREAKER_OPTIONS = DEFAULT_PROVIDER_CIRCUIT_BREAKER_OPTIONS;
+function readOpencodeRuntimeEnv(env, spec) {
+  const envValue = env?.[spec.name]?.trim();
+  if (envValue) {
+    return envValue;
+  }
+  const contextValue = getExecutionContext().envOverrides[spec.name]?.trim();
+  if (contextValue) {
+    return contextValue;
+  }
+  return readRawEnv(spec)?.trim();
+}
+function isOpencodeRuntimeEnvEnabled(env, spec) {
+  const raw = readOpencodeRuntimeEnv(env, spec);
+  if (raw === void 0) {
+    return spec.default ?? false;
+  }
+  const normalized = raw.toLowerCase();
+  if (["1", "true", "yes", "on"].includes(normalized)) return true;
+  if (["0", "false", "no", "off"].includes(normalized)) return false;
+  throw new Error(
+    `Invalid boolean value for ${spec.name}: "${raw}". Expected one of: 1, true, yes, on, 0, false, no, off`
+  );
+}
+function resolveOpencodeAttemptTimeoutMs(timeoutMs, deadlineMs) {
+  return clampAttemptTimeoutToDeadline(
+    timeoutMs,
+    deadlineMs,
+    () => new ProviderExecutionError("OpenCode deadline exceeded before attempt start.", {
+      providerName: metadata.id,
+      retryable: false,
+      reason: "deadline_exhausted"
+    })
+  );
+}
+function resolveOpencodeIdleTimeout(requested, providerDefault, allowAboveProviderDefault) {
+  if (requested == null) return providerDefault;
+  if (providerDefault == null || allowAboveProviderDefault) return requested;
+  return Math.min(requested, providerDefault);
+}
+function formatResolvedOpencodeModel(providerId, modelId) {
+  if (typeof modelId !== "string" || modelId.trim().length === 0) {
+    return void 0;
+  }
+  const trimmedModel = modelId.trim();
+  if (trimmedModel.includes("/")) {
+    return trimmedModel;
+  }
+  return typeof providerId === "string" && providerId.trim().length > 0 ? `${providerId.trim()}/${trimmedModel}` : trimmedModel;
+}
+function extractUsefulOpencodeRawOutput(stdout, stderr) {
+  return stripAnsiSequences(`${stdout}
+${stderr}`).split(/\r?\n/).map((line) => line.trim()).filter((line) => {
+    if (!line) return false;
+    if (line === "Performing one time database migration, may take a few minutes...") {
+      return false;
+    }
+    if (line === "sqlite-migration:done") return false;
+    if (line === "Database migration complete.") return false;
+    if (/^>\s+build\s+·\s+/i.test(line)) return false;
+    return true;
+  }).join("\n").trim();
+}
+function hasOpencodeReportedToolFailure(output) {
+  return output.split(/\r?\n/).some((line) => /^\u2717\s+.+\s+failed\b/i.test(line.trim()));
+}
+function resolveUserOpencodeDataHome() {
+  return process.env.XDG_DATA_HOME?.trim() || path3.join(homedir2(), ".local", "share");
+}
+function resolveUserOpencodeConfigHome() {
+  return process.env.XDG_CONFIG_HOME?.trim() || path3.join(homedir2(), ".config");
+}
+async function seedOpencodeCredentials(sourceDataHome, destinationDataHome) {
+  if (path3.resolve(sourceDataHome) === path3.resolve(destinationDataHome)) {
+    return void 0;
+  }
+  const sourceAuthPath = path3.join(sourceDataHome, "opencode", "auth.json");
+  const destinationDir = path3.join(destinationDataHome, "opencode");
+  const destinationAuthPath = path3.join(destinationDir, "auth.json");
+  try {
+    await fs3.mkdir(destinationDir, { recursive: true });
+    await fs3.copyFile(sourceAuthPath, destinationAuthPath);
+    return await recordAuthCopySeed(sourceAuthPath, destinationAuthPath);
+  } catch (error) {
+    const code = error.code;
+    if (code !== "ENOENT") {
+      debugLog(
+        `[OpenCode] Failed to seed auth.json into isolated XDG_DATA_HOME: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+    return void 0;
+  }
+}
+async function resolveOpencodeDataHome(env) {
+  const caller = resolveCallerOwnedPath(
+    env?.XDG_DATA_HOME,
+    readOpencodeRuntimeEnv(env, BUILD_OPENCODE_XDG_DATA_HOME)
+  );
+  if (caller) return { dataHome: caller.path };
+  const dataHome = await mkBuildTempDir("opencode-xdg");
+  const authSeed = await seedOpencodeCredentials(resolveUserOpencodeDataHome(), dataHome);
+  const owned = markRunOwnedRoot(dataHome);
+  return {
+    dataHome,
+    cleanup: async () => {
+      if (authSeed) await writeBackRefreshedAuth(authSeed);
+      await removeAndVerifyRunOwnedRoot(owned, { role: "opencode-xdg-data" });
+    }
+  };
+}
+async function resolveOpencodeStateHome(env) {
+  const caller = resolveCallerOwnedPath(
+    env?.XDG_STATE_HOME,
+    readOpencodeRuntimeEnv(env, BUILD_OPENCODE_XDG_STATE_HOME)
+  );
+  if (caller) return { stateHome: caller.path };
+  const stateHome = await mkBuildTempDir("opencode-state");
+  const owned = markRunOwnedRoot(stateHome);
+  return {
+    stateHome,
+    cleanup: async () => {
+      await removeAndVerifyRunOwnedRoot(owned, { role: "opencode-xdg-state" });
+    }
+  };
+}
+async function resolveOpencodeConfigHome(env) {
+  const caller = resolveCallerOwnedPath(
+    env?.XDG_CONFIG_HOME,
+    readOpencodeRuntimeEnv(env, BUILD_OPENCODE_XDG_CONFIG_HOME)
+  );
+  if (caller) return { configHome: caller.path, callerOwned: true };
+  const configHome = await mkBuildTempDir("opencode-config");
+  const owned = markRunOwnedRoot(configHome);
+  try {
+    await seedOpencodeUserConfig(resolveUserOpencodeConfigHome(), configHome, {
+      excludeGlobals: excludesAgentGlobals(readLaunchInheritance(env))
+    });
+  } catch (error) {
+    try {
+      await removeAndVerifyRunOwnedRoot(owned, { role: "opencode-xdg-config-seed-abort" });
+    } catch (cleanupError) {
+      if (cleanupError instanceof CredentialResidueError) {
+        throw contextualizeCredentialCleanupError(
+          cleanupError,
+          error,
+          "opencode-xdg-config-seed-abort"
+        );
+      }
+      throw cleanupError;
+    }
+    throw error;
+  }
+  return {
+    configHome,
+    cleanup: async () => {
+      await removeAndVerifyRunOwnedRoot(owned, { role: "opencode-xdg-config" });
+    }
+  };
+}
+async function resolveOpencodeCacheHome(env) {
+  const caller = resolveCallerOwnedPath(
+    env?.XDG_CACHE_HOME,
+    readOpencodeRuntimeEnv(env, BUILD_OPENCODE_XDG_CACHE_HOME)
+  );
+  if (caller) return { cacheHome: caller.path };
+  const cacheHome = await mkBuildTempDir("opencode-cache");
+  const owned = markRunOwnedRoot(cacheHome);
+  return {
+    cacheHome,
+    cleanup: async () => {
+      await removeAndVerifyRunOwnedRoot(owned, { role: "opencode-xdg-cache" });
+    }
+  };
+}
+async function hasOpenrouterCredential(childEnv, dataHome) {
+  if (childEnv.OPENROUTER_API_KEY?.trim() || childEnv.OPENROUTER_KEY?.trim()) {
+    return true;
+  }
+  try {
+    const authJson = await fs3.readFile(path3.join(dataHome, "opencode", "auth.json"), "utf8");
+    return /"openrouter"\s*:/.test(authJson);
+  } catch {
+    return false;
+  }
+}
+async function resolveOpencodeSessionFromDb(workingDir, dataHome) {
+  try {
+    const dbPath = path3.join(dataHome, "opencode", "opencode.db");
+    const { default: Database } = await import("better-sqlite3");
+    const db = new Database(dbPath, { readonly: true, fileMustExist: true });
+    try {
+      const session = db.prepare(
+        `
+            SELECT id
+            FROM session
+            WHERE directory = ?
+            ORDER BY time_updated DESC
+            LIMIT 1
+          `
+      ).get(workingDir);
+      if (typeof session?.id !== "string") {
+        return {};
+      }
+      const modelRow = db.prepare(
+        `
+            SELECT
+              json_extract(data, '$.providerID') AS providerID,
+              json_extract(data, '$.modelID') AS modelID,
+              json_extract(data, '$.model') AS model
+            FROM message
+            WHERE session_id = ?
+              AND json_extract(data, '$.role') = 'assistant'
+              AND (
+                json_extract(data, '$.modelID') IS NOT NULL
+                OR json_extract(data, '$.model') IS NOT NULL
+              )
+            ORDER BY time_created DESC
+            LIMIT 1
+          `
+      ).get(session.id);
+      const sessionProviderId = typeof modelRow?.providerID === "string" ? modelRow.providerID.trim() : "";
+      return {
+        sessionId: session.id,
+        ...sessionProviderId ? { servedRoute: sessionProviderId } : {},
+        resolvedModel: formatResolvedOpencodeModel(modelRow?.providerID, modelRow?.modelID) ?? formatResolvedOpencodeModel(void 0, modelRow?.model)
+      };
+    } finally {
+      db.close();
+    }
+  } catch {
+    return {};
+  }
+}
+async function resolveAttachedFilePaths(workingDir, files, attachments) {
+  const candidates = [...files ?? [], ...attachments ?? []].map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+  const deduped = /* @__PURE__ */ new Set();
+  const root = path3.resolve(workingDir);
+  for (const candidate of candidates) {
+    const resolved = path3.resolve(root, candidate);
+    if (resolved !== root && !resolved.startsWith(root + path3.sep)) {
+      throw new Error(`OpenCode attachment must be within working directory: ${candidate}`);
+    }
+    try {
+      if (!(await fs3.stat(resolved)).isFile()) {
+        debugLog(`[OpenCode] Skipping non-file attachment path: ${candidate}`);
+        continue;
+      }
+      deduped.add(resolved);
+    } catch {
+      debugLog(`[OpenCode] Skipping missing attachment path: ${candidate}`);
+    }
+  }
+  return [...deduped];
+}
+async function writePromptAttachment(prompt) {
+  const dir = await mkBuildTempDir("opencode-prompt");
+  const filePath = path3.join(dir, "prompt.md");
+  try {
+    await fs3.writeFile(filePath, prompt, "utf8");
+  } catch (error) {
+    await fs3.rm(dir, { recursive: true, force: true }).catch((cleanupError) => {
+      debugLog(
+        `[OpenCode] Failed to clean prompt attachment ${dir} after write failure: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}`
+      );
+    });
+    throw error;
+  }
+  return {
+    filePath,
+    cleanup: async () => {
+      try {
+        await fs3.rm(dir, { recursive: true, force: true });
+      } catch (error) {
+        debugLog(
+          `[OpenCode] Failed to clean prompt attachment ${dir}: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  };
+}
+async function clearMacProvenanceAttributes(filePaths) {
+  if (process.platform !== "darwin" || filePaths.length === 0) {
+    return;
+  }
+  try {
+    const { execa } = await import("execa");
+    for (const filePath of filePaths) {
+      try {
+        await execa("xattr", ["-d", "com.apple.provenance", filePath], {
+          reject: false,
+          timeout: 5e3
+        });
+      } catch (error) {
+        debugLog(
+          `[OpenCode] Failed to clear com.apple.provenance from ${filePath}: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  } catch (error) {
+    debugLog(
+      `[OpenCode] Unable to prepare macOS provenance cleanup: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function attachOpencodeInvocationDiagnostics(error, diagnostics) {
+  if (!error || typeof error !== "object") {
+    return;
+  }
+  const diagnosticError = error;
+  diagnosticError.commandPath ??= diagnostics.commandPath;
+  diagnosticError.argvRedacted ??= diagnostics.argvRedacted;
+  diagnosticError.stdoutTail ??= providerOutputTail(diagnostics.stdout ?? "");
+  diagnosticError.stderrTail ??= providerOutputTail(diagnostics.stderr ?? "");
+  diagnosticError.providerDiagnostics ??= diagnostics.providerDiagnostics;
+  diagnosticError.filesModified ??= diagnostics.filesModified;
+}
+async function runOpencodeNative(options) {
+  const {
+    prompt,
+    workingDir,
+    env,
+    onData,
+    onErrorData,
+    model,
+    modelReasoningEffort,
+    generationSettings,
+    files,
+    attachments,
+    abortSignal,
+    executionIntent
+  } = options;
+  await acquireRateLimitToken(metadata.id, model);
+  const baselineHead = await getGitHead(workingDir);
+  const baselineSnapshot = await captureGitBaseline(workingDir).catch(() => null);
+  const timeout = resolveProviderTimeoutMs(metadata.id, options.timeout);
+  const { command, prefixArgs } = resolveProviderCliCommand(metadata.id);
+  const runtimeQuirks = getProviderRuntimeQuirks(metadata.id);
+  const capabilities = await getOpencodeRunCapabilities(env);
+  const serverArgs = opencodeRunServerArgs(capabilities);
+  const capabilityWarnings = [];
+  const inventoryCacheDir = resolveOpencodeModelsCacheDir({
+    // Refresh and other readers use the canonical execution-context project,
+    // which remains stable when this launch executes in a variant worktree.
+    env: { ...process.env, ...getExecutionContext().envOverrides, ...env }
+  });
+  let effectiveModel = model;
+  if (model && options.modelExecutionPolicy !== "exact") {
+    const cachedModels = getCachedOpencodeModelIds(inventoryCacheDir);
+    const canonicalizedModel = canonicalizeOpencodeModelId(model, cachedModels);
+    effectiveModel = canonicalizedModel;
+    if (cachedModels.length > 0 && !cachedModels.includes(canonicalizedModel)) {
+      const suggestion = `openrouter/${model}`;
+      const suggestionHint = model.split("/").length === 2 && cachedModels.includes(suggestion) ? ` Did you mean "${suggestion}"?` : "";
+      const warning = `[OpenCode] Model "${model}" not found in cached model list.${suggestionHint}`;
+      capabilityWarnings.push(warning);
+      debugLog(warning);
+    }
+  }
+  const requestedWorkspaceMode = options.workspaceMode ?? options.promptMode;
+  const adaptation = adaptPromptForOpencode(prompt, {
+    executionIntent: executionIntent ?? "mixed",
+    files,
+    promptMode: requestedWorkspaceMode,
+    projectRoot: workingDir
+  });
+  let adaptedPrompt = adaptation.adapted;
+  debugLog(formatAdaptations(adaptation));
+  const steeringFileEnabled = isOpencodeRuntimeEnvEnabled(env, BUILD_OPENCODE_TRANSIENT_AGENT);
+  const inheritedSet = readInheritedSet(env);
+  const opencodeSteeringPayload = adaptation.promptMode !== "passthrough" || steeringFileEnabled ? buildOpencodeSteering({
+    guidance: {
+      recentContext: options.recentContext,
+      subagents: Boolean(options.delegatedSubagents)
+    },
+    env,
+    omitInstructionSet: inheritedSet !== void 0
+  }) : void 0;
+  const explicitEffort = normalizeOpencodeReasoningEffort(modelReasoningEffort);
+  const heuristicEffort = explicitEffort ? void 0 : normalizeOpencodeReasoningEffort(generationSettings?.reasoningEffort);
+  const effortResolution = explicitEffort ? resolveOpencodeReasoningEffort(explicitEffort, true, effectiveModel) : heuristicEffort ? resolveOpencodeReasoningEffort(heuristicEffort, false, effectiveModel) : void 0;
+  if (effortResolution) {
+    logReasoningEffortResolution(effortResolution, "opencode");
+  }
+  const nativeVariant = opencodeNativeVariant(options.variantInvocation);
+  const effectiveVariant = nativeVariant ?? effortResolution?.variantMapping;
+  const attachedFiles = await resolveAttachedFilePaths(workingDir, files, attachments);
+  await clearMacProvenanceAttributes(attachedFiles);
+  requireActiveSandboxBoundary(
+    "OpenCode",
+    "OpenCode automation bypass (OPENCODE_PERMISSION allow-all)",
+    "opencode"
+  );
+  let opencodeDataHome;
+  let opencodeStateHome;
+  let opencodeConfigHome;
+  let opencodeCacheHome;
+  let promptAttachmentCleanup;
+  let steeringInstructions;
+  let attachmentInstruction;
+  let runError;
+  try {
+    opencodeDataHome = await resolveOpencodeDataHome(env);
+    opencodeStateHome = await resolveOpencodeStateHome(env);
+    opencodeConfigHome = await resolveOpencodeConfigHome(env);
+    opencodeCacheHome = await resolveOpencodeCacheHome(env);
+    if (opencodeSteeringPayload && steeringFileEnabled) {
+      try {
+        steeringInstructions = await stageOpencodeSteeringInstructions(opencodeSteeringPayload);
+      } catch (error) {
+        debugLog(
+          `[OpenCode] Steering instructions staging failed; preamble fallback is used only outside passthrough mode. Error: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+    const steeringText = steeringInstructions && opencodeSteeringPayload?.systemChannel;
+    if (opencodeSteeringPayload && !steeringText && adaptation.promptMode !== "passthrough") {
+      adaptedPrompt = applyOpencodePreambleFallback(opencodeSteeringPayload, adaptedPrompt);
+    }
+    debugLog(
+      `[OpenCode] Runtime directories: TMPDIR=${env?.TMPDIR ?? process.env.TMPDIR ?? tmpdir2()} XDG_STATE_HOME=${opencodeStateHome.stateHome}`
+    );
+    const headlessEnv = {
+      OPENCODE_PERMISSION: JSON.stringify({ "*": { "*": "allow" } }),
+      XDG_CACHE_HOME: opencodeCacheHome.cacheHome,
+      XDG_CONFIG_HOME: opencodeConfigHome.configHome,
+      XDG_DATA_HOME: opencodeDataHome.dataHome,
+      XDG_STATE_HOME: opencodeStateHome.stateHome,
+      // The instructions list and what the per-run config folder carries (inherited-config.ts).
+      ...await prepareOpencodeRunConfig({
+        env,
+        set: inheritedSet,
+        configHome: opencodeConfigHome.configHome,
+        callerOwned: opencodeConfigHome.callerOwned === true,
+        steeringFile: steeringInstructions?.filePath
+      })
+    };
+    const childEnv = buildProviderExecutionEnv("opencode", { ...env ?? {}, ...headlessEnv });
+    const opencodeLogCheckpoint = await captureOpencodeLogCheckpoint(opencodeDataHome.dataHome);
+    const opencodeWorkspaceStateDir = path3.join(workingDir, ".opencode");
+    const opencodeRuntimeWritePaths = [
+      opencodeCacheHome.cacheHome,
+      opencodeConfigHome.configHome,
+      opencodeDataHome.dataHome,
+      opencodeStateHome.stateHome,
+      opencodeWorkspaceStateDir
+    ];
+    requireActivePolicyBoundary(
+      "OpenCode",
+      "OpenCode automation bypass (OPENCODE_PERMISSION allow-all)",
+      "opencode",
+      { env: childEnv }
+    );
+    if (effectiveModel?.toLowerCase().startsWith("openrouter/") && !await hasOpenrouterCredential(childEnv, opencodeDataHome.dataHome)) {
+      const stderr = "OpenCode OpenRouter credentials missing. Set OPENROUTER_API_KEY or run `opencode auth login` before using OpenRouter models.";
+      return {
+        stdout: "",
+        stderr,
+        exitCode: 1,
+        commandPath: command,
+        argvRedacted: redactProviderArgv([...prefixArgs, "run"]),
+        stdoutTail: "",
+        stderrTail: providerOutputTail(stderr),
+        workspaceMode: options.workspaceMode ?? options.promptMode,
+        workspaceModeRequested: options.workspaceMode ?? options.promptMode,
+        promptMode: options.workspaceMode ?? options.promptMode,
+        promptModeRequested: options.workspaceMode ?? options.promptMode
+      };
+    }
+    const args = [...prefixArgs, "run", ...serverArgs];
+    if (capabilities.supportsPure) {
+      args.push("--pure");
+    }
+    if (capabilities.supportsDir) {
+      args.push("--dir", workingDir);
+    }
+    if (capabilities.supportsFormatJson) {
+      args.push("--format", "json");
+    }
+    if (capabilities.supportsTitle) {
+      args.push("--title", `Build (${metadata.id}) - ${path3.basename(workingDir)}`);
+    }
+    if (capabilities.supportsDangerouslySkipPermissions) {
+      args.push("--dangerously-skip-permissions");
+    }
+    appendOpencodeExecutionSettings(args, {
+      model: effectiveModel,
+      variant: effectiveVariant,
+      supportsVariant: capabilities.supportsVariant,
+      supportsModelVariant: capabilities.supportsModelVariant
+    });
+    if (effectiveVariant && !canEmitOpencodeVariant(effectiveModel, capabilities)) {
+      if ((explicitEffort ?? nativeVariant) && capabilities.helpProbeConfirmed) {
+        throw new ProviderExecutionError(
+          capabilities.supportsModelVariant ? `OpenCode reasoning effort "${explicitEffort ?? nativeVariant}" needs an explicit model to carry it as provider/model#variant.` : `OpenCode reasoning effort "${explicitEffort ?? nativeVariant}" requires --variant, but this OpenCode CLI version does not support --variant.`,
+          {
+            retryable: false,
+            reason: "unsupported_reasoning_effort",
+            providerName: metadata.id
+          }
+        );
+      } else if (isDebugMode()) {
+        const warning = `[OpenCode] Variant "${effectiveVariant}" requested but this CLI version does not support --variant.`;
+        capabilityWarnings.push(warning);
+        debugLog(warning);
+      } else {
+        capabilityWarnings.push(
+          `[OpenCode] Variant "${effectiveVariant}" requested but this CLI version does not support --variant.`
+        );
+      }
+    }
+    if (attachedFiles.length > 0) {
+      if (capabilities.supportsFile) {
+        for (const filePath of attachedFiles) {
+          args.push("--file", filePath);
+        }
+      } else if (isDebugMode()) {
+        debugLog(
+          `[OpenCode] ${attachedFiles.length} attachment(s) were provided but this CLI version does not support --file.`
+        );
+      }
+    }
+    if (capabilities.supportsFile) {
+      const promptAttachment = await writePromptAttachment(adaptedPrompt);
+      promptAttachmentCleanup = promptAttachment.cleanup;
+      args.push("--file", promptAttachment.filePath);
+      attachmentInstruction = "Read the attached prompt file and complete the task exactly as specified.";
+      args.push("--", attachmentInstruction);
+    } else {
+      args.push("--");
+      args.push(adaptedPrompt);
+    }
+    const fastRetry = process.env.NODE_ENV === "test" || process.env.VITEST === "true" || readEnv(BUILD_TEST_FAST_RETRY).value;
+    const callerRetryBudget = options.retryBudget;
+    const retryBudget = callerRetryBudget ?? new RetryBudget({ maxTotalAttempts: 3 });
+    const callerConstrainedToOneAttempt = callerRetryBudget !== void 0 && callerRetryBudget.remaining <= 1;
+    const maxAttempts = callerConstrainedToOneAttempt ? 1 : 3;
+    const outerRetryBudget = callerConstrainedToOneAttempt ? void 0 : retryBudget;
+    const bootstrapRetryBudget = callerConstrainedToOneAttempt ? callerRetryBudget : void 0;
+    const bootstrapMaxAttempts = callerConstrainedToOneAttempt ? 1 : 3;
+    const invocationTimeRequestSentMs = Date.now();
+    let invocationTimeFirstTokenMs = null;
+    const opencodeLivenessStartedAtMs = invocationTimeRequestSentMs;
+    const opencodeLivenessPhasesMs = {
+      // Anchor phase for downstream relative timings; not a measured launch duration.
+      cliLaunch: 0
+    };
+    const argvRedacted = redactProviderArgv(args, { promptValues: [adaptedPrompt] });
+    let retryResult;
+    notifySubmittedPrompt(options.onSubmittedPrompt, { prompt: adaptedPrompt, role: "user" });
+    try {
+      retryResult = await executeWithResilience(
+        async () => {
+          const attemptStartState = await captureWorkspaceRetryState(workingDir);
+          try {
+            return await executeOpencodeCommandWithBootstrapRetry({
+              command,
+              args,
+              workingDir,
+              // Fall back to a sanitized inherited env when the caller did not
+              // supply one, so PATH/HOME/auth-related vars reach the subprocess.
+              env: childEnv,
+              timeout: resolveOpencodeAttemptTimeoutMs(timeout, options.deadlineMs),
+              deadlineMs: options.deadlineMs,
+              extraWritePaths: opencodeRuntimeWritePaths,
+              readOnlyWorkingDir: options.readOnlyWorkingDir,
+              // OPENCODE_PERMISSION (1.x) and --auto (2.x) disable the provider's
+              // tool-approval layer; the shared argv scan knows neither, so carry
+              // that fact to the final post-wrap proof-pair guard.
+              providerInternalSandboxBypass: serverArgs.includes("--auto") ? "--auto" : "OPENCODE_PERMISSION allow-all",
+              executionIntent: options.executionIntent,
+              executionTransport: options.executionTransport,
+              idleWarnMs: resolveOpencodeIdleTimeout(
+                options.idleWarnMs,
+                runtimeQuirks?.idleDefaults?.idleWarnMs,
+                options.allowIdleTimeoutAboveProviderDefault
+              ),
+              idleKillMs: resolveOpencodeIdleTimeout(
+                options.idleKillMs,
+                runtimeQuirks?.idleDefaults?.idleKillMs,
+                options.allowIdleTimeoutAboveProviderDefault
+              ),
+              onData,
+              onErrorData,
+              onStdoutChunk: options.onStdoutChunk,
+              onStderrChunk: options.onStderrChunk,
+              onActivity: options.onActivity,
+              onFirstOutput: () => {
+                if (!invocationTimeFirstTokenMs) {
+                  invocationTimeFirstTokenMs = Date.now();
+                  opencodeLivenessPhasesMs.firstOutput = invocationTimeFirstTokenMs - opencodeLivenessStartedAtMs;
+                }
+              },
+              abortSignal,
+              operation: "run",
+              // Thread caller budgets into bootstrap so BunInstall recovery cannot
+              // outrun the invoke one-attempt contract. Omitted for ordinary runs.
+              ...bootstrapRetryBudget ? { retryBudget: bootstrapRetryBudget } : {},
+              maxAttempts: bootstrapMaxAttempts,
+              beforeRetryAttempt: (error) => rejectUnsafeFullPromptRetry({
+                workingDir,
+                attemptStartState,
+                error,
+                providerName: metadata.id,
+                requireCleanState: true
+              }),
+              metadata: {
+                id: metadata.id,
+                name: metadata.name,
+                installCommand: metadata.installCommand,
+                authHint: metadata.authHint,
+                docsPath: metadata.docsPath,
+                docsAnchor: metadata.docsAnchor
+              }
+            });
+          } catch (error) {
+            await assertWorkspaceRetryIsSafe({
+              providerId: metadata.id,
+              providerName: metadata.name,
+              workingDir,
+              attemptStartState,
+              originalError: error,
+              retryable: parseOpencodeError(error, {
+                requestedModel: effectiveModel ?? model,
+                cliVersion: capabilities.cliVersion,
+                inventoryModelIds: getCachedOpencodeModelIds(inventoryCacheDir),
+                inventoryAgeMs: getOpencodeModelsCacheInfo(inventoryCacheDir).ageMs
+              }).retryable
+            });
+            throw error;
+          }
+        },
+        {
+          providerName: metadata.id,
+          providerId: metadata.id,
+          operation: "run",
+          maxAttempts,
+          abortSignal,
+          fastRetryMode: fastRetry,
+          retryBudget: outerRetryBudget,
+          errorParser: (error) => parseOpencodeError(error, {
+            requestedModel: effectiveModel ?? model,
+            cliVersion: capabilities.cliVersion,
+            inventoryModelIds: getCachedOpencodeModelIds(inventoryCacheDir),
+            inventoryAgeMs: getOpencodeModelsCacheInfo(inventoryCacheDir).ageMs
+          }),
+          circuitBreakerOptions: OPENCODE_CIRCUIT_BREAKER_OPTIONS,
+          circuitBreakerScope: options.circuitBreakerScope,
+          deadlineMs: options.deadlineMs ?? Date.now() + timeout,
+          minimumAttemptTimeMs: Math.min(timeout, 3e4),
+          retryWorktreeDir: workingDir
+        }
+      );
+    } catch (error) {
+      const exitCode = typeof error?.exitCode === "number" ? error.exitCode ?? null : null;
+      const stdout = typeof error?.stdout === "string" ? error.stdout : void 0;
+      const stderr = typeof error?.stderr === "string" ? error.stderr : void 0;
+      leadWithOpencodeErrorEvents(error);
+      const logErrors = await readOpencodeLogErrorsSince(opencodeLogCheckpoint);
+      const partialFilesModified = await detectGitChangedFiles(workingDir, {
+        baselineHead,
+        baselineSnapshot
+      }).catch(() => void 0);
+      attachOpencodeInvocationDiagnostics(error, {
+        commandPath: command,
+        argvRedacted,
+        stdout,
+        stderr,
+        ...logErrors.length > 0 ? {
+          providerDiagnostics: {
+            transportErrors: logErrors,
+            stderrSeverity: "error"
+          }
+        } : {},
+        ...partialFilesModified?.length ? { filesModified: partialFilesModified } : {}
+      });
+      await recordInvocationTiming({
+        providerId: metadata.id,
+        // The steering instructions file (when staged) is a second prompt channel.
+        requestSizeBytes: measurePromptRequestBytes(
+          adaptedPrompt,
+          attachmentInstruction,
+          steeringText
+        ),
+        modelId: model ?? "auto",
+        timeRequestSentMs: invocationTimeRequestSentMs,
+        timeFirstTokenMs: invocationTimeFirstTokenMs,
+        timeLastTokenMs: Date.now(),
+        status: "error",
+        failure: error,
+        env: childEnv
+      });
+      const errMsg = error instanceof Error ? error.message : String(error);
+      const isHardFailure = errMsg.includes("auth") || errMsg.includes("unauthorized") || errMsg.includes("not_found");
+      recordProviderRunFailure("opencode", {
+        error,
+        severity: isHardFailure ? "hard" : "normal",
+        phase: inferProviderFailurePhase({
+          error,
+          exitCode
+        })
+      });
+      throw error;
+    }
+    const result = retryResult.result;
+    const {
+      text: parsedText,
+      tokenUsage,
+      totalCostUsd,
+      resolvedModel,
+      servedRoute,
+      agentUsed,
+      subAgentInvocations,
+      subAgentTypes,
+      structuredEventCount,
+      errorEvents
+    } = parseOpencodeProviderOutput(result.stdout, result.stderr);
+    const opencodeSession = await resolveOpencodeSessionFromDb(
+      workingDir,
+      opencodeDataHome.dataHome
+    );
+    const effectiveResolvedModel = resolvedModel ?? opencodeSession.resolvedModel;
+    const effectiveServedRoute = servedRoute ?? opencodeSession.servedRoute;
+    const opencodeLogErrors = await readOpencodeLogErrorsSince(opencodeLogCheckpoint);
+    let filesModified;
+    let changeDetectionWarning;
+    try {
+      filesModified = await detectGitChangedFiles(workingDir, {
+        baselineHead,
+        baselineSnapshot
+      });
+    } catch {
+      changeDetectionWarning = "OpenCode Git change detection failed; file changes are unknown.";
+    }
+    const confirmedNoFileChanges = filesModified?.length === 0;
+    const rawStdoutNonEmpty = result.stdout.trim().length > 0;
+    const diagnosticRawOutput = extractUsefulOpencodeRawOutput(result.stdout, result.stderr);
+    const contributableRawOutput = extractUsefulOpencodeRawOutput(
+      extractUnstructuredOpencodeStdout(result.stdout),
+      ""
+    );
+    const contributedOutput = parsedText || contributableRawOutput;
+    const reportedToolFailure = hasOpencodeReportedToolFailure(diagnosticRawOutput);
+    const reportedProviderError = (errorEvents?.length ?? 0) > 0;
+    const reportedUnsuccessfulFinish = errorEvents?.some(
+      (event) => event.errorType === "length" || event.errorType === "content-filter"
+    ) === true;
+    const hasMeaningfulDelivery = contributedOutput.trim().length > 0 || (filesModified?.length ?? 0) > 0;
+    if (hasMeaningfulDelivery && opencodeLivenessPhasesMs.firstUsefulAction === void 0) {
+      opencodeLivenessPhasesMs.firstUsefulAction = Date.now() - opencodeLivenessStartedAtMs;
+    }
+    const noContentSuccess = result.exitCode === 0 && contributedOutput.trim().length === 0 && confirmedNoFileChanges;
+    const effectiveExitCode = noContentSuccess || reportedToolFailure || reportedUnsuccessfulFinish || reportedProviderError && !hasMeaningfulDelivery ? 1 : result.exitCode;
+    const emptySuccessMessage = "OpenCode exited 0 but produced no assistant output and no file changes.";
+    const reportedToolFailureMessage = "OpenCode exited 0 but reported a failed internal tool operation.";
+    const reportedProviderErrorMessage = reportedProviderError ? summarizeOpencodeErrorEvents(errorEvents ?? []) : void 0;
+    await recordInvocationTiming({
+      providerId: metadata.id,
+      // The steering instructions file (when staged) is a second prompt channel.
+      requestSizeBytes: measurePromptRequestBytes(
+        adaptedPrompt,
+        attachmentInstruction,
+        steeringText
+      ),
+      modelId: effectiveResolvedModel ?? model ?? "auto",
+      timeRequestSentMs: invocationTimeRequestSentMs,
+      timeFirstTokenMs: invocationTimeFirstTokenMs,
+      timeLastTokenMs: Date.now(),
+      tokensIn: tokenUsage?.inputTokens,
+      tokensOut: tokenUsage?.outputTokens,
+      tokenUsage,
+      providerReportedCostUsd: totalCostUsd,
+      backend: effectiveServedRoute,
+      status: effectiveExitCode === 0 ? "success" : "error",
+      errorCode: effectiveExitCode !== 0 ? `EXIT_${effectiveExitCode}` : null,
+      // The env OpenCode was spawned with: attribution ids are resolved from it, and
+      // the caller's map can be a partial one that lacks them.
+      env: childEnv
+    });
+    if (effectiveExitCode !== 0 && rawStdoutNonEmpty && structuredEventCount === 0 && confirmedNoFileChanges) {
+      reportOutputDrift({
+        provider: "opencode",
+        severity: "parse_fallback",
+        field: "jsonlParse",
+        detail: "stdout was non-empty but JSONL extraction produced no events and no edits",
+        outputShapeTag: "no-jsonl-events-no-edits"
+      });
+    }
+    if (structuredEventCount > 0 && parsedText.trim().length === 0 && rawStdoutNonEmpty && contributableRawOutput.length === 0 && confirmedNoFileChanges && !reportedProviderError) {
+      reportOutputDrift({
+        provider: "opencode",
+        severity: "parse_fallback",
+        field: "structuredDelivery",
+        detail: "structured events were present but contained no assistant delivery and no edits",
+        outputShapeTag: "structured-events-no-delivery-no-edits"
+      });
+    }
+    if (effectiveExitCode === 0) {
+      recordProviderRunSuccess("opencode");
+    } else {
+      recordProviderRunFailure("opencode", {
+        severity: "normal",
+        phase: inferProviderFailurePhase({
+          exitCode: effectiveExitCode,
+          stderr: result.stderr,
+          stdout: result.stdout,
+          filesModifiedCount: filesModified?.length ?? 0,
+          producedOutput: Boolean(contributedOutput.trim().length)
+        })
+      });
+    }
+    const appliedWorkspaceMode = adaptation.promptMode;
+    opencodeLivenessPhasesMs.finalResponse = Date.now() - opencodeLivenessStartedAtMs;
+    const baseStderr = noContentSuccess || reportedToolFailure || reportedProviderError ? [
+      result.stderr.trim(),
+      noContentSuccess ? emptySuccessMessage : void 0,
+      reportedToolFailure ? reportedToolFailureMessage : void 0,
+      reportedProviderErrorMessage
+    ].filter(Boolean).join("\n") : result.stderr;
+    const finalStderr = [capabilityWarnings.join("\n"), baseStderr.trim(), changeDetectionWarning].filter(Boolean).join("\n");
+    const finalResult = {
+      stdout: contributedOutput,
+      stderr: finalStderr,
+      exitCode: effectiveExitCode,
+      commandPath: command,
+      argvRedacted,
+      stdoutTail: providerOutputTail(result.stdout),
+      stderrTail: providerOutputTail(finalStderr),
+      providerDiagnostics: {
+        finalAnswerPresent: Boolean(contributedOutput.trim().length),
+        ...reportedToolFailure ? { toolErrors: [reportedToolFailureMessage] } : {},
+        ...reportedProviderError && reportedProviderErrorMessage ? { transportErrors: [reportedProviderErrorMessage] } : opencodeLogErrors.length > 0 && effectiveExitCode !== 0 ? { transportErrors: opencodeLogErrors } : {},
+        ...opencodeLogErrors.length > 0 && effectiveExitCode === 0 ? { retryErrors: opencodeLogErrors } : {},
+        stderrSeverity: reportedToolFailure || reportedProviderError || noContentSuccess ? "error" : capabilityWarnings.length > 0 || opencodeLogErrors.length > 0 || changeDetectionWarning ? "warning" : "none"
+      },
+      providerLivenessPhasesMs: opencodeLivenessPhasesMs,
+      ...capabilities.cliVersion ? { providerCliVersion: capabilities.cliVersion } : {},
+      sessionId: opencodeSession.sessionId,
+      workspaceMode: appliedWorkspaceMode,
+      workspaceModeRequested: requestedWorkspaceMode,
+      // Backwards compatibility
+      promptMode: appliedWorkspaceMode,
+      promptModeRequested: requestedWorkspaceMode,
+      completionSignalVariant: adaptation.completionSignalVariant,
+      tokenUsage,
+      totalCostUsd,
+      providerReportedCostUsd: totalCostUsd,
+      ...effectiveServedRoute ? { servedRoute: effectiveServedRoute } : {},
+      filesModified,
+      // Actual model chosen by OpenCode at runtime (only set when extracted from JSONL
+      // output). When model='auto', the CLI selects its own default and this captures
+      // what it actually used, allowing downstream telemetry to record the real model
+      // instead of the placeholder 'auto'.
+      ...effectiveResolvedModel ? { resolvedModel: effectiveResolvedModel } : {},
+      agentUsed,
+      subAgentInvocations,
+      subAgentTypes
+    };
+    return finalResult;
+  } catch (error) {
+    runError = error;
+    throw error;
+  } finally {
+    const cleanupResults = await Promise.allSettled([
+      promptAttachmentCleanup?.(),
+      steeringInstructions?.cleanup(),
+      opencodeDataHome?.cleanup?.(),
+      opencodeStateHome?.cleanup?.(),
+      opencodeConfigHome?.cleanup?.(),
+      opencodeCacheHome?.cleanup?.()
+    ]);
+    const cleanupErrors = cleanupResults.filter((result) => result.status === "rejected").map((result) => result.reason);
+    const residueErrors = cleanupErrors.filter(
+      (error) => error instanceof CredentialResidueError
+    );
+    if (residueErrors.length > 0) {
+      throw aggregateCredentialResidueErrors(residueErrors, {
+        ownership: "run-owned",
+        role: "opencode-runtime-cleanup",
+        ...runError !== void 0 ? { primaryError: runError } : {}
+      });
+    }
+    if (cleanupErrors.length > 0) {
+      const cleanupError = cleanupErrors[0];
+      throw cleanupError;
+    }
+  }
+}
+export {
+  resolveAttachedFilePaths,
+  runOpencodeNative,
+  seedOpencodeCredentials
+};
+//# sourceMappingURL=runner-PIS2BW7Y.js.map