@tangle-network/agent-eval 0.173.3 → 0.174.0

package/dist/external-optimizer-contracts-CQCpyrIL.d.ts

@@ -1,172 +0,0 @@
-import { b as CustomTokenPricing, g as CostReceiptInput } from "./cost-ledger-DbQdN3nO.js";
-import { h as ChatResponse, m as ChatRequest } from "./types-gvRsyJLh.js";
-//#region src/campaign/external-optimizer-contracts.d.ts
-interface ExternalOptimizerProcessLimits {
-  /** Maximum serialized input written for the child process. */
-  maxInputBytes: number;
-  /** Maximum JSON result read from the child process. */
-  maxResultBytes: number;
-  /** Maximum stdout or stderr characters retained for diagnostics. */
-  maxOutputChars: number;
-}
-declare const DEFAULT_EXTERNAL_OPTIMIZER_PROCESS_LIMITS: Readonly<ExternalOptimizerProcessLimits>;
-interface ExternalOptimizerCallbackLimits {
-  /** Maximum serialized request accepted by the loopback callback. */
-  maxRequestBytes: number;
-  /** Maximum serialized response returned by the loopback callback. */
-  maxResponseBytes: number;
-}
-declare const DEFAULT_EXTERNAL_OPTIMIZER_CALLBACK_LIMITS: Readonly<ExternalOptimizerCallbackLimits>;
-interface ExternalOptimizerRunnerCommand {
-  command?: string;
-  args?: readonly string[];
-  env?: NodeJS.ProcessEnv;
-  /** Child-process resource limits. Omitted fields use finite defaults. */
-  limits?: Partial<ExternalOptimizerProcessLimits>;
-}
-type ExternalOptimizerResumeMode = 'never' | 'if-compatible' | 'required';
-type ExternalTextCandidate = string | Record<string, string>;
-interface ExternalTextEvaluationRequest {
-  candidate: ExternalTextCandidate;
-  exampleId: string;
-}
-declare function resolveExternalOptimizerProcessLimits(value: Partial<ExternalOptimizerProcessLimits> | undefined, label?: string): ExternalOptimizerProcessLimits;
-declare function resolveExternalOptimizerCallbackLimits(value: Partial<ExternalOptimizerCallbackLimits> | undefined, label?: string): ExternalOptimizerCallbackLimits;
-type DeepReadonly<T> = T extends ((...args: never[]) => unknown) ? T : T extends readonly (infer U)[] ? readonly DeepReadonly<U>[] : T extends object ? { readonly [K in keyof T]: DeepReadonly<T[K]>; } : T;
-/** Provider-neutral request parsed once from the optimizer's loopback protocol. */
-type ExternalOptimizerChatRequest = DeepReadonly<Omit<ChatRequest, 'model'> & {
-  model: string;
-}>;
-type ExternalOptimizerEndpointFormat = 'chat-completions' | 'responses' | 'anthropic-messages';
-/** One exact model request admitted by the loopback proxy. */
-interface ExternalOptimizerModelCallRequest {
-  /** Stable identity allocated by the cost ledger for this paid call. */
-  readonly callId: string;
-  /** Deeply immutable canonical request; HTTP protocol fields never cross this boundary. */
-  readonly request: ExternalOptimizerChatRequest;
-  /** Child response shape, when the execution owner needs to retain it as evidence. */
-  readonly endpointFormat?: ExternalOptimizerEndpointFormat;
-  readonly signal: AbortSignal;
-}
-/** Runtime-owned result for one admitted optimizer-model call. */
-type ExternalOptimizerModelCallResult = {
-  readonly succeeded: true;
-  /** Canonical response encoded back into the child's protocol by Agent Eval. */
-  readonly response: ChatResponse;
-  /**
-   * Canonical measured usage/cost input retained by Agent Eval's cost ledger.
-   * `inputTokens` is the non-cached portion, `cachedTokens` is the cache-read
-   * portion, and response `promptTokens` equals their sum. Cache-write tokens
-   * remain a separately billed class and are never silently added to that total.
-   */
-  readonly receipt: CostReceiptInput;
-  /** Opaque, finite JSON proof of the exact execution retained in provenance. */
-  readonly execution: unknown;
-} | {
-  readonly succeeded: false;
-  /** Public failure text safe to retain and return to the child process. */
-  readonly error: string;
-  /** Usage/cost state for the failed Runtime call. Unknown values stay unknown. */
-  readonly receipt: CostReceiptInput;
-  /** Opaque, finite JSON proof of the failed exact execution. */
-  readonly execution: unknown;
-};
-/**
- * Execution-neutral model-call seam for an external optimizer.
- *
- * The package that owns execution implements this with its exact execution
- * path. For Discovery that owner is Runtime and the identity is an
- * AgentProfile. The loopback proxy owns request validation, limits, response
- * bounds, and cost-ledger recording. Once invoked, the callback must resolve
- * with one success/failure result. Rejecting loses the execution record and
- * therefore fails the optimizer attempt.
- */
-type ExternalOptimizerModelCall = (request: ExternalOptimizerModelCallRequest) => Promise<ExternalOptimizerModelCallResult>;
-/** One opaque Runtime execution record retained for one admitted model call. */
-type ExternalOptimizerModelExecutionObservation = {
-  readonly sequence: number;
-  readonly callId: string;
-  readonly callRef: string;
-  readonly path: '/v1/chat/completions' | '/v1/responses' | '/v1/messages';
-  readonly model: string;
-  readonly succeeded: true;
-  readonly responseStatus: number;
-  readonly execution: unknown;
-} | {
-  readonly sequence: number;
-  readonly callId: string;
-  readonly callRef: string;
-  readonly path: '/v1/chat/completions' | '/v1/responses' | '/v1/messages';
-  readonly model: string;
-  readonly succeeded: false;
-  readonly error: string;
-  readonly execution: unknown;
-};
-type ExternalOptimizerEvaluationRefusalReason = 'invalid-request' | 'evaluation-limit' | 'evaluation-failed';
-/**
- * Durable callback-side record of every candidate submitted for scoring,
- * scored task, and callback refusal. Optimizer-internal proposals that never
- * reach this callback are outside this record's scope.
- */
-type ExternalOptimizerEvaluationObservation = {
-  readonly kind: 'proposal';
-  readonly sequence: number;
-  readonly candidate: ExternalTextCandidate;
-  readonly candidateHash: string;
-} | {
-  readonly kind: 'evaluation';
-  readonly sequence: number;
-  readonly candidate: ExternalTextCandidate;
-  readonly candidateHash: string;
-  readonly exampleId: string;
-  /** One-based accepted evaluation number for this optimizer attempt. */
-  readonly evaluationNumber: number;
-  readonly response: unknown;
-} | {
-  readonly kind: 'refusal';
-  readonly sequence: number;
-  readonly reason: ExternalOptimizerEvaluationRefusalReason;
-  readonly candidate?: ExternalTextCandidate;
-  readonly candidateHash?: string;
-  readonly exampleId?: string;
-};
-interface ExternalOptimizerModelBudget {
-  /** Optional optimizer-model spend ceiling, independent of task-evaluation spend. */
-  maxCostUsd?: number;
-  /** Maximum calls into the execution owner; owner-internal retries are reported there. */
-  maxRequests: number;
-  /** Reject a request body above this byte count. */
-  maxRequestBytes: number;
-  /** Reject a provider response above this byte count. */
-  maxResponseBytes: number;
-  /** Reject a request asking the provider for more output tokens. */
-  maxOutputTokensPerRequest: number;
-  /**
-   * Reasoning tokens a single response may bill beyond its completion limit.
-   *
-   * A reasoning model bounds only the completion by `max_tokens` and bills
-   * thinking on top, so a reservation sized to the completion alone is always
-   * too small and the ledger refuses the real charge. Callers that route a
-   * reasoning model declare its thinking budget here; the reservation covers
-   * it and a response exceeding it still fails loudly. Default: 0.
-   */
-  maxReasoningTokensPerRequest?: number;
-  /**
-   * Optional rates used to estimate cost when the provider omits a valid
-   * `usage.cost`. Omit when billed USD is unknown; catalog estimates are not
-   * enforcement evidence.
-   */
-  pricing?: CustomTokenPricing;
-  /** Per-provider-request deadline. Default: 300,000 ms. */
-  requestTimeoutMs?: number;
-}
-/** Per-wire request accounting for the loopback proxy. */
-interface ExternalOptimizerWireCounts {
-  /** Execution-owner calls admitted on this wire, including failures. */
-  requestAttempts: number;
-  /** Successful 2xx responses recorded on this wire. */
-  successfulCompletions: number;
-}
-//#endregion
-export { ExternalTextCandidate as _, ExternalOptimizerEndpointFormat as a, resolveExternalOptimizerProcessLimits as b, ExternalOptimizerModelBudget as c, ExternalOptimizerModelCallResult as d, ExternalOptimizerModelExecutionObservation as f, ExternalOptimizerWireCounts as g, ExternalOptimizerRunnerCommand as h, ExternalOptimizerChatRequest as i, ExternalOptimizerModelCall as l, ExternalOptimizerResumeMode as m, DEFAULT_EXTERNAL_OPTIMIZER_PROCESS_LIMITS as n, ExternalOptimizerEvaluationObservation as o, ExternalOptimizerProcessLimits as p, ExternalOptimizerCallbackLimits as r, ExternalOptimizerEvaluationRefusalReason as s, DEFAULT_EXTERNAL_OPTIMIZER_CALLBACK_LIMITS as t, ExternalOptimizerModelCallRequest as u, ExternalTextEvaluationRequest as v, resolveExternalOptimizerCallbackLimits as y };
-//# sourceMappingURL=external-optimizer-contracts-CQCpyrIL.d.ts.map

