@tangle-network/agent-eval 0.189.0 → 0.190.0

package/dist/{index-CnJOPR_E.d.ts → index-Ci0-EYzc.d.ts}

@@ -1,14 +1,16 @@
 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 } from "./run-record-DF-fuu31.js";
+import { a as RunRecord, c as RunSplitTag, s as RunSearchCoordinates } from "./run-record-DF-fuu31.js";
 import { D as TraceAnalysisStore, _ as ProposalFinding, f as AnalystUsageReceipt, i as AnalystFinding, l as AnalystRunResult } from "./types-Bay1dh2o.js";
 import { M as LlmCallMetadata, ft as ServedModelPolicy, rt as RawProviderSink, x as ChatClient } from "./types-C0bWoSKC.js";
-import { Et as FinalEvidenceLedger, Mt as EvaluationClaim, Nt as EvaluationUnitSummary, P as PairedArmsComparison, ft as EvidenceReceipt, it as CampaignEvidenceContext, kt as FinalEvidenceRecord } from "./statistical-heldout-plAHG82H.js";
+import { Et as FinalEvidenceLedger, P as PairedArmsComparison, ft as EvidenceReceipt, it as CampaignEvidenceContext, kt as FinalEvidenceRecord } from "./statistical-heldout-CLpjYffJ.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-BvmWNjjs.js";
+import { n as EvaluationUnitSummary, t as EvaluationClaim } from "./claim-BGOUqoMq.js";
 import { r as LedgerHash } from "./canonical-CFpojCN5.js";
-import { m as LedgerTrustedHeadRemoval, p as LedgerTrustedHead } from "./index-BqDJ6fUK.js";
-import { D as SearchSourceRef, _ as SearchLedgerHash, g as SearchLedgerEvent, m as SearchLedgerAudit, n as SearchArtifactRef, p as SearchLedgerAppendResult, r as SearchAttemptAccounting, v as SearchLedgerReplay, x as SearchOperationRecordedEvent, y as SearchModelIdentity } from "./search-ledger-types-D7KDVg-o.js";
+import { m as LedgerTrustedHeadRemoval, p as LedgerTrustedHead, u as LedgerProjector } from "./index-BqDJ6fUK.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 { 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-DNV_U6QR.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";
@@ -433,9 +435,250 @@ 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 is not semantic are
- * sorted so retries from different processes produce byte-identical events. */
+/** Validate and return a canonical copy. Arrays whose order carries no meaning
+ * are sorted, so retries from different processes produce identical bytes. */
 declare function validateSearchLedgerEvent(input: unknown): SearchLedgerEvent;
 /**
  * How this ledger uses its trusted head — the `(sequence, entryHash)` pin kept
@@ -446,51 +689,53 @@ declare function validateSearchLedgerEvent(input: unknown): SearchLedgerEvent;
  * - `pin` (default): every append records the new head, and a pin that is
  *   present is verified on every read.
  * - `require`: additionally refuses to read a non-empty ledger whose pin is
- *   gone, so deleting the sibling file cannot downgrade the guarantee. Only for
- *   ledgers written under `pin` from their first entry.
+ *   gone, so deleting the sibling file cannot downgrade the guarantee.
  * - `off`: chain verification only. Truncation to a valid shorter prefix is
  *   undetectable.
  */
 type SearchLedgerTrustedHeadMode = 'pin' | 'require' | 'off';
 interface OpenSearchLedgerOptions {
   path: string;
-  campaignId: string;
+  searchId: string;
   trustedHead?: SearchLedgerTrustedHeadMode;
 }
+interface SearchLedgerAppendResult {
+  entry: SearchLedgerEntry;
+  /** False when the exact event was already durably present. */
+  appended: boolean;
+  state: SearchStateView;
+}
 interface SearchLedger {
   readonly path: string;
-  readonly campaignId: string;
+  readonly searchId: string;
   /** Sibling file holding this ledger's trusted head. */
   readonly trustedHeadPath: string;
   append(event: SearchLedgerEvent): Promise<SearchLedgerAppendResult>;
-  replay(): Promise<SearchLedgerReplay>;
+  /** The verified state at the file's current head. */
+  state(): Promise<SearchStateView>;
   /** The pinned head, or null when this ledger has never been pinned. */
   trustedHead(): Promise<LedgerTrustedHead | null>;
-  /** Pin the current verified head: how a ledger written under `off`, or one
-   * whose pin file was removed, acquires a pin without rewriting a byte. */
+  /** Pin the current verified head without rewriting a byte. */
   pinTrustedHead(): Promise<LedgerTrustedHead>;
-  /** Discard this ledger's pin, reporting what was discarded. Deleting or
-   * rebuilding the ledger file leaves a pin naming history the file no longer
-   * carries, and every later read is refused because that is exactly the
-   * deletion the pin exists to catch; clearing is the supported way to abandon
-   * that history on purpose. It gives up the deletion guarantee for every entry
-   * the pin covered. */
+  /** Discard this ledger's pin, reporting what was discarded. It gives up the
+   * deletion guarantee for every entry the pin covered. */
   clearTrustedHead(): Promise<LedgerTrustedHeadRemoval>;
 }
 /** Open a durable filesystem search ledger. Construction performs no I/O; the
- * first `append` or `replay` validates the complete existing file. */
+ * first `append` or `state` verifies the whole existing file. */
 declare function openSearchLedger(options: OpenSearchLedgerOptions): SearchLedger;
