@remnic/bench 9.3.704 → 9.3.706

package/dist/index.d.ts

@@ -528,6 +528,47 @@ interface CustomBenchmarkSpec {
     tasks: CustomBenchmarkTask[];
 }
 
+/** Generator options. Deterministic given an identical `seed`. */
+interface MemCorrectGeneratorOptions {
+    /** Number of personas (each owns ≥2 namespaces). */
+    personaCount: number;
+    /** Facts per persona, spread across categories. */
+    factsPerPersona: number;
+    /** PRNG seed. */
+    seed: number;
+    /** Anchor "now"; all timestamps derive from this. */
+    nowIso: string;
+    /** Maintenance cycles applied between post-correction and post-reingest. */
+    maintenanceCycles: number;
+    /** Latency cap (in interaction turns) for `uptake_latency`. */
+    uptakeLatencyCap: number;
+}
+/**
+ * The system-agnostic adapter contract. This is the public surface a
+ * third-party memory system implements to be scored on MemCorrect.
+ *
+ * Implementations MUST be isolated: `reset()` returns the system to a clean
+ * slate, and no call reaches into another system's durable store.
+ */
+interface MemCorrectSystemAdapter {
+    /** Human-readable label for artifact metadata (e.g. "remnic-native"). */
+    readonly label: string;
+    /** Reset to a clean slate before each scenario. */
+    reset(): Promise<void>;
+    /** Ingest one conversational turn through the system's normal observe path. */
+    ingestTurn(sessionKey: string, role: "user" | "assistant", text: string, at: string): Promise<void>;
+    /** Ranked memory/context strings for a probe query in a session. */
+    recall(query: string, sessionKey: string): Promise<string[]>;
+    /** However the system accepts a correction (explicit tool, turn, contract). */
+    correct(text: string, sessionKey: string, at?: string): Promise<void>;
+    /**
+     * Consolidation / dreams / pattern-reinforcement / contradiction scan.
+     * A no-op is allowed; the protocol runs this N times between phases and
+     * the `non_resurrection` metric measures whether retired facts survive it.
+     */
+    runMaintenance(): Promise<void>;
+}
+
 /**
  * Shared types for inbox fixture generators.
  */
