@tangle-network/agent-eval 0.199.1 → 0.200.0

package/CHANGELOG.md

@@ -4,6 +4,10 @@ All notable changes to `@tangle-network/agent-eval` and its sibling `agent-eval-
 
 ---
 
+## [0.200.0] — 2026-09-27
+
+- feat(rl): decide whether a checker-verified claim is a result about its source or only about its checker (#882)
+
 ## [0.199.1] — 2026-09-27
 
 - fix(release): keep the analyst dependency pin stable across version bumps (#883)

package/dist/analyst/index.d.ts

@@ -10,6 +10,7 @@ import { n as buildTraceToolsForGroup, t as TraceToolGroupName } from "../tool-g
 import { A as SemanticConceptJudgeInput, C as DspyRlmTraceEngineOptions, E as createChatTraceEngine, S as renderFindingSubject, T as ChatTraceEngineOptions, _ as FindingSubject, a as FAILURE_MODE_KIND_SPEC, b as findingSubjectGrammarPromptFor, c as emitControlIntegrityFindings, d as FindingsStore, f as PersistedFinding, g as FINDING_SUBJECT_SYNTAX, h as FINDING_SUBJECT_KINDS, i as IMPROVEMENT_KIND_SPEC, j as SemanticConceptJudgeOptions, l as DiffPolicy, m as diffFindings, n as KNOWLEDGE_POISONING_KIND_SPEC, o as CONTROL_INTEGRITY_ANALYST, p as defaultIsMaterial, r as KNOWLEDGE_GAP_KIND_SPEC, s as ControlIntegrityAnalyst, t as DEFAULT_TRACE_ANALYST_KINDS, u as FindingsDiff, v as FindingSubjectKind, w as createDspyRlmTraceEngine, x as parseFindingSubject, y as KIND_EXPECTED_SUBJECTS } from "../index-Bi2fLITd.js";
 import { A as ReplyRowDecoded, C as primeProtocolSha256, D as DecodedReply, E as runPrimeExchange, M as decodeReplyRows, O as ReplyContract, S as normalizePrimeUsage, T as projectPrimeTrajectory, _ as buildPrimePrompt, a as PrimeProjectionOutcome, b as extractPrimeJsonObject, c as PrimeProtocolIdentity, d as PrimeRepairPromptSpec, f as PrimeRepairState, g as analystUsageReceiptFromPrimeUsage, h as PrimeTurnRecord, i as PrimeProjectionDelivery, j as ReplyRowRejection, k as ReplyEnvelope, l as PrimeRawUsage, m as PrimeRowDecoded, n as PrimeExchangeOutcome, o as PrimeProjectionSource, p as PrimeReplyContract, r as PrimeFailure, s as PrimePromptSpec, t as PrimeExchangeOptions, u as PrimeRejectedRow, v as buildPrimeRepairPrompt, w as primeReplyDefect, x as mergePrimeRawUsage, y as emptyPrimeRawUsage } from "../prime-protocol-T0i6xcAs.js";
 import { i as nodeHttpPrimeBridgeTransport, n as PrimeBridgeTransportRequest, r as PrimeBridgeTransportResult, t as PrimeBridgeTransport } from "../prime-bridge-transport-6feEglLf.js";
+import { a as askTraceQuestions, i as VerifiedTraceFinding, n as TraceQuestionOutcome, o as citedSpansOnly, r as TraceQuestionSpec, t as AskTraceQuestionsOptions } from "../trace-questions-DnqdmwyV.js";
 import { z } from "zod";
 //#region src/analyst/adapters.d.ts
 interface SemanticConceptJudgeAdapterOpts {
@@ -1357,68 +1358,5 @@ declare function isProposalFinding(finding: unknown): finding is ProposalFinding
  */
 declare function assertProposalFindings(findings: unknown, context?: string): ReadonlyArray<ProposalFinding>;
 //#endregion
-//#region src/analyst/trace-questions.d.ts
-/** One question to ask of the store. */
-interface TraceQuestionSpec {
-  /** Stable id: letters, digits, dot, underscore, hyphen. */
-  readonly id: string;
-  readonly question: string;
-  /** Guidance for this question only, after the shared rules. */
-  readonly instructions?: string;
-}
-interface AskTraceQuestionsOptions {
-  readonly questions: readonly TraceQuestionSpec[];
-  readonly store: TraceAnalysisStore;
-  readonly engine: TraceAnalysisEngine;
-  /** Every question and verifier charges this ledger; its ceiling bounds the whole call. */
-  readonly costLedger: CostLedgerHandle;
-  /** Stable id for cost attribution and logs. */
-  readonly runId: string;
-  /** Material every question receives before its first model call, such as the check's verdict. */
-  readonly context?: string;
-  /** Investigations running at once. Default 4. */
-  readonly concurrency?: number;
-  /** Distinct citations a finding needs. Default 2. */
-  readonly minimumEvidenceCitations?: number;
-  /** Run the independent verifier on every admitted finding. Default true. */
-  readonly verify?: boolean;
-  readonly limits?: Partial<TraceAnalystLimits>;
-  readonly signal?: AbortSignal;
-  readonly log?: (message: string, fields?: Record<string, unknown>) => void;
-}
-/** A finding and what the verifier, shown only its cited spans, concluded. */
-interface VerifiedTraceFinding {
-  readonly finding: RawAnalystFinding;
-  /** The finding's trace citations, as `trace://` URIs. */
-  readonly citations: readonly string[];
-  /** `true` supported, `false` not supported, `null` when verification was off or failed. */
-  readonly verified: boolean | null;
-  /** The verifier's own words, when it answered. */
-  readonly verifierAnswer?: string;
-}
-interface TraceQuestionOutcome {
-  readonly id: string;
-  readonly question: string;
-  readonly status: 'answered' | 'failed';
-  readonly failure?: string;
-  /** The engine's prose answer, verbatim; `null` when it returned none. */
-  readonly answer: string | null;
-  readonly findings: readonly VerifiedTraceFinding[];
-  /** `null` when the engine failed before reporting. */
-  readonly modelCalls: number | null;
-  readonly toolCalls: number | null;
-}
-/**
- * Ask every question, then verify every admitted finding. Never throws for a failed question or
- * verifier: each failure is recorded on its outcome. Throws before any model call for a malformed
- * question list or options.
- */
-declare function askTraceQuestions(opts: AskTraceQuestionsOptions): Promise<TraceQuestionOutcome[]>;
-/**
- * A store that exposes exactly the cited spans. Discovery and whole-trace reads refuse, so the
- * verifier cannot go looking for other support; the underlying store's bounds still apply.
- */
-declare function citedSpansOnly(store: TraceAnalysisStore, allowed: ReadonlyMap<string, ReadonlySet<string>>): TraceAnalysisStore;
-//#endregion
 export { AGENT_RX_UPSTREAM_REVISION, ANALYST_BENCHMARK_COST_LEDGER_FILE, ANALYST_BENCHMARK_DEPENDENCY_LOCK_DIGEST_ALGORITHM, ANALYST_BENCHMARK_DEPENDENCY_LOCK_FILES, ANALYST_BENCHMARK_DEPENDENCY_LOCK_SHA256, ANALYST_BENCHMARK_EVIDENCE_DEPENDENCY_LOCK_SHA256, ANALYST_BENCHMARK_EVIDENCE_IMPLEMENTATION_SHA256, ANALYST_BENCHMARK_IMPLEMENTATION_DIGEST_ALGORITHM, ANALYST_BENCHMARK_IMPLEMENTATION_FILES, ANALYST_BENCHMARK_IMPLEMENTATION_SHA256, ANALYST_BENCHMARK_LOCAL_RECEIPT_FILE, ANALYST_BENCHMARK_MANIFEST_FILE, ANALYST_BENCHMARK_OBSERVATIONS_FILE, type AgentRxBenchmarkCaseOptions, type AgentRxCalibrationRunnerSummary, type AgentRxCalibrationSummary, type AgentRxFailure, type AgentRxPrediction, type AgentRxPredictionReport, type AgentRxRow, type Analyst, type AnalystBenchmarkArtifact, type AnalystBenchmarkCase, type AnalystBenchmarkCommandConfig, type AnalystBenchmarkCommandDependencies, type AnalystBenchmarkDatasetRef, type AnalystBenchmarkDescriptor, type AnalystBenchmarkError, type AnalystBenchmarkLabelState, type AnalystBenchmarkLocalRunReceipt, type AnalystBenchmarkObservation, type AnalystBenchmarkOutput, type AnalystBenchmarkProgressRow, type AnalystBenchmarkProvenance, type AnalystBenchmarkResult, type AnalystBenchmarkRunIdentity, type AnalystBenchmarkRunManifest, type AnalystBenchmarkRunner, type AnalystBenchmarkSummary, type AnalystBudgetDeclaration, type AnalystComparisonMetric, type AnalystContext, type AnalystCost, type AnalystDefinition, type AnalystDefinitionAsymmetry, type AnalystDefinitionAsymmetryReport, type AnalystEvidenceBinding, type AnalystEvidenceExpectation, type AnalystEvidenceResolution, type AnalystEvidenceResolutionError, type AnalystEvidenceResolver, AnalystExpressivenessError, type AnalystFinding, type AnalystFindingScore, type AnalystHooks, type AnalystInputKind, type AnalystInstructionsOverride, type AnalystIssueExpectation, type AnalystLatencyDistribution, type AnalystMetricComparison, type AnalystProfileFragment, AnalystRegistry, type AnalystRegistryOptions, type AnalystRepairDeclaration, type AnalystRequirements, type AnalystRowExpansion, type AnalystRunEvent, type AnalystRunInputs, type AnalystRunResult, type AnalystRunSummary, type AnalystRunnerComparison, type AnalystSeverity, type AnalystTransportBinding, type AnalystUsageReceipt, type AskTraceQuestionsOptions, type BehavioralAnalystOptions, type BudgetPolicy, CODE_TRACE_BENCH_ANALYST_PROMPT, CONTROL_INTEGRITY_ANALYST, type ChatCallOpts, type ChatClient, type ChatRequest, type ChatResponse, type ChatTraceEngineOptions, type ChatTransport, type ChunkedEvidenceBinding, type CodeTraceBenchCaseOptions, type CodeTraceBenchLabelOptions, type CodeTraceBenchLabelSet, type CodeTraceBenchRow, type CodeTraceBlockDiagnostics, type CodeTraceCalibrationRunnerSummary, type CodeTraceCalibrationSummary, type CodeTraceFailureBlock, type CodeTraceStageAnnotation, type CodeTracerLabelGroup, type CodeTracerPredictionAdapterOptions, type CodeTracerPredictions, type CodeTracerStepLabel, ControlIntegrityAnalyst, type CreateChatClientOpts, type CreateTraceAnalystOptions, type CustomTransportOpts, DEFAULT_MAX_VERIFICATION_ARTIFACT_BYTES, DEFAULT_TRACE_ANALYST_KINDS, DEFAULT_TRACE_ANALYST_OUTPUT_TOKENS, type DecodedReply, type DefaultAnalystRegistryOptions, type DefineCustomAnalystOptions, type DefineExactCustomAnalystOptions, type DiffPolicy, type DspyRlmTraceEngineOptions, type EvidenceProjection, type EvidenceRef, type ExactAnalystBudgetPolicy, type ExactAnalystBudgetSnapshot, type ExactAnalystExecutionPlanSnapshot, type ExactAnalystRunCompletion, type ExactAnalystRunEvent, ExactAnalystRunExecutionError, type ExactAnalystRunPolicySnapshot, type ExactAnalystRunResult, type ExactAnalystRunSummary, type ExactAnalystSnapshot, type ExactCapableAnalyst, type ExactExecutionComponentIdentity, type ExactExecutionComponentSnapshot, type ExactRegistryRunOpts, type ExecutionProbe, type ExecutionProbeOutcome, type ExecutionProbeRequest, type ExpandRowsArgs, FAILURE_MODE_KIND_SPEC, FINDING_SUBJECT_KINDS, FINDING_SUBJECT_SYNTAX, type FindingSubject, type FindingSubjectKind, type FindingsDiff, FindingsStore, IMPROVEMENT_KIND_SPEC, type InlineEvidenceBinding, KIND_EXPECTED_SUBJECTS, KNOWLEDGE_GAP_KIND_SPEC, KNOWLEDGE_POISONING_KIND_SPEC, type LoadedVerificationArtifacts, MAX_INCORRECT_BLOCKS, MAX_INCORRECT_BLOCK_STEPS, type MockTransportOpts, type OpenAiCompatibleTransportOpts, type PersistedFinding, type PreparedPublicAnalystBenchmark, type PrimeBenchmarkRunnerOptions, type PrimeBridgeTransport, type PrimeBridgeTransportRequest, type PrimeBridgeTransportResult, type PrimeCodeTraceDefinitionArgs, type PrimeExchangeOptions, type PrimeExchangeOutcome, type PrimeFailure, type PrimeProjectionDelivery, type PrimeProjectionOutcome, type PrimeProjectionSource, type PrimePromptSpec, type PrimeProtocolIdentity, type PrimeRawUsage, type PrimeRejectedRow, type PrimeRepairPromptSpec, type PrimeRepairState, type PrimeReplyContract, type PrimeRowDecoded, type PrimeTurnRecord, type ProposalFinding, type ProposalFindingOrigin, type PublicAnalystBenchmarkDataset, type PublicAnalystBenchmarkModelConfig, type PublicAnalystBenchmarkModelOwner, type PublicAnalystBenchmarkModelSettings, type PublicBenchmarkDistributions, type PublicBenchmarkModelPrediction, type PublicBenchmarkSelectionReport, type PublicBenchmarkValueDistribution, type PublicDirectDefinitionArgs, type PublicRlmDefinitionArgs, RAW_FINDING_SCHEMA_PROMPT, type RawAnalystEvidence, type RawAnalystFinding, RawAnalystFindingSchema, type RegistryRunOpts, type ReplVariableConsensusPort, type ReplVariableEvidenceBinding, type ReplyContract, type ReplyEnvelope, type ReplyRowDecoded, type ReplyRowRejection, type RunAnalystBenchmarkOptions, SKILL_USAGE_ANALYST, type SandboxSdkTransportOpts, type SemanticConceptJudgeAdapterOpts, type SkillUsageRecord, type SkillUsageReport, type SkillUsageScanConfig, type StepLabelAdapterOptions, type TraceAnalysisEngine, type TraceAnalysisEngineRequest, type TraceAnalysisEngineResult, type TraceAnalystDefinition, type TraceAnalystLimits, type TraceQuestionOutcome, type TraceQuestionSpec, type TraceToolGroupName, type UpstreamPredictionAdapterOptions, type VerificationArtifactFile, type VerificationArtifactManifest, type VerificationArtifactRole, type VerificationAvailabilitySummary, type VerificationOutcome, type VerificationOutcomeSource, type VerificationOutcomeStatus, type VerificationResultFile, type VerifiedTraceFinding, adaptPublicBenchmarkFindings, agentRxBenchmarkCase, agentRxPredictionsToFindings, analystBenchmarkDependencyLockDigest, analystBenchmarkImplementationDigest, analystDefinitionAsymmetries, analystDefinitionProtocolSha256, analystInstructionsOverrideFromText, analystUsageReceiptFromPrimeUsage, appendVerificationArtifactsToOtlp, askTraceQuestions, assertProposalFindings, behavioralAnalyst, bindAnalyst, buildDefaultAnalystRegistry, buildPrimePrompt, buildPrimeRepairPrompt, buildSkillUsageReport, buildTraceToolsForGroup, citedSpansOnly, codeTraceBenchCase, codeTracerPredictionsToFindings, coerceJson, compareAnalystRunners, computeFindingId, createChatClient, createChatTraceEngine, createDspyRlmTraceEngine, createPrimeBenchmarkRunner, createPublicBenchmarkDirectRunner, createPublicBenchmarkRlmRunner, createSemanticConceptJudgeAdapter, createTraceAnalyst, decodeReplyRows, defaultIsMaterial, defineCustomAnalyst, defineTraceAnalyst, deriveEfficiencyFindings, diffFindings, effectiveAnalystProtocolSha256, emitControlIntegrityFindings, emitSkillUsageFindings, emptyPrimeRawUsage, emptyPublicBenchmarkRunner, evidenceRefsFromRawFinding, expandCodeTraceFailureBlocks, extractPrimeJsonObject, findingSubjectGrammarPromptFor, isProposalFinding, loadCodeTraceVerificationArtifacts, loadPublicBenchmarkRows, makeFinding, makeProposalFinding, mergePrimeRawUsage, nodeHttpPrimeBridgeTransport, normalizeAgentRxCategory, normalizeBenchmarkLabel, normalizePrimeUsage, parseFindingSubject, parseRawFinding, parseVerificationOutcome, preparePublicAnalystBenchmark, primeAnalystProtocolSha256, primeCodeTraceAnalystDefinition, primeProtocolSha256, primeReplyDefect, projectPrimeTrajectory, publicBenchmarkDistributions, publicBenchmarkProtocolSha256, publicBenchmarkRlmInstructions, publicBenchmarkSelectionReport, publicBenchmarkSystemPrompt, publicDirectAnalystDefinition, publicRlmAnalystDefinition, readAnalystBenchmarkArtifact, readAnalystInstructionsOverride, registryBenchmarkRunner, renderAgentRxCalibrationMarkdown, renderAnalystBenchmarkMarkdown, renderCodeTraceCalibrationMarkdown, renderFindingSubject, renderPriorFindings, resolveTraceAnalystLimits, rlmEngineLimits, roundAgentRxStep, runAnalystBenchmark, runAnalystBenchmarkCommand, runPrimeExchange, runTraceAnalyst, scoreAnalystFindings, selectPublicBenchmarkRows, stripCodeFences, summarizeAgentRxCalibration, summarizeAnalystBenchmarkRunner, summarizeCodeTraceCalibration, traceStoreEvidenceResolver };
 //# sourceMappingURL=index.d.ts.map

