@tangle-network/agent-eval 0.95.0 → 0.95.1

package/dist/campaign/presets/run-eval.d.ts

@@ -1,14 +0,0 @@
-/**
- * `runEval` — the simplest preset over `runCampaign`. No optimizer, no
- * gate, no auto-PR. Just: run scenarios through dispatch, score with
- * judges, return CampaignResult.
- *
- * The 80% case for consumers who want a scorecard, not an improvement loop.
- */
-import { type RunCampaignOptions } from '../run-campaign';
-import type { CampaignResult, Scenario } from '../types';
-export interface RunEvalOptions<TScenario extends Scenario, TArtifact> extends Omit<RunCampaignOptions<TScenario, TArtifact>, 'runDir'> {
-    runDir: string;
-}
-export declare function runEval<TScenario extends Scenario, TArtifact>(opts: RunEvalOptions<TScenario, TArtifact>): Promise<CampaignResult<TArtifact, TScenario>>;
-//# sourceMappingURL=run-eval.d.ts.map

package/dist/campaign/presets/run-eval.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"run-eval.d.ts","sourceRoot":"","sources":["../../../src/campaign/presets/run-eval.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,KAAK,kBAAkB,EAAe,MAAM,iBAAiB,CAAA;AACtE,OAAO,KAAK,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAExD,MAAM,WAAW,cAAc,CAAC,SAAS,SAAS,QAAQ,EAAE,SAAS,CACnE,SAAQ,IAAI,CAAC,kBAAkB,CAAC,SAAS,EAAE,SAAS,CAAC,EAAE,QAAQ,CAAC;IAChE,MAAM,EAAE,MAAM,CAAA;CACf;AAED,wBAAsB,OAAO,CAAC,SAAS,SAAS,QAAQ,EAAE,SAAS,EACjE,IAAI,EAAE,cAAc,CAAC,SAAS,EAAE,SAAS,CAAC,GACzC,OAAO,CAAC,cAAc,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC,CAE/C"}

package/dist/campaign/presets/run-improvement-loop.d.ts

@@ -1,63 +0,0 @@
-/**
- * `runImprovementLoop` — the gated-promotion shell around the improvement
- * loop body (`runOptimization`). Proposes candidate surfaces via the
- * `SurfaceProposer`, re-scores the winner against the baseline on a
- * holdout set, runs the release gate, and optionally opens a PR.
- *
- * Role vocabulary (see docs/design/loop-taxonomy.md):
- *   - PROPOSER   = the `SurfaceProposer` (evolutionary GEPA mutator OR
- *                  reflective analyst). Proposes candidate SURFACES — the
- *                  worker's system prompt / tool config — NOT conversation
- *                  turns.
- *   - MEASUREMENT= `runCampaign`. Scores one surface by running the worker
- *                  (via `dispatch`) over scenarios and judging the output.
- *   - WORKER     = the agent harness in the sandbox, invoked behind the
- *                  topology-opaque `dispatch` seam — never referenced here.
- *
- * Distinct from `runLoop` in `@tangle-network/agent-runtime`, which is the
- * INNER conversation loop (execution driver ↔ workers in a sandbox). `runImprovementLoop`
- * is the OUTER loop: it improves the surface that those workers run.
- *
- * Hard-refuses unsafe configurations:
- *   - `tracing: 'off'` when a proposer is wired (improvement is unattributable)
- *   - `autoOnPromote: 'config'` — DEFERRED to Pass B; v0.40 only ships
- *     `'pr'` and `'none'`.
- */
-import { openAutoPr } from '../auto-pr';
-import type { CampaignResult, Gate, MutableSurface, Scenario } from '../types';
-import type { RunOptimizationOptions, RunOptimizationResult } from './run-optimization';
-export type RunImprovementLoopOptions<TScenario extends Scenario, TArtifact> = RunOptimizationOptions<TScenario, TArtifact> & {
-    /** Holdout scenarios kept OUT of the training optimization pool — used
-     *  ONLY to score baseline vs winner for the gate. */
-    holdoutScenarios: TScenario[];
-    /** Promotion gate. Substrate strongly recommends `defaultProductionGate`
-     *  for production wiring (composes red-team / reward-hacking / canary /
-     *  heldout). */
-    gate: Gate<TArtifact, TScenario>;
-    /** What to do when the gate ships:
-     *   - `'pr'`: open a PR via `openAutoPr`
-     *   - `'none'`: just report — caller decides what to do with the winner
-     *  v0.40 does NOT support `'config'` (live-runtime self-mutation) —
-     *  deferred to Pass B behind safety stack. */
-    autoOnPromote: 'pr' | 'none';
-    /** GH owner / repo for the auto-PR. Required when autoOnPromote === 'pr'. */
-    ghOwner?: string;
-    ghRepo?: string;
-    /** Optional render override — substrate writes a diff-shaped surface; pass
-     *  a function to format the promoted surface differently. */
-    renderPromotedDiff?: (winnerSurface: MutableSurface, baselineSurface: MutableSurface) => string;
-};
-export interface RunImprovementLoopResult<TArtifact, TScenario extends Scenario> extends RunOptimizationResult<TArtifact, TScenario> {
-    baselineOnHoldout: CampaignResult<TArtifact, TScenario>;
-    winnerOnHoldout: CampaignResult<TArtifact, TScenario>;
-    gateResult: Awaited<ReturnType<Gate<TArtifact, TScenario>['decide']>>;
-    /** Unified baseline→winner surface diff. Computed UNCONDITIONALLY (not only
-     *  when `autoOnPromote === 'pr'`) so the diff that the gate decided on is
-     *  always present on the result + in the emitted provenance record. Empty
-     *  string when winner == baseline (no change to diff). */
-    promotedDiff: string;
-    prResult?: ReturnType<typeof openAutoPr>;
-}
-export declare function runImprovementLoop<TScenario extends Scenario, TArtifact>(opts: RunImprovementLoopOptions<TScenario, TArtifact>): Promise<RunImprovementLoopResult<TArtifact, TScenario>>;
-export declare function defaultRenderDiff(winnerSurface: MutableSurface, baselineSurface: MutableSurface): string;
-//# sourceMappingURL=run-improvement-loop.d.ts.map