@@ -3832,4 +3873,4 @@ interface MitigatedTargetConfig {
  */
 declare function createMitigatedTarget(config: MitigatedTargetConfig): ExtractionAttackTarget;
 
-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 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 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 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 BuildBenchmarkArtifactInput, type BuildBenchmarkPublishFeedOptions, type BuildBenchmarkReproManifestOptions, type BuiltInProvider, CALIBRATION_SLICE_SIZE, CANARY_FIXED_RECALL, CANARY_SCORE_FLOOR, type CalibrationAnswer, type CalibrationVerdictPair, type CanaryAdapterOptions, type CanaryFloorCheck, type CodexCliProviderConfig, 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_BOOTSTRAP_SEED, DEFAULT_ASSISTANT_RUBRIC_ID, DEFAULT_BASELINE_SCENARIOS, DEFAULT_JUDGE_BINARIZATION_THRESHOLD, type DatasetSource, 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, type GeneratedFile, 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, LOCAL_LAB_PROVIDER_KINDS, LOCOMO_DATASET_FILENAMES, LONG_MEM_EVAL_DATASET_FILENAMES, type LeaderboardArtifactWrite, type LlmJudge, type LlmProvider, 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, MEMORY_EVAL_DIMENSIONS, MEMORY_EVAL_PUBLIC_LINE, MIN_CALIBRATION_SOURCE_TASKS, MITIGATED_BASELINE_SCENARIOS, type MemoryEvalCategory, type MemoryEvalDimension, type MemoryEvalDimensionId, type MemoryEvalMetric, type MemoryGraph, type MemoryStats, type MemorySystem, type Message, type MetricAggregate, type MitigatedBaselineConfig, type MitigatedTargetConfig, type MultipleChoiceQuestion, OTHER_NAMESPACE_MEMORIES, type OllamaProviderConfig, type OpenAiCompatibleProviderConfig, 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, type RemnicAdapterOptions, 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, 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 SpotCheckLogger, type StatisticalReport, type StructuredJudge, type SyntheticEmailIngestionAdapterOptions, type SyntheticTargetOptions, type TaskResult, type TaskTokenUsage, type TemporalRetrievalCase, type TierDetail, type TimelineEntry, type TokenUsage, type WriteBenchmarkArtifactResult, addContaminationEntry, aggregateTaskScores, answerBenchmarkQuestion, assertCanaryUnderFloor, assertIntegrityMetaPresent, assertPublishableIntegrity, assertSha256Hex, assistantMeetingPrepDefinition, assistantMorningBriefDefinition, assistantNextBestActionDefinition, assistantSynthesisDefinition, backlinkF1, binarizeJudgeScore, bootstrapMeanConfidenceInterval, buildAmaBenchDiagnosticMatrixArtifact, buildAmaBenchDiagnosticVariantSummary, buildAmaBenchLeaderboardRows, buildBenchmarkArtifact, buildBenchmarkArtifactFilename, buildBenchmarkPublishFeed, buildBenchmarkReproManifest, buildBenchmarkRunSeeds, buildJudgePayload, buildOracleTrajectoryRecall, buildSchemaTierFixture, buildSchemaTierSmokeFixture, calendarFixture, canonicalJsonStringify, chatFixture, checkDatasetContamination, checkRegression, clampScore, cohensD, compareResults, computeCohensKappa, computeSealHash, containsAnswer, createSeededRng as createAdamSeededRng, createAmaBenchDiagnosticAdapter, createAnthropicProvider, createCanaryAdapter, createCodexCliProvider, createDeterministicSpotCheckLogger, createGatewayResponder, createLightweightAdapter, createLiteLlmProvider, createLocalLlmProvider, createMitigatedTarget, createOllamaProvider, createOpenAiCompatibleProvider, createSeededRandom as createProceduralAblationSeededRandom, createProvider, createProviderBackedAmaBenchRecommendedJudge, createProviderBackedJudge, createProviderBackedResponder, createProviderBackedStructuredJudge, createRemnicAdapter, createResponderFromProvider, createSeededRng$1 as createSeededRng, createSpotCheckFileLogger, createStructuredJudgeFromProvider, createSyntheticEmailIngestionAdapter, createSyntheticTarget, createTimeoutGuardedAdapter, defaultBenchmarkBaselineDir, defaultBenchmarkPublishPath, deleteBenchmarkResults, discoverAllProviders, discoveryEndpointFor, emailFixture, entityRecall, exactMatch, extractMarkdownSectionsByTitle, f1Score, fixtureToAblationScenarios, formatHandoffNote, formatMissingDatasetError, generateReport, getBenchmark, getBenchmarkLowerIsBetter, getMemoryEvalDimension, getRemnicVersion, hashBenchmarkArtifact, hashBytes, hashCanonicalJson, hashString, integrityMetaIsComplete, interpretEffectSize, isAmaBenchUnknownLikeAnswer, isContaminationEntry, isContaminationManifest, isSealedQrelsArtifact, isSha256Hex, linkMatches, listBenchmarkBaselines, listBenchmarkResults, listBenchmarks, listMemoryEvalBenchmarkIds, listMemoryEvalDimensions, llmJudgeScore, llmJudgeScoreDetailed, loadAblationFixture, loadBaseline, loadBeamDatasetPreview, loadBenchmarkArtifact, loadBenchmarkBaseline, loadBenchmarkResult, loadCustomBenchmarkFile, loadJudgeCalibrationState, loadLoCoMo10, loadLocalLabManifest, loadLongMemEvalS, loadSealKeyFromEnv, loadSealedQrels, loadSealedRubric, matchEntity, mergeContaminationManifests, openSeal, orchestrateBenchmarkRuns, pairedDeltaConfidenceInterval, parseBenchmarkArtifact, parseCustomBenchmark, parseLocalLabManifest, parseRubricResponse, parseSealedQrels, precisionAtK, preflightLocalLabRole, projectFolderFixture, recallAtK, redactBenchmarkResultSecrets, renderBaselineMarkdown, renderBenchmarkResultExport, renderMemorySummaryForJudge, renderMemoryViewForAgent, resolveAssistantAgent, resolveAssistantRubricId, resolveAssistantSeeds, resolveAssistantSpotCheckDir, resolveBenchRuntimeProfile, resolveBenchmarkPhaseTimeoutMs, resolveBenchmarkProgressLogging, resolveBenchmarkResultReference, resolveBenchmarkRunCount, resolveLocalLabProfile, resolveLocalLabRole, resolveStructuredJudge, rotateDistractors, rougeL, runAssistantBenchmark, runAssistantMeetingPrepBenchmark, runAssistantMorningBriefBenchmark, runAssistantNextBestActionBenchmark, runAssistantSynthesisBenchmark, runBaseline, runBenchSuite, runBenchmark, 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 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 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 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 BuildBenchmarkArtifactInput, type BuildBenchmarkPublishFeedOptions, type BuildBenchmarkReproManifestOptions, type BuiltInProvider, CALIBRATION_SLICE_SIZE, CANARY_FIXED_RECALL, CANARY_SCORE_FLOOR, type CalibrationAnswer, type CalibrationVerdictPair, type CanaryAdapterOptions, type CanaryFloorCheck, type CodexCliProviderConfig, 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_BOOTSTRAP_SEED, DEFAULT_ASSISTANT_RUBRIC_ID, DEFAULT_BASELINE_SCENARIOS, DEFAULT_JUDGE_BINARIZATION_THRESHOLD, type DatasetSource, 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, type GeneratedFile, 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, LOCAL_LAB_PROVIDER_KINDS, LOCOMO_DATASET_FILENAMES, LONG_MEM_EVAL_DATASET_FILENAMES, type LeaderboardArtifactWrite, type LlmJudge, type LlmProvider, 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, MEMORY_EVAL_DIMENSIONS, MEMORY_EVAL_PUBLIC_LINE, MIN_CALIBRATION_SOURCE_TASKS, MITIGATED_BASELINE_SCENARIOS, type MemCorrectGeneratorOptions, type MemCorrectSystemAdapter, type MemoryEvalCategory, type MemoryEvalDimension, type MemoryEvalDimensionId, type MemoryEvalMetric, type MemoryGraph, type MemoryStats, type MemorySystem, type Message, type MetricAggregate, type MitigatedBaselineConfig, type MitigatedTargetConfig, type MultipleChoiceQuestion, OTHER_NAMESPACE_MEMORIES, type OllamaProviderConfig, type OpenAiCompatibleProviderConfig, 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, type RemnicAdapterOptions, 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, 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 SpotCheckLogger, type StatisticalReport, type StructuredJudge, type SyntheticEmailIngestionAdapterOptions, type SyntheticTargetOptions, type TaskResult, type TaskTokenUsage, type TemporalRetrievalCase, type TierDetail, type TimelineEntry, type TokenUsage, type WriteBenchmarkArtifactResult, addContaminationEntry, aggregateTaskScores, answerBenchmarkQuestion, assertCanaryUnderFloor, assertIntegrityMetaPresent, assertPublishableIntegrity, assertSha256Hex, assistantMeetingPrepDefinition, assistantMorningBriefDefinition, assistantNextBestActionDefinition, assistantSynthesisDefinition, backlinkF1, binarizeJudgeScore, bootstrapMeanConfidenceInterval, buildAmaBenchDiagnosticMatrixArtifact, buildAmaBenchDiagnosticVariantSummary, buildAmaBenchLeaderboardRows, buildBenchmarkArtifact, buildBenchmarkArtifactFilename, buildBenchmarkPublishFeed, buildBenchmarkReproManifest, buildBenchmarkRunSeeds, buildJudgePayload, buildOracleTrajectoryRecall, buildSchemaTierFixture, buildSchemaTierSmokeFixture, calendarFixture, canonicalJsonStringify, chatFixture, checkDatasetContamination, checkRegression, clampScore, cohensD, compareResults, computeCohensKappa, computeSealHash, containsAnswer, createSeededRng as createAdamSeededRng, createAmaBenchDiagnosticAdapter, createAnthropicProvider, createCanaryAdapter, createCodexCliProvider, createDeterministicSpotCheckLogger, createGatewayResponder, createLightweightAdapter, createLiteLlmProvider, createLocalLlmProvider, createMitigatedTarget, createOllamaProvider, createOpenAiCompatibleProvider, createSeededRandom as createProceduralAblationSeededRandom, createProvider, createProviderBackedAmaBenchRecommendedJudge, createProviderBackedJudge, createProviderBackedResponder, createProviderBackedStructuredJudge, createRemnicAdapter, createResponderFromProvider, createSeededRng$1 as createSeededRng, createSpotCheckFileLogger, createStructuredJudgeFromProvider, createSyntheticEmailIngestionAdapter, createSyntheticTarget, createTimeoutGuardedAdapter, defaultBenchmarkBaselineDir, defaultBenchmarkPublishPath, deleteBenchmarkResults, discoverAllProviders, discoveryEndpointFor, emailFixture, entityRecall, exactMatch, extractMarkdownSectionsByTitle, f1Score, fixtureToAblationScenarios, formatHandoffNote, formatMissingDatasetError, generateReport, getBenchmark, getBenchmarkLowerIsBetter, getMemoryEvalDimension, getRemnicVersion, hashBenchmarkArtifact, hashBytes, hashCanonicalJson, hashString, integrityMetaIsComplete, interpretEffectSize, isAmaBenchUnknownLikeAnswer, isContaminationEntry, isContaminationManifest, isSealedQrelsArtifact, isSha256Hex, linkMatches, listBenchmarkBaselines, listBenchmarkResults, listBenchmarks, listMemoryEvalBenchmarkIds, listMemoryEvalDimensions, llmJudgeScore, llmJudgeScoreDetailed, loadAblationFixture, loadBaseline, loadBeamDatasetPreview, loadBenchmarkArtifact, loadBenchmarkBaseline, loadBenchmarkResult, loadCustomBenchmarkFile, loadJudgeCalibrationState, loadLoCoMo10, loadLocalLabManifest, loadLongMemEvalS, loadSealKeyFromEnv, loadSealedQrels, loadSealedRubric, matchEntity, mergeContaminationManifests, openSeal, orchestrateBenchmarkRuns, pairedDeltaConfidenceInterval, parseBenchmarkArtifact, parseCustomBenchmark, parseLocalLabManifest, parseRubricResponse, parseSealedQrels, precisionAtK, preflightLocalLabRole, projectFolderFixture, recallAtK, redactBenchmarkResultSecrets, renderBaselineMarkdown, renderBenchmarkResultExport, renderMemorySummaryForJudge, renderMemoryViewForAgent, resolveAssistantAgent, resolveAssistantRubricId, resolveAssistantSeeds, resolveAssistantSpotCheckDir, resolveBenchRuntimeProfile, resolveBenchmarkPhaseTimeoutMs, resolveBenchmarkProgressLogging, resolveBenchmarkResultReference, resolveBenchmarkRunCount, resolveLocalLabProfile, resolveLocalLabRole, resolveStructuredJudge, rotateDistractors, rougeL, runAssistantBenchmark, runAssistantMeetingPrepBenchmark, runAssistantMorningBriefBenchmark, runAssistantNextBestActionBenchmark, runAssistantSynthesisBenchmark, runBaseline, runBenchSuite, runBenchmark, 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 };

package/dist/index.js