package/dist/analyst/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/analyst/adapters.ts","../../src/analyst/benchmark-agentrx-calibration.ts","../../src/analyst/benchmark-dataset-types.ts","../../src/analyst/benchmark-dataset-agentrx.ts","../../src/analyst/benchmark-dataset-codetrace.ts","../../src/analyst/benchmark-dataset-utils.ts","../../src/analyst/benchmark-verification-outcome.ts","../../src/analyst/benchmark-verification-artifacts.ts","../../src/analyst/benchmark-public-types.ts","../../src/analyst/benchmark-public-adapters.ts","../../src/analyst/benchmark-public-data.ts","../../src/analyst/definition.ts","../../src/analyst/benchmark-public-prompt.ts","../../src/analyst/benchmark-public-model.ts","../../src/analyst/benchmark-public-rlm.ts","../../src/analyst/benchmark-runner-prime.ts","../../src/analyst/benchmark-comparison.ts","../../src/analyst/benchmark-public-calibration.ts","../../src/analyst/benchmark-command-artifact.ts","../../src/analyst/benchmark-command-result.ts","../../src/analyst/benchmark-command.ts","../../src/analyst/benchmark-implementation.ts","../../src/analyst/benchmark-instructions-override.ts","../../src/analyst/benchmark-report.ts","../../src/analyst/benchmark-summary.ts","../../src/analyst/bind.ts","../../src/analyst/define.ts","../../src/analyst/kinds/skill-usage.ts","../../src/analyst/parse-tolerant.ts","../../src/analyst/proposal-findings.ts","../../src/analyst/trace-questions.ts"],"mappings":";;;;;;;;;;;;;;UA8CiB;EACf;EACA;;EAEA,SAAS,KAAK;;EAEd;;iBAGc,kCACd,MAAM,kCACL,QAAQ;;;cCtDE;UAEI;EACf;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;UAGe;EACf;EACA;EACA;EACA,SAAS;;iBAGK,4BACd,QAAQ,wBACR,2BACC;iBAkBa,iCAAiC,SAAS;;;KCtD9C;UAEK;EACf,YAAY;EACZ;EACA;EACA;EACA;EACA;;UAGe;EACf,eAAe;EACf,mBAAmB;EACnB;IAAe,YAAY;IAAY;;EACvC,wBAAwB;EACxB;EACA;EACA;;UAGe;EACf,UAAU;EACV;EACA;EACA;EACA;;UAGe;EACf,UAAU;EACV,mBAAmB;EACnB;EACA;EACA;EACA;EACA;;UAGe;EACf;EACA;EACA;EACA;;UAGe;EACf;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;UAGe;EACf;EACA;EACA;EACA,iBAAiB;;KAGP,0CAEC,sCACA,iCACA;UAEI;EACf;EACA;EACA;EACA;;EAEA;EACA;EACA;EACA;EACA;EACA;EACA,oCAAoC;;UAGrB;EACf,eAAe;EACf,WAAW,sBAAsB;;KAGvB;UAEK;;;;;EAKf,WAAW;;UAGI,kCACP,yBACN;UAEa,oCAAoC;EACnD;;EAEA;;UAGe,yCAAyC;EACxD;EACA;EACA;EACA;;UAGe,2CACP,kCACN;;;iBCtGY,qBAAqB,QACnC,KAAK,YACL,OAAO,QACP,UAAS,8BACR,qBAAqB;;iBAsGR,6BACd,mBAAmB,YACnB,iBACA,UAAS,mCACR;iBA6Ea,yBAAyB;;iBAoNzB,iBAAiB;;;iBC/YjB,mBAAmB,QACjC,KAAK,mBACL,OAAO,QACP,UAAS,4BACR,qBAAqB;;iBAwFR,gCACd,2BACA,aAAa,uBACb,UAAS,qCACR;;;iBClHa,wBAAwB;;;KCA5B;UAEK;EACf;EACA;EACA,QAAQ;;UAGO;EACf,QAAQ;EACR;EAKA;IAAe;IAAe;;EAC9B,SAAS;EACT;EACA;EACA;E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;;;iBA8EE;UAIC;;EAEf;;EAEA;;;;;;iBAOc,gCACd,MAAM,+BACL,kBAAkB;;iBAyDL,2BACd,SAAS,8BACR,uBAAuB;;;;;;;;;;cC5OpB;WACQ;WACC;WACK;WACd;WACkB;WACJ;WACO;WACD;WACJ;WACK;WACd;WACJ;WACM;WACC;WACG;WACH;WACI;WACT;;KAGC,uCAAuC;UAgBlC;EACf,QAAQ;EACR;;EAEA;;EAEA;;EAEA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;UAGe;EACf;EACA;EACA,SAAS;;iBASK,sBACd,QAAQ,wBACR;EACE;EACA;EACA;EACA;EACA;IAED;;;UC3Fc;EACf;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;EAEA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;UAGe;EACf;EACA;EACA,SAAS;;iBAGK,8BACd,QAAQ,yBACP;iBAca,mCAAmC,SAAS;;;UCpC3C;EACf;EACA;EACA;IACE,SAAS;IACT;IACA;IACA;IACA;IACA,YAAY;MAAQ;MAAiB;MAAsB;;IAC3D,uBAAuB;IACvB,0BAA0B;IAC1B;MACE;MACA;MACA;MACA,QAAQ;;IAEV;MACE;MACA;;MAEA;MACA;;MAEA;MACA;MACA;MACA;MACA;MACA;MACA;MACA,UAAU;MACV;QACE;QACA;QACA;QACA;QACA;QACA;QACA;QACA;;MAEF;QACE;QACA;QACA;;MAEF;MACA;MACA;;MAEA;MACA;MACA;;;EAGJ,QAAQ;EACR,aAAa;EACb,uBAAuB;EACvB,qBAAqB;;UAGN;EACf;EACA;EACA;EACA;IACE;IACA;IACA;;;UAIa;EACf;IACE,SAAS;IACT;IACA;IACA;MACE;MACA;MACA;MACA;MACA;MACA;MACA;MACA;MACA,SAAS;MACT;QACE;QACA;QACA;QACA;QACA;QACA;QACA;QACA;;MAEF;QACE;QACA;QACA;;;IAGJ;IACA;IACA;IACA;;IAEA;IACA;IACA;IACA;;IAEA;IACA;IACA;IACA;;EAEF;IACE;IACA;IACA;IACA,YAAY;MAAQ;MAAiB;MAAsB;;IAC3D;IACA;;;UAIa;EACf;EACA;EACA;EACA;EACA,UAAU;;UAGK;EACf;EACA;EACA;EACA;IACE;IACA;IACA;IACA;;IAEA;;EAEF;EACA;IACE;IACA;IACA;;EAEF;IACE;IACA;IACA;IACA;IACA;IACA;;;UAIa;EACf;EACA;EACA;EACA,aAAa;EACb;;cAGW;cACA;cACA;cACA;;;iBC5KS,6BACpB,eACC,QAAQ;;;UCuEM;EACf,uBACE,SAAS,+BACT,QAAQ,wCACL,uBAAuB;EAC5B,2BACE,mBACA;IACE;IACA,aAAa,SAAS,OAAO;QAE5B,QAAQ;;;;;;;;;KAUH;;UAGK;EACf;EACA;;UAGe;EACf,SAAS;EACT,SAAS;EACT;EACA;EACA;EACA;EACA;EACA;EACA,OAAO;EACP;EACA;EACA;EACA;;EAEA;EACA;EACA;;EAEA;;EAEA,QAAQ;EACR;EACA;;iBAKoB,2BACpB,yBACA,MAAK,OAAO,YACZ,eAAc,sCACb;;;cCzJU;;;cAIA;cAGA;cAOA;cAYA;cAGA;cAGA;cAiHA;iBAGG;iBAIA;;;;iBC/IA,oCAAoC,eAAe;;iBAQnD,gCAAgC,eAAe;;;;;;;;;;;iBAyB/C,+BACd,SAAS,+BACT,WAAW,KAAK;;;iBCzCF,+BACd,QAAQ,wBACR,uBAAsB;;;iBCIR,gCACd,kBACA,uBAAuB,gCACtB;;;;KCcS;;WAGG;WACA;WACA;WACA,YAAY;WACZ,UAAU;;;WAIV;WACA,QAAQ;;;;;;iBAOP,YAAY,MAAM,aAAa,QAC7C,YAAY,kBAAkB,MAAM,aAAa,SACjD,YAAY,0BACX,uBAAuB;;;;;;;;;;iBCpCV,mBAAmB,YAAY,yBAAyB;UAkBvD;EACf;EACA;EACA;EACA,MAAM;EACN,SAAS,QAAQ;;UAGF,wCAAwC;;EAEvD,iBAAiB,SAAS;;;iBAIZ,oBACd,SAAS,kCACR,oBAAoB;iBACP,oBACd,SAAS,6BACR,QAAQ;;;KCpBC;;UAGK;EACf;EACA,MAAM;;EAEN;EACA;;EAEA;;EAEA;;;EAGA;;EAEA;;EAEA;EACA;EACA;;EAEA;;EAEA;;UAGe;EACf;EACA,SAAS;;UAGM;;EAEf;;EAEA;IAAc;IAAc,MAAM;;;EAElC;;;EAGA,kBAAkB;;EAElB;;;iBA2Ec,sBAAsB,QAAQ,uBAAuB;;iBAiHrD,uBACd,QAAQ,kBACR,qBACC;cA2HG,6BAA6B,oBAAoB;WAC5C;WACA;WAEA;WACA;IAAS;IAAgC;;WACzC;WACA;aACP;aACA;aACA;;EAGI,QAAQ,OAAO,kBAAkB,KAAK,iBAAiB,QAAQ;;cAS1D,qBAAmB;;;;;;;;;;;;;;;iBC5YhB,gBAAgB;;;;;iBAgBhB,WAAW;;;;iBCIX,kBAAkB,mBAAmB,WAAW;;;;;;iBAShD,uBACd,mBACA,mBACC,cAAc;;;;UChBA;;WAEN;WACA;;WAEA;;UAGM;WACN,oBAAoB;WACpB,OAAO;WACP,QAAQ;;WAER,YAAY;;WAEZ;;WAEA;;WAEA;;WAEA;;WAEA;WACA,SAAS,QAAQ;WACjB,SAAS;WACT,OAAO,iBAAiB,SAAS;;;UAI3B;WACN,SAAS;;WAET;;WAEA;;WAEA;;UAGM;WACN;WACA;WACA;WACA;;WAEA;WACA,mBAAmB;;WAEnB;WACA;;;;;;;iBAyBW,kBACpB,MAAM,2BACL,QAAQ;;;;;iBA2JK,eACd,OAAO,oBACP,SAAS,oBAAoB,uBAC5B"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/analyst/adapters.ts","../../src/analyst/benchmark-agentrx-calibration.ts","../../src/analyst/benchmark-dataset-types.ts","../../src/analyst/benchmark-dataset-agentrx.ts","../../src/analyst/benchmark-dataset-codetrace.ts","../../src/analyst/benchmark-dataset-utils.ts","../../src/analyst/benchmark-verification-outcome.ts","../../src/analyst/benchmark-verification-artifacts.ts","../../src/analyst/benchmark-public-types.ts","../../src/analyst/benchmark-public-adapters.ts","../../src/analyst/benchmark-public-data.ts","../../src/analyst/definition.ts","../../src/analyst/benchmark-public-prompt.ts","../../src/analyst/benchmark-public-model.ts","../../src/analyst/benchmark-public-rlm.ts","../../src/analyst/benchmark-runner-prime.ts","../../src/analyst/benchmark-comparison.ts","../../src/analyst/benchmark-public-calibration.ts","../../src/analyst/benchmark-command-artifact.ts","../../src/analyst/benchmark-command-result.ts","../../src/analyst/benchmark-command.ts","../../src/analyst/benchmark-implementation.ts","../../src/analyst/benchmark-instructions-override.ts","../../src/analyst/benchmark-report.ts","../../src/analyst/benchmark-summary.ts","../../src/analyst/bind.ts","../../src/analyst/define.ts","../../src/analyst/kinds/skill-usage.ts","../../src/analyst/parse-tolerant.ts","../../src/analyst/proposal-findings.ts"],"mappings":";;;;;;;;;;;;;;;UA8CiB;EACf;EACA;;EAEA,SAAS,KAAK;;EAEd;;iBAGc,kCACd,MAAM,kCACL,QAAQ;;;cCtDE;UAEI;EACf;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;UAGe;EACf;EACA;EACA;EACA,SAAS;;iBAGK,4BACd,QAAQ,wBACR,2BACC;iBAkBa,iCAAiC,SAAS;;;KCtD9C;UAEK;EACf,YAAY;EACZ;EACA;EACA;EACA;EACA;;UAGe;EACf,eAAe;EACf,mBAAmB;EACnB;IAAe,YAAY;IAAY;;EACvC,wBAAwB;EACxB;EACA;EACA;;UAGe;EACf,UAAU;EACV;EACA;EACA;EACA;;UAGe;EACf,UAAU;EACV,mBAAmB;EACnB;EACA;EACA;EACA;EACA;;UAGe;EACf;EACA;EACA;EACA;;UAGe;EACf;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;UAGe;EACf;EACA;EACA;EACA,iBAAiB;;KAGP,0CAEC,sCACA,iCACA;UAEI;EACf;EACA;EACA;EACA;;EAEA;EACA;EACA;EACA;EACA;EACA;EACA,oCAAoC;;UAGrB;EACf,eAAe;EACf,WAAW,sBAAsB;;KAGvB;UAEK;;;;;EAKf,WAAW;;UAGI,kCACP,yBACN;UAEa,oCAAoC;EACnD;;EAEA;;UAGe,yCAAyC;EACxD;EACA;EACA;EACA;;UAGe,2CACP,kCACN;;;iBCtGY,qBAAqB,QACnC,KAAK,YACL,OAAO,QACP,UAAS,8BACR,qBAAqB;;iBAsGR,6BACd,mBAAmB,YACnB,iBACA,UAAS,mCACR;iBA6Ea,yBAAyB;;iBAoNzB,iBAAiB;;;iBC/YjB,mBAAmB,QACjC,KAAK,mBACL,OAAO,QACP,UAAS,4BACR,qBAAqB;;iBAwFR,gCACd,2BACA,aAAa,uBACb,UAAS,qCACR;;;iBClHa,wBAAwB;;;KCA5B;UAEK;EACf;EACA;EACA,QAAQ;;UAGO;EACf,QAAQ;EACR;EAKA;IAAe;IAAe;;EAC9B,SAAS;EACT;EACA;EACA;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;;;;iBA8EE;UAIC;;EAEf;;EAEA;;;;;;iBAOc,gCACd,MAAM,+BACL,kBAAkB;;iBAyDL,2BACd,SAAS,8BACR,uBAAuB;;;;;;;;;;cC5OpB;WACQ;WACC;WACK;WACd;WACkB;WACJ;WACO;WACD;WACJ;WACK;WACd;WACJ;WACM;WACC;WACG;WACH;WACI;WACT;;KAGC,uCAAuC;UAgBlC;EACf,QAAQ;EACR;;EAEA;;EAEA;;EAEA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;UAGe;EACf;EACA;EACA,SAAS;;iBASK,sBACd,QAAQ,wBACR;EACE;EACA;EACA;EACA;EACA;IAED;;;UC3Fc;EACf;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;EAEA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;UAGe;EACf;EACA;EACA,SAAS;;iBAGK,8BACd,QAAQ,yBACP;iBAca,mCAAmC,SAAS;;;UCpC3C;EACf;EACA;EACA;IACE,SAAS;IACT;IACA;IACA;IACA;IACA,YAAY;MAAQ;MAAiB;MAAsB;;IAC3D,uBAAuB;IACvB,0BAA0B;IAC1B;MACE;MACA;MACA;MACA,QAAQ;;IAEV;MACE;MACA;;MAEA;MACA;;MAEA;MACA;MACA;MACA;MACA;MACA;MACA;MACA,UAAU;MACV;QACE;QACA;QACA;QACA;QACA;QACA;QACA;QACA;;MAEF;QACE;QACA;QACA;;MAEF;MACA;MACA;;MAEA;MACA;MACA;;;EAGJ,QAAQ;EACR,aAAa;EACb,uBAAuB;EACvB,qBAAqB;;UAGN;EACf;EACA;EACA;EACA;IACE;IACA;IACA;;;UAIa;EACf;IACE,SAAS;IACT;IACA;IACA;MACE;MACA;MACA;MACA;MACA;MACA;MACA;MACA;MACA,SAAS;MACT;QACE;QACA;QACA;QACA;QACA;QACA;QACA;QACA;;MAEF;QACE;QACA;QACA;;;IAGJ;IACA;IACA;IACA;;IAEA;IACA;IACA;IACA;;IAEA;IACA;IACA;IACA;;EAEF;IACE;IACA;IACA;IACA,YAAY;MAAQ;MAAiB;MAAsB;;IAC3D;IACA;;;UAIa;EACf;EACA;EACA;EACA;EACA,UAAU;;UAGK;EACf;EACA;EACA;EACA;IACE;IACA;IACA;IACA;;IAEA;;EAEF;EACA;IACE;IACA;IACA;;EAEF;IACE;IACA;IACA;IACA;IACA;IACA;;;UAIa;EACf;EACA;EACA;EACA,aAAa;EACb;;cAGW;cACA;cACA;cACA;;;iBC5KS,6BACpB,eACC,QAAQ;;;UCuEM;EACf,uBACE,SAAS,+BACT,QAAQ,wCACL,uBAAuB;EAC5B,2BACE,mBACA;IACE;IACA,aAAa,SAAS,OAAO;QAE5B,QAAQ;;;;;;;;;KAUH;;UAGK;EACf;EACA;;UAGe;EACf,SAAS;EACT,SAAS;EACT;EACA;EACA;EACA;EACA;EACA;EACA,OAAO;EACP;EACA;EACA;EACA;;EAEA;EACA;EACA;;EAEA;;EAEA,QAAQ;EACR;EACA;;iBAKoB,2BACpB,yBACA,MAAK,OAAO,YACZ,eAAc,sCACb;;;cCzJU;;;cAIA;cAGA;cAOA;cAYA;cAGA;cAGA;cAiHA;iBAGG;iBAIA;;;;iBC/IA,oCAAoC,eAAe;;iBAQnD,gCAAgC,eAAe;;;;;;;;;;;iBAyB/C,+BACd,SAAS,+BACT,WAAW,KAAK;;;iBCzCF,+BACd,QAAQ,wBACR,uBAAsB;;;iBCIR,gCACd,kBACA,uBAAuB,gCACtB;;;;KCcS;;WAGG;WACA;WACA;WACA,YAAY;WACZ,UAAU;;;WAIV;WACA,QAAQ;;;;;;iBAOP,YAAY,MAAM,aAAa,QAC7C,YAAY,kBAAkB,MAAM,aAAa,SACjD,YAAY,0BACX,uBAAuB;;;;;;;;;;iBCpCV,mBAAmB,YAAY,yBAAyB;UAkBvD;EACf;EACA;EACA;EACA,MAAM;EACN,SAAS,QAAQ;;UAGF,wCAAwC;;EAEvD,iBAAiB,SAAS;;;iBAIZ,oBACd,SAAS,kCACR,oBAAoB;iBACP,oBACd,SAAS,6BACR,QAAQ;;;KCpBC;;UAGK;EACf;EACA,MAAM;;EAEN;EACA;;EAEA;;EAEA;;;EAGA;;EAEA;;EAEA;EACA;EACA;;EAEA;;EAEA;;UAGe;EACf;EACA,SAAS;;UAGM;;EAEf;;EAEA;IAAc;IAAc,MAAM;;;EAElC;;;EAGA,kBAAkB;;EAElB;;;iBA2Ec,sBAAsB,QAAQ,uBAAuB;;iBAiHrD,uBACd,QAAQ,kBACR,qBACC;cA2HG,6BAA6B,oBAAoB;WAC5C;WACA;WAEA;WACA;IAAS;IAAgC;;WACzC;WACA;aACP;aACA;aACA;;EAGI,QAAQ,OAAO,kBAAkB,KAAK,iBAAiB,QAAQ;;cAS1D,qBAAmB;;;;;;;;;;;;;;;iBC5YhB,gBAAgB;;;;;iBAgBhB,WAAW;;;;iBCIX,kBAAkB,mBAAmB,WAAW;;;;;;iBAShD,uBACd,mBACA,mBACC,cAAc"}

