@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-6LAH2UV2.js

@@ -0,0 +1,525 @@
+import {
+  detectAutoloopAutoQualityGates
+} from "./chunk-OV5PKQMA.js";
+import {
+  selectCustomGateCommands
+} from "./chunk-J6NZX6QH.js";
+import {
+  FAILURE_POLICY,
+  classifyFailureEnvelope
+} from "./chunk-PRDHI2L5.js";
+import {
+  signalCoordinator
+} from "./chunk-GC4CRMTS.js";
+import {
+  atomicWriteJson
+} from "./chunk-RFDVSI4N.js";
+import {
+  parseJsonWithContext
+} from "./chunk-P6SSWAKY.js";
+import {
+  mkBuildTempDirSync
+} from "./chunk-D6WTZMZB.js";
+import {
+  boundedFailureDiagnostics
+} from "./chunk-AHU3FKPA.js";
+import {
+  emitWarning,
+  getRuntimeEnv,
+  mergeExecutionContextEnvOverrides
+} from "./chunk-7VRJHTGZ.js";
+
+// src/core/safety/recursion-tracker.ts
+import { chmodSync, existsSync, rmSync, unlinkSync } from "fs";
+import { chmod, mkdir, readFile, rm, unlink } from "fs/promises";
+import { join } from "path";
+var RecursionTracker = class {
+  stateDir;
+  stateFile;
+  maxDepth;
+  currentState = null;
+  previousStateFile;
+  cleanupHandlers = [];
+  /**
+   * Number of live, unbalanced `enter()` calls in THIS process. The tracker is a
+   * per-process singleton, so overlapping in-process competitions share one
+   * instance. Only the FIRST `enter()`
+   * establishes the depth/state file and only the LAST `exit()` tears it down;
+   * intermediate calls just adjust this count. This makes enter()/exit() safe to
+   * call from independent concurrent invocations without one clearing another's
+   * state. NOTE: the cross-PROCESS recursion DEPTH (the exponential-spawn guard)
+   * is unchanged — it is still derived once, on the first entry, from the parent
+   * state file; this counter only governs local teardown ordering.
+   */
+  activeEntries = 0;
+  /**
+   * Single-flight guard for first-entry establishment. The first concurrent
+   * `enter()` that finds no `currentState` runs the establishment work (read
+   * parent state file → derive depth → write our state file → set the child env
+   * pointer) exactly once; any other entrant that arrives while it is in flight
+   * awaits THIS promise instead of re-deriving depth. Without it, two concurrent
+   * first entries would both pass the `currentState === null` check and the
+   * second could read the first's just-written state file as its "parent",
+   * inflating depth to 1 for same-process concurrency. Cleared once settled so a
+   * later entry can retry if establishment failed.
+   */
+  establishmentInFlight = null;
+  constructor(maxDepth = 2) {
+    this.stateDir = mkBuildTempDirSync("recursion");
+    chmodSync(this.stateDir, 448);
+    this.stateFile = join(this.stateDir, `recursion-${process.pid}.json`);
+    this.maxDepth = maxDepth;
+    this.registerCleanupHandlers();
+  }
+  /**
+   * Initialize recursion tracking for this process.
+   * Checks if we're exceeding recursion limits.
+   *
+   * @throws Error if recursion depth exceeded
+   * @returns Current depth after increment
+   */
+  async enter() {
+    this.activeEntries += 1;
+    try {
+      if (this.currentState) {
+        return this.currentState.depth;
+      }
+      if (!this.establishmentInFlight) {
+        this.establishmentInFlight = this.establish();
+      }
+      try {
+        const state = await this.establishmentInFlight;
+        return state.depth;
+      } finally {
+        this.establishmentInFlight = null;
+      }
+    } catch (err) {
+      this.activeEntries -= 1;
+      throw err;
+    }
+  }
+  /**
+   * One-time first-entry establishment: read the parent state file, derive this
+   * process's depth, enforce the recursion limit, persist our state, and point
+   * children at it. Runs at most once concurrently (guarded by
+   * `establishmentInFlight`); the result is shared by all concurrent first
+   * entrants so they observe the same depth.
+   */
+  async establish() {
+    await this.ensureStateDir();
+    const parentStateFile = getRuntimeEnv("BUILD_RECURSION_STATE_FILE");
+    let parentState = null;
+    if (parentStateFile) {
+      try {
+        const content = await readFile(parentStateFile, "utf8");
+        parentState = parseJsonWithContext(content, "parent recursion state file");
+      } catch (_err) {
+        parentState = null;
+      }
+    }
+    const currentDepth = parentState ? parentState.depth + 1 : 0;
+    if (currentDepth >= this.maxDepth) {
+      throw new Error(
+        `Alert: RECURSION LIMIT EXCEEDED
+
+Maximum recursion depth: ${this.maxDepth}
+Current depth: ${currentDepth}
+Parent PIDs: ${parentState?.parentPids.join(" \u2192 ") || "none"}
+
+This safety limit prevents exponential process growth that could crash your system.
+Build detected nested parallel execution or recursive task spawning.
+
+Solution:
+- Start Build commands only at the top level, not from sub-agents
+- Check if your task accidentally spawns nested Build commands
+- Increase limit with BUILD_MAX_RECURSION_DEPTH env var (not recommended)
+`
+      );
+    }
+    const state = {
+      depth: currentDepth,
+      maxDepth: this.maxDepth,
+      parentPids: [...parentState?.parentPids || [], process.pid],
+      timestamp: Date.now()
+    };
+    this.currentState = state;
+    await atomicWriteJson(this.stateFile, state);
+    this.previousStateFile = parentStateFile;
+    mergeExecutionContextEnvOverrides({
+      BUILD_RECURSION_STATE_FILE: this.stateFile
+    });
+    return state;
+  }
+  /** Active state-file pointer to propagate to child execution contexts. */
+  getStateFilePath() {
+    return this.currentState ? this.stateFile : void 0;
+  }
+  /**
+   * Clean up recursion state for this process.
+   * Called automatically on process exit.
+   *
+   * Ref-counted: balances one `enter()`. When more than one live entry remains
+   * (concurrent/nested in-process invocations), this only decrements the count
+   * and returns WITHOUT tearing down, so one invocation cannot clear state that
+   * another still depends on. Only the last balancing `exit()` removes the state
+   * file and restores the parent env pointer.
+   *
+   * @param opts.force - Tear down immediately regardless of the live-entry count
+   *   (used by full-reset and signal/process-exit cleanup, where the whole
+   *   process is being reset or terminated). Default false.
+   */
+  async exit(opts) {
+    if (!opts?.force && this.activeEntries > 1) {
+      this.activeEntries -= 1;
+      return;
+    }
+    this.activeEntries = 0;
+    this.establishmentInFlight = null;
+    if (this.currentState) {
+      mergeExecutionContextEnvOverrides({
+        BUILD_RECURSION_STATE_FILE: this.previousStateFile
+      });
+      this.previousStateFile = void 0;
+    }
+    if (this.stateFile) {
+      try {
+        await unlink(this.stateFile);
+      } catch (err) {
+        const code = err?.code;
+        if (code === "ENOENT") {
+          this.currentState = null;
+          return;
+        }
+        emitWarning(
+          "WS-003",
+          {
+            subsystem: "safety",
+            executionPhase: "cleanup"
+          },
+          {
+            severity: "WARN" /* WARN */,
+            metadata: {
+              error: err instanceof Error ? err.message : String(err),
+              operation: "cleanupRecursionState",
+              stateFile: this.stateFile
+            }
+          }
+        );
+      }
+    }
+    this.currentState = null;
+  }
+  /**
+   * Get current recursion depth.
+   * Returns 0 if not yet entered.
+   */
+  getDepth() {
+    return this.currentState?.depth ?? 0;
+  }
+  /**
+   * Get maximum allowed recursion depth.
+   */
+  getMaxDepth() {
+    return this.maxDepth;
+  }
+  /**
+   * Get parent process PIDs for debugging.
+   */
+  getParentPids() {
+    return this.currentState?.parentPids ?? [];
+  }
+  /**
+   * Check if we can safely spawn child processes.
+   * Returns true if we're below recursion limit.
+   */
+  canSpawnChildren() {
+    const currentDepth = this.currentState?.depth ?? 0;
+    return currentDepth < this.maxDepth - 1;
+  }
+  /**
+   * Ensure state directory exists with secure permissions.
+   */
+  async ensureStateDir() {
+    if (!existsSync(this.stateDir)) {
+      await mkdir(this.stateDir, { recursive: true });
+      await chmod(this.stateDir, 448);
+    }
+  }
+  /**
+   * Register cleanup handlers for process exit.
+   */
+  registerCleanupHandlers() {
+    signalCoordinator.register("RecursionTracker", async () => {
+      await this.exit({ force: true });
+    });
+    const exitHandler = () => {
+      if (this.stateFile && existsSync(this.stateFile)) {
+        try {
+          unlinkSync(this.stateFile);
+        } catch {
+        }
+      }
+    };
+    process.on("exit", exitHandler);
+    this.cleanupHandlers = [() => process.off("exit", exitHandler)];
+  }
+  /**
+   * Clean up resources and remove event listeners.
+   * Also removes the temporary directory created in constructor.
+   */
+  close() {
+    for (const cleanup of this.cleanupHandlers) {
+      try {
+        cleanup();
+      } catch (_error) {
+      }
+    }
+    this.cleanupHandlers = [];
+    if (this.stateDir && existsSync(this.stateDir)) {
+      try {
+        rmSync(this.stateDir, { recursive: true, force: true });
+      } catch (_error) {
+      }
+    }
+  }
+  /**
+   * Async cleanup for temporary directory.
+   * Preferred over close() when async context is available.
+   */
+  async closeAsync() {
+    for (const cleanup of this.cleanupHandlers) {
+      try {
+        cleanup();
+      } catch (_error) {
+      }
+    }
+    this.cleanupHandlers = [];
+    if (this.stateDir && existsSync(this.stateDir)) {
+      try {
+        await rm(this.stateDir, { recursive: true, force: true });
+      } catch (_error) {
+      }
+    }
+  }
+};
+var _globalRecursionTracker = null;
+var DEFAULT_MAX_RECURSION_DEPTH = 2;
+function parseMaxRecursionDepthEnv(value) {
+  if (value === void 0) {
+    return DEFAULT_MAX_RECURSION_DEPTH;
+  }
+  const normalized = value.trim();
+  if (!/^\d+$/.test(normalized)) {
+    return DEFAULT_MAX_RECURSION_DEPTH;
+  }
+  const parsed = Number(normalized);
+  return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : DEFAULT_MAX_RECURSION_DEPTH;
+}
+function resolveMaxRecursionDepth(override) {
+  if (override !== void 0) {
+    return Number.isSafeInteger(override) ? override : DEFAULT_MAX_RECURSION_DEPTH;
+  }
+  return parseMaxRecursionDepthEnv(getRuntimeEnv("BUILD_MAX_RECURSION_DEPTH"));
+}
+function getGlobalRecursionTracker(maxDepth) {
+  if (!_globalRecursionTracker) {
+    const depth = resolveMaxRecursionDepth(maxDepth);
+    _globalRecursionTracker = new RecursionTracker(depth);
+  }
+  return _globalRecursionTracker;
+}
+async function resetGlobalRecursionTracker() {
+  if (_globalRecursionTracker) {
+    await _globalRecursionTracker.exit({ force: true });
+  }
+}
+var globalRecursionTracker = new Proxy({}, {
+  get(_target, prop) {
+    if (prop === "reset") {
+      return resetGlobalRecursionTracker;
+    }
+    const tracker = getGlobalRecursionTracker();
+    const value = tracker[prop];
+    return typeof value === "function" ? value.bind(tracker) : value;
+  }
+});
+
+// src/orchestrator/autoloop-gate-rediscovery.ts
+import { readFileSync } from "fs";
+import * as path from "path";
+function readPackageScriptsForCustomGateSelection(root) {
+  try {
+    const parsed = JSON.parse(readFileSync(path.join(root, "package.json"), "utf8"));
+    if (!parsed.scripts || typeof parsed.scripts !== "object" || Array.isArray(parsed.scripts)) {
+      return {};
+    }
+    return Object.fromEntries(
+      Object.entries(parsed.scripts).filter(
+        (entry) => typeof entry[1] === "string"
+      )
+    );
+  } catch {
+    return {};
+  }
+}
+function createCandidateGateCommandResolver(input) {
+  return async (workingDir) => {
+    const resolver = await import("./evidence-plan-resolver-5FUAP3SA.js");
+    const plan = input.analysis ? await resolver.resolveEvidencePlan(input.analysis, input.taskDescription, workingDir) : await resolver.resolveEvidencePlanFromPrompt({
+      prompt: input.taskDescription,
+      cwd: workingDir
+    });
+    if (plan.isFallback) return [];
+    return selectCustomGateCommands(
+      plan.surfaces.flatMap((surface) => surface.commands),
+      {
+        ...input.selectionOptions,
+        normalizeEvidencePlanCommands: true,
+        packageScripts: readPackageScriptsForCustomGateSelection(workingDir)
+      }
+    ).selectedCommands;
+  };
+}
+async function rediscoverCandidateGates(emitter, telemetry, config, workingDir, iteration) {
+  const resolveCustomGates = config.rediscoverQualityGates;
+  if (!resolveCustomGates || config.runQualityGates) {
+    return;
+  }
+  const detected = await detectAutoloopAutoQualityGates(workingDir, config.qualityGatesMode);
+  const customGateCommands = await resolveCustomGates(workingDir).catch(() => []);
+  if (!detected.enabled && customGateCommands.length === 0) {
+    return;
+  }
+  config.runQualityGates = true;
+  config.qualityGatesMode = detected.mode ?? config.qualityGatesMode;
+  config.qualityGatePolicy = "enabled";
+  config.rediscoverQualityGates = void 0;
+  if (customGateCommands.length > 0) {
+    config.customGateCommands = customGateCommands;
+    config.customGateCommandsSource = "evidence_plan";
+  }
+  const detectedCommands = [.../* @__PURE__ */ new Set([...detected.detectedCommands, ...customGateCommands])];
+  const event = {
+    type: "quality_gates_rediscovered",
+    iteration,
+    mode: config.qualityGatesMode,
+    detectedCommands,
+    notRunCommands: (detected.notRunByMode ?? []).filter(
+      (command) => !customGateCommands.includes(command)
+    )
+  };
+  telemetry?.logEvent({
+    name: "autoloop_quality_gates_rediscovered",
+    timestamp: /* @__PURE__ */ new Date(),
+    properties: { iteration, mode: event.mode, detectedCommands, customGateCommands }
+  });
+  emitter.emit("quality_gates_rediscovered", event);
+}
+
+// src/orchestrator/autoloop-recovery.ts
+var TERMINAL_ENVIRONMENT_FAILURES = /* @__PURE__ */ new Set([
+  "auth_unavailable",
+  "cli_missing",
+  "quota_exhausted",
+  "model_unavailable",
+  "sandbox_denied",
+  "invalid_configuration"
+]);
+function isPositiveClassification(failure) {
+  return failure.confidence === "high" && (failure.evidenceSource === "typed" || failure.evidenceSource === "parsed");
+}
+function deriveDirectAutoloopRecovery(failure, options = {}) {
+  if (failure.category === "user_cancelled" && isPositiveClassification(failure)) {
+    return "operator_stop";
+  }
+  if (options.deliveryRescueEligible === true) {
+    return "delivery_rescue";
+  }
+  if (isPositiveClassification(failure) && TERMINAL_ENVIRONMENT_FAILURES.has(failure.category)) {
+    return "terminal_stop";
+  }
+  if (isPositiveClassification(failure) && FAILURE_POLICY[failure.category].retryable && failure.retryable === true && failure.mutationState === "none-observed") {
+    return "transport_retry";
+  }
+  return "agent_correction";
+}
+function serializeDirectAutoloopFailureRecovery(failure, disposition) {
+  return {
+    schemaVersion: 1,
+    failure: {
+      category: failure.category,
+      evidenceSource: failure.evidenceSource,
+      executionPhase: failure.executionPhase,
+      mutationState: failure.mutationState,
+      retryable: failure.retryable,
+      failoverEligible: failure.failoverEligible,
+      confidence: failure.confidence
+    },
+    recovery: { disposition }
+  };
+}
+var MAX_CARRIED_FAILING_TESTS = 5;
+var MAX_CARRIED_TEST_NAME_CHARS = 200;
+function boundTestFailureEvidence(testsExecuted) {
+  const failingTests = (testsExecuted?.failingTests ?? []).slice(0, MAX_CARRIED_FAILING_TESTS).map((name) => name.slice(0, MAX_CARRIED_TEST_NAME_CHARS));
+  const command = testsExecuted?.command;
+  const outputTail = boundedFailureDiagnostics({
+    // A newline-joined command folds several commands and cannot select a parser.
+    ...command && !command.includes("\n") ? { command } : {},
+    outputTail: testsExecuted?.outputTail
+  });
+  if (failingTests.length === 0 && !outputTail) return void 0;
+  return { failingTests, ...outputTail ? { outputTail } : {} };
+}
+var DirectAutoloopExecutionFailure = class extends Error {
+  failureEnvelope;
+  iterationFingerprint;
+  testFailure;
+  constructor(error, failureEnvelope, detail = "", iterationFingerprint, testFailure) {
+    super(`${error.message}${detail}`, { cause: error });
+    this.name = "DirectAutoloopExecutionFailure";
+    this.failureEnvelope = failureEnvelope;
+    this.iterationFingerprint = iterationFingerprint;
+    this.testFailure = testFailure;
+  }
+};
+function createDirectAutoloopCancellationFailure(error, executionPhase, mutationState = executionPhase === "post-run" ? "none-observed" : "unknown") {
+  return new DirectAutoloopExecutionFailure(
+    error,
+    classifyFailureEnvelope(
+      { reason: "cancelled", message: error.message },
+      { executionPhase, mutationState }
+    )
+  );
+}
+function createDirectAutoloopProviderFailure(error, filesModifiedCount, changedFilesReadable, detail = "", iterationFingerprint, testsExecuted) {
+  const mutationState = filesModifiedCount > 0 ? "observed" : changedFilesReadable ? "none-observed" : "unknown";
+  return new DirectAutoloopExecutionFailure(
+    error,
+    classifyFailureEnvelope(error, { executionPhase: "post-run", mutationState }),
+    detail,
+    iterationFingerprint,
+    boundTestFailureEvidence(testsExecuted)
+  );
+}
+function getCarriedDirectAutoloopFailureEnvelope(error) {
+  return error instanceof DirectAutoloopExecutionFailure ? error.failureEnvelope : void 0;
+}
+function getCarriedDirectAutoloopIterationFingerprint(error) {
+  return error instanceof DirectAutoloopExecutionFailure ? error.iterationFingerprint : void 0;
+}
+
+export {
+  globalRecursionTracker,
+  readPackageScriptsForCustomGateSelection,
+  createCandidateGateCommandResolver,
+  rediscoverCandidateGates,
+  deriveDirectAutoloopRecovery,
+  serializeDirectAutoloopFailureRecovery,
+  DirectAutoloopExecutionFailure,
+  createDirectAutoloopCancellationFailure,
+  createDirectAutoloopProviderFailure,
+  getCarriedDirectAutoloopFailureEnvelope,
+  getCarriedDirectAutoloopIterationFingerprint
+};
+//# sourceMappingURL=chunk-6LAH2UV2.js.map