@tangle-network/agent-eval 0.191.0 → 0.193.0

package/dist/{index-CzfnASj_.d.ts → index-DMPLG226.d.ts}

@@ -1,21 +1,19 @@
 import { c as ValidationError, t as AgentEvalError } from "./errors-DEE6u6ot.js";
 import { T as RunPaidCallInput, c as CostLedgerHandle, f as CostLedgerSummary, m as CostReceipt, o as CostLedger, p as CostProvenance } from "./cost-ledger-DbQdN3nO.js";
-import { a as RunRecord, c as RunSplitTag, s as RunSearchCoordinates } from "./run-record-DF-fuu31.js";
+import { a as RunRecord, c as RunSplitTag } from "./run-record-DF-fuu31.js";
 import { O as TraceAnalysisStore, _ as ProposalFinding, f as AnalystUsageReceipt, i as AnalystFinding, l as AnalystRunResult } from "./types-CeDfCRXp.js";
 import { M as LlmCallMetadata, ft as ServedModelPolicy, rt as RawProviderSink, x as ChatClient } from "./types-C0bWoSKC.js";
-import { Et as FinalEvidenceLedger, P as PairedArmsComparison, ft as EvidenceReceipt, it as CampaignEvidenceContext, kt as FinalEvidenceRecord } from "./statistical-heldout-BED3wBtX.js";
+import { Et as FinalEvidenceLedger, P as PairedArmsComparison, ft as EvidenceReceipt, it as CampaignEvidenceContext, kt as FinalEvidenceRecord } from "./statistical-heldout-D-xBpbrd.js";
 import { a as PairedPromotionDecision, d as PairedBootstrapResult } from "./paired-promotion-decision-DPKz8ZnF.js";
-import { A as LabeledScenarioWrite, B as ScoredSurfaceOutcome, C as JudgeDimension, D as LabeledScenarioSampleArgs, E as LabeledScenarioRecord, H as SurfaceProposer, N as ParetoParent, O as LabeledScenarioSource, R as Scenario, S as JudgeConfig, T as LabelTrust, _ as GateDecision, a as CampaignResult, b as GenerationRecord, c as CampaignTraceWriter, d as DispatchContext, f as DispatchFn, g as GateContribution, i as CampaignCostMeter, j as MutableSurface, k as LabeledScenarioStore, l as CodeSurface, o as CampaignScenarioIdentity, p as Gate, r as CampaignCellResult, u as ComponentSurface, v as GateResult, y as GenerationCandidate } from "./types-BmQRs661.js";
-import { n as EvaluationUnitSummary, t as EvaluationClaim } from "./claim-BGOUqoMq.js";
+import { A as SearchLedgerHash, C as SearchEdgeOperator, E as SearchExecutionIdentity, G as SearchSplit, H as SearchProposerKind, L as SearchOpenedEvent, N as SearchNodeDecision, O as SearchLedgerEntry, P as SearchNodeRef, Q as SearchTaskOutcome, R as SearchOperationKind, S as SearchEdgeAttribution, U as SearchReservation, V as SearchProposer, W as SearchSourceRef, Y as SearchSurfaceEvidence, Z as SearchTask, _ as SearchClaimPower, a as SearchAttemptAccounting, et as SearchTraceRef, i as SearchArtifactRef, j as SearchModelIdentity, k as SearchLedgerEvent, l as SearchCandidateSurface, m as SearchClaim, nt as EvaluationClaim, o as SearchAudit, p as SearchCellStage, rt as EvaluationUnitSummary, t as NodeEstimate, tt as SearchUnknown, y as SearchCloseReason, z as SearchOperationRecordedEvent } from "./search-ledger-types-B3El5xgS.js";
+import { b as LedgerTrustedHeadRemoval, f as LedgerLineContext, h as LedgerTextStore, y as LedgerTrustedHead } from "./index-Bj96W0jZ.js";
 import { r as LedgerHash } from "./canonical-CFpojCN5.js";
-import { _ as LedgerTrustedHead, f as LedgerLineContext, p as LedgerProjector, v as LedgerTrustedHeadRemoval } from "./index-I4UJGRno.js";
-import { A as SearchNodeDecision, B as SearchReservation, C as SearchExecutionIdentity, D as SearchLedgerHash, E as SearchLedgerEvent, F as SearchOperationKind, H as SearchSplit, I as SearchOperationRecordedEvent, J as SearchTask, K as SearchSurfaceEvidence, N as SearchNodeStatus, O as SearchModelIdentity, P as SearchOpenedEvent, Q as SearchUnknown, R as SearchProposer, T as SearchLedgerEntry, V as SearchSourceRef, Y as SearchTaskOutcome, Z as SearchTraceRef, _ as SearchClosedEvent, a as SearchAttemptAccounting, b as SearchEdgeOperator, d as SearchCellCancelledEvent, g as SearchCloseReason, i as SearchArtifactRef, j as SearchNodeRef, l as SearchCandidateSurface, m as SearchClaim, o as SearchAudit, p as SearchCellStage, t as NodeEstimate, x as SearchEdgeRecordedEvent, y as SearchEdgeAttribution } from "./search-ledger-types-C9anU2DX.js";
-import { i as RolloutSearchLineage } from "./mint-C9Lojt1V.js";
+import { $ as SearchNode, A as LabeledScenarioWrite, C as JudgeDimension, D as LabeledScenarioSampleArgs, E as LabeledScenarioRecord, H as SurfaceProposer, N as ParetoParent, O as LabeledScenarioSource, R as Scenario, S as JudgeConfig, T as LabelTrust, _ as GateDecision, a as CampaignResult, at as SearchUnitScore, b as GenerationRecord, c as CampaignTraceWriter, d as DispatchContext, f as DispatchFn, g as GateContribution, i as CampaignCostMeter, it as SearchStateView, j as MutableSurface, k as LabeledScenarioStore, l as CodeSurface, o as CampaignScenarioIdentity, p as Gate, r as CampaignCellResult, tt as SearchScoredCell, u as ComponentSurface, v as GateResult, y as GenerationCandidate } from "./types-BWwRXofp.js";
 import { B as ExternalOptimizerModelBudget, E as AnalystIssueExpectation, F as ExternalOptimizerCallbackLimits, J as ExternalOptimizerWireCounts, K as ExternalOptimizerResumeMode, R as ExternalOptimizerEvaluationObservation, V as ExternalOptimizerModelCall, X as ExternalTextEvaluationRequest, Y as ExternalTextCandidate, m as AnalystBenchmarkLabelState, q as ExternalOptimizerRunnerCommand, t as AgentProfile$1, u as AnalystBenchmarkCase } from "./agent-profile-DDfIjdyS.js";
 import { r as DatasetScenario, t as Dataset } from "./dataset-DQqhOCPt.js";
 import { a as CheckerIdentity, n as VerdictCertification, t as DefaultVerdict, x as VerificationStrategySource } from "./verdict-E4eRNf7-.js";
 import { t as DetectRewardHackingInput } from "./reward-hacking-Cyk-QHk9.js";
-import { p as TraceSpanEvent, t as HostedClient } from "./client-wFyDisxi.js";
+import { p as TraceSpanEvent, t as HostedClient } from "./client-dMMKoQNS.js";
 import { AgentProfile } from "@tangle-network/agent-interface";
 import { z } from "zod";
 //#region src/campaign/coverage.d.ts