package/dist/{index-D4pC7Tvd.d.ts → index-D4pC7Tvd2.d.ts}

@@ -665,4 +665,4 @@ declare function parseRolloutReleaseArgs(argv: string[]): RolloutReleaseCliArgs;
 declare function runRolloutReleaseCli(argv: string[]): Promise<number>;
 //#endregion
 export { HarborFinalMetrics as $, measureFormatGate as A, DEFAULT_CLAUDE_PROJECTS_DIR as B, FORMAT_GATE_DISPOSITION as C, gatedEvidenceOf as Ct, ReleaseRowRef as D, GateReport as E, openOpencodeDb as F, readRolloutJournal as G, findClaudeTranscripts as H, readOpencodeSessionMessages as I, ATIF_SCHEMA_VERSION as J, readRolloutLedger as K, ClaudeTranscript as L, DEFAULT_OPENCODE_DB as M, OpencodeSessionRow as N, assertGateReport as O, findOpencodeSessionsByDirectory as P, HarborContentPart as Q, ClaudeTranscriptRef as R, EmittedEvidence as S, gateErrors as St, GateDisposition as T, readClaudeTranscript as U, claudeProjectSlug as V, appendRolloutLines as W, HARBOR_IMPORT_GAP as X, FromHarborOptions as Y, HarborAgent as Z, defaultRolloutScrubber as _, GateCheckDisposition as _t, buildHfDataset as a, HarborStepSource as at, scrubRolloutLine as b, GateEntryPoint as bt, runRolloutReleaseCli as c, HarborTrajectory as ct, RELEASE_FORMATS as d, toHarborTrajectories as dt, HarborImageSource as et, ReleaseFormat as f, toHarborTrajectory as ft, addScrubCounts as g, GateCheck as gt, ScrubRule as h, GATE_POLICIES as ht, ScrubReport as i, HarborStep as it, releaseRowRefs as j, gatedRolloutIds as k, DatasetCardInputs as l, fromHarborTrajectory as lt, ScrubCounts as m, GATE_CHECK_IDS as mt, BuildSummary as n, HarborObservation as nt, parseRolloutReleaseArgs as o, HarborSubagentTrajectoryRef as ot, buildDatasetCard as p, GATE_CHECKS as pt, writeRolloutLedger as q, RolloutReleaseCliArgs as r, HarborObservationResult as rt, planPushCommand as s, HarborToolCall as st, BuildOptions as t, HarborMetrics as tt, FORMAT_FILES as u, relabelImportedSplit as ut, emptyScrubCounts as v, GateCheckId as vt, FormatGateCounts as w, scrubText as x, GatePolicy as xt, scrubLines as y, GateCheckedOutcome as yt, ClaudeUsageTotals as z };
