@tangle-network/agent-eval 0.115.3 → 0.116.0

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

@@ -12,7 +12,7 @@ import {
   runImprovementLoop,
   surfaceContentHash,
   surfaceHash
-} from "./chunk-ADYLPOSX.js";
+} from "./chunk-3274WNK7.js";
 import {
   estimateCost,
   isModelPriced
@@ -26,17 +26,23 @@ import {
 } from "./chunk-FAOEFFRT.js";
 import {
   Mutex,
-  admitPolicyEdit,
-  applyPolicyEditToSurface,
-  clamp01,
-  isPolicyEdit,
-  policyEditsFromFindings
-} from "./chunk-QMXXSNC4.js";
+  clamp01
+} from "./chunk-MPHTT5HE.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-CIUOICJT.js";
 import {
   eProcess,
   mcnemar,
@@ -63,7 +69,8 @@ import {
   canonicalize
 } from "./chunk-VSMTAMNK.js";
 import {
-  callLlm
+  callLlm,
+  callLlmJson
 } from "./chunk-GY4SYVPJ.js";
 import {
   AgentEvalError,
@@ -5130,10 +5137,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)}`);
@@ -5264,6 +5277,1153 @@ ${findings.slice(0, 800)}`,
   });
 }
 
+// src/campaign/proposers/llm-policy-edit.ts
+import { z } from "zod";
+
+// src/campaign/proposers/policy-edit.ts
+function policyEditProposer(opts = {}) {
+  return {
+    kind: "policy-edit",
+    async propose(ctx) {
+      const edits = materializePolicyEdits(opts.edits ?? ctx.findings, opts.findingOptions);
+      const limit = Math.max(
+        0,
+        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));
+        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(", ")}]`,
+          candidateRecord: makePolicyEditCandidateRecord(edit)
+        });
+        if (out.length >= limit) break;
+      }
+      return out;
+    }
+  };
+}
+function materializePolicyEdits(inputs, findingOptions) {
+  const edits = [];
+  const findings = [];
+  for (const input of inputs) {
+    if (isPolicyEdit(input)) {
+      edits.push(input);
+    } else if (isAnalystFindingLike(input)) {
+      findings.push(input);
+    }
+  }
+  if (findings.length > 0) edits.push(...policyEditsFromFindings(findings, findingOptions));
+  return edits;
+}
+function isAnalystFindingLike(input) {
+  if (!input || typeof input !== "object") return false;
+  const obj = input;
+  return typeof obj.finding_id === "string" && typeof obj.analyst_id === "string" && typeof obj.claim === "string" && Array.isArray(obj.evidence_refs);
+}
+function coerceCandidateSurface(surface) {
+  if (typeof surface === "string") return surface;
+  if (surface && typeof surface === "object") {
+    const obj = surface;
+    if (obj.kind === "code" && typeof obj.worktreeRef === "string") {
+      assertCodeSurfaceIdentity(surface);
+      return surface;
+    }
+    return JSON.stringify(surface, null, 2);
+  }
+  throw new Error("policyEditProposer: policy edit produced an unsupported surface");
+}
+
+// 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"
+  );
+  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 { value } = await callLlmJson(
+        {
+          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
+        },
+        { ...opts.llm, signal: ctx.signal }
+      );
+      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 -->";
@@ -5344,69 +6504,6 @@ ${block}
   };
 }
 
-// src/campaign/proposers/policy-edit.ts
-function policyEditProposer(opts = {}) {
-  return {
-    kind: "policy-edit",
-    async propose(ctx) {
-      const edits = materializePolicyEdits(opts.edits ?? ctx.findings, opts.findingOptions);
-      const limit = Math.max(
-        0,
-        Math.min(opts.maxCandidates ?? ctx.populationSize, ctx.populationSize)
-      );
-      const out = [];
-      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;
-        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(", ")}]`
-        });
-        if (out.length >= limit) break;
-      }
-      return out;
-    }
-  };
-}
-function materializePolicyEdits(inputs, findingOptions) {
-  const edits = [];
-  const findings = [];
-  for (const input of inputs) {
-    if (isPolicyEdit(input)) {
-      edits.push(input);
-    } else if (isAnalystFindingLike(input)) {
-      findings.push(input);
-    }
-  }
-  if (findings.length > 0) edits.push(...policyEditsFromFindings(findings, findingOptions));
-  return edits;
-}
-function isAnalystFindingLike(input) {
-  if (!input || typeof input !== "object") return false;
-  const obj = input;
-  return typeof obj.finding_id === "string" && typeof obj.analyst_id === "string" && typeof obj.claim === "string" && Array.isArray(obj.evidence_refs);
-}
-function coerceCandidateSurface(surface) {
-  if (typeof surface === "string") return surface;
-  if (surface && typeof surface === "object") {
-    const obj = surface;
-    if (obj.kind === "code" && typeof obj.worktreeRef === "string") {
-      assertCodeSurfaceIdentity(surface);
-      return surface;
-    }
-    return JSON.stringify(surface, null, 2);
-  }
-  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) {
@@ -5518,7 +6615,7 @@ function selectDiscriminative(signals, k, opts) {
 import { createHash as createHash7 } from "crypto";
 import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
 import { resolve as resolve2 } from "path";
-import { z as z2 } from "zod";
+import { z as z3 } from "zod";
 
 // src/campaign/search-ledger-errors.ts
 var SearchLedgerError = class extends ValidationError {
@@ -5545,7 +6642,7 @@ import {
 } from "fs";
 import { hostname } from "os";
 import { dirname as dirname2 } from "path";
-import { z } from "zod";
+import { z as z2 } 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);
@@ -5639,10 +6736,10 @@ function readOwner(lockPath) {
       cause: error
     });
   }
