@tangle-network/agent-eval 0.195.1 → 0.197.0

package/dist/{index-B7omS8L-.d.ts → index-CRsmcAGl.d.ts}

@@ -3,10 +3,10 @@ import { a as RunRecord, c as RunSplitTag, n as RunCostProvenance } from "./run-
 import "./types-CeDfCRXp.js";
 import "./statistical-heldout-BedVSZb2.js";
 import "./types-B2673PBj.js";
-import "./index-D7o8xhFO.js";
+import "./index-DJKZEldg.js";
 import { p as TraceSpanEvent } from "./client-BzL9niqi.js";
 import { d as InsightReport, t as AnalyzeRunsOptions } from "./analyze-runs-CPiKLJFs.js";
-import "./define-agent-eval-C_oqRN9O.js";
+import "./define-agent-eval-ulRlLvse.js";
 import "./default-registry-D2csUBBQ.js";
 import { AgentCandidateBenchmarkCellRef, AgentCandidateBenchmarkSuiteInputs, AgentCandidateBenchmarkTask, AgentCandidateBenchmarkTaskMaterial, AgentCandidateBundle, AgentCandidateEvaluationPolicy, AgentCandidateExperiment, AgentCandidateExperimentMaterial, AgentCandidateExperimentMeasurement, AgentImprovementCost, AgentImprovementMeasuredComparison, AgentProfileImprovementExperiment, AgentProfileImprovementExperimentMaterial, AgentProfileImprovementMeasuredComparison, AgentProfileImprovementMeasurement, AgentProfileImprovementRunCell, AgentProfileImprovementRunReceipt, AgentProfileImprovementSuiteInputs, AgentProfileImprovementTask, AgentProfileImprovementTaskMaterial, CandidateExecutionEvidence, Sha256Digest } from "@tangle-network/agent-interface";
 //#region src/contract/measured-comparison.d.ts
@@ -687,4 +687,4 @@ interface FromOtelSpansOptions {
 declare function fromOtelSpans(opts: FromOtelSpansOptions): RunRecord[];
 //#endregion
 export { FromRunRecordDirResult as $, CodeAgentSessionActionStatus as A, AgentTraceFile as B, fromOpenCodeSession as C, measuredComparisonFromCandidateExperiment as Ct, streamCodeAgentJsonlFile as D, sealCandidateExperiment as Dt, parseCodeAgentJsonlFile as E, sealCandidateBenchmarkTask as Et, CodeAgentSessionTerminalStatus as F, PartitionByAuthoringModelResult as G, AgentTraceRange as H, observeCodeAgentSession as I, EvalReportingSuiteInput as J, parseAgentTrace as K, AgentTraceContributor as L, CodeAgentSessionExecutionReceipt as M, CodeAgentSessionObservation as N, CodeAgentSessionAction as O, verifyCandidateExperiment as Ot, CodeAgentSessionSource as P, FromRunRecordDirOptions as Q, AgentTraceContributorType as R, fromKimiCodeSession as S, evaluatePairedMeasurements as St, parseCodeAgentJsonl as T, sealCandidateBenchmarkSuite as Tt, AgentTraceRecord as U, AgentTraceIndex as V, AuthoringProvenance as W, EvalReportingSuiteResult as X, EvalReportingSuiteOptions as Y, evalReportingSuite as Z, CodeAgentSessionIntakeResult as _, PairedMeasurement as _t, FromFeedbackTableOptions as a, RunAgentProfileImprovementExperimentOptions as at, fromClaudeCodeSession as b, RunCandidateExperimentOptions as bt, CodeAgentStoreObservation as c, runAgentProfileImprovementExperiment as ct, CodeAgentStoreScope as d, sealAgentProfileImprovementTask as dt, RunRecordRejection as et, CodeAgentStoreSession as f, verifyAgentProfileImprovementExperimentComparison as ft, CodeAgentSessionIntakeOptions as g, EvaluatePairedMeasurementsOptions as gt, CodeAgentSessionDiagnostic as h, CompareCandidateExperimentOptions as ht, FeedbackTableRow as i, CompareAgentProfileImprovementExperimentOptions as it, CodeAgentSessionActionSurface as j, CodeAgentSessionActionKind as k, verifyCandidateExperimentComparison as kt, CodeAgentStoreRejection as l, sealAgentProfileImprovementExperiment as lt, CodeAgentJsonlLine as m, CandidateExperimentRun as mt, fromOtelSpans as n, AgentProfileImprovementExperimentExecutionInput as nt, FromFeedbackTableResult as o, SealAgentProfileImprovementSuiteOptions as ot, observeCodeAgentStore as p, CandidateExperimentExecutionInput as pt, partitionRunsByAuthoringModel as q, FeedbackTableMeta as r, AgentProfileImprovementExperimentRun as rt, fromFeedbackTable as s, measuredComparisonFromAgentProfileImprovementExperiment as st, FromOtelSpansOptions as t, fromRunRecordDir as tt, CodeAgentStoreRejections as u, sealAgentProfileImprovementSuite as ut, CodeAgentSessionMetrics as v, PairedMeasurementAdapter as vt, fromPiSession as w, runCandidateExperiment as wt, fromCodexSession as x, SealCandidateBenchmarkSuiteOptions as xt, ParsedCodeAgentJsonl as y, PairedMeasurementEvaluation as yt, AgentTraceConversation as z };
-//# sourceMappingURL=index-B7omS8L-.d.ts.map
+//# sourceMappingURL=index-CRsmcAGl.d.ts.map

package/dist/{index-B7omS8L-.d.ts.map → index-CRsmcAGl.d.ts.map}

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

package/dist/{index-D7o8xhFO.d.ts → index-DJKZEldg.d.ts}

@@ -1824,6 +1824,21 @@ interface SkillOptOptimizationMethodConfig<TScenario extends Scenario, TArtifact
   describeArtifact?: (artifact: TArtifact, scenario: TScenario) => unknown;
   resume?: ExternalOptimizerResumeMode;
   runner?: SkillOptRunnerCommand;
+  /**
+   * Record SkillOpt's search into a search ledger and return the bounded
+   * receipt on the method result, so a comparison under `searchHistoryPolicy:
+   * 'require-complete'` accepts this method. Every candidate the callback
+   * evaluated becomes a node with an `unknown` edge (SkillOpt reports no
+   * parents), and every evaluation becomes a cell.
+   *
+   * `identity` declares the immutable revisions and the model the ledger
+   * requires and the bridge does not report. `path` defaults to
+   * `<runDir>/search-ledger.jsonl`.
+   */
+  searchLedger?: {
+    identity: SearchRunIdentity;
+    path?: string;
+  };
 }
 /** Run Microsoft's SkillOpt trainer as a complete optimization method. */
 declare function skillOptOptimizationMethod<TScenario extends Scenario, TArtifact>(config: SkillOptOptimizationMethodConfig<TScenario, TArtifact>): OptimizationMethod<TScenario, TArtifact>;
