@tangle-network/agent-eval 0.93.0 → 0.95.0

package/dist/campaign/labeled-store/fs-adapter.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Filesystem `LabeledScenarioStore` adapter. The default capture sink for
+ * traces + eval artifacts. Production deployments typically swap for a
+ * Turso/SQLite adapter (same interface).
+ *
+ * Records land as one JSONL file per source under `<root>/<source>.jsonl`.
+ * Each line is a `LabeledScenarioRecord`. Append-only — no in-place edits.
+ *
+ * Safety properties enforced at write-time:
+ *
+ *   - **Provenance required**: writes without `source`, `sourceVersionHash`,
+ *     `capturedAt`, `redactionStatus` are rejected. Closes the alignment
+ *     reviewer's data-poisoning gap.
+ *   - **Per-source rate limits**: optional `rateLimitBucket` + `maxWritesPerMinute`
+ *     stops a single tenant/source from flooding the store.
+ *
+ * Safety properties enforced at sample-time:
+ *
+ *   - **Required split + capturedBefore**: substrate refuses to sample without
+ *     an explicit `split` ('train' | 'test') AND a temporal cutoff. Eliminates
+ *     accidental train/test contamination.
+ *   - **Default training-source filter**: when the store is sampled with
+ *     `split: 'train'`, production-trace records are EXCLUDED unless the
+ *     caller passes `filter.source: 'production-trace'` explicitly. Closes
+ *     the contamination-by-default gap flagged by the senior eval engineer.
+ */
+import type { LabeledScenarioRecord, LabeledScenarioSampleArgs, LabeledScenarioStore, LabeledScenarioWrite, LabelTrust } from '../types';
+export interface FsLabeledScenarioStoreOptions {
+    /** Root directory for JSONL files. Created if missing. */
+    root: string;
+    /** Per-source rate limit. When set, writes exceeding the cap are rejected
+     *  with a typed error. Default: no limit. */
+    maxWritesPerMinutePerBucket?: number;
+    /** Test seam — override `Date.now()` for deterministic tests. */
+    now?: () => number;
+}
+export declare class LabeledScenarioStoreError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+export declare class FsLabeledScenarioStore implements LabeledScenarioStore {
+    private readonly options;
+    private readonly now;
+    private readonly rateLimits;
+    constructor(options: FsLabeledScenarioStoreOptions);
+    observe(write: LabeledScenarioWrite): Promise<void>;
+    sample(args: LabeledScenarioSampleArgs): Promise<LabeledScenarioRecord[]>;
+    size(): Promise<{
+        train: number;
+        test: number;
+        bySource: Record<string, number>;
+        byTrust: Record<LabelTrust, number>;
+    }>;
+    private assertProvenance;
+    private assertRateLimit;
+    private toRecord;
+    private pathForSource;
+}
+//# sourceMappingURL=fs-adapter.d.ts.map

package/dist/campaign/labeled-store/fs-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fs-adapter.d.ts","sourceRoot":"","sources":["../../../src/campaign/labeled-store/fs-adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAKH,OAAO,KAAK,EACV,qBAAqB,EACrB,yBAAyB,EAEzB,oBAAoB,EACpB,oBAAoB,EACpB,UAAU,EACX,MAAM,UAAU,CAAA;AAGjB,MAAM,WAAW,6BAA6B;IAC5C,0DAA0D;IAC1D,IAAI,EAAE,MAAM,CAAA;IACZ;iDAC6C;IAC7C,2BAA2B,CAAC,EAAE,MAAM,CAAA;IACpC,iEAAiE;IACjE,GAAG,CAAC,EAAE,MAAM,MAAM,CAAA;CACnB;AAED,qBAAa,yBAA0B,SAAQ,KAAK;aAEhC,IAAI,EAAE,MAAM;gBAAZ,IAAI,EAAE,MAAM,EAC5B,OAAO,EAAE,MAAM;CAKlB;AAQD,qBAAa,sBAAuB,YAAW,oBAAoB;IAIrD,OAAO,CAAC,QAAQ,CAAC,OAAO;IAHpC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAc;IAClC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAoC;gBAElC,OAAO,EAAE,6BAA6B;IAK7D,OAAO,CAAC,KAAK,EAAE,oBAAoB,GAAG,OAAO,CAAC,IAAI,CAAC;IAYnD,MAAM,CAAC,IAAI,EAAE,yBAAyB,GAAG,OAAO,CAAC,qBAAqB,EAAE,CAAC;IA8CzE,IAAI,IAAI,OAAO,CAAC;QACpB,KAAK,EAAE,MAAM,CAAA;QACb,IAAI,EAAE,MAAM,CAAA;QACZ,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;QAChC,OAAO,EAAE,MAAM,CAAC,UAAU,EAAE,MAAM,CAAC,CAAA;KACpC,CAAC;IAiCF,OAAO,CAAC,gBAAgB;IAiCxB,OAAO,CAAC,eAAe;IAmBvB,OAAO,CAAC,QAAQ;IAkBhB,OAAO,CAAC,aAAa;CAGtB"}