package/dist/campaign/presets/run-improvement-loop.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"run-improvement-loop.d.ts","sourceRoot":"","sources":["../../../src/campaign/presets/run-improvement-loop.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AACvC,OAAO,KAAK,EAAE,cAAc,EAAE,IAAI,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAC9E,OAAO,KAAK,EAAE,sBAAsB,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAA;AASvF,MAAM,MAAM,yBAAyB,CACnC,SAAS,SAAS,QAAQ,EAC1B,SAAS,IACP,sBAAsB,CAAC,SAAS,EAAE,SAAS,CAAC,GAAG;IACjD;yDACqD;IACrD,gBAAgB,EAAE,SAAS,EAAE,CAAA;IAC7B;;oBAEgB;IAChB,IAAI,EAAE,IAAI,CAAC,SAAS,EAAE,SAAS,CAAC,CAAA;IAChC;;;;kDAI8C;IAC9C,aAAa,EAAE,IAAI,GAAG,MAAM,CAAA;IAC5B,6EAA6E;IAC7E,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf;iEAC6D;IAC7D,kBAAkB,CAAC,EAAE,CAAC,aAAa,EAAE,cAAc,EAAE,eAAe,EAAE,cAAc,KAAK,MAAM,CAAA;CAChG,CAAA;AAED,MAAM,WAAW,wBAAwB,CAAC,SAAS,EAAE,SAAS,SAAS,QAAQ,CAC7E,SAAQ,qBAAqB,CAAC,SAAS,EAAE,SAAS,CAAC;IACnD,iBAAiB,EAAE,cAAc,CAAC,SAAS,EAAE,SAAS,CAAC,CAAA;IACvD,eAAe,EAAE,cAAc,CAAC,SAAS,EAAE,SAAS,CAAC,CAAA;IACrD,UAAU,EAAE,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAA;IACrE;;;8DAG0D;IAC1D,YAAY,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,EAAE,UAAU,CAAC,OAAO,UAAU,CAAC,CAAA;CACzC;AAED,wBAAsB,kBAAkB,CAAC,SAAS,SAAS,QAAQ,EAAE,SAAS,EAC5E,IAAI,EAAE,yBAAyB,CAAC,SAAS,EAAE,SAAS,CAAC,GACpD,OAAO,CAAC,wBAAwB,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC,CAgLzD;AAED,wBAAgB,iBAAiB,CAC/B,aAAa,EAAE,cAAc,EAC7B,eAAe,EAAE,cAAc,GAC9B,MAAM,CAgBR"}

package/dist/campaign/presets/run-improvement-loop.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=run-improvement-loop.test.d.ts.map

package/dist/campaign/presets/run-improvement-loop.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"run-improvement-loop.test.d.ts","sourceRoot":"","sources":["../../../src/campaign/presets/run-improvement-loop.test.ts"],"names":[],"mappings":""}

package/dist/campaign/presets/run-optimization.d.ts

