@tangle-network/agent-eval 0.115.3 → 0.117.0

package/dist/{chunk-KG4TD7EQ.js → chunk-ZUXV7UWZ.js}

@@ -1,57 +1,68 @@
 import {
+  JudgeParseError,
   assertCodeSurfaceIdentity,
   campaignBreakdown,
   campaignMeanComposite,
+  costReceiptFromTCloud,
   defaultProductionGate,
   gepaProposer,
   isProposedCandidate,
   labelTrustRank,
+  maximumChargeForTCloudRequest,
   pairHoldout,
   recoverTruncatedJson,
   renderAnalystEvidence,
   runImprovementLoop,
   surfaceContentHash,
   surfaceHash
-} from "./chunk-ADYLPOSX.js";
-import {
-  estimateCost,
-  isModelPriced
-} from "./chunk-VI2UW6B6.js";
+} from "./chunk-HQPHZGL6.js";
 import {
+  SearchLedgerConflictError,
+  SearchLedgerError,
+  SearchLedgerIntegrityError,
+  appendSearchLedgerLine,
   assertRealBackend,
   contentHash,
+  createRunCostLedger,
+  fsCampaignStorage,
   planCampaignRun,
+  resolveRunDir,
   runCampaign,
-  summarizeBackendIntegrity
-} from "./chunk-FAOEFFRT.js";
+  summarizeBackendIntegrity,
+  withSearchLedgerFileLock
+} from "./chunk-IDZTTFRR.js";
 import {
-  Mutex,
-  admitPolicyEdit,
-  applyPolicyEditToSurface,
-  clamp01,
-  isPolicyEdit,
-  policyEditsFromFindings
-} from "./chunk-QMXXSNC4.js";
+  Mutex
+} from "./chunk-3YYRZDON.js";
 import {
   AnalystRegistry,
   DEFAULT_TRACE_ANALYST_KINDS,
-  createTraceAnalystKind
-} from "./chunk-5S5NJ63F.js";
+  POLICY_EDIT_AXES,
+  POLICY_EDIT_TARGET_SURFACES,
+  admitPolicyEdit,
+  applyPolicyEditToSurface,
+  assertNoJudgeVerdict,
+  createTraceAnalystKind,
+  isPolicyEdit,
+  makePolicyEdit,
+  makePolicyEditCandidateRecord,
+  policyEditsFromFindings,
+  validatePolicyEditCandidateRecord
+} from "./chunk-MGEHEHSN.js";
 import {
   eProcess,
   mcnemar,
   mulberry32,
   pairedBootstrap,
   pairedRiskDifference,
-  weightedComposite,
   wilcoxonSignedRank
 } from "./chunk-PJQFMIOX.js";
 import {
   analyzeTraces
-} from "./chunk-RPDDVKI7.js";
+} from "./chunk-4JLWXDYA.js";
 import {
   OtlpFileTraceStore
-} from "./chunk-LNQEP766.js";
+} from "./chunk-S2F4J57L.js";
 import {
   modelHasSnapshot,
   validateRunRecord
@@ -63,11 +74,18 @@ import {
   canonicalize
 } from "./chunk-VSMTAMNK.js";
 import {
-  callLlm
-} from "./chunk-GY4SYVPJ.js";
+  callLlm,
+  callLlmJson,
+  costReceiptFromLlm,
+  costReceiptFromLlmError,
+  maximumChargeForLlmRequest
+} from "./chunk-NJC7U437.js";
+import {
+  CostAccountingIncompleteError,
+  CostLedger
+} from "./chunk-VCTY3W6J.js";
 import {
   AgentEvalError,
-  JudgeError,
   ValidationError
 } from "./chunk-ONWEPEDO.js";
 
@@ -489,339 +507,6 @@ async function runLineage(opts) {
   return { lineage, best: lineage.best(), steps };
 }
 
-// src/judges.ts
-var JudgeParseError = class extends JudgeError {
-  /** Name of the judge whose response failed to parse. */
-  judgeName;
-  /** The raw (truncated) model response that failed to parse. */
-  raw;
-  constructor(judgeName, raw, options) {
-    super(`judge '${judgeName}' returned an unparseable response: ${raw.slice(0, 200)}`, options);
-    this.judgeName = judgeName;
-    this.raw = raw;
-  }
-};
-function createDomainExpertJudge(domain) {
-  return async (tc, { scenario, turns }) => {
-    const conversation = turns.map(
-      (t, i) => `Turn ${i + 1}:
-User: ${t.userMessage}
-Agent: ${t.agentResponse.slice(0, 2e3)}`
-    ).join("\n\n---\n\n");
-    const resp = await tc.chat({
-      model: "gpt-4o",
-      messages: [
-        {
-          role: "system",
-          content: `You are a senior ${domain} professional with 20+ years of experience. You are evaluating an AI agent's responses for professional accuracy and depth.
-
-Score STRICTLY. A 5 means "a junior professional could do this." An 8 means "solid mid-career work." A 10 means "I would hire this agent."
-
-Evaluate:
-1. **domain_accuracy** (0-10): Are the technical terms correct? Are the recommendations what you'd actually do? Would this advice cause problems if followed?
-2. **professional_depth** (0-10): Does it go beyond surface-level? Does it consider practical constraints, edge cases, industry standards? Or is it generic textbook advice?
-
-Respond with JSON only: [{"dimension":"domain_accuracy","score":N,"reasoning":"...","evidence":"quote from response"},{"dimension":"professional_depth","score":N,"reasoning":"...","evidence":"quote"}]`
-        },
-        {
-          role: "user",
-          content: `Persona: ${scenario.persona} (${scenario.label})
-Scenario: ${scenario.thesis}
-
-${conversation}`
-        }
-      ],
-      temperature: 0.1,
-      maxTokens: 800
-    });
-    return parseJudgeResponse("domain_expert", resp);
-  };
-}
-var codeExecutionJudge = async (tc, { scenario, artifacts }) => {
-  const codeBlocks = artifacts.codeBlocks;
-  if (codeBlocks.length === 0) {
-    return [
-      {
-        judgeName: "code_execution",
-        dimension: "code_execution",
-        score: 0,
-        reasoning: "No code blocks found in agent response."
-      }
-    ];
-  }
-  const codeText = codeBlocks.map(
-    (b, i) => `Block ${i + 1} (${b.language}):
-\`\`\`${b.language}
-${b.code.slice(0, 3e3)}
-\`\`\``
-  ).join("\n\n");
-  const resp = await tc.chat({
-    model: "gpt-4o",
-    messages: [
-      {
-        role: "system",
-        content: `You are a principal software engineer reviewing code written by an AI agent.
-
-Score STRICTLY:
-1. **executability** (0-10): Would this code run without errors? Check: import errors, undefined variables, missing deps, syntax errors. A 5 means "would run with minor fixes." A 10 means "copy-paste and it works."
-2. **completeness** (0-10): Does it handle the FULL task, or just the happy path? A 5 means "handles the main case." A 10 means "production-ready."
-3. **reusability** (0-10): Could this be saved as a tool and reused? A 5 means "works for this case." A 10 means "general-purpose tool."
-
-Respond with JSON only: [{"dimension":"executability","score":N,"reasoning":"...","evidence":"specific line/issue"},{"dimension":"completeness","score":N,"reasoning":"...","evidence":"..."},{"dimension":"reusability","score":N,"reasoning":"...","evidence":"..."}]`
-      },
-      {
-        role: "user",
-        content: `Task: ${scenario.thesis}
-
-${codeText}`
-      }
-    ],
-    temperature: 0.1,
-    maxTokens: 1e3
-  });
-  return parseJudgeResponse("code_execution", resp);
-};
-var coherenceJudge = async (tc, { scenario, turns }) => {
-  if (turns.length < 2) {
-    return [];
-  }
-  const conversation = turns.map(
-    (t, i) => `Turn ${i + 1}:
-User: ${t.userMessage}
-Agent (${t.agentResponse.length} chars): ${t.agentResponse.slice(0, 1500)}`
-  ).join("\n\n---\n\n");
-  const resp = await tc.chat({
-    model: "gpt-4o",
-    messages: [
-      {
-        role: "system",
-        content: `You evaluate whether an AI agent maintains coherence across a multi-turn conversation.
-
-Score STRICTLY:
-1. **consistency** (0-10): Does the agent contradict itself across turns? Does it remember what it said/built earlier?
-2. **progression** (0-10): Does each turn BUILD on the previous? Or does it start fresh? A 5 means "vaguely related." A 10 means "each turn clearly advances the work."
-3. **feedback_integration** (0-10): When the user gives feedback, does the agent demonstrate it HEARD the feedback?
-
-Respond with JSON only: [{"dimension":"consistency","score":N,"reasoning":"..."},{"dimension":"progression","score":N,"reasoning":"..."},{"dimension":"feedback_integration","score":N,"reasoning":"..."}]`
-      },
-      {
-        role: "user",
-        content: `Scenario: ${scenario.thesis}
-
-${conversation}`
-      }
-    ],
-    temperature: 0.1,
-    maxTokens: 800
-  });
-  return parseJudgeResponse("coherence", resp);
-};
-var adversarialJudge = async (tc, { scenario, turns }) => {
-  const conversation = turns.map(
-    (t, i) => `Turn ${i + 1}:
-User: ${t.userMessage}
-Agent: ${t.agentResponse.slice(0, 1500)}`
-  ).join("\n\n---\n\n");
-  const resp = await tc.chat({
-    model: "gpt-4o",
-    messages: [
-      {
-        role: "system",
-        content: `You are a red-team evaluator. Find the WEAKEST point in the AI agent's responses. Be adversarial.
-
-1. **hallucination** (0-10, inverted \u2014 10 means NO hallucination): Did the agent make up facts, cite nonexistent tools, invent standards?
-2. **false_confidence** (0-10, inverted \u2014 10 means appropriate uncertainty): Did the agent present uncertain information as fact?
-3. **worst_failure** (0-10, inverted \u2014 10 means no critical failures): What is the single worst thing in the response?
-
-Be harsh. If everything is genuinely good, say so \u2014 but look hard first.
-
-Respond with JSON only: [{"dimension":"hallucination","score":N,"reasoning":"...","evidence":"specific quote"},{"dimension":"false_confidence","score":N,"reasoning":"...","evidence":"..."},{"dimension":"worst_failure","score":N,"reasoning":"...","evidence":"..."}]`
-      },
-      {
-        role: "user",
-        content: `Persona: ${scenario.persona}
-Scenario: ${scenario.thesis}
-
-${conversation}`
-      }
-    ],
-    temperature: 0.2,
-    maxTokens: 800
-  });
-  return parseJudgeResponse("adversarial", resp);
-};
-function createCustomJudge(name, systemPrompt, opts) {
-  return async (tc, { scenario, turns }) => {
-    const conversation = turns.map(
-      (t, i) => `Turn ${i + 1}:
-User: ${t.userMessage}
-Agent: ${t.agentResponse.slice(0, 2e3)}`
-    ).join("\n\n---\n\n");
-    const resp = await tc.chat({
-      model: opts?.model ?? "gpt-4o",
-      messages: [
-        {
-          role: "system",
-          content: systemPrompt
-        },
-        {
-          role: "user",
-          content: `Persona: ${scenario.persona} (${scenario.label})
-Scenario: ${scenario.thesis}
-
-${conversation}`
-        }
-      ],
-      temperature: opts?.temperature ?? 0.1,
-      maxTokens: opts?.maxTokens ?? 1e3
-    });
-    return parseJudgeResponse(name, resp);
-  };
-}
-function defaultJudges(domain) {
-  return [createDomainExpertJudge(domain), codeExecutionJudge, coherenceJudge, adversarialJudge];
-}
-function parseJudgeResponse(judgeName, resp) {
-  const content = resp.choices?.[0]?.message?.content ?? "";
-  try {
-    let cleaned = content.replace(/```json\n?|\n?```/g, "").trim();
-    const arrayMatch = cleaned.match(/\[[\s\S]*\]/);
-    if (arrayMatch) cleaned = arrayMatch[0];
-    const parsed = JSON.parse(cleaned);
-    return parsed.map((p) => ({
-      judgeName,
-      dimension: p.dimension,
-      score: Math.max(0, Math.min(10, p.score)),
-      reasoning: p.reasoning ?? "",
-      evidence: p.evidence
-    }));
-  } catch (err) {
-    throw new JudgeParseError(judgeName, content, { cause: err });
-  }
-}
-
-// src/llm-judge.ts
-function llmJudge(name, prompt, opts) {
-  if (!name.trim()) {
-    throw new Error("llmJudge: name must be non-empty");
-  }
-  if (!prompt.trim()) {
-    throw new Error(`llmJudge '${name}': prompt must be non-empty`);
-  }
-  const model = opts.model ?? opts.chat.defaultModel;
-  if (!model) {
-    throw new Error(
-      `llmJudge '${name}': no model on opts and no defaultModel on the ChatClient \u2014 pass opts.model or bind defaultModel at createChatClient().`
-    );
-  }
-  const dimensions = normalizeDimensions(opts.dimensions, name);
-  const scale = opts.scale ?? "unit";
-  const divisor = scale === "ten" ? 10 : 1;
-  const renderUser = opts.renderUser ?? ((input) => JSON.stringify({ scenario: input.scenario, artifact: input.artifact }, null, 2));
-  if (opts.weights) {
-    for (const key of Object.keys(opts.weights)) {
-      if (!dimensions.some((d) => d.key === key)) {
-        throw new Error(
-          `llmJudge '${name}': weights names dimension '${key}' that is not declared in dimensions`
-        );
-      }
-    }
-  }
-  const systemPrompt = `${prompt}
-
-${renderContract(dimensions, scale)}`;
-  return {
-    name,
-    dimensions,
-    appliesTo: opts.appliesTo,
-    async score({ artifact, scenario, signal }) {
-      const response = await opts.chat.chat(
-        {
-          model,
-          messages: [
-            { role: "system", content: systemPrompt },
-            { role: "user", content: renderUser({ artifact, scenario }) }
-          ],
-          jsonMode: true,
-          temperature: opts.temperature ?? 0.1,
-          maxTokens: opts.maxTokens ?? 800
-        },
-        { signal }
-      );
-      const parsed = parseResponse(name, response.content);
-      const rawDims = parsed.dimensions ?? parsed.scores;
-      if (!rawDims || typeof rawDims !== "object") {
-        throw new JudgeParseError(name, response.content, {
-          cause: new Error("response has no `dimensions` object")
-        });
-      }
-      const dims = {};
-      for (const { key } of dimensions) {
-        const raw = rawDims[key];
-        const value = Number(raw);
-        if (raw === void 0 || raw === null || !Number.isFinite(value)) {
-          throw new JudgeParseError(name, response.content, {
-            cause: new Error(
-              `dimension '${key}' missing or non-numeric (got ${JSON.stringify(raw)})`
-            )
-          });
-        }
-        dims[key] = clamp01(value / divisor);
-      }
-      const weights = opts.weights ?? Object.fromEntries(dimensions.map((d) => [d.key, 1 / dimensions.length]));
-      const { composite } = weightedComposite({ dims, weights });
-      const notes = firstString(parsed.notes) ?? firstString(parsed.rationale) ?? `${name}: composite ${composite.toFixed(3)} over ${dimensions.length} dimension(s)`;
-      return { dimensions: dims, composite, notes };
-    }
-  };
-}
-function normalizeDimensions(input, name) {
-  const raw = input && input.length > 0 ? input : ["quality"];
-  const out = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const d of raw) {
-    const dim = typeof d === "string" ? { key: d, description: d } : d;
-    if (!dim.key.trim()) {
-      throw new Error(`llmJudge '${name}': dimension key must be non-empty`);
-    }
-    if (seen.has(dim.key)) {
-      throw new Error(`llmJudge '${name}': duplicate dimension key '${dim.key}'`);
-    }
-    seen.add(dim.key);
-    out.push(dim);
-  }
-  return out;
-}
-function renderContract(dimensions, scale) {
-  const range = scale === "ten" ? "0 to 10" : "0.0 to 1.0";
-  const lines = dimensions.map((d) => `  - "${d.key}": ${d.description} (score ${range})`);
-  const example = `{"dimensions": {${dimensions.map((d) => `"${d.key}": <number>`).join(", ")}}, "notes": "<one-line rationale>"}`;
-  return [
-    "Score the artifact on EACH of these dimensions:",
-    ...lines,
-    "",
-    `Respond with JSON ONLY, no prose. Every dimension is a number in [${range}]:`,
-    example
-  ].join("\n");
-}
-function parseResponse(name, content) {
-  const stripped = content.replace(/```json\n?|\n?```/g, "").trim();
-  const objMatch = stripped.match(/\{[\s\S]*\}/);
-  const payload = objMatch ? objMatch[0] : stripped;
-  try {
-    const parsed = JSON.parse(payload);
-    if (typeof parsed !== "object" || parsed === null) {
-      throw new Error("parsed value is not an object");
-    }
-    return parsed;
-  } catch (err) {
-    throw new JudgeParseError(name, content, { cause: err });
-  }
-}
-function firstString(value) {
-  return typeof value === "string" && value.trim() ? value : void 0;
-}
-
 // src/campaign/analyst-surface.ts
 function surfaceToText(surface) {
   if (typeof surface === "string") return surface;
@@ -3411,6 +3096,7 @@ var SKILLOPT_SYSTEM = 'You are a SkillOpt optimizer. You improve ONE skill docum
 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,
@@ -3422,19 +3108,29 @@ function skillOptProposer(opts) {
       findingsNote: args.findingsNote,
       count: args.count
     });
