@tangle-network/agent-eval 0.147.0 → 0.148.0

package/dist/{provenance-LrOEOHQb.d.ts → provenance-DA-Pmyfv.d.ts}

@@ -5,6 +5,7 @@ import { _ as ProposalFinding } from "./types-BohHewKK.js";
 import { g as ExternalTextCandidate, o as ExternalOptimizerEvaluationObservation } from "./external-optimizer-contracts-CSjDLLmr.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-C1Bmeb8X.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-BV7icIfy.js";
 import { z } from "zod";
 //#region src/llm-judge.d.ts
@@ -465,6 +466,435 @@ declare function readGepaCandidatePopulationArtifact(input: {
   storage?: CampaignStorage;
 }): GepaCandidatePopulationArtifact;
 //#endregion
+//#region src/campaign/search-ledger.d.ts
+declare const SEARCH_LEDGER_SCHEMA: 'tangle.search-ledger.v1';
+type SearchLedgerHash = LedgerHash;
+type SearchSurfaceKind = 'prompt' | 'tool-contract' | 'runtime-config' | 'memory' | 'knowledge' | 'agent-profile' | 'code' | 'deployment';
+/** Content-addressed artifact or receipt. Mutable paths are locators only; the
+ * digest and byte length bind the exact bytes used by the search. */
+interface SearchArtifactRef {
+  role: string;
+  uri: string;
+  sha256: SearchLedgerHash;
+  byteLength: number;
+}
+/** Repository, dataset, or package source pinned to an immutable commit or
+ * content digest. Branches, tags, and bare package versions are rejected. */
+interface SearchSourceRef {
+  uri: string;
+  revision: string;
+}
+interface SearchModelIdentity {
+  provider: string;
+  snapshot: string;
+}
+interface SearchCandidateSurface {
+  surfaceId: string;
+  kind: SearchSurfaceKind;
+  artifact: SearchArtifactRef;
+}
+interface SearchCandidateLineage {
+  /** Existing `LineageNode.id`; this ledger references rather than embeds it. */
+  lineageNodeId: string;
+  parentCandidateIds: string[];
+  generation: number;
+  proposer: string;
+  proposerSource: SearchSourceRef;
+}
+type SearchOperationKind = 'candidate-generation' | 'analysis' | 'selection' | 'judge' | 'other';
+interface SearchPlannedTask {
+  taskId: string;
+  source: SearchSourceRef;
+  benchmark: SearchSourceRef;
+  /** Maximum transport attempts for this task and candidate. Only an explicit
+   * passed/failed outcome satisfies the planned denominator. */
+  maxAttempts: number;
+}
+interface SearchPlannedOperation {
+  operationId: string;
+  kind: SearchOperationKind;
+}
+interface SearchCandidateSlot {
+  slotId: string;
+  /** Planned candidate-generation call that must either produce this slot or
+   * fail before the slot can be closed. Several slots may share one batched call. */
+  generationOperationId: string;
+}
+interface SearchPlan {
+  /** Stable slots and their proposer calls are frozen before search begins. */
+  candidateSlots: SearchCandidateSlot[];
+  /** Every task applies to every successfully registered candidate. */
+  tasks: SearchPlannedTask[];
+  /** Non-task spend slots: proposal, analysis, selection, extra judges, etc. */
+  operations: SearchPlannedOperation[];
+}
+type SearchTokenAccounting = {
+  status: 'known';
+  inputTokens: number;
+  outputTokens: number;
+  cachedTokens: number;
+} | {
+  status: 'unknown';
+  reason: string;
+};
+type SearchCostAccounting = {
+  status: 'known';
+  usd: number;
+  source: 'provider' | 'pricing-table' | 'free';
+} | {
+  status: 'unknown';
+  /** Known spend may still be a lower bound when one call was unpriced. */
+  knownLowerBoundUsd: number;
+  reason: string;
+};
+interface SearchAttemptAccounting {
+  tokens: SearchTokenAccounting;
+  cost: SearchCostAccounting;
+}
+interface SearchFailureReason {
+  code: string;
+  message: string;
+}
+type SearchTaskOutcome = {
+  status: 'passed';
+  score: number;
+  metrics: Record<string, number>;
+} | {
+  status: 'failed';
+  score: number;
+  metrics: Record<string, number>;
+  failure: SearchFailureReason;
+} | {
+  status: 'errored';
+  metrics: Record<string, number>;
+  error: SearchFailureReason & {
+    retryable: boolean;
+  };
+};
+type SearchSurfaceEffect = {
+  status: 'measured';
+  metric: string;
+  baselineValue: number;
+  candidateValue: number;
+  delta: number;
+} | {
+  status: 'not-measured';
+  reason: string;
+};
+/** Per-attempt proof that a declared candidate surface was or was not active,
+ * plus measured effect when the experiment supports attribution. */
+interface SearchSurfaceEvidence {
+  surfaceId: string;
+  fired: boolean;
+  firingCount: number;
+  effect: SearchSurfaceEffect;
+  evidence: SearchArtifactRef[];
+}
+interface SearchLedgerEventBase {
+  eventId: string;
+  occurredAt: string;
+  artifacts: SearchArtifactRef[];
+}
+interface SearchPlannedEvent extends SearchLedgerEventBase {
+  kind: 'search-planned';
+  plan: SearchPlan;
+}
+interface SearchCandidateRegisteredEvent extends SearchLedgerEventBase {
+  kind: 'candidate-registered';
+  slotId: string;
+  generationOperationId: string;
+  candidateId: string;
+  lineage: SearchCandidateLineage;
+  surfaces: SearchCandidateSurface[];
+}
+interface SearchCandidateSlotClosedEvent extends SearchLedgerEventBase {
+  kind: 'candidate-slot-closed';
+  slotId: string;
+  generationOperationId: string;
+  reason: SearchFailureReason;
+}
+interface SearchTaskAttemptedEvent extends SearchLedgerEventBase {
+  kind: 'task-attempted';
+  candidateId: string;
+  runId: string;
+  attemptIndex: number;
+  task: {
+    taskId: string;
+    source: SearchSourceRef;
+  };
+  identity: {
+    model: SearchModelIdentity;
+    agent: SearchSourceRef;
+    benchmark: SearchSourceRef;
+  };
+  outcome: SearchTaskOutcome;
+  accounting: SearchAttemptAccounting;
+  surfaceEvidence: SearchSurfaceEvidence[];
+}
+interface SearchOperationRecordedEvent extends SearchLedgerEventBase {
+  kind: 'search-operation-recorded';
+  operationId: string;
+  operationKind: SearchOperationKind;
+  execution: {
+    kind: 'model';
+    model: SearchModelIdentity;
+    source: SearchSourceRef;
+  } | {
+    kind: 'deterministic';
+    source: SearchSourceRef;
+  };
+  outcome: {
+    status: 'completed';
+  } | {
+    status: 'partial';
+    failure: SearchFailureReason;
+  } | {
+    status: 'failed';
+    failure: SearchFailureReason;
+  };
+  accounting: SearchAttemptAccounting;
+}
+interface SearchCandidateDecidedEvent extends SearchLedgerEventBase {
+  kind: 'candidate-decided';
+  candidateId: string;
+  decision: {
+    status: 'selected';
+  } | {
+    status: 'rejected';
+    reason: SearchFailureReason;
+  };
+}
+interface SearchCompletedEvent extends SearchLedgerEventBase {
+  kind: 'search-completed';
+  result: {
+    status: 'selected';
+    candidateId: string;
+  } | {
+    status: 'all-rejected';
+    reason: SearchFailureReason;
+  };
+}
+type SearchLedgerEvent = SearchPlannedEvent | SearchCandidateRegisteredEvent | SearchCandidateSlotClosedEvent | SearchTaskAttemptedEvent | SearchOperationRecordedEvent | SearchCandidateDecidedEvent | SearchCompletedEvent;
+interface SearchLedgerEntry {
+  schema: typeof SEARCH_LEDGER_SCHEMA;
+  campaignId: string;
+  sequence: number;
+  previousHash: SearchLedgerHash | null;
+  event: SearchLedgerEvent;
+  entryHash: SearchLedgerHash;
+}
+type SearchAccountingAudit = {
+  status: 'known';
+  inputTokens: number;
+  outputTokens: number;
+  cachedTokens: number;
+  costUsd: number;
+} | {
+  status: 'partial';
+  knownInputTokens: number;
+  knownOutputTokens: number;
+  knownCachedTokens: number;
+  knownCostUsd: number;
+  unknownTokenEventIds: string[];
+  unknownCostEventIds: string[];
+};
+interface SearchLedgerAudit {
+  campaignId: string;
+  eventCount: number;
+  candidateCount: number;
+  closedCandidateSlotCount: number;
+  attemptCount: number;
+  operationCount: number;
+  outcomes: {
+    passed: number;
+    failed: number;
+    errored: number;
+  };
+  operationOutcomes: {
+    completed: number;
+    partial: number;
+    failed: number;
+  };
+  decisions: {
+    selected: number;
+    rejected: number;
+    pending: number;
+  };
+  expected: {
+    candidateSlots: number;
+    taskOutcomes: number;
+    operations: number;
+    missingCandidateSlots: string[];
+    missingTaskOutcomes: string[];
+    missingOperations: string[];
+  };
+  status: 'in-progress' | 'selected' | 'all-rejected';
+  selectedCandidateId: string | null;
+  accounting: SearchAccountingAudit;
+  headHash: SearchLedgerHash | null;
+}
+interface SearchLedgerReplay {
+  entries: SearchLedgerEntry[];
+  plan: SearchPlannedEvent | null;
+  candidates: SearchCandidateRegisteredEvent[];
+  closedCandidateSlots: SearchCandidateSlotClosedEvent[];
+  attempts: SearchTaskAttemptedEvent[];
+  operations: SearchOperationRecordedEvent[];
+  decisions: SearchCandidateDecidedEvent[];
+  completion: SearchCompletedEvent | null;
+  audit: SearchLedgerAudit;
+}
+interface SearchLedgerAppendResult {
+  entry: SearchLedgerEntry;
+  /** False when the exact event was already durably present. */
+  appended: boolean;
+  replay: SearchLedgerReplay;
+}
+/** Validate and return a canonical copy. Arrays whose order is not semantic are
+ * sorted so retries from different processes produce byte-identical events. */
+declare function validateSearchLedgerEvent(input: unknown): SearchLedgerEvent;
+/**
+ * How this ledger uses its trusted head — the `(sequence, entryHash)` pin kept
+ * in the sibling `<path>.head` file that a hash chain needs to prove entries
+ * were not deleted from the end. `ledger-core/trusted-head.ts` holds the threat
+ * model.
+ *
+ * - `pin` (default): every append records the new head, and a pin that is
+ *   present is verified on every read.
+ * - `require`: additionally refuses to read a non-empty ledger whose pin is
+ *   gone, so deleting the sibling file cannot downgrade the guarantee. Only for
+ *   ledgers written under `pin` from their first entry.
+ * - `off`: chain verification only. Truncation to a valid shorter prefix is
+ *   undetectable.
+ */
+type SearchLedgerTrustedHeadMode = 'pin' | 'require' | 'off';
+interface OpenSearchLedgerOptions {
+  path: string;
+  campaignId: string;
+  trustedHead?: SearchLedgerTrustedHeadMode;
+}
+interface SearchLedger {
+  readonly path: string;
+  readonly campaignId: string;
+  /** Sibling file holding this ledger's trusted head. */
+  readonly trustedHeadPath: string;
+  append(event: SearchLedgerEvent): Promise<SearchLedgerAppendResult>;
+  replay(): Promise<SearchLedgerReplay>;
+  /** The pinned head, or null when this ledger has never been pinned. */
+  trustedHead(): Promise<LedgerTrustedHead | null>;
+  /** Pin the current verified head: how a ledger written under `off`, or one
+   * whose pin file was removed, acquires a pin without rewriting a byte. */
+  pinTrustedHead(): Promise<LedgerTrustedHead>;
+  /** Discard this ledger's pin, reporting what was discarded. Deleting or
+   * rebuilding the ledger file leaves a pin naming history the file no longer
+   * carries, and every later read is refused because that is exactly the
+   * deletion the pin exists to catch; clearing is the supported way to abandon
+   * that history on purpose. It gives up the deletion guarantee for every entry
+   * the pin covered. */
+  clearTrustedHead(): Promise<LedgerTrustedHeadRemoval>;
+}
+/** Open a durable filesystem search ledger. Construction performs no I/O; the
+ * first `append` or `replay` validates the complete existing file. */
+declare function openSearchLedger(options: OpenSearchLedgerOptions): SearchLedger;
+/** Append-only file-backed search ledger with idempotent writes and replay. */
+declare class FileSearchLedger implements SearchLedger {
+  readonly path: string;
+  readonly campaignId: string;
+  readonly trustedHeadPath: string;
+  private readonly trustedHeadMode;
+  private readonly journal;
+  constructor(path: string, campaignId: string, trustedHead?: SearchLedgerTrustedHeadMode);
+  replay(): Promise<SearchLedgerReplay>;
+  append(input: SearchLedgerEvent): Promise<SearchLedgerAppendResult>;
+  trustedHead(): Promise<LedgerTrustedHead | null>;
+  pinTrustedHead(): Promise<LedgerTrustedHead>;
+  clearTrustedHead(): Promise<LedgerTrustedHeadRemoval>;
+}
+//#endregion
+//#region src/campaign/search-history-receipt.d.ts
+declare const SEARCH_HISTORY_RECEIPT_SCHEMA_VERSION: '1.0.0';
+declare const SEARCH_HISTORY_RECEIPT_DIGEST_ALGORITHM: 'rfc8785-sha256';
+/** Bounded projection of the canonical replay audit. Exact ids stay in SearchLedger. */
+interface SearchHistoryAuditSummary {
+  readonly campaignId: string;
+  readonly headHash: SearchLedgerHash | null;
+  readonly status: SearchLedgerAudit['status'];
+  readonly selectedCandidateId: string | null;
+  readonly eventCount: number;
+  readonly candidateCount: number;
+  readonly closedCandidateSlotCount: number;
+  readonly attemptCount: number;
+  readonly operationCount: number;
+  readonly expectedCandidateSlots: number;
+  readonly expectedTaskOutcomes: number;
+  readonly expectedOperations: number;
+  readonly missingCandidateSlots: number;
+  readonly missingTaskOutcomes: number;
+  readonly missingOperations: number;
+  readonly pendingDecisions: number;
+  readonly hasPlan: boolean;
+  readonly hasCompletion: boolean;
+}
+/**
+ * A bounded proof envelope over one canonical SearchLedger replay.
+ *
+ * The content-addressed ledger remains the sole rich history. This receipt binds
+ * its producer/run identity, exact audit digest, bounded completeness summary,
+ * and its own canonical digest. Consumers needing candidate ids, attempts,
+ * failures, accounting gaps, or decisions read and replay the canonical ledger.
+ */
+interface SearchHistoryReceipt {
+  readonly schemaVersion: typeof SEARCH_HISTORY_RECEIPT_SCHEMA_VERSION;
+  readonly kind: 'search-history-receipt';
+  readonly digestAlgorithm: typeof SEARCH_HISTORY_RECEIPT_DIGEST_ALGORITHM;
+  readonly receiptDigest: SearchLedgerHash;
+  /** Stable producer identity, for example an OptimizationMethod name. */
+  readonly producerId: string;
+  /** Concrete optimizer/runtime invocation that produced the ledger. */
+  readonly runId: string;
+  readonly ledger: SearchArtifactRef;
+  /** Digest of the complete SearchLedgerAudit produced by canonical replay. */
+  readonly auditDigest: SearchLedgerHash;
+  readonly summary: SearchHistoryAuditSummary;
+  readonly complete: boolean;
+  readonly incompleteReasons: readonly string[];
+}
+interface CreateSearchHistoryReceiptInput {
+  readonly producerId: string;
+  readonly runId: string;
+  /** Content-addressed canonical SearchLedger JSONL artifact. */
+  readonly ledger: SearchArtifactRef;
+  /** The result returned by SearchLedger.replay(). */
+  readonly replay: SearchLedgerReplay;
+}
+type SearchHistoryPolicy = 'allow-missing' | 'require-complete';
+interface SearchHistoryCoverageRow {
+  readonly producerId: string;
+  readonly status: 'complete' | 'incomplete' | 'missing';
+  readonly reasons: readonly string[];
+  readonly receipt?: SearchHistoryReceipt;
+}
+interface SearchHistoryCoverage {
+  readonly policy: SearchHistoryPolicy;
+  readonly allComplete: boolean;
+  readonly producers: readonly SearchHistoryCoverageRow[];
+}
+declare class SearchHistoryRequiredError extends Error {
+  readonly producerId: string;
+  readonly reasons: readonly string[];
+  constructor(producerId: string, reasons: readonly string[]);
+}
+/** Build a bounded receipt from the projection returned by canonical ledger replay. */
+declare function createSearchHistoryReceipt(input: CreateSearchHistoryReceiptInput): SearchHistoryReceipt;
+/** Verify the bounded receipt. Full ledger bytes are verified by SearchLedger. */
+declare function verifySearchHistoryReceipt(receipt: SearchHistoryReceipt): SearchHistoryReceipt;
+/** Prove that a receipt still describes the exact canonical replay supplied. */
+declare function assertSearchHistoryMatchesReplay(receipt: SearchHistoryReceipt, replay: SearchLedgerReplay): void;
+/** Require a receipt owned by this producer and a terminal, denominator-complete history. */
+declare function assertCompleteSearchHistory(producerId: string, receipt: SearchHistoryReceipt | undefined): asserts receipt is SearchHistoryReceipt;
+/** Classify one producer's history without treating malformed evidence as absence. */
+declare function searchHistoryCoverageRow(producerId: string, receipt: SearchHistoryReceipt | undefined): SearchHistoryCoverageRow;
+//#endregion
 //#region src/campaign/presets/compare-optimization-methods.d.ts
 /** Shared campaign settings applied to every optimization method. */
 type OptimizationMethodRunOptions<TScenario extends Scenario, TArtifact> = Omit<RunCampaignOptions<TScenario, TArtifact>, 'costCeiling' | 'costLedger' | 'dispatch' | 'judges' | 'runDir' | 'scenarios' | 'seed'>;