@@ -1,92 +0,0 @@
-/**
- * `runOptimization` — the improvement loop body. Runs N generations: the
- * `SurfaceProposer` proposes K candidate surfaces per generation, each
- * candidate runs a campaign (the measurement), top-scoring promote to the
- * next generation. Proposer-agnostic — the same loop runs an evolutionary
- * population mutator (`evolutionaryProposer`) or any reflective / agentic
- * proposer; they differ only in how `propose()` picks candidates.
- *
- * This is `runLoop`'s shape (plan → measure → decide) specialized to surface
- * improvement: `proposer.propose` = plan, `runCampaign` = the measurement
- * (which runs the worker behind `dispatch`), the mean-composite ranking = the
- * validator, `proposer.decide` = the stop check.
- *
- * The gated-promotion shell (`runImprovementLoop`) wraps this with a holdout
- * re-score + release gate + optional PR.
- */
-import { type RunCampaignOptions } from '../run-campaign';
-import { type CampaignResult, type GenerationRecord, type MutableSurface, type ParetoParent, type Scenario, type SurfaceProposer } from '../types';
-export interface RunOptimizationBaseOptions<TScenario extends Scenario, TArtifact> extends Omit<RunCampaignOptions<TScenario, TArtifact>, 'dispatch'> {
-    /** Initial mutable surface (typically system prompt or addendum). */
-    baselineSurface: MutableSurface;
-    /** Dispatcher that takes the CURRENT surface + scenario → artifact. */
-    dispatchWithSurface: (surface: MutableSurface, scenario: TScenario, ctx: Parameters<RunCampaignOptions<TScenario, TArtifact>['dispatch']>[1]) => Promise<TArtifact>;
-    /** The candidate-generation strategy. Wrap a population `Mutator` via
-     *  `evolutionaryProposer({ mutator })`, or pass any reflective / agentic
-     *  proposer that implements `SurfaceProposer`. */
-    proposer: SurfaceProposer;
-    populationSize: number;
-    maxGenerations: number;
-    /** How many top-scoring candidates carry to the next generation. Default 2. */
-    promoteTopK?: number;
-    /** DEPTH knob forwarded to the proposer's `propose()` — max iterations the
-     *  agentic generator may take per candidate. */
-    maxImprovementShots?: number;
-    /** Optional analysis report forwarded to `propose()`. Opaque here; the
-     *  proposer types it. */
-    report?: unknown;
-    /** Structured findings forwarded to `propose()` as `ctx.findings`. A
-     *  findings producer emits these from the
-     *  generation's traces; findings-grounded proposers consume them. Opaque here;
-     *  the proposer types its `TFindings`. Empty when no producer is wired. */
-    findings?: unknown[];
-    /** Per-generation findings producer. After each
-     *  generation's candidates are scored, this is called with that generation's
-     *  results; whatever it returns REPLACES `ctx.findings` for the NEXT
-     *  generation's `propose()`, so the diagnosis is refreshed each round instead
-     *  of being a static one-shot. Generic by design: the substrate does not
-     *  import an analyst — the consumer plugs its trace-analyst registry / HALO
-     *  here (reading the per-candidate `runDir` traces). When absent, findings
-     *  stay the static `opts.findings`. */
-    analyzeGeneration?: (input: {
-        generation: number;
-        runDir: string;
-        candidates: Array<{
-            surfaceHash: string;
-            campaign: CampaignResult<TArtifact, TScenario>;
-            composite: number;
-        }>;
-        history: GenerationRecord[];
-    }) => Promise<unknown[]>;
-}
-export type RunOptimizationOptions<TScenario extends Scenario, TArtifact> = RunOptimizationBaseOptions<TScenario, TArtifact>;
-export interface RunOptimizationResult<TArtifact, TScenario extends Scenario> {
-    generations: Array<{
-        record: GenerationRecord;
-        surfaces: Array<{
-            surfaceHash: string;
-            surface: MutableSurface;
-            campaign: CampaignResult<TArtifact, TScenario>;
-        }>;
-    }>;
-    winnerSurface: MutableSurface;
-    winnerSurfaceHash: string;
-    /** Proposer label for the promoted surface. Present when the winning
-     *  candidate came from a `ProposedCandidate` (a reflective proposer);
-     *  absent when the winner is the baseline or a bare-surface mutator. */
-    winnerLabel?: string;
-    /** Proposer rationale for the promoted surface — the "because Z" that
-     *  motivated the winning change. Survives to `SelfImproveResult` and the
-     *  emitted provenance record. Absent when the winner is the baseline. */
-    winnerRationale?: string;
-    baselineCampaign: CampaignResult<TArtifact, TScenario>;
-    /** The GEPA Pareto frontier across every scored surface (baseline + all
-     *  generations) by per-scenario objective vector — the non-dominated set.
-     *  Each generation's `propose()` received the frontier-so-far as
-     *  `ctx.paretoParents`; this is the final frontier. A surface here that is
-     *  NOT the winner is uniquely best on some scenario the winner loses on. */
-    paretoFrontier: ParetoParent[];
-}
-export declare function runOptimization<TScenario extends Scenario, TArtifact>(opts: RunOptimizationOptions<TScenario, TArtifact>): Promise<RunOptimizationResult<TArtifact, TScenario>>;
-export declare function surfaceHash(surface: MutableSurface): string;
-//# sourceMappingURL=run-optimization.d.ts.map

package/dist/campaign/presets/run-optimization.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"run-optimization.d.ts","sourceRoot":"","sources":["../../../src/campaign/presets/run-optimization.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAIH,OAAO,EAAE,KAAK,kBAAkB,EAAe,MAAM,iBAAiB,CAAA;AAEtE,OAAO,EACL,KAAK,cAAc,EACnB,KAAK,gBAAgB,EAErB,KAAK,cAAc,EACnB,KAAK,YAAY,EAEjB,KAAK,QAAQ,EACb,KAAK,eAAe,EACrB,MAAM,UAAU,CAAA;AAEjB,MAAM,WAAW,0BAA0B,CAAC,SAAS,SAAS,QAAQ,EAAE,SAAS,CAC/E,SAAQ,IAAI,CAAC,kBAAkB,CAAC,SAAS,EAAE,SAAS,CAAC,EAAE,UAAU,CAAC;IAClE,qEAAqE;IACrE,eAAe,EAAE,cAAc,CAAA;IAC/B,uEAAuE;IACvE,mBAAmB,EAAE,CACnB,OAAO,EAAE,cAAc,EACvB,QAAQ,EAAE,SAAS,EACnB,GAAG,EAAE,UAAU,CAAC,kBAAkB,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,KACrE,OAAO,CAAC,SAAS,CAAC,CAAA;IACvB;;sDAEkD;IAClD,QAAQ,EAAE,eAAe,CAAA;IACzB,cAAc,EAAE,MAAM,CAAA;IACtB,cAAc,EAAE,MAAM,CAAA;IACtB,+EAA+E;IAC/E,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB;oDACgD;IAChD,mBAAmB,CAAC,EAAE,MAAM,CAAA;IAC5B;6BACyB;IACzB,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB;;;+EAG2E;IAC3E,QAAQ,CAAC,EAAE,OAAO,EAAE,CAAA;IACpB;;;;;;;2CAOuC;IACvC,iBAAiB,CAAC,EAAE,CAAC,KAAK,EAAE;QAC1B,UAAU,EAAE,MAAM,CAAA;QAClB,MAAM,EAAE,MAAM,CAAA;QACd,UAAU,EAAE,KAAK,CAAC;YAChB,WAAW,EAAE,MAAM,CAAA;YACnB,QAAQ,EAAE,cAAc,CAAC,SAAS,EAAE,SAAS,CAAC,CAAA;YAC9C,SAAS,EAAE,MAAM,CAAA;SAClB,CAAC,CAAA;QACF,OAAO,EAAE,gBAAgB,EAAE,CAAA;KAC5B,KAAK,OAAO,CAAC,OAAO,EAAE,CAAC,CAAA;CACzB;AAED,MAAM,MAAM,sBAAsB,CAChC,SAAS,SAAS,QAAQ,EAC1B,SAAS,IACP,0BAA0B,CAAC,SAAS,EAAE,SAAS,CAAC,CAAA;AAEpD,MAAM,WAAW,qBAAqB,CAAC,SAAS,EAAE,SAAS,SAAS,QAAQ;IAC1E,WAAW,EAAE,KAAK,CAAC;QACjB,MAAM,EAAE,gBAAgB,CAAA;QACxB,QAAQ,EAAE,KAAK,CAAC;YACd,WAAW,EAAE,MAAM,CAAA;YACnB,OAAO,EAAE,cAAc,CAAA;YACvB,QAAQ,EAAE,cAAc,CAAC,SAAS,EAAE,SAAS,CAAC,CAAA;SAC/C,CAAC,CAAA;KACH,CAAC,CAAA;IACF,aAAa,EAAE,cAAc,CAAA;IAC7B,iBAAiB,EAAE,MAAM,CAAA;IACzB;;4EAEwE;IACxE,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB;;6EAEyE;IACzE,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,gBAAgB,EAAE,cAAc,CAAC,SAAS,EAAE,SAAS,CAAC,CAAA;IACtD;;;;gFAI4E;IAC5E,cAAc,EAAE,YAAY,EAAE,CAAA;CAC/B;AAED,wBAAsB,eAAe,CAAC,SAAS,SAAS,QAAQ,EAAE,SAAS,EACzE,IAAI,EAAE,sBAAsB,CAAC,SAAS,EAAE,SAAS,CAAC,GACjD,OAAO,CAAC,qBAAqB,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC,CA2JtD;AA6DD,wBAAgB,WAAW,CAAC,OAAO,EAAE,cAAc,GAAG,MAAM,CAY3D"}