-    const result = await callLlm(
-      {
-        model: opts.model,
-        messages: [
-          { role: "system", content: SKILLOPT_SYSTEM },
-          { role: "user", content: userPrompt }
-        ],
-        jsonMode: true,
-        temperature: opts.temperature ?? 0.6,
-        maxTokens: opts.maxTokens ?? 4e3
-      },
-      opts.llm
-    );
+    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);
   }
   return {
@@ -3454,7 +3150,9 @@ function skillOptProposer(opts) {
         rejectedBuffer: [],
         findingsNote: renderAnalystEvidence(ctx.findings, ctx.report) ?? void 0,
         count: ctx.populationSize,
-        signal: ctx.signal
+        signal: ctx.signal,
+        costLedger: ctx.costLedger ?? directCostLedger,
+        costPhase: ctx.costPhase ?? "search.proposal"
       });
       const out = [];
       const seen = /* @__PURE__ */ new Set();
@@ -3618,16 +3316,20 @@ async function runSkillOpt(opts) {
   const budgetAnneal = opts.budgetAnneal ?? true;
   const rejectedBufferSize = opts.rejectedBufferSize ?? 12;
   const slowMetaEvery = opts.slowMetaEvery ?? 2;
-  let totalCostUsd = 0;
+  opts.runDir = resolveRunDir(opts.runDir, opts.repo);
+  const storage = opts.storage ?? fsCampaignStorage();
+  const costLedger = opts.costLedger ?? createRunCostLedger({
+    storage,
+    runDir: opts.runDir,
+    costCeilingUsd: opts.costCeiling
+  });
   const scoreHoldout = async (surface, tag) => {
-    const campaign = await runScoringCampaign(opts, opts.holdoutScenarios, surface, tag);
-    totalCostUsd += campaign.aggregates.totalCostUsd;
+    const campaign = await runScoringCampaign(opts, opts.holdoutScenarios, surface, tag, costLedger);
     return campaignMeanComposite(campaign);
   };
   const evidenceK = opts.evidenceK ?? 3;
   const trainEvidence = async (surface, tag) => {
-    const campaign = await runScoringCampaign(opts, opts.trainScenarios, surface, tag);
-    totalCostUsd += campaign.aggregates.totalCostUsd;
+    const campaign = await runScoringCampaign(opts, opts.trainScenarios, surface, tag, costLedger);
     return toEvidence(campaign, evidenceK);
   };
   let current = opts.baselineSurface;
@@ -3651,7 +3353,9 @@ async function runSkillOpt(opts) {
       rejectedBuffer: buffer,
       metaNote,
       count: patchesPerEpoch,
-      signal: opts.signal ?? new AbortController().signal
+      signal: opts.signal ?? new AbortController().signal,
+      costLedger,
+      costPhase: "skill-opt.proposal"
     });
     let accepted = null;
     const rejectedThisEpoch = [];
@@ -3710,6 +3414,7 @@ async function runSkillOpt(opts) {
     });
     if (sinceAccept >= patience) break;
   }
+  const cost = costLedger.summary();
   return {
     winnerSurface: current,
     baselineHoldoutComposite: baselineHoldout,
@@ -3719,12 +3424,14 @@ async function runSkillOpt(opts) {
     rejectedEdits: rejectedAll,
     epochsRun,
     history,
-    totalCostUsd
+    totalCostUsd: cost.totalCostUsd,
+    cost
   };
 }
-function runScoringCampaign(opts, scenarios, surface, tag) {
+function runScoringCampaign(opts, scenarios, surface, tag, costLedger) {
   return runCampaign({
     ...opts,
+    costLedger,
     scenarios,
     dispatch: (scenario, ctx) => opts.dispatchWithSurface(surface, scenario, ctx),
     runDir: `${opts.runDir}/${tag}`
@@ -3896,11 +3603,11 @@ function gepaEntry(config, combineParents, name) {
         ...config.analyzeGeneration ? { analyzeGeneration: config.analyzeGeneration } : {},
         ...config.report !== void 0 ? { report: config.report } : {}
       });
-      const costUsd = result.baselineCampaign.aggregates.totalCostUsd + result.generations.reduce(
-        (sum, g) => sum + g.surfaces.reduce((s, sf) => s + sf.campaign.aggregates.totalCostUsd, 0),
-        0
-      );
-      return { winnerSurface: result.winnerSurface, costUsd, durationMs: Date.now() - started };
+      return {
+        winnerSurface: result.winnerSurface,
+        costUsd: result.cost.totalCostUsd,
+        durationMs: Date.now() - started
+      };
     }
   };
 }
@@ -3973,11 +3680,11 @@ function fapoEscalationEntry(config, name = "fapo-escalation") {
         ...config.analyzeGeneration ? { analyzeGeneration: config.analyzeGeneration } : {},
         ...config.report !== void 0 ? { report: config.report } : {}
       });
-      const costUsd = result.baselineCampaign.aggregates.totalCostUsd + result.generations.reduce(
-        (sum, g) => sum + g.surfaces.reduce((s, sf) => s + sf.campaign.aggregates.totalCostUsd, 0),
-        0
-      );
-      return { winnerSurface: result.winnerSurface, costUsd, durationMs: Date.now() - started };
+      return {
+        winnerSurface: result.winnerSurface,
+        costUsd: result.cost.totalCostUsd,
+        durationMs: Date.now() - started
+      };
     }
   };
 }
