@tangle-network/agent-eval 0.129.0 → 0.130.0

package/CHANGELOG.md

@@ -4,6 +4,20 @@ 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

package/README.md

@@ -364,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"}