package/dist/campaign/presets/run-profile-matrix.d.ts

@@ -1,151 +0,0 @@
-/**
- * `runProfileMatrix` — the missing keystone between `runAgentMatrix` and the
- * backend-integrity guard.
- *
- * The gap it closes: `runAgentMatrix` is a topology-opaque scheduler whose
- * cells return a bare `{ output, verdict, costUsd }` — no `tokenUsage`, not a
- * `RunRecord`. `assertRealBackend` / `summarizeBackendIntegrity` key on
- * `RunRecord.tokenUsage`, so they cannot run on a raw matrix result. Every
- * consumer therefore hand-writes the same bridge: fan a profile × scenario
- * cartesian, call dispatch, fabricate a `RunRecord` with token usage, thread it
- * back, run the integrity guard. That hand-rolled bridge is exactly the pile of
- * bespoke `eval:*` scripts the adoption skills keep trying (and failing) to
- * forbid.
- *
- * `runProfileMatrix` IS that bridge, once:
- *
- *   - axis 3 (PROFILE) = `profiles: AgentProfile[]`
- *   - axis 1 (PERSONA/SCENARIO) = `scenarios: Scenario[]` (each scenario carries
- *     its persona; `personaOf` groups them for the `byPersona` pivot)
- *   - the scoring axis = `judges`
- *
- * It runs `runCampaign` once per profile (reusing its seeds, reps, bootstrap
- * CIs, resumability, and the `LabeledScenarioStore` capture flywheel), maps
- * every cell to a validated `RunRecord` carrying the real `tokenUsage` the
- * dispatch reported via `ctx.cost.observeTokens`, and runs `assertRealBackend`
- * BY CONSTRUCTION before returning — so a stub-backend run fails loudly instead
- * of reporting a clean 0/N leaderboard.
- *
- * Dispatch contract: a dispatch that calls an LLM MUST report usage via
- * `ctx.cost.observeTokens({ input, output })` (and cost via `ctx.cost.observe`).
- * A dispatch that reports zero tokens is indistinguishable from a stub and the
- * integrity guard treats it as one.
- */
-import { type AgentProfile } from '../../agent-profile';
-import { AgentEvalError } from '../../errors';
-import { type BackendIntegrityReport } from '../../integrity/backend-integrity';
-import { type RunRecord, type RunSplitTag } from '../../run-record';
-import type { CampaignStorage } from '../storage';
-import type { CampaignResult, DispatchContext, JudgeConfig, LabeledScenarioSource, LabeledScenarioStore, Scenario } from '../types';
-/** Thrown when the matrix is misconfigured (no profiles, a profile whose model
- *  lacks a snapshot version, etc.). Distinct from `BackendIntegrityError`,
- *  which signals a stub backend at run time. */
-export declare class ProfileMatrixError extends AgentEvalError {
-    constructor(message: string);
-}
-/** Dispatch for one cell: render `profile` against `scenario`, returning the
- *  artifact the judges score. Report LLM usage via `ctx.cost.observeTokens`
- *  and `ctx.cost.observe` — the integrity guard depends on it. */
-export type ProfileDispatchFn<TScenario extends Scenario, TArtifact> = (profile: AgentProfile, scenario: TScenario, ctx: DispatchContext) => Promise<TArtifact>;
-export interface RunProfileMatrixOptions<TScenario extends Scenario, TArtifact> {
-    /** Axis 3 — the agent-under-test configurations. Each is one column. */
-    profiles: AgentProfile[];
-    /** Axis 1 — the persona/scenario corpus, run against every profile. */
-    scenarios: TScenario[];
-    /** Renders one (profile, scenario) cell. */
-    dispatch: ProfileDispatchFn<TScenario, TArtifact>;
-    /** The scoring axis. */
-    judges?: JudgeConfig<TArtifact, TScenario>[];
-    /** Where each profile's campaign writes artifacts/traces. One subdir per
-     *  profile. */
-    runDir: string;
-    /** Git SHA the harness ran from — stamped onto every RunRecord (mandatory
-     *  for paper-grade records). */
-    commitSha: string;
-    /** Logical experiment id shared across the whole matrix so the promotion
-     *  gate can pair profiles on matched scenarios. Default: a hash of the
-     *  profile + scenario ids. */
-    experimentId?: string;
-    /** Which split these runs belong to. Default `'search'`. */
-    splitTag?: RunSplitTag;
-    /** Replicates per (profile, scenario) cell for CI bands. Default 1. */
-    reps?: number;
-    /** Campaign seed (per profile). Default 42. */
-    seed?: number;
-    /**
-     * Backend-integrity posture, enforced AFTER the matrix completes:
-     *   - `'assert'` (default) — throw `BackendIntegrityError` if the run was a
-     *     stub (and, with `allowMixed:false`, if it was mixed).
-     *   - `'warn'` — log the verdict but never throw.
-     *   - `'off'` — skip the guard entirely (only for offline/replay analysis).
-     */
-    integrity?: 'assert' | 'warn' | 'off';
-    /** Forwarded to `assertRealBackend`. Default true (tolerate partial 429
-     *  cascades); set false for strict CI gates. */
-    allowMixed?: boolean;
-    /** Max concurrent cells WITHIN each profile's campaign. Default 2.
-     *  Profiles run sequentially so the cost ceiling is honored deterministically. */
-    maxConcurrency?: number;
-    /** Cumulative USD cap per profile campaign. */
-    costCeiling?: number;
-    /** Capture flywheel — forwarded to each campaign. */
-    labeledStore?: LabeledScenarioStore | 'off';
-    captureSource?: LabeledScenarioSource;
-    /** Storage backend. Default `fsCampaignStorage`. Pass
-     *  `inMemoryCampaignStorage()` for edge/CF-Worker/test runs. */
-    storage?: CampaignStorage;
-    /** Test seam — override the wall clock. */
-    now?: () => Date;
-    /** Optional persona key per scenario — drives the `byPersona` pivot. When
-     *  unset, `byPersona` is omitted. */
-    personaOf?: (scenario: TScenario) => string;
-    /** Validate every produced RunRecord with `validateRunRecord` (fail-loud).
-     *  Default true — catches bad model snapshots and non-finite judge dims at
-     *  the boundary instead of letting them poison downstream analysis. */
-    validate?: boolean;
-    /** Corpus-by-default: derive the trajectory text (`prompt` + `completion`)
-     *  for each cell from its artifact + scenario. When set, every produced
-     *  record carries `prompt`/`completion` (a `CorpusRecord`) so the run's
-     *  graded trajectories can be appended to the durable RL corpus with no
-     *  side-channel — `appendToCorpus(result.records, path)`. Fail-soft: a
-     *  throwing or undefined-returning extractor just omits the text. */
-    corpusText?: (artifact: TArtifact, scenario: TScenario) => {
-        prompt: string;
-        completion: string;
-    } | undefined;
-}
-export interface ProfileSummary {
-    profileId: string;
-    profileHash: string;
-    model: string;
-    /** RunRecords produced for this profile (= scenarios × reps). */
-    records: number;
-    /** Mean composite across this profile's records. */
-    meanComposite: number;
-    totalCostUsd: number;
-    /** Per-profile integrity verdict — surfaces a single profile that ran stub
-     *  even when the matrix as a whole looks real. */
-    integrity: BackendIntegrityReport;
-}
-export interface ScenarioRollup {
-    meanComposite: number;
-    n: number;
-}
-export interface RunProfileMatrixResult<TArtifact, TScenario extends Scenario> {
-    matrixId: string;
-    experimentId: string;
-    /** One RunRecord per (profile, scenario, rep) cell — the integrity-checked,
-     *  paper-grade output. Feed straight into `analyzeRuns`, `HeldOutGate`,
-     *  scorecards, the hosted wire format. */
-    records: RunRecord[];
-    byProfile: Record<string, ProfileSummary>;
-    byScenario: Record<string, ScenarioRollup>;
-    /** Present only when `personaOf` was supplied. */
-    byPersona?: Record<string, ScenarioRollup>;
-    /** Whole-matrix integrity report (the one `integrity:'assert'` enforces). */
-    integrity: BackendIntegrityReport;
-    /** The raw per-profile campaign results, keyed by profile id. */
-    campaigns: Record<string, CampaignResult<TArtifact, TScenario>>;
-}
-export declare function runProfileMatrix<TScenario extends Scenario, TArtifact>(opts: RunProfileMatrixOptions<TScenario, TArtifact>): Promise<RunProfileMatrixResult<TArtifact, TScenario>>;
-//# sourceMappingURL=run-profile-matrix.d.ts.map