package/dist/external-optimizer-contracts-CQCpyrIL.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"external-optimizer-contracts-CQCpyrIL.d.ts","names":[],"sources":["../src/campaign/external-optimizer-contracts.ts"],"mappings":";;;UAWiB;;EAEf;;EAEA;;EAEA;;cAGW,2CAA2C,SAAS;UAOhD;;EAEf;;EAEA;;cAGW,4CAA4C,SAAS;UAMjD;EACf;EACA;EACA,MAAM,OAAO;;EAEb,SAAS,QAAQ;;KAGP;KAEA,iCAAiC;UAE5B;EACf,WAAW;EACX;;iBAUc,sCACd,OAAO,QAAQ,6CACf,iBACC;iBAmBa,uCACd,OAAO,QAAQ,8CACf,iBACC;KAkBE,aAAa,KAAK,eAAc,6BACjC,IACA,0BAA0B,gBACf,aAAa,OACtB,+BACc,WAAW,IAAI,aAAa,EAAE,SAC1C;;KAGI,+BAA+B,aACzC,KAAK;EAA0B;;KAGrB;;UAMK;;WAEN;;WAEA,SAAS;;WAET,iBAAiB;WACjB,QAAQ;;;KAIP;WAEG;;WAEA,UAAU;;;;;;;WAOV,SAPU;;WASV;;WAGA;;WAEA;;WAEA,SATkC;;WAWlC;;;;;;;;;;;;KAaH,8BACV,SAAS,sCACN,QAAQ;;KAGD;WAEG;WACA;WACA;WACA;WACA;WACA;WACA;WACA;;WAGA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;;KAGH;;;;;;KAUA;WAEG;WACA;WACA,WAAW;WACX;;WAGA;WACA;WACA,WAAW;WACX;WACA;;WAEA;WACA;;WAGA;WACA;WACA,QAAQ;WACR,YAAY;WACZ;WACA;;UAGE;;EAEf;;EAEA;;EAEA;;EAEA;;EAEA;;;;;;;;;;EAUA;;;;;;EAMA,UAAU;;EAEV;;;UAIe;;EAEf;;EAEA"}

