@remnic/bench 9.6.21 → 9.6.23

package/README.md

@@ -91,12 +91,22 @@ status` to report ChatGPT authentication. A 473-credit safety reserve leaves
 then measure a quick task before choosing a workload bound:
 
 ```bash
+export BUILD_WEEK_RUN_ROOT="$HOME/.remnic/bench/build-week-2026"
+export BUILD_WEEK_RESULTS_DIR="$BUILD_WEEK_RUN_ROOT/results"
+umask 077
+mkdir -p "$BUILD_WEEK_RUN_ROOT" "$BUILD_WEEK_RESULTS_DIR"
+chmod 700 "$BUILD_WEEK_RUN_ROOT" "$BUILD_WEEK_RESULTS_DIR"
+
 export REMNIC_BENCH_CODEX_CREDIT_BUDGET=2473
 export REMNIC_BENCH_CODEX_CREDIT_RESERVE=473
-export REMNIC_BENCH_CODEX_CREDIT_LEDGER="$PWD/.bench-private/codex-credit-ledger.json"
+export REMNIC_BENCH_CODEX_CREDIT_LEDGER="$BUILD_WEEK_RUN_ROOT/codex-credit-ledger.json"
 
-remnic bench run --quick longmemeval \
+remnic bench run longmemeval \
   --runtime-profile real \
+  --limit 1 \
+  --dataset-dir ./bench-datasets/longmemeval \
+  --results-dir "$BUILD_WEEK_RESULTS_DIR" \
+  --drain-timeout 600000 \
   --system-provider codex-cli --system-model gpt-5.6-luna \
   --system-codex-reasoning-effort medium \
   --internal-provider codex-cli --internal-model gpt-5.6-luna \
@@ -106,6 +116,9 @@ remnic bench run --quick longmemeval \
 
 remnic bench run longmemeval \
   --runtime-profile real --limit <LEDGER_DERIVED_LIMIT> \
+  --dataset-dir ./bench-datasets/longmemeval \
+  --results-dir "$BUILD_WEEK_RESULTS_DIR" \
+  --drain-timeout 600000 \
   --system-provider codex-cli --system-model gpt-5.6-luna \
   --system-codex-reasoning-effort medium \
   --internal-provider codex-cli --internal-model gpt-5.6-luna \
@@ -120,10 +133,29 @@ actual `turn.completed` JSONL usage. Stop dispatching at 2,000 spent; the
 473-credit reserve absorbs only a final in-flight call whose exact cost becomes
 known after completion. Missing exact terminal usage blocks the ledger pending
 manual account reconciliation.
+The measured probe is a full-mode run bounded to one staged LongMemEval item.
+Full mode fails before provider dispatch if that explicit dataset directory is
+missing or unreadable, so it cannot fall back to the bundled quick fixture.
+Both commands pin the same gitignored dataset source and do not fall back to
+the CLI-managed dataset store.
 Rates per one million tokens are Luna: 25 input, 2.5 cached input, 150 output;
 Terra: 62.5 input, 6.25 cached input, 375 output. A bounded result is a trial,
 not a full leaderboard artifact.
 
+Codex CLI receives a benchmark-owned 180-second transport timeout when no
+request timeout is supplied. Keep `--request-timeout` out of these commands:
+an explicit value also becomes a whole-phase guard, while the transport-only
+default lets long store/recall/reset phases complete. The 600-second drain cap
+remains explicit for queued internal work.
+
+The ledger and results stay outside the repository because stored runs may
+contain questions, answers, and recalled context. The `umask` plus explicit
+directory modes make newly created state private. After the first ledger write,
+run `chmod 600 "$REMNIC_BENCH_CODEX_CREDIT_LEDGER"`. Preserve the exact run ID
+printed by the CLI, or recover it only from this run store with
+`remnic bench runs list --results-dir "$BUILD_WEEK_RESULTS_DIR"`; use that ID
+for export and artifact promotion rather than an ambiguous “latest” run.
+
 Codex built and adversarially reviewed the Build Week adapter, Responses
 provider, and report card. The underlying Remnic engine and original benchmark
 harness are prior work. The evidence ledger, credit-backed frontier-run

package/dist/index.d.ts

@@ -300,6 +300,12 @@ interface ProviderConfig {
         retryOnTimeout?: boolean;
         max429WaitMs?: number;
     };
+    /**
+     * Provider transport timeout that must not be interpreted as a benchmark
+     * phase timeout. Runtime profiles use this for safe provider defaults while
+     * reserving retryOptions.timeoutMs for an explicit --request-timeout.
+     */
+    providerRequestTimeoutMs?: number;
     disableThinking?: boolean;
     reasoningEffort?: BenchReasoningEffort;
     responderContextBudgetChars?: number;
