@tangle-network/agent-eval 0.147.0 → 0.149.0

package/dist/{index-BjBjxiVv.d.ts → index-BCDyf_kT.d.ts}

@@ -8,11 +8,10 @@ import { A as LabeledScenarioWrite, D as LabeledScenarioSampleArgs, E as Labeled
 import { d as CompletionVerdict, f as CorrectnessChecker, h as ProducedState, n as BackendIntegrityReport, s as RuntimeEventLike, u as CompletionRequirement } from "./backend-integrity-Bz8nSrRE.js";
 import { g as PairedArmsComparison } from "./pre-registration-zFSLEiFU.js";
 import { d as PairedBootstrapResult } from "./paired-promotion-decision-CGzg0cI_.js";
-import { Ct as PlanCampaignRunOptions, Tt as CampaignStorage, xt as CampaignRunPlan } from "./provenance-LrOEOHQb.js";
-import "./skillopt-optimization-method-BoC1Qccx.js";
+import { Cn as CampaignStorage, xn as PlanCampaignRunOptions, yn as CampaignRunPlan } from "./provenance-DA-Pmyfv.js";
+import "./skillopt-optimization-method-ChCTN4FD.js";
 import "./promotion-policy-CewdjfCJ.js";
 import "./statistical-heldout-uxSpFEjm.js";
-import { D as LedgerHash, m as LedgerTrustedHeadRemoval, p as LedgerTrustedHead } from "./index-B8Ui1mr1.js";
 import { AgentProfile } from "@tangle-network/agent-interface";
 //#region src/campaign/analyst-surface.d.ts
 interface TraceAnalystScenario extends Scenario {
@@ -307,6 +306,14 @@ interface CrossSurfaceInteractionReport<TRow extends CrossSurfaceTaskRow = Cross
  */
 declare function analyzeCrossSurfaceInteractions<TRow extends CrossSurfaceTaskRow>(input: AnalyzeCrossSurfaceInteractionsInput<TRow>): CrossSurfaceInteractionReport<TRow>;
 //#endregion
+//#region src/campaign/search-ledger-errors.d.ts
+/** Base error for invalid search-ledger input or operations. */
+declare class SearchLedgerError extends ValidationError {}
+/** Error raised when durable search-ledger data fails an integrity check. */
+declare class SearchLedgerIntegrityError extends SearchLedgerError {}
+/** Error raised when an event identifier is reused with different content. */
+declare class SearchLedgerConflictError extends SearchLedgerError {}
+//#endregion
 //#region src/campaign/fixtures.d.ts
 type EvalFixtureValidationMode = 'vitest' | 'none';
 interface EvalFixtureFile {
@@ -944,359 +951,6 @@ interface CampaignBreakdown {
  *  on: mean score per judge dimension + per-scenario composite. */
 declare function campaignBreakdown<TArtifact, TScenario extends Scenario>(campaign: CampaignResult<TArtifact, TScenario>): CampaignBreakdown;
 //#endregion
-//#region src/campaign/search-ledger-errors.d.ts
-/** Base error for invalid search-ledger input or operations. */
-declare class SearchLedgerError extends ValidationError {}
-/** Error raised when durable search-ledger data fails an integrity check. */
-declare class SearchLedgerIntegrityError extends SearchLedgerError {}
-/** Error raised when an event identifier is reused with different content. */
-declare class SearchLedgerConflictError extends SearchLedgerError {}
-//#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/single-run-lock.d.ts
 /**
  * Single-run lock for evaluations that share one mutable environment.
@@ -1510,5 +1164,5 @@ declare function verifyCodeSurface(surface: CodeSurface, worktreeDir?: string):
  *  identity against the checkout at `worktreeRef`. */
 declare function resolveWorktreePath(surface: CodeSurface, worktreeDir?: string): string;
 //#endregion
-export { SearchPlannedEvent as $, CrossSurfacePairEvidence as $n, RunProfileMatrixResult as $t, SearchAccountingAudit as A, CrossSurfaceAdditionRejectionReason as An, ProfileMatrixSegmentResult as At, SearchCostAccounting as B, CrossSurfaceComponentEvidence as Bn, ScoreboardRow as Bt, surfaceHash as C, discoverEvalFixtures as Cn, tangleTracesRoot as Ct, FileSearchLedger as D, analyzeCrossSurfaceInteractions as Dn, ProfileMatrixCoverage as Dt, acquireSingleRunLock as E, planEvalFixtureRun as En, FinalizedProfileMatrixResult as Et, SearchCandidateRegisteredEvent as F, CrossSurfaceCandidateComparison as Fn, runProfileMatrixSegment as Ft, SearchLedgerEvent as G, CrossSurfaceIneligibilityReason as Gn, renderScoreboardMarkdown as Gt, SearchLedger as H, CrossSurfaceDistribution as Hn, UserStory as Ht, SearchCandidateSlot as I, CrossSurfaceCandidateEvidence as In, PlaybackContext as It, SearchLedgerTrustedHeadMode as J, CrossSurfaceInteractionPath as Jn, userStoryScoreboard as Jt, SearchLedgerHash as K, CrossSurfaceInteractionAwareSelection as Kn, scoreUserStory as Kt, SearchCandidateSlotClosedEvent as L, CrossSurfaceCandidateOutcome as Ln, PlaybackDriver as Lt, SearchAttemptAccounting as M, CrossSurfaceBestSingleSelection as Mn, SegmentedProfileMatrixError as Mt, SearchCandidateDecidedEvent as N, CrossSurfaceBootstrapPolicy as Nn, createProfileMatrixPlan as Nt, OpenSearchLedgerOptions as O, AnalyzeCrossSurfaceInteractionsInput as On, ProfileMatrixPlan as Ot, SearchCandidateLineage as P, CrossSurfaceCandidate as Pn, finalizeProfileMatrix as Pt, SearchPlan as Q, CrossSurfacePairCompatibility as Qn, RunProfileMatrixOptions as Qt, SearchCandidateSurface as R, CrossSurfaceCandidateSummary as Rn, PlaybackStep as Rt, surfaceContentHash as S, PlanEvalFixtureRunOptions as Sn, resolveRunDir as St, SingleRunLockOptions as T, loadEvalFixtureScenarios as Tn, FinalizeProfileMatrixOptions as Tt, SearchLedgerAppendResult as U, CrossSurfaceEligibility as Un, UserStoryVerdict as Ut, SearchFailureReason as V, CrossSurfaceCompositionStep as Vn, ScoreboardSummary as Vt, SearchLedgerEntry as W, CrossSurfaceEvidenceBreakdown as Wn, makePlaybackDispatch as Wt, SearchOperationKind as X, CrossSurfaceInteractionTask as Xn, ProfileMatrixError as Xt, SearchModelIdentity as Y, CrossSurfaceInteractionReport as Yn, ProfileDispatchFn as Yt, SearchOperationRecordedEvent as Z, CrossSurfaceNaiveStackSelection as Zn, ProfileSummary as Zt, assertCodeSurfaceIdentity as _, EvalFixtureLoadOptions as _n, compareRankKeys as _t, WorktreeAdapterError as a, LabeledScenarioStoreError as an, CrossSurfaceSelections as ar, SearchSurfaceKind as at, componentSurfaceIdentityMaterial as b, EvalFixtureValidationMode as bn, scoreDiscrimination as bt, verifyCodeSurface as c, RolloutCall as cn, TraceAnalystArtifact as cr, SearchTokenAccounting as ct, PhoenixEvaluationResultLike as d, classifyUngroundedLiterals as dn, traceAnalystQualityJudge as dr, SearchLedgerConflictError as dt, ScenarioRollup as en, CrossSurfacePairIncompatibilityReason as er, SearchPlannedOperation as et, PhoenixEvaluatorLike as f, rolloutArgumentDiff as fn, SearchLedgerError as ft, isTransientTransportFailure as g, EvalFixtureFile as gn, campaignMeanComposite as gt, TransientFailureOptions as h, EvalFixture as hn, campaignBreakdown as ht, WorktreeAdapter as i, FsLabeledScenarioStoreOptions as in, CrossSurfaceSelectionPolicy as ir, SearchSurfaceEvidence as it, SearchArtifactRef as j, CrossSurfaceAttemptCompleteness as jn, RunProfileMatrixSegmentOptions as jt, SEARCH_LEDGER_SCHEMA as k, CrossSurfaceAdditionDecision as kn, ProfileMatrixRow as kt, AutoevalsScoreLike as l, ScoredRollout as ln, TraceAnalystScenario as lr, openSearchLedger as lt, phoenixEvaluatorJudge as m, neutralizationGate as mn, CampaignBreakdown as mt, GitWorktreeAdapterOptions as n, neutralizeText as nn, CrossSurfaceRankedSingle as nr, SearchSourceRef as nt, gitWorktreeAdapter as o, RolloutArgumentDiff as on, CrossSurfaceTaskRow as or, SearchTaskAttemptedEvent as ot, autoevalsScorerJudge as p, NeutralizationGateOptions as pn, SearchLedgerIntegrityError as pt, SearchLedgerReplay as q, CrossSurfaceInteractionEffect as qn, scoreboardSummary as qt, Worktree as r, FsLabeledScenarioStore as rn, CrossSurfaceRelativeCost as rr, SearchSurfaceEffect as rt, resolveWorktreePath as s, RolloutArgumentDiffOptions as sn, BuildTraceAnalystSurfaceDispatchOptions as sr, SearchTaskOutcome as st, CodeSurfaceVerification as t, runProfileMatrix as tn, CrossSurfacePairwiseEntry as tr, SearchPlannedTask as tt, AutoevalsScorerLike as u, UngroundedLiteralReport as un, buildTraceAnalystSurfaceDispatch as ur, validateSearchLedgerEvent as ut, assertComponentSurface as v, EvalFixtureRunPlan as vn, DiscriminationScore as vt, SingleRunLock as w, loadEvalFixture as wn, CreateProfileMatrixPlanOptions as wt, renderSurfaceDiff as x, LoadEvalFixtureScenariosOptions as xn, selectDiscriminative as xt, codeSurfaceIdentityMaterial as y, EvalFixtureScenario as yn, ScenarioSignal as yt, SearchCompletedEvent as z, CrossSurfaceComponent as zn, ScoreboardRenderOptions as zt };
-//# sourceMappingURL=index-BjBjxiVv.d.ts.map
+export { ScoreboardRow as $, CrossSurfaceCandidateOutcome as $t, compareRankKeys as A, EvalFixtureLoadOptions as At, ProfileMatrixCoverage as B, SearchLedgerConflictError as Bt, surfaceHash as C, BuildTraceAnalystSurfaceDispatchOptions as Cn, UngroundedLiteralReport as Ct, CampaignBreakdown as D, traceAnalystQualityJudge as Dn, neutralizationGate as Dt, acquireSingleRunLock as E, buildTraceAnalystSurfaceDispatch as En, NeutralizationGateOptions as Et, resolveRunDir as F, PlanEvalFixtureRunOptions as Ft, SegmentedProfileMatrixError as G, CrossSurfaceAdditionDecision as Gt, ProfileMatrixRow as H, SearchLedgerIntegrityError as Ht, tangleTracesRoot as I, discoverEvalFixtures as It, runProfileMatrixSegment as J, CrossSurfaceBestSingleSelection as Jt, createProfileMatrixPlan as K, CrossSurfaceAdditionRejectionReason as Kt, CreateProfileMatrixPlanOptions as L, loadEvalFixture as Lt, ScenarioSignal as M, EvalFixtureScenario as Mt, scoreDiscrimination as N, EvalFixtureValidationMode as Nt, campaignBreakdown as O, EvalFixture as Ot, selectDiscriminative as P, LoadEvalFixtureScenariosOptions as Pt, ScoreboardRenderOptions as Q, CrossSurfaceCandidateEvidence as Qt, FinalizeProfileMatrixOptions as R, loadEvalFixtureScenarios as Rt, surfaceContentHash as S, CrossSurfaceTaskRow as Sn, ScoredRollout as St, SingleRunLockOptions as T, TraceAnalystScenario as Tn, rolloutArgumentDiff as Tt, ProfileMatrixSegmentResult as U, analyzeCrossSurfaceInteractions as Ut, ProfileMatrixPlan as V, SearchLedgerError as Vt, RunProfileMatrixSegmentOptions as W, AnalyzeCrossSurfaceInteractionsInput as Wt, PlaybackDriver as X, CrossSurfaceCandidate as Xt, PlaybackContext as Y, CrossSurfaceBootstrapPolicy as Yt, PlaybackStep as Z, CrossSurfaceCandidateComparison as Zt, assertCodeSurfaceIdentity as _, CrossSurfacePairwiseEntry as _n, FsLabeledScenarioStoreOptions as _t, WorktreeAdapterError as a, CrossSurfaceEligibility as an, scoreUserStory as at, componentSurfaceIdentityMaterial as b, CrossSurfaceSelectionPolicy as bn, RolloutArgumentDiffOptions as bt, verifyCodeSurface as c, CrossSurfaceInteractionAwareSelection as cn, ProfileDispatchFn as ct, PhoenixEvaluationResultLike as d, CrossSurfaceInteractionReport as dn, RunProfileMatrixOptions as dt, CrossSurfaceCandidateSummary as en, ScoreboardSummary as et, PhoenixEvaluatorLike as f, CrossSurfaceInteractionTask as fn, RunProfileMatrixResult as ft, isTransientTransportFailure as g, CrossSurfacePairIncompatibilityReason as gn, FsLabeledScenarioStore as gt, TransientFailureOptions as h, CrossSurfacePairEvidence as hn, neutralizeText as ht, WorktreeAdapter as i, CrossSurfaceDistribution as in, renderScoreboardMarkdown as it, DiscriminationScore as j, EvalFixtureRunPlan as jt, campaignMeanComposite as k, EvalFixtureFile as kt, AutoevalsScoreLike as l, CrossSurfaceInteractionEffect as ln, ProfileMatrixError as lt, phoenixEvaluatorJudge as m, CrossSurfacePairCompatibility as mn, runProfileMatrix as mt, GitWorktreeAdapterOptions as n, CrossSurfaceComponentEvidence as nn, UserStoryVerdict as nt, gitWorktreeAdapter as o, CrossSurfaceEvidenceBreakdown as on, scoreboardSummary as ot, autoevalsScorerJudge as p, CrossSurfaceNaiveStackSelection as pn, ScenarioRollup as pt, finalizeProfileMatrix as q, CrossSurfaceAttemptCompleteness as qt, Worktree as r, CrossSurfaceCompositionStep as rn, makePlaybackDispatch as rt, resolveWorktreePath as s, CrossSurfaceIneligibilityReason as sn, userStoryScoreboard as st, CodeSurfaceVerification as t, CrossSurfaceComponent as tn, UserStory as tt, AutoevalsScorerLike as u, CrossSurfaceInteractionPath as un, ProfileSummary as ut, assertComponentSurface as v, CrossSurfaceRankedSingle as vn, LabeledScenarioStoreError as vt, SingleRunLock as w, TraceAnalystArtifact as wn, classifyUngroundedLiterals as wt, renderSurfaceDiff as x, CrossSurfaceSelections as xn, RolloutCall as xt, codeSurfaceIdentityMaterial as y, CrossSurfaceRelativeCost as yn, RolloutArgumentDiff as yt, FinalizedProfileMatrixResult as z, planEvalFixtureRun as zt };
+//# sourceMappingURL=index-BCDyf_kT.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index-BCDyf_kT.d.ts","names":[],"sources":["../src/campaign/analyst-surface.ts","../src/campaign/cross-surface-types.ts","../src/campaign/cross-surface-interaction.ts","../src/campaign/search-ledger-errors.ts","../src/campaign/fixtures.ts","../src/campaign/gates/neutralization-gate.ts","../src/campaign/grounded-reflection.ts","../src/campaign/labeled-store/fs-adapter.ts","../src/campaign/neutralize.ts","../src/campaign/presets/run-profile-matrix.ts","../src/campaign/presets/playback.ts","../src/campaign/presets/segmented-profile-matrix.ts","../src/campaign/run-dir.ts","../src/campaign/scenario-selection.ts","../src/campaign/score-utils.ts","../src/campaign/single-run-lock.ts","../src/campaign/surface-identity.ts","../src/campaign/transient-failure.ts","../src/campaign/upstream-evaluators.ts","../src/campaign/worktree/index.ts"],"mappings":"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"}

package/dist/{index-gtjtfLEJ.d.ts → index-aHDnhBC7.d.ts}

@@ -1,4 +1,4 @@
-import { o as Severity } from "./multi-layer-verifier-DIguZc8Z.js";
+import { o as Severity } from "./multi-layer-verifier-BUaQ4C17.js";
 import { b as CustomTokenPricing, c as CostLedgerHandle } from "./cost-ledger-DbQdN3nO.js";
 import { A as LlmClientOptions } from "./types-DOhGq4S1.js";
 import { i as AnalystFinding, n as AnalystContext } from "./types-BohHewKK.js";
@@ -449,4 +449,4 @@ declare const KNOWLEDGE_POISONING_KIND_SPEC: TraceAnalystDefinition;
 declare const DEFAULT_TRACE_ANALYST_KINDS: readonly TraceAnalystDefinition[];
 //#endregion
 export { SemanticConceptJudgeInput as A, parseFindingSubject as C, ConceptFinding as D, createDspyRlmTraceEngine as E, RunScoreWeights as F, aggregateRunScore as I, clamp01 as L, SemanticConceptJudgeResult as M, runSemanticConceptJudge as N, ConceptSpec as O, RunScore as P, findingSubjectGrammarPromptFor as S, DspyRlmTraceEngineOptions as T, FINDING_SUBJECT_SYNTAX as _, FAILURE_MODE_KIND_SPEC as a, FindingSubjectStringSchema as b, emitControlIntegrityFindings as c, FindingsStore as d, PersistedFinding as f, FINDING_SUBJECT_KINDS as g, FINDING_SUBJECT_GRAMMAR_PROMPT as h, IMPROVEMENT_KIND_SPEC as i, SemanticConceptJudgeOptions as j, SEMANTIC_CONCEPT_JUDGE_VERSION as k, DiffPolicy as l, diffFindings as m, KNOWLEDGE_POISONING_KIND_SPEC as n, CONTROL_INTEGRITY_ANALYST as o, defaultIsMaterial as p, KNOWLEDGE_GAP_KIND_SPEC as r, ControlIntegrityAnalyst as s, DEFAULT_TRACE_ANALYST_KINDS as t, FindingsDiff as u, FindingSubject as v, renderFindingSubject as w, KIND_EXPECTED_SUBJECTS as x, FindingSubjectKind as y };
-//# sourceMappingURL=index-gtjtfLEJ.d.ts.map
+//# sourceMappingURL=index-aHDnhBC7.d.ts.map

package/dist/{index-gtjtfLEJ.d.ts.map → index-aHDnhBC7.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"index-gtjtfLEJ.d.ts","names":[],"sources":["../src/run-score.ts","../src/semantic-concept-judge.ts","../src/analyst/trace-tool-callback.ts","../src/analyst/dspy-rlm-engine.ts","../src/analyst/finding-subject.ts","../src/analyst/findings-store.ts","../src/analyst/kinds/control-integrity.ts","../src/analyst/kinds/failure-mode.ts","../src/analyst/kinds/improvement.ts","../src/analyst/kinds/knowledge-gap.ts","../src/analyst/kinds/knowledge-poisoning.ts","../src/analyst/kinds/index.ts"],"mappings":";;;;;;;;;;;UAAiB;EACf;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;UAGe;EACf;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;iBAiBc,kBAAkB,OAAO,UAAU,UAAS,QAAQ;iBAiBpD,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;KCLZ;UAEK;EACf;;EAEA;;EAEA;;EAEA,aAAa;;UAGE;EACf;EACA;;EAEA;EACA;EACA,UAAU;;UAGK;;EAEf;;EAEA;;EAEA,aAAa;IAAQ;IAAc;;;EAEnC,kBAAkB;;EAElB;EACA;;UAGe;EACf;EACA;;EAEA;EACA;EACA;EACA,UAAU;EACV;EACA;EACA;;EAEA;EACA;;;;;;;;KASU;UAQK;;EAEf;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA,MAAM;EACN,aAAa;EACb;EACA,WAAW;EACX,SAAS;;;;;;EAMT,iBAAiB;;EAEjB,oBAAoB,QAAQ,OAAO;;cAKxB;;;;;;iBAkGS,wBACpB,OAAO,2BACP,UAAS,8BACR,QAAQ;;;KC5OC,0BAA0B;;;UCoBrB;;EAEf,MAAM;;EAEN;;EAEA,kBAAkB,aAAa;EAC/B;;EAEA,UAAU;;EAEV;;EAEA;;;;;;EAMA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA,kBAAkB,QAAQ;;EAE1B;;;;;;;;;;EAUA;;EAEA,SAAS;;EAET;;;iBAIc,yBAAyB,SAAS,4BAA4B;;;;;;;;;;KCvClE;EAEN;EAAwB;EAAc;;EACtC;EAAyB;;EACzB;EAAuB;;EACvB;EAAyB;;EAGzB;EAAuB;;EACvB;EAAe;;EACf;EAAkB;EAAc;;EAChC;EAAkB;;EAClB;EAAa;EAAgB;;EAC7B;EAAc;;EACd;EAAkB;;EAClB;EAAkB;;EAClB;EAAwB;;EACxB;EAAuB;;EACvB;EAAc;;EACd;EAAa;EAAgB;;EAC7B;EAAgB;;EAChB;EAAqB;;EACrB;EAAuB;;EAEvB;EAA4B;;EAC5B;EAA2B;;EAE3B;EAAiB;;KAEX,qBAAqB;cAEpB,uBAAuB,cAAc;;;;;;;;;;;;;;;;;iBA2ClC,oBAAoB,iCAAiC;;;;;;;iBAoHrD,qBAAqB,GAAG;;;;;;;;;;cA8D3B,wBAAwB,SAAS,OAAO;cA0DxC;;;;;;;;;cAYA,wBAAwB,eAAe,cAAc;;iBAqElD,+BAA+B;;;;;;;;;;;;cAmBlC,4BAA0B,EAAA;;;;;;;;UC1atB,yBAAyB;EACxC;;cAGW;WAGiB;mBAFX;EAEjB,YAA4B;EAItB,OAAO,eAAe,UAAU,mBAAmB;;EAQzD,WAAW;;EAkBX,QAAQ,gBAAgB;;UAOT;;EAEf,UAAU;;EAEV,aAAa;;EAEb,WAAW;;;;;EAKX,SAAS;IAAQ,UAAU;IAAkB,SAAS;;;UAGvC;;;;;;;;EAQf,cAAc,UAAU,gBAAgB,SAAS;;;;;;iBAOnC,kBAAkB,GAAG,gBAAgB,GAAG;;;;;iBAWxC,aACd,UAAU,oBACV,SAAS,oBACT,SAAQ,aACP;;;;iBC7Fa,6BACd,OAAO,uBAAuB,mBAC9B,qBACC;;cA4BU,mCACA,oBAAoB,uBAAuB;WAE7C;WACA;WAEA;WACA;IAAS;IAAgC;;WACzC;WACA;aACP;aACA;;EAGI,QACJ,OAAO,uBAAuB,mBAC9B,KAAK,iBACJ,QAAQ;;cAUA,2BAAyB;;;cCHzB,wBAAwB;;;cC3BxB,uBAAuB;;;cCGvB,yBAAyB;;;cCPzB,+BAA+B;;;;;;;;;;;;cCP/B,sCAAsC"}
+{"version":3,"file":"index-aHDnhBC7.d.ts","names":[],"sources":["../src/run-score.ts","../src/semantic-concept-judge.ts","../src/analyst/trace-tool-callback.ts","../src/analyst/dspy-rlm-engine.ts","../src/analyst/finding-subject.ts","../src/analyst/findings-store.ts","../src/analyst/kinds/control-integrity.ts","../src/analyst/kinds/failure-mode.ts","../src/analyst/kinds/improvement.ts","../src/analyst/kinds/knowledge-gap.ts","../src/analyst/kinds/knowledge-poisoning.ts","../src/analyst/kinds/index.ts"],"mappings":";;;;;;;;;;;UAAiB;EACf;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;UAGe;EACf;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;iBAiBc,kBAAkB,OAAO,UAAU,UAAS,QAAQ;iBAiBpD,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;KCLZ;UAEK;EACf;;EAEA;;EAEA;;EAEA,aAAa;;UAGE;EACf;EACA;;EAEA;EACA;EACA,UAAU;;UAGK;;EAEf;;EAEA;;EAEA,aAAa;IAAQ;IAAc;;;EAEnC,kBAAkB;;EAElB;EACA;;UAGe;EACf;EACA;;EAEA;EACA;EACA;EACA,UAAU;EACV;EACA;EACA;;EAEA;EACA;;;;;;;;KASU;UAQK;;EAEf;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA,MAAM;EACN,aAAa;EACb;EACA,WAAW;EACX,SAAS;;;;;;EAMT,iBAAiB;;EAEjB,oBAAoB,QAAQ,OAAO;;cAKxB;;;;;;iBAkGS,wBACpB,OAAO,2BACP,UAAS,8BACR,QAAQ;;;KC5OC,0BAA0B;;;UCoBrB;;EAEf,MAAM;;EAEN;;EAEA,kBAAkB,aAAa;EAC/B;;EAEA,UAAU;;EAEV;;EAEA;;;;;;EAMA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA,kBAAkB,QAAQ;;EAE1B;;;;;;;;;;EAUA;;EAEA,SAAS;;EAET;;;iBAIc,yBAAyB,SAAS,4BAA4B;;;;;;;;;;KCvClE;EAEN;EAAwB;EAAc;;EACtC;EAAyB;;EACzB;EAAuB;;EACvB;EAAyB;;EAGzB;EAAuB;;EACvB;EAAe;;EACf;EAAkB;EAAc;;EAChC;EAAkB;;EAClB;EAAa;EAAgB;;EAC7B;EAAc;;EACd;EAAkB;;EAClB;EAAkB;;EAClB;EAAwB;;EACxB;EAAuB;;EACvB;EAAc;;EACd;EAAa;EAAgB;;EAC7B;EAAgB;;EAChB;EAAqB;;EACrB;EAAuB;;EAEvB;EAA4B;;EAC5B;EAA2B;;EAE3B;EAAiB;;KAEX,qBAAqB;cAEpB,uBAAuB,cAAc;;;;;;;;;;;;;;;;;iBA2ClC,oBAAoB,iCAAiC;;;;;;;iBAoHrD,qBAAqB,GAAG;;;;;;;;;;cA8D3B,wBAAwB,SAAS,OAAO;cA0DxC;;;;;;;;;cAYA,wBAAwB,eAAe,cAAc;;iBAqElD,+BAA+B;;;;;;;;;;;;cAmBlC,4BAA0B,EAAA;;;;;;;;UC1atB,yBAAyB;EACxC;;cAGW;WAGiB;mBAFX;EAEjB,YAA4B;EAItB,OAAO,eAAe,UAAU,mBAAmB;;EAQzD,WAAW;;EAkBX,QAAQ,gBAAgB;;UAOT;;EAEf,UAAU;;EAEV,aAAa;;EAEb,WAAW;;;;;EAKX,SAAS;IAAQ,UAAU;IAAkB,SAAS;;;UAGvC;;;;;;;;EAQf,cAAc,UAAU,gBAAgB,SAAS;;;;;;iBAOnC,kBAAkB,GAAG,gBAAgB,GAAG;;;;;iBAWxC,aACd,UAAU,oBACV,SAAS,oBACT,SAAQ,aACP;;;;iBC7Fa,6BACd,OAAO,uBAAuB,mBAC9B,qBACC;;cA4BU,mCACA,oBAAoB,uBAAuB;WAE7C;WACA;WAEA;WACA;IAAS;IAAgC;;WACzC;WACA;aACP;aACA;;EAGI,QACJ,OAAO,uBAAuB,mBAC9B,KAAK,iBACJ,QAAQ;;cAUA,2BAAyB;;;cCHzB,wBAAwB;;;cC3BxB,uBAAuB;;;cCGvB,yBAAyB;;;cCPzB,+BAA+B;;;;;;;;;;;;cCP/B,sCAAsC"}

package/dist/index.d.ts

@@ -1,8 +1,8 @@
 import { a as JudgeError, c as ValidationError, i as ConfigError, n as AgentEvalErrorCode, s as NotFoundError, t as AgentEvalError } from "./errors-DEE6u6ot.js";
 import { C as verifyAgentProfileCell, h as agentProfileCellKey, i as AgentProfileCellInput, l as AgentProfileJson, m as agentProfileCellHashMaterial, p as AgentProfileSourceInput, r as AgentProfileCell, s as AgentProfileDimensionValue, t as AGENT_PROFILE_KINDS, v as buildAgentProfileCell, x as toAgentProfileJson, y as groupRunsByAgentProfileCell } from "./agent-profile-cell-BkcRDikH.js";
 import { C as defineEquivalenceCheck, S as buildEquivalenceRecord, _ as StrategyChecker, a as CheckerIdentity, b as VerificationStrategyProfile, c as EquivalenceCheckDefinition, d as EquivalenceCheckerInput, f as EquivalenceCheckerResult, g as EquivalenceRecord, h as EquivalenceProtocolError, i as equivalenceVerdict, l as EquivalenceCheckSpec, m as EquivalenceObligationStatus, n as VerdictCertification, o as CheckerOutcome, p as EquivalenceObligation, r as certificationEvidenceDigest, s as EquivalenceArm, t as DefaultVerdict, u as EquivalenceChecker, v as VERIFICATION_STRATEGIES, w as runEquivalenceCheck, x as VerificationStrategySource, y as VERIFICATION_STRATEGY_SOURCES } from "./verdict-E4eRNf7-.js";
-import { a as MultiLayerVerifier, c as VerifyOptions, i as LayerStatus, l as gradeSemanticStatus, n as Layer, o as Severity, r as LayerResult, s as VerificationReport, t as Finding } from "./multi-layer-verifier-DIguZc8Z.js";
-import { A as SemanticConceptJudgeInput, D as ConceptFinding, E as createDspyRlmTraceEngine, F as RunScoreWeights, I as aggregateRunScore, L as clamp01, M as SemanticConceptJudgeResult, N as runSemanticConceptJudge, O as ConceptSpec, P as RunScore, T as DspyRlmTraceEngineOptions, a as FAILURE_MODE_KIND_SPEC, d as FindingsStore, f as PersistedFinding, j as SemanticConceptJudgeOptions, k as SEMANTIC_CONCEPT_JUDGE_VERSION, l as DiffPolicy, m as diffFindings, t as DEFAULT_TRACE_ANALYST_KINDS, u as FindingsDiff, v as FindingSubject, y as FindingSubjectKind } from "./index-gtjtfLEJ.js";
+import { a as MultiLayerVerifier, c as VerifyOptions, i as LayerStatus, l as gradeSemanticStatus, n as Layer, o as Severity, r as LayerResult, s as VerificationReport, t as Finding } from "./multi-layer-verifier-BUaQ4C17.js";
+import { A as SemanticConceptJudgeInput, D as ConceptFinding, E as createDspyRlmTraceEngine, F as RunScoreWeights, I as aggregateRunScore, L as clamp01, M as SemanticConceptJudgeResult, N as runSemanticConceptJudge, O as ConceptSpec, P as RunScore, T as DspyRlmTraceEngineOptions, a as FAILURE_MODE_KIND_SPEC, d as FindingsStore, f as PersistedFinding, j as SemanticConceptJudgeOptions, k as SEMANTIC_CONCEPT_JUDGE_VERSION, l as DiffPolicy, m as diffFindings, t as DEFAULT_TRACE_ANALYST_KINDS, u as FindingsDiff, v as FindingSubject, y as FindingSubjectKind } from "./index-aHDnhBC7.js";
 import { C as PendingCostCall, D as costForUsage, E as costForTokenPricing, O as modelPriceKey, S as PaidCallResult, T as RunPaidCallInput, _ as CostReservationExceededError, a as CostChannel, b as CustomTokenPricing, c as CostLedgerHandle, d as CostLedgerPersistenceError, f as CostLedgerSummary, g as CostReceiptInput, h as CostReceiptCaptureError, i as CostCeilingReachedError, l as CostLedgerOptions, m as CostReceipt, n as CostAccountingIncompleteError, o as CostLedger, p as CostProvenance, r as CostCallConflictError, s as CostLedgerFilter, t as ChannelRollup, u as CostLedgerPersistence, v as CostResult, w as PendingCostCallView, x as MaximumCharge, y as CostUsage } from "./cost-ledger-DbQdN3nO.js";
 import { C as TraceEvent, O as isToolSpan, S as ToolSpan, T as isLlmSpan, _ as Span, a as FAILURE_CLASSES, c as JudgeSpan, f as Run, h as RunStatus, l as LlmSpan, n as BudgetLedgerEntry, o as FailureClass, r as BudgetSpec, s as GenericSpan, t as Artifact, w as isJudgeSpan } from "./schema-BtVldJ3T.js";
 import { _ as validateRunRecord, a as RunRecord, c as RunTaskFailure, d as UNKNOWN_MODEL, f as isRunRecord, g as runTaskScore, h as roundTripRunRecord, i as RunOutcome, l as RunTerminalOutcome, m as parseRunRecordSafe, n as RunCostProvenance, o as RunRecordValidationError, p as modelHasSnapshot, r as RunJudgeMetadata, s as RunSplitTag, t as JudgeScoresRecord, u as RunTokenUsage } from "./run-record-DVV82Gwh.js";
@@ -35,10 +35,10 @@ import { o as InsightReport } from "./insight-report-BeT8KCgI.js";
 import { C as analyzeRuns, b as AnalyzeRunsOptions, d as RawAnalystFinding, i as TraceAnalysisEngineResult, n as TraceAnalysisEngine } from "./engine-CIy18RTX.js";
 import { o as MintedRolloutLine } from "./schema-Cef2cFmb.js";
 import { i as BenchmarkEvaluation } from "./types-ColZlZtc.js";
-import { A as RedTeamCategory, B as CanaryReport, F as scoreRedTeamOutput, I as CanaryAlert, L as CanaryEvaluation, M as RedTeamReport, N as redTeamDataset, Nt as LlmJudgeOptions, O as DEFAULT_RED_TEAM_CORPUS, P as redTeamReport, Pt as llmJudge, R as CanaryKind, V as runCanaries, bt as runCampaign, j as RedTeamFinding, k as RedTeamCase, vt as CampaignCellFailureReceipt, yt as RunCampaignOptions, z as CanaryOptions } from "./provenance-LrOEOHQb.js";
+import { A as RedTeamCategory, B as CanaryReport, F as scoreRedTeamOutput, I as CanaryAlert, L as CanaryEvaluation, M as RedTeamReport, Mn as llmJudge, N as redTeamDataset, O as DEFAULT_RED_TEAM_CORPUS, P as redTeamReport, R as CanaryKind, V as runCanaries, _n as RunCampaignOptions, gn as CampaignCellFailureReceipt, j as RedTeamFinding, jn as LlmJudgeOptions, k as RedTeamCase, vn as runCampaign, z as CanaryOptions } from "./provenance-DA-Pmyfv.js";
 import { a as paretoFrontier, i as dominates, n as Objective, r as ParetoResult } from "./pareto-BqNW3LJR.js";
 import { n as SandboxDriver } from "./sandbox-harness-BlSOu4LX.js";
-import { a as DefinedAgentEval, c as SelfImproveOptions, f as selfImprove, i as DefineAgentEvalOptions, o as defineAgentEval, u as SelfImproveResult } from "./define-agent-eval-D52ClbX2.js";
+import { a as DefinedAgentEval, c as SelfImproveOptions, f as selfImprove, i as DefineAgentEvalOptions, o as defineAgentEval, u as SelfImproveResult } from "./define-agent-eval-BWuk2O_N.js";
 import { a as PairedEvalueStep, c as SequentialDecision, i as PairedEvalueSequence, l as evaluateInterimReleaseConfidence, n as InterimReleaseConfidenceInput, r as PairedEvalueOptions, t as InterimReleaseConfidence, u as pairedEvalueSequence } from "./sequential-BhsrMupG.js";
 import { n as TrajectoryStep, r as buildTrajectory, t as Trajectory } from "./trajectory-YC15QDYQ.js";
 import { a as runCounterfactual, i as CounterfactualRunner, n as CounterfactualMutation, r as CounterfactualResult, t as CounterfactualContext } from "./counterfactual--bpysZF0.js";

package/dist/index.js

@@ -1,7 +1,7 @@
 import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
 import { i as JudgeError, o as NotFoundError, r as ConfigError, s as ValidationError, t as AgentEvalError } from "./errors-Dngq5h35.js";
 import { r as hashJson, t as canonicalize } from "./pre-registration-DakwTRXk.js";
-import { a as CODING_HARNESSES, c as agentProfileId, d as harnessAxisOf, i as verifyCompletion, l as agentProfileModelId, n as completionVerdict, o as HARNESS_NATIVE_MODEL, r as createLlmCorrectnessChecker, s as agentProfileHash, t as extractProducedState, u as expandProfileAxes } from "./produced-state-Dtx60bUQ.js";
+import { a as CODING_HARNESSES, c as agentProfileId, d as harnessAxisOf, i as verifyCompletion, l as agentProfileModelId, n as completionVerdict, o as HARNESS_NATIVE_MODEL, r as createLlmCorrectnessChecker, s as agentProfileHash, t as extractProducedState, u as expandProfileAxes } from "./produced-state-C0oJ4vr-.js";
 import { AGENT_PROFILE_KINDS, agentProfileCellHashMaterial, agentProfileCellKey, buildAgentProfileCell, groupRunsByAgentProfileCell, toAgentProfileJson, verifyAgentProfileCell } from "./profile-cell.js";
 import { c as mulberry32 } from "./internal-BDHPCnjk.js";
 import { a as spearmanR, i as ranks, n as partialCredit, o as weightedComposite, r as pearsonR, s as weightedMean, t as confidenceInterval } from "./descriptive-B5MwKfbf.js";
@@ -15,12 +15,12 @@ import { t as eProcess } from "./sequential-eprocess-CbUt2htw.js";
 import { n as iqr, r as welchsTTest } from "./baseline-BhPRQBVn.js";
 import { i as isLlmSpan, r as isJudgeSpan, s as isToolSpan, t as FAILURE_CLASSES } from "./schema-CRhEY1SO.js";
 import { a as judgeSpans, c as runsForScenario, n as argHash } from "./query-Di7eEQ79.js";
-import { i as analyzeRuns, o as checkCanaries, r as selfImprove, t as defineAgentEval } from "./define-agent-eval-BqWFz3sK.js";
+import { i as analyzeRuns, o as checkCanaries, r as selfImprove, t as defineAgentEval } from "./define-agent-eval-CvZQW4u9.js";
 import { r as observedSplitScore, t as isRealnessGated } from "./reward-nw2xZGZG.js";
 import { a as parseRunRecordSafe, c as validateRunRecord, i as modelHasSnapshot, n as UNKNOWN_MODEL, o as roundTripRunRecord, r as isRunRecord, s as runTaskScore, t as RunRecordValidationError } from "./run-record-D2lDdSAz.js";
 import { a as summaryTable, n as gainHistogram, r as paretoChart } from "./summary-report-Blysd6Z2.js";
 import { n as contentHash, r as fileVerdictCache, t as canonicalJson } from "./verdict-cache-mZf5FEiY.js";
-import { B as DEFAULT_RED_TEAM_CORPUS, F as parseReflectionResponse, H as redTeamReport, K as runCampaign, P as buildReflectionPrompt, Q as summarizeBackendIntegrity, U as scoreRedTeamOutput, V as redTeamDataset, W as runCanaries, X as BackendIntegrityError, Z as assertRealBackend, _ as paretoFrontier, g as dominates, k as surfaceContentHash, t as llmJudge } from "./llm-judge-DrzsVS5k.js";
+import { H as buildReflectionPrompt, J as DEFAULT_RED_TEAM_CORPUS, Q as runCanaries, U as parseReflectionResponse, X as redTeamReport, Y as redTeamDataset, Z as scoreRedTeamOutput, _ as paretoFrontier, at as assertRealBackend, et as runCampaign, g as dominates, it as BackendIntegrityError, k as surfaceContentHash, ot as summarizeBackendIntegrity, t as llmJudge } from "./llm-judge-DWq1Ptco.js";
 import { a as resolveModelPricing, i as isModelPriced, n as estimateCost, r as estimateTokens, t as MODEL_PRICING } from "./metrics-Qv-cpptD.js";
 import { a as CostLedgerPersistenceError, c as costForTokenPricing, i as CostLedger, l as costForUsage, n as CostCallConflictError, o as CostReceiptCaptureError, r as CostCeilingReachedError, s as CostReservationExceededError, t as CostAccountingIncompleteError, u as modelPriceKey } from "./cost-ledger-B1qx30B4.js";
 import { n as REDACTION_VERSION, r as redactString, t as DEFAULT_REDACTION_RULES } from "./redact-7Aq1ukl-.js";
@@ -6293,11 +6293,9 @@ function softFail(expectedConcepts, start, error) {
 /**
 * Multi-layer verifier — ordered pipeline of verification layers.
 *
-* Different contract from {@link JudgeRunner} (which runs parallel
-* specs against a sandbox). MultiLayerVerifier is a DAG of layers
-* (install → typecheck → build → lint → serve → semantic → …) with
-* dependency-based skip, per-layer findings, soft-fail semantics, and
-* an aggregated `blendedScore` across all passed layers.
+* A DAG of layers (install → typecheck → build → lint → serve → semantic → …)
+* with dependency-based skip, per-layer findings, soft-fail semantics, and an
+* aggregated `blendedScore` across all passed layers.
 *
 * Use when you want:
 *   - ordered stages where a failing upstream stage skips downstream ones
@@ -6305,13 +6303,8 @@ function softFail(expectedConcepts, start, error) {
 *   - a single composite score across stages with per-stage weights
 *   - soft-fail stages whose failure doesn't abort the pipeline
 *
-* Use {@link JudgeRunner} when you want:
-*   - N independent judges running in parallel against the same artifact
-*   - no inter-judge dependencies
-*   - boolean `passed` per judge + overall
-*
-* Both primitives compose — JudgeRunner can be invoked as a single
-* layer inside a MultiLayerVerifier if that suits the caller.
+* A layer body is an arbitrary async function, so independent checks that need
+* no ordering run as one layer that resolves them in parallel.
 */
 /**
 * Grade a semantic-concept-style judge result into a single layer status.