@tangle-network/agent-eval 0.196.0 → 0.198.0

package/dist/{index-CigojbNH.d.ts → index-BhoOCduB.d.ts}

@@ -1,14 +1,14 @@
 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 { T as RunPaidCallInput, c as CostLedgerHandle, f as CostLedgerSummary, m as CostReceipt, p as CostProvenance } from "./cost-ledger-DbQdN3nO.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-BedVSZb2.js";
+import { Et as FinalEvidenceLedger, P as PairedArmsComparison, ft as EvidenceReceipt, it as CampaignEvidenceContext, kt as FinalEvidenceRecord } from "./statistical-heldout-CMpxMjlQ.js";
 import { a as PairedPromotionDecision, d as PairedBootstrapResult } from "./paired-promotion-decision-DPKz8ZnF.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-p2xKfiDJ.js";
-import { b as LedgerTrustedHeadRemoval, f as LedgerLineContext, h as LedgerTextStore, y as LedgerTrustedHead } from "./index-Bj96W0jZ.js";
+import { E as SearchExecutionIdentity, G as SearchSplit, V as SearchProposer, a as SearchAttemptAccounting, i as SearchArtifactRef, j as SearchModelIdentity, nt as EvaluationClaim, rt as EvaluationUnitSummary, tt as SearchUnknown, z as SearchOperationRecordedEvent } from "./search-ledger-types-p2xKfiDJ.js";
 import { r as LedgerHash } from "./canonical-CFpojCN5.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-B2673PBj.js";