-//# sourceMappingURL=index-D4pC7Tvd.d.ts.map
+//# sourceMappingURL=index-D4pC7Tvd2.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index-D4pC7Tvd2.d.ts","names":[],"sources":["../src/rollout/gate-checks.ts","../src/rollout/interchange/harbor.ts","../src/rollout/ledger.ts","../src/rollout/readers/claude-jsonl.ts","../src/rollout/readers/opencode-sqlite.ts","../src/rollout/release/gate-report.ts","../src/rollout/release/scrub.ts","../src/rollout/release/card.ts","../src/rollout/release/hf-dataset.ts"],"mappings":"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"}

package/dist/{index-DNgf5gyG.d.ts → index-DNgf5gyG2.d.ts}

@@ -195,4 +195,4 @@ interface RunAgentMatrixOptions<Output> {
 declare function runAgentMatrix<Output>(opts: RunAgentMatrixOptions<Output>): Promise<MatrixResult<Output>>;
 //#endregion
 export { MatrixCell as a, CellSpend as c, MatrixAxis as i, readCellSpend as l, AxisSummary as n, MatrixResult as o, CellResult as r, RunAgentMatrixOptions as s, runAgentMatrix as t, withCellSpend as u };
-//# sourceMappingURL=index-DNgf5gyG.d.ts.map
+//# sourceMappingURL=index-DNgf5gyG2.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index-DNgf5gyG2.d.ts","names":[],"sources":["../src/matrix/cell-spend.ts","../src/matrix/types.ts","../src/matrix/runner.ts"],"mappings":";;;;;;;;;;;;;;;;;;UAoBiB;;;;EAIf;;EAEA;;;;EAIA;;;;;;;;;;;;;;;;iBAiBc,cAAc,gBAAgB,OAAO;;;;iBA+CrC,cAAc,iBAAiB;;;;;UC5E9B,WAAW;;EAE1B;;EAEA,QAAQ;IAAQ;IAAY,OAAO;;;;EAGnC,SAAS,OAAO,GAAG;;;UAIJ;EACf,MAAM;IAAiB;IAAY;;;EAEnC;;EAEA;;UAGe,WAAW;EAC1B,QAAQ;EACR,SAAS;;;;EAIT;EACA;EACA;;;;;;;;;;;EAWA,iBAAiB;;;;EAIjB;IAAU;IAAiB;;;UAGZ;EACf;EACA;EACA;EACA;EACA;EACA;EACA;;;EAGA;;EAEA;EACA;;UAGe,aAAa;EAC5B,OAAO;IAAQ,MAAM;IAAY,MAAM,WAAW;;;;EAGlD,QAAQ,eAAe,eAAe;EACtC;IACE;IACA;;;IAGA;IACA;IACA;;;;IAIA;;;;IAIA;;;;IAIA;IACA;;;EAGF;;UAGe,sBAAsB;EACrC,MAAM;;;;;;EAMN,UAAU,MAAM,eAAe,QAAQ,WAAW;;EAElD;;EAEA,UAAU,MAAM,KAAK;;EAErB;;EAEA;;;;;EAKA;;;;;;;;;;;;;EAaA;;EAEA,kBAAkB,MAAM,YAAY,QAAQ,WAAW;;;EAGvD,SAAS;;;;iBC1BW,eAAe,QACnC,MAAM,sBAAsB,UAC3B,QAAQ,aAAa"}

package/dist/index.d.ts

@@ -44,7 +44,7 @@ import { C as inferDomainKeywords, H as captureFetchToRawSink, I as OtlpExport,
 import { a as RunIntegrityReport, o as assertRunCaptured, t as RunIntegrityError } from "./integrity-CaeNeusS.js";
 import { c as judgeSpans, f as runsForScenario, i as argHash } from "./query-DBUQhehH.js";
 import { a as SteeringChange, c as CampaignRunContext, d as CampaignVariant, f as EvalCampaignOptions, h as runEvalCampaign, i as Researcher, l as CampaignRunOutcome, m as FailedRun, n as ExperimentResult, o as CampaignFactoryParams, p as EvalCampaignResult, r as FailureMode, s as CampaignIntegrityPolicy, t as ExperimentPlan, u as CampaignScenario } from "./researcher-DojEMb7E.js";
-import "./index-D4pC7Tvd.js";
+import "./index-D4pC7Tvd2.js";
 import { _ as iqr, a as ToolStats, c as computeToolUseMetrics, d as judgeAgreementView, i as toolWasteView, m as budgetBreachView, o as ToolUseMetrics, s as ToolUseOptions } from "./tool-waste-CP5DO383.js";
 import { SpanKind } from "@tangle-network/agent-trace-contract";
 //#region src/statistics/effect-sizes.d.ts

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

@@ -0,0 +1,82 @@
+//#region src/jev-protocol.d.ts
+/**
+ * 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[];
+/** 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?: JevDescription;
+  criteria?: {
+    true?: JevDescription;
+    false?: JevDescription;
+  } | null;
+} | {
+  type: 'score';
+  instructions?: JevDescription;
+  criteria: JevScoreCriteria;
+} | {
+  type: 'choice';
+  instructions?: JevDescription;
+  criteria: Record<string, JevDescription>;
+};
+type JevQuestions = Record<string, JevQuestion>;
+interface JevRequest<Q extends JevQuestions = JevQuestions> {
+  model: string;
+  state: JevState;
+  questions: Q;
+}
+type ScoreKeys<T extends JevScoreCriteria> = number extends T['length'] ? number : Extract<keyof T, `${number}`>;
+type JevAnswerFor<Q extends JevQuestion> = Q extends {
+  type: 'noul';
+} ? {
+  readonly type: 'noul';
+  readonly noul: number;
+} : Q extends {
+  type: 'score';
+  criteria: infer C extends JevScoreCriteria;
+} ? {
+  readonly type: 'score';
+  readonly score: number;
+  readonly confidence: number;
+  readonly legend: { readonly [K in ScoreKeys<C>]: C[K]; };
+  readonly probabilities: { readonly [K in ScoreKeys<C>]: number; };
+} : Q extends {
+  type: 'choice';
+  criteria: infer C;
+} ? {
+  readonly type: 'choice';
+  readonly choice: keyof C & string;
+  readonly confidence: number;
+  readonly probabilities: { readonly [K in keyof C]: number; };
+} : never;
+type JevAnswer = JevAnswerFor<JevQuestion>;
+interface JevResult<Q extends JevQuestions = JevQuestions> {
+  readonly model: string;
+  readonly answers: { readonly [K in keyof Q]: JevAnswerFor<Q[K]>; };
+  readonly usage: {
+    readonly input_tokens: number;
+    readonly output_tokens: number;
+  };
+}
+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 { JevQuestion as a, JevResponseError as c, JevState as d, jevUsage as f, parseJevResult as h, JevJson as i, JevResult as l, parseJevRequest as m, JevAnswerFor as n, JevQuestions as o, parseJevQuestions as p, JevDescription as r, JevRequest as s, JevAnswer as t, JevScoreCriteria as u };
+//# sourceMappingURL=jev-protocol-CpKI7XSu.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"jev-protocol-CpKI7XSu.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.d.ts

@@ -1,82 +1,2 @@
-//#region src/jev-protocol.d.ts
-/**
- * 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[];
-/** 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?: JevDescription;
-  criteria?: {
-    true?: JevDescription;
-    false?: JevDescription;
-  } | null;
-} | {
-  type: 'score';
-  instructions?: JevDescription;
-  criteria: JevScoreCriteria;
-} | {
-  type: 'choice';
-  instructions?: JevDescription;
-  criteria: Record<string, JevDescription>;
-};
-type JevQuestions = Record<string, JevQuestion>;
-interface JevRequest<Q extends JevQuestions = JevQuestions> {
-  model: string;
-  state: JevState;
-  questions: Q;
-}
-type ScoreKeys<T extends JevScoreCriteria> = number extends T['length'] ? number : Extract<keyof T, `${number}`>;
-type JevAnswerFor<Q extends JevQuestion> = Q extends {
-  type: 'noul';
-} ? {
-  readonly type: 'noul';
-  readonly noul: number;
-} : Q extends {
-  type: 'score';
-  criteria: infer C extends JevScoreCriteria;
-} ? {
-  readonly type: 'score';
-  readonly score: number;
-  readonly confidence: number;
-  readonly legend: { readonly [K in ScoreKeys<C>]: C[K]; };
-  readonly probabilities: { readonly [K in ScoreKeys<C>]: number; };
-} : Q extends {
-  type: 'choice';
-  criteria: infer C;
-} ? {
-  readonly type: 'choice';
-  readonly choice: keyof C & string;
-  readonly confidence: number;
-  readonly probabilities: { readonly [K in keyof C]: number; };
-} : never;
-type JevAnswer = JevAnswerFor<JevQuestion>;
-interface JevResult<Q extends JevQuestions = JevQuestions> {
-  readonly model: string;
-  readonly answers: { readonly [K in keyof Q]: JevAnswerFor<Q[K]>; };
-  readonly usage: {
-    readonly input_tokens: number;
-    readonly output_tokens: number;
-  };
-}
-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, JevDescription, JevJson, JevQuestion, JevQuestions, JevRequest, JevResponseError, JevResult, JevScoreCriteria, JevState, jevUsage, parseJevQuestions, parseJevRequest, parseJevResult };
-//# sourceMappingURL=jev-protocol.d.ts.map
+import { a as JevQuestion, c as JevResponseError, d as JevState, f as jevUsage, h as parseJevResult, i as JevJson, l as JevResult, m as parseJevRequest, n as JevAnswerFor, o as JevQuestions, p as parseJevQuestions, r as JevDescription, s as JevRequest, t as JevAnswer, u as JevScoreCriteria } from "./jev-protocol-CpKI7XSu.js";
+export { JevAnswer, JevAnswerFor, JevDescription, JevJson, JevQuestion, JevQuestions, JevRequest, JevResponseError, JevResult, JevScoreCriteria, JevState, jevUsage, parseJevQuestions, parseJevRequest, parseJevResult };

package/dist/jev-review-Cu9xtIu4.js

@@ -0,0 +1,155 @@
+import { a as hashCanonical, o as jsonDocument, r as canonicalString } from "./canonical-BsZVgBhW.js";
+import { t as deepFreezeCanonicalJson } from "./deep-freeze-CurcOQg3.js";
+import { r as makeFinding, t as ANALYST_SEVERITIES } from "./types-CW5b90JH.js";
+import { parseJevRequest, parseJevResult } from "./jev-protocol.js";
+import { z } from "zod";
+//#region src/jev-review.ts
+const name = z.string().trim().min(1);
+const probability = z.number().finite().gt(0).max(1);
+const checkSchema = z.object({
+	claim: name,
+	area: name,
+	subject: name,
+	severity: z.enum(ANALYST_SEVERITIES),
+	/** Choice labels or score-level keys, never scores invented from category order. */
+	supports: z.array(z.string()).min(1),
+	refutes: z.array(z.string()).min(1),
+	supportAtLeast: probability,
+	refuteAtLeast: probability,
+	/** Host-supplied coverage of the question's required evidence, not model self-assessment. */
+	coverage: z.enum([
+		"complete",
+		"partial",
+		"missing"
+	]),
+	evidence: z.array(z.object({
+		kind: z.enum([
+			"span",
+			"event",
+			"artifact",
+			"finding",
+			"metric"
+		]),
+		uri: name,
+		excerpt: z.string().optional()
+	}).strict())
+}).strict().refine((value) => value.supportAtLeast + value.refuteAtLeast > 1, { message: "Support and refutation thresholds must not overlap" });
+function alternatives(question) {
+	if (question.type === "noul") return ["true", "false"];
+	return question.type === "choice" ? Object.keys(question.criteria) : question.criteria.map((_, index) => String(index));
+}
+/** Validate before paid admission; make a detached, frozen snapshot without rewriting native JSON. */
+function prepareJevReview(input) {
+	if (!input.version?.trim()) throw new TypeError("Review version is required");
+	parseJevRequest(input.request);
+	const document = jsonDocument(input);
+	canonicalString(document);
+	const snapshot = structuredClone(document);
+	const keys = Object.keys(snapshot.request.questions);
+	if (!snapshot.checks || Object.keys(snapshot.checks).length !== keys.length || keys.some((key) => !Object.hasOwn(snapshot.checks, key))) throw new TypeError("Review checks must match the exact question names");
+	for (const key of keys) {
+		const check = checkSchema.parse(snapshot.checks[key]);
+		const labels = [...check.supports, ...check.refutes];
+		const allowed = alternatives(snapshot.request.questions[key]);
+		if (new Set(labels).size !== labels.length || labels.some((label) => !allowed.includes(label))) throw new TypeError("Review alternatives must exist and be disjoint");
+		if (check.coverage !== "missing" && check.evidence.length === 0) throw new TypeError("Review evidence references are required for non-missing coverage");
+		if (canonicalString(jsonDocument(check)) !== canonicalString(snapshot.checks[key])) throw new TypeError("Review metadata must not require normalization");
+	}
+	const order = keys.map((key) => [key, alternatives(snapshot.request.questions[key])]);
+	return deepFreezeCanonicalJson({
+		...snapshot,
+		digest: hashCanonical({
+			snapshot,
+			order
+		})
+	});
+}
+/** Re-score the same retained distribution without new inference or any authorization effect. */
+function assessJevReview(review, raw) {
+	const { digest, ...input } = review;
+	const prepared = prepareJevReview(input);
+	if (prepared.digest !== digest) throw new TypeError("Review definition changed after preparation");
+	const result = parseJevResult(raw, prepared.request);
+	const assessments = Object.entries(prepared.checks).map(([question, check]) => {
+		const answer = result.answers[question];
+		const probabilities = answer.type === "noul" ? {
+			true: answer.noul,
+			false: 1 - answer.noul
+		} : answer.probabilities;
+		const sum = (labels) => labels.reduce((total, label) => total + probabilities[label], 0);
+		const supportProbability = sum(check.supports);
+		const refutationProbability = sum(check.refutes);
+		const used = /* @__PURE__ */ new Set([...check.supports, ...check.refutes]);
+		const unresolvedProbability = sum(Object.keys(probabilities).filter((label) => !used.has(label)));
+		let status = "unresolved";
+		let reason = "below-threshold";
+		if (supportProbability > 1 || refutationProbability > 1 || unresolvedProbability > 1) throw new TypeError("Review probability mass exceeds one; do not silently normalize it");
+		if (check.coverage === "missing") reason = "missing-evidence";
+		else if (supportProbability >= check.supportAtLeast && refutationProbability >= check.refuteAtLeast) reason = "ambiguous-thresholds";
+		else if (supportProbability >= check.supportAtLeast) {
+			status = "supported";
+			reason = "support-threshold";
+		} else if (refutationProbability >= check.refuteAtLeast) if (check.coverage === "complete") {
+			status = "refuted";
+			reason = "refutation-threshold";
+		} else reason = "partial-negative-evidence";
+		return {
+			question,
+			status,
+			reason,
+			supportProbability,
+			refutationProbability,
+			unresolvedProbability,
+			modelConfidence: answer.type === "noul" ? null : answer.confidence,
+			check: structuredClone(check)
+		};
+	});
+	return {
+		reviewDigest: digest,
+		requestedModel: review.request.model,
+		servedModel: result.model,
+		assessments
+	};
+}
+/** Ordinary analyst findings; a negative review is not a global safety certificate. */
+function jevReviewFindings(review, result, options) {
+	if (!options.analystId.trim()) throw new TypeError("Analyst id is required");
+	const report = assessJevReview(review, result);
+	return report.assessments.filter((item) => item.status !== "refuted").map((item) => makeFinding({
+		analyst_id: options.analystId,
+		...options.producedAt === void 0 ? {} : { produced_at: options.producedAt },
+		subject: item.check.subject,
+		area: item.status === "unresolved" ? "assessment-coverage" : item.check.area,
+		severity: item.status === "unresolved" ? "info" : item.check.severity,
+		claim: item.status === "supported" ? `Model-supported hypothesis: ${item.check.claim}` : `Unresolved review: ${item.check.claim}`,
+		evidence_refs: structuredClone(item.check.evidence),
+		confidence: item.status === "supported" ? item.supportProbability : 1,
+		derived_from_judge: true,
+		id_basis: hashCanonical([
+			item.question,
+			item.status,
+			review.version,
+			item.check.claim
+		]),
+		metadata: {
+			review_digest: report.reviewDigest,
+			question: item.question,
+			requested_model: report.requestedModel,
+			served_model: report.servedModel,
+			assessment: item.status,
+			assessment_reason: item.reason,
+			evidence_coverage: item.check.coverage,
+			support_probability: item.supportProbability,
+			refutation_probability: item.refutationProbability,
+			unresolved_probability: item.unresolvedProbability,
+			model_confidence: item.modelConfidence,
+			calibration: "not-established",
+			confidence_basis: item.status === "supported" ? "model-support-mass" : "deterministic-status",
+			native_answer: structuredClone(result.answers[item.question])
+		}
+	}));
+}
+//#endregion
+export { jevReviewFindings as n, prepareJevReview as r, assessJevReview as t };
+
+//# sourceMappingURL=jev-review-Cu9xtIu4.js.map

