@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/autonomous-loop-controller-2WL363LW.js

@@ -0,0 +1,4386 @@
+import {
+  resolveAutoloopElapsedMs
+} from "./chunk-MZ5WYKNA.js";
+import {
+  describeMissingGateBaseline,
+  failsIdenticallyOnBaseline,
+  gateEvidenceOf
+} from "./chunk-CBSWKQCX.js";
+import {
+  createDirectAutoloopCancellationFailure,
+  deriveDirectAutoloopRecovery,
+  getCarriedDirectAutoloopFailureEnvelope,
+  getCarriedDirectAutoloopIterationFingerprint,
+  globalRecursionTracker,
+  rediscoverCandidateGates,
+  serializeDirectAutoloopFailureRecovery
+} from "./chunk-6LAH2UV2.js";
+import "./chunk-OV5PKQMA.js";
+import {
+  DEFAULT_AUTOLOOP_TIMEBOX_MS,
+  resolveAutoloopTimeboxMs,
+  resolveAutoloopValidationMode
+} from "./chunk-6FIBNIQU.js";
+import {
+  computeMonotonicAutoloopEscalation,
+  execWithTimeout,
+  validateRequirements
+} from "./chunk-OTXLMJKP.js";
+import {
+  autoloopPresetIncludesGateKind
+} from "./chunk-GQIP72ZJ.js";
+import {
+  tailUtf8
+} from "./chunk-K7FAFORM.js";
+import "./chunk-J6NZX6QH.js";
+import {
+  COMPLETION_BLOCKER_MISSING_SUBSTANTIVE_EVIDENCE,
+  COMPLETION_BLOCKER_PROGRESS_VERIFICATION_UNAVAILABLE,
+  completionStatusAllowsSuccess,
+  customGatesAllowCompletion,
+  customGatesHaveBlockingFailure,
+  evaluateCompletion,
+  hasOnlyStyleVerificationEvidence,
+  hasSubstantiveCompletionEvidence,
+  isBenignSemanticSkip,
+  isBlockingCustomGateForCompletion,
+  isBlockingQualityGateForCompletion,
+  isNonBlockingQualityGateSkip,
+  isSemanticCheckBlocking,
+  isSemanticCompletionSatisfied,
+  isSemanticErrorSkip,
+  isSuccessLikeControllerReason,
+  isUnavailableOrSkippedQualityGate,
+  qualityGatesAllowCompletion,
+  qualityGatesHaveBlockingFailure,
+  readReturnedTaskFailure,
+  verificationGatesUnavailableOnly
+} from "./chunk-IJM4GKAT.js";
+import {
+  countBlockingVulnerabilities,
+  isTestEvidenceGate,
+  isTestEvidenceGateResult,
+  testEvidenceGateId
+} from "./chunk-QOFLUS24.js";
+import {
+  isSignificantProgress,
+  rateProgress
+} from "./chunk-4ZPLWEZO.js";
+import {
+  calculateSatisfactionScore,
+  checkAcceptanceCriteria
+} from "./chunk-C7AGUJ5K.js";
+import "./chunk-VLMDM56Q.js";
+import "./chunk-VCGSWN5M.js";
+import "./chunk-6CAU7VBA.js";
+import "./chunk-IYY3HQAD.js";
+import "./chunk-TGCVL74Y.js";
+import "./chunk-MKASIKWZ.js";
+import "./chunk-UDNNAQN5.js";
+import "./chunk-HKO45NLZ.js";
+import {
+  classifyFailureEnvelope
+} from "./chunk-PRDHI2L5.js";
+import {
+  abortableDelay
+} from "./chunk-4QKP6I4C.js";
+import "./chunk-GWHGTG37.js";
+import "./chunk-XON4ZCYX.js";
+import "./chunk-S6I4KISU.js";
+import "./chunk-3P5IN5E7.js";
+import {
+  globalProcessLimiter
+} from "./chunk-SF6YK3JI.js";
+import "./chunk-JBBB2Y47.js";
+import "./chunk-RBKLOUXA.js";
+import "./chunk-VMFZEVVX.js";
+import "./chunk-T7E5JS6N.js";
+import {
+  ORCHESTRATOR_FEATURE_FLAGS
+} from "./chunk-ZJB6SQPA.js";
+import {
+  signalCoordinator
+} from "./chunk-GC4CRMTS.js";
+import "./chunk-C3DH3NCY.js";
+import "./chunk-IVZEONFC.js";
+import "./chunk-XTXYIISX.js";
+import "./chunk-MEMSY6VY.js";
+import "./chunk-VBNCKCCI.js";
+import "./chunk-33IGPPUI.js";
+import "./chunk-UPHU64NB.js";
+import "./chunk-JLS65NUQ.js";
+import "./chunk-FRBPKBFE.js";
+import "./chunk-BAWJNMWF.js";
+import "./chunk-LX4F24ZH.js";
+import "./chunk-BBPIILO2.js";
+import "./chunk-2NMNFUQA.js";
+import "./chunk-I7SCBHJN.js";
+import "./chunk-TGXXYDL4.js";
+import {
+  isSafeGitRef
+} from "./chunk-D2M2Y5ID.js";
+import "./chunk-UJP3XM54.js";
+import "./chunk-MULMXX4V.js";
+import "./chunk-UTDEOPKV.js";
+import "./chunk-RFDVSI4N.js";
+import "./chunk-M4BUEXXF.js";
+import "./chunk-ZH4G3FU5.js";
+import "./chunk-726G6WDL.js";
+import {
+  readUntrackedFileDiffEntry,
+  renderUntrackedFileDiff
+} from "./chunk-5UBIFVRD.js";
+import "./chunk-7HPCIOMA.js";
+import "./chunk-P6SSWAKY.js";
+import {
+  classifyResolverCommand,
+  countSecurityVulnerabilities
+} from "./chunk-6TBEX4R4.js";
+import "./chunk-PXKERBKX.js";
+import "./chunk-QYQOVOLR.js";
+import "./chunk-AEQWV746.js";
+import "./chunk-SVUNZOPG.js";
+import "./chunk-KUEWV2JH.js";
+import "./chunk-R2TIYG7U.js";
+import {
+  parseDiffGitHeaderPaths
+} from "./chunk-5FKHIKTS.js";
+import {
+  runVerificationCommand
+} from "./chunk-S2E632FQ.js";
+import "./chunk-XJ2E7YEJ.js";
+import "./chunk-B7YRSULE.js";
+import "./chunk-4U6XK2DG.js";
+import "./chunk-BY6ODHNZ.js";
+import "./chunk-3H4MWYIC.js";
+import "./chunk-DP7FKP6W.js";
+import "./chunk-VIFHYTI5.js";
+import "./chunk-XGU6PBO5.js";
+import "./chunk-F55YABKV.js";
+import "./chunk-D6WTZMZB.js";
+import "./chunk-5EQN56OZ.js";
+import {
+  shouldIgnoreRepoPath
+} from "./chunk-RBBTBCHX.js";
+import "./chunk-4DJL2VXA.js";
+import {
+  boundedFailureDiagnostics,
+  detectProjectCapabilities,
+  parseFailureOutput
+} from "./chunk-AHU3FKPA.js";
+import {
+  deriveVerificationDisposition
+} from "./chunk-TUQMMFEQ.js";
+import {
+  describeVerificationCommand,
+  detectExitZeroVerifyFailure
+} from "./chunk-EPAMVGI3.js";
+import "./chunk-6CB3KJRY.js";
+import "./chunk-L2S235CU.js";
+import "./chunk-D4VJFCGZ.js";
+import "./chunk-RPIMAMV7.js";
+import "./chunk-ALDTFNZ3.js";
+import "./chunk-QOIASNEJ.js";
+import "./chunk-2VUEDIUM.js";
+import "./chunk-MJ6WNSIX.js";
+import "./chunk-5KQETTNS.js";
+import "./chunk-J2ICMYDA.js";
+import "./chunk-2VLJUXJU.js";
+import "./chunk-PPZESPJT.js";
+import "./chunk-XCOIBNET.js";
+import "./chunk-Y733RB7T.js";
+import "./chunk-H3HGMISG.js";
+import "./chunk-FAZBRHGG.js";
+import "./chunk-CJBSZX3F.js";
+import "./chunk-C3KCMAJP.js";
+import "./chunk-FKCG7K6H.js";
+import "./chunk-AJN5Y5YZ.js";
+import {
+  execGit
+} from "./chunk-MHLEZQQI.js";
+import "./chunk-HEP3ILP4.js";
+import "./chunk-BQJOGAWT.js";
+import "./chunk-WV3KQDPE.js";
+import "./chunk-VSWC5ZXI.js";
+import "./chunk-XV7NZL4B.js";
+import "./chunk-KKQKWAMF.js";
+import "./chunk-RWQQIKIC.js";
+import "./chunk-GVJGSSKM.js";
+import "./chunk-QJ6OEH4K.js";
+import "./chunk-BD3PGW6A.js";
+import "./chunk-43OKHTW4.js";
+import "./chunk-MNOVBYFU.js";
+import "./chunk-QXBKTJT6.js";
+import "./chunk-4BTDUT2S.js";
+import "./chunk-35J4NE6S.js";
+import "./chunk-RIMARPCF.js";
+import "./chunk-HGFXODKO.js";
+import "./chunk-N5DX4JAK.js";
+import "./chunk-V2TVPO3X.js";
+import "./chunk-RRC5BL7B.js";
+import "./chunk-352PCJLK.js";
+import "./chunk-RCP2Y6DQ.js";
+import "./chunk-M6UHOC4I.js";
+import "./chunk-KTMW65UX.js";
+import "./chunk-3JKNRYEE.js";
+import "./chunk-MT2WAIR3.js";
+import "./chunk-WGQAXLNA.js";
+import "./chunk-ONHAMBN6.js";
+import "./chunk-XSJTIFUY.js";
+import "./chunk-XWIZ6B5S.js";
+import "./chunk-U4DRS6ZW.js";
+import "./chunk-I56TH7VM.js";
+import "./chunk-Z5WGNULV.js";
+import "./chunk-O26L6F7F.js";
+import "./chunk-RJ6RSNT6.js";
+import "./chunk-TAJPCXSB.js";
+import "./chunk-56WPYDJH.js";
+import "./chunk-RSYTSBOO.js";
+import "./chunk-STW7OFOA.js";
+import "./chunk-CHA2HDE5.js";
+import "./chunk-JNMWYMC6.js";
+import {
+  BUILD_AUTOLOOP_COMPLETION_SIGNAL,
+  BUILD_AUTOLOOP_JUDGE,
+  BUILD_AUTOLOOP_MAX_ITERATIONS,
+  BUILD_AUTOLOOP_MAX_MEMORY,
+  BUILD_AUTOLOOP_MIN_PROGRESS,
+  BUILD_AUTOLOOP_QUALITY_GATES_MODE,
+  debugLog,
+  emitWarning,
+  readEnv,
+  readRawEnv,
+  withExecutionContextEnvOverrides
+} from "./chunk-7VRJHTGZ.js";
+import "./chunk-XDM65LBX.js";
+import "./chunk-CPSVQR2I.js";
+import "./chunk-PZ5AY32C.js";
+
+// src/orchestrator/autonomous-loop-controller.ts
+import { createHash } from "crypto";
+import { EventEmitter } from "events";
+import * as os from "os";
+import { performance } from "perf_hooks";
+
+// src/core/project/compile-failure-output.ts
+var MAVEN_LEVEL_TAG = String.raw`(?:\[(?:ERROR|INFO|WARNING)\]\s+)?`;
+var COMPILE_DIAGNOSTIC_PATTERNS = [
+  // Rust compiler diagnostics: `error[E0382]:` (the bare form is BARE_ERROR_LINE)
+  /^\s*error\[[A-Z]\d+\]:/m,
+  /\berror:\s+could not compile\b/i,
+  // Go compiler diagnostics: `path/file.go:line:col: message`
+  /^\s*(?:\.[/\\][^\n]+\.go:\d+:\d+:|[^\s:]+\.go:\d+:\d+:)\s+.+/m,
+  // Maven's compiler section header.
+  new RegExp(String.raw`^\s*${MAVEN_LEVEL_TAG}COMPILATION ERROR\b`, "im"),
+  /\bfailed to compile\b/i,
+  /\bcompilation failed\b/i
+];
+var BUILD_FAILURE_BANNER_PATTERNS = [
+  /^\s*BUILD FAILED\b/im,
+  new RegExp(String.raw`^\s*${MAVEN_LEVEL_TAG}BUILD FAILURE\b`, "im")
+];
+var BARE_ERROR_LINE = /^\s*error:/m;
+function hasCompileDiagnosticOutput(output, scope = "tail") {
+  if (scope === "tail" && BARE_ERROR_LINE.test(output)) return true;
+  return COMPILE_DIAGNOSTIC_PATTERNS.some((pattern) => pattern.test(output));
+}
+function hasBuildFailureBanner(output) {
+  return BUILD_FAILURE_BANNER_PATTERNS.some((pattern) => pattern.test(output));
+}
+
+// src/core/project/failure-count-availability.ts
+var UNATTRIBUTABLE_COUNT = "unattributable";
+function failureCountUnavailableReason(language, kind) {
+  return `No registered ${kind} failure parser for language '${language}'; issue count unavailable.`;
+}
+function unavailableFailureCountForCommand(command, kind) {
+  const { language } = describeVerificationCommand(command);
+  if (language === "node" || language === "unknown") return null;
+  return { language, reason: failureCountUnavailableReason(language, kind) };
+}
+function deriveVerificationFailureCount(command, output, kind) {
+  const parsed = parseFailureOutput(command, output, kind);
+  if (parsed.parsed && parsed.errorCount !== null) {
+    return {
+      status: "counted",
+      count: parsed.errorCount,
+      messages: parsed.messages,
+      ...parsed.suiteFootprint ? { suiteFootprint: parsed.suiteFootprint } : {}
+    };
+  }
+  const unavailable = unavailableFailureCountForCommand(command, kind);
+  if (unavailable) {
+    return { status: "unavailable", ...unavailable };
+  }
+  return { status: "unattributed", language: describeVerificationCommand(command).language };
+}
+
+// src/orchestrator/autoloop-custom-gate-result.ts
+var RESOLVER_BUCKETS = ["lint", "typecheck", "build", "test"];
+function readResolverBucketKinds(cwd) {
+  const kinds = /* @__PURE__ */ new Map();
+  try {
+    const { verification } = detectProjectCapabilities(cwd);
+    for (const bucket of RESOLVER_BUCKETS) {
+      for (const command of verification[bucket] ?? []) kinds.set(command, bucket);
+    }
+    for (const command of verification.format ?? []) {
+      if (!kinds.has(command)) kinds.set(command, "format");
+    }
+  } catch {
+  }
+  return kinds;
+}
+function withCustomGateVerificationKinds(cwd, gates) {
+  if (!gates || gates.length === 0) return gates;
+  const bucketKinds = readResolverBucketKinds(cwd);
+  return gates.map((gate) => ({
+    ...gate,
+    verificationKind: gate.verificationKind ?? describeVerificationCommand(gate.command, { bucket: bucketKinds.get(gate.command) }).kind
+  }));
+}
+
+// src/orchestrator/autoloop-mature-delivery.ts
+function idleStopEnabledChecksFromConfig(config) {
+  return {
+    qualityGates: config.runQualityGates === true,
+    customGates: config.runQualityGates === true && (config.customGateCommands?.length ?? 0) > 0,
+    qualityGatePolicy: config.qualityGatePolicy ?? (config.runQualityGates === true ? "enabled" : "not_configured"),
+    stopOnUnconfirmableCompletion: config.stopOnUnconfirmableCompletion === true
+  };
+}
+function isUnconfirmableGatesOffDelivery(result, enabled) {
+  return enabled.stopOnUnconfirmableCompletion === true && enabled.qualityGatePolicy === "explicitly_disabled" && !enabled.qualityGates && !enabled.customGates && result.success && typeof result.iterationFingerprint === "string" && result.iterationFingerprint !== "" && result.requirements?.enabled !== true && result.completionSummary?.completionSignalDetected === true && result.completionSummary.blockingIssues?.includes(
+    COMPLETION_BLOCKER_MISSING_SUBSTANTIVE_EVIDENCE
+  ) === true;
+}
+var EMPTY_DIFF_FAILURE_PATTERN = /no[- ]?changes? detected|empty (?:diff|change set)|git diff (?:is )?empty|baseline unchanged|delivery no[- ]?op/i;
+function enabledRequiredGatesActuallyRanAndPassed(result, enabled) {
+  if (!enabled.qualityGates && !enabled.customGates) {
+    return false;
+  }
+  let standardGateEvidence = false;
+  if (enabled.qualityGates) {
+    const gates = result.qualityGates;
+    if (gates?.some((gate) => isBlockingQualityGateForCompletion(gate)) === true) {
+      return false;
+    }
+    if (gates?.some((gate) => gate.unavailable === true)) {
+      return false;
+    }
+    standardGateEvidence = qualityGatesAllowCompletion(gates);
+  }
+  let customGateEvidence = false;
+  if (enabled.customGates) {
+    const customGates = result.customGateResults;
+    if (!customGates || customGates.length === 0) {
+      return false;
+    }
+    for (const gate of customGates) {
+      if (gate.skipped === true || gate.unavailable === true || !gate.passed) {
+        return false;
+      }
+    }
+    customGateEvidence = customGates.some(
+      (gate) => gate.passed && gate.skipped !== true && gate.unavailable !== true
+    );
+  }
+  if (!standardGateEvidence && !customGateEvidence) {
+    return false;
+  }
+  if (result.requirements?.enabled && !result.requirements.passed) {
+    return false;
+  }
+  return true;
+}
+function resolveMatureDeliveryVerification(result, enabled) {
+  if (result.completionSummary?.completionSignalDetected !== true) {
+    return null;
+  }
+  if (!enabled.qualityGates && !enabled.customGates) {
+    if (enabled.qualityGatePolicy !== "explicitly_disabled") {
+      return null;
+    }
+    if (result.completionSummary.hasSubstantiveEvidence !== true) {
+      return null;
+    }
+    const expectedUnverifiedBlockers = /* @__PURE__ */ new Set([
+      COMPLETION_BLOCKER_PROGRESS_VERIFICATION_UNAVAILABLE
+    ]);
+    const hasSubstantiveEvidence = result.completionSummary.hasSubstantiveEvidence === true;
+    const explicitlyDisabledWithOnlyExpectedUnverifiedEvidenceGaps = result.completionSummary.status === "NOT_COMPLETE" && result.completionSummary.providerOk === true && result.completionSummary.gatesOk === true && result.completionSummary.unsafeCompletion === true && hasSubstantiveEvidence && (result.completionSummary.blockingIssues?.length ?? 0) > 0 && result.completionSummary.blockingIssues?.every(
+      (issue) => expectedUnverifiedBlockers.has(issue)
+    ) === true;
+    if (!completionStatusAllowsSuccess(result.completionSummary.status) && !explicitlyDisabledWithOnlyExpectedUnverifiedEvidenceGaps) {
+      return null;
+    }
+    if (result.requirements?.enabled && !result.requirements.passed) {
+      return null;
+    }
+    if (isSemanticCheckBlocking(result.semanticValidation)) {
+      return null;
+    }
+    return "unverified";
+  }
+  if (resolveUnavailableOnlyDelivery(result, enabled)) {
+    return "unverified";
+  }
+  if (!completionStatusAllowsSuccess(result.completionSummary.status)) {
+    return null;
+  }
+  if (!enabledRequiredGatesActuallyRanAndPassed(result, enabled)) {
+    return null;
+  }
+  return hasOnlyStyleVerificationEvidence(result) ? "unverified" : "verified";
+}
+function resolveUnavailableOnlyDelivery(result, enabled) {
+  const summary = result.completionSummary;
+  if (!enabled.qualityGates && !enabled.customGates) return null;
+  if (summary?.completionSignalDetected !== true || summary.providerOk !== true || summary.hasSubstantiveEvidence !== true) {
+    return null;
+  }
+  if (result.requirements?.enabled && !result.requirements.passed) return null;
+  if (isSemanticCheckBlocking(result.semanticValidation)) return null;
+  if (!verificationGatesUnavailableOnly({
+    qualityGates: result.qualityGates,
+    customGateResults: result.customGateResults
+  })) {
+    return null;
+  }
+  if (result.customGateResults?.some(
+    (gate) => !gate.passed && gate.skipped === true && gate.unavailable !== true
+  )) {
+    return null;
+  }
+  const unavailable = (result.qualityGates?.filter((gate) => gate.unavailable === true && !gate.passed).length ?? 0) + (result.customGateResults?.filter((gate) => gate.unavailable === true && !gate.passed).length ?? 0);
+  return deriveVerificationDisposition({
+    passed: false,
+    unavailable: true,
+    scope: "project",
+    reason: `required verification was unavailable (${unavailable} gate${unavailable === 1 ? "" : "s"} could not run)`
+  });
+}
+function isRealFirstDeliveryIteration(result, enabled) {
+  if (!result.success) {
+    return false;
+  }
+  if (typeof result.iterationFingerprint !== "string" || result.iterationFingerprint === "") {
+    return false;
+  }
+  return resolveMatureDeliveryVerification(result, enabled) !== null;
+}
+function isEmptyDiffIdleFailure(result) {
+  if (result.success) {
+    return result.iterationFingerprint === "";
+  }
+  return result.iterationFingerprint === "" && EMPTY_DIFF_FAILURE_PATTERN.test(result.error?.message ?? "");
+}
+function shouldIdleStopAfterRealFirstDelivery(priorIterations, current, enabled) {
+  return resolveIdleStopAfterRealFirstDelivery(priorIterations, current, enabled).shouldStop;
+}
+function resolveIdleStopAfterRealFirstDelivery(priorIterations, current, enabled, options = {}) {
+  if (options.iterationChangeEvidenceTrusted === false || !isEmptyDiffIdleFailure(current)) {
+    return { shouldStop: false };
+  }
+  const priorIterationIndex = priorIterations.length - 1;
+  if (priorIterationIndex < 0) {
+    return { shouldStop: false };
+  }
+  const priorIteration = priorIterations[priorIterationIndex];
+  if (!isRealFirstDeliveryIteration(priorIteration, enabled)) {
+    return { shouldStop: false };
+  }
+  const verification = resolveMatureDeliveryVerification(priorIteration, enabled);
+  if (verification === null) {
+    return { shouldStop: false };
+  }
+  const disposition = verification === "unverified" ? resolveUnavailableOnlyDelivery(priorIteration, enabled) ?? void 0 : void 0;
+  return {
+    shouldStop: true,
+    priorIterationIndex,
+    verification,
+    ...disposition ? { disposition } : {}
+  };
+}
+
+// src/orchestrator/progress-untracked-diff.ts
+var MAX_UNTRACKED_DIFF_BYTES = 10 * 1024 * 1024;
+var MAX_UNTRACKED_FILE_BYTES = 1024 * 1024;
+async function buildUntrackedFilesDiff(workingDir) {
+  let listed;
+  try {
+    listed = await execGit(["ls-files", "--others", "--exclude-standard", "-z"], {
+      cwd: workingDir
+    });
+  } catch {
+    return "";
+  }
+  if (listed.exitCode !== 0) return "";
+  const parts = [];
+  let totalBytes = 0;
+  for (const relPath of listed.stdout.split("\0").filter(Boolean)) {
+    let lines = [`diff --git a/${relPath} b/${relPath}`, "new file mode 100644"];
+    try {
+      const entry = await readUntrackedFileDiffEntry(workingDir, relPath, MAX_UNTRACKED_FILE_BYTES);
+      if (entry) lines = renderUntrackedFileDiff(`a/${relPath}`, `b/${relPath}`, entry);
+    } catch {
+    }
+    const text = lines.join("\n");
+    totalBytes += text.length;
+    if (totalBytes > MAX_UNTRACKED_DIFF_BYTES) break;
+    parts.push(text);
+  }
+  return parts.join("\n");
+}
+
+// src/orchestrator/progress-validator.ts
+function isProgressRuntimePath(filePath) {
+  const normalized = filePath.replace(/\\/g, "/");
+  return normalized === ".build-project" || normalized.startsWith(".build-project/");
+}
+function getExecOutput(error) {
+  if (!error || typeof error !== "object") return null;
+  const stdout = "stdout" in error ? error.stdout : void 0;
+  const stderr = "stderr" in error ? error.stderr : void 0;
+  const stdoutText = typeof stdout === "string" ? stdout : Buffer.isBuffer(stdout) ? stdout.toString("utf-8") : "";
+  const stderrText = typeof stderr === "string" ? stderr : Buffer.isBuffer(stderr) ? stderr.toString("utf-8") : "";
+  const combined = `${stdoutText}
+${stderrText}`.trim();
+  return combined.length > 0 ? combined : null;
+}
+function countVerificationErrorsFromOutput(command, output, kind) {
+  const derived = deriveVerificationFailureCount(command, output, kind);
+  if (derived.status === "counted") return { count: derived.count, unavailable: false };
+  if (derived.status === "unavailable") return { count: null, unavailable: true };
+  return { count: countErrorsFromOutputHeuristics(output), unavailable: false };
+}
+function countErrorsFromOutputHeuristics(output) {
+  const normalized = output.trim();
+  if (normalized.length === 0) return null;
+  const tsErrorMatches = output.match(/error TS\d+:/g);
+  if (tsErrorMatches && tsErrorMatches.length > 0) {
+    return tsErrorMatches.length;
+  }
+  const errorMatches = Array.from(output.matchAll(/(?:Found\s+)?(\d+)\s+errors?/gi));
+  const lastErrorMatch = errorMatches[errorMatches.length - 1];
+  if (lastErrorMatch?.[1]) {
+    const parsed = Number.parseInt(lastErrorMatch[1], 10);
+    if (Number.isFinite(parsed)) return parsed;
+  }
+  if (/^\s*FAIL\b/m.test(output) || /\b[1-9]\d*\s+Error\(s\)/i.test(output) || hasBuildFailureBanner(output) || hasCompileDiagnosticOutput(output)) {
+    return 1;
+  }
+  return null;
+}
+function detectProjectLanguageSummary(workingDir) {
+  try {
+    return detectProjectCapabilities(workingDir).languages.join(", ") || "unknown";
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return `unknown (capability detection failed: ${message})`;
+  }
+}
+function selectProjectProgressVerificationCommands(workingDir) {
+  const capabilities = detectProjectCapabilities(workingDir);
+  if (capabilities.verification.typecheck.length > 0) {
+    return { commands: [...new Set(capabilities.verification.typecheck)], kind: "typecheck" };
+  }
+  if (capabilities.verification.build.length > 0) {
+    return { commands: [...new Set(capabilities.verification.build)], kind: "build" };
+  }
+  return { commands: [...new Set(capabilities.verification.test)], kind: "test" };
+}
+async function countTypeScriptErrors(workingDir) {
+  const { commands, kind } = selectProjectProgressVerificationCommands(workingDir);
+  if (commands.length === 0) return null;
+  let total = 0;
+  let counted = false;
+  let unattributable = false;
+  for (const command of commands) {
+    const count = await countErrorsForCommand(workingDir, command, kind);
+    if (count === UNATTRIBUTABLE_COUNT) {
+      unattributable = true;
+      continue;
+    }
+    if (count === null) continue;
+    counted = true;
+    total += count;
+  }
+  if (unattributable) return null;
+  if (total > 0) return total;
+  return counted ? 0 : null;
+}
+async function countErrorsForCommand(workingDir, command, kind) {
+  try {
+    const envTimeout = Number.parseInt(process.env.BUILD_TSC_TIMEOUT_MS ?? "", 10);
+    const timeoutMs = Number.isFinite(envTimeout) && envTimeout > 0 ? envTimeout : 15e3;
+    const result = await runVerificationCommand(command, {
+      cwd: workingDir,
+      timeoutMs
+    });
+    const output = String(result.all ?? `${result.stdout ?? ""}
+${result.stderr ?? ""}`).trim();
+    const exitCode = result.exitCode;
+    if (exitCode == null || exitCode === 126) return null;
+    if (exitCode !== 0) {
+      if (classifyResolverCommand(command, result, 0).classification === "unavailable") {
+        return UNATTRIBUTABLE_COUNT;
+      }
+      const parsed = countVerificationErrorsFromOutput(command, output, kind);
+      if (parsed.unavailable) return UNATTRIBUTABLE_COUNT;
+      if (detectExitZeroVerifyFailure(command, output)) {
+        return Math.max(parsed.count ?? 0, 1);
+      }
+      return parsed.count === 0 ? 1 : parsed.count ?? 1;
+    }
+    const exitZeroFailure = detectExitZeroVerifyFailure(command, output);
+    if (exitZeroFailure) return 1;
+    return countVerificationErrorsFromOutput(command, output, kind).count ?? 0;
+  } catch (error) {
+    const output = getExecOutput(error);
+    if (!output) return null;
+    const parsed = countVerificationErrorsFromOutput(command, output, kind);
+    if (parsed.unavailable) return UNATTRIBUTABLE_COUNT;
+    if (detectExitZeroVerifyFailure(command, output)) {
+      return Math.max(parsed.count ?? 0, 1);
+    }
+    return parsed.count === 0 ? 1 : parsed.count;
+  }
+}
+var ProgressValidator = class {
+  constructor(options = {}) {
+    this.options = options;
+    this.options = {
+      enableGitAnalysis: true,
+      enableTestDetection: true,
+      minProgressThreshold: 0.05,
+      trendThreshold: 0.01,
+      ...options
+    };
+  }
+  options;
+  compilationBaselineErrors = null;
+  getPreviousScore(context) {
+    const previous = context.previousIterations[context.previousIterations.length - 1];
+    return previous?.progress.score ?? 0;
+  }
+  isProgressSignificant(context, score) {
+    const threshold = this.options.minProgressThreshold ?? 0.05;
+    if (context.previousIterations.length === 0) {
+      return score >= threshold;
+    }
+    const previousScore = this.getPreviousScore(context);
+    const delta = score - previousScore;
+    return delta >= threshold;
+  }
+  /**
+   * Validate progress for an iteration
+   */
+  async validateProgress(context) {
+    const startTime = Date.now();
+    try {
+      const compilationCheck = await this.checkCompilation(context);
+      const hadToolingFailure = compilationCheck.toolingFailure === true;
+      const verificationUnavailable = compilationCheck.status === "unavailable";
+      if (verificationUnavailable) {
+        debugLog(
+          `[ProgressValidator] Compilation verification unavailable: ${compilationCheck.reason}`
+        );
+      } else if (!compilationCheck.passed) {
+        debugLog(
+          `[ProgressValidator] Compilation check failed: ${compilationCheck.newErrors} new errors`
+        );
+        emitWarning(
+          "VAL-002",
+          {
+            taskId: context.workingDir,
+            subsystem: "progress-validator",
+            executionPhase: "validation"
+          },
+          {
+            severity: "ERROR" /* ERROR */,
+            metadata: {
+              newErrors: compilationCheck.newErrors,
+              totalErrors: compilationCheck.totalErrors,
+              iteration: context.iteration
+            }
+          }
+        );
+        return {
+          score: 0,
+          isSignificant: false,
+          trend: "declining",
+          confidence: 1,
+          // High confidence - compilation failure is definitive
+          metrics: {
+            testCoverage: 0,
+            completeness: 0
+          },
+          insights: [
+            `Iteration ${context.iteration}: Compilation failed with ${compilationCheck.newErrors} new errors`,
+            "Fix compilation errors before proceeding",
+            `Total errors: ${compilationCheck.totalErrors}`
+          ],
+          compilationErrors: compilationCheck.errorCount
+        };
+      }
+      const gitStats = this.options.enableGitAnalysis ? await this.analyzeGitChanges(context.workingDir, context.baseRef) : this.getEmptyGitStats();
+      const metrics = this.calculateMetrics(gitStats, context);
+      const score = this.calculateProgressScore(metrics, gitStats);
+      const isSignificant = this.isProgressSignificant(context, score);
+      const trend = this.calculateTrend(context.previousIterations, score);
+      const confidence = this.calculateConfidence(gitStats, context);
+      const insights = this.generateInsights(context.iteration, score, metrics, gitStats, trend);
+      if (verificationUnavailable) {
+        insights.push(
+          `WARNING: Validation unavailable \u2014 ${compilationCheck.reason ?? "no deterministic compilation check could run"}`
+        );
+      } else if (hadToolingFailure) {
+        insights.push("WARNING: Validation tooling failed \u2014 reported progress may be illusory");
+      }
+      const validationDuration = Date.now() - startTime;
+      debugLog(
+        `[ProgressValidator] Iteration ${context.iteration} validated in ${validationDuration}ms`
+      );
+      return {
+        score,
+        isSignificant,
+        trend,
+        // Reduce confidence when tooling failed to reflect lower certainty
+        confidence: verificationUnavailable || hadToolingFailure ? Math.min(confidence, 0.4) : confidence,
+        metrics,
+        insights,
+        ...compilationCheck.errorCount !== void 0 ? { compilationErrors: compilationCheck.errorCount } : {},
+        ...hadToolingFailure ? { toolingFailure: true } : {},
+        ...verificationUnavailable ? {
+          verificationUnavailable: true,
+          verificationUnavailableReason: compilationCheck.reason ?? "No deterministic compilation check could run."
+        } : {}
+      };
+    } catch (error) {
+      emitWarning(
+        "VAL-001",
+        {
+          taskId: context.workingDir,
+          subsystem: "progress-validator",
+          executionPhase: "validation"
+        },
+        {
+          severity: "WARN" /* WARN */,
+          metadata: {
+            error: error instanceof Error ? error.message : String(error),
+            iteration: context.iteration,
+            operation: "validateProgress"
+          }
+        }
+      );
+      return this.createFallbackValidation(context);
+    }
+  }
+  // ========================================================================
+  // COMPILATION CHECK
+  // ========================================================================
+  /**
+   * Check project compilation/typecheck status and compare against baseline.
+   *
+   * Runs a detected typecheck/build command without inventing target-project tooling.
+   * If no compile-specific command exists, falls back to resolver-backed test
+   * commands as deterministic verification evidence.
+   * Compares the current error count against a baseline to detect if new errors were introduced.
+   *
+   * Baseline precedence:
+   * 1) `context.compilationBaselineErrors` (captured pre-iteration by controller, preferred)
+   * 2) Internal baseline captured on first use (fallback)
+   *
+   * @param context - Progress validation context for this iteration
+   * @returns Compilation check result with pass/fail status and error counts
+   */
+  async checkCompilation(context) {
+    try {
+      const compilationCommands = selectProjectProgressVerificationCommands(
+        context.workingDir
+      ).commands;
+      if (compilationCommands.length === 0) {
+        const reason = `No deterministic typecheck/build/test command found; compilation verification is unavailable for detected languages: ${detectProjectLanguageSummary(context.workingDir)}.`;
+        debugLog(`[ProgressValidator] ${reason}`);
+        return {
+          passed: false,
+          newErrors: 0,
+          totalErrors: 0,
+          toolingFailure: true,
+          status: "unavailable",
+          reason,
+          errorCount: null
+        };
+      }
+      const totalErrors = await countTypeScriptErrors(context.workingDir);
+      if (totalErrors === null) {
+        debugLog(
+          `[ProgressValidator] Unable to run ${compilationCommands.join(", ")}, marking validation tooling failure`
+        );
+        return {
+          passed: false,
+          newErrors: 0,
+          totalErrors: 0,
+          toolingFailure: true,
+          status: "unavailable",
+          errorCount: null,
+          reason: `Project compilation command was unavailable or produced output no registered parser could attribute: ${compilationCommands.join(", ")} (detected languages: ${detectProjectLanguageSummary(context.workingDir)})`
+        };
+      }
+      const capturedBaseline = context.compilationBaselineErrors ?? this.compilationBaselineErrors;
+      if (context.compilationBaselineErrors === null && capturedBaseline === null && totalErrors > 0) {
+        return {
+          passed: false,
+          newErrors: 0,
+          totalErrors,
+          errorCount: totalErrors,
+          toolingFailure: true,
+          status: "unavailable",
+          reason: "Pre-iteration compilation baseline is unavailable; new errors cannot be attributed."
+        };
+      }
+      const baselineErrors = capturedBaseline ?? totalErrors;
+      this.compilationBaselineErrors ??= baselineErrors;
+      const newErrors = Math.max(0, totalErrors - baselineErrors);
+      const passed = newErrors === 0;
+      if (!passed) {
+        debugLog(
+          `[ProgressValidator] Compilation check failed: ${newErrors} new errors (${totalErrors} total)`
+        );
+      } else {
+        debugLog("[ProgressValidator] Compilation check passed");
+      }
+      return {
+        passed,
+        newErrors,
+        totalErrors,
+        errorCount: totalErrors,
+        status: passed ? "verified" : "failed"
+      };
+    } catch (error) {
+      console.warn(
+        `Error running compilation check: ${error instanceof Error ? error.message : String(error)}`
+      );
+      debugLog("Full stack:", error);
+      emitWarning(
+        "VAL-002",
+        {
+          taskId: context.workingDir,
+          subsystem: "progress-validator",
+          executionPhase: "validation"
+        },
+        {
+          severity: "WARN" /* WARN */,
+          metadata: {
+            error: error instanceof Error ? error.message : String(error),
+            operation: "checkCompilation"
+          }
+        }
+      );
+      return {
+        passed: false,
+        newErrors: 0,
+        totalErrors: 0,
+        toolingFailure: true,
+        status: "unavailable",
+        reason: "Compilation validation tooling failed before producing a result."
+      };
+    }
+  }
+  // ========================================================================
+  // GIT ANALYSIS
+  // ========================================================================
+  /**
+   * Calculate meaningful code delta excluding comments and whitespace.
+   * Used to detect "comment-only" changes that shouldn't count as progress.
+   *
+   * @param gitDiff - Full git diff output
+   * @returns Additions and deletions excluding comments/whitespace
+   */
+  calculateMeaningfulDelta(gitDiff) {
+    const lines = gitDiff.split("\n");
+    let additions = 0;
+    let deletions = 0;
+    for (const line of lines) {
+      if (line.startsWith("@@") || line.startsWith("diff") || line.startsWith("index") || line.startsWith("---") || line.startsWith("+++")) {
+        continue;
+      }
+      if (!line.startsWith("+") && !line.startsWith("-")) {
+        continue;
+      }
+      const content = line.slice(1).trim();
+      if (!content) continue;
+      const isDefinitelyComment = content.startsWith("//") || // C-family single-line comment
+      content.startsWith("/*") || // C-family multi-line start
+      content.startsWith("*/") || // C-family multi-line end
+      content.startsWith("*") && content.match(/^\*\s+[^*/]/);
+      if (isDefinitelyComment) {
+        continue;
+      }
+      if (line.match(/^[+-]\s*$/)) continue;
+      if (line.startsWith("+")) additions++;
+      if (line.startsWith("-")) deletions++;
+    }
+    return { additions, deletions };
+  }
+  /**
+   * Analyze git changes since base ref
+   */
+  async analyzeGitChanges(workingDir, baseRef = "HEAD") {
+    try {
+      if (!this.isGitRepository(workingDir)) {
+        return this.getEmptyGitStats();
+      }
+      const safeBaseRef = baseRef.trim();
+      if (!isSafeGitRef(safeBaseRef)) {
+        return this.getEmptyGitStats();
+      }
+      const trackedDiff = execWithTimeout(`git diff ${safeBaseRef} 2>/dev/null || echo ""`, {
+        cwd: workingDir,
+        maxBuffer: 10 * 1024 * 1024,
+        timeout: 3e4,
+        returnEmptyOnError: true
+      }).trim();
+      const fullDiff = [trackedDiff, await buildUntrackedFilesDiff(workingDir)].filter(Boolean).join("\n");
+      if (!fullDiff) {
+        return this.getEmptyGitStats();
+      }
+      const modifiedFileSet = /* @__PURE__ */ new Set();
+      let insertions = 0;
+      let deletions = 0;
+      let includeCurrentFile = false;
+      const includedDiffLines = [];
+      for (const line of fullDiff.split("\n")) {
+        const paths = parseDiffGitHeaderPaths(line);
+        if (paths) {
+          const filePath = paths.bPath;
+          includeCurrentFile = !isProgressRuntimePath(filePath);
+          if (includeCurrentFile) {
+            modifiedFileSet.add(filePath);
+            includedDiffLines.push(line);
+          }
+          continue;
+        }
+        if (!includeCurrentFile) {
+          continue;
+        }
+        includedDiffLines.push(line);
+        if (line.startsWith("+++") || line.startsWith("---") || line.startsWith("@@") || line.startsWith("diff --git") || line.startsWith("index ")) {
+          continue;
+        }
+        if (line.startsWith("+")) insertions++;
+        if (line.startsWith("-")) deletions++;
+      }
+      const modifiedFiles = Array.from(modifiedFileSet).sort((a, b) => a.localeCompare(b));
+      const hasTests = modifiedFiles.some(
+        (f) => f.includes("test") || f.includes("spec") || f.endsWith(".test.ts") || f.endsWith(".spec.ts")
+      );
+      const hasDocs = modifiedFiles.some(
+        (f) => f.endsWith(".md") || f.includes("doc") || f.includes("README")
+      );
+      const meaningfulDelta = this.calculateMeaningfulDelta(includedDiffLines.join("\n"));
+      return {
+        filesChanged: modifiedFiles.length,
+        insertions,
+        deletions,
+        totalLines: insertions + deletions,
+        modifiedFiles,
+        hasTests,
+        hasDocs,
+        meaningfulInsertions: meaningfulDelta.additions,
+        meaningfulDeletions: meaningfulDelta.deletions
+      };
+    } catch (error) {
+      console.warn(
+        `Error analyzing git changes: ${error instanceof Error ? error.message : String(error)}`
+      );
+      debugLog("Full stack:", error);
+      emitWarning(
+        "VAL-001",
+        {
+          taskId: workingDir,
+          subsystem: "progress-validator",
+          executionPhase: "validation"
+        },
+        {
+          severity: "WARN" /* WARN */,
+          metadata: {
+            error: error instanceof Error ? error.message : String(error),
+            operation: "analyzeGitChanges"
+          }
+        }
+      );
+      return this.getEmptyGitStats();
+    }
+  }
+  /**
+   * Check if directory is a git repository
+   */
+  isGitRepository(dir) {
+    try {
+      execWithTimeout("git rev-parse --git-dir", {
+        cwd: dir,
+        stdio: "pipe",
+        timeout: 3e4
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  // ========================================================================
+  // METRICS CALCULATION
+  // ========================================================================
+  /**
+   * Calculate all progress metrics from git stats.
+   *
+   * completeness and testCoverage are derived from the diff. They feed telemetry
+   * and the diff-size floor that applies only when no verification gate produced
+   * evidence; passing gates, not this score, decide completion.
+   */
+  calculateMetrics(gitStats, context) {
+    const hasMeaningfulChanges = gitStats.meaningfulInsertions + gitStats.meaningfulDeletions > 0;
+    const hasAnyChanges = gitStats.insertions + gitStats.deletions > 0;
+    const isCommentOnlyChange = hasAnyChanges && !hasMeaningfulChanges;
+    if (isCommentOnlyChange) {
+      debugLog("[ProgressValidator] Comment/whitespace-only changes detected, no progress credit");
+    }
+    const completeness = isCommentOnlyChange ? 0 : Math.min(
+      1,
+      (gitStats.meaningfulInsertions + gitStats.meaningfulDeletions) / Math.max(100, 1)
+    );
+    const testCoverage = gitStats.hasTests ? Math.min(1, 0.5 + gitStats.filesChanged * 0.1) : context.previousIterations.length > 0 ? context.previousIterations[context.previousIterations.length - 1]?.progress.metrics.testCoverage ?? 0.3 : 0.3;
+    return {
+      completeness: Math.max(0, Math.min(1, completeness)),
+      testCoverage: Math.max(0, Math.min(1, testCoverage))
+    };
+  }
+  /**
+   * Calculate overall progress score.
+   *
+   * Weights: completeness 70%, testCoverage 30%.
+   * Bonuses: +0.05 for test file changes, +0.02 for doc changes.
+   */
+  calculateProgressScore(metrics, gitStats) {
+    const hasMeaningfulChanges = gitStats.meaningfulInsertions + gitStats.meaningfulDeletions > 0;
+    if (!hasMeaningfulChanges) {
+      return 0;
+    }
+    const weights = {
+      completeness: 0.7,
+      testCoverage: 0.3
+    };
+    let score = metrics.completeness * weights.completeness + metrics.testCoverage * weights.testCoverage;
+    if (gitStats.hasTests) score += 0.05;
+    if (gitStats.hasDocs) score += 0.02;
+    return Math.max(0, Math.min(1, score));
+  }
+  /**
+   * Calculate trend from previous iterations
+   */
+  calculateTrend(previousIterations, currentScore) {
+    if (previousIterations.length === 0) {
+      return "unknown";
+    }
+    if (previousIterations.length === 1) {
+      const prev = previousIterations[0]?.progress.score ?? 0;
+      const diff = currentScore - prev;
+      const threshold2 = this.options.trendThreshold ?? 0.01;
+      if (diff > threshold2) return "improving";
+      if (diff < -threshold2) return "declining";
+      return "stable";
+    }
+    const recentCount = Math.min(3, previousIterations.length);
+    const recent = previousIterations.slice(-recentCount);
+    const scores = [...recent.map((r) => r.progress.score), currentScore];
+    let sumX = 0;
+    let sumY = 0;
+    let sumXY = 0;
+    let sumXX = 0;
+    const n = scores.length;
+    for (let i = 0; i < n; i++) {
+      sumX += i;
+      sumY += scores[i] ?? 0;
+      sumXY += i * (scores[i] ?? 0);
+      sumXX += i * i;
+    }
+    const slope = (n * sumXY - sumX * sumY) / (n * sumXX - sumX * sumX);
+    const threshold = this.options.trendThreshold ?? 0.01;
+    if (slope > threshold) return "improving";
+    if (slope < -threshold) return "declining";
+    return "stable";
+  }
+  /**
+   * Calculate confidence in assessment
+   */
+  calculateConfidence(gitStats, context) {
+    let confidence = 0.5;
+    if (gitStats.filesChanged > 0) {
+      confidence += Math.min(0.2, gitStats.filesChanged * 0.05);
+    }
+    if (context.previousIterations.length >= 2) {
+      confidence += 0.3;
+    }
+    return Math.max(0, Math.min(1, confidence));
+  }
+  // ========================================================================
+  // INSIGHTS GENERATION
+  // ========================================================================
+  /**
+   * Generate human-readable insights
+   */
+  generateInsights(iteration, score, metrics, gitStats, trend) {
+    const insights = [];
+    insights.push(
+      `Iteration ${iteration}: ${(score * 100).toFixed(1)}% overall progress (${trend})`
+    );
+    if (gitStats.filesChanged > 0) {
+      insights.push(
+        `Modified ${gitStats.filesChanged} file(s): +${gitStats.insertions} -${gitStats.deletions} lines`
+      );
+      const hasMeaningfulChanges = gitStats.meaningfulInsertions + gitStats.meaningfulDeletions > 0;
+      if (!hasMeaningfulChanges) {
+        insights.push("Only comment/whitespace changes detected - no meaningful code progress");
+      }
+    } else {
+      insights.push("No file changes detected in this iteration");
+    }
+    if (gitStats.hasTests) {
+      insights.push("Test files updated - good coverage practice");
+    } else if (gitStats.filesChanged > 0) {
+      insights.push("Recommendation: Add tests for code changes");
+    }
+    if (metrics.completeness >= 0.9) {
+      insights.push("Task appears nearly complete");
+    } else if (metrics.completeness >= 0.7) {
+      insights.push("Good progress, some work remaining");
+    } else if (metrics.completeness >= 0.5) {
+      insights.push("Halfway through task completion");
+    } else {
+      insights.push("Significant work still needed");
+    }
+    if (trend === "improving") {
+      insights.push("Progress trend: Improving - keep going!");
+    } else if (trend === "declining") {
+      insights.push("Progress trend: Declining - review approach");
+    } else if (trend === "stable") {
+      insights.push("Progress trend: Stable - consider new strategies");
+    }
+    return insights;
+  }
+  // ========================================================================
+  // FALLBACK & HELPERS
+  // ========================================================================
+  /**
+   * Create fallback validation when analysis fails.
+   *
+   * Returns score=0 with low confidence and an explicit warning rather than
+   * fabricating a positive score from the iteration count.  A non-zero score
+   * derived purely from "how many iterations have elapsed" is illusory — it
+   * says nothing about whether actual work was done.
+   */
+  createFallbackValidation(context) {
+    const score = 0;
+    return {
+      score,
+      isSignificant: false,
+      trend: "unknown",
+      // Low confidence: we could not run any real analysis
+      confidence: 0.1,
+      metrics: {
+        testCoverage: 0,
+        completeness: 0
+      },
+      insights: [
+        `Iteration ${context.iteration}: Using fallback validation`,
+        "Unable to perform detailed analysis - reported progress may be illusory",
+        "Proceeding with caution"
+      ],
+      toolingFailure: true,
+      verificationUnavailable: true,
+      verificationUnavailableReason: "Progress validation failed before deterministic checks completed."
+    };
+  }
+  /**
+   * Get empty git stats
+   */
+  getEmptyGitStats() {
+    return {
+      filesChanged: 0,
+      insertions: 0,
+      deletions: 0,
+      totalLines: 0,
+      modifiedFiles: [],
+      hasTests: false,
+      hasDocs: false,
+      meaningfulInsertions: 0,
+      meaningfulDeletions: 0
+    };
+  }
+};
+function createCustomProgressValidator(options) {
+  return new ProgressValidator(options);
+}
+
+// src/orchestrator/quality-failed-commands.ts
+function compareFailedCommands(allCurrent, allBaseline) {
+  const current = allCurrent.filter((entry) => !entry.unavailable && !entry.passed);
+  const baseline = allBaseline.filter((entry) => !entry.unavailable && !entry.passed);
+  if ([...current, ...baseline].some((entry) => entry.timedOut)) return void 0;
+  if (current.some((entry) => !baseline.some((b) => b.command === entry.command))) return true;
+  if (current.length !== 1 || baseline.length !== 1) return void 0;
+  return null;
+}
+function compareLintCommands(allCurrent, allBaseline, countOf) {
+  const current = allCurrent.filter((entry) => !entry.passed);
+  const baseline = allBaseline.filter((entry) => !entry.passed);
+  if ([...current, ...baseline].some((entry) => entry.timedOut || entry.unavailable)) {
+    return void 0;
+  }
+  if (current.some((entry) => !baseline.some((b) => b.command === entry.command))) return true;
+  const provenPassing = (command) => allCurrent.some((entry) => entry.passed && entry.command === command);
+  const absent = baseline.filter((b) => !current.some((entry) => entry.command === b.command));
+  if (absent.some((b) => !provenPassing(b.command))) return void 0;
+  if (current.length === 1 && baseline.length === 1) return null;
+  const unique = (list) => new Set(list.map((entry) => entry.command)).size === list.length;
+  if (!unique(current) || !unique(baseline)) return void 0;
+  let unknown = false;
+  for (const entry of current) {
+    const counterpart = baseline.find((b) => b.command === entry.command);
+    if (!counterpart) return void 0;
+    const now = countOf(entry);
+    const before = countOf(counterpart);
+    const guessed = now.method === "fallback_1" || before.method === "fallback_1";
+    if (now.count === null || before.count === null || guessed) {
+      unknown = true;
+    } else if (now.count > before.count) {
+      return true;
+    }
+  }
+  return unknown ? void 0 : false;
+}
+function compareAuditCommands(allCurrent, allBaseline, countOf) {
+  const unproven = (counted) => counted.count === null || counted.method === "fallback_1" || counted.method === "unavailable_no_parser";
+  let unknown = false;
+  for (const entry of allCurrent.filter((candidate) => !candidate.passed)) {
+    const now = entry.timedOut || entry.unavailable ? null : countOf(entry);
+    if (now !== null && !unproven(now) && now.count === 0) continue;
+    const counterpart = allBaseline.find((b) => b.command === entry.command);
+    let before = 0;
+    if (counterpart && !counterpart.passed) {
+      const counted = counterpart.timedOut || counterpart.unavailable ? null : countOf(counterpart);
+      before = counted && !unproven(counted) ? counted.count : null;
+    }
+    if (now === null || unproven(now) || before === null) {
+      unknown = true;
+    } else if (now.count !== null && now.count > before) {
+      return true;
+    }
+  }
+  return unknown ? void 0 : false;
+}
+function compareBucketCommands(gate, current, baseline, extract) {
+  const countOf = (entry) => extract([{ gate, success: false, ...entry }], gate);
+  if (gate === "lint") return compareLintCommands(current, baseline, countOf);
+  if (gate === "security") return compareAuditCommands(current, baseline, countOf);
+  return compareFailedCommands(current, baseline);
+}
+
+// src/orchestrator/autonomous-loop-controller.ts
+var DEFAULT_AUTOLOOP_RESOURCE_LIMITS = {
+  maxMemoryMB: 1048576
+};
+var MAX_AUTOLOOP_ENV_ITERATIONS = 100;
+var COMPLETION_SIGNAL_TAIL_BYTES = 8192;
+function parseCompletionSignal(spec) {
+  if (spec.startsWith("xml:")) {
+    const tag = spec.slice(4);
+    if (tag.length === 0) return null;
+    return { type: "xml", tag };
+  }
+  if (spec.startsWith("regex:")) {
+    const rawPattern = spec.slice(6);
+    if (rawPattern.length === 0) return null;
+    const slashMatch = rawPattern.match(/^\/(.+)\/([gimsuy]*)$/);
+    const patternSource = slashMatch ? slashMatch[1] : rawPattern;
+    const patternFlags = slashMatch ? slashMatch[2] : "i";
+    if (patternSource.length === 0) return null;
+    try {
+      return {
+        type: "regex",
+        pattern: new RegExp(patternSource, patternFlags)
+      };
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+function matchesCompletionSignal(output, signal) {
+  if (typeof output !== "string") {
+    return false;
+  }
+  const tail = tailUtf8(output, COMPLETION_SIGNAL_TAIL_BYTES) ?? "";
+  if (signal.type === "xml") {
+    const escapedTag = signal.tag.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const atLineStart = new RegExp(`(?:^|[\\r\\n])${escapedTag}(?:\\s|$)`, "i");
+    const asFinalToken = new RegExp(`${escapedTag}\\s*$`, "i");
+    return atLineStart.test(tail) || asFinalToken.test(tail.trimEnd());
+  }
+  const trimmedEnd = tail.trimEnd();
+  const pattern = new RegExp(
+    signal.pattern.source,
+    signal.pattern.flags.includes("g") ? signal.pattern.flags : `${signal.pattern.flags}g`
+  );
+  let lastMatch = null;
+  let match = pattern.exec(trimmedEnd);
+  while (match !== null) {
+    lastMatch = match;
+    if (match[0].length === 0) {
+      pattern.lastIndex += 1;
+    }
+    match = pattern.exec(trimmedEnd);
+  }
+  if (!lastMatch) {
+    return false;
+  }
+  return lastMatch.index + lastMatch[0].length >= trimmedEnd.length;
+}
+function selectTaskOutputForChecks(taskResult) {
+  if (typeof taskResult === "object" && taskResult !== null) {
+    if ("completionOutputText" in taskResult && typeof taskResult.completionOutputText === "string") {
+      return taskResult.completionOutputText;
+    }
+    if ("providerOutputText" in taskResult && typeof taskResult.providerOutputText === "string") {
+      return taskResult.providerOutputText;
+    }
+  }
+  return typeof taskResult === "string" ? taskResult : "";
+}
+function isRepairOutcome(value) {
+  if (!value || typeof value !== "object") return false;
+  const candidate = value;
+  return typeof candidate.status === "string" && typeof candidate.attempts === "number" && typeof candidate.reason === "string";
+}
+function isCompletionEvidence(value) {
+  if (!value || typeof value !== "object") return false;
+  const candidate = value;
+  return candidate.durable === true && (candidate.source === "simple-artifact" || candidate.source === "requirements" || candidate.source === "external") && (candidate.detail === void 0 || typeof candidate.detail === "string");
+}
+function isCustomGateResult(value) {
+  if (!value || typeof value !== "object") return false;
+  const candidate = value;
+  if (typeof candidate.id !== "string" || typeof candidate.command !== "string" || typeof candidate.passed !== "boolean" || typeof candidate.durationMs !== "number" || !Number.isFinite(candidate.durationMs) || candidate.durationMs < 0) {
+    return false;
+  }
+  if (candidate.exitCode !== void 0 && typeof candidate.exitCode !== "number") return false;
+  if (candidate.outputTail !== void 0 && typeof candidate.outputTail !== "string") return false;
+  if (candidate.isRegression !== void 0 && typeof candidate.isRegression !== "boolean") {
+    return false;
+  }
+  if (candidate.skipped !== void 0 && typeof candidate.skipped !== "boolean") return false;
+  if (candidate.unavailable !== void 0 && typeof candidate.unavailable !== "boolean") {
+    return false;
+  }
+  if (candidate.misconfigured !== void 0 && typeof candidate.misconfigured !== "boolean") {
+    return false;
+  }
+  return true;
+}
+function isCustomGateResultsArray(value) {
+  return Array.isArray(value) && value.every(isCustomGateResult);
+}
+function buildCustomGateId(command) {
+  const prefix = command.replace(/\s+/g, "-").slice(0, 40);
+  const hash = createHash("sha256").update(command).digest("hex").slice(0, 8);
+  return `${prefix}-${hash}`;
+}
+function filterSemanticValidationDiff(gitDiff, taskText) {
+  if (!gitDiff.trim()) {
+    return gitDiff;
+  }
+  const normalizedTaskText = taskText.replace(/\\/g, "/");
+  const sections = gitDiff.split(/^diff --git /m).map((section, index) => index === 0 ? section : `diff --git ${section}`).filter((section) => section.trim().length > 0);
+  return sections.filter((section) => {
+    const match = section.match(/^diff --git a\/(.+?) b\/(.+)$/m);
+    const changedPath = match?.[2] ?? match?.[1];
+    if (!changedPath) {
+      return true;
+    }
+    if (!shouldIgnoreRepoPath(changedPath)) {
+      return true;
+    }
+    const normalizedPath = changedPath.replace(/\\/g, "/");
+    const parentDir = normalizedPath.includes("/") ? `${normalizedPath.slice(0, normalizedPath.lastIndexOf("/") + 1)}` : "";
+    return normalizedTaskText.includes(normalizedPath) || parentDir.length > 0 && normalizedTaskText.includes(parentDir);
+  }).join("\n");
+}
+var TYPECHECK_GATE_IDS = /* @__PURE__ */ new Set(["tsc", "typecheck", "typescript"]);
+function normalizeGateId(gateId) {
+  return gateId.trim().toLowerCase().replaceAll("_", "-");
+}
+function isTypecheckGateId(gateId) {
+  const normalized = normalizeGateId(gateId);
+  if (TYPECHECK_GATE_IDS.has(normalized)) {
+    return true;
+  }
+  return normalized.split("-").some((part) => TYPECHECK_GATE_IDS.has(part));
+}
+function hasCompilerErrorOutput(output, scope = "tail") {
+  if (output.trim().length === 0) {
+    return false;
+  }
+  const hasTsError = output.split(/\r?\n/).some(
+    (line) => /^(?:.+(?:\(\d+,\d+\)|:\d+:\d+)\s*(?::|-)\s+)?error\s+TS\d+:/i.test(line.trim())
+  );
+  return hasTsError || hasCompileDiagnosticOutput(output, scope);
+}
+function hasCompilationProgressSignal(insights) {
+  return insights?.some(
+    (insight) => /\bcompilation failed with [1-9]\d* new (?:typescript )?errors?\b/i.test(insight)
+  ) ?? false;
+}
+function classifyQualityGateFailure(gate) {
+  if (gate.passed || gate.isRegression === false) {
+    return "other";
+  }
+  if (isTypecheckGateId(gate.gateId)) {
+    return "compilation";
+  }
+  if (gate.compilationFailure !== void 0) {
+    return gate.compilationFailure ? "compilation" : "other";
+  }
+  const compilerOutput = `${gate.details}
+${gate.outputTail ?? ""}`;
+  return hasCompilerErrorOutput(compilerOutput) ? "compilation" : "other";
+}
+function semanticSkipped(skipped) {
+  return { enabled: true, skipped };
+}
+function semanticDisabled() {
+  return { enabled: false };
+}
+var MIN_CUSTOM_GATE_BASELINE_MS = 3e3;
+var MIN_CUSTOM_GATE_RUN_MS = 1e3;
+var MIN_FIRST_ITERATION_RESERVE_MS = 15e3;
+var MAX_FIRST_ITERATION_RESERVE_MS = 9e4;
+function classifyError(error) {
+  const message = error.message.toLowerCase();
+  if (message.includes("timeout") || message.includes("timed out") || message.includes("deadline")) {
+    return {
+      category: "timeout",
+      hint: "Consider reducing iteration complexity or increasing timeout limits"
+    };
+  }
+  if (message.includes("auth") || message.includes("unauthorized") || message.includes("forbidden") || message.includes("credentials")) {
+    return {
+      category: "auth",
+      hint: "Verify API credentials and authentication configuration"
+    };
+  }
+  if (message.includes("syntax") || message.includes("parse") || message.includes("unexpected token")) {
+    return {
+      category: "syntax",
+      hint: "Check generated code for syntax errors or malformed output"
+    };
+  }
+  if (message.includes("memory") || message.includes("cpu") || message.includes("disk") || message.includes("enospc") || message.includes("enomem")) {
+    return {
+      category: "resource",
+      hint: "Reduce memory/CPU usage or increase resource limits"
+    };
+  }
+  return {
+    category: "unknown",
+    hint: "Review error details and adjust implementation approach"
+  };
+}
+function abortErrorFromSignal(signal) {
+  const reason = signal.reason;
+  if (reason instanceof Error) {
+    return reason;
+  }
+  if (typeof reason === "string" && reason.trim().length > 0) {
+    return new Error(reason);
+  }
+  return new Error("Autoloop iteration aborted");
+}
+function isAutoloopTimeboxAbortError(error) {
+  return /remaining timebox|autoloop timebox exceeded/i.test(error.message);
+}
+function rejectIterationAbort(signal, reject) {
+  const abortError = abortErrorFromSignal(signal);
+  if (isAutoloopTimeboxAbortError(abortError)) {
+    reject(abortError);
+    return;
+  }
+  reject(createDirectAutoloopCancellationFailure(abortError, "mid-run"));
+}
+function resolveQualityGateExecutionFlags(mode = "fast") {
+  return {
+    coverage: autoloopPresetIncludesGateKind(mode, "unit"),
+    lint: autoloopPresetIncludesGateKind(mode, "lint"),
+    security: autoloopPresetIncludesGateKind(mode, "security")
+  };
+}
+async function captureQualityBaseline(workingDir, qualityGates, options) {
+  if (!qualityGates) {
+    return {
+      status: "skipped",
+      reason: "quality_gates_unavailable",
+      capturedAt: /* @__PURE__ */ new Date()
+    };
+  }
+  try {
+    const gateFlags = resolveQualityGateExecutionFlags(options?.mode ?? "fast");
+    const summary = await qualityGates.run({
+      ...gateFlags,
+      cwd: workingDir,
+      abortSignal: options?.abortSignal,
+      ...typeof options?.timeoutMs === "number" && options.timeoutMs > 0 ? { timeoutMs: options.timeoutMs } : {}
+    });
+    const testFailuresResult = extractFailureCountWithMethod(
+      summary.results,
+      testEvidenceGateId(summary.results)
+    );
+    const lintErrorsResult = extractFailureCountWithMethod(summary.results, "lint");
+    const securityFailuresResult = extractFailureCountWithMethod(summary.results, "security");
+    const typeErrorsResult = lintErrorsResult;
+    const failedCommandsOf = (gate) => {
+      const gateResult = summary.results.find((entry) => entry.gate === gate);
+      return gateResult?.success ? [] : gateResult?.failedCommands;
+    };
+    return {
+      status: "captured",
+      testFailures: testFailuresResult.count,
+      testFailuresMethod: testFailuresResult.method,
+      ...testFailuresResult.suiteFootprint ? { testSuiteFootprint: testFailuresResult.suiteFootprint } : {},
+      ...testFailuresResult.messages && testFailuresResult.messages.length > 0 ? { testFailureMessages: testFailuresResult.messages } : {},
+      testEvidenceCommand: summary.results.find(
+        (entry) => entry.gate === testEvidenceGateId(summary.results)
+      )?.command,
+      lintErrors: lintErrorsResult.count,
+      lintErrorsMethod: lintErrorsResult.method,
+      typeErrors: typeErrorsResult.count,
+      typeErrorsMethod: typeErrorsResult.method,
+      securityFailures: securityFailuresResult.count,
+      securityFailuresMethod: securityFailuresResult.method,
+      gateEvidence: Object.fromEntries(
+        summary.results.map((entry) => [entry.gate, gateEvidenceOf(entry, workingDir)])
+      ),
+      lintFailedCommands: failedCommandsOf("lint"),
+      testFailedCommands: failedCommandsOf(testEvidenceGateId(summary.results)),
+      securityFailedCommands: failedCommandsOf("security"),
+      gateAvailability: {
+        coverage: summary.results.some(
+          (result) => isTestEvidenceGate(result.gate) && !result.skipped && !result.unavailable
+        ),
+        lint: summary.results.some(
+          (result) => result.gate === "lint" && !result.skipped && !result.unavailable
+        ),
+        security: summary.results.some(
+          (result) => result.gate === "security" && !result.skipped && !result.unavailable
+        )
+      },
+      capturedAt: /* @__PURE__ */ new Date()
+    };
+  } catch (error) {
+    console.warn(
+      `[AutonomousLoopController] Failed to capture quality baseline: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return {
+      status: "failed",
+      reason: error instanceof Error ? error.message : String(error),
+      capturedAt: /* @__PURE__ */ new Date()
+    };
+  }
+}
+function computeErrorSignature(result) {
+  const normalizedMessage = (result.error?.message ?? "").replace(/T\d+/g, "TASK_ID").replace(/\d+/g, "N").trim().toLowerCase();
+  const warningCodes = [...new Set(result.warningCodes ?? [])].sort();
+  const missingFiles = [...new Set(result.metadata?.missingFiles ?? [])].sort();
+  const hash = createHash("sha256").update(JSON.stringify({ normalizedMessage, warningCodes, missingFiles })).digest("hex").slice(0, 16);
+  return {
+    hash,
+    components: {
+      normalizedMessage,
+      warningCodes,
+      missingFiles
+    }
+  };
+}
+function classifyCoverageBaselineComparison(baseline, candidate) {
+  if (baseline.failures === null || candidate.failures === null) {
+    return "unknown";
+  }
+  if (candidate.failures > baseline.failures) {
+    return "regression";
+  }
+  const baseFp = baseline.suiteFootprint;
+  const candFp = candidate.suiteFootprint;
+  if (!baseFp || !candFp) {
+    return "unknown";
+  }
+  if (candFp.executed < baseFp.executed) {
+    return "regression";
+  }
+  if (candFp.skipped > baseFp.skipped) {
+    return "regression";
+  }
+  if (candidate.failures < baseline.failures) {
+    return "improvement";
+  }
+  const baseMsgs = baseline.messages ?? [];
+  const candMsgs = candidate.messages ?? [];
+  if (baseMsgs.length === 0 || candMsgs.length === 0) {
+    return "unknown";
+  }
+  if (!stableMessageSetsMatch(baseMsgs, candMsgs)) {
+    return "unknown";
+  }
+  return "pre_existing";
+}
+function stableMessageSetsMatch(a, b) {
+  if (a.length !== b.length) return false;
+  const counts = /* @__PURE__ */ new Map();
+  for (const msg of a) {
+    counts.set(msg, (counts.get(msg) ?? 0) + 1);
+  }
+  for (const msg of b) {
+    const next = (counts.get(msg) ?? 0) - 1;
+    if (next < 0) return false;
+    if (next === 0) counts.delete(msg);
+    else counts.set(msg, next);
+  }
+  return counts.size === 0;
+}
+function extractFailureCountWithMethod(results, gateId) {
+  const result = results.find((r) => r.gate === gateId);
+  if (!result) {
+    return { count: 0, method: "passed_or_not_found" };
+  }
+  if (result.unavailable === true || result.skipped === true) {
+    return { count: 0, method: "passed_or_not_found" };
+  }
+  const output = result.stdout + result.stderr;
+  if (isTestEvidenceGate(gateId)) {
+    if (result.command) {
+      const parsed = parseFailureOutput(result.command, output, "test");
+      if (parsed.parsed && parsed.errorCount !== null) {
+        return {
+          count: parsed.errorCount,
+          method: "parsed_failure_output",
+          ...parsed.suiteFootprint ? { suiteFootprint: parsed.suiteFootprint } : {},
+          ...parsed.messages.length > 0 ? { messages: parsed.messages } : {}
+        };
+      }
+    }
+    if (result.success) {
+      return { count: 0, method: "passed_or_not_found" };
+    }
+    const failMatch = output.match(/(\d+)\s+(?:tests?\s+)?(?:failing|failed)/i);
+    if (failMatch?.[1]) {
+      return { count: parseInt(failMatch[1], 10), method: "fail_pattern" };
+    }
+  }
+  if (result.success) {
+    return { count: 0, method: "passed_or_not_found" };
+  }
+  if (gateId === "lint") {
+    if (result.command) {
+      const parsed = parseFailureOutput(result.command, output, "lint");
+      if (parsed.parsed && parsed.errorCount !== null) {
+        return { count: parsed.errorCount, method: "parsed_failure_output" };
+      }
+      const unavailable2 = unavailableFailureCountForCommand(result.command, "lint");
+      if (unavailable2) {
+        return { count: null, method: "unavailable_no_parser", language: unavailable2.language };
+      }
+    }
+    const tsErrorMatches = output.match(/error TS\d+:/g);
+    if (tsErrorMatches && tsErrorMatches.length > 0) {
+      return { count: tsErrorMatches.length, method: "ts_error_lines" };
+    }
+    const eslintMatch = output.match(/(\d+)\s+problems?\s*\(\s*(\d+)\s+errors?/i);
+    if (eslintMatch?.[2]) {
+      return { count: parseInt(eslintMatch[2], 10), method: "eslint_summary" };
+    }
+    const errorMatches = Array.from(output.matchAll(/(?:Found\s+)?(\d+)\s+errors?/gi));
+    const lastErrorMatch = errorMatches[errorMatches.length - 1];
+    if (lastErrorMatch?.[1]) {
+      return { count: parseInt(lastErrorMatch[1], 10), method: "found_errors" };
+    }
+  }
+  if (gateId === "security") {
+    const blockingCount = countSecurityVulnerabilities(result, countBlockingVulnerabilities);
+    if (blockingCount !== null) {
+      return { count: blockingCount, method: "security_vuln_count" };
+    }
+  }
+  const unavailable = isTestEvidenceGate(gateId) && result.command ? unavailableFailureCountForCommand(result.command, "test") : null;
+  if (unavailable) {
+    return { count: null, method: "unavailable_no_parser", language: unavailable.language };
+  }
+  return { count: 1, method: "fallback_1" };
+}
+function createProgressScore(score) {
+  if (score < 0 || score > 1) {
+    throw new Error(`Progress score must be between 0 and 1, got: ${score}`);
+  }
+  return score;
+}
+function createIterationCount(count) {
+  if (count < 0 || !Number.isInteger(count)) {
+    throw new Error(`Iteration count must be a non-negative integer, got: ${count}`);
+  }
+  return count;
+}
+function createDurationMs(ms) {
+  if (ms < 0 || !Number.isFinite(ms)) {
+    throw new Error(`Duration must be a non-negative finite number, got: ${ms}`);
+  }
+  return ms;
+}
+function calculateBackoffDelay(attempt, config) {
+  const delay = Math.min(config.initialDelayMs * config.multiplier ** attempt, config.maxDelayMs);
+  return createDurationMs(delay);
+}
+function getResourceUsage() {
+  const memory = process.memoryUsage();
+  const cpu = process.cpuUsage();
+  const cpuCount = Math.max(1, os.cpus().length);
+  const load1 = os.loadavg?.()[0] ?? 0;
+  const cpuPercent = Math.max(0, load1 / cpuCount * 100);
+  return {
+    memory,
+    cpu: (cpu.user + cpu.system) / 1e6,
+    // Convert to seconds
+    processes: globalProcessLimiter.getActiveCount(),
+    cpuPercent
+  };
+}
+function requiredHostGatesPassed(qualityGates, customGates) {
+  const ran = (qualityGates ?? []).some((gate) => gate.passed && gate.skipped !== true) || (customGates ?? []).some((gate) => gate.passed);
+  const qualityOk = (qualityGates ?? []).every(
+    (gate) => gate.passed || isNonBlockingQualityGateSkip(gate)
+  );
+  return ran && qualityOk && (customGates ?? []).every((gate) => gate.passed);
+}
+var AutonomousLoopController = class extends EventEmitter {
+  config;
+  recursionTracker;
+  telemetry;
+  resultStreamer;
+  aiJudge;
+  qualityGates;
+  progressValidator;
+  state = { status: "idle" };
+  iterationHistory = [];
+  startTime = 0;
+  elapsedRuntimeBeforeStartMs = 0;
+  instanceId = `AutonomousLoopController-${createHash("md5").update(String(Date.now() + Math.random())).digest("hex").slice(0, 8)}`;
+  cleanupStarted = false;
+  backoffAttempts = 0;
+  resourceWarnings = /* @__PURE__ */ new Set();
+  lastErrorSignature = null;
+  consecutiveIdenticalCount = 0;
+  /** A normally returned failure is recorded but, as before, does not spend retry budget. */
+  lastIterationReturnedFailure = false;
+  /**
+   * Set when shouldContinue idle-stops after a real first delivery so start()
+   * can mark the run completed even if the completion XML 0.3 gate left the
+   * oracle at NOT_COMPLETE. Does not change totalIterations accounting.
+   */
+  idleStoppedAfterRealFirstDelivery = false;
+  cleanupHandlers = [];
+  workingDir = process.cwd();
+  /** Whether completion signal matched on last iteration */
+  completionSignalMatched = false;
+  /** Quality baseline captured at loop start (undefined until initialized) */
+  qualityBaseline;
+  /** Custom gate pass/fail captured at loop start (gate id -> passed). */
+  customGateBaseline;
+  /** TypeScript error baseline captured at loop start (null if not applicable) */
+  compilationBaselineErrors = null;
+  /** Monotonic policy level for stability-first escalation */
+  policyLevel = "baseline";
+  /**
+   * Git ref (SHA) captured at loop start for semantic validation diffs.
+   *
+   * Important: semantic validation should evaluate cumulative work across the whole loop,
+   * not just the last iteration’s working-tree or last commit’s diff.
+   */
+  semanticBaselineRef = null;
+  /** Loop-start HEAD SHA for change-surface gate scaling. */
+  loopStartRef = null;
+  /** Git ref (SHA) captured at loop start for progress validation diffs. */
+  progressBaselineRef = null;
+  /** Current provider for cross-provider pivot (initialized from routing decision or undefined) */
+  currentProvider;
+  /** Current provider setup mode for pivot-aware execution mode selection */
+  currentProviderSetup;
+  /** Available alternate providers for pivot */
+  availableAlternates = [];
+  constructor(config = {}, dependencies = {}) {
+    super();
+    this.config = {
+      maxIterations: createIterationCount(3),
+      timeboxMs: createDurationMs(DEFAULT_AUTOLOOP_TIMEBOX_MS),
+      minProgressThreshold: createProgressScore(0.05),
+      useAIJudge: false,
+      runQualityGates: false,
+      qualityGatesMode: "fast",
+      resourceLimits: DEFAULT_AUTOLOOP_RESOURCE_LIMITS,
+      backoffConfig: {
+        initialDelayMs: createDurationMs(1e3),
+        maxDelayMs: createDurationMs(3e4),
+        multiplier: 2,
+        maxRetries: 3
+      },
+      progressConfig: {
+        windowSize: 3,
+        trendThreshold: 0.01,
+        confidenceThreshold: 0.7
+      },
+      validationMode: "heuristic",
+      requirements: {
+        mode: "auto",
+        minCoverage: 0.9,
+        requireEvidence: true,
+        blockNewRepoRootMarkdown: true
+      },
+      // completionSignal is undefined by default (opt-in)
+      ...config
+    };
+    this.recursionTracker = globalRecursionTracker;
+    this.telemetry = dependencies.telemetry;
+    this.resultStreamer = dependencies.resultStreamer;
+    this.aiJudge = dependencies.aiJudge;
+    this.qualityGates = dependencies.qualityGates;
+    this.validateConfig();
+    if (this.config.routingDecision) {
+      this.currentProvider = this.config.routingDecision.primary.provider;
+      this.currentProviderSetup = this.config.routingDecision.primary.setup;
+      this.availableAlternates = [...this.config.routingDecision.alternates];
+    }
+    this.progressValidator = createCustomProgressValidator({
+      minProgressThreshold: this.config.minProgressThreshold,
+      trendThreshold: this.config.progressConfig.trendThreshold
+    });
+    this.setupEventForwarding();
+  }
+  // ========================================================================
+  // PUBLIC API
+  // ========================================================================
+  /**
+   * Start the autonomous loop with the given task function
+   */
+  async start(taskFunction) {
+    if (this.state.status !== "idle") {
+      throw new Error(`Cannot start loop in state: ${this.state.status}`);
+    }
+    try {
+      this.synchronizeWallClockBudgetAtStart();
+      this.startTime = performance.now();
+      this.state = {
+        status: "running",
+        _iteration: createIterationCount(0),
+        startTime: this.startTime
+      };
+      if (this.getRemainingTimeboxMs() <= 0) {
+        this.terminate("timebox_exceeded");
+        throw new Error("Autoloop timebox exceeded before loop started");
+      }
+      await this.initializeSafetySystems();
+      this.emit("loop_started", { type: "loop_started", config: this.config });
+      let lastResult;
+      for (let i = 1; i <= this.config.maxIterations; i++) {
+        if (this.state.status !== "running") {
+          break;
+        }
+        const iteration = createIterationCount(i);
+        if (this.state.status === "running") {
+          this.state._iteration = iteration;
+        }
+        if (await this.shouldTerminate(iteration)) {
+          break;
+        }
+        if (this.state.status !== "running") {
+          break;
+        }
+        lastResult = await this.executeIteration(iteration, taskFunction);
+        this.iterationHistory.push(lastResult);
+        if (!await this.shouldContinue(lastResult)) {
+          break;
+        }
+        if (!lastResult.success && !this.lastIterationReturnedFailure) {
+          if (this.isRunAborted()) {
+            if (this.state.status === "running") {
+              this.terminate("system_error");
+            }
+            break;
+          }
+          await this.applyBackoff();
+        }
+      }
+      if (!lastResult) {
+        const terminatedReason2 = this.state.status === "terminated" ? this.state.reason : void 0;
+        if (terminatedReason2 === "timebox_exceeded") {
+          const timeboxMin = (this.config.timeboxMs / 6e4).toFixed(1);
+          throw new Error(
+            `Autoloop timebox (${timeboxMin}m) elapsed before the first iteration completed. Baseline quality-gate capture runs inside the first iteration and can exhaust a small budget; increase --autoloop-timebox (recommend at least 15m) or reduce gate cost with --autoloop-quality-gates-mode fast.`
+          );
+        }
+        throw new Error("No iterations were executed");
+      }
+      const finalResult = lastResult;
+      const totalDuration = createDurationMs(this.getElapsedRuntimeMs());
+      const hasCompilationFailure = this.detectCompilationFailure(finalResult);
+      const currentTerminatedReason = this.state.status === "terminated" ? this.state.reason : null;
+      const isMaxIterationsOnly = currentTerminatedReason === "max_iterations_reached";
+      if (hasCompilationFailure && (this.state.status !== "terminated" || isMaxIterationsOnly)) {
+        this.telemetry?.logEvent({
+          name: "loop_terminated_compilation_errors",
+          timestamp: /* @__PURE__ */ new Date(),
+          properties: {
+            iteration: finalResult._iteration,
+            progressScore: finalResult.progress.score,
+            insights: finalResult.progress.insights.slice(0, 3)
+          }
+        });
+        this.upgradeTerminationReason("compilation_errors");
+        return { ...finalResult, success: false };
+      }
+      if (this.iterationHistory.length >= this.config.maxIterations && this.state.status === "running") {
+        this.terminate("max_iterations_reached");
+      }
+      const ranAllIterations = this.iterationHistory.length === this.config.maxIterations;
+      const terminatedReason = this.state.status === "terminated" ? this.state.reason : null;
+      const isBudgetCompletionTermination = terminatedReason === "max_iterations_reached";
+      const isSuccessfulEarlyTermination = terminatedReason !== null && isSuccessLikeControllerReason(terminatedReason);
+      const currentStateStatus = this.state.status;
+      const summaryProvesUnsafeCompletion = finalResult.completionSummary?.unsafeCompletion === true;
+      const summaryAllowsCompletion = completionStatusAllowsSuccess(finalResult.completionSummary?.status) || this.idleStoppedAfterRealFirstDelivery;
+      const shouldMarkCompleted = (currentStateStatus === "running" && finalResult.success !== false || currentStateStatus === "terminated" && (ranAllIterations && isBudgetCompletionTermination || isSuccessfulEarlyTermination) && finalResult.success !== false) && !summaryProvesUnsafeCompletion && summaryAllowsCompletion;
+      if (shouldMarkCompleted) {
+        this.state = {
+          status: "completed",
+          totalIterations: createIterationCount(this.iterationHistory.length),
+          finalScore: finalResult.progress.score,
+          duration: totalDuration,
+          completionReason: terminatedReason ?? void 0
+        };
+        this.emit("loop_completed", {
+          type: "loop_completed",
+          finalResult,
+          totalDuration
+        });
+      } else if (this.state.status === "running" && finalResult.success === false) {
+        const failureError = finalResult.error ?? new Error("Autoloop ended without success");
+        this.state = {
+          status: "failed",
+          _iteration: finalResult._iteration,
+          _error: failureError,
+          duration: totalDuration
+        };
+        this.emit("loop_failed", {
+          type: "loop_failed",
+          error: failureError,
+          _iteration: finalResult._iteration
+        });
+      }
+      return finalResult;
+    } catch (error) {
+      if (this.state.status === "terminated") {
+        throw error;
+      }
+      const currentIteration = this.state.status === "running" ? this.state._iteration : createIterationCount(0);
+      const duration = createDurationMs(this.getElapsedRuntimeMs());
+      this.state = {
+        status: "failed",
+        _iteration: currentIteration,
+        _error: error,
+        duration
+      };
+      this.emit("loop_failed", {
+        type: "loop_failed",
+        error,
+        _iteration: currentIteration
+      });
+      throw error;
+    } finally {
+      await this.cleanup();
+      this.close();
+    }
+  }
+  /**
+   * Set the initial policy level (e.g., from static pre-run detection).
+   *
+   * Monotonic: only allows moving to a more conservative level.
+   */
+  setInitialPolicyLevel(level) {
+    if (this.policyLevel === "safe") return;
+    if (this.policyLevel === "guarded" && level === "baseline") return;
+    this.policyLevel = level;
+  }
+  /**
+   * Apply a monotonic escalation in response to a runtime signal.
+   *
+   * Returns true if the policy level advanced (even if no config knobs changed),
+   * false if already at max level.
+   */
+  escalatePolicy(signal, details) {
+    const escalation = computeMonotonicAutoloopEscalation({
+      currentLevel: this.policyLevel,
+      signal,
+      currentValidationMode: this.config.validationMode,
+      currentUseAIJudge: this.config.useAIJudge,
+      currentQualityGatesMode: this.config.qualityGatesMode,
+      runQualityGates: this.config.runQualityGates
+    });
+    if (!escalation) return false;
+    if (escalation.corePatch.validationMode && this.config.validationMode === "none") {
+      this.config.validationMode = escalation.corePatch.validationMode;
+    }
+    if (escalation.corePatch.useAIJudge === true) {
+      if (this.aiJudge) {
+        this.config.useAIJudge = true;
+      } else {
+        this.telemetry?.logEvent({
+          name: "autoloop_escalation_skipped",
+          timestamp: /* @__PURE__ */ new Date(),
+          properties: { reason: "ai_judge_dependency_missing", signal }
+        });
+      }
+    }
+    if (escalation.corePatch.qualityGatesMode && this.config.runQualityGates) {
+      if (this.config.qualityGatesMode === "fast" && escalation.corePatch.qualityGatesMode === "safe") {
+        this.config.qualityGatesMode = "safe";
+      }
+    }
+    const from = this.policyLevel;
+    this.policyLevel = escalation.to;
+    this.telemetry?.logEvent({
+      name: "autoloop_policy_escalated",
+      timestamp: /* @__PURE__ */ new Date(),
+      properties: {
+        from,
+        to: escalation.to,
+        signal,
+        appliedPatch: escalation.corePatch,
+        ...details ? { details } : {}
+      }
+    });
+    this.emit("policy_escalated", {
+      type: "policy_escalated",
+      from,
+      to: escalation.to,
+      signal,
+      appliedPatch: escalation.corePatch,
+      ...details ? { details } : {}
+    });
+    return true;
+  }
+  /**
+   * Terminate the loop with a specific reason
+   */
+  terminate(reason) {
+    if (this.state.status === "terminated") {
+      return;
+    }
+    if (this.state.status === "idle" || this.state.status === "completed" || this.state.status === "failed") {
+      return;
+    }
+    if (this.state.status !== "running") {
+      return;
+    }
+    const currentIteration = createIterationCount(this.iterationHistory.length);
+    const duration = createDurationMs(this.getElapsedRuntimeMs());
+    this.state = {
+      status: "terminated",
+      _iteration: currentIteration,
+      reason,
+      duration
+    };
+    this.emit("loop_terminated", {
+      type: "loop_terminated",
+      reason,
+      _iteration: currentIteration
+    });
+  }
+  /**
+   * Internal reason upgrade used by the start() epilogue: replaces the generic
+   * budget termination ('max_iterations_reached') with a more specific reason
+   * such as 'compilation_errors'. Bypasses terminate()'s already-terminated
+   * early return without changing public terminate() semantics. Deliberately
+   * does not re-emit 'loop_terminated' (the original termination event has
+   * already been delivered to ledger/CLI listeners).
+   */
+  upgradeTerminationReason(reason) {
+    if (this.state.status !== "terminated") {
+      this.terminate(reason);
+      return;
+    }
+    this.state = { ...this.state, reason };
+  }
+  /**
+   * Get current loop state
+   */
+  getState() {
+    return { ...this.state };
+  }
+  /** The loop-start gate baseline, or why there is none. */
+  getQualityBaseline() {
+    return this.qualityBaseline;
+  }
+  /**
+   * Get iteration history
+   */
+  getIterationHistory() {
+    return [...this.iterationHistory];
+  }
+  /**
+   * Get current configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * Override the working directory used for git-based progress validation and quality gates.
+   *
+   * Useful when an orchestrator executes iterations inside an isolated worktree.
+   */
+  setWorkingDir(workingDir) {
+    this.workingDir = workingDir;
+  }
+  /**
+   * Apply outer-run wall-clock handoff immediately before start().
+   *
+   * CLI setup (evidence-plan resolution, worktree creation, etc.) happens before the
+   * controller starts; this keeps custom/evidence gate budgets aligned with runStart.
+   */
+  applyWallClockHandoff(handoff) {
+    if (typeof handoff.wallClockRunStartMs === "number" && Number.isFinite(handoff.wallClockRunStartMs)) {
+      this.config.wallClockRunStartMs = handoff.wallClockRunStartMs;
+    }
+    if (typeof handoff.preControllerElapsedMs === "number" && Number.isFinite(handoff.preControllerElapsedMs)) {
+      this.config.preControllerElapsedMs = Math.max(0, Math.floor(handoff.preControllerElapsedMs));
+    }
+  }
+  // ========================================================================
+  // PRIVATE IMPLEMENTATION
+  // ========================================================================
+  /**
+   * Validate configuration values
+   */
+  validateConfig() {
+    if (this.config.maxIterations <= 0) {
+      throw new Error("Iteration count must be a positive integer");
+    }
+    if (this.config.validationMode === "deterministic" && this.config.completionSignal) {
+      throw new Error(
+        'Cannot combine validation mode "deterministic" with a completion signal. Deterministic mode uses quality gates to determine completion.'
+      );
+    }
+    if (this.config.runQualityGates && !this.qualityGates) {
+      throw new Error(
+        "Quality gates enabled (runQualityGates=true) but no QualityGateRunner injected. Either wire `dependencies.qualityGates` or set `runQualityGates: false` if gates are run elsewhere."
+      );
+    }
+    if (this.config.useAIJudge && !this.aiJudge) {
+      throw new Error(
+        "AI judge enabled (useAIJudge=true) but no Judge injected. Either wire `dependencies.aiJudge` or set `useAIJudge: false`."
+      );
+    }
+  }
+  synchronizeWallClockBudgetAtStart() {
+    const elapsedMs = resolveAutoloopElapsedMs({
+      wallClockRunStartMs: this.config.wallClockRunStartMs,
+      preControllerElapsedMs: this.config.preControllerElapsedMs
+    });
+    if (elapsedMs > 0) {
+      this.elapsedRuntimeBeforeStartMs = elapsedMs;
+    }
+  }
+  getElapsedRuntimeMs() {
+    if (typeof this.config.wallClockRunStartMs === "number" && Number.isFinite(this.config.wallClockRunStartMs)) {
+      return Math.max(0, Date.now() - this.config.wallClockRunStartMs);
+    }
+    if (this.state.status === "running") {
+      return this.elapsedRuntimeBeforeStartMs + (performance.now() - this.startTime);
+    }
+    return this.elapsedRuntimeBeforeStartMs;
+  }
+  isRunAborted() {
+    return this.config.abortSignal?.aborted === true;
+  }
+  getRemainingTimeboxMs() {
+    return Math.max(0, Math.floor(this.config.timeboxMs - this.getElapsedRuntimeMs()));
+  }
+  ensureRemainingTimeboxMs(phase) {
+    const remainingMs = this.getRemainingTimeboxMs();
+    if (remainingMs <= 0) {
+      this.terminate("timebox_exceeded");
+      throw new Error(`Autoloop timebox exceeded before ${phase}`);
+    }
+    return remainingMs;
+  }
+  getFirstIterationReserveMs() {
+    const timeboxMs = Number(this.config.timeboxMs);
+    if (!Number.isFinite(timeboxMs) || timeboxMs <= 0) {
+      return 0;
+    }
+    const proportionalReserveMs = Math.floor(timeboxMs * 0.25);
+    const maxReserveForTimeboxMs = Math.max(1, Math.floor(timeboxMs * 0.5));
+    return Math.min(
+      MAX_FIRST_ITERATION_RESERVE_MS,
+      maxReserveForTimeboxMs,
+      Math.max(MIN_FIRST_ITERATION_RESERVE_MS, proportionalReserveMs)
+    );
+  }
+  getPreIterationGateBudgetMs() {
+    const remainingMs = this.getRemainingTimeboxMs();
+    const reserveMs = this.getFirstIterationReserveMs();
+    return {
+      budgetMs: Math.max(0, remainingMs - reserveMs),
+      reserveMs,
+      remainingMs
+    };
+  }
+  /**
+   * Initialize safety systems
+   */
+  async initializeSafetySystems() {
+    await this.recursionTracker.enter();
+    this.checkResourceLimits();
+    this.setupCleanupHandlers();
+    this.compilationBaselineErrors = await countTypeScriptErrors(this.workingDir);
+    if (this.compilationBaselineErrors !== null) {
+      this.telemetry?.logEvent({
+        name: "compilation_baseline_captured",
+        timestamp: /* @__PURE__ */ new Date(),
+        properties: {
+          totalErrors: this.compilationBaselineErrors
+        }
+      });
+    }
+    if (this.config.runQualityGates && this.qualityGates) {
+      const {
+        budgetMs: baselineBudgetMs,
+        reserveMs,
+        remainingMs
+      } = this.getPreIterationGateBudgetMs();
+      if (baselineBudgetMs <= 0 || this.isRunAborted()) {
+        const skipReason = this.isRunAborted() ? "aborted" : remainingMs <= 0 ? "insufficient_timebox" : "first_iteration_reserved";
+        this.qualityBaseline = {
+          status: "skipped",
+          reason: skipReason,
+          capturedAt: /* @__PURE__ */ new Date()
+        };
+        this.telemetry?.logEvent({
+          name: "quality_baseline_skipped",
+          timestamp: /* @__PURE__ */ new Date(),
+          properties: {
+            remainingMs,
+            reserveMs,
+            reason: skipReason
+          }
+        });
+      } else {
+        this.qualityBaseline = await captureQualityBaseline(this.workingDir, this.qualityGates, {
+          mode: this.config.qualityGatesMode,
+          timeoutMs: baselineBudgetMs,
+          abortSignal: this.config.abortSignal
+        });
+        const captured = this.qualityBaseline.status === "captured" ? this.qualityBaseline : void 0;
+        this.telemetry?.logEvent({
+          name: "quality_baseline_captured",
+          timestamp: /* @__PURE__ */ new Date(),
+          properties: {
+            budgetMs: baselineBudgetMs,
+            reserveMs,
+            status: this.qualityBaseline.status,
+            reason: this.qualityBaseline.status === "captured" ? void 0 : this.qualityBaseline.reason,
+            testFailures: captured?.testFailures,
+            testFailuresMethod: captured?.testFailuresMethod,
+            lintErrors: captured?.lintErrors,
+            lintErrorsMethod: captured?.lintErrorsMethod,
+            typeErrors: captured?.typeErrors,
+            typeErrorsMethod: captured?.typeErrorsMethod,
+            securityFailures: captured?.securityFailures,
+            securityFailuresMethod: captured?.securityFailuresMethod
+          }
+        });
+      }
+    }
+    if (this.config.runQualityGates && this.config.customGateCommands && this.config.customGateCommands.length > 0) {
+      const {
+        budgetMs: customBaselineBudgetMs,
+        reserveMs,
+        remainingMs
+      } = this.getPreIterationGateBudgetMs();
+      if (customBaselineBudgetMs < MIN_CUSTOM_GATE_BASELINE_MS || remainingMs < MIN_CUSTOM_GATE_BASELINE_MS || this.isRunAborted()) {
+        this.telemetry?.logEvent({
+          name: "custom_gate_baseline_skipped",
+          timestamp: /* @__PURE__ */ new Date(),
+          properties: {
+            remainingMs,
+            reserveMs,
+            reason: this.isRunAborted() ? "aborted" : remainingMs < MIN_CUSTOM_GATE_BASELINE_MS ? "insufficient_timebox" : "first_iteration_reserved"
+          }
+        });
+      } else {
+        const baselineResults = await this.runCustomGates(
+          createIterationCount(0),
+          this.config.customGateCommands,
+          customBaselineBudgetMs
+        );
+        this.customGateBaseline = new Map(
+          baselineResults.filter((result) => result.skipped !== true && result.misconfigured !== true).map((result) => [result.id, result.passed])
+        );
+        this.telemetry?.logEvent({
+          name: "custom_gate_baseline_captured",
+          timestamp: /* @__PURE__ */ new Date(),
+          properties: {
+            budgetMs: customBaselineBudgetMs,
+            reserveMs,
+            gateCount: baselineResults.length,
+            failingAtStart: baselineResults.filter((result) => !result.passed).length
+          }
+        });
+      }
+    }
+    if (this.config.semanticCheck?.enabled || this.config.validationMode === "heuristic" || (this.config.requirementsTaskText?.length ?? 0) > 0 || this.config.runQualityGates && (this.config.customGateCommands?.length ?? 0) > 0) {
+      try {
+        const { execa } = await import("execa");
+        const { stdout } = await execa("git", ["rev-parse", "HEAD"], {
+          cwd: this.workingDir,
+          timeout: 5e3,
+          maxBuffer: 1024 * 1024,
+          stderr: "ignore"
+        });
+        const sha = stdout.trim();
+        const resolvedSha = sha || null;
+        this.loopStartRef = resolvedSha;
+        if (this.config.semanticCheck?.enabled) {
+          this.semanticBaselineRef = resolvedSha;
+        }
+        if (this.config.validationMode === "heuristic") {
+          this.progressBaselineRef = resolvedSha;
+        }
+        if (sha) {
+          this.telemetry?.logEvent({
+            name: "semantic_baseline_captured",
+            timestamp: /* @__PURE__ */ new Date(),
+            properties: { baseRef: sha }
+          });
+        }
+      } catch {
+        this.loopStartRef = null;
+        if (this.config.semanticCheck?.enabled) {
+          this.semanticBaselineRef = null;
+        }
+        if (this.config.validationMode === "heuristic") {
+          this.progressBaselineRef = null;
+        }
+      }
+    }
+  }
+  /**
+   * Replace stale progress-insight wording when a completion signal succeeds
+   * because separate durable evidence proved completion.
+   */
+  reconcileCompletionEvidenceInsights(result) {
+    const summary = result.completionSummary;
+    if (result.completionEvidence?.durable !== true || summary?.completionSignalDetected !== true || !completionStatusAllowsSuccess(summary.status) && summary.status !== "BASELINE_BLOCKED") {
+      return;
+    }
+    const illusoryProgressPattern = /reported progress may be illusory/i;
+    const staleCompletenessPattern = /^(Task appears nearly complete|Good progress, some work remaining|Halfway through task completion|Significant work still needed)$/i;
+    const filteredInsights = [];
+    let removedIllusoryProgress = false;
+    let removedStaleCompleteness = false;
+    for (const insight of result.progress.insights) {
+      if (result.progress.toolingFailure === true && illusoryProgressPattern.test(insight)) {
+        removedIllusoryProgress = true;
+        continue;
+      }
+      if (staleCompletenessPattern.test(insight)) {
+        removedStaleCompleteness = true;
+        continue;
+      }
+      filteredInsights.push(insight);
+    }
+    if (!removedIllusoryProgress && !removedStaleCompleteness) {
+      return;
+    }
+    result.progress.insights = [
+      ...filteredInsights,
+      ...removedStaleCompleteness ? ["Durable completion evidence satisfied the requested completion criteria."] : [],
+      ...removedIllusoryProgress ? [
+        "Progress validation tooling failed; durable completion evidence satisfied the completion signal."
+      ] : []
+    ];
+  }
+  /**
+   * Execute a single iteration
+   */
+  async executeIteration(iteration, taskFunction) {
+    const iterationStart = performance.now();
+    this.emit("iteration_start", { type: "iteration_start", iteration });
+    this.lastIterationReturnedFailure = false;
+    try {
+      const lastIteration = this.iterationHistory.length > 0 ? this.iterationHistory[this.iterationHistory.length - 1] : void 0;
+      const blockingCustomGate = lastIteration?.customGateResults?.find(
+        isBlockingCustomGateForCompletion
+      );
+      const boundedCustomGateContext = blockingCustomGate ? `Custom gate '${blockingCustomGate.id}' failed${typeof blockingCustomGate.exitCode === "number" ? ` (exit code ${blockingCustomGate.exitCode})` : ""}${blockingCustomGate.outputTail ? `: ${blockingCustomGate.outputTail.slice(-1e3)}` : ""}` : void 0;
+      const previousError = lastIteration && (!lastIteration.success || boundedCustomGateContext) ? {
+        message: [lastIteration.error?.message, boundedCustomGateContext].filter((part) => Boolean(part)).join("\n"),
+        iteration: lastIteration._iteration,
+        // Convert branded type to plain number
+        ...lastIteration.error ? classifyError(lastIteration.error) : { category: "unknown" },
+        ...boundedCustomGateContext ? { hint: "Address the blocking custom-gate failure before retrying." } : {}
+      } : void 0;
+      const HISTORY_WINDOW = 10;
+      const context = {
+        _iteration: iteration,
+        history: this.iterationHistory.length <= HISTORY_WINDOW ? [...this.iterationHistory] : this.iterationHistory.slice(-HISTORY_WINDOW),
+        config: this.config,
+        isFirstIteration: iteration === 1,
+        isLastIteration: iteration === this.config.maxIterations,
+        previousError,
+        workingDir: this.workingDir,
+        currentProvider: this.currentProvider,
+        currentProviderSetup: this.currentProviderSetup,
+        availableAlternates: [...this.availableAlternates]
+      };
+      const remainingTimeboxMs = this.config.timeboxMs - this.getElapsedRuntimeMs();
+      if (remainingTimeboxMs <= 0) {
+        this.terminate("timebox_exceeded");
+        throw new Error("Autoloop timebox exceeded before iteration started");
+      }
+      let timeoutId;
+      const iterationAbortController = new AbortController();
+      const iterationAbortSignal = this.config.abortSignal ? AbortSignal.any([this.config.abortSignal, iterationAbortController.signal]) : iterationAbortController.signal;
+      context.abortSignal = iterationAbortSignal;
+      const timeboxError = new Error("Autoloop iteration exceeded remaining timebox");
+      const timeboxRace = new Promise((_, reject) => {
+        timeoutId = setTimeout(() => {
+          reject(timeboxError);
+          iterationAbortController.abort(timeboxError);
+        }, remainingTimeboxMs);
+      });
+      const abortSignal = iterationAbortSignal;
+      let abortListener;
+      const recursionStateFile = this.recursionTracker.getStateFilePath?.();
+      const taskPromise = recursionStateFile ? withExecutionContextEnvOverrides(
+        { BUILD_RECURSION_STATE_FILE: recursionStateFile },
+        () => taskFunction(iteration, context)
+      ) : taskFunction(iteration, context);
+      const raceArms = [taskPromise, timeboxRace];
+      if (abortSignal) {
+        const abortRace = new Promise((_, reject) => {
+          if (abortSignal.aborted) {
+            rejectIterationAbort(abortSignal, reject);
+            return;
+          }
+          abortListener = () => {
+            rejectIterationAbort(abortSignal, reject);
+          };
+          abortSignal.addEventListener("abort", abortListener, { once: true });
+        });
+        raceArms.push(abortRace);
+      }
+      let taskResult;
+      try {
+        taskResult = await Promise.race(raceArms);
+      } catch (error) {
+        if (error instanceof Error && isAutoloopTimeboxAbortError(error)) {
+          this.terminate("timebox_exceeded");
+        }
+        throw error;
+      } finally {
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+        }
+        if (abortSignal && abortListener) {
+          abortSignal.removeEventListener("abort", abortListener);
+        }
+      }
+      const returnedFailure = readReturnedTaskFailure(taskResult);
+      this.lastIterationReturnedFailure = returnedFailure !== void 0;
+      const repairOutcome = taskResult && typeof taskResult === "object" && "repairOutcome" in taskResult && isRepairOutcome(taskResult.repairOutcome) ? taskResult.repairOutcome : void 0;
+      const completionEvidence = taskResult && typeof taskResult === "object" && "completionEvidence" in taskResult && isCompletionEvidence(taskResult.completionEvidence) ? taskResult.completionEvidence : void 0;
+      const iterationFingerprint = taskResult && typeof taskResult === "object" && "iterationFingerprint" in taskResult && typeof taskResult.iterationFingerprint === "string" ? taskResult.iterationFingerprint : void 0;
+      const callbackCustomGateResults = taskResult && typeof taskResult === "object" && "customGateResults" in taskResult && isCustomGateResultsArray(taskResult.customGateResults) ? taskResult.customGateResults.map(
+        (gate) => ({
+          ...gate,
+          durationMs: createDurationMs(gate.durationMs)
+        })
+      ) : void 0;
+      const outputForChecks = selectTaskOutputForChecks(taskResult);
+      this.completionSignalMatched = false;
+      if (this.config.completionSignal) {
+        this.completionSignalMatched = matchesCompletionSignal(
+          outputForChecks,
+          this.config.completionSignal
+        );
+        if (this.completionSignalMatched) {
+          this.telemetry?.logEvent({
+            name: "completion_signal_matched",
+            timestamp: /* @__PURE__ */ new Date(),
+            properties: {
+              iteration,
+              signalType: this.config.completionSignal.type,
+              usedProviderOutputText: outputForChecks !== taskResult
+            }
+          });
+        }
+      }
+      const progress = await this.validateProgress(iteration, taskResult);
+      const metadata = {};
+      if (this.compilationBaselineErrors !== null) {
+        const currentTypeErrors = progress.compilationErrors !== void 0 ? progress.compilationErrors : await countTypeScriptErrors(this.workingDir);
+        if (currentTypeErrors !== null && currentTypeErrors > this.compilationBaselineErrors) {
+          metadata.compilationErrorDelta = currentTypeErrors - this.compilationBaselineErrors;
+        }
+      }
+      await rediscoverCandidateGates(this, this.telemetry, this.config, this.workingDir, iteration);
+      const qualityGateBudgetMs = this.config.runQualityGates ? this.ensureRemainingTimeboxMs("quality gates") : void 0;
+      const qualityGates = this.config.runQualityGates && qualityGateBudgetMs !== void 0 ? await this.runQualityGates(iteration, qualityGateBudgetMs) : void 0;
+      const customGateBudgetMs = this.config.runQualityGates && this.config.customGateCommands && this.config.customGateCommands.length > 0 ? this.ensureRemainingTimeboxMs("custom quality gates") : void 0;
+      const customGateResults = withCustomGateVerificationKinds(
+        this.workingDir,
+        customGateBudgetMs !== void 0 && this.config.customGateCommands ? await this.runCustomGates(iteration, this.config.customGateCommands, customGateBudgetMs) : callbackCustomGateResults
+      );
+      const testGateResults = [
+        // A test gate the caller disabled ("skipped by configuration") is not a
+        // missing check; leave it out so passing custom test gates still count.
+        ...(qualityGates ?? []).filter((gate) => isTestEvidenceGateResult(gate.gateId, gate.notMeasured)).filter((gate) => !isNonBlockingQualityGateSkip(gate)).map((gate) => ({
+          passed: gate.passed,
+          executed: gate.skipped !== true && gate.unavailable !== true
+        })),
+        ...(customGateResults ?? []).filter((gate) => describeVerificationCommand(gate.command).kind === "test").map((gate) => ({
+          passed: gate.passed,
+          executed: gate.skipped !== true && gate.unavailable !== true
+        }))
+      ];
+      const executedTestGates = testGateResults.filter((gate) => gate.executed);
+      const testVerification = {
+        status: executedTestGates.some((gate) => !gate.passed) ? "failed" : executedTestGates.length > 0 && testGateResults.every((gate) => gate.executed && gate.passed) ? "passed" : "unavailable",
+        checksRun: executedTestGates.length
+      };
+      const changedFiles = await this.getChangedFilesSinceLoopStart();
+      const requirements = validateRequirements({
+        requirementsTaskText: this.config.requirementsTaskText,
+        providerOutputText: outputForChecks,
+        workingDir: this.workingDir,
+        config: this.config.requirements,
+        changedFiles: changedFiles ?? void 0,
+        testVerification,
+        hostGatesPassed: requiredHostGatesPassed(qualityGates, customGateResults)
+      });
+      const judgeEvaluation = this.config.useAIJudge ? await this.getAIJudgeEvaluation(iteration, taskResult, progress) : void 0;
+      const isCompletionOrBounds = this.completionSignalMatched || iteration >= this.config.maxIterations;
+      const semanticValidation = this.config.semanticCheck?.enabled ? await this.runSemanticValidation(iteration, outputForChecks, isCompletionOrBounds) : void 0;
+      const duration = createDurationMs(performance.now() - iterationStart);
+      const memoryUsage = process.memoryUsage();
+      const result = {
+        _iteration: iteration,
+        progress,
+        requirements,
+        duration,
+        memoryUsage,
+        success: !returnedFailure,
+        error: returnedFailure,
+        iterationFingerprint,
+        metadata: Object.keys(metadata).length > 0 ? metadata : void 0,
+        qualityGates,
+        customGateResults,
+        repairOutcome,
+        judgeEvaluation,
+        semanticValidation,
+        completionEvidence,
+        usedProvider: this.currentProvider ?? this.config.routingDecision?.primary.provider
+      };
+      result.completionSummary = this.computeCompletionSummary(
+        result,
+        this.completionSignalMatched,
+        isCompletionOrBounds
+      );
+      this.reconcileCompletionEvidenceInsights(result);
+      this.emit("iteration_complete", { type: "iteration_complete", result });
+      return result;
+    } catch (error) {
+      const duration = createDurationMs(performance.now() - iterationStart);
+      const memoryUsage = process.memoryUsage();
+      const failureEnvelope = getCarriedDirectAutoloopFailureEnvelope(error) ?? classifyFailureEnvelope(error, {
+        executionPhase: "post-run",
+        mutationState: "unknown"
+      });
+      const failureRecovery = serializeDirectAutoloopFailureRecovery(
+        failureEnvelope,
+        deriveDirectAutoloopRecovery(failureEnvelope)
+      );
+      const iterationFingerprint = getCarriedDirectAutoloopIterationFingerprint(error) ?? (error && typeof error === "object" && "iterationFingerprint" in error && typeof error.iterationFingerprint === "string" ? error.iterationFingerprint : void 0);
+      const result = {
+        _iteration: iteration,
+        progress: {
+          score: createProgressScore(0),
+          isSignificant: false,
+          trend: "unknown",
+          confidence: 0,
+          metrics: {
+            testCoverage: 0,
+            completeness: 0
+          },
+          insights: [`Iteration failed: ${error.message}`]
+        },
+        completionSummary: {
+          status: "NOT_COMPLETE",
+          gatesOk: false,
+          providerOk: false,
+          convergedOk: false,
+          completionSignalDetected: false,
+          hasSubstantiveEvidence: false,
+          blockingIssues: [`Iteration failed: ${error.message}`],
+          hasBaselineFailures: false,
+          unsafeCompletion: false,
+          // Diagnostic-only: the iteration crashed BEFORE any verification gate
+          // ran, so verification never executed. Per competition semantics
+          // (judge-types-core.ts: skipped/unavailable/no-evidence -> 'not_run'),
+          // a crash with no gate evidence is 'not_run', NOT 'failed' — gatesOk is
+          // false for fail-closed decision reasons, but verification did not fail.
+          verificationDisposition: "not_run"
+        },
+        duration,
+        memoryUsage,
+        success: false,
+        iterationFingerprint,
+        error,
+        failureRecovery,
+        usedProvider: this.currentProvider ?? this.config.routingDecision?.primary.provider
+      };
+      this.emit("iteration_complete", { type: "iteration_complete", result });
+      this.telemetry?.trackError(error, { iteration, duration });
+      return result;
+    }
+  }
+  /**
+   * Validate progress using heuristic analysis (git diff + file metrics).
+   *
+   * Uses the ProgressValidator to:
+   * - Analyze git diffs to measure meaningful code changes
+   * - Detect test coverage changes
+   * - Evaluate task completeness
+   * - Determine progress trends
+   *
+   * Behavior depends on `validationMode`:
+   * - `heuristic`: Full ProgressValidator analysis
+   * - `none` or `deterministic`: Returns minimal validation (skips heuristics)
+   *
+   * @param iteration - Current iteration number
+   * @param taskResult - Result from task execution
+   * @returns ProgressValidation with scores and metrics
+   */
+  async validateProgress(iteration, taskResult) {
+    if (this.config.validationMode !== "heuristic") {
+      const skipValidation = {
+        score: createProgressScore(0.5),
+        // Neutral score
+        isSignificant: true,
+        // Don't trigger stagnation in 'none' mode
+        trend: "unknown",
+        confidence: 0,
+        metrics: {
+          testCoverage: 0,
+          completeness: 0
+        },
+        insights: [
+          `Iteration ${iteration}: Heuristic validation skipped (mode: ${this.config.validationMode})`
+        ]
+      };
+      this.emit("progress_validated", {
+        type: "progress_validated",
+        validation: skipValidation
+      });
+      this.telemetry?.logEvent({
+        name: "progress_validated",
+        timestamp: /* @__PURE__ */ new Date(),
+        properties: {
+          iteration,
+          score: skipValidation.score,
+          trend: skipValidation.trend,
+          validationMode: this.config.validationMode,
+          skipped: true
+        }
+      });
+      return skipValidation;
+    }
+    try {
+      const context = {
+        iteration,
+        taskResult,
+        workingDir: this.workingDir,
+        previousIterations: this.iterationHistory.map((r) => ({
+          progress: r.progress,
+          duration: r.duration
+        })),
+        compilationBaselineErrors: this.compilationBaselineErrors,
+        baseRef: this.progressBaselineRef ?? (typeof this.config.progressConfig.baseRef === "string" ? this.config.progressConfig.baseRef : "HEAD")
+        // Compare working tree to baseline commit by default
+      };
+      const validation = await this.progressValidator.validateProgress(context);
+      this.emit("progress_validated", {
+        type: "progress_validated",
+        validation
+      });
+      this.telemetry?.logEvent({
+        name: "progress_validated",
+        timestamp: /* @__PURE__ */ new Date(),
+        properties: {
+          iteration,
+          score: validation.score,
+          trend: validation.trend,
+          confidence: validation.confidence,
+          metrics: validation.metrics,
+          validationMode: this.config.validationMode
+        }
+      });
+      return validation;
+    } catch (error) {
+      console.warn(
+        `[AutonomousLoopController] Heuristic validation failed: ${error instanceof Error ? error.message : String(error)}`
+      );
+      this.telemetry?.trackError(error, {
+        iteration,
+        context: "progress_validation"
+      });
+      const fallbackScore = createProgressScore(
+        Math.min(0.3, iteration / this.config.maxIterations)
+      );
+      return {
+        score: fallbackScore,
+        isSignificant: false,
+        trend: "unknown",
+        confidence: 0.2,
+        metrics: {
+          testCoverage: 0.3,
+          completeness: 0.3
+        },
+        insights: [
+          `Iteration ${iteration}: Heuristic validation failed, using fallback`,
+          "Unable to analyze progress - recommend manual review"
+        ],
+        toolingFailure: true,
+        verificationUnavailable: true,
+        verificationUnavailableReason: error instanceof Error ? error.message : "Heuristic validation failed before producing a result."
+      };
+    }
+  }
+  /**
+   * Run quality gates if enabled
+   */
+  async runQualityGates(_iteration, timeoutMs) {
+    if (!this.qualityGates) return [];
+    try {
+      const gateFlags = resolveQualityGateExecutionFlags(this.config.qualityGatesMode);
+      const summary = await this.qualityGates.run({
+        ...gateFlags,
+        cwd: this.workingDir,
+        abortSignal: this.config.abortSignal,
+        ...typeof timeoutMs === "number" && timeoutMs > 0 ? { timeoutMs } : {}
+      });
+      const mappedResults = summary.results.map((result) => {
+        const duration = createDurationMs(result.durationMs);
+        let isRegression = result.skipped === true ? void 0 : this.isQualityRegression(result);
+        let baselineUnavailableReason;
+        if (!result.success && result.skipped !== true && isRegression === void 0) {
+          const current = gateEvidenceOf(result, this.workingDir);
+          const base = this.qualityBaseline?.status === "captured" ? this.qualityBaseline.gateEvidence?.[result.gate] : void 0;
+          if (failsIdenticallyOnBaseline(current, base)) {
+            isRegression = false;
+            this.telemetry?.logEvent({
+              name: "quality_gate_pre_existing_failure",
+              timestamp: /* @__PURE__ */ new Date(),
+              properties: { gate: result.gate, classification: "identical_to_baseline" }
+            });
+          } else {
+            baselineUnavailableReason = describeMissingGateBaseline(
+              this.qualityBaseline,
+              result.gate
+            );
+          }
+        }
+        let effectiveSuccess = result.success;
+        if (isTestEvidenceGate(result.gate) && !result.skipped && result.success && isRegression === true) {
+          effectiveSuccess = false;
+        }
+        const score = result.skipped ? 0 : effectiveSuccess ? 1 : 0;
+        if (effectiveSuccess && !result.skipped) {
+          this.emit("quality_gate_passed", {
+            type: "quality_gate_passed",
+            gateId: result.gate,
+            score
+          });
+        } else if (!result.skipped) {
+          this.emit("quality_gate_failed", {
+            type: "quality_gate_failed",
+            gateId: result.gate,
+            score,
+            reason: result.message
+          });
+        }
+        const buildOutputTail = () => {
+          if (effectiveSuccess) return void 0;
+          const combined = result.stdout + (result.stderr ? `
+=== stderr ===
+${result.stderr}` : "");
+          if (combined.length === 0) return void 0;
+          return combined.length > 500 ? `...${combined.slice(-500)}` : combined;
+        };
+        const fullOutput = `${result.message}
+${result.stdout}
+${result.stderr ?? ""}`;
+        const compilationFailure = !effectiveSuccess && hasCompilerErrorOutput(fullOutput, "full");
+        const failureDiagnostics = effectiveSuccess ? void 0 : boundedFailureDiagnostics({
+          command: result.command,
+          stdoutTail: result.stdout,
+          stderrTail: result.stderr
+        });
+        const exitCode = effectiveSuccess ? void 0 : result.failedCommands?.find((entry) => entry.command === result.command)?.exitCode;
+        return {
+          gateId: result.gate,
+          passed: result.skipped === true ? false : effectiveSuccess,
+          score,
+          details: result.message,
+          duration,
+          outputTail: buildOutputTail(),
+          ...effectiveSuccess || !failureDiagnostics ? {} : { diagnostics: failureDiagnostics },
+          ...effectiveSuccess ? {} : { compilationFailure },
+          isRegression,
+          ...baselineUnavailableReason ? { baselineUnavailableReason } : {},
+          ...effectiveSuccess || !result.command ? {} : { command: result.command },
+          ...exitCode === void 0 ? {} : { exitCode },
+          ...result.skipped === true ? { skipped: true } : {},
+          ...result.unavailable === true ? { unavailable: true } : {},
+          ...result.notApplicable === true ? { notApplicable: true } : {},
+          ...result.notMeasured === true ? { notMeasured: true } : {},
+          ...result.styleOnly === true ? { styleOnly: true } : {}
+        };
+      });
+      return mappedResults;
+    } catch (error) {
+      this.telemetry?.trackError(error, {
+        _iteration,
+        context: "quality_gates"
+      });
+      return [
+        {
+          gateId: "gate-runner-error",
+          passed: false,
+          score: 0,
+          isRegression: true,
+          details: error instanceof Error ? error.message : String(error),
+          duration: createDurationMs(0)
+        }
+      ];
+    }
+  }
+  /**
+   * Run custom gate commands resolved from a Phase A evidence plan.
+   *
+   * Strictly isolated from QualityGateRunner: never widens QualityGateId,
+   * never participates in baseline capture, never feeds isQualityRegression.
+   * Returns results in `customGateResults`, a sibling of `qualityGates`.
+   */
+  /**
+   * Files changed since loop start: committed/staged/unstaged tracked changes
+   * against the loop-start SHA plus untracked files. Returns null (no scaling)
+   * when the loop-start ref is unknown or git fails, so gate selection falls
+   * back to the configured command list.
+   */
+  async getChangedFilesSinceLoopStart() {
+    if (!this.loopStartRef || !/^[0-9a-f]{4,40}$/i.test(this.loopStartRef)) return null;
+    try {
+      const { execa } = await import("execa");
+      const execOptions = {
+        cwd: this.workingDir,
+        timeout: 5e3,
+        maxBuffer: 4 * 1024 * 1024,
+        stderr: "ignore"
+      };
+      const [{ stdout: tracked }, { stdout: untracked }] = await Promise.all([
+        execa("git", ["diff", "--name-only", this.loopStartRef], execOptions),
+        execa("git", ["ls-files", "--others", "--exclude-standard"], execOptions)
+      ]);
+      const files = new Set(
+        `${tracked}
+${untracked}`.split("\n").map((line) => line.trim()).filter((line) => line.length > 0)
+      );
+      return Array.from(files);
+    } catch {
+      return null;
+    }
+  }
+  async runCustomGates(iteration, commands, timeoutBudgetMs) {
+    if (commands.length === 0) return [];
+    const { checkVerifyCommandSafety, runVerifyCommands } = await import("./verify-commands-LOHMOFKC.js");
+    const { resolveVerifyCommandTimeoutMs } = await import("./verify-command-timeout-DQUYH33Z.js");
+    const { detectUnavailableGateCommand } = await import("./flywheel-autoloop-unverified-TOKYFCDC.js");
+    const { canLaunchBroadAutoloopEvidenceGate, selectCustomGateCommands } = await import("./autoloop-evidence-gates-J5GG5YQB.js");
+    if (iteration >= 1) {
+      const changedFiles = await this.getChangedFilesSinceLoopStart();
+      if (changedFiles !== null && changedFiles.length > 0) {
+        const { isProseOrTabularDiffPath } = await import("./simple-artifact-goal-MQLDDMMX.js");
+        if (this.config.customGateCommandsSource !== "prompt" && changedFiles.every((file) => isProseOrTabularDiffPath(file))) {
+          const selection = selectCustomGateCommands(commands, {
+            timeboxMs: this.config.timeboxMs,
+            artifactOnlyChangeSurface: true
+          });
+          if (selection.filtered) {
+            commands = selection.selectedCommands;
+            this.telemetry?.logEvent({
+              name: "custom_gates_scaled_for_change_surface",
+              timestamp: /* @__PURE__ */ new Date(),
+              properties: {
+                iteration,
+                reason: selection.reason ?? null,
+                changedFileCount: changedFiles.length,
+                keptCommands: selection.selectedCommands.join(", "),
+                droppedCommands: selection.droppedCommands.join(", ")
+              }
+            });
+          }
+        }
+      }
+    }
+    const results = [];
+    for (const command of commands) {
+      const start = performance.now();
+      const gateId = buildCustomGateId(command);
+      if (this.isRunAborted()) {
+        results.push({
+          id: gateId,
+          command,
+          passed: false,
+          skipped: true,
+          durationMs: createDurationMs(0),
+          outputTail: "Custom gate skipped: autoloop run aborted."
+        });
+        continue;
+      }
+      const remainingWallMs = this.getRemainingTimeboxMs();
+      const phaseBudgetMs = typeof timeoutBudgetMs === "number" && Number.isFinite(timeoutBudgetMs) ? Math.max(0, Math.floor(timeoutBudgetMs)) : void 0;
+      const effectiveRemainingMs = phaseBudgetMs !== void 0 ? Math.min(remainingWallMs, phaseBudgetMs) : remainingWallMs;
+      if (effectiveRemainingMs < MIN_CUSTOM_GATE_RUN_MS) {
+        results.push({
+          id: gateId,
+          command,
+          passed: false,
+          skipped: true,
+          durationMs: createDurationMs(0),
+          outputTail: "Custom gate skipped: autoloop timebox exhausted."
+        });
+        if (remainingWallMs <= 0) {
+          break;
+        }
+        continue;
+      }
+      if (!canLaunchBroadAutoloopEvidenceGate(command, effectiveRemainingMs, this.config.timeboxMs)) {
+        results.push({
+          id: gateId,
+          command,
+          passed: false,
+          skipped: true,
+          durationMs: createDurationMs(0),
+          outputTail: "Custom gate skipped: broad evidence verifier blocked for remaining autoloop timebox."
+        });
+        continue;
+      }
+      const commandTimeoutMs = Math.max(
+        1,
+        Math.min(effectiveRemainingMs, resolveVerifyCommandTimeoutMs())
+      );
+      try {
+        const safety = checkVerifyCommandSafety(command);
+        let passed = false;
+        let exitCode;
+        let boundedOutputTail;
+        let failureDiagnostics;
+        let durationMs = createDurationMs(0);
+        if (safety.safe) {
+          const verifyOutcome = await runVerifyCommands({
+            cwd: this.workingDir,
+            commands: [command],
+            timeoutMs: commandTimeoutMs,
+            commandProvenance: "workflow-config"
+          });
+          const verifyResult = verifyOutcome.results[0];
+          durationMs = createDurationMs(verifyResult?.durationMs ?? performance.now() - start);
+          const diagnosticOutputTail = [
+            verifyResult?.outputTail,
+            verifyResult?.stderrTail,
+            verifyResult?.stdoutTail
+          ].filter((value) => Boolean(value?.trim())).join("\n");
+          const outputTail = [verifyResult?.outputTail, verifyResult?.stderrTail, verifyResult?.stdoutTail].find(
+            (value) => value?.trim() && value.trim() !== "(no output)"
+          ) ?? verifyResult?.outputTail;
+          boundedOutputTail = outputTail && outputTail.length > 500 ? `...${outputTail.slice(-500)}` : outputTail;
+          passed = verifyOutcome.passed && (verifyResult?.exitCode ?? 1) === 0;
+          if (!passed) {
+            failureDiagnostics = boundedFailureDiagnostics({
+              command,
+              stderrTail: verifyResult?.stderrTail,
+              stdoutTail: verifyResult?.stdoutTail,
+              outputTail: verifyResult?.outputTail
+            });
+          }
+          exitCode = verifyResult?.exitCode;
+          const unavailableSignal = !passed && diagnosticOutputTail && exitCode !== void 0 ? detectUnavailableGateCommand({
+            command,
+            output: diagnosticOutputTail,
+            exitCode,
+            complete: verifyResult?.unavailable ? void 0 : verifyResult?.complete,
+            // a launch error proves the tool missing
+            unavailableReason: verifyResult?.unavailableReason
+          }) : void 0;
+          if (unavailableSignal) {
+            results.push({
+              id: gateId,
+              command,
+              passed: false,
+              skipped: true,
+              unavailable: true,
+              durationMs,
+              exitCode,
+              outputTail: unavailableSignal.message,
+              ...this.customGateBaseline !== void 0 ? {
+                isRegression: false
+              } : {}
+            });
+            continue;
+          }
+        } else {
+          durationMs = createDurationMs(performance.now() - start);
+          results.push({
+            id: gateId,
+            command,
+            passed: false,
+            misconfigured: true,
+            durationMs,
+            outputTail: safety.error.includes("shell") || /[|&;<>()`]/u.test(command) ? "Custom gate misconfiguration: shell metacharacters are not supported. Use a verifier-safe command." : `Custom gate misconfiguration: ${safety.error.slice(-500)}`
+          });
+          continue;
+        }
+        results.push({
+          id: gateId,
+          command,
+          passed,
+          durationMs,
+          exitCode,
+          outputTail: passed ? void 0 : boundedOutputTail,
+          ...failureDiagnostics ? { diagnostics: failureDiagnostics } : {},
+          ...this.customGateBaseline !== void 0 ? {
+            isRegression: this.isCustomGateRegression(gateId, passed)
+          } : {}
+        });
+        if (!passed && this.isRunAborted()) {
+          break;
+        }
+      } catch (err) {
+        const durationMs = createDurationMs(performance.now() - start);
+        const aborted = this.isRunAborted() || err instanceof Error && (err.name === "AbortError" || /aborted|timebox exceeded/i.test(err.message));
+        results.push({
+          id: gateId,
+          command,
+          passed: false,
+          ...aborted ? { skipped: true } : {},
+          durationMs,
+          outputTail: aborted ? "Custom gate aborted: autoloop timebox exceeded." : err instanceof Error ? err.message.slice(-500) : String(err).slice(-500)
+        });
+        if (aborted) {
+          break;
+        }
+      }
+    }
+    return results;
+  }
+  isCustomGateRegression(gateId, passed) {
+    if (passed) {
+      return false;
+    }
+    if (!this.customGateBaseline) {
+      return true;
+    }
+    const baselinePassed = this.customGateBaseline.get(gateId);
+    if (baselinePassed === false) {
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Determine if a quality gate result represents a NEW regression.
+   * Compares current failure count against baseline to distinguish
+   * pre-existing failures from new failures introduced this iteration.
+   *
+   * Coverage/test also enforces suite-footprint integrity: a greener count is
+   * only non-blocking when executed/skipped footprints prove the suite did not
+   * shrink or skip more tests. Lint and security keep count-only comparison.
+   *
+   * @param result - Quality gate check result
+   * @returns true if this is a new regression, false if pre-existing or passed,
+   *   undefined when comparison is unknown (fail-closed)
+   */
+  isQualityRegression(result) {
+    if (!this.qualityBaseline || this.qualityBaseline.status !== "captured") {
+      if (result.success) return false;
+      return void 0;
+    }
+    const baselineGate = isTestEvidenceGate(result.gate) ? "coverage" : result.gate;
+    if ((baselineGate === "lint" || baselineGate === "security" || baselineGate === "coverage") && this.qualityBaseline.gateAvailability[baselineGate] !== true) {
+      if (result.success) return false;
+      return void 0;
+    }
+    const baselineFailed = {
+      lint: this.qualityBaseline.lintFailedCommands,
+      coverage: this.qualityBaseline.testFailedCommands,
+      security: this.qualityBaseline.securityFailedCommands
+    }[baselineGate];
+    if (!result.success && result.failedCommands && baselineFailed) {
+      const perCommand = compareBucketCommands(
+        baselineGate,
+        result.failedCommands,
+        baselineFailed,
+        extractFailureCountWithMethod
+      );
+      if (perCommand !== null) return perCommand;
+    }
+    const currentResult = extractFailureCountWithMethod([result], result.gate);
+    const currentFailures = currentResult.count;
+    if (isTestEvidenceGate(result.gate)) {
+      const baselineCommand = this.qualityBaseline.testEvidenceCommand;
+      if (baselineCommand && result.command && baselineCommand !== result.command) {
+        return void 0;
+      }
+      const classification = classifyCoverageBaselineComparison(
+        {
+          failures: this.qualityBaseline.testFailures,
+          suiteFootprint: this.qualityBaseline.testSuiteFootprint,
+          messages: this.qualityBaseline.testFailureMessages
+        },
+        {
+          failures: currentFailures,
+          suiteFootprint: currentResult.suiteFootprint,
+          messages: currentResult.messages
+        }
+      );
+      if (classification === "regression") {
+        return true;
+      }
+      if (classification === "improvement" || classification === "pre_existing") {
+        if ((currentFailures ?? 0) > 0) {
+          this.telemetry?.logEvent({
+            name: "quality_gate_pre_existing_failure",
+            timestamp: /* @__PURE__ */ new Date(),
+            properties: {
+              gate: result.gate,
+              currentFailures,
+              currentMethod: currentResult.method,
+              baselineFailures: this.qualityBaseline.testFailures,
+              baselineMethod: this.qualityBaseline.testFailuresMethod,
+              classification
+            }
+          });
+        }
+        return false;
+      }
+      return void 0;
+    }
+    if (result.success) {
+      return false;
+    }
+    let baselineFailures = 0;
+    let baselineMethod;
+    switch (result.gate) {
+      case "lint":
+        baselineFailures = this.qualityBaseline.lintErrors;
+        baselineMethod = this.qualityBaseline.lintErrorsMethod;
+        break;
+      case "security":
+        baselineFailures = this.qualityBaseline.securityFailures;
+        baselineMethod = this.qualityBaseline.securityFailuresMethod;
+        break;
+      default:
+        return true;
+    }
+    const unprovenSecurityCount = (method) => method === "fallback_1" || method === "unavailable_no_parser";
+    if (result.gate === "security" && (unprovenSecurityCount(currentResult.method) || unprovenSecurityCount(baselineMethod))) {
+      return true;
+    }
+    if (currentFailures === null || baselineFailures === null) {
+      return void 0;
+    }
+    const guessed = currentResult.method === "fallback_1" || baselineMethod === "fallback_1";
+    if (result.gate === "lint" && guessed) return void 0;
+    const isRegression = currentFailures > baselineFailures;
+    if (!isRegression && currentFailures > 0) {
+      this.telemetry?.logEvent({
+        name: "quality_gate_pre_existing_failure",
+        timestamp: /* @__PURE__ */ new Date(),
+        properties: {
+          gate: result.gate,
+          currentFailures,
+          currentMethod: currentResult.method,
+          baselineFailures,
+          baselineMethod
+        }
+      });
+    }
+    return isRegression;
+  }
+  /**
+   * Detect if the iteration failed due to new TypeScript compilation errors.
+   *
+   * Compilation failure is indicated by typed controller metadata, the
+   * ProgressValidator's structured insight, or a classified gate failure. Provider
+   * output text is not used for this decision.
+   *
+   * This is used to block completion when new compilation errors exist.
+   *
+   * @param result - Loop iteration result to check
+   * @returns true if compilation failure detected
+   */
+  detectCompilationFailure(result) {
+    if ((result.metadata?.compilationErrorDelta ?? 0) > 0) {
+      return true;
+    }
+    if (hasCompilationProgressSignal(result.progress?.insights)) {
+      return true;
+    }
+    return (result.qualityGates ?? []).some(
+      (gate) => classifyQualityGateFailure(gate) === "compilation"
+    );
+  }
+  /**
+   * Compute deterministic completion summary based on hard signals.
+   * Separates "done" (gates, provider, convergence) from heuristics.
+   *
+   * @param result - Current iteration result
+   * @param completionSignalDetected - Whether explicit completion signal was found
+   * @returns CompletionSummary with deterministic status
+   */
+  computeCompletionSummary(result, completionSignalDetected, isCompletionOrBounds) {
+    const semanticValidation = result.semanticValidation;
+    return evaluateCompletion({
+      result,
+      completionSignalDetected,
+      isCompletionOrBounds,
+      validationMode: this.config.validationMode,
+      runQualityGates: this.config.runQualityGates,
+      priorIterationFingerprints: this.iterationHistory.map((h) => h.iterationFingerprint),
+      priorCompletenessSignals: this.iterationHistory.map((h) => h.progress.metrics.completeness),
+      hasDurableCompletionEvidence: this.hasDurableCompletionEvidence(result),
+      semanticCompletionOk: isSemanticCompletionSatisfied(semanticValidation),
+      semanticIsErrorSkip: isSemanticErrorSkip(semanticValidation?.skipped)
+    });
+  }
+  hasSubstantiveCompletionEvidence(result) {
+    return hasSubstantiveCompletionEvidence(result, this.hasDurableCompletionEvidence(result));
+  }
+  hasDurableCompletionEvidence(result) {
+    return result.completionEvidence?.durable === true;
+  }
+  /**
+   * Get AI Judge evaluation if enabled
+   */
+  async getAIJudgeEvaluation(_iteration, _taskResult, progress) {
+    if (!this.aiJudge) return void 0;
+    try {
+      const variantResult = {
+        variant: `iteration-${_iteration}`,
+        provider: "autonomous-loop",
+        success: progress.isSignificant,
+        completeness: progress.score * 100,
+        output: typeof _taskResult === "object" ? JSON.stringify(_taskResult) : String(_taskResult),
+        duration: 0,
+        // Will be filled by iteration result
+        costMetrics: void 0
+      };
+      const remainingMs = this.ensureRemainingTimeboxMs("AI judge evaluation");
+      const deadlineMs = Date.now() + remainingMs;
+      const judgeResult = await this.aiJudge.evaluate(
+        [variantResult],
+        `Iteration ${_iteration} progress evaluation`,
+        {
+          taskId: `loop-iteration-${_iteration}`,
+          deadlineMs,
+          abortSignal: this.config.abortSignal
+        }
+      );
+      const evaluation = judgeResult.evaluations[0];
+      const recommendation = this.determineRecommendation(
+        evaluation?.qualityScore ?? progress.score * 100,
+        progress
+      );
+      const result = {
+        overallScore: evaluation?.qualityScore ?? progress.score * 100,
+        criteria: evaluation?.codeQuality ?? {
+          completeness: progress.metrics.completeness * 100
+        },
+        recommendation,
+        reasoning: judgeResult.reasoning || `Progress: ${(progress.score * 100).toFixed(1)}%`,
+        confidence: judgeResult.metadata?.confidence ?? progress.confidence
+      };
+      this.emit("ai_judge_evaluation", {
+        type: "ai_judge_evaluation",
+        evaluation: result
+      });
+      return result;
+    } catch (error) {
+      this.telemetry?.trackError(error, {
+        _iteration,
+        context: "ai_judge"
+      });
+      return void 0;
+    }
+  }
+  /**
+   * Count actual change lines in a git diff (lines starting with + or -).
+   * Excludes diff metadata lines (@@, diff, index, ---, +++).
+   */
+  countActualDiffLines(gitDiff) {
+    let count = 0;
+    for (const line of gitDiff.split("\n")) {
+      if ((line.startsWith("+") || line.startsWith("-")) && !line.startsWith("+++") && !line.startsWith("---")) {
+        count++;
+      }
+    }
+    return count;
+  }
+  /**
+   * Run semantic validation using AI-powered progress checks.
+   *
+   * This validates:
+   * 1. Progress toward goals (via semantic-progress-rater)
+   * 2. Acceptance criteria satisfaction (via acceptance-criteria-checker)
+   *
+   * Graceful degradation: If provider calls fail (auth errors, timeouts, parse errors),
+   * semantic validation is skipped with a warning rather than failing the loop (unless strictMode).
+   * Routing (provider and model) is resolved by the caller; when no override is given, checks run on the
+   * task's own engine/model, and missing provider/auth simply logs a warning and continues without
+   * validation. The CLI gates only at completion boundaries by default; the check itself is opt-in.
+   * Provider/auth warnings become hard failures only when `strictMode` is true (default false).
+   *
+   * Mode behavior:
+   * - `completion-only` (default): Only runs when `isCompletionOrBounds` is true
+   * - `every-iteration`: Runs every N iterations (controlled by runEveryNIterations)
+   *
+   * @param iteration - Current iteration number
+   * @param _outputForChecks - Provider output text for checks
+   * @param isCompletionOrBounds - True if completion signal matched or at bounds (last iteration)
+   * @returns Semantic validation result
+   */
+  async runSemanticValidation(iteration, _outputForChecks, isCompletionOrBounds) {
+    const config = this.config.semanticCheck;
+    if (!config?.enabled) {
+      return semanticDisabled();
+    }
+    const mode = config.mode ?? "completion-only";
+    if (mode === "completion-only" && !isCompletionOrBounds) {
+      return semanticSkipped("not_completion_bounds");
+    }
+    if (!config.provider) {
+      emitWarning(
+        "SEM-000",
+        {
+          taskId: "semantic-validation",
+          subsystem: "autonomous-loop-controller",
+          executionPhase: "validation"
+        },
+        {
+          severity: "WARN" /* WARN */,
+          metadata: {
+            error: "Semantic validation enabled but no provider configured; skipping",
+            iteration
+          }
+        }
+      );
+      return semanticSkipped("provider_error");
+    }
+    if (mode === "every-iteration") {
+      const runEveryN = config.runEveryNIterations ?? 1;
+      if (runEveryN > 1 && iteration % runEveryN !== 0) {
+        return semanticSkipped("iteration_skip");
+      }
+    }
+    const baseRef = this.semanticBaselineRef ?? this.config.progressConfig.baseRef ?? "HEAD~1";
+    let gitDiff;
+    try {
+      if (!isSafeGitRef(baseRef)) {
+        throw new Error(`Invalid git baseRef: "${baseRef}"`);
+      }
+      const { execFileSync } = await import("child_process");
+      gitDiff = execFileSync("git", ["diff", baseRef], {
+        cwd: this.workingDir,
+        timeout: 1e4,
+        maxBuffer: 5 * 1024 * 1024,
+        // 5MB
+        encoding: "utf-8",
+        stdio: ["ignore", "pipe", "pipe"]
+      }).trim();
+    } catch (error) {
+      this.telemetry?.logEvent({
+        name: "semantic_validation_skipped",
+        timestamp: /* @__PURE__ */ new Date(),
+        properties: {
+          iteration,
+          reason: "git_diff_failed",
+          error: error instanceof Error ? error.message : String(error)
+        }
+      });
+      return semanticSkipped("provider_error");
+    }
+    const taskText = this.config.requirementsTaskText;
+    if (!taskText) {
+      return semanticSkipped("no_task_spec");
+    }
+    gitDiff = filterSemanticValidationDiff(gitDiff, taskText).trim();
+    const minDiffLines = config.minDiffLines ?? 10;
+    const actualDiffLines = this.countActualDiffLines(gitDiff);
+    if (!isCompletionOrBounds && actualDiffLines < minDiffLines) {
+      return semanticSkipped("trivial_diff");
+    }
+    const remainingMs = this.ensureRemainingTimeboxMs("semantic validation");
+    const deadlineMs = Date.now() + remainingMs;
+    const abortSignal = this.config.abortSignal;
+    const configuredTimeoutMs = config.timeoutMs;
+    const timeoutMs = configuredTimeoutMs != null ? Math.min(configuredTimeoutMs, remainingMs) : remainingMs;
+    let progressResult;
+    try {
+      progressResult = await rateProgress(taskText, gitDiff, {
+        provider: config.provider,
+        workingDir: this.workingDir,
+        profile: config.profile,
+        model: config.model,
+        timeoutMs,
+        deadlineMs,
+        abortSignal,
+        workspaceMode: config.workspaceMode
+      });
+    } catch (error) {
+      if (config.strictMode) throw error;
+      emitWarning(
+        "SEM-001",
+        {
+          taskId: "semantic-validation",
+          subsystem: "autonomous-loop-controller",
+          executionPhase: "validation"
+        },
+        {
+          severity: "WARN" /* WARN */,
+          metadata: {
+            error: error instanceof Error ? error.message : String(error),
+            iteration,
+            operation: "rateProgress"
+          }
+        }
+      );
+      return semanticSkipped("provider_error");
+    }
+    let acResults = [];
+    let satisfactionScore = 0;
+    try {
+      acResults = await checkAcceptanceCriteria(taskText, gitDiff, {
+        provider: config.provider,
+        workingDir: this.workingDir,
+        profile: config.profile,
+        model: config.model,
+        timeoutMs,
+        deadlineMs,
+        abortSignal,
+        workspaceMode: config.workspaceMode
+      });
+      const hasAnyConfidence = acResults.some((r) => r.confidence > 0);
+      if (acResults.length > 0 && !hasAnyConfidence) {
+        emitWarning(
+          "SEM-002",
+          {
+            taskId: "semantic-validation",
+            subsystem: "autonomous-loop-controller",
+            executionPhase: "validation"
+          },
+          {
+            severity: "WARN" /* WARN */,
+            metadata: {
+              error: "All acceptance criteria checks returned zero confidence; evaluating as unsatisfied",
+              iteration,
+              operation: "checkAcceptanceCriteria"
+            }
+          }
+        );
+      }
+      if (acResults.length > 0) satisfactionScore = calculateSatisfactionScore(acResults);
+    } catch (error) {
+      if (config.strictMode) throw error;
+      emitWarning(
+        "SEM-002",
+        {
+          taskId: "semantic-validation",
+          subsystem: "autonomous-loop-controller",
+          executionPhase: "validation"
+        },
+        {
+          severity: "WARN" /* WARN */,
+          metadata: {
+            error: error instanceof Error ? error.message : String(error),
+            iteration,
+            operation: "checkAcceptanceCriteria"
+          }
+        }
+      );
+      return semanticSkipped("provider_error");
+    }
+    let passed;
+    const minProgressConfidence = this.config.progressConfig.confidenceThreshold ?? 0.7;
+    const significantProgress = isSignificantProgress(progressResult, minProgressConfidence);
+    if (acResults.length > 0) {
+      passed = significantProgress || satisfactionScore >= 0.5;
+    } else {
+      passed = significantProgress;
+    }
+    this.telemetry?.logEvent({
+      name: "semantic_validation_complete",
+      timestamp: /* @__PURE__ */ new Date(),
+      properties: {
+        iteration,
+        movedCloser: progressResult.movedCloser,
+        progressConfidence: progressResult.confidence,
+        satisfactionScore,
+        totalACs: acResults.length,
+        satisfiedACs: acResults.filter((r) => r.satisfied).length,
+        passed,
+        hasACs: acResults.length > 0
+      }
+    });
+    return {
+      enabled: true,
+      passed,
+      progressResult,
+      acResults,
+      satisfactionScore
+    };
+  }
+  /**
+   * Determine recommendation based on score and progress trends
+   */
+  determineRecommendation(score, progress) {
+    if (score >= 80 && progress.trend === "improving") return "continue";
+    if (score >= 80 && progress.trend === "stable" && !progress.isSignificant) return "terminate";
+    if (score < 40 && progress.trend === "declining") return "terminate";
+    if (progress.isSignificant) return "continue";
+    return score >= 60 ? "continue" : "pivot";
+  }
+  /**
+   * Handle a 'pivot' recommendation from determineRecommendation.
+   *
+   * Behavior depends on the BUILD_CROSS_PROVIDER_PIVOT feature flag:
+   * - 'off': No action taken
+   * - 'shadow': Emits telemetry events but does not switch provider
+   * - 'on': Switches to the next configured alternate provider
+   */
+  async handlePivotRecommendation(result) {
+    if (!this.config.enableCrossProviderPivot) return;
+    const flagMode = ORCHESTRATOR_FEATURE_FLAGS.CROSS_PROVIDER_PIVOT;
+    if (flagMode === "off") return;
+    const fromProvider = this.currentProvider ?? this.config.routingDecision?.primary.provider ?? "unknown";
+    const nextAlternate = this.availableAlternates.find(
+      (alt) => alt.provider !== this.currentProvider
+    );
+    this.emit("pivot_triggered", {
+      type: "pivot_triggered",
+      iteration: result._iteration,
+      fromProvider,
+      toProvider: nextAlternate?.provider,
+      reason: `Score ${result.judgeEvaluation?.overallScore ?? "N/A"} < 60 with insufficient progress`,
+      mode: flagMode
+    });
+    this.telemetry?.logEvent({
+      name: "cross_provider_pivot_triggered",
+      timestamp: /* @__PURE__ */ new Date(),
+      properties: {
+        iteration: result._iteration,
+        fromProvider,
+        toProvider: nextAlternate?.provider ?? null,
+        mode: flagMode,
+        score: result.judgeEvaluation?.overallScore,
+        hasAlternates: this.availableAlternates.length > 0
+      }
+    });
+    if (flagMode === "shadow") return;
+    if (nextAlternate) {
+      const previousProvider = this.currentProvider;
+      this.currentProvider = nextAlternate.provider;
+      this.currentProviderSetup = nextAlternate.setup;
+      this.availableAlternates = this.availableAlternates.filter(
+        (alt) => alt.provider !== nextAlternate.provider
+      );
+      this.emit("provider_switched", {
+        type: "provider_switched",
+        iteration: result._iteration,
+        fromProvider: previousProvider ?? "unknown",
+        toProvider: nextAlternate.provider
+      });
+      this.telemetry?.logEvent({
+        name: "cross_provider_switched",
+        timestamp: /* @__PURE__ */ new Date(),
+        properties: {
+          iteration: result._iteration,
+          fromProvider: previousProvider,
+          toProvider: nextAlternate.provider,
+          remainingAlternates: this.availableAlternates.length
+        }
+      });
+    }
+  }
+  /**
+   * Check if loop should terminate
+   */
+  async shouldTerminate(_iteration) {
+    if (this.state.status !== "running") {
+      return true;
+    }
+    const elapsed = this.getElapsedRuntimeMs();
+    if (elapsed >= this.config.timeboxMs) {
+      this.terminate("timebox_exceeded");
+      return true;
+    }
+    const resources = getResourceUsage();
+    if (resources.memory.heapUsed > this.config.resourceLimits.maxMemoryMB * 1024 * 1024) {
+      this.terminate("resource_exhaustion");
+      return true;
+    }
+    if (!this.recursionTracker.canSpawnChildren()) {
+      this.terminate("recursion_limit");
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Check if loop should continue based on progress, completion signal, and validation mode.
+   *
+   * Termination priority (first match wins):
+   * 1. Iteration failure → retry if under limit
+   * 2. Compilation failure (new TS errors) → continue (cannot complete with compilation errors)
+   * 3. Completion signal matched → terminate with 'completion_signal' (unless blocked by gates)
+   *    - Gates: quality regressions, requirements, progress (heuristic), semantic validation
+   *    - Semantic check gates completion: if enabled and fails, ignore completion signal
+   *    - At bounds + semantic fails → terminate with 'semantic_criteria_unsatisfied'
+   * 4. Bounds reached + semantic fails → terminate with 'semantic_criteria_unsatisfied'
+   * 5. Deterministic mode + all quality gates pass (or non-regressions only) → terminate
+   * 6. Heuristic mode: completion threshold / stagnation / AI Judge
+   * 7. None mode: only bounds + completion signal can stop (no stagnation detection)
+   *
+   * Baseline-aware rules:
+   * - Quality gate failures with isRegression === false (pre-existing) do NOT block completion
+   * - Only gates with isRegression === true block completion
+   *
+   * Semantic validation as gate (not parallel termination):
+   * - Semantic check is a gate on "DONE" (completion signal or bounds)
+   * - It does NOT terminate mid-loop on its own; only at completion/bounds checkpoints
+   */
+  async shouldContinue(result) {
+    if (this.state.status === "terminated") {
+      return false;
+    }
+    if (!result.success) {
+      const initialDisposition = result.failureRecovery?.recovery.disposition;
+      if (initialDisposition === "operator_stop") {
+        this.terminate("system_error");
+        return false;
+      }
+      if (this.tryIdleStopAfterRealFirstDelivery(result)) {
+        if (result.failureRecovery) {
+          result.failureRecovery = serializeDirectAutoloopFailureRecovery(
+            result.failureRecovery.failure,
+            "delivery_rescue"
+          );
+        }
+        return false;
+      }
+      if (initialDisposition === "terminal_stop") {
+        this.telemetry?.logEvent({
+          name: "autoloop_terminal_failure_stop",
+          timestamp: /* @__PURE__ */ new Date(),
+          properties: {
+            iteration: result._iteration,
+            category: result.failureRecovery?.failure.category,
+            evidenceSource: result.failureRecovery?.failure.evidenceSource
+          }
+        });
+        this.terminate("system_error");
+        return false;
+      }
+      if (this.lastIterationReturnedFailure) return true;
+      if (result.error) {
+        const signature = computeErrorSignature(result);
+        if (signature.hash === this.lastErrorSignature) {
+          this.consecutiveIdenticalCount += 1;
+        } else {
+          this.consecutiveIdenticalCount = 1;
+        }
+        this.lastErrorSignature = signature.hash;
+        if (this.consecutiveIdenticalCount >= 2) {
+          this.telemetry?.logEvent({
+            name: "autoloop_identical_error_exit",
+            timestamp: /* @__PURE__ */ new Date(),
+            properties: {
+              iteration: result._iteration,
+              signature: signature.hash,
+              components: signature.components,
+              consecutiveCount: this.consecutiveIdenticalCount
+            }
+          });
+          this.terminate("identical_error_pattern");
+          return false;
+        }
+      } else {
+        this.lastErrorSignature = null;
+        this.consecutiveIdenticalCount = 0;
+      }
+      return this.continueAfterFailureOrTerminate();
+    }
+    this.lastErrorSignature = null;
+    this.consecutiveIdenticalCount = 0;
+    const requirementsUnmet = Boolean(result.requirements?.enabled && !result.requirements.passed);
+    const hasCompilationFailure = this.detectCompilationFailure(result);
+    if (hasCompilationFailure) {
+      this.telemetry?.logEvent({
+        name: "completion_blocked_compilation_errors",
+        timestamp: /* @__PURE__ */ new Date(),
+        properties: {
+          iteration: result._iteration,
+          progressScore: result.progress.score
+        }
+      });
+      return true;
+    }
+    if (result.completionSummary?.status === "BASELINE_BLOCKED") {
+      this.telemetry?.logEvent({
+        name: "loop_terminated_baseline_blocked",
+        timestamp: /* @__PURE__ */ new Date(),
+        properties: {
+          iteration: result._iteration,
+          baselineGateCount: (result.qualityGates?.filter((gate) => !gate.passed && gate.isRegression === false).length ?? 0) + (result.customGateResults?.filter((gate) => !gate.passed && gate.isRegression === false).length ?? 0)
+        }
+      });
+      this.terminate("baseline_blocked");
+      return false;
+    }
+    if (this.tryIdleStopAfterRealFirstDelivery(result)) {
+      return false;
+    }
+    if (this.completionSignalMatched) {
+      const enabled = idleStopEnabledChecksFromConfig(this.config);
+      if (isUnconfirmableGatesOffDelivery(this.deliverySnapshot(result), enabled)) {
+        this.terminate("completion_unconfirmable");
+        return false;
+      }
+      const customGatesOk = customGatesAllowCompletion(result.customGateResults);
+      const blockingQualityGates = (result.qualityGates ?? []).filter(
+        (gate) => isBlockingQualityGateForCompletion(gate) && !(customGatesOk && isUnavailableOrSkippedQualityGate(gate))
+      );
+      if (blockingQualityGates.length > 0) {
+        this.escalatePolicy("completion_signal_gated", {
+          iteration: result._iteration,
+          gate: "quality_regression"
+        });
+        this.telemetry?.logEvent({
+          name: "completion_signal_ignored_failed_gates",
+          timestamp: /* @__PURE__ */ new Date(),
+          properties: {
+            iteration: result._iteration,
+            signalType: this.config.completionSignal?.type,
+            failingGateIds: blockingQualityGates.map((g) => g.gateId),
+            preExistingFailures: result.qualityGates?.filter((g) => !g.passed && g.isRegression === false).map((g) => g.gateId)
+          }
+        });
+        return true;
+      }
+      const blockingCustomGates = (result.customGateResults ?? []).filter(
+        isBlockingCustomGateForCompletion
+      );
+      if (blockingCustomGates.length > 0) {
+        this.escalatePolicy("completion_signal_gated", {
+          iteration: result._iteration,
+          gate: "custom_regression"
+        });
+        this.telemetry?.logEvent({
+          name: "completion_signal_ignored_failed_custom_gates",
+          timestamp: /* @__PURE__ */ new Date(),
+          properties: {
+            iteration: result._iteration,
+            signalType: this.config.completionSignal?.type,
+            failingGateIds: blockingCustomGates.map((g) => g.id),
+            preExistingFailures: result.customGateResults?.filter((g) => !g.passed && g.isRegression === false).map((g) => g.id)
+          }
+        });
+        return true;
+      }
+      const verificationEvidenceSatisfied = qualityGatesAllowCompletion(result.qualityGates) || customGatesOk;
+      if (this.config.runQualityGates && !verificationEvidenceSatisfied) {
+        if (verificationGatesUnavailableOnly({
+          qualityGates: result.qualityGates,
+          customGateResults: result.customGateResults
+        })) {
+          if (this.tryCompleteUnavailableOnlyDelivery(result)) {
+            return false;
+          }
+          this.telemetry?.logEvent({
+            name: "loop_terminated_verification_unavailable",
+            timestamp: /* @__PURE__ */ new Date(),
+            properties: {
+              iteration: result._iteration,
+              signalType: this.config.completionSignal?.type,
+              gateCount: result.qualityGates?.length ?? 0,
+              customGateCount: result.customGateResults?.length ?? 0
+            }
+          });
+          this.terminate("verification_unavailable");
+          return false;
+        }
+        this.escalatePolicy("completion_signal_gated", {
+          iteration: result._iteration,
+          gate: "quality_unverified"
+        });
+        this.telemetry?.logEvent({
+          name: "completion_signal_ignored_unverified_gates",
+          timestamp: /* @__PURE__ */ new Date(),
+          properties: {
+            iteration: result._iteration,
+            signalType: this.config.completionSignal?.type,
+            gateCount: result.qualityGates?.length ?? 0,
+            skippedGateIds: result.qualityGates?.filter((g) => g.skipped === true).map((g) => g.gateId),
+            customGateCount: result.customGateResults?.length ?? 0,
+            skippedCustomGateIds: result.customGateResults?.filter((g) => g.skipped === true).map((g) => g.id)
+          }
+        });
+        return true;
+      }
+      if (requirementsUnmet) {
+        this.escalatePolicy("completion_signal_gated", {
+          iteration: result._iteration,
+          gate: "requirements",
+          coverage: result.requirements?.coverage
+        });
+        this.telemetry?.logEvent({
+          name: "completion_signal_ignored_requirements_unmet",
+          timestamp: /* @__PURE__ */ new Date(),
+          properties: {
+            iteration: result._iteration,
+            coverage: result.requirements?.coverage,
+            blockingIssues: result.requirements?.blockingIssues?.slice(0, 5)
+          }
+        });
+        return true;
+      }
+      const hasPositiveVerificationEvidence = qualityGatesAllowCompletion(result.qualityGates) || customGatesOk;
+      if (this.config.validationMode === "heuristic" && result.progress.verificationUnavailable === true && !hasPositiveVerificationEvidence && this.config.qualityGatePolicy !== "explicitly_disabled") {
+        this.telemetry?.logEvent({
+          name: "loop_terminated_verification_unavailable",
+          timestamp: /* @__PURE__ */ new Date(),
+          properties: {
+            iteration: result._iteration,
+            signalType: this.config.completionSignal?.type,
+            reason: result.progress.verificationUnavailableReason
+          }
+        });
+        this.terminate("verification_unavailable");
+        return false;
+      }
+      const styleOnlyEvidence = hasPositiveVerificationEvidence && hasOnlyStyleVerificationEvidence(result);
+      if (this.config.validationMode === "heuristic" && (!hasPositiveVerificationEvidence || styleOnlyEvidence)) {
+        const COMPLETION_SIGNAL_MIN_SCORE = 0.3;
+        const validationUnavailable = !styleOnlyEvidence && (result.progress.toolingFailure === true || result.progress.verificationUnavailable === true);
+        const durableEvidenceCanSubstituteForTooling = validationUnavailable && this.hasDurableCompletionEvidence(result);
+        const isProgressSufficient = durableEvidenceCanSubstituteForTooling || !validationUnavailable && result.progress.trend !== "declining" && (result.progress.isSignificant || result.progress.score >= COMPLETION_SIGNAL_MIN_SCORE);
+        if (!isProgressSufficient) {
+          this.escalatePolicy("completion_signal_gated", {
+            iteration: result._iteration,
+            gate: "progress",
+            trend: result.progress.trend
+          });
+          this.telemetry?.logEvent({
+            name: "completion_signal_ignored_progress_insufficient",
+            timestamp: /* @__PURE__ */ new Date(),
+            properties: {
+              iteration: result._iteration,
+              signalType: this.config.completionSignal?.type,
+              score: result.progress.score,
+              trend: result.progress.trend,
+              isSignificant: result.progress.isSignificant,
+              minScore: COMPLETION_SIGNAL_MIN_SCORE
+            }
+          });
+          return true;
+        }
+      }
+      const hostVerifiedCompletionEvidence = result.success === true && this.hasDurableCompletionEvidence(result) && customGatesOk;
+      if (isSemanticCheckBlocking(result.semanticValidation) && !hostVerifiedCompletionEvidence) {
+        const atBounds2 = result._iteration >= this.config.maxIterations;
+        if (atBounds2) {
+          this.telemetry?.logEvent({
+            name: "loop_terminated_semantic_criteria_unsatisfied",
+            timestamp: /* @__PURE__ */ new Date(),
+            properties: {
+              iteration: result._iteration,
+              context: "completion_signal_gated_at_bounds",
+              movedCloser: result.semanticValidation?.progressResult?.movedCloser,
+              satisfactionScore: result.semanticValidation?.satisfactionScore,
+              totalACs: result.semanticValidation?.acResults?.length ?? 0,
+              satisfiedACs: result.semanticValidation?.acResults?.filter((r) => r.satisfied).length ?? 0
+            }
+          });
+          this.terminate("semantic_criteria_unsatisfied");
+          return false;
+        }
+        this.escalatePolicy("completion_signal_gated", {
+          iteration: result._iteration,
+          gate: "semantic",
+          satisfactionScore: result.semanticValidation?.satisfactionScore
+        });
+        this.telemetry?.logEvent({
+          name: "completion_signal_ignored_semantic_failed",
+          timestamp: /* @__PURE__ */ new Date(),
+          properties: {
+            iteration: result._iteration,
+            signalType: this.config.completionSignal?.type,
+            movedCloser: result.semanticValidation?.progressResult?.movedCloser,
+            satisfactionScore: result.semanticValidation?.satisfactionScore,
+            totalACs: result.semanticValidation?.acResults?.length ?? 0,
+            satisfiedACs: result.semanticValidation?.acResults?.filter((r) => r.satisfied).length ?? 0
+          }
+        });
+        return true;
+      }
+      if (!completionStatusAllowsSuccess(result.completionSummary?.status)) {
+        this.escalatePolicy("completion_signal_gated", {
+          iteration: result._iteration,
+          gate: "completion_summary",
+          status: result.completionSummary?.status
+        });
+        this.telemetry?.logEvent({
+          name: "completion_signal_ignored_incomplete_summary",
+          timestamp: /* @__PURE__ */ new Date(),
+          properties: {
+            iteration: result._iteration,
+            signalType: this.config.completionSignal?.type,
+            status: result.completionSummary?.status,
+            blockingIssues: result.completionSummary?.blockingIssues.slice(0, 5)
+          }
+        });
+        return true;
+      }
+      this.telemetry?.logEvent({
+        name: "loop_terminated_completion_signal",
+        timestamp: /* @__PURE__ */ new Date(),
+        properties: {
+          iteration: result._iteration,
+          signalType: this.config.completionSignal?.type
+        }
+      });
+      this.terminate("completion_signal");
+      return false;
+    }
+    const atBounds = result._iteration >= this.config.maxIterations;
+    if (atBounds && isSemanticCheckBlocking(result.semanticValidation)) {
+      this.telemetry?.logEvent({
+        name: "loop_terminated_semantic_criteria_unsatisfied",
+        timestamp: /* @__PURE__ */ new Date(),
+        properties: {
+          iteration: result._iteration,
+          context: "bounds_reached",
+          movedCloser: result.semanticValidation?.progressResult?.movedCloser,
+          satisfactionScore: result.semanticValidation?.satisfactionScore,
+          totalACs: result.semanticValidation?.acResults?.length ?? 0,
+          satisfiedACs: result.semanticValidation?.acResults?.filter((r) => r.satisfied).length ?? 0
+        }
+      });
+      this.terminate("semantic_criteria_unsatisfied");
+      return false;
+    }
+    const customGatesAtBoundsEvidence = customGatesAllowCompletion(result.customGateResults);
+    const qualityGatesAtBoundsBlocking = qualityGatesHaveBlockingFailure(result.qualityGates, {
+      customGatesProvideEvidence: customGatesAtBoundsEvidence
+    });
+    const qualityGatesAtBoundsOk = !this.config.runQualityGates || (qualityGatesAllowCompletion(result.qualityGates) || customGatesAtBoundsEvidence) && !qualityGatesAtBoundsBlocking;
+    const customGatesAtBoundsOk = !customGatesHaveBlockingFailure(result.customGateResults);
+    if (atBounds && this.config.validationMode !== "deterministic" && result.success === true && isSemanticCompletionSatisfied(result.semanticValidation) && this.hasSubstantiveCompletionEvidence(result) && qualityGatesAtBoundsOk && customGatesAtBoundsOk && !requirementsUnmet) {
+      this.telemetry?.logEvent({
+        name: "loop_terminated_semantic_complete",
+        timestamp: /* @__PURE__ */ new Date(),
+        properties: {
+          iteration: result._iteration,
+          movedCloser: result.semanticValidation?.progressResult?.movedCloser,
+          satisfactionScore: result.semanticValidation?.satisfactionScore,
+          totalACs: result.semanticValidation?.acResults?.length ?? 0,
+          satisfiedACs: result.semanticValidation?.acResults?.filter((r) => r.satisfied).length ?? 0
+        }
+      });
+      this.terminate("semantic_complete");
+      return false;
+    }
+    if (this.config.validationMode === "deterministic") {
+      const allGatesPassed = result.qualityGates && result.qualityGates.length > 0 && result.qualityGates.every((g) => g.passed);
+      const qualityGatesOk = qualityGatesAllowCompletion(result.qualityGates);
+      const customGatesOk = customGatesAllowCompletion(result.customGateResults);
+      const qualityGatesBlocking = qualityGatesHaveBlockingFailure(result.qualityGates, {
+        customGatesProvideEvidence: customGatesOk
+      });
+      const customGatesBlocking = customGatesHaveBlockingFailure(result.customGateResults);
+      if ((allGatesPassed || qualityGatesOk || customGatesOk) && !qualityGatesBlocking && !customGatesBlocking && !requirementsUnmet && completionStatusAllowsSuccess(result.completionSummary?.status)) {
+        this.telemetry?.logEvent({
+          name: "loop_terminated_deterministic_complete",
+          timestamp: /* @__PURE__ */ new Date(),
+          properties: {
+            iteration: result._iteration,
+            gateCount: result.qualityGates?.length,
+            customGateCount: result.customGateResults?.length,
+            allPassed: allGatesPassed,
+            preExistingFailuresOnly: !allGatesPassed && qualityGatesOk,
+            preExistingFailures: result.qualityGates?.filter((g) => !g.passed && g.isRegression === false).map((g) => g.gateId)
+          }
+        });
+        this.terminate("deterministic_complete");
+        return false;
+      }
+      return true;
+    }
+    if (this.config.validationMode === "none") {
+      if (result.judgeEvaluation?.recommendation === "terminate" && !requirementsUnmet) {
+        this.terminate("ai_judge_recommendation");
+        return false;
+      }
+      if (result.judgeEvaluation?.recommendation === "pivot") {
+        await this.handlePivotRecommendation(result);
+      }
+      return true;
+    }
+    const completionThreshold = 0.8;
+    const stableHighScore = result.progress.trend === "stable" && !result.progress.isSignificant && result.progress.score >= completionThreshold && result.progress.verificationUnavailable !== true && result.progress.toolingFailure !== true && !requirementsUnmet;
+    const completionSummary = result.completionSummary;
+    if (stableHighScore && completionSummary !== void 0 && completionStatusAllowsSuccess(completionSummary.status) && completionSummary.hasSubstantiveEvidence && completionSummary.blockingIssues.length === 0) {
+      this.telemetry?.logEvent({
+        name: "loop_terminated_heuristic_complete",
+        timestamp: /* @__PURE__ */ new Date(),
+        properties: {
+          iteration: result._iteration,
+          progressScore: result.progress.score,
+          trend: result.progress.trend
+        }
+      });
+      this.terminate("heuristic_complete");
+      return false;
+    }
+    if (!result.progress.isSignificant) {
+      const recentResults = this.iterationHistory.slice(-this.config.progressConfig.windowSize);
+      const stagnantCount = recentResults.filter((r) => !r.progress.isSignificant).length;
+      if (stagnantCount >= this.config.progressConfig.windowSize) {
+        if (result._iteration < this.config.maxIterations) {
+          this.terminate("progress_stagnation");
+          return false;
+        }
+      }
+    }
+    if (result.judgeEvaluation?.recommendation === "terminate") {
+      this.terminate("ai_judge_recommendation");
+      return false;
+    }
+    if (result.judgeEvaluation?.recommendation === "pivot") {
+      await this.handlePivotRecommendation(result);
+    }
+    return true;
+  }
+  /**
+   * After a mature delivery, stop on the next empty-diff iteration instead
+   * of burning retries. Do not stop on the successful delivery itself — that
+   * would bypass the completion-signal progress floor and semantic oracle.
+   * Baseline-only green does not qualify.
+   */
+  deliverySnapshot(result) {
+    return {
+      success: result.success,
+      iterationFingerprint: result.iterationFingerprint,
+      error: result.error,
+      qualityGates: result.qualityGates,
+      customGateResults: result.customGateResults,
+      requirements: result.requirements,
+      completionSummary: result.completionSummary,
+      semanticValidation: result.semanticValidation
+    };
+  }
+  /**
+   * A completion signal over a sound delivery whose only blocker is
+   * proven-unavailable required verification completes as delivered-unverified
+   * instead of terminating as `verification_unavailable`. Real gate failures,
+   * budget skips and unmet requirements keep their existing handling.
+   */
+  tryCompleteUnavailableOnlyDelivery(result) {
+    const disposition = resolveUnavailableOnlyDelivery(
+      this.deliverySnapshot(result),
+      idleStopEnabledChecksFromConfig(this.config)
+    );
+    if (!result.success || !disposition) {
+      return false;
+    }
+    result.earlyFinalization = {
+      reason: "delivered_unverified_verification_unavailable",
+      priorIteration: Number(result._iteration),
+      verification: "unverified",
+      disposition
+    };
+    this.telemetry?.logEvent({
+      name: "loop_completed_delivered_unverified",
+      timestamp: /* @__PURE__ */ new Date(),
+      properties: {
+        iteration: result._iteration,
+        signalType: this.config.completionSignal?.type,
+        scope: disposition.scope,
+        reason: disposition.reason
+      }
+    });
+    this.terminate("deterministic_complete");
+    return true;
+  }
+  tryIdleStopAfterRealFirstDelivery(result) {
+    const enabled = idleStopEnabledChecksFromConfig(this.config);
+    const snapshot = this.deliverySnapshot(result);
+    const prior = this.iterationHistory.filter((iteration) => iteration !== result);
+    const resolution = resolveIdleStopAfterRealFirstDelivery(prior, snapshot, enabled, {
+      iterationChangeEvidenceTrusted: this.config.iterationChangeEvidenceTrusted !== false
+    });
+    if (!resolution.shouldStop) {
+      return false;
+    }
+    this.idleStoppedAfterRealFirstDelivery = true;
+    const priorResult = prior[resolution.priorIterationIndex];
+    result.earlyFinalization = {
+      reason: "mature_delivery_followed_by_no_op",
+      priorIteration: Number(priorResult?._iteration ?? resolution.priorIterationIndex + 1),
+      verification: resolution.verification,
+      ...resolution.disposition ? { disposition: resolution.disposition } : {}
+    };
+    this.telemetry?.logEvent({
+      name: "loop_terminated_idle_after_first_delivery",
+      timestamp: /* @__PURE__ */ new Date(),
+      properties: {
+        iteration: result._iteration,
+        emptyDiffAfterDelivery: true,
+        gateCount: result.qualityGates?.length ?? 0,
+        verification: resolution.verification
+      }
+    });
+    this.terminate("deterministic_complete");
+    return true;
+  }
+  /**
+   * Decide whether a failed iteration may retry. Terminates the loop with
+   * 'max_retries_exceeded' once the backoff/retry budget is exhausted so retry
+   * exhaustion surfaces as a specific termination reason rather than a generic
+   * failure. backoffAttempts is incremented by applyBackoff() after each
+   * retry-granting failure, so this check gates the NEXT retry.
+   */
+  continueAfterFailureOrTerminate() {
+    if (this.backoffAttempts >= this.config.backoffConfig.maxRetries) {
+      this.terminate("max_retries_exceeded");
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Apply exponential backoff for failed iterations
+   */
+  async applyBackoff() {
+    if (this.isRunAborted()) {
+      this.terminate("system_error");
+      return;
+    }
+    if (this.backoffAttempts >= this.config.backoffConfig.maxRetries) {
+      this.terminate("max_retries_exceeded");
+      return;
+    }
+    const delay = calculateBackoffDelay(this.backoffAttempts, this.config.backoffConfig);
+    this.backoffAttempts++;
+    this.emit("backoff_triggered", {
+      type: "backoff_triggered",
+      delay,
+      reason: "iteration_failed"
+    });
+    await abortableDelay(delay, this.config.abortSignal);
+  }
+  /**
+   * Check resource limits and emit warnings.
+   * Near-limit warnings are memory-only; CPU/process stay diagnostic-only.
+   */
+  checkResourceLimits() {
+    const resources = getResourceUsage();
+    const memoryMB = resources.memory.heapUsed / (1024 * 1024);
+    if (memoryMB > this.config.resourceLimits.maxMemoryMB * 0.8) {
+      if (!this.resourceWarnings.has("memory")) {
+        this.resourceWarnings.add("memory");
+        this.emit("resource_warning", {
+          type: "resource_warning",
+          resource: "memory",
+          usage: memoryMB,
+          limit: this.config.resourceLimits.maxMemoryMB
+        });
+      }
+    }
+  }
+  /**
+   * Set up event forwarding to dependencies
+   */
+  setupEventForwarding() {
+    if (this.resultStreamer) {
+      this.on("iteration_complete", (data) => {
+        this.resultStreamer?.emit("iterationComplete", data);
+      });
+    }
+  }
+  /**
+   * Set up cleanup handlers
+   */
+  setupCleanupHandlers() {
+    signalCoordinator.register(this.instanceId, async () => {
+      await this.cleanup();
+    });
+    this.cleanupHandlers = [() => signalCoordinator.unregister(this.instanceId)];
+  }
+  /**
+   * Clean up resources and remove event listeners
+   */
+  close() {
+    this.cleanupHandlers.forEach((cleanup) => {
+      try {
+        cleanup();
+      } catch (_error) {
+      }
+    });
+    this.cleanupHandlers = [];
+    this.removeAllListeners();
+  }
+  /**
+   * Clean up resources
+   */
+  async cleanup() {
+    if (this.cleanupStarted) return;
+    this.cleanupStarted = true;
+    try {
+      await this.recursionTracker.exit();
+      if (this.telemetry) {
+        await this.telemetry.flush();
+      }
+      this.emit("loop_cleanup", { type: "loop_cleanup", state: this.state });
+    } catch (error) {
+      console.error("Error during cleanup:", error);
+    }
+  }
+};
+function createAutonomousLoopController(config = {}, dependencies = {}) {
+  return new AutonomousLoopController(config, dependencies);
+}
+var DEFAULT_COMPLETION_SIGNALS = [
+  "xml:<task_complete/>",
+  "xml:<TASK_COMPLETE/>",
+  "regex:task\\s+complete|task\\s+finished|all\\s+done"
+];
+function createConfigFromEnv(cliFlags = {}) {
+  const readPositiveNumber = (envName, fallback, max) => {
+    const raw = readRawEnv(envName);
+    if (raw === void 0 || raw === "") return fallback;
+    const value = Number(raw);
+    if (!Number.isFinite(value) || value <= 0) return fallback;
+    return max === void 0 ? value : Math.min(value, max);
+  };
+  const readUnitInterval = (envName, fallback) => {
+    const raw = readRawEnv(envName);
+    if (raw === void 0 || raw === "") return fallback;
+    const value = Number(raw);
+    return Number.isFinite(value) && value >= 0 && value <= 1 ? value : fallback;
+  };
+  const maxIterations = readPositiveNumber(
+    BUILD_AUTOLOOP_MAX_ITERATIONS,
+    3,
+    MAX_AUTOLOOP_ENV_ITERATIONS
+  );
+  const timeboxMs = resolveAutoloopTimeboxMs();
+  const minProgress = readUnitInterval(BUILD_AUTOLOOP_MIN_PROGRESS, 0.05);
+  const maxMemoryRaw = readRawEnv(BUILD_AUTOLOOP_MAX_MEMORY);
+  const maxMemoryMB = maxMemoryRaw === void 0 ? DEFAULT_AUTOLOOP_RESOURCE_LIMITS.maxMemoryMB : readPositiveNumber(BUILD_AUTOLOOP_MAX_MEMORY, DEFAULT_AUTOLOOP_RESOURCE_LIMITS.maxMemoryMB);
+  const cliValidation = cliFlags["--autoloop-validation"];
+  const validationMode = resolveAutoloopValidationMode(cliValidation);
+  const completionSignalRaw = validationMode === "deterministic" ? void 0 : cliFlags["--autoloop-completion-signal"] || readEnv(BUILD_AUTOLOOP_COMPLETION_SIGNAL).value;
+  let completionSignal;
+  if (completionSignalRaw) {
+    completionSignal = parseCompletionSignal(completionSignalRaw) ?? void 0;
+  } else if (validationMode !== "deterministic" && validationMode !== "none") {
+    for (const defaultSignal of DEFAULT_COMPLETION_SIGNALS) {
+      const parsed = parseCompletionSignal(defaultSignal);
+      if (parsed) {
+        completionSignal = parsed;
+        break;
+      }
+    }
+  }
+  const qualityGatesModeRaw = cliFlags["--autoloop-quality-gates-mode"] || readRawEnv(BUILD_AUTOLOOP_QUALITY_GATES_MODE);
+  const qualityGatesMode = qualityGatesModeRaw === "full" || qualityGatesModeRaw === "safe" || qualityGatesModeRaw === "fast" ? qualityGatesModeRaw : "fast";
+  return {
+    maxIterations: createIterationCount(maxIterations),
+    timeboxMs: createDurationMs(timeboxMs),
+    minProgressThreshold: createProgressScore(minProgress),
+    useAIJudge: readEnv(BUILD_AUTOLOOP_JUDGE).value === "1" || cliFlags["--autoloop-judge"] === true,
+    runQualityGates: cliFlags["--autoloop-quality-gates"] === true,
+    qualityGatesMode,
+    resourceLimits: {
+      maxMemoryMB
+    },
+    ...completionSignal ? { completionSignal } : {},
+    validationMode
+  };
+}
+var autonomous_loop_controller_default = AutonomousLoopController;
+export {
+  AutonomousLoopController,
+  COMPLETION_SIGNAL_TAIL_BYTES,
+  DEFAULT_AUTOLOOP_RESOURCE_LIMITS,
+  DEFAULT_COMPLETION_SIGNALS,
+  MAX_FIRST_ITERATION_RESERVE_MS,
+  MIN_FIRST_ITERATION_RESERVE_MS,
+  buildCustomGateId,
+  classifyCoverageBaselineComparison,
+  classifyError,
+  classifyQualityGateFailure,
+  createAutonomousLoopController,
+  createConfigFromEnv,
+  createDurationMs,
+  createIterationCount,
+  createProgressScore,
+  autonomous_loop_controller_default as default,
+  extractFailureCountWithMethod,
+  hasCompilationProgressSignal,
+  isBenignSemanticSkip,
+  isEmptyDiffIdleFailure,
+  isRealFirstDeliveryIteration,
+  isSemanticCompletionSatisfied,
+  isSemanticErrorSkip,
+  matchesCompletionSignal,
+  parseCompletionSignal,
+  resolveIdleStopAfterRealFirstDelivery,
+  selectTaskOutputForChecks,
+  semanticDisabled,
+  semanticSkipped,
+  shouldIdleStopAfterRealFirstDelivery
+};
+//# sourceMappingURL=autonomous-loop-controller-2WL363LW.js.map