npm - @remnic/bench - Versions diffs - 9.6.31 → 9.6.32 - Mend

@remnic/bench 9.6.31 → 9.6.32

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (3) hide show

package/dist/index.d.ts CHANGED Viewed

@@ -165,6 +165,11 @@ interface BenchJudge {
 interface BenchMemoryAdapter {
     store(sessionId: string, messages: Message[], control?: BenchPhaseControl): Promise<void>;
     recall(sessionId: string, query: string, budgetChars?: number, options?: BenchRecallOptions, control?: BenchPhaseControl): Promise<string>;
+    /**
+     * Optional diagnostic recall surface. The trace contains only structural
+     * lineage and budget metadata; it never includes recalled or source text.
+     */
+    recallWithTrace?(sessionId: string, query: string, budgetChars?: number, options?: BenchRecallOptions, control?: BenchPhaseControl): Promise<BenchRecallWithTraceResult>;
     /**
      * Optionally assess support using the exact, final recall context that will
      * be sent to the responder. Implementations may return `weak` only from
@@ -195,6 +200,109 @@ interface BenchRecallOptions {
     /** Optional historical recall timestamp for benchmarks that expose query time. */
     asOf?: string;
 }
+type BenchRecallLineageStatus = "exact" | "unavailable";
+/**
+ * Half-open offsets measured in JavaScript string characters (UTF-16 code
+ * units), matching `String.length` and `String.prototype.slice`.
+ */
+interface BenchRecallTraceRange {
+    composedStart: number;
+    composedEnd: number;
+    visibleStart: number;
+    visibleEnd: number;
+}
+interface BenchRecallTraceSection extends BenchRecallTraceRange {
+    id: string;
+    source: "derived" | "explicit-cue" | "trajectory-analysis" | "core" | "evidence-pack" | "lcm-summary" | "raw-row";
+    /** Character offset where this section's leading separator starts. */
+    separatorStart: number;
+    /** Character offset where content starts after the optional `\n\n` separator. */
+    contentStart: number;
+    /** Exclusive character offset where section content ends. */
+    contentEnd: number;
+    /** Visible separator plus content characters attributed to this section. */
+    visibleChars: number;
+}
+interface BenchRecallTraceSelection extends BenchRecallTraceRange {
+    sectionId: string;
+    kind: "evidence-block" | "trajectory-line" | "lcm-summary" | "raw-row";
+    lineageStatus: BenchRecallLineageStatus;
+    archiveRowIds?: number[];
+    turnIndex?: number;
+    role?: string;
+    score?: number;
+    summary?: {
+        id: string;
+        depth: number;
+        msgStart: number;
+        msgEnd: number;
+    };
+}
+interface BenchRecallTraceLcmCandidate {
+    rank: number;
+    archiveRowId?: number;
+    turnIndex: number;
+    role: string;
+    score?: number;
+    lineageStatus: BenchRecallLineageStatus;
+}
+interface BenchRecallTraceCoreCapture {
+    snapshotId: string;
+    capturedAt: number;
+    traceId?: string;
+    budget: {
+        chars: number;
+        used: number;
+    };
+    filters: Array<{
+        name: string;
+        considered: number;
+        admitted: number;
+    }>;
+    results: Array<{
+        /** Content-free reference to the UTF-8 encoded core memory id. */
+        memoryIdRef: {
+            sha256: string;
+            length: number;
+        };
+        servedBy: string;
+        scoreDecomposition: {
+            vector?: number;
+            bm25?: number;
+            importance?: number;
+            mmrPenalty?: number;
+            tierPrior?: number;
+            reinforcementBoost?: number;
+            final: number;
+        };
+        admittedBy: string[];
+        rejectedBy?: string;
+        disclosure?: "chunk" | "section" | "raw";
+        estimatedTokens?: number;
+    }>;
+}
+interface BenchRecallTrace {
+    schemaVersion: 1;
+    sensitivity: {
+        classification: "restricted";
+        contentEncoding: "sha256+length";
+        containsGold: false;
+    };
+    sections: BenchRecallTraceSection[];
+    selections: BenchRecallTraceSelection[];
+    lcmCandidates: BenchRecallTraceLcmCandidate[];
+    coreCapture?: BenchRecallTraceCoreCapture;
+    budget: {
+        requestedChars: number;
+        composedChars: number;
+        returnedChars: number;
+        truncated: boolean;
+    };
+}
+interface BenchRecallWithTraceResult {
+    text: string;
+    trace: BenchRecallTrace;
+}
 type LlmJudge = BenchJudge;
 type MemorySystem = BenchMemoryAdapter;
@@ -5300,4 +5408,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 BenchRecallOptions, type BenchRecallSupportAssessment, type BenchRecallSupportRequest, type BenchRecallSupportStatus, 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 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, LONG_MEM_EVAL_DATASET_FILENAMES, type LeaderboardArtifactWrite, type LettaAdapterConfig, LettaMemCorrectAdapter, type LlmJudge, type LlmProvider, 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, buildSchemaTierFixture, buildSchemaTierSmokeFixture, calendarFixture, canonicalJsonStringify, 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, 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, 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, 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 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, LONG_MEM_EVAL_DATASET_FILENAMES, type LeaderboardArtifactWrite, type LettaAdapterConfig, LettaMemCorrectAdapter, type LlmJudge, type LlmProvider, 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, buildSchemaTierFixture, buildSchemaTierSmokeFixture, calendarFixture, canonicalJsonStringify, 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, 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, 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, serializeSealedQrels, shuffleTasks, timed, verifyRubricDigest, writeBenchmarkArtifact, writeBenchmarkPublishFeed, writeBenchmarkReproManifest, writeBenchmarkResult, writeJudgeCalibrationState, writeLeaderboardArtifactsForResult, zeroScores };

package/dist/index.js CHANGED Viewed