package/dist/campaign/presets/run-profile-matrix.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"run-profile-matrix.d.ts","sourceRoot":"","sources":["../../../src/campaign/presets/run-profile-matrix.ts"],"names":[],"mappings":"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"}

package/dist/campaign/presets/run-skill-opt.d.ts

@@ -1,96 +0,0 @@
-/**
- * `runSkillOpt` — the SkillOpt epoch hill-climb (Microsoft, arXiv:2605.23904).
- * Unlike `runOptimization`'s population/promote-top-K search, SkillOpt is a
- * sequential, held-out-gated hill-climb on ONE skill document:
- *
- *   each epoch:
- *     1. reflect on the CURRENT surface's weakest TRAIN scenarios/dimensions
- *        (never the held-out split — proposals must not see the acceptance axis)
- *     2. propose ≤ `patchesPerEpoch` bounded patches (≤ `editBudget` ops each)
- *     3. apply each; score the candidate on the HELD-OUT split
- *     4. ACCEPT the first patch that STRICTLY improves the held-out composite;
- *        otherwise push it to the rejected-edit buffer (fed back so the model
- *        does not re-propose dead ends)
- *     5. anneal the edit budget down after consecutive rejections (the
- *        "textual learning rate" decay); refresh the slow-update meta note
- *     6. stop at `maxEpochs` or after `patience` epochs with no acceptance
- *
- * The accept-only-if-held-out-improves rule is the same discipline as
- * `HeldOutGate`/`defaultProductionGate`, applied per edit instead of once at
- * the end — which is why the held-out composite is monotonically
- * non-decreasing and a regression can never ship. `runCampaign` is the
- * measurement; `applySkillPatch` applies the edits; `skillOptProposer` proposes
- * them.
- */
-import type { RejectedEdit, SkillOptProposer } from '../proposers/skill-opt';
-import { type RunCampaignOptions } from '../run-campaign';
-import type { DispatchContext, Scenario } from '../types';
-export interface RunSkillOptOptions<TScenario extends Scenario, TArtifact> extends Omit<RunCampaignOptions<TScenario, TArtifact>, 'dispatch' | 'scenarios'> {
-    /** The skill document being optimized. */
-    baselineSurface: string;
-    /** Dispatcher taking the CURRENT skill surface + scenario → artifact. */
-    dispatchWithSurface: (surface: string, scenario: TScenario, ctx: DispatchContext) => Promise<TArtifact>;
-    proposer: SkillOptProposer;
-    /** Scenarios the optimizer reflects on for evidence. MUST be disjoint from
-     *  `holdoutScenarios` — proposals never see the acceptance axis. */
-    trainScenarios: TScenario[];
-    /** Held-out scenarios. An edit is accepted ONLY if it strictly improves the
-     *  mean composite here. */
-    holdoutScenarios: TScenario[];
-    maxEpochs: number;
-    /** Candidate patches proposed per epoch. Default 2. */
-    patchesPerEpoch?: number;
-    /** Initial ops-per-patch cap (the textual learning rate). Default 3. */
-    editBudget?: number;
-    /** Strict acceptance margin: accept iff the held-out composite improves by
-     *  MORE than this. Default 0 (any strict improvement). */
-    minImprovement?: number;
-    /** Stop after this many consecutive epochs with no acceptance. Default =
-     *  `maxEpochs` (never early-stop). */
-    patience?: number;
-    /** Shrink the edit budget by 1 after 2 consecutive rejected epochs (min 1).
-     *  Default true. */
-    budgetAnneal?: boolean;
-    /** Cap on the rejected-edit buffer (most-recent kept). Default 12. */
-    rejectedBufferSize?: number;
-    /** Refresh the slow-update meta note every N epochs. Default 2. 0 disables. */
-    slowMetaEvery?: number;
-    /** Top-K weak scenarios/dimensions surfaced as evidence each epoch. Default 3. */
-    evidenceK?: number;
-    /** Abort signal forwarded to the patch-proposing LLM calls. */
-    signal?: AbortSignal;
-}
-export interface AcceptedEdit {
-    epoch: number;
-    label: string;
-    rationale: string;
-    /** Held-out composite improvement vs the surface before this edit. */
-    holdoutDelta: number;
-}
-export interface SkillOptEpochRecord {
-    epoch: number;
-    editBudget: number;
-    proposed: number;
-    /** The accepted edit this epoch, or null if every proposal was rejected. */
-    accepted: AcceptedEdit | null;
-    rejected: RejectedEdit[];
-    /** Held-out composite of the CURRENT surface at the END of the epoch. */
-    holdoutComposite: number;
-}
-export interface RunSkillOptResult {
-    winnerSurface: string;
-    baselineHoldoutComposite: number;
-    winnerHoldoutComposite: number;
-    /** `winnerHoldoutComposite - baselineHoldoutComposite` — monotonically ≥ 0
-     *  by construction (only strictly-improving edits are accepted). */
-    lift: number;
-    acceptedEdits: AcceptedEdit[];
-    rejectedEdits: RejectedEdit[];
-    epochsRun: number;
-    history: SkillOptEpochRecord[];
-    /** Total cost across every scoring campaign (train evidence + holdout
-     *  acceptance) the hill-climb ran. */
-    totalCostUsd: number;
-}
-export declare function runSkillOpt<TScenario extends Scenario, TArtifact>(opts: RunSkillOptOptions<TScenario, TArtifact>): Promise<RunSkillOptResult>;
-//# sourceMappingURL=run-skill-opt.d.ts.map