@@ -4211,6 +3918,7 @@ function createLlmCorrectnessChecker(tc, opts = {}) {
   const model = opts.model ?? "claude-sonnet-4-6";
   const maxContentChars = opts.maxContentChars ?? 8e3;
   const maxAttempts = opts.maxAttempts ?? 2;
+  const costLedger = opts.costLedger ?? new CostLedger();
   const sink = opts.rawSink;
   const record = async (event) => {
     try {
@@ -4254,7 +3962,24 @@ ${content.slice(0, maxContentChars)}`
         redactedFields: []
       });
       try {
-        const resp = await tc.chat(request);
+        const paid = await costLedger.runPaidCall({
+          channel: "verifier",
+          phase: opts.costPhase ?? "completion.correctness",
+          actor: "correctness-checker",
+          model,
+          maximumCharge: maximumChargeForTCloudRequest(request, opts.tcloudMaximumAttempts),
+          tags: {
+            ...opts.costTags,
+            requirementId: requirement.reqId,
+            attempt: String(attempt)
+          },
+          signal: opts.signal,
+          execute: () => tc.chat(request),
+          receipt: (response) => costReceiptFromTCloud(response, model),
+          receiptFromError: (error) => opts.receiptFromError?.(error, attempt)
+        });
+        if (!paid.succeeded) throw paid.error;
+        const resp = paid.value;
         const raw = resp.choices?.[0]?.message?.content ?? "";
         await record({
           eventId: randomUUID(),
@@ -4770,12 +4495,12 @@ function requireResolvedModel(cell, profileId) {
   const resolved = cell.resolvedModel?.trim();
   if (!resolved) {
     throw new ProfileMatrixError(
-      `profile '${profileId}' declared the '${HARNESS_NATIVE_MODEL}' runtime-resolved model but its dispatch reported no resolved model for cell '${cell.cellId}' \u2014 report it via ctx.cost.observeModel(<id>) so the RunRecord pins the real model (never records '${HARNESS_NATIVE_MODEL}')`
+      `profile '${profileId}' declared the '${HARNESS_NATIVE_MODEL}' runtime-resolved model but its dispatch reported no resolved model for cell '${cell.cellId}' \u2014 return it in the ctx.cost.runPaidCall receipt so the RunRecord pins the real model (never records '${HARNESS_NATIVE_MODEL}')`
     );
   }
   if (!modelHasSnapshot(resolved)) {
     throw new ProfileMatrixError(
-      `profile '${profileId}' resolved to model '${resolved}' for cell '${cell.cellId}', which lacks a snapshot version \u2014 pin it (name@YYYY-MM-DD or name-YYYYMMDD) before reporting it via ctx.cost.observeModel`
+      `profile '${profileId}' resolved to model '${resolved}' for cell '${cell.cellId}', which lacks a snapshot version \u2014 pin it (name@YYYY-MM-DD or name-YYYYMMDD) in the paid-call receipt`
     );
   }
   return resolved;
@@ -4801,14 +4526,9 @@ function buildRunRecord(args) {
   }
   const perDimMean = {};
   for (const [dim, values] of Object.entries(dimAccum)) perDimMean[dim] = mean3(values);
-  let costUsd = cell.costUsd;
-  let costEstimated = false;
-  if (costUsd === 0 && cell.tokenUsage.output > 0 && isModelPriced(model)) {
-    costUsd = estimateCost(cell.tokenUsage.input, cell.tokenUsage.output, model);
-    costEstimated = costUsd > 0;
-  }
+  const costUsd = cell.costUsd;
   raw.cost_usd = costUsd;
-  raw.cost_estimated = costEstimated ? 1 : 0;
+  raw.cost_estimated = cell.costEstimated ? 1 : 0;
   raw.tokens_input = cell.tokenUsage.input;
   raw.tokens_output = cell.tokenUsage.output;
   if (typeof cell.tokenUsage.cached === "number") raw.tokens_cached = cell.tokenUsage.cached;
@@ -4951,11 +4671,8 @@ async function runProfileMatrix(opts) {
       profileRecords.push(record);
       records.push(record);
     }
-    const pricedTotalCostUsd = profileRecords.reduce((a, r) => a + r.costUsd, 0);
-    campaigns[profileId] = {
-      ...campaign,
-      aggregates: { ...campaign.aggregates, totalCostUsd: pricedTotalCostUsd }
-    };
+    const totalCostUsd = campaign.aggregates.totalCostUsd;
+    campaigns[profileId] = campaign;
     byProfile[profileId] = {
       profileId,
       profileHash,
@@ -4965,7 +4682,7 @@ async function runProfileMatrix(opts) {
       model: declaredModel === HARNESS_NATIVE_MODEL ? profileRecords[0]?.model ?? declaredModel : declaredModel,
       records: profileRecords.length,
       meanComposite: mean3(profileRecords.map(compositeOf)),
-      totalCostUsd: pricedTotalCostUsd,
+      totalCostUsd,
       integrity: summarizeBackendIntegrity(profileRecords)
     };
   }
@@ -5130,10 +4847,16 @@ function compositeProposer(opts) {
             const surface = isCandidate ? proposal.surface : proposal;
             const label = isCandidate ? proposal.label : "candidate";
             const rationale = isCandidate ? proposal.rationale : "";
+            const candidateRecord = isCandidate ? proposal.candidateRecord : void 0;
             const key = surfaceContentHash(surface);
             if (seen.has(key)) continue;
             seen.add(key);
-            pool.push({ surface, label: `${member.kind}:${label}`, rationale });
+            pool.push({
+              surface,
+              label: `${member.kind}:${label}`,
+              rationale,
+              ...candidateRecord ? { candidateRecord } : {}
+            });
           }
         } catch (err) {
           errors.push(`${member.kind}: ${err instanceof Error ? err.message : String(err)}`);
@@ -5176,36 +4899,78 @@ function surfaceToPromptText(surface) {
   return typeof surface === "string" ? surface : JSON.stringify(surface);
 }
 function analysisEditProposer(opts) {
+  const directCostLedger = opts.costLedger ?? new CostLedger();
   return {
     kind: opts.kind,
     async propose(ctx) {
       const parent = surfaceToPromptText(ctx.currentSurface);
+      const costLedger = ctx.costLedger ?? directCostLedger;
+      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");
       writeFileSync2(tracePath, traces.endsWith("\n") ? traces : `${traces}
 `);
-      const report = await opts.analyze(tracePath, ctx);
-      const applied = await callLlm(
-        {
-          model: opts.applyModel,
-          messages: [
-            { role: "system", content: APPLY_SYSTEM },
-            {
-              role: "user",
-              content: `CURRENT PROMPT:
+      if (costLedger.costCeilingUsd !== void 0 && !opts.analysisReceipt) {
+        throw new CostAccountingIncompleteError(
+          `${opts.kind}: capped analysis requires analysisReceipt before external execution`
+        );
+      }
+      const analysis = await costLedger.runPaidCall({
+        channel: "analyst",
+        phase,
+        actor: `${opts.kind}.analyze`,
+        model: opts.analysisModel,
+        maximumCharge: opts.analysisMaximumCharge,
+        tags: { generation: String(ctx.generation) },
+        signal: ctx.signal,
+        execute: (signal) => opts.analyze(tracePath, { ...ctx, signal }),
+        receipt: (report2) => opts.analysisReceipt?.(report2) ?? {
+          model: opts.analysisModel,
+          inputTokens: 0,
+          outputTokens: 0,
+          costUnknown: true
+        }
+      });
+      if (!analysis.succeeded) throw analysis.error;
+      const report = analysis.value;
+      const request = {
+        model: opts.applyModel,
+        messages: [
+          { role: "system", content: APPLY_SYSTEM },
+          {
+            role: "user",
+            content: `CURRENT PROMPT:
 ${parent}
 
 TRACE-ANALYSIS REPORT:
 ${report}
 
 Return the full revised prompt.`
-            }
-          ]
-        },
-        { baseUrl: opts.baseUrl, apiKey: opts.apiKey, fetch: opts.fetchImpl }
-      );
+          }
+        ],
+        maxTokens: opts.applyMaxTokens ?? 6e3
+      };
+      const llm = {
+        baseUrl: opts.baseUrl,
+        apiKey: opts.apiKey,
+        fetch: opts.fetchImpl
+      };
+      const apply = await costLedger.runPaidCall({
+        channel: "driver",
+        phase,
+        actor: `${opts.kind}.apply`,
+        model: opts.applyModel,
+        maximumCharge: maximumChargeForLlmRequest(request, llm),
+        tags: { generation: String(ctx.generation) },
+        signal: ctx.signal,
+        execute: (signal, callId) => callLlm(request, { ...llm, signal, idempotencyKey: callId }),
+        receipt: costReceiptFromLlm,
+        receiptFromError: costReceiptFromLlmError
+      });
+      if (!apply.succeeded) throw apply.error;
+      const applied = apply.value;
       const text = applied.content.trim();
       if (!text || text === parent) return [];
       return [{ surface: text, label: opts.label, rationale: opts.rationale(report) }];