@@ -597,7 +597,7 @@ var LettaMemCorrectAdapter = class {
 var REQUIRED_FRONTMATTER_FIELDS = ["title", "type", "state", "created", "see-also"];
 // src/adapters/remnic-adapter.ts
-import { createHash } from "crypto";
+import { createHash as createHash2 } from "crypto";
 import { execFile } from "child_process";
 import {
   chmod,
@@ -629,6 +629,226 @@ import {
   parseEntityFile,
   serializeEntityFile
 } from "@remnic/core";
+import {
+  lcmEvidenceIdentity
+} from "@remnic/core/lcm";
+// src/adapters/remnic-recall-trace.ts
+import { createHash } from "crypto";
+import {
+  lcmArchiveRowId
+} from "@remnic/core/lcm";
+function visibleRange(start, end, returnedChars) {
+  const visibleStart = Math.min(start, returnedChars);
+  return {
+    visibleStart,
+    visibleEnd: Math.max(visibleStart, Math.min(end, returnedChars))
+  };
+}
+function projectBenchCoreCapture(snapshot) {
+  return {
+    snapshotId: snapshot.snapshotId,
+    capturedAt: snapshot.capturedAt,
+    ...snapshot.traceId === void 0 ? {} : { traceId: snapshot.traceId },
+    budget: { chars: snapshot.budget.chars, used: snapshot.budget.used },
+    filters: snapshot.filters.map(({ name, considered, admitted }) => ({
+      name,
+      considered,
+      admitted
+    })),
+    results: snapshot.results.map((result) => {
+      const scores = result.scoreDecomposition;
+      return {
+        memoryIdRef: {
+          sha256: createHash("sha256").update(result.memoryId, "utf8").digest("hex"),
+          length: Buffer.byteLength(result.memoryId, "utf8")
+        },
+        servedBy: result.servedBy,
+        scoreDecomposition: {
+          ...typeof scores.vector === "number" ? { vector: scores.vector } : {},
+          ...typeof scores.bm25 === "number" ? { bm25: scores.bm25 } : {},
+          ...typeof scores.importance === "number" ? { importance: scores.importance } : {},
+          ...typeof scores.mmrPenalty === "number" ? { mmrPenalty: scores.mmrPenalty } : {},
+          ...typeof scores.tierPrior === "number" ? { tierPrior: scores.tierPrior } : {},
+          ...typeof scores.reinforcementBoost === "number" ? { reinforcementBoost: scores.reinforcementBoost } : {},
+          final: scores.final
+        },
+        admittedBy: [...result.admittedBy],
+        ...result.rejectedBy === void 0 ? {} : { rejectedBy: result.rejectedBy },
+        ...result.disclosure === void 0 ? {} : { disclosure: result.disclosure },
+        ...result.estimatedTokens === void 0 ? {} : { estimatedTokens: result.estimatedTokens }
+      };
+    })
+  };
+}
+function createBenchRecallTraceRecorder(requestedChars) {
+  const sections = [];
+  const pendingSelections = [];
+  const lcmCandidates = [];
+  let composedChars = 0;
+  let coreCapture;
+  const sectionById = (sectionId) => {
+    const section = sections.find((entry) => entry.id === sectionId);
+    if (!section) throw new Error(`Unknown benchmark recall trace section: ${sectionId}`);
+    return section;
+  };
+  const appendRelativeSelection = (sectionId, kind, start, end, lineageStatus, fields = {}) => {
+    const section = sectionById(sectionId);
+    const contentLength = section.contentEnd - section.contentStart;
+    if (!Number.isSafeInteger(start) || !Number.isSafeInteger(end) || start < 0 || end < start || end > contentLength) {
+      throw new Error(
+        `Invalid benchmark recall trace range for ${sectionId}: ${start}..${end}.`
+      );
+    }
+    pendingSelections.push({
+      sectionId,
+      kind,
+      lineageStatus,
+      composedStart: section.contentStart + start,
+      composedEnd: section.contentStart + end,
+      ...fields
+    });
+  };
+  return {
+    appendSection(id, source, renderedLength) {
+      if (!Number.isSafeInteger(renderedLength) || renderedLength < 0) {
+        throw new Error("Benchmark recall trace section length must be a non-negative integer.");
+      }
+      if (sections.some((section) => section.id === id)) {
+        throw new Error(`Duplicate benchmark recall trace section: ${id}`);
+      }
+      const separatorStart = composedChars;
+      const contentStart = composedChars + (sections.length === 0 ? 0 : 2);
+      const contentEnd = contentStart + renderedLength;
+      sections.push({
+        id,
+        source,
+        separatorStart,
+        contentStart,
+        contentEnd,
+        composedStart: separatorStart,
+        composedEnd: contentEnd,
+        visibleStart: 0,
+        visibleEnd: 0,
+        visibleChars: 0
+      });
+      composedChars = contentEnd;
+    },
+    recordEvidenceSelections(sectionId, receipts) {
+      for (const receipt of receipts) {
+        appendRelativeSelection(
+          sectionId,
+          "evidence-block",
+          receipt.blockStart,
+          receipt.blockEnd,
+          receipt.item.archiveRowId === void 0 ? "unavailable" : "exact",
+          {
+            ...receipt.item.archiveRowId === void 0 ? {} : { archiveRowIds: [receipt.item.archiveRowId] },
+            ...receipt.item.turnIndex === void 0 ? {} : { turnIndex: receipt.item.turnIndex },
+            ...receipt.item.role === void 0 ? {} : { role: receipt.item.role },
+            ...receipt.item.score === void 0 ? {} : { score: receipt.item.score }
+          }
+        );
+      }
+    },
+    recordTrajectorySelections(sectionId, receipts) {
+      for (const receipt of receipts) {
+        appendRelativeSelection(
+          sectionId,
+          "trajectory-line",
+          receipt.lineStart,
+          receipt.lineEnd,
+          receipt.lineageStatus,
+          {
+            archiveRowIds: [
+              ...receipt.actionArchiveRowIds,
+              ...receipt.observationArchiveRowIds
+            ]
+          }
+        );
+      }
+    },
+    recordSummarySelections(sectionId, receipts) {
+      for (const receipt of receipts) {
+        appendRelativeSelection(
+          sectionId,
+          "lcm-summary",
+          receipt.entryStart,
+          receipt.entryEnd,
+          "exact",
+          {
+            summary: {
+              id: receipt.id,
+              depth: receipt.depth,
+              msgStart: receipt.msgStart,
+              msgEnd: receipt.msgEnd
+            }
+          }
+        );
+      }
+    },
+    recordRawRow(sectionId, range, row) {
+      const archiveRowId = lcmArchiveRowId(row);
+      appendRelativeSelection(
+        sectionId,
+        "raw-row",
+        range.start,
+        range.end,
+        archiveRowId === void 0 ? "unavailable" : "exact",
+        {
+          ...archiveRowId === void 0 ? {} : { archiveRowIds: [archiveRowId] },
+          turnIndex: row.turn_index,
+          role: row.role
+        }
+      );
+    },
+    recordLcmCandidate(candidate) {
+      lcmCandidates.push({ ...candidate });
+    },
+    recordCoreCapture(snapshot) {
+      coreCapture = snapshot ? projectBenchCoreCapture(snapshot) : void 0;
+    },
+    finalize(returnedChars) {
+      const normalizedReturnedChars = Math.max(0, Math.min(returnedChars, composedChars));
+      return {
+        schemaVersion: 1,
+        sensitivity: {
+          classification: "restricted",
+          contentEncoding: "sha256+length",
+          containsGold: false
+        },
+        sections: sections.map((section) => {
+          const visible = visibleRange(
+            section.composedStart,
+            section.composedEnd,
+            normalizedReturnedChars
+          );
+          return {
+            ...section,
+            ...visible,
+            visibleChars: visible.visibleEnd - visible.visibleStart
+          };
+        }),
+        selections: pendingSelections.map((selection) => ({
+          ...selection,
+          ...visibleRange(
+            selection.composedStart,
+            selection.composedEnd,
+            normalizedReturnedChars
+          )
+        })),
+        lcmCandidates: lcmCandidates.map((candidate) => ({ ...candidate })),
+        ...coreCapture === void 0 ? {} : { coreCapture },
+        budget: {
+          requestedChars,
+          composedChars,
+          returnedChars: normalizedReturnedChars,
+          truncated: normalizedReturnedChars < composedChars
+        }
+      };
+    }
+  };
+}
 // src/recall-budget.ts
 var DEFAULT_BENCH_RECALL_BUDGET_CHARS = 24e3;
@@ -1264,7 +1484,7 @@ function benchCoreMemoryTier(memory) {
   return memory.path.includes(`${path.sep}cold${path.sep}`) ? "cold" : "hot";
 }
 function benchCoreMemorySource(sessionId) {
-  return `bench-replay-${createHash("sha256").update(sessionId).digest("hex").slice(0, 16)}`;
+  return `bench-replay-${createHash2("sha256").update(sessionId).digest("hex").slice(0, 16)}`;
 }
 function resolveSessionScopedCorrectionDecision(plan, ownedIds, phase) {
   const actionTargets = [];
@@ -2009,7 +2229,8 @@ function createAdapterFactory(mode) {
       }
       return correctionAccess.service;
     };
-    return {
+    const composeRecall = /* @__PURE__ */ Symbol("benchRecallComposer");
+    const adapter = {
       async store(sessionId, messages, control) {
         throwIfBenchPhaseAborted(control, "store");
         sessionId = normalizeBenchSessionId(sessionId);
@@ -2128,7 +2349,7 @@ function createAdapterFactory(mode) {
           throw error;
         }
       },
-      async recall(sessionId, query, budgetChars, recallOptions = {}, control) {
+      async [composeRecall](sessionId, query, budgetChars, recallOptions = {}, control, traceRecorder) {
         throwIfBenchPhaseAborted(control, "recall");
         const waitForRecall = (promise) => withBenchPhaseAbort(promise, control, "recall");
         sessionId = normalizeBenchSessionId(sessionId);
@@ -2150,6 +2371,10 @@ function createAdapterFactory(mode) {
           );
         }
         const sections = [];
+        const appendSection = (id, source, rendered) => {
+          traceRecorder?.appendSection(id, source, rendered.length);
+          sections.push(rendered);
+        };
         let usedChars = 0;
         const explicitReferences = historicalRecall ? [] : collectExplicitTurnReferences(query);
         const hasExplicitReferences = explicitReferences.length > 0;
@@ -2175,7 +2400,7 @@ function createAdapterFactory(mode) {
           }));
           if (temporalIntervalEvidence) {
             hasTemporalIntervalEvidence = true;
-            sections.push(temporalIntervalEvidence);
+            appendSection("temporal-interval", "derived", temporalIntervalEvidence);
             usedChars += temporalIntervalEvidence.length;
           }
         }
@@ -2187,7 +2412,7 @@ function createAdapterFactory(mode) {
           }));
           if (dependencyVersionEvidence) {
             hasDependencyVersionEvidence = true;
-            sections.push(dependencyVersionEvidence);
+            appendSection("dependency-version", "derived", dependencyVersionEvidence);
             usedChars += dependencyVersionEvidence.length;
           }
         }