package/dist/campaign/presets/run-skill-opt.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"run-skill-opt.d.ts","sourceRoot":"","sources":["../../../src/campaign/presets/run-skill-opt.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAoB,gBAAgB,EAAE,MAAM,wBAAwB,CAAA;AAC9F,OAAO,EAAE,KAAK,kBAAkB,EAAe,MAAM,iBAAiB,CAAA;AAGtE,OAAO,KAAK,EAAkB,eAAe,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAEzE,MAAM,WAAW,kBAAkB,CAAC,SAAS,SAAS,QAAQ,EAAE,SAAS,CACvE,SAAQ,IAAI,CAAC,kBAAkB,CAAC,SAAS,EAAE,SAAS,CAAC,EAAE,UAAU,GAAG,WAAW,CAAC;IAChF,0CAA0C;IAC1C,eAAe,EAAE,MAAM,CAAA;IACvB,yEAAyE;IACzE,mBAAmB,EAAE,CACnB,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,SAAS,EACnB,GAAG,EAAE,eAAe,KACjB,OAAO,CAAC,SAAS,CAAC,CAAA;IACvB,QAAQ,EAAE,gBAAgB,CAAA;IAC1B;wEACoE;IACpE,cAAc,EAAE,SAAS,EAAE,CAAA;IAC3B;+BAC2B;IAC3B,gBAAgB,EAAE,SAAS,EAAE,CAAA;IAC7B,SAAS,EAAE,MAAM,CAAA;IACjB,uDAAuD;IACvD,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,wEAAwE;IACxE,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB;8DAC0D;IAC1D,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB;0CACsC;IACtC,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB;wBACoB;IACpB,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,sEAAsE;IACtE,kBAAkB,CAAC,EAAE,MAAM,CAAA;IAC3B,+EAA+E;IAC/E,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,kFAAkF;IAClF,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,+DAA+D;IAC/D,MAAM,CAAC,EAAE,WAAW,CAAA;CACrB;AAED,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,SAAS,EAAE,MAAM,CAAA;IACjB,sEAAsE;IACtE,YAAY,EAAE,MAAM,CAAA;CACrB;AAED,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,MAAM,CAAA;IACb,UAAU,EAAE,MAAM,CAAA;IAClB,QAAQ,EAAE,MAAM,CAAA;IAChB,4EAA4E;IAC5E,QAAQ,EAAE,YAAY,GAAG,IAAI,CAAA;IAC7B,QAAQ,EAAE,YAAY,EAAE,CAAA;IACxB,yEAAyE;IACzE,gBAAgB,EAAE,MAAM,CAAA;CACzB;AAED,MAAM,WAAW,iBAAiB;IAChC,aAAa,EAAE,MAAM,CAAA;IACrB,wBAAwB,EAAE,MAAM,CAAA;IAChC,sBAAsB,EAAE,MAAM,CAAA;IAC9B;wEACoE;IACpE,IAAI,EAAE,MAAM,CAAA;IACZ,aAAa,EAAE,YAAY,EAAE,CAAA;IAC7B,aAAa,EAAE,YAAY,EAAE,CAAA;IAC7B,SAAS,EAAE,MAAM,CAAA;IACjB,OAAO,EAAE,mBAAmB,EAAE,CAAA;IAC9B;0CACsC;IACtC,YAAY,EAAE,MAAM,CAAA;CACrB;AAED,wBAAsB,WAAW,CAAC,SAAS,SAAS,QAAQ,EAAE,SAAS,EACrE,IAAI,EAAE,kBAAkB,CAAC,SAAS,EAAE,SAAS,CAAC,GAC7C,OAAO,CAAC,iBAAiB,CAAC,CAqJ5B"}