package/dist/campaign/presets/compare-proposers.d.ts

@@ -0,0 +1,146 @@
+/**
+ * `compareProposers` — a head-to-head lift benchmark across surface proposers
+ * on ONE corpus. This is the forcing function: optimizer quality (GEPA
+ * reflection vs GEPA+Pareto vs SkillOpt) becomes a NUMBER with a confidence
+ * interval, so a proposer regression — or shipping a simplified proposer and
+ * calling it the real one — turns a build red instead of going
+ * measurement-invisible.
+ *
+ * Every entrant is scored the SAME way: each proposer returns the surface it
+ * promoted, then the benchmark scores the baseline + every winner on the
+ * SAME held-out scenarios with the SAME judges. Apples-to-apples by
+ * construction — the comparison never depends on how a proposer measured itself.
+ * The per-scenario held-out composites feed a paired bootstrap (`statistics.ts`)
+ * for each proposer's lift CI and for the pairwise "which proposer wins" CI.
+ */
+import type { LlmClientOptions } from '../../llm-client';
+import { type FapoProposerOptions, type ParameterCandidate } from '../proposers/fapo';
+import { type RunCampaignOptions } from '../run-campaign';
+import type { DispatchContext, JudgeConfig, MutableSurface, Scenario, SurfaceProposer } from '../types';
+import { type RunImprovementLoopOptions } from './run-improvement-loop';
+/** What an optimizer produced: the surface it promoted + what it cost to get
+ *  there. The comparison does the held-out scoring itself, so an entry only
+ *  needs to run its loop and hand back the winner. */
+export interface ProposerEntry {
+    name: string;
+    optimize: () => Promise<{
+        winnerSurface: MutableSurface;
+        costUsd: number;
+        durationMs?: number;
+    }>;
+}
+export interface ProposerScore {
+    name: string;
+    /** Mean held-out composite of the baseline (identical across proposers). */
+    baselineComposite: number;
+    /** Mean held-out composite of this proposer's promoted surface. */
+    winnerComposite: number;
+    /** Mean per-scenario held-out lift (winner − baseline). */
+    lift: number;
+    /** Paired-bootstrap CI of the per-scenario lift. `low > 0` ⇒ a real gain. */
+    liftCi: {
+        low: number;
+        high: number;
+    };
+    costUsd: number;
+    durationMs?: number;
+    winnerSurface: MutableSurface;
+    /** 1-based, by descending lift. */
+    rank: number;
+}
+export interface ProposerPairwise {
+    /** Higher-ranked proposer. */
+    a: string;
+    b: string;
+    /** Mean per-scenario held-out delta (a − b). */
+    deltaMean: number;
+    low: number;
+    high: number;
+    /** `a` if the CI clears 0, `b` if it is entirely negative, else `'tie'`. */
+    favored: string;
+}
+export interface ProposerComparison {
+    /** Sorted by descending lift; `rank` set accordingly. */
+    scores: ProposerScore[];
+    best: ProposerScore;
+    /** Best vs each other proposer, paired-bootstrap on the held-out winners. */
+    pairwise: ProposerPairwise[];
+    holdoutScenarioIds: string[];
+}
+export interface CompareProposersOptions<TScenario extends Scenario, TArtifact> extends Omit<RunCampaignOptions<TScenario, TArtifact>, 'dispatch' | 'scenarios'> {
+    proposers: ProposerEntry[];
+    baselineSurface: MutableSurface;
+    /** The held-out scenarios every winner is scored on. */
+    holdoutScenarios: TScenario[];
+    /** Scores a surface on a scenario — the same dispatcher the proposers used. */
+    dispatchWithSurface: (surface: MutableSurface, scenario: TScenario, ctx: DispatchContext) => Promise<TArtifact>;
+    /** Bootstrap resamples for the lift CIs. Default 2000. */
+    resamples?: number;
+    /** CI confidence. Default 0.95. */
+    confidence?: number;
+}
+export declare function compareProposers<TScenario extends Scenario, TArtifact>(opts: CompareProposersOptions<TScenario, TArtifact>): Promise<ProposerComparison>;
+/** Shared corpus + transport for the three built-in optimizer entries. */
+export interface OptimizerEntryConfig<TScenario extends Scenario, TArtifact> {
+    baselineSurface: string;
+    /** Training scenarios the proposers reflect on. */
+    trainScenarios: TScenario[];
+    /** Held-out scenarios (the gate axis + the benchmark scoring axis). */
+    holdoutScenarios: TScenario[];
+    dispatchWithSurface: (surface: MutableSurface, scenario: TScenario, ctx: DispatchContext) => Promise<TArtifact>;
+    judges: JudgeConfig<TArtifact, TScenario>[];
+    llm: LlmClientOptions;
+    model: string;
+    target: string;
+    runDir: string;
+    seed?: number;
+    /** GEPA population per generation. Default 2. */
+    populationSize?: number;
+    /** GEPA generations. Default 3. */
+    maxGenerations?: number;
+    /** SkillOpt epochs. Default 6. */
+    maxEpochs?: number;
+    mutationPrimitives?: string[];
+    /** Static findings seed forwarded to each GEPA proposer's `propose()` as
+     *  `ctx.findings`. Forwarded by `gepaReflectionEntry` / `gepaParetoEntry`;
+     *  `skillOptEntry` runs without findings (see its doc). */
+    findings?: unknown[];
+    /** Per-generation findings producer: after each generation scores, this
+     *  re-diagnoses and REPLACES `ctx.findings` for the
+     *  next generation's `propose()`. Reuses the `runOptimization` field type so
+     *  it cannot drift. GEPA entries only. */
+    analyzeGeneration?: RunImprovementLoopOptions<TScenario, TArtifact>['analyzeGeneration'];
+    /** Optional analysis report forwarded to `propose()` as `ctx.report`. */
+    report?: unknown;
+}
+/** GEPA, reflection-only (single-parent, no Pareto combine). */
+export declare function gepaReflectionEntry<TScenario extends Scenario, TArtifact>(config: OptimizerEntryConfig<TScenario, TArtifact>, name?: string): ProposerEntry;
+/** GEPA with the Pareto frontier + combine-complementary-lessons. */
+export declare function gepaParetoEntry<TScenario extends Scenario, TArtifact>(config: OptimizerEntryConfig<TScenario, TArtifact>, name?: string): ProposerEntry;
+/** SkillOpt patch-mode hill-climb. Runs findings-BLIND: `runSkillOpt` owns its
+ *  own epoch acceptance/budget loop and does not thread `analyzeGeneration`, so
+ *  `config.findings` is intentionally NOT forwarded here. In a findings-fed
+ *  comparison this entry is the blind control — do not read its result as
+ *  findings-fed. (Threading findings into the SkillOpt epoch loop is a separate
+ *  refactor, deferred not faked.) */
+export declare function skillOptEntry<TScenario extends Scenario, TArtifact>(config: OptimizerEntryConfig<TScenario, TArtifact>, name?: string): ProposerEntry;
+/** FAPO reviewed-escalation policy. This is an orchestration layer over
+ * level-specific proposers, not a new mutation operator:
+ * prompt -> parameter -> structural, with scope + reviewer + plateau rules in
+ * `fapoProposer`. The prompt proposer defaults to GEPA+Pareto because that is
+ * the package's strongest prompt-tier proposer; parameter/structural proposers
+ * are opt-in so we do not fake code-generation inside agent-eval. */
+export interface FapoEntryConfig<TScenario extends Scenario, TArtifact> extends OptimizerEntryConfig<TScenario, TArtifact> {
+    /** Override the prompt-level proposer. Default: `gepaProposer({ combineParents: true })`. */
+    promptProposer?: SurfaceProposer;
+    /** Parameter/config-level proposer. If omitted, `parameterCandidates` builds one. */
+    parameterProposer?: SurfaceProposer;
+    /** Structural/code-level proposer, typically supplied by agent-runtime. */
+    structuralProposer?: SurfaceProposer;
+    /** Convenience: build a `parameterSweepProposer` from these candidates. */
+    parameterCandidates?: readonly ParameterCandidate[];
+    /** FAPO policy knobs: scope, reviewer, plateau thresholds. */
+    fapo?: Omit<FapoProposerOptions, 'proposers' | 'promptProposer' | 'parameterProposer' | 'structuralProposer'>;
+}
+export declare function fapoEscalationEntry<TScenario extends Scenario, TArtifact>(config: FapoEntryConfig<TScenario, TArtifact>, name?: string): ProposerEntry;
+//# sourceMappingURL=compare-proposers.d.ts.map

