@remnic/bench 9.6.33 → 9.6.34

package/dist/index.d.ts

@@ -3465,6 +3465,83 @@ declare function buildProviderFreeLoCoMoRetrievalConfig(retrievalConfig: Record<
 declare function captureLoCoMoRetrievalTrace(options: CaptureLoCoMoRetrievalTraceOptions): Promise<LoCoMoRetrievalTraceReceipt>;
 declare function serializeLoCoMoRetrievalTraceReceipt(receipt: LoCoMoRetrievalTraceReceipt): string;
 
+declare const LOCOMO_RETRIEVAL_TRACE_DELTA_SCHEMA_VERSION: 1;
+declare const CATEGORIES: readonly ["single_hop", "multi_hop", "temporal", "open_domain", "adversarial"];
+declare const MECHANISMS: readonly ["real-core-visible-lcm-displacement", "lcm-selection-change", "composition-filter-displacement", "composition-digest-change", "budget-truncation-change", "mixed", "no-structural-delta", "insufficient-exact-lineage"];
+type LoCoMoRetrievalMechanism = (typeof MECHANISMS)[number];
+type LoCoMoCategory = (typeof CATEGORIES)[number];
+interface LoCoMoStructuralMultisetDelta {
+    baselineCount: number;
+    realCount: number;
+    sharedCount: number;
+    baselineOnlyCount: number;
+    realOnlyCount: number;
+    changed: boolean;
+}
+interface LoCoMoRetrievalTaskDelta {
+    taskRef: {
+        sha256: string;
+        length: number;
+    };
+    category: LoCoMoCategory;
+    mechanism: LoCoMoRetrievalMechanism;
+    dimensions: {
+        sectionVisibleChars: LoCoMoStructuralMultisetDelta;
+        selections: LoCoMoStructuralMultisetDelta;
+        archiveRows: LoCoMoStructuralMultisetDelta;
+        lcmCandidates: LoCoMoStructuralMultisetDelta;
+        coreResults: LoCoMoStructuralMultisetDelta;
+        coreFilters: LoCoMoStructuralMultisetDelta;
+        coreBudget: LoCoMoStructuralMultisetDelta;
+        recallBudget: LoCoMoStructuralMultisetDelta;
+        compositionPolicy: LoCoMoStructuralMultisetDelta;
+        compositionDigests: LoCoMoStructuralMultisetDelta;
+    };
+}
+interface LoCoMoRetrievalMechanismSummary {
+    taskCount: number;
+    mechanisms: Record<LoCoMoRetrievalMechanism, number>;
+}
+interface LoCoMoRetrievalTraceDeltaReport {
+    schemaVersion: typeof LOCOMO_RETRIEVAL_TRACE_DELTA_SCHEMA_VERSION;
+    benchmarkId: "locomo";
+    analysisKind: "paired-retrieval-structural-delta";
+    artifactHash: string;
+    sensitivity: {
+        classification: "restricted";
+        contentEncoding: "sha256+length";
+        containsGold: false;
+        containsRawContent: false;
+        containsRawIdentifiers: false;
+    };
+    comparison: {
+        baselineArtifactHash: string;
+        realArtifactHash: string;
+        retrievalConfigHashesDiffer: true;
+        taskOrderSha256: string;
+    };
+    overall: LoCoMoRetrievalMechanismSummary;
+    categories: Array<LoCoMoRetrievalMechanismSummary & {
+        category: LoCoMoCategory;
+    }>;
+    dominantMultiHopMechanism: {
+        status: "supported" | "not-supported";
+        mechanism?: LoCoMoRetrievalMechanism;
+        count: number;
+        taskCount: number;
+        rule: "strict-majority-and-at-least-two";
+    };
+    tasks: LoCoMoRetrievalTaskDelta[];
+    evidenceBoundary: {
+        attribution: "observed-structural-mechanism-only";
+        causalClaim: false;
+        exactLineageRequired: true;
+        explanation: string;
+    };
+}
+declare function diagnoseLoCoMoRetrievalTraceDelta(baseline: LoCoMoRetrievalTraceReceipt, real: LoCoMoRetrievalTraceReceipt): LoCoMoRetrievalTraceDeltaReport;
+declare function serializeLoCoMoRetrievalTraceDelta(report: LoCoMoRetrievalTraceDeltaReport): string;
+
 /**
  * Dataset-contamination guard.
  *
@@ -5538,4 +5615,4 @@ declare function checkCodingGraphRegression(report: CodingGraphBenchReport, base
  */
 declare function buildBaselineFromReport(report: CodingGraphBenchReport, note: string): CodingGraphBaseline;
 
-export { AMA_BENCH_DIAGNOSTIC_VARIANTS, ASSISTANT_AGENT_CONFIG_KEY, ASSISTANT_JUDGE_CONFIG_KEY, ASSISTANT_MEETING_PREP_SCENARIOS, ASSISTANT_MEETING_PREP_SMOKE_SCENARIOS, ASSISTANT_MORNING_BRIEF_SCENARIOS, ASSISTANT_MORNING_BRIEF_SMOKE_SCENARIOS, ASSISTANT_NEXT_BEST_ACTION_SCENARIOS, ASSISTANT_NEXT_BEST_ACTION_SMOKE_SCENARIOS, ASSISTANT_RUBRIC_DIMENSIONS, ASSISTANT_RUBRIC_ID_KEY, ASSISTANT_SEEDS_CONFIG_KEY, ASSISTANT_SPOT_CHECK_DIR_KEY, ASSISTANT_SYNTHESIS_SCENARIOS, ASSISTANT_SYNTHESIS_SMOKE_SCENARIOS, type AblationConfigOverrides, type AbstentionRetrievalCase, type AggregateMetrics, type AmaBenchDiagnosticAdapterOptions, type AmaBenchDiagnosticAnswererMode, type AmaBenchDiagnosticBreakdown, type AmaBenchDiagnosticMatrixArtifact, type AmaBenchDiagnosticRecallMode, type AmaBenchDiagnosticRunContext, type AmaBenchDiagnosticTaskEvidence, type AmaBenchDiagnosticTaskRow, type AmaBenchDiagnosticVariant, type AmaBenchDiagnosticVariantSummary, type AnthropicProviderConfig, type AssistantAgent, type AssistantMemoryFact, type AssistantMemoryGraph, type AssistantRubricDimension, type AssistantRubricRequest, type AssistantRubricScores, type AssistantRunnerOptions, type AssistantScenario, type AssistantStance, type AttackRecallOptions, type AttackRetrievalHit, type AttackerMode, BENCHMARK_ARTIFACT_SCHEMA_VERSION, BENCHMARK_INTEGRITY_META_SCHEMA, BENCHMARK_REPRO_MANIFEST_FILENAME, BENCHMARK_REPRO_MANIFEST_SCHEMA_VERSION, BENCHMARK_RESULT_SCHEMA, BENCHMARK_SPLIT_TYPES, type BaselineRow, type BaselineScenario, type BeamDatasetPreview, type BenchConfig, type BenchJudge, type BenchJudgeResult, type BenchMemoryAdapter, type BenchModelSource, type BenchReasoningEffort, type BenchRecallLineageStatus, type BenchRecallOptions, type BenchRecallSupportAssessment, type BenchRecallSupportRequest, type BenchRecallSupportStatus, type BenchRecallTrace, type BenchRecallTraceCoreCapture, type BenchRecallTraceLcmCandidate, type BenchRecallTraceRange, type BenchRecallTraceSection, type BenchRecallTraceSelection, type BenchRecallWithTraceResult, type BenchResponder, type BenchResponse, type BenchRuntimeProfile, type BenchTier, type BenchmarkArtifact, type BenchmarkArtifactEnvironment, type BenchmarkArtifactHardware, type BenchmarkArtifactJudgeCalibration, type BenchmarkArtifactPerTaskScore, type BenchmarkArtifactSystem, type BenchmarkArtifactTier, type BenchmarkCategory, type BenchmarkDefinition, type BenchmarkIntegrityMeta, type BenchmarkMeta, type BenchmarkMode, type BenchmarkReport, type BenchmarkReproManifest, type BenchmarkReproManifestDataset, type BenchmarkReproManifestFile, type BenchmarkReproManifestResult, type BenchmarkResult, type BenchmarkSplitType, type BenchmarkStatus, type BenchmarkSuiteResult, type BenchmarkTier, type BootstrapKappaOptions, type BootstrapKappaResult, type BuildBenchmarkArtifactInput, type BuildBenchmarkPublishFeedOptions, type BuildBenchmarkReproManifestOptions, type BuiltInProvider, CALIBRATION_SLICE_SIZE, CANARY_FIXED_RECALL, CANARY_SCORE_FLOOR, DEFAULT_10K_FIXTURE as CODING_GRAPH_10K_FIXTURE, CODING_GRAPH_BENCH_SCHEMA_VERSION, DEFAULT_TOLERANCE_PERCENT as CODING_GRAPH_DEFAULT_TOLERANCE, MIN_ITERATIONS as CODING_GRAPH_MIN_ITERATIONS, DEFAULT_SMOKE_FIXTURE as CODING_GRAPH_SMOKE_FIXTURE, type CalibrationAnswer, type CalibrationVerdictPair, type CanaryAdapterOptions, type CanaryFloorCheck, type CaptureLoCoMoRetrievalTraceOptions, type ClaudeCliProviderConfig, type CodexCliProviderConfig, type CodexCreditReceipt, type CodexCreditReceiptScope, type CodexCreditReconciliationReceipt, type CodingGraphBaseline, type CodingGraphBenchConfig, type CodingGraphBenchReport, type MachineFingerprint as CodingGraphMachineFingerprint, type CodingGraphMetricKey, type RegressionMetricDetail as CodingGraphRegressionDetail, type RegressionMetricKey as CodingGraphRegressionKey, type RegressionGateResult as CodingGraphRegressionResult, type CohenKappaResult, type ComparisonMetricDelta, type ComparisonResult, type CompletionOpts, type CompletionResult, type ConfidenceInterval, type ContaminationCheckResult, type ContaminationEntry, type ContaminationManifest, type CustomBenchmarkScoring, type CustomBenchmarkSpec, type CustomBenchmarkTask, DEFAULT_ABLATION_BENCHMARK, DEFAULT_ABLATION_BOOTSTRAP_SEED, DEFAULT_ASSISTANT_RUBRIC_ID, DEFAULT_BASELINE_SCENARIOS, DEFAULT_JUDGE_BINARIZATION_THRESHOLD, DEFAULT_KAPPA_BOOTSTRAP_SAMPLES, DEFAULT_KAPPA_CONFIDENCE_LEVEL, DEFAULT_OPENAI_RESPONSES_JUDGE_MODEL, type DatasetSource, type DiagnoseLoComoProfileDeltaOptions, type DiagnoseLoComoRecallDeltaOptions, type DiscoveredModel, EMPTY_CONTAMINATION_MANIFEST, type EffectSizeInterpretation, type EffectSizeSummary, type ExplainResult, type ExtractedEntity, type ExtractedLink, type ExtractedPage, type ExtractionAttackOptions, type ExtractionAttackResult, type ExtractionAttackTarget, type FixtureGenerator, type FixtureOutput, type FixtureVariant, GENERAL_ANSWER_JUDGE_RUBRIC, type GeneratedFile, type GeneratedRepo, type GoldEntity, type GoldEntityType, type GoldGraph, type GoldLink, type GoldPage, type HarnessRng, INTEGRITY_CIPHER_ALGORITHM, INTEGRITY_HASH_ALGORITHM, INTEGRITY_META_FIELDS, type IngestionBenchAdapter, type IngestionLog, JUDGE_CALIBRATION_KAPPA_THRESHOLD, JUDGE_CALIBRATION_PROTOCOL_VERSION, type JudgeCalibrationCheckpointProvenance, type JudgeCalibrationIdentities, type JudgeCalibrationResult, type JudgeCategory, type KappaConfidenceInterval, LOCAL_LAB_PROVIDER_KINDS, LOCOMO_DATASET_FILENAMES, LOCOMO_FULL_TASK_COUNT, LOCOMO_RECALL_DIFF_LINE_LIMIT, LOCOMO_RECALL_EXCERPT_CHARS, LOCOMO_RETRIEVAL_TRACE_BUDGET_VERSION, LOCOMO_RETRIEVAL_TRACE_SCHEMA_VERSION, LOCOMO_RETRIEVAL_TRACE_SELECTION_VERSION, LONG_MEM_EVAL_DATASET_FILENAMES, type LeaderboardArtifactWrite, type LettaAdapterConfig, LettaMemCorrectAdapter, type LlmJudge, type LlmProvider, type LoCoMoRetrievalSessionReceipt, type LoCoMoRetrievalStructuralTrace, type LoCoMoRetrievalTaskReceipt, type LoCoMoRetrievalTraceCoreCaptureReceipt, type LoCoMoRetrievalTraceProfile, type LoCoMoRetrievalTraceReceipt, type LoCoMoRetrievalTraceSelectionManifest, type LoCoMoRetrievalTraceSelector, type LoComoCategoryDelta, type LoComoFinalContextRegression, type LoComoMetricDelta, type LoComoProfileArtifactEvidence, type LoComoProfileDeltaReport, type LoComoRawResultEvidence, type LoComoRecallCategoryDelta, type LoComoRecallContextSummary, type LoComoRecallDeltaReport, type LoComoRecallLineDelta, type LoComoRecallLineEvidence, type LoComoRecallMetricDelta, type LoComoRecallResultProvenance, type LoComoRecallTextDigest, type LoComoTaskRegression, type LoadDatasetOptions, type LoadSealedQrelsOptions, type LoadedDataset, type LoadedJudgeCalibrationState, type LocalLabManifest, type LocalLabManifestNotes, type LocalLabPhase, type LocalLabPhaseDescriptor, type LocalLabPhaseExecute, type LocalLabPhaseName, type LocalLabPhaseOutcome, LocalLabPreflightError, type LocalLabPreflightFailure, type LocalLabPreflightInput, type LocalLabPreflightOptions, type LocalLabPreflightResult, type LocalLabPreflightSuccess, type LocalLabProviderKind, type LocalLabRoleConfig, type LocalLlmProviderConfig, MEMCORRECT_CORRECTION_ACCEPTANCE_RUBRIC, MEMCORRECT_CORRECTION_ACCEPTANCE_RUBRIC_VERSION, MEMCORRECT_STALE_HARM_RUBRIC, MEMCORRECT_STALE_HARM_RUBRIC_VERSION, MEMORY_EVAL_DIMENSIONS, MEMORY_EVAL_PUBLIC_LINE, MIN_CALIBRATION_SOURCE_TASKS, MITIGATED_BASELINE_SCENARIOS, type McpArgumentSemantic, type McpBackendErrorCode, type McpBackendResult, type McpBenchMemoryAdapter, type McpConformanceResult, type McpHttpTransportConfig, type McpListedTool, type McpMemCorrectAdapter, type McpMemoryAdapterOptions, McpMemoryBackendError, type McpMemoryToolMapping, type McpMemoryTransportConfig, type McpStdioTransportConfig, type McpToolCallResult, type McpToolClient, type McpToolMappingEntry, type McpToolMappingValue, type McpToolOperation, type Mem0AdapterConfig, Mem0MemCorrectAdapter, type MemCorrectGeneratorOptions, type MemCorrectJudgeRequest, type MemCorrectJudgeResult, type MemCorrectSystemAdapter, type MemoryEvalCategory, type MemoryEvalDimension, type MemoryEvalDimensionId, type MemoryEvalMetric, type MemoryGraph, type MemoryStats, type MemorySystem, type Message, type MetricAggregate, type MicroMetric, MissingCredentialError, type MitigatedBaselineConfig, type MitigatedTargetConfig, type MultipleChoiceQuestion, OPENAI_RESPONSES_JUDGE_RUBRIC_VERSION, OTHER_NAMESPACE_MEMORIES, type OllamaProviderConfig, type OpenAiCompatibleProviderConfig, OpenAiResponsesJudgeError, type OpenAiResponsesJudgeErrorCode, type OpenAiResponsesJudgeTelemetry, OpenAiResponsesProvider, type OpenAiResponsesProviderConfig, type OpenAiResponsesVerdict, type OpenAiResponsesVerdictResult, PROCEDURAL_REAL_SCENARIOS, PROCEDURAL_REAL_SCENARIOS_SMOKE, PUBLISHED_BENCHMARK_ARTIFACT_IDS, type PersonalizationRetrievalCase, type PreflightDiscoveredModel, type ProceduralAblationArtifact, type ProceduralAblationPerCase, type ProceduralAblationScenario, type ProceduralRealScenario, type ProceduralRealScenarioCategory, type ProviderBaseConfig, type ProviderConfig, type ProviderDiscoveryResult, type ProviderFactoryConfig, type PublishSkipReason, type PublishSkipRecord, type PublishedBenchmarkFeed, type PublishedBenchmarkFeedEntry, type PublishedBenchmarkId, REQUIRED_FRONTMATTER_FIELDS, type RecallMetrics, type RecoveredMemory, type RegressionDetail, type RegressionGateResult$1 as RegressionGateResult, type RemnicAdapterOptions, type ReportCardProvenanceContext, type ResolveBenchRuntimeProfileOptions, type ResolvedBenchRuntimeProfile, type ResolvedLocalLabProfile, type ResolvedLocalLabRole, type ResolvedRunBenchmarkOptions, type RotatedChoices, type RunBenchmarkOptions, type RunJudgeCalibrationOptions, type RunProceduralAblationCliArgs, type RunProceduralAblationOptions, type RunSequentialPhasesOptions, SCHEMA_TIER_FIXTURE, SCHEMA_TIER_SMOKE_FIXTURE, SEALED_PROMPT_REGISTRY, SINGLE_FLAG_ABLATION_MATRIX, SYNTHETIC_MEMORIES, type SanitizedDiagnosticProvider, type SavedBaseline, type SchemaTierCorpus, type SchemaTierFixture, type SchemaTierName, type SchemaTierPage, type SchemaTierPageFrontmatter, type SealedArtifact, type SealedJudgeDecision, type SealedJudgeInput, type SealedQrelsArtifact, type SealedQrelsHandle, type SealedRubric, type SearchResult, type SeededMemory, type SeededRng, type SequentialPhaseHooks, type SingleFlagAblationCell, type SingleFlagAblationId, type SpotCheckLogger, type StatisticalReport, type StructuredJudge, StructuredJudgeError, type StructuredJudgeErrorCode, type StructuredJudgeProvider, type StructuredJudgeTelemetry, type StructuredJudgeVerdict, type StructuredJudgeVerdictResult, type StructuredVerdictRequest, type SyntheticEdge, type SyntheticEmailIngestionAdapterOptions, type SyntheticFileIR, type SyntheticRepoConfig, type SyntheticSymbol, type SyntheticTargetOptions, type TaskResult, type TaskTokenUsage, type TemporalRetrievalCase, type ThirdPartyAdapterConfig, type TierDetail, type TimelineEntry, type TokenUsage, type WallMetric, type WriteBenchmarkArtifactResult, type ZepAdapterConfig, ZepMemCorrectAdapter, addContaminationEntry, aggregateTaskScores, answerBenchmarkQuestion, assertCanaryUnderFloor, assertIntegrityMetaPresent, assertPublishableIntegrity, assertSha256Hex, assistantMeetingPrepDefinition, assistantMorningBriefDefinition, assistantNextBestActionDefinition, assistantSynthesisDefinition, backlinkF1, binarizeJudgeScore, bootstrapCohensKappaConfidenceInterval, bootstrapMeanConfidenceInterval, buildAmaBenchDiagnosticMatrixArtifact, buildAmaBenchDiagnosticVariantSummary, buildAmaBenchLeaderboardRows, buildBaselineFromReport, buildBenchmarkArtifact, buildBenchmarkArtifactFilename, buildBenchmarkPublishFeed, buildBenchmarkReproManifest, buildBenchmarkRunSeeds, buildCodexCreditReceipt, buildJudgePayload, buildOracleTrajectoryRecall, buildProviderFreeLoCoMoRetrievalConfig, buildSchemaTierFixture, buildSchemaTierSmokeFixture, calendarFixture, canonicalJsonStringify, captureLoCoMoRetrievalTrace, captureMachineFingerprint, chatFixture, checkCodingGraphRegression, checkDatasetContamination, checkRegression, clampScore, cohensD, compareResults, computeCohensKappa, computeSealHash, containsAnswer, createSeededRng$1 as createAdamSeededRng, createAmaBenchDiagnosticAdapter, createAnthropicProvider, createCanaryAdapter, createClaudeCliProvider, createCodexCliProvider, createSeededRng as createCodingGraphSeededRng, createDeterministicSpotCheckLogger, createGatewayResponder, createLightweightAdapter, createLiteLlmProvider, createLocalLlmProvider, createMcpDemoMemCorrectAdapter, createMcpDemoMemoryAdapter, createMcpMemCorrectAdapter, createMcpMemoryAdapter, createMitigatedTarget, createOllamaProvider, createOpenAiCompatibleProvider, createOpenAiResponsesBenchJudge, createOpenAiResponsesProvider, createSeededRandom as createProceduralAblationSeededRandom, createProvider, createProviderBackedAmaBenchRecommendedJudge, createProviderBackedJudge, createProviderBackedResponder, createProviderBackedStructuredJudge, createRemnicAdapter, createResponderFromProvider, createSeededRng$2 as createSeededRng, createSpotCheckFileLogger, createStructuredBenchJudge, createStructuredJudgeFromProvider, createSyntheticEmailIngestionAdapter, createSyntheticTarget, createTimeoutGuardedAdapter, defaultBenchmarkBaselineDir, defaultBenchmarkPublishPath, deleteBenchmarkResults, diagnoseLoComoProfileDelta, diagnoseLoComoRecallDelta, discoverAllProviders, discoveryEndpointFor, emailFixture, entityRecall, exactMatch, extractMetrics as extractCodingGraphMetrics, extractMarkdownSectionsByTitle, f1Score, fixtureToAblationScenarios, formatHandoffNote, formatMissingDatasetError, generateReport, generateSyntheticRepo, getAblationCell, getBenchmark, getBenchmarkLowerIsBetter, getGitSha, getMemoryEvalDimension, getProviderBackedJudgePromptIdentity, getRemnicVersion, hashBenchmarkArtifact, hashBytes, hashCanonicalJson, hashOrderedQuestionIds, hashString, integrityMetaIsComplete, interpretEffectSize, isAmaBenchUnknownLikeAnswer, isContaminationEntry, isContaminationManifest, isSealedQrelsArtifact, isSha256Hex, isStructuredJudgeProvider, judgeMemCorrectCorrectionAcceptance, judgeMemCorrectStaleMemoryHarm, linkMatches, listBenchmarkBaselines, listBenchmarkResults, listBenchmarks, listMemoryEvalBenchmarkIds, listMemoryEvalDimensions, llmJudgeScore, llmJudgeScoreDetailed, loadAblationFixture, loadBaseline, loadBeamDatasetPreview, loadBenchmarkArtifact, loadBenchmarkBaseline, loadBenchmarkReportCardProvenance, loadBenchmarkResult, loadCustomBenchmarkFile, loadJudgeCalibrationState, loadLoCoMo10, loadLocalLabManifest, loadLongMemEvalS, loadSealKeyFromEnv, loadSealedQrels, loadSealedRubric, matchEntity, mergeContaminationManifests, openSeal, orchestrateBenchmarkRuns, pairedDeltaConfidenceInterval, parseBenchmarkArtifact, parseCustomBenchmark, parseLocalLabManifest, parseRubricResponse, parseSealedQrels, pickStableQualifiedName, precisionAtK, preflightLoCoMoRetrievalTraceCapture, preflightLocalLabRole, projectFolderFixture, recallAtK, reconcileCodexCreditLedger, redactBenchmarkResultSecrets, renderBaselineMarkdown, renderBenchmarkResultExport, renderLoComoProfileDeltaMarkdown, renderLoComoRecallDeltaMarkdown, renderMemorySummaryForJudge, renderMemoryViewForAgent, resolveAssistantAgent, resolveAssistantRubricId, resolveAssistantSeeds, resolveAssistantSpotCheckDir, resolveBenchRuntimeProfile, resolveBenchmarkPhaseTimeoutMs, resolveBenchmarkProgressLogging, resolveBenchmarkResultReference, resolveBenchmarkRunCount, resolveLocalLabJudgeProviderConfig, resolveLocalLabProfile, resolveLocalLabRole, resolveStructuredJudge, rotateDistractors, rougeL, runAssistantBenchmark, runAssistantMeetingPrepBenchmark, runAssistantMorningBriefBenchmark, runAssistantNextBestActionBenchmark, runAssistantSynthesisBenchmark, runBaseline, runBenchSuite, runBenchmark, runCodingGraphBenchmark, runCustomBenchmarkFile, runExplain, runExtractionAttack, runJudgeCalibration, runMitigatedBaseline, runProceduralAblation, runProceduralAblationCli, runSealedJudge, runSequentialPhases, safeHexEqual, sanitizeLoComoResultReference, saveBaseline, saveBenchmarkBaseline, schemaCompleteness, sealPayload, selectAmaBenchDiagnosticVariants, selectCalibrationSlice, selectFixtureVariant, serializeBenchmarkArtifact, serializeJsonl, serializeLoCoMoRetrievalTraceReceipt, serializeSealedQrels, shuffleTasks, timed, verifyRubricDigest, writeBenchmarkArtifact, writeBenchmarkPublishFeed, writeBenchmarkReproManifest, writeBenchmarkResult, writeJudgeCalibrationState, writeLeaderboardArtifactsForResult, zeroScores };
+export { AMA_BENCH_DIAGNOSTIC_VARIANTS, ASSISTANT_AGENT_CONFIG_KEY, ASSISTANT_JUDGE_CONFIG_KEY, ASSISTANT_MEETING_PREP_SCENARIOS, ASSISTANT_MEETING_PREP_SMOKE_SCENARIOS, ASSISTANT_MORNING_BRIEF_SCENARIOS, ASSISTANT_MORNING_BRIEF_SMOKE_SCENARIOS, ASSISTANT_NEXT_BEST_ACTION_SCENARIOS, ASSISTANT_NEXT_BEST_ACTION_SMOKE_SCENARIOS, ASSISTANT_RUBRIC_DIMENSIONS, ASSISTANT_RUBRIC_ID_KEY, ASSISTANT_SEEDS_CONFIG_KEY, ASSISTANT_SPOT_CHECK_DIR_KEY, ASSISTANT_SYNTHESIS_SCENARIOS, ASSISTANT_SYNTHESIS_SMOKE_SCENARIOS, type AblationConfigOverrides, type AbstentionRetrievalCase, type AggregateMetrics, type AmaBenchDiagnosticAdapterOptions, type AmaBenchDiagnosticAnswererMode, type AmaBenchDiagnosticBreakdown, type AmaBenchDiagnosticMatrixArtifact, type AmaBenchDiagnosticRecallMode, type AmaBenchDiagnosticRunContext, type AmaBenchDiagnosticTaskEvidence, type AmaBenchDiagnosticTaskRow, type AmaBenchDiagnosticVariant, type AmaBenchDiagnosticVariantSummary, type AnthropicProviderConfig, type AssistantAgent, type AssistantMemoryFact, type AssistantMemoryGraph, type AssistantRubricDimension, type AssistantRubricRequest, type AssistantRubricScores, type AssistantRunnerOptions, type AssistantScenario, type AssistantStance, type AttackRecallOptions, type AttackRetrievalHit, type AttackerMode, BENCHMARK_ARTIFACT_SCHEMA_VERSION, BENCHMARK_INTEGRITY_META_SCHEMA, BENCHMARK_REPRO_MANIFEST_FILENAME, BENCHMARK_REPRO_MANIFEST_SCHEMA_VERSION, BENCHMARK_RESULT_SCHEMA, BENCHMARK_SPLIT_TYPES, type BaselineRow, type BaselineScenario, type BeamDatasetPreview, type BenchConfig, type BenchJudge, type BenchJudgeResult, type BenchMemoryAdapter, type BenchModelSource, type BenchReasoningEffort, type BenchRecallLineageStatus, type BenchRecallOptions, type BenchRecallSupportAssessment, type BenchRecallSupportRequest, type BenchRecallSupportStatus, type BenchRecallTrace, type BenchRecallTraceCoreCapture, type BenchRecallTraceLcmCandidate, type BenchRecallTraceRange, type BenchRecallTraceSection, type BenchRecallTraceSelection, type BenchRecallWithTraceResult, type BenchResponder, type BenchResponse, type BenchRuntimeProfile, type BenchTier, type BenchmarkArtifact, type BenchmarkArtifactEnvironment, type BenchmarkArtifactHardware, type BenchmarkArtifactJudgeCalibration, type BenchmarkArtifactPerTaskScore, type BenchmarkArtifactSystem, type BenchmarkArtifactTier, type BenchmarkCategory, type BenchmarkDefinition, type BenchmarkIntegrityMeta, type BenchmarkMeta, type BenchmarkMode, type BenchmarkReport, type BenchmarkReproManifest, type BenchmarkReproManifestDataset, type BenchmarkReproManifestFile, type BenchmarkReproManifestResult, type BenchmarkResult, type BenchmarkSplitType, type BenchmarkStatus, type BenchmarkSuiteResult, type BenchmarkTier, type BootstrapKappaOptions, type BootstrapKappaResult, type BuildBenchmarkArtifactInput, type BuildBenchmarkPublishFeedOptions, type BuildBenchmarkReproManifestOptions, type BuiltInProvider, CALIBRATION_SLICE_SIZE, CANARY_FIXED_RECALL, CANARY_SCORE_FLOOR, DEFAULT_10K_FIXTURE as CODING_GRAPH_10K_FIXTURE, CODING_GRAPH_BENCH_SCHEMA_VERSION, DEFAULT_TOLERANCE_PERCENT as CODING_GRAPH_DEFAULT_TOLERANCE, MIN_ITERATIONS as CODING_GRAPH_MIN_ITERATIONS, DEFAULT_SMOKE_FIXTURE as CODING_GRAPH_SMOKE_FIXTURE, type CalibrationAnswer, type CalibrationVerdictPair, type CanaryAdapterOptions, type CanaryFloorCheck, type CaptureLoCoMoRetrievalTraceOptions, type ClaudeCliProviderConfig, type CodexCliProviderConfig, type CodexCreditReceipt, type CodexCreditReceiptScope, type CodexCreditReconciliationReceipt, type CodingGraphBaseline, type CodingGraphBenchConfig, type CodingGraphBenchReport, type MachineFingerprint as CodingGraphMachineFingerprint, type CodingGraphMetricKey, type RegressionMetricDetail as CodingGraphRegressionDetail, type RegressionMetricKey as CodingGraphRegressionKey, type RegressionGateResult as CodingGraphRegressionResult, type CohenKappaResult, type ComparisonMetricDelta, type ComparisonResult, type CompletionOpts, type CompletionResult, type ConfidenceInterval, type ContaminationCheckResult, type ContaminationEntry, type ContaminationManifest, type CustomBenchmarkScoring, type CustomBenchmarkSpec, type CustomBenchmarkTask, DEFAULT_ABLATION_BENCHMARK, DEFAULT_ABLATION_BOOTSTRAP_SEED, DEFAULT_ASSISTANT_RUBRIC_ID, DEFAULT_BASELINE_SCENARIOS, DEFAULT_JUDGE_BINARIZATION_THRESHOLD, DEFAULT_KAPPA_BOOTSTRAP_SAMPLES, DEFAULT_KAPPA_CONFIDENCE_LEVEL, DEFAULT_OPENAI_RESPONSES_JUDGE_MODEL, type DatasetSource, type DiagnoseLoComoProfileDeltaOptions, type DiagnoseLoComoRecallDeltaOptions, type DiscoveredModel, EMPTY_CONTAMINATION_MANIFEST, type EffectSizeInterpretation, type EffectSizeSummary, type ExplainResult, type ExtractedEntity, type ExtractedLink, type ExtractedPage, type ExtractionAttackOptions, type ExtractionAttackResult, type ExtractionAttackTarget, type FixtureGenerator, type FixtureOutput, type FixtureVariant, GENERAL_ANSWER_JUDGE_RUBRIC, type GeneratedFile, type GeneratedRepo, type GoldEntity, type GoldEntityType, type GoldGraph, type GoldLink, type GoldPage, type HarnessRng, INTEGRITY_CIPHER_ALGORITHM, INTEGRITY_HASH_ALGORITHM, INTEGRITY_META_FIELDS, type IngestionBenchAdapter, type IngestionLog, JUDGE_CALIBRATION_KAPPA_THRESHOLD, JUDGE_CALIBRATION_PROTOCOL_VERSION, type JudgeCalibrationCheckpointProvenance, type JudgeCalibrationIdentities, type JudgeCalibrationResult, type JudgeCategory, type KappaConfidenceInterval, LOCAL_LAB_PROVIDER_KINDS, LOCOMO_DATASET_FILENAMES, LOCOMO_FULL_TASK_COUNT, LOCOMO_RECALL_DIFF_LINE_LIMIT, LOCOMO_RECALL_EXCERPT_CHARS, LOCOMO_RETRIEVAL_TRACE_BUDGET_VERSION, LOCOMO_RETRIEVAL_TRACE_DELTA_SCHEMA_VERSION, LOCOMO_RETRIEVAL_TRACE_SCHEMA_VERSION, LOCOMO_RETRIEVAL_TRACE_SELECTION_VERSION, LONG_MEM_EVAL_DATASET_FILENAMES, type LeaderboardArtifactWrite, type LettaAdapterConfig, LettaMemCorrectAdapter, type LlmJudge, type LlmProvider, type LoCoMoCategory, type LoCoMoRetrievalMechanism, type LoCoMoRetrievalMechanismSummary, type LoCoMoRetrievalSessionReceipt, type LoCoMoRetrievalStructuralTrace, type LoCoMoRetrievalTaskDelta, type LoCoMoRetrievalTaskReceipt, type LoCoMoRetrievalTraceCoreCaptureReceipt, type LoCoMoRetrievalTraceDeltaReport, type LoCoMoRetrievalTraceProfile, type LoCoMoRetrievalTraceReceipt, type LoCoMoRetrievalTraceSelectionManifest, type LoCoMoRetrievalTraceSelector, type LoCoMoStructuralMultisetDelta, type LoComoCategoryDelta, type LoComoFinalContextRegression, type LoComoMetricDelta, type LoComoProfileArtifactEvidence, type LoComoProfileDeltaReport, type LoComoRawResultEvidence, type LoComoRecallCategoryDelta, type LoComoRecallContextSummary, type LoComoRecallDeltaReport, type LoComoRecallLineDelta, type LoComoRecallLineEvidence, type LoComoRecallMetricDelta, type LoComoRecallResultProvenance, type LoComoRecallTextDigest, type LoComoTaskRegression, type LoadDatasetOptions, type LoadSealedQrelsOptions, type LoadedDataset, type LoadedJudgeCalibrationState, type LocalLabManifest, type LocalLabManifestNotes, type LocalLabPhase, type LocalLabPhaseDescriptor, type LocalLabPhaseExecute, type LocalLabPhaseName, type LocalLabPhaseOutcome, LocalLabPreflightError, type LocalLabPreflightFailure, type LocalLabPreflightInput, type LocalLabPreflightOptions, type LocalLabPreflightResult, type LocalLabPreflightSuccess, type LocalLabProviderKind, type LocalLabRoleConfig, type LocalLlmProviderConfig, MEMCORRECT_CORRECTION_ACCEPTANCE_RUBRIC, MEMCORRECT_CORRECTION_ACCEPTANCE_RUBRIC_VERSION, MEMCORRECT_STALE_HARM_RUBRIC, MEMCORRECT_STALE_HARM_RUBRIC_VERSION, MEMORY_EVAL_DIMENSIONS, MEMORY_EVAL_PUBLIC_LINE, MIN_CALIBRATION_SOURCE_TASKS, MITIGATED_BASELINE_SCENARIOS, type McpArgumentSemantic, type McpBackendErrorCode, type McpBackendResult, type McpBenchMemoryAdapter, type McpConformanceResult, type McpHttpTransportConfig, type McpListedTool, type McpMemCorrectAdapter, type McpMemoryAdapterOptions, McpMemoryBackendError, type McpMemoryToolMapping, type McpMemoryTransportConfig, type McpStdioTransportConfig, type McpToolCallResult, type McpToolClient, type McpToolMappingEntry, type McpToolMappingValue, type McpToolOperation, type Mem0AdapterConfig, Mem0MemCorrectAdapter, type MemCorrectGeneratorOptions, type MemCorrectJudgeRequest, type MemCorrectJudgeResult, type MemCorrectSystemAdapter, type MemoryEvalCategory, type MemoryEvalDimension, type MemoryEvalDimensionId, type MemoryEvalMetric, type MemoryGraph, type MemoryStats, type MemorySystem, type Message, type MetricAggregate, type MicroMetric, MissingCredentialError, type MitigatedBaselineConfig, type MitigatedTargetConfig, type MultipleChoiceQuestion, OPENAI_RESPONSES_JUDGE_RUBRIC_VERSION, OTHER_NAMESPACE_MEMORIES, type OllamaProviderConfig, type OpenAiCompatibleProviderConfig, OpenAiResponsesJudgeError, type OpenAiResponsesJudgeErrorCode, type OpenAiResponsesJudgeTelemetry, OpenAiResponsesProvider, type OpenAiResponsesProviderConfig, type OpenAiResponsesVerdict, type OpenAiResponsesVerdictResult, PROCEDURAL_REAL_SCENARIOS, PROCEDURAL_REAL_SCENARIOS_SMOKE, PUBLISHED_BENCHMARK_ARTIFACT_IDS, type PersonalizationRetrievalCase, type PreflightDiscoveredModel, type ProceduralAblationArtifact, type ProceduralAblationPerCase, type ProceduralAblationScenario, type ProceduralRealScenario, type ProceduralRealScenarioCategory, type ProviderBaseConfig, type ProviderConfig, type ProviderDiscoveryResult, type ProviderFactoryConfig, type PublishSkipReason, type PublishSkipRecord, type PublishedBenchmarkFeed, type PublishedBenchmarkFeedEntry, type PublishedBenchmarkId, REQUIRED_FRONTMATTER_FIELDS, type RecallMetrics, type RecoveredMemory, type RegressionDetail, type RegressionGateResult$1 as RegressionGateResult, type RemnicAdapterOptions, type ReportCardProvenanceContext, type ResolveBenchRuntimeProfileOptions, type ResolvedBenchRuntimeProfile, type ResolvedLocalLabProfile, type ResolvedLocalLabRole, type ResolvedRunBenchmarkOptions, type RotatedChoices, type RunBenchmarkOptions, type RunJudgeCalibrationOptions, type RunProceduralAblationCliArgs, type RunProceduralAblationOptions, type RunSequentialPhasesOptions, SCHEMA_TIER_FIXTURE, SCHEMA_TIER_SMOKE_FIXTURE, SEALED_PROMPT_REGISTRY, SINGLE_FLAG_ABLATION_MATRIX, SYNTHETIC_MEMORIES, type SanitizedDiagnosticProvider, type SavedBaseline, type SchemaTierCorpus, type SchemaTierFixture, type SchemaTierName, type SchemaTierPage, type SchemaTierPageFrontmatter, type SealedArtifact, type SealedJudgeDecision, type SealedJudgeInput, type SealedQrelsArtifact, type SealedQrelsHandle, type SealedRubric, type SearchResult, type SeededMemory, type SeededRng, type SequentialPhaseHooks, type SingleFlagAblationCell, type SingleFlagAblationId, type SpotCheckLogger, type StatisticalReport, type StructuredJudge, StructuredJudgeError, type StructuredJudgeErrorCode, type StructuredJudgeProvider, type StructuredJudgeTelemetry, type StructuredJudgeVerdict, type StructuredJudgeVerdictResult, type StructuredVerdictRequest, type SyntheticEdge, type SyntheticEmailIngestionAdapterOptions, type SyntheticFileIR, type SyntheticRepoConfig, type SyntheticSymbol, type SyntheticTargetOptions, type TaskResult, type TaskTokenUsage, type TemporalRetrievalCase, type ThirdPartyAdapterConfig, type TierDetail, type TimelineEntry, type TokenUsage, type WallMetric, type WriteBenchmarkArtifactResult, type ZepAdapterConfig, ZepMemCorrectAdapter, addContaminationEntry, aggregateTaskScores, answerBenchmarkQuestion, assertCanaryUnderFloor, assertIntegrityMetaPresent, assertPublishableIntegrity, assertSha256Hex, assistantMeetingPrepDefinition, assistantMorningBriefDefinition, assistantNextBestActionDefinition, assistantSynthesisDefinition, backlinkF1, binarizeJudgeScore, bootstrapCohensKappaConfidenceInterval, bootstrapMeanConfidenceInterval, buildAmaBenchDiagnosticMatrixArtifact, buildAmaBenchDiagnosticVariantSummary, buildAmaBenchLeaderboardRows, buildBaselineFromReport, buildBenchmarkArtifact, buildBenchmarkArtifactFilename, buildBenchmarkPublishFeed, buildBenchmarkReproManifest, buildBenchmarkRunSeeds, buildCodexCreditReceipt, buildJudgePayload, buildOracleTrajectoryRecall, buildProviderFreeLoCoMoRetrievalConfig, buildSchemaTierFixture, buildSchemaTierSmokeFixture, calendarFixture, canonicalJsonStringify, captureLoCoMoRetrievalTrace, captureMachineFingerprint, chatFixture, checkCodingGraphRegression, checkDatasetContamination, checkRegression, clampScore, cohensD, compareResults, computeCohensKappa, computeSealHash, containsAnswer, createSeededRng$1 as createAdamSeededRng, createAmaBenchDiagnosticAdapter, createAnthropicProvider, createCanaryAdapter, createClaudeCliProvider, createCodexCliProvider, createSeededRng as createCodingGraphSeededRng, createDeterministicSpotCheckLogger, createGatewayResponder, createLightweightAdapter, createLiteLlmProvider, createLocalLlmProvider, createMcpDemoMemCorrectAdapter, createMcpDemoMemoryAdapter, createMcpMemCorrectAdapter, createMcpMemoryAdapter, createMitigatedTarget, createOllamaProvider, createOpenAiCompatibleProvider, createOpenAiResponsesBenchJudge, createOpenAiResponsesProvider, createSeededRandom as createProceduralAblationSeededRandom, createProvider, createProviderBackedAmaBenchRecommendedJudge, createProviderBackedJudge, createProviderBackedResponder, createProviderBackedStructuredJudge, createRemnicAdapter, createResponderFromProvider, createSeededRng$2 as createSeededRng, createSpotCheckFileLogger, createStructuredBenchJudge, createStructuredJudgeFromProvider, createSyntheticEmailIngestionAdapter, createSyntheticTarget, createTimeoutGuardedAdapter, defaultBenchmarkBaselineDir, defaultBenchmarkPublishPath, deleteBenchmarkResults, diagnoseLoCoMoRetrievalTraceDelta, diagnoseLoComoProfileDelta, diagnoseLoComoRecallDelta, discoverAllProviders, discoveryEndpointFor, emailFixture, entityRecall, exactMatch, extractMetrics as extractCodingGraphMetrics, extractMarkdownSectionsByTitle, f1Score, fixtureToAblationScenarios, formatHandoffNote, formatMissingDatasetError, generateReport, generateSyntheticRepo, getAblationCell, getBenchmark, getBenchmarkLowerIsBetter, getGitSha, getMemoryEvalDimension, getProviderBackedJudgePromptIdentity, getRemnicVersion, hashBenchmarkArtifact, hashBytes, hashCanonicalJson, hashOrderedQuestionIds, hashString, integrityMetaIsComplete, interpretEffectSize, isAmaBenchUnknownLikeAnswer, isContaminationEntry, isContaminationManifest, isSealedQrelsArtifact, isSha256Hex, isStructuredJudgeProvider, judgeMemCorrectCorrectionAcceptance, judgeMemCorrectStaleMemoryHarm, linkMatches, listBenchmarkBaselines, listBenchmarkResults, listBenchmarks, listMemoryEvalBenchmarkIds, listMemoryEvalDimensions, llmJudgeScore, llmJudgeScoreDetailed, loadAblationFixture, loadBaseline, loadBeamDatasetPreview, loadBenchmarkArtifact, loadBenchmarkBaseline, loadBenchmarkReportCardProvenance, loadBenchmarkResult, loadCustomBenchmarkFile, loadJudgeCalibrationState, loadLoCoMo10, loadLocalLabManifest, loadLongMemEvalS, loadSealKeyFromEnv, loadSealedQrels, loadSealedRubric, matchEntity, mergeContaminationManifests, openSeal, orchestrateBenchmarkRuns, pairedDeltaConfidenceInterval, parseBenchmarkArtifact, parseCustomBenchmark, parseLocalLabManifest, parseRubricResponse, parseSealedQrels, pickStableQualifiedName, precisionAtK, preflightLoCoMoRetrievalTraceCapture, preflightLocalLabRole, projectFolderFixture, recallAtK, reconcileCodexCreditLedger, redactBenchmarkResultSecrets, renderBaselineMarkdown, renderBenchmarkResultExport, renderLoComoProfileDeltaMarkdown, renderLoComoRecallDeltaMarkdown, renderMemorySummaryForJudge, renderMemoryViewForAgent, resolveAssistantAgent, resolveAssistantRubricId, resolveAssistantSeeds, resolveAssistantSpotCheckDir, resolveBenchRuntimeProfile, resolveBenchmarkPhaseTimeoutMs, resolveBenchmarkProgressLogging, resolveBenchmarkResultReference, resolveBenchmarkRunCount, resolveLocalLabJudgeProviderConfig, resolveLocalLabProfile, resolveLocalLabRole, resolveStructuredJudge, rotateDistractors, rougeL, runAssistantBenchmark, runAssistantMeetingPrepBenchmark, runAssistantMorningBriefBenchmark, runAssistantNextBestActionBenchmark, runAssistantSynthesisBenchmark, runBaseline, runBenchSuite, runBenchmark, runCodingGraphBenchmark, runCustomBenchmarkFile, runExplain, runExtractionAttack, runJudgeCalibration, runMitigatedBaseline, runProceduralAblation, runProceduralAblationCli, runSealedJudge, runSequentialPhases, safeHexEqual, sanitizeLoComoResultReference, saveBaseline, saveBenchmarkBaseline, schemaCompleteness, sealPayload, selectAmaBenchDiagnosticVariants, selectCalibrationSlice, selectFixtureVariant, serializeBenchmarkArtifact, serializeJsonl, serializeLoCoMoRetrievalTraceDelta, serializeLoCoMoRetrievalTraceReceipt, serializeSealedQrels, shuffleTasks, timed, verifyRubricDigest, writeBenchmarkArtifact, writeBenchmarkPublishFeed, writeBenchmarkReproManifest, writeBenchmarkResult, writeJudgeCalibrationState, writeLeaderboardArtifactsForResult, zeroScores };

package/dist/index.js

@@ -8998,8 +8998,8 @@ function parseRetryAfterMs(value) {
   if (Number.isNaN(asNumber2)) {
     const dateMs = Date.parse(value);
     if (Number.isFinite(dateMs)) {
-      const delta = dateMs - Date.now();
-      return delta > 0 ? Math.min(delta, MAX_RETRY_AFTER_S * 1e3) : 0;
+      const delta2 = dateMs - Date.now();
+      return delta2 > 0 ? Math.min(delta2, MAX_RETRY_AFTER_S * 1e3) : 0;
     }
   }
   return void 0;
@@ -16394,11 +16394,11 @@ function tokenize(value) {
   return normalizeText(value).replace(/[^\w\s]/g, " ").split(/\s+/).filter((token) => token.length > 0);
 }
 function frequencyMap(tokens) {
-  const counts = /* @__PURE__ */ new Map();
+  const counts2 = /* @__PURE__ */ new Map();
   for (const token of tokens) {
-    counts.set(token, (counts.get(token) ?? 0) + 1);
+    counts2.set(token, (counts2.get(token) ?? 0) + 1);
   }
-  return counts;
+  return counts2;
 }
 function longestCommonSubsequence(left, right) {
   let previous = new Array(right.length + 1).fill(0);
@@ -16806,11 +16806,11 @@ function buildAmaBenchRecallQueries(qaPairs) {
   });
 }
 function questionCounts(qaPairs) {
-  const counts = /* @__PURE__ */ new Map();
+  const counts2 = /* @__PURE__ */ new Map();
   for (const qa of qaPairs) {
-    counts.set(qa.question, (counts.get(qa.question) ?? 0) + 1);
+    counts2.set(qa.question, (counts2.get(qa.question) ?? 0) + 1);
   }
-  return counts;
+  return counts2;
 }
 function isInventoryHistoryQuestion(question) {
   const normalized = question.toLowerCase();
@@ -26454,11 +26454,11 @@ function officialF1(prediction, groundTruth) {
   return 2 * precision * recall / (precision + recall);
 }
 function countTokens(tokens) {
-  const counts = /* @__PURE__ */ new Map();
+  const counts2 = /* @__PURE__ */ new Map();
   for (const token of tokens) {
-    counts.set(token, (counts.get(token) ?? 0) + 1);
+    counts2.set(token, (counts2.get(token) ?? 0) + 1);
   }
-  return counts;
+  return counts2;
 }
 function extractRecommendationMovies(output, movieCandidates, aliasCounts) {
   let recommendationText = output;
@@ -26524,14 +26524,14 @@ function stripTrailingRecommendationPunctuation(value) {
   return value.replace(/^["'`]+/g, "").replace(/["'`.!?;:]+$/g, "").trim();
 }
 function countMovieAliases(movieCandidates) {
-  const counts = /* @__PURE__ */ new Map();
+  const counts2 = /* @__PURE__ */ new Map();
   for (const movie of movieCandidates) {
     for (const alias of movieAliases(movie)) {
       const normalizedAlias = alias.toLowerCase();
-      counts.set(normalizedAlias, (counts.get(normalizedAlias) ?? 0) + 1);
+      counts2.set(normalizedAlias, (counts2.get(normalizedAlias) ?? 0) + 1);
     }
   }
-  return counts;
+  return counts2;
 }
 function movieAliases(movie) {
   const aliases = [movie];
@@ -35611,10 +35611,10 @@ function uptakeLatency(log, corrections, cap) {
     let resolved = cap;
     let found = false;
     for (const entry of post) {
-      const delta = entry.turnIndex - correction.turnIndex;
-      if (delta > cap) break;
+      const delta2 = entry.turnIndex - correction.turnIndex;
+      if (delta2 > cap) break;
       if (probePassesForCorrection(entry, correction)) {
-        resolved = delta;
+        resolved = delta2;
         found = true;
         break;
       }
@@ -38458,11 +38458,11 @@ function compareResults(baseline, candidate, threshold = 0.05, lowerIsBetter = /
       candidate,
       metricName
     );
-    const delta = aggregate.mean - baselineAggregate.mean;
+    const delta2 = aggregate.mean - baselineAggregate.mean;
     const metricDelta = {
       baseline: baselineAggregate.mean,
       candidate: aggregate.mean,
-      delta,
+      delta: delta2,
       percentChange: percentChange(aggregate.mean, baselineAggregate.mean),
       effectSize: {
         cohensD: 0,
@@ -39283,6 +39283,803 @@ function formatSignedScore2(value) {
   return `${value >= 0 ? "+" : ""}${formatScore2(value)}`;
 }
 
+// src/stats/locomo-retrieval-trace-delta.ts
+var LOCOMO_RETRIEVAL_TRACE_DELTA_SCHEMA_VERSION = 1;
+var CATEGORIES = ["single_hop", "multi_hop", "temporal", "open_domain", "adversarial"];
+var MECHANISMS = [
+  "real-core-visible-lcm-displacement",
+  "lcm-selection-change",
+  "composition-filter-displacement",
+  "composition-digest-change",
+  "budget-truncation-change",
+  "mixed",
+  "no-structural-delta",
+  "insufficient-exact-lineage"
+];
+function diagnoseLoCoMoRetrievalTraceDelta(baseline, real) {
+  assertReceipt(baseline, "baseline");
+  assertReceipt(real, "real");
+  assertComparable(baseline, real);
+  const tasks = baseline.tasks.map(
+    (baselineTask, index) => compareTask(baselineTask, real.tasks[index])
+  );
+  const overall = summarize(tasks);
+  const categories = CATEGORIES.filter((category) => tasks.some((task) => task.category === category)).map(
+    (category) => ({ category, ...summarize(tasks.filter((task) => task.category === category)) })
+  );
+  const multiHop = tasks.filter((task) => task.category === "multi_hop");
+  const candidates = MECHANISMS.filter(
+    (mechanism) => mechanism !== "no-structural-delta" && mechanism !== "insufficient-exact-lineage"
+  ).map((mechanism) => ({ mechanism, count: multiHop.filter((task) => task.mechanism === mechanism).length }));
+  candidates.sort((left, right) => right.count - left.count || left.mechanism.localeCompare(right.mechanism));
+  const dominant = candidates[0];
+  const supported = dominant !== void 0 && dominant.count >= 2 && dominant.count * 2 > multiHop.length;
+  const withoutHash = {
+    schemaVersion: LOCOMO_RETRIEVAL_TRACE_DELTA_SCHEMA_VERSION,
+    benchmarkId: "locomo",
+    analysisKind: "paired-retrieval-structural-delta",
+    sensitivity: {
+      classification: "restricted",
+      contentEncoding: "sha256+length",
+      containsGold: false,
+      containsRawContent: false,
+      containsRawIdentifiers: false
+    },
+    comparison: {
+      baselineArtifactHash: baseline.artifactHash,
+      realArtifactHash: real.artifactHash,
+      retrievalConfigHashesDiffer: true,
+      taskOrderSha256: hashCanonicalJson(baseline.tasks.map((task) => digestIdentifier(task.taskId)))
+    },
+    overall,
+    categories,
+    dominantMultiHopMechanism: {
+      status: supported ? "supported" : "not-supported",
+      ...supported && dominant ? { mechanism: dominant.mechanism } : {},
+      count: dominant?.count ?? 0,
+      taskCount: multiHop.length,
+      rule: "strict-majority-and-at-least-two"
+    },
+    tasks,
+    evidenceBoundary: {
+      attribution: "observed-structural-mechanism-only",
+      causalClaim: false,
+      exactLineageRequired: true,
+      explanation: "Labels summarize paired, content-free structural differences. The budget-truncation label denotes a fixed-budget tail-geometry transition with a stable recorded composition outcome; it does not prove identical prefix content. No label proves that a retrieval mechanism caused an answer or score change."
+    }
+  };
+  return { ...withoutHash, artifactHash: hashCanonicalJson(withoutHash) };
+}
+function serializeLoCoMoRetrievalTraceDelta(report) {
+  return `${canonicalJsonStringify(report, 2)}
+`;
+}
+function compareTask(baseline, real) {
+  const category = categoryOf(baseline.taskId);
+  const dimensions = {
+    sectionVisibleChars: delta(signatures(baseline, "sectionVisibleChars"), signatures(real, "sectionVisibleChars")),
+    selections: delta(signatures(baseline, "selections"), signatures(real, "selections")),
+    archiveRows: delta(signatures(baseline, "archiveRows"), signatures(real, "archiveRows")),
+    lcmCandidates: delta(signatures(baseline, "lcmCandidates"), signatures(real, "lcmCandidates")),
+    coreResults: delta(signatures(baseline, "coreResults"), signatures(real, "coreResults")),
+    coreFilters: delta(signatures(baseline, "coreFilters"), signatures(real, "coreFilters")),
+    coreBudget: delta(signatures(baseline, "coreBudget"), signatures(real, "coreBudget")),
+    recallBudget: delta(signatures(baseline, "recallBudget"), signatures(real, "recallBudget")),
+    compositionPolicy: delta(signatures(baseline, "compositionPolicy"), signatures(real, "compositionPolicy")),
+    compositionDigests: delta(signatures(baseline, "compositionDigests"), signatures(real, "compositionDigests"))
+  };
+  const hasCompleteExactLineage = (task) => {
+    return task.sessions.every((session) => {
+      const renderedSections = session.trace.sections.filter(
+        (section) => section.source === "lcm-summary" || section.source === "raw-row"
+      );
+      const lcmSelections = session.trace.selections.filter(
+        (selection) => selection.kind === "lcm-summary" || selection.kind === "raw-row"
+      );
+      const selectionMatchesSection = (selection) => renderedSections.some((section) => section.id === selection.sectionId && section.source === selection.kind);
+      const renderedLineageComplete = renderedSections.every(
+        (section) => lcmSelections.some(
+          (selection) => selection.sectionId === section.id && selection.kind === section.source && hasExactSelectionLineage(selection)
+        )
+      );
+      const candidateLineageComplete = session.trace.lcmCandidates.every(hasExactCandidateLineage);
+      const hasCarrier = renderedSections.length > 0 && renderedLineageComplete || renderedSections.length === 0 && lcmSelections.length === 0 && session.trace.lcmCandidates.length > 0 && candidateLineageComplete;
+      const hasLcmEvidence = renderedSections.length > 0 || lcmSelections.length > 0 || session.trace.lcmCandidates.length > 0;
+      return (!hasLcmEvidence || hasCarrier) && lcmSelections.every(selectionMatchesSection) && lcmSelections.every(hasExactSelectionLineage) && (renderedSections.length > 0 || candidateLineageComplete) && (session.trace.coreCapture?.results.every(
+        (result) => isSha256Hex(result.memoryIdRef.sha256) && result.memoryIdRef.length > 0
+      ) ?? true);
+    });
+  };
+  const exact = hasCompleteExactLineage(baseline) && hasCompleteExactLineage(real);
+  const lcmSelectionsChanged = delta(
+    exactSelectionSignatures(baseline, "lcm", "emitted"),
+    exactSelectionSignatures(real, "lcm", "emitted")
+  ).changed;
+  const lcmArchiveRowsChanged = delta(
+    exactArchiveRowSignatures(baseline, "lcm"),
+    exactArchiveRowSignatures(real, "lcm")
+  ).changed;
+  const auxiliarySelectionsChanged = delta(
+    exactSelectionSignatures(baseline, "auxiliary", "emitted"),
+    exactSelectionSignatures(real, "auxiliary", "emitted")
+  ).changed;
+  const auxiliaryArchiveRowsChanged = delta(
+    exactArchiveRowSignatures(baseline, "auxiliary"),
+    exactArchiveRowSignatures(real, "auxiliary")
+  ).changed;
+  const core = dimensions.coreResults.changed || dimensions.coreFilters.changed || dimensions.coreBudget.changed;
+  const baselineVisible = visibleCharsByGroup(baseline);
+  const realVisible = visibleCharsByGroup(real);
+  const coreSections = sectionGroupChanged(baseline, real, "core", "emitted");
+  const lcmSections = sectionGroupChanged(baseline, real, "lcm", "emitted");
+  const otherSections = sectionGroupChanged(baseline, real, "other", "emitted");
+  const lcm = lcmSections || lcmSelectionsChanged || lcmArchiveRowsChanged || dimensions.lcmCandidates.changed;
+  const auxiliary = auxiliarySelectionsChanged || auxiliaryArchiveRowsChanged;
+  const other = otherSections || auxiliary;
+  const composedSelectionsChanged = delta(
+    structuralSelectionSignatures(baseline, "all", "composed", false),
+    structuralSelectionSignatures(real, "all", "composed", false)
+  ).changed;
+  const allCandidatesChanged = delta(candidateSignatures(baseline, false), candidateSignatures(real, false)).changed;
+  const compositionPolicy = dimensions.compositionPolicy.changed;
+  const compositionDigests = dimensions.compositionDigests.changed;
+  const compositionOutcomeChanged = compositionOutcomeSignature(baseline) !== compositionOutcomeSignature(real);
+  const budget = dimensions.recallBudget.changed;
+  const coreVisibleLcmDisplacement = core && lcm && realVisible.core > baselineVisible.core && realVisible.lcm < baselineVisible.lcm && !other && !budget && !compositionPolicy;
+  const budgetTailGeometryTransition = budget && hasFixedBudgetTailGeometryTransition(baseline, real) && !core && !composedSelectionsChanged && !allCandidatesChanged && !compositionPolicy && !compositionOutcomeChanged;
+  let mechanism;
+  if (!exact) mechanism = "insufficient-exact-lineage";
+  else if (coreVisibleLcmDisplacement) mechanism = "real-core-visible-lcm-displacement";
+  else if (lcm && !core && !coreSections && !other && !budget && !compositionPolicy)
+    mechanism = "lcm-selection-change";
+  else if (budgetTailGeometryTransition) mechanism = "budget-truncation-change";
+  else if (compositionPolicy && !core && !coreSections && !lcm && !other && !budget)
+    mechanism = "composition-filter-displacement";
+  else if (compositionDigests && !compositionPolicy && !core && !coreSections && !lcm && !other && !budget)
+    mechanism = "composition-digest-change";
+  else if (!core && !coreSections && !lcm && !other && !budget && !compositionPolicy && !compositionDigests)
+    mechanism = "no-structural-delta";
+  else mechanism = "mixed";
+  return { taskRef: digestIdentifier(baseline.taskId), category, mechanism, dimensions };
+}
+function visibleCharsByGroup(task) {
+  const output = { core: 0, lcm: 0, other: 0 };
+  for (const session of task.sessions) {
+    for (const section of session.trace.sections) {
+      if (section.source === "core") {
+        output.core += section.visibleChars;
+      } else if (section.source === "lcm-summary" || section.source === "raw-row") {
+        output.lcm += section.visibleChars;
+      } else {
+        output.other += section.visibleChars;
+      }
+    }
+  }
+  return output;
+}
+function sectionGroupChanged(baseline, real, group, projection) {
+  const signaturesFor = (task) => {
+    const output = [];
+    task.sessions.forEach((session, sessionOrdinal) => {
+      session.trace.sections.forEach((section, sectionOrdinal) => {
+        if (sectionGroup(section.source) === group) {
+          output.push(structuralSectionSignature(section, sessionOrdinal, sectionOrdinal, projection));
+        }
+      });
+    });
+    return output;
+  };
+  return delta(signaturesFor(baseline), signaturesFor(real)).changed;
+}
+function sectionGroup(source) {
+  if (source === "core") return "core";
+  if (source === "lcm-summary" || source === "raw-row") return "lcm";
+  return "other";
+}
+function structuralSectionSignature(section, sessionOrdinal, sectionOrdinal, projection) {
+  return hashCanonicalJson({
+    sessionOrdinal,
+    sectionOrdinal,
+    sectionIdRef: digestIdentifier(section.id),
+    source: section.source,
+    separatorStart: section.separatorStart,
+    contentStart: section.contentStart,
+    contentEnd: section.contentEnd,
+    composedStart: section.composedStart,
+    composedEnd: section.composedEnd,
+    ...projection === "emitted" ? {
+      visibleStart: section.visibleStart,
+      visibleEnd: section.visibleEnd,
+      visibleChars: section.visibleChars
+    } : {}
+  });
+}
+function selectionInScope(selection, scope) {
+  const isLcm = selection.kind === "lcm-summary" || selection.kind === "raw-row";
+  return scope === "all" || (scope === "lcm" ? isLcm : !isLcm);
+}
+function exactSelectionSignatures(task, scope, projection) {
+  return structuralSelectionSignatures(task, scope, projection, true);
+}
+function structuralSelectionSignatures(task, scope, projection, exactOnly) {
+  const output = [];
+  task.sessions.forEach((session, sessionOrdinal) => {
+    for (const value of session.trace.selections) {
+      if (!selectionInScope(value, scope) || exactOnly && !hasExactSelectionLineage(value)) continue;
+      output.push(
+        hashCanonicalJson({
+          sessionOrdinal,
+          sectionIdRef: digestIdentifier(value.sectionId),
+          kind: value.kind,
+          lineageStatus: value.lineageStatus,
+          turnIndex: value.turnIndex,
+          role: value.role,
+          score: value.score,
+          summary: value.summary,
+          archiveRowIds: value.archiveRowIds,
+          composedStart: value.composedStart,
+          composedEnd: value.composedEnd,
+          ...projection === "emitted" ? {
+            visibleStart: value.visibleStart,
+            visibleEnd: value.visibleEnd
+          } : {}
+        })
+      );
+    }
+  });
+  return output;
+}
+function exactArchiveRowSignatures(task, scope) {
+  const output = [];
+  task.sessions.forEach((session, sessionOrdinal) => {
+    for (const value of session.trace.selections) {
+      if (!selectionInScope(value, scope) || !hasExactSelectionLineage(value)) continue;
+      for (const archiveRowId of value.archiveRowIds ?? []) {
+        output.push(hashCanonicalJson({ sessionOrdinal, archiveRowId }));
+      }
+    }
+  });
+  return output;
+}
+function hasExactSelectionLineage(selection) {
+  if (selection.lineageStatus !== "exact") return false;
+  if (selection.kind === "lcm-summary") {
+    return selection.summary !== void 0 && Number.isSafeInteger(selection.summary.depth) && selection.summary.depth >= 0 && Number.isSafeInteger(selection.summary.msgStart) && selection.summary.msgStart >= 0 && Number.isSafeInteger(selection.summary.msgEnd) && selection.summary.msgEnd >= selection.summary.msgStart;
+  }
+  return Array.isArray(selection.archiveRowIds) && selection.archiveRowIds.length > 0 && selection.archiveRowIds.every((id) => Number.isSafeInteger(id) && id > 0);
+}
+function hasExactCandidateLineage(candidate) {
+  return candidate.lineageStatus === "exact" && Number.isSafeInteger(candidate.archiveRowId) && candidate.archiveRowId > 0;
+}
+function candidateSignatures(task, exactOnly) {
+  const output = [];
+  task.sessions.forEach((session, sessionOrdinal) => {
+    for (const value of session.trace.lcmCandidates) {
+      if (exactOnly && !hasExactCandidateLineage(value)) continue;
+      output.push(
+        hashCanonicalJson({
+          sessionOrdinal,
+          rank: value.rank,
+          archiveRowId: value.archiveRowId,
+          turnIndex: value.turnIndex,
+          role: value.role,
+          score: value.score,
+          lineageStatus: value.lineageStatus
+        })
+      );
+    }
+  });
+  return output;
+}
+function signatures(task, dimension) {
+  if (dimension === "selections") return exactSelectionSignatures(task, "all", "emitted");
+  if (dimension === "archiveRows") return exactArchiveRowSignatures(task, "all");
+  if (dimension === "lcmCandidates") return candidateSignatures(task, true);
+  if (dimension === "recallBudget") {
+    return [
+      hashCanonicalJson({
+        recallBudgetChars: task.recallBudgetChars,
+        budgets: task.sessions.map((session) => ({
+          requestedChars: session.trace.budget.requestedChars,
+          truncated: session.trace.budget.truncated
+        }))
+      })
+    ];
+  }
+  if (dimension === "compositionPolicy") {
+    return [
+      hashCanonicalJson({
+        mode: task.composition.mode,
+        multiHopRecallComposition: task.composition.multiHopRecallComposition,
+        selectedLines: task.composition.selectedLines.map((line) => ({
+          inputOrdinal: line.inputOrdinal,
+          stage: line.stage,
+          hop: line.hop,
+          visible: line.visible,
+          outputStart: line.outputStart,
+          outputEnd: line.outputEnd,
+          visibleStart: line.visibleStart,
+          visibleEnd: line.visibleEnd
+        }))
+      })
+    ];
+  }
+  if (dimension === "compositionDigests") {
+    return [
+      hashCanonicalJson({
+        input: task.composition.input,
+        output: task.composition.output,
+        selectedLines: task.composition.selectedLines.map((line) => ({ input: line.input, output: line.output }))
+      })
+    ];
+  }
+  const output = [];
+  task.sessions.forEach((session, sessionOrdinal) => {
+    const trace2 = session.trace;
+    if (dimension === "sectionVisibleChars") {
+      trace2.sections.forEach((value, sectionOrdinal) => {
+        output.push(structuralSectionSignature(value, sessionOrdinal, sectionOrdinal, "emitted"));
+      });
+    } else if (dimension === "coreResults") {
+      for (const [resultOrdinal, value] of (trace2.coreCapture?.results ?? []).entries())
+        output.push(
+          hashCanonicalJson({
+            sessionOrdinal,
+            resultOrdinal,
+            memoryIdRef: value.memoryIdRef,
+            servedBy: value.servedBy,
+            scoreDecomposition: value.scoreDecomposition,
+            admittedBy: value.admittedBy,
+            rejectedBy: value.rejectedBy,
+            disclosure: value.disclosure,
+            estimatedTokens: value.estimatedTokens
+          })
+        );
+    } else if (dimension === "coreFilters") {
+      for (const value of trace2.coreCapture?.filters ?? [])
+        output.push(
+          hashCanonicalJson({
+            sessionOrdinal,
+            name: value.name,
+            considered: value.considered,
+            admitted: value.admitted
+          })
+        );
+    } else if (dimension === "coreBudget") {
+      if (trace2.coreCapture) output.push(hashCanonicalJson({ sessionOrdinal, ...trace2.coreCapture.budget }));
+    }
+  });
+  return output;
+}
+function compositionOutcomeSignature(task) {
+  return hashCanonicalJson({
+    output: task.composition.output,
+    selectedLines: task.composition.selectedLines.map((line) => ({ input: line.input, output: line.output }))
+  });
+}
+function hasFixedBudgetTailGeometryTransition(baseline, real) {
+  let sawTransition = false;
+  for (let index = 0; index < baseline.sessions.length; index += 1) {
+    const baselineSession = baseline.sessions[index];
+    const realSession = real.sessions[index];
+    const baselineTrace = baselineSession?.trace;
+    const realTrace = realSession?.trace;
+    if (!baselineSession || !realSession || !baselineTrace || !realTrace || baselineTrace.budget.requestedChars !== realTrace.budget.requestedChars) {
+      return false;
+    }
+    if (baselineTrace.budget.truncated === realTrace.budget.truncated) {
+      if (baselineTrace.budget.composedChars !== realTrace.budget.composedChars || baselineTrace.budget.returnedChars !== realTrace.budget.returnedChars || sectionGroupChanged(
+        { ...baseline, sessions: [baselineSession] },
+        { ...real, sessions: [realSession] },
+        "core",
+        "composed"
+      ) || sectionGroupChanged(
+        { ...baseline, sessions: [baselineSession] },
+        { ...real, sessions: [realSession] },
+        "lcm",
+        "composed"
+      ) || sectionGroupChanged(
+        { ...baseline, sessions: [baselineSession] },
+        { ...real, sessions: [realSession] },
+        "other",
+        "composed"
+      )) {
+        return false;
+      }
+      continue;
+    }
+    const shorter = baselineTrace.budget.truncated ? realTrace : baselineTrace;
+    const longer = baselineTrace.budget.truncated ? baselineTrace : realTrace;
+    const requested = shorter.budget.requestedChars;
+    if (shorter.budget.truncated || !longer.budget.truncated || shorter.budget.composedChars > requested || longer.budget.composedChars <= requested || shorter.budget.returnedChars !== shorter.budget.composedChars || longer.budget.returnedChars !== requested || shorter.sections.length === 0 || shorter.sections.length !== longer.sections.length) {
+      return false;
+    }
+    const finalIndex = shorter.sections.length - 1;
+    for (let sectionIndex = 0; sectionIndex < finalIndex; sectionIndex += 1) {
+      const shortSection = shorter.sections[sectionIndex];
+      const longSection = longer.sections[sectionIndex];
+      if (!shortSection || !longSection) return false;
+      if (structuralSectionSignature(shortSection, 0, sectionIndex, "composed") !== structuralSectionSignature(longSection, 0, sectionIndex, "composed")) {
+        return false;
+      }
+    }
+    const shortFinal = shorter.sections[finalIndex];
+    const longFinal = longer.sections[finalIndex];
+    if (!shortFinal || !longFinal) return false;
+    const extension = longFinal.composedEnd - shortFinal.composedEnd;
+    if (shortFinal.id !== longFinal.id || shortFinal.source !== longFinal.source || shortFinal.separatorStart !== longFinal.separatorStart || shortFinal.contentStart !== longFinal.contentStart || shortFinal.composedStart !== longFinal.composedStart || shortFinal.contentEnd !== shortFinal.composedEnd || longFinal.contentEnd !== longFinal.composedEnd || shortFinal.composedEnd !== shorter.budget.composedChars || longFinal.composedEnd !== longer.budget.composedChars || extension <= 0 || longFinal.contentEnd - shortFinal.contentEnd !== extension) {
+      return false;
+    }
+    sawTransition = true;
+  }
+  return sawTransition;
+}
+function delta(baseline, real) {
+  const realCounts = counts(real);
+  let sharedCount = 0;
+  for (const entry of baseline) {
+    const available = realCounts.get(entry) ?? 0;
+    if (available > 0) {
+      sharedCount += 1;
+      realCounts.set(entry, available - 1);
+    }
+  }
+  return {
+    baselineCount: baseline.length,
+    realCount: real.length,
+    sharedCount,
+    baselineOnlyCount: baseline.length - sharedCount,
+    realOnlyCount: real.length - sharedCount,
+    changed: sharedCount !== baseline.length || sharedCount !== real.length
+  };
+}
+function counts(values) {
+  const output = /* @__PURE__ */ new Map();
+  for (const value of values) output.set(value, (output.get(value) ?? 0) + 1);
+  return output;
+}
+function summarize(tasks) {
+  const mechanisms = Object.fromEntries(MECHANISMS.map((mechanism) => [mechanism, 0]));
+  for (const task of tasks) mechanisms[task.mechanism] += 1;
+  return { taskCount: tasks.length, mechanisms };
+}
+function digestIdentifier(value) {
+  return { sha256: hashString(value), length: value.length };
+}
+function categoryOf(taskId) {
+  const category = CATEGORIES.find((candidate) => taskId.endsWith(`-${candidate}`));
+  if (!category) throw new Error("LoCoMo retrieval trace task id has an unsupported category.");
+  return category;
+}
+function assertReceipt(receipt, label) {
+  if (!receipt || typeof receipt !== "object") throw new Error(`${label} receipt must be an object.`);
+  assertFiniteJson(receipt, `${label} receipt`);
+  assertExactKeys(
+    receipt,
+    ["schemaVersion", "benchmarkId", "captureKind", "artifactHash", "sensitivity", "provenance", "selection", "tasks"],
+    `${label} receipt`
+  );
+  assertExactKeys(
+    receipt.sensitivity,
+    ["classification", "contentEncoding", "containsGold", "containsRawContent"],
+    `${label} receipt.sensitivity`
+  );
+  assertExactKeys(
+    receipt.provenance,
+    [
+      "gitSha",
+      "remnicVersion",
+      "runtimeProfile",
+      "adapterMode",
+      "replayExtractionMode",
+      "providerFree",
+      "dataset",
+      "retrievalConfigSha256",
+      "recallBudget"
+    ],
+    `${label} receipt.provenance`
+  );
+  assertExactKeys(receipt.provenance.dataset, ["id", "sha256"], `${label} receipt.provenance.dataset`);
+  assertExactKeys(
+    receipt.provenance.recallBudget,
+    ["algorithm", "version"],
+    `${label} receipt.provenance.recallBudget`
+  );
+  assertExactKeys(
+    receipt.selection,
+    ["algorithm", "version", "seed", "candidateCount", "selectedCount", "selectedTaskIds", "selectedTaskIdsSha256"],
+    `${label} receipt.selection`
+  );
+  const { artifactHash, ...withoutHash } = receipt;
+  if (!isSha256Hex(artifactHash) || hashCanonicalJson(withoutHash) !== artifactHash) {
+    throw new Error(`${label} retrieval trace artifact hash verification failed.`);
+  }
+  if (receipt.schemaVersion !== 1 || receipt.benchmarkId !== "locomo" || receipt.captureKind !== "retrieval-only" || receipt.sensitivity.classification !== "restricted" || receipt.sensitivity.contentEncoding !== "sha256+length" || receipt.sensitivity.containsGold !== false || receipt.sensitivity.containsRawContent !== false || receipt.provenance.providerFree !== true || receipt.provenance.adapterMode !== "direct" || receipt.provenance.replayExtractionMode !== "skip" || receipt.provenance.dataset.id !== "locomo-10" || receipt.provenance.recallBudget.algorithm !== "benchmarkRecallBudgetForSessionCount" || receipt.provenance.recallBudget.version !== 1 || typeof receipt.provenance.gitSha !== "string" || receipt.provenance.gitSha.length === 0 || typeof receipt.provenance.remnicVersion !== "string" || receipt.provenance.remnicVersion.length === 0 || receipt.selection.version !== 1 || receipt.selection.algorithm !== "explicit-task-ids" && receipt.selection.algorithm !== "sha256-seeded-sample" || receipt.selection.algorithm === "explicit-task-ids" && receipt.selection.seed !== void 0 || receipt.selection.algorithm === "sha256-seeded-sample" && !isNonNegativeSafeInteger(receipt.selection.seed) || !Array.isArray(receipt.selection.selectedTaskIds) || receipt.selection.selectedTaskIds.some((taskId) => typeof taskId !== "string" || taskId.length === 0) || !Array.isArray(receipt.tasks) || !Number.isSafeInteger(receipt.selection.candidateCount) || !Number.isSafeInteger(receipt.selection.selectedCount) || receipt.selection.selectedCount <= 0 || receipt.selection.candidateCount < receipt.selection.selectedCount || receipt.selection.selectedCount !== receipt.tasks.length || receipt.selection.selectedTaskIds.length !== receipt.tasks.length || new Set(receipt.selection.selectedTaskIds).size !== receipt.selection.selectedTaskIds.length || new Set(receipt.tasks.map((task) => task.taskId)).size !== receipt.tasks.length || receipt.selection.selectedTaskIdsSha256 !== hashCanonicalJson(receipt.selection.selectedTaskIds) || receipt.selection.selectedTaskIds.some((taskId, index) => taskId !== receipt.tasks[index]?.taskId) || receipt.tasks.length === 0) {
+    throw new Error(`${label} retrieval trace receipt violates the restricted provider-free contract.`);
+  }
+  if (!isSha256Hex(receipt.provenance.dataset.sha256) || !isSha256Hex(receipt.provenance.retrievalConfigSha256)) {
+    throw new Error(`${label} retrieval trace receipt contains invalid provenance hashes.`);
+  }
+  for (const task of receipt.tasks) {
+    assertExactKeys(
+      task,
+      ["taskId", "question", "recallBudgetChars", "sessions", "composition"],
+      `${label} retrieval trace task`
+    );
+    if (typeof task.taskId !== "string" || task.taskId.length === 0 || !Array.isArray(task.sessions) || task.sessions.length === 0 || !isDigest(task.question) || !Number.isSafeInteger(task.recallBudgetChars) || task.recallBudgetChars < 0) {
+      throw new Error(`${label} retrieval trace task structure is invalid.`);
+    }
+    categoryOf(task.taskId);
+    assertComposition(task.composition, label);
+    for (const session of task.sessions) {
+      assertExactKeys(session, ["session", "trace"], `${label} retrieval trace session`);
+      const trace2 = session.trace;
+      const expectedComposedChars = Array.isArray(trace2.sections) ? trace2.sections.reduce((maximum, section) => Math.max(maximum, section.composedEnd), 0) : -1;
+      assertExactKeys(
+        trace2,
+        ["schemaVersion", "sensitivity", "sections", "selections", "lcmCandidates", "coreCapture", "budget"],
+        `${label} retrieval structural trace`
+      );
+      assertExactKeys(
+        trace2.sensitivity,
+        ["classification", "contentEncoding", "containsGold"],
+        `${label} retrieval trace sensitivity`
+      );
+      assertExactKeys(
+        trace2.budget,
+        ["requestedChars", "composedChars", "returnedChars", "truncated"],
+        `${label} retrieval trace budget`
+      );
+      if (!isDigest(session.session) || !trace2 || trace2.schemaVersion !== 1 || trace2.sensitivity.classification !== "restricted" || trace2.sensitivity.contentEncoding !== "sha256+length" || trace2.sensitivity.containsGold !== false || !Array.isArray(trace2.sections) || !Array.isArray(trace2.selections) || !Array.isArray(trace2.lcmCandidates) || new Set(trace2.sections.map((section) => section.id)).size !== trace2.sections.length || !isTraceBudget(trace2.budget) || trace2.budget.requestedChars !== task.recallBudgetChars || trace2.budget.composedChars !== expectedComposedChars || trace2.budget.returnedChars !== Math.min(trace2.budget.requestedChars, trace2.budget.composedChars) || trace2.budget.returnedChars > trace2.budget.composedChars || trace2.budget.truncated !== trace2.budget.returnedChars < trace2.budget.composedChars) {
+        throw new Error(`${label} retrieval trace session structure is invalid.`);
+      }
+      let previousContentEnd = 0;
+      for (const [sectionIndex, section] of trace2.sections.entries()) {
+        assertExactKeys(
+          section,
+          [
+            "id",
+            "source",
+            "separatorStart",
+            "contentStart",
+            "contentEnd",
+            "composedStart",
+            "composedEnd",
+            "visibleStart",
+            "visibleEnd",
+            "visibleChars"
+          ],
+          `${label} retrieval trace section`
+        );
+        const expectedVisibleStart = Math.min(section.composedStart, trace2.budget.returnedChars);
+        const expectedVisibleEnd = Math.max(
+          expectedVisibleStart,
+          Math.min(section.composedEnd, trace2.budget.returnedChars)
+        );
+        const expectedSeparatorStart = sectionIndex === 0 ? 0 : previousContentEnd;
+        const expectedContentStart = expectedSeparatorStart + (sectionIndex === 0 ? 0 : 2);
+        if (![
+          "derived",
+          "explicit-cue",
+          "trajectory-analysis",
+          "core",
+          "evidence-pack",
+          "lcm-summary",
+          "raw-row"
+        ].includes(section.source) || typeof section.id !== "string" || section.id.length === 0 || !isTraceRange(section) || ![section.separatorStart, section.contentStart, section.contentEnd].every(isNonNegativeSafeInteger) || section.separatorStart !== expectedSeparatorStart || section.contentStart !== expectedContentStart || section.contentEnd < section.contentStart || section.composedStart !== section.separatorStart || section.composedEnd !== section.contentEnd || !Number.isSafeInteger(section.visibleChars) || section.visibleChars < 0 || section.visibleStart !== expectedVisibleStart || section.visibleEnd !== expectedVisibleEnd || section.visibleChars !== expectedVisibleEnd - expectedVisibleStart) {
+          throw new Error(`${label} retrieval trace section structure is invalid.`);
+        }
+        previousContentEnd = section.contentEnd;
+      }
+      for (const selection of trace2.selections) {
+        assertExactKeys(
+          selection,
+          [
+            "sectionId",
+            "kind",
+            "lineageStatus",
+            "archiveRowIds",
+            "turnIndex",
+            "role",
+            "score",
+            "summary",
+            "composedStart",
+            "composedEnd",
+            "visibleStart",
+            "visibleEnd"
+          ],
+          `${label} retrieval trace selection`
+        );
+        if (selection.summary !== void 0) {
+          assertExactKeys(
+            selection.summary,
+            ["depth", "msgStart", "msgEnd"],
+            `${label} retrieval trace selection summary`
+          );
+        }
+        const selectedSection = trace2.sections.find((section) => section.id === selection.sectionId);
+        const expectedVisibleStart = Math.min(selection.composedStart, trace2.budget.returnedChars);
+        const expectedVisibleEnd = Math.max(
+          expectedVisibleStart,
+          Math.min(selection.composedEnd, trace2.budget.returnedChars)
+        );
+        if (!["evidence-block", "trajectory-line", "lcm-summary", "raw-row"].includes(selection.kind) || typeof selection.sectionId !== "string" || selection.sectionId.length === 0 || selectedSection === void 0 || selection.kind === "lcm-summary" && selectedSection.source !== "lcm-summary" || selection.kind === "raw-row" && selectedSection.source !== "raw-row" || selection.kind === "evidence-block" && selectedSection.source !== "explicit-cue" && selectedSection.source !== "evidence-pack" || selection.kind === "trajectory-line" && selectedSection.source !== "trajectory-analysis" || !isTraceRange(selection) || selection.composedStart < selectedSection.contentStart || selection.composedEnd > selectedSection.contentEnd || selection.visibleStart !== expectedVisibleStart || selection.visibleEnd !== expectedVisibleEnd || selection.lineageStatus !== "exact" && selection.lineageStatus !== "unavailable" || selection.turnIndex !== void 0 && !isNonNegativeSafeInteger(selection.turnIndex) || selection.role !== void 0 && typeof selection.role !== "string" || selection.score !== void 0 && !Number.isFinite(selection.score) || selection.summary !== void 0 && ![selection.summary.depth, selection.summary.msgStart, selection.summary.msgEnd].every(
+          isNonNegativeSafeInteger
+        ) || selection.archiveRowIds !== void 0 && (!Array.isArray(selection.archiveRowIds) || selection.archiveRowIds.some((id) => !Number.isSafeInteger(id) || id <= 0))) {
+          throw new Error(`${label} retrieval trace selection structure is invalid.`);
+        }
+      }
+      for (const candidate of trace2.lcmCandidates) {
+        assertExactKeys(
+          candidate,
+          ["rank", "archiveRowId", "turnIndex", "role", "score", "lineageStatus"],
+          `${label} retrieval trace LCM candidate`
+        );
+        if (candidate.lineageStatus !== "exact" && candidate.lineageStatus !== "unavailable" || !Number.isSafeInteger(candidate.rank) || candidate.rank < 0 || !isNonNegativeSafeInteger(candidate.turnIndex) || typeof candidate.role !== "string" || candidate.score !== void 0 && !Number.isFinite(candidate.score) || candidate.lineageStatus === "exact" && candidate.archiveRowId === void 0 || candidate.lineageStatus === "unavailable" && candidate.archiveRowId !== void 0 || candidate.archiveRowId !== void 0 && (!Number.isSafeInteger(candidate.archiveRowId) || candidate.archiveRowId <= 0)) {
+          throw new Error(`${label} retrieval trace LCM candidate structure is invalid.`);
+        }
+      }
+      if (trace2.coreCapture) {
+        assertExactKeys(trace2.coreCapture, ["budget", "filters", "results"], `${label} retrieval trace core capture`);
+        assertExactKeys(trace2.coreCapture.budget, ["chars", "used"], `${label} retrieval trace core budget`);
+        for (const filter of trace2.coreCapture.filters) {
+          assertExactKeys(filter, ["name", "considered", "admitted"], `${label} retrieval trace core filter`);
+          if (typeof filter.name !== "string" || !isNonNegativeSafeInteger(filter.considered) || !isNonNegativeSafeInteger(filter.admitted) || filter.admitted > filter.considered) {
+            throw new Error(`${label} retrieval trace core filter structure is invalid.`);
+          }
+        }
+        for (const result of trace2.coreCapture.results) {
+          assertExactKeys(
+            result,
+            [
+              "memoryIdRef",
+              "servedBy",
+              "scoreDecomposition",
+              "admittedBy",
+              "rejectedBy",
+              "disclosure",
+              "estimatedTokens"
+            ],
+            `${label} retrieval trace core result`
+          );
+          assertExactKeys(result.memoryIdRef, ["sha256", "length"], `${label} retrieval trace core memory reference`);
+          assertExactKeys(
+            result.scoreDecomposition,
+            ["vector", "bm25", "importance", "mmrPenalty", "tierPrior", "reinforcementBoost", "final"],
+            `${label} retrieval trace score decomposition`
+          );
+          if (typeof result.servedBy !== "string" || !Number.isFinite(result.scoreDecomposition.final) || !Object.values(result.scoreDecomposition).every((score) => score === void 0 || Number.isFinite(score)) || !Array.isArray(result.admittedBy) || result.admittedBy.some((reason) => typeof reason !== "string") || result.rejectedBy !== void 0 && typeof result.rejectedBy !== "string" || result.disclosure !== void 0 && !["chunk", "section", "raw"].includes(result.disclosure) || result.estimatedTokens !== void 0 && !isNonNegativeSafeInteger(result.estimatedTokens)) {
+            throw new Error(`${label} retrieval trace core result structure is invalid.`);
+          }
+        }
+        if (!isCountBudget(trace2.coreCapture.budget) || !Array.isArray(trace2.coreCapture.filters) || !Array.isArray(trace2.coreCapture.results) || trace2.coreCapture.results.some(
+          (result) => !isSha256Hex(result.memoryIdRef?.sha256) || !Number.isSafeInteger(result.memoryIdRef?.length) || result.memoryIdRef.length <= 0
+        )) {
+          throw new Error(`${label} retrieval trace core capture structure is invalid.`);
+        }
+      }
+    }
+  }
+}
+function assertComposition(composition, label) {
+  assertExactKeys(
+    composition,
+    ["schemaVersion", "mode", "multiHopRecallComposition", "input", "output", "selectedLines"],
+    `${label} retrieval trace composition`
+  );
+  if (!composition || composition.schemaVersion !== 1 || composition.mode !== "focused" && composition.mode !== "fallback" || typeof composition.multiHopRecallComposition !== "boolean" || !isDigest(composition.input) || !isDigest(composition.output) || !Array.isArray(composition.selectedLines)) {
+    throw new Error(`${label} retrieval trace composition structure is invalid.`);
+  }
+  let previousOutputEnd = -1;
+  for (const line of composition.selectedLines) {
+    assertExactKeys(
+      line,
+      [
+        "inputOrdinal",
+        "input",
+        "output",
+        "stage",
+        "hop",
+        "visible",
+        "outputStart",
+        "outputEnd",
+        "visibleStart",
+        "visibleEnd"
+      ],
+      `${label} retrieval trace composition line`
+    );
+    if (!isNonNegativeSafeInteger(line.inputOrdinal) || !isDigest(line.input) || !isDigest(line.output) || line.stage !== "direct" && line.stage !== "linked" || line.hop !== void 0 && !isNonNegativeSafeInteger(line.hop) || typeof line.visible !== "boolean" || ![line.outputStart, line.outputEnd, line.visibleStart, line.visibleEnd].every(isNonNegativeSafeInteger) || line.outputStart < previousOutputEnd || line.outputEnd < line.outputStart || line.outputEnd - line.outputStart !== line.output.charCount || line.visibleEnd < line.visibleStart || line.visibleStart > line.outputStart || line.visibleEnd > line.outputEnd || line.visibleEnd > composition.output.charCount || line.visibleStart < line.outputStart && line.visibleStart !== line.visibleEnd || line.visible !== (line.visibleStart === line.outputStart && line.visibleEnd === line.outputEnd)) {
+      throw new Error(`${label} retrieval trace composition line structure is invalid.`);
+    }
+    previousOutputEnd = line.outputEnd;
+  }
+}
+function assertExactKeys(value, allowed, label) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`${label} must be an object.`);
+  }
+  const allowedKeys = new Set(allowed);
+  if (Object.keys(value).some((key) => !allowedKeys.has(key))) {
+    throw new Error(`${label} contains an unsupported field.`);
+  }
+}
+function isNonNegativeSafeInteger(value) {
+  return Number.isSafeInteger(value) && value >= 0;
+}
+function isTraceRange(value) {
+  return [value.composedStart, value.composedEnd, value.visibleStart, value.visibleEnd].every(isNonNegativeSafeInteger) && value.composedEnd >= value.composedStart && value.visibleEnd >= value.visibleStart;
+}
+function isTraceBudget(value) {
+  if (!value || typeof value !== "object") return false;
+  const budget = value;
+  return [budget.requestedChars, budget.composedChars, budget.returnedChars].every(
+    (entry) => Number.isSafeInteger(entry) && entry >= 0
+  ) && typeof budget.truncated === "boolean";
+}
+function isCountBudget(value) {
+  if (!value || typeof value !== "object") return false;
+  const budget = value;
+  return [budget.chars, budget.used].every((entry) => Number.isSafeInteger(entry) && entry >= 0);
+}
+function assertFiniteJson(value, label) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") return;
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) throw new Error(`${label} contains a non-finite number.`);
+    return;
+  }
+  if (Array.isArray(value)) {
+    value.forEach((entry, index) => assertFiniteJson(entry, `${label}[${index}]`));
+    return;
+  }
+  if (!value || typeof value !== "object") throw new Error(`${label} is not canonical JSON.`);
+  for (const [key, entry] of Object.entries(value)) {
+    if (entry === void 0) throw new Error(`${label}.${key} is undefined.`);
+    assertFiniteJson(entry, `${label}.${key}`);
+  }
+}
+function assertComparable(baseline, real) {
+  if (baseline.provenance.runtimeProfile !== "baseline" || real.provenance.runtimeProfile !== "real") {
+    throw new Error("Paired retrieval traces require baseline and real runtime profiles in that order.");
+  }
+  const matching = [
+    [baseline.schemaVersion, real.schemaVersion],
+    [baseline.benchmarkId, real.benchmarkId],
+    [baseline.provenance.gitSha, real.provenance.gitSha],
+    [baseline.provenance.remnicVersion, real.provenance.remnicVersion],
+    [baseline.provenance.dataset.sha256, real.provenance.dataset.sha256],
+    [baseline.provenance.recallBudget.version, real.provenance.recallBudget.version],
+    [baseline.selection.selectedTaskIdsSha256, real.selection.selectedTaskIdsSha256],
+    [canonicalJsonStringify(baseline.selection), canonicalJsonStringify(real.selection)],
+    [baseline.tasks.length, real.tasks.length]
+  ];
+  if (matching.some(([left, right]) => left !== right))
+    throw new Error("Paired retrieval trace provenance does not match.");
+  if (baseline.provenance.retrievalConfigSha256 === real.provenance.retrievalConfigSha256) {
+    throw new Error("Paired retrieval traces must use different baseline and real retrieval configuration hashes.");
+  }
+  baseline.tasks.forEach((left, index) => {
+    const right = real.tasks[index];
+    if (!right || left.taskId !== right.taskId || canonicalJsonStringify(left.question) !== canonicalJsonStringify(right.question) || left.recallBudgetChars !== right.recallBudgetChars || left.sessions.length !== right.sessions.length || left.composition.multiHopRecallComposition !== right.composition.multiHopRecallComposition) {
+      throw new Error(`Paired retrieval trace task mismatch at index ${index}.`);
+    }
+    left.sessions.forEach((session, sessionIndex) => {
+      const other = right.sessions[sessionIndex];
+      if (!other || canonicalJsonStringify(session.session) !== canonicalJsonStringify(other.session)) {
+        throw new Error(`Paired retrieval trace session mismatch at task ${index}, session ${sessionIndex}.`);
+      }
+      if (session.trace.budget.requestedChars !== other.trace.budget.requestedChars) {
+        throw new Error(`Paired retrieval trace budget mismatch at task ${index}, session ${sessionIndex}.`);
+      }
+    });
+  });
+}
+function isDigest(value) {
+  if (!value || typeof value !== "object") return false;
+  if (Object.keys(value).some((key) => !["sha256", "charCount", "lineCount"].includes(key))) return false;
+  const digest = value;
+  return isSha256Hex(digest.sha256) && Number.isSafeInteger(digest.charCount) && digest.charCount >= 0 && Number.isSafeInteger(digest.lineCount) && digest.lineCount >= 0;
+}
+
 // src/benchmarks/published/locomo/retrieval-trace-runner.ts
 var LOCOMO_RETRIEVAL_TRACE_SCHEMA_VERSION = 1;
 var LOCOMO_RETRIEVAL_TRACE_SELECTION_VERSION = 1;
@@ -43497,6 +44294,7 @@ export {
   LOCOMO_RECALL_DIFF_LINE_LIMIT,
   LOCOMO_RECALL_EXCERPT_CHARS,
   LOCOMO_RETRIEVAL_TRACE_BUDGET_VERSION,
+  LOCOMO_RETRIEVAL_TRACE_DELTA_SCHEMA_VERSION,
   LOCOMO_RETRIEVAL_TRACE_SCHEMA_VERSION,
   LOCOMO_RETRIEVAL_TRACE_SELECTION_VERSION,
   LONG_MEM_EVAL_DATASET_FILENAMES,
@@ -43611,6 +44409,7 @@ export {
   defaultBenchmarkBaselineDir,
   defaultBenchmarkPublishPath,
   deleteBenchmarkResults,
+  diagnoseLoCoMoRetrievalTraceDelta,
   diagnoseLoComoProfileDelta,
   diagnoseLoComoRecallDelta,
   discoverAllProviders,
@@ -43739,6 +44538,7 @@ export {
   selectFixtureVariant,
   serializeBenchmarkArtifact,
   serializeJsonl,
+  serializeLoCoMoRetrievalTraceDelta,
   serializeLoCoMoRetrievalTraceReceipt,
   serializeSealedQrels,
   shuffleTasks,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remnic/bench",
-  "version": "9.6.33",
+  "version": "9.6.34",
   "description": "Retrieval latency ladder benchmarks + CI regression gates for @remnic/core",
   "type": "module",
   "main": "./dist/index.js",
@@ -39,8 +39,8 @@
     "hyparquet": "^1.25.7",
     "yaml": "^2.4.2",
     "zod": "^3.24.0",
-    "@remnic/coding-graph": "^9.6.33",
-    "@remnic/core": "^9.6.33"
+    "@remnic/coding-graph": "^9.6.34",
+    "@remnic/core": "^9.6.34"
   },
   "devDependencies": {
     "tsup": "^8.5.1",