@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-WGQAXLNA.js

@@ -0,0 +1,384 @@
+import {
+  PI_BACKEND_ENV_KEYS
+} from "./chunk-ONHAMBN6.js";
+import {
+  envWithoutAmbientGitRepository
+} from "./chunk-XDM65LBX.js";
+
+// src/core/providers/shared/child-env.ts
+var RESERVED_HEADERS = [
+  "ANTHROPIC_CUSTOM_HEADERS",
+  // Claude Code session markers — all must be removed to prevent
+  // "Claude Code cannot be launched inside another Claude Code session" errors.
+  "CLAUDECODE",
+  "CLAUDE_CODE",
+  "CLAUDE_CODE_SSE_PORT",
+  "CLAUDE_CODE_ENTRYPOINT",
+  "CLAUDE_BASH_MAINTAIN_PROJECT_WORKING_DIR",
+  "AI_SDK"
+];
+var CLAUDE_SESSION_PREFIX = "CLAUDE_CODE_";
+var CLAUDE_SESSION_MARKER_ALLOWED_KEYS = /* @__PURE__ */ new Set([
+  "CLAUDE_CODE_OAUTH_TOKEN",
+  "CLAUDE_CODE_EFFORT_LEVEL",
+  // Capability flag, not a session marker: it disables the 1M context window.
+  // Build reads the same variable when deciding whether to append the `[1m]`
+  // selector, so suppressing the selector in the parent while letting the child
+  // run unrestricted would desync the two.
+  "CLAUDE_CODE_DISABLE_1M_CONTEXT",
+  "CLAUDE_CODE_USE_BEDROCK",
+  "CLAUDE_CODE_USE_VERTEX",
+  // Microsoft Foundry backend switch. Like the Bedrock/Vertex flags it selects a
+  // backend rather than marking a nested session, so stripping it would silently
+  // drop the operator's backend choice before the child spawns.
+  "CLAUDE_CODE_USE_FOUNDRY",
+  // Capability flag: loads the CLAUDE.md of each `--add-dir` directory. Build sets it
+  // for a launch that carries Build's instruction set (claude/execution/instruction-isolation.ts).
+  "CLAUDE_CODE_ADDITIONAL_DIRECTORIES_CLAUDE_MD",
+  // User output-token override; docs/providers/claude.md documents that it is honoured.
+  "CLAUDE_CODE_MAX_OUTPUT_TOKENS",
+  // Capability flag the Bedrock reserved-keyword error recommends (claude/error-parser.ts).
+  "CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS",
+  // The user's telemetry opt-in, not a session marker: the CLI's nested-session
+  // refusal keys on CLAUDECODE. Forwarding it lets shell-exported OpenTelemetry
+  // (OTEL_*, forwarded by prefix below) cover Build-launched sessions.
+  "CLAUDE_CODE_ENABLE_TELEMETRY",
+  "CLAUDE_CODE_ENHANCED_TELEMETRY_BETA"
+]);
+var RESERVED_HEADER_SET = new Set(RESERVED_HEADERS);
+var PARENT_ENV_ALLOWLIST = /* @__PURE__ */ new Set([
+  "CI",
+  "COLORTERM",
+  "HOME",
+  "LANG",
+  "LC_ALL",
+  "LC_CTYPE",
+  "LOGNAME",
+  "NODE_EXTRA_CA_CERTS",
+  "PATH",
+  "PWD",
+  "SHELL",
+  "TERM",
+  "TMPDIR",
+  "USER",
+  "XDG_CACHE_HOME",
+  "XDG_CONFIG_HOME",
+  "XDG_DATA_HOME",
+  "XDG_STATE_HOME",
+  "ANTHROPIC_API_KEY",
+  "CLAUDE_CODE_OAUTH_TOKEN",
+  "CLAUDE_CODE_EFFORT_LEVEL",
+  "CLAUDE_CODE_DISABLE_1M_CONTEXT",
+  "CLAUDE_CODE_MAX_OUTPUT_TOKENS",
+  "CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS",
+  "CLAUDE_CODE_ENABLE_TELEMETRY",
+  "CLAUDE_CODE_ENHANCED_TELEMETRY_BETA",
+  "CLAUDE_CODE_USE_BEDROCK",
+  "CLAUDE_CODE_USE_VERTEX",
+  "ANTHROPIC_VERTEX_PROJECT_ID",
+  "CLOUD_ML_REGION",
+  // Microsoft Foundry connection + credentials. One of RESOURCE (the CLI builds
+  // the endpoint from it) or BASE_URL is required; the credential is a bearer
+  // token, an API key, or — when neither is set — the Azure default credential
+  // chain, which reaches the child through the already-forwarded HOME (Azure CLI
+  // cache). No broad AZURE_* forward is needed for that.
+  "CLAUDE_CODE_USE_FOUNDRY",
+  "ANTHROPIC_FOUNDRY_RESOURCE",
+  "ANTHROPIC_FOUNDRY_BASE_URL",
+  "ANTHROPIC_FOUNDRY_API_KEY",
+  "ANTHROPIC_FOUNDRY_AUTH_TOKEN",
+  // Vertex model-default knobs. The Claude CLI resolves the bare aliases
+  // (`opus`/`sonnet`/`haiku`) to provider-specific model ids via these env
+  // vars; stripping them on Vertex silently resolves the wrong model and drops
+  // the operator's override before it reaches the child. These are model
+  // names / region knobs, not secrets. ANTHROPIC_MODEL is safe to forward
+  // because an explicit `--model` flag takes precedence over it (verified
+  // against Anthropic docs: "--model and /model override ANTHROPIC_MODEL").
+  // Build emits `--model` for any model that resolves and omits it only for
+  // unresolvable/cross-provider input (commands.ts), so ANTHROPIC_MODEL governs
+  // just that no-flag fallback — it can never override an explicit selection.
+  "ANTHROPIC_MODEL",
+  "ANTHROPIC_DEFAULT_OPUS_MODEL",
+  "ANTHROPIC_DEFAULT_SONNET_MODEL",
+  "ANTHROPIC_DEFAULT_HAIKU_MODEL",
+  "ANTHROPIC_SMALL_FAST_MODEL",
+  "CURSOR_CONFIG_DIR",
+  "CURSOR_DATA_DIR",
+  "GEMINI_API_KEY",
+  "GOOGLE_API_KEY",
+  "GOOGLE_APPLICATION_CREDENTIALS",
+  "GOOGLE_CLOUD_PROJECT",
+  "GOOGLE_CLOUD_LOCATION",
+  "GCLOUD_PROJECT",
+  "CLOUDSDK_CONFIG",
+  // Grok API keys are intentionally absent: re-admitted only via grok provider
+  // execution policy (provider-execution-env.ts), not the generic parent allowlist.
+  "OPENAI_API_KEY",
+  "OPENROUTER_API_KEY",
+  "OPENROUTER_KEY",
+  "BLACKBOX_API_KEY",
+  "ZAI_API_KEY",
+  "ZHIPU_API_KEY",
+  "KIRO_API_KEY",
+  "ANTIGRAVITY_API_KEY",
+  // Pi's agent directory holds auth.json and models.json. An operator who moves
+  // it must have the override reach the child, or Pi reads ~/.pi/agent instead
+  // and fails to resolve their configured backend or credential. A directory
+  // path, not a secret (matches CURSOR_CONFIG_DIR above).
+  "PI_CODING_AGENT_DIR"
+]);
+var PARENT_ENV_ALLOWLIST_PREFIXES = ["AWS_", "OTEL_", "BUILD_", "VERTEX_REGION_CLAUDE_"];
+var PARENT_ENV_DENYLIST = /* @__PURE__ */ new Set([
+  "BUILD_ALLOW_SKIP_AUTH",
+  "BUILD_CONFIG_ALLOW_DEFAULT_FALLBACK",
+  "BUILD_PROVIDER_HISTORY_RAW",
+  "BUILD_SKIP_AUTH",
+  "BUILD_WEBHOOK_SECRET",
+  "BUILD_WORKER_ALLOW_EMPTY_RESULTS",
+  "BUILD_WORKER_EXECUTION_INTENT",
+  // Native web-search clearance is an authority signal:
+  // it must come ONLY from the parent's per-run capability-matrix decision, never
+  // from an inherited shell env. Denylist it so a pre-set shell value cannot
+  // enable provider web tools outside an analysis-only --research run; the master
+  // re-applies the trusted value onto the worker env after this clean step.
+  "BUILD_RESEARCH_NATIVE_PROVIDERS"
+]);
+function isSandboxAuthorityEnvVar(name) {
+  return name.startsWith("BUILD_") && name.includes("SANDBOX");
+}
+function shouldStripClaudeSessionVar(name) {
+  if (RESERVED_HEADER_SET.has(name)) {
+    return true;
+  }
+  return name.startsWith(CLAUDE_SESSION_PREFIX) && !CLAUDE_SESSION_MARKER_ALLOWED_KEYS.has(name);
+}
+function shouldForwardParentEnvVar(name) {
+  if (PARENT_ENV_DENYLIST.has(name) || isSandboxAuthorityEnvVar(name)) {
+    return false;
+  }
+  return PARENT_ENV_ALLOWLIST.has(name) || PARENT_ENV_ALLOWLIST_PREFIXES.some((prefix) => name.startsWith(prefix));
+}
+function filterParentEnvForProvider(baseEnv) {
+  const filtered = {};
+  for (const [key, value] of Object.entries(baseEnv)) {
+    if (value !== void 0 && shouldForwardParentEnvVar(key)) {
+      filtered[key] = value;
+    }
+  }
+  return filtered;
+}
+function stripClaudeSessionEnv(env) {
+  const mergedEnv = { ...env };
+  for (const key of Object.keys(mergedEnv)) {
+    if (shouldStripClaudeSessionVar(key)) {
+      delete mergedEnv[key];
+    }
+  }
+  return mergedEnv;
+}
+function createCleanChildEnv(overrides, baseEnv = filterParentEnvForProvider(process.env)) {
+  const mergedEnv = {
+    ...baseEnv,
+    ...overrides ?? {}
+  };
+  for (const key of PARENT_ENV_DENYLIST) {
+    delete mergedEnv[key];
+  }
+  for (const key of Object.keys(mergedEnv)) {
+    if (isSandboxAuthorityEnvVar(key)) {
+      delete mergedEnv[key];
+    }
+  }
+  return stripClaudeSessionEnv(mergedEnv);
+}
+var PROVIDER_SECRET_KEYS = /* @__PURE__ */ new Set([
+  "ANTHROPIC_API_KEY",
+  "CLAUDE_CODE_OAUTH_TOKEN",
+  "CLAUDE_CODE_USE_BEDROCK",
+  "CLAUDE_CODE_USE_VERTEX",
+  "ANTHROPIC_VERTEX_PROJECT_ID",
+  "CLOUD_ML_REGION",
+  // Foundry switch, connection and credentials — scoped to claude/anthropic so a
+  // non-claude run carries neither the backend selector nor the Foundry
+  // credential (the API key and auth token are secrets, mirroring
+  // ANTHROPIC_API_KEY).
+  "CLAUDE_CODE_USE_FOUNDRY",
+  "ANTHROPIC_FOUNDRY_RESOURCE",
+  "ANTHROPIC_FOUNDRY_BASE_URL",
+  "ANTHROPIC_FOUNDRY_API_KEY",
+  "ANTHROPIC_FOUNDRY_AUTH_TOKEN",
+  // Claude Vertex model-default knobs — scoped to claude/anthropic so a
+  // non-claude provider run does not carry claude model overrides (mirrors
+  // CLAUDE_CODE_USE_VERTEX / CLOUD_ML_REGION). Not secrets; listed here only so
+  // the per-provider scoping pass keeps them for claude and strips them
+  // elsewhere.
+  "ANTHROPIC_MODEL",
+  "ANTHROPIC_DEFAULT_OPUS_MODEL",
+  "ANTHROPIC_DEFAULT_SONNET_MODEL",
+  "ANTHROPIC_DEFAULT_HAIKU_MODEL",
+  "ANTHROPIC_SMALL_FAST_MODEL",
+  "GOOGLE_CLOUD_PROJECT",
+  "GOOGLE_CLOUD_LOCATION",
+  "GCLOUD_PROJECT",
+  "GEMINI_API_KEY",
+  "GOOGLE_API_KEY",
+  "GOOGLE_APPLICATION_CREDENTIALS",
+  "CLOUDSDK_CONFIG",
+  "GROK_CODE_XAI_API_KEY",
+  "XAI_API_KEY",
+  "OPENAI_API_KEY",
+  // Codex CLI legacy key names ride the generic CODEX_ prefix; scope them to
+  // codex so a non-codex child does not inherit them (codex's own api_key /
+  // chatgpt_login policy in provider-execution-env.ts still applies afterwards).
+  "CODEX_API_KEY",
+  "CODEX_TOKEN",
+  // Cursor's API key rides the generic CURSOR_ prefix; scope it to cursor.
+  "CURSOR_API_KEY",
+  // OpenCode's API key rides the generic OPENCODE_ prefix; scope it to opencode.
+  "OPENCODE_API_KEY",
+  "OPENROUTER_API_KEY",
+  "OPENROUTER_KEY",
+  "BLACKBOX_API_KEY",
+  "ZAI_API_KEY",
+  "ZHIPU_API_KEY",
+  "SYNTHETIC_API_KEY",
+  "KIRO_API_KEY",
+  "ANTIGRAVITY_API_KEY"
+]);
+var CLAUDE_VERTEX_REGION_PREFIX = "VERTEX_REGION_CLAUDE_";
+var CREDENTIAL_FAMILY_OWNERS = [
+  { prefix: "ANTHROPIC_", owners: ["claude", "anthropic"] },
+  { prefix: "COPILOT_", owners: ["copilot"] },
+  { prefix: "AZURE_OPENAI_", owners: ["codex", "openai"] }
+];
+var CREDENTIAL_KEY_SUFFIX = /_(?:KEY|TOKEN|SECRET|PASSWORD)$/;
+function providerSecretAllowlist(provider) {
+  switch ((provider ?? "").toLowerCase()) {
+    case "claude":
+    case "anthropic":
+      return /* @__PURE__ */ new Set([
+        "ANTHROPIC_API_KEY",
+        "CLAUDE_CODE_OAUTH_TOKEN",
+        "CLAUDE_CODE_USE_BEDROCK",
+        "CLAUDE_CODE_USE_VERTEX",
+        "ANTHROPIC_VERTEX_PROJECT_ID",
+        "CLOUD_ML_REGION",
+        "CLAUDE_CODE_USE_FOUNDRY",
+        "ANTHROPIC_FOUNDRY_RESOURCE",
+        "ANTHROPIC_FOUNDRY_BASE_URL",
+        "ANTHROPIC_FOUNDRY_API_KEY",
+        "ANTHROPIC_FOUNDRY_AUTH_TOKEN",
+        // Vertex model-default knobs (see PROVIDER_SECRET_KEYS comment). Kept
+        // for claude so the scoping pass doesn't re-strip the model overrides.
+        "ANTHROPIC_MODEL",
+        "ANTHROPIC_DEFAULT_OPUS_MODEL",
+        "ANTHROPIC_DEFAULT_SONNET_MODEL",
+        "ANTHROPIC_DEFAULT_HAIKU_MODEL",
+        "ANTHROPIC_SMALL_FAST_MODEL",
+        "GOOGLE_APPLICATION_CREDENTIALS",
+        "GOOGLE_CLOUD_PROJECT",
+        "GOOGLE_CLOUD_LOCATION",
+        "GCLOUD_PROJECT",
+        "CLOUDSDK_CONFIG"
+      ]);
+    case "gemini":
+      return /* @__PURE__ */ new Set([
+        "GEMINI_API_KEY",
+        "GOOGLE_API_KEY",
+        "GOOGLE_APPLICATION_CREDENTIALS",
+        "GOOGLE_CLOUD_PROJECT",
+        "GOOGLE_CLOUD_LOCATION",
+        "GCLOUD_PROJECT",
+        "CLOUDSDK_CONFIG"
+      ]);
+    case "codex":
+    case "openai":
+      return /* @__PURE__ */ new Set(["OPENAI_API_KEY", "CODEX_API_KEY", "CODEX_TOKEN"]);
+    case "copilot":
+      return /* @__PURE__ */ new Set();
+    case "cursor":
+      return /* @__PURE__ */ new Set(["CURSOR_API_KEY"]);
+    case "grok":
+      return /* @__PURE__ */ new Set(["XAI_API_KEY", "GROK_CODE_XAI_API_KEY"]);
+    case "blackbox":
+      return /* @__PURE__ */ new Set(["BLACKBOX_API_KEY"]);
+    case "opencode":
+      return /* @__PURE__ */ new Set([
+        "OPENROUTER_API_KEY",
+        "OPENROUTER_KEY",
+        "OPENAI_API_KEY",
+        "ANTHROPIC_API_KEY",
+        "GEMINI_API_KEY",
+        "GOOGLE_API_KEY",
+        "BLACKBOX_API_KEY",
+        "ZAI_API_KEY",
+        "ZHIPU_API_KEY",
+        "SYNTHETIC_API_KEY",
+        "OPENCODE_API_KEY"
+      ]);
+    case "kiro":
+      return /* @__PURE__ */ new Set(["KIRO_API_KEY"]);
+    case "antigravity":
+      return /* @__PURE__ */ new Set(["ANTIGRAVITY_API_KEY"]);
+    // Pi is a backend-agnostic host, so the key that matters belongs to whichever
+    // inference backend the operator configured. Sourced from the Pi adapter so
+    // this list cannot drift from Pi's auth detection (pi/backend-env.ts explains
+    // why that drift is not hypothetical).
+    // quirks-allow: secret-allowlist membership is provider credential metadata owned by the provider adapter, not runtime CLI quirks expressible in the declarative table
+    case "pi":
+      return new Set(PI_BACKEND_ENV_KEYS);
+    default:
+      return /* @__PURE__ */ new Set();
+  }
+}
+function scopeChildEnvForProvider(env, provider, _options) {
+  const scoped = envWithoutAmbientGitRepository(env);
+  const normalizedProvider = (provider ?? "").toLowerCase();
+  const allowedSecrets = providerSecretAllowlist(provider);
+  for (const key of PROVIDER_SECRET_KEYS) {
+    if (!allowedSecrets.has(key)) {
+      delete scoped[key];
+    }
+  }
+  for (const { prefix, owners } of CREDENTIAL_FAMILY_OWNERS) {
+    if (owners.includes(normalizedProvider)) continue;
+    for (const key of Object.keys(scoped)) {
+      if (key.startsWith(prefix) && CREDENTIAL_KEY_SUFFIX.test(key) && !allowedSecrets.has(key)) {
+        delete scoped[key];
+      }
+    }
+  }
+  const isClaude = normalizedProvider === "claude" || normalizedProvider === "anthropic";
+  const keepAws = isClaude || // quirks-allow: AWS credential forwarding is child-env secret-boundary policy for Bedrock-capable families, not a runtime CLI quirk
+  normalizedProvider === "codex" || normalizedProvider === "openai" || normalizedProvider === "opencode";
+  if (!isClaude) {
+    for (const key of Object.keys(scoped)) {
+      if (key.startsWith(CLAUDE_VERTEX_REGION_PREFIX)) {
+        delete scoped[key];
+      }
+      if (!keepAws && key.startsWith("AWS_")) {
+        delete scoped[key];
+      }
+    }
+  }
+  delete scoped.SSH_AUTH_SOCK;
+  delete scoped.GIT_SSH;
+  delete scoped.GIT_SSH_COMMAND;
+  return scoped;
+}
+function createScopedProviderChildEnv(provider, baseEnv = process.env) {
+  return scopeChildEnvForProvider(
+    createCleanChildEnv(void 0, filterParentEnvForProvider(baseEnv)),
+    provider
+  );
+}
+
+export {
+  PARENT_ENV_DENYLIST,
+  isSandboxAuthorityEnvVar,
+  stripClaudeSessionEnv,
+  createCleanChildEnv,
+  scopeChildEnvForProvider,
+  createScopedProviderChildEnv
+};
+//# sourceMappingURL=chunk-WGQAXLNA.js.map