package/dist/campaign/proposers/_findings-text.d.ts

@@ -1,22 +0,0 @@
-/**
- * Shared finding→text helpers for the curator-style proposers (`memoryCurationProposer`
- * dedup-and-replace, `aceProposer` append-mostly). One copy so the two proposers
- * extract lessons + normalize keys identically and cannot drift apart.
- */
-import type { MutableSurface } from '../types';
-/** A finding can be a raw string or a structured analyst finding. Pulls the
- *  most actionable text (recommended_action > claim > lesson > text > message). */
-export declare function findingToLesson(f: unknown): string | null;
-/** Normalize for dedup/idempotency: lowercase, collapse whitespace, strip
- *  trailing punctuation. */
-export declare function normKey(s: string): string;
-/** Curator proposers are prompt-tier — they manage a text block in the surface.
- *  A code-tier surface has no prompt to append to; fail loud rather than
- *  silently coercing. */
-export declare function surfaceToText(surface: MutableSurface): string;
-/** Body text strictly between `startMarker` and `endMarker`; '' if absent. */
-export declare function extractBlockBody(text: string, startMarker: string, endMarker: string): string;
-/** Remove the delimited block (and surrounding trailing whitespace), trimmed,
- *  so the caller can re-emit a fresh block. */
-export declare function stripBlock(text: string, startMarker: string, endMarker: string): string;
-//# sourceMappingURL=_findings-text.d.ts.map

package/dist/campaign/proposers/_findings-text.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"_findings-text.d.ts","sourceRoot":"","sources":["../../../src/campaign/proposers/_findings-text.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AAE9C;mFACmF;AACnF,wBAAgB,eAAe,CAAC,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAQzD;AAED;4BAC4B;AAC5B,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAMzC;AAED;;yBAEyB;AACzB,wBAAgB,aAAa,CAAC,OAAO,EAAE,cAAc,GAAG,MAAM,CAK7D;AAOD,8EAA8E;AAC9E,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAK7F;AAED;+CAC+C;AAC/C,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAKvF"}

package/dist/campaign/proposers/ace.d.ts

@@ -1,33 +0,0 @@
-/**
- * `aceProposer` — Agentic Context Engineering: an APPEND-MOSTLY curator, the
- * deliberate contrast to `memoryCurationProposer`'s dedup-and-replace. ACE's
- * thesis (arXiv:2510.04618) is that aggressively deduping/rewriting a context
- * causes "context collapse" — hard-won specific lessons get summarized away. So
- * the playbook GROWS by appending each generation's new lessons as provenance-
- * tagged delta bullets; existing bullets are preserved verbatim, never merged.
- *
- * Each generation it:
- *  1. reads the playbook block already in the parent surface (verbatim);
- *  2. turns this generation's `findings` into lessons, keeping only the ones not
- *     already present (idempotency — a recurring finding is not re-appended, but
- *     a genuinely NEW lesson always is, even if similar to an old one);
- *  3. appends the new lessons as `- [gN] <lesson>` deltas and re-emits the block.
- *
- * Bounded WITHOUT collapse: when the playbook exceeds `maxEntries`, the OLDEST
- * deltas are evicted (FIFO) — recency is kept, but no two distinct lessons are
- * ever merged into one. Deterministic (no LLM) so a lift is attributable to the
- * accumulated lessons, not a rewrite's model noise.
- *
- * Fail-loud: with no new lesson this generation it returns NO candidate (the
- * playbook is unchanged — nothing to propose), never a fabricated bullet.
- */
-import type { SurfaceProposer } from '../types';
-export interface AceProposerOptions {
-    /** Max delta bullets retained in the playbook. On overflow the OLDEST are
-     *  evicted (FIFO) — never merged. Default 50 (ACE keeps a long context). */
-    maxEntries?: number;
-    /** Heading rendered above the bullets inside the block. */
-    sectionHeading?: string;
-}
-export declare function aceProposer(opts?: AceProposerOptions): SurfaceProposer;
-//# sourceMappingURL=ace.d.ts.map

package/dist/campaign/proposers/ace.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ace.d.ts","sourceRoot":"","sources":["../../../src/campaign/proposers/ace.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,KAAK,EAAqC,eAAe,EAAE,MAAM,UAAU,CAAA;AAalF,MAAM,WAAW,kBAAkB;IACjC;gFAC4E;IAC5E,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,2DAA2D;IAC3D,cAAc,CAAC,EAAE,MAAM,CAAA;CACxB;AAwBD,wBAAgB,WAAW,CAAC,IAAI,GAAE,kBAAuB,GAAG,eAAe,CAgD1E"}

