@tangle-network/agent-eval 0.128.2 → 0.130.0

package/CHANGELOG.md

@@ -4,6 +4,285 @@ All notable changes to `@tangle-network/agent-eval` and its sibling `agent-eval-
 
 ---
 
+## [0.130.0] - 2026-07-26 - current dependency and build cohort
+
+### Changed
+
+- Updated Agent Core to `0.4.24` and Agent Interface to `0.35.0`.
+- Updated TypeScript to `7.0.2` and replaced the unsupported declaration build with `tsdown`.
+- Replaced the TypeScript compiler import in the score derivation source check with `oxc-parser`.
+- Updated GitHub Actions to their current stable major releases.
+
+### Fixed
+
+- Release checks now validate package metadata and every ESM and bundler type entrypoint before publish.
+- Removed two obsolete declaration build scripts and stale release instructions.
+
+## [0.129.0] - 2026-07-25 - provider-neutral chat and canonical rollout training
+
+### Changed
+
+- **Breaking:** benchmark, driver, executor, judge, completion-checker, tracing, and analyst APIs now accept `ChatClient`.
+- **Breaking:** removed the exported provider SDK type, direct provider SDK dependency, provider-specific retry fields, and custom completion-checker error receipt callback.
+- **Breaking:** `LlmClientOptions.maximumAttempts` replaces the misleading `maxRetries` name, which already represented total attempts.
+- **Breaking:** `toGrpoRows`, `toSftRows`, `extractPreferences`, and `buildRlDataset` accept only `MintedRolloutLine[]`.
+  Convert run records once with `mintRolloutRows`.
+- **Breaking:** removed `rolloutReward`, record-input training overloads, record-only reward hooks, duplicate line lookup and preference option types, and the duplicate dataset split map.
+- **Breaking:** removed scalar belief-state and off-policy `qHat` fields; contextual estimates require `qHatChosen` and `vHatTarget` together.
+- **Breaking:** removed `CampaignAggregates.totalCostUsd`, `CostLedgerEntry`, `VerifiableReward.breakdown`, and the fixed-prompt `JudgeFn` factories.
+- **Breaking:** removed the unused `OptimizationProposer` alias; use `SurfaceProposer`.
+- **Breaking:** `CampaignStorage.append` is required; read/write-only storage adapters are no longer accepted.
+- **Breaking:** `RawAnalystFinding` now has one plural `evidence` field.
+  Removed the duplicate `CanonicalRawAnalystFinding` names, singular-evidence adapters, the second
+  recovery callback, `AnalystRunSummary.cost_usd`, and finding-metadata cost accounting.
+- Paid calls read canonical `ChatResponse.content`, usage, model, duration, and cost.
+- Cost reservations derive provider retries from `ChatClient.maximumAttempts`; capped calls reject clients that do not declare a finite attempt count.
+- `createChatClient({ transport: 'custom' })` adapts external SDKs and transports without importing them into Agent Eval.
+- Updated Agent Core to `0.4.22` and Agent Interface to `0.34.0`.
+- No compatibility aliases, overloads, environment fallbacks, or alternate readers preserve these
+  removed fields and functions.
+- Settled cost events accept one current receipt shape, and execution summaries read only
+  `outcome.raw.execution_error_count`.
+- Single-run locks accept only structured owner records; plain-PID lock files are rejected.
+
+### Fixed
+
+- **A run flagged as gamed exported at full positive reward through every RL path.** The realness gate
+  (`outcome.realness.gated`) existed in exactly one function, `rolloutReward`, called from exactly one
+  place — `mintRolloutRows`. The same derivation, `outcome.holdoutScore ?? outcome.searchScore`, was
+  hand-rolled at 20 other sites with no gate. Six of those sites feed exported training data: the GRPO
+  default reward and the SFT row metadata (`rl/exporters.ts`), the DPO preference ordering
+  (`rl/preferences.ts`), the probabilistic verifiable-reward fallback (`rl/verifiable-reward.ts`), the
+  corpus `minScore` filter (`rl/corpus.ts`), and the published datasheet's reward statistics
+  (`rl/dataset.ts`). A gamed run therefore trained at its claimed score, and in DPO it became the
+  *chosen* side of a pair against its honest sibling. Every one of those six now derives its reward
+  through the gate.
+
+### Added
+
+- `trainingScore`, `trainingReward`, `observedScore`, `isRealnessGated`, and the `ScorePreference`
+  type — the score derivation now lives once, in `src/rollout/reward.ts`, behind two names that force
+  the caller to state intent. `trainingScore` / `trainingReward` are gated and required for anything a
+  trainer or an exported dataset consumes; `observedScore` is raw and documented as unsafe for
+  training data. Raw is a legitimate choice — reward-hack detection, scorecards, and curriculum
+  allocation need the ungated number, and gating a detector's proxy would make it report "clean" on
+  precisely the population being gamed — so the fix names the choice rather than removing it.
+- A regression test (`src/rollout/reward-invariant.test.ts`) with two halves: a source-level check that
+  the bare derivation appears nowhere outside `rollout/reward.ts`, and a behavioural check that pushes
+  one gated record with a 0.95 score through mint, GRPO, SFT, DPO, verifiable reward, the dataset
+  bundle, and the corpus filter, asserting 0 in each. Against the pre-fix tree the source check reports
+  21 offending lines and 7 of the 10 tests fail.
+
+### Changed
+
+- `rolloutReward` was removed.
+  Use `trainingReward` for score derivation or `rolloutRewardFields` when producing a rollout outcome.
+- The 14 analysis, reporting, and detection sites that legitimately want the raw number now call
+  `observedScore` explicitly. Behaviour is unchanged at all 14, including the two sites that
+  deliberately prefer the search split (`rl/active-curriculum.ts`, via the new `ScorePreference`
+  argument). (`description-length-gate.ts` reads through `runTaskScore`, which 0.127.0 stripped of
+  its obsolete `raw.score` fallback.)
+
+### Fixed — second pass (the waist now enforces its own invariant)
+
+An adversarial review of the pass above found the hole still open on 13 paths. Its core finding:
+`validateRolloutLine({outcome: {reward: 0.95, realness_gated: true}})` returned **zero errors**. It
+type-checked `reward` and it type-checked `realness_gated`, and never once checked the RELATIONSHIP
+between them. `RolloutLine` was a plain structural interface, so any object literal of that shape WAS
+one — "the input is a rollout line" guaranteed nothing, and the ledger round-tripped a poisoned line
+unchanged.
+
+- **The invariant now lives in the validator.** `validateRolloutLine` / `assertRolloutLine` reject
+  `reward > 0` together with `realness_gated: true`, with an error that explains the rule rather than
+  naming the fields. Because `writeRolloutLedger` and `readRolloutLedger` both assert, a poisoned line
+  can neither enter a ledger nor leave one — which closes the published-CLI path (`agent-eval
+  rollout-release`) at its entrance: `buildHfDataset` reads through `readRolloutLedger`, so the gated
+  line is refused before `verifiers/train.jsonl` and `rft/train.jsonl` are written. The dataset card's
+  claim about the flag was a **false claim on a published artifact** until now; it is now enforced, and
+  the card states the count of gated lines it shipped.
+- **And in the type system.** `MintedRolloutLine` brands the line with a phantom `unique symbol`
+  (nothing at runtime, identical JSON). It is produced only by `mintRolloutRows`, `readRolloutLedger`,
+  or an explicit `assertMinted` / `assertMintedLines`. The training exporters now require it:
+  `rollout/exporters` (`toSftRows`, `toRewardRows`, `toVerifiersRolloutOutput(s)`, `toRftItem(s)`),
+  `rl/exporters` (`toGrpoRows`, `toSftRows`, `PrmLineContext.lines`), `rl/preferences.extractPreferences`,
+  and `rl/dataset.buildRlDataset`. Belt and braces on purpose: the brand closes first-party call sites
+  at compile time, the validator closes data arriving at runtime.
+- **The regex guard is replaced, not extended.** `src/rollout/score-derivation-guard.ts` walks the
+  TypeScript AST of `src/**` and flags every READ of `outcome.holdoutScore` / `outcome.searchScore`
+  outside a *counted* allowlist (writes and declarations are untouched). The old line regex caught 2 of
+  the 7 re-derivations the review planted; the AST rule catches all 7, and they are kept as a permanent
+  fixture in `reward-invariant.test.ts` rather than a one-time demonstration.
+- **`supervisorRunRolloutLines` was a second minting door**, writing `outcome.reward` from the judge
+  score and omitting `realness_gated` entirely. It now states the flag explicitly on every supervisor
+  and worker row, and its rows are plain `RolloutLine`s — a caller putting them into a training export
+  has to run them through `assertMinted` first.
+- **`EvalTraceStore.getBest` ranked few-shot exemplars on the ungated score** while its doc comment
+  claimed otherwise. `runScore` is now gated, and `getBest` drops realness-gated runs outright instead
+  of ranking them: whatever it returns is pasted into the next agent's prompt as an example to imitate,
+  so the SFT rule applies. When every run for a scenario is gated the answer is `null`, not the
+  least-bad fake.
+- **`release-confidence.passRate` counted a gamed run as a pass.** Gated runs are now excluded from
+  both numerator and denominator, and the count ships beside the rate as `metrics.realnessGatedRuns`.
+  `HeldOutGate` gets the same treatment: gated runs are dropped from both sides before pairing, with
+  `evidence.realnessGatedRuns` surfacing how many. Never a silent 0 — a shrunken denominator has to say
+  by how much.
+- **Ten remaining hand-rolled derivations routed by classification**: `rl/sim-fidelity.ts` (×2, RAW —
+  gating a sim-vs-production divergence measure would report the simulator as more faithful precisely
+  where it is gamed), `belief-state/code-agent-corpus.ts` (GATED — its output becomes corpus labels),
+  `eval-trace-store.ts` (GATED, above), `contract/analyze-runs.ts` (×3, RAW), `summary-report.ts` (×4,
+  RAW), `release-confidence.ts` (RAW), `held-out-gate.ts` (RAW, over an already-degated set).
+- **`trainingReward` no longer collapses an unscored record to 0.** It returns `reward: null`, matching
+  the schema's own "a labeled gap, never 0" rule; a gated run still returns 0, because that IS a
+  verdict. Previously a run nobody graded was indistinguishable from one graded a total failure.
+
+### Fixed — the published dataset (`agent-eval rollout-release`)
+
+- **The card's gate claim is no longer a sentence; it is a rendering of measured counts.** A README that
+  STATES what the build does is a claim about bytes it never reads, and it drifts the moment an exporter
+  changes — to whoever downloads the dataset. `buildHfDataset` now exports the rows for every selected
+  format, measures the realness-gated rows among them (`measureFormatGate`, matched on `rollout_id`),
+  checks the measurement against the declared per-format policy, and only then writes. `buildDatasetCard`
+  requires that report, renders it, and **throws** if it disagrees with the lines it describes or with the
+  policy. A card that contradicts its own data files cannot be produced without failing the build first.
+  The measurement also ships on `BuildSummary.gate` and in the CLI's stdout JSON.
+- **Nothing is written when any config would ship a gated row above reward 0.** Formats used to be
+  exported and written one at a time; a build that failed halfway left a poisoned config on disk for
+  someone to `--push`. Rows are now computed and gate-checked for every format before the first byte.
+- **The per-format decision is stated once as data**, in `src/rollout/release/gate-report.ts`:
+  `sft: 'exclude'` (an SFT row is imitated verbatim — a gamed trajectory must not appear at any weight),
+  `verifiers` / `rft` / `raw`: `'zero-and-flag'`. Keeping gated rows in the last three is deliberate: in
+  `verifiers` the reward is a signed learning signal, so a gamed trajectory at reward 0 is a correct
+  negative, and dropping it would bias the negative population toward honest failures and leave a trainer
+  no example of gaming being penalized; `rft` re-samples the completion, so only the prompt and the grader
+  reference ship; `raw` is an audit dump, where the gated row is the one an auditor most wants.
+- **Reward 0 is never the only label.** Zeroing without the flag makes a faked success indistinguishable
+  from an honest failure — it hides the gamed population instead of disclosing it. `VerifiersRolloutOutput.
+  info.realness_gated`, `RftItem.reference.realness_gated`, and `RewardRow.metadata.realness_gated` are new
+  and always present, so a consumer can filter the population out or select it for a gaming detector.
+
+### Fixed — Harbor ATIF interchange (`src/rollout/interchange/harbor.ts`)
+
+- **Export emitted documents that violate ATIF MUST rule 2.** Tool results were folded into the
+  `observation` of whichever step happened to PRECEDE them, so an assistant turn that declared no tool
+  calls could carry a `source_call_id`, a result could be attached to a step that declared a different
+  call, and an unanswered result rode a synthetic `system` step carrying a `source_call_id` a system
+  step can never declare. Results now attach only to the step that declared their `tool_call_id`;
+  everything else becomes a carrier step whose observation states no call id and escrows it instead.
+  Message order is preserved exactly in every case, and `ruleTwoViolations` checks the whole tree in
+  the tests.
+- **`logprobs`, `prompt_token_ids`, `completion_token_ids` and per-step `llm_call_count` were adopted
+  onto our types but never wired through the interchange.** They were escrowed under
+  `extra.tangle.spans`, where no foreign consumer looks, and ATIF's own `step.metrics` /
+  `step.llm_call_count` were left empty in both directions — so a Harbor-native file's logprobs were
+  read, validated, and dropped. They now travel on the native channel both ways (escrow still wins on
+  import for exactness); a step carrying none of them still produces no span.
+- **`session_id` was invocation-scoped.** ATIF's `session_id` is RUN-scoped; export set it to the root
+  LINE's `rollout_id`, so two roots of one run got different session ids and foreign tooling grouping
+  by session split the run. It is now `run_id`, on every node.
+- **`is_copied_context` (RFC rule 7) was silently dropped on import.** It is now a field on
+  `ChatMessage`, validated, carried both ways on ATIF's native step field, and — the part the RFC
+  actually mandates — `toSftRows` excludes those turns, dropping the row entirely if nothing else is
+  left.
+- **An escrowed split was trusted from any document.** `extra.tangle.task.split: 'search'` in a
+  hand-written or third-party file imported as a TRAINABLE split; the escrow key is namespaced, not
+  authenticated. Import now forces `holdout` unconditionally, and promotion is an explicit, greppable
+  step (`relabelImportedSplit`) so `grep` enumerates every place foreign data was declared trainable.
+- **Round-tripping was not idempotent.** `provenance.gap` accreted one copy of the import note per
+  pass, and imported messages were assembled in an order that depended on which optional fields were
+  present, so a ledger hashed on serialized bytes saw a diff. The gap is now composed as a
+  de-duplicated ordered set and every imported message is built in the canonical schema key order.
+- **The interchange was not root-exported.** `import { toHarborTrajectory } from
+  '@tangle-network/agent-eval'` failed — the symbols existed only on the `/rollout` subpath while every
+  other rollout symbol was on both.
+- **The reward-absence test was a substring scan.** `expect(serialized).not.toContain('reward')` passed
+  only because the fixture happened to have no reward-shaped key in `outcome.metrics`; it says nothing
+  about WHERE a match is and false-positives on any metric named e.g. `reward_hack_rate`. It is now a
+  structural walk that reports the PATH of every label-shaped key, exempting the escrowed metrics bag
+  by path.
+
+### Known gap (not fixed here)
+
+- `mintRolloutRows` hardcodes `tool_defs: []`, so `agent.tool_definitions` is absent on every minted
+  line's ATIF export. This is a capture-side gap, not an interchange one: neither `RunRecord` nor the
+  trace-span projection carries a tool schema, so there is nothing for mint to read. Fixing it means
+  recording the harness's tool definitions at capture time.
+
+### Fixed — unrelated flake encountered on the way
+
+- `node:sqlite` is loaded through `createRequire` in `rollout/readers/opencode-sqlite.ts` and its test.
+  esbuild and Vite both rewrite an `import()` of a builtin and strip the `node:` prefix, producing a bogus
+  `sqlite` package lookup; composing the specifier at runtime did not reliably defeat it, so the failure
+  moved between workers whenever a test file was added. A require obtained from `createRequire` is not an
+  analyzable module reference in either tool.
+
+### Added — second pass
+
+- `MintedRolloutLine`, `MintedRolloutOutcome`, `assertMinted`, `assertMintedLines` (rollout barrel +
+  root barrel).
+- `observedSplitScore` (the raw score on ONE split, no cross-split fallback — what every split-scoped
+  report and promotion gate actually wants) and `scoreOrigin` / `ScoreOrigin` (which split carried the
+  score, or that none did — the provenance `reward_source` is built from).
+- `malformedRolloutLine` in `rollout/fixtures` for tests whose subject is the validator itself;
+  `fixtureRolloutLine` now validates on every construction and returns a `MintedRolloutLine`.
+- `rollout/release/gate-report`: `FORMAT_GATE_DISPOSITION`, `GateDisposition`, `GateReport`,
+  `FormatGateCounts`, `ReleaseRowRef`, `gatedRolloutIds`, `releaseRowRefs`, `measureFormatGate`,
+  `assertGateReport` (rollout barrel). `BuildSummary.gate` and `DatasetCardInputs.gate` are new;
+  `DatasetCardInputs.gate` is required, so a card cannot be rendered without the measurement.
+
+### Fixed — third pass (one canonical training input)
+
+Trainer-facing APIs now accept canonical minted lines only.
+Artifacts that carry run ids without embedded reward state still require explicit line context.
+
+- **Record-input preference and trainer overloads were removed.**
+  Their custom reward hooks and independent filtering rules created alternate paths around the canonical rollout checks.
+  Callers now mint once and every downstream transform reads the same reward and split fields.
+- **`extractVerifiableRewardsFromRecords` gated only its judge-fallback branch.** The deterministic
+  branch — the highest-credibility channel the module emits, `determinism: 'deterministic'`,
+  `confidence: 1`, and what the module header calls "the RL training signal" — returned the layer
+  score untouched, so a gated run carrying `outcome.raw['layer.test'] = 1.0` exported at value 1 and
+  `filterDeterministicallyRewarded` kept it. That is exactly the shape of a reward-hacked coding run:
+  `realness.gated` means the success signal was faked, and a test suite reporting green on a stubbed
+  integration IS the deterministic layer being the thing that got faked. The gate applies to that
+  channel most, not least. `value` and every `components` entry are now 0 on a gated run — zeroing
+  `value` alone would let a consumer re-weighting per source reconstruct the refused reward — and the
+  new `VerifiableReward.realnessGated` distinguishes "measured a genuine failure" from "claimed a
+  success we refuse to believe", which a bare 0 cannot.
+- **`toPrmRows(triples, lookups)` — the deprecated 2-arg form — applied no gate and now fails
+  closed.** A `PrmTrainingTriple` carries a bare `chosenReward` number, so without the minted lines
+  the exporter has no way to learn that its chosen step belongs to a run that faked its success; the
+  rows it produced trained a process-reward model to prefer the gaming move at the exact step the
+  gaming happened. The overload is removed (TypeScript callers fail to compile) and the runtime
+  throws for everyone else.
+- **`supervisorRunRolloutLines` no longer writes the reward pair by hand.** `reward` and
+  `realness_gated` come out of one call in the module that owns the gate — `rolloutRewardFields` for
+  `mintRolloutRows`, `unscreenedRewardFields` for a producer with a score but no `RunRecord` behind
+  it. Two minting doors is the same class of defect as two reward derivations; there is now one
+  writer of the pair, so a future third door cannot state one field and forget the other.
+- **`EvalTraceStore.compareRuns` counted a gamed run as a silent zero.** Gating `runScore` (second
+  pass, above) fixed few-shot seeding and quietly changed this: a gamed run entered the paired
+  comparison at 0, which reads as "this candidate failed the scenario" when what happened is "this
+  candidate's result is not evidence". Gated runs are now excluded and counted in
+  `CandidateComparison.realnessGatedRuns` — the same never-a-silent-0 rule `passRate` follows.
+
+#### Deliberately NOT gated
+
+`rl/reward-hacking.ts` reads the deterministic reward through the new
+`VerifiableRewardExtractionOptions.applyRealnessGate: false`, which preserves its previous behaviour
+exactly. Its `judge_drift` and `reward_disagreement` signals measure the GAP between the judge reward
+and the deterministic one; a deterministic reward another gate already forced to 0 opens that gap by
+construction on the gamed population, so the detector would fire on its own input rather than on
+evidence it found. Same reasoning as its ungated `DEFAULT_PROXY`. The option defaults to `true` and an
+empty options object gates — the opt-out is explicit and greppable.
+
+### Known, not fixed here
+
+- `description-length-gate.ts` gives a gated run claiming `score: 1.0` the largest possible improvement
+  to its objective, and `product-benchmark/export.ts` publishes a gated run with `pass: true`. Each
+  site carries a comment naming the hole.
+- `extractVerifiableReward(report)` — the `VerificationReport` signature — cannot gate and does not
+  claim to: `realness` lives on the `RunRecord`, not on the report. Documented on the function.
+
 ## [0.128.2] - 2026-07-25 - current core contract
 
 ### Changed

package/README.md

@@ -24,6 +24,24 @@ Model calls occur only through the clients and agents you configure.
 pnpm add @tangle-network/agent-eval
 ```
 
+## Configure Model Calls
+
+Benchmarks, user drivers, executors, built-in judges, completion checkers, and judge adapters accept the same `ChatClient`.
+
+```ts
+import { createChatClient } from '@tangle-network/agent-eval'
+
+const chat = createChatClient({
+  transport: 'router',
+  apiKey: process.env.TANGLE_API_KEY!,
+  defaultModel: 'openai/gpt-4.1',
+  maximumAttempts: 3,
+})
+```
+
+Use `direct-provider` for an OpenAI-compatible endpoint, `cli-bridge` for a local subscription, `sandbox-sdk` for Sandbox, or `custom` to adapt another SDK.
+A custom adapter must return `ChatResponse` and declare `maximumAttempts` before a capped cost ledger can dispatch it.
+
 The official optimizers use the Python bridge.
 Install only the optimizer you plan to run:
 
@@ -346,6 +364,7 @@ See [concepts](./docs/concepts.md), [customer paths](./docs/customer-journeys.md
 |---|---|
 | `@tangle-network/agent-eval/contract` | Define an evaluation, run it, improve with a custom candidate generator, and analyze runs. |
 | `@tangle-network/agent-eval/campaign` | Control campaigns, official optimization methods, comparisons, storage, and release rules. |
+| `@tangle-network/agent-eval/ledger-core` | Generic hash-chained append-only journal: idempotent append, chain verification, replay-to-projection, cross-process locking. |
 | `@tangle-network/agent-eval/reporting` | Statistical comparisons and report rendering. |
 | `@tangle-network/agent-eval/analyst` | Model-assisted failure analysis. |
 | `@tangle-network/agent-eval/traces` | Store, replay, and inspect structured traces. |

package/dist/active-curriculum-C4mk67HP.js

@@ -0,0 +1,214 @@
+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);
+	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;
+}
+function makeRng(seed) {
+	if (seed === void 0) return Math.random;
+	let s = seed >>> 0;
+	return () => {
+		s = s + 1831565813 >>> 0;
+		let t = s;
+		t = Math.imul(t ^ t >>> 15, t | 1);
+		t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+		return ((t ^ t >>> 14) >>> 0) / 4294967296;
+	};
+}
+/**
+* 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-C4mk67HP.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"active-curriculum-C4mk67HP.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'\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. Default unset (Math.random). */\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(opts.seed)\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\nfunction makeRng(seed?: number): () => number {\n  if (seed === undefined) return Math.random\n  let s = seed >>> 0\n  return () => {\n    s = (s + 0x6d2b79f5) >>> 0\n    let t = s\n    t = Math.imul(t ^ (t >>> 15), t | 1)\n    t ^= t + Math.imul(t ^ (t >>> 7), t | 61)\n    return ((t ^ (t >>> 14)) >>> 0) / 4294967296\n  }\n}\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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"}

