@tangle-network/agent-eval 0.144.11 → 0.144.13

package/dist/{skillopt-optimization-method-USDKhxSA.d.ts → provenance-CCdxgLDT.d.ts}

@@ -1,13 +1,11 @@
-import { c as CostLedgerHandle, f as CostLedgerSummary, m as CostReceipt, o as CostLedger, p as CostProvenance } from "./cost-ledger-Bv_e8XHY.js";
-import { a as RunRecord } from "./run-record-CF4Dwpxr.js";
-import { A as ChatClient, U as LlmCallMetadata } from "./types-D216SgwM.js";
-import { s as TraceStore } from "./store-CT9YIIve.js";
-import { _ as ProposalFinding } from "./types-BvDKaULh.js";
-import { _ as ExternalTextEvaluationRequest, c as ExternalOptimizerModelBudget, g as ExternalTextCandidate, h as ExternalOptimizerRunnerCommand, l as ExternalOptimizerModelCall, m as ExternalOptimizerResumeMode, o as ExternalOptimizerEvaluationObservation, r as ExternalOptimizerCallbackLimits } from "./external-optimizer-contracts-CZuJNcT5.js";
-import { C as JudgeDimension, H as SurfaceProposer, N as ParetoParent, R as Scenario, S as JudgeConfig, _ as GateDecision, a as CampaignResult, b as GenerationRecord, c as CampaignTraceWriter, d as DispatchContext, f as DispatchFn, g as GateContribution, i as CampaignCostMeter, j as MutableSurface, k as LabeledScenarioStore, o as CampaignScenarioIdentity, p as Gate, r as CampaignCellResult, v as GateResult, y as GenerationCandidate } from "./types-BnjdJ70P.js";
-import { a as DatasetScenario, t as Dataset } from "./dataset-C8xaLXdY.js";
-import { t as DetectRewardHackingInput } from "./reward-hacking-BI0OMAlo.js";
-import { g as TraceSpanEvent, t as HostedClient } from "./client-C9gzZE59.js";
+import { c as CostLedgerHandle, f as CostLedgerSummary, m as CostReceipt, o as CostLedger, p as CostProvenance } from "./cost-ledger-DbQdN3nO.js";
+import { a as RunRecord } from "./run-record-CKiihE6f.js";
+import { p as ChatClient } from "./types-Cx3YUh2r.js";
+import { _ as ProposalFinding } from "./types-DLQx4mKU.js";
+import { g as ExternalTextCandidate, o as ExternalOptimizerEvaluationObservation } from "./external-optimizer-contracts-lixrOZdX.js";
+import { C as JudgeDimension, H as SurfaceProposer, N as ParetoParent, R as Scenario, S as JudgeConfig, _ as GateDecision, a as CampaignResult, b as GenerationRecord, c as CampaignTraceWriter, d as DispatchContext, f as DispatchFn, g as GateContribution, j as MutableSurface, k as LabeledScenarioStore, p as Gate, r as CampaignCellResult, v as GateResult, y as GenerationCandidate } from "./types-BZ59Ahr8.js";
+import { r as DatasetScenario, t as Dataset } from "./dataset-CJjKqQfA.js";
+import { g as TraceSpanEvent, t as HostedClient } from "./client-KUbGulm_.js";
 import { z } from "zod";
 //#region src/llm-judge.d.ts
 /** A rubric dimension as a bare key or the full `{ key, description }` shape. A
@@ -62,43 +60,6 @@ interface LlmJudgeOptions<TArtifact, TScenario extends Scenario = Scenario> {
  */
 declare function llmJudge<TArtifact = unknown, TScenario extends Scenario = Scenario>(name: string, prompt: string, opts: LlmJudgeOptions<TArtifact, TScenario>): JudgeConfig<TArtifact, TScenario>;
 //#endregion