package/dist/chunk-WJAL4JL3.js

@@ -0,0 +1,206 @@
+import {
+  parsePositiveInt
+} from "./chunk-T7E5JS6N.js";
+import {
+  resolveExecutionBoundary
+} from "./chunk-2VUEDIUM.js";
+import {
+  BUILD_IDLE_KILL_CAP_MS,
+  BUILD_IDLE_KILL_CEILING_FRACTION,
+  BUILD_IDLE_KILL_MS,
+  BUILD_IDLE_WARN_CAP_MS,
+  BUILD_IDLE_WARN_MS,
+  readEnv
+} from "./chunk-7VRJHTGZ.js";
+
+// src/core/providers/shared/idle-timeout.ts
+import { execFile, execFileSync } from "child_process";
+import path from "path";
+var DEFAULT_IDLE_KILL_CEILING_FRACTION = 0.8;
+var MIN_SIGNIFICANT_CPU_TIME_DELTA_SECONDS = 0.01;
+var REQUIRED_CONSECUTIVE_CPU_POLLS = 2;
+var PROVIDER_IDLE_ACTIVITY_SIGNALS = ["stdout", "stderr", "cpu"];
+function getProviderIdleDefaults(_provider) {
+  const boundary = resolveExecutionBoundary("agent-run");
+  return {
+    warnMs: boundary.idle?.warnAfterMs ?? 3e5,
+    killMs: boundary.idle?.killAfterMs ?? 9e5
+  };
+}
+function resolveCommandName(command) {
+  const posix = path.posix.basename(command);
+  const win32 = path.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 isLikelySilentMode(commandName, args) {
+  if (commandName === "CLAUDE") {
+    const idx = args.indexOf("--output-format");
+    const fmt = idx >= 0 ? args[idx + 1] : void 0;
+    return typeof fmt === "string" && fmt.toLowerCase() === "json";
+  }
+  return false;
+}
+function getIdleKillCeilingFraction() {
+  const raw = readEnv(BUILD_IDLE_KILL_CEILING_FRACTION).value ?? DEFAULT_IDLE_KILL_CEILING_FRACTION;
+  return Math.max(0.5, Math.min(0.95, raw));
+}
+function readOptionalIdleTimeout(read) {
+  try {
+    return read();
+  } catch {
+    return void 0;
+  }
+}
+function normalizeIdleTimeouts(warnMs, rawKillMs, hardTimeoutMs) {
+  if (!Number.isFinite(warnMs) || !Number.isFinite(rawKillMs) || warnMs <= 0 || rawKillMs <= 0) {
+    return null;
+  }
+  const ceilingMs = Number.isFinite(hardTimeoutMs) && hardTimeoutMs > 0 ? Math.max(1e3, Math.floor(hardTimeoutMs * getIdleKillCeilingFraction())) : rawKillMs;
+  const killMs = Math.min(rawKillMs, ceilingMs);
+  if (killMs <= 1) {
+    return null;
+  }
+  const adjustedWarnMs = killMs > 1e3 ? killMs - 1e3 : Math.max(1, Math.floor(killMs / 2));
+  return warnMs >= killMs ? { warnMs: adjustedWarnMs, killMs } : { warnMs, killMs };
+}
+function resolveIdleTimeoutPlan(command, args, hardTimeoutMs, absoluteOverrides) {
+  if (absoluteOverrides?.idleWarnMs !== void 0 && absoluteOverrides?.idleKillMs !== void 0) {
+    const normalized2 = normalizeIdleTimeouts(
+      absoluteOverrides.idleWarnMs,
+      absoluteOverrides.idleKillMs,
+      hardTimeoutMs
+    );
+    if (normalized2) {
+      return {
+        ...normalized2,
+        activitySignals: PROVIDER_IDLE_ACTIVITY_SIGNALS,
+        source: "flag",
+        sourceLabel: "flag"
+      };
+    }
+  }
+  const commandName = resolveCommandName(command);
+  const providerDefaults = getProviderIdleDefaults(commandName);
+  const defaultIdleKillCapMs = Number.isFinite(hardTimeoutMs) && hardTimeoutMs > 0 ? Math.max(12e5, Math.floor(hardTimeoutMs * getIdleKillCeilingFraction())) : 12e5;
+  const defaultIdleWarnCapMs = Number.isFinite(hardTimeoutMs) && hardTimeoutMs > 0 ? Math.max(6e5, Math.floor(defaultIdleKillCapMs / 2)) : 6e5;
+  const idleKillCapEnv = readEnv(BUILD_IDLE_KILL_CAP_MS).value;
+  const idleWarnCapEnv = readEnv(BUILD_IDLE_WARN_CAP_MS).value;
+  const idleKillCapEnvSet = process.env[BUILD_IDLE_KILL_CAP_MS.name] !== void 0;
+  const idleWarnCapEnvSet = process.env[BUILD_IDLE_WARN_CAP_MS.name] !== void 0;
+  const idleKillCeilingFractionEnvSet = process.env[BUILD_IDLE_KILL_CEILING_FRACTION.name] !== void 0;
+  const idleKillCapMs = idleKillCapEnv ?? defaultIdleKillCapMs;
+  const idleWarnCapMs = idleWarnCapEnv ?? defaultIdleWarnCapMs;
+  const scaledForProviderCli = Number.isFinite(hardTimeoutMs) && hardTimeoutMs > 0 ? {
+    warnMs: Math.min(idleWarnCapMs, Math.max(1e3, Math.floor(hardTimeoutMs * 0.75))),
+    killMs: Math.min(idleKillCapMs, Math.max(1e3, Math.floor(hardTimeoutMs * 0.95)))
+  } : null;
+  const scaledForSilentMode = Number.isFinite(hardTimeoutMs) && hardTimeoutMs > 0 ? {
+    warnMs: Math.min(idleWarnCapMs, Math.max(1e3, Math.floor(hardTimeoutMs * 0.6))),
+    killMs: Math.min(idleKillCapMs, Math.max(1e3, Math.floor(hardTimeoutMs * 0.85)))
+  } : null;
+  const isProviderCli = commandName === "CLAUDE" || commandName === "GEMINI" || commandName === "CURSOR_AGENT" || commandName === "CODEX" || commandName === "OPENCODE" || commandName === "GROK" || commandName === "COPILOT";
+  const providerWarnEnvName = `BUILD_IDLE_WARN_${commandName}_MS`;
+  const providerKillEnvName = `BUILD_IDLE_KILL_${commandName}_MS`;
+  const providerWarnEnv = parsePositiveInt(process.env[providerWarnEnvName]);
+  const providerKillEnv = parsePositiveInt(process.env[providerKillEnvName]);
+  const globalWarnEnv = readOptionalIdleTimeout(() => readEnv(BUILD_IDLE_WARN_MS).value);
+  const globalKillEnv = readOptionalIdleTimeout(() => readEnv(BUILD_IDLE_KILL_MS).value);
+  const defaultTimeouts = isLikelySilentMode(commandName, args) && scaledForSilentMode ? scaledForSilentMode : isProviderCli && scaledForProviderCli ? scaledForProviderCli : providerDefaults;
+  const warnMs = providerWarnEnv ?? globalWarnEnv ?? defaultTimeouts.warnMs;
+  const killMs = providerKillEnv ?? globalKillEnv ?? defaultTimeouts.killMs;
+  const normalized = normalizeIdleTimeouts(warnMs, killMs, Number.POSITIVE_INFINITY);
+  if (!normalized) {
+    return null;
+  }
+  const source = providerWarnEnv !== void 0 || providerKillEnv !== void 0 ? "provider-env" : globalWarnEnv !== void 0 || globalKillEnv !== void 0 || idleKillCapEnvSet || idleWarnCapEnvSet || idleKillCeilingFractionEnvSet ? "global-env" : "default";
+  const sourceLabel = source === "provider-env" ? `env:${[providerWarnEnv !== void 0 ? providerWarnEnvName : void 0, providerKillEnv !== void 0 ? providerKillEnvName : void 0].filter(Boolean).join(",")}` : source === "global-env" ? `env:${[
+    globalWarnEnv !== void 0 ? BUILD_IDLE_WARN_MS.name : void 0,
+    globalKillEnv !== void 0 ? BUILD_IDLE_KILL_MS.name : void 0,
+    idleWarnCapEnvSet ? BUILD_IDLE_WARN_CAP_MS.name : void 0,
+    idleKillCapEnvSet ? BUILD_IDLE_KILL_CAP_MS.name : void 0,
+    idleKillCeilingFractionEnvSet ? BUILD_IDLE_KILL_CEILING_FRACTION.name : void 0
+  ].filter(Boolean).join(",")}` : "default";
+  return {
+    ...normalized,
+    activitySignals: PROVIDER_IDLE_ACTIVITY_SIGNALS,
+    source,
+    sourceLabel
+  };
+}
+function resolveIdleTimeoutsMs(command, args, hardTimeoutMs, absoluteOverrides) {
+  const plan = resolveIdleTimeoutPlan(command, args, hardTimeoutMs, absoluteOverrides);
+  return plan ? { warnMs: plan.warnMs, killMs: plan.killMs } : null;
+}
+function formatIdleTimeoutDuration(ms) {
+  const totalSeconds = Math.max(1, Math.round(ms / 1e3));
+  const minutes = Math.floor(totalSeconds / 60);
+  const seconds = totalSeconds % 60;
+  if (minutes > 0 && seconds === 0) return `${minutes}m`;
+  if (minutes > 0) return `${minutes}m ${seconds}s`;
+  return `${seconds}s`;
+}
+function formatIdleTimeoutPlan(plan) {
+  return `warn after ${formatIdleTimeoutDuration(plan.warnMs)} idle; stop after ${formatIdleTimeoutDuration(plan.killMs)} idle; activity=${plan.activitySignals.join("/")}; source=${plan.sourceLabel}`;
+}
+function parseCpuTimeSeconds(rawValue) {
+  const trimmed = rawValue.trim();
+  if (!trimmed) return 0;
+  const daySplit = trimmed.split("-");
+  const timePart = daySplit.length > 1 ? daySplit[daySplit.length - 1] : daySplit[0];
+  const dayPart = daySplit.length > 1 ? daySplit.slice(0, -1).join("-") : void 0;
+  const days = typeof dayPart === "string" && dayPart.length > 0 ? Number.parseInt(dayPart, 10) : 0;
+  if (!Number.isFinite(days)) return void 0;
+  const parts = timePart?.split(":") ?? [];
+  if (parts.length < 2 || parts.length > 3) return void 0;
+  const seconds = Number.parseFloat(parts[parts.length - 1] ?? "");
+  const minutes = Number.parseInt(parts[parts.length - 2] ?? "", 10);
+  const hours = parts.length === 3 ? Number.parseInt(parts[0] ?? "", 10) : 0;
+  if (![seconds, minutes, hours].every((value) => Number.isFinite(value))) {
+    return void 0;
+  }
+  return days * 86400 + hours * 3600 + minutes * 60 + seconds;
+}
+function readCpuTimeSeconds(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return void 0;
+  try {
+    const out = execFileSync("ps", ["-o", "time=", "-p", String(pid)], {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    return parseCpuTimeSeconds(out);
+  } catch {
+    return void 0;
+  }
+}
+async function readCpuTimeSecondsAsync(pid) {
+  if (typeof pid !== "number" || !Number.isInteger(pid) || pid <= 0) return void 0;
+  return new Promise((resolve) => {
+    execFile(
+      "ps",
+      ["-o", "time=", "-p", String(pid)],
+      { encoding: "utf-8", timeout: 250, killSignal: "SIGKILL", maxBuffer: 1024 },
+      (error, stdout) => resolve(error ? void 0 : parseCpuTimeSeconds(stdout))
+    );
+  });
+}
+function evaluateCpuTimeProgressStreak(params) {
+  if (typeof params.currentCpuSeconds !== "number" || typeof params.previousCpuSeconds !== "number" || params.currentCpuSeconds - params.previousCpuSeconds < MIN_SIGNIFICANT_CPU_TIME_DELTA_SECONDS) {
+    return { nextBusyPolls: 0, shouldCountAsActivity: false };
+  }
+  const nextBusyPolls = params.currentBusyPolls + 1;
+  return {
+    nextBusyPolls,
+    shouldCountAsActivity: nextBusyPolls >= REQUIRED_CONSECUTIVE_CPU_POLLS
+  };
+}
+
+export {
+  resolveIdleTimeoutPlan,
+  resolveIdleTimeoutsMs,
+  formatIdleTimeoutPlan,
+  readCpuTimeSeconds,
+  readCpuTimeSecondsAsync,
+  evaluateCpuTimeProgressStreak
+};
+//# sourceMappingURL=chunk-WJAL4JL3.js.map