package/dist/jev-review-Cu9xtIu4.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"jev-review-Cu9xtIu4.js","names":[],"sources":["../src/jev-review.ts"],"sourcesContent":["import { z } from 'zod'\nimport {\n  ANALYST_SEVERITIES,\n  type AnalystFinding,\n  type EvidenceRef,\n  makeFinding,\n} from './analyst/types'\nimport type { JevQuestions, JevRequest, JevResult } from './jev-protocol'\nimport { parseJevRequest, parseJevResult } from './jev-protocol'\nimport { canonicalString, hashCanonical, jsonDocument } from './ledger-core/canonical'\nimport { deepFreezeCanonicalJson } from './ledger-core/deep-freeze'\n\nconst name = z.string().trim().min(1)\nconst probability = z.number().finite().gt(0).max(1)\nconst checkSchema = z\n  .object({\n    claim: name,\n    area: name,\n    subject: name,\n    severity: z.enum(ANALYST_SEVERITIES),\n    /** Choice labels or score-level keys, never scores invented from category order. */\n    supports: z.array(z.string()).min(1),\n    refutes: z.array(z.string()).min(1),\n    supportAtLeast: probability,\n    refuteAtLeast: probability,\n    /** Host-supplied coverage of the question's required evidence, not model self-assessment. */\n    coverage: z.enum(['complete', 'partial', 'missing']),\n    evidence: z.array(\n      z\n        .object({\n          kind: z.enum(['span', 'event', 'artifact', 'finding', 'metric']),\n          uri: name,\n          excerpt: z.string().optional(),\n        })\n        .strict(),\n    ),\n  })\n  .strict()\n  .refine((value) => value.supportAtLeast + value.refuteAtLeast > 1, {\n    message: 'Support and refutation thresholds must not overlap',\n  })\n\n/** Optional interpretation of native choices/scores. Policy and evidence belong to the caller. */\nexport type JevReviewCheck = z.infer<typeof checkSchema>\nexport interface JevReviewInput<Q extends JevQuestions = JevQuestions> {\n  version: string\n  request: JevRequest<Q>\n  checks: { [K in keyof Q]: JevReviewCheck }\n}\n\nexport interface PreparedJevReview<Q extends JevQuestions = JevQuestions>\n  extends JevReviewInput<Q> {\n  /** Binds questions, option order, context, evidence, thresholds and definition version. */\n  digest: string\n}\n\nexport interface JevReviewAssessment {\n  question: string\n  status: 'supported' | 'refuted' | 'unresolved'\n  reason:\n    | 'support-threshold'\n    | 'refutation-threshold'\n    | 'missing-evidence'\n    | 'partial-negative-evidence'\n    | 'below-threshold'\n    | 'ambiguous-thresholds'\n  /** Unnormalized marginal mass of caller-designated native alternatives. Not calibrated risk. */\n  supportProbability: number\n  refutationProbability: number\n  unresolvedProbability: number\n  modelConfidence: number | null\n  check: JevReviewCheck\n}\n\nexport interface JevReviewReport {\n  reviewDigest: string\n  requestedModel: string\n  servedModel: string\n  assessments: JevReviewAssessment[]\n}\n\nfunction alternatives(question: JevQuestions[string]): string[] {\n  if (question.type === 'noul') return ['true', 'false']\n  return question.type === 'choice'\n    ? Object.keys(question.criteria)\n    : question.criteria.map((_, index) => String(index))\n}\n\n/** Validate before paid admission; make a detached, frozen snapshot without rewriting native JSON. */\nexport function prepareJevReview<const Q extends JevQuestions>(\n  input: JevReviewInput<Q>,\n): PreparedJevReview<Q> {\n  if (!input.version?.trim()) throw new TypeError('Review version is required')\n  parseJevRequest(input.request)\n  // Document form drops only optional undefined object fields; canonicalization rejects loss.\n  const document = jsonDocument(input)\n  canonicalString(document)\n  // Canonical bytes are for hashing, not dispatch: option order can affect a classifier.\n  const snapshot = structuredClone(document) as JevReviewInput<Q>\n  const keys = Object.keys(snapshot.request.questions)\n  if (\n    !snapshot.checks ||\n    Object.keys(snapshot.checks).length !== keys.length ||\n    keys.some((key) => !Object.hasOwn(snapshot.checks, key))\n  ) {\n    throw new TypeError('Review checks must match the exact question names')\n  }\n  for (const key of keys) {\n    const check = checkSchema.parse(snapshot.checks[key])\n    const labels = [...check.supports, ...check.refutes]\n    const allowed = alternatives(snapshot.request.questions[key]!)\n    if (\n      new Set(labels).size !== labels.length ||\n      labels.some((label) => !allowed.includes(label))\n    ) {\n      throw new TypeError('Review alternatives must exist and be disjoint')\n    }\n    if (check.coverage !== 'missing' && check.evidence.length === 0) {\n      throw new TypeError('Review evidence references are required for non-missing coverage')\n    }\n    // Validation must not normalize a label into a different native option.\n    if (canonicalString(jsonDocument(check)) !== canonicalString(snapshot.checks[key])) {\n      throw new TypeError('Review metadata must not require normalization')\n    }\n  }\n  const order = keys.map((key) => [key, alternatives(snapshot.request.questions[key]!)])\n  return deepFreezeCanonicalJson({ ...snapshot, digest: hashCanonical({ snapshot, order }) })\n}\n\n/** Re-score the same retained distribution without new inference or any authorization effect. */\nexport function assessJevReview<Q extends JevQuestions>(\n  review: PreparedJevReview<Q>,\n  raw: unknown,\n): JevReviewReport {\n  const { digest, ...input } = review\n  const prepared = prepareJevReview(input)\n  if (prepared.digest !== digest) throw new TypeError('Review definition changed after preparation')\n  const result = parseJevResult(raw, prepared.request)\n  const assessments = Object.entries(prepared.checks).map(([question, check]) => {\n    const answer = result.answers[question]!\n    const probabilities: Record<string, number> =\n      answer.type === 'noul' ? { true: answer.noul, false: 1 - answer.noul } : answer.probabilities\n    const sum = (labels: string[]) =>\n      labels.reduce((total, label) => total + probabilities[label]!, 0)\n    const supportProbability = sum(check.supports)\n    const refutationProbability = sum(check.refutes)\n    const used = new Set([...check.supports, ...check.refutes])\n    const unresolvedProbability = sum(\n      Object.keys(probabilities).filter((label) => !used.has(label)),\n    )\n    let status: JevReviewAssessment['status'] = 'unresolved'\n    let reason: JevReviewAssessment['reason'] = 'below-threshold'\n    if (supportProbability > 1 || refutationProbability > 1 || unresolvedProbability > 1) {\n      throw new TypeError('Review probability mass exceeds one; do not silently normalize it')\n    }\n    if (check.coverage === 'missing') reason = 'missing-evidence'\n    else if (\n      supportProbability >= check.supportAtLeast &&\n      refutationProbability >= check.refuteAtLeast\n    ) {\n      reason = 'ambiguous-thresholds'\n    } else if (supportProbability >= check.supportAtLeast) {\n      status = 'supported'\n      reason = 'support-threshold'\n    } else if (refutationProbability >= check.refuteAtLeast) {\n      if (check.coverage === 'complete') {\n        status = 'refuted'\n        reason = 'refutation-threshold'\n      } else reason = 'partial-negative-evidence'\n    }\n    return {\n      question,\n      status,\n      reason,\n      supportProbability,\n      refutationProbability,\n      unresolvedProbability,\n      modelConfidence: answer.type === 'noul' ? null : answer.confidence,\n      check: structuredClone(check),\n    }\n  })\n  return {\n    reviewDigest: digest,\n    requestedModel: review.request.model,\n    servedModel: result.model,\n    assessments,\n  }\n}\n\n/** Ordinary analyst findings; a negative review is not a global safety certificate. */\nexport function jevReviewFindings<Q extends JevQuestions>(\n  review: PreparedJevReview<Q>,\n  result: JevResult<Q>,\n  options: { analystId: string; producedAt?: string },\n): AnalystFinding[] {\n  if (!options.analystId.trim()) throw new TypeError('Analyst id is required')\n  const report = assessJevReview(review, result)\n  return report.assessments\n    .filter((item) => item.status !== 'refuted')\n    .map((item) =>\n      makeFinding({\n        analyst_id: options.analystId,\n        ...(options.producedAt === undefined ? {} : { produced_at: options.producedAt }),\n        subject: item.check.subject,\n        area: item.status === 'unresolved' ? 'assessment-coverage' : item.check.area,\n        severity: item.status === 'unresolved' ? 'info' : item.check.severity,\n        claim:\n          item.status === 'supported'\n            ? `Model-supported hypothesis: ${item.check.claim}`\n            : `Unresolved review: ${item.check.claim}`,\n        evidence_refs: structuredClone(item.check.evidence) as EvidenceRef[],\n        // For unresolved findings, confidence describes the deterministic unresolved status only.\n        confidence: item.status === 'supported' ? item.supportProbability : 1,\n        derived_from_judge: true,\n        id_basis: hashCanonical([item.question, item.status, review.version, item.check.claim]),\n        metadata: {\n          review_digest: report.reviewDigest,\n          question: item.question,\n          requested_model: report.requestedModel,\n          served_model: report.servedModel,\n          assessment: item.status,\n          assessment_reason: item.reason,\n          evidence_coverage: item.check.coverage,\n          support_probability: item.supportProbability,\n          refutation_probability: item.refutationProbability,\n          unresolved_probability: item.unresolvedProbability,\n          model_confidence: item.modelConfidence,\n          calibration: 'not-established',\n          confidence_basis:\n            item.status === 'supported' ? 'model-support-mass' : 'deterministic-status',\n          native_answer: structuredClone(result.answers[item.question]),\n        },\n      }),\n    )\n}\n"],"mappings":"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"}