-//#region src/reference-equivalence-judge.d.ts
-declare const REFERENCE_EQUIVALENCE_JUDGE_VERSION = "reference-equivalence-judge-v1-2026-07-13";
-declare const REFERENCE_EQUIVALENCE_INPUT_LIMITS: {
-  readonly userRequest: 8000;
-  readonly expectedAnswer: 32000;
-  readonly candidateOutput: 32000;
-};
-interface ReferenceEquivalenceScenario extends Scenario {
-  userRequest: string;
-  expectedAnswer: string;
-}
-interface ReferenceEquivalenceJudgeInput {
-  userRequest: string;
-  expectedAnswer: string;
-  candidateOutput: string;
-}
-interface ReferenceEquivalenceJudgeOptions {
-  /** Injected transport. No implicit provider or credentials are selected. */
-  chat: ChatClient;
-  /** Falls back to the ChatClient's default model. */
-  model?: string;
-  /** Used only by the direct-call adapter. */
-  signal?: AbortSignal;
-  /** Optional receipt destination for direct calls; campaigns supply their own. */
-  costLedger?: CostLedgerHandle;
-}
-interface ReferenceEquivalenceJudgeResult extends LlmCallMetadata {
-  kind: 'reference-equivalence';
-  version: string;
-  score: number;
-  rationale: string;
-}
-/** Build the campaign-native expected-answer judge. */
-declare function createReferenceEquivalenceJudge(options: ReferenceEquivalenceJudgeOptions): JudgeConfig<string, ReferenceEquivalenceScenario>;
-/** Direct-call adapter over the campaign judge for product callers. */
-declare function runReferenceEquivalenceJudge(input: ReferenceEquivalenceJudgeInput, options: ReferenceEquivalenceJudgeOptions): Promise<ReferenceEquivalenceJudgeResult>;
-//#endregion
 //#region src/campaign/auto-pr.d.ts
 interface OpenAutoPrOptions<TArtifact, TScenario extends Scenario> {
   /** Campaign result to attach to the PR. */
@@ -137,18 +98,6 @@ interface OpenAutoPrResult {
  */
 declare function openAutoPr<TArtifact, TScenario extends Scenario>(options: OpenAutoPrOptions<TArtifact, TScenario>): OpenAutoPrResult;
 //#endregion
-//#region src/campaign/coverage.d.ts
-/** Reject campaign designs whose denominator cannot be identified exactly. */
-declare function assertCampaignDesign<TScenario extends Scenario>(scenarios: readonly TScenario[], reps: number): void;
-/** Redacted but independently verifiable identity of one complete scenario. */
-declare function campaignScenarioIdentity<TScenario extends Scenario>(scenario: TScenario): CampaignScenarioIdentity & Pick<TScenario, 'id' | 'kind'>;
-/** Canonical split identity reconstructed from redacted scenario identities. */
-declare function campaignSplitDigestFromIdentities(scenarios: readonly CampaignScenarioIdentity[], reps: number): `sha256:${string}`;
-/** Canonical identity of the exact scenario payloads and replicate count. */
-declare function campaignSplitDigest<TScenario extends Scenario>(scenarios: readonly TScenario[], reps: number): `sha256:${string}`;
-/** Refuse a campaign whose retained task identities contradict its split digest. */
-declare function assertCampaignSplitIdentity(scenarios: readonly CampaignScenarioIdentity[], reps: number, splitDigest: string): void;
-//#endregion
 //#region src/campaign/storage.d.ts
 /**
  * `CampaignStorage` — the filesystem seam `runCampaign` writes through
@@ -298,6 +247,53 @@ declare function readGepaCandidatePopulationArtifact(input: {
   storage?: CampaignStorage;
 }): GepaCandidatePopulationArtifact;
 //#endregion
+//#region src/campaign/cell-cache.d.ts
+type CacheIssueReason = 'missing' | 'manifest-mismatch' | 'cell-mismatch' | 'missing-cost-provenance' | 'invalid-cost-provenance' | 'invalid-cost-receipts' | 'corrupt';
+//#endregion
+//#region src/campaign/plan-campaign-run.d.ts
+interface CampaignRunPlanCell {
+  cellId: string;
+  scenarioId: string;
+  rep: number;
+  seed: number;
+  cachePath: string;
+  status: 'cached' | 'run' | 'blocked';
+  reason?: CacheIssueReason | 'resumable-off';
+}
+interface CampaignRunPlan {
+  manifestHash: string;
+  splitDigest: `sha256:${string}`;
+  totalCells: number;
+  cellsCached: number;
+  cellsBlocked: number;
+  cellsToRun: number;
+  cells: CampaignRunPlanCell[];
+}
+interface PlanCampaignRunOptions<TScenario extends Scenario, TArtifact> {
+  scenarios: TScenario[];
+  dispatch?: DispatchFn<TScenario, TArtifact>;
+  dispatchRef?: string;
+  judges?: JudgeConfig<TArtifact, TScenario>[];
+  seed?: number;
+  reps?: number;
+  resumable?: boolean;
+  /** See RunCampaignOptions.rerunInvalidCachedCells. */
+  rerunInvalidCachedCells?: boolean;
+  runDir: string;
+  /** Subject repo for the shared run-dir root (see RunCampaignOptions.repo). */
+  repo?: string;
+  storage?: CampaignStorage;
+  /** Spend account used to validate cached receipt identities. */
+  costLedger?: CostLedgerHandle;
+  /** Receipt tags used by the campaign that produced the cached cells. */
+  costTags?: Readonly<Record<string, string>>;
+}
+/**
+ * Plan a campaign WITHOUT dispatching: computes the manifest hash and the per-cell
+ * run-vs-cached schedule so callers can preview cost and resumability before spending.
+ */
+declare function planCampaignRun<TScenario extends Scenario, TArtifact>(opts: PlanCampaignRunOptions<TScenario, TArtifact>): CampaignRunPlan;
+//#endregion
 //#region src/campaign/run-campaign.d.ts
 interface RunCampaignOptions<TScenario extends Scenario, TArtifact> {
   scenarios: TScenario[];
@@ -438,49 +434,6 @@ interface CampaignCellFailureReceipt<TArtifact = unknown> {
  * Core campaign orchestrator: fan scenarios through dispatch, score with judges, aggregate bootstrap CIs, and persist reproducible `CampaignResult` records.
  */
 declare function runCampaign<TScenario extends Scenario, TArtifact>(opts: RunCampaignOptions<TScenario, TArtifact>): Promise<CampaignResult<TArtifact, TScenario>>;
-interface CampaignRunPlanCell {
-  cellId: string;
-  scenarioId: string;
-  rep: number;
-  seed: number;
-  cachePath: string;
-  status: 'cached' | 'run' | 'blocked';
-  reason?: CacheIssueReason | 'resumable-off';
-}
-interface CampaignRunPlan {
-  manifestHash: string;
-  splitDigest: `sha256:${string}`;
-  totalCells: number;
-  cellsCached: number;
-  cellsBlocked: number;
-  cellsToRun: number;
-  cells: CampaignRunPlanCell[];
-}
-interface PlanCampaignRunOptions<TScenario extends Scenario, TArtifact> {
-  scenarios: TScenario[];
-  dispatch?: DispatchFn<TScenario, TArtifact>;
-  dispatchRef?: string;
-  judges?: JudgeConfig<TArtifact, TScenario>[];
-  seed?: number;
-  reps?: number;
-  resumable?: boolean;
-  /** See RunCampaignOptions.rerunInvalidCachedCells. */
-  rerunInvalidCachedCells?: boolean;
-  runDir: string;
-  /** Subject repo for the shared run-dir root (see RunCampaignOptions.repo). */
-  repo?: string;
-  storage?: CampaignStorage;
-  /** Spend account used to validate cached receipt identities. */
-  costLedger?: CostLedgerHandle;
-  /** Receipt tags used by the campaign that produced the cached cells. */
-  costTags?: Readonly<Record<string, string>>;
-}
-/**
- * Plan a campaign WITHOUT dispatching: computes the manifest hash and the per-cell
- * run-vs-cached schedule so callers can preview cost and resumability before spending.
- */
-declare function planCampaignRun<TScenario extends Scenario, TArtifact>(opts: PlanCampaignRunOptions<TScenario, TArtifact>): CampaignRunPlan;
-type CacheIssueReason = 'missing' | 'manifest-mismatch' | 'cell-mismatch' | 'missing-cost-provenance' | 'invalid-cost-provenance' | 'invalid-cost-receipts' | 'corrupt';
 //#endregion
 //#region src/campaign/presets/compare-optimization-methods.d.ts
 /** Shared campaign settings applied to every optimization method. */
@@ -696,96 +649,6 @@ declare function combineComparisonCosts(entries: ReadonlyArray<{
   cost: ComparisonCost;
 }>): ComparisonCost;
 //#endregion
-//#region src/campaign/external-text-evaluation.d.ts
-interface ExternalOptimizationExample {
-  id: string;
-  data: unknown;
-}
-interface ExternalTextEvaluationResponse {
-  score: number;
-  info: {
-    scenarioId: string;
-    dimensions: Record<string, number>;
-    notes?: string;
-    artifact?: unknown;
-  };
-}
-declare function decodeExternalTextCandidate(candidate: ExternalTextCandidate): MutableSurface;
-//#endregion
-//#region src/campaign/external-text-optimization-contract.d.ts
-interface ExternalTextOptimizerContext {
-  readonly runId: string;
-  readonly name: string;
-  readonly objective: string;
-  readonly evaluationId: string;
-  readonly background?: string;
-  readonly seedCandidate: ExternalTextCandidate;
-  readonly trainSet: readonly ExternalOptimizationExample[];
-  readonly selectionSet: readonly ExternalOptimizationExample[];
-  readonly maxEvaluations: number;
-  readonly seed: number;
-  /** Stable directory for optimizer checkpoints from compatible attempts. */
-  readonly stateDir: string;
-  readonly restoreRequested: boolean;
-  readonly artifactDir: string;
-  readonly signal: AbortSignal;
-  /** Record every optimizer-owned paid call through this attributed account. */
-  readonly cost: CampaignCostMeter;
-  readonly evaluate: (request: ExternalTextEvaluationRequest) => Promise<ExternalTextEvaluationResponse>;
-}
-interface ExternalTextOptimizerResult {
-  bestCandidate: ExternalTextCandidate;
-  resumed: boolean;
-  costAccounting: {
-    kind: 'metered';
-  } | {
-    kind: 'no-paid-work';
-  } | {
-    kind: 'external';
-    reason: string;
-  };
-}
-/**
- * Configuration for adapting another text optimizer.
- *
- * `run` owns search. Agent Eval owns split isolation, bounded candidate
- * evaluation, exact cost collection, provenance, and final comparison.
- */
-interface ExternalTextOptimizationMethodConfig<TScenario extends Scenario, TArtifact = unknown> {
-  name: string;
-  source: Omit<OptimizationPackageSource, 'evidence'>;
-  objective: string;
-  evaluationId: string;
-  background?: string;
-  maxEvaluations: number;
-  /** Hard limit for calls made through `context.cost`. Use 0 for no paid work. */
-  maxOptimizerCostUsd: number;
-  /** Abort `context.signal` after this duration. Default: 30 minutes. */
-  timeoutMs?: number;
-  /** Default: `never`. Compatible runs reuse one state directory. */
-  resume?: ExternalOptimizerResumeMode;
-  maxCandidateChars?: number;
-  maxEvidenceChars?: number;
-  describeScenario?: (scenario: TScenario) => unknown;
-  describeArtifact?: (artifact: TArtifact, scenario: TScenario) => unknown;
-  run: (context: ExternalTextOptimizerContext) => Promise<ExternalTextOptimizerResult>;
-}
-//#endregion
-//#region src/campaign/external-text-optimization.d.ts
-/**
- * Adapt a third-party text optimizer without reimplementing its search.
- *
- * The callback never receives final test cases. Calls to `evaluate` are
- * counted before execution and stop at `maxEvaluations`.
- */
-declare function externalTextOptimizationMethod<TScenario extends Scenario, TArtifact>(config: ExternalTextOptimizationMethodConfig<TScenario, TArtifact>): OptimizationMethod<TScenario, TArtifact>;
-//#endregion
-//#region src/campaign/gates/compose.d.ts
-/** Compose gates — all must `ship` for the composite to `ship`. First
- *  non-ship verdict short-circuits the composite verdict, but ALL gates run
- *  (so the result records every gate's reason — useful for diagnostics). */
-declare function composeGate<TArtifact = unknown, TScenario extends Scenario = Scenario>(...gates: Array<Gate<TArtifact, TScenario>>): Gate<TArtifact, TScenario>;
-//#endregion
 //#region src/canary.d.ts
 type CanaryKind = 'silent_judge_fallback' | 'judge_calibration_drift' | 'distribution_shift';
 type CanarySeverity = 'info' | 'warn' | 'error';
@@ -907,234 +770,6 @@ declare function redTeamDataset(extraCases?: RedTeamCase[]): Dataset;
 declare function scoreRedTeamOutput(output: string, toolCalls: string[], rtCase: RedTeamCase): RedTeamFinding;
 /** Aggregate red-team findings into per-category pass rates. */
 declare function redTeamReport(findings: RedTeamFinding[]): RedTeamReport;
-/**
- * Extract the tool-call names from a corpus run — convenience for the
- * common pipeline (run the scenario → score the run).
- */
-declare function toolNamesForRun(store: TraceStore, runId: string): Promise<string[]>;
-//#endregion
-//#region src/campaign/gates/default-production-gate.d.ts
-type DefaultProductionGateCheck = 'dimension-regression' | 'budget' | 'red-team' | 'reward-hacking' | 'canary';
-type DefaultProductionRewardHackingOptions = Omit<DetectRewardHackingInput, 'runs' | 'truthOf'> & {
-  truthOf: NonNullable<DetectRewardHackingInput['truthOf']>;
-};
-interface DefaultProductionGateOptions {
-  /** Required: scenarios held out from training; substrate compares
-   *  candidate-on-holdout vs baseline-on-holdout. */
-  holdoutScenarios: Scenario[];
-  /** Minimum held-out lift the **paired-bootstrap CI lower bound** must clear
-   *  to ship — NOT a point estimate. Default 0 ⇒ "confidently positive at the
-   *  confidence level". Interpreted in the judge's native composite scale (set
-   *  e.g. 2 for a 0-100 rubric to require a ≥2-point significant gain). */
-  deltaThreshold?: number;
-  /** Confidence level for the held-out + dimension bootstraps. Default 0.95. */
-  confidence?: number;
-  /** Bootstrap resamples. Default 2000. */
-  bootstrapResamples?: number;
-  /** Fixed bootstrap seed for a deterministic verdict. Default 1337. */
-  bootstrapSeed?: number;
-  /** Minimum paired holdout observations (scenarios × reps) before a
-   *  significance claim is allowed. The exact small-sample test may require
-   *  more observations at the selected confidence. Default 3. */
-  minProductiveRuns?: number;
-  /** Ship statistic for the held-out significance test. Default `'mean'`
-   *  (tie-robust — see `heldoutSignificance`). Pass `'median'` for
-   *  outlier-robustness at the cost of tie-blindness. */
-  heldoutStatistic?: 'mean' | 'median';
-  /** Critical judge dimensions that must NOT significantly regress even when
-   *  the net composite rises (anti-Goodhart). The gate HOLDS if any listed
-   *  dimension's paired-delta CI lower bound < −`regressionTolerance`. E.g.
-   *  `['hallucination_free']` for a legal agent. */
-  criticalDimensions?: string[];
-  /** Tolerance for the per-dimension regression guard, in the dimension's
-   *  native scale. When omitted it auto-scales off observed magnitudes:
-   *  0.05 on [0,1], 5 on 0-100. */
-  regressionTolerance?: number;
-  /** Total $ budget for the complete improvement run. Requires
-   *  `GateContext.costLedger`; missing or incomplete accounting holds. */
-  budgetUsd?: number;
-  /** Static artifact-screening cases. Only `expected: 'ignore'` cases without
-   *  tool assertions are valid because this check does not dispatch case inputs
-   *  or observe tool calls. */
-  redTeamBattery?: RedTeamCase[];
-  /** Shared run history, oldest first. Supplying history does not enable either
-   *  monitoring check; configure `rewardHacking` and/or `canary` explicitly. */
-  recentRuns?: RunRecord[];
-  /** Enable reward-hacking monitoring with a caller-owned independent truth channel. */
-  rewardHacking?: DefaultProductionRewardHackingOptions;
-  /** Enable canary monitoring. Pass `{}` to use the canary defaults. */
-  canary?: CanaryOptions;
-  /** Optional checks that must be evaluated even when their normal input is
-   *  absent. Configuring a check's input also makes that check required.
-   *  Missing evidence always records `not_evaluated`; required unevaluated
-   *  checks hold the release decision. Held-out significance is always required. */
-  requiredChecks?: DefaultProductionGateCheck[];
-}
-/**
- * Opinionated production gate composing held-out significance, red-team, reward-hacking, and canary checks into a single `Gate.decide` decision.
- */
-declare function defaultProductionGate<TArtifact, TScenario extends Scenario>(options: DefaultProductionGateOptions): Gate<TArtifact, TScenario>;
-//#endregion
-//#region src/campaign/gates/heldout-gate.d.ts
-interface HeldOutGateOptions<TScenario extends Scenario = Scenario> {
-  scenarios: TScenario[];
-  /** Effect-size threshold the CI lower bound must clear, in the judge's native
-   *  scale. Default 0.5. Equality holds; CI.low must be greater than this value. */
-  deltaThreshold?: number;
-  /** Bootstrap CI confidence. Default 0.95. */
-  confidence?: number;
-  /** Minimum paired holdout observations to claim significance. The exact
-   *  small-sample test may require more observations at the selected
-   *  confidence. Default 3. */
-  minProductiveRuns?: number;
-  /** Bootstrap resamples. Default 2000. */
-  resamples?: number;
-  /** Fixed bootstrap seed for deterministic verdicts. Default 1337. */
-  bootstrapSeed?: number;
-}
-/**
- * Composable held-out gate: ships only when the lower bound of the DECIDING
- * paired interval on the candidate-minus-baseline composite delta clears
- * `deltaThreshold` — Tango's score interval on a pass/fail holdout, the mean
- * bootstrap otherwise. See {@link decidePairedPromotion}.
- */
-declare function heldOutGate<TArtifact, TScenario extends Scenario>(options: HeldOutGateOptions<TScenario>): Gate<TArtifact, TScenario>;
-//#endregion
-//#region src/campaign/optimizer-model.d.ts
-type OptimizerModelBudget = ExternalOptimizerModelBudget;
-/** One metered model path supplied by the package that owns execution. */
-interface OpenAICompatibleOptimizerModel {
-  model: string;
-  budget: OptimizerModelBudget;
-  /** Caller-owned execution path, such as Runtime's exact AgentProfile adapter. */
-  call: ExternalOptimizerModelCall;
-  /** Stable public identity included in resumable-run compatibility. */
-  callRef: string;
-}
-//#endregion
-//#region src/campaign/gepa-optimization-method.d.ts
-/** Shared settings for one bounded GEPA engine invocation. */
-interface GepaEngineOptions {
-  /** GEPA engine name. GEPA validates names available in its Python runtime. */
-  engine: string;
-  /** Optional billed-USD stop. Omit when the execution owner reports USD as unknown. */
-  maxProposerCostUsd?: number;
-  /** Maximum concurrent evaluations inside this engine. Default: 1. */
-  maxConcurrency?: number;
-  /** Stop the engine after it reaches this score. */
-  stopAtScore?: number;
-  /** Isolate agent-based engines. Default: true. */
-  sandbox?: boolean;
-  /**
-   * JSON-safe configuration for the registered GEPA engine.
-   * Python callables and class instances cannot cross the process boundary.
-   */
-  engineConfig?: Record<string, unknown>;
-}
-/** One independently budgeted GEPA engine invocation. */
-interface GepaEngineRun extends GepaEngineOptions {
-  /** Maximum callback evaluations this engine may consume. */
-  maxEvaluations: number;
-}
-/** An engine in an adaptive run. All engines share the recipe evaluation limit. */
-type GepaAdaptiveEngineRun = GepaEngineOptions;
-/**
- * A direct mapping to a GEPA optimization recipe.
- *
- * GEPA owns every search and composition operation represented here. Tangle
- * supplies the candidate, data, execution callback, judges, and budgets.
- */
-type GepaOptimizationRecipe = {
-  kind: 'engine';
-  run: GepaEngineRun;
-} | {
-  kind: 'sequential';
-  runs: readonly GepaEngineRun[];
-} | {
-  kind: 'adaptive-sequential';
-  runs: readonly GepaAdaptiveEngineRun[];
-  /** One evaluation budget shared by every adaptive stage. */
-  maxEvaluations: number;
-  /** Switch engines after this many evaluations without improvement. */
-  plateauEvaluations: number;
-  patience?: number;
-  minEvaluationsPerStage?: number;
-  improvementEpsilon?: number;
-  cycle?: boolean;
-  maxSwitches?: number;
-  maxConcurrency?: number;
-} | {
-  kind: 'best-of';
-  runs: readonly GepaEngineRun[];
-  maxWorkers?: number;
-} | {
-  kind: 'vote';
-  runs: readonly GepaEngineRun[];
-  maxWorkers?: number;
-} | {
-  kind: 'omni';
-  explore: readonly GepaEngineRun[];
-  continueWith: GepaEngineRun;
-  maxWorkers?: number;
-};
-/** The command that runs the Python GEPA bridge. */
-type GepaRunnerCommand = ExternalOptimizerRunnerCommand;
-interface GepaOptimizationMethodConfig<TScenario extends Scenario, TArtifact = unknown> {
-  /** Unique comparison-method name. Default identifies the GEPA recipe. */
-  name?: string;
-  /** A direct GEPA recipe. */
-  recipe: GepaOptimizationRecipe;
-  /** Plain-language goal shown to the external optimizer. */
-  objective: string;
-  /** Stable identity for the dispatch, judges, model settings, and scoring logic. */
-  evaluationId: string;
-  /** Optional bounded context about the surface and task. */
-  background?: string;
-  /**
-   * Public dotted Python modules imported before GEPA resolves engine names.
-   * Each module should call GEPA's official `register_engine()` API at import.
-   */
-  engineModules?: readonly string[];
-  /** Reject external candidates longer than this. Default: 200,000 characters. */
-  maxCandidateChars?: number;
-  /** Reject serialized score evidence longer than this. Default: 100,000 characters. */
-  maxEvidenceChars?: number;
-  /** Candidate-evaluation callback byte limits. Omitted fields use finite defaults. */
-  evaluationCallbackLimits?: Partial<ExternalOptimizerCallbackLimits>;
-  /** End the bridge process after this many milliseconds. Default: 30 minutes. */
-  timeoutMs?: number;
-  /**
-   * OpenAI-compatible model used by standard GEPA reflection.
-   * Calls pass through Agent Eval's local model proxy. Every recipe engine must
-   * be `gepa` when this is set.
-   */
-  optimizer?: OpenAICompatibleOptimizerModel;
-  /**
-   * Decide what the external optimizer may read for a train or selection case.
-   * The returned value must be JSON-serializable. The final comparison cases
-   * are not accepted by this API and cannot be serialized here.
-   */
-  describeScenario?: (scenario: TScenario) => unknown;
-  /** Optional bounded artifact evidence returned to GEPA after each evaluation. */
-  describeArtifact?: (artifact: TArtifact, scenario: TScenario) => unknown;
-  /** Default: `never`. Compatible runs resume only when explicitly enabled. */
-  resume?: ExternalOptimizerResumeMode;
-  /**
-   * Required for resumable direct GEPA runs because upstream state uses Python
-   * pickle. Enable only for state created locally in a directory you control.
-   */
-  trustResumeState?: boolean;
-  runner?: GepaRunnerCommand;
-}
-/**
- * Turn an optional GEPA installation into an `OptimizationMethod`.
- *
- * GEPA receives only serialized train and selection cases. The caller's final
- * test partition stays inside `compareOptimizationMethods`, which invokes this
- * method without a test-set field. The local callback routes every candidate
- * evaluation through the same dispatch and judges used by other methods.
- */
-declare function gepaOptimizationMethod<TScenario extends Scenario, TArtifact>(config: GepaOptimizationMethodConfig<TScenario, TArtifact>): OptimizationMethod<TScenario, TArtifact>;
 //#endregion
 //#region src/campaign/presets/run-eval.d.ts
 interface RunEvalOptions<TScenario extends Scenario, TArtifact> extends Omit<RunCampaignOptions<TScenario, TArtifact>, 'runDir'> {
@@ -1535,61 +1170,5 @@ interface EmitLoopProvenanceArgs<TArtifact, TScenario extends Scenario> extends
  */
 declare function emitLoopProvenance<TArtifact, TScenario extends Scenario>(args: EmitLoopProvenanceArgs<TArtifact, TScenario>): Promise<EmitLoopProvenanceResult>;
 //#endregion
-//#region src/campaign/skillopt-optimization-method.d.ts
-interface SkillOptTrainerConfig {
-  epochs: number;
-  batchSize: number;
-  accumulation?: number;
-  editBudget?: number;
-  minEditBudget?: number;
-  analystWorkers?: number;
-  minibatchSize?: number;
-  mergeBatchSize?: number;
-  maxAnalystRounds?: number;
-  evaluationWorkers?: number;
-  learningRateSchedule?: 'constant' | 'linear' | 'cosine' | 'autonomous';
-  learningRateControl?: 'fixed' | 'autonomous' | 'none';
-  updateMode?: 'patch' | 'rewrite_from_suggestions' | 'full_rewrite_minibatch';
-  failureOnly?: boolean;
-  useSlowUpdate?: boolean;
-  useMetaSkill?: boolean;
-  /**
-   * Additional flat SkillOpt trainer settings. Tangle overwrites data,
-   * output, split, seed, validation, and activation settings.
-   */
-  overrides?: Record<string, unknown>;
-}
-type SkillOptRunnerCommand = ExternalOptimizerRunnerCommand;
-interface SkillOptOptimizationMethodConfig<TScenario extends Scenario, TArtifact = unknown> {
-  name?: string;
-  /** Goal included with every described train and selection case. */
-  objective: string;
-  background?: string;
-  /** Stable identity for the dispatch, judges, model settings, and scoring logic. */
-  evaluationId: string;
-  trainer: SkillOptTrainerConfig;
-  /**
-   * OpenAI-compatible model connection and hard limits for SkillOpt's own
-   * optimizer calls.
-   */
-  optimizer: OpenAICompatibleOptimizerModel;
-  /** Hard cap on candidate-case callback requests. */
-  maxEvaluations: number;
-  /** Scores at or above this value count as hard successes. Default: 1. */
-  hardScoreThreshold?: number;
-  maxCandidateChars?: number;
-  /** Maximum serialized scenario plus evaluation evidence. Default: 100,000. */
-  maxEvidenceChars?: number;
-  /** Candidate-evaluation callback byte limits. Omitted fields use finite defaults. */
-  evaluationCallbackLimits?: Partial<ExternalOptimizerCallbackLimits>;
-  timeoutMs?: number;
-  describeScenario?: (scenario: TScenario) => unknown;
-  describeArtifact?: (artifact: TArtifact, scenario: TScenario) => unknown;
-  resume?: ExternalOptimizerResumeMode;
-  runner?: SkillOptRunnerCommand;
-}
-/** Run Microsoft's SkillOpt trainer as a complete optimization method. */
-declare function skillOptOptimizationMethod<TScenario extends Scenario, TArtifact>(config: SkillOptOptimizationMethodConfig<TScenario, TArtifact>): OptimizationMethod<TScenario, TArtifact>;
-//#endregion
-export { redTeamDataset as $, fsCampaignStorage as $t, RunEvalOptions as A, combineComparisonCosts as At, OptimizerModelBudget as B, runCampaign as Bt, RunImprovementLoopOptions as C, OptimizationMethodPairwise as Ct, RunOptimizationOptions as D, OptimizationMethodScore as Dt, PremeasuredOptimizationBaseline as E, OptimizationMethodRunOptions as Et, GepaOptimizationMethodConfig as F, CampaignRunPlan as Ft, DefaultProductionRewardHackingOptions as G, readGepaCandidatePopulationArtifact as Gt, heldOutGate as H, GepaCandidatePopulationCandidate as Ht, GepaOptimizationRecipe as I, CampaignRunPlanCell as It, RedTeamCase as J, ExternalOptimizerObservationSummary as Jt, defaultProductionGate as K, ExternalOptimizerExecutionSummary as Kt, GepaRunnerCommand as L, PlanCampaignRunOptions as Lt, GepaAdaptiveEngineRun as M, costFromLedgerSummary as Mt, GepaEngineOptions as N, optimizationTokenUsageFromSummary as Nt, RunOptimizationResult as O, OptimizationPackageSource as Ot, GepaEngineRun as P, CampaignCellFailureReceipt as Pt, RedTeamReport as Q, createRunCostLedger as Qt, gepaOptimizationMethod as R, RunCampaignOptions as Rt, verifyLoopProvenanceRecord as S, OptimizationMethodInput as St, runImprovementLoop as T, OptimizationMethodResult as Tt, DefaultProductionGateCheck as U, GepaCandidatePopulationSummary as Ut, HeldOutGateOptions as V, GepaCandidatePopulationArtifact as Vt, DefaultProductionGateOptions as W, GepaCandidateSelectionScore as Wt, RedTeamFinding as X, readExternalOptimizerObservationArtifact as Xt, RedTeamCategory as Y, ExternalOptimizerSubmittedCandidate as Yt, RedTeamPayload as Z, CampaignStorage as Zt, emitLoopProvenance as _, LlmJudgeDimension as _n, decodeExternalTextCandidate as _t, BuildLoopProvenanceArgs as a, campaignSplitDigestFromIdentities as an, CanaryKind as at, provenanceRecordPath as b, OptimizationMethod as bt, LoopProvenanceArgsFromResult as c, openAutoPr as cn, CanarySeverity as ct, LoopProvenanceEvidence as d, ReferenceEquivalenceJudgeInput as dn, externalTextOptimizationMethod as dt, inMemoryCampaignStorage as en, redTeamReport as et, LoopProvenanceOptimizationMethod as f, ReferenceEquivalenceJudgeOptions as fn, ExternalTextOptimizationMethodConfig as ft, canonicalDigest as g, runReferenceEquivalenceJudge as gn, ExternalTextEvaluationResponse as gt, campaignMeasurementDigest as h, createReferenceEquivalenceJudge as hn, ExternalOptimizationExample as ht, skillOptOptimizationMethod as i, campaignSplitDigest as in, CanaryEvaluation as it, runEval as j, compareOptimizationMethods as jt, runOptimization as k, OptimizationTokenUsage as kt, LoopProvenanceBackend as l, REFERENCE_EQUIVALENCE_INPUT_LIMITS as ln, runCanaries as lt, buildLoopProvenanceRecord as m, ReferenceEquivalenceScenario as mn, ExternalTextOptimizerResult as mt, SkillOptRunnerCommand as n, assertCampaignSplitIdentity as nn, toolNamesForRun as nt, EmitLoopProvenanceArgs as o, OpenAutoPrOptions as on, CanaryOptions as ot, LoopProvenanceRecord as p, ReferenceEquivalenceJudgeResult as pn, ExternalTextOptimizerContext as pt, DEFAULT_RED_TEAM_CORPUS as q, ExternalOptimizerObservationArtifact as qt, SkillOptTrainerConfig as r, campaignScenarioIdentity as rn, CanaryAlert as rt, EmitLoopProvenanceResult as s, OpenAutoPrResult as sn, CanaryReport as st, SkillOptOptimizationMethodConfig as t, assertCampaignDesign as tn, scoreRedTeamOutput as tt, LoopProvenanceCandidate as u, REFERENCE_EQUIVALENCE_JUDGE_VERSION as un, composeGate as ut, loopProvenanceArgsFromResult as v, LlmJudgeOptions as vn, CompareOptimizationMethodsOptions as vt, RunImprovementLoopResult as w, OptimizationMethodProvenance as wt, provenanceSpansPath as x, OptimizationMethodComparison as xt, loopProvenanceSpans as y, llmJudge as yn, ComparisonCost as yt, OpenAICompatibleOptimizerModel as z, planCampaignRun as zt };
-//# sourceMappingURL=skillopt-optimization-method-USDKhxSA.d.ts.map
+export { OptimizationTokenUsage as $, RedTeamCategory as A, llmJudge as At, CanaryReport as B, RunOptimizationOptions as C, fsCampaignStorage as Ct, runEval as D, openAutoPr as Dt, RunEvalOptions as E, OpenAutoPrResult as Et, scoreRedTeamOutput as F, OptimizationMethodComparison as G, CompareOptimizationMethodsOptions as H, CanaryAlert as I, OptimizationMethodProvenance as J, OptimizationMethodInput as K, CanaryEvaluation as L, RedTeamReport as M, redTeamDataset as N, DEFAULT_RED_TEAM_CORPUS as O, LlmJudgeDimension as Ot, redTeamReport as P, OptimizationPackageSource as Q, CanaryKind as R, PremeasuredOptimizationBaseline as S, createRunCostLedger as St, runOptimization as T, OpenAutoPrOptions as Tt, ComparisonCost as U, runCanaries as V, OptimizationMethod as W, OptimizationMethodRunOptions as X, OptimizationMethodResult as Y, OptimizationMethodScore as Z, provenanceSpansPath as _, ExternalOptimizerObservationArtifact as _t, LoopProvenanceBackend as a, RunCampaignOptions as at, RunImprovementLoopResult as b, readExternalOptimizerObservationArtifact as bt, LoopProvenanceOptimizationMethod as c, CampaignRunPlanCell as ct, campaignMeasurementDigest as d, GepaCandidatePopulationArtifact as dt, combineComparisonCosts as et, canonicalDigest as f, GepaCandidatePopulationCandidate as ft, provenanceRecordPath as g, ExternalOptimizerExecutionSummary as gt, loopProvenanceSpans as h, readGepaCandidatePopulationArtifact as ht, LoopProvenanceArgsFromResult as i, CampaignCellFailureReceipt as it, RedTeamFinding as j, RedTeamCase as k, LlmJudgeOptions as kt, LoopProvenanceRecord as l, PlanCampaignRunOptions as lt, loopProvenanceArgsFromResult as m, GepaCandidateSelectionScore as mt, EmitLoopProvenanceArgs as n, costFromLedgerSummary as nt, LoopProvenanceCandidate as o, runCampaign as ot, emitLoopProvenance as p, GepaCandidatePopulationSummary as pt, OptimizationMethodPairwise as q, EmitLoopProvenanceResult as r, optimizationTokenUsageFromSummary as rt, LoopProvenanceEvidence as s, CampaignRunPlan as st, BuildLoopProvenanceArgs as t, compareOptimizationMethods as tt, buildLoopProvenanceRecord as u, planCampaignRun as ut, verifyLoopProvenanceRecord as v, ExternalOptimizerObservationSummary as vt, RunOptimizationResult as w, inMemoryCampaignStorage as wt, runImprovementLoop as x, CampaignStorage as xt, RunImprovementLoopOptions as y, ExternalOptimizerSubmittedCandidate as yt, CanaryOptions as z };
+//# sourceMappingURL=provenance-CCdxgLDT.d.ts.map

package/dist/provenance-CCdxgLDT.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provenance-CCdxgLDT.d.ts","names":[],"sources":["../src/llm-judge.ts","../src/campaign/auto-pr.ts","../src/campaign/storage.ts","../src/campaign/external-optimizer-observations.ts","../src/campaign/gepa-candidate-population.ts","../src/campaign/cell-cache.ts","../src/campaign/plan-campaign-run.ts","../src/campaign/run-campaign.ts","../src/campaign/presets/compare-optimization-methods.ts","../src/canary.ts","../src/red-team.ts","../src/campaign/presets/run-eval.ts","../src/campaign/presets/run-optimization.ts","../src/campaign/presets/run-improvement-loop.ts","../src/campaign/provenance.ts"],"mappings":"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"}