@poetic-ai/poetic 1.42.1-bootstrap.0

package/dist/coverage-orchestrator-MNKHD6YC.js

@@ -0,0 +1,772 @@
+import {
+  extractFailedTestFiles,
+  scanCoverage
+} from "./chunk-CCV7BPSY.js";
+import {
+  COVERAGE_STOP_FILE,
+  COVERAGE_WORK_DIR,
+  generateCoverageWorkflow
+} from "./chunk-WDVTY4U6.js";
+import {
+  mergeWorkflowResult
+} from "./chunk-CVMVZWG4.js";
+import "./chunk-RJAAKDRX.js";
+import {
+  executeWorkflowFile
+} from "./chunk-EX3OM35G.js";
+import "./chunk-OMX5VL43.js";
+import "./chunk-Z476RATD.js";
+import "./chunk-UXZF3B7T.js";
+import "./chunk-OQ6K46CK.js";
+import "./chunk-6BM72ZMG.js";
+import "./chunk-LO3X5NLS.js";
+import "./chunk-CSLAS5GW.js";
+import "./chunk-RW7RVSDV.js";
+import "./chunk-OKBTRSZI.js";
+import "./chunk-FDVZLG6Z.js";
+import "./chunk-QNOB37UH.js";
+import "./chunk-4NA7FSTV.js";
+import "./chunk-SKHGYQ7W.js";
+import "./chunk-HY3ESWCA.js";
+import "./chunk-F7ER6ANO.js";
+import "./chunk-IFCBYECK.js";
+import "./chunk-HAC6EHZZ.js";
+import "./chunk-35P3W3JX.js";
+import "./chunk-G2PTLLEL.js";
+import "./chunk-NEDCMN7E.js";
+import "./chunk-BIGSACCY.js";
+import "./chunk-3LUMR3D3.js";
+import "./chunk-TK644IOG.js";
+import "./chunk-4SHKPCGK.js";
+import "./chunk-M3HQYKQX.js";
+import "./chunk-XUXVDPSZ.js";
+import "./chunk-5UCJARII.js";
+import "./chunk-3AOKYKA7.js";
+import "./chunk-ALAB3PBR.js";
+import "./chunk-BXI4NXL3.js";
+import "./chunk-LZBBXYWF.js";
+import "./chunk-TAOOYK3P.js";
+import "./chunk-FCNAS3W2.js";
+import "./chunk-SNLBO4BF.js";
+import "./chunk-P6VQROCO.js";
+import "./chunk-JEV6UI7H.js";
+import "./chunk-BPYMCIVD.js";
+import "./chunk-IUXNGKA6.js";
+import "./chunk-FFH5HHJU.js";
+import "./chunk-4HXKHDNH.js";
+import "./chunk-6V7HGQFZ.js";
+import "./chunk-I46EG2XQ.js";
+import "./chunk-S2MNWFAG.js";
+import "./chunk-GG6KJYW6.js";
+import "./chunk-IP7BYVUV.js";
+import "./chunk-BBHRN366.js";
+import "./chunk-L7E6XCRA.js";
+import "./chunk-PTH5E5XO.js";
+import "./chunk-HIHENQDX.js";
+import "./chunk-NGK6PEOG.js";
+import "./chunk-4CSS7WVI.js";
+import {
+  generateCompetitionId
+} from "./chunk-3A5PDH5L.js";
+import "./chunk-6EQKFDBH.js";
+import "./chunk-VTLNJQ44.js";
+import "./chunk-LWTN3WRV.js";
+import "./chunk-KQEBSK3T.js";
+import "./chunk-I4NPDSCB.js";
+import "./chunk-AX6GWE7V.js";
+import "./chunk-Y5677NDO.js";
+import "./chunk-RGROYC2G.js";
+import "./chunk-TFTGP7Z7.js";
+import "./chunk-CKP2Q3TP.js";
+import "./chunk-5LAMRH4X.js";
+import "./chunk-GJTWJNLV.js";
+import "./chunk-3M57DADF.js";
+import "./chunk-6QMUKUHH.js";
+import "./chunk-EQGIDAUF.js";
+import "./chunk-U62VCQGR.js";
+import "./chunk-7D7QT3BE.js";
+import "./chunk-T2SZELJL.js";
+import "./chunk-77I6G4CO.js";
+import "./chunk-NEQUQHOX.js";
+import "./chunk-OGMSYL6J.js";
+import "./chunk-ZIPWI2LY.js";
+import "./chunk-HMVQIPH3.js";
+import "./chunk-GHTZSQB7.js";
+import "./chunk-RE5VZDFQ.js";
+import "./chunk-4KKI477Q.js";
+import "./chunk-GOAQ2I7Y.js";
+import "./chunk-K54Y7MLK.js";
+import "./chunk-AHWAZ2MU.js";
+import "./chunk-CJHRFSNY.js";
+import "./chunk-TWYLVAS2.js";
+import "./chunk-SUZ7UYZH.js";
+import "./chunk-Y55LZN5U.js";
+import "./chunk-TDSEX5CF.js";
+import "./chunk-HK4AQZSR.js";
+import "./chunk-7QCZSLBH.js";
+import "./chunk-VXF4Q3FW.js";
+import "./chunk-JD6SIZED.js";
+import "./chunk-EJ4ZAWLV.js";
+import "./chunk-ASEP3M2W.js";
+import "./chunk-XZAMZUX5.js";
+import "./chunk-XHEKQENB.js";
+import "./chunk-UKMAFG7A.js";
+import "./chunk-3JWNRJSB.js";
+import "./chunk-RIKFAWZF.js";
+import "./chunk-HQLGXODD.js";
+import "./chunk-QVFV5IP2.js";
+import "./chunk-JKBHJQMT.js";
+import {
+  cleanupStaleWorktrees,
+  recoverPendingWorktrees
+} from "./chunk-V6YLL5WA.js";
+import "./chunk-4HN6DF7V.js";
+import "./chunk-66CIO2SV.js";
+import "./chunk-GXWAJQOJ.js";
+import "./chunk-BCZAENOH.js";
+import "./chunk-MFADRRTR.js";
+import "./chunk-RI4EX2QE.js";
+import "./chunk-ZZZUL4OF.js";
+import "./chunk-PIKLF7BM.js";
+import "./chunk-7NPSXSHO.js";
+import "./chunk-XUSRFFA7.js";
+import "./chunk-P7CQGPLS.js";
+import "./chunk-KNT72VR6.js";
+import "./chunk-3BCUNHKF.js";
+import "./chunk-OYZYO7TV.js";
+import "./chunk-VNSYKC25.js";
+import "./chunk-FEPIFY7D.js";
+import "./chunk-OPYFYTWQ.js";
+import "./chunk-UHT2KRG5.js";
+import "./chunk-DSFM56OA.js";
+import "./chunk-UGX7GI37.js";
+import "./chunk-HOYBYAOA.js";
+import "./chunk-6EDAJH2I.js";
+import "./chunk-3FLXLLB7.js";
+import "./chunk-WTLMSPBQ.js";
+import "./chunk-AG2Z2SUZ.js";
+import "./chunk-LWCBNGH6.js";
+import "./chunk-CQM3A35X.js";
+import "./chunk-FH7WOJAE.js";
+import "./chunk-U32HWI76.js";
+import "./chunk-APPNGGN7.js";
+import "./chunk-5HDP7XZG.js";
+import "./chunk-EK2U3YEG.js";
+import "./chunk-Y34DUC4A.js";
+import "./chunk-MYLH2S4G.js";
+import "./chunk-CYB6QDCT.js";
+import "./chunk-IC7I6YIJ.js";
+import "./chunk-B76KHLX6.js";
+import "./chunk-2XQXYBM2.js";
+import "./chunk-A722DEVA.js";
+import "./chunk-4SALLK63.js";
+import "./chunk-6Y5TWI7H.js";
+import "./chunk-TSPQONRT.js";
+import "./chunk-LFTQVYBB.js";
+import "./chunk-EJ42BNGY.js";
+import "./chunk-73NCTWKL.js";
+import "./chunk-VVGEPBPS.js";
+import "./chunk-E74LUIID.js";
+import "./chunk-ATVKCSGT.js";
+import "./chunk-72XCRQED.js";
+import "./chunk-66AGFTBQ.js";
+import "./chunk-AZQILSNQ.js";
+import "./chunk-CFBIG37O.js";
+import "./chunk-KT6VHSPF.js";
+import "./chunk-W4OMESPG.js";
+import "./chunk-X6UIEADS.js";
+import "./chunk-JOSYEJKY.js";
+import "./chunk-5REDMNLZ.js";
+import "./chunk-YQAAKTVH.js";
+import "./chunk-CLKSETWE.js";
+import "./chunk-TIBZPAD2.js";
+import "./chunk-6BTFXYRO.js";
+import "./chunk-QTCJ5CC5.js";
+import "./chunk-MWHF5V7U.js";
+import "./chunk-3FOZ2VHV.js";
+import "./chunk-P47VN5F4.js";
+import "./chunk-R2ZYWNW3.js";
+import "./chunk-QJYIHVXT.js";
+import "./chunk-4CUY7AFY.js";
+import "./chunk-MWK5UZQ3.js";
+import "./chunk-C3L6YQ7P.js";
+import "./chunk-L4427KOE.js";
+import "./chunk-STJOHHSF.js";
+import "./chunk-MN6PL4AN.js";
+import "./chunk-NS33V3IM.js";
+import "./chunk-UHRBTZYY.js";
+import "./chunk-MCPQNJMK.js";
+import "./chunk-H2AYQIHW.js";
+import "./chunk-FATUVIIN.js";
+import "./chunk-OIS7J26S.js";
+import "./chunk-IZZK3H6I.js";
+import "./chunk-25QL3M3L.js";
+import "./chunk-VBNCKCCI.js";
+import "./chunk-SZ7DL357.js";
+import "./chunk-LGHII5ET.js";
+import "./chunk-PJWJ3SAV.js";
+import "./chunk-NRLY536M.js";
+import "./chunk-7DNSNKJV.js";
+import "./chunk-HIO33P3G.js";
+import "./chunk-APV6MK5E.js";
+import "./chunk-ZYG7GGKO.js";
+import "./chunk-SQZRPY23.js";
+import "./chunk-E3NTPHEO.js";
+import "./chunk-4NXPXE62.js";
+import "./chunk-4VJITV4P.js";
+import "./chunk-GHHFDU2U.js";
+import "./chunk-R6W23LKN.js";
+import "./chunk-UH3JJSHK.js";
+import "./chunk-FC23CTXV.js";
+import "./chunk-36PEBZAF.js";
+import "./chunk-SURZ2WFE.js";
+import "./chunk-SP3LFU6B.js";
+import "./chunk-R4UWBC35.js";
+import "./chunk-2YFUIER7.js";
+import "./chunk-T6VPI2XP.js";
+import "./chunk-3733QTI7.js";
+import "./chunk-J62KPGII.js";
+import "./chunk-XAONGNST.js";
+import "./chunk-GAFJEYLK.js";
+import "./chunk-H6G7QRMQ.js";
+import "./chunk-J6P3FWWW.js";
+import "./chunk-YWNAHW24.js";
+import "./chunk-IATQ7NBI.js";
+import "./chunk-BSE4R6XD.js";
+import "./chunk-KAT4RXUT.js";
+import "./chunk-JSWMRQYG.js";
+import "./chunk-XGYF2QMZ.js";
+import "./chunk-72YTZMAM.js";
+import "./chunk-S2VQCZO4.js";
+import "./chunk-WMPU2UOV.js";
+import "./chunk-JQD5VYKR.js";
+import "./chunk-XT2ZQVTC.js";
+import "./chunk-YGXKOBQQ.js";
+import "./chunk-V72RMBM4.js";
+import "./chunk-ZDTGECTN.js";
+import "./chunk-G36W2T2S.js";
+import "./chunk-GKN3HMN4.js";
+import "./chunk-QVZMFDYG.js";
+import "./chunk-S54MKU6V.js";
+import "./chunk-3S62LLWJ.js";
+import "./chunk-45FPSA3B.js";
+import "./chunk-YMX76IOS.js";
+import "./chunk-6Y5U7UFY.js";
+import "./chunk-XV7NZL4B.js";
+import "./chunk-CD7ISXA4.js";
+import "./chunk-QGJDMEOV.js";
+import "./chunk-FEQ4HXL7.js";
+import "./chunk-6TZJRKNW.js";
+import "./chunk-2AICM4P3.js";
+import "./chunk-5WCQRDRB.js";
+import "./chunk-5WRLK5KW.js";
+import "./chunk-C57KJOUQ.js";
+import "./chunk-DF5SLDE4.js";
+import "./chunk-TGON4N4O.js";
+import "./chunk-I5WRT7ZR.js";
+import "./chunk-A3YGID55.js";
+import "./chunk-5EERLVZB.js";
+import "./chunk-XQD2B6BB.js";
+import "./chunk-34CNP2HB.js";
+import "./chunk-KNDYMVWN.js";
+import "./chunk-RWREC3KJ.js";
+import "./chunk-QU6JQJMH.js";
+import "./chunk-7R2WLDOS.js";
+import "./chunk-LAMKBTXX.js";
+import "./chunk-FD4ERYEG.js";
+import "./chunk-KTMW65UX.js";
+import "./chunk-GNH3QGTL.js";
+import "./chunk-UDMS5AD3.js";
+import "./chunk-MWHLBPNU.js";
+import "./chunk-JLS65NUQ.js";
+import "./chunk-TRSVUPCX.js";
+import "./chunk-FKAUPHMR.js";
+import "./chunk-TSXGRLPR.js";
+import "./chunk-LUVKFFWR.js";
+import "./chunk-ENRGKNR5.js";
+import "./chunk-XB5YLCLB.js";
+import "./chunk-QOCOVLUH.js";
+import "./chunk-2VSQMRCB.js";
+import "./chunk-ON3G73BU.js";
+import "./chunk-3G6FZCRF.js";
+import "./chunk-N5DX4JAK.js";
+import "./chunk-4BIPZBT7.js";
+import "./chunk-7GDRQBQC.js";
+import "./chunk-PGSPX4SU.js";
+import "./chunk-AT4TNPWW.js";
+import "./chunk-GSGD5E4C.js";
+import "./chunk-UI2F6DJ5.js";
+import "./chunk-4BTDUT2S.js";
+import "./chunk-L6OM4A22.js";
+import "./chunk-G4THLFV3.js";
+import "./chunk-RGWHUI5E.js";
+import "./chunk-UUH2RVKS.js";
+import "./chunk-LEIIWPWQ.js";
+import "./chunk-L7JZLXQL.js";
+import "./chunk-IZYIQQ7X.js";
+import "./chunk-JPKSXKNB.js";
+import "./chunk-TAJPCXSB.js";
+import "./chunk-XZE4XARH.js";
+import "./chunk-EJGCZGUF.js";
+import "./chunk-LPITVM7M.js";
+import {
+  POETIC_COVERAGE_FAILURE_COOLDOWN_MS,
+  readEnv
+} from "./chunk-5DLKYTQX.js";
+import "./chunk-PZ5AY32C.js";
+
+// src/automation/coverage-orchestrator.ts
+import { execSync } from "child_process";
+import fs from "fs";
+import path from "path";
+async function runCoverageLoop(repoRoot, options, log) {
+  const startMs = Date.now();
+  const maxMs = options.maxHours > 0 ? options.maxHours * 36e5 : 0;
+  const iterations = [];
+  const failureMap = /* @__PURE__ */ new Map();
+  const FAILURE_COOLDOWN_MS = readEnv(POETIC_COVERAGE_FAILURE_COOLDOWN_MS).value ?? 6e5;
+  let exitReason = "error";
+  let totalCompleted = 0;
+  let totalFailed = 0;
+  let lastRepoAverage;
+  for (let iter = 1; ; iter++) {
+    if (shouldStop(repoRoot)) {
+      exitReason = "stop_file";
+      log.warn("Stop file detected; exiting.");
+      break;
+    }
+    if (maxMs > 0 && Date.now() - startMs >= maxMs) {
+      exitReason = "time_limit";
+      log.warn(`Reached max runtime (${options.maxHours}h); exiting.`);
+      break;
+    }
+    if (options.maxIterations > 0 && iter > options.maxIterations) {
+      exitReason = "iteration_limit";
+      log.info(`Reached max iterations (${options.maxIterations}); exiting.`);
+      break;
+    }
+    const iterStartMs = Date.now();
+    log.info(`--- Iteration ${iter} ---`);
+    try {
+      await recoverPendingWorktrees({ dryRun: false });
+    } catch (error) {
+      log.warn(
+        `recoverPendingWorktrees failed: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+    try {
+      await cleanupStaleWorktrees({ repoCwd: repoRoot, dryRun: false });
+    } catch (error) {
+      log.warn(
+        `cleanupStaleWorktrees failed: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+    log.info("Phase: healthcheck");
+    const healthResult = await runHealthcheck(repoRoot, options, log);
+    let queue = [];
+    let testsWereFixed = false;
+    if (!healthResult.passed && healthResult.failedTestFiles.length > 0) {
+      log.info(`Phase: fix-tests (${healthResult.failedTestFiles.length} failing test files)`);
+      const fixResults = await dispatchFixTests(
+        repoRoot,
+        healthResult.failedTestFiles,
+        options,
+        failureMap,
+        FAILURE_COOLDOWN_MS,
+        log
+      );
+      totalCompleted += fixResults.filter((r) => r.success).length;
+      totalFailed += fixResults.filter((r) => !r.success).length;
+      updateFailureMap(failureMap, fixResults);
+      testsWereFixed = fixResults.some((r) => r.success);
+    }
+    log.info("Phase: scan coverage");
+    const coverageDir = path.join(repoRoot, COVERAGE_WORK_DIR, `scan-${iter}`);
+    let scanResult;
+    if (!testsWereFixed && healthResult.coverageSummaryPath && fs.existsSync(healthResult.coverageSummaryPath)) {
+      const { parseCoverageSummary } = await import("./coverage-scanner-YVD62MLH.js");
+      scanResult = parseCoverageSummary(healthResult.coverageSummaryPath, options.threshold);
+      log.info(
+        `Reusing healthcheck coverage data: ${scanResult.queue.length} files below threshold`
+      );
+    } else {
+      if (testsWereFixed) {
+        log.info("Rescanning coverage after test fixes (healthcheck summary is stale)");
+      }
+      scanResult = await scanCoverage(repoRoot, options.threshold, coverageDir, {
+        verbose: options.verbose
+      });
+    }
+    lastRepoAverage = scanResult.repoWideAverage;
+    if (scanResult.missing) {
+      log.error("Coverage summary file is missing or unreadable; treating as scan failure.");
+      exitReason = "error";
+      break;
+    }
+    if (scanResult.queue.length === 0) {
+      log.info("All files above threshold; done.");
+      exitReason = "all_above_threshold";
+      iterations.push({
+        iteration: iter,
+        phase: "complete",
+        filesTargeted: 0,
+        filesCompleted: 0,
+        filesFailed: 0,
+        filesRetried: 0,
+        durationMs: Date.now() - iterStartMs
+      });
+      break;
+    }
+    queue = filterRetryable(scanResult.queue, failureMap, FAILURE_COOLDOWN_MS);
+    if (queue.length === 0) {
+      const cooldownMs = getNextRetryDelayMs(scanResult.queue, failureMap, FAILURE_COOLDOWN_MS);
+      log.info(
+        `All ${scanResult.queue.length} below-threshold files are cooling down; retrying in ${formatMs(cooldownMs)}.`
+      );
+      ageFailures(failureMap, []);
+      iterations.push({
+        iteration: iter,
+        phase: "scan",
+        filesTargeted: scanResult.queue.length,
+        filesCompleted: 0,
+        filesFailed: 0,
+        filesRetried: 0,
+        durationMs: Date.now() - iterStartMs
+      });
+      await sleep(cooldownMs);
+      continue;
+    }
+    log.info(
+      `Phase: dispatch (${queue.length} files below ${options.threshold}%, repo avg: ${scanResult.repoWideAverage}%, workers: ${options.workers})`
+    );
+    const workerResults = await dispatchCoverageWorkers(repoRoot, queue, options, log);
+    const completed = workerResults.filter((r) => r.success).length;
+    const failed = workerResults.filter((r) => !r.success).length;
+    totalCompleted += completed;
+    totalFailed += failed;
+    updateFailureMap(failureMap, workerResults);
+    ageFailures(failureMap, workerResults);
+    const retriedCount = workerResults.filter((r) => {
+      const entry = failureMap.get(r.file);
+      return entry && entry.count > 1;
+    }).length;
+    iterations.push({
+      iteration: iter,
+      phase: "dispatch",
+      filesTargeted: queue.length,
+      filesCompleted: completed,
+      filesFailed: failed,
+      filesRetried: retriedCount,
+      durationMs: Date.now() - iterStartMs
+    });
+    log.info(
+      `Iteration ${iter} complete: ${completed} succeeded, ${failed} failed, ${retriedCount} retried`
+    );
+  }
+  return {
+    iterations,
+    totalFilesCompleted: totalCompleted,
+    totalFilesFailed: totalFailed,
+    totalDurationMs: Date.now() - startMs,
+    finalRepoWideAverage: lastRepoAverage,
+    exitReason
+  };
+}
+async function runHealthcheck(repoRoot, _options, log) {
+  const startMs = Date.now();
+  const logDir = path.join(repoRoot, COVERAGE_WORK_DIR);
+  fs.mkdirSync(logDir, { recursive: true });
+  const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const logPath = path.join(logDir, `healthcheck-${ts}.log`);
+  const coverageDir = path.join(logDir, `healthcheck-cov-${ts}`);
+  const quotedCoverageDir = `'${coverageDir.replace(/'/g, "'\\''")}'`;
+  const cmd = [
+    "node scripts/dynamic-node-options.mjs vitest run",
+    "--config vitest.partial.config.ts",
+    "tests/unit/telemetry tests/unit/core tests/unit/orchestrator tests/unit/automation tests/unit/quality tests/unit/types tests/unit/utils",
+    "--coverage.enabled --coverage.reporter json-summary",
+    `--coverage.reportsDirectory ${quotedCoverageDir}`
+  ].join(" ");
+  let passed = false;
+  try {
+    execSync(cmd, {
+      cwd: repoRoot,
+      timeout: 6e5,
+      stdio: ["pipe", "pipe", "pipe"],
+      env: process.env
+    });
+    passed = true;
+  } catch (err) {
+    const execErr = err;
+    const output = [execErr.stdout?.toString() ?? "", execErr.stderr?.toString() ?? ""].join("\n");
+    fs.writeFileSync(logPath, output, "utf8");
+  }
+  const coverageSummaryPath = path.join(coverageDir, "coverage-summary.json");
+  const failedTestFiles = passed ? [] : extractFailedTestFiles(logPath);
+  if (passed) {
+    log.info("Healthcheck passed");
+  } else {
+    log.warn(`Healthcheck failed: ${failedTestFiles.length} test file(s) failing`);
+  }
+  return {
+    passed,
+    failedTestFiles,
+    coverageSummaryPath: fs.existsSync(coverageSummaryPath) ? coverageSummaryPath : void 0,
+    logPath,
+    durationMs: Date.now() - startMs
+  };
+}
+async function dispatchFixTests(repoRoot, failedTestFiles, opts, failureMap, cooldownMs, log) {
+  const outDir = path.join(repoRoot, COVERAGE_WORK_DIR, "workflows");
+  const workflows = [];
+  for (let i = 0; i < failedTestFiles.length; i++) {
+    const testFile = failedTestFiles[i];
+    if (isInCooldown(testFile, failureMap, cooldownMs)) {
+      log.info(`Skipping ${testFile} (failure cooldown)`);
+      continue;
+    }
+    const provider = opts.providers[i % opts.providers.length];
+    const importedSources = findImportedSources(repoRoot, testFile);
+    const wf = generateCoverageWorkflow({
+      sourceFile: testFile,
+      provider,
+      threshold: opts.threshold,
+      repoRoot,
+      outDir,
+      mode: "fix-tests",
+      testFileOverride: testFile,
+      importedSources
+    });
+    workflows.push(wf);
+  }
+  return executeWorkflowBatch(repoRoot, workflows, opts.workers, log);
+}
+async function dispatchCoverageWorkers(repoRoot, queue, options, log) {
+  const outDir = path.join(repoRoot, COVERAGE_WORK_DIR, "workflows");
+  const workflows = [];
+  for (let i = 0; i < queue.length; i++) {
+    const file = queue[i];
+    const provider = options.providers[i % options.providers.length];
+    const wf = generateCoverageWorkflow({
+      sourceFile: file.file,
+      provider,
+      threshold: options.threshold,
+      repoRoot,
+      outDir,
+      mode: "coverage"
+    });
+    workflows.push(wf);
+  }
+  return executeWorkflowBatch(repoRoot, workflows, options.workers, log);
+}
+async function executeWorkflowBatch(repoRoot, workflows, maxWorkers, log) {
+  const executedResults = [];
+  for (let i = 0; i < workflows.length; i += maxWorkers) {
+    const batch = workflows.slice(i, i + maxWorkers);
+    const batchPromises = batch.map((wf) => executeSingleWorkflow(repoRoot, wf, log));
+    const batchResults = await Promise.allSettled(batchPromises);
+    for (let j = 0; j < batchResults.length; j++) {
+      const result = batchResults[j];
+      const wf = batch[j];
+      if (result.status === "fulfilled") {
+        executedResults.push(result.value);
+      } else {
+        executedResults.push({
+          file: wf.sourceFile,
+          success: false,
+          workflowId: void 0,
+          merged: false,
+          durationMs: 0,
+          error: result.reason instanceof Error ? result.reason.message : String(result.reason)
+        });
+      }
+    }
+  }
+  const mergedResults = [];
+  for (const result of executedResults) {
+    if (!result.success || !result.workflowId) {
+      mergedResults.push(result);
+      continue;
+    }
+    try {
+      const merge = await mergeWorkflowResult({
+        workflowId: result.workflowId
+      });
+      if (!merge.success) {
+        log.warn(`Worker: ${result.file} merge failed (workflow=${result.workflowId})`);
+        mergedResults.push({
+          ...result,
+          success: false,
+          merged: false,
+          error: merge.error ?? "merge failed"
+        });
+        continue;
+      }
+      log.info(`Worker: ${result.file} merged (workflow=${result.workflowId})`);
+      mergedResults.push({
+        ...result,
+        merged: true
+      });
+    } catch (error) {
+      log.warn(`Worker: ${result.file} merge failed (workflow=${result.workflowId})`);
+      mergedResults.push({
+        ...result,
+        success: false,
+        merged: false,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  return mergedResults;
+}
+async function executeSingleWorkflow(_repoRoot, wf, log) {
+  const startMs = Date.now();
+  const workflowId = generateCompetitionId();
+  log.info(`Worker: executing ${wf.sourceFile} (provider=${wf.provider})`);
+  try {
+    const result = await executeWorkflowFile(wf.filePath, {
+      workflowId,
+      verbose: true,
+      preflight: {
+        repoCleanMode: "warn"
+      },
+      manifest: {
+        sourceType: "direct",
+        generatedYamlPath: wf.filePath,
+        originalCommand: ["poetic", "coverage"]
+      }
+    });
+    if (!result.success) {
+      log.warn(`Worker: ${wf.sourceFile} failed (workflow=${workflowId})`);
+      return {
+        file: wf.sourceFile,
+        success: false,
+        workflowId,
+        merged: false,
+        durationMs: Date.now() - startMs,
+        error: result.errors.join("; ") || "flywheel execution failed"
+      };
+    }
+    return {
+      file: wf.sourceFile,
+      success: true,
+      workflowId,
+      merged: false,
+      durationMs: Date.now() - startMs,
+      error: void 0
+    };
+  } catch (error) {
+    log.warn(`Worker: ${wf.sourceFile} failed (workflow=${workflowId})`);
+    return {
+      file: wf.sourceFile,
+      success: false,
+      workflowId,
+      merged: false,
+      durationMs: Date.now() - startMs,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function updateFailureMap(failureMap, results) {
+  for (const r of results) {
+    if (!r.success) {
+      const existing = failureMap.get(r.file);
+      failureMap.set(r.file, {
+        count: (existing?.count ?? 0) + 1,
+        lastFailedMs: Date.now()
+      });
+    } else {
+      failureMap.delete(r.file);
+    }
+  }
+}
+function ageFailures(failureMap, currentResults) {
+  const attempted = new Set(currentResults.map((r) => r.file));
+  for (const [file, entry] of failureMap) {
+    if (!attempted.has(file)) {
+      entry.count = Math.max(1, Math.floor(entry.count / 2));
+    }
+  }
+}
+function isInCooldown(file, failureMap, baseCooldownMs) {
+  const entry = failureMap.get(file);
+  if (!entry) return false;
+  const multiplier = Math.min(entry.count, 6);
+  const cooldown = baseCooldownMs * multiplier;
+  return Date.now() - entry.lastFailedMs < cooldown;
+}
+function filterRetryable(queue, failureMap, baseCooldownMs) {
+  return queue.filter((m) => !isInCooldown(m.file, failureMap, baseCooldownMs));
+}
+function getCooldownRemainingMs(file, failureMap, baseCooldownMs) {
+  const entry = failureMap.get(file);
+  if (!entry) return 0;
+  const multiplier = Math.min(entry.count, 6);
+  const cooldown = baseCooldownMs * multiplier;
+  return Math.max(0, cooldown - (Date.now() - entry.lastFailedMs));
+}
+function getNextRetryDelayMs(queue, failureMap, baseCooldownMs) {
+  const remaining = queue.map((item) => getCooldownRemainingMs(item.file, failureMap, baseCooldownMs)).filter((ms) => ms > 0);
+  if (remaining.length === 0) return 0;
+  return Math.max(25, Math.min(Math.min(...remaining), 3e4));
+}
+function sleep(ms) {
+  if (ms <= 0) return Promise.resolve();
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function formatMs(ms) {
+  if (ms < 1e3) return `${ms}ms`;
+  return `${Math.ceil(ms / 1e3)}s`;
+}
+function findImportedSources(repoRoot, testFile) {
+  const absPath = path.join(repoRoot, testFile);
+  if (!fs.existsSync(absPath)) {
+    return [];
+  }
+  const content = fs.readFileSync(absPath, "utf8");
+  const importerDir = path.dirname(absPath);
+  const imports = /* @__PURE__ */ new Set();
+  const pattern = /\b(?:import|export)\s+(?:[^'"]*?\s+from\s+)?['"]([^'"]+)['"]|require\(\s*['"]([^'"]+)['"]\s*\)|import\(\s*['"]([^'"]+)['"]\s*\)/g;
+  for (const match of content.matchAll(pattern)) {
+    const specifier = match[1] ?? match[2] ?? match[3];
+    if (!specifier || !specifier.startsWith(".")) {
+      continue;
+    }
+    const resolved = resolveImportedSource(repoRoot, importerDir, specifier);
+    if (resolved) {
+      imports.add(resolved);
+    }
+  }
+  return [...imports].sort();
+}
+function resolveImportedSource(repoRoot, importerDir, specifier) {
+  const base = path.resolve(importerDir, specifier);
+  const candidates = [
+    base,
+    `${base}.ts`,
+    `${base}.tsx`,
+    `${base}.js`,
+    `${base}.mts`,
+    path.join(base, "index.ts"),
+    path.join(base, "index.tsx"),
+    path.join(base, "index.js")
+  ];
+  for (const candidate of candidates) {
+    if (!fs.existsSync(candidate)) {
+      continue;
+    }
+    const relative = path.relative(repoRoot, candidate).split(path.sep).join("/");
+    if (relative.startsWith("src/")) {
+      return relative.replace(/\.js$/u, ".ts");
+    }
+  }
+  return void 0;
+}
+function shouldStop(repoRoot) {
+  return fs.existsSync(path.join(repoRoot, COVERAGE_STOP_FILE));
+}
+export {
+  findImportedSources,
+  runCoverageLoop
+};
+//# sourceMappingURL=coverage-orchestrator-MNKHD6YC.js.map