@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-633XZ7UF.js

@@ -0,0 +1,3583 @@
+import {
+  globalProcessLimiter
+} from "./chunk-SF6YK3JI.js";
+import {
+  classifyAndWrapExecaError,
+  exitCodeToSignal,
+  formatTerminationRemedy,
+  hasSignal,
+  redactProviderArgv,
+  resolveTerminationExitCode
+} from "./chunk-JBBB2Y47.js";
+import {
+  evaluateCpuTimeProgressStreak,
+  readCpuTimeSeconds,
+  resolveIdleTimeoutsMs
+} from "./chunk-WJAL4JL3.js";
+import {
+  providerExecutionTransportStreamOptions,
+  sanitizeDiagnosticOutput,
+  sanitizeDiagnosticText
+} from "./chunk-RBKLOUXA.js";
+import {
+  TelemetryLogger
+} from "./chunk-PFCXFO7A.js";
+import {
+  requestProcessExit
+} from "./chunk-GC4CRMTS.js";
+import {
+  createLogger
+} from "./chunk-3OPP2OZB.js";
+import {
+  detectSandboxBoundaryAttestation,
+  wrapWithSandbox
+} from "./chunk-B7YRSULE.js";
+import {
+  BUILD_TEMP_MARKER_FILENAME,
+  markBuildTempDirSync
+} from "./chunk-D6WTZMZB.js";
+import {
+  chunkToText,
+  createLineBufferedStreamProcessor,
+  processOutput,
+  selectBestErrorSummary
+} from "./chunk-TUQMMFEQ.js";
+import {
+  isSignalableProcessGroupId,
+  signalProcessGroup
+} from "./chunk-6CB3KJRY.js";
+import {
+  safeRmDir
+} from "./chunk-ALDTFNZ3.js";
+import {
+  normalizeEngineId
+} from "./chunk-KKQKWAMF.js";
+import {
+  authorizeLinuxHostClassWrites
+} from "./chunk-V2TVPO3X.js";
+import {
+  ProviderExecutionError
+} from "./chunk-RRC5BL7B.js";
+import {
+  formatHostTimeoutTerminationDetail,
+  isHostTimeoutAbortReason
+} from "./chunk-M6UHOC4I.js";
+import {
+  createCleanChildEnv,
+  isSandboxAuthorityEnvVar,
+  stripClaudeSessionEnv
+} from "./chunk-WGQAXLNA.js";
+import {
+  DEFAULT_TIMEOUT_MS
+} from "./chunk-I56TH7VM.js";
+import {
+  BUILD_PROCESS_SLOT_WAIT_MS,
+  BUILD_SUBPROCESS_PID_WAIT_MS,
+  BUILD_VARIANT_WORKER,
+  emitWarning,
+  isDebugMode,
+  isPathDebug,
+  isTimeoutDebug,
+  readEnv
+} from "./chunk-7VRJHTGZ.js";
+import {
+  sanitizeError
+} from "./chunk-CPSVQR2I.js";
+
+// src/core/execution/boundary-telemetry.ts
+function emitBoundaryTriggered(event) {
+  const { trigger, workloadClass, effectiveCeilingMs, elapsedMs, source } = event;
+  const severity = trigger === "ceiling" ? "ERROR" /* ERROR */ : "WARN" /* WARN */;
+  emitWarning(
+    "EB-001",
+    {
+      taskId: event.taskId ?? "unknown",
+      subsystem: "execution",
+      executionPhase: "execution"
+    },
+    {
+      severity,
+      skipConsole: true,
+      metadata: {
+        ...event.metadata,
+        trigger,
+        workloadClass,
+        effectiveCeilingMs,
+        elapsedMs,
+        source,
+        ...event.idleDurationMs !== void 0 ? { idleDurationMs: event.idleDurationMs } : {},
+        ...event.stagnantChecks !== void 0 ? { stagnantChecks: event.stagnantChecks } : {},
+        type: "execution_boundary_triggered"
+      }
+    }
+  );
+  const level = trigger === "ceiling" ? "warn" : "debug";
+  const msg = `[ExecutionBoundary] ${trigger} fired for ${workloadClass} after ${elapsedMs}ms (ceiling: ${effectiveCeilingMs}ms, source: ${source})`;
+  if (level === "warn") {
+    console.warn(msg);
+  } else if (isDebugMode() || process.env.DEBUG) {
+    console.debug(msg);
+  }
+}
+
+// src/core/process-lifecycle-context.ts
+var processLifecycleManager;
+function setProcessLifecycleManager(manager) {
+  processLifecycleManager = manager;
+}
+function getProcessLifecycleManager() {
+  return processLifecycleManager;
+}
+
+// src/core/providers/shared/raw-chunk-observers.ts
+function isNonEmptyRawChunk(chunk) {
+  if (typeof chunk === "string") {
+    return chunk.length > 0;
+  }
+  return chunk.byteLength > 0;
+}
+function rawChunkToBuffer(chunk) {
+  if (typeof chunk === "string") {
+    if (chunk.length === 0) {
+      return Buffer.alloc(0);
+    }
+    return Buffer.from(chunk, "utf8");
+  }
+  if (chunk.byteLength === 0) {
+    return Buffer.alloc(0);
+  }
+  return Buffer.from(chunk);
+}
+function composeRawChunkObservers(...observers) {
+  const active2 = observers.filter((o) => typeof o === "function");
+  if (active2.length === 0) return void 0;
+  if (active2.length === 1) return active2[0];
+  return (chunk) => {
+    for (const observer of active2) {
+      try {
+        observer(chunk);
+      } catch {
+      }
+    }
+  };
+}
+
+// src/core/providers/shared/tmux-completion-signal.ts
+var TMUX_COMPLETION_SIGNAL_GRACE_MS = 1500;
+var DEFAULT_MAX_PENDING_LINE_BYTES = 1024 * 1024;
+function defaultShouldCheckPendingLine(pendingLine) {
+  return pendingLine.trimEnd().endsWith("}");
+}
+function createLineDelimitedTmuxCompletionSignal(lineConcludes, opts) {
+  let pendingLine = "";
+  let concluded = false;
+  const maxPendingLineBytes = opts?.maxPendingLineBytes ?? DEFAULT_MAX_PENDING_LINE_BYTES;
+  const shouldCheckPendingLine = opts?.shouldCheckPendingLine ?? defaultShouldCheckPendingLine;
+  const lineConcludesSafely = (line) => {
+    try {
+      return lineConcludes(line);
+    } catch {
+      return false;
+    }
+  };
+  return (chunk, stream) => {
+    if (concluded) return true;
+    if (stream !== "stdout" || !chunk) return false;
+    const combined = pendingLine + chunk;
+    const lines = combined.split(/\r?\n/);
+    pendingLine = lines.pop() ?? "";
+    if (pendingLine.length > maxPendingLineBytes) {
+      pendingLine = pendingLine.slice(-maxPendingLineBytes);
+    }
+    for (const line of lines) {
+      if (lineConcludesSafely(line)) {
+        concluded = true;
+        return true;
+      }
+    }
+    if (shouldCheckPendingLine(pendingLine) && lineConcludesSafely(pendingLine)) {
+      concluded = true;
+      return true;
+    }
+    return false;
+  };
+}
+
+// src/core/providers/shared/variant-launch.ts
+import { AsyncLocalStorage } from "async_hooks";
+var active = new AsyncLocalStorage();
+function withVariantInvocation(invocation, run) {
+  return active.run(invocation, run);
+}
+function activeVariantServiceTier() {
+  return active.getStore()?.resolution.resolved.serviceTier;
+}
+function prepareVariantCommand(command, model, effort) {
+  active.getStore()?.prepare({
+    ...model ? { model } : {},
+    ...effort ? { effort } : {}
+  });
+  return command;
+}
+function observeVariantProcessSpawn(process2) {
+  const invocation = active.getStore();
+  if (invocation) process2.once("spawn", () => invocation.submitted());
+}
+function recordVariantTmuxLaunch() {
+  active.getStore()?.submitted();
+}
+
+// src/core/providers/shared/base-runner.ts
+import { createHash } from "crypto";
+import os3 from "os";
+import path2 from "path";
+import { StringDecoder as StringDecoder2 } from "string_decoder";
+
+// src/core/providers/shared/file-backed-stdout.ts
+import * as fs from "fs";
+import { StringDecoder } from "string_decoder";
+var FILE_BACKED_STDOUT_DEFAULT_MAX_BYTES = 256 * 1024 * 1024;
+var FILE_BACKED_STDOUT_MIN_FREE_BYTES = 8 * 1024 * 1024;
+var DEFAULT_POLL_INTERVAL_MS = 25;
+var TRUTHY_OVERRIDES = /* @__PURE__ */ new Set(["1", "true", "yes", "on"]);
+var FALSY_OVERRIDES = /* @__PURE__ */ new Set(["0", "false", "no", "off"]);
+var FILE_BACKED_STDOUT_ENV_NAME = "BUILD_PROVIDER_FILE_BACKED_STDOUT";
+function resolveFileBackedStdoutOverride(env = process.env) {
+  const raw = env[FILE_BACKED_STDOUT_ENV_NAME];
+  if (raw === void 0 || raw === "") return void 0;
+  const lower = raw.toLowerCase();
+  if (TRUTHY_OVERRIDES.has(lower)) return true;
+  if (FALSY_OVERRIDES.has(lower)) return false;
+  throw new Error(
+    `Invalid boolean value for ${FILE_BACKED_STDOUT_ENV_NAME}: "${raw}". Expected one of: 1, true, yes, on, 0, false, no, off`
+  );
+}
+var MAX_SLICE_BYTES = 1024 * 1024;
+var SETTLE_ATTEMPTS = 5;
+function spoolFilesystemFreeBytes(dir) {
+  if (typeof fs.statfsSync !== "function") return void 0;
+  try {
+    const stats = fs.statfsSync(dir);
+    const available = Number(stats.bavail) * Number(stats.bsize);
+    return Number.isFinite(available) && available >= 0 ? available : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function createStdoutSpoolTailer(options) {
+  const pollIntervalMs = Math.max(1, options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS);
+  const decoder = new StringDecoder("utf8");
+  let offset = 0;
+  let polling = false;
+  let timer;
+  let inflight;
+  let failure;
+  const recordFailure = (candidate) => {
+    if (failure) return;
+    failure = candidate;
+    polling = false;
+    options.onFailure(candidate);
+  };
+  const asMessage = (error) => error instanceof Error ? error.message : String(error);
+  const pump = async () => {
+    for (; ; ) {
+      if (failure) return;
+      const size = await options.stream.statSize();
+      if (size > options.maxBytes) {
+        recordFailure({
+          reason: "output_ceiling_exceeded",
+          message: `provider stdout exceeded the ${options.maxBytes} byte capture ceiling (${size} bytes spooled)`
+        });
+        return;
+      }
+      if (size <= offset) return;
+      const bytes = await options.stream.readAt(offset, Math.min(size - offset, MAX_SLICE_BYTES));
+      if (bytes.length === 0) return;
+      offset += bytes.length;
+      try {
+        options.onBytes(bytes, decoder.write(bytes));
+      } catch (error) {
+        recordFailure({
+          reason: "stdout_spool_consume_failed",
+          message: `processing spooled provider stdout failed: ${asMessage(error)}`
+        });
+        return;
+      }
+    }
+  };
+  const tick = () => {
+    if (!polling || inflight) return;
+    inflight = pump().catch((error) => {
+      recordFailure({
+        reason: "stdout_spool_read_failed",
+        message: `reading spooled provider stdout failed: ${asMessage(error)}`
+      });
+    }).finally(() => {
+      inflight = void 0;
+      if (polling) {
+        timer = setTimeout(tick, pollIntervalMs);
+        timer.unref?.();
+      }
+    });
+  };
+  const readToEnd = async () => {
+    polling = false;
+    if (timer) {
+      clearTimeout(timer);
+      timer = void 0;
+    }
+    if (inflight) {
+      try {
+        await inflight;
+      } catch {
+      }
+    }
+    if (failure) return;
+    try {
+      await pump();
+    } catch (error) {
+      recordFailure({
+        reason: "stdout_spool_read_failed",
+        message: `final drain of spooled provider stdout failed: ${asMessage(error)}`
+      });
+    }
+  };
+  let flushed = false;
+  const flushDecoder = () => {
+    if (flushed) return;
+    flushed = true;
+    const tail = decoder.end();
+    if (!tail || failure) return;
+    try {
+      options.onBytes(void 0, tail);
+    } catch (error) {
+      recordFailure({
+        reason: "stdout_spool_consume_failed",
+        message: `flushing spooled provider stdout failed: ${asMessage(error)}`
+      });
+    }
+  };
+  return {
+    bytesObserved: () => offset,
+    failure: () => failure,
+    start() {
+      if (polling) return;
+      polling = true;
+      tick();
+    },
+    drain: readToEnd,
+    async finish() {
+      let size;
+      for (let attempt = 0; attempt < SETTLE_ATTEMPTS; attempt += 1) {
+        await readToEnd();
+        if (failure) break;
+        try {
+          size = await options.stream.statSize();
+        } catch (error) {
+          recordFailure({
+            reason: "stdout_spool_read_failed",
+            message: `measuring the spooled provider stdout failed: ${asMessage(error)}`
+          });
+          break;
+        }
+        if (size === offset) break;
+      }
+      if (!failure && size !== void 0 && size !== offset) {
+        recordFailure({
+          reason: "stdout_spool_read_failed",
+          message: `provider stdout spool never settled: ${size} bytes on disk but ${offset} read after ${SETTLE_ATTEMPTS} passes`
+        });
+      }
+      flushDecoder();
+      return size;
+    }
+  };
+}
+
+// src/core/providers/shared/private-spool.ts
+import * as fs2 from "fs";
+import * as os from "os";
+import * as path from "path";
+var PrivateSpoolError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "PrivateSpoolError";
+  }
+};
+var EXCL_RDWR_FLAGS = fs2.constants.O_RDWR | fs2.constants.O_CREAT | fs2.constants.O_EXCL | (fs2.constants.O_NOFOLLOW ?? 0);
+function writeAllToFd(fd, buffer, createError) {
+  return new Promise((resolve, reject) => {
+    let offset = 0;
+    const writeNext = () => {
+      if (offset >= buffer.length) {
+        resolve();
+        return;
+      }
+      fs2.write(fd, buffer, offset, buffer.length - offset, null, (error, written) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+        if (typeof written !== "number" || written <= 0) {
+          reject(createError("write made no progress"));
+          return;
+        }
+        offset += written;
+        writeNext();
+      });
+    };
+    writeNext();
+  });
+}
+function fsyncFd(fd) {
+  return new Promise((resolve, reject) => {
+    fs2.fsync(fd, (error) => {
+      if (error) reject(error);
+      else resolve();
+    });
+  });
+}
+function closeFd(fd) {
+  return new Promise((resolve, reject) => {
+    fs2.close(fd, (error) => {
+      if (error) reject(error);
+      else resolve();
+    });
+  });
+}
+function fstatSize(fd) {
+  return new Promise((resolve, reject) => {
+    fs2.fstat(fd, (error, stats) => {
+      if (error) reject(error);
+      else resolve(stats.size);
+    });
+  });
+}
+function readAtFd(fd, position, length) {
+  if (length <= 0) return Promise.resolve(Buffer.alloc(0));
+  const buffer = Buffer.allocUnsafe(length);
+  return new Promise((resolve, reject) => {
+    fs2.read(fd, buffer, 0, length, position, (error, bytesRead) => {
+      if (error) {
+        reject(error);
+        return;
+      }
+      resolve(Buffer.from(buffer.subarray(0, bytesRead)));
+    });
+  });
+}
+function cleanupPartiallyInitializedSpool(dir, leaves) {
+  for (const leaf of leaves) {
+    try {
+      fs2.unlinkSync(leaf);
+    } catch {
+    }
+  }
+  try {
+    fs2.rmdirSync(dir);
+  } catch {
+  }
+}
+function createPrivateSpool(options) {
+  const errorLabel = options.errorLabel ?? "private spool";
+  const createError = options.createError ?? ((message) => new PrivateSpoolError(message));
+  const fail = (message) => createError(`${errorLabel} ${message}`);
+  if (options.streams.length === 0) {
+    throw fail("requires at least one stream");
+  }
+  const label = (options.label ?? "spool").replace(/[^a-zA-Z0-9._-]+/g, "-").slice(0, 40);
+  const dir = fs2.mkdtempSync(path.join(os.tmpdir(), `build-${label}-`));
+  fs2.chmodSync(dir, 448);
+  markBuildTempDirSync(dir);
+  const states = /* @__PURE__ */ new Map();
+  const leafPaths = [path.join(dir, BUILD_TEMP_MARKER_FILENAME)];
+  try {
+    for (const name of options.streams) {
+      if (states.has(name)) {
+        throw fail(`duplicate stream '${name}'`);
+      }
+      if (!/^[a-zA-Z0-9._-]+$/.test(name) || name === "." || name === "..") {
+        throw fail(`invalid stream name '${name}'`);
+      }
+      const leaf = path.join(dir, `${name}.spool`);
+      leafPaths.push(leaf);
+      const fd = fs2.openSync(leaf, EXCL_RDWR_FLAGS, 384);
+      fs2.fchmodSync(fd, 384);
+      states.set(name, { name, path: leaf, fd, sawEnqueuedWrite: false });
+    }
+  } catch (error) {
+    for (const state of states.values()) {
+      if (state.fd !== null) {
+        try {
+          fs2.closeSync(state.fd);
+        } catch {
+        }
+      }
+    }
+    cleanupPartiallyInitializedSpool(dir, leafPaths);
+    throw error;
+  }
+  let writeChain = Promise.resolve();
+  let writeError;
+  let finalized = false;
+  let disposed = false;
+  const closeHeldFds = async () => {
+    const fds = [];
+    for (const state of states.values()) {
+      if (state.fd !== null) {
+        fds.push(state.fd);
+        state.fd = null;
+      }
+    }
+    for (const fd of fds) {
+      try {
+        await closeFd(fd);
+      } catch {
+      }
+    }
+  };
+  const makeStream = (state) => ({
+    get name() {
+      return state.name;
+    },
+    get path() {
+      return state.path;
+    },
+    get sawEnqueuedWrite() {
+      return state.sawEnqueuedWrite;
+    },
+    enqueue(chunk) {
+      if (disposed || finalized || state.fd === null) return;
+      if (!isNonEmptyRawChunk(chunk)) return;
+      const targetFd = state.fd;
+      const buffer = rawChunkToBuffer(chunk);
+      if (buffer.length === 0) return;
+      state.sawEnqueuedWrite = true;
+      writeChain = writeChain.then(async () => {
+        if (disposed) return;
+        await writeAllToFd(targetFd, buffer, fail);
+      }).catch((error) => {
+        if (!writeError) {
+          writeError = error instanceof Error ? error : fail(String(error));
+        }
+      });
+    },
+    requireOpenFd() {
+      if (disposed) throw fail("already disposed");
+      if (state.fd === null) throw fail(`${state.name} FD not available`);
+      return state.fd;
+    },
+    requireFinalizedFd() {
+      if (disposed) throw fail("already disposed");
+      if (!finalized || state.fd === null) {
+        throw fail(`${state.name} FD not available (finalize first)`);
+      }
+      return state.fd;
+    },
+    async statSize() {
+      if (disposed) throw fail("already disposed");
+      if (state.fd === null) throw fail(`${state.name} FD not available`);
+      return fstatSize(state.fd);
+    },
+    async readAt(position, length) {
+      if (disposed) throw fail("already disposed");
+      if (state.fd === null) throw fail(`${state.name} FD not available`);
+      return readAtFd(state.fd, position, length);
+    }
+  });
+  const streams = /* @__PURE__ */ new Map();
+  for (const state of states.values()) {
+    streams.set(state.name, makeStream(state));
+  }
+  return {
+    get dir() {
+      return dir;
+    },
+    stream(name) {
+      const stream = streams.get(name);
+      if (!stream) {
+        throw fail(`unknown stream '${name}'`);
+      }
+      return stream;
+    },
+    async finalize() {
+      if (disposed) throw fail("already disposed");
+      if (finalized) return;
+      await writeChain;
+      if (writeError) {
+        await closeHeldFds();
+        throw fail(`write failed: ${writeError.message}`);
+      }
+      try {
+        for (const state of states.values()) {
+          if (state.fd !== null) {
+            await fsyncFd(state.fd);
+          }
+        }
+      } catch (error) {
+        await closeHeldFds();
+        const message = error instanceof Error ? error.message : String(error);
+        throw fail(`fsync failed: ${message}`);
+      }
+      finalized = true;
+    },
+    async dispose() {
+      if (disposed) return;
+      disposed = true;
+      try {
+        await writeChain;
+      } catch {
+      }
+      await closeHeldFds();
+      try {
+        await safeRmDir(dir, {
+          protectedPaths: [os.tmpdir()],
+          managedRoots: [os.tmpdir()]
+        });
+      } catch {
+      }
+    }
+  };
+}
+
+// src/core/providers/shared/process-signals.ts
+var BUILD_PROCESS_GROUP_OWNER_ENV = "BUILD_PROCESS_GROUP_OWNER";
+var BUILD_PROVIDER_PROCESS_GROUP_MARKER_PREFIX = "__BUILD_PROVIDER_PROCESS_GROUP_PID__:";
+var BUILD_PROVIDER_PROCESS_GROUP_CLEARED_MARKER_PREFIX = "__BUILD_PROVIDER_PROCESS_GROUP_CLEARED__:";
+function isReportableProviderProcessGroupPid(pid) {
+  return isSignalableProcessGroupId(pid);
+}
+function shouldEmitWorkerProcessGroupMarker(pid) {
+  return readEnv(BUILD_VARIANT_WORKER).value === true && process.platform !== "win32" && isReportableProviderProcessGroupPid(pid);
+}
+function isProviderProcessGroupMarkerLine(line) {
+  return line.startsWith(BUILD_PROVIDER_PROCESS_GROUP_MARKER_PREFIX) || line.startsWith(BUILD_PROVIDER_PROCESS_GROUP_CLEARED_MARKER_PREFIX);
+}
+function resolveProviderProcessGroupOwnership() {
+  return {
+    owner: "runner",
+    detach: process.platform !== "win32"
+  };
+}
+function emitProviderProcessGroupMarker(pid) {
+  if (!shouldEmitWorkerProcessGroupMarker(pid)) {
+    return;
+  }
+  try {
+    process.stdout.write(`${BUILD_PROVIDER_PROCESS_GROUP_MARKER_PREFIX}${pid}
+`);
+  } catch {
+  }
+}
+function emitProviderProcessGroupClearedMarker(pid) {
+  if (!shouldEmitWorkerProcessGroupMarker(pid)) {
+    return;
+  }
+  try {
+    process.stdout.write(`${BUILD_PROVIDER_PROCESS_GROUP_CLEARED_MARKER_PREFIX}${pid}
+`);
+  } catch {
+  }
+}
+function isNoSuchProcess(error) {
+  return error?.code === "ESRCH";
+}
+async function ensureDetachedProviderProcessGroupGone(pid, timeoutMs = 2e3) {
+  if (process.platform === "win32" || !isReportableProviderProcessGroupPid(pid)) {
+    return true;
+  }
+  try {
+    signalProcessGroup(pid, 0);
+  } catch (error) {
+    return isNoSuchProcess(error);
+  }
+  try {
+    signalProcessGroup(pid, "SIGKILL");
+  } catch (error) {
+    return isNoSuchProcess(error);
+  }
+  const deadline = Date.now() + Math.max(0, timeoutMs);
+  while (Date.now() < deadline) {
+    try {
+      signalProcessGroup(pid, 0);
+    } catch (error) {
+      return isNoSuchProcess(error);
+    }
+    await new Promise((resolve) => setTimeout(resolve, 25));
+  }
+  return false;
+}
+function sendSignalToSubprocessTree(subprocess, signal) {
+  let delivered = false;
+  if (process.platform !== "win32" && isSignalableProcessGroupId(subprocess.pid)) {
+    try {
+      signalProcessGroup(subprocess.pid, signal);
+      delivered = true;
+    } catch {
+    }
+  }
+  try {
+    subprocess.kill(signal);
+    delivered = true;
+  } catch {
+  }
+  return delivered;
+}
+
+// src/core/providers/shared/process-slot-reservation.ts
+import { execa } from "execa";
+var DEFAULT_PROCESS_SLOT_WAIT_MS = 3e4;
+var PROCESS_SLOT_POLL_MS = 100;
+function releaseProcessSlotReservation(reservation) {
+  if (reservation !== void 0) {
+    globalProcessLimiter.cancelReservation(reservation);
+  }
+}
+function getProcessSlotWaitBudgetMs() {
+  const raw = readEnv(BUILD_PROCESS_SLOT_WAIT_MS).value ?? DEFAULT_PROCESS_SLOT_WAIT_MS;
+  return Math.max(0, Math.min(3e5, raw));
+}
+function tryReserveProcessSlot() {
+  if (typeof globalProcessLimiter.reserve === "function") {
+    const reservation = globalProcessLimiter.reserve();
+    if (reservation !== null) {
+      return reservation;
+    }
+  } else {
+    const canSpawn = typeof globalProcessLimiter.canSpawn === "function" ? globalProcessLimiter.canSpawn() : true;
+    if (canSpawn) {
+      return void 0;
+    }
+  }
+  return null;
+}
+function processSlotAbortError(limiterDescription) {
+  return new Error(`Process slot wait aborted before spawn: ${limiterDescription}`);
+}
+function throwIfReservationAborted(reservation, limiterDescription, abortSignal) {
+  if (!abortSignal?.aborted) {
+    return;
+  }
+  releaseProcessSlotReservation(reservation);
+  throw processSlotAbortError(limiterDescription);
+}
+function acquireProcessSlot(limiterDescription, abortSignal) {
+  const immediateReservation = tryReserveProcessSlot();
+  if (immediateReservation !== null) {
+    throwIfReservationAborted(immediateReservation, limiterDescription, abortSignal);
+    return immediateReservation;
+  }
+  return waitForProcessSlot(limiterDescription, abortSignal);
+}
+async function waitForProcessSlot(limiterDescription, abortSignal) {
+  const waitBudgetMs = getProcessSlotWaitBudgetMs();
+  const deadline = Date.now() + waitBudgetMs;
+  while (true) {
+    const reservation = tryReserveProcessSlot();
+    if (reservation !== null) {
+      throwIfReservationAborted(reservation, limiterDescription, abortSignal);
+      return reservation;
+    }
+    if (abortSignal?.aborted) {
+      throw processSlotAbortError(limiterDescription);
+    }
+    const remainingMs = deadline - Date.now();
+    if (remainingMs <= 0 || waitBudgetMs === 0) {
+      throw new Error(
+        `Process limit reached before spawn after waiting ${waitBudgetMs}ms: ${limiterDescription}. Wait for existing provider processes to complete or increase BUILD_MAX_PROCESSES.`
+      );
+    }
+    await new Promise((resolve, reject) => {
+      const timer = setTimeout(
+        () => {
+          abortSignal?.removeEventListener("abort", onAbort);
+          resolve();
+        },
+        Math.min(PROCESS_SLOT_POLL_MS, remainingMs)
+      );
+      const onAbort = () => {
+        clearTimeout(timer);
+        abortSignal?.removeEventListener("abort", onAbort);
+        reject(processSlotAbortError(limiterDescription));
+      };
+      abortSignal?.addEventListener("abort", onAbort, { once: true });
+    });
+    if (abortSignal?.aborted) {
+      throw processSlotAbortError(limiterDescription);
+    }
+  }
+}
+function spawnProviderSubprocess(command, args, options, reservation) {
+  try {
+    return execa(command, args, options);
+  } catch (spawnErr) {
+    releaseProcessSlotReservation(reservation);
+    throw spawnErr;
+  }
+}
+
+// src/core/providers/shared/sandbox-bypass-guard.ts
+import os2 from "os";
+var PROVIDER_INTERNAL_SANDBOX_BYPASS_FLAGS = /* @__PURE__ */ new Set([
+  "--dangerously-bypass-approvals-and-sandbox",
+  "--dangerously-skip-permissions",
+  "--yolo",
+  "--allow-all-tools",
+  "--always-approve",
+  "--trust-all-tools"
+]);
+var PROVIDER_INTERNAL_SANDBOX_BYPASS_OPTION_VALUES = /* @__PURE__ */ new Map([
+  ["--permission-mode", /* @__PURE__ */ new Set(["acceptEdits", "auto", "dontAsk", "bypassPermissions"])],
+  ["--sandbox", /* @__PURE__ */ new Set(["disabled"])]
+]);
+function parseBooleanLikeFlagValue(value) {
+  const normalized = value.trim().toLowerCase();
+  return normalized === "true" || normalized === "1" || normalized === "yes";
+}
+function hasAcceptedPolicyBoundaryProof(sandboxed) {
+  const { boundaryProof, policyProof } = sandboxed;
+  if (boundaryProof === "wrap_applied" && policyProof === "wrap_applied") {
+    return true;
+  }
+  if ((boundaryProof === "inherited_outer" || boundaryProof === "container") && policyProof === "capability_probe") {
+    return true;
+  }
+  if (os2.platform() === "linux" && (boundaryProof === "linux_isolated" || boundaryProof === "linux_acknowledged") && policyProof === "linux_host_class") {
+    return true;
+  }
+  return false;
+}
+var HOST_CLASS_BYPASS_PROVENANCES = /* @__PURE__ */ new Set([
+  "linux_isolated",
+  "linux_acknowledged"
+]);
+function formatHostClassBypassNotice(providerName, provenance) {
+  if (!HOST_CLASS_BYPASS_PROVENANCES.has(provenance)) return void 0;
+  return `Info: ${providerName} internal sandbox is bypassed for this run because the Linux host class provides the boundary (provenance=${provenance}).`;
+}
+function emitHostClassBypassNotice(providerName, providerId, options = {}) {
+  const { provenance } = detectSandboxBoundaryAttestation(providerName, providerId, options);
+  const notice = formatHostClassBypassNotice(providerName, provenance);
+  if (!notice) return;
+  console.warn(notice);
+}
+function findProviderInternalSandboxBypass(args) {
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (!arg) continue;
+    if (PROVIDER_INTERNAL_SANDBOX_BYPASS_FLAGS.has(arg)) return arg;
+    for (const flag of PROVIDER_INTERNAL_SANDBOX_BYPASS_FLAGS) {
+      if (arg.startsWith(`${flag}=`)) {
+        const value = arg.slice(flag.length + 1);
+        if (parseBooleanLikeFlagValue(value)) return flag;
+      }
+    }
+    const equalsIndex = arg.indexOf("=");
+    if (equalsIndex > 0) {
+      const option = arg.slice(0, equalsIndex);
+      const value = arg.slice(equalsIndex + 1);
+      const bypassValues2 = PROVIDER_INTERNAL_SANDBOX_BYPASS_OPTION_VALUES.get(option);
+      if (bypassValues2?.has(value)) return `${option}=${value}`;
+    }
+    const bypassValues = PROVIDER_INTERNAL_SANDBOX_BYPASS_OPTION_VALUES.get(arg);
+    const next = args[index + 1];
+    if (next && bypassValues?.has(next)) return `${arg} ${next}`;
+  }
+  return void 0;
+}
+function assertProviderBypassHasBoundaryProof(metadata, args, sandboxed, explicitBypass) {
+  const bypassFlag = explicitBypass ?? findProviderInternalSandboxBypass(args);
+  if (!bypassFlag || hasAcceptedPolicyBoundaryProof(sandboxed)) return;
+  if (sandboxed.boundaryProof) {
+    throw new ProviderExecutionError(
+      `[${metadata.name}] Provider internal sandbox bypass (${bypassFlag}) requires a sandbox policy boundary for this exact invocation, but the final provider command only has security boundary proof (${sandboxed.boundaryProof}) [reason=sandbox_capability_denied]`,
+      {
+        retryable: false,
+        reason: "sandbox_capability_denied",
+        providerName: metadata.name
+      }
+    );
+  }
+  if (os2.platform() === "linux") {
+    authorizeLinuxHostClassWrites();
+  }
+  throw new ProviderExecutionError(
+    `[${metadata.name}] Provider internal sandbox bypass (${bypassFlag}) requires a sandbox boundary for this exact invocation, but the final provider command has no boundary proof [reason=sandbox_boundary_required]`,
+    {
+      retryable: false,
+      reason: "sandbox_boundary_required",
+      providerName: metadata.name
+    }
+  );
+}
+
+// src/core/providers/shared/sandbox-path-denial.ts
+var SANDBOX_PATH_DENIED_REASON = "sandbox_path_denied";
+var SEATBELT_BOUNDARY_PROOFS = /* @__PURE__ */ new Set([
+  "wrap_applied",
+  "inherited_outer"
+]);
+var MAX_SCANNED_STDERR_CHARS = 16384;
+var MAX_SCANNED_LINE_CHARS = 2048;
+var MAX_REPORTED_PATH_CHARS = 512;
+var PATH = String.raw`(?:\/|~\/)`;
+var NODE_FILE_OPS = "open|mkdir|mkdtemp|rename|unlink|rmdir|rm|copyfile|symlink|link|scandir|opendir|access|stat|lstat|utime";
+var DENIAL_PATTERNS = [
+  // node: EPERM: operation not permitted, open '/path'
+  new RegExp(
+    String.raw`\bEPERM: operation not permitted, (?:${NODE_FILE_OPS}) '(${PATH}[^'\n]+)'`,
+    "i"
+  ),
+  // python: [Errno 1] Operation not permitted: '/path'
+  new RegExp(String.raw`operation not permitted: '(${PATH}[^'\n]+)'`, "i"),
+  // zsh: <script>:<line>: operation not permitted: /path
+  new RegExp(String.raw`operation not permitted: (${PATH}.*?)\s*$`, "i"),
+  // bash, dash, go: /path: Operation not permitted
+  new RegExp(String.raw`(${PATH}[^\n:']*): operation not permitted\b`, "i")
+];
+var NON_PATH_EPERM = /sandbox_apply|(?:^|:\s)(?:ch(?:own|mod|grp|flags)|kill|set[ug]id|ptrace)(?::|\s+[/~])|\b(?:l?ch(?:own|mod|flags)|kill|set[ug]id)\s*\(/i;
+var TRACE_TAIL = /^(?:\s+at\s|\s+(?:errno|code|syscall|path|dest):\s|\}|Node\.js v|Bun v)/;
+function detectSandboxPathDenial(stderr) {
+  const lines = stderr.slice(-MAX_SCANNED_STDERR_CHARS).split(/\r?\n/).filter((line) => line.trim().length > 0);
+  let end = lines.length - 1;
+  while (end >= 0 && TRACE_TAIL.test(lines[end] ?? "")) end--;
+  const last = lines[end];
+  if (!last || last.length > MAX_SCANNED_LINE_CHARS) return void 0;
+  let start = end;
+  while (start > 0 && /^\s/.test(lines[start - 1] ?? "")) start--;
+  const block = lines.slice(start).filter((line) => !/^\s+at\s/.test(line));
+  if (block.some((line) => NON_PATH_EPERM.test(line))) return void 0;
+  for (const pattern of DENIAL_PATTERNS) {
+    const path3 = pattern.exec(last)?.[1]?.trim();
+    if (path3) return { path: path3 };
+  }
+  return void 0;
+}
+function sandboxPathDenialError(metadata, sandbox, exit, maxPublicLength) {
+  const { exitCode } = exit;
+  if (sandbox?.sandboxed !== true || !SEATBELT_BOUNDARY_PROOFS.has(sandbox.boundaryProof)) {
+    return void 0;
+  }
+  if (exitCode === void 0 || exitCode === 0) return void 0;
+  if (exit.stdout.trim().length > 0 || (exit.stdoutBytes ?? 0) > 0) return void 0;
+  const denial = detectSandboxPathDenial(exit.stderr);
+  if (!denial) return void 0;
+  const path3 = sanitizeDiagnosticText(denial.path).slice(0, MAX_REPORTED_PATH_CHARS);
+  const providerId = normalizeEngineId(metadata.id ?? metadata.name);
+  return new ProviderExecutionError(
+    `${metadata.name} CLI exited with code ${exitCode} after reporting access denied to ${path3} while running inside the sandbox. If the command Build runs for ${metadata.name} is a wrapper or launcher that writes outside the run's workspace, point Build at the real binary with providers.${providerId}.cli.command in your user providers.yaml or BUILD_${providerId.toUpperCase()}_CLI_COMMAND.`,
+    {
+      retryable: false,
+      exitCode,
+      reason: SANDBOX_PATH_DENIED_REASON,
+      ...providerExecutionTransportStreamOptions(exit.stdout, exit.stderr, { maxPublicLength })
+    }
+  );
+}
+
+// src/core/memory/guardian.ts
+import { randomBytes } from "crypto";
+import { totalmem } from "os";
+import { getHeapStatistics } from "v8";
+
+// src/core/memory/provider-profiles.ts
+function cloneProfile(profile) {
+  return {
+    ...profile,
+    gracefulDegradation: { ...profile.gracefulDegradation }
+  };
+}
+function cloneProfiles(profiles) {
+  return Object.fromEntries(
+    Object.entries(profiles).map(([providerId, profile]) => [providerId, cloneProfile(profile)])
+  );
+}
+var DEFAULT_PROFILES = {
+  default: {
+    warnThreshold: 0.85,
+    criticalThreshold: 0.9,
+    emergencyThreshold: 0.95,
+    gracefulDegradation: {
+      enabled: true,
+      reduceParallelism: true,
+      slowPolling: true
+    },
+    maxProcesses: 10
+  },
+  claude: {
+    warnThreshold: 0.8,
+    criticalThreshold: 0.88,
+    emergencyThreshold: 0.93,
+    gracefulDegradation: {
+      enabled: true,
+      reduceParallelism: true,
+      slowPolling: true
+    },
+    maxProcesses: 3
+  },
+  gemini: {
+    warnThreshold: 0.85,
+    criticalThreshold: 0.92,
+    emergencyThreshold: 0.96,
+    gracefulDegradation: {
+      enabled: true,
+      reduceParallelism: true,
+      slowPolling: false
+    },
+    maxProcesses: 8
+  },
+  codex: {
+    warnThreshold: 0.82,
+    criticalThreshold: 0.89,
+    emergencyThreshold: 0.94,
+    gracefulDegradation: {
+      enabled: true,
+      reduceParallelism: true,
+      slowPolling: true
+    },
+    maxProcesses: 2
+  },
+  cursor: {
+    warnThreshold: 0.75,
+    criticalThreshold: 0.85,
+    emergencyThreshold: 0.92,
+    gracefulDegradation: {
+      enabled: true,
+      reduceParallelism: true,
+      slowPolling: true
+    },
+    maxProcesses: 1
+  },
+  copilot: {
+    warnThreshold: 0.78,
+    criticalThreshold: 0.86,
+    emergencyThreshold: 0.92,
+    gracefulDegradation: {
+      enabled: true,
+      reduceParallelism: true,
+      slowPolling: true
+    },
+    maxProcesses: 3
+  },
+  opencode: {
+    warnThreshold: 0.85,
+    criticalThreshold: 0.9,
+    emergencyThreshold: 0.95,
+    gracefulDegradation: {
+      enabled: true,
+      reduceParallelism: true,
+      slowPolling: true
+    },
+    maxProcesses: 3
+  },
+  grok: {
+    warnThreshold: 0.85,
+    criticalThreshold: 0.92,
+    emergencyThreshold: 0.96,
+    gracefulDegradation: {
+      enabled: true,
+      reduceParallelism: true,
+      slowPolling: true
+    },
+    maxProcesses: 3
+  }
+};
+var MemoryProfilesManager = class _MemoryProfilesManager {
+  static instance;
+  profiles = cloneProfiles(DEFAULT_PROFILES);
+  constructor() {
+  }
+  /**
+   * Synchronous singleton construction. JavaScript module execution is single-threaded
+   * here, so an event-loop-blocking spin lock is unnecessary and unsafe.
+   */
+  static getInstance() {
+    if (_MemoryProfilesManager.instance) {
+      return _MemoryProfilesManager.instance;
+    }
+    _MemoryProfilesManager.instance = new _MemoryProfilesManager();
+    return _MemoryProfilesManager.instance;
+  }
+  /**
+   * Replace profiles explicitly for an embedding or test harness.
+   * Production startup does not call this from providers.yaml.
+   */
+  loadProfiles(config) {
+    this.profiles = {
+      ...cloneProfiles(DEFAULT_PROFILES),
+      ...cloneProfiles(config)
+    };
+  }
+  /**
+   * Get profile for a specific provider
+   * Falls back to 'default' if provider-specific profile not found
+   */
+  getProfile(providerId) {
+    return cloneProfile(this.profiles[providerId] || this.profiles.default);
+  }
+  /**
+   * Get all loaded profiles
+   */
+  getAllProfiles() {
+    return cloneProfiles(this.profiles);
+  }
+  /**
+   * Check if a memory ratio requires warning
+   */
+  shouldWarn(providerId, ratio) {
+    const profile = this.getProfile(providerId);
+    return ratio >= profile.warnThreshold;
+  }
+  /**
+   * Check if memory ratio is at critical threshold
+   */
+  isCritical(providerId, ratio) {
+    const profile = this.getProfile(providerId);
+    return ratio >= profile.criticalThreshold;
+  }
+  /**
+   * Check if memory ratio is at emergency threshold
+   */
+  isEmergency(providerId, ratio) {
+    const profile = this.getProfile(providerId);
+    return ratio >= profile.emergencyThreshold;
+  }
+  /**
+   * Get graceful degradation strategy for provider
+   */
+  getGracefulDegradationStrategy(providerId) {
+    const profile = this.getProfile(providerId);
+    return profile.gracefulDegradation;
+  }
+  /**
+   * Get max concurrent processes for provider
+   */
+  getMaxProcesses(providerId) {
+    const profile = this.getProfile(providerId);
+    return profile.maxProcesses;
+  }
+  /**
+   * Reset to defaults (for testing)
+   */
+  static resetForTesting() {
+    if (_MemoryProfilesManager.instance) {
+      _MemoryProfilesManager.instance.profiles = cloneProfiles(DEFAULT_PROFILES);
+    }
+  }
+};
+function getMemoryProfilesManager() {
+  return MemoryProfilesManager.getInstance();
+}
+
+// src/core/memory/guardian.ts
+var MemoryGuardian = class _MemoryGuardian {
+  static instance;
+  trackedProcesses = /* @__PURE__ */ new Map();
+  pids = [];
+  // LIFO ordering, de-duplicated (legacy support)
+  interval;
+  isShuttingDown = false;
+  isActive = false;
+  exitHandlerRegistered = false;
+  emergencyHandler;
+  handleExit = () => {
+    this.stop();
+  };
+  // CRITICAL FIX: Track active kill operations to prevent race conditions
+  activeKillOperations = /* @__PURE__ */ new Set();
+  // Adaptive intervals (ms)
+  // Increased from 2s/1s/500ms to reduce overhead and false alarms
+  currentInterval = 1e4;
+  // Start slow (10s)
+  NORMAL_INTERVAL = 1e4;
+  // 10s when < warn threshold
+  WARNING_INTERVAL = 5e3;
+  // 5s when warn-critical
+  CRITICAL_INTERVAL = 2e3;
+  // 2s when > critical threshold
+  // Kill strategy configuration
+  // - Default: Warn at provider warn%, kill at critical%+ (hybrid approach)
+  // - BUILD_MEMORY_KILL=0: Never kill (log-only mode)
+  // - BUILD_MEMORY_KILL=1: Kill at all thresholds (aggressive mode)
+  killMode = this.getKillMode();
+  lastCheckTime = 0;
+  lastWarnTime = 0;
+  // Default thresholds (fallback if provider profiles not available)
+  DEFAULT_WARN = 0.85;
+  DEFAULT_CRIT = 0.9;
+  DEFAULT_EMRG = 0.95;
+  constructor() {
+  }
+  resolveRssLimitMb() {
+    const explicitMb = parseInt(process.env.BUILD_RSS_LIMIT_MB || "", 10);
+    if (!Number.isNaN(explicitMb) && explicitMb > 0) {
+      return explicitMb;
+    }
+    const pctRaw = process.env.BUILD_RSS_LIMIT_PCT;
+    if (!pctRaw) return null;
+    const pct = Number(pctRaw);
+    if (!Number.isFinite(pct) || pct <= 0) return null;
+    const totalMb = totalmem() / (1024 * 1024);
+    const derived = Math.floor(totalMb * pct / 100);
+    return derived > 0 ? derived : null;
+  }
+  static getInstance() {
+    if (!_MemoryGuardian.instance) {
+      _MemoryGuardian.instance = new _MemoryGuardian();
+    }
+    return _MemoryGuardian.instance;
+  }
+  /**
+   * Determine kill mode from environment variable
+   * - '0' or 'false': Never kill (log-only)
+   * - '1' or 'true': Kill at all thresholds (aggressive)
+   * - undefined or other: Hybrid (warn only at warn-crit%, kill at crit%+)
+   */
+  getKillMode() {
+    const env = process.env.BUILD_MEMORY_KILL;
+    if (env === "0" || env === "false") {
+      return "never";
+    }
+    if (env === "1" || env === "true") {
+      return "always";
+    }
+    return "hybrid";
+  }
+  /**
+   * Get memory thresholds for a provider
+   */
+  getThresholds(provider) {
+    try {
+      const profilesManager = getMemoryProfilesManager();
+      const profile = profilesManager.getProfile(provider || "default");
+      return {
+        warn: profile.warnThreshold,
+        crit: profile.criticalThreshold,
+        emrg: profile.emergencyThreshold
+      };
+    } catch {
+      return {
+        warn: this.DEFAULT_WARN,
+        crit: this.DEFAULT_CRIT,
+        emrg: this.DEFAULT_EMRG
+      };
+    }
+  }
+  /**
+   * Phase 1: Evaluate a single process memory sample and return a decision.
+   * PLM calls this instead of using hard-coded thresholds.
+   *
+   * Policy:
+   * - If no RSS limit configured (BUILD_RSS_LIMIT_MB/PCT), warn-only (never kill)
+   * - If RSS limit configured but killMode='never', warn-only
+   * - If RSS limit configured and kill enabled, kill at/above limit
+   * - Runaway (2x limit) gets immediate kill (graceMs=0)
+   */
+  evaluateProcessSample(sample) {
+    const rssLimitMB = this.resolveRssLimitMb();
+    const killEnabled = rssLimitMB !== null && this.killMode !== "never";
+    const rssMB = sample.rssMB;
+    const details = {
+      processId: sample.processId,
+      pid: sample.pid,
+      rssMB,
+      rssLimitMB,
+      provider: sample.provider ?? null,
+      command: sample.command ?? null,
+      workloadClass: sample.workloadClass,
+      killMode: this.killMode
+    };
+    if (!rssLimitMB) {
+      if (rssMB >= 1e3) {
+        return {
+          action: "warn",
+          reason: "high_rss_no_cap_configured",
+          details
+        };
+      }
+      return { action: "none" };
+    }
+    const warnAtMB = Math.floor(rssLimitMB * 0.8);
+    const runawayAtMB = rssLimitMB * 2;
+    if (rssMB >= runawayAtMB) {
+      if (!killEnabled) {
+        return { action: "warn", reason: "runaway_rss_would_kill_but_disabled", details };
+      }
+      return {
+        action: "kill",
+        reason: "runaway",
+        graceMs: 0,
+        // immediate
+        details
+      };
+    }
+    if (rssMB >= rssLimitMB) {
+      if (!killEnabled) {
+        return { action: "warn", reason: "over_cap_would_kill_but_disabled", details };
+      }
+      return {
+        action: "kill",
+        reason: "over_cap",
+        graceMs: 5e3,
+        // SIGTERM -> wait -> SIGKILL
+        details
+      };
+    }
+    if (rssMB >= warnAtMB) {
+      return { action: "warn", reason: "approaching_rss_cap", details };
+    }
+    return { action: "none" };
+  }
+  /**
+   * Start memory monitoring with adaptive intervals
+   */
+  start() {
+    if (this.isActive) return;
+    this.isActive = true;
+    this.scheduleCheck();
+    if (!this.exitHandlerRegistered) {
+      process.on("exit", this.handleExit);
+      this.exitHandlerRegistered = true;
+    }
+  }
+  /**
+   * Stop monitoring and cleanup
+   */
+  stop() {
+    this.isActive = false;
+    if (this.interval) {
+      clearTimeout(this.interval);
+      this.interval = void 0;
+    }
+    if (this.exitHandlerRegistered) {
+      process.off("exit", this.handleExit);
+      this.exitHandlerRegistered = false;
+    }
+  }
+  /**
+   * Schedule next check with adaptive interval
+   */
+  scheduleCheck() {
+    if (!this.isActive) {
+      return;
+    }
+    this.interval = setTimeout(() => {
+      this.check();
+      if (this.isActive) {
+        this.scheduleCheck();
+      }
+    }, this.currentInterval);
+  }
+  /**
+   * Ultra-lightweight memory check
+   * Target: <1ms execution time
+   */
+  check() {
+    const now = Date.now();
+    if (now - this.lastCheckTime < 100) return;
+    this.lastCheckTime = now;
+    const { heapUsed, rss } = process.memoryUsage();
+    const { heap_size_limit } = getHeapStatistics();
+    let ratio = heapUsed / heap_size_limit;
+    const rssLimitMb = this.resolveRssLimitMb();
+    if (typeof rssLimitMb === "number" && rssLimitMb > 0) {
+      const rssRatio = rss / (rssLimitMb * 1024 * 1024);
+      if (rssRatio > ratio) ratio = rssRatio;
+    }
+    const currentProvider = this.getMostCommonProvider();
+    const thresholds = this.getThresholds(currentProvider);
+    if (ratio < thresholds.warn) {
+      this.currentInterval = this.NORMAL_INTERVAL;
+      return;
+    }
+    if (ratio >= thresholds.emrg) {
+      this.emergencyKill(ratio, thresholds);
+      return;
+    }
+    if (ratio >= thresholds.crit) {
+      this.currentInterval = this.CRITICAL_INTERVAL;
+      if (!this.isShuttingDown) {
+        this.gracefulKill(ratio, thresholds);
+      }
+      return;
+    }
+    this.currentInterval = this.WARNING_INTERVAL;
+    this.warn(ratio, currentProvider);
+  }
+  /**
+   * Track a process for memory management
+   *
+   * CRITICAL FIX: Ensure atomic updates to both data structures to prevent
+   * inconsistent state between legacy array and new Map tracking systems.
+   */
+  track(pid, provider) {
+    if (!pid || pid <= 0) {
+      return;
+    }
+    const trackingInfo = {
+      pid,
+      provider,
+      startedAt: Date.now()
+    };
+    if (!this.pids.includes(pid)) {
+      this.pids.push(pid);
+    }
+    this.trackedProcesses.set(pid, trackingInfo);
+  }
+  /**
+   * Untrack a process
+   */
+  untrack(pid) {
+    const idx = this.pids.indexOf(pid);
+    if (idx !== -1) {
+      this.pids.splice(idx, 1);
+    }
+    this.trackedProcesses.delete(pid);
+  }
+  /**
+   * Get most common provider from tracked processes
+   */
+  getMostCommonProvider() {
+    const providers = /* @__PURE__ */ new Map();
+    for (const tracking of this.trackedProcesses.values()) {
+      if (tracking.provider) {
+        providers.set(tracking.provider, (providers.get(tracking.provider) || 0) + 1);
+      }
+    }
+    let maxProvider;
+    let maxCount = 0;
+    for (const [provider, count] of providers) {
+      if (count > maxCount) {
+        maxProvider = provider;
+        maxCount = count;
+      }
+    }
+    return maxProvider;
+  }
+  /**
+   * Warn (minimal logging, max once per 10s)
+   */
+  warn(ratio, provider) {
+    const now = Date.now();
+    if (now - this.lastWarnTime < 1e4) return;
+    this.lastWarnTime = now;
+    const pct = Math.floor(ratio * 100);
+    const processCount = this.trackedProcesses.size || this.pids.length;
+    emitWarning(
+      "PERF-002",
+      {
+        subsystem: "memory-guardian",
+        provider,
+        executionPhase: "execution"
+      },
+      {
+        severity: pct >= 85 ? "WARN" /* WARN */ : "INFO" /* INFO */,
+        metadata: {
+          percentage: pct,
+          processCount,
+          killMode: this.killMode,
+          threshold: "warn"
+        }
+      }
+    );
+    if (this.killMode === "never") {
+      emitWarning(
+        "CFG-002",
+        {
+          subsystem: "memory-guardian",
+          executionPhase: "execution"
+        },
+        {
+          severity: "INFO" /* INFO */,
+          metadata: {
+            setting: "BUILD_MEMORY_KILL",
+            value: "0",
+            message: "Log-only mode: Set BUILD_MEMORY_KILL=1 to enable process termination"
+          }
+        }
+      );
+    } else if (this.killMode === "hybrid") {
+      const profile = this.getThresholds(provider);
+      emitWarning(
+        "PERF-002",
+        {
+          subsystem: "memory-guardian",
+          provider,
+          executionPhase: "execution"
+        },
+        {
+          severity: "INFO" /* INFO */,
+          metadata: {
+            killThreshold: Math.floor(profile.crit * 100),
+            currentUsage: pct,
+            message: `Hybrid mode: Will kill processes at ${Math.floor(profile.crit * 100)}%+ (currently ${pct}%)`
+          }
+        }
+      );
+    }
+  }
+  /**
+   * Graceful kill - newest processes first
+   * Kill 50% of processes to free memory quickly
+   * Respects kill mode: never (log only), hybrid (kill at critical%+), always (kill at all thresholds)
+   *
+   * CRITICAL FIX: Track active kill operations to prevent race conditions and ensure
+   * proper state synchronization during concurrent kill operations.
+   */
+  gracefulKill(ratio, _thresholds = this.getThresholds()) {
+    const pct = Math.floor(ratio * 100);
+    const operationId = `graceful-${Date.now()}-${randomBytes(8).toString("hex")}`;
+    if (this.killMode === "never") {
+      const allPids2 = this.getTerminationPids();
+      emitWarning(
+        "PERF-002",
+        {
+          subsystem: "memory-guardian",
+          executionPhase: "execution"
+        },
+        {
+          severity: "ERROR" /* ERROR */,
+          metadata: {
+            percentage: pct,
+            threshold: "critical",
+            killMode: "never",
+            wouldKillCount: Math.max(1, Math.floor(allPids2.length / 2)),
+            trackedPids: allPids2,
+            message: `CRITICAL: ${pct}% memory - would kill processes (log-only mode)`
+          }
+        }
+      );
+      emitWarning(
+        "CFG-002",
+        {
+          subsystem: "memory-guardian",
+          executionPhase: "execution"
+        },
+        {
+          severity: "ERROR" /* ERROR */,
+          metadata: {
+            setting: "BUILD_MEMORY_KILL",
+            value: "0",
+            message: "Set BUILD_MEMORY_KILL=1 or remove BUILD_MEMORY_KILL=0 to enable process termination"
+          }
+        }
+      );
+      return;
+    }
+    this.activeKillOperations.add(operationId);
+    this.isShuttingDown = true;
+    const allPids = this.getTerminationPids();
+    const killCount = Math.max(1, Math.floor(allPids.length / 2));
+    emitWarning(
+      "PERF-002",
+      {
+        subsystem: "memory-guardian",
+        executionPhase: "execution"
+      },
+      {
+        severity: "ERROR" /* ERROR */,
+        metadata: {
+          percentage: pct,
+          threshold: "critical",
+          killMode: this.killMode,
+          killCount,
+          totalProcesses: allPids.length,
+          operationId,
+          message: `CRITICAL: ${pct}% memory - killing newest processes (${this.killMode} mode)`
+        }
+      }
+    );
+    const killedPids = [];
+    for (let i = 0; i < killCount && allPids.length > 0; i++) {
+      const pid = allPids.pop();
+      try {
+        process.kill(pid, "SIGTERM");
+        killedPids.push(pid);
+      } catch {
+      }
+    }
+    emitWarning(
+      "PERF-002",
+      {
+        subsystem: "memory-guardian",
+        executionPhase: "cleanup"
+      },
+      {
+        severity: "ERROR" /* ERROR */,
+        metadata: {
+          killedCount: killedPids.length,
+          killedPids,
+          operationId,
+          message: `Killed ${killedPids.length} processes: ${killedPids.join(", ")}`
+        }
+      }
+    );
+    setTimeout(() => {
+      try {
+        for (const pid of killedPids) {
+          try {
+            process.kill(pid, 0);
+            try {
+              process.kill(pid, "SIGKILL");
+            } catch {
+            }
+          } catch {
+          }
+        }
+      } finally {
+        this.activeKillOperations.delete(operationId);
+        if (this.activeKillOperations.size === 0) {
+          this.isShuttingDown = false;
+        }
+        emitWarning(
+          "PERF-002",
+          {
+            subsystem: "memory-guardian",
+            executionPhase: "cleanup"
+          },
+          {
+            severity: "INFO" /* INFO */,
+            metadata: {
+              operationId,
+              message: "Graceful kill operation completed"
+            }
+          }
+        );
+      }
+    }, 3e3);
+  }
+  /**
+   * Emergency kill - all processes immediately
+   * Last resort at emergency% heap usage
+   * Respects kill mode: never (log only), hybrid/always (kill all processes)
+   *
+   * CRITICAL FIX: Add proper error handling and cleanup to prevent
+   * inconsistent state during emergency termination.
+   */
+  emergencyKill(ratio, _thresholds = this.getThresholds()) {
+    const pct = Math.floor(ratio * 100);
+    const operationId = `emergency-${Date.now()}-${randomBytes(8).toString("hex")}`;
+    this.activeKillOperations.add(operationId);
+    try {
+      if (this.killMode === "never") {
+        const allPids2 = this.getTerminationPids();
+        emitWarning(
+          "PERF-002",
+          {
+            subsystem: "memory-guardian",
+            executionPhase: "execution"
+          },
+          {
+            severity: "ERROR" /* ERROR */,
+            metadata: {
+              percentage: pct,
+              threshold: "emergency",
+              killMode: "never",
+              wouldKillCount: allPids2.length,
+              trackedPids: allPids2,
+              operationId,
+              message: `EMERGENCY: ${pct}% memory - would kill ALL processes (log-only mode)`
+            }
+          }
+        );
+        emitWarning(
+          "CFG-002",
+          {
+            subsystem: "memory-guardian",
+            executionPhase: "execution"
+          },
+          {
+            severity: "ERROR" /* ERROR */,
+            metadata: {
+              setting: "BUILD_MEMORY_KILL",
+              value: "0",
+              criticalWarning: "SYSTEM AT RISK OF OOM CRASH - Manual intervention strongly recommended",
+              message: "Set BUILD_MEMORY_KILL=1 or remove BUILD_MEMORY_KILL=0 to enable process termination"
+            }
+          }
+        );
+        return;
+      }
+      const limiterOwned = this.getTrackedPids().length === 0;
+      const allPids = this.getTerminationPids();
+      if (allPids.length === 0) {
+        emitWarning(
+          "PERF-002",
+          {
+            subsystem: "memory-guardian",
+            executionPhase: "execution"
+          },
+          {
+            severity: "ERROR" /* ERROR */,
+            metadata: {
+              percentage: pct,
+              threshold: "emergency",
+              processCount: 0,
+              operationId,
+              action: "skipping forced exit to prevent data loss",
+              message: `EMERGENCY: ${pct}% memory - no tracked child processes`
+            }
+          }
+        );
+        this.currentInterval = this.CRITICAL_INTERVAL;
+        return;
+      }
+      emitWarning(
+        "PERF-002",
+        {
+          subsystem: "memory-guardian",
+          executionPhase: "execution"
+        },
+        {
+          severity: "ERROR" /* ERROR */,
+          metadata: {
+            percentage: pct,
+            threshold: "emergency",
+            killMode: this.killMode,
+            killCount: allPids.length,
+            operationId,
+            message: `EMERGENCY: ${pct}% memory - killing ALL ${allPids.length} processes (${this.killMode} mode)`
+          }
+        }
+      );
+      const killedCount = allPids.length;
+      const successfulKills = [];
+      const failedKills = [];
+      for (const pid of allPids) {
+        try {
+          if (limiterOwned && process.platform !== "win32") {
+            try {
+              signalProcessGroup(pid, "SIGKILL");
+            } catch {
+              process.kill(pid, "SIGKILL");
+            }
+          } else {
+            process.kill(pid, "SIGKILL");
+          }
+          successfulKills.push(pid);
+        } catch (error) {
+          failedKills.push({ pid, error });
+        }
+      }
+      emitWarning(
+        "PERF-002",
+        {
+          subsystem: "memory-guardian",
+          executionPhase: "cleanup"
+        },
+        {
+          severity: "ERROR" /* ERROR */,
+          metadata: {
+            successfulKills: successfulKills.length,
+            totalAttempted: killedCount,
+            killedPids: successfulKills,
+            operationId,
+            message: `Force-killed ${successfulKills.length}/${killedCount} processes to prevent crash`
+          }
+        }
+      );
+      if (failedKills.length > 0) {
+        emitWarning(
+          "PERF-002",
+          {
+            subsystem: "memory-guardian",
+            executionPhase: "cleanup"
+          },
+          {
+            severity: "ERROR" /* ERROR */,
+            metadata: {
+              failedCount: failedKills.length,
+              failedPids: failedKills.map((f) => f.pid),
+              operationId,
+              message: `Failed to kill ${failedKills.length} processes: ${failedKills.map((f) => f.pid).join(", ")}`
+            }
+          }
+        );
+      }
+      this.pids.length = 0;
+      this.trackedProcesses.clear();
+      this.stop();
+      const handler = this.emergencyHandler;
+      if (handler) {
+        try {
+          handler({ pct, killedCount: successfulKills.length, pids: successfulKills });
+        } catch (handlerError) {
+          emitWarning(
+            "PERF-002",
+            {
+              subsystem: "memory-guardian",
+              executionPhase: "cleanup"
+            },
+            {
+              severity: "ERROR" /* ERROR */,
+              metadata: {
+                error: String(handlerError),
+                operationId,
+                message: `Emergency handler failed: ${handlerError}`
+              }
+            }
+          );
+          requestProcessExit(1);
+        }
+      } else {
+        requestProcessExit(1);
+      }
+    } finally {
+      this.activeKillOperations.delete(operationId);
+    }
+  }
+  /**
+   * Get current memory status (for debugging)
+   */
+  getStatus() {
+    const usage = process.memoryUsage();
+    const { heap_size_limit } = getHeapStatistics();
+    return {
+      heapUsedMB: Math.round(usage.heapUsed / 1024 / 1024),
+      heapTotalMB: Math.round(heap_size_limit / 1024 / 1024),
+      heapUsedPercent: Math.round(usage.heapUsed / heap_size_limit * 100),
+      processCount: Math.max(this.trackedProcesses.size, this.pids.length),
+      interval: this.currentInterval,
+      mostCommonProvider: this.getMostCommonProvider()
+    };
+  }
+  /**
+   * Get tracked PIDs (for testing)
+   */
+  getTrackedPids() {
+    return [
+      ...this.trackedProcesses.keys(),
+      ...this.pids.filter((p) => !this.trackedProcesses.has(p))
+    ];
+  }
+  /**
+   * One ownership policy for both termination stages. Preserve direct tracking
+   * precedence; competition parents fall back to the workers they registered
+   * with the process limiter. Return oldest first for newest-first shedding.
+   */
+  getTerminationPids() {
+    const direct = this.getTrackedPids();
+    if (direct.length > 0) return direct;
+    return globalProcessLimiter.getTrackedProcesses().filter(
+      (tracked) => tracked.pid !== void 0 && Number.isInteger(tracked.pid) && tracked.pid > 0
+    ).sort((a, b) => b.ageMs - a.ageMs).map((tracked) => tracked.pid);
+  }
+  /**
+   * Check if log-only mode is enabled
+   */
+  isLogOnly() {
+    return this.killMode === "never";
+  }
+  /**
+   * Get current kill mode
+   */
+  getKillModeStatus() {
+    return this.killMode;
+  }
+  /**
+   * Register an emergency handler. If set, the guardian will call this instead of exiting.
+   */
+  setEmergencyHandler(handler) {
+    this.emergencyHandler = handler;
+  }
+  /**
+   * Reset instance (for testing only)
+   */
+  static resetForTesting() {
+    if (_MemoryGuardian.instance) {
+      if (_MemoryGuardian.instance.exitHandlerRegistered) {
+        process.off("exit", _MemoryGuardian.instance.handleExit);
+        _MemoryGuardian.instance.exitHandlerRegistered = false;
+      }
+      _MemoryGuardian.instance.stop();
+      _MemoryGuardian.instance.pids.length = 0;
+      _MemoryGuardian.instance.trackedProcesses.clear();
+      _MemoryGuardian.instance.isShuttingDown = false;
+      _MemoryGuardian.instance.lastCheckTime = 0;
+      _MemoryGuardian.instance.lastWarnTime = 0;
+      _MemoryGuardian.instance.currentInterval = 1e4;
+    }
+    _MemoryGuardian.instance = void 0;
+  }
+};
+
+// src/core/providers/shared/subprocess-tracking.ts
+var logger = createLogger("ProviderRunner");
+function trackSubprocess(subprocess) {
+  if (!subprocess) {
+    return null;
+  }
+  const guardian = MemoryGuardian.getInstance();
+  const trackedPid = typeof subprocess.pid === "number" && subprocess.pid > 0 ? subprocess.pid : null;
+  if (trackedPid) {
+    guardian.track(trackedPid);
+  }
+  return trackedPid;
+}
+var subprocessFallbackTracking = /* @__PURE__ */ new WeakMap();
+var fallbackSubprocesses = /* @__PURE__ */ new Map();
+var fallbackCleanupRegistered = false;
+function getFallbackTrackedSubprocesses() {
+  return Array.from(fallbackSubprocesses.values());
+}
+function killAllFallbackTrackedSubprocesses(signal = "SIGTERM") {
+  let killed = 0;
+  for (const subprocess of getFallbackTrackedSubprocesses()) {
+    if (killFallbackSubprocess(subprocess, signal)) {
+      killed += 1;
+    }
+  }
+  return killed;
+}
+var fallbackExitHandler;
+function registerFallbackCleanup() {
+  if (fallbackCleanupRegistered) {
+    return;
+  }
+  fallbackCleanupRegistered = true;
+  fallbackExitHandler = () => {
+    killAllFallbackTrackedSubprocesses("SIGTERM");
+    killAllFallbackTrackedSubprocesses("SIGKILL");
+  };
+  process.removeListener("exit", fallbackExitHandler);
+  process.on("exit", fallbackExitHandler);
+}
+function killFallbackSubprocess(subprocess, signal = "SIGTERM") {
+  try {
+    return sendSignalToSubprocessTree(subprocess, signal);
+  } catch (error) {
+    logger.warn(`[BaseRunner] Failed to kill fallback subprocess: ${error}`);
+    return false;
+  }
+}
+async function trackSubprocessAsync(subprocess) {
+  if (!subprocess) {
+    return null;
+  }
+  const guardian = MemoryGuardian.getInstance();
+  let trackedPid = null;
+  const maxPidWaitMs = Math.max(250, readEnv(BUILD_SUBPROCESS_PID_WAIT_MS).value ?? 2e3);
+  await new Promise((resolve) => {
+    let settled = false;
+    let pollInterval;
+    const finish = () => {
+      if (settled) return;
+      settled = true;
+      if (pollInterval) {
+        clearInterval(pollInterval);
+      }
+      resolve();
+    };
+    const exitListener = () => {
+      finish();
+    };
+    subprocess.once?.("exit", exitListener);
+    subprocess.once?.("close", exitListener);
+    if (typeof subprocess.pid === "number" && subprocess.pid > 0) {
+      trackedPid = subprocess.pid;
+      guardian.track(subprocess.pid);
+      finish();
+    } else {
+      const PID_POLL_INTERVAL_MS = 25;
+      const startTime = Date.now();
+      pollInterval = setInterval(() => {
+        if (typeof subprocess.pid === "number" && subprocess.pid > 0) {
+          trackedPid = subprocess.pid;
+          guardian.track(subprocess.pid);
+          finish();
+        } else if (Date.now() - startTime >= maxPidWaitMs) {
+          if (!subprocess.killed && (subprocess.exitCode ?? null) === null) {
+            const subprocessId = /* @__PURE__ */ Symbol("subprocess-fallback");
+            subprocessFallbackTracking.set(subprocess, subprocessId);
+            fallbackSubprocesses.set(subprocessId, subprocess);
+            registerFallbackCleanup();
+            logger.warn(
+              `[BaseRunner] PID not available after ${maxPidWaitMs}ms - using fallback tracking by subprocess reference`,
+              { maxWaitMs: maxPidWaitMs }
+            );
+          }
+          finish();
+        }
+      }, PID_POLL_INTERVAL_MS);
+      pollInterval.unref?.();
+    }
+  });
+  return trackedPid;
+}
+function untrackSubprocess(trackedPid, subprocess) {
+  if (trackedPid) {
+    const guardian = MemoryGuardian.getInstance();
+    guardian.untrack(trackedPid);
+  } else if (subprocess) {
+    const subprocessId = subprocessFallbackTracking.get(subprocess);
+    if (subprocessId) {
+      fallbackSubprocesses.delete(subprocessId);
+      subprocessFallbackTracking.delete(subprocess);
+    }
+  }
+}
+
+// src/core/providers/shared/base-runner.ts
+var logger2 = createLogger("ProviderRunner");
+var PROVIDER_TERMINATION_GRACE_MS = 2e3;
+var PROVIDER_ARGV_PAYLOAD_REDACTION = "[argv-redacted]";
+var PROVIDER_SINGLE_ARG_MAX_SAFE_BYTES = 128 * 1024;
+var PROVIDER_PROCESS_ARG_ENV_MAX_SAFE_BYTES = 256 * 1024;
+function computePromptFingerprint(prompt) {
+  return createHash("sha256").update(prompt).digest("hex");
+}
+var DEFAULT_TIMEOUT = DEFAULT_TIMEOUT_MS;
+var DEFAULT_STREAM_CAPTURE_BYTES = 1024 * 1024;
+function throwIfAbortAlreadyRequested(abortSignal, providerName) {
+  if (!abortSignal?.aborted) {
+    return;
+  }
+  const hostTimeout = isHostTimeoutAbortReason(abortSignal.reason);
+  const detail = hostTimeout ? formatHostTimeoutTerminationDetail(abortSignal.reason) : void 0;
+  throw new ProviderExecutionError(
+    `[${providerName}] Provider execution aborted before subprocess start${detail ? ` (${detail})` : ""}`,
+    {
+      retryable: false,
+      reason: hostTimeout ? "timeout" : "abort",
+      terminationSource: "abortSignal",
+      providerName
+    }
+  );
+}
+var BoundedOutputBuffer = class {
+  chunks = [];
+  bytes = 0;
+  append(chunk, maxBytes) {
+    if (!chunk) {
+      return;
+    }
+    if (!Number.isFinite(maxBytes) || maxBytes <= 0) {
+      this.clear();
+      return;
+    }
+    const boundedMaxBytes = Math.floor(maxBytes);
+    if (boundedMaxBytes <= 0) {
+      this.clear();
+      return;
+    }
+    const nextChunk = chunk;
+    const nextChunkBytes = Buffer.byteLength(nextChunk, "utf8");
+    if (nextChunkBytes >= boundedMaxBytes) {
+      const tail = trimUtf8Tail(nextChunk, boundedMaxBytes);
+      this.chunks.length = 0;
+      this.bytes = 0;
+      if (tail.text) {
+        this.chunks.push(tail.text);
+        this.bytes = tail.bytes;
+      }
+      return;
+    }
+    this.chunks.push(nextChunk);
+    this.bytes += nextChunkBytes;
+    while (this.bytes > boundedMaxBytes && this.chunks.length > 0) {
+      const overflowBytes = this.bytes - boundedMaxBytes;
+      const first = this.chunks[0] ?? "";
+      const firstBytes = Buffer.byteLength(first, "utf8");
+      if (firstBytes <= overflowBytes) {
+        this.chunks.shift();
+        this.bytes -= firstBytes;
+        continue;
+      }
+      const trimmed = trimUtf8Tail(first, firstBytes - overflowBytes);
+      if (trimmed.text) {
+        this.chunks[0] = trimmed.text;
+        this.bytes = this.bytes - firstBytes + trimmed.bytes;
+      } else {
+        this.chunks.shift();
+        this.bytes -= firstBytes;
+      }
+      break;
+    }
+  }
+  toString() {
+    return this.chunks.join("");
+  }
+  clear() {
+    this.chunks.length = 0;
+    this.bytes = 0;
+  }
+};
+function trimUtf8Tail(text, maxBytes) {
+  if (!Number.isFinite(maxBytes) || maxBytes <= 0) {
+    return { text: "", bytes: 0 };
+  }
+  const buffer = Buffer.from(text, "utf8");
+  if (buffer.length <= maxBytes) {
+    return { text, bytes: buffer.length };
+  }
+  let start = buffer.length - Math.floor(maxBytes);
+  while (start < buffer.length && ((buffer[start] ?? 0) & 192) === 128) {
+    start += 1;
+  }
+  const tail = buffer.subarray(start);
+  return { text: tail.toString("utf8"), bytes: tail.length };
+}
+function sanitizeExecutionEnv(env, options) {
+  if (!env) {
+    if (isDebugMode()) {
+      console.warn("[BaseRunner] executeProviderCommand fallbacked to marker-stripped process.env");
+    }
+    return createCleanChildEnv();
+  }
+  const sanitized = stripClaudeSessionEnv(env);
+  for (const key of Object.keys(sanitized)) {
+    if (isSandboxAuthorityEnvVar(key)) {
+      delete sanitized[key];
+    }
+  }
+  if (options?.preserveClaudeBackendFlags === true) {
+    if (env.CLAUDE_CODE_USE_BEDROCK !== void 0) {
+      sanitized.CLAUDE_CODE_USE_BEDROCK = env.CLAUDE_CODE_USE_BEDROCK;
+    }
+    if (env.CLAUDE_CODE_USE_VERTEX !== void 0) {
+      sanitized.CLAUDE_CODE_USE_VERTEX = env.CLAUDE_CODE_USE_VERTEX;
+    }
+    if (env.CLAUDE_CODE_USE_FOUNDRY !== void 0) {
+      sanitized.CLAUDE_CODE_USE_FOUNDRY = env.CLAUDE_CODE_USE_FOUNDRY;
+    }
+  }
+  return sanitized;
+}
+function resolveCommandName(command) {
+  const posix = path2.posix.basename(command);
+  const win32 = path2.win32.basename(command);
+  const basename = posix.length <= win32.length ? posix : win32;
+  return basename.replace(/\.(exe|cmd|bat|ps1)$/i, "").toUpperCase().replace(/[^A-Z0-9]/g, "_");
+}
+function redactProviderArgvForRunnerDiagnostics(args) {
+  return redactProviderArgv(args).map((arg) => {
+    if (arg === "[REDACTED]") return arg;
+    if (/[\r\n]/.test(arg)) return PROVIDER_ARGV_PAYLOAD_REDACTION;
+    if (/\s/.test(arg)) return PROVIDER_ARGV_PAYLOAD_REDACTION;
+    if (arg.length > 200) return PROVIDER_ARGV_PAYLOAD_REDACTION;
+    return arg;
+  });
+}
+function formatRedactedCommandSignature(command, args) {
+  const [redactedCommand = command] = redactProviderArgv([command]);
+  return [redactedCommand, ...redactProviderArgvForRunnerDiagnostics(args)].join(" ").trim();
+}
+function logPlmVerificationFailure(details) {
+  logger2.warn(`[BaseRunner] PLM verification failed for ${details.provider}`, {
+    provider: details.provider,
+    command: details.command,
+    argCount: details.args.length,
+    exitCode: details.code,
+    signal: details.signal,
+    hasExited: details.hasExited,
+    stderr: sanitizeDiagnosticOutput(details.stderr, 2e3)
+  });
+}
+function hasPlmExitEvidence(details) {
+  return details.hasExited || details.code !== null || details.signal !== null;
+}
+var TERMINATION_PRIORITY = {
+  abort: 100,
+  hard_timeout: 90,
+  timeout: 80,
+  plm_timeout: 70,
+  plm_abort: 60,
+  plm_cancelled: 50,
+  idle_timeout: 40,
+  unknown: 0
+};
+function createProviderTerminationController(params) {
+  const { subprocess, startTime, timeout, providerName, command } = params;
+  const processState = {
+    hasExited: false,
+    exitCode: null,
+    exitSignal: null,
+    exitAt: null,
+    sigtermSentAt: null,
+    sigkillSentAt: null
+  };
+  const terminationState = {
+    attempts: [],
+    getPrimaryRecord() {
+      const activeAttempts = this.attempts.filter((attempt) => attempt.requestedAfterExit !== true);
+      if (activeAttempts.length === 0) return null;
+      const priorityFor = (reason) => TERMINATION_PRIORITY[reason] ?? 0;
+      return activeAttempts.reduce((best, current) => {
+        const bestPriority = priorityFor(best.reason);
+        const currentPriority = priorityFor(current.reason);
+        return currentPriority > bestPriority ? current : best;
+      });
+    }
+  };
+  let hardTimeoutTimer;
+  let terminationForceKillTimer;
+  let stdioClosed = false;
+  const exitWaiters = /* @__PURE__ */ new Set();
+  const clearTerminationTimer = () => {
+    if (hardTimeoutTimer) {
+      clearTimeout(hardTimeoutTimer);
+      hardTimeoutTimer = void 0;
+    }
+    if (terminationForceKillTimer) {
+      clearTimeout(terminationForceKillTimer);
+      terminationForceKillTimer = void 0;
+    }
+  };
+  const markExited = (code, signal) => {
+    if (processState.hasExited) return;
+    processState.hasExited = true;
+    processState.exitCode = code;
+    processState.exitSignal = signal;
+    processState.exitAt = Date.now();
+    for (const resolve of exitWaiters) {
+      resolve();
+    }
+    exitWaiters.clear();
+  };
+  const waitForExitOrTimeout = async (timeoutMs) => {
+    if (processState.hasExited || timeoutMs <= 0) return;
+    await new Promise((resolve) => {
+      let timer;
+      const finish = () => {
+        if (timer) {
+          clearTimeout(timer);
+        }
+        exitWaiters.delete(finish);
+        resolve();
+      };
+      exitWaiters.add(finish);
+      timer = setTimeout(finish, timeoutMs);
+      timer.unref?.();
+    });
+  };
+  subprocess.on("exit", (code, signal) => {
+    markExited(code, signal ?? null);
+  });
+  subprocess.on("close", (code, signal) => {
+    markExited(code, signal ?? null);
+    stdioClosed = true;
+    clearTerminationTimer();
+  });
+  const requestTermination = (reason, source, detail, boundaryEvent) => {
+    const record = {
+      reason,
+      source,
+      detail,
+      requestedAt: Date.now(),
+      requestedAfterExit: processState.hasExited
+    };
+    terminationState.attempts.push(record);
+    if (processState.hasExited) {
+      if (!stdioClosed && processState.sigkillSentAt === null) {
+        if (sendSignalToSubprocessTree(subprocess, "SIGKILL")) {
+          processState.sigkillSentAt = Date.now();
+        }
+      }
+      return true;
+    }
+    const isFirstRequest = terminationState.attempts.length === 1;
+    if (!isFirstRequest) {
+      return false;
+    }
+    if (reason === "idle_timeout") {
+      emitBoundaryTriggered({
+        trigger: "idle",
+        workloadClass: "agent-run",
+        effectiveCeilingMs: timeout,
+        elapsedMs: Math.max(0, Date.now() - startTime),
+        source: "base-runner",
+        idleDurationMs: boundaryEvent?.idleDurationMs,
+        metadata: {
+          provider: providerName,
+          command
+        }
+      });
+    } else if (reason === "hard_timeout" || reason === "timeout" || reason === "plm_timeout") {
+      emitBoundaryTriggered({
+        trigger: "ceiling",
+        workloadClass: "agent-run",
+        effectiveCeilingMs: timeout,
+        elapsedMs: Math.max(0, Date.now() - startTime),
+        source: "base-runner",
+        metadata: {
+          provider: providerName,
+          command
+        }
+      });
+    }
+    if (processState.sigtermSentAt === null) {
+      if (sendSignalToSubprocessTree(subprocess, "SIGTERM")) {
+        processState.sigtermSentAt = Date.now();
+      }
+    }
+    terminationForceKillTimer = setTimeout(() => {
+      if (stdioClosed) return;
+      if (processState.sigkillSentAt !== null) return;
+      if (sendSignalToSubprocessTree(subprocess, "SIGKILL")) {
+        processState.sigkillSentAt = Date.now();
+      }
+    }, PROVIDER_TERMINATION_GRACE_MS);
+    terminationForceKillTimer.unref?.();
+    return true;
+  };
+  if (Number.isFinite(timeout) && timeout > 0) {
+    hardTimeoutTimer = setTimeout(() => {
+      requestTermination(
+        "timeout",
+        "base-runner:hard-timeout",
+        `timeout after ${Math.round(timeout / 1e3)}s`
+      );
+    }, timeout);
+    hardTimeoutTimer.unref?.();
+  }
+  return {
+    processState,
+    terminationState,
+    requestTermination,
+    markExited,
+    clearTerminationTimer,
+    waitForExitOrTimeout
+  };
+}
+async function drainProviderTerminationGrace(terminationController) {
+  const { processState } = terminationController;
+  if (terminationController.terminationState.getPrimaryRecord() === null) return;
+  if (processState.hasExited) return;
+  if (processState.sigtermSentAt === null) return;
+  if (processState.sigkillSentAt !== null) return;
+  const elapsedMs = Date.now() - processState.sigtermSentAt;
+  const remainingMs = Math.max(0, PROVIDER_TERMINATION_GRACE_MS - elapsedMs);
+  if (remainingMs > 0) {
+    await terminationController.waitForExitOrTimeout(remainingMs);
+  }
+}
+function trackProviderSubprocess(subprocess, mode) {
+  return mode === "async" ? trackSubprocessAsync(subprocess) : trackSubprocess(subprocess);
+}
+function registerProviderProcessLimiter(params) {
+  const {
+    subprocess,
+    limiterDescription,
+    timeout,
+    reservation,
+    requestTermination,
+    trackedPid,
+    onRegistrationFailure
+  } = params;
+  try {
+    return globalProcessLimiter.track(
+      subprocess,
+      limiterDescription,
+      timeout,
+      (request) => {
+        const detail = `timeout after ${Math.round(request.timeoutMs / 1e3)}s`;
+        requestTermination(request.reason, request.source, detail);
+      },
+      reservation
+    );
+  } catch (err) {
+    sendSignalToSubprocessTree(subprocess, "SIGKILL");
+    untrackSubprocess(trackedPid, subprocess);
+    try {
+      onRegistrationFailure?.();
+    } catch {
+    }
+    throw err;
+  }
+}
+async function registerProviderProcessLifecycle(params) {
+  const {
+    subprocess,
+    completionPromise,
+    processState,
+    exitStatus,
+    requestTermination,
+    activityState,
+    stderrChunks,
+    providerName,
+    command,
+    args,
+    workingDir,
+    ownsProcessGroup
+  } = params;
+  try {
+    const plm = getProcessLifecycleManager();
+    if (!plm) {
+      return void 0;
+    }
+    return await plm.registerProcessWithOptions({
+      completionPromise,
+      terminateFn: async (request) => {
+        const mappedReason = request.reason === "timeout" ? "hard_timeout" : `plm_${request.reason}`;
+        const detail = `PLM requested termination: ${request.reason}`;
+        requestTermination(mappedReason, request.source, detail);
+      },
+      verificationFn: async () => {
+        const code = processState.exitCode ?? exitStatus.code ?? subprocess.exitCode ?? null;
+        const signal = processState.exitSignal ?? exitStatus.signal ?? subprocess?.signal ?? null;
+        const verified = hasPlmExitEvidence({
+          code,
+          signal: signal == null ? null : String(signal),
+          hasExited: processState.hasExited
+        });
+        if (!verified) {
+          logPlmVerificationFailure({
+            provider: providerName,
+            command,
+            args,
+            code,
+            signal: signal == null ? null : String(signal),
+            hasExited: processState.hasExited,
+            stderr: stderrChunks.join("").trim().slice(0, 2e3)
+          });
+        }
+        return verified;
+      },
+      processType: "local",
+      timeoutMs: 0,
+      metadata: {
+        provider: providerName,
+        command,
+        args,
+        cwd: workingDir,
+        startTime: Date.now()
+      },
+      progressCallback: async () => ({
+        filesChanged: 0,
+        outputLines: activityState.outputLines,
+        lastActivityTimestamp: activityState.lastActivityAt
+      }),
+      childProcess: subprocess,
+      ownsProcessGroup
+    });
+  } catch (err) {
+    logger2.warn(`[BaseRunner] ProcessLifecycleManager registration failed: ${err}`, {
+      provider: providerName
+    });
+    return void 0;
+  }
+}
+function startProviderIdleMonitor(params) {
+  const {
+    subprocess,
+    activityState,
+    terminationState,
+    requestTermination,
+    command,
+    timeout,
+    providerName,
+    variantLabel,
+    commandSignature,
+    stderrChunks,
+    onActivity,
+    onIdleTermination,
+    idleTimeouts
+  } = params;
+  if (!idleTimeouts) {
+    return void 0;
+  }
+  const { warnMs, killMs } = idleTimeouts;
+  const idlePollMs = Math.max(250, Math.min(3e4, Math.floor(warnMs / 2)));
+  if (isDebugMode() || isTimeoutDebug()) {
+    logger2.debug(
+      `[BaseRunner] Idle config (${providerName}) variant=${variantLabel} timeout=${timeout}ms warn=${warnMs}ms kill=${killMs}ms poll=${idlePollMs}ms command=${commandSignature}`,
+      {
+        provider: providerName,
+        variantLabel,
+        timeout,
+        warnMs,
+        killMs,
+        idlePollMs,
+        command: commandSignature
+      }
+    );
+  }
+  let idleWarned = false;
+  let lastCpuTimeSeconds;
+  const idleMonitorInterval = setInterval(() => {
+    if (terminationState.attempts.length > 0) return;
+    const now = Date.now();
+    const pid = subprocess?.pid;
+    const currentCpuSeconds = typeof pid === "number" ? readCpuTimeSeconds(pid) : void 0;
+    const cpuActivity = evaluateCpuTimeProgressStreak({
+      currentCpuSeconds,
+      previousCpuSeconds: lastCpuTimeSeconds,
+      currentBusyPolls: activityState.consecutiveBusyCpuPolls
+    });
+    lastCpuTimeSeconds = currentCpuSeconds;
+    activityState.consecutiveBusyCpuPolls = cpuActivity.nextBusyPolls;
+    if (cpuActivity.shouldCountAsActivity) {
+      activityState.lastActivityAt = now;
+      onActivity?.({ source: "cpu", timestampMs: now });
+    }
+    const idleFor = now - activityState.lastActivityAt;
+    if (!idleWarned && idleFor >= warnMs) {
+      idleWarned = true;
+      logger2.warn(
+        `[BaseRunner] ${providerName} subprocess appears idle for ${Math.round(idleFor / 1e3)}s (warn=${Math.round(warnMs / 1e3)}s kill=${Math.round(killMs / 1e3)}s) - ${command}`,
+        {
+          provider: providerName,
+          command,
+          idleForMs: Math.round(idleFor / 1e3) * 1e3,
+          warnMs,
+          killMs
+        }
+      );
+    }
+    if (idleFor >= killMs) {
+      const detail = `idle timeout after ${Math.round(killMs / 1e3)}s with no stdout/stderr/CPU activity`;
+      const recentStderr = stderrChunks.join("").trim();
+      if (recentStderr) {
+        const sanitizedRecentStderr = sanitizeError(new Error(recentStderr.slice(-500))).message;
+        logger2.warn(`[BaseRunner] Recent stderr before idle kill:
+${sanitizedRecentStderr}`, {
+          provider: providerName,
+          command,
+          idleForMs: Math.round(idleFor / 1e3) * 1e3,
+          warnMs,
+          killMs
+        });
+      }
+      onIdleTermination?.();
+      const won = requestTermination("idle_timeout", "base-runner:idle-monitor", detail, {
+        idleDurationMs: Math.round(idleFor / 1e3) * 1e3
+      });
+      if (won) {
+        logger2.warn(`[BaseRunner] Terminating idle subprocess (${providerName}): ${detail}`, {
+          provider: providerName,
+          command,
+          idleForMs: Math.round(idleFor / 1e3) * 1e3,
+          warnMs,
+          killMs
+        });
+      }
+    }
+  }, idlePollMs);
+  idleMonitorInterval.unref?.();
+  return idleMonitorInterval;
+}
+function startProviderTimeoutWatchdog(params) {
+  const { processState, startTime, timeout, providerName } = params;
+  return setInterval(() => {
+    const elapsed = Date.now() - startTime;
+    if (elapsed > timeout * 0.75 && !processState.hasExited) {
+      logger2.debug(
+        `[BaseRunner] Subprocess approaching timeout (${Math.round(elapsed / 1e3)}s / ${Math.round(timeout / 1e3)}s) - ${providerName}`,
+        {
+          provider: providerName,
+          elapsedMs: Math.round(elapsed),
+          timeoutMs: timeout
+        }
+      );
+    }
+  }, 3e4);
+}
+function removeStreamDataListener(subprocess, streamName, listener) {
+  try {
+    const stream = subprocess?.[streamName];
+    if (typeof stream?.removeListener === "function") {
+      stream.removeListener("data", listener);
+    } else if (typeof stream?.off === "function") {
+      stream.off("data", listener);
+    }
+  } catch {
+  }
+}
+function cleanupProviderExecutionResources(params) {
+  const {
+    watchdogInterval,
+    idleMonitorInterval,
+    terminationController,
+    abortSignal,
+    abortListener,
+    subprocess,
+    stdoutDataListener,
+    stderrListener,
+    plmProcessId,
+    limiterId,
+    trackedPid,
+    workingDir,
+    providerName
+  } = params;
+  if (watchdogInterval) {
+    clearInterval(watchdogInterval);
+  }
+  if (idleMonitorInterval) {
+    clearInterval(idleMonitorInterval);
+  }
+  terminationController.clearTerminationTimer();
+  if (abortSignal && abortListener) {
+    abortSignal.removeEventListener("abort", abortListener);
+  }
+  removeStreamDataListener(subprocess, "stdout", stdoutDataListener);
+  removeStreamDataListener(subprocess, "stderr", stderrListener);
+  const cleanupErrors = [];
+  const { processState } = terminationController;
+  if (!processState.hasExited) {
+    if (processState.sigtermSentAt === null) {
+      if (sendSignalToSubprocessTree(subprocess, "SIGTERM")) {
+        processState.sigtermSentAt = Date.now();
+      }
+    }
+    if (processState.sigkillSentAt === null) {
+      if (sendSignalToSubprocessTree(subprocess, "SIGKILL")) {
+        processState.sigkillSentAt = Date.now();
+      }
+    }
+  }
+  if (plmProcessId) {
+    try {
+      const plm = getProcessLifecycleManager();
+      plm?.unregisterProcess(plmProcessId);
+    } catch (error) {
+      cleanupErrors.push(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+  if (limiterId !== void 0) {
+    try {
+      globalProcessLimiter.untrack(limiterId);
+    } catch (error) {
+      cleanupErrors.push(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+  try {
+    untrackSubprocess(trackedPid, subprocess);
+  } catch (error) {
+    cleanupErrors.push(error instanceof Error ? error : new Error(String(error)));
+  }
+  if (cleanupErrors.length > 0) {
+    try {
+      const telemetryLogger = TelemetryLogger.getInstance({
+        buildDir: resolveTelemetryBuildDir(workingDir)
+      });
+      telemetryLogger.logCostEvent("resource_cleanup_failed", {
+        errors: cleanupErrors.map((e) => e.message),
+        errorCount: cleanupErrors.length,
+        limiterId: limiterId ?? null,
+        pid: trackedPid ?? null,
+        provider: providerName,
+        timestamp: Date.now()
+      });
+    } catch (telemetryError) {
+      logger2.warn(`Failed to log cleanup error to telemetry: ${telemetryError}`);
+    }
+    logger2.warn("Resource cleanup errors occurred:", {
+      provider: providerName,
+      errorCount: cleanupErrors.length,
+      limiterId: limiterId ?? null,
+      pid: trackedPid ?? null
+    });
+    if (process.env.NODE_ENV === "test") {
+      logger2.error(
+        `[BaseRunner] Resource cleanup failed: ${cleanupErrors.length} error(s) - ${cleanupErrors.map((e) => e.message).join("; ")}`,
+        void 0,
+        {
+          provider: providerName,
+          errorCount: cleanupErrors.length,
+          limiterId: limiterId ?? null,
+          pid: trackedPid ?? null
+        }
+      );
+    }
+  }
+}
+function prepareCommand(command, args, workingDir, metadata, sandboxOptions) {
+  if (sandboxOptions?.disableBuildSandbox === true) {
+    return { command, args, sandboxed: false };
+  }
+  const result = wrapWithSandbox({
+    workingDir,
+    command,
+    args,
+    providerName: metadata.name,
+    extraWritePaths: sandboxOptions?.extraWritePaths,
+    readOnlyWorkingDir: sandboxOptions?.readOnlyWorkingDir,
+    // This is the provider execution path, so it must not run write-capable
+    // automation without an accepted boundary. Read-only runs still pass
+    // readOnlyWorkingDir and stay exempt.
+    requiresBoundaryForWrites: true,
+    env: sandboxOptions?.env,
+    // Prefer stable provider ids when available, otherwise derive a stable-ish id
+    // from the command basename (e.g. "copilot", "cursor-agent").
+    providerId: metadata.id ?? resolveCommandName(command)
+  });
+  if (result.sandboxed && isDebugMode()) {
+    logger2.debug(`[BaseRunner] Sandboxed ${metadata.name} execution in ${workingDir}`, {
+      provider: metadata.name,
+      workingDir
+    });
+  }
+  return result;
+}
+function computeArgvBytes(command, args, env) {
+  let argBytes = Buffer.byteLength(command, "utf8") + 1;
+  let maxArgBytes = Buffer.byteLength(command, "utf8");
+  for (const arg of args) {
+    const bytes = Buffer.byteLength(arg, "utf8");
+    argBytes += bytes + 1;
+    maxArgBytes = Math.max(maxArgBytes, bytes);
+  }
+  let envBytes = 0;
+  for (const [key, value] of Object.entries(env)) {
+    if (value === void 0) continue;
+    envBytes += Buffer.byteLength(key, "utf8") + 1 + Buffer.byteLength(value, "utf8") + 1;
+  }
+  return { argBytes, envBytes, totalBytes: argBytes + envBytes, maxArgBytes };
+}
+function throwIfProviderArgvTooLarge(command, args, env, metadata) {
+  const { argBytes, envBytes, totalBytes, maxArgBytes } = computeArgvBytes(command, args, env);
+  if (totalBytes <= PROVIDER_PROCESS_ARG_ENV_MAX_SAFE_BYTES && maxArgBytes <= PROVIDER_SINGLE_ARG_MAX_SAFE_BYTES) {
+    return;
+  }
+  throw new ProviderExecutionError(
+    `[${metadata.name}] Provider command argv/env is too large before spawn (argvBytes=${argBytes}, envBytes=${envBytes}, totalBytes=${totalBytes}, maxArgBytes=${maxArgBytes}). Use stdin or a prompt-file/config-file transport for large provider prompts or config payloads. [reason=argument_list_too_long]`,
+    {
+      retryable: false,
+      reason: "argument_list_too_long",
+      providerName: metadata.name
+    }
+  );
+}
+function resolveTelemetryBuildDir(workingDir) {
+  return path2.join(path2.resolve(workingDir), ".build-project");
+}
+function resultIsOurCancellation(result) {
+  if (result == null || typeof result !== "object") {
+    return false;
+  }
+  const r = result;
+  if (r.isCanceled === true || r.canceled === true) return true;
+  if (r.isTerminated === true && (r.signal === "SIGTERM" || r.signal === "SIGKILL")) {
+    return true;
+  }
+  if (r.signal === "SIGTERM" || r.signal === "SIGKILL") return true;
+  return false;
+}
+function shouldPreserveTerminationPartialOutput(record) {
+  return record.reason === "timeout" || record.reason === "hard_timeout" || record.reason === "plm_timeout" || record.reason === "idle_timeout" || record.reason === "abort" || // Spool failures kill the child, and what was captured before the failure is
+  // the evidence for diagnosing it.
+  record.reason === "output_ceiling_exceeded" || record.reason === "stdout_spool_read_failed" || record.reason === "stdout_spool_consume_failed";
+}
+async function executeProviderCommand(options) {
+  return executeProviderCommandImpl(options, "immediate");
+}
+async function executeProviderCommandAsync(options) {
+  return executeProviderCommandImpl(options, "async");
+}
+async function executeProviderCommandImpl(options, trackMode) {
+  const {
+    command,
+    args,
+    workingDir,
+    env,
+    preserveClaudeBackendFlags = false,
+    input,
+    stdinMode = "pipe",
+    timeout = DEFAULT_TIMEOUT,
+    maxBufferBytes,
+    extraWritePaths,
+    readOnlyWorkingDir,
+    disableBuildSandbox,
+    providerInternalSandboxBypass,
+    abortSignal,
+    beforeSpawn,
+    metadata,
+    onData,
+    onErrorData,
+    onStderrChunk,
+    onStdoutChunk,
+    onActivity,
+    onIdleTermination,
+    formatLine,
+    passThroughUnformatted = false,
+    streamOutput = false,
+    variantLabel,
+    idleWarnMs: optIdleWarnMs,
+    idleKillMs: optIdleKillMs,
+    fileBackedStdout = false,
+    fileBackedStdoutMaxBytes
+  } = options;
+  const useStreamingOutput = streamOutput === true;
+  const useFileBackedStdout = fileBackedStdout === true;
+  const fileBackedMaxBytes = typeof fileBackedStdoutMaxBytes === "number" && Number.isFinite(fileBackedStdoutMaxBytes) && fileBackedStdoutMaxBytes > 0 ? Math.floor(fileBackedStdoutMaxBytes) : FILE_BACKED_STDOUT_DEFAULT_MAX_BYTES;
+  throwIfAbortAlreadyRequested(abortSignal, metadata.name);
+  const idleTimeouts = resolveIdleTimeoutsMs(command, args, timeout, {
+    idleWarnMs: optIdleWarnMs,
+    idleKillMs: optIdleKillMs
+  });
+  const startTime = Date.now();
+  if (isTimeoutDebug()) {
+    logger2.debug(
+      `[BaseRunner] Starting ${metadata.name} with timeout ${timeout}ms (${Math.round(timeout / 6e4)}m)`,
+      {
+        provider: metadata.name,
+        command,
+        workingDir,
+        timeout,
+        variantLabel
+      }
+    );
+  }
+  if (isPathDebug()) {
+    logger2.debug(`[base-runner] Executing ${metadata.name} in cwd: ${workingDir}`, {
+      provider: metadata.name,
+      command,
+      workingDir,
+      timeout,
+      variantLabel
+    });
+    if (workingDir.includes("build-worktrees-")) {
+      const expectedUid = os3.userInfo().uid.toString();
+      if (!workingDir.includes(`build-worktrees-${expectedUid}`)) {
+        logger2.warn(`[base-runner] cwd UID mismatch - expected ${expectedUid} in: ${workingDir}`, {
+          provider: metadata.name,
+          command,
+          workingDir,
+          timeout,
+          variantLabel
+        });
+      }
+    }
+  }
+  const internalController = new AbortController();
+  const sandboxed = prepareCommand(command, args, workingDir, metadata, {
+    extraWritePaths,
+    readOnlyWorkingDir,
+    disableBuildSandbox,
+    env
+  });
+  assertProviderBypassHasBoundaryProof(metadata, args, sandboxed, providerInternalSandboxBypass);
+  const { command: sandboxedCommand, args: sandboxedArgs } = sandboxed;
+  const childEnv = sanitizeExecutionEnv(env, { preserveClaudeBackendFlags });
+  const processGroupOwnership = resolveProviderProcessGroupOwnership();
+  childEnv[BUILD_PROCESS_GROUP_OWNER_ENV] = processGroupOwnership.owner;
+  childEnv.PWD = path2.resolve(workingDir);
+  throwIfProviderArgvTooLarge(sandboxedCommand, sandboxedArgs, childEnv, metadata);
+  const commandSignature = formatRedactedCommandSignature(sandboxedCommand, sandboxedArgs);
+  const resolvedVariantLabel = variantLabel ?? "unknown";
+  const limiterDescription = `${metadata.name} provider command: ${formatRedactedCommandSignature(command, args)}`.trim();
+  const reservationOrWait = acquireProcessSlot(limiterDescription, abortSignal);
+  const reservation = reservationOrWait instanceof Promise ? await reservationOrWait : reservationOrWait;
+  let stdoutSpool;
+  let stdoutSpoolFd;
+  try {
+    throwIfAbortAlreadyRequested(abortSignal, metadata.name);
+    if (useFileBackedStdout) {
+      stdoutSpool = createPrivateSpool({
+        label: `stdout-${metadata.name}`,
+        streams: ["stdout"],
+        errorLabel: "stdout spool"
+      });
+      const freeBytes = spoolFilesystemFreeBytes(stdoutSpool.dir);
+      if (freeBytes !== void 0 && freeBytes < FILE_BACKED_STDOUT_MIN_FREE_BYTES) {
+        throw new ProviderExecutionError(
+          `${metadata.name} CLI not started: stdout spool filesystem has ${freeBytes} bytes free, below the ${FILE_BACKED_STDOUT_MIN_FREE_BYTES} byte floor.`,
+          {
+            retryable: false,
+            reason: "stdout_spool_insufficient_space",
+            providerName: metadata.name
+          }
+        );
+      }
+      stdoutSpoolFd = stdoutSpool.stream("stdout").requireOpenFd();
+    }
+    beforeSpawn?.();
+  } catch (error) {
+    if (stdoutSpool) {
+      await stdoutSpool.dispose().catch(() => {
+      });
+    }
+    releaseProcessSlotReservation(reservation);
+    throw error;
+  }
+  const spawnOptions = {
+    cwd: workingDir,
+    env: childEnv,
+    extendEnv: false,
+    input,
+    ...stdinMode === "ignore" && input === void 0 ? { stdin: "ignore" } : {},
+    // The child writes stdout straight to the spool inode. execa then reports
+    // `subprocess.stdout` as null and `result.stdout` as undefined, so the
+    // captured spool contents become the authoritative stdout below.
+    //
+    // The cast is deliberate: execa's types admit only the literals 3-9 for a
+    // descriptor here, while the runtime passes any integer through to Node's
+    // stdio, which shares that descriptor with the child. Verified on execa
+    // 9.6.1 / Node 24 with descriptor 42: exit 0 and all 500,000 bytes landed on
+    // the spool inode.
+    ...stdoutSpoolFd !== void 0 ? { stdout: stdoutSpoolFd } : {},
+    cancelSignal: internalController.signal,
+    all: false,
+    reject: false,
+    detached: processGroupOwnership.detach,
+    timeout: 0,
+    buffer: !useStreamingOutput,
+    ...!useStreamingOutput && typeof maxBufferBytes === "number" && Number.isFinite(maxBufferBytes) && maxBufferBytes > 0 ? { maxBuffer: Math.floor(maxBufferBytes) } : {}
+  };
+  const subprocess = spawnProviderSubprocess(
+    sandboxedCommand,
+    sandboxedArgs,
+    spawnOptions,
+    reservation
+  );
+  observeVariantProcessSpawn(subprocess);
+  const providerProcessGroupPid = subprocess.pid;
+  emitProviderProcessGroupMarker(providerProcessGroupPid);
+  const terminationController = createProviderTerminationController({
+    subprocess,
+    startTime,
+    timeout,
+    providerName: metadata.name,
+    command
+  });
+  const { processState, terminationState, requestTermination, markExited } = terminationController;
+  const requestTerminationFromAbortSignal = (signal) => {
+    if (isHostTimeoutAbortReason(signal.reason)) {
+      requestTermination(
+        "timeout",
+        "abortSignal",
+        formatHostTimeoutTerminationDetail(signal.reason)
+      );
+      return;
+    }
+    requestTermination("abort", "abortSignal");
+  };
+  let abortListener;
+  if (abortSignal) {
+    if (abortSignal.aborted) {
+      internalController.abort();
+      requestTerminationFromAbortSignal(abortSignal);
+    } else {
+      abortListener = () => {
+        internalController.abort();
+        requestTerminationFromAbortSignal(abortSignal);
+      };
+      abortSignal.addEventListener("abort", abortListener, { once: true });
+    }
+  }
+  const activityState = {
+    outputLines: 0,
+    lastActivityAt: Date.now(),
+    consecutiveBusyCpuPolls: 0
+  };
+  const stderrChunks = [];
+  const stdoutChunks = [];
+  const streamCaptureLimit = typeof maxBufferBytes === "number" && Number.isFinite(maxBufferBytes) && maxBufferBytes > 0 ? Math.floor(maxBufferBytes) : DEFAULT_STREAM_CAPTURE_BYTES;
+  const capturedStdout = new BoundedOutputBuffer();
+  const capturedStderr = new BoundedOutputBuffer();
+  const resolveResultStdout = (result) => useFileBackedStdout ? capturedStdout.toString() || result.stdout : result.stdout;
+  let streamingStdoutProcessor;
+  let streamingStderrProcessor;
+  let streamCallbackError;
+  const captureStreamCallbackError = (error, streamName) => {
+    if (streamCallbackError) {
+      return;
+    }
+    streamCallbackError = error;
+    logger2.error(
+      `[BaseRunner] Streaming ${streamName} callback failed: ${String(error)}`,
+      void 0,
+      {
+        provider: metadata.name,
+        stream: streamName
+      }
+    );
+  };
+  if (useStreamingOutput) {
+    streamingStdoutProcessor = createLineBufferedStreamProcessor((line) => {
+      if (!onData || streamCallbackError) {
+        return;
+      }
+      try {
+        if (formatLine) {
+          const formatted = formatLine(line);
+          if (formatted) {
+            onData(`${formatted}
+`);
+          } else if (passThroughUnformatted) {
+            onData(`${line}
+`);
+          }
+        } else {
+          onData(`${line}
+`);
+        }
+      } catch (error) {
+        captureStreamCallbackError(error, "stdout");
+      }
+    });
+    streamingStderrProcessor = createLineBufferedStreamProcessor((line) => {
+      if (!onErrorData || streamCallbackError) {
+        return;
+      }
+      try {
+        onErrorData(line);
+      } catch (error) {
+        captureStreamCallbackError(error, "stderr");
+      }
+    });
+  }
+  const bumpActivity = (chunk, source = "stdout") => {
+    if (chunk == null) return;
+    const now = Date.now();
+    activityState.lastActivityAt = now;
+    const text = chunkToText(chunk);
+    if (text) {
+      activityState.outputLines += text.split(/\r?\n/).filter(Boolean).length;
+      onActivity?.({ source, timestampMs: now });
+    }
+  };
+  const completionSignal = options.completionSignal;
+  const completionSignalGraceMs = Math.max(
+    0,
+    options.completionSignalGraceMs ?? TMUX_COMPLETION_SIGNAL_GRACE_MS
+  );
+  let completionSignalGraceTimer;
+  let completionSignalEarlyExit = false;
+  const observeCompletionSignal = (text, stream) => {
+    if (!completionSignal || completionSignalGraceTimer || processState.hasExited) return;
+    let signalled = false;
+    try {
+      signalled = completionSignal(text, stream) === true;
+    } catch {
+      return;
+    }
+    if (!signalled) return;
+    completionSignalGraceTimer = setTimeout(() => {
+      if (processState.hasExited) return;
+      if (terminationState.getPrimaryRecord() !== null) return;
+      completionSignalEarlyExit = true;
+      if (processState.sigtermSentAt === null) {
+        if (sendSignalToSubprocessTree(subprocess, "SIGTERM")) {
+          processState.sigtermSentAt = Date.now();
+        }
+      }
+      internalController.abort();
+    }, completionSignalGraceMs);
+    completionSignalGraceTimer.unref?.();
+  };
+  const deliverRawChunk = (observer, chunk) => {
+    if (!observer) {
+      return;
+    }
+    let raw;
+    if (Buffer.isBuffer(chunk)) {
+      if (chunk.length === 0) return;
+      raw = Buffer.from(chunk);
+    } else if (chunk instanceof Uint8Array) {
+      if (chunk.byteLength === 0) return;
+      raw = Buffer.from(chunk);
+    } else if (typeof chunk === "string") {
+      if (chunk.length === 0) return;
+      raw = chunk;
+    } else {
+      return;
+    }
+    try {
+      observer(raw);
+    } catch {
+    }
+  };
+  let firstOutputFiredInExec = false;
+  const ingestStdout = (raw, text) => {
+    bumpActivity(text);
+    if (!firstOutputFiredInExec && text) {
+      firstOutputFiredInExec = true;
+      options.onFirstOutput?.(Date.now());
+    }
+    if (raw !== void 0) {
+      deliverRawChunk(onStdoutChunk, raw);
+    }
+    if (text) {
+      observeCompletionSignal(text, "stdout");
+    }
+    if ((useStreamingOutput || completionSignal || useFileBackedStdout) && text) {
+      capturedStdout.append(text, streamCaptureLimit);
+      stdoutChunks.push(text);
+      if (stdoutChunks.length > 5) {
+        stdoutChunks.shift();
+      }
+    }
+    if (useStreamingOutput) {
+      streamingStdoutProcessor?.push(text);
+    }
+  };
+  const stdoutDecoder = new StringDecoder2("utf8");
+  const stderrDecoder = new StringDecoder2("utf8");
+  let pipeDecodersFlushed = false;
+  const decodePipeChunk = (decoder, chunk) => {
+    if (Buffer.isBuffer(chunk)) return decoder.write(chunk);
+    if (chunk instanceof Uint8Array) return decoder.write(Buffer.from(chunk));
+    return chunkToText(chunk);
+  };
+  const stdoutDataListener = (chunk) => {
+    ingestStdout(chunk, decodePipeChunk(stdoutDecoder, chunk));
+  };
+  let stdoutSpoolFailure;
+  let stdoutSpoolTailer;
+  if (stdoutSpool !== void 0) {
+    stdoutSpoolTailer = createStdoutSpoolTailer({
+      stream: stdoutSpool.stream("stdout"),
+      maxBytes: fileBackedMaxBytes,
+      onBytes: (bytes, text) => {
+        ingestStdout(bytes, text);
+      },
+      onFailure: (failure) => {
+        if (stdoutSpoolFailure) return;
+        stdoutSpoolFailure = failure;
+        requestTermination(failure.reason, "base-runner:stdout-spool", failure.message);
+      }
+    });
+    stdoutSpoolTailer.start();
+  }
+  if (typeof subprocess?.stdout?.on === "function") {
+    subprocess.stdout.on("data", stdoutDataListener);
+  } else if (stdoutSpool === void 0 && isDebugMode()) {
+    console.warn("[base-runner] subprocess.stdout not available \u2014 diagnostics may be incomplete");
+  }
+  const ingestStderr = (raw, text) => {
+    if (raw !== void 0) {
+      deliverRawChunk(onStderrChunk, raw);
+    }
+    if (text) {
+      bumpActivity(text, "stderr");
+      if (useStreamingOutput || completionSignal) {
+        capturedStderr.append(text, streamCaptureLimit);
+      }
+      stderrChunks.push(text);
+      if (stderrChunks.length > 5) {
+        stderrChunks.shift();
+      }
+      observeCompletionSignal(text, "stderr");
+    }
+    if (useStreamingOutput) {
+      streamingStderrProcessor?.push(text);
+    }
+  };
+  const stderrListener = (chunk) => {
+    ingestStderr(chunk, decodePipeChunk(stderrDecoder, chunk));
+  };
+  const flushPipeDecoders = () => {
+    if (pipeDecodersFlushed) return;
+    pipeDecodersFlushed = true;
+    const stdoutRemainder = stdoutDecoder.end();
+    if (stdoutRemainder) ingestStdout(void 0, stdoutRemainder);
+    const stderrRemainder = stderrDecoder.end();
+    if (stderrRemainder) ingestStderr(void 0, stderrRemainder);
+  };
+  if (typeof subprocess?.stderr?.on === "function") {
+    subprocess.stderr.on("data", stderrListener);
+  }
+  const exitStatus = {
+    code: null,
+    signal: null
+  };
+  const completionPromise = (async () => {
+    const result = await subprocess;
+    exitStatus.code = result.exitCode ?? null;
+    exitStatus.signal = result?.signal ?? null;
+    if (!processState.hasExited) {
+      markExited(exitStatus.code, exitStatus.signal);
+    }
+    return result;
+  })();
+  let enteredTry = false;
+  completionPromise.catch((err) => {
+    if (!enteredTry) {
+      const message = err instanceof Error ? err.message : String(err);
+      logger2.error(`[BaseRunner] Subprocess rejected before await: ${message}`, void 0, {
+        provider: metadata.name
+      });
+    }
+  });
+  let trackedPid = null;
+  let limiterId;
+  const registerLimiter = () => registerProviderProcessLimiter({
+    subprocess,
+    limiterDescription,
+    timeout,
+    reservation,
+    requestTermination,
+    trackedPid,
+    onRegistrationFailure: () => {
+      terminationController.clearTerminationTimer();
+      if (abortSignal && abortListener) {
+        abortSignal.removeEventListener("abort", abortListener);
+      }
+      removeStreamDataListener(subprocess, "stdout", stdoutDataListener);
+      removeStreamDataListener(subprocess, "stderr", stderrListener);
+    }
+  });
+  try {
+    if (trackMode === "async") {
+      limiterId = registerLimiter();
+      trackedPid = await trackProviderSubprocess(subprocess, "async");
+    } else {
+      trackedPid = trackProviderSubprocess(subprocess, "immediate");
+      limiterId = registerLimiter();
+    }
+  } catch (error) {
+    try {
+      if (limiterId !== void 0) {
+        globalProcessLimiter.untrack(limiterId);
+        limiterId = void 0;
+      } else if (reservation !== void 0) {
+        globalProcessLimiter.cancelReservation(reservation);
+      }
+    } catch (cleanupError) {
+      logger2.warn("[BaseRunner] Failed to release process limiter after tracking setup failure", {
+        cleanupError: sanitizeError(
+          cleanupError instanceof Error ? cleanupError : new Error(String(cleanupError))
+        ).message
+      });
+    }
+    sendSignalToSubprocessTree(subprocess, "SIGKILL");
+    terminationController.clearTerminationTimer();
+    if (abortSignal && abortListener) {
+      abortSignal.removeEventListener("abort", abortListener);
+    }
+    removeStreamDataListener(subprocess, "stdout", stdoutDataListener);
+    removeStreamDataListener(subprocess, "stderr", stderrListener);
+    if (stdoutSpool) {
+      await stdoutSpool.dispose().catch(() => {
+      });
+    }
+    untrackSubprocess(trackedPid, subprocess);
+    throw error;
+  }
+  const plmProcessId = await registerProviderProcessLifecycle({
+    subprocess,
+    completionPromise,
+    processState,
+    exitStatus,
+    requestTermination,
+    activityState,
+    stderrChunks,
+    providerName: metadata.name,
+    command,
+    args,
+    workingDir,
+    ownsProcessGroup: processGroupOwnership.detach
+  });
+  let idleMonitorInterval;
+  let watchdogInterval;
+  enteredTry = true;
+  try {
+    idleMonitorInterval = startProviderIdleMonitor({
+      subprocess,
+      activityState,
+      terminationState,
+      requestTermination,
+      command,
+      timeout,
+      providerName: metadata.name,
+      variantLabel: resolvedVariantLabel,
+      commandSignature,
+      stderrChunks,
+      onActivity,
+      onIdleTermination,
+      idleTimeouts
+    });
+    watchdogInterval = startProviderTimeoutWatchdog({
+      processState,
+      startTime,
+      timeout,
+      providerName: metadata.name
+    });
+    const result = await completionPromise;
+    const failure = result;
+    if (failure.failed && (failure.isMaxBuffer || failure.code === "ENOENT")) throw result;
+    flushPipeDecoders();
+    let stdoutSpoolBytes;
+    let stdoutSpoolDiskExhausted;
+    if (stdoutSpoolTailer && stdoutSpool) {
+      await stdoutSpoolTailer.drain();
+      stdoutSpoolFailure ??= stdoutSpoolTailer.failure();
+      try {
+        await stdoutSpool.finalize();
+        stdoutSpoolBytes = await stdoutSpoolTailer.finish();
+        stdoutSpoolFailure ??= stdoutSpoolTailer.failure();
+      } catch (error) {
+        stdoutSpoolFailure ??= {
+          reason: "stdout_spool_read_failed",
+          message: `finalizing the provider stdout spool failed: ${error instanceof Error ? error.message : String(error)}`
+        };
+      }
+      const freeBytes = spoolFilesystemFreeBytes(stdoutSpool.dir);
+      if (freeBytes !== void 0 && freeBytes < FILE_BACKED_STDOUT_MIN_FREE_BYTES) {
+        stdoutSpoolDiskExhausted = true;
+      }
+    }
+    const spoolMeasuredBytes = stdoutSpoolBytes !== void 0 && stdoutSpoolBytes > 0 ? stdoutSpoolBytes : void 0;
+    if (useStreamingOutput) {
+      streamingStdoutProcessor?.flush();
+      streamingStderrProcessor?.flush();
+      if (streamCallbackError) {
+        throw streamCallbackError;
+      }
+    } else {
+      processOutput(
+        resolveResultStdout(result),
+        result.stderr,
+        onData,
+        onErrorData,
+        formatLine,
+        passThroughUnformatted
+      );
+    }
+    if (stdoutSpoolFailure !== void 0) {
+      throw new ProviderExecutionError(
+        `${metadata.name} CLI stdout capture failed: ${stdoutSpoolFailure.message}`,
+        {
+          retryable: false,
+          exitCode: result.exitCode ?? void 0,
+          reason: stdoutSpoolFailure.reason,
+          providerName: metadata.name,
+          includeStdoutTail: true,
+          ...providerExecutionTransportStreamOptions(
+            capturedStdout.toString(),
+            result.stderr || capturedStderr.toString(),
+            { streamBytes: { stdout: spoolMeasuredBytes } }
+          )
+        }
+      );
+    }
+    if (completionSignalEarlyExit && terminationState.getPrimaryRecord() === null && resultIsOurCancellation(result)) {
+      return {
+        stdout: capturedStdout.toString() || stdoutChunks.join("") || resolveResultStdout(result) || "",
+        stderr: capturedStderr.toString() || stderrChunks.join("") || result.stderr || "",
+        exitCode: 0,
+        ...stdoutSpoolBytes !== void 0 ? { stdoutBytes: stdoutSpoolBytes } : {},
+        ...stdoutSpoolDiskExhausted ? { stdoutSpoolDiskExhausted: true } : {}
+      };
+    }
+    const successfulTermination = terminationState.getPrimaryRecord();
+    if (result.exitCode === 0 && successfulTermination !== null) {
+      const detailSuffix = successfulTermination.detail ? ` (${successfulTermination.detail})` : "";
+      const preservePartialOutput = shouldPreserveTerminationPartialOutput(successfulTermination);
+      const terminationStdout = resolveResultStdout(result) || (preservePartialOutput ? capturedStdout.toString() || stdoutChunks.join("") : "");
+      const terminationStderr = result.stderr || (preservePartialOutput ? capturedStderr.toString() || stderrChunks.join("") : "");
+      throw new ProviderExecutionError(
+        `${metadata.name} CLI terminated (${successfulTermination.reason} via ${successfulTermination.source})${detailSuffix}.${formatTerminationRemedy(successfulTermination.reason, timeout)}`,
+        {
+          retryable: false,
+          exitCode: resolveTerminationExitCode(
+            successfulTermination.reason,
+            result.exitCode ?? void 0
+          ),
+          reason: successfulTermination.reason,
+          signal: hasSignal(result) ? result.signal : void 0,
+          terminationSource: successfulTermination.source,
+          ...providerExecutionTransportStreamOptions(terminationStdout, terminationStderr, {
+            streamBytes: { stdout: spoolMeasuredBytes }
+          })
+        }
+      );
+    }
+    if (result.exitCode !== 0) {
+      const bufferedStderr = stderrChunks.join("").trim();
+      const bufferedStdout = useStreamingOutput || useFileBackedStdout ? stdoutChunks.join("").trim() : "";
+      const rawErrorOutput = result.stderr?.trim() || bufferedStderr || bufferedStdout || resolveResultStdout(result)?.trim() || "no error output";
+      const decoratedErrorOutput = rawErrorOutput === "no error output" ? `${rawErrorOutput} (command: ${commandSignature})` : rawErrorOutput;
+      const selectedLine = selectBestErrorSummary(
+        decoratedErrorOutput,
+        bufferedStdout || resolveResultStdout(result)?.trim()
+      ) ?? "";
+      const sanitizedSelectedLine = selectedLine ? sanitizeError(new Error(selectedLine)).message : selectedLine;
+      const termination = terminationState.getPrimaryRecord();
+      if (termination !== null) {
+        const signal = hasSignal(result) ? result.signal : void 0;
+        const detailSuffix = termination.detail ? ` (${termination.detail})` : "";
+        const preservePartialOutput = shouldPreserveTerminationPartialOutput(termination);
+        const terminationStdout = resolveResultStdout(result) || (preservePartialOutput ? capturedStdout.toString() || stdoutChunks.join("") : "");
+        const terminationStderr = result.stderr || (preservePartialOutput ? capturedStderr.toString() || stderrChunks.join("") : "");
+        throw new ProviderExecutionError(
+          `${metadata.name} CLI terminated (${termination.reason} via ${termination.source})${detailSuffix}: ${sanitizedSelectedLine}${formatTerminationRemedy(termination.reason, timeout)}`,
+          {
+            retryable: false,
+            exitCode: resolveTerminationExitCode(termination.reason, result.exitCode ?? void 0),
+            reason: termination.reason,
+            signal,
+            terminationSource: termination.source,
+            ...providerExecutionTransportStreamOptions(
+              terminationStdout,
+              terminationStderr || bufferedStderr || "",
+              { streamBytes: { stdout: spoolMeasuredBytes } }
+            )
+          }
+        );
+      }
+      let terminationReason;
+      let reason;
+      if (result.exitCode === void 0) {
+        if (hasSignal(result)) {
+          const signal = result.signal;
+          if (signal === "SIGTERM") {
+            terminationReason = "killed by SIGTERM signal (timeout or manual termination)";
+            reason = "signal_sigterm";
+          } else if (signal === "SIGKILL") {
+            terminationReason = "force killed by SIGKILL signal (unresponsive process)";
+            reason = "signal_sigkill";
+          } else {
+            terminationReason = `killed by signal ${signal}`;
+            reason = `signal_${signal.toLowerCase()}`;
+          }
+        } else {
+          terminationReason = "crashed or terminated abnormally (no exit code)";
+          reason = "abnormal_termination";
+        }
+      } else {
+        const decodedSignal = exitCodeToSignal(result.exitCode, result.signal ?? void 0);
+        if (decodedSignal) {
+          if (decodedSignal === "SIGTERM") {
+            terminationReason = `killed by SIGTERM signal (exit code ${result.exitCode})`;
+            reason = "signal_sigterm";
+          } else if (decodedSignal === "SIGKILL") {
+            terminationReason = `force killed by SIGKILL signal (exit code ${result.exitCode})`;
+            reason = "signal_sigkill";
+          } else {
+            terminationReason = `killed by signal ${decodedSignal} (exit code ${result.exitCode})`;
+            reason = `signal_${decodedSignal.toLowerCase()}`;
+          }
+        } else {
+          terminationReason = `exited with code ${result.exitCode}`;
+          reason = "non_zero_exit";
+        }
+      }
+      const fullStdout = resolveResultStdout(result) || (useStreamingOutput || useFileBackedStdout ? capturedStdout.toString() || bufferedStdout : "") || "";
+      const fullStderr = result.stderr || bufferedStderr || "";
+      if (reason === "non_zero_exit") {
+        const denial = sandboxPathDenialError(metadata, sandboxed, {
+          exitCode: result.exitCode,
+          stdout: fullStdout,
+          stderr: fullStderr,
+          stdoutBytes: spoolMeasuredBytes
+        });
+        if (denial) throw denial;
+      }
+      throw new ProviderExecutionError(
+        `${metadata.name} CLI ${terminationReason}: ${sanitizedSelectedLine}`,
+        {
+          retryable: false,
+          exitCode: result.exitCode ?? void 0,
+          reason,
+          signal: result.signal ?? void 0,
+          ...providerExecutionTransportStreamOptions(fullStdout, fullStderr, {
+            streamBytes: { stdout: spoolMeasuredBytes }
+          })
+        }
+      );
+    }
+    return {
+      stdout: useFileBackedStdout ? resolveResultStdout(result) || "" : useStreamingOutput ? capturedStdout.toString() : result.stdout || "",
+      stderr: useStreamingOutput ? capturedStderr.toString() : result.stderr || "",
+      exitCode: result.exitCode,
+      // Authoritative size from the spool inode. `stdout` above is
+      // display-bounded, so a caller reporting a stream size must use this.
+      // Reported only when bytes were actually measured: a zero-byte spool
+      // alongside non-empty execa output means the redirect did not apply, and
+      // zero would then be a claim about a stream this never saw.
+      ...spoolMeasuredBytes !== void 0 ? { stdoutBytes: spoolMeasuredBytes } : {},
+      ...stdoutSpoolDiskExhausted ? { stdoutSpoolDiskExhausted: true } : {}
+    };
+  } catch (error) {
+    flushPipeDecoders();
+    let failurePathSpoolBytes;
+    if (stdoutSpoolTailer) {
+      try {
+        failurePathSpoolBytes = await stdoutSpoolTailer.finish();
+      } catch {
+      }
+    }
+    if (streamCallbackError && error === streamCallbackError) {
+      throw error;
+    }
+    if (completionSignalEarlyExit && terminationState.getPrimaryRecord() === null && resultIsOurCancellation(error)) {
+      return {
+        stdout: capturedStdout.toString() || stdoutChunks.join(""),
+        stderr: capturedStderr.toString() || stderrChunks.join(""),
+        exitCode: 0
+      };
+    }
+    throw classifyAndWrapExecaError({
+      error,
+      metadata,
+      terminationState,
+      startTime,
+      timeout,
+      maxBufferBytes,
+      command,
+      args,
+      workingDir,
+      // Under a file-backed stdout the execa error carries no stdout at all —
+      // the child wrote to the spool, not to a pipe execa was reading. Without
+      // these the timeout and abort classifications would lose every byte of
+      // partial output, which is precisely the evidence a hung provider run is
+      // diagnosed from.
+      capturedStdout: capturedStdout.toString() || void 0,
+      capturedStderr: capturedStderr.toString() || void 0,
+      ...failurePathSpoolBytes !== void 0 && failurePathSpoolBytes > 0 ? { streamBytes: { stdout: failurePathSpoolBytes } } : {}
+    });
+  } finally {
+    if (completionSignalGraceTimer) {
+      clearTimeout(completionSignalGraceTimer);
+    }
+    if (stdoutSpool) {
+      await stdoutSpool.dispose().catch(() => {
+      });
+    }
+    await drainProviderTerminationGrace(terminationController);
+    cleanupProviderExecutionResources({
+      watchdogInterval,
+      idleMonitorInterval,
+      terminationController,
+      abortSignal,
+      abortListener,
+      subprocess,
+      stdoutDataListener,
+      stderrListener,
+      plmProcessId,
+      limiterId,
+      trackedPid,
+      workingDir,
+      providerName: metadata.name
+    });
+    if (processGroupOwnership.detach && await ensureDetachedProviderProcessGroupGone(providerProcessGroupPid)) {
+      emitProviderProcessGroupClearedMarker(providerProcessGroupPid);
+    }
+  }
+}
+
+export {
+  emitBoundaryTriggered,
+  setProcessLifecycleManager,
+  getProcessLifecycleManager,
+  resolveFileBackedStdoutOverride,
+  isNonEmptyRawChunk,
+  rawChunkToBuffer,
+  composeRawChunkObservers,
+  createPrivateSpool,
+  BUILD_PROCESS_GROUP_OWNER_ENV,
+  BUILD_PROVIDER_PROCESS_GROUP_MARKER_PREFIX,
+  BUILD_PROVIDER_PROCESS_GROUP_CLEARED_MARKER_PREFIX,
+  isProviderProcessGroupMarkerLine,
+  resolveProviderProcessGroupOwnership,
+  acquireProcessSlot,
+  hasAcceptedPolicyBoundaryProof,
+  emitHostClassBypassNotice,
+  assertProviderBypassHasBoundaryProof,
+  sandboxPathDenialError,
+  MemoryGuardian,
+  killAllFallbackTrackedSubprocesses,
+  TMUX_COMPLETION_SIGNAL_GRACE_MS,
+  createLineDelimitedTmuxCompletionSignal,
+  withVariantInvocation,
+  activeVariantServiceTier,
+  prepareVariantCommand,
+  recordVariantTmuxLaunch,
+  computePromptFingerprint,
+  DEFAULT_TIMEOUT,
+  executeProviderCommand,
+  executeProviderCommandAsync
+};
+//# sourceMappingURL=chunk-633XZ7UF.js.map