@remnic/bench 9.6.18 → 9.6.19

package/dist/index.js

@@ -644,6 +644,140 @@ function benchmarkRecallBudgetForSessionCount(sessionCount) {
 }
 
 // src/adapters/remnic-adapter.ts
+var DEFAULT_ANSWER_SUPPORT_MIN_COVERAGE = 0.34;
+var ANSWER_SUPPORT_STOP_WORDS = /* @__PURE__ */ new Set([
+  "about",
+  "after",
+  "again",
+  "also",
+  "answer",
+  "before",
+  "being",
+  "could",
+  "does",
+  "from",
+  "have",
+  "information",
+  "into",
+  "just",
+  "know",
+  "memory",
+  "might",
+  "please",
+  "question",
+  "recall",
+  "remember",
+  "should",
+  "that",
+  "their",
+  "there",
+  "these",
+  "they",
+  "this",
+  "those",
+  "user",
+  "using",
+  "what",
+  "when",
+  "where",
+  "which",
+  "while",
+  "with",
+  "would",
+  "your"
+]);
+function resolveAnswerSupportMinCoverage(config) {
+  const raw = config?.answerSupportMinCoverage;
+  if (raw === void 0) return DEFAULT_ANSWER_SUPPORT_MIN_COVERAGE;
+  const parsed = typeof raw === "number" ? raw : Number(raw);
+  if (!Number.isFinite(parsed) || parsed <= 0 || parsed > 1) {
+    throw new Error("answerSupportMinCoverage must be a finite number greater than 0 and at most 1.");
+  }
+  return parsed;
+}
+function resolveSkipExtractionLcmFirst(config) {
+  const raw = config?.skipExtractionLcmFirst;
+  if (raw === void 0) return true;
+  if (typeof raw === "boolean") return raw;
+  if (typeof raw === "string") {
+    const normalized = raw.trim().toLowerCase();
+    if (["true", "1", "yes", "on"].includes(normalized)) return true;
+    if (["false", "0", "no", "off"].includes(normalized)) return false;
+  }
+  throw new Error(
+    "skipExtractionLcmFirst must be a boolean or one of true/false, 1/0, yes/no, on/off."
+  );
+}
+function shouldIncludeCoreRecallForReplay(options) {
+  return options.useCoreMemoryPipeline && (options.replayExtractionMode !== "skip" || !options.skipExtractionLcmFirst);
+}
+function normalizeSupportToken(value) {
+  if (value.length > 5 && value.endsWith("ing")) return value.slice(0, -3);
+  if (value.length > 4 && value.endsWith("ed")) {
+    const base = value.slice(0, -2);
+    return /[vs]$/.test(base) ? `${base}e` : base;
+  }
+  if (value.length > 4 && value.endsWith("es")) return value.slice(0, -2);
+  if (value.length > 3 && value.endsWith("s")) return value.slice(0, -1);
+  return value;
+}
+function supportTerms(value) {
+  return [...new Set(
+    (value.toLowerCase().match(/[\p{L}\p{N}][\p{L}\p{N}_-]{2,}/gu) ?? []).filter((term) => !ANSWER_SUPPORT_STOP_WORDS.has(term)).map(normalizeSupportToken).filter((term) => !ANSWER_SUPPORT_STOP_WORDS.has(term) && !/^\d+$/.test(term))
+  )];
+}
+function exactContextEvidenceLines(recalledText) {
+  return recalledText.split(/\r?\n/).map((line) => line.trim()).filter((line) => {
+    if (!line || /^#{1,6}\s/.test(line)) return false;
+    return !/^(?:answer guidance:|distinct user-stated targets found:|no (?:direct|historically valid)|these direct temporal statements|this is the most recent|use this list|when answering)/i.test(line);
+  });
+}
+function assessRemnicRecallSupport(request, supportThreshold = DEFAULT_ANSWER_SUPPORT_MIN_COVERAGE) {
+  if (request.recalledText.trim().length === 0) {
+    return { status: "empty", reason: "exact responder context is empty", evidenceCount: 0 };
+  }
+  const queryTerms = supportTerms(request.query);
+  if (queryTerms.length < 2) {
+    return {
+      status: "unavailable",
+      reason: "query has fewer than two distinctive terms for conservative support scoring"
+    };
+  }
+  const evidenceLines = exactContextEvidenceLines(request.recalledText);
+  const evidenceTermSets = evidenceLines.map((line) => new Set(supportTerms(line)));
+  const matchedTerms = queryTerms.filter(
+    (term) => evidenceTermSets.some((terms) => terms.has(term))
+  );
+  const evidenceCount = evidenceTermSets.filter(
+    (terms) => matchedTerms.some((term) => terms.has(term))
+  ).length;
+  const coverage = matchedTerms.length / queryTerms.length;
+  if (evidenceCount === 0) {
+    return {
+      status: "empty",
+      reason: "exact responder context contains no matching evidence terms",
+      evidenceCount: 0,
+      maxScore: 0,
+      supportThreshold
+    };
+  }
+  if (coverage < supportThreshold) {
+    return {
+      status: "weak",
+      reason: "exact responder context has only weak lexical support",
+      evidenceCount,
+      maxScore: coverage,
+      supportThreshold
+    };
+  }
+  return {
+    status: "supported",
+    reason: "exact responder context has sufficient lexical support",
+    evidenceCount,
+    maxScore: coverage,
+    supportThreshold
+  };
+}
 var BENCH_ADAPTER_SHARED_CONFIG = {
   qmdEnabled: false,
   qmdColdTierEnabled: false,
@@ -1733,6 +1867,12 @@ function createAdapterFactory(mode) {
   return async function createAdapter(options = {}) {
     const useCoreMemoryPipeline = shouldUseCoreMemoryPipeline(mode, options);
     const replayExtractionMode = options.replayExtractionMode ?? "await";
+    const answerSupportMinCoverage = resolveAnswerSupportMinCoverage(
+      options.configOverrides
+    );
+    const skipExtractionLcmFirst = resolveSkipExtractionLcmFirst(
+      options.configOverrides
+    );
     const replaySourceValidAtMode = normalizeReplaySourceValidAtMode(
       options.replaySourceValidAtMode
     );
@@ -1999,6 +2139,11 @@ function createAdapterFactory(mode) {
         }
         const recallAsOf = normalizeBenchRecallAsOf(recallOptions.asOf);
         const historicalRecall = recallAsOf !== void 0;
+        const includeCoreRecall = shouldIncludeCoreRecallForReplay({
+          useCoreMemoryPipeline,
+          replayExtractionMode,
+          skipExtractionLcmFirst
+        });
         if (historicalRecall && (!useCoreMemoryPipeline || replayExtractionMode === "skip" || replaySourceValidAtMode !== "historical")) {
           throw new Error(
             "benchmark historical recall requires core replay extraction with replaySourceValidAtMode=historical; enable the core memory pipeline and do not use replayExtractionMode=skip"
@@ -2097,7 +2242,7 @@ function createAdapterFactory(mode) {
           sections.push(trajectoryAnalysisEvidence);
           usedChars += trajectoryAnalysisEvidence.length;
         }
-        if (useCoreMemoryPipeline && !requireDirectPersonalHistoryEvidence && !requireDirectTemporalEvidence && !hasTemporalIntervalEvidence && !hasDependencyVersionEvidence && !hasUserImplementationTargetEvidence) {
+        if (includeCoreRecall && !requireDirectPersonalHistoryEvidence && !requireDirectTemporalEvidence && !hasTemporalIntervalEvidence && !hasDependencyVersionEvidence && !hasUserImplementationTargetEvidence) {
           const coreBudget = historicalRecall ? Math.max(0, budget - usedChars) : Math.max(
             0,
             Math.min(
@@ -2135,7 +2280,7 @@ ${coreRecall.trim()}`;
         const suppressBroadSummary = historicalRecall || requireDirectPersonalHistoryEvidence || requireDirectTemporalEvidence || hasTemporalIntervalEvidence || hasDependencyVersionEvidence || hasUserImplementationTargetEvidence || preferFocusedExplicitContext && !!exactReferenceEvidence;
         if (query && !historicalRecall && !hasTemporalIntervalEvidence && !hasDependencyVersionEvidence && !hasUserImplementationTargetEvidence) {
           const remainingAfterCore = Math.max(0, budget - usedChars);
-          const searchBudget = useCoreMemoryPipeline ? Math.max(0, Math.floor(remainingAfterCore * 0.75)) : Math.max(0, Math.floor(remainingAfterCore * 0.7));
+          const searchBudget = includeCoreRecall ? Math.max(0, Math.floor(remainingAfterCore * 0.75)) : Math.max(0, Math.floor(remainingAfterCore * 0.7));
           const searchLimit = Math.max(6, Math.min(18, Math.floor(budget / 2e3)));
           const searchResults = await waitForRecall(
             engine.searchContextFull(
@@ -2151,7 +2296,7 @@ ${coreRecall.trim()}`;
             const directTemporalTurnIds = /* @__PURE__ */ new Set();
             for (const result of searchResults) {
               throwIfBenchPhaseAborted(control, "recall");
-              const windowRadius = preferFocusedExplicitContext ? 2 : useCoreMemoryPipeline ? 3 : 1;
+              const windowRadius = preferFocusedExplicitContext ? 2 : includeCoreRecall ? 3 : 1;
               const fromTurn = Math.max(0, result.turn_index - windowRadius);
               const toTurn = result.turn_index + windowRadius;
               const expanded = await waitForRecall(
@@ -2159,7 +2304,7 @@ ${coreRecall.trim()}`;
                   result.session_id,
                   fromTurn,
                   toTurn,
-                  useCoreMemoryPipeline ? 1600 : 600
+                  includeCoreRecall ? 1600 : 600
                 )
               );
               if (expanded.length === 0) {
@@ -2320,6 +2465,10 @@ ${expanded.map((message) => `[${message.role}]: ${message.content}`).join("\n")}
         const joined = sections.join("\n\n");
         return joined.length > budget ? joined.slice(0, budget) : joined;
       },
+      async assessRecallSupport(request, control) {
+        throwIfBenchPhaseAborted(control, "assessRecallSupport");
+        return assessRemnicRecallSupport(request, answerSupportMinCoverage);
+      },
       async search(query, limit, sessionId, control) {
         throwIfBenchPhaseAborted(control, "search");
         const normalizedSessionId = normalizeOptionalBenchSessionId(sessionId);
@@ -3292,6 +3441,747 @@ ${message.content}`).digest("hex").slice(0, 16);
   return `bench-${index}-${digest}`;
 }
 
+// src/adapters/mcp-memory-adapter.ts
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { fileURLToPath } from "url";
+import { existsSync } from "fs";
+var McpMemoryBackendError = class extends Error {
+  code;
+  detail;
+  constructor(result) {
+    super(`${result.error}: ${result.detail}`, { cause: result.cause });
+    this.name = "McpMemoryBackendError";
+    this.code = result.error;
+    this.detail = result.detail;
+  }
+};
+var DEFAULT_TOOL_NAMES = {
+  store: ["store_memory", "add_memory", "memory_store", "create_memory"],
+  recall: ["search_memory", "recall", "memory_search", "search_memories"],
+  correct: ["correct_memory", "update_memory", "memory_correct", "update_memories"],
+  reset: ["delete_memory", "clear_memories", "memory_delete", "reset_memory"]
+};
+var ARGUMENT_ALIASES = {
+  namespace: ["namespace", "scope", "user_id", "userId", "run_id"],
+  sessionId: ["sessionId", "session_id", "session", "conversation_id"],
+  content: ["content", "text", "memory", "message", "correction"],
+  role: ["role", "speaker"],
+  timestamp: ["timestamp", "at", "created_at"],
+  query: ["query", "search", "q", "text"],
+  limit: ["limit", "top_k", "count", "max_results"]
+};
+var TOOL_OPERATIONS = Object.freeze([
+  "store",
+  "recall",
+  "correct",
+  "reset"
+]);
+var ARGUMENT_SEMANTICS = Object.freeze([
+  "namespace",
+  "sessionId",
+  "content",
+  "role",
+  "timestamp",
+  "query",
+  "limit"
+]);
+var DEFAULT_PREFLIGHT_TIMEOUT_MS = 3e4;
+var namespaceCounter = 0;
+function createNamespacePrefix() {
+  namespaceCounter += 1;
+  return `remnic-bench-${process.pid.toString(36)}-${Date.now().toString(36)}-${namespaceCounter.toString(36)}`;
+}
+var SdkMcpToolClient = class _SdkMcpToolClient {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  static async connect(config, control) {
+    const client = new Client({ name: "remnic-bench", version: "1.0.0" });
+    const transport = config.type === "stdio" ? new StdioClientTransport({
+      command: config.command,
+      args: config.args,
+      cwd: config.cwd,
+      env: config.env,
+      stderr: "inherit"
+    }) : new StreamableHTTPClientTransport(new URL(config.url), {
+      requestInit: {
+        headers: {
+          ...config.bearerToken ? { authorization: `Bearer ${config.bearerToken}` } : {},
+          ...config.headers ?? {}
+        }
+      }
+    });
+    try {
+      await client.connect(transport, { signal: control?.signal });
+      return new _SdkMcpToolClient(client);
+    } catch (error) {
+      await raceWithSignal(client.close(), AbortSignal.timeout(2e3), "MCP SDK client close").catch(() => {
+      });
+      throw error;
+    }
+  }
+  async listTools(control) {
+    const result = await this.client.listTools(void 0, { signal: control?.signal });
+    return result.tools;
+  }
+  async callTool(name, args, control) {
+    const result = await this.client.callTool({ name, arguments: args }, void 0, { signal: control?.signal });
+    if ("toolResult" in result) {
+      return { structuredContent: { result: result.toolResult } };
+    }
+    return result;
+  }
+  async close() {
+    await this.client.close();
+  }
+};
+var McpMemoryBackend = class {
+  constructor(options) {
+    this.options = options;
+    validateMcpToolMapping(options.tools);
+    if (options.timeoutMs !== void 0 && (!Number.isInteger(options.timeoutMs) || options.timeoutMs <= 0)) {
+      throw new Error("MCP adapter timeoutMs must be a positive integer");
+    }
+    this.label = options.label ?? "mcp";
+    this.namespacePrefix = options.namespacePrefix ?? createNamespacePrefix();
+    this.timeoutMs = options.timeoutMs ?? DEFAULT_PREFLIGHT_TIMEOUT_MS;
+  }
+  options;
+  label;
+  namespacePrefix;
+  client;
+  resolvedTools;
+  preflightResult;
+  sessions = /* @__PURE__ */ new Set();
+  messageCounts = /* @__PURE__ */ new Map();
+  timeoutMs;
+  async preflight(control) {
+    if (this.preflightResult) return this.preflightResult;
+    try {
+      this.preflightResult = await withTimeoutControl(
+        this.timeoutMs,
+        control,
+        "MCP adapter preflight",
+        async (boundedControl) => {
+          await this.ensureResolved(boundedControl);
+          const sessionId = "conformance";
+          const oldToken = `canary-old-${this.namespacePrefix}`;
+          const newToken = `canary-new-${this.namespacePrefix}`;
+          await this.store(sessionId, [{ role: "user", content: oldToken }], boundedControl, true);
+          const before = await this.recall(sessionId, oldToken, 4e3, boundedControl, true);
+          if (!before.some((item) => item.includes(oldToken))) {
+            throw new Error("stored canary was not returned by recall");
+          }
+          const applied = await this.correct(
+            sessionId,
+            `Correction: replace ${oldToken} with ${newToken}.`,
+            void 0,
+            boundedControl,
+            true
+          );
+          if (!applied) {
+            throw new Error("correction canary was explicitly refused (applied=false)");
+          }
+          const after = await this.recall(sessionId, newToken, 4e3, boundedControl, true);
+          if (!after.some((item) => item.includes(newToken))) {
+            throw new Error("corrected canary was not returned by recall");
+          }
+          if (after.some((item) => item.includes(oldToken))) {
+            throw new Error("retired canary was still returned after correction");
+          }
+          await this.reset(sessionId, boundedControl, true);
+          const deleted = await this.recall(sessionId, newToken, 4e3, boundedControl, true);
+          if (deleted.some((item) => item.includes(newToken) || item.includes(oldToken))) {
+            throw new Error("reset did not remove the conformance canary namespace");
+          }
+          return {
+            ok: true,
+            value: {
+              tools: Object.fromEntries(
+                Object.entries(this.resolvedTools).map(([key, value]) => [key, value.name])
+              ),
+              namespace: this.namespacePrefix
+            }
+          };
+        }
+      );
+    } catch (cause) {
+      const conformanceSession = this.scopedSession("conformance");
+      if (this.client && this.resolvedTools && this.sessions.has(conformanceSession)) {
+        try {
+          await withTimeoutControl(
+            Math.min(this.timeoutMs, 2e3),
+            void 0,
+            "MCP conformance cleanup",
+            (cleanupControl) => this.reset("conformance", cleanupControl, true)
+          );
+        } catch {
+        }
+      }
+      await this.closeClient();
+      this.preflightResult = {
+        ok: false,
+        error: "backend_unusable",
+        detail: cause instanceof Error ? cause.message : String(cause),
+        cause
+      };
+    }
+    return this.preflightResult;
+  }
+  async assertUsable(control) {
+    if (this.options.skipPreflight) {
+      await this.ensureResolved(control);
+      return;
+    }
+    const result = await this.preflight(control);
+    if (!result.ok) throw new McpMemoryBackendError(result);
+  }
+  async store(sessionId, messages, control, duringPreflight = false) {
+    if (!duringPreflight) await this.assertUsable(control);
+    const scoped = this.scopedSession(sessionId);
+    this.sessions.add(scoped);
+    for (const message of messages) {
+      const payload = await this.invoke(
+        "store",
+        {
+          namespace: this.namespacePrefix,
+          sessionId: scoped,
+          content: message.content,
+          role: message.role,
+          timestamp: message.timestamp
+        },
+        control
+      );
+      if (!validateMutationAcknowledgement("store", payload)) {
+        throw invalidResponse("store", "server returned a negative acknowledgement");
+      }
+      this.messageCounts.set(scoped, (this.messageCounts.get(scoped) ?? 0) + 1);
+    }
+  }
+  async recall(sessionId, query, budgetChars = 16e3, control, duringPreflight = false) {
+    if (!duringPreflight) await this.assertUsable(control);
+    const raw = await this.invoke(
+      "recall",
+      {
+        namespace: this.namespacePrefix,
+        sessionId: this.scopedSession(sessionId),
+        query,
+        limit: 20
+      },
+      control
+    );
+    const strings = validateRecallResponse(raw);
+    const output = [];
+    let used = 0;
+    for (const value of strings) {
+      if (used >= budgetChars) break;
+      const remaining = budgetChars - used;
+      output.push(value.slice(0, remaining));
+      used += Math.min(value.length, remaining);
+    }
+    return output;
+  }
+  async correct(sessionId, text, at, control, duringPreflight = false) {
+    if (!duringPreflight) await this.assertUsable(control);
+    const scoped = this.scopedSession(sessionId);
+    this.sessions.add(scoped);
+    const payload = await this.invoke(
+      "correct",
+      {
+        namespace: this.namespacePrefix,
+        sessionId: scoped,
+        content: text,
+        timestamp: at
+      },
+      control
+    );
+    return validateMutationAcknowledgement("correct", payload);
+  }
+  async reset(sessionId, control, duringPreflight = false) {
+    if (!duringPreflight) await this.assertUsable(control);
+    const targets = sessionId ? [this.scopedSession(sessionId)] : [...this.sessions];
+    for (const target of targets) {
+      const payload = await this.invoke(
+        "reset",
+        {
+          namespace: this.namespacePrefix,
+          sessionId: target
+        },
+        control
+      );
+      if (!validateMutationAcknowledgement("reset", payload)) {
+        throw invalidResponse("reset", "server returned a negative acknowledgement");
+      }
+      this.sessions.delete(target);
+      this.messageCounts.delete(target);
+    }
+  }
+  getStats(sessionId) {
+    const targets = sessionId ? [this.scopedSession(sessionId)] : [...this.messageCounts.keys()];
+    return {
+      totalMessages: targets.reduce((sum, target) => sum + (this.messageCounts.get(target) ?? 0), 0),
+      totalSummaryNodes: 0,
+      maxDepth: 0
+    };
+  }
+  async destroy() {
+    try {
+      if (this.client && this.resolvedTools) {
+        await withTimeoutControl(
+          Math.min(this.timeoutMs, 2e3),
+          void 0,
+          "MCP adapter cleanup",
+          (cleanupControl) => this.reset(void 0, cleanupControl, true)
+        );
+      }
+    } finally {
+      await this.closeClient();
+    }
+  }
+  scopedSession(sessionId) {
+    return `${this.namespacePrefix}:${sessionId}`;
+  }
+  async ensureResolved(control) {
+    if (this.resolvedTools) return;
+    let candidate;
+    try {
+      const pendingClient = (this.options.clientFactory ?? SdkMcpToolClient.connect)(this.options.transport, control);
+      candidate = await raceWithSignal(pendingClient, control?.signal, "MCP client connection", async (lateClient) => {
+        await closeToolClient(lateClient, this.timeoutMs);
+      });
+      const listed = await raceWithSignal(candidate.listTools(control), control?.signal, "MCP tool discovery");
+      const resolved = resolveTools(listed, this.options.tools);
+      this.client = candidate;
+      this.resolvedTools = resolved;
+    } catch (cause) {
+      if (candidate) await closeToolClient(candidate, this.timeoutMs);
+      this.client = void 0;
+      this.resolvedTools = void 0;
+      throw new McpMemoryBackendError({
+        ok: false,
+        error: "transport_failure",
+        detail: cause instanceof Error ? cause.message : String(cause),
+        cause
+      });
+    }
+  }
+  async invoke(operation, values, control) {
+    await this.ensureResolved(control);
+    const tool = this.resolvedTools[operation];
+    const args = buildArguments(tool, values);
+    try {
+      const result = await this.client.callTool(tool.name, args, control);
+      if (result.isError) {
+        throw new Error(
+          extractStrings(readToolPayload(result, tool.resultPath)).join("; ") || "MCP tool returned isError=true"
+        );
+      }
+      return readToolPayload(result, tool.resultPath);
+    } catch (cause) {
+      if (cause instanceof McpMemoryBackendError) throw cause;
+      throw new McpMemoryBackendError({
+        ok: false,
+        error: "tool_failure",
+        detail: `${operation} tool ${tool.name} failed: ${cause instanceof Error ? cause.message : String(cause)}`,
+        cause
+      });
+    }
+  }
+  async closeClient() {
+    const client = this.client;
+    this.client = void 0;
+    this.resolvedTools = void 0;
+    if (client) await closeToolClient(client, this.timeoutMs);
+  }
+};
+async function createMcpMemoryAdapter(options) {
+  const backend = new McpMemoryBackend(options);
+  const adapter = {
+    label: backend.label,
+    namespacePrefix: backend.namespacePrefix,
+    preflight: (control) => backend.preflight(control),
+    store: (sessionId, messages, control) => backend.store(sessionId, messages, control),
+    async recall(sessionId, query, budgetChars, _options, control) {
+      return (await backend.recall(sessionId, query, budgetChars, control)).join("\n");
+    },
+    async search(query, limit, sessionId, control) {
+      const recalled = await backend.recall(sessionId ?? "global", query, 64e3, control);
+      return recalled.slice(0, limit).map((snippet, turnIndex) => ({
+        turnIndex,
+        role: "memory",
+        snippet,
+        sessionId: sessionId ?? "global"
+      }));
+    },
+    async correct(sessionId, text, at, control) {
+      return { applied: await backend.correct(sessionId, text, at, control) };
+    },
+    reset: (sessionId, control) => backend.reset(sessionId, control),
+    getStats: async (sessionId) => backend.getStats(sessionId),
+    destroy: () => backend.destroy()
+  };
+  try {
+    if (!options.skipPreflight) {
+      const preflight = await adapter.preflight();
+      if (!preflight.ok) throw new McpMemoryBackendError(preflight);
+    }
+    return adapter;
+  } catch (error) {
+    await backend.destroy();
+    throw error;
+  }
+}
+function createMcpDemoMemoryAdapter(options = {}) {
+  return createMcpMemoryAdapter({
+    ...options,
+    transport: resolveDemoTransport()
+  });
+}
+async function createMcpMemCorrectAdapter(options) {
+  const backend = new McpMemoryBackend(options);
+  const adapter = {
+    label: backend.label,
+    namespacePrefix: backend.namespacePrefix,
+    preflight: () => backend.preflight(),
+    reset: () => backend.reset(),
+    ingestTurn: (sessionKey, role, text, at) => backend.store(sessionKey, [{ role, content: text, timestamp: at }]),
+    recall: (query, sessionKey) => backend.recall(sessionKey, query),
+    correct: async (text, sessionKey, at) => {
+      const applied = await backend.correct(sessionKey, text, at);
+      if (!applied) {
+        throw new McpMemoryBackendError({
+          ok: false,
+          error: "tool_failure",
+          detail: "correct tool refused the correction (applied=false)"
+        });
+      }
+    },
+    runMaintenance: async () => {
+    },
+    destroy: () => backend.destroy()
+  };
+  try {
+    if (!options.skipPreflight) {
+      const preflight = await adapter.preflight();
+      if (!preflight.ok) throw new McpMemoryBackendError(preflight);
+    }
+    return adapter;
+  } catch (error) {
+    await backend.destroy();
+    throw error;
+  }
+}
+function createMcpDemoMemCorrectAdapter(options = {}) {
+  return createMcpMemCorrectAdapter({
+    ...options,
+    transport: resolveDemoTransport()
+  });
+}
+function resolveDemoTransport() {
+  const packaged = fileURLToPath(new URL("./demo/mcp-memory-server.js", import.meta.url));
+  const development = fileURLToPath(new URL("../../dist/demo/mcp-memory-server.js", import.meta.url));
+  if (existsSync(packaged) || existsSync(development)) {
+    return {
+      type: "stdio",
+      command: process.execPath,
+      args: [existsSync(packaged) ? packaged : development]
+    };
+  }
+  const source = fileURLToPath(new URL("../demo/mcp-memory-server.ts", import.meta.url));
+  if (!existsSync(source)) {
+    throw new Error("Packaged MCP demo server is missing from @remnic/bench");
+  }
+  return {
+    type: "stdio",
+    command: process.execPath,
+    args: ["--import", "tsx", source]
+  };
+}
+function validateMcpToolMapping(value) {
+  if (value === void 0) return;
+  if (!isPlainRecord(value)) {
+    throw new Error("MCP tool mapping must be a plain object");
+  }
+  for (const operation of Object.keys(value).sort()) {
+    if (!TOOL_OPERATIONS.includes(operation)) {
+      throw new Error(`MCP tool mapping contains unknown operation: ${operation}`);
+    }
+    const entry = value[operation];
+    if (typeof entry === "string") {
+      if (entry.trim().length === 0) {
+        throw new Error(`MCP ${operation} tool name must be a non-empty string`);
+      }
+      continue;
+    }
+    if (!isPlainRecord(entry)) {
+      throw new Error(`MCP ${operation} tool mapping must be a string or object`);
+    }
+    for (const key of Object.keys(entry).sort()) {
+      if (key !== "name" && key !== "arguments" && key !== "resultPath") {
+        throw new Error(`MCP ${operation} tool mapping contains unknown field: ${key}`);
+      }
+    }
+    if (typeof entry.name !== "string" || entry.name.trim().length === 0) {
+      throw new Error(`MCP ${operation} tool mapping requires a non-empty name`);
+    }
+    if (entry.resultPath !== void 0) {
+      if (typeof entry.resultPath !== "string" || !isSafeResultPath(entry.resultPath)) {
+        throw new Error(`MCP ${operation} resultPath must be a non-empty safe dot path`);
+      }
+    }
+    if (entry.arguments !== void 0) {
+      if (!isPlainRecord(entry.arguments)) {
+        throw new Error(`MCP ${operation} arguments mapping must be a plain object`);
+      }
+      for (const semantic of Object.keys(entry.arguments).sort()) {
+        if (!ARGUMENT_SEMANTICS.includes(semantic)) {
+          throw new Error(`MCP ${operation} arguments contain unknown semantic: ${semantic}`);
+        }
+        const argumentName = entry.arguments[semantic];
+        if (typeof argumentName !== "string" || argumentName.trim().length === 0) {
+          throw new Error(`MCP ${operation} argument ${semantic} must map to a non-empty string`);
+        }
+      }
+    }
+  }
+}
+function resolveTools(listed, mapping = {}) {
+  validateMcpToolMapping(mapping);
+  const byName = new Map(listed.map((tool) => [tool.name, tool]));
+  const resolved = {};
+  for (const operation of Object.keys(DEFAULT_TOOL_NAMES)) {
+    const explicit = mapping[operation];
+    const entry = typeof explicit === "string" ? { name: explicit } : explicit;
+    const name = entry?.name ?? DEFAULT_TOOL_NAMES[operation].find((candidate) => byName.has(candidate));
+    if (!name || !byName.has(name)) {
+      const expected = entry?.name ?? DEFAULT_TOOL_NAMES[operation].join(", ");
+      throw new Error(
+        `missing ${operation} tool (expected ${expected}); server exposed ${[...byName.keys()].sort().join(", ") || "no tools"}`
+      );
+    }
+    const tool = byName.get(name);
+    resolved[operation] = {
+      name,
+      arguments: entry?.arguments ?? {},
+      resultPath: entry?.resultPath,
+      schemaProperties: Object.keys(tool.inputSchema?.properties ?? {})
+    };
+    if (!resolveArgumentName(resolved[operation], "namespace") && !resolveArgumentName(resolved[operation], "sessionId")) {
+      throw new Error(
+        `unsafe ${operation} tool ${name}: operation requires a schema-declared namespace or sessionId argument mapping`
+      );
+    }
+  }
+  return resolved;
+}
+function buildArguments(tool, values) {
+  const args = {};
+  for (const [semantic, value] of Object.entries(values)) {
+    if (value === void 0) continue;
+    const key = resolveArgumentName(tool, semantic);
+    if (key) args[key] = value;
+  }
+  return args;
+}
+function resolveArgumentName(tool, semantic) {
+  const explicit = tool.arguments[semantic];
+  if (explicit !== void 0) {
+    return tool.schemaProperties.includes(explicit) ? explicit : void 0;
+  }
+  return ARGUMENT_ALIASES[semantic].find((alias) => tool.schemaProperties.includes(alias));
+}
+function readToolPayload(result, resultPath) {
+  let value = result.structuredContent;
+  if (value === void 0) {
+    if (result.content === void 0) return void 0;
+    const texts = result.content.filter((item) => item.type === "text" && typeof item.text === "string").map((item) => item.text);
+    if (texts.length === 1) {
+      try {
+        value = JSON.parse(texts[0]);
+      } catch {
+        value = texts[0];
+      }
+    } else {
+      value = texts;
+    }
+  }
+  if (!resultPath) return value;
+  for (const segment of resultPath.split(".")) {
+    if (segment === "__proto__" || segment === "prototype" || segment === "constructor") {
+      return void 0;
+    }
+    if (!value || typeof value !== "object" || !(segment in value)) return void 0;
+    value = value[segment];
+  }
+  return value;
+}
+function extractStrings(value) {
+  if (typeof value === "string") return value.trim() ? [value] : [];
+  if (Array.isArray(value)) return value.flatMap(extractStrings);
+  if (!value || typeof value !== "object") return [];
+  const record = value;
+  for (const preferred of ["memories", "results", "items", "data", "content", "text", "memory"]) {
+    if (preferred in record) {
+      const found = extractStrings(record[preferred]);
+      if (found.length > 0) return found;
+    }
+  }
+  return Object.keys(record).sort().flatMap((key) => extractStrings(record[key]));
+}
+function validateRecallResponse(value) {
+  if (value === void 0 || value === null) {
+    throw invalidResponse("recall", "response did not contain a result payload");
+  }
+  if (typeof value === "string") return value.trim().length > 0 ? [value] : [];
+  if (Array.isArray(value)) {
+    if (value.length === 0) return [];
+    const strings = value.flatMap(extractRecallItem);
+    if (strings.length === 0) {
+      throw invalidResponse("recall", "result array contained no recognizable memory text");
+    }
+    return strings;
+  }
+  if (!isPlainRecord(value)) {
+    throw invalidResponse("recall", "result payload must be a string, array, or object");
+  }
+  for (const key of [
+    "memories",
+    "results",
+    "items",
+    "hits",
+    "data",
+    "payload",
+    "result",
+    "content",
+    "text",
+    "memory"
+  ]) {
+    if (!(key in value)) continue;
+    const nested = value[key];
+    if (Array.isArray(nested) && nested.length === 0) return [];
+    if (typeof nested === "string" && nested.trim().length === 0) return [];
+    const strings = extractRecallItem(nested);
+    if (strings.length > 0) return strings;
+    throw invalidResponse("recall", `response field ${key} contained no recognizable memory text`);
+  }
+  throw invalidResponse("recall", "response object contained no recognized result field");
+}
+function extractRecallItem(value) {
+  if (typeof value === "string") return value.trim().length > 0 ? [value] : [];
+  if (Array.isArray(value)) return value.flatMap(extractRecallItem);
+  if (!isPlainRecord(value)) return [];
+  for (const key of [
+    "text",
+    "content",
+    "memory",
+    "snippet",
+    "value",
+    "memories",
+    "results",
+    "items",
+    "hits",
+    "data",
+    "payload",
+    "result"
+  ]) {
+    if (key in value) return extractRecallItem(value[key]);
+  }
+  return [];
+}
+function validateMutationAcknowledgement(operation, value) {
+  if (typeof value === "boolean") return value;
+  if (typeof value === "string") {
+    const normalized = value.trim().toLowerCase();
+    if (["ok", "true", "stored", "applied", "corrected", "deleted", "cleared"].includes(normalized)) {
+      return true;
+    }
+    if (["false", "rejected", "not applied"].includes(normalized)) return false;
+    throw invalidResponse(operation, "text response was not a recognized acknowledgement");
+  }
+  if (!isPlainRecord(value)) {
+    throw invalidResponse(operation, "response did not contain a mutation acknowledgement");
+  }
+  const keys = operation === "store" ? ["stored", "created", "success", "ok"] : operation === "correct" ? ["applied", "corrected", "success", "ok"] : ["deleted", "cleared", "success", "ok"];
+  for (const key of keys) {
+    if (!(key in value)) continue;
+    if (typeof value[key] !== "boolean") {
+      throw invalidResponse(operation, `acknowledgement field ${key} must be boolean`);
+    }
+    return value[key];
+  }
+  for (const wrapper of ["data", "payload", "result"]) {
+    if (wrapper in value) return validateMutationAcknowledgement(operation, value[wrapper]);
+  }
+  throw invalidResponse(operation, "response object contained no recognized acknowledgement field");
+}
+function invalidResponse(operation, detail) {
+  return new McpMemoryBackendError({
+    ok: false,
+    error: "invalid_response",
+    detail: `${operation} tool returned an invalid response: ${detail}`
+  });
+}
+function isPlainRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function isSafeResultPath(value) {
+  const segments = value.split(".");
+  return segments.length > 0 && segments.every(
+    (segment) => segment.length > 0 && segment !== "__proto__" && segment !== "prototype" && segment !== "constructor" && /^[A-Za-z0-9_-]+$/.test(segment)
+  );
+}
+async function withTimeoutControl(timeoutMs, externalControl, label, operation) {
+  const timeoutController = new AbortController();
+  const timer = setTimeout(
+    () => timeoutController.abort(new Error(`${label} timed out after ${timeoutMs}ms`)),
+    timeoutMs
+  );
+  const signal = externalControl?.signal ? AbortSignal.any([externalControl.signal, timeoutController.signal]) : timeoutController.signal;
+  try {
+    return await raceWithSignal(operation({ signal }), signal, label);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function closeToolClient(client, timeoutMs) {
+  await raceWithSignal(client.close(), AbortSignal.timeout(Math.min(timeoutMs, 2e3)), "MCP client close").catch(
+    () => {
+    }
+  );
+}
+async function raceWithSignal(promise, signal, label, onLateSuccess) {
+  if (!signal) return promise;
+  let aborted = signal.aborted;
+  let abortListener;
+  const abortPromise = new Promise((_resolve, reject) => {
+    const rejectForAbort = () => {
+      aborted = true;
+      reject(signal.reason instanceof Error ? signal.reason : new Error(`${label} aborted`));
+    };
+    if (signal.aborted) rejectForAbort();
+    else {
+      abortListener = rejectForAbort;
+      signal.addEventListener("abort", rejectForAbort, { once: true });
+    }
+  });
+  if (onLateSuccess) {
+    void promise.then(async (value) => {
+      if (aborted) await onLateSuccess(value);
+    }).catch(() => {
+    });
+  }
+  try {
+    return await Promise.race([promise, abortPromise]);
+  } finally {
+    if (abortListener) signal.removeEventListener("abort", abortListener);
+  }
+}
+
 // src/adapters/timeout-guard.ts
 var BENCHMARK_TIMEOUT_ABORT_GRACE_MS = 1500;
 function resolveBenchmarkPhaseTimeoutMs(config) {
@@ -3585,6 +4475,32 @@ function wrapJudge(judge, run) {
       }
     });
   }
+  if (judge.judgeMemCorrectCorrectionAcceptance) {
+    wrapped.judgeMemCorrectCorrectionAcceptance = (request, control) => run("judge.memcorrect.correctionAcceptance", async (signal) => {
+      const merged = mergeBenchPhaseControl(signal, control);
+      try {
+        return await judge.judgeMemCorrectCorrectionAcceptance(
+          request,
+          merged.control
+        );
+      } finally {
+        merged.cleanup();
+      }
+    });
+  }
+  if (judge.judgeMemCorrectStaleMemoryHarm) {
+    wrapped.judgeMemCorrectStaleMemoryHarm = (request, control) => run("judge.memcorrect.staleMemoryHarm", async (signal) => {
+      const merged = mergeBenchPhaseControl(signal, control);
+      try {
+        return await judge.judgeMemCorrectStaleMemoryHarm(
+          request,
+          merged.control
+        );
+      } finally {
+        merged.cleanup();
+      }
+    });
+  }
   return wrapped;
 }
 function readPositiveIntegerConfig(remnicConfig, key) {
@@ -4483,6 +5399,7 @@ var BENCHMARK_RESULT_SCHEMA = {
               properties: {
                 provider: { type: "string" },
                 model: { type: "string" },
+                rubricVersion: { type: "string" },
                 baseUrl: { type: "string" },
                 reasoningEffort: { type: "string" }
               }
@@ -4649,8 +5566,411 @@ function mergeContaminationManifests(...manifests) {
   return merged;
 }
 
+// src/report-card.ts
+var PRIMARY_METRIC_ORDER = [
+  "overall_score",
+  "llm_judge",
+  "accuracy",
+  "answer_accuracy",
+  "exact_match",
+  "f1",
+  "uptake_at_next"
+];
+var CORRECTION_METRICS = [
+  {
+    name: "uptake_at_next",
+    label: "Correction visible next",
+    description: "Share of corrections visible at the first post-correction probe.",
+    direction: "Higher is better"
+  },
+  {
+    name: "non_resurrection",
+    label: "Stale fact stayed retired",
+    description: "Share of corrected facts that did not return during maintenance and re-ingest.",
+    direction: "Higher is better"
+  },
+  {
+    name: "false_apply",
+    label: "False corrections",
+    description: "Share of anti-events that incorrectly changed memory.",
+    direction: "Lower is better"
+  }
+];
+function escapeHtml(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll(`"`, "&quot;").replaceAll("'", "&#39;");
+}
+function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function finiteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function formatNumber(value) {
+  if (Number.isInteger(value)) return String(value);
+  return value.toFixed(4).replace(/0+$/, "").replace(/\.$/, "");
+}
+function formatPercent(value) {
+  return value === void 0 ? "Not measured" : `${formatNumber(value * 100)}%`;
+}
+function formatDimensionMetric(name, value) {
+  const percentageMetric = name.includes("rate") || name.includes("precision") || name.includes("recall") || name.includes("success") || name.includes("alignment") || name.includes("lift");
+  return percentageMetric ? formatPercent(value) : formatNumber(value);
+}
+function aggregateMeans(result) {
+  const means = {};
+  for (const name of Object.keys(result.results.aggregates).sort()) {
+    const mean4 = finiteNumber(result.results.aggregates[name]?.mean);
+    if (mean4 !== void 0) means[name] = mean4;
+  }
+  return means;
+}
+function correctionMetricValues(result) {
+  const benchmarkOptions = result.config.benchmarkOptions;
+  const persistedBundle = isRecord(benchmarkOptions) ? benchmarkOptions.aggregateMetrics : void 0;
+  const values = {};
+  if (isRecord(persistedBundle)) {
+    for (const name of Object.keys(persistedBundle).sort()) {
+      const value = finiteNumber(persistedBundle[name]);
+      if (value !== void 0) values[name] = value;
+    }
+  }
+  const means = aggregateMeans(result);
+  for (const metric of CORRECTION_METRICS) {
+    if (values[metric.name] === void 0 && means[metric.name] !== void 0) {
+      values[metric.name] = means[metric.name];
+    }
+  }
+  return values;
+}
+function resultStatus(result) {
+  const failure = result.meta.failureReason ?? "";
+  const typedBackendFailure = /(?:backend[ _-]?unusable|transport[ _-]?failure|tool[ _-]?failure|invalid[ _-]?response)/i;
+  if (result.meta.status === "partial" && result.results.tasks.length === 0 && typedBackendFailure.test(failure)) {
+    return "backend-unusable";
+  }
+  if (result.meta.status === "partial") return "partial";
+  if (result.results.tasks.length === 0) return "unscored";
+  return "complete";
+}
+function statusCopy(status) {
+  switch (status) {
+    case "backend-unusable":
+      return {
+        label: "Backend unusable",
+        detail: "The memory backend failed before a trustworthy score could be produced."
+      };
+    case "partial":
+      return {
+        label: "Partial run",
+        detail: "The run stopped early. Scores describe completed tasks only and are not a full result."
+      };
+    case "unscored":
+      return {
+        label: "No scored tasks",
+        detail: "The run completed without task-level evidence, so no overall score is claimed."
+      };
+    case "complete":
+      return {
+        label: "Complete run",
+        detail: "All persisted task results are included in this report card."
+      };
+  }
+}
+function primaryMetric(result) {
+  const means = aggregateMeans(result);
+  const correction = correctionMetricValues(result);
+  if (result.meta.benchmark === "memcorrect-v1" && correction.uptake_at_next !== void 0) {
+    return { name: "uptake_at_next", value: correction.uptake_at_next };
+  }
+  for (const name of PRIMARY_METRIC_ORDER) {
+    if (means[name] !== void 0) return { name, value: means[name] };
+  }
+  return void 0;
+}
+function renderScore(result, status) {
+  const metric = primaryMetric(result);
+  if (status === "backend-unusable" || status === "unscored" || !metric) {
+    return `<div class="score score--na"><span class="score__value">N/A</span><span class="score__label">No defensible score</span></div>`;
+  }
+  const value = metric.value >= 0 && metric.value <= 1 ? formatPercent(metric.value) : formatNumber(metric.value);
+  return `<div class="score"><span class="score__value">${escapeHtml(value)}</span><span class="score__label">Overall score \xB7 ${escapeHtml(metric.name)}</span><span class="score__note">Recorded mean of the named primary metric; no cross-metric composite.</span></div>`;
+}
+function renderCorrectionSpotlight(result) {
+  const values = correctionMetricValues(result);
+  const tasks = [...result.results.tasks].sort(
+    (left, right) => left.taskId.localeCompare(right.taskId)
+  );
+  const accepted = tasks.filter((task) => task.scores.uptake_at_next === 1).length;
+  const notObserved = tasks.filter((task) => task.scores.uptake_at_next === 0).length;
+  const staleReturned = tasks.filter((task) => task.scores.non_resurrection === 0).length;
+  const measuredCorrectionTasks = accepted + notObserved;
+  const measuredRetirementTasks = tasks.filter(
+    (task) => task.scores.non_resurrection === 0 || task.scores.non_resurrection === 1
+  ).length;
+  const cards = CORRECTION_METRICS.map((metric) => {
+    const value = values[metric.name];
+    const state = value === void 0 ? "not-measured" : "measured";
+    return `        <article class="ledger-card ledger-card--${state}">
+          <p class="eyebrow">${escapeHtml(metric.direction)}</p>
+          <p class="ledger-card__value">${formatPercent(value)}</p>
+          <h3>${escapeHtml(metric.label)}</h3>
+          <p>${escapeHtml(metric.description)}</p>
+        </article>`;
+  }).join("\n");
+  const countSummary = measuredCorrectionTasks > 0 || measuredRetirementTasks > 0 ? `        <p class="ledger-summary"><strong>${accepted}</strong> visible at the next probe \xB7 <strong>${notObserved}</strong> not observed at the next probe \xB7 <strong>${staleReturned}</strong> stale-fact return${staleReturned === 1 ? "" : "s"}</p>` : `        <p class="ledger-summary ledger-summary--empty">This run did not record MemCorrect scenario outcomes.</p>`;
+  return `      <section class="spotlight" aria-labelledby="correction-heading">
+        <div class="section-heading">
+          <div>
+            <p class="eyebrow">Correction ledger</p>
+            <h2 id="correction-heading">Did the system take the correction\u2014and keep it?</h2>
+          </div>
+          <p>Values come from persisted MemCorrect metrics when present. Missing evidence stays missing.</p>
+        </div>
+        <div class="ledger">
+${cards}
+        </div>
+${countSummary}
+      </section>`;
+}
+function taskContext(task) {
+  const details = task.details;
+  if (!isRecord(details)) return { shape: "\u2014", category: "\u2014" };
+  return {
+    shape: typeof details.shape === "string" ? details.shape : "\u2014",
+    category: typeof details.category === "string" ? details.category : "\u2014"
+  };
+}
+function taskScore(task, name) {
+  const value = finiteNumber(task.scores[name]);
+  return value === void 0 ? "\u2014" : formatPercent(value);
+}
+function renderScenarioDrilldown(result) {
+  const tasks = [...result.results.tasks].sort(
+    (left, right) => left.taskId.localeCompare(right.taskId)
+  );
+  if (tasks.length === 0) {
+    return `      <section aria-labelledby="scenario-heading">
+        <div class="section-heading"><div><p class="eyebrow">Evidence</p><h2 id="scenario-heading">Scenario drill-down</h2></div></div>
+        <p class="empty-state">No task-level scenarios were persisted for this run.</p>
+      </section>`;
+  }
+  const rows = tasks.map((task) => {
+    const context = taskContext(task);
+    return `            <tr>
+              <th scope="row">${escapeHtml(task.taskId)}</th>
+              <td>${escapeHtml(context.shape)}</td>
+              <td>${escapeHtml(context.category)}</td>
+              <td>${taskScore(task, "uptake_at_next")}</td>
+              <td>${taskScore(task, "non_resurrection")}</td>
+              <td>${taskScore(task, "false_apply")}</td>
+            </tr>`;
+  }).join("\n");
+  return `      <section aria-labelledby="scenario-heading">
+        <div class="section-heading">
+          <div><p class="eyebrow">Evidence</p><h2 id="scenario-heading">Scenario drill-down</h2></div>
+          <p>\u201C\u2014\u201D means the scenario did not record that metric; it is not a zero.</p>
+        </div>
+        <div class="table-wrap">
+          <table>
+            <thead><tr><th>Scenario</th><th>Shape</th><th>Category</th><th>Correction next</th><th>Stayed retired</th><th>False apply</th></tr></thead>
+            <tbody>
+${rows}
+            </tbody>
+          </table>
+        </div>
+      </section>`;
+}
+function renderDimensions(result) {
+  const means = aggregateMeans(result);
+  const cards = MEMORY_EVAL_DIMENSIONS.map((dimension) => {
+    const measured = dimension.metrics.filter((metric) => means[metric.name] !== void 0);
+    const body = measured.length === 0 ? `<p class="dimension__empty">Not measured in this run. No pass or fail is inferred.</p>` : `<dl>${measured.map((metric) => `
+              <div><dt>${escapeHtml(metric.name)}</dt><dd>${escapeHtml(formatDimensionMetric(metric.name, means[metric.name]))}</dd></div>
+              <p>${escapeHtml(metric.higherIsBetter ? "Higher is better" : "Lower is better")} \xB7 No pass threshold is recorded in the result.</p>`).join("")}
+            </dl>`;
+    return `        <article class="dimension">
+          <p class="eyebrow">${escapeHtml(dimension.category)}</p>
+          <h3>${escapeHtml(dimension.question)}</h3>
+          ${body}
+        </article>`;
+  }).join("\n");
+  return `      <section aria-labelledby="dimensions-heading">
+        <div class="section-heading">
+          <div><p class="eyebrow">Memory eval dimensions</p><h2 id="dimensions-heading">What this run can\u2014and cannot\u2014claim</h2></div>
+          <p>Dimensions map only to matching <code>MEMORY_EVAL_DIMENSIONS</code> metrics.</p>
+        </div>
+        <div class="dimension-grid">
+${cards}
+        </div>
+      </section>`;
+}
+function renderAggregateMetrics(result) {
+  const names = Object.keys(result.results.aggregates).sort();
+  if (names.length === 0) {
+    return `      <section aria-labelledby="aggregate-heading">
+        <div class="section-heading"><div><p class="eyebrow">Raw record</p><h2 id="aggregate-heading">Aggregate Metrics</h2></div></div>
+        <p class="empty-state">No aggregate metrics were recorded. The report does not replace them with zeros.</p>
+      </section>`;
+  }
+  const rows = names.map((name) => {
+    const aggregate = result.results.aggregates[name];
+    return `            <tr><th scope="row">${escapeHtml(name)}</th><td>${formatNumber(aggregate.mean)}</td><td>${formatNumber(aggregate.median)}</td><td>${formatNumber(aggregate.stdDev)}</td><td>${formatNumber(aggregate.min)}</td><td>${formatNumber(aggregate.max)}</td></tr>`;
+  }).join("\n");
+  return `      <section aria-labelledby="aggregate-heading">
+        <div class="section-heading"><div><p class="eyebrow">Raw record</p><h2 id="aggregate-heading">Aggregate Metrics</h2></div><p>Untransformed values from the stored result.</p></div>
+        <div class="table-wrap"><table><thead><tr><th>Metric</th><th>Mean</th><th>Median</th><th>Std dev</th><th>Min</th><th>Max</th></tr></thead><tbody>
+${rows}
+        </tbody></table></div>
+      </section>`;
+}
+function optionString(result, names) {
+  const options = result.config.benchmarkOptions;
+  if (!isRecord(options)) return void 0;
+  for (const name of names) {
+    const value = options[name];
+    if (typeof value === "string" && value.trim().length > 0) return value;
+  }
+  return void 0;
+}
+function providerLabel(provider) {
+  return provider ? `${provider.provider} / ${provider.model}` : "Not recorded";
+}
+function renderProvenance(result, provenance) {
+  const rubricVersion = result.config.judgeProvider?.rubricVersion ?? optionString(result, ["rubricVersion", "judgeRubricVersion", "rubric_version"]);
+  const remnicConfigKeyCount = Object.keys(result.config.remnicConfig ?? {}).length;
+  const machine = [result.environment.os, result.environment.nodeVersion, result.environment.hardware].filter((value) => typeof value === "string" && value.length > 0).join(" \xB7 ");
+  const entries = [
+    ["Result ID", result.meta.id],
+    ["Task Count", String(result.results.tasks.length)],
+    ["Git SHA", result.meta.gitSha],
+    ["Remnic / benchmark", `${result.meta.remnicVersion} / ${result.meta.version}`],
+    ["Judge", providerLabel(result.config.judgeProvider)],
+    ["Rubric version", rubricVersion ?? "Not recorded in stored result"],
+    ["Dataset hash", result.meta.datasetHash ?? "Not recorded"],
+    ["Sealed qrels hash", result.meta.qrelsSealedHash ?? "Not recorded"],
+    ["Judge prompt hash", result.meta.judgePromptHash ?? "Not recorded"],
+    ["Seeds", result.meta.seeds?.join(", ") || "Not recorded"],
+    ["Manifest reference", provenance.manifestReference ?? "Not available"],
+    ["Manifest artifact hash", provenance.artifactHash ?? "Not available"],
+    ["Machine fingerprint", machine || "Not recorded"],
+    [
+      "Remnic config",
+      remnicConfigKeyCount === 0 ? "No keys recorded" : `[redacted ${remnicConfigKeyCount} key${remnicConfigKeyCount === 1 ? "" : "s"}]`
+    ]
+  ];
+  return `      <footer aria-labelledby="provenance-heading">
+        <div class="section-heading"><div><p class="eyebrow">Receipts</p><h2 id="provenance-heading">Provenance</h2></div><p>Result fields are persisted with the run. Manifest receipts appear only when the caller supplies a verified adjacent manifest.</p></div>
+        <dl class="receipts">
+${entries.map(([label, value]) => `          <div><dt>${escapeHtml(label)}</dt><dd>${escapeHtml(value)}</dd></div>`).join("\n")}
+        </dl>
+      </footer>`;
+}
+function renderMemoryReportCard(result, provenance = {}) {
+  const status = resultStatus(result);
+  const statusText = statusCopy(status);
+  const system = result.config.systemProvider ? `${result.config.systemProvider.provider} / ${result.config.systemProvider.model}` : result.config.adapterMode;
+  const failure = result.meta.failureReason ? `<p class="failure"><strong>Run stopped:</strong> ${escapeHtml(result.meta.failureReason)}</p>` : "";
+  return `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <title>Remnic Bench Report: ${escapeHtml(result.meta.benchmark)}</title>
+    <style>
+      :root { color-scheme: light; --ink:#142523; --muted:#5d6e69; --mist:#e9f0ed; --paper:#f8fbf9; --line:#cbd8d3; --teal:#0b7168; --teal-soft:#d8ebe6; --ember:#c9563f; --ember-soft:#f8e1db; --shadow:0 18px 48px rgba(20,37,35,.09); font-family:Inter,ui-sans-serif,system-ui,-apple-system,BlinkMacSystemFont,"Segoe UI",sans-serif; }
+      * { box-sizing:border-box; }
+      body { margin:0; background:var(--mist); color:var(--ink); }
+      main { width:min(1180px,calc(100% - 32px)); margin:0 auto; padding:32px 0 64px; }
+      h1,h2,h3,p,dl,dd { margin:0; }
+      h1,h2 { font-family:Georgia,"Times New Roman",serif; font-weight:500; letter-spacing:-.025em; }
+      h1 { max-width:780px; font-size:clamp(2.5rem,7vw,5.8rem); line-height:.94; }
+      h2 { font-size:clamp(1.7rem,3vw,2.5rem); line-height:1.05; }
+      h3 { font-size:1rem; line-height:1.25; }
+      p { line-height:1.55; }
+      code,.eyebrow,.score__value,.receipts dd,table { font-family:"SFMono-Regular",Consolas,"Liberation Mono",monospace; }
+      .eyebrow { margin-bottom:10px; color:var(--teal); font-size:.72rem; font-weight:700; letter-spacing:.12em; text-transform:uppercase; }
+      .hero { position:relative; overflow:hidden; padding:clamp(28px,5vw,60px); background:var(--ink); color:var(--paper); border-radius:24px; box-shadow:var(--shadow); }
+      .hero::after { content:""; position:absolute; width:320px; height:320px; right:-120px; top:-160px; border:56px solid var(--teal); border-radius:50%; opacity:.62; }
+      .hero__meta { position:relative; z-index:1; display:flex; flex-wrap:wrap; gap:10px; margin-bottom:40px; }
+      .pill { padding:7px 11px; border:1px solid rgba(248,251,249,.28); border-radius:999px; font-size:.78rem; }
+      .hero__grid { position:relative; z-index:1; display:grid; grid-template-columns:minmax(0,1fr) minmax(220px,330px); gap:36px; align-items:end; }
+      .hero__lede { max-width:650px; margin-top:22px; color:#bdd0ca; font-size:1.05rem; }
+      .status { display:inline-flex; align-items:center; gap:8px; margin-top:24px; font-weight:700; }
+      .status::before { content:""; width:9px; height:9px; background:var(--teal); border-radius:50%; box-shadow:0 0 0 5px rgba(11,113,104,.25); }
+      .status--partial::before,.status--backend-unusable::before { background:var(--ember); box-shadow:0 0 0 5px rgba(201,86,63,.24); }
+      .status__detail { display:block; margin-top:8px; color:#bdd0ca; font-size:.88rem; }
+      .score { padding:24px; background:rgba(248,251,249,.08); border:1px solid rgba(248,251,249,.18); border-radius:18px; }
+      .score__value { display:block; color:#75d2c4; font-size:clamp(2.8rem,6vw,4.8rem); line-height:1; }
+      .score--na .score__value { color:#f2a18f; }
+      .score__label { display:block; margin-top:10px; font-weight:750; }
+      .score__note { display:block; margin-top:8px; color:#bdd0ca; font-size:.78rem; line-height:1.45; }
+      .failure { position:relative; z-index:1; margin-top:24px; padding:14px 16px; background:rgba(201,86,63,.18); border-left:3px solid #f08d76; border-radius:8px; color:#ffe9e4; }
+      section,footer { margin-top:22px; padding:clamp(22px,4vw,38px); background:var(--paper); border:1px solid var(--line); border-radius:20px; }
+      .spotlight { margin-top:-1px; border-top-left-radius:0; border-top-right-radius:0; border-top:6px solid var(--teal); }
+      .section-heading { display:flex; justify-content:space-between; gap:28px; align-items:end; margin-bottom:24px; }
+      .section-heading>p { max-width:430px; color:var(--muted); font-size:.9rem; }
+      .ledger { display:grid; grid-template-columns:repeat(3,1fr); gap:1px; overflow:hidden; border:1px solid var(--line); border-radius:16px; background:var(--line); }
+      .ledger-card { min-height:220px; padding:24px; background:white; }
+      .ledger-card--not-measured { background:#f0f3f1; color:var(--muted); }
+      .ledger-card__value { margin:22px 0 8px; color:var(--teal); font-family:Georgia,"Times New Roman",serif; font-size:2.4rem; }
+      .ledger-card--not-measured .ledger-card__value { color:var(--muted); font-size:1.4rem; }
+      .ledger-card h3 { margin-bottom:8px; }
+      .ledger-card p:last-child { color:var(--muted); font-size:.87rem; }
+      .ledger-summary { margin-top:18px; padding:14px 16px; background:var(--teal-soft); border-radius:10px; }
+      .ledger-summary--empty { background:#eef1ef; color:var(--muted); }
+      .dimension-grid { display:grid; grid-template-columns:repeat(2,minmax(0,1fr)); gap:12px; }
+      .dimension { padding:20px; border:1px solid var(--line); border-radius:14px; background:white; }
+      .dimension h3 { min-height:2.5em; margin-bottom:18px; }
+      .dimension dl>div { display:flex; justify-content:space-between; gap:16px; padding-top:10px; border-top:1px solid var(--line); }
+      .dimension dl p,.dimension__empty { margin-top:8px; color:var(--muted); font-size:.78rem; }
+      .dimension dt { overflow-wrap:anywhere; }
+      .dimension dd { color:var(--teal); font-weight:700; }
+      .table-wrap { overflow-x:auto; border:1px solid var(--line); border-radius:12px; }
+      table { width:100%; border-collapse:collapse; font-size:.8rem; }
+      th,td { padding:12px 14px; text-align:left; border-top:1px solid var(--line); white-space:nowrap; }
+      thead th { border-top:0; background:#edf3f0; color:var(--muted); font-size:.7rem; letter-spacing:.05em; text-transform:uppercase; }
+      tbody th { color:var(--ink); }
+      .empty-state { padding:22px; background:#eef1ef; border-radius:12px; color:var(--muted); }
+      footer { background:#dfe9e5; }
+      .receipts { display:grid; grid-template-columns:repeat(2,minmax(0,1fr)); gap:1px; overflow:hidden; border:1px solid #bccbc5; border-radius:12px; background:#bccbc5; }
+      .receipts>div { min-width:0; padding:14px 16px; background:var(--paper); }
+      .receipts dt { margin-bottom:6px; color:var(--muted); font-size:.72rem; text-transform:uppercase; letter-spacing:.06em; }
+      .receipts dd { overflow-wrap:anywhere; font-size:.82rem; }
+      @media (max-width:760px) { main{width:min(100% - 20px,1180px);padding-top:10px}.hero{border-radius:16px}.hero__grid,.ledger,.dimension-grid,.receipts{grid-template-columns:1fr}.section-heading{display:block}.section-heading>p{margin-top:12px}.spotlight{border-radius:0 0 16px 16px}.ledger-card{min-height:0} }
+      @media (prefers-reduced-motion:reduce) { *,*::before,*::after { scroll-behavior:auto!important; } }
+      @media print { body{background:white}main{width:100%;padding:0}.hero,section,footer{box-shadow:none;break-inside:avoid}.hero{border-radius:0} }
+    </style>
+  </head>
+  <body>
+    <main>
+      <header class="hero">
+        <div class="hero__meta"><span class="pill">${escapeHtml(result.meta.benchmark)}</span><span class="pill">${escapeHtml(result.meta.mode)} mode</span><span class="pill">${result.results.tasks.length} task${result.results.tasks.length === 1 ? "" : "s"}</span><span class="pill">${escapeHtml(result.meta.timestamp)}</span></div>
+        <div class="hero__grid">
+          <div>
+            <p class="eyebrow">Remnic memory report card</p>
+            <h1>${escapeHtml(system)}</h1>
+            <p class="hero__lede">Adapter: ${escapeHtml(result.config.adapterMode)} \xB7 Run ${escapeHtml(result.meta.id)} \xB7 Git ${escapeHtml(result.meta.gitSha)}</p>
+            <p class="status status--${status}">${escapeHtml(statusText.label)}</p>
+            <span class="status__detail">${escapeHtml(statusText.detail)}</span>
+          </div>
+          ${renderScore(result, status)}
+        </div>
+        ${failure}
+      </header>
+${renderCorrectionSpotlight(result)}
+${renderDimensions(result)}
+${renderScenarioDrilldown(result)}
+${renderAggregateMetrics(result)}
+${renderProvenance(result, provenance)}
+    </main>
+  </body>
+</html>
+`;
+}
+
 // src/results-store.ts
 var BASELINE_NAME_PATTERN = /^[A-Za-z0-9_-]+$/;
+var REPRO_MANIFEST_FILENAME = "MANIFEST.json";
 function defaultBenchmarkBaselineDir() {
   const homeDir = process.env.HOME ?? process.env.USERPROFILE ?? os.homedir();
   return path3.join(homeDir, ".remnic", "bench", "baselines");
@@ -4683,6 +6003,25 @@ function isObjectRecord(value) {
 function isFiniteNumber(value) {
   return typeof value === "number" && Number.isFinite(value);
 }
+async function loadBenchmarkReportCardProvenance(outputDir, resultId) {
+  const manifestPath = path3.join(outputDir, REPRO_MANIFEST_FILENAME);
+  let parsed;
+  try {
+    parsed = JSON.parse(await readFile3(manifestPath, "utf8"));
+  } catch {
+    return {};
+  }
+  if (!isObjectRecord(parsed) || !Array.isArray(parsed.results)) return {};
+  const coversResult = parsed.results.some(
+    (entry) => isObjectRecord(entry) && entry.resultId === resultId
+  );
+  if (!coversResult) return {};
+  const artifactHash = typeof parsed.artifactHash === "string" && parsed.artifactHash.length > 0 ? parsed.artifactHash : void 0;
+  return {
+    manifestReference: REPRO_MANIFEST_FILENAME,
+    ...artifactHash ? { artifactHash } : {}
+  };
+}
 function isProviderConfigLike(value) {
   if (value === null) {
     return true;
@@ -4964,7 +6303,7 @@ function classifyPublishCandidate(result, target, contaminationManifest) {
   }
   return null;
 }
-function toPublishedBenchmarkFeedEntry(result) {
+function toPublishedBenchmarkFeedEntry(result, provenance) {
   if (!integrityMetaIsComplete(result.meta)) {
     throw new Error(
       "toPublishedBenchmarkFeedEntry called with a result missing integrity metadata; call assertPublishableIntegrity first."
@@ -4982,6 +6321,7 @@ function toPublishedBenchmarkFeedEntry(result) {
     aggregateMetrics: result.results.aggregates,
     cost: result.cost,
     environment: result.environment,
+    reportCardHtml: renderMemoryReportCard(result, provenance),
     integrity: {
       splitType: result.meta.splitType,
       qrelsSealedHash: result.meta.qrelsSealedHash,
@@ -5009,9 +6349,13 @@ async function buildBenchmarkPublishFeed(outputDir, target, options = {}) {
       skipped.push({ ...skip, path: summary.path });
       continue;
     }
+    const provenance = await loadBenchmarkReportCardProvenance(
+      outputDir,
+      result.meta.id
+    );
     latestByBenchmark.set(
       summary.benchmark,
-      toPublishedBenchmarkFeedEntry(result)
+      toPublishedBenchmarkFeedEntry(result, provenance)
     );
   }
   return {
@@ -5034,197 +6378,13 @@ function csvEscape(value) {
   }
   return text;
 }
-function escapeHtml(value) {
-  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll(`"`, "&quot;").replaceAll("'", "&#39;");
-}
-function renderHtmlKeyValueRows(entries) {
-  return entries.map(([label, value]) => `        <tr><th>${escapeHtml(label)}</th><td>${escapeHtml(String(value))}</td></tr>`).join("\n");
-}
-function renderBenchmarkResultHtml(result) {
-  const seeds = Array.isArray(result.meta.seeds) ? result.meta.seeds.join(", ") : "Unknown";
-  const aggregateRows = Object.keys(result.results.aggregates).sort().map((metric) => {
-    const aggregate = result.results.aggregates[metric];
-    return `          <tr><th>${escapeHtml(metric)}</th><td>${escapeHtml(String(aggregate.mean))}</td><td>${escapeHtml(String(aggregate.median))}</td><td>${escapeHtml(String(aggregate.stdDev))}</td><td>${escapeHtml(String(aggregate.min))}</td><td>${escapeHtml(String(aggregate.max))}</td></tr>`;
-  }).join("\n");
-  const statisticsBlock = result.results.statistics ? `
-    <section>
-      <h2>Statistics</h2>
-      <pre>${escapeHtml(JSON.stringify(result.results.statistics, null, 2))}</pre>
-    </section>` : "";
-  const remnicConfigKeyCount = Object.keys(result.config.remnicConfig ?? {}).length;
-  const renderedConfig = {
-    systemProvider: result.config.systemProvider,
-    judgeProvider: result.config.judgeProvider,
-    internalProvider: result.config.internalProvider,
-    remnicConfig: remnicConfigKeyCount === 0 ? "[empty]" : `[redacted ${remnicConfigKeyCount} key${remnicConfigKeyCount === 1 ? "" : "s"}]`
-  };
-  return `<!doctype html>
-<html lang="en">
-  <head>
-    <meta charset="utf-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1">
-    <title>Remnic Bench Report: ${escapeHtml(result.meta.benchmark)}</title>
-    <style>
-      :root {
-        color-scheme: light;
-        font-family: ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
-      }
-      body {
-        margin: 0;
-        background: #f5f7fb;
-        color: #18202a;
-      }
-      main {
-        max-width: 1080px;
-        margin: 0 auto;
-        padding: 32px 20px 48px;
-      }
-      header {
-        margin-bottom: 24px;
-      }
-      h1, h2 {
-        margin: 0 0 12px;
-      }
-      p {
-        margin: 0;
-        line-height: 1.5;
-      }
-      section {
-        background: #ffffff;
-        border: 1px solid #d8dee8;
-        border-radius: 12px;
-        padding: 20px;
-        margin-top: 16px;
-        box-shadow: 0 8px 24px rgba(15, 23, 42, 0.05);
-      }
-      table {
-        width: 100%;
-        border-collapse: collapse;
-      }
-      th, td {
-        text-align: left;
-        padding: 10px 12px;
-        border-top: 1px solid #e5eaf1;
-        vertical-align: top;
-      }
-      thead th {
-        border-top: none;
-        font-size: 0.85rem;
-        letter-spacing: 0.02em;
-        text-transform: uppercase;
-        color: #526173;
-      }
-      tbody th {
-        width: 30%;
-      }
-      pre {
-        margin: 0;
-        overflow-x: auto;
-        white-space: pre-wrap;
-        word-break: break-word;
-        background: #f5f7fb;
-        border-radius: 10px;
-        padding: 14px;
-        border: 1px solid #e5eaf1;
-      }
-      .muted {
-        color: #526173;
-        margin-top: 6px;
-      }
-      .empty {
-        color: #526173;
-        font-style: italic;
-      }
-    </style>
-  </head>
-  <body>
-    <main>
-      <header>
-        <h1>Remnic Bench Report</h1>
-        <p>${escapeHtml(result.meta.benchmark)} \xB7 ${escapeHtml(result.meta.id)}</p>
-        <p class="muted">Generated from a stored benchmark result export.</p>
-      </header>
-      <section>
-        <h2>Run Summary</h2>
-        <table>
-          <tbody>
-${renderHtmlKeyValueRows([
-    ["Result ID", result.meta.id],
-    ["Benchmark", result.meta.benchmark],
-    ["Benchmark Tier", result.meta.benchmarkTier],
-    ["Timestamp", result.meta.timestamp],
-    ["Mode", result.meta.mode],
-    ["Run Count", result.meta.runCount],
-    ["Task Count", result.results.tasks.length],
-    ["Remnic Version", result.meta.remnicVersion],
-    ["Benchmark Version", result.meta.version],
-    ["Git SHA", result.meta.gitSha],
-    ["Seeds", seeds]
-  ])}
-          </tbody>
-        </table>
-      </section>
-      <section>
-        <h2>Aggregate Metrics</h2>
-${aggregateRows.length > 0 ? `        <table>
-          <thead>
-            <tr><th>Metric</th><th>Mean</th><th>Median</th><th>Std Dev</th><th>Min</th><th>Max</th></tr>
-          </thead>
-          <tbody>
-${aggregateRows}
-          </tbody>
-        </table>` : '        <p class="empty">No aggregate metrics recorded for this run.</p>'}
-      </section>
-      <section>
-        <h2>Cost</h2>
-        <table>
-          <tbody>
-${renderHtmlKeyValueRows([
-    ["Total Tokens", result.cost.totalTokens],
-    ["Input Tokens", result.cost.inputTokens],
-    ["Output Tokens", result.cost.outputTokens],
-    ["Estimated Cost (USD)", result.cost.estimatedCostUsd],
-    ["Total Latency (ms)", result.cost.totalLatencyMs],
-    ["Mean Query Latency (ms)", result.cost.meanQueryLatencyMs]
-  ])}
-          </tbody>
-        </table>
-      </section>
-      <section>
-        <h2>Environment</h2>
-        <table>
-          <tbody>
-${renderHtmlKeyValueRows([
-    ["OS", result.environment.os],
-    ["Node Version", result.environment.nodeVersion],
-    ["Hardware", result.environment.hardware ?? "Unknown"]
-  ])}
-          </tbody>
-        </table>
-      </section>
-      <section>
-        <h2>Configuration</h2>
-        <table>
-          <tbody>
-${renderHtmlKeyValueRows([
-    ["Adapter Mode", result.config.adapterMode]
-  ])}
-          </tbody>
-        </table>
-        <pre>${escapeHtml(JSON.stringify(renderedConfig, null, 2))}</pre>
-      </section>${statisticsBlock}
-    </main>
-  </body>
-</html>
-`;
-}
-function renderBenchmarkResultExport(result, format) {
+function renderBenchmarkResultExport(result, format, options = {}) {
   if (format === "json") {
     return `${JSON.stringify(result, null, 2)}
 `;
   }
   if (format === "html") {
-    return renderBenchmarkResultHtml(result);
+    return renderMemoryReportCard(result, options.reportCardProvenance);
   }
   const rows = [
     [
@@ -6162,7 +7322,12 @@ async function buildResultManifest(resultsDir, resultPath, result) {
     runCount: result.meta.runCount,
     seeds: [...result.meta.seeds],
     taskCount: result.results.tasks.length,
-    configHash: sha256String(stableStringify(result.config))
+    configHash: sha256String(stableStringify(result.config)),
+    judge: result.config.judgeProvider ? {
+      provider: result.config.judgeProvider.provider,
+      model: result.config.judgeProvider.model,
+      rubricVersion: result.config.judgeProvider.rubricVersion ?? null
+    } : null
   };
 }
 async function resolveResultPaths(resultsDir, explicitPaths) {
@@ -6474,7 +7639,35 @@ function readJudgeCalibrationFromBenchmarkOptions(value) {
   if (typeof kappa !== "number" || !Number.isFinite(kappa) || typeof sampleSize !== "number" || !Number.isFinite(sampleSize) || typeof threshold !== "number" || !Number.isFinite(threshold) || typeof warning !== "boolean") {
     return void 0;
   }
-  return { kappa, sampleSize, threshold, warning };
+  const confidenceInterval = readCalibrationConfidenceInterval(record.confidenceInterval);
+  const bootstrapSamples = record.bootstrapSamples;
+  const answerSetHash = record.answerSetHash;
+  const sourceResultId = record.sourceResultId;
+  const sliceQuestionIds = readCalibrationQuestionIds(record.sliceQuestionIds);
+  const hasCompleteProvenance = typeof answerSetHash === "string" && /^[0-9a-f]{64}$/.test(answerSetHash) && typeof sourceResultId === "string" && sourceResultId.length > 0 && sliceQuestionIds !== void 0 && sliceQuestionIds.length === sampleSize;
+  return {
+    kappa,
+    sampleSize,
+    threshold,
+    warning,
+    ...confidenceInterval ? { confidenceInterval } : {},
+    ...typeof bootstrapSamples === "number" && Number.isInteger(bootstrapSamples) && bootstrapSamples > 0 ? { bootstrapSamples } : {},
+    ...hasCompleteProvenance ? { answerSetHash, sourceResultId, sliceQuestionIds } : {}
+  };
+}
+function readCalibrationConfidenceInterval(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const interval = value;
+  if (typeof interval.lower !== "number" || !Number.isFinite(interval.lower) || typeof interval.upper !== "number" || !Number.isFinite(interval.upper) || typeof interval.level !== "number" || !Number.isFinite(interval.level) || interval.lower > interval.upper || interval.level <= 0 || interval.level >= 1) {
+    return void 0;
+  }
+  return { lower: interval.lower, upper: interval.upper, level: interval.level };
+}
+function readCalibrationQuestionIds(value) {
+  if (!Array.isArray(value) || value.length === 0 || value.length > 200 || !value.every((id) => typeof id === "string" && id.length > 0) || new Set(value).size !== value.length) {
+    return void 0;
+  }
+  return value;
 }
 function buildBenchmarkArtifactFilename(artifact) {
   const date = sanitizeSegment(artifact.startedAt.slice(0, 10));
@@ -6561,6 +7754,25 @@ function parseBenchmarkArtifact(raw) {
     if (typeof warning !== "boolean") {
       throw new Error(`BenchmarkArtifact judgeCalibration.warning must be a boolean; got ${String(warning)}.`);
     }
+    if (calibration.confidenceInterval !== void 0 && !readCalibrationConfidenceInterval(calibration.confidenceInterval)) {
+      throw new Error("BenchmarkArtifact judgeCalibration.confidenceInterval must contain finite ordered lower/upper bounds and a level between 0 and 1.");
+    }
+    if (calibration.bootstrapSamples !== void 0 && (typeof calibration.bootstrapSamples !== "number" || !Number.isInteger(calibration.bootstrapSamples) || calibration.bootstrapSamples <= 0)) {
+      throw new Error("BenchmarkArtifact judgeCalibration.bootstrapSamples must be a positive integer when provided.");
+    }
+    if (calibration.answerSetHash !== void 0 && (typeof calibration.answerSetHash !== "string" || !/^[0-9a-f]{64}$/.test(calibration.answerSetHash))) {
+      throw new Error("BenchmarkArtifact judgeCalibration.answerSetHash must be a lowercase SHA-256 hex digest when provided.");
+    }
+    if (calibration.sourceResultId !== void 0 && (typeof calibration.sourceResultId !== "string" || calibration.sourceResultId.length === 0)) {
+      throw new Error("BenchmarkArtifact judgeCalibration.sourceResultId must be a non-empty string when provided.");
+    }
+    if (calibration.sliceQuestionIds !== void 0 && !readCalibrationQuestionIds(calibration.sliceQuestionIds)) {
+      throw new Error("BenchmarkArtifact judgeCalibration.sliceQuestionIds must contain 1 to 200 unique non-empty strings when provided.");
+    }
+    const hasAnyPinnedProvenance = calibration.answerSetHash !== void 0 || calibration.sourceResultId !== void 0 || calibration.sliceQuestionIds !== void 0;
+    if (hasAnyPinnedProvenance && (typeof calibration.answerSetHash !== "string" || !/^[0-9a-f]{64}$/.test(calibration.answerSetHash) || typeof calibration.sourceResultId !== "string" || calibration.sourceResultId.length === 0 || !readCalibrationQuestionIds(calibration.sliceQuestionIds) || calibration.sliceQuestionIds.length !== calibration.sampleSize)) {
+      throw new Error("BenchmarkArtifact judgeCalibration pinned provenance requires a sourceResultId, answerSetHash, and unique sliceQuestionIds matching sampleSize.");
+    }
   }
   const metrics = requireObject(record, "metrics");
   for (const [key, value] of Object.entries(metrics)) {
@@ -6678,6 +7890,14 @@ function isPublishedBenchmarkArtifactId(value) {
 }
 
 // src/providers/retry-fetch.ts
+var RetryFetchHttpError = class extends Error {
+  status;
+  constructor(status, message) {
+    super(message);
+    this.name = "RetryFetchHttpError";
+    this.status = status;
+  }
+};
 var DEFAULTS = {
   maxAttempts: 3,
   baseBackoffMs: 1e3,
@@ -6839,7 +8059,8 @@ async function retryFetch(url, init, options) {
       const bodyPreview = await readBodyPreview(response, 512);
       if (attempt >= opts.maxAttempts && remainingExtendedBudgetMs() <= 0) {
         callerSignal?.removeEventListener("abort", onCallerAbort);
-        throw new Error(
+        throw new RetryFetchHttpError(
+          response.status,
           `HTTP ${response.status} ${response.statusText} (attempt ${attempt}/${opts.maxAttempts}): ${bodyPreview}`
         );
       }
@@ -9183,7 +10404,10 @@ function readGitSha() {
     return explicitSha.trim().slice(0, 40);
   }
   try {
-    return execSync("git rev-parse --short HEAD", { encoding: "utf8" }).trim();
+    return execSync("git rev-parse --short HEAD", {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
   } catch {
     return "unknown";
   }
@@ -9766,11 +10990,12 @@ async function answerBenchmarkQuestion(options) {
   }
   const answerMode = options.answerMode ?? "default";
   const answerFormat = options.answerFormat === "auto" || options.answerFormat === void 0 ? inferAnswerFormat(options.question) : options.answerFormat;
-  const question = answerMode === "strict" ? buildStrictBenchmarkQuestion(options.question, answerFormat) : answerMode === "agentic-memory" ? buildAgenticMemoryBenchmarkQuestion(
+  const baseQuestion = answerMode === "strict" ? buildStrictBenchmarkQuestion(options.question, answerFormat) : answerMode === "agentic-memory" ? buildAgenticMemoryBenchmarkQuestion(
     options.question,
     answerFormat,
     options.questionContext
   ) : options.question;
+  const question = shouldInstructRecallAbstention(options.recallSupport) ? buildRecallAbstentionQuestion(baseQuestion, options.recallSupport) : baseQuestion;
   const response = await options.responder.respond(
     question,
     options.recalledText
@@ -9793,6 +11018,19 @@ async function answerBenchmarkQuestion(options) {
     model: finalResponse.model ?? response.model
   };
 }
+function shouldInstructRecallAbstention(support) {
+  return support?.status === "empty" || support?.status === "weak";
+}
+function buildRecallAbstentionQuestion(question, support) {
+  const description = support.status === "empty" ? "the successful recall returned no evidence" : "the recall adapter explicitly classified the supplied evidence as weak";
+  return [
+    question,
+    "",
+    "Recall support gate:",
+    `- ${description}.`,
+    '- Do not infer, guess, or synthesize an answer. Answer exactly "unknown".'
+  ].join("\n");
+}
 function buildAgenticMemoryBenchmarkQuestion(question, answerFormat = "auto", context) {
   const prompt = buildStrictBenchmarkQuestion(question, answerFormat);
   return [
@@ -10402,6 +11640,592 @@ function asStringArray(value) {
 
 // src/responders.ts
 import { FallbackLlmClient } from "@remnic/core";
+
+// src/judges/memcorrect-rubrics.ts
+var OPENAI_RESPONSES_JUDGE_RUBRIC_VERSION = "openai-responses-bench-v1";
+var MEMCORRECT_CORRECTION_ACCEPTANCE_RUBRIC_VERSION = "memcorrect-correction-acceptance-v1";
+var MEMCORRECT_STALE_HARM_RUBRIC_VERSION = "memcorrect-stale-memory-harm-v1";
+var GENERAL_ANSWER_JUDGE_RUBRIC = [
+  "Grade the predicted benchmark answer against the reference answer.",
+  "A score of 1 means fully correct, 0 means fully incorrect, and values between 0 and 1 mean partially correct.",
+  "Do not reward unsupported claims. Ignore harmless wording and formatting differences."
+].join(" ");
+var MEMCORRECT_CORRECTION_ACCEPTANCE_RUBRIC = [
+  "Decide whether the memory system accepted the user's correction.",
+  "Pass only when the corrected fact is reflected and the retired fact is not asserted as current.",
+  "A quotation or correction-history record that clearly marks the retired fact as obsolete is not stale recall.",
+  "Use a score of 1 for accepted, 0 for not accepted, and a fractional score only when the evidence is genuinely ambiguous."
+].join(" ");
+var MEMCORRECT_STALE_HARM_RUBRIC = [
+  "Decide whether the memory system avoided stale-memory harm after a correction.",
+  "Pass only when the answer does not present the retired fact as current and does not act on it.",
+  "Correction provenance may mention the retired fact only when it is explicitly identified as obsolete.",
+  "Use a score of 1 when no stale harm is present, 0 when stale information affected the answer, and a fractional score only for genuinely ambiguous evidence."
+].join(" ");
+
+// src/providers/openai-responses.ts
+var DEFAULT_OPENAI_RESPONSES_JUDGE_MODEL = "gpt-5.6";
+var VERDICT_JSON_SCHEMA = {
+  type: "object",
+  additionalProperties: false,
+  required: ["score", "decision", "reason"],
+  properties: {
+    score: { type: "number", minimum: 0, maximum: 1 },
+    decision: { type: "string", enum: ["pass", "partial", "fail"] },
+    reason: { type: "string" }
+  }
+};
+var ASSISTANT_RUBRIC_JSON_SCHEMA = {
+  type: "object",
+  additionalProperties: false,
+  required: ["identity_accuracy", "stance_coherence", "novelty", "calibration", "notes"],
+  properties: {
+    identity_accuracy: { type: "number", minimum: 0, maximum: 5 },
+    stance_coherence: { type: "number", minimum: 0, maximum: 5 },
+    novelty: { type: "number", minimum: 0, maximum: 5 },
+    calibration: { type: "number", minimum: 0, maximum: 5 },
+    notes: { type: "string" }
+  }
+};
+var OpenAiResponsesJudgeError = class extends Error {
+  code;
+  retryable;
+  httpStatus;
+  telemetry;
+  constructor(failure) {
+    super(failure.error.message);
+    this.name = "OpenAiResponsesJudgeError";
+    this.code = failure.error.code;
+    this.retryable = failure.error.retryable;
+    this.httpStatus = failure.error.httpStatus;
+    this.telemetry = failure.telemetry;
+  }
+};
+var OpenAiResponsesProvider = class {
+  provider = "openai";
+  id;
+  name;
+  rubricVersion;
+  config;
+  usage = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
+  telemetryEvents = [];
+  constructor(config = {}) {
+    const model = normalizeModel(config.model);
+    this.config = { ...config, model };
+    this.id = `openai-responses:${model}`;
+    this.name = model;
+    this.rubricVersion = config.rubricVersion ?? OPENAI_RESPONSES_JUDGE_RUBRIC_VERSION;
+  }
+  async complete(prompt, opts = {}) {
+    const startedAt = performance.now();
+    let response;
+    try {
+      response = await retryFetch(
+        this.responsesUrl(),
+        {
+          method: "POST",
+          headers: this.headers(opts.headers),
+          signal: opts.signal,
+          body: JSON.stringify({
+            model: this.config.model,
+            ...opts.systemPrompt ? { instructions: opts.systemPrompt } : {},
+            input: prompt,
+            temperature: opts.temperature ?? this.config.temperature,
+            ...this.config.seed !== void 0 ? { seed: this.config.seed } : {},
+            ...opts.maxTokens !== void 0 ? { max_output_tokens: opts.maxTokens } : {},
+            store: false
+          })
+        },
+        this.config.retryOptions
+      );
+    } catch (error) {
+      throw this.asTransportError(error, startedAt, this.rubricVersion);
+    }
+    const parsed = await this.parseResponse(response, startedAt, this.rubricVersion);
+    this.recordUsage(parsed.telemetry.inputTokens, parsed.telemetry.outputTokens);
+    if (!parsed.ok) {
+      this.recordTelemetry(parsed.telemetry);
+      throw new OpenAiResponsesJudgeError(parsed);
+    }
+    const text = parsed.text;
+    if (text === null) {
+      const failure = this.failure(
+        "malformed_response",
+        "OpenAI Responses API returned no text output.",
+        startedAt,
+        {
+          response,
+          payload: parsed.payload,
+          rubricVersion: this.rubricVersion
+        }
+      );
+      this.recordTelemetry(failure.telemetry);
+      throw new OpenAiResponsesJudgeError(failure);
+    }
+    this.recordTelemetry(parsed.telemetry);
+    return {
+      text,
+      tokens: {
+        input: parsed.telemetry.inputTokens,
+        output: parsed.telemetry.outputTokens
+      },
+      latencyMs: parsed.telemetry.latencyMs,
+      model: parsed.telemetry.model
+    };
+  }
+  async judge(request) {
+    const startedAt = performance.now();
+    let response;
+    try {
+      response = await retryFetch(
+        this.responsesUrl(),
+        {
+          method: "POST",
+          headers: this.headers(),
+          signal: request.signal,
+          body: JSON.stringify({
+            model: this.config.model,
+            instructions: request.rubric,
+            input: request.input,
+            temperature: this.config.temperature,
+            ...this.config.seed !== void 0 ? { seed: this.config.seed } : {},
+            text: {
+              format: {
+                type: "json_schema",
+                name: "benchmark_verdict",
+                description: "A normalized benchmark grading verdict.",
+                strict: true,
+                schema: VERDICT_JSON_SCHEMA
+              }
+            },
+            max_output_tokens: request.maxTokens ?? 256,
+            store: false
+          })
+        },
+        this.config.retryOptions
+      );
+    } catch (error) {
+      const failure = this.transportFailure(error, startedAt, request.rubricVersion);
+      this.recordTelemetry(failure.telemetry);
+      return failure;
+    }
+    const parsed = await this.parseResponse(response, startedAt, request.rubricVersion);
+    this.recordUsage(parsed.telemetry.inputTokens, parsed.telemetry.outputTokens);
+    if (!parsed.ok) {
+      this.recordTelemetry(parsed.telemetry);
+      return parsed;
+    }
+    if (parsed.text === null) {
+      const failure = this.failure(
+        "malformed_response",
+        "OpenAI Responses API returned no structured verdict text.",
+        startedAt,
+        { response, payload: parsed.payload, rubricVersion: request.rubricVersion }
+      );
+      this.recordTelemetry(failure.telemetry);
+      return failure;
+    }
+    const verdict = parseVerdict(parsed.text);
+    if (!verdict) {
+      const failure = this.failure(
+        "malformed_verdict",
+        "OpenAI Responses API returned a verdict that failed schema validation.",
+        startedAt,
+        { response, payload: parsed.payload, rubricVersion: request.rubricVersion }
+      );
+      this.recordTelemetry(failure.telemetry);
+      return failure;
+    }
+    this.recordTelemetry(parsed.telemetry);
+    return { ok: true, verdict, telemetry: parsed.telemetry };
+  }
+  async evaluateAssistantRubric(request) {
+    const rubricVersion = `sealed:${request.rubricId}`;
+    const startedAt = performance.now();
+    let response;
+    try {
+      response = await retryFetch(
+        this.responsesUrl(),
+        {
+          method: "POST",
+          headers: this.headers(),
+          body: JSON.stringify({
+            model: this.config.model,
+            instructions: request.system,
+            input: request.user,
+            temperature: this.config.temperature,
+            ...this.config.seed !== void 0 ? { seed: this.config.seed } : {},
+            text: {
+              format: {
+                type: "json_schema",
+                name: "sealed_assistant_rubric",
+                description: "Scores for every sealed assistant-rubric dimension.",
+                strict: true,
+                schema: ASSISTANT_RUBRIC_JSON_SCHEMA
+              }
+            },
+            max_output_tokens: 512,
+            store: false
+          })
+        },
+        this.config.retryOptions
+      );
+    } catch (error) {
+      throw this.asTransportError(error, startedAt, rubricVersion);
+    }
+    const parsed = await this.parseResponse(response, startedAt, rubricVersion);
+    this.recordUsage(parsed.telemetry.inputTokens, parsed.telemetry.outputTokens);
+    if (!parsed.ok) {
+      this.recordTelemetry(parsed.telemetry);
+      throw new OpenAiResponsesJudgeError(parsed);
+    }
+    if (parsed.text === null || !parseAssistantRubric(parsed.text)) {
+      const failure = this.failure(
+        "malformed_verdict",
+        "OpenAI Responses API returned an invalid sealed assistant-rubric verdict.",
+        startedAt,
+        { response, payload: parsed.payload, rubricVersion }
+      );
+      this.recordTelemetry(failure.telemetry);
+      throw new OpenAiResponsesJudgeError(failure);
+    }
+    this.recordTelemetry(parsed.telemetry);
+    return parsed.text;
+  }
+  getUsage() {
+    return { ...this.usage };
+  }
+  resetUsage() {
+    this.usage = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
+  }
+  getTelemetryEvents() {
+    return this.telemetryEvents.map((event) => ({ ...event }));
+  }
+  async parseResponse(response, startedAt, rubricVersion) {
+    let payload;
+    try {
+      payload = await response.json();
+    } catch {
+      if (!response.ok) {
+        return this.failure(
+          response.status === 429 ? "rate_limited" : "api_error",
+          `OpenAI Responses API request failed with HTTP ${response.status}.`,
+          startedAt,
+          { response, rubricVersion }
+        );
+      }
+      return this.failure(
+        "malformed_response",
+        "OpenAI Responses API returned non-JSON data.",
+        startedAt,
+        { response, rubricVersion }
+      );
+    }
+    if (!response.ok) {
+      const code = response.status === 429 ? "rate_limited" : "api_error";
+      return this.failure(
+        code,
+        `OpenAI Responses API request failed with HTTP ${response.status}.`,
+        startedAt,
+        { response, payload, rubricVersion }
+      );
+    }
+    if (payload.error || payload.status === "failed" || payload.status === "cancelled") {
+      return this.failure(
+        "api_error",
+        `OpenAI Responses API reported ${payload.error?.code ?? payload.status ?? "an error"}.`,
+        startedAt,
+        { response, payload, rubricVersion }
+      );
+    }
+    if (payload.status === "incomplete") {
+      return this.failure(
+        "incomplete_response",
+        `OpenAI Responses API response was incomplete (${payload.incomplete_details?.reason ?? "unknown reason"}).`,
+        startedAt,
+        { response, payload, rubricVersion }
+      );
+    }
+    const refusal = readRefusal(payload);
+    if (refusal !== null) {
+      return this.failure(
+        "refusal",
+        "OpenAI Responses API refused the benchmark grading request.",
+        startedAt,
+        { response, payload, rubricVersion }
+      );
+    }
+    return {
+      ok: true,
+      payload,
+      text: readOutputText(payload),
+      telemetry: this.telemetry(payload, startedAt, rubricVersion)
+    };
+  }
+  failure(code, message, startedAt, context) {
+    const telemetry = this.telemetry(
+      context.payload,
+      startedAt,
+      context.rubricVersion,
+      code,
+      context.response?.status
+    );
+    return {
+      ok: false,
+      error: {
+        code,
+        message,
+        retryable: code === "rate_limited" || code === "transport_error",
+        ...context.response ? { httpStatus: context.response.status } : {}
+      },
+      telemetry
+    };
+  }
+  transportFailure(error, startedAt, rubricVersion) {
+    if (isAbortError2(error)) {
+      return this.failure(
+        "aborted",
+        "OpenAI Responses API request was aborted by the caller.",
+        startedAt,
+        { rubricVersion }
+      );
+    }
+    if (error instanceof RetryFetchHttpError) {
+      return this.failure(
+        error.status === 429 ? "rate_limited" : "api_error",
+        `OpenAI Responses API request failed with HTTP ${error.status} after retries.`,
+        startedAt,
+        {
+          response: new Response(null, { status: error.status }),
+          rubricVersion
+        }
+      );
+    }
+    return this.failure(
+      "transport_error",
+      `OpenAI Responses API transport failed (${safeErrorName(error)}).`,
+      startedAt,
+      { rubricVersion }
+    );
+  }
+  asTransportError(error, startedAt, rubricVersion) {
+    const failure = this.transportFailure(error, startedAt, rubricVersion);
+    this.recordTelemetry(failure.telemetry);
+    return new OpenAiResponsesJudgeError(failure);
+  }
+  telemetry(payload, startedAt, rubricVersion, errorCode, httpStatus) {
+    const tokens = readTokens(payload);
+    return {
+      model: payload?.model ?? this.config.model,
+      rubricVersion,
+      inputTokens: tokens.input,
+      outputTokens: tokens.output,
+      latencyMs: Math.round(performance.now() - startedAt),
+      ...errorCode ? { errorCode } : {},
+      ...httpStatus !== void 0 ? { httpStatus } : {}
+    };
+  }
+  recordTelemetry(event) {
+    this.telemetryEvents.push({ ...event });
+  }
+  recordUsage(input, output) {
+    this.usage = {
+      inputTokens: this.usage.inputTokens + input,
+      outputTokens: this.usage.outputTokens + output,
+      totalTokens: this.usage.totalTokens + input + output
+    };
+  }
+  responsesUrl() {
+    const baseUrl = trimTrailingSlashes(this.config.baseUrl ?? "https://api.openai.com/v1");
+    return `${baseUrl}/responses`;
+  }
+  headers(extra = {}) {
+    return {
+      "content-type": "application/json",
+      ...this.config.apiKey ? { authorization: `Bearer ${this.config.apiKey}` } : {},
+      ...this.config.headers ?? {},
+      ...extra
+    };
+  }
+};
+function createOpenAiResponsesProvider(config = {}) {
+  return new OpenAiResponsesProvider(config);
+}
+function createOpenAiResponsesBenchJudge(config = {}, provider = createOpenAiResponsesProvider(config)) {
+  const scoreWithMetrics = async (question, predicted, expected, control) => {
+    const result = await provider.judge({
+      rubric: GENERAL_ANSWER_JUDGE_RUBRIC,
+      rubricVersion: config.rubricVersion ?? OPENAI_RESPONSES_JUDGE_RUBRIC_VERSION,
+      input: [
+        `QUESTION: ${question}`,
+        `REFERENCE_ANSWER: ${expected}`,
+        `PREDICTED_ANSWER: ${predicted}`
+      ].join("\n\n"),
+      signal: control?.signal
+    });
+    if (!result.ok) throw new OpenAiResponsesJudgeError(result);
+    return toBenchJudgeResult(result);
+  };
+  const scoreBinaryPrompt = async (prompt, control) => {
+    const result = await provider.judge({
+      rubric: `${GENERAL_ANSWER_JUDGE_RUBRIC} This evaluator is binary: score must be exactly 0 or 1.`,
+      rubricVersion: config.rubricVersion ?? OPENAI_RESPONSES_JUDGE_RUBRIC_VERSION,
+      input: prompt,
+      signal: control?.signal
+    });
+    if (!result.ok) throw new OpenAiResponsesJudgeError(result);
+    if (result.verdict.score !== 0 && result.verdict.score !== 1) {
+      const failure = {
+        ok: false,
+        error: {
+          code: "malformed_verdict",
+          message: "OpenAI Responses API returned a non-binary verdict for a binary rubric.",
+          retryable: false
+        },
+        telemetry: { ...result.telemetry, errorCode: "malformed_verdict" }
+      };
+      throw new OpenAiResponsesJudgeError(failure);
+    }
+    return toBenchJudgeResult(result);
+  };
+  const judgeSpecialized = async (request, rubric, control) => {
+    const result = rubric === "correction" ? await judgeMemCorrectCorrectionAcceptance(provider, serializeMemCorrectJudgeRequest(request), control?.signal) : await judgeMemCorrectStaleMemoryHarm(provider, serializeMemCorrectJudgeRequest(request), control?.signal);
+    if (!result.ok) throw new OpenAiResponsesJudgeError(result);
+    return {
+      ...toBenchJudgeResult(result),
+      decision: result.verdict.decision,
+      reason: result.verdict.reason,
+      rubricVersion: result.telemetry.rubricVersion
+    };
+  };
+  return {
+    async score(question, predicted, expected, control) {
+      return (await scoreWithMetrics(question, predicted, expected, control)).score;
+    },
+    scoreWithMetrics,
+    scoreBinaryPrompt,
+    judgeMemCorrectCorrectionAcceptance: (request, control) => judgeSpecialized(request, "correction", control),
+    judgeMemCorrectStaleMemoryHarm: (request, control) => judgeSpecialized(request, "stale_harm", control)
+  };
+}
+async function judgeMemCorrectCorrectionAcceptance(provider, input, signal) {
+  return provider.judge({
+    rubric: MEMCORRECT_CORRECTION_ACCEPTANCE_RUBRIC,
+    rubricVersion: MEMCORRECT_CORRECTION_ACCEPTANCE_RUBRIC_VERSION,
+    input,
+    signal
+  });
+}
+async function judgeMemCorrectStaleMemoryHarm(provider, input, signal) {
+  return provider.judge({
+    rubric: MEMCORRECT_STALE_HARM_RUBRIC,
+    rubricVersion: MEMCORRECT_STALE_HARM_RUBRIC_VERSION,
+    input,
+    signal
+  });
+}
+function toBenchJudgeResult(result) {
+  return {
+    score: result.verdict.score,
+    tokens: {
+      input: result.telemetry.inputTokens,
+      output: result.telemetry.outputTokens
+    },
+    latencyMs: result.telemetry.latencyMs,
+    model: result.telemetry.model
+  };
+}
+function normalizeModel(model) {
+  if (model === void 0) return DEFAULT_OPENAI_RESPONSES_JUDGE_MODEL;
+  const trimmed = model.trim();
+  if (trimmed.length === 0) {
+    throw new Error("OpenAI Responses judge model must be a non-empty string");
+  }
+  return trimmed;
+}
+function parseVerdict(text) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return null;
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+  const candidate = parsed;
+  const keys = Object.keys(candidate).sort();
+  if (keys.join(",") !== "decision,reason,score") return null;
+  if (typeof candidate.score !== "number" || !Number.isFinite(candidate.score) || candidate.score < 0 || candidate.score > 1 || candidate.decision !== "pass" && candidate.decision !== "partial" && candidate.decision !== "fail" || typeof candidate.reason !== "string" || candidate.reason.trim().length === 0) {
+    return null;
+  }
+  return {
+    score: candidate.score,
+    decision: candidate.decision,
+    reason: candidate.reason.trim()
+  };
+}
+function parseAssistantRubric(text) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return false;
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return false;
+  const candidate = parsed;
+  const keys = Object.keys(candidate).sort();
+  if (keys.join(",") !== "calibration,identity_accuracy,notes,novelty,stance_coherence") return false;
+  return ["identity_accuracy", "stance_coherence", "novelty", "calibration"].every(
+    (key) => typeof candidate[key] === "number" && Number.isFinite(candidate[key]) && candidate[key] >= 0 && candidate[key] <= 5
+  ) && typeof candidate.notes === "string";
+}
+function serializeMemCorrectJudgeRequest(request) {
+  return JSON.stringify({
+    taskId: request.taskId,
+    query: request.query,
+    retiredContent: request.retiredContent,
+    correctedContent: request.correctedContent,
+    evidence: {
+      postCorrectionRecall: request.postCorrectionRecall,
+      postMaintenanceRecall: request.postMaintenanceRecall,
+      postReingestRecall: request.postReingestRecall
+    }
+  });
+}
+function readOutputText(payload) {
+  const text = (payload.output ?? []).flatMap((item) => item.type === "message" ? item.content ?? [] : []).filter((part) => part.type === "output_text").map((part) => part.text ?? "").join("").trim();
+  return text.length > 0 ? text : null;
+}
+function readRefusal(payload) {
+  for (const item of payload.output ?? []) {
+    if (item.type !== "message") continue;
+    for (const part of item.content ?? []) {
+      if (part.type === "refusal") return part.refusal ?? "refused";
+    }
+  }
+  return null;
+}
+function readTokens(payload) {
+  return {
+    input: finiteNonNegative(payload?.usage?.input_tokens),
+    output: finiteNonNegative(payload?.usage?.output_tokens)
+  };
+}
+function finiteNonNegative(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : 0;
+}
+function safeErrorName(error) {
+  return error instanceof Error && error.name.trim().length > 0 ? error.name : "Error";
+}
+function isAbortError2(error) {
+  return error instanceof Error && error.name === "AbortError";
+}
+function trimTrailingSlashes(value) {
+  let end = value.length;
+  while (end > 0 && value.charCodeAt(end - 1) === 47) end -= 1;
+  return end === value.length ? value : value.slice(0, end);
+}
+
+// src/responders.ts
 var DEFAULT_RESPONDER_SYSTEM_PROMPT = [
   "You answer benchmark questions using only the supplied Remnic memory context.",
   "If the context does not contain enough information, say that the answer is unknown.",
@@ -10891,6 +12715,9 @@ function createJudgeFromProvider(provider) {
 }
 function createProviderBackedJudge(config, providerInstance) {
   validateProviderConfig(config, "judge");
+  if (config.provider === "openai" && providerInstance === void 0) {
+    return createOpenAiResponsesBenchJudge({ ...config, provider: "openai" });
+  }
   return createJudgeFromProvider(providerInstance ?? createProvider(config));
 }
 function createAmaBenchRecommendedJudgeFromProvider(provider) {
@@ -10944,7 +12771,15 @@ function createStructuredJudgeFromProvider(provider) {
 }
 function createProviderBackedStructuredJudge(config, providerInstance) {
   validateProviderConfig(config, "judge");
-  return createStructuredJudgeFromProvider(providerInstance ?? createProvider(config));
+  if (config.provider === "openai" && providerInstance === void 0) {
+    const provider = createOpenAiResponsesProvider({ ...config, provider: "openai" });
+    return {
+      evaluate: (request) => provider.evaluateAssistantRubric(request)
+    };
+  }
+  return createStructuredJudgeFromProvider(
+    providerInstance ?? createProvider(config)
+  );
 }
 function createGatewayResponder(options) {
   if (!options.gatewayConfig) {
@@ -11769,10 +13604,10 @@ function manifestProviderKindToBuiltIn(kind) {
 }
 
 // src/local-lab/preflight.ts
-var DEFAULT_PREFLIGHT_TIMEOUT_MS = 5e3;
+var DEFAULT_PREFLIGHT_TIMEOUT_MS2 = 5e3;
 async function preflightLocalLabRole(input, options = {}) {
   const fetchImpl = options.fetchImpl ?? fetch;
-  const timeoutMs = options.timeoutMs ?? DEFAULT_PREFLIGHT_TIMEOUT_MS;
+  const timeoutMs = options.timeoutMs ?? DEFAULT_PREFLIGHT_TIMEOUT_MS2;
   const endpoint = discoveryEndpointFor(input.provider, input.baseUrl);
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(new Error("preflight timeout")), timeoutMs);
@@ -12109,9 +13944,8 @@ async function resolveBenchRuntimeProfile(options) {
   registerCodexCliFallbackRunnerIfNeeded(internalProvider);
   const responderFactoryConfig = systemProvider ? asProviderFactoryConfig(systemProvider) : void 0;
   const judgeFactoryConfig = judgeProvider ? asProviderFactoryConfig(judgeProvider) : void 0;
-  const judgeProviderInstance = judgeFactoryConfig ? createProvider(judgeFactoryConfig) : void 0;
-  const judge = judgeFactoryConfig ? createProviderBackedJudge(judgeFactoryConfig, judgeProviderInstance) : void 0;
-  const structuredJudge = judgeFactoryConfig ? createProviderBackedStructuredJudge(judgeFactoryConfig, judgeProviderInstance) : void 0;
+  const judge = judgeFactoryConfig ? createProviderBackedJudge(judgeFactoryConfig) : void 0;
+  const structuredJudge = judgeFactoryConfig ? createProviderBackedStructuredJudge(judgeFactoryConfig) : void 0;
   if (profile === "baseline") {
     const responder = responderFactoryConfig ? createProviderBackedResponder(responderFactoryConfig) : void 0;
     const baselineConfig = buildBenchBaselineRemnicConfig();
@@ -12136,7 +13970,7 @@ async function resolveBenchRuntimeProfile(options) {
         ...drainTimeoutMs ? { drainTimeoutMs } : {}
       },
       systemProvider,
-      judgeProvider,
+      judgeProvider: judgeProvider ? sanitizeProviderConfig(judgeProvider) : null,
       internalProvider: internalProvider ? sanitizeProviderConfig(internalProvider) : null
     };
   }
@@ -12145,6 +13979,10 @@ async function resolveBenchRuntimeProfile(options) {
     const fileConfig = options.remnicConfigPath ? await loadRemnicConfigFile(options.remnicConfigPath) : {};
     const realProfileOverrides = {
       lcmEnabled: true,
+      // Read-time faithfulness is on by default for the full-feature profile.
+      // An explicit config value (including false-like strings) remains
+      // authoritative so benchmark operators can perform reversible ablations.
+      ...fileConfig.answerSupportGate === void 0 ? { answerSupportGate: true } : {},
       ...options.modelSource ? { modelSource: options.modelSource } : {},
       ...options.gatewayAgentId ? { gatewayAgentId: options.gatewayAgentId } : {},
       ...options.fastGatewayAgentId ? { fastGatewayAgentId: options.fastGatewayAgentId } : {},
@@ -12175,7 +14013,7 @@ async function resolveBenchRuntimeProfile(options) {
         ...drainTimeoutMs ? { drainTimeoutMs } : {}
       },
       systemProvider,
-      judgeProvider,
+      judgeProvider: judgeProvider ? sanitizeProviderConfig(judgeProvider) : null,
       internalProvider: internalProvider ? sanitizeProviderConfig(internalProvider) : null
     };
   }
@@ -12226,7 +14064,7 @@ async function resolveBenchRuntimeProfile(options) {
       ...drainTimeoutMs ? { drainTimeoutMs } : {}
     },
     systemProvider: null,
-    judgeProvider,
+    judgeProvider: judgeProvider ? sanitizeProviderConfig(judgeProvider) : null,
     internalProvider: internalProvider ? sanitizeProviderConfig(internalProvider) : null
   };
 }
@@ -12284,7 +14122,9 @@ async function loadJsonObject(filePath, label) {
 }
 function resolveProviderConfig(kind, provider, model, baseUrl, requestTimeout, disableThinking, apiKey, max429WaitMs, reasoningEffort, responderContextBudgetChars, responderPromptBudgetChars) {
   const hasProvider = typeof provider === "string";
-  const hasModel = typeof model === "string" && model.trim().length > 0;
+  const defaultOpenAiJudgeModel = kind === "judge" && provider === "openai" && model === void 0 ? DEFAULT_OPENAI_RESPONSES_JUDGE_MODEL : void 0;
+  const resolvedModel = defaultOpenAiJudgeModel ?? model;
+  const hasModel = typeof resolvedModel === "string" && resolvedModel.trim().length > 0;
   const hasBaseUrl = typeof baseUrl === "string" && baseUrl.trim().length > 0;
   const hasApiKey = typeof apiKey === "string" && apiKey.trim().length > 0;
   const hasReasoningEffort = reasoningEffort !== void 0;
@@ -12313,7 +14153,8 @@ function resolveProviderConfig(kind, provider, model, baseUrl, requestTimeout, d
   }
   return {
     provider,
-    model: model.trim(),
+    model: resolvedModel.trim(),
+    ...kind === "judge" && provider === "openai" ? { rubricVersion: OPENAI_RESPONSES_JUDGE_RUBRIC_VERSION } : {},
     ...hasBaseUrl ? { baseUrl: baseUrl.trim() } : {},
     ...hasApiKey ? { apiKey: apiKey.trim() } : {},
     ...requestTimeout != null || max429WaitMs != null ? { retryOptions: {
@@ -12588,7 +14429,8 @@ function asProviderFactoryConfig(config) {
     ...config.temperature !== void 0 ? { temperature: config.temperature } : {},
     ...config.seed !== void 0 ? { seed: config.seed } : {},
     ...config.responderContextBudgetChars !== void 0 ? { responderContextBudgetChars: config.responderContextBudgetChars } : {},
-    ...config.responderPromptBudgetChars !== void 0 ? { responderPromptBudgetChars: config.responderPromptBudgetChars } : {}
+    ...config.responderPromptBudgetChars !== void 0 ? { responderPromptBudgetChars: config.responderPromptBudgetChars } : {},
+    ...config.rubricVersion !== void 0 ? { rubricVersion: config.rubricVersion } : {}
   };
 }
 function asNonEmptyString(value) {
@@ -12642,9 +14484,8 @@ async function resolveLocalLabRuntimeProfile(options) {
     options
   );
   const judgeFactoryConfig = judgeProvider ? asProviderFactoryConfig(judgeProvider) : void 0;
-  const judgeProviderInstance = judgeFactoryConfig ? createProvider(judgeFactoryConfig) : void 0;
-  const judge = judgeFactoryConfig ? createProviderBackedJudge(judgeFactoryConfig, judgeProviderInstance) : void 0;
-  const structuredJudge = judgeFactoryConfig ? createProviderBackedStructuredJudge(judgeFactoryConfig, judgeProviderInstance) : void 0;
+  const judge = judgeFactoryConfig ? createProviderBackedJudge(judgeFactoryConfig) : void 0;
+  const structuredJudge = judgeFactoryConfig ? createProviderBackedStructuredJudge(judgeFactoryConfig) : void 0;
   const responderFactoryConfig = systemProvider ? asProviderFactoryConfig(systemProvider) : void 0;
   const responder = responderFactoryConfig ? createProviderBackedResponder(responderFactoryConfig) : void 0;
   const lcmObserveConcurrencyOverrides = buildLcmObserveConcurrencyOverrides(options.lcmObserveConcurrency);
@@ -12947,6 +14788,22 @@ function runJudgeWithCache(options) {
       }
     });
   }
+  if (typeof judge.judgeMemCorrectCorrectionAcceptance === "function") {
+    Object.defineProperty(wrapper, "judgeMemCorrectCorrectionAcceptance", {
+      configurable: true,
+      enumerable: true,
+      writable: false,
+      value: (request, control) => judge.judgeMemCorrectCorrectionAcceptance(request, control)
+    });
+  }
+  if (typeof judge.judgeMemCorrectStaleMemoryHarm === "function") {
+    Object.defineProperty(wrapper, "judgeMemCorrectStaleMemoryHarm", {
+      configurable: true,
+      enumerable: true,
+      writable: false,
+      value: (request, control) => judge.judgeMemCorrectStaleMemoryHarm(request, control)
+    });
+  }
   return wrapper;
 }
 function parseEnvelope(raw) {
@@ -15303,10 +17160,10 @@ function unpackMemoryArenaWebshopJsonlRecord(parsed) {
   if (Array.isArray(parsed)) {
     return parsed.map((value) => ({ value }));
   }
-  if (isPlainRecord(parsed)) {
+  if (isPlainRecord2(parsed)) {
     for (const key of ["products", "records", "items"]) {
       const value = parsed[key];
-      if (Array.isArray(value) || isPlainRecord(value)) {
+      if (Array.isArray(value) || isPlainRecord2(value)) {
         return unpackMemoryArenaWebshopRecords(parsed);
       }
     }
@@ -15317,7 +17174,7 @@ function unpackMemoryArenaWebshopRecords(parsed) {
   if (Array.isArray(parsed)) {
     return parsed.map((value) => ({ value }));
   }
-  if (!isPlainRecord(parsed)) {
+  if (!isPlainRecord2(parsed)) {
     throw new Error("top-level value must be a JSON array, object, or JSONL records");
   }
   for (const key of ["products", "records", "items"]) {
@@ -15325,7 +17182,7 @@ function unpackMemoryArenaWebshopRecords(parsed) {
     if (Array.isArray(value)) {
       return value.map((item) => ({ value: item }));
     }
-    if (isPlainRecord(value)) {
+    if (isPlainRecord2(value)) {
       return Object.entries(value).map(([defaultAsin, item]) => ({
         value: item,
         defaultAsin
@@ -15348,7 +17205,7 @@ function isMemoryArenaWebshopProductRecord(record) {
   ).length > 0;
 }
 function parseMemoryArenaWebshopProduct(raw) {
-  if (!isPlainRecord(raw.value)) {
+  if (!isPlainRecord2(raw.value)) {
     return void 0;
   }
   const record = raw.value;
@@ -15698,7 +17555,7 @@ function formatMemoryArenaDecisionCandidate(candidate) {
 }
 function extractSelectedMemoryArenaCustomization(record) {
   const customizationOptions = record.customization_options;
-  if (!isPlainRecord(customizationOptions)) {
+  if (!isPlainRecord2(customizationOptions)) {
     return void 0;
   }
   for (const optionGroup of Object.values(customizationOptions)) {
@@ -15706,7 +17563,7 @@ function extractSelectedMemoryArenaCustomization(record) {
       continue;
     }
     for (const option of optionGroup) {
-      if (!isPlainRecord(option) || option.is_selected !== true) {
+      if (!isPlainRecord2(option) || option.is_selected !== true) {
         continue;
       }
       const priceText = cleanMemoryArenaWebshopString(
@@ -15723,7 +17580,7 @@ function extractSelectedMemoryArenaCustomization(record) {
 }
 function extractMemoryArenaProductInformationValue(record, requestedKey) {
   const productInformation = record.product_information;
-  if (!isPlainRecord(productInformation)) {
+  if (!isPlainRecord2(productInformation)) {
     return void 0;
   }
   const normalizedRequestedKey = normalizeItemSelectionText(requestedKey);
@@ -15736,13 +17593,13 @@ function extractMemoryArenaProductInformationValue(record, requestedKey) {
 }
 function readMemoryArenaProductCustomerReviewNumber(record, key) {
   const productInformation = record.product_information;
-  if (!isPlainRecord(productInformation)) {
+  if (!isPlainRecord2(productInformation)) {
     return void 0;
   }
   const customerReviews = Object.entries(productInformation).find(
     ([entryKey]) => normalizeItemSelectionText(cleanMemoryArenaWebshopString(entryKey)) === "customer reviews"
   )?.[1];
-  if (!isPlainRecord(customerReviews)) {
+  if (!isPlainRecord2(customerReviews)) {
     return void 0;
   }
   return readMemoryArenaNumberField(customerReviews, key);
@@ -15815,7 +17672,7 @@ function cleanMemoryArenaWebshopString(value) {
 function formatMemoryArenaNumber(value) {
   return Number.isInteger(value) ? String(value) : String(Number(value.toFixed(2)));
 }
-function isPlainRecord(value) {
+function isPlainRecord2(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function isNodeErrorCode(error, code) {
@@ -17027,6 +18884,7 @@ async function* toAsyncIterable(iter) {
 }
 async function runPublishedHarness(ctx) {
   validateContext(ctx);
+  const answerSupportGate = resolveAnswerSupportGate(ctx.options);
   const trialConcurrency = resolveTrialConcurrency(
     ctx.options.benchmarkOptions?.trialConcurrency
   );
@@ -17050,7 +18908,8 @@ async function runPublishedHarness(ctx) {
     await executePlanTrials(ctx, plan.trials, {
       planIndex,
       tasks,
-      trialConcurrency
+      trialConcurrency,
+      answerSupportGate
     });
   }
   return buildBenchmarkResult(ctx, tasks);
@@ -17061,7 +18920,12 @@ async function executePlanTrials(ctx, trials, options) {
       appendCompletedTask(
         ctx,
         options.tasks,
-        await executeTrialWithFailure(ctx, trial, options.planIndex)
+        await executeTrialWithFailure(
+          ctx,
+          trial,
+          options.planIndex,
+          options.answerSupportGate
+        )
       );
     }
     return;
@@ -17086,7 +18950,8 @@ async function executePlanTrials(ctx, trials, options) {
       results[trialIndex] = await executeTrialWithFailure(
         ctx,
         trials[trialIndex],
-        options.planIndex
+        options.planIndex,
+        options.answerSupportGate
       );
       completed[trialIndex] = true;
       emitCompletedPrefix();
@@ -17101,10 +18966,10 @@ function appendCompletedTask(ctx, tasks, task) {
   tasks.push(task);
   ctx.options.onTaskComplete?.(task, tasks.length, ctx.totalCount);
 }
-async function executeTrialWithFailure(ctx, trial, planIndex) {
+async function executeTrialWithFailure(ctx, trial, planIndex, answerSupportGate) {
   const trialId = trial.taskId ?? trial.question.slice(0, 60);
   try {
-    return await executeTrial(ctx, trial);
+    return await executeTrial(ctx, trial, answerSupportGate);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     console.error(`  [WARN] harness trial plan-${planIndex}/${trialId} failed: ${message}`);
@@ -17116,7 +18981,17 @@ async function executeTrialWithFailure(ctx, trial, planIndex) {
       scores: buildFailureScores(ctx.metricsSpec.metrics),
       latencyMs: 0,
       tokens: { input: 0, output: 0 },
-      details: { error: message }
+      details: {
+        // `error` is retained for compatibility with existing diagnostics.
+        // The structured marker is the authoritative run-status signal; an
+        // arbitrary benchmark-owned `extraDetails.error` must not make a
+        // successful trial look failed.
+        error: message,
+        benchmarkFailure: {
+          kind: "trial_execution_failure",
+          message
+        }
+      }
     };
   }
 }
@@ -17172,8 +19047,29 @@ function resolveTrialConcurrency(raw) {
   }
   return parsed;
 }
-async function executeTrial(ctx, trial) {
-  const { result: recalledText, durationMs } = await timed(async () => {
+function resolveAnswerSupportGate(options) {
+  const raw = options.benchmarkOptions?.answerSupportGate ?? options.remnicConfig?.answerSupportGate;
+  if (raw === void 0) {
+    return false;
+  }
+  if (typeof raw === "boolean") {
+    return raw;
+  }
+  if (typeof raw === "string") {
+    const normalized = raw.trim().toLowerCase();
+    if (["true", "1", "yes", "on"].includes(normalized)) {
+      return true;
+    }
+    if (["false", "0", "no", "off"].includes(normalized)) {
+      return false;
+    }
+  }
+  throw new Error(
+    "PublishedBenchmarkHarness: answerSupportGate must be a boolean or one of true/false, 1/0, yes/no, on/off."
+  );
+}
+async function executeTrial(ctx, trial, answerSupportGate) {
+  const { result: recallResult, durationMs } = await timed(async () => {
     const recallBudget = benchmarkRecallBudgetForSessionCount(
       trial.recallSessionIds.length
     );
@@ -17183,17 +19079,21 @@ async function executeTrial(ctx, trial) {
       )
     );
     const rawRecalledText = recalledSessions.filter(Boolean).join("\n\n");
-    return trial.recallTextTransform ? trial.recallTextTransform({
+    const recalledText2 = trial.recallTextTransform ? trial.recallTextTransform({
       question: trial.question,
       recalledText: rawRecalledText
     }) : rawRecalledText;
+    const recallSupport2 = answerSupportGate ? await assessRecallSupport(ctx, trial, recalledText2) : void 0;
+    return { recalledText: recalledText2, recallSupport: recallSupport2 };
   });
+  const { recalledText, recallSupport } = recallResult;
   let answered = await answerBenchmarkQuestion({
     question: trial.question,
     recalledText,
     responder: ctx.options.system.responder,
     answerMode: "strict",
-    answerFormat: trial.answerFormat
+    answerFormat: trial.answerFormat,
+    recallSupport
   }).catch(
     (error) => answerWithTrialFallback(trial, recalledText, error)
   );
@@ -17261,6 +19161,7 @@ async function executeTrial(ctx, trial) {
     recalledText,
     answeredText: answered.finalAnswer,
     ...trial.answerFormat ? { answerFormat: trial.answerFormat } : {},
+    ...answerSupportGate ? { answerSupportGate: true, recallSupport } : {},
     responderModel: answered.model,
     judgeModel: judgeResult.model,
     ...answered.fallbackReason ? { answerFallbackReason: answered.fallbackReason } : {},
@@ -17290,6 +19191,56 @@ async function executeTrial(ctx, trial) {
     details
   };
 }
+async function assessRecallSupport(ctx, trial, recalledText) {
+  if (recalledText.trim().length === 0) {
+    return {
+      status: "empty",
+      reason: "successful recall returned empty responder context",
+      evidenceCount: 0
+    };
+  }
+  const assessor = ctx.options.system.assessRecallSupport;
+  if (!assessor) {
+    return {
+      status: "unavailable",
+      reason: "adapter did not provide an exact-context support assessment"
+    };
+  }
+  try {
+    const assessment = await assessor.call(ctx.options.system, {
+      query: trial.question,
+      recalledText,
+      sessionIds: trial.recallSessionIds
+    });
+    validateRecallSupportAssessment(assessment);
+    return assessment;
+  } catch (error) {
+    return {
+      status: "backend_failure",
+      reason: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function validateRecallSupportAssessment(assessment) {
+  const allowed = [
+    "supported",
+    "weak",
+    "empty",
+    "unavailable",
+    "backend_failure"
+  ];
+  if (!assessment || !allowed.includes(assessment.status)) {
+    throw new Error("adapter returned an invalid recall support status");
+  }
+  if (assessment.status !== "weak") {
+    return;
+  }
+  if (!Number.isInteger(assessment.evidenceCount) || (assessment.evidenceCount ?? 0) <= 0 || !Number.isFinite(assessment.maxScore) || !Number.isFinite(assessment.supportThreshold) || (assessment.maxScore ?? Number.POSITIVE_INFINITY) >= (assessment.supportThreshold ?? Number.NEGATIVE_INFINITY)) {
+    throw new Error(
+      "adapter weak recall support requires a positive evidenceCount and a finite maxScore below supportThreshold"
+    );
+  }
+}
 async function scoreTrialJudge(ctx, trial, answeredText) {
   if (!trial.binaryJudgePrompt) {
     return llmJudgeScoreDetailed(
@@ -17379,6 +19330,18 @@ async function buildBenchmarkResult(ctx, tasks) {
     0
   );
   const mode = ctx.options.mode;
+  const failedTasks = tasks.flatMap((task) => {
+    const marker = task.details?.benchmarkFailure;
+    if (typeof marker !== "object" || marker === null || marker.kind !== "trial_execution_failure") {
+      return [];
+    }
+    const message = marker.message;
+    return [{
+      taskId: task.taskId,
+      message: typeof message === "string" ? message : "unknown trial failure"
+    }];
+  });
+  const failureReason = failedTasks.length > 0 ? `trial_execution_failure: ${failedTasks.length}/${tasks.length} scored trial(s) failed (${failedTasks.slice(0, 3).map((failure) => `${failure.taskId}: ${failure.message.slice(0, 240)}`).join("; ")}${failedTasks.length > 3 ? `; and ${failedTasks.length - 3} more` : ""})` : void 0;
   return {
     meta: {
       id: randomUUID5(),
@@ -17390,7 +19353,8 @@ async function buildBenchmarkResult(ctx, tasks) {
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
       mode,
       runCount: 1,
-      seeds: [ctx.options.seed ?? 0]
+      seeds: [ctx.options.seed ?? 0],
+      ...failureReason ? { status: "partial", failureReason } : {}
     },
     config: {
       systemProvider: ctx.options.systemProvider ?? null,
@@ -17453,16 +19417,25 @@ async function runLongMemEvalBenchmark(options) {
 function buildPlan(item, options) {
   const ingestSessions = [];
   const sessionIds = [];
-  const annotateTemporalSources = shouldAnnotateTemporalSources(item.question);
+  const evidenceStrategy = resolveLongMemEvalEvidenceStrategy(item);
+  const annotateSources = evidenceStrategy !== "single-session" || shouldAnnotateTemporalSources(item.question);
+  const sourceChronology = rankSourceDates(
+    item.haystack_dates,
+    item.haystack_sessions.length
+  );
+  const currentKnowledgeSourceIndex = evidenceStrategy === "knowledge-update" ? sourceChronology.indexOf(item.haystack_sessions.length) : void 0;
   for (let sessionIndex = 0; sessionIndex < item.haystack_sessions.length; sessionIndex += 1) {
     const sessionId = item.haystack_session_ids[sessionIndex] ?? `session-${sessionIndex}`;
     const haystackDate = item.haystack_dates[sessionIndex];
     const messages = item.haystack_sessions[sessionIndex].map(
       (turn) => ({
         role: turn.role,
-        content: annotateTemporalSources ? formatLongMemEvalTurn(turn.content, {
+        content: annotateSources ? formatLongMemEvalTurn(turn.content, {
           sessionId,
-          haystackDate
+          haystackDate,
+          sourceOrder: sourceChronology[sessionIndex],
+          sourceCount: item.haystack_sessions.length,
+          sourceRecency: currentKnowledgeSourceIndex === void 0 ? void 0 : sessionIndex === currentKnowledgeSourceIndex ? "latest_source" : "historical_source"
         }) : turn.content
       })
     );
@@ -17474,6 +19447,7 @@ function buildPlan(item, options) {
     question: item.question,
     expected: item.answer,
     recallSessionIds: sessionIds,
+    recallTextTransform: ({ recalledText }) => composeLongMemEvalEvidence(recalledText, evidenceStrategy),
     binaryJudgePrompt: ({ answeredText }) => buildLongMemEvalOfficialJudgePrompt(item, answeredText),
     extraDetails: {
       questionType: item.question_type,
@@ -17481,6 +19455,8 @@ function buildPlan(item, options) {
       haystackDates: item.haystack_dates,
       haystackSessionIds: item.haystack_session_ids,
       answerSessionIds: item.answer_session_ids,
+      evidenceStrategy,
+      knowledgeSupersessionSurfaced: evidenceStrategy === "knowledge-update",
       judgeProtocol: "longmemeval-official-yes-no",
       judgePromptSource: "https://github.com/xiaowu0162/LongMemEval/blob/main/src/evaluation/evaluate_qa.py"
     },
@@ -17605,12 +19581,71 @@ function uniqueSearchResults(results) {
   return unique;
 }
 function formatLongMemEvalTurn(content, metadata) {
-  const fields = [`source_session: ${metadata.sessionId}`];
+  const fields = [
+    `source_session: ${metadata.sessionId}`,
+    `source_order: ${metadata.sourceOrder}/${metadata.sourceCount}`
+  ];
   if (metadata.haystackDate) {
     fields.push(`source_date: ${metadata.haystackDate}`);
   }
+  if (metadata.sourceRecency) {
+    fields.push(`source_recency: ${metadata.sourceRecency}`);
+  }
   return `[${fields.join("] [")}] ${content}`;
 }
+function resolveLongMemEvalEvidenceStrategy(item) {
+  if (item.question_type === "knowledge-update" || item.question_type === "multi-session-update") {
+    return "knowledge-update";
+  }
+  if (item.question_type === "multi-session") {
+    return "multi-session";
+  }
+  return "single-session";
+}
+function composeLongMemEvalEvidence(recalledText, strategy) {
+  if (recalledText.trim().length === 0 || strategy === "single-session") {
+    return recalledText;
+  }
+  const guidance = [
+    "[multi_session_evidence] Compose the answer from all relevant source_session blocks; one block may contain only part of the answer."
+  ];
+  if (strategy === "knowledge-update") {
+    guidance.push(
+      "[knowledge_update_evidence] Only when the same fact conflicts across sources, treat its older value as superseded and prefer the later source_date/source_order. source_recency describes source chronology, not the validity of unrelated facts."
+    );
+  }
+  return `${guidance.join("\n")}
+
+${recalledText}`;
+}
+function rankSourceDates(dates, sourceCount) {
+  const chronologicalIndices = Array.from(
+    { length: sourceCount },
+    (_, index) => index
+  ).sort((left, right) => {
+    const leftTimestamp = parseSourceDate(dates[left]);
+    const rightTimestamp = parseSourceDate(dates[right]);
+    if (leftTimestamp < rightTimestamp) {
+      return -1;
+    }
+    if (leftTimestamp > rightTimestamp) {
+      return 1;
+    }
+    return left - right;
+  });
+  const ranks = new Array(sourceCount);
+  chronologicalIndices.forEach((sourceIndex, chronologicalIndex) => {
+    ranks[sourceIndex] = chronologicalIndex + 1;
+  });
+  return ranks;
+}
+function parseSourceDate(value) {
+  if (!value) {
+    return Number.NEGATIVE_INFINITY;
+  }
+  const timestamp = Date.parse(value);
+  return Number.isFinite(timestamp) ? timestamp : Number.NEGATIVE_INFINITY;
+}
 function shouldAnnotateTemporalSources(question) {
   return collectIsoDateCues(question).length > 0 || collectTemporalLexicalCues(question).length > 0;
 }
@@ -17683,6 +19718,8 @@ var CATEGORY_NAMES = {
 };
 var DIALOGUE_ID_PATTERN = /\bD\d+:\d+\b/g;
 var LOCOMO_FOCUSED_LINE_LIMIT = 14;
+var LOCOMO_DIRECT_LINE_LIMIT = 10;
+var LOCOMO_COMPOSITION_HOP_LIMIT = 2;
 var LOCOMO_FOCUSED_LINE_MAX_CHARS = 420;
 var LOCOMO_FOCUSED_CONTEXT_MAX_CHARS = 6e3;
 var LOCOMO_FALLBACK_CONTEXT_MAX_CHARS = 8e3;
@@ -17917,8 +19954,22 @@ async function runLoCoMoBenchmark(options) {
     options.limit
   );
   const trialLimit = resolveTrialLimit(options.benchmarkOptions?.trialLimit);
-  const plans = applyTrialLimit(conversations.map(buildPlan2), trialLimit);
-  const benchmarkOptions = trialLimit === void 0 ? options.benchmarkOptions : { ...options.benchmarkOptions ?? {}, trialLimit };
+  const multiHopRecallComposition = resolveLoCoMoBooleanOption(
+    options.benchmarkOptions?.multiHopRecallComposition,
+    "multiHopRecallComposition",
+    true
+  );
+  const plans = applyTrialLimit(
+    conversations.map(
+      (conversation) => buildPlan2(conversation, multiHopRecallComposition)
+    ),
+    trialLimit
+  );
+  const benchmarkOptions = {
+    ...options.benchmarkOptions ?? {},
+    ...trialLimit === void 0 ? {} : { trialLimit },
+    multiHopRecallComposition
+  };
   return runPublishedHarness({
     options: { ...options, benchmarkOptions },
     metricsSpec: {
@@ -17928,6 +19979,26 @@ async function runLoCoMoBenchmark(options) {
     totalCount: plans.reduce((sum, plan) => sum + plan.trials.length, 0)
   });
 }
+function resolveLoCoMoBooleanOption(raw, optionName, defaultValue) {
+  if (raw === void 0) {
+    return defaultValue;
+  }
+  if (typeof raw === "boolean") {
+    return raw;
+  }
+  if (typeof raw === "string") {
+    const normalized = raw.trim().toLowerCase();
+    if (["true", "1", "yes", "on"].includes(normalized)) {
+      return true;
+    }
+    if (["false", "0", "no", "off"].includes(normalized)) {
+      return false;
+    }
+  }
+  throw new Error(
+    `LoCoMo benchmarkOptions.${optionName} must be a boolean or one of true/false, 1/0, yes/no, on/off.`
+  );
+}
 function resolveTrialLimit(raw) {
   if (raw === void 0) {
     return void 0;
@@ -17961,7 +20032,7 @@ function applyTrialLimit(plans, trialLimit) {
   }
   return limitedPlans;
 }
-function buildPlan2(conversation) {
+function buildPlan2(conversation, multiHopRecallComposition) {
   const sessions = extractSessions(conversation.conversation);
   const speakerA = typeof conversation.conversation.speaker_a === "string" ? conversation.conversation.speaker_a : "Speaker A";
   const ingestSessions = [];
@@ -17979,11 +20050,17 @@ function buildPlan2(conversation) {
     ingestSessions.push({ sessionId, messages });
   }
   const trials = conversation.qa.map(
-    (qa, questionIndex) => buildTrial(conversation.sample_id, qa, questionIndex, sessionIds)
+    (qa, questionIndex) => buildTrial(
+      conversation.sample_id,
+      qa,
+      questionIndex,
+      sessionIds,
+      multiHopRecallComposition
+    )
   );
   return { ingestSessions, trials };
 }
-function buildTrial(conversationId, qa, questionIndex, sessionIds) {
+function buildTrial(conversationId, qa, questionIndex, sessionIds, multiHopRecallComposition) {
   const categoryName = CATEGORY_NAMES[qa.category] ?? `category_${qa.category}`;
   return {
     taskId: `${conversationId}-q${questionIndex}-${categoryName}`,
@@ -17993,7 +20070,8 @@ function buildTrial(conversationId, qa, questionIndex, sessionIds) {
     answerFormat: "short-with-specifics",
     recallTextTransform: ({ question, recalledText }) => prioritizeLoCoMoRecallText({
       question,
-      recalledText: sanitizeLoCoMoRecallText({ question, recalledText })
+      recalledText: sanitizeLoCoMoRecallText({ question, recalledText }),
+      multiHopRecallComposition
     }),
     answerFallback: ({ question, recalledText }) => answerLoCoMoFromRecall(question, recalledText),
     answerRefinement: ({ question, recalledText, answeredText }) => refineLoCoMoAnswerFromRecall({ question, recalledText, answeredText }),
@@ -18194,7 +20272,9 @@ function sanitizeLoCoMoRecallText(args) {
   );
 }
 function prioritizeLoCoMoRecallText(args) {
-  const lines = args.recalledText.replaceAll("\r\n", "\n").replaceAll("\r", "\n").split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
+  const lines = dedupePreserveOrder(
+    args.recalledText.replaceAll("\r\n", "\n").replaceAll("\r", "\n").split("\n").map((line) => line.trim()).filter((line) => line.length > 0)
+  );
   const questionTokens = expandLoCoMoQuestionTokens(
     tokenizeForLoCoMo(args.question)
   );
@@ -18205,20 +20285,124 @@ function prioritizeLoCoMoRecallText(args) {
   })).filter((entry) => entry.score > 0).sort(
     (left, right) => right.score === left.score ? left.index - right.index : right.score - left.score
   );
-  const focused = dedupePreserveOrder(
-    scored.slice(0, LOCOMO_FOCUSED_LINE_LIMIT).map((entry) => truncateLoCoMoLine(entry.line))
+  const directSeeds = scored.slice(
+    0,
+    args.multiHopRecallComposition ? LOCOMO_DIRECT_LINE_LIMIT : LOCOMO_FOCUSED_LINE_LIMIT
   );
-  if (focused.length === 0) {
+  const linkedHops = args.multiHopRecallComposition ? composeLoCoMoLinkedEvidence({
+    lines,
+    direct: directSeeds,
+    questionTokens,
+    remainingLineBudget: LOCOMO_FOCUSED_LINE_LIMIT - directSeeds.length
+  }) : [];
+  const linkedLineCount = linkedHops.reduce(
+    (sum, hop) => sum + hop.lines.length,
+    0
+  );
+  const direct = [
+    ...directSeeds,
+    ...scored.slice(
+      directSeeds.length,
+      LOCOMO_FOCUSED_LINE_LIMIT - linkedLineCount
+    )
+  ];
+  if (direct.length === 0 && linkedHops.length === 0) {
     return truncateLoCoMoContext(
       args.recalledText,
       LOCOMO_FALLBACK_CONTEXT_MAX_CHARS
     );
   }
+  const sections = [
+    "## LoCoMo Question-Focused Evidence",
+    ...direct.map((entry) => truncateLoCoMoLine(entry.line))
+  ];
+  for (const hop of linkedHops) {
+    sections.push(
+      `## LoCoMo Linked Evidence (hop ${hop.hop})`,
+      ...hop.lines.map(truncateLoCoMoLine)
+    );
+  }
   return truncateLoCoMoContext(
-    ["## LoCoMo Question-Focused Evidence", ...focused].join("\n"),
+    sections.join("\n"),
     LOCOMO_FOCUSED_CONTEXT_MAX_CHARS
   );
 }
+function composeLoCoMoLinkedEvidence(args) {
+  if (args.direct.length === 0 || args.remainingLineBudget <= 0) {
+    return [];
+  }
+  const lineEntries = args.lines.map((line, index) => ({
+    line,
+    index,
+    directScore: scoreLoCoMoLine(line, args.questionTokens),
+    bridgeTokens: collectLoCoMoBridgeTokens(line, args.questionTokens)
+  }));
+  const selectedIndexes = new Set(args.direct.map((entry) => entry.index));
+  const visitedBridgeTokens = /* @__PURE__ */ new Set();
+  let frontierTokens = /* @__PURE__ */ new Set();
+  for (const entry of args.direct) {
+    for (const token of lineEntries[entry.index]?.bridgeTokens ?? []) {
+      frontierTokens.add(token);
+      visitedBridgeTokens.add(token);
+    }
+  }
+  const hops = [];
+  let remaining = args.remainingLineBudget;
+  for (let hop = 1; hop <= LOCOMO_COMPOSITION_HOP_LIMIT && remaining > 0 && frontierTokens.size > 0; hop += 1) {
+    const candidates = lineEntries.filter(
+      (entry) => entry.directScore === 0 && !selectedIndexes.has(entry.index)
+    ).map((entry) => ({
+      ...entry,
+      sharedTokens: [...entry.bridgeTokens].filter(
+        (token) => frontierTokens.has(token)
+      )
+    })).filter((entry) => entry.sharedTokens.length > 0).sort((left, right) => {
+      if (right.sharedTokens.length !== left.sharedTokens.length) {
+        return right.sharedTokens.length - left.sharedTokens.length;
+      }
+      const longestLeft = Math.max(
+        ...left.sharedTokens.map((token) => token.length)
+      );
+      const longestRight = Math.max(
+        ...right.sharedTokens.map((token) => token.length)
+      );
+      return longestRight === longestLeft ? left.index - right.index : longestRight - longestLeft;
+    }).slice(0, remaining);
+    if (candidates.length === 0) {
+      break;
+    }
+    hops.push({ hop, lines: candidates.map((entry) => entry.line) });
+    remaining -= candidates.length;
+    const nextFrontier = /* @__PURE__ */ new Set();
+    for (const candidate of candidates) {
+      selectedIndexes.add(candidate.index);
+      for (const token of candidate.bridgeTokens) {
+        if (!visitedBridgeTokens.has(token)) {
+          nextFrontier.add(token);
+          visitedBridgeTokens.add(token);
+        }
+      }
+    }
+    frontierTokens = nextFrontier;
+  }
+  return hops;
+}
+function collectLoCoMoBridgeTokens(line, questionTokens) {
+  const entityLikeTokens = /* @__PURE__ */ new Set();
+  for (const match of line.matchAll(/\b[A-Z][A-Za-z0-9'-]{2,}\b/g)) {
+    for (const token of tokenizeForLoCoMo(match[0])) {
+      entityLikeTokens.add(token);
+    }
+  }
+  const result = /* @__PURE__ */ new Set();
+  for (const token of tokenizeForLoCoMo(line)) {
+    if (!entityLikeTokens.has(token) || token.length < 3 || /^\d+$/.test(token) || questionTokens.has(token) || LOCOMO_LINK_STOP_WORDS.has(token)) {
+      continue;
+    }
+    result.add(token);
+  }
+  return result;
+}
 function tokenizeForLoCoMo(text) {
   const tokens = /* @__PURE__ */ new Set();
   for (const rawToken of text.toLowerCase().match(/[a-z0-9]+/g) ?? []) {
@@ -18254,6 +20438,49 @@ var LOCOMO_STOP_WORDS = /* @__PURE__ */ new Set([
   "who",
   "would"
 ]);
+var LOCOMO_LINK_STOP_WORDS = /* @__PURE__ */ new Set([
+  ...LOCOMO_STOP_WORDS,
+  "about",
+  "assistant",
+  "context",
+  "conversation",
+  "discuss",
+  "discussed",
+  "evidence",
+  "focused",
+  "from",
+  "have",
+  "has",
+  "had",
+  "linked",
+  "memory",
+  "mention",
+  "mentioned",
+  "metadata",
+  "observation",
+  "pipeline",
+  "question",
+  "recall",
+  "recalled",
+  "remnic",
+  "said",
+  "says",
+  "search",
+  "session",
+  "speaker",
+  "summary",
+  "system",
+  "talked",
+  "that",
+  "their",
+  "them",
+  "they",
+  "this",
+  "told",
+  "user",
+  "were",
+  "with"
+]);
 function expandLoCoMoQuestionTokens(tokens) {
   const expanded = new Set(tokens);
   if (tokens.has("when")) {
@@ -32446,6 +34673,31 @@ async function runScenario(scenario, adapter, maintenanceCycles, uptakeLatencyCa
     metrics
   };
 }
+function buildMemCorrectJudgeRequest(scenario, log) {
+  const recalledFor = (phase) => log.find(
+    (entry) => entry.phase === phase && entry.namespace === scenario.namespace && entry.query === scenario.probe.query
+  )?.recalled ?? [];
+  return {
+    taskId: scenario.id,
+    query: scenario.probe.query,
+    retiredContent: scenario.correction.retiredContent,
+    correctedContent: scenario.correction.correctedContent,
+    postCorrectionRecall: recalledFor("post_correction"),
+    postMaintenanceRecall: recalledFor("post_maintenance"),
+    postReingestRecall: recalledFor("post_reingest")
+  };
+}
+function safeMemCorrectJudgeDetails(result) {
+  return {
+    score: result.score,
+    decision: result.decision,
+    model: result.model ?? "unknown",
+    rubricVersion: result.rubricVersion,
+    inputTokens: result.tokens.input,
+    outputTokens: result.tokens.output,
+    latencyMs: result.latencyMs
+  };
+}
 async function runMemCorrectBenchmark(options) {
   const baseOptions = options.mode === "quick" ? QUICK_OPTIONS2 : FULL_OPTIONS2;
   const seed = typeof options.seed === "number" ? options.seed : baseOptions.seed;
@@ -32458,6 +34710,13 @@ async function runMemCorrectBenchmark(options) {
     );
   }
   const { adapter, adapterLabel } = resolveAdapter(options);
+  const judge = options.memCorrectJudge ?? options.system.judge;
+  const hasSpecializedJudge = judge?.judgeMemCorrectCorrectionAcceptance !== void 0 && judge.judgeMemCorrectStaleMemoryHarm !== void 0;
+  if (options.judgeProvider?.provider === "openai" && !hasSpecializedJudge) {
+    throw new Error(
+      "OpenAI MemCorrect judging requires the Responses API specialized correction and stale-harm judge methods."
+    );
+  }
   const { limit } = options;
   let scenarios;
   if (typeof limit !== "number") {
@@ -32477,6 +34736,10 @@ async function runMemCorrectBenchmark(options) {
   const aggregateCollateralBefore = [];
   const aggregateCollateralAfter = [];
   const aggregateProvenance = [];
+  let judgeModelCalls = 0;
+  let judgeInputTokens = 0;
+  let judgeOutputTokens = 0;
+  let judgeLatencyMs = 0;
   for (const scenario of scenarios) {
     const started = performance.now();
     const run = await runScenario(
@@ -32485,7 +34748,6 @@ async function runMemCorrectBenchmark(options) {
       generatorOptions.maintenanceCycles,
       generatorOptions.uptakeLatencyCap
     );
-    const latencyMs = Math.round(performance.now() - started);
     aggregateLog.push(...run.log);
     aggregateCorrections.push(run.correction);
     aggregateAntiEvents.push(...run.antiEvents);
@@ -32503,6 +34765,26 @@ async function runMemCorrectBenchmark(options) {
     };
     if (m.scope_precision !== null) scores.scope_precision = m.scope_precision;
     if (m.reassertion !== null) scores.reassertion = m.reassertion;
+    let correctionJudge;
+    let staleHarmJudge;
+    if (hasSpecializedJudge) {
+      const request = buildMemCorrectJudgeRequest(scenario, run.log);
+      correctionJudge = await judge.judgeMemCorrectCorrectionAcceptance(request);
+      staleHarmJudge = await judge.judgeMemCorrectStaleMemoryHarm(request);
+      scores.judge_correction_acceptance = correctionJudge.score;
+      scores.judge_stale_harm_avoidance = staleHarmJudge.score;
+      for (const verdict of [correctionJudge, staleHarmJudge]) {
+        judgeModelCalls += 1;
+        judgeInputTokens += verdict.tokens.input;
+        judgeOutputTokens += verdict.tokens.output;
+        judgeLatencyMs += verdict.latencyMs;
+      }
+    }
+    const taskTokens = {
+      input: (correctionJudge?.tokens.input ?? 0) + (staleHarmJudge?.tokens.input ?? 0),
+      output: (correctionJudge?.tokens.output ?? 0) + (staleHarmJudge?.tokens.output ?? 0)
+    };
+    const latencyMs = Math.round(performance.now() - started);
     const task = {
       taskId: scenario.id,
       question: scenario.probe.query,
@@ -32519,7 +34801,7 @@ async function runMemCorrectBenchmark(options) {
       }),
       scores,
       latencyMs,
-      tokens: { input: 0, output: 0 },
+      tokens: taskTokens,
       details: {
         scenarioId: scenario.id,
         shape: scenario.correction.shape,
@@ -32528,7 +34810,13 @@ async function runMemCorrectBenchmark(options) {
         adapter: adapterLabel,
         metrics: {
           memcorrect: m
-        }
+        },
+        ...correctionJudge && staleHarmJudge ? {
+          judges: {
+            correctionAcceptance: safeMemCorrectJudgeDetails(correctionJudge),
+            staleMemoryHarmAvoidance: safeMemCorrectJudgeDetails(staleHarmJudge)
+          }
+        } : {}
       }
     };
     tasks.push(task);
@@ -32546,6 +34834,7 @@ async function runMemCorrectBenchmark(options) {
   });
   const remnicVersion = await getRemnicVersion();
   const totalLatencyMs = tasks.reduce((sum, t) => sum + t.latencyMs, 0);
+  const totalTokens = judgeInputTokens + judgeOutputTokens;
   const { adapter: _liveAdapter, ...persistableBenchmarkOptions } = options.benchmarkOptions ?? {};
   return {
     meta: {
@@ -32573,6 +34862,14 @@ async function runMemCorrectBenchmark(options) {
         factsPerPersona: generatorOptions.factsPerPersona,
         maintenanceCycles: generatorOptions.maintenanceCycles,
         uptakeLatencyCap: generatorOptions.uptakeLatencyCap,
+        ...judgeModelCalls > 0 ? {
+          judgeTelemetry: {
+            calls: judgeModelCalls,
+            inputTokens: judgeInputTokens,
+            outputTokens: judgeOutputTokens,
+            latencyMs: judgeLatencyMs
+          }
+        } : {},
         // 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
@@ -32581,13 +34878,13 @@ async function runMemCorrectBenchmark(options) {
       }
     },
     cost: {
-      totalTokens: 0,
-      inputTokens: 0,
-      outputTokens: 0,
+      totalTokens,
+      inputTokens: judgeInputTokens,
+      outputTokens: judgeOutputTokens,
       estimatedCostUsd: 0,
       totalLatencyMs,
       meanQueryLatencyMs: tasks.length > 0 ? totalLatencyMs / tasks.length : 0,
-      judgeModelCalls: 0
+      judgeModelCalls
     },
     results: {
       tasks,
@@ -34326,10 +36623,20 @@ async function runBenchmark(benchmarkId, options) {
   }
   const primaryCalls = judgeCacheCounters?.modelCalls ?? 0;
   const crossCalls = crossJudgeCacheCounters?.modelCalls ?? 0;
-  if (judgeCacheCounters !== void 0 || crossJudgeCacheCounters !== void 0) {
+  if (benchmarkId !== "memcorrect-v1" && (judgeCacheCounters !== void 0 || crossJudgeCacheCounters !== void 0)) {
     result.cost.judgeModelCalls = primaryCalls + crossCalls;
   }
-  return finalizeBenchmarkResultConfig(result, options);
+  const finalized = finalizeBenchmarkResultConfig(result, options);
+  assertCompleteBenchmarkResult(finalized);
+  return finalized;
+}
+function assertCompleteBenchmarkResult(result) {
+  if (result.meta.status !== "partial") {
+    return;
+  }
+  throw new Error(
+    `Benchmark "${result.meta.benchmark}" produced a partial result: ${result.meta.failureReason ?? "unknown benchmark failure"}`
+  );
 }
 function wrapJudgeWithCache(args) {
   const crossJudgeIdSuffix = args.role === "cross" ? "-cross" : "";
@@ -34788,6 +37095,273 @@ function getBenchmarkLowerIsBetter(benchmarkId) {
   return LOWER_IS_BETTER_BY_BENCHMARK[benchmarkId] ?? /* @__PURE__ */ new Set();
 }
 
+// src/stats/locomo-profile-delta.ts
+var LOCOMO_CATEGORY_ORDER = [
+  "single_hop",
+  "multi_hop",
+  "temporal",
+  "open_domain",
+  "adversarial"
+];
+var LOCOMO_TASK_CATEGORY_PATTERN = /-(single_hop|multi_hop|temporal|open_domain|adversarial)$/;
+function diagnoseLoComoProfileDelta(options) {
+  const maxRegressions = options.maxRegressions ?? 20;
+  if (!Number.isInteger(maxRegressions) || maxRegressions < 0) {
+    throw new Error("maxRegressions must be a non-negative integer.");
+  }
+  assertComparableArtifacts(options.baseline.artifact, options.real.artifact);
+  const joined = joinTasks(options.baseline.artifact, options.real.artifact);
+  const metrics = collectMetrics(joined);
+  const primaryMetric2 = options.primaryMetric ?? "llm_judge";
+  if (!metrics.includes(primaryMetric2)) {
+    throw new Error(
+      `Primary metric ${JSON.stringify(primaryMetric2)} is not present on every joined task.`
+    );
+  }
+  const overall = summarizeMetrics(joined, metrics, joined.length);
+  verifyPublishedMetricMeans(options.baseline.artifact, overall, "baseline");
+  verifyPublishedMetricMeans(options.real.artifact, overall, "real");
+  const categories = [...new Set(joined.map((task) => task.category))].sort(compareLoComoCategories).map((category) => {
+    const tasks = joined.filter((task) => task.category === category);
+    return {
+      category,
+      taskCount: tasks.length,
+      metrics: summarizeMetrics(tasks, metrics, joined.length)
+    };
+  });
+  const topRegressions = joined.map((task) => ({
+    taskId: task.taskId,
+    category: task.category,
+    baselineScore: task.baseline.scores[primaryMetric2],
+    realScore: task.real.scores[primaryMetric2],
+    delta: task.real.scores[primaryMetric2] - task.baseline.scores[primaryMetric2]
+  })).filter((task) => task.delta < 0).sort((left, right) => left.delta - right.delta || left.taskId.localeCompare(right.taskId)).slice(0, maxRegressions);
+  const baselineArtifact = options.baseline.artifact;
+  return {
+    schemaVersion: 1,
+    benchmarkId: "locomo",
+    comparison: {
+      baseline: {
+        reference: options.baseline.reference,
+        sha256: options.baseline.sha256
+      },
+      real: {
+        reference: options.real.reference,
+        sha256: options.real.sha256
+      },
+      datasetVersion: baselineArtifact.datasetVersion,
+      model: baselineArtifact.model,
+      seed: baselineArtifact.seed,
+      gitSha: baselineArtifact.system.gitSha,
+      tier: baselineArtifact.tier ?? "frontier"
+    },
+    taskCount: joined.length,
+    primaryMetric: primaryMetric2,
+    metrics,
+    overall,
+    categories,
+    topRegressions,
+    evidenceBoundary: {
+      scoreDiagnosis: "complete",
+      recallRootCause: "requires-paired-recall-receipts"
+    }
+  };
+}
+function renderLoComoProfileDeltaMarkdown(report) {
+  const primary = report.primaryMetric;
+  const lines = [
+    "# LoCoMo runtime-profile score diagnosis",
+    "",
+    `Joined ${report.taskCount} identical task ids from the baseline and real artifacts. The primary diagnostic metric is \`${primary}\` (real minus baseline).`,
+    "",
+    "| Category | Tasks | Baseline | Real | Delta | Aggregate contribution | Wins | Losses | Ties |",
+    "|---|---:|---:|---:|---:|---:|---:|---:|---:|"
+  ];
+  for (const category of report.categories) {
+    const metric = category.metrics[primary];
+    lines.push(
+      `| ${category.category} | ${category.taskCount} | ${formatScore(metric.baselineMean)} | ${formatScore(metric.realMean)} | ${formatSignedScore(metric.delta)} | ${formatSignedScore(metric.aggregateContribution)} | ${metric.wins} | ${metric.losses} | ${metric.ties} |`
+    );
+  }
+  const overall = report.overall[primary];
+  lines.push(
+    `| **Overall** | **${report.taskCount}** | **${formatScore(overall.baselineMean)}** | **${formatScore(overall.realMean)}** | **${formatSignedScore(overall.delta)}** | **${formatSignedScore(overall.aggregateContribution)}** | **${overall.wins}** | **${overall.losses}** | **${overall.ties}** |`,
+    "",
+    "## Highest-priority paired recall samples",
+    "",
+    `These task ids have the largest negative \`${primary}\` deltas. They are candidates for paired recall X-ray capture; score artifacts alone do not identify what recall tier served or what evidence was displaced.`,
+    "",
+    "| Task | Category | Baseline | Real | Delta |",
+    "|---|---|---:|---:|---:|"
+  );
+  for (const task of report.topRegressions) {
+    lines.push(
+      `| ${task.taskId} | ${task.category} | ${formatScore(task.baselineScore)} | ${formatScore(task.realScore)} | ${formatSignedScore(task.delta)} |`
+    );
+  }
+  lines.push(
+    "",
+    "## Evidence boundary",
+    "",
+    "The paired score diagnosis is complete for these artifacts. A recall-side root cause is not established until paired recall receipts exist for the same task ids and runtime profiles.",
+    "",
+    `Baseline: \`${report.comparison.baseline.reference}\` (\`${report.comparison.baseline.sha256}\`)`,
+    "",
+    `Real: \`${report.comparison.real.reference}\` (\`${report.comparison.real.sha256}\`)`,
+    ""
+  );
+  return `${lines.join("\n")}
+`;
+}
+function assertComparableArtifacts(baseline, real) {
+  if (baseline.benchmarkId !== "locomo" || real.benchmarkId !== "locomo") {
+    throw new Error("LoCoMo profile diagnosis requires two locomo artifacts.");
+  }
+  const checks = [
+    ["datasetVersion", baseline.datasetVersion, real.datasetVersion],
+    ["model", baseline.model, real.model],
+    ["seed", baseline.seed, real.seed],
+    ["system.gitSha", baseline.system.gitSha, real.system.gitSha],
+    ["tier", baseline.tier ?? "frontier", real.tier ?? "frontier"]
+  ];
+  for (const [field, baselineValue, realValue] of checks) {
+    if (baselineValue !== realValue) {
+      throw new Error(
+        `Artifacts are not comparable: ${field} differs (${JSON.stringify(baselineValue)} vs ${JSON.stringify(realValue)}).`
+      );
+    }
+  }
+}
+function joinTasks(baseline, real) {
+  const baselineTasks = indexTasks(baseline.perTaskScores, "baseline");
+  const realTasks = indexTasks(real.perTaskScores, "real");
+  const missingFromReal = [...baselineTasks.keys()].filter((id) => !realTasks.has(id)).sort();
+  const missingFromBaseline = [...realTasks.keys()].filter((id) => !baselineTasks.has(id)).sort();
+  if (missingFromReal.length > 0 || missingFromBaseline.length > 0) {
+    throw new Error(
+      `Artifacts do not contain identical task-id sets: ${missingFromReal.length} missing from real, ${missingFromBaseline.length} missing from baseline.`
+    );
+  }
+  return [...baselineTasks.keys()].sort().map((taskId) => {
+    const baselineTask = baselineTasks.get(taskId);
+    const realTask = realTasks.get(taskId);
+    const baselineCategory = resolveLoComoCategory(baselineTask);
+    const realCategory = resolveLoComoCategory(realTask);
+    if (baselineCategory !== realCategory) {
+      throw new Error(
+        `Task ${JSON.stringify(taskId)} has mismatched categories (${baselineCategory} vs ${realCategory}).`
+      );
+    }
+    return {
+      taskId,
+      category: baselineCategory,
+      baseline: baselineTask,
+      real: realTask
+    };
+  });
+}
+function indexTasks(tasks, label) {
+  const indexed = /* @__PURE__ */ new Map();
+  for (const task of tasks) {
+    if (indexed.has(task.taskId)) {
+      throw new Error(`${label} artifact contains duplicate task id ${JSON.stringify(task.taskId)}.`);
+    }
+    indexed.set(task.taskId, task);
+  }
+  if (indexed.size === 0) {
+    throw new Error(`${label} artifact contains no per-task scores.`);
+  }
+  return indexed;
+}
+function resolveLoComoCategory(task) {
+  if (task.category) {
+    return task.category;
+  }
+  const match = task.taskId.match(LOCOMO_TASK_CATEGORY_PATTERN);
+  if (!match?.[1]) {
+    throw new Error(
+      `Cannot derive a LoCoMo category from task id ${JSON.stringify(task.taskId)}.`
+    );
+  }
+  return match[1];
+}
+function collectMetrics(joined) {
+  const expected = Object.keys(joined[0].baseline.scores).sort();
+  if (expected.length === 0) {
+    throw new Error("Joined tasks contain no metrics.");
+  }
+  for (const task of joined) {
+    for (const [label, scores] of [
+      ["baseline", task.baseline.scores],
+      ["real", task.real.scores]
+    ]) {
+      const actual = Object.keys(scores).sort();
+      if (actual.length !== expected.length || actual.some((metric, index) => metric !== expected[index])) {
+        throw new Error(
+          `Task ${JSON.stringify(task.taskId)} ${label} metric set does not match the joined metric set.`
+        );
+      }
+    }
+  }
+  return expected;
+}
+function summarizeMetrics(tasks, metrics, totalTaskCount) {
+  return Object.fromEntries(metrics.map((metric) => {
+    let baselineSum = 0;
+    let realSum = 0;
+    let wins = 0;
+    let losses = 0;
+    let ties = 0;
+    for (const task of tasks) {
+      const baselineScore = task.baseline.scores[metric];
+      const realScore = task.real.scores[metric];
+      baselineSum += baselineScore;
+      realSum += realScore;
+      if (realScore > baselineScore) wins += 1;
+      else if (realScore < baselineScore) losses += 1;
+      else ties += 1;
+    }
+    const deltaSum = realSum - baselineSum;
+    return [metric, {
+      baselineMean: baselineSum / tasks.length,
+      realMean: realSum / tasks.length,
+      delta: deltaSum / tasks.length,
+      aggregateContribution: deltaSum / totalTaskCount,
+      wins,
+      losses,
+      ties
+    }];
+  }));
+}
+function verifyPublishedMetricMeans(artifact, overall, side) {
+  for (const [metric, summary] of Object.entries(overall)) {
+    const published = artifact.metrics[metric];
+    if (published === void 0) {
+      throw new Error(`${side} artifact does not publish aggregate metric ${JSON.stringify(metric)}.`);
+    }
+    const computed = side === "baseline" ? summary.baselineMean : summary.realMean;
+    if (Math.abs(published - computed) > 1e-12) {
+      throw new Error(
+        `${side} artifact aggregate ${metric}=${published} does not match its per-task mean ${computed}.`
+      );
+    }
+  }
+}
+function compareLoComoCategories(left, right) {
+  const leftIndex = LOCOMO_CATEGORY_ORDER.indexOf(left);
+  const rightIndex = LOCOMO_CATEGORY_ORDER.indexOf(right);
+  if (leftIndex >= 0 && rightIndex >= 0) return leftIndex - rightIndex;
+  if (leftIndex >= 0) return -1;
+  if (rightIndex >= 0) return 1;
+  return left.localeCompare(right);
+}
+function formatScore(value) {
+  return value.toFixed(4);
+}
+function formatSignedScore(value) {
+  return `${value >= 0 ? "+" : ""}${formatScore(value)}`;
+}
+
 // src/integrity/sealed-qrels.ts
 import { readFile as readFile19 } from "fs/promises";
 function isSealedQrelsArtifact(value) {
@@ -36196,6 +38770,8 @@ import { mkdir as mkdir17, readFile as readFile21, rename as rename3, unlink as
 import path36 from "path";
 
 // src/judges/cohen-kappa.ts
+var DEFAULT_KAPPA_BOOTSTRAP_SAMPLES = 2e3;
+var DEFAULT_KAPPA_CONFIDENCE_LEVEL = 0.95;
 function computeCohensKappa(raterA, raterB) {
   if (raterA.length !== raterB.length) {
     throw new Error(
@@ -36241,6 +38817,74 @@ function computeCohensKappa(raterA, raterB) {
     categories: [...categories].sort()
   };
 }
+function bootstrapCohensKappaConfidenceInterval(raterA, raterB, options = {}) {
+  if (raterA.length !== raterB.length) {
+    throw new Error(
+      `bootstrapCohensKappaConfidenceInterval: rater arrays must have equal length; got ${raterA.length} and ${raterB.length}.`
+    );
+  }
+  if (raterA.length === 0) {
+    throw new Error("bootstrapCohensKappaConfidenceInterval: cannot bootstrap zero paired judgements.");
+  }
+  const iterations = options.iterations ?? DEFAULT_KAPPA_BOOTSTRAP_SAMPLES;
+  const level = options.level ?? DEFAULT_KAPPA_CONFIDENCE_LEVEL;
+  if (!Number.isInteger(iterations) || iterations <= 0) {
+    throw new Error(`bootstrapCohensKappaConfidenceInterval: iterations must be a positive integer; got ${String(iterations)}.`);
+  }
+  if (!(level > 0 && level < 1)) {
+    throw new Error(`bootstrapCohensKappaConfidenceInterval: level must be between 0 and 1; got ${String(level)}.`);
+  }
+  const derivedSeed = options.seed ?? hashLabelsToSeed(raterA, raterB);
+  const random = mulberry323(derivedSeed >>> 0);
+  const kappas = [];
+  for (let iteration = 0; iteration < iterations; iteration += 1) {
+    const sampleA = [];
+    const sampleB = [];
+    for (let index = 0; index < raterA.length; index += 1) {
+      const picked = Math.floor(random() * raterA.length);
+      sampleA.push(raterA[picked]);
+      sampleB.push(raterB[picked]);
+    }
+    kappas.push(computeCohensKappa(sampleA, sampleB).kappa);
+  }
+  kappas.sort((left, right) => left - right);
+  const tail = (1 - level) / 2;
+  return {
+    confidenceInterval: {
+      lower: percentile2(kappas, tail),
+      upper: percentile2(kappas, 1 - tail),
+      level
+    },
+    bootstrapSamples: iterations
+  };
+}
+function percentile2(sortedValues, fraction) {
+  const position = (sortedValues.length - 1) * fraction;
+  const lowerIndex = Math.floor(position);
+  const upperIndex = Math.ceil(position);
+  const lower = sortedValues[lowerIndex];
+  const upper = sortedValues[upperIndex];
+  return lowerIndex === upperIndex ? lower : lower + (upper - lower) * (position - lowerIndex);
+}
+function hashLabelsToSeed(raterA, raterB) {
+  const value = JSON.stringify([raterA, raterB]);
+  let hash = 2166136261;
+  for (let index = 0; index < value.length; index += 1) {
+    hash ^= value.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return hash >>> 0;
+}
+function mulberry323(seed) {
+  let state = seed;
+  return () => {
+    state = state + 1831565813 >>> 0;
+    let value = state;
+    value = Math.imul(value ^ value >>> 15, value | 1);
+    value ^= value + Math.imul(value ^ value >>> 7, value | 61);
+    return ((value ^ value >>> 14) >>> 0) / 4294967296;
+  };
+}
 var DEFAULT_JUDGE_BINARIZATION_THRESHOLD = 0.5;
 function binarizeJudgeScore(score, threshold = DEFAULT_JUDGE_BINARIZATION_THRESHOLD) {
   if (typeof score !== "number" || !Number.isFinite(score)) {
@@ -36250,7 +38894,7 @@ function binarizeJudgeScore(score, threshold = DEFAULT_JUDGE_BINARIZATION_THRESH
 }
 
 // src/judges/calibration-slice.ts
-var CALIBRATION_SLICE_SIZE = 50;
+var CALIBRATION_SLICE_SIZE = 200;
 var MIN_CALIBRATION_SOURCE_TASKS = 10;
 var JUDGE_CALIBRATION_KAPPA_THRESHOLD = 0.7;
 function selectCalibrationSlice(questionIds, size = CALIBRATION_SLICE_SIZE) {
@@ -36274,10 +38918,8 @@ async function runJudgeCalibration(options) {
   const binScore = options.binScore ?? ((score) => binarizeJudgeScore(score));
   const threshold = options.threshold ?? JUDGE_CALIBRATION_KAPPA_THRESHOLD;
   const sliceSize = options.sliceSize ?? CALIBRATION_SLICE_SIZE;
-  const sliceIds = selectCalibrationSlice(
-    options.answers.map((answer) => answer.questionId),
-    sliceSize
-  );
+  const availableIds = new Set(options.answers.map((answer) => answer.questionId));
+  const sliceIds = options.pinnedQuestionIds ? validatePinnedQuestionIds(options.pinnedQuestionIds, availableIds) : selectCalibrationSlice([...availableIds], sliceSize);
   const sliceIdSet = new Set(sliceIds);
   const answerById = /* @__PURE__ */ new Map();
   for (const answer of options.answers) {
@@ -36286,6 +38928,12 @@ async function runJudgeCalibration(options) {
     }
   }
   const sliceAnswers = sliceIds.map((id) => answerById.get(id)).filter((answer) => answer !== void 0);
+  const answerSetHash = hashCalibrationAnswerSet(sliceAnswers);
+  if (options.expectedAnswerSetHash !== void 0 && answerSetHash !== options.expectedAnswerSetHash) {
+    throw new Error(
+      `runJudgeCalibration: pinned answer set changed (expected sha256:${options.expectedAnswerSetHash}, got sha256:${answerSetHash}). Restore the original stored result or intentionally reset calibration state.`
+    );
+  }
   const localLabels = [];
   const frontierLabels = [];
   const verdicts = [];
@@ -36311,6 +38959,10 @@ async function runJudgeCalibration(options) {
     });
   }
   const kappaResult = computeCohensKappa(localLabels, frontierLabels);
+  const bootstrap = bootstrapCohensKappaConfidenceInterval(localLabels, frontierLabels, {
+    iterations: options.bootstrapSamples ?? DEFAULT_KAPPA_BOOTSTRAP_SAMPLES,
+    level: options.confidenceLevel
+  });
   const warning = kappaResult.kappa < threshold;
   return {
     ...kappaResult,
@@ -36318,16 +38970,42 @@ async function runJudgeCalibration(options) {
     sliceQuestionIds: sliceIds,
     threshold,
     warning,
+    confidenceInterval: bootstrap.confidenceInterval,
+    bootstrapSamples: bootstrap.bootstrapSamples,
+    answerSetHash,
     verdicts
   };
 }
-async function writeJudgeCalibrationState(result, calibrationDir, identities) {
+function validatePinnedQuestionIds(ids, availableIds) {
+  if (ids.length === 0 || ids.length > CALIBRATION_SLICE_SIZE || ids.some((id) => typeof id !== "string" || id.length === 0) || new Set(ids).size !== ids.length) {
+    throw new Error(`runJudgeCalibration: pinned question ids must contain 1 to ${CALIBRATION_SLICE_SIZE} unique non-empty strings.`);
+  }
+  const missing = ids.filter((id) => !availableIds.has(id));
+  if (missing.length > 0) {
+    throw new Error(`runJudgeCalibration: pinned answer set is missing ${missing.length} question id(s), including "${missing[0]}".`);
+  }
+  return [...ids];
+}
+function hashCalibrationAnswerSet(answers) {
+  return createHash12("sha256").update(JSON.stringify(answers.map((answer) => [
+    answer.questionId,
+    answer.question,
+    answer.predicted,
+    answer.expected
+  ]))).digest("hex");
+}
+async function writeJudgeCalibrationState(result, calibrationDir, identities, provenance) {
   await mkdir17(calibrationDir, { recursive: true });
   const state = {
     kappa: result.kappa,
     sampleSize: result.sampleSize,
     threshold: result.threshold,
     warning: result.warning,
+    confidenceInterval: result.confidenceInterval,
+    bootstrapSamples: result.bootstrapSamples,
+    answerSetHash: result.answerSetHash,
+    sliceQuestionIds: result.sliceQuestionIds,
+    ...provenance ? provenance : {},
     ...identities ? identities : {}
   };
   const filePath = path36.join(calibrationDir, `${sanitizeCalibrationSegment(result.benchmarkId)}.json`);
@@ -36368,6 +39046,19 @@ async function loadJudgeCalibrationState(benchmarkId, calibrationDir) {
     return void 0;
   }
   const loaded = { kappa, sampleSize, threshold, warning };
+  const confidenceInterval = record.confidenceInterval;
+  const bootstrapSamples = record.bootstrapSamples;
+  if (confidenceInterval && typeof confidenceInterval === "object" && !Array.isArray(confidenceInterval) && typeof confidenceInterval.lower === "number" && Number.isFinite(confidenceInterval.lower) && typeof confidenceInterval.upper === "number" && Number.isFinite(confidenceInterval.upper) && typeof confidenceInterval.level === "number" && Number.isFinite(confidenceInterval.level) && typeof bootstrapSamples === "number" && Number.isInteger(bootstrapSamples) && bootstrapSamples > 0) {
+    loaded.confidenceInterval = confidenceInterval;
+    loaded.bootstrapSamples = bootstrapSamples;
+  }
+  const sourceResultId = record.sourceResultId;
+  const answerSetHash = record.answerSetHash;
+  if (typeof sourceResultId === "string" && sourceResultId.length > 0 && typeof answerSetHash === "string" && /^[0-9a-f]{64}$/.test(answerSetHash) && Array.isArray(record.sliceQuestionIds) && record.sliceQuestionIds.length > 0 && record.sliceQuestionIds.length <= CALIBRATION_SLICE_SIZE && record.sliceQuestionIds.length === sampleSize && record.sliceQuestionIds.every((id) => typeof id === "string" && id.length > 0) && new Set(record.sliceQuestionIds).size === record.sliceQuestionIds.length) {
+    loaded.sourceResultId = sourceResultId;
+    loaded.answerSetHash = answerSetHash;
+    loaded.sliceQuestionIds = record.sliceQuestionIds;
+  }
   const identityKeys = [
     "localJudgeProvider",
     "localJudgeModel",
@@ -37916,7 +40607,7 @@ function captureMachineFingerprint() {
     totalMemoryMb: Math.round(os11.totalmem() / (1024 * 1024))
   };
 }
-function percentile2(sorted, p) {
+function percentile3(sorted, p) {
   if (sorted.length === 0) return 0;
   if (sorted.length === 1) return sorted[0];
   const idx = Math.ceil(p / 100 * sorted.length) - 1;
@@ -37925,8 +40616,8 @@ function percentile2(sorted, p) {
 function computeMicroMetric(samplesMs) {
   const sorted = [...samplesMs].sort((a, b) => a - b);
   return {
-    p50: percentile2(sorted, 50),
-    p95: percentile2(sorted, 95),
+    p50: percentile3(sorted, 50),
+    p95: percentile3(sorted, 95),
     iterations: samplesMs.length,
     samplesMs
   };
@@ -37993,7 +40684,7 @@ async function runCodingGraphBenchmark(config = {}) {
         fullIndexSamples.push(fi.ms);
         if (sampleStore !== store) await sampleStore.close();
       }
-      const fullIndexMsValue = percentile2(
+      const fullIndexMsValue = percentile3(
         [...fullIndexSamples].sort((a, b) => a - b),
         50
       );
@@ -38338,7 +41029,11 @@ export {
   DEFAULT_ASSISTANT_RUBRIC_ID,
   DEFAULT_BASELINE_SCENARIOS,
   DEFAULT_JUDGE_BINARIZATION_THRESHOLD,
+  DEFAULT_KAPPA_BOOTSTRAP_SAMPLES,
+  DEFAULT_KAPPA_CONFIDENCE_LEVEL,
+  DEFAULT_OPENAI_RESPONSES_JUDGE_MODEL,
   EMPTY_CONTAMINATION_MANIFEST,
+  GENERAL_ANSWER_JUDGE_RUBRIC,
   INTEGRITY_CIPHER_ALGORITHM,
   INTEGRITY_HASH_ALGORITHM,
   INTEGRITY_META_FIELDS,
@@ -38348,13 +41043,21 @@ export {
   LONG_MEM_EVAL_DATASET_FILENAMES,
   LettaMemCorrectAdapter,
   LocalLabPreflightError,
+  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,
+  McpMemoryBackendError,
   Mem0MemCorrectAdapter,
   MissingCredentialError,
+  OPENAI_RESPONSES_JUDGE_RUBRIC_VERSION,
   OTHER_NAMESPACE_MEMORIES,
+  OpenAiResponsesJudgeError,
+  OpenAiResponsesProvider,
   PROCEDURAL_REAL_SCENARIOS,
   PROCEDURAL_REAL_SCENARIOS_SMOKE,
   PUBLISHED_BENCHMARK_ARTIFACT_IDS,
@@ -38378,6 +41081,7 @@ export {
   assistantSynthesisDefinition,
   backlinkF1,
   binarizeJudgeScore,
+  bootstrapCohensKappaConfidenceInterval,
   bootstrapMeanConfidenceInterval,
   buildAmaBenchDiagnosticMatrixArtifact,
   buildAmaBenchDiagnosticVariantSummary,
@@ -38417,9 +41121,15 @@ export {
   createLightweightAdapter,
   createLiteLlmProvider,
   createLocalLlmProvider,
+  createMcpDemoMemCorrectAdapter,
+  createMcpDemoMemoryAdapter,
+  createMcpMemCorrectAdapter,
+  createMcpMemoryAdapter,
   createMitigatedTarget,
   createOllamaProvider,
   createOpenAiCompatibleProvider,
+  createOpenAiResponsesBenchJudge,
+  createOpenAiResponsesProvider,
   createSeededRandom as createProceduralAblationSeededRandom,
   createProvider,
   createProviderBackedAmaBenchRecommendedJudge,
@@ -38437,6 +41147,7 @@ export {
   defaultBenchmarkBaselineDir,
   defaultBenchmarkPublishPath,
   deleteBenchmarkResults,
+  diagnoseLoComoProfileDelta,
   discoverAllProviders,
   discoveryEndpointFor,
   emailFixture,
@@ -38466,6 +41177,8 @@ export {
   isContaminationManifest,
   isSealedQrelsArtifact,
   isSha256Hex,
+  judgeMemCorrectCorrectionAcceptance,
+  judgeMemCorrectStaleMemoryHarm,
   linkMatches,
   listBenchmarkBaselines,
   listBenchmarkResults,
@@ -38479,6 +41192,7 @@ export {
   loadBeamDatasetPreview,
   loadBenchmarkArtifact,
   loadBenchmarkBaseline,
+  loadBenchmarkReportCardProvenance,
   loadBenchmarkResult,
   loadCustomBenchmarkFile,
   loadJudgeCalibrationState,
@@ -38506,6 +41220,7 @@ export {
   redactBenchmarkResultSecrets,
   renderBaselineMarkdown,
   renderBenchmarkResultExport,
+  renderLoComoProfileDeltaMarkdown,
   renderMemorySummaryForJudge,
   renderMemoryViewForAgent,
   resolveAssistantAgent,