@@ -2847,6 +2862,8 @@ interface NeutralizationGateOptions<TScenario extends Scenario = Scenario> {
 declare function neutralizationGate<TArtifact, TScenario extends Scenario>(options: NeutralizationGateOptions<TScenario>): Gate<TArtifact, TScenario>;
 //#endregion
 //#region src/campaign/gepa-search-import.d.ts
+/** The external optimizers whose searches this module records. */
+type ExternalSearchOptimizer = 'GEPA' | 'SkillOpt';
 interface GepaPopulationImport {
   /** Population index to node id. */
   nodeIds: ReadonlyMap<number, string>;
@@ -2880,7 +2897,8 @@ interface GepaEvaluationImport {
 /**
  * Record every evaluation in the callback's observation log as an `external`
  * cell attempt. A candidate that is not yet a node (GEPA evaluated it on a
- * minibatch and discarded it) is registered with an `unknown` edge.
+ * minibatch and discarded it, or SkillOpt, which reports no parents, proposed
+ * it) is registered with an `unknown` edge.
  */
 declare function importExternalEvaluations(input: {
   recorder: SearchRecorder;
@@ -2889,18 +2907,13 @@ declare function importExternalEvaluations(input: {
   identity: SearchExecutionIdentity;
   /** The split each evaluated example belongs to. */
   splitOf: (exampleId: string) => SearchSplit;
+  /** The optimizer that proposed the candidates. Default GEPA. */
+  optimizer?: ExternalSearchOptimizer;
 }): Promise<GepaEvaluationImport>;
 /** An optimizer candidate as the mutable surface it represents. */
 declare function externalSurface(candidate: ExternalTextCandidate): MutableSurface;
-/**
- * Write GEPA's finished search into its ledger: the baseline as the seeded
- * root, the population as nodes with `correlated` edges, every callback
- * evaluation as an `external` cell, GEPA's proposer spend as one operation,
- * GEPA's choice as the selected node, and the close. GEPA's own selection is a
- * budget decision, so the ledger carries no claim; the final comparison runs
- * outside this search.
- */
-declare function recordGepaSearch(input: {
+/** What `recordGepaSearch` and `recordSkillOptSearch` share. */
+interface ExternalSearchRecordInput {
   name: string;
   path: string;
   searchId: string;
@@ -2911,9 +2924,36 @@ declare function recordGepaSearch(input: {
   trainScenarios: readonly Scenario[];
   selectionScenarios: readonly Scenario[];
   evaluationLimit: number;
-  population: GepaCandidatePopulationArtifact;
   observations: ExternalOptimizerObservationArtifact;
   generationAccounting: SearchAttemptAccounting;
+}
+/**
+ * Write GEPA's finished search into its ledger: the baseline as the seeded
+ * root, the population as nodes with `correlated` edges, every callback
+ * evaluation as an `external` cell, GEPA's proposer spend as one operation,
+ * GEPA's choice as the selected node, and the close. GEPA's own selection is a
+ * budget decision, so the ledger carries no claim; the final comparison runs
+ * outside this search.
+ *
+ * A composed recipe reports no population: pass `population: null` and GEPA's
+ * returned best as `selected`, and every evaluated candidate enters with an
+ * `unknown` edge, as SkillOpt's do.
+ */
+declare function recordGepaSearch(input: ExternalSearchRecordInput & ({
+  population: GepaCandidatePopulationArtifact;
+} | {
+  population: null;
+  selected: MutableSurface;
+})): Promise<SearchHistoryReceipt>;
+/**
+ * Write SkillOpt's finished search into its ledger: the baseline as the seeded
+ * root, every candidate SkillOpt evaluated as a node with an `unknown` edge
+ * (SkillOpt reports no parents), every callback evaluation as an `external`
+ * cell, SkillOpt's optimizer spend as one operation, SkillOpt's choice as the
+ * selected node, and the close. Like GEPA's, the ledger carries no claim.
+ */
+declare function recordSkillOptSearch(input: ExternalSearchRecordInput & {
+  selected: MutableSurface;
 }): Promise<SearchHistoryReceipt>;
 //#endregion
 //#region src/campaign/grounded-reflection.d.ts
@@ -4020,6 +4060,27 @@ declare function searchDivergence(state: SearchStateView, nodeId: string): {
   reason: string;
 } | null;
 //#endregion
+//#region src/campaign/search-campaign-cell.d.ts
+/**
+ * What `cell-settled` records for one campaign cell: `passed` with the
+ * composite (and each judge's) when every judge scored it, else `errored`,
+ * never retryable, because `runCampaign` already applied its own retry policy;
+ * its tokens and cost, with an uncaptured cost kept as a lower bound; the
+ * model the cell resolved, else the declared one.
+ */
+declare function campaignCellSearchResult<TArtifact>(cell: CampaignCellResult<TArtifact>, input: {
+  execution: SearchExecutionIdentity;
+  lane: string;
+}): SearchCellResult;
+/** A provider-reported model: a snapshot when its name pins one, else a moving alias. */
+declare function searchModelIdentity(model: string, provider: string): SearchModelIdentity;
+/** The accounting of a proposal's cost receipts: token and dollar sums, each
+ * unknown (with the known dollars as a lower bound) when a receipt lacks it. */
+declare function searchReceiptAccounting(receipts: ReadonlyArray<CostReceipt>): SearchAttemptAccounting;
+/** What ran a proposal: a model when it made a paid call other than a judge's,
+ * else deterministic code. */
+declare function searchProposalExecution(receipts: ReadonlyArray<CostReceipt>, provider: string, source: SearchOperationRecordedEvent['execution']['source']): SearchOperationRecordedEvent['execution'];
+//#endregion
 //#region src/campaign/single-run-lock.d.ts
 /**
  * Single-run lock for evaluations that share one mutable environment.
@@ -4205,5 +4266,5 @@ declare function verifyCodeSurface(surface: CodeSurface, worktreeDir?: string):
  *  identity against the checkout at `worktreeRef`. */
 declare function resolveWorktreePath(surface: CodeSurface, worktreeDir?: string): string;
 //#endregion
-export { scoreDiscrimination as $, searchEdgeId as $a, OptimizationPackageSource as $i, CrossSurfaceCandidateSummary as $n, assertCampaignDesign as $o, CampaignComparisonUnits as $r, createLlmCorrectnessChecker as $t, SearchExecutor as A, transientDispatchFailure as Aa, GepaOptimizationMethodConfig as Ai, discoverEvalFixtures as An, openAutoPr as Ao, SearchCellPlan as Ar, RunProfileMatrixOptions as At, searchExpansionIndex as B, SearchPolicyView as Ba, ExternalOptimizationExample as Bi, searchCellSetDigest as Bn, planCampaignRun as Bo, LoopProvenanceEvidence as Br, RuntimeEventLike as Bt, SingleRunLockOptions as C, runReferenceEquivalenceJudge as Ca, SkillOptOptimizationMethodConfig as Ci, EvalFixtureFile as Cn, replaySearchLedgerText as Co, TraceAnalystArtifact as Cr, renderScoreboardMarkdown as Ct, SearchArtifactCodec as D, TransientFailureOptions as Da, GepaAdaptiveEngineRun as Di, EvalFixtureValidationMode as Dn, SearchLedgerIntegrityError as Do, AshaOptions as Dr, ProfileDispatchFn as Dt, SEARCH_KERNEL_SOURCE as E, llmJudge as Ea, skillOptOptimizationMethod as Ei, EvalFixtureScenario as En, SearchLedgerError as Eo, traceAnalystQualityJudge as Er, userStoryScoreboard as Et, SearchProposedChild as F, RunOptimizationOptions as Fa, OptimizerModelBudget as Fi, NodePosterior as Fn, RunCampaignOptions as Fo, EmitLoopProvenanceArgs as Fr, BackendIntegrityReport as Ft, SearchClaimPlan as G, RegisterSearchNodeInput as Ga, OptimizationMethodComparison as Gi, CrossSurfaceAdditionRejectionReason as Gn, buildCellSchedule as Go, canonicalDigest as Gr, CorrectnessChecker as Gt, PlanSearchClaimInput as H, incumbent as Ha, decodeExternalTextCandidate as Hi, analyzeCrossSurfaceInteractions as Hn, CacheRead as Ho, LoopProvenanceRecord as Hr, extractProducedState as Ht, SearchProposerPort as I, RunOptimizationResult as Ia, externalTextOptimizationMethod as Ii, SEARCH_ESTIMATOR as In, runCampaign as Io, EmitLoopProvenanceResult as Ir, assertRealBackend as It, planSearchClaim as J, SearchRecorder as Ja, OptimizationMethodPairwise as Ji, CrossSurfaceBootstrapPolicy as Jn, createRunCostLedger as Jo, loopProvenanceSpans as Jr, ProducedState as Jt, SearchClaimVerification as K, SearchLedgerBinding as Ka, OptimizationMethodComposition as Ki, CrossSurfaceAttemptCompleteness as Kn, cellCachePath as Ko, emitLoopProvenance as Kr, LlmCorrectnessCheckerOpts as Kt, SearchRunResult as L, runOptimization as La, ExternalTextOptimizationMethodConfig as Li, SearchPosterior as Ln, CampaignRunPlan as Lo, LoopProvenanceArgsFromResult as Lr, summarizeBackendIntegrity as Lt, SearchProposalBlob as M, RunImprovementLoopResult as Ma, GepaRunnerCommand as Mi, loadEvalFixtureScenarios as Mn, runEval as Mo, asha as Mr, ScenarioRollup as Mt, SearchProposalRequest as N, runImprovementLoop as Na, gepaOptimizationMethod as Ni, planEvalFixtureRun as Nn, CampaignCellFailureReceipt as No, uniform as Nr, runProfileMatrix as Nt, SearchCellResult as O, isTransientTransportFailure as Oa, GepaEngineOptions as Oi, LoadEvalFixtureScenariosOptions as On, OpenAutoPrOptions as Oo, SearchAllocationView as Or, ProfileMatrixError as Ot, SearchProposalResult as P, PremeasuredOptimizationBaseline as Pa, OpenAICompatibleOptimizerModel as Pi, EstimateNodeCellsInput as Pn, CampaignCellRetryPolicy as Po, BuildLoopProvenanceArgs as Pr, BackendIntegrityError as Pt, ScenarioSignal as Q, developmentClaim as Qa, OptimizationMethodScore as Qi, CrossSurfaceCandidateOutcome as Qn, FinalEvidenceUse as Qo, CampaignBreakdown as Qr, completionVerdict as Qt, runSearch as R, SearchExpansion as Ra, ExternalTextOptimizerContext as Ri, estimateNode as Rn, CampaignRunPlanCell as Ro, LoopProvenanceBackend as Rr, ArtifactEventLike as Rt, SingleRunLock as S, createReferenceEquivalenceJudge as Sa, composeGate as Si, EvalFixture as Sn, parseSearchLedgerLine as So, BuildTraceAnalystSurfaceDispatchOptions as Sr, makePlaybackDispatch as St, RunSearchOptions as T, LlmJudgeOptions as Ta, SkillOptTrainerConfig as Ti, EvalFixtureRunPlan as Tn, SearchLedgerConflictError as To, buildTraceAnalystSurfaceDispatch as Tr, scoreboardSummary as Tt, SEARCH_CLAIM_RULE as U, AllocateSearchCellInput as Ua, CompareOptimizationMethodsOptions as Ui, AnalyzeCrossSurfaceInteractionsInput as Un, readCachedCell as Uo, buildLoopProvenanceRecord as Ur, CompletionRequirement as Ut, searchPolicyView as V, crowdedFrontierParent as Va, ExternalTextEvaluationResponse as Vi, searchPosterior as Vn, CacheIssueReason as Vo, LoopProvenanceOptimizationMethod as Vr, ToolCallEventLike as Vt, SearchClaimDecision as W, RecordSearchEdgeInput as Wa, OptimizationMethod as Wi, CrossSurfaceAdditionDecision as Wn, CellScheduleSlot as Wo, campaignMeasurementDigest as Wr, CompletionVerdict as Wt, verifySearchClaim as X, SearchRunIdentity as Xa, OptimizationMethodResult as Xi, CrossSurfaceCandidateComparison as Xn, inMemoryCampaignStorage as Xo, provenanceSpansPath as Xr, SatisfiedBy as Xt, searchClaimReserveUsd as Y, SearchRecorderOptions as Ya, OptimizationMethodProvenance as Yi, CrossSurfaceCandidate as Yn, fsCampaignStorage as Yo, provenanceRecordPath as Yr, RequirementCheck as Yt, DiscriminationScore as Z, SettleSearchCellInput as Za, OptimizationMethodRunOptions as Zi, CrossSurfaceCandidateEvidence as Zn, FinalEvidencePolicy as Zo, verifyLoopProvenanceRecord as Zr, TaskGold as Zt, componentSurfaceIdentityMaterial as _, REFERENCE_EQUIVALENCE_JUDGE_VERSION as _a, CanaryEvaluation as _i, importExternalEvaluations as _n, OpenSearchLedgerOptions as _o, CrossSurfaceRankedSingle as _r, ScoreboardRenderOptions as _t, WorktreeAdapterError as a, costFromLedgerSummary as aa, DefaultProductionGateOptions as ai, FsLabeledScenarioStoreOptions as an, SearchHistoryCoverage as ao, CrossSurfaceEvidenceBreakdown as ar, FinalizedProfileMatrixResult as at, surfaceDispatchRef as b, ReferenceEquivalenceJudgeResult as ba, CanaryReport as bi, NeutralizationGateOptions as bn, SearchLedgerTrustedHeadMode as bo, CrossSurfaceSelections as br, UserStory as bt, verifyCodeSurface as c, GepaCandidatePopulationSummary as ca, DEFAULT_RED_TEAM_CORPUS as ci, RolloutArgumentDiffOptions as cn, SearchHistoryReceipt as co, CrossSurfaceInteractionEffect as cr, ProfileMatrixRow as ct, PhoenixEvaluationResultLike as d, ExternalOptimizerExecutionSummary as da, RedTeamFinding as di, UngroundedLiteralReport as dn, assertSearchHistoryMatchesState as do, CrossSurfaceInteractionTask as dr, createProfileMatrixPlan as dt, OptimizationTokenUsage as ea, campaignBreakdown as ei, verifyCompletion as en, surfaceDiff as eo, CrossSurfaceComponent as er, assertCampaignSplitIdentity as es, selectDiscriminative as et, PhoenixEvaluatorLike as f, ExternalOptimizerObservationArtifact as fa, RedTeamReport as fi, classifyUngroundedLiterals as fn, createSearchHistoryReceipt as fo, CrossSurfaceNaiveStackSelection as fr, finalizeProfileMatrix as ft, codeSurfaceIdentityMaterial as g, REFERENCE_EQUIVALENCE_INPUT_LIMITS as ga, CanaryAlert as gi, externalSurface as gn, FileSearchLedger as go, CrossSurfacePairwiseEntry as gr, PlaybackStep as gt, assertCodeSurfaceIdentity as h, readExternalOptimizerObservationArtifact as ha, scoreRedTeamOutput as hi, GepaPopulationImport as hn, verifySearchHistoryReceipt as ho, CrossSurfacePairIncompatibilityReason as hr, PlaybackDriver as ht, WorktreeAdapter as i, combineComparisonCosts as ia, DefaultProductionGateCheck as ii, FsLabeledScenarioStore as in, SearchHistoryAuditSummary as io, CrossSurfaceEligibility as ir, FinalizeProfileMatrixOptions as it, SearchLane as j, RunImprovementLoopOptions as ja, GepaOptimizationRecipe as ji, loadEvalFixture as jn, RunEvalOptions as jo, SearchRungDecision as jr, RunProfileMatrixResult as jt, SearchCellWork as k, quotaExhaustedUntil as ka, GepaEngineRun as ki, PlanEvalFixtureRunOptions as kn, OpenAutoPrResult as ko, SearchAllocator as kr, ProfileSummary as kt, AutoevalsScoreLike as l, GepaCandidateSelectionScore as la, RedTeamCase as li, RolloutCall as ln, SearchHistoryRequiredError as lo, CrossSurfaceInteractionPath as lr, ProfileMatrixSegmentResult as lt, phoenixEvaluatorJudge as m, ExternalOptimizerSubmittedCandidate as ma, redTeamReport as mi, GepaEvaluationImport as mn, verifySearchHistoryArtifact as mo, CrossSurfacePairEvidence as mr, PlaybackContext as mt, GitWorktreeAdapterOptions as n, optimizationTokenUsageFromSummary as na, HeldOutGateOptions as ni, sequentialOptimizationMethod as nn, CreateSearchHistoryReceiptInput as no, CrossSurfaceCompositionStep as nr, campaignSplitDigest as ns, tangleTracesRoot as nt, gitWorktreeAdapter as o, GepaCandidatePopulationArtifact as oa, DefaultProductionRewardHackingOptions as oi, LabeledScenarioStoreError as on, SearchHistoryCoverageRow as oo, CrossSurfaceIneligibilityReason as or, ProfileMatrixCoverage as ot, autoevalsScorerJudge as p, ExternalOptimizerObservationSummary as pa, redTeamDataset as pi, rolloutArgumentDiff as pn, searchHistoryCoverageRow as po, CrossSurfacePairCompatibility as pr, runProfileMatrixSegment as pt, decideSearchClaim as q, SearchOpening as qa, OptimizationMethodInput as qi, CrossSurfaceBestSingleSelection as qn, CampaignStorage as qo, loopProvenanceArgsFromResult as qr, ProducedProposal as qt, Worktree as r, ComparisonCost as ra, heldOutGate as ri, neutralizeText as rn, SearchHistoryAdmissionOptions as ro, CrossSurfaceDistribution as rr, campaignSplitDigestFromIdentities as rs, CreateProfileMatrixPlanOptions as rt, resolveWorktreePath as s, GepaCandidatePopulationCandidate as sa, defaultProductionGate as si, RolloutArgumentDiff as sn, SearchHistoryPolicy as so, CrossSurfaceInteractionAwareSelection as sr, ProfileMatrixPlan as st, CodeSurfaceVerification as t, compareOptimizationMethods as ta, campaignMeanComposite as ti, scopedOptimizationMethod as tn, surfaceNode as to, CrossSurfaceComponentEvidence as tr, campaignScenarioIdentity as ts, resolveRunDir as tt, AutoevalsScorerLike as u, readGepaCandidatePopulationArtifact as ua, RedTeamCategory as ui, ScoredRollout as un, assertCompleteSearchHistory as uo, CrossSurfaceInteractionReport as ur, RunProfileMatrixSegmentOptions as ut, renderSurfaceDiff as v, ReferenceEquivalenceJudgeInput as va, CanaryKind as vi, importGepaPopulation as vn, SearchLedger as vo, CrossSurfaceRelativeCost as vr, ScoreboardRow as vt, acquireSingleRunLock as w, LlmJudgeDimension as wa, SkillOptRunnerCommand as wi, EvalFixtureLoadOptions as wn, validateSearchLedgerEvent as wo, TraceAnalystScenario as wr, scoreUserStory as wt, surfaceHash as x, ReferenceEquivalenceScenario as xa, runCanaries as xi, neutralizationGate as xn, openSearchLedger as xo, CrossSurfaceTaskRow as xr, UserStoryVerdict as xt, surfaceContentHash as y, ReferenceEquivalenceJudgeOptions as ya, CanaryOptions as yi, recordGepaSearch as yn, SearchLedgerAppendResult as yo, CrossSurfaceSelectionPolicy as yr, ScoreboardSummary as yt, searchDivergence as z, SearchPolicy as za, ExternalTextOptimizerResult as zi, estimateNodeFromCells as zn, PlanCampaignRunOptions as zo, LoopProvenanceCandidate as zr, ProposalEventLike as zt };
-//# sourceMappingURL=index-D7o8xhFO.d.ts.map
+export { searchClaimReserveUsd as $, SearchOpening as $a, OptimizationMethodInput as $i, CrossSurfaceBestSingleSelection as $n, CampaignStorage as $o, loopProvenanceArgsFromResult as $r, RequirementCheck as $t, SEARCH_KERNEL_SOURCE as A, LlmJudgeDimension as Aa, SkillOptRunnerCommand as Ai, EvalFixtureLoadOptions as An, validateSearchLedgerEvent as Ao, TraceAnalystScenario as Ar, userStoryScoreboard as At, SearchProposerPort as B, PremeasuredOptimizationBaseline as Ba, OpenAICompatibleOptimizerModel as Bi, EstimateNodeCellsInput as Bn, CampaignCellRetryPolicy as Bo, BuildLoopProvenanceArgs as Br, assertRealBackend as Bt, SingleRunLockOptions as C, REFERENCE_EQUIVALENCE_JUDGE_VERSION as Ca, CanaryEvaluation as Ci, importGepaPopulation as Cn, OpenSearchLedgerOptions as Co, CrossSurfaceRankedSingle as Cr, ScoreboardSummary as Ct, searchProposalExecution as D, ReferenceEquivalenceScenario as Da, runCanaries as Di, neutralizationGate as Dn, openSearchLedger as Do, CrossSurfaceTaskRow as Dr, renderScoreboardMarkdown as Dt, searchModelIdentity as E, ReferenceEquivalenceJudgeResult as Ea, CanaryReport as Ei, NeutralizationGateOptions as En, SearchLedgerTrustedHeadMode as Eo, CrossSurfaceSelections as Er, makePlaybackDispatch as Et, SearchLane as F, quotaExhaustedUntil as Fa, GepaEngineRun as Fi, PlanEvalFixtureRunOptions as Fn, OpenAutoPrResult as Fo, SearchAllocator as Fr, RunProfileMatrixResult as Ft, searchPolicyView as G, SearchPolicy as Ga, ExternalTextOptimizerResult as Gi, estimateNodeFromCells as Gn, PlanCampaignRunOptions as Go, LoopProvenanceCandidate as Gr, ToolCallEventLike as Gt, runSearch as H, RunOptimizationResult as Ha, externalTextOptimizationMethod as Hi, SEARCH_ESTIMATOR as Hn, runCampaign as Ho, EmitLoopProvenanceResult as Hr, ArtifactEventLike as Ht, SearchProposalBlob as I, transientDispatchFailure as Ia, GepaOptimizationMethodConfig as Ii, discoverEvalFixtures as In, openAutoPr as Io, SearchCellPlan as Ir, ScenarioRollup as It, SearchClaimDecision as J, incumbent as Ja, decodeExternalTextCandidate as Ji, analyzeCrossSurfaceInteractions as Jn, CacheRead as Jo, LoopProvenanceRecord as Jr, CompletionVerdict as Jt, PlanSearchClaimInput as K, SearchPolicyView as Ka, ExternalOptimizationExample as Ki, searchCellSetDigest as Kn, planCampaignRun as Ko, LoopProvenanceEvidence as Kr, extractProducedState as Kt, SearchProposalRequest as L, RunImprovementLoopOptions as La, GepaOptimizationRecipe as Li, loadEvalFixture as Ln, RunEvalOptions as Lo, SearchRungDecision as Lr, runProfileMatrix as Lt, SearchCellResult as M, llmJudge as Ma, skillOptOptimizationMethod as Mi, EvalFixtureScenario as Mn, SearchLedgerError as Mo, traceAnalystQualityJudge as Mr, ProfileMatrixError as Mt, SearchCellWork as N, TransientFailureOptions as Na, GepaAdaptiveEngineRun as Ni, EvalFixtureValidationMode as Nn, SearchLedgerIntegrityError as No, AshaOptions as Nr, ProfileSummary as Nt, searchReceiptAccounting as O, createReferenceEquivalenceJudge as Oa, composeGate as Oi, EvalFixture as On, parseSearchLedgerLine as Oo, BuildTraceAnalystSurfaceDispatchOptions as Or, scoreUserStory as Ot, SearchExecutor as P, isTransientTransportFailure as Pa, GepaEngineOptions as Pi, LoadEvalFixtureScenariosOptions as Pn, OpenAutoPrOptions as Po, SearchAllocationView as Pr, RunProfileMatrixOptions as Pt, planSearchClaim as Q, SearchLedgerBinding as Qa, OptimizationMethodComposition as Qi, CrossSurfaceAttemptCompleteness as Qn, cellCachePath as Qo, emitLoopProvenance as Qr, ProducedState as Qt, SearchProposalResult as R, RunImprovementLoopResult as Ra, GepaRunnerCommand as Ri, loadEvalFixtureScenarios as Rn, runEval as Ro, asha as Rr, BackendIntegrityError as Rt, SingleRunLock as S, REFERENCE_EQUIVALENCE_INPUT_LIMITS as Sa, CanaryAlert as Si, importExternalEvaluations as Sn, FileSearchLedger as So, CrossSurfacePairwiseEntry as Sr, ScoreboardRow as St, campaignCellSearchResult as T, ReferenceEquivalenceJudgeOptions as Ta, CanaryOptions as Ti, recordSkillOptSearch as Tn, SearchLedgerAppendResult as To, CrossSurfaceSelectionPolicy as Tr, UserStoryVerdict as Tt, searchDivergence as U, runOptimization as Ua, ExternalTextOptimizationMethodConfig as Ui, SearchPosterior as Un, CampaignRunPlan as Uo, LoopProvenanceArgsFromResult as Ur, ProposalEventLike as Ut, SearchRunResult as V, RunOptimizationOptions as Va, OptimizerModelBudget as Vi, NodePosterior as Vn, RunCampaignOptions as Vo, EmitLoopProvenanceArgs as Vr, summarizeBackendIntegrity as Vt, searchExpansionIndex as W, SearchExpansion as Wa, ExternalTextOptimizerContext as Wi, estimateNode as Wn, CampaignRunPlanCell as Wo, LoopProvenanceBackend as Wr, RuntimeEventLike as Wt, SearchClaimVerification as X, RecordSearchEdgeInput as Xa, OptimizationMethod as Xi, CrossSurfaceAdditionDecision as Xn, CellScheduleSlot as Xo, campaignMeasurementDigest as Xr, LlmCorrectnessCheckerOpts as Xt, SearchClaimPlan as Y, AllocateSearchCellInput as Ya, CompareOptimizationMethodsOptions as Yi, AnalyzeCrossSurfaceInteractionsInput as Yn, readCachedCell as Yo, buildLoopProvenanceRecord as Yr, CorrectnessChecker as Yt, decideSearchClaim as Z, RegisterSearchNodeInput as Za, OptimizationMethodComparison as Zi, CrossSurfaceAdditionRejectionReason as Zn, buildCellSchedule as Zo, canonicalDigest as Zr, ProducedProposal as Zt, componentSurfaceIdentityMaterial as _, ExternalOptimizerExecutionSummary as _a, RedTeamFinding as _i, rolloutArgumentDiff as _n, assertSearchHistoryMatchesState as _o, CrossSurfaceInteractionTask as _r, runProfileMatrixSegment as _t, WorktreeAdapterError as a, OptimizationPackageSource as aa, CampaignComparisonUnits as ai, scopedOptimizationMethod as an, searchEdgeId as ao, CrossSurfaceCandidateSummary as ar, assertCampaignDesign as as, resolveRunDir as at, surfaceDispatchRef as b, ExternalOptimizerSubmittedCandidate as ba, redTeamReport as bi, GepaPopulationImport as bn, verifySearchHistoryArtifact as bo, CrossSurfacePairEvidence as br, PlaybackStep as bt, verifyCodeSurface as c, optimizationTokenUsageFromSummary as ca, HeldOutGateOptions as ci, FsLabeledScenarioStore as cn, CreateSearchHistoryReceiptInput as co, CrossSurfaceCompositionStep as cr, campaignSplitDigest as cs, FinalizeProfileMatrixOptions as ct, PhoenixEvaluationResultLike as d, costFromLedgerSummary as da, DefaultProductionGateOptions as di, RolloutArgumentDiff as dn, SearchHistoryCoverage as do, CrossSurfaceEvidenceBreakdown as dr, ProfileMatrixPlan as dt, OptimizationMethodPairwise as ea, loopProvenanceSpans as ei, SatisfiedBy as en, SearchRecorder as eo, CrossSurfaceBootstrapPolicy as er, createRunCostLedger as es, verifySearchClaim as et, PhoenixEvaluatorLike as f, GepaCandidatePopulationArtifact as fa, DefaultProductionRewardHackingOptions as fi, RolloutArgumentDiffOptions as fn, SearchHistoryCoverageRow as fo, CrossSurfaceIneligibilityReason as fr, ProfileMatrixRow as ft, codeSurfaceIdentityMaterial as g, readGepaCandidatePopulationArtifact as ga, RedTeamCategory as gi, classifyUngroundedLiterals as gn, assertCompleteSearchHistory as go, CrossSurfaceInteractionReport as gr, finalizeProfileMatrix as gt, assertCodeSurfaceIdentity as h, GepaCandidateSelectionScore as ha, RedTeamCase as hi, UngroundedLiteralReport as hn, SearchHistoryRequiredError as ho, CrossSurfaceInteractionPath as hr, createProfileMatrixPlan as ht, WorktreeAdapter as i, OptimizationMethodScore as ia, CampaignBreakdown as ii, verifyCompletion as in, developmentClaim as io, CrossSurfaceCandidateOutcome as ir, FinalEvidenceUse as is, selectDiscriminative as it, SearchArtifactCodec as j, LlmJudgeOptions as ja, SkillOptTrainerConfig as ji, EvalFixtureRunPlan as jn, SearchLedgerConflictError as jo, buildTraceAnalystSurfaceDispatch as jr, ProfileDispatchFn as jt, RunSearchOptions as k, runReferenceEquivalenceJudge as ka, SkillOptOptimizationMethodConfig as ki, EvalFixtureFile as kn, replaySearchLedgerText as ko, TraceAnalystArtifact as kr, scoreboardSummary as kt, AutoevalsScoreLike as l, ComparisonCost as la, heldOutGate as li, FsLabeledScenarioStoreOptions as ln, SearchHistoryAdmissionOptions as lo, CrossSurfaceDistribution as lr, campaignSplitDigestFromIdentities as ls, FinalizedProfileMatrixResult as lt, phoenixEvaluatorJudge as m, GepaCandidatePopulationSummary as ma, DEFAULT_RED_TEAM_CORPUS as mi, ScoredRollout as mn, SearchHistoryReceipt as mo, CrossSurfaceInteractionEffect as mr, RunProfileMatrixSegmentOptions as mt, GitWorktreeAdapterOptions as n, OptimizationMethodResult as na, provenanceSpansPath as ni, completionVerdict as nn, SearchRunIdentity as no, CrossSurfaceCandidateComparison as nr, inMemoryCampaignStorage as ns, ScenarioSignal as nt, gitWorktreeAdapter as o, OptimizationTokenUsage as oa, campaignBreakdown as oi, sequentialOptimizationMethod as on, surfaceDiff as oo, CrossSurfaceComponent as or, assertCampaignSplitIdentity as os, tangleTracesRoot as ot, autoevalsScorerJudge as p, GepaCandidatePopulationCandidate as pa, defaultProductionGate as pi, RolloutCall as pn, SearchHistoryPolicy as po, CrossSurfaceInteractionAwareSelection as pr, ProfileMatrixSegmentResult as pt, SEARCH_CLAIM_RULE as q, crowdedFrontierParent as qa, ExternalTextEvaluationResponse as qi, searchPosterior as qn, CacheIssueReason as qo, LoopProvenanceOptimizationMethod as qr, CompletionRequirement as qt, Worktree as r, OptimizationMethodRunOptions as ra, verifyLoopProvenanceRecord as ri, createLlmCorrectnessChecker as rn, SettleSearchCellInput as ro, CrossSurfaceCandidateEvidence as rr, FinalEvidencePolicy as rs, scoreDiscrimination as rt, resolveWorktreePath as s, compareOptimizationMethods as sa, campaignMeanComposite as si, neutralizeText as sn, surfaceNode as so, CrossSurfaceComponentEvidence as sr, campaignScenarioIdentity as ss, CreateProfileMatrixPlanOptions as st, CodeSurfaceVerification as t, OptimizationMethodProvenance as ta, provenanceRecordPath as ti, TaskGold as tn, SearchRecorderOptions as to, CrossSurfaceCandidate as tr, fsCampaignStorage as ts, DiscriminationScore as tt, AutoevalsScorerLike as u, combineComparisonCosts as ua, DefaultProductionGateCheck as ui, LabeledScenarioStoreError as un, SearchHistoryAuditSummary as uo, CrossSurfaceEligibility as ur, ProfileMatrixCoverage as ut, renderSurfaceDiff as v, ExternalOptimizerObservationArtifact as va, RedTeamReport as vi, ExternalSearchOptimizer as vn, createSearchHistoryReceipt as vo, CrossSurfaceNaiveStackSelection as vr, PlaybackContext as vt, acquireSingleRunLock as w, ReferenceEquivalenceJudgeInput as wa, CanaryKind as wi, recordGepaSearch as wn, SearchLedger as wo, CrossSurfaceRelativeCost as wr, UserStory as wt, surfaceHash as x, readExternalOptimizerObservationArtifact as xa, scoreRedTeamOutput as xi, externalSurface as xn, verifySearchHistoryReceipt as xo, CrossSurfacePairIncompatibilityReason as xr, ScoreboardRenderOptions as xt, surfaceContentHash as y, ExternalOptimizerObservationSummary as ya, redTeamDataset as yi, GepaEvaluationImport as yn, searchHistoryCoverageRow as yo, CrossSurfacePairCompatibility as yr, PlaybackDriver as yt, SearchProposedChild as z, runImprovementLoop as za, gepaOptimizationMethod as zi, planEvalFixtureRun as zn, CampaignCellFailureReceipt as zo, uniform as zr, BackendIntegrityReport as zt };
+//# sourceMappingURL=index-DJKZEldg.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index-DJKZEldg.d.ts","names":[],"sources":["../src/campaign/coverage.ts","../src/campaign/final-evidence.ts","../src/campaign/storage.ts","../src/campaign/cell-schedule.ts","../src/campaign/cell-cache.ts","../src/campaign/plan-campaign-run.ts","../src/campaign/run-campaign.ts","../src/campaign/presets/run-eval.ts","../src/campaign/auto-pr.ts","../src/campaign/search-ledger-errors.ts","../src/campaign/search-ledger.ts","../src/campaign/search-history-receipt.ts","../src/campaign/search-ledger-recording.ts","../src/campaign/search-policy.ts","../src/campaign/presets/run-optimization.ts","../src/campaign/presets/run-improvement-loop.ts","../src/campaign/transient-failure.ts","../src/llm-judge.ts","../src/reference-equivalence-judge.ts","../src/campaign/external-optimizer-observations.ts","../src/campaign/gepa-candidate-population.ts","../src/campaign/optimization-cost.ts","../src/campaign/presets/compare-optimization-methods.ts","../src/campaign/external-text-evaluation.ts","../src/campaign/external-text-optimization-contract.ts","../src/campaign/external-text-optimization.ts","../src/campaign/optimizer-model.ts","../src/campaign/gepa-optimization-method.ts","../src/campaign/skillopt-optimization-method.ts","../src/campaign/gates/compose.ts","../src/canary.ts","../src/red-team.ts","../src/campaign/gates/default-production-gate.ts","../src/campaign/gates/heldout-gate.ts","../src/campaign/score-utils.ts","../src/campaign/provenance.ts","../src/campaign/allocation.ts","../src/campaign/analyst-surface.ts","../src/campaign/cross-surface-types.ts","../src/campaign/cross-surface-interaction.ts","../src/campaign/estimate-node.ts","../src/campaign/fixtures.ts","../src/campaign/gates/neutralization-gate.ts","../src/campaign/gepa-search-import.ts","../src/campaign/grounded-reflection.ts","../src/campaign/labeled-store/fs-adapter.ts","../src/campaign/neutralize.ts","../src/campaign/optimization-method-composition.ts","../src/artifact-validator.ts","../src/completion-verifier.ts","../src/produced-state.ts","../src/integrity/backend-integrity.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/search-claim.ts","../src/campaign/search-kernel.ts","../src/campaign/search-campaign-cell.ts","../src/campaign/single-run-lock.ts","../src/campaign/surface-identity.ts","../src/campaign/upstream-evaluators.ts","../src/campaign/worktree/index.ts"],"mappings":"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"}

package/dist/index.d.ts

@@ -17,7 +17,7 @@ import { a as RunFilter, i as InMemoryTraceStore, n as FileSystemTraceStore, o a
 import { a as MintedRolloutLine } from "./schema-B5LtYvn9.js";
 import { a as mintRolloutRows, c as ScorePreference, i as RolloutSearchLineage, n as MintRolloutResult, t as MintRolloutOptions } from "./mint-C9Lojt1V.js";
 import { R as Scenario$1, S as JudgeConfig, _ as GateDecision, a as CampaignResult, w as JudgeScore$1 } from "./types-B2673PBj.js";
-import { $t as createLlmCorrectnessChecker, Aa as transientDispatchFailure, Bt as RuntimeEventLike, Ea as llmJudge, Fo as RunCampaignOptions, Ft as BackendIntegrityReport, Gt as CorrectnessChecker, Ht as extractProducedState, Io as runCampaign, It as assertRealBackend, Jt as ProducedState, Kt as LlmCorrectnessCheckerOpts, Lt as summarizeBackendIntegrity, No as CampaignCellFailureReceipt, Po as CampaignCellRetryPolicy, Pt as BackendIntegrityError, Qt as completionVerdict, Rt as ArtifactEventLike, Ta as LlmJudgeOptions, Ut as CompletionRequirement, Vt as ToolCallEventLike, Wt as CompletionVerdict, Xt as SatisfiedBy, Yt as RequirementCheck, Zt as TaskGold, _i as CanaryEvaluation, bi as CanaryReport, ci as DEFAULT_RED_TEAM_CORPUS, di as RedTeamFinding, en as verifyCompletion, fi as RedTeamReport, gi as CanaryAlert, hi as scoreRedTeamOutput, ka as quotaExhaustedUntil, li as RedTeamCase, mi as redTeamReport, pi as redTeamDataset, qt as ProducedProposal, ui as RedTeamCategory, vi as CanaryKind, xi as runCanaries, yi as CanaryOptions, zt as ProposalEventLike } from "./index-D7o8xhFO.js";
+import { $t as RequirementCheck, Bo as CampaignCellRetryPolicy, Bt as assertRealBackend, Ci as CanaryEvaluation, Di as runCanaries, Ei as CanaryReport, Fa as quotaExhaustedUntil, Gt as ToolCallEventLike, Ho as runCampaign, Ht as ArtifactEventLike, Ia as transientDispatchFailure, Jt as CompletionVerdict, Kt as extractProducedState, Ma as llmJudge, Qt as ProducedState, Rt as BackendIntegrityError, Si as CanaryAlert, Ti as CanaryOptions, Ut as ProposalEventLike, Vo as RunCampaignOptions, Vt as summarizeBackendIntegrity, Wt as RuntimeEventLike, Xt as LlmCorrectnessCheckerOpts, Yt as CorrectnessChecker, Zt as ProducedProposal, _i as RedTeamFinding, bi as redTeamReport, en as SatisfiedBy, gi as RedTeamCategory, hi as RedTeamCase, in as verifyCompletion, ja as LlmJudgeOptions, mi as DEFAULT_RED_TEAM_CORPUS, nn as completionVerdict, qt as CompletionRequirement, rn as createLlmCorrectnessChecker, tn as TaskGold, vi as RedTeamReport, wi as CanaryKind, xi as scoreRedTeamOutput, yi as redTeamDataset, zo as CampaignCellFailureReceipt, zt as BackendIntegrityReport } from "./index-DJKZEldg.js";
 import { a as ProfileAxisSpec, c as expandProfileAxes, i as HarnessType, l as harnessAxisOf, n as CODING_HARNESSES, o as agentProfileHash, r as HARNESS_NATIVE_MODEL, s as agentProfileId, t as AgentProfile } from "./agent-profile-DDfIjdyS.js";
 import { i as DatasetSplit, n as DatasetManifest, r as DatasetScenario, t as Dataset } from "./dataset-DQqhOCPt.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";
@@ -27,7 +27,7 @@ import { a as FAILURE_BLAME, c as FailureContext, d as INFRA_FAILURE_BLAMES, f a
 import { d as InsightReport, i as analyzeRuns, t as AnalyzeRunsOptions } from "./analyze-runs-CPiKLJFs.js";
 import { i as ExactAnalystRunEvent, l as ExactCapableAnalyst, o as ExactAnalystRunResult } from "./exact-types-KGxBWH4b.js";
 import { c as RegistryRunOpts, i as BudgetPolicy, n as AnalystRegistry, r as AnalystRegistryOptions, s as ExactRegistryRunOpts } from "./registry-Bu3lNole.js";
-import { _ as SelfImproveMethodResult, a as DefinedAgentEval, c as SelfImproveMethodOptions, d as SelfImproveProposerOptions, f as SelfImproveProposerResult, g as SelfImproveMethodProvenance, h as selfImprove, i as DefineAgentEvalOptions, l as SelfImproveOptions, n as AgentEvalEvaluateOptions, o as defineAgentEval, p as SelfImproveResult, r as AgentEvalImproveOptions, s as SelfImproveBudget, t as AgentEvalAgent, u as SelfImproveProgressEvent } from "./define-agent-eval-C_oqRN9O.js";
+import { _ as SelfImproveMethodResult, a as DefinedAgentEval, c as SelfImproveMethodOptions, d as SelfImproveProposerOptions, f as SelfImproveProposerResult, g as SelfImproveMethodProvenance, h as selfImprove, i as DefineAgentEvalOptions, l as SelfImproveOptions, n as AgentEvalEvaluateOptions, o as defineAgentEval, p as SelfImproveResult, r as AgentEvalImproveOptions, s as SelfImproveBudget, t as AgentEvalAgent, u as SelfImproveProgressEvent } from "./define-agent-eval-ulRlLvse.js";
 import { a as createTraceAnalyst, i as TraceAnalystDefinition, n as buildDefaultAnalystRegistry, r as CreateTraceAnalystOptions, t as DefaultAnalystRegistryOptions } from "./default-registry-D2csUBBQ.js";
 import { i as TraceAnalysisEngineResult, l as RawAnalystFinding, n as TraceAnalysisEngine, t as DEFAULT_TRACE_ANALYST_OUTPUT_TOKENS } from "./engine-De2hfuiQ.js";
 import { A as SemanticConceptJudgeInput, C as DspyRlmTraceEngineOptions, D as ConceptFinding, E as createChatTraceEngine, M as SemanticConceptJudgeResult, N as runSemanticConceptJudge, O as ConceptSpec, T as ChatTraceEngineOptions, _ as FindingSubject, 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 FindingSubjectKind, w as createDspyRlmTraceEngine } from "./index-kKECJfib.js";

package/dist/index.js

@@ -1,7 +1,7 @@
 import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
 import { i as JudgeError, n as CaptureIntegrityError, o as NotFoundError, r as ConfigError, s as ValidationError, t as AgentEvalError } from "./errors-Dngq5h35.js";
 import { a as hashCanonical, r as canonicalString } from "./canonical-BsZVgBhW.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-B0QMdiLh.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-1RnbLrSa.js";
 import { c as groupRunsByAgentProfileCell, d as validateAgentProfileCell, f as verifyAgentProfileCell, h as manifestContentDigest, i as agentProfileCellKey, m as hashJson, r as agentProfileCellHashMaterial, s as buildAgentProfileCell, t as AGENT_PROFILE_KINDS, u as toAgentProfileJson } from "./agent-profile-cell-DcFW4vOc.js";
 import { t as mulberry32 } from "./random-Dn5fPWkt.js";
 import { a as spearmanR, c as weightedMean, i as ranks, n as partialCredit, o as summarizeNumberSeries, r as pearsonR, s as weightedComposite, t as confidenceInterval } from "./descriptive-1V17A-qa.js";
@@ -22,12 +22,12 @@ import { r as observedSplitScore, t as isRealnessGated } from "./reward-nw2xZGZG
 import { a as parseRunRecordSafe, c as runTaskScore, i as modelHasSnapshot, l as searchCellRunId, n as UNKNOWN_MODEL, o as roundTripRunRecord, r as isRunRecord, s as runCostFloorUsd, t as RunRecordValidationError, u as validateRunRecord } from "./run-record-BRlM99rX.js";
 import { a as summaryTable, n as gainHistogram, r as paretoChart } from "./summary-report-BMvou2oZ.js";
 import { n as contentHash, r as fileVerdictCache, t as canonicalJson } from "./verdict-cache-BQEsVy9n.js";
-import { G as requiredPairsForPairedPromotion, J as dominates, W as pairedPromotionPower, Y as paretoFrontier, a as transientDispatchFailure, et as DEFAULT_RED_TEAM_CORPUS, i as quotaExhaustedUntil, it as runCanaries, nt as redTeamReport, o as aggregateRunScore, rt as scoreRedTeamOutput, s as clamp01, t as llmJudge, tt as redTeamDataset, ut as runCampaign } from "./llm-judge-CxfoYqdk.js";
+import { $ as paretoFrontier, G as requiredPairsForPairedPromotion, Q as dominates, W as pairedPromotionPower, a as transientDispatchFailure, at as redTeamDataset, ct as runCanaries, i as quotaExhaustedUntil, it as DEFAULT_RED_TEAM_CORPUS, mt as runCampaign, o as aggregateRunScore, ot as redTeamReport, s as clamp01, st as scoreRedTeamOutput, t as llmJudge } from "./llm-judge-fhkFQL1N.js";
 import { a as resolveModelPricing, i as isModelPriced, n as estimateCost, r as estimateTokens, t as MODEL_PRICING } from "./metrics-DOMpkoeb.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-_IbkejCF.js";
 import { B as assertRealBackend, F as surfaceContentHash, T as parseReflectionResponse, V as summarizeBackendIntegrity, c as ATTESTATION_ALGORITHM, l as attest, u as verifyAttestation, w as buildReflectionPrompt, z as BackendIntegrityError } from "./campaign-evidence-DJc60F9C.js";
 import { d as redactForShare, f as redactText, n as REDACTION_VERSION, p as shareAllowed, r as assessShareSafety, u as redact } from "./redact-Dk1ZdJEm.js";
-import { r as selfImprove, t as defineAgentEval } from "./define-agent-eval-h2qYe0xY.js";
+import { r as selfImprove, t as defineAgentEval } from "./define-agent-eval-4J02MdF7.js";
 import { n as equivalenceVerdict, t as certificationEvidenceDigest } from "./verdict-DhPoXApk.js";
 import { t as TraceEmitter } from "./emitter-DbMXUIVP.js";
 import { t as buildTrajectory } from "./trajectory-D_7rLrvE.js";

package/dist/jev-protocol.d.ts

@@ -1,27 +1,33 @@
 //#region src/jev-protocol.d.ts
-/** Structural equivalents of the native SDK types; callers can use its builders unchanged. */
+/**
+ * Structural equivalents of TypeSafe's published request schema
+ * (https://api.typesafe.ai/openapi.json); callers can use its builders unchanged.
+ */
 type JevJson = string | number | boolean | null | JevJson[] | {
   [key: string]: JevJson;
 };
+/** What TypeSafe accepts as `state` and as a score level: text or JSON, never null. */
 type JevState = string | {
   [key: string]: JevJson;
-} | JevJson[] | null;
+} | JevJson[];
+/** Instructions and choice or noul descriptions, which TypeSafe also accepts as null. */
+type JevDescription = JevState | null;
 type JevScoreCriteria = readonly [JevState, JevState, ...JevState[]];
 type JevQuestion = {
   type: 'noul';
-  instructions?: JevState;
+  instructions?: JevDescription;
   criteria?: {
-    true?: JevState;
-    false?: JevState;
+    true?: JevDescription;
+    false?: JevDescription;
   } | null;
 } | {
   type: 'score';
-  instructions?: JevState;
+  instructions?: JevDescription;
   criteria: JevScoreCriteria;
 } | {
   type: 'choice';
-  instructions?: JevState;
-  criteria: Record<string, JevState>;
+  instructions?: JevDescription;
+  criteria: Record<string, JevDescription>;
 };
 type JevQuestions = Record<string, JevQuestion>;
 interface JevRequest<Q extends JevQuestions = JevQuestions> {
@@ -65,10 +71,12 @@ interface JevResult<Q extends JevQuestions = JevQuestions> {
 declare class JevResponseError extends Error {
   constructor(message: string);
 }
+/** Validate named questions without a state, as a judge does before it has input. */
+declare function parseJevQuestions(raw: unknown): JevQuestions;
 declare function parseJevRequest(raw: unknown): JevRequest;
 declare function jevUsage(raw: unknown): JevResult['usage'];
 /** Validate native evidence, not model alias policy or the caller's scoring rules. */
 declare function parseJevResult<Q extends JevQuestions>(raw: unknown, request: JevRequest<Q>): JevResult<Q>;
 //#endregion
-export { JevAnswer, JevAnswerFor, JevJson, JevQuestion, JevQuestions, JevRequest, JevResponseError, JevResult, JevScoreCriteria, JevState, jevUsage, parseJevRequest, parseJevResult };
+export { JevAnswer, JevAnswerFor, JevDescription, JevJson, JevQuestion, JevQuestions, JevRequest, JevResponseError, JevResult, JevScoreCriteria, JevState, jevUsage, parseJevQuestions, parseJevRequest, parseJevResult };
 //# sourceMappingURL=jev-protocol.d.ts.map

package/dist/jev-protocol.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"jev-protocol.d.ts","names":[],"sources":["../src/jev-protocol.ts"],"mappings":";;KAIY,6CAA6C;GAAe,cAAc;;KAC1E;GAAuB,cAAc;IAAY;KACjD,6BAA6B,UAAU,aAAa;KACpD;EAEN;EACA,eAAe;EACf;IAAa,OAAO;IAAU,QAAQ;;;EAEtC;EAAe,eAAe;EAAU,UAAU;;EAClD;EAAgB,eAAe;EAAU,UAAU,eAAe;;KAC5D,eAAe,eAAe;UACzB,WAAW,UAAU,eAAe;EACnD;EACA,OAAO;EACP,WAAW;;KAGR,UAAU,UAAU,mCAAmC,uBAExD,cAAc;KACN,aAAa,UAAU,eAAe;EAAY;;WAC/C;WAAuB;IAClC;EAAY;EAAe,gBAAgB,UAAU;;WAExC;WACA;WACA;WACA,oBAAoB,KAAK,UAAU,KAAK,EAAE;WAC1C,2BAA2B,KAAK,UAAU;IAErD;EAAY;EAAgB,gBAAgB;;WAE/B;WACA,cAAc;WACd;WACA,2BAA2B,WAAW;;KAG7C,YAAY,aAAa;UACpB,UAAU,UAAU,eAAe;WACzC;WACA,qBAAqB,WAAW,IAAI,aAAa,EAAE;WACnD;aAAkB;aAA+B;;;cAG/C,yBAAyB;EACpC,YAAY;;iBAoBE,gBAAgB,eAAe;iBAqC/B,SAAS,eAAe;;iBA2BxB,eAAe,UAAU,cACvC,cACA,SAAS,WAAW,KACnB,UAAU"}
+{"version":3,"file":"jev-protocol.d.ts","names":[],"sources":["../src/jev-protocol.ts"],"mappings":";;;;;KAOY,6CAA6C;GAAe,cAAc;;;KAE1E;GAAuB,cAAc;IAAY;;KAEjD,iBAAiB;KACjB,6BAA6B,UAAU,aAAa;KACpD;EAEN;EACA,eAAe;EACf;IAAa,OAAO;IAAgB,QAAQ;;;EAE5C;EAAe,eAAe;EAAgB,UAAU;;EACxD;EAAgB,eAAe;EAAgB,UAAU,eAAe;;KAClE,eAAe,eAAe;UACzB,WAAW,UAAU,eAAe;EACnD;EACA,OAAO;EACP,WAAW;;KAGR,UAAU,UAAU,mCAAmC,uBAExD,cAAc;KACN,aAAa,UAAU,eAAe;EAAY;;WAC/C;WAAuB;IAClC;EAAY;EAAe,gBAAgB,UAAU;;WAExC;WACA;WACA;WACA,oBAAoB,KAAK,UAAU,KAAK,EAAE;WAC1C,2BAA2B,KAAK,UAAU;IAErD;EAAY;EAAgB,gBAAgB;;WAE/B;WACA,cAAc;WACd;WACA,2BAA2B,WAAW;;KAG7C,YAAY,aAAa;UACpB,UAAU,UAAU,eAAe;WACzC;WACA,qBAAqB,WAAW,IAAI,aAAa,EAAE;WACnD;aAAkB;aAA+B;;;cAG/C,yBAAyB;EACpC,YAAY;;;iBA6BE,kBAAkB,eAAe;iBAkCjC,gBAAgB,eAAe;iBAU/B,SAAS,eAAe;;iBA2BxB,eAAe,UAAU,cACvC,cACA,SAAS,WAAW,KACnB,UAAU"}

package/dist/jev-protocol.js

@@ -11,37 +11,45 @@ function object(value) {
 	if (value === null || typeof value !== "object" || Array.isArray(value)) throw new JevResponseError("Expected an object");
 	return value;
 }
-function entry(value) {
-	if (value === null || typeof value === "string") return;
-	if (typeof value !== "object") throw new TypeError("Expected text, JSON object/array, or null");
+function textOrJson(value, name) {
+	if (typeof value === "string") return;
+	if (value === null || typeof value !== "object") throw new TypeError(`${name} must be text or a JSON object/array`);
 	canonicalString(value);
 }
-function parseJevRequest(raw) {
-	const request = object(raw);
-	if (typeof request.model !== "string" || !request.model.trim()) throw new TypeError("Evaluation requires a model");
-	entry(request.state);
-	const questions = object(request.questions);
+function optionalTextOrJson(value, name) {
+	if (value !== null) textOrJson(value, name);
+}
+/** Validate named questions without a state, as a judge does before it has input. */
+function parseJevQuestions(raw) {
+	const questions = object(raw);
 	if (!Object.keys(questions).length) throw new TypeError("At least one question is required");
-	for (const rawQuestion of Object.values(questions)) {
+	for (const [name, rawQuestion] of Object.entries(questions)) {
 		const question = object(rawQuestion);
-		if (question.instructions !== void 0) entry(question.instructions);
+		if (question.instructions !== void 0) optionalTextOrJson(question.instructions, `${name} instructions`);
 		if (question.type === "noul") {
 			if (question.criteria != null) {
 				const criteria = object(question.criteria);
 				if (Object.keys(criteria).some((key) => key !== "true" && key !== "false")) throw new TypeError("Noul criteria must describe true and/or false");
-				for (const value of Object.values(criteria)) if (value !== void 0) entry(value);
+				for (const value of Object.values(criteria)) if (value !== void 0) optionalTextOrJson(value, `${name} criteria`);
 			}
 		} else if (question.type === "score") {
 			if (!Array.isArray(question.criteria) || question.criteria.length < 2) throw new TypeError("Score criteria require at least two ordered entries");
-			for (const value of question.criteria) entry(value);
+			for (const value of question.criteria) textOrJson(value, `${name} score level`);
 		} else if (question.type === "choice") {
 			const criteria = object(question.criteria);
 			if (!Object.keys(criteria).length) throw new TypeError("Choice criteria cannot be empty");
-			for (const value of Object.values(criteria)) entry(value);
+			for (const value of Object.values(criteria)) optionalTextOrJson(value, `${name} choice`);
 		} else throw new TypeError("Unsupported native question type");
 	}
 	return raw;
 }
+function parseJevRequest(raw) {
+	const request = object(raw);
+	if (typeof request.model !== "string" || !request.model.trim()) throw new TypeError("Evaluation requires a model");
+	textOrJson(request.state, "Evaluation state");
+	parseJevQuestions(request.questions);
+	return raw;
+}
 function jevUsage(raw) {
 	const usage = object(object(raw).usage);
 	for (const key of ["input_tokens", "output_tokens"]) if (!Number.isSafeInteger(usage[key]) || Number(usage[key]) < 0) throw new JevResponseError("Missing or invalid usage");
@@ -86,6 +94,6 @@ function parseJevResult(raw, request) {
 	return raw;
 }
 //#endregion
-export { JevResponseError, jevUsage, parseJevRequest, parseJevResult };
+export { JevResponseError, jevUsage, parseJevQuestions, parseJevRequest, parseJevResult };
 
 //# sourceMappingURL=jev-protocol.js.map

package/dist/jev-protocol.js.map

@@ -1 +1 @@
-{"version":3,"file":"jev-protocol.js","names":[],"sources":["../src/jev-protocol.ts"],"sourcesContent":["import { isDeepStrictEqual } from 'node:util'\nimport { canonicalString } from './ledger-core/canonical'\n\n/** Structural equivalents of the native SDK types; callers can use its builders unchanged. */\nexport type JevJson = string | number | boolean | null | JevJson[] | { [key: string]: JevJson }\nexport type JevState = string | { [key: string]: JevJson } | JevJson[] | null\nexport type JevScoreCriteria = readonly [JevState, JevState, ...JevState[]]\nexport type JevQuestion =\n  | {\n      type: 'noul'\n      instructions?: JevState\n      criteria?: { true?: JevState; false?: JevState } | null\n    }\n  | { type: 'score'; instructions?: JevState; criteria: JevScoreCriteria }\n  | { type: 'choice'; instructions?: JevState; criteria: Record<string, JevState> }\nexport type JevQuestions = Record<string, JevQuestion>\nexport interface JevRequest<Q extends JevQuestions = JevQuestions> {\n  model: string\n  state: JevState\n  questions: Q\n}\n\ntype ScoreKeys<T extends JevScoreCriteria> = number extends T['length']\n  ? number\n  : Extract<keyof T, `${number}`>\nexport type JevAnswerFor<Q extends JevQuestion> = Q extends { type: 'noul' }\n  ? { readonly type: 'noul'; readonly noul: number }\n  : Q extends { type: 'score'; criteria: infer C extends JevScoreCriteria }\n    ? {\n        readonly type: 'score'\n        readonly score: number\n        readonly confidence: number\n        readonly legend: { readonly [K in ScoreKeys<C>]: C[K] }\n        readonly probabilities: { readonly [K in ScoreKeys<C>]: number }\n      }\n    : Q extends { type: 'choice'; criteria: infer C }\n      ? {\n          readonly type: 'choice'\n          readonly choice: keyof C & string\n          readonly confidence: number\n          readonly probabilities: { readonly [K in keyof C]: number }\n        }\n      : never\nexport type JevAnswer = JevAnswerFor<JevQuestion>\nexport interface JevResult<Q extends JevQuestions = JevQuestions> {\n  readonly model: string\n  readonly answers: { readonly [K in keyof Q]: JevAnswerFor<Q[K]> }\n  readonly usage: { readonly input_tokens: number; readonly output_tokens: number }\n}\n\nexport class JevResponseError extends Error {\n  constructor(message: string) {\n    super(`Jev: ${message}`)\n    this.name = 'JevResponseError'\n  }\n}\n\nfunction object(value: unknown): Record<string, unknown> {\n  if (value === null || typeof value !== 'object' || Array.isArray(value)) {\n    throw new JevResponseError('Expected an object')\n  }\n  return value as Record<string, unknown>\n}\n\nfunction entry(value: unknown): void {\n  if (value === null || typeof value === 'string') return\n  if (typeof value !== 'object') throw new TypeError('Expected text, JSON object/array, or null')\n  // Reuse the canonical JSON validator rather than accepting lossy Map/Date coercions.\n  canonicalString(value)\n}\n\nexport function parseJevRequest(raw: unknown): JevRequest {\n  const request = object(raw)\n  if (typeof request.model !== 'string' || !request.model.trim()) {\n    throw new TypeError('Evaluation requires a model')\n  }\n  entry(request.state)\n  const questions = object(request.questions)\n  if (!Object.keys(questions).length) throw new TypeError('At least one question is required')\n  for (const rawQuestion of Object.values(questions)) {\n    const question = object(rawQuestion)\n    if (question.instructions !== undefined) entry(question.instructions)\n    if (question.type === 'noul') {\n      if (question.criteria != null) {\n        const criteria = object(question.criteria)\n        if (Object.keys(criteria).some((key) => key !== 'true' && key !== 'false')) {\n          throw new TypeError('Noul criteria must describe true and/or false')\n        }\n        for (const value of Object.values(criteria)) {\n          if (value !== undefined) entry(value)\n        }\n      }\n    } else if (question.type === 'score') {\n      if (!Array.isArray(question.criteria) || question.criteria.length < 2) {\n        throw new TypeError('Score criteria require at least two ordered entries')\n      }\n      for (const value of question.criteria) entry(value)\n    } else if (question.type === 'choice') {\n      const criteria = object(question.criteria)\n      if (!Object.keys(criteria).length) throw new TypeError('Choice criteria cannot be empty')\n      for (const value of Object.values(criteria)) entry(value)\n    } else {\n      throw new TypeError('Unsupported native question type')\n    }\n  }\n  return raw as JevRequest\n}\n\nexport function jevUsage(raw: unknown): JevResult['usage'] {\n  const usage = object(object(raw).usage)\n  for (const key of ['input_tokens', 'output_tokens']) {\n    if (!Number.isSafeInteger(usage[key]) || Number(usage[key]) < 0) {\n      throw new JevResponseError('Missing or invalid usage')\n    }\n  }\n  return usage as unknown as JevResult['usage']\n}\n\nfunction probability(value: unknown): number {\n  if (typeof value !== 'number' || !Number.isFinite(value) || value < 0 || value > 1) {\n    throw new JevResponseError('Invalid probability')\n  }\n  return value\n}\n\nfunction exactKeys(value: Record<string, unknown>, names: string[]): void {\n  if (\n    Object.keys(value).length !== names.length ||\n    names.some((key) => !Object.hasOwn(value, key))\n  ) {\n    throw new JevResponseError('Response keys differ from the request')\n  }\n}\n\n/** Validate native evidence, not model alias policy or the caller's scoring rules. */\nexport function parseJevResult<Q extends JevQuestions>(\n  raw: unknown,\n  request: JevRequest<Q>,\n): JevResult<Q> {\n  // Preserve extension metadata, rejecting values that change when persisted as JSON.\n  canonicalString(raw)\n  const response = object(raw)\n  if (typeof response.model !== 'string' || !response.model.trim()) {\n    throw new JevResponseError('Missing served model')\n  }\n  const answers = object(response.answers)\n  exactKeys(answers, Object.keys(request.questions))\n  for (const [name, question] of Object.entries(request.questions)) {\n    const answer = object(answers[name])\n    if (answer.type !== question.type) throw new JevResponseError('Wrong answer type')\n    if (question.type === 'noul') {\n      probability(answer.noul)\n      continue\n    }\n    probability(answer.confidence)\n    const levels =\n      question.type === 'score'\n        ? question.criteria.map((_, index) => String(index))\n        : Object.keys(question.criteria)\n    const probabilities = object(answer.probabilities)\n    exactKeys(probabilities, levels)\n    const sum = levels.reduce((total, level) => total + probability(probabilities[level]), 0)\n    if (Math.abs(sum - 1) > 0.0001) throw new JevResponseError('Invalid probability distribution')\n    if (question.type === 'score') {\n      const legend = object(answer.legend)\n      exactKeys(legend, levels)\n      if (\n        levels.some((level) => !isDeepStrictEqual(legend[level], question.criteria[Number(level)]))\n      ) {\n        throw new JevResponseError('Provider changed the rubric')\n      }\n      const expected = levels.reduce(\n        (total, level) => total + Number(level) * Number(probabilities[level]),\n        0,\n      )\n      if (\n        typeof answer.score !== 'number' ||\n        !Number.isFinite(answer.score) ||\n        Math.abs(answer.score - expected) > 0.0001\n      ) {\n        throw new JevResponseError('Score differs from its distribution')\n      }\n    } else if (\n      typeof answer.choice !== 'string' ||\n      !Object.hasOwn(probabilities, answer.choice) ||\n      levels.some(\n        (level) =>\n          Number(probabilities[level]) > Number(probabilities[String(answer.choice)]) + 0.0001,\n      )\n    ) {\n      throw new JevResponseError('Choice is not a highest-probability option')\n    }\n  }\n  jevUsage(raw)\n  return raw as JevResult<Q>\n}\n"],"mappings":"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"}
+{"version":3,"file":"jev-protocol.js","names":[],"sources":["../src/jev-protocol.ts"],"sourcesContent":["import { isDeepStrictEqual } from 'node:util'\nimport { canonicalString } from './ledger-core/canonical'\n\n/**\n * Structural equivalents of TypeSafe's published request schema\n * (https://api.typesafe.ai/openapi.json); callers can use its builders unchanged.\n */\nexport type JevJson = string | number | boolean | null | JevJson[] | { [key: string]: JevJson }\n/** What TypeSafe accepts as `state` and as a score level: text or JSON, never null. */\nexport type JevState = string | { [key: string]: JevJson } | JevJson[]\n/** Instructions and choice or noul descriptions, which TypeSafe also accepts as null. */\nexport type JevDescription = JevState | null\nexport type JevScoreCriteria = readonly [JevState, JevState, ...JevState[]]\nexport type JevQuestion =\n  | {\n      type: 'noul'\n      instructions?: JevDescription\n      criteria?: { true?: JevDescription; false?: JevDescription } | null\n    }\n  | { type: 'score'; instructions?: JevDescription; criteria: JevScoreCriteria }\n  | { type: 'choice'; instructions?: JevDescription; criteria: Record<string, JevDescription> }\nexport type JevQuestions = Record<string, JevQuestion>\nexport interface JevRequest<Q extends JevQuestions = JevQuestions> {\n  model: string\n  state: JevState\n  questions: Q\n}\n\ntype ScoreKeys<T extends JevScoreCriteria> = number extends T['length']\n  ? number\n  : Extract<keyof T, `${number}`>\nexport type JevAnswerFor<Q extends JevQuestion> = Q extends { type: 'noul' }\n  ? { readonly type: 'noul'; readonly noul: number }\n  : Q extends { type: 'score'; criteria: infer C extends JevScoreCriteria }\n    ? {\n        readonly type: 'score'\n        readonly score: number\n        readonly confidence: number\n        readonly legend: { readonly [K in ScoreKeys<C>]: C[K] }\n        readonly probabilities: { readonly [K in ScoreKeys<C>]: number }\n      }\n    : Q extends { type: 'choice'; criteria: infer C }\n      ? {\n          readonly type: 'choice'\n          readonly choice: keyof C & string\n          readonly confidence: number\n          readonly probabilities: { readonly [K in keyof C]: number }\n        }\n      : never\nexport type JevAnswer = JevAnswerFor<JevQuestion>\nexport interface JevResult<Q extends JevQuestions = JevQuestions> {\n  readonly model: string\n  readonly answers: { readonly [K in keyof Q]: JevAnswerFor<Q[K]> }\n  readonly usage: { readonly input_tokens: number; readonly output_tokens: number }\n}\n\nexport class JevResponseError extends Error {\n  constructor(message: string) {\n    super(`Jev: ${message}`)\n    this.name = 'JevResponseError'\n  }\n}\n\nfunction object(value: unknown): Record<string, unknown> {\n  if (value === null || typeof value !== 'object' || Array.isArray(value)) {\n    throw new JevResponseError('Expected an object')\n  }\n  return value as Record<string, unknown>\n}\n\n// TypeSafe answers 422 for a null state or score level. Refusing it here reports the\n// caller's mistake before a paid round trip, not as a provider failure after one.\nfunction textOrJson(value: unknown, name: string): void {\n  if (typeof value === 'string') return\n  if (value === null || typeof value !== 'object') {\n    throw new TypeError(`${name} must be text or a JSON object/array`)\n  }\n  // Reuse the canonical JSON validator rather than accepting lossy Map/Date coercions.\n  canonicalString(value)\n}\n\nfunction optionalTextOrJson(value: unknown, name: string): void {\n  if (value !== null) textOrJson(value, name)\n}\n\n/** Validate named questions without a state, as a judge does before it has input. */\nexport function parseJevQuestions(raw: unknown): JevQuestions {\n  const questions = object(raw)\n  if (!Object.keys(questions).length) throw new TypeError('At least one question is required')\n  for (const [name, rawQuestion] of Object.entries(questions)) {\n    const question = object(rawQuestion)\n    if (question.instructions !== undefined) {\n      optionalTextOrJson(question.instructions, `${name} instructions`)\n    }\n    if (question.type === 'noul') {\n      if (question.criteria != null) {\n        const criteria = object(question.criteria)\n        if (Object.keys(criteria).some((key) => key !== 'true' && key !== 'false')) {\n          throw new TypeError('Noul criteria must describe true and/or false')\n        }\n        for (const value of Object.values(criteria)) {\n          if (value !== undefined) optionalTextOrJson(value, `${name} criteria`)\n        }\n      }\n    } else if (question.type === 'score') {\n      if (!Array.isArray(question.criteria) || question.criteria.length < 2) {\n        throw new TypeError('Score criteria require at least two ordered entries')\n      }\n      for (const value of question.criteria) textOrJson(value, `${name} score level`)\n    } else if (question.type === 'choice') {\n      const criteria = object(question.criteria)\n      if (!Object.keys(criteria).length) throw new TypeError('Choice criteria cannot be empty')\n      for (const value of Object.values(criteria)) optionalTextOrJson(value, `${name} choice`)\n    } else {\n      throw new TypeError('Unsupported native question type')\n    }\n  }\n  return raw as JevQuestions\n}\n\nexport function parseJevRequest(raw: unknown): JevRequest {\n  const request = object(raw)\n  if (typeof request.model !== 'string' || !request.model.trim()) {\n    throw new TypeError('Evaluation requires a model')\n  }\n  textOrJson(request.state, 'Evaluation state')\n  parseJevQuestions(request.questions)\n  return raw as JevRequest\n}\n\nexport function jevUsage(raw: unknown): JevResult['usage'] {\n  const usage = object(object(raw).usage)\n  for (const key of ['input_tokens', 'output_tokens']) {\n    if (!Number.isSafeInteger(usage[key]) || Number(usage[key]) < 0) {\n      throw new JevResponseError('Missing or invalid usage')\n    }\n  }\n  return usage as unknown as JevResult['usage']\n}\n\nfunction probability(value: unknown): number {\n  if (typeof value !== 'number' || !Number.isFinite(value) || value < 0 || value > 1) {\n    throw new JevResponseError('Invalid probability')\n  }\n  return value\n}\n\nfunction exactKeys(value: Record<string, unknown>, names: string[]): void {\n  if (\n    Object.keys(value).length !== names.length ||\n    names.some((key) => !Object.hasOwn(value, key))\n  ) {\n    throw new JevResponseError('Response keys differ from the request')\n  }\n}\n\n/** Validate native evidence, not model alias policy or the caller's scoring rules. */\nexport function parseJevResult<Q extends JevQuestions>(\n  raw: unknown,\n  request: JevRequest<Q>,\n): JevResult<Q> {\n  // Preserve extension metadata, rejecting values that change when persisted as JSON.\n  canonicalString(raw)\n  const response = object(raw)\n  if (typeof response.model !== 'string' || !response.model.trim()) {\n    throw new JevResponseError('Missing served model')\n  }\n  const answers = object(response.answers)\n  exactKeys(answers, Object.keys(request.questions))\n  for (const [name, question] of Object.entries(request.questions)) {\n    const answer = object(answers[name])\n    if (answer.type !== question.type) throw new JevResponseError('Wrong answer type')\n    if (question.type === 'noul') {\n      probability(answer.noul)\n      continue\n    }\n    probability(answer.confidence)\n    const levels =\n      question.type === 'score'\n        ? question.criteria.map((_, index) => String(index))\n        : Object.keys(question.criteria)\n    const probabilities = object(answer.probabilities)\n    exactKeys(probabilities, levels)\n    const sum = levels.reduce((total, level) => total + probability(probabilities[level]), 0)\n    if (Math.abs(sum - 1) > 0.0001) throw new JevResponseError('Invalid probability distribution')\n    if (question.type === 'score') {\n      const legend = object(answer.legend)\n      exactKeys(legend, levels)\n      if (\n        levels.some((level) => !isDeepStrictEqual(legend[level], question.criteria[Number(level)]))\n      ) {\n        throw new JevResponseError('Provider changed the rubric')\n      }\n      const expected = levels.reduce(\n        (total, level) => total + Number(level) * Number(probabilities[level]),\n        0,\n      )\n      if (\n        typeof answer.score !== 'number' ||\n        !Number.isFinite(answer.score) ||\n        Math.abs(answer.score - expected) > 0.0001\n      ) {\n        throw new JevResponseError('Score differs from its distribution')\n      }\n    } else if (\n      typeof answer.choice !== 'string' ||\n      !Object.hasOwn(probabilities, answer.choice) ||\n      levels.some(\n        (level) =>\n          Number(probabilities[level]) > Number(probabilities[String(answer.choice)]) + 0.0001,\n      )\n    ) {\n      throw new JevResponseError('Choice is not a highest-probability option')\n    }\n  }\n  jevUsage(raw)\n  return raw as JevResult<Q>\n}\n"],"mappings":"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"}

package/dist/jev.d.ts

@@ -2,7 +2,7 @@ import { b as CustomTokenPricing, g as CostReceiptInput } from "./cost-ledger-Db
 import { i as AnalystFinding, n as AnalystContext, t as Analyst } from "./types-CeDfCRXp.js";
 import { R as Scenario, S as JudgeConfig, w as JudgeScore } from "./types-B2673PBj.js";
 import { EvaluationAnalystOptions, EvaluationContext, EvaluationJudgeOptions, EvaluationResult, Evaluator, EvaluatorOptions, asAnalyst, asJudge, createEvaluator } from "./evaluation.js";
-import { JevAnswer, JevAnswerFor, JevJson, JevQuestion, JevQuestions, JevRequest, JevResponseError, JevResult, JevScoreCriteria, JevState, jevUsage, parseJevRequest, parseJevResult } from "./jev-protocol.js";
+import { JevAnswer, JevAnswerFor, JevDescription, JevJson, JevQuestion, JevQuestions, JevRequest, JevResponseError, JevResult, JevScoreCriteria, JevState, jevUsage, parseJevQuestions, parseJevRequest, parseJevResult } from "./jev-protocol.js";
 import { z } from "zod";
 //#region src/jev-review.d.ts
 declare const checkSchema: z.ZodObject<{
@@ -127,5 +127,5 @@ interface JevAnalystOptions<I, Q extends JevQuestions = JevQuestions> extends Je
 }
 declare function jevAnalyst<I, Q extends JevQuestions = JevQuestions>(options: JevAnalystOptions<I, Q>): Analyst<I>;
 //#endregion
-export { EvaluationAnalystOptions, EvaluationContext, EvaluationJudgeOptions, EvaluationResult, Evaluator, EvaluatorOptions, JevAnalystOptions, JevAnswer, JevAnswerFor, JevEvaluate, JevEvaluatorOptions, JevJson, JevJudgeOptions, JevOptions, JevQuestion, JevQuestions, JevRequest, JevResponseError, JevResult, JevReviewAssessment, JevReviewCheck, JevReviewInput, JevReviewReport, JevScoreCriteria, JevState, PreparedJevReview, asAnalyst, asJudge, assessJevReview, createEvaluator, jevAnalyst, jevEvaluator, jevJudge, jevReviewFindings, jevUsage, normalizedJevScore, parseJevRequest, parseJevResult, prepareJevReview };
+export { EvaluationAnalystOptions, EvaluationContext, EvaluationJudgeOptions, EvaluationResult, Evaluator, EvaluatorOptions, JevAnalystOptions, JevAnswer, JevAnswerFor, JevDescription, JevEvaluate, JevEvaluatorOptions, JevJson, JevJudgeOptions, JevOptions, JevQuestion, JevQuestions, JevRequest, JevResponseError, JevResult, JevReviewAssessment, JevReviewCheck, JevReviewInput, JevReviewReport, JevScoreCriteria, JevState, PreparedJevReview, asAnalyst, asJudge, assessJevReview, createEvaluator, jevAnalyst, jevEvaluator, jevJudge, jevReviewFindings, jevUsage, normalizedJevScore, parseJevQuestions, parseJevRequest, parseJevResult, prepareJevReview };
 //# sourceMappingURL=jev.d.ts.map

package/dist/jev.js

@@ -4,7 +4,7 @@ import { n as contentHash } from "./verdict-cache-BQEsVy9n.js";
 import { t as deepFreezeCanonicalJson } from "./deep-freeze-CurcOQg3.js";
 import { r as makeFinding, t as ANALYST_SEVERITIES } from "./types-CW5b90JH.js";
 import { asAnalyst, asJudge, createEvaluator } from "./evaluation.js";
-import { JevResponseError, jevUsage, parseJevRequest, parseJevResult } from "./jev-protocol.js";
+import { JevResponseError, jevUsage, parseJevQuestions, parseJevRequest, parseJevResult } from "./jev-protocol.js";
 import { z } from "zod";
 //#region src/jev-review.ts
 const name = z.string().trim().min(1);
@@ -247,11 +247,7 @@ function jevJudge(name, options) {
 	if (!name.trim() || !options.version.trim()) throw new TypeError("Judge name and version are required");
 	if ((typeof source === "function" || config.map) && !config.dimensions) throw new TypeError("Dynamic questions and custom mappings require stable judge dimensions");
 	if (!config.map && typeof source !== "function") {
-		parseJevRequest({
-			model: config.model,
-			state: null,
-			questions: source
-		});
+		parseJevQuestions(source);
 		if (Object.values(source).some((question) => question.type === "choice")) throw new TypeError("Choice scoring requires an explicit map; labels have no numeric ordering");
 		if (weights) validateWeights(weights, Object.keys(source));
 	}
@@ -308,6 +304,6 @@ function jevAnalyst(options) {
 	});
 }
 //#endregion
-export { JevResponseError, asAnalyst, asJudge, assessJevReview, createEvaluator, jevAnalyst, jevEvaluator, jevJudge, jevReviewFindings, jevUsage, normalizedJevScore, parseJevRequest, parseJevResult, prepareJevReview };
+export { JevResponseError, asAnalyst, asJudge, assessJevReview, createEvaluator, jevAnalyst, jevEvaluator, jevJudge, jevReviewFindings, jevUsage, normalizedJevScore, parseJevQuestions, parseJevRequest, parseJevResult, prepareJevReview };
 
 //# sourceMappingURL=jev.js.map