@poetic-ai/poetic 1.42.1-bootstrap.0

package/dist/chunk-WGXYDLMX.js

@@ -0,0 +1,4386 @@
+import {
+  ProcessLifecycleManager,
+  parseCitationTrace,
+  serializeCitationTrace
+} from "./chunk-PA6BCSOX.js";
+import {
+  AutomaticPromptOptimizer
+} from "./chunk-VCAUV5XQ.js";
+import {
+  detectHostConcurrencyBudget
+} from "./chunk-PYITM4N2.js";
+import {
+  LocalExecutor,
+  WorkspaceAgentRunner
+} from "./chunk-BIGSACCY.js";
+import {
+  GitHubPRManager
+} from "./chunk-5UCJARII.js";
+import {
+  enqueueRemoteBranchCleanup,
+  isRemoteBranchMissingError,
+  isRetryableRemoteDeleteError,
+  resolveExpectedRemoteShaForQueuedBranch
+} from "./chunk-BXI4NXL3.js";
+import {
+  UnifiedCostTracker
+} from "./chunk-FCNAS3W2.js";
+import {
+  WORKER_EXIT_DRAIN_MS,
+  applyComplementaryPatchToWinnerWorktree,
+  buildSynthesisTelemetrySnapshot,
+  countCompletedCompetitionObservations,
+  createLocalVariantResourceManager,
+  didSynthesisArtifactSucceed,
+  resolveLocalWorktreeConcurrency,
+  resolveSynthesisOutcomeStatusForArtifact,
+  resolveSynthesisSelectedVariants,
+  sealVariantResultSnapshot,
+  toConcurrencyProviderId
+} from "./chunk-BPYMCIVD.js";
+import {
+  createEvaluationHandleFinalState,
+  finalizeEvaluationHandle,
+  initEvaluationHandle,
+  isDurableHandleCompletion,
+  updateEvaluationHandleWithResult
+} from "./chunk-4HXKHDNH.js";
+import {
+  sanitizeSynthesisArtifactForPersistence
+} from "./chunk-GG6KJYW6.js";
+import {
+  ProviderAwareResourceManager
+} from "./chunk-L7E6XCRA.js";
+import {
+  UniversalOutputValidator,
+  VariantOrchestrator
+} from "./chunk-3A5PDH5L.js";
+import {
+  ConfigManager
+} from "./chunk-GJTWJNLV.js";
+import {
+  recordProviderRateLimit
+} from "./chunk-GHTZSQB7.js";
+import {
+  UniversalCostCalculator
+} from "./chunk-ASEP3M2W.js";
+import {
+  getEvaluationQualityScore,
+  getEvaluationRankingScore,
+  getEvaluationRankingScoreOrZero
+} from "./chunk-4SALLK63.js";
+import {
+  buildProjectVerificationGuidance
+} from "./chunk-MCPQNJMK.js";
+import {
+  resolveSynthesisModel
+} from "./chunk-IZZK3H6I.js";
+import {
+  getProcessLifecycleManager,
+  setProcessLifecycleManager
+} from "./chunk-SQZRPY23.js";
+import {
+  matchesErrorPattern
+} from "./chunk-2YFUIER7.js";
+import {
+  TelemetryLogger
+} from "./chunk-T6VPI2XP.js";
+import {
+  formatVariantIdentifier,
+  formatVariantIdentifierFromResult
+} from "./chunk-YWNAHW24.js";
+import {
+  parseJsonWithContext
+} from "./chunk-QVZMFDYG.js";
+import {
+  calculateRetryDelayMs,
+  retryOperation
+} from "./chunk-C57KJOUQ.js";
+import {
+  pruneGitWorktreeEntries
+} from "./chunk-5EERLVZB.js";
+import {
+  isProtectedPipelineBranch
+} from "./chunk-XQD2B6BB.js";
+import {
+  isPoeticOwnedBranch,
+  poeticVariantBranchName,
+  poeticVariantBranchPrefix
+} from "./chunk-34CNP2HB.js";
+import {
+  runVerifyCommands
+} from "./chunk-QU6JQJMH.js";
+import {
+  MAX_PER_VARIANT_TIMEOUT_MINUTES
+} from "./chunk-LAMKBTXX.js";
+import {
+  detectProjectCapabilities,
+  hasProjectLanguage
+} from "./chunk-GNH3QGTL.js";
+import {
+  isQuietOutputRequested,
+  isVerboseOutputRequested
+} from "./chunk-FKAUPHMR.js";
+import {
+  toVariantSlug
+} from "./chunk-TSXGRLPR.js";
+import {
+  CompetitionTimeoutError
+} from "./chunk-LUVKFFWR.js";
+import {
+  getRuntimeEnv
+} from "./chunk-ENRGKNR5.js";
+import {
+  LabPathResolver
+} from "./chunk-7GDRQBQC.js";
+import {
+  rethrowConfigValidityError
+} from "./chunk-AT4TNPWW.js";
+import {
+  resolvePoeticDirFromContext
+} from "./chunk-UI2F6DJ5.js";
+import {
+  findProjectRoot
+} from "./chunk-L6OM4A22.js";
+import {
+  debugLog,
+  emitWarning
+} from "./chunk-EJGCZGUF.js";
+
+// src/orchestrator/pr-workflow-coordinator-impl-core.ts
+import fs from "fs/promises";
+import chalk3 from "chalk";
+import { execa } from "execa";
+
+// src/config/validation-helpers.ts
+function validateTimeout(value, unit, options = {}) {
+  const {
+    defaultMs = 3e5,
+    // 5 minutes default
+    minMs = 1e3,
+    // 1 second minimum
+    maxMs = 72e5,
+    // 2 hours maximum
+    fieldName = "timeout"
+  } = options;
+  if (value === void 0 || value === null) {
+    return defaultMs;
+  }
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new Error(`${fieldName} must be a finite number, got: ${value}`);
+  }
+  let timeoutMs;
+  switch (unit) {
+    case "milliseconds":
+      timeoutMs = value;
+      break;
+    case "seconds":
+      timeoutMs = value * 1e3;
+      break;
+    case "minutes":
+      timeoutMs = value * 60 * 1e3;
+      break;
+    default:
+      throw new Error(`Invalid timeout unit: ${unit}`);
+  }
+  if (timeoutMs < 0) {
+    throw new Error(`${fieldName} must be non-negative, got: ${value} ${unit}`);
+  }
+  if (timeoutMs < minMs) {
+    throw new Error(
+      `${fieldName} (${timeoutMs}ms) is below minimum (${minMs}ms). Provide at least ${minMs / 1e3}s.`
+    );
+  }
+  if (timeoutMs > maxMs) {
+    throw new Error(
+      `${fieldName} (${timeoutMs}ms) exceeds maximum (${maxMs}ms). Provide at most ${maxMs / 6e4} minutes.`
+    );
+  }
+  return Math.round(timeoutMs);
+}
+function validateVerbosity(verboseBoolean, verbosityEnum) {
+  if (verbosityEnum !== void 0) {
+    const validLevels = ["silent", "minimal", "normal", "detailed", "debug"];
+    if (!validLevels.includes(verbosityEnum)) {
+      throw new Error(
+        `Invalid verbosity level: ${verbosityEnum}. Must be one of: ${validLevels.join(", ")}`
+      );
+    }
+    return verbosityEnum;
+  }
+  if (verboseBoolean === true) {
+    return "detailed";
+  }
+  if (verboseBoolean === false) {
+    return "normal";
+  }
+  return "normal";
+}
+function validatePercentage(value, fieldName, options = {}) {
+  const {
+    min = 0,
+    max = 100,
+    defaultValue = min,
+    fieldName: name = fieldName,
+    allowFractional = false
+  } = options;
+  if (value === void 0 || value === null) {
+    return defaultValue;
+  }
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new Error(`${name} must be a finite number, got: ${value}`);
+  }
+  if (value < min || value > max) {
+    throw new Error(`${name} must be between ${min} and ${max}, got: ${value}`);
+  }
+  if (!allowFractional && !Number.isInteger(value)) {
+    throw new Error(`${name} must be an integer, got: ${value}`);
+  }
+  return value;
+}
+function validateConfidence(value, options = {}) {
+  if (value === void 0 || value === null) {
+    return options.defaultValue ?? 85;
+  }
+  const fieldName = options.fieldName ?? "confidence";
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new Error(`${fieldName} must be a finite number, got: ${value}`);
+  }
+  if (value >= 0 && value <= 1) {
+    return Math.round(value * 100);
+  }
+  return validatePercentage(value, fieldName, {
+    min: 0,
+    max: 100,
+    allowFractional: false
+  });
+}
+
+// src/orchestrator/dependency-graph-resolver.ts
+var DependencyGraphResolver = class {
+  /**
+   * Builds a dependency graph from task specifications
+   *
+   * Algorithm:
+   * 1. Create nodes with initial state (O(V))
+   * 2. Build adjacency list by reversing dependencies (O(E))
+   * 3. Compute topological levels via Kahn's algorithm (O(V+E))
+   *
+   * Complexity: O(V+E) where V = tasks, E = dependencies
+   *
+   * @param tasks - Array of task dependency specifications
+   * @returns Complete dependency graph with topological levels
+   *
+   * @example
+   * ```typescript
+   * const graph = resolver.buildGraph([
+   *   { id: "task1", dependencies: [] },
+   *   { id: "task2", dependencies: ["task1"] }
+   * ]);
+   * // graph.nodes.get("task1").topologicalLevel === 0
+   * // graph.nodes.get("task2").topologicalLevel === 1
+   * ```
+   */
+  buildGraph(tasks) {
+    const nodes = /* @__PURE__ */ new Map();
+    const adjacency = {};
+    for (const task of tasks) {
+      nodes.set(task.id, {
+        id: task.id,
+        state: task.dependencies.length === 0 ? "ready" : "pending",
+        dependencies: [...task.dependencies],
+        // Defensive copy
+        dependents: [],
+        // Will be populated below
+        topologicalLevel: -1,
+        // Will be computed below
+        metadata: task.metadata ? { ...task.metadata } : void 0
+      });
+      adjacency[task.id] = [];
+    }
+    for (const task of tasks) {
+      for (const depId of task.dependencies) {
+        const depNode = nodes.get(depId);
+        if (depNode) {
+          depNode.dependents.push(task.id);
+          if (!adjacency[depId]) {
+            adjacency[depId] = [];
+          }
+          const depAdjacency = adjacency[depId];
+          if (depAdjacency) {
+            depAdjacency.push(task.id);
+          }
+        }
+      }
+    }
+    this.computeTopologicalLevels(nodes, adjacency);
+    return { nodes, adjacency };
+  }
+  /**
+   * Computes topological levels using Kahn's algorithm
+   *
+   * Algorithm (modified Kahn's for level assignment):
+   * 1. Start with tasks that have no dependencies (level 0)
+   * 2. Process tasks level by level
+   * 3. When all dependencies of a task are processed, assign it to next level
+   * 4. Repeat until all tasks are assigned
+   *
+   * Complexity: O(V+E)
+   *
+   * Side effect: Updates topologicalLevel field in nodes
+   *
+   * @private
+   */
+  computeTopologicalLevels(nodes, adjacency) {
+    const inDegree = /* @__PURE__ */ new Map();
+    for (const [id, node] of nodes.entries()) {
+      inDegree.set(id, node.dependencies.length);
+    }
+    let currentLevel = [];
+    for (const [id, degree] of inDegree.entries()) {
+      if (degree === 0) {
+        currentLevel.push(id);
+        const node = nodes.get(id);
+        if (node) {
+          node.topologicalLevel = 0;
+        }
+      }
+    }
+    let level = 0;
+    while (currentLevel.length > 0) {
+      const nextLevel = [];
+      for (const taskId of currentLevel) {
+        const dependents = adjacency[taskId] || [];
+        for (const depId of dependents) {
+          const currentDegree = inDegree.get(depId) ?? 0;
+          const newDegree = currentDegree - 1;
+          inDegree.set(depId, newDegree);
+          if (newDegree === 0) {
+            nextLevel.push(depId);
+            const node = nodes.get(depId);
+            if (node) {
+              node.topologicalLevel = level + 1;
+            }
+          }
+        }
+      }
+      currentLevel = nextLevel;
+      level++;
+    }
+  }
+  /**
+   * Validates graph structure for safe execution
+   *
+   * Checks:
+   * 1. No cycles (circular dependencies)
+   * 2. No missing dependencies (broken references)
+   * 3. No self-loops (task depends on itself)
+   * 4. Warns about orphaned nodes (unreachable tasks)
+   *
+   * Complexity: O(V+E)
+   *
+   * @param graph - Graph to validate
+   * @returns Validation result with errors and warnings
+   *
+   * @example
+   * ```typescript
+   * const validation = resolver.validateGraph(graph);
+   * if (!validation.valid) {
+   *   console.error("Invalid graph:", validation.errors);
+   * }
+   * if (validation.warnings?.length) {
+   *   console.warn("Warnings:", validation.warnings);
+   * }
+   * ```
+   */
+  validateGraph(graph) {
+    const errors = [];
+    const warnings = [];
+    const cycleResult = this.detectCycles(graph);
+    if (cycleResult.hasCycle) {
+      const cyclePath = cycleResult.cyclePath?.join(" \u2192 ") || "unknown";
+      errors.push(`Circular dependency detected: ${cyclePath}`);
+    }
+    for (const [id, node] of graph.nodes.entries()) {
+      for (const depId of node.dependencies) {
+        if (!graph.nodes.has(depId)) {
+          errors.push(`Task "${id}" depends on non-existent task "${depId}"`);
+        }
+      }
+    }
+    for (const [id, node] of graph.nodes.entries()) {
+      if (node.dependencies.includes(id)) {
+        errors.push(`Task "${id}" has a self-loop (depends on itself)`);
+      }
+    }
+    const reachable = this.findReachableNodes(graph);
+    for (const id of graph.nodes.keys()) {
+      if (!reachable.has(id)) {
+        warnings.push(`Task "${id}" is orphaned (unreachable from entry points)`);
+      }
+    }
+    for (const [id, node] of graph.nodes.entries()) {
+      if (node.topologicalLevel === -1 && reachable.has(id)) {
+        warnings.push(`Task "${id}" has unassigned topological level (possible algorithm bug)`);
+      }
+    }
+    return {
+      valid: errors.length === 0,
+      errors,
+      warnings: warnings.length > 0 ? warnings : void 0
+    };
+  }
+  /**
+   * Detects cycles in the graph using DFS with colored nodes
+   *
+   * Algorithm:
+   * 1. Mark all nodes as WHITE (unvisited)
+   * 2. For each WHITE node, start DFS traversal
+   * 3. Mark nodes GRAY when entering, BLACK when leaving
+   * 4. If we encounter a GRAY node, we've found a cycle
+   *
+   * Complexity: O(V+E)
+   *
+   * @private
+   * @returns Cycle detection result with path if found
+   */
+  detectCycles(graph) {
+    const colors = /* @__PURE__ */ new Map();
+    const parent = /* @__PURE__ */ new Map();
+    for (const id of graph.nodes.keys()) {
+      colors.set(id, "WHITE");
+    }
+    for (const id of graph.nodes.keys()) {
+      if (colors.get(id) === "WHITE") {
+        const cyclePath = this.dfsVisit(id, graph, colors, parent, []);
+        if (cyclePath.length > 0) {
+          return { hasCycle: true, cyclePath };
+        }
+      }
+    }
+    return { hasCycle: false };
+  }
+  /**
+   * DFS visit helper for cycle detection
+   *
+   * @private
+   * @returns Cycle path if found, empty array otherwise
+   */
+  dfsVisit(nodeId, graph, colors, parent, path3) {
+    colors.set(nodeId, "GRAY");
+    path3.push(nodeId);
+    const adjacentNodes = graph.adjacency[nodeId] || [];
+    for (const adjId of adjacentNodes) {
+      const color = colors.get(adjId);
+      if (color === "GRAY") {
+        const cycleStart = path3.indexOf(adjId);
+        return [...path3.slice(cycleStart), adjId];
+      }
+      if (color === "WHITE") {
+        parent.set(adjId, nodeId);
+        const cyclePath = this.dfsVisit(adjId, graph, colors, parent, path3);
+        if (cyclePath.length > 0) {
+          return cyclePath;
+        }
+      }
+    }
+    path3.pop();
+    colors.set(nodeId, "BLACK");
+    return [];
+  }
+  /**
+   * Finds all reachable nodes from entry points (tasks with no dependencies)
+   *
+   * Uses Tarjan's algorithm to detect strongly connected components (cycles),
+   * then performs reachability analysis that properly handles cycles.
+   *
+   * Algorithm:
+   * 1. Find all SCCs (strongly connected components) using Tarjan's algorithm
+   * 2. Build condensed graph where each SCC is a single node
+   * 3. Perform BFS from entry point SCCs
+   * 4. A node is reachable if its SCC is reachable
+   *
+   * This ensures nodes in cycles are marked reachable if any node in the cycle
+   * is reachable from an entry point.
+   *
+   * Complexity: O(V+E)
+   *
+   * @private
+   * @returns Set of reachable task IDs
+   */
+  findReachableNodes(graph) {
+    const sccs = this.findStronglyConnectedComponents(graph);
+    const nodeToScc = /* @__PURE__ */ new Map();
+    for (let i = 0; i < sccs.length; i++) {
+      const scc = sccs[i];
+      if (!scc) continue;
+      for (const nodeId of scc) {
+        nodeToScc.set(nodeId, i);
+      }
+    }
+    const sccDeps = Array.from({ length: sccs.length }, () => /* @__PURE__ */ new Set());
+    for (const [id, node] of graph.nodes.entries()) {
+      const sccIdx = nodeToScc.get(id);
+      if (sccIdx === void 0) continue;
+      for (const depId of node.dependencies) {
+        const depSccIdx = nodeToScc.get(depId);
+        if (depSccIdx !== void 0 && depSccIdx !== sccIdx) {
+          sccDeps[depSccIdx]?.add(sccIdx);
+        }
+      }
+    }
+    const entrySCCs = /* @__PURE__ */ new Set();
+    for (let i = 0; i < sccs.length; i++) {
+      const scc = sccs[i];
+      if (!scc) continue;
+      for (const nodeId of scc) {
+        const node = graph.nodes.get(nodeId);
+        if (!node) continue;
+        if (node.dependencies.length === 0) {
+          entrySCCs.add(i);
+          break;
+        }
+        const hasOnlyInternalDeps = node.dependencies.every((depId) => {
+          const depSccIdx = nodeToScc.get(depId);
+          return depSccIdx === i;
+        });
+        if (hasOnlyInternalDeps && scc.length === 1) {
+          entrySCCs.add(i);
+          break;
+        }
+      }
+    }
+    const reachableSCCs = /* @__PURE__ */ new Set();
+    const queue = Array.from(entrySCCs);
+    for (const sccIdx of queue) {
+      reachableSCCs.add(sccIdx);
+    }
+    while (queue.length > 0) {
+      const current = queue.shift();
+      const deps = sccDeps[current];
+      if (!deps) continue;
+      for (const depIdx of deps) {
+        if (!reachableSCCs.has(depIdx)) {
+          reachableSCCs.add(depIdx);
+          queue.push(depIdx);
+        }
+      }
+    }
+    const reachable = /* @__PURE__ */ new Set();
+    for (const sccIdx of reachableSCCs) {
+      const scc = sccs[sccIdx];
+      if (!scc) continue;
+      for (const nodeId of scc) {
+        reachable.add(nodeId);
+      }
+    }
+    return reachable;
+  }
+  /**
+   * Finds strongly connected components using Tarjan's algorithm
+   *
+   * A strongly connected component is a maximal set of nodes where every node
+   * is reachable from every other node. Cycles form SCCs.
+   *
+   * Complexity: O(V+E)
+   *
+   * @private
+   * @returns Array of SCCs, where each SCC is an array of node IDs
+   */
+  findStronglyConnectedComponents(graph) {
+    const sccs = [];
+    const index = /* @__PURE__ */ new Map();
+    const lowlink = /* @__PURE__ */ new Map();
+    const onStack = /* @__PURE__ */ new Set();
+    const stack = [];
+    let currentIndex = 0;
+    const strongConnect = (nodeId) => {
+      index.set(nodeId, currentIndex);
+      lowlink.set(nodeId, currentIndex);
+      currentIndex++;
+      stack.push(nodeId);
+      onStack.add(nodeId);
+      const dependents = graph.adjacency[nodeId] || [];
+      for (const depId of dependents) {
+        if (!index.has(depId)) {
+          strongConnect(depId);
+          lowlink.set(nodeId, Math.min(lowlink.get(nodeId), lowlink.get(depId)));
+        } else if (onStack.has(depId)) {
+          lowlink.set(nodeId, Math.min(lowlink.get(nodeId), index.get(depId)));
+        }
+      }
+      if (lowlink.get(nodeId) === index.get(nodeId)) {
+        const scc = [];
+        let w;
+        do {
+          w = stack.pop();
+          onStack.delete(w);
+          scc.push(w);
+        } while (w !== nodeId);
+        sccs.push(scc);
+      }
+    };
+    for (const nodeId of graph.nodes.keys()) {
+      if (!index.has(nodeId)) {
+        strongConnect(nodeId);
+      }
+    }
+    return sccs;
+  }
+  /**
+   * Gets all tasks that are ready to execute
+   *
+   * A task is ready if:
+   * - All dependencies are completed
+   * - Current state is "ready"
+   *
+   * Complexity: O(V) - scans all nodes
+   *
+   * @param graph - Current graph state
+   * @returns Array of task IDs ready to execute, sorted by topological level
+   *
+   * @example
+   * ```typescript
+   * const readyTasks = resolver.getReadyTasks(graph);
+   * // Execute ready tasks in parallel
+   * await Promise.all(readyTasks.map(id => executeTask(id)));
+   * ```
+   */
+  getReadyTasks(graph) {
+    const ready = [];
+    for (const [id, node] of graph.nodes.entries()) {
+      if (node.state === "ready") {
+        ready.push({ id, level: node.topologicalLevel });
+      }
+    }
+    ready.sort((a, b) => a.level - b.level);
+    return ready.map((r) => r.id);
+  }
+  /**
+   * Marks a task as running
+   *
+   * Complexity: O(1)
+   *
+   * @param graph - Graph to update
+   * @param taskId - Task to mark as running
+   * @throws Error if task is not in "ready" state
+   */
+  markRunning(graph, taskId) {
+    const node = graph.nodes.get(taskId);
+    if (!node) {
+      throw new Error(`Task "${taskId}" not found in graph`);
+    }
+    if (node.state !== "ready") {
+      throw new Error(`Task "${taskId}" is not ready (current state: ${node.state})`);
+    }
+    node.state = "running";
+  }
+  /**
+   * Marks a task as completed and updates dependent tasks
+   *
+   * Algorithm:
+   * 1. Set task state to "completed"
+   * 2. For each dependent task:
+   *    - Check if all dependencies are completed
+   *    - If yes, mark as "ready"
+   *
+   * Complexity: O(D) where D = number of dependents
+   *
+   * @param graph - Graph to update
+   * @param taskId - Task to mark as completed
+   * @returns Array of newly ready task IDs
+   *
+   * @example
+   * ```typescript
+   * const newlyReady = resolver.markCompleted(graph, "compile");
+   * // Execute newly ready tasks
+   * for (const id of newlyReady) {
+   *   await executeTask(id);
+   * }
+   * ```
+   */
+  markCompleted(graph, taskId) {
+    const node = graph.nodes.get(taskId);
+    if (!node) {
+      throw new Error(`Task "${taskId}" not found in graph`);
+    }
+    if (node.state !== "running") {
+      throw new Error(`Task "${taskId}" cannot be completed from state "${node.state}"`);
+    }
+    node.state = "completed";
+    const newlyReady = [];
+    for (const depId of node.dependents) {
+      const depNode = graph.nodes.get(depId);
+      if (!depNode) continue;
+      if (depNode.state !== "pending" && depNode.state !== "blocked") {
+        continue;
+      }
+      const allDepsCompleted = depNode.dependencies.every((d) => {
+        const dNode = graph.nodes.get(d);
+        return dNode?.state === "completed";
+      });
+      if (allDepsCompleted) {
+        depNode.state = "ready";
+        newlyReady.push(depId);
+      }
+    }
+    return newlyReady;
+  }
+  /**
+   * Marks a task as failed and optionally blocks or resets dependent tasks
+   *
+   * Algorithm:
+   * 1. Set task state to "failed"
+   * 2. If blockDependents=true: Recursively mark all transitive dependents as "blocked"
+   * 3. If blockDependents=false: Reset dependents to "pending" for retry workflows
+   *
+   * Complexity: O(V) worst case (if failure cascades through entire graph)
+   *
+   * @param graph - Graph to update
+   * @param taskId - Task to mark as failed
+   * @param error - Optional error message
+   * @param blockDependents - If true, blocks dependents; if false, resets to pending (default: true)
+   * @returns Array of affected task IDs (blocked or reset)
+   *
+   * @example
+   * ```typescript
+   * // Block dependents (default behavior)
+   * const blocked = resolver.markFailed(graph, "compile", "Type errors");
+   * console.log(`Blocked ${blocked.length} dependent tasks`);
+   *
+   * // Allow retry by resetting dependents to pending
+   * const reset = resolver.markFailed(graph, "compile", "Type errors", false);
+   * console.log(`Reset ${reset.length} dependents for retry`);
+   * ```
+   */
+  markFailed(graph, taskId, error, blockDependents = true) {
+    const node = graph.nodes.get(taskId);
+    if (!node) {
+      throw new Error(`Task "${taskId}" not found in graph`);
+    }
+    node.state = "failed";
+    if (error && node.metadata) {
+      node.metadata.error = error;
+    } else if (error) {
+      node.metadata = { error };
+    }
+    const affected = [];
+    const queue = [...node.dependents];
+    const visited = /* @__PURE__ */ new Set();
+    while (queue.length > 0) {
+      const depId = queue.shift();
+      if (visited.has(depId)) continue;
+      visited.add(depId);
+      const depNode = graph.nodes.get(depId);
+      if (!depNode) continue;
+      if (depNode.state === "completed" || depNode.state === "failed") {
+        continue;
+      }
+      if (blockDependents) {
+        depNode.state = "blocked";
+        affected.push(depId);
+        queue.push(...depNode.dependents);
+      } else {
+        const hasFailedDependency = depNode.dependencies.some(
+          (dependencyId) => dependencyId !== taskId && graph.nodes.get(dependencyId)?.state === "failed"
+        );
+        depNode.state = hasFailedDependency ? "blocked" : "pending";
+        affected.push(depId);
+        queue.push(...depNode.dependents);
+      }
+    }
+    return affected;
+  }
+  /**
+   * Checks if all tasks are in a terminal state
+   *
+   * Terminal states: completed, failed, blocked
+   *
+   * Complexity: O(V)
+   *
+   * @param graph - Graph to check
+   * @returns True if all tasks are completed, failed, or blocked
+   */
+  isComplete(graph) {
+    for (const node of graph.nodes.values()) {
+      if (node.state !== "completed" && node.state !== "failed" && node.state !== "blocked") {
+        return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * Gets tasks at a specific topological level
+   *
+   * Useful for level-by-level execution strategies.
+   *
+   * Complexity: O(V)
+   *
+   * @param graph - Graph to query
+   * @param level - Topological level
+   * @returns Array of task IDs at the specified level
+   *
+   * @example
+   * ```typescript
+   * // Execute all level 0 tasks first
+   * const level0 = resolver.getTasksByLevel(graph, 0);
+   * await Promise.all(level0.map(id => executeTask(id)));
+   * ```
+   */
+  getTasksByLevel(graph, level) {
+    const tasks = [];
+    for (const [id, node] of graph.nodes.entries()) {
+      if (node.topologicalLevel === level) {
+        tasks.push(id);
+      }
+    }
+    return tasks;
+  }
+  /**
+   * Gets the maximum topological level in the graph
+   *
+   * Complexity: O(V)
+   *
+   * @param graph - Graph to analyze
+   * @returns Maximum level, or -1 if graph is empty
+   */
+  getMaxLevel(graph) {
+    let maxLevel = -1;
+    for (const node of graph.nodes.values()) {
+      if (node.topologicalLevel > maxLevel) {
+        maxLevel = node.topologicalLevel;
+      }
+    }
+    return maxLevel;
+  }
+  /**
+   * Computes comprehensive statistics about the graph
+   *
+   * Useful for monitoring, debugging, and optimization.
+   *
+   * Complexity: O(V)
+   *
+   * @param graph - Graph to analyze
+   * @returns Detailed statistics
+   *
+   * @example
+   * ```typescript
+   * const stats = resolver.getStatistics(graph);
+   * console.log(`Progress: ${stats.completedTasks}/${stats.totalTasks}`);
+   * console.log(`Graph depth: ${stats.maxLevel + 1} levels`);
+   * ```
+   */
+  getStatistics(graph) {
+    let readyCount = 0;
+    let runningCount = 0;
+    let completedCount = 0;
+    let failedCount = 0;
+    let blockedCount = 0;
+    let maxLevel = -1;
+    let totalDeps = 0;
+    let entryPoints = 0;
+    let terminalNodes = 0;
+    for (const node of graph.nodes.values()) {
+      switch (node.state) {
+        case "ready":
+          readyCount++;
+          break;
+        case "running":
+          runningCount++;
+          break;
+        case "completed":
+          completedCount++;
+          break;
+        case "failed":
+          failedCount++;
+          break;
+        case "blocked":
+          blockedCount++;
+          break;
+      }
+      if (node.topologicalLevel > maxLevel) {
+        maxLevel = node.topologicalLevel;
+      }
+      totalDeps += node.dependencies.length;
+      if (node.dependencies.length === 0) {
+        entryPoints++;
+      }
+      if (node.dependents.length === 0) {
+        terminalNodes++;
+      }
+    }
+    const totalTasks = graph.nodes.size;
+    return {
+      totalTasks,
+      readyTasks: readyCount,
+      runningTasks: runningCount,
+      completedTasks: completedCount,
+      failedTasks: failedCount,
+      blockedTasks: blockedCount,
+      maxLevel,
+      averageDependencies: totalTasks > 0 ? totalDeps / totalTasks : 0,
+      entryPoints,
+      terminalNodes
+    };
+  }
+  /**
+   * Resets all task states to initial values
+   *
+   * Useful for re-executing the graph or recovering from failures.
+   *
+   * Complexity: O(V)
+   *
+   * @param graph - Graph to reset
+   *
+   * @example
+   * ```typescript
+   * // Retry execution after fixing issues
+   * resolver.reset(graph);
+   * const validation = resolver.validateGraph(graph);
+   * if (validation.valid) {
+   *   // Execute again
+   * }
+   * ```
+   */
+  reset(graph) {
+    for (const node of graph.nodes.values()) {
+      node.state = node.dependencies.length === 0 ? "ready" : "pending";
+      if (node.metadata?.error) {
+        delete node.metadata.error;
+      }
+    }
+  }
+};
+
+// src/orchestrator/services/cleanup-service.ts
+import path from "path";
+import chalk from "chalk";
+var CleanupService = class {
+  constructor(prManager, verbose = false, worktreeCleanup, repoRoot = process.cwd()) {
+    this.prManager = prManager;
+    this.verbose = verbose;
+    this.worktreeCleanup = worktreeCleanup;
+    this.repoRoot = path.resolve(repoRoot);
+  }
+  prManager;
+  verbose;
+  worktreeCleanup;
+  repoRoot;
+  /**
+   * Clean up non-winning PRs and branches after competition
+   */
+  async cleanupCompetition(results, winner, options = {}) {
+    const labMode = options.labMode === true || LabPathResolver.getInstance().isLabMode();
+    if (labMode) {
+      if (this.verbose || options.verbose) {
+        console.log(
+          chalk.cyan("Lab mode active - skipping cleanup to preserve worktrees for analysis")
+        );
+      }
+      return;
+    }
+    const { verbose = this.verbose, preserveSubmittedOnly = false, taskId } = options;
+    const losers = results.filter((r) => {
+      if (!r.prNumber) {
+        if (verbose) {
+          console.log(chalk.gray(`  \u2022 Skipping ${r.provider} ${r.strategy} - no PR number`));
+        }
+        return false;
+      }
+      if (winner.prNumber) {
+        const isLoser2 = r.prNumber !== winner.prNumber;
+        if (verbose && !isLoser2) {
+          console.log(
+            chalk.gray(`  \u2022 Skipping ${r.provider} ${r.strategy} - winner's PR #${r.prNumber}`)
+          );
+        }
+        return isLoser2;
+      }
+      const isLoser = r.variant !== winner.variant || r.provider !== winner.provider;
+      if (verbose && !isLoser) {
+        console.log(chalk.gray(`  \u2022 Skipping ${r.provider} ${r.strategy} - winner's variant`));
+      }
+      return isLoser;
+    });
+    const applyPendingLosers = [];
+    const eligibleLosers = losers.filter((r) => {
+      if (this.requiresApplyRecovery(r)) {
+        applyPendingLosers.push(r);
+        return false;
+      }
+      return true;
+    });
+    if (applyPendingLosers.length > 0) {
+      console.log(chalk.gray("\nPreserving PRs awaiting local apply:"));
+      applyPendingLosers.forEach((variant) => {
+        const label = this.formatProviderVariantLabel(variant);
+        const prLabel = variant.prNumber ? `PR #${variant.prNumber}` : "PR pending";
+        const hint = this.getRecoveryHint(variant);
+        console.log(
+          chalk.gray(
+            `  \u2022 ${prLabel} - ${label}${hint ? ` \u2192 ${hint}` : " (run apply command before cleanup)"}`
+          )
+        );
+      });
+    }
+    const shouldPreserveSubmittedPRs = preserveSubmittedOnly;
+    const preservedSubmittedPRs = [];
+    const losersToCleanup = eligibleLosers.filter((r) => {
+      if (!shouldPreserveSubmittedPRs) {
+        return true;
+      }
+      if (this.isPreservedSubmittedVariant(r)) {
+        preservedSubmittedPRs.push(r);
+        if (verbose) {
+          console.log(
+            chalk.gray(
+              `  \u2022 Preserving ${r.provider} ${r.strategy} PR #${r.prNumber ?? "?"} (submit-only mode)`
+            )
+          );
+        }
+        return false;
+      }
+      return true;
+    });
+    if (preservedSubmittedPRs.length > 0) {
+      await this.displayPreservedPRs(preservedSubmittedPRs);
+    }
+    if (losersToCleanup.length === 0) {
+      if (preservedSubmittedPRs.length === 0 && verbose) {
+        console.log(chalk.gray("\nNo losing PRs to close - checking for orphan branches..."));
+      }
+      if (taskId) {
+        await this.cleanupOrphanBranchesByTask(taskId, winner);
+      }
+      return;
+    }
+    const hasBranchOnlyLosers = results.some(
+      (r) => !r.prNumber && (r.variant !== winner.variant || r.provider !== winner.provider)
+    );
+    console.log(chalk.blue(`
+Cleaning up ${losersToCleanup.length} non-winning variant(s)...
+`));
+    const cleanupResults = {
+      success: 0,
+      degraded: 0,
+      failed: 0,
+      errors: [],
+      warnings: [],
+      preserved: preservedSubmittedPRs
+    };
+    const CONCURRENCY_LIMIT = 3;
+    const startTime = Date.now();
+    for (let batchStart = 0; batchStart < losersToCleanup.length; batchStart += CONCURRENCY_LIMIT) {
+      const batchEnd = Math.min(batchStart + CONCURRENCY_LIMIT, losersToCleanup.length);
+      const batch = losersToCleanup.slice(batchStart, batchEnd);
+      if (verbose) {
+        console.log(
+          chalk.gray(
+            `
+  [Batch ${Math.floor(batchStart / CONCURRENCY_LIMIT) + 1}] Processing ${batch.length} variant(s) in parallel...`
+          )
+        );
+      }
+      const batchPromises = batch.map(
+        (loser, batchIndex) => this.cleanupSingleVariant(loser, batchStart + batchIndex, losersToCleanup.length, verbose)
+      );
+      const batchResults = await Promise.allSettled(batchPromises);
+      batchResults.forEach((result, index) => {
+        if (result.status === "fulfilled") {
+          const variantResult = result.value;
+          cleanupResults.success += variantResult.success ? 1 : 0;
+          cleanupResults.degraded += variantResult.degraded ? 1 : 0;
+          cleanupResults.failed += variantResult.success ? 0 : 1;
+          if (variantResult.error) {
+            cleanupResults.errors.push(variantResult.error);
+          }
+          if (variantResult.warning) {
+            cleanupResults.warnings.push(variantResult.warning);
+          }
+        } else {
+          const loser = batch[index];
+          if (loser) {
+            const errorMsg = `Unhandled exception during cleanup of ${loser.provider} ${loser.strategy}: ${result.reason instanceof Error ? result.reason.message : String(result.reason)}`;
+            cleanupResults.errors.push(errorMsg);
+            cleanupResults.failed++;
+          }
+        }
+      });
+      if (batchEnd < losersToCleanup.length) {
+        await new Promise((resolve) => setTimeout(resolve, 500));
+      }
+    }
+    const elapsedSeconds = ((Date.now() - startTime) / 1e3).toFixed(1);
+    console.log(chalk.bold(`
+Cleanup Summary (${elapsedSeconds}s):`));
+    console.log(chalk.green(`  Successfully cleaned up: ${cleanupResults.success} variant(s)`));
+    if (cleanupResults.degraded > 0) {
+      console.log(chalk.yellow(`  Completed with warnings: ${cleanupResults.degraded} variant(s)`));
+      cleanupResults.warnings.forEach((warning) => {
+        console.log(chalk.gray(`  \u2022 ${warning}`));
+      });
+    }
+    if (cleanupResults.failed > 0) {
+      console.log(chalk.red(`  Failed cleanup: ${cleanupResults.failed} variant(s)`));
+      console.log(chalk.yellow("\nManual cleanup required for:"));
+      cleanupResults.errors.forEach((error) => {
+        console.log(chalk.gray(`  \u2022 ${error}`));
+      });
+      console.log(chalk.gray("\nManual cleanup commands:"));
+      losersToCleanup.forEach((loser) => {
+        console.log(chalk.gray(`  # For ${loser.provider} ${loser.strategy}:`));
+        console.log(chalk.gray(`  gh pr close ${loser.prNumber} || true`));
+        if (taskId && loser.provider && loser.strategy && loser.executionMode) {
+          const branch = poeticVariantBranchName({
+            taskId,
+            provider: loser.provider,
+            strategy: loser.strategy,
+            executionMode: loser.executionMode,
+            model: loser.model
+          });
+          console.log(chalk.gray(`  git branch -D ${branch} || true`));
+        } else {
+          console.log(chalk.gray("  gh pr view <PR_NUMBER> --json headRefName -q '.headRefName'"));
+        }
+      });
+    } else {
+      console.log(chalk.green("\nAll cleanup operations completed successfully!\n"));
+    }
+    if (hasBranchOnlyLosers && taskId) {
+      await this.cleanupOrphanBranchesByTask(taskId, winner);
+    }
+    if (cleanupResults.failed > 0) {
+      const summary = cleanupResults.errors.join("; ");
+      throw new Error(
+        `Cleanup partially failed: ${cleanupResults.failed}/${losersToCleanup.length} variant(s) \u2014 ${summary}`
+      );
+    }
+  }
+  /**
+   * Cleanup a single variant (PR close + branch delete)
+   * Returns result object for collection by Promise.allSettled()
+   */
+  async cleanupSingleVariant(loser, index, total, verbose = false) {
+    const label = `${loser.provider} ${loser.strategy}`;
+    try {
+      if (verbose) {
+        console.log(
+          chalk.gray(`  [${index + 1}/${total}] Processing ${label} (PR #${loser.prNumber})`)
+        );
+      }
+      let prState = "unknown";
+      let branch;
+      try {
+        const prData = await this.prManager.executeWithRetry(
+          async () => {
+            const { execa: execa2 } = await import("execa");
+            const result = await execa2(
+              "gh",
+              ["pr", "view", String(loser.prNumber), "--json", "state,mergeable,headRefName"],
+              { stdio: "pipe" }
+            );
+            return parseJsonWithContext(result.stdout, "[Cleanup] gh pr view output");
+          },
+          `validate PR #${loser.prNumber} state`,
+          2
+          // 2 retries
+        );
+        if (prData) {
+          prState = prData.state ?? "unknown";
+          branch = prData.headRefName ?? "";
+          if (prState === "closed") {
+            console.log(
+              chalk.yellow(`  PR #${loser.prNumber} already closed, skipping to branch cleanup`)
+            );
+          } else if (prState === "merged") {
+            const warning = `PR #${loser.prNumber} was already merged; cleanup skipped`;
+            console.log(chalk.yellow(`  PR #${loser.prNumber} already merged, skipping cleanup`));
+            return { success: true, degraded: true, warning };
+          }
+          if (branch && isProtectedPipelineBranch(branch)) {
+            const warning = `PR #${loser.prNumber} branch ${branch} is protected; cleanup skipped`;
+            return { success: true, degraded: true, warning };
+          }
+        }
+      } catch (validationError) {
+        console.log(
+          chalk.yellow(`  Could not validate PR #${loser.prNumber} state: ${validationError}`)
+        );
+      }
+      if (branch) {
+        await this.releaseWorktreesForBranch(branch, verbose, false);
+      }
+      if (prState === "open") {
+        try {
+          if (verbose) {
+            console.log(chalk.gray(`    \u2192 Closing PR #${loser.prNumber}`));
+          }
+          const prNumber = loser.prNumber;
+          if (typeof prNumber === "number") {
+            await this.prManager.closePR(prNumber);
+            console.log(chalk.green(`    Closed PR #${prNumber}`));
+          }
+        } catch (closeError) {
+          console.log(chalk.yellow(`    Failed to close PR #${loser.prNumber}: ${closeError}`));
+        }
+      }
+      if (!branch) {
+        try {
+          const prNumber = loser.prNumber;
+          if (typeof prNumber === "number") {
+            branch = await this.prManager.getPRBranch(prNumber);
+          }
+          if (verbose) {
+            console.log(chalk.gray(`    \u2192 PR branch: ${branch}`));
+          }
+        } catch (branchError) {
+          console.log(
+            chalk.yellow(`    Could not get branch name for PR #${loser.prNumber}: ${branchError}`)
+          );
+          return {
+            success: false,
+            error: `Could not determine branch name for PR #${loser.prNumber}. Try: gh pr view <PR_NUMBER> --json headRefName -q '.headRefName'`
+          };
+        }
+      }
+      if (branch) {
+        if (isProtectedPipelineBranch(branch)) {
+          const warning = `Branch ${branch} is protected; cleanup skipped`;
+          return { success: true, degraded: true, warning };
+        }
+        try {
+          if (verbose) {
+            console.log(chalk.gray(`    \u2192 Deleting branch: ${branch}`));
+          }
+          try {
+            await this.prManager.deleteBranch(branch, { force: false });
+          } catch (_regularDeleteError) {
+            if (verbose) {
+              console.log(chalk.gray("    \u2192 Regular delete failed, trying force delete"));
+            }
+            await this.prManager.deleteBranch(branch, { force: true });
+          }
+          console.log(chalk.green(`    Deleted branch: ${branch}`));
+        } catch (deleteError) {
+          const errorMsg = `Failed to delete branch ${branch}: ${deleteError instanceof Error ? deleteError.message : String(deleteError)}`;
+          console.log(chalk.yellow(`    ${errorMsg}`));
+          return { success: false, error: errorMsg };
+        }
+      }
+      console.log(chalk.green(`  Successfully cleaned up ${label} (PR #${loser.prNumber})`));
+      return { success: true };
+    } catch (error) {
+      const errorMsg = `Failed to cleanup ${loser.provider} ${loser.strategy}: ${error instanceof Error ? error.message : String(error)}`;
+      console.log(chalk.red(`  ${errorMsg}`));
+      return { success: false, error: errorMsg };
+    }
+  }
+  /**
+   * Proactively remove git worktrees that are checked out on the given branch.
+   *
+   * This prevents "branch is checked out at ..." errors when deleting branches
+   * during cleanup, especially when worktree pooling is enabled.
+   */
+  async releaseWorktreesForBranch(branch, verbose = false, labMode = LabPathResolver.getInstance().isLabMode()) {
+    if (labMode || LabPathResolver.getInstance().isLabMode()) {
+      if (verbose) {
+        console.log(chalk.gray("    Lab mode - preserving worktrees"));
+      }
+      return;
+    }
+    try {
+      const { execa: execa2 } = await import("execa");
+      const { stdout } = await execa2("git", ["worktree", "list", "--porcelain"], {
+        cwd: this.repoRoot,
+        stdio: "pipe"
+      });
+      const lines = stdout.split("\n");
+      const worktrees = [];
+      let currentPath = null;
+      for (const line of lines) {
+        if (line.startsWith("worktree ")) {
+          currentPath = line.substring("worktree ".length).trim();
+        } else if (line.startsWith("branch ") && currentPath) {
+          const branchRef = line.substring("branch ".length).trim();
+          worktrees.push({ path: currentPath, branch: branchRef });
+          currentPath = null;
+        } else if (line.startsWith("detached ") && currentPath) {
+          worktrees.push({ path: currentPath, branch: "" });
+          currentPath = null;
+        }
+      }
+      if (worktrees.length === 0) {
+        return;
+      }
+      const normalizedBranch = branch.startsWith("refs/heads/") ? branch : `refs/heads/${branch}`;
+      const matching = worktrees.filter(
+        (wt) => wt.branch === normalizedBranch || wt.branch === branch
+      );
+      for (const wt of matching) {
+        try {
+          if (verbose) {
+            console.log(chalk.gray(`    \u2192 Releasing worktree for branch ${branch}: ${wt.path}`));
+          }
+          if (this.worktreeCleanup) {
+            const released = await this.worktreeCleanup.cleanup(wt.path, {
+              preserve: false,
+              gitCwd: this.repoRoot
+            });
+            if (released === false) {
+              throw new Error(`worktree cleanup refused ${wt.path}`);
+            }
+          } else {
+            await execa2("git", ["worktree", "remove", wt.path, "--force"], {
+              cwd: this.repoRoot,
+              stdio: "pipe"
+            });
+          }
+        } catch (error) {
+          if (verbose) {
+            const msg = error instanceof Error ? error.message : String(error);
+            console.log(chalk.yellow(`    Failed to remove worktree ${wt.path}: ${msg}`));
+          }
+        }
+      }
+      if (matching.length > 0) {
+        await pruneGitWorktreeEntries({ cwd: this.repoRoot });
+      }
+    } catch (error) {
+      if (verbose) {
+        const msg = error instanceof Error ? error.message : String(error);
+        console.log(chalk.gray(`    Skipping worktree release for branch ${branch}: ${msg}`));
+      }
+    }
+  }
+  requiresApplyRecovery(result) {
+    if (result.submittedOnly) {
+      return true;
+    }
+    return result.applied === false;
+  }
+  isPreservedSubmittedVariant(result) {
+    return result.submittedOnly === true;
+  }
+  /**
+   * Display preserved PRs that still need manual attention
+   */
+  async displayPreservedPRs(preserved) {
+    if (preserved.length === 0) {
+      return;
+    }
+    console.log(chalk.blue(`
+Preserved ${preserved.length} PR(s) needing attention:
+`));
+    for (const variant of preserved) {
+      const label = this.formatProviderVariantLabel(variant);
+      const prLabel = variant.prNumber ? `PR #${variant.prNumber}` : "PR pending";
+      const appliedStatus = this.formatAppliedStatus(variant);
+      const hint = this.getRecoveryHint(variant);
+      console.log(chalk.gray(`  \u2022 ${prLabel} - ${label}`));
+      if (appliedStatus) {
+        console.log(chalk.gray(`    ${appliedStatus}`));
+      }
+      if (hint) {
+        console.log(chalk.gray(`    Recovery: ${hint}`));
+      }
+    }
+    console.log();
+  }
+  /**
+   * Format provider variant label
+   */
+  formatProviderVariantLabel(result) {
+    return `${result.provider} ${result.model || "default"} ${result.strategy}`;
+  }
+  /**
+   * Format applied status
+   */
+  formatAppliedStatus(result) {
+    if (result.applied === true) {
+      return "Applied locally";
+    }
+    if (result.applied === false) {
+      return "Apply failed";
+    }
+    if (result.submittedOnly) {
+      return "Awaiting local apply";
+    }
+    return "";
+  }
+  /**
+   * Get recovery hint
+   */
+  getRecoveryHint(result) {
+    if (result.provider === "codex" && result.cloudTaskId) {
+      return `Inspect historical task ${result.cloudTaskId}`;
+    }
+    if (result.provider === "cursor" || result.provider === "cursor-api") {
+      return "Apply via Cursor IDE";
+    }
+    return void 0;
+  }
+  /**
+   * OPTIONAL/OPT-IN: Prune old variant_results rows from the telemetry database.
+   *
+   * This method is intentionally separate from cleanupCompetition() and is NOT
+   * called automatically. Historical telemetry has analytical value; callers
+   * should only invoke this when explicitly managing disk space.
+   *
+   * The automatic size-triggered path (DbSizeManager) also covers variant_results,
+   * so manual pruning is rarely needed. Use this when you want fine-grained control
+   * over the retention window or need a dry-run estimate first.
+   *
+   * @param db - The variants telemetry database instance (DatabaseLike).
+   *             Obtain via TelemetryDatabase.getVariantsDb() or equivalent.
+   *             If undefined, the method is a no-op and returns zero deleted rows.
+   * @param options - Pruning configuration (retentionDays, verbose, dryRun).
+   * @returns Summary of what was (or would be) deleted.
+   *
+   * @example
+   * ```typescript
+   * // Dry-run first to see the impact
+   * const estimate = await cleanupService.pruneVariantResults(variantsDb, {
+   *   retentionDays: 90,
+   *   dryRun: true,
+   *   verbose: true,
+   * });
+   * console.log(`Would delete ${estimate.deletedRows} rows`);
+   *
+   * // Then execute for real
+   * const result = await cleanupService.pruneVariantResults(variantsDb, {
+   *   retentionDays: 90,
+   * });
+   * ```
+   */
+  async pruneVariantResults(db, options = {}) {
+    const { retentionDays = 90, verbose = false, dryRun = false } = options;
+    const cutoff = new Date(Date.now() - retentionDays * 24 * 60 * 60 * 1e3);
+    const cutoffTimestamp = cutoff.toISOString();
+    if (!db) {
+      if (verbose) {
+        console.log(
+          chalk.gray("[CleanupService] pruneVariantResults: no database provided, skipping")
+        );
+      }
+      return { deletedRows: 0, cutoffTimestamp, dryRun };
+    }
+    if (verbose) {
+      console.log(
+        chalk.gray(
+          `[CleanupService] pruneVariantResults: targeting rows with completed_at < ${cutoffTimestamp} (retention: ${retentionDays}d)${dryRun ? " [DRY RUN]" : ""}`
+        )
+      );
+    }
+    try {
+      if (dryRun) {
+        const countStmt = db.prepare(
+          "SELECT COUNT(*) as count FROM variant_results WHERE completed_at < ? AND completed_at IS NOT NULL"
+        );
+        const row = countStmt.get(cutoffTimestamp);
+        const deletedRows2 = row?.count ?? 0;
+        if (verbose) {
+          console.log(
+            chalk.gray(
+              `[CleanupService] pruneVariantResults: dry-run \u2014 would delete ${deletedRows2} row(s)`
+            )
+          );
+        }
+        return { deletedRows: deletedRows2, cutoffTimestamp, dryRun: true };
+      }
+      const deleteStmt = db.prepare(
+        "DELETE FROM variant_results WHERE completed_at < ? AND completed_at IS NOT NULL"
+      );
+      const result = deleteStmt.run(cutoffTimestamp);
+      const deletedRows = result.changes ?? 0;
+      if (verbose) {
+        console.log(
+          chalk.gray(
+            `[CleanupService] pruneVariantResults: deleted ${deletedRows} row(s) older than ${cutoffTimestamp}`
+          )
+        );
+      }
+      return { deletedRows, cutoffTimestamp, dryRun: false };
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      console.warn(`[CleanupService] pruneVariantResults failed: ${msg}`);
+      return { deletedRows: 0, cutoffTimestamp, dryRun };
+    }
+  }
+  /**
+   * Cleanup orphan branches by task ID
+   */
+  async cleanupOrphanBranchesByTask(taskId, winner) {
+    try {
+      const { execa: execa2 } = await import("execa");
+      const result = await execa2("git", ["branch", "--list", `*${taskId}*`], {
+        stdio: "pipe"
+      });
+      const branches = result.stdout.split("\n").map((b) => b.trim().replace(/^\*\s*/, "")).filter((b) => b.length > 0);
+      let deletedCount = 0;
+      let winnerBranch = "";
+      if (winner.prNumber) {
+        try {
+          winnerBranch = await this.prManager.getPRBranch(winner.prNumber);
+        } catch (error) {
+          const msg = error instanceof Error ? error.message : String(error);
+          console.warn(
+            `[CleanupService] Skipping orphan branch cleanup for task ${taskId}: failed to resolve winner branch for PR #${winner.prNumber}: ${msg}`
+          );
+          return 0;
+        }
+      } else {
+        console.warn(
+          `[CleanupService] Skipping orphan branch cleanup for task ${taskId}: winner has no PR number, cannot identify winning branch`
+        );
+        return 0;
+      }
+      for (const branch of branches) {
+        if (branch === winnerBranch) {
+          continue;
+        }
+        if (!isPoeticOwnedBranch(branch)) {
+          continue;
+        }
+        if (isProtectedPipelineBranch(branch)) {
+          continue;
+        }
+        try {
+          await this.prManager.deleteBranch(branch, { force: true });
+          deletedCount++;
+        } catch (_error) {
+        }
+      }
+      return deletedCount;
+    } catch (_error) {
+      return 0;
+    }
+  }
+};
+
+// src/orchestrator/services/judge-display-service.ts
+import chalk2 from "chalk";
+var JudgeDisplayService = class {
+  verbosity;
+  showRationale;
+  streaming;
+  resultStreamer;
+  judgeProgressHandler;
+  liveScoringHandler;
+  judgeEvaluatedHandler;
+  judgeWinnerSelectedHandler;
+  constructor(options = {}) {
+    this.verbosity = options.verbosity ?? "normal";
+    this.showRationale = options.showRationale ?? false;
+    this.streaming = options.streaming ?? false;
+  }
+  /**
+   * Set result streamer for real-time updates
+   */
+  setResultStreamer(streamer) {
+    this.resultStreamer = streamer;
+  }
+  /**
+   * Setup judge streaming listeners for a task
+   * @returns Cleanup function to remove listeners
+   */
+  setupStreamingListeners(taskId) {
+    if (!this.resultStreamer || !this.streaming) return () => {
+    };
+    this.removeStreamingListeners();
+    this.judgeProgressHandler = (event) => {
+      if (event.taskId === taskId) {
+        this.displayJudgeProgress(event);
+      }
+    };
+    this.liveScoringHandler = (event) => {
+      if (event.taskId === taskId) {
+        this.displayLiveScoring(event);
+      }
+    };
+    this.judgeEvaluatedHandler = (event) => {
+      if (event.taskId === taskId) {
+        this.displayJudgeEvaluation(event);
+      }
+    };
+    this.judgeWinnerSelectedHandler = (event) => {
+      if (event.taskId === taskId) {
+        this.displayWinnerSelection(event);
+      }
+    };
+    this.resultStreamer.on("judgeProgress", this.judgeProgressHandler);
+    this.resultStreamer.on("liveScoring", this.liveScoringHandler);
+    this.resultStreamer.on("judgeEvaluated", this.judgeEvaluatedHandler);
+    this.resultStreamer.on("judgeWinnerSelected", this.judgeWinnerSelectedHandler);
+    return () => this.removeStreamingListeners();
+  }
+  /**
+   * Remove all streaming listeners
+   */
+  removeStreamingListeners() {
+    if (!this.resultStreamer) return;
+    if (this.judgeProgressHandler) {
+      this.resultStreamer.removeListener("judgeProgress", this.judgeProgressHandler);
+      this.judgeProgressHandler = void 0;
+    }
+    if (this.liveScoringHandler) {
+      this.resultStreamer.removeListener("liveScoring", this.liveScoringHandler);
+      this.liveScoringHandler = void 0;
+    }
+    if (this.judgeEvaluatedHandler) {
+      this.resultStreamer.removeListener("judgeEvaluated", this.judgeEvaluatedHandler);
+      this.judgeEvaluatedHandler = void 0;
+    }
+    if (this.judgeWinnerSelectedHandler) {
+      this.resultStreamer.removeListener("judgeWinnerSelected", this.judgeWinnerSelectedHandler);
+      this.judgeWinnerSelectedHandler = void 0;
+    }
+  }
+  /**
+   * Display AI Judge evaluation results
+   *
+   * @param evaluation - The judge synthesis result to display
+   * @param variantResultsMap - Optional map of variant name to result for analysis-mode detection
+   */
+  displayEvaluation(evaluation, variantResultsMap) {
+    if (this.verbosity === "silent" || isQuietOutputRequested()) return;
+    const summary = this.buildSummary(evaluation, variantResultsMap);
+    const shouldShowDetails = this.verbosity === "detailed" || this.verbosity === "debug";
+    if (!shouldShowDetails) {
+      if (this.verbosity === "minimal") {
+        const confidenceSuffix = summary.confidenceLabel ? ` (${summary.confidenceLabel})` : "";
+        const analysisSuffix = summary.isAnalysisMode ? " [analysis mode]" : "";
+        console.log(chalk2.bold(`Winner: ${summary.winner}${confidenceSuffix}${analysisSuffix}`));
+        return;
+      }
+      console.log(chalk2.bold.cyan("\nAI Judge Result\n"));
+      const analysisTag = summary.isAnalysisMode ? chalk2.yellow(" [analysis mode]") : "";
+      console.log(chalk2.bold(`Winner: ${summary.winner}${analysisTag}`));
+      if (summary.confidenceLabel) {
+        console.log(chalk2.gray(`   Confidence: ${summary.confidenceLabel}`));
+      }
+      if (summary.runnerUp) {
+        console.log(
+          chalk2.gray(
+            `   Runner-up: ${summary.runnerUp}${summary.margin ? ` (margin ${summary.margin} pts)` : ""}`
+          )
+        );
+      }
+      if (summary.modelLabel) {
+        console.log(chalk2.gray(`   Model: ${summary.modelLabel}`));
+      }
+      if (summary.durationLabel) {
+        console.log(chalk2.gray(`   Evaluation Time: ${summary.durationLabel}`));
+      }
+      if (summary.reasons.length > 0) {
+        console.log(chalk2.gray(`   Reasons: ${summary.reasons.join(" | ")}`));
+      }
+      console.log();
+      return;
+    }
+    console.log(chalk2.bold.cyan("\nAI Judge Evaluation:\n"));
+    const detailedAnalysisTag = summary.isAnalysisMode ? chalk2.yellow(" [analysis mode]") : "";
+    console.log(chalk2.bold(`Winner: ${summary.winner}${detailedAnalysisTag}`));
+    const confidenceValue = typeof summary.confidence === "number" && Number.isFinite(summary.confidence) ? summary.confidence : 0;
+    console.log(chalk2.gray(`   Confidence: ${confidenceValue}%`));
+    if (summary.modelLabel) {
+      console.log(chalk2.gray(`   Model: ${summary.modelLabel}`));
+    }
+    if (summary.durationLabel) {
+      console.log(chalk2.gray(`   Evaluation Time: ${summary.durationLabel}
+`));
+    }
+    if (evaluation.reasoning && this.showRationale) {
+      console.log(chalk2.bold.blue("Reasoning:"));
+      console.log(chalk2.gray(`   ${evaluation.reasoning}
+`));
+    }
+    console.log(chalk2.bold.blue("Detailed Evaluations:"));
+    evaluation.evaluations.forEach((eval_, index) => {
+      const isWinner = eval_.variant === evaluation.winner;
+      const variantColor = isWinner ? chalk2.green : chalk2.white;
+      const variantName = eval_.variant ? eval_.variant.toUpperCase() : "UNKNOWN";
+      const rankingScore = getEvaluationRankingScore(eval_);
+      const qualityScore = getEvaluationQualityScore(eval_);
+      console.log(variantColor(`
+   ${index + 1}. ${variantName}${isWinner ? " [winner]" : ""}`));
+      if (rankingScore != null) {
+        console.log(chalk2.gray(`      Ranking Score: ${rankingScore.toFixed(1)}/100`));
+      }
+      if (qualityScore != null && (rankingScore == null || Math.abs(rankingScore - qualityScore) > 0.05)) {
+        console.log(chalk2.gray(`      Quality Score: ${qualityScore.toFixed(1)}/100`));
+      }
+      if (eval_.codeQuality) {
+        console.log(chalk2.gray(`      Correctness: ${Number(eval_.codeQuality.correctness)}/100`));
+        console.log(chalk2.gray(`      Readability: ${Number(eval_.codeQuality.readability)}/100`));
+        console.log(
+          chalk2.gray(`      Maintainability: ${Number(eval_.codeQuality.maintainability)}/100`)
+        );
+        console.log(
+          chalk2.gray(`      Completeness: ${Number(eval_.codeQuality.completeness)}/100`)
+        );
+      }
+      if (eval_.strengths && eval_.strengths.length > 0) {
+        console.log(chalk2.green("      Strengths:"));
+        eval_.strengths.forEach((strength) => {
+          console.log(chalk2.gray(`        ${strength}`));
+        });
+      }
+      if (eval_.weaknesses && eval_.weaknesses.length > 0) {
+        console.log(chalk2.yellow("      Weaknesses:"));
+        eval_.weaknesses.forEach((weakness) => {
+          console.log(chalk2.gray(`        \u2022 ${weakness}`));
+        });
+      }
+    });
+    if (evaluation.recommendations && evaluation.recommendations.length > 0) {
+      console.log(chalk2.bold.blue("\nRecommendations:"));
+      evaluation.recommendations.forEach((rec, index) => {
+        console.log(chalk2.gray(`   ${index + 1}. ${rec}`));
+      });
+    }
+    console.log();
+  }
+  /**
+   * Display judge progress updates
+   */
+  displayJudgeProgress(event) {
+    if (isQuietOutputRequested()) return;
+    if (this.verbosity === "silent" || this.verbosity === "minimal") return;
+    const progressBar = this.createProgressBar(event.progress, 40);
+    let output = `\r${event.variant}: ${progressBar} ${event.progress.toFixed(1)}%`;
+    if (event.step) {
+      output += ` | ${event.step}`;
+    }
+    if (event.currentScore !== void 0) {
+      output += ` | Score: ${event.currentScore.toFixed(1)}`;
+    }
+    if (event.estimatedTimeRemaining) {
+      const seconds = Math.ceil(event.estimatedTimeRemaining / 1e3);
+      output += ` | ETA: ${seconds}s`;
+    }
+    process.stdout.write(output);
+    if (event.progress >= 100) {
+      process.stdout.write("\n");
+    }
+  }
+  /**
+   * Display live scoring updates
+   */
+  displayLiveScoring(event) {
+    if (isQuietOutputRequested()) return;
+    if (this.verbosity === "silent" || this.verbosity === "minimal") return;
+    console.log(
+      chalk2.gray(`  ${event.variant}: ${event.criteria} score updated to ${event.score}`)
+    );
+  }
+  /**
+   * Display judge evaluation results (streaming event)
+   */
+  displayJudgeEvaluation(event) {
+    if (isQuietOutputRequested()) return;
+    if (this.verbosity === "silent") return;
+    if (this.verbosity !== "detailed" && this.verbosity !== "debug") return;
+    const overall = typeof event.evaluation.rankingScore === "number" && Number.isFinite(event.evaluation.rankingScore) ? event.evaluation.rankingScore : typeof event.evaluation.compositeScore === "number" && Number.isFinite(event.evaluation.compositeScore) ? event.evaluation.compositeScore : typeof event.evaluation.overallScore === "number" && Number.isFinite(event.evaluation.overallScore) ? event.evaluation.overallScore : 0;
+    const weighted = typeof event.evaluation.weightedScore === "number" && Number.isFinite(event.evaluation.weightedScore) ? event.evaluation.weightedScore : 0;
+    const quality = typeof event.evaluation.qualityScore === "number" && Number.isFinite(event.evaluation.qualityScore) ? event.evaluation.qualityScore : null;
+    console.log(chalk2.green(`
+${event.variant} evaluation completed`));
+    console.log(chalk2.gray(`  Ranking Score: ${overall.toFixed(1)}`));
+    if (quality != null && Math.abs(overall - quality) > 0.05) {
+      console.log(chalk2.gray(`  Quality Score: ${quality.toFixed(1)}`));
+    }
+    console.log(chalk2.gray(`  Weighted Score: ${weighted.toFixed(1)}`));
+  }
+  /**
+   * Display winner selection results (streaming event)
+   */
+  displayWinnerSelection(event) {
+    if (isQuietOutputRequested()) return;
+    if (this.verbosity === "silent") return;
+    const winnerLabel = event.winner === "none" ? "No winner" : event.winner;
+    const confidenceLabel = `${(event.confidence * 100).toFixed(1)}%`;
+    if (this.verbosity === "minimal" || this.verbosity === "normal") {
+      console.log(chalk2.bold.green(`
+Winner: ${winnerLabel} (${confidenceLabel})`));
+      if (this.showRationale) {
+        console.log(chalk2.gray(`  Reason: ${event.rationale}`));
+      }
+      return;
+    }
+    console.log(chalk2.bold.green(`
+Winner Selected: ${winnerLabel}`));
+    console.log(chalk2.gray(`  Confidence: ${confidenceLabel}`));
+    if (this.showRationale) {
+      console.log(chalk2.gray(`  Rationale: ${event.rationale}`));
+    }
+  }
+  /**
+   * Create a simple progress bar
+   */
+  createProgressBar(progress, width) {
+    const filled = Math.round(progress / 100 * width);
+    return "#".repeat(filled) + ".".repeat(width - filled);
+  }
+  buildSummary(evaluation, variantResultsMap) {
+    const evaluations = Array.isArray(evaluation.evaluations) ? evaluation.evaluations : [];
+    const scored = evaluations.map((item) => ({
+      variant: item.variant ?? "UNKNOWN",
+      score: getEvaluationRankingScoreOrZero(item, "judge-display.buildSummary"),
+      primaryReason: item.primaryReason,
+      strengths: item.strengths ?? []
+    })).sort((a, b) => b.score - a.score);
+    const winnerScore = scored.find((entry) => entry.variant === evaluation.winner)?.score;
+    const runnerUp = scored.find((entry) => entry.variant !== evaluation.winner);
+    const margin = typeof winnerScore === "number" && runnerUp ? (winnerScore - runnerUp.score).toFixed(1) : void 0;
+    const confidence = typeof evaluation.metadata.confidence === "number" && Number.isFinite(evaluation.metadata.confidence) ? evaluation.metadata.confidence : void 0;
+    const durationLabel = evaluation.metadata.evaluationTimeMs < 1e3 ? `${evaluation.metadata.evaluationTimeMs}ms` : `${(evaluation.metadata.evaluationTimeMs / 1e3).toFixed(1)}s`;
+    const reasons = [];
+    if (evaluation.winnerPrimaryReason) {
+      reasons.push(evaluation.winnerPrimaryReason);
+    }
+    const winnerReason = scored.find((entry) => entry.variant === evaluation.winner);
+    if (winnerReason?.primaryReason) {
+      reasons.push(winnerReason.primaryReason);
+    }
+    if (winnerReason?.strengths && reasons.length < 2) {
+      reasons.push(...winnerReason.strengths.slice(0, 2 - reasons.length));
+    }
+    let isAnalysisMode = false;
+    if (variantResultsMap && evaluation.winner) {
+      const winnerResult = variantResultsMap.get(evaluation.winner);
+      if (winnerResult) {
+        const executionCategory = winnerResult.executionCategory;
+        const editMode = winnerResult.completenessScore?.editMode;
+        isAnalysisMode = executionCategory === "analysis" || editMode === "analysis" || winnerResult.executionIntent === "analysis";
+      }
+    }
+    return {
+      winner: evaluation.winner ?? "none",
+      runnerUp: runnerUp?.variant,
+      margin,
+      confidence,
+      confidenceLabel: confidence !== void 0 ? `${confidence.toFixed(1)}%` : void 0,
+      modelLabel: evaluation.metadata.model,
+      durationLabel,
+      reasons: reasons.slice(0, 2),
+      isAnalysisMode
+    };
+  }
+};
+
+// src/orchestrator/pr-workflow-coordinator-impl-core.ts
+var SynthesisWinnerRestorationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SynthesisWinnerRestorationError";
+  }
+};
+var CompetitionTimeoutFailure = class extends CompetitionTimeoutError {
+  observedResults;
+  drain;
+  /** True only when the execution cohort joined within the drain bound. */
+  cleanupJoined;
+  constructor(args) {
+    super(args.timeoutMs, args.completedVariants, args.totalVariants);
+    this.observedResults = sealVariantResultSnapshot(args.observedResults);
+    this.drain = args.drain;
+    this.cleanupJoined = args.drain.joined;
+  }
+};
+async function awaitBoundedCohortDrain(cohortPromise, drainMs = WORKER_EXIT_DRAIN_MS) {
+  const startedAt = Date.now();
+  let joined = false;
+  let drainTimer;
+  try {
+    await Promise.race([
+      Promise.resolve(cohortPromise).then(
+        () => {
+          joined = true;
+        },
+        () => {
+          joined = true;
+        }
+      ),
+      new Promise((resolve) => {
+        drainTimer = setTimeout(resolve, drainMs);
+      })
+    ]);
+  } finally {
+    if (drainTimer) {
+      clearTimeout(drainTimer);
+    }
+  }
+  return {
+    joined,
+    awaitedMs: Date.now() - startedAt,
+    pendingAtDeadline: joined ? 0 : 1,
+    settledCount: joined ? 1 : 0,
+    aborted: false
+  };
+}
+function markSynthesisWinnerFallback(mergedResult, fallbackReason, winner, applyError) {
+  mergedResult.deliverySucceeded = true;
+  mergedResult.synthesisApplied = false;
+  mergedResult.winnerFallback = true;
+  mergedResult.fallbackReason = fallbackReason;
+  mergedResult.patchApplyValidated = false;
+  mergedResult.gatesPassed = false;
+  mergedResult.winnerClone = true;
+  mergedResult.noveltyScore ??= 0;
+  if (winner) {
+    const winnerId = formatVariantIdentifierFromResult(winner);
+    mergedResult.mergedVariants = [winnerId];
+    mergedResult.contributingVariants = [winnerId];
+  }
+  if (mergedResult.aiGuidedFallbackAttempted === true) {
+    if (applyError) {
+      mergedResult.aiGuidedFallbackOutcome = "candidate_rejected";
+    } else if (mergedResult.aiGuidedFallbackOutcome !== "generation_failed") {
+      mergedResult.aiGuidedFallbackOutcome = "winner_equivalent";
+    }
+  }
+  if (applyError) {
+    mergedResult.applyError = applyError;
+    mergedResult.error ??= applyError;
+  }
+  if (!mergedResult.synthesisOutcomeStatus || mergedResult.synthesisOutcomeStatus === "applied") {
+    mergedResult.synthesisOutcomeStatus = applyError ? "gate_failed" : "winner_carry_forward";
+  }
+}
+function markTypecheckOnlySynthesisFallback(mergedResult, winner, detail) {
+  const fallbackReason = detail ? `Synthesis passed legacy typecheck-only validation, but full deterministic gates were not run; winner-only result retained (${detail})` : "Synthesis passed legacy typecheck-only validation, but full deterministic gates were not run; winner-only result retained";
+  markSynthesisWinnerFallback(mergedResult, fallbackReason, winner);
+  mergedResult.validationScope = "typecheck-only";
+}
+async function cleanupAgenticSynthesisWorktree(synthesisWorktree, preserveWorktrees) {
+  if (preserveWorktrees || !synthesisWorktree.trim()) return;
+  const worktreeAvailable = await fs.access(synthesisWorktree).then(() => true).catch(() => false);
+  if (!worktreeAvailable) return;
+  const repoRootResult = await execa("git", ["rev-parse", "--show-toplevel"], {
+    cwd: synthesisWorktree,
+    reject: false
+  });
+  await execa("git", ["worktree", "remove", synthesisWorktree, "--force"], {
+    cwd: repoRootResult.stdout.trim() || process.cwd(),
+    reject: false
+  });
+  await fs.rm(synthesisWorktree, { recursive: true, force: true }).catch(() => {
+  });
+}
+function resolveSynthesisVerifyCommands(worktreePath) {
+  try {
+    const capabilities = detectProjectCapabilities(worktreePath);
+    const guidance = buildProjectVerificationGuidance(worktreePath);
+    const derived = [];
+    for (const command of guidance.commands) {
+      if (command.kind === "typecheck" || command.kind === "build") {
+        derived.push(command.command);
+      }
+    }
+    const deduped = [...new Set(derived)];
+    if (deduped.length > 0) {
+      return { available: true, commands: deduped };
+    }
+    if (hasProjectLanguage(capabilities, "typescript") && capabilities.manifests?.tsconfig) {
+      return { available: true, commands: ["npx --no-install tsc --noEmit"] };
+    }
+    return { available: false, commands: [] };
+  } catch {
+    return { available: false, commands: [] };
+  }
+}
+function shouldSelectCompetitionWinner(input) {
+  return input.total > 0 && input.completed > 0 && !(input.judgeOff && input.total > 1);
+}
+var PRWorkflowOrchestrator = class {
+  prManager;
+  localExecutor;
+  variantOrchestrator;
+  verbose;
+  orchestratorTimeoutMs;
+  orchestratorDeadlineMs;
+  executorTimeoutMs;
+  cleanupOnCompletion;
+  localFastMode;
+  pushLocalVariants;
+  preserveWorktrees;
+  aiJudge;
+  judgeOff;
+  aiJudgeModel;
+  aiJudgeVerbose;
+  aiJudgeShowRationale;
+  aiJudgeVerbosity;
+  aiJudgeCriteriaWeights;
+  aiJudgeMinScore;
+  aiJudgeConfidenceThreshold;
+  aiJudgeStreaming;
+  aiJudgeTelemetry;
+  aiJudgeRun;
+  aiJudgePrimary;
+  judgeModels;
+  judgeModel;
+  judgeAllowUnsafeModel;
+  judgeStrict;
+  anonymizeJudge;
+  verificationMode;
+  synthesize;
+  synthesisTopN;
+  synthesisStrategy;
+  synthesisModel;
+  resultStreamer;
+  processLifecycle;
+  ownsProcessLifecycle;
+  enableAutoTuning;
+  enablePromptOptimization;
+  costTracker;
+  workspaceAgentRunner;
+  outputValidator;
+  branchListCache;
+  BRANCH_LIST_CACHE_TTL_MS = 60 * 1e3;
+  // 60 seconds
+  cleanupService;
+  judgeDisplayService;
+  judgeListenerCleanup;
+  ownsResultStreamer;
+  repoRoot;
+  // Dependency-aware execution (experimental)
+  flywheel;
+  taskDependencies;
+  globalMaxConcurrent;
+  sharedVariantResourceManager;
+  dependencyResolver;
+  resourceManager;
+  constructor(options = {}) {
+    this.repoRoot = findProjectRoot(process.cwd()) ?? process.cwd();
+    const verbosityLevel = validateVerbosity(options.verbose);
+    this.verbose = verbosityLevel === "detailed" || verbosityLevel === "debug";
+    this.localFastMode = options.localFast ?? false;
+    this.pushLocalVariants = options.noPush === true ? false : options.pushLocalVariants ?? getRuntimeEnv("POETIC_PUSH_VARIANTS") === "1";
+    this.cleanupOnCompletion = (options.cleanupOnCompletion ?? true) && !this.localFastMode;
+    this.preserveWorktrees = options.preserveWorktrees ?? getRuntimeEnv("POETIC_PRESERVE_WORKTREES") === "1";
+    this.aiJudge = options.aiJudge ?? true;
+    this.judgeOff = options.judgeOff ?? false;
+    this.aiJudgeModel = options.aiJudgeModel;
+    this.aiJudgeShowRationale = options.aiJudgeShowRationale ?? false;
+    this.aiJudgeRun = options.aiJudgeRun;
+    this.aiJudgePrimary = options.aiJudgePrimary;
+    this.judgeModels = options.judgeModels;
+    this.judgeModel = options.judgeModel;
+    this.judgeAllowUnsafeModel = options.judgeAllowUnsafeModel;
+    this.judgeStrict = options.judgeStrict ?? false;
+    this.anonymizeJudge = options.anonymizeJudge;
+    this.aiJudgeVerbosity = validateVerbosity(void 0, options.aiJudgeVerbosity);
+    this.aiJudgeVerbose = this.aiJudgeVerbosity === "detailed" || this.aiJudgeVerbosity === "debug";
+    this.aiJudgeCriteriaWeights = options.aiJudgeCriteriaWeights;
+    if (options.aiJudgeMinScore !== void 0) {
+      this.aiJudgeMinScore = validatePercentage(options.aiJudgeMinScore, "aiJudgeMinScore", {
+        min: 0,
+        max: 100,
+        allowFractional: false
+      });
+    } else {
+      this.aiJudgeMinScore = void 0;
+    }
+    if (options.aiJudgeConfidenceThreshold !== void 0) {
+      this.aiJudgeConfidenceThreshold = validateConfidence(options.aiJudgeConfidenceThreshold, {
+        fieldName: "aiJudgeConfidenceThreshold"
+      });
+    } else {
+      this.aiJudgeConfidenceThreshold = void 0;
+    }
+    this.aiJudgeStreaming = options.aiJudgeStreaming;
+    this.aiJudgeTelemetry = options.aiJudgeTelemetry ?? true;
+    this.verificationMode = options.verificationMode ?? "auto";
+    this.synthesize = options.synthesize ?? true;
+    this.synthesisTopN = options.synthesisTopN ?? 2;
+    this.synthesisStrategy = options.synthesisStrategy ?? "agentic-synthesis";
+    this.synthesisModel = options.synthesisModel ?? resolveSynthesisModel().value;
+    this.enableAutoTuning = options.enableAutoTuning ?? false;
+    this.enablePromptOptimization = options.enablePromptOptimization ?? true;
+    this.resultStreamer = options.resultStreamer;
+    this.ownsResultStreamer = !options.resultStreamer;
+    this.branchListCache = /* @__PURE__ */ new Map();
+    this.flywheel = options.flywheel ?? false;
+    this.taskDependencies = options.taskDependencies;
+    this.globalMaxConcurrent = Math.max(
+      1,
+      resolveLocalWorktreeConcurrency(options.globalMaxConcurrent, void 0)
+    );
+    this.sharedVariantResourceManager = options.sharedVariantResourceManager;
+    if (this.flywheel) {
+      this.dependencyResolver = new DependencyGraphResolver();
+      this.resourceManager = new ProviderAwareResourceManager({
+        globalMaxConcurrent: this.globalMaxConcurrent,
+        fairnessMode: "weighted-fair",
+        enableTelemetry: true
+      });
+      if (this.taskDependencies) {
+        const graph = this.dependencyResolver.buildGraph(this.taskDependencies);
+        const validation = this.dependencyResolver.validateGraph(graph);
+        if (!validation.valid) {
+          throw new Error(`Invalid task dependencies: ${validation.errors.join(", ")}`);
+        }
+        if (validation.warnings && validation.warnings.length > 0 && this.verbose) {
+          emitWarning(
+            "CFG-002",
+            {
+              taskId: "unknown",
+              subsystem: "orchestrator",
+              executionPhase: "setup"
+            },
+            {
+              severity: "INFO" /* INFO */,
+              metadata: {
+                operation: "validateDependencyGraph",
+                warnings: validation.warnings
+              }
+            }
+          );
+        }
+      }
+    }
+    this.executorTimeoutMs = validateTimeout(options.executorTimeoutMinutes, "minutes", {
+      defaultMs: 45 * 60 * 1e3,
+      // 45 minutes default
+      minMs: 1 * 60 * 1e3,
+      // 1 minute minimum
+      maxMs: MAX_PER_VARIANT_TIMEOUT_MINUTES * 60 * 1e3,
+      fieldName: "executorTimeoutMinutes"
+    });
+    this.orchestratorTimeoutMs = validateTimeout(options.timeoutMinutes, "minutes", {
+      defaultMs: 90 * 60 * 1e3,
+      // 90 minutes default
+      minMs: 1 * 60 * 1e3,
+      // 1 minute minimum
+      maxMs: 1440 * 60 * 1e3,
+      // 24 hours maximum
+      fieldName: "timeoutMinutes"
+    });
+    if (this.orchestratorTimeoutMs < this.executorTimeoutMs) {
+      const originalOrchestratorMin = this.orchestratorTimeoutMs / 6e4;
+      const executorMin = this.executorTimeoutMs / 6e4;
+      emitWarning(
+        "CFG-002",
+        {
+          taskId: "unknown",
+          subsystem: "orchestrator",
+          executionPhase: "setup"
+        },
+        {
+          severity: "WARN" /* WARN */,
+          metadata: {
+            operation: "validateTimeouts",
+            originalOrchestratorTimeoutMin: originalOrchestratorMin,
+            executorTimeoutMin: executorMin,
+            adjustedOrchestratorTimeoutMin: executorMin,
+            reason: "Orchestrator timeout must be >= executor timeout to prevent premature termination",
+            suggestedFix: `Set --timeout ${Math.ceil(executorMin)} (or higher) to avoid auto-adjustment`
+          }
+        }
+      );
+      console.warn(
+        `
+Timeout Auto-Adjustment:
+   Orchestrator timeout (${originalOrchestratorMin} min) was less than executor timeout (${executorMin} min).
+   Auto-adjusted orchestrator timeout to ${executorMin} min to prevent premature termination.
+   
+   To configure properly:
+   - Set orchestrator timeout: --timeout ${Math.ceil(executorMin)} (or higher)
+   - Or reduce executor timeout: --executor-timeout ${Math.floor(originalOrchestratorMin)}
+`
+      );
+      this.orchestratorTimeoutMs = this.executorTimeoutMs;
+    }
+    if (options.deadlineMs !== void 0) {
+      if (!Number.isFinite(options.deadlineMs)) {
+        throw new Error(`deadlineMs must be a finite timestamp, got: ${options.deadlineMs}`);
+      }
+      this.orchestratorDeadlineMs = options.deadlineMs;
+      this.orchestratorTimeoutMs = this.resolveRemainingOrchestratorTimeoutMs();
+      this.executorTimeoutMs = Math.min(this.executorTimeoutMs, this.orchestratorTimeoutMs);
+    }
+    this.prManager = new GitHubPRManager();
+    this.workspaceAgentRunner = new WorkspaceAgentRunner();
+    this.outputValidator = new UniversalOutputValidator();
+    try {
+      const costCalculator = new UniversalCostCalculator(TelemetryLogger.getInstance());
+      this.costTracker = new UnifiedCostTracker(costCalculator, TelemetryLogger.getInstance(), {
+        enabled: true,
+        budgetThresholds: {
+          warning: 10,
+          critical: 50,
+          daily: 100,
+          monthly: 1e3
+        },
+        optimization: {
+          enableSuggestions: false,
+          // Disable suggestions for now
+          minSavingsThreshold: 1,
+          maxSuggestionsPerHour: 5
+        },
+        updateIntervalMs: 3e4
+        // 30 seconds
+      });
+    } catch (error) {
+      if (this.verbose) {
+        emitWarning(
+          "CFG-002",
+          {
+            taskId: "unknown",
+            subsystem: "orchestrator",
+            executionPhase: "setup"
+          },
+          {
+            severity: "WARN" /* WARN */,
+            metadata: {
+              error: error instanceof Error ? error.message : String(error),
+              operation: "costTrackingInit"
+            }
+          }
+        );
+      }
+    }
+    this.localExecutor = new LocalExecutor({
+      prManager: this.prManager,
+      verbose: this.verbose,
+      executorTimeoutMs: this.executorTimeoutMs,
+      costTracker: this.costTracker,
+      workspaceAgentRunner: this.workspaceAgentRunner,
+      outputValidator: this.outputValidator,
+      preserveWorktrees: this.preserveWorktrees,
+      resultStreamer: this.resultStreamer
+    });
+    this.variantOrchestrator = new VariantOrchestrator();
+    const existingProcessLifecycle = getProcessLifecycleManager();
+    if (existingProcessLifecycle instanceof ProcessLifecycleManager) {
+      this.processLifecycle = existingProcessLifecycle;
+      this.ownsProcessLifecycle = false;
+    } else {
+      this.processLifecycle = new ProcessLifecycleManager({
+        verbose: this.verbose,
+        defaultTimeoutMinutes: options.executorTimeoutMinutes ?? 45,
+        maxConcurrentProcesses: 50,
+        cleanupOnTermination: true
+      });
+      setProcessLifecycleManager(this.processLifecycle);
+      this.ownsProcessLifecycle = true;
+    }
+    this.cleanupService = new CleanupService(
+      this.prManager,
+      this.verbose,
+      {
+        cleanup: (worktreePath) => this.localExecutor.releaseWorktreeForBranchCleanup(worktreePath)
+      },
+      this.repoRoot
+    );
+    this.judgeDisplayService = new JudgeDisplayService({
+      verbosity: this.aiJudgeVerbosity,
+      showRationale: this.aiJudgeShowRationale,
+      streaming: this.aiJudgeStreaming
+    });
+  }
+  async executeLocalVariant(taskId, variant, prompt, retryMeta, abortSignal) {
+    if (this.pushLocalVariants) {
+      return this.localExecutor.executeVariantWithRetry(taskId, variant, prompt, {
+        iterationIndex: retryMeta?.iterationIndex ?? 0,
+        abortSignal
+      });
+    }
+    const outcome = await this.localExecutor.executeVariantFastWithRetry(taskId, variant, prompt, {
+      commit: false,
+      cleanup: false,
+      iterationIndex: retryMeta?.iterationIndex ?? 0,
+      abortSignal
+    });
+    return outcome.result;
+  }
+  resolveRemainingOrchestratorTimeoutMs() {
+    if (this.orchestratorDeadlineMs === void 0) {
+      return this.orchestratorTimeoutMs;
+    }
+    const remainingDeadlineMs = this.orchestratorDeadlineMs - Date.now();
+    if (remainingDeadlineMs <= 0) {
+      throw new Error("deadlineMs must be in the future");
+    }
+    return Math.min(this.orchestratorTimeoutMs, remainingDeadlineMs);
+  }
+  /**
+   * Execute all variants in competition
+   * Returns results for all variants
+   */
+  async executeVariants(taskId, prompt, variants, retryMeta) {
+    const observedResults = [];
+    try {
+      initEvaluationHandle(taskId, prompt, variants);
+    } catch (handleError) {
+      console.warn(
+        `Failed to initialize competition handle for task ${taskId}: ${handleError instanceof Error ? handleError.message : String(handleError)}`
+      );
+      debugLog("Full stack:", handleError);
+    }
+    this.orchestratorTimeoutMs = this.resolveRemainingOrchestratorTimeoutMs();
+    const outerController = new AbortController();
+    let timeoutHandle;
+    let timedOut = false;
+    const timeoutPromise = new Promise((_, reject) => {
+      timeoutHandle = setTimeout(() => {
+        timedOut = true;
+        outerController.abort(
+          new Error(`Orchestrator timeout after ${this.orchestratorTimeoutMs / 6e4} minutes`)
+        );
+        reject(
+          new Error(`Orchestrator timeout after ${this.orchestratorTimeoutMs / 6e4} minutes`)
+        );
+      }, this.orchestratorTimeoutMs);
+    });
+    let finalResult = null;
+    let finalError;
+    let lastDrain;
+    const cohortPromise = this.executeVariantsInternal(
+      taskId,
+      prompt,
+      variants,
+      retryMeta,
+      observedResults,
+      outerController.signal
+    );
+    try {
+      finalResult = await Promise.race([cohortPromise, timeoutPromise]);
+      if (timeoutHandle) {
+        clearTimeout(timeoutHandle);
+        timeoutHandle = void 0;
+      }
+      try {
+        await this.close();
+      } catch (cleanupErr) {
+        console.warn(
+          `Cleanup error (post-success): ${cleanupErr instanceof Error ? cleanupErr.message : String(cleanupErr)}`
+        );
+      }
+      return finalResult;
+    } catch (error) {
+      if (timedOut || error instanceof Error && error.message.includes("Orchestrator timeout")) {
+        const sealedResults = sealVariantResultSnapshot(observedResults);
+        const completedCount = countCompletedCompetitionObservations(sealedResults);
+        lastDrain = await awaitBoundedCohortDrain(cohortPromise);
+        const timeoutFailure = new CompetitionTimeoutFailure({
+          timeoutMs: this.orchestratorTimeoutMs,
+          completedVariants: completedCount,
+          totalVariants: variants.length,
+          observedResults: sealedResults,
+          drain: lastDrain
+        });
+        finalError = timeoutFailure;
+        console.log(chalk3.yellow(`
+${timeoutFailure.message}`));
+        if (completedCount === 0) {
+          console.log(chalk3.red("Timeout occurred before any variants completed\n"));
+        } else {
+          console.log(
+            chalk3.red(
+              `Timeout after ${completedCount}/${variants.length} variants completed` + (lastDrain.joined ? "" : " (cleanup did not fully join within drain bound)") + "\n"
+            )
+          );
+        }
+        try {
+          await this.close();
+        } catch (cleanupErr) {
+          console.warn(
+            `Cleanup error: ${cleanupErr instanceof Error ? cleanupErr.message : String(cleanupErr)}`
+          );
+          debugLog("Full cleanup error:", cleanupErr);
+        }
+        throw timeoutFailure;
+      }
+      finalError = error;
+      try {
+        await this.close();
+      } catch (cleanupErr) {
+        console.warn(
+          `Cleanup error: ${cleanupErr instanceof Error ? cleanupErr.message : String(cleanupErr)}`
+        );
+        debugLog("Full cleanup error:", cleanupErr);
+        emitWarning(
+          "PR-001",
+          {
+            taskId,
+            subsystem: "orchestrator",
+            executionPhase: "cleanup"
+          },
+          {
+            severity: "WARN" /* WARN */,
+            metadata: {
+              error: cleanupErr instanceof Error ? cleanupErr.message : String(cleanupErr),
+              operation: "cleanup"
+            }
+          }
+        );
+      }
+      throw error;
+    } finally {
+      if (timeoutHandle) {
+        clearTimeout(timeoutHandle);
+      }
+      const completedAt = (/* @__PURE__ */ new Date()).toISOString();
+      if (finalResult) {
+        const anySuccess = finalResult.variants.some((variant) => variant.success);
+        const ungradedIdentity = this.judgeOff && finalResult.variants.length === 1 && finalResult.winner !== null;
+        const decision = this.judgeOff ? {
+          outcome: "none",
+          reason: "judge_off",
+          decisionStatus: "not_run",
+          decisionOutcome: "no_judge",
+          primaryJudge: "n/a"
+        } : void 0;
+        const finalState = ungradedIdentity ? createEvaluationHandleFinalState({
+          outcome: "no_winner",
+          completedAt,
+          winner: null,
+          decision
+        }) : finalResult.winner ? createEvaluationHandleFinalState({
+          outcome: "winner_selected",
+          completedAt,
+          winner: {
+            provider: finalResult.winner.provider,
+            model: finalResult.winner.model,
+            strategy: finalResult.winner.strategy,
+            executionMode: finalResult.winner.executionMode,
+            variant: finalResult.winner.variant
+          },
+          decision
+        }) : createEvaluationHandleFinalState({
+          outcome: anySuccess ? "no_winner" : "all_failed",
+          completedAt,
+          winner: null,
+          decision
+        });
+        const finalizeResult = finalizeEvaluationHandle(taskId, finalState);
+        if (finalizeResult.kind === "persistence_failed" && !isDurableHandleCompletion(finalizeResult, anySuccess ? "completed" : "failed")) {
+          console.warn(
+            `Evaluation handle persistence failed for ${taskId}: ${finalizeResult.error}`
+          );
+        }
+      } else if (finalError) {
+        const message = finalError instanceof Error ? finalError.message : String(finalError);
+        const isTimeout = finalError instanceof CompetitionTimeoutFailure || /orchestrator timeout|competition timed out/i.test(message);
+        const finalizeResult = finalizeEvaluationHandle(
+          taskId,
+          createEvaluationHandleFinalState({
+            outcome: isTimeout ? "timed_out" : "error",
+            completedAt,
+            errorMessage: finalError instanceof CompetitionTimeoutFailure ? `${message}; cleanupJoined=${finalError.cleanupJoined}` : message,
+            winner: null
+          })
+        );
+        if (finalizeResult.kind === "persistence_failed") {
+          console.warn(
+            `Evaluation handle persistence failed for ${taskId}: ${finalizeResult.error}`
+          );
+        }
+      }
+    }
+  }
+  /**
+   * Internal method to execute all variants (without timeout wrapper)
+   */
+  async executeVariantsInternal(taskId, prompt, variants, retryMeta, observedResults = [], outerSignal) {
+    console.log(chalk3.bold.cyan("\nPoetic Variant Competition\n"));
+    console.log(chalk3.gray(`Task ID: ${taskId}`));
+    console.log(chalk3.gray(`Variants: ${variants.length}`));
+    console.log(chalk3.gray(`Executor timeout: ${this.executorTimeoutMs / 6e4} minutes`));
+    console.log(
+      chalk3.gray(
+        `Orchestrator timeout: ${this.orchestratorTimeoutMs / 6e4} minutes (safety net)
+`
+      )
+    );
+    if (this.aiJudgeStreaming) {
+      const { ResultStreamer } = await import("./result-streamer-WEHW476R.js");
+      if (!this.resultStreamer) {
+        this.resultStreamer = new ResultStreamer();
+        this.ownsResultStreamer = true;
+      }
+      this.localExecutor.setResultStreamer(this.resultStreamer);
+      this.judgeDisplayService.setResultStreamer(this.resultStreamer);
+      this.judgeListenerCleanup = this.judgeDisplayService.setupStreamingListeners(taskId);
+    }
+    const localVariants = variants;
+    console.log(chalk3.blue("Execution Plan:"));
+    console.log(chalk3.gray(`  Local variants: ${localVariants.length}
+`));
+    const results = [];
+    if (this.flywheel && this.dependencyResolver && this.resourceManager) {
+      console.log(chalk3.bold.blue("Executing Variants with Dependency Awareness\n"));
+      return this.executeVariantsWithDependencies(
+        taskId,
+        prompt,
+        variants,
+        results,
+        retryMeta,
+        outerSignal
+      );
+    }
+    console.log(chalk3.bold.blue("Executing All Variants in Parallel\n"));
+    const allPromises = [];
+    const localResourceManager = this.sharedVariantResourceManager ?? createLocalVariantResourceManager(this.globalMaxConcurrent);
+    const controller = new AbortController();
+    const signal = controller.signal;
+    if (outerSignal) {
+      if (outerSignal.aborted) {
+        controller.abort(outerSignal.reason);
+      } else {
+        outerSignal.addEventListener("abort", () => controller.abort(outerSignal.reason), {
+          once: true
+        });
+      }
+    }
+    const geminiCount = localVariants.filter((v) => v.provider === "gemini").length;
+    if (geminiCount > 1 && isVerboseOutputRequested()) {
+      console.log(
+        chalk3.cyan(
+          `Running ${geminiCount} Gemini variant(s) in parallel (HOME isolation, auto-fallback to serial on ECONNRESET)
+`
+        )
+      );
+    }
+    const localPromises = localVariants.map((variant) => {
+      const variantLabel = `${variant.provider} ${variant.model || "default-model"} ${variant.strategy}`;
+      return (async () => {
+        let providerId;
+        try {
+          providerId = toConcurrencyProviderId(variant.provider);
+        } catch (err) {
+          const failureResult = this.buildFailureResult(variant, err, 0);
+          this.logVariantCompleteSafe(taskId, variant, failureResult);
+          return failureResult;
+        }
+        const acquisitionTimeoutMs = this.orchestratorTimeoutMs ?? 30 * 60 * 1e3;
+        if (process.env.DEBUG_ORCHESTRATOR) {
+          console.warn(
+            `[DEBUG ORCHESTRATOR] Acquiring resource for ${providerId} (timeout: ${acquisitionTimeoutMs}ms)...`
+          );
+        }
+        const handle = await localResourceManager.acquire(providerId, signal, acquisitionTimeoutMs);
+        const startTime = Date.now();
+        this.logVariantStartSafe(taskId, variant);
+        console.log(chalk3.cyan(`\u2192 Starting: ${variantLabel} ${chalk3.gray("(local)")}`));
+        try {
+          const result = await this.executeLocalVariant(taskId, variant, prompt, retryMeta, signal);
+          observedResults.push(result);
+          const elapsed = ((Date.now() - startTime) / 1e3).toFixed(1);
+          if (result?.success) {
+            console.log(
+              chalk3.green(
+                `${variantLabel}: Completed in ${elapsed}s (local)${result?.prNumber ? ` (PR #${result.prNumber})` : ""}
+`
+              )
+            );
+          } else {
+            console.log(
+              chalk3.red(
+                `${variantLabel}: Failed after ${elapsed}s - ${result?.error?.message || "Unknown error"}
+`
+              )
+            );
+            const errorMsg = result?.error?.message?.toLowerCase() ?? "";
+            if (errorMsg.includes("rate limit") || errorMsg.includes("ratelimit") || errorMsg.includes("too many requests") || matchesErrorPattern(errorMsg, "429")) {
+              recordProviderRateLimit(providerId);
+            }
+          }
+          try {
+            updateEvaluationHandleWithResult(taskId, result);
+          } catch (handleError) {
+            console.warn(
+              `Failed to update competition handle for local task ${taskId} variant ${variant.provider}-${variant.strategy}: ${handleError instanceof Error ? handleError.message : String(handleError)}`
+            );
+            debugLog("Full stack:", handleError);
+          }
+          this.logVariantCompleteSafe(taskId, variant, result);
+          return result;
+        } catch (error) {
+          const elapsedSeconds = (Date.now() - startTime) / 1e3;
+          const elapsed = elapsedSeconds.toFixed(1);
+          console.log(
+            chalk3.red(
+              `${variantLabel}: Error after ${elapsed}s - ${error instanceof Error ? error.message : String(error)}
+`
+            )
+          );
+          const errorMsg = error instanceof Error ? error.message.toLowerCase() : "";
+          if (errorMsg.includes("rate limit") || errorMsg.includes("ratelimit") || errorMsg.includes("too many requests") || matchesErrorPattern(errorMsg, "429")) {
+            recordProviderRateLimit(providerId);
+          }
+          const failureResult = this.buildFailureResult(variant, error, elapsedSeconds);
+          observedResults.push(failureResult);
+          try {
+            updateEvaluationHandleWithResult(taskId, failureResult);
+          } catch (handleError) {
+            console.warn(
+              `Failed to update competition handle for failed local task ${taskId} variant ${variant.provider}-${variant.strategy}: ${handleError instanceof Error ? handleError.message : String(handleError)}`
+            );
+            debugLog("Full stack:", handleError);
+          }
+          this.logVariantCompleteSafe(taskId, variant, failureResult);
+          return failureResult;
+        } finally {
+          await handle.release();
+        }
+      })();
+    });
+    allPromises.push(...localPromises);
+    const allResults = await Promise.allSettled(allPromises);
+    if (outerSignal?.aborted) {
+      throw outerSignal.reason instanceof Error ? outerSignal.reason : new Error("Variant execution aborted");
+    }
+    allResults.forEach((result) => {
+      if (result.status === "fulfilled") {
+        results.push(result.value);
+      } else if (result.status === "rejected") {
+        const failureResult = {
+          success: false,
+          error: result.reason instanceof Error ? result.reason : new Error(String(result.reason)),
+          duration: 0,
+          provider: "unknown",
+          variant: "unknown",
+          executionMode: "local",
+          strategy: "unknown",
+          completeness: 0
+        };
+        results.push(failureResult);
+      }
+    });
+    const state = this.getVariantState(results);
+    this.logVariantApplicationWarnings(results);
+    console.log(chalk3.bold.blue("\nCompetition Results\n"));
+    if (state.completed < state.total || state.succeeded === 0) {
+      console.log(
+        chalk3.yellow(
+          state.succeeded === 0 ? this.judgeOff ? "No successful variants; no judge ran (--judge off)" : "No successful variants - judges will still evaluate available results" : `Partial Results - Only ${state.completed}/${state.total} variants completed`
+        )
+      );
+      console.log(
+        chalk3.gray(
+          `   Succeeded: ${state.succeeded}, Failed: ${state.failed}, Timed out: ${state.timedOut}
+`
+        )
+      );
+    }
+    if (outerSignal?.aborted) {
+      throw outerSignal.reason instanceof Error ? outerSignal.reason : new Error("Variant execution aborted before judge selection");
+    }
+    const winner = this.shouldRunWinnerSelection(state) ? await this.variantOrchestrator.selectWinner(results, {
+      useAIJudge: this.aiJudge,
+      originalPrompt: prompt,
+      model: this.aiJudgeModel,
+      aiJudgeVerbose: this.aiJudgeVerbose,
+      aiJudgeShowRationale: this.aiJudgeShowRationale,
+      aiJudgeCriteriaWeights: this.aiJudgeCriteriaWeights,
+      aiJudgeMinScore: this.aiJudgeMinScore,
+      aiJudgeConfidenceThreshold: this.aiJudgeConfidenceThreshold,
+      aiJudgeStreaming: this.aiJudgeStreaming,
+      aiJudgeRun: this.aiJudgeRun,
+      aiJudgePrimary: this.aiJudgePrimary,
+      judgeModels: this.judgeModels,
+      judgeModel: this.judgeModel,
+      judgeAllowUnsafeModel: this.judgeAllowUnsafeModel,
+      judgeStrict: this.judgeStrict,
+      anonymizeJudge: this.anonymizeJudge,
+      aiJudgeVerbosity: this.aiJudgeVerbosity,
+      verificationMode: this.verificationMode,
+      resultStreamer: this.resultStreamer,
+      // Enable streaming for final results
+      taskId,
+      competitionMode: true,
+      aiJudgeTelemetry: this.aiJudgeTelemetry,
+      ungradedIdentity: this.judgeOff && state.total === 1
+    }) : null;
+    if (winner && !this.judgeOff && this.shouldTriggerOptimization(results)) {
+      try {
+        const optimizer = new AutomaticPromptOptimizer({
+          telemetryLogger: this.getTelemetryLogger(),
+          enableAutoTuning: this.enableAutoTuning ?? false
+        });
+        const recommendation = await optimizer.analyzePrompt(prompt);
+        if (recommendation && recommendation.action !== "no_action" && recommendation.action !== "needs_more_data") {
+          const optimizationResult = await optimizer.optimizePrompt(prompt, recommendation);
+          if (this.verbose) {
+            console.log(chalk3.gray("Prompt optimization analysis complete"));
+            if (optimizationResult.improvements.length > 0) {
+              console.log(chalk3.gray(`  Improvements: ${optimizationResult.improvements.length}`));
+            }
+            if (optimizationResult.warnings.length > 0) {
+              console.log(chalk3.yellow(`  Warnings: ${optimizationResult.warnings.length}`));
+            }
+          }
+        }
+        optimizer.close();
+      } catch (optimizationError) {
+        if (this.verbose) {
+          console.log(
+            chalk3.yellow(
+              `Prompt optimization skipped: ${optimizationError instanceof Error ? optimizationError.message : String(optimizationError)}`
+            )
+          );
+        }
+      }
+    }
+    this.displayResults(results, winner);
+    if (winner?.judgeEvaluation) {
+      const variantResultsMap = new Map(results.map((r) => [r.variant, r]));
+      this.judgeDisplayService.displayEvaluation(winner.judgeEvaluation, variantResultsMap);
+    }
+    let mergedResult = null;
+    if (this.synthesize && winner) {
+      console.log(chalk3.blue("\nGenerating synthesized solution from top variants...\n"));
+      try {
+        const { VariantResultsMerger } = await import("./synthesis-TGQUVAW3.js");
+        const merger = new VariantResultsMerger({
+          defaultTopN: 2,
+          defaultStrategy: "agentic-synthesis",
+          maxVariantsToMerge: 5
+        });
+        const synthesisMergeOptions = {
+          enabled: true,
+          topN: this.synthesisTopN,
+          createPR: false,
+          strategy: this.synthesisStrategy,
+          taskId,
+          aiModel: this.synthesisModel,
+          taskDescription: prompt,
+          judgeRationale: winner?.judgeEvaluation?.winnerPrimaryReason ?? winner?.judgeEvaluation?.rationalePacket?.selectionRationale.primary ?? winner?.judgeEvaluation?.reasoning ?? void 0,
+          judgeContext: this.variantOrchestrator.getLastSynthesisJudgeContext(),
+          declaredWinner: winner ? { provider: winner.provider, variant: winner.variant } : void 0
+        };
+        mergedResult = await merger.merge(results, synthesisMergeOptions);
+        if (mergedResult?.success) {
+          mergedResult.mergeGenerated = true;
+          mergedResult.complementaryPatchApplied = false;
+          mergedResult.deliverySucceeded = true;
+          mergedResult.synthesisApplied = false;
+          mergedResult.winnerFallback = mergedResult.winnerFallback === true || mergedResult.winnerClone === true;
+          mergedResult.patchApplyValidated = false;
+          mergedResult.gatesPassed = false;
+          if (mergedResult.winnerClone === true) {
+            mergedResult.fallbackReason = mergedResult.reasoning;
+            mergedResult.synthesisOutcomeStatus ??= "winner_carry_forward";
+          }
+        }
+        if (mergedResult) {
+          const selectedVariants = resolveSynthesisSelectedVariants(
+            results,
+            mergedResult.inputVariants
+          );
+          const synthesisTelemetry = buildSynthesisTelemetrySnapshot({
+            results,
+            topVariants: selectedVariants,
+            declaredWinner: synthesisMergeOptions.declaredWinner,
+            synthesisIntents: synthesisMergeOptions.synthesisIntents,
+            intentFilteredMaterial: synthesisMergeOptions.intentFilteredMaterial
+          });
+          if (synthesisTelemetry) {
+            Object.assign(mergedResult, synthesisTelemetry);
+          }
+        }
+        if (mergedResult?.success) {
+          console.log(chalk3.green("\nSynthesis complete"));
+          console.log(chalk3.gray(`   ${mergedResult.reasoning}`));
+          const winnerWorktree = winner?.retainedWorktreePath;
+          if (this.synthesisStrategy === "agentic-synthesis" && mergedResult.synthesisWorktreePath) {
+            const synthesisWorktree = mergedResult.synthesisWorktreePath.trim();
+            try {
+              if (!synthesisWorktree) {
+                throw new Error("missing synthesis worktree path");
+              }
+              const verifyPlan = resolveSynthesisVerifyCommands(synthesisWorktree);
+              if (!verifyPlan.available) {
+                markSynthesisWinnerFallback(
+                  mergedResult,
+                  "Agentic synthesis worktree verification unavailable for the target language; winner-only result retained",
+                  winner
+                );
+                console.warn(
+                  chalk3.yellow(
+                    "   Agentic synthesis worktree verification unavailable: no deterministic typecheck/build signal detected for the target language."
+                  )
+                );
+                console.warn(
+                  chalk3.gray(
+                    "     Retaining the judged winner without complementary donor changes."
+                  )
+                );
+                await cleanupAgenticSynthesisWorktree(synthesisWorktree, this.preserveWorktrees);
+              } else {
+                const verifyResult = await runVerifyCommands({
+                  cwd: synthesisWorktree,
+                  baselineCwd: winnerWorktree,
+                  // Never let validation auto-install into the product worktree.
+                  // If the toolchain is unavailable, retain the judged winner.
+                  commands: verifyPlan.commands,
+                  timeoutMs: 6e4
+                });
+                mergedResult.validationScope = "typecheck-only";
+                if (verifyResult.passed) {
+                  markTypecheckOnlySynthesisFallback(
+                    mergedResult,
+                    winner,
+                    "Agentic synthesis was not promoted because PR workflow validation is typecheck-only"
+                  );
+                  await cleanupAgenticSynthesisWorktree(synthesisWorktree, this.preserveWorktrees);
+                } else {
+                  const failedResult = verifyResult.results.find((result) => result.exitCode !== 0);
+                  const baselineAwareMessage = failedResult && typeof failedResult.newErrorCount === "number" && typeof failedResult.currentErrorCount === "number" && typeof failedResult.baselineErrorCount === "number" ? `agentic synthesis introduced ${failedResult.newErrorCount} new typecheck error(s) (baseline=${failedResult.baselineErrorCount}, current=${failedResult.currentErrorCount})` : "agentic synthesis failed build gate";
+                  markSynthesisWinnerFallback(
+                    mergedResult,
+                    "Agentic synthesis edited worktree failed deterministic gates; winner-only result retained",
+                    winner,
+                    baselineAwareMessage
+                  );
+                  console.warn(
+                    chalk3.yellow(
+                      `   Agentic synthesis worktree failed validation: ${baselineAwareMessage}`
+                    )
+                  );
+                  console.warn(
+                    chalk3.gray(
+                      "     Retaining the judged winner without complementary donor changes."
+                    )
+                  );
+                  await cleanupAgenticSynthesisWorktree(synthesisWorktree, this.preserveWorktrees);
+                }
+              }
+            } catch (validationError) {
+              const validationErrorMessage = validationError instanceof Error ? validationError.message : String(validationError);
+              markSynthesisWinnerFallback(
+                mergedResult,
+                "Agentic synthesis worktree validation failed; winner-only result retained",
+                winner,
+                validationErrorMessage
+              );
+              console.warn(
+                chalk3.yellow(
+                  `   Could not validate agentic synthesis worktree: ${validationError instanceof Error ? validationError.message : String(validationError)}`
+                )
+              );
+              console.warn(
+                chalk3.gray("     Retaining the judged winner without complementary donor changes.")
+              );
+              await cleanupAgenticSynthesisWorktree(synthesisWorktree, this.preserveWorktrees);
+            }
+          } else if (this.synthesisStrategy !== "agentic-synthesis" && winnerWorktree && mergedResult.complementaryPatch) {
+            try {
+              const augmentation = await applyComplementaryPatchToWinnerWorktree({
+                winnerWorktree,
+                complementaryPatch: mergedResult.complementaryPatch,
+                validate: async (worktreePath, baselineWorktreePath) => {
+                  const verifyPlan = resolveSynthesisVerifyCommands(worktreePath);
+                  if (!verifyPlan.available) {
+                    return {
+                      ok: false,
+                      error: "Complementary synthesis was not promoted because target-language verification is unavailable"
+                    };
+                  }
+                  const verifyResult = await runVerifyCommands({
+                    cwd: worktreePath,
+                    baselineCwd: baselineWorktreePath,
+                    // Never let validation auto-install into the product worktree.
+                    // If the toolchain is unavailable, retain the judged winner.
+                    commands: verifyPlan.commands,
+                    timeoutMs: 6e4
+                  });
+                  if (mergedResult) {
+                    mergedResult.validationScope = "typecheck-only";
+                  }
+                  if (verifyResult.passed) {
+                    return {
+                      ok: false,
+                      error: "Complementary synthesis was not promoted because PR workflow validation is typecheck-only"
+                    };
+                  }
+                  const failedResult = verifyResult.results.find((result) => result.exitCode !== 0);
+                  const baselineAwareMessage = failedResult && typeof failedResult.newErrorCount === "number" && typeof failedResult.currentErrorCount === "number" && typeof failedResult.baselineErrorCount === "number" ? `augmented code introduced ${failedResult.newErrorCount} new typecheck error(s) (baseline=${failedResult.baselineErrorCount}, current=${failedResult.currentErrorCount})` : "augmented code failed build gate";
+                  return {
+                    ok: false,
+                    error: baselineAwareMessage
+                  };
+                }
+              });
+              mergedResult.applyMode = augmentation.applyMode;
+              mergedResult.applyError = augmentation.applyError;
+              if (augmentation.winnerWorktreeDirty) {
+                throw new SynthesisWinnerRestorationError(
+                  `Complementary synthesis failed and the winner worktree could not be restored exactly: ${augmentation.applyError ?? "unknown restoration failure"}`
+                );
+              }
+              if (augmentation.applied && augmentation.augmentedFiles.length > 0) {
+                mergedResult.complementaryPatchApplied = true;
+                mergedResult.synthesisApplied = true;
+                mergedResult.winnerFallback = false;
+                delete mergedResult.fallbackReason;
+                mergedResult.patchApplyValidated = true;
+                mergedResult.gatesPassed = false;
+                mergedResult.validationScope = "typecheck-only";
+                console.log(
+                  chalk3.green(
+                    `   ${augmentation.augmentedFiles.length} file(s) augmented with complementary changes (${augmentation.applyMode ?? "unknown"} apply, typecheck verified)`
+                  )
+                );
+                console.log(chalk3.gray(`     ${augmentation.augmentedFiles.join(", ")}`));
+              } else if (augmentation.applyError) {
+                if (augmentation.applyError === "Complementary synthesis was not promoted because PR workflow validation is typecheck-only") {
+                  markTypecheckOnlySynthesisFallback(mergedResult, winner, augmentation.applyError);
+                } else {
+                  markSynthesisWinnerFallback(
+                    mergedResult,
+                    "Complementary patch application failed; winner-only result retained",
+                    winner,
+                    augmentation.applyError
+                  );
+                }
+                console.warn(
+                  chalk3.yellow(
+                    `   Could not apply complementary patch: ${augmentation.applyError}. Retaining judged winner.`
+                  )
+                );
+              } else {
+                markSynthesisWinnerFallback(
+                  mergedResult,
+                  "Complementary patch produced no validated winner-worktree changes; winner-only result retained",
+                  winner
+                );
+              }
+            } catch (applyError) {
+              if (applyError instanceof SynthesisWinnerRestorationError) {
+                throw applyError;
+              }
+              const applyErrorMessage = applyError instanceof Error ? applyError.message : String(applyError);
+              markSynthesisWinnerFallback(
+                mergedResult,
+                "Complementary patch application failed; winner-only result retained",
+                winner,
+                applyErrorMessage
+              );
+              console.warn(
+                chalk3.yellow(
+                  `   Could not apply complementary patch: ${applyErrorMessage}. Retaining judged winner.`
+                )
+              );
+            }
+          } else if (this.synthesisStrategy === "agentic-synthesis") {
+            markSynthesisWinnerFallback(
+              mergedResult,
+              "Agentic synthesis did not retain an editable synthesis worktree for direct validation; winner-only result retained",
+              winner
+            );
+          } else if (!mergedResult.complementaryPatch) {
+            markSynthesisWinnerFallback(
+              mergedResult,
+              mergedResult.winnerClone === true ? mergedResult.reasoning ?? "Synthesis retained judged winner" : "No complementary changes from losers; winner-only result retained",
+              winner
+            );
+            console.log(
+              chalk3.gray("   No complementary changes from losers (all overlapped winner)")
+            );
+          } else {
+            markSynthesisWinnerFallback(
+              mergedResult,
+              "Complementary patch could not be applied because the winner worktree was unavailable; winner-only result retained",
+              winner
+            );
+          }
+        } else if (mergedResult) {
+          mergedResult.deliverySucceeded = true;
+          mergedResult.synthesisApplied = false;
+          mergedResult.winnerFallback = true;
+          mergedResult.fallbackReason = mergedResult.error ?? "Synthesis generation failed; winner-only result retained";
+          mergedResult.patchApplyValidated = false;
+          mergedResult.gatesPassed = false;
+          if (mergedResult.error) {
+            console.log(
+              chalk3.yellow(`
+Synthesis completed with warnings: ${mergedResult.error}
+`)
+            );
+          }
+        }
+      } catch (error) {
+        if (error instanceof SynthesisWinnerRestorationError) {
+          throw error;
+        }
+        console.warn(chalk3.yellow("\nSynthesis failed, but winner is still selected"));
+        console.warn(
+          chalk3.gray(`   Error: ${error instanceof Error ? error.message : String(error)}
+`)
+        );
+      }
+      try {
+        const fs2 = await import("fs/promises");
+        const pathMod = await import("path");
+        const dir = pathMod.join(resolvePoeticDirFromContext(), "telemetry", "synthesis");
+        await fs2.mkdir(dir, { recursive: true });
+        const code = mergedResult?.code;
+        const selectedVariants = resolveSynthesisSelectedVariants(
+          results,
+          mergedResult?.inputVariants
+        );
+        const artifact = {
+          taskId,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          selectedVariants: selectedVariants.map((variant) => ({
+            provider: variant.provider,
+            variant: variant.variant ?? variant.strategy
+          })),
+          declaredWinner: winner ? {
+            provider: winner.provider,
+            variant: winner.variant ?? winner.strategy
+          } : void 0,
+          synthesisStrategy: this.synthesisStrategy,
+          synthesisModel: this.synthesisModel,
+          synthesisOutcomeStatus: resolveSynthesisOutcomeStatusForArtifact(mergedResult),
+          success: didSynthesisArtifactSucceed({ mergedResult }),
+          mergeGenerated: mergedResult?.mergeGenerated ?? false,
+          complementaryPatchApplied: mergedResult?.complementaryPatchApplied ?? false,
+          deliverySucceeded: mergedResult?.deliverySucceeded ?? false,
+          synthesisApplied: mergedResult?.synthesisApplied ?? false,
+          winnerFallback: mergedResult?.winnerFallback ?? false,
+          fallbackReason: mergedResult?.fallbackReason,
+          patchApplyValidated: mergedResult?.patchApplyValidated ?? false,
+          gatesPassed: mergedResult?.gatesPassed ?? false,
+          validationScope: mergedResult?.validationScope,
+          gateFailureDetails: mergedResult?.gateFailureDetails,
+          synthesisWorktree: mergedResult?.synthesisWorktreePath ? {
+            scope: "session-local",
+            name: pathMod.basename(mergedResult.synthesisWorktreePath)
+          } : void 0,
+          synthesisBaseRef: mergedResult?.synthesisBaseRef,
+          synthesisBranch: mergedResult?.synthesisBranch,
+          applyMode: mergedResult?.applyMode,
+          applyError: mergedResult?.applyError,
+          aiGuidedFallbackAttempted: mergedResult?.aiGuidedFallbackAttempted ?? false,
+          aiGuidedFallbackOutcome: mergedResult?.aiGuidedFallbackOutcome,
+          winnerClone: mergedResult?.winnerClone,
+          noveltyScore: mergedResult?.noveltyScore,
+          mergedVariants: mergedResult?.mergedVariants ?? [],
+          contributingVariants: mergedResult?.contributingVariants,
+          synthesisIntents: mergedResult?.synthesisIntents,
+          donorProfiles: mergedResult?.donorProfiles,
+          donorSelectionDecisions: mergedResult?.donorSelectionDecisions,
+          intentMaterialSummaries: mergedResult?.intentMaterialSummaries,
+          donorMaterialDiagnostic: mergedResult?.donorMaterialDiagnostic,
+          harvestManifest: mergedResult?.harvestManifest,
+          winnerFirstReview: mergedResult?.winnerFirstReview,
+          intentFilteredHunkCount: mergedResult?.intentFilteredHunkCount,
+          excludedHunkCount: mergedResult?.excludedHunkCount,
+          unknownIncludedHunkCount: mergedResult?.unknownIncludedHunkCount,
+          unknownExcludedHunkCount: mergedResult?.unknownExcludedHunkCount,
+          overlapRejectedHunkCount: mergedResult?.overlapRejectedHunkCount,
+          reasoning: mergedResult?.reasoning,
+          error: mergedResult?.error,
+          synthesisOutputLines: code != null ? code.split("\n").length : void 0
+        };
+        await fs2.writeFile(
+          pathMod.join(dir, `${taskId}.json`),
+          JSON.stringify(sanitizeSynthesisArtifactForPersistence(artifact), null, 2),
+          "utf-8"
+        );
+        if (this.verbose) {
+          console.log(
+            chalk3.gray(`   Synthesis artifact saved to .poetic/telemetry/synthesis/${taskId}.json`)
+          );
+        }
+      } catch {
+      }
+      if (this.synthesisStrategy === "agentic-synthesis" && mergedResult?.synthesisApplied === true && mergedResult.synthesisWorktreePath) {
+        await cleanupAgenticSynthesisWorktree(
+          mergedResult.synthesisWorktreePath,
+          this.preserveWorktrees
+        );
+      }
+    }
+    await this.cleanupIfEnabled(results, winner, taskId);
+    return {
+      taskId,
+      variants: results,
+      winner,
+      synthesis: mergedResult,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  /**
+   * DAG-aware variant execution with dependency resolution and resource management
+   *
+   * Algorithm:
+   * 1. Build dependency graph from task dependencies (or infer from variants)
+   * 2. Validate graph structure (detect cycles, missing nodes)
+   * 3. Execute variants in topological order:
+   *    - Cloud variants: Submit async, mark completed immediately (non-blocking)
+   *    - Local variants: Acquire resource slot, execute, release slot
+   *    - Gemini variants: Parallel by default (HOME isolation), auto-fallback on exit 54
+   * 4. Mark tasks completed/failed, unblock dependents
+   * 5. Continue until all tasks terminal or blocked
+   *
+   * @param taskId - Unique task identifier
+   * @param prompt - Task prompt
+   * @param variants - Variant configurations
+   * @param results - Results array (mutated in place)
+   * @returns Competition result
+   */
+  async executeVariantsWithDependencies(taskId, prompt, variants, results, retryMeta, outerSignal) {
+    if (!this.dependencyResolver || !this.resourceManager) {
+      throw new Error("Dependency components not initialized (enable via flywheel)");
+    }
+    const taskDeps = this.taskDependencies || variants.map((v) => ({
+      id: this.getVariantId(v),
+      dependencies: [],
+      // No dependencies if not specified (all parallel)
+      metadata: { variant: v }
+    }));
+    const graph = this.dependencyResolver.buildGraph(taskDeps);
+    const validation = this.dependencyResolver.validateGraph(graph);
+    if (!validation.valid) {
+      throw new Error(`Invalid dependency graph: ${validation.errors.join(", ")}`);
+    }
+    if (validation.warnings && validation.warnings.length > 0) {
+      console.warn(chalk3.yellow(`Dependency warnings: ${validation.warnings.join(", ")}`));
+    }
+    const abortController = new AbortController();
+    const signal = abortController.signal;
+    if (outerSignal) {
+      if (outerSignal.aborted) {
+        abortController.abort(outerSignal.reason);
+      } else {
+        outerSignal.addEventListener("abort", () => abortController.abort(outerSignal.reason), {
+          once: true
+        });
+      }
+    }
+    const variantMap = /* @__PURE__ */ new Map();
+    for (const variant of variants) {
+      variantMap.set(this.getVariantId(variant), variant);
+    }
+    const localVariants = variants;
+    const geminiVariants = localVariants.filter((v) => v.provider === "gemini");
+    const nonGeminiLocalVariants = localVariants.filter((v) => v.provider !== "gemini");
+    console.log(chalk3.gray("DAG Execution Plan:"));
+    console.log(chalk3.gray(`  Total tasks: ${graph.nodes.size}`));
+    console.log(
+      chalk3.gray(`  Max depth: ${this.dependencyResolver.getMaxLevel(graph) + 1} levels`)
+    );
+    console.log(
+      chalk3.gray(`  Local variants: ${nonGeminiLocalVariants.length} (resource-managed)`)
+    );
+    console.log(
+      chalk3.gray(`  Gemini variants: ${geminiVariants.length} (parallel + auto-fallback)
+`)
+    );
+    while (!this.dependencyResolver.isComplete(graph)) {
+      const readyTasks = this.dependencyResolver.getReadyTasks(graph);
+      if (readyTasks.length === 0) {
+        const stats2 = this.dependencyResolver.getStatistics(graph);
+        if (stats2.blockedTasks > 0) {
+          console.warn(
+            chalk3.yellow(`${stats2.blockedTasks} task(s) blocked due to dependency failures`)
+          );
+        }
+        break;
+      }
+      console.log(chalk3.cyan(`\u2192 Ready tasks: ${readyTasks.length} (${readyTasks.join(", ")})`));
+      const executionPromises = [];
+      for (const variantId of readyTasks) {
+        const variant = variantMap.get(variantId);
+        if (!variant) {
+          console.warn(chalk3.yellow(`Variant not found for task ${variantId}`));
+          this.dependencyResolver.markFailed(graph, variantId, "Variant not found");
+          continue;
+        }
+        this.dependencyResolver.markRunning(graph, variantId);
+        const executionPromise = this.executeVariantWithResources(
+          taskId,
+          prompt,
+          variant,
+          variantId,
+          signal,
+          retryMeta
+        ).then((result) => {
+          results.push(result);
+          if (result.success) {
+            if (this.dependencyResolver) {
+              const newlyReady = this.dependencyResolver.markCompleted(graph, variantId);
+              if (newlyReady.length > 0 && this.verbose) {
+                console.log(chalk3.gray(`  Unblocked: ${newlyReady.join(", ")}`));
+              }
+            }
+          } else {
+            if (this.dependencyResolver) {
+              const blocked = this.dependencyResolver.markFailed(
+                graph,
+                variantId,
+                result.error?.message
+              );
+              if (blocked.length > 0) {
+                console.warn(chalk3.yellow(`  Blocked dependents: ${blocked.join(", ")}`));
+              }
+            }
+          }
+          try {
+            updateEvaluationHandleWithResult(taskId, result);
+          } catch (handleError) {
+            console.warn(
+              `Failed to update competition handle: ${handleError instanceof Error ? handleError.message : String(handleError)}`
+            );
+            debugLog("Full stack:", handleError);
+          }
+        }).catch((error) => {
+          console.error(
+            chalk3.red(
+              `Execution error for ${variantId}: ${error instanceof Error ? error.message : String(error)}`
+            )
+          );
+          if (this.dependencyResolver) {
+            this.dependencyResolver.markFailed(graph, variantId, String(error));
+          }
+        });
+        executionPromises.push(executionPromise);
+      }
+      await Promise.allSettled(executionPromises);
+      if (outerSignal?.aborted) {
+        throw outerSignal.reason instanceof Error ? outerSignal.reason : new Error("Dependency-aware variant execution aborted");
+      }
+    }
+    const stats = this.dependencyResolver.getStatistics(graph);
+    console.log(chalk3.blue("\nDAG Execution Summary:"));
+    console.log(chalk3.gray(`  Completed: ${stats.completedTasks}/${stats.totalTasks}`));
+    console.log(chalk3.gray(`  Failed: ${stats.failedTasks}`));
+    console.log(chalk3.gray(`  Blocked: ${stats.blockedTasks}
+`));
+    const state = this.getVariantState(results);
+    this.logVariantApplicationWarnings(results);
+    console.log(chalk3.bold.blue("\nCompetition Results\n"));
+    if (outerSignal?.aborted) {
+      throw outerSignal.reason instanceof Error ? outerSignal.reason : new Error("Variant execution aborted before judge selection");
+    }
+    const winner = this.shouldRunWinnerSelection(state) ? await this.variantOrchestrator.selectWinner(results, {
+      useAIJudge: this.aiJudge,
+      originalPrompt: prompt,
+      model: this.aiJudgeModel,
+      aiJudgeVerbose: this.aiJudgeVerbose,
+      aiJudgeShowRationale: this.aiJudgeShowRationale,
+      aiJudgeCriteriaWeights: this.aiJudgeCriteriaWeights,
+      aiJudgeMinScore: this.aiJudgeMinScore,
+      aiJudgeConfidenceThreshold: this.aiJudgeConfidenceThreshold,
+      aiJudgeStreaming: this.aiJudgeStreaming,
+      aiJudgeRun: this.aiJudgeRun,
+      aiJudgePrimary: this.aiJudgePrimary,
+      judgeModels: this.judgeModels,
+      judgeModel: this.judgeModel,
+      judgeAllowUnsafeModel: this.judgeAllowUnsafeModel,
+      judgeStrict: this.judgeStrict,
+      anonymizeJudge: this.anonymizeJudge,
+      aiJudgeVerbosity: this.aiJudgeVerbosity,
+      verificationMode: this.verificationMode,
+      resultStreamer: this.resultStreamer,
+      taskId,
+      competitionMode: true,
+      aiJudgeTelemetry: this.aiJudgeTelemetry
+    }) : null;
+    this.displayResults(results, winner);
+    if (winner?.judgeEvaluation) {
+      const variantResultsMap = new Map(results.map((r) => [r.variant, r]));
+      this.judgeDisplayService.displayEvaluation(winner.judgeEvaluation, variantResultsMap);
+    }
+    await this.cleanupIfEnabled(results, winner, taskId);
+    return {
+      taskId,
+      variants: results,
+      winner,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  /**
+   * Execute a single variant with resource management
+   *
+   * Handles three execution modes:
+   * 1. Cloud: Submit async, return immediately (non-blocking)
+   * 2. Local (non-Gemini): Acquire resource slot, execute, release
+   * 3. Gemini: Parallel by default with auto-fallback to serial on exit 54
+   *
+   * @param taskId - Task ID
+   * @param prompt - Task prompt
+   * @param variant - Variant configuration
+   * @param variantId - Unique variant identifier
+   * @param signal - Abort signal for cancellation
+   * @returns Variant result
+   */
+  async executeVariantWithResources(taskId, prompt, variant, _variantId, signal, retryMeta) {
+    const variantLabel = `${variant.provider} ${variant.model || "default-model"} ${variant.strategy}`;
+    const startTime = Date.now();
+    this.logVariantStartSafe(taskId, variant);
+    try {
+      let result;
+      console.log(
+        chalk3.cyan(`\u2192 Starting: ${variantLabel} ${chalk3.gray("(local, resource-managed)")}`)
+      );
+      if (!this.resourceManager) {
+        throw new Error("Resource manager not initialized");
+      }
+      const handle = await this.resourceManager.acquire(
+        variant.provider,
+        signal,
+        this.orchestratorTimeoutMs
+      );
+      try {
+        result = await this.executeLocalVariant(taskId, variant, prompt, retryMeta, signal);
+      } finally {
+        await handle.release();
+      }
+      const elapsed = ((Date.now() - startTime) / 1e3).toFixed(1);
+      if (result.success) {
+        console.log(
+          chalk3.green(
+            `${variantLabel}: Completed in ${elapsed}s ${result.prNumber ? `(PR #${result.prNumber})` : ""}
+`
+          )
+        );
+      } else {
+        console.log(
+          chalk3.red(
+            `${variantLabel}: Failed after ${elapsed}s - ${result.error?.message || "Unknown error"}
+`
+          )
+        );
+      }
+      this.logVariantCompleteSafe(taskId, variant, result);
+      return result;
+    } catch (error) {
+      const elapsedSeconds = (Date.now() - startTime) / 1e3;
+      const elapsed = elapsedSeconds.toFixed(1);
+      console.log(
+        chalk3.red(
+          `${variantLabel}: Error after ${elapsed}s - ${error instanceof Error ? error.message : String(error)}
+`
+        )
+      );
+      const failureResult = this.buildFailureResult(variant, error, elapsedSeconds);
+      this.logVariantCompleteSafe(taskId, variant, failureResult);
+      return failureResult;
+    }
+  }
+  /**
+   * Get unique variant identifier for DAG tracking
+   *
+   * @param variant - Variant configuration
+   * @returns Unique variant ID
+   */
+  getVariantId(variant) {
+    return `${variant.provider}:${variant.model || "default"}:${variant.strategy}:${variant.executionMode}`;
+  }
+  /**
+   * Log cleanup telemetry event (non-blocking, best-effort)
+   */
+  logCleanupTelemetry(event) {
+    try {
+      console.log(
+        JSON.stringify({
+          eventType: event.eventType,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          taskId: event.taskId,
+          ...event.data
+        })
+      );
+    } catch (telemetryError) {
+      console.warn(
+        `Failed to log cleanup telemetry event ${event.eventType}: ${telemetryError instanceof Error ? telemetryError.message : String(telemetryError)}`
+      );
+      debugLog("Full stack:", telemetryError);
+    }
+  }
+  /**
+   * Best-effort cleanup trigger that runs when enabled and a winner exists.
+   * Used from both the normal completion path and the timeout partial-results path.
+   *
+   * ENHANCED: Added robust error handling, retry logic, and detailed logging
+   * to ensure cleanup triggers consistently even under error conditions.
+   */
+  async cleanupIfEnabled(results, winner, taskId, context) {
+    const cleanupStartTime = Date.now();
+    if (!this.cleanupOnCompletion) {
+      this.logCleanupTelemetry({
+        eventType: "cleanup.disabled",
+        taskId,
+        data: { reason: "configuration" }
+      });
+      if (this.verbose) {
+        console.log(chalk3.gray("Cleanup disabled by configuration"));
+      }
+      return;
+    }
+    if (!winner) {
+      this.logCleanupTelemetry({
+        eventType: "cleanup.skipped",
+        taskId,
+        data: { reason: context?.reason ?? "no_winner" }
+      });
+      if (this.verbose) {
+        console.log(chalk3.yellow("Cleanup skipped - no winner determined"));
+      }
+      return;
+    }
+    if (!results || results.length === 0) {
+      this.logCleanupTelemetry({
+        eventType: "cleanup.skipped",
+        taskId,
+        data: { reason: "no_results" }
+      });
+      if (this.verbose) {
+        console.log(chalk3.yellow("Cleanup skipped - no results available"));
+      }
+      return;
+    }
+    const losersWithPRs = results.filter((r) => {
+      const hasPrNumber = typeof r.prNumber === "number" && r.prNumber > 0;
+      return hasPrNumber && (winner.prNumber ? r.prNumber !== winner.prNumber : r.variant !== winner.variant || r.provider !== winner.provider);
+    });
+    const hasLosers = losersWithPRs.length > 0;
+    if (!hasLosers) {
+      if (this.verbose) {
+        console.log(chalk3.gray("No losing PRs detected, checking for orphan branches by task..."));
+      }
+      if (taskId && results.length > 1) {
+        try {
+          const orphanScanStart = Date.now();
+          await this.cleanupService.cleanupCompetition(results, winner, {
+            verbose: this.verbose,
+            preserveSubmittedOnly: this.shouldPreserveSubmittedOnly(),
+            taskId
+          });
+          const orphanCount = await this.cleanupOrphanBranchesByTask(taskId, winner);
+          this.logCleanupTelemetry({
+            eventType: "cleanup.orphan_scan",
+            taskId,
+            data: {
+              branchesDeleted: orphanCount,
+              durationMs: Date.now() - orphanScanStart
+            }
+          });
+          if (orphanCount > 0) {
+            console.log(chalk3.green(`Removed ${orphanCount} orphan branch(es) for task ${taskId}`));
+          } else if (this.verbose) {
+            console.log(chalk3.gray(`No orphan branches found for task ${taskId}`));
+          }
+        } catch (orphanError) {
+          if (this.verbose) {
+            console.log(
+              chalk3.yellow(
+                `Failed scanning orphan branches: ${orphanError instanceof Error ? orphanError.message : String(orphanError)}`
+              )
+            );
+          }
+        }
+      } else if (results.length === 1) {
+        if (this.verbose) {
+          console.log(
+            chalk3.gray("Skipping orphan branch scan - single variant (no orphans possible)")
+          );
+        }
+      } else if (!taskId && this.verbose) {
+        console.log(chalk3.gray("Skipping orphan branch scan - taskId not provided"));
+      }
+      return;
+    }
+    this.logCleanupTelemetry({
+      eventType: "cleanup.started",
+      taskId,
+      data: {
+        loserCount: losersWithPRs.length
+      }
+    });
+    console.log(
+      chalk3.blue(`
+Starting cleanup of ${losersWithPRs.length} non-winning variant(s)...`)
+    );
+    const maxRetries = 3;
+    let cleanupSuccessful = false;
+    let lastError = null;
+    let lastErrorMessage = null;
+    let cleanupAttempts = 0;
+    try {
+      await retryOperation(
+        async () => {
+          cleanupAttempts += 1;
+          if (this.verbose) {
+            console.log(chalk3.gray(`Cleanup attempt ${cleanupAttempts}/${maxRetries}`));
+          }
+          try {
+            await this.cleanupService.cleanupCompetition(results, winner, {
+              verbose: this.verbose,
+              preserveSubmittedOnly: this.shouldPreserveSubmittedOnly(),
+              taskId
+            });
+          } catch (cleanupError) {
+            lastError = cleanupError instanceof Error ? cleanupError : new Error(String(cleanupError));
+            lastErrorMessage = lastError.message;
+            this.logCleanupTelemetry({
+              eventType: "cleanup.retry_attempt",
+              taskId,
+              data: {
+                attempt: cleanupAttempts,
+                maxRetries,
+                error: lastErrorMessage
+              }
+            });
+            console.log(
+              chalk3.yellow(`Cleanup attempt ${cleanupAttempts} failed: ${lastErrorMessage}`)
+            );
+            throw lastError;
+          }
+          cleanupSuccessful = true;
+          if (this.verbose) {
+            console.log(
+              chalk3.green(`Cleanup completed successfully on attempt ${cleanupAttempts}`)
+            );
+          }
+        },
+        {
+          maxRetries,
+          initialDelayMs: 1e3,
+          backoffMultiplier: 2,
+          maxDelayMs: 5e3,
+          onRetry: (_error, attempt) => {
+            const backoffMs = calculateRetryDelayMs(attempt, {
+              initialDelayMs: 1e3,
+              backoffMultiplier: 2,
+              maxDelayMs: 5e3
+            });
+            console.log(chalk3.gray(`   Retrying in ${backoffMs}ms...`));
+          }
+        }
+      );
+    } catch {
+    }
+    const cleanupDurationMs = Date.now() - cleanupStartTime;
+    this.logCleanupTelemetry({
+      eventType: "cleanup.completed",
+      taskId,
+      data: {
+        success: cleanupSuccessful,
+        totalDurationMs: cleanupDurationMs,
+        retryAttempts: cleanupAttempts || maxRetries
+      }
+    });
+    if (!cleanupSuccessful && lastErrorMessage) {
+      console.log(chalk3.yellow(`
+Cleanup failed after ${maxRetries} attempts:`));
+      console.log(chalk3.yellow(`   ${lastErrorMessage}`));
+      console.log(chalk3.gray("\nManual cleanup may be required for the following variants:"));
+      losersWithPRs.forEach((loser) => {
+        console.log(chalk3.gray(`  \u2022 ${loser.provider} ${loser.variant} (PR #${loser.prNumber})`));
+      });
+      console.log(chalk3.gray("\nManual cleanup commands:"));
+      losersWithPRs.forEach((loser) => {
+        console.log(chalk3.gray(`  gh pr close ${loser.prNumber}`));
+        if (taskId && loser.provider && loser.strategy && loser.executionMode) {
+          const branch = poeticVariantBranchName({
+            taskId,
+            provider: loser.provider,
+            strategy: loser.strategy,
+            executionMode: loser.executionMode,
+            model: loser.model
+          });
+          console.log(chalk3.gray(`  git branch -D ${branch}`));
+        } else {
+          console.log(chalk3.gray("  gh pr view <PR_NUMBER> --json headRefName -q '.headRefName'"));
+        }
+      });
+    }
+    if (taskId) {
+      this.clearBranchListCache(taskId);
+    }
+  }
+  /**
+   * Calculate variant state from results
+   */
+  getVariantState(results) {
+    const isSubmittedOnly = (r) => r.submittedOnly === true;
+    const validResults = results.filter((r) => r && r.success !== void 0);
+    return {
+      total: results.length,
+      // Do not count submitted-only variants as completed
+      completed: validResults.filter((r) => !isSubmittedOnly(r)).length,
+      succeeded: validResults.filter((r) => r.success === true && !isSubmittedOnly(r)).length,
+      failed: validResults.filter((r) => r.success === false && !r.timedOut).length,
+      timedOut: validResults.filter((r) => r.timedOut === true).length
+    };
+  }
+  /**
+   * Check whether there is any provider result to send to winner selection.
+   * Completion/success counts are telemetry only; the judges decide among the available outputs.
+   */
+  shouldRunWinnerSelection(state) {
+    return shouldSelectCompetitionWinner({
+      total: state.total,
+      completed: state.completed,
+      judgeOff: this.judgeOff
+    });
+  }
+  /**
+   * Display results in a formatted table
+   */
+  displayResults(results, winner) {
+    console.log(chalk3.bold("Results Summary:\n"));
+    const validResults = results.filter((r) => r);
+    validResults.forEach((result) => {
+      const isWinner = !this.judgeOff && winner && result.variant === winner.variant && result.provider === winner.provider;
+      const prefix = isWinner ? chalk3.green("[winner]") : chalk3.gray("  ");
+      const needsApply = this.requiresApplyRecovery(result);
+      const status = result.submittedOnly ? chalk3.cyan("Submitted") : result.success && needsApply ? chalk3.yellow("Apply required") : result.success ? chalk3.green("ok") : chalk3.red("failed");
+      const provider = chalk3.blue(`${result.provider}${result.model ? `:${result.model}` : ""}`);
+      const strategy = chalk3.yellow(result.variant);
+      const mode = chalk3.gray("local");
+      const duration = chalk3.gray(`${result.duration.toFixed(1)}s`);
+      const pr = result.prNumber ? chalk3.gray(`#${result.prNumber}`) : "";
+      console.log(`${prefix} ${status} ${mode} ${provider} ${strategy} - ${duration} ${pr}`);
+    });
+    console.log();
+    let selectionSummary;
+    if (this.judgeOff && results.length === 1 && winner) {
+      selectionSummary = chalk3.bold(
+        `Ungraded result: ${winner.provider}${winner.model ? `:${winner.model}` : ""} ${winner.variant}`
+      );
+    } else if (this.judgeOff) {
+      selectionSummary = chalk3.yellow(
+        "Manual comparison (--judge off): no automatic winner selected."
+      );
+    } else if (winner) {
+      selectionSummary = chalk3.bold.green(
+        `Winner: ${winner.provider}${winner.model ? `:${winner.model}` : ""} ${winner.variant}`
+      );
+    } else {
+      const state = this.getVariantState(results);
+      selectionSummary = chalk3.yellow(
+        state.completed < state.total * 0.5 ? "No winner declared by judges for the available results." : "No winner declared by judges."
+      );
+    }
+    console.log(selectionSummary);
+    if (!this.judgeOff && winner?.prNumber) {
+      console.log(chalk3.gray(`  PR: #${winner.prNumber}`));
+    }
+    console.log();
+    const hasRetainedLocalWorktrees = results.some((r) => Boolean(r?.retainedWorktreePath));
+    if (this.localFastMode || !this.pushLocalVariants && hasRetainedLocalWorktrees) {
+      this.displayLocalFastSummary(results);
+    }
+  }
+  /**
+   * Get comparison and recommendations
+   */
+  async getComparison(results, resolvedWinner, noWinnerMode) {
+    const comparison = await this.variantOrchestrator.compareVariants(
+      results,
+      resolvedWinner,
+      noWinnerMode
+    );
+    return {
+      ...comparison,
+      analysis: comparison.analysis
+    };
+  }
+  /**
+   * Cleanup non-winning variant PRs and branches after competition
+   * Delegates to CleanupService for all cleanup logic
+   *
+   * @deprecated Use CleanupService directly for new code
+   */
+  async cleanupCompetition(results, winner, taskId) {
+    return this.cleanupService.cleanupCompetition(results, winner, {
+      verbose: this.verbose,
+      preserveSubmittedOnly: this.shouldPreserveSubmittedOnly(),
+      taskId
+    });
+  }
+  requiresApplyRecovery(result) {
+    if (result.submittedOnly) {
+      return true;
+    }
+    return result.applied === false;
+  }
+  isCloudVariant(result) {
+    return result.submittedOnly === true;
+  }
+  formatProviderVariantLabel(result) {
+    const provider = result.provider ? this.capitalizeWords(result.provider) : "Cloud";
+    const variantName = typeof result.variant === "string" && result.variant.length > 0 ? result.variant : typeof result.variant === "string" ? result.variant : "";
+    const variantLabel = variantName ? this.capitalizeWords(String(variantName)) : "";
+    return variantLabel ? `${provider} ${variantLabel}` : provider;
+  }
+  logVariantApplicationWarnings(results) {
+    const applyIssues = results.filter((result) => this.requiresApplyRecovery(result));
+    if (applyIssues.length > 0) {
+      console.log(chalk3.yellow(`${applyIssues.length} variant(s) have local-apply observations:`));
+      applyIssues.forEach((result) => {
+        const label = this.formatProviderVariantLabel(result);
+        const prLabel = result.prNumber ? `PR #${result.prNumber}` : "PR pending";
+        const hint = this.getCloudRecoveryHint(result);
+        console.log(
+          chalk3.gray(
+            `   - ${label} (${prLabel}) - local result not applied${hint ? ` | ${hint}` : ""}`
+          )
+        );
+      });
+    }
+    const submittedOnly = results.filter((result) => result.submittedOnly === true);
+    if (submittedOnly.length > 0) {
+      console.log(
+        chalk3.gray(`${submittedOnly.length} variant(s) were submitted without local results.`)
+      );
+    }
+  }
+  getCloudRecoveryHint(result) {
+    if (!this.isCloudVariant(result) || !this.requiresApplyRecovery(result)) {
+      return void 0;
+    }
+    if (result.provider === "cursor") {
+      if (result.prUrl) {
+        return result.prUrl;
+      }
+      if (result.prNumber) {
+        return `gh pr checkout ${result.prNumber}`;
+      }
+      return "Cursor runs locally; review the commits on the run branch";
+    }
+    return result.prUrl ?? (result.prNumber ? `gh pr view ${result.prNumber}` : void 0);
+  }
+  displayLocalFastSummary(results) {
+    const retained = results.filter((r) => r.retainedWorktreePath);
+    if (retained.length === 0) {
+      console.log(chalk3.gray("No retained local worktrees (clean)"));
+      return;
+    }
+    console.log(chalk3.bold.blue("Local fast-path worktrees:"));
+    retained.forEach((variant) => {
+      const label = this.formatProviderVariantLabel(variant);
+      console.log(
+        chalk3.gray(
+          `  \u2022 ${label}: ${variant.retainedWorktreePath}${// Show workspace edits: prefer requested count (includes git-detected), fallback to applied
+          (variant.workspaceEditsRequested ?? variant.workspaceEditsApplied) !== void 0 ? ` (${variant.workspaceEditsRequested ?? variant.workspaceEditsApplied} file${(variant.workspaceEditsRequested ?? variant.workspaceEditsApplied) === 1 ? "" : "s"} changed)` : ""}`
+        )
+      );
+      if (variant.worktreeSummary) {
+        console.log(
+          chalk3.gray(
+            `    Diff: ${variant.worktreeSummary.filesChanged} files (+${variant.worktreeSummary.insertions}/-${variant.worktreeSummary.deletions})`
+          )
+        );
+        variant.worktreeSummary.statusLines.slice(0, 5).forEach((line) => {
+          console.log(chalk3.gray(`      ${line}`));
+        });
+        if (variant.worktreeSummary.statusLines.length > 5) {
+          console.log(
+            chalk3.gray(`      \u2026 ${variant.worktreeSummary.statusLines.length - 5} more file(s)`)
+          );
+        }
+      }
+      console.log(
+        chalk3.cyan(
+          `    Next: cd ${variant.retainedWorktreePath} && git status && git commit -am "<message>"`
+        )
+      );
+    });
+    console.log();
+  }
+  capitalizeWords(value) {
+    return value.split(/[\s_-]+/).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ");
+  }
+  /**
+   * Retrieve cached branch list or fetch fresh from git
+   * Implements 60-second TTL cache to reduce git operations during cleanup
+   * Thread-safe: validates timestamp before use
+   *
+   * @param taskId - Task ID for cache key
+   * @param pattern - Git branch pattern (e.g., "origin/feature/T123-*")
+   * @returns Array of matching branch names
+   */
+  async getCachedBranchList(taskId, pattern) {
+    const now = Date.now();
+    const cached = this.branchListCache.get(taskId);
+    if (cached && now - cached.timestamp < this.BRANCH_LIST_CACHE_TTL_MS) {
+      if (this.verbose) {
+        console.log(
+          chalk3.gray(
+            `  [cache hit] Using cached branch list for task ${taskId} (${Math.round((now - cached.timestamp) / 1e3)}s old)`
+          )
+        );
+      }
+      return cached.branches;
+    }
+    if (this.verbose && cached) {
+      console.log(
+        chalk3.gray(
+          `  [cache expired] Refreshing branch list for task ${taskId} (${Math.round((now - cached.timestamp) / 1e3)}s old)`
+        )
+      );
+    }
+    try {
+      const { execa: execa2 } = await import("execa");
+      const { stdout } = await execa2("git", ["branch", "-r", "--list", pattern], {
+        cwd: this.repoRoot,
+        reject: false
+      });
+      const branches = stdout.split("\n").map((b) => b.trim()).filter(Boolean);
+      this.branchListCache.set(taskId, {
+        branches,
+        timestamp: now
+      });
+      if (this.verbose) {
+        console.log(
+          chalk3.gray(`  [cache set] Cached ${branches.length} branches for task ${taskId}`)
+        );
+      }
+      return branches;
+    } catch (_error) {
+      if (cached) {
+        if (this.verbose) {
+          console.log(
+            chalk3.yellow(
+              `Git branch list failed for task ${taskId}, using stale cache (${Math.round((now - cached.timestamp) / 1e3)}s old)`
+            )
+          );
+        }
+        return cached.branches;
+      }
+      return [];
+    }
+  }
+  /**
+   * Clear branch list cache entries (best-effort cleanup)
+   * Can be called during orchestrator shutdown to free memory
+   * Optionally filter by taskId, or clear all entries if taskId is undefined
+   *
+   * @param taskId - Optional task ID to clear specific cache entry, or undefined to clear all
+   */
+  clearBranchListCache(taskId) {
+    if (taskId) {
+      const hadEntry = this.branchListCache.has(taskId);
+      this.branchListCache.delete(taskId);
+      if (this.verbose && hadEntry) {
+        console.log(chalk3.gray(`  [cache cleared] Removed branch list cache for task ${taskId}`));
+      }
+    } else {
+      const size = this.branchListCache.size;
+      this.branchListCache.clear();
+      if (this.verbose && size > 0) {
+        console.log(chalk3.gray(`  [cache cleared] Cleared ${size} branch list cache entries`));
+      }
+    }
+  }
+  /**
+   * Best-effort removal of orphan competition branches that may not have associated PR results
+   * Pattern: origin/poetic/var-{taskId}-*
+   * - Deletes remote branches first, then attempts local removal
+   * - Skips winner branch if identifiable
+   */
+  async cleanupOrphanBranchesByTask(taskId, winner) {
+    try {
+      const { execa: execa2 } = await import("execa");
+      const pattern = `origin/${poeticVariantBranchPrefix(taskId)}*`;
+      const remoteBranches = await this.getCachedBranchList(taskId, pattern);
+      if (remoteBranches.length === 0) {
+        return 0;
+      }
+      let winnerBranch;
+      if (winner?.prNumber) {
+        try {
+          winnerBranch = await this.prManager.getPRBranch(winner.prNumber);
+        } catch (error) {
+          const msg = error instanceof Error ? error.message : String(error);
+          console.warn(
+            chalk3.yellow(
+              `Skipping orphan branch cleanup for task ${taskId}: failed to resolve winner branch for PR #${winner.prNumber}: ${msg}`
+            )
+          );
+          return 0;
+        }
+      } else {
+        if (this.verbose) {
+          emitWarning(
+            "PR-001",
+            {
+              taskId,
+              subsystem: "orchestrator",
+              executionPhase: "cleanup"
+            },
+            {
+              severity: "INFO" /* INFO */,
+              metadata: {
+                operation: "skipOrphanBranchCleanup",
+                reason: "winner has no PR number, cannot identify winning branch"
+              }
+            }
+          );
+        }
+        return 0;
+      }
+      let deletedCount = 0;
+      for (const fullRef of remoteBranches) {
+        const branch = fullRef.replace(/^origin\//, "");
+        if (winnerBranch) {
+          const isExactMatch = branch === winnerBranch;
+          if (isExactMatch) {
+            if (this.verbose) {
+              console.log(chalk3.gray(`  Skipping winner branch: ${branch}`));
+            }
+            continue;
+          }
+        }
+        if (isProtectedPipelineBranch(branch)) {
+          continue;
+        }
+        try {
+          await this.prManager.deleteBranch(branch, {
+            deleteLocal: true,
+            deleteRemote: true,
+            force: true,
+            cwd: this.repoRoot
+          });
+          deletedCount++;
+        } catch (_error) {
+          try {
+            const result = await execa2("git", ["push", "origin", "--delete", branch], {
+              cwd: this.repoRoot,
+              reject: false
+            });
+            if (result.exitCode === 0) {
+              deletedCount++;
+              continue;
+            }
+            const message = `${result.stderr ?? ""}
+${result.stdout ?? ""}`.trim();
+            if (isRemoteBranchMissingError(message)) {
+              deletedCount++;
+              continue;
+            }
+            if (isRetryableRemoteDeleteError(message)) {
+              const expectedRemoteSha = await resolveExpectedRemoteShaForQueuedBranch(branch, {
+                remote: "origin",
+                cwd: this.repoRoot
+              });
+              await enqueueRemoteBranchCleanup(branch, {
+                remote: "origin",
+                reason: "cleanupOrphanBranchesByTask(fallback)",
+                expectedRemoteSha,
+                cwd: this.repoRoot
+              }).catch(() => {
+              });
+            }
+          } catch (error) {
+            console.warn(
+              `Failed to delete remote branch: ${error instanceof Error ? error.message : String(error)}`
+            );
+            debugLog("Full stack:", error);
+          }
+        }
+      }
+      return deletedCount;
+    } catch (_error) {
+      return 0;
+    }
+  }
+  /**
+   * Determine if prompt optimization should be triggered for these results
+   * Only trigger if we have at least 2 successful variants
+   */
+  shouldTriggerOptimization(results) {
+    if (!this.enablePromptOptimization) {
+      return false;
+    }
+    const successfulVariants = results.filter((r) => r && r.success === true);
+    return successfulVariants.length >= 2;
+  }
+  /**
+   * Get telemetry logger instance (if available)
+   * Returns undefined if telemetry is not available
+   */
+  getTelemetryLogger() {
+    try {
+      return TelemetryLogger.getInstance();
+    } catch {
+      return void 0;
+    }
+  }
+  logVariantStartSafe(taskId, variant) {
+    try {
+      this.variantOrchestrator.logVariantStart(
+        taskId,
+        formatVariantIdentifier(variant),
+        "unversioned",
+        {
+          provider: variant.provider,
+          model: variant.model,
+          executionMode: variant.executionMode,
+          strategy: variant.strategy
+        }
+      );
+    } catch (_error) {
+    }
+  }
+  logVariantCompleteSafe(taskId, variant, result) {
+    try {
+      this.variantOrchestrator.logVariantComplete(
+        taskId,
+        formatVariantIdentifier(variant),
+        result,
+        result.prNumber,
+        {
+          provider: variant.provider,
+          model: result.model || variant.model,
+          executionMode: variant.executionMode,
+          strategy: variant.strategy
+        }
+      );
+    } catch (_error) {
+    }
+  }
+  buildFailureResult(variant, error, durationSeconds) {
+    const normalizedError = error instanceof Error ? error : new Error(String(error));
+    const variantId = `${variant.provider}:${variant.model ?? "default"}:${variant.strategy}:${variant.executionMode ?? "local"}`;
+    return {
+      variant: variantId,
+      provider: variant.provider,
+      model: variant.model,
+      strategy: variant.strategy,
+      executionMode: variant.executionMode,
+      success: false,
+      error: normalizedError,
+      duration: Math.max(0, durationSeconds),
+      completeness: 0,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  shouldPreserveSubmittedOnly() {
+    return false;
+  }
+  /**
+   * Close resources
+   */
+  async close() {
+    if (this.verbose) {
+      console.log(chalk3.gray("Closing PRWorkflowOrchestrator..."));
+    }
+    const closers = [];
+    try {
+      if (this.localExecutor && typeof this.localExecutor.close === "function") {
+        closers.push(Promise.resolve(this.localExecutor.close()));
+      }
+    } catch {
+    }
+    if (closers.length > 0) {
+      await Promise.allSettled(closers);
+    }
+    this.variantOrchestrator.close();
+    if (this.judgeListenerCleanup) {
+      try {
+        this.judgeListenerCleanup();
+      } catch {
+      }
+    }
+    if (this.resultStreamer && this.ownsResultStreamer) {
+      try {
+        this.resultStreamer.close();
+      } catch {
+      }
+    }
+    if (this.ownsProcessLifecycle) {
+      try {
+        await this.processLifecycle.close();
+      } catch (error) {
+        emitWarning(
+          "PR-001",
+          {
+            taskId: "unknown",
+            subsystem: "orchestrator",
+            executionPhase: "cleanup"
+          },
+          {
+            severity: "WARN" /* WARN */,
+            metadata: {
+              error: error instanceof Error ? error.message : String(error),
+              operation: "processLifecycle.close"
+            }
+          }
+        );
+      } finally {
+        if (getProcessLifecycleManager() === this.processLifecycle) {
+          setProcessLifecycleManager(void 0);
+        }
+      }
+    }
+    if (this.verbose) {
+      console.log(chalk3.green("PRWorkflowOrchestrator closed"));
+    }
+  }
+};
+async function executeVariantsLocalFast(taskId, prompt, variants, options = {}) {
+  const prManager = new GitHubPRManager();
+  let costTracker;
+  try {
+    const costCalculator = new UniversalCostCalculator(TelemetryLogger.getInstance());
+    costTracker = new UnifiedCostTracker(costCalculator, TelemetryLogger.getInstance(), {
+      enabled: true
+    });
+  } catch {
+    costTracker = void 0;
+  }
+  const localExecutor = new LocalExecutor({
+    prManager,
+    verbose: options.verbose,
+    costTracker,
+    resultStreamer: options.resultStreamer,
+    preserveWorktrees: options.preserveWorktrees ?? getRuntimeEnv("POETIC_PRESERVE_WORKTREES") === "1"
+  });
+  try {
+    const outputs = [];
+    for (const variant of variants) {
+      if (variant.executionMode !== "local") {
+        throw new Error("Local fast path only supports variants with executionMode=local.");
+      }
+      const result = await localExecutor.executeVariantFastWithRetry(taskId, variant, prompt, {
+        commit: options.commit,
+        cleanup: options.cleanup
+      });
+      outputs.push(result);
+    }
+    return {
+      taskId,
+      variants: outputs,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  } finally {
+    await localExecutor.close();
+  }
+}
+
+// src/orchestrator/judge-completeness-telemetry.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function toJsonValue(value) {
+  if (value === null) return null;
+  if (typeof value === "string" || typeof value === "boolean") return value;
+  if (typeof value === "number") return Number.isFinite(value) ? value : void 0;
+  if (Array.isArray(value)) {
+    return value.map((item) => toJsonValue(item)).filter((item) => item !== void 0);
+  }
+  if (isRecord(value)) {
+    const record = {};
+    for (const [key, item] of Object.entries(value)) {
+      const jsonValue = toJsonValue(item);
+      if (jsonValue !== void 0) {
+        record[key] = jsonValue;
+      }
+    }
+    return record;
+  }
+  return void 0;
+}
+function asJsonArray(value) {
+  const jsonValue = toJsonValue(value);
+  return Array.isArray(jsonValue) && jsonValue.length > 0 ? jsonValue : void 0;
+}
+function getStringArray(value) {
+  return Array.isArray(value) ? value.filter((item) => typeof item === "string" && item.trim().length > 0) : [];
+}
+function collectNegativeSpace(workerPackets) {
+  if (!Array.isArray(workerPackets)) return void 0;
+  const entries = [];
+  for (const packet of workerPackets) {
+    if (!isRecord(packet) || typeof packet.variantId !== "string") continue;
+    const items = getStringArray(packet.negativeSpace);
+    if (items.length > 0) {
+      entries.push({ variant: packet.variantId, items });
+    }
+  }
+  return entries.length > 0 ? entries : void 0;
+}
+function collectEvidenceConcerns(workerEvidenceMatrix) {
+  if (!isRecord(workerEvidenceMatrix)) return void 0;
+  const concerns = [];
+  const criteriaRows = Array.isArray(workerEvidenceMatrix.criteriaRows) ? workerEvidenceMatrix.criteriaRows : [];
+  for (const row of criteriaRows) {
+    if (!isRecord(row) || !isRecord(row.variants)) continue;
+    const item = typeof row.criterion === "string" ? row.criterion : typeof row.criterionKey === "string" ? row.criterionKey : "acceptance criterion";
+    for (const [variant, cell] of Object.entries(row.variants)) {
+      if (!isRecord(cell)) continue;
+      const evidenceStatus = cell.evidenceStatus === "valid" || cell.evidenceStatus === "invalid" || cell.evidenceStatus === "missing" ? cell.evidenceStatus : void 0;
+      const evidenceKind = typeof cell.evidenceKind === "string" ? cell.evidenceKind : void 0;
+      const category = evidenceKind === "unverifiable" || evidenceStatus === "invalid" ? "unverifiable" : evidenceStatus === "missing" || evidenceKind === "missing" ? "missing" : void 0;
+      if (category) {
+        concerns.push({
+          variant,
+          item,
+          category,
+          ...evidenceStatus ? { evidenceStatus } : {},
+          ...evidenceKind ? { evidenceKind } : {}
+        });
+      }
+    }
+  }
+  const emergentFindings = Array.isArray(workerEvidenceMatrix.emergentFindings) ? workerEvidenceMatrix.emergentFindings : [];
+  for (const finding of emergentFindings) {
+    if (!isRecord(finding) || !isRecord(finding.variants)) continue;
+    const item = typeof finding.finding === "string" ? finding.finding : typeof finding.findingKey === "string" ? finding.findingKey : "emergent finding";
+    for (const [variant, cell] of Object.entries(finding.variants)) {
+      if (!isRecord(cell)) continue;
+      const evidenceStatus = cell.evidenceStatus === "valid" || cell.evidenceStatus === "invalid" || cell.evidenceStatus === "missing" ? cell.evidenceStatus : void 0;
+      const status = typeof cell.status === "string" ? cell.status : void 0;
+      const category = status === "unverifiable" || evidenceStatus === "invalid" ? "unverifiable" : evidenceStatus === "missing" ? "missing" : void 0;
+      if (category) {
+        concerns.push({
+          variant,
+          item,
+          category,
+          ...evidenceStatus ? { evidenceStatus } : {}
+        });
+      }
+    }
+  }
+  return concerns.length > 0 ? concerns : void 0;
+}
+function buildJudgeCompletenessTelemetryFromEvaluation(judgeEvaluation) {
+  const audit = judgeEvaluation?.metadata?.audit;
+  if (!isRecord(audit)) return void 0;
+  const coverageGaps = asJsonArray(audit.coverageGaps);
+  const negativeSpaceByVariant = collectNegativeSpace(audit.workerPackets);
+  const evidenceConcerns = collectEvidenceConcerns(audit.workerEvidenceMatrix);
+  const workerEvidenceMatrix = toJsonValue(audit.workerEvidenceMatrix);
+  if (!coverageGaps && !negativeSpaceByVariant && !evidenceConcerns && workerEvidenceMatrix === void 0) {
+    return void 0;
+  }
+  return {
+    source: "judge-audit",
+    ...coverageGaps ? { coverageGaps } : {},
+    ...negativeSpaceByVariant ? { negativeSpaceByVariant } : {},
+    ...evidenceConcerns ? { evidenceConcerns } : {},
+    ...workerEvidenceMatrix !== void 0 ? { workerEvidenceMatrix } : {}
+  };
+}
+function buildJudgeCompletenessTelemetryFromVariants(variants) {
+  for (const variant of variants) {
+    const telemetry = buildJudgeCompletenessTelemetryFromEvaluation(variant.judgeEvaluation);
+    if (telemetry) return telemetry;
+  }
+  return void 0;
+}
+
+// src/cli/competition-interruption.ts
+function shouldStopBeforeJudgeOrSynthesis(isShuttingDown, variants) {
+  return isShuttingDown || variants.some((variant) => variant.terminationReason === "canceled_user");
+}
+
+// src/cli/handlers/compete/concurrency-config.ts
+function asValidConcurrency(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : void 0;
+}
+async function loadConfiguredConcurrency(explicitRequest) {
+  if (explicitRequest !== void 0) return {};
+  try {
+    const merged = await new ConfigManager().loadConfig();
+    return {
+      maxConcurrent: asValidConcurrency(merged.config.variants?.maxConcurrent),
+      worktreeMax: asValidConcurrency(merged.config.worktree?.maxConcurrent)
+    };
+  } catch (error) {
+    rethrowConfigValidityError(error);
+    return {};
+  }
+}
+function concurrencyAdvisoryMessage(effectiveMaxConcurrent) {
+  if (typeof effectiveMaxConcurrent !== "number") return void 0;
+  const legSlots = detectHostConcurrencyBudget().legSlots;
+  if (effectiveMaxConcurrent <= legSlots) return void 0;
+  return `Requested concurrency ${effectiveMaxConcurrent} exceeds this host's recommendation of ${legSlots} legs (see poetic doctor); running as asked with validation pacing.`;
+}
+
+// src/cli/handlers/compete/research-trace-persistence.ts
+import { mkdir, writeFile } from "fs/promises";
+import path2 from "path";
+function resolveNativeResearchTraceDir(poeticDir, taskId, resolver = LabPathResolver.getInstance()) {
+  const labContext = resolver.getContext();
+  if (labContext) {
+    return path2.join(
+      poeticDir,
+      "labs",
+      labContext.labId,
+      "runs",
+      labContext.runId,
+      "research",
+      taskId
+    );
+  }
+  return path2.join(poeticDir, "research", taskId);
+}
+async function persistNativeResearchTraces(input) {
+  const traceDir = input.traceDir ?? resolveNativeResearchTraceDir(
+    input.poeticDir ?? path2.join(process.cwd(), ".poetic"),
+    input.taskId
+  );
+  const cleared = new Set(
+    Array.from(input.clearedProviders, (provider) => provider.trim().toLowerCase())
+  );
+  let traceDirReady = false;
+  let tracesPersisted = 0;
+  const failures = [];
+  for (const variant of input.variants) {
+    if (variant.success !== true) continue;
+    if (!cleared.has(variant.provider.trim().toLowerCase())) continue;
+    const variantKey = formatVariantIdentifierFromResult(variant);
+    const trace = parseCitationTrace({
+      variantId: variantKey,
+      provider: variant.provider,
+      mode: "native",
+      output: variant.result?.stdout ?? variant.output ?? "",
+      corroboratedUrls: variant.result?.researchCorroboratedUrls,
+      observedWebToolEvent: variant.result?.researchObservedWebToolEvent,
+      excludedDomains: input.excludedDomains
+    });
+    variant.researchTrace = trace;
+    try {
+      if (!traceDirReady) {
+        await mkdir(traceDir, { recursive: true });
+        traceDirReady = true;
+      }
+      const tracePath = path2.join(
+        traceDir,
+        `${toVariantSlug(variantKey) || "variant"}-research-trace.json`
+      );
+      trace.artifactPath = tracePath;
+      await writeFile(tracePath, serializeCitationTrace(trace), "utf-8");
+      tracesPersisted++;
+    } catch (error) {
+      failures.push({
+        variantId: variantKey,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  const totalCitations = input.variants.reduce(
+    (sum, variant) => sum + (variant.researchTrace?.citations.length ?? 0),
+    0
+  );
+  const excludedDomainViolations = input.variants.reduce(
+    (sum, variant) => sum + (variant.researchTrace?.citations.filter((citation) => citation.excludedDomainViolation).length ?? 0),
+    0
+  );
+  return { traceDir, totalCitations, excludedDomainViolations, tracesPersisted, failures };
+}
+
+export {
+  DependencyGraphResolver,
+  validateVerbosity,
+  PRWorkflowOrchestrator,
+  executeVariantsLocalFast,
+  buildJudgeCompletenessTelemetryFromVariants,
+  shouldStopBeforeJudgeOrSynthesis,
+  loadConfiguredConcurrency,
+  concurrencyAdvisoryMessage,
+  resolveNativeResearchTraceDir,
+  persistNativeResearchTraces
+};
+//# sourceMappingURL=chunk-WGXYDLMX.js.map