@@ -2199,7 +2424,7 @@ function createAdapterFactory(mode) {
             maxChars: Math.min(3e3, Math.floor(budget * 0.25))
           }));
           if (latestQuantitativeEvidence) {
-            sections.push(latestQuantitativeEvidence);
+            appendSection("latest-quantitative", "derived", latestQuantitativeEvidence);
             usedChars += latestQuantitativeEvidence.length;
           }
         }
@@ -2211,10 +2436,11 @@ function createAdapterFactory(mode) {
           }));
           if (userImplementationTargetEvidence) {
             hasUserImplementationTargetEvidence = true;
-            sections.push(userImplementationTargetEvidence);
+            appendSection("implementation-targets", "derived", userImplementationTargetEvidence);
             usedChars += userImplementationTargetEvidence.length;
           }
         }
+        const explicitCueSelections = [];
         const exactReferenceEvidence = historicalRecall || hasDependencyVersionEvidence ? "" : await waitForRecall(buildExplicitCueRecallSection({
           engine,
           sessionId,
@@ -2223,12 +2449,17 @@ function createAdapterFactory(mode) {
           maxItemChars: CORE_EXPLICIT_CUE_MAX_ITEM_CHARS,
           maxReferences: CORE_EXPLICIT_CUE_MAX_REFERENCES,
           includeBenchmarkAnchorCues: sessionId.startsWith("beam-"),
-          includeStructuredPlanCues: sessionId.startsWith("arena-")
+          includeStructuredPlanCues: sessionId.startsWith("arena-"),
+          ...traceRecorder ? { onEvidenceSelected: (receipt) => {
+            explicitCueSelections.push(receipt);
+          } } : {}
         }));
         if (exactReferenceEvidence) {
-          sections.push(exactReferenceEvidence);
+          appendSection("explicit-cue", "explicit-cue", exactReferenceEvidence);
+          traceRecorder?.recordEvidenceSelections("explicit-cue", explicitCueSelections);
           usedChars += exactReferenceEvidence.length;
         }
+        const trajectorySelections = [];
         const trajectoryAnalysisEvidence = !historicalRecall && sessionId.startsWith("ama-") ? await waitForRecall(buildTrajectoryAnalysisRecallSection({
           engine,
           sessionId,
@@ -2236,10 +2467,17 @@ function createAdapterFactory(mode) {
           maxChars: Math.min(
             CORE_TRAJECTORY_ANALYSIS_MAX_CHARS,
             Math.max(0, Math.floor((budget - usedChars) * 0.55))
-          )
+          ),
+          ...traceRecorder ? { onLineSelected: (receipt) => {
+            trajectorySelections.push(receipt);
+          } } : {}
         })) : "";
         if (trajectoryAnalysisEvidence) {
-          sections.push(trajectoryAnalysisEvidence);
+          appendSection("trajectory-analysis", "trajectory-analysis", trajectoryAnalysisEvidence);
+          traceRecorder?.recordTrajectorySelections(
+            "trajectory-analysis",
+            trajectorySelections
+          );
           usedChars += trajectoryAnalysisEvidence.length;
         }
         if (includeCoreRecall && !requireDirectPersonalHistoryEvidence && !requireDirectTemporalEvidence && !hasTemporalIntervalEvidence && !hasDependencyVersionEvidence && !hasUserImplementationTargetEvidence) {
@@ -2252,17 +2490,27 @@ function createAdapterFactory(mode) {
               )
             )
           );