package/dist/adversarial-smnADNFS.d.ts

@@ -0,0 +1,21 @@
+//#region src/rl/adversarial.d.ts
+/**
+ * Adversarial mutation contract.
+ *
+ * `AdversarialMutation<S>` is the scenario-mutation strategy the fuzz harness
+ * (`fuzzAgent`, src/fuzz) drives: paraphrase, edge-case substitution, or
+ * compositional combination of a scenario the policy currently passes, looking
+ * for the tail inputs that break it. The harness supplies the loop; consumers
+ * supply the mutations and the failure detector.
+ */
+interface AdversarialMutation<S> {
+  id: string;
+  /**
+   * Mutate one scenario. Return null to skip; return one or more new
+   * scenarios. The harness deduplicates by `mutateScenarioId(scenario)`.
+   */
+  mutate(parent: S, rng: () => number): Promise<S[]> | S[];
+}
+//#endregion
+export { AdversarialMutation as t };
+//# sourceMappingURL=adversarial-smnADNFS.d.ts.map

package/dist/adversarial-smnADNFS.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adversarial-smnADNFS.d.ts","names":[],"sources":["../src/rl/adversarial.ts"],"mappings":";;;;;;;;;;UAUiB,oBAAoB;EACnC;;;;;EAKA,OAAO,QAAQ,GAAG,oBAAoB,QAAQ,OAAO"}