@tangle-network/agent-eval 0.191.0 → 0.193.0

package/dist/{types-BmQRs661.d.ts → types-BWwRXofp.d.ts}

@@ -1,8 +1,317 @@
 import { S as PaidCallResult, T as RunPaidCallInput, a as CostChannel, c as CostLedgerHandle, f as CostLedgerSummary, p as CostProvenance } from "./cost-ledger-DbQdN3nO.js";
-import { d as RunTokenUsage } from "./run-record-DF-fuu31.js";
+import { d as RunTokenUsage, s as RunSearchCoordinates } from "./run-record-DF-fuu31.js";
 import { _ as ProposalFinding } from "./types-CeDfCRXp.js";
 import { M as LlmCallMetadata } from "./types-C0bWoSKC.js";
 import { t as SeriesDistribution } from "./descriptive-B2iPaT9J.js";
+import { A as SearchLedgerHash, G as SearchSplit, I as SearchNodeStatus, L as SearchOpenedEvent, N as SearchNodeDecision, O as SearchLedgerEntry, P as SearchNodeRef, Q as SearchTaskOutcome, R as SearchOperationKind, U as SearchReservation, Z as SearchTask, b as SearchClosedEvent, d as SearchCellCancelledEvent, i as SearchArtifactRef, l as SearchCandidateSurface, o as SearchAudit, p as SearchCellStage, t as NodeEstimate, w as SearchEdgeRecordedEvent, z as SearchOperationRecordedEvent } from "./search-ledger-types-B3El5xgS.js";
+import { p as LedgerProjector } from "./index-Bj96W0jZ.js";
+import { i as RolloutSearchLineage } from "./mint-C9Lojt1V.js";
+//#region src/campaign/search-state.d.ts
+/** Deterministic node id: identical content in one search is one node. */
+declare function searchNodeId(searchId: string, artifactDigest: string): string;
+/** Deterministic cell id: one node on one task in one split at one repeat. */
+declare function searchCellId(searchId: string, nodeId: string, taskId: string, split: SearchSplit, rep: number): string;
+/** Digest a split's task list in taskId order. */
+declare function searchTaskSetDigest(tasks: readonly SearchTask[]): SearchLedgerHash;
+interface SearchDecisionRecord {
+  sequence: number;
+  decision: SearchNodeDecision;
+  basis: NodeEstimate | null;
+  rule: string;
+  reason: string;
+}
+interface SearchSpend {
+  knownUsd: number;
+  floorUsd: number;
+  unknownCostCells: number;
+  boxMinutes: number;
+}
+/** Scores of one node on one unit of one split: the sum and count of its
+ * scored cells. Repeats and sibling tasks of the unit average inside it. */
+interface SearchUnitScore {
+  unitId: string;
+  sum: number;
+  count: number;
+  mean: number;
+}
+/** A cell's scored attempt: the inputs of every per-unit statistic. */
+interface SearchScoredCell {
+  cellId: string;
+  unitId: string;
+  /** The attempt that produced the score, which is the cell's last. */
+  attempt: number;
+  score: number;
+}
+/**
+ * Per-unit means of scored cells, in unitId order. Each unit sums its cells in
+ * cellId order, so the result depends on the set of cells alone, never on the
+ * order they settled in: a verifier that reads the same cells from a database
+ * gets the same bits.
+ */
+declare function searchUnitScores(cells: readonly SearchScoredCell[]): SearchUnitScore[];
+interface SearchNode {
+  nodeId: string;
+  /** Registration order; the root is 0. */
+  ordinal: number;
+  artifactDigest: SearchLedgerHash;
+  artifact: SearchArtifactRef;
+  surfaces: readonly SearchCandidateSurface[];
+  /** First in-search parent of the node's first edge; null for the root, a
+   * derived root, or a node whose parents are unknown. */
+  primaryParentId: string | null;
+  /** Edges from the root along primary parents; null while unknown. */
+  depth: number | null;
+  /** Every parent named by any edge into the node, in edge order. */
+  parents: readonly SearchNodeRef[];
+  children: readonly string[];
+  edgeIds: readonly string[];
+  status: SearchNodeStatus | null;
+  rung: number | null;
+  /** The node was decided `finalist` at some point, so its test cells are legal. */
+  finalist: boolean;
+  decisions: readonly SearchDecisionRecord[];
+  cellCount: number;
+  spend: SearchSpend;
+  registeredSequence: number;
+  updatedSequence: number;
+}
+interface SearchCell {
+  cellId: string;
+  nodeId: string;
+  taskId: string;
+  unitId: string;
+  split: SearchSplit;
+  rep: number;
+  stage: SearchCellStage;
+  lane: string | null;
+  reservation: SearchReservation | null;
+  attempts: number;
+  lastRunId: string | null;
+  outcome: SearchTaskOutcome['status'] | null;
+  /** Score of the scored attempt; null when no attempt was scored. */
+  score: number | null;
+  /** No further attempt is legal: a scored or non-retryable outcome. */
+  final: boolean;
+  cancelled: SearchCellCancelledEvent['reason'] | null;
+  /** Known cost plus proven floors across attempts. */
+  spentUsd: number;
+  /** Every attempt's cost is known. */
+  costKnown: boolean;
+  traceId: string | null;
+  allocatedSequence: number;
+  updatedSequence: number;
+}
+interface SearchOperation {
+  operationId: string;
+  operationKind: SearchOperationKind;
+  reservation: SearchReservation | null;
+  recorded: boolean;
+  /** The recorded outcome; null until the operation is recorded. */
+  outcome: SearchOperationRecordedEvent['outcome']['status'] | null;
+  /** Artifacts the started event bound, then those the recorded event bound,
+   * for example a claim's plan or a proposal's output. */
+  artifacts: readonly SearchArtifactRef[];
+  spentUsd: number;
+}
+interface SearchCompletion {
+  complete: boolean;
+  reasons: string[];
+}
+/**
+ * The pure, incremental projection of one search ledger. `apply` refuses any
+ * entry that breaks an invariant; the journal then discards this instance and
+ * replays into a new one, so a refused entry leaves no partial state behind.
+ */
+declare class SearchState implements LedgerProjector<SearchLedgerEntry, SearchStateView> {
+  readonly searchId: string;
+  private version;
+  private header;
+  private closed;
+  private head;
+  private lastOccurredAt;
+  private lastOccurredAtText;
+  private readonly tasks;
+  private readonly nodes;
+  private readonly nodeOrder;
+  private readonly nodeByDigest;
+  private readonly edges;
+  private readonly edgeOrder;
+  private readonly cells;
+  private readonly operations;
+  private selectedNodeId;
+  private claimUsedUsd;
+  /** Nodes ever decided `finalist`. */
+  private readonly finalists;
+  /** Claim cells allocated. Once one exists, the finalists are fixed. */
+  private claimCells;
+  private readonly audit;
+  constructor(searchId: string);
+  apply(entry: SearchLedgerEntry, index: number): void;
+  snapshot(): SearchStateView;
+  /** @internal Views check this before every read of the live indexes. */
+  isAt(version: number): boolean;
+  private applyEvent;
+  private open;
+  private startOperation;
+  private recordOperation;
+  private registerNode;
+  private recordEdge;
+  private allocateCell;
+  private settleCell;
+  private cancelCell;
+  private decideNode;
+  private close;
+  private checkClaim;
+  /** Once the first finalist is decided, the search only runs its claim:
+   * nothing new is proposed, registered or allocated outside the test. */
+  private assertSearching;
+  /** @internal */
+  incompleteReasons(): string[];
+  /** Book an attempt's or operation's accounting into the running totals. An
+   * unknown cost counts as its proven floor. */
+  private book;
+  /** A cell's share of the open reservations, its overspend, and what it draws
+   * from the claim reserve: the larger of its hold and its spend. */
+  private reservationParts;
+  /** The admission rule: committed spend, open holds, the unspent claim
+   * reserve and the new hold stay within the cap. A claim cell draws on the
+   * claim reserve instead of adding to it. */
+  private admit;
+  /** @internal 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 */
+  readClosed(): SearchClosedEvent | null;
+  /** @internal */
+  readHead(): {
+    sequence: number;
+    entryHash: SearchLedgerHash;
+  } | null;
+  /** @internal */
+  readLastOccurredAt(): string | null;
+  /** @internal */
+  readAudit(): SearchAudit;
+  /** @internal */
+  readNode(nodeId: string): SearchNode | undefined;
+  /** @internal */
+  readNodeIds(): readonly string[];
+  /** @internal */
+  readHasNode(nodeId: string): boolean;
+  /** @internal */
+  readNodeIdForDigest(artifactDigest: string): string | undefined;
+  /** @internal */
+  readEdge(edgeId: string): SearchEdgeRecordedEvent | undefined;
+  /** @internal */
+  readEdgeIds(): readonly string[];
+  /** @internal */
+  readCell(cellId: string): SearchCell | undefined;
+  /** @internal */
+  readCellIds(nodeId?: string): readonly string[];
+  /** @internal */
+  readOperation(operationId: string): SearchOperation | undefined;
+  /** @internal */
+  readScoredCells(nodeId: string, split: SearchSplit): SearchScoredCell[];
+}
+/**
+ * A read of `SearchState` at one ledger position. Header, head, audit and
+ * claim are values. Node, edge, cell and score reads go to the live indexes and
+ * throw once the state has applied a later entry.
+ */
+declare class SearchStateView {
+  readonly searchId: string;
+  readonly header: SearchOpenedEvent | null;
+  readonly closed: SearchClosedEvent | null;
+  readonly head: {
+    sequence: number;
+    entryHash: SearchLedgerHash;
+  } | null;
+  /** `occurredAt` of the head entry; a writer stamps later events at or after it. */
+  readonly lastOccurredAt: string | null;
+  readonly audit: SearchAudit;
+  readonly completion: SearchCompletion;
+  /**
+   * 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);
+  /** The node the search started from: the first registered. */
+  get rootNodeId(): string | null;
+  node(nodeId: string): SearchNode | undefined;
+  hasNode(nodeId: string): boolean;
+  /** Node ids in registration order. */
+  nodeIds(): string[];
+  /** Nodes in registration order. */
+  nodes(): SearchNode[];
+  nodeIdForDigest(artifactDigest: string): string | undefined;
+  edge(edgeId: string): SearchEdgeRecordedEvent | undefined;
+  /** Edges in ledger order. */
+  edges(): SearchEdgeRecordedEvent[];
+  cell(cellId: string): SearchCell | undefined;
+  /** Cells in allocation order, optionally of one node. */
+  cells(filter?: {
+    nodeId?: string;
+  }): SearchCell[];
+  operation(operationId: string): SearchOperation | undefined;
+  /** A node's scored cells on one split, in allocation order. Unscored cells
+   * (errored, cancelled or in flight) are absent, never zero. */
+  scoredCells(nodeId: string, split: SearchSplit): SearchScoredCell[];
+  /** Per-unit score means of a node on one split, in unitId order. */
+  unitScores(nodeId: string, split: SearchSplit): SearchUnitScore[];
+  /** The lineage a RunRecord mint needs for one cell attempt. */
+  lineage(coordinates: RunSearchCoordinates): RolloutSearchLineage;
+  private live;
+}
+//#endregion
+//#region src/campaign/search-summary.d.ts
+/** The proposer's own read of a search: its node's cells on the train split,
+ * the only split a proposer may ever see. */
+interface SearchProposerView {
+  readonly searchId: string;
+  readonly direction: 'maximize' | 'minimize';
+  /** `nodeId`'s scored train cells. Unscored cells (errored, cancelled or in
+   * flight) are absent, never zero. */
+  scoredCells(nodeId: string): readonly SearchScoredCell[];
+  /** Per-unit train-split means of `nodeId`, in unitId order. */
+  unitScores(nodeId: string): readonly SearchUnitScore[];
+}
+/** The train-only view `ProposeContext.train` carries. */
+declare function searchProposerView(state: SearchStateView): SearchProposerView;
+interface SearchSummaryOptions {
+  /**
+   * The split every estimate in the summary is computed on. A proposer's
+   * context must always pass `'train'`: the selection and test splits stay
+   * unread by anything a proposer's text can reach. The CLI passes the
+   * search's own ranking split, `'selection'` when the search declares one
+   * else `'train'`, matching `searchPolicyView`.
+   */
+  split: SearchSplit;
+  /** Nodes shown under "Leading" and under "Recently discarded". Default 5. */
+  limit?: number;
+}
+/**
+ * `SearchState` as compact text: a header line with the search's shape and
+ * spend, the leading nodes against the root with their estimates, the most
+ * recently discarded nodes with the measurement that discarded them, and a
+ * log of recent proposals (operator and label — the ledger's inline,
+ * redacted summary of each rationale; the full rationale is a blob this
+ * function never reads, so it stays a pure, I/O-free projection of the
+ * state already in hand).
+ */
+declare function renderSearchSummary(state: SearchStateView, options: SearchSummaryOptions): string;
+//#endregion
 //#region src/campaign/types.d.ts
 /** Stable identifier + kind tag for any scenario. Consumers
  *  extend with their per-domain payload (persona, task, requirement, ...). */
