@tangle-network/agent-eval 0.150.1 → 0.161.0

package/dist/trajectory-replay/index.d.ts

@@ -1,8 +1,8 @@
 import { t as DefaultVerdict } from "../verdict-E4eRNf7-.js";
-import { s as TraceStore } from "../store-CT9YIIve.js";
-import { i as TraceEmitter } from "../emitter-DGQGoLyj.js";
-import { i as CounterfactualRunner, t as CounterfactualContext } from "../counterfactual--bpysZF0.js";
-import { _ as isSubmitAction, a as RecordedObservationKind, b as parseRecordedReturncode, c as SUBMIT_ACTION_SIGNATURE, d as classifyObservation, f as decodeRecordedTurns, g as isRecordedTimeout, h as isElidedField, i as RecordedFinalOutcome, l as TIMEOUT_OBSERVATION_MARKER, m as finalRecordedOutcome, n as FORMAT_ERROR_OBSERVATION_PREFIX, o as RecordedTrajectoryStep, p as deriveFailureSignature, r as RECORDED_ELISION_PATTERN, s as RecordedTrajectoryTurn, t as DecodedTrajectory, u as assertReplayableTrajectory, v as isSubmitOnlyAction, x as unreadableExitCount, y as parseObservationOutput } from "../steps-AmkT-GIM.js";
+import { s as TraceStore } from "../store-B06JdC56.js";
+import { i as TraceEmitter } from "../emitter-D_jYSGRd.js";
+import { i as CounterfactualRunner, t as CounterfactualContext } from "../counterfactual-BaFUWK3H.js";
+import { _ as isSubmitOnlyAction, a as RecordedTrajectoryStep, b as unreadableExitCount, c as TIMEOUT_OBSERVATION_MARKER, d as decodeRecordedTurns, f as deriveFailureSignature, g as isSubmitAction, h as isRecordedTimeout, i as RecordedObservationKind, l as assertReplayableTrajectory, m as isElidedField, n as FORMAT_ERROR_OBSERVATION_PREFIX, o as RecordedTrajectoryTurn, p as finalRecordedOutcome, r as RecordedFinalOutcome, s as SUBMIT_ACTION_SIGNATURE, t as DecodedTrajectory, u as classifyObservation, v as parseObservationOutput, y as parseRecordedReturncode } from "../steps-CiNVJry_.js";
 //#region src/trajectory-replay/corpus.d.ts
 interface CorpusSpec {
   readonly name: string;
@@ -790,5 +790,5 @@ interface ReplayFindingResult {
  */
 declare function replayVerifyFinding(finding: AnalystReplayFinding, options: ReplayFindingOptions): Promise<ReplayFindingResult>;
 //#endregion
-export { type AnalystReplayFinding, type ArmExecutionResult, type CaseResources, type ChatCompletionCaller, type ChatOutcome, type ChatUsage, type CorpusSpec, type CwdSource, type DecodedTrajectory, type DockerImagePreparerOptions, type EnumerationResult, type ExcludedCase, FORMAT_ERROR_OBSERVATION_PREFIX, type FailedFixAttempt, type FindingReplaySource, type FindingReplayability, type FindingVerification, type FindingVerificationStatus, type FixArmExecution, type FixArmExecutor, type FixGenerationOutcome, type FixLoopAttemptRecord, type FixLoopOptions, type FixLoopResult, type FixPromptInput, type ImagePreparation, type ImagePreparer, type IncorrectStepsSubject, type IngestedTrajectory, PREFIX_DIVERGENCE_TOLERANCE_PCT, type PrefixDivergence, type PrefixDivergenceKind, type PrefixReplayResult, RECORDED_ELISION_PATTERN, type RecordedFinalOutcome, type RecordedObservationKind, type RecordedTrajectoryStep, type RecordedTrajectoryTurn, type ReplayArmVerdict, type ReplayBatchCaseRow, type ReplayBatchFixResult, type ReplayBatchOptions, type ReplayBatchReport, type ReplayExclusionReason, type ReplayExecBackend, type ReplayExecBackendFactory, type ReplayExecResult, type ReplayExecSession, type ReplayFindingOptions, type ReplayFindingResult, type ReplayVerdict, type ReplayVerifyOptions, type ReplayableCase, type ResolvedFindingReplay, type ResolvedReplayInvocation, type ResourceResolution, SUBMIT_ACTION_SIGNATURE, SandboxCounterfactualRunner, type SandboxCounterfactualRunnerOptions, TIMEOUT_OBSERVATION_MARKER, type VerifiableFinding, type VerifyFindingsOptions, type VerifyFindingsRun, assertReplayableTrajectory, buildFixPrompt, buildRetryFixPrompt, classifyObservation, classifyPrefixStep, classifyVerdict, clipText, countScriptCommands, decodeRecordedTurns, deriveFailureSignature, derivedImageTag, dockerImagePreparer, enumerateReplayableCases, extractFixCommand, finalRecordedOutcome, findingReplayStep, findingTrajectoryId, generateFixCommand, goldIncorrectSteps, ingestRecordedTrajectory, isElidedField, isRecordedTimeout, isSubmitAction, isSubmitOnlyAction, parseCorpusFlag, parseIncorrectStepsSubject, parseObservationOutput, parseRecordedReturncode, readFindingsFile, readLabelEntries, renderBatchReport, renderVerifiedFindingsSection, replayVerify, replayVerifyFinding, resolveCaseResources, resolveFindingInvocation, resolveFindingReplayability, runFixLoop, runReplayBatch, seededSample, summarizePrefixReplay, unreadableExitCount, verifyFindings, wrapActionForExec };
+export { type AnalystReplayFinding, type ArmExecutionResult, type CaseResources, type ChatCompletionCaller, type ChatOutcome, type ChatUsage, type CorpusSpec, type CwdSource, type DecodedTrajectory, type DockerImagePreparerOptions, type EnumerationResult, type ExcludedCase, FORMAT_ERROR_OBSERVATION_PREFIX, type FailedFixAttempt, type FindingReplaySource, type FindingReplayability, type FindingVerification, type FindingVerificationStatus, type FixArmExecution, type FixArmExecutor, type FixGenerationOutcome, type FixLoopAttemptRecord, type FixLoopOptions, type FixLoopResult, type FixPromptInput, type ImagePreparation, type ImagePreparer, type IncorrectStepsSubject, type IngestedTrajectory, PREFIX_DIVERGENCE_TOLERANCE_PCT, type PrefixDivergence, type PrefixDivergenceKind, type PrefixReplayResult, type RecordedFinalOutcome, type RecordedObservationKind, type RecordedTrajectoryStep, type RecordedTrajectoryTurn, type ReplayArmVerdict, type ReplayBatchCaseRow, type ReplayBatchFixResult, type ReplayBatchOptions, type ReplayBatchReport, type ReplayExclusionReason, type ReplayExecBackend, type ReplayExecBackendFactory, type ReplayExecResult, type ReplayExecSession, type ReplayFindingOptions, type ReplayFindingResult, type ReplayVerdict, type ReplayVerifyOptions, type ReplayableCase, type ResolvedFindingReplay, type ResolvedReplayInvocation, type ResourceResolution, SUBMIT_ACTION_SIGNATURE, SandboxCounterfactualRunner, type SandboxCounterfactualRunnerOptions, TIMEOUT_OBSERVATION_MARKER, type VerifiableFinding, type VerifyFindingsOptions, type VerifyFindingsRun, assertReplayableTrajectory, buildFixPrompt, buildRetryFixPrompt, classifyObservation, classifyPrefixStep, classifyVerdict, clipText, countScriptCommands, decodeRecordedTurns, deriveFailureSignature, derivedImageTag, dockerImagePreparer, enumerateReplayableCases, extractFixCommand, finalRecordedOutcome, findingReplayStep, findingTrajectoryId, generateFixCommand, goldIncorrectSteps, ingestRecordedTrajectory, isElidedField, isRecordedTimeout, isSubmitAction, isSubmitOnlyAction, parseCorpusFlag, parseIncorrectStepsSubject, parseObservationOutput, parseRecordedReturncode, readFindingsFile, readLabelEntries, renderBatchReport, renderVerifiedFindingsSection, replayVerify, replayVerifyFinding, resolveCaseResources, resolveFindingInvocation, resolveFindingReplayability, runFixLoop, runReplayBatch, seededSample, summarizePrefixReplay, unreadableExitCount, verifyFindings, wrapActionForExec };
 //# sourceMappingURL=index.d.ts.map

package/dist/trajectory-replay/index.js

@@ -1,9 +1,9 @@
-import { t as certificationEvidenceDigest } from "../verdict-BndeTAh_.js";
-import { t as TraceEmitter } from "../emitter-CPBAhxum.js";
-import { t as runCounterfactual } from "../counterfactual-lDfCx0Uz.js";
+import { t as certificationEvidenceDigest } from "../verdict-B0xltqu6.js";
+import { t as TraceEmitter } from "../emitter-BpYFQPj4.js";
+import { t as runCounterfactual } from "../counterfactual-D_VWavVm.js";
 import { n as InMemoryTraceStore } from "../store-DNe_Uv1Q.js";
 import { t as packageVersion } from "../package-version-D7lQHt_-.js";
-import { _ as unreadableExitCount, a as TIMEOUT_OBSERVATION_MARKER, c as decodeRecordedTurns, d as isElidedField, f as isRecordedTimeout, g as parseRecordedReturncode, h as parseObservationOutput, i as SUBMIT_ACTION_SIGNATURE, l as deriveFailureSignature, m as isSubmitOnlyAction, n as FORMAT_ERROR_OBSERVATION_PREFIX, o as assertReplayableTrajectory, p as isSubmitAction, r as RECORDED_ELISION_PATTERN, s as classifyObservation, t as wrapActionForExec, u as finalRecordedOutcome } from "../exec-y-DCLqK7.js";
+import { a as assertReplayableTrajectory, c as deriveFailureSignature, d as isRecordedTimeout, f as isSubmitAction, g as unreadableExitCount, h as parseRecordedReturncode, i as TIMEOUT_OBSERVATION_MARKER, l as finalRecordedOutcome, m as parseObservationOutput, n as FORMAT_ERROR_OBSERVATION_PREFIX, o as classifyObservation, p as isSubmitOnlyAction, r as SUBMIT_ACTION_SIGNATURE, s as decodeRecordedTurns, t as wrapActionForExec, u as isElidedField } from "../exec-D9WpA2p-.js";
 import { createHash } from "node:crypto";
 import { appendFileSync, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
@@ -2145,6 +2145,6 @@ function readFindingsFile(path) {
 	return array;
 }
 //#endregion
-export { FORMAT_ERROR_OBSERVATION_PREFIX, PREFIX_DIVERGENCE_TOLERANCE_PCT, RECORDED_ELISION_PATTERN, SUBMIT_ACTION_SIGNATURE, SandboxCounterfactualRunner, TIMEOUT_OBSERVATION_MARKER, assertReplayableTrajectory, buildFixPrompt, buildRetryFixPrompt, classifyObservation, classifyPrefixStep, classifyVerdict, clipText, countScriptCommands, decodeRecordedTurns, deriveFailureSignature, derivedImageTag, dockerImagePreparer, enumerateReplayableCases, extractFixCommand, finalRecordedOutcome, findingReplayStep, findingTrajectoryId, generateFixCommand, goldIncorrectSteps, ingestRecordedTrajectory, isElidedField, isRecordedTimeout, isSubmitAction, isSubmitOnlyAction, parseCorpusFlag, parseIncorrectStepsSubject, parseObservationOutput, parseRecordedReturncode, readFindingsFile, readLabelEntries, renderBatchReport, renderVerifiedFindingsSection, replayVerify, replayVerifyFinding, resolveCaseResources, resolveFindingInvocation, resolveFindingReplayability, runFixLoop, runReplayBatch, seededSample, summarizePrefixReplay, unreadableExitCount, verifyFindings, wrapActionForExec };
+export { FORMAT_ERROR_OBSERVATION_PREFIX, PREFIX_DIVERGENCE_TOLERANCE_PCT, SUBMIT_ACTION_SIGNATURE, SandboxCounterfactualRunner, TIMEOUT_OBSERVATION_MARKER, assertReplayableTrajectory, buildFixPrompt, buildRetryFixPrompt, classifyObservation, classifyPrefixStep, classifyVerdict, clipText, countScriptCommands, decodeRecordedTurns, deriveFailureSignature, derivedImageTag, dockerImagePreparer, enumerateReplayableCases, extractFixCommand, finalRecordedOutcome, findingReplayStep, findingTrajectoryId, generateFixCommand, goldIncorrectSteps, ingestRecordedTrajectory, isElidedField, isRecordedTimeout, isSubmitAction, isSubmitOnlyAction, parseCorpusFlag, parseIncorrectStepsSubject, parseObservationOutput, parseRecordedReturncode, readFindingsFile, readLabelEntries, renderBatchReport, renderVerifiedFindingsSection, replayVerify, replayVerifyFinding, resolveCaseResources, resolveFindingInvocation, resolveFindingReplayability, runFixLoop, runReplayBatch, seededSample, summarizePrefixReplay, unreadableExitCount, verifyFindings, wrapActionForExec };
 
 //# sourceMappingURL=index.js.map

package/dist/{provenance-oA4-zUqm.d.ts → transient-failure-DKF5Mofa.d.ts}

@@ -1,13 +1,169 @@
+import { t as AgentEvalError } from "./errors-DEE6u6ot.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-DVV82Gwh.js";
-import { p as ChatClient } from "./types-jUBXJ7Iz.js";
-import { _ as ProposalFinding } from "./types-B2NsbrNy.js";
-import { _ as ExternalTextCandidate, g as ExternalOptimizerWireCounts, o as ExternalOptimizerEvaluationObservation } from "./external-optimizer-contracts-DbLsm4Po.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-DdFNuyxQ.js";
-import { r as DatasetScenario, t as Dataset } from "./dataset-CJjKqQfA.js";
-import { D as LedgerHash, m as LedgerTrustedHeadRemoval, p as LedgerTrustedHead } from "./index-B8Ui1mr1.js";
-import { g as TraceSpanEvent, t as HostedClient } from "./client-kPQYT_56.js";
+import { a as RunRecord } from "./run-record-VVy4T9OW.js";
+import { p as ChatClient } from "./types-Bfk0uxRj.js";
+import { _ as ProposalFinding } from "./types-D9ssmxKL.js";
+import { _ as ExternalTextCandidate, g as ExternalOptimizerWireCounts, o as ExternalOptimizerEvaluationObservation } from "./external-optimizer-contracts-szBJ_1vh.js";
+import { B as ScoredSurfaceOutcome, 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-D4s7Z6nq.js";
+import { r as DatasetScenario, t as Dataset } from "./dataset-DQqhOCPt.js";
+import { D as LedgerHash, m as LedgerTrustedHeadRemoval, p as LedgerTrustedHead } from "./index-lfaSeKSD.js";
+import { g as TraceSpanEvent, t as HostedClient } from "./client-L9VVPkim.js";
 import { z } from "zod";
+//#region src/judge-families.d.ts
+/**
+ * Judge model-family classification + cross-family enforcement.
+ *
+ * A judge ensemble built entirely from one provider family shares that
+ * family's blind spots and self-preference — its "agreement" is correlated
+ * bias, not independent signal. `assertCrossFamily` makes the consumer prove
+ * the ensemble spans ≥2 families; `judgeFamily` is the single regex map that
+ * replaces the per-consumer copies (tax/legal/creative/gtm each ship one).
+ */
+/** Provider family a model belongs to. `unknown` when no rule matches. */
+type JudgeFamily = 'anthropic' | 'openai' | 'google' | 'meta' | 'mistral' | 'deepseek' | 'xai' | 'qwen' | 'cohere' | 'amazon' | 'moonshot' | 'zhipu' | 'unknown';
+/**
+ * Classify a model id into its provider family. Strips a `@snapshot` suffix
+ * and prefers an explicit `provider/...` prefix; otherwise matches the model
+ * name. Returns `unknown` when nothing matches (callers decide whether that's
+ * acceptable — `assertCrossFamily` counts it as its own family).
+ */
+declare function judgeFamily(modelId: string): JudgeFamily;
+interface AssertCrossFamilyOptions {
+  /** Minimum number of distinct families the ensemble must span. Default 2. */
+  minFamilies?: number;
+  /** When false (default), `unknown`-family models do NOT count toward the
+   *  family total — an ensemble of all-unclassifiable models is not provably
+   *  cross-family. Set true to count `unknown` as one shared family. */
+  allowUnknown?: boolean;
+}
+declare class CrossFamilyError extends Error {
+  readonly families: JudgeFamily[];
+  readonly models: string[];
+  constructor(message: string, families: JudgeFamily[], models: string[]);
+}
+/**
+ * Throw unless the judge models span at least `minFamilies` distinct provider
+ * families. Pass the model ids backing your judge ensemble. Fail-loud by
+ * design — a correlated single-family ensemble silently inflates agreement.
+ *
+ * Scope: this reads the ids you REQUEST. It proves the panel was configured
+ * across families; it cannot prove the panel RAN across families, because a
+ * routing gateway may answer several different ids from one provider. Where
+ * the diversity claim is load-bearing (a published leaderboard, a
+ * certification, a non-self-judging exclusion), assert on the ids the
+ * provider echoed instead: `assertCrossFamilyServed` in
+ * ./integrity/served-model.
+ */
+declare function assertCrossFamily(models: string[], opts?: AssertCrossFamilyOptions): JudgeFamily[];
+//#endregion
+//#region src/integrity/served-model.d.ts
+/** How a served id relates to the id that was requested. */
+type ServedModelVerdict =
+/** Byte-identical after normalisation — the requested model answered. */
+'exact' |
+/** Same model, different spelling (provider prefix, snapshot, tier suffix). */
+'alias' |
+/** A different model of the SAME provider family answered. */
+'substituted-within-family' |
+/** A different provider's model answered. */
+'substituted-cross-family' |
+/** The response carried no model id — identity is unproven either way. */
+'unreported';
+interface ServedModelCheck {
+  /** The id the caller asked for. */
+  requested: string;
+  /** The id echoed on the response; `null` when the response omitted it. */
+  served: string | null;
+  requestedFamily: JudgeFamily;
+  /** `null` when `served` is null. */
+  servedFamily: JudgeFamily | null;
+  verdict: ServedModelVerdict;
+  /** True for every verdict except `exact` and `alias`. */
+  substituted: boolean;
+}
+/**
+ * Classify one requested/served pair. Pure — no I/O — so it is safe inside
+ * response handlers, reducers, and CI gates.
+ *
+ * `served` is the id echoed by the provider (OpenAI-compatible bodies put it
+ * at `model`). `null`/`undefined` means the body omitted it; that is
+ * `unreported`, NOT a pass — a provider that does not name what answered has
+ * not proven identity, and a transport that drops the field must not read as
+ * agreement.
+ */
+declare function checkServedModel(requested: string, served: string | null | undefined): ServedModelCheck;
+declare class ModelSubstitutionError extends AgentEvalError {
+  readonly checks: ReadonlyArray<ServedModelCheck>;
+  constructor(message: string, checks: ReadonlyArray<ServedModelCheck>);
+}
+/**
+ * Consumer-facing name for the substitution policy a metered surface applies.
+ * `'exact'` rejects every substitution. `'allow-within-family'` accepts a
+ * different model of the same provider family; it keeps family-level claims
+ * valid and forfeits per-model claims. Maps to
+ * `AssertServedModelOptions.allowWithinFamily`.
+ */
+type ServedModelPolicy = 'exact' | 'allow-within-family';
+interface AssertServedModelOptions {
+  /**
+   * Accept a different model of the same provider family (e.g. requested
+   * `deepseek-v3.2`, served `deepseek-v4-flash`). Default false. Setting this
+   * keeps family-level claims valid and forfeits per-model claims.
+   */
+  allowWithinFamily?: boolean;
+  /**
+   * Accept a response that carried no model id. Default false — an
+   * unidentified response cannot support a per-model or per-family claim.
+   */
+  allowUnreported?: boolean;
+  /** Prefixed to the thrown message, e.g. the judge or campaign cell name. */
+  context?: string;
+}
+/**
+ * The one place the accept/reject policy lives, so a caller that reports
+ * substitution (a preflight table, a run record) and a caller that throws on it
+ * can never drift apart. A cross-family substitution is never acceptable.
+ */
+declare function servedModelAcceptable(check: ServedModelCheck, opts?: AssertServedModelOptions): boolean;
+/**
+ * Throw `ModelSubstitutionError` unless the served id is the requested model.
+ * Returns the check on success so callers can record the served id alongside
+ * the result.
+ */
+declare function assertServedModel(requested: string, served: string | null | undefined, opts?: AssertServedModelOptions): ServedModelCheck;
+/**
+ * Batch form: check every pair and throw naming EVERY substitution, so one
+ * failure does not hide the rest. Returns all checks on success.
+ */
+declare function assertServedModels(pairs: ReadonlyArray<{
+  requested: string;
+  served: string | null | undefined;
+}>, opts?: AssertServedModelOptions): ServedModelCheck[];
+interface AssertCrossFamilyServedOptions extends AssertServedModelOptions {
+  /** Minimum distinct SERVED families required. Default 2. */
+  minFamilies?: number;
+  /** Count `unknown`-family served ids toward the total. Default false. */
+  allowUnknown?: boolean;
+}
+declare class ServedCrossFamilyError extends AgentEvalError {
+  readonly families: JudgeFamily[];
+  readonly checks: ReadonlyArray<ServedModelCheck>;
+  constructor(message: string, families: JudgeFamily[], checks: ReadonlyArray<ServedModelCheck>);
+}
+/**
+ * Family-diversity rule over the models that actually ANSWERED.
+ *
+ * `assertCrossFamily` (../judge-families) reads the requested ids and so
+ * cannot see a gateway that answers three "different" requests from one
+ * provider. This one asserts no substitution first, then counts families from
+ * the served ids — a panel that collapsed to one family under the hood fails
+ * here even though its request list looked diverse.
+ */
+declare function assertCrossFamilyServed(pairs: ReadonlyArray<{
+  requested: string;
+  served: string | null | undefined;
+}>, opts?: AssertCrossFamilyServedOptions): JudgeFamily[];
+//#endregion
 //#region src/llm-judge.d.ts
 /** A rubric dimension as a bare key or the full `{ key, description }` shape. A
  *  bare string uses the key as its own description. */
@@ -29,6 +185,27 @@ interface LlmJudgeOptions<TArtifact, TScenario extends Scenario = Scenario> {
   /** Composite weights forwarded to `weightedComposite`: a partial map selects
    *  AND weights exactly the named dimensions. Omit for a uniform mean. */
   weights?: Record<string, number>;
+  /**
+   * How to read a score out of the model's answer.
+   *
+   * `'sampled'` (default) reads the number the model emitted. Discrete grades
+   * tie often, and a tie carries no ranking signal.
+   *
+   * `'expectation'` asks the provider for the log probabilities of the score
+   * token and returns the expected value over the integer grades the model
+   * considered, so two answers that both sample `8` separate by how much mass
+   * sat on `7` and `9`. It requires `scale: 'ten'`: an integer grade is one
+   * token, and a `unit` float is not. `whenUnavailable` decides what happens
+   * when the provider returns no log probabilities, or the grade did not land
+   * in one token: `'fail'` throws, `'sampled'` reads the emitted number and
+   * records `scoringMethod: 'sampled'` on the score.
+   */
+  scoring?: {
+    method: 'sampled';
+  } | {
+    method: 'expectation';
+    whenUnavailable: 'fail' | 'sampled';
+  };
   /** Scale the model is prompted to score on, normalized into `[0,1]`:
    *   - `'unit'`  (default): the model returns `[0,1]` directly.
    *   - `'ten'`:  the model returns `[0,10]`; divided by 10 here.
@@ -257,8 +434,18 @@ interface RunCampaignOptions<TScenario extends Scenario, TArtifact> {
    * rejects with the exact error thrown by that dispatch or judge.
    * Default false preserves the normal behavior of returning failed cells and
    * continuing the remaining schedule.
+   * With `cellRetry`, a retryable failure is not an error yet: this abort
+   * fires only when a cell's final attempt fails.
    */
   abortOnCellError?: boolean;
+  /**
+   * Opt-in bounded in-run retry of a failed cell. Absent by default: a failed
+   * cell is final on its first attempt. A retried attempt re-runs the SAME
+   * slot — same `cellId`, same `seed`, same cost tags — so the schedule,
+   * manifest, and pairing are unchanged. An attempt that failed because the
+   * campaign was cancelled is never retried.
+   */
+  cellRetry?: CampaignCellRetryPolicy;
   /**
    * Per-cell dispatch deadline in ms. A `dispatch` that neither resolves nor
    * rejects within this window is a hang (a stalled model request, an
@@ -343,6 +530,25 @@ interface CampaignCellFailureReceipt<TArtifact = unknown> {
   cell: CampaignCellResult<TArtifact>;
   cost: CostLedgerSummary;
 }
+/**
+ * Bounded in-run retry of failed cells. Every attempt dispatches the same
+ * slot and charges the shared cost ledger, so the final cell's `costUsd`,
+ * `tokenUsage`, and `costCallIds` cover all attempts. Each retried attempt
+ * keeps its failure receipt at `<cell>/failure-receipt.attempt-<n>.json`; a
+ * final failed attempt keeps the usual `<cell>/failure-receipt.json`. The
+ * final cell records the retry count as `retryAttempts`. Artifacts and trace
+ * spans written by a later attempt replace those of the retried attempt; the
+ * per-attempt failure receipts are the durable evidence.
+ */
+interface CampaignCellRetryPolicy {
+  /** Total attempts per cell, including the first. A positive safe integer. */
+  attempts: number;
+  /** Decides whether a failed attempt is dispatched again. Receives the
+   *  receipt's `failure` record. `transientDispatchFailure()` is the
+   *  ready-made predicate for infrastructure hiccups (502/503/504, dropped
+   *  streams, admission rejections). */
+  retryable: (failure: CampaignCellFailureReceipt['failure']) => boolean;
+}
 /**
  * Core campaign orchestrator: fan scenarios through dispatch, score with judges, aggregate bootstrap CIs, and persist reproducible `CampaignResult` records.
  */
@@ -599,6 +805,17 @@ interface SearchPlannedEvent extends SearchLedgerEventBase {
   kind: 'search-planned';
   plan: SearchPlan;
 }
+/** Additional candidate slots and operations for a search whose length is not
+ * known when it starts. The plan stays the first event and the planned task
+ * denominator stays frozen: extending tasks would retroactively reopen
+ * candidates that already closed theirs. */
+interface SearchPlanExtendedEvent extends SearchLedgerEventBase {
+  kind: 'search-plan-extended';
+  extension: {
+    candidateSlots: SearchCandidateSlot[];
+    operations: SearchPlannedOperation[];
+  };
+}
 interface SearchCandidateRegisteredEvent extends SearchLedgerEventBase {
   kind: 'candidate-registered';
   slotId: string;
@@ -674,7 +891,7 @@ interface SearchCompletedEvent extends SearchLedgerEventBase {
     reason: SearchFailureReason;
   };
 }
-type SearchLedgerEvent = SearchPlannedEvent | SearchCandidateRegisteredEvent | SearchCandidateSlotClosedEvent | SearchTaskAttemptedEvent | SearchOperationRecordedEvent | SearchCandidateDecidedEvent | SearchCompletedEvent;
+type SearchLedgerEvent = SearchPlannedEvent | SearchPlanExtendedEvent | SearchCandidateRegisteredEvent | SearchCandidateSlotClosedEvent | SearchTaskAttemptedEvent | SearchOperationRecordedEvent | SearchCandidateDecidedEvent | SearchCompletedEvent;
 interface SearchLedgerEntry {
   schema: typeof SEARCH_LEDGER_SCHEMA;
   campaignId: string;
@@ -736,6 +953,9 @@ interface SearchLedgerAudit {
 interface SearchLedgerReplay {
   entries: SearchLedgerEntry[];
   plan: SearchPlannedEvent | null;
+  /** Appended plan extensions, in ledger order. The effective plan is the
+   *  first plan event merged with these; `audit.expected` counts the merge. */
+  planExtensions: SearchPlanExtendedEvent[];
   candidates: SearchCandidateRegisteredEvent[];
   closedCandidateSlots: SearchCandidateSlotClosedEvent[];
   attempts: SearchTaskAttemptedEvent[];
@@ -1251,6 +1471,183 @@ declare function scoreRedTeamOutput(output: string, toolCalls: string[], rtCase:
 /** Aggregate red-team findings into per-category pass rates. */
 declare function redTeamReport(findings: RedTeamFinding[]): RedTeamReport;
 //#endregion
+//#region src/campaign/search-ledger-recording.d.ts
+/** How a search operation executed. The shape the ledger event records. */
+type SearchExecutionIdentity = SearchOperationRecordedEvent['execution'];
+/** Immutable identities the ledger requires and a campaign cannot infer. */
+interface SearchRunIdentity {
+  /** The agent implementation under optimization. */
+  agent: SearchSourceRef;
+  /** The candidate generator: a model call or deterministic code. */
+  proposer: SearchExecutionIdentity;
+  /** The code that plans the search and selects its winner. */
+  search: SearchSourceRef;
+  /** Model the agent runs. Used only for a cell that reported none. */
+  model: SearchModelIdentity;
+}
+interface SearchLedgerBinding {
+  ledger: SearchLedger;
+  identity: SearchRunIdentity;
+}
+/** One proposed candidate, before it is measured. */
+interface ProposedSearchCandidate {
+  surface: MutableSurface;
+  surfaceHash: string;
+  label?: string;
+}
+/** One measured candidate, after its campaign scored. */
+interface MeasuredSearchCandidate<TArtifact> {
+  surface: MutableSurface;
+  surfaceHash: string;
+  cells: ReadonlyArray<CampaignCellResult<TArtifact>>;
+  runDir: string;
+  /** False when the candidate missed a designed cell. */
+  coverageComplete: boolean;
+}
+interface SearchRecorderOptions<TScenario extends Scenario> {
+  binding: SearchLedgerBinding;
+  storage: CampaignStorage;
+  runDir: string;
+  scenarios: ReadonlyArray<TScenario>;
+  reps: number;
+  maxGenerations: number;
+  populationSize: number;
+  /** Identity of the exact campaign design; the task benchmark pin. */
+  splitDigest: `sha256:${string}`;
+  /** Proposer label recorded on every candidate lineage. */
+  proposerLabel: string;
+  costLedger: CostLedgerHandle;
+}
+/**
+ * Recorder for one `runOptimization` run: `open()`, then `recordGeneration()`
+ * and `recordResults()` per generation, then `finish()`.
+ *
+ * Every event id is derived from the run, and an id already durable is not
+ * appended again, so a resumed run continues one ledger instead of conflicting
+ * with its own history.
+ */
+declare class SearchRecorder<TScenario extends Scenario, TArtifact> {
+  private readonly opts;
+  private readonly tasks;
+  private readonly registered;
+  private readonly order;
+  private readonly coverage;
+  private readonly openSlots;
+  private readonly durableEventIds;
+  private lastStampMs;
+  private proposalReceiptCount;
+  private constructor();
+  /** Open the recorder and append the plan. An existing ledger for the same
+   *  run is re-read first, so a resumed run keeps one plan and one lineage. */
+  static open<TScenario extends Scenario, TArtifact>(opts: SearchRecorderOptions<TScenario>): Promise<SearchRecorder<TScenario, TArtifact>>;
+  /**
+   * Record one generation's candidate-generation call and the candidates it
+   * produced. A proposal larger than the planned population extends the plan
+   * with the extra slots; a proposal that fills fewer closes the rest.
+   */
+  recordGeneration(input: {
+    generation: number;
+    parentSurfaceHash: string;
+    candidates: ReadonlyArray<ProposedSearchCandidate>;
+  }): Promise<void>;
+  /** Append one task attempt per designed cell of each candidate campaign. */
+  recordResults(candidates: ReadonlyArray<MeasuredSearchCandidate<TArtifact>>): Promise<void>;
+  /**
+   * Close the search: unreached generations, the selection operation, one
+   * decision per candidate, then the terminal event.
+   *
+   * The terminal event is appended only when canonical replay accounts for the
+   * whole planned denominator. An interrupted or partly unscored search stays
+   * `in-progress` and its receipt reports the exact gap, instead of claiming a
+   * closed search.
+   */
+  finish(input: {
+    winnerSurfaceHash: string;
+    generationsRun: number;
+    runId: string;
+  }): Promise<SearchHistoryReceipt>;
+  /** Bounded receipt over the exact ledger bytes this run produced. */
+  receipt(runId: string): Promise<SearchHistoryReceipt>;
+  /** Read an existing ledger for this run so a resume continues it. */
+  private hydrate;
+  private plan;
+  private registeredSlot;
+  private remember;
+  private recordGenerationOperation;
+  private closeSlot;
+  /** Spend booked to candidate generation since the previous generation. */
+  private proposalAccounting;
+  private cellModel;
+  private proposalArtifact;
+  /** Write one canonical evidence document and return its content address. */
+  private writeArtifact;
+  private append;
+  /** Non-decreasing ISO stamps; the ledger refuses an event that moves back. */
+  private stamp;
+}
+/**
+ * Record an optimizer's own candidate graph into the same ledger.
+ *
+ * A complete optimization method searches inside its own process and reports
+ * one artifact when it finishes: the candidate population, with each
+ * candidate's parents and its score per selection scenario. This turns that
+ * artifact into the canonical event stream, so a first-party method returns
+ * the same `SearchHistoryReceipt` the in-process loop returns, and
+ * `compareOptimizationMethods({ searchHistoryPolicy: 'require-complete' })`
+ * accepts it.
+ *
+ * A candidate the optimizer left unscored on a planned scenario leaves the
+ * planned denominator open, so the receipt reports the gap instead of closing
+ * the search.
+ */
+declare function recordCandidatePopulationSearch<TScenario extends Scenario>(input: {
+  ledger: SearchLedger;
+  storage: CampaignStorage;
+  runDir: string;
+  identity: SearchRunIdentity;
+  population: GepaCandidatePopulationArtifact;
+  /** Scenarios the optimizer selected on. Must cover the population's ids. */
+  scenarios: ReadonlyArray<TScenario>;
+  /** Spend the optimizer booked to its own candidate generation. */
+  generationAccounting: SearchAttemptAccounting;
+  producerId: string;
+  runId: string;
+}): Promise<SearchHistoryReceipt>;
+//#endregion
+//#region src/campaign/parent-selection.d.ts
+/** Search state supplied to one parent-selection call. */
+interface ParentSelectionContext {
+  /** Non-dominated scored surfaces across the whole run so far, including the
+   *  baseline (`generation: -1`). Never empty. */
+  readonly frontier: ReadonlyArray<ParetoParent>;
+  /** Measured result of the global incumbent, the promotion bar. Under the
+   *  default `selectionRankKey` the incumbent is always on `frontier`. */
+  readonly incumbent: ScoredSurfaceOutcome;
+  /** Every completed generation so far. */
+  readonly history: ReadonlyArray<GenerationRecord>;
+  /** Index of the generation about to propose. */
+  readonly generation: number;
+}
+/** Chooses the surface the next generation mutates. Returns one frontier
+ *  parent; `runOptimization` refuses a parent it has not measured to
+ *  completion or whose surface does not match its `surfaceHash`. */
+type ParentSelector = (ctx: ParentSelectionContext) => ParetoParent;
+interface CrowdedFrontierParentOptions {
+  /** Integer seed for the per-generation draw. The same seed, frontier, and
+   *  generation index select the same parent. */
+  seed: number;
+}
+/**
+ * NSGA-II crowded tournament selection over the frontier. Each generation
+ * draws two distinct frontier members with a PRNG seeded from `seed` and the
+ * generation index, and keeps the one with the larger crowding distance (more
+ * isolated on the frontier). Boundary parents carry infinite distance, so a
+ * boundary parent always beats an interior one. A tie on distance falls back
+ * to the higher mean composite, then to the smaller surface hash. A frontier
+ * of one member returns that member.
+ */
+declare function crowdedFrontierParent(options: CrowdedFrontierParentOptions): ParentSelector;
+//#endregion
 //#region src/campaign/presets/run-eval.d.ts
 interface RunEvalOptions<TScenario extends Scenario, TArtifact> extends Omit<RunCampaignOptions<TScenario, TArtifact>, 'runDir'> {
   runDir: string;
@@ -1334,6 +1731,31 @@ interface RunOptimizationBaseOptions<TScenario extends Scenario, TArtifact> exte
    * vectors are untouched, so proposer diversity and reporting are unaffected.
    */
   selectionRankKey?: (campaign: CampaignResult<TArtifact, TScenario>) => number[];
+  /**
+   * Optional policy for which scored surface the next generation MUTATES.
+   * Absent, every generation mutates the global incumbent, so the recorded
+   * `parentSurfaceHash` lineage is a chain. Present, the selector receives the
+   * Pareto frontier so far, the measured incumbent, the generation history,
+   * and the generation index, and returns one frontier parent; the loop hands
+   * that parent to `propose()` as `currentSurface` + `parentOutcome` and
+   * records it as every candidate's `parentSurfaceHash`. Promotion is
+   * unchanged: a candidate still has to beat the incumbent. The loop refuses
+   * a parent it has not measured to completion. `crowdedFrontierParent` is
+   * the provided seeded policy.
+   */
+  selectParent?: ParentSelector;
+  /**
+   * Record this search into a durable `SearchLedger`. The loop emits the plan,
+   * each candidate-generation operation, each candidate registration with its
+   * measured parent, one task attempt per designed cell, one decision per
+   * candidate, and the terminal event, then returns a bounded
+   * `searchHistory` receipt over the exact ledger bytes.
+   *
+   * `identity` declares what the ledger requires and a campaign cannot infer:
+   * immutable revisions for the agent, proposer, and search implementations,
+   * and the model the agent runs when a cell reports none.
+   */
+  searchLedger?: SearchLedgerBinding;
 }
 type RunOptimizationOptions<TScenario extends Scenario, TArtifact> = RunOptimizationBaseOptions<TScenario, TArtifact>;
 interface RunOptimizationResult<TArtifact, TScenario extends Scenario> {
@@ -1360,6 +1782,10 @@ interface RunOptimizationResult<TArtifact, TScenario extends Scenario> {
   baselineCampaign: CampaignResult<TArtifact, TScenario>;
   /** Run-wide spend, including agents, proposers, analysts, and judges. */
   cost: CostLedgerSummary;
+  /** Bounded proof envelope over the canonical search ledger. Present only
+   *  when `searchLedger` was supplied. `complete` is false when the search was
+   *  interrupted or a candidate left a designed cell unscored. */
+  searchHistory?: SearchHistoryReceipt;
   /** 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
@@ -1368,7 +1794,7 @@ interface RunOptimizationResult<TArtifact, TScenario extends Scenario> {
   paretoFrontier: ParetoParent[];
 }
 /**
- * Improvement loop body: N generations of propose → campaign → rank, maintaining a Pareto frontier and one global incumbent across generations.
+ * Improvement loop body: N generations of propose → campaign → rank, maintaining a Pareto frontier and one global incumbent across generations. The parent each generation mutates is the incumbent unless `selectParent` draws it from the frontier.
  */
 declare function runOptimization<TScenario extends Scenario, TArtifact>(opts: RunOptimizationOptions<TScenario, TArtifact>): Promise<RunOptimizationResult<TArtifact, TScenario>>;
 //#endregion
@@ -1602,7 +2028,8 @@ declare function buildLoopProvenanceRecord<TArtifact, TScenario extends Scenario
 declare function campaignMeasurementDigest<TArtifact, TScenario extends Scenario>(campaign: CampaignResult<TArtifact, TScenario>): `sha256:${string}`;
 /** Recompute and validate the self-addressed durable record. */
 declare function verifyLoopProvenanceRecord(record: LoopProvenanceRecord): LoopProvenanceRecord;
-/** Return the canonical SHA-256 digest of a JSON-serializable value. */
+/** SHA-256 over the RFC 8785 canonical JSON of `value`. Throws
+ * `LedgerCanonicalizationError` for a value with no canonical form. */
 declare function canonicalDigest(value: unknown): `sha256:${string}`;
 /**
  * Build the loop's OTLP-ingestable spans from a provenance record. One root
@@ -1650,5 +2077,33 @@ interface EmitLoopProvenanceArgs<TArtifact, TScenario extends Scenario> extends
  */
 declare function emitLoopProvenance<TArtifact, TScenario extends Scenario>(args: EmitLoopProvenanceArgs<TArtifact, TScenario>): Promise<EmitLoopProvenanceResult>;
 //#endregion
-export { OptimizationTokenUsage as $, SearchTokenAccounting as $t, RedTeamCategory as A, LlmJudgeDimension as An, SearchCompletedEvent as At, CanaryReport as B, SearchModelIdentity as Bt, RunOptimizationOptions as C, CampaignStorage as Cn, SearchAttemptAccounting as Ct, runEval as D, OpenAutoPrOptions as Dn, SearchCandidateSlot as Dt, RunEvalOptions as E, inMemoryCampaignStorage as En, SearchCandidateRegisteredEvent as Et, scoreRedTeamOutput as F, SearchLedgerEntry as Ft, OptimizationMethodComparison as G, SearchPlannedOperation as Gt, CompareOptimizationMethodsOptions as H, SearchOperationRecordedEvent as Ht, CanaryAlert as I, SearchLedgerEvent as It, OptimizationMethodProvenance as J, SearchSurfaceEffect as Jt, OptimizationMethodInput as K, SearchPlannedTask as Kt, CanaryEvaluation as L, SearchLedgerHash as Lt, RedTeamReport as M, llmJudge as Mn, SearchFailureReason as Mt, redTeamDataset as N, SearchLedger as Nt, DEFAULT_RED_TEAM_CORPUS as O, OpenAutoPrResult as On, SearchCandidateSlotClosedEvent as Ot, redTeamReport as P, SearchLedgerAppendResult as Pt, OptimizationPackageSource as Q, SearchTaskOutcome as Qt, CanaryKind as R, SearchLedgerReplay as Rt, PremeasuredOptimizationBaseline as S, planCampaignRun as Sn, SearchArtifactRef as St, runOptimization as T, fsCampaignStorage as Tn, SearchCandidateLineage as Tt, ComparisonCost as U, SearchPlan as Ut, runCanaries as V, SearchOperationKind as Vt, OptimizationMethod as W, SearchPlannedEvent as Wt, OptimizationMethodRunOptions as X, SearchSurfaceKind as Xt, OptimizationMethodResult as Y, SearchSurfaceEvidence as Yt, OptimizationMethodScore as Z, SearchTaskAttemptedEvent as Zt, provenanceSpansPath as _, RunCampaignOptions as _n, verifySearchHistoryReceipt as _t, LoopProvenanceBackend as a, GepaCandidateSelectionScore as an, SEARCH_HISTORY_RECEIPT_DIGEST_ALGORITHM as at, RunImprovementLoopResult as b, CampaignRunPlanCell as bn, SEARCH_LEDGER_SCHEMA as bt, LoopProvenanceOptimizationMethod as c, ExternalOptimizerObservationArtifact as cn, SearchHistoryCoverage as ct, campaignMeasurementDigest as d, readExternalOptimizerObservationArtifact as dn, SearchHistoryReceipt as dt, openSearchLedger as en, combineComparisonCosts as et, canonicalDigest as f, CacheIssueReason as fn, SearchHistoryRequiredError as ft, provenanceRecordPath as g, CampaignCellFailureReceipt as gn, searchHistoryCoverageRow as gt, loopProvenanceSpans as h, cellCachePath as hn, createSearchHistoryReceipt as ht, LoopProvenanceArgsFromResult as i, GepaCandidatePopulationSummary as in, CreateSearchHistoryReceiptInput as it, RedTeamFinding as j, LlmJudgeOptions as jn, SearchCostAccounting as jt, RedTeamCase as k, openAutoPr as kn, SearchCandidateSurface as kt, LoopProvenanceRecord as l, ExternalOptimizerObservationSummary as ln, SearchHistoryCoverageRow as lt, loopProvenanceArgsFromResult as m, readCachedCell as mn, assertSearchHistoryMatchesReplay as mt, EmitLoopProvenanceArgs as n, GepaCandidatePopulationArtifact as nn, costFromLedgerSummary as nt, LoopProvenanceCandidate as o, readGepaCandidatePopulationArtifact as on, SEARCH_HISTORY_RECEIPT_SCHEMA_VERSION as ot, emitLoopProvenance as p, CacheRead as pn, assertCompleteSearchHistory as pt, OptimizationMethodPairwise as q, SearchSourceRef as qt, EmitLoopProvenanceResult as r, GepaCandidatePopulationCandidate as rn, optimizationTokenUsageFromSummary as rt, LoopProvenanceEvidence as s, ExternalOptimizerExecutionSummary as sn, SearchHistoryAuditSummary as st, BuildLoopProvenanceArgs as t, validateSearchLedgerEvent as tn, compareOptimizationMethods as tt, buildLoopProvenanceRecord as u, ExternalOptimizerSubmittedCandidate as un, SearchHistoryPolicy as ut, verifyLoopProvenanceRecord as v, runCampaign as vn, FileSearchLedger as vt, RunOptimizationResult as w, createRunCostLedger as wn, SearchCandidateDecidedEvent as wt, runImprovementLoop as x, PlanCampaignRunOptions as xn, SearchAccountingAudit as xt, RunImprovementLoopOptions as y, CampaignRunPlan as yn, OpenSearchLedgerOptions as yt, CanaryOptions as z, SearchLedgerTrustedHeadMode as zt };
-//# sourceMappingURL=provenance-oA4-zUqm.d.ts.map
+//#region src/campaign/transient-failure.d.ts
+interface TransientFailureOptions {
+  /**
+   * Treat full-duration timeouts ("timeout after 180000ms") as transient.
+   * Enable on saturated shared infrastructure where queue starvation eats
+   * the clock; leave off when the agent had the resources and simply failed.
+   * Default false.
+   */
+  readonly retryFullDurationTimeouts?: boolean;
+  /** Additional caller-specific transient patterns. */
+  readonly extraPatterns?: readonly RegExp[];
+}
+/**
+ * True when the error text describes an infrastructure hiccup that should be
+ * retried rather than scored. Empty/undefined input is not transient.
+ */
+declare function isTransientTransportFailure(message: string | null | undefined, opts?: TransientFailureOptions): boolean;
+/**
+ * Ready-made `cellRetry.retryable` predicate: true for a dispatch-stage
+ * failure whose error message `isTransientTransportFailure` classifies as an
+ * infrastructure hiccup. A judge-stage failure is never retried here — the
+ * dispatch already produced an artifact, so re-dispatching would score a
+ * different sample. A per-cell dispatch deadline ("dispatch exceeded <N>ms")
+ * is not transient by default; opt in via `extraPatterns` or
+ * `retryFullDurationTimeouts` when queue starvation eats the clock.
+ */
+declare function transientDispatchFailure(opts?: TransientFailureOptions): (failure: CampaignCellFailureReceipt['failure']) => boolean;
+//#endregion
+export { CanaryKind as $, ServedModelVerdict as $n, SearchOperationKind as $t, runEval as A, CampaignCellRetryPolicy as An, verifySearchHistoryReceipt as At, SearchRecorderOptions as B, inMemoryCampaignStorage as Bn, SearchCandidateSlotClosedEvent as Bt, RunImprovementLoopResult as C, ExternalOptimizerSubmittedCandidate as Cn, SearchHistoryPolicy as Ct, RunOptimizationResult as D, readCachedCell as Dn, assertSearchHistoryMatchesReplay as Dt, RunOptimizationOptions as E, CacheRead as En, assertCompleteSearchHistory as Et, MeasuredSearchCandidate as F, PlanCampaignRunOptions as Fn, SearchAttemptAccounting as Ft, RedTeamCategory as G, LlmJudgeOptions as Gn, SearchLedger as Gt, recordCandidatePopulationSearch as H, OpenAutoPrResult as Hn, SearchCompletedEvent as Ht, ProposedSearchCandidate as I, planCampaignRun as In, SearchCandidateDecidedEvent as It, redTeamDataset as J, AssertServedModelOptions as Jn, SearchLedgerEvent as Jt, RedTeamFinding as K, llmJudge as Kn, SearchLedgerAppendResult as Kt, SearchExecutionIdentity as L, CampaignStorage as Ln, SearchCandidateLineage as Lt, ParentSelectionContext as M, runCampaign as Mn, OpenSearchLedgerOptions as Mt, ParentSelector as N, CampaignRunPlan as Nn, SearchAccountingAudit as Nt, runOptimization as O, cellCachePath as On, createSearchHistoryReceipt as Ot, crowdedFrontierParent as P, CampaignRunPlanCell as Pn, SearchArtifactRef as Pt, CanaryEvaluation as Q, ServedModelPolicy as Qn, SearchModelIdentity as Qt, SearchLedgerBinding as R, createRunCostLedger as Rn, SearchCandidateRegisteredEvent as Rt, RunImprovementLoopOptions as S, ExternalOptimizerObservationSummary as Sn, SearchHistoryCoverageRow as St, PremeasuredOptimizationBaseline as T, CacheIssueReason as Tn, SearchHistoryRequiredError as Tt, DEFAULT_RED_TEAM_CORPUS as U, openAutoPr as Un, SearchCostAccounting as Ut, SearchRunIdentity as V, OpenAutoPrOptions as Vn, SearchCandidateSurface as Vt, RedTeamCase as W, LlmJudgeDimension as Wn, SearchFailureReason as Wt, scoreRedTeamOutput as X, ServedCrossFamilyError as Xn, SearchLedgerReplay as Xt, redTeamReport as Y, ModelSubstitutionError as Yn, SearchLedgerHash as Yt, CanaryAlert as Z, ServedModelCheck as Zn, SearchLedgerTrustedHeadMode as Zt, loopProvenanceArgsFromResult as _, GepaCandidatePopulationSummary as _n, costFromLedgerSummary as _t, EmitLoopProvenanceArgs as a, SearchPlannedTask as an, AssertCrossFamilyOptions as ar, OptimizationMethod as at, provenanceSpansPath as b, ExternalOptimizerExecutionSummary as bn, SearchHistoryAuditSummary as bt, LoopProvenanceBackend as c, SearchSurfaceEvidence as cn, assertCrossFamily as cr, OptimizationMethodPairwise as ct, LoopProvenanceOptimizationMethod as d, SearchTaskOutcome as dn, OptimizationMethodRunOptions as dt, SearchOperationRecordedEvent as en, assertCrossFamilyServed as er, CanaryOptions as et, LoopProvenanceRecord as f, SearchTokenAccounting as fn, OptimizationMethodScore as ft, emitLoopProvenance as g, GepaCandidatePopulationCandidate as gn, compareOptimizationMethods as gt, canonicalDigest as h, GepaCandidatePopulationArtifact as hn, combineComparisonCosts as ht, BuildLoopProvenanceArgs as i, SearchPlannedOperation as in, servedModelAcceptable as ir, ComparisonCost as it, CrowdedFrontierParentOptions as j, RunCampaignOptions as jn, FileSearchLedger as jt, RunEvalOptions as k, CampaignCellFailureReceipt as kn, searchHistoryCoverageRow as kt, LoopProvenanceCandidate as l, SearchSurfaceKind as ln, judgeFamily as lr, OptimizationMethodProvenance as lt, campaignMeasurementDigest as m, validateSearchLedgerEvent as mn, OptimizationTokenUsage as mt, isTransientTransportFailure as n, SearchPlanExtendedEvent as nn, assertServedModels as nr, runCanaries as nt, EmitLoopProvenanceResult as o, SearchSourceRef as on, CrossFamilyError as or, OptimizationMethodComparison as ot, buildLoopProvenanceRecord as p, openSearchLedger as pn, OptimizationPackageSource as pt, RedTeamReport as q, AssertCrossFamilyServedOptions as qn, SearchLedgerEntry as qt, transientDispatchFailure as r, SearchPlannedEvent as rn, checkServedModel as rr, CompareOptimizationMethodsOptions as rt, LoopProvenanceArgsFromResult as s, SearchSurfaceEffect as sn, JudgeFamily as sr, OptimizationMethodInput as st, TransientFailureOptions as t, SearchPlan as tn, assertServedModel as tr, CanaryReport as tt, LoopProvenanceEvidence as u, SearchTaskAttemptedEvent as un, OptimizationMethodResult as ut, loopProvenanceSpans as v, GepaCandidateSelectionScore as vn, optimizationTokenUsageFromSummary as vt, runImprovementLoop as w, readExternalOptimizerObservationArtifact as wn, SearchHistoryReceipt as wt, verifyLoopProvenanceRecord as x, ExternalOptimizerObservationArtifact as xn, SearchHistoryCoverage as xt, provenanceRecordPath as y, readGepaCandidatePopulationArtifact as yn, CreateSearchHistoryReceiptInput as yt, SearchRecorder as z, fsCampaignStorage as zn, SearchCandidateSlot as zt };
+//# sourceMappingURL=transient-failure-DKF5Mofa.d.ts.map