@tangle-network/agent-eval 0.216.1 → 0.217.1

package/dist/fuzz.d.ts

@@ -1,5 +1,5 @@
 import { a as CostLedgerHandle, m as MaximumCharge, r as CostChannel } from "./cost-ledger-Jk62OBfF.js";
-import { t as DefaultVerdict } from "./verdict-E4eRNf7-.js";
+import { t as DefaultVerdict } from "./verdict-C24NELtN.js";
 import { t as AdversarialMutation } from "./adversarial-smnADNFS.js";
 //#region src/fuzz/types.d.ts
 /** One input axis of the stratification plan (e.g. matterType, difficulty, personaRigor). */
@@ -39,13 +39,13 @@ interface Evaluation extends DefaultVerdict {
 /** Run the target against one scenario in a cell. */
 type Evaluator<S> = (scenario: S, cell: Cell) => Promise<Evaluation>;
 /** Context a proposer sees — prior elites + findings let a skill-backed proposer steer. */
-interface ProposeContext<S> {
+interface FuzzProposeContext<S> {
   cell: Cell;
   seeds: S[];
   /** Current archive elites whose input cell matches. */
   elites: S[];
   /** Verified findings so far (read-only) — probe new gaps, not re-found ones. */
-  findings: ReadonlyArray<Finding<S>>;
+  findings: ReadonlyArray<FuzzFinding<S>>;
   /** How many candidates to propose. */
   count: number;
   rng: () => number;
@@ -60,13 +60,13 @@ interface ProposeContext<S> {
  * is the scenario generator in the behavior-fuzzing loop. `SurfaceProposer` is
  * THE optimization proposer.
  */
-type MutationProposer<S> = (ctx: ProposeContext<S>) => Promise<S[]> | S[];
+type MutationProposer<S> = (ctx: FuzzProposeContext<S>) => Promise<S[]> | S[];
 /**
  * What "interesting" means. `interest` in [0,1]; a candidate is notable (gate-
  * checked, reported) when `interest >= threshold`. `adversarialObjective` (low
  * score is interesting) and `noveltyObjective` (far from the archive) ship.
  */
-interface Objective {
+interface FuzzObjective {
   kind: string;
   interest(ev: Evaluation, ctx: ObjectiveContext): number;
   /** Default 0.5. */
@@ -87,7 +87,7 @@ interface ValidityGates<S> {
   isUncontaminated?: (scenario: S, ev: Evaluation, cell: Cell) => boolean | Promise<boolean>;
 }
 /** A gate-verified, minimized finding — the unit the capsule reports. */
-interface Finding<S> {
+interface FuzzFinding<S> {
   id: string;
   cell: Cell;
   scenario: S;
@@ -148,7 +148,7 @@ interface CapsuleData<S> {
   generatedAt?: string;
   coverage: CoverageCell[];
   /** Verified findings, sorted by descending interest. */
-  findings: Finding<S>[];
+  findings: FuzzFinding<S>[];
   /** QD archive elites (binned by input × measured coords). */
   archive: ArchiveEntry<S>[];
   /** Post-harden lift, filled by a second pass after an improvement. */
@@ -211,7 +211,7 @@ type ExploreEvent<S> = {
   evaluation: Evaluation;
 } | {
   type: 'finding';
-  finding: Finding<S>;
+  finding: FuzzFinding<S>;
 } | {
   type: 'eval-error';
   cell: Cell;
@@ -240,7 +240,7 @@ interface ExploreOptions<S> {
   /** Measured behavior coords appended to the archive bin. Default: input cell only. */
   descriptor?: (scenario: S, ev: Evaluation) => Record<string, string>;
   /** What "interesting" means. Default: `adversarialObjective(0.5)`. */
-  objective?: Objective;
+  objective?: FuzzObjective;
   /** Validity gates. Default pass-through. */
   gates?: ValidityGates<S>;
   /** Budget steering across input cells. `variance` chases uncertainty; `uniform` is the unsteered ablation baseline. Default `variance`. */
@@ -322,7 +322,7 @@ interface BuildCapsuleInput<S> {
   /** The objective's notable threshold — drives findingRate. */
   threshold: number;
   archive: ArchiveEntry<S>[];
-  findings: Finding<S>[];
+  findings: FuzzFinding<S>[];
   candidateFindings: number;
   runsUsed: number;
   /** Known-dollar / unknown-run split — present only when cost tracking was
@@ -339,7 +339,6 @@ interface BuildCapsuleInput<S> {
     detail: string;
   };
 }
-export declare function buildCapsule<S>(input: BuildCapsuleInput<S>): CapsuleData<S>;
 interface RenderCapsuleOptions {
   /** Max finding exemplars to show. Default 8. */
   maxFindings?: number;
@@ -349,47 +348,6 @@ interface RenderCapsuleOptions {
 /** Render a self-contained HTML capsule — heat-map + per-dimension chips + verified findings. */
 export declare function renderCapsuleHtml<S>(capsule: CapsuleData<S>, opts?: RenderCapsuleOptions): string;
 //#endregion
-//#region src/fuzz/explorer.d.ts
-export declare class BehaviorExplorer<S> {
-  private readonly opts;
-  private readonly cells;
-  private readonly cellById;
-  private readonly objective;
-  private readonly threshold;
-  private readonly floorPerCell;
-  private readonly perRoundBudget;
-  /** The single evaluation log — coverage + allocation are projections of it. */
-  private readonly log;
-  /** binId (input × measured coords) → the most interesting entry seen. */
-  private readonly archiveByBin;
-  private readonly _findings;
-  private runsUsed;
-  private candidateFindings;
-  private evalErrors;
-  private consecutiveEvalErrors;
-  private stoppedEarly;
-  private readonly rng;
-  private readonly costLedger?;
-  private readonly costPhase;
-  constructor(opts: ExploreOptions<S>);
-  private binId;
-  private allocate;
-  private objectiveContext;
-  /** Elites whose INPUT cell matches — what the proposer mutates/deepens from. */
-  private elitesFor;
-  /** One allocate → propose → evaluate → gate → archive round. */
-  step(): Promise<{
-    runs: number;
-    findings: Finding<S>[];
-  }>;
-  /** Loop `step()` until the run or dollar budget is spent, the signal aborts,
-   *  or no progress is made. */
-  run(): Promise<CapsuleData<S>>;
-  coverage(): CoverageCell[];
-  findings(): Finding<S>[];
-  capsule(): CapsuleData<S>;
-}
-//#endregion
 //#region src/fuzz/fuzz-agent.d.ts
 type FuzzAgentOptions<S> = Omit<ExploreOptions<S>, 'objective'> & {
   /** Score strictly below this is a candidate failure. Default 0.5. */
@@ -435,16 +393,16 @@ export declare function mutationProposer<S>(opts: {
   mutationsFor: (cell: Cell) => AdversarialMutation<S>[];
   scenarioId: (s: S) => string;
 }): MutationProposer<S>;
-/** Adversarial: a low headline score is interesting — find where the agent fails. */
-export declare function adversarialObjective(threshold?: number): Objective;
-/**
- * Novelty: interesting when far from the archive in score AND measured behavior
- * descriptor — quality-diversity's diversity pressure; drives corpus growth
- * rather than re-finding the same hole.
- */
-export declare function noveltyObjective(threshold?: number): Objective;
 //#endregion
 //#region src/fuzz/tools.d.ts
+/**
+ * Agent-drivable surface over a live exploration session.
+ *
+ * Framework-neutral tool defs ({name, description, parameters: JSON Schema,
+ * handler}) so the on-demand agent — not a batch script — drives the search:
+ * step it, read coverage, inspect findings, render the capsule. Transport
+ * encodings (OpenAI function shape, MCP) are one-line mappings the host owns.
+ */
 interface ExploreToolDef {
   name: string;
   description: string;
@@ -454,7 +412,6 @@ interface ExploreToolDef {
     signal?: AbortSignal;
   }) => Promise<unknown>;
 }
-export declare function makeExploreTools<S>(explorer: BehaviorExplorer<S>): ExploreToolDef[];
 //#endregion
-export type { ArchiveEntry, BehaviorSpace, BuildCapsuleInput, CapsuleData, Cell, CoverageCell, EvalRecord, Evaluation, Evaluator, ExploreEvent, ExploreOptions, ExploreToolDef, Finding, FuzzAgentOptions, MutationProposer, Objective, ObjectiveContext, ProposeContext, RenderCapsuleOptions, RunCost, SpaceAxis, ValidityGates };
+export type { ArchiveEntry, BehaviorSpace, BuildCapsuleInput, CapsuleData, Cell, CoverageCell, EvalRecord, Evaluation, Evaluator, ExploreEvent, ExploreOptions, ExploreToolDef, FuzzAgentOptions, FuzzFinding, FuzzObjective, FuzzProposeContext, MutationProposer, ObjectiveContext, RenderCapsuleOptions, RunCost, SpaceAxis, ValidityGates };
 //# sourceMappingURL=fuzz.d.ts.map

package/dist/fuzz.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fuzz.d.ts","names":[],"sources":["../src/fuzz/types.ts","../src/fuzz/cube.ts","../src/fuzz/capsule.ts","../src/fuzz/explorer.ts","../src/fuzz/fuzz-agent.ts","../src/fuzz/gates.ts","../src/fuzz/policies.ts","../src/fuzz/tools.ts"],"mappings":"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"}
+{"version":3,"file":"fuzz.d.ts","names":[],"sources":["../src/fuzz/types.ts","../src/fuzz/cube.ts","../src/fuzz/capsule.ts","../src/fuzz/fuzz-agent.ts","../src/fuzz/gates.ts","../src/fuzz/policies.ts","../src/fuzz/tools.ts"],"mappings":"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"}

package/dist/fuzz.js

@@ -1,7 +1,6 @@
-import { s as ValidationError } from "./errors-DVZiqS7K.js";
-import { t as mulberry32 } from "./random-ByUSnV9w.js";
-import { o as CostReceiptCaptureError, t as CostLedger } from "./cost-ledger-BP8V4kUQ.js";
-import { t as varianceBasedCurriculum } from "./active-curriculum-B_Lc9kfO.js";
+import { s as ValidationError } from "./errors-BcOs5MKW.js";
+import { t as mulberry32 } from "./random-DDDcC7YU.js";
+import { o as CostReceiptCaptureError, t as CostLedger } from "./cost-ledger-D0352Z4d.js";
 //#region src/fuzz/cube.ts
 /** Enumerate every input cell (cartesian product of the axes), in stable order. */
 function enumerateCells(space) {
@@ -260,6 +259,64 @@ ${findingsHtml(capsule.findings, opts.maxFindings ?? 8)}
 </div></body></html>`;
 }
 //#endregion
+//#region src/rl/active-curriculum.ts
+/**
+* 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)})`
+		};
+	});
+}
+//#endregion
 //#region src/fuzz/policies.ts
 const clamp01 = (x) => Math.max(0, Math.min(1, x));
 /**
@@ -298,30 +355,6 @@ function adversarialObjective(threshold = .5) {
 		interest: (ev) => clamp01(1 - ev.score)
 	};
 }
-function hamming(a, b) {
-	if (!a || !b) return 1;
-	const keys = /* @__PURE__ */ new Set([...Object.keys(a), ...Object.keys(b)]);
-	if (keys.size === 0) return 0;
-	let diff = 0;
-	for (const k of keys) if (a[k] !== b[k]) diff++;
-	return diff / keys.size;
-}
-/**
-* Novelty: interesting when far from the archive in score AND measured behavior
-* descriptor — quality-diversity's diversity pressure; drives corpus growth
-* rather than re-finding the same hole.
-*/
-function noveltyObjective(threshold = .3) {
-	return {
-		kind: "novelty",
-		threshold,
-		interest: (ev, ctx) => {
-			const scoreNovelty = ctx.archiveScores.length === 0 ? 1 : Math.min(...ctx.archiveScores.map((s) => Math.abs(s - ev.score)));
-			const descNovelty = ctx.archiveDescriptors.length === 0 ? 1 : Math.min(...ctx.archiveDescriptors.map((d) => hamming(d, ev.descriptor)));
-			return clamp01(.5 * scoreNovelty + .5 * descNovelty);
-		}
-	};
-}
 //#endregion
 //#region src/fuzz/explorer.ts
 /**
@@ -677,85 +710,6 @@ function severityFloorGate(opts) {
 	return { isValid: (_scenario, ev) => ev.score <= threshold - margin };
 }
 //#endregion
-//#region src/fuzz/tools.ts
-/**
-* Agent-drivable surface over a live exploration session.
-*
-* Framework-neutral tool defs ({name, description, parameters: JSON Schema,
-* handler}) so the on-demand agent — not a batch script — drives the search:
-* step it, read coverage, inspect findings, render the capsule. Transport
-* encodings (OpenAI function shape, MCP) are one-line mappings the host owns.
-*/
-const NO_ARGS = {
-	type: "object",
-	properties: {},
-	additionalProperties: false
-};
-function makeExploreTools(explorer) {
-	return [
-		{
-			name: "explore_step",
-			description: "Run one exploration round: allocate budget across cells, propose + evaluate scenarios, archive elites, admit gate-verified findings. Returns runs spent and new findings.",
-			parameters: NO_ARGS,
-			handler: async () => {
-				const { runs, findings } = await explorer.step();
-				return {
-					runs,
-					newFindings: findings.length,
-					findings
-				};
-			}
-		},
-		{
-			name: "explore_coverage",
-			description: "Read the live coverage map: per planned cell — runs, robustness (null = uncovered), finding rate, per-dimension means.",
-			parameters: NO_ARGS,
-			handler: async () => explorer.coverage()
-		},
-		{
-			name: "explore_findings",
-			description: "List gate-verified findings so far, sorted by descending interest.",
-			parameters: {
-				type: "object",
-				properties: { limit: {
-					type: "number",
-					description: "max findings to return"
-				} },
-				additionalProperties: false
-			},
-			handler: async (args) => {
-				const limit = args?.limit;
-				const all = explorer.findings();
-				return typeof limit === "number" ? all.slice(0, limit) : all;
-			}
-		},
-		{
-			name: "explore_capsule",
-			description: "Build the capsule artifact from the current session state. format \"data\" returns the structured CapsuleData; \"html\" returns the standalone page.",
-			parameters: {
-				type: "object",
-				properties: {
-					format: {
-						type: "string",
-						enum: ["data", "html"]
-					},
-					generatedAt: {
-						type: "string",
-						description: "ISO timestamp to stamp into the page"
-					}
-				},
-				additionalProperties: false
-			},
-			handler: async (args) => {
-				const a = args ?? {};
-				const capsule = explorer.capsule();
-				if (a.format === "html") return renderCapsuleHtml(capsule, { generatedAt: a.generatedAt });
-				return capsule;
-			}
-		}
-	];
-}
-//#endregion
-export { BehaviorExplorer, adversarialObjective, buildCapsule, buildCoverage, cellId, composeGates, enumerateCells, fuzzAgent, makeExploreTools, mutationProposer, noveltyObjective, perturbationStabilityGate, renderCapsuleHtml, severityFloorGate };
+export { buildCoverage, cellId, composeGates, enumerateCells, fuzzAgent, mutationProposer, perturbationStabilityGate, renderCapsuleHtml, severityFloorGate };
 
 //# sourceMappingURL=fuzz.js.map