@poetic-ai/poetic 1.42.1-bootstrap.0

package/dist/chunk-3VABAKT2.js

@@ -0,0 +1,1784 @@
+import {
+  CoreLensEvaluator,
+  MultiLensJudge
+} from "./chunk-4SALLK63.js";
+import {
+  createPercentScore,
+  percentScoreToNumber
+} from "./chunk-TSPQONRT.js";
+import {
+  TelemetryLogger
+} from "./chunk-T6VPI2XP.js";
+
+// scripts/simulation/analysis.ts
+import { rootMeanSquare, sampleRankCorrelation } from "simple-statistics";
+var MULTI_LENS_CORE_WEIGHTS = [0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1];
+var PLANNING_CAP_VALUES = [30, 40, 50];
+function binomialConfidenceInterval(successes, trials, z = 1.96) {
+  if (trials === 0) {
+    return [0, 1];
+  }
+  const p = successes / trials;
+  const denominator = 1 + z * z / trials;
+  const centre = p + z * z / (2 * trials);
+  const margin = z * Math.sqrt(p * (1 - p) / trials + z * z / (4 * trials * trials));
+  const lower = (centre - margin) / denominator;
+  const upper = (centre + margin) / denominator;
+  return [Math.max(0, lower), Math.min(1, upper)];
+}
+function mapEvaluationsToScores(result) {
+  if (!result) return null;
+  const map = {};
+  for (const evaluation of result.evaluations) {
+    map[evaluation.variant] = percentScoreToNumber(evaluation.qualityScore);
+  }
+  return map;
+}
+function clamp01(value) {
+  if (!Number.isFinite(value)) return 0;
+  return Math.max(0, Math.min(1, value));
+}
+function extractConfidence01(result) {
+  if (!result || !result.metadata) return null;
+  const meta = result.metadata;
+  const rawCandidates = [meta.confidence, meta.confidenceScore];
+  for (const raw of rawCandidates) {
+    const numeric = Number(raw);
+    if (!Number.isFinite(numeric)) continue;
+    const normalized = numeric <= 1 ? numeric : numeric / 100;
+    return clamp01(normalized);
+  }
+  return null;
+}
+function computeBrier(pairs) {
+  if (pairs.length === 0) return void 0;
+  const sum = pairs.reduce((acc, { p, y }) => acc + (p - y) * (p - y), 0);
+  return sum / pairs.length;
+}
+function computeEce10(pairs) {
+  if (pairs.length === 0) return void 0;
+  const bins = Array.from({ length: 10 }, () => ({ count: 0, sumP: 0, sumY: 0 }));
+  for (const { p, y } of pairs) {
+    const idx = Math.min(9, Math.max(0, Math.floor(clamp01(p) * 10)));
+    const bin = bins[idx];
+    if (!bin) continue;
+    bin.count += 1;
+    bin.sumP += p;
+    bin.sumY += y;
+  }
+  const total = pairs.length;
+  let ece = 0;
+  for (const bin of bins) {
+    if (bin.count === 0) continue;
+    const avgP = bin.sumP / bin.count;
+    const acc = bin.sumY / bin.count;
+    ece += bin.count / total * Math.abs(acc - avgP);
+  }
+  return ece;
+}
+function updateSweepBucket(bucket, key, judge, params, matchesGroundTruth) {
+  if (!bucket[key]) {
+    bucket[key] = { judge, params, winnerMatches: 0, total: 0 };
+  }
+  const entry = bucket[key];
+  if (entry) {
+    entry.total += 1;
+    if (matchesGroundTruth) {
+      entry.winnerMatches += 1;
+    }
+  }
+}
+function selectGroundTruth(scenario, judge, mode) {
+  if (mode === "policy") {
+    const policyModel = scenario.groundTruth.policyModels?.[judge];
+    if (policyModel) {
+      return {
+        expectedRanking: policyModel.expectedRanking,
+        expectedWinner: policyModel.expectedWinner,
+        expectedScores: policyModel.expectedScores
+      };
+    }
+  }
+  return {
+    expectedRanking: scenario.groundTruth.expectedRanking,
+    expectedWinner: scenario.groundTruth.expectedWinner,
+    expectedScores: scenario.groundTruth.expectedScores
+  };
+}
+function accumulateJudgeStats(bucket, scores, judgeWinner, expected) {
+  const actualOrder = Object.keys(scores).sort((a, b) => (scores[b] ?? 0) - (scores[a] ?? 0));
+  const expectedList = expected.expectedRanking;
+  for (const variantId of expectedList) {
+    const expectedRank = expectedList.indexOf(variantId);
+    const actualRank = actualOrder.indexOf(variantId);
+    if (expectedRank < 0 || actualRank < 0) continue;
+    bucket.expectedRanks.push(expectedRank + 1);
+    bucket.actualRanks.push(actualRank + 1);
+    bucket.diffs.push((scores[variantId] ?? 0) - (expected.expectedScores[variantId] ?? 0));
+  }
+  const winnerMatches = judgeWinner === expected.expectedWinner;
+  if (winnerMatches) bucket.winnerMatches += 1;
+  bucket.total += 1;
+  return winnerMatches;
+}
+function finalizeAccuracyMetrics(stats, calibrationPairs, agreement) {
+  const accuracy = {
+    judges: {},
+    agreementRate: agreement
+  };
+  for (const judge of ["multiLens", "hybrid"]) {
+    const { expectedRanks, actualRanks, diffs, winnerMatches, total } = stats[judge];
+    const rmse = diffs.length > 0 ? rootMeanSquare(diffs) : 0;
+    const bias = diffs.length > 0 ? diffs.reduce((acc, value) => acc + value, 0) / diffs.length : 0;
+    const correlation = expectedRanks.length > 1 && actualRanks.length > 1 ? sampleRankCorrelation(expectedRanks, actualRanks) : 0;
+    const winnerAccuracy = total === 0 ? 0 : winnerMatches / total;
+    const pairs = calibrationPairs[judge];
+    const brier = computeBrier(pairs);
+    const ece = computeEce10(pairs);
+    accuracy.judges[judge] = {
+      winnerAccuracy,
+      winnerAccuracyCI: binomialConfidenceInterval(winnerMatches, total),
+      rankingCorrelation: correlation,
+      scoreRMSE: rmse,
+      scoreBias: bias,
+      brierScore: brier,
+      expectedCalibrationError: ece,
+      calibrationCount: pairs.length
+    };
+  }
+  return accuracy;
+}
+function analyzeSimulationResults(results, prompt, options = {}) {
+  const judgeNames = ["multiLens", "hybrid"];
+  const legacyStats = {
+    multiLens: { expectedRanks: [], actualRanks: [], diffs: [], winnerMatches: 0, total: 0 },
+    hybrid: { expectedRanks: [], actualRanks: [], diffs: [], winnerMatches: 0, total: 0 }
+  };
+  const policyStats = {
+    multiLens: { expectedRanks: [], actualRanks: [], diffs: [], winnerMatches: 0, total: 0 },
+    hybrid: { expectedRanks: [], actualRanks: [], diffs: [], winnerMatches: 0, total: 0 }
+  };
+  const legacyCalibrationPairs = {
+    multiLens: [],
+    hybrid: []
+  };
+  const policyCalibrationPairs = {
+    multiLens: [],
+    hybrid: []
+  };
+  let agreementMatches = 0;
+  let agreementTotal = 0;
+  const bucketMap = {};
+  const coreLens = new CoreLensEvaluator();
+  for (const scenario of results) {
+    const { groundTruth, variants } = scenario;
+    const scenarioPrompt = scenario.scenario.prompt ?? prompt;
+    const staticScores = coreLens.evaluate(variants, scenarioPrompt);
+    const staticRanking = variants.map((variant, index) => ({ variantId: variant.variant, score: staticScores[index] ?? 0 })).sort((a, b) => (b.score ?? 0) - (a.score ?? 0) || a.variantId.localeCompare(b.variantId));
+    const staticWinner = staticRanking[0]?.variantId ?? variants[0]?.variant ?? "unknown";
+    const hybridWinner = scenario.hybridResult?.winner ?? staticWinner;
+    const hybridScores = mapEvaluationsToScores(scenario.hybridResult);
+    const multiLensScores = mapEvaluationsToScores(scenario.multiLensResult);
+    for (const judge of judgeNames) {
+      const scores = judge === "multiLens" ? multiLensScores : hybridScores;
+      if (!scores) {
+        continue;
+      }
+      const judgeResult = scenario[judge === "multiLens" ? "multiLensResult" : "hybridResult"];
+      const judgeWinner = judgeResult?.winner;
+      const legacyExpected = selectGroundTruth(scenario, judge, "legacy");
+      const policyExpected = selectGroundTruth(scenario, judge, "policy");
+      const legacyWinnerMatches = accumulateJudgeStats(
+        legacyStats[judge],
+        scores,
+        judgeWinner,
+        legacyExpected
+      );
+      const policyWinnerMatches = accumulateJudgeStats(
+        policyStats[judge],
+        scores,
+        judgeWinner,
+        policyExpected
+      );
+      const p = extractConfidence01(judgeResult);
+      if (p !== null) {
+        legacyCalibrationPairs[judge].push({ p, y: legacyWinnerMatches ? 1 : 0 });
+        policyCalibrationPairs[judge].push({ p, y: policyWinnerMatches ? 1 : 0 });
+      }
+    }
+    if (scenario.multiLensResult && scenario.hybridResult) {
+      agreementTotal += 1;
+      if (scenario.multiLensResult.winner === scenario.hybridResult.winner) {
+        agreementMatches += 1;
+      }
+    }
+    if (options.enableSweep ?? true) {
+      updateSweepBucket(
+        bucketMap,
+        "hybrid:mode=always_ai",
+        "hybrid",
+        {},
+        hybridWinner === groundTruth.expectedWinner
+      );
+      for (const coreWeight of MULTI_LENS_CORE_WEIGHTS) {
+        for (const planningCap of PLANNING_CAP_VALUES) {
+          const scores = variants.map((variant) => {
+            const coreScore = groundTruth.expectedScores[variant.variant] ?? 0;
+            const strategyScore2 = groundTruth.expectedStrategyScores[variant.variant] ?? 0;
+            const combined = coreWeight * coreScore + (1 - coreWeight) * strategyScore2;
+            const isPlanningOnly = variant.executionCategory === "analysis";
+            const capped = isPlanningOnly ? Math.min(planningCap, combined) : combined;
+            return { variantId: variant.variant, value: capped };
+          });
+          scores.sort((a, b) => b.value - a.value || a.variantId.localeCompare(b.variantId));
+          const predictedWinner = scores[0]?.variantId ?? "unknown";
+          const matchesGroundTruth = predictedWinner === groundTruth.expectedWinner;
+          updateSweepBucket(
+            bucketMap,
+            `multiLens:core=${coreWeight}:cap=${planningCap}`,
+            "multiLens",
+            { coreWeight, planningCapValue: planningCap },
+            matchesGroundTruth
+          );
+        }
+      }
+    }
+  }
+  const agreementRate = {
+    matches: agreementMatches,
+    total: agreementTotal,
+    rate: agreementTotal === 0 ? 0 : agreementMatches / agreementTotal
+  };
+  const accuracy = finalizeAccuracyMetrics(legacyStats, legacyCalibrationPairs, agreementRate);
+  const policyAccuracy = finalizeAccuracyMetrics(
+    policyStats,
+    policyCalibrationPairs,
+    agreementRate
+  );
+  const sweepEntries = options.enableSweep ?? true ? Object.values(bucketMap).map((bucket) => ({
+    judge: bucket.judge,
+    params: bucket.params,
+    totalScenarios: bucket.total,
+    winnerAccuracy: bucket.total === 0 ? 0 : bucket.winnerMatches / bucket.total
+  })).sort((a, b) => b.winnerAccuracy - a.winnerAccuracy) : [];
+  const parameterSweep = {
+    entries: sweepEntries
+  };
+  return { accuracy, policyAccuracy, parameterSweep };
+}
+
+// scripts/simulation/spec-harness.ts
+import path from "path";
+var EXCLUDED_DIR_PREFIXES = ["node_modules/", ".git/", "dist/", "coverage/", "build/"];
+function normalizeRepoRelativePath(raw) {
+  const trimmed = raw.trim();
+  const withSlashes = trimmed.replaceAll("\\", "/");
+  const isAbsolute = path.posix.isAbsolute(withSlashes) || /^[a-zA-Z]:\//.test(withSlashes);
+  const normalized = path.posix.normalize(withSlashes).replace(/^(\.\/)+/, "");
+  return { normalized, isAbsolute };
+}
+function isOutsideRepo(normalized) {
+  if (normalized === "..") return true;
+  if (normalized.startsWith("../")) return true;
+  return normalized.includes("/../") || normalized.includes("/..");
+}
+function isExcluded(normalized) {
+  if (EXCLUDED_DIR_PREFIXES.some((prefix) => normalized === prefix.slice(0, -1))) return true;
+  return EXCLUDED_DIR_PREFIXES.some((prefix) => normalized.startsWith(prefix));
+}
+function validateRepoRelativePaths(inputs) {
+  const violations = [];
+  const valid = [];
+  for (const input of inputs) {
+    if (typeof input !== "string") {
+      violations.push({
+        code: "NON_STRING",
+        input,
+        reason: `expected string path, received ${input === null ? "null" : typeof input}`
+      });
+      continue;
+    }
+    if (input.trim().length === 0) {
+      violations.push({ code: "EMPTY", input, reason: "empty path" });
+      continue;
+    }
+    const { normalized, isAbsolute } = normalizeRepoRelativePath(input);
+    if (normalized.length === 0 || normalized === ".") {
+      violations.push({
+        code: "EMPTY",
+        input,
+        normalized,
+        reason: "empty path after normalization"
+      });
+      continue;
+    }
+    if (isAbsolute) {
+      violations.push({ code: "ABSOLUTE", input, normalized, reason: "absolute path" });
+      continue;
+    }
+    if (normalized.includes("\0")) {
+      violations.push({ code: "INVALID", input, normalized, reason: "contains NUL byte" });
+      continue;
+    }
+    if (isOutsideRepo(normalized)) {
+      violations.push({
+        code: "OUTSIDE_REPO",
+        input,
+        normalized,
+        reason: "path escapes repo boundary"
+      });
+      continue;
+    }
+    if (isExcluded(normalized)) {
+      violations.push({
+        code: "EXCLUDED_DIR",
+        input,
+        normalized,
+        reason: "path targets excluded directory"
+      });
+      continue;
+    }
+    valid.push(normalized);
+  }
+  valid.sort((a, b) => a.localeCompare(b));
+  const deduped = [];
+  for (const item of valid) {
+    if (deduped.length === 0 || deduped[deduped.length - 1] !== item) {
+      deduped.push(item);
+    }
+  }
+  return { valid: deduped, violations };
+}
+
+// scripts/simulation/deterministic-judge.ts
+var clamp = (value) => Math.max(0, Math.min(100, value));
+function coerceFiniteNumber(value, fallback) {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string" && value.trim().length > 0) {
+    const parsed = Number(value);
+    if (Number.isFinite(parsed)) return parsed;
+  }
+  return fallback;
+}
+function extractSyntheticSignals(variant) {
+  const rubricMeta = variant.evaluationRubric?.metadata;
+  const synthetic = rubricMeta && typeof rubricMeta === "object" ? rubricMeta.synthetic : void 0;
+  const syntheticObj = synthetic && typeof synthetic === "object" ? synthetic : {};
+  const fallbackCompleteness = coerceFiniteNumber(variant.completeness, 0);
+  const fallbackCorrectness = coerceFiniteNumber(variant.testMetrics?.passRate, 50);
+  const edgeModifiersRaw = syntheticObj.edgeModifiers;
+  const edgeModifiers = edgeModifiersRaw && typeof edgeModifiersRaw === "object" ? edgeModifiersRaw : {};
+  return {
+    codeQuality: clamp(coerceFiniteNumber(syntheticObj.codeQuality, fallbackCompleteness)),
+    correctness: clamp(coerceFiniteNumber(syntheticObj.correctness, fallbackCorrectness)),
+    completeness: clamp(coerceFiniteNumber(syntheticObj.completeness, fallbackCompleteness)),
+    innovation: clamp(coerceFiniteNumber(syntheticObj.innovation, 50)),
+    files: Array.isArray(syntheticObj.files) ? syntheticObj.files : [],
+    edgeModifiers
+  };
+}
+function inferDocsOnly(validPaths) {
+  if (validPaths.length === 0) return false;
+  const isDoc = (p) => p.startsWith("docs/") || p.endsWith(".md") || p.endsWith(".mdx");
+  return validPaths.every(isDoc);
+}
+function buildStrengthsWeaknesses(scores) {
+  const strengths = [];
+  const weaknesses = [];
+  if (scores.functionalCorrectness >= 85)
+    strengths.push("Strong correctness and validation signals");
+  if (scores.semanticTaskFit >= 85) strengths.push("High semantic task fit and completeness");
+  if (scores.maintainability >= 85) strengths.push("Maintainable, readable implementation shape");
+  if (scores.changeDiscipline >= 85) strengths.push("Disciplined, scoped changes");
+  if (scores.functionalCorrectness <= 50)
+    weaknesses.push("Correctness risk (tests/syntax/execution)");
+  if (scores.semanticTaskFit <= 50) weaknesses.push("Low completeness or mismatched intent");
+  if (scores.maintainability <= 50) weaknesses.push("Quality/maintainability concerns");
+  if (scores.changeDiscipline <= 50)
+    weaknesses.push("Change discipline issues (scope/paths/empties)");
+  if (strengths.length === 0 && scores.finalScore >= 60) strengths.push("Solid overall balance");
+  if (weaknesses.length === 0 && scores.finalScore < 60)
+    weaknesses.push("Overall score below target threshold");
+  return { strengths, weaknesses };
+}
+function computeCategoryScores(signals) {
+  const semanticTaskFit2 = clamp(signals.completeness * 0.85 + signals.correctness * 0.15);
+  const functionalCorrectness2 = clamp(signals.correctness);
+  const maintainability2 = clamp(signals.codeQuality * 0.65 + signals.innovation * 0.35);
+  const changeDiscipline2 = clamp(100 - signals.completeness * 0.3 + signals.codeQuality * 0.2);
+  const strategyScore2 = clamp(signals.codeQuality * 0.6 + signals.innovation * 0.4);
+  return {
+    semanticTaskFit: semanticTaskFit2,
+    functionalCorrectness: functionalCorrectness2,
+    maintainability: maintainability2,
+    changeDiscipline: changeDiscipline2,
+    strategyScore: strategyScore2
+  };
+}
+function applyDeterministicCaps(variant, signals, baseScore) {
+  let score = baseScore;
+  const capReasons = [];
+  let planningCapApplied = false;
+  const { valid: validPaths, violations } = validateRepoRelativePaths(signals.files);
+  const hasPathViolations = violations.length > 0;
+  const docsOnly = Boolean(signals.edgeModifiers.isDocsOnly) || inferDocsOnly(validPaths) || Boolean(variant.completenessScore?.factors?.docsOnly);
+  const emptyChanges = Boolean(signals.edgeModifiers.hasEmptyChanges) || variant.emptyChanges === true || (variant.gitMetrics?.filesChanged ?? 0) === 0 || typeof variant.worktreeDiff === "string" && variant.worktreeDiff.length === 0;
+  const planningOnly = Boolean(signals.edgeModifiers.isPlanningOnly) || variant.executionCategory === "analysis" || variant.executionIntent === "analysis";
+  const hasTestFailures = Boolean(signals.edgeModifiers.hasTestFailures) || variant.testStatus === "failed";
+  const hasSyntaxErrors = Boolean(signals.edgeModifiers.hasSyntaxErrors) || typeof variant.result?.stderr === "string" && /syntaxerror/i.test(variant.result.stderr);
+  if (planningOnly) {
+    capReasons.push("planning-only cap");
+    planningCapApplied = true;
+    score = Math.min(score, 40);
+  }
+  if (hasTestFailures) {
+    capReasons.push("tests-failed cap");
+    score = Math.min(score, 50);
+  }
+  if (hasSyntaxErrors) {
+    capReasons.push("syntax-error cap");
+    score = Math.min(score, 40);
+  }
+  if (emptyChanges) {
+    capReasons.push("empty-changes cap");
+    score = Math.min(score, 10);
+  }
+  if (docsOnly) {
+    capReasons.push("docs-only cap");
+    score = Math.min(score, 60);
+  }
+  if (signals.edgeModifiers.hasOrphanedTestImports) {
+    capReasons.push("orphaned-test-imports cap");
+    score = Math.min(score, 60);
+  }
+  if (hasPathViolations) {
+    capReasons.push("invalid-paths cap");
+    score = Math.min(score, 10);
+  }
+  return { finalScore: clamp(score), capReasons, planningCapApplied };
+}
+function buildEvaluation(variantId, categories, finalScore, capReasons, judgeKind) {
+  const { strengths, weaknesses } = buildStrengthsWeaknesses({
+    semanticTaskFit: categories.semanticTaskFit,
+    functionalCorrectness: categories.functionalCorrectness,
+    maintainability: categories.maintainability,
+    changeDiscipline: categories.changeDiscipline,
+    finalScore
+  });
+  const primaryReason = capReasons.length > 0 ? `Capped (${capReasons.join(", ")})` : judgeKind === "hybrid" ? "Static deterministic evaluation: high-confidence winner selection" : "Static deterministic evaluation: multi-lens composite scoring";
+  return {
+    variant: variantId,
+    qualityScore: createPercentScore(finalScore, `simulation ${judgeKind} qualityScore`),
+    strengths,
+    weaknesses,
+    codeQuality: {
+      correctness: createPercentScore(categories.functionalCorrectness, "correctness"),
+      readability: createPercentScore(categories.maintainability, "readability"),
+      maintainability: createPercentScore(categories.maintainability, "maintainability"),
+      completeness: createPercentScore(categories.semanticTaskFit, "completeness"),
+      innovation: createPercentScore(categories.strategyScore, "innovation"),
+      security: createPercentScore(categories.changeDiscipline, "security")
+    },
+    schemaVersion: "2.0",
+    planningCap: capReasons.includes("planning-only cap") ? { applied: true, reason: "planning-only", preCapScore: finalScore } : { applied: false },
+    scoreBreakdown: {
+      core: createPercentScore(finalScore, "core"),
+      strategy: createPercentScore(categories.strategyScore, "strategy"),
+      combined: createPercentScore(finalScore, "combined"),
+      weights: { core: 1, strategy: 0 }
+    },
+    primaryReason
+  };
+}
+function simulateJudgeSynthesisResult(judgeKind, variants, _prompt) {
+  const startTime = Date.now();
+  if (!variants || variants.length === 0) {
+    return {
+      winner: "unknown",
+      evaluations: [],
+      reasoning: "No variants provided for evaluation",
+      recommendations: ["Provide at least one variant to evaluate"],
+      metadata: {
+        model: `simulation:${judgeKind}:deterministic-v1`,
+        evaluationTimeMs: 0,
+        confidence: createPercentScore(0, "no variants"),
+        timestamp: /* @__PURE__ */ new Date(),
+        topVariants: []
+      }
+    };
+  }
+  const stableVariants = [...variants].sort((a, b) => a.variant.localeCompare(b.variant));
+  const finalAllScores = {};
+  const evaluations = [];
+  const audit = {};
+  for (const variant of stableVariants) {
+    const signals = extractSyntheticSignals(variant);
+    const categories = computeCategoryScores(signals);
+    const baseScore = judgeKind === "hybrid" ? 0.4 * categories.functionalCorrectness + 0.35 * clamp(signals.codeQuality * 0.8 + signals.innovation * 0.2) + 0.25 * clamp(signals.completeness) : 0.45 * categories.semanticTaskFit + 0.35 * categories.functionalCorrectness + 0.15 * categories.maintainability + 0.05 * categories.changeDiscipline;
+    const capped = applyDeterministicCaps(variant, signals, baseScore);
+    finalAllScores[variant.variant] = capped.finalScore;
+    evaluations.push(
+      buildEvaluation(variant.variant, categories, capped.finalScore, capped.capReasons, judgeKind)
+    );
+    audit[variant.variant] = {
+      baseScore: clamp(baseScore),
+      capReasons: capped.capReasons,
+      files: validateRepoRelativePaths(signals.files).valid
+    };
+  }
+  if (judgeKind === "hybrid") {
+    const isCorrectnessFailure2 = (v) => {
+      const s = extractSyntheticSignals(v);
+      return Boolean(s.edgeModifiers.hasTestFailures || s.edgeModifiers.hasSyntaxErrors);
+    };
+    const isLikelyCorrect = (v) => {
+      const s = extractSyntheticSignals(v);
+      return !isCorrectnessFailure2(v) && s.correctness >= 70;
+    };
+    const bestCorrect = stableVariants.filter(isLikelyCorrect).sort(
+      (a, b) => (finalAllScores[b.variant] ?? 0) - (finalAllScores[a.variant] ?? 0) || a.variant.localeCompare(b.variant)
+    )[0];
+    if (bestCorrect) {
+      const bestScore = finalAllScores[bestCorrect.variant] ?? 0;
+      for (const v of stableVariants) {
+        if (!isCorrectnessFailure2(v)) continue;
+        const current = finalAllScores[v.variant] ?? 0;
+        if (current >= bestScore) {
+          finalAllScores[v.variant] = clamp(Math.max(0, bestScore - 0.1));
+        }
+      }
+    }
+  } else {
+    const STRONG_CORRECTNESS_GAP = 25;
+    const variantsWithSignals = stableVariants.map((v) => ({
+      variant: v,
+      signals: extractSyntheticSignals(v),
+      score: finalAllScores[v.variant] ?? 0
+    }));
+    for (let i = 0; i < variantsWithSignals.length; i++) {
+      const a = variantsWithSignals[i];
+      if (!a) continue;
+      for (let j = i + 1; j < variantsWithSignals.length; j++) {
+        const b = variantsWithSignals[j];
+        if (!b) continue;
+        const correctnessA = a.signals.correctness;
+        const correctnessB = b.signals.correctness;
+        if (correctnessA >= correctnessB + STRONG_CORRECTNESS_GAP && b.score > a.score) {
+          finalAllScores[b.variant.variant] = clamp(Math.max(0, a.score - 0.1));
+        } else if (correctnessB >= correctnessA + STRONG_CORRECTNESS_GAP && a.score > b.score) {
+          finalAllScores[a.variant.variant] = clamp(Math.max(0, b.score - 0.1));
+        }
+      }
+    }
+  }
+  const ranked = Object.keys(finalAllScores).sort(
+    (a, b) => (finalAllScores[b] ?? 0) - (finalAllScores[a] ?? 0) || a.localeCompare(b)
+  );
+  const winner = ranked[0] ?? stableVariants[0]?.variant ?? "unknown";
+  const winnerScore = finalAllScores[winner] ?? 0;
+  const runnerUp = ranked[1];
+  const runnerUpScore = runnerUp ? finalAllScores[runnerUp] ?? 0 : winnerScore;
+  const margin = Math.max(0, winnerScore - runnerUpScore);
+  const confidence = judgeKind === "hybrid" ? margin > 15 ? 98 : margin > 5 ? 95 : margin > 3 ? 90 : margin > 1 ? 85 : 80 : clamp(55 + margin * 0.9);
+  const reasoning = ranked.length <= 1 ? `Single-variant evaluation; selecting ${winner}` : `Selected ${winner} (score=${winnerScore.toFixed(1)}) over ${runnerUp} (score=${runnerUpScore.toFixed(1)}), margin=${margin.toFixed(1)}`;
+  return {
+    winner,
+    evaluations: evaluations.sort(
+      (a, b) => percentScoreToNumber(b.qualityScore) - percentScoreToNumber(a.qualityScore) || a.variant.localeCompare(b.variant)
+    ),
+    reasoning,
+    recommendations: [],
+    confidence: createPercentScore(confidence, "simulation confidence"),
+    metadata: {
+      model: `simulation:${judgeKind}:deterministic-v1`,
+      timestamp: /* @__PURE__ */ new Date(),
+      evaluationTimeMs: Math.max(0, Date.now() - startTime),
+      confidence: createPercentScore(confidence, "simulation confidence"),
+      finalAllScores,
+      topVariants: ranked.slice(0, 5),
+      audit: {
+        judgeKind,
+        deterministic: true,
+        marginScore: margin,
+        perVariant: audit
+      },
+      ...judgeKind === "hybrid" ? {
+        routedToAI: false,
+        confidenceScore: createPercentScore(confidence, "static confidence"),
+        marginScore: margin,
+        staticWinner: winner,
+        staticConfidence: createPercentScore(confidence, "static confidence"),
+        staticEvaluationTimeMs: Math.max(0, Date.now() - startTime),
+        aiAttempted: false,
+        staticFallback: true,
+        routeTier: "static"
+      } : {}
+    }
+  };
+}
+
+// scripts/simulation/generators.ts
+import path2 from "path";
+var DEFAULT_FILES = ["src/lib/main.ts", "src/core/judge/judge.ts", "docs/runtime.md"];
+function clampScore(value) {
+  if (Number.isNaN(value)) return 0;
+  return Math.max(0, Math.min(100, value));
+}
+function safeIdentifier(input) {
+  const normalized = input.trim().replace(/[^a-zA-Z0-9_]/g, "_");
+  return normalized.length > 0 ? normalized : "variant";
+}
+function buildCodeDocOnlyLines(spec, file) {
+  const label = safeIdentifier(spec.variantLabel);
+  return [
+    "+/**",
+    `+ * ${label}: documentation-only change`,
+    "+ *",
+    "+ * NOTE: No runtime logic changes intended.",
+    "+ */",
+    `+// ${label}: updated docs for ${file}`
+  ];
+}
+function buildCodeExecutableLines(spec) {
+  const label = safeIdentifier(spec.variantLabel);
+  const quality = typeof spec.codeQuality === "number" ? spec.codeQuality : 65;
+  if (quality <= 55) {
+    return [
+      `+export function ${label}Example(): number {`,
+      "+  // TODO: cleanup",
+      "+  let x: any = 7;",
+      "+  x++;",
+      "+  x = x + 42;",
+      "+  return x;",
+      "+}"
+    ];
+  }
+  if (quality >= 75) {
+    return [
+      "+const EXAMPLE_DEFAULT = 1;",
+      `+function compute${label}Example(): number {`,
+      "+  return EXAMPLE_DEFAULT;",
+      "+}",
+      `+export function ${label}Example(): number {`,
+      `+  return compute${label}Example();`,
+      "+}"
+    ];
+  }
+  return [`+export function ${label}Example(): number {`, "+  return 1;", "+}"];
+}
+function buildTestExecutableLines(spec) {
+  const label = safeIdentifier(spec.variantLabel);
+  const orphanedImport = spec.edgeModifiers?.hasOrphanedTestImports ? [`+import { missing } from './__poetic_orphaned_test_import_never_exists__';`, "+"] : [];
+  return [
+    `+import { describe, it, expect } from 'vitest';`,
+    "+",
+    ...orphanedImport,
+    `+describe('${label}', () => {`,
+    `+  it('works', () => {`,
+    "+    expect(1).toBe(1);",
+    "+  });",
+    "+});"
+  ];
+}
+function buildMarkdownLines(spec) {
+  const label = safeIdentifier(spec.variantLabel);
+  return [`+## ${label} update`, "+", "+- Added documentation and usage notes."];
+}
+function buildFileChange(spec, file, linesAdded) {
+  const ext = path2.posix.extname(file).toLowerCase();
+  const isTestFile = /\.test\.(ts|tsx|js|jsx)$/.test(file) || /\/__tests__\//.test(file);
+  const isCodeFile = [".ts", ".tsx", ".js", ".jsx"].includes(ext);
+  const isMarkdown = ext === ".md";
+  if (isMarkdown) {
+    return buildMarkdownLines(spec);
+  }
+  if (isCodeFile) {
+    if (spec.edgeModifiers?.docOnlyInCodeFiles) {
+      return buildCodeDocOnlyLines(spec, file);
+    }
+    if (spec.edgeModifiers?.addsExecutableLines) {
+      return isTestFile ? buildTestExecutableLines(spec) : buildCodeExecutableLines(spec);
+    }
+  }
+  const quality = typeof spec.codeQuality === "number" ? spec.codeQuality : 65;
+  const buildLegacyQualitySignalLines = () => {
+    if (!isCodeFile) return [];
+    if (quality <= 55) {
+      return [
+        "+// TODO: tidy this up later",
+        "+let tmp: any = 2 + 3 + 4 + 5 + 6 + 7;",
+        "+tmp++;",
+        "+const data: any[] = [];",
+        "+data.push(tmp);",
+        "+data.sort();"
+      ];
+    }
+    if (quality >= 75) {
+      return [
+        "+const EXAMPLE_LIMIT = 10;",
+        "+function buildExampleValue(): number {",
+        "+  return EXAMPLE_LIMIT;",
+        "+}",
+        "+const EXAMPLE_RESULT = buildExampleValue();"
+      ];
+    }
+    return [
+      "+const exampleLimit = 10;",
+      "+function buildExampleValue(): number {",
+      "+  return exampleLimit;",
+      "+}"
+    ];
+  };
+  const lines = [];
+  lines.push(`+// ${spec.variantLabel} modification`);
+  lines.push(`+// ${spec.description ?? "Synthetic change"}`);
+  lines.push(...buildLegacyQualitySignalLines());
+  for (let i = 0; i < Math.max(1, Math.floor(linesAdded)); i += 1) {
+    lines.push(`+// ${spec.variantLabel} change`);
+    lines.push(`-// ${spec.variantLabel} old change`);
+  }
+  return lines;
+}
+function buildDiff(spec, files, linesAdded) {
+  if (spec.edgeModifiers?.hasEmptyChanges) return "";
+  const parts = [];
+  for (const file of files) {
+    const basePath = file.startsWith("/") ? file : path2.posix.join("/", file);
+    parts.push(`diff --git a${basePath} b${basePath}`);
+    parts.push("index 0000000..1111111 100644");
+    parts.push(`--- a${basePath}`);
+    parts.push(`+++ b${basePath}`);
+    const linesPerFile = Math.max(1, Math.floor(linesAdded / files.length));
+    parts.push(...buildFileChange(spec, file, linesPerFile));
+  }
+  return parts.join("\n");
+}
+function createVariantResult(spec) {
+  const files = spec.files && spec.files.length > 0 ? spec.files : DEFAULT_FILES;
+  const filesChanged = spec.edgeModifiers?.hasEmptyChanges ? 0 : files.length;
+  const linesAdded = spec.edgeModifiers?.hasEmptyChanges ? 0 : Math.round(spec.completeness / 100 * 120 + 3);
+  const linesRemoved = Math.round(linesAdded * 0.5);
+  const diff = buildDiff(spec, files, linesAdded);
+  const exitCode = spec.edgeModifiers?.hasTestFailures ? 1 : 0;
+  const testStatus = spec.edgeModifiers?.hasTestFailures ? "failed" : spec.edgeModifiers?.isPlanningOnly || spec.edgeModifiers?.isDocsOnly || spec.edgeModifiers?.docOnlyInCodeFiles ? "not_run" : "passed";
+  const testMetrics = testStatus === "not_run" ? { totalTests: 0, passedTests: 0, failedTests: 0, passRate: 0 } : (() => {
+    const passRate = testStatus === "passed" ? 100 : clampScore(spec.correctness);
+    const totalTests = 100;
+    const passedTests = Math.round(passRate / 100 * totalTests);
+    const failedTests = Math.max(0, totalTests - passedTests);
+    return { totalTests, passedTests, failedTests, passRate };
+  })();
+  const durationMs = spec.durationMs ?? 12e3;
+  const success = !spec.edgeModifiers?.hasTestFailures && !spec.edgeModifiers?.hasSyntaxErrors;
+  const isPlanningIntent = spec.edgeModifiers?.isPlanningOnly ?? false;
+  const result = {
+    stdout: diff,
+    stderr: spec.edgeModifiers?.hasSyntaxErrors ? "SyntaxError: Unexpected token" : "",
+    exitCode
+  };
+  return {
+    variant: spec.id,
+    provider: spec.provider,
+    strategy: spec.variantStrategy,
+    executionMode: spec.executionMode ?? "local",
+    success,
+    testStatus,
+    testMetrics,
+    result,
+    duration: Math.max(1, Math.round(durationMs / 1e3)),
+    executionDurationMs: durationMs,
+    completeness: clampScore(spec.completeness),
+    gitMetrics: {
+      filesChanged,
+      linesAdded,
+      linesDeleted: linesRemoved,
+      source: "worktree"
+    },
+    worktreeDiff: diff,
+    output: diff,
+    filesChanged,
+    linesAdded,
+    linesRemoved,
+    emptyChanges: spec.edgeModifiers?.hasEmptyChanges,
+    executionCategory: isPlanningIntent ? "analysis" : "edit",
+    executionIntent: isPlanningIntent ? "analysis" : "code",
+    promptHash: spec.id,
+    promptLength: diff.length,
+    evaluationRubric: {
+      rubricVersion: "simulation",
+      editMode: isPlanningIntent ? "analysis" : "edit",
+      metadata: {
+        scenario: spec.description ?? spec.id,
+        synthetic: {
+          id: spec.id,
+          variantLabel: spec.variantLabel,
+          variantStrategy: spec.variantStrategy,
+          provider: spec.provider,
+          executionMode: spec.executionMode ?? "local",
+          outcomeType: spec.outcomeType ?? (success ? "success" : "failure"),
+          codeQuality: clampScore(spec.codeQuality),
+          correctness: clampScore(spec.correctness),
+          completeness: clampScore(spec.completeness),
+          innovation: clampScore(spec.innovation),
+          files,
+          edgeModifiers: spec.edgeModifiers ?? {}
+        }
+      }
+    },
+    analysisCompletenessSource: spec.edgeModifiers?.isPlanningOnly ? "empty" : "provider"
+  };
+}
+
+// scripts/simulation/ground-truth.ts
+var clamp2 = (value) => Math.max(0, Math.min(100, value));
+function semanticTaskFit(spec) {
+  const base = spec.completeness * 0.85 + spec.correctness * 0.15;
+  return clamp2(base);
+}
+function functionalCorrectness(spec) {
+  const base = spec.correctness;
+  return clamp2(base);
+}
+function maintainability(spec) {
+  const base = spec.codeQuality * 0.65 + spec.innovation * 0.35;
+  return clamp2(base);
+}
+function changeDiscipline(spec) {
+  const base = 100 - spec.completeness * 0.3 + spec.codeQuality * 0.2;
+  return clamp2(base);
+}
+function strategyScore(spec) {
+  return clamp2(spec.codeQuality * 0.6 + spec.innovation * 0.4);
+}
+function applyCommonCaps(spec, score, constraints, scoreLabel) {
+  if (spec.edgeModifiers?.isPlanningOnly) {
+    constraints.push({
+      type: "planningOnly",
+      reason: `${spec.id} is planning-only, applying planning cap (${scoreLabel})`
+    });
+    score = Math.min(score, 40);
+  }
+  if (spec.edgeModifiers?.hasTestFailures) {
+    constraints.push({
+      type: "testsFailed",
+      reason: `${spec.id} exercise failed tests (${scoreLabel})`
+    });
+    score = Math.min(score, 50);
+  }
+  if (spec.edgeModifiers?.hasSyntaxErrors) {
+    constraints.push({
+      type: "syntaxErrors",
+      reason: `${spec.id} contains syntax errors (${scoreLabel})`
+    });
+    score = Math.min(score, 40);
+  }
+  if (spec.edgeModifiers?.hasEmptyChanges) {
+    constraints.push({
+      type: "emptyChanges",
+      reason: `${spec.id} produced no file changes (${scoreLabel})`
+    });
+    score = Math.min(score, 10);
+  }
+  if (spec.edgeModifiers?.isDocsOnly) {
+    constraints.push({
+      type: "docsOnly",
+      reason: `${spec.id} touched docs-only paths (${scoreLabel})`
+    });
+    score = Math.min(score, 60);
+  }
+  if (spec.edgeModifiers?.hasOrphanedTestImports) {
+    constraints.push({
+      type: "orphanedTestImports",
+      reason: `${spec.id} includes orphaned test relative imports (${scoreLabel})`
+    });
+    score = Math.min(score, 60);
+  }
+  if (spec.edgeModifiers?.isTestsOnly) {
+    constraints.push({
+      type: "testsOnly",
+      reason: `${spec.id} edits only touch test files (${scoreLabel})`
+    });
+    score = Math.min(score, 60);
+  }
+  return clamp2(score);
+}
+function applyLegacyCaps(spec, composites, constraints) {
+  const { semanticTaskFit: semanticTaskFit2, functionalCorrectness: functionalCorrectness2, maintainability: maintainability2, changeDiscipline: changeDiscipline2 } = composites;
+  const score = 0.45 * semanticTaskFit2 + 0.35 * functionalCorrectness2 + 0.15 * maintainability2 + 0.05 * changeDiscipline2;
+  return applyCommonCaps(spec, score, constraints, "legacy");
+}
+function hybridQuality(spec) {
+  return clamp2(spec.codeQuality * 0.8 + spec.innovation * 0.2);
+}
+function hybridDelivery(spec) {
+  return clamp2(spec.completeness);
+}
+function hybridCorrectness(spec) {
+  return clamp2(spec.correctness);
+}
+function isCorrectnessFailure(spec) {
+  return Boolean(spec.edgeModifiers?.hasTestFailures || spec.edgeModifiers?.hasSyntaxErrors);
+}
+function isLikelyCorrectVariant(spec) {
+  return !isCorrectnessFailure(spec) && hybridCorrectness(spec) >= 70;
+}
+function computeHybridGroundTruth(specs) {
+  const constraints = [];
+  const expectedScores = {};
+  for (const spec of specs) {
+    const score = 0.4 * hybridCorrectness(spec) + 0.35 * hybridQuality(spec) + 0.25 * hybridDelivery(spec);
+    expectedScores[spec.id] = applyCommonCaps(spec, score, constraints, "hybrid_policy");
+  }
+  const bestCorrectCandidate = specs.filter(isLikelyCorrectVariant).sort(
+    (a, b) => (expectedScores[b.id] ?? 0) - (expectedScores[a.id] ?? 0) || a.id.localeCompare(b.id)
+  )[0];
+  if (bestCorrectCandidate) {
+    const bestCorrectScore = expectedScores[bestCorrectCandidate.id] ?? 0;
+    for (const spec of specs) {
+      if (!isCorrectnessFailure(spec)) continue;
+      const current = expectedScores[spec.id] ?? 0;
+      if (current >= bestCorrectScore) {
+        constraints.push({
+          type: "correctnessDominance",
+          reason: `${spec.id} capped below ${bestCorrectCandidate.id} due to correctness-dominance (hybrid_policy)`
+        });
+        expectedScores[spec.id] = clamp2(Math.max(0, bestCorrectScore - 0.1));
+      }
+    }
+  }
+  const ranked = [...specs].sort(
+    (a, b) => (expectedScores[b.id] ?? 0) - (expectedScores[a.id] ?? 0) || a.id.localeCompare(b.id)
+  ).map((spec) => spec.id);
+  const expectedConfidence = computeExpectedConfidence(specs, expectedScores);
+  return {
+    expectedRanking: ranked,
+    expectedWinner: ranked[0] ?? specs[0]?.id ?? "unknown",
+    expectedScores,
+    constraints,
+    expectedConfidence
+  };
+}
+function computeExpectedConfidence(specs, scores) {
+  const sorted = [...specs].sort(
+    (a, b) => (scores[b.id] ?? 0) - (scores[a.id] ?? 0) || a.id.localeCompare(b.id)
+  );
+  const confidence = {};
+  if (sorted.length === 0) return confidence;
+  const topScore = scores[sorted[0]?.id ?? ""] ?? 0;
+  const runnerUpScore = sorted.length > 1 ? scores[sorted[1]?.id ?? ""] ?? 0 : 0;
+  const margin = topScore - runnerUpScore;
+  for (const spec of sorted) {
+    const score = scores[spec.id] ?? 0;
+    const distFromTop = topScore - score;
+    if (distFromTop === 0) {
+      if (margin > 15) confidence[spec.id] = 0.9;
+      else if (margin > 5) confidence[spec.id] = 0.85;
+      else if (margin > 3) confidence[spec.id] = 0.65;
+      else if (margin > 1) confidence[spec.id] = 0.5;
+      else confidence[spec.id] = 0.45;
+    } else {
+      confidence[spec.id] = clamp2(Math.max(15, 50 - distFromTop * 0.8)) / 100;
+    }
+  }
+  return confidence;
+}
+function calculateGroundTruth(specs) {
+  const constraints = [];
+  const expectedScores = {};
+  const expectedStrategyScores = {};
+  const expectedCategoryScores = {};
+  for (const spec of specs) {
+    const categories = {
+      semanticTaskFit: semanticTaskFit(spec),
+      functionalCorrectness: functionalCorrectness(spec),
+      maintainability: maintainability(spec),
+      changeDiscipline: changeDiscipline(spec)
+    };
+    expectedCategoryScores[spec.id] = categories;
+    expectedStrategyScores[spec.id] = strategyScore(spec);
+    expectedScores[spec.id] = applyLegacyCaps(spec, categories, constraints);
+  }
+  const STRONG_CORRECTNESS_GAP = 25;
+  for (let i = 0; i < specs.length; i++) {
+    const specA = specs[i];
+    if (!specA) continue;
+    const scoreA = expectedScores[specA.id] ?? 0;
+    const correctnessA = functionalCorrectness(specA);
+    for (let j = i + 1; j < specs.length; j++) {
+      const specB = specs[j];
+      if (!specB) continue;
+      const scoreB = expectedScores[specB.id] ?? 0;
+      const correctnessB = functionalCorrectness(specB);
+      if (correctnessA >= correctnessB + STRONG_CORRECTNESS_GAP && scoreB > scoreA) {
+        constraints.push({
+          type: "correctnessDominance",
+          reason: `${specB.id} (FC=${correctnessB.toFixed(1)}) capped below ${specA.id} (FC=${correctnessA.toFixed(1)}) due to strong correctness gap (legacy)`
+        });
+        expectedScores[specB.id] = clamp2(Math.max(0, scoreA - 0.1));
+      } else if (correctnessB >= correctnessA + STRONG_CORRECTNESS_GAP && scoreA > scoreB) {
+        constraints.push({
+          type: "correctnessDominance",
+          reason: `${specA.id} (FC=${correctnessA.toFixed(1)}) capped below ${specB.id} (FC=${correctnessB.toFixed(1)}) due to strong correctness gap (legacy)`
+        });
+        expectedScores[specA.id] = clamp2(Math.max(0, scoreB - 0.1));
+      }
+    }
+  }
+  const ranked = [...specs].sort(
+    (a, b) => (expectedScores[b.id] ?? 0) - (expectedScores[a.id] ?? 0) || a.id.localeCompare(b.id)
+  ).map((spec) => spec.id);
+  const expectedConfidence = computeExpectedConfidence(specs, expectedScores);
+  return {
+    expectedRanking: ranked,
+    expectedWinner: ranked[0] ?? specs[0]?.id ?? "unknown",
+    expectedScores,
+    expectedStrategyScores,
+    expectedCategoryScores,
+    constraints,
+    expectedConfidence,
+    policyModels: {
+      hybrid: computeHybridGroundTruth(specs)
+    }
+  };
+}
+
+// scripts/simulation/runner.ts
+async function safeEvaluate(evaluator, variants, prompt, options, label) {
+  try {
+    return await evaluator(variants, prompt, options);
+  } catch (error) {
+    console.warn(`[simulation] ${label} judge failed:`, error);
+    return void 0;
+  }
+}
+async function runScenario(scenario, config, context) {
+  const variants = scenario.variants.map(createVariantResult);
+  const groundTruth = calculateGroundTruth(scenario.variants);
+  const prompt = scenario.prompt ?? config.prompt;
+  const options = {
+    timeoutSeconds: 120,
+    // Simulation benchmarks should be strict/single-attempt for signal purity and runtime control.
+    maxAttempts: 1
+  };
+  if (config.dryRun) {
+    const multiLensResult2 = simulateJudgeSynthesisResult("multiLens", variants, prompt);
+    const hybridResult = simulateJudgeSynthesisResult("hybrid", variants, prompt);
+    return {
+      scenario,
+      variants,
+      groundTruth,
+      multiLensResult: multiLensResult2,
+      hybridResult,
+      runDir: context.runDir
+    };
+  }
+  const multiLensJudge = new MultiLensJudge({ telemetryLogger: context.telemetryLogger });
+  const multiLensResult = await safeEvaluate(
+    multiLensJudge.evaluate.bind(multiLensJudge),
+    variants,
+    prompt,
+    options,
+    "multiLens"
+  );
+  return {
+    scenario,
+    variants,
+    groundTruth,
+    multiLensResult,
+    runDir: context.runDir
+  };
+}
+
+// scripts/simulation/scenarios/edge-cases.ts
+var createSpec = (baseId, overrides) => ({
+  id: `${baseId}-${overrides.variantStrategy ?? "variant"}`,
+  variantLabel: overrides.variantLabel ?? overrides.variantStrategy ?? "variant",
+  variantStrategy: overrides.variantStrategy ?? "conservative",
+  provider: overrides.provider ?? "claude",
+  codeQuality: overrides.codeQuality ?? 65,
+  correctness: overrides.correctness ?? 70,
+  completeness: overrides.completeness ?? 70,
+  innovation: overrides.innovation ?? 50,
+  executionMode: overrides.executionMode ?? "local",
+  durationMs: overrides.durationMs ?? 12e3,
+  files: overrides.files ?? ["src/lib/main.ts"],
+  description: overrides.description,
+  edgeModifiers: overrides.edgeModifiers,
+  outcomeType: overrides.outcomeType
+});
+var EDGE_CASE_SCENARIOS = [
+  {
+    id: "close-scores",
+    description: "Variants with near-identical metrics to test tie handling",
+    type: "edge",
+    prompt: "Implement a small feature in FILE: src/lib/main.ts. Keep changes minimal but complete, and ensure tests pass.",
+    variants: [
+      createSpec("close", {
+        variantStrategy: "stable",
+        codeQuality: 75,
+        completeness: 78,
+        correctness: 79,
+        innovation: 69,
+        durationMs: 8e3
+      }),
+      createSpec("close", {
+        variantStrategy: "innovative",
+        codeQuality: 77,
+        completeness: 77,
+        correctness: 78,
+        innovation: 72,
+        durationMs: 9e3
+      }),
+      createSpec("close", {
+        variantStrategy: "balanced",
+        codeQuality: 76,
+        completeness: 79,
+        correctness: 77,
+        innovation: 70,
+        durationMs: 1e4
+      })
+    ]
+  },
+  {
+    id: "tie-breaker",
+    description: "Scores tie after caps to exercise deterministic ordering",
+    type: "edge",
+    prompt: "Refactor FILE: src/lib/main.ts for readability without changing behavior. Keep changes minimal and well-scoped.",
+    variants: [
+      createSpec("tie", {
+        variantStrategy: "alpha",
+        codeQuality: 80,
+        correctness: 80,
+        completeness: 70,
+        innovation: 60
+      }),
+      createSpec("tie", {
+        variantStrategy: "beta",
+        codeQuality: 80,
+        correctness: 80,
+        completeness: 70,
+        innovation: 60
+      })
+    ]
+  },
+  {
+    id: "planning-only",
+    description: "One variant only produces a plan (no code)",
+    type: "edge",
+    prompt: "Implement the requested change in code (not just a plan). Modify FILE: src/lib/main.ts and ensure tests pass.",
+    variants: [
+      createSpec("plan", {
+        variantStrategy: "planner",
+        outcomeType: "planning-only",
+        edgeModifiers: { isPlanningOnly: true, hasEmptyChanges: true },
+        files: [],
+        codeQuality: 30,
+        correctness: 20,
+        completeness: 10,
+        innovation: 40
+      }),
+      createSpec("plan", {
+        variantStrategy: "executor",
+        codeQuality: 70,
+        correctness: 85,
+        completeness: 80,
+        innovation: 60
+      })
+    ]
+  },
+  {
+    id: "empty-result",
+    description: "Provider reported success but made zero edits",
+    type: "edge",
+    prompt: "Fix the bug in FILE: src/lib/main.ts and ensure tests pass.",
+    variants: [
+      createSpec("empty", {
+        variantStrategy: "silent",
+        edgeModifiers: { hasEmptyChanges: true },
+        codeQuality: 10,
+        correctness: 10,
+        completeness: 0,
+        innovation: 5
+      }),
+      createSpec("empty", {
+        variantStrategy: "no-op",
+        codeQuality: 50,
+        correctness: 60,
+        completeness: 65,
+        innovation: 45
+      })
+    ]
+  },
+  {
+    id: "docs-only",
+    description: "Variants that only touch documentation",
+    type: "edge",
+    prompt: "Update documentation in FILE: docs/guide.md. Do not change runtime code. Keep the update accurate and concise.",
+    variants: [
+      createSpec("docs", {
+        variantStrategy: "docs",
+        edgeModifiers: { isDocsOnly: true },
+        files: ["docs/guide.md"],
+        codeQuality: 65,
+        correctness: 55,
+        completeness: 70,
+        innovation: 30
+      }),
+      createSpec("docs", {
+        variantStrategy: "docs-plus",
+        edgeModifiers: { isDocsOnly: true },
+        files: ["docs/reference.md"],
+        codeQuality: 70,
+        correctness: 58,
+        completeness: 72,
+        innovation: 35
+      })
+    ]
+  },
+  {
+    id: "high-quality-failed-tests",
+    description: "High code quality but failing tests",
+    type: "edge",
+    prompt: "Implement the change in FILE: src/lib/main.ts and ensure tests pass. Correctness is more important than novelty.",
+    variants: [
+      createSpec("hqfail", {
+        variantStrategy: "alpha",
+        edgeModifiers: { hasTestFailures: true },
+        codeQuality: 90,
+        correctness: 45,
+        completeness: 80,
+        innovation: 85
+      }),
+      createSpec("hqfail", {
+        variantStrategy: "beta",
+        codeQuality: 85,
+        correctness: 70,
+        completeness: 85,
+        innovation: 65
+      })
+    ]
+  },
+  {
+    id: "orphaned-test-imports",
+    description: "Tests introduce orphaned relative imports (incomplete scaffolding)",
+    type: "edge",
+    prompt: "Add feature foo",
+    variants: [
+      createSpec("orphaned", {
+        variantStrategy: "scaffold",
+        files: ["src/lib/main.test.ts"],
+        edgeModifiers: { addsExecutableLines: true, hasOrphanedTestImports: true },
+        codeQuality: 92,
+        correctness: 85,
+        completeness: 88,
+        innovation: 75
+      }),
+      createSpec("orphaned", {
+        variantStrategy: "implemented",
+        files: ["src/lib/main.ts"],
+        edgeModifiers: { addsExecutableLines: true },
+        codeQuality: 82,
+        correctness: 90,
+        completeness: 80,
+        innovation: 60
+      })
+    ]
+  },
+  {
+    id: "all-fail",
+    description: "Every variant fails (syntactic or test issues)",
+    type: "edge",
+    prompt: "Fix the code in FILE: src/lib/main.ts and ensure it runs and tests pass.",
+    variants: [
+      createSpec("fail", {
+        variantStrategy: "syntax",
+        edgeModifiers: { hasSyntaxErrors: true },
+        codeQuality: 30,
+        correctness: 40,
+        completeness: 30,
+        innovation: 20
+      }),
+      createSpec("fail", {
+        variantStrategy: "tests",
+        edgeModifiers: { hasTestFailures: true },
+        codeQuality: 40,
+        correctness: 35,
+        completeness: 45,
+        innovation: 25
+      })
+    ]
+  },
+  {
+    id: "single-variant",
+    description: "Only one variant is available for evaluation",
+    type: "edge",
+    prompt: "Implement the change in FILE: src/lib/main.ts. Ensure code is correct.",
+    variants: [
+      createSpec("single", {
+        variantStrategy: "solo",
+        codeQuality: 70,
+        correctness: 75,
+        completeness: 80,
+        innovation: 60
+      })
+    ]
+  },
+  {
+    id: "file-target-violation",
+    description: "Variants violate FILE: targets to test caps",
+    type: "edge",
+    prompt: "Make a change ONLY in FILE: src/lib/main.ts. Do not modify other files. Keep changes minimal.",
+    variants: [
+      createSpec("files", {
+        variantStrategy: "misaligned",
+        files: ["src/unused.ts"],
+        codeQuality: 60,
+        correctness: 80,
+        completeness: 65,
+        innovation: 55
+      }),
+      createSpec("files", {
+        variantStrategy: "aligned",
+        files: ["src/lib/main.ts"],
+        codeQuality: 65,
+        correctness: 82,
+        completeness: 70,
+        innovation: 58
+      })
+    ]
+  },
+  {
+    id: "long-duration",
+    description: "Variants run for an unusually long time",
+    type: "edge",
+    prompt: "Implement the change efficiently in FILE: src/lib/main.ts. Avoid long-running operations and keep runtime fast.",
+    variants: [
+      createSpec("slow", {
+        variantStrategy: "timeout",
+        durationMs: 18e4,
+        codeQuality: 75,
+        correctness: 70,
+        completeness: 72,
+        innovation: 60
+      }),
+      createSpec("slow", {
+        variantStrategy: "steady",
+        durationMs: 12e4,
+        codeQuality: 78,
+        correctness: 75,
+        completeness: 76,
+        innovation: 65
+      })
+    ]
+  },
+  {
+    id: "conflicting-tradeoffs",
+    description: "One variant prioritizes completeness, another correctness",
+    type: "edge",
+    prompt: "Implement the change in FILE: src/lib/main.ts. Prioritize correctness and safety over breadth; tests should pass.",
+    variants: [
+      createSpec("tradeoff", {
+        variantStrategy: "completeness",
+        codeQuality: 65,
+        correctness: 60,
+        completeness: 90,
+        innovation: 50
+      }),
+      createSpec("tradeoff", {
+        variantStrategy: "correctness",
+        codeQuality: 60,
+        correctness: 92,
+        completeness: 55,
+        innovation: 45
+      })
+    ]
+  },
+  {
+    id: "high-innovation-low-correctness",
+    description: "Innovative approaches that may sacrifice correctness",
+    type: "edge",
+    prompt: "Implement the change in FILE: src/lib/main.ts. Prefer correct, maintainable solutions over cleverness. Tests should pass.",
+    variants: [
+      createSpec("innovate", {
+        variantStrategy: "creative",
+        codeQuality: 85,
+        correctness: 50,
+        completeness: 65,
+        innovation: 95
+      }),
+      createSpec("innovate", {
+        variantStrategy: "safe",
+        codeQuality: 70,
+        correctness: 85,
+        completeness: 80,
+        innovation: 55
+      })
+    ]
+  },
+  {
+    id: "stable-high-quality",
+    description: "Variants that maximize maintainability and change discipline",
+    type: "edge",
+    prompt: "Refactor FILE: src/lib/main.ts for maintainability. Preserve behavior; avoid unnecessary changes.",
+    variants: [
+      createSpec("stable", {
+        variantStrategy: "refined",
+        codeQuality: 90,
+        correctness: 88,
+        completeness: 85,
+        innovation: 60
+      }),
+      createSpec("stable", {
+        variantStrategy: "polished",
+        codeQuality: 88,
+        correctness: 90,
+        completeness: 80,
+        innovation: 65
+      })
+    ]
+  },
+  {
+    id: "partial-success",
+    description: "One variant produces half the required changes",
+    type: "edge",
+    prompt: "Implement the full set of requested changes in FILE: src/lib/main.ts. Completeness matters; ensure tests pass.",
+    variants: [
+      createSpec("partial", {
+        variantStrategy: "half",
+        codeQuality: 70,
+        correctness: 60,
+        completeness: 40,
+        innovation: 50
+      }),
+      createSpec("partial", {
+        variantStrategy: "complete",
+        codeQuality: 75,
+        correctness: 70,
+        completeness: 85,
+        innovation: 55
+      })
+    ]
+  },
+  {
+    id: "planning-intent",
+    description: "Prompt suggests planning, but edit exists",
+    type: "edge",
+    prompt: "Create a plan for the change. Do not modify code. Explain steps clearly and comprehensively.",
+    variants: [
+      createSpec("intent", {
+        variantStrategy: "plan",
+        edgeModifiers: { isPlanningOnly: true },
+        codeQuality: 50,
+        correctness: 55,
+        completeness: 40,
+        innovation: 45
+      }),
+      createSpec("intent", {
+        variantStrategy: "execute",
+        codeQuality: 75,
+        correctness: 80,
+        completeness: 82,
+        innovation: 60
+      })
+    ]
+  },
+  {
+    id: "missing-files",
+    description: "Variants touched no tracked files (workspace empty)",
+    type: "edge",
+    prompt: "Implement the change in FILE: src/lib/main.ts. Ensure code is updated.",
+    variants: [
+      createSpec("missing", {
+        variantStrategy: "ghost",
+        edgeModifiers: { hasEmptyChanges: true },
+        codeQuality: 20,
+        correctness: 30,
+        completeness: 10,
+        innovation: 20
+      }),
+      createSpec("missing", {
+        variantStrategy: "minimal",
+        codeQuality: 55,
+        correctness: 60,
+        completeness: 45,
+        innovation: 35
+      })
+    ]
+  },
+  {
+    id: "multiple-weak",
+    description: "Many low-quality variants force judge to pick the least bad",
+    type: "edge",
+    prompt: "Fix the bug in FILE: src/lib/main.ts. Even among weak attempts, prefer the most correct and complete result.",
+    variants: [
+      createSpec("weak", {
+        variantStrategy: "alpha",
+        codeQuality: 30,
+        correctness: 40,
+        completeness: 35,
+        innovation: 25
+      }),
+      createSpec("weak", {
+        variantStrategy: "beta",
+        codeQuality: 32,
+        correctness: 45,
+        completeness: 38,
+        innovation: 28
+      }),
+      createSpec("weak", {
+        variantStrategy: "gamma",
+        codeQuality: 29,
+        correctness: 42,
+        completeness: 34,
+        innovation: 24
+      })
+    ]
+  },
+  {
+    id: "strong-tests-low-quality",
+    description: "Variants with perfect pass rates but mediocre code quality",
+    type: "edge",
+    prompt: "Implement the change in FILE: src/lib/main.ts. Correctness matters, but prefer maintainable production code. Tests should pass.",
+    variants: [
+      createSpec("tests", {
+        variantStrategy: "test-first",
+        codeQuality: 50,
+        correctness: 95,
+        completeness: 70,
+        innovation: 45
+      }),
+      createSpec("tests", {
+        variantStrategy: "code-first",
+        codeQuality: 65,
+        correctness: 88,
+        completeness: 75,
+        innovation: 55
+      })
+    ]
+  },
+  {
+    id: "tests-only-implementation",
+    description: "Tests-only changes should not beat real implementation work on feature tasks",
+    type: "edge",
+    prompt: "Implement the feature in FILE: src/lib/main.ts. Ensure tests pass.",
+    variants: [
+      createSpec("tests-only", {
+        variantStrategy: "tests-only",
+        files: ["src/lib/main.test.ts"],
+        edgeModifiers: { addsExecutableLines: true, isTestsOnly: true },
+        // Make this variant look tempting on correctness, but it should be capped for being tests-only.
+        codeQuality: 70,
+        correctness: 95,
+        completeness: 65,
+        innovation: 55
+      }),
+      createSpec("tests-only", {
+        variantStrategy: "implemented",
+        files: ["src/lib/main.ts", "src/lib/main.test.ts"],
+        edgeModifiers: { addsExecutableLines: true },
+        codeQuality: 72,
+        correctness: 90,
+        completeness: 80,
+        innovation: 55
+      })
+    ]
+  },
+  {
+    id: "docs-tests",
+    description: "Combination of documentation work and test scaffolding",
+    type: "edge",
+    prompt: "Update documentation in FILE: docs/guide.md and add a unit test in FILE: src/lib/main.test.ts. Ensure tests pass.",
+    variants: [
+      createSpec("docs-tests", {
+        variantStrategy: "docs",
+        edgeModifiers: { isDocsOnly: true },
+        files: ["docs/guide.md"],
+        codeQuality: 60,
+        correctness: 60,
+        completeness: 60,
+        innovation: 40
+      }),
+      createSpec("docs-tests", {
+        variantStrategy: "tests",
+        files: ["src/lib/main.ts", "src/lib/main.test.ts"],
+        edgeModifiers: { addsExecutableLines: true },
+        codeQuality: 70,
+        correctness: 90,
+        completeness: 65,
+        innovation: 50
+      })
+    ]
+  },
+  {
+    id: "jsdoc-only-codefile",
+    description: "Doc-only (JSDoc/comment) changes inside a code file should not be penalized as no-op for doc-intent prompts",
+    type: "edge",
+    prompt: "Add JSDoc/TSDoc comments ONLY (no runtime logic changes) in FILE: src/lib/main.ts. Keep changes limited to comments/docs.",
+    variants: [
+      createSpec("jsdoc", {
+        variantStrategy: "docs",
+        files: ["src/lib/main.ts"],
+        edgeModifiers: { docOnlyInCodeFiles: true },
+        codeQuality: 75,
+        correctness: 80,
+        completeness: 75,
+        innovation: 30
+      }),
+      createSpec("jsdoc", {
+        variantStrategy: "code",
+        files: ["src/lib/main.ts"],
+        edgeModifiers: { addsExecutableLines: true },
+        codeQuality: 65,
+        correctness: 78,
+        completeness: 78,
+        innovation: 50
+      })
+    ]
+  },
+  {
+    id: "jsdoc-only-vs-noop",
+    description: "Doc-only in code file vs empty/no-op result",
+    type: "edge",
+    prompt: "Add JSDoc comments ONLY in FILE: src/lib/main.ts (no runtime logic changes). Do not add new files.",
+    variants: [
+      createSpec("jsdoc-noop", {
+        variantStrategy: "docs",
+        files: ["src/lib/main.ts"],
+        edgeModifiers: { docOnlyInCodeFiles: true },
+        codeQuality: 70,
+        correctness: 75,
+        completeness: 70,
+        innovation: 25
+      }),
+      createSpec("jsdoc-noop", {
+        variantStrategy: "silent",
+        files: ["src/lib/main.ts"],
+        edgeModifiers: { hasEmptyChanges: true },
+        codeQuality: 60,
+        correctness: 60,
+        completeness: 60,
+        innovation: 20
+      })
+    ]
+  },
+  {
+    id: "docs-and-tests-required",
+    description: "Prompt requests both docs and tests; tests variant should win over docs-only",
+    type: "edge",
+    prompt: "Update documentation and add tests for the change. Add a new unit test file and ensure tests pass.",
+    variants: [
+      createSpec("docs-tests-req", {
+        variantStrategy: "docs",
+        files: ["docs/guide.md"],
+        edgeModifiers: { isDocsOnly: true },
+        codeQuality: 70,
+        correctness: 60,
+        completeness: 75,
+        innovation: 35
+      }),
+      createSpec("docs-tests-req", {
+        variantStrategy: "tests",
+        files: ["src/lib/main.ts", "tests/unit/main.test.ts"],
+        edgeModifiers: { addsExecutableLines: true },
+        codeQuality: 68,
+        correctness: 85,
+        completeness: 78,
+        innovation: 45
+      })
+    ]
+  },
+  {
+    id: "syntax-error",
+    description: "Syntax problems limit functional correctness",
+    type: "edge",
+    prompt: "Fix the syntax error in FILE: src/lib/main.ts and ensure code runs.",
+    variants: [
+      createSpec("syntax", {
+        variantStrategy: "broken",
+        edgeModifiers: { hasSyntaxErrors: true },
+        codeQuality: 40,
+        correctness: 30,
+        completeness: 45,
+        innovation: 35
+      }),
+      createSpec("syntax", {
+        variantStrategy: "fixed",
+        codeQuality: 70,
+        correctness: 75,
+        completeness: 78,
+        innovation: 50
+      })
+    ]
+  },
+  {
+    id: "mixed-signals",
+    description: "Inconsistent data with high innovation but partial success",
+    type: "edge",
+    prompt: "Implement the change in FILE: src/lib/main.ts. Prefer correct, practical solutions over novelty; ensure tests pass.",
+    variants: [
+      createSpec("mixed", {
+        variantStrategy: "creative",
+        codeQuality: 85,
+        correctness: 55,
+        completeness: 60,
+        innovation: 90
+      }),
+      createSpec("mixed", {
+        variantStrategy: "practical",
+        codeQuality: 65,
+        correctness: 80,
+        completeness: 75,
+        innovation: 55
+      })
+    ]
+  },
+  {
+    id: "spread-out",
+    description: "Variants spaced across low/high metrics to test spread",
+    type: "edge",
+    prompt: "Implement the change in FILE: src/lib/main.ts. Prefer the most complete and correct implementation; tests should pass.",
+    variants: [
+      createSpec("spread", {
+        variantStrategy: "low",
+        codeQuality: 35,
+        correctness: 40,
+        completeness: 45,
+        innovation: 30
+      }),
+      createSpec("spread", {
+        variantStrategy: "mid",
+        codeQuality: 60,
+        correctness: 65,
+        completeness: 60,
+        innovation: 55
+      }),
+      createSpec("spread", {
+        variantStrategy: "high",
+        codeQuality: 88,
+        correctness: 90,
+        completeness: 85,
+        innovation: 70
+      })
+    ]
+  }
+];
+
+// scripts/simulation/types.ts
+import fs from "fs";
+import os from "os";
+import path3 from "path";
+var SIMULATION_ROOT = process.env.POETIC_SIMULATION_ROOT ?? path3.join(os.tmpdir(), "poetic-simulation");
+function createIsolatedRun(runId) {
+  const runDir = path3.join(SIMULATION_ROOT, runId);
+  fs.mkdirSync(runDir, { recursive: true });
+  const telemetryLogger = TelemetryLogger.getInstance({ poeticDir: runDir });
+  return { runDir, telemetryLogger };
+}
+
+export {
+  analyzeSimulationResults,
+  runScenario,
+  EDGE_CASE_SCENARIOS,
+  createIsolatedRun
+};
+//# sourceMappingURL=chunk-3VABAKT2.js.map