@tangle-network/agent-eval 0.123.2 → 0.123.4

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

@@ -15,12 +15,13 @@ import {
   runImprovementLoop,
   surfaceContentHash,
   surfaceHash
-} from "./chunk-HQY7LBV2.js";
+} from "./chunk-SUN7QLPB.js";
 import {
   SearchLedgerConflictError,
   SearchLedgerError,
   SearchLedgerIntegrityError,
   appendSearchLedgerLine,
+  assertCampaignDesign,
   assertRealBackend,
   canonicalJson,
   contentHash,
@@ -33,13 +34,12 @@ import {
   summarizeBackendIntegrity,
   tryAcquireAtomicFileLock,
   withSearchLedgerFileLock
-} from "./chunk-3FCG7FBV.js";
+} from "./chunk-D5JZ7UDZ.js";
 import {
   AnalystRegistry,
   DEFAULT_TRACE_ANALYST_KINDS,
   Mutex,
   POLICY_EDIT_AXES,
-  POLICY_EDIT_TARGET_SURFACES,
   admitPolicyEdit,
   applyPolicyEditToSurface,
   assertNoJudgeVerdict,
@@ -51,14 +51,14 @@ import {
   mapConcurrent,
   policyEditsFromFindings,
   validatePolicyEditCandidateRecord
-} from "./chunk-WXQTVEKM.js";
+} from "./chunk-MHPEGJHC.js";
 import {
   callLlm,
   callLlmJson,
   costReceiptFromLlm,
   costReceiptFromLlmError,
   maximumChargeForLlmRequest
-} from "./chunk-J7S4YM27.js";
+} from "./chunk-MK3Q6GCL.js";
 import {
   eProcess,
   mcnemar,
@@ -70,7 +70,7 @@ import {
 import {
   CostAccountingIncompleteError,
   CostLedger
-} from "./chunk-BGVTIE2C.js";
+} from "./chunk-GRCDRKII.js";
 import {
   analyzeTraces
 } from "./chunk-NUKSVU3W.js";
@@ -3404,56 +3404,509 @@ function snippet(s, max = 120) {
   return t.length <= max ? t : `${t.slice(0, max)}\u2026`;
 }
 
+// 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;
+  };
+  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]);
+  };
+  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 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
+    };
+    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);
+    }
+    start = end;
+  }
+  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 (!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}'`
+      );
+    }
+    pathOwners.set(pathKey, method.name);
+  }
+}
+function assertOptimizationResult(name, result) {
+  if (!result || typeof result !== "object") {
+    throw new Error(`compareOptimizationMethods: method '${name}' returned no result`);
+  }
+  try {
+    surfaceContentHash(result.winnerSurface);
+  } catch (cause) {
+    throw new Error(
+      `compareOptimizationMethods: method '${name}' returned an invalid winnerSurface`,
+      { cause }
+    );
+  }
+  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`);
+  }
+}
+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");
+  }
+  try {
+    surfaceContentHash(opts.baselineSurface);
+  } catch (cause) {
+    throw new Error("compareOptimizationMethods: baselineSurface is invalid", { cause });
+  }
+  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);
+    }
+  }
+  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)}`);
+  }
+  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/presets/run-skill-opt.ts
 async function runSkillOpt(opts) {
-  if (opts.trainScenarios.length === 0) throw new Error("runSkillOpt: trainScenarios is empty");
-  if (opts.holdoutScenarios.length === 0) throw new Error("runSkillOpt: holdoutScenarios is empty");
+  const legacy = opts;
+  if (legacy.holdoutScenarios !== void 0) {
+    throw new Error(
+      "runSkillOpt: holdoutScenarios was renamed to selectionScenarios because SkillOpt adaptively reuses it for edit acceptance. Provide selectionScenarios and score any final test outside runSkillOpt."
+    );
+  }
+  if (!Array.isArray(opts.trainScenarios) || opts.trainScenarios.length === 0)
+    throw new Error("runSkillOpt: trainScenarios is empty");
+  if (!Array.isArray(opts.selectionScenarios) || opts.selectionScenarios.length === 0)
+    throw new Error("runSkillOpt: selectionScenarios is empty");
   if (!opts.judges || opts.judges.length === 0) {
     throw new Error(
       "runSkillOpt: at least one judge is required \u2014 scoring (and therefore acceptance) is meaningless without one, and would report a silent zero lift."
     );
   }
-  const holdoutIds = new Set(opts.holdoutScenarios.map((s) => s.id));
-  const overlap = opts.trainScenarios.filter((s) => holdoutIds.has(s.id)).map((s) => s.id);
+  const selectionIds = new Set(opts.selectionScenarios.map((s) => s.id));
+  const overlap = opts.trainScenarios.filter((s) => selectionIds.has(s.id)).map((s) => s.id);
   if (overlap.length > 0) {
     throw new Error(
-      `runSkillOpt: trainScenarios and holdoutScenarios must be disjoint (overlap: [${overlap.join(
+      `runSkillOpt: trainScenarios and selectionScenarios must be disjoint (overlap: [${overlap.join(
         ", "
-      )}]) \u2014 a shared scenario leaks the held-out acceptance axis into the proposal evidence.`
+      )}]) \u2014 a shared scenario leaks the selection axis into the proposal evidence.`
     );
   }
+  const maxEpochs = opts.maxEpochs;
   const patchesPerEpoch = opts.patchesPerEpoch ?? 2;
   const initialBudget = opts.editBudget ?? 3;
   const minImprovement = opts.minImprovement ?? 0;
-  if (minImprovement < 0) {
-    throw new Error(
-      "runSkillOpt: minImprovement must be >= 0 \u2014 a negative threshold would accept held-out regressions, breaking the monotonic-lift contract."
-    );
-  }
-  const patience = opts.patience ?? opts.maxEpochs;
+  const patience = opts.patience ?? maxEpochs;
   const budgetAnneal = opts.budgetAnneal ?? true;
   const rejectedBufferSize = opts.rejectedBufferSize ?? 12;
   const slowMetaEvery = opts.slowMetaEvery ?? 2;
-  opts.runDir = resolveRunDir(opts.runDir, opts.repo);
+  const evidenceK = opts.evidenceK ?? 3;
+  assertPositiveSafeInteger("maxEpochs", maxEpochs);
+  assertPositiveSafeInteger("patchesPerEpoch", patchesPerEpoch);
+  assertPositiveSafeInteger("editBudget", initialBudget);
+  assertFiniteNonNegative("minImprovement", minImprovement);
+  assertPositiveSafeInteger("patience", patience);
+  assertNonNegativeSafeInteger("rejectedBufferSize", rejectedBufferSize);
+  assertNonNegativeSafeInteger("slowMetaEvery", slowMetaEvery);
+  assertPositiveSafeInteger("evidenceK", evidenceK);
+  if (typeof opts.runDir !== "string" || opts.runDir.trim().length === 0) {
+    throw new Error("runSkillOpt: runDir must be a non-empty string");
+  }
+  const runDir = resolveRunDir(opts.runDir, opts.repo);
   const storage = opts.storage ?? fsCampaignStorage();
   const costLedger = opts.costLedger ?? createRunCostLedger({
     storage,
-    runDir: opts.runDir,
+    runDir,
     costCeilingUsd: opts.costCeiling
   });
-  const scoreHoldout = async (surface, tag) => {
-    const campaign = await runScoringCampaign(opts, opts.holdoutScenarios, surface, tag, costLedger);
+  const scoreSelection = async (surface, tag) => {
+    const campaign = await runScoringCampaign(
+      opts,
+      opts.selectionScenarios,
+      surface,
+      tag,
+      costLedger,
+      runDir
+    );
     return campaignMeanComposite(campaign);
   };
-  const evidenceK = opts.evidenceK ?? 3;
   const trainEvidence = async (surface, tag) => {
-    const campaign = await runScoringCampaign(opts, opts.trainScenarios, surface, tag, costLedger);
+    const campaign = await runScoringCampaign(
+      opts,
+      opts.trainScenarios,
+      surface,
+      tag,
+      costLedger,
+      runDir
+    );
     return toEvidence(campaign, evidenceK);
   };
   let current = opts.baselineSurface;
   let currentEvidence = await trainEvidence(current, "baseline-train");
-  const baselineHoldout = await scoreHoldout(current, "baseline-holdout");
-  let currentHoldout = baselineHoldout;
+  const baselineSelection = await scoreSelection(current, "baseline-selection");
+  let currentSelection = baselineSelection;
   const buffer = [];
   const acceptedEdits = [];
   const rejectedAll = [];
@@ -3462,9 +3915,9 @@ async function runSkillOpt(opts) {
   let sinceAccept = 0;
   let metaNote;
   let epochsRun = 0;
-  for (let epoch = 0; epoch < opts.maxEpochs; epoch++) {
+  for (let epoch = 0; epoch < maxEpochs; epoch++) {
     epochsRun++;
-    const patches = await opts.proposer.proposePatches({
+    const proposed = await opts.proposer.proposePatches({
       surface: current,
       evidence: currentEvidence,
       editBudget: budget,
@@ -3475,6 +3928,10 @@ async function runSkillOpt(opts) {
       costLedger,
       costPhase: "skill-opt.proposal"
     });
+    if (!Array.isArray(proposed)) {
+      throw new Error("runSkillOpt: proposer.proposePatches() must return an array");
+    }
+    const patches = proposed.slice(0, patchesPerEpoch);
     let accepted = null;
     const rejectedThisEpoch = [];
     for (let i = 0; i < patches.length; i++) {
@@ -3488,23 +3945,26 @@ async function runSkillOpt(opts) {
         });
         continue;
       }
-      const candidateHoldout = await scoreHoldout(candidate, `epoch-${epoch}-cand-${i}-holdout`);
-      if (candidateHoldout > currentHoldout + minImprovement) {
+      const candidateSelection = await scoreSelection(
+        candidate,
+        `epoch-${epoch}-cand-${i}-selection`
+      );
+      if (candidateSelection > currentSelection + minImprovement) {
         accepted = {
           epoch,
           label: patch.label,
           rationale: patch.rationale,
-          holdoutDelta: candidateHoldout - currentHoldout
+          selectionDelta: candidateSelection - currentSelection
         };
         current = candidate;
-        currentHoldout = candidateHoldout;
+        currentSelection = candidateSelection;
         currentEvidence = await trainEvidence(current, `epoch-${epoch}-train`);
         break;
       }
       rejectedThisEpoch.push({
         label: patch.label,
         rationale: patch.rationale,
-        reason: `held-out ${candidateHoldout.toFixed(3)} \u2264 current ${currentHoldout.toFixed(3)}`
+        reason: `selection ${candidateSelection.toFixed(3)} \u2264 current ${currentSelection.toFixed(3)}`
       });
     }
     if (accepted) {
@@ -3528,16 +3988,16 @@ async function runSkillOpt(opts) {
       proposed: patches.length,
       accepted,
       rejected: rejectedThisEpoch,
-      holdoutComposite: currentHoldout
+      selectionComposite: currentSelection
     });
     if (sinceAccept >= patience) break;
   }
   const cost = costLedger.summary();
   return {
     winnerSurface: current,
-    baselineHoldoutComposite: baselineHoldout,
-    winnerHoldoutComposite: currentHoldout,
-    lift: currentHoldout - baselineHoldout,
+    baselineSelectionComposite: baselineSelection,
+    winnerSelectionComposite: currentSelection,
+    selectionLift: currentSelection - baselineSelection,
     acceptedEdits,
     rejectedEdits: rejectedAll,
     epochsRun,
@@ -3546,15 +4006,30 @@ async function runSkillOpt(opts) {
     cost
   };
 }
-function runScoringCampaign(opts, scenarios, surface, tag, costLedger) {
+function runScoringCampaign(opts, scenarios, surface, tag, costLedger, runDir) {
   return runCampaign({
     ...opts,
     costLedger,
     scenarios,
     dispatch: (scenario, ctx) => opts.dispatchWithSurface(surface, scenario, ctx),
-    runDir: `${opts.runDir}/${tag}`
+    runDir: `${runDir}/${tag}`
   });
 }
+function assertPositiveSafeInteger(name, value) {
+  if (!Number.isSafeInteger(value) || value <= 0) {
+    throw new Error(`runSkillOpt: ${name} must be a positive safe integer`);
+  }
+}
+function assertNonNegativeSafeInteger(name, value) {
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw new Error(`runSkillOpt: ${name} must be a non-negative safe integer`);
+  }
+}
+function assertFiniteNonNegative(name, value) {
+  if (!Number.isFinite(value) || value < 0) {
+    throw new Error(`runSkillOpt: ${name} must be a finite number greater than or equal to 0`);
+  }
+}
 function toEvidence(campaign, k) {
   const { dimensions, scenarios } = campaignBreakdown(campaign);
   const weakScenarios = [...scenarios].sort((a, b) => a.composite - b.composite).slice(0, k);
@@ -3565,7 +4040,7 @@ function buildMetaNote(accepted, rejected) {
   const parts = [];
   if (accepted.length > 0) {
     parts.push(
-      `Edits that improved held-out so far: ${accepted.map((a) => `"${a.label}" (+${a.holdoutDelta.toFixed(3)})`).join("; ")}. Build on these.`
+      `Edits that improved selection so far: ${accepted.map((a) => `"${a.label}" (+${a.selectionDelta.toFixed(3)})`).join("; ")}. Build on these.`
     );
   }
   if (rejected.length > 0) {
@@ -3576,231 +4051,108 @@ function buildMetaNote(accepted, rejected) {
   return parts.join(" ");
 }
 
-// src/campaign/presets/compare-proposers.ts
-async function compareProposers(opts) {
-  return compareProposerEntries(opts);
+// src/campaign/presets/builtin-optimization-methods.ts
+function gepaReflectionMethod(config, name = "gepa-reflection") {
+  return gepaMethod(config, false, name);
 }
-async function compareProposerEntries(opts) {
-  if (opts.proposers.length === 0) throw new Error("compareProposers: no proposers to compare");
-  const seed = opts.seed ?? 42;
-  const resamples = opts.resamples ?? 2e3;
-  const confidence = opts.confidence ?? 0.95;
-  const scoreOnHoldout = async (surface, tag) => {
-    const campaign = await runCampaign({
-      ...opts,
-      scenarios: opts.holdoutScenarios,
-      dispatch: (scenario, ctx) => opts.dispatchWithSurface(surface, scenario, ctx),
-      runDir: `${opts.runDir}/${tag}`
-    });
-    const byScenario = {};
-    for (const { scenarioId, composite } of campaignBreakdown(campaign).scenarios) {
-      byScenario[scenarioId] = composite;
-    }
-    return byScenario;
-  };
-  const scenarioIds = [...new Set(opts.holdoutScenarios.map((s) => s.id))].sort();
-  if (scenarioIds.length === 0) throw new Error("compareProposers: holdoutScenarios is empty");
-  const align = (byScenario, label) => {
-    const missing = scenarioIds.filter((id) => !(id in byScenario));
-    if (missing.length > 0) {
-      throw new Error(
-        `compareProposers: ${label} produced no held-out score for scenario(s) [${missing.join(
-          ", "
-        )}] \u2014 a cell errored or its judges returned nothing. Refusing to fabricate a 0 (it would corrupt the lift comparison). Fix the dispatch/judge or drop the scenario.`
-      );
-    }
-    return scenarioIds.map((id) => byScenario[id]);
-  };
-  const baselineArr = align(
-    await scoreOnHoldout(opts.baselineSurface, "compare-baseline"),
-    "baseline"
-  );
-  const winners = [];
-  for (const proposer of opts.proposers) {
-    const out = await proposer.optimize();
-    const byScenario = await scoreOnHoldout(out.winnerSurface, `compare-${slug(proposer.name)}`);
-    winners.push({
-      name: proposer.name,
-      winnerSurface: out.winnerSurface,
-      costUsd: out.costUsd,
-      durationMs: out.durationMs,
-      arr: align(byScenario, `proposer "${proposer.name}"`)
-    });
-  }
-  const scores = winners.map((w) => {
-    const boot = pairedBootstrap(baselineArr, w.arr, {
-      seed,
-      resamples,
-      confidence,
-      statistic: "mean"
-    });
-    const score = {
-      name: w.name,
-      baselineComposite: mean2(baselineArr),
-      winnerComposite: mean2(w.arr),
-      lift: boot.mean,
-      liftCi: { low: boot.low, high: boot.high },
-      costUsd: w.costUsd,
-      winnerSurface: w.winnerSurface,
-      rank: 0
-    };
-    if (w.durationMs !== void 0) score.durationMs = w.durationMs;
-    return score;
-  });
-  scores.sort((a, b) => b.lift - a.lift || a.costUsd - b.costUsd);
-  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,
-      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
-    };
-  });
-  return { scores, best, pairwise, holdoutScenarioIds: scenarioIds };
-}
-function mean2(xs) {
-  return xs.length === 0 ? 0 : xs.reduce((a, b) => a + b, 0) / xs.length;
+function gepaParetoMethod(config, name = "gepa-pareto") {
+  return gepaMethod(config, true, name);
 }
-function slug(name) {
-  return name.replace(/[^a-z0-9]+/gi, "-").toLowerCase();
-}
-function gepaReflectionEntry(config, name = "gepa-reflection") {
-  return gepaEntry(config, false, name);
-}
-function gepaParetoEntry(config, name = "gepa-pareto") {
-  return gepaEntry(config, true, name);
-}
-function gepaEntry(config, combineParents, name) {
-  return {
+function gepaMethod(config, combineParents, name) {
+  return improvementLoopMethod(
+    config,
     name,
-    async optimize() {
-      const started = Date.now();
-      const proposer = gepaProposer({
-        llm: config.llm,
-        model: config.model,
-        target: config.target,
-        combineParents,
-        ...config.mutationPrimitives ? { mutationPrimitives: config.mutationPrimitives } : {}
-      });
-      const result = await runImprovementLoop({
-        scenarios: config.trainScenarios,
-        holdoutScenarios: config.holdoutScenarios,
-        baselineSurface: config.baselineSurface,
-        dispatchWithSurface: config.dispatchWithSurface,
-        judges: config.judges,
-        proposer,
-        populationSize: config.populationSize ?? 2,
-        maxGenerations: config.maxGenerations ?? 3,
-        gate: defaultProductionGate({
-          holdoutScenarios: config.holdoutScenarios,
-          deltaThreshold: 0
-        }),
-        autoOnPromote: "none",
-        runDir: `${config.runDir}/${slug(name)}-loop`,
-        ...config.seed !== void 0 ? { seed: config.seed } : {},
-        // Flow findings to the proposer's propose(). These reach runOptimization
-        // unchanged (runImprovementLoop extends RunOptimizationOptions and
-        // forwards {...opts}); ctx.findings/report/analyzeGeneration are consumed there.
-        ...config.findings !== void 0 ? { findings: config.findings } : {},
-        ...config.analyzeGeneration ? { analyzeGeneration: config.analyzeGeneration } : {},
-        ...config.report !== void 0 ? { report: config.report } : {}
-      });
-      return {
-        winnerSurface: result.winnerSurface,
-        costUsd: result.cost.totalCostUsd,
-        durationMs: Date.now() - started
-      };
-    }
-  };
+    () => gepaProposer({
+      llm: config.llm,
+      model: config.model,
+      target: config.target,
+      combineParents,
+      ...config.mutationPrimitives ? { mutationPrimitives: config.mutationPrimitives } : {}
+    })
+  );
 }
-function skillOptEntry(config, name = "skill-opt") {
+function skillOptMethod(config, name = "skill-opt") {
   return {
     name,
-    async optimize() {
+    async optimize(input) {
       const started = Date.now();
+      if (typeof input.baselineSurface !== "string") {
+        throw new Error(`${name}: SkillOpt requires a string baselineSurface`);
+      }
       const proposer = skillOptProposer({
         llm: config.llm,
         model: config.model,
         target: config.target
       });
       const result = await runSkillOpt({
-        baselineSurface: config.baselineSurface,
-        dispatchWithSurface: config.dispatchWithSurface,
-        judges: config.judges,
+        ...input.runOptions,
+        ...config.runOptions ?? {},
+        baselineSurface: input.baselineSurface,
+        dispatchWithSurface: input.dispatchWithSurface,
+        judges: [...input.judges],
         proposer,
-        trainScenarios: config.trainScenarios,
-        holdoutScenarios: config.holdoutScenarios,
+        trainScenarios: [...input.trainScenarios],
+        selectionScenarios: [...input.selectionScenarios],
         maxEpochs: config.maxEpochs ?? 6,
-        runDir: `${config.runDir}/${slug(name)}-loop`,
-        ...config.seed !== void 0 ? { seed: config.seed } : {}
+        runDir: `${input.runDir}/loop`,
+        seed: config.seed ?? input.seed
       });
       return {
         winnerSurface: result.winnerSurface,
-        costUsd: result.totalCostUsd,
+        cost: costFromLedgerSummary(result.cost),
         durationMs: Date.now() - started
       };
     }
   };
 }
-function fapoEscalationEntry(config, name = "fapo-escalation") {
+function fapoEscalationMethod(config, name = "fapo-escalation") {
+  return improvementLoopMethod(config, name, () => {
+    const promptProposer = config.promptProposer ?? gepaProposer({
+      llm: config.llm,
+      model: config.model,
+      target: config.target,
+      combineParents: true,
+      ...config.mutationPrimitives ? { mutationPrimitives: config.mutationPrimitives } : {}
+    });
+    const parameterProposer = config.parameterProposer ?? (config.parameterCandidates ? parameterSweepProposer({ candidates: config.parameterCandidates }) : void 0);
+    return fapoProposer({
+      ...config.fapo ?? {},
+      promptProposer,
+      ...parameterProposer ? { parameterProposer } : {},
+      ...config.structuralProposer ? { structuralProposer: config.structuralProposer } : {}
+    });
+  });
+}
+function improvementLoopMethod(config, name, createProposer) {
   return {
     name,
-    async optimize() {
+    async optimize(input) {
       const started = Date.now();
-      const promptProposer = config.promptProposer ?? gepaProposer({
-        llm: config.llm,
-        model: config.model,
-        target: config.target,
-        combineParents: true,
-        ...config.mutationPrimitives ? { mutationPrimitives: config.mutationPrimitives } : {}
-      });
-      const parameterProposer = config.parameterProposer ?? (config.parameterCandidates ? parameterSweepProposer({ candidates: config.parameterCandidates }) : void 0);
-      const structuralProposer = config.structuralProposer;
-      const proposer = fapoProposer({
-        ...config.fapo ?? {},
-        promptProposer,
-        ...parameterProposer ? { parameterProposer } : {},
-        ...structuralProposer ? { structuralProposer } : {}
-      });
       const result = await runImprovementLoop({
-        scenarios: config.trainScenarios,
-        holdoutScenarios: config.holdoutScenarios,
-        baselineSurface: config.baselineSurface,
-        dispatchWithSurface: config.dispatchWithSurface,
-        judges: config.judges,
-        proposer,
+        ...input.runOptions,
+        ...config.runOptions ?? {},
+        scenarios: [...input.trainScenarios],
+        holdoutScenarios: [...input.selectionScenarios],
+        baselineSurface: input.baselineSurface,
+        dispatchWithSurface: input.dispatchWithSurface,
+        judges: [...input.judges],
+        proposer: createProposer(),
         populationSize: config.populationSize ?? 2,
         maxGenerations: config.maxGenerations ?? 3,
         gate: defaultProductionGate({
-          holdoutScenarios: config.holdoutScenarios,
+          holdoutScenarios: [...input.selectionScenarios],
           deltaThreshold: 0
         }),
         autoOnPromote: "none",
-        runDir: `${config.runDir}/${slug(name)}-loop`,
-        ...config.seed !== void 0 ? { seed: config.seed } : {},
+        runDir: `${input.runDir}/loop`,
+        seed: config.seed ?? input.seed,
         ...config.findings !== void 0 ? { findings: config.findings } : {},
         ...config.analyzeGeneration ? { analyzeGeneration: config.analyzeGeneration } : {},
         ...config.report !== void 0 ? { report: config.report } : {}
       });
       return {
-        winnerSurface: result.winnerSurface,
-        costUsd: result.cost.totalCostUsd,
+        winnerSurface: result.gateResult.decision === "ship" ? result.winnerSurface : input.baselineSurface,
+        cost: costFromLedgerSummary(result.cost),
         durationMs: Date.now() - started
       };
     }
@@ -3808,7 +4160,7 @@ function fapoEscalationEntry(config, name = "fapo-escalation") {
 }
 
 // src/completion-verifier.ts
-import { randomUUID } from "crypto";
+import { randomUUID as randomUUID2 } from "crypto";
 function completionVerdict(input) {
   if (input.requirements.length === 0) {
     throw new Error(
@@ -4068,7 +4420,7 @@ ${content.slice(0, maxContentChars)}`
     for (let attempt = 0; attempt < maxAttempts; attempt++) {
       const started = Date.now();
       await record({
-        eventId: randomUUID(),
+        eventId: randomUUID2(),
         provider: "correctness-checker",
         model,
         endpoint: "/chat",
@@ -4100,7 +4452,7 @@ ${content.slice(0, maxContentChars)}`
         const resp = paid.value;
         const raw = resp.choices?.[0]?.message?.content ?? "";
         await record({
-          eventId: randomUUID(),
+          eventId: randomUUID2(),
           provider: "correctness-checker",
           model,
           endpoint: "/chat",
@@ -4116,7 +4468,7 @@ ${content.slice(0, maxContentChars)}`
       } catch (err) {
         lastErr = err;
         await record({
-          eventId: randomUUID(),
+          eventId: randomUUID2(),
           provider: "correctness-checker",
           model,
           endpoint: "/chat",
@@ -5284,7 +5636,11 @@ function coerceCandidateSurface(surface) {
 
 // src/campaign/proposers/policy-edit-author-context.ts
 function selectPolicyEditAuthorRows(rows, options) {
-  assertPositiveSafeInteger(options.limit, "limit");
+  assertPositiveSafeInteger2(options.limit, "limit");
+  const scenarioOrder = options.scenarioOrder ?? "ranked";
+  if (scenarioOrder !== "ranked" && scenarioOrder !== "input") {
+    throw new Error("selectPolicyEditAuthorRows: scenarioOrder must be 'ranked' or 'input'");
+  }
   const unique2 = /* @__PURE__ */ new Map();
   for (const row of rows) {
     if (!row.scenarioId || row.scenarioId.trim() !== row.scenarioId) {
@@ -5307,6 +5663,9 @@ function selectPolicyEditAuthorRows(rows, options) {
       delta: reference === void 0 ? null : row.composite - reference
     });
   }
+  if (scenarioOrder === "input") {
+    return [...unique2.values()].slice(0, options.limit).map(({ row }) => row);
+  }
   const hardest = [...unique2.values()].sort(
     (a, b) => a.row.composite - b.row.composite || compareScenarioId(a.row, b.row)
   );
@@ -5328,7 +5687,7 @@ function selectPolicyEditAuthorRows(rows, options) {
   return selected;
 }
 function assertPolicyEditAuthorContextBudget(value, maxChars) {
-  assertPositiveSafeInteger(maxChars, "maxChars");
+  assertPositiveSafeInteger2(maxChars, "maxChars");
   const json = JSON.stringify(value);
   if (json === void 0) {
     throw new Error("assertPolicyEditAuthorContextBudget: value must serialize to JSON");
@@ -5344,7 +5703,7 @@ function assertPolicyEditAuthorContextBudget(value, maxChars) {
 function compareScenarioId(a, b) {
   return a.scenarioId < b.scenarioId ? -1 : a.scenarioId > b.scenarioId ? 1 : 0;
 }
-function assertPositiveSafeInteger(value, name) {
+function assertPositiveSafeInteger2(value, name) {
   if (!Number.isSafeInteger(value) || value <= 0) {
     throw new Error(`${name} must be a positive safe integer (got ${value})`);
   }
@@ -5372,37 +5731,27 @@ var JsonValueSchema = z.lazy(
 );
 var AuthoredJsonChangeSchema = z.discriminatedUnion("mode", [
   z.object({
-    kind: z.literal("json"),
     mode: z.literal("set"),
-    path: NonEmptyStringSchema,
     value: JsonValueSchema
   }).strict(),
   z.object({
-    kind: z.literal("json"),
     mode: z.literal("merge"),
-    path: NonEmptyStringSchema,
     value: JsonValueSchema
   }).strict(),
   z.object({
-    kind: z.literal("json"),
-    mode: z.literal("remove"),
-    path: NonEmptyStringSchema
+    mode: z.literal("remove")
   }).strict()
 ]);
 var AuthoredPolicyEditSchema = z.object({
   axis: z.enum(POLICY_EDIT_AXES),
   target: z.object({
-    surface: z.enum(POLICY_EDIT_TARGET_SURFACES),
     path: NonEmptyStringSchema,
     label: NonEmptyStringSchema.max(200).nullable()
   }).strict(),
   change: AuthoredJsonChangeSchema,
   claim: NonEmptyStringSchema.max(2e3),
   expectedGain: z.object({
-    metric: NonEmptyStringSchema.max(400),
-    direction: z.enum(["increase", "decrease"]),
     amount: z.number().finite().positive(),
-    unit: z.enum(["absolute", "relative", "percent", "score"]).nullable(),
     rationale: NonEmptyStringSchema.max(2e3).nullable()
   }).strict(),
   confidence: z.number().finite().min(0).max(1),
@@ -5443,11 +5792,15 @@ var POLICY_EDIT_AUTHOR_JSON_SCHEMA = {
           target: {
             type: "object",
             additionalProperties: false,
-            required: ["surface", "path", "label"],
+            required: ["path", "label"],
             properties: {
-              surface: { type: "string", enum: [...POLICY_EDIT_TARGET_SURFACES] },
               path: { type: "string", minLength: 1 },
-              label: { type: ["string", "null"], maxLength: 200 }
+              label: {
+                type: ["string", "null"],
+                minLength: 1,
+                maxLength: 200,
+                pattern: "\\S"
+              }
             }
           },
           change: {
@@ -5455,51 +5808,44 @@ var POLICY_EDIT_AUTHOR_JSON_SCHEMA = {
               {
                 type: "object",
                 additionalProperties: false,
-                required: ["kind", "mode", "path", "value"],
+                required: ["mode", "value"],
                 properties: {
-                  kind: { const: "json" },
                   mode: { const: "set" },
-                  path: { type: "string", minLength: 1 },
                   value: {}
                 }
               },
               {
                 type: "object",
                 additionalProperties: false,
-                required: ["kind", "mode", "path", "value"],
+                required: ["mode", "value"],
                 properties: {
-                  kind: { const: "json" },
                   mode: { const: "merge" },
-                  path: { type: "string", minLength: 1 },
                   value: {}
                 }
               },
               {
                 type: "object",
                 additionalProperties: false,
-                required: ["kind", "mode", "path"],
+                required: ["mode"],
                 properties: {
-                  kind: { const: "json" },
-                  mode: { const: "remove" },
-                  path: { type: "string", minLength: 1 }
+                  mode: { const: "remove" }
                 }
               }
             ]
           },
-          claim: { type: "string", minLength: 1, maxLength: 2e3 },
+          claim: { type: "string", minLength: 1, maxLength: 2e3, pattern: "\\S" },
           expectedGain: {
             type: "object",
             additionalProperties: false,
-            required: ["metric", "direction", "amount", "unit", "rationale"],
+            required: ["amount", "rationale"],
             properties: {
-              metric: { type: "string", minLength: 1, maxLength: 400 },
-              direction: { type: "string", enum: ["increase", "decrease"] },
               amount: { type: "number", exclusiveMinimum: 0 },
-              unit: {
+              rationale: {
                 type: ["string", "null"],
-                enum: ["absolute", "relative", "percent", "score", null]
-              },
-              rationale: { type: ["string", "null"], maxLength: 2e3 }
+                minLength: 1,
+                maxLength: 2e3,
+                pattern: "\\S"
+              }
             }
           },
           confidence: { type: "number", minimum: 0, maximum: 1 },
@@ -5513,18 +5859,28 @@ var POLICY_EDIT_AUTHOR_JSON_SCHEMA = {
                 type: "array",
                 minItems: 1,
                 uniqueItems: true,
-                items: { type: "string", minLength: 1 }
+                items: { type: "string", minLength: 1, pattern: "\\S" }
               }
             }
           },
-          rationale: { type: ["string", "null"], maxLength: 4e3 },
-          validationPlan: { type: ["string", "null"], maxLength: 2e3 }
+          rationale: {
+            type: ["string", "null"],
+            minLength: 1,
+            maxLength: 4e3,
+            pattern: "\\S"
+          },
+          validationPlan: {
+            type: ["string", "null"],
+            minLength: 1,
+            maxLength: 2e3,
+            pattern: "\\S"
+          }
         }
       }
     }
   }
 };
-function policyEditAuthorJsonSchema(maxItems, targetSurface, allowedJsonPaths, objectives) {
+function policyEditAuthorJsonSchema(maxItems, allowedJsonPaths) {
   const schema = JSON.parse(JSON.stringify(POLICY_EDIT_AUTHOR_JSON_SCHEMA));
   const properties = schema.properties;
   const edits = properties.edits;
@@ -5533,24 +5889,7 @@ function policyEditAuthorJsonSchema(maxItems, targetSurface, allowedJsonPaths, o
   const itemProperties = item.properties;
   const target = itemProperties.target;
   const targetProperties = target.properties;
-  targetProperties.surface = { type: "string", enum: [targetSurface] };
   targetProperties.path = { type: "string", enum: [...allowedJsonPaths] };
-  const change = itemProperties.change;
-  for (const variant of change.anyOf) {
-    const variantProperties = variant.properties;
-    variantProperties.path = { type: "string", enum: [...allowedJsonPaths] };
-  }
-  const expectedGain = itemProperties.expectedGain;
-  const gainProperties = expectedGain.properties;
-  gainProperties.metric = { type: "string", enum: objectives.map((objective) => objective.key) };
-  gainProperties.direction = {
-    type: "string",
-    enum: [...new Set(objectives.map((objective) => objective.direction))]
-  };
-  gainProperties.unit = {
-    type: "string",
-    enum: [...new Set(objectives.map((objective) => objective.unit))]
-  };
   return schema;
 }
 var DEFAULT_POLICY_EDIT_HISTORY_LIMITS = Object.freeze({
@@ -5564,9 +5903,9 @@ var POLICY_EDIT_AUTHOR_SYSTEM = [
   "You author strictly typed PolicyEdit candidates over one JSON surface.",
   'Return exactly one JSON object with shape {"edits":[...]}; emit an empty edits array when no evidence supports a change.',
   `axis must be one of: ${POLICY_EDIT_AXES.join(", ")}.`,
-  `target.surface must be one of: ${POLICY_EDIT_TARGET_SURFACES.join(", ")}.`,
-  "target.path and change.path must be the same caller-allowed JSON path.",
-  'change must be exactly one operation: {"kind":"json","mode":"set","path":string,"value":json}, {"kind":"json","mode":"merge","path":string,"value":json}, or {"kind":"json","mode":"remove","path":string}.',
+  "target.path must be one caller-allowed JSON path.",
+  'change must be exactly one operation: {"mode":"set","value":json}, {"mode":"merge","value":json}, or {"mode":"remove"}.',
+  "The caller binds target surface, JSON operation kind and path, and objective metric, direction, and unit; do not emit those fields.",
   "Nullable fields required by the response schema must be null when they do not apply.",
   "Every edit must cite one or more supplied finding keys in source.findingKeys. Do not emit persistent finding IDs, analyst IDs, or evidence references; the caller binds those from the cited findings.",
   "Treat expectedGain and confidence as forecasts, never as measured evidence. Learn from baselineOutcome, incumbentOutcome, and observedDeltaFromParent.",
@@ -5605,6 +5944,7 @@ function llmPolicyEditProposer(opts) {
     ...opts.maxHistoryGenerations === void 0 ? {} : { maxGenerations: opts.maxHistoryGenerations },
     ...opts.maxHistoryCandidatesPerGeneration === void 0 ? {} : { maxCandidatesPerGeneration: opts.maxHistoryCandidatesPerGeneration },
     ...opts.maxScenariosPerCandidate === void 0 ? {} : { maxScenariosPerCandidate: opts.maxScenariosPerCandidate },
+    ...opts.scenarioOrder === void 0 ? {} : { scenarioOrder: opts.scenarioOrder },
     ...opts.scenarioIdTransform === void 0 ? {} : { scenarioIdTransform: opts.scenarioIdTransform }
   });
   const maxFindings = positiveLimit(
@@ -5658,12 +5998,14 @@ function llmPolicyEditProposer(opts) {
         baselineOutcome: projectOutcome(
           ctx.baselineOutcome,
           scenarioIds,
-          historyLimits.maxScenariosPerCandidate
+          historyLimits.maxScenariosPerCandidate,
+          historyLimits.scenarioOrder
         ),
         incumbentOutcome: projectOutcome(
           ctx.incumbentOutcome,
           scenarioIds,
           historyLimits.maxScenariosPerCandidate,
+          historyLimits.scenarioOrder,
           ctx.baselineOutcome
         ),
         history: projectPolicyEditHistoryWithProjector(
@@ -5673,12 +6015,7 @@ function llmPolicyEditProposer(opts) {
           objectiveByKey
         )
       };
-      const responseSchema = policyEditAuthorJsonSchema(
-        limit,
-        opts.targetSurface,
-        allowedJsonPaths,
-        objectives
-      );
+      const responseSchema = policyEditAuthorJsonSchema(limit, allowedJsonPaths);
       const system = policyEditAuthorSystem(responseSchema);
       assertPolicyEditAuthorContextBudget(
         { system, authorContext, responseSchema },
@@ -5707,7 +6044,12 @@ function llmPolicyEditProposer(opts) {
         maximumCharge: maximumChargeForLlmRequest(request, opts.llm),
         tags: { generation: String(ctx.generation) },
         signal: ctx.signal,
-        execute: (signal, callId) => callLlmJson(request, { ...opts.llm, signal, idempotencyKey: callId }),
+        execute: (signal, callId) => callLlmJson(request, {
+          ...opts.llm,
+          jsonPayloadMode: "exact",
+          signal,
+          idempotencyKey: callId
+        }),
         receipt: ({ result }) => costReceiptFromLlm(result),
         receiptFromError: costReceiptFromLlmError
       });
@@ -5725,7 +6067,7 @@ function llmPolicyEditProposer(opts) {
           findingByKey,
           opts.targetSurface,
           allowedPathSet,
-          objectiveByKey,
+          objectives[0],
           ctx.incumbentOutcome?.composite ?? ctx.baselineOutcome?.composite
         )
       );
@@ -5773,6 +6115,7 @@ function projectPolicyEditHistoryWithProjector(history, limits, scenarioIds, obj
           candidate,
           scenarioIds,
           limits.maxScenariosPerCandidate,
+          limits.scenarioOrder,
           candidate.parentSurfaceHash ? candidateByHash.get(candidate.parentSurfaceHash)?.scenarios : void 0,
           objectiveByKey
         )
@@ -5798,10 +6141,11 @@ function selectHistoryCandidates(record, limit) {
   }
   return selected;
 }
-function projectHistoryCandidate(candidate, scenarioIds, maxScenarios, parentScenarios, objectiveByKey) {
+function projectHistoryCandidate(candidate, scenarioIds, maxScenarios, scenarioOrder, parentScenarios, objectiveByKey) {
   const referenceByScenario = parentScenarios ? new Map(parentScenarios.map((scenario) => [scenario.scenarioId, scenario.composite])) : void 0;
   const selectedScenarios = selectPolicyEditAuthorRows(candidate.scenarios, {
     limit: maxScenarios,
+    scenarioOrder,
     ...referenceByScenario ? { referenceByScenario } : {}
   });
   const validatedRecord = candidate.candidateRecord ? validatePolicyEditCandidateRecord(candidate.candidateRecord) : void 0;
@@ -5835,11 +6179,12 @@ function projectHistoryCandidate(candidate, scenarioIds, maxScenarios, parentSce
     forecastCalibration: forecastCalibration(candidate, validatedRecord, objectiveByKey)
   };
 }
-function projectOutcome(outcome, scenarioIds, maxScenarios, reference = void 0) {
+function projectOutcome(outcome, scenarioIds, maxScenarios, scenarioOrder, reference = void 0) {
   if (!outcome) return null;
   const referenceByScenario = reference ? new Map(reference.scenarios.map((scenario) => [scenario.scenarioId, scenario.composite])) : void 0;
   const selectedScenarios = selectPolicyEditAuthorRows(outcome.scenarios, {
     limit: maxScenarios,
+    scenarioOrder,
     ...referenceByScenario ? { referenceByScenario } : {}
   });
   return {
@@ -6092,6 +6437,7 @@ function validateHistoryLimits(options) {
   const maxGenerations = options.maxGenerations ?? DEFAULT_POLICY_EDIT_HISTORY_LIMITS.generations;
   const maxCandidatesPerGeneration = options.maxCandidatesPerGeneration ?? DEFAULT_POLICY_EDIT_HISTORY_LIMITS.candidatesPerGeneration;
   const maxScenariosPerCandidate = options.maxScenariosPerCandidate ?? DEFAULT_POLICY_EDIT_HISTORY_LIMITS.scenariosPerCandidate;
+  const scenarioOrder = options.scenarioOrder ?? "ranked";
   if (!Number.isSafeInteger(maxGenerations) || maxGenerations <= 0) {
     throw new Error("llmPolicyEditProposer: maxHistoryGenerations must be a positive safe integer");
   }
@@ -6105,10 +6451,14 @@ function validateHistoryLimits(options) {
       "llmPolicyEditProposer: maxScenariosPerCandidate must be a positive safe integer"
     );
   }
+  if (scenarioOrder !== "ranked" && scenarioOrder !== "input") {
+    throw new Error("llmPolicyEditProposer: scenarioOrder must be 'ranked' or 'input'");
+  }
   return {
     maxGenerations,
     maxCandidatesPerGeneration,
     maxScenariosPerCandidate,
+    scenarioOrder,
     scenarioIdTransform: options.scenarioIdTransform ?? ((scenarioId) => scenarioId)
   };
 }
@@ -6163,18 +6513,10 @@ function parseAuthorResponse(value) {
   const issues = parsed.error.issues.map((issue) => `${issue.path.join(".") || "<root>"}: ${issue.message}`).join("; ");
   throw new Error(`llmPolicyEditProposer: invalid PolicyEdit response: ${issues}`);
 }
-function bindAuthoredEdit(draft, findingByKey, targetSurface, allowedPaths, objectiveByKey, currentComposite) {
-  if (draft.target.surface !== targetSurface) {
+function bindAuthoredEdit(draft, findingByKey, targetSurface, allowedPaths, objective, currentComposite) {
+  if (!allowedPaths.has(draft.target.path)) {
     throw new Error(
-      `llmPolicyEditProposer: target surface '${draft.target.surface}' does not match '${targetSurface}'`
-    );
-  }
-  if (draft.target.path !== draft.change.path) {
-    throw new Error("llmPolicyEditProposer: target.path must equal change.path");
-  }
-  if (!allowedPaths.has(draft.change.path)) {
-    throw new Error(
-      `llmPolicyEditProposer: JSON path '${draft.change.path}' is outside allowedJsonPaths`
+      `llmPolicyEditProposer: JSON path '${draft.target.path}' is outside allowedJsonPaths`
     );
   }
   const cited = draft.source.findingKeys.map((findingKey) => {
@@ -6190,22 +6532,6 @@ function bindAuthoredEdit(draft, findingByKey, targetSurface, allowedPaths, obje
   if (evidenceRefs.length === 0) {
     throw new Error("llmPolicyEditProposer: authored edit has no cited evidence");
   }
-  const objective = objectiveByKey.get(draft.expectedGain.metric);
-  if (!objective) {
-    throw new Error(
-      `llmPolicyEditProposer: unknown forecast objective '${draft.expectedGain.metric}'`
-    );
-  }
-  if (draft.expectedGain.direction !== objective.direction) {
-    throw new Error(
-      `llmPolicyEditProposer: forecast direction for '${objective.key}' must be '${objective.direction}'`
-    );
-  }
-  if (draft.expectedGain.unit !== objective.unit) {
-    throw new Error(
-      `llmPolicyEditProposer: forecast unit for '${objective.key}' must be '${objective.unit}'`
-    );
-  }
   const maxGain = currentComposite === void 0 ? objective.scale.max - objective.scale.min : objective.scale.max - currentComposite;
   if (draft.expectedGain.amount > maxGain) {
     throw new Error(
@@ -6213,20 +6539,26 @@ function bindAuthoredEdit(draft, findingByKey, targetSurface, allowedPaths, obje
     );
   }
   const expectedGain = {
-    metric: draft.expectedGain.metric,
-    direction: draft.expectedGain.direction,
+    metric: objective.key,
+    direction: objective.direction,
     amount: draft.expectedGain.amount,
-    ...draft.expectedGain.unit ? { unit: draft.expectedGain.unit } : {},
+    unit: objective.unit,
     ...draft.expectedGain.rationale ? { rationale: draft.expectedGain.rationale } : {}
   };
+  const change = draft.change.mode === "remove" ? { kind: "json", mode: "remove", path: draft.target.path } : {
+    kind: "json",
+    mode: draft.change.mode,
+    path: draft.target.path,
+    value: draft.change.value
+  };
   const init = {
     axis: draft.axis,
     target: {
-      surface: draft.target.surface,
+      surface: targetSurface,
       path: draft.target.path,
       ...draft.target.label ? { label: draft.target.label } : {}
     },
-    change: draft.change,
+    change,
     claim: draft.claim,
     expectedGain,
     confidence: draft.confidence,
@@ -6544,6 +6876,33 @@ ${block}
 }
 
 // src/campaign/proposers/trace-analyst.ts
+async function analyzeOtlpTraceFile(opts) {
+  if (!opts.apiKey) throw new Error("analyzeOtlpTraceFile: apiKey is required");
+  if (!opts.model) throw new Error("analyzeOtlpTraceFile: model is required");
+  const aiService = createAnalystAi({
+    provider: opts.provider ?? "openai",
+    apiKey: opts.apiKey,
+    baseUrl: opts.baseUrl,
+    model: opts.model
+  });
+  const registry = new AnalystRegistry();
+  for (const spec of opts.kinds ?? DEFAULT_TRACE_ANALYST_KINDS) {
+    registry.register(createTraceAnalystKind(spec, { ai: aiService, model: opts.model }));
+  }
+  const result = await registry.run(
+    opts.runId,
+    { traceStore: new OtlpFileTraceStore({ path: opts.tracePath }) },
+    {
+      signal: opts.signal ?? new AbortController().signal,
+      chainFindings: true,
+      ...opts.costLedger ? { costLedger: opts.costLedger } : {},
+      ...opts.costPhase ? { costPhase: opts.costPhase } : {},
+      ...opts.priorFindings === void 0 ? {} : { priorFindings: opts.priorFindings }
+    }
+  );
+  if (result.findings.length === 0) throw noFindingsError(result);
+  return result.findings;
+}
 function renderFindings(findings) {
   return findings.map((f, i) => {
     const action = f.recommended_action ? `
@@ -6562,30 +6921,20 @@ function traceAnalystProposer(opts) {
   }
   const kinds = opts.kinds ?? DEFAULT_TRACE_ANALYST_KINDS;
   const produceFindings = opts.analyze ?? (async (path, c) => {
-    const aiService = createAnalystAi({
+    const priorFindings = await opts.resolvePriorFindings?.(c);
+    return analyzeOtlpTraceFile({
+      tracePath: path,
+      runId: `trace-analyst-gen-${c.generation}`,
       provider: opts.provider ?? "openai",
       apiKey: opts.apiKey,
       baseUrl: opts.baseUrl,
-      model: opts.model
+      model: opts.model,
+      kinds,
+      signal: c.signal,
+      costLedger: c.costLedger,
+      costPhase: c.costPhase,
+      ...priorFindings === void 0 ? {} : { priorFindings }
     });
-    const registry = new AnalystRegistry();
-    for (const spec of kinds) {
-      registry.register(createTraceAnalystKind(spec, { ai: aiService, model: opts.model }));
-    }
-    const priorFindings = await opts.resolvePriorFindings?.(c);
-    const result = await registry.run(
-      `trace-analyst-gen-${c.generation}`,
-      { traceStore: new OtlpFileTraceStore({ path }) },
-      {
-        signal: c.signal,
-        chainFindings: true,
-        costLedger: c.costLedger,
-        costPhase: c.costPhase,
-        ...priorFindings === void 0 ? {} : { priorFindings }
-      }
-    );
-    if (result.findings.length === 0) throw noFindingsError(result);
-    return result.findings;
   });
   return analysisEditProposer({
     kind: "trace-analyst",
@@ -8347,12 +8696,13 @@ export {
   skillOptProposer,
   SkillPatchParseError,
   parseSkillPatchResponse,
+  compareOptimizationMethods,
+  costFromLedgerSummary,
   runSkillOpt,
-  compareProposers,
-  gepaReflectionEntry,
-  gepaParetoEntry,
-  skillOptEntry,
-  fapoEscalationEntry,
+  gepaReflectionMethod,
+  gepaParetoMethod,
+  skillOptMethod,
+  fapoEscalationMethod,
   makePlaybackDispatch,
   scoreUserStory,
   userStoryScoreboard,
@@ -8371,6 +8721,7 @@ export {
   llmPolicyEditProposer,
   projectPolicyEditHistory,
   memoryCurationProposer,
+  analyzeOtlpTraceFile,
   traceAnalystProposer,
   scoreDiscrimination,
   selectDiscriminative,
@@ -8385,4 +8736,4 @@ export {
   verifyCodeSurface,
   resolveWorktreePath
 };
-//# sourceMappingURL=chunk-RQP5UTK5.js.map
+//# sourceMappingURL=chunk-LT4J7ULK.js.map