package/dist/heldout-gate-Df5hsqmm.d.ts

@@ -1,453 +0,0 @@
-import { c as CostLedgerHandle } from "./cost-ledger-DbQdN3nO.js";
-import { a as RunRecord } from "./run-record-DTv1MdjK.js";
-import { it as ServedModelPolicy, p as ChatClient, w as LlmCallMetadata } from "./types-gvRsyJLh.js";
-import { R as Scenario, S as JudgeConfig, i as CampaignCostMeter, j as MutableSurface, o as CampaignScenarioIdentity, p as Gate } from "./types-Ba5UQyVD.js";
-import { A as CanaryOptions, F as OptimizationMethod, U as OptimizationPackageSource, b as RedTeamCase, bt as SearchRunIdentity } from "./provenance-CRY67X50.js";
-import { _ as ExternalTextCandidate, c as ExternalOptimizerModelBudget, h as ExternalOptimizerRunnerCommand, l as ExternalOptimizerModelCall, m as ExternalOptimizerResumeMode, r as ExternalOptimizerCallbackLimits, v as ExternalTextEvaluationRequest } from "./external-optimizer-contracts-CQCpyrIL.js";
-import { t as DetectRewardHackingInput } from "./reward-hacking-ZXEi9VCq.js";
-//#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/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/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;
-    /** The optimizer score is a finite protocol value; Eval remains the
-     * authority for whether the underlying cell actually produced a score. */
-    status?: 'scored' | 'failed';
-    error?: {
-      stage: 'dispatch' | 'judge' | 'unknown';
-      message: string;
-    };
-  };
-}
-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/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;
-  /**
-   * Served-model acceptance for every proxied call. Default `'exact'`, which
-   * rejects any substitution with a 502 to the child.
-   * `'allow-within-family'` accepts a different model of the same provider
-   * family; it keeps family-level claims valid and forfeits per-model claims.
-   */
-  servedModelPolicy?: ServedModelPolicy;
-  /**
-   * Also expose this metered model over the Anthropic Messages API
-   * (`POST /v1/messages`) on the loopback proxy. Required for GEPA agent
-   * engines that drive a `claude` CLI subprocess. Agent engines are chatty:
-   * size `budget.maxRequests` for tens of calls per engine run. Default: false.
-   */
-  anthropicEndpoint?: boolean;
-}
-//#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;
-  /**
-   * Record GEPA's own candidate population into the canonical `SearchLedger`
-   * and return the bounded receipt on the method result, so a comparison run
-   * under `searchHistoryPolicy: 'require-complete'` accepts this method.
-   *
-   * `identity` declares the immutable revisions and the model snapshot the
-   * ledger requires and the bridge does not report. `path` defaults to
-   * `<runDir>/search-ledger.jsonl`.
-   */
-  searchLedger?: {
-    identity: SearchRunIdentity;
-    path?: string;
-  };
-}
-declare function gepaOptimizationMethod<TScenario extends Scenario, TArtifact>(config: GepaOptimizationMethodConfig<TScenario, TArtifact>): OptimizationMethod<TScenario, TArtifact>;
-//#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
-//#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/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
-export { ReferenceEquivalenceJudgeInput as A, campaignSplitDigestFromIdentities as B, ExternalTextOptimizerContext as C, decodeExternalTextCandidate as D, ExternalTextEvaluationResponse as E, runReferenceEquivalenceJudge as F, assertCampaignDesign as I, assertCampaignSplitIdentity as L, ReferenceEquivalenceJudgeResult as M, ReferenceEquivalenceScenario as N, REFERENCE_EQUIVALENCE_INPUT_LIMITS as O, createReferenceEquivalenceJudge as P, campaignScenarioIdentity as R, ExternalTextOptimizationMethodConfig as S, ExternalOptimizationExample as T, GepaRunnerCommand as _, DefaultProductionRewardHackingOptions as a, OptimizerModelBudget as b, SkillOptOptimizationMethodConfig as c, skillOptOptimizationMethod as d, GepaAdaptiveEngineRun as f, GepaOptimizationRecipe as g, GepaOptimizationMethodConfig as h, DefaultProductionGateOptions as i, ReferenceEquivalenceJudgeOptions as j, REFERENCE_EQUIVALENCE_JUDGE_VERSION as k, SkillOptRunnerCommand as l, GepaEngineRun as m, heldOutGate as n, defaultProductionGate as o, GepaEngineOptions as p, DefaultProductionGateCheck as r, composeGate as s, HeldOutGateOptions as t, SkillOptTrainerConfig as u, gepaOptimizationMethod as v, ExternalTextOptimizerResult as w, externalTextOptimizationMethod as x, OpenAICompatibleOptimizerModel as y, campaignSplitDigest as z };
-//# sourceMappingURL=heldout-gate-Df5hsqmm.d.ts.map