@@ -59,6 +57,10 @@ interface FinalEvidenceUse {
  * so the same `join(...)`-built paths work unchanged across both adapters.
  */
 interface CampaignStorage {
+  /** `filesystem` for the Node filesystem, whose paths durable journals such
+   * as the search ledger may open directly; any other storage keeps those
+   * journals in itself. */
+  readonly kind?: 'filesystem' | 'memory';
   /** Ensure a directory exists (recursive). No-op for in-memory. */
   ensureDir(dir: string): void;
   /** Does this path exist (as a written file or an ensured dir)? */
@@ -393,40 +395,6 @@ interface OpenAutoPrResult {
  */
 declare function openAutoPr<TArtifact, TScenario extends Scenario>(options: OpenAutoPrOptions<TArtifact, TScenario>): OpenAutoPrResult;
 //#endregion
-//#region src/campaign/parent-selection.d.ts
-/** Search state supplied to one parent-selection call. */
-interface ParentSelectionContext {
-  /** Non-dominated scored surfaces across the whole run so far, including the
-   *  baseline (`generation: -1`). Never empty. */
-  readonly frontier: ReadonlyArray<ParetoParent>;
-  /** Measured result of the global incumbent, the promotion bar. Under the
-   *  default `selectionRankKey` the incumbent is always on `frontier`. */
-  readonly incumbent: ScoredSurfaceOutcome;
-  /** Every completed generation so far. */
-  readonly history: ReadonlyArray<GenerationRecord>;
-  /** Index of the generation about to propose. */
-  readonly generation: number;
-}
-/** Chooses the surface the next generation mutates. Returns one frontier
- *  parent; `runOptimization` refuses a parent it has not measured to
- *  completion or whose surface does not match its `surfaceHash`. */
-type ParentSelector = (ctx: ParentSelectionContext) => ParetoParent;
-interface CrowdedFrontierParentOptions {
-  /** Integer seed for the per-generation draw. The same seed, frontier, and
-   *  generation index select the same parent. */
-  seed: number;
-}
-/**
- * NSGA-II crowded tournament selection over the frontier. Each generation
- * draws two distinct frontier members with a PRNG seeded from `seed` and the
- * generation index, and keeps the one with the larger crowding distance (more
- * isolated on the frontier). Boundary parents carry infinite distance, so a
- * boundary parent always beats an interior one. A tie on distance falls back
- * to the higher mean composite, then to the smaller surface hash. A frontier
- * of one member returns that member.
- */
-declare function crowdedFrontierParent(options: CrowdedFrontierParentOptions): ParentSelector;
-//#endregion
 //#region src/campaign/search-ledger-errors.d.ts
 /** Base error for invalid search-ledger input or operations. */
 declare class SearchLedgerError extends ValidationError {}
@@ -435,247 +403,6 @@ declare class SearchLedgerIntegrityError extends SearchLedgerError {}
 /** Error raised when an event identifier is reused with different content. */
 declare class SearchLedgerConflictError extends SearchLedgerError {}
 //#endregion
-//#region src/campaign/search-state.d.ts
-/** Deterministic node id: identical content in one search is one node. */
-declare function searchNodeId(searchId: string, artifactDigest: string): string;
-/** Deterministic cell id: one node on one task in one split at one repeat. */
-declare function searchCellId(searchId: string, nodeId: string, taskId: string, split: SearchSplit, rep: number): string;
-/** Digest a split's task list in taskId order. */
-declare function searchTaskSetDigest(tasks: readonly SearchTask[]): SearchLedgerHash;
-interface SearchDecisionRecord {
-  sequence: number;
-  decision: SearchNodeDecision;
-  basis: NodeEstimate | null;
-  rule: string;
-  reason: string;
-}
-interface SearchSpend {
-  knownUsd: number;
-  floorUsd: number;
-  unknownCostCells: number;
-  boxMinutes: number;
-}
-/** Scores of one node on one unit of one split: the sum and count of its
- * scored cells. Repeats and sibling tasks of the unit average inside it. */
-interface SearchUnitScore {
-  unitId: string;
-  sum: number;
-  count: number;
-  mean: number;
-}
-/** A cell's scored attempt: the inputs of every per-unit statistic. */
-interface SearchScoredCell {
-  cellId: string;
-  unitId: string;
-  /** The attempt that produced the score, which is the cell's last. */
-  attempt: number;
-  score: number;
-}
-/**
- * Per-unit means of scored cells, in unitId order. Each unit sums its cells in
- * cellId order, so the result depends on the set of cells alone, never on the
- * order they settled in: a verifier that reads the same cells from a database
- * gets the same bits.
- */
-declare function searchUnitScores(cells: readonly SearchScoredCell[]): SearchUnitScore[];
-interface SearchNode {
-  nodeId: string;
-  /** Registration order; the root is 0. */
-  ordinal: number;
-  artifactDigest: SearchLedgerHash;
-  artifact: SearchArtifactRef;
-  surfaces: readonly SearchCandidateSurface[];
-  /** First in-search parent of the node's first edge; null for the root, a
-   * derived root, or a node whose parents are unknown. */
-  primaryParentId: string | null;
-  /** Edges from the root along primary parents; null while unknown. */
-  depth: number | null;
-  /** Every parent named by any edge into the node, in edge order. */
-  parents: readonly SearchNodeRef[];
-  children: readonly string[];
-  edgeIds: readonly string[];
-  status: SearchNodeStatus | null;
-  rung: number | null;
-  /** The node was decided `finalist` at some point, so its test cells are legal. */
-  finalist: boolean;
-  decisions: readonly SearchDecisionRecord[];
-  cellCount: number;
-  spend: SearchSpend;
-  registeredSequence: number;
-  updatedSequence: number;
-}
-interface SearchCell {
-  cellId: string;
-  nodeId: string;
-  taskId: string;
-  unitId: string;
-  split: SearchSplit;
-  rep: number;
-  stage: SearchCellStage;
-  lane: string | null;
-  reservation: SearchReservation | null;
-  attempts: number;
-  lastRunId: string | null;
-  outcome: SearchTaskOutcome['status'] | null;
-  /** Score of the scored attempt; null when no attempt was scored. */
-  score: number | null;
-  /** No further attempt is legal: a scored or non-retryable outcome. */
-  final: boolean;
-  cancelled: SearchCellCancelledEvent['reason'] | null;
-  /** Known cost plus proven floors across attempts. */
-  spentUsd: number;
-  /** Every attempt's cost is known. */
-  costKnown: boolean;
-  traceId: string | null;
-  allocatedSequence: number;
-  updatedSequence: number;
-}
-interface SearchOperation {
-  operationId: string;
-  operationKind: SearchOperationKind;
-  reservation: SearchReservation | null;
-  recorded: boolean;
-  spentUsd: number;
-}
-interface SearchCompletion {
-  complete: boolean;
-  reasons: string[];
-}
-/**
- * The pure, incremental projection of one search ledger. `apply` refuses any
- * entry that breaks an invariant; the journal then discards this instance and
- * replays into a new one, so a refused entry leaves no partial state behind.
- */
-declare class SearchState implements LedgerProjector<SearchLedgerEntry, SearchStateView> {
-  readonly searchId: string;
-  private version;
-  private header;
-  private closed;
-  private head;
-  private lastOccurredAt;
-  private lastOccurredAtText;
-  private readonly tasks;
-  private readonly nodes;
-  private readonly nodeOrder;
-  private readonly nodeByDigest;
-  private readonly edges;
-  private readonly edgeOrder;
-  private readonly cells;
-  private readonly operations;
-  private selectedNodeId;
-  private claimUsedUsd;
-  private readonly audit;
-  constructor(searchId: string);
-  apply(entry: SearchLedgerEntry, index: number): void;
-  snapshot(): SearchStateView;
-  /** @internal Views check this before every read of the live indexes. */
-  isAt(version: number): boolean;
-  private applyEvent;
-  private open;
-  private startOperation;
-  private recordOperation;
-  private registerNode;
-  private recordEdge;
-  private allocateCell;
-  private settleCell;
-  private cancelCell;
-  private decideNode;
-  private close;
-  private checkClaim;
-  /** @internal */
-  incompleteReasons(): string[];
-  /** Book an attempt's or operation's accounting into the running totals. An
-   * unknown cost counts as its proven floor. */
-  private book;
-  /** A cell's share of the open reservations, its overspend, and what it draws
-   * from the claim reserve: the larger of its hold and its spend. */
-  private reservationParts;
-  /** The admission rule: committed spend, open holds, the unspent claim
-   * reserve and the new hold stay within the cap. A claim cell draws on the
-   * claim reserve instead of adding to it. */
-  private admit;
-  /** @internal */
-  readHeader(): SearchOpenedEvent | null;
-  /** @internal */
-  readClosed(): SearchClosedEvent | null;
-  /** @internal */
-  readHead(): {
-    sequence: number;
-    entryHash: SearchLedgerHash;
-  } | null;
-  /** @internal */
-  readLastOccurredAt(): string | null;
-  /** @internal */
-  readAudit(): SearchAudit;
-  /** @internal */
-  readNode(nodeId: string): SearchNode | undefined;
-  /** @internal */
-  readNodeIds(): readonly string[];
-  /** @internal */
-  readHasNode(nodeId: string): boolean;
-  /** @internal */
-  readNodeIdForDigest(artifactDigest: string): string | undefined;
-  /** @internal */
-  readEdge(edgeId: string): SearchEdgeRecordedEvent | undefined;
-  /** @internal */
-  readEdgeIds(): readonly string[];
-  /** @internal */
-  readCell(cellId: string): SearchCell | undefined;
-  /** @internal */
-  readCellIds(nodeId?: string): readonly string[];
-  /** @internal */
-  readOperation(operationId: string): SearchOperation | undefined;
-  /** @internal */
-  readScoredCells(nodeId: string, split: SearchSplit): SearchScoredCell[];
-}
-/**
- * A read of `SearchState` at one ledger position. Header, head, audit and
- * claim are values. Node, edge, cell and score reads go to the live indexes and
- * throw once the state has applied a later entry.
- */
-declare class SearchStateView {
-  readonly searchId: string;
-  readonly header: SearchOpenedEvent | null;
-  readonly closed: SearchClosedEvent | null;
-  readonly head: {
-    sequence: number;
-    entryHash: SearchLedgerHash;
-  } | null;
-  /** `occurredAt` of the head entry; a writer stamps later events at or after it. */
-  readonly lastOccurredAt: string | null;
-  readonly audit: SearchAudit;
-  readonly completion: SearchCompletion;
-  private readonly state;
-  private readonly version;
-  constructor(state: SearchState, version: number);
-  /** The node the search started from: the first registered. */
-  get rootNodeId(): string | null;
-  node(nodeId: string): SearchNode | undefined;
-  hasNode(nodeId: string): boolean;
-  /** Node ids in registration order. */
-  nodeIds(): string[];
-  /** Nodes in registration order. */
-  nodes(): SearchNode[];
-  nodeIdForDigest(artifactDigest: string): string | undefined;
-  edge(edgeId: string): SearchEdgeRecordedEvent | undefined;
-  /** Edges in ledger order. */
-  edges(): SearchEdgeRecordedEvent[];
-  cell(cellId: string): SearchCell | undefined;
-  /** Cells in allocation order, optionally of one node. */
-  cells(filter?: {
-    nodeId?: string;
-  }): SearchCell[];
-  operation(operationId: string): SearchOperation | undefined;
-  /** A node's scored cells on one split, in allocation order. Unscored cells
-   * (errored, cancelled or in flight) are absent, never zero. */
-  scoredCells(nodeId: string, split: SearchSplit): SearchScoredCell[];
-  /** Per-unit score means of a node on one split, in unitId order. */
-  unitScores(nodeId: string, split: SearchSplit): SearchUnitScore[];
-  /** The lineage a RunRecord mint needs for one cell attempt. */
-  lineage(coordinates: RunSearchCoordinates): RolloutSearchLineage;
-  private live;
-}
-//#endregion
 //#region src/campaign/search-ledger.d.ts
 /** Validate and return a canonical copy. Arrays whose order carries no meaning
  * are sorted, so retries from different processes produce identical bytes. */
@@ -698,6 +425,13 @@ interface OpenSearchLedgerOptions {
   path: string;
   searchId: string;
   trustedHead?: SearchLedgerTrustedHeadMode;
+  /**
+   * Keep the ledger's text in this in-process store instead of a file, for a
+   * run without a filesystem (an in-memory `CampaignStorage`, keyed by `path`).
+   * The chain, parse and state rules are the file ledger's; there is no lock,
+   * fsync or trusted head, and the ledger lives as long as the store.
+   */
+  store?: LedgerTextStore;
 }
 interface SearchLedgerAppendResult {
   entry: SearchLedgerEntry;
@@ -966,6 +700,12 @@ declare class SearchRecorder {
   state(): Promise<SearchStateView>;
   /** Store `body` as a canonical JSON blob and return its content address. */
   blob(role: string, body: unknown): SearchArtifactRef;
+  /**
+   * Read back a blob this recorder stored, by its content address. The bytes
+   * must hash to the reference's digest and length, so a resumed search reads
+   * exactly what the ledger bound.
+   */
+  readBlob(ref: SearchArtifactRef): unknown;
   /** Register a node, or return the existing node with the same artifact digest. */
   registerNode(input: RegisterSearchNodeInput): Promise<{
     nodeId: string;
@@ -977,6 +717,9 @@ declare class SearchRecorder {
     operationId: string;
     operationKind: SearchOperationKind;
     reservation?: SearchReservation | null;
+    /** Bound at the start, so a restart finds them even if the operation
+     * never records a result. */
+    artifacts?: SearchArtifactRef[];
   }): Promise<void>;
   recordOperation(input: Omit<SearchOperationRecordedEvent, 'kind' | 'eventId' | 'occurredAt' | 'artifacts'> & {
     artifacts?: SearchArtifactRef[];
@@ -1017,6 +760,74 @@ declare function surfaceNode(recorder: SearchRecorder, surface: MutableSurface):
 /** A parent-to-child diff of two mutable surfaces, stored as a blob. */
 declare function surfaceDiff(recorder: SearchRecorder, parent: MutableSurface, child: MutableSurface): SearchArtifactRef;
 //#endregion
+//#region src/campaign/search-policy.d.ts
+/** What a policy may read about a search. */
+interface SearchPolicyView {
+  readonly searchId: string;
+  readonly seed: number;
+  readonly direction: 'maximize' | 'minimize';
+  /** The split nodes are ranked on: selection, or train when the search
+   * declares no selection split (the proposer's own feedback then ranks). */
+  readonly split: 'selection' | 'train';
+  readonly rootNodeId: string;
+  /** Proposals completed so far. One an interrupted process lost does not count. */
+  readonly expansions: number;
+  /** Admitted nodes whose screen finished, in registration order, root first. */
+  readonly screened: readonly string[];
+  /** Admitted nodes still being screened. */
+  readonly screening: number;
+  /** True when the node scored every unit its screen allocated on `split`.
+   * A node that dodged a unit (an unscored cell) cannot lead. */
+  complete(nodeId: string): boolean;
+  /** Per-unit means on `split`, in unitId order. */
+  unitScores(nodeId: string): readonly SearchUnitScore[];
+  /** The paired contrast of `nodeId` against `against` on `split`. */
+  estimate(nodeId: string, against: string): NodeEstimate;
+}
+/** One expansion: the parents a proposer derives a child from, and how. */
+interface SearchExpansion {
+  parents: string[];
+  operator: Exclude<SearchEdgeOperator, 'seed' | 'derive'>;
+  /** Why these parents: recorded on every edge the expansion produces. */
+  selection: {
+    rule: string;
+    evidence: Record<string, number>;
+  };
+}
+interface SearchPolicy {
+  /** Recorded as the search's `policy.expansion`. */
+  readonly name: string;
+  /** Stop after this many expansions without a new leader. */
+  readonly patience?: number;
+  /** The next expansion, or null to wait for more evidence. */
+  expand(view: SearchPolicyView): SearchExpansion | null;
+  /** The node the search keeps if it stopped now. */
+  leader(view: SearchPolicyView): string;
+}
+/**
+ * The hill climb. The leader starts at the root; a screened node that scored
+ * every unit of its screen takes the lead when its mean on the units it shares
+ * with the leader beats the leader's mean on those units. Nodes are taken in
+ * registration order, so the leader is a pure function of the ledger. The
+ * policy expands the leader, and only once every earlier child is screened,
+ * so each proposal sees every result before it.
+ */
+declare function incumbent(options?: {
+  patience?: number;
+}): SearchPolicy;
+/**
+ * The hill climb with a different parent: each expansion draws two distinct
+ * members of the Pareto frontier (per-unit means on the policy split) with a
+ * PRNG seeded from `seed` and the expansion index, and keeps the one with the
+ * larger crowding distance, the more isolated. Boundary members carry infinite
+ * distance. Ties fall to the higher mean, then to the earlier node. The leader
+ * rule is the incumbent's: a frontier parent explores, and only a node that
+ * beats the leader leads.
+ */
+declare function crowdedFrontierParent(options: {
+  seed: number;
+}): SearchPolicy;
+//#endregion
 //#region src/campaign/presets/run-optimization.d.ts
 interface PremeasuredOptimizationBaseline<TArtifact, TScenario extends Scenario> {
   /** Hash of the exact surface that produced `campaign`. */
@@ -1030,36 +841,34 @@ interface RunOptimizationBaseOptions<TScenario extends Scenario, TArtifact> exte
   /**
    * Complete prior measurement of `baselineSurface`. When present,
    * `runOptimization` validates its surface, scenario split, seed, reps, and
-   * normal campaign coverage, then skips the baseline campaign entirely — no
-   * dispatch or resumability-cache lookup. Candidate campaigns still run
-   * normally. Prior spend remains in the imported campaign aggregates and is
-   * not added again to this continuation's CostLedger.
+   * normal campaign coverage, then records its cells as the root's instead of
+   * dispatching them. Prior spend stays in the imported campaign aggregates and
+   * is not added again to this run's CostLedger.
    */
   premeasuredBaseline?: PremeasuredOptimizationBaseline<TArtifact, TScenario>;
-  /** Dispatcher that takes the CURRENT surface + scenario → artifact. */
+  /** Dispatcher that takes a surface and a scenario to an artifact. */
   dispatchWithSurface: (surface: MutableSurface, scenario: TScenario, ctx: Parameters<RunCampaignOptions<TScenario, TArtifact>['dispatch']>[1]) => Promise<TArtifact>;
   /** The candidate-generation strategy. */
   proposer: SurfaceProposer<ProposalFinding>;
+  /** Candidates asked of each proposal. */
   populationSize: number;
+  /** Proposals the search may make. */
   maxGenerations: number;
-  /** Candidate campaigns run at once. Default 1. Total concurrent cells are
-   *  bounded by candidateConcurrency * maxConcurrency. */
+  /** Scales the run's cell lanes: at most `candidateConcurrency *
+   * maxConcurrency` cells run at once. Default 1. */
   candidateConcurrency?: number;
-  /** DEPTH knob forwarded to the proposer's `propose()` — max iterations the
+  /** DEPTH knob forwarded to the proposer's `propose()`: max iterations the
    *  agentic generator may take per candidate. */
   maxImprovementShots?: number;
   /** Search or observed-production findings forwarded to candidate generation. */
   findings?: ReadonlyArray<ProposalFinding>;
-  /** Per-generation findings producer. Runs once on the BASELINE campaign
-   *  (as `generation: -1`, the baseline convention) before generation 0
-   *  proposes — so even a single-generation run proposes with trace context —
-   *  and then after each generation's candidates are scored with that
-   *  generation's results; whatever it returns REPLACES `ctx.findings` for the
-   *  NEXT `propose()`, so the diagnosis is refreshed each round instead
-   *  of being a static one-shot. Generic by design: the substrate does not
-   *  import an analyst — the consumer plugs its trace-analyst registry / HALO
-   *  here (reading the per-candidate `runDir` traces). When absent, findings
-   *  stay the static `opts.findings`. */
+  /** Findings producer. Before each proposal it runs on the previous
+   *  generation's measured candidates (the baseline, as `generation: -1`,
+   *  before the first), and what it returns REPLACES `ctx.findings` for that
+   *  proposal. The substrate does not import an analyst: the consumer plugs its
+   *  trace-analyst registry here, reading the per-candidate `runDir` traces.
+   *  When absent, findings stay the static `opts.findings`. Its spend is
+   *  booked to the proposal's operation. */
   analyzeGeneration?: (input: {
     generation: number;
     runDir: string;
@@ -1073,53 +882,19 @@ interface RunOptimizationBaseOptions<TScenario extends Scenario, TArtifact> exte
     costLedger?: CostLedgerHandle;
     costPhase?: string;
   }) => Promise<ReadonlyArray<ProposalFinding>>;
-  /**
-   * Optional override for how the WINNER is selected among coverage-complete
-   * candidates (and how the incumbent bar is set). Returns a lexicographic rank
-   * key — each element higher-is-better; candidates are ranked by descending key
-   * (`compareRankKeys`) and the top must STRICTLY beat the incumbent's key to
-   * promote. Defaults to `[campaignMeanComposite(campaign)]`, i.e. the historical
-   * scalar-mean ranking (single-element key ⇒ identical behavior).
-   *
-   * A binary-with-replicates consumer (e.g. swe-arena, whose ship-gate counts an
-   * instance resolved only when EVERY replicate resolved) passes a fail-closed
-   * key built from the SAME reduction its gate uses, so winner-selection and the
-   * ship-gate rank on the identical metric and can never invert — the selector
-   * cannot promote a flaky per-cell-mean candidate the gate would reject over a
-   * fail-closed candidate the gate would accept. Only the winner CHOICE changes;
-   * the descriptive `composite` (mean) on every record and the Pareto objective
-   * vectors are untouched, so proposer diversity and reporting are unaffected.
-   */
-  selectionRankKey?: (campaign: CampaignResult<TArtifact, TScenario>) => number[];
-  /**
-   * Optional policy for which scored surface the next generation MUTATES.
-   * Absent, every generation mutates the global incumbent, so the recorded
-   * `parentSurfaceHash` lineage is a chain. Present, the selector receives the
-   * Pareto frontier so far, the measured incumbent, the generation history,
-   * and the generation index, and returns one frontier parent; the loop hands
-   * that parent to `propose()` as `currentSurface` + `parentOutcome` and
-   * records it as every candidate's `parentSurfaceHash`. Promotion is
-   * unchanged: a candidate still has to beat the incumbent. The loop refuses
-   * a parent it has not measured to completion. `crowdedFrontierParent` is
-   * the provided seeded policy.
-   */
-  selectParent?: ParentSelector;
-  /**
-   * Record this search into a search ledger as it runs: the baseline as the
-   * seeded root and its cells, each generation's candidate-generation
-   * operation, each candidate as a node with an explicit edge, rationale and
-   * diff from the parent it mutated, each designed cell when its campaign
-   * starts and settles, one decision per node, and the close. Returns a
-   * bounded `searchHistory` receipt over the exact ledger bytes.
-   *
-   * `identity` declares what the ledger requires and a campaign cannot infer:
-   * immutable revisions for the agent, proposer, and search implementations,
-   * and the model the agent runs when a cell reports none.
-   */
+  /** Which node each proposal extends, and which node the run keeps. Default
+   *  `incumbent()`: the hill climb. `crowdedFrontierParent({ seed })` draws
+   *  the parent from the Pareto frontier instead. */
+  policy?: SearchPolicy;
+  /** Where the search ledger goes and the identities it records. Default: a
+   *  ledger at `<runDir>/search/ledger.jsonl`, held in `storage` unless that is
+   *  the filesystem, whose identities are the dispatch ref's and proposer's
+   *  digests. */
   searchLedger?: SearchLedgerBinding;
 }
 type RunOptimizationOptions<TScenario extends Scenario, TArtifact> = RunOptimizationBaseOptions<TScenario, TArtifact>;
 interface RunOptimizationResult<TArtifact, TScenario extends Scenario> {
+  /** One entry per proposal, with the candidates it registered. */
   generations: Array<{
     record: GenerationRecord;
     surfaces: Array<{
@@ -1132,31 +907,20 @@ interface RunOptimizationResult<TArtifact, TScenario extends Scenario> {
   baselineSurface: MutableSurface;
   winnerSurface: MutableSurface;
   winnerSurfaceHash: string;
-  /** Proposer label for the promoted surface. Present when the winning
-   *  candidate came from a `ProposedCandidate` (a reflective proposer);
-   *  absent when the winner is the baseline or a bare-surface mutator. */
+  /** Proposer label for the kept surface; absent when the winner is the baseline. */
   winnerLabel?: string;
-  /** Proposer rationale for the promoted surface — the "because Z" that
-   *  motivated the winning change. Survives to `SelfImproveResult` and the
-   *  emitted provenance record. Absent when the winner is the baseline. */
+  /** Proposer rationale for the kept surface, as stored: redacted with the
+   *  share profile. Absent when the winner is the baseline. */
   winnerRationale?: string;
   baselineCampaign: CampaignResult<TArtifact, TScenario>;
   /** Run-wide spend, including agents, proposers, analysts, and judges. */
   cost: CostLedgerSummary;
-  /** Bounded proof envelope over the canonical search ledger. Present only
-   *  when `searchLedger` was supplied. `complete` is false when the search was
-   *  interrupted or a candidate left a designed cell unscored. */
-  searchHistory?: SearchHistoryReceipt;
-  /** The GEPA Pareto frontier across every scored surface (baseline + all
-   *  generations) by per-scenario objective vector — the non-dominated set.
-   *  Each generation's `propose()` received the frontier-so-far as
-   *  `ctx.paretoParents`; this is the final frontier. A surface here that is
-   *  NOT the winner is uniquely best on some scenario the winner loses on. */
+  /** Bounded proof envelope over the search ledger. */
+  searchHistory: SearchHistoryReceipt;
+  /** The non-dominated set of measured surfaces by per-scenario composite. */
   paretoFrontier: ParetoParent[];
 }
-/**
- * Improvement loop body: N generations of propose → campaign → rank, maintaining a Pareto frontier and one global incumbent across generations. The parent each generation mutates is the incumbent unless `selectParent` draws it from the frontier.
- */
+/** Improve a surface as a search on the kernel; see the module comment. */
 declare function runOptimization<TScenario extends Scenario, TArtifact>(opts: RunOptimizationOptions<TScenario, TArtifact>): Promise<RunOptimizationResult<TArtifact, TScenario>>;
 //#endregion
 //#region src/campaign/presets/run-improvement-loop.d.ts
@@ -2293,10 +2057,6 @@ interface CampaignComparisonUnits {
  *  Partial judge results remain on their cells but never enter this value.
  *  A campaign with no complete score has no numeric mean and fails loudly. */
 declare function campaignMeanComposite<TArtifact, TScenario extends Scenario>(campaign: CampaignResult<TArtifact, TScenario>): number;
-/** Compare fixed-length lexicographic rank keys where each element is higher-is-better.
- *  Returns a positive number when `a` ranks above `b`, negative when below, and
- *  zero when equal. */
-declare function compareRankKeys(a: readonly number[], b: readonly number[]): number;
 interface CampaignBreakdown {
   /** Mean score per judge dimension across all cells. */
   dimensions: Record<string, number>;
@@ -2334,12 +2094,6 @@ interface LoopProvenanceCandidate {
    *  `GenerationCandidate.attribution`. Opaque here; the producer's schema tag
    *  governs interpretation. */
   attribution?: Readonly<Record<string, unknown>>;
-  /** Exact complete incumbent this candidate mutated. */
-  parentSurfaceHash: string;
-  /** Search-split composite of the exact parent. */
-  parentComposite: number;
-  /** Search-split composite change relative to the exact parent. */
-  observedDeltaFromParent?: number;
   /** Whether the candidate completed every designed cell and could be selected. */
   eligibleForPromotion: boolean;
   /** Designed-denominator receipt retained even for incomplete candidates. */
@@ -2546,6 +2300,35 @@ interface EmitLoopProvenanceArgs<TArtifact, TScenario extends Scenario> extends
  */
 declare function emitLoopProvenance<TArtifact, TScenario extends Scenario>(args: EmitLoopProvenanceArgs<TArtifact, TScenario>): Promise<EmitLoopProvenanceResult>;
 //#endregion
+//#region src/campaign/allocation.d.ts
+/** One cell an allocator wants for a node. */
+interface SearchCellPlan {
+  taskId: string;
+  split: SearchSplit;
+  rep: number;
+  stage: SearchCellStage;
+}
+interface SearchAllocator {
+  /** Recorded as the search's `policy.allocation`. */
+  readonly name: string;
+  /** Repeats of each task. The claim runs its test cells at the same repeats. */
+  readonly reps: number;
+  /** Every cell the node needs now. The kernel allocates the ones missing. */
+  plan(state: SearchStateView, nodeId: string): SearchCellPlan[];
+  /** Cells a newly admitted node's screen allocates, so the kernel can price an
+   * expansion against the budget before the proposer runs. */
+  screenSize(state: SearchStateView): number;
+}
+/**
+ * Every node gets every train and selection task at every repeat: the root as
+ * `root` cells, every other node as `train` cells (the proposer's feedback) and
+ * `screen` cells (the policy's private evidence). This is the fixed plan the
+ * generation loop ran and GEPA runs.
+ */
+declare function uniform(options?: {
+  reps?: number;
+}): SearchAllocator;
+//#endregion
 //#region src/campaign/analyst-surface.d.ts
 interface TraceAnalystScenario extends Scenario {
   kind: 'trace-analyst';
@@ -3889,6 +3672,249 @@ declare function selectDiscriminative(signals: ScenarioSignal[], k: number, opts
   saturationCeiling?: number;
 }): string[];
 //#endregion
+//#region src/campaign/search-claim.d.ts
+/** The claim procedure every `SearchClaim` and claim plan names. */
+declare const SEARCH_CLAIM_RULE: SearchSourceRef;
+/**
+ * The claim reserve a search needs: the root and 3 finalists on every test
+ * task at `reps` repeats, each held at `cellUsd`. Declare at least this as
+ * `budget.reservedClaimUsd`; `runSearch` refuses to start a capped search
+ * with less.
+ */
+declare function searchClaimReserveUsd(input: {
+  testTasks: number;
+  reps: number;
+  cellUsd: number;
+}): number;
+/**
+ * The claim's design, fixed before any test cell runs, and stored as the
+ * `claim-plan` artifact of the ledger's `claim` operation.
+ */
+interface SearchClaimPlan {
+  kind: 'search-claim-plan';
+  rule: SearchSourceRef;
+  /** Why expansion stopped; the search closes with this reason. */
+  stopReason: SearchCloseReason;
+  /** Best first. Every one is decided `finalist` and named by the claim. */
+  finalists: Array<{
+    nodeId: string;
+    selectionMean: number;
+  }>;
+  power: SearchClaimPower;
+  /** `run`: the root and the finalists run every test task. Otherwise the
+   * claim closes with this decision and spends nothing on test cells. */
+  test: 'run' | 'hold' | 'test-cannot-resolve';
+  reason: string;
+}
+interface PlanSearchClaimInput {
+  stopReason: SearchCloseReason;
+  /** Repeats per test task. */
+  reps: number;
+  /** Whether the budget admits the test cells of the root and `finalists`. */
+  affordable(finalists: number): boolean;
+}
+/** Fix the claim's design from a search that stopped expanding. */
+declare function planSearchClaim(state: SearchStateView, input: PlanSearchClaimInput): SearchClaimPlan;
+/** A node decision the claim makes, ready for `recorder.decideNode`. */
+interface SearchClaimDecision {
+  nodeId: string;
+  decision: SearchNodeDecision;
+  basis: NodeEstimate | null;
+  rule: string;
+  reason: string;
+}
+/**
+ * Decide the claim from the test cells of the root and the finalists. Call it
+ * once every claim cell is settled or cancelled. It returns the claim and the
+ * terminal decisions of the root and every finalist.
+ */
+declare function decideSearchClaim(state: SearchStateView, plan: SearchClaimPlan): {
+  claim: SearchClaim;
+  decisions: SearchClaimDecision[];
+};
+//#endregion
+//#region src/campaign/search-kernel.d.ts
+/** The kernel every `runSearch` ledger names as its search implementation. */
+declare const SEARCH_KERNEL_SOURCE: SearchSourceRef;
+/** An execution lane: a pool of slots whose cells share a cost rule. */
+interface SearchLane {
+  name: string;
+  /** Cells the lane runs at once. */
+  capacity: number;
+  /** `hard`: the lane enforces `cellUsd` as each cell's maximum. `estimate`:
+   * it cannot, and the kernel holds an estimate, recording any overshoot. */
+  costCap: 'hard' | 'estimate';
+  /** The enforced per-cell maximum of a hard lane; the prior estimate of an
+   * estimate lane until it has settled enough cells to estimate its own. */
+  cellUsd: number;
+}
+/** One attempt at one cell, as the kernel hands it to an executor. */
+interface SearchCellWork<TArtifact> {
+  searchId: string;
+  cellId: string;
+  nodeId: string;
+  taskId: string;
+  unitId: string;
+  split: SearchSplit;
+  rep: number;
+  stage: SearchCellStage;
+  lane: string;
+  attempt: number;
+  /** `cellId:attempt`: the id an executor keys the attempt's run by. */
+  runId: string;
+  artifact: TArtifact;
+  signal: AbortSignal;
+}
+/** What an attempt produced: everything `cell-settled` records except the
+ * coordinates the kernel owns. An environment fault is an `errored` outcome,
+ * not a rejection; a rejection stops the search. */
+type SearchCellResult = Omit<SettleSearchCellInput, 'cellId' | 'attempt'>;
+/** The executor port: lanes, placement, running a cell, and adopting an
+ * attempt an earlier kernel process started. */
+interface SearchExecutor<TArtifact> {
+  lanes(): readonly SearchLane[];
+  /** The lane a planned cell runs on. */
+  place(cell: SearchCellPlan & {
+    nodeId: string;
+  }): string;
+  run(work: SearchCellWork<TArtifact>): Promise<SearchCellResult>;
+  /** The result of `work.runId` if the executor already has it, else null.
+   * Called before the first dispatch of a cell the ledger shows unsettled when
+   * the kernel starts, so a restart does not run an attempt twice. */
+  adopt(work: SearchCellWork<TArtifact>): Promise<SearchCellResult | null>;
+}
+/** How a search stores, compares and restores its artifacts. */
+interface SearchArtifactCodec<TArtifact> {
+  /** The artifact as a content-addressed node; stores its bytes. */
+  node(recorder: SearchRecorder, artifact: TArtifact): RegisterSearchNodeInput;
+  /** The parent-to-child diff, stored as a blob, or why there is none. */
+  diff(recorder: SearchRecorder, parent: TArtifact, child: TArtifact): SearchArtifactRef | SearchUnknown;
+  /** The artifact a node holds, read back from its stored bytes. */
+  load(recorder: SearchRecorder, node: SearchNode): TArtifact;
+}
+interface SearchProposalRequest<TArtifact> {
+  expansion: number;
+  operationId: string;
+  operator: Exclude<SearchEdgeOperator, 'seed' | 'derive'>;
+  /** The parents the policy chose, primary first. */
+  parents: ReadonlyArray<{
+    nodeId: string;
+    artifact: TArtifact;
+  }>;
+  /** The node the search keeps now. */
+  leader: string;
+  signal: AbortSignal;
+}
+/** One child a proposal returned. */
+interface SearchProposedChild<TArtifact> {
+  artifact: TArtifact;
+  label: string;
+  /** The proposer's reason; redacted with the share profile before it is stored. */
+  rationale: string;
+  /** Typed JSON the proposer attaches to the child, stored with the proposal
+   * and never interpreted by the kernel. */
+  attribution?: Readonly<Record<string, unknown>>;
+}
+interface SearchProposalResult<TArtifact> {
+  children: ReadonlyArray<SearchProposedChild<TArtifact>>;
+  /** Set when the proposer judges the search converged; expansion stops. */
+  stop?: string;
+  /** What generated the children; default the port's `execution`. */
+  execution?: SearchOperationRecordedEvent['execution'];
+  accounting: SearchAttemptAccounting;
+}
+/** The proposer port: derives children from the parents the policy chose. */
+interface SearchProposerPort<TArtifact> {
+  readonly name: string;
+  readonly kind: SearchProposerKind;
+  readonly source: SearchSourceRef;
+  readonly execution: SearchOperationRecordedEvent['execution'];
+  /** Prior hold for one proposal until 20 proposals have settled. Default 0. */
+  readonly reservationUsd?: number;
+  /** Children one proposal usually returns, to price an expansion's screens
+   * before it runs. Default 1. */
+  readonly childrenPerProposal?: number;
+  propose(request: SearchProposalRequest<TArtifact>): Promise<SearchProposalResult<TArtifact>>;
+}
+interface RunSearchOptions<TArtifact> {
+  /** An opened recorder; its header names this policy and allocator. */
+  recorder: SearchRecorder;
+  /** The starting artifact: the seeded root. */
+  root: TArtifact;
+  codec: SearchArtifactCodec<TArtifact>;
+  policy: SearchPolicy;
+  allocation: SearchAllocator;
+  proposer: SearchProposerPort<TArtifact>;
+  executor: SearchExecutor<TArtifact>;
+  /** Refuse a child before it runs: the reason, or null to admit it. A
+   * refused child is recorded, decided `invalid`, and never becomes a parent. */
+  admit?: (artifact: TArtifact) => string | null;
+  /** Stop expanding after this many proposals. */
+  maxExpansions?: number;
+  /** Attempts per cell for retryable environment errors. Default 3. */
+  maxAttempts?: number;
+  /** Aborting pauses the search: in-flight cells are aborted, what settled is
+   * recorded, the ledger stays open, and the call rejects. Run the kernel on
+   * the same ledger again to continue. */
+  signal?: AbortSignal;
+  /** Milliseconds since the epoch, for the deadline. Default `Date.now`. */
+  now?: () => number;
+}
+interface SearchRunResult {
+  /** The closed search. */
+  state: SearchStateView;
+  /** The node the search keeps: the claim's selection, or without a claim the
+   * policy leader; the root when nothing was selected. */
+  leader: string;
+  reason: SearchCloseReason;
+  /** The claim on the sealed test split; null for a search without one. */
+  claim: SearchClaim | null;
+}
+/** Run a search to its close, or continue one from its ledger. */
+declare function runSearch<TArtifact>(options: RunSearchOptions<TArtifact>): Promise<SearchRunResult>;
+/** The expansion index a kernel operation id encodes, or null. */
+declare function searchExpansionIndex(operationId: string): number | null;
+/** The stored output of one proposal: enough to register its children again. */
+interface SearchProposalBlob {
+  kind: 'search-proposal';
+  operator: SearchProposalRequest<unknown>['operator'];
+  parents: string[];
+  selection: {
+    rule: string;
+    evidence: Record<string, number>;
+  };
+  children: Array<{
+    node: RegisterSearchNodeInput;
+    diffs: Array<SearchArtifactRef | SearchUnknown>;
+    label: string;
+    rationale: string;
+    attribution: Readonly<Record<string, unknown>> | null;
+    invalid: string | null;
+  }>;
+}
+/**
+ * A policy's read of a search: `screened` lists the admitted nodes whose screen
+ * finished, in registration order; `screening` counts the admitted nodes still
+ * being screened. Nodes are ranked on the selection split, or on train when
+ * the search declares no selection split. The view reads no test cell.
+ */
+declare function searchPolicyView(state: SearchStateView, input: {
+  screened: readonly string[];
+  screening: number;
+  expansions: number;
+}): SearchPolicyView;
+/**
+ * The divergence rule: a node whose train mean rose over its parent's on the
+ * train units they share while its selection interval against the parent (6
+ * or more units, not indeterminate) lies wholly on the worse side. Train is
+ * what the proposer reads; a gain there that selection contradicts is the
+ * signature of fitting the feedback instead of the task.
+ */
+declare function searchDivergence(state: SearchStateView, nodeId: string): {
+  basis: NodeEstimate;
+  reason: string;
+} | null;
+//#endregion
 //#region src/campaign/single-run-lock.d.ts
 /**
  * Single-run lock for evaluations that share one mutable environment.
@@ -4074,5 +4100,5 @@ declare function verifyCodeSurface(surface: CodeSurface, worktreeDir?: string):
  *  identity against the checkout at `worktreeRef`. */
 declare function resolveWorktreePath(surface: CodeSurface, worktreeDir?: string): string;
 //#endregion
-export { scoreboardSummary as $, searchNodeId as $a, RunImprovementLoopOptions as $i, buildTraceAnalystSurfaceDispatch as $n, GepaOptimizationRecipe as $r, EvalFixtureRunPlan as $t, tangleTracesRoot as A, searchHistoryCoverageRow as Aa, GepaCandidatePopulationSummary as Ai, CrossSurfaceCompositionStep as An, fsCampaignStorage as Ao, DEFAULT_RED_TEAM_CORPUS as Ar, sequentialOptimizationMethod as At, finalizeProfileMatrix as B, replaySearchLedgerText as Ba, ReferenceEquivalenceJudgeInput as Bi, CrossSurfaceNaiveStackSelection as Bn, CanaryKind as Br, classifyUngroundedLiterals as Bt, SingleRunLockOptions as C, SearchHistoryCoverageRow as Ca, compareOptimizationMethods as Ci, CrossSurfaceCandidate as Cn, CacheRead as Co, compareRankKeys as Cr, RequirementCheck as Ct, scoreDiscrimination as D, assertCompleteSearchHistory as Da, costFromLedgerSummary as Di, CrossSurfaceCandidateSummary as Dn, cellCachePath as Do, DefaultProductionGateOptions as Dr, createLlmCorrectnessChecker as Dt, ScenarioSignal as E, SearchHistoryRequiredError as Ea, combineComparisonCosts as Ei, CrossSurfaceCandidateOutcome as En, buildCellSchedule as Eo, DefaultProductionGateCheck as Er, completionVerdict as Et, ProfileMatrixPlan as F, SearchLedger as Fa, ExternalOptimizerObservationSummary as Fi, CrossSurfaceInteractionAwareSelection as Fn, assertCampaignSplitIdentity as Fo, redTeamDataset as Fr, RolloutArgumentDiff as Ft, ScoreboardRenderOptions as G, SearchNode as Ga, runReferenceEquivalenceJudge as Gi, CrossSurfaceRankedSingle as Gn, SkillOptOptimizationMethodConfig as Gr, importExternalEvaluations as Gt, PlaybackContext as H, SearchCell as Ha, ReferenceEquivalenceJudgeResult as Hi, CrossSurfacePairEvidence as Hn, CanaryReport as Hr, GepaEvaluationImport as Ht, ProfileMatrixRow as I, SearchLedgerAppendResult as Ia, ExternalOptimizerSubmittedCandidate as Ii, CrossSurfaceInteractionEffect as In, campaignScenarioIdentity as Io, redTeamReport as Ir, RolloutArgumentDiffOptions as It, UserStory as J, SearchSpend as Ja, llmJudge as Ji, CrossSurfaceSelections as Jn, skillOptOptimizationMethod as Jr, NeutralizationGateOptions as Jt, ScoreboardRow as K, SearchOperation as Ka, LlmJudgeDimension as Ki, CrossSurfaceRelativeCost as Kn, SkillOptRunnerCommand as Kr, importGepaPopulation as Kt, ProfileMatrixSegmentResult as L, SearchLedgerTrustedHeadMode as La, readExternalOptimizerObservationArtifact as Li, CrossSurfaceInteractionPath as Ln, campaignSplitDigest as Lo, scoreRedTeamOutput as Lr, RolloutCall as Lt, FinalizeProfileMatrixOptions as M, verifySearchHistoryReceipt as Ma, readGepaCandidatePopulationArtifact as Mi, CrossSurfaceEligibility as Mn, FinalEvidencePolicy as Mo, RedTeamCategory as Mr, FsLabeledScenarioStore as Mt, FinalizedProfileMatrixResult as N, FileSearchLedger as Na, ExternalOptimizerExecutionSummary as Ni, CrossSurfaceEvidenceBreakdown as Nn, FinalEvidenceUse as No, RedTeamFinding as Nr, FsLabeledScenarioStoreOptions as Nt, selectDiscriminative as O, assertSearchHistoryMatchesState as Oa, GepaCandidatePopulationArtifact as Oi, CrossSurfaceComponent as On, CampaignStorage as Oo, DefaultProductionRewardHackingOptions as Or, verifyCompletion as Ot, ProfileMatrixCoverage as P, OpenSearchLedgerOptions as Pa, ExternalOptimizerObservationArtifact as Pi, CrossSurfaceIneligibilityReason as Pn, assertCampaignDesign as Po, RedTeamReport as Pr, LabeledScenarioStoreError as Pt, scoreUserStory as Q, searchCellId as Qa, transientDispatchFailure as Qi, TraceAnalystScenario as Qn, GepaOptimizationMethodConfig as Qr, EvalFixtureLoadOptions as Qt, RunProfileMatrixSegmentOptions as R, openSearchLedger as Ra, REFERENCE_EQUIVALENCE_INPUT_LIMITS as Ri, CrossSurfaceInteractionReport as Rn, campaignSplitDigestFromIdentities as Ro, CanaryAlert as Rr, ScoredRollout as Rt, SingleRunLock as S, SearchHistoryCoverage as Sa, OptimizationTokenUsage as Si, CrossSurfaceBootstrapPolicy as Sn, CacheIssueReason as So, campaignMeanComposite as Sr, ProducedState as St, DiscriminationScore as T, SearchHistoryReceipt as Ta, ComparisonCost as Ti, CrossSurfaceCandidateEvidence as Tn, CellScheduleSlot as To, heldOutGate as Tr, TaskGold as Tt, PlaybackDriver as U, SearchCompletion as Ua, ReferenceEquivalenceScenario as Ui, CrossSurfacePairIncompatibilityReason as Un, runCanaries as Ur, GepaPopulationImport as Ut, runProfileMatrixSegment as V, validateSearchLedgerEvent as Va, ReferenceEquivalenceJudgeOptions as Vi, CrossSurfacePairCompatibility as Vn, CanaryOptions as Vr, rolloutArgumentDiff as Vt, PlaybackStep as W, SearchDecisionRecord as Wa, createReferenceEquivalenceJudge as Wi, CrossSurfacePairwiseEntry as Wn, composeGate as Wr, externalSurface as Wt, makePlaybackDispatch as X, SearchStateView as Xa, isTransientTransportFailure as Xi, BuildTraceAnalystSurfaceDispatchOptions as Xn, GepaEngineOptions as Xr, EvalFixture as Xt, UserStoryVerdict as Y, SearchState as Ya, TransientFailureOptions as Yi, CrossSurfaceTaskRow as Yn, GepaAdaptiveEngineRun as Yr, neutralizationGate as Yt, renderScoreboardMarkdown as Z, SearchUnitScore as Za, quotaExhaustedUntil as Zi, TraceAnalystArtifact as Zn, GepaEngineRun as Zr, EvalFixtureFile as Zt, componentSurfaceIdentityMaterial as _, surfaceDiff as _a, OptimizationMethodProvenance as _i, AnalyzeCrossSurfaceInteractionsInput as _n, runCampaign as _o, provenanceSpansPath as _r, CompletionRequirement as _t, WorktreeAdapterError as a, runOptimization as aa, ExternalTextOptimizationMethodConfig as ai, loadEvalFixture as an, CrowdedFrontierParentOptions as ao, LoopProvenanceBackend as ar, RunProfileMatrixResult as at, surfaceDispatchRef as b, SearchHistoryAdmissionOptions as ba, OptimizationMethodScore as bi, CrossSurfaceAttemptCompleteness as bn, PlanCampaignRunOptions as bo, CampaignComparisonUnits as br, LlmCorrectnessCheckerOpts as bt, verifyCodeSurface as c, RegisterSearchNodeInput as ca, ExternalOptimizationExample as ci, EstimateNodeCellsInput as cn, crowdedFrontierParent as co, LoopProvenanceOptimizationMethod as cr, BackendIntegrityError as ct, PhoenixEvaluationResultLike as d, SearchRecorder as da, CompareOptimizationMethodsOptions as di, SearchPosterior as dn, openAutoPr as do, campaignMeasurementDigest as dr, summarizeBackendIntegrity as dt, RunImprovementLoopResult as ea, GepaRunnerCommand as ei, EvalFixtureScenario as en, searchTaskSetDigest as eo, traceAnalystQualityJudge as er, userStoryScoreboard as et, PhoenixEvaluatorLike as f, SearchRecorderOptions as fa, OptimizationMethod as fi, estimateNode as fn, RunEvalOptions as fo, canonicalDigest as fr, ArtifactEventLike as ft, codeSurfaceIdentityMaterial as g, searchEdgeId as ga, OptimizationMethodPairwise as gi, analyzeCrossSurfaceInteractions as gn, RunCampaignOptions as go, provenanceRecordPath as gr, extractProducedState as gt, assertCodeSurfaceIdentity as h, developmentClaim as ha, OptimizationMethodInput as hi, searchPosterior as hn, CampaignCellRetryPolicy as ho, loopProvenanceSpans as hr, ToolCallEventLike as ht, WorktreeAdapter as i, RunOptimizationResult as ia, externalTextOptimizationMethod as ii, discoverEvalFixtures as in, SearchLedgerIntegrityError as io, LoopProvenanceArgsFromResult as ir, RunProfileMatrixOptions as it, CreateProfileMatrixPlanOptions as j, verifySearchHistoryArtifact as ja, GepaCandidateSelectionScore as ji, CrossSurfaceDistribution as jn, inMemoryCampaignStorage as jo, RedTeamCase as jr, neutralizeText as jt, resolveRunDir as k, createSearchHistoryReceipt as ka, GepaCandidatePopulationCandidate as ki, CrossSurfaceComponentEvidence as kn, createRunCostLedger as ko, defaultProductionGate as kr, scopedOptimizationMethod as kt, AutoevalsScoreLike as l, SearchLedgerBinding as la, ExternalTextEvaluationResponse as li, NodePosterior as ln, OpenAutoPrOptions as lo, LoopProvenanceRecord as lr, BackendIntegrityReport as lt, phoenixEvaluatorJudge as m, SettleSearchCellInput as ma, OptimizationMethodComposition as mi, searchCellSetDigest as mn, CampaignCellFailureReceipt as mo, loopProvenanceArgsFromResult as mr, RuntimeEventLike as mt, GitWorktreeAdapterOptions as n, PremeasuredOptimizationBaseline as na, OpenAICompatibleOptimizerModel as ni, LoadEvalFixtureScenariosOptions as nn, SearchLedgerConflictError as no, EmitLoopProvenanceArgs as nr, ProfileMatrixError as nt, gitWorktreeAdapter as o, AllocateSearchCellInput as oa, ExternalTextOptimizerContext as oi, loadEvalFixtureScenarios as on, ParentSelectionContext as oo, LoopProvenanceCandidate as or, ScenarioRollup as ot, autoevalsScorerJudge as p, SearchRunIdentity as pa, OptimizationMethodComparison as pi, estimateNodeFromCells as pn, runEval as po, emitLoopProvenance as pr, ProposalEventLike as pt, ScoreboardSummary as q, SearchScoredCell as qa, LlmJudgeOptions as qi, CrossSurfaceSelectionPolicy as qn, SkillOptTrainerConfig as qr, recordGepaSearch as qt, Worktree as r, RunOptimizationOptions as ra, OptimizerModelBudget as ri, PlanEvalFixtureRunOptions as rn, SearchLedgerError as ro, EmitLoopProvenanceResult as rr, ProfileSummary as rt, resolveWorktreePath as s, RecordSearchEdgeInput as sa, ExternalTextOptimizerResult as si, planEvalFixtureRun as sn, ParentSelector as so, LoopProvenanceEvidence as sr, runProfileMatrix as st, CodeSurfaceVerification as t, runImprovementLoop as ta, gepaOptimizationMethod as ti, EvalFixtureValidationMode as tn, searchUnitScores as to, BuildLoopProvenanceArgs as tr, ProfileDispatchFn as tt, AutoevalsScorerLike as u, SearchOpening as ua, decodeExternalTextCandidate as ui, SEARCH_ESTIMATOR as un, OpenAutoPrResult as uo, buildLoopProvenanceRecord as ur, assertRealBackend as ut, renderSurfaceDiff as v, surfaceNode as va, OptimizationMethodResult as vi, CrossSurfaceAdditionDecision as vn, CampaignRunPlan as vo, verifyLoopProvenanceRecord as vr, CompletionVerdict as vt, acquireSingleRunLock as w, SearchHistoryPolicy as wa, optimizationTokenUsageFromSummary as wi, CrossSurfaceCandidateComparison as wn, readCachedCell as wo, HeldOutGateOptions as wr, SatisfiedBy as wt, surfaceHash as x, SearchHistoryAuditSummary as xa, OptimizationPackageSource as xi, CrossSurfaceBestSingleSelection as xn, planCampaignRun as xo, campaignBreakdown as xr, ProducedProposal as xt, surfaceContentHash as y, CreateSearchHistoryReceiptInput as ya, OptimizationMethodRunOptions as yi, CrossSurfaceAdditionRejectionReason as yn, CampaignRunPlanCell as yo, CampaignBreakdown as yr, CorrectnessChecker as yt, createProfileMatrixPlan as z, parseSearchLedgerLine as za, REFERENCE_EQUIVALENCE_JUDGE_VERSION as zi, CrossSurfaceInteractionTask as zn, CanaryEvaluation as zr, UngroundedLiteralReport as zt };
-//# sourceMappingURL=index-CzfnASj_.d.ts.map
+export { resolveRunDir as $, SearchHistoryCoverage as $a, costFromLedgerSummary as $i, CrossSurfaceComponentEvidence as $n, DefaultProductionGateOptions as $r, scopedOptimizationMethod as $t, SearchExecutor as A, RunOptimizationResult as Aa, externalTextOptimizationMethod as Ai, loadEvalFixtureScenarios as An, runCampaign as Ao, EmitLoopProvenanceResult as Ar, ScenarioRollup as At, searchExpansionIndex as B, SearchLedgerBinding as Ba, OptimizationMethodComposition as Bi, analyzeCrossSurfaceInteractions as Bn, cellCachePath as Bo, emitLoopProvenance as Br, extractProducedState as Bt, SingleRunLockOptions as C, quotaExhaustedUntil as Ca, GepaEngineRun as Ci, EvalFixtureRunPlan as Cn, OpenAutoPrResult as Co, buildTraceAnalystSurfaceDispatch as Cr, scoreboardSummary as Ct, SearchArtifactCodec as D, runImprovementLoop as Da, gepaOptimizationMethod as Di, PlanEvalFixtureRunOptions as Dn, CampaignCellFailureReceipt as Do, uniform as Dr, ProfileSummary as Dt, SEARCH_KERNEL_SOURCE as E, RunImprovementLoopResult as Ea, GepaRunnerCommand as Ei, LoadEvalFixtureScenariosOptions as En, runEval as Eo, SearchCellPlan as Er, ProfileMatrixError as Et, SearchProposedChild as F, crowdedFrontierParent as Fa, ExternalTextEvaluationResponse as Fi, SearchPosterior as Fn, CacheIssueReason as Fo, LoopProvenanceOptimizationMethod as Fr, summarizeBackendIntegrity as Ft, SearchClaimPlan as G, SettleSearchCellInput as Ga, OptimizationMethodRunOptions as Gi, CrossSurfaceBestSingleSelection as Gn, FinalEvidencePolicy as Go, verifyLoopProvenanceRecord as Gr, ProducedProposal as Gt, PlanSearchClaimInput as H, SearchRecorder as Ha, OptimizationMethodPairwise as Hi, CrossSurfaceAdditionDecision as Hn, createRunCostLedger as Ho, loopProvenanceSpans as Hr, CompletionVerdict as Ht, SearchProposerPort as I, incumbent as Ia, decodeExternalTextCandidate as Ii, estimateNode as In, CacheRead as Io, LoopProvenanceRecord as Ir, ArtifactEventLike as It, searchClaimReserveUsd as J, surfaceDiff as Ja, OptimizationTokenUsage as Ji, CrossSurfaceCandidateComparison as Jn, assertCampaignSplitIdentity as Jo, campaignBreakdown as Jr, SatisfiedBy as Jt, decideSearchClaim as K, developmentClaim as Ka, OptimizationMethodScore as Ki, CrossSurfaceBootstrapPolicy as Kn, FinalEvidenceUse as Ko, CampaignBreakdown as Kr, ProducedState as Kt, SearchRunResult as L, AllocateSearchCellInput as La, CompareOptimizationMethodsOptions as Li, estimateNodeFromCells as Ln, readCachedCell as Lo, buildLoopProvenanceRecord as Lr, ProposalEventLike as Lt, SearchProposalBlob as M, SearchExpansion as Ma, ExternalTextOptimizerContext as Mi, EstimateNodeCellsInput as Mn, CampaignRunPlanCell as Mo, LoopProvenanceBackend as Mr, BackendIntegrityError as Mt, SearchProposalRequest as N, SearchPolicy as Na, ExternalTextOptimizerResult as Ni, NodePosterior as Nn, PlanCampaignRunOptions as No, LoopProvenanceCandidate as Nr, BackendIntegrityReport as Nt, SearchCellResult as O, PremeasuredOptimizationBaseline as Oa, OpenAICompatibleOptimizerModel as Oi, discoverEvalFixtures as On, CampaignCellRetryPolicy as Oo, BuildLoopProvenanceArgs as Or, RunProfileMatrixOptions as Ot, SearchProposalResult as P, SearchPolicyView as Pa, ExternalOptimizationExample as Pi, SEARCH_ESTIMATOR as Pn, planCampaignRun as Po, LoopProvenanceEvidence as Pr, assertRealBackend as Pt, selectDiscriminative as Q, SearchHistoryAuditSummary as Qa, combineComparisonCosts as Qi, CrossSurfaceComponent as Qn, DefaultProductionGateCheck as Qr, verifyCompletion as Qt, runSearch as R, RecordSearchEdgeInput as Ra, OptimizationMethod as Ri, searchCellSetDigest as Rn, CellScheduleSlot as Ro, campaignMeasurementDigest as Rr, RuntimeEventLike as Rt, SingleRunLock as S, isTransientTransportFailure as Sa, GepaEngineOptions as Si, EvalFixtureLoadOptions as Sn, OpenAutoPrOptions as So, TraceAnalystScenario as Sr, scoreUserStory as St, RunSearchOptions as T, RunImprovementLoopOptions as Ta, GepaOptimizationRecipe as Ti, EvalFixtureValidationMode as Tn, RunEvalOptions as To, SearchAllocator as Tr, ProfileDispatchFn as Tt, SEARCH_CLAIM_RULE as U, SearchRecorderOptions as Ua, OptimizationMethodProvenance as Ui, CrossSurfaceAdditionRejectionReason as Un, fsCampaignStorage as Uo, provenanceRecordPath as Ur, CorrectnessChecker as Ut, searchPolicyView as V, SearchOpening as Va, OptimizationMethodInput as Vi, AnalyzeCrossSurfaceInteractionsInput as Vn, CampaignStorage as Vo, loopProvenanceArgsFromResult as Vr, CompletionRequirement as Vt, SearchClaimDecision as W, SearchRunIdentity as Wa, OptimizationMethodResult as Wi, CrossSurfaceAttemptCompleteness as Wn, inMemoryCampaignStorage as Wo, provenanceSpansPath as Wr, LlmCorrectnessCheckerOpts as Wt, ScenarioSignal as X, CreateSearchHistoryReceiptInput as Xa, optimizationTokenUsageFromSummary as Xi, CrossSurfaceCandidateOutcome as Xn, campaignSplitDigest as Xo, HeldOutGateOptions as Xr, completionVerdict as Xt, DiscriminationScore as Y, surfaceNode as Ya, compareOptimizationMethods as Yi, CrossSurfaceCandidateEvidence as Yn, campaignScenarioIdentity as Yo, campaignMeanComposite as Yr, TaskGold as Yt, scoreDiscrimination as Z, SearchHistoryAdmissionOptions as Za, ComparisonCost as Zi, CrossSurfaceCandidateSummary as Zn, campaignSplitDigestFromIdentities as Zo, heldOutGate as Zr, createLlmCorrectnessChecker as Zt, componentSurfaceIdentityMaterial as _, runReferenceEquivalenceJudge as _a, SkillOptOptimizationMethodConfig as _i, recordGepaSearch as _n, replaySearchLedgerText as _o, CrossSurfaceSelectionPolicy as _r, ScoreboardSummary as _t, WorktreeAdapterError as a, ExternalOptimizerExecutionSummary as aa, RedTeamFinding as ai, RolloutArgumentDiff as an, assertSearchHistoryMatchesState as ao, CrossSurfaceInteractionAwareSelection as ar, ProfileMatrixPlan as at, surfaceDispatchRef as b, llmJudge as ba, skillOptOptimizationMethod as bi, EvalFixture as bn, SearchLedgerError as bo, BuildTraceAnalystSurfaceDispatchOptions as br, makePlaybackDispatch as bt, verifyCodeSurface as c, ExternalOptimizerSubmittedCandidate as ca, redTeamReport as ci, ScoredRollout as cn, verifySearchHistoryArtifact as co, CrossSurfaceInteractionReport as cr, RunProfileMatrixSegmentOptions as ct, PhoenixEvaluationResultLike as d, REFERENCE_EQUIVALENCE_JUDGE_VERSION as da, CanaryEvaluation as di, rolloutArgumentDiff as dn, OpenSearchLedgerOptions as do, CrossSurfacePairCompatibility as dr, runProfileMatrixSegment as dt, GepaCandidatePopulationArtifact as ea, DefaultProductionRewardHackingOptions as ei, sequentialOptimizationMethod as en, SearchHistoryCoverageRow as eo, CrossSurfaceCompositionStep as er, tangleTracesRoot as et, PhoenixEvaluatorLike as f, ReferenceEquivalenceJudgeInput as fa, CanaryKind as fi, GepaEvaluationImport as fn, SearchLedger as fo, CrossSurfacePairEvidence as fr, PlaybackContext as ft, codeSurfaceIdentityMaterial as g, createReferenceEquivalenceJudge as ga, composeGate as gi, importGepaPopulation as gn, parseSearchLedgerLine as go, CrossSurfaceRelativeCost as gr, ScoreboardRow as gt, assertCodeSurfaceIdentity as h, ReferenceEquivalenceScenario as ha, runCanaries as hi, importExternalEvaluations as hn, openSearchLedger as ho, CrossSurfaceRankedSingle as hr, ScoreboardRenderOptions as ht, WorktreeAdapter as i, readGepaCandidatePopulationArtifact as ia, RedTeamCategory as ii, LabeledScenarioStoreError as in, assertCompleteSearchHistory as io, CrossSurfaceIneligibilityReason as ir, ProfileMatrixCoverage as it, SearchLane as j, runOptimization as ja, ExternalTextOptimizationMethodConfig as ji, planEvalFixtureRun as jn, CampaignRunPlan as jo, LoopProvenanceArgsFromResult as jr, runProfileMatrix as jt, SearchCellWork as k, RunOptimizationOptions as ka, OptimizerModelBudget as ki, loadEvalFixture as kn, RunCampaignOptions as ko, EmitLoopProvenanceArgs as kr, RunProfileMatrixResult as kt, AutoevalsScoreLike as l, readExternalOptimizerObservationArtifact as la, scoreRedTeamOutput as li, UngroundedLiteralReport as ln, verifySearchHistoryReceipt as lo, CrossSurfaceInteractionTask as lr, createProfileMatrixPlan as lt, phoenixEvaluatorJudge as m, ReferenceEquivalenceJudgeResult as ma, CanaryReport as mi, externalSurface as mn, SearchLedgerTrustedHeadMode as mo, CrossSurfacePairwiseEntry as mr, PlaybackStep as mt, GitWorktreeAdapterOptions as n, GepaCandidatePopulationSummary as na, DEFAULT_RED_TEAM_CORPUS as ni, FsLabeledScenarioStore as nn, SearchHistoryReceipt as no, CrossSurfaceEligibility as nr, FinalizeProfileMatrixOptions as nt, gitWorktreeAdapter as o, ExternalOptimizerObservationArtifact as oa, RedTeamReport as oi, RolloutArgumentDiffOptions as on, createSearchHistoryReceipt as oo, CrossSurfaceInteractionEffect as or, ProfileMatrixRow as ot, autoevalsScorerJudge as p, ReferenceEquivalenceJudgeOptions as pa, CanaryOptions as pi, GepaPopulationImport as pn, SearchLedgerAppendResult as po, CrossSurfacePairIncompatibilityReason as pr, PlaybackDriver as pt, planSearchClaim as q, searchEdgeId as qa, OptimizationPackageSource as qi, CrossSurfaceCandidate as qn, assertCampaignDesign as qo, CampaignComparisonUnits as qr, RequirementCheck as qt, Worktree as r, GepaCandidateSelectionScore as ra, RedTeamCase as ri, FsLabeledScenarioStoreOptions as rn, SearchHistoryRequiredError as ro, CrossSurfaceEvidenceBreakdown as rr, FinalizedProfileMatrixResult as rt, resolveWorktreePath as s, ExternalOptimizerObservationSummary as sa, redTeamDataset as si, RolloutCall as sn, searchHistoryCoverageRow as so, CrossSurfaceInteractionPath as sr, ProfileMatrixSegmentResult as st, CodeSurfaceVerification as t, GepaCandidatePopulationCandidate as ta, defaultProductionGate as ti, neutralizeText as tn, SearchHistoryPolicy as to, CrossSurfaceDistribution as tr, CreateProfileMatrixPlanOptions as tt, AutoevalsScorerLike as u, REFERENCE_EQUIVALENCE_INPUT_LIMITS as ua, CanaryAlert as ui, classifyUngroundedLiterals as un, FileSearchLedger as uo, CrossSurfaceNaiveStackSelection as ur, finalizeProfileMatrix as ut, renderSurfaceDiff as v, LlmJudgeDimension as va, SkillOptRunnerCommand as vi, NeutralizationGateOptions as vn, validateSearchLedgerEvent as vo, CrossSurfaceSelections as vr, UserStory as vt, acquireSingleRunLock as w, transientDispatchFailure as wa, GepaOptimizationMethodConfig as wi, EvalFixtureScenario as wn, openAutoPr as wo, traceAnalystQualityJudge as wr, userStoryScoreboard as wt, surfaceHash as x, TransientFailureOptions as xa, GepaAdaptiveEngineRun as xi, EvalFixtureFile as xn, SearchLedgerIntegrityError as xo, TraceAnalystArtifact as xr, renderScoreboardMarkdown as xt, surfaceContentHash as y, LlmJudgeOptions as ya, SkillOptTrainerConfig as yi, neutralizationGate as yn, SearchLedgerConflictError as yo, CrossSurfaceTaskRow as yr, UserStoryVerdict as yt, searchDivergence as z, RegisterSearchNodeInput as za, OptimizationMethodComparison as zi, searchPosterior as zn, buildCellSchedule as zo, canonicalDigest as zr, ToolCallEventLike as zt };
+//# sourceMappingURL=index-DMPLG226.d.ts.map