-/** Replay immutable search-ledger JSONL through the same codec as FileSearchLedger. */
-declare function replaySearchLedgerText(text: string, campaignId: string, source: string): SearchLedgerReplay;
-/** Append-only file-backed search ledger with idempotent writes and replay. */
+/** Verify and project immutable search-ledger JSONL through the same codec as
+ * `FileSearchLedger`. */
+declare function replaySearchLedgerText(text: string, searchId: string, source: string): SearchStateView;
+/** Append-only file-backed search ledger with idempotent writes. */
 declare class FileSearchLedger implements SearchLedger {
   readonly path: string;
-  readonly campaignId: string;
+  readonly searchId: string;
   readonly trustedHeadPath: string;
   private readonly trustedHeadMode;
   private readonly journal;
-  constructor(path: string, campaignId: string, trustedHead?: SearchLedgerTrustedHeadMode);
-  replay(): Promise<SearchLedgerReplay>;
+  constructor(path: string, searchId: string, trustedHead?: SearchLedgerTrustedHeadMode);
+  state(): Promise<SearchStateView>;
   append(input: SearchLedgerEvent): Promise<SearchLedgerAppendResult>;
   trustedHead(): Promise<LedgerTrustedHead | null>;
   pinTrustedHead(): Promise<LedgerTrustedHead>;
@@ -498,36 +743,34 @@ declare class FileSearchLedger implements SearchLedger {
 }
 //#endregion
 //#region src/campaign/search-history-receipt.d.ts
-declare const SEARCH_HISTORY_RECEIPT_SCHEMA_VERSION: '1.0.0';
+declare const SEARCH_HISTORY_RECEIPT_SCHEMA_VERSION: '2026-09';
 declare const SEARCH_HISTORY_RECEIPT_DIGEST_ALGORITHM: 'rfc8785-sha256';
-/** Bounded projection of the canonical replay audit. Exact ids stay in SearchLedger. */
+/** Bounded summary of a search's audit. Exact ids stay in the ledger. */
 interface SearchHistoryAuditSummary {
-  readonly campaignId: string;
+  readonly searchId: string;
   readonly headHash: SearchLedgerHash | null;
-  readonly status: SearchLedgerAudit['status'];
-  readonly selectedCandidateId: string | null;
+  readonly status: SearchAudit['status'];
+  readonly closeReason: SearchAudit['closeReason'];
+  readonly claimDecision: 'ship' | 'hold' | 'test-cannot-resolve' | null;
+  readonly selectedNodeId: string | null;
   readonly eventCount: number;
-  readonly candidateCount: number;
-  readonly closedCandidateSlotCount: number;
-  readonly attemptCount: number;
-  readonly operationCount: number;
-  readonly expectedCandidateSlots: number;
-  readonly expectedTaskOutcomes: number;
-  readonly expectedOperations: number;
-  readonly missingCandidateSlots: number;
-  readonly missingTaskOutcomes: number;
-  readonly missingOperations: number;
-  readonly pendingDecisions: number;
-  readonly hasPlan: boolean;
-  readonly hasCompletion: boolean;
-}
-/**
- * A bounded proof envelope over one canonical SearchLedger replay.
+  readonly nodes: number;
+  readonly edges: number;
+  readonly cells: number;
+  readonly openCells: number;
+  readonly openOperations: number;
+  readonly nodesWithoutEdge: number;
+  readonly undecidedNodes: number;
+}
+/**
+ * A bounded proof envelope over one search ledger.
  *
- * The content-addressed ledger remains the sole rich history. This receipt binds
- * its producer/run identity, exact audit digest, bounded completeness summary,
- * and its own canonical digest. Consumers needing candidate ids, attempts,
- * failures, accounting gaps, or decisions read and replay the canonical ledger.
+ * The content-addressed ledger stays the only rich history. The receipt binds
+ * its producer and run, the exact ledger bytes, the digest of the complete
+ * audit, and a bounded summary. `complete` means the ledger holds
+ * `search-closed`, which the ledger admits only when every allocated cell has
+ * an outcome or was cancelled, every started operation was recorded, and every
+ * node has an edge and a terminal decision.
  */
 interface SearchHistoryReceipt {
   readonly schemaVersion: typeof SEARCH_HISTORY_RECEIPT_SCHEMA_VERSION;
@@ -536,10 +779,11 @@ interface SearchHistoryReceipt {
   readonly receiptDigest: SearchLedgerHash;
   /** Stable producer identity, for example an OptimizationMethod name. */
   readonly producerId: string;
-  /** Concrete optimizer/runtime invocation that produced the ledger. */
+  /** Concrete optimizer or runtime invocation that produced the ledger. */
   readonly runId: string;
+  /** The ledger file: `sha256` and `byteLength` of its exact bytes. */
   readonly ledger: SearchArtifactRef;
-  /** Digest of the complete SearchLedgerAudit produced by canonical replay. */
+  /** `hashCanonical` of the complete `SearchAudit` from replaying those bytes. */
   readonly auditDigest: SearchLedgerHash;
   readonly summary: SearchHistoryAuditSummary;
   readonly complete: boolean;
@@ -548,19 +792,25 @@ interface SearchHistoryReceipt {
 interface CreateSearchHistoryReceiptInput {
   readonly producerId: string;
   readonly runId: string;
-  /** Content-addressed canonical SearchLedger JSONL artifact. */
-  readonly ledger: SearchArtifactRef;
-  /** The result returned by SearchLedger.replay(). */
-  readonly replay: SearchLedgerReplay;
+  readonly ledger: {
+    readonly path: string;
+    readonly searchId: string;
+  };
+  readonly storage?: Pick<CampaignStorage, 'read'>;
 }
 type SearchHistoryPolicy = 'allow-missing' | 'require-complete';
 interface SearchHistoryAdmissionOptions {
-  /** Missing history is reported by default; require-complete refuses final assessment without a complete receipt. */
+  /** Missing history is reported by default; require-complete refuses final
+   * assessment without a closed search ledger. */
   searchHistoryPolicy?: SearchHistoryPolicy;
-  /** Receipt checks are the default. Ledger checks also resolve bytes through CampaignStorage.read. */
+  /** Receipt checks are the default. Ledger checks also resolve and replay the bytes. */
   searchHistoryVerification?: 'receipt' | 'ledger';
 }
-/** Verify resolved bytes with the canonical codec, never a caller-supplied replay projection. */
+/** Read the ledger's bytes, replay them through the search codec, and build
+ * the receipt from that replay. */
+declare function createSearchHistoryReceipt(input: CreateSearchHistoryReceiptInput): SearchHistoryReceipt;
+/** Verify the receipt, then resolve its ledger bytes, check them, and replay
+ * them with the canonical codec. Never trusts a caller-supplied projection. */
 declare function verifySearchHistoryArtifact(receipt: SearchHistoryReceipt, storage: Pick<CampaignStorage, 'read'>): void;
 interface SearchHistoryCoverageRow {
   readonly producerId: string;
@@ -581,209 +831,183 @@ declare class SearchHistoryRequiredError extends Error {
   readonly reasons: readonly string[];
   constructor(producerId: string, reasons: readonly string[]);
 }
-/** Build a bounded receipt from the projection returned by canonical ledger replay. */
-declare function createSearchHistoryReceipt(input: CreateSearchHistoryReceiptInput): SearchHistoryReceipt;
-/** Verify the bounded receipt. Full ledger bytes are verified by SearchLedger. */
+/** Verify a receipt's own consistency and digest. */
 declare function verifySearchHistoryReceipt(receipt: SearchHistoryReceipt): SearchHistoryReceipt;
-/** Prove that a receipt still describes the exact canonical replay supplied. */
-declare function assertSearchHistoryMatchesReplay(receipt: SearchHistoryReceipt, replay: SearchLedgerReplay): void;
-/** Require a receipt owned by this producer and a terminal, denominator-complete history. */
+/** Prove that a receipt describes exactly the supplied replayed state. */
+declare function assertSearchHistoryMatchesState(receipt: SearchHistoryReceipt, state: SearchStateView): void;
+/** Require a receipt owned by this producer over a closed search. */
 declare function assertCompleteSearchHistory(producerId: string, receipt: SearchHistoryReceipt | undefined): asserts receipt is SearchHistoryReceipt;
 /** Classify one producer's history without treating malformed evidence as absence. */
 declare function searchHistoryCoverageRow(producerId: string, receipt: SearchHistoryReceipt | undefined): SearchHistoryCoverageRow;
 //#endregion
-//#region src/campaign/gepa-candidate-population.d.ts
-interface GepaCandidatePopulationSummary {
-  readonly scope: 'gepa-candidate-population';
-  readonly path: string;
-  readonly sha256: `sha256:${string}`;
-  readonly bytes: number;
-  readonly runId: string;
-  readonly candidates: number;
-  readonly bestIndex: number;
-  readonly maxCandidates: number;
-  readonly maxCandidateChars: number;
-  readonly scenarioIds: readonly string[];
-  readonly surfaceKind: 'text' | 'components';
-}
-interface GepaCandidateSelectionScore {
-  readonly scenarioId: string;
-  readonly score: number;
-}
-interface GepaCandidatePopulationCandidate {
-  /** Zero-based index assigned by the exact GEPA result. */
-  readonly index: number;
-  readonly candidate: ExternalTextCandidate;
-  readonly candidateHash: string;
-  readonly candidateDigest: `sha256:${string}`;
-  /** Exact GEPA parent indices. The seed candidate has one null parent. */
-  readonly parentIndices: readonly (number | null)[];
-  /** Null means GEPA had no selection score for this candidate. */
-  readonly aggregateScore: number | null;
-  readonly selectionScores: readonly GepaCandidateSelectionScore[];
-  readonly discoveryEvaluationCount: number;
-}
-interface GepaCandidatePopulationArtifact {
-  readonly summary: GepaCandidatePopulationSummary;
-  readonly runId: string;
-  readonly bestIndex: number;
-  readonly candidates: readonly GepaCandidatePopulationCandidate[];
-}
-/**
- * Read GEPA's exact candidate graph from the artifact addressed by method provenance.
- *
- * The reader checks the supplied digest, declared byte count, run identity,
- * candidate surfaces, parent graph, selection scores, and configured bounds.
- * This proves that the bytes match the supplied summary. The caller remains
- * responsible for obtaining that summary from trusted method provenance.
- */
-declare function readGepaCandidatePopulationArtifact(input: {
-  summary: GepaCandidatePopulationSummary;
-  storage?: CampaignStorage;
-}): GepaCandidatePopulationArtifact;
-//#endregion
 //#region src/campaign/search-ledger-recording.d.ts
-/** How a search operation executed. The shape the ledger event records. */
-type SearchExecutionIdentity = SearchOperationRecordedEvent['execution'];
-/** Immutable identities the ledger requires and a campaign cannot infer. */
+/** Identities the ledger needs and a loop cannot infer. */
 interface SearchRunIdentity {
   /** The agent implementation under optimization. */
   agent: SearchSourceRef;
   /** The candidate generator: a model call or deterministic code. */
-  proposer: SearchExecutionIdentity;
-  /** The code that plans the search and selects its winner. */
+  proposer: SearchOperationRecordedEvent['execution'];
+  /** The code that runs the search and decides its nodes. */
   search: SearchSourceRef;
-  /** Model the agent runs. Used only for a cell that reported none. */
+  /** Model the agent runs; used for a cell that reported none. */
   model: SearchModelIdentity;
+  /** What the search improves, for example `vb/coder`. Default: the producer's name. */
+  subject?: string;
+  /** The judge's pinned source. Default: unknown, because judges arrive as functions. */
+  judge?: SearchSourceRef;
+  /** The claim the search's numbers may support. Default: a development claim
+   *  over the supplied tasks, one unit per task. */
+  claim?: EvaluationClaim;
 }
+/** A ledger and the identities a loop records into it. */
 interface SearchLedgerBinding {
   ledger: SearchLedger;
   identity: SearchRunIdentity;
 }
-/** One proposed candidate, before it is measured. */
-interface ProposedSearchCandidate {
-  surface: MutableSurface;
-  surfaceHash: string;
-  label?: string;
+/** The default claim: development numbers over exactly the supplied tasks. */
+declare function developmentClaim(populationId: string): EvaluationClaim;
+/** The header of a search, with plain task lists; the recorder digests them. */
+type SearchOpening = Omit<SearchOpenedEvent, 'kind' | 'eventId' | 'occurredAt' | 'artifacts' | 'splits'> & {
+  splits: {
+    train: SearchTask[];
+    selection: SearchTask[];
+    test: SearchTask[];
+    heldOutUnits: boolean;
+  };
+};
+interface SearchRecorderOptions {
+  ledger: SearchLedger;
+  /** Where content-addressed blobs are written. Default: `blobs/` beside the ledger. */
+  blobDir?: string;
+  storage?: CampaignStorage;
+  /** Milliseconds since the epoch. Default: `Date.now`. */
+  now?: () => number;
 }
-/** One measured candidate, after its campaign scored. */
-interface MeasuredSearchCandidate<TArtifact> {
-  surface: MutableSurface;
-  surfaceHash: string;
-  cells: ReadonlyArray<CampaignCellResult<TArtifact>>;
-  runDir: string;
-  /** False when the candidate missed a designed cell. */
-  coverageComplete: boolean;
+interface RegisterSearchNodeInput {
+  artifactDigest: `sha256:${string}`;
+  artifact: SearchArtifactRef;
+  surfaces: SearchCandidateSurface[];
+}
+interface RecordSearchEdgeInput {
+  childNodeId: string;
+  /** Parents in this search, primary first, as node ids; or refs for a derive edge. */
+  parents: Array<string | SearchNodeRef>;
+  operator: SearchEdgeOperator;
+  attribution: SearchEdgeAttribution;
+  proposer: SearchProposer | null;
+  /** Stable id of this proposal within the search, so a resumed search
+   * recognizes the edge; for example `gen-3:candidate-1`. */
+  proposalKey: string;
+  selection?: {
+    rule: string;
+    evidence: Record<string, number>;
+  } | null;
+  /** The proposer's free-text rationale; redacted before it is stored. */
+  rationale: string | SearchUnknown;
+  /** One per parent: a diff blob from `recorder.blob('diff', …)`, or why there is none. */
+  diffs: Array<SearchArtifactRef | SearchUnknown>;
+  label?: string;
 }
-interface SearchRecorderOptions<TScenario extends Scenario> {
-  binding: SearchLedgerBinding;
-  storage: CampaignStorage;
-  runDir: string;
-  scenarios: ReadonlyArray<TScenario>;
-  reps: number;
-  maxGenerations: number;
-  populationSize: number;
-  /** Identity of the exact campaign design; the task benchmark pin. */
-  splitDigest: `sha256:${string}`;
-  /** Proposer label recorded on every candidate lineage. */
-  proposerLabel: string;
-  costLedger: CostLedgerHandle;
+interface AllocateSearchCellInput {
+  nodeId: string;
+  taskId: string;
+  split: SearchSplit;
+  rep: number;
+  stage: SearchCellStage;
+  lane?: string | null;
+  reservation?: SearchReservation | null;
 }
-/**
- * Recorder for one `runOptimization` run: `open()`, then `recordGeneration()`
- * and `recordResults()` per generation, then `finish()`.
- *
- * Every event id is derived from the run, and an id already durable is not
- * appended again, so a resumed run continues one ledger instead of conflicting
- * with its own history.
- */
-declare class SearchRecorder<TScenario extends Scenario, TArtifact> {
-  private readonly opts;
+interface SettleSearchCellInput {
+  cellId: string;
+  /** Default: the next attempt. An attempt already in the ledger is not appended again. */
+  attempt?: number;
+  outcome: SearchTaskOutcome;
+  accounting: SearchAttemptAccounting;
+  identity: SearchExecutionIdentity;
+  boxMinutes?: number | null;
+  wallMs?: number | null;
+  queueMs?: number | null;
+  placement?: {
+    lane: string;
+    boxId: string | null;
+  } | null;
+  surfaceEvidence?: SearchSurfaceEvidence[];
+  traceRef?: SearchTraceRef;
+  /** The attempt's RunRecord; its search coordinates and runId must match. */
+  runRecord?: RunRecord;
+  artifacts?: SearchArtifactRef[];
+}
+/** Deterministic edge id: one proposal of one child within one search. */
+declare function searchEdgeId(searchId: string, childNodeId: string, proposalKey: string): string;
+/** Writes one search's events into its ledger as they happen. */
+declare class SearchRecorder {
+  readonly ledger: SearchLedger;
+  private readonly storage;
+  private readonly blobDir;
+  private readonly now;
   private readonly tasks;
-  private readonly registered;
-  private readonly order;
-  private readonly coverage;
-  private readonly openSlots;
-  private readonly durableEventIds;
   private lastStampMs;
-  private proposalReceiptCount;
   private constructor();
-  /** Open the recorder and append the plan. An existing ledger for the same
-   *  run is re-read first, so a resumed run keeps one plan and one lineage. */
-  static open<TScenario extends Scenario, TArtifact>(opts: SearchRecorderOptions<TScenario>): Promise<SearchRecorder<TScenario, TArtifact>>;
   /**
-   * Record one generation's candidate-generation call and the candidates it
-   * produced. A proposal larger than the planned population extends the plan
-   * with the extra slots; a proposal that fills fewer closes the rest.
+   * Open the search: append `search-opened`, or, when the ledger already holds
+   * one, check that it is this search and continue it.
    */
-  recordGeneration(input: {
-    generation: number;
-    parentSurfaceHash: string;
-    candidates: ReadonlyArray<ProposedSearchCandidate>;
+  static open(options: SearchRecorderOptions, opening: SearchOpening, artifacts?: SearchArtifactRef[]): Promise<SearchRecorder>;
+  get searchId(): string;
+  /** The ledger's verified state now. */
+  state(): Promise<SearchStateView>;
+  /** Store `body` as a canonical JSON blob and return its content address. */
+  blob(role: string, body: unknown): SearchArtifactRef;
+  /** Register a node, or return the existing node with the same artifact digest. */
+  registerNode(input: RegisterSearchNodeInput): Promise<{
+    nodeId: string;
+    existed: boolean;
+  }>;
+  /** Record the proposal that derived a node. Returns the edge id. */
+  recordEdge(input: RecordSearchEdgeInput): Promise<string>;
+  startOperation(input: {
+    operationId: string;
+    operationKind: SearchOperationKind;
+    reservation?: SearchReservation | null;
   }): Promise<void>;
-  /** Append one task attempt per designed cell of each candidate campaign. */
-  recordResults(candidates: ReadonlyArray<MeasuredSearchCandidate<TArtifact>>): Promise<void>;
-  /**
-   * Close the search: unreached generations, the selection operation, one
-   * decision per candidate, then the terminal event.
-   *
-   * The terminal event is appended only when canonical replay accounts for the
-   * whole planned denominator. An interrupted or partly unscored search stays
-   * `in-progress` and its receipt reports the exact gap, instead of claiming a
-   * closed search.
-   */
-  finish(input: {
-    winnerSurfaceHash: string;
-    generationsRun: number;
+  recordOperation(input: Omit<SearchOperationRecordedEvent, 'kind' | 'eventId' | 'occurredAt' | 'artifacts'> & {
+    artifacts?: SearchArtifactRef[];
+  }): Promise<void>;
+  /** Plan one cell. Returns the cell id; an allocated cell is not allocated again. */
+  allocateCell(input: AllocateSearchCellInput): Promise<string>;
+  /** Record one finished attempt at a cell. */
+  settleCell(input: SettleSearchCellInput): Promise<void>;
+  cancelCell(input: {
+    cellId: string;
+    reason: 'pruned' | 'budget' | 'deadline' | 'aborted';
+  }): Promise<void>;
+  /** Record a decision about a node. Repeating the node's latest decision appends nothing. */
+  decideNode(input: {
+    nodeId: string;
+    decision: SearchNodeDecision;
+    basis?: NodeEstimate | null;
+    rule: string;
+    reason: string;
+  }): Promise<void>;
+  /** Close the search. The ledger refuses a close while any cell, operation or
+   * node decision is outstanding. */
+  close(input: {
+    reason: SearchCloseReason;
+    claim: SearchClaim | null;
+  }): Promise<void>;
+  /** A bounded receipt over the exact ledger bytes. */
+  receipt(input: {
+    producerId: string;
     runId: string;
-  }): Promise<SearchHistoryReceipt>;
-  /** Bounded receipt over the exact ledger bytes this run produced. */
-  receipt(runId: string): Promise<SearchHistoryReceipt>;
-  /** Read an existing ledger for this run so a resume continues it. */
-  private hydrate;
-  private plan;
-  private registeredSlot;
-  private remember;
-  private recordGenerationOperation;
-  private closeSlot;
-  /** Spend booked to candidate generation since the previous generation. */
-  private proposalAccounting;
-  private cellModel;
-  private proposalArtifact;
-  /** Write one canonical evidence document and return its content address. */
-  private writeArtifact;
+  }): SearchHistoryReceipt;
   private append;
   /** Non-decreasing ISO stamps; the ledger refuses an event that moves back. */
   private stamp;
 }
-/**
- * Record an optimizer's own candidate graph into the same ledger.
- *
- * A complete optimization method searches inside its own process and reports
- * one artifact when it finishes: the candidate population, with each
- * candidate's parents and its score per selection scenario. This turns that
- * artifact into the canonical event stream, so a first-party method returns
- * the same `SearchHistoryReceipt` the in-process loop returns, and
- * `compareOptimizationMethods({ searchHistoryPolicy: 'require-complete' })`
- * accepts it.
- *
- * A candidate the optimizer left unscored on a planned scenario leaves the
- * planned denominator open, so the receipt reports the gap instead of closing
- * the search.
- */
-declare function recordCandidatePopulationSearch<TScenario extends Scenario>(input: {
-  ledger: SearchLedger;
-  storage: CampaignStorage;
-  runDir: string;
-  identity: SearchRunIdentity;
-  population: GepaCandidatePopulationArtifact;
-  /** Scenarios the optimizer selected on. Must cover the population's ids. */
-  scenarios: ReadonlyArray<TScenario>;
-  /** Spend the optimizer booked to its own candidate generation. */
-  generationAccounting: SearchAttemptAccounting;
-  producerId: string;
-  runId: string;
-}): Promise<SearchHistoryReceipt>;
+/** A mutable surface as a node: its content digest, stored bytes and declared surfaces. */
+declare function surfaceNode(recorder: SearchRecorder, surface: MutableSurface): RegisterSearchNodeInput;
+/** 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/presets/run-optimization.d.ts
 interface PremeasuredOptimizationBaseline<TArtifact, TScenario extends Scenario> {
@@ -873,11 +1097,12 @@ interface RunOptimizationBaseOptions<TScenario extends Scenario, TArtifact> exte
    */
   selectParent?: ParentSelector;
   /**
-   * Record this search into a durable `SearchLedger`. The loop emits the plan,
-   * each candidate-generation operation, each candidate registration with its
-   * measured parent, one task attempt per designed cell, one decision per
-   * candidate, and the terminal event, then returns a bounded
-   * `searchHistory` receipt over the exact ledger bytes.
+   * 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,
@@ -1205,6 +1430,56 @@ declare function readExternalOptimizerObservationArtifact(input: {
   storage?: CampaignStorage;
 }): ExternalOptimizerObservationArtifact;
 //#endregion
+//#region src/campaign/gepa-candidate-population.d.ts
+interface GepaCandidatePopulationSummary {
+  readonly scope: 'gepa-candidate-population';
+  readonly path: string;
+  readonly sha256: `sha256:${string}`;
+  readonly bytes: number;
+  readonly runId: string;
+  readonly candidates: number;
+  readonly bestIndex: number;
+  readonly maxCandidates: number;
+  readonly maxCandidateChars: number;
+  readonly scenarioIds: readonly string[];
+  readonly surfaceKind: 'text' | 'components';
+}
+interface GepaCandidateSelectionScore {
+  readonly scenarioId: string;
+  readonly score: number;
+}
+interface GepaCandidatePopulationCandidate {
+  /** Zero-based index assigned by the exact GEPA result. */
+  readonly index: number;
+  readonly candidate: ExternalTextCandidate;
+  readonly candidateHash: string;
+  readonly candidateDigest: `sha256:${string}`;
+  /** Exact GEPA parent indices. The seed candidate has one null parent. */
+  readonly parentIndices: readonly (number | null)[];
+  /** Null means GEPA had no selection score for this candidate. */
+  readonly aggregateScore: number | null;
+  readonly selectionScores: readonly GepaCandidateSelectionScore[];
+  readonly discoveryEvaluationCount: number;
+}
+interface GepaCandidatePopulationArtifact {
+  readonly summary: GepaCandidatePopulationSummary;
+  readonly runId: string;
+  readonly bestIndex: number;
+  readonly candidates: readonly GepaCandidatePopulationCandidate[];
+}
+/**
+ * Read GEPA's exact candidate graph from the artifact addressed by method provenance.
+ *
+ * The reader checks the supplied digest, declared byte count, run identity,
+ * candidate surfaces, parent graph, selection scores, and configured bounds.
+ * This proves that the bytes match the supplied summary. The caller remains
+ * responsible for obtaining that summary from trusted method provenance.
+ */
+declare function readGepaCandidatePopulationArtifact(input: {
+  summary: GepaCandidatePopulationSummary;
+  storage?: CampaignStorage;
+}): GepaCandidatePopulationArtifact;
+//#endregion
 //#region src/campaign/optimization-cost.d.ts
 /** Cost reported by a method or by final test scoring. */
 interface ComparisonCost {
@@ -1706,12 +1981,13 @@ interface GepaOptimizationMethodConfig<TScenario extends Scenario, TArtifact = u
   trustResumeState?: boolean;
   runner?: GepaRunnerCommand;
   /**
-   * Record GEPA's own candidate population into the canonical `SearchLedger`
-   * and return the bounded receipt on the method result, so a comparison run
-   * under `searchHistoryPolicy: 'require-complete'` accepts this method.
+   * Record GEPA's search into a search ledger and return the bounded receipt
+   * on the method result, so a comparison under `searchHistoryPolicy:
+   * 'require-complete'` accepts this method. The population becomes nodes and
+   * `correlated` edges, and every callback evaluation becomes a cell.
    *
-   * `identity` declares the immutable revisions and the model snapshot the
-   * ledger requires and the bridge does not report. `path` defaults to
+   * `identity` declares the immutable revisions and the model the ledger
+   * requires and the bridge does not report. `path` defaults to
    * `<runDir>/search-ledger.jsonl`.
    */
   searchLedger?: {
@@ -2556,6 +2832,89 @@ interface CrossSurfaceInteractionReport<TRow extends CrossSurfaceTaskRow = Cross
  */
 declare function analyzeCrossSurfaceInteractions<TRow extends CrossSurfaceTaskRow>(input: AnalyzeCrossSurfaceInteractionsInput<TRow>): CrossSurfaceInteractionReport<TRow>;
 //#endregion
+//#region src/campaign/estimate-node.d.ts
+/** The estimator every `NodeEstimate` names. */
+declare const SEARCH_ESTIMATOR: SearchSourceRef;
+interface EstimateNodeCellsInput {
+  nodeId: string;
+  against: string;
+  split: SearchSplit;
+  direction: 'maximize' | 'minimize';
+  /** Every scored cell of `nodeId` on `split`. */
+  nodeCells: readonly SearchScoredCell[];
+  /** Every scored cell of `against` on `split`. */
+  againstCells: readonly SearchScoredCell[];
+}
+/**
+ * Digest of the cells an estimate reads, with the contrast they serve. Cells
+ * are listed in cellId order, so the digest names the set, not the order it
+ * was read in.
+ */
+declare function searchCellSetDigest(input: Omit<EstimateNodeCellsInput, 'direction'>): SearchLedgerHash;
+/**
+ * The paired contrast of `nodeId` against `against` on the units both scored.
+ *
+ * `delta` is the mean per-unit difference, node minus `against`, in the
+ * metric's own units; for a `minimize` objective an improvement is negative.
+ * The exact sign test is one-sided toward improvement in the objective's
+ * direction. Unscored cells (errored, cancelled or in flight) are absent from
+ * the inputs, never zero.
+ *
+ * - `none` (0 or 1 pair): no delta.
+ * - `insufficient` (2 to 5): the delta only.
+ * - `descriptive` (6 to 19): the bootstrap interval as spread, and the sign-test p.
+ * - `bootstrap` (20 or more): the decision-grade bootstrap interval.
+ *
+ * When every paired delta is equal the interval would have zero width, which
+ * is an absence of evidence; the estimate is then `indeterminate` and carries
+ * neither an interval nor a p-value.
+ */
+declare function estimateNodeFromCells(input: EstimateNodeCellsInput): NodeEstimate;
+/**
+ * `estimateNodeFromCells` over the cells a search state holds: `nodeId`
+ * against `against` on one split, in the direction the search's objective
+ * declares.
+ */
+declare function estimateNode(state: SearchStateView, nodeId: string, options: {
+  against: string;
+  split: SearchSplit;
+}): NodeEstimate;
+/** A node's normal posterior on its improvement over the root. */
+interface NodePosterior {
+  nodeId: string;
+  /** Units the node and the root both scored. */
+  pairs: number;
+  /** Mean per-unit improvement over the root in the objective's direction,
+   * so larger is better for either direction. Null without a shared unit. */
+  mean: number | null;
+  /** The pooled variance divided by `pairs`. Null when either is unknown. */
+  variance: number | null;
+}
+interface SearchPosterior {
+  split: SearchSplit;
+  rootNodeId: string;
+  /**
+   * Between-unit variance of the per-unit improvements over the root, pooled
+   * across every non-root node with at least 2 shared units. Null until some
+   * node has 2.
+   */
+  pooledVariance: number | null;
+  /** Sum over the pooled nodes of their shared units minus one. */
+  degreesOfFreedom: number;
+  /** Every node in registration order; the root first, at exactly 0. */
+  nodes: NodePosterior[];
+}
+/**
+ * The posterior every node's parent-selection draw uses. Each node's mean is
+ * its improvement over the root on shared units; its variance is the search's
+ * pooled between-unit variance divided by its unit count, so a node measured
+ * on one unit has a wide posterior rather than none. The root is the reference
+ * and sits at exactly 0.
+ */
+declare function searchPosterior(state: SearchStateView, options?: {
+  split?: SearchSplit;
+}): SearchPosterior;
+//#endregion
 //#region src/campaign/fixtures.d.ts
 type EvalFixtureValidationMode = 'vitest' | 'none';
 interface EvalFixtureFile {
@@ -2632,6 +2991,76 @@ interface NeutralizationGateOptions<TScenario extends Scenario = Scenario> {
  */
 declare function neutralizationGate<TArtifact, TScenario extends Scenario>(options: NeutralizationGateOptions<TScenario>): Gate<TArtifact, TScenario>;
 //#endregion
+//#region src/campaign/gepa-search-import.d.ts
+interface GepaPopulationImport {
+  /** Population index to node id. */
+  nodeIds: ReadonlyMap<number, string>;
+  /** Distinct nodes the population maps to. */
+  nodes: number;
+  edges: number;
+  /** Population entries whose content equals an earlier entry's: one node, a second edge. */
+  collapsedDuplicates: number;
+  /** Proposals whose content equals their own parent, which no edge can express. */
+  unchangedProposals: number;
+}
+/**
+ * Register GEPA's population as nodes and its parent indices as `correlated`
+ * edges. A parentless entry (GEPA's seed) gets a seed edge unless its node is
+ * already in the tree, for example the root the caller seeded.
+ */
+declare function importGepaPopulation(input: {
+  recorder: SearchRecorder;
+  population: GepaCandidatePopulationArtifact;
+  proposer: SearchProposer;
+  /** How a candidate becomes a node. Default: its text or component surface. */
+  node?: (candidate: GepaCandidatePopulationCandidate) => RegisterSearchNodeInput;
+  /** How a parent-to-child diff is stored. Default: the surface diff. */
+  diff?: (parent: GepaCandidatePopulationCandidate, child: GepaCandidatePopulationCandidate) => SearchArtifactRef | SearchUnknown;
+}): Promise<GepaPopulationImport>;
+interface GepaEvaluationImport {
+  cells: number;
+  /** Nodes of candidates GEPA evaluated but kept out of its population. */
+  unrecordedParentNodeIds: string[];
+}
+/**
+ * Record every evaluation in the callback's observation log as an `external`
+ * cell attempt. A candidate that is not yet a node (GEPA evaluated it on a
+ * minibatch and discarded it) is registered with an `unknown` edge.
+ */
+declare function importExternalEvaluations(input: {
+  recorder: SearchRecorder;
+  observations: ExternalOptimizerObservationArtifact;
+  proposer: SearchProposer;
+  identity: SearchExecutionIdentity;
+  /** The split each evaluated example belongs to. */
+  splitOf: (exampleId: string) => SearchSplit;
+}): Promise<GepaEvaluationImport>;
+/** An optimizer candidate as the mutable surface it represents. */
+declare function externalSurface(candidate: ExternalTextCandidate): MutableSurface;
+/**
+ * Write GEPA's finished search into its ledger: the baseline as the seeded
+ * root, the population as nodes with `correlated` edges, every callback
+ * evaluation as an `external` cell, GEPA's proposer spend as one operation,
+ * GEPA's choice as the selected node, and the close. GEPA's own selection is a
+ * budget decision, so the ledger carries no claim; the final comparison runs
+ * outside this search.
+ */
+declare function recordGepaSearch(input: {
+  name: string;
+  path: string;
+  searchId: string;
+  identity: SearchRunIdentity;
+  storage: CampaignStorage;
+  seed: number;
+  baselineSurface: MutableSurface;
+  trainScenarios: readonly Scenario[];
+  selectionScenarios: readonly Scenario[];
+  evaluationLimit: number;
+  population: GepaCandidatePopulationArtifact;
+  observations: ExternalOptimizerObservationArtifact;
+  generationAccounting: SearchAttemptAccounting;
+}): Promise<SearchHistoryReceipt>;
+//#endregion
 //#region src/campaign/grounded-reflection.d.ts
 /**
  * Evidence grounding for reflective optimizers (GEPA-style revise loops).
@@ -3638,5 +4067,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 $, assertCampaignDesign as $a, readGepaCandidatePopulationArtifact as $i, emitLoopProvenance as $n, OptimizationMethodComparison as $r, loadEvalFixture as $t, tangleTracesRoot as A, openAutoPr as Aa, TransientFailureOptions as Ai, CrossSurfacePairwiseEntry as An, composeGate as Ar, sequentialOptimizationMethod as At, finalizeProfileMatrix as B, planCampaignRun as Ba, runOptimization as Bi, traceAnalystQualityJudge as Bn, GepaRunnerCommand as Br, classifyUngroundedLiterals as Bt, SingleRunLockOptions as C, SearchLedgerIntegrityError as Ca, ReferenceEquivalenceJudgeResult as Ci, CrossSurfaceInteractionPath as Cn, scoreRedTeamOutput as Cr, RequirementCheck as Ct, scoreDiscrimination as D, crowdedFrontierParent as Da, LlmJudgeDimension as Di, CrossSurfacePairCompatibility as Dn, CanaryOptions as Dr, createLlmCorrectnessChecker as Dt, ScenarioSignal as E, ParentSelector as Ea, runReferenceEquivalenceJudge as Ei, CrossSurfaceNaiveStackSelection as En, CanaryKind as Er, completionVerdict as Et, ProfileMatrixPlan as F, RunCampaignOptions as Fa, RunImprovementLoopResult as Fi, CrossSurfaceTaskRow as Fn, GepaAdaptiveEngineRun as Fr, RolloutArgumentDiff as Ft, ScoreboardRenderOptions as G, buildCellSchedule as Ga, SearchRecorder as Gi, LoopProvenanceBackend as Gn, ExternalTextOptimizationMethodConfig as Gr, EvalFixtureFile as Gt, PlaybackContext as H, CacheRead as Ha, ProposedSearchCandidate as Hi, EmitLoopProvenanceArgs as Hn, OpenAICompatibleOptimizerModel as Hr, NeutralizationGateOptions as Ht, ProfileMatrixRow as I, runCampaign as Ia, runImprovementLoop as Ii, BuildTraceAnalystSurfaceDispatchOptions as In, GepaEngineOptions as Ir, RolloutArgumentDiffOptions as It, UserStory as J, createRunCostLedger as Ja, recordCandidatePopulationSearch as Ji, LoopProvenanceOptimizationMethod as Jn, ExternalOptimizationExample as Jr, EvalFixtureScenario as Jt, ScoreboardRow as K, cellCachePath as Ka, SearchRecorderOptions as Ki, LoopProvenanceCandidate as Kn, ExternalTextOptimizerContext as Kr, EvalFixtureLoadOptions as Kt, ProfileMatrixSegmentResult as L, CampaignRunPlan as La, PremeasuredOptimizationBaseline as Li, TraceAnalystArtifact as Ln, GepaEngineRun as Lr, RolloutCall as Lt, FinalizeProfileMatrixOptions as M, runEval as Ma, quotaExhaustedUntil as Mi, CrossSurfaceRelativeCost as Mn, SkillOptRunnerCommand as Mr, FsLabeledScenarioStore as Mt, FinalizedProfileMatrixResult as N, CampaignCellFailureReceipt as Na, transientDispatchFailure as Ni, CrossSurfaceSelectionPolicy as Nn, SkillOptTrainerConfig as Nr, FsLabeledScenarioStoreOptions as Nt, selectDiscriminative as O, OpenAutoPrOptions as Oa, LlmJudgeOptions as Oi, CrossSurfacePairEvidence as On, CanaryReport as Or, verifyCompletion as Ot, ProfileMatrixCoverage as P, CampaignCellRetryPolicy as Pa, RunImprovementLoopOptions as Pi, CrossSurfaceSelections as Pn, skillOptOptimizationMethod as Pr, LabeledScenarioStoreError as Pt, scoreUserStory as Q, FinalEvidenceUse as Qa, GepaCandidateSelectionScore as Qi, canonicalDigest as Qn, OptimizationMethod as Qr, discoverEvalFixtures as Qt, RunProfileMatrixSegmentOptions as R, CampaignRunPlanCell as Ra, RunOptimizationOptions as Ri, TraceAnalystScenario as Rn, GepaOptimizationMethodConfig as Rr, ScoredRollout as Rt, SingleRunLock as S, SearchLedgerError as Sa, ReferenceEquivalenceJudgeOptions as Si, CrossSurfaceInteractionEffect as Sn, redTeamReport as Sr, ProducedState as St, DiscriminationScore as T, ParentSelectionContext as Ta, createReferenceEquivalenceJudge as Ti, CrossSurfaceInteractionTask as Tn, CanaryEvaluation as Tr, TaskGold as Tt, PlaybackDriver as U, readCachedCell as Ua, SearchExecutionIdentity as Ui, EmitLoopProvenanceResult as Un, OptimizerModelBudget as Ur, neutralizationGate as Ut, runProfileMatrixSegment as V, CacheIssueReason as Va, MeasuredSearchCandidate as Vi, BuildLoopProvenanceArgs as Vn, gepaOptimizationMethod as Vr, rolloutArgumentDiff as Vt, PlaybackStep as W, CellScheduleSlot as Wa, SearchLedgerBinding as Wi, LoopProvenanceArgsFromResult as Wn, externalTextOptimizationMethod as Wr, EvalFixture as Wt, makePlaybackDispatch as X, inMemoryCampaignStorage as Xa, GepaCandidatePopulationCandidate as Xi, buildLoopProvenanceRecord as Xn, decodeExternalTextCandidate as Xr, LoadEvalFixtureScenariosOptions as Xt, UserStoryVerdict as Y, fsCampaignStorage as Ya, GepaCandidatePopulationArtifact as Yi, LoopProvenanceRecord as Yn, ExternalTextEvaluationResponse as Yr, EvalFixtureValidationMode as Yt, renderScoreboardMarkdown as Z, FinalEvidencePolicy as Za, GepaCandidatePopulationSummary as Zi, campaignMeasurementDigest as Zn, CompareOptimizationMethodsOptions as Zr, PlanEvalFixtureRunOptions as Zt, componentSurfaceIdentityMaterial as _, SearchLedgerTrustedHeadMode as _a, ExternalOptimizerSubmittedCandidate as _i, CrossSurfaceDistribution as _n, RedTeamCase as _r, CompletionRequirement as _t, WorktreeAdapterError as a, SearchHistoryPolicy as aa, OptimizationMethodRunOptions as ai, CrossSurfaceAdditionRejectionReason as an, CampaignBreakdown as ar, RunProfileMatrixResult as at, surfaceDispatchRef as b, validateSearchLedgerEvent as ba, REFERENCE_EQUIVALENCE_JUDGE_VERSION as bi, CrossSurfaceIneligibilityReason as bn, RedTeamReport as br, LlmCorrectnessCheckerOpts as bt, verifyCodeSurface as c, assertCompleteSearchHistory as ca, OptimizationTokenUsage as ci, CrossSurfaceBootstrapPolicy as cn, campaignMeanComposite as cr, BackendIntegrityError as ct, PhoenixEvaluationResultLike as d, searchHistoryCoverageRow as da, ComparisonCost as di, CrossSurfaceCandidateEvidence as dn, heldOutGate as dr, summarizeBackendIntegrity as dt, CreateSearchHistoryReceiptInput as ea, OptimizationMethodComposition as ei, loadEvalFixtureScenarios as en, assertCampaignSplitIdentity as eo, loopProvenanceArgsFromResult as er, userStoryScoreboard as et, PhoenixEvaluatorLike as f, verifySearchHistoryArtifact as fa, combineComparisonCosts as fi, CrossSurfaceCandidateOutcome as fn, DefaultProductionGateCheck as fr, ArtifactEventLike as ft, codeSurfaceIdentityMaterial as g, SearchLedger as ga, ExternalOptimizerObservationSummary as gi, CrossSurfaceCompositionStep as gn, DEFAULT_RED_TEAM_CORPUS as gr, extractProducedState as gt, assertCodeSurfaceIdentity as h, OpenSearchLedgerOptions as ha, ExternalOptimizerObservationArtifact as hi, CrossSurfaceComponentEvidence as hn, defaultProductionGate as hr, ToolCallEventLike as ht, WorktreeAdapter as i, SearchHistoryCoverageRow as ia, OptimizationMethodResult as ii, CrossSurfaceAdditionDecision as in, verifyLoopProvenanceRecord as ir, RunProfileMatrixOptions as it, CreateProfileMatrixPlanOptions as j, RunEvalOptions as ja, isTransientTransportFailure as ji, CrossSurfaceRankedSingle as jn, SkillOptOptimizationMethodConfig as jr, neutralizeText as jt, resolveRunDir as k, OpenAutoPrResult as ka, llmJudge as ki, CrossSurfacePairIncompatibilityReason as kn, runCanaries as kr, scopedOptimizationMethod as kt, AutoevalsScoreLike as l, assertSearchHistoryMatchesReplay as la, compareOptimizationMethods as li, CrossSurfaceCandidate as ln, compareRankKeys as lr, BackendIntegrityReport as lt, phoenixEvaluatorJudge as m, FileSearchLedger as ma, ExternalOptimizerExecutionSummary as mi, CrossSurfaceComponent as mn, DefaultProductionRewardHackingOptions as mr, RuntimeEventLike as mt, GitWorktreeAdapterOptions as n, SearchHistoryAuditSummary as na, OptimizationMethodPairwise as ni, analyzeCrossSurfaceInteractions as nn, campaignSplitDigest as no, provenanceRecordPath as nr, ProfileMatrixError as nt, gitWorktreeAdapter as o, SearchHistoryReceipt as oa, OptimizationMethodScore as oi, CrossSurfaceAttemptCompleteness as on, CampaignComparisonUnits as or, ScenarioRollup as ot, autoevalsScorerJudge as p, verifySearchHistoryReceipt as pa, costFromLedgerSummary as pi, CrossSurfaceCandidateSummary as pn, DefaultProductionGateOptions as pr, ProposalEventLike as pt, ScoreboardSummary as q, CampaignStorage as qa, SearchRunIdentity as qi, LoopProvenanceEvidence as qn, ExternalTextOptimizerResult as qr, EvalFixtureRunPlan as qt, Worktree as r, SearchHistoryCoverage as ra, OptimizationMethodProvenance as ri, AnalyzeCrossSurfaceInteractionsInput as rn, campaignSplitDigestFromIdentities as ro, provenanceSpansPath as rr, ProfileSummary as rt, resolveWorktreePath as s, SearchHistoryRequiredError as sa, OptimizationPackageSource as si, CrossSurfaceBestSingleSelection as sn, campaignBreakdown as sr, runProfileMatrix as st, CodeSurfaceVerification as t, SearchHistoryAdmissionOptions as ta, OptimizationMethodInput as ti, planEvalFixtureRun as tn, campaignScenarioIdentity as to, loopProvenanceSpans as tr, ProfileDispatchFn as tt, AutoevalsScorerLike as u, createSearchHistoryReceipt as ua, optimizationTokenUsageFromSummary as ui, CrossSurfaceCandidateComparison as un, HeldOutGateOptions as ur, assertRealBackend as ut, renderSurfaceDiff as v, openSearchLedger as va, readExternalOptimizerObservationArtifact as vi, CrossSurfaceEligibility as vn, RedTeamCategory as vr, CompletionVerdict as vt, acquireSingleRunLock as w, CrowdedFrontierParentOptions as wa, ReferenceEquivalenceScenario as wi, CrossSurfaceInteractionReport as wn, CanaryAlert as wr, SatisfiedBy as wt, surfaceHash as x, SearchLedgerConflictError as xa, ReferenceEquivalenceJudgeInput as xi, CrossSurfaceInteractionAwareSelection as xn, redTeamDataset as xr, ProducedProposal as xt, surfaceContentHash as y, replaySearchLedgerText as ya, REFERENCE_EQUIVALENCE_INPUT_LIMITS as yi, CrossSurfaceEvidenceBreakdown as yn, RedTeamFinding as yr, CorrectnessChecker as yt, createProfileMatrixPlan as z, PlanCampaignRunOptions as za, RunOptimizationResult as zi, buildTraceAnalystSurfaceDispatch as zn, GepaOptimizationRecipe as zr, UngroundedLiteralReport as zt };
-//# sourceMappingURL=index-CnJOPR_E.d.ts.map
+export { scoreboardSummary as $, searchTaskSetDigest 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, inMemoryCampaignStorage as Ao, DEFAULT_RED_TEAM_CORPUS as Ar, sequentialOptimizationMethod as At, finalizeProfileMatrix as B, validateSearchLedgerEvent 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, readCachedCell as Co, compareRankKeys as Cr, RequirementCheck as Ct, scoreDiscrimination as D, assertCompleteSearchHistory as Da, costFromLedgerSummary as Di, CrossSurfaceCandidateSummary as Dn, CampaignStorage as Do, DefaultProductionGateOptions as Dr, createLlmCorrectnessChecker as Dt, ScenarioSignal as E, SearchHistoryRequiredError as Ea, combineComparisonCosts as Ei, CrossSurfaceCandidateOutcome as En, cellCachePath as Eo, DefaultProductionGateCheck as Er, completionVerdict as Et, ProfileMatrixPlan as F, SearchLedger as Fa, ExternalOptimizerObservationSummary as Fi, CrossSurfaceInteractionAwareSelection as Fn, campaignScenarioIdentity as Fo, redTeamDataset as Fr, RolloutArgumentDiff as Ft, ScoreboardRenderOptions as G, SearchOperation as Ga, runReferenceEquivalenceJudge as Gi, CrossSurfaceRankedSingle as Gn, SkillOptOptimizationMethodConfig as Gr, importExternalEvaluations as Gt, PlaybackContext as H, SearchCompletion 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, campaignSplitDigest as Io, redTeamReport as Ir, RolloutArgumentDiffOptions as It, UserStory as J, SearchState as Ja, llmJudge as Ji, CrossSurfaceSelections as Jn, skillOptOptimizationMethod as Jr, NeutralizationGateOptions as Jt, ScoreboardRow as K, SearchScoredCell 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, campaignSplitDigestFromIdentities as Lo, scoreRedTeamOutput as Lr, RolloutCall as Lt, FinalizeProfileMatrixOptions as M, verifySearchHistoryReceipt as Ma, readGepaCandidatePopulationArtifact as Mi, CrossSurfaceEligibility as Mn, FinalEvidenceUse as Mo, RedTeamCategory as Mr, FsLabeledScenarioStore as Mt, FinalizedProfileMatrixResult as N, FileSearchLedger as Na, ExternalOptimizerExecutionSummary as Ni, CrossSurfaceEvidenceBreakdown as Nn, assertCampaignDesign as No, RedTeamFinding as Nr, FsLabeledScenarioStoreOptions as Nt, selectDiscriminative as O, assertSearchHistoryMatchesState as Oa, GepaCandidatePopulationArtifact as Oi, CrossSurfaceComponent as On, createRunCostLedger as Oo, DefaultProductionRewardHackingOptions as Or, verifyCompletion as Ot, ProfileMatrixCoverage as P, OpenSearchLedgerOptions as Pa, ExternalOptimizerObservationArtifact as Pi, CrossSurfaceIneligibilityReason as Pn, assertCampaignSplitIdentity as Po, RedTeamReport as Pr, LabeledScenarioStoreError as Pt, scoreUserStory as Q, searchNodeId 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, CanaryAlert as Rr, ScoredRollout as Rt, SingleRunLock as S, SearchHistoryCoverage as Sa, OptimizationTokenUsage as Si, CrossSurfaceBootstrapPolicy as Sn, CacheRead as So, campaignMeanComposite as Sr, ProducedState as St, DiscriminationScore as T, SearchHistoryReceipt as Ta, ComparisonCost as Ti, CrossSurfaceCandidateEvidence as Tn, buildCellSchedule as To, heldOutGate as Tr, TaskGold as Tt, PlaybackDriver as U, SearchDecisionRecord as Ua, ReferenceEquivalenceScenario as Ui, CrossSurfacePairIncompatibilityReason as Un, runCanaries as Ur, GepaPopulationImport as Ut, runProfileMatrixSegment as V, SearchCell as Va, ReferenceEquivalenceJudgeOptions as Vi, CrossSurfacePairCompatibility as Vn, CanaryOptions as Vr, rolloutArgumentDiff as Vt, PlaybackStep as W, SearchNode as Wa, createReferenceEquivalenceJudge as Wi, CrossSurfacePairwiseEntry as Wn, composeGate as Wr, externalSurface as Wt, makePlaybackDispatch as X, SearchUnitScore as Xa, isTransientTransportFailure as Xi, BuildTraceAnalystSurfaceDispatchOptions as Xn, GepaEngineOptions as Xr, EvalFixture as Xt, UserStoryVerdict as Y, SearchStateView as Ya, TransientFailureOptions as Yi, CrossSurfaceTaskRow as Yn, GepaAdaptiveEngineRun as Yr, neutralizationGate as Yt, renderScoreboardMarkdown as Z, searchCellId 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, CampaignRunPlan as _o, provenanceSpansPath as _r, CompletionRequirement as _t, WorktreeAdapterError as a, runOptimization as aa, ExternalTextOptimizationMethodConfig as ai, loadEvalFixture as an, ParentSelectionContext as ao, LoopProvenanceBackend as ar, RunProfileMatrixResult as at, surfaceDispatchRef as b, SearchHistoryAdmissionOptions as ba, OptimizationMethodScore as bi, CrossSurfaceAttemptCompleteness as bn, planCampaignRun as bo, CampaignComparisonUnits as br, LlmCorrectnessCheckerOpts as bt, verifyCodeSurface as c, RegisterSearchNodeInput as ca, ExternalOptimizationExample as ci, EstimateNodeCellsInput as cn, OpenAutoPrOptions as co, LoopProvenanceOptimizationMethod as cr, BackendIntegrityError as ct, PhoenixEvaluationResultLike as d, SearchRecorder as da, CompareOptimizationMethodsOptions as di, SearchPosterior as dn, RunEvalOptions as do, campaignMeasurementDigest as dr, summarizeBackendIntegrity as dt, RunImprovementLoopResult as ea, GepaRunnerCommand as ei, EvalFixtureScenario as en, searchUnitScores as eo, traceAnalystQualityJudge as er, userStoryScoreboard as et, PhoenixEvaluatorLike as f, SearchRecorderOptions as fa, OptimizationMethod as fi, estimateNode as fn, runEval as fo, canonicalDigest as fr, ArtifactEventLike as ft, codeSurfaceIdentityMaterial as g, searchEdgeId as ga, OptimizationMethodPairwise as gi, analyzeCrossSurfaceInteractions as gn, runCampaign as go, provenanceRecordPath as gr, extractProducedState as gt, assertCodeSurfaceIdentity as h, developmentClaim as ha, OptimizationMethodInput as hi, searchPosterior as hn, RunCampaignOptions as ho, loopProvenanceSpans as hr, ToolCallEventLike as ht, WorktreeAdapter as i, RunOptimizationResult as ia, externalTextOptimizationMethod as ii, discoverEvalFixtures as in, CrowdedFrontierParentOptions as io, LoopProvenanceArgsFromResult as ir, RunProfileMatrixOptions as it, CreateProfileMatrixPlanOptions as j, verifySearchHistoryArtifact as ja, GepaCandidateSelectionScore as ji, CrossSurfaceDistribution as jn, FinalEvidencePolicy as jo, RedTeamCase as jr, neutralizeText as jt, resolveRunDir as k, createSearchHistoryReceipt as ka, GepaCandidatePopulationCandidate as ki, CrossSurfaceComponentEvidence as kn, fsCampaignStorage as ko, defaultProductionGate as kr, scopedOptimizationMethod as kt, AutoevalsScoreLike as l, SearchLedgerBinding as la, ExternalTextEvaluationResponse as li, NodePosterior as ln, OpenAutoPrResult as lo, LoopProvenanceRecord as lr, BackendIntegrityReport as lt, phoenixEvaluatorJudge as m, SettleSearchCellInput as ma, OptimizationMethodComposition as mi, searchCellSetDigest as mn, CampaignCellRetryPolicy as mo, loopProvenanceArgsFromResult as mr, RuntimeEventLike as mt, GitWorktreeAdapterOptions as n, PremeasuredOptimizationBaseline as na, OpenAICompatibleOptimizerModel as ni, LoadEvalFixtureScenariosOptions as nn, SearchLedgerError as no, EmitLoopProvenanceArgs as nr, ProfileMatrixError as nt, gitWorktreeAdapter as o, AllocateSearchCellInput as oa, ExternalTextOptimizerContext as oi, loadEvalFixtureScenarios as on, ParentSelector as oo, LoopProvenanceCandidate as or, ScenarioRollup as ot, autoevalsScorerJudge as p, SearchRunIdentity as pa, OptimizationMethodComparison as pi, estimateNodeFromCells as pn, CampaignCellFailureReceipt as po, emitLoopProvenance as pr, ProposalEventLike as pt, ScoreboardSummary as q, SearchSpend 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, SearchLedgerIntegrityError as ro, EmitLoopProvenanceResult as rr, ProfileSummary as rt, resolveWorktreePath as s, RecordSearchEdgeInput as sa, ExternalTextOptimizerResult as si, planEvalFixtureRun as sn, crowdedFrontierParent as so, LoopProvenanceEvidence as sr, runProfileMatrix as st, CodeSurfaceVerification as t, runImprovementLoop as ta, gepaOptimizationMethod as ti, EvalFixtureValidationMode as tn, SearchLedgerConflictError as to, BuildLoopProvenanceArgs as tr, ProfileDispatchFn as tt, AutoevalsScorerLike as u, SearchOpening as ua, decodeExternalTextCandidate as ui, SEARCH_ESTIMATOR as un, openAutoPr as uo, buildLoopProvenanceRecord as ur, assertRealBackend as ut, renderSurfaceDiff as v, surfaceNode as va, OptimizationMethodResult as vi, CrossSurfaceAdditionDecision as vn, CampaignRunPlanCell as vo, verifyLoopProvenanceRecord as vr, CompletionVerdict as vt, acquireSingleRunLock as w, SearchHistoryPolicy as wa, optimizationTokenUsageFromSummary as wi, CrossSurfaceCandidateComparison as wn, CellScheduleSlot as wo, HeldOutGateOptions as wr, SatisfiedBy as wt, surfaceHash as x, SearchHistoryAuditSummary as xa, OptimizationPackageSource as xi, CrossSurfaceBestSingleSelection as xn, CacheIssueReason as xo, campaignBreakdown as xr, ProducedProposal as xt, surfaceContentHash as y, CreateSearchHistoryReceiptInput as ya, OptimizationMethodRunOptions as yi, CrossSurfaceAdditionRejectionReason as yn, PlanCampaignRunOptions as yo, CampaignBreakdown as yr, CorrectnessChecker as yt, createProfileMatrixPlan as z, replaySearchLedgerText as za, REFERENCE_EQUIVALENCE_JUDGE_VERSION as zi, CrossSurfaceInteractionTask as zn, CanaryEvaluation as zr, UngroundedLiteralReport as zt };
+//# sourceMappingURL=index-Ci0-EYzc.d.ts.map