@poetic-ai/poetic 1.42.0

package/dist/chunk-R7XDDX2A.js

@@ -0,0 +1,4007 @@
+import {
+  renderRepairConstraints,
+  renderUntrustedCommandOutput
+} from "./chunk-LRGMHROI.js";
+import {
+  extractExplicitVerificationCommands,
+  hasExplicitVerificationIntent
+} from "./chunk-J3UUR7DE.js";
+import {
+  evaluateStageCompletionProof,
+  hostSurfaceEvaluatorFailureProof,
+  mergeIterationRetryFeedback,
+  resolveProviderExecutionIntentFromStage,
+  resolveStageExecutionIntent,
+  stageHasHostDeterministicCompletionSurface,
+  toAutoloopCompletionEvidence
+} from "./chunk-5ZCXC23G.js";
+import {
+  collectDeclaredStageTargets
+} from "./chunk-IFCBYECK.js";
+import {
+  decideStageChangeScope
+} from "./chunk-HAC6EHZZ.js";
+import {
+  extractAcceptanceCriteria,
+  formatAcceptanceCriteriaForPrompt,
+  prepareInitialAutoloopPolicy,
+  validateRequirements
+} from "./chunk-35P3W3JX.js";
+import {
+  completionStatusAllowsSuccess,
+  isSuccessLikeControllerReason,
+  unsafeCompletionAllowsSuccess
+} from "./chunk-4IAPOG5V.js";
+import {
+  changesHaveVerifiableCodeSurface,
+  getProviderDetectionMode,
+  normalizeProviderRunDiagnostics,
+  providerDiagnosticsReportFatalRuntimeIssue,
+  resolveTokenAccounting
+} from "./chunk-M3HQYKQX.js";
+import {
+  readCostMetricsUnavailableReason
+} from "./chunk-XUXVDPSZ.js";
+import {
+  generateCompetitionId
+} from "./chunk-WIFZCHEG.js";
+import {
+  isSimpleArtifactGoalSatisfiedForChanges,
+  parseSimpleArtifactGoal
+} from "./chunk-OGMSYL6J.js";
+import {
+  getPlanningRoot,
+  withIndexRegeneration,
+  withPlanningLock
+} from "./chunk-OPYFYTWQ.js";
+import {
+  getBucketArchivePathByKind,
+  getBucketPathByKind
+} from "./chunk-HOYBYAOA.js";
+import {
+  buildProviderOutputExcerpt
+} from "./chunk-MYLH2S4G.js";
+import {
+  parseGitStatus,
+  parseGitStatusPaths
+} from "./chunk-MN6PL4AN.js";
+import {
+  shouldExcludeFile
+} from "./chunk-NS33V3IM.js";
+import {
+  listMarkdownFiles,
+  listMarkdownFilesRecursive,
+  readMarkdownFile,
+  writeMarkdownFile
+} from "./chunk-OIS7J26S.js";
+import {
+  resolveDefaultProvider
+} from "./chunk-XPU2XADL.js";
+import {
+  emitBoundaryTriggered
+} from "./chunk-PFTQBXS6.js";
+import {
+  normalizeEngineId
+} from "./chunk-SURZ2WFE.js";
+import {
+  filterWorktreeRunSentinelPaths,
+  isWorktreeRunSentinelPath
+} from "./chunk-I5WRT7ZR.js";
+import {
+  atomicWriteJson
+} from "./chunk-A3YGID55.js";
+import {
+  execGit
+} from "./chunk-KNDYMVWN.js";
+import {
+  runVerifyCommands
+} from "./chunk-LO23NABI.js";
+import {
+  resolveExecutionBoundary
+} from "./chunk-7R2WLDOS.js";
+import {
+  detectProjectCapabilities
+} from "./chunk-FHOWVDF5.js";
+import {
+  isProjectConfigPath,
+  isProjectTestPath,
+  languageForProjectPath
+} from "./chunk-UDMS5AD3.js";
+import {
+  truncateTail
+} from "./chunk-TSXGRLPR.js";
+import {
+  describeVerificationCommand,
+  detectVerificationToolUnavailable
+} from "./chunk-2QLYTVYX.js";
+import {
+  safeRmDir
+} from "./chunk-G4THLFV3.js";
+import {
+  resolvePoeticRoot
+} from "./chunk-LEIIWPWQ.js";
+
+// src/automation/flywheel-autoloop-executor.ts
+import * as fs4 from "fs/promises";
+import * as path5 from "path";
+import { performance as performance2 } from "perf_hooks";
+import chalk from "chalk";
+import { execa as execa2 } from "execa";
+
+// src/core/providers/claude/simple-artifact-tool-policy.ts
+var CLAUDE_SIMPLE_ARTIFACT_TOOLS = ["Read", "Write", "Edit", "Glob", "Grep"];
+var CLAUDE_SIMPLE_ARTIFACT_DISALLOWED_TOOLS = ["Bash"];
+function claudeSimpleArtifactToolPolicy() {
+  return {
+    allowedTools: [...CLAUDE_SIMPLE_ARTIFACT_TOOLS],
+    disallowedTools: [...CLAUDE_SIMPLE_ARTIFACT_DISALLOWED_TOOLS],
+    providerOutputSuppression: "claude-disallowed-bash"
+  };
+}
+
+// src/core/providers/simple-artifact-tool-policy.ts
+var SIMPLE_ARTIFACT_TOOL_POLICIES = {
+  claude: claudeSimpleArtifactToolPolicy
+};
+function simpleArtifactToolPolicy(provider) {
+  const factory = SIMPLE_ARTIFACT_TOOL_POLICIES[normalizeEngineId(provider)];
+  return factory ? factory() : null;
+}
+
+// src/orchestrator/autoloop-termination-map.ts
+function mapControllerReasonToFlywheel(reason) {
+  switch (reason) {
+    case "max_iterations_reached":
+    case "timebox_exceeded":
+    case "progress_stagnation":
+    case "no_op_loop":
+    case "duplicate_change_loop":
+    case "resource_exhaustion":
+      return reason;
+    case "identical_error_pattern":
+      return "progress_stagnation";
+    case "recursion_limit":
+      return "resource_exhaustion";
+    case "system_error":
+    case "ai_judge_recommendation":
+    case "max_retries_exceeded":
+      return "error";
+    case "completion_signal":
+    case "semantic_complete":
+    case "deterministic_complete":
+      return "success";
+    case "heuristic_complete":
+      return "heuristic_complete";
+    case "baseline_blocked":
+      return "baseline_blocked";
+    case "verification_unavailable":
+      return "verification_unavailable";
+    case "compilation_errors":
+      return "quality_gate_failure";
+    case "semantic_criteria_unsatisfied":
+      return "evidence_unsatisfied";
+    default: {
+      const exhaustive = reason;
+      return exhaustive;
+    }
+  }
+}
+
+// src/automation/autoloop-termination-events.ts
+function createAutoloopEventRecorder() {
+  const events = [];
+  return {
+    events,
+    emit(event) {
+      const recorded = {
+        ...event,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      events.push(recorded);
+      return recorded;
+    }
+  };
+}
+
+// src/automation/flywheel-autoloop-durability.ts
+import { createHash, randomUUID } from "crypto";
+import * as fs from "fs/promises";
+import * as path from "path";
+import { execa } from "execa";
+async function computeWorktreeFingerprint(worktreePath) {
+  try {
+    const head = await execa("git", ["rev-parse", "HEAD"], {
+      cwd: worktreePath,
+      stdio: "pipe",
+      timeout: 3e4,
+      reject: false
+    });
+    const headSha = head.stdout.trim();
+    if ((head.exitCode ?? 1) !== 0 || headSha.length === 0) return void 0;
+    const runGit = async (args) => {
+      const result = await execa("git", args, {
+        cwd: worktreePath,
+        stdio: "pipe",
+        timeout: 3e4,
+        reject: false
+      });
+      if ((result.exitCode ?? 1) !== 0) {
+        throw new Error(`git ${args[0] ?? ""} failed while fingerprinting`);
+      }
+      return result.stdout;
+    };
+    const [porcelainZ, unstagedDiff, stagedDiff] = await Promise.all([
+      // -z gives NUL-delimited entries with unquoted paths, which is robust for
+      // extracting the changed-path set used by the resume superset check.
+      runGit(["status", "--porcelain", "--untracked-files=all", "-z"]),
+      runGit(["diff", "--binary", "--no-ext-diff"]),
+      runGit(["diff", "--cached", "--binary", "--no-ext-diff"])
+    ]);
+    const changedPaths = parsePorcelainPaths(porcelainZ);
+    const digest = createHash("sha256").update("status-z\0").update(porcelainZ).update("\0unstaged\0").update(unstagedDiff.replace(/\r/g, "")).update("\0staged\0").update(stagedDiff.replace(/\r/g, ""));
+    const root = path.resolve(worktreePath);
+    for (const relativePath of changedPaths) {
+      const absolutePath = path.resolve(root, relativePath);
+      const insideRoot = absolutePath === root || !path.relative(root, absolutePath).startsWith("..") && !path.isAbsolute(path.relative(root, absolutePath));
+      if (!insideRoot) throw new Error(`Dirty path escapes worktree: ${relativePath}`);
+      digest.update("\0path\0").update(relativePath);
+      try {
+        const stat3 = await fs.lstat(absolutePath);
+        if (stat3.isSymbolicLink()) {
+          digest.update("\0symlink\0").update(await fs.readlink(absolutePath));
+        } else if (stat3.isFile()) {
+          digest.update("\0file\0").update(String(stat3.mode & 73)).update("\0");
+          digest.update(await fs.readFile(absolutePath));
+        } else {
+          throw new Error(`Unsupported dirty path type: ${relativePath}`);
+        }
+      } catch (error) {
+        if (error.code === "ENOENT") {
+          digest.update("\0missing\0");
+        } else {
+          throw error;
+        }
+      }
+    }
+    return { headSha, dirtyDigest: digest.digest("hex"), changedPaths };
+  } catch {
+    return void 0;
+  }
+}
+function parsePorcelainPaths(porcelainZ) {
+  const paths = /* @__PURE__ */ new Set();
+  const entries = porcelainZ.split("\0");
+  for (let i = 0; i < entries.length; i++) {
+    const entry = entries[i];
+    if (!entry || entry.length === 0) continue;
+    const status = entry.slice(0, 2);
+    const p = entry.length > 3 ? entry.slice(3) : entry;
+    if (p.length > 0) paths.add(p);
+    if ((status[0] === "R" || status[0] === "C") && i + 1 < entries.length) {
+      const source = entries[i + 1];
+      if (source && source.length > 0) paths.add(source);
+      i++;
+    }
+  }
+  return [...paths].sort();
+}
+function worktreeFingerprintExactlyMatches(recorded, current) {
+  return Boolean(
+    recorded && current && recorded.headSha === current.headSha && recorded.dirtyDigest === current.dirtyDigest
+  );
+}
+function worktreeFingerprintResumable(recorded, current) {
+  if (!recorded || !current) return true;
+  if (recorded.headSha !== current.headSha) return false;
+  if (recorded.dirtyDigest === current.dirtyDigest) return true;
+  if (recorded.changedPaths === void 0 || current.changedPaths === void 0) {
+    return false;
+  }
+  const currentPaths = new Set(current.changedPaths);
+  return recorded.changedPaths.every((p) => currentPaths.has(p));
+}
+function safeFilename(input) {
+  return input.replace(/[^a-zA-Z0-9-_]/g, "_");
+}
+function isValidOptionalFingerprint(value) {
+  if (value === void 0) return true;
+  if (!value || typeof value !== "object") return false;
+  const fp = value;
+  if (typeof fp.headSha !== "string" || typeof fp.dirtyDigest !== "string") return false;
+  if (fp.changedPaths !== void 0) {
+    if (!Array.isArray(fp.changedPaths)) return false;
+    if (!fp.changedPaths.every((p) => typeof p === "string")) return false;
+  }
+  return true;
+}
+function isDurableAutoloopRunRecord(input) {
+  if (!input || typeof input !== "object") return false;
+  const obj = input;
+  return obj.schemaVersion === 1 && typeof obj.recordedAt === "string" && typeof obj.workflowId === "string" && typeof obj.stageId === "string" && obj.stageType === "autoloop" && typeof obj.validationPassed === "boolean" && typeof obj.loopSuccess === "boolean" && typeof obj.terminationReason === "string" && typeof obj.totalIterations === "number" && typeof obj.finalProgressScore === "number" && typeof obj.cost === "number" && isValidOptionalFingerprint(obj.worktreeFingerprint);
+}
+function isDurableAutoloopIterationSpill(input) {
+  if (!input || typeof input !== "object") return false;
+  const obj = input;
+  return obj.schemaVersion === 1 && typeof obj.updatedAt === "string" && typeof obj.workflowId === "string" && typeof obj.stageId === "string" && typeof obj.writer === "string" && (obj.runStartedAtMs === void 0 || typeof obj.runStartedAtMs === "number" && Number.isFinite(obj.runStartedAtMs)) && isValidOptionalFingerprint(obj.worktreeFingerprint) && Array.isArray(obj.iterations);
+}
+function pickFailureFromIterations(result) {
+  const last = result.iterationHistory.at(-1);
+  if (!last) return void 0;
+  const failing = last.qualityGateCommandResults?.find((r) => r.exitCode !== 0);
+  const allowlistViolations = (last.allowlistViolations?.length ? last.allowlistViolations : void 0) ?? result.iterationHistory.find((r) => r.allowlistViolations && r.allowlistViolations.length > 0)?.allowlistViolations;
+  const allowlistRevertedFiles = (last.allowlistRevertedFiles?.length ? last.allowlistRevertedFiles : void 0) ?? result.iterationHistory.find(
+    (r) => r.allowlistRevertedFiles && r.allowlistRevertedFiles.length > 0
+  )?.allowlistRevertedFiles;
+  const changedFiles = last.changedFiles?.length ? last.changedFiles : void 0;
+  if (result.validationPassed && result.loopSuccess && !last.allowlistDrift && last.qualityGatePassed !== false) {
+    return void 0;
+  }
+  return {
+    iteration: last.iteration,
+    qualityGateError: last.qualityGateError,
+    failingCommand: failing?.command,
+    failingExitCode: failing?.exitCode,
+    outputTail: failing?.outputTail,
+    allowlistViolations,
+    allowlistRevertedFiles,
+    changedFiles
+  };
+}
+function buildDurableAutoloopRunRecord(input) {
+  const recordedAt = input.recordedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+  const failure = input.result.validationPassed ? void 0 : pickFailureFromIterations(input.result);
+  return {
+    schemaVersion: 1,
+    recordedAt,
+    workflowId: input.workflowId,
+    stageId: input.stage.id,
+    stageType: "autoloop",
+    validationPassed: input.result.validationPassed,
+    loopSuccess: input.result.loopSuccess,
+    terminationReason: input.result.terminationReason,
+    totalIterations: input.result.totalIterations,
+    finalProgressScore: input.result.finalProgressScore,
+    cost: input.result.cost,
+    outcomeMetadata: input.result.outcomeMetadata,
+    ...input.worktreeFingerprint ? { worktreeFingerprint: input.worktreeFingerprint } : {},
+    allowlist: input.stage.allowlist,
+    allowlistMode: input.stage.allowlistMode,
+    ...failure ? { failure } : {}
+  };
+}
+async function writeJsonAtomic(filePath, json) {
+  const dir = path.dirname(filePath);
+  const base = path.basename(filePath);
+  const tmpPath = path.join(dir, `${base}.tmp-${process.pid}-${Date.now()}-${randomUUID()}`);
+  await fs.mkdir(dir, { recursive: true });
+  const file = await fs.open(tmpPath, "w");
+  try {
+    await file.writeFile(JSON.stringify(json, null, 2), "utf-8");
+    await file.sync();
+  } finally {
+    await file.close().catch(() => {
+    });
+  }
+  try {
+    await fs.rename(tmpPath, filePath);
+  } catch (renameError) {
+    await fs.unlink(tmpPath).catch(() => {
+    });
+    throw renameError;
+  }
+  try {
+    const dirHandle = await fs.open(dir, "r");
+    try {
+      await dirHandle.sync();
+    } finally {
+      await dirHandle.close().catch(() => {
+      });
+    }
+  } catch {
+  }
+}
+function taskIdMatchesBasename(basename2, taskId) {
+  if (!basename2.startsWith(taskId)) return false;
+  const rest = basename2.slice(taskId.length);
+  return rest.length === 0 || /^[^a-zA-Z0-9]/.test(rest);
+}
+async function findTaskFilePath(taskId) {
+  const planningRoot = getPlanningRoot();
+  const tasksDir = getBucketPathByKind("task", planningRoot);
+  const activeFiles = await listMarkdownFiles(tasksDir).catch(() => []);
+  const active = activeFiles.find((f) => taskIdMatchesBasename(path.basename(f), taskId));
+  if (active) return active;
+  const archiveDir = getBucketArchivePathByKind("task", planningRoot);
+  const archivedFiles = await listMarkdownFilesRecursive(archiveDir).catch(() => []);
+  const archived = archivedFiles.find((f) => taskIdMatchesBasename(path.basename(f), taskId));
+  return archived ?? null;
+}
+function normalizeTaskStatus(raw) {
+  const statusRaw = typeof raw === "string" ? raw : "todo";
+  const statusMap = {
+    todo: "todo",
+    in_progress: "in_progress",
+    review: "review",
+    done: "done",
+    blocked: "blocked",
+    pending: "todo",
+    "in-progress": "in_progress",
+    completed: "done",
+    archived: "done"
+  };
+  return statusMap[statusRaw] ?? "todo";
+}
+async function persistToTaskFrontmatter(record) {
+  const planningRoot = getPlanningRoot();
+  const taskFile = await findTaskFilePath(record.stageId);
+  if (!taskFile) return;
+  await withIndexRegeneration(planningRoot, async () => {
+    const { frontMatter, body } = await readMarkdownFile(taskFile);
+    const now = record.recordedAt;
+    const currentStatus = normalizeTaskStatus(frontMatter.status);
+    const shouldBlock = record.validationPassed === false && currentStatus !== "blocked" && currentStatus !== "done";
+    const nextFrontMatter = {
+      ...frontMatter,
+      updated_at: now,
+      version: (typeof frontMatter.version === "number" ? frontMatter.version : 0) + 1,
+      lastRun: {
+        at: now,
+        workflowId: record.workflowId,
+        stageType: record.stageType,
+        terminationReason: record.terminationReason,
+        success: record.validationPassed,
+        iterations: record.totalIterations,
+        finalProgressScore: record.finalProgressScore,
+        cost: record.cost,
+        allowlistMode: record.allowlistMode
+      },
+      ...record.validationPassed === false ? {
+        lastFailure: {
+          at: now,
+          workflowId: record.workflowId,
+          terminationReason: record.terminationReason,
+          ...record.failure
+        }
+      } : {},
+      ...shouldBlock ? { status: "blocked" } : {}
+    };
+    await writeMarkdownFile(taskFile, nextFrontMatter, body);
+  });
+}
+async function persistToTelemetryState(record) {
+  const root = getPlanningRoot();
+  const stageSafe = safeFilename(record.stageId);
+  const workflowSafe = safeFilename(record.workflowId);
+  const outPath = path.join(
+    root,
+    ".poetic",
+    "telemetry",
+    "state",
+    "flywheel",
+    workflowSafe,
+    "autoloop",
+    `${stageSafe}.json`
+  );
+  await writeJsonAtomic(outPath, record);
+}
+function getIterationSpillPath(input) {
+  const root = getPlanningRoot();
+  const stageSafe = safeFilename(input.stageId);
+  const workflowSafe = safeFilename(input.workflowId);
+  return path.join(
+    root,
+    ".poetic",
+    "telemetry",
+    "state",
+    "flywheel",
+    workflowSafe,
+    "autoloop",
+    `${stageSafe}.iterations.json`
+  );
+}
+async function loadDurableAutoloopIterationSpill(input) {
+  const filePath = getIterationSpillPath(input);
+  try {
+    const raw = await fs.readFile(filePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    return isDurableAutoloopIterationSpill(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+var iterationSpillWriteLocks = /* @__PURE__ */ new Map();
+async function persistDurableAutoloopIterationSpill(input) {
+  const lockKey = `${input.workflowId}::${input.stageId}`;
+  const prior = iterationSpillWriteLocks.get(lockKey) ?? Promise.resolve();
+  const run = prior.then(async () => {
+    const existing = await loadDurableAutoloopIterationSpill({
+      workflowId: input.workflowId,
+      stageId: input.stageId
+    });
+    const iterationsByIndex = /* @__PURE__ */ new Map();
+    for (const record of existing?.iterations ?? []) {
+      iterationsByIndex.set(record.index, record);
+    }
+    iterationsByIndex.set(input.record.index, input.record);
+    const worktreeFingerprint = input.worktreeFingerprint ?? existing?.worktreeFingerprint;
+    const runStartedAtMs = input.runStartedAtMs ?? existing?.runStartedAtMs;
+    const spill = {
+      schemaVersion: 1,
+      updatedAt: new Date(input.record.timestamp).toISOString(),
+      workflowId: input.workflowId,
+      stageId: input.stageId,
+      writer: input.writer,
+      ...runStartedAtMs !== void 0 ? { runStartedAtMs } : {},
+      ...worktreeFingerprint ? { worktreeFingerprint } : {},
+      iterations: [...iterationsByIndex.values()].sort((left, right) => left.index - right.index)
+    };
+    await writeJsonAtomic(getIterationSpillPath(input), spill);
+    return spill;
+  });
+  const tail = run.catch(() => void 0);
+  iterationSpillWriteLocks.set(lockKey, tail);
+  void tail.then(() => {
+    if (iterationSpillWriteLocks.get(lockKey) === tail) {
+      iterationSpillWriteLocks.delete(lockKey);
+    }
+  });
+  return run;
+}
+async function loadDurableAutoloopDiagnostics(input) {
+  const root = getPlanningRoot();
+  const stageSafe = safeFilename(input.stageId);
+  const workflowSafe = safeFilename(input.workflowId);
+  const filePath = path.join(
+    root,
+    ".poetic",
+    "telemetry",
+    "state",
+    "flywheel",
+    workflowSafe,
+    "autoloop",
+    `${stageSafe}.json`
+  );
+  try {
+    const raw = await fs.readFile(filePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    return isDurableAutoloopRunRecord(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function priorOutcomeFromDiagnostics(diagnostics) {
+  return {
+    loopSuccess: diagnostics.loopSuccess,
+    validationPassed: diagnostics.validationPassed,
+    terminationReason: diagnostics.terminationReason,
+    finalProgressScore: diagnostics.finalProgressScore,
+    totalIterations: diagnostics.totalIterations,
+    cost: diagnostics.cost,
+    outcomeMetadata: diagnostics.outcomeMetadata,
+    failure: diagnostics.failure
+  };
+}
+async function loadDurableAutoloopResumeState(input) {
+  const current = input.worktreePath ? await computeWorktreeFingerprint(input.worktreePath) : void 0;
+  const diagnostics = await loadDurableAutoloopDiagnostics(input);
+  const diagnosticsExact = diagnostics?.stageType === "autoloop" && worktreeFingerprintExactlyMatches(diagnostics.worktreeFingerprint, current);
+  const spill = await loadDurableAutoloopIterationSpill(input);
+  if (spill !== null && spill.iterations.length > 0) {
+    const maxIndex = spill.iterations.reduce((max, r) => Math.max(max, r.index), -1);
+    const completedIterations = maxIndex + 1;
+    const diagnosticsRecordedAt = diagnostics ? Date.parse(diagnostics.recordedAt) : Number.NaN;
+    const spillUpdatedAt = Date.parse(spill.updatedAt);
+    if (diagnostics !== null && diagnosticsExact && Number.isFinite(diagnosticsRecordedAt) && Number.isFinite(spillUpdatedAt) && diagnosticsRecordedAt >= spillUpdatedAt) {
+      return {
+        completedIterations: diagnostics.totalIterations,
+        source: "diagnostics",
+        finalProgressScore: diagnostics.finalProgressScore,
+        priorOutcome: priorOutcomeFromDiagnostics(diagnostics)
+      };
+    }
+    if (input.worktreePath && !worktreeFingerprintResumable(spill.worktreeFingerprint, current)) {
+      await clearDurableAutoloopIterationSpill(input);
+      return { completedIterations: 0, source: "spill", fingerprintMismatch: true };
+    }
+    return {
+      completedIterations,
+      source: "spill",
+      ...spill.runStartedAtMs !== void 0 ? { runStartedAtMs: spill.runStartedAtMs } : {}
+    };
+  }
+  if (diagnostics !== null && diagnostics.stageType === "autoloop") {
+    if (!diagnosticsExact) {
+      return { completedIterations: 0, source: "diagnostics", fingerprintMismatch: true };
+    }
+    return {
+      completedIterations: diagnostics.totalIterations,
+      source: "diagnostics",
+      finalProgressScore: diagnostics.finalProgressScore,
+      priorOutcome: priorOutcomeFromDiagnostics(diagnostics)
+    };
+  }
+  return null;
+}
+async function clearDurableAutoloopIterationSpill(input) {
+  const filePath = getIterationSpillPath(input);
+  try {
+    await fs.unlink(filePath);
+  } catch {
+  }
+}
+async function persistDurableAutoloopDiagnostics(input) {
+  const record = buildDurableAutoloopRunRecord(input);
+  const results = await Promise.allSettled([
+    persistToTelemetryState(record),
+    persistToTaskFrontmatter(record)
+  ]);
+  const canonicalPersisted = results[0].status === "fulfilled";
+  const errors = results.map((r, idx) => ({ r, idx })).filter(({ r }) => r.status === "rejected").map(({ r, idx }) => ({
+    target: idx === 0 ? "telemetry_state" : "task_frontmatter",
+    error: r.reason
+  }));
+  if (errors.length > 0) {
+    console.warn(
+      `[flywheel-autoloop-durability] Best-effort persistence errors: ${errors.map((e) => `${e.target}: ${e.error instanceof Error ? e.error.message : String(e.error)}`).join("; ")}`
+    );
+  }
+  return { record, canonicalPersisted };
+}
+
+// src/automation/flywheel-autoloop-trajectory.ts
+import * as path2 from "path";
+var MAX_CHANGED_FILES = 200;
+var MAX_PROVIDER_OUTPUT_BYTES = 4e3;
+var MAX_OUTPUT_TAIL_BYTES = 1500;
+var MAX_POLICY_EVENTS = 100;
+function safeFilename2(input) {
+  return input.replace(/[^a-zA-Z0-9-_]/g, "_");
+}
+function tailUtf8(input, maxBytes) {
+  if (input === void 0 || input === null || input.length === 0) return void 0;
+  if (Buffer.byteLength(input, "utf8") <= maxBytes) return input;
+  const buf = Buffer.from(input, "utf8");
+  const slice = buf.subarray(buf.length - maxBytes);
+  return slice.toString("utf8");
+}
+function detectCompletionSignal(events) {
+  if (!events || events.length === 0) return false;
+  return events.some((event) => {
+    const details = event.details;
+    return details?.completionSignalDetected === true;
+  });
+}
+function semanticValidationStatusFor(record) {
+  if (record.aiValidationShortCircuited === true) return "short_circuited";
+  return "unknown";
+}
+function buildIteration(record) {
+  const failing = record.qualityGateCommandResults?.find((r) => r.exitCode !== 0);
+  const changedFiles = record.changedFiles ?? [];
+  const policyEvents = record.policyEvents;
+  return {
+    iteration: record.iteration,
+    success: record.success,
+    providerExecutionStatus: record.providerExecutionStatus,
+    providerOutputStatus: record.providerOutputStatus,
+    providerStatusDetail: record.providerStatusDetail,
+    durationMs: record.durationMs,
+    cost: record.cost,
+    changedFiles: changedFiles.slice(0, MAX_CHANGED_FILES),
+    changedFileCount: changedFiles.length,
+    progressScore: record.progressScore,
+    hadDiff: record.progressMetrics?.hadDiff,
+    wasNoOp: record.progressMetrics?.wasNoOp,
+    qualityGatePassed: record.qualityGatePassed,
+    qualityGateError: record.qualityGateError,
+    failingCommand: failing?.command,
+    failingExitCode: failing?.exitCode,
+    failingOutputTail: tailUtf8(failing?.outputTail, MAX_OUTPUT_TAIL_BYTES),
+    allowlistDrift: record.allowlistDrift,
+    allowlistViolationCount: record.allowlistViolations?.length,
+    repairAttempted: record.repairAttempted,
+    repairSuccesses: record.repairSuccesses,
+    testsCreated: record.testsCreated,
+    aiValidationShortCircuited: record.aiValidationShortCircuited,
+    completionEvidence: record.completionEvidence,
+    completionSignalDetected: detectCompletionSignal(policyEvents),
+    semanticValidationStatus: semanticValidationStatusFor(record),
+    error: record.error,
+    providerOutputExcerpt: tailUtf8(record.providerOutputText, MAX_PROVIDER_OUTPUT_BYTES)
+  };
+}
+function buildAutoloopTrajectory(input) {
+  const { result, summary } = input;
+  const iterations = (result.iterationHistory ?? []).map(buildIteration);
+  const policyEvents = result.policyEvents ? result.policyEvents.slice(-MAX_POLICY_EVENTS) : void 0;
+  const completionEvidence = iterations.slice().reverse().find((iteration) => iteration.completionEvidence !== void 0)?.completionEvidence;
+  return {
+    schemaVersion: 1,
+    runId: summary.runId,
+    taskId: summary.taskId,
+    workflowId: input.workflowId,
+    stageId: input.stage.id,
+    startedAt: summary.startedAt,
+    completedAt: summary.completedAt,
+    durationMs: summary.durationMs,
+    provider: summary.provider,
+    model: summary.model,
+    terminationReason: result.terminationReason,
+    outcome: summary.outcome,
+    success: summary.success,
+    loopSuccess: result.loopSuccess,
+    totalIterations: result.totalIterations,
+    finalProgressScore: result.finalProgressScore,
+    completionEvidence,
+    totalCost: summary.totalCost,
+    noOpIterationCount: summary.noOpIterationCount,
+    repairAttempts: summary.repairAttempts,
+    repairSuccesses: summary.repairSuccesses,
+    aiValidationShortCircuited: summary.aiValidationShortCircuited,
+    iterationHistoryArtifact: result.iterationHistoryArtifact,
+    resultArtifact: result.resultArtifact,
+    failureArtifact: result.failureArtifact,
+    iterations,
+    policyEvents
+  };
+}
+function getAutoloopTrajectoryPath(input) {
+  const root = input.projectRoot ?? getPlanningRoot();
+  return path2.join(
+    root,
+    ".poetic",
+    "telemetry",
+    "state",
+    "flywheel",
+    safeFilename2(input.workflowId),
+    "autoloop",
+    `${safeFilename2(input.stageId)}.trajectory.json`
+  );
+}
+async function persistAutoloopTrajectory(input) {
+  const trajectory = buildAutoloopTrajectory(input);
+  const workflowId = input.workflowId;
+  if (!workflowId) {
+    return { trajectory, path: null };
+  }
+  const filePath = getAutoloopTrajectoryPath({
+    workflowId,
+    stageId: input.stage.id
+  });
+  try {
+    await atomicWriteJson(filePath, trajectory);
+    return { trajectory, path: filePath };
+  } catch (err) {
+    console.warn(
+      `[flywheel-autoloop-trajectory] Persist failed: ${err instanceof Error ? err.message : String(err)}`
+    );
+    return { trajectory, path: null };
+  }
+}
+
+// src/automation/flywheel-gate-repair.ts
+import { performance } from "perf_hooks";
+
+// src/automation/repair-evidence.ts
+import * as fs2 from "fs/promises";
+import * as path3 from "path";
+function formatRepairSuppressionWarning(evidence) {
+  return `Review required: ${evidence.kind} in ${evidence.path}: ${evidence.addedLine}`;
+}
+var SUPPRESSION_PATTERNS = [
+  /\bbiome-ignore\b/i,
+  /\beslint-disable(?:-next-line|-line)?\b/i,
+  /@ts-(?:ignore|nocheck|expect-error)\b/i,
+  /#\s*noqa\b/i,
+  /#\s*nolint\b/i,
+  /\bnoinspection\b/i,
+  /\bshellcheck\s+disable\b/i,
+  /\bpragma:\s*no\s+cover\b/i,
+  /\bistanbul\s+ignore\b/i,
+  /\bc8\s+ignore\b/i,
+  /\bpytest\.mark\.(?:skip|skipif|xfail)\b/i
+];
+async function snapshotRepairSuppressions(cwd) {
+  let stdout;
+  try {
+    const diff = await execGit(["diff", "--unified=0", "--no-ext-diff", "HEAD"], {
+      cwd,
+      timeoutMs: 3e4
+    });
+    if (diff.exitCode !== 0) return void 0;
+    stdout = diff.stdout;
+  } catch {
+    return void 0;
+  }
+  const counts = /* @__PURE__ */ new Map();
+  let currentPath = "";
+  for (const line of stdout.split(/\r?\n/)) {
+    if (line.startsWith("+++ b/")) {
+      currentPath = line.slice("+++ b/".length);
+      continue;
+    }
+    if (!currentPath || !line.startsWith("+") || line.startsWith("+++")) continue;
+    const addedLine = line.slice(1).trim();
+    if (!SUPPRESSION_PATTERNS.some((pattern) => pattern.test(addedLine))) continue;
+    const key = `${currentPath}\0${addedLine}`;
+    counts.set(key, (counts.get(key) ?? 0) + 1);
+  }
+  try {
+    const untracked = await execGit(["ls-files", "--others", "--exclude-standard", "-z"], {
+      cwd,
+      timeoutMs: 3e4
+    });
+    if (untracked.exitCode !== 0) return void 0;
+    for (const relativePath of untracked.stdout.split("\0").filter(Boolean)) {
+      if (isWorktreeRunSentinelPath(relativePath) || shouldExcludeFile(relativePath)) continue;
+      const absolutePath = path3.resolve(cwd, relativePath);
+      const stat3 = await fs2.stat(absolutePath);
+      if (!stat3.isFile() || stat3.size > 1e6) continue;
+      const content = await fs2.readFile(absolutePath, "utf8");
+      for (const line of content.split(/\r?\n/)) {
+        const addedLine = line.trim();
+        if (!SUPPRESSION_PATTERNS.some((pattern) => pattern.test(addedLine))) continue;
+        const key = `${relativePath}\0${addedLine}`;
+        counts.set(key, (counts.get(key) ?? 0) + 1);
+      }
+    }
+  } catch {
+    return void 0;
+  }
+  return counts;
+}
+async function detectNewRepairSuppressions(cwd, before) {
+  if (!before) return [];
+  const after = await snapshotRepairSuppressions(cwd);
+  if (!after) return [];
+  const evidence = [];
+  for (const [key, count] of after) {
+    const added = count - (before.get(key) ?? 0);
+    if (added <= 0) continue;
+    const [path6, addedLine] = key.split("\0");
+    for (let i = 0; i < added; i++) {
+      evidence.push({
+        kind: "new_suppression_directive",
+        path: path6 ?? "",
+        addedLine: addedLine ?? "",
+        reviewRequired: true
+      });
+    }
+  }
+  return evidence;
+}
+
+// src/automation/repair-scope-enforcement.ts
+import * as fs3 from "fs/promises";
+import * as path4 from "path";
+
+// src/core/project/verification-control-paths.ts
+var SOURCE_LIKE_VERIFICATION_CONTROLS = /* @__PURE__ */ new Set(["build.rs", "conftest.py"]);
+function isVerificationControlPath(filePath) {
+  const normalized = filePath.replaceAll("\\", "/").replace(/^\.\//, "").toLowerCase();
+  const basename2 = normalized.slice(normalized.lastIndexOf("/") + 1);
+  return isProjectConfigPath(filePath) || SOURCE_LIKE_VERIFICATION_CONTROLS.has(basename2);
+}
+function isAutomaticRepairProtectedPath(filePath) {
+  return isProjectTestPath(filePath) || isVerificationControlPath(filePath);
+}
+
+// src/automation/repair-scope-enforcement.ts
+var LITERAL_PATHSPEC_ENV = { GIT_LITERAL_PATHSPECS: "1" };
+function isRelevantRepairPath(filePath) {
+  return !isWorktreeRunSentinelPath(filePath) && !shouldExcludeFile(filePath);
+}
+async function detectRepairScopeEvidence(worktreePath) {
+  const status = await execGit(["status", "--porcelain=v1", "--untracked-files=all"], {
+    cwd: worktreePath,
+    timeoutMs: 3e4
+  });
+  if (status.exitCode !== 0) {
+    throw new Error("Automatic repair scope status is unavailable");
+  }
+  const changedFiles = /* @__PURE__ */ new Set();
+  const linkedEndpoints = /* @__PURE__ */ new Map();
+  for (const entry of parseGitStatus(status.stdout)) {
+    if (isRelevantRepairPath(entry.path)) changedFiles.add(entry.path);
+    if (entry.originalPath && isRelevantRepairPath(entry.originalPath)) {
+      changedFiles.add(entry.originalPath);
+      if (isRelevantRepairPath(entry.path)) {
+        linkedEndpoints.set(entry.originalPath, entry.path);
+        linkedEndpoints.set(entry.path, entry.originalPath);
+      }
+    }
+  }
+  return {
+    changedFiles: [...changedFiles].sort((a, b) => a.localeCompare(b)),
+    linkedEndpoints
+  };
+}
+async function snapshotPath(worktreePath, relativePath) {
+  const absolutePath = path4.resolve(worktreePath, relativePath);
+  let worktree;
+  try {
+    const stat3 = await fs3.lstat(absolutePath);
+    if (stat3.isSymbolicLink()) {
+      worktree = { kind: "symlink", target: await fs3.readlink(absolutePath) };
+    } else if (stat3.isFile()) {
+      worktree = {
+        kind: "file",
+        contents: await fs3.readFile(absolutePath),
+        executable: (stat3.mode & 73) !== 0
+      };
+    } else {
+      throw new Error(`Unsupported repair snapshot path type: ${relativePath}`);
+    }
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+    worktree = { kind: "missing" };
+  }
+  const indexResult = await execGit(["ls-files", "--stage", "--", relativePath], {
+    cwd: worktreePath,
+    timeoutMs: 3e4,
+    env: LITERAL_PATHSPEC_ENV
+  });
+  const match = /^(\d+)\s+([0-9a-f]+)\s+0\t/.exec(indexResult.stdout);
+  return {
+    worktree,
+    ...indexResult.exitCode === 0 && match?.[1] && match[2] ? { index: { mode: match[1], blob: match[2] } } : {}
+  };
+}
+async function captureAutomaticRepairScopeBaseline(worktreePath) {
+  const evidence = await detectRepairScopeEvidence(worktreePath);
+  const entries = /* @__PURE__ */ new Map();
+  for (const relativePath of evidence.changedFiles) {
+    entries.set(relativePath, await snapshotPath(worktreePath, relativePath));
+  }
+  return { entries };
+}
+async function pathMatchesSnapshot(worktreePath, relativePath, snapshot) {
+  const current = await snapshotPath(worktreePath, relativePath);
+  if (current.index?.mode !== snapshot.index?.mode || current.index?.blob !== snapshot.index?.blob) {
+    return false;
+  }
+  if (current.worktree.kind !== snapshot.worktree.kind) return false;
+  if (current.worktree.kind === "missing") return true;
+  if (current.worktree.kind === "symlink" && snapshot.worktree.kind === "symlink") {
+    return current.worktree.target === snapshot.worktree.target;
+  }
+  if (current.worktree.kind === "file" && snapshot.worktree.kind === "file") {
+    return current.worktree.executable === snapshot.worktree.executable && current.worktree.contents.equals(snapshot.worktree.contents);
+  }
+  return false;
+}
+async function restoreSnapshotPath(worktreePath, relativePath, snapshot) {
+  const removeRepairPath = async (absolutePath2) => {
+    try {
+      await fs3.lstat(absolutePath2);
+    } catch (error) {
+      if (error.code === "ENOENT") return;
+      throw error;
+    }
+    const removal = await safeRmDir(absolutePath2, {
+      managedRoots: [worktreePath],
+      protectedPaths: [worktreePath]
+    });
+    if (!removal.deleted) {
+      throw new Error(removal.reason ?? `Refusing to remove repair path ${absolutePath2}`);
+    }
+  };
+  if (!snapshot) {
+    const checkout = await execGit(["checkout", "HEAD", "--", relativePath], {
+      cwd: worktreePath,
+      timeoutMs: 3e4,
+      env: LITERAL_PATHSPEC_ENV
+    }).catch(() => void 0);
+    if (checkout?.exitCode === 0) return;
+    await execGit(["update-index", "--force-remove", "--", relativePath], {
+      cwd: worktreePath,
+      timeoutMs: 3e4,
+      env: LITERAL_PATHSPEC_ENV
+    }).catch(() => void 0);
+    await removeRepairPath(path4.resolve(worktreePath, relativePath));
+    return;
+  }
+  const absolutePath = path4.resolve(worktreePath, relativePath);
+  if (snapshot.worktree.kind === "missing") {
+    await removeRepairPath(absolutePath);
+  } else {
+    await fs3.mkdir(path4.dirname(absolutePath), { recursive: true });
+    await removeRepairPath(absolutePath);
+    if (snapshot.worktree.kind === "symlink") {
+      await fs3.symlink(snapshot.worktree.target, absolutePath);
+    } else {
+      await fs3.writeFile(absolutePath, snapshot.worktree.contents, {
+        mode: snapshot.worktree.executable ? 493 : 420
+      });
+    }
+  }
+  if (snapshot.index) {
+    await execGit(
+      [
+        "update-index",
+        "--add",
+        "--cacheinfo",
+        snapshot.index.mode,
+        snapshot.index.blob,
+        relativePath
+      ],
+      { cwd: worktreePath, timeoutMs: 3e4, env: LITERAL_PATHSPEC_ENV }
+    );
+  } else {
+    await execGit(["update-index", "--force-remove", "--", relativePath], {
+      cwd: worktreePath,
+      timeoutMs: 3e4,
+      env: LITERAL_PATHSPEC_ENV
+    });
+  }
+}
+function decideAutomaticRepairScope(changedFiles, explicitScope) {
+  const protectedPaths = changedFiles.filter(isAutomaticRepairProtectedPath);
+  return decideStageChangeScope({
+    changedPaths: changedFiles,
+    explicitScope,
+    allowlistMode: explicitScope.length > 0 ? "strict" : "off",
+    denylistPolicy: {
+      denylist: protectedPaths,
+      mode: "strict",
+      allow: explicitScope
+    },
+    mutationOrigin: "provider"
+  });
+}
+async function changedSinceBaseline(worktreePath, baseline) {
+  const current = await detectRepairScopeEvidence(worktreePath);
+  const candidates = /* @__PURE__ */ new Set([...baseline.entries.keys(), ...current.changedFiles]);
+  const changed = [];
+  for (const relativePath of candidates) {
+    const prior = baseline.entries.get(relativePath);
+    if (!prior || !await pathMatchesSnapshot(worktreePath, relativePath, prior)) {
+      changed.push(relativePath);
+    }
+  }
+  return {
+    changedFiles: changed.sort((a, b) => a.localeCompare(b)),
+    linkedEndpoints: current.linkedEndpoints
+  };
+}
+async function enforceAutomaticRepairScope(input) {
+  const explicitScope = [...input.explicitScope ?? []];
+  const repairEvidence = await changedSinceBaseline(input.worktreePath, input.baseline);
+  const decision = decideAutomaticRepairScope(repairEvidence.changedFiles, explicitScope);
+  const violationSet = /* @__PURE__ */ new Set([
+    .../* @__PURE__ */ new Set([...decision.allowlistViolations, ...decision.denylistViolations])
+  ]);
+  for (const violation of [...violationSet]) {
+    const counterpart = repairEvidence.linkedEndpoints.get(violation);
+    if (counterpart) violationSet.add(counterpart);
+  }
+  const violations = [...violationSet].sort((a, b) => a.localeCompare(b));
+  for (const relativePath of violations) {
+    await restoreSnapshotPath(
+      input.worktreePath,
+      relativePath,
+      input.baseline.entries.get(relativePath)
+    );
+  }
+  const residualEvidence = await changedSinceBaseline(input.worktreePath, input.baseline);
+  const residual = decideAutomaticRepairScope(residualEvidence.changedFiles, explicitScope);
+  const residualViolations = [
+    .../* @__PURE__ */ new Set([...residual.allowlistViolations, ...residual.denylistViolations])
+  ];
+  return {
+    changedFiles: residualEvidence.changedFiles,
+    violations,
+    revertedFiles: violations,
+    ...residualViolations.length > 0 ? { error: `Automatic repair scope violation: ${residualViolations.join(", ")}` } : {}
+  };
+}
+
+// src/automation/flywheel-gate-repair.ts
+function normalizeGates(gates) {
+  return gates.map((gate, index) => {
+    if (typeof gate === "string") {
+      return {
+        id: `gate-${index + 1}`,
+        command: gate,
+        deterministic: true,
+        severity: "error",
+        mustPass: true
+      };
+    }
+    const severity = gate.severity ?? "error";
+    return {
+      ...gate,
+      deterministic: gate.deterministic ?? true,
+      severity,
+      mustPass: gate.mustPass ?? severity !== "warn"
+    };
+  });
+}
+async function enforceAllowlistAfterEdit(input) {
+  const result = await enforceAutomaticRepairScope({
+    worktreePath: input.worktreePath,
+    baseline: input.baseline,
+    explicitScope: input.allowlist
+  });
+  return {
+    changedFiles: result.changedFiles,
+    violations: result.violations,
+    autoRevertedFiles: result.revertedFiles,
+    error: result.error
+  };
+}
+var DEFAULT_GATE_COMMAND_TIMEOUT_MS = 10 * 6e4;
+async function runGate(gate, cwd, options = {}) {
+  const start = performance.now();
+  const envTimeoutMsRaw = Number(process.env.POETIC_GATE_COMMAND_TIMEOUT_MS);
+  const envTimeoutMs = Number.isFinite(envTimeoutMsRaw) && envTimeoutMsRaw > 0 ? envTimeoutMsRaw : void 0;
+  try {
+    const result = await runVerifyCommands({
+      cwd,
+      commands: [gate.command],
+      commandProvenance: "candidate-gate-config",
+      timeoutMs: gate.timeoutMs ?? envTimeoutMs ?? DEFAULT_GATE_COMMAND_TIMEOUT_MS,
+      signal: options.abortSignal
+    });
+    const commandResult = result.results[0];
+    const durationMs = performance.now() - start;
+    const exitCode = commandResult?.exitCode ?? 1;
+    const expectedExitCode = gate.expectedExitCode ?? 0;
+    return {
+      gate,
+      passed: exitCode === expectedExitCode,
+      exitCode,
+      durationMs,
+      outputTail: result.combinedOutput ? truncateTail(result.combinedOutput, 4e3) : commandResult?.outputTail
+    };
+  } catch (error) {
+    const durationMs = performance.now() - start;
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      gate,
+      passed: false,
+      exitCode: 124,
+      durationMs,
+      outputTail: truncateTail(message, 4e3)
+    };
+  }
+}
+async function runAllGates(gates, cwd, options = {}) {
+  const results = [];
+  for (const gate of gates) {
+    const result = await runGate(gate, cwd, { abortSignal: options.abortSignal });
+    if (!result.passed && gate.mustPass && options.baselineCwd) {
+      const baselineResult = await runGate(gate, options.baselineCwd, {
+        abortSignal: options.abortSignal
+      });
+      result.baselinePassed = baselineResult.passed;
+      result.isRegression = baselineResult.passed;
+    }
+    results.push(result);
+    if (!result.passed && gate.mustPass && result.isRegression !== false) {
+      break;
+    }
+  }
+  const allMustPassPassed = results.every((r) => r.passed || !r.gate.mustPass);
+  const regressionsPassed = results.every(
+    (r) => r.passed || !r.gate.mustPass || r.isRegression === false
+  );
+  return {
+    passed: allMustPassPassed,
+    regressionsPassed,
+    results
+  };
+}
+function buildRepairPrompt(opts) {
+  const { failedGate, gateResult, changedFiles, repairConfig } = opts;
+  const template = repairConfig?.promptTemplate || `The following quality gate is failing:
+
+Command: ${failedGate.command}
+Exit Code: ${gateResult.exitCode}
+Expected: ${failedGate.expectedExitCode ?? 0}
+
+Output (last 4000 chars):
+${renderUntrustedCommandOutput(gateResult.outputTail)}
+
+Changed Files:
+${changedFiles.length > 0 ? changedFiles.map((f) => `- ${f}`).join("\n") : "(none)"}
+
+Please make the MINIMUM changes required to make this gate pass. Fix the underlying cause of the specific issue reported by the gate command.`;
+  return `${template}
+
+${renderRepairConstraints()}`;
+}
+async function attemptGateRepair(opts) {
+  const start = performance.now();
+  const {
+    failedGate,
+    gateResult,
+    allGates,
+    worktreePath,
+    changedFiles,
+    executor,
+    provider,
+    model,
+    attemptNumber,
+    allowlist,
+    allowlistMode,
+    baselineCwd,
+    abortSignal,
+    timeoutMs
+  } = opts;
+  const repairConfig = failedGate.repair;
+  const repairScopeBaseline = await captureAutomaticRepairScopeBaseline(worktreePath);
+  const suppressionBaseline = await snapshotRepairSuppressions(worktreePath);
+  if (repairConfig?.preCommands) {
+    for (const cmd of repairConfig.preCommands) {
+      await runVerifyCommands({
+        cwd: worktreePath,
+        commands: [cmd],
+        commandProvenance: "repair-config",
+        signal: abortSignal
+      });
+    }
+  }
+  const repairPrompt = buildRepairPrompt({
+    failedGate,
+    gateResult,
+    changedFiles,
+    repairConfig
+  });
+  let providerError;
+  let providerCost = 0;
+  let providerCostUnavailableReason;
+  let providerInputTokens;
+  let providerOutputTokens;
+  let tokenUsageSource;
+  try {
+    const variantConfig = {
+      provider,
+      model,
+      strategy: "conservative",
+      executionMode: "local",
+      isBasicCompetition: true,
+      workflowWorktreePath: worktreePath,
+      disableAutoCommit: true,
+      structuredFileTargets: allowlist ?? [],
+      ...typeof timeoutMs === "number" && timeoutMs > 0 ? { timeoutMs } : {}
+    };
+    const result = await executor.executeVariant(
+      generateCompetitionId(),
+      variantConfig,
+      repairPrompt,
+      { abortSignal }
+    );
+    providerCostUnavailableReason = readCostMetricsUnavailableReason(result.costMetrics);
+    const reportedCost = result.costMetrics?.totalCost;
+    if (providerCostUnavailableReason === void 0 && typeof reportedCost === "number" && Number.isFinite(reportedCost)) {
+      providerCost = reportedCost;
+    }
+    providerInputTokens = result.costMetrics?.inputTokens;
+    providerOutputTokens = result.costMetrics?.outputTokens;
+    tokenUsageSource = result.costMetrics?.tokenUsageSource;
+    providerError = result.success ? void 0 : result.error?.message ?? "Repair provider failed";
+  } catch (error) {
+    providerError = error instanceof Error ? error.message : String(error);
+  }
+  if (repairConfig?.postCommands) {
+    for (const cmd of repairConfig.postCommands) {
+      await runVerifyCommands({
+        cwd: worktreePath,
+        commands: [cmd],
+        commandProvenance: "repair-config",
+        signal: abortSignal
+      });
+    }
+  }
+  const allowlistState = await enforceAllowlistAfterEdit({
+    worktreePath,
+    baseline: repairScopeBaseline,
+    allowlist,
+    allowlistMode: allowlistMode ?? "warn"
+  });
+  const reviewRequiredEvidence = await detectNewRepairSuppressions(
+    worktreePath,
+    suppressionBaseline
+  );
+  if (allowlistState.error) {
+    const durationMs2 = performance.now() - start;
+    const combinedError = [providerError, allowlistState.error].filter((value) => Boolean(value)).join("\n");
+    return {
+      success: false,
+      attemptNumber,
+      cost: providerCost,
+      costUnavailableReason: providerCostUnavailableReason,
+      inputTokens: providerInputTokens,
+      outputTokens: providerOutputTokens,
+      tokenUsageSource,
+      durationMs: durationMs2,
+      gatesPassedAfterRepair: false,
+      gateResults: [],
+      providerError: combinedError,
+      allowlistState,
+      abortFurtherRepairs: true
+    };
+  }
+  const gateCheck = await runAllGates(allGates, worktreePath, {
+    baselineCwd,
+    abortSignal
+  });
+  const durationMs = performance.now() - start;
+  return {
+    success: !providerError && gateCheck.regressionsPassed,
+    attemptNumber,
+    cost: providerCost,
+    costUnavailableReason: providerCostUnavailableReason,
+    inputTokens: providerInputTokens,
+    outputTokens: providerOutputTokens,
+    tokenUsageSource,
+    durationMs,
+    gatesPassedAfterRepair: gateCheck.passed,
+    gateResults: gateCheck.results,
+    providerError,
+    allowlistState,
+    ...reviewRequiredEvidence.length > 0 ? { reviewRequiredEvidence } : {}
+  };
+}
+function shouldAttemptRepair(gate) {
+  if (!gate.mustPass) return false;
+  if (!gate.deterministic) return false;
+  if (gate.repair === void 0) return false;
+  return true;
+}
+function getMaxRepairAttempts(gate) {
+  return gate.repair?.maxAttempts ?? 2;
+}
+
+// src/automation/flywheel-provider-defaults.ts
+function resolveFlywheelProvider(provider, cwd = process.cwd()) {
+  const explicitProvider = provider?.trim();
+  return resolveDefaultProvider(
+    explicitProvider && explicitProvider.length > 0 ? { provider: explicitProvider } : void 0,
+    cwd
+  ).value;
+}
+function resolveFlywheelStageProvider(stage, cwd = process.cwd()) {
+  return resolveFlywheelProvider(stage.provider, cwd);
+}
+
+// src/automation/flywheel-autoloop-executor.ts
+var FLYWHEEL_AUTOLOOP_CONTROLLER_RESOURCE_LIMITS = {
+  maxMemoryMB: 1048576,
+  maxCpuPercent: 1e3,
+  maxProcesses: Number.MAX_SAFE_INTEGER
+};
+var LITERAL_PATHSPEC_ENV2 = { GIT_LITERAL_PATHSPECS: "1" };
+var AutoloopTerminationError = class extends Error {
+  terminationSignal;
+  constructor(message, terminationSignal) {
+    super(message);
+    this.name = "AutoloopTerminationError";
+    this.terminationSignal = terminationSignal;
+  }
+};
+function policyForTerminationReason(reason) {
+  if (reason === "max_iterations_reached") return "max_iterations";
+  if (reason === "timebox_exceeded") return "timebox";
+  if (reason === "quality_gate_failure" || reason === "baseline_blocked" || reason === "allowlist_violation" || reason === "tests_required_not_met") {
+    return "quality_gate";
+  }
+  if (reason === "resource_exhaustion") return "resource_limit";
+  if (reason === "progress_stagnation") return "provider_pivot";
+  if (reason === "success" || reason === "heuristic_complete") return "success";
+  return "goal_gate";
+}
+function mapQualityGateCommandResultsToCustomGateResults(commandResults, toDurationMs) {
+  if (!commandResults || commandResults.length === 0) {
+    return [];
+  }
+  return commandResults.filter((r) => r.mustPass !== false).map((r, idx) => {
+    const expectedExitCode = r.expectedExitCode ?? 0;
+    const passed = typeof r.passed === "boolean" ? r.passed : r.exitCode === expectedExitCode;
+    const mapped = {
+      id: r.id && r.id.length > 0 ? r.id : `gate-${idx + 1}`,
+      command: r.command,
+      passed,
+      durationMs: toDurationMs(Math.max(0, Number.isFinite(r.durationMs) ? r.durationMs : 0)),
+      exitCode: r.exitCode
+    };
+    if (r.outputTail !== void 0) {
+      mapped.outputTail = r.outputTail;
+    }
+    if (r.isRegression !== void 0) {
+      mapped.isRegression = r.isRegression;
+    }
+    return mapped;
+  });
+}
+var MIN_GATE_REPAIR_TIMEOUT_MS = 3e4;
+var DEFAULT_TEST_FILE_PATTERNS = [
+  "**/*.test.ts",
+  "**/*.spec.ts",
+  "tests/**/*.ts",
+  "__tests__/**/*.ts"
+];
+var TEST_FILE_PATTERNS_BY_LANGUAGE = {
+  node: DEFAULT_TEST_FILE_PATTERNS,
+  typescript: DEFAULT_TEST_FILE_PATTERNS,
+  javascript: ["**/*.test.js", "**/*.spec.js", "tests/**/*.js", "__tests__/**/*.js"],
+  python: ["test_*.py", "*_test.py", "tests/**/*.py"],
+  go: ["*_test.go"],
+  rust: ["tests/**/*.rs", "#[test] functions in src/**/*.rs"],
+  java: ["**/*Test.java", "**/*Tests.java", "src/test/**/*.java"],
+  dotnet: ["**/*Tests.cs", "**/*Test.cs"],
+  swift: ["**/*Tests.swift", "Tests/**/*.swift"],
+  kotlin: ["**/*Test.kt", "**/*Tests.kt", "src/test/**/*.kt"],
+  dart: ["*_test.dart", "test/**/*_test.dart"],
+  ruby: ["*_test.rb", "*_spec.rb", "spec/**/*_spec.rb", "test/**/*_test.rb"],
+  php: ["*Test.php", "tests/**/*Test.php"],
+  c: ["*_test.c", "tests/**/*.c"],
+  cpp: ["*_test.cc", "*_test.cpp", "tests/**/*.cc", "tests/**/*.cpp"],
+  shell: ["*_test.sh", "tests/**/*.bats"],
+  powershell: ["*.Tests.ps1"],
+  r: ["tests/testthat/test-*.R"]
+};
+function selectDisplayTestFilePatterns(language, configuredPatterns) {
+  if (configuredPatterns && configuredPatterns.length > 0) {
+    return configuredPatterns;
+  }
+  if (!language) return null;
+  return TEST_FILE_PATTERNS_BY_LANGUAGE[language] ?? null;
+}
+function selectPrimaryPromptLanguage(languages) {
+  const concrete = languages.filter(
+    (language) => language !== "docs" && language !== "unknown" && language !== "node"
+  );
+  if (concrete.length === 1) return concrete[0] ?? null;
+  if (concrete.length > 1) {
+    const nonJs = concrete.filter(
+      (language) => language !== "typescript" && language !== "javascript"
+    );
+    if (nonJs.length === 0) {
+      return concrete.includes("typescript") ? "typescript" : "javascript";
+    }
+    return null;
+  }
+  if (languages.includes("node")) {
+    return "typescript";
+  }
+  return null;
+}
+function renderTestRequirementBody(language, configuredPatterns) {
+  const patterns = selectDisplayTestFilePatterns(language, configuredPatterns);
+  if (patterns && patterns.length > 0) {
+    return `Expected patterns:
+${patterns.map((p) => `- ${p}`).join("\n")}`;
+  }
+  return "Follow the existing test conventions of the target project (match the naming, directory layout, and framework already used for tests in this repository).";
+}
+function isCreatedTargetTestFile(filePath) {
+  if (!isProjectTestPath(filePath)) return false;
+  const language = languageForProjectPath(filePath);
+  return language !== null && language !== "docs";
+}
+async function detectTestFiles(changedFiles, patterns) {
+  if (patterns && patterns.length > 0) {
+    const minimatchModule = await import("minimatch");
+    const minimatch = typeof minimatchModule.minimatch === "function" ? minimatchModule.minimatch : typeof minimatchModule.default === "function" ? minimatchModule.default : void 0;
+    if (!minimatch) {
+      throw new Error("Failed to load minimatch for test file detection");
+    }
+    return changedFiles.filter((file) => patterns.some((pattern) => minimatch(file, pattern)));
+  }
+  return changedFiles.filter((file) => isCreatedTargetTestFile(file));
+}
+function verifyRuntimeEvidence(input) {
+  if (!input.config) {
+    return { passed: true, blockingIssues: [] };
+  }
+  if (input.config.requireAcceptanceCriteria !== true) {
+    return { passed: true, blockingIssues: [] };
+  }
+  const validation = validateRequirements({
+    requirementsTaskText: input.basePrompt,
+    providerOutputText: input.providerOutputText,
+    workingDir: input.worktreePath,
+    changedFiles: input.changedFiles,
+    testVerification: input.testVerification,
+    config: {
+      mode: "on",
+      minCoverage: input.config.minCoverage ?? 0.9,
+      requireEvidence: input.config.requireEvidence ?? true,
+      blockNewRepoRootMarkdown: input.config.blockNewRepoRootMarkdown ?? true
+    }
+  });
+  return {
+    passed: validation.passed,
+    blockingIssues: validation.blockingIssues,
+    validation
+  };
+}
+var AUTOLOOP_TERMINATION_REASON_SET = /* @__PURE__ */ new Set([
+  "max_iterations_reached",
+  "timebox_exceeded",
+  "progress_stagnation",
+  "no_op_loop",
+  "duplicate_change_loop",
+  "resource_exhaustion",
+  "quality_gate_failure",
+  "allowlist_violation",
+  "tests_required_not_met",
+  "evidence_unsatisfied",
+  "verification_unavailable",
+  "no_op_intervention_exceeded",
+  "goal_satisfied",
+  "heuristic_complete",
+  "baseline_blocked",
+  "success",
+  "error"
+]);
+function coerceAutoloopTerminationReason(reason) {
+  return AUTOLOOP_TERMINATION_REASON_SET.has(reason) ? reason : "max_iterations_reached";
+}
+function reconstructExhaustedAutoloopOutcome(input) {
+  const successCompatibleReasons = /* @__PURE__ */ new Set([
+    "success",
+    "goal_satisfied",
+    "heuristic_complete",
+    "max_iterations_reached"
+  ]);
+  if (!input.priorOutcome) {
+    return {
+      terminationReason: "max_iterations_reached",
+      loopSuccess: false,
+      finalProgressScore: input.finalProgressScore ?? 0,
+      evidenceComplete: false
+    };
+  }
+  if (input.priorOutcome.loopSuccess !== true) {
+    return {
+      terminationReason: coerceAutoloopTerminationReason(input.priorOutcome.terminationReason),
+      loopSuccess: false,
+      finalProgressScore: input.priorOutcome.finalProgressScore,
+      evidenceComplete: true
+    };
+  }
+  if (input.priorOutcome.validationPassed !== true || !successCompatibleReasons.has(input.priorOutcome.terminationReason)) {
+    return {
+      terminationReason: coerceAutoloopTerminationReason(input.priorOutcome.terminationReason),
+      loopSuccess: false,
+      finalProgressScore: input.priorOutcome.finalProgressScore,
+      evidenceComplete: false
+    };
+  }
+  return {
+    terminationReason: coerceAutoloopTerminationReason(input.priorOutcome.terminationReason),
+    loopSuccess: true,
+    finalProgressScore: input.priorOutcome.finalProgressScore,
+    evidenceComplete: true
+  };
+}
+var GATE_TYPE_ORDER = {
+  lint: 0,
+  typecheck: 1,
+  unit: 2,
+  integration: 3,
+  build: 4,
+  other: 5
+};
+function classifyGateType(command) {
+  const descriptor = describeVerificationCommand(command);
+  if (descriptor.kind === "lint" || descriptor.kind === "typecheck" || descriptor.kind === "build") {
+    return descriptor.kind;
+  }
+  if (descriptor.kind === "test") {
+    return /\b(?:integration|e2e|playwright|cypress)\b/i.test(command) ? "integration" : "unit";
+  }
+  return "other";
+}
+function classifyAutoloopGateTypeForTest(command) {
+  return classifyGateType(command);
+}
+function orderGatesByType(gates) {
+  return [...gates].sort((a, b) => {
+    const orderA = GATE_TYPE_ORDER[classifyGateType(a.command)];
+    const orderB = GATE_TYPE_ORDER[classifyGateType(b.command)];
+    return orderA !== orderB ? orderA - orderB : gates.indexOf(a) - gates.indexOf(b);
+  });
+}
+async function resolveGatePreset(input) {
+  const { configuredPreset, escalation, changedFiles, repairAttempts, failedGateIds } = input;
+  const basePreset = configuredPreset ?? "fast";
+  if (!escalation || basePreset === "full") {
+    return { preset: basePreset };
+  }
+  const reasons = [];
+  if (escalation.escalationPaths && escalation.escalationPaths.length > 0 && changedFiles.length > 0) {
+    try {
+      const minimatchModule = await import("minimatch");
+      const minimatch = typeof minimatchModule.minimatch === "function" ? minimatchModule.minimatch : typeof minimatchModule.default === "function" ? minimatchModule.default : void 0;
+      if (minimatch) {
+        const escalationPatterns = escalation.escalationPaths;
+        const matchedFile = changedFiles.find(
+          (file) => escalationPatterns.some((pattern) => minimatch(file, pattern))
+        );
+        if (matchedFile) {
+          reasons.push(`path match: ${matchedFile}`);
+        }
+      }
+    } catch {
+    }
+  }
+  const repairThreshold = escalation.escalationRepairThreshold ?? 2;
+  if (repairAttempts >= repairThreshold) {
+    reasons.push(`repair attempts (${repairAttempts}) >= threshold (${repairThreshold})`);
+  }
+  if (escalation.baselineRegressionGateIds && escalation.baselineRegressionGateIds.length > 0) {
+    const baselineRegressionGateIds = escalation.baselineRegressionGateIds;
+    const regressionMatch = failedGateIds.find((id) => baselineRegressionGateIds.includes(id));
+    if (regressionMatch) {
+      reasons.push(`baseline regression gate failed: ${regressionMatch}`);
+    }
+  }
+  if (escalation.escalateOnTestChanges === true && changedFiles.length > 0) {
+    const testFile = changedFiles.find((file) => isCreatedTargetTestFile(file));
+    if (testFile) {
+      reasons.push(`test file changed: ${testFile}`);
+    }
+  }
+  if (reasons.length > 0) {
+    return { preset: "full", escalationReason: reasons.join(", ") };
+  }
+  return { preset: basePreset };
+}
+function filterGatesByPreset(gates, preset) {
+  if (preset === "full") return gates;
+  return gates.filter((gate) => {
+    const gateType = classifyGateType(gate.command);
+    if (preset === "fast") {
+      return gateType === "lint" || gateType === "typecheck";
+    }
+    return gateType === "lint" || gateType === "typecheck" || gateType === "unit";
+  });
+}
+var ZERO_TIME_METRICS = {
+  totalProviderMs: 0,
+  totalGateMs: 0,
+  totalRepairMs: 0,
+  totalTestMs: 0,
+  totalBuildMs: 0,
+  totalOverheadMs: 0,
+  avgIterationMs: 0,
+  noOpIterationCount: 0,
+  providerTimePct: 0,
+  deterministicTimePct: 0
+};
+function buildAutoloopRunSummary(ctx, result, options) {
+  const timeMetrics = result.aggregateTimeMetrics ?? ZERO_TIME_METRICS;
+  return {
+    runId: options.runId,
+    taskId: ctx.workflowId ?? ctx.stage.id,
+    stageId: ctx.stage.id,
+    startedAt: options.startedAt,
+    completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    durationMs: result.durationMs ?? 0,
+    totalIterations: result.totalIterations,
+    terminationReason: result.terminationReason,
+    finalProgressScore: result.finalProgressScore,
+    success: result.loopSuccess,
+    outcome: result.outcomeMetadata?.outcome ?? "red",
+    terminationClass: result.outcomeMetadata?.terminationClass,
+    totalCost: result.cost ?? 0,
+    costUnavailableReason: result.costUnavailableReason,
+    timeMetrics,
+    provider: resolveFlywheelStageProvider(ctx.stage, ctx.worktreePath),
+    model: ctx.stage.model,
+    gatePreset: options.gatePreset,
+    noOpIterationCount: options.noOpIterationCount,
+    repairAttempts: options.repairAttempts,
+    repairSuccesses: options.repairSuccesses,
+    aiValidationShortCircuited: options.aiValidationShortCircuited,
+    policyEvents: result.policyEvents
+  };
+}
+function firstCostUnavailableReason(records) {
+  return records.find((record) => record.costUnavailableReason)?.costUnavailableReason;
+}
+function formatAutoloopIterationCost(record) {
+  if (record.costUnavailableReason === "provider_not_reported") {
+    return "cost not reported";
+  }
+  if (record.costUnavailableReason === "pricing_unavailable") {
+    return "cost unavailable";
+  }
+  return `$${record.cost.toFixed(4)}`;
+}
+async function finalizeAutoloopRun(ctx, result, summary, options = {}) {
+  const now = Date.now();
+  const writer = `flywheel-autoloop:${ctx.stage.id}`;
+  const updateHistoryPersistenceBestEffort = async (history) => {
+    if (!ctx.stateManager || !ctx.workflowId) {
+      return;
+    }
+    try {
+      const state = await ctx.stateManager.load(ctx.workflowId);
+      const current = state.autoloopFinal;
+      if (!current) {
+        return;
+      }
+      await ctx.stateManager.recordAutoloopFinal(
+        ctx.workflowId,
+        {
+          ...current,
+          persistence: {
+            ...current.persistence,
+            history
+          }
+        },
+        writer
+      );
+    } catch (err) {
+      console.warn(
+        `[Autoloop] State persistence update failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  };
+  if (ctx.stateManager && ctx.workflowId) {
+    const marker = {
+      completedAt: now,
+      terminationReason: result.terminationReason,
+      success: result.loopSuccess,
+      totalIterations: result.totalIterations,
+      summary,
+      persistence: {
+        history: {
+          written: false,
+          lastAttemptAt: now,
+          lastError: void 0
+        }
+      }
+    };
+    try {
+      await ctx.stateManager.recordAutoloopFinal(ctx.workflowId, marker, writer);
+    } catch (err) {
+      console.warn(
+        `[Autoloop] State persistence failed (canonical summary not written): ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  try {
+    const projectRoot = resolvePoeticRoot(ctx.worktreePath);
+    const historyPath = path5.join(projectRoot, ".poetic", "telemetry", "autoloop-history.jsonl");
+    await withPlanningLock(projectRoot, async () => {
+      await fs4.mkdir(path5.dirname(historyPath), { recursive: true });
+      await fs4.appendFile(historyPath, `${JSON.stringify(summary)}
+`, "utf8");
+    });
+    await updateHistoryPersistenceBestEffort({
+      written: true,
+      lastAttemptAt: now,
+      lastError: void 0
+    });
+  } catch (err) {
+    const errorMsg = err instanceof Error ? err.message : String(err);
+    console.warn(`[Autoloop] History persistence failed: ${errorMsg}`);
+    await updateHistoryPersistenceBestEffort({
+      written: false,
+      lastAttemptAt: now,
+      lastError: errorMsg
+    });
+  }
+  try {
+    await persistAutoloopTrajectory({
+      workflowId: ctx.workflowId,
+      stage: ctx.stage,
+      result,
+      summary
+    });
+  } catch (err) {
+    console.warn(
+      `[Autoloop] Trajectory persistence failed: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  let diagnosticsPersisted = options.preserveDurableDiagnostics === true;
+  if (ctx.workflowId && !options.preserveDurableDiagnostics) {
+    try {
+      const worktreeFingerprint = await computeWorktreeFingerprint(ctx.worktreePath);
+      const { canonicalPersisted } = await persistDurableAutoloopDiagnostics({
+        workflowId: ctx.workflowId,
+        stage: ctx.stage,
+        result,
+        worktreeFingerprint
+      });
+      diagnosticsPersisted = canonicalPersisted;
+    } catch (err) {
+      console.warn(
+        `[Autoloop] Durable diagnostics persistence failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  if (ctx.workflowId && diagnosticsPersisted) {
+    await clearDurableAutoloopIterationSpill({
+      workflowId: ctx.workflowId,
+      stageId: ctx.stage.id
+    });
+  }
+}
+async function computeEvidencePlanFromPrompt(input) {
+  const [{ DomainAnalyzer }, { resolveEvidencePlan }] = await Promise.all([
+    import("./domain-analyzer-AWF3RP6E.js"),
+    import("./evidence-plan-resolver-GBSYSAPX.js")
+  ]);
+  const analyzer = new DomainAnalyzer();
+  const analysis = await analyzer.analyze(input.prompt);
+  return resolveEvidencePlan(analysis, input.prompt, input.cwd);
+}
+function buildRecoveryPrompt(input) {
+  const { config, iteration, lastDurationMs, consecutiveNoOps } = input;
+  if (config.recoveryPromptTemplate) {
+    return config.recoveryPromptTemplate.replace("{iteration}", String(iteration)).replace("{lastDuration}", String(Math.round(lastDurationMs / 1e3))).replace("{consecutiveCount}", String(consecutiveNoOps));
+  }
+  return `
+## Recovery Notice
+
+This is iteration ${iteration}. The previous ${consecutiveNoOps} iteration(s) made no changes to the codebase.
+
+Please take a different approach:
+1. Review the task requirements carefully
+2. Consider if you're blocked by something not mentioned
+3. Try a minimal first step to verify you can make changes
+4. If truly stuck, emit the completion signal with a note about what's blocking progress
+
+Last iteration took ${Math.round(lastDurationMs / 1e3)}s without producing any file changes.
+`.trim();
+}
+function isAutoloopStage(stage) {
+  return stage.type === "autoloop";
+}
+function resolveAutoloopWorkspaceMode(provider, executionIntent) {
+  if (executionIntent !== "code" && executionIntent !== "mixed") return void 0;
+  const detection = getProviderDetectionMode(provider);
+  if (!detection.emitsJsonl) return void 0;
+  return "enhanced";
+}
+async function detectNonEmptyEditsJsonl(worktreePath) {
+  try {
+    const stat3 = await fs4.stat(path5.join(worktreePath, ".poetic", "edits.jsonl"));
+    if (!stat3.isFile()) return null;
+    if (stat3.size <= 0) return null;
+    return { bytes: stat3.size };
+  } catch {
+    return null;
+  }
+}
+async function executeAutoloopStage(ctx) {
+  const startTime = performance2.now();
+  const invocationStartedAtMs = Date.now();
+  let result;
+  let runSummary;
+  let executionError;
+  const iterationHistory = [];
+  const policyRecorder = createAutoloopEventRecorder();
+  let runStartedAtMsForSummary = invocationStartedAtMs;
+  let previousIterationCountForResult = 0;
+  let resumedFromTerminalDiagnostics = false;
+  let priorTerminalCostForResult;
+  const repairReviewWarnings = /* @__PURE__ */ new Set();
+  let iterationHistoryArtifactPersisted = false;
+  let resultArtifactPersisted = false;
+  let failureArtifactPersisted = false;
+  const pendingIterationRecords = [];
+  const iterationFingerprints = /* @__PURE__ */ new Map();
+  try {
+    const config = ctx.stage.autoloop ?? {};
+    const repairScopeBaseline = ctx.stage.automaticRepair === true ? ctx.repairScopeBaseline ?? await captureAutomaticRepairScopeBaseline(ctx.worktreePath) : void 0;
+    let promptLanguage = null;
+    try {
+      promptLanguage = selectPrimaryPromptLanguage(
+        detectProjectCapabilities(ctx.worktreePath).languages
+      );
+    } catch {
+      promptLanguage = null;
+    }
+    const {
+      AutonomousLoopController,
+      createDurationMs,
+      createIterationCount,
+      createProgressScore,
+      matchesCompletionSignal,
+      parseCompletionSignal
+    } = await import("./autonomous-loop-controller-PW4XVFGQ.js");
+    const log = (msg) => {
+      if (ctx.verbose) console.log(chalk.gray(`    [${ctx.stage.id}] ${msg}`));
+    };
+    const maxIterations = config.maxIterations ?? 3;
+    const { resolveAutoloopTimeboxMs, DEFAULT_AUTOLOOP_VALIDATION_MODE } = await import("./autoloop-run-defaults-FERGRZGP.js");
+    const timeboxMs = resolveAutoloopTimeboxMs(config.timeboxMs);
+    const minProgress = config.minProgress ?? 0.05;
+    const validationMode = config.validationMode === "heuristic" || config.validationMode === "none" || config.validationMode === "deterministic" ? config.validationMode : DEFAULT_AUTOLOOP_VALIDATION_MODE;
+    const iterationTimeboxMs = config.iterationTimeboxMs;
+    const requireEarlyDiff = config.requireEarlyDiff ?? true;
+    let completionSignal = validationMode === "deterministic" ? null : typeof config.completionSignal === "string" && config.completionSignal.length > 0 ? parseCompletionSignal(config.completionSignal) : null;
+    let completionSignalXmlTag = completionSignal?.type === "xml" ? completionSignal.tag : void 0;
+    const backoffMaxRetries = (() => {
+      const raw = config.backoffMaxRetries;
+      if (raw === void 0) return 0;
+      const n = Number(raw);
+      if (!Number.isFinite(n)) return 0;
+      return Math.max(0, Math.floor(n));
+    })();
+    let rawGateCommands = [];
+    let evidencePlanUsed = false;
+    let validationSourceExplanation = "";
+    const explicitValidationConfigured = Array.isArray(config.gates) && config.gates.length > 0 || Array.isArray(config.qualityGateCommands) && config.qualityGateCommands.length > 0 || config.stopOnQualityGate === true;
+    const simpleArtifactGoal = parseSimpleArtifactGoal(ctx.stage.prompt ?? "");
+    const explicitVerificationCommands = extractExplicitVerificationCommands(
+      ctx.stage.prompt ?? ""
+    );
+    const explicitVerificationIntent = hasExplicitVerificationIntent(ctx.stage.prompt ?? "") || explicitVerificationCommands.length > 0;
+    const shouldSuppressInferredGatesForSimpleArtifact = simpleArtifactGoal !== void 0 && !explicitValidationConfigured && !explicitVerificationIntent;
+    const shouldComputeEvidencePlan = !explicitValidationConfigured && !shouldSuppressInferredGatesForSimpleArtifact;
+    let evidencePlan = ctx.evidencePlan;
+    if (!evidencePlan && shouldComputeEvidencePlan) {
+      try {
+        const basePrompt = ctx.stage.prompt ?? "";
+        if (basePrompt.trim().length > 0) {
+          evidencePlan = await computeEvidencePlanFromPrompt({
+            prompt: basePrompt,
+            cwd: ctx.worktreePath
+          });
+        }
+      } catch (err) {
+        if (ctx.verbose) {
+          log(
+            `Evidence plan unavailable (skipping): ${err instanceof Error ? err.message : String(err)}`
+          );
+        }
+      }
+    }
+    if (Array.isArray(config.gates) && config.gates.length > 0) {
+      validationSourceExplanation = "explicit autoloop.gates config";
+    } else if (Array.isArray(config.qualityGateCommands) && config.qualityGateCommands.length > 0) {
+      rawGateCommands = config.qualityGateCommands;
+      validationSourceExplanation = "explicit autoloop.qualityGateCommands config";
+    } else if (config.stopOnQualityGate === true) {
+      rawGateCommands = ctx.stage.verify?.commands ?? [];
+      validationSourceExplanation = "stage verify.commands";
+    } else if (explicitVerificationCommands.length > 0) {
+      rawGateCommands = explicitVerificationCommands;
+      validationSourceExplanation = "explicit verification commands from prompt";
+    } else if (evidencePlan && !shouldSuppressInferredGatesForSimpleArtifact) {
+      rawGateCommands = evidencePlan.surfaces.flatMap((surface) => surface.commands);
+      evidencePlanUsed = true;
+      validationSourceExplanation = `evidence plan (${evidencePlan.surfaces.length} surface(s))`;
+      if (ctx.verbose) {
+        log(
+          `Using validation surface from evidence plan (${evidencePlan.surfaces.length} surface(s))`
+        );
+        for (const surface of evidencePlan.surfaces) {
+          log(`  - ${surface.description} (source: ${surface.source})`);
+          if (surface.rationale && surface.rationale.length > 0) {
+            for (const reason of surface.rationale) {
+              log(`    \u2022 ${reason}`);
+            }
+          }
+        }
+        if (evidencePlan.isFallback) {
+          log("Evidence plan is fallback (minimal safe checks)");
+        }
+      }
+    }
+    const shouldDefaultGateOrdering = (!Array.isArray(config.qualityGateCommands) || config.qualityGateCommands.length === 0) && (!Array.isArray(config.gates) || config.gates.length === 0) && !evidencePlanUsed;
+    const gatesFromConfig = Array.isArray(config.gates) && config.gates.length > 0 ? normalizeGates(config.gates) : null;
+    const rawGatesFromCommands = rawGateCommands.length > 0 ? normalizeGates(rawGateCommands) : [];
+    const defaultGatesFromCommands = shouldDefaultGateOrdering && rawGatesFromCommands.length > 1 ? orderGatesByType(rawGatesFromCommands) : rawGatesFromCommands;
+    const gatesConfigured = (gatesFromConfig ?? defaultGatesFromCommands).map(
+      (g, idx) => ({
+        ...g,
+        id: g.id || `gate-${idx + 1}`,
+        repair: g.repair ?? (g.deterministic !== false && g.mustPass !== false ? { maxAttempts: 2 } : void 0)
+      })
+    );
+    const qualityGatePolicy = config.qualityGatePolicy ?? "deterministic";
+    const { gatesToRun, filteredGates } = qualityGatePolicy === "deterministic" ? filterDeterministicGates(gatesConfigured) : { gatesToRun: gatesConfigured, filteredGates: [] };
+    const gatesEnabled = gatesToRun.length > 0;
+    const durableResumeState = ctx.workflowId !== void 0 ? await loadDurableAutoloopResumeState({
+      workflowId: ctx.workflowId,
+      stageId: ctx.stage.id,
+      // Verify the worktree still holds the prior iterations' work before
+      // trusting the count; on mismatch this resets to 0 (re-run from
+      // scratch) rather than silently under-iterating against a fresh tree.
+      worktreePath: ctx.worktreePath
+    }) : null;
+    if (durableResumeState?.fingerprintMismatch) {
+      log(
+        "Warning: prior autoloop state does not match the current worktree (HEAD or working-tree changes differ); re-running from iteration 0."
+      );
+    }
+    const previousIterationCount = durableResumeState?.completedIterations ?? 0;
+    previousIterationCountForResult = previousIterationCount;
+    const remainingIterations = Math.max(0, maxIterations - previousIterationCount);
+    const hasTerminalDurableOutcome = durableResumeState?.source === "diagnostics" && durableResumeState.priorOutcome !== void 0;
+    resumedFromTerminalDiagnostics = hasTerminalDurableOutcome;
+    priorTerminalCostForResult = durableResumeState?.priorOutcome?.cost;
+    const wallClockRunStartMs = durableResumeState?.runStartedAtMs ?? invocationStartedAtMs;
+    runStartedAtMsForSummary = wallClockRunStartMs;
+    const elapsedLoopMs = () => Math.max(0, Date.now() - wallClockRunStartMs, performance2.now() - startTime);
+    log(
+      `Starting autoloop (maxIterations: ${maxIterations}, timeboxMs: ${timeboxMs}, previousIterations: ${previousIterationCount})`
+    );
+    if (validationSourceExplanation && ctx.verbose) {
+      log(`Validation source: ${validationSourceExplanation}`);
+    }
+    {
+      const provider = resolveFlywheelStageProvider(ctx.stage, ctx.worktreePath);
+      const executionIntent = resolveStageExecutionIntent(ctx.stage);
+      const detection = getProviderDetectionMode(provider);
+      if (executionIntent === "edit") {
+        log(
+          detection.emitsJsonl ? `Workspace mode: enhanced (provider '${provider}' supports JSONL edit contract)` : `Workspace mode: passthrough (provider '${provider}' is git-only; JSONL protocol disabled)`
+        );
+      }
+    }
+    if (typeof config.completionSignal === "string" && config.completionSignal.length > 0) {
+      if (validationMode === "deterministic") {
+        log("Completion signal ignored in deterministic mode");
+      } else if (!completionSignal) {
+        log(`Invalid completionSignal: ${config.completionSignal}`);
+      } else {
+        log(`Completion signal enabled (${completionSignal.type})`);
+      }
+    }
+    if (validationMode !== "heuristic") {
+      log(`Validation mode: ${validationMode}`);
+    }
+    if (gatesEnabled && filteredGates.length > 0) {
+      log(
+        `Filtered ${filteredGates.length} non-deterministic gate(s) (policy: ${qualityGatePolicy})`
+      );
+      if (ctx.verbose) {
+        for (const g of filteredGates.slice(0, 6)) log(`  - ${g.command}`);
+        if (filteredGates.length > 6) log(`  ... and ${filteredGates.length - 6} more`);
+      }
+    }
+    if (Array.isArray(config.qualityGateCommands) && config.qualityGateCommands.length > 0 || config.stopOnQualityGate === true || Array.isArray(config.gates) && config.gates.length > 0) {
+      if (!gatesEnabled) {
+        log(
+          "Quality gates enabled but no deterministic gates were available; check autoloop.gates/qualityGateCommands and policy."
+        );
+      }
+    }
+    if (validationMode !== "deterministic" && config.completionOnQualityGatePass === true && !completionSignal) {
+      const { createAutoloopCompletionToken } = await import("./autoloop-helpers-2KTK43GL.js");
+      const generated = createAutoloopCompletionToken({});
+      completionSignal = parseCompletionSignal(generated.completionSignal);
+      completionSignalXmlTag = completionSignal?.type === "xml" ? completionSignal.tag : void 0;
+      log(
+        `completionOnQualityGatePass: auto-generated completion signal (${completionSignalXmlTag ?? "none"})`
+      );
+    }
+    const dynamicGates = [];
+    let totalTokens = 0;
+    let finalProgressScore = 0;
+    const configuredGatePreset = config.gatePreset;
+    const gateEscalation = config.gateEscalation;
+    const noOpIntervention = config.noOpIntervention;
+    let consecutiveNoOps = 0;
+    let interventionActive = false;
+    let lastIterationDurationMs = 0;
+    let totalRepairAttemptsForEscalation = 0;
+    const failedGateIdsForEscalation = [];
+    let currentGatePreset = configuredGatePreset ?? "fast";
+    let aiValidationShortCircuited = false;
+    const gateCommandsForPrompt = () => [...gatesToRun, ...dynamicGates].map((g) => g.command);
+    const loopController = new AutonomousLoopController({
+      maxIterations: createIterationCount(Math.max(1, remainingIterations)),
+      timeboxMs: createDurationMs(timeboxMs),
+      minProgressThreshold: createProgressScore(minProgress),
+      validationMode,
+      ...completionSignal ? { completionSignal } : {},
+      requirementsTaskText: ctx.stage.prompt ?? "",
+      requirements: {
+        mode: "auto",
+        minCoverage: 1,
+        requireEvidence: true,
+        blockNewRepoRootMarkdown: true
+      },
+      wallClockRunStartMs,
+      resourceLimits: FLYWHEEL_AUTOLOOP_CONTROLLER_RESOURCE_LIMITS,
+      // Flywheel runs quality gates in this executor so we can:
+      // - use stage-specific commands (matching verify)
+      // - feed failures back into subsequent iteration prompts
+      runQualityGates: false,
+      backoffConfig: {
+        initialDelayMs: createDurationMs(0),
+        maxDelayMs: createDurationMs(0),
+        multiplier: 1,
+        maxRetries: backoffMaxRetries
+      },
+      progressConfig: {
+        windowSize: 3,
+        trendThreshold: 0.01,
+        confidenceThreshold: 0.7,
+        // Compare working tree against the stage HEAD so uncommitted changes count as progress.
+        baseRef: "HEAD"
+      }
+    });
+    loopController.setWorkingDir(ctx.worktreePath);
+    const flywheelInitialPolicy = prepareInitialAutoloopPolicy({
+      taskText: ctx.stage.prompt ?? "",
+      userProvidedValidationMode: validationMode,
+      userProvidedAIJudge: false
+    });
+    loopController.setInitialPolicyLevel(flywheelInitialPolicy.level);
+    let terminationReason = "success";
+    let loopSuccess = false;
+    let runtimeEvidenceCheck;
+    if (ctx.workflowId && ctx.stateManager) {
+      const writer = `flywheel-autoloop:${ctx.stage.id}`;
+      loopController.on("iteration_complete", (payload) => {
+        pendingIterationRecords.push(
+          (async () => {
+            const result2 = payload?.result;
+            const iteration = typeof result2?._iteration === "number" ? result2._iteration : void 0;
+            const score = typeof result2?.progress?.score === "number" ? result2.progress.score : void 0;
+            if (iteration === void 0) return;
+            const recordIdx = Math.max(0, iteration - 1);
+            const durableIdx = previousIterationCount + recordIdx;
+            const local = iterationHistory[recordIdx];
+            if (local && score !== void 0) {
+              local.progressScore = score;
+            }
+            const success = local ? local.success : typeof result2?.success === "boolean" ? result2.success : true;
+            const durationMs2 = local ? local.durationMs : typeof result2?.duration === "number" ? result2.duration : 0;
+            if (ctx.stateManager && ctx.workflowId) {
+              const iterationRecord = {
+                index: durableIdx,
+                success,
+                duration: Math.max(0, Math.round(durationMs2)),
+                timestamp: Date.now(),
+                ...score !== void 0 ? { score } : {}
+              };
+              let spillWritten = false;
+              try {
+                const worktreeFingerprint = iterationFingerprints.get(iteration);
+                await persistDurableAutoloopIterationSpill({
+                  workflowId: ctx.workflowId,
+                  stageId: ctx.stage.id,
+                  writer,
+                  record: iterationRecord,
+                  worktreeFingerprint,
+                  runStartedAtMs: wallClockRunStartMs
+                });
+                spillWritten = true;
+              } catch (spillError) {
+                console.warn(
+                  `[flywheel-autoloop] iteration spill persistence failed for ${ctx.stage.id} (iteration ${durableIdx}): ${spillError instanceof Error ? spillError.message : String(spillError)}`
+                );
+              }
+              try {
+                await ctx.stateManager.recordIteration(ctx.workflowId, iterationRecord, writer);
+              } catch (error) {
+                if (spillWritten) {
+                  console.warn(
+                    `[flywheel-autoloop] recordIteration failed for ${ctx.stage.id} (iteration ${durableIdx}; durable spill already written): ${error instanceof Error ? error.message : String(error)}`
+                  );
+                } else {
+                  console.warn(
+                    `[flywheel-autoloop] recordIteration failed for ${ctx.stage.id} (iteration ${durableIdx}) AND durable spill was NOT written \u2014 this iteration is not durably recorded in either store and may be lost on resume: ${error instanceof Error ? error.message : String(error)}`
+                  );
+                }
+              }
+            }
+          })()
+        );
+      });
+    }
+    let previousIterationWorktreeFingerprint;
+    try {
+      previousIterationWorktreeFingerprint = await computeWorktreeFingerprint(ctx.worktreePath);
+    } catch {
+      previousIterationWorktreeFingerprint = void 0;
+    }
+    const captureIterationFingerprint = async (iteration) => {
+      try {
+        const current = await computeWorktreeFingerprint(ctx.worktreePath);
+        iterationFingerprints.set(iteration, current);
+        const prior = previousIterationWorktreeFingerprint;
+        previousIterationWorktreeFingerprint = current;
+        if (!prior || !current) return void 0;
+        if (prior.headSha === current.headSha && prior.dirtyDigest === current.dirtyDigest) {
+          return "";
+        }
+        return `${current.headSha}:${current.dirtyDigest}`;
+      } catch {
+        iterationFingerprints.set(iteration, void 0);
+        previousIterationWorktreeFingerprint = void 0;
+        return void 0;
+      }
+    };
+    try {
+      const finalIteration = hasTerminalDurableOutcome || remainingIterations === 0 ? 0 : await loopController.start(async (iteration) => {
+        const effectiveIteration = previousIterationCount + iteration;
+        const iterationStart = performance2.now();
+        const timeBreakdown = {
+          providerMs: 0,
+          gateMs: 0,
+          repairMs: 0,
+          testMs: 0,
+          buildMs: 0,
+          overheadMs: 0
+        };
+        const recordEarlyFailure = async (message, terminationSignal) => {
+          const changedFiles2 = (await getWorktreeChangedFiles(ctx.worktreePath)).files;
+          const durationMs2 = performance2.now() - iterationStart;
+          const record2 = {
+            iteration: effectiveIteration,
+            success: false,
+            providerExecutionStatus: "failed",
+            providerOutputStatus: "missing",
+            providerStatusDetail: message,
+            changedFiles: changedFiles2,
+            cost: 0,
+            durationMs: durationMs2,
+            timeBreakdown: {
+              ...timeBreakdown,
+              overheadMs: Math.max(0, durationMs2)
+            },
+            error: message,
+            terminationSignal,
+            policyEvents: policyRecorder.events.filter(
+              (event) => event.iteration === effectiveIteration
+            )
+          };
+          iterationHistory.push(record2);
+          if (ctx.artifactStore) {
+            await saveBestEffort(
+              ctx.artifactStore,
+              ctx.stage.id,
+              `iteration-${effectiveIteration}`,
+              record2
+            );
+          }
+          return record2;
+        };
+        let basePromptWithIntervention = ctx.stage.prompt ?? "";
+        if (interventionActive && noOpIntervention) {
+          const recoveryPrompt = buildRecoveryPrompt({
+            config: noOpIntervention,
+            iteration: effectiveIteration,
+            lastDurationMs: lastIterationDurationMs,
+            consecutiveNoOps
+          });
+          basePromptWithIntervention = `${recoveryPrompt}
+
+---
+
+${basePromptWithIntervention}`;
+          log(
+            `Intervention active: injecting recovery prompt (${consecutiveNoOps} consecutive no-ops)`
+          );
+        }
+        const prompt = buildIterationPrompt({
+          basePrompt: basePromptWithIntervention,
+          iteration: effectiveIteration,
+          iterationHistory,
+          gateCommands: gateCommandsForPrompt(),
+          requiresTests: config.requiresTests,
+          testFilePatterns: config.testFilePatterns,
+          promptLanguage
+        });
+        log(`Iteration ${effectiveIteration}: executing provider...`);
+        let providerResult;
+        let providerCost = 0;
+        let providerCostUnavailableReason;
+        let providerTokens = 0;
+        let providerError;
+        let providerOutputText;
+        let providerExecutionStatus;
+        let providerOutputStatus;
+        let providerStatusDetail;
+        let providerHardExitFailure = false;
+        let providerVerificationUnavailableRecovered = false;
+        const providerStart = performance2.now();
+        try {
+          const elapsedLoopMsForProvider = elapsedLoopMs();
+          const remainingLoopMs = Math.max(0, timeboxMs - elapsedLoopMsForProvider);
+          if (remainingLoopMs <= 0) {
+            const message = "Autoloop timebox exhausted before provider execution";
+            policyRecorder.emit({
+              policy: "timebox",
+              eventType: "terminated",
+              iteration: effectiveIteration,
+              reason: message,
+              details: {
+                elapsedLoopMs: elapsedLoopMsForProvider,
+                timeboxMs
+              }
+            });
+            await recordEarlyFailure(message, "timebox_exceeded");
+            throw new AutoloopTerminationError(message, "timebox_exceeded");
+          }
+          const perIterationCapMs = typeof iterationTimeboxMs === "number" && iterationTimeboxMs > 0 ? Math.min(remainingLoopMs, iterationTimeboxMs) : remainingLoopMs;
+          providerResult = await executeProviderIteration({
+            executor: ctx.executor,
+            stage: ctx.stage,
+            worktreePath: ctx.worktreePath,
+            prompt,
+            timeoutMs: perIterationCapMs,
+            abortSignal: ctx.abortSignal,
+            ...ctx.providerExecutionTransport !== void 0 ? {
+              defaultProviderExecutionTransport: ctx.providerExecutionTransport
+            } : {}
+          });
+          const rawProviderExitCode = providerResult.result?.exitCode;
+          providerHardExitFailure = typeof rawProviderExitCode === "number" && rawProviderExitCode !== 0;
+          providerCostUnavailableReason = readCostMetricsUnavailableReason(
+            providerResult.costMetrics
+          );
+          const reportedProviderCost = providerResult.costMetrics?.totalCost;
+          if (providerCostUnavailableReason === void 0 && typeof reportedProviderCost === "number" && Number.isFinite(reportedProviderCost)) {
+            providerCost = reportedProviderCost;
+          }
+          providerTokens = resolveTokenAccounting(providerResult.costMetrics).totalTokens;
+          timeBreakdown.providerMs = performance2.now() - providerStart;
+          const { selectProviderEngineStdout } = await import("./autoloop-helpers-2KTK43GL.js");
+          const engineStdout = selectProviderEngineStdout(
+            providerResult.result
+          );
+          const engineStderr = providerResult.result?.stderr ?? "";
+          const stdoutText = typeof engineStdout === "string" ? engineStdout : String(engineStdout ?? "");
+          const stderrText = typeof engineStderr === "string" ? engineStderr : String(engineStderr ?? "");
+          const trimmed = buildProviderOutputExcerpt(
+            resolveFlywheelStageProvider(ctx.stage, ctx.worktreePath),
+            stdoutText,
+            stderrText
+          );
+          if (trimmed.length > 0) {
+            providerOutputText = trimmed;
+          } else if (typeof providerResult.output === "string" && providerResult.output.length > 0) {
+            providerOutputText = providerResult.output;
+          } else if (providerResult.result !== void 0 && providerResult.result !== null) {
+            try {
+              providerOutputText = JSON.stringify(providerResult.result);
+            } catch {
+              providerOutputText = String(providerResult.result);
+            }
+          }
+          const providerStatus = classifyAutoloopProviderStatus({
+            providerResult,
+            stdoutText,
+            stderrText
+          });
+          providerExecutionStatus = providerStatus.executionStatus;
+          providerOutputStatus = providerStatus.outputStatus;
+          providerStatusDetail = providerStatus.detail;
+          providerError = providerResult.success ? providerStatus.error : providerResult.error?.message ?? providerStatus.error;
+        } catch (error) {
+          if (error instanceof AutoloopTerminationError) {
+            throw error;
+          }
+          timeBreakdown.providerMs = performance2.now() - providerStart;
+          providerResult = {
+            success: false,
+            error: error instanceof Error ? error : new Error(String(error))
+          };
+          providerError = error instanceof Error ? error.message : String(error);
+          providerExecutionStatus = "failed";
+          providerOutputStatus = "missing";
+          providerStatusDetail = providerError;
+        }
+        totalTokens += providerTokens;
+        const allowlist = ctx.stage.allowlist;
+        const allowlistMode2 = ctx.stage.allowlistMode ?? "warn";
+        let allowlistViolations = [];
+        let allowlistRevertedFiles;
+        let allowlistDrift = false;
+        let allowlistError;
+        let changedFilesResult = await getWorktreeChangedFiles(ctx.worktreePath);
+        let changedFiles = changedFilesResult.files;
+        let simpleArtifactGoalSatisfied;
+        if (!changedFilesResult.readable) {
+          allowlistError = "Changed-file status unavailable: git status failed";
+          providerError = providerError ?? allowlistError;
+        }
+        if (changedFiles.length === 0) {
+          const provider = resolveFlywheelStageProvider(ctx.stage, ctx.worktreePath);
+          const detection = getProviderDetectionMode(provider);
+          if (!detection.emitsJsonl) {
+            const jsonl = await detectNonEmptyEditsJsonl(ctx.worktreePath);
+            if (jsonl) {
+              providerError = providerError ?? `Protocol mismatch: detected .poetic/edits.jsonl (${jsonl.bytes} bytes) but provider '${provider}' is configured as git-only; no tracked changes were applied.`;
+            }
+          }
+        }
+        if (ctx.stage.automaticRepair === true && changedFilesResult.readable && changedFiles.length > 0) {
+          const repairScope = await enforceAutomaticRepairScope({
+            worktreePath: ctx.worktreePath,
+            baseline: repairScopeBaseline,
+            explicitScope: allowlist
+          });
+          changedFiles = repairScope.changedFiles;
+          allowlistViolations = repairScope.violations;
+          allowlistRevertedFiles = repairScope.revertedFiles;
+          allowlistDrift = repairScope.violations.length > 0;
+          if (repairScope.error) {
+            allowlistError = repairScope.error;
+            providerError = providerError ?? repairScope.error;
+          }
+        } else if (allowlistMode2 !== "off" && allowlist !== void 0 && changedFiles.length > 0) {
+          let scopeDecision = decideStageChangeScope({
+            changedPaths: changedFiles,
+            explicitScope: allowlist ?? [],
+            allowlistMode: allowlistMode2,
+            mutationOrigin: "provider"
+          });
+          allowlistViolations = scopeDecision.allowlistViolations;
+          allowlistDrift = allowlistViolations.length > 0;
+          if (scopeDecision.disposition === "rollback") {
+            allowlistRevertedFiles = allowlistViolations;
+            await revertFilesToHead(ctx.worktreePath, allowlistViolations);
+            changedFilesResult = await getWorktreeChangedFiles(ctx.worktreePath);
+            changedFiles = changedFilesResult.files;
+            if (!changedFilesResult.readable) {
+              allowlistError = "Changed-file status unavailable after allowlist revert";
+              providerError = providerError ?? allowlistError;
+            }
+            scopeDecision = decideStageChangeScope({
+              changedPaths: changedFiles,
+              explicitScope: allowlist ?? [],
+              allowlistMode: allowlistMode2,
+              mutationOrigin: "provider"
+            });
+            allowlistViolations = scopeDecision.allowlistViolations;
+            allowlistDrift = allowlistViolations.length > 0;
+            if (allowlistDrift) {
+              allowlistError = `Allowlist violation: ${allowlistViolations.length} file(s) outside allowlist`;
+              providerError = providerError ?? allowlistError;
+            }
+          } else if (scopeDecision.disposition === "filter") {
+            const filteredViolations = allowlistViolations;
+            allowlistRevertedFiles = filteredViolations;
+            await revertFilesToHead(ctx.worktreePath, filteredViolations);
+            changedFilesResult = await getWorktreeChangedFiles(ctx.worktreePath);
+            changedFiles = changedFilesResult.files;
+            if (!changedFilesResult.readable) {
+              allowlistError = "Changed-file status unavailable after allowlist filter";
+              providerError = providerError ?? allowlistError;
+            }
+            const residualViolations = decideStageChangeScope({
+              changedPaths: changedFiles,
+              explicitScope: allowlist ?? [],
+              allowlistMode: allowlistMode2,
+              mutationOrigin: "provider"
+            }).allowlistViolations;
+            allowlistViolations = filteredViolations;
+            allowlistDrift = true;
+            if (residualViolations.length > 0) {
+              allowlistError = `Allowlist filter violation: ${residualViolations.length} file(s) outside allowlist could not be filtered`;
+              providerError = providerError ?? allowlistError;
+              allowlistViolations = residualViolations;
+            }
+          } else if (allowlistDrift && allowlistMode2 === "warn") {
+            providerError = providerError ?? `Allowlist drift (warn): ${allowlistViolations.length} file(s) outside allowlist`;
+          }
+        }
+        if (!allowlistError && !explicitValidationConfigured && !explicitVerificationIntent && changedFilesResult.readable) {
+          const simpleGoalResult = await evaluateSimpleArtifactGoal({
+            prompt: ctx.stage.prompt ?? "",
+            worktreePath: ctx.worktreePath,
+            changedFiles
+          });
+          if (simpleGoalResult.satisfied && simpleGoalResult.goal) {
+            simpleArtifactGoalSatisfied = simpleGoalResult.goal;
+            policyRecorder.emit({
+              policy: "goal_gate",
+              eventType: "terminated",
+              iteration: effectiveIteration,
+              reason: "simple artifact goal satisfied",
+              details: { path: simpleArtifactGoalSatisfied.path }
+            });
+            log(`Simple artifact goal satisfied: ${simpleArtifactGoalSatisfied.path}`);
+          }
+        }
+        let iterationCompletionProof;
+        if (stageHasHostDeterministicCompletionSurface(ctx.stage)) {
+          try {
+            iterationCompletionProof = await evaluateStageCompletionProof({
+              stage: ctx.stage,
+              worktreePath: ctx.worktreePath,
+              stdout: providerOutputText ?? "",
+              providerText: providerOutputText,
+              attemptChangedFiles: changedFiles,
+              allowlist: collectDeclaredStageTargets(ctx.stage),
+              stageId: ctx.stage.id
+            });
+            if (iterationCompletionProof.contractsSatisfied && iterationCompletionProof.mayAcceptOutcome) {
+              policyRecorder.emit({
+                policy: "goal_gate",
+                eventType: "evaluated",
+                iteration: effectiveIteration,
+                reason: "host completion surface satisfied",
+                details: {
+                  alreadySatisfied: iterationCompletionProof.alreadySatisfied,
+                  source: iterationCompletionProof.evidence?.source
+                }
+              });
+            } else if (iterationCompletionProof.hasHostSurface && !iterationCompletionProof.contractsSatisfied) {
+              policyRecorder.emit({
+                policy: "goal_gate",
+                eventType: "evaluated",
+                iteration: effectiveIteration,
+                reason: "host completion surface not satisfied",
+                details: {
+                  feedback: iterationCompletionProof.feedback
+                }
+              });
+            }
+          } catch (error) {
+            iterationCompletionProof = hostSurfaceEvaluatorFailureProof(error);
+            providerError = mergeIterationRetryFeedback(
+              providerError,
+              iterationCompletionProof.feedback
+            );
+            policyRecorder.emit({
+              policy: "goal_gate",
+              eventType: "evaluated",
+              iteration: effectiveIteration,
+              reason: "host completion evaluator error",
+              details: {
+                feedback: iterationCompletionProof.feedback
+              }
+            });
+          }
+        }
+        const hostContractsBlockShortCircuit = iterationCompletionProof?.hasHostSurface === true && iterationCompletionProof.mayAcceptOutcome !== true;
+        const hostContractsBackCompletion = !iterationCompletionProof?.hasHostSurface || iterationCompletionProof.mayAcceptOutcome === true;
+        const allConfiguredGates = [...gatesToRun, ...dynamicGates];
+        let normalizedGates;
+        if (configuredGatePreset) {
+          const presetResult = await resolveGatePreset({
+            configuredPreset: configuredGatePreset,
+            escalation: gateEscalation,
+            changedFiles,
+            repairAttempts: totalRepairAttemptsForEscalation,
+            failedGateIds: failedGateIdsForEscalation
+          });
+          currentGatePreset = presetResult.preset;
+          if (presetResult.escalationReason) {
+            log(`Gate escalation: ${currentGatePreset} (${presetResult.escalationReason})`);
+          }
+          const presetFilteredGates = filterGatesByPreset(
+            allConfiguredGates,
+            currentGatePreset
+          );
+          normalizedGates = orderGatesByType(presetFilteredGates);
+          if (normalizedGates.length !== allConfiguredGates.length) {
+            log(
+              `Gates filtered by preset '${currentGatePreset}': ${normalizedGates.length}/${allConfiguredGates.length}`
+            );
+          }
+        } else {
+          normalizedGates = orderGatesByType(allConfiguredGates);
+          currentGatePreset = "full";
+        }
+        let finalGateResults;
+        let iterRepairAttempted = false;
+        let iterRepairSuccesses = 0;
+        if (normalizedGates.length > 0 && !allowlistError && !simpleArtifactGoalSatisfied) {
+          const gateNow = performance2.now();
+          const elapsedLoopMsForGates = elapsedLoopMs();
+          const elapsedIterationMsForGates = Math.max(0, gateNow - iterationStart);
+          const hasIterationGateCeiling = typeof iterationTimeboxMs === "number" && iterationTimeboxMs > 0;
+          const iterationGateRemainingMs = hasIterationGateCeiling ? Math.floor(iterationTimeboxMs - elapsedIterationMsForGates) : void 0;
+          if (iterationGateRemainingMs !== void 0 && iterationGateRemainingMs <= 0) {
+            providerError = providerError ?? "Autoloop timebox exhausted before quality gates";
+            log(providerError);
+          } else {
+            const loopGateRemainingMs = Math.floor(timeboxMs - elapsedLoopMsForGates);
+            if (loopGateRemainingMs <= 0) {
+              providerError = providerError ?? "Autoloop timebox exhausted before quality gates";
+              log(providerError);
+            } else {
+              const effectiveGateRemainingMs = Math.max(
+                1,
+                iterationGateRemainingMs !== void 0 ? Math.min(iterationGateRemainingMs, loopGateRemainingMs) : loopGateRemainingMs
+              );
+              const gatesWithTimeout = normalizedGates.map(
+                (gate) => typeof gate.timeoutMs === "number" && gate.timeoutMs > 0 ? (
+                  // Tighten an explicit operator-set timeout to the
+                  // remaining budget; only ever shrink, never widen.
+                  {
+                    ...gate,
+                    timeoutMs: Math.min(gate.timeoutMs, effectiveGateRemainingMs)
+                  }
+                ) : { ...gate, timeoutMs: effectiveGateRemainingMs }
+              );
+              const gateStart = performance2.now();
+              const gateRun = await runAllGates(gatesWithTimeout, ctx.worktreePath, {
+                baselineCwd: ctx.baselineWorktreePath,
+                abortSignal: ctx.abortSignal
+              });
+              timeBreakdown.gateMs = performance2.now() - gateStart;
+              finalGateResults = gateRun.results;
+              const unavailableGateSignal2 = detectUnavailableGateVerification(
+                gateRun.results
+              );
+              if (unavailableGateSignal2) {
+                providerError = providerError ?? `Verification unavailable: ${unavailableGateSignal2.message}`;
+              }
+              if (!gateRun.passed && !unavailableGateSignal2) {
+                const failedMustPassGates = gateRun.results.filter(
+                  (r) => !r.passed && r.gate.mustPass && r.isRegression !== false
+                );
+                const failedGate = failedMustPassGates.find(
+                  (r) => shouldAttemptRepair(r.gate)
+                );
+                if (failedGate && shouldAttemptRepair(failedGate.gate)) {
+                  const holisticFailedGate = failedMustPassGates.length > 1 ? {
+                    ...failedGate,
+                    outputTail: failedMustPassGates.map(
+                      (r) => `Gate ${r.gate.id} (${r.gate.command}) failed with exit ${r.exitCode}:
+${r.outputTail || "(no output)"}`
+                    ).join("\n\n")
+                  } : failedGate;
+                  const maxAttempts = getMaxRepairAttempts(failedGate.gate);
+                  const provider = resolveFlywheelStageProvider(ctx.stage, ctx.worktreePath);
+                  const { applyFlywheelModelDefaults } = await import("./flywheel-model-defaults-7CVKP53V.js");
+                  const model = applyFlywheelModelDefaults(ctx.stage, provider);
+                  const recentFailingGates = [failedGate.gate.id];
+                  if (!failedGateIdsForEscalation.includes(failedGate.gate.id)) {
+                    failedGateIdsForEscalation.push(failedGate.gate.id);
+                  }
+                  const repairStart = performance2.now();
+                  for (let attemptNum = 1; attemptNum <= maxAttempts; attemptNum++) {
+                    const repairNow = performance2.now();
+                    const loopRepairRemainingMs = Math.floor(timeboxMs - elapsedLoopMs());
+                    const iterationRepairRemainingMs = typeof iterationTimeboxMs === "number" && iterationTimeboxMs > 0 ? Math.floor(
+                      iterationTimeboxMs - Math.max(0, repairNow - iterationStart)
+                    ) : void 0;
+                    const effectiveRepairRemainingMs = iterationRepairRemainingMs !== void 0 ? Math.min(iterationRepairRemainingMs, loopRepairRemainingMs) : loopRepairRemainingMs;
+                    if (effectiveRepairRemainingMs < MIN_GATE_REPAIR_TIMEOUT_MS) {
+                      log(
+                        `Skipping gate repair ${attemptNum}/${maxAttempts} for ${failedGate.gate.id}: insufficient remaining timebox (${Math.max(0, effectiveRepairRemainingMs)}ms < ${MIN_GATE_REPAIR_TIMEOUT_MS}ms)`
+                      );
+                      break;
+                    }
+                    const repairTimeoutMs = effectiveRepairRemainingMs;
+                    if (!iterRepairAttempted) {
+                      iterRepairAttempted = true;
+                      totalRepairAttemptsForEscalation++;
+                    }
+                    log(
+                      `Attempting gate repair ${attemptNum}/${maxAttempts} for ${failedGate.gate.id}`
+                    );
+                    const repairResult = await attemptGateRepair({
+                      failedGate: failedGate.gate,
+                      gateResult: holisticFailedGate,
+                      allGates: gatesWithTimeout,
+                      worktreePath: ctx.worktreePath,
+                      changedFiles,
+                      executor: ctx.executor,
+                      provider,
+                      model,
+                      attemptNumber: attemptNum,
+                      // Use the SAME raw allowlist the main iteration enforces
+                      // against (ctx.stage.allowlist). collectDeclaredStageTargets
+                      // returns a different set — it normalizes/filters entries
+                      // (drops node_modules/absolute/.. paths) and folds in
+                      // requiredFiles, specHarness targets, and prompt-declared
+                      // targets — so the repair allowlist diverged from the main
+                      // check and could flag files the iteration had permitted.
+                      allowlist: ctx.stage.allowlist,
+                      allowlistMode: allowlistMode2,
+                      baselineCwd: ctx.baselineWorktreePath,
+                      abortSignal: ctx.abortSignal,
+                      timeoutMs: repairTimeoutMs
+                    });
+                    providerCost += repairResult.cost;
+                    providerCostUnavailableReason ??= repairResult.costUnavailableReason;
+                    const repairTokenAccounting = resolveTokenAccounting({
+                      inputTokens: repairResult.inputTokens ?? 0,
+                      outputTokens: repairResult.outputTokens ?? 0,
+                      totalCost: repairResult.cost,
+                      tokenUsageSource: repairResult.tokenUsageSource
+                    });
+                    providerTokens += repairTokenAccounting.totalTokens;
+                    totalTokens += repairTokenAccounting.totalTokens;
+                    for (const evidence of repairResult.reviewRequiredEvidence ?? []) {
+                      repairReviewWarnings.add(formatRepairSuppressionWarning(evidence));
+                    }
+                    if (repairResult.allowlistState) {
+                      changedFiles = repairResult.allowlistState.changedFiles;
+                      allowlistViolations = repairResult.allowlistState.violations;
+                      allowlistDrift = allowlistViolations.length > 0;
+                      if (repairResult.allowlistState.autoRevertedFiles.length > 0) {
+                        allowlistRevertedFiles = repairResult.allowlistState.autoRevertedFiles;
+                      }
+                      if (repairResult.allowlistState.error) {
+                        allowlistError = repairResult.allowlistState.error;
+                        providerError = providerError ?? allowlistError;
+                      }
+                    }
+                    if (repairResult.abortFurtherRepairs) {
+                      finalGateResults = repairResult.gateResults;
+                      break;
+                    }
+                    if (repairResult.success) {
+                      iterRepairSuccesses++;
+                      finalGateResults = repairResult.gateResults;
+                      log(`Gate repair successful after ${attemptNum} attempt(s)`);
+                      break;
+                    }
+                    const nowFailingGate = repairResult.gateResults?.find(
+                      (r) => !r.passed && r.gate.mustPass
+                    );
+                    if (nowFailingGate) {
+                      recentFailingGates.push(nowFailingGate.gate.id);
+                      if (recentFailingGates.length > 4) recentFailingGates.shift();
+                      const uniqueRecent = new Set(recentFailingGates);
+                      const isFlipPattern = recentFailingGates.length >= 3 && recentFailingGates[0] === recentFailingGates[2] && recentFailingGates[0] !== recentFailingGates[1];
+                      const isTooManyDistinct = uniqueRecent.size >= 3;
+                      if (isFlipPattern || isTooManyDistinct) {
+                        const pattern = [...uniqueRecent].join("<->");
+                        const reason = isFlipPattern ? "flip pattern detected" : "too many distinct failing gates";
+                        log(
+                          `Gate repair thrashing: ${pattern} (${reason}). Stopping repairs this iteration.`
+                        );
+                        providerError = providerError ?? `Gate repair thrashing (${pattern}): fixes for one gate break another. Next iteration should address all failing gates holistically.`;
+                        finalGateResults = repairResult.gateResults;
+                        break;
+                      }
+                    }
+                    if (attemptNum < maxAttempts) {
+                      log(`Gate repair attempt ${attemptNum} failed, retrying...`);
+                    } else {
+                      log(`Gate repair exhausted all ${maxAttempts} attempts`);
+                      finalGateResults = repairResult.gateResults;
+                    }
+                  }
+                  timeBreakdown.repairMs = performance2.now() - repairStart;
+                }
+              }
+            }
+          }
+        }
+        const qualityGate = finalGateResults ? {
+          passed: finalGateResults.every(
+            (r) => r.passed || !r.gate.mustPass || r.isRegression === false
+          ),
+          error: (() => {
+            const failedGate = finalGateResults.find(
+              (r) => !r.passed && r.gate.mustPass && r.isRegression !== false
+            );
+            return failedGate ? `Verify command failed (exit ${failedGate.exitCode}): ${failedGate.gate.command}` : void 0;
+          })(),
+          commandResults: finalGateResults.map((r) => ({
+            id: r.gate.id,
+            command: r.gate.command,
+            exitCode: r.exitCode,
+            expectedExitCode: r.gate.expectedExitCode ?? 0,
+            passed: r.passed,
+            durationMs: r.durationMs,
+            outputTail: r.outputTail,
+            baselinePassed: r.baselinePassed,
+            isRegression: r.isRegression,
+            mustPass: r.gate.mustPass ?? true
+          }))
+        } : void 0;
+        if (qualityGate) {
+          policyRecorder.emit({
+            policy: "quality_gate",
+            eventType: qualityGate.passed ? "evaluated" : "blocked",
+            iteration: effectiveIteration,
+            reason: qualityGate.passed ? "Quality gates passed" : qualityGate.error,
+            details: {
+              gateCount: qualityGate.commandResults.length,
+              failedCommandCount: qualityGate.commandResults.filter((r) => !r.passed).length
+            }
+          });
+        }
+        if (qualityGate?.passed === true && finalGateResults !== void 0 && finalGateResults.length > 0 && !providerHardExitFailure && isVerificationUnavailableError(providerError) && !hostContractsBlockShortCircuit && hostContractsBackCompletion) {
+          providerVerificationUnavailableRecovered = false;
+        }
+        const testFilesInIteration = config.requiresTests === true ? await detectTestFiles(changedFiles, config.testFilePatterns) : [];
+        const testsCreated = testFilesInIteration.length > 0;
+        const totalTrackedMs = timeBreakdown.providerMs + timeBreakdown.gateMs + timeBreakdown.repairMs + (timeBreakdown.testMs ?? 0) + (timeBreakdown.buildMs ?? 0);
+        const iterationTotalMs = performance2.now() - iterationStart;
+        timeBreakdown.overheadMs = Math.max(0, iterationTotalMs - totalTrackedMs);
+        const progressMetrics = computeIterationProgressMetrics({
+          changedFiles,
+          qualityGate,
+          previousIteration: iterationHistory.at(-1)
+        });
+        let shouldTerminateNoOp = false;
+        let noOpTerminationMessage = "";
+        let shouldTerminateIterationTimebox = false;
+        let iterationTimeboxMessage = "";
+        let iterationTerminationSignal;
+        if (providerResult.success && requireEarlyDiff && progressMetrics.wasNoOp && effectiveIteration > 1) {
+          consecutiveNoOps++;
+          lastIterationDurationMs = iterationTotalMs;
+          providerError = providerError ?? "No-op iteration: no file changes detected";
+          log(`No-op iteration detected (consecutive: ${consecutiveNoOps})`);
+          if (noOpIntervention) {
+            const maxConsecutive = noOpIntervention.maxConsecutiveNoOps ?? 2;
+            const triggerDelay = noOpIntervention.triggerDelayMs ?? 45e3;
+            if (consecutiveNoOps >= maxConsecutive) {
+              shouldTerminateNoOp = true;
+              iterationTerminationSignal = "no_op_intervention_exceeded";
+              noOpTerminationMessage = `No-op intervention exceeded: ${consecutiveNoOps} consecutive no-ops`;
+              providerError = noOpTerminationMessage;
+              log(`Max consecutive no-ops reached (${consecutiveNoOps}/${maxConsecutive})`);
+            } else if (iterationTotalMs >= triggerDelay) {
+              interventionActive = true;
+              log(
+                `Intervention triggered: iteration took ${iterationTotalMs}ms >= ${triggerDelay}ms`
+              );
+            }
+          }
+        } else if (providerResult.success && !progressMetrics.wasNoOp) {
+          consecutiveNoOps = 0;
+          interventionActive = false;
+        }
+        if (iterationTimeboxMs && iterationTotalMs > iterationTimeboxMs) {
+          iterationTimeboxMessage = `Iteration exceeded per-iteration timebox (${iterationTotalMs.toFixed(0)}ms > ${iterationTimeboxMs}ms)`;
+          log(iterationTimeboxMessage);
+          shouldTerminateIterationTimebox = true;
+          iterationTerminationSignal = "timebox_exceeded";
+          providerError = providerError ?? iterationTimeboxMessage;
+        }
+        if (simpleArtifactGoalSatisfied && !iterationTerminationSignal) {
+          iterationTerminationSignal = "goal_satisfied";
+        }
+        let shouldTerminateVerificationUnavailable = false;
+        let verificationUnavailableMessage = "";
+        const unavailableGateSignal = detectUnavailableGateVerification(finalGateResults);
+        if (providerResult.success && !allowlistError && isVerificationUnavailableError(providerError) && (!changesHaveVerifiableCodeSurface(changedFiles) || unavailableGateSignal || /\bverification(?:\s+tool)?\s+unavailable\b/i.test(providerError ?? ""))) {
+          shouldTerminateVerificationUnavailable = true;
+          verificationUnavailableMessage = unavailableGateSignal ? `Verification unavailable: ${unavailableGateSignal.message} Stopping instead of asking the provider to install or repair target tooling; this is not reported as success.` : "Verification unavailable: post-execution tests did not run and the changed files expose no verifiable code surface (read-only / docs-only task). Stopping instead of re-iterating; this is not reported as success.";
+          providerError = verificationUnavailableMessage;
+          iterationTerminationSignal = "verification_unavailable";
+          log(verificationUnavailableMessage);
+          policyRecorder.emit({
+            policy: "goal_gate",
+            eventType: "terminated",
+            iteration: effectiveIteration,
+            reason: "verification_unavailable",
+            details: { changedFiles: changedFiles.length }
+          });
+        }
+        const record = {
+          iteration: effectiveIteration,
+          success: providerResult.success && !providerVerificationUnavailableRecovered && !allowlistError && !providerError,
+          providerExecutionStatus,
+          providerOutputStatus,
+          providerStatusDetail,
+          changedFiles,
+          providerOutputText,
+          cost: providerCost,
+          costUnavailableReason: providerCostUnavailableReason,
+          durationMs: iterationTotalMs,
+          timeBreakdown,
+          progressMetrics,
+          progressScore: void 0,
+          error: providerError,
+          terminationSignal: iterationTerminationSignal ?? (allowlistError ? "allowlist_violation" : void 0),
+          qualityGatePassed: qualityGate?.passed,
+          qualityGateError: qualityGate?.error,
+          qualityGateCommandResults: qualityGate?.commandResults,
+          allowlistViolations: allowlistDrift ? allowlistViolations : void 0,
+          allowlistRevertedFiles: allowlistRevertedFiles?.length ? allowlistRevertedFiles : void 0,
+          allowlistDrift,
+          repairAttempted: iterRepairAttempted,
+          repairSuccesses: iterRepairSuccesses,
+          testsRequired: config.requiresTests === true,
+          testsCreated,
+          // Priority 3: Short-circuit detection
+          aiValidationShortCircuited: false,
+          // Set below if conditions are met
+          completionEvidence: simpleArtifactGoalSatisfied ? {
+            durable: true,
+            source: "simple-artifact",
+            detail: simpleArtifactGoal?.path ?? "simple artifact",
+            ...iterationCompletionProof?.evidence?.providerAdvisory ? {
+              providerAdvisory: iterationCompletionProof.evidence.providerAdvisory
+            } : {},
+            ...iterationCompletionProof?.evidence?.attemptScopedEdits ? {
+              attemptScopedEdits: iterationCompletionProof.evidence.attemptScopedEdits
+            } : {},
+            ...iterationCompletionProof?.evidence?.contractResults ? {
+              contractResults: iterationCompletionProof.evidence.contractResults
+            } : {}
+          } : toAutoloopCompletionEvidence(
+            iterationCompletionProof ?? {
+              contractsSatisfied: false,
+              requireChangesSatisfied: "n/a",
+              alreadySatisfied: false,
+              mayAcceptOutcome: false,
+              hasHostSurface: false,
+              reasons: []
+            }
+          ),
+          policyEvents: policyRecorder.events.filter(
+            (event) => event.iteration === effectiveIteration
+          )
+        };
+        const cumulativeAutoloopCost = iterationHistory.reduce((sum, item) => sum + item.cost, 0) + record.cost;
+        const incrementalTracker = ctx.budgetTracker;
+        incrementalTracker.trackIncrementalStageCost?.(ctx.stage.id, cumulativeAutoloopCost);
+        let completionSignalDetected = false;
+        if (completionSignal && providerOutputText) {
+          completionSignalDetected = matchesCompletionSignal(
+            providerOutputText,
+            completionSignal
+          );
+        }
+        const canShortCircuitAiValidation = qualityGate?.passed === true && record.success && !interventionActive && !hostContractsBlockShortCircuit && hostContractsBackCompletion && (completionSignalDetected || validationMode === "deterministic" || iterationCompletionProof?.alreadySatisfied === true || record.completionEvidence?.durable === true);
+        if (canShortCircuitAiValidation) {
+          record.aiValidationShortCircuited = true;
+          aiValidationShortCircuited = true;
+          const reason = iterationCompletionProof?.alreadySatisfied ? "host completion surface already satisfied" : completionSignalDetected ? "deterministic gates passed + completion signal detected" : "deterministic validation mode + gates passed";
+          policyRecorder.emit({
+            policy: "goal_gate",
+            eventType: "terminated",
+            iteration: effectiveIteration,
+            reason,
+            details: {
+              completionSignalDetected,
+              validationMode,
+              hostContractsSatisfied: iterationCompletionProof?.contractsSatisfied
+            }
+          });
+          record.policyEvents = policyRecorder.events.filter(
+            (event) => event.iteration === effectiveIteration
+          );
+          log(`Short-circuiting AI validation (${reason})`);
+        }
+        const hasPassingHardQualityGate = (record.qualityGateCommandResults ?? []).some(
+          (gate) => gate.mustPass !== false && gate.passed === true
+        );
+        if (validationMode !== "deterministic" && config.completionOnQualityGatePass === true && completionSignalXmlTag && record.success && record.qualityGatePassed === true && hasPassingHardQualityGate && !hostContractsBlockShortCircuit && hostContractsBackCompletion) {
+          const cumulativeChangedFiles = [
+            ...iterationHistory.flatMap((item) => item.changedFiles),
+            ...record.changedFiles
+          ];
+          const requiredTestsSatisfied = config.requiresTests !== true || (await detectTestFiles(cumulativeChangedFiles, config.testFilePatterns)).length > 0;
+          const currentTestGateResults = (record.qualityGateCommandResults ?? []).filter(
+            (gate) => gate.mustPass !== false && describeVerificationCommand(gate.command).kind === "test"
+          );
+          const runtimeEvidenceSatisfied = verifyRuntimeEvidence({
+            config: config.runtimeEvidence,
+            providerOutputText: record.providerOutputText,
+            worktreePath: ctx.worktreePath,
+            basePrompt: ctx.stage.prompt ?? "",
+            changedFiles: record.changedFiles,
+            testVerification: {
+              status: currentTestGateResults.length === 0 ? "unavailable" : currentTestGateResults.every((gate) => gate.passed === true) ? "passed" : "failed",
+              checksRun: currentTestGateResults.length
+            }
+          }).passed;
+          if (requiredTestsSatisfied && runtimeEvidenceSatisfied) {
+            record.completionEvidence ??= {
+              durable: true,
+              source: "external",
+              detail: "Flywheel quality gates passed"
+            };
+            record.providerOutputText = `${record.providerOutputText ?? ""}
+${completionSignalXmlTag}`.trim().concat("\n");
+          }
+        }
+        const hostCustomGateResults = mapQualityGateCommandResultsToCustomGateResults(
+          record.qualityGateCommandResults,
+          createDurationMs
+        );
+        if (hostCustomGateResults.length > 0) {
+          Object.assign(record, { customGateResults: hostCustomGateResults });
+        }
+        record.iterationFingerprint = await captureIterationFingerprint(iteration);
+        iterationHistory.push(record);
+        if (ctx.artifactStore) {
+          await saveBestEffort(
+            ctx.artifactStore,
+            ctx.stage.id,
+            `iteration-${effectiveIteration}`,
+            record
+          );
+        }
+        const driftMsg = record.allowlistDrift ? ` [drift: ${record.allowlistViolations?.length ?? 0}]` : "";
+        log(
+          `Iteration ${effectiveIteration} ${record.success ? "ok" : "failed"} (${record.changedFiles.length} files, ${formatAutoloopIterationCost(record)})${driftMsg}`
+        );
+        if (shouldTerminateNoOp) {
+          throw new Error(noOpTerminationMessage);
+        }
+        if (shouldTerminateVerificationUnavailable) {
+          throw new AutoloopTerminationError(
+            verificationUnavailableMessage,
+            "verification_unavailable"
+          );
+        }
+        if (shouldTerminateIterationTimebox) {
+          try {
+            loopController.terminate("timebox_exceeded");
+          } catch {
+          }
+          throw new Error(iterationTimeboxMessage);
+        }
+        if (simpleArtifactGoalSatisfied) {
+          try {
+            loopController.terminate("deterministic_complete");
+          } catch {
+          }
+        }
+        return record;
+      });
+      await Promise.allSettled(pendingIterationRecords);
+      if (hasTerminalDurableOutcome || remainingIterations === 0) {
+        const reconstructed = reconstructExhaustedAutoloopOutcome({
+          priorOutcome: durableResumeState?.priorOutcome,
+          finalProgressScore: durableResumeState?.finalProgressScore
+        });
+        terminationReason = reconstructed.terminationReason;
+        loopSuccess = reconstructed.loopSuccess;
+        finalProgressScore = reconstructed.finalProgressScore;
+        policyRecorder.emit({
+          policy: policyForTerminationReason(terminationReason),
+          eventType: reconstructed.loopSuccess ? "evaluated" : "terminated",
+          reason: terminationReason,
+          details: {
+            finalProgressScore,
+            iterations: 0,
+            reconstructedFromDurableEvidence: true,
+            evidenceComplete: reconstructed.evidenceComplete,
+            source: durableResumeState?.source
+          }
+        });
+      } else {
+        finalProgressScore = finalIteration !== 0 ? finalIteration.progress.score : 0;
+        const loopIterations = loopController.getIterationHistory();
+        const lastIterationRecord = iterationHistory.at(-1);
+        const testGateResults = (lastIterationRecord?.qualityGateCommandResults ?? []).filter(
+          (gate) => gate.mustPass !== false && describeVerificationCommand(gate.command).kind === "test"
+        );
+        runtimeEvidenceCheck = verifyRuntimeEvidence({
+          config: config.runtimeEvidence,
+          providerOutputText: iterationHistory.length > 0 ? iterationHistory.at(-1)?.providerOutputText : void 0,
+          worktreePath: ctx.worktreePath,
+          basePrompt: ctx.stage.prompt ?? "",
+          changedFiles: lastIterationRecord?.changedFiles,
+          testVerification: {
+            status: testGateResults.length === 0 ? "unavailable" : testGateResults.every((gate) => gate.passed === true) ? "passed" : "failed",
+            checksRun: testGateResults.length
+          }
+        });
+        const controllerState = loopController.getState();
+        const acceptanceCriteriaEvidenceConfigured = config.runtimeEvidence?.requireAcceptanceCriteria === true;
+        terminationReason = await inferTerminationReason({
+          maxIterations: remainingIterations,
+          timeboxMs,
+          iterationHistory,
+          loopIterations,
+          minProgress,
+          gatesEnabled: gatesEnabled || dynamicGates.length > 0,
+          requiresTests: config.requiresTests,
+          testFilePatterns: config.testFilePatterns,
+          runtimeEvidenceCheck,
+          runtimeEvidenceConfigured: acceptanceCriteriaEvidenceConfigured,
+          controllerTerminationReason: controllerState.status === "terminated" ? controllerState.reason : controllerState.status === "completed" ? controllerState.completionReason : void 0
+        });
+        policyRecorder.emit({
+          policy: policyForTerminationReason(terminationReason),
+          eventType: terminationReason === "success" ? "evaluated" : "terminated",
+          reason: terminationReason,
+          details: {
+            finalProgressScore,
+            iterations: iterationHistory.length,
+            loopStatus: controllerState.status
+          }
+        });
+        const requiresPassingGates = terminationReason === "goal_satisfied" ? false : gatesEnabled || dynamicGates.length > 0;
+        const finalGatePassed = requiresPassingGates ? iterationHistory.at(-1)?.qualityGatePassed === true : true;
+        const controllerUnsafeCompletion = finalIteration !== 0 && finalIteration.completionSummary?.unsafeCompletion === true;
+        const completionSummarySupportsSuccess = finalIteration !== 0 && finalIteration.completionSummary !== void 0 && completionStatusAllowsSuccess(finalIteration.completionSummary.status) && finalIteration.completionSummary.hasSubstantiveEvidence === true && finalIteration.completionSummary.blockingIssues.length === 0;
+        const controllerReportedSuccess = controllerState.status === "terminated" && isSuccessLikeControllerReason(controllerState.reason);
+        const lastIterRecord = iterationHistory.at(-1);
+        const lastIterationOk = lastIterRecord?.success !== false;
+        const hardFailure = (
+          // Parity with the controller start() consumer: unsafeCompletion forces
+          // non-success. Shared predicate keeps the two surfaces fail-closed in
+          // lockstep (see autoloop-success.ts:unsafeCompletionAllowsSuccess).
+          !unsafeCompletionAllowsSuccess(controllerUnsafeCompletion) || controllerReportedSuccess && !completionSummarySupportsSuccess || terminationReason === "resource_exhaustion" || terminationReason === "error" || terminationReason === "timebox_exceeded" || terminationReason === "allowlist_violation" || terminationReason === "quality_gate_failure" || terminationReason === "baseline_blocked" || terminationReason === "tests_required_not_met" || terminationReason === "evidence_unsatisfied" || terminationReason === "progress_stagnation" || terminationReason === "no_op_intervention_exceeded"
+        );
+        if (!finalGatePassed || !lastIterationOk || hardFailure) {
+          loopSuccess = false;
+        } else if (terminationReason === "max_iterations_reached") {
+          const maxIterationsSuccessThreshold = ctx.stage.validation?.enabled === false ? minProgress : 0.5;
+          loopSuccess = finalProgressScore >= maxIterationsSuccessThreshold && completionSummarySupportsSuccess;
+          const lastControllerIteration = loopIterations.at(-1);
+          if (lastControllerIteration?.requirements?.enabled && !lastControllerIteration.requirements.passed) {
+            loopSuccess = false;
+          }
+        } else if (terminationReason === "success" || terminationReason === "goal_satisfied" || terminationReason === "heuristic_complete") {
+          loopSuccess = true;
+        } else {
+          loopSuccess = false;
+        }
+      }
+    } catch (error) {
+      terminationReason = inferFailureTerminationReason(error, iterationHistory);
+      loopSuccess = false;
+      policyRecorder.emit({
+        policy: policyForTerminationReason(terminationReason),
+        eventType: "terminated",
+        reason: terminationReason,
+        details: {
+          error: error instanceof Error ? error.message : String(error),
+          iterations: iterationHistory.length
+        }
+      });
+      if (ctx.artifactStore) {
+        const failureDiagnostic = createFailureDiagnostic({
+          error,
+          iterationHistory,
+          stageId: ctx.stage.id,
+          terminationReason,
+          allowlist: ctx.stage.allowlist
+        });
+        failureArtifactPersisted = await saveBestEffort(
+          ctx.artifactStore,
+          ctx.stage.id,
+          "autoloop-failure",
+          failureDiagnostic
+        );
+      }
+    }
+    const durationMs = performance2.now() - startTime;
+    if (terminationReason === "timebox_exceeded") {
+      emitBoundaryTriggered({
+        trigger: "ceiling",
+        workloadClass: "bounded-loop",
+        effectiveCeilingMs: timeboxMs,
+        elapsedMs: Math.round(durationMs),
+        source: "autoloop",
+        taskId: ctx.stage.id,
+        metadata: {
+          stageId: ctx.stage.id
+        }
+      });
+    } else if (terminationReason === "progress_stagnation" || terminationReason === "no_op_intervention_exceeded") {
+      emitBoundaryTriggered({
+        trigger: "progress",
+        workloadClass: "bounded-loop",
+        effectiveCeilingMs: timeboxMs,
+        elapsedMs: Math.round(durationMs),
+        source: "autoloop",
+        taskId: ctx.stage.id,
+        stagnantChecks: terminationReason === "progress_stagnation" ? resolveExecutionBoundary("bounded-loop").progress?.maxStagnantChecks : void 0,
+        metadata: {
+          stageId: ctx.stage.id,
+          terminationReason
+        }
+      });
+    }
+    const totalCost = hasTerminalDurableOutcome ? durableResumeState?.priorOutcome?.cost ?? 0 : iterationHistory.reduce((sum, r) => sum + r.cost, 0);
+    const totalIterationsOverall = previousIterationCount + iterationHistory.length;
+    if (terminationReason === "tests_required_not_met" && iterationHistory.length > 0) {
+      const lastIter2 = iterationHistory[iterationHistory.length - 1];
+      if (lastIter2) {
+        const displayPatterns = selectDisplayTestFilePatterns(
+          promptLanguage,
+          config.testFilePatterns
+        );
+        const expectation = displayPatterns && displayPatterns.length > 0 ? `Expected patterns: ${displayPatterns.join(", ")}` : "Follow the existing test conventions of the target project.";
+        lastIter2.error = lastIter2.error ?? `Test files required but none created. ${expectation}`;
+      }
+    }
+    if (terminationReason === "evidence_unsatisfied" && iterationHistory.length > 0) {
+      const lastIter2 = iterationHistory[iterationHistory.length - 1];
+      if (lastIter2 && runtimeEvidenceCheck && runtimeEvidenceCheck.blockingIssues.length > 0) {
+        const issueList = runtimeEvidenceCheck.blockingIssues.join("; ");
+        lastIter2.error = lastIter2.error ?? `Runtime evidence requirements not satisfied: ${issueList}. Completion blocked until evidence is verified.`;
+      }
+    }
+    const aggregateTimeMetrics = computeAggregateTimeMetrics(iterationHistory);
+    const costUnavailableReason = firstCostUnavailableReason(iterationHistory);
+    if (ctx.verbose && aggregateTimeMetrics) {
+      log("Aggregate time breakdown:");
+      log(
+        `  Provider (model): ${aggregateTimeMetrics.totalProviderMs.toFixed(0)}ms (${aggregateTimeMetrics.providerTimePct.toFixed(1)}%)`
+      );
+      log(`  Gates: ${aggregateTimeMetrics.totalGateMs.toFixed(0)}ms`);
+      log(`  Repair: ${aggregateTimeMetrics.totalRepairMs.toFixed(0)}ms`);
+      log(`  Deterministic work: ${aggregateTimeMetrics.deterministicTimePct.toFixed(1)}%`);
+      log(
+        `  No-op iterations: ${aggregateTimeMetrics.noOpIterationCount}/${iterationHistory.length}`
+      );
+      log(`  Avg iteration: ${aggregateTimeMetrics.avgIterationMs.toFixed(0)}ms`);
+    }
+    if (ctx.artifactStore) {
+      iterationHistoryArtifactPersisted = await saveBestEffort(
+        ctx.artifactStore,
+        ctx.stage.id,
+        "iteration-history",
+        iterationHistory
+      );
+      resultArtifactPersisted = await saveBestEffort(
+        ctx.artifactStore,
+        ctx.stage.id,
+        "autoloop-result",
+        {
+          totalIterations: totalIterationsOverall,
+          terminationReason,
+          finalProgressScore,
+          loopSuccess,
+          totalDurationMs: durationMs,
+          totalCost,
+          costUnavailableReason,
+          totalTokens,
+          aggregateTimeMetrics,
+          policyEvents: policyRecorder.events
+        }
+      );
+      if (!loopSuccess || iterationHistory.some((r) => r.allowlistDrift)) {
+        const failureDiagnostic = createFailureDiagnostic({
+          error: new Error(`Autoloop terminated: ${terminationReason}`),
+          iterationHistory,
+          stageId: ctx.stage.id,
+          terminationReason,
+          allowlist: ctx.stage.allowlist
+        });
+        await saveBestEffort(
+          ctx.artifactStore,
+          ctx.stage.id,
+          "autoloop-diagnostics",
+          failureDiagnostic
+        );
+      }
+    }
+    const allowlistMode = ctx.stage.allowlistMode ?? "warn";
+    const gatesForOutcome = [...gatesToRun, ...dynamicGates];
+    let finalGateResultsForOutcome;
+    const lastIter = iterationHistory.at(-1);
+    if (lastIter?.qualityGateCommandResults && gatesForOutcome.length > 0) {
+      finalGateResultsForOutcome = lastIter.qualityGateCommandResults.map((cmdResult, idx) => {
+        const gate = (cmdResult.id ? gatesForOutcome.find((g) => g.id === cmdResult.id) : void 0) ?? gatesForOutcome[idx] ?? {
+          id: `gate-${idx + 1}`,
+          command: cmdResult.command,
+          deterministic: true,
+          severity: cmdResult.mustPass === false ? "warn" : "error",
+          // Preserve persisted authority; default hard when field is absent (legacy).
+          mustPass: cmdResult.mustPass ?? true
+        };
+        const expectedExitCode = gate.expectedExitCode ?? cmdResult.expectedExitCode ?? 0;
+        const passed = typeof cmdResult.passed === "boolean" ? cmdResult.passed : cmdResult.exitCode === expectedExitCode;
+        return {
+          gate,
+          passed,
+          exitCode: cmdResult.exitCode,
+          durationMs: cmdResult.durationMs,
+          outputTail: cmdResult.outputTail,
+          baselinePassed: cmdResult.baselinePassed,
+          isRegression: cmdResult.isRegression
+        };
+      });
+    }
+    const totalRepairAttempted = iterationHistory.some((r) => r.repairAttempted === true);
+    const totalRepairSuccesses = iterationHistory.reduce(
+      (sum, r) => sum + (r.repairSuccesses ?? 0),
+      0
+    );
+    const outcomeMetadata = durableResumeState?.priorOutcome?.outcomeMetadata ?? computeAutoloopOutcome({
+      finalGateResults: finalGateResultsForOutcome,
+      iterationHistory,
+      terminationReason,
+      allowlistMode,
+      repairAttempted: totalRepairAttempted,
+      repairSuccesses: totalRepairSuccesses
+    });
+    const noOpCount = iterationHistory.filter((r) => r.progressMetrics?.wasNoOp).length;
+    const finalIterationCompletionEvidence = iterationHistory.slice().reverse().find((item) => item.completionEvidence !== void 0)?.completionEvidence;
+    result = {
+      stageId: ctx.stage.id,
+      stageType: "autoloop",
+      validationPassed: loopSuccess,
+      cost: totalCost,
+      costUnavailableReason,
+      ...repairReviewWarnings.size > 0 ? { warnings: [...repairReviewWarnings] } : {},
+      durationMs,
+      summary: `Autoloop: ${totalIterationsOverall} iterations, ${terminationReason} (${outcomeMetadata.outcome})`,
+      iterationHistory,
+      totalIterations: totalIterationsOverall,
+      terminationReason,
+      finalProgressScore,
+      loopSuccess,
+      outcomeMetadata,
+      aggregateTimeMetrics,
+      policyEvents: policyRecorder.events,
+      iterationHistoryArtifact: iterationHistoryArtifactPersisted ? `${ctx.stage.id}.iteration-history` : void 0,
+      resultArtifact: resultArtifactPersisted ? `${ctx.stage.id}.autoloop-result` : void 0,
+      failureArtifact: terminationReason === "error" && failureArtifactPersisted ? `${ctx.stage.id}.autoloop-failure` : void 0,
+      ...finalIterationCompletionEvidence ? { completionEvidence: finalIterationCompletionEvidence } : {}
+    };
+    runSummary = buildAutoloopRunSummary(ctx, result, {
+      runId: generateCompetitionId(),
+      startedAt: new Date(runStartedAtMsForSummary).toISOString(),
+      noOpIterationCount: noOpCount,
+      repairAttempts: totalRepairAttemptsForEscalation,
+      repairSuccesses: totalRepairSuccesses,
+      gatePreset: currentGatePreset,
+      aiValidationShortCircuited
+    });
+  } catch (err) {
+    executionError = err instanceof Error ? err : new Error(String(err));
+    const durationMs = performance2.now() - startTime;
+    policyRecorder.emit({
+      policy: "goal_gate",
+      eventType: "terminated",
+      reason: "error",
+      details: { error: executionError.message }
+    });
+    const outerCatchCost = resumedFromTerminalDiagnostics ? priorTerminalCostForResult ?? 0 : iterationHistory.reduce((sum, record) => sum + record.cost, 0);
+    const costUnavailableReason = firstCostUnavailableReason(iterationHistory);
+    if (ctx.artifactStore) {
+      if (iterationHistory.length > 0) {
+        iterationHistoryArtifactPersisted = await saveBestEffort(
+          ctx.artifactStore,
+          ctx.stage.id,
+          "iteration-history",
+          iterationHistory
+        ) || iterationHistoryArtifactPersisted;
+      }
+      failureArtifactPersisted = await saveBestEffort(
+        ctx.artifactStore,
+        ctx.stage.id,
+        "autoloop-failure",
+        createFailureDiagnostic({
+          error: executionError,
+          iterationHistory,
+          stageId: ctx.stage.id,
+          terminationReason: "error",
+          allowlist: ctx.stage.allowlist
+        })
+      ) || failureArtifactPersisted;
+    }
+    result = {
+      stageId: ctx.stage.id,
+      stageType: "autoloop",
+      validationPassed: false,
+      cost: outerCatchCost,
+      costUnavailableReason,
+      ...repairReviewWarnings.size > 0 ? { warnings: [...repairReviewWarnings] } : {},
+      durationMs,
+      summary: `Autoloop: ${iterationHistory.length} iteration(s), error (red)`,
+      iterationHistory,
+      totalIterations: previousIterationCountForResult + iterationHistory.length,
+      terminationReason: "error",
+      finalProgressScore: iterationHistory.length > 0 ? iterationHistory.at(-1)?.progressScore ?? 0 : 0,
+      loopSuccess: false,
+      outcomeMetadata: {
+        outcome: "red",
+        terminationClass: "execution_error",
+        failedMustPassGates: 0,
+        failedWarnGates: 0,
+        repairAttempted: false,
+        repairSuccesses: 0,
+        hadDrift: false,
+        summary: executionError.message
+      },
+      policyEvents: policyRecorder.events,
+      iterationHistoryArtifact: iterationHistory.length > 0 && iterationHistoryArtifactPersisted ? `${ctx.stage.id}.iteration-history` : void 0,
+      resultArtifact: void 0,
+      failureArtifact: failureArtifactPersisted ? `${ctx.stage.id}.autoloop-failure` : void 0
+    };
+    runSummary = buildAutoloopRunSummary(ctx, result, {
+      runId: generateCompetitionId(),
+      startedAt: new Date(runStartedAtMsForSummary).toISOString(),
+      noOpIterationCount: 0,
+      repairAttempts: 0,
+      repairSuccesses: 0,
+      gatePreset: "fast",
+      aiValidationShortCircuited: false
+    });
+  } finally {
+    await Promise.allSettled(pendingIterationRecords);
+    await finalizeAutoloopRun(ctx, result, runSummary, {
+      preserveDurableDiagnostics: resumedFromTerminalDiagnostics
+    });
+  }
+  if (executionError) {
+    throw executionError;
+  }
+  return result;
+}
+function filterDeterministicGates(gates) {
+  const filteredGates = [];
+  const gatesToRun = [];
+  const isNonDeterministic = (gate) => {
+    const c = gate.command.trim();
+    if (!c) return true;
+    if (gate.deterministic === false) return true;
+    const patterns = [
+      /\bpoetic\s+(compete|run|flywheel|sprint)\b/i,
+      /\btests\/e2e\b/i,
+      /\btest:e2e\b/i,
+      /\bvitest\b.*\btests\/e2e\b/i,
+      /\bplaywright\b/i,
+      /\bcypress\b/i,
+      /\b--ai-judge\b/i
+    ];
+    return patterns.some((re) => re.test(c));
+  };
+  for (const gate of gates) {
+    const c = gate.command.trim();
+    if (!c) continue;
+    if (isNonDeterministic(gate)) {
+      filteredGates.push(gate);
+      continue;
+    }
+    gatesToRun.push({ ...gate, command: c });
+  }
+  return { gatesToRun, filteredGates };
+}
+async function executeProviderIteration(opts) {
+  const provider = resolveFlywheelStageProvider(opts.stage, opts.worktreePath);
+  const executionIntent = resolveProviderExecutionIntentFromStage(opts.stage);
+  const workspaceMode = resolveAutoloopWorkspaceMode(provider, executionIntent);
+  const { applyFlywheelModelDefaults } = await import("./flywheel-model-defaults-7CVKP53V.js");
+  const model = applyFlywheelModelDefaults(opts.stage, provider);
+  const simpleArtifactGoal = parseSimpleArtifactGoal(opts.prompt);
+  const simpleArtifactTools = simpleArtifactGoal !== void 0 ? simpleArtifactToolPolicy(provider) : null;
+  const variantConfig = {
+    provider,
+    model,
+    strategy: "conservative",
+    executionMode: "local",
+    executionIntent,
+    ...opts.stage.providerExecutionTransport ?? opts.defaultProviderExecutionTransport ? {
+      executionTransport: opts.stage.providerExecutionTransport ?? opts.defaultProviderExecutionTransport
+    } : {},
+    ...workspaceMode ? { workspaceMode } : {},
+    // Force basic CLI execution against the provided stage worktree.
+    isBasicCompetition: true,
+    workflowWorktreePath: opts.worktreePath,
+    disableAutoCommit: true,
+    structuredFileTargets: collectDeclaredStageTargets(opts.stage),
+    ...simpleArtifactTools ? {
+      allowedTools: simpleArtifactTools.allowedTools,
+      tools: simpleArtifactTools.allowedTools,
+      disallowedTools: simpleArtifactTools.disallowedTools,
+      providerOutputSuppression: simpleArtifactTools.providerOutputSuppression
+    } : {},
+    ...typeof opts.timeoutMs === "number" && opts.timeoutMs > 0 ? { timeoutMs: Math.max(1, Math.floor(opts.timeoutMs)) } : {}
+  };
+  return opts.abortSignal ? opts.executor.executeVariant(generateCompetitionId(), variantConfig, opts.prompt, {
+    abortSignal: opts.abortSignal
+  }) : opts.executor.executeVariant(generateCompetitionId(), variantConfig, opts.prompt);
+}
+function classifyAutoloopProviderStatus(input) {
+  const runResult = input.providerResult.result;
+  const providerDiagnostics = normalizeProviderRunDiagnostics(runResult?.providerDiagnostics) ?? normalizeProviderRunDiagnostics(input.providerResult.providerDiagnostics);
+  const exitCode = typeof runResult?.exitCode === "number" ? runResult.exitCode : void 0;
+  const executionStatus = exitCode === void 0 ? input.providerResult.success ? "completed" : "failed" : exitCode === 0 ? "completed" : "failed";
+  const hasLegacyUsableStdout = input.stdoutText.trim().length > 0 || typeof input.providerResult.output === "string" && input.providerResult.output.trim().length > 0;
+  const hasUsableOutput = typeof providerDiagnostics?.finalAnswerPresent === "boolean" ? providerDiagnostics.finalAnswerPresent : hasLegacyUsableStdout;
+  const stderrText = input.stderrText.trim();
+  const diagnosticsLookFatal = providerDiagnosticsReportFatalRuntimeIssue(providerDiagnostics);
+  const stderrLooksFatal = providerDiagnostics === void 0 && looksLikeProviderToolOrRuntimeError(stderrText);
+  if (executionStatus === "failed") {
+    const detail = exitCode === void 0 ? "Provider execution failed before reporting an exit code" : `Provider execution failed with exit code ${exitCode}`;
+    return {
+      executionStatus,
+      outputStatus: hasUsableOutput ? "usable" : "missing",
+      detail,
+      error: input.providerResult.error?.message ?? detail
+    };
+  }
+  if (!hasUsableOutput && (diagnosticsLookFatal || stderrLooksFatal)) {
+    const detail = providerDiagnostics === void 0 ? "Provider completed but stderr reports tool/runtime errors and no usable stdout" : "Provider completed but structured diagnostics report tool/runtime errors and no usable output";
+    const stderrTail = truncateTail(stderrText, 500);
+    return {
+      executionStatus,
+      outputStatus: "invalid",
+      detail,
+      error: stderrTail ? `${detail}: ${stderrTail}` : detail
+    };
+  }
+  return {
+    executionStatus,
+    outputStatus: hasUsableOutput ? "usable" : "missing",
+    detail: hasUsableOutput ? void 0 : "Provider completed without usable output"
+  };
+}
+function looksLikeProviderToolOrRuntimeError(stderrText) {
+  if (!stderrText) return false;
+  return [
+    /\btool(?:\s+\w+)?\s+(?:error|failed|failure)\b/i,
+    /\btool call\b.*\b(?:error|failed|failure)\b/i,
+    /\bfailed to (?:call|execute|run) tool\b/i,
+    /\berror executing tool\b/i,
+    /\btransport channel closed\b/i,
+    /\bAuthorizationRequired\b/i,
+    /^error[:\s]/i,
+    /\buncaught (?:exception|error)\b/i
+  ].some((pattern) => pattern.test(stderrText));
+}
+function isVerificationUnavailableError(message) {
+  if (!message) return false;
+  return /\b(?:tests?|verification)\b[\s\S]{0,40}\bdid not run\b/i.test(message) || /\bverification(?:\s+tool)?\s+unavailable\b/i.test(message);
+}
+function detectUnavailableGateVerification(results) {
+  if (!results) return void 0;
+  for (const result of results) {
+    if (result.passed || !result.gate.mustPass || result.isRegression === false) continue;
+    const signal = detectVerificationToolUnavailable(result.gate.command, result.outputTail ?? "");
+    if (signal) {
+      return {
+        command: result.gate.command,
+        message: signal.message
+      };
+    }
+  }
+  return void 0;
+}
+async function evaluateSimpleArtifactGoal(input) {
+  const goal = parseSimpleArtifactGoal(input.prompt);
+  if (!goal) return { satisfied: false };
+  return {
+    satisfied: await isSimpleArtifactGoalSatisfiedForChanges(
+      input.worktreePath,
+      goal,
+      input.changedFiles
+    ),
+    goal
+  };
+}
+async function getWorktreeChangedFiles(worktreePath) {
+  try {
+    const { stdout } = await execa2("git", ["status", "--porcelain", "--untracked-files=all"], {
+      cwd: worktreePath,
+      stdio: "pipe",
+      timeout: 3e4
+    });
+    const files = parseGitStatusPaths(stdout, { includeOriginalPaths: true }).filter(
+      (file) => file.length > 0
+    );
+    return {
+      files: filterWorktreeRunSentinelPaths(Array.from(new Set(files))).sort(
+        (a, b) => a.localeCompare(b)
+      ),
+      readable: true
+    };
+  } catch {
+    return { files: [], readable: false };
+  }
+}
+function buildIterationPrompt(input) {
+  const { basePrompt, iteration, iterationHistory, gateCommands } = input;
+  const acceptanceCriteria = extractAcceptanceCriteria(basePrompt);
+  const acceptanceCriteriaForPrompt = formatAcceptanceCriteriaForPrompt(acceptanceCriteria);
+  const acceptanceCriteriaSection = acceptanceCriteria.length > 0 ? `
+## Acceptance Criteria (treat as a checklist)
+${acceptanceCriteriaForPrompt}
+` : "";
+  const criteriaReportSection = acceptanceCriteria.length > 0 ? '\n## Criteria Report (required every iteration)\nAt the end of your response, output a machine-parseable JSON report exactly like:\n\nPOETIC_CRITERIA_REPORT:\n{\n  "criteria": [\n    { "id": "AC1", "status": "met", "evidence": ["src/path.ts: explains how criterion is satisfied"] },\n    { "id": "AC2", "status": "partial", "evidence": ["..."] },\n    { "id": "AC3", "status": "not_met", "evidence": [] }\n  ]\n}\n\nRules:\n- Status must be one of: met | partial | not_met\n- Evidence must be concrete (file paths, flags, behavior, outputs)\n- Do not add features beyond the acceptance criteria unless explicitly requested\n' : "";
+  if (iteration <= 1) {
+    const testRequirementSection = input.requiresTests === true ? "\n\n## Test Requirement\nThis autoloop requires test files to be created. " + renderTestRequirementBody(input.promptLanguage, input.testFilePatterns) + "\n" : "";
+    if (gateCommands.length === 0)
+      return `${basePrompt}${acceptanceCriteriaSection}${testRequirementSection}${criteriaReportSection}`;
+    return `${basePrompt}
+
+` + acceptanceCriteriaSection + testRequirementSection + "## Autoloop Quality Gates\nMake these commands pass (they will be re-run after each iteration):\n" + gateCommands.map((c) => `- ${c}`).join("\n") + `
+${criteriaReportSection}`;
+  }
+  const prev = iterationHistory.at(-1);
+  const parts = [`${basePrompt}${acceptanceCriteriaSection}${criteriaReportSection}`];
+  if (input.requiresTests === true) {
+    parts.push(
+      "\n## Test Requirement\nThis autoloop requires test files to be created. " + renderTestRequirementBody(input.promptLanguage, input.testFilePatterns)
+    );
+  }
+  if (gateCommands.length > 0) {
+    parts.push(
+      "\n## Autoloop Quality Gates\nMake these commands pass (they will be re-run after each iteration):\n" + gateCommands.map((c) => `- ${c}`).join("\n")
+    );
+  }
+  if (prev) {
+    const changed = prev.changedFiles.slice(0, 50).map((f) => `- ${f}`).join("\n");
+    parts.push(`
+## Previous Iteration Feedback (iteration ${prev.iteration})`);
+    if (prev.error) parts.push(`- Provider error: ${prev.error}`);
+    if (prev.allowlistDrift && prev.allowlistViolations && prev.allowlistViolations.length > 0) {
+      const driftFiles = prev.allowlistViolations.slice(0, 20).map((f) => `  - ${f}`).join("\n");
+      parts.push(
+        `
+### Allowlist Drift Detected
+The following ${prev.allowlistViolations.length} file(s) are outside the stage allowlist:
+${driftFiles}` + (prev.allowlistViolations.length > 20 ? `
+  ... and ${prev.allowlistViolations.length - 20} more` : "") + "\n\n**Action required**: Revert changes to these files or ensure they are within the allowlist scope."
+      );
+    }
+    if (prev.allowlistRevertedFiles && prev.allowlistRevertedFiles.length > 0) {
+      const reverted = prev.allowlistRevertedFiles.slice(0, 20).map((f) => `  - ${f}`).join("\n");
+      parts.push(
+        `
+### Allowlist Auto-Revert (strict mode)
+Flywheel automatically reverted edits to ${prev.allowlistRevertedFiles.length} file(s) outside the stage allowlist:
+${reverted}` + (prev.allowlistRevertedFiles.length > 20 ? `
+  ... and ${prev.allowlistRevertedFiles.length - 20} more` : "") + "\n\n**Action required**: Keep all edits within the allowlist; do not reintroduce these changes."
+      );
+    }
+    if (prev.qualityGatePassed === false) {
+      parts.push(`- Quality gate failed: ${prev.qualityGateError ?? "unknown"}`);
+      const tail = prev.qualityGateCommandResults?.find((r) => r.exitCode !== 0)?.outputTail ?? prev.qualityGateCommandResults?.at(-1)?.outputTail;
+      if (tail) {
+        parts.push(`
+### Failing Command Output (tail)
+\`\`\`
+${tail}
+\`\`\``);
+      }
+    }
+    if (changed) parts.push(`
+### Changed Files (latest)
+${changed}`);
+  }
+  return parts.join("\n");
+}
+async function revertFilesToHead(worktreePath, files) {
+  const uniqueFiles = Array.from(new Set(files)).filter((f) => typeof f === "string" && f.length);
+  if (uniqueFiles.length === 0) return;
+  try {
+    await execa2("git", ["checkout", "--", ...uniqueFiles], {
+      cwd: worktreePath,
+      stdio: "pipe",
+      reject: false,
+      timeout: 3e4,
+      env: LITERAL_PATHSPEC_ENV2
+    });
+  } catch {
+  }
+  try {
+    await execa2("git", ["clean", "-fd", "--", ...uniqueFiles], {
+      cwd: worktreePath,
+      stdio: "pipe",
+      reject: false,
+      timeout: 3e4,
+      env: LITERAL_PATHSPEC_ENV2
+    });
+  } catch {
+  }
+}
+async function saveBestEffort(store, stageId, name, payload) {
+  try {
+    await store.save(stageId, name, "json", JSON.stringify(payload, null, 2));
+    return true;
+  } catch {
+    return false;
+  }
+}
+function createFailureDiagnostic(input) {
+  const lastIteration = input.iterationHistory.at(-1);
+  const failingGateCommand = lastIteration?.qualityGateCommandResults?.find(
+    (r) => r.exitCode !== 0
+  );
+  return {
+    stageId: input.stageId,
+    terminationReason: input.terminationReason,
+    errorMessage: input.error instanceof Error ? input.error.message : String(input.error),
+    errorStack: input.error instanceof Error ? input.error.stack : void 0,
+    lastIteration: lastIteration ? {
+      iteration: lastIteration.iteration,
+      changedFiles: lastIteration.changedFiles,
+      allowlistViolations: lastIteration.allowlistViolations,
+      qualityGateError: lastIteration.qualityGateError,
+      failingCommand: failingGateCommand ? {
+        command: failingGateCommand.command,
+        exitCode: failingGateCommand.exitCode,
+        outputTail: failingGateCommand.outputTail
+      } : void 0
+    } : void 0,
+    allowlist: input.allowlist,
+    totalIterations: input.iterationHistory.length,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function inferFailureTerminationReason(error, iterationHistory = []) {
+  const lastIterationSignal = iterationHistory.at(-1)?.terminationSignal;
+  if (lastIterationSignal) {
+    return lastIterationSignal;
+  }
+  if (error instanceof AutoloopTerminationError) {
+    return error.terminationSignal;
+  }
+  return "error";
+}
+async function inferTerminationReason(input) {
+  const lastIteration = input.iterationHistory.at(-1);
+  if (input.controllerTerminationReason) {
+    const controllerReason = input.controllerTerminationReason;
+    if (controllerReason === "completion_signal" || controllerReason === "semantic_complete" || controllerReason === "deterministic_complete" || controllerReason === "heuristic_complete" || controllerReason === "progress_stagnation") {
+    } else {
+      return mapControllerReasonToFlywheel(controllerReason);
+    }
+  }
+  if (lastIteration?.terminationSignal && lastIteration.terminationSignal !== "goal_satisfied") {
+    return lastIteration.terminationSignal;
+  }
+  if (input.gatesEnabled && input.iterationHistory.length > 0 && input.iterationHistory.at(-1)?.qualityGatePassed !== true) {
+    const errorText = input.iterationHistory.at(-1)?.error ?? "";
+    if (/timebox exhausted before quality gates/i.test(errorText)) {
+      return "timebox_exceeded";
+    }
+    return "quality_gate_failure";
+  }
+  const hasBaselineOnlyFailure = lastIteration?.qualityGateCommandResults?.some(
+    (gate) => gate.mustPass !== false && gate.passed === false && gate.isRegression === false
+  );
+  const hasPassingGateEvidence = lastIteration?.qualityGateCommandResults?.some(
+    (gate) => gate.mustPass !== false && gate.passed === true
+  );
+  if (hasBaselineOnlyFailure && !hasPassingGateEvidence) {
+    return "baseline_blocked";
+  }
+  if (lastIteration?.terminationSignal === "goal_satisfied") {
+    return "goal_satisfied";
+  }
+  if (input.controllerTerminationReason === "progress_stagnation") {
+    return "progress_stagnation";
+  }
+  if (input.requiresTests === true) {
+    const allChangedFiles = input.iterationHistory.flatMap((r) => r.changedFiles);
+    const testFiles = await detectTestFiles(allChangedFiles, input.testFilePatterns);
+    if (testFiles.length === 0) {
+      return "tests_required_not_met";
+    }
+  }
+  if (input.runtimeEvidenceCheck && !input.runtimeEvidenceCheck.passed) {
+    return "evidence_unsatisfied";
+  }
+  if (input.iterationHistory.length >= input.maxIterations) return "max_iterations_reached";
+  const lastTwo = input.loopIterations.slice(-2);
+  if (lastTwo.length === 2) {
+    const prev = lastTwo[0];
+    const curr = lastTwo[1];
+    const noDelta = Math.abs(curr.progress.score - prev.progress.score) < input.minProgress;
+    const bothNotSignificant = !prev.progress.isSignificant && !curr.progress.isSignificant;
+    const stable = curr.progress.trend === "stable";
+    if (stable && noDelta && bothNotSignificant) return "progress_stagnation";
+  }
+  if (input.controllerTerminationReason) {
+    if (!hasFlywheelSubstantiveCompletionEvidence(input) && isSuccessLikeControllerReason(input.controllerTerminationReason)) {
+      return "evidence_unsatisfied";
+    }
+    return mapControllerReasonToFlywheel(input.controllerTerminationReason);
+  }
+  return "error";
+}
+function hasFlywheelSubstantiveCompletionEvidence(input) {
+  if (input.iterationHistory.some(
+    (iteration) => iteration.changedFiles.length > 0 || iteration.qualityGatePassed === true || iteration.terminationSignal === "goal_satisfied"
+  )) {
+    return true;
+  }
+  return input.runtimeEvidenceConfigured === true && input.runtimeEvidenceCheck?.passed === true;
+}
+function computeAutoloopOutcome(input) {
+  const {
+    finalGateResults,
+    iterationHistory,
+    terminationReason,
+    allowlistMode,
+    repairAttempted,
+    repairSuccesses
+  } = input;
+  const failedMustPassGates = finalGateResults?.filter((r) => !r.passed && r.gate.mustPass && r.isRegression !== false).length ?? 0;
+  const failedWarnGates = finalGateResults?.filter((r) => !r.passed && !r.gate.mustPass).length ?? 0;
+  const baselineOnlyFailures = finalGateResults?.filter((r) => !r.passed && r.gate.mustPass && r.isRegression === false).length ?? 0;
+  const lastFailingGate = finalGateResults?.find((r) => !r.passed && r.isRegression !== false);
+  const gatesExecuted = finalGateResults !== void 0 && finalGateResults.length > 0;
+  const hadDrift = iterationHistory.some((r) => r.allowlistDrift === true);
+  let outcome;
+  let summary;
+  const terminationClassByReason = {
+    allowlist_violation: "allowlist_violation",
+    baseline_blocked: "quality_gate",
+    error: "execution_error",
+    duplicate_change_loop: "no_op_loop",
+    evidence_unsatisfied: "evidence_unsatisfied",
+    goal_satisfied: "success",
+    heuristic_complete: "success",
+    max_iterations_reached: "iteration_budget",
+    no_op_intervention_exceeded: "no_op_loop",
+    no_op_loop: "no_op_loop",
+    progress_stagnation: "progress_stagnation",
+    quality_gate_failure: "quality_gate",
+    resource_exhaustion: "resource_limit",
+    success: "success",
+    tests_required_not_met: "quality_gate",
+    timebox_exceeded: "timebox",
+    verification_unavailable: "verification_unavailable"
+  };
+  const terminationClass = terminationClassByReason[terminationReason];
+  if (terminationReason === "allowlist_violation" && allowlistMode === "strict") {
+    outcome = "red";
+    summary = "Hard allowlist violation (strict mode)";
+  } else if (terminationReason === "resource_exhaustion") {
+    outcome = "red";
+    summary = "Resource limit (memory/CPU/process) exhausted before completion";
+  } else if (terminationReason === "error") {
+    outcome = "red";
+    summary = "Unrecoverable execution error";
+  } else if (terminationReason === "verification_unavailable") {
+    outcome = "yellow";
+    summary = "Verification unavailable; completion is unverified by deterministic gates";
+  } else if (terminationReason === "baseline_blocked") {
+    outcome = "yellow";
+    summary = `${baselineOnlyFailures} baseline gate failure(s) remain; zero-green verification is not success`;
+  } else if (failedMustPassGates > 0) {
+    outcome = "yellow";
+    summary = `${failedMustPassGates} must-pass gate(s) still failing after ${repairAttempted ? "repair attempts" : "iterations"}`;
+  } else if (hadDrift && allowlistMode === "warn") {
+    outcome = "yellow";
+    summary = "Allowlist drift detected (warn mode)";
+  } else if (hadDrift && allowlistMode === "filter") {
+    outcome = "yellow";
+    summary = "Allowlist drift filtered (filter mode)";
+  } else if (failedWarnGates > 0) {
+    outcome = "yellow";
+    summary = `${failedWarnGates} warn-level gate(s) failing`;
+  } else if (!gatesExecuted) {
+    outcome = "yellow";
+    summary = "No deterministic quality gates were executed; completion is unverified by gates";
+  } else {
+    outcome = "green";
+    summary = baselineOnlyFailures > 0 ? `No new gate regressions; ${baselineOnlyFailures} baseline gate failure(s) remain` : `All gates passed${repairAttempted ? ` (after ${repairSuccesses} repair iteration(s))` : ""}`;
+  }
+  return {
+    outcome,
+    terminationClass,
+    failedMustPassGates,
+    failedWarnGates,
+    lastFailingGateId: lastFailingGate?.gate.id,
+    repairAttempted,
+    repairSuccesses,
+    hadDrift,
+    summary
+  };
+}
+function computeAggregateTimeMetrics(iterationHistory) {
+  if (iterationHistory.length === 0) {
+    return {
+      totalProviderMs: 0,
+      totalGateMs: 0,
+      totalRepairMs: 0,
+      totalTestMs: 0,
+      totalBuildMs: 0,
+      totalOverheadMs: 0,
+      avgIterationMs: 0,
+      noOpIterationCount: 0,
+      providerTimePct: 0,
+      deterministicTimePct: 0
+    };
+  }
+  let totalProviderMs = 0;
+  let totalGateMs = 0;
+  let totalRepairMs = 0;
+  let totalTestMs = 0;
+  let totalBuildMs = 0;
+  let totalOverheadMs = 0;
+  let totalDurationMs = 0;
+  let noOpIterationCount = 0;
+  for (const iter of iterationHistory) {
+    if (iter.timeBreakdown) {
+      totalProviderMs += iter.timeBreakdown.providerMs;
+      totalGateMs += iter.timeBreakdown.gateMs;
+      totalRepairMs += iter.timeBreakdown.repairMs;
+      totalTestMs += iter.timeBreakdown.testMs ?? 0;
+      totalBuildMs += iter.timeBreakdown.buildMs ?? 0;
+      totalOverheadMs += iter.timeBreakdown.overheadMs;
+    }
+    totalDurationMs += iter.durationMs;
+    if (iter.progressMetrics?.wasNoOp) {
+      noOpIterationCount++;
+    }
+  }
+  const avgIterationMs = totalDurationMs / iterationHistory.length;
+  const providerTimePct = totalDurationMs > 0 ? totalProviderMs / totalDurationMs * 100 : 0;
+  const deterministicMs = totalGateMs + totalRepairMs + totalTestMs + totalBuildMs;
+  const deterministicTimePct = totalDurationMs > 0 ? deterministicMs / totalDurationMs * 100 : 0;
+  return {
+    totalProviderMs,
+    totalGateMs,
+    totalRepairMs,
+    totalTestMs,
+    totalBuildMs,
+    totalOverheadMs,
+    avgIterationMs,
+    noOpIterationCount,
+    providerTimePct,
+    deterministicTimePct
+  };
+}
+function computeIterationProgressMetrics(input) {
+  const { changedFiles, qualityGate, previousIteration } = input;
+  const hadDiff = changedFiles.length > 0;
+  const wasNoOp = !hadDiff;
+  let failingTestsEnd;
+  let coverageEnd;
+  if (qualityGate?.commandResults) {
+    for (const result of qualityGate.commandResults) {
+      const isTestCommand = describeVerificationCommand(result.command).kind === "test";
+      if (isTestCommand && result.exitCode !== 0) {
+        const parsedFailingTestCount = parseFailingTestCount(result.command, result.outputTail);
+        if (parsedFailingTestCount !== void 0) {
+          failingTestsEnd = parsedFailingTestCount;
+        }
+      }
+    }
+  }
+  const failingTestsStart = previousIteration?.progressMetrics?.failingTestsEnd;
+  const failingTestsDelta = failingTestsStart !== void 0 && failingTestsEnd !== void 0 ? failingTestsEnd - failingTestsStart : void 0;
+  const coverageStart = previousIteration?.progressMetrics?.coverageEnd;
+  const coverageDelta = coverageStart !== void 0 && coverageEnd !== void 0 ? coverageEnd - coverageStart : void 0;
+  return {
+    failingTestsStart,
+    failingTestsEnd,
+    failingTestsDelta,
+    coverageStart,
+    coverageEnd,
+    coverageDelta,
+    hadDiff,
+    wasNoOp
+  };
+}
+function parseFailingTestCount(command, output) {
+  const descriptor = describeVerificationCommand(command);
+  if (descriptor.kind !== "test") return void 0;
+  const text = output?.trim();
+  if (!text) return void 0;
+  if (descriptor.language === "node") {
+    const vitestTestsLine = /^\s*Tests?\s+(\d+)\s+failed\b/im.exec(text);
+    if (vitestTestsLine?.[1]) return Number(vitestTestsLine[1]);
+    const jestTestsLine = /^\s*Tests?:.*?\b(\d+)\s+failed\b/im.exec(text);
+    if (jestTestsLine?.[1]) return Number(jestTestsLine[1]);
+  }
+  if (descriptor.language === "python") {
+    const pytestSummary = /^\s*=+\s+.*?\b([1-9]\d*)\s+failed\b.*?=+\s*$/im.exec(text) ?? /^\s*([1-9]\d*)\s+failed\b.*\bin\s+\d+(?:\.\d+)?s\s*$/im.exec(text);
+    if (pytestSummary?.[1]) return Number(pytestSummary[1]);
+  }
+  if (descriptor.language === "go") {
+    const goFailures = text.match(/^--- FAIL:/gm);
+    if (goFailures && goFailures.length > 0) return goFailures.length;
+  }
+  if (descriptor.language === "rust") {
+    const cargoSummary = /\btest result:\s+FAILED\..*?\b(\d+)\s+failed\b/im.exec(text);
+    if (cargoSummary?.[1]) return Number(cargoSummary[1]);
+  }
+  if (descriptor.language === "swift") {
+    const swiftSummary = /\bExecuted\s+\d+\s+tests?,\s+with\s+(\d+)\s+failures?\b/im.exec(text);
+    if (swiftSummary?.[1]) return Number(swiftSummary[1]);
+  }
+  return void 0;
+}
+
+export {
+  simpleArtifactToolPolicy,
+  mapControllerReasonToFlywheel,
+  formatRepairSuppressionWarning,
+  snapshotRepairSuppressions,
+  detectNewRepairSuppressions,
+  captureAutomaticRepairScopeBaseline,
+  normalizeGates,
+  runAllGates,
+  resolveFlywheelProvider,
+  selectDisplayTestFilePatterns,
+  selectPrimaryPromptLanguage,
+  detectTestFiles,
+  verifyRuntimeEvidence,
+  reconstructExhaustedAutoloopOutcome,
+  classifyAutoloopGateTypeForTest,
+  isAutoloopStage,
+  executeAutoloopStage,
+  isVerificationUnavailableError,
+  detectUnavailableGateVerification,
+  computeIterationProgressMetrics
+};
+//# sourceMappingURL=chunk-R7XDDX2A.js.map