package/dist/jev-review-D4ynCORp.d.ts

@@ -0,0 +1,76 @@
+import { i as AnalystFinding } from "./types-CeDfCRXp.js";
+import { l as JevResult, o as JevQuestions, s as JevRequest } from "./jev-protocol-CpKI7XSu.js";
+import { z } from "zod";
+//#region src/jev-review.d.ts
+declare const checkSchema: z.ZodObject<{
+  claim: z.ZodString;
+  area: z.ZodString;
+  subject: z.ZodString;
+  severity: z.ZodEnum<{
+    critical: "critical";
+    high: "high";
+    info: "info";
+    low: "low";
+    medium: "medium";
+  }>;
+  supports: z.ZodArray<z.ZodString>;
+  refutes: z.ZodArray<z.ZodString>;
+  supportAtLeast: z.ZodNumber;
+  refuteAtLeast: z.ZodNumber;
+  coverage: z.ZodEnum<{
+    complete: "complete";
+    missing: "missing";
+    partial: "partial";
+  }>;
+  evidence: z.ZodArray<z.ZodObject<{
+    kind: z.ZodEnum<{
+      artifact: "artifact";
+      event: "event";
+      finding: "finding";
+      metric: "metric";
+      span: "span";
+    }>;
+    uri: z.ZodString;
+    excerpt: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>>;
+}, z.core.$strict>;
+/** Optional interpretation of native choices/scores. Policy and evidence belong to the caller. */
+type JevReviewCheck = z.infer<typeof checkSchema>;
+interface JevReviewInput<Q extends JevQuestions = JevQuestions> {
+  version: string;
+  request: JevRequest<Q>;
+  checks: { [K in keyof Q]: JevReviewCheck; };
+}
+interface PreparedJevReview<Q extends JevQuestions = JevQuestions> extends JevReviewInput<Q> {
+  /** Binds questions, option order, context, evidence, thresholds and definition version. */
+  digest: string;
+}
+interface JevReviewAssessment {
+  question: string;
+  status: 'supported' | 'refuted' | 'unresolved';
+  reason: 'support-threshold' | 'refutation-threshold' | 'missing-evidence' | 'partial-negative-evidence' | 'below-threshold' | 'ambiguous-thresholds';
+  /** Unnormalized marginal mass of caller-designated native alternatives. Not calibrated risk. */
+  supportProbability: number;
+  refutationProbability: number;
+  unresolvedProbability: number;
+  modelConfidence: number | null;
+  check: JevReviewCheck;
+}
+interface JevReviewReport {
+  reviewDigest: string;
+  requestedModel: string;
+  servedModel: string;
+  assessments: JevReviewAssessment[];
+}
+/** Validate before paid admission; make a detached, frozen snapshot without rewriting native JSON. */
+declare function prepareJevReview<const Q extends JevQuestions>(input: JevReviewInput<Q>): PreparedJevReview<Q>;
+/** Re-score the same retained distribution without new inference or any authorization effect. */
+declare function assessJevReview<Q extends JevQuestions>(review: PreparedJevReview<Q>, raw: unknown): JevReviewReport;
+/** Ordinary analyst findings; a negative review is not a global safety certificate. */
+declare function jevReviewFindings<Q extends JevQuestions>(review: PreparedJevReview<Q>, result: JevResult<Q>, options: {
+  analystId: string;
+  producedAt?: string;
+}): AnalystFinding[];
+//#endregion
+export { PreparedJevReview as a, prepareJevReview as c, JevReviewReport as i, JevReviewCheck as n, assessJevReview as o, JevReviewInput as r, jevReviewFindings as s, JevReviewAssessment as t };
+//# sourceMappingURL=jev-review-D4ynCORp.d.ts.map