@@ -5224,7 +4989,12 @@ function haloProposer(opts) {
     label: "halo",
     baseUrl: opts.baseUrl,
     apiKey: opts.apiKey,
+    analysisModel: model,
     applyModel: opts.applyModel ?? model,
+    costLedger: opts.costLedger,
+    analysisMaximumCharge: opts.analysisMaximumCharge,
+    analysisReceipt: opts.analysisReceipt,
+    applyMaxTokens: opts.applyMaxTokens,
     fetchImpl: opts.fetchImpl,
     resolveTraces: opts.resolveTraces,
     noTracesError: "haloProposer: resolveTraces returned no OTLP traces \u2014 the halo engine has nothing to analyze",
@@ -5264,85 +5034,8 @@ ${findings.slice(0, 800)}`,
   });
 }
 
-// src/campaign/proposers/memory.ts
-var BLOCK_START2 = "<!-- BEGIN curated-memory (auto-managed by memoryCurationProposer) -->";
-var BLOCK_END2 = "<!-- END curated-memory -->";
-var DEFAULT_HEADING2 = "## Learned from prior runs (curated memory)";
-var DISTILL_SYSTEM = 'You compress raw trace-analysis findings into crisp, generalizable agent guidance. Output ONLY a JSON array of strings, each one imperative lesson the agent should follow (e.g. "Always fetch a resource before mutating it"). No prose outside the JSON. Deduplicate; keep the most actionable and general; drop case-specific noise.';
-function extractExistingLessons(text) {
-  return extractBlockBody(text, BLOCK_START2, BLOCK_END2).split("\n").map((l) => l.replace(/^\s*-\s+/, "").trim()).filter((l) => l && !l.startsWith("#"));
-}
-async function distillLessons(raw, distill) {
-  const res = await callLlm(
-    {
-      model: distill.model,
-      messages: [
-        { role: "system", content: DISTILL_SYSTEM },
-        { role: "user", content: `Findings:
-${raw.map((r) => `- ${r}`).join("\n")}` }
-      ]
-    },
-    { baseUrl: distill.baseUrl, apiKey: distill.apiKey, fetch: distill.fetchImpl }
-  );
-  try {
-    const parsed = JSON.parse(res.content.trim());
-    if (Array.isArray(parsed)) {
-      const lessons = parsed.filter(
-        (x) => typeof x === "string" && x.trim().length > 0
-      );
-      if (lessons.length > 0) return lessons;
-    }
-  } catch {
-  }
-  return raw;
-}
-function memoryCurationProposer(opts = {}) {
-  const maxEntries = opts.maxEntries ?? 12;
-  const heading = opts.sectionHeading ?? DEFAULT_HEADING2;
-  return {
-    kind: "memory-curation",
-    async propose(ctx) {
-      const parent = surfaceToText2(ctx.currentSurface);
-      const fresh = [];
-      for (const f of ctx.findings ?? []) {
-        const l = findingToLesson(f);
-        if (l) fresh.push(l);
-      }
-      const carried = extractExistingLessons(parent);
-      if (fresh.length === 0 && carried.length === 0) return [];
-      const distilled = opts.distill && fresh.length > 0 ? await distillLessons(fresh, opts.distill) : fresh;
-      const byKey = /* @__PURE__ */ new Map();
-      for (const l of carried) {
-        const k = normKey(l);
-        if (k) byKey.set(k, { text: l, count: 1 });
-      }
-      for (const l of distilled) {
-        const k = normKey(l);
-        if (!k) continue;
-        const e = byKey.get(k);
-        if (e) e.count += 1;
-        else byKey.set(k, { text: l, count: 1 });
-      }
-      const ranked = [...byKey.values()].sort((a, b) => b.count - a.count || a.text.localeCompare(b.text)).slice(0, maxEntries);
-      if (ranked.length === 0) return [];
-      const block = [BLOCK_START2, heading, ...ranked.map((e) => `- ${e.text}`), BLOCK_END2].join(
-        "\n"
-      );
-      const next = `${stripBlock(parent, BLOCK_START2, BLOCK_END2)}
-
-${block}
-`;
-      if (next === parent) return [];
-      return [
-        {
-          surface: next,
-          label: "memory-curation",
-          rationale: `curated ${ranked.length} lessons (from ${fresh.length} new finding(s) + ${carried.length} carried)`
-        }
-      ];
-    }
-  };
-}
+// src/campaign/proposers/llm-policy-edit.ts
+import { z } from "zod";
 
 // src/campaign/proposers/policy-edit.ts
 function policyEditProposer(opts = {}) {
@@ -5355,17 +5048,21 @@ function policyEditProposer(opts = {}) {
         Math.min(opts.maxCandidates ?? ctx.populationSize, ctx.populationSize)
       );
       const out = [];
+      const seen = /* @__PURE__ */ new Set([surfaceContentHash(ctx.currentSurface)]);
       if (limit === 0) return out;
       for (const edit of edits) {
         const admission = admitPolicyEdit(edit, opts.admission);
         opts.onAdmission?.(admission);
         if (admission.decision !== "admit") continue;
         const surface = coerceCandidateSurface(applyPolicyEditToSurface(ctx.currentSurface, edit));
-        if (sameSurface(ctx.currentSurface, surface)) continue;
+        const hash = surfaceContentHash(surface);
+        if (seen.has(hash)) continue;
+        seen.add(hash);
         out.push({
           surface,
           label: `policy-edit:${edit.axis}`,
-          rationale: `${edit.editId} expected ${edit.expectedGain.direction} ${edit.expectedGain.metric} by ${edit.expectedGain.amount}; source findings [${edit.source.findingIds.join(", ")}]`
+          rationale: `${edit.editId} expected ${edit.expectedGain.direction} ${edit.expectedGain.metric} by ${edit.expectedGain.amount}; source findings [${edit.source.findingIds.join(", ")}]`,
+          candidateRecord: makePolicyEditCandidateRecord(edit)
         });
         if (out.length >= limit) break;
       }
@@ -5403,22 +5100,1206 @@ function coerceCandidateSurface(surface) {
   }
   throw new Error("policyEditProposer: policy edit produced an unsupported surface");
 }
-function sameSurface(a, b) {
-  return surfaceContentHash(a) === surfaceContentHash(b);
-}
 
-// src/campaign/proposers/trace-analyst.ts
-import { ai } from "@ax-llm/ax";
-function renderFindings(findings) {
-  return findings.map((f, i) => {
-    const action = f.recommended_action ? `
-   FIX: ${f.recommended_action}` : "";
-    const subject = f.subject ? ` (${f.subject})` : "";
-    return `${i + 1}. [${f.severity}/${f.area}]${subject} ${f.claim}${action}`;
-  }).join("\n");
-}
-function traceAnalystProposer(opts) {
-  if (!opts.apiKey) throw new Error("traceAnalystProposer: apiKey is required");
+// src/campaign/proposers/policy-edit-author-context.ts
+function selectPolicyEditAuthorRows(rows, options) {
+  assertPositiveSafeInteger(options.limit, "limit");
+  const unique2 = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    if (!row.scenarioId || row.scenarioId.trim() !== row.scenarioId) {
+      throw new Error("selectPolicyEditAuthorRows: scenarioId must be trimmed and non-empty");
+    }
+    if (!Number.isFinite(row.composite)) {
+      throw new Error(
+        `selectPolicyEditAuthorRows: composite must be finite for '${row.scenarioId}'`
+      );
+    }
+    if (unique2.has(row.scenarioId)) continue;
+    const reference = options.referenceByScenario?.get(row.scenarioId);
+    if (reference !== void 0 && !Number.isFinite(reference)) {
+      throw new Error(
+        `selectPolicyEditAuthorRows: reference must be finite for '${row.scenarioId}'`
+      );
+    }
+    unique2.set(row.scenarioId, {
+      row,
+      delta: reference === void 0 ? null : row.composite - reference
+    });
+  }
+  const hardest = [...unique2.values()].sort(
+    (a, b) => a.row.composite - b.row.composite || compareScenarioId(a.row, b.row)
+  );
+  const regressions = [...unique2.values()].filter((entry) => entry.delta !== null && entry.delta < 0).sort((a, b) => a.delta - b.delta || compareScenarioId(a.row, b.row));
+  const improvements = [...unique2.values()].filter((entry) => entry.delta !== null && entry.delta > 0).sort((a, b) => b.delta - a.delta || compareScenarioId(a.row, b.row));
+  const rankings = [hardest, regressions, improvements];
+  const maxDepth = Math.max(...rankings.map((ranking) => ranking.length), 0);
+  const selected = [];
+  const selectedIds = /* @__PURE__ */ new Set();
+  for (let depth = 0; depth < maxDepth && selected.length < options.limit; depth += 1) {
+    for (const ranking of rankings) {
+      const entry = ranking[depth];
+      if (!entry || selectedIds.has(entry.row.scenarioId)) continue;
+      selected.push(entry.row);
+      selectedIds.add(entry.row.scenarioId);
+      if (selected.length === options.limit) break;
+    }
+  }
+  return selected;
+}
+function assertPolicyEditAuthorContextBudget(value, maxChars) {
+  assertPositiveSafeInteger(maxChars, "maxChars");
+  const json = JSON.stringify(value);
+  if (json === void 0) {
+    throw new Error("assertPolicyEditAuthorContextBudget: value must serialize to JSON");
+  }
+  const actualChars = json.length;
+  if (actualChars > maxChars) {
+    throw new Error(
+      `assertPolicyEditAuthorContextBudget: serialized JSON exceeds budget (actualChars=${actualChars}, maxChars=${maxChars})`
+    );
+  }
+  return { json, actualChars, maxChars };
+}
+function compareScenarioId(a, b) {
+  return a.scenarioId < b.scenarioId ? -1 : a.scenarioId > b.scenarioId ? 1 : 0;
+}
+function assertPositiveSafeInteger(value, name) {
+  if (!Number.isSafeInteger(value) || value <= 0) {
+    throw new Error(`${name} must be a positive safe integer (got ${value})`);
+  }
+}
+
+// src/campaign/proposers/llm-policy-edit.ts
+var JSON_POLICY_EDIT_TARGET_SURFACES = [
+  "prompt",
+  "tool-contract",
+  "runtime-config",
+  "memory",
+  "agent-profile"
+];
+var NonEmptyStringSchema = z.string().trim().min(1);
+var JsonValueSchema = z.lazy(
+  () => z.union([
+    z.string(),
+    z.number().finite(),
+    z.boolean(),
+    z.null(),
+    z.array(JsonValueSchema),
+    z.record(NonEmptyStringSchema, JsonValueSchema)
+  ])
+);
+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
+  }).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),
+  risk: z.enum(["low", "medium", "high", "unknown"]),
+  source: z.object({
+    findingKeys: z.array(NonEmptyStringSchema).min(1).refine((ids) => new Set(ids).size === ids.length, "findingKeys must be unique")
+  }).strict(),
+  rationale: NonEmptyStringSchema.max(4e3).nullable(),
+  validationPlan: NonEmptyStringSchema.max(2e3).nullable()
+}).strict();
+var PolicyEditAuthorResponseSchema = z.object({
+  edits: z.array(AuthoredPolicyEditSchema)
+}).strict();
+var POLICY_EDIT_AUTHOR_JSON_SCHEMA = {
+  type: "object",
+  additionalProperties: false,
+  required: ["edits"],
+  properties: {
+    edits: {
+      type: "array",
+      items: {
+        type: "object",
+        additionalProperties: false,
+        required: [
+          "axis",
+          "target",
+          "change",
+          "claim",
+          "expectedGain",
+          "confidence",
+          "risk",
+          "source",
+          "rationale",
+          "validationPlan"
+        ],
+        properties: {
+          axis: { type: "string", enum: [...POLICY_EDIT_AXES] },
+          target: {
+            type: "object",
+            additionalProperties: false,
+            required: ["surface", "path", "label"],
+            properties: {
+              surface: { type: "string", enum: [...POLICY_EDIT_TARGET_SURFACES] },
+              path: { type: "string", minLength: 1 },
+              label: { type: ["string", "null"], maxLength: 200 }
+            }
+          },
+          change: {
+            anyOf: [
+              {
+                type: "object",
+                additionalProperties: false,
+                required: ["kind", "mode", "path", "value"],
+                properties: {
+                  kind: { const: "json" },
+                  mode: { const: "set" },
+                  path: { type: "string", minLength: 1 },
+                  value: {}
+                }
+              },
+              {
+                type: "object",
+                additionalProperties: false,
+                required: ["kind", "mode", "path", "value"],
+                properties: {
+                  kind: { const: "json" },
+                  mode: { const: "merge" },
+                  path: { type: "string", minLength: 1 },
+                  value: {}
+                }
+              },
+              {
+                type: "object",
+                additionalProperties: false,
+                required: ["kind", "mode", "path"],
+                properties: {
+                  kind: { const: "json" },
+                  mode: { const: "remove" },
+                  path: { type: "string", minLength: 1 }
+                }
+              }
+            ]
+          },
+          claim: { type: "string", minLength: 1, maxLength: 2e3 },
+          expectedGain: {
+            type: "object",
+            additionalProperties: false,
+            required: ["metric", "direction", "amount", "unit", "rationale"],
+            properties: {
+              metric: { type: "string", minLength: 1, maxLength: 400 },
+              direction: { type: "string", enum: ["increase", "decrease"] },
+              amount: { type: "number", exclusiveMinimum: 0 },
+              unit: {
+                type: ["string", "null"],
+                enum: ["absolute", "relative", "percent", "score", null]
+              },
+              rationale: { type: ["string", "null"], maxLength: 2e3 }
+            }
+          },
+          confidence: { type: "number", minimum: 0, maximum: 1 },
+          risk: { type: "string", enum: ["low", "medium", "high", "unknown"] },
+          source: {
+            type: "object",
+            additionalProperties: false,
+            required: ["findingKeys"],
+            properties: {
+              findingKeys: {
+                type: "array",
+                minItems: 1,
+                uniqueItems: true,
+                items: { type: "string", minLength: 1 }
+              }
+            }
+          },
+          rationale: { type: ["string", "null"], maxLength: 4e3 },
+          validationPlan: { type: ["string", "null"], maxLength: 2e3 }
+        }
+      }
+    }
+  }
+};
+function policyEditAuthorJsonSchema(maxItems, targetSurface, allowedJsonPaths, objectives) {
+  const schema = JSON.parse(JSON.stringify(POLICY_EDIT_AUTHOR_JSON_SCHEMA));
+  const properties = schema.properties;
+  const edits = properties.edits;
+  edits.maxItems = maxItems;
+  const item = edits.items;
+  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({
+  generations: 4,
+  candidatesPerGeneration: 16,
+  scenariosPerCandidate: 12,
+  findings: 32,
+  authorContextChars: 2e5
+});
+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}.',
+  "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.",
+  "Do not invent a finding, path, field, score, or task fact. Do not include schemaVersion, editId, metadata, prose, or undeclared keys."
+].join("\n");
+function llmPolicyEditProposer(opts) {
+  const allowedJsonPaths = validateAllowedJsonPaths(opts.allowedJsonPaths);
+  const allowedPathSet = new Set(allowedJsonPaths);
+  const objectives = validateObjectives(opts.objectives);
+  const objectiveByKey = new Map(objectives.map((objective) => [objective.key, objective]));
+  requireNonEmpty(opts.model, "model");
+  requireNonEmpty(opts.target, "target");
+  if (!JSON_POLICY_EDIT_TARGET_SURFACES.includes(opts.targetSurface)) {
+    throw new Error(
+      `llmPolicyEditProposer: targetSurface '${opts.targetSurface}' is not a JSON-backed surface`
+    );
+  }
+  if (opts.maxCandidates !== void 0 && (!Number.isSafeInteger(opts.maxCandidates) || opts.maxCandidates < 0)) {
+    throw new Error("llmPolicyEditProposer: maxCandidates must be a non-negative safe integer");
+  }
+  const admissionMode = opts.admissionMode ?? "evidence-only";
+  if (admissionMode !== "evidence-only" && admissionMode !== "strict") {
+    throw new Error("llmPolicyEditProposer: admissionMode must be 'evidence-only' or 'strict'");
+  }
+  if (opts.admission && admissionMode !== "strict") {
+    throw new Error("llmPolicyEditProposer: admission thresholds require admissionMode: 'strict'");
+  }
+  const historyLimits = validateHistoryLimits({
+    ...opts.maxHistoryGenerations === void 0 ? {} : { maxGenerations: opts.maxHistoryGenerations },
+    ...opts.maxHistoryCandidatesPerGeneration === void 0 ? {} : { maxCandidatesPerGeneration: opts.maxHistoryCandidatesPerGeneration },
+    ...opts.maxScenariosPerCandidate === void 0 ? {} : { maxScenariosPerCandidate: opts.maxScenariosPerCandidate },
+    ...opts.scenarioIdTransform === void 0 ? {} : { scenarioIdTransform: opts.scenarioIdTransform }
+  });
+  const maxFindings = positiveLimit(
+    opts.maxFindings ?? DEFAULT_POLICY_EDIT_HISTORY_LIMITS.findings,
+    "maxFindings"
+  );
+  const maxAuthorContextChars = positiveLimit(
+    opts.maxAuthorContextChars ?? DEFAULT_POLICY_EDIT_HISTORY_LIMITS.authorContextChars,
+    "maxAuthorContextChars"
+  );
+  const directCostLedger = opts.costLedger ?? new CostLedger();
+  return {
+    kind: "llm-policy-edit",
+    async propose(ctx) {
+      const limit = Math.min(ctx.populationSize, opts.maxCandidates ?? ctx.populationSize);
+      if (limit <= 0) return [];
+      const currentSurface = parseJsonSurface(ctx.currentSurface);
+      assertSearchOutcome(ctx.baselineOutcome, "baselineOutcome");
+      assertSearchOutcome(ctx.incumbentOutcome, "incumbentOutcome");
+      assertMeasuredCompositesInScale(ctx, objectives[0]);
+      const scenarioIds = createScenarioIdProjector(historyLimits.scenarioIdTransform);
+      registerOutcomeScenarioIds(ctx.baselineOutcome, scenarioIds);
+      registerOutcomeScenarioIds(ctx.incumbentOutcome, scenarioIds);
+      registerHistoryScenarioIds(ctx.history.slice(-historyLimits.maxGenerations), scenarioIds);
+      assertSurfaceIsTaskAgnostic(
+        { currentSurface, allowedJsonPaths, objectives, targetSurface: opts.targetSurface },
+        scenarioIds
+      );
+      const measuredSources = measuredSourceMeasurements(ctx);
+      const findings = citableFindings(ctx.findings, measuredSources, maxFindings);
+      const findingByKey = new Map(
+        findings.map((finding, index) => [`finding-${index + 1}`, finding])
+      );
+      const authorContext = {
+        target: scenarioIds.sanitize(opts.target),
+        targetSurface: opts.targetSurface,
+        allowedJsonPaths,
+        objectives,
+        candidateCount: limit,
+        generation: ctx.generation,
+        currentSurface,
+        findings: findings.map(
+          (finding, index) => renderFinding(finding, `finding-${index + 1}`, scenarioIds, measuredSources)
+        ),
+        baselineOutcome: projectOutcome(
+          ctx.baselineOutcome,
+          scenarioIds,
+          historyLimits.maxScenariosPerCandidate
+        ),
+        incumbentOutcome: projectOutcome(
+          ctx.incumbentOutcome,
+          scenarioIds,
+          historyLimits.maxScenariosPerCandidate,
+          ctx.baselineOutcome
+        ),
+        history: projectPolicyEditHistoryWithProjector(
+          ctx.history,
+          historyLimits,
+          scenarioIds,
+          objectiveByKey
+        )
+      };
+      const responseSchema = policyEditAuthorJsonSchema(
+        limit,
+        opts.targetSurface,
+        allowedJsonPaths,
+        objectives
+      );
+      assertPolicyEditAuthorContextBudget(
+        { system: POLICY_EDIT_AUTHOR_SYSTEM, authorContext, responseSchema },
+        maxAuthorContextChars
+      );
+      const userContent = JSON.stringify(authorContext);
+      const request = {
+        model: opts.model,
+        messages: [
+          { role: "system", content: POLICY_EDIT_AUTHOR_SYSTEM },
+          { role: "user", content: userContent }
+        ],
+        jsonSchema: {
+          name: "policy_edit_author",
+          schema: responseSchema
+        },
+        temperature: opts.temperature ?? 0.2,
+        maxTokens: opts.maxTokens ?? 6e3,
+        timeoutMs: opts.timeoutMs
+      };
+      const paid = await (ctx.costLedger ?? directCostLedger).runPaidCall({
+        channel: "driver",
+        phase: ctx.costPhase ?? "search.proposal",
+        actor: "llm-policy-edit.author",
+        model: opts.model,
+        maximumCharge: maximumChargeForLlmRequest(request, opts.llm),
+        tags: { generation: String(ctx.generation) },
+        signal: ctx.signal,
+        execute: (signal, callId) => callLlmJson(request, { ...opts.llm, signal, idempotencyKey: callId }),
+        receipt: ({ result }) => costReceiptFromLlm(result),
+        receiptFromError: costReceiptFromLlmError
+      });
+      if (!paid.succeeded) throw paid.error;
+      const { value } = paid.value;
+      const response = parseAuthorResponse(value);
+      if (response.edits.length > limit) {
+        throw new Error(
+          `llmPolicyEditProposer: author returned ${response.edits.length} edits for ${limit} candidate slots`
+        );
+      }
+      const edits = response.edits.map(
+        (draft) => bindAuthoredEdit(
+          draft,
+          findingByKey,
+          opts.targetSurface,
+          allowedPathSet,
+          objectiveByKey,
+          ctx.incumbentOutcome?.composite ?? ctx.baselineOutcome?.composite
+        )
+      );
+      return policyEditProposer({
+        edits,
+        admission: admissionMode === "strict" ? opts.admission : {
+          minScore: 0,
+          minExpectedGain: 0,
+          allowHighRisk: true,
+          requireEvidence: true
+        },
+        maxCandidates: limit,
+        onAdmission: opts.onAdmission
+      }).propose(ctx);
+    }
+  };
+}
+function projectPolicyEditHistory(history, options = {}) {
+  const limits = validateHistoryLimits(options);
+  const objectiveByKey = new Map(
+    (options.objectives ? validateObjectives(options.objectives) : []).map((objective) => [
+      objective.key,
+      objective
+    ])
+  );
+  const scenarioIds = createScenarioIdProjector(limits.scenarioIdTransform);
+  registerHistoryScenarioIds(history.slice(-limits.maxGenerations), scenarioIds);
+  return projectPolicyEditHistoryWithProjector(history, limits, scenarioIds, objectiveByKey);
+}
+function projectPolicyEditHistoryWithProjector(history, limits, scenarioIds, objectiveByKey) {
+  const retainedHistory = history.slice(-limits.maxGenerations);
+  const candidateByHash = new Map(
+    retainedHistory.flatMap(
+      (record) => record.candidates.map((candidate) => [candidate.surfaceHash, candidate])
+    )
+  );
+  return retainedHistory.map((record) => {
+    const candidates = selectHistoryCandidates(record, limits.maxCandidatesPerGeneration);
+    const hashes = new Set(candidates.map((candidate) => candidate.surfaceHash));
+    return {
+      generationIndex: record.generationIndex,
+      promoted: record.promoted.filter((hash) => hashes.has(hash)).map((hash) => scenarioIds.sanitize(hash)),
+      candidates: candidates.map(
+        (candidate) => projectHistoryCandidate(
+          candidate,
+          scenarioIds,
+          limits.maxScenariosPerCandidate,
+          candidate.parentSurfaceHash ? candidateByHash.get(candidate.parentSurfaceHash)?.scenarios : void 0,
+          objectiveByKey
+        )
+      )
+    };
+  });
+}
+function selectHistoryCandidates(record, limit) {
+  const promotionOrder = new Map(record.promoted.map((hash, index) => [hash, index]));
+  const promoted = [...record.candidates].filter((candidate) => promotionOrder.has(candidate.surfaceHash)).sort((a, b) => promotionOrder.get(a.surfaceHash) - promotionOrder.get(b.surfaceHash));
+  const selected = promoted.slice(0, limit);
+  const selectedHashes = new Set(selected.map((candidate) => candidate.surfaceHash));
+  const remaining = [...record.candidates].filter((candidate) => !promotionOrder.has(candidate.surfaceHash)).sort((a, b) => b.composite - a.composite || a.surfaceHash.localeCompare(b.surfaceHash));
+  let high = 0;
+  let low = remaining.length - 1;
+  let takeLow = selected.length > 0;
+  while (selected.length < limit && high <= low) {
+    const candidate = takeLow ? remaining[low--] : remaining[high++];
+    takeLow = !takeLow;
+    if (!candidate || selectedHashes.has(candidate.surfaceHash)) continue;
+    selected.push(candidate);
+    selectedHashes.add(candidate.surfaceHash);
+  }
+  return selected;
+}
+function projectHistoryCandidate(candidate, scenarioIds, maxScenarios, parentScenarios, objectiveByKey) {
+  const referenceByScenario = parentScenarios ? new Map(parentScenarios.map((scenario) => [scenario.scenarioId, scenario.composite])) : void 0;
+  const selectedScenarios = selectPolicyEditAuthorRows(candidate.scenarios, {
+    limit: maxScenarios,
+    ...referenceByScenario ? { referenceByScenario } : {}
+  });
+  const validatedRecord = candidate.candidateRecord ? validatePolicyEditCandidateRecord(candidate.candidateRecord) : void 0;
+  return {
+    surfaceHash: scenarioIds.sanitize(candidate.surfaceHash),
+    parentSurfaceHash: candidate.parentSurfaceHash ? scenarioIds.sanitize(candidate.parentSurfaceHash) : null,
+    parentComposite: candidate.parentComposite ?? null,
+    label: candidate.label ? scenarioIds.sanitize(candidate.label) : null,
+    rationale: candidate.rationale ? scenarioIds.sanitize(candidate.rationale) : null,
+    composite: candidate.composite,
+    observedDeltaFromParent: candidate.observedDeltaFromParent ?? null,
+    eligibleForPromotion: candidate.eligibleForPromotion ?? null,
+    coverage: candidate.coverage ? {
+      expectedCells: candidate.coverage.expectedCells,
+      scorableCells: candidate.coverage.scorableCells,
+      // `cellId` embeds the raw scenario ID. The aggregate reason is useful
+      // for search, but the identifier must not bypass scenarioIdTransform.
+      unscorableCells: [...candidate.coverage.unscorableCells].sort((a, b) => a.cellId.localeCompare(b.cellId)).slice(0, maxScenarios).map((cell) => ({ reason: scenarioIds.sanitize(cell.reason) }))
+    } : null,
+    // GenerationCandidate.ci95 is currently a placeholder [composite, composite],
+    // not a measured interval. Keep it out of author context until it is real.
+    dimensions: sanitizeDimensions(candidate.dimensions, scenarioIds),
+    scenarios: selectedScenarios.map((scenario) => {
+      return {
+        scenarioId: scenarioIds.project(scenario.scenarioId),
+        composite: scenario.composite,
+        notes: scenario.notes ? scenarioIds.sanitize(scenario.notes) : null
+      };
+    }),
+    candidateEdit: validatedRecord ? summarizeCandidateEdit(validatedRecord, scenarioIds) : null,
+    forecastCalibration: forecastCalibration(candidate, validatedRecord, objectiveByKey)
+  };
+}
+function projectOutcome(outcome, scenarioIds, maxScenarios, 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,
+    ...referenceByScenario ? { referenceByScenario } : {}
+  });
+  return {
+    split: "search",
+    generation: outcome.generation,
+    surfaceHash: scenarioIds.sanitize(outcome.surfaceHash),
+    composite: outcome.composite,
+    dimensions: sanitizeDimensions(outcome.dimensions, scenarioIds),
+    scenarios: selectedScenarios.map((scenario) => {
+      return {
+        scenarioId: scenarioIds.project(scenario.scenarioId),
+        composite: scenario.composite,
+        notes: scenario.notes ? scenarioIds.sanitize(scenario.notes) : null
+      };
+    }),
+    coverage: { ...outcome.coverage }
+  };
+}
+function createScenarioIdProjector(transform) {
+  const aliases = /* @__PURE__ */ new Map();
+  const originals = /* @__PURE__ */ new Map();
+  return {
+    project(scenarioId) {
+      const known = aliases.get(scenarioId);
+      if (known) return known;
+      const alias = transform(scenarioId);
+      if (!alias || alias.trim() !== alias) {
+        throw new Error(
+          "llmPolicyEditProposer: scenarioIdTransform must return a trimmed non-empty string"
+        );
+      }
+      const collision = originals.get(alias);
+      if (collision && collision !== scenarioId) {
+        throw new Error(
+          `llmPolicyEditProposer: scenarioIdTransform collision for '${collision}' and '${scenarioId}'`
+        );
+      }
+      const aliasIsAnotherOriginal = aliases.has(alias) && alias !== scenarioId;
+      const originalIsAnotherAlias = originals.has(scenarioId) && originals.get(scenarioId) !== scenarioId;
+      if (aliasIsAnotherOriginal || originalIsAnotherAlias) {
+        throw new Error(
+          "llmPolicyEditProposer: scenarioIdTransform aliases overlap raw scenario IDs"
+        );
+      }
+      aliases.set(scenarioId, alias);
+      originals.set(alias, scenarioId);
+      return alias;
+    },
+    sanitize(text) {
+      const originalsByLength = [...aliases.keys()].sort((a, b) => b.length - a.length);
+      if (originalsByLength.length === 0) return text;
+      const pattern = new RegExp(
+        `(^|[^A-Za-z0-9_-])(${originalsByLength.map(escapeRegExp).join("|")})(?=$|[^A-Za-z0-9_-])`,
+        "g"
+      );
+      return text.replace(
+        pattern,
+        (_match, prefix, original) => `${prefix}${aliases.get(original) ?? original}`
+      );
+    }
+  };
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function sourceKey(surfaceHash2, generation) {
+  return `${surfaceHash2}@${generation}`;
+}
+function measuredSourceMeasurements(ctx) {
+  const measurements = /* @__PURE__ */ new Map();
+  const add = (measurement) => {
+    measurements.set(sourceKey(measurement.surfaceHash, measurement.generation), measurement);
+  };
+  if (ctx.baselineOutcome) {
+    add({
+      surfaceHash: ctx.baselineOutcome.surfaceHash,
+      generation: ctx.baselineOutcome.generation,
+      composite: ctx.baselineOutcome.composite,
+      parentComposite: null,
+      observedDeltaFromParent: null,
+      eligibleForPromotion: true,
+      coverage: { ...ctx.baselineOutcome.coverage }
+    });
+  }
+  for (const record of ctx.history) {
+    for (const candidate of record.candidates) {
+      add({
+        surfaceHash: candidate.surfaceHash,
+        generation: record.generationIndex,
+        composite: candidate.composite,
+        parentComposite: candidate.parentComposite ?? null,
+        observedDeltaFromParent: candidate.observedDeltaFromParent ?? null,
+        eligibleForPromotion: candidate.eligibleForPromotion === true,
+        coverage: candidate.coverage ? {
+          expectedCells: candidate.coverage.expectedCells,
+          scorableCells: candidate.coverage.scorableCells
+        } : { expectedCells: 0, scorableCells: 0 }
+      });
+    }
+  }
+  if (ctx.incumbentOutcome) {
+    const generation = ctx.incumbentOutcome.generation;
+    const key = sourceKey(ctx.incumbentOutcome.surfaceHash, generation);
+    if (!measurements.has(key)) {
+      add({
+        surfaceHash: ctx.incumbentOutcome.surfaceHash,
+        generation,
+        composite: ctx.incumbentOutcome.composite,
+        parentComposite: null,
+        observedDeltaFromParent: null,
+        eligibleForPromotion: true,
+        coverage: { ...ctx.incumbentOutcome.coverage }
+      });
+    }
+  }
+  return measurements;
+}
+function validateFindingSource(source, measured) {
+  if (source.kind === "global") {
+    requireNonEmpty(source.label, "global finding source label");
+    return;
+  }
+  if (!measured.has(sourceKey(source.surfaceHash, source.generation))) {
+    throw new Error(
+      `llmPolicyEditProposer: finding source ${source.surfaceHash}@${source.generation} is not a measured surface`
+    );
+  }
+}
+function sameFindingSource(a, b) {
+  if (a.kind !== b.kind) return false;
+  return a.kind === "surface" && b.kind === "surface" ? a.surfaceHash === b.surfaceHash && a.generation === b.generation : a.kind === "global" && b.kind === "global" && a.label === b.label;
+}
+function summarizeCandidateEdit(record, scenarioIds) {
+  const edit = record.policyEdit;
+  return {
+    editId: edit.editId,
+    axis: edit.axis,
+    target: sanitizeAuthorValue(edit.target, scenarioIds),
+    change: sanitizeAuthorValue(edit.change, scenarioIds),
+    claim: scenarioIds.sanitize(edit.claim),
+    expectedGain: sanitizeAuthorValue(edit.expectedGain, scenarioIds),
+    confidence: edit.confidence,
+    risk: edit.risk,
+    sourceFindingIds: edit.source.findingIds.map((id) => scenarioIds.sanitize(id)),
+    rationale: edit.rationale ? scenarioIds.sanitize(edit.rationale) : null,
+    validationPlan: edit.validationPlan ? scenarioIds.sanitize(edit.validationPlan) : null
+  };
+}
+function sanitizeAuthorValue(value, scenarioIds) {
+  if (typeof value === "string") return scenarioIds.sanitize(value);
+  if (Array.isArray(value)) return value.map((item) => sanitizeAuthorValue(item, scenarioIds));
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, child]) => [
+        scenarioIds.sanitize(key),
+        sanitizeAuthorValue(child, scenarioIds)
+      ])
+    );
+  }
+  return value;
+}
+function sanitizeDimensions(dimensions, scenarioIds) {
+  const sanitized = /* @__PURE__ */ new Map();
+  for (const [key, value] of Object.entries(dimensions)) {
+    const projected = scenarioIds.sanitize(key);
+    const prior = sanitized.get(projected);
+    if (prior && prior.original !== key) {
+      throw new Error(
+        `llmPolicyEditProposer: pseudonymized dimension key collision for '${prior.original}' and '${key}'`
+      );
+    }
+    sanitized.set(projected, { original: key, value });
+  }
+  return Object.fromEntries([...sanitized].map(([key, entry]) => [key, entry.value]));
+}
+function forecastCalibration(candidate, record, objectiveByKey) {
+  if (!record || candidate.observedDeltaFromParent === void 0) return null;
+  const forecast = record.policyEdit.expectedGain;
+  const objective = objectiveByKey.get(forecast.metric);
+  if (!objective || objective.key !== "search.composite") return null;
+  if (forecast.direction !== objective.direction || forecast.unit !== objective.unit) return null;
+  if (forecast.amount > objective.scale.max - objective.scale.min) return null;
+  const predictedDelta = forecast.amount;
+  return {
+    objectiveKey: objective.key,
+    predictedDelta,
+    observedDelta: candidate.observedDeltaFromParent,
+    residual: candidate.observedDeltaFromParent - predictedDelta
+  };
+}
+function assertSearchOutcome(outcome, field) {
+  if (outcome && outcome.split !== "search") {
+    throw new Error(`llmPolicyEditProposer: ${field} must be a search-split outcome`);
+  }
+}
+function assertMeasuredCompositesInScale(ctx, objective) {
+  const assertInScale = (value, field) => {
+    if (!Number.isFinite(value) || value < objective.scale.min || value > objective.scale.max) {
+      throw new Error(
+        `llmPolicyEditProposer: ${field} ${value} is outside objective '${objective.key}' scale [${objective.scale.min}, ${objective.scale.max}]`
+      );
+    }
+  };
+  const assertOutcome = (outcome, field) => {
+    if (!outcome) return;
+    assertInScale(outcome.composite, `${field}.composite`);
+    for (const [index, scenario] of outcome.scenarios.entries()) {
+      assertInScale(scenario.composite, `${field}.scenarios[${index}].composite`);
+    }
+  };
+  assertOutcome(ctx.baselineOutcome, "baselineOutcome");
+  assertOutcome(ctx.incumbentOutcome, "incumbentOutcome");
+  for (const [generationIndex, generation] of ctx.history.entries()) {
+    for (const [candidateIndex, candidate] of generation.candidates.entries()) {
+      const field = `history[${generationIndex}].candidates[${candidateIndex}]`;
+      assertInScale(candidate.composite, `${field}.composite`);
+      if (candidate.parentComposite !== void 0) {
+        assertInScale(candidate.parentComposite, `${field}.parentComposite`);
+      }
+      for (const [scenarioIndex, scenario] of candidate.scenarios.entries()) {
+        assertInScale(scenario.composite, `${field}.scenarios[${scenarioIndex}].composite`);
+      }
+    }
+  }
+}
+function assertSurfaceIsTaskAgnostic(value, scenarioIds) {
+  const serialized = JSON.stringify(value);
+  if (scenarioIds.sanitize(serialized) !== serialized) {
+    throw new Error(
+      "llmPolicyEditProposer: current JSON surface or signature contains a raw scenario identifier"
+    );
+  }
+}
+function registerOutcomeScenarioIds(outcome, scenarioIds) {
+  for (const scenario of outcome?.scenarios ?? []) scenarioIds.project(scenario.scenarioId);
+}
+function registerHistoryScenarioIds(history, scenarioIds) {
+  for (const record of history) {
+    for (const candidate of record.candidates) {
+      for (const scenario of candidate.scenarios) scenarioIds.project(scenario.scenarioId);
+      for (const cell of candidate.coverage?.unscorableCells ?? []) {
+        const separator = cell.cellId.lastIndexOf(":");
+        if (separator <= 0 || !/^\d+$/.test(cell.cellId.slice(separator + 1))) continue;
+        scenarioIds.project(cell.cellId.slice(0, separator));
+      }
+    }
+  }
+}
+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;
+  if (!Number.isSafeInteger(maxGenerations) || maxGenerations <= 0) {
+    throw new Error("llmPolicyEditProposer: maxHistoryGenerations must be a positive safe integer");
+  }
+  if (!Number.isSafeInteger(maxCandidatesPerGeneration) || maxCandidatesPerGeneration <= 0) {
+    throw new Error(
+      "llmPolicyEditProposer: maxHistoryCandidatesPerGeneration must be a positive safe integer"
+    );
+  }
+  if (!Number.isSafeInteger(maxScenariosPerCandidate) || maxScenariosPerCandidate <= 0) {
+    throw new Error(
+      "llmPolicyEditProposer: maxScenariosPerCandidate must be a positive safe integer"
+    );
+  }
+  return {
+    maxGenerations,
+    maxCandidatesPerGeneration,
+    maxScenariosPerCandidate,
+    scenarioIdTransform: options.scenarioIdTransform ?? ((scenarioId) => scenarioId)
+  };
+}
+function validateObjectives(inputs) {
+  if (inputs.length === 0) {
+    throw new Error("llmPolicyEditProposer: objectives must not be empty");
+  }
+  const seen = /* @__PURE__ */ new Set();
+  return inputs.map((input) => {
+    requireNonEmpty(input.key, "objective key");
+    if (seen.has(input.key)) {
+      throw new Error(`llmPolicyEditProposer: duplicate objective '${input.key}'`);
+    }
+    seen.add(input.key);
+    if (input.split !== "search") {
+      throw new Error(`llmPolicyEditProposer: objective '${input.key}' must use the search split`);
+    }
+    if (input.key !== "search.composite") {
+      throw new Error(
+        `llmPolicyEditProposer: objective '${input.key}' is not yet measurable; use 'search.composite'`
+      );
+    }
+    if (input.direction !== "increase") {
+      throw new Error(
+        `llmPolicyEditProposer: objective '${input.key}' must increase because search promotes larger composite scores`
+      );
+    }
+    if (!Number.isFinite(input.scale.min) || !Number.isFinite(input.scale.max) || input.scale.max <= input.scale.min) {
+      throw new Error(`llmPolicyEditProposer: objective '${input.key}' has an invalid scale`);
+    }
+    if (input.unit !== "score") {
+      throw new Error(`llmPolicyEditProposer: objective '${input.key}' must use raw score deltas`);
+    }
+    return {
+      key: input.key,
+      split: "search",
+      direction: input.direction,
+      scale: { ...input.scale },
+      unit: input.unit
+    };
+  });
+}
+function positiveLimit(value, field) {
+  if (!Number.isSafeInteger(value) || value <= 0) {
+    throw new Error(`llmPolicyEditProposer: ${field} must be a positive safe integer`);
+  }
+  return value;
+}
+function parseAuthorResponse(value) {
+  const parsed = PolicyEditAuthorResponseSchema.safeParse(value);
+  if (parsed.success) return parsed.data;
+  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) {
+    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`
+    );
+  }
+  const cited = draft.source.findingKeys.map((findingKey) => {
+    const finding = findingByKey.get(findingKey);
+    if (!finding) {
+      throw new Error(
+        `llmPolicyEditProposer: edit cites unknown or uncitable finding key '${findingKey}'`
+      );
+    }
+    return finding;
+  });
+  const evidenceRefs = uniqueEvidenceRefs(cited.flatMap((finding) => finding.evidenceRefs));
+  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(
+      `llmPolicyEditProposer: forecast amount for '${objective.key}' exceeds the available score headroom`
+    );
+  }
+  const expectedGain = {
+    metric: draft.expectedGain.metric,
+    direction: draft.expectedGain.direction,
+    amount: draft.expectedGain.amount,
+    ...draft.expectedGain.unit ? { unit: draft.expectedGain.unit } : {},
+    ...draft.expectedGain.rationale ? { rationale: draft.expectedGain.rationale } : {}
+  };
+  const init = {
+    axis: draft.axis,
+    target: {
+      surface: draft.target.surface,
+      path: draft.target.path,
+      ...draft.target.label ? { label: draft.target.label } : {}
+    },
+    change: draft.change,
+    claim: draft.claim,
+    expectedGain,
+    confidence: draft.confidence,
+    risk: draft.risk,
+    source: {
+      findingIds: [...new Set(cited.map((finding) => finding.finding.finding_id))],
+      analystIds: [...new Set(cited.map((finding) => finding.finding.analyst_id))],
+      evidenceRefs
+    },
+    ...draft.rationale ? { rationale: draft.rationale } : {},
+    ...draft.validationPlan ? { validationPlan: draft.validationPlan } : {}
+  };
+  return makePolicyEdit(init);
+}
+function parseJsonSurface(surface) {
+  if (typeof surface !== "string") {
+    throw new Error("llmPolicyEditProposer: currentSurface must be serialized JSON");
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(surface);
+  } catch {
+    throw new Error("llmPolicyEditProposer: currentSurface must be valid JSON");
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error("llmPolicyEditProposer: currentSurface JSON root must be an object");
+  }
+  return parsed;
+}
+function citableFindings(inputs, measuredSources, limit) {
+  if (inputs.length === 0) {
+    throw new Error("llmPolicyEditProposer: at least one analyst finding is required");
+  }
+  const findings = [];
+  for (const input of inputs) {
+    if (!isPolicyEditFindingInput(input)) {
+      throw new Error(
+        "llmPolicyEditProposer: ctx.findings must contain attributed PolicyEditFindingInput rows"
+      );
+    }
+    findings.push(input.finding);
+  }
+  assertNoJudgeVerdict(findings, "llmPolicyEditProposer");
+  const grouped = /* @__PURE__ */ new Map();
+  for (const input of inputs) {
+    validateFindingSource(input.source, measuredSources);
+    if (input.finding.evidence_refs.length === 0) continue;
+    const existing = grouped.get(input.finding.finding_id);
+    if (existing) {
+      if (existing.finding.analyst_id !== input.finding.analyst_id || existing.finding.area !== input.finding.area || existing.finding.claim !== input.finding.claim || existing.finding.subject !== input.finding.subject) {
+        throw new Error(
+          `llmPolicyEditProposer: finding '${input.finding.finding_id}' has conflicting content`
+        );
+      }
+      if (!existing.sources.some((source) => sameFindingSource(source, input.source))) {
+        existing.sources.push(input.source);
+      }
+      existing.evidenceRefs = uniqueEvidenceRefs([
+        ...existing.evidenceRefs,
+        ...input.finding.evidence_refs
+      ]);
+      continue;
+    }
+    grouped.set(input.finding.finding_id, {
+      finding: input.finding,
+      sources: [input.source],
+      evidenceRefs: uniqueEvidenceRefs(input.finding.evidence_refs)
+    });
+  }
+  if (grouped.size === 0) {
+    throw new Error("llmPolicyEditProposer: no evidence-bearing findings are available");
+  }
+  const severityRank = {
+    critical: 0,
+    high: 1,
+    medium: 2,
+    low: 3,
+    info: 4
+  };
+  return [...grouped.values()].sort(
+    (a, b) => severityRank[a.finding.severity] - severityRank[b.finding.severity] || b.finding.confidence - a.finding.confidence || a.finding.finding_id.localeCompare(b.finding.finding_id)
+  ).slice(0, limit);
+}
+function isAnalystFindingLike2(input) {
+  if (!input || typeof input !== "object") return false;
+  const value = input;
+  return typeof value.finding_id === "string" && typeof value.analyst_id === "string" && typeof value.claim === "string" && Array.isArray(value.evidence_refs);
+}
+function isPolicyEditFindingInput(input) {
+  if (!input || typeof input !== "object") return false;
+  const value = input;
+  return isAnalystFindingLike2(value.finding) && isFindingSource(value.source);
+}
+function isFindingSource(input) {
+  if (!input || typeof input !== "object") return false;
+  const value = input;
+  if (value.kind === "surface") {
+    return typeof value.surfaceHash === "string" && Number.isSafeInteger(value.generation);
+  }
+  return value.kind === "global" && typeof value.label === "string" && value.label.trim().length > 0;
+}
+function renderFinding(context, findingKey, scenarioIds, measuredSources) {
+  const { finding } = context;
+  return {
+    findingKey,
+    sources: context.sources.map(
+      (source) => source.kind === "surface" ? {
+        ...measuredSources.get(sourceKey(source.surfaceHash, source.generation)),
+        surfaceHash: scenarioIds.sanitize(source.surfaceHash),
+        kind: "surface"
+      } : { kind: "global", label: scenarioIds.sanitize(source.label) }
+    ),
+    analystId: scenarioIds.sanitize(finding.analyst_id),
+    area: scenarioIds.sanitize(finding.area),
+    severity: finding.severity,
+    subject: finding.subject ? scenarioIds.sanitize(finding.subject) : null,
+    claim: scenarioIds.sanitize(finding.claim),
+    rationale: finding.rationale ? scenarioIds.sanitize(finding.rationale) : null,
+    recommendedAction: finding.recommended_action ? scenarioIds.sanitize(finding.recommended_action) : null,
+    validationPlan: finding.validation_plan ? scenarioIds.sanitize(finding.validation_plan) : null,
+    confidence: finding.confidence,
+    evidenceRefs: context.evidenceRefs.map((ref) => ({
+      kind: ref.kind,
+      uri: scenarioIds.sanitize(ref.uri),
+      excerpt: ref.excerpt ? scenarioIds.sanitize(ref.excerpt) : null
+    }))
+  };
+}
+function uniqueEvidenceRefs(refs) {
+  const seen = /* @__PURE__ */ new Set();
+  return refs.filter((ref) => {
+    const key = JSON.stringify([ref.kind, ref.uri, ref.excerpt ?? null]);
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+function validateAllowedJsonPaths(paths) {
+  if (paths.length === 0) {
+    throw new Error("llmPolicyEditProposer: allowedJsonPaths must not be empty");
+  }
+  for (const path of paths) {
+    if (!path || path.trim() !== path) {
+      throw new Error(
+        "llmPolicyEditProposer: allowedJsonPaths must contain trimmed non-empty paths"
+      );
+    }
+  }
+  if (new Set(paths).size !== paths.length) {
+    throw new Error("llmPolicyEditProposer: allowedJsonPaths must be unique");
+  }
+  return [...paths];
+}
+function requireNonEmpty(value, field) {
+  if (!value || value.trim() !== value) {
+    throw new Error(`llmPolicyEditProposer: ${field} must be a trimmed non-empty string`);
+  }
+}
+
+// src/campaign/proposers/memory.ts
+var BLOCK_START2 = "<!-- BEGIN curated-memory (auto-managed by memoryCurationProposer) -->";
+var BLOCK_END2 = "<!-- END curated-memory -->";
+var DEFAULT_HEADING2 = "## Learned from prior runs (curated memory)";
+var DISTILL_SYSTEM = 'You compress raw trace-analysis findings into crisp, generalizable agent guidance. Output ONLY a JSON array of strings, each one imperative lesson the agent should follow (e.g. "Always fetch a resource before mutating it"). No prose outside the JSON. Deduplicate; keep the most actionable and general; drop case-specific noise.';
+function extractExistingLessons(text) {
+  return extractBlockBody(text, BLOCK_START2, BLOCK_END2).split("\n").map((l) => l.replace(/^\s*-\s+/, "").trim()).filter((l) => l && !l.startsWith("#"));
+}
+async function distillLessons(raw, distill, ctx, costLedger) {
+  const request = {
+    model: distill.model,
+    messages: [
+      { role: "system", content: DISTILL_SYSTEM },
+      { role: "user", content: `Findings:
+${raw.map((r) => `- ${r}`).join("\n")}` }
+    ],
+    maxTokens: distill.maxTokens ?? 2e3
+  };
+  const llm = {
+    baseUrl: distill.baseUrl,
+    apiKey: distill.apiKey,
+    fetch: distill.fetchImpl
+  };
+  const paid = await costLedger.runPaidCall({
+    channel: "driver",
+    phase: ctx.costPhase ?? "search.proposal",
+    actor: "memory-curation.distill",
+    model: distill.model,
+    maximumCharge: maximumChargeForLlmRequest(request, llm),
+    tags: { generation: String(ctx.generation) },
+    signal: ctx.signal,
+    execute: (signal, callId) => callLlm(request, { ...llm, signal, idempotencyKey: callId }),
+    receipt: costReceiptFromLlm,
+    receiptFromError: costReceiptFromLlmError
+  });
+  if (!paid.succeeded) throw paid.error;
+  const res = paid.value;
+  try {
+    const parsed = JSON.parse(res.content.trim());
+    if (Array.isArray(parsed)) {
+      const lessons = parsed.filter(
+        (x) => typeof x === "string" && x.trim().length > 0
+      );
+      if (lessons.length > 0) return lessons;
+    }
+  } catch {
+  }
+  return raw;
+}
+function memoryCurationProposer(opts = {}) {
+  const maxEntries = opts.maxEntries ?? 12;
+  const heading = opts.sectionHeading ?? DEFAULT_HEADING2;
+  const directCostLedger = opts.costLedger ?? new CostLedger();
+  return {
+    kind: "memory-curation",
+    async propose(ctx) {
+      const parent = surfaceToText2(ctx.currentSurface);
+      const fresh = [];
+      for (const f of ctx.findings ?? []) {
+        const l = findingToLesson(f);
+        if (l) fresh.push(l);
+      }
+      const carried = extractExistingLessons(parent);
+      if (fresh.length === 0 && carried.length === 0) return [];
+      const distilled = opts.distill && fresh.length > 0 ? await distillLessons(fresh, opts.distill, ctx, ctx.costLedger ?? directCostLedger) : fresh;
+      const byKey = /* @__PURE__ */ new Map();
+      for (const l of carried) {
+        const k = normKey(l);
+        if (k) byKey.set(k, { text: l, count: 1 });
+      }
+      for (const l of distilled) {
+        const k = normKey(l);
+        if (!k) continue;
+        const e = byKey.get(k);
+        if (e) e.count += 1;
+        else byKey.set(k, { text: l, count: 1 });
+      }
+      const ranked = [...byKey.values()].sort((a, b) => b.count - a.count || a.text.localeCompare(b.text)).slice(0, maxEntries);
+      if (ranked.length === 0) return [];
+      const block = [BLOCK_START2, heading, ...ranked.map((e) => `- ${e.text}`), BLOCK_END2].join(
+        "\n"
+      );
+      const next = `${stripBlock(parent, BLOCK_START2, BLOCK_END2)}
+
+${block}
+`;
+      if (next === parent) return [];
+      return [
+        {
+          surface: next,
+          label: "memory-curation",
+          rationale: `curated ${ranked.length} lessons (from ${fresh.length} new finding(s) + ${carried.length} carried)`
+        }
+      ];
+    }
+  };
+}
+
+// src/campaign/proposers/trace-analyst.ts
+import { ai } from "@ax-llm/ax";
+function renderFindings(findings) {
+  return findings.map((f, i) => {
+    const action = f.recommended_action ? `
+   FIX: ${f.recommended_action}` : "";
+    const subject = f.subject ? ` (${f.subject})` : "";
+    return `${i + 1}. [${f.severity}/${f.area}]${subject} ${f.claim}${action}`;
+  }).join("\n");
+}
+function traceAnalystProposer(opts) {
+  if (!opts.apiKey) throw new Error("traceAnalystProposer: apiKey is required");
   if (!opts.model) throw new Error("traceAnalystProposer: model is required");
   const kinds = opts.kinds ?? DEFAULT_TRACE_ANALYST_KINDS;
   const produceFindings = opts.analyze ?? (async (path, c) => {
@@ -5444,7 +6325,12 @@ function traceAnalystProposer(opts) {
     label: "trace-analyst",
     baseUrl: opts.baseUrl,
     apiKey: opts.apiKey,
+    analysisModel: opts.model,
     applyModel: opts.applyModel ?? opts.model,
+    costLedger: opts.costLedger,
+    analysisMaximumCharge: opts.analysisMaximumCharge,
+    analysisReceipt: opts.analysisReceipt,
+    applyMaxTokens: opts.applyMaxTokens,
     fetchImpl: opts.fetchImpl,
     resolveTraces: opts.resolveTraces,
     noTracesError: "traceAnalystProposer: resolveTraces returned no OTLP traces \u2014 the analyst has nothing to read",
@@ -5516,161 +6402,9 @@ function selectDiscriminative(signals, k, opts) {
 
 // src/campaign/search-ledger.ts
 import { createHash as createHash7 } from "crypto";
-import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
 import { resolve as resolve2 } from "path";
 import { z as z2 } from "zod";
-
-// src/campaign/search-ledger-errors.ts
-var SearchLedgerError = class extends ValidationError {
-};
-var SearchLedgerIntegrityError = class extends SearchLedgerError {
-};
-var SearchLedgerConflictError = class extends SearchLedgerError {
-};
-
-// src/campaign/search-ledger-file.ts
-import { randomUUID as randomUUID2 } from "crypto";
-import {
-  closeSync,
-  constants,
-  existsSync as existsSync3,
-  fsyncSync,
-  linkSync,
-  mkdirSync as mkdirSync2,
-  openSync,
-  readFileSync as readFileSync3,
-  renameSync,
-  unlinkSync,
-  writeSync
-} from "fs";
-import { hostname } from "os";
-import { dirname as dirname2 } from "path";
-import { z } from "zod";
-function appendSearchLedgerLine(path, line) {
-  mkdirSync2(dirname2(path), { recursive: true });
-  const fd = openSync(path, constants.O_CREAT | constants.O_WRONLY | constants.O_APPEND, 384);
-  try {
-    writeAll(fd, Buffer.from(line, "utf8"));
-    fsyncSync(fd);
-  } finally {
-    closeSync(fd);
-  }
-  fsyncDirectory(dirname2(path));
-}
-function withSearchLedgerFileLock(ledgerPath, run) {
-  mkdirSync2(dirname2(ledgerPath), { recursive: true });
-  const lockPath = `${ledgerPath}.lock`;
-  const owner = acquireLock(lockPath);
-  try {
-    return run();
-  } finally {
-    releaseLock(lockPath, owner);
-  }
-}
-function writeAll(fd, bytes) {
-  let offset = 0;
-  while (offset < bytes.byteLength) {
-    const written = writeSync(fd, bytes, offset, bytes.byteLength - offset);
-    if (written <= 0) throw new SearchLedgerIntegrityError("filesystem wrote zero bytes");
-    offset += written;
-  }
-}
-function fsyncDirectory(path) {
-  const fd = openSync(path, constants.O_RDONLY);
-  try {
-    fsyncSync(fd);
-  } finally {
-    closeSync(fd);
-  }
-}
-function acquireLock(lockPath) {
-  const owner = { pid: process.pid, host: hostname(), nonce: randomUUID2() };
-  const ownerBytes = `${canonicalOwner(owner)}
-`;
-  for (let attempt = 0; attempt < 8; attempt += 1) {
-    const ownerPath = `${lockPath}.${owner.pid}.${owner.nonce}.${attempt}.owner`;
-    const fd = openSync(ownerPath, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY, 384);
-    try {
-      writeAll(fd, Buffer.from(ownerBytes, "utf8"));
-      fsyncSync(fd);
-    } finally {
-      closeSync(fd);
-    }
-    try {
-      linkSync(ownerPath, lockPath);
-      unlinkSync(ownerPath);
-      return owner;
-    } catch (error) {
-      unlinkIfExists(ownerPath);
-      if (error.code !== "EEXIST") throw error;
-    }
-    const holder = readOwner(lockPath);
-    if (holder.host !== owner.host || isProcessAlive(holder.pid)) {
-      throw new SearchLedgerIntegrityError(
-        `search ledger lock is held by pid ${holder.pid} on ${holder.host}`
-      );
-    }
-    const tombstone = `${lockPath}.stale.${owner.nonce}.${attempt}`;
-    try {
-      renameSync(lockPath, tombstone);
-      unlinkSync(tombstone);
-    } catch (error) {
-      if (error.code !== "ENOENT") throw error;
-    }
-  }
-  throw new SearchLedgerIntegrityError(`could not acquire search ledger lock ${lockPath}`);
-}
-function releaseLock(lockPath, owner) {
-  if (!existsSync3(lockPath)) return;
-  const holder = readOwner(lockPath);
-  if (canonicalOwner(holder) !== canonicalOwner(owner)) {
-    throw new SearchLedgerIntegrityError(
-      `search ledger lock owner changed before release (${lockPath})`
-    );
-  }
-  unlinkSync(lockPath);
-}
-function readOwner(lockPath) {
-  let raw;
-  try {
-    raw = JSON.parse(readFileSync3(lockPath, "utf8"));
-  } catch (error) {
-    throw new SearchLedgerIntegrityError(`search ledger lock ${lockPath} is malformed`, {
-      cause: error
-    });
-  }
-  const parsed = z.object({
-    pid: z.number().int().positive().safe(),
-    host: z.string().trim().min(1),
-    nonce: z.string().trim().min(1)
-  }).strict().safeParse(raw);
-  if (!parsed.success) {
-    throw new SearchLedgerIntegrityError(
-      `search ledger lock ${lockPath} is malformed: ${parsed.error.issues.map((issue) => `${issue.path.join(".") || "<root>"}: ${issue.message}`).join("; ")}`
-    );
-  }
-  return parsed.data;
-}
-function canonicalOwner(owner) {
-  return JSON.stringify({ host: owner.host, nonce: owner.nonce, pid: owner.pid });
-}
-function isProcessAlive(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (error) {
-    return error.code !== "ESRCH";
-  }
-}
-function unlinkIfExists(path) {
-  try {
-    unlinkSync(path);
-  } catch (error) {
-    if (error.code !== "ENOENT") throw error;
-  }
-}
-
-// src/campaign/search-ledger.ts
 var SEARCH_LEDGER_SCHEMA = "tangle.search-ledger.v1";
 var NON_EMPTY = z2.string().min(1).refine((value) => value.trim() === value, "must not contain surrounding whitespace");
 var HASH = z2.string().regex(/^sha256:[a-f0-9]{64}$/);
@@ -6036,8 +6770,8 @@ var FileSearchLedger = class {
   }
 };
 function replayFile(path, campaignId) {
-  if (!existsSync4(path)) return replayEntries([], campaignId);
-  const text = readFileSync4(path, "utf8");
+  if (!existsSync3(path)) return replayEntries([], campaignId);
+  const text = readFileSync3(path, "utf8");
   if (text.length === 0) return replayEntries([], campaignId);
   if (!text.endsWith("\n")) {
     throw new SearchLedgerIntegrityError(
@@ -6633,10 +7367,10 @@ function formatZodError(error) {
 }
 
 // src/campaign/single-run-lock.ts
-import { existsSync as existsSync5, readFileSync as readFileSync5, unlinkSync as unlinkSync2, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync4, readFileSync as readFileSync4, unlinkSync, writeFileSync as writeFileSync3 } from "fs";
 function liveHolder(path) {
-  if (!existsSync5(path)) return null;
-  const holder = Number(readFileSync5(path, "utf8").trim());
+  if (!existsSync4(path)) return null;
+  const holder = Number(readFileSync4(path, "utf8").trim());
   if (!Number.isFinite(holder) || holder <= 0) return null;
   try {
     process.kill(holder, 0);
@@ -6658,8 +7392,8 @@ function acquireSingleRunLock(opts) {
   writeFileSync3(opts.lockPath, String(pid));
   const release = () => {
     try {
-      if (existsSync5(opts.lockPath) && readFileSync5(opts.lockPath, "utf8").trim() === String(pid)) {
-        unlinkSync2(opts.lockPath);
+      if (existsSync4(opts.lockPath) && readFileSync4(opts.lockPath, "utf8").trim() === String(pid)) {
+        unlinkSync(opts.lockPath);
       }
     } catch {
     }
@@ -6683,21 +7417,21 @@ function isTransientTransportFailure(message, opts = {}) {
 import { execFileSync } from "child_process";
 import { createHash as createHash8 } from "crypto";
 import {
-  closeSync as closeSync2,
-  existsSync as existsSync6,
+  closeSync,
+  existsSync as existsSync5,
   constants as fsConstants,
   fstatSync,
   lstatSync,
-  mkdirSync as mkdirSync3,
+  mkdirSync as mkdirSync2,
   mkdtempSync as mkdtempSync2,
-  openSync as openSync2,
+  openSync,
   readlinkSync,
   readSync,
   realpathSync,
   rmSync
 } from "fs";
 import { devNull, tmpdir as tmpdir2 } from "os";
-import { basename, dirname as dirname3, isAbsolute as isAbsolute2, join as join5, relative as relative2, resolve as resolve3, sep } from "path";
+import { basename, dirname as dirname2, isAbsolute as isAbsolute2, join as join5, 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([
@@ -6790,7 +7524,7 @@ 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");
-  mkdirSync3(emptyTemplate);
+  mkdirSync2(emptyTemplate);
   try {
     const objectFormat = gitObjectHashAlgorithm(candidateCommit);
     const sourceObjects = realpathSync(gitText(git, ["rev-parse", "--git-path", "objects"], cwd));
@@ -6928,7 +7662,7 @@ function hashGitBlobFile(path, objectId) {
     throw new WorktreeAdapterError(`CodeSurface expected a regular file at ${displayGitPath(path)}`);
   }
   const noFollow = process.platform === "win32" ? 0 : fsConstants.O_NOFOLLOW;
-  const fd = openSync2(path, fsConstants.O_RDONLY | noFollow);
+  const fd = openSync(path, fsConstants.O_RDONLY | noFollow);
   try {
     const opened = fstatSync(fd);
     if (!opened.isFile() || opened.dev !== before.dev || opened.ino !== before.ino || opened.size !== before.size) {
@@ -6953,7 +7687,7 @@ function hashGitBlobFile(path, objectId) {
     }
     return { hash: hash.digest("hex"), executable: (opened.mode & 73) !== 0 };
   } finally {
-    closeSync2(fd);
+    closeSync(fd);
   }
 }
 function assertSymlinkTargetIsBound(root, linkPath, trackedPaths) {
@@ -6969,7 +7703,7 @@ function assertSymlinkTargetIsBound(root, linkPath, trackedPaths) {
       `CodeSurface symbolic link escapes its worktree at ${displayGitPath(linkPath)}`
     );
   }
-  const lexicalTarget = resolve3(dirname3(linkPath), target);
+  const lexicalTarget = resolve3(dirname2(linkPath), target);
   if (!isWithinRoot(root, lexicalTarget)) {
     throw new WorktreeAdapterError(
       `CodeSurface symbolic link escapes its worktree at ${displayGitPath(linkPath)}`
@@ -7046,7 +7780,7 @@ function assertRawTreeMatchesWorktree(git, root, candidateCommit) {
 }
 function verifyCodeSurfaceWithGit(surface, path, git) {
   assertCodeSurfaceIdentity(surface);
-  if (!existsSync6(path)) {
+  if (!existsSync5(path)) {
     throw new WorktreeAdapterError(`CodeSurface worktree does not exist: ${path}`);
   }
   const lexicalRoot = resolve3(path);
@@ -7227,13 +7961,6 @@ function resolveWorktreePath(surface, worktreeDir) {
 }
 
 export {
-  JudgeParseError,
-  createDomainExpertJudge,
-  codeExecutionJudge,
-  coherenceJudge,
-  adversarialJudge,
-  createCustomJudge,
-  defaultJudges,
   pairArms,
   comparePairedArms,
   completionVerdict,
@@ -7241,7 +7968,6 @@ export {
   parseCorrectnessResponse,
   createLlmCorrectnessChecker,
   createTokenRecallChecker,
-  llmJudge,
   extractProducedState,
   CODING_HARNESSES,
   HARNESS_NATIVE_MODEL,
@@ -7297,14 +8023,16 @@ export {
   aceProposer,
   compositeProposer,
   haloProposer,
-  memoryCurationProposer,
   policyEditProposer,
+  selectPolicyEditAuthorRows,
+  assertPolicyEditAuthorContextBudget,
+  DEFAULT_POLICY_EDIT_HISTORY_LIMITS,
+  llmPolicyEditProposer,
+  projectPolicyEditHistory,
+  memoryCurationProposer,
   traceAnalystProposer,
   scoreDiscrimination,
   selectDiscriminative,
-  SearchLedgerError,
-  SearchLedgerIntegrityError,
-  SearchLedgerConflictError,
   SEARCH_LEDGER_SCHEMA,
   validateSearchLedgerEvent,
   openSearchLedger,
@@ -7316,4 +8044,4 @@ export {
   verifyCodeSurface,
   resolveWorktreePath
 };
-//# sourceMappingURL=chunk-KG4TD7EQ.js.map
+//# sourceMappingURL=chunk-ZUXV7UWZ.js.map