-          const coreRecall = await waitForRecall(
-            state.orchestrator.recall(query, sessionId, {
-              budgetCharsOverride: coreBudget,
-              mode: "full",
-              ...recallAsOf ? { asOf: recallAsOf } : {}
-            })
+          const coreOptions = {
+            budgetCharsOverride: coreBudget,
+            mode: "full",
+            ...control?.signal ? { abortSignal: control.signal } : {},
+            ...recallAsOf ? { asOf: recallAsOf } : {}
+          };
+          const coreRecall = traceRecorder ? await withBenchPhaseAbort(
+            state.orchestrator.recallWithXrayCapture(query, sessionId, coreOptions),
+            control,
+            "recall",
+            { waitForCompletionOnAbort: true }
+          ).then((capture) => {
+            traceRecorder.recordCoreCapture(capture.snapshot);
+            return capture.result;
+          }) : await waitForRecall(
+            state.orchestrator.recall(query, sessionId, coreOptions)
           );
           if (coreRecall.trim().length > 0) {
             const section = `## Remnic recall pipeline
 ${coreRecall.trim()}`;
-            sections.push(section);
+            appendSection("core", "core", section);
             usedChars += section.length;
           }
         }
@@ -2273,7 +2521,7 @@ ${coreRecall.trim()}`;
               "## Remnic historical recall",
               `No historically valid Remnic memories matched this query as of ${recallAsOf}.`
             ].join("\n");
-            sections.push(section);
+            appendSection("historical-empty", "derived", section);
             usedChars += section.length;
           }
         }
@@ -2289,6 +2537,30 @@ ${coreRecall.trim()}`;
               sessionId
             )
           );
