@tangle-network/agent-eval 0.191.0 → 0.192.0

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

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