@poetic-ai/poetic 1.42.0

package/dist/runner-HHH7ZN2Z.js

@@ -0,0 +1,1571 @@
+import {
+  canonicalizeOpencodeModelId,
+  ensureOpencodeWarm,
+  executeOpencodeCommandWithBootstrapRetry,
+  formatCacheAge,
+  getCachedOpencodeModelIds,
+  getOpencodeModelsCacheInfo,
+  parseOpencodeProviderOutput
+} from "./chunk-GPEL3FBM.js";
+import {
+  aggregateCredentialResidueErrors,
+  contextualizeCredentialCleanupError,
+  markRunOwnedRoot,
+  normalizeProviderCliVersion,
+  removeAndVerifyRunOwnedRoot,
+  resolveCallerOwnedPath
+} from "./chunk-XZYR5EDO.js";
+import {
+  metadata
+} from "./chunk-3FLXLLB7.js";
+import {
+  reportOutputDrift,
+  resolveSettings
+} from "./chunk-QTCJ5CC5.js";
+import {
+  assembleSteering
+} from "./chunk-MWHF5V7U.js";
+import "./chunk-3FOZ2VHV.js";
+import {
+  runMockNative
+} from "./chunk-P47VN5F4.js";
+import {
+  DEFAULT_PROVIDER_CIRCUIT_BREAKER_OPTIONS,
+  RetryBudget,
+  assertWorkspaceRetryIsSafe,
+  captureRetryWorktreeState,
+  captureWorkspaceRetryState,
+  executeWithResilience,
+  recordInvocationTiming,
+  rejectUnsafeFullPromptRetry,
+  resolveProviderTimeoutMs
+} from "./chunk-WZ6U3O7I.js";
+import {
+  detectGitChangedFiles,
+  getGitHead,
+  getGitStatusPaths,
+  stripAnsiSequences
+} from "./chunk-VTW7HP3R.js";
+import "./chunk-4CUY7AFY.js";
+import {
+  acquireRateLimitToken
+} from "./chunk-MWK5UZQ3.js";
+import "./chunk-MN6PL4AN.js";
+import "./chunk-NS33V3IM.js";
+import {
+  inferProviderFailurePhase,
+  recordProviderRunFailure,
+  recordProviderRunSuccess
+} from "./chunk-UHRBTZYY.js";
+import "./chunk-H2AYQIHW.js";
+import {
+  detectTaskType
+} from "./chunk-FATUVIIN.js";
+import "./chunk-XPU2XADL.js";
+import "./chunk-AURFMVCD.js";
+import "./chunk-VBNCKCCI.js";
+import "./chunk-SZ7DL357.js";
+import "./chunk-HIO33P3G.js";
+import {
+  buildProviderExecutionEnv
+} from "./chunk-APV6MK5E.js";
+import "./chunk-ZYG7GGKO.js";
+import {
+  providerOutputTail,
+  redactProviderArgv,
+  sanitizeDiagnosticOutput
+} from "./chunk-PFTQBXS6.js";
+import "./chunk-E3NTPHEO.js";
+import "./chunk-4NXPXE62.js";
+import "./chunk-4VJITV4P.js";
+import "./chunk-GHHFDU2U.js";
+import {
+  getProviderRuntimeQuirks
+} from "./chunk-FC23CTXV.js";
+import "./chunk-36PEBZAF.js";
+import {
+  resolveProviderCliCommand
+} from "./chunk-SURZ2WFE.js";
+import "./chunk-SP3LFU6B.js";
+import "./chunk-R4UWBC35.js";
+import "./chunk-2YFUIER7.js";
+import "./chunk-CKNX3TTP.js";
+import "./chunk-FYOILAN5.js";
+import "./chunk-J62KPGII.js";
+import "./chunk-XAONGNST.js";
+import "./chunk-GAFJEYLK.js";
+import "./chunk-H6G7QRMQ.js";
+import "./chunk-J6P3FWWW.js";
+import "./chunk-CP7H3HSP.js";
+import "./chunk-ETYDXCK7.js";
+import "./chunk-BSE4R6XD.js";
+import {
+  applyWorkspaceMode,
+  resolveEffectiveMode
+} from "./chunk-UR2IBGIM.js";
+import "./chunk-JSWMRQYG.js";
+import "./chunk-XGYF2QMZ.js";
+import "./chunk-72YTZMAM.js";
+import "./chunk-S2VQCZO4.js";
+import "./chunk-WMPU2UOV.js";
+import "./chunk-VX3UMWB7.js";
+import {
+  deriveOpencodePrefixes
+} from "./chunk-XT2ZQVTC.js";
+import "./chunk-YGXKOBQQ.js";
+import "./chunk-V72RMBM4.js";
+import "./chunk-ZDTGECTN.js";
+import "./chunk-G36W2T2S.js";
+import "./chunk-GKN3HMN4.js";
+import "./chunk-QVZMFDYG.js";
+import "./chunk-S54MKU6V.js";
+import "./chunk-3S62LLWJ.js";
+import "./chunk-45FPSA3B.js";
+import {
+  emitTelemetryFallbackWarning
+} from "./chunk-YMX76IOS.js";
+import "./chunk-6Y5U7UFY.js";
+import "./chunk-XV7NZL4B.js";
+import "./chunk-CD7ISXA4.js";
+import "./chunk-QGJDMEOV.js";
+import "./chunk-6TZJRKNW.js";
+import {
+  requireActivePolicyBoundary,
+  requireActiveSandboxBoundary
+} from "./chunk-PCAGC5MR.js";
+import "./chunk-5WCQRDRB.js";
+import "./chunk-5WRLK5KW.js";
+import {
+  mkPoeticTempDir
+} from "./chunk-C57KJOUQ.js";
+import "./chunk-DF5SLDE4.js";
+import "./chunk-TGON4N4O.js";
+import "./chunk-I5WRT7ZR.js";
+import "./chunk-A3YGID55.js";
+import "./chunk-5EERLVZB.js";
+import "./chunk-XQD2B6BB.js";
+import "./chunk-34CNP2HB.js";
+import "./chunk-KNDYMVWN.js";
+import "./chunk-RWREC3KJ.js";
+import "./chunk-7R2WLDOS.js";
+import "./chunk-LAMKBTXX.js";
+import "./chunk-FD4ERYEG.js";
+import "./chunk-KTMW65UX.js";
+import "./chunk-FHOWVDF5.js";
+import "./chunk-UDMS5AD3.js";
+import "./chunk-MWHLBPNU.js";
+import "./chunk-JLS65NUQ.js";
+import "./chunk-TRSVUPCX.js";
+import "./chunk-FKAUPHMR.js";
+import "./chunk-TSXGRLPR.js";
+import {
+  CredentialResidueError,
+  ProviderExecutionError
+} from "./chunk-LUVKFFWR.js";
+import "./chunk-ENRGKNR5.js";
+import "./chunk-XB5YLCLB.js";
+import "./chunk-QOCOVLUH.js";
+import "./chunk-2VSQMRCB.js";
+import {
+  logReasoningEffortResolution,
+  resolveReasoningEffort
+} from "./chunk-ON3G73BU.js";
+import "./chunk-3G6FZCRF.js";
+import "./chunk-N5DX4JAK.js";
+import "./chunk-2QLYTVYX.js";
+import "./chunk-7GDRQBQC.js";
+import "./chunk-PGSPX4SU.js";
+import "./chunk-AT4TNPWW.js";
+import "./chunk-GSGD5E4C.js";
+import {
+  getExecutionContext
+} from "./chunk-UI2F6DJ5.js";
+import "./chunk-4BTDUT2S.js";
+import "./chunk-L6OM4A22.js";
+import "./chunk-G4THLFV3.js";
+import "./chunk-RGWHUI5E.js";
+import "./chunk-UUH2RVKS.js";
+import "./chunk-LEIIWPWQ.js";
+import "./chunk-L7JZLXQL.js";
+import "./chunk-IZYIQQ7X.js";
+import "./chunk-JPKSXKNB.js";
+import "./chunk-TAJPCXSB.js";
+import "./chunk-XZE4XARH.js";
+import {
+  debugLog,
+  isDebugMode
+} from "./chunk-EJGCZGUF.js";
+import "./chunk-LPITVM7M.js";
+import {
+  POETIC_ALLOW_MOCK_PROVIDERS,
+  POETIC_MOCK_PROVIDERS,
+  POETIC_OPENCODE_TRANSIENT_AGENT,
+  POETIC_OPENCODE_XDG_CACHE_HOME,
+  POETIC_OPENCODE_XDG_CONFIG_HOME,
+  POETIC_OPENCODE_XDG_DATA_HOME,
+  POETIC_OPENCODE_XDG_STATE_HOME,
+  POETIC_TEST_FAST_RETRY,
+  readEnv,
+  readRawEnv
+} from "./chunk-5DLKYTQX.js";
+import "./chunk-PZ5AY32C.js";
+
+// src/core/providers/opencode/execution/runner.ts
+import * as fs2 from "fs/promises";
+import { homedir, tmpdir } from "os";
+import * as path2 from "path";
+
+// src/core/steering/transport/opencode.ts
+import { randomBytes } from "crypto";
+function buildOpencodeSteering(options) {
+  return assembleSteering({
+    provider: "opencode",
+    guidance: options.guidance
+  });
+}
+function planOpencodeTransientAgent(payload, options = {}) {
+  if (!payload.systemChannel) return void 0;
+  const suffix = options.randomSuffix ?? randomBytes(8).toString("hex");
+  const agentName = `poetic-steering-${suffix}`;
+  const config = {
+    $schema: "https://opencode.ai/config.json",
+    agent: {
+      [agentName]: {
+        description: "Poetic runtime steering (transient, per-invocation).",
+        mode: "primary",
+        prompt: payload.systemChannel
+      }
+    }
+  };
+  return {
+    agentName,
+    configContent: JSON.stringify(config)
+  };
+}
+function applyOpencodePreambleFallback(payload, userPrompt) {
+  if (!payload.systemChannel) return userPrompt;
+  return `${payload.systemChannel}
+
+${userPrompt}`;
+}
+
+// src/core/providers/opencode/capabilities.ts
+var capabilityCache = null;
+var capabilityCacheValidatedAt = 0;
+var capabilityProbePromise = null;
+var capabilityCacheKey = null;
+function hasHelpTextShape(text) {
+  return /\b(usage|options|positionals)\b/i.test(text);
+}
+function hasCliFlag(text, longFlag) {
+  const escaped = longFlag.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return new RegExp(`(^|[\\s,])${escaped}(?=$|[\\s,])`).test(text);
+}
+function defaultCapabilities() {
+  return {
+    supportsFormatJson: false,
+    supportsTitle: false,
+    supportsVariant: false,
+    supportsFile: false,
+    supportsAgent: false,
+    supportsDir: false,
+    supportsDangerouslySkipPermissions: false,
+    supportsPure: false
+  };
+}
+async function getOpencodeRunCapabilities(env) {
+  const now = Date.now();
+  if (capabilityProbePromise) {
+    return capabilityProbePromise;
+  }
+  capabilityProbePromise = (async () => {
+    const capabilities = defaultCapabilities();
+    try {
+      const { execa } = await import("execa");
+      const { command, prefixArgs } = resolveProviderCliCommand("opencode");
+      const mergedEnv = {
+        ...process.env,
+        ...env ?? {}
+      };
+      const version = await execa(command, [...prefixArgs, "--version"], {
+        reject: false,
+        timeout: 5e3,
+        env: mergedEnv
+      });
+      const cacheKey = `${command} ${prefixArgs.join(" ")}::${(version.stdout ?? "").trim()}`;
+      const cliVersion = normalizeProviderCliVersion(version.stdout);
+      if (version.exitCode === 0 && cliVersion) {
+        capabilities.cliVersion = cliVersion;
+      }
+      if (capabilityCache && capabilityCacheValidatedAt && capabilityCacheKey === cacheKey && now - capabilityCacheValidatedAt < 6e4) {
+        return capabilityCache;
+      }
+      const help = await execa(command, [...prefixArgs, "run", "--help"], {
+        reject: false,
+        timeout: 5e3,
+        env: mergedEnv
+      });
+      const text = `${help.stdout ?? ""}
+${help.stderr ?? ""}`;
+      if (hasHelpTextShape(text)) {
+        capabilities.supportsFormatJson = hasCliFlag(text, "--format") && /\bjson\b/.test(text);
+        capabilities.supportsTitle = hasCliFlag(text, "--title");
+        capabilities.supportsVariant = hasCliFlag(text, "--variant");
+        capabilities.supportsFile = hasCliFlag(text, "--file");
+        capabilities.supportsAgent = hasCliFlag(text, "--agent");
+        capabilities.supportsDir = hasCliFlag(text, "--dir");
+        capabilities.supportsDangerouslySkipPermissions = hasCliFlag(
+          text,
+          "--dangerously-skip-permissions"
+        );
+        capabilities.supportsPure = hasCliFlag(text, "--pure");
+      }
+      capabilityCacheKey = cacheKey;
+    } catch (error) {
+      debugLog(
+        `[OpenCode] CLI capability probe failed; falling back to conservative flags. Error: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+    capabilityCache = capabilities;
+    capabilityCacheValidatedAt = Date.now();
+    return capabilities;
+  })();
+  try {
+    return await capabilityProbePromise;
+  } finally {
+    capabilityProbePromise = null;
+  }
+}
+
+// src/core/providers/opencode/error-parser.ts
+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/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 Poetic 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("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 combined = `${message}
+${stderr}
+${stdout}`.toLowerCase();
+  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 }
+    };
+  }
+  if (/\brate limit\b|\btoo many requests\b|\bquota exceeded\b|resource_exhausted/i.test(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 (/service unavailable|temporarily unavailable|server is overloaded|overloaded/i.test(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 (/maximum context length|context window|token limit|too many tokens|prompt too long|input is too long|request exceeds/i.test(
+    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 Poetic configuration bug.",
+      original: { message, stderr, stdout, exitCode, reason }
+    };
+  }
+  return {
+    type: "unknown",
+    retryable: false,
+    userMessage: "OpenCode execution failed with an unknown error.",
+    original: { message, stderr, stdout, exitCode, reason }
+  };
+}
+
+// src/core/providers/opencode/log-diagnostics.ts
+import * as fs from "fs/promises";
+import * as path 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 = path.join(dataHome, "opencode", "log", "opencode.log");
+  try {
+    const stat2 = await fs.stat(logPath);
+    return { path: logPath, offset: stat2.size };
+  } catch {
+    return { path: logPath, offset: 0 };
+  }
+}
+async function readOpencodeLogErrorsSince(checkpoint) {
+  let handle;
+  try {
+    const stat2 = await fs.stat(checkpoint.path);
+    if (stat2.size <= checkpoint.offset) return [];
+    const start = Math.max(checkpoint.offset, stat2.size - MAX_OPENCODE_LOG_BYTES);
+    const length = stat2.size - start;
+    const buffer = Buffer.alloc(length);
+    handle = await fs.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 strategy = (options.strategy ?? "conservative").trim().toLowerCase();
+  const composed = applyWorkspaceMode(prompt, {
+    mode: effectiveMode,
+    provider: "OPENCODE",
+    executionIntent: options.executionIntent ?? "mixed",
+    strategy: strategy === "innovative" ? "innovative" : strategy === "hybrid" ? "hybrid" : "conservative",
+    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/reasoning-variant.ts
+function normalizeOpencodeReasoningEffort(value) {
+  if (typeof value !== "string") return void 0;
+  const normalized = value.trim().toLowerCase().replace(/[_\s]/g, "-");
+  if (normalized === "low" || normalized === "medium" || normalized === "high") {
+    return normalized;
+  }
+  if (normalized === "xhigh" || normalized === "x-high" || normalized === "extra-high") {
+    return "xhigh";
+  }
+  if (normalized === "max") return "max";
+  return void 0;
+}
+function mapReasoningEffortToOpencodeVariant(effort) {
+  return resolveReasoningEffort("opencode", effort, false).variantMapping;
+}
+
+// src/core/providers/opencode/execution/runner.ts
+var OPENCODE_CIRCUIT_BREAKER_OPTIONS = DEFAULT_PROVIDER_CIRCUIT_BREAKER_OPTIONS;
+var OPENCODE_DEADLINE_SAFETY_BUFFER_MS = 5e3;
+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) {
+  if (deadlineMs == null) {
+    return timeoutMs;
+  }
+  const remainingMs = deadlineMs - Date.now() - OPENCODE_DEADLINE_SAFETY_BUFFER_MS;
+  if (remainingMs <= 0) {
+    throw new ProviderExecutionError("OpenCode deadline exceeded before attempt start.", {
+      providerName: metadata.id,
+      retryable: false,
+      reason: "deadline_exhausted"
+    });
+  }
+  return Math.max(1, Math.min(timeoutMs, remainingMs));
+}
+function resolveOpencodeIdleTimeout(requested, providerDefault, allowAboveProviderDefault) {
+  if (requested == null) return providerDefault;
+  if (providerDefault == null || allowAboveProviderDefault) return requested;
+  return Math.min(requested, providerDefault);
+}
+function resolveTaskAwareVariant(prompt) {
+  const taskType = detectTaskType(prompt);
+  const generationSettings = resolveSettings(taskType, "opencode");
+  const taskEffort = normalizeOpencodeReasoningEffort(generationSettings.reasoningEffort);
+  if (!taskEffort) {
+    return void 0;
+  }
+  const resolution = resolveReasoningEffort("opencode", taskEffort, false);
+  logReasoningEffortResolution(resolution, "opencode");
+  if (resolution.variantMapping) {
+    debugLog(
+      `[OpenCode] Task-aware variant selected: ${resolution.variantMapping} (taskType=${taskType})`
+    );
+  }
+  return resolution.variantMapping;
+}
+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 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 resolveUserOpencodeDataHome() {
+  return process.env.XDG_DATA_HOME?.trim() || path2.join(homedir(), ".local", "share");
+}
+function resolveUserOpencodeConfigHome() {
+  return process.env.XDG_CONFIG_HOME?.trim() || path2.join(homedir(), ".config");
+}
+var OPENCODE_USER_CONFIG_FILES = ["opencode.json", "config.json"];
+var OPENCODE_USER_CONFIG_DIRS = ["agent"];
+async function seedOpencodeUserConfig(sourceConfigHome, destinationConfigHome) {
+  if (path2.resolve(sourceConfigHome) === path2.resolve(destinationConfigHome)) {
+    return;
+  }
+  const sourceDir = path2.join(sourceConfigHome, "opencode");
+  const destinationDir = path2.join(destinationConfigHome, "opencode");
+  try {
+    await fs2.access(sourceDir);
+  } catch {
+    return;
+  }
+  try {
+    await fs2.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 = path2.join(sourceDir, fileName);
+    const dst = path2.join(destinationDir, fileName);
+    try {
+      await fs2.copyFile(src, 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 OPENCODE_USER_CONFIG_DIRS) {
+    const src = path2.join(sourceDir, dirName);
+    const dst = path2.join(destinationDir, dirName);
+    try {
+      await fs2.cp(src, dst, { recursive: true, errorOnExist: false, force: 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)}`
+        );
+      }
+    }
+  }
+}
+async function seedOpencodeCredentials(sourceDataHome, destinationDataHome) {
+  if (path2.resolve(sourceDataHome) === path2.resolve(destinationDataHome)) {
+    return;
+  }
+  const sourceAuthPath = path2.join(sourceDataHome, "opencode", "auth.json");
+  const destinationDir = path2.join(destinationDataHome, "opencode");
+  const destinationAuthPath = path2.join(destinationDir, "auth.json");
+  try {
+    await fs2.mkdir(destinationDir, { recursive: true });
+    await fs2.copyFile(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)}`
+      );
+    }
+  }
+}
+async function resolveOpencodeDataHome(env) {
+  const caller = resolveCallerOwnedPath(
+    env?.XDG_DATA_HOME,
+    readOpencodeRuntimeEnv(env, POETIC_OPENCODE_XDG_DATA_HOME)
+  );
+  if (caller) return { dataHome: caller.path };
+  const dataHome = await mkPoeticTempDir("opencode-xdg");
+  await seedOpencodeCredentials(resolveUserOpencodeDataHome(), dataHome);
+  const owned = markRunOwnedRoot(dataHome);
+  return {
+    dataHome,
+    cleanup: async () => {
+      await removeAndVerifyRunOwnedRoot(owned, { role: "opencode-xdg-data" });
+    }
+  };
+}
+async function resolveOpencodeStateHome(env) {
+  const caller = resolveCallerOwnedPath(
+    env?.XDG_STATE_HOME,
+    readOpencodeRuntimeEnv(env, POETIC_OPENCODE_XDG_STATE_HOME)
+  );
+  if (caller) return { stateHome: caller.path };
+  const stateHome = await mkPoeticTempDir("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, POETIC_OPENCODE_XDG_CONFIG_HOME)
+  );
+  if (caller) return { configHome: caller.path };
+  const configHome = await mkPoeticTempDir("opencode-config");
+  const owned = markRunOwnedRoot(configHome);
+  try {
+    await seedOpencodeUserConfig(resolveUserOpencodeConfigHome(), configHome);
+  } 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, POETIC_OPENCODE_XDG_CACHE_HOME)
+  );
+  if (caller) return { cacheHome: caller.path };
+  const cacheHome = await mkPoeticTempDir("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 fs2.readFile(path2.join(dataHome, "opencode", "auth.json"), "utf8");
+    return /"openrouter"\s*:/.test(authJson);
+  } catch {
+    return false;
+  }
+}
+async function resolveOpencodeSessionFromDb(workingDir, dataHome) {
+  try {
+    const dbPath = path2.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);
+      return {
+        sessionId: session.id,
+        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 = path2.resolve(workingDir);
+  for (const candidate of candidates) {
+    const resolved = path2.isAbsolute(candidate) ? candidate : path2.resolve(workingDir, candidate);
+    if (resolved !== root && !resolved.startsWith(root + path2.sep)) {
+      throw new Error(`OpenCode attachment must be within working directory: ${candidate}`);
+    }
+    try {
+      await fs2.access(resolved);
+      deduped.add(resolved);
+    } catch {
+      debugLog(`[OpenCode] Skipping missing attachment path: ${candidate}`);
+    }
+  }
+  return [...deduped];
+}
+async function writePromptAttachment(prompt) {
+  const dir = await mkPoeticTempDir("opencode-prompt");
+  const filePath = path2.join(dir, "prompt.md");
+  try {
+    await fs2.writeFile(filePath, prompt, "utf8");
+  } catch (error) {
+    await fs2.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 fs2.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,
+    strategy,
+    executionIntent
+  } = options;
+  const mockProvidersEnabled = env?.POETIC_MOCK_PROVIDERS === "1" || process.env.NODE_ENV !== "test" && readEnv(POETIC_MOCK_PROVIDERS).value === "1";
+  if (mockProvidersEnabled) {
+    if (process.env.NODE_ENV === "production" && !readEnv(POETIC_ALLOW_MOCK_PROVIDERS).value) {
+      throw new Error(
+        "POETIC_MOCK_PROVIDERS is enabled in production without explicit allow; aborting to prevent synthetic responses."
+      );
+    }
+    emitTelemetryFallbackWarning(
+      "POETIC_MOCK_PROVIDERS enabled for OpenCode; responses are synthetic"
+    );
+    return runMockNative({
+      ...options,
+      provider: metadata.id
+    });
+  }
+  await acquireRateLimitToken(metadata.id, model);
+  const baselineHead = await getGitHead(workingDir);
+  const baselineStatusPaths = await getGitStatusPaths(workingDir).catch(() => /* @__PURE__ */ new Set());
+  const timeout = resolveProviderTimeoutMs(metadata.id, options.timeout);
+  const { command, prefixArgs } = resolveProviderCliCommand(metadata.id);
+  const runtimeQuirks = getProviderRuntimeQuirks(metadata.id);
+  try {
+    await ensureOpencodeWarm({ command, prefixArgs, workingDir });
+  } catch (error) {
+    debugLog(
+      `[OpenCode] Warmup failed; continuing without warmup: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  const capabilities = await getOpencodeRunCapabilities(env);
+  const capabilityWarnings = [];
+  let effectiveModel = model;
+  if (model && options.modelExecutionPolicy !== "exact") {
+    const cachedModels = getCachedOpencodeModelIds();
+    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,
+    strategy,
+    promptMode: requestedWorkspaceMode,
+    projectRoot: workingDir
+  });
+  let adaptedPrompt = adaptation.adapted;
+  debugLog(formatAdaptations(adaptation));
+  const transientAgentEnabled = isOpencodeRuntimeEnvEnabled(env, POETIC_OPENCODE_TRANSIENT_AGENT);
+  const shouldApplyOpencodeSteering = adaptation.promptMode !== "passthrough" || transientAgentEnabled && capabilities.supportsAgent;
+  const opencodeSteeringPayload = shouldApplyOpencodeSteering ? buildOpencodeSteering({
+    guidance: {
+      strategy,
+      recentContext: options.recentContext,
+      subagents: Boolean(options.delegatedSubagents)
+    }
+  }) : void 0;
+  let steeringAgentName;
+  let steeringConfigContent;
+  if (opencodeSteeringPayload && capabilities.supportsAgent && transientAgentEnabled) {
+    try {
+      const plan = planOpencodeTransientAgent(opencodeSteeringPayload);
+      if (plan) {
+        steeringAgentName = plan.agentName;
+        steeringConfigContent = plan.configContent;
+      }
+    } catch (error) {
+      debugLog(
+        `[OpenCode] Transient steering-agent planning failed; preamble fallback is used only outside passthrough mode. Error: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  if (opencodeSteeringPayload && !steeringAgentName && adaptation.promptMode !== "passthrough") {
+    adaptedPrompt = applyOpencodePreambleFallback(opencodeSteeringPayload, adaptedPrompt);
+  }
+  const explicitEffort = normalizeOpencodeReasoningEffort(modelReasoningEffort) ?? normalizeOpencodeReasoningEffort(generationSettings?.reasoningEffort);
+  const effectiveVariant = explicitEffort ? mapReasoningEffortToOpencodeVariant(explicitEffort) : resolveTaskAwareVariant(prompt);
+  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 runError;
+  try {
+    opencodeDataHome = await resolveOpencodeDataHome(env);
+    opencodeStateHome = await resolveOpencodeStateHome(env);
+    opencodeConfigHome = await resolveOpencodeConfigHome(env);
+    opencodeCacheHome = await resolveOpencodeCacheHome(env);
+    debugLog(
+      `[OpenCode] Runtime directories: TMPDIR=${env?.TMPDIR ?? process.env.TMPDIR ?? tmpdir()} 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
+    };
+    if (steeringConfigContent) {
+      headlessEnv.OPENCODE_CONFIG_CONTENT = steeringConfigContent;
+    }
+    const childEnv = buildProviderExecutionEnv("opencode", { ...env ?? {}, ...headlessEnv });
+    const opencodeLogCheckpoint = await captureOpencodeLogCheckpoint(opencodeDataHome.dataHome);
+    const opencodeWorkspaceStateDir = path2.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"];
+    if (capabilities.supportsPure) {
+      args.push("--pure");
+    }
+    if (capabilities.supportsDir) {
+      args.push("--dir", workingDir);
+    }
+    if (steeringAgentName) {
+      args.push("--agent", steeringAgentName);
+    }
+    if (capabilities.supportsFormatJson) {
+      args.push("--format", "json");
+    }
+    if (capabilities.supportsTitle) {
+      args.push("--title", `Poetic (${metadata.id}) - ${path2.basename(workingDir)}`);
+    }
+    if (capabilities.supportsDangerouslySkipPermissions) {
+      args.push("--dangerously-skip-permissions");
+    }
+    if (effectiveModel && effectiveModel !== "auto") {
+      args.push("--model", effectiveModel);
+    }
+    if (effectiveVariant) {
+      if (capabilities.supportsVariant) {
+        args.push("--variant", effectiveVariant);
+      } 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);
+      args.push("--");
+      args.push("Read the attached prompt file and complete the task exactly as specified.");
+    } else {
+      args.push("--");
+      args.push(adaptedPrompt);
+    }
+    const fastRetry = process.env.NODE_ENV === "test" || process.env.VITEST === "true" || readEnv(POETIC_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;
+    try {
+      retryResult = await executeWithResilience(
+        async () => {
+          const bootstrapAttemptStartState = await captureRetryWorktreeState(workingDir);
+          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 disables the provider's tool-approval layer
+              // even when capability discovery omits the equivalent argv flag.
+              // Carry that fact to the final post-wrap proof-pair guard.
+              providerInternalSandboxBypass: "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: bootstrapAttemptStartState,
+                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(),
+                inventoryAgeMs: getOpencodeModelsCacheInfo().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(),
+            inventoryAgeMs: getOpencodeModelsCacheInfo().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;
+      const logErrors = await readOpencodeLogErrorsSince(opencodeLogCheckpoint);
+      const partialFilesModified = await detectGitChangedFiles(workingDir, {
+        baselineHead,
+        baselineStatusPaths
+      }).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,
+        modelId: model ?? "auto",
+        timeRequestSentMs: invocationTimeRequestSentMs,
+        timeFirstTokenMs: invocationTimeFirstTokenMs,
+        timeLastTokenMs: Date.now(),
+        status: "error",
+        errorCode: exitCode !== null ? `EXIT_${exitCode}` : "UNKNOWN",
+        env
+      });
+      const errMsg = error instanceof Error ? error.message : String(error);
+      const isHardFailure = errMsg.includes("auth") || errMsg.includes("unauthorized") || errMsg.includes("not_found") || errMsg.includes("aborted");
+      recordProviderRunFailure("opencode", {
+        severity: isHardFailure ? "hard" : "normal",
+        phase: inferProviderFailurePhase({
+          error,
+          exitCode
+        })
+      });
+      throw error;
+    }
+    const result = retryResult.result;
+    const {
+      text: parsedText,
+      tokenUsage,
+      totalCostUsd,
+      resolvedModel,
+      agentUsed,
+      subAgentInvocations,
+      subAgentTypes,
+      structuredEventCount,
+      errorEvents
+    } = parseOpencodeProviderOutput(result.stdout, result.stderr);
+    const opencodeSession = await resolveOpencodeSessionFromDb(
+      workingDir,
+      opencodeDataHome.dataHome
+    );
+    const effectiveResolvedModel = resolvedModel ?? opencodeSession.resolvedModel;
+    const opencodeLogErrors = await readOpencodeLogErrorsSince(opencodeLogCheckpoint);
+    let filesModified;
+    try {
+      filesModified = await detectGitChangedFiles(workingDir, {
+        baselineHead,
+        baselineStatusPaths
+      });
+    } catch {
+    }
+    const rawStdoutNonEmpty = result.stdout.trim().length > 0;
+    const usefulRawOutput = extractUsefulOpencodeRawOutput(result.stdout, result.stderr);
+    const reportedToolFailure = hasOpencodeReportedToolFailure(usefulRawOutput);
+    const reportedProviderError = (errorEvents?.length ?? 0) > 0;
+    const reportedContextLengthExhaustion = errorEvents?.some((event) => event.errorType === "length") === true;
+    const hasMeaningfulDelivery = parsedText.trim().length > 0 || (filesModified?.length ?? 0) > 0;
+    if (hasMeaningfulDelivery && opencodeLivenessPhasesMs.firstUsefulAction === void 0) {
+      opencodeLivenessPhasesMs.firstUsefulAction = Date.now() - opencodeLivenessStartedAtMs;
+    }
+    const noContentSuccess = result.exitCode === 0 && parsedText.trim().length === 0 && usefulRawOutput.length === 0 && (filesModified?.length ?? 0) === 0;
+    const effectiveExitCode = noContentSuccess || reportedToolFailure || reportedContextLengthExhaustion || 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,
+      modelId: effectiveResolvedModel ?? model ?? "auto",
+      timeRequestSentMs: invocationTimeRequestSentMs,
+      timeFirstTokenMs: invocationTimeFirstTokenMs,
+      timeLastTokenMs: Date.now(),
+      tokensIn: tokenUsage?.inputTokens,
+      tokensOut: tokenUsage?.outputTokens,
+      status: effectiveExitCode === 0 ? "success" : "error",
+      errorCode: effectiveExitCode !== 0 ? `EXIT_${effectiveExitCode}` : null,
+      env
+    });
+    if (effectiveExitCode !== 0 && rawStdoutNonEmpty && structuredEventCount === 0 && (filesModified?.length ?? 0) === 0) {
+      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 (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((parsedText || usefulRawOutput).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()].filter(Boolean).join("\n");
+    const finalResult = {
+      stdout: parsedText || usefulRawOutput || result.stdout,
+      stderr: finalStderr,
+      exitCode: effectiveExitCode,
+      commandPath: command,
+      argvRedacted,
+      stdoutTail: providerOutputTail(result.stdout),
+      stderrTail: providerOutputTail(finalStderr),
+      providerDiagnostics: {
+        finalAnswerPresent: Boolean(parsedText.trim().length || usefulRawOutput.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 ? "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,
+      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?.(),
+      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 {
+  runOpencodeNative,
+  seedOpencodeCredentials,
+  seedOpencodeUserConfig
+};
+//# sourceMappingURL=runner-HHH7ZN2Z.js.map