+import { 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, 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-EBUav9Bu.js";
+import { Dt as SearchHistoryAdmissionOptions, L as SearchPolicy, Mt as SearchHistoryReceipt, Yt as CampaignStorage, bt as SearchRunIdentity, gt as SearchLedgerBinding, ht as RegisterSearchNodeInput, i as SearchCellResult, kt as SearchHistoryCoverage, vt as SearchRecorder } from "./search-kernel-CuvbakC_.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";
@@ -40,60 +40,6 @@ interface FinalEvidenceUse {
   record: FinalEvidenceRecord;
 }
 //#endregion
-//#region src/campaign/storage.d.ts
-/**
- * `CampaignStorage` — the filesystem seam `runCampaign` writes through
- * (run/cell dirs, the resumability cache, per-cell artifacts, trace spans).
- *
- * The default (`fsCampaignStorage`) is the Node filesystem — identical
- * behavior to the inline `node:fs` calls it replaces, so existing CLI
- * consumers are unaffected. `inMemoryCampaignStorage` keeps everything in a
- * `Map`, so the substrate runs in environments WITHOUT a filesystem
- * (Cloudflare Workers, Deno Deploy, other edge runtimes) — the campaign
- * still produces its `CampaignResult` (cells + aggregates) in memory;
- * artifacts/traces simply aren't persisted to disk.
- *
- * Paths are opaque keys to the in-memory adapter — it does not parse them,
- * 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)? */
-  exists(path: string): boolean;
-  /** Read a UTF-8 file; `undefined` when missing or unreadable. */
-  read(path: string): string | undefined;
-  /** Write a file (string or bytes). Parent dir is assumed ensured. */
-  write(path: string, content: string | Uint8Array): void;
-  /** Append only when the current UTF-8 byte length matches `expectedBytes`.
-   * Returns the new length, or undefined when another writer won. */
-  append(path: string, content: string, expectedBytes: number): number | undefined;
-}
-/** Node-filesystem storage — the default. Lazily requires `node:fs` so the
- *  module imports cleanly in non-Node runtimes (where the caller passes
- *  `inMemoryCampaignStorage` instead and never constructs this).
- *
- *  `createRequire(import.meta.url)` is the ESM-native lazy require — a bare
- *  `require` is a ReferenceError under `"type": "module"`, which is exactly
- *  the shape this package publishes. */
-declare function fsCampaignStorage(): CampaignStorage;
-/** In-memory storage for filesystem-less runtimes. Artifacts + trace spans
- *  live in a `Map` for the duration of the run; the `CampaignResult` is
- *  fully populated, but nothing is persisted to disk. */
-declare function inMemoryCampaignStorage(): CampaignStorage;
-/** Open the durable spend account stored beside a logical run. */
-declare function createRunCostLedger(input: {
-  storage: CampaignStorage;
-  runDir: string;
-  costCeilingUsd?: number;
-  /** Set false for read-only inspection that must not create the run directory. */
-  ensureRunDir?: boolean;
-}): CostLedger;
-//#endregion
 //#region src/campaign/cell-schedule.d.ts
 declare function buildCellSchedule<TScenario extends Scenario>(scenarios: TScenario[], seed: number, reps: number): Array<{
   scenario: TScenario;
@@ -403,434 +349,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-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. */
-declare function validateSearchLedgerEvent(input: unknown): SearchLedgerEvent;
-/**
- * How this ledger uses its trusted head — the `(sequence, entryHash)` pin kept
- * in the sibling `<path>.head` file that a hash chain needs to prove entries
- * were not deleted from the end. `ledger-core/trusted-head.ts` holds the threat
- * model.
- *
- * - `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.
- * - `off`: chain verification only. Truncation to a valid shorter prefix is
- *   undetectable.
- */
-type SearchLedgerTrustedHeadMode = 'pin' | 'require' | 'off';
-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;
-  /** False when the exact event was already durably present. */
-  appended: boolean;
-  state: SearchStateView;
-}
-interface SearchLedger {
-  readonly path: string;
-  readonly searchId: string;
-  /** Sibling file holding this ledger's trusted head. */
-  readonly trustedHeadPath: string;
-  append(event: SearchLedgerEvent): Promise<SearchLedgerAppendResult>;
-  /** 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 without rewriting a byte. */
-  pinTrustedHead(): Promise<LedgerTrustedHead>;
-  /** 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 `state` verifies the whole existing file. */
-declare function openSearchLedger(options: OpenSearchLedgerOptions): SearchLedger;
-/** Verify and project immutable search-ledger JSONL through the same codec as
- * `FileSearchLedger`. */
-declare function replaySearchLedgerText(text: string, searchId: string, source: string): SearchStateView;
-/**
- * Verify one stored ledger line in isolation: the schema tag, the entry and
- * event schemas, canonical bytes, the entry's own hash, and its search. The
- * chain (sequence and previous hash) and the state machine are the caller's,
- * because they need the lines before this one. An ingest server runs this on
- * every received line, so it hashes exactly the bytes the producer hashed.
- */
-declare function parseSearchLedgerLine(line: string, searchId: string, context: LedgerLineContext): SearchLedgerEntry;
-/** Append-only file-backed search ledger with idempotent writes. */
-declare class FileSearchLedger implements SearchLedger {
-  readonly path: string;
-  readonly searchId: string;
-  readonly trustedHeadPath: string;
-  private readonly trustedHeadMode;
-  private readonly journal;
-  constructor(path: string, searchId: string, trustedHead?: SearchLedgerTrustedHeadMode);
-  state(): Promise<SearchStateView>;
-  append(input: SearchLedgerEvent): Promise<SearchLedgerAppendResult>;
-  trustedHead(): Promise<LedgerTrustedHead | null>;
-  pinTrustedHead(): Promise<LedgerTrustedHead>;
-  clearTrustedHead(): Promise<LedgerTrustedHeadRemoval>;
-}
-//#endregion
-//#region src/campaign/search-history-receipt.d.ts
-declare const SEARCH_HISTORY_RECEIPT_SCHEMA_VERSION: '2026-09';
-declare const SEARCH_HISTORY_RECEIPT_DIGEST_ALGORITHM: 'rfc8785-sha256';
-/** Bounded summary of a search's audit. Exact ids stay in the ledger. */
-interface SearchHistoryAuditSummary {
-  readonly searchId: string;
-  readonly headHash: SearchLedgerHash | 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 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 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;
-  readonly kind: 'search-history-receipt';
-  readonly digestAlgorithm: typeof SEARCH_HISTORY_RECEIPT_DIGEST_ALGORITHM;
-  readonly receiptDigest: SearchLedgerHash;
-  /** Stable producer identity, for example an OptimizationMethod name. */
-  readonly producerId: string;
-  /** 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;
-  /** `hashCanonical` of the complete `SearchAudit` from replaying those bytes. */
-  readonly auditDigest: SearchLedgerHash;
-  readonly summary: SearchHistoryAuditSummary;
-  readonly complete: boolean;
-  readonly incompleteReasons: readonly string[];
-}
-interface CreateSearchHistoryReceiptInput {
-  readonly producerId: string;
-  readonly runId: string;
-  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 closed search ledger. */
-  searchHistoryPolicy?: SearchHistoryPolicy;
-  /** Receipt checks are the default. Ledger checks also resolve and replay the bytes. */
-  searchHistoryVerification?: 'receipt' | 'ledger';
-}
-/** 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;
-  readonly status: 'complete' | 'incomplete' | 'missing';
-  readonly reasons: readonly string[];
-  readonly stages?: readonly SearchHistoryCoverageRow[];
-  readonly receipt?: SearchHistoryReceipt;
-  /** Present only after the referenced bytes and replay were verified. */
-  readonly ledgerVerified?: true;
-}
-interface SearchHistoryCoverage {
-  readonly policy: SearchHistoryPolicy;
-  readonly allComplete: boolean;
-  readonly producers: readonly SearchHistoryCoverageRow[];
-}
-declare class SearchHistoryRequiredError extends Error {
-  readonly producerId: string;
-  readonly reasons: readonly string[];
-  constructor(producerId: string, reasons: readonly string[]);
-}
-/** Verify a receipt's own consistency and digest. */
-declare function verifySearchHistoryReceipt(receipt: SearchHistoryReceipt): SearchHistoryReceipt;
-/** 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/search-ledger-recording.d.ts
-/** 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: SearchOperationRecordedEvent['execution'];
-  /** The code that runs the search and decides its nodes. */
-  search: SearchSourceRef;
-  /** 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;
-}
-/** 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;
-}
-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 AllocateSearchCellInput {
-  nodeId: string;
-  taskId: string;
-  split: SearchSplit;
-  rep: number;
-  stage: SearchCellStage;
-  lane?: string | null;
-  reservation?: SearchReservation | null;
-}
-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 lastStampMs;
-  private constructor();
-  /**
-   * Open the search: append `search-opened`, or, when the ledger already holds
-   * one, check that it is this search and continue it.
-   */
-  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;
-  /**
-   * 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;
-    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;
-    /** 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[];
-  }): 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;
-  }): SearchHistoryReceipt;
-  private append;
-  /** Non-decreasing ISO stamps; the ledger refuses an event that moves back. */
-  private stamp;
-}
-/** 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/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 has a scored cell on `split` and none of its cells
-   * there ran and ended unscored. A node that dodged a unit cannot lead; cells
-   * still to run, such as a rung the allocator just opened, do not count. */
-  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 dodged no
- * unit takes the lead when it scored every unit the leader scored and its mean
- * on them beats the leader's. A node measured on fewer units than the leader,
- * such as one an allocator has only screened, cannot take the lead on less
- * evidence than the leader holds. 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`. */
@@ -887,7 +405,11 @@ interface RunOptimizationBaseOptions<TScenario extends Scenario, TArtifact> exte
   }) => Promise<ReadonlyArray<ProposalFinding>>;
   /** 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. */
+   *  the parent from the Pareto frontier instead; `aide()` drafts, debugs and
+   *  improves with Thompson-sampled parents, and `beam({ width })` expands the
+   *  top nodes in turn. Every policy ranks on the scenarios, and the run keeps
+   *  the `uniform` allocator, because the proposer reads every candidate's
+   *  score on every scenario. */
   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
@@ -2318,97 +1840,6 @@ 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;
-}
-/** What an allocator reads when it decides. */
-interface SearchAllocationView {
-  readonly state: SearchStateView;
-  /** True when no cell allocated to the node can still run: each one ended
-   * scored, failed, cancelled or out of attempts. */
-  idle(nodeId: string): boolean;
-}
-/** A rank decision an allocator asks the kernel to record. */
-interface SearchRungDecision {
-  nodeId: string;
-  decision: {
-    status: 'advanced';
-    rung: number;
-  } | {
-    status: 'pruned';
-  };
-  /** The node against the root on the ranked split, as it stood at the decision. */
-  basis: NodeEstimate | null;
-  rule: string;
-  reason: string;
-}
-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 through `rung`. The kernel allocates the ones
-   * missing; a node that was never advanced is at rung 0. */
-  plan(state: SearchStateView, nodeId: string, rung: number): 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;
-  /** Nodes the evidence now moves to a further rung, deepest rung first. The
-   * kernel records each one the budget admits and allocates its rung. */
-  advance(view: SearchAllocationView): SearchRungDecision[];
-  /** At close: nodes left waiting below the top rung, decided `pruned` with
-   * their rank. `keep`, the node the search keeps, is never pruned. */
-  prune(view: SearchAllocationView, keep: string): SearchRungDecision[];
-}
-/**
- * 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. It has one rung, so it never advances or
- * prunes a node.
- */
-declare function uniform(options?: {
-  reps?: number;
-}): SearchAllocator;
-interface AshaOptions {
-  /** Units of the first rung. Default 6, `minimumPairsForPairedDeltaTest(0.95)`:
-   * the fewest shared units a paired contrast needs, so every screened edge
-   * gets one. */
-  units?: number;
-  /** Reduction factor: a node advances when it ranks in the top 1/eta of the
-   * nodes that finished its rung. Default 3. */
-  eta?: number;
-  /** Train units every non-root node also runs, as the proposer's feedback.
-   * They never enter a rank. Default 2. */
-  trainUnits?: number;
-  /** Repeats per task. Default 1. */
-  reps?: number;
-}
-/**
- * Asynchronous successive halving (Li et al., 2020) over one seeded
- * permutation of the ranked split's units, fixed by the search's seed.
- *
- * Rung k is the first `units × 2^k` units of the permutation; the top rung is
- * every unit. The root runs every unit before anything else, so every rung
- * pairs against it. A new node screens on rung 0 plus `trainUnits` train
- * units. Every node at a rung runs the same units as its parent, the root and
- * its siblings, so every contrast pairs.
- *
- * A node that finished rung k advances once it ranks in the top
- * floor(n / eta) of the n nodes that finished rung k, the root included, by
- * mean over the rung's units; a node with an unscored unit ranks last and
- * never advances. There is no barrier: a node outside the top waits, because
- * the set grows as more nodes finish. At close a waiting node is pruned with
- * its rank. The ranked split is selection, or train when a search declares no
- * selection split, as the policy's.
- */
-declare function asha(options?: AshaOptions): SearchAllocator;
-//#endregion
 //#region src/campaign/analyst-surface.d.ts
 interface TraceAnalystScenario extends Scenario {
   kind: 'trace-analyst';
@@ -2702,89 +2133,6 @@ 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 {
@@ -2934,10 +2282,17 @@ interface ExternalSearchRecordInput {
  * 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.
+ *
+ * A composed recipe reports no population: pass `population: null` and GEPA's
+ * returned best as `selected`, and every evaluated candidate enters with an
+ * `unknown` edge, as SkillOpt's do.
  */
-declare function recordGepaSearch(input: ExternalSearchRecordInput & {
+declare function recordGepaSearch(input: ExternalSearchRecordInput & ({
   population: GepaCandidatePopulationArtifact;
-}): Promise<SearchHistoryReceipt>;
+} | {
+  population: null;
+  selected: MutableSurface;
+})): Promise<SearchHistoryReceipt>;
 /**
  * Write SkillOpt's finished search into its ledger: the baseline as the seeded
  * root, every candidate SkillOpt evaluated as a node with an `unknown` edge
@@ -3770,288 +3125,26 @@ 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[];
-};
-/** Whether a closed search's claim is the one its own ledger supports. */
-type SearchClaimVerification = {
-  status: 'verified';
-} |
-/** The claim differs from the one the claim rule makes from the ledger. */
-{
-  status: 'mismatch';
-  differences: string[];
-} |
-/** The claim names a rule revision this code does not implement, so this
- * code can neither confirm nor refute it. */
-{
-  status: 'unknown';
-  reason: string;
-};
+//#region src/campaign/search-campaign-cell.d.ts
 /**
- * Make a closed search's claim again from its ledger alone and compare it with
- * the recorded one, byte for byte: the power check, the finalists, each
- * finalist's test estimate and deciding interval, the selection, the decision
- * and the reason. A producer's claim is not evidence until this holds; a store
- * keeps what this function derives, not what the producer wrote.
- *
- * It needs no blob, so it works on a store that keeps digests only. The
- * finalists are the nodes the ledger decided `finalist`, in decision order.
- * The one input the ledger cannot replay is whether the budget covered k
- * finalists' test cells; the claim cells that ran answer it (none ran: the
- * budget covered none). Test repeats come from the claim cells too; without
- * test cells, the recorded estimator stands for them (binary needs one repeat,
- * so any other count reproduces continuous).
- *
- * Returns null for a search that made no claim.
+ * What `cell-settled` records for one campaign cell: `passed` with the
+ * composite (and each judge's) when every judge scored it, else `errored`,
+ * never retryable, because `runCampaign` already applied its own retry policy;
+ * its tokens and cost, with an uncaptured cost kept as a lower bound; the
+ * model the cell resolved, else the declared one.
  */
-declare function verifySearchClaim(state: SearchStateView): SearchClaimVerification | null;
-//#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;
+declare function campaignCellSearchResult<TArtifact>(cell: CampaignCellResult<TArtifact>, input: {
+  execution: SearchExecutionIdentity;
   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;
-  /** The claim made again from the ledger alone (`verifySearchClaim`): never
-   * `mismatch`, which `runSearch` throws; `unknown` for a claim another rule
-   * revision made; null without a claim. */
-  claimVerification: SearchClaimVerification | 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.
- * `maxAttempts` (default 3, the kernel's) says when an errored cell has no
- * attempt left, which makes its unit a dodge.
- */
-declare function searchPolicyView(state: SearchStateView, input: {
-  screened: readonly string[];
-  screening: number;
-  expansions: number;
-  maxAttempts?: 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;
+}): SearchCellResult;
+/** A provider-reported model: a snapshot when its name pins one, else a moving alias. */
+declare function searchModelIdentity(model: string, provider: string): SearchModelIdentity;
+/** The accounting of a proposal's cost receipts: token and dollar sums, each
+ * unknown (with the known dollars as a lower bound) when a receipt lacks it. */
+declare function searchReceiptAccounting(receipts: ReadonlyArray<CostReceipt>): SearchAttemptAccounting;
+/** What ran a proposal: a model when it made a paid call other than a judge's,
+ * else deterministic code. */
+declare function searchProposalExecution(receipts: ReadonlyArray<CostReceipt>, provider: string, source: SearchOperationRecordedEvent['execution']['source']): SearchOperationRecordedEvent['execution'];
 //#endregion
 //#region src/campaign/single-run-lock.d.ts
 /**
@@ -4238,5 +3331,5 @@ declare function verifyCodeSurface(surface: CodeSurface, worktreeDir?: string):
  *  identity against the checkout at `worktreeRef`. */
 declare function resolveWorktreePath(surface: CodeSurface, worktreeDir?: string): string;
 //#endregion
-export { scoreDiscrimination as $, SettleSearchCellInput as $a, OptimizationMethodRunOptions as $i, CrossSurfaceCandidateEvidence as $n, FinalEvidencePolicy as $o, verifyLoopProvenanceRecord as $r, createLlmCorrectnessChecker as $t, SearchExecutor as A, isTransientTransportFailure as Aa, GepaEngineOptions as Ai, LoadEvalFixtureScenariosOptions as An, OpenAutoPrOptions as Ao, SearchAllocationView as Ar, RunProfileMatrixOptions as At, searchExpansionIndex as B, SearchExpansion as Ba, ExternalTextOptimizerContext as Bi, estimateNode as Bn, CampaignRunPlanCell as Bo, LoopProvenanceBackend as Br, RuntimeEventLike as Bt, SingleRunLockOptions as C, ReferenceEquivalenceScenario as Ca, runCanaries as Ci, neutralizationGate as Cn, openSearchLedger as Co, CrossSurfaceTaskRow as Cr, renderScoreboardMarkdown as Ct, SearchArtifactCodec as D, LlmJudgeOptions as Da, SkillOptTrainerConfig as Di, EvalFixtureRunPlan as Dn, SearchLedgerConflictError as Do, buildTraceAnalystSurfaceDispatch as Dr, ProfileDispatchFn as Dt, SEARCH_KERNEL_SOURCE as E, LlmJudgeDimension as Ea, SkillOptRunnerCommand as Ei, EvalFixtureLoadOptions as En, validateSearchLedgerEvent as Eo, TraceAnalystScenario as Er, userStoryScoreboard as Et, SearchProposedChild as F, runImprovementLoop as Fa, gepaOptimizationMethod as Fi, planEvalFixtureRun as Fn, CampaignCellFailureReceipt as Fo, uniform as Fr, BackendIntegrityReport as Ft, SearchClaimPlan as G, AllocateSearchCellInput as Ga, CompareOptimizationMethodsOptions as Gi, AnalyzeCrossSurfaceInteractionsInput as Gn, readCachedCell as Go, buildLoopProvenanceRecord as Gr, CorrectnessChecker as Gt, PlanSearchClaimInput as H, SearchPolicyView as Ha, ExternalOptimizationExample as Hi, searchCellSetDigest as Hn, planCampaignRun as Ho, LoopProvenanceEvidence as Hr, extractProducedState as Ht, SearchProposerPort as I, PremeasuredOptimizationBaseline as Ia, OpenAICompatibleOptimizerModel as Ii, EstimateNodeCellsInput as In, CampaignCellRetryPolicy as Io, BuildLoopProvenanceArgs as Ir, assertRealBackend as It, planSearchClaim as J, SearchLedgerBinding as Ja, OptimizationMethodComposition as Ji, CrossSurfaceAttemptCompleteness as Jn, cellCachePath as Jo, emitLoopProvenance as Jr, ProducedState as Jt, SearchClaimVerification as K, RecordSearchEdgeInput as Ka, OptimizationMethod as Ki, CrossSurfaceAdditionDecision as Kn, CellScheduleSlot as Ko, campaignMeasurementDigest as Kr, LlmCorrectnessCheckerOpts as Kt, SearchRunResult as L, RunOptimizationOptions as La, OptimizerModelBudget as Li, NodePosterior as Ln, RunCampaignOptions as Lo, EmitLoopProvenanceArgs as Lr, summarizeBackendIntegrity as Lt, SearchProposalBlob as M, transientDispatchFailure as Ma, GepaOptimizationMethodConfig as Mi, discoverEvalFixtures as Mn, openAutoPr as Mo, SearchCellPlan as Mr, ScenarioRollup as Mt, SearchProposalRequest as N, RunImprovementLoopOptions as Na, GepaOptimizationRecipe as Ni, loadEvalFixture as Nn, RunEvalOptions as No, SearchRungDecision as Nr, runProfileMatrix as Nt, SearchCellResult as O, llmJudge as Oa, skillOptOptimizationMethod as Oi, EvalFixtureScenario as On, SearchLedgerError as Oo, traceAnalystQualityJudge as Or, ProfileMatrixError as Ot, SearchProposalResult as P, RunImprovementLoopResult as Pa, GepaRunnerCommand as Pi, loadEvalFixtureScenarios as Pn, runEval as Po, asha as Pr, BackendIntegrityError as Pt, ScenarioSignal as Q, SearchRunIdentity as Qa, OptimizationMethodResult as Qi, CrossSurfaceCandidateComparison as Qn, inMemoryCampaignStorage as Qo, provenanceSpansPath as Qr, completionVerdict as Qt, runSearch as R, RunOptimizationResult as Ra, externalTextOptimizationMethod as Ri, SEARCH_ESTIMATOR as Rn, runCampaign as Ro, EmitLoopProvenanceResult as Rr, ArtifactEventLike as Rt, SingleRunLock as S, ReferenceEquivalenceJudgeResult as Sa, CanaryReport as Si, NeutralizationGateOptions as Sn, SearchLedgerTrustedHeadMode as So, CrossSurfaceSelections as Sr, makePlaybackDispatch as St, RunSearchOptions as T, runReferenceEquivalenceJudge as Ta, SkillOptOptimizationMethodConfig as Ti, EvalFixtureFile as Tn, replaySearchLedgerText as To, TraceAnalystArtifact as Tr, scoreboardSummary as Tt, SEARCH_CLAIM_RULE as U, crowdedFrontierParent as Ua, ExternalTextEvaluationResponse as Ui, searchPosterior as Un, CacheIssueReason as Uo, LoopProvenanceOptimizationMethod as Ur, CompletionRequirement as Ut, searchPolicyView as V, SearchPolicy as Va, ExternalTextOptimizerResult as Vi, estimateNodeFromCells as Vn, PlanCampaignRunOptions as Vo, LoopProvenanceCandidate as Vr, ToolCallEventLike as Vt, SearchClaimDecision as W, incumbent as Wa, decodeExternalTextCandidate as Wi, analyzeCrossSurfaceInteractions as Wn, CacheRead as Wo, LoopProvenanceRecord as Wr, CompletionVerdict as Wt, verifySearchClaim as X, SearchRecorder as Xa, OptimizationMethodPairwise as Xi, CrossSurfaceBootstrapPolicy as Xn, createRunCostLedger as Xo, loopProvenanceSpans as Xr, SatisfiedBy as Xt, searchClaimReserveUsd as Y, SearchOpening as Ya, OptimizationMethodInput as Yi, CrossSurfaceBestSingleSelection as Yn, CampaignStorage as Yo, loopProvenanceArgsFromResult as Yr, RequirementCheck as Yt, DiscriminationScore as Z, SearchRecorderOptions as Za, OptimizationMethodProvenance as Zi, CrossSurfaceCandidate as Zn, fsCampaignStorage as Zo, provenanceRecordPath as Zr, TaskGold as Zt, componentSurfaceIdentityMaterial as _, readExternalOptimizerObservationArtifact as _a, scoreRedTeamOutput as _i, externalSurface as _n, verifySearchHistoryReceipt as _o, CrossSurfacePairIncompatibilityReason as _r, ScoreboardRenderOptions as _t, WorktreeAdapterError as a, ComparisonCost as aa, heldOutGate as ai, FsLabeledScenarioStoreOptions as an, SearchHistoryAdmissionOptions as ao, CrossSurfaceDistribution as ar, campaignSplitDigestFromIdentities as as, FinalizedProfileMatrixResult as at, surfaceDispatchRef as b, ReferenceEquivalenceJudgeInput as ba, CanaryKind as bi, recordGepaSearch as bn, SearchLedger as bo, CrossSurfaceRelativeCost as br, UserStory as bt, verifyCodeSurface as c, GepaCandidatePopulationArtifact as ca, DefaultProductionRewardHackingOptions as ci, RolloutArgumentDiffOptions as cn, SearchHistoryCoverageRow as co, CrossSurfaceIneligibilityReason as cr, ProfileMatrixRow as ct, PhoenixEvaluationResultLike as d, GepaCandidateSelectionScore as da, RedTeamCase as di, UngroundedLiteralReport as dn, SearchHistoryRequiredError as do, CrossSurfaceInteractionPath as dr, createProfileMatrixPlan as dt, OptimizationMethodScore as ea, CampaignBreakdown as ei, verifyCompletion as en, developmentClaim as eo, CrossSurfaceCandidateOutcome as er, FinalEvidenceUse as es, selectDiscriminative as et, PhoenixEvaluatorLike as f, readGepaCandidatePopulationArtifact as fa, RedTeamCategory as fi, classifyUngroundedLiterals as fn, assertCompleteSearchHistory as fo, CrossSurfaceInteractionReport as fr, finalizeProfileMatrix as ft, codeSurfaceIdentityMaterial as g, ExternalOptimizerSubmittedCandidate as ga, redTeamReport as gi, GepaPopulationImport as gn, verifySearchHistoryArtifact as go, CrossSurfacePairEvidence as gr, PlaybackStep as gt, assertCodeSurfaceIdentity as h, ExternalOptimizerObservationSummary as ha, redTeamDataset as hi, GepaEvaluationImport as hn, searchHistoryCoverageRow as ho, CrossSurfacePairCompatibility as hr, PlaybackDriver as ht, WorktreeAdapter as i, optimizationTokenUsageFromSummary as ia, HeldOutGateOptions as ii, FsLabeledScenarioStore as in, CreateSearchHistoryReceiptInput as io, CrossSurfaceCompositionStep as ir, campaignSplitDigest as is, FinalizeProfileMatrixOptions as it, SearchLane as j, quotaExhaustedUntil as ja, GepaEngineRun as ji, PlanEvalFixtureRunOptions as jn, OpenAutoPrResult as jo, SearchAllocator as jr, RunProfileMatrixResult as jt, SearchCellWork as k, TransientFailureOptions as ka, GepaAdaptiveEngineRun as ki, EvalFixtureValidationMode as kn, SearchLedgerIntegrityError as ko, AshaOptions as kr, ProfileSummary as kt, AutoevalsScoreLike as l, GepaCandidatePopulationCandidate as la, defaultProductionGate as li, RolloutCall as ln, SearchHistoryPolicy as lo, CrossSurfaceInteractionAwareSelection as lr, ProfileMatrixSegmentResult as lt, phoenixEvaluatorJudge as m, ExternalOptimizerObservationArtifact as ma, RedTeamReport as mi, ExternalSearchOptimizer as mn, createSearchHistoryReceipt as mo, CrossSurfaceNaiveStackSelection as mr, PlaybackContext as mt, GitWorktreeAdapterOptions as n, OptimizationTokenUsage as na, campaignBreakdown as ni, sequentialOptimizationMethod as nn, surfaceDiff as no, CrossSurfaceComponent as nr, assertCampaignSplitIdentity as ns, tangleTracesRoot as nt, gitWorktreeAdapter as o, combineComparisonCosts as oa, DefaultProductionGateCheck as oi, LabeledScenarioStoreError as on, SearchHistoryAuditSummary as oo, CrossSurfaceEligibility as or, ProfileMatrixCoverage as ot, autoevalsScorerJudge as p, ExternalOptimizerExecutionSummary as pa, RedTeamFinding as pi, rolloutArgumentDiff as pn, assertSearchHistoryMatchesState as po, CrossSurfaceInteractionTask as pr, runProfileMatrixSegment as pt, decideSearchClaim as q, RegisterSearchNodeInput as qa, OptimizationMethodComparison as qi, CrossSurfaceAdditionRejectionReason as qn, buildCellSchedule as qo, canonicalDigest as qr, ProducedProposal as qt, Worktree as r, compareOptimizationMethods as ra, campaignMeanComposite as ri, neutralizeText as rn, surfaceNode as ro, CrossSurfaceComponentEvidence as rr, campaignScenarioIdentity as rs, CreateProfileMatrixPlanOptions as rt, resolveWorktreePath as s, costFromLedgerSummary as sa, DefaultProductionGateOptions as si, RolloutArgumentDiff as sn, SearchHistoryCoverage as so, CrossSurfaceEvidenceBreakdown as sr, ProfileMatrixPlan as st, CodeSurfaceVerification as t, OptimizationPackageSource as ta, CampaignComparisonUnits as ti, scopedOptimizationMethod as tn, searchEdgeId as to, CrossSurfaceCandidateSummary as tr, assertCampaignDesign as ts, resolveRunDir as tt, AutoevalsScorerLike as u, GepaCandidatePopulationSummary as ua, DEFAULT_RED_TEAM_CORPUS as ui, ScoredRollout as un, SearchHistoryReceipt as uo, CrossSurfaceInteractionEffect as ur, RunProfileMatrixSegmentOptions as ut, renderSurfaceDiff as v, REFERENCE_EQUIVALENCE_INPUT_LIMITS as va, CanaryAlert as vi, importExternalEvaluations as vn, FileSearchLedger as vo, CrossSurfacePairwiseEntry as vr, ScoreboardRow as vt, acquireSingleRunLock as w, createReferenceEquivalenceJudge as wa, composeGate as wi, EvalFixture as wn, parseSearchLedgerLine as wo, BuildTraceAnalystSurfaceDispatchOptions as wr, scoreUserStory as wt, surfaceHash as x, ReferenceEquivalenceJudgeOptions as xa, CanaryOptions as xi, recordSkillOptSearch as xn, SearchLedgerAppendResult as xo, CrossSurfaceSelectionPolicy as xr, UserStoryVerdict as xt, surfaceContentHash as y, REFERENCE_EQUIVALENCE_JUDGE_VERSION as ya, CanaryEvaluation as yi, importGepaPopulation as yn, OpenSearchLedgerOptions as yo, CrossSurfaceRankedSingle as yr, ScoreboardSummary as yt, searchDivergence as z, runOptimization as za, ExternalTextOptimizationMethodConfig as zi, SearchPosterior as zn, CampaignRunPlan as zo, LoopProvenanceArgsFromResult as zr, ProposalEventLike as zt };
-//# sourceMappingURL=index-CigojbNH.d.ts.map
+export { UserStoryVerdict as $, PremeasuredOptimizationBaseline as $i, BuildLoopProvenanceArgs as $n, OpenAICompatibleOptimizerModel as $r, recordSkillOptSearch as $t, ScenarioSignal as A, campaignSplitDigest as Aa, ExternalOptimizerExecutionSummary as Ai, CrossSurfaceEligibility as An, RedTeamFinding as Ar, completionVerdict as At, ProfileMatrixRow as B, ReferenceEquivalenceScenario as Bi, CrossSurfacePairEvidence as Bn, runCanaries as Br, RolloutArgumentDiffOptions as Bt, SingleRunLockOptions as C, buildCellSchedule as Ca, combineComparisonCosts as Ci, CrossSurfaceCandidateEvidence as Cn, DefaultProductionGateCheck as Cr, CorrectnessChecker as Ct, searchProposalExecution as D, assertCampaignDesign as Da, GepaCandidatePopulationSummary as Di, CrossSurfaceComponentEvidence as Dn, DEFAULT_RED_TEAM_CORPUS as Dr, RequirementCheck as Dt, searchModelIdentity as E, FinalEvidenceUse as Ea, GepaCandidatePopulationCandidate as Ei, CrossSurfaceComponent as En, defaultProductionGate as Er, ProducedState as Et, CreateProfileMatrixPlanOptions as F, REFERENCE_EQUIVALENCE_INPUT_LIMITS as Fi, CrossSurfaceInteractionPath as Fn, CanaryAlert as Fr, neutralizeText as Ft, runProfileMatrixSegment as G, llmJudge as Gi, CrossSurfaceSelectionPolicy as Gn, skillOptOptimizationMethod as Gr, rolloutArgumentDiff as Gt, RunProfileMatrixSegmentOptions as H, runReferenceEquivalenceJudge as Hi, CrossSurfacePairwiseEntry as Hn, SkillOptOptimizationMethodConfig as Hr, ScoredRollout as Ht, FinalizeProfileMatrixOptions as I, REFERENCE_EQUIVALENCE_JUDGE_VERSION as Ii, CrossSurfaceInteractionReport as In, CanaryEvaluation as Ir, FsLabeledScenarioStore as It, PlaybackStep as J, quotaExhaustedUntil as Ji, BuildTraceAnalystSurfaceDispatchOptions as Jn, GepaEngineRun as Jr, GepaPopulationImport as Jt, PlaybackContext as K, TransientFailureOptions as Ki, CrossSurfaceSelections as Kn, GepaAdaptiveEngineRun as Kr, ExternalSearchOptimizer as Kt, FinalizedProfileMatrixResult as L, ReferenceEquivalenceJudgeInput as Li, CrossSurfaceInteractionTask as Ln, CanaryKind as Lr, FsLabeledScenarioStoreOptions as Lt, selectDiscriminative as M, ExternalOptimizerObservationSummary as Mi, CrossSurfaceIneligibilityReason as Mn, redTeamDataset as Mr, verifyCompletion as Mt, resolveRunDir as N, ExternalOptimizerSubmittedCandidate as Ni, CrossSurfaceInteractionAwareSelection as Nn, redTeamReport as Nr, scopedOptimizationMethod as Nt, searchReceiptAccounting as O, assertCampaignSplitIdentity as Oa, GepaCandidateSelectionScore as Oi, CrossSurfaceCompositionStep as On, RedTeamCase as Or, SatisfiedBy as Ot, tangleTracesRoot as P, readExternalOptimizerObservationArtifact as Pi, CrossSurfaceInteractionEffect as Pn, scoreRedTeamOutput as Pr, sequentialOptimizationMethod as Pt, UserStory as Q, runImprovementLoop as Qi, traceAnalystQualityJudge as Qn, gepaOptimizationMethod as Qr, recordGepaSearch as Qt, ProfileMatrixCoverage as R, ReferenceEquivalenceJudgeOptions as Ri, CrossSurfaceNaiveStackSelection as Rn, CanaryOptions as Rr, LabeledScenarioStoreError as Rt, SingleRunLock as S, CellScheduleSlot as Sa, ComparisonCost as Si, CrossSurfaceCandidateComparison as Sn, heldOutGate as Sr, CompletionVerdict as St, campaignCellSearchResult as T, FinalEvidencePolicy as Ta, GepaCandidatePopulationArtifact as Ti, CrossSurfaceCandidateSummary as Tn, DefaultProductionRewardHackingOptions as Tr, ProducedProposal as Tt, createProfileMatrixPlan as U, LlmJudgeDimension as Ui, CrossSurfaceRankedSingle as Un, SkillOptRunnerCommand as Ur, UngroundedLiteralReport as Ut, ProfileMatrixSegmentResult as V, createReferenceEquivalenceJudge as Vi, CrossSurfacePairIncompatibilityReason as Vn, composeGate as Vr, RolloutCall as Vt, finalizeProfileMatrix as W, LlmJudgeOptions as Wi, CrossSurfaceRelativeCost as Wn, SkillOptTrainerConfig as Wr, classifyUngroundedLiterals as Wt, ScoreboardRow as X, RunImprovementLoopOptions as Xi, TraceAnalystScenario as Xn, GepaOptimizationRecipe as Xr, importExternalEvaluations as Xt, ScoreboardRenderOptions as Y, transientDispatchFailure as Yi, TraceAnalystArtifact as Yn, GepaOptimizationMethodConfig as Yr, externalSurface as Yt, ScoreboardSummary as Z, RunImprovementLoopResult as Zi, buildTraceAnalystSurfaceDispatch as Zn, GepaRunnerCommand as Zr, importGepaPopulation as Zt, componentSurfaceIdentityMaterial as _, PlanCampaignRunOptions as _a, OptimizationMethodScore as _i, CrossSurfaceAdditionRejectionReason as _n, CampaignBreakdown as _r, ProposalEventLike as _t, WorktreeAdapterError as a, SearchLedgerIntegrityError as aa, ExternalOptimizationExample as ai, EvalFixtureRunPlan as an, LoopProvenanceEvidence as ar, ProfileDispatchFn as at, surfaceDispatchRef as b, CacheRead as ba, compareOptimizationMethods as bi, CrossSurfaceBootstrapPolicy as bn, campaignMeanComposite as br, extractProducedState as bt, verifyCodeSurface as c, openAutoPr as ca, CompareOptimizationMethodsOptions as ci, LoadEvalFixtureScenariosOptions as cn, buildLoopProvenanceRecord as cr, RunProfileMatrixOptions as ct, PhoenixEvaluationResultLike as d, CampaignCellFailureReceipt as da, OptimizationMethodComposition as di, loadEvalFixture as dn, emitLoopProvenance as dr, runProfileMatrix as dt, RunOptimizationOptions as ea, OptimizerModelBudget as ei, NeutralizationGateOptions as en, EmitLoopProvenanceArgs as er, makePlaybackDispatch as et, PhoenixEvaluatorLike as f, CampaignCellRetryPolicy as fa, OptimizationMethodInput as fi, loadEvalFixtureScenarios as fn, loopProvenanceArgsFromResult as fr, BackendIntegrityError as ft, codeSurfaceIdentityMaterial as g, CampaignRunPlanCell as ga, OptimizationMethodRunOptions as gi, CrossSurfaceAdditionDecision as gn, verifyLoopProvenanceRecord as gr, ArtifactEventLike as gt, assertCodeSurfaceIdentity as h, CampaignRunPlan as ha, OptimizationMethodResult as hi, AnalyzeCrossSurfaceInteractionsInput as hn, provenanceSpansPath as hr, summarizeBackendIntegrity as ht, WorktreeAdapter as i, SearchLedgerError as ia, ExternalTextOptimizerResult as ii, EvalFixtureLoadOptions as in, LoopProvenanceCandidate as ir, userStoryScoreboard as it, scoreDiscrimination as j, campaignSplitDigestFromIdentities as ja, ExternalOptimizerObservationArtifact as ji, CrossSurfaceEvidenceBreakdown as jn, RedTeamReport as jr, createLlmCorrectnessChecker as jt, DiscriminationScore as k, campaignScenarioIdentity as ka, readGepaCandidatePopulationArtifact as ki, CrossSurfaceDistribution as kn, RedTeamCategory as kr, TaskGold as kt, AutoevalsScoreLike as l, RunEvalOptions as la, OptimizationMethod as li, PlanEvalFixtureRunOptions as ln, campaignMeasurementDigest as lr, RunProfileMatrixResult as lt, phoenixEvaluatorJudge as m, runCampaign as ma, OptimizationMethodProvenance as mi, analyzeCrossSurfaceInteractions as mn, provenanceRecordPath as mr, assertRealBackend as mt, GitWorktreeAdapterOptions as n, runOptimization as na, ExternalTextOptimizationMethodConfig as ni, EvalFixture as nn, LoopProvenanceArgsFromResult as nr, scoreUserStory as nt, gitWorktreeAdapter as o, OpenAutoPrOptions as oa, ExternalTextEvaluationResponse as oi, EvalFixtureScenario as on, LoopProvenanceOptimizationMethod as or, ProfileMatrixError as ot, autoevalsScorerJudge as p, RunCampaignOptions as pa, OptimizationMethodPairwise as pi, planEvalFixtureRun as pn, loopProvenanceSpans as pr, BackendIntegrityReport as pt, PlaybackDriver as q, isTransientTransportFailure as qi, CrossSurfaceTaskRow as qn, GepaEngineOptions as qr, GepaEvaluationImport as qt, Worktree as r, SearchLedgerConflictError as ra, ExternalTextOptimizerContext as ri, EvalFixtureFile as rn, LoopProvenanceBackend as rr, scoreboardSummary as rt, resolveWorktreePath as s, OpenAutoPrResult as sa, decodeExternalTextCandidate as si, EvalFixtureValidationMode as sn, LoopProvenanceRecord as sr, ProfileSummary as st, CodeSurfaceVerification as t, RunOptimizationResult as ta, externalTextOptimizationMethod as ti, neutralizationGate as tn, EmitLoopProvenanceResult as tr, renderScoreboardMarkdown as tt, AutoevalsScorerLike as u, runEval as ua, OptimizationMethodComparison as ui, discoverEvalFixtures as un, canonicalDigest as ur, ScenarioRollup as ut, renderSurfaceDiff as v, planCampaignRun as va, OptimizationPackageSource as vi, CrossSurfaceAttemptCompleteness as vn, CampaignComparisonUnits as vr, RuntimeEventLike as vt, acquireSingleRunLock as w, cellCachePath as wa, costFromLedgerSummary as wi, CrossSurfaceCandidateOutcome as wn, DefaultProductionGateOptions as wr, LlmCorrectnessCheckerOpts as wt, surfaceHash as x, readCachedCell as xa, optimizationTokenUsageFromSummary as xi, CrossSurfaceCandidate as xn, HeldOutGateOptions as xr, CompletionRequirement as xt, surfaceContentHash as y, CacheIssueReason as ya, OptimizationTokenUsage as yi, CrossSurfaceBestSingleSelection as yn, campaignBreakdown as yr, ToolCallEventLike as yt, ProfileMatrixPlan as z, ReferenceEquivalenceJudgeResult as zi, CrossSurfacePairCompatibility as zn, CanaryReport as zr, RolloutArgumentDiff as zt };
+//# sourceMappingURL=index-BhoOCduB.d.ts.map