package/dist/campaign/proposers/ace.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=ace.test.d.ts.map

package/dist/campaign/proposers/ace.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ace.test.d.ts","sourceRoot":"","sources":["../../../src/campaign/proposers/ace.test.ts"],"names":[],"mappings":""}

package/dist/campaign/proposers/analysis-edit.d.ts

@@ -1,32 +0,0 @@
-/**
- * Shared core for prompt-tier "analysis → one LLM edit" proposers. `haloProposer`
- * and `traceAnalystProposer` differ ONLY in who produces the findings; the
- * materialize-traces → apply-via-`APPLY_SYSTEM` → candidate pipeline is
- * identical. Keeping it in one place IS the fairness contract their head-to-head
- * (`compareProposers`) depends on — the apply step can no longer drift between the
- * two engines being compared.
- */
-import type { LlmClientOptions } from '../../llm-client';
-import type { ProposeContext, SurfaceProposer } from '../types';
-export declare const APPLY_SYSTEM = "You apply a trace-analysis report to an agent instruction prompt. Output ONLY the full revised prompt \u2014 no preamble, no commentary, no code fences. Make the minimal edits that address the report findings; preserve everything else verbatim.";
-/** Serialize a surface (string or structured) into prompt text. */
-export declare function surfaceToPromptText(surface: unknown): string;
-export interface AnalysisEditProposerOptions {
-    kind: string;
-    label: string;
-    baseUrl: string;
-    apiKey?: string;
-    applyModel: string;
-    fetchImpl?: LlmClientOptions['fetch'];
-    /** Resolve the OTLP traces (JSONL) for THIS generation. Empty → `noTracesError`. */
-    resolveTraces: (ctx: ProposeContext) => string | Promise<string>;
-    /** Produce the analysis REPORT string from the materialized trace file. Owns
-     *  its engine-specific failure + no-findings throws. */
-    analyze: (tracePath: string, ctx: ProposeContext) => Promise<string>;
-    noTracesError: string;
-    rationale: (report: string) => string;
-}
-/** Build a `SurfaceProposer` that runs `analyze` over the generation's OTLP
- *  traces and applies the report to the surface via one identical LLM edit. */
-export declare function analysisEditProposer(opts: AnalysisEditProposerOptions): SurfaceProposer;
-//# sourceMappingURL=analysis-edit.d.ts.map

package/dist/campaign/proposers/analysis-edit.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"analysis-edit.d.ts","sourceRoot":"","sources":["../../../src/campaign/proposers/analysis-edit.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAKH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAA;AAExD,OAAO,KAAK,EAAE,cAAc,EAAqB,eAAe,EAAE,MAAM,UAAU,CAAA;AAElF,eAAO,MAAM,YAAY,yPAC0N,CAAA;AAEnP,mEAAmE;AACnE,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAE5D;AAED,MAAM,WAAW,2BAA2B;IAC1C,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,CAAA;IACb,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,UAAU,EAAE,MAAM,CAAA;IAClB,SAAS,CAAC,EAAE,gBAAgB,CAAC,OAAO,CAAC,CAAA;IACrC,oFAAoF;IACpF,aAAa,EAAE,CAAC,GAAG,EAAE,cAAc,KAAK,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;IAChE;4DACwD;IACxD,OAAO,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,cAAc,KAAK,OAAO,CAAC,MAAM,CAAC,CAAA;IACpE,aAAa,EAAE,MAAM,CAAA;IACrB,SAAS,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,CAAA;CACtC;AAED;+EAC+E;AAC/E,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,2BAA2B,GAAG,eAAe,CAgCvF"}

package/dist/campaign/proposers/evolutionary.d.ts

@@ -1,20 +0,0 @@
-/**
- * `evolutionaryProposer` — adapts a stateless `Mutator` (population mutation:
- * GEPA / AxGEPA / reflective-mutation) into a `SurfaceProposer`. This is
- * the evolutionary strategy: each generation, mutate the current best surface
- * into N candidates, measure, select. No generation memory beyond the current
- * surface; the loop body handles ranking + promotion.
- *
- * The reflective alternative is agent-runtime's runtime proposer with a
- * `reflectiveGenerator` / `agenticGenerator`: it reasons over the report +
- * trace findings to propose targeted edits rather than blind mutations. Both
- * conform to `SurfaceProposer`; the improvement loop is identical either way.
- */
-import type { Mutator, SurfaceProposer } from '../types';
-export interface EvolutionaryProposerOptions<TFindings = unknown> {
-    mutator: Mutator<TFindings>;
-    /** External findings fed to the mutator each generation. Default: []. */
-    findings?: TFindings[];
-}
-export declare function evolutionaryProposer<TFindings = unknown>(opts: EvolutionaryProposerOptions<TFindings>): SurfaceProposer<TFindings>;
-//# sourceMappingURL=evolutionary.d.ts.map

package/dist/campaign/proposers/evolutionary.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"evolutionary.d.ts","sourceRoot":"","sources":["../../../src/campaign/proposers/evolutionary.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAExD,MAAM,WAAW,2BAA2B,CAAC,SAAS,GAAG,OAAO;IAC9D,OAAO,EAAE,OAAO,CAAC,SAAS,CAAC,CAAA;IAC3B,yEAAyE;IACzE,QAAQ,CAAC,EAAE,SAAS,EAAE,CAAA;CACvB;AAED,wBAAgB,oBAAoB,CAAC,SAAS,GAAG,OAAO,EACtD,IAAI,EAAE,2BAA2B,CAAC,SAAS,CAAC,GAC3C,eAAe,CAAC,SAAS,CAAC,CAY5B"}