package/dist/campaign/presets/compare-proposers.d.ts.map

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

package/dist/campaign/presets/playback.d.ts

@@ -0,0 +1,120 @@
+/**
+ * Product-flow playback — drive the REAL product through a user story and
+ * score the produced state per requirement (the launch "Jira tick-off").
+ *
+ * This is the substrate adapter + contract only. It plugs a `PlaybackDriver`
+ * into the existing `runProfileMatrix` dispatch seam: a driver drives the real
+ * product (a Playwright UI session or a sandbox workspace) and returns the
+ * runtime event stream; `extractProducedState` + `verifyCompletion` then score
+ * each requirement PASS/FAIL. The concrete drivers live in consumers — they
+ * depend on browser / runtime infra the substrate must not import — so
+ * agent-eval owns the seam, the `UserStory` contract, and the scoreboard.
+ */
+import type { AgentProfile } from '@tangle-network/agent-interface';
+import { type CompletionRequirement, type CompletionVerdict, type CorrectnessChecker, type ProducedState } from '../../completion-verifier';
+import { type RuntimeEventLike } from '../../produced-state';
+import type { DispatchContext, Scenario } from '../types';
+import type { ProfileDispatchFn } from './run-profile-matrix';
+/** One step of a user story — what the user does. The driver interprets
+ *  `payload` (a Playwright selector + action, or a sandbox chat turn). */
+export interface PlaybackStep {
+    /** Human-readable action, captured verbatim in the UX narrative. */
+    action: string;
+    /** Driver-specific payload (e.g. `{ selector, fill }` or `{ turn }`). */
+    payload?: Record<string, unknown>;
+}
+/**
+ * A user story = a runnable product journey plus the requirements that define
+ * "this story works". Each requirement is one Jira ticket line. Extends
+ * `Scenario` so a catalog drops straight into `runProfileMatrix({ scenarios })`.
+ */
+export interface UserStory extends Scenario {
+    /** Human-readable story title (the ticket headline). */
+    title: string;
+    /** Ordered steps the driver executes. */
+    steps: PlaybackStep[];
+    /** What must hold in the produced state for the story to pass. */
+    requirements: CompletionRequirement[];
+}
+/** Dispatch context plus the profile under test (which cheap model, etc.). */
+export interface PlaybackContext extends DispatchContext {
+    profile: AgentProfile;
+}
+/**
+ * Drives the real product through a story and returns the runtime event stream
+ * `extractProducedState` consumes. Implemented by CONSUMERS —
+ * `SandboxPlaybackDriver` (real API / sandbox workspace) and
+ * `PlaywrightPlaybackDriver` (real UI) — because they depend on runtime /
+ * browser infra the substrate must not import. The driver MUST report LLM
+ * usage via `ctx.cost.observeTokens` so the backend-integrity guard sees real
+ * tokens (a run that never reports tokens reads as a stub).
+ */
+export interface PlaybackDriver<TStory extends UserStory = UserStory> {
+    run(story: TStory, ctx: PlaybackContext): Promise<readonly RuntimeEventLike[]>;
+}
+/**
+ * Adapt a `PlaybackDriver` into a `runProfileMatrix` dispatch. The artifact the
+ * matrix scores is the `ProducedState` extracted from the driver's event
+ * stream — grade it with `scoreUserStory` (or a judge wrapping it).
+ */
+export declare function makePlaybackDispatch<TStory extends UserStory>(driver: PlaybackDriver<TStory>): ProfileDispatchFn<TStory, ProducedState>;
+/** A scored user story — the completion verdict plus its human title. */
+export interface UserStoryVerdict extends CompletionVerdict {
+    title: string;
+}
+/**
+ * Score one story's produced state against its requirements. Thin wrapper over
+ * `verifyCompletion` that builds the gold from the story and returns a
+ * per-requirement PASS/FAIL verdict. `checkCorrectness` is injected — a
+ * deterministic stub in tests, `createLlmCorrectnessChecker` in production.
+ */
+export declare function scoreUserStory(story: UserStory, state: ProducedState, checkCorrectness: CorrectnessChecker): Promise<UserStoryVerdict>;
+/** One row of the launch scoreboard — story × requirement → PASS/FAIL. */
+export interface ScoreboardRow {
+    storyId: string;
+    storyTitle: string;
+    reqId: string;
+    reqTitle: string;
+    status: 'PASS' | 'FAIL';
+    evidence: string[];
+}
+/**
+ * Flatten story verdicts into the per-requirement scoreboard — the literal
+ * Jira tick-off: one row per (story, requirement) with PASS/FAIL and the
+ * evidence behind the verdict.
+ */
+export declare function userStoryScoreboard(verdicts: readonly UserStoryVerdict[]): ScoreboardRow[];
+/** Launch-readiness headline counts rolled up from the per-requirement rows. */
+export interface ScoreboardSummary {
+    /** Distinct user stories on the board. */
+    stories: number;
+    /** Stories whose every requirement passed. */
+    storiesFullyComplete: number;
+    /** Total (story, requirement) rows. */
+    requirements: number;
+    /** Rows with status PASS. */
+    passed: number;
+    /** Rows with status FAIL. */
+    failed: number;
+    /** passed / requirements; 0 when there are no rows. */
+    passRate: number;
+}
+/** Roll the per-requirement rows up into the launch headline counts. */
+export declare function scoreboardSummary(rows: readonly ScoreboardRow[]): ScoreboardSummary;
+export interface ScoreboardRenderOptions {
+    /** Document H1. Defaults to a generic playback title. */
+    title?: string;
+    /** Key/value run metadata rendered under the headline (runId, backend, model, date). */
+    meta?: Record<string, string>;
+    /** Max chars of joined evidence shown per row. Default 160. */
+    maxEvidenceChars?: number;
+}
+/**
+ * Render the scoreboard as a launch-readiness Markdown document — the literal
+ * "tick off every user story" artifact: a headline roll-up, the open tickets
+ * (FAIL rows) up top as the launch blockers, then a per-story table of
+ * requirement → PASS/FAIL with the evidence behind each verdict. Pure: same
+ * rows in, same bytes out (no clock/random), so it is safe to snapshot.
+ */
+export declare function renderScoreboardMarkdown(rows: readonly ScoreboardRow[], opts?: ScoreboardRenderOptions): string;
+//# sourceMappingURL=playback.d.ts.map

package/dist/campaign/presets/playback.d.ts.map

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

package/dist/campaign/presets/playback.test.d.ts

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

package/dist/campaign/presets/playback.test.d.ts.map

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

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

@@ -0,0 +1,14 @@
+/**
+ * `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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,63 @@
+/**
+ * `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

@@ -0,0 +1 @@
+{"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

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

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,92 @@
+/**
+ * `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

@@ -0,0 +1 @@
+{"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"}