+          const exactSearchHits = /* @__PURE__ */ new Map();
+          const uniqueLegacySearchHits = /* @__PURE__ */ new Map();
+          const ambiguousLegacySearchHitIds = /* @__PURE__ */ new Set();
+          searchResults.forEach((result, rank) => {
+            const identity = lcmEvidenceIdentity(result, result.session_id);
+            if (identity.archiveRowId !== void 0 && !exactSearchHits.has(identity.id)) {
+              exactSearchHits.set(identity.id, result);
+            } else if (identity.archiveRowId === void 0) {
+              if (uniqueLegacySearchHits.has(identity.id)) {
+                uniqueLegacySearchHits.delete(identity.id);
+                ambiguousLegacySearchHitIds.add(identity.id);
+              } else if (!ambiguousLegacySearchHitIds.has(identity.id)) {
+                uniqueLegacySearchHits.set(identity.id, result);
+              }
+            }
+            traceRecorder?.recordLcmCandidate({
+              rank: rank + 1,
+              ...identity.archiveRowId === void 0 ? {} : { archiveRowId: identity.archiveRowId },
+              turnIndex: result.turn_index,
+              role: result.role,
+              ...typeof result.score === "number" ? { score: result.score } : {},
+              lineageStatus: identity.archiveRowId === void 0 ? "unavailable" : "exact"
+            });
+          });
           if (searchResults.length > 0) {
             const evidenceItems = [];
             const directTemporalEvidenceItems = [];
@@ -2307,8 +2579,20 @@ ${coreRecall.trim()}`;
                   includeCoreRecall ? 1600 : 600
                 )
               );
+              const expandedIdentityCounts = /* @__PURE__ */ new Map();
+              for (const message of expanded) {
+                const expandedIdentity = lcmEvidenceIdentity(
+                  message,
+                  result.session_id
+                );
+                expandedIdentityCounts.set(
+                  expandedIdentity.id,
+                  (expandedIdentityCounts.get(expandedIdentity.id) ?? 0) + 1
+                );
+              }
               if (expanded.length === 0) {
-                const id = `${result.session_id}:${result.turn_index}`;
+                const identity = lcmEvidenceIdentity(result, result.session_id);
+                const { id } = identity;
                 if (!directTemporalTurnIds.has(id) && shouldIncludeDirectTemporalEvidence(
                   result.content,
                   query,
@@ -2317,6 +2601,7 @@ ${coreRecall.trim()}`;
                   directTemporalTurnIds.add(id);
                   directTemporalEvidenceItems.push({
                     id,
+                    ...identity.archiveRowId === void 0 ? {} : { archiveRowId: identity.archiveRowId },
                     sessionId: result.session_id,
                     turnIndex: result.turn_index,
                     role: result.role,
@@ -2336,6 +2621,7 @@ ${coreRecall.trim()}`;
                   seenTurns.add(id);
                   evidenceItems.push({
                     id,
+                    ...identity.archiveRowId === void 0 ? {} : { archiveRowId: identity.archiveRowId },
                     sessionId: result.session_id,
                     turnIndex: result.turn_index,
                     role: result.role,
@@ -2346,7 +2632,10 @@ ${coreRecall.trim()}`;
                 continue;
               }
               for (const message of expanded) {
-                const id = `${result.session_id}:${message.turn_index}`;
+                const identity = lcmEvidenceIdentity(message, result.session_id);
+                const { id } = identity;
+                const attributableSearchHit = identity.archiveRowId === void 0 ? expandedIdentityCounts.get(identity.id) === 1 ? uniqueLegacySearchHits.get(identity.id) : void 0 : exactSearchHits.get(identity.id);
+                const attributableScore = typeof attributableSearchHit?.score === "number" ? attributableSearchHit.score : void 0;
                 if (seenTurns.has(id)) continue;
                 if (!directTemporalTurnIds.has(id) && shouldIncludeDirectTemporalEvidence(
                   message.content,
@@ -2356,11 +2645,12 @@ ${coreRecall.trim()}`;
                   directTemporalTurnIds.add(id);
                   directTemporalEvidenceItems.push({
                     id,
+                    ...identity.archiveRowId === void 0 ? {} : { archiveRowId: identity.archiveRowId },
                     sessionId: result.session_id,
                     turnIndex: message.turn_index,
                     role: message.role,
                     content: message.content,
-                    ...message.turn_index === result.turn_index && typeof result.score === "number" ? { score: result.score } : {}
+                    ...attributableScore === void 0 ? {} : { score: attributableScore }
                   });
                 }
                 if (!shouldIncludeFocusedSearchEvidence(
@@ -2377,18 +2667,23 @@ ${coreRecall.trim()}`;
                 seenTurns.add(id);
                 evidenceItems.push({
                   id,
+                  ...identity.archiveRowId === void 0 ? {} : { archiveRowId: identity.archiveRowId },
                   sessionId: result.session_id,
                   turnIndex: message.turn_index,
                   role: message.role,
                   content: message.content,
-                  ...message.turn_index === result.turn_index && typeof result.score === "number" ? { score: result.score } : {}
+                  ...attributableScore === void 0 ? {} : { score: attributableScore }
                 });
               }
             }
+            const directTemporalSelections = [];
             const directTemporalEvidence = buildEvidencePack(directTemporalEvidenceItems, {
               title: "Direct temporal evidence",
               maxChars: Math.min(searchBudget, 3e3),
-              maxItemChars: 900
+              maxItemChars: 900,
+              ...traceRecorder ? { onSelection: (receipt) => {
+                directTemporalSelections.push(receipt);
+              } } : {}
             });
             let remainingSearchBudget = searchBudget;
             if (directTemporalEvidence) {
@@ -2396,7 +2691,11 @@ ${coreRecall.trim()}`;
                 directTemporalEvidence,
                 "These direct temporal statements match the question wording. Prefer them over indirect schedule-update context unless the question asks for the latest or current value."
               ].join("\n\n");
-              sections.push(section);
+              appendSection("direct-temporal", "evidence-pack", section);
+              traceRecorder?.recordEvidenceSelections(
+                "direct-temporal",
+                directTemporalSelections
+              );
               usedChars += section.length;
               remainingSearchBudget = 0;
             }
@@ -2405,19 +2704,27 @@ ${coreRecall.trim()}`;
               evidenceItems
             );
             if (contradictionGuidance) {
-              sections.push(contradictionGuidance);
+              appendSection("contradiction-guidance", "derived", contradictionGuidance);
               usedChars += contradictionGuidance.length;
             }
+            const searchSelections = [];
             const searchEvidence = buildEvidencePack(
               directTemporalEvidence ? evidenceItems.filter((item) => !directTemporalTurnIds.has(item.id)) : evidenceItems,
               {
                 title: "Search evidence",
                 maxChars: remainingSearchBudget,
-                maxItemChars: 900
+                maxItemChars: 900,
+                ...traceRecorder ? { onSelection: (receipt) => {
+                  searchSelections.push(receipt);
+                } } : {}
               }
             );
             if (searchEvidence) {
-              sections.push(searchEvidence);
+              appendSection("search-evidence", "evidence-pack", searchEvidence);
+              traceRecorder?.recordEvidenceSelections(
+                "search-evidence",
+                searchSelections
+              );
               usedChars += searchEvidence.length;
             }
           }
@@ -2429,17 +2736,26 @@ ${coreRecall.trim()}`;
               "## Remnic recall sufficiency",
               "No direct evidence found for the requested personal background or previous development projects in this session."
             ].join("\n");
-            sections.push(section);
+            appendSection("personal-history-empty", "derived", section);
             usedChars += section.length;
           }
         }
         if (!suppressBroadSummary) {
           const summaryBudget = Math.max(0, budget - usedChars - 4);
-          const recallText = await waitForRecall(
+          const summaryCapture = traceRecorder && engine.assembleRecallWithTrace ? await waitForRecall(
+            engine.assembleRecallWithTrace(sessionId, summaryBudget)
+          ) : void 0;
+          const recallText = summaryCapture?.text ?? await waitForRecall(
             engine.assembleRecall(sessionId, summaryBudget)
           );
           if (recallText) {
-            sections.push(recallText);
+            appendSection("lcm-summary", "lcm-summary", recallText);
+            if (summaryCapture) {
+              traceRecorder?.recordSummarySelections(
+                "lcm-summary",
+                summaryCapture.selectedSummaries
+              );
+            }
           }
         }
         if (!historicalRecall && sections.length === 0) {
@@ -2455,16 +2771,50 @@ ${coreRecall.trim()}`;
               )
             );
             if (expanded.length > 0) {
-              sections.push(
-                `## Raw messages
-${expanded.map((message) => `[${message.role}]: ${message.content}`).join("\n")}`
+              const prefix = "## Raw messages\n";
+              const rows = expanded.map(
+                (message) => `[${message.role}]: ${message.content}`
               );
+              const rawSection = `${prefix}${rows.join("\n")}`;
+              appendSection("raw-messages", "raw-row", rawSection);
+              let rowStart = prefix.length;
+              expanded.forEach((message, index) => {
+                const rowEnd = rowStart + rows[index].length;
+                traceRecorder?.recordRawRow(
+                  "raw-messages",
+                  { start: rowStart, end: rowEnd },
+                  message
+                );
+                rowStart = rowEnd + 1;
+              });
             }
           }
         }
         const joined = sections.join("\n\n");
         return joined.length > budget ? joined.slice(0, budget) : joined;
       },
+      recall(sessionId, query, budgetChars, recallOptions = {}, control) {
+        return adapter[composeRecall](
+          sessionId,
+          query,
+          budgetChars,
+          recallOptions,
+          control
+        );
+      },
+      async recallWithTrace(sessionId, query, budgetChars, recallOptions = {}, control) {
+        const budget = budgetChars ?? DEFAULT_BENCH_RECALL_BUDGET_CHARS;
+        const traceRecorder = createBenchRecallTraceRecorder(Math.max(0, budget));
+        const text = await adapter[composeRecall](
+          sessionId,
+          query,
+          budgetChars,
+          recallOptions,
+          control,
+          traceRecorder
+        );
+        return { text, trace: traceRecorder.finalize(text.length) };
+      },
       async assessRecallSupport(request, control) {
         throwIfBenchPhaseAborted(control, "assessRecallSupport");
         return assessRemnicRecallSupport(request, answerSupportMinCoverage);
@@ -2699,6 +3049,7 @@ ${expanded.map((message) => `[${message.role}]: ${message.content}`).join("\n")}
       responder: options.responder,
       judge: options.judge
     };
+    return adapter;
   };
 }
 var createLightweightAdapter = createAdapterFactory("lightweight");