@@ -1515,12 +1521,29 @@ interface CodexCliNativeUsage {
 interface CodexCreditReceiptScope extends CodexCliNativeUsage {
     calls: number;
     credits: number;
+    unattributedReconciliationCount: number;
+    unattributedReconciledCredits: number;
     models: Array<CodexCliNativeUsage & {
         model: string;
         calls: number;
         credits: number;
     }>;
 }
+interface CodexCreditReconciliationReceipt {
+    schemaVersion: 1;
+    priorLedgerSha256: string;
+    ledgerSha256: string;
+    at: string;
+    attribution: "account-wide-unattributed";
+    affectedRunId: string;
+    originalBudgetCredits: number;
+    priorRecordedSpentCredits: number;
+    observedRemainingCredits: number;
+    unattributedCredits: number;
+    totalSpentCredits: number;
+    totalRemainingCredits: number;
+    affectedBlockedEventSha256: string;
+}
 interface CodexCreditReceipt {
     schemaVersion: 1;
     ledgerSha256: string;
@@ -1535,6 +1558,16 @@ interface CodexCreditReceipt {
         id: string;
     };
 }
+declare function reconcileCodexCreditLedger(args: {
+    ledgerPath: string;
+    priorLedgerSha256: string;
+    observedRemainingCredits: number;
+    originalBudgetBalanceConfirmed: true;
+    noCreditsAddedOrRefundedConfirmed: true;
+    accountWideUnattributedChargeAccepted: true;
+    affectedRunId: string;
+}): Promise<CodexCreditReconciliationReceipt>;
+declare function buildCodexCreditReceipt(ledgerPath: string, runId?: string): Promise<CodexCreditReceipt>;
 
 declare const BENCHMARK_REPRO_MANIFEST_FILENAME = "MANIFEST.json";
 declare const BENCHMARK_REPRO_MANIFEST_SCHEMA_VERSION = 1;
@@ -3054,6 +3087,115 @@ interface DiagnoseLoComoProfileDeltaOptions {
 declare function diagnoseLoComoProfileDelta(options: DiagnoseLoComoProfileDeltaOptions): LoComoProfileDeltaReport;
 declare function renderLoComoProfileDeltaMarkdown(report: LoComoProfileDeltaReport): string;
 
+declare const LOCOMO_FULL_TASK_COUNT = 1986;
+declare const LOCOMO_RECALL_EXCERPT_CHARS = 240;
+declare const LOCOMO_RECALL_DIFF_LINE_LIMIT = 20;
+interface LoComoRawResultEvidence {
+    result: BenchmarkResult;
+    reference: string;
+    /** SHA-256 of the exact result-file bytes, computed before JSON parsing. */
+    sha256: string;
+}
+interface LoComoRecallTextDigest {
+    sha256: string;
+    charCount: number;
+    excerpt: string;
+}
+interface LoComoRecallLineEvidence extends LoComoRecallTextDigest {
+    ordinal: number;
+    sourceRef?: string;
+}
+interface LoComoRecallLineDelta {
+    totalCount: number;
+    shownCount: number;
+    lines: LoComoRecallLineEvidence[];
+}
+interface LoComoRecallContextSummary {
+    sha256: string;
+    charCount: number;
+    lineCount: number;
+    headings: string[];
+    sourceRefs: string[];
+    expectedTokenCoverage: number;
+}
+interface LoComoRecallMetricDelta {
+    baselineMean: number;
+    realMean: number;
+    delta: number;
+    wins: number;
+    losses: number;
+    ties: number;
+}
+interface LoComoRecallCategoryDelta extends LoComoRecallMetricDelta {
+    category: string;
+    taskCount: number;
+}
+interface LoComoFinalContextRegression {
+    taskId: string;
+    category: string;
+    baselineScore: number;
+    realScore: number;
+    delta: number;
+    questionSha256: string;
+    expectedAnswerSha256: string;
+    baseline: {
+        answer: LoComoRecallTextDigest;
+        recall: LoComoRecallContextSummary;
+    };
+    real: {
+        answer: LoComoRecallTextDigest;
+        recall: LoComoRecallContextSummary;
+    };
+    displacedLines: LoComoRecallLineDelta;
+    introducedLines: LoComoRecallLineDelta;
+}
+interface LoComoRecallResultProvenance {
+    reference: string;
+    sha256: string;
+    resultId: string;
+    gitSha: string;
+    remnicVersion: string;
+    runtimeProfile: "baseline" | "real";
+    systemProvider: string;
+    systemModel: string;
+    judgeProvider: string;
+    judgeModel: string;
+    seeds: number[];
+    taskPayloadSha256: string;
+}
+interface LoComoRecallDeltaReport {
+    schemaVersion: 1;
+    benchmarkId: "locomo";
+    comparison: {
+        baseline: LoComoRecallResultProvenance;
+        real: LoComoRecallResultProvenance;
+    };
+    taskCount: number;
+    primaryMetric: string;
+    overall: LoComoRecallMetricDelta;
+    categories: LoComoRecallCategoryDelta[];
+    topRegressions: LoComoFinalContextRegression[];
+    evidenceBoundary: {
+        finalContextComparison: "complete";
+        retrievalTierAttribution: "unavailable-in-cached-results";
+        hiddenEvidenceUsed: false;
+        explanation: string;
+    };
+}
+interface DiagnoseLoComoRecallDeltaOptions {
+    baseline: LoComoRawResultEvidence;
+    real: LoComoRawResultEvidence;
+    primaryMetric?: string;
+    maxRegressions?: number;
+}
+/**
+ * Return a stable provenance label without exposing the caller's directory
+ * layout. CLI callers should use this instead of persisting an input path.
+ */
+declare function sanitizeLoComoResultReference(path: string): string;
+declare function diagnoseLoComoRecallDelta(options: DiagnoseLoComoRecallDeltaOptions): LoComoRecallDeltaReport;
+declare function renderLoComoRecallDeltaMarkdown(report: LoComoRecallDeltaReport): string;
+
 /**
  * Dataset-contamination guard.
  *
@@ -3910,7 +4052,7 @@ interface RunJudgeCalibrationOptions {
      * binning function so they are compared on the same scale.
      */
     binScore?: (score: number) => JudgeCategory;
-    /** Override the slice size (default 50; mainly for tests). */
+    /** Override the slice size (default 200; mainly for tests). */
     sliceSize?: number;
     /** Override the warning threshold (default 0.7). */
     threshold?: number;
@@ -5109,4 +5251,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 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 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, type JudgeCalibrationIdentities, type JudgeCalibrationResult, type JudgeCategory, type KappaConfidenceInterval, LOCAL_LAB_PROVIDER_KINDS, LOCOMO_DATASET_FILENAMES, LONG_MEM_EVAL_DATASET_FILENAMES, type LeaderboardArtifactWrite, type LettaAdapterConfig, LettaMemCorrectAdapter, type LlmJudge, type LlmProvider, type LoComoCategoryDelta, type LoComoMetricDelta, type LoComoProfileArtifactEvidence, type LoComoProfileDeltaReport, 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, 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, discoverAllProviders, discoveryEndpointFor, emailFixture, entityRecall, exactMatch, extractMetrics as extractCodingGraphMetrics, extractMarkdownSectionsByTitle, f1Score, fixtureToAblationScenarios, formatHandoffNote, formatMissingDatasetError, generateReport, generateSyntheticRepo, getAblationCell, getBenchmark, getBenchmarkLowerIsBetter, getMemoryEvalDimension, getRemnicVersion, hashBenchmarkArtifact, hashBytes, hashCanonicalJson, 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, redactBenchmarkResultSecrets, renderBaselineMarkdown, renderBenchmarkResultExport, renderLoComoProfileDeltaMarkdown, renderMemorySummaryForJudge, renderMemoryViewForAgent, resolveAssistantAgent, resolveAssistantRubricId, resolveAssistantSeeds, resolveAssistantSpotCheckDir, resolveBenchRuntimeProfile, resolveBenchmarkPhaseTimeoutMs, resolveBenchmarkProgressLogging, resolveBenchmarkResultReference, resolveBenchmarkRunCount, resolveLocalLabProfile, resolveLocalLabRole, resolveStructuredJudge, rotateDistractors, rougeL, runAssistantBenchmark, runAssistantMeetingPrepBenchmark, runAssistantMorningBriefBenchmark, runAssistantNextBestActionBenchmark, runAssistantSynthesisBenchmark, runBaseline, runBenchSuite, runBenchmark, runCodingGraphBenchmark, runCustomBenchmarkFile, runExplain, runExtractionAttack, runJudgeCalibration, runMitigatedBaseline, runProceduralAblation, runProceduralAblationCli, runSealedJudge, runSequentialPhases, safeHexEqual, 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 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, 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, getRemnicVersion, hashBenchmarkArtifact, hashBytes, hashCanonicalJson, 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, 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

@@ -5509,6 +5509,7 @@ import { mkdir as mkdir2, open, readFile as readFile3, rename as rename2, rmdir,
 import os from "os";
 import path3 from "path";
 var ONE_MILLION = 1e6;
+var CREDIT_EPSILON = 1e-9;
 var MAX_BOUNDED_CALL_CREDITS = 300;
 var SOL_MODEL = /^gpt-5\.6-sol$/i;
 var CREDIT_RATES = [
@@ -5534,6 +5535,123 @@ var CodexCreditDispatchError = class extends Error {
     this.name = "CodexCreditDispatchError";
   }
 };
+async function reconcileCodexCreditLedger(args) {
+  if (args.originalBudgetBalanceConfirmed !== true) {
+    throw new Error(
+      "Codex credit reconciliation requires confirmation that the observed balance belongs to the ledger's original budget"
+    );
+  }
+  if (args.noCreditsAddedOrRefundedConfirmed !== true) {
+    throw new Error(
+      "Codex credit reconciliation requires confirmation that no credits were added or refunded after the original budget was established"
+    );
+  }
+  if (args.accountWideUnattributedChargeAccepted !== true) {
+    throw new Error(
+      "Codex credit reconciliation requires acknowledgment that all unexplained account activity will be charged as account-wide unattributed spend"
+    );
+  }
+  if (!isSha256(args.priorLedgerSha256)) {
+    throw new Error("priorLedgerSha256 must be a lowercase SHA-256 digest");
+  }
+  if (!Number.isFinite(args.observedRemainingCredits) || args.observedRemainingCredits < 0) {
+    throw new Error("observedRemainingCredits must be a finite non-negative number");
+  }
+  const affectedRunId = parseRequiredRunId(args.affectedRunId, "affectedRunId");
+  const ledgerPath = path3.resolve(expandHomeRelativePath(args.ledgerPath));
+  const previous = completionQueue;
+  let release;
+  completionQueue = new Promise((resolve) => {
+    release = resolve;
+  });
+  await previous;
+  const lockPath = `${ledgerPath}.lock`;
+  let lock;
+  try {
+    await mkdir2(path3.dirname(lockPath), { recursive: true, mode: 448 });
+    lock = await acquireLedgerLock(lockPath);
+    const contents = await readFile3(ledgerPath);
+    const currentSha256 = sha256(contents);
+    if (currentSha256 !== args.priorLedgerSha256) {
+      throw new Error(
+        `Codex credit ledger changed since operator observation: expected ${args.priorLedgerSha256}, found ${currentSha256}; obtain a fresh ledger hash and remaining balance`
+      );
+    }
+    const ledger = parseLedger(JSON.parse(contents.toString("utf8")));
+    if (!ledger.blockedReason) {
+      throw new Error("Codex credit ledger is not blocked; reconciliation is not permitted");
+    }
+    if (args.observedRemainingCredits > ledger.budgetCredits) {
+      throw new Error("observedRemainingCredits cannot exceed the ledger budget");
+    }
+    const rawUnattributedCredits = ledger.budgetCredits - args.observedRemainingCredits - ledger.spentCredits;
+    if (!Number.isFinite(rawUnattributedCredits) || rawUnattributedCredits < -CREDIT_EPSILON) {
+      throw new Error(
+        "observedRemainingCredits implies less spend than the ledger already records; reconciliation refused"
+      );
+    }
+    const unattributedCredits = Math.abs(rawUnattributedCredits) <= CREDIT_EPSILON ? 0 : rawUnattributedCredits;
+    const observedSpentCredits = ledger.spentCredits + unattributedCredits;
+    const at = (/* @__PURE__ */ new Date()).toISOString();
+    const reconciliation = {
+      at,
+      basis: "operator-observed-original-budget-balance",
+      attribution: "account-wide-unattributed",
+      priorLedgerSha256: currentSha256,
+      originalBudgetCredits: ledger.budgetCredits,
+      priorRecordedSpentCredits: ledger.spentCredits,
+      observedRemainingCredits: args.observedRemainingCredits,
+      credits: normalizeZero(unattributedCredits),
+      confirmations: {
+        observedBalanceBelongsToOriginalBudget: true,
+        noCreditsAddedOrRefunded: true,
+        accountWideUnattributedChargeAccepted: true
+      },
+      affectedBlockedEvent: {
+        runId: affectedRunId,
+        blockedReason: ledger.blockedReason
+      }
+    };
+    const nextLedger = {
+      ...ledger,
+      spentCredits: observedSpentCredits,
+      reconciliations: [...ledger.reconciliations ?? [], reconciliation],
+      blockedReason: void 0
+    };
+    await writeLedger(ledgerPath, nextLedger);
+    await writeLockState(lock, "settled");
+    const nextContents = await readFile3(ledgerPath);
+    return {
+      schemaVersion: 1,
+      priorLedgerSha256: currentSha256,
+      ledgerSha256: sha256(nextContents),
+      at,
+      attribution: "account-wide-unattributed",
+      affectedRunId,
+      originalBudgetCredits: ledger.budgetCredits,
+      priorRecordedSpentCredits: ledger.spentCredits,
+      observedRemainingCredits: args.observedRemainingCredits,
+      unattributedCredits: reconciliation.credits,
+      totalSpentCredits: observedSpentCredits,
+      totalRemainingCredits: args.observedRemainingCredits,
+      affectedBlockedEventSha256: sha256(
+        JSON.stringify(reconciliation.affectedBlockedEvent)
+      )
+    };
+  } finally {
+    try {
+      if (lock) {
+        try {
+          await lock.close();
+        } finally {
+          await removeOwnedLedgerLock(lockPath);
+        }
+      }
+    } finally {
+      release();
+    }
+  }
+}
 function resolveCodexCreditBudgetConfig(env = process.env, fallbackRunId) {
   const rawBudget = env.REMNIC_BENCH_CODEX_CREDIT_BUDGET?.trim();
   if (!rawBudget) return void 0;
@@ -5793,11 +5911,12 @@ async function buildCodexCreditReceipt(ledgerPath, runId) {
   const contents = await readFile3(resolvedPath);
   const ledger = parseLedger(JSON.parse(contents.toString("utf8")));
   const normalizedRunId = parseOptionalRunId(runId);
-  const cumulative = summarizeLedgerEntries(ledger.entries);
+  const reconciliations = ledger.reconciliations ?? [];
+  const cumulative = summarizeLedgerEntries(ledger.entries, reconciliations);
   const runEntries = normalizedRunId ? ledger.entries.filter((entry) => entry.runId === normalizedRunId) : [];
   return {
     schemaVersion: 1,
-    ledgerSha256: createHash3("sha256").update(contents).digest("hex"),
+    ledgerSha256: sha256(contents),
     budgetCredits: ledger.budgetCredits,
     reserveCredits: ledger.reserveCredits,
     plannedSpendCeilingCredits: ledger.budgetCredits - ledger.reserveCredits,
@@ -5805,7 +5924,12 @@ async function buildCodexCreditReceipt(ledgerPath, runId) {
     totalRemainingCredits: ledger.budgetCredits - ledger.spentCredits,
     blocked: ledger.blockedReason !== void 0,
     cumulative,
-    ...normalizedRunId ? { run: { id: normalizedRunId, ...summarizeLedgerEntries(runEntries) } } : {}
+    ...normalizedRunId ? {
+      run: {
+        id: normalizedRunId,
+        ...summarizeLedgerEntries(runEntries)
+      }
+    } : {}
   };
 }
 function resolveRate(model) {
@@ -5852,11 +5976,36 @@ function parseLedger(parsed) {
     (sum, entry) => sum + (typeof entry?.credits === "number" ? entry.credits ?? 0 : 0),
     0
   ) : Number.NaN;
-  if (parsed.schemaVersion !== 1 || typeof parsed.budgetCredits !== "number" || !Number.isFinite(parsed.budgetCredits) || parsed.budgetCredits <= 0 || typeof parsed.reserveCredits !== "number" || !Number.isFinite(parsed.reserveCredits) || parsed.reserveCredits < 0 || parsed.reserveCredits >= parsed.budgetCredits || typeof parsed.spentCredits !== "number" || !Number.isFinite(parsed.spentCredits) || parsed.spentCredits < 0 || !Array.isArray(parsed.entries) || !parsed.entries.every(isLedgerEntry) || Math.abs(entryCredits - parsed.spentCredits) > 1e-9 || parsed.blockedReason !== void 0 && typeof parsed.blockedReason !== "string") {
+  const reconciliationCredits = parsed.reconciliations === void 0 ? 0 : Array.isArray(parsed.reconciliations) ? parsed.reconciliations.reduce(
+    (sum, reconciliation) => sum + (typeof reconciliation?.credits === "number" ? reconciliation.credits ?? 0 : 0),
+    0
+  ) : Number.NaN;
+  if (parsed.schemaVersion !== 1 || typeof parsed.budgetCredits !== "number" || !Number.isFinite(parsed.budgetCredits) || parsed.budgetCredits <= 0 || typeof parsed.reserveCredits !== "number" || !Number.isFinite(parsed.reserveCredits) || parsed.reserveCredits < 0 || parsed.reserveCredits >= parsed.budgetCredits || typeof parsed.spentCredits !== "number" || !Number.isFinite(parsed.spentCredits) || parsed.spentCredits < 0 || !Array.isArray(parsed.entries) || !parsed.entries.every(isLedgerEntry) || parsed.reconciliations !== void 0 && (!Array.isArray(parsed.reconciliations) || !parsed.reconciliations.every(
+    (reconciliation) => isLedgerReconciliationWithinBudget(reconciliation, parsed.budgetCredits)
+  )) || Math.abs(entryCredits + reconciliationCredits - parsed.spentCredits) > 1e-9 || parsed.blockedReason !== void 0 && typeof parsed.blockedReason !== "string") {
     throw new Error("ledger schema is invalid");
   }
   return parsed;
 }
+function isLedgerReconciliation(value) {
+  if (!value || typeof value !== "object") return false;
+  const candidate = value;
+  const forbiddenUsageFields = [
+    "runId",
+    "unknownEvent",
+    "model",
+    "inputTokens",
+    "cachedInputTokens",
+    "outputTokens",
+    "reasoningOutputTokens"
+  ];
+  return forbiddenUsageFields.every((field) => !Object.prototype.hasOwnProperty.call(candidate, field)) && isIsoTimestamp(candidate.at) && candidate.basis === "operator-observed-original-budget-balance" && candidate.attribution === "account-wide-unattributed" && isSha256(candidate.priorLedgerSha256) && typeof candidate.originalBudgetCredits === "number" && Number.isFinite(candidate.originalBudgetCredits) && candidate.originalBudgetCredits > 0 && typeof candidate.priorRecordedSpentCredits === "number" && Number.isFinite(candidate.priorRecordedSpentCredits) && candidate.priorRecordedSpentCredits >= 0 && typeof candidate.observedRemainingCredits === "number" && Number.isFinite(candidate.observedRemainingCredits) && candidate.observedRemainingCredits >= 0 && typeof candidate.credits === "number" && Number.isFinite(candidate.credits) && candidate.credits >= 0 && candidate.confirmations?.observedBalanceBelongsToOriginalBudget === true && candidate.confirmations.noCreditsAddedOrRefunded === true && candidate.confirmations.accountWideUnattributedChargeAccepted === true && isValidStoredRunId(candidate.affectedBlockedEvent?.runId) && typeof candidate.affectedBlockedEvent?.blockedReason === "string" && candidate.affectedBlockedEvent.blockedReason.length > 0;
+}
+function isLedgerReconciliationWithinBudget(value, budget) {
+  return typeof budget === "number" && isLedgerReconciliation(value) && value.originalBudgetCredits === budget && value.observedRemainingCredits <= budget && value.credits <= budget && Math.abs(
+    value.priorRecordedSpentCredits + value.credits + value.observedRemainingCredits - budget
+  ) <= 1e-9;
+}
 function isLedgerEntry(entry) {
   if (!entry || typeof entry !== "object") return false;
   const candidate = entry;
@@ -5869,7 +6018,7 @@ function isEntryCreditConsistent(entry) {
     return false;
   }
 }
-function summarizeLedgerEntries(entries) {
+function summarizeLedgerEntries(entries, reconciliations = []) {
   const byModel = /* @__PURE__ */ new Map();
   for (const entry of entries) {
     const modelEntries = byModel.get(entry.model) ?? [];
@@ -5879,7 +6028,12 @@ function summarizeLedgerEntries(entries) {
   const totals = summarizeUsage(entries);
   return {
     calls: entries.length,
-    credits: entries.reduce((sum, entry) => sum + entry.credits, 0),
+    credits: entries.reduce((sum, entry) => sum + entry.credits, 0) + reconciliations.reduce((sum, reconciliation) => sum + reconciliation.credits, 0),
+    unattributedReconciliationCount: reconciliations.length,
+    unattributedReconciledCredits: reconciliations.reduce(
+      (sum, reconciliation) => sum + reconciliation.credits,
+      0
+    ),
     ...totals,
     models: [...byModel.entries()].sort(([left], [right]) => left.localeCompare(right)).map(([model, modelEntries]) => ({
       model,
@@ -5958,6 +6112,30 @@ function hasControlCharacters(value) {
   }
   return false;
 }
+function parseRequiredRunId(value, name) {
+  const runId = value?.trim();
+  if (!runId || !isValidStoredRunId(runId)) {
+    throw new Error(`${name} must be 1 to 128 trimmed characters without control characters`);
+  }
+  return runId;
+}
+function isSha256(value) {
+  return typeof value === "string" && /^[a-f0-9]{64}$/.test(value);
+}
+function sha256(value) {
+  return createHash3("sha256").update(value).digest("hex");
+}
+function normalizeZero(value) {
+  return Object.is(value, -0) ? 0 : value;
+}
+function isIsoTimestamp(value) {
+  if (typeof value !== "string") return false;
+  try {
+    return new Date(value).toISOString() === value;
+  } catch {
+    return false;
+  }
+}
 
 // src/results-store.ts
 import { mkdir as mkdir3, readdir as readdir3, readFile as readFile4, unlink as unlink3, writeFile as writeFile3 } from "fs/promises";
@@ -14553,6 +14731,8 @@ function resolveOpenClawRemnicPluginEntry(raw) {
 }
 var REDACTED_CONFIG_VALUE = "[redacted]";
 var INTERNAL_GATEWAY_AGENT_ID = "remnic-bench-internal";
+var DEFAULT_CODEX_CLI_REQUEST_TIMEOUT_MS = 18e4;
+var DEFAULT_CODEX_CLI_DRAIN_TIMEOUT_MS = 6e5;
 var codexCliFallbackRegistered = false;
 var codexCliFallbackChain = Promise.resolve();
 async function resolveBenchRuntimeProfile(options) {
@@ -14606,8 +14786,11 @@ async function resolveBenchRuntimeProfile(options) {
     { disableThinking: options.internalDisableThinking === true }
   );
   const lcmObserveConcurrencyOverrides = buildLcmObserveConcurrencyOverrides(options.lcmObserveConcurrency);
+  const usesImplicitCodexRequestTimeout = options.requestTimeout === void 0 && [systemProvider, judgeProvider, internalProvider].some(
+    (config) => config?.provider === "codex-cli"
+  );
   const drainTimeoutMs = normalizeDrainTimeoutMs2(
-    options.drainTimeout ?? options.requestTimeout
+    options.drainTimeout ?? options.requestTimeout ?? (usesImplicitCodexRequestTimeout ? DEFAULT_CODEX_CLI_DRAIN_TIMEOUT_MS : void 0)
   );
   registerCodexCliFallbackRunnerIfNeeded(internalProvider);
   const responderFactoryConfig = systemProvider ? asProviderFactoryConfig(systemProvider) : void 0;
@@ -14819,6 +15002,7 @@ function resolveProviderConfig(kind, provider, model, baseUrl, requestTimeout, d
       `${kind} Codex reasoning effort requires provider "codex-cli"`
     );
   }
+  const providerRequestTimeoutMs = requestTimeout === void 0 && provider === "codex-cli" ? DEFAULT_CODEX_CLI_REQUEST_TIMEOUT_MS : void 0;
   return {
     provider,
     model: resolvedModel.trim(),
@@ -14829,6 +15013,7 @@ function resolveProviderConfig(kind, provider, model, baseUrl, requestTimeout, d
       ...requestTimeout != null ? { timeoutMs: requestTimeout } : {},
       ...max429WaitMs != null ? { max429WaitMs } : {}
     } } : {},
+    ...providerRequestTimeoutMs !== void 0 ? { providerRequestTimeoutMs } : {},
     ...disableThinking ? { disableThinking: true } : {},
     ...provider === "codex-cli" ? { reasoningEffort: reasoningEffort ?? "xhigh" } : {},
     ...responderContextBudgetChars !== void 0 ? { responderContextBudgetChars } : {},
@@ -14884,13 +15069,14 @@ function buildInternalRemnicConfigOverrides(config, options) {
       ...config.retryOptions?.timeoutMs ? { localLlmTimeoutMs: config.retryOptions.timeoutMs } : {}
     };
   }
+  const providerTimeoutMs = config.retryOptions?.timeoutMs ?? config.providerRequestTimeoutMs;
   return {
     ...thinkingOverrides,
     modelSource: "gateway",
     localLlmEnabled: false,
-    ...config.retryOptions?.timeoutMs ? {
-      localLlmTimeoutMs: config.retryOptions.timeoutMs,
-      localLlmFastTimeoutMs: config.retryOptions.timeoutMs
+    ...providerTimeoutMs ? {
+      localLlmTimeoutMs: providerTimeoutMs,
+      localLlmFastTimeoutMs: providerTimeoutMs
     } : {},
     gatewayConfig: buildInternalGatewayConfig(config, options),
     gatewayAgentId: INTERNAL_GATEWAY_AGENT_ID,
@@ -14900,7 +15086,7 @@ function buildInternalRemnicConfigOverrides(config, options) {
 function buildInternalGatewayConfig(config, options) {
   const providerId = INTERNAL_GATEWAY_AGENT_ID;
   const modelRef = `${providerId}/${config.model}`;
-  const timeoutMs = config.retryOptions?.timeoutMs;
+  const timeoutMs = config.retryOptions?.timeoutMs ?? config.providerRequestTimeoutMs;
   return {
     agents: {
       defaults: {
@@ -15086,12 +15272,16 @@ function createAssistantAgentFromResponder2(responder) {
   };
 }
 function asProviderFactoryConfig(config) {
+  const retryOptions = config.retryOptions || config.providerRequestTimeoutMs !== void 0 ? {
+    ...config.retryOptions,
+    ...config.retryOptions?.timeoutMs === void 0 && config.providerRequestTimeoutMs !== void 0 ? { timeoutMs: config.providerRequestTimeoutMs } : {}
+  } : void 0;
   return {
     provider: config.provider,
     model: config.model,
     ...config.baseUrl ? { baseUrl: config.baseUrl } : {},
     ...config.apiKey ? { apiKey: config.apiKey } : {},
-    ...config.retryOptions ? { retryOptions: config.retryOptions } : {},
+    ...retryOptions ? { retryOptions } : {},
     ...config.disableThinking ? { disableThinking: config.disableThinking } : {},
     ...config.reasoningEffort ? { reasoningEffort: config.reasoningEffort } : {},
     ...config.temperature !== void 0 ? { temperature: config.temperature } : {},
@@ -32094,9 +32284,9 @@ 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 sha256 = createHash9("sha256").update(prompt, "utf8").digest("hex");
+  const sha2563 = createHash9("sha256").update(prompt, "utf8").digest("hex");
   const version = parseVersionFromId(id);
-  return { id, version, prompt, sha256 };
+  return { id, version, prompt, sha256: sha2563 };
 }
 function verifyRubricDigest(expectedSha256, options = {}) {
   const rubric = loadSealedRubric(options.id, { registry: options.registry });
@@ -38030,6 +38220,523 @@ function formatSignedScore(value) {
   return `${value >= 0 ? "+" : ""}${formatScore(value)}`;
 }
 
+// src/stats/locomo-recall-delta.ts
+import { createHash as createHash13 } from "crypto";
+import { basename } from "path";
+var LOCOMO_FULL_TASK_COUNT = 1986;
+var LOCOMO_RECALL_EXCERPT_CHARS = 240;
+var LOCOMO_RECALL_DIFF_LINE_LIMIT = 20;
+var LOCOMO_CATEGORY_ORDER2 = ["single_hop", "multi_hop", "temporal", "open_domain", "adversarial"];
+var LOCOMO_TASK_CATEGORY_PATTERN2 = /-(single_hop|multi_hop|temporal|open_domain|adversarial)$/;
+var SOURCE_TURN_PATTERN = /^\[([^,\]\s]+),\s*turn\s+(\d+),\s*([^,\]]+?)(?:,\s*score\s+[^\]]+)?\]/i;
+var SHA256_PATTERN = /^[a-f0-9]{64}$/;
+function sanitizeLoComoResultReference(path40) {
+  const reference = basename(path40).replace(/[\u0000-\u001f\u007f`]/g, "_");
+  if (!reference) throw new Error("Result path must identify a file.");
+  return reference;
+}
+function diagnoseLoComoRecallDelta(options) {
+  const primaryMetric2 = options.primaryMetric ?? "llm_judge";
+  const maxRegressions = parseNonNegativeInteger(options.maxRegressions ?? 20, "maxRegressions");
+  assertEvidenceEnvelope(options.baseline, "baseline");
+  assertEvidenceEnvelope(options.real, "real");
+  assertCompleteResult(options.baseline.result, "baseline");
+  assertCompleteResult(options.real.result, "real");
+  assertComparableResults(options.baseline.result, options.real.result);
+  const joined = joinTasks2(options.baseline.result, options.real.result);
+  assertMetricSets(joined, primaryMetric2);
+  verifyAggregateMeans(options.baseline.result, joined, "baseline");
+  verifyAggregateMeans(options.real.result, joined, "real");
+  const overall = summarizeMetric(joined, primaryMetric2);
+  const categories = [...new Set(joined.map((task) => task.category))].sort(compareLoComoCategories2).map((category) => {
+    const tasks = joined.filter((task) => task.category === category);
+    return {
+      category,
+      taskCount: tasks.length,
+      ...summarizeMetric(tasks, primaryMetric2)
+    };
+  });
+  const topRegressions = joined.map((task) => buildRegression(task, primaryMetric2, LOCOMO_RECALL_EXCERPT_CHARS, LOCOMO_RECALL_DIFF_LINE_LIMIT)).filter((task) => task.delta < 0).sort((left, right) => left.delta - right.delta || compareStrings(left.taskId, right.taskId)).slice(0, maxRegressions);
+  return {
+    schemaVersion: 1,
+    benchmarkId: "locomo",
+    comparison: {
+      baseline: buildProvenance(options.baseline, "baseline", joined, "baseline"),
+      real: buildProvenance(options.real, "real", joined, "real")
+    },
+    taskCount: joined.length,
+    primaryMetric: primaryMetric2,
+    overall,
+    categories,
+    topRegressions,
+    evidenceBoundary: {
+      finalContextComparison: "complete",
+      retrievalTierAttribution: "unavailable-in-cached-results",
+      hiddenEvidenceUsed: false,
+      explanation: "Cached BenchmarkResult files preserve the final transformed recall context, but not pre-transform candidates, section provenance, filter traces, or served-by tiers."
+    }
+  };
+}
+function renderLoComoRecallDeltaMarkdown(report) {
+  const lines = [
+    "# LoCoMo paired final-context diagnosis",
+    "",
+    `Joined ${report.taskCount} complete paired tasks. The primary metric is \`${report.primaryMetric}\` (real minus baseline).`,
+    "",
+    "| Category | Tasks | Baseline | Real | Delta | Wins | Losses | Ties |",
+    "|---|---:|---:|---:|---:|---:|---:|---:|"
+  ];
+  for (const category of report.categories) {
+    lines.push(
+      `| ${escapeMarkdownCell(category.category)} | ${category.taskCount} | ${formatScore2(category.baselineMean)} | ${formatScore2(category.realMean)} | ${formatSignedScore2(category.delta)} | ${category.wins} | ${category.losses} | ${category.ties} |`
+    );
+  }
+  lines.push(
+    `| **Overall** | **${report.taskCount}** | **${formatScore2(report.overall.baselineMean)}** | **${formatScore2(report.overall.realMean)}** | **${formatSignedScore2(report.overall.delta)}** | **${report.overall.wins}** | **${report.overall.losses}** | **${report.overall.ties}** |`,
+    "",
+    "## Highest-priority final-context regressions",
+    ""
+  );
+  for (const task of report.topRegressions) {
+    lines.push(
+      `### ${escapeMarkdownCell(task.taskId)}`,
+      "",
+      `Category: \`${task.category}\`; baseline ${formatScore2(task.baselineScore)}, real ${formatScore2(task.realScore)}, delta ${formatSignedScore2(task.delta)}.`,
+      "",
+      `Recall: baseline ${task.baseline.recall.charCount} chars (expected-token coverage ${formatScore2(task.baseline.recall.expectedTokenCoverage)}), real ${task.real.recall.charCount} chars (coverage ${formatScore2(task.real.recall.expectedTokenCoverage)}).`,
+      "",
+      `Displaced lines: ${task.displacedLines.totalCount}; introduced lines: ${task.introducedLines.totalCount}.`,
+      ""
+    );
+    const displaced = task.displacedLines.lines[0];
+    if (displaced) {
+      lines.push(
+        `- Baseline-only evidence: ${escapeMarkdownCell(displaced.excerpt)} (sha256 \`${displaced.sha256}\`)`
+      );
+    }
+    const introduced = task.introducedLines.lines[0];
+    if (introduced) {
+      lines.push(
+        `- Real-only evidence: ${escapeMarkdownCell(introduced.excerpt)} (sha256 \`${introduced.sha256}\`)`
+      );
+    }
+    if (displaced || introduced) lines.push("");
+  }
+  lines.push(
+    "## Evidence boundary",
+    "",
+    "The final responder contexts are compared completely by hash, length, headings, source references, and bounded line-difference receipts. Retrieval-tier attribution is unavailable because the cached results do not preserve served-by or candidate traces. Hidden `details.evidence` metadata is not read or emitted.",
+    "",
+    `Baseline: \`${report.comparison.baseline.reference}\` (sha256 \`${report.comparison.baseline.sha256}\`)`,
+    "",
+    `Real: \`${report.comparison.real.reference}\` (sha256 \`${report.comparison.real.sha256}\`)`,
+    ""
+  );
+  return `${lines.join("\n")}
+`;
+}
+function assertEvidenceEnvelope(evidence, label) {
+  if (!evidence.reference.trim()) {
+    throw new Error(`${label} result reference must not be empty.`);
+  }
+  if (!SHA256_PATTERN.test(evidence.sha256)) {
+    throw new Error(`${label} result sha256 must be 64 lowercase hexadecimal characters.`);
+  }
+}
+function assertCompleteResult(result, label) {
+  if (result.meta.benchmark !== "locomo") {
+    throw new Error(`${label} result must be a locomo benchmark result.`);
+  }
+  if (result.meta.mode !== "full" || result.meta.status === "partial") {
+    throw new Error(`${label} result must be a complete full-mode run.`);
+  }
+  if (!result.config.systemProvider || !result.config.judgeProvider) {
+    throw new Error(`${label} result must identify both system and judge providers.`);
+  }
+  const limit = result.config.benchmarkOptions?.limit;
+  const trialLimit = result.config.benchmarkOptions?.trialLimit;
+  if (limit !== void 0 || trialLimit !== void 0) {
+    throw new Error(`${label} result is limited and cannot be used as complete evidence.`);
+  }
+  if (result.results.tasks.length !== LOCOMO_FULL_TASK_COUNT) {
+    throw new Error(
+      `${label} result must contain exactly ${LOCOMO_FULL_TASK_COUNT} tasks; got ${result.results.tasks.length}.`
+    );
+  }
+  for (const task of result.results.tasks) {
+    const details = asRecord(task.details);
+    const failure = details?.benchmarkFailure;
+    const legacyError = details?.error;
+    if (failure !== void 0 && failure !== null || typeof legacyError === "string" && legacyError.length > 0) {
+      throw new Error(`${label} result contains failed task ${JSON.stringify(task.taskId)}.`);
+    }
+  }
+}
+function assertComparableResults(baseline, real) {
+  if (baseline.config.runtimeProfile !== "baseline") {
+    throw new Error('baseline result runtimeProfile must be "baseline".');
+  }
+  if (real.config.runtimeProfile !== "real") {
+    throw new Error('real result runtimeProfile must be "real".');
+  }
+  const checks = [
+    ["meta.version", baseline.meta.version, real.meta.version],
+    ["meta.remnicVersion", baseline.meta.remnicVersion, real.meta.remnicVersion],
+    ["meta.gitSha", baseline.meta.gitSha, real.meta.gitSha],
+    ["meta.runCount", baseline.meta.runCount, real.meta.runCount],
+    ["meta.seeds", baseline.meta.seeds, real.meta.seeds],
+    ["meta.datasetHash", baseline.meta.datasetHash ?? null, real.meta.datasetHash ?? null],
+    ["config.adapterMode", baseline.config.adapterMode, real.config.adapterMode],
+    [
+      "config.systemProvider",
+      providerIdentity(baseline.config.systemProvider),
+      providerIdentity(real.config.systemProvider)
+    ],
+    [
+      "config.judgeProvider",
+      providerIdentity(baseline.config.judgeProvider),
+      providerIdentity(real.config.judgeProvider)
+    ],
+    [
+      "config.internalProvider",
+      providerIdentity(baseline.config.internalProvider),
+      providerIdentity(real.config.internalProvider)
+    ]
+  ];
+  for (const [field, baselineValue, realValue] of checks) {
+    if (stableJson(baselineValue) !== stableJson(realValue)) {
+      throw new Error(
+        `Results are not comparable: ${field} differs (${stableJson(baselineValue)} vs ${stableJson(realValue)}).`
+      );
+    }
+  }
+}
+function joinTasks2(baseline, real) {
+  const baselineTasks = indexTasks2(baseline.results.tasks, "baseline");
+  const realTasks = indexTasks2(real.results.tasks, "real");
+  const missingFromReal = [...baselineTasks.keys()].filter((id) => !realTasks.has(id)).sort(compareStrings);
+  const missingFromBaseline = [...realTasks.keys()].filter((id) => !baselineTasks.has(id)).sort(compareStrings);
+  if (missingFromReal.length > 0 || missingFromBaseline.length > 0) {
+    throw new Error(
+      `Results do not contain identical task-id sets: ${missingFromReal.length} missing from real, ${missingFromBaseline.length} missing from baseline.`
+    );
+  }
+  return [...baselineTasks.keys()].sort(compareStrings).map((taskId) => {
+    const baselineTask = baselineTasks.get(taskId);
+    const realTask = realTasks.get(taskId);
+    if (!baselineTask || !realTask) {
+      throw new Error(`Task ${JSON.stringify(taskId)} disappeared during the validated join.`);
+    }
+    for (const [field, baselineValue, realValue] of [
+      ["question", baselineTask.question, realTask.question],
+      ["expected", baselineTask.expected, realTask.expected]
+    ]) {
+      if (baselineValue !== realValue) {
+        throw new Error(`Task ${JSON.stringify(taskId)} has mismatched ${field} payloads.`);
+      }
+    }
+    const baselineCategory = resolveCategory2(baselineTask);
+    const realCategory = resolveCategory2(realTask);
+    if (baselineCategory !== realCategory) {
+      throw new Error(`Task ${JSON.stringify(taskId)} has mismatched categories.`);
+    }
+    return { taskId, category: baselineCategory, baseline: baselineTask, real: realTask };
+  });
+}
+function indexTasks2(tasks, label) {
+  const result = /* @__PURE__ */ new Map();
+  for (const task of tasks) {
+    if (!task.taskId || result.has(task.taskId)) {
+      throw new Error(`${label} result contains duplicate or empty task id ${JSON.stringify(task.taskId)}.`);
+    }
+    if (!task.question || !task.expected) {
+      throw new Error(`${label} task ${JSON.stringify(task.taskId)} has an empty question or expected answer.`);
+    }
+    const recalledText = asRecord(task.details)?.recalledText;
+    if (typeof recalledText !== "string") {
+      throw new Error(`${label} task ${JSON.stringify(task.taskId)} has no final recalledText.`);
+    }
+    result.set(task.taskId, task);
+  }
+  return result;
+}
+function assertMetricSets(joined, primaryMetric2) {
+  const first = joined[0];
+  if (!first) throw new Error("Cannot validate metric sets for an empty paired result.");
+  const expectedMetrics = Object.keys(first.baseline.scores).sort(compareStrings);
+  for (const task of joined) {
+    const baselineMetrics = Object.keys(task.baseline.scores).sort(compareStrings);
+    const realMetrics = Object.keys(task.real.scores).sort(compareStrings);
+    if (stableJson(baselineMetrics) !== stableJson(realMetrics)) {
+      throw new Error(`Task ${JSON.stringify(task.taskId)} has mismatched metric sets.`);
+    }
+    if (stableJson(baselineMetrics) !== stableJson(expectedMetrics)) {
+      throw new Error(`Task ${JSON.stringify(task.taskId)} has an inconsistent metric set.`);
+    }
+    if (!baselineMetrics.includes(primaryMetric2)) {
+      throw new Error(`Task ${JSON.stringify(task.taskId)} is missing metric ${JSON.stringify(primaryMetric2)}.`);
+    }
+    for (const [side, scores] of [
+      ["baseline", task.baseline.scores],
+      ["real", task.real.scores]
+    ]) {
+      for (const [metric, score] of Object.entries(scores)) {
+        if (!Number.isFinite(score)) {
+          throw new Error(`${side} task ${JSON.stringify(task.taskId)} metric ${metric} is not finite.`);
+        }
+      }
+    }
+  }
+}
+function buildRegression(task, metric, excerptChars, maxDiffLines) {
+  const baselineRecall = finalRecallText(task.baseline);
+  const realRecall = finalRecallText(task.real);
+  const baselineLines = contentLines(baselineRecall);
+  const realLines = contentLines(realRecall);
+  const displaced = subtractLineMultiset(baselineLines, realLines);
+  const introduced = subtractLineMultiset(realLines, baselineLines);
+  const baselineScore = requireMetricScore(task.baseline, metric, "baseline");
+  const realScore = requireMetricScore(task.real, metric, "real");
+  return {
+    taskId: task.taskId,
+    category: task.category,
+    baselineScore,
+    realScore,
+    delta: realScore - baselineScore,
+    questionSha256: sha2562(normalizeText3(task.baseline.question)),
+    expectedAnswerSha256: sha2562(normalizeText3(task.baseline.expected)),
+    baseline: {
+      answer: textDigest(task.baseline.actual, excerptChars),
+      recall: recallSummary(baselineRecall, task.baseline.expected)
+    },
+    real: {
+      answer: textDigest(task.real.actual, excerptChars),
+      recall: recallSummary(realRecall, task.real.expected)
+    },
+    displacedLines: lineDelta(displaced, maxDiffLines, excerptChars),
+    introducedLines: lineDelta(introduced, maxDiffLines, excerptChars)
+  };
+}
+function buildProvenance(evidence, profile, joined, side) {
+  const system = requireProvider(evidence.result.config.systemProvider, profile, "system");
+  const judge = requireProvider(evidence.result.config.judgeProvider, profile, "judge");
+  const payload = joined.map((task) => ({
+    taskId: task.taskId,
+    category: task.category,
+    question: task[side].question,
+    expected: task[side].expected
+  }));
+  return {
+    reference: evidence.reference,
+    sha256: evidence.sha256,
+    resultId: evidence.result.meta.id,
+    gitSha: evidence.result.meta.gitSha,
+    remnicVersion: evidence.result.meta.remnicVersion,
+    runtimeProfile: profile,
+    systemProvider: system.provider,
+    systemModel: system.model,
+    judgeProvider: judge.provider,
+    judgeModel: judge.model,
+    seeds: [...evidence.result.meta.seeds],
+    taskPayloadSha256: sha2562(stableJson(payload))
+  };
+}
+function summarizeMetric(tasks, metric) {
+  let baselineSum = 0;
+  let realSum = 0;
+  let wins = 0;
+  let losses = 0;
+  let ties = 0;
+  for (const task of tasks) {
+    const baseline = requireMetricScore(task.baseline, metric, "baseline");
+    const real = requireMetricScore(task.real, metric, "real");
+    baselineSum += baseline;
+    realSum += real;
+    if (real > baseline) wins += 1;
+    else if (real < baseline) losses += 1;
+    else ties += 1;
+  }
+  const baselineMean = baselineSum / tasks.length;
+  const realMean = realSum / tasks.length;
+  return { baselineMean, realMean, delta: realMean - baselineMean, wins, losses, ties };
+}
+function lineDelta(lines, maxDiffLines, excerptChars) {
+  return {
+    totalCount: lines.length,
+    shownCount: Math.min(lines.length, maxDiffLines),
+    lines: lines.slice(0, maxDiffLines).map((line) => {
+      const parsedSourceRef = sourceRef(line.text);
+      return {
+        ordinal: line.ordinal,
+        ...textDigest(line.text, excerptChars),
+        ...parsedSourceRef ? { sourceRef: parsedSourceRef } : {}
+      };
+    })
+  };
+}
+function recallSummary(text, expected) {
+  const normalized = normalizeText3(text);
+  const lines = normalized.split("\n").map((line) => line.trim()).filter(Boolean);
+  return {
+    sha256: sha2562(normalized),
+    charCount: normalized.length,
+    lineCount: lines.length,
+    headings: [...new Set(lines.filter(isHeading))],
+    sourceRefs: [...new Set(lines.map(sourceRef).filter((value) => !!value))].sort(compareStrings),
+    expectedTokenCoverage: tokenCoverage(expected, normalized)
+  };
+}
+function textDigest(text, excerptChars) {
+  const normalized = normalizeText3(text);
+  return {
+    sha256: sha2562(normalized),
+    charCount: normalized.length,
+    excerpt: normalized.slice(0, excerptChars)
+  };
+}
+function contentLines(text) {
+  return normalizeText3(text).split("\n").map((line, ordinal) => ({ text: line.trim(), ordinal })).filter((line) => line.text.length > 0 && !isHeading(line.text));
+}
+function subtractLineMultiset(source, comparison) {
+  const remaining = /* @__PURE__ */ new Map();
+  for (const line of comparison) {
+    remaining.set(line.text, (remaining.get(line.text) ?? 0) + 1);
+  }
+  return source.filter((line) => {
+    const count = remaining.get(line.text) ?? 0;
+    if (count === 0) return true;
+    remaining.set(line.text, count - 1);
+    return false;
+  });
+}
+function verifyAggregateMeans(result, joined, side) {
+  const first = joined[0];
+  if (!first) throw new Error("Cannot verify aggregates for an empty paired result.");
+  const metrics = Object.keys(first[side].scores).sort(compareStrings);
+  for (const metric of metrics) {
+    const aggregate = result.results.aggregates[metric];
+    if (!aggregate || !Number.isFinite(aggregate.mean)) {
+      throw new Error(`${side} result has no finite aggregate mean for ${JSON.stringify(metric)}.`);
+    }
+    const computed = joined.reduce((sum, task) => sum + requireMetricScore(task[side], metric, side), 0) / joined.length;
+    if (Math.abs(aggregate.mean - computed) > 1e-12) {
+      throw new Error(`${side} aggregate ${metric}=${aggregate.mean} does not match task mean ${computed}.`);
+    }
+  }
+}
+function tokenCoverage(expected, recalled) {
+  const expectedTokens = new Set(tokenize6(expected));
+  if (expectedTokens.size === 0) return 0;
+  const recalledTokens = new Set(tokenize6(recalled));
+  let matched = 0;
+  for (const token of expectedTokens) {
+    if (recalledTokens.has(token)) matched += 1;
+  }
+  return matched / expectedTokens.size;
+}
+function tokenize6(value) {
+  return normalizeText3(value).toLocaleLowerCase("en-US").match(/[\p{L}\p{N}]+/gu) ?? [];
+}
+function resolveCategory2(task) {
+  const categoryName = asRecord(task.details)?.categoryName;
+  if (typeof categoryName === "string" && categoryName.trim()) return categoryName;
+  const match = task.taskId.match(LOCOMO_TASK_CATEGORY_PATTERN2);
+  if (!match?.[1]) {
+    throw new Error(`Cannot derive LoCoMo category from task id ${JSON.stringify(task.taskId)}.`);
+  }
+  return match[1];
+}
+function finalRecallText(task) {
+  const recalledText = asRecord(task.details)?.recalledText;
+  if (typeof recalledText !== "string") {
+    throw new Error(`Task ${JSON.stringify(task.taskId)} has no final recalledText.`);
+  }
+  return recalledText;
+}
+function providerIdentity(provider) {
+  if (!provider) return null;
+  return {
+    provider: provider.provider,
+    model: provider.model,
+    rubricVersion: provider.rubricVersion ?? null,
+    baseUrl: provider.baseUrl ?? null,
+    providerRequestTimeoutMs: provider.providerRequestTimeoutMs ?? null,
+    retryOptions: provider.retryOptions ? {
+      maxAttempts: provider.retryOptions.maxAttempts ?? null,
+      baseBackoffMs: provider.retryOptions.baseBackoffMs ?? null,
+      timeoutMs: provider.retryOptions.timeoutMs ?? null,
+      retryOnTimeout: provider.retryOptions.retryOnTimeout ?? null,
+      max429WaitMs: provider.retryOptions.max429WaitMs ?? null
+    } : null,
+    disableThinking: provider.disableThinking ?? null,
+    reasoningEffort: provider.reasoningEffort ?? null,
+    responderContextBudgetChars: provider.responderContextBudgetChars ?? null,
+    responderPromptBudgetChars: provider.responderPromptBudgetChars ?? null,
+    temperature: provider.temperature ?? null,
+    seed: provider.seed ?? null
+  };
+}
+function sourceRef(line) {
+  const match = line.match(SOURCE_TURN_PATTERN);
+  const sessionId = match?.[1];
+  const turn = match?.[2];
+  const role = match?.[3];
+  if (!sessionId || !turn || !role) return void 0;
+  return `${sessionId}:turn-${turn}:${role.trim().toLowerCase()}`;
+}
+function requireMetricScore(task, metric, side) {
+  const score = task.scores[metric];
+  if (typeof score !== "number" || !Number.isFinite(score)) {
+    throw new Error(`${side} task ${JSON.stringify(task.taskId)} metric ${metric} is not finite.`);
+  }
+  return score;
+}
+function requireProvider(provider, profile, role) {
+  if (!provider) throw new Error(`${profile} result has no ${role} provider identity.`);
+  return provider;
+}
+function isHeading(line) {
+  return /^##\s+/.test(line);
+}
+function normalizeText3(value) {
+  return value.replaceAll("\r\n", "\n").replaceAll("\r", "\n");
+}
+function sha2562(value) {
+  return createHash13("sha256").update(value).digest("hex");
+}
+function stableJson(value) {
+  return JSON.stringify(value);
+}
+function asRecord(value) {
+  return typeof value === "object" && value !== null ? value : void 0;
+}
+function parseNonNegativeInteger(value, label) {
+  if (!Number.isInteger(value) || value < 0) {
+    throw new Error(`${label} must be a non-negative integer.`);
+  }
+  return value;
+}
+function compareLoComoCategories2(left, right) {
+  const leftIndex = LOCOMO_CATEGORY_ORDER2.indexOf(left);
+  const rightIndex = LOCOMO_CATEGORY_ORDER2.indexOf(right);
+  if (leftIndex >= 0 && rightIndex >= 0) return leftIndex - rightIndex;
+  if (leftIndex >= 0) return -1;
+  if (rightIndex >= 0) return 1;
+  return compareStrings(left, right);
+}
+function compareStrings(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+function escapeMarkdownCell(value) {
+  return value.replaceAll("|", "\\|").replaceAll("\n", " ");
+}
+function formatScore2(value) {
+  return value.toFixed(4);
+}
+function formatSignedScore2(value) {
+  return `${value >= 0 ? "+" : ""}${formatScore2(value)}`;
+}
+
 // src/integrity/sealed-qrels.ts
 import { readFile as readFile20 } from "fs/promises";
 function isSealedQrelsArtifact(value) {
@@ -39433,7 +40140,7 @@ var chatFixture = {
 };
 
 // src/judges/calibration-slice.ts
-import { createHash as createHash13, randomBytes as randomBytes3 } from "crypto";
+import { createHash as createHash14, randomBytes as randomBytes3 } from "crypto";
 import { mkdir as mkdir18, readFile as readFile22, rename as rename4, unlink as unlink4, writeFile as writeFile17 } from "fs/promises";
 import path37 from "path";
 
@@ -39580,7 +40287,7 @@ function selectCalibrationSlice(questionIds, size = CALIBRATION_SLICE_SIZE) {
       unique.push(id);
     }
   }
-  return unique.map((id) => ({ id, digest: createHash13("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: createHash14("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));
@@ -39655,7 +40362,7 @@ function validatePinnedQuestionIds(ids, availableIds) {
   return [...ids];
 }
 function hashCalibrationAnswerSet(answers) {
-  return createHash13("sha256").update(JSON.stringify(answers.map((answer) => [
+  return createHash14("sha256").update(JSON.stringify(answers.map((answer) => [
     answer.questionId,
     answer.question,
     answer.predicted,
@@ -40342,7 +41049,7 @@ var PROCEDURAL_REAL_SCENARIOS_SMOKE = [
 ];
 
 // src/security/extraction-attack/tokenize.ts
-function tokenize6(text) {
+function tokenize7(text) {
   return text.toLowerCase().split(/[^a-z0-9]+/u).filter((t) => t.length > 2);
 }
 
@@ -40384,7 +41091,7 @@ function createSeededRng2(seed) {
     }
   };
 }
-var tokenizeContent = tokenize6;
+var tokenizeContent = tokenize7;
 function recoveryTokensFor(memory) {
   if (memory.tokens && memory.tokens.length > 0) {
     const seen = /* @__PURE__ */ new Set();
@@ -40863,11 +41570,11 @@ function createSyntheticTarget(options) {
   }
   const normalized = memories.map((m) => ({
     memory: m,
-    tokens: new Set((m.tokens ?? tokenize6(m.content)).map((t) => t.toLowerCase()))
+    tokens: new Set((m.tokens ?? tokenize7(m.content)).map((t) => t.toLowerCase()))
   }));
   return {
     async recall(query, recallOptions) {
-      const qTokens = tokenize6(query);
+      const qTokens = tokenize7(query);
       if (qTokens.length === 0) return [];
       const requestedNs = recallOptions?.namespace;
       if (enforceNamespaceAcl && requestedNs !== void 0 && requestedNs !== allowedNamespace) {
@@ -41111,7 +41818,7 @@ function createMitigatedTarget(config) {
 }
 
 // src/coding-graph/generator.ts
-import { createHash as createHash14 } from "crypto";
+import { createHash as createHash15 } from "crypto";
 function createSeededRng3(seed) {
   let state = seed >>> 0;
   return function rng() {
@@ -41140,7 +41847,7 @@ var EDGE_TYPE_WEIGHTS = [
 var PROVENANCE_VALUES = ["heuristic", "heuristic", "heuristic", "trace"];
 var AVG_BYTES_PER_LINE = 40;
 function hashContent(input) {
-  return createHash14("sha256").update(input).digest("hex").slice(0, 16);
+  return createHash15("sha256").update(input).digest("hex").slice(0, 16);
 }
 function generateSyntheticRepo(config) {
   const rng = createSeededRng3(config.seed);
@@ -41708,6 +42415,9 @@ export {
   JUDGE_CALIBRATION_KAPPA_THRESHOLD,
   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,
   LettaMemCorrectAdapter,
   LocalLabPreflightError,
@@ -41761,6 +42471,7 @@ export {
   buildBenchmarkPublishFeed,
   buildBenchmarkReproManifest,
   buildBenchmarkRunSeeds,
+  buildCodexCreditReceipt,
   buildJudgePayload,
   buildOracleTrajectoryRecall,
   buildSchemaTierFixture,
@@ -41818,6 +42529,7 @@ export {
   defaultBenchmarkPublishPath,
   deleteBenchmarkResults,
   diagnoseLoComoProfileDelta,
+  diagnoseLoComoRecallDelta,
   discoverAllProviders,
   discoveryEndpointFor,
   emailFixture,
@@ -41888,10 +42600,12 @@ export {
   preflightLocalLabRole,
   projectFolderFixture,
   recallAtK,
+  reconcileCodexCreditLedger,
   redactBenchmarkResultSecrets,
   renderBaselineMarkdown,
   renderBenchmarkResultExport,
   renderLoComoProfileDeltaMarkdown,
+  renderLoComoRecallDeltaMarkdown,
   renderMemorySummaryForJudge,
   renderMemoryViewForAgent,
   resolveAssistantAgent,
@@ -41927,6 +42641,7 @@ export {
   runSealedJudge,
   runSequentialPhases,
   safeHexEqual,
+  sanitizeLoComoResultReference,
   saveBaseline,
   saveBenchmarkBaseline,
   schemaCompleteness,

package/package.json

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