@tangle-network/agent-eval 0.123.5 → 0.123.7

package/dist/{chunk-LT4J7ULK.js → chunk-VPDOSN3L.js}

@@ -15,7 +15,7 @@ import {
   runImprovementLoop,
   surfaceContentHash,
   surfaceHash
-} from "./chunk-SUN7QLPB.js";
+} from "./chunk-KKPPFIDS.js";
 import {
   SearchLedgerConflictError,
   SearchLedgerError,
@@ -2405,1427 +2405,1875 @@ function sequentialDecide(options = {}) {
   return decide;
 }
 
-// src/campaign/grounded-reflection.ts
-function rolloutArgumentDiff(rollouts, opts = {}) {
-  const passThreshold = opts.passThreshold ?? 1;
-  const maxValues = opts.maxValuesPerField ?? 4;
-  const collect = (pass) => {
-    const byField = /* @__PURE__ */ new Map();
-    for (const r of rollouts) {
-      if (pass !== r.score >= passThreshold) continue;
-      for (const c of r.calls) {
-        for (const [k, v] of Object.entries(c.args)) {
-          const set = byField.get(k) ?? /* @__PURE__ */ new Set();
-          set.add(String(v));
-          byField.set(k, set);
-        }
-      }
+// src/campaign/gepa-optimization-method.ts
+import { spawn } from "child_process";
+import { randomBytes } from "crypto";
+import { mkdir, mkdtemp, readFile, rm, writeFile } from "fs/promises";
+import { createServer } from "http";
+import { tmpdir } from "os";
+import { join as join2 } from "path";
+
+// src/campaign/presets/compare-optimization-methods.ts
+import { randomUUID } from "crypto";
+async function compareOptimizationMethods(opts) {
+  assertOptimizationMethods(opts.methods);
+  assertComparisonPartitions(opts);
+  const seed = opts.seed ?? 42;
+  const confidence = opts.confidence ?? 0.95;
+  assertConfidence(confidence);
+  const optimizationConcurrency = opts.optimizationConcurrency ?? 1;
+  const comparisonCount = opts.methods.length * (opts.methods.length + 1) / 2;
+  const intervalConfidence = 1 - (1 - confidence) / comparisonCount;
+  const minimumResamples = minimumBootstrapResamples(confidence, comparisonCount);
+  const resamples = opts.resamples ?? Math.max(2e3, minimumResamples);
+  assertComparisonControls(opts, seed, resamples, confidence);
+  const storage = opts.storage ?? fsCampaignStorage();
+  const resolvedRunDir = resolveRunDir(opts.runDir, opts.repo);
+  const testCostPhase = `compareOptimizationMethods:test:${randomUUID()}`;
+  const testCostLedger = opts.costLedger ?? createRunCostLedger({
+    storage,
+    runDir: `${resolvedRunDir}/test/cost`,
+    costCeilingUsd: opts.costCeiling
+  });
+  const scoreOnTest = async (surface, tag) => {
+    const campaign = await runCampaign({
+      ...opts,
+      storage,
+      costLedger: testCostLedger,
+      costPhase: testCostPhase,
+      scenarios: opts.testScenarios.map((scenario) => structuredClone(scenario)),
+      dispatch: (scenario, ctx) => opts.dispatchWithSurface(surface, scenario, ctx),
+      runDir: `${resolvedRunDir}/${tag}`
+    });
+    const byScenario = {};
+    for (const { scenarioId, composite } of campaignBreakdown(campaign).scenarios) {
+      byScenario[scenarioId] = composite;
     }
-    return byField;
-  };
-  const passing = collect(true);
-  const failing = collect(false);
-  const lines = [];
-  for (const field of /* @__PURE__ */ new Set([...passing.keys(), ...failing.keys()])) {
-    const pv = [...passing.get(field) ?? []].slice(0, maxValues);
-    const fv = [...failing.get(field) ?? []].slice(0, maxValues);
-    const render = (vals) => vals.length ? JSON.stringify(vals) : "NOT SET (omitted)";
-    lines.push(`  ${field}: passing runs -> ${render(pv)} | failing runs -> ${render(fv)}`);
-  }
-  const lower = (m) => {
-    const out = /* @__PURE__ */ new Set();
-    for (const vals of m.values()) for (const v of vals) out.add(v.toLowerCase());
-    return out;
-  };
-  return {
-    text: lines.join("\n") || "  (no calls observed)",
-    passingValues: lower(passing),
-    failingValues: lower(failing)
-  };
-}
-function classifyUngroundedLiterals(text, diff) {
-  const ungrounded = /* @__PURE__ */ new Set();
-  for (const m of text.matchAll(/'([a-z][a-z_-]{1,19})'/gi)) {
-    const w = m[1].toLowerCase();
-    if (!diff.passingValues.has(w)) ungrounded.add(w);
-  }
-  const all = [...ungrounded];
-  return {
-    ungrounded: all,
-    harmful: all.filter((w) => diff.failingValues.has(w))
+    return byScenario;
   };
-}
-
-// src/campaign/labeled-store/fs-adapter.ts
-import { createHash as createHash4 } from "crypto";
-import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
-import { join as join2 } from "path";
-var LabeledScenarioStoreError = class extends Error {
-  constructor(code, message) {
-    super(message);
-    this.code = code;
-    this.name = "LabeledScenarioStoreError";
-  }
-  code;
-};
-var FsLabeledScenarioStore = class {
-  constructor(options) {
-    this.options = options;
-    if (!existsSync2(options.root)) mkdirSync(options.root, { recursive: true });
-    this.now = options.now ?? Date.now;
-  }
-  options;
-  now;
-  rateLimits = /* @__PURE__ */ new Map();
-  async observe(write) {
-    this.assertProvenance(write);
-    this.assertRateLimit(write);
-    const record = this.toRecord(write);
-    const path = this.pathForSource(write.source);
-    const line = `${JSON.stringify(record)}
-`;
-    appendLine(path, line);
-  }
-  async sample(args) {
-    if (!args.split) {
-      throw new LabeledScenarioStoreError(
-        "split_required",
-        "sample() requires an explicit `split` (train | test) \u2014 substrate refuses ambiguous reads"
+  const scenarioIds = opts.testScenarios.map((s) => s.id).sort();
+  const align = (byScenario, label) => {
+    const missing = scenarioIds.filter((id) => !(id in byScenario));
+    if (missing.length > 0) {
+      throw new Error(
+        `compareOptimizationMethods: ${label} produced no test score for scenario(s) [${missing.join(
+          ", "
+        )}]. A cell failed or its judges returned nothing. Fix the dispatch or judge; the comparison will not replace missing scores with zero.`
       );
     }
-    if (!args.capturedBefore) {
-      throw new LabeledScenarioStoreError(
-        "capturedBefore_required",
-        "sample() requires an explicit `capturedBefore` timestamp for temporal-split discipline"
+    return scenarioIds.map((id) => byScenario[id]);
+  };
+  const optimized = await mapConcurrent(opts.methods, optimizationConcurrency, async (method) => {
+    const out = await method.optimize(
+      createOptimizationMethodInput(opts, method.name, resolvedRunDir, seed)
+    );
+    assertOptimizationResult(method.name, out);
+    const winnerSurface = structuredClone(out.winnerSurface);
+    return {
+      name: method.name,
+      winnerSurface,
+      cost: out.cost,
+      durationMs: out.durationMs
+    };
+  });
+  const baselineArr = align(await scoreOnTest(opts.baselineSurface, "test/baseline"), "baseline");
+  const testScoresBySurface = /* @__PURE__ */ new Map([[surfaceContentHash(opts.baselineSurface), baselineArr]]);
+  const winners = [];
+  for (const winner of optimized) {
+    const surfaceKey = surfaceContentHash(winner.winnerSurface);
+    let arr = testScoresBySurface.get(surfaceKey);
+    if (!arr) {
+      const byScenario = await scoreOnTest(
+        winner.winnerSurface,
+        `test/methods/${slug(winner.name)}`
       );
+      arr = align(byScenario, `method "${winner.name}"`);
+      testScoresBySurface.set(surfaceKey, arr);
     }
-    const all = [];
-    for (const source of ALL_SOURCES) {
-      if (args.split === "train" && source === "production-trace") {
-        const explicit = sourceFilterContains(args.filter?.source, "production-trace");
-        if (!explicit) continue;
-      }
-      const path = this.pathForSource(source);
-      if (!existsSync2(path)) continue;
-      const lines = readFileSync2(path, "utf8").split("\n").filter(Boolean);
-      for (const line of lines) {
-        let record;
-        try {
-          record = JSON.parse(line);
-        } catch {
-          continue;
-        }
-        if (!matchesFilter(record, args, source)) continue;
-        all.push(record);
-      }
-    }
-    all.sort((a, b) => {
-      if (a.capturedAt !== b.capturedAt) return a.capturedAt.localeCompare(b.capturedAt);
-      return a.recordHash.localeCompare(b.recordHash);
+    winners.push({
+      ...winner,
+      arr
     });
-    return all.slice(0, args.count);
   }
-  async size() {
-    const bySource = {};
-    const byTrust = {
-      unverified: 0,
-      "verified-signal": 0,
-      "human-rated": 0
+  const scores = winners.map((w) => {
+    const boot = pairedBootstrap(baselineArr, w.arr, {
+      seed,
+      resamples,
+      confidence: intervalConfidence,
+      statistic: "mean"
+    });
+    const score = {
+      name: w.name,
+      baselineComposite: mean2(baselineArr),
+      winnerComposite: mean2(w.arr),
+      lift: boot.mean,
+      liftCi: { low: boot.low, high: boot.high },
+      optimizationCost: w.cost,
+      scenarioScores: scenarioIds.map((scenarioId, index) => ({
+        scenarioId,
+        baselineComposite: baselineArr[index],
+        winnerComposite: w.arr[index],
+        lift: w.arr[index] - baselineArr[index]
+      })),
+      winnerSurface: w.winnerSurface,
+      rank: 0
     };
-    let total = 0;
-    for (const source of ALL_SOURCES) {
-      const path = this.pathForSource(source);
-      if (!existsSync2(path)) {
-        bySource[source] = 0;
-        continue;
-      }
-      const lines = readFileSync2(path, "utf8").split("\n").filter(Boolean);
-      bySource[source] = lines.length;
-      total += lines.length;
-      for (const line of lines) {
-        let trust = "unverified";
-        try {
-          trust = JSON.parse(line).labelTrust ?? "unverified";
-        } catch {
-        }
-        byTrust[trust] += 1;
-      }
+    if (w.durationMs !== void 0) score.durationMs = w.durationMs;
+    return score;
+  });
+  scores.sort((a, b) => b.lift - a.lift);
+  for (let start = 0; start < scores.length; ) {
+    let end = start + 1;
+    while (end < scores.length && scores[end].lift === scores[start].lift) end += 1;
+    const tied = scores.slice(start, end);
+    if (tied.every((score) => score.optimizationCost.accountingComplete)) {
+      tied.sort((a, b) => a.optimizationCost.totalCostUsd - b.optimizationCost.totalCostUsd);
+      scores.splice(start, tied.length, ...tied);
     }
-    return { train: total, test: total, bySource, byTrust };
+    start = end;
   }
-  assertProvenance(write) {
-    if (!write.source) {
-      throw new LabeledScenarioStoreError(
-        "missing_source",
-        "LabeledScenarioWrite requires `source`"
-      );
-    }
-    if (!write.sourceVersionHash || write.sourceVersionHash.length === 0) {
-      throw new LabeledScenarioStoreError(
-        "missing_source_version",
-        "LabeledScenarioWrite requires `sourceVersionHash` (git sha or substrate version)"
-      );
+  scores.forEach((s, i) => {
+    s.rank = i + 1;
+  });
+  const best = scores[0];
+  const byName = new Map(winners.map((w) => [w.name, w]));
+  const bestArr = byName.get(best.name).arr;
+  const pairwise = scores.slice(1).map((other) => {
+    const otherArr = byName.get(other.name).arr;
+    const boot = pairedBootstrap(otherArr, bestArr, {
+      seed,
+      resamples,
+      confidence: intervalConfidence,
+      statistic: "mean"
+    });
+    const favored = boot.low > 0 ? best.name : boot.high < 0 ? other.name : "tie";
+    return {
+      a: best.name,
+      b: other.name,
+      deltaMean: boot.mean,
+      low: boot.low,
+      high: boot.high,
+      favored
+    };
+  });
+  const optimizationCost = combineCosts(
+    scores.map((score) => ({ label: `method '${score.name}'`, cost: score.optimizationCost }))
+  );
+  const testCost = costFromLedgerSummary(testCostLedger.summary({ phase: testCostPhase }));
+  const totalCost = combineCosts([
+    { label: "optimization", cost: optimizationCost },
+    { label: "final test", cost: testCost }
+  ]);
+  return {
+    scores,
+    best,
+    pairwise,
+    testScenarioIds: scenarioIds,
+    optimizationCost,
+    testCost,
+    totalCost,
+    confidence,
+    intervalConfidence,
+    comparisonCount,
+    seed,
+    resamples,
+    reps: opts.reps ?? 1
+  };
+}
+function assertOptimizationMethods(methods) {
+  if (!Array.isArray(methods) || methods.length === 0) {
+    throw new Error("compareOptimizationMethods: no methods to compare");
+  }
+  const names = /* @__PURE__ */ new Set();
+  const pathOwners = /* @__PURE__ */ new Map();
+  for (const method of methods) {
+    if (!method || typeof method !== "object" || typeof method.optimize !== "function") {
+      throw new Error("compareOptimizationMethods: every method must provide optimize(input)");
     }
-    if (!write.capturedAt) {
-      throw new LabeledScenarioStoreError(
-        "missing_captured_at",
-        "LabeledScenarioWrite requires `capturedAt` ISO timestamp"
-      );
+    if (!method.name || method.name.trim() !== method.name) {
+      throw new Error("compareOptimizationMethods: method names must be trimmed and non-empty");
     }
-    if (!write.redactionStatus) {
-      throw new LabeledScenarioStoreError(
-        "missing_redaction_status",
-        "LabeledScenarioWrite requires explicit `redactionStatus` \u2014 raw / redacted-pii / redacted-secrets / fully-redacted"
-      );
+    if (names.has(method.name)) {
+      throw new Error(`compareOptimizationMethods: duplicate method name '${method.name}'`);
     }
-    if (!ALL_SOURCES.includes(write.source)) {
-      throw new LabeledScenarioStoreError(
-        "unknown_source",
-        `LabeledScenarioWrite.source must be one of: ${ALL_SOURCES.join(", ")}`
+    names.add(method.name);
+    const pathKey = slug(method.name);
+    const prior = pathOwners.get(pathKey);
+    if (prior) {
+      throw new Error(
+        `compareOptimizationMethods: method names '${prior}' and '${method.name}' map to the same run path '${pathKey}'`
       );
     }
+    pathOwners.set(pathKey, method.name);
   }
-  assertRateLimit(write) {
-    const cap = this.options.maxWritesPerMinutePerBucket;
-    if (!cap || !write.rateLimitBucket) return;
-    const now = this.now();
-    const windowMs = 6e4;
-    let state = this.rateLimits.get(write.rateLimitBucket);
-    if (!state || now - state.windowStartMs >= windowMs) {
-      state = { bucket: write.rateLimitBucket, windowStartMs: now, count: 0 };
-      this.rateLimits.set(write.rateLimitBucket, state);
-    }
-    if (state.count >= cap) {
-      throw new LabeledScenarioStoreError(
-        "rate_limit_exceeded",
-        `LabeledScenarioStore: bucket ${write.rateLimitBucket} exceeded ${cap} writes/min`
-      );
-    }
-    state.count += 1;
+}
+function assertOptimizationResult(name, result) {
+  if (!result || typeof result !== "object") {
+    throw new Error(`compareOptimizationMethods: method '${name}' returned no result`);
   }
-  toRecord(write) {
-    const recordHash = sha256(
-      JSON.stringify({
-        id: write.scenario.id,
-        src: write.source,
-        at: write.capturedAt,
-        ver: write.sourceVersionHash
-      })
+  try {
+    surfaceContentHash(result.winnerSurface);
+  } catch (cause) {
+    throw new Error(
+      `compareOptimizationMethods: method '${name}' returned an invalid winnerSurface`,
+      { cause }
     );
-    return {
-      ...write,
-      recordHash,
-      split: "train"
-    };
   }
-  pathForSource(source) {
-    return join2(this.options.root, `${source}.jsonl`);
+  assertComparisonCost(result.cost, `method '${name}'`);
+  if (result.durationMs !== void 0 && (!Number.isFinite(result.durationMs) || result.durationMs < 0)) {
+    throw new Error(`compareOptimizationMethods: method '${name}' returned an invalid durationMs`);
   }
-};
-var ALL_SOURCES = [
-  "production-trace",
-  "eval-run",
-  "manual",
-  "red-team",
-  "synthetic"
-];
-function sourceFilterContains(filter, needle) {
-  if (!filter) return false;
-  if (Array.isArray(filter)) return filter.includes(needle);
-  return filter === needle;
 }
-function matchesFilter(record, args, source) {
-  if (args.split === "train" && record.capturedAt >= args.capturedBefore) return false;
-  if (args.split === "test" && record.capturedAt < args.capturedBefore) return false;
-  const f = args.filter;
-  if (!f) return true;
-  if (f.kind && record.scenario.kind !== f.kind) return false;
-  if (f.source) {
-    const sources = Array.isArray(f.source) ? f.source : [f.source];
-    if (!sources.includes(source)) return false;
+function assertComparisonControls(opts, seed, resamples, confidence) {
+  if (!opts.judges || opts.judges.length === 0) {
+    throw new Error("compareOptimizationMethods: at least one judge is required");
   }
-  if (f.minComposite !== void 0 || f.maxComposite !== void 0) {
-    const composites = Object.values(record.judgeScores).map((s) => s.composite);
-    const max = composites.length === 0 ? 0 : Math.max(...composites);
-    if (f.minComposite !== void 0 && max < f.minComposite) return false;
-    if (f.maxComposite !== void 0 && max > f.maxComposite) return false;
+  if (typeof opts.dispatchWithSurface !== "function") {
+    throw new Error("compareOptimizationMethods: dispatchWithSurface must be a function");
   }
-  if (f.minTrust !== void 0 && labelTrustRank(record.labelTrust) < labelTrustRank(f.minTrust)) {
-    return false;
+  try {
+    surfaceContentHash(opts.baselineSurface);
+  } catch (cause) {
+    throw new Error("compareOptimizationMethods: baselineSurface is invalid", { cause });
   }
-  return true;
-}
-function sha256(input) {
-  return createHash4("sha256").update(input).digest("hex").slice(0, 16);
-}
-function appendLine(path, line) {
-  if (existsSync2(path)) {
-    const existing = readFileSync2(path, "utf8");
-    writeFileSync(path, existing + line);
-  } else {
-    writeFileSync(path, line);
+  const judgeNames = /* @__PURE__ */ new Set();
+  for (const judge of opts.judges) {
+    if (!judge || typeof judge !== "object" || typeof judge.name !== "string" || judge.name.trim().length === 0 || judge.name.trim() !== judge.name || typeof judge.score !== "function" || !Array.isArray(judge.dimensions) || judge.dimensions.length === 0) {
+      throw new Error(
+        "compareOptimizationMethods: every judge needs a trimmed name, at least one dimension, and score(input)"
+      );
+    }
+    if (judgeNames.has(judge.name)) {
+      throw new Error(`compareOptimizationMethods: duplicate judge name '${judge.name}'`);
+    }
+    judgeNames.add(judge.name);
+    const dimensionKeys = /* @__PURE__ */ new Set();
+    for (const dimension of judge.dimensions) {
+      if (!dimension || typeof dimension.key !== "string" || dimension.key.trim().length === 0 || dimension.key.trim() !== dimension.key || typeof dimension.description !== "string" || dimension.description.trim().length === 0) {
+        throw new Error(
+          `compareOptimizationMethods: judge '${judge.name}' has an invalid dimension`
+        );
+      }
+      if (dimensionKeys.has(dimension.key)) {
+        throw new Error(
+          `compareOptimizationMethods: judge '${judge.name}' has duplicate dimension '${dimension.key}'`
+        );
+      }
+      dimensionKeys.add(dimension.key);
+    }
   }
-}
-
-// src/campaign/neutralize.ts
-var FILLER = "#";
-function neutralizeText(content) {
-  return content.replace(/\S/g, FILLER);
-}
-
-// src/campaign/proposers/fapo.ts
-var FAPO_LEVELS = ["prompt", "parameter", "structural"];
-var MAX_FINDING_DEPTH = 16;
-var UNSAFE_JSON_KEYS = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]);
-function fapoProposer(opts) {
-  const proposers = levelProposers(opts);
-  const allowed = allowedLevels(opts, proposers);
-  const plateauWindow = opts.plateauWindow ?? 3;
-  const minDistinctStrategies = opts.minDistinctStrategies ?? 3;
-  const minImprovement = opts.minImprovement ?? 0;
-  const proposalsPerCycle = opts.proposalsPerCycle ?? 1;
-  if (allowed.length === 0) {
-    throw new Error("fapoProposer: at least one allowed level must have a proposer");
+  if (typeof opts.runDir !== "string" || opts.runDir.trim().length === 0) {
+    throw new Error("compareOptimizationMethods: runDir must be a non-empty string");
   }
-  if (plateauWindow < 1) throw new Error("fapoProposer: plateauWindow must be >= 1");
-  if (minDistinctStrategies < 1) {
-    throw new Error("fapoProposer: minDistinctStrategies must be >= 1");
+  if (!Number.isSafeInteger(seed)) {
+    throw new Error(`compareOptimizationMethods: seed must be a safe integer, got ${String(seed)}`);
   }
-  if (proposalsPerCycle < 1) throw new Error("fapoProposer: proposalsPerCycle must be >= 1");
-  return {
-    kind: "fapo",
-    async propose(ctx) {
-      const state = policyState(ctx.history, ctx.findings, {
-        plateauWindow,
-        minDistinctStrategies,
-        minImprovement
-      });
-      const decision = chooseLevel({
-        allowed,
-        available: allowed.filter((level) => !state.exhausted[level]),
-        proposers,
-        state,
-        promptFirst: opts.promptFirst ?? true,
-        parameterBeforeStructural: opts.parameterBeforeStructural ?? true
-      });
-      if (!decision) return [];
-      const proposer = proposers[decision.level];
-      if (!proposer) {
-        throw new Error(`fapoProposer: selected ${decision.level} but no proposer is configured`);
-      }
-      const requested = Math.min(ctx.populationSize, proposalsPerCycle);
-      const raw = await proposer.propose({ ...ctx, populationSize: requested });
-      const wrapped = raw.map((candidate) => normalizeProposal(candidate)).map((candidate) => wrapProposal(candidate, decision.level, decision.reason));
-      const reviewed = [];
-      for (const candidate of wrapped) {
-        const review = opts.reviewCandidate ? await opts.reviewCandidate({
-          level: decision.level,
-          candidate,
-          context: ctx,
-          reason: decision.reason
-        }) : { verdict: "pass" };
-        if (review.verdict === "fail") continue;
-        const warn = review.verdict === "warn" ? renderReviewWarnings(review) : "";
-        reviewed.push(
-          warn ? { ...candidate, rationale: `${candidate.rationale}
-${warn}` } : candidate
-        );
+  if (!Number.isSafeInteger(resamples) || resamples <= 0 || resamples > 1e6) {
+    throw new Error(
+      `compareOptimizationMethods: resamples must be a positive safe integer no greater than 1000000, got ${String(resamples)}`
+    );
+  }
+  if (!Number.isFinite(confidence) || confidence <= 0 || confidence >= 1) {
+    throw new Error(
+      `compareOptimizationMethods: confidence must be a finite number in (0,1), got ${String(confidence)}`
+    );
+  }
+  const minimumResamples = minimumBootstrapResamples(
+    confidence,
+    opts.methods.length * (opts.methods.length + 1) / 2
+  );
+  if (resamples < minimumResamples) {
+    throw new Error(
+      `compareOptimizationMethods: resamples must be at least ${minimumResamples} for simultaneous confidence ${confidence} across ${opts.methods.length} methods, got ${resamples}`
+    );
+  }
+  if (opts.optimizationConcurrency !== void 0 && (!Number.isSafeInteger(opts.optimizationConcurrency) || opts.optimizationConcurrency <= 0)) {
+    throw new Error(
+      "compareOptimizationMethods: optimizationConcurrency must be a positive safe integer"
+    );
+  }
+  if (opts.maxConcurrency !== void 0 && (!Number.isSafeInteger(opts.maxConcurrency) || opts.maxConcurrency <= 0)) {
+    throw new Error("compareOptimizationMethods: maxConcurrency must be a positive safe integer");
+  }
+  if (opts.dispatchTimeoutMs !== void 0 && (!Number.isSafeInteger(opts.dispatchTimeoutMs) || opts.dispatchTimeoutMs < 0 || opts.dispatchTimeoutMs > 2147483647)) {
+    throw new Error(
+      "compareOptimizationMethods: dispatchTimeoutMs must be a non-negative safe integer no greater than 2147483647"
+    );
+  }
+  if (opts.costCeiling !== void 0 && (!Number.isFinite(opts.costCeiling) || opts.costCeiling < 0)) {
+    throw new Error(
+      "compareOptimizationMethods: costCeiling must be a finite number greater than or equal to 0"
+    );
+  }
+  if (opts.costCeiling !== void 0 && opts.costLedger !== void 0 && opts.costLedger.costCeilingUsd !== opts.costCeiling) {
+    throw new Error(
+      "compareOptimizationMethods: costCeiling must match the shared CostLedger ceiling"
+    );
+  }
+}
+function assertComparisonPartitions(opts) {
+  const legacy = opts;
+  if (legacy.holdoutScenarios !== void 0) {
+    throw new Error(
+      "compareOptimizationMethods: holdoutScenarios is ambiguous and no longer accepted. Provide disjoint trainScenarios, selectionScenarios, and testScenarios; selection may be reused adaptively, test must remain untouched."
+    );
+  }
+  const partitions = [
+    { name: "trainScenarios", scenarios: opts.trainScenarios },
+    { name: "selectionScenarios", scenarios: opts.selectionScenarios },
+    { name: "testScenarios", scenarios: opts.testScenarios }
+  ];
+  const owner = /* @__PURE__ */ new Map();
+  for (const partition of partitions) {
+    if (!Array.isArray(partition.scenarios) || partition.scenarios.length === 0) {
+      throw new Error(`compareOptimizationMethods: ${partition.name} is empty`);
+    }
+    if (partition.name === "testScenarios" && partition.scenarios.length < 2) {
+      throw new Error(
+        "compareOptimizationMethods: testScenarios requires at least 2 scenarios to estimate uncertainty"
+      );
+    }
+    const local = /* @__PURE__ */ new Set();
+    const duplicates = /* @__PURE__ */ new Set();
+    const overlaps = /* @__PURE__ */ new Map();
+    for (const scenario of partition.scenarios) {
+      if (local.has(scenario.id)) duplicates.add(scenario.id);
+      local.add(scenario.id);
+      const prior = owner.get(scenario.id);
+      if (prior !== void 0 && prior !== partition.name) overlaps.set(scenario.id, prior);
+    }
+    if (duplicates.size > 0) {
+      throw new Error(
+        `compareOptimizationMethods: ${partition.name} contains duplicate scenario id(s) [${[
+          ...duplicates
+        ].join(", ")}]`
+      );
+    }
+    if (overlaps.size > 0) {
+      const detail = [...overlaps].map(([id, prior]) => `${id} (${prior} \u2229 ${partition.name})`).join(", ");
+      throw new Error(
+        `compareOptimizationMethods: trainScenarios, selectionScenarios, and testScenarios must be pairwise disjoint; overlap: [${detail}]`
+      );
+    }
+    assertCampaignDesign(partition.scenarios, opts.reps ?? 1);
+    for (const id of local) owner.set(id, partition.name);
+  }
+}
+function mean2(xs) {
+  return xs.length === 0 ? 0 : xs.reduce((a, b) => a + b, 0) / xs.length;
+}
+function slug(name) {
+  return name.replace(/[^a-z0-9]+/gi, "-").replace(/^-|-$/g, "").toLowerCase() || "method";
+}
+function assertConfidence(confidence) {
+  if (!Number.isFinite(confidence) || confidence <= 0 || confidence >= 1) {
+    throw new Error(
+      `compareOptimizationMethods: confidence must be a finite number in (0,1), got ${String(confidence)}`
+    );
+  }
+}
+function minimumBootstrapResamples(confidence, comparisonCount) {
+  const exact = 2 * comparisonCount / (1 - confidence);
+  return Math.ceil(exact - Number.EPSILON * Math.max(1, exact) * 32);
+}
+function createOptimizationMethodInput(opts, methodName, resolvedRunDir, seed) {
+  const cloneScenarios = (scenarios) => Object.freeze(scenarios.map((scenario) => structuredClone(scenario)));
+  const judges = opts.judges.map(
+    (judge) => Object.freeze({
+      ...judge,
+      dimensions: Object.freeze(
+        judge.dimensions.map((dimension) => Object.freeze({ ...dimension }))
+      )
+    })
+  );
+  return Object.freeze({
+    baselineSurface: structuredClone(opts.baselineSurface),
+    trainScenarios: cloneScenarios(opts.trainScenarios),
+    selectionScenarios: cloneScenarios(opts.selectionScenarios),
+    dispatchWithSurface: opts.dispatchWithSurface,
+    judges: Object.freeze(judges),
+    runDir: `${resolvedRunDir}/optimization/${slug(methodName)}`,
+    seed,
+    runOptions: Object.freeze({ ...opts.optimizationRunOptions ?? {} })
+  });
+}
+function costFromLedgerSummary(summary) {
+  const cost = {
+    totalCostUsd: summary.totalCostUsd,
+    accountingComplete: summary.accountingComplete,
+    incompleteReasons: [...summary.incompleteReasons]
+  };
+  assertComparisonCost(cost, "cost ledger");
+  return cost;
+}
+function combineCosts(entries) {
+  return {
+    totalCostUsd: entries.reduce((total, entry) => total + entry.cost.totalCostUsd, 0),
+    accountingComplete: entries.every((entry) => entry.cost.accountingComplete),
+    incompleteReasons: entries.flatMap(
+      (entry) => entry.cost.incompleteReasons.map((reason) => `${entry.label}: ${reason}`)
+    )
+  };
+}
+function assertComparisonCost(cost, label) {
+  if (!cost || typeof cost !== "object") {
+    throw new Error(`compareOptimizationMethods: ${label} returned no cost`);
+  }
+  if (!Number.isFinite(cost.totalCostUsd) || cost.totalCostUsd < 0) {
+    throw new Error(`compareOptimizationMethods: ${label} returned an invalid totalCostUsd`);
+  }
+  if (typeof cost.accountingComplete !== "boolean") {
+    throw new Error(`compareOptimizationMethods: ${label} returned invalid accountingComplete`);
+  }
+  if (!Array.isArray(cost.incompleteReasons) || cost.incompleteReasons.some(
+    (reason) => typeof reason !== "string" || reason.trim().length === 0
+  )) {
+    throw new Error(`compareOptimizationMethods: ${label} returned invalid incompleteReasons`);
+  }
+  if (cost.accountingComplete !== (cost.incompleteReasons.length === 0)) {
+    throw new Error(
+      `compareOptimizationMethods: ${label} returned inconsistent cost completeness and reasons`
+    );
+  }
+}
+
+// src/campaign/gepa-optimization-method.ts
+var DEFAULT_MAX_CANDIDATE_CHARS = 2e5;
+var DEFAULT_TIMEOUT_MS = 30 * 60 * 1e3;
+var MAX_CALLBACK_BODY_BYTES = 1e6;
+var MAX_PROCESS_OUTPUT_CHARS = 64e3;
+var PROCESS_TERMINATION_GRACE_MS = 5e3;
+function gepaOptimizationMethod(config) {
+  assertConfig(config);
+  const name = config.name ?? defaultMethodName(config.recipe);
+  return {
+    name,
+    async optimize(input) {
+      if (typeof input.baselineSurface !== "string") {
+        throw new Error(`${name}: GEPA bridge requires a string baselineSurface`);
       }
-      if (wrapped.length > 0 && reviewed.length === 0) {
-        throw new Error(
-          `fapoProposer: reviewer blocked every ${decision.level} candidate; refusing to evaluate an unreviewed variant`
+      const started = Date.now();
+      const maxCandidateChars = config.maxCandidateChars ?? DEFAULT_MAX_CANDIDATE_CHARS;
+      const storage = input.runOptions.storage ?? fsCampaignStorage();
+      const runDir = `${input.runDir}/gepa`;
+      storage.ensureDir(runDir);
+      const costLedger = createRunCostLedger({
+        storage,
+        runDir,
+        costCeilingUsd: input.runOptions.costCeiling
+      });
+      const scenarioById = scenarioMap(input.trainScenarios, input.selectionScenarios);
+      const evaluate = createEvaluationFunction({
+        input,
+        config,
+        runDir,
+        costLedger,
+        scenarioById,
+        maxCandidateChars
+      });
+      const callback = await startCallbackServer({
+        token: randomBytes(32).toString("hex"),
+        maxEvaluations: recipeEvaluationLimit(config.recipe),
+        evaluate
+      });
+      try {
+        const outputDir = `${runDir}/external`;
+        await mkdir(outputDir, { recursive: true });
+        const result = await runGepaBridge(
+          {
+            version: 2,
+            callbackUrl: callback.url,
+            callbackToken: callback.token,
+            recipe: config.recipe,
+            objective: config.objective,
+            ...config.background ? { background: config.background } : {},
+            seedCandidate: input.baselineSurface,
+            trainSet: input.trainScenarios.map((scenario) => describeScenario(config, scenario)),
+            selectionSet: input.selectionScenarios.map(
+              (scenario) => describeScenario(config, scenario)
+            ),
+            maxCandidateChars,
+            outputDir
+          },
+          config.runner,
+          config.timeoutMs ?? DEFAULT_TIMEOUT_MS
         );
+        assertBridgeOutput(
+          result,
+          name,
+          maxCandidateChars,
+          config.recipe.kind,
+          recipeEvaluationLimit(config.recipe)
+        );
+        const evaluationCost = costFromLedgerSummary(costLedger.summary());
+        const reportedProposerCost = result.proposerCostUsd ?? 0;
+        return {
+          winnerSurface: result.bestCandidate,
+          cost: {
+            totalCostUsd: evaluationCost.totalCostUsd + reportedProposerCost,
+            accountingComplete: false,
+            incompleteReasons: [
+              ...evaluationCost.incompleteReasons,
+              result.proposerCostAccounting === "reported" ? "GEPA proposer cost is externally reported and has no agent-eval receipt" : "GEPA proposer cost is unavailable"
+            ]
+          },
+          durationMs: Date.now() - started
+        };
+      } finally {
+        await callback.close();
       }
-      return reviewed;
-    },
-    decide({ history }) {
-      const last = history[history.length - 1];
-      if (last && last.candidates.length === 0) {
-        return { stop: true, reason: "FAPO produced no scoped candidate in the prior generation" };
-      }
-      const state = policyState(history, [], {
-        plateauWindow,
-        minDistinctStrategies,
-        minImprovement
-      });
-      const everyAllowedLevelExhausted = allowed.every((level) => state.exhausted[level]);
-      return everyAllowedLevelExhausted ? { stop: true, reason: `all FAPO levels exhausted (${allowed.join(", ")})` } : { stop: false };
     }
   };
 }
-function levelProposers(opts) {
-  return {
-    ...opts.proposers ?? {},
-    ...opts.promptProposer ? { prompt: opts.promptProposer } : {},
-    ...opts.parameterProposer ? { parameter: opts.parameterProposer } : {},
-    ...opts.structuralProposer ? { structural: opts.structuralProposer } : {}
+function createEvaluationFunction(args) {
+  const cached = /* @__PURE__ */ new Map();
+  return async ({ candidate, exampleId }) => {
+    if (!args.scenarioById.has(exampleId)) {
+      throw new Error(`GEPA requested unknown train or selection case '${exampleId}'`);
+    }
+    if (!isCandidateText(candidate, args.maxCandidateChars)) {
+      throw new Error("GEPA submitted an invalid candidate");
+    }
+    const scenario = args.scenarioById.get(exampleId);
+    const cacheKey = `${surfaceContentHash(candidate)}:${exampleId}`;
+    const existing = cached.get(cacheKey);
+    if (existing) return existing;
+    const result = scoreOneScenario({
+      input: args.input,
+      candidate,
+      scenario,
+      runDir: args.runDir,
+      costLedger: args.costLedger
+    });
+    cached.set(cacheKey, result);
+    return result;
   };
 }
-function allowedLevels(opts, proposers) {
-  const explicit = opts.scope?.allowedLevels;
-  const forbidden = new Set(opts.scope?.forbiddenLevels ?? []);
-  return FAPO_LEVELS.filter((level) => {
-    if (!proposers[level]) return false;
-    if (forbidden.has(level)) return false;
-    return explicit ? explicit.includes(level) : true;
+async function scoreOneScenario(args) {
+  const campaign = await runCampaign({
+    ...args.input.runOptions,
+    scenarios: [structuredClone(args.scenario)],
+    dispatch: (scenario, context) => args.input.dispatchWithSurface(args.candidate, scenario, context),
+    judges: [...args.input.judges],
+    runDir: `${args.runDir}/evaluations/${safePathComponent(surfaceContentHash(args.candidate))}/${safePathComponent(args.scenario.id)}`,
+    seed: args.input.seed,
+    costLedger: args.costLedger,
+    costPhase: "gepa.external-evaluation",
+    maxConcurrency: 1
   });
+  const breakdown = campaignBreakdown(campaign);
+  const row = breakdown.scenarios[0];
+  if (!row) throw new Error(`GEPA evaluation produced no score for '${args.scenario.id}'`);
+  return {
+    score: row.composite,
+    info: {
+      scenarioId: row.scenarioId,
+      dimensions: breakdown.dimensions,
+      ...row.notes ? { notes: row.notes } : {}
+    }
+  };
 }
-function policyState(history, findings, opts) {
-  const attempts = extractAttempts(history);
+function scenarioMap(train, selection) {
+  const out = /* @__PURE__ */ new Map();
+  for (const scenario of [...train, ...selection]) {
+    if (out.has(scenario.id)) {
+      throw new Error(
+        `GEPA bridge requires unique train and selection ids; duplicate '${scenario.id}'`
+      );
+    }
+    out.set(scenario.id, scenario);
+  }
+  return out;
+}
+function describeScenario(config, scenario) {
+  const data = config.describeScenario ? config.describeScenario(scenario) : { id: scenario.id };
+  assertJsonValue(data, `GEPA scenario '${scenario.id}'`);
+  return { id: scenario.id, data };
+}
+async function startCallbackServer(args) {
+  let evaluations = 0;
+  const server = createServer((request, response) => {
+    void handleCallback(request, response, args, () => {
+      evaluations += 1;
+      return evaluations;
+    });
+  });
+  const port = await listen(server);
   return {
-    attempts,
-    exhausted: {
-      prompt: isLevelExhausted("prompt", attempts, opts),
-      parameter: isLevelExhausted("parameter", attempts, opts),
-      structural: isLevelExhausted("structural", attempts, opts)
-    },
-    signals: extractFapoAttributionSignals(findings)
+    url: `http://127.0.0.1:${port}/evaluate`,
+    token: args.token,
+    close: () => closeServer(server)
   };
 }
-function extractAttempts(history) {
-  const attempts = [];
-  for (const generation of history) {
-    for (const candidate of generation.candidates) {
-      const level = candidateLevel(candidate);
-      if (!level) continue;
-      attempts.push({
-        level,
-        composite: candidate.composite,
-        strategy: candidateStrategy(candidate)
-      });
-    }
+async function handleCallback(request, response, args, nextEvaluation) {
+  try {
+    if (request.method !== "POST" || request.url !== "/evaluate") {
+      sendJson(response, 404, { error: "not found" });
+      return;
+    }
+    if (request.headers.authorization !== `Bearer ${args.token}`) {
+      sendJson(response, 401, { error: "unauthorized" });
+      return;
+    }
+    const body = await readJson(request);
+    if (!isRecord(body) || typeof body.candidate !== "string" || typeof body.exampleId !== "string") {
+      sendJson(response, 400, { error: "candidate and exampleId are required strings" });
+      return;
+    }
+    const count = nextEvaluation();
+    if (count > args.maxEvaluations) {
+      sendJson(response, 429, { error: "evaluation limit reached" });
+      return;
+    }
+    const result = await args.evaluate({ candidate: body.candidate, exampleId: body.exampleId });
+    sendJson(response, 200, result);
+  } catch {
+    sendJson(response, 500, { error: "evaluation failed" });
   }
-  return attempts;
-}
-function candidateLevel(candidate) {
-  const label = candidate.label ?? "";
-  const rationale = candidate.rationale ?? "";
-  return parseLevel(label) ?? parseLevel(rationale);
-}
-function parseLevel(text) {
-  const match = /\bfapo:(prompt|parameter|structural)\b/.exec(text);
-  return match ? match[1] : null;
-}
-function candidateStrategy(candidate) {
-  const label = candidate.label ?? candidate.rationale ?? candidate.surfaceHash;
-  return label.replace(/\bfapo:(prompt|parameter|structural):?/g, "").trim() || candidate.surfaceHash;
 }
-function isLevelExhausted(level, attempts, opts) {
-  const own = attempts.filter((attempt) => attempt.level === level);
-  if (own.length < opts.plateauWindow) return false;
-  const distinctStrategies = new Set(own.map((attempt) => attempt.strategy)).size;
-  if (distinctStrategies < opts.minDistinctStrategies) return false;
-  let best = Number.NEGATIVE_INFINITY;
-  let nonImproving = 0;
-  for (const attempt of own) {
-    if (attempt.composite > best + opts.minImprovement) {
-      best = attempt.composite;
-      nonImproving = 0;
-    } else {
-      nonImproving += 1;
-    }
+async function runGepaBridge(input, runner, timeoutMs) {
+  const dir = await mkdtemp(join2(tmpdir(), "agent-eval-gepa-"));
+  const inputPath = join2(dir, "input.json");
+  const outputPath = join2(dir, "output.json");
+  try {
+    await writeFile(inputPath, `${JSON.stringify(input)}
+`);
+    const command = runner?.command ?? "python";
+    const args = [
+      ...runner?.args ?? ["-m", "agent_eval_rpc.gepa_bridge"],
+      "--input",
+      inputPath,
+      "--output",
+      outputPath
+    ];
+    await runProcess(command, args, runner?.cwd ?? dir, runner?.env, timeoutMs);
+    const raw = JSON.parse(await readFile(outputPath, "utf8"));
+    if (!isRecord(raw)) throw new Error("GEPA bridge output must be a JSON object");
+    return raw;
+  } finally {
+    await rm(dir, { recursive: true, force: true });
   }
-  return nonImproving >= opts.plateauWindow;
 }
-function chooseLevel(args) {
-  const { available, state } = args;
-  if (available.length === 0) return null;
-  const triedPrompt = state.attempts.some((attempt) => attempt.level === "prompt");
-  if (args.promptFirst && available.includes("prompt") && !triedPrompt) {
-    return {
-      level: "prompt",
-      reason: "prompt-first policy: no prompt-level variant has been tried yet"
-    };
-  }
-  const supported = available.filter((level) => state.signals.counts[level] > 0);
-  if (supported.includes("prompt")) {
-    return {
-      level: "prompt",
-      reason: `attribution has ${state.signals.counts.prompt} prompt-addressable failure(s)`
-    };
-  }
-  const strongest = supported.sort(
-    (a, b) => state.signals.counts[b] - state.signals.counts[a] || levelRank(a) - levelRank(b)
-  )[0];
-  if (strongest) {
-    if (strongest === "structural" && args.parameterBeforeStructural && available.includes("parameter") && args.proposers.parameter) {
-      return {
-        level: "parameter",
-        reason: "attribution indicates a non-prompt bottleneck; trying parameter/config edits before structural edits"
-      };
-    }
-    return {
-      level: strongest,
-      reason: `attribution has ${state.signals.counts[strongest]} ${strongest}-addressable failure(s)`
+function runProcess(command, args, cwd, env, timeoutMs) {
+  return new Promise((resolvePromise, reject) => {
+    const child = spawn(command, args, {
+      cwd,
+      env: { ...process.env, ...env },
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    let timedOut = false;
+    let timeout;
+    let terminationGrace;
+    const finish = (error) => {
+      if (settled) return;
+      settled = true;
+      if (timeout) clearTimeout(timeout);
+      if (terminationGrace) clearTimeout(terminationGrace);
+      if (error) reject(error);
+      else resolvePromise();
     };
-  }
-  if (state.attempts.length === 0) {
-    const first = available.slice().sort((a, b) => levelRank(a) - levelRank(b))[0];
-    return { level: first, reason: "no attribution yet; starting at the cheapest allowed level" };
-  }
-  return null;
-}
-function levelRank(level) {
-  return level === "prompt" ? 0 : level === "parameter" ? 1 : 2;
+    timeout = setTimeout(() => {
+      timedOut = true;
+      child.kill("SIGTERM");
+      terminationGrace = setTimeout(() => {
+        child.kill("SIGKILL");
+        finish(new Error(`GEPA bridge exceeded ${timeoutMs}ms`));
+      }, PROCESS_TERMINATION_GRACE_MS);
+    }, timeoutMs);
+    child.stdout.on("data", (chunk) => {
+      stdout = appendProcessOutput(stdout, chunk);
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr = appendProcessOutput(stderr, chunk);
+    });
+    child.on("error", (error) => finish(new Error(`GEPA bridge could not start: ${error.message}`)));
+    child.on("close", (code) => {
+      if (timedOut) {
+        finish(new Error(`GEPA bridge exceeded ${timeoutMs}ms`));
+        return;
+      }
+      if (code === 0) {
+        finish();
+        return;
+      }
+      finish(
+        new Error(
+          `GEPA bridge exited ${String(code)}. stderr=${truncate(stderr)} stdout=${truncate(stdout)}`
+        )
+      );
+    });
+  });
 }
-function normalizeProposal(value) {
-  return isProposedCandidate(value) ? value : { surface: value, label: "candidate", rationale: "bare candidate from level proposer" };
+function appendProcessOutput(current, chunk) {
+  if (current.length >= MAX_PROCESS_OUTPUT_CHARS) return current;
+  return `${current}${chunk.toString()}`.slice(0, MAX_PROCESS_OUTPUT_CHARS);
+}
+function readJson(request) {
+  return new Promise((resolvePromise, reject) => {
+    let size = 0;
+    const chunks = [];
+    request.on("data", (chunk) => {
+      size += chunk.length;
+      if (size > MAX_CALLBACK_BODY_BYTES) {
+        reject(new Error("callback body too large"));
+        request.destroy();
+        return;
+      }
+      chunks.push(chunk);
+    });
+    request.on("error", reject);
+    request.on("end", () => {
+      try {
+        resolvePromise(JSON.parse(Buffer.concat(chunks).toString("utf8")));
+      } catch (error) {
+        reject(error);
+      }
+    });
+  });
 }
-function wrapProposal(candidate, level, reason) {
-  const label = candidate.label ? `fapo:${level}:${candidate.label}` : `fapo:${level}`;
-  return {
-    ...candidate,
-    label,
-    rationale: [
-      `fapo:${level} selected by reviewed escalation policy`,
-      `Reason: ${reason}`,
-      candidate.rationale ? `Level proposer rationale: ${candidate.rationale}` : ""
-    ].filter(Boolean).join("\n")
-  };
+function listen(server) {
+  return new Promise((resolvePromise, reject) => {
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", () => {
+      server.off("error", reject);
+      const address = server.address();
+      if (!address || typeof address === "string") {
+        reject(new Error("GEPA callback did not bind a TCP port"));
+        return;
+      }
+      resolvePromise(address.port);
+    });
+  });
 }
-function renderReviewWarnings(review) {
-  const issues = review.issues?.filter((issue) => issue.severity === "warn") ?? [];
-  if (issues.length === 0) return "";
-  return `Reviewer warnings:
-${issues.map((issue) => `- ${issue.checkName}: ${issue.description}`).join("\n")}`;
+function closeServer(server) {
+  return new Promise((resolvePromise, reject) => {
+    server.close((error) => error ? reject(error) : resolvePromise());
+  });
 }
-function extractFapoAttributionSignals(findings) {
-  const signals = {
-    counts: { prompt: 0, parameter: 0, structural: 0 },
-    clusters: []
-  };
-  const seen = /* @__PURE__ */ new WeakSet();
-  for (const finding of findings) {
-    collectFinding(signals, finding, seen, 0);
+function assertConfig(config) {
+  if (!config.objective || config.objective.trim() !== config.objective) {
+    throw new Error("gepaOptimizationMethod: objective must be trimmed and non-empty");
+  }
+  assertRecipe(config.recipe);
+  if (config.maxCandidateChars !== void 0 && (!Number.isSafeInteger(config.maxCandidateChars) || config.maxCandidateChars <= 0)) {
+    throw new Error("gepaOptimizationMethod: maxCandidateChars must be a positive safe integer");
+  }
+  if (config.timeoutMs !== void 0 && (!Number.isSafeInteger(config.timeoutMs) || config.timeoutMs <= 0)) {
+    throw new Error("gepaOptimizationMethod: timeoutMs must be a positive safe integer");
   }
-  return signals;
 }
-function collectFinding(signals, finding, seen, depth) {
-  if (depth > MAX_FINDING_DEPTH) return;
-  if (!finding) return;
-  if (typeof finding === "string") {
-    const level = inferLevelFromText(finding);
-    if (level) addCluster(signals, { label: finding, level, count: 1 });
-    return;
+function assertRecipe(recipe) {
+  if (!recipe || typeof recipe !== "object") {
+    throw new Error("gepaOptimizationMethod: recipe is required");
   }
-  if (Array.isArray(finding)) {
-    if (seen.has(finding)) return;
-    seen.add(finding);
-    for (const item of finding) collectFinding(signals, item, seen, depth + 1);
+  if (recipe.kind === "engine") {
+    assertEngineRun(recipe.run, "recipe.run");
     return;
   }
-  if (typeof finding !== "object") return;
-  if (seen.has(finding)) return;
-  seen.add(finding);
-  const obj = finding;
-  collectLevelPartition(signals, obj.level_partition ?? obj.levelPartition, seen, depth + 1);
-  collectCounts(signals, obj);
-  collectClusters(signals, obj.clusters, true, seen, depth + 1);
-  const explicit = parseFindingLevel(obj.level ?? obj.optimization_level ?? obj.optimizationLevel);
-  const text = textFields(obj);
-  const inferred = explicit ?? inferLevelFromText(text);
-  if (inferred) {
-    addCluster(signals, {
-      label: text || inferred,
-      level: inferred,
-      count: numberField(obj.count) ?? 1,
-      confidence: confidenceField(obj.confidence),
-      suggestedFix: stringField(obj.suggested_fix ?? obj.suggestedFix ?? obj.recommended_action),
-      caseIds: stringArrayField(obj.case_ids ?? obj.caseIds)
-    });
+  if (recipe.kind === "best-of-then-continue") {
+    if (!Array.isArray(recipe.explore) || recipe.explore.length < 2) {
+      throw new Error(
+        "gepaOptimizationMethod: recipe.explore must contain at least two bounded engine runs"
+      );
+    }
+    for (const [index, run] of recipe.explore.entries()) {
+      assertEngineRun(run, `recipe.explore[${index}]`);
+    }
+    assertEngineRun(recipe.continueWith, "recipe.continueWith");
+    return;
   }
+  throw new Error("gepaOptimizationMethod: unsupported recipe");
 }
-function collectLevelPartition(signals, raw, seen, depth) {
-  if (!raw || typeof raw !== "object") return;
-  if (seen.has(raw)) return;
-  seen.add(raw);
-  const partition = raw;
-  for (const level of FAPO_LEVELS) {
-    const bucket = partition[level];
-    if (!bucket || typeof bucket !== "object") continue;
-    const obj = bucket;
-    const count = numberField(obj.count) ?? 0;
-    if (count > 0) signals.counts[level] += count;
-    collectClusters(signals, obj.clusters, false, seen, depth + 1);
+function assertEngineRun(run, label) {
+  if (!run || typeof run !== "object") {
+    throw new Error(`gepaOptimizationMethod: ${label} is required`);
   }
+  if (typeof run.engine !== "string" || !run.engine.trim() || run.engine.trim() !== run.engine) {
+    throw new Error(`gepaOptimizationMethod: ${label}.engine must be a trimmed non-empty string`);
+  }
+  if (!Number.isSafeInteger(run.maxEvaluations) || run.maxEvaluations <= 0) {
+    throw new Error(
+      `gepaOptimizationMethod: ${label}.maxEvaluations must be a positive safe integer`
+    );
+  }
+  if (!Number.isFinite(run.maxProposerCostUsd) || run.maxProposerCostUsd <= 0) {
+    throw new Error(
+      `gepaOptimizationMethod: ${label}.maxProposerCostUsd must be a positive finite number`
+    );
+  }
+  assertJsonValue(run.engineConfig ?? {}, `gepaOptimizationMethod: ${label}.engineConfig`);
 }
-function collectCounts(signals, obj) {
-  const prompt = numberField(obj.prompt_addressable ?? obj.promptAddressable);
-  const structural = numberField(obj.structural_addressable ?? obj.structuralAddressable);
-  const tool = numberField(obj.tool_addressable ?? obj.toolAddressable);
-  if (prompt) signals.counts.prompt += prompt;
-  if (structural) signals.counts.structural += structural;
-  if (tool) signals.counts.structural += tool;
-}
-function collectClusters(signals, raw, countClusters, seen, depth) {
-  if (!Array.isArray(raw)) return;
-  if (seen.has(raw)) return;
-  seen.add(raw);
-  for (const item of raw) {
-    if (countClusters) {
-      collectFinding(signals, item, seen, depth + 1);
-      continue;
+function recipeEvaluationLimit(recipe) {
+  const runs = recipe.kind === "engine" ? [recipe.run] : [...recipe.explore, recipe.continueWith];
+  let total = 0;
+  for (const run of runs) {
+    total += run.maxEvaluations;
+    if (!Number.isSafeInteger(total)) {
+      throw new Error("gepaOptimizationMethod: recipe evaluation limit exceeds safe integer range");
     }
-    const cluster = parseCluster(item);
-    if (cluster) signals.clusters.push(cluster);
   }
+  return total;
 }
-function addCluster(signals, cluster) {
-  signals.counts[cluster.level] += Math.max(1, cluster.count);
-  signals.clusters.push(cluster);
+function defaultMethodName(recipe) {
+  if (recipe.kind === "engine") return `gepa:${recipe.run.engine}`;
+  return `gepa:best-of-then-continue:${recipe.continueWith.engine}`;
 }
-function parseCluster(raw) {
-  if (!raw || typeof raw !== "object") return null;
-  const obj = raw;
-  const text = textFields(obj);
-  const level = parseFindingLevel(obj.level ?? obj.optimization_level ?? obj.optimizationLevel) ?? inferLevelFromText(text);
-  if (!level) return null;
-  return {
-    label: text || level,
-    level,
-    count: numberField(obj.count) ?? 1,
-    confidence: confidenceField(obj.confidence),
-    suggestedFix: stringField(obj.suggested_fix ?? obj.suggestedFix ?? obj.recommended_action),
-    caseIds: stringArrayField(obj.case_ids ?? obj.caseIds)
-  };
+function assertBridgeOutput(result, name, maxCandidateChars, recipeKind, maxEvaluations) {
+  if (result.recipeKind !== recipeKind)
+    throw new Error(`${name}: GEPA bridge reported recipe '${String(result.recipeKind)}'`);
+  if (!isCandidateText(result.bestCandidate, maxCandidateChars)) {
+    throw new Error(`${name}: GEPA bridge returned an invalid candidate`);
+  }
+  if (!Number.isFinite(result.bestScore))
+    throw new Error(`${name}: GEPA bridge returned an invalid bestScore`);
+  if (!Number.isSafeInteger(result.totalEvaluations) || result.totalEvaluations < 0 || result.totalEvaluations > maxEvaluations) {
+    throw new Error(`${name}: GEPA bridge returned an invalid totalEvaluations`);
+  }
+  if (result.proposerCostUsd !== void 0 && (!Number.isFinite(result.proposerCostUsd) || result.proposerCostUsd < 0)) {
+    throw new Error(`${name}: GEPA bridge returned an invalid proposerCostUsd`);
+  }
 }
-function parseFindingLevel(raw) {
-  if (typeof raw !== "string") return null;
-  const lower = raw.toLowerCase();
-  if (lower === "prompt" || lower === "parameter" || lower === "structural") return lower;
-  if (lower === "chain" || lower === "tool" || lower === "code") return "structural";
-  if (lower === "config" || lower === "params") return "parameter";
-  return null;
+function isCandidateText(value, maxChars) {
+  return typeof value === "string" && value.trim().length > 0 && value.length <= maxChars;
 }
-function inferLevelFromText(text) {
-  const lower = text.toLowerCase();
-  if (/\b(retrieval_k|temperature|top_p|max_tokens|max_completion_tokens|reasoning_effort|config|parameter)\b/.test(
-    lower
-  )) {
-    return "parameter";
-  }
-  if (/\b(retriev\w*|search\w*|bm25|hop|evidence|cascade|tool|node|chain|state|structur\w*|topology|import)\b/.test(
-    lower
-  )) {
-    return "structural";
+function assertJsonValue(value, label, seen = /* @__PURE__ */ new Set()) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") return;
+  if (typeof value === "number" && Number.isFinite(value)) return;
+  if (Array.isArray(value)) {
+    if (seen.has(value)) throw new Error(`${label} must be JSON-serializable`);
+    seen.add(value);
+    for (const item of value) assertJsonValue(item, label, seen);
+    seen.delete(value);
+    return;
   }
-  if (/\b(format\w*|verbose|brevity|abstain\w*|reasoning|instruction|prompt|output|answer)\b/.test(
-    lower
-  )) {
-    return "prompt";
+  if (typeof value === "object") {
+    if (seen.has(value)) throw new Error(`${label} must be JSON-serializable`);
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null) {
+      throw new Error(`${label} must be JSON-serializable`);
+    }
+    seen.add(value);
+    for (const item of Object.values(value)) assertJsonValue(item, label, seen);
+    seen.delete(value);
+    return;
   }
-  return null;
+  throw new Error(`${label} must be JSON-serializable`);
 }
-function textFields(obj) {
-  return [
-    obj.label,
-    obj.claim,
-    obj.recommended_action,
-    obj.suggested_fix,
-    obj.suggestedFix,
-    obj.message,
-    obj.text,
-    obj.heuristic,
-    obj.area
-  ].filter((value) => typeof value === "string" && value.trim().length > 0).join(" ");
-}
-function numberField(value) {
-  return typeof value === "number" && Number.isFinite(value) ? value : null;
+function safePathComponent(value) {
+  return value.replace(/[^a-zA-Z0-9._-]/g, "_");
 }
-function stringField(value) {
-  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function confidenceField(value) {
-  return value === "high" || value === "medium" || value === "low" ? value : void 0;
+function sendJson(response, status, body) {
+  response.writeHead(status, { "content-type": "application/json; charset=utf-8" });
+  response.end(JSON.stringify(body));
 }
-function stringArrayField(value) {
-  return Array.isArray(value) ? value.filter((item) => typeof item === "string") : void 0;
+function truncate(value, max = 1e3) {
+  const compact2 = value.trim().replace(/\s+/g, " ");
+  return compact2.length <= max ? compact2 : `${compact2.slice(0, max)}\u2026`;
 }
-function parameterSweepProposer(opts) {
-  if (opts.candidates.length === 0) {
-    throw new Error("parameterSweepProposer: candidates must not be empty");
-  }
-  return {
-    kind: "parameter-sweep",
-    async propose(ctx) {
-      if (typeof ctx.currentSurface !== "string") {
-        throw new Error(
-          "parameterSweepProposer: currentSurface must be a JSON string config surface"
-        );
-      }
-      const parse = opts.parse ?? parseJsonObject;
-      const stringify = opts.stringify ?? ((config) => JSON.stringify(config, null, 2));
-      const current = parse(ctx.currentSurface);
-      const currentCanonical = canonicalJson2(current);
-      const tried = triedLabels(ctx.history);
-      const out = [];
-      for (const candidate of opts.candidates) {
-        if (tried.has(candidate.label)) continue;
-        const next = applyParameterCandidate(current, candidate);
-        const surface = stringify(next);
-        if (surface === ctx.currentSurface || canonicalJson2(next) === currentCanonical) continue;
-        out.push({ surface, label: candidate.label, rationale: candidate.rationale });
-        if (out.length >= ctx.populationSize) break;
+
+// src/campaign/grounded-reflection.ts
+function rolloutArgumentDiff(rollouts, opts = {}) {
+  const passThreshold = opts.passThreshold ?? 1;
+  const maxValues = opts.maxValuesPerField ?? 4;
+  const collect = (pass) => {
+    const byField = /* @__PURE__ */ new Map();
+    for (const r of rollouts) {
+      if (pass !== r.score >= passThreshold) continue;
+      for (const c of r.calls) {
+        for (const [k, v] of Object.entries(c.args)) {
+          const set = byField.get(k) ?? /* @__PURE__ */ new Set();
+          set.add(String(v));
+          byField.set(k, set);
+        }
       }
-      return out;
     }
+    return byField;
   };
-}
-function parseJsonObject(surface) {
-  let parsed;
-  try {
-    parsed = JSON.parse(surface);
-  } catch (error) {
-    throw new Error(
-      `parameterSweepProposer: currentSurface must be valid JSON object config (${error instanceof Error ? error.message : String(error)})`
-    );
-  }
-  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-    throw new Error("parameterSweepProposer: JSON surface must parse to an object");
-  }
-  return parsed;
-}
-function triedLabels(history) {
-  const tried = /* @__PURE__ */ new Set();
-  for (const generation of history) {
-    for (const candidate of generation.candidates) {
-      if (!candidate.label) continue;
-      tried.add(candidate.label);
-      tried.add(candidateStrategy(candidate));
-    }
+  const passing = collect(true);
+  const failing = collect(false);
+  const lines = [];
+  for (const field of /* @__PURE__ */ new Set([...passing.keys(), ...failing.keys()])) {
+    const pv = [...passing.get(field) ?? []].slice(0, maxValues);
+    const fv = [...failing.get(field) ?? []].slice(0, maxValues);
+    const render = (vals) => vals.length ? JSON.stringify(vals) : "NOT SET (omitted)";
+    lines.push(`  ${field}: passing runs -> ${render(pv)} | failing runs -> ${render(fv)}`);
   }
-  return tried;
+  const lower = (m) => {
+    const out = /* @__PURE__ */ new Set();
+    for (const vals of m.values()) for (const v of vals) out.add(v.toLowerCase());
+    return out;
+  };
+  return {
+    text: lines.join("\n") || "  (no calls observed)",
+    passingValues: lower(passing),
+    failingValues: lower(failing)
+  };
 }
-function applyParameterCandidate(current, candidate) {
-  const next = cloneJsonObject(current);
-  if (candidate.patch) deepMerge(next, candidate.patch);
-  for (const change of candidate.changes ?? []) {
-    setPath(
-      next,
-      typeof change.path === "string" ? change.path.split(".") : [...change.path],
-      change.value
-    );
+function classifyUngroundedLiterals(text, diff) {
+  const ungrounded = /* @__PURE__ */ new Set();
+  for (const m of text.matchAll(/'([a-z][a-z_-]{1,19})'/gi)) {
+    const w = m[1].toLowerCase();
+    if (!diff.passingValues.has(w)) ungrounded.add(w);
   }
-  return next;
-}
-function cloneJsonObject(value) {
-  return JSON.parse(JSON.stringify(value));
+  const all = [...ungrounded];
+  return {
+    ungrounded: all,
+    harmful: all.filter((w) => diff.failingValues.has(w))
+  };
 }
-function deepMerge(target, patch) {
-  for (const [key, value] of Object.entries(patch)) {
-    assertSafeJsonKey(key);
-    if (isPlainObject(value) && isPlainObject(target[key])) {
-      deepMerge(target[key], value);
-    } else {
-      target[key] = value;
-    }
+
+// src/campaign/labeled-store/fs-adapter.ts
+import { createHash as createHash4 } from "crypto";
+import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { join as join3 } from "path";
+var LabeledScenarioStoreError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "LabeledScenarioStoreError";
   }
-}
-function setPath(target, path, value) {
-  if (path.length === 0) throw new Error("parameterSweepProposer: change path must not be empty");
-  for (const part of path) assertSafeJsonKey(part);
-  let cursor = target;
-  for (const part of path.slice(0, -1)) {
-    const existing = cursor[part];
-    if (!isPlainObject(existing)) {
-      cursor[part] = {};
-    }
-    cursor = cursor[part];
+  code;
+};
+var FsLabeledScenarioStore = class {
+  constructor(options) {
+    this.options = options;
+    if (!existsSync2(options.root)) mkdirSync(options.root, { recursive: true });
+    this.now = options.now ?? Date.now;
   }
-  cursor[path[path.length - 1]] = value;
-}
-function assertSafeJsonKey(key) {
-  if (!key.trim()) throw new Error("parameterSweepProposer: change path contains an empty key");
-  if (UNSAFE_JSON_KEYS.has(key)) {
-    throw new Error(`parameterSweepProposer: unsafe JSON key "${key}" is not allowed`);
+  options;
+  now;
+  rateLimits = /* @__PURE__ */ new Map();
+  async observe(write) {
+    this.assertProvenance(write);
+    this.assertRateLimit(write);
+    const record = this.toRecord(write);
+    const path = this.pathForSource(write.source);
+    const line = `${JSON.stringify(record)}
+`;
+    appendLine(path, line);
   }
-}
-function canonicalJson2(value) {
-  if (Array.isArray(value)) return `[${value.map((item) => canonicalJson2(item)).join(",")}]`;
-  if (isPlainObject(value)) {
-    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson2(value[key])}`).join(",")}}`;
+  async sample(args) {
+    if (!args.split) {
+      throw new LabeledScenarioStoreError(
+        "split_required",
+        "sample() requires an explicit `split` (train | test) \u2014 substrate refuses ambiguous reads"
+      );
+    }
+    if (!args.capturedBefore) {
+      throw new LabeledScenarioStoreError(
+        "capturedBefore_required",
+        "sample() requires an explicit `capturedBefore` timestamp for temporal-split discipline"
+      );
+    }
+    const all = [];
+    for (const source of ALL_SOURCES) {
+      if (args.split === "train" && source === "production-trace") {
+        const explicit = sourceFilterContains(args.filter?.source, "production-trace");
+        if (!explicit) continue;
+      }
+      const path = this.pathForSource(source);
+      if (!existsSync2(path)) continue;
+      const lines = readFileSync2(path, "utf8").split("\n").filter(Boolean);
+      for (const line of lines) {
+        let record;
+        try {
+          record = JSON.parse(line);
+        } catch {
+          continue;
+        }
+        if (!matchesFilter(record, args, source)) continue;
+        all.push(record);
+      }
+    }
+    all.sort((a, b) => {
+      if (a.capturedAt !== b.capturedAt) return a.capturedAt.localeCompare(b.capturedAt);
+      return a.recordHash.localeCompare(b.recordHash);
+    });
+    return all.slice(0, args.count);
   }
-  return JSON.stringify(value);
-}
-function isPlainObject(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
-  const proto = Object.getPrototypeOf(value);
-  return proto === Object.prototype || proto === null;
-}
-
-// src/campaign/skill-patch.ts
-function applySkillPatch(surface, patch) {
-  let lines = surface.split("\n");
-  let applied = 0;
-  const rejected = [];
-  const findLine = (anchor) => lines.findIndex((l) => l.includes(anchor));
-  for (const op of patch.ops) {
-    if (op.op === "add") {
-      if (typeof op.text !== "string" || op.text.trim() === "") {
-        rejected.push({ op, reason: "empty add text" });
+  async size() {
+    const bySource = {};
+    const byTrust = {
+      unverified: 0,
+      "verified-signal": 0,
+      "human-rated": 0
+    };
+    let total = 0;
+    for (const source of ALL_SOURCES) {
+      const path = this.pathForSource(source);
+      if (!existsSync2(path)) {
+        bySource[source] = 0;
         continue;
       }
-      const insert = op.text.split("\n");
-      if (op.after === void 0 || op.after === "") {
-        lines = [...lines, ...insert];
-        applied++;
-        continue;
-      }
-      const idx = findLine(op.after);
-      if (idx === -1) {
-        rejected.push({ op, reason: `add anchor not found: ${truncate(op.after)}` });
-        continue;
-      }
-      lines = [...lines.slice(0, idx + 1), ...insert, ...lines.slice(idx + 1)];
-      applied++;
-    } else if (op.op === "delete") {
-      const idx = findLine(op.anchor);
-      if (idx === -1) {
-        rejected.push({ op, reason: `delete anchor not found: ${truncate(op.anchor)}` });
-        continue;
-      }
-      lines = [...lines.slice(0, idx), ...lines.slice(idx + 1)];
-      applied++;
-    } else {
-      const idx = findLine(op.anchor);
-      if (idx === -1) {
-        rejected.push({ op, reason: `replace anchor not found: ${truncate(op.anchor)}` });
-        continue;
-      }
-      if (typeof op.text !== "string") {
-        rejected.push({ op, reason: "replace text missing" });
-        continue;
+      const lines = readFileSync2(path, "utf8").split("\n").filter(Boolean);
+      bySource[source] = lines.length;
+      total += lines.length;
+      for (const line of lines) {
+        let trust = "unverified";
+        try {
+          trust = JSON.parse(line).labelTrust ?? "unverified";
+        } catch {
+        }
+        byTrust[trust] += 1;
       }
-      lines = [...lines.slice(0, idx), ...op.text.split("\n"), ...lines.slice(idx + 1)];
-      applied++;
     }
+    return { train: total, test: total, bySource, byTrust };
   }
-  return { surface: lines.join("\n"), applied, rejected };
+  assertProvenance(write) {
+    if (!write.source) {
+      throw new LabeledScenarioStoreError(
+        "missing_source",
+        "LabeledScenarioWrite requires `source`"
+      );
+    }
+    if (!write.sourceVersionHash || write.sourceVersionHash.length === 0) {
+      throw new LabeledScenarioStoreError(
+        "missing_source_version",
+        "LabeledScenarioWrite requires `sourceVersionHash` (git sha or substrate version)"
+      );
+    }
+    if (!write.capturedAt) {
+      throw new LabeledScenarioStoreError(
+        "missing_captured_at",
+        "LabeledScenarioWrite requires `capturedAt` ISO timestamp"
+      );
+    }
+    if (!write.redactionStatus) {
+      throw new LabeledScenarioStoreError(
+        "missing_redaction_status",
+        "LabeledScenarioWrite requires explicit `redactionStatus` \u2014 raw / redacted-pii / redacted-secrets / fully-redacted"
+      );
+    }
+    if (!ALL_SOURCES.includes(write.source)) {
+      throw new LabeledScenarioStoreError(
+        "unknown_source",
+        `LabeledScenarioWrite.source must be one of: ${ALL_SOURCES.join(", ")}`
+      );
+    }
+  }
+  assertRateLimit(write) {
+    const cap = this.options.maxWritesPerMinutePerBucket;
+    if (!cap || !write.rateLimitBucket) return;
+    const now = this.now();
+    const windowMs = 6e4;
+    let state = this.rateLimits.get(write.rateLimitBucket);
+    if (!state || now - state.windowStartMs >= windowMs) {
+      state = { bucket: write.rateLimitBucket, windowStartMs: now, count: 0 };
+      this.rateLimits.set(write.rateLimitBucket, state);
+    }
+    if (state.count >= cap) {
+      throw new LabeledScenarioStoreError(
+        "rate_limit_exceeded",
+        `LabeledScenarioStore: bucket ${write.rateLimitBucket} exceeded ${cap} writes/min`
+      );
+    }
+    state.count += 1;
+  }
+  toRecord(write) {
+    const recordHash = sha256(
+      JSON.stringify({
+        id: write.scenario.id,
+        src: write.source,
+        at: write.capturedAt,
+        ver: write.sourceVersionHash
+      })
+    );
+    return {
+      ...write,
+      recordHash,
+      split: "train"
+    };
+  }
+  pathForSource(source) {
+    return join3(this.options.root, `${source}.jsonl`);
+  }
+};
+var ALL_SOURCES = [
+  "production-trace",
+  "eval-run",
+  "manual",
+  "red-team",
+  "synthetic"
+];
+function sourceFilterContains(filter, needle) {
+  if (!filter) return false;
+  if (Array.isArray(filter)) return filter.includes(needle);
+  return filter === needle;
 }
-function patchEditCount(patch) {
-  return patch.ops.length;
+function matchesFilter(record, args, source) {
+  if (args.split === "train" && record.capturedAt >= args.capturedBefore) return false;
+  if (args.split === "test" && record.capturedAt < args.capturedBefore) return false;
+  const f = args.filter;
+  if (!f) return true;
+  if (f.kind && record.scenario.kind !== f.kind) return false;
+  if (f.source) {
+    const sources = Array.isArray(f.source) ? f.source : [f.source];
+    if (!sources.includes(source)) return false;
+  }
+  if (f.minComposite !== void 0 || f.maxComposite !== void 0) {
+    const composites = Object.values(record.judgeScores).map((s) => s.composite);
+    const max = composites.length === 0 ? 0 : Math.max(...composites);
+    if (f.minComposite !== void 0 && max < f.minComposite) return false;
+    if (f.maxComposite !== void 0 && max > f.maxComposite) return false;
+  }
+  if (f.minTrust !== void 0 && labelTrustRank(record.labelTrust) < labelTrustRank(f.minTrust)) {
+    return false;
+  }
+  return true;
 }
-function truncate(s, max = 48) {
-  return s.length <= max ? s : `${s.slice(0, max)}\u2026`;
+function sha256(input) {
+  return createHash4("sha256").update(input).digest("hex").slice(0, 16);
+}
+function appendLine(path, line) {
+  if (existsSync2(path)) {
+    const existing = readFileSync2(path, "utf8");
+    writeFileSync(path, existing + line);
+  } else {
+    writeFileSync(path, line);
+  }
 }
 
-// src/campaign/proposers/skill-opt.ts
-var SKILLOPT_SYSTEM = 'You are a SkillOpt optimizer. You improve ONE skill document by proposing BOUNDED, anchored edits \u2014 never a full rewrite. Output ONLY a JSON object of shape {"patches":[{"label":string,"rationale":string,"ops":[op,...]}]} where each op is one of: {"op":"add","after":<exact substring of an existing line, or omit to append>,"text":<new line(s)>}, {"op":"delete","anchor":<exact substring of the line to remove>}, {"op":"replace","anchor":<exact substring of the line to replace>,"text":<replacement line(s)>}. Anchors MUST be verbatim substrings of lines that exist in the document. No prose outside JSON.';
-function skillOptProposer(opts) {
-  const evidenceK = opts.evidenceK ?? 3;
-  const defaultBudget = opts.editBudget ?? 3;
-  const directCostLedger = opts.costLedger ?? new CostLedger();
-  async function proposePatches(args) {
-    const userPrompt = buildPatchPrompt({
-      target: opts.target,
-      surface: args.surface,
-      evidence: args.evidence,
-      editBudget: args.editBudget,
-      rejectedBuffer: args.rejectedBuffer,
-      metaNote: args.metaNote,
-      findingsNote: args.findingsNote,
-      count: args.count
-    });
-    const request = {
-      model: opts.model,
-      messages: [
-        { role: "system", content: SKILLOPT_SYSTEM },
-        { role: "user", content: userPrompt }
-      ],
-      jsonMode: true,
-      temperature: opts.temperature ?? 0.6,
-      maxTokens: opts.maxTokens ?? 4e3
-    };
-    const paid = await (args.costLedger ?? directCostLedger).runPaidCall({
-      channel: "driver",
-      phase: args.costPhase ?? "search.proposal",
-      actor: "skill-opt.propose",
-      model: opts.model,
-      maximumCharge: maximumChargeForLlmRequest(request, opts.llm),
-      signal: args.signal,
-      execute: (signal, callId) => callLlm(request, { ...opts.llm, signal, idempotencyKey: callId }),
-      receipt: costReceiptFromLlm,
-      receiptFromError: costReceiptFromLlmError
-    });
-    if (!paid.succeeded) throw paid.error;
-    const result = paid.value;
-    return parseSkillPatchResponse(result.content, args.count, args.editBudget);
+// src/campaign/neutralize.ts
+var FILLER = "#";
+function neutralizeText(content) {
+  return content.replace(/\S/g, FILLER);
+}
+
+// src/campaign/proposers/fapo.ts
+var FAPO_LEVELS = ["prompt", "parameter", "structural"];
+var MAX_FINDING_DEPTH = 16;
+var UNSAFE_JSON_KEYS = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]);
+function fapoProposer(opts) {
+  const proposers = levelProposers(opts);
+  const allowed = allowedLevels(opts, proposers);
+  const plateauWindow = opts.plateauWindow ?? 3;
+  const minDistinctStrategies = opts.minDistinctStrategies ?? 3;
+  const minImprovement = opts.minImprovement ?? 0;
+  const proposalsPerCycle = opts.proposalsPerCycle ?? 1;
+  if (allowed.length === 0) {
+    throw new Error("fapoProposer: at least one allowed level must have a proposer");
   }
+  if (plateauWindow < 1) throw new Error("fapoProposer: plateauWindow must be >= 1");
+  if (minDistinctStrategies < 1) {
+    throw new Error("fapoProposer: minDistinctStrategies must be >= 1");
+  }
+  if (proposalsPerCycle < 1) throw new Error("fapoProposer: proposalsPerCycle must be >= 1");
   return {
-    kind: "skill-opt",
-    proposePatches,
+    kind: "fapo",
     async propose(ctx) {
-      if (typeof ctx.currentSurface !== "string") {
+      const state = policyState(ctx.history, ctx.findings, {
+        plateauWindow,
+        minDistinctStrategies,
+        minImprovement
+      });
+      const decision = chooseLevel({
+        allowed,
+        available: allowed.filter((level) => !state.exhausted[level]),
+        proposers,
+        state,
+        promptFirst: opts.promptFirst ?? true,
+        parameterBeforeStructural: opts.parameterBeforeStructural ?? true
+      });
+      if (!decision) return [];
+      const proposer = proposers[decision.level];
+      if (!proposer) {
+        throw new Error(`fapoProposer: selected ${decision.level} but no proposer is configured`);
+      }
+      const requested = Math.min(ctx.populationSize, proposalsPerCycle);
+      const raw = await proposer.propose({ ...ctx, populationSize: requested });
+      const wrapped = raw.map((candidate) => normalizeProposal(candidate)).map((candidate) => wrapProposal(candidate, decision.level, decision.reason));
+      const reviewed = [];
+      for (const candidate of wrapped) {
+        const review = opts.reviewCandidate ? await opts.reviewCandidate({
+          level: decision.level,
+          candidate,
+          context: ctx,
+          reason: decision.reason
+        }) : { verdict: "pass" };
+        if (review.verdict === "fail") continue;
+        const warn = review.verdict === "warn" ? renderReviewWarnings(review) : "";
+        reviewed.push(
+          warn ? { ...candidate, rationale: `${candidate.rationale}
+${warn}` } : candidate
+        );
+      }
+      if (wrapped.length > 0 && reviewed.length === 0) {
         throw new Error(
-          "skillOptProposer: surface must be a string skill document (got a CodeSurface). SkillOpt patches text."
+          `fapoProposer: reviewer blocked every ${decision.level} candidate; refusing to evaluate an unreviewed variant`
         );
       }
-      const surface = ctx.currentSurface;
-      const patches = await proposePatches({
-        surface,
-        evidence: evidenceFromHistory(ctx, evidenceK),
-        editBudget: defaultBudget,
-        rejectedBuffer: [],
-        findingsNote: renderAnalystEvidence(ctx.findings, ctx.report) ?? void 0,
-        count: ctx.populationSize,
-        signal: ctx.signal,
-        costLedger: ctx.costLedger ?? directCostLedger,
-        costPhase: ctx.costPhase ?? "search.proposal"
-      });
-      const out = [];
-      const seen = /* @__PURE__ */ new Set();
-      for (const patch of patches) {
-        const { surface: candidate, applied } = applySkillPatch(surface, patch);
-        if (applied === 0 || candidate === surface || seen.has(candidate)) continue;
-        seen.add(candidate);
-        out.push({ surface: candidate, label: patch.label, rationale: patch.rationale });
-        if (out.length >= ctx.populationSize) break;
+      return reviewed;
+    },
+    decide({ history }) {
+      const last = history[history.length - 1];
+      if (last && last.candidates.length === 0) {
+        return { stop: true, reason: "FAPO produced no scoped candidate in the prior generation" };
       }
-      return out;
+      const state = policyState(history, [], {
+        plateauWindow,
+        minDistinctStrategies,
+        minImprovement
+      });
+      const everyAllowedLevelExhausted = allowed.every((level) => state.exhausted[level]);
+      return everyAllowedLevelExhausted ? { stop: true, reason: `all FAPO levels exhausted (${allowed.join(", ")})` } : { stop: false };
     }
   };
 }
-function evidenceFromHistory(ctx, k) {
-  const last = ctx.history.at(-1);
-  if (!last || last.candidates.length === 0) return { weakScenarios: [], weakDimensions: [] };
-  const best = [...last.candidates].sort((a, b) => b.composite - a.composite)[0];
-  if (!best) return { weakScenarios: [], weakDimensions: [] };
-  const weakScenarios = [...best.scenarios].sort((a, b) => a.composite - b.composite).slice(0, k);
-  const weakDimensions = Object.entries(best.dimensions).sort((a, b) => a[1] - b[1]).slice(0, k).map(([dimension, score]) => ({ dimension, score }));
-  return { weakScenarios, weakDimensions };
+function levelProposers(opts) {
+  return {
+    ...opts.proposers ?? {},
+    ...opts.promptProposer ? { prompt: opts.promptProposer } : {},
+    ...opts.parameterProposer ? { parameter: opts.parameterProposer } : {},
+    ...opts.structuralProposer ? { structural: opts.structuralProposer } : {}
+  };
 }
-function buildPatchPrompt(args) {
-  const lines = [
-    `Skill document governs: ${args.target}.`,
-    "",
-    "Current skill document:",
-    "```",
-    args.surface,
-    "```",
-    "",
-    `Propose ${args.count} candidate patch(es). Each patch is a SMALL bundle of`,
-    `at most ${args.editBudget} op(s). Anchors must be verbatim substrings of`,
-    "existing lines. Prefer adding a specific missing rule or sharpening a vague",
-    "one over deleting; never rewrite the whole document."
-  ];
-  if (args.evidence.weakScenarios.length > 0) {
-    lines.push(
-      "",
-      "Weakest scenarios (patch to fix these):",
-      ...args.evidence.weakScenarios.map((s) => `- ${s.scenarioId} (${s.composite.toFixed(2)})`)
-    );
-  }
-  if (args.evidence.weakDimensions.length > 0) {
-    lines.push(
-      "",
-      "Weakest dimensions (what to improve):",
-      ...args.evidence.weakDimensions.map((d) => `- ${d.dimension} (${d.score.toFixed(2)})`)
-    );
-  }
-  if (args.rejectedBuffer.length > 0) {
-    lines.push(
-      "",
-      "Already tried and REJECTED (do not repeat or restate these edits):",
-      ...args.rejectedBuffer.map((e) => `- ${e.label}: ${e.rationale} \u2014 ${e.reason}`)
-    );
-  }
-  if (args.findingsNote) {
-    lines.push("", args.findingsNote);
-  }
-  if (args.metaNote) {
-    lines.push("", `Strategy note from prior epochs: ${args.metaNote}`);
-  }
-  return lines.join("\n");
+function allowedLevels(opts, proposers) {
+  const explicit = opts.scope?.allowedLevels;
+  const forbidden = new Set(opts.scope?.forbiddenLevels ?? []);
+  return FAPO_LEVELS.filter((level) => {
+    if (!proposers[level]) return false;
+    if (forbidden.has(level)) return false;
+    return explicit ? explicit.includes(level) : true;
+  });
 }
-var SkillPatchParseError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "SkillPatchParseError";
-  }
-};
-function parseSkillPatchResponse(raw, maxPatches, editBudget) {
-  let text = raw.trim();
-  if (text.startsWith("```")) text = text.replace(/^```(?:json)?\n?/, "").replace(/\n?```$/, "");
-  const start = text.indexOf("{");
-  const end = text.lastIndexOf("}");
-  if (start < 0 || end <= start) {
-    throw new SkillPatchParseError(
-      `parseSkillPatchResponse: response was not valid JSON (no object found): ${snippet(raw)}`
-    );
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(text.slice(start, end + 1));
-  } catch (err) {
-    throw new SkillPatchParseError(
-      `parseSkillPatchResponse: response was not valid JSON (${err instanceof Error ? err.message : String(err)}): ${snippet(raw)}`
-    );
+function policyState(history, findings, opts) {
+  const attempts = extractAttempts(history);
+  return {
+    attempts,
+    exhausted: {
+      prompt: isLevelExhausted("prompt", attempts, opts),
+      parameter: isLevelExhausted("parameter", attempts, opts),
+      structural: isLevelExhausted("structural", attempts, opts)
+    },
+    signals: extractFapoAttributionSignals(findings)
+  };
+}
+function extractAttempts(history) {
+  const attempts = [];
+  for (const generation of history) {
+    for (const candidate of generation.candidates) {
+      const level = candidateLevel(candidate);
+      if (!level) continue;
+      attempts.push({
+        level,
+        composite: candidate.composite,
+        strategy: candidateStrategy(candidate)
+      });
+    }
   }
-  const rawPatches = Array.isArray(parsed.patches) ? parsed.patches : [];
-  const out = [];
-  for (const rp of rawPatches) {
-    if (typeof rp !== "object" || rp === null) continue;
-    const obj = rp;
-    const ops = Array.isArray(obj.ops) ? obj.ops.map(normalizeOp).filter(isOp) : [];
-    if (ops.length === 0) continue;
-    out.push({
-      label: typeof obj.label === "string" ? obj.label : "patch",
-      rationale: typeof obj.rationale === "string" ? obj.rationale : "",
-      ops: ops.slice(0, editBudget)
-    });
-    if (out.length >= maxPatches) break;
+  return attempts;
+}
+function candidateLevel(candidate) {
+  const label = candidate.label ?? "";
+  const rationale = candidate.rationale ?? "";
+  return parseLevel(label) ?? parseLevel(rationale);
+}
+function parseLevel(text) {
+  const match = /\bfapo:(prompt|parameter|structural)\b/.exec(text);
+  return match ? match[1] : null;
+}
+function candidateStrategy(candidate) {
+  const label = candidate.label ?? candidate.rationale ?? candidate.surfaceHash;
+  return label.replace(/\bfapo:(prompt|parameter|structural):?/g, "").trim() || candidate.surfaceHash;
+}
+function isLevelExhausted(level, attempts, opts) {
+  const own = attempts.filter((attempt) => attempt.level === level);
+  if (own.length < opts.plateauWindow) return false;
+  const distinctStrategies = new Set(own.map((attempt) => attempt.strategy)).size;
+  if (distinctStrategies < opts.minDistinctStrategies) return false;
+  let best = Number.NEGATIVE_INFINITY;
+  let nonImproving = 0;
+  for (const attempt of own) {
+    if (attempt.composite > best + opts.minImprovement) {
+      best = attempt.composite;
+      nonImproving = 0;
+    } else {
+      nonImproving += 1;
+    }
   }
-  return out;
+  return nonImproving >= opts.plateauWindow;
 }
-function normalizeOp(raw) {
-  if (typeof raw !== "object" || raw === null) return null;
-  const o = raw;
-  if (o.op === "add") {
-    if (typeof o.text !== "string") return null;
-    const op = { op: "add", text: o.text };
-    if (typeof o.after === "string") op.after = o.after;
-    return op;
+function chooseLevel(args) {
+  const { available, state } = args;
+  if (available.length === 0) return null;
+  const triedPrompt = state.attempts.some((attempt) => attempt.level === "prompt");
+  if (args.promptFirst && available.includes("prompt") && !triedPrompt) {
+    return {
+      level: "prompt",
+      reason: "prompt-first policy: no prompt-level variant has been tried yet"
+    };
   }
-  if (o.op === "delete") {
-    if (typeof o.anchor !== "string") return null;
-    return { op: "delete", anchor: o.anchor };
+  const supported = available.filter((level) => state.signals.counts[level] > 0);
+  if (supported.includes("prompt")) {
+    return {
+      level: "prompt",
+      reason: `attribution has ${state.signals.counts.prompt} prompt-addressable failure(s)`
+    };
   }
-  if (o.op === "replace") {
-    if (typeof o.anchor !== "string" || typeof o.text !== "string") return null;
-    return { op: "replace", anchor: o.anchor, text: o.text };
+  const strongest = supported.sort(
+    (a, b) => state.signals.counts[b] - state.signals.counts[a] || levelRank(a) - levelRank(b)
+  )[0];
+  if (strongest) {
+    if (strongest === "structural" && args.parameterBeforeStructural && available.includes("parameter") && args.proposers.parameter) {
+      return {
+        level: "parameter",
+        reason: "attribution indicates a non-prompt bottleneck; trying parameter/config edits before structural edits"
+      };
+    }
+    return {
+      level: strongest,
+      reason: `attribution has ${state.signals.counts[strongest]} ${strongest}-addressable failure(s)`
+    };
+  }
+  if (state.attempts.length === 0) {
+    const first = available.slice().sort((a, b) => levelRank(a) - levelRank(b))[0];
+    return { level: first, reason: "no attribution yet; starting at the cheapest allowed level" };
   }
   return null;
 }
-function isOp(op) {
-  return op !== null;
+function levelRank(level) {
+  return level === "prompt" ? 0 : level === "parameter" ? 1 : 2;
 }
-function snippet(s, max = 120) {
-  const t = s.trim().replace(/\s+/g, " ");
-  return t.length <= max ? t : `${t.slice(0, max)}\u2026`;
+function normalizeProposal(value) {
+  return isProposedCandidate(value) ? value : { surface: value, label: "candidate", rationale: "bare candidate from level proposer" };
 }
-
-// src/campaign/presets/compare-optimization-methods.ts
-import { randomUUID } from "crypto";
-async function compareOptimizationMethods(opts) {
-  assertOptimizationMethods(opts.methods);
-  assertComparisonPartitions(opts);
-  const seed = opts.seed ?? 42;
-  const confidence = opts.confidence ?? 0.95;
-  assertConfidence(confidence);
-  const optimizationConcurrency = opts.optimizationConcurrency ?? 1;
-  const comparisonCount = opts.methods.length * (opts.methods.length + 1) / 2;
-  const intervalConfidence = 1 - (1 - confidence) / comparisonCount;
-  const minimumResamples = minimumBootstrapResamples(confidence, comparisonCount);
-  const resamples = opts.resamples ?? Math.max(2e3, minimumResamples);
-  assertComparisonControls(opts, seed, resamples, confidence);
-  const storage = opts.storage ?? fsCampaignStorage();
-  const resolvedRunDir = resolveRunDir(opts.runDir, opts.repo);
-  const testCostPhase = `compareOptimizationMethods:test:${randomUUID()}`;
-  const testCostLedger = opts.costLedger ?? createRunCostLedger({
-    storage,
-    runDir: `${resolvedRunDir}/test/cost`,
-    costCeilingUsd: opts.costCeiling
-  });
-  const scoreOnTest = async (surface, tag) => {
-    const campaign = await runCampaign({
-      ...opts,
-      storage,
-      costLedger: testCostLedger,
-      costPhase: testCostPhase,
-      scenarios: opts.testScenarios.map((scenario) => structuredClone(scenario)),
-      dispatch: (scenario, ctx) => opts.dispatchWithSurface(surface, scenario, ctx),
-      runDir: `${resolvedRunDir}/${tag}`
-    });
-    const byScenario = {};
-    for (const { scenarioId, composite } of campaignBreakdown(campaign).scenarios) {
-      byScenario[scenarioId] = composite;
-    }
-    return byScenario;
+function wrapProposal(candidate, level, reason) {
+  const label = candidate.label ? `fapo:${level}:${candidate.label}` : `fapo:${level}`;
+  return {
+    ...candidate,
+    label,
+    rationale: [
+      `fapo:${level} selected by reviewed escalation policy`,
+      `Reason: ${reason}`,
+      candidate.rationale ? `Level proposer rationale: ${candidate.rationale}` : ""
+    ].filter(Boolean).join("\n")
   };
-  const scenarioIds = opts.testScenarios.map((s) => s.id).sort();
-  const align = (byScenario, label) => {
-    const missing = scenarioIds.filter((id) => !(id in byScenario));
-    if (missing.length > 0) {
-      throw new Error(
-        `compareOptimizationMethods: ${label} produced no test score for scenario(s) [${missing.join(
-          ", "
-        )}]. A cell failed or its judges returned nothing. Fix the dispatch or judge; the comparison will not replace missing scores with zero.`
-      );
-    }
-    return scenarioIds.map((id) => byScenario[id]);
+}
+function renderReviewWarnings(review) {
+  const issues = review.issues?.filter((issue) => issue.severity === "warn") ?? [];
+  if (issues.length === 0) return "";
+  return `Reviewer warnings:
+${issues.map((issue) => `- ${issue.checkName}: ${issue.description}`).join("\n")}`;
+}
+function extractFapoAttributionSignals(findings) {
+  const signals = {
+    counts: { prompt: 0, parameter: 0, structural: 0 },
+    clusters: []
   };
-  const optimized = await mapConcurrent(opts.methods, optimizationConcurrency, async (method) => {
-    const out = await method.optimize(
-      createOptimizationMethodInput(opts, method.name, resolvedRunDir, seed)
-    );
-    assertOptimizationResult(method.name, out);
-    const winnerSurface = structuredClone(out.winnerSurface);
-    return {
-      name: method.name,
-      winnerSurface,
-      cost: out.cost,
-      durationMs: out.durationMs
-    };
-  });
-  const baselineArr = align(await scoreOnTest(opts.baselineSurface, "test/baseline"), "baseline");
-  const testScoresBySurface = /* @__PURE__ */ new Map([[surfaceContentHash(opts.baselineSurface), baselineArr]]);
-  const winners = [];
-  for (const winner of optimized) {
-    const surfaceKey = surfaceContentHash(winner.winnerSurface);
-    let arr = testScoresBySurface.get(surfaceKey);
-    if (!arr) {
-      const byScenario = await scoreOnTest(
-        winner.winnerSurface,
-        `test/methods/${slug(winner.name)}`
-      );
-      arr = align(byScenario, `method "${winner.name}"`);
-      testScoresBySurface.set(surfaceKey, arr);
-    }
-    winners.push({
-      ...winner,
-      arr
-    });
+  const seen = /* @__PURE__ */ new WeakSet();
+  for (const finding of findings) {
+    collectFinding(signals, finding, seen, 0);
   }
-  const scores = winners.map((w) => {
-    const boot = pairedBootstrap(baselineArr, w.arr, {
-      seed,
-      resamples,
-      confidence: intervalConfidence,
-      statistic: "mean"
+  return signals;
+}
+function collectFinding(signals, finding, seen, depth) {
+  if (depth > MAX_FINDING_DEPTH) return;
+  if (!finding) return;
+  if (typeof finding === "string") {
+    const level = inferLevelFromText(finding);
+    if (level) addCluster(signals, { label: finding, level, count: 1 });
+    return;
+  }
+  if (Array.isArray(finding)) {
+    if (seen.has(finding)) return;
+    seen.add(finding);
+    for (const item of finding) collectFinding(signals, item, seen, depth + 1);
+    return;
+  }
+  if (typeof finding !== "object") return;
+  if (seen.has(finding)) return;
+  seen.add(finding);
+  const obj = finding;
+  collectLevelPartition(signals, obj.level_partition ?? obj.levelPartition, seen, depth + 1);
+  collectCounts(signals, obj);
+  collectClusters(signals, obj.clusters, true, seen, depth + 1);
+  const explicit = parseFindingLevel(obj.level ?? obj.optimization_level ?? obj.optimizationLevel);
+  const text = textFields(obj);
+  const inferred = explicit ?? inferLevelFromText(text);
+  if (inferred) {
+    addCluster(signals, {
+      label: text || inferred,
+      level: inferred,
+      count: numberField(obj.count) ?? 1,
+      confidence: confidenceField(obj.confidence),
+      suggestedFix: stringField(obj.suggested_fix ?? obj.suggestedFix ?? obj.recommended_action),
+      caseIds: stringArrayField(obj.case_ids ?? obj.caseIds)
     });
-    const score = {
-      name: w.name,
-      baselineComposite: mean2(baselineArr),
-      winnerComposite: mean2(w.arr),
-      lift: boot.mean,
-      liftCi: { low: boot.low, high: boot.high },
-      optimizationCost: w.cost,
-      scenarioScores: scenarioIds.map((scenarioId, index) => ({
-        scenarioId,
-        baselineComposite: baselineArr[index],
-        winnerComposite: w.arr[index],
-        lift: w.arr[index] - baselineArr[index]
-      })),
-      winnerSurface: w.winnerSurface,
-      rank: 0
-    };
-    if (w.durationMs !== void 0) score.durationMs = w.durationMs;
-    return score;
-  });
-  scores.sort((a, b) => b.lift - a.lift);
-  for (let start = 0; start < scores.length; ) {
-    let end = start + 1;
-    while (end < scores.length && scores[end].lift === scores[start].lift) end += 1;
-    const tied = scores.slice(start, end);
-    if (tied.every((score) => score.optimizationCost.accountingComplete)) {
-      tied.sort((a, b) => a.optimizationCost.totalCostUsd - b.optimizationCost.totalCostUsd);
-      scores.splice(start, tied.length, ...tied);
+  }
+}
+function collectLevelPartition(signals, raw, seen, depth) {
+  if (!raw || typeof raw !== "object") return;
+  if (seen.has(raw)) return;
+  seen.add(raw);
+  const partition = raw;
+  for (const level of FAPO_LEVELS) {
+    const bucket = partition[level];
+    if (!bucket || typeof bucket !== "object") continue;
+    const obj = bucket;
+    const count = numberField(obj.count) ?? 0;
+    if (count > 0) signals.counts[level] += count;
+    collectClusters(signals, obj.clusters, false, seen, depth + 1);
+  }
+}
+function collectCounts(signals, obj) {
+  const prompt = numberField(obj.prompt_addressable ?? obj.promptAddressable);
+  const structural = numberField(obj.structural_addressable ?? obj.structuralAddressable);
+  const tool = numberField(obj.tool_addressable ?? obj.toolAddressable);
+  if (prompt) signals.counts.prompt += prompt;
+  if (structural) signals.counts.structural += structural;
+  if (tool) signals.counts.structural += tool;
+}
+function collectClusters(signals, raw, countClusters, seen, depth) {
+  if (!Array.isArray(raw)) return;
+  if (seen.has(raw)) return;
+  seen.add(raw);
+  for (const item of raw) {
+    if (countClusters) {
+      collectFinding(signals, item, seen, depth + 1);
+      continue;
     }
-    start = end;
+    const cluster = parseCluster(item);
+    if (cluster) signals.clusters.push(cluster);
   }
-  scores.forEach((s, i) => {
-    s.rank = i + 1;
-  });
-  const best = scores[0];
-  const byName = new Map(winners.map((w) => [w.name, w]));
-  const bestArr = byName.get(best.name).arr;
-  const pairwise = scores.slice(1).map((other) => {
-    const otherArr = byName.get(other.name).arr;
-    const boot = pairedBootstrap(otherArr, bestArr, {
-      seed,
-      resamples,
-      confidence: intervalConfidence,
-      statistic: "mean"
-    });
-    const favored = boot.low > 0 ? best.name : boot.high < 0 ? other.name : "tie";
-    return {
-      a: best.name,
-      b: other.name,
-      deltaMean: boot.mean,
-      low: boot.low,
-      high: boot.high,
-      favored
-    };
-  });
-  const optimizationCost = combineCosts(
-    scores.map((score) => ({ label: `method '${score.name}'`, cost: score.optimizationCost }))
-  );
-  const testCost = costFromLedgerSummary(testCostLedger.summary({ phase: testCostPhase }));
-  const totalCost = combineCosts([
-    { label: "optimization", cost: optimizationCost },
-    { label: "final test", cost: testCost }
-  ]);
+}
+function addCluster(signals, cluster) {
+  signals.counts[cluster.level] += Math.max(1, cluster.count);
+  signals.clusters.push(cluster);
+}
+function parseCluster(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const obj = raw;
+  const text = textFields(obj);
+  const level = parseFindingLevel(obj.level ?? obj.optimization_level ?? obj.optimizationLevel) ?? inferLevelFromText(text);
+  if (!level) return null;
   return {
-    scores,
-    best,
-    pairwise,
-    testScenarioIds: scenarioIds,
-    optimizationCost,
-    testCost,
-    totalCost,
-    confidence,
-    intervalConfidence,
-    comparisonCount,
-    seed,
-    resamples,
-    reps: opts.reps ?? 1
+    label: text || level,
+    level,
+    count: numberField(obj.count) ?? 1,
+    confidence: confidenceField(obj.confidence),
+    suggestedFix: stringField(obj.suggested_fix ?? obj.suggestedFix ?? obj.recommended_action),
+    caseIds: stringArrayField(obj.case_ids ?? obj.caseIds)
   };
 }
-function assertOptimizationMethods(methods) {
-  if (!Array.isArray(methods) || methods.length === 0) {
-    throw new Error("compareOptimizationMethods: no methods to compare");
+function parseFindingLevel(raw) {
+  if (typeof raw !== "string") return null;
+  const lower = raw.toLowerCase();
+  if (lower === "prompt" || lower === "parameter" || lower === "structural") return lower;
+  if (lower === "chain" || lower === "tool" || lower === "code") return "structural";
+  if (lower === "config" || lower === "params") return "parameter";
+  return null;
+}
+function inferLevelFromText(text) {
+  const lower = text.toLowerCase();
+  if (/\b(retrieval_k|temperature|top_p|max_tokens|max_completion_tokens|reasoning_effort|config|parameter)\b/.test(
+    lower
+  )) {
+    return "parameter";
   }
-  const names = /* @__PURE__ */ new Set();
-  const pathOwners = /* @__PURE__ */ new Map();
-  for (const method of methods) {
-    if (!method || typeof method !== "object" || typeof method.optimize !== "function") {
-      throw new Error("compareOptimizationMethods: every method must provide optimize(input)");
-    }
-    if (!method.name || method.name.trim() !== method.name) {
-      throw new Error("compareOptimizationMethods: method names must be trimmed and non-empty");
-    }
-    if (names.has(method.name)) {
-      throw new Error(`compareOptimizationMethods: duplicate method name '${method.name}'`);
-    }
-    names.add(method.name);
-    const pathKey = slug(method.name);
-    const prior = pathOwners.get(pathKey);
-    if (prior) {
-      throw new Error(
-        `compareOptimizationMethods: method names '${prior}' and '${method.name}' map to the same run path '${pathKey}'`
-      );
+  if (/\b(retriev\w*|search\w*|bm25|hop|evidence|cascade|tool|node|chain|state|structur\w*|topology|import)\b/.test(
+    lower
+  )) {
+    return "structural";
+  }
+  if (/\b(format\w*|verbose|brevity|abstain\w*|reasoning|instruction|prompt|output|answer)\b/.test(
+    lower
+  )) {
+    return "prompt";
+  }
+  return null;
+}
+function textFields(obj) {
+  return [
+    obj.label,
+    obj.claim,
+    obj.recommended_action,
+    obj.suggested_fix,
+    obj.suggestedFix,
+    obj.message,
+    obj.text,
+    obj.heuristic,
+    obj.area
+  ].filter((value) => typeof value === "string" && value.trim().length > 0).join(" ");
+}
+function numberField(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function stringField(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function confidenceField(value) {
+  return value === "high" || value === "medium" || value === "low" ? value : void 0;
+}
+function stringArrayField(value) {
+  return Array.isArray(value) ? value.filter((item) => typeof item === "string") : void 0;
+}
+function parameterSweepProposer(opts) {
+  if (opts.candidates.length === 0) {
+    throw new Error("parameterSweepProposer: candidates must not be empty");
+  }
+  return {
+    kind: "parameter-sweep",
+    async propose(ctx) {
+      if (typeof ctx.currentSurface !== "string") {
+        throw new Error(
+          "parameterSweepProposer: currentSurface must be a JSON string config surface"
+        );
+      }
+      const parse = opts.parse ?? parseJsonObject;
+      const stringify = opts.stringify ?? ((config) => JSON.stringify(config, null, 2));
+      const current = parse(ctx.currentSurface);
+      const currentCanonical = canonicalJson2(current);
+      const tried = triedLabels(ctx.history);
+      const out = [];
+      for (const candidate of opts.candidates) {
+        if (tried.has(candidate.label)) continue;
+        const next = applyParameterCandidate(current, candidate);
+        const surface = stringify(next);
+        if (surface === ctx.currentSurface || canonicalJson2(next) === currentCanonical) continue;
+        out.push({ surface, label: candidate.label, rationale: candidate.rationale });
+        if (out.length >= ctx.populationSize) break;
+      }
+      return out;
     }
-    pathOwners.set(pathKey, method.name);
-  }
+  };
 }
-function assertOptimizationResult(name, result) {
-  if (!result || typeof result !== "object") {
-    throw new Error(`compareOptimizationMethods: method '${name}' returned no result`);
-  }
+function parseJsonObject(surface) {
+  let parsed;
   try {
-    surfaceContentHash(result.winnerSurface);
-  } catch (cause) {
+    parsed = JSON.parse(surface);
+  } catch (error) {
     throw new Error(
-      `compareOptimizationMethods: method '${name}' returned an invalid winnerSurface`,
-      { cause }
+      `parameterSweepProposer: currentSurface must be valid JSON object config (${error instanceof Error ? error.message : String(error)})`
     );
   }
-  assertComparisonCost(result.cost, `method '${name}'`);
-  if (result.durationMs !== void 0 && (!Number.isFinite(result.durationMs) || result.durationMs < 0)) {
-    throw new Error(`compareOptimizationMethods: method '${name}' returned an invalid durationMs`);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error("parameterSweepProposer: JSON surface must parse to an object");
   }
+  return parsed;
 }
-function assertComparisonControls(opts, seed, resamples, confidence) {
-  if (!opts.judges || opts.judges.length === 0) {
-    throw new Error("compareOptimizationMethods: at least one judge is required");
-  }
-  if (typeof opts.dispatchWithSurface !== "function") {
-    throw new Error("compareOptimizationMethods: dispatchWithSurface must be a function");
+function triedLabels(history) {
+  const tried = /* @__PURE__ */ new Set();
+  for (const generation of history) {
+    for (const candidate of generation.candidates) {
+      if (!candidate.label) continue;
+      tried.add(candidate.label);
+      tried.add(candidateStrategy(candidate));
+    }
   }
-  try {
-    surfaceContentHash(opts.baselineSurface);
-  } catch (cause) {
-    throw new Error("compareOptimizationMethods: baselineSurface is invalid", { cause });
+  return tried;
+}
+function applyParameterCandidate(current, candidate) {
+  const next = cloneJsonObject(current);
+  if (candidate.patch) deepMerge(next, candidate.patch);
+  for (const change of candidate.changes ?? []) {
+    setPath(
+      next,
+      typeof change.path === "string" ? change.path.split(".") : [...change.path],
+      change.value
+    );
   }
-  const judgeNames = /* @__PURE__ */ new Set();
-  for (const judge of opts.judges) {
-    if (!judge || typeof judge !== "object" || typeof judge.name !== "string" || judge.name.trim().length === 0 || judge.name.trim() !== judge.name || typeof judge.score !== "function" || !Array.isArray(judge.dimensions) || judge.dimensions.length === 0) {
-      throw new Error(
-        "compareOptimizationMethods: every judge needs a trimmed name, at least one dimension, and score(input)"
-      );
+  return next;
+}
+function cloneJsonObject(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+function deepMerge(target, patch) {
+  for (const [key, value] of Object.entries(patch)) {
+    assertSafeJsonKey(key);
+    if (isPlainObject(value) && isPlainObject(target[key])) {
+      deepMerge(target[key], value);
+    } else {
+      target[key] = value;
     }
-    if (judgeNames.has(judge.name)) {
-      throw new Error(`compareOptimizationMethods: duplicate judge name '${judge.name}'`);
+  }
+}
+function setPath(target, path, value) {
+  if (path.length === 0) throw new Error("parameterSweepProposer: change path must not be empty");
+  for (const part of path) assertSafeJsonKey(part);
+  let cursor = target;
+  for (const part of path.slice(0, -1)) {
+    const existing = cursor[part];
+    if (!isPlainObject(existing)) {
+      cursor[part] = {};
     }
-    judgeNames.add(judge.name);
-    const dimensionKeys = /* @__PURE__ */ new Set();
-    for (const dimension of judge.dimensions) {
-      if (!dimension || typeof dimension.key !== "string" || dimension.key.trim().length === 0 || dimension.key.trim() !== dimension.key || typeof dimension.description !== "string" || dimension.description.trim().length === 0) {
-        throw new Error(
-          `compareOptimizationMethods: judge '${judge.name}' has an invalid dimension`
-        );
+    cursor = cursor[part];
+  }
+  cursor[path[path.length - 1]] = value;
+}
+function assertSafeJsonKey(key) {
+  if (!key.trim()) throw new Error("parameterSweepProposer: change path contains an empty key");
+  if (UNSAFE_JSON_KEYS.has(key)) {
+    throw new Error(`parameterSweepProposer: unsafe JSON key "${key}" is not allowed`);
+  }
+}
+function canonicalJson2(value) {
+  if (Array.isArray(value)) return `[${value.map((item) => canonicalJson2(item)).join(",")}]`;
+  if (isPlainObject(value)) {
+    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson2(value[key])}`).join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+function isPlainObject(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+
+// src/campaign/skill-patch.ts
+function applySkillPatch(surface, patch) {
+  let lines = surface.split("\n");
+  let applied = 0;
+  const rejected = [];
+  const findLine = (anchor) => lines.findIndex((l) => l.includes(anchor));
+  for (const op of patch.ops) {
+    if (op.op === "add") {
+      if (typeof op.text !== "string" || op.text.trim() === "") {
+        rejected.push({ op, reason: "empty add text" });
+        continue;
       }
-      if (dimensionKeys.has(dimension.key)) {
-        throw new Error(
-          `compareOptimizationMethods: judge '${judge.name}' has duplicate dimension '${dimension.key}'`
-        );
+      const insert = op.text.split("\n");
+      if (op.after === void 0 || op.after === "") {
+        lines = [...lines, ...insert];
+        applied++;
+        continue;
       }
-      dimensionKeys.add(dimension.key);
+      const idx = findLine(op.after);
+      if (idx === -1) {
+        rejected.push({ op, reason: `add anchor not found: ${truncate2(op.after)}` });
+        continue;
+      }
+      lines = [...lines.slice(0, idx + 1), ...insert, ...lines.slice(idx + 1)];
+      applied++;
+    } else if (op.op === "delete") {
+      const idx = findLine(op.anchor);
+      if (idx === -1) {
+        rejected.push({ op, reason: `delete anchor not found: ${truncate2(op.anchor)}` });
+        continue;
+      }
+      lines = [...lines.slice(0, idx), ...lines.slice(idx + 1)];
+      applied++;
+    } else {
+      const idx = findLine(op.anchor);
+      if (idx === -1) {
+        rejected.push({ op, reason: `replace anchor not found: ${truncate2(op.anchor)}` });
+        continue;
+      }
+      if (typeof op.text !== "string") {
+        rejected.push({ op, reason: "replace text missing" });
+        continue;
+      }
+      lines = [...lines.slice(0, idx), ...op.text.split("\n"), ...lines.slice(idx + 1)];
+      applied++;
     }
   }
-  if (typeof opts.runDir !== "string" || opts.runDir.trim().length === 0) {
-    throw new Error("compareOptimizationMethods: runDir must be a non-empty string");
-  }
-  if (!Number.isSafeInteger(seed)) {
-    throw new Error(`compareOptimizationMethods: seed must be a safe integer, got ${String(seed)}`);
+  return { surface: lines.join("\n"), applied, rejected };
+}
+function patchEditCount(patch) {
+  return patch.ops.length;
+}
+function truncate2(s, max = 48) {
+  return s.length <= max ? s : `${s.slice(0, max)}\u2026`;
+}
+
+// src/campaign/proposers/skill-opt.ts
+var SKILLOPT_SYSTEM = 'You are a SkillOpt optimizer. You improve ONE skill document by proposing BOUNDED, anchored edits \u2014 never a full rewrite. Output ONLY a JSON object of shape {"patches":[{"label":string,"rationale":string,"ops":[op,...]}]} where each op is one of: {"op":"add","after":<exact substring of an existing line, or omit to append>,"text":<new line(s)>}, {"op":"delete","anchor":<exact substring of the line to remove>}, {"op":"replace","anchor":<exact substring of the line to replace>,"text":<replacement line(s)>}. Anchors MUST be verbatim substrings of lines that exist in the document. No prose outside JSON.';
+function skillOptProposer(opts) {
+  const evidenceK = opts.evidenceK ?? 3;
+  const defaultBudget = opts.editBudget ?? 3;
+  const directCostLedger = opts.costLedger ?? new CostLedger();
+  async function proposePatches(args) {
+    const userPrompt = buildPatchPrompt({
+      target: opts.target,
+      surface: args.surface,
+      evidence: args.evidence,
+      editBudget: args.editBudget,
+      rejectedBuffer: args.rejectedBuffer,
+      metaNote: args.metaNote,
+      findingsNote: args.findingsNote,
+      count: args.count
+    });
+    const request = {
+      model: opts.model,
+      messages: [
+        { role: "system", content: SKILLOPT_SYSTEM },
+        { role: "user", content: userPrompt }
+      ],
+      jsonMode: true,
+      temperature: opts.temperature ?? 0.6,
+      maxTokens: opts.maxTokens ?? 4e3
+    };
+    const paid = await (args.costLedger ?? directCostLedger).runPaidCall({
+      channel: "driver",
+      phase: args.costPhase ?? "search.proposal",
+      actor: "skill-opt.propose",
+      model: opts.model,
+      maximumCharge: maximumChargeForLlmRequest(request, opts.llm),
+      signal: args.signal,
+      execute: (signal, callId) => callLlm(request, { ...opts.llm, signal, idempotencyKey: callId }),
+      receipt: costReceiptFromLlm,
+      receiptFromError: costReceiptFromLlmError
+    });
+    if (!paid.succeeded) throw paid.error;
+    const result = paid.value;
+    return parseSkillPatchResponse(result.content, args.count, args.editBudget);
   }
-  if (!Number.isSafeInteger(resamples) || resamples <= 0 || resamples > 1e6) {
-    throw new Error(
-      `compareOptimizationMethods: resamples must be a positive safe integer no greater than 1000000, got ${String(resamples)}`
+  return {
+    kind: "skill-opt",
+    proposePatches,
+    async propose(ctx) {
+      if (typeof ctx.currentSurface !== "string") {
+        throw new Error(
+          "skillOptProposer: surface must be a string skill document (got a CodeSurface). SkillOpt patches text."
+        );
+      }
+      const surface = ctx.currentSurface;
+      const patches = await proposePatches({
+        surface,
+        evidence: evidenceFromHistory(ctx, evidenceK),
+        editBudget: defaultBudget,
+        rejectedBuffer: [],
+        findingsNote: renderAnalystEvidence(ctx.findings, ctx.report) ?? void 0,
+        count: ctx.populationSize,
+        signal: ctx.signal,
+        costLedger: ctx.costLedger ?? directCostLedger,
+        costPhase: ctx.costPhase ?? "search.proposal"
+      });
+      const out = [];
+      const seen = /* @__PURE__ */ new Set();
+      for (const patch of patches) {
+        const { surface: candidate, applied } = applySkillPatch(surface, patch);
+        if (applied === 0 || candidate === surface || seen.has(candidate)) continue;
+        seen.add(candidate);
+        out.push({ surface: candidate, label: patch.label, rationale: patch.rationale });
+        if (out.length >= ctx.populationSize) break;
+      }
+      return out;
+    }
+  };
+}
+function evidenceFromHistory(ctx, k) {
+  const last = ctx.history.at(-1);
+  if (!last || last.candidates.length === 0) return { weakScenarios: [], weakDimensions: [] };
+  const best = [...last.candidates].sort((a, b) => b.composite - a.composite)[0];
+  if (!best) return { weakScenarios: [], weakDimensions: [] };
+  const weakScenarios = [...best.scenarios].sort((a, b) => a.composite - b.composite).slice(0, k);
+  const weakDimensions = Object.entries(best.dimensions).sort((a, b) => a[1] - b[1]).slice(0, k).map(([dimension, score]) => ({ dimension, score }));
+  return { weakScenarios, weakDimensions };
+}
+function buildPatchPrompt(args) {
+  const lines = [
+    `Skill document governs: ${args.target}.`,
+    "",
+    "Current skill document:",
+    "```",
+    args.surface,
+    "```",
+    "",
+    `Propose ${args.count} candidate patch(es). Each patch is a SMALL bundle of`,
+    `at most ${args.editBudget} op(s). Anchors must be verbatim substrings of`,
+    "existing lines. Prefer adding a specific missing rule or sharpening a vague",
+    "one over deleting; never rewrite the whole document."
+  ];
+  if (args.evidence.weakScenarios.length > 0) {
+    lines.push(
+      "",
+      "Weakest scenarios (patch to fix these):",
+      ...args.evidence.weakScenarios.map((s) => `- ${s.scenarioId} (${s.composite.toFixed(2)})`)
     );
   }
-  if (!Number.isFinite(confidence) || confidence <= 0 || confidence >= 1) {
-    throw new Error(
-      `compareOptimizationMethods: confidence must be a finite number in (0,1), got ${String(confidence)}`
+  if (args.evidence.weakDimensions.length > 0) {
+    lines.push(
+      "",
+      "Weakest dimensions (what to improve):",
+      ...args.evidence.weakDimensions.map((d) => `- ${d.dimension} (${d.score.toFixed(2)})`)
     );
   }
-  const minimumResamples = minimumBootstrapResamples(
-    confidence,
-    opts.methods.length * (opts.methods.length + 1) / 2
-  );
-  if (resamples < minimumResamples) {
-    throw new Error(
-      `compareOptimizationMethods: resamples must be at least ${minimumResamples} for simultaneous confidence ${confidence} across ${opts.methods.length} methods, got ${resamples}`
+  if (args.rejectedBuffer.length > 0) {
+    lines.push(
+      "",
+      "Already tried and REJECTED (do not repeat or restate these edits):",
+      ...args.rejectedBuffer.map((e) => `- ${e.label}: ${e.rationale} \u2014 ${e.reason}`)
     );
   }
-  if (opts.optimizationConcurrency !== void 0 && (!Number.isSafeInteger(opts.optimizationConcurrency) || opts.optimizationConcurrency <= 0)) {
-    throw new Error(
-      "compareOptimizationMethods: optimizationConcurrency must be a positive safe integer"
-    );
+  if (args.findingsNote) {
+    lines.push("", args.findingsNote);
   }
-  if (opts.maxConcurrency !== void 0 && (!Number.isSafeInteger(opts.maxConcurrency) || opts.maxConcurrency <= 0)) {
-    throw new Error("compareOptimizationMethods: maxConcurrency must be a positive safe integer");
+  if (args.metaNote) {
+    lines.push("", `Strategy note from prior epochs: ${args.metaNote}`);
   }
-  if (opts.dispatchTimeoutMs !== void 0 && (!Number.isSafeInteger(opts.dispatchTimeoutMs) || opts.dispatchTimeoutMs < 0 || opts.dispatchTimeoutMs > 2147483647)) {
-    throw new Error(
-      "compareOptimizationMethods: dispatchTimeoutMs must be a non-negative safe integer no greater than 2147483647"
-    );
+  return lines.join("\n");
+}
+var SkillPatchParseError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SkillPatchParseError";
   }
-  if (opts.costCeiling !== void 0 && (!Number.isFinite(opts.costCeiling) || opts.costCeiling < 0)) {
-    throw new Error(
-      "compareOptimizationMethods: costCeiling must be a finite number greater than or equal to 0"
+};
+function parseSkillPatchResponse(raw, maxPatches, editBudget) {
+  let text = raw.trim();
+  if (text.startsWith("```")) text = text.replace(/^```(?:json)?\n?/, "").replace(/\n?```$/, "");
+  const start = text.indexOf("{");
+  const end = text.lastIndexOf("}");
+  if (start < 0 || end <= start) {
+    throw new SkillPatchParseError(
+      `parseSkillPatchResponse: response was not valid JSON (no object found): ${snippet(raw)}`
     );
   }
-  if (opts.costCeiling !== void 0 && opts.costLedger !== void 0 && opts.costLedger.costCeilingUsd !== opts.costCeiling) {
-    throw new Error(
-      "compareOptimizationMethods: costCeiling must match the shared CostLedger ceiling"
+  let parsed;
+  try {
+    parsed = JSON.parse(text.slice(start, end + 1));
+  } catch (err) {
+    throw new SkillPatchParseError(
+      `parseSkillPatchResponse: response was not valid JSON (${err instanceof Error ? err.message : String(err)}): ${snippet(raw)}`
     );
   }
+  const rawPatches = Array.isArray(parsed.patches) ? parsed.patches : [];
+  const out = [];
+  for (const rp of rawPatches) {
+    if (typeof rp !== "object" || rp === null) continue;
+    const obj = rp;
+    const ops = Array.isArray(obj.ops) ? obj.ops.map(normalizeOp).filter(isOp) : [];
+    if (ops.length === 0) continue;
+    out.push({
+      label: typeof obj.label === "string" ? obj.label : "patch",
+      rationale: typeof obj.rationale === "string" ? obj.rationale : "",
+      ops: ops.slice(0, editBudget)
+    });
+    if (out.length >= maxPatches) break;
+  }
+  return out;
 }
-function assertComparisonPartitions(opts) {
-  const legacy = opts;
-  if (legacy.holdoutScenarios !== void 0) {
-    throw new Error(
-      "compareOptimizationMethods: holdoutScenarios is ambiguous and no longer accepted. Provide disjoint trainScenarios, selectionScenarios, and testScenarios; selection may be reused adaptively, test must remain untouched."
-    );
+function normalizeOp(raw) {
+  if (typeof raw !== "object" || raw === null) return null;
+  const o = raw;
+  if (o.op === "add") {
+    if (typeof o.text !== "string") return null;
+    const op = { op: "add", text: o.text };
+    if (typeof o.after === "string") op.after = o.after;
+    return op;
   }
-  const partitions = [
-    { name: "trainScenarios", scenarios: opts.trainScenarios },
-    { name: "selectionScenarios", scenarios: opts.selectionScenarios },
-    { name: "testScenarios", scenarios: opts.testScenarios }
-  ];
-  const owner = /* @__PURE__ */ new Map();
-  for (const partition of partitions) {
-    if (!Array.isArray(partition.scenarios) || partition.scenarios.length === 0) {
-      throw new Error(`compareOptimizationMethods: ${partition.name} is empty`);
-    }
-    if (partition.name === "testScenarios" && partition.scenarios.length < 2) {
-      throw new Error(
-        "compareOptimizationMethods: testScenarios requires at least 2 scenarios to estimate uncertainty"
-      );
-    }
-    const local = /* @__PURE__ */ new Set();
-    const duplicates = /* @__PURE__ */ new Set();
-    const overlaps = /* @__PURE__ */ new Map();
-    for (const scenario of partition.scenarios) {
-      if (local.has(scenario.id)) duplicates.add(scenario.id);
-      local.add(scenario.id);
-      const prior = owner.get(scenario.id);
-      if (prior !== void 0 && prior !== partition.name) overlaps.set(scenario.id, prior);
-    }
-    if (duplicates.size > 0) {
-      throw new Error(
-        `compareOptimizationMethods: ${partition.name} contains duplicate scenario id(s) [${[
-          ...duplicates
-        ].join(", ")}]`
-      );
-    }
-    if (overlaps.size > 0) {
-      const detail = [...overlaps].map(([id, prior]) => `${id} (${prior} \u2229 ${partition.name})`).join(", ");
-      throw new Error(
-        `compareOptimizationMethods: trainScenarios, selectionScenarios, and testScenarios must be pairwise disjoint; overlap: [${detail}]`
-      );
-    }
-    assertCampaignDesign(partition.scenarios, opts.reps ?? 1);
-    for (const id of local) owner.set(id, partition.name);
+  if (o.op === "delete") {
+    if (typeof o.anchor !== "string") return null;
+    return { op: "delete", anchor: o.anchor };
   }
-}
-function mean2(xs) {
-  return xs.length === 0 ? 0 : xs.reduce((a, b) => a + b, 0) / xs.length;
-}
-function slug(name) {
-  return name.replace(/[^a-z0-9]+/gi, "-").replace(/^-|-$/g, "").toLowerCase() || "method";
-}
-function assertConfidence(confidence) {
-  if (!Number.isFinite(confidence) || confidence <= 0 || confidence >= 1) {
-    throw new Error(
-      `compareOptimizationMethods: confidence must be a finite number in (0,1), got ${String(confidence)}`
-    );
+  if (o.op === "replace") {
+    if (typeof o.anchor !== "string" || typeof o.text !== "string") return null;
+    return { op: "replace", anchor: o.anchor, text: o.text };
   }
+  return null;
 }
-function minimumBootstrapResamples(confidence, comparisonCount) {
-  const exact = 2 * comparisonCount / (1 - confidence);
-  return Math.ceil(exact - Number.EPSILON * Math.max(1, exact) * 32);
-}
-function createOptimizationMethodInput(opts, methodName, resolvedRunDir, seed) {
-  const cloneScenarios = (scenarios) => Object.freeze(scenarios.map((scenario) => structuredClone(scenario)));
-  const judges = opts.judges.map(
-    (judge) => Object.freeze({
-      ...judge,
-      dimensions: Object.freeze(
-        judge.dimensions.map((dimension) => Object.freeze({ ...dimension }))
-      )
-    })
-  );
-  return Object.freeze({
-    baselineSurface: structuredClone(opts.baselineSurface),
-    trainScenarios: cloneScenarios(opts.trainScenarios),
-    selectionScenarios: cloneScenarios(opts.selectionScenarios),
-    dispatchWithSurface: opts.dispatchWithSurface,
-    judges: Object.freeze(judges),
-    runDir: `${resolvedRunDir}/optimization/${slug(methodName)}`,
-    seed,
-    runOptions: Object.freeze({ ...opts.optimizationRunOptions ?? {} })
-  });
-}
-function costFromLedgerSummary(summary) {
-  const cost = {
-    totalCostUsd: summary.totalCostUsd,
-    accountingComplete: summary.accountingComplete,
-    incompleteReasons: [...summary.incompleteReasons]
-  };
-  assertComparisonCost(cost, "cost ledger");
-  return cost;
-}
-function combineCosts(entries) {
-  return {
-    totalCostUsd: entries.reduce((total, entry) => total + entry.cost.totalCostUsd, 0),
-    accountingComplete: entries.every((entry) => entry.cost.accountingComplete),
-    incompleteReasons: entries.flatMap(
-      (entry) => entry.cost.incompleteReasons.map((reason) => `${entry.label}: ${reason}`)
-    )
-  };
+function isOp(op) {
+  return op !== null;
 }
-function assertComparisonCost(cost, label) {
-  if (!cost || typeof cost !== "object") {
-    throw new Error(`compareOptimizationMethods: ${label} returned no cost`);
-  }
-  if (!Number.isFinite(cost.totalCostUsd) || cost.totalCostUsd < 0) {
-    throw new Error(`compareOptimizationMethods: ${label} returned an invalid totalCostUsd`);
-  }
-  if (typeof cost.accountingComplete !== "boolean") {
-    throw new Error(`compareOptimizationMethods: ${label} returned invalid accountingComplete`);
-  }
-  if (!Array.isArray(cost.incompleteReasons) || cost.incompleteReasons.some(
-    (reason) => typeof reason !== "string" || reason.trim().length === 0
-  )) {
-    throw new Error(`compareOptimizationMethods: ${label} returned invalid incompleteReasons`);
-  }
-  if (cost.accountingComplete !== (cost.incompleteReasons.length === 0)) {
-    throw new Error(
-      `compareOptimizationMethods: ${label} returned inconsistent cost completeness and reasons`
-    );
-  }
+function snippet(s, max = 120) {
+  const t = s.trim().replace(/\s+/g, " ");
+  return t.length <= max ? t : `${t.slice(0, max)}\u2026`;
 }
 
 // src/campaign/presets/run-skill-opt.ts
@@ -4627,14 +5075,14 @@ function scoreboardSummary(rows) {
 function escapeCell(s) {
   return s.replace(/\|/g, "\\|").replace(/\r?\n/g, " ");
 }
-function truncate2(s, max) {
+function truncate3(s, max) {
   return s.length <= max ? s : `${s.slice(0, Math.max(0, max - 1))}\u2026`;
 }
 function renderScoreboardMarkdown(rows, opts = {}) {
   const maxEv = opts.maxEvidenceChars ?? 160;
   const sum = scoreboardSummary(rows);
   const pct = (n) => `${Math.round(n * 100)}%`;
-  const ev = (e) => escapeCell(truncate2(e.join("; "), maxEv)) || "\u2014";
+  const ev = (e) => escapeCell(truncate3(e.join("; "), maxEv)) || "\u2014";
   const out = [`# ${opts.title ?? "Product-flow playback scoreboard"}`, ""];
   if (opts.meta) {
     for (const [k, v] of Object.entries(opts.meta)) out.push(`- **${k}:** ${v}`);
@@ -4872,7 +5320,7 @@ async function runLineageLoop(opts) {
 
 // src/campaign/presets/run-profile-matrix.ts
 import { createHash as createHash6 } from "crypto";
-import { join as join3 } from "path";
+import { join as join4 } from "path";
 
 // src/agent-profile.ts
 import { createHash as createHash5 } from "crypto";
@@ -5137,7 +5585,7 @@ async function runProfileMatrix(opts) {
       captureSource: opts.captureSource,
       storage: opts.storage,
       now: opts.now,
-      runDir: join3(opts.runDir, sanitize(profileId))
+      runDir: join4(opts.runDir, sanitize(profileId))
     });
     const axis = harnessAxisOf(profile);
     const buildCellIdentity = (cellModel) => buildAgentProfileCell({
@@ -5420,8 +5868,8 @@ import { promisify } from "util";
 
 // src/campaign/proposers/analysis-edit.ts
 import { mkdtempSync, writeFileSync as writeFileSync2 } from "fs";
-import { tmpdir } from "os";
-import { join as join4 } from "path";
+import { tmpdir as tmpdir2 } from "os";
+import { join as join5 } from "path";
 var APPLY_SYSTEM = "You apply a trace-analysis report to an agent instruction prompt. Output ONLY the full revised prompt \u2014 no preamble, no commentary, no code fences. Make the minimal edits that address the report findings; preserve everything else verbatim.";
 function surfaceToPromptText(surface) {
   return typeof surface === "string" ? surface : JSON.stringify(surface);
@@ -5436,8 +5884,8 @@ function analysisEditProposer(opts) {
       const phase = ctx.costPhase ?? "search.proposal";
       const traces = await opts.resolveTraces(ctx) ?? "";
       if (!traces.trim()) throw new Error(opts.noTracesError);
-      const dir = mkdtempSync(join4(tmpdir(), `${opts.kind}-proposer-`));
-      const tracePath = join4(dir, "traces.jsonl");
+      const dir = mkdtempSync(join5(tmpdir2(), `${opts.kind}-proposer-`));
+      const tracePath = join5(dir, "traces.jsonl");
       writeFileSync2(tracePath, traces.endsWith("\n") ? traces : `${traces}
 `);
       let report;
@@ -8064,8 +8512,8 @@ import {
   realpathSync,
   rmSync
 } from "fs";
-import { devNull, tmpdir as tmpdir2 } from "os";
-import { basename, dirname as dirname2, isAbsolute as isAbsolute2, join as join5, relative as relative2, resolve as resolve3, sep } from "path";
+import { devNull, tmpdir as tmpdir3 } from "os";
+import { basename, dirname as dirname2, isAbsolute as isAbsolute2, join as join6, relative as relative2, resolve as resolve3, sep } from "path";
 var MAX_GIT_OUTPUT_BYTES = 256 * 1024 * 1024;
 var FILE_HASH_CHUNK_BYTES = 1024 * 1024;
 var GIT_REPOSITORY_ENV = /* @__PURE__ */ new Set([
@@ -8194,9 +8642,9 @@ var CANONICAL_GIT_ENV = {
   GIT_CONFIG_SYSTEM: devNull
 };
 function patchBytes(git, cwd, baseCommit, candidateCommit) {
-  const scratch = mkdtempSync2(join5(tmpdir2(), "agent-eval-patch-"));
-  const bareRepo = join5(scratch, "repo.git");
-  const emptyTemplate = join5(scratch, "empty-template");
+  const scratch = mkdtempSync2(join6(tmpdir3(), "agent-eval-patch-"));
+  const bareRepo = join6(scratch, "repo.git");
+  const emptyTemplate = join6(scratch, "empty-template");
   mkdirSync2(emptyTemplate);
   try {
     const objectFormat = gitObjectHashAlgorithm(candidateCommit);
@@ -8232,7 +8680,7 @@ function resolveCommit(git, cwd, ref) {
 }
 function unresolvedWorktreePath(surface, worktreeDir) {
   if (isAbsolute2(surface.worktreeRef)) return surface.worktreeRef;
-  if (worktreeDir) return join5(worktreeDir, basename(surface.worktreeRef));
+  if (worktreeDir) return join6(worktreeDir, basename(surface.worktreeRef));
   return surface.worktreeRef;
 }
 function displayGitPath(path) {
@@ -8308,7 +8756,7 @@ function assertSafeRelativePath(root, path) {
     if (segment.length === 0 || segment === "." || segment === "..") {
       throw new WorktreeAdapterError(`CodeSurface contains unsafe path ${displayGitPath(path)}`);
     }
-    parent = join5(parent, segment);
+    parent = join6(parent, segment);
     const stat = lstatSync(parent);
     if (!stat.isDirectory() || stat.isSymbolicLink()) {
       throw new WorktreeAdapterError(
@@ -8568,13 +9016,13 @@ function slug2(label) {
 }
 function gitWorktreeAdapter(opts) {
   const git = opts.git ?? defaultGit;
-  const worktreeDir = opts.worktreeDir ?? join5(opts.repoRoot, ".worktrees");
+  const worktreeDir = opts.worktreeDir ?? join6(opts.repoRoot, ".worktrees");
   const branchPrefix = opts.branchPrefix ?? "improve";
   return {
     async create({ baseRef, label }) {
       const id = `${slug2(label)}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 6)}`;
       const branch = `${branchPrefix}/${id}`;
-      const path = join5(worktreeDir, id);
+      const path = join6(worktreeDir, id);
       const baseCommit = resolveCommit(git, opts.repoRoot, baseRef);
       const baseTree = gitText(
         git,
@@ -8683,6 +9131,9 @@ export {
   neutralizationGate,
   sequentialPairedGate,
   sequentialDecide,
+  compareOptimizationMethods,
+  costFromLedgerSummary,
+  gepaOptimizationMethod,
   rolloutArgumentDiff,
   classifyUngroundedLiterals,
   LabeledScenarioStoreError,
@@ -8696,8 +9147,6 @@ export {
   skillOptProposer,
   SkillPatchParseError,
   parseSkillPatchResponse,
-  compareOptimizationMethods,
-  costFromLedgerSummary,
   runSkillOpt,
   gepaReflectionMethod,
   gepaParetoMethod,
@@ -8736,4 +9185,4 @@ export {
   verifyCodeSurface,
   resolveWorktreePath
 };
-//# sourceMappingURL=chunk-LT4J7ULK.js.map
+//# sourceMappingURL=chunk-VPDOSN3L.js.map