@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-D37WY7SH.js

@@ -0,0 +1,1060 @@
+import {
+  contextWindowAvailability
+} from "./chunk-Z7CDQNH3.js";
+import {
+  classifyFailure
+} from "./chunk-PRDHI2L5.js";
+import {
+  CircuitBreakerError,
+  createCircuitBreakerOptions,
+  executeWithCircuitBreaker
+} from "./chunk-JVHGMURQ.js";
+import {
+  createRetryOptions,
+  withRetry
+} from "./chunk-4QKP6I4C.js";
+import {
+  isTelemetryPersistenceEnabled
+} from "./chunk-SDPIFNLD.js";
+import {
+  ModelInvocationsDB,
+  captureInvocationRegistryVersion,
+  ensurePendingInvocationCostEnrichment,
+  generateInvocationId,
+  modelEvidenceAvailability,
+  observedSpeedAvailability,
+  requestEvidenceAvailability,
+  requestedServiceTierAvailability,
+  resolveInvocationsDbPath
+} from "./chunk-Q64IR2Z2.js";
+import {
+  ModelMetadataResolver
+} from "./chunk-YVCMDVBB.js";
+import {
+  JsonParseError,
+  safeJsonParse
+} from "./chunk-XJ2E7YEJ.js";
+import {
+  readTrackedToolOutputRoots,
+  shouldExcludeFile,
+  shouldExcludePorcelainEntry,
+  shouldExcludeStatusPath
+} from "./chunk-5EQN56OZ.js";
+import {
+  parseGitStatus
+} from "./chunk-5KQETTNS.js";
+import {
+  execGit
+} from "./chunk-MHLEZQQI.js";
+import {
+  ProviderExecutionError,
+  providerExecutionErrorStreamOptions
+} from "./chunk-RRC5BL7B.js";
+import {
+  resolveBuildRoot
+} from "./chunk-CHA2HDE5.js";
+import {
+  BUILD_ACTIVE_TASK_ID,
+  BUILD_LAB_ID,
+  BUILD_LAB_RUN_ID,
+  BUILD_MOCK_PROVIDERS,
+  BUILD_PROJECT_ID,
+  BUILD_RUN_ID,
+  BUILD_TELEMETRY_DIR,
+  BUILD_WORKER_VARIANT,
+  debugLog,
+  emitWarning,
+  getExecutionContext,
+  getRuntimeEnv,
+  hasExecutionContext,
+  isDebugMode,
+  readEnv
+} from "./chunk-7VRJHTGZ.js";
+
+// src/core/providers/shared/invocation-telemetry.ts
+import { createHash } from "crypto";
+import path from "path";
+
+// src/core/providers/shared/invocation-context-window.ts
+var REPORTED_CONTEXT_WINDOW_KEY = /^modelUsage\/[^/]+\/contextWindow$/;
+function resolveInvocationContextWindow(input) {
+  const reported = new Set(
+    Object.entries(input.reportedDimensions ?? {}).filter(([key, value]) => REPORTED_CONTEXT_WINDOW_KEY.test(key) && value > 0).map(([, value]) => value)
+  );
+  if (reported.size === 1) return [...reported][0];
+  if (reported.size > 1 || input.contextSelector || !input.providerId) return void 0;
+  for (const modelId of input.modelIds) {
+    const model = modelId?.trim();
+    if (!model) continue;
+    try {
+      const window = ModelMetadataResolver.getContextWindow(input.providerId, model, {
+        env: input.env
+      });
+      if (window !== void 0) return window;
+    } catch {
+    }
+  }
+  return void 0;
+}
+
+// src/core/providers/shared/invocation-telemetry.ts
+var AGENT_ROLE_ENV_KEY = "BUILD_AGENT_ROLE";
+function invocationErrorCategory(record) {
+  if (record.failure instanceof ProviderExecutionError && record.failure.category) {
+    return record.failure.category;
+  }
+  if (record.failure !== void 0 && record.failure !== null) {
+    return classifyFailure(record.failure);
+  }
+  const code = record.errorCode?.trim();
+  if (!code) return record.status === "error" ? "unknown" : null;
+  const exit = /^exit_(\d+)$/i.exec(code);
+  return classifyFailure(exit ? { providerExitCode: Number(exit[1]) } : { reason: code });
+}
+function effectiveInvocationEnv(env) {
+  return env ? { ...process.env, ...env } : process.env;
+}
+function normalizeRequestSizeBytes(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.floor(value) : null;
+}
+async function recordInvocationTiming(record) {
+  try {
+    const requestSentMs = Number(record.timeRequestSentMs);
+    if (!Number.isFinite(requestSentMs) || requestSentMs <= 0) {
+      return;
+    }
+    const executionSource = resolveInvocationExecutionSource(record);
+    const providerId = normalizeTelemetryId(record.providerId);
+    const modelId = normalizeTelemetryId(record.canonicalModelId) ?? normalizeTelemetryId(record.modelId);
+    if (executionSource === "live" && (!providerId || !modelId)) {
+      debugLog("[Telemetry] Skipped live invocation timing without provider/model identity");
+      return;
+    }
+    const firstTokenMs = typeof record.timeFirstTokenMs === "number" && Number.isFinite(record.timeFirstTokenMs) ? record.timeFirstTokenMs : null;
+    const lastTokenMs = typeof record.timeLastTokenMs === "number" && Number.isFinite(record.timeLastTokenMs) ? record.timeLastTokenMs : null;
+    const timeToFirstTokenMs = firstTokenMs !== null ? Math.max(0, Math.floor(firstTokenMs - requestSentMs)) : null;
+    const totalTimeMs = lastTokenMs !== null ? Math.max(0, Math.floor(lastTokenMs - requestSentMs)) : null;
+    const threadedBuildDir = record.env ? normalizeTelemetryId(record.env[BUILD_TELEMETRY_DIR.name]) : normalizeTelemetryId(getRuntimeEnv(BUILD_TELEMETRY_DIR.name));
+    const buildDir = record.buildDir ?? threadedBuildDir ?? (hasExecutionContext() ? getExecutionContext().buildDir : path.join(resolveBuildRoot(process.cwd()), ".build-project"));
+    if (!isTelemetryPersistenceEnabled(buildDir)) {
+      return;
+    }
+    const invocationsDbPath = resolveInvocationsDbPath(buildDir);
+    const db = new ModelInvocationsDB(invocationsDbPath);
+    try {
+      const registryVersion = captureInvocationRegistryVersion(db, record.registrySnapshot) ?? "unavailable";
+      const invocationId = generateInvocationId();
+      const runId = normalizeTelemetryId(record.runId) ?? resolveEnvAttributionId(record, BUILD_RUN_ID.name) ?? normalizeTelemetryId(record.parentWorkflowId) ?? normalizeTelemetryId(record.competitionId) ?? normalizeTelemetryId(record.taskId);
+      const attemptId = normalizeTelemetryId(record.attemptId) ?? invocationId;
+      const labId = record.env ? normalizeTelemetryId(record.env[BUILD_LAB_ID.name]) : normalizeTelemetryId(readEnv(BUILD_LAB_ID).value);
+      const labRunId = record.env ? normalizeTelemetryId(record.env[BUILD_LAB_RUN_ID.name]) : normalizeTelemetryId(readEnv(BUILD_LAB_RUN_ID).value);
+      db.insertInvocation({
+        id: invocationId,
+        timestamp: requestSentMs,
+        providerId: providerId ?? "unknown",
+        modelId: modelId ?? "auto",
+        registryVersion,
+        tokensIn: record.tokensIn ?? null,
+        tokensOut: record.tokensOut ?? null,
+        timeRequestSentMs: requestSentMs,
+        timeFirstTokenMs: firstTokenMs,
+        timeLastTokenMs: lastTokenMs,
+        timeToFirstTokenMs,
+        totalTimeMs,
+        status: record.status,
+        errorCode: invocationErrorCategory(record),
+        requestSizeBytes: normalizeRequestSizeBytes(record.requestSizeBytes),
+        agentRole: record.agentRole ?? resolveEnvAttributionId(record, AGENT_ROLE_ENV_KEY),
+        copilotSubcommand: record.copilotSubcommand ?? null,
+        parentWorkflowId: record.parentWorkflowId ?? null,
+        executionSource,
+        // ModelIdentity fields (canonicalModelId already mapped into modelId above)
+        requestedModelId: normalizeTelemetryId(record.requestedModelId),
+        executionModelId: normalizeTelemetryId(record.executionModelId),
+        reportedModelId: normalizeTelemetryId(record.reportedModelId),
+        backend: formatServedRoute(record.backend, record.servedPrecision),
+        scope: normalizeTelemetryId(record.scope),
+        contextSelector: normalizeTelemetryId(record.contextSelector),
+        resolutionSource: normalizeTelemetryId(record.resolutionSource),
+        runId,
+        attemptId,
+        attemptOrdinal: record.attemptOrdinal ?? 1,
+        projectId: normalizeTelemetryId(record.projectId) ?? resolveEnvAttributionId(record, BUILD_PROJECT_ID.name),
+        labId,
+        labRunId,
+        providerReportedCostUsd: finiteOrNull(record.providerReportedCostUsd),
+        buildCalculatedCostUsd: finiteOrNull(record.buildCalculatedCostUsd),
+        ...resolveInvocationCostAttribution(record)
+      });
+      const usage = {
+        ...record.tokenUsage ?? {
+          inputTokens: record.tokensIn ?? void 0,
+          outputTokens: record.tokensOut ?? void 0
+        },
+        extraDimensions: mergeExtraDimensions(
+          record.tokenUsage?.extraDimensions,
+          record.reportedModelUsageDimensions
+        )
+      };
+      const hasUsage = Object.values(usage).some((value) => typeof value === "number") || Object.keys(usage.extraDimensions ?? {}).length > 0;
+      let evidenceId;
+      if (hasUsage) {
+        const evidenceRunId = runId ?? invocationId;
+        const evidencePayload = {
+          invocationId,
+          runId: evidenceRunId,
+          attemptId,
+          usage,
+          provenance: record.usageProvenance ?? "provider_reported"
+        };
+        evidenceId = createHash("sha256").update(JSON.stringify(evidencePayload)).digest("hex");
+        db.insertUsageEvidence({
+          evidenceId,
+          invocationId,
+          runId: evidenceRunId,
+          attemptId,
+          eventSemantics: usage.eventSemantics ?? "logical_run_aggregate",
+          provenance: record.usageProvenance ?? "provider_reported",
+          inputTokens: finiteOrNull(usage.inputTokens),
+          outputTokens: finiteOrNull(usage.outputTokens),
+          cacheReadTokens: finiteOrNull(usage.cachedInputTokens),
+          cacheWriteTokens: finiteOrNull(usage.cacheCreationInputTokens),
+          reasoningTokens: finiteOrNull(usage.reasoningTokens),
+          toolTokens: finiteOrNull(usage.toolTokens),
+          cacheReadIncludedInInput: usage.cacheReadTokensIncludedInInput,
+          cacheWriteIncludedInInput: usage.cacheCreationTokensIncludedInInput,
+          extraDimensionsJson: usage.extraDimensions ? JSON.stringify(usage.extraDimensions) : null,
+          availabilityJson: JSON.stringify({
+            input: usage.inputTokens === void 0 ? "not_emitted" : "available",
+            output: usage.outputTokens === void 0 ? "not_emitted" : "available",
+            cacheRead: usage.cachedInputTokens === void 0 ? "not_emitted" : "available",
+            cacheWrite: usage.cacheCreationInputTokens === void 0 ? "not_emitted" : "available",
+            reasoning: usage.reasoningTokens === void 0 ? "not_emitted" : "available",
+            tool: usage.toolTokens === void 0 ? "not_emitted" : "available",
+            ...requestedServiceTierAvailability(record.requestedServiceTier),
+            ...observedSpeedAvailability(record.observedSpeed),
+            ...modelEvidenceAvailability(record.modelEvidence),
+            ...requestEvidenceAvailability(record.requestEvidence),
+            ...contextWindowAvailability(
+              resolveInvocationContextWindow({
+                providerId,
+                modelIds: [record.reportedModelId, record.executionModelId, modelId],
+                contextSelector: record.contextSelector,
+                reportedDimensions: record.reportedModelUsageDimensions,
+                env: effectiveInvocationEnv(record.env)
+              })
+            )
+          }),
+          parserVersion: "usage-evidence-v1",
+          createdAt: Date.now()
+        });
+      }
+      try {
+        await ensurePendingInvocationCostEnrichment(db, {
+          aggregate: false,
+          refreshRegistrySnapshot: false
+        });
+      } catch (error) {
+        debugLog(
+          `[Telemetry] Failed to enrich invocation cost: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    } finally {
+      db.close();
+    }
+  } catch (error) {
+    debugLog(
+      `[Telemetry] Failed to record invocation timing: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function mergeExtraDimensions(own, reported) {
+  return own || reported ? { ...own, ...reported } : void 0;
+}
+function finiteOrNull(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : null;
+}
+function resolveInvocationExecutionSource(record = {}) {
+  if (record.executionSource) return record.executionSource;
+  const env = record.env;
+  if (env?.BUILD_MOCK_PROVIDERS === "1") {
+    return "mock";
+  }
+  if (process.env.NODE_ENV === "test" || process.env.VITEST === "true") return "test";
+  if (readEnv(BUILD_MOCK_PROVIDERS).value === "1") return "mock";
+  return "live";
+}
+function formatServedRoute(route, precision) {
+  const normalizedRoute = normalizeTelemetryId(route);
+  const normalizedPrecision = normalizeTelemetryId(precision);
+  return normalizedRoute && normalizedPrecision ? `${normalizedRoute}@${normalizedPrecision}` : normalizedRoute;
+}
+function normalizeTelemetryId(value) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+function firstTelemetryId(...values) {
+  for (const value of values) {
+    const normalized = normalizeTelemetryId(value);
+    if (normalized) return normalized;
+  }
+  return null;
+}
+function resolveEnvAttributionId(record, key) {
+  return normalizeTelemetryId(record.env?.[key]) ?? normalizeTelemetryId(getRuntimeEnv(key));
+}
+function resolveInvocationCostAttribution(record) {
+  const taskId = firstTelemetryId(
+    record.taskId,
+    resolveEnvAttributionId(record, BUILD_ACTIVE_TASK_ID.name)
+  );
+  const variantId = firstTelemetryId(
+    record.variantId,
+    resolveEnvAttributionId(record, BUILD_WORKER_VARIANT.name)
+  );
+  const competitionId = firstTelemetryId(record.competitionId, taskId);
+  return { taskId, competitionId, variantId };
+}
+
+// src/core/providers/shared/prompt-request-bytes.ts
+function measurePromptRequestBytes(...channels) {
+  let total = 0;
+  let measured = false;
+  for (const channel of channels) {
+    if (typeof channel !== "string") continue;
+    total += Buffer.byteLength(channel, "utf8");
+    measured = true;
+  }
+  return measured ? total : null;
+}
+
+// src/core/providers/shared/pure-cli-runner.ts
+async function getGitHead(workingDir) {
+  try {
+    const { execa } = await import("execa");
+    const result = await execa("git", ["rev-parse", "HEAD"], { cwd: workingDir });
+    const head = result.stdout.trim();
+    return head.length > 0 ? head : void 0;
+  } catch (err) {
+    if (isDebugMode()) {
+      console.warn(`[PureCliRunner] Unable to resolve HEAD in ${workingDir}:`, err);
+    }
+    return void 0;
+  }
+}
+async function getGitBranch(workingDir) {
+  try {
+    const { execa } = await import("execa");
+    const result = await execa("git", ["branch", "--show-current"], { cwd: workingDir });
+    const branch = result.stdout.trim();
+    return branch.length > 0 ? branch : void 0;
+  } catch (err) {
+    if (isDebugMode()) {
+      console.warn(`[PureCliRunner] Unable to resolve branch in ${workingDir}:`, err);
+    }
+    return void 0;
+  }
+}
+function parseNameOnlyLines(output) {
+  return output.split("\0").filter((line) => line.length > 0);
+}
+function changedPathsFromPorcelain(porcelain, trackedRoots) {
+  return parseGitStatus(porcelain).filter((entry) => entry.path.length > 0 && !shouldExcludePorcelainEntry(entry, trackedRoots)).map((entry) => entry.path);
+}
+async function readPorcelainPaths(workingDir, porcelain) {
+  return changedPathsFromPorcelain(porcelain, await readTrackedToolOutputRoots(workingDir));
+}
+function isOnlyMetaChanges(files) {
+  return files.length > 0 && files.every((file) => shouldExcludeFile(file));
+}
+function isChangedFile(file, trackedRoots) {
+  return file.length > 0 && !shouldExcludeStatusPath(file, false, trackedRoots);
+}
+async function getGitStatusPaths(workingDir) {
+  try {
+    const { execa } = await import("execa");
+    const status = await execa("git", ["status", "--porcelain", "--untracked-files=all"], {
+      cwd: workingDir,
+      reject: false
+    });
+    if (status.exitCode !== 0) {
+      throw new Error(status.stderr.trim() || `git status exited ${status.exitCode}`);
+    }
+    return new Set(await readPorcelainPaths(workingDir, status.stdout));
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Unable to read git status in ${workingDir}: ${message}`);
+  }
+}
+async function captureGitBaseline(workingDir, knownPaths) {
+  const trackedRoots = await readTrackedToolOutputRoots(workingDir);
+  const paths = knownPaths === void 0 ? await getGitStatusPaths(workingDir) : new Set([...knownPaths].filter((file) => isChangedFile(file, trackedRoots)));
+  const fileStates = /* @__PURE__ */ new Map();
+  if (paths.size > 0) {
+    const { fingerprintPathState } = await import("./workspace-tree-identity-JO5PSKTW.js");
+    for (const file of paths) fileStates.set(file, await fingerprintPathState(workingDir, file));
+  }
+  return { paths, fileStates };
+}
+async function detectGitChangedFiles(workingDir, baseline) {
+  const { execa } = await import("execa");
+  const files = /* @__PURE__ */ new Set();
+  const baselineHead = typeof baseline === "string" ? baseline : baseline?.baselineHead;
+  const snapshot = typeof baseline === "string" ? void 0 : baseline?.baselineSnapshot;
+  if (snapshot === null) throw new Error("Git change detection baseline is unavailable");
+  const baselineStatusPaths = typeof baseline === "string" ? /* @__PURE__ */ new Set() : new Set(snapshot?.paths ?? baseline?.baselineStatusPaths ?? []);
+  const currentHead = await getGitHead(workingDir);
+  if (baselineHead && currentHead && baselineHead !== currentHead) {
+    try {
+      const diff = await execa("git", ["diff", "--name-only", "-z", baselineHead, currentHead], {
+        cwd: workingDir,
+        reject: false
+      });
+      const trackedRoots = await readTrackedToolOutputRoots(workingDir, baselineHead);
+      for (const file of parseNameOnlyLines(diff.stdout)) {
+        if (isChangedFile(file, trackedRoots)) {
+          files.add(file);
+        }
+      }
+    } catch {
+    }
+  }
+  const statusPaths = await getGitStatusPaths(workingDir);
+  statusPaths.forEach((file) => {
+    if (!baselineStatusPaths.has(file)) {
+      files.add(file);
+    }
+  });
+  if (snapshot?.fileStates.size) {
+    const { fingerprintPathState } = await import("./workspace-tree-identity-JO5PSKTW.js");
+    for (const [file, before] of snapshot.fileStates) {
+      if (await fingerprintPathState(workingDir, file) !== before) files.add(file);
+    }
+  }
+  return Array.from(files);
+}
+
+// src/core/providers/shared/retry-budget.ts
+var RetryBudget = class {
+  maxTotalAttempts;
+  usedAttempts;
+  constructor(options) {
+    this.maxTotalAttempts = options?.maxTotalAttempts ?? 5;
+    this.usedAttempts = 0;
+  }
+  /**
+   * Returns true if there are remaining attempts in the budget.
+   */
+  hasRemaining() {
+    return this.usedAttempts < this.maxTotalAttempts;
+  }
+  /**
+   * Number of remaining attempts.
+   */
+  get remaining() {
+    return Math.max(0, this.maxTotalAttempts - this.usedAttempts);
+  }
+  /**
+   * Number of attempts consumed so far.
+   */
+  get used() {
+    return this.usedAttempts;
+  }
+  /**
+   * Consume one attempt from the budget.
+   * @returns true if the attempt was allowed, false if the budget is exhausted.
+   */
+  consume() {
+    if (this.usedAttempts >= this.maxTotalAttempts) {
+      return false;
+    }
+    this.usedAttempts += 1;
+    return true;
+  }
+  /**
+   * Reset the budget to its initial state.
+   */
+  reset() {
+    this.usedAttempts = 0;
+  }
+};
+
+// src/core/providers/shared/workspace-retry-safety.ts
+import { createHash as createHash2 } from "crypto";
+import { promises as fs } from "fs";
+import * as path2 from "path";
+function isEnoentError(error) {
+  return Boolean(
+    error && typeof error === "object" && "code" in error && error.code === "ENOENT"
+  );
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+async function captureWorkspaceFingerprintOnce(workingDir) {
+  const [head, status, staged, unstaged, untracked] = await Promise.all([
+    execGit(["rev-parse", "HEAD"], { cwd: workingDir }),
+    execGit(["status", "--porcelain=v1", "--untracked-files=all", "-z"], {
+      cwd: workingDir
+    }),
+    execGit(["diff", "--cached", "--binary", "--full-index", "--no-ext-diff"], {
+      cwd: workingDir
+    }),
+    execGit(["diff", "--binary", "--full-index", "--no-ext-diff"], { cwd: workingDir }),
+    execGit(["ls-files", "--others", "--exclude-standard", "-z"], { cwd: workingDir })
+  ]);
+  const failed = [status, staged, unstaged, untracked].find((result) => result.exitCode !== 0);
+  if (failed) {
+    return {
+      kind: "unavailable",
+      error: failed.stderr.trim() || "git state query failed"
+    };
+  }
+  const hash = createHash2("sha256");
+  for (const [label, value] of [
+    ["head", head.exitCode === 0 ? head.stdout : "<unborn>"],
+    ["status", status.stdout],
+    ["staged", staged.stdout],
+    ["unstaged", unstaged.stdout]
+  ]) {
+    hash.update(label).update("\0").update(value).update("\0");
+  }
+  const untrackedPaths = untracked.stdout.split("\0").filter(Boolean).sort();
+  for (const relativePath of untrackedPaths) {
+    const absolutePath = path2.join(workingDir, relativePath);
+    let stats;
+    try {
+      stats = await fs.lstat(absolutePath);
+    } catch (error) {
+      if (isEnoentError(error)) {
+        return { kind: "unstable", error: errorMessage(error) };
+      }
+      throw error;
+    }
+    hash.update("untracked\0").update(relativePath).update("\0");
+    try {
+      if (stats.isSymbolicLink()) {
+        hash.update("symlink\0").update(await fs.readlink(absolutePath));
+      } else if (stats.isFile()) {
+        hash.update("file\0").update(await fs.readFile(absolutePath));
+      } else {
+        hash.update(`other:${stats.mode}:${stats.size}\0`);
+      }
+    } catch (error) {
+      if (isEnoentError(error)) {
+        return { kind: "unstable", error: errorMessage(error) };
+      }
+      throw error;
+    }
+    hash.update("\0");
+  }
+  return { kind: "ready", fingerprint: hash.digest("hex") };
+}
+async function captureWorkspaceRetryState(workingDir) {
+  try {
+    const insideWorkTree = await execGit(["rev-parse", "--is-inside-work-tree"], {
+      cwd: workingDir
+    });
+    if (insideWorkTree.exitCode !== 0 || insideWorkTree.stdout.trim() !== "true") {
+      return {
+        available: false,
+        error: insideWorkTree.stderr.trim() || "working directory is not inside a Git worktree"
+      };
+    }
+    const first = await captureWorkspaceFingerprintOnce(workingDir);
+    if (first.kind === "ready") {
+      return { available: true, fingerprint: first.fingerprint };
+    }
+    if (first.kind === "unavailable") {
+      return { available: false, error: first.error };
+    }
+    const second = await captureWorkspaceFingerprintOnce(workingDir);
+    if (second.kind === "ready") {
+      return { available: true, fingerprint: second.fingerprint };
+    }
+    return {
+      available: false,
+      error: second.error
+    };
+  } catch (error) {
+    return {
+      available: false,
+      error: errorMessage(error)
+    };
+  }
+}
+async function assertWorkspaceRetryIsSafe(options) {
+  if (!options.retryable) {
+    return;
+  }
+  const attemptEndState = await captureWorkspaceRetryState(options.workingDir);
+  const unavailable = !options.attemptStartState.available || !attemptEndState.available;
+  const changed = !unavailable && options.attemptStartState.fingerprint !== attemptEndState.fingerprint;
+  if (!unavailable && !changed) {
+    return;
+  }
+  const detail = options.attemptStartState.error ?? attemptEndState.error ?? "workspace fingerprint could not be captured";
+  const explanation = changed ? "the failed attempt changed HEAD, the index, the working tree, or untracked files" : `Build could not verify that the worktree stayed unchanged: ${detail}`;
+  throw new ProviderExecutionError(
+    `${options.providerName} retry suppressed because ${explanation}. Inspect the worktree and preserve or revert the attempt changes before retrying.`,
+    {
+      retryable: false,
+      reason: changed ? "workspace_changed_during_attempt" : "workspace_state_unknown",
+      providerName: options.providerId,
+      cause: options.originalError instanceof Error ? options.originalError : void 0
+    }
+  );
+}
+
+// src/core/providers/shared/retry-worktree-state.ts
+async function captureRetryWorktreeState(workingDir) {
+  return captureWorkspaceRetryState(workingDir);
+}
+function suppressUnsafeRetryAfterMutatedWorktree(providerName, reason, originalError, detail) {
+  const explanation = reason === "changed" ? "the failed attempt changed HEAD, the index, the working tree, or untracked files" : `Build could not verify that the worktree stayed unchanged${detail ? `: ${detail}` : ""}`;
+  return new ProviderExecutionError(
+    `${providerName} retry suppressed because ${explanation}. Inspect the worktree and preserve or revert the attempt's changes before running ${providerName} again.`,
+    {
+      retryable: false,
+      reason: reason === "changed" ? "workspace_changed_during_attempt" : "workspace_state_unknown",
+      providerName,
+      cause: originalError
+    }
+  );
+}
+function isRetryableProviderError(error) {
+  return error instanceof ProviderExecutionError && error.retryable === true;
+}
+async function rejectUnsafeFullPromptRetry(options) {
+  if (!options.requireCleanState && !isRetryableProviderError(options.error) || options.isResumeSafe === true) {
+    return;
+  }
+  const attemptEndState = await captureRetryWorktreeState(options.workingDir);
+  if (!options.attemptStartState.available || !attemptEndState.available) {
+    throw suppressUnsafeRetryAfterMutatedWorktree(
+      options.providerName,
+      "unavailable",
+      options.error,
+      options.attemptStartState.error ?? attemptEndState.error
+    );
+  }
+  if (options.attemptStartState.fingerprint !== attemptEndState.fingerprint) {
+    throw suppressUnsafeRetryAfterMutatedWorktree(options.providerName, "changed", options.error);
+  }
+}
+
+// src/core/providers/shared/workspace-edits-parser.ts
+import * as path3 from "path";
+function isUnsafePath(candidate, options = {}) {
+  if (!candidate) return true;
+  const { rootDir = process.cwd(), allowAbsolute = false, allowHomeExpansion = false } = options;
+  const normalized = candidate.normalize("NFD").replace(/[\u0300-\u036f]/g, "").replace(/\\/g, "/");
+  if (normalized.includes("\0")) return true;
+  if (!allowAbsolute && path3.isAbsolute(candidate)) return true;
+  if (!allowHomeExpansion && normalized.startsWith("~")) return true;
+  if (normalized.startsWith("../")) return true;
+  if (normalized.includes("/../")) return true;
+  if (/^[a-zA-Z]:[\\/]/.test(candidate)) return true;
+  try {
+    const resolved = path3.resolve(rootDir, normalized);
+    const resolvedRoot = path3.resolve(rootDir);
+    const relative2 = path3.relative(resolvedRoot, resolved);
+    const escapesRoot = relative2.startsWith("..") || path3.isAbsolute(relative2);
+    return escapesRoot;
+  } catch {
+    return true;
+  }
+}
+function parseWorkspaceEditsFromJsonl(rawOutput, options = {}) {
+  if (!rawOutput) {
+    return { cleanedOutput: rawOutput, edits: [], errors: [] };
+  }
+  const edits = [];
+  const errors = [];
+  const kept = [];
+  const pathSafetyOptions = options.workspaceRoot ? { rootDir: options.workspaceRoot } : {};
+  for (const line of rawOutput.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith("{")) {
+      kept.push(line);
+      continue;
+    }
+    let parsed = null;
+    try {
+      parsed = safeJsonParse(trimmed, {
+        debug: false,
+        context: "workspace edit JSON"
+      });
+    } catch (error) {
+      const baseMessage = error instanceof JsonParseError ? error.message : `Failed to parse workspace edit JSON: ${error instanceof Error ? error.message : String(error)}`;
+      const message = `Malformed workspace edit (${baseMessage})`;
+      errors.push(message);
+      options.onError?.(message);
+      kept.push(line);
+      continue;
+    }
+    if (parsed.type && parsed.type !== "build_edit") {
+      kept.push(line);
+      continue;
+    }
+    if (!parsed.op || !parsed.path) {
+      const message = `Incomplete workspace edit payload (missing op/path): ${trimmed}`;
+      errors.push(message);
+      options.onError?.(message);
+      kept.push(line);
+      continue;
+    }
+    const validOps = ["writeFile", "appendFile", "deleteFile", "renameFile"];
+    if (!validOps.includes(parsed.op)) {
+      const message = `Invalid workspace edit operation "${parsed.op}" (expected: ${validOps.join(", ")})`;
+      errors.push(message);
+      options.onError?.(message);
+      kept.push(line);
+      continue;
+    }
+    if (isUnsafePath(parsed.path, pathSafetyOptions) || parsed.fromPath && isUnsafePath(parsed.fromPath, pathSafetyOptions)) {
+      const message = `Rejected unsafe workspace edit path: ${parsed.path}${parsed.fromPath ? ` (from: ${parsed.fromPath})` : ""}`;
+      errors.push(message);
+      options.onError?.(message);
+      kept.push(line);
+      continue;
+    }
+    edits.push({
+      op: parsed.op,
+      path: parsed.path.replace(/\\/g, "/"),
+      contents: parsed.contents,
+      fromPath: parsed.fromPath?.replace(/\\/g, "/")
+    });
+  }
+  return {
+    cleanedOutput: kept.join("\n"),
+    edits,
+    errors
+  };
+}
+
+// src/core/providers/shared/retry-notice.ts
+import { AsyncLocalStorage } from "async_hooks";
+var scope = new AsyncLocalStorage();
+var GENERIC_REASONS = /* @__PURE__ */ new Set(["non_zero_exit", "provider_cli_error"]);
+function withProviderRetryNotices(listener, fn) {
+  return scope.run(listener, fn);
+}
+function describeRetryReason(error) {
+  if (error instanceof ProviderExecutionError) {
+    if (typeof error.reason === "string" && error.reason.length > 0 && !GENERIC_REASONS.has(error.reason)) {
+      return error.reason;
+    }
+    if (error.category !== void 0) return error.category;
+  }
+  return classifyFailure(error);
+}
+function formatProviderRetryNotice(notice) {
+  return `${notice.provider} attempt ${notice.attempt} of ${notice.maxAttempts} failed (${notice.reason}); retrying.`;
+}
+function notifyProviderRetry(notice) {
+  const listener = scope.getStore();
+  if (!listener) return;
+  try {
+    listener(notice);
+  } catch {
+  }
+}
+
+// src/core/providers/shared/write-workspace-edits.ts
+import * as fs2 from "fs/promises";
+import * as path4 from "path";
+var MAX_WRITE_RETRIES = 3;
+var RETRY_BASE_DELAY_MS = 10;
+async function appendWithRetry(editsFile, payload) {
+  let attempt = 0;
+  while (true) {
+    try {
+      await fs2.appendFile(editsFile, payload, "utf8");
+      return;
+    } catch (error) {
+      attempt += 1;
+      if (attempt >= MAX_WRITE_RETRIES) {
+        throw error;
+      }
+      const delayMs = RETRY_BASE_DELAY_MS * 2 ** (attempt - 1);
+      await new Promise((resolve2) => setTimeout(resolve2, delayMs));
+    }
+  }
+}
+async function writeWorkspaceEditsToFile(worktreePath, edits) {
+  if (!edits || edits.length === 0) {
+    return { success: true, written: 0, failed: 0, skipped: 0 };
+  }
+  const editsDir = path4.join(worktreePath, ".build-project");
+  const editsFile = path4.join(editsDir, "edits.jsonl");
+  let written = 0;
+  let skipped = 0;
+  try {
+    await fs2.mkdir(editsDir, { recursive: true });
+    const payloads = [];
+    for (const edit of edits) {
+      if (isUnsafePath(edit.path, { rootDir: worktreePath }) || shouldExcludeFile(edit.path) || edit.fromPath && (isUnsafePath(edit.fromPath, { rootDir: worktreePath }) || shouldExcludeFile(edit.fromPath))) {
+        emitWarning(
+          "WS-003",
+          {
+            subsystem: "workspace-edits",
+            executionPhase: "execution"
+          },
+          {
+            severity: "WARN" /* WARN */,
+            metadata: {
+              error: "Unsafe workspace edit path",
+              path: edit.path,
+              fromPath: edit.fromPath,
+              operation: "writeWorkspaceEdits"
+            }
+          }
+        );
+        skipped += 1;
+        continue;
+      }
+      const payload = {
+        type: "build_edit",
+        op: edit.op,
+        path: edit.path,
+        ...edit.contents !== void 0 ? { contents: edit.contents } : {},
+        ...edit.fromPath !== void 0 ? { fromPath: edit.fromPath } : {}
+      };
+      payloads.push(`${JSON.stringify(payload)}
+`);
+    }
+    if (payloads.length > 0) {
+      await appendWithRetry(editsFile, payloads.join(""));
+      written = payloads.length;
+    }
+    return {
+      success: written > 0 || skipped === 0,
+      written,
+      failed: written === 0 && skipped > 0 ? skipped : 0,
+      skipped,
+      ...written === 0 && skipped > 0 ? { error: "All workspace edits were skipped by safety filters" } : {}
+    };
+  } catch (error) {
+    const errorMessage2 = error instanceof Error ? error.message : String(error);
+    emitWarning(
+      "WS-003",
+      {
+        subsystem: "workspace-edits",
+        executionPhase: "execution"
+      },
+      {
+        severity: "ERROR" /* ERROR */,
+        metadata: {
+          error: errorMessage2,
+          operation: "writeWorkspaceEdits",
+          editsFile
+        }
+      }
+    );
+    return {
+      success: false,
+      written,
+      failed: edits.length - written - skipped,
+      skipped,
+      error: errorMessage2
+    };
+  }
+}
+
+// src/core/providers/shared/runner-lifecycle.ts
+var DEFAULT_PROVIDER_CIRCUIT_BREAKER_OPTIONS = createCircuitBreakerOptions({
+  failureThreshold: 5,
+  recoveryTimeout: 6e4
+});
+async function executeWithResilience(fn, options) {
+  const {
+    providerName,
+    operation = "execute_prompt",
+    maxAttempts = 3,
+    retryBudget,
+    onRetry,
+    abortSignal,
+    circuitBreakerOptions = DEFAULT_PROVIDER_CIRCUIT_BREAKER_OPTIONS,
+    errorParser,
+    providerId,
+    fastRetryMode = false,
+    initialDelayMs,
+    maxDelayMs,
+    backoffMultiplier,
+    deadlineMs,
+    minimumAttemptTimeMs,
+    circuitBreakerScope,
+    retryWorktreeDir,
+    isRetryResumeSafe
+  } = options;
+  const retryOptions = createRetryOptions({
+    providerName,
+    operation,
+    maxAttempts,
+    initialDelayMs: fastRetryMode ? 0 : initialDelayMs,
+    maxDelayMs: fastRetryMode ? 0 : maxDelayMs,
+    backoffMultiplier,
+    retryBudget,
+    onRetry: (attempt, error) => {
+      onRetry?.(attempt, error);
+      notifyProviderRetry({
+        provider: providerId ?? providerName,
+        attempt,
+        maxAttempts,
+        reason: describeRetryReason(error)
+      });
+    },
+    abortSignal,
+    suppressDelayFloors: fastRetryMode,
+    deadlineMs,
+    minimumAttemptTimeMs
+  });
+  const wrappedFn = async () => {
+    const attemptStartState = retryWorktreeDir ? await captureRetryWorktreeState(retryWorktreeDir) : void 0;
+    try {
+      return await executeWithCircuitBreaker(
+        providerName,
+        errorParser ? async () => {
+          try {
+            return await fn();
+          } catch (error) {
+            throw wrapProviderError(error, errorParser, providerId ?? providerName);
+          }
+        } : fn,
+        { isFailure: countsTowardProviderBreaker, ...circuitBreakerOptions },
+        circuitBreakerScope
+      );
+    } catch (error) {
+      const thrown = errorParser && error instanceof CircuitBreakerError ? wrapProviderError(error, errorParser, providerId ?? providerName) : error;
+      if (retryWorktreeDir && attemptStartState) {
+        await rejectUnsafeFullPromptRetry({
+          workingDir: retryWorktreeDir,
+          attemptStartState,
+          error: thrown,
+          providerName: providerId ?? providerName,
+          isResumeSafe: isRetryResumeSafe?.() === true
+        });
+      }
+      throw thrown;
+    }
+  };
+  return withRetry(wrappedFn, retryOptions);
+}
+var PROVIDER_BREAKER_CATEGORIES = /* @__PURE__ */ new Set([
+  "transport_error",
+  "rate_limited"
+]);
+function countsTowardProviderBreaker(error) {
+  const category = error instanceof ProviderExecutionError && error.category !== void 0 ? error.category : classifyFailure(error);
+  return PROVIDER_BREAKER_CATEGORIES.has(category);
+}
+function stampFailureCategory(error) {
+  const category = classifyFailure(error);
+  error.category = category;
+  if (error.context) error.context.category = category;
+  return error;
+}
+function wrapProviderError(error, errorParser, providerId) {
+  if (error instanceof CircuitBreakerError) {
+    return stampFailureCategory(
+      new ProviderExecutionError(error.message, {
+        retryable: false,
+        reason: "circuit_open",
+        providerName: providerId,
+        cause: error
+      })
+    );
+  }
+  if (error instanceof ProviderExecutionError && (error.category !== void 0 || isReplaySuppressed(error.parsedError))) {
+    return error.category === void 0 ? stampFailureCategory(error) : error;
+  }
+  const parsed = errorParser(error);
+  if (error instanceof ProviderExecutionError) {
+    const GENERIC_FALLBACK_REASONS = /* @__PURE__ */ new Set(["non_zero_exit", "provider_cli_error"]);
+    const hasExplicitTerminalReason = typeof error.reason === "string" && error.reason.length > 0 && !GENERIC_FALLBACK_REASONS.has(error.reason);
+    const retryable = error.retryable === false && hasExplicitTerminalReason ? false : parsed.retryable;
+    return stampFailureCategory(
+      new ProviderExecutionError(error.message, {
+        retryable,
+        exitCode: error.exitCode,
+        statusCode: error.statusCode,
+        reason: error.reason,
+        signal: error.signal,
+        terminationSource: error.terminationSource,
+        // Preserve truncated public fields and non-enumerable full raw carriers.
+        ...providerExecutionErrorStreamOptions(error),
+        providerName: providerId,
+        cause: error.cause,
+        parsedError: parsed,
+        prelaunch: error.prelaunch
+      })
+    );
+  }
+  const originalMessage = error instanceof Error ? error.message : String(error);
+  return stampFailureCategory(
+    new ProviderExecutionError(originalMessage, {
+      retryable: parsed.retryable,
+      providerName: providerId,
+      cause: error,
+      parsedError: parsed
+    })
+  );
+}
+var TOOL_ACTIVITY_REPLAY_SUPPRESSED = "tool_activity_without_resume";
+function isReplaySuppressed(parsed) {
+  const debugInfo = parsed?.debugInfo;
+  return debugInfo?.retrySuppressed === TOOL_ACTIVITY_REPLAY_SUPPRESSED;
+}
+function suppressReplayAfterToolActivity(error, errorParser, providerId) {
+  const wrapped = wrapProviderError(error, errorParser, providerId);
+  if (!wrapped.retryable) return error;
+  const target = error instanceof ProviderExecutionError ? error : wrapped;
+  const parsed = wrapped.parsedError;
+  target.retryable = false;
+  target.parsedError = {
+    ...parsed,
+    retryable: false,
+    debugInfo: { ...parsed.debugInfo ?? {}, retrySuppressed: TOOL_ACTIVITY_REPLAY_SUPPRESSED }
+  };
+  return target;
+}
+async function persistWorkspaceEdits(workingDir, edits) {
+  if (edits.length === 0) return;
+  try {
+    await writeWorkspaceEditsToFile(workingDir, edits);
+  } catch (error) {
+    if (process.env.NODE_ENV !== "test") {
+      console.warn(
+        `[runner-lifecycle] Failed to persist workspace edits for ${workingDir}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+}
+
+export {
+  recordInvocationTiming,
+  measurePromptRequestBytes,
+  getGitHead,
+  getGitBranch,
+  readPorcelainPaths,
+  isOnlyMetaChanges,
+  captureGitBaseline,
+  detectGitChangedFiles,
+  RetryBudget,
+  withProviderRetryNotices,
+  formatProviderRetryNotice,
+  captureWorkspaceRetryState,
+  assertWorkspaceRetryIsSafe,
+  captureRetryWorktreeState,
+  rejectUnsafeFullPromptRetry,
+  parseWorkspaceEditsFromJsonl,
+  DEFAULT_PROVIDER_CIRCUIT_BREAKER_OPTIONS,
+  executeWithResilience,
+  wrapProviderError,
+  isReplaySuppressed,
+  suppressReplayAfterToolActivity,
+  persistWorkspaceEdits
+};
+//# sourceMappingURL=chunk-D37WY7SH.js.map