@@ -7269,9 +7269,15 @@ function resolveContainedPath(root, ...segments) {
 import { mkdir as mkdir6, writeFile as writeFile6 } from "fs/promises";
 import path8 from "path";
 async function writeLeaderboardArtifactsForResult(result, outputDir) {
-  if (result.meta.benchmark !== "ama-bench") {
-    return [];
+  if (result.meta.benchmark === "ama-bench") {
+    return writeAmaBenchLeaderboard(result, outputDir);
+  }
+  if (result.meta.benchmark === "memcorrect-v1") {
+    return writeMemCorrectLeaderboard(result, outputDir);
   }
+  return [];
+}
+async function writeAmaBenchLeaderboard(result, outputDir) {
   const rows = buildAmaBenchLeaderboardRows(result);
   if (rows.length === 0) {
     return [];
@@ -7291,6 +7297,29 @@ async function writeLeaderboardArtifactsForResult(result, outputDir) {
     }
   ];
 }
+async function writeMemCorrectLeaderboard(result, outputDir) {
+  const row = buildMemCorrectLeaderboardRow(result);
+  if (!row) return [];
+  const outputRoot = path8.resolve(outputDir);
+  const leaderboardDir = resolveContainedPath(outputRoot, "leaderboard");
+  await mkdir6(leaderboardDir, { recursive: true });
+  const timestamp = sanitizeFilenameSegment(result.meta.timestamp.replace(/[:.]/g, "-"));
+  const safeAdapter = sanitizeFilenameSegment(row.adapter);
+  const filePath = resolveContainedPath(
+    leaderboardDir,
+    `memcorrect-${safeAdapter}-${timestamp}.jsonl`
+  );
+  await writeFile6(filePath, `${JSON.stringify(row)}
+`, "utf8");
+  return [
+    {
+      benchmark: "memcorrect-v1",
+      path: filePath,
+      format: "memcorrect-adapter-metrics-jsonl",
+      records: 1
+    }
+  ];
+}
 function buildAmaBenchLeaderboardRows(result) {
   const rowsByEpisode = /* @__PURE__ */ new Map();
   result.results.tasks.forEach((task, taskIndex) => {
@@ -7316,6 +7345,34 @@ function buildAmaBenchLeaderboardRows(result) {
     answer_list: row.answers
   }));
 }
+function buildMemCorrectLeaderboardRow(result) {
+  const aggregate = result.config.benchmarkOptions?.aggregateMetrics;
+  if (!aggregate) return null;
+  const adapter = typeof result.config.adapterMode === "string" ? result.config.adapterMode : "unknown";
+  const provenance = aggregate.provenance_fidelity;
+  return {
+    benchmark: "memcorrect-v1",
+    adapter,
+    seed: result.meta.seeds[0] ?? 0,
+    dataset_hash: result.meta.datasetHash ?? "",
+    remnic_version: result.meta.remnicVersion,
+    git_sha: result.meta.gitSha,
+    timestamp: result.meta.timestamp,
+    mode: result.meta.mode,
+    uptake_at_next: numberOrZero(aggregate.uptake_at_next),
+    uptake_latency: numberOrZero(aggregate.uptake_latency),
+    uptake_latency_censored: numberOrZero(aggregate.uptake_latency_censored),
+    non_resurrection: numberOrZero(aggregate.non_resurrection),
+    collateral_delta: numberOrZero(aggregate.collateral_delta),
+    scope_precision: typeof aggregate.scope_precision === "number" ? aggregate.scope_precision : null,
+    false_apply: numberOrZero(aggregate.false_apply),
+    reassertion: typeof aggregate.reassertion === "number" ? aggregate.reassertion : null,
+    provenance_fidelity: typeof provenance === "number" ? provenance : null
+  };
+}
+function numberOrZero(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
 function serializeJsonl(rows) {
   return `${rows.map((row) => JSON.stringify(row)).join("\n")}
 `;
@@ -11142,7 +11199,7 @@ async function resolveLocalLabRuntimeProfile(options) {
 // src/benchmark.ts
 import fs2 from "fs";
 import path32 from "path";
-import { createHash as createHash9 } from "crypto";
+import { createHash as createHash10 } from "crypto";
 import { expandTildePath as expandTildePath3 } from "@remnic/core";
 
 // src/judges/judge-cache.ts
@@ -29862,6 +29919,1062 @@ async function runRetentionAgedDatasetBenchmark(options) {
   };
 }
 
+// src/benchmarks/remnic/memcorrect/runner.ts
+import { randomUUID as randomUUID31 } from "crypto";
+
+// src/benchmarks/remnic/memcorrect/generator.ts
+import { createHash as createHash9 } from "crypto";
+
+// src/benchmarks/remnic/memcorrect/token-pools.ts
+var PERSONAS = [
+  "Avery",
+  "Blair",
+  "Cassidy",
+  "Dakota",
+  "Emerson",
+  "Finley",
+  "Harper",
+  "Jordan",
+  "Kendall",
+  "Logan"
+];
+var SUBJECTS = [
+  "coffee",
+  "editor",
+  "database",
+  "calendar",
+  "standup",
+  "deploy",
+  "notebook",
+  "keyboard"
+];
+var VALUES_A = [
+  "oat-milk",
+  "helix",
+  "postgres",
+  "monday",
+  "nine-am",
+  "blue-green",
+  "dotgrid",
+  "mechanical"
+];
+var VALUES_B = [
+  "black-coffee",
+  "neovim",
+  "mysql",
+  "wednesday",
+  "ten-am",
+  "canary",
+  "lined",
+  "membrane"
+];
+
+// src/benchmarks/remnic/memcorrect/generator.ts
+var MAX_PRNG_SEED2 = 4294967295;
+var FACT_CATEGORIES = [
+  "fact",
+  "preference",
+  "decision",
+  "commitment",
+  "relationship"
+];
+function mulberry322(seed) {
+  let state = seed >>> 0;
+  return function rng() {
+    state |= 0;
+    state = state + 1831565813 | 0;
+    let t = Math.imul(state ^ state >>> 15, 1 | state);
+    t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+function pick(rng, pool) {
+  return pool[Math.floor(rng() * pool.length) % pool.length];
+}
+function pickExcluding(rng, pool, exclude) {
+  const choices = pool.filter((v) => v !== exclude);
+  const source = choices.length > 0 ? choices : pool;
+  return source[Math.floor(rng() * source.length) % source.length];
+}
+function pickExcludingSet(rng, pool, used) {
+  const choices = pool.filter((v) => !used.has(v));
+  const source = choices.length > 0 ? choices : pool;
+  return source[Math.floor(rng() * source.length) % source.length];
+}
+function isoAfter(baseMs, addMs) {
+  return new Date(baseMs + addMs).toISOString();
+}
+function planFacts(rng, options) {
+  const plans = [];
+  const shapes = [
+    "explicit-targeted",
+    "conversational",
+    "scoped",
+    "re-assertion"
+  ];
+  for (let p = 0; p < options.personaCount; p += 1) {
+    const persona = PERSONAS[p % PERSONAS.length];
+    const namespaces = [
+      `${persona.toLowerCase()}-work`,
+      `${persona.toLowerCase()}-home`
+    ];
+    for (let f = 0; f < options.factsPerPersona; f += 1) {
+      const category = FACT_CATEGORIES[(p * options.factsPerPersona + f) % FACT_CATEGORIES.length];
+      const subject = pick(rng, SUBJECTS);
+      const oldValue = pick(rng, VALUES_A);
+      const newValue = pick(rng, VALUES_B);
+      const namespace = namespaces[f % namespaces.length];
+      const shape = shapes[(p * options.factsPerPersona + f) % shapes.length];
+      plans.push({ persona, namespace, category, subject, oldValue, newValue, shape });
+    }
+  }
+  return plans;
+}
+function establishTurns(plan, baseMs, startOffsetMs) {
+  const turns = [
+    {
+      role: "user",
+      text: `My ${plan.subject} preference is ${plan.oldValue}.`,
+      at: isoAfter(baseMs, startOffsetMs)
+    },
+    {
+      role: "assistant",
+      text: `Got it \u2014 noting ${plan.oldValue} for ${plan.subject}.`,
+      at: isoAfter(baseMs, startOffsetMs + 6e4)
+    }
+  ];
+  return { turns, nextOffsetMs: startOffsetMs + 12e4 };
+}
+function buildCorrection(plan, baseMs, offsetMs) {
+  const retiredContent = [plan.oldValue];
+  const correctedContent = [plan.newValue];
+  let text;
+  switch (plan.shape) {
+    case "explicit-targeted":
+      text = `Correction: my ${plan.subject} record saying ${plan.oldValue} is wrong. It is now ${plan.newValue}.`;
+      break;
+    case "conversational":
+      text = `Oh by the way, we switched ${plan.subject} from ${plan.oldValue} to ${plan.newValue} last month.`;
+      break;
+    case "scoped":
+      text = `For this project, ${plan.subject} is ${plan.newValue} now, not ${plan.oldValue}.`;
+      break;
+    case "re-assertion":
+      text = `Update: ${plan.subject} is ${plan.newValue} going forward instead of ${plan.oldValue}.`;
+      break;
+  }
+  const correction = {
+    shape: plan.shape,
+    turn: { role: "user", text, at: isoAfter(baseMs, offsetMs) },
+    retiredContent,
+    correctedContent
+  };
+  return { correction, nextOffsetMs: offsetMs + 6e4 };
+}
+function buildAntiEvents(rng, plan, baseMs, offsetMs) {
+  const kinds = [
+    "quoting-other",
+    "hypothetical",
+    "third-party-correction"
+  ];
+  const kind = kinds[Math.floor(rng() * kinds.length) % kinds.length];
+  const decoy = pickExcluding(rng, VALUES_B, plan.newValue);
+  let text;
+  switch (kind) {
+    case "quoting-other":
+      text = `Riley mentioned their ${plan.subject} is set to ${decoy}.`;
+      break;
+    case "hypothetical":
+      text = `If someone asked, I might consider ${decoy} for ${plan.subject}, but I have not decided.`;
+      break;
+    case "third-party-correction":
+      text = `Sage said you should change ${plan.subject} to ${decoy} for them.`;
+      break;
+  }
+  const event = {
+    kind,
+    turn: { role: "user", text, at: isoAfter(baseMs, offsetMs) },
+    probeQuery: `what is my ${plan.subject} preference?`,
+    // The decoy must NOT stick from a third-party / hypothetical cue; if it
+    // surfaces in a later probe the system falsely applied the anti-event.
+    shouldNotAppear: decoy
+  };
+  return { events: [event], nextOffsetMs: offsetMs + 6e4 };
+}
+function buildScopedTwin(plan, baseMs, offsetMs) {
+  const otherNamespace = plan.namespace.endsWith("-work") ? plan.namespace.replace(/-work$/, "-home") : plan.namespace.replace(/-home$/, "-work");
+  const twin = {
+    namespace: otherNamespace,
+    establishingTurns: [
+      {
+        role: "user",
+        text: `My ${plan.subject} preference is ${plan.oldValue}.`,
+        at: isoAfter(baseMs, offsetMs)
+      },
+      {
+        role: "assistant",
+        text: `Noted ${plan.oldValue} for ${plan.subject}.`,
+        at: isoAfter(baseMs, offsetMs + 6e4)
+      }
+    ],
+    twinContent: plan.oldValue
+  };
+  return { twin, nextOffsetMs: offsetMs + 12e4 };
+}
+function buildReassertion(plan, baseMs, offsetMs) {
+  return {
+    turn: {
+      role: "user",
+      text: `Actually, we went back to ${plan.oldValue} for ${plan.subject}.`,
+      at: isoAfter(baseMs, offsetMs)
+    },
+    expectedContent: plan.oldValue
+  };
+}
+function buildUnrelatedProbes(rng, plan, baseMs, offsetMs) {
+  const PROBE_COUNT = 2;
+  const probes = [];
+  const usedSubjects = /* @__PURE__ */ new Set([plan.subject]);
+  for (let i = 0; i < PROBE_COUNT; i += 1) {
+    const subject = pickExcludingSet(rng, SUBJECTS, usedSubjects);
+    usedSubjects.add(subject);
+    const value = pick(rng, VALUES_A);
+    const turnBase = offsetMs + i * 12e4;
+    probes.push({
+      query: `what is my ${subject} setting?`,
+      expectedContent: value,
+      establishingTurns: [
+        {
+          role: "user",
+          text: `My ${subject} setting is ${value}.`,
+          at: isoAfter(baseMs, turnBase)
+        },
+        {
+          role: "assistant",
+          text: `Got it \u2014 noting ${value} for ${subject}.`,
+          at: isoAfter(baseMs, turnBase + 6e4)
+        }
+      ]
+    });
+  }
+  return { probes, nextOffsetMs: PROBE_COUNT * 12e4 };
+}
+function probeFor(plan) {
+  return {
+    query: `what is my ${plan.subject} preference?`,
+    mustContain: [plan.newValue],
+    mustAbsent: [plan.oldValue]
+  };
+}
+function generateMemCorrectCorpus(options) {
+  if (!Number.isInteger(options.personaCount) || options.personaCount <= 0) {
+    throw new Error(
+      `personaCount must be a positive integer, got ${options.personaCount}`
+    );
+  }
+  if (!Number.isInteger(options.factsPerPersona) || options.factsPerPersona <= 0) {
+    throw new Error(
+      `factsPerPersona must be a positive integer, got ${options.factsPerPersona}`
+    );
+  }
+  if (!Number.isInteger(options.maintenanceCycles) || options.maintenanceCycles < 0) {
+    throw new Error(
+      `maintenanceCycles must be a non-negative integer, got ${options.maintenanceCycles}`
+    );
+  }
+  if (!Number.isInteger(options.uptakeLatencyCap) || options.uptakeLatencyCap <= 0) {
+    throw new Error(
+      `uptakeLatencyCap must be a positive integer, got ${options.uptakeLatencyCap}`
+    );
+  }
+  if (!Number.isInteger(options.seed) || options.seed < 0 || options.seed > MAX_PRNG_SEED2) {
+    throw new Error(
+      `seed must be an integer in [0, ${MAX_PRNG_SEED2}], got ${options.seed}`
+    );
+  }
+  const baseMs = Date.parse(options.nowIso);
+  if (!Number.isFinite(baseMs)) {
+    throw new Error(`nowIso must be a valid ISO timestamp, got ${options.nowIso}`);
+  }
+  const rng = mulberry322(options.seed);
+  const plans = planFacts(rng, options);
+  const scenarios = [];
+  for (let i = 0; i < plans.length; i += 1) {
+    const plan = plans[i];
+    const scenarioBase = baseMs + i * 864e5;
+    let offset = 0;
+    const established = establishTurns(plan, scenarioBase, offset);
+    offset = established.nextOffsetMs;
+    const unrelated = buildUnrelatedProbes(rng, plan, scenarioBase, offset);
+    offset += unrelated.nextOffsetMs;
+    let scopedTwin;
+    if (plan.shape === "scoped") {
+      const twin = buildScopedTwin(plan, scenarioBase, offset);
+      scopedTwin = twin.twin;
+      offset = twin.nextOffsetMs;
+    }
+    const corrected = buildCorrection(plan, scenarioBase, offset);
+    offset = corrected.nextOffsetMs;
+    const antis = buildAntiEvents(rng, plan, scenarioBase, offset);
+    offset = antis.nextOffsetMs;
+    let reassertion2;
+    if (plan.shape === "re-assertion") {
+      reassertion2 = buildReassertion(plan, scenarioBase, offset);
+      offset += 6e4;
+    }
+    scenarios.push({
+      id: `memcorrect-${options.seed}-${i.toString(16)}`,
+      namespace: plan.namespace,
+      category: plan.category,
+      establishingTurns: established.turns,
+      correction: corrected.correction,
+      probe: probeFor(plan),
+      antiEvents: antis.events,
+      scopedTwin,
+      reassertion: reassertion2,
+      unrelatedProbes: unrelated.probes
+    });
+  }
+  return { options, scenarios };
+}
+function corpusHash(corpus) {
+  const canonical = JSON.stringify({
+    personaCount: corpus.options.personaCount,
+    factsPerPersona: corpus.options.factsPerPersona,
+    seed: corpus.options.seed,
+    nowIso: corpus.options.nowIso,
+    maintenanceCycles: corpus.options.maintenanceCycles,
+    uptakeLatencyCap: corpus.options.uptakeLatencyCap,
+    scenarios: corpus.scenarios
+  });
+  return createHash9("sha256").update(canonical).digest("hex");
+}
+
+// src/benchmarks/remnic/memcorrect/schema.ts
+var ALLOWED_CATEGORIES = [
+  "fact",
+  "preference",
+  "decision",
+  "commitment",
+  "relationship"
+];
+var ALLOWED_SHAPES = [
+  "explicit-targeted",
+  "conversational",
+  "scoped",
+  "re-assertion"
+];
+var ALL_TOKENS = /* @__PURE__ */ new Set([
+  ...PERSONAS.map((p) => p.toLowerCase()),
+  ...SUBJECTS,
+  ...VALUES_A,
+  ...VALUES_B,
+  "correction",
+  "update",
+  "actually",
+  "preference",
+  "setting",
+  "for",
+  "this",
+  "project",
+  "my",
+  "is",
+  "now",
+  "not",
+  "wrong",
+  "it",
+  "we",
+  "switched",
+  "from",
+  "to",
+  "last",
+  "month",
+  "going",
+  "forward",
+  "instead",
+  "of",
+  "the",
+  "record",
+  "saying",
+  "oh",
+  "by",
+  "way",
+  "mentioned",
+  "their",
+  "set",
+  "if",
+  "someone",
+  "asked",
+  "i",
+  "might",
+  "consider",
+  "but",
+  "have",
+  "decided",
+  "said",
+  "you",
+  "should",
+  "change",
+  "them",
+  "noting",
+  "noted",
+  "got",
+  "it",
+  "we",
+  "went",
+  "back",
+  "riley",
+  "sage",
+  "what"
+]);
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((v) => typeof v === "string");
+}
+function isIso(value) {
+  if (typeof value !== "string") return false;
+  const ms = Date.parse(value);
+  return Number.isFinite(ms);
+}
+function validateScenario(scenario) {
+  const errors = [];
+  const id = scenario.id;
+  if (scenario.id.length === 0) {
+    errors.push({ scenarioId: id, message: "id must be a non-empty string" });
+  }
+  if (scenario.namespace.length === 0) {
+    errors.push({ scenarioId: id, message: "namespace must be a non-empty string" });
+  }
+  if (!ALLOWED_CATEGORIES.includes(scenario.category)) {
+    errors.push({
+      scenarioId: id,
+      message: `category must be one of ${ALLOWED_CATEGORIES.join(", ")}`
+    });
+  }
+  if (scenario.establishingTurns.length === 0) {
+    errors.push({
+      scenarioId: id,
+      message: "establishingTurns must be a non-empty array"
+    });
+  } else {
+    for (const [index, turn] of scenario.establishingTurns.entries()) {
+      if (turn.role !== "user" && turn.role !== "assistant") {
+        errors.push({
+          scenarioId: id,
+          message: `establishing turn ${index} role invalid`
+        });
+      }
+      if (turn.text.length === 0) {
+        errors.push({
+          scenarioId: id,
+          message: `establishing turn ${index} text empty`
+        });
+      }
+      if (!isIso(turn.at)) {
+        errors.push({
+          scenarioId: id,
+          message: `establishing turn ${index} at not ISO`
+        });
+      }
+    }
+  }
+  if (!ALLOWED_SHAPES.includes(scenario.correction.shape)) {
+    errors.push({
+      scenarioId: id,
+      message: `correction.shape must be one of ${ALLOWED_SHAPES.join(", ")}`
+    });
+  }
+  if (!isStringArray(scenario.correction.retiredContent)) {
+    errors.push({ scenarioId: id, message: "retiredContent must be string[]" });
+  }
+  if (!isStringArray(scenario.correction.correctedContent)) {
+    errors.push({ scenarioId: id, message: "correctedContent must be string[]" });
+  }
+  if (scenario.correction.shape === "scoped" && (!scenario.scopedTwin || scenario.scopedTwin.twinContent.length === 0)) {
+    errors.push({
+      scenarioId: id,
+      message: "scoped correction must carry a scopedTwin with non-empty twinContent"
+    });
+  }
+  if (scenario.correction.shape === "re-assertion" && (!scenario.reassertion || scenario.reassertion.expectedContent.length === 0)) {
+    errors.push({
+      scenarioId: id,
+      message: "re-assertion correction must carry a reassertion block with expectedContent"
+    });
+  }
+  if (scenario.probe.query.length === 0) {
+    errors.push({ scenarioId: id, message: "probe.query empty" });
+  }
+  if (!isStringArray(scenario.probe.mustContain)) {
+    errors.push({ scenarioId: id, message: "probe.mustContain must be string[]" });
+  }
+  if (!isStringArray(scenario.probe.mustAbsent)) {
+    errors.push({ scenarioId: id, message: "probe.mustAbsent must be string[]" });
+  }
+  if (!Array.isArray(scenario.antiEvents)) {
+    errors.push({ scenarioId: id, message: "antiEvents must be an array" });
+  }
+  if (!Array.isArray(scenario.unrelatedProbes)) {
+    errors.push({ scenarioId: id, message: "unrelatedProbes must be an array" });
+  }
+  return errors;
+}
+function validateCorpus(corpus) {
+  const errors = [];
+  if (!Array.isArray(corpus.scenarios)) {
+    return {
+      ok: false,
+      errors: [{ scenarioId: "<root>", message: "scenarios must be an array" }]
+    };
+  }
+  const seenIds = /* @__PURE__ */ new Set();
+  for (const scenario of corpus.scenarios) {
+    if (seenIds.has(scenario.id)) {
+      errors.push({ scenarioId: scenario.id, message: "duplicate scenario id" });
+    }
+    seenIds.add(scenario.id);
+    errors.push(...validateScenario(scenario));
+    const factTokens = [
+      ...scenario.correction?.retiredContent ?? [],
+      ...scenario.correction?.correctedContent ?? [],
+      ...scenario.scopedTwin ? [scenario.scopedTwin.twinContent] : [],
+      ...scenario.reassertion ? [scenario.reassertion.expectedContent] : []
+    ];
+    for (const token of factTokens) {
+      if (!ALL_TOKENS.has(token.toLowerCase())) {
+        errors.push({
+          scenarioId: scenario.id,
+          message: `fact token "${token}" is outside the synthetic pools (PII guard)`
+        });
+      }
+    }
+  }
+  return { ok: errors.length === 0, errors };
+}
+
+// src/benchmarks/remnic/memcorrect/metrics.ts
+function tokenize3(text) {
+  const tokens = text.toLowerCase().match(/[a-z0-9][a-z0-9-]*/g);
+  return new Set(tokens ?? []);
+}
+function containsAll(haystack, needles) {
+  if (needles.length === 0) return true;
+  const hay = tokenize3(haystack);
+  for (const needle of needles) {
+    if (!hay.has(needle.toLowerCase())) return false;
+  }
+  return true;
+}
+function joinedRecall(entry) {
+  return entry.recalled.join(" ");
+}
+function recallShowsStaleRetired(entry, correction) {
+  for (const recalled of entry.recalled) {
+    if (!containsAll(recalled, correction.retiredContent)) continue;
+    if (!containsAll(recalled, correction.correctedContent)) return true;
+  }
+  return false;
+}
+function probePassesForCorrection(entry, correction) {
+  const hay = joinedRecall(entry);
+  return containsAll(hay, correction.correctedContent) && !recallShowsStaleRetired(entry, correction);
+}
+function entriesFor(log, scenarioId, phase) {
+  return log.filter((e) => e.scenarioId === scenarioId && e.phase === phase);
+}
+function uptakeAtNext(log, corrections) {
+  if (corrections.length === 0) return 0;
+  let passed = 0;
+  for (const correction of corrections) {
+    const post = entriesFor(log, correction.scenarioId, "post_correction").sort((a, b) => a.turnIndex - b.turnIndex);
+    const eligible = post.filter((e) => e.turnIndex > correction.turnIndex);
+    const first = eligible[0];
+    if (first && probePassesForCorrection(first, correction)) passed += 1;
+  }
+  return passed / corrections.length;
+}
+function uptakeLatency(log, corrections, cap) {
+  if (corrections.length === 0) return { mean: 0, censored: 0 };
+  let sum = 0;
+  let censored = 0;
+  for (const correction of corrections) {
+    const post = entriesFor(log, correction.scenarioId, "post_correction").sort((a, b) => a.turnIndex - b.turnIndex).filter((e) => e.turnIndex > correction.turnIndex);
+    let resolved = cap;
+    let found = false;
+    for (const entry of post) {
+      const delta = entry.turnIndex - correction.turnIndex;
+      if (delta > cap) break;
+      if (probePassesForCorrection(entry, correction)) {
+        resolved = delta;
+        found = true;
+        break;
+      }
+    }
+    if (!found) censored += 1;
+    sum += resolved;
+  }
+  return { mean: sum / corrections.length, censored };
+}
+function nonResurrection(log, corrections) {
+  if (corrections.length === 0) return 0;
+  let stayedRetired = 0;
+  for (const correction of corrections) {
+    const postMaint = entriesFor(log, correction.scenarioId, "post_maintenance");
+    const postReingest = entriesFor(log, correction.scenarioId, "post_reingest");
+    const both = [...postMaint, ...postReingest];
+    if (both.length === 0) continue;
+    const allRetired = both.every(
+      (e) => !recallShowsStaleRetired(e, correction)
+    );
+    if (allRetired) stayedRetired += 1;
+  }
+  return corrections.length > 0 ? stayedRetired / corrections.length : 0;
+}
+function collateralDelta(before, after) {
+  if (before.length === 0) return 0;
+  const mean3 = (xs) => xs.reduce((s, x) => s + x, 0) / xs.length;
+  return mean3(after) - mean3(before);
+}
+function scopePrecision(log, corrections) {
+  let scopedCount = 0;
+  let passed = 0;
+  for (const correction of corrections) {
+    const twin = correction.scopedTwin;
+    if (!twin) continue;
+    scopedCount += 1;
+    const primaryPost = entriesFor(log, correction.scenarioId, "post_correction").filter((e) => e.turnIndex > correction.turnIndex).sort((a, b) => a.turnIndex - b.turnIndex)[0];
+    const twinPost = log.filter(
+      (e) => e.scenarioId === correction.scenarioId && e.namespace === twin.namespace && e.phase === "post_correction" && e.turnIndex > correction.turnIndex
+    ).sort((a, b) => a.turnIndex - b.turnIndex)[0];
+    if (!primaryPost || !twinPost) continue;
+    const primaryRetired = !recallShowsStaleRetired(primaryPost, correction);
+    const twinIntact = containsAll(joinedRecall(twinPost), [twin.twinContent]);
+    if (primaryRetired && twinIntact) passed += 1;
+  }
+  return scopedCount > 0 ? passed / scopedCount : null;
+}
+function falseApply(log, antiEvents) {
+  if (antiEvents.length === 0) return 0;
+  let triggered = 0;
+  for (const anti of antiEvents) {
+    const probes = log.filter(
+      (e) => e.scenarioId === anti.scenarioId && e.phase === "post_correction"
+    );
+    const leaked = probes.some(
+      (e) => containsAll(joinedRecall(e), [anti.shouldNotAppear])
+    );
+    if (leaked) triggered += 1;
+  }
+  return triggered / antiEvents.length;
+}
+function reassertion(log, reassertions) {
+  if (reassertions.length === 0) return null;
+  let recalled = 0;
+  for (const re of reassertions) {
+    const post = entriesFor(log, re.scenarioId, "post_reassertion");
+    const found = post.some(
+      (e) => containsAll(joinedRecall(e), [re.expectedContent])
+    );
+    if (found) recalled += 1;
+  }
+  return recalled / reassertions.length;
+}
+function provenanceFidelity(citeLog) {
+  if (citeLog.length === 0) return null;
+  if (citeLog.every((v) => v === null)) return null;
+  const scored = citeLog.filter((v) => v !== null);
+  if (scored.length === 0) return null;
+  return scored.reduce((s, v) => s + v, 0) / scored.length;
+}
+function computeMetricBundle(args) {
+  const latency = uptakeLatency(
+    args.log,
+    args.corrections,
+    args.uptakeLatencyCap
+  );
+  return {
+    uptake_at_next: uptakeAtNext(args.log, args.corrections),
+    uptake_latency: latency.mean,
+    uptake_latency_censored: latency.censored,
+    non_resurrection: nonResurrection(args.log, args.corrections),
+    collateral_delta: collateralDelta(args.collateralBefore, args.collateralAfter),
+    scope_precision: scopePrecision(args.log, args.corrections),
+    false_apply: falseApply(args.log, args.antiEvents),
+    reassertion: reassertion(args.log, args.reassertions),
+    provenance_fidelity: provenanceFidelity(args.provenanceCites)
+  };
+}
+
+// src/benchmarks/remnic/memcorrect/adapters.ts
+function createRemnicMemCorrectAdapter(adapter, options = {}) {
+  const label = options.label ?? "remnic-native";
+  const sessionPrefix = options.sessionPrefix ?? "memcorrect";
+  return {
+    label,
+    async reset() {
+      await adapter.reset();
+    },
+    async ingestTurn(sessionKey, role, text, at) {
+      await adapter.store(`${sessionPrefix}:${sessionKey}`, [
+        { role, content: text, timestamp: at }
+      ]);
+    },
+    async recall(query, sessionKey) {
+      const text = await adapter.recall(`${sessionPrefix}:${sessionKey}`, query);
+      const trimmed = text.trim();
+      if (trimmed.length === 0) return [];
+      return trimmed.split(/\n\s*\n/).map((s) => s.trim()).filter((s) => s.length > 0);
+    },
+    async correct(text, sessionKey, at) {
+      await adapter.store(`${sessionPrefix}:${sessionKey}`, [
+        { role: "user", content: text, timestamp: at }
+      ]);
+    },
+    async runMaintenance() {
+      await adapter.drain?.();
+    }
+  };
+}
+
+// src/benchmarks/remnic/memcorrect/runner.ts
+var memcorrectDefinition = {
+  id: "memcorrect-v1",
+  title: "MemCorrect (correction / steerability)",
+  tier: "remnic",
+  status: "ready",
+  runnerAvailable: true,
+  meta: {
+    name: "memcorrect-v1",
+    version: "1.0.0",
+    description: "Open correction/steerability benchmark: uptake, non-resurrection, collateral, scope-precision, false-apply, reassertion. System-agnostic adapter interface; hermetic seeded synthetic corpus.",
+    category: "conversational",
+    citation: "Remnic MemCorrect v1 (issue #1584). Open benchmark; adapter contract is the public contribution."
+  }
+};
+var MEMCORRECT_LOWER_IS_BETTER = /* @__PURE__ */ new Set([
+  "uptake_latency",
+  "uptake_latency_censored",
+  "false_apply"
+]);
+var QUICK_OPTIONS2 = {
+  personaCount: 2,
+  factsPerPersona: 4,
+  seed: 12613607,
+  nowIso: "2026-07-05T00:00:00.000Z",
+  maintenanceCycles: 3,
+  uptakeLatencyCap: 5
+};
+var FULL_OPTIONS2 = {
+  personaCount: 5,
+  factsPerPersona: 8,
+  seed: 12613607,
+  nowIso: "2026-07-05T00:00:00.000Z",
+  maintenanceCycles: 5,
+  uptakeLatencyCap: 8
+};
+function resolveAdapter(options) {
+  const override = options.benchmarkOptions?.["adapter"];
+  if (override && typeof override === "object" && "reset" in override && "ingestTurn" in override && "recall" in override) {
+    const adapter = override;
+    return { adapter, adapterLabel: adapter.label ?? "custom" };
+  }
+  return {
+    adapter: createRemnicMemCorrectAdapter(options.system, {
+      label: "remnic-native"
+    }),
+    adapterLabel: "remnic-native"
+  };
+}
+async function runScenario(scenario, adapter, maintenanceCycles, uptakeLatencyCap) {
+  await adapter.reset();
+  const log = [];
+  let turn = 0;
+  const sessionKey = scenario.namespace;
+  const recordProbe = (phase, query, namespace, recalled, at) => {
+    log.push({ scenarioId: scenario.id, phase, turnIndex: turn, namespace, query, recalled, at });
+  };
+  for (const t of scenario.establishingTurns) {
+    await adapter.ingestTurn(sessionKey, t.role, t.text, t.at);
+    turn += 1;
+  }
+  if (scenario.scopedTwin) {
+    for (const t of scenario.scopedTwin.establishingTurns) {
+      await adapter.ingestTurn(scenario.scopedTwin.namespace, t.role, t.text, t.at);
+      turn += 1;
+    }
+  }
+  for (const probe of scenario.unrelatedProbes) {
+    for (const t of probe.establishingTurns) {
+      await adapter.ingestTurn(sessionKey, t.role, t.text, t.at);
+      turn += 1;
+    }
+  }
+  const collateralBefore = [];
+  for (const probe of scenario.unrelatedProbes) {
+    turn += 1;
+    const recalled = await adapter.recall(probe.query, sessionKey);
+    recordProbe("baseline", probe.query, sessionKey, recalled, scenario.correction.turn.at);
+    collateralBefore.push(
+      containsAll(recalled.join(" "), [probe.expectedContent]) ? 1 : 0
+    );
+  }
+  await adapter.correct(scenario.correction.turn.text, sessionKey, scenario.correction.turn.at);
+  turn += 1;
+  const correctionTurnIndex = turn;
+  {
+    turn += 1;
+    const recalled = await adapter.recall(scenario.probe.query, sessionKey);
+    recordProbe("post_correction", scenario.probe.query, sessionKey, recalled, scenario.correction.turn.at);
+  }
+  for (const anti of scenario.antiEvents) {
+    await adapter.ingestTurn(sessionKey, anti.turn.role, anti.turn.text, anti.turn.at);
+    turn += 1;
+    turn += 1;
+    const recalled = await adapter.recall(anti.probeQuery, sessionKey);
+    recordProbe("post_correction", anti.probeQuery, sessionKey, recalled, anti.turn.at);
+  }
+  if (scenario.scopedTwin) {
+    turn += 1;
+    const recalled = await adapter.recall(scenario.probe.query, scenario.scopedTwin.namespace);
+    recordProbe("post_correction", scenario.probe.query, scenario.scopedTwin.namespace, recalled, scenario.correction.turn.at);
+  }
+  const collateralAfter = [];
+  for (const probe of scenario.unrelatedProbes) {
+    const recalled = await adapter.recall(probe.query, sessionKey);
+    collateralAfter.push(
+      containsAll(recalled.join(" "), [probe.expectedContent]) ? 1 : 0
+    );
+  }
+  for (let i = 0; i < maintenanceCycles; i += 1) {
+    await adapter.runMaintenance();
+    turn += 1;
+  }
+  {
+    const recalled = await adapter.recall(scenario.probe.query, sessionKey);
+    recordProbe("post_maintenance", scenario.probe.query, sessionKey, recalled, scenario.correction.turn.at);
+    turn += 1;
+  }
+  for (const t of scenario.establishingTurns) {
+    await adapter.ingestTurn(sessionKey, t.role, t.text, t.at);
+    turn += 1;
+  }
+  {
+    const recalled = await adapter.recall(scenario.probe.query, sessionKey);
+    recordProbe("post_reingest", scenario.probe.query, sessionKey, recalled, scenario.correction.turn.at);
+    turn += 1;
+  }
+  let reassertion2 = null;
+  if (scenario.reassertion) {
+    await adapter.ingestTurn(
+      sessionKey,
+      scenario.reassertion.turn.role,
+      scenario.reassertion.turn.text,
+      scenario.reassertion.turn.at
+    );
+    turn += 1;
+    const recalled = await adapter.recall(scenario.probe.query, sessionKey);
+    recordProbe("post_reassertion", scenario.probe.query, sessionKey, recalled, scenario.reassertion.turn.at);
+    turn += 1;
+    reassertion2 = {
+      scenarioId: scenario.id,
+      namespace: sessionKey,
+      expectedContent: scenario.reassertion.expectedContent
+    };
+  }
+  const correction = {
+    scenarioId: scenario.id,
+    namespace: sessionKey,
+    turnIndex: correctionTurnIndex,
+    retiredContent: scenario.correction.retiredContent,
+    correctedContent: scenario.correction.correctedContent,
+    scopedTwin: scenario.scopedTwin
+  };
+  const antiEvents = scenario.antiEvents.map((anti) => ({
+    scenarioId: scenario.id,
+    namespace: sessionKey,
+    probeQuery: anti.probeQuery,
+    shouldNotAppear: anti.shouldNotAppear
+  }));
+  const provenanceCite = null;
+  const metrics = computeMetricBundle({
+    log,
+    corrections: [correction],
+    antiEvents,
+    reassertions: reassertion2 ? [reassertion2] : [],
+    collateralBefore,
+    collateralAfter,
+    provenanceCites: [provenanceCite],
+    uptakeLatencyCap
+  });
+  return {
+    log,
+    correction,
+    antiEvents,
+    reassertion: reassertion2,
+    collateralBefore,
+    collateralAfter,
+    provenanceCite,
+    metrics
+  };
+}
+async function runMemCorrectBenchmark(options) {
+  const baseOptions = options.mode === "quick" ? QUICK_OPTIONS2 : FULL_OPTIONS2;
+  const seed = typeof options.seed === "number" ? options.seed : baseOptions.seed;
+  const generatorOptions = { ...baseOptions, seed };
+  const corpus = generateMemCorrectCorpus(generatorOptions);
+  const validation = validateCorpus(corpus);
+  if (!validation.ok) {
+    throw new Error(
+      `MemCorrect corpus failed schema validation: ${validation.errors.map((e) => `${e.scenarioId}: ${e.message}`).join("; ")}`
+    );
+  }
+  const { adapter, adapterLabel } = resolveAdapter(options);
+  const { limit } = options;
+  let scenarios;
+  if (typeof limit !== "number") {
+    scenarios = corpus.scenarios;
+  } else if (!Number.isInteger(limit) || limit < 0) {
+    throw new Error(
+      `MemCorrect --limit must be a non-negative integer; got ${String(limit)}`
+    );
+  } else {
+    scenarios = corpus.scenarios.slice(0, limit);
+  }
+  const tasks = [];
+  const aggregateLog = [];
+  const aggregateCorrections = [];
+  const aggregateAntiEvents = [];
+  const aggregateReassertions = [];
+  const aggregateCollateralBefore = [];
+  const aggregateCollateralAfter = [];
+  const aggregateProvenance = [];
+  for (const scenario of scenarios) {
+    const started = performance.now();
+    const run = await runScenario(
+      scenario,
+      adapter,
+      generatorOptions.maintenanceCycles,
+      generatorOptions.uptakeLatencyCap
+    );
+    const latencyMs = Math.round(performance.now() - started);
+    aggregateLog.push(...run.log);
+    aggregateCorrections.push(run.correction);
+    aggregateAntiEvents.push(...run.antiEvents);
+    if (run.reassertion) aggregateReassertions.push(run.reassertion);
+    aggregateCollateralBefore.push(...run.collateralBefore);
+    aggregateCollateralAfter.push(...run.collateralAfter);
+    aggregateProvenance.push(run.provenanceCite);
+    const m = run.metrics;
+    const scores = {
+      uptake_at_next: m.uptake_at_next,
+      uptake_latency: m.uptake_latency,
+      uptake_latency_censored: m.uptake_latency_censored,
+      non_resurrection: m.non_resurrection,
+      false_apply: m.false_apply
+    };
+    if (m.scope_precision !== null) scores.scope_precision = m.scope_precision;
+    if (m.reassertion !== null) scores.reassertion = m.reassertion;
+    const task = {
+      taskId: scenario.id,
+      question: scenario.probe.query,
+      expected: JSON.stringify({
+        correctedContent: scenario.correction.correctedContent,
+        retiredContent: scenario.correction.retiredContent
+      }),
+      actual: JSON.stringify({
+        shape: scenario.correction.shape,
+        namespace: scenario.namespace,
+        postCorrectionRecall: run.log.find(
+          (e) => e.phase === "post_correction" && e.namespace === scenario.namespace
+        )?.recalled.slice(0, 3) ?? []
+      }),
+      scores,
+      latencyMs,
+      tokens: { input: 0, output: 0 },
+      details: {
+        scenarioId: scenario.id,
+        shape: scenario.correction.shape,
+        category: scenario.category,
+        namespace: scenario.namespace,
+        adapter: adapterLabel,
+        metrics: {
+          memcorrect: m
+        }
+      }
+    };
+    tasks.push(task);
+    options.onTaskComplete?.(task, tasks.length, scenarios.length);
+  }
+  const aggregateMetrics = computeMetricBundle({
+    log: aggregateLog,
+    corrections: aggregateCorrections,
+    antiEvents: aggregateAntiEvents,
+    reassertions: aggregateReassertions,
+    collateralBefore: aggregateCollateralBefore,
+    collateralAfter: aggregateCollateralAfter,
+    provenanceCites: aggregateProvenance,
+    uptakeLatencyCap: generatorOptions.uptakeLatencyCap
+  });
+  const remnicVersion = await getRemnicVersion();
+  const totalLatencyMs = tasks.reduce((sum, t) => sum + t.latencyMs, 0);
+  const { adapter: _liveAdapter, ...persistableBenchmarkOptions } = options.benchmarkOptions ?? {};
+  return {
+    meta: {
+      id: randomUUID31(),
+      benchmark: options.benchmark.id,
+      benchmarkTier: options.benchmark.tier,
+      version: options.benchmark.meta.version,
+      remnicVersion,
+      gitSha: getGitSha(),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      mode: options.mode,
+      runCount: 1,
+      seeds: [seed],
+      datasetHash: corpusHash(corpus)
+    },
+    config: {
+      runtimeProfile: options.runtimeProfile ?? null,
+      systemProvider: options.systemProvider ?? null,
+      judgeProvider: options.judgeProvider ?? null,
+      adapterMode: adapterLabel,
+      remnicConfig: options.remnicConfig ?? {},
+      benchmarkOptions: {
+        ...persistableBenchmarkOptions,
+        personaCount: generatorOptions.personaCount,
+        factsPerPersona: generatorOptions.factsPerPersona,
+        maintenanceCycles: generatorOptions.maintenanceCycles,
+        uptakeLatencyCap: generatorOptions.uptakeLatencyCap,
+        // Headline metric bundle computed across the union of all scenario
+        // probe logs (more robust than the per-task mean for fraction
+        // metrics when scenario sizes vary). `aggregateTaskScores` in
+        // results.aggregates is the per-task-mean view.
+        aggregateMetrics
+      }
+    },
+    cost: {
+      totalTokens: 0,
+      inputTokens: 0,
+      outputTokens: 0,
+      estimatedCostUsd: 0,
+      totalLatencyMs,
+      meanQueryLatencyMs: tasks.length > 0 ? totalLatencyMs / tasks.length : 0,
+      judgeModelCalls: 0
+    },
+    results: {
+      tasks,
+      aggregates: aggregateTaskScores(tasks.map((t) => t.scores)),
+      statistics: {
+        confidenceIntervals: {},
+        bootstrapSamples: 0
+      }
+    },
+    environment: {
+      os: process.platform,
+      nodeVersion: process.version,
+      hardware: process.arch
+    }
+  };
+}
+
 // src/registry.ts
 var REGISTERED_BENCHMARKS = [
   {
@@ -29995,6 +31108,10 @@ var REGISTERED_BENCHMARKS = [
   {
     ...retentionAgedDatasetDefinition,
     run: runRetentionAgedDatasetBenchmark
+  },
+  {
+    ...memcorrectDefinition,
+    run: runMemCorrectBenchmark
   }
 ];
 function listBenchmarks() {
@@ -30023,8 +31140,9 @@ function finalizeBenchmarkResultConfig(result, options) {
   result.config.runtimeProfile ??= options.runtimeProfile ?? null;
   result.config.internalProvider ??= options.internalProvider ?? null;
   if (options.benchmarkOptions !== void 0 || options.limit !== void 0) {
+    const { adapter: _omitAdapter, ...persistableOptions } = options.benchmarkOptions ?? {};
     result.config.benchmarkOptions = {
-      ...options.benchmarkOptions,
+      ...persistableOptions,
       ...options.limit !== void 0 ? { limit: options.limit } : {},
       ...result.config.benchmarkOptions ?? {}
     };
@@ -30234,13 +31352,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: createHash9("sha256").update(JUDGE_CACHE_PROTOCOL_VERSION).update("
").update(args.amaBenchJudgeProtocol).update("
").update(args.role).digest("hex"),
+      judgePromptHash: createHash10("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: createHash9("sha256").update(
+      judgeParamsHash: createHash10("sha256").update(
         stableStringify2({
           role: args.role,
           provider: args.provider
@@ -30671,7 +31789,8 @@ function compareResults(baseline, candidate, threshold = 0.05, lowerIsBetter = /
 }
 var LOWER_IS_BETTER_BY_BENCHMARK = {
   "ingestion-setup-friction": INGESTION_SETUP_FRICTION_LOWER_IS_BETTER,
-  "retrieval-reasoning-trace": RETRIEVAL_REASONING_TRACE_LOWER_IS_BETTER
+  "retrieval-reasoning-trace": RETRIEVAL_REASONING_TRACE_LOWER_IS_BETTER,
+  "memcorrect-v1": MEMCORRECT_LOWER_IS_BETTER
 };
 function getBenchmarkLowerIsBetter(benchmarkId) {
   return LOWER_IS_BETTER_BY_BENCHMARK[benchmarkId] ?? /* @__PURE__ */ new Set();
@@ -30995,7 +32114,7 @@ function formatError(error) {
 }
 
 // src/benchmarks/custom/runner.ts
-import { randomUUID as randomUUID31 } from "crypto";
+import { randomUUID as randomUUID32 } from "crypto";
 import path33 from "path";
 import { expandTildePath as expandTildePath4 } from "@remnic/core";
 async function runCustomBenchmarkFile(filePath, options) {
@@ -31083,7 +32202,7 @@ async function runCustomBenchmark(spec, options) {
   const totalOutputTokens = tasks.reduce((sum, task) => sum + task.tokens.output, 0);
   return finalizeBenchmarkResultConfig({
     meta: {
-      id: randomUUID31(),
+      id: randomUUID32(),
       benchmark: options.benchmark.id,
       benchmarkTier: options.benchmark.tier,
       version: options.benchmark.meta.version,
@@ -32080,7 +33199,7 @@ var chatFixture = {
 };
 
 // src/judges/calibration-slice.ts
-import { createHash as createHash10, randomBytes as randomBytes3 } from "crypto";
+import { createHash as createHash11, randomBytes as randomBytes3 } from "crypto";
 import { mkdir as mkdir16, readFile as readFile21, rename as rename3, unlink as unlink3, writeFile as writeFile15 } from "fs/promises";
 import path34 from "path";
 
@@ -32157,7 +33276,7 @@ function selectCalibrationSlice(questionIds, size = CALIBRATION_SLICE_SIZE) {
       unique.push(id);
     }
   }
-  return unique.map((id) => ({ id, digest: createHash10("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: createHash11("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));
@@ -32823,7 +33942,7 @@ var PROCEDURAL_REAL_SCENARIOS_SMOKE = [
 ];
 
 // src/security/extraction-attack/tokenize.ts
-function tokenize3(text) {
+function tokenize4(text) {
   return text.toLowerCase().split(/[^a-z0-9]+/u).filter((t) => t.length > 2);
 }
 
@@ -32865,7 +33984,7 @@ function createSeededRng2(seed) {
     }
   };
 }
-var tokenizeContent = tokenize3;
+var tokenizeContent = tokenize4;
 function recoveryTokensFor(memory) {
   if (memory.tokens && memory.tokens.length > 0) {
     const seen = /* @__PURE__ */ new Set();
@@ -33344,11 +34463,11 @@ function createSyntheticTarget(options) {
   }
   const normalized = memories.map((m) => ({
     memory: m,
-    tokens: new Set((m.tokens ?? tokenize3(m.content)).map((t) => t.toLowerCase()))
+    tokens: new Set((m.tokens ?? tokenize4(m.content)).map((t) => t.toLowerCase()))
   }));
   return {
     async recall(query, recallOptions) {
-      const qTokens = tokenize3(query);
+      const qTokens = tokenize4(query);
       if (qTokens.length === 0) return [];
       const requestedNs = recallOptions?.namespace;
       if (enforceNamespaceAcl && requestedNs !== void 0 && requestedNs !== allowedNamespace) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remnic/bench",
-  "version": "9.3.704",
+  "version": "9.3.706",
   "description": "Retrieval latency ladder benchmarks + CI regression gates for @remnic/core",
   "type": "module",
   "main": "./dist/index.js",
@@ -36,7 +36,7 @@
   "dependencies": {
     "hyparquet": "^1.25.7",
     "yaml": "^2.4.2",
-    "@remnic/core": "^9.3.704"
+    "@remnic/core": "^9.3.706"
   },
   "devDependencies": {
     "tsup": "^8.5.1",