-  const parsed = z.object({
-    pid: z.number().int().positive().safe(),
-    host: z.string().trim().min(1),
-    nonce: z.string().trim().min(1)
+  const parsed = z2.object({
+    pid: z2.number().int().positive().safe(),
+    host: z2.string().trim().min(1),
+    nonce: z2.string().trim().min(1)
   }).strict().safeParse(raw);
   if (!parsed.success) {
     throw new SearchLedgerIntegrityError(
@@ -5672,82 +6769,82 @@ function unlinkIfExists(path) {
 
 // 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}$/);
-var LINEAGE_NODE_ID = z2.string().regex(/^[a-f0-9]{16}$/);
-var IMMUTABLE_REVISION = z2.string().regex(/^(?:[a-f0-9]{40}|[a-f0-9]{64}|sha256:[a-f0-9]{64}|sha512:[A-Za-z0-9+/=]+)$/);
-var ISO_TIMESTAMP = z2.string().regex(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z$/).refine((value) => Number.isFinite(Date.parse(value)), "invalid timestamp");
-var NON_NEGATIVE_INT = z2.number().int().nonnegative().safe();
-var FINITE_NUMBER = z2.number().finite();
-var ArtifactRefSchema = z2.object({
+var NON_EMPTY = z3.string().min(1).refine((value) => value.trim() === value, "must not contain surrounding whitespace");
+var HASH = z3.string().regex(/^sha256:[a-f0-9]{64}$/);
+var LINEAGE_NODE_ID = z3.string().regex(/^[a-f0-9]{16}$/);
+var IMMUTABLE_REVISION = z3.string().regex(/^(?:[a-f0-9]{40}|[a-f0-9]{64}|sha256:[a-f0-9]{64}|sha512:[A-Za-z0-9+/=]+)$/);
+var ISO_TIMESTAMP = z3.string().regex(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z$/).refine((value) => Number.isFinite(Date.parse(value)), "invalid timestamp");
+var NON_NEGATIVE_INT = z3.number().int().nonnegative().safe();
+var FINITE_NUMBER = z3.number().finite();
+var ArtifactRefSchema = z3.object({
   role: NON_EMPTY,
   uri: NON_EMPTY,
   sha256: HASH,
   byteLength: NON_NEGATIVE_INT
 }).strict();
-var SourceRefSchema = z2.object({
+var SourceRefSchema = z3.object({
   uri: NON_EMPTY,
   revision: IMMUTABLE_REVISION
 }).strict();
-var FailureReasonSchema = z2.object({
+var FailureReasonSchema = z3.object({
   code: NON_EMPTY,
   message: NON_EMPTY
 }).strict();
 var EventBaseShape = {
   eventId: NON_EMPTY,
   occurredAt: ISO_TIMESTAMP,
-  artifacts: z2.array(ArtifactRefSchema).min(1)
+  artifacts: z3.array(ArtifactRefSchema).min(1)
 };
-var OperationKindSchema = z2.enum([
+var OperationKindSchema = z3.enum([
   "candidate-generation",
   "analysis",
   "selection",
   "judge",
   "other"
 ]);
-var SearchPlannedSchema = z2.object({
+var SearchPlannedSchema = z3.object({
   ...EventBaseShape,
-  kind: z2.literal("search-planned"),
-  plan: z2.object({
-    candidateSlots: z2.array(
-      z2.object({
+  kind: z3.literal("search-planned"),
+  plan: z3.object({
+    candidateSlots: z3.array(
+      z3.object({
         slotId: NON_EMPTY,
         generationOperationId: NON_EMPTY
       }).strict()
     ).min(1),
-    tasks: z2.array(
-      z2.object({
+    tasks: z3.array(
+      z3.object({
         taskId: NON_EMPTY,
         source: SourceRefSchema,
         benchmark: SourceRefSchema,
-        maxAttempts: z2.number().int().positive().safe()
+        maxAttempts: z3.number().int().positive().safe()
       }).strict()
     ).min(1),
-    operations: z2.array(
-      z2.object({
+    operations: z3.array(
+      z3.object({
         operationId: NON_EMPTY,
         kind: OperationKindSchema
       }).strict()
     ).min(1)
   }).strict()
 }).strict();
-var CandidateRegisteredSchema = z2.object({
+var CandidateRegisteredSchema = z3.object({
   ...EventBaseShape,
-  kind: z2.literal("candidate-registered"),
+  kind: z3.literal("candidate-registered"),
   slotId: NON_EMPTY,
   generationOperationId: NON_EMPTY,
   candidateId: NON_EMPTY,
-  lineage: z2.object({
+  lineage: z3.object({
     lineageNodeId: LINEAGE_NODE_ID,
-    parentCandidateIds: z2.array(NON_EMPTY),
+    parentCandidateIds: z3.array(NON_EMPTY),
     generation: NON_NEGATIVE_INT,
     proposer: NON_EMPTY,
     proposerSource: SourceRefSchema
   }).strict(),
-  surfaces: z2.array(
-    z2.object({
+  surfaces: z3.array(
+    z3.object({
       surfaceId: NON_EMPTY,
-      kind: z2.enum([
+      kind: z3.enum([
         "prompt",
         "tool-contract",
         "runtime-config",
@@ -5761,69 +6858,69 @@ var CandidateRegisteredSchema = z2.object({
     }).strict()
   ).min(1)
 }).strict();
-var CandidateSlotClosedSchema = z2.object({
+var CandidateSlotClosedSchema = z3.object({
   ...EventBaseShape,
-  kind: z2.literal("candidate-slot-closed"),
+  kind: z3.literal("candidate-slot-closed"),
   slotId: NON_EMPTY,
   generationOperationId: NON_EMPTY,
   reason: FailureReasonSchema
 }).strict();
-var KnownTokensSchema = z2.object({
-  status: z2.literal("known"),
+var KnownTokensSchema = z3.object({
+  status: z3.literal("known"),
   inputTokens: NON_NEGATIVE_INT,
   outputTokens: NON_NEGATIVE_INT,
   cachedTokens: NON_NEGATIVE_INT
 }).strict();
-var UnknownSchema = z2.object({
-  status: z2.literal("unknown"),
+var UnknownSchema = z3.object({
+  status: z3.literal("unknown"),
   reason: NON_EMPTY
 }).strict();
-var KnownCostSchema = z2.object({
-  status: z2.literal("known"),
-  usd: z2.number().finite().nonnegative(),
-  source: z2.enum(["provider", "pricing-table", "free"])
+var KnownCostSchema = z3.object({
+  status: z3.literal("known"),
+  usd: z3.number().finite().nonnegative(),
+  source: z3.enum(["provider", "pricing-table", "free"])
 }).strict().superRefine((cost, ctx) => {
   if (cost.source === "free" && cost.usd !== 0) {
     ctx.addIssue({ code: "custom", message: "free cost source must have usd 0" });
   }
 });
-var UnknownCostSchema = z2.object({
-  status: z2.literal("unknown"),
-  knownLowerBoundUsd: z2.number().finite().nonnegative(),
+var UnknownCostSchema = z3.object({
+  status: z3.literal("unknown"),
+  knownLowerBoundUsd: z3.number().finite().nonnegative(),
   reason: NON_EMPTY
 }).strict();
-var AccountingSchema = z2.object({
-  tokens: z2.discriminatedUnion("status", [KnownTokensSchema, UnknownSchema]),
-  cost: z2.discriminatedUnion("status", [KnownCostSchema, UnknownCostSchema])
+var AccountingSchema = z3.object({
+  tokens: z3.discriminatedUnion("status", [KnownTokensSchema, UnknownSchema]),
+  cost: z3.discriminatedUnion("status", [KnownCostSchema, UnknownCostSchema])
 }).strict();
-var MetricsSchema = z2.record(NON_EMPTY, FINITE_NUMBER).superRefine((metrics, ctx) => {
+var MetricsSchema = z3.record(NON_EMPTY, FINITE_NUMBER).superRefine((metrics, ctx) => {
   for (const key of Object.keys(metrics)) {
     if (key === "__proto__" || key === "constructor" || key === "prototype") {
       ctx.addIssue({ code: "custom", message: `unsafe metric key ${key}` });
     }
   }
 });
-var OutcomeSchema = z2.discriminatedUnion("status", [
-  z2.object({
-    status: z2.literal("passed"),
+var OutcomeSchema = z3.discriminatedUnion("status", [
+  z3.object({
+    status: z3.literal("passed"),
     score: FINITE_NUMBER,
     metrics: MetricsSchema
   }).strict(),
-  z2.object({
-    status: z2.literal("failed"),
+  z3.object({
+    status: z3.literal("failed"),
     score: FINITE_NUMBER,
     metrics: MetricsSchema,
     failure: FailureReasonSchema
   }).strict(),
-  z2.object({
-    status: z2.literal("errored"),
+  z3.object({
+    status: z3.literal("errored"),
     metrics: MetricsSchema,
-    error: FailureReasonSchema.extend({ retryable: z2.boolean() }).strict()
+    error: FailureReasonSchema.extend({ retryable: z3.boolean() }).strict()
   }).strict()
 ]);
-var EffectSchema = z2.discriminatedUnion("status", [
-  z2.object({
-    status: z2.literal("measured"),
+var EffectSchema = z3.discriminatedUnion("status", [
+  z3.object({
+    status: z3.literal("measured"),
     metric: NON_EMPTY,
     baselineValue: FINITE_NUMBER,
     candidateValue: FINITE_NUMBER,
@@ -5835,17 +6932,17 @@ var EffectSchema = z2.discriminatedUnion("status", [
       ctx.addIssue({ code: "custom", message: "delta must equal candidateValue - baselineValue" });
     }
   }),
-  z2.object({
-    status: z2.literal("not-measured"),
+  z3.object({
+    status: z3.literal("not-measured"),
     reason: NON_EMPTY
   }).strict()
 ]);
-var SurfaceEvidenceSchema = z2.object({
+var SurfaceEvidenceSchema = z3.object({
   surfaceId: NON_EMPTY,
-  fired: z2.boolean(),
+  fired: z3.boolean(),
   firingCount: NON_NEGATIVE_INT,
   effect: EffectSchema,
-  evidence: z2.array(ArtifactRefSchema).min(1)
+  evidence: z3.array(ArtifactRefSchema).min(1)
 }).strict().superRefine((evidence, ctx) => {
   if (evidence.fired && evidence.firingCount === 0) {
     ctx.addIssue({ code: "custom", message: "a fired surface must have firingCount >= 1" });
@@ -5863,15 +6960,15 @@ var SurfaceEvidenceSchema = z2.object({
     });
   }
 });
-var TaskAttemptedSchema = z2.object({
+var TaskAttemptedSchema = z3.object({
   ...EventBaseShape,
-  kind: z2.literal("task-attempted"),
+  kind: z3.literal("task-attempted"),
   candidateId: NON_EMPTY,
   runId: NON_EMPTY,
   attemptIndex: NON_NEGATIVE_INT,
-  task: z2.object({ taskId: NON_EMPTY, source: SourceRefSchema }).strict(),
-  identity: z2.object({
-    model: z2.object({
+  task: z3.object({ taskId: NON_EMPTY, source: SourceRefSchema }).strict(),
+  identity: z3.object({
+    model: z3.object({
       provider: NON_EMPTY,
       snapshot: NON_EMPTY.refine(
         modelHasSnapshot,
@@ -5883,17 +6980,17 @@ var TaskAttemptedSchema = z2.object({
   }).strict(),
   outcome: OutcomeSchema,
   accounting: AccountingSchema,
-  surfaceEvidence: z2.array(SurfaceEvidenceSchema).min(1)
+  surfaceEvidence: z3.array(SurfaceEvidenceSchema).min(1)
 }).strict();
-var SearchOperationRecordedSchema = z2.object({
+var SearchOperationRecordedSchema = z3.object({
   ...EventBaseShape,
-  kind: z2.literal("search-operation-recorded"),
+  kind: z3.literal("search-operation-recorded"),
   operationId: NON_EMPTY,
   operationKind: OperationKindSchema,
-  execution: z2.discriminatedUnion("kind", [
-    z2.object({
-      kind: z2.literal("model"),
-      model: z2.object({
+  execution: z3.discriminatedUnion("kind", [
+    z3.object({
+      kind: z3.literal("model"),
+      model: z3.object({
         provider: NON_EMPTY,
         snapshot: NON_EMPTY.refine(
           modelHasSnapshot,
@@ -5902,51 +6999,51 @@ var SearchOperationRecordedSchema = z2.object({
       }).strict(),
       source: SourceRefSchema
     }).strict(),
-    z2.object({
-      kind: z2.literal("deterministic"),
+    z3.object({
+      kind: z3.literal("deterministic"),
       source: SourceRefSchema
     }).strict()
   ]),
-  outcome: z2.discriminatedUnion("status", [
-    z2.object({ status: z2.literal("completed") }).strict(),
-    z2.object({
-      status: z2.literal("partial"),
+  outcome: z3.discriminatedUnion("status", [
+    z3.object({ status: z3.literal("completed") }).strict(),
+    z3.object({
+      status: z3.literal("partial"),
       failure: FailureReasonSchema
     }).strict(),
-    z2.object({
-      status: z2.literal("failed"),
+    z3.object({
+      status: z3.literal("failed"),
       failure: FailureReasonSchema
     }).strict()
   ]),
   accounting: AccountingSchema
 }).strict();
-var CandidateDecidedSchema = z2.object({
+var CandidateDecidedSchema = z3.object({
   ...EventBaseShape,
-  kind: z2.literal("candidate-decided"),
+  kind: z3.literal("candidate-decided"),
   candidateId: NON_EMPTY,
-  decision: z2.discriminatedUnion("status", [
-    z2.object({ status: z2.literal("selected") }).strict(),
-    z2.object({
-      status: z2.literal("rejected"),
+  decision: z3.discriminatedUnion("status", [
+    z3.object({ status: z3.literal("selected") }).strict(),
+    z3.object({
+      status: z3.literal("rejected"),
       reason: FailureReasonSchema
     }).strict()
   ])
 }).strict();
-var SearchCompletedSchema = z2.object({
+var SearchCompletedSchema = z3.object({
   ...EventBaseShape,
-  kind: z2.literal("search-completed"),
-  result: z2.discriminatedUnion("status", [
-    z2.object({
-      status: z2.literal("selected"),
+  kind: z3.literal("search-completed"),
+  result: z3.discriminatedUnion("status", [
+    z3.object({
+      status: z3.literal("selected"),
       candidateId: NON_EMPTY
     }).strict(),
-    z2.object({
-      status: z2.literal("all-rejected"),
+    z3.object({
+      status: z3.literal("all-rejected"),
       reason: FailureReasonSchema
     }).strict()
   ])
 }).strict();
-var EventSchema = z2.discriminatedUnion("kind", [
+var EventSchema = z3.discriminatedUnion("kind", [
   SearchPlannedSchema,
   CandidateRegisteredSchema,
   CandidateSlotClosedSchema,
@@ -5955,11 +7052,11 @@ var EventSchema = z2.discriminatedUnion("kind", [
   CandidateDecidedSchema,
   SearchCompletedSchema
 ]);
-var EntrySchema = z2.object({
-  schema: z2.literal(SEARCH_LEDGER_SCHEMA),
+var EntrySchema = z3.object({
+  schema: z3.literal(SEARCH_LEDGER_SCHEMA),
   campaignId: NON_EMPTY,
   sequence: NON_NEGATIVE_INT,
-  previousHash: z2.union([HASH, z2.null()]),
+  previousHash: z3.union([HASH, z3.null()]),
   event: EventSchema,
   entryHash: HASH
 }).strict();
@@ -7297,8 +8394,13 @@ export {
   aceProposer,
   compositeProposer,
   haloProposer,
-  memoryCurationProposer,
   policyEditProposer,
+  selectPolicyEditAuthorRows,
+  assertPolicyEditAuthorContextBudget,
+  DEFAULT_POLICY_EDIT_HISTORY_LIMITS,
+  llmPolicyEditProposer,
+  projectPolicyEditHistory,
+  memoryCurationProposer,
   traceAnalystProposer,
   scoreDiscrimination,
   selectDiscriminative,
@@ -7316,4 +8418,4 @@ export {
   verifyCodeSurface,
   resolveWorktreePath
 };
-//# sourceMappingURL=chunk-KG4TD7EQ.js.map
+//# sourceMappingURL=chunk-GSW3OBHK.js.map