@@ -565,6 +995,8 @@ interface OptimizationMethodResult {
   durationMs?: number;
   /** Exact external implementation and run identity, when the method uses one. */
   provenance?: OptimizationMethodProvenance;
+  /** Bounded proof envelope over the canonical SearchLedger for this optimization. */
+  searchHistory?: SearchHistoryReceipt;
 }
 /** A complete optimization method, including candidate generation and selection. */
 interface OptimizationMethod<TScenario extends Scenario = Scenario, TArtifact = unknown> {
@@ -639,6 +1071,8 @@ interface OptimizationMethodComparison {
   resamples: number;
   /** Agent runs averaged within each test scenario before resampling scenarios. */
   reps: number;
+  /** Coverage of every method's canonical search history. */
+  searchHistory: SearchHistoryCoverage;
 }
 interface CompareOptimizationMethodsOptions<TScenario extends Scenario, TArtifact> extends Omit<RunCampaignOptions<TScenario, TArtifact>, 'dispatch' | 'judges' | 'scenarios'> {
   methods: OptimizationMethod<TScenario, TArtifact>[];
@@ -664,6 +1098,11 @@ interface CompareOptimizationMethodsOptions<TScenario extends Scenario, TArtifac
   confidence?: number;
   /** Shared spend limit across every method's optimizer and evaluation calls plus final scoring. */
   costCeiling?: number;
+  /**
+   * Missing history is reported by default. Publication-grade or autonomous
+   * callers set `require-complete`, which aborts before the first final-test call.
+   */
+  searchHistoryPolicy?: SearchHistoryPolicy;
 }
 /**
  * Compare complete optimization methods on disjoint train, selection, and final test data.
@@ -1200,5 +1639,5 @@ interface EmitLoopProvenanceArgs<TArtifact, TScenario extends Scenario> extends
  */
 declare function emitLoopProvenance<TArtifact, TScenario extends Scenario>(args: EmitLoopProvenanceArgs<TArtifact, TScenario>): Promise<EmitLoopProvenanceResult>;
 //#endregion
-export { OptimizationTokenUsage as $, RedTeamCategory as A, OpenAutoPrResult as At, CanaryReport as B, RunOptimizationOptions as C, PlanCampaignRunOptions as Ct, runEval as D, fsCampaignStorage as Dt, RunEvalOptions as E, createRunCostLedger 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, LlmJudgeDimension as Mt, redTeamDataset as N, LlmJudgeOptions as Nt, DEFAULT_RED_TEAM_CORPUS as O, inMemoryCampaignStorage as Ot, redTeamReport as P, llmJudge as Pt, OptimizationPackageSource as Q, CanaryKind as R, PremeasuredOptimizationBaseline as S, CampaignRunPlanCell as St, runOptimization as T, CampaignStorage as Tt, ComparisonCost as U, runCanaries as V, OptimizationMethod as W, OptimizationMethodRunOptions as X, OptimizationMethodResult as Y, OptimizationMethodScore as Z, provenanceSpansPath as _, cellCachePath as _t, LoopProvenanceBackend as a, GepaCandidatePopulationCandidate as at, RunImprovementLoopResult as b, runCampaign as bt, LoopProvenanceOptimizationMethod as c, readGepaCandidatePopulationArtifact as ct, campaignMeasurementDigest as d, ExternalOptimizerObservationSummary as dt, combineComparisonCosts as et, canonicalDigest as f, ExternalOptimizerSubmittedCandidate as ft, provenanceRecordPath as g, readCachedCell as gt, loopProvenanceSpans as h, CacheRead as ht, LoopProvenanceArgsFromResult as i, GepaCandidatePopulationArtifact as it, RedTeamFinding as j, openAutoPr as jt, RedTeamCase as k, OpenAutoPrOptions as kt, LoopProvenanceRecord as l, ExternalOptimizerExecutionSummary as lt, loopProvenanceArgsFromResult as m, CacheIssueReason as mt, EmitLoopProvenanceArgs as n, costFromLedgerSummary as nt, LoopProvenanceCandidate as o, GepaCandidatePopulationSummary as ot, emitLoopProvenance as p, readExternalOptimizerObservationArtifact as pt, OptimizationMethodPairwise as q, EmitLoopProvenanceResult as r, optimizationTokenUsageFromSummary as rt, LoopProvenanceEvidence as s, GepaCandidateSelectionScore as st, BuildLoopProvenanceArgs as t, compareOptimizationMethods as tt, buildLoopProvenanceRecord as u, ExternalOptimizerObservationArtifact as ut, verifyLoopProvenanceRecord as v, CampaignCellFailureReceipt as vt, RunOptimizationResult as w, planCampaignRun as wt, runImprovementLoop as x, CampaignRunPlan as xt, RunImprovementLoopOptions as y, RunCampaignOptions as yt, CanaryOptions as z };
-//# sourceMappingURL=provenance-LrOEOHQb.d.ts.map
+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-DA-Pmyfv.d.ts.map

package/dist/provenance-DA-Pmyfv.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provenance-DA-Pmyfv.d.ts","names":[],"sources":["../src/llm-judge.ts","../src/campaign/auto-pr.ts","../src/campaign/storage.ts","../src/campaign/plan-campaign-run.ts","../src/campaign/run-campaign.ts","../src/campaign/cell-schedule.ts","../src/campaign/cell-cache.ts","../src/campaign/external-optimizer-observations.ts","../src/campaign/gepa-candidate-population.ts","../src/campaign/search-ledger.ts","../src/campaign/search-history-receipt.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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"}

package/dist/{skillopt-optimization-method-BoC1Qccx.d.ts → skillopt-optimization-method-CrY0OG17.d.ts}

@@ -3,7 +3,7 @@ import { a as RunRecord } from "./run-record-DVV82Gwh.js";
 import { E as LlmCallMetadata, p as ChatClient } from "./types-DOhGq4S1.js";
 import { _ as ExternalTextEvaluationRequest, c as ExternalOptimizerModelBudget, g as ExternalTextCandidate, h as ExternalOptimizerRunnerCommand, l as ExternalOptimizerModelCall, m as ExternalOptimizerResumeMode, r as ExternalOptimizerCallbackLimits } from "./external-optimizer-contracts-CSjDLLmr.js";
 import { R as Scenario, S as JudgeConfig, i as CampaignCostMeter, j as MutableSurface, o as CampaignScenarioIdentity, p as Gate } from "./types-C1Bmeb8X.js";
-import { Q as OptimizationPackageSource, W as OptimizationMethod, k as RedTeamCase, z as CanaryOptions } from "./provenance-LrOEOHQb.js";
+import { Q as OptimizationPackageSource, W as OptimizationMethod, k as RedTeamCase, z as CanaryOptions } from "./provenance-DA-Pmyfv.js";
 import { t as DetectRewardHackingInput } from "./reward-hacking-Bu8ev6PR.js";
 //#region src/reference-equivalence-judge.d.ts
 declare const REFERENCE_EQUIVALENCE_JUDGE_VERSION = "reference-equivalence-judge-v1-2026-07-13";
@@ -431,4 +431,4 @@ interface SkillOptOptimizationMethodConfig<TScenario extends Scenario, TArtifact
 declare function skillOptOptimizationMethod<TScenario extends Scenario, TArtifact>(config: SkillOptOptimizationMethodConfig<TScenario, TArtifact>): OptimizationMethod<TScenario, TArtifact>;
 //#endregion
 export { campaignScenarioIdentity as A, runReferenceEquivalenceJudge as B, ExternalTextOptimizerContext as C, decodeExternalTextCandidate as D, ExternalTextEvaluationResponse as E, ReferenceEquivalenceJudgeInput as F, ReferenceEquivalenceJudgeOptions as I, ReferenceEquivalenceJudgeResult as L, campaignSplitDigestFromIdentities as M, REFERENCE_EQUIVALENCE_INPUT_LIMITS as N, assertCampaignDesign as O, REFERENCE_EQUIVALENCE_JUDGE_VERSION as P, ReferenceEquivalenceScenario as R, ExternalTextOptimizationMethodConfig as S, ExternalOptimizationExample as T, DefaultProductionGateOptions as _, GepaAdaptiveEngineRun as a, composeGate as b, GepaOptimizationMethodConfig as c, gepaOptimizationMethod as d, OpenAICompatibleOptimizerModel as f, DefaultProductionGateCheck as g, heldOutGate as h, skillOptOptimizationMethod as i, campaignSplitDigest as j, assertCampaignSplitIdentity as k, GepaOptimizationRecipe as l, HeldOutGateOptions as m, SkillOptRunnerCommand as n, GepaEngineOptions as o, OptimizerModelBudget as p, SkillOptTrainerConfig as r, GepaEngineRun as s, SkillOptOptimizationMethodConfig as t, GepaRunnerCommand as u, DefaultProductionRewardHackingOptions as v, ExternalTextOptimizerResult as w, externalTextOptimizationMethod as x, defaultProductionGate as y, createReferenceEquivalenceJudge as z };
-//# sourceMappingURL=skillopt-optimization-method-BoC1Qccx.d.ts.map
+//# sourceMappingURL=skillopt-optimization-method-CrY0OG17.d.ts.map

package/dist/{skillopt-optimization-method-BoC1Qccx.d.ts.map → skillopt-optimization-method-CrY0OG17.d.ts.map}

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

package/dist/{skillopt-optimization-method-C_UrqZs2.js → skillopt-optimization-method-Donmq4sq.js}

@@ -1,5 +1,5 @@
 import { n as contentHash, t as canonicalJson } from "./verdict-cache-mZf5FEiY.js";
-import { C as optimizationTokenUsageFromSummary, K as runCampaign, L as assertGepaCandidatePopulationSummary, R as readGepaCandidatePopulationArtifact, S as costFromLedgerSummary, b as combineComparisonCosts, j as campaignBreakdown, k as surfaceContentHash, t as llmJudge } from "./llm-judge-DrzsVS5k.js";
+import { C as optimizationTokenUsageFromSummary, G as assertGepaCandidatePopulationSummary, K as readGepaCandidatePopulationArtifact, S as costFromLedgerSummary, b as combineComparisonCosts, et as runCampaign, k as surfaceContentHash, t as llmJudge, z as campaignBreakdown } from "./llm-judge-DWq1Ptco.js";
 import { _ as resolveExternalOptimizerCallbackLimits, b as createRunCostLedger, d as assertJsonValue, f as assertNoCredentialValues, g as removeCredentialEnvironment, h as isRecord, i as startExternalOptimizerModelProxy, m as isExternalTextCandidate, n as closeExternalOptimizerResources, p as isCandidateText, r as runWithCleanup, t as runExternalOptimizerProcess, u as assertExternalOptimizerModelBudget, v as resolveExternalOptimizerProcessLimits, x as fsCampaignStorage, y as safePathComponent } from "./external-optimizer-subprocess-DU1KM8yV.js";
 import { a as heldoutSignificance, o as pairHoldout } from "./power-preflight-DEw-uC7q.js";
 import { c as deepFreezeCanonicalJson } from "./types-BI4fT3HN.js";
@@ -2019,4 +2019,4 @@ function skillOptOptimizationMethod(config) {
 //#endregion
 export { externalTextOptimizationMethod as a, REFERENCE_EQUIVALENCE_INPUT_LIMITS as c, runReferenceEquivalenceJudge as d, composeGate as i, REFERENCE_EQUIVALENCE_JUDGE_VERSION as l, gepaOptimizationMethod as n, decodeExternalTextCandidate as o, heldOutGate as r, readExternalOptimizerObservationArtifact as s, skillOptOptimizationMethod as t, createReferenceEquivalenceJudge as u };
 
-//# sourceMappingURL=skillopt-optimization-method-C_UrqZs2.js.map
+//# sourceMappingURL=skillopt-optimization-method-Donmq4sq.js.map