package/dist/heldout-gate-Df5hsqmm.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"heldout-gate-Df5hsqmm.d.ts","names":[],"sources":["../src/campaign/coverage.ts","../src/reference-equivalence-judge.ts","../src/campaign/external-text-evaluation.ts","../src/campaign/external-text-optimization-contract.ts","../src/campaign/external-text-optimization.ts","../src/campaign/optimizer-model.ts","../src/campaign/gepa-optimization-method.ts","../src/campaign/skillopt-optimization-method.ts","../src/campaign/gates/compose.ts","../src/campaign/gates/default-production-gate.ts","../src/campaign/gates/heldout-gate.ts"],"mappings":"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"}

package/dist/index-BQqOjerE.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index-BQqOjerE.d.ts","names":[],"sources":["../src/contract/measured-comparison.ts","../src/contract/profile-measured-comparison.ts","../src/contract/intake/run-record-dir.ts","../src/contract/eval-reporting-suite.ts","../src/contract/diff.ts","../src/contract/intake/agent-trace.ts","../src/contract/intake/code-agent-observation.ts","../src/contract/intake/code-agent-session.ts","../src/contract/intake/code-agent-store.ts","../src/contract/intake/feedback-table.ts","../src/contract/intake/otel-spans.ts"],"mappings":"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"}