@tangle-network/agent-eval 0.197.0 → 0.198.1

package/dist/{types-B3jzCp0p.js → types-B3jzCp0p2.js}

@@ -105,4 +105,4 @@ function describeValue(value) {
 //#endregion
 export { assertMultishotShotResult as i, MultishotFatalToolError as n, MultishotShotResultError as r, MultishotDriverEmptyError as t };
 
-//# sourceMappingURL=types-B3jzCp0p.js.map
+//# sourceMappingURL=types-B3jzCp0p2.js.map

package/dist/types-B3jzCp0p2.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-B3jzCp0p2.js","names":[],"sources":["../src/multishot/types.ts"],"sourcesContent":["// Public types for the multishot substrate.\n\nimport type { CostProvenance } from '../cost-ledger'\n\nexport interface MultishotMessage {\n  role: 'user' | 'assistant' | 'tool'\n  content: string\n  toolCallId?: string\n  toolCalls?: Array<{ id: string; name: string; args: Record<string, unknown> }>\n}\n\nexport interface MultishotArtifact {\n  type: string\n  turn: number\n  invocation: { name: string; args: Record<string, unknown> }\n  content: string\n}\n\nexport interface MultishotResult {\n  transcript: MultishotMessage[]\n  artifacts: MultishotArtifact[]\n  toolCalls: number\n  durationMs: number\n  /** Known spend. A subtotal, not a total, when `costProvenance.kind` is\n   *  `uncaptured`. */\n  costUsd: number\n  /** Origin of `costUsd`. A shot that priced every call reports `estimated`\n   *  or `observed`; a shot with a call the router priced at nothing reports\n   *  `uncaptured`, and the matrix records the cell as under-counted instead of\n   *  presenting the subtotal as a complete estimate.\n   *\n   *  Optional so an engine written before this field keeps working; the matrix\n   *  then judges the cell on judge receipts alone, as it did before. */\n  costProvenance?: CostProvenance\n}\n\nexport interface MultishotToolDefinition {\n  type: 'function'\n  function: {\n    name: string\n    description: string\n    parameters: Record<string, unknown>\n  }\n}\n\n/** One chat-completion request the multishot loop issues for a single agent\n *  (or driver) inference step. Mirrors the OpenAI-compat body the loop would\n *  otherwise POST to the Tangle router. */\nexport interface MultishotTransportRequest {\n  model: string\n  messages: Array<Record<string, unknown>>\n  tools?: MultishotToolDefinition[]\n  temperature?: number\n  maxTokens?: number\n  signal?: AbortSignal\n}\n\nexport interface MultishotTransportToolCall {\n  id: string\n  type: 'function'\n  function: { name: string; arguments: string }\n}\n\nexport interface MultishotTransportResponse {\n  message: { content?: string | null; tool_calls?: MultishotTransportToolCall[] }\n  usage?: { prompt_tokens?: number; completion_tokens?: number }\n  /** Actual spend for this call. When omitted, the loop meters cost from\n   *  `usage` via the per-model estimator (estimateMultishotCost). */\n  costUsd?: number\n  /** Model identity the provider reported, when the transport observed one.\n   *  Omitted means unreported, and the requested model is used for\n   *  attribution — which is not proof that model answered. */\n  model?: string\n}\n\n/** Execution seam for one leg of the multishot loop. The caller owns model\n *  execution: agent-eval issues no provider request and holds no credential.\n *  The loop still owns turn scheduling, tool dispatch, transcript capture, and\n *  cost metering. agent-eval has no dependency on agent-runtime; adapt\n *  agent-runtime's `profileChatClient` (or any sandbox, bridge, or router\n *  client) into this signature product-side. */\nexport type MultishotTransport = (\n  req: MultishotTransportRequest,\n) => Promise<MultishotTransportResponse>\n\nexport type MultishotToolExecutor = (\n  args: Record<string, unknown>,\n  ctx: {\n    /** Caller-owned execution seam for the specialist leg this tool runs. */\n    transport: MultishotTransport\n    signal?: AbortSignal\n  },\n) => Promise<{ content: string; costUsd: number }>\n\nexport interface MultishotPersona {\n  /** Stable identifier — used for per-cell artifact paths + matrix axis keys. */\n  id: string\n  /** Per-domain payload (income/profile/voice/etc.) shaped by the consumer. */\n  [k: string]: unknown\n}\n\n/**\n * Persona-shaping callbacks. Both are OPTIONAL: when omitted, the loop derives\n * them from the `AgentProfile` + persona payload (see `defaultShapeFromProfile`)\n * so a pure-profile call — `runMultishot({ profile, persona })` — works with no\n * role-builder functions. Provide callbacks only to override the derived shape.\n */\nexport interface MultishotShape<TPersona extends MultishotPersona> {\n  /** Opening user message (turn 0) — the persona's first ask. */\n  buildOpener?: (persona: TPersona) => string\n  /** System prompt the driver LLM uses to roleplay the persona. Should set\n   *  voice, goals, constraints, time-pressure, and the \"never go silent\" rule. */\n  buildDriverSystemPrompt?: (persona: TPersona) => string\n}\n\nexport class MultishotDriverEmptyError extends Error {\n  constructor(public readonly turn: number) {\n    super(`multishot: driver returned empty content twice at turn ${turn} — failing loud`)\n    this.name = 'MultishotDriverEmptyError'\n  }\n}\n\nexport class MultishotFatalToolError extends Error {\n  constructor(message: string) {\n    super(message)\n    this.name = 'MultishotFatalToolError'\n  }\n}\n\nexport class MultishotShotResultError extends Error {\n  constructor(reason: string) {\n    super(`multishot: shot returned an invalid MultishotResult — ${reason}`)\n    this.name = 'MultishotShotResultError'\n  }\n}\n\nconst MULTISHOT_ROLES = new Set(['user', 'assistant', 'tool'])\n\n/** Contract guard for the value a caller-supplied shot resolves with. The\n *  matrix writes per-cell artifacts, builds judge inputs, and meters cost from\n *  this value, so a malformed result must stop the cell instead of scoring a\n *  degraded one. Two silent degradations this closes: an artifact with no\n *  `type` matches neither the code nor the content artifact set, so the cell\n *  scores as though the artifact was never produced; a non-finite `costUsd`\n *  reaches `summary.totalCostUsd` and makes every cost number NaN.\n *\n *  A rejected cell is still billed: the matrix cell reads the shot's own\n *  `costUsd` when it is a usable amount and declares that spend on the throw,\n *  so money the shot spent before returning a malformed result stays in the\n *  cumulative sum the cost ceiling reads. A result whose `costUsd` is itself\n *  malformed carries no usable amount, and the cell records as `uncaptured`.\n *\n *  Every required field of `MultishotMessage` and `MultishotArtifact` is\n *  checked, including `toolCalls` elements and `invocation.args`. Optional\n *  fields are checked only when present. */\nexport function assertMultishotShotResult(value: unknown): asserts value is MultishotResult {\n  if (typeof value !== 'object' || value === null) {\n    throw new MultishotShotResultError(`expected an object, received ${describeValue(value)}`)\n  }\n  const result = value as Record<string, unknown>\n  if (!Array.isArray(result.transcript)) {\n    throw new MultishotShotResultError(\n      `transcript must be an array, received ${describeValue(result.transcript)}`,\n    )\n  }\n  if (!Array.isArray(result.artifacts)) {\n    throw new MultishotShotResultError(\n      `artifacts must be an array, received ${describeValue(result.artifacts)}`,\n    )\n  }\n  result.transcript.forEach(assertMessage)\n  result.artifacts.forEach(assertArtifact)\n  assertFiniteCount(result.toolCalls, 'toolCalls')\n  assertFiniteCount(result.durationMs, 'durationMs')\n  assertFiniteCount(result.costUsd, 'costUsd')\n  if (result.costProvenance !== undefined) assertCostProvenance(result.costProvenance)\n}\n\nfunction assertCostProvenance(value: unknown): void {\n  const row = requireRow(value, 'costProvenance')\n  if (row.kind !== 'observed' && row.kind !== 'estimated' && row.kind !== 'uncaptured') {\n    throw new MultishotShotResultError(\n      `costProvenance.kind must be observed, estimated or uncaptured, received ${describeValue(row.kind)}`,\n    )\n  }\n  // The matrix reads the amount from `costUsd`; `usd` only has to agree with\n  // the kind, so an uncaptured provenance cannot smuggle in a total.\n  if (row.kind === 'uncaptured') {\n    if (row.usd !== null) {\n      throw new MultishotShotResultError(\n        `uncaptured costProvenance.usd must be null, received ${describeValue(row.usd)}`,\n      )\n    }\n    return\n  }\n  assertFiniteCount(row.usd, 'costProvenance.usd')\n}\n\nfunction assertMessage(value: unknown, index: number): void {\n  const row = requireRow(value, `transcript[${index}]`)\n  if (typeof row.role !== 'string' || !MULTISHOT_ROLES.has(row.role)) {\n    throw new MultishotShotResultError(\n      `transcript[${index}].role must be user, assistant or tool, received ${describeValue(row.role)}`,\n    )\n  }\n  assertString(row.content, `transcript[${index}].content`)\n  if (row.toolCallId !== undefined) {\n    assertString(row.toolCallId, `transcript[${index}].toolCallId`)\n  }\n  if (row.toolCalls === undefined) return\n  if (!Array.isArray(row.toolCalls)) {\n    throw new MultishotShotResultError(\n      `transcript[${index}].toolCalls must be an array when present, received ${describeValue(row.toolCalls)}`,\n    )\n  }\n  row.toolCalls.forEach((call, callIndex) => {\n    const field = `transcript[${index}].toolCalls[${callIndex}]`\n    const row = requireRow(call, field)\n    assertString(row.id, `${field}.id`)\n    assertString(row.name, `${field}.name`)\n    requireRow(row.args, `${field}.args`)\n  })\n}\n\nfunction assertArtifact(value: unknown, index: number): void {\n  const row = requireRow(value, `artifacts[${index}]`)\n  assertString(row.type, `artifacts[${index}].type`)\n  assertString(row.content, `artifacts[${index}].content`)\n  assertFiniteCount(row.turn, `artifacts[${index}].turn`)\n  const invocation = requireRow(row.invocation, `artifacts[${index}].invocation`)\n  assertString(invocation.name, `artifacts[${index}].invocation.name`)\n  requireRow(invocation.args, `artifacts[${index}].invocation.args`)\n}\n\nfunction requireRow(value: unknown, field: string): Record<string, unknown> {\n  if (typeof value !== 'object' || value === null || Array.isArray(value)) {\n    throw new MultishotShotResultError(\n      `${field} must be an object, received ${describeValue(value)}`,\n    )\n  }\n  return value as Record<string, unknown>\n}\n\nfunction assertString(value: unknown, field: string): void {\n  if (typeof value !== 'string') {\n    throw new MultishotShotResultError(\n      `${field} must be a string, received ${describeValue(value)}`,\n    )\n  }\n}\n\nfunction assertFiniteCount(value: unknown, field: string): void {\n  if (typeof value !== 'number' || !Number.isFinite(value) || value < 0) {\n    throw new MultishotShotResultError(\n      `${field} must be a finite number >= 0, received ${describeValue(value)}`,\n    )\n  }\n}\n\nfunction describeValue(value: unknown): string {\n  if (value === null) return 'null'\n  if (Array.isArray(value)) return 'an array'\n  if (typeof value === 'object') return 'an object'\n  return `${typeof value} ${String(value)}`\n}\n"],"mappings":"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"}

package/dist/{types-CjFDKMDe.d.ts → types-D94EanDL.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-B2673PBj.js";
+import { R as Scenario, d as DispatchContext } from "./types-EBUav9Bu.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-CjFDKMDe.d.ts.map
+//# sourceMappingURL=types-D94EanDL.d.ts.map

package/dist/{types-CjFDKMDe.d.ts.map → types-D94EanDL.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"types-CjFDKMDe.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-D94EanDL.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/dist/{types-B2673PBj.d.ts → types-EBUav9Bu.d.ts}

@@ -110,6 +110,9 @@ interface SearchOperation {
   recorded: boolean;
   /** The recorded outcome; null until the operation is recorded. */
   outcome: SearchOperationRecordedEvent['outcome']['status'] | null;
+  /** What ran the operation, for example a proposer's model; null until the
+   * operation is recorded. */
+  execution: SearchOperationRecordedEvent['execution'] | 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[];
@@ -588,9 +591,10 @@ interface ProposeContext<TFindings = ProposalFinding> {
    *  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. */
+  /** How the child should derive from the parent: `improve` edits it;
+   *  `draft` writes a whole alternative to it (`aide` drafts from the root);
+   *  `debug` fixes a parent whose cells failed as defects, such as a crash or
+   *  a broken build; `merge` combines every parent. 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.
@@ -1002,4 +1006,4 @@ interface CampaignResult<TArtifact = unknown, TScenario extends Scenario = Scena
 }
 //#endregion
 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-B2673PBj.d.ts.map
+//# sourceMappingURL=types-EBUav9Bu.d.ts.map

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

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

package/docs/campaign-proposers.md

@@ -611,6 +611,8 @@ Lineage lives in the ledger: read a node's parents from its edges and its paired
 `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.
+`aide()` and `beam({ width })` also run here; they rank on the scenarios, because `runOptimization` has no private selection split, and it keeps the `uniform` allocator, because its proposer reads every candidate's score on every scenario.
+Under `aide`, `ctx.operator` says what to write: `draft` a whole alternative from the parent, `debug` a parent whose cells failed as defects, or `improve` it.
 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.
 

package/docs/design/statistics-decisions.md

@@ -299,7 +299,7 @@ That is why the option stays optional — a required seed would push the caller
 | `summary-report.ts` `bayesianBootstrapMeanSamples` | Dirichlet-weight bootstrap | reported posterior and gain histogram | `makeRng(seed, deltas)` |
 | `meta-eval/rubric-predictive-validity.ts` `bootstrapCi` | percentile bootstrap of Pearson r | rubric verdict (`load_bearing` / `informative`) | `makeRng(input.seed, xs, ys)` |
 | `meta-eval/correlation-study.ts` `bootstrapPearsonCi` | percentile bootstrap of Pearson r | reported correlation CI | `makeRng(options.seed, xs, ys)` |
-| `rl/active-curriculum.ts` `thompsonCurriculum` | Beta posterior sampling | sample-budget allocation | `makeRng(opts.seed, scores)` |
+| `campaign/search-policy.ts` `aide` | Thompson draw over node posteriors, the debug coin, the debug and uniform draws | the parent an expansion extends (spends budget, claims nothing) | `mulberry32(seed ^ imul(completed expansions + 1, 0x9e3779b1) ^ salt)`, a pure function of the ledger |
 | `rl/adaptation-eval.ts` `compareAdaptationCurves` | bootstrap of per-k mean deltas | per-k CI and AUC delta | `makeRng(opts.seed, a-means, b-means)` |
 | `campaign/gates/sequential.ts` | seeded Fisher-Yates over paired deltas | exchangeability guard before the e-process | `shuffleSeed`, default 1337, data-independent by construction |
 

package/docs/search-ledger.md

@@ -139,6 +139,58 @@ renderSearchSummary(state, { split: 'train' })
 `searchProposerView(state)` has no parameter that can select another split: its `scoredCells`/`unitScores` always read `'train'`, so a proposer built on it cannot reach the sealed selection or test split even by mistake.
 `ProposeContext.parents` carries every parent the policy chose, primary first, with its artifact — `currentSurface` is `parents[0].artifact`; a `merge` proposal needs every parent, and the built-in `incumbent`/`crowdedFrontierParent` policies always choose one.
 
+## Lenses
+
+A lens (`@tangle-network/agent-eval/search`, search-tree-design §12) is a pure function of a `SearchStateView`: it reads no other record type and does no I/O.
+Each returns `{ data, signal }` — `data` is JSON a view or `agent-eval search show` renders, and `signal` is exactly one named, quantitative value a `SearchPolicy` can read, so what a person sees and what the climber uses come from the same computation.
+No lens imputes a value below the design's honesty thresholds: an unknown cost or an unpaired sample stays excluded, reported as `insufficient` or `no measured children` rather than folded into a number.
+Every sample a lens summarizes is staged by `estimateNode`'s own `searchEstimateMethod`: `none` below 2 (no mean; one observation is no estimate), `insufficient` below 6 (a mean, no interval), `descriptive` below 20 and `bootstrap` from 20, each interval naming its method and n.
+Every order a lens reports, such as a cluster id, sorts by UTF-16 code unit, so a fixed ledger gives the same JSON on every host.
+
+| Lens | Reports | Signal |
+|---|---|---|
+| `tree(state)` | a tidy tree of nodes and edges — the base view every other lens sits beside; a node with unknown-cost cells shows its known spend, its proven floor and how many cells are unknown, never a total | `tree.nodeCount` (drives no policy) |
+| `operatorYield(state, { split? })` | each edge operator's proposals, re-proposals, outcome counts and improvement-per-known-dollar yield, from `searchPosterior` (`estimateNode`'s tree-wide contrast); a node counts once, under the operator of the edge that registered it, and a re-proposal adds a proposal but no outcome or sample; a node is excluded from yield when it was decided invalid, shares fewer than 2 units with the root, or any of its cells has an unknown cost | `operatorYield.weights`: an operator's yield mean once it has 6 or more yield-eligible nodes (`MIN_OUTCOMES_FOR_WEIGHT`), else `null` |
+| `front(state, { split?, axes? })` | the Pareto frontier over per-unit mean score and known cost per attempted cell on the split (reusing `paretoFrontier`), with room for caller-declared extra axes; a node's total spend depends on how far the allocator measured it, so it is shown but is not an axis; a node decided invalid, scored on fewer than 2 units, with an unknown-cost cell on the split, or with a non-finite extra axis is excluded from every frontier pass, with the reason | `front.membership`: 1 for a node on the frontier, 0 otherwise (including an excluded node) |
+| `taskMatrix(state, { split? })` | nodes and units, each single-linkage clustered on the root-mean-square difference over their shared scores, cutoff at the data's own median pairwise distance | `taskMatrix.specialistGain`: per unit cluster, the best node's mean minus the mean of node means, in the objective's direction, among nodes not decided invalid that scored every unit of the cluster; `null` with the reason, and omitted from the signal, below 2 such nodes or 6 units |
+
+`agent-eval search show <ledger> [--tree] [--operator-yield] [--front] [--task-matrix]` prints each lens's text form below the search summary, so an agent reading the CLI sees the same numbers Intelligence, discovery lab, VerticalBench and agent-runtime `improve()` would render from the same JSON.
+
+`incumbentWithOperatorBandit({ seed, fixedWeights? })` (`/campaign`) is the one built-in policy that reads a lens signal: a hill climb, like `incumbent`, whose expansion operator is a weighted draw over `operatorYield`'s weights.
+An operator without 6 measured outcomes yet draws on `fixedWeights` (uniform by default) instead of being starved until every operator clears the gate; a measured operator's weight is `fixedWeights[operator] + yield`, floored just above zero, because yield (dollars) and the fixed prior (an arbitrary share) are not on the same scale and a small positive yield should not draw less than an untested operator's default prior.
+
+## Edit credit: which edits earned their score
+
+`editCredit(state, { readArtifact })` (`@tangle-network/agent-eval/search`) treats the edits of a search as genes and follows them down its lineage.
+It diffs each lineage parent and child line by line, with whitespace normalized, and cuts every changed run into paragraphs.
+An added paragraph is an `insert` gene and a removed paragraph is a `delete` gene.
+A gene's id hashes its kind, its location in the artifact and its normalized lines, so the same edit has the same id wherever a proposer makes it.
+The lens computes these ids; the ledger records no hunk ids.
+A node carries a gene when its content holds the paragraph (or, for a delete, lacks it), so carrying follows merges, re-proposals and reverts.
+`readArtifact` returns a node's parsed artifact, and the caller verifies its bytes against the reference's digest.
+A node whose artifact is unreadable, or a code surface whose patch is not in the ledger, has unknown content, and its steps yield no genes.
+
+Credit pairs, on each clean lineage step, the side that carries the gene against the side that lacks it, on the units both scored.
+A step is clean for a gene when every change on it belongs to one edit that introduced the gene, so a merge that also brings in other edits credits none of them.
+Per unit, both sides average over the gene's clean steps, and `pairedDeltaTest` decides on the per-unit contrasts, staged like `NodeEstimate.method`: `none` below 2 units, `insufficient` below 6, `descriptive` below 20, `bootstrap` from 20.
+The verdict is `pairedDeltaTest`'s own decision in each direction: `reusable`, `harmful`, `unresolved`, or `insufficient` below 6 units.
+Genes with the same clean steps are linked: they have one credit, and they count as one edit.
+Credit is not adjusted for the number of edits, because it steers what to reuse and test next and claims nothing.
+`data.chance.expectedReusable` states how many reusable edits the verdict would call if no edit had an effect, so read the count against it.
+A policy chooses a parent for its scores, so a parent is high by chance on the units it was chosen on.
+On a step where the child gained a gene, that parent is the lacking side, and credit is biased toward `harmful`; where the child lost the gene, credit is biased toward `reusable`.
+With no true effect, the generator below measured `harmful` on 4.3 % of measured edits under `uniform` (103 of 2,396, 40 searches) and 1.3 % under `asha` (31 of 2,412), and `reusable` on 0.8 % and 1.0 %.
+Only the sealed test split is free of this bias, so a reusable edit still needs a held-out test before it ships.
+
+Interactions compare a gene's step contrasts where another gene is present on both ends against where it is absent on both ends, in both directions.
+The pairs with 6 or more units are tested with an exact two-sided sign test and flagged after a Holm correction; a flag is a reason for a factorial test, not a claim.
+A flag says that a gene's credit depends on its context; the named partner can be a gene that travels with the true partner.
+
+The signal `reusableHunks` counts the reusable edits, and `signal.top` names the first gene of each, best first; it is null until some gene has 6 units on clean steps.
+`data.skillCandidates` turns each reusable insert edit into an inline skill resource with the `improve()` options that select it, for agent-runtime's SkillOpt (`surface: 'skills'`).
+`agent-eval search show <ledger> --edit-credit [--json]` prints the lens, reading artifacts from the blobs the ledger names.
+`scripts/synthetic-search-ledger.ts` writes a seeded search with planted edit effects through the real kernel and scores the lens against the planted truth.
+
 ## Record a search
 
 `SearchRecorder` writes each fact the moment it exists.
@@ -199,11 +251,22 @@ The ports:
   Its output is stored as a `proposal` blob on `operation-recorded` before any child is registered.
 - **Codec:** `node(recorder, artifact)` content-addresses an artifact, `diff` stores the parent-to-child diff, and `load` reads a node's artifact back.
 - **Policy:** `expand(view)` returns parents and an operator, or null to wait; `leader(view)` names the node the search keeps.
-  The view holds the policy split (selection, or train when a search has none) and no test cell.
-  `incumbent({ patience })` is the hill climb: it expands the leader once every earlier child is screened.
-  A node leads when it dodged no unit (no cell ran and ended unscored), scored every unit the leader scored, and beats the leader's mean on them.
+  The view holds the policy split (selection, or train when a search has none) and no test cell: per-unit scores, paired estimates, every node's lineage, status and defect count (`nodes()`), and each node's posterior on its improvement over the root (`posterior`, from `searchPosterior`, computed once per ledger state).
+  The kernel refuses an expansion without a parent or with a parent whose screen has not finished; an invalid node is never screened, so it is never a parent.
+  Every built-in policy keeps the same leader: a node leads when it dodged no unit (no cell ran and ended unscored), scored every unit the leader scored, and beats the leader's mean on them.
   A node measured on fewer units than the leader, such as one an allocator has only screened, cannot take the lead on less evidence.
-  `crowdedFrontierParent({ seed })` draws the parent from the Pareto frontier by a seeded crowded tournament and keeps the incumbent's leader rule.
+  `incumbent({ patience })` is the hill climb: it expands the leader once every earlier child is screened.
+  `crowdedFrontierParent({ seed })` draws the parent from the Pareto frontier by a seeded crowded tournament.
+  `aide({ drafts, debugProbability, maxDebugDepth, stallAfter })` (defaults 5, 0.5, 3, 4) is AIDE's policy with three changes for noisy scores.
+  It drafts whole alternatives from the root until `drafts` nodes were drafted.
+  Then, with probability `debugProbability`, it debugs a buggy leaf whose chain holds fewer than `maxDebugDepth` debug edges; a node is buggy when at least half of its final cells outside the test split `failed`, and an `errored` cell never makes it buggy.
+  Otherwise it improves a parent drawn by Thompson sampling from every screened node that is not buggy: the root at 0, every other node from a normal with its mean improvement over the root and the pooled between-unit variance divided by its shared units.
+  Until some node shares 2 units with the root the variance is unknown and the draw is uniform.
+  When the drawn parent's lineage (the nodes under its nearest draft, or under the root) has had `stallAfter` improve children in a row that did not raise its best posterior mean, the improve forks from the node with the best posterior mean instead.
+  A fork's children restart the run of the lineage they join, so a stalled lineage that holds the global best forks once, not on every later expansion.
+  `beam({ width })` expands the top `width` nodes by posterior mean, the member with the fewest children first; a member is the root, a node an allocator advanced, or a node that scored every unit the root scored.
+  Each edge records the rule and evidence that chose its parent (`aide:draft`, `aide:debug`, `aide:thompson`, `aide:uniform-draw`, `aide:stall-fork`, `beam(width=k)`).
+  Pair `incumbent` and `crowdedFrontierParent` with `uniform`, and `aide` and `beam` with `asha`: a hill climb expands only the leader, and under `asha` the root keeps the lead until a child finishes the top rung, while a posterior stays honest about a node measured only on the first rung.
 - **Allocator:** `plan(state, nodeId, rung)` lists the cells a node needs through its rung; the kernel allocates the ones the ledger lacks.
   `advance(view)` names the nodes the evidence moves to a further rung, and `prune(view, keep)` names, at close, the nodes left waiting.
   The kernel records each `advanced` decision only once the cap admits its rung's cells, then allocates them.
@@ -248,14 +311,59 @@ Aborting the `signal` pauses the search: in-flight cells are aborted, a scored r
 One kernel runs a ledger file at a time on a host: a second one is refused by a pid lock beside the ledger, and a killed holder's lock is reclaimed.
 A closed ledger returns its result; more work on a closed search is a new search.
 
-An `asha` search ranks a node when it finishes a rung, so a restart that changes the order cells finish in can change a promotion.
-Its resumed ledger holds only rank decisions that its own evidence supports.
+A node an allocator advanced stays a possible parent while its rung cells run, after a restart too.
+An `asha` search ranks a node when it finishes a rung, and `aide` and `beam` expand while other screens run.
+A restart that changes the order cells finish in can therefore change a promotion or a parent.
+The resumed ledger holds only decisions that its own evidence supports.
+A hill climb under `uniform` waits for every screen, so its resumed search equals the uninterrupted one.
 
 `scripts/search-sim.ts` runs the real kernel, ledger, policies and claim over a seeded synthetic objective, proposer and executor.
 `kill-resume` SIGKILLs it at random ledger positions and compares the resumed search with an uninterrupted one.
 `claims --searches 200 --null` runs 200 searches in which no node differs from the root and reports how often the claim ships, with Wilson and Clopper-Pearson intervals; `--plant-gain X` plants a real gain to measure how often the claim finds it.
-`compare --seeds 200` runs one search per seed under `uniform` and under `asha` and reports the cells each allocated, the node each kept, and the units each edge pairs on; `--pool-gap X` swaps the hill climb for a fixed pool with one planted best candidate.
+`compare --seeds 200 --arms incumbent+uniform,aide+asha` runs one search per seed under each `policy+allocation` arm and reports the cells each allocated, the node each kept, how often it kept the planted node and how often it kept a node at least half the planted gain above the root (each with a Wilson interval), and the units each edge pairs on; every later arm is paired with the first by seed, with an exact sign test.
+`--max-cells N` caps the cells a search allocates, so arms compare at equal cells.
+`--pool-gap X` swaps the hill climb for a fixed pool with one planted best candidate; `--deep-gain X` plants a gain at depth `--deep-depth` (default 3) of one lineage, behind neutral path nodes (or a gradient with `--deep-ramp`), with every other edit a loss.
+`--defect-rate X` makes a share of children fail every cell as a defect, which `aide` debugs.
 Every simulated run re-derives each `advanced` and `pruned` decision from the ledger just before it.
+It also rebuilds the policy's view from the ledger just before each proposal started and checks that the policy returns the recorded parents, operator and selection evidence.
+
+## Geometry lenses: `landscape` and `skillManifold`
+
+A lens is a pure function of a `SearchStateView` from `@tangle-network/agent-eval/search`.
+It returns `data` for a view and one `signal` that a policy or an allocator reads, so a person and the climber read the same number.
+A geometry lens signal states its `method`, its sample `n`, and, when its value is null, the reason in `insufficient`.
+A lens never imputes a score or a cost.
+
+`landscape(state, embed?, options?)` places every node in two dimensions by landmark classical multidimensional scaling of a distance between profiles.
+The default distance, `lineageEdits()`, counts the improve, debug and merge edges between two nodes.
+A draft is written afresh, so the lineage distance leaves a draft's lineage unplaced; `surfaceTextEdits(read)` places it by line edits between the surface texts.
+`vectorEmbedding(name, vector)` takes a caller's vectors, for example a model embedding of each profile.
+A node's score is its improvement over the root on shared units, with the standard error that `searchPosterior` gives it.
+The surface is ordinary kriging with each node's own noise; a grid cell is null where the nodes leave more than half the prior variance unexplained.
+No surface is drawn unless distance predicts score: the fitted length scale must raise the log-likelihood by 1 or more over independent node scores.
+Basins are peaks of the node scores on the 6-nearest-neighbour graph that stand above their saddle by z standard errors.
+z is the Bonferroni normal quantile at 5% over the graph's local maxima, so a flat landscape of noisy nodes counts one basin at least 95% of the time.
+The surface and the basins need 6 nodes that share 2 or more units with the root.
+The signal `plateau` is the rise of the best improvement over the root across the last 6 accepted nodes, divided by that node's standard error.
+An accepted node is screened, dodged no unit, and shares 6 or more units with the root.
+`draftOnPlateau(base, { window, below })` wraps any policy: on every `window`-th expansion, when `plateau` is below `below` (default 1), it drafts from the root; otherwise `base` expands.
+A draft pays off only when `base` expands drafts that trail its leader, as `aide` does; `incumbent` expands only its leader.
+The trigger adds drafts to `aide`'s own; it does not replace them.
+In `scripts/search-sim.ts plateau` (30 seeds, 24 expansions, root lineage capped at 0.62), `draftOnPlateau(aide({ drafts: 0 }))` kept 0.198 less true quality than `aide()` (95% paired bootstrap [−0.230, −0.163]; 25 of 30 seeds worse).
+With the cap removed, the difference was not detectable (−0.012 [−0.049, +0.026]).
+
+`skillManifold(state, k?, options?)` factors the node × unit matrix of per-unit means as `b_u + P_i · Q_u` on standardized scores.
+Alternating ridge least squares reads only observed cells; a missing cell is masked, never filled.
+Five-fold cross-validation over held-out cells picks the intrinsic dimension by the one-standard-error rule.
+With fewer than 6 nodes and 6 units the dimension is insufficient, and `k: 'auto'` fits one descriptive axis.
+The signal `nextUnit` names the unit whose next cell removes the largest expected share of the variance of the leaders' contrasts.
+It needs 2 leaders with 6 or more modelled units and a cross-validated cell noise.
+`skillCalibration(lens)` keeps the unit loadings of a fit whose cross-validation found an axis.
+`asha({ extend: nextUnitExtension(calibration) })` fills each rung it opens with the units that best separate the leaders, read from the ledger at the decision that opened the rung.
+The extension is off by default.
+
+`agent-eval search show <ledger> --landscape --skill-manifold` prints both lenses as text; `--landscape` reads surface texts from `blobs/` beside the ledger and checks each digest.
+`scripts/search-sim.ts plateau` compares `incumbent` with `draftOnPlateau(incumbent)` by seed, and `scripts/search-sim.ts adaptive` compares `asha` with the extension.
 
 ## The claim
 
@@ -292,6 +400,31 @@ A judge change is a changed `search-opened` header, which `SearchRecorder.open`
 `compareOptimizationMethods` keeps its own held-out comparison for black-box methods such as GEPA, which return one winner and never see the test split.
 A method's search ledger closes before the comparison starts, so the comparison cannot add claim cells to it.
 
+## A search of searches: `metaSearch` and nested searches
+
+`metaSearch(searches, { objective? })` (`@tangle-network/agent-eval/search`) treats each search as one node.
+Its genome is the configuration its ledger records: expansion policy, allocator, budget, proposer and the proposer's model.
+A policy parameter equal to the search's own seed reads `seed=<search>`, so one configuration run on different seeds is one genome.
+Its score is `metaSearchScore(state)`: the claim's held-out lift per known dollar of the whole search.
+The lift is `estimateNode` of the shipped node, or on `hold` of the first finalist the claim fixed before test, against the root on the test split.
+A search that is open, has no claim, cannot resolve its test, held with no finalist tested, pairs fewer than 2 test units, or has a claim its ledger contradicts is unscored with that reason, never 0.
+A search with an unknown-cost cell has only a floor, so its lift per dollar is a bound that enters no estimate.
+
+Searches form a forest by derivation (`derivedFrom`) and containment (`containment`).
+Configurations group searches of one genome within one objective.
+A configuration's estimate is the mean over its scored searches with a percentile bootstrap interval, staged like `NodeEstimate.method` by the number of searches; one scored search carries its own paired interval over its test units.
+Every configuration reports how many of its searches were scored.
+The signal `metaSearch.bestPolicyConfiguration` names the configuration with the largest estimate within one objective, with its interval, method, n and coverage; it is a point ranking, not a test.
+`agent-eval search show <ledger> [<ledger> ...] --meta [--objective <key>] [--json]` prints the lens as text, or as JSON with `--json`.
+
+`runNestedSearch` runs an outer search whose cells are inner searches, on the same kernel.
+An outer node is a configuration (`runtime-config`), an outer task is a problem, and each outer cell runs one inner search of its node's configuration on its task's problem.
+The inner search records the outer cell attempt as its `containment`, and its id is a digest of that attempt, so a rerun resumes the inner ledger instead of starting again.
+The outer cell scores `metaSearchScore` of the closed inner search, costs what the inner search spent, and binds the inner head hash.
+An inner search without a known lift per dollar settles its cell `errored` and not retryable, so its configuration cannot lead on missing evidence.
+The outer search's judge is `META_SEARCH_SCORE_SOURCE`, and with a test split it claims once, on held-out problems, whether a configuration beats the root configuration.
+`scripts/search-meta-sim.ts` runs one over simulator configurations with no model spend.
+
 ## Ship a search
 
 A hosted store (Intelligence, or the reference receiver in `examples/hosted-ingest-server/`) receives a search through the [hosted ingest wire](./hosted-ingest-spec.md).
@@ -337,12 +470,16 @@ Those claims need the sealed test split, the claim's power check, and held-out e
 - `src/campaign/search-state.ts`: `SearchState`, the invariants and read model, and the id functions.
 - `src/campaign/estimate-node.ts`: `estimateNode`, `estimateNodeFromCells` and `searchPosterior`.
 - `src/campaign/search-summary.ts`: `renderSearchSummary` and `searchProposerView`.
+- `src/search/lenses/edit-credit.ts`: `editCredit` and `editCreditText`.
 - `src/campaign/search-ledger-recording.ts`: `SearchRecorder` and the surface helpers.
 - `src/campaign/search-kernel.ts`: `runSearch`, the executor, proposer and codec ports, `searchPolicyView` and `searchDivergence`.
 - `src/campaign/search-claim.ts`: `planSearchClaim`, `decideSearchClaim`, `verifySearchClaim` and `searchClaimReserveUsd`.
-- `src/campaign/search-policy.ts`: `SearchPolicy`, `incumbent` and `crowdedFrontierParent`.
+- `src/search/lenses/landscape.ts`, `plateau.ts` and `skill-manifold.ts`: the geometry lenses, the plateau score and the unit extension.
+- `src/campaign/search-policy.ts`: `SearchPolicy`, `incumbent`, `incumbentWithOperatorBandit`, `crowdedFrontierParent`, `aide` and `beam`.
 - `src/campaign/allocation.ts`: `SearchAllocator`, `uniform` and `asha`.
 - `src/campaign/presets/run-optimization.ts`: `runOptimization` as a search on the kernel.
 - `src/campaign/gepa-search-import.ts`: the GEPA population and evaluation importers.
 - `src/campaign/search-history-receipt.ts`: receipts and admission.
+- `src/search/lenses/meta-search.ts`: `metaSearch`, `metaSearchScore`, `searchPolicyGenome` and `renderMetaSearchText`.
+- `src/search/nested-search.ts`: `runNestedSearch`, `nestedSearchId` and `searchConfigCodec`.
 - `src/ledger-core/`: hashing, locking, durable appends, chain verification, and the trusted-head pin.

package/docs/trace-contracts.md

@@ -149,9 +149,7 @@ const result = checkTraceContracts(await store.spans({ runId }), [contract])
 
 ## Gate CI on a contract
 
-**Unreleased.** `traces check` lives on `feat/traces-check` in `/traces` (PR #128), proven against this package but not yet mergeable: it needs the traces/agent-runtime redaction-core migration first, so a `/traces` build on this package's contract API does not crash at load. Until then, call `evaluateTraceContract` / `checkTraceContracts` directly, as shown above.
-
-`traces check` runs a contract over a recorded trace and exits with a code a CI step can read:
+`traces check` (`@tangle-network/traces` 0.16.3+) runs a contract over a recorded trace and exits with a code a CI step can read:
 
 ```sh
 traces check spans.otlp.jsonl --contract refund-desk.contract.json --junit contract.xml

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangle-network/agent-eval",
-  "version": "0.197.0",
+  "version": "0.198.1",
   "description": "Evaluate and improve AI agents from runs, traces, judges, and feedback. Compare candidates, cluster failures, measure lift, and gate releases.",
   "homepage": "https://github.com/tangle-network/agent-eval#readme",
   "repository": {
@@ -104,6 +104,11 @@
       "import": "./dist/campaign/index.js",
       "default": "./dist/campaign/index.js"
     },
+    "./search": {
+      "types": "./dist/search/index.d.ts",
+      "import": "./dist/search/index.js",
+      "default": "./dist/search/index.js"
+    },
     "./ledger-core": {
       "types": "./dist/ledger-core/index.d.ts",
       "import": "./dist/ledger-core/index.js",

package/dist/active-curriculum-OjIWgrUJ.js

@@ -1,204 +0,0 @@
-import { i as makeRng } from "./internal-BMFSR8Ns.js";
-import { n as observedScore } from "./reward-nw2xZGZG.js";
-//#region src/rl/active-curriculum.ts
-/**
-* Adaptive curriculum / active scenario selection.
-*
-* Fixed scenario sets waste sample budget on cells the policy already
-* passes (no information left) and cells the policy never passes (no
-* gradient available either). Active learning over scenarios fixes this
-* by allocating the next sample budget to cells where the policy's
-* outcome is *uncertain* — those carry the most decision-relevant signal.
-*
-* This module ships two complementary strategies:
-*
-*   1. **Variance-based** — score each (variant, scenario) cell by the
-*      empirical variance of past observations. Allocate next-round budget
-*      proportional to variance. Standard active-learning-by-uncertainty
-*      heuristic; works well when the policy is non-deterministic and
-*      cells differ in observation noise.
-*
-*   2. **Bandit-based (Thompson sampling)** — model each (variant,
-*      scenario) cell as a Beta-Bernoulli arm; sample a posterior; pick
-*      cells whose posterior mean is closest to the per-scenario decision
-*      threshold. The right primitive when scenarios are
-*      "pass/fail" rather than continuous, and when promotion gates fire
-*      at a known threshold (e.g., 0.5).
-*
-* The output is a *next-round budget allocation* — a list of (variant,
-* scenario, count) triples. The consumer's matrix runner consumes the
-* allocation, runs those cells, feeds the new observations back. Loop.
-*
-* Out of scope (deliberate): scenario *generation* — that's the
-* adversarial primitive's job. This module allocates over an existing
-* scenario pool.
-*/
-/**
-* Variance-proportional allocation. For each cell, estimate variance from
-* past observations + a prior, then allocate the budget proportional to
-* (sqrt(variance) + 1/sqrt(n)) — a classical optimal-allocation rule
-* (Neyman 1934) that balances "explore noisy cells" with "explore
-* under-sampled cells."
-*/
-function varianceBasedCurriculum(observations, candidateCells, opts) {
-	const variancePrior = opts.variancePrior ?? .05;
-	const floor = opts.floorPerCell ?? 1;
-	const budget = opts.budget;
-	const grouped = /* @__PURE__ */ new Map();
-	for (const o of observations) {
-		const k = `${o.variantId}::${o.scenarioId}`;
-		const arr = grouped.get(k) ?? [];
-		arr.push(o.score);
-		grouped.set(k, arr);
-	}
-	const cellStats = candidateCells.map((c) => {
-		const k = `${c.variantId}::${c.scenarioId}`;
-		const samples = grouped.get(k) ?? [];
-		const n = samples.length;
-		const mean = n === 0 ? .5 : samples.reduce((s, v) => s + v, 0) / n;
-		const variance = n < 2 ? variancePrior : samples.reduce((s, v) => s + (v - mean) ** 2, 0) / (n - 1) + variancePrior;
-		const weight = Math.sqrt(variance) + 1 / Math.sqrt(Math.max(1, n));
-		return {
-			variantId: c.variantId,
-			scenarioId: c.scenarioId,
-			n,
-			mean,
-			variance,
-			weight
-		};
-	});
-	const floorTotal = floor * cellStats.length;
-	if (floorTotal >= budget) {
-		const each = Math.max(1, Math.floor(budget / Math.max(1, cellStats.length)));
-		return cellStats.map((c) => ({
-			variantId: c.variantId,
-			scenarioId: c.scenarioId,
-			count: each,
-			reason: `floor allocation (budget tight; n=${c.n})`
-		}));
-	}
-	const remaining = budget - floorTotal;
-	const totalWeight = cellStats.reduce((s, c) => s + c.weight, 0);
-	return cellStats.map((c) => {
-		const proportional = totalWeight === 0 ? 0 : Math.round(c.weight / totalWeight * remaining);
-		return {
-			variantId: c.variantId,
-			scenarioId: c.scenarioId,
-			count: floor + proportional,
-			reason: `variance ${c.variance.toFixed(3)} (n=${c.n}, mean=${c.mean.toFixed(3)})`
-		};
-	});
-}
-/**
-* Thompson-sampling-style allocation for pass/fail cells. For each cell:
-*
-*   - Maintain Beta(α + passes, β + failures) posterior on pass-rate
-*   - Allocation weight ∝ exp(-((sampledMean - threshold) / σ)^2):
-*     cells whose sampled posterior straddles the decision boundary get
-*     the most weight; cells already clearly above or below get less.
-*
-* This is the right primitive when promotion gates fire at a known
-* threshold and you want to sharpen the posterior near the boundary.
-*/
-function thompsonCurriculum(observations, candidateCells, opts) {
-	const threshold = opts.decisionThreshold ?? .5;
-	const alpha0 = opts.priorAlpha ?? 1;
-	const beta0 = opts.priorBeta ?? 1;
-	const rng = makeRng(opts.seed, observations.map((observation) => observation.score));
-	const grouped = /* @__PURE__ */ new Map();
-	for (const o of observations) {
-		const k = `${o.variantId}::${o.scenarioId}`;
-		const cur = grouped.get(k) ?? {
-			passes: 0,
-			failures: 0
-		};
-		if (o.pass ?? o.score >= threshold) cur.passes += 1;
-		else cur.failures += 1;
-		grouped.set(k, cur);
-	}
-	const stats = candidateCells.map((c) => {
-		const k = `${c.variantId}::${c.scenarioId}`;
-		const cur = grouped.get(k) ?? {
-			passes: 0,
-			failures: 0
-		};
-		const a = alpha0 + cur.passes;
-		const b = beta0 + cur.failures;
-		const sampled = sampleBeta(a, b, rng);
-		const distance = Math.abs(sampled - threshold);
-		const variance = a * b / ((a + b) ** 2 * (a + b + 1));
-		const sigma = Math.max(.05, Math.sqrt(variance));
-		const weight = Math.exp(-((distance / sigma) ** 2));
-		return {
-			variantId: c.variantId,
-			scenarioId: c.scenarioId,
-			n: cur.passes + cur.failures,
-			sampled,
-			sigma,
-			weight,
-			a,
-			b
-		};
-	});
-	const totalWeight = stats.reduce((s, c) => s + c.weight, 0);
-	return stats.map((c) => {
-		const proportional = totalWeight === 0 ? 0 : Math.round(c.weight / totalWeight * opts.budget);
-		return {
-			variantId: c.variantId,
-			scenarioId: c.scenarioId,
-			count: Math.max(0, proportional),
-			reason: `Beta(${c.a.toFixed(1)},${c.b.toFixed(1)}) sample=${c.sampled.toFixed(3)} (target ${threshold})`
-		};
-	});
-}
-/** Convenience: extract `CellObservation[]` directly from `RunRecord[]`. */
-function observationsFromRunRecords(runs, opts = {}) {
-	const threshold = opts.passThreshold ?? .5;
-	const useHoldout = opts.useHoldout ?? true;
-	const out = [];
-	for (const r of runs) {
-		if (!r.scenarioId) continue;
-		const score = observedScore(r, useHoldout ? "holdout" : "search");
-		if (typeof score !== "number" || !Number.isFinite(score)) continue;
-		out.push({
-			variantId: r.candidateId,
-			scenarioId: r.scenarioId,
-			score,
-			pass: score >= threshold
-		});
-	}
-	return out;
-}
-/**
-* Sample from Beta(α, β) via the Marsaglia–Tsang method using two Gamma
-* variates. Accuracy is good for α, β > 1; we floor the parameters at 1
-* to avoid degenerate cases.
-*/
-function sampleBeta(alpha, beta, rng) {
-	const a = Math.max(1, alpha);
-	const b = Math.max(1, beta);
-	const x = sampleGamma(a, rng);
-	return x / (x + sampleGamma(b, rng));
-}
-function sampleGamma(shape, rng) {
-	const d = shape - 1 / 3;
-	const c = 1 / Math.sqrt(9 * d);
-	while (true) {
-		let x;
-		let v;
-		do {
-			const u1 = rng() || 1e-12;
-			const u2 = rng() || 1e-12;
-			x = Math.sqrt(-2 * Math.log(u1)) * Math.cos(2 * Math.PI * u2);
-			v = 1 + c * x;
-		} while (v <= 0);
-		v = v * v * v;
-		const u = rng();
-		if (u < 1 - .0331 * x ** 4) return d * v;
-		if (Math.log(u) < .5 * x * x + d * (1 - v + Math.log(v))) return d * v;
-	}
-}
-//#endregion
-export { thompsonCurriculum as n, varianceBasedCurriculum as r, observationsFromRunRecords as t };
-
-//# sourceMappingURL=active-curriculum-OjIWgrUJ.js.map

package/dist/active-curriculum-OjIWgrUJ.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"active-curriculum-OjIWgrUJ.js","names":[],"sources":["../src/rl/active-curriculum.ts"],"sourcesContent":["/**\n * Adaptive curriculum / active scenario selection.\n *\n * Fixed scenario sets waste sample budget on cells the policy already\n * passes (no information left) and cells the policy never passes (no\n * gradient available either). Active learning over scenarios fixes this\n * by allocating the next sample budget to cells where the policy's\n * outcome is *uncertain* — those carry the most decision-relevant signal.\n *\n * This module ships two complementary strategies:\n *\n *   1. **Variance-based** — score each (variant, scenario) cell by the\n *      empirical variance of past observations. Allocate next-round budget\n *      proportional to variance. Standard active-learning-by-uncertainty\n *      heuristic; works well when the policy is non-deterministic and\n *      cells differ in observation noise.\n *\n *   2. **Bandit-based (Thompson sampling)** — model each (variant,\n *      scenario) cell as a Beta-Bernoulli arm; sample a posterior; pick\n *      cells whose posterior mean is closest to the per-scenario decision\n *      threshold. The right primitive when scenarios are\n *      \"pass/fail\" rather than continuous, and when promotion gates fire\n *      at a known threshold (e.g., 0.5).\n *\n * The output is a *next-round budget allocation* — a list of (variant,\n * scenario, count) triples. The consumer's matrix runner consumes the\n * allocation, runs those cells, feeds the new observations back. Loop.\n *\n * Out of scope (deliberate): scenario *generation* — that's the\n * adversarial primitive's job. This module allocates over an existing\n * scenario pool.\n */\n\nimport { observedScore } from '../rollout/reward'\nimport type { RunRecord } from '../run-record'\nimport { makeRng } from '../statistics/internal'\n\nexport interface CellObservation {\n  variantId: string\n  scenarioId: string\n  /** Observed score in [0, 1]. */\n  score: number\n  /** For Bernoulli arms — derive from the score with a threshold if needed. */\n  pass?: boolean\n}\n\nexport interface CurriculumAllocation {\n  variantId: string\n  scenarioId: string\n  /** How many additional reps to run on this cell. */\n  count: number\n  /** Strategy-specific reason for the allocation. */\n  reason: string\n}\n\nexport interface VarianceCurriculumOptions {\n  /** Total reps to allocate across all cells. */\n  budget: number\n  /**\n   * Smoothing prior on variance — keeps the allocator from concentrating\n   * on a cell with one observation just because its 1-sample variance is\n   * 0. Default 0.05.\n   */\n  variancePrior?: number\n  /**\n   * Minimum reps per cell — even when the variance estimate is low, give\n   * every cell at least this many. Default 1.\n   */\n  floorPerCell?: number\n}\n\n/**\n * Variance-proportional allocation. For each cell, estimate variance from\n * past observations + a prior, then allocate the budget proportional to\n * (sqrt(variance) + 1/sqrt(n)) — a classical optimal-allocation rule\n * (Neyman 1934) that balances \"explore noisy cells\" with \"explore\n * under-sampled cells.\"\n */\nexport function varianceBasedCurriculum(\n  observations: CellObservation[],\n  candidateCells: Array<{ variantId: string; scenarioId: string }>,\n  opts: VarianceCurriculumOptions,\n): CurriculumAllocation[] {\n  const variancePrior = opts.variancePrior ?? 0.05\n  const floor = opts.floorPerCell ?? 1\n  const budget = opts.budget\n\n  const grouped = new Map<string, number[]>()\n  for (const o of observations) {\n    const k = `${o.variantId}::${o.scenarioId}`\n    const arr = grouped.get(k) ?? []\n    arr.push(o.score)\n    grouped.set(k, arr)\n  }\n\n  const cellStats = candidateCells.map((c) => {\n    const k = `${c.variantId}::${c.scenarioId}`\n    const samples = grouped.get(k) ?? []\n    const n = samples.length\n    const mean = n === 0 ? 0.5 : samples.reduce((s, v) => s + v, 0) / n\n    const variance =\n      n < 2\n        ? variancePrior\n        : samples.reduce((s, v) => s + (v - mean) ** 2, 0) / (n - 1) + variancePrior\n    // Neyman optimal allocation: weight ∝ √variance; add √(1/n) to break\n    // ties toward under-sampled cells.\n    const weight = Math.sqrt(variance) + 1 / Math.sqrt(Math.max(1, n))\n    return { variantId: c.variantId, scenarioId: c.scenarioId, n, mean, variance, weight }\n  })\n\n  // Reserve floor*N for the floor; allocate the rest proportional to weight.\n  const floorTotal = floor * cellStats.length\n  if (floorTotal >= budget) {\n    const each = Math.max(1, Math.floor(budget / Math.max(1, cellStats.length)))\n    return cellStats.map((c) => ({\n      variantId: c.variantId,\n      scenarioId: c.scenarioId,\n      count: each,\n      reason: `floor allocation (budget tight; n=${c.n})`,\n    }))\n  }\n  const remaining = budget - floorTotal\n  const totalWeight = cellStats.reduce((s, c) => s + c.weight, 0)\n  return cellStats.map((c) => {\n    const proportional = totalWeight === 0 ? 0 : Math.round((c.weight / totalWeight) * remaining)\n    return {\n      variantId: c.variantId,\n      scenarioId: c.scenarioId,\n      count: floor + proportional,\n      reason: `variance ${c.variance.toFixed(3)} (n=${c.n}, mean=${c.mean.toFixed(3)})`,\n    }\n  })\n}\n\nexport interface ThompsonCurriculumOptions {\n  budget: number\n  /**\n   * The per-scenario decision threshold. Cells whose posterior mean is\n   * closest to this get the most budget — that's where the next observation\n   * has the highest information value for the gate decision. Default 0.5.\n   */\n  decisionThreshold?: number\n  /** Beta prior parameters. Default α=β=1 (uniform). */\n  priorAlpha?: number\n  priorBeta?: number\n  /** Seed the Thompson sampler. Absent, the seed is derived from the observed\n   *  scores, so the same observations reproduce the same allocation. */\n  seed?: number\n}\n\n/**\n * Thompson-sampling-style allocation for pass/fail cells. For each cell:\n *\n *   - Maintain Beta(α + passes, β + failures) posterior on pass-rate\n *   - Allocation weight ∝ exp(-((sampledMean - threshold) / σ)^2):\n *     cells whose sampled posterior straddles the decision boundary get\n *     the most weight; cells already clearly above or below get less.\n *\n * This is the right primitive when promotion gates fire at a known\n * threshold and you want to sharpen the posterior near the boundary.\n */\nexport function thompsonCurriculum(\n  observations: CellObservation[],\n  candidateCells: Array<{ variantId: string; scenarioId: string }>,\n  opts: ThompsonCurriculumOptions,\n): CurriculumAllocation[] {\n  const threshold = opts.decisionThreshold ?? 0.5\n  const alpha0 = opts.priorAlpha ?? 1\n  const beta0 = opts.priorBeta ?? 1\n  const rng = makeRng(\n    opts.seed,\n    observations.map((observation) => observation.score),\n  )\n\n  const grouped = new Map<string, { passes: number; failures: number }>()\n  for (const o of observations) {\n    const k = `${o.variantId}::${o.scenarioId}`\n    const cur = grouped.get(k) ?? { passes: 0, failures: 0 }\n    const pass = o.pass ?? o.score >= threshold\n    if (pass) cur.passes += 1\n    else cur.failures += 1\n    grouped.set(k, cur)\n  }\n\n  const stats = candidateCells.map((c) => {\n    const k = `${c.variantId}::${c.scenarioId}`\n    const cur = grouped.get(k) ?? { passes: 0, failures: 0 }\n    const a = alpha0 + cur.passes\n    const b = beta0 + cur.failures\n    // Sample a single Beta draw — the Thompson signal.\n    const sampled = sampleBeta(a, b, rng)\n    const distance = Math.abs(sampled - threshold)\n    // Information-near-threshold weight: closer = higher.\n    // Use Gaussian-shaped kernel with σ tuned to posterior std.\n    const variance = (a * b) / ((a + b) ** 2 * (a + b + 1))\n    const sigma = Math.max(0.05, Math.sqrt(variance))\n    const weight = Math.exp(-((distance / sigma) ** 2))\n    return {\n      variantId: c.variantId,\n      scenarioId: c.scenarioId,\n      n: cur.passes + cur.failures,\n      sampled,\n      sigma,\n      weight,\n      a,\n      b,\n    }\n  })\n\n  const totalWeight = stats.reduce((s, c) => s + c.weight, 0)\n  return stats.map((c) => {\n    const proportional = totalWeight === 0 ? 0 : Math.round((c.weight / totalWeight) * opts.budget)\n    return {\n      variantId: c.variantId,\n      scenarioId: c.scenarioId,\n      count: Math.max(0, proportional),\n      reason: `Beta(${c.a.toFixed(1)},${c.b.toFixed(1)}) sample=${c.sampled.toFixed(3)} (target ${threshold})`,\n    }\n  })\n}\n\n/** Convenience: extract `CellObservation[]` directly from `RunRecord[]`. */\nexport function observationsFromRunRecords(\n  runs: RunRecord[],\n  opts: { passThreshold?: number; useHoldout?: boolean } = {},\n): CellObservation[] {\n  const threshold = opts.passThreshold ?? 0.5\n  const useHoldout = opts.useHoldout ?? true\n  const out: CellObservation[] = []\n  for (const r of runs) {\n    if (!r.scenarioId) continue\n    // Ungated on purpose, and the precedence is caller policy, not a default:\n    // `useHoldout: false` means \"score this curriculum on the search split when\n    // both exist\". This feeds sampling COUNTS, not an exported reward. Known\n    // risk: a gamed run's high score inflates the cell's Beta posterior, so the\n    // curriculum stops sampling a cell it wrongly believes is solved. The fix\n    // for that is an upstream filter on gated records — zeroing the score here\n    // would push the posterior the opposite way and be equally wrong.\n    const score = observedScore(r, useHoldout ? 'holdout' : 'search')\n    if (typeof score !== 'number' || !Number.isFinite(score)) continue\n    out.push({\n      variantId: r.candidateId,\n      scenarioId: r.scenarioId,\n      score,\n      pass: score >= threshold,\n    })\n  }\n  return out\n}\n\n// ── Helpers ──────────────────────────────────────────────────────────────\n\n/**\n * Sample from Beta(α, β) via the Marsaglia–Tsang method using two Gamma\n * variates. Accuracy is good for α, β > 1; we floor the parameters at 1\n * to avoid degenerate cases.\n */\nfunction sampleBeta(alpha: number, beta: number, rng: () => number): number {\n  const a = Math.max(1, alpha)\n  const b = Math.max(1, beta)\n  const x = sampleGamma(a, rng)\n  const y = sampleGamma(b, rng)\n  return x / (x + y)\n}\n\nfunction sampleGamma(shape: number, rng: () => number): number {\n  // Marsaglia–Tsang for shape ≥ 1.\n  const d = shape - 1 / 3\n  const c = 1 / Math.sqrt(9 * d)\n  while (true) {\n    let x: number\n    let v: number\n    do {\n      const u1 = rng() || 1e-12\n      const u2 = rng() || 1e-12\n      // Box-Muller for a normal sample.\n      x = Math.sqrt(-2 * Math.log(u1)) * Math.cos(2 * Math.PI * u2)\n      v = 1 + c * x\n    } while (v <= 0)\n    v = v * v * v\n    const u = rng()\n    if (u < 1 - 0.0331 * x ** 4) return d * v\n    if (Math.log(u) < 0.5 * x * x + d * (1 - v + Math.log(v))) return d * v\n  }\n}\n"],"mappings":"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"}