@@ -266,9 +575,30 @@ interface ScoredSurfaceOutcome {
 /** Search state supplied to one candidate-generation call.
  *  Final evaluation data is not represented in this contract. */
 interface ProposeContext<TFindings = ProposalFinding> {
-  /** The parent surface this proposal mutates: the global incumbent by
-   *  default, or the frontier parent a `selectParent` policy drew. */
+  /** The parent surface this proposal mutates: the node the search policy
+   *  chose (the incumbent by default). Equal to `parents[0].artifact` when
+   *  `parents` is present. */
   readonly currentSurface: MutableSurface;
+  /** How the child should derive from the parent: `improve` for a hill-climb
+   *  step; other policies ask for `draft`, `debug` or `merge`. Absent outside
+   *  a search. */
+  readonly operator?: 'draft' | 'improve' | 'debug' | 'merge';
+  /** Every parent the policy chose, primary first, with its artifact. A
+   *  `merge` proposal needs every parent; other operators name exactly one.
+   *  Absent outside a search. */
+  readonly parents?: ReadonlyArray<{
+    nodeId: string;
+    artifact: MutableSurface;
+  }>;
+  /** The proposer's own read of the search: its nodes' cells on the train
+   *  split only. Absent outside a search. See {@link SearchProposerView}. */
+  readonly train?: SearchProposerView;
+  /** `renderSearchSummary` of the search so far, computed on the train
+   *  split: the leading nodes, recently discarded ideas and recent proposals,
+   *  as compact text. Absent outside a search. */
+  readonly summary?: string;
+  /** One record per earlier proposal: its candidates' measurements and the
+   *  candidate that took the lead, if any. */
   readonly history: ReadonlyArray<GenerationRecord>;
   readonly findings: ReadonlyArray<TFindings>;
   /** BREADTH: how many candidate surfaces to return this generation. */
@@ -284,8 +614,8 @@ interface ProposeContext<TFindings = ProposalFinding> {
    *  candidate must beat to promote. `runOptimization` always supplies it. */
   readonly incumbentOutcome?: ScoredSurfaceOutcome;
   /** Measured result for `currentSurface`, the parent this proposal mutates.
-   *  Equal to `incumbentOutcome` unless the run draws parents from the Pareto
-   *  frontier through `selectParent`. `runOptimization` always supplies it. */
+   *  Equal to `incumbentOutcome` unless the policy draws parents from the Pareto
+   *  frontier. `runOptimization` always supplies it. */
   readonly parentOutcome?: ScoredSurfaceOutcome;
   /** DEPTH: max iterations the agentic generator may take per candidate.
    *  1 = single-shot; >1 = it may iterate on its own change before handing it
@@ -569,17 +899,10 @@ interface GenerationRecord {
  *  handled — the evidence a blind `Mutator` cannot see. */
 interface GenerationCandidate {
   surfaceHash: string;
-  /** Mean over complete task-quality scores, or null when none were produced. */
+  /** Mean over complete task-quality scores, or null when none were produced.
+   *  Lineage and paired contrasts live in the search ledger: read the node's
+   *  edges from its `SearchStateView` and its contrast from `estimateNode`. */
   composite: number | null;
-  /** Estimated interval for `composite`, or null when uncertainty was not estimated. */
-  ci95: [number, number] | null;
-  /** Exact surface this candidate mutated. */
-  parentSurfaceHash?: string;
-  /** Measured search-split composite of the exact parent surface. */
-  parentComposite?: number;
-  /** Candidate composite minus its parent's composite. Present only when the
-   *  candidate completed the designed denominator. */
-  observedDeltaFromParent?: number;
   /** Whether this candidate had a scorable result for every designed campaign
    *  cell and was therefore eligible for ranking, promotion, and Pareto
    *  selection. */
@@ -669,5 +992,5 @@ interface CampaignResult<TArtifact = unknown, TScenario extends Scenario = Scena
   scenarios: Array<CampaignScenarioIdentity & Pick<TScenario, 'id' | 'kind'>>;
 }
 //#endregion
-export { LabeledScenarioWrite as A, ScoredSurfaceOutcome as B, JudgeDimension as C, LabeledScenarioSampleArgs as D, LabeledScenarioRecord as E, ProposeContext as F, labelTrustRank as G, SurfaceProposer as H, ProposedCandidate as I, RedactionStatus as L, OptimizerConfig as M, ParetoParent as N, LabeledScenarioSource as O, ProposalTrackContext as P, Scenario as R, JudgeConfig as S, LabelTrust as T, TraceSpan as U, SessionScript as V, isProposedCandidate as W, GateDecision as _, CampaignResult as a, GenerationRecord as b, CampaignTraceWriter as c, DispatchContext as d, DispatchFn as f, GateContribution as g, GateContext as h, CampaignCostMeter as i, MutableSurface as j, LabeledScenarioStore as k, CodeSurface as l, GateCheckStatus as m, CampaignArtifactWriter as n, CampaignScenarioIdentity as o, Gate as p, CampaignCellResult as r, CampaignTokenUsage as s, CampaignAggregates as t, ComponentSurface as u, GateResult as v, JudgeScore as w, JudgeAggregate as x, GenerationCandidate as y, ScenarioAggregate as z };
-//# sourceMappingURL=types-BmQRs661.d.ts.map
+export { SearchNode as $, LabeledScenarioWrite as A, ScoredSurfaceOutcome as B, JudgeDimension as C, LabeledScenarioSampleArgs as D, LabeledScenarioRecord as E, ProposeContext as F, labelTrustRank as G, SurfaceProposer as H, ProposedCandidate as I, renderSearchSummary as J, SearchProposerView as K, RedactionStatus as L, OptimizerConfig as M, ParetoParent as N, LabeledScenarioSource as O, ProposalTrackContext as P, SearchDecisionRecord as Q, Scenario as R, JudgeConfig as S, LabelTrust as T, TraceSpan as U, SessionScript as V, isProposedCandidate as W, SearchCell as X, searchProposerView as Y, SearchCompletion as Z, GateDecision as _, CampaignResult as a, SearchUnitScore as at, GenerationRecord as b, CampaignTraceWriter as c, searchTaskSetDigest as ct, DispatchContext as d, SearchOperation as et, DispatchFn as f, GateContribution as g, GateContext as h, CampaignCostMeter as i, SearchStateView as it, MutableSurface as j, LabeledScenarioStore as k, CodeSurface as l, searchUnitScores as lt, GateCheckStatus as m, CampaignArtifactWriter as n, SearchSpend as nt, CampaignScenarioIdentity as o, searchCellId as ot, Gate as p, SearchSummaryOptions as q, CampaignCellResult as r, SearchState as rt, CampaignTokenUsage as s, searchNodeId as st, CampaignAggregates as t, SearchScoredCell as tt, ComponentSurface as u, GateResult as v, JudgeScore as w, JudgeAggregate as x, GenerationCandidate as y, ScenarioAggregate as z };
+//# sourceMappingURL=types-BWwRXofp.d.ts.map

package/dist/types-BWwRXofp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-BWwRXofp.d.ts","names":[],"sources":["../src/campaign/search-state.ts","../src/campaign/search-summary.ts","../src/campaign/types.ts"],"mappings":"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"}

package/dist/{types-ClK-sHs8.d.ts → types-qoxUfKQg.d.ts}

@@ -1,5 +1,5 @@
 import { c as RunSplitTag } from "./run-record-DF-fuu31.js";
-import { R as Scenario, d as DispatchContext } from "./types-BmQRs661.js";
+import { R as Scenario, d as DispatchContext } from "./types-BWwRXofp.js";
 //#region src/benchmarks/types.d.ts
 type BenchmarkTaskKind = 'retrieval' | 'rag-answer' | 'hallucination' | 'kb-improvement' | 'routing' | 'custom';
 type BenchmarkFamily = 'beir' | 'mteb-retrieval' | 'msmarco' | 'trec-dl' | 'miracl' | 'lotte' | 'bright' | 'crag' | 'hotpotqa' | 'kilt' | 'ragtruth' | 'faithbench' | 'first-party' | 'custom';
@@ -99,4 +99,4 @@ declare const BENCHMARK_SPLIT_SEED = "agent-eval-v1";
 declare function deterministicSplit(itemId: string, seed?: string): RunSplitTag;
 //#endregion
 export { BenchmarkFamily as a, BenchmarkSource as c, BenchmarkEvaluation as i, BenchmarkTaskKind as l, BenchmarkAdapter as n, BenchmarkResponder as o, BenchmarkDatasetItem as r, BenchmarkScenario as s, BENCHMARK_SPLIT_SEED as t, deterministicSplit as u };
-//# sourceMappingURL=types-ClK-sHs8.d.ts.map
+//# sourceMappingURL=types-qoxUfKQg.d.ts.map

package/dist/{types-ClK-sHs8.d.ts.map → types-qoxUfKQg.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"types-ClK-sHs8.d.ts","names":[],"sources":["../src/benchmarks/types.ts"],"mappings":";;;KASY;KAQA;UAgBK,qBAAqB;;;EAGpC;;EAEA,SAAS;;EAET,QAAQ;;EAER,SAAS;;EAET,WAAW;;EAEX;;EAEA,SAAS;EACT,WAAW;;UAGI;;;;EAIf;;EAEA;;EAEA,aAAa;;;EAGb,KAAK;EACL;;UAGe;EACf;EACA;EACA;;EAEA;EACA;EACA;;EAEA;;;;;EAKA;;;UAQe,iBAAiB,kBAAkB,oBAAoB;;EAEtE;EACA,SAAS;EACT,WAAW;EACX;EACA,SAAS;EACT;;;;;EAKA,YAAY,OAAO,cAAc,QAAQ,qBAAqB;;EAE9D,SAAS,MAAM,qBAAqB,WAAW,UAAU,YAAY,QAAQ;;;;EAI7E,YAAY,iBAAiB;;UAGd,kBAAkB,4BAA4B;EAC7D;EACA;EACA,QAAQ;EACR,UAAU;EACV,UAAU;EACV,MAAM,qBAAqB;;KAGjB,mBAAmB,oBAAoB,uBAAuB;EACxE,UAAU,kBAAkB;EAC5B,MAAM,qBAAqB;EAC3B,SAAS;MACL,QAAQ,aAAa;;;cAoBd;;;;;;;;;iBAUG,mBACd,gBACA,gBACC"}
+{"version":3,"file":"types-qoxUfKQg.d.ts","names":[],"sources":["../src/benchmarks/types.ts"],"mappings":";;;KASY;KAQA;UAgBK,qBAAqB;;;EAGpC;;EAEA,SAAS;;EAET,QAAQ;;EAER,SAAS;;EAET,WAAW;;EAEX;;EAEA,SAAS;EACT,WAAW;;UAGI;;;;EAIf;;EAEA;;EAEA,aAAa;;;EAGb,KAAK;EACL;;UAGe;EACf;EACA;EACA;;EAEA;EACA;EACA;;EAEA;;;;;EAKA;;;UAQe,iBAAiB,kBAAkB,oBAAoB;;EAEtE;EACA,SAAS;EACT,WAAW;EACX;EACA,SAAS;EACT;;;;;EAKA,YAAY,OAAO,cAAc,QAAQ,qBAAqB;;EAE9D,SAAS,MAAM,qBAAqB,WAAW,UAAU,YAAY,QAAQ;;;;EAI7E,YAAY,iBAAiB;;UAGd,kBAAkB,4BAA4B;EAC7D;EACA;EACA,QAAQ;EACR,UAAU;EACV,UAAU;EACV,MAAM,qBAAqB;;KAGjB,mBAAmB,oBAAoB,uBAAuB;EACxE,UAAU,kBAAkB;EAC5B,MAAM,qBAAqB;EAC3B,SAAS;MACL,QAAQ,aAAa;;;cAoBd;;;;;;;;;iBAUG,mBACd,gBACA,gBACC"}

package/docs/campaign-proposers.md

@@ -100,7 +100,7 @@ Underreported spending and incomplete receipts remain explicit; `raw.method.cost
 Inspect `cost.accountingComplete` and `cost.incompleteReasons` before treating the known subtotal as complete spending.
 The shared dollar limit controls calls admitted through the cost ledger; arbitrary off-ledger callbacks must enforce their own spending limits.
 
-Native generation records report `ci95: null` because search does not estimate candidate uncertainty.
+Native generation records carry no interval; a candidate's paired contrast with its parent or the baseline is `estimateNode` over the run's search ledger.
 Final comparisons retain their independently computed statistics.
 Every final case and replica must have complete execution and judge results before comparison.
 
@@ -596,38 +596,36 @@ const proposer: SurfaceProposer = {
 Return a label and rationale when they will help later analysis.
 Candidate creation must not read final test results.
 
-A proposer may attach `attribution`: an opaque JSON-safe record retained on `GenerationCandidate.attribution` and in loop provenance.
+A proposer may attach `attribution`: an opaque JSON-safe record stored with the proposal in the search ledger and retained on `GenerationCandidate.attribution` and in loop provenance.
 The loop never interprets it.
 Tag it with a schema field and validate it on readback.
 `makePolicyEditCandidateRecord` from `/analyst` records an edit forecast that can later be compared with the measured change.
 
-`runOptimization()` rejects a candidate whose `surfaceHash` was already admitted.
-This includes the baseline, an earlier generation, and another candidate in the same proposal.
-The complete proposal is checked before candidate dispatch, so duplicates cannot consume candidate cells.
+A candidate is a content-addressed node in the run's search ledger.
+A candidate identical to a surface the search already holds, including the baseline, is a re-proposal: the ledger records a second edge into the existing node, and the surface is not measured again.
 Use `reps` when one surface needs repeated measurements.
+Lineage lives in the ledger: read a node's parents from its edges and its paired contrast from `estimateNode`, not from the generation record.
 
 ### Choose The Parent
 
-`runOptimization()` is incumbent-anchored by default.
-Every generation mutates the single best complete surface seen so far, and only a candidate that beats the incumbent becomes the next incumbent.
-The recorded `parentSurfaceHash` lineage is then a chain.
-Pass `selectParent` to draw the parent from the Pareto frontier instead.
-The selector receives the frontier so far, the measured incumbent, the generation history, and the generation index, and returns one frontier parent.
-The loop hands that parent to the proposer as `ctx.currentSurface` and `ctx.parentOutcome`, and records it as every candidate's `parentSurfaceHash`.
-`ctx.incumbentOutcome` stays the global promotion bar, and a candidate still has to beat the incumbent to promote.
-`crowdedFrontierParent({ seed })` is the provided policy: a seeded NSGA-II crowded tournament that prefers isolated frontier parents.
-The loop refuses a parent it has not measured to completion.
-`selfImprove({ selectParent })` forwards the same policy in proposer mode.
+`runOptimization()` runs on the search kernel with a `SearchPolicy` ([search ledger](./search-ledger.md#run-a-search-the-kernel)).
+The default, `incumbent()`, is the hill climb: each proposal extends the leader once every earlier candidate is measured, and a candidate that scored every scenario leads when it beats the leader on the scenarios they share.
+Pass `policy: crowdedFrontierParent({ seed })` to draw the parent from the Pareto frontier instead: a seeded NSGA-II crowded tournament that prefers isolated frontier members.
+The proposer receives that parent as `ctx.currentSurface` and `ctx.parentOutcome`; `ctx.incumbentOutcome` stays the leader, and only a candidate that beats the leader leads.
+`selfImprove({ policy })` forwards the same policy in proposer mode.
 
 ```ts
 import { crowdedFrontierParent, runOptimization } from '@tangle-network/agent-eval/campaign'
 
 const result = await runOptimization({
   // ...scenarios, dispatchWithSurface, judges, proposer, populationSize, maxGenerations, runDir
-  selectParent: crowdedFrontierParent({ seed: 42 }),
+  policy: crowdedFrontierParent({ seed: 42 }),
 })
 ```
 
+`runOptimization` always writes its search ledger, at `<runDir>/search/ledger.jsonl` unless `searchLedger` puts it elsewhere, and returns the receipt on `searchHistory`.
+Running it again on the same run directory continues an interrupted search and reruns nothing that settled; after a finished search it starts the next one beside it.
+
 ## Data And Cost Rules
 
 - Train and selection cases are visible to complete optimization methods.