@@ -3434,7 +3785,7 @@ function extractStructuredTrajectoryCueNumber(content) {
 function nextBenchTranscriptTurnId(counters, sessionId, message) {
   const index = counters.get(sessionId) ?? 0;
   counters.set(sessionId, index + 1);
-  const digest = createHash("sha256").update(`${sessionId}
+  const digest = createHash2("sha256").update(`${sessionId}
 ${index}
 ${message.role}
 ${message.content}`).digest("hex").slice(0, 16);
@@ -4301,6 +4652,33 @@ function createTimeoutGuardedAdapter(adapter, options) {
       return adapter.destroy();
     }
   };
+  if (adapter.recallWithTrace) {
+    wrapped.recallWithTrace = (sessionId, query, budgetChars, recallOptions, control) => {
+      if (phaseTimeoutMs === void 0) {
+        return adapter.recallWithTrace(
+          sessionId,
+          query,
+          budgetChars,
+          recallOptions,
+          control
+        );
+      }
+      return run(`recallWithTrace session=${sessionId}`, async (signal) => {
+        const merged = mergeBenchPhaseControl(signal, control);
+        try {
+          return await adapter.recallWithTrace(
+            sessionId,
+            query,
+            budgetChars,
+            recallOptions,
+            merged.control
+          );
+        } finally {
+          merged.cleanup();
+        }
+      });
+    };
+  }
   if (adapter.drain) {
     wrapped.drain = (control) => drainTimeoutMs === void 0 ? adapter.drain(control) : run(
       "drain",
@@ -5101,7 +5479,7 @@ function listMemoryEvalBenchmarkIds() {
 import {
   createCipheriv,
   createDecipheriv,
-  createHash as createHash2,
+  createHash as createHash3,
   randomBytes,
   timingSafeEqual
 } from "crypto";
@@ -5112,10 +5490,10 @@ var AES_TAG_LENGTH = 16;
 var INTEGRITY_HASH_ALGORITHM = "sha256";
 var INTEGRITY_CIPHER_ALGORITHM = "aes-256-gcm";
 function hashString(value) {
-  return createHash2(INTEGRITY_HASH_ALGORITHM).update(value, "utf8").digest("hex");
+  return createHash3(INTEGRITY_HASH_ALGORITHM).update(value, "utf8").digest("hex");
 }
 function hashBytes(value) {
-  return createHash2(INTEGRITY_HASH_ALGORITHM).update(value).digest("hex");
+  return createHash3(INTEGRITY_HASH_ALGORITHM).update(value).digest("hex");
 }
 function canonicalJsonStringify(value, space) {
   return JSON.stringify(value, canonicalReplacer, space);
@@ -5497,14 +5875,14 @@ var BENCHMARK_RESULT_SCHEMA = {
 // src/repro-manifest.ts
 import { execFileSync } from "child_process";
-import { createHash as createHash4 } from "crypto";
+import { createHash as createHash5 } from "crypto";
 import { createReadStream } from "fs";
 import { lstat as lstat3, mkdir as mkdir4, readFile as readFile5, readdir as readdir4, readlink, realpath as realpath3, stat as stat2, writeFile as writeFile4 } from "fs/promises";
 import os3 from "os";
 import path5 from "path";
 // src/providers/codex-credit-budget.ts
-import { createHash as createHash3 } from "crypto";
+import { createHash as createHash4 } from "crypto";
 import { mkdir as mkdir2, open, readFile as readFile3, rename as rename2, rmdir, unlink as unlink2, writeFile as writeFile2 } from "fs/promises";
 import os from "os";
 import path3 from "path";
@@ -6123,7 +6501,7 @@ function isSha256(value) {
   return typeof value === "string" && /^[a-f0-9]{64}$/.test(value);
 }
 function sha256(value) {
-  return createHash3("sha256").update(value).digest("hex");
+  return createHash4("sha256").update(value).digest("hex");
 }
 function normalizeZero(value) {
   return Object.is(value, -0) ? 0 : value;
@@ -7270,13 +7648,13 @@ var CODEX_CREDIT_REPRO_ENV_KEYS = [
   "REMNIC_BENCH_RUN_ID"
 ];
 function sha256String(value) {
-  return createHash4("sha256").update(value).digest("hex");
+  return createHash5("sha256").update(value).digest("hex");
 }
 function sha256Buffer(value) {
-  return createHash4("sha256").update(value).digest("hex");
+  return createHash5("sha256").update(value).digest("hex");
 }
 async function sha256File(filePath) {
-  const hash = createHash4("sha256");
+  const hash = createHash5("sha256");
   await new Promise((resolve, reject) => {
     const stream = createReadStream(filePath);
     stream.on("data", (chunk) => hash.update(chunk));
@@ -8197,7 +8575,7 @@ async function writeBenchmarkReproManifest(resultsDir, options = {}) {
 }
 // src/published-artifact.ts
-import { createHash as createHash5 } from "crypto";
+import { createHash as createHash6 } from "crypto";
 import { mkdir as mkdir5, readFile as readFile6, writeFile as writeFile5 } from "fs/promises";
 import path6 from "path";
 var BENCHMARK_ARTIFACT_SCHEMA_VERSION = 1;
@@ -8343,7 +8721,7 @@ function serializeBenchmarkArtifact(artifact) {
 `;
 }
 function hashBenchmarkArtifact(artifact) {
-  return createHash5("sha256").update(serializeBenchmarkArtifact(artifact)).digest("hex");
+  return createHash6("sha256").update(serializeBenchmarkArtifact(artifact)).digest("hex");
 }
 async function writeBenchmarkArtifact(artifact, outputDir) {
   await mkdir5(outputDir, { recursive: true });
@@ -8361,7 +8739,7 @@ async function writeBenchmarkArtifact(artifact, outputDir) {
   return {
     path: abs,
     filename,
-    sha256: createHash5("sha256").update(body).digest("hex"),
+    sha256: createHash6("sha256").update(body).digest("hex"),
     bytes: Buffer.byteLength(body, "utf8")
   };
 }
@@ -8475,7 +8853,7 @@ async function loadBenchmarkArtifact(filePath) {
   const artifact = parseBenchmarkArtifact(raw);
   return {
     artifact,
-    sha256: createHash5("sha256").update(raw).digest("hex"),
+    sha256: createHash6("sha256").update(raw).digest("hex"),
     bytes: Buffer.byteLength(raw, "utf8")
   };
 }
@@ -9638,7 +10016,7 @@ function createClaudeCliProvider(config, deps) {
 // src/providers/codex-cli.ts
 import { spawn as spawn2 } from "child_process";
-import { createHash as createHash6, randomUUID } from "crypto";
+import { createHash as createHash7, randomUUID } from "crypto";
 import { mkdir as mkdir6, mkdtemp as mkdtemp3, readFile as readFile7, rm as rm3, writeFile as writeFile6 } from "fs/promises";
 import os5 from "os";
 import path8 from "path";
@@ -10506,7 +10884,7 @@ function resolveCodexCliDiagnosticsMode(config) {
 }
 function inspectCodexCompletionPrompt(prompt) {
   const stats = {
-    sha256: createHash6("sha256").update(prompt).digest("hex"),
+    sha256: createHash7("sha256").update(prompt).digest("hex"),
     chars: prompt.length,
     lines: prompt.length === 0 ? 0 : prompt.split("\n").length
   };
@@ -12642,7 +13020,7 @@ function asStringArray(value) {
 }
 // src/responders.ts
-import { createHash as createHash7 } from "crypto";
+import { createHash as createHash8 } from "crypto";
 import { FallbackLlmClient } from "@remnic/core";
 // src/providers/openai-responses.ts
@@ -13115,7 +13493,7 @@ function getProviderBackedJudgePromptIdentity(config) {
     temperature: 0,
     maxTokens: 16
   };
-  return `sha256:${createHash7("sha256").update(JSON.stringify(contract)).digest("hex")}`;
+  return `sha256:${createHash8("sha256").update(JSON.stringify(contract)).digest("hex")}`;
 }
 var AMA_BENCH_RECOMMENDED_JUDGE_SYSTEM_PROMPT = [
   "You are evaluating an AMA-Bench long-horizon memory question.",
@@ -15456,11 +15834,11 @@ async function resolveLocalLabRuntimeProfile(options) {
 // src/benchmark.ts
 import fs2 from "fs";
 import path35 from "path";
-import { createHash as createHash13 } from "crypto";
+import { createHash as createHash14 } from "crypto";
 import { expandTildePath as expandTildePath3 } from "@remnic/core";
 // src/judges/judge-cache.ts
-import { createHash as createHash8, randomBytes as randomBytes2 } from "crypto";
+import { createHash as createHash9, randomBytes as randomBytes2 } from "crypto";
 import {
   mkdir as mkdir9,
   readFile as readFile11,
@@ -15503,8 +15881,8 @@ var JudgeCache = class {
   }
   /** Compute the sha256-hex key for a set of parts. Pure, sync, side-effect-free. */
   computeKey(parts) {
-    const fieldDigest = (value) => createHash8("sha256").update(value).digest();
-    return createHash8("sha256").update(fieldDigest(parts.benchmarkId)).update(fieldDigest(parts.datasetVersion)).update(fieldDigest(parts.questionId)).update(fieldDigest(parts.answerText)).update(fieldDigest(parts.judgePromptHash)).update(fieldDigest(parts.judgeModelId)).update(fieldDigest(parts.judgeParamsHash)).digest("hex");
+    const fieldDigest = (value) => createHash9("sha256").update(value).digest();
+    return createHash9("sha256").update(fieldDigest(parts.benchmarkId)).update(fieldDigest(parts.datasetVersion)).update(fieldDigest(parts.questionId)).update(fieldDigest(parts.answerText)).update(fieldDigest(parts.judgePromptHash)).update(fieldDigest(parts.judgeModelId)).update(fieldDigest(parts.judgeParamsHash)).digest("hex");
   }
   /**
    * Read a previously-stored verdict. Returns `undefined` on miss, corrupted
@@ -15699,7 +16077,7 @@ function runJudgeWithCache(options) {
           // Binary prompts are content-sensitive: two distinct prompts of
           // the same character length would collide on the previous
           // `binary:N` key, so key on a sha256 prefix of the prompt body.
-          questionId: `binary:${createHash8("sha256").update(prompt).digest("hex").slice(0, 16)}`,
+          questionId: `binary:${createHash9("sha256").update(prompt).digest("hex").slice(0, 16)}`,
           answerText: prompt,
           judgePromptHash: keyExtras.judgePromptHash ?? "unknown-prompt",
           judgeModelId: keyExtras.judgeModelId ?? "unknown-judge",
@@ -23190,7 +23568,7 @@ var StructuredLiteralParser = class {
 };
 // src/benchmarks/published/personamem/runner.ts
-import { createHash as createHash9, randomUUID as randomUUID7 } from "crypto";
+import { createHash as createHash10, randomUUID as randomUUID7 } from "crypto";
 import { readFile as readFile16, realpath as realpath4 } from "fs/promises";
 import path19 from "path";
@@ -23795,7 +24173,7 @@ function buildMcqPrompt(sample, seed) {
 function deterministicShuffle(values, seedMaterial) {
   return values.map((value, index) => ({
     value,
-    key: createHash9("sha256").update(`${seedMaterial}:${index}:${value}`).digest("hex"),
+    key: createHash10("sha256").update(`${seedMaterial}:${index}:${value}`).digest("hex"),
     index
   })).sort((left, right) => {
     const byKey = left.key.localeCompare(right.key);
@@ -32254,7 +32632,7 @@ function pairedDeltaConfidenceInterval(candidateValues, baselineValues, options
 }
 // src/judges/sealed-rubric.ts
-import { createHash as createHash10 } from "crypto";
+import { createHash as createHash11 } from "crypto";
 import { appendFileSync, mkdirSync } from "fs";
 import path31 from "path";
@@ -32363,7 +32741,7 @@ function loadSealedRubric(id = DEFAULT_ASSISTANT_RUBRIC_ID, options = {}) {
   if (typeof prompt !== "string" || prompt.length === 0) {
     throw new Error(`sealed rubric not found in registry: ${id}`);
   }
-  const sha2563 = createHash10("sha256").update(prompt, "utf8").digest("hex");
+  const sha2563 = createHash11("sha256").update(prompt, "utf8").digest("hex");
   const version = parseVersionFromId(id);
   return { id, version, prompt, sha256: sha2563 };
 }
@@ -34566,7 +34944,7 @@ async function runRetentionAgedDatasetBenchmark(options) {
 import { randomUUID as randomUUID31 } from "crypto";
 // src/benchmarks/remnic/memcorrect/generator.ts
-import { createHash as createHash11 } from "crypto";
+import { createHash as createHash12 } from "crypto";
 // src/benchmarks/remnic/memcorrect/token-pools.ts
 var PERSONAS = [
@@ -34890,7 +35268,7 @@ function corpusHash(corpus) {
     uptakeLatencyCap: corpus.options.uptakeLatencyCap,
     scenarios: corpus.scenarios
   });
-  return createHash11("sha256").update(canonical).digest("hex");
+  return createHash12("sha256").update(canonical).digest("hex");
 }
 // src/benchmarks/remnic/memcorrect/schema.ts
@@ -35845,7 +36223,7 @@ import { mkdir as mkdir17, writeFile as writeFile16 } from "fs/promises";
 import path34 from "path";
 // src/benchmarks/remnic/bounded-memory-contracts/fixture.ts
-import { createHash as createHash12 } from "crypto";
+import { createHash as createHash13 } from "crypto";
 var SCOPE_ACME = "project:acme";
 var SCOPE_BETA = "project:beta";
 var SCOPE_ALICE = "user:alice";
@@ -36328,7 +36706,7 @@ var BOUNDED_MEMORY_SMOKE_FIXTURE = [
 function fixtureHash(tasks) {
   const source = tasks ?? BOUNDED_MEMORY_FIXTURE;
   const payload = JSON.stringify(source);
-  return createHash12("sha256").update(payload, "utf8").digest("hex");
+  return createHash13("sha256").update(payload, "utf8").digest("hex");
 }
 // src/benchmarks/remnic/bounded-memory-contracts/agent.ts
@@ -37588,13 +37966,13 @@ function wrapJudgeWithCache(args) {
       // differentiator is part of the prompt hash. Bumping
       // JUDGE_CACHE_PROTOCOL_VERSION invalidates verdicts when judge
       // prompt/parse semantics change (PR #1591, High).
-      judgePromptHash: createHash13("sha256").update(JUDGE_CACHE_PROTOCOL_VERSION).update("").update(args.amaBenchJudgeProtocol).update("").update(args.role).digest("hex"),
+      judgePromptHash: createHash14("sha256").update(JUDGE_CACHE_PROTOCOL_VERSION).update("").update(args.amaBenchJudgeProtocol).update("").update(args.role).digest("hex"),
       judgeModelId: args.provider?.model !== void 0 && args.provider.model.length > 0 ? `${args.provider.model}${crossJudgeIdSuffix}` : `unknown-${args.role}-judge`,
       // Full judge configuration, deterministically serialized (sorted
       // keys) so provider/base-url/retry changes produce fresh cache
       // keys. `role` is included so primary and cross judges never
       // share a paramsHash.
-      judgeParamsHash: createHash13("sha256").update(
+      judgeParamsHash: createHash14("sha256").update(
         stableStringify2({
           role: args.role,
           provider: args.provider
@@ -38300,7 +38678,7 @@ function formatSignedScore(value) {
 }
 // src/stats/locomo-recall-delta.ts
-import { createHash as createHash14 } from "crypto";
+import { createHash as createHash15 } from "crypto";
 import { basename } from "path";
 var LOCOMO_FULL_TASK_COUNT = 1986;
 var LOCOMO_RECALL_EXCERPT_CHARS = 240;
@@ -38781,7 +39159,7 @@ function normalizeText3(value) {
   return value.replaceAll("\r\n", "\n").replaceAll("\r", "\n");
 }
 function sha2562(value) {
-  return createHash14("sha256").update(value).digest("hex");
+  return createHash15("sha256").update(value).digest("hex");
 }
 function stableJson(value) {
   return JSON.stringify(value);
@@ -40219,7 +40597,7 @@ var chatFixture = {
 };
 // src/judges/calibration-slice.ts
-import { createHash as createHash15, randomBytes as randomBytes3 } from "crypto";
+import { createHash as createHash16, randomBytes as randomBytes3 } from "crypto";
 import { chmod as chmod2, lstat as lstat4, mkdir as mkdir18, open as open2, readFile as readFile22, rename as rename4, unlink as unlink4, writeFile as writeFile17 } from "fs/promises";
 import path37 from "path";
@@ -40368,7 +40746,7 @@ function selectCalibrationSlice(questionIds, size = CALIBRATION_SLICE_SIZE) {
       unique.push(id);
     }
   }
-  return unique.map((id) => ({ id, digest: createHash15("sha256").update(id, "utf8").digest("hex") })).sort((a, b) => a.digest < b.digest ? -1 : a.digest > b.digest ? 1 : 0).slice(0, Math.min(size, unique.length)).map((entry) => entry.id);
+  return unique.map((id) => ({ id, digest: createHash16("sha256").update(id, "utf8").digest("hex") })).sort((a, b) => a.digest < b.digest ? -1 : a.digest > b.digest ? 1 : 0).slice(0, Math.min(size, unique.length)).map((entry) => entry.id);
 }
 async function runJudgeCalibration(options) {
   const binScore = options.binScore ?? ((score) => binarizeJudgeScore(score));
@@ -40485,7 +40863,7 @@ function hashOrderedQuestionIds(questionIds) {
   if (questionIds.some((id) => typeof id !== "string" || id.length === 0)) {
     throw new Error("hashOrderedQuestionIds: question ids must be non-empty strings.");
   }
-  return createHash15("sha256").update(JSON.stringify(questionIds), "utf8").digest("hex");
+  return createHash16("sha256").update(JSON.stringify(questionIds), "utf8").digest("hex");
 }
 function validatePinnedQuestionIds(ids, availableIds) {
   if (ids.length === 0 || ids.length > CALIBRATION_SLICE_SIZE || ids.some((id) => typeof id !== "string" || id.length === 0) || new Set(ids).size !== ids.length) {
@@ -40498,7 +40876,7 @@ function validatePinnedQuestionIds(ids, availableIds) {
   return [...ids];
 }
 function hashCalibrationAnswerSet(answers) {
-  return createHash15("sha256").update(JSON.stringify(answers.map((answer) => [
+  return createHash16("sha256").update(JSON.stringify(answers.map((answer) => [
     answer.questionId,
     answer.question,
     answer.predicted,
@@ -40564,7 +40942,7 @@ async function loadOrInitializeCheckpoint(benchmarkId, provenance, sliceQuestion
       frontierJudgeConfigHash: provenance.frontierJudgeConfigHash,
       binningIdentity: provenance.binningIdentity
     };
-    const contractHash = createHash15("sha256").update(stableJson2(contract)).digest("hex");
+    const contractHash = createHash16("sha256").update(stableJson2(contract)).digest("hex");
     let raw;
     try {
       const info = await lstat4(checkpointPath);
@@ -42085,7 +42463,7 @@ function createMitigatedTarget(config) {
 }
 // src/coding-graph/generator.ts
-import { createHash as createHash16 } from "crypto";
+import { createHash as createHash17 } from "crypto";
 function createSeededRng3(seed) {
   let state = seed >>> 0;
   return function rng() {
@@ -42114,7 +42492,7 @@ var EDGE_TYPE_WEIGHTS = [
 var PROVENANCE_VALUES = ["heuristic", "heuristic", "heuristic", "trace"];
 var AVG_BYTES_PER_LINE = 40;
 function hashContent(input) {
-  return createHash16("sha256").update(input).digest("hex").slice(0, 16);
+  return createHash17("sha256").update(input).digest("hex").slice(0, 16);
 }
 function generateSyntheticRepo(config) {
   const rng = createSeededRng3(config.seed);

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@remnic/bench",
-  "version": "9.6.31",
+  "version": "9.6.32",
   "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.31",
-    "@remnic/core": "^9.6.31"
+    "@remnic/coding-graph": "^9.6.32",
+    "@remnic/core": "^9.6.32"
   },
   "devDependencies": {
     "tsup": "^8.5.1",