@poetic-ai/poetic 1.42.1-bootstrap.0

package/dist/runner-2YPKOJ6A.js

@@ -0,0 +1,1092 @@
+import {
+  resolveGrokReasoningEffortLookupModel
+} from "./chunk-AHWAZ2MU.js";
+import {
+  GROK_CLI_PROBE_TIMEOUT_MS,
+  GROK_DONT_ASK_MIN_VERSION,
+  GROK_READ_ONLY_ALLOW_RULES,
+  allowsGrokBrowserAuth,
+  buildGrokArgv,
+  capturedStdoutHasTerminalEnvelope,
+  createGrokCliChildEnv,
+  createGrokTmuxCompletionSignal,
+  formatGrokStreamLineForDisplay,
+  grokCliSupportsDontAsk,
+  grokResolvedHasLockedReadOnlyPosture,
+  hasGrokHeadlessApiKey,
+  isStderrOnlyNoise,
+  metadata,
+  parseGrokOutput
+} from "./chunk-Y34DUC4A.js";
+import "./chunk-MYLH2S4G.js";
+import {
+  runMockNative
+} from "./chunk-P47VN5F4.js";
+import {
+  DEFAULT_PROVIDER_CIRCUIT_BREAKER_OPTIONS,
+  RetryBudget,
+  assertWorkspaceRetryIsSafe,
+  captureWorkspaceRetryState,
+  executeWithResilience,
+  recordInvocationTiming,
+  reportTransportDecision,
+  resolveProviderTimeoutMs,
+  selectProviderExecutor
+} from "./chunk-R2ZYWNW3.js";
+import {
+  detectGitChangedFiles,
+  getGitStatusPaths
+} from "./chunk-QJYIHVXT.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 {
+  resolveConfiguredProviderExecutionTransport
+} from "./chunk-IZZK3H6I.js";
+import "./chunk-25QL3M3L.js";
+import "./chunk-VBNCKCCI.js";
+import "./chunk-SZ7DL357.js";
+import "./chunk-7DNSNKJV.js";
+import {
+  resolveProviderStreamingEnabled
+} from "./chunk-HIO33P3G.js";
+import "./chunk-APV6MK5E.js";
+import "./chunk-ZYG7GGKO.js";
+import {
+  TMUX_COMPLETION_SIGNAL_GRACE_MS,
+  composeRawChunkObservers,
+  executeProviderCommand,
+  isNonEmptyRawChunk,
+  providerOutputTail,
+  redactProviderArgv
+} from "./chunk-SQZRPY23.js";
+import "./chunk-E3NTPHEO.js";
+import "./chunk-4NXPXE62.js";
+import "./chunk-4VJITV4P.js";
+import "./chunk-GHHFDU2U.js";
+import {
+  authFailureEvidence,
+  isAuthFailureError,
+  recordAuthOutcome
+} from "./chunk-R6W23LKN.js";
+import "./chunk-UH3JJSHK.js";
+import "./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-T6VPI2XP.js";
+import "./chunk-3733QTI7.js";
+import "./chunk-J62KPGII.js";
+import "./chunk-XAONGNST.js";
+import "./chunk-GAFJEYLK.js";
+import "./chunk-H6G7QRMQ.js";
+import "./chunk-J6P3FWWW.js";
+import "./chunk-YWNAHW24.js";
+import "./chunk-IATQ7NBI.js";
+import "./chunk-BSE4R6XD.js";
+import {
+  applyWorkspaceMode,
+  resolveEffectiveMode
+} from "./chunk-KAT4RXUT.js";
+import "./chunk-JSWMRQYG.js";
+import "./chunk-XGYF2QMZ.js";
+import "./chunk-72YTZMAM.js";
+import "./chunk-S2VQCZO4.js";
+import "./chunk-WMPU2UOV.js";
+import "./chunk-JQD5VYKR.js";
+import "./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
+} from "./chunk-2AICM4P3.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-GNH3QGTL.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 {
+  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-4BIPZBT7.js";
+import "./chunk-7GDRQBQC.js";
+import "./chunk-PGSPX4SU.js";
+import "./chunk-AT4TNPWW.js";
+import "./chunk-GSGD5E4C.js";
+import "./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
+} from "./chunk-EJGCZGUF.js";
+import "./chunk-LPITVM7M.js";
+import {
+  POETIC_ALLOW_MOCK_PROVIDERS,
+  POETIC_GROK_TRANSPORT_WATCHDOG,
+  POETIC_MINIMAL_PROMPTS,
+  POETIC_MOCK_PROVIDERS,
+  POETIC_SKIP_GROK,
+  readEnv,
+  readRawEnv
+} from "./chunk-5DLKYTQX.js";
+import "./chunk-PZ5AY32C.js";
+
+// src/core/providers/grok/execution/runner.ts
+import { rm, writeFile } from "fs/promises";
+import path from "path";
+
+// src/core/providers/grok/prompt-adapter.ts
+function isMinimalPromptsEnabled() {
+  return readEnv(POETIC_MINIMAL_PROMPTS).value === true;
+}
+function resolveMode(options) {
+  if (isMinimalPromptsEnabled()) return "minimal";
+  return resolveEffectiveMode(
+    options.promptMode ?? null,
+    options.globalWorkspaceMode ?? null,
+    "grok"
+  );
+}
+function appendNativeSubagentGuidance(prompt, nativeSubagents) {
+  if (!nativeSubagents) {
+    return { prompt, applied: false };
+  }
+  const request = typeof nativeSubagents.count === "number" ? `Run ${nativeSubagents.count} native Grok subagents for this task.` : "Run a swarm of native Grok subagents for this task.";
+  const guidance = [
+    "",
+    "Provider-native subagents:",
+    request,
+    "Give the subagents disjoint responsibilities, ask them for concise findings or changes, then synthesize the final answer yourself.",
+    // Verified on grok 0.2.73: subagent count is not hard-capped, but only
+    // ~8 run simultaneously; extras queue and rate-limit retries increase.
+    "About 8 subagents run simultaneously; if you need more, launch them in waves of about 8 rather than all at once.",
+    "Do not run Poetic commands recursively."
+  ].join("\n");
+  return { prompt: `${prompt.trimEnd()}
+${guidance}`, applied: true };
+}
+function adaptPromptForGrok(prompt, options = {}) {
+  const mode = resolveMode(options);
+  const subagentResult = appendNativeSubagentGuidance(prompt, options.nativeSubagents);
+  const result = applyWorkspaceMode(subagentResult.prompt, {
+    mode,
+    provider: "GROK",
+    executionIntent: options.executionIntent ?? "code",
+    strategy: options.strategy ?? "conservative",
+    targetFiles: options.files,
+    projectRoot: options.projectRoot
+  });
+  const operations = [...result.operations];
+  if (subagentResult.applied) {
+    operations.push("Injected Grok native subagent request");
+  }
+  return {
+    original: prompt,
+    adapted: result.adapted,
+    mode: result.mode,
+    adaptations: operations,
+    promptFingerprint: result.adaptedHash,
+    finalPromptLength: result.lengths.adapted,
+    completionSignalVariant: result.completionSignalVariant
+  };
+}
+
+// src/core/providers/grok/transport-death-watchdog.ts
+import { StringDecoder } from "string_decoder";
+var TRANSPORT_CLOSE_PATTERN = /Transport channel closed, when Auth\(AuthorizationRequired\)/i;
+var TOOL_OUTPUT_ERROR_PATTERN = /tool[_\s-]?output[_\s-]?error/i;
+var DEFAULT_GROK_SPIRAL_TOOL_ERROR_THRESHOLD = 3;
+var DEFAULT_GROK_SPIRAL_POST_CLOSE_LINE_WINDOW = 15;
+function createGrokTransportDeathWatchdog(options) {
+  const threshold = Math.max(
+    1,
+    options.toolErrorThreshold ?? DEFAULT_GROK_SPIRAL_TOOL_ERROR_THRESHOLD
+  );
+  const postCloseLineWindow = Math.max(
+    threshold,
+    options.postCloseLineWindow ?? DEFAULT_GROK_SPIRAL_POST_CLOSE_LINE_WINDOW
+  );
+  let transportCloseCount = 0;
+  let postTransportToolErrorCount = 0;
+  let linesSinceTransportClose = 0;
+  let armed = false;
+  let tripped = false;
+  let pendingPartialLine = "";
+  let decoder = new StringDecoder("utf8");
+  const snapshot = () => ({
+    transportCloseCount,
+    postTransportToolErrorCount,
+    threshold
+  });
+  const observeLine = (line) => {
+    if (TRANSPORT_CLOSE_PATTERN.test(line)) {
+      transportCloseCount += 1;
+      armed = true;
+      postTransportToolErrorCount = 0;
+      linesSinceTransportClose = 0;
+      return;
+    }
+    if (!armed) return;
+    linesSinceTransportClose += 1;
+    if (TOOL_OUTPUT_ERROR_PATTERN.test(line)) {
+      postTransportToolErrorCount += 1;
+      if (postTransportToolErrorCount >= threshold) {
+        tripped = true;
+        options.onSpiralDetected(snapshot());
+        return;
+      }
+    }
+    if (linesSinceTransportClose >= postCloseLineWindow) {
+      armed = false;
+    }
+  };
+  const observeText = (text) => {
+    if (tripped || !text) return;
+    const segments = (pendingPartialLine + text).split(/\r?\n/);
+    pendingPartialLine = segments.pop() ?? "";
+    for (const segment of segments) {
+      const line = segment.trim();
+      if (!line) continue;
+      observeLine(line);
+      if (tripped) return;
+    }
+    const partial = pendingPartialLine.trim();
+    if (partial && (TRANSPORT_CLOSE_PATTERN.test(partial) || TOOL_OUTPUT_ERROR_PATTERN.test(partial))) {
+      pendingPartialLine = "";
+      observeLine(partial);
+    }
+  };
+  const observe = (chunk) => {
+    if (tripped || !isNonEmptyRawChunk(chunk)) return;
+    if (typeof chunk === "string") {
+      const held = decoder.end();
+      decoder = new StringDecoder("utf8");
+      observeText(held + chunk);
+      return;
+    }
+    const text = decoder.write(Buffer.from(chunk));
+    observeText(text);
+  };
+  return {
+    observe,
+    hasTripped: () => tripped,
+    snapshot
+  };
+}
+
+// src/core/providers/grok/execution/runner.ts
+function shouldStreamGrokOutput(outputFormat, env) {
+  if (outputFormat !== "streaming-json") return false;
+  return resolveProviderStreamingEnabled(env);
+}
+var GROK_DEADLINE_SAFETY_BUFFER_MS = 5e3;
+var GROK_AUTHORITATIVE_STDOUT_CEILING_BYTES = 32 * 1024 * 1024;
+function grokCategoryToRetryable(category) {
+  return category === "rate_limit" || category === "network";
+}
+function grokEditIntentRequiresMutation(options) {
+  if (options.allowEmptyResults === true) return false;
+  if (options.readOnlyWorkingDir === true) return false;
+  if (options.executionIntent === "analysis") return false;
+  return true;
+}
+function readGrokBuilderEnvString(env, key) {
+  const source = env ?? process.env;
+  const value = source[key];
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function grokDontAskUnsupportedForEditMessage() {
+  return [
+    "[Grok] permissionMode=dontAsk is not supported for edit/mixed execution.",
+    "ProviderRunOptions has no allowRules channel for a bounded edit allowlist;",
+    "applying read-only allows would deny Edit and fail mid-run.",
+    "Use readOnlyWorkingDir or executionIntent=analysis for auto dontAsk inspect/search,",
+    "or omit permissionMode / unset POETIC_GROK_PERMISSION_MODE for headless edit (default --always-approve),",
+    "or set permissionMode=bypassPermissions when policy permits."
+  ].join(" ");
+}
+function throwGrokDontAskUnsupportedForEdit() {
+  throw new ProviderExecutionError(grokDontAskUnsupportedForEditMessage(), {
+    providerName: metadata.id,
+    retryable: false,
+    reason: "unsupported_permission_mode"
+  });
+}
+function throwGrokUnsupportedLockedReadOnlyPosture(source) {
+  const sourceNote = source === "explicit-dontAsk" ? "permissionMode=dontAsk" : "semantic auto-readonly / analysis (readOnlyWorkingDir or executionIntent=analysis)";
+  throw new ProviderExecutionError(
+    [
+      `[Grok] ${sourceNote} requires Grok CLI >= ${GROK_DONT_ASK_MIN_VERSION}`,
+      "for the locked native read-only permission posture",
+      "(dontAsk + inspect/search allows + --tools/--disallowed-tools/--deny).",
+      "The installed CLI version does not support this posture; upgrade grok.",
+      source === "auto-readonly" ? "Poetic will not fall back to default permissions + --always-approve for semantic auto-readonly runs." : "Upgrade grok or omit permissionMode."
+    ].join(" "),
+    {
+      providerName: metadata.id,
+      retryable: false,
+      reason: "unsupported_permission_mode"
+    }
+  );
+}
+function resolveGrokPermissionArgvInput(options) {
+  const lockPermissionMode = options.isReadOnlyRun;
+  const explicit = options.permissionMode;
+  if (explicit === "dontAsk" && !options.isReadOnlyRun) {
+    throwGrokDontAskUnsupportedForEdit();
+  }
+  if (explicit) {
+    if (explicit === "dontAsk") {
+      if (!options.supportsDontAsk) {
+        throwGrokUnsupportedLockedReadOnlyPosture("explicit-dontAsk");
+      }
+      return {
+        permissionMode: "dontAsk",
+        allowRules: GROK_READ_ONLY_ALLOW_RULES,
+        lockPermissionMode: true,
+        lockReadOnlyPosture: true
+      };
+    }
+    return {
+      permissionMode: explicit,
+      lockPermissionMode
+    };
+  }
+  if (options.isReadOnlyRun) {
+    if (!options.supportsDontAsk) {
+      throwGrokUnsupportedLockedReadOnlyPosture("auto-readonly");
+    }
+    return {
+      permissionMode: "dontAsk",
+      allowRules: GROK_READ_ONLY_ALLOW_RULES,
+      lockPermissionMode: true,
+      lockReadOnlyPosture: true
+    };
+  }
+  return { lockPermissionMode };
+}
+function isTerminationReason(reason) {
+  if (!reason) return false;
+  return reason === "hard_timeout" || reason === "idle_timeout" || reason === "timeout" || reason === "abort" || reason === "signal" || reason.startsWith("signal_") || reason.startsWith("plm_");
+}
+function isTimeoutTerminationReason(reason) {
+  if (!reason) return false;
+  return reason === "hard_timeout" || reason === "idle_timeout" || reason === "timeout" || reason === "plm_timeout";
+}
+function grokCategoryToReason(category) {
+  switch (category) {
+    case "auth":
+      return "auth";
+    case "fs_permission_denied":
+      return "fs_permission_denied";
+    case "model_rejection":
+      return "model_rejection";
+    case "max_turns_exceeded":
+      return "max_turns_exceeded";
+    case "provider_transport_failure":
+      return "provider_transport_failure";
+    case "rate_limit":
+      return "rate_limit";
+    case "network":
+      return "network";
+    case "runtime":
+      return "runtime";
+    default:
+      return "unknown";
+  }
+}
+function trySalvageCompletedGrokOutput(error, outputFormatIsJson) {
+  if (!outputFormatIsJson || !(error instanceof ProviderExecutionError)) {
+    return void 0;
+  }
+  if (typeof error.stdout !== "string" || error.stdout.trim().length === 0) {
+    return void 0;
+  }
+  if (!capturedStdoutHasTerminalEnvelope(error.stdout)) {
+    return void 0;
+  }
+  if (parseGrokOutput(error.stdout, error.stderr ?? "", 0).type !== "success") {
+    return void 0;
+  }
+  return {
+    stdout: error.stdout,
+    stderr: error.stderr ?? "",
+    exitCode: 0
+  };
+}
+async function recordRunTiming(options) {
+  await recordInvocationTiming({
+    providerId: metadata.id,
+    modelId: options.resolvedModel ?? options.model ?? metadata.defaultModel ?? "default",
+    timeRequestSentMs: options.startMs,
+    timeFirstTokenMs: options.firstOutputMs ?? null,
+    timeLastTokenMs: options.endMs,
+    tokensIn: options.tokensIn ?? null,
+    tokensOut: options.tokensOut ?? null,
+    status: options.status,
+    errorCode: options.errorCode ?? null,
+    env: options.env
+  });
+}
+function shouldSkipGrok() {
+  const value = readEnv(POETIC_SKIP_GROK).value;
+  return typeof value === "string" && value.trim().length > 0 && value !== "0";
+}
+function areMockProvidersAllowed(env) {
+  const raw = env?.POETIC_ALLOW_MOCK_PROVIDERS;
+  if (raw !== void 0) {
+    return !["", "0", "false", "no", "off"].includes(raw.trim().toLowerCase());
+  }
+  return readEnv(POETIC_ALLOW_MOCK_PROVIDERS).value === true;
+}
+function isGrokTransportWatchdogDisabled(env) {
+  const raw = env ? env.POETIC_GROK_TRANSPORT_WATCHDOG : readRawEnv(POETIC_GROK_TRANSPORT_WATCHDOG);
+  return typeof raw === "string" && raw.trim() === "0";
+}
+function combineAbortSignals(outer, inner) {
+  if (!outer) return inner;
+  if (!inner) return outer;
+  const anyFn = AbortSignal.any;
+  if (typeof anyFn === "function") {
+    return anyFn([outer, inner]);
+  }
+  const controller = new AbortController();
+  const onAbort = () => controller.abort();
+  if (outer.aborted || inner.aborted) {
+    controller.abort();
+  } else {
+    outer.addEventListener("abort", onAbort, { once: true });
+    inner.addEventListener("abort", onAbort, { once: true });
+  }
+  return controller.signal;
+}
+function recordGrokAuthOutcomeBestEffort(result, evidence, env) {
+  void recordAuthOutcome(metadata.id, result, evidence, { env }).catch(() => {
+  });
+}
+function attachGrokDiagnosticsToParsedError(parsedError, grokDiagnostics) {
+  if (parsedError && typeof parsedError === "object" && !Array.isArray(parsedError)) {
+    return {
+      ...parsedError,
+      grokDiagnostics
+    };
+  }
+  return {
+    type: "grok_automation_diagnostics",
+    grokDiagnostics
+  };
+}
+function withGrokDiagnosticsForExecutionError(error, grokDiagnostics) {
+  return new ProviderExecutionError(error.message, {
+    providerName: metadata.id,
+    retryable: error.retryable,
+    exitCode: error.exitCode,
+    statusCode: error.statusCode,
+    reason: error.reason,
+    idleTerminated: error.idleTerminated,
+    signal: error.signal,
+    terminationSource: error.terminationSource,
+    stdout: error.stdout,
+    stderr: error.stderr,
+    // The public fields above may already be truncated, and a stream size must
+    // never be re-derived from a truncated string. Forward the structured sizes.
+    streamBytes: { stdout: error.stdoutBytes, stderr: error.stderrBytes },
+    cause: error.cause,
+    parsedError: attachGrokDiagnosticsToParsedError(error.parsedError, {
+      ...grokDiagnostics,
+      failureStage: grokDiagnostics.failureStage ?? "task_execution"
+    })
+  });
+}
+async function writePromptToTempFile(prompt) {
+  const dir = await mkPoeticTempDir("grok");
+  const file = path.join(dir, "prompt.txt");
+  await writeFile(file, prompt, "utf8");
+  const cleanup = async () => {
+    try {
+      await rm(dir, { recursive: true, force: true });
+    } catch {
+    }
+  };
+  return { file, cleanup };
+}
+async function probeGrokCliVersionRaw(env) {
+  const { execa } = await import("execa");
+  const { command, prefixArgs } = resolveProviderCliCommand(metadata.id);
+  const result = await execa(command, [...prefixArgs, "--version"], {
+    reject: false,
+    timeout: GROK_CLI_PROBE_TIMEOUT_MS,
+    stdio: "pipe",
+    env,
+    extendEnv: true
+  });
+  if (result.exitCode !== 0) {
+    throw new Error(`grok --version exited ${result.exitCode}`);
+  }
+  return result.stdout ?? "";
+}
+async function runGrokNative(options) {
+  if (shouldSkipGrok()) {
+    const stderr = "Grok provider skipped via POETIC_SKIP_GROK";
+    return {
+      stdout: "",
+      stderr,
+      exitCode: 1,
+      skipped: true,
+      skipReason: "POETIC_SKIP_GROK",
+      commandPath: metadata.id,
+      argvRedacted: [],
+      stdoutTail: "",
+      stderrTail: providerOutputTail(stderr)
+    };
+  }
+  const mockProvidersEnabled = options.env?.POETIC_MOCK_PROVIDERS === "1" || readEnv(POETIC_MOCK_PROVIDERS).value === "1";
+  if (mockProvidersEnabled) {
+    emitTelemetryFallbackWarning("POETIC_MOCK_PROVIDERS enabled for Grok; responses are synthetic");
+    if (process.env.NODE_ENV === "production" && !areMockProvidersAllowed(options.env)) {
+      throw new Error(
+        "POETIC_MOCK_PROVIDERS is enabled in production without explicit allow; aborting to prevent synthetic responses."
+      );
+    }
+    return runMockNative({
+      ...options,
+      provider: metadata.id
+    });
+  }
+  const resolvedTimeoutMs = resolveProviderTimeoutMs(metadata.id, options.timeout);
+  await acquireRateLimitToken(metadata.id, options.model);
+  const { command, prefixArgs } = resolveProviderCliCommand(metadata.id);
+  const effectiveEnv = createGrokCliChildEnv(options.env);
+  const hasHeadlessApiKey = hasGrokHeadlessApiKey(effectiveEnv);
+  const allowsBrowserAuth = allowsGrokBrowserAuth(effectiveEnv);
+  const grokDiagnostics = {
+    hasHeadlessApiKey,
+    allowsBrowserAuth,
+    authCache: "not_checked",
+    authPath: hasHeadlessApiKey ? "api_key" : void 0
+  };
+  grokDiagnostics.authPath = hasHeadlessApiKey ? "api_key" : allowsBrowserAuth ? "browser_auth_probe" : "cli_auth_file_probe";
+  const effortLookupModel = options.modelReasoningEffort ? await resolveGrokReasoningEffortLookupModel(options.model) : options.model;
+  const reasoningResolution = options.modelReasoningEffort ? resolveReasoningEffort(metadata.id, options.modelReasoningEffort, true, effortLookupModel) : void 0;
+  if (reasoningResolution) {
+    logReasoningEffortResolution(reasoningResolution, metadata.id);
+  }
+  const workspaceModeRequested = options.workspaceMode ?? options.promptMode;
+  const adaptation = adaptPromptForGrok(options.prompt, {
+    executionIntent: options.executionIntent,
+    files: options.files,
+    strategy: options.strategy,
+    promptMode: workspaceModeRequested,
+    nativeSubagents: options.nativeSubagents,
+    projectRoot: options.workingDir
+  });
+  const workspaceModeApplied = adaptation.mode;
+  const baselineStatusPaths = await getGitStatusPaths(options.workingDir).catch(
+    () => /* @__PURE__ */ new Set()
+  );
+  const { file: promptFile, cleanup } = await writePromptToTempFile(adaptation.adapted);
+  let executionStartMs;
+  let firstOutputMs;
+  let mutationPolicyBoundary;
+  try {
+    const isReadOnlyRun = options.readOnlyWorkingDir === true || options.executionIntent === "analysis";
+    const envPermissionMode = readGrokBuilderEnvString(options.env, "POETIC_GROK_PERMISSION_MODE");
+    const mayUseDontAsk = options.permissionMode === "dontAsk" || envPermissionMode === "dontAsk" || isReadOnlyRun;
+    const supportsDontAsk = mayUseDontAsk ? await grokCliSupportsDontAsk(() => probeGrokCliVersionRaw(options.env)) : false;
+    const permissionInput = resolveGrokPermissionArgvInput({
+      permissionMode: options.permissionMode,
+      isReadOnlyRun,
+      supportsDontAsk
+    });
+    const grokReasoningEffort = reasoningResolution?.nativeParam === "max" ? void 0 : reasoningResolution?.nativeParam;
+    const { args, resolved } = buildGrokArgv({
+      promptFile,
+      model: options.model,
+      modelReasoningEffort: grokReasoningEffort,
+      env: options.env,
+      resumeSessionId: options.resumeSessionId,
+      // Version-gate only when dontAsk is in play; omit otherwise so non-dontAsk
+      // modes are unaffected by probe failures.
+      ...mayUseDontAsk ? { supportsDontAsk } : {},
+      ...permissionInput
+    });
+    const grokPlainOutputForcesHeadless = resolved.outputFormat === "plain" ? "grok plain output has no JSON terminal envelope for tmux-exec completion; using headless" : void 0;
+    if (!isReadOnlyRun && resolved.permissionMode === "dontAsk") {
+      throwGrokDontAskUnsupportedForEdit();
+    }
+    if (grokEditIntentRequiresMutation(options) && !resolved.alwaysApprove && resolved.permissionMode === "default") {
+      throw new ProviderExecutionError(
+        [
+          "[Grok] Edit run cannot proceed with auto-approve disabled.",
+          "Headless edit tool use requires --always-approve (default) or --permission-mode bypassPermissions.",
+          "Unset POETIC_GROK_AUTO_APPROVE / POETIC_GROK_ALWAYS_APPROVE, or set an explicit safe permission mode."
+        ].join(" "),
+        {
+          providerName: metadata.id,
+          retryable: false,
+          reason: "auto_approve_disabled",
+          parsedError: attachGrokDiagnosticsToParsedError(
+            {
+              type: "grok_auto_approve_disabled",
+              message: "Edit run with auto-approve disabled",
+              permissionMode: resolved.permissionMode
+            },
+            { ...grokDiagnostics, failureStage: "pre_execution_probe" }
+          )
+        }
+      );
+    }
+    if (resolved.alwaysApprove) {
+      mutationPolicyBoundary = requireActivePolicyBoundary(
+        "Grok",
+        "Grok automation bypass (--always-approve)",
+        metadata.id,
+        { env: options.env }
+      );
+    }
+    const hasLockedNativeReadOnlyPosture = grokResolvedHasLockedReadOnlyPosture(resolved);
+    if (resolved.permissionMode === "bypassPermissions" || resolved.permissionMode === "acceptEdits" || resolved.permissionMode === "auto" || resolved.permissionMode === "dontAsk" && !hasLockedNativeReadOnlyPosture) {
+      mutationPolicyBoundary = requireActivePolicyBoundary(
+        "Grok",
+        `Grok permission bypass (--permission-mode ${resolved.permissionMode})`,
+        metadata.id,
+        { env: options.env }
+      );
+    }
+    const finalArgs = [...prefixArgs, ...args];
+    const argvRedacted = redactProviderArgv(finalArgs);
+    const grokStreamOutput = shouldStreamGrokOutput(resolved.outputFormat, options.env);
+    const watchdogEnabled = !isGrokTransportWatchdogDisabled(options.env);
+    const requestedExecutionTransport = options.executionTransport ?? (options.nativeSubagents ? "tmux-exec" : void 0);
+    const { execute: executeGrokCommand } = await selectProviderExecutor({
+      provider: metadata.id,
+      requested: requestedExecutionTransport,
+      configured: resolveConfiguredProviderExecutionTransport(metadata.id, options.workingDir).value,
+      env: options.env,
+      executionIntent: options.executionIntent,
+      readOnlyWorkingDir: options.readOnlyWorkingDir,
+      forceHeadlessReason: grokPlainOutputForcesHeadless,
+      headless: executeProviderCommand,
+      onDecision: (decision) => reportTransportDecision(metadata.id, decision, debugLog)
+    });
+    const outputFormatIsJson = resolved.outputFormat === "json" || resolved.outputFormat === "streaming-json";
+    const wantsCompletionSignal = outputFormatIsJson;
+    executionStartMs = Date.now();
+    const retryBudget = options.retryBudget ?? new RetryBudget({ maxTotalAttempts: 6 });
+    const retryResult = await executeWithResilience(
+      async () => {
+        const attemptStartState = await captureWorkspaceRetryState(options.workingDir);
+        let executionTimeoutMs = resolvedTimeoutMs;
+        if (options.deadlineMs != null) {
+          const remaining = options.deadlineMs - Date.now() - GROK_DEADLINE_SAFETY_BUFFER_MS;
+          if (remaining <= 0) {
+            throw new ProviderExecutionError("Grok deadline exceeded before attempt start.", {
+              providerName: metadata.id,
+              retryable: false,
+              reason: "deadline_exhausted"
+            });
+          }
+          executionTimeoutMs = Math.max(1, Math.min(resolvedTimeoutMs, remaining));
+        }
+        firstOutputMs = void 0;
+        let spiralDiagnostics;
+        const watchdogController = new AbortController();
+        const watchdog = watchdogEnabled ? createGrokTransportDeathWatchdog({
+          onSpiralDetected: (diagnostics) => {
+            spiralDiagnostics = diagnostics;
+            watchdogController.abort();
+          }
+        }) : void 0;
+        const combinedAbortSignal = combineAbortSignals(
+          options.abortSignal,
+          watchdog ? watchdogController.signal : void 0
+        );
+        const completionSignal = wantsCompletionSignal ? createGrokTmuxCompletionSignal() : void 0;
+        const authoritativeStdoutParts = [];
+        let authoritativeStdoutBytes = 0;
+        let authoritativeStdoutOverflow = false;
+        const onStdoutChunk = (chunk) => {
+          if (authoritativeStdoutOverflow || !chunk) return;
+          const part = typeof chunk === "string" ? chunk.length === 0 ? Buffer.alloc(0) : Buffer.from(chunk, "utf8") : chunk.byteLength === 0 ? Buffer.alloc(0) : Buffer.from(chunk);
+          if (part.length === 0) return;
+          if (authoritativeStdoutBytes + part.length > GROK_AUTHORITATIVE_STDOUT_CEILING_BYTES) {
+            authoritativeStdoutOverflow = true;
+            return;
+          }
+          authoritativeStdoutParts.push(part);
+          authoritativeStdoutBytes += part.length;
+        };
+        let childResult;
+        try {
+          childResult = await executeGrokCommand({
+            command,
+            args: finalArgs,
+            workingDir: options.workingDir,
+            env: effectiveEnv,
+            timeout: executionTimeoutMs,
+            readOnlyWorkingDir: options.readOnlyWorkingDir,
+            abortSignal: combinedAbortSignal,
+            onData: options.onData,
+            onErrorData: options.onErrorData,
+            onFirstOutput: (timestampMs) => {
+              firstOutputMs ??= timestampMs;
+            },
+            // Compose invoke capture with Grok's authoritative stdout collector.
+            // Watchdog.observe accepts RawChunk and statefully decodes for
+            // pattern matching only; authoritative spool observers still get
+            // exact Buffer bytes via the same compose chain.
+            onStdoutChunk: composeRawChunkObservers(onStdoutChunk, options.onStdoutChunk),
+            onStderrChunk: composeRawChunkObservers(
+              watchdog ? watchdog.observe : void 0,
+              options.onStderrChunk
+            ),
+            ...completionSignal ? {
+              completionSignal,
+              completionSignalGraceMs: TMUX_COMPLETION_SIGNAL_GRACE_MS
+            } : {},
+            idleWarnMs: options.idleWarnMs,
+            idleKillMs: options.idleKillMs,
+            onActivity: options.onActivity,
+            metadata: {
+              id: metadata.id,
+              name: metadata.name,
+              installCommand: metadata.installCommand,
+              authHint: metadata.authHint,
+              docsPath: metadata.docsPath,
+              docsAnchor: metadata.docsAnchor
+            },
+            variantStrategy: options.strategy,
+            ...grokStreamOutput ? {
+              streamOutput: true,
+              formatLine: (line) => formatGrokStreamLineForDisplay(line)
+            } : {}
+          });
+        } catch (error) {
+          if (spiralDiagnostics) {
+            const salvaged = trySalvageCompletedGrokOutput(error, outputFormatIsJson);
+            if (salvaged) {
+              childResult = salvaged;
+            } else {
+              const underlying = error instanceof ProviderExecutionError ? error : void 0;
+              const failureDiagnostics = {
+                ...grokDiagnostics,
+                failureStage: "task_transport_watchdog",
+                probeCategory: "provider_transport_failure",
+                transportCloseCount: spiralDiagnostics.transportCloseCount,
+                postTransportToolErrorCount: spiralDiagnostics.postTransportToolErrorCount
+              };
+              throw new ProviderExecutionError(
+                `[Grok] Worker transport died (Auth(AuthorizationRequired)) and the agent spiraled on ${spiralDiagnostics.postTransportToolErrorCount} tool-output errors; aborted before the turn cap.`,
+                {
+                  providerName: metadata.id,
+                  retryable: false,
+                  reason: "provider_transport_failure",
+                  stdout: underlying?.stdout,
+                  stderr: underlying?.stderr,
+                  exitCode: underlying?.exitCode,
+                  parsedError: attachGrokDiagnosticsToParsedError(void 0, failureDiagnostics)
+                }
+              );
+            }
+          } else {
+            const salvaged = trySalvageCompletedGrokOutput(error, outputFormatIsJson);
+            if (outputFormatIsJson && error instanceof ProviderExecutionError && isTimeoutTerminationReason(error.reason) && salvaged) {
+              childResult = salvaged;
+            } else if (error instanceof ProviderExecutionError && !isTerminationReason(error.reason) && error.terminationSource === void 0 && (error.stdout !== void 0 || error.stderr !== void 0)) {
+              childResult = {
+                stdout: error.stdout ?? "",
+                stderr: error.stderr ?? "",
+                exitCode: error.exitCode ?? 1
+              };
+            } else {
+              if (error instanceof ProviderExecutionError) {
+                const enriched = withGrokDiagnosticsForExecutionError(error, grokDiagnostics);
+                await assertWorkspaceRetryIsSafe({
+                  providerId: metadata.id,
+                  providerName: metadata.name,
+                  workingDir: options.workingDir,
+                  attemptStartState,
+                  originalError: enriched,
+                  retryable: enriched.retryable === true
+                });
+                throw enriched;
+              }
+              await assertWorkspaceRetryIsSafe({
+                providerId: metadata.id,
+                providerName: metadata.name,
+                workingDir: options.workingDir,
+                attemptStartState,
+                originalError: error,
+                retryable: error instanceof ProviderExecutionError && error.retryable === true
+              });
+              throw error;
+            }
+          }
+        }
+        if (authoritativeStdoutOverflow) {
+          const partial = authoritativeStdoutParts.length > 0 ? Buffer.concat(authoritativeStdoutParts).toString("utf8") : "";
+          const displayStdout = childResult.stdout ?? "";
+          throw new ProviderExecutionError(
+            `[Grok] Authoritative stdout capture exceeded ${GROK_AUTHORITATIVE_STDOUT_CEILING_BYTES} bytes; refusing to parse a truncated display tail as success.`,
+            {
+              providerName: metadata.id,
+              retryable: false,
+              reason: "output_truncated",
+              exitCode: typeof childResult.exitCode === "number" ? childResult.exitCode : 1,
+              stdout: partial.length > 0 ? partial : displayStdout,
+              stderr: childResult.stderr ?? "",
+              parsedError: attachGrokDiagnosticsToParsedError(
+                {
+                  type: "grok_output_truncated",
+                  ceilingBytes: GROK_AUTHORITATIVE_STDOUT_CEILING_BYTES
+                },
+                { ...grokDiagnostics, failureStage: "task_execution" }
+              )
+            }
+          );
+        }
+        const authoritativeStdout = authoritativeStdoutParts.length > 0 ? Buffer.concat(authoritativeStdoutParts).toString("utf8") : "";
+        const stdout2 = authoritativeStdout.length > 0 ? authoritativeStdout : childResult.stdout ?? "";
+        const stderr2 = childResult.stderr ?? "";
+        const exitCode2 = typeof childResult.exitCode === "number" ? childResult.exitCode : 1;
+        if (resolved.outputFormat === "plain") {
+          return { stdout: stdout2, stderr: stderr2, exitCode: exitCode2, parsed: void 0 };
+        }
+        const parsed2 = parseGrokOutput(stdout2, stderr2, exitCode2);
+        if (parsed2.type === "error") {
+          const failureDiagnostics = {
+            ...grokDiagnostics,
+            failureStage: "task_execution",
+            probeCategory: parsed2.category
+          };
+          const parsedError = new ProviderExecutionError(`[Grok] ${parsed2.message}`, {
+            providerName: metadata.id,
+            retryable: grokCategoryToRetryable(parsed2.category),
+            exitCode: exitCode2,
+            statusCode: parsed2.inner?.httpStatus,
+            reason: grokCategoryToReason(parsed2.category),
+            stdout: stdout2,
+            stderr: stderr2,
+            parsedError: attachGrokDiagnosticsToParsedError(parsed2, failureDiagnostics)
+          });
+          await assertWorkspaceRetryIsSafe({
+            providerId: metadata.id,
+            providerName: metadata.name,
+            workingDir: options.workingDir,
+            attemptStartState,
+            originalError: parsedError,
+            retryable: parsedError.retryable === true
+          });
+          throw parsedError;
+        }
+        return { stdout: stdout2, stderr: stderr2, exitCode: exitCode2, parsed: parsed2 };
+      },
+      {
+        providerName: metadata.name,
+        providerId: metadata.id,
+        operation: "execute_prompt",
+        maxAttempts: 3,
+        abortSignal: options.abortSignal,
+        retryBudget,
+        circuitBreakerOptions: DEFAULT_PROVIDER_CIRCUIT_BREAKER_OPTIONS,
+        fastRetryMode: process.env.NODE_ENV === "test" || process.env.VITEST === "true",
+        deadlineMs: options.deadlineMs ?? Date.now() + resolvedTimeoutMs,
+        minimumAttemptTimeMs: Math.min(resolvedTimeoutMs, 3e4),
+        retryWorktreeDir: options.workingDir
+      }
+    );
+    const { stdout, stderr, exitCode, parsed } = retryResult.result;
+    const effectiveExitCode = exitCode ?? 0;
+    const filesModified = await detectGitChangedFiles(options.workingDir, {
+      baselineStatusPaths
+    }).catch(() => []);
+    await recordRunTiming({
+      model: options.model,
+      resolvedModel: parsed?.type === "success" ? parsed.resolvedModel : void 0,
+      startMs: executionStartMs,
+      firstOutputMs,
+      endMs: Date.now(),
+      status: effectiveExitCode === 0 ? "success" : "error",
+      errorCode: effectiveExitCode === 0 ? void 0 : `exit_${effectiveExitCode}`,
+      tokensIn: parsed?.type === "success" ? parsed.tokenUsage?.inputTokens : void 0,
+      tokensOut: parsed?.type === "success" ? parsed.tokenUsage?.outputTokens : void 0,
+      env: options.env
+    });
+    if (effectiveExitCode === 0) {
+      recordProviderRunSuccess(metadata.id);
+      recordGrokAuthOutcomeBestEffort(
+        "ok",
+        { source: "provider-call", message: "Provider call succeeded" },
+        options.env
+      );
+    } else {
+      recordProviderRunFailure(metadata.id, {
+        severity: "normal",
+        phase: inferProviderFailurePhase({ exitCode: effectiveExitCode, stderr, stdout })
+      });
+    }
+    if (!parsed) {
+      return {
+        stdout,
+        stderr,
+        rawStdout: stdout,
+        rawStderr: stderr,
+        commandPath: command,
+        argvRedacted,
+        stdoutTail: providerOutputTail(stdout),
+        stderrTail: providerOutputTail(stderr),
+        exitCode,
+        requestedReasoningEffort: reasoningResolution?.requestedLevel,
+        effectiveReasoningEffort: reasoningResolution?.resolvedLevel,
+        reasoningEffortOutcome: reasoningResolution?.outcome,
+        workspaceMode: workspaceModeApplied,
+        workspaceModeRequested,
+        promptMode: workspaceModeApplied,
+        promptModeRequested: workspaceModeRequested,
+        promptFingerprint: adaptation.promptFingerprint,
+        finalPromptLength: adaptation.finalPromptLength,
+        completionSignalVariant: adaptation.completionSignalVariant,
+        filesModified,
+        grokDiagnostics,
+        sandboxProvenance: mutationPolicyBoundary?.attestation.provenance,
+        sandboxEvidence: mutationPolicyBoundary?.attestation.evidence
+      };
+    }
+    const stderrWasAuthNoise = parsed.type === "success" && stderr.trim() && isStderrOnlyNoise(stderr);
+    const visibleStdout = parsed.type === "success" ? parsed.text : stdout;
+    const visibleStderr = stderrWasAuthNoise ? "" : stderr;
+    return {
+      stdout: visibleStdout,
+      stderr: visibleStderr,
+      rawStdout: stdout,
+      rawStderr: stderr,
+      commandPath: command,
+      argvRedacted,
+      stdoutTail: providerOutputTail(stdout),
+      stderrTail: providerOutputTail(stderr),
+      sessionId: parsed.type === "success" ? parsed.sessionId : void 0,
+      resolvedModel: parsed.type === "success" ? parsed.resolvedModel : void 0,
+      exitCode,
+      requestedReasoningEffort: reasoningResolution?.requestedLevel,
+      effectiveReasoningEffort: reasoningResolution?.resolvedLevel,
+      reasoningEffortOutcome: reasoningResolution?.outcome,
+      workspaceMode: workspaceModeApplied,
+      workspaceModeRequested,
+      promptMode: workspaceModeApplied,
+      promptModeRequested: workspaceModeRequested,
+      promptFingerprint: adaptation.promptFingerprint,
+      finalPromptLength: adaptation.finalPromptLength,
+      completionSignalVariant: adaptation.completionSignalVariant,
+      tokenUsage: parsed.tokenUsage,
+      filesModified,
+      grokDiagnostics,
+      sandboxProvenance: mutationPolicyBoundary?.attestation.provenance,
+      sandboxEvidence: mutationPolicyBoundary?.attestation.evidence
+    };
+  } catch (error) {
+    if (executionStartMs !== void 0) {
+      const providerError2 = error instanceof ProviderExecutionError ? error : void 0;
+      await recordRunTiming({
+        model: options.model,
+        startMs: executionStartMs,
+        firstOutputMs,
+        endMs: Date.now(),
+        status: "error",
+        errorCode: providerError2?.reason ?? "execution_failed",
+        env: options.env
+      });
+    }
+    const reason = error?.reason;
+    if (reason === "auth" || isAuthFailureError(error)) {
+      recordGrokAuthOutcomeBestEffort("failed", authFailureEvidence(error), options.env);
+    }
+    const providerError = error instanceof ProviderExecutionError ? error : void 0;
+    recordProviderRunFailure(metadata.id, {
+      severity: reason === "auth" || isAuthFailureError(error) ? "hard" : "normal",
+      phase: inferProviderFailurePhase({
+        error,
+        exitCode: providerError?.exitCode,
+        stderr: providerError?.stderr,
+        stdout: providerError?.stdout
+      })
+    });
+    throw error;
+  } finally {
+    await cleanup();
+  }
+}
+export {
+  runGrokNative,
+  shouldSkipGrok,
+  shouldStreamGrokOutput
+};
+//# sourceMappingURL=runner-2YPKOJ6A.js.map