@remnic/bench 9.45.3 → 9.45.4

package/dist/index.js

@@ -1977,6 +1977,63 @@ function isProviderConfigLike(value) {
   }
   return isObjectRecord(value) && typeof value.provider === "string" && typeof value.model === "string";
 }
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function isNonNegativeInteger(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+function isUniqueMemoryIdList(value) {
+  if (value === null) return true;
+  if (!Array.isArray(value)) return false;
+  const ids = /* @__PURE__ */ new Set();
+  for (const id of value) {
+    if (!isNonEmptyString(id) || ids.has(id)) return false;
+    ids.add(id);
+  }
+  return true;
+}
+function isTaskAttributionWitnessLike(value, goldMemories) {
+  if (!isObjectRecord(value) || value.schemaVersion !== 1) {
+    return false;
+  }
+  const runtime = value.runtime;
+  if (!isObjectRecord(runtime) || !isNonEmptyString(runtime.qmdCollection) || !isNonEmptyString(runtime.qmdIndex) || !isNonNegativeInteger(runtime.qmdMaxResults) || typeof runtime.attributionThreshold !== "number" || !Number.isFinite(runtime.attributionThreshold) || runtime.attributionThreshold < 0 || runtime.attributionThreshold > 1) {
+    return false;
+  }
+  if (!Array.isArray(value.golds) || goldMemories !== void 0 && value.golds.length !== goldMemories.length) {
+    return false;
+  }
+  for (let index = 0; index < value.golds.length; index += 1) {
+    const gold = value.golds[index];
+    if (!isObjectRecord(gold) || !isNonEmptyString(gold.goldMemory) || goldMemories !== void 0 && gold.goldMemory !== goldMemories[index] || !isUniqueMemoryIdList(gold.storeMemoryIds) || !isUniqueMemoryIdList(gold.oracleMemoryIds)) {
+      return false;
+    }
+  }
+  if (!Array.isArray(value.retrievals)) {
+    return false;
+  }
+  const sessionIds = /* @__PURE__ */ new Set();
+  for (const retrieval of value.retrievals) {
+    if (!isObjectRecord(retrieval) || !isNonEmptyString(retrieval.sessionId) || sessionIds.has(retrieval.sessionId) || !(retrieval.appliedCap === null || isNonNegativeInteger(retrieval.appliedCap)) || !isUniqueMemoryIdList(retrieval.atCapMemoryIds) || !isUniqueMemoryIdList(retrieval.headroomMemoryIds)) {
+      return false;
+    }
+    sessionIds.add(retrieval.sessionId);
+    const appliedCap = retrieval.appliedCap;
+    const atCapIds = retrieval.atCapMemoryIds;
+    const headroomIds = retrieval.headroomMemoryIds;
+    if (appliedCap === null && (atCapIds !== null || headroomIds !== null) || appliedCap !== null && atCapIds !== null && atCapIds.length > appliedCap || appliedCap !== null && atCapIds !== null && atCapIds.length < appliedCap && headroomIds === null || appliedCap !== null && headroomIds !== null && headroomIds.length > 0 && (atCapIds === null || atCapIds.length !== appliedCap)) {
+      return false;
+    }
+    if (atCapIds !== null && headroomIds !== null) {
+      const atCapSet = new Set(atCapIds);
+      if (headroomIds.some((id) => atCapSet.has(id))) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
 function isBenchmarkResult(value) {
   if (!isObjectRecord(value)) {
     return false;
@@ -2013,6 +2070,9 @@ function isTaskResultLike(value) {
   if (goldMemories !== void 0 && (!Array.isArray(goldMemories) || !goldMemories.every((item) => typeof item === "string"))) {
     return false;
   }
+  if (value.attributionWitness !== void 0 && !isTaskAttributionWitnessLike(value.attributionWitness, goldMemories)) {
+    return false;
+  }
   return typeof value.taskId === "string" && typeof value.question === "string" && typeof value.expected === "string" && typeof value.actual === "string" && isObjectRecord(value.scores) && Object.values(value.scores).every(isFiniteNumber) && isFiniteNumber(value.latencyMs) && isObjectRecord(tokens) && isFiniteNumber(tokens.input) && isFiniteNumber(tokens.output);
 }
 function isStoredBenchmarkBaseline(value) {
@@ -5587,7 +5647,8 @@ import {
   parseConfig,
   parseEntityFile,
   serializeEntityFile,
-  StorageManager
+  StorageManager,
+  withRawEntityPageMutation
 } from "@remnic/core";
 
 // src/adapters/with-bench-core-memory-source.ts
@@ -5625,344 +5686,1132 @@ async function withBenchCoreMemorySource(orchestrator, source, task) {
   }
 }
 
-// src/adapters/remnic-adapter.ts
-import {
-  lcmEvidenceIdentity
-} from "@remnic/core/lcm";
-
-// src/adapters/remnic-recall-trace.ts
-import { createHash as createHash6 } from "crypto";
-import {
-  lcmArchiveRowId
-} from "@remnic/core/lcm";
-function visibleRange(start, end, returnedChars) {
-  const visibleStart = Math.min(start, returnedChars);
-  return {
-    visibleStart,
-    visibleEnd: Math.max(visibleStart, Math.min(end, returnedChars))
-  };
-}
-function projectBenchCoreCapture(snapshot) {
-  return {
-    snapshotId: snapshot.snapshotId,
-    capturedAt: snapshot.capturedAt,
-    ...snapshot.traceId === void 0 ? {} : { traceId: snapshot.traceId },
-    budget: { chars: snapshot.budget.chars, used: snapshot.budget.used },
-    filters: snapshot.filters.map(({ name, considered, admitted }) => ({
-      name,
-      considered,
-      admitted
-    })),
-    results: snapshot.results.map((result) => {
-      const scores = result.scoreDecomposition;
-      return {
-        memoryIdRef: {
-          sha256: createHash6("sha256").update(result.memoryId, "utf8").digest("hex"),
-          length: Buffer.byteLength(result.memoryId, "utf8")
-        },
-        servedBy: result.servedBy,
-        scoreDecomposition: {
-          ...typeof scores.vector === "number" ? { vector: scores.vector } : {},
-          ...typeof scores.bm25 === "number" ? { bm25: scores.bm25 } : {},
-          ...typeof scores.importance === "number" ? { importance: scores.importance } : {},
-          ...typeof scores.mmrPenalty === "number" ? { mmrPenalty: scores.mmrPenalty } : {},
-          ...typeof scores.tierPrior === "number" ? { tierPrior: scores.tierPrior } : {},
-          ...typeof scores.reinforcementBoost === "number" ? { reinforcementBoost: scores.reinforcementBoost } : {},
-          final: scores.final
-        },
-        admittedBy: [...result.admittedBy],
-        ...result.rejectedBy === void 0 ? {} : { rejectedBy: result.rejectedBy },
-        ...result.disclosure === void 0 ? {} : { disclosure: result.disclosure },
-        ...result.estimatedTokens === void 0 ? {} : { estimatedTokens: result.estimatedTokens }
-      };
-    })
-  };
-}
-function createBenchRecallTraceRecorder(requestedChars) {
-  const sections = [];
-  const pendingSelections = [];
-  const lcmCandidates = [];
-  let composedChars = 0;
-  let coreCapture;
-  const sectionById = (sectionId) => {
-    const section = sections.find((entry) => entry.id === sectionId);
-    if (!section) throw new Error(`Unknown benchmark recall trace section: ${sectionId}`);
-    return section;
-  };
-  const appendRelativeSelection = (sectionId, kind, start, end, lineageStatus, fields = {}) => {
-    const section = sectionById(sectionId);
-    const contentLength = section.contentEnd - section.contentStart;
-    if (!Number.isSafeInteger(start) || !Number.isSafeInteger(end) || start < 0 || end < start || end > contentLength) {
-      throw new Error(
-        `Invalid benchmark recall trace range for ${sectionId}: ${start}..${end}.`
-      );
-    }
-    pendingSelections.push({
-      sectionId,
-      kind,
-      lineageStatus,
-      composedStart: section.contentStart + start,
-      composedEnd: section.contentStart + end,
-      ...fields
-    });
-  };
-  return {
-    appendSection(id, source, renderedLength) {
-      if (!Number.isSafeInteger(renderedLength) || renderedLength < 0) {
-        throw new Error("Benchmark recall trace section length must be a non-negative integer.");
-      }
-      if (sections.some((section) => section.id === id)) {
-        throw new Error(`Duplicate benchmark recall trace section: ${id}`);
-      }
-      const separatorStart = composedChars;
-      const contentStart = composedChars + (sections.length === 0 ? 0 : 2);
-      const contentEnd = contentStart + renderedLength;
-      sections.push({
-        id,
-        source,
-        separatorStart,
-        contentStart,
-        contentEnd,
-        composedStart: separatorStart,
-        composedEnd: contentEnd,
-        visibleStart: 0,
-        visibleEnd: 0,
-        visibleChars: 0
-      });
-      composedChars = contentEnd;
-    },
-    recordEvidenceSelections(sectionId, receipts) {
-      for (const receipt of receipts) {
-        appendRelativeSelection(
-          sectionId,
-          "evidence-block",
-          receipt.blockStart,
-          receipt.blockEnd,
-          receipt.item.archiveRowId === void 0 ? "unavailable" : "exact",
-          {
-            ...receipt.item.archiveRowId === void 0 ? {} : { archiveRowIds: [receipt.item.archiveRowId] },
-            ...receipt.item.turnIndex === void 0 ? {} : { turnIndex: receipt.item.turnIndex },
-            ...receipt.item.role === void 0 ? {} : { role: receipt.item.role },
-            ...receipt.item.score === void 0 ? {} : { score: receipt.item.score }
-          }
-        );
-      }
-    },
-    recordTrajectorySelections(sectionId, receipts) {
-      for (const receipt of receipts) {
-        appendRelativeSelection(
-          sectionId,
-          "trajectory-line",
-          receipt.lineStart,
-          receipt.lineEnd,
-          receipt.lineageStatus,
-          {
-            archiveRowIds: [
-              ...receipt.actionArchiveRowIds,
-              ...receipt.observationArchiveRowIds
-            ]
-          }
-        );
-      }
-    },
-    recordSummarySelections(sectionId, receipts) {
-      for (const receipt of receipts) {
-        appendRelativeSelection(
-          sectionId,
-          "lcm-summary",
-          receipt.entryStart,
-          receipt.entryEnd,
-          "exact",
-          {
-            summary: {
-              id: receipt.id,
-              depth: receipt.depth,
-              msgStart: receipt.msgStart,
-              msgEnd: receipt.msgEnd
-            }
-          }
-        );
-      }
-    },
-    recordRawRow(sectionId, range, row) {
-      const archiveRowId = lcmArchiveRowId(row);
-      appendRelativeSelection(
-        sectionId,
-        "raw-row",
-        range.start,
-        range.end,
-        archiveRowId === void 0 ? "unavailable" : "exact",
-        {
-          ...archiveRowId === void 0 ? {} : { archiveRowIds: [archiveRowId] },
-          turnIndex: row.turn_index,
-          role: row.role
-        }
-      );
-    },
-    recordLcmCandidate(candidate) {
-      lcmCandidates.push({ ...candidate });
-    },
-    recordCoreCapture(snapshot) {
-      coreCapture = snapshot ? projectBenchCoreCapture(snapshot) : void 0;
-    },
-    finalize(returnedChars) {
-      const normalizedReturnedChars = Math.max(0, Math.min(returnedChars, composedChars));
-      return {
-        schemaVersion: 1,
-        sensitivity: {
-          classification: "restricted",
-          contentEncoding: "sha256+length",
-          containsGold: false
-        },
-        sections: sections.map((section) => {
-          const visible = visibleRange(
-            section.composedStart,
-            section.composedEnd,
-            normalizedReturnedChars
-          );
-          return {
-            ...section,
-            ...visible,
-            visibleChars: visible.visibleEnd - visible.visibleStart
-          };
-        }),
-        selections: pendingSelections.map((selection) => ({
-          ...selection,
-          ...visibleRange(
-            selection.composedStart,
-            selection.composedEnd,
-            normalizedReturnedChars
-          )
-        })),
-        lcmCandidates: lcmCandidates.map((candidate) => ({ ...candidate })),
-        ...coreCapture === void 0 ? {} : { coreCapture },
-        budget: {
-          requestedChars,
-          composedChars,
-          returnedChars: normalizedReturnedChars,
-          truncated: normalizedReturnedChars < composedChars
-        }
-      };
-    }
-  };
-}
-
-// src/recall-budget.ts
-var DEFAULT_BENCH_RECALL_BUDGET_CHARS = 24e3;
-var MAX_COMBINED_RECALL_BUDGET_CHARS = 36e3;
-function benchmarkRecallBudgetForSessionCount(sessionCount) {
-  if (!Number.isInteger(sessionCount) || sessionCount <= 0) {
-    return DEFAULT_BENCH_RECALL_BUDGET_CHARS;
-  }
-  if (sessionCount === 1) {
-    return DEFAULT_BENCH_RECALL_BUDGET_CHARS;
-  }
-  return Math.floor(MAX_COMBINED_RECALL_BUDGET_CHARS / 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",
+// src/attribution.ts
+var DEFAULT_ATTRIBUTION_THRESHOLD = 0.6;
+var DEFAULT_STOPWORDS = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "the",
+  "in",
+  "on",
+  "at",
+  "to",
+  "for",
+  "of",
+  "with",
+  "by",
   "from",
-  "have",
-  "information",
+  "up",
+  "about",
   "into",
-  "just",
-  "know",
-  "memory",
-  "might",
-  "please",
-  "question",
-  "recall",
-  "remember",
-  "should",
+  "through",
+  "during",
+  "before",
+  "after",
+  "above",
+  "below",
+  "and",
+  "or",
+  "but",
+  "if",
+  "then",
+  "else",
+  "when",
+  "where",
+  "why",
+  "how",
+  "all",
+  "any",
+  "both",
+  "each",
+  "few",
+  "more",
+  "most",
+  "other",
+  "some",
+  "such",
+  "no",
+  "nor",
+  "not",
+  "only",
+  "own",
+  "same",
+  "so",
+  "than",
+  "too",
+  "very",
+  "this",
   "that",
-  "their",
-  "there",
   "these",
-  "they",
-  "this",
   "those",
-  "user",
-  "using",
-  "what",
-  "when",
-  "where",
-  "which",
-  "while",
-  "with",
-  "would",
-  "your"
+  "it",
+  "its",
+  "is",
+  "are",
+  "was",
+  "were",
+  "be",
+  "been",
+  "being",
+  "have",
+  "has",
+  "had",
+  "do",
+  "does",
+  "did"
 ]);
-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.");
+function extractContentWords(text) {
+  const cleaned = text.toLowerCase().replace(/[^a-z0-9\s]/g, " ");
+  const tokens = cleaned.split(/\s+/).filter(Boolean);
+  return tokens.filter((t) => !DEFAULT_STOPWORDS.has(t));
+}
+function lexicalSimilarity(a, b) {
+  const goldWords = extractContentWords(a);
+  if (goldWords.length === 0) {
+    return 0;
   }
-  return parsed;
+  const candWords = new Set(extractContentWords(b));
+  let matchCount = 0;
+  for (const word of goldWords) {
+    if (candWords.has(word)) {
+      matchCount++;
+    }
+  }
+  return matchCount / goldWords.length;
 }
-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;
+var CLASS_RANK = {
+  extraction_miss: 1,
+  index_miss: 2,
+  retrieval_miss: 3,
+  use_miss: 4,
+  unattributed: 5
+};
+var RETRIEVAL_STAGE_RANK = {
+  cap: 1,
+  rank: 2,
+  filter: 3,
+  unknown: 4
+};
+function computeOverallLabel(golds) {
+  if (golds.length === 0) {
+    return { class: "unattributed", reason: "no gold memories" };
   }
-  throw new Error(
-    "skipExtractionLcmFirst must be a boolean or one of true/false, 1/0, yes/no, on/off."
-  );
+  let bestGold = golds[0];
+  for (let i = 1; i < golds.length; i++) {
+    const current = golds[i];
+    const bestRank = CLASS_RANK[bestGold.label.class];
+    const currRank = CLASS_RANK[current.label.class];
+    if (currRank < bestRank) {
+      bestGold = current;
+    } else if (currRank === bestRank && current.label.class === "retrieval_miss") {
+      const bestRetRank = RETRIEVAL_STAGE_RANK[bestGold.label.retrievalStage ?? "unknown"];
+      const currRetRank = RETRIEVAL_STAGE_RANK[current.label.retrievalStage ?? "unknown"];
+      if (currRetRank < bestRetRank) {
+        bestGold = current;
+      }
+    }
+  }
+  return { ...bestGold.label };
 }
-function shouldIncludeCoreRecallForReplay(options) {
-  return options.useCoreMemoryPipeline && (options.replayExtractionMode !== "skip" || !options.skipExtractionLcmFirst);
+function isDiagnosticScore(name) {
+  return name.endsWith("_agreement") || name.includes("_id_leak") || name === "search_hits";
 }
-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;
+function isTaskFailed(task) {
+  if (!task.scores || Object.keys(task.scores).length === 0) {
+    return true;
   }
-  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))
-  )];
+  if ("overall" in task.scores && typeof task.scores.overall === "number") {
+    return task.scores.overall < 1;
+  }
+  const primaryScores = Object.entries(task.scores).filter(([name, score]) => typeof score === "number" && !isDiagnosticScore(name)).map(([, score]) => score);
+  return primaryScores.length === 0 || Math.min(...primaryScores) < 1;
 }
-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 withMemoizedListMemories(env) {
+  let cache = null;
+  return {
+    ...env,
+    listMemories() {
+      if (!cache) {
+        cache = env.listMemories();
+      }
+      return cache;
+    }
+  };
 }
-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 };
+async function attributeGoldMemory(goldStatement, question, env, options = {}, recalledText) {
+  if (options.threshold !== void 0) {
+    if (typeof options.threshold !== "number" || !Number.isFinite(options.threshold) || options.threshold < 0 || options.threshold > 1) {
+      throw new RangeError("attribution threshold must be a finite number between 0 and 1");
+    }
   }
-  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 threshold = options.threshold ?? DEFAULT_ATTRIBUTION_THRESHOLD;
+  const simFn = options.similarity ?? lexicalSimilarity;
+  const goldInRecalledText = typeof recalledText === "string" && simFn(goldStatement, recalledText) >= threshold;
+  const stages = {
+    extraction: { status: "unavailable" },
+    index: { status: "unavailable" },
+    retrieval: { status: "unavailable" },
+    use: { status: "unavailable" }
+  };
+  let memories = [];
+  let extractionRan = false;
+  let extractionErrorDetail;
+  if (typeof env.listMemories === "function") {
+    try {
+      memories = await env.listMemories();
+      extractionRan = true;
+    } catch {
+      extractionRan = false;
+      extractionErrorDetail = "listMemories failed";
+    }
   }
-  const evidenceLines = exactContextEvidenceLines(request.recalledText);
-  const evidenceTermSets = evidenceLines.map((line) => new Set(supportTerms(line)));
-  const matchedTerms = queryTerms.filter(
+  let bestSim = -1;
+  let matchedMem = null;
+  if (extractionRan) {
+    if (memories.length === 0) {
+      if (goldInRecalledText) {
+        const impliedDetail = "implied pass from recalled context (post-hoc store scan missed)";
+        stages.extraction = { status: "pass", detail: impliedDetail };
+        stages.index = { status: "pass", detail: impliedDetail };
+        stages.retrieval = { status: "pass", detail: impliedDetail };
+        stages.use = {
+          status: "fail",
+          detail: "Gold memory present in context but answer was incorrect"
+        };
+        return {
+          goldMemory: goldStatement,
+          label: { class: "use_miss", reason: "Gold memory present in context but task failed" },
+          stages
+        };
+      }
+      const detail = "store contains no memories";
+      stages.extraction = { status: "fail", detail };
+      stages.index = { status: "unavailable", detail: "not reached" };
+      stages.retrieval = { status: "unavailable", detail: "not reached" };
+      stages.use = { status: "unavailable", detail: "not reached" };
+      return {
+        goldMemory: goldStatement,
+        label: { class: "extraction_miss", reason: detail },
+        stages
+      };
+    }
+    for (const mem of memories) {
+      const sim = simFn(goldStatement, mem.content);
+      if (sim > bestSim) {
+        bestSim = sim;
+        matchedMem = mem;
+      }
+    }
+    if (bestSim < threshold || !matchedMem) {
+      if (goldInRecalledText) {
+        const impliedDetail = "implied pass from recalled context (post-hoc store scan missed)";
+        stages.extraction = { status: "pass", detail: impliedDetail };
+        stages.index = { status: "pass", detail: impliedDetail };
+        stages.retrieval = { status: "pass", detail: impliedDetail };
+        stages.use = {
+          status: "fail",
+          detail: "Gold memory present in context but answer was incorrect"
+        };
+        return {
+          goldMemory: goldStatement,
+          label: { class: "use_miss", reason: "Gold memory present in context but task failed" },
+          stages
+        };
+      }
+      const detail = `Best similarity ${bestSim >= 0 ? bestSim.toFixed(3) : 0} below threshold ${threshold}`;
+      stages.extraction = { status: "fail", detail };
+      stages.index = { status: "unavailable", detail: "not reached" };
+      stages.retrieval = { status: "unavailable", detail: "not reached" };
+      stages.use = { status: "unavailable", detail: "not reached" };
+      return {
+        goldMemory: goldStatement,
+        label: { class: "extraction_miss", reason: detail },
+        stages
+      };
+    }
+    stages.extraction = {
+      status: "pass",
+      detail: `Matched memory ${matchedMem.id} (sim ${bestSim.toFixed(3)})`
+    };
+  } else {
+    stages.extraction = {
+      status: "unavailable",
+      detail: extractionErrorDetail ?? "listMemories unavailable"
+    };
+  }
+  const matchedMemoryId = matchedMem ? matchedMem.id : void 0;
+  const recallLimit = env.recallLimit;
+  const replayLimit = env.replayLimit ?? Math.max(25, recallLimit * 5);
+  let indexCheckPassed = false;
+  let indexCheckFailed = false;
+  if (typeof env.oracleSearch === "function" && extractionRan) {
+    try {
+      const oracleResults = await env.oracleSearch(goldStatement, replayLimit);
+      const idMatched = matchedMemoryId ? oracleResults.some((r) => r.id === matchedMemoryId) : false;
+      if (idMatched) {
+        indexCheckPassed = true;
+      } else {
+        const memMap = new Map(memories.map((m) => [m.id, m]));
+        indexCheckPassed = oracleResults.some((r) => {
+          const mem = memMap.get(r.id);
+          return mem ? simFn(goldStatement, mem.content) >= threshold : false;
+        });
+      }
+      if (indexCheckPassed) {
+        stages.index = { status: "pass", detail: "Found in oracle search" };
+      } else {
+        indexCheckFailed = true;
+        stages.index = { status: "fail", detail: "Not found in oracle search" };
+      }
+    } catch {
+      stages.index = { status: "unavailable", detail: "oracleSearch threw error" };
+    }
+  } else if (typeof env.oracleSearch === "function") {
+    stages.index = {
+      status: "unavailable",
+      detail: "extraction check unavailable; oracle result would be ambiguous"
+    };
+  } else {
+    stages.index = { status: "unavailable", detail: "index check unavailable" };
+  }
+  let retrievalCheckPassed = false;
+  let retrievalStageMiss = void 0;
+  if (typeof env.recall === "function") {
+    try {
+      const recallResults = await env.recall(question, recallLimit);
+      const isGoldInRecall = recallResults.some(
+        (m) => matchedMemoryId && m.id === matchedMemoryId || simFn(goldStatement, m.content) >= threshold
+      );
+      if (isGoldInRecall) {
+        retrievalCheckPassed = true;
+        stages.retrieval = { status: "pass", detail: `Recalled within recallLimit ${recallLimit}` };
+      } else {
+        const replayResults = await env.recall(question, replayLimit);
+        const replayIndex = replayResults.findIndex(
+          (m) => matchedMemoryId && m.id === matchedMemoryId || simFn(goldStatement, m.content) >= threshold
+        );
+        if (replayIndex >= 0) {
+          const rank = replayIndex + 1;
+          retrievalStageMiss = "cap";
+          stages.retrieval = {
+            status: "fail",
+            detail: `Rank ${rank} exceeds recallLimit ${recallLimit}`
+          };
+        } else {
+          retrievalStageMiss = "unknown";
+          stages.retrieval = {
+            status: "fail",
+            detail: `absent from recall at replayLimit ${replayLimit}; filter vs rank indistinguishable without candidate-stage evidence`
+          };
+        }
+      }
+    } catch {
+      stages.retrieval = { status: "unavailable", detail: "recall threw error" };
+    }
+  } else {
+    stages.retrieval = { status: "unavailable", detail: "retrieval check unavailable" };
+  }
+  if (!retrievalCheckPassed && goldInRecalledText) {
+    retrievalCheckPassed = true;
+    stages.retrieval = { status: "pass", detail: "Found in recalledText context" };
+  }
+  if (retrievalCheckPassed) {
+    if (indexCheckFailed) {
+      stages.index = { status: "pass", detail: "implied pass from retrieval (oracle query missed)" };
+      indexCheckPassed = true;
+    } else if (stages.index.status === "unavailable") {
+      stages.index = { status: "pass", detail: "implied pass from retrieval" };
+      indexCheckPassed = true;
+    }
+  }
+  if (retrievalCheckPassed) {
+    stages.use = {
+      status: "fail",
+      detail: "Gold memory present in context but answer was incorrect"
+    };
+    return {
+      goldMemory: goldStatement,
+      label: { class: "use_miss", reason: "Gold memory present in context but task failed" },
+      stages
+    };
+  }
+  if (stages.extraction.status === "pass" && indexCheckFailed) {
+    stages.use = { status: "unavailable", detail: "not reached" };
+    return {
+      goldMemory: goldStatement,
+      label: { class: "index_miss", reason: "Gold statement missing from search index" },
+      stages
+    };
+  }
+  if (stages.extraction.status === "pass" && stages.index.status === "pass" && stages.retrieval.status === "fail") {
+    stages.use = { status: "unavailable", detail: "not reached" };
+    return {
+      goldMemory: goldStatement,
+      label: {
+        class: "retrieval_miss",
+        retrievalStage: retrievalStageMiss ?? "unknown",
+        reason: stages.retrieval.detail
+      },
+      stages
+    };
+  }
+  const missingReason = stages.extraction.status === "unavailable" ? `extraction check unavailable (${stages.extraction.detail})` : stages.index.status === "unavailable" && stages.retrieval.status === "unavailable" ? "index/retrieval checks unavailable in this attribution environment" : stages.index.status === "unavailable" ? "index check unavailable; a retrieval miss cannot be isolated from an index miss" : "retrieval check unavailable";
+  stages.use = { status: "unavailable", detail: "not reached" };
+  return {
+    goldMemory: goldStatement,
+    label: { class: "unattributed", reason: missingReason },
+    stages
+  };
+}
+function attributeGoldMemoryFromWitness(goldStatement, goldWitness, retrievals, witnessThreshold, options, recalledText) {
+  const threshold = options.threshold ?? DEFAULT_ATTRIBUTION_THRESHOLD;
+  if (!Number.isFinite(threshold) || threshold < 0 || threshold > 1) {
+    throw new RangeError("attribution threshold must be a finite number between 0 and 1");
+  }
+  const similarity = options.similarity ?? lexicalSimilarity;
+  const stages = {
+    extraction: { status: "unavailable" },
+    index: { status: "unavailable" },
+    retrieval: { status: "unavailable" },
+    use: { status: "unavailable" }
+  };
+  if (typeof recalledText === "string" && similarity(goldStatement, recalledText) >= threshold) {
+    const detail = "implied pass from recalled context";
+    stages.extraction = { status: "pass", detail };
+    stages.index = { status: "pass", detail };
+    stages.retrieval = { status: "pass", detail: "Found in recalledText context" };
+    stages.use = { status: "fail", detail: "Gold memory present in context but answer was incorrect" };
+    return {
+      goldMemory: goldStatement,
+      label: { class: "use_miss", reason: "Gold memory present in context but task failed" },
+      stages
+    };
+  }
+  if (options.similarity || threshold !== witnessThreshold) {
+    const detail = "stored extraction witness uses a different similarity policy";
+    stages.extraction = { status: "unavailable", detail };
+    stages.index = { status: "unavailable", detail: "extraction check unavailable" };
+    stages.retrieval = { status: "unavailable", detail: "extraction check unavailable" };
+    stages.use = { status: "unavailable", detail: "not reached" };
+    return {
+      goldMemory: goldStatement,
+      label: { class: "unattributed", reason: detail },
+      stages
+    };
+  }
+  const storeIds = goldWitness.storeMemoryIds;
+  if (storeIds === null) {
+    stages.extraction = { status: "unavailable", detail: "stored extraction witness unavailable" };
+    stages.index = { status: "unavailable", detail: "extraction check unavailable" };
+    stages.retrieval = { status: "unavailable", detail: "extraction check unavailable" };
+    stages.use = { status: "unavailable", detail: "not reached" };
+    return {
+      goldMemory: goldStatement,
+      label: { class: "unattributed", reason: "extraction check unavailable (stored witness)" },
+      stages
+    };
+  }
+  if (storeIds.length === 0) {
+    const detail = "stored witness found no matching memory";
+    stages.extraction = { status: "fail", detail };
+    stages.index = { status: "unavailable", detail: "not reached" };
+    stages.retrieval = { status: "unavailable", detail: "not reached" };
+    stages.use = { status: "unavailable", detail: "not reached" };
+    return {
+      goldMemory: goldStatement,
+      label: { class: "extraction_miss", reason: detail },
+      stages
+    };
+  }
+  const storeIdSet = new Set(storeIds);
+  stages.extraction = {
+    status: "pass",
+    detail: `Stored witness matched ${storeIds.length} memory id${storeIds.length === 1 ? "" : "s"}`
+  };
+  const oracleIds = goldWitness.oracleMemoryIds;
+  let indexPassed = false;
+  let indexFailed = false;
+  if (oracleIds === null) {
+    stages.index = { status: "unavailable", detail: "stored oracle witness unavailable" };
+  } else if (oracleIds.some((id) => storeIdSet.has(id))) {
+    indexPassed = true;
+    stages.index = { status: "pass", detail: "Found in stored oracle witness" };
+  } else {
+    indexFailed = true;
+    stages.index = { status: "fail", detail: "Not found in stored oracle witness" };
+  }
+  let appliedHit;
+  let atCapUnavailable = retrievals.length === 0;
+  for (const retrieval of retrievals) {
+    if (retrieval.atCapMemoryIds === null) {
+      atCapUnavailable = true;
+      continue;
+    }
+    const index = retrieval.atCapMemoryIds.findIndex((id) => storeIdSet.has(id));
+    if (index >= 0) {
+      appliedHit = { sessionId: retrieval.sessionId, rank: index + 1 };
+      break;
+    }
+  }
+  let headroomHit;
+  if (!appliedHit) {
+    for (const retrieval of retrievals) {
+      if (retrieval.headroomMemoryIds === null || retrieval.appliedCap === null) {
+        continue;
+      }
+      const index = retrieval.headroomMemoryIds.findIndex((id) => storeIdSet.has(id));
+      if (index >= 0) {
+        headroomHit = {
+          sessionId: retrieval.sessionId,
+          rank: retrieval.appliedCap + index + 1,
+          appliedCap: retrieval.appliedCap
+        };
+        break;
+      }
+    }
+  }
+  if (appliedHit) {
+    stages.retrieval = {
+      status: "pass",
+      detail: `Found at rank ${appliedHit.rank} in stored session ${appliedHit.sessionId}`
+    };
+    if (!indexPassed) {
+      indexPassed = true;
+      indexFailed = false;
+      stages.index = { status: "pass", detail: "implied pass from retrieval" };
+    }
+    stages.use = { status: "fail", detail: "Gold memory present in context but answer was incorrect" };
+    return {
+      goldMemory: goldStatement,
+      label: { class: "use_miss", reason: "Gold memory present in context but task failed" },
+      stages
+    };
+  }
+  let retrievalStageMiss = "unknown";
+  if (atCapUnavailable) {
+    stages.retrieval = { status: "unavailable", detail: "stored at-cap witness unavailable" };
+  } else if (headroomHit) {
+    retrievalStageMiss = "cap";
+    stages.retrieval = {
+      status: "fail",
+      detail: `Headroom rank ${headroomHit.rank} exceeds applied cap ${headroomHit.appliedCap} in session ${headroomHit.sessionId}`
+    };
+    if (!indexPassed) {
+      indexPassed = true;
+      indexFailed = false;
+      stages.index = { status: "pass", detail: "implied pass from retrieval headroom" };
+    }
+  } else {
+    stages.retrieval = { status: "fail", detail: "absent from every stored at-cap retrieval witness" };
+  }
+  if (indexFailed && stages.retrieval.status === "fail") {
+    stages.use = { status: "unavailable", detail: "not reached" };
+    return {
+      goldMemory: goldStatement,
+      label: { class: "index_miss", reason: "Gold statement missing from search index" },
+      stages
+    };
+  }
+  if (indexPassed && stages.retrieval.status === "fail") {
+    stages.use = { status: "unavailable", detail: "not reached" };
+    return {
+      goldMemory: goldStatement,
+      label: {
+        class: "retrieval_miss",
+        retrievalStage: retrievalStageMiss,
+        reason: stages.retrieval.detail
+      },
+      stages
+    };
+  }
+  stages.use = { status: "unavailable", detail: "not reached" };
+  const reason = stages.index.status === "unavailable" ? "index check unavailable; a retrieval miss cannot be isolated from an index miss" : "retrieval check unavailable";
+  return {
+    goldMemory: goldStatement,
+    label: { class: "unattributed", reason },
+    stages
+  };
+}
+async function attributeTask(task, env, options = {}) {
+  const golds = task.goldMemories ?? task.attributionWitness?.golds.map((gold) => gold.goldMemory);
+  if (!golds || golds.length === 0) {
+    return null;
+  }
+  const recalledText = typeof task.details?.recalledText === "string" ? task.details.recalledText : void 0;
+  if (task.attributionWitness) {
+    const goldAttributions2 = [];
+    for (let index = 0; index < golds.length; index += 1) {
+      const gold = golds[index];
+      const goldWitness = task.attributionWitness.golds[index];
+      if (!goldWitness || goldWitness.goldMemory !== gold) {
+        throw new Error("attribution witness golds must match task goldMemories in length and order");
+      }
+      goldAttributions2.push(attributeGoldMemoryFromWitness(
+        gold,
+        goldWitness,
+        task.attributionWitness.retrievals,
+        task.attributionWitness.runtime.attributionThreshold,
+        options,
+        recalledText
+      ));
+    }
+    if (task.attributionWitness.golds.length !== golds.length) {
+      throw new Error("attribution witness golds must match task goldMemories in length and order");
+    }
+    return {
+      taskId: task.taskId,
+      question: task.question,
+      golds: goldAttributions2,
+      overall: computeOverallLabel(goldAttributions2)
+    };
+  }
+  const memoizedEnv = withMemoizedListMemories(env);
+  const goldAttributions = [];
+  for (const gold of golds) {
+    const attr = await attributeGoldMemory(gold, task.question, memoizedEnv, options, recalledText);
+    goldAttributions.push(attr);
+  }
+  const overall = computeOverallLabel(goldAttributions);
+  return {
+    taskId: task.taskId,
+    question: task.question,
+    golds: goldAttributions,
+    overall
+  };
+}
+async function attributeRun(result, env, options = {}) {
+  const runId = result.meta?.runId ?? result.meta?.id ?? "unknown-run";
+  let memoizedEnv;
+  const totals = {
+    extraction_miss: 0,
+    index_miss: 0,
+    retrieval_miss: 0,
+    use_miss: 0,
+    unattributed: 0
+  };
+  const retrievalStages = {
+    filter: 0,
+    cap: 0,
+    rank: 0,
+    unknown: 0
+  };
+  const items = [];
+  const skippedTasks = [];
+  for (const task of result.results.tasks) {
+    if (task.details?.benchmarkFailure && typeof task.details.benchmarkFailure === "object") {
+      skippedTasks.push({
+        taskId: task.taskId,
+        reason: "trial execution failure (not an answer failure)"
+      });
+      continue;
+    }
+    const goldCount = task.goldMemories?.length ?? task.attributionWitness?.golds.length ?? 0;
+    if (goldCount === 0) {
+      skippedTasks.push({
+        taskId: task.taskId,
+        reason: "No goldMemories specified"
+      });
+      continue;
+    }
+    if (!isTaskFailed(task)) {
+      skippedTasks.push({
+        taskId: task.taskId,
+        reason: "Task passed (score >= 1)"
+      });
+      continue;
+    }
+    const taskEnv = task.attributionWitness ? env : memoizedEnv ??= withMemoizedListMemories(env);
+    const taskAttr = await attributeTask(task, taskEnv, options);
+    if (taskAttr) {
+      items.push(taskAttr);
+    }
+  }
+  items.sort((a, b) => a.taskId < b.taskId ? -1 : a.taskId > b.taskId ? 1 : 0);
+  skippedTasks.sort((a, b) => a.taskId < b.taskId ? -1 : a.taskId > b.taskId ? 1 : 0);
+  for (const item of items) {
+    totals[item.overall.class]++;
+    if (item.overall.class === "retrieval_miss") {
+      const stage = item.overall.retrievalStage ?? "unknown";
+      retrievalStages[stage]++;
+    }
+  }
+  return {
+    runId,
+    totals,
+    retrievalStages,
+    attributedTasks: items.length,
+    skippedTasks,
+    items
+  };
+}
+function renderAttributionReportTable(report) {
+  const lines = [];
+  lines.push(`Attribution Report (Run: ${report.runId})`);
+  lines.push(`Failed-task predicate: minimum primary answer score < 1 (scores.overall or non-diagnostic scores)`);
+  lines.push(`Attributed tasks: ${report.attributedTasks}, Skipped tasks: ${report.skippedTasks.length}`);
+  lines.push("");
+  lines.push("Totals by Class:");
+  lines.push(`  extraction_miss: ${report.totals.extraction_miss}`);
+  lines.push(`  index_miss:      ${report.totals.index_miss}`);
+  lines.push(`  retrieval_miss:  ${report.totals.retrieval_miss}`);
+  lines.push(`  use_miss:        ${report.totals.use_miss}`);
+  lines.push(`  unattributed:    ${report.totals.unattributed}`);
+  lines.push("");
+  lines.push("Retrieval Miss Stages:");
+  lines.push(`  filter:  ${report.retrievalStages.filter}`);
+  lines.push(`  cap:     ${report.retrievalStages.cap}`);
+  lines.push(`  rank:    ${report.retrievalStages.rank}`);
+  lines.push(`  unknown: ${report.retrievalStages.unknown}`);
+  lines.push("");
+  lines.push("Task Attributions:");
+  if (report.items.length === 0) {
+    lines.push("  (none)");
+  } else {
+    for (const item of report.items) {
+      const stageStr = item.overall.retrievalStage ? ` (${item.overall.retrievalStage})` : "";
+      const labelStr = `${item.overall.class}${stageStr}`;
+      const reasonStr = item.overall.reason ? ` - ${item.overall.reason}` : "";
+      lines.push(`  ${item.taskId.padEnd(20)} ${labelStr.padEnd(24)}${reasonStr}`);
+    }
+  }
+  if (report.skippedTasks.length > 0) {
+    lines.push("");
+    lines.push("Skipped Tasks:");
+    for (const skipped of report.skippedTasks) {
+      lines.push(`  ${skipped.taskId.padEnd(20)} ${skipped.reason}`);
+    }
+  }
+  return `${lines.join("\n")}
+`;
+}
+function serializeAttributionReport(report) {
+  return `${JSON.stringify(report, null, 2)}
+`;
+}
+
+// src/adapters/attribution-witness.ts
+async function readCoreMemories(orchestrator) {
+  return [
+    ...await orchestrator.storage.readAllMemories(),
+    ...await orchestrator.storage.readAllColdMemories()
+  ];
+}
+async function canonicalizeMemoryIds(orchestrator, results) {
+  const memories = await Promise.all(
+    results.map((result) => orchestrator.qmdResultResolver.readQmdResultMemory(
+      result.path,
+      orchestrator.storage,
+      [],
+      result.namespace
+    ))
+  );
+  if (memories.some((memory) => memory === null)) return null;
+  return memories.map((memory) => memory.frontmatter.id);
+}
+async function captureRecallAttribution(orchestrator, sessionId, snapshot) {
+  const [atCapMemoryIds, headroomMemoryIds] = await Promise.all([
+    canonicalizeMemoryIds(orchestrator, snapshot.appliedResults),
+    canonicalizeMemoryIds(orchestrator, snapshot.headroomResults)
+  ]);
+  if (atCapMemoryIds === null || headroomMemoryIds === null) return void 0;
+  return {
+    sessionId,
+    appliedCap: snapshot.appliedResultLimit,
+    atCapMemoryIds,
+    headroomMemoryIds
+  };
+}
+async function captureTaskAttributionWitness(options) {
+  const qmdMaxResults = options.orchestrator.config.qmdMaxResults;
+  let storedMemories;
+  try {
+    storedMemories = await readCoreMemories(options.orchestrator);
+  } catch {
+    storedMemories = null;
+  }
+  const golds = await Promise.all(
+    options.goldMemories.map(async (goldMemory) => {
+      const storeMemoryIds = storedMemories === null ? null : [
+        ...new Set(
+          storedMemories.filter((memory) => lexicalSimilarity(goldMemory, memory.content) >= 0.6).map((memory) => memory.frontmatter.id)
+        )
+      ];
+      let oracleMemoryIds = null;
+      if (qmdMaxResults > 0) {
+        try {
+          const oracleResults = await options.orchestrator.searchAcrossNamespaces({
+            query: goldMemory,
+            maxResults: qmdMaxResults,
+            mode: "search"
+          });
+          const canonicalIds = await canonicalizeMemoryIds(
+            options.orchestrator,
+            oracleResults
+          );
+          oracleMemoryIds = canonicalIds === null ? null : [...new Set(canonicalIds)];
+        } catch {
+          oracleMemoryIds = null;
+        }
+      }
+      return { goldMemory, storeMemoryIds, oracleMemoryIds };
+    })
+  );
+  return {
+    schemaVersion: 1,
+    runtime: {
+      qmdCollection: options.qmdCollection,
+      qmdIndex: options.qmdIndex,
+      qmdMaxResults,
+      attributionThreshold: DEFAULT_ATTRIBUTION_THRESHOLD
+    },
+    golds,
+    retrievals: options.retrievals.map((retrieval) => ({
+      sessionId: retrieval.sessionId,
+      appliedCap: retrieval.appliedCap,
+      atCapMemoryIds: retrieval.atCapMemoryIds === null ? null : [...retrieval.atCapMemoryIds],
+      headroomMemoryIds: retrieval.headroomMemoryIds === null ? null : [...retrieval.headroomMemoryIds]
+    }))
+  };
+}
+
+// src/adapters/remnic-adapter.ts
+import {
+  lcmEvidenceIdentity
+} from "@remnic/core/lcm";
+
+// src/adapters/remnic-recall-trace.ts
+import { createHash as createHash6 } from "crypto";
+import {
+  lcmArchiveRowId
+} from "@remnic/core/lcm";
+function visibleRange(start, end, returnedChars) {
+  const visibleStart = Math.min(start, returnedChars);
+  return {
+    visibleStart,
+    visibleEnd: Math.max(visibleStart, Math.min(end, returnedChars))
+  };
+}
+function projectBenchCoreCapture(snapshot) {
+  return {
+    snapshotId: snapshot.snapshotId,
+    capturedAt: snapshot.capturedAt,
+    ...snapshot.traceId === void 0 ? {} : { traceId: snapshot.traceId },
+    budget: { chars: snapshot.budget.chars, used: snapshot.budget.used },
+    filters: snapshot.filters.map(({ name, considered, admitted }) => ({
+      name,
+      considered,
+      admitted
+    })),
+    results: snapshot.results.map((result) => {
+      const scores = result.scoreDecomposition;
+      return {
+        memoryIdRef: {
+          sha256: createHash6("sha256").update(result.memoryId, "utf8").digest("hex"),
+          length: Buffer.byteLength(result.memoryId, "utf8")
+        },
+        servedBy: result.servedBy,
+        scoreDecomposition: {
+          ...typeof scores.vector === "number" ? { vector: scores.vector } : {},
+          ...typeof scores.bm25 === "number" ? { bm25: scores.bm25 } : {},
+          ...typeof scores.importance === "number" ? { importance: scores.importance } : {},
+          ...typeof scores.mmrPenalty === "number" ? { mmrPenalty: scores.mmrPenalty } : {},
+          ...typeof scores.tierPrior === "number" ? { tierPrior: scores.tierPrior } : {},
+          ...typeof scores.reinforcementBoost === "number" ? { reinforcementBoost: scores.reinforcementBoost } : {},
+          final: scores.final
+        },
+        admittedBy: [...result.admittedBy],
+        ...result.rejectedBy === void 0 ? {} : { rejectedBy: result.rejectedBy },
+        ...result.disclosure === void 0 ? {} : { disclosure: result.disclosure },
+        ...result.estimatedTokens === void 0 ? {} : { estimatedTokens: result.estimatedTokens }
+      };
+    })
+  };
+}
+function createBenchRecallTraceRecorder(requestedChars) {
+  const sections = [];
+  const pendingSelections = [];
+  const lcmCandidates = [];
+  let composedChars = 0;
+  let coreCapture;
+  const sectionById = (sectionId) => {
+    const section = sections.find((entry) => entry.id === sectionId);
+    if (!section) throw new Error(`Unknown benchmark recall trace section: ${sectionId}`);
+    return section;
+  };
+  const appendRelativeSelection = (sectionId, kind, start, end, lineageStatus, fields = {}) => {
+    const section = sectionById(sectionId);
+    const contentLength = section.contentEnd - section.contentStart;
+    if (!Number.isSafeInteger(start) || !Number.isSafeInteger(end) || start < 0 || end < start || end > contentLength) {
+      throw new Error(
+        `Invalid benchmark recall trace range for ${sectionId}: ${start}..${end}.`
+      );
+    }
+    pendingSelections.push({
+      sectionId,
+      kind,
+      lineageStatus,
+      composedStart: section.contentStart + start,
+      composedEnd: section.contentStart + end,
+      ...fields
+    });
+  };
+  return {
+    appendSection(id, source, renderedLength) {
+      if (!Number.isSafeInteger(renderedLength) || renderedLength < 0) {
+        throw new Error("Benchmark recall trace section length must be a non-negative integer.");
+      }
+      if (sections.some((section) => section.id === id)) {
+        throw new Error(`Duplicate benchmark recall trace section: ${id}`);
+      }
+      const separatorStart = composedChars;
+      const contentStart = composedChars + (sections.length === 0 ? 0 : 2);
+      const contentEnd = contentStart + renderedLength;
+      sections.push({
+        id,
+        source,
+        separatorStart,
+        contentStart,
+        contentEnd,
+        composedStart: separatorStart,
+        composedEnd: contentEnd,
+        visibleStart: 0,
+        visibleEnd: 0,
+        visibleChars: 0
+      });
+      composedChars = contentEnd;
+    },
+    recordEvidenceSelections(sectionId, receipts) {
+      for (const receipt of receipts) {
+        appendRelativeSelection(
+          sectionId,
+          "evidence-block",
+          receipt.blockStart,
+          receipt.blockEnd,
+          receipt.item.archiveRowId === void 0 ? "unavailable" : "exact",
+          {
+            ...receipt.item.archiveRowId === void 0 ? {} : { archiveRowIds: [receipt.item.archiveRowId] },
+            ...receipt.item.turnIndex === void 0 ? {} : { turnIndex: receipt.item.turnIndex },
+            ...receipt.item.role === void 0 ? {} : { role: receipt.item.role },
+            ...receipt.item.score === void 0 ? {} : { score: receipt.item.score }
+          }
+        );
+      }
+    },
+    recordTrajectorySelections(sectionId, receipts) {
+      for (const receipt of receipts) {
+        appendRelativeSelection(
+          sectionId,
+          "trajectory-line",
+          receipt.lineStart,
+          receipt.lineEnd,
+          receipt.lineageStatus,
+          {
+            archiveRowIds: [
+              ...receipt.actionArchiveRowIds,
+              ...receipt.observationArchiveRowIds
+            ]
+          }
+        );
+      }
+    },
+    recordSummarySelections(sectionId, receipts) {
+      for (const receipt of receipts) {
+        appendRelativeSelection(
+          sectionId,
+          "lcm-summary",
+          receipt.entryStart,
+          receipt.entryEnd,
+          "exact",
+          {
+            summary: {
+              id: receipt.id,
+              depth: receipt.depth,
+              msgStart: receipt.msgStart,
+              msgEnd: receipt.msgEnd
+            }
+          }
+        );
+      }
+    },
+    recordRawRow(sectionId, range, row) {
+      const archiveRowId = lcmArchiveRowId(row);
+      appendRelativeSelection(
+        sectionId,
+        "raw-row",
+        range.start,
+        range.end,
+        archiveRowId === void 0 ? "unavailable" : "exact",
+        {
+          ...archiveRowId === void 0 ? {} : { archiveRowIds: [archiveRowId] },
+          turnIndex: row.turn_index,
+          role: row.role
+        }
+      );
+    },
+    recordLcmCandidate(candidate) {
+      lcmCandidates.push({ ...candidate });
+    },
+    recordCoreCapture(snapshot) {
+      coreCapture = snapshot ? projectBenchCoreCapture(snapshot) : void 0;
+    },
+    finalize(returnedChars) {
+      const normalizedReturnedChars = Math.max(0, Math.min(returnedChars, composedChars));
+      return {
+        schemaVersion: 1,
+        sensitivity: {
+          classification: "restricted",
+          contentEncoding: "sha256+length",
+          containsGold: false
+        },
+        sections: sections.map((section) => {
+          const visible = visibleRange(
+            section.composedStart,
+            section.composedEnd,
+            normalizedReturnedChars
+          );
+          return {
+            ...section,
+            ...visible,
+            visibleChars: visible.visibleEnd - visible.visibleStart
+          };
+        }),
+        selections: pendingSelections.map((selection) => ({
+          ...selection,
+          ...visibleRange(
+            selection.composedStart,
+            selection.composedEnd,
+            normalizedReturnedChars
+          )
+        })),
+        lcmCandidates: lcmCandidates.map((candidate) => ({ ...candidate })),
+        ...coreCapture === void 0 ? {} : { coreCapture },
+        budget: {
+          requestedChars,
+          composedChars,
+          returnedChars: normalizedReturnedChars,
+          truncated: normalizedReturnedChars < composedChars
+        }
+      };
+    }
+  };
+}
+
+// src/recall-budget.ts
+var DEFAULT_BENCH_RECALL_BUDGET_CHARS = 24e3;
+var MAX_COMBINED_RECALL_BUDGET_CHARS = 36e3;
+function benchmarkRecallBudgetForSessionCount(sessionCount) {
+  if (!Number.isInteger(sessionCount) || sessionCount <= 0) {
+    return DEFAULT_BENCH_RECALL_BUDGET_CHARS;
+  }
+  if (sessionCount === 1) {
+    return DEFAULT_BENCH_RECALL_BUDGET_CHARS;
+  }
+  return Math.floor(MAX_COMBINED_RECALL_BUDGET_CHARS / 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(
@@ -6859,6 +7708,14 @@ function pruneBenchEntityStructuredFacts(structuredSections, targetSources, prot
   return { changed, structuredSections: nextSections };
 }
 async function clearBenchCoreEntitiesForSession(orchestrator, sessionId) {
+  const baseDir = orchestrator.storage.dir;
+  await withRawEntityPageMutation(
+    baseDir,
+    path5.join(baseDir, "entities", ".bench-session-cleanup.md"),
+    async () => clearBenchCoreEntitiesForSessionUnlocked(orchestrator, sessionId)
+  );
+}
+async function clearBenchCoreEntitiesForSessionUnlocked(orchestrator, sessionId) {
   const storage = orchestrator.storage;
   const entityStorage = storage;
   const entitySchemas = entityStorage.entitySchemas;
@@ -7328,7 +8185,7 @@ function createAdapterFactory(mode) {
           throw error;
         }
       },
-      async [composeRecall](sessionId, query, budgetChars, recallOptions = {}, control, traceRecorder) {
+      async [composeRecall](sessionId, query, budgetChars, recallOptions = {}, control, traceRecorder, attributionSink) {
         throwIfBenchPhaseAborted(control, "recall");
         const waitForRecall = (promise) => withBenchPhaseAbort(promise, control, "recall");
         sessionId = normalizeBenchSessionId(sessionId);
@@ -7480,8 +8337,15 @@ function createAdapterFactory(mode) {
             control,
             "recall",
             { waitForCompletionOnAbort: true }
-          ).then((capture) => {
+          ).then(async (capture) => {
             traceRecorder.recordCoreCapture(capture.snapshot);
+            attributionSink?.(
+              capture.snapshot ? await captureRecallAttribution(
+                state.orchestrator,
+                sessionId,
+                capture.snapshot
+              ).catch(() => void 0) : void 0
+            );
             return capture.result;
           }) : await waitForRecall(
             state.orchestrator.recall(query, sessionId, coreOptions)
@@ -7784,15 +8648,32 @@ ${coreRecall.trim()}`;
       async recallWithTrace(sessionId, query, budgetChars, recallOptions = {}, control) {
         const budget = budgetChars ?? DEFAULT_BENCH_RECALL_BUDGET_CHARS;
         const traceRecorder = createBenchRecallTraceRecorder(Math.max(0, budget));
+        let attribution;
         const text = await adapter[composeRecall](
           sessionId,
           query,
           budgetChars,
           recallOptions,
           control,
-          traceRecorder
+          traceRecorder,
+          (captured) => {
+            attribution = captured;
+          }
         );
-        return { text, trace: traceRecorder.finalize(text.length) };
+        return {
+          text,
+          trace: traceRecorder.finalize(text.length),
+          ...attribution ? { attribution } : {}
+        };
+      },
+      async captureAttributionWitness(request) {
+        return captureTaskAttributionWitness({
+          orchestrator: state.orchestrator,
+          qmdCollection: state.orchestrator.config.qmdCollection,
+          qmdIndex: state.qmdSandbox.indexName,
+          goldMemories: request.goldMemories,
+          retrievals: request.retrievals
+        });
       },
       async assessRecallSupport(request, control) {
         throwIfBenchPhaseAborted(control, "assessRecallSupport");
@@ -21704,8 +22585,15 @@ function appendCompletedTask(ctx, tasks, pendingPairedAnswerReplays, task) {
 }
 async function executeTrialWithFailure(ctx, trial, planIndex, answerSupportGate, pendingPairedAnswerReplays) {
   const trialId = trial.taskId ?? trial.question.slice(0, 60);
+  const attributionCapture = {};
   try {
-    return await executeTrial(ctx, trial, answerSupportGate, pendingPairedAnswerReplays);
+    return await executeTrial(
+      ctx,
+      trial,
+      answerSupportGate,
+      pendingPairedAnswerReplays,
+      attributionCapture
+    );
   } catch (err) {
     const blocked = findBenchmarkRunBlockedError(err);
     if (blocked) {
@@ -21722,6 +22610,7 @@ async function executeTrialWithFailure(ctx, trial, planIndex, answerSupportGate,
       latencyMs: 0,
       tokens: { input: 0, output: 0 },
       ...trial.goldMemories ? { goldMemories: trial.goldMemories } : {},
+      ...attributionCapture.witness ? { attributionWitness: attributionCapture.witness } : {},
       details: {
         // Preserve the trial's category so a failed trial is still attributed
         // to its per-category bucket (computeCategoryAggregates), keeping the
@@ -21872,13 +22761,38 @@ function resolveResponderIdentity(responder) {
   const trimmed = typeof raw === "string" ? raw.trim() : "";
   return trimmed.length > 0 ? trimmed : null;
 }
-async function executeTrial(ctx, trial, answerSupportGate, pendingPairedAnswerReplays) {
+async function executeTrial(ctx, trial, answerSupportGate, pendingPairedAnswerReplays, attributionCapture) {
   const { result: recallResult, durationMs } = await timed(async () => {
     const recallBudget = benchmarkRecallBudgetForSessionCount(trial.recallSessionIds.length);
+    const witnessEnabled = (trial.goldMemories?.length ?? 0) > 0 && typeof ctx.options.system.recallWithTrace === "function" && typeof ctx.options.system.captureAttributionWitness === "function";
     const recalledSessions = await Promise.all(
-      trial.recallSessionIds.map((sessionId) => ctx.options.system.recall(sessionId, trial.question, recallBudget))
+      trial.recallSessionIds.map(async (sessionId) => {
+        if (!witnessEnabled) {
+          return {
+            text: await ctx.options.system.recall(sessionId, trial.question, recallBudget)
+          };
+        }
+        const traced = await ctx.options.system.recallWithTrace(
+          sessionId,
+          trial.question,
+          recallBudget
+        );
+        const attribution = traced.attribution ?? {
+          sessionId,
+          appliedCap: null,
+          atCapMemoryIds: null,
+          headroomMemoryIds: null
+        };
+        return { text: traced.text, attribution };
+      })
     );
-    const rawRecalledText = recalledSessions.filter(Boolean).join("\n\n");
+    if (witnessEnabled) {
+      attributionCapture.witness = await ctx.options.system.captureAttributionWitness({
+        goldMemories: trial.goldMemories,
+        retrievals: recalledSessions.map((session) => session.attribution)
+      }).catch(() => void 0);
+    }
+    const rawRecalledText = recalledSessions.map((session) => session.text).filter(Boolean).join("\n\n");
     const recalledText2 = trial.recallTextTransform ? trial.recallTextTransform({
       question: trial.question,
       recalledText: rawRecalledText
@@ -22007,6 +22921,7 @@ async function executeTrial(ctx, trial, answerSupportGate, pendingPairedAnswerRe
       output: answered.tokens.output + judgeResult.tokens.output
     },
     ...trial.goldMemories ? { goldMemories: trial.goldMemories } : {},
+    ...attributionCapture.witness ? { attributionWitness: attributionCapture.witness } : {},
     details
   };
   if (answerReplayKey && currentProfile === "baseline" && answered.fallbackReason === void 0) {
@@ -45797,771 +46712,268 @@ async function runCodingGraphBenchmark(config = {}) {
           throw new Error(
             `search_graph failed: ${searchRes.result.code}`
           );
-        }
-        searchSamples.push(searchRes.ms);
-      }
-      const deadCode = timeSync(() => store.deadCode());
-      if (!deadCode.result.ok) {
-        throw new Error(`dead_code failed: ${deadCode.result.code}`);
-      }
-      await store.drain();
-      let dbBytes = statSync(dbPath).size;
-      try {
-        dbBytes += statSync(dbPath + "-wal").size;
-      } catch {
-      }
-      const kloc = Math.max(1, repo.approximateLoc / 1e3);
-      const dbBytesPerKloc = dbBytes / kloc;
-      const modifiedSamples = [];
-      for (let i = 0; i < iterations; i++) {
-        const fileIdx = i % storeFiles.length;
-        const original = storeFiles[fileIdx];
-        if (!original) continue;
-        const ownSyms = new Set(original.symbols.map((sym) => sym.qualifiedName));
-        const churnName = `mod.benchChurnSymbol${i}`;
-        const representativeEdges = (original.edges ?? []).filter((e) => !ownSyms.has(e.dstQualifiedName)).slice(0, 2).map((e) => ({ ...e, srcQualifiedName: churnName }));
-        const modified = {
-          ...original,
-          contentHash: `${original.contentHash}-mod-${i}`,
-          symbols: [
-            {
-              qualifiedName: churnName,
-              name: `benchChurnSymbol${i}`,
-              kind: "function",
-              span: { startByte: 0, endByte: 0 }
-            }
-          ],
-          edges: representativeEdges
-        };
-        const modResult = await timeAsync(
-          () => store.upsertFileBatch([modified])
-        );
-        if (!modResult.result.ok) {
-          throw new Error(`modified update failed: ${modResult.result.code}`);
-        }
-        modifiedSamples.push(modResult.ms);
-        const restoreResult = await store.upsertFileBatch(storeFiles);
-        if (!restoreResult.ok) {
-          throw new Error(`restore failed: ${restoreResult.code}`);
-        }
-        sampleRss();
-      }
-      sampleRss();
-      const peakRssBytes = peakRss;
-      return {
-        schemaVersion: CODING_GRAPH_BENCH_SCHEMA_VERSION,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        machine: captureMachineFingerprint(),
-        fixture: {
-          config: fixtureConfig,
-          approximateLoc: repo.approximateLoc,
-          fileCount: repo.files.length,
-          symbolCount: repo.files.reduce((sum, f) => sum + f.symbols.length, 0),
-          edgeCount: repo.files.reduce((sum, f) => sum + f.edges.length, 0)
-        },
-        fullIndexMs: { ms: fullIndexMsValue },
-        fullIndexLocsPerSecond: Math.round(locsPerSecond),
-        incrementalUpdate: computeMicroMetric(incrementalSamples),
-        incrementalModifiedUpdate: computeMicroMetric(
-          modifiedSamples.length > 0 ? modifiedSamples : [0]
-        ),
-        tracePath: computeMicroMetric(traceSamples.length > 0 ? traceSamples : [0]),
-        searchGraph: computeMicroMetric(searchSamples),
-        deadCodeMs: { ms: deadCode.ms },
-        dbBytesPerKloc: Math.round(dbBytesPerKloc),
-        peakRssBytes,
-        dbBytes,
-        graphNodeCount,
-        graphEdgeCount
-      };
-    } finally {
-      await store.close();
-    }
-  } finally {
-    await rm15(dir, { recursive: true, force: true });
-  }
-}
-
-// src/coding-graph/regression.ts
-var METRIC_DIRECTION = {
-  fullIndexMs: "lower-is-better",
-  fullIndexLocsPerSecond: "higher-is-better",
-  incrementalUpdateP95Ms: "lower-is-better",
-  incrementalUpdateP50Ms: "lower-is-better",
-  incrementalModifiedUpdateP95Ms: "lower-is-better",
-  incrementalModifiedUpdateP50Ms: "lower-is-better",
-  tracePathP95Ms: "lower-is-better",
-  searchGraphP95Ms: "lower-is-better",
-  deadCodeMs: "lower-is-better",
-  dbBytesPerKloc: "lower-is-better"
-};
-function extractMetrics(report) {
-  return {
-    fullIndexMs: report.fullIndexMs.ms,
-    fullIndexLocsPerSecond: report.fullIndexLocsPerSecond,
-    incrementalUpdateP50Ms: report.incrementalUpdate.p50,
-    incrementalUpdateP95Ms: report.incrementalUpdate.p95,
-    incrementalModifiedUpdateP50Ms: report.incrementalModifiedUpdate.p50,
-    incrementalModifiedUpdateP95Ms: report.incrementalModifiedUpdate.p95,
-    tracePathP95Ms: report.tracePath.p95,
-    searchGraphP95Ms: report.searchGraph.p95,
-    deadCodeMs: report.deadCodeMs.ms,
-    dbBytesPerKloc: report.dbBytesPerKloc
-  };
-}
-var NODE_MAJOR_CACHE = /* @__PURE__ */ new WeakMap();
-function nodeMajor(fp) {
-  const cached = NODE_MAJOR_CACHE.get(fp);
-  if (cached !== void 0) return cached;
-  const major = fp.nodeVersion.replace(/^v/, "").split(".")[0] ?? fp.nodeVersion;
-  NODE_MAJOR_CACHE.set(fp, major);
-  return major;
-}
-function compareMachineFingerprints(report, baseline) {
-  const differing = [];
-  if (report.arch !== baseline.arch) differing.push("arch");
-  if (report.platform !== baseline.platform) differing.push("platform");
-  if (nodeMajor(report) !== nodeMajor(baseline)) differing.push("nodeVersion(major)");
-  if (report.cpuModel !== null && baseline.cpuModel !== null && report.cpuModel !== baseline.cpuModel) {
-    differing.push("cpuModel");
-  }
-  if (report.cpuCores !== baseline.cpuCores) differing.push("cpuCores");
-  return { differingFields: differing };
-}
-function invalidFingerprintFields(fp) {
-  const bad = [];
-  if (typeof fp.arch !== "string") bad.push("arch");
-  if (typeof fp.platform !== "string") bad.push("platform");
-  if (typeof fp.nodeVersion !== "string") bad.push("nodeVersion");
-  if (typeof fp.cpuCores !== "number" || !Number.isFinite(fp.cpuCores)) bad.push("cpuCores");
-  if (fp.cpuModel !== null && typeof fp.cpuModel !== "string") bad.push("cpuModel");
-  return bad;
-}
-function checkCodingGraphRegression(report, baseline, tolerancePercent = DEFAULT_TOLERANCE_PERCENT) {
-  const reportFixture = report.fixture.config;
-  const baselineFixture = baseline.fixtureConfig;
-  const mismatchedKeys = Object.keys(baselineFixture).filter((key) => reportFixture[key] !== baselineFixture[key]);
-  if (mismatchedKeys.length > 0) {
-    const diffs = mismatchedKeys.map(
-      (key) => `${key}: report=${reportFixture[key]} baseline=${baselineFixture[key]}`
-    ).join(", ");
-    return {
-      passed: false,
-      regressions: [],
-      summary: `Fixture mismatch (${diffs}). Metrics are not comparable across different fixtures.`
-    };
-  }
-  if (report.schemaVersion !== baseline.schemaVersion) {
-    return {
-      passed: false,
-      regressions: [],
-      summary: `Schema-version mismatch: report=${report.schemaVersion} baseline=${baseline.schemaVersion}. Metrics are not comparable across schema versions \u2014 regenerate the baseline (#1688).`
-    };
-  }
-  const metricChecks = [
-    ["incrementalUpdate.p50", report.incrementalUpdate?.p50],
-    ["incrementalUpdate.p95", report.incrementalUpdate?.p95],
-    ["incrementalModifiedUpdate.p50", report.incrementalModifiedUpdate?.p50],
-    ["incrementalModifiedUpdate.p95", report.incrementalModifiedUpdate?.p95],
-    ["tracePath.p95", report.tracePath?.p95],
-    ["searchGraph.p95", report.searchGraph?.p95],
-    ["fullIndexMs.ms", report.fullIndexMs?.ms],
-    ["fullIndexLocsPerSecond", report.fullIndexLocsPerSecond],
-    ["deadCodeMs.ms", report.deadCodeMs?.ms],
-    ["dbBytesPerKloc", report.dbBytesPerKloc]
-  ];
-  const missingFields = metricChecks.filter(([, v]) => typeof v !== "number" || !Number.isFinite(v)).map(([k]) => k);
-  if (missingFields.length > 0) {
-    return {
-      passed: false,
-      regressions: [],
-      summary: "Report claims schemaVersion " + report.schemaVersion + " but is missing required metric field(s): " + missingFields.join(", ") + " \u2014 the report is incomplete or corrupt. Regenerate it (#1688)."
-    };
-  }
-  const badBaselineMetrics = Object.keys(METRIC_DIRECTION).filter((key) => {
-    const v = baseline.metrics[key];
-    return v != null && (typeof v !== "number" || !Number.isFinite(v));
-  });
-  if (badBaselineMetrics.length > 0) {
-    return {
-      passed: false,
-      regressions: [],
-      summary: "Baseline has a non-numeric required metric field(s): " + badBaselineMetrics.join(", ") + " \u2014 the baseline is corrupt. Regenerate it (#1688)."
-    };
-  }
-  const reportFpBad = report.machine == null ? ["<missing>"] : invalidFingerprintFields(report.machine);
-  const baselineFpBad = baseline.machine == null ? ["<missing>"] : invalidFingerprintFields(baseline.machine);
-  if (reportFpBad.length > 0 || baselineFpBad.length > 0) {
-    const which = [];
-    if (reportFpBad.length > 0) which.push("report (" + reportFpBad.join(", ") + ")");
-    if (baselineFpBad.length > 0) which.push("baseline (" + baselineFpBad.join(", ") + ")");
-    return {
-      passed: false,
-      regressions: [],
-      summary: "Report or baseline machine fingerprint is missing or has an invalid field type(s): " + which.join("; ") + " \u2014 the artifact is incomplete or corrupt. Regenerate it (#1688)."
-    };
-  }
-  const mismatch = compareMachineFingerprints(report.machine, baseline.machine);
-  if (mismatch.differingFields.length > 0) {
-    return {
-      passed: true,
-      skipped: true,
-      regressions: [],
-      summary: "Machine-fingerprint mismatch \u2014 comparison skipped to avoid a false-positive hardware-variance failure. Differing fields: " + mismatch.differingFields.join(", ") + ". Regenerate the baseline on this machine for a real comparison (#1688).",
-      machineMismatch: {
-        report: report.machine,
-        baseline: baseline.machine,
-        differingFields: mismatch.differingFields
-      }
-    };
-  }
-  const measured = extractMetrics(report);
-  const baselineMetrics = baseline.metrics;
-  const regressions = [];
-  for (const key of Object.keys(METRIC_DIRECTION)) {
-    const baseVal = baselineMetrics[key];
-    const measVal = measured[key];
-    if (baseVal == null || measVal == null) continue;
-    if (baseVal === 0) continue;
-    const direction = METRIC_DIRECTION[key];
-    const ratio2 = measVal / baseVal;
-    const percentChange2 = direction === "lower-is-better" ? (ratio2 - 1) * 100 : (1 - ratio2) * 100;
-    const regressed = percentChange2 > tolerancePercent;
-    if (regressed) {
-      regressions.push({
-        key,
-        baseline: baseVal,
-        measured: measVal,
-        percentChange: Math.round(percentChange2 * 10) / 10,
-        direction,
-        tolerancePercent,
-        regressed: true
-      });
-    }
-  }
-  const passed = regressions.length === 0;
-  const summary = passed ? "All metrics within tolerance." : `${regressions.length} metric(s) regressed beyond ${tolerancePercent}% tolerance:
-` + regressions.map(
-    (r) => `  ${r.key}: ${r.baseline} \u2192 ${r.measured} (${r.percentChange > 0 ? "+" : ""}${r.percentChange}% vs baseline)`
-  ).join("\n");
-  return { passed, regressions, summary };
-}
-function buildBaselineFromReport(report, note) {
-  return {
-    schemaVersion: report.schemaVersion,
-    machine: report.machine,
-    fixtureConfig: report.fixture.config,
-    metrics: extractMetrics(report),
-    createdAt: report.timestamp,
-    note
-  };
-}
-
-// src/attribution.ts
-var DEFAULT_STOPWORDS = /* @__PURE__ */ new Set([
-  "a",
-  "an",
-  "the",
-  "in",
-  "on",
-  "at",
-  "to",
-  "for",
-  "of",
-  "with",
-  "by",
-  "from",
-  "up",
-  "about",
-  "into",
-  "through",
-  "during",
-  "before",
-  "after",
-  "above",
-  "below",
-  "and",
-  "or",
-  "but",
-  "if",
-  "then",
-  "else",
-  "when",
-  "where",
-  "why",
-  "how",
-  "all",
-  "any",
-  "both",
-  "each",
-  "few",
-  "more",
-  "most",
-  "other",
-  "some",
-  "such",
-  "no",
-  "nor",
-  "not",
-  "only",
-  "own",
-  "same",
-  "so",
-  "than",
-  "too",
-  "very",
-  "this",
-  "that",
-  "these",
-  "those",
-  "it",
-  "its",
-  "is",
-  "are",
-  "was",
-  "were",
-  "be",
-  "been",
-  "being",
-  "have",
-  "has",
-  "had",
-  "do",
-  "does",
-  "did"
-]);
-function extractContentWords(text) {
-  const cleaned = text.toLowerCase().replace(/[^a-z0-9\s]/g, " ");
-  const tokens = cleaned.split(/\s+/).filter(Boolean);
-  return tokens.filter((t) => !DEFAULT_STOPWORDS.has(t));
-}
-function lexicalSimilarity(a, b) {
-  const goldWords = extractContentWords(a);
-  if (goldWords.length === 0) {
-    return 0;
-  }
-  const candWords = new Set(extractContentWords(b));
-  let matchCount = 0;
-  for (const word of goldWords) {
-    if (candWords.has(word)) {
-      matchCount++;
-    }
-  }
-  return matchCount / goldWords.length;
-}
-var CLASS_RANK = {
-  extraction_miss: 1,
-  index_miss: 2,
-  retrieval_miss: 3,
-  use_miss: 4,
-  unattributed: 5
-};
-var RETRIEVAL_STAGE_RANK = {
-  cap: 1,
-  rank: 2,
-  filter: 3,
-  unknown: 4
-};
-function computeOverallLabel(golds) {
-  if (golds.length === 0) {
-    return { class: "unattributed", reason: "no gold memories" };
-  }
-  let bestGold = golds[0];
-  for (let i = 1; i < golds.length; i++) {
-    const current = golds[i];
-    const bestRank = CLASS_RANK[bestGold.label.class];
-    const currRank = CLASS_RANK[current.label.class];
-    if (currRank < bestRank) {
-      bestGold = current;
-    } else if (currRank === bestRank && current.label.class === "retrieval_miss") {
-      const bestRetRank = RETRIEVAL_STAGE_RANK[bestGold.label.retrievalStage ?? "unknown"];
-      const currRetRank = RETRIEVAL_STAGE_RANK[current.label.retrievalStage ?? "unknown"];
-      if (currRetRank < bestRetRank) {
-        bestGold = current;
-      }
-    }
-  }
-  return { ...bestGold.label };
-}
-function isDiagnosticScore(name) {
-  return name.endsWith("_agreement") || name.includes("_id_leak") || name === "search_hits";
-}
-function isTaskFailed(task) {
-  if (!task.scores || Object.keys(task.scores).length === 0) {
-    return true;
-  }
-  if ("overall" in task.scores && typeof task.scores.overall === "number") {
-    return task.scores.overall < 1;
-  }
-  const primaryScores = Object.entries(task.scores).filter(([name, score]) => typeof score === "number" && !isDiagnosticScore(name)).map(([, score]) => score);
-  return primaryScores.length === 0 || Math.min(...primaryScores) < 1;
-}
-function withMemoizedListMemories(env) {
-  let cache = null;
-  return {
-    ...env,
-    listMemories() {
-      if (!cache) {
-        cache = env.listMemories();
-      }
-      return cache;
-    }
-  };
-}
-async function attributeGoldMemory(goldStatement, question, env, options = {}, recalledText) {
-  if (options.threshold !== void 0) {
-    if (typeof options.threshold !== "number" || !Number.isFinite(options.threshold) || options.threshold < 0 || options.threshold > 1) {
-      throw new RangeError("attribution threshold must be a finite number between 0 and 1");
-    }
-  }
-  const threshold = options.threshold ?? 0.6;
-  const simFn = options.similarity ?? lexicalSimilarity;
-  const goldInRecalledText = typeof recalledText === "string" && simFn(goldStatement, recalledText) >= threshold;
-  const stages = {
-    extraction: { status: "unavailable" },
-    index: { status: "unavailable" },
-    retrieval: { status: "unavailable" },
-    use: { status: "unavailable" }
-  };
-  let memories = [];
-  let extractionRan = false;
-  let extractionErrorDetail;
-  if (typeof env.listMemories === "function") {
-    try {
-      memories = await env.listMemories();
-      extractionRan = true;
-    } catch {
-      extractionRan = false;
-      extractionErrorDetail = "listMemories failed";
-    }
-  }
-  let bestSim = -1;
-  let matchedMem = null;
-  if (extractionRan) {
-    if (memories.length === 0) {
-      if (goldInRecalledText) {
-        const impliedDetail = "implied pass from recalled context (post-hoc store scan missed)";
-        stages.extraction = { status: "pass", detail: impliedDetail };
-        stages.index = { status: "pass", detail: impliedDetail };
-        stages.retrieval = { status: "pass", detail: impliedDetail };
-        stages.use = {
-          status: "fail",
-          detail: "Gold memory present in context but answer was incorrect"
-        };
-        return {
-          goldMemory: goldStatement,
-          label: { class: "use_miss", reason: "Gold memory present in context but task failed" },
-          stages
-        };
-      }
-      const detail = "store contains no memories";
-      stages.extraction = { status: "fail", detail };
-      stages.index = { status: "unavailable", detail: "not reached" };
-      stages.retrieval = { status: "unavailable", detail: "not reached" };
-      stages.use = { status: "unavailable", detail: "not reached" };
-      return {
-        goldMemory: goldStatement,
-        label: { class: "extraction_miss", reason: detail },
-        stages
-      };
-    }
-    for (const mem of memories) {
-      const sim = simFn(goldStatement, mem.content);
-      if (sim > bestSim) {
-        bestSim = sim;
-        matchedMem = mem;
-      }
-    }
-    if (bestSim < threshold || !matchedMem) {
-      if (goldInRecalledText) {
-        const impliedDetail = "implied pass from recalled context (post-hoc store scan missed)";
-        stages.extraction = { status: "pass", detail: impliedDetail };
-        stages.index = { status: "pass", detail: impliedDetail };
-        stages.retrieval = { status: "pass", detail: impliedDetail };
-        stages.use = {
-          status: "fail",
-          detail: "Gold memory present in context but answer was incorrect"
-        };
-        return {
-          goldMemory: goldStatement,
-          label: { class: "use_miss", reason: "Gold memory present in context but task failed" },
-          stages
-        };
+        }
+        searchSamples.push(searchRes.ms);
       }
-      const detail = `Best similarity ${bestSim >= 0 ? bestSim.toFixed(3) : 0} below threshold ${threshold}`;
-      stages.extraction = { status: "fail", detail };
-      stages.index = { status: "unavailable", detail: "not reached" };
-      stages.retrieval = { status: "unavailable", detail: "not reached" };
-      stages.use = { status: "unavailable", detail: "not reached" };
-      return {
-        goldMemory: goldStatement,
-        label: { class: "extraction_miss", reason: detail },
-        stages
-      };
-    }
-    stages.extraction = {
-      status: "pass",
-      detail: `Matched memory ${matchedMem.id} (sim ${bestSim.toFixed(3)})`
-    };
-  } else {
-    stages.extraction = {
-      status: "unavailable",
-      detail: extractionErrorDetail ?? "listMemories unavailable"
-    };
-  }
-  const matchedMemoryId = matchedMem ? matchedMem.id : void 0;
-  const recallLimit = env.recallLimit;
-  const replayLimit = env.replayLimit ?? Math.max(25, recallLimit * 5);
-  let indexCheckPassed = false;
-  let indexCheckFailed = false;
-  if (typeof env.oracleSearch === "function" && extractionRan) {
-    try {
-      const oracleResults = await env.oracleSearch(goldStatement, replayLimit);
-      const idMatched = matchedMemoryId ? oracleResults.some((r) => r.id === matchedMemoryId) : false;
-      if (idMatched) {
-        indexCheckPassed = true;
-      } else {
-        const memMap = new Map(memories.map((m) => [m.id, m]));
-        indexCheckPassed = oracleResults.some((r) => {
-          const mem = memMap.get(r.id);
-          return mem ? simFn(goldStatement, mem.content) >= threshold : false;
-        });
+      const deadCode = timeSync(() => store.deadCode());
+      if (!deadCode.result.ok) {
+        throw new Error(`dead_code failed: ${deadCode.result.code}`);
       }
-      if (indexCheckPassed) {
-        stages.index = { status: "pass", detail: "Found in oracle search" };
-      } else {
-        indexCheckFailed = true;
-        stages.index = { status: "fail", detail: "Not found in oracle search" };
+      await store.drain();
+      let dbBytes = statSync(dbPath).size;
+      try {
+        dbBytes += statSync(dbPath + "-wal").size;
+      } catch {
       }
-    } catch {
-      stages.index = { status: "unavailable", detail: "oracleSearch threw error" };
-    }
-  } else if (typeof env.oracleSearch === "function") {
-    stages.index = {
-      status: "unavailable",
-      detail: "extraction check unavailable; oracle result would be ambiguous"
-    };
-  } else {
-    stages.index = { status: "unavailable", detail: "index check unavailable" };
-  }
-  let retrievalCheckPassed = false;
-  let retrievalStageMiss = void 0;
-  if (typeof env.recall === "function") {
-    try {
-      const recallResults = await env.recall(question, recallLimit);
-      const isGoldInRecall = recallResults.some(
-        (m) => matchedMemoryId && m.id === matchedMemoryId || simFn(goldStatement, m.content) >= threshold
-      );
-      if (isGoldInRecall) {
-        retrievalCheckPassed = true;
-        stages.retrieval = { status: "pass", detail: `Recalled within recallLimit ${recallLimit}` };
-      } else {
-        const replayResults = await env.recall(question, replayLimit);
-        const replayIndex = replayResults.findIndex(
-          (m) => matchedMemoryId && m.id === matchedMemoryId || simFn(goldStatement, m.content) >= threshold
+      const kloc = Math.max(1, repo.approximateLoc / 1e3);
+      const dbBytesPerKloc = dbBytes / kloc;
+      const modifiedSamples = [];
+      for (let i = 0; i < iterations; i++) {
+        const fileIdx = i % storeFiles.length;
+        const original = storeFiles[fileIdx];
+        if (!original) continue;
+        const ownSyms = new Set(original.symbols.map((sym) => sym.qualifiedName));
+        const churnName = `mod.benchChurnSymbol${i}`;
+        const representativeEdges = (original.edges ?? []).filter((e) => !ownSyms.has(e.dstQualifiedName)).slice(0, 2).map((e) => ({ ...e, srcQualifiedName: churnName }));
+        const modified = {
+          ...original,
+          contentHash: `${original.contentHash}-mod-${i}`,
+          symbols: [
+            {
+              qualifiedName: churnName,
+              name: `benchChurnSymbol${i}`,
+              kind: "function",
+              span: { startByte: 0, endByte: 0 }
+            }
+          ],
+          edges: representativeEdges
+        };
+        const modResult = await timeAsync(
+          () => store.upsertFileBatch([modified])
         );
-        if (replayIndex >= 0) {
-          const rank = replayIndex + 1;
-          retrievalStageMiss = "cap";
-          stages.retrieval = {
-            status: "fail",
-            detail: `Rank ${rank} exceeds recallLimit ${recallLimit}`
-          };
-        } else {
-          retrievalStageMiss = "unknown";
-          stages.retrieval = {
-            status: "fail",
-            detail: `absent from recall at replayLimit ${replayLimit}; filter vs rank indistinguishable without candidate-stage evidence`
-          };
+        if (!modResult.result.ok) {
+          throw new Error(`modified update failed: ${modResult.result.code}`);
+        }
+        modifiedSamples.push(modResult.ms);
+        const restoreResult = await store.upsertFileBatch(storeFiles);
+        if (!restoreResult.ok) {
+          throw new Error(`restore failed: ${restoreResult.code}`);
         }
+        sampleRss();
       }
-    } catch {
-      stages.retrieval = { status: "unavailable", detail: "recall threw error" };
+      sampleRss();
+      const peakRssBytes = peakRss;
+      return {
+        schemaVersion: CODING_GRAPH_BENCH_SCHEMA_VERSION,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        machine: captureMachineFingerprint(),
+        fixture: {
+          config: fixtureConfig,
+          approximateLoc: repo.approximateLoc,
+          fileCount: repo.files.length,
+          symbolCount: repo.files.reduce((sum, f) => sum + f.symbols.length, 0),
+          edgeCount: repo.files.reduce((sum, f) => sum + f.edges.length, 0)
+        },
+        fullIndexMs: { ms: fullIndexMsValue },
+        fullIndexLocsPerSecond: Math.round(locsPerSecond),
+        incrementalUpdate: computeMicroMetric(incrementalSamples),
+        incrementalModifiedUpdate: computeMicroMetric(
+          modifiedSamples.length > 0 ? modifiedSamples : [0]
+        ),
+        tracePath: computeMicroMetric(traceSamples.length > 0 ? traceSamples : [0]),
+        searchGraph: computeMicroMetric(searchSamples),
+        deadCodeMs: { ms: deadCode.ms },
+        dbBytesPerKloc: Math.round(dbBytesPerKloc),
+        peakRssBytes,
+        dbBytes,
+        graphNodeCount,
+        graphEdgeCount
+      };
+    } finally {
+      await store.close();
     }
-  } else {
-    stages.retrieval = { status: "unavailable", detail: "retrieval check unavailable" };
-  }
-  if (!retrievalCheckPassed && goldInRecalledText) {
-    retrievalCheckPassed = true;
-    stages.retrieval = { status: "pass", detail: "Found in recalledText context" };
+  } finally {
+    await rm15(dir, { recursive: true, force: true });
   }
-  if (retrievalCheckPassed) {
-    if (indexCheckFailed) {
-      stages.index = { status: "pass", detail: "implied pass from retrieval (oracle query missed)" };
-      indexCheckPassed = true;
-    } else if (stages.index.status === "unavailable") {
-      stages.index = { status: "pass", detail: "implied pass from retrieval" };
-      indexCheckPassed = true;
-    }
+}
+
+// src/coding-graph/regression.ts
+var METRIC_DIRECTION = {
+  fullIndexMs: "lower-is-better",
+  fullIndexLocsPerSecond: "higher-is-better",
+  incrementalUpdateP95Ms: "lower-is-better",
+  incrementalUpdateP50Ms: "lower-is-better",
+  incrementalModifiedUpdateP95Ms: "lower-is-better",
+  incrementalModifiedUpdateP50Ms: "lower-is-better",
+  tracePathP95Ms: "lower-is-better",
+  searchGraphP95Ms: "lower-is-better",
+  deadCodeMs: "lower-is-better",
+  dbBytesPerKloc: "lower-is-better"
+};
+function extractMetrics(report) {
+  return {
+    fullIndexMs: report.fullIndexMs.ms,
+    fullIndexLocsPerSecond: report.fullIndexLocsPerSecond,
+    incrementalUpdateP50Ms: report.incrementalUpdate.p50,
+    incrementalUpdateP95Ms: report.incrementalUpdate.p95,
+    incrementalModifiedUpdateP50Ms: report.incrementalModifiedUpdate.p50,
+    incrementalModifiedUpdateP95Ms: report.incrementalModifiedUpdate.p95,
+    tracePathP95Ms: report.tracePath.p95,
+    searchGraphP95Ms: report.searchGraph.p95,
+    deadCodeMs: report.deadCodeMs.ms,
+    dbBytesPerKloc: report.dbBytesPerKloc
+  };
+}
+var NODE_MAJOR_CACHE = /* @__PURE__ */ new WeakMap();
+function nodeMajor(fp) {
+  const cached = NODE_MAJOR_CACHE.get(fp);
+  if (cached !== void 0) return cached;
+  const major = fp.nodeVersion.replace(/^v/, "").split(".")[0] ?? fp.nodeVersion;
+  NODE_MAJOR_CACHE.set(fp, major);
+  return major;
+}
+function compareMachineFingerprints(report, baseline) {
+  const differing = [];
+  if (report.arch !== baseline.arch) differing.push("arch");
+  if (report.platform !== baseline.platform) differing.push("platform");
+  if (nodeMajor(report) !== nodeMajor(baseline)) differing.push("nodeVersion(major)");
+  if (report.cpuModel !== null && baseline.cpuModel !== null && report.cpuModel !== baseline.cpuModel) {
+    differing.push("cpuModel");
   }
-  if (retrievalCheckPassed) {
-    stages.use = {
-      status: "fail",
-      detail: "Gold memory present in context but answer was incorrect"
+  if (report.cpuCores !== baseline.cpuCores) differing.push("cpuCores");
+  return { differingFields: differing };
+}
+function invalidFingerprintFields(fp) {
+  const bad = [];
+  if (typeof fp.arch !== "string") bad.push("arch");
+  if (typeof fp.platform !== "string") bad.push("platform");
+  if (typeof fp.nodeVersion !== "string") bad.push("nodeVersion");
+  if (typeof fp.cpuCores !== "number" || !Number.isFinite(fp.cpuCores)) bad.push("cpuCores");
+  if (fp.cpuModel !== null && typeof fp.cpuModel !== "string") bad.push("cpuModel");
+  return bad;
+}
+function checkCodingGraphRegression(report, baseline, tolerancePercent = DEFAULT_TOLERANCE_PERCENT) {
+  const reportFixture = report.fixture.config;
+  const baselineFixture = baseline.fixtureConfig;
+  const mismatchedKeys = Object.keys(baselineFixture).filter((key) => reportFixture[key] !== baselineFixture[key]);
+  if (mismatchedKeys.length > 0) {
+    const diffs = mismatchedKeys.map(
+      (key) => `${key}: report=${reportFixture[key]} baseline=${baselineFixture[key]}`
+    ).join(", ");
+    return {
+      passed: false,
+      regressions: [],
+      summary: `Fixture mismatch (${diffs}). Metrics are not comparable across different fixtures.`
     };
+  }
+  if (report.schemaVersion !== baseline.schemaVersion) {
     return {
-      goldMemory: goldStatement,
-      label: { class: "use_miss", reason: "Gold memory present in context but task failed" },
-      stages
+      passed: false,
+      regressions: [],
+      summary: `Schema-version mismatch: report=${report.schemaVersion} baseline=${baseline.schemaVersion}. Metrics are not comparable across schema versions \u2014 regenerate the baseline (#1688).`
     };
   }
-  if (stages.extraction.status === "pass" && indexCheckFailed) {
-    stages.use = { status: "unavailable", detail: "not reached" };
+  const metricChecks = [
+    ["incrementalUpdate.p50", report.incrementalUpdate?.p50],
+    ["incrementalUpdate.p95", report.incrementalUpdate?.p95],
+    ["incrementalModifiedUpdate.p50", report.incrementalModifiedUpdate?.p50],
+    ["incrementalModifiedUpdate.p95", report.incrementalModifiedUpdate?.p95],
+    ["tracePath.p95", report.tracePath?.p95],
+    ["searchGraph.p95", report.searchGraph?.p95],
+    ["fullIndexMs.ms", report.fullIndexMs?.ms],
+    ["fullIndexLocsPerSecond", report.fullIndexLocsPerSecond],
+    ["deadCodeMs.ms", report.deadCodeMs?.ms],
+    ["dbBytesPerKloc", report.dbBytesPerKloc]
+  ];
+  const missingFields = metricChecks.filter(([, v]) => typeof v !== "number" || !Number.isFinite(v)).map(([k]) => k);
+  if (missingFields.length > 0) {
     return {
-      goldMemory: goldStatement,
-      label: { class: "index_miss", reason: "Gold statement missing from search index" },
-      stages
+      passed: false,
+      regressions: [],
+      summary: "Report claims schemaVersion " + report.schemaVersion + " but is missing required metric field(s): " + missingFields.join(", ") + " \u2014 the report is incomplete or corrupt. Regenerate it (#1688)."
     };
   }
-  if (stages.extraction.status === "pass" && stages.index.status === "pass" && stages.retrieval.status === "fail") {
-    stages.use = { status: "unavailable", detail: "not reached" };
+  const badBaselineMetrics = Object.keys(METRIC_DIRECTION).filter((key) => {
+    const v = baseline.metrics[key];
+    return v != null && (typeof v !== "number" || !Number.isFinite(v));
+  });
+  if (badBaselineMetrics.length > 0) {
     return {
-      goldMemory: goldStatement,
-      label: {
-        class: "retrieval_miss",
-        retrievalStage: retrievalStageMiss ?? "unknown",
-        reason: stages.retrieval.detail
-      },
-      stages
+      passed: false,
+      regressions: [],
+      summary: "Baseline has a non-numeric required metric field(s): " + badBaselineMetrics.join(", ") + " \u2014 the baseline is corrupt. Regenerate it (#1688)."
     };
   }
-  const missingReason = stages.extraction.status === "unavailable" ? `extraction check unavailable (${stages.extraction.detail})` : stages.index.status === "unavailable" && stages.retrieval.status === "unavailable" ? "index/retrieval checks unavailable in this attribution environment" : stages.index.status === "unavailable" ? "index check unavailable; a retrieval miss cannot be isolated from an index miss" : "retrieval check unavailable";
-  stages.use = { status: "unavailable", detail: "not reached" };
-  return {
-    goldMemory: goldStatement,
-    label: { class: "unattributed", reason: missingReason },
-    stages
-  };
-}
-async function attributeTask(task, env, options = {}) {
-  const golds = task.goldMemories;
-  if (!golds || golds.length === 0) {
-    return null;
+  const reportFpBad = report.machine == null ? ["<missing>"] : invalidFingerprintFields(report.machine);
+  const baselineFpBad = baseline.machine == null ? ["<missing>"] : invalidFingerprintFields(baseline.machine);
+  if (reportFpBad.length > 0 || baselineFpBad.length > 0) {
+    const which = [];
+    if (reportFpBad.length > 0) which.push("report (" + reportFpBad.join(", ") + ")");
+    if (baselineFpBad.length > 0) which.push("baseline (" + baselineFpBad.join(", ") + ")");
+    return {
+      passed: false,
+      regressions: [],
+      summary: "Report or baseline machine fingerprint is missing or has an invalid field type(s): " + which.join("; ") + " \u2014 the artifact is incomplete or corrupt. Regenerate it (#1688)."
+    };
   }
-  const memoizedEnv = withMemoizedListMemories(env);
-  const recalledText = typeof task.details?.recalledText === "string" ? task.details.recalledText : void 0;
-  const goldAttributions = [];
-  for (const gold of golds) {
-    const attr = await attributeGoldMemory(gold, task.question, memoizedEnv, options, recalledText);
-    goldAttributions.push(attr);
+  const mismatch = compareMachineFingerprints(report.machine, baseline.machine);
+  if (mismatch.differingFields.length > 0) {
+    return {
+      passed: true,
+      skipped: true,
+      regressions: [],
+      summary: "Machine-fingerprint mismatch \u2014 comparison skipped to avoid a false-positive hardware-variance failure. Differing fields: " + mismatch.differingFields.join(", ") + ". Regenerate the baseline on this machine for a real comparison (#1688).",
+      machineMismatch: {
+        report: report.machine,
+        baseline: baseline.machine,
+        differingFields: mismatch.differingFields
+      }
+    };
   }
-  const overall = computeOverallLabel(goldAttributions);
-  return {
-    taskId: task.taskId,
-    question: task.question,
-    golds: goldAttributions,
-    overall
-  };
-}
-async function attributeRun(result, env, options = {}) {
-  const runId = result.meta?.runId ?? result.meta?.id ?? "unknown-run";
-  const memoizedEnv = withMemoizedListMemories(env);
-  const totals = {
-    extraction_miss: 0,
-    index_miss: 0,
-    retrieval_miss: 0,
-    use_miss: 0,
-    unattributed: 0
-  };
-  const retrievalStages = {
-    filter: 0,
-    cap: 0,
-    rank: 0,
-    unknown: 0
-  };
-  const items = [];
-  const skippedTasks = [];
-  for (const task of result.results.tasks) {
-    if (task.details?.benchmarkFailure && typeof task.details.benchmarkFailure === "object") {
-      skippedTasks.push({
-        taskId: task.taskId,
-        reason: "trial execution failure (not an answer failure)"
-      });
-      continue;
-    }
-    if (!task.goldMemories || task.goldMemories.length === 0) {
-      skippedTasks.push({
-        taskId: task.taskId,
-        reason: "No goldMemories specified"
-      });
-      continue;
-    }
-    if (!isTaskFailed(task)) {
-      skippedTasks.push({
-        taskId: task.taskId,
-        reason: "Task passed (score >= 1)"
+  const measured = extractMetrics(report);
+  const baselineMetrics = baseline.metrics;
+  const regressions = [];
+  for (const key of Object.keys(METRIC_DIRECTION)) {
+    const baseVal = baselineMetrics[key];
+    const measVal = measured[key];
+    if (baseVal == null || measVal == null) continue;
+    if (baseVal === 0) continue;
+    const direction = METRIC_DIRECTION[key];
+    const ratio2 = measVal / baseVal;
+    const percentChange2 = direction === "lower-is-better" ? (ratio2 - 1) * 100 : (1 - ratio2) * 100;
+    const regressed = percentChange2 > tolerancePercent;
+    if (regressed) {
+      regressions.push({
+        key,
+        baseline: baseVal,
+        measured: measVal,
+        percentChange: Math.round(percentChange2 * 10) / 10,
+        direction,
+        tolerancePercent,
+        regressed: true
       });
-      continue;
-    }
-    const taskAttr = await attributeTask(task, memoizedEnv, options);
-    if (taskAttr) {
-      items.push(taskAttr);
-    }
-  }
-  items.sort((a, b) => a.taskId < b.taskId ? -1 : a.taskId > b.taskId ? 1 : 0);
-  skippedTasks.sort((a, b) => a.taskId < b.taskId ? -1 : a.taskId > b.taskId ? 1 : 0);
-  for (const item of items) {
-    totals[item.overall.class]++;
-    if (item.overall.class === "retrieval_miss") {
-      const stage = item.overall.retrievalStage ?? "unknown";
-      retrievalStages[stage]++;
     }
   }
+  const passed = regressions.length === 0;
+  const summary = passed ? "All metrics within tolerance." : `${regressions.length} metric(s) regressed beyond ${tolerancePercent}% tolerance:
+` + regressions.map(
+    (r) => `  ${r.key}: ${r.baseline} \u2192 ${r.measured} (${r.percentChange > 0 ? "+" : ""}${r.percentChange}% vs baseline)`
+  ).join("\n");
+  return { passed, regressions, summary };
+}
+function buildBaselineFromReport(report, note) {
   return {
-    runId,
-    totals,
-    retrievalStages,
-    attributedTasks: items.length,
-    skippedTasks,
-    items
+    schemaVersion: report.schemaVersion,
+    machine: report.machine,
+    fixtureConfig: report.fixture.config,
+    metrics: extractMetrics(report),
+    createdAt: report.timestamp,
+    note
   };
 }
-function renderAttributionReportTable(report) {
-  const lines = [];
-  lines.push(`Attribution Report (Run: ${report.runId})`);
-  lines.push(`Failed-task predicate: minimum primary answer score < 1 (scores.overall or non-diagnostic scores)`);
-  lines.push(`Attributed tasks: ${report.attributedTasks}, Skipped tasks: ${report.skippedTasks.length}`);
-  lines.push("");
-  lines.push("Totals by Class:");
-  lines.push(`  extraction_miss: ${report.totals.extraction_miss}`);
-  lines.push(`  index_miss:      ${report.totals.index_miss}`);
-  lines.push(`  retrieval_miss:  ${report.totals.retrieval_miss}`);
-  lines.push(`  use_miss:        ${report.totals.use_miss}`);
-  lines.push(`  unattributed:    ${report.totals.unattributed}`);
-  lines.push("");
-  lines.push("Retrieval Miss Stages:");
-  lines.push(`  filter:  ${report.retrievalStages.filter}`);
-  lines.push(`  cap:     ${report.retrievalStages.cap}`);
-  lines.push(`  rank:    ${report.retrievalStages.rank}`);
-  lines.push(`  unknown: ${report.retrievalStages.unknown}`);
-  lines.push("");
-  lines.push("Task Attributions:");
-  if (report.items.length === 0) {
-    lines.push("  (none)");
-  } else {
-    for (const item of report.items) {
-      const stageStr = item.overall.retrievalStage ? ` (${item.overall.retrievalStage})` : "";
-      const labelStr = `${item.overall.class}${stageStr}`;
-      const reasonStr = item.overall.reason ? ` - ${item.overall.reason}` : "";
-      lines.push(`  ${item.taskId.padEnd(20)} ${labelStr.padEnd(24)}${reasonStr}`);
-    }
-  }
-  if (report.skippedTasks.length > 0) {
-    lines.push("");
-    lines.push("Skipped Tasks:");
-    for (const skipped of report.skippedTasks) {
-      lines.push(`  ${skipped.taskId.padEnd(20)} ${skipped.reason}`);
-    }
-  }
-  return `${lines.join("\n")}
-`;
-}
-function serializeAttributionReport(report) {
-  return `${JSON.stringify(report, null, 2)}
-`;
-}
 
 // src/attribute-cli.ts
+import { QmdClient } from "@remnic/core";
 import { lstat as lstat6, readdir as readdir8, readFile as readFile25 } from "fs/promises";
 import path40 from "path";
 function parseFrontmatter2(fileContent) {
@@ -46658,6 +47070,53 @@ async function scanMemoryDir(dirPath) {
   }
   return memories;
 }
+async function resolveQmdMemory(memoryDir, collection, resultPath) {
+  const root = path40.resolve(memoryDir);
+  const candidates = /* @__PURE__ */ new Set();
+  const addCandidate = (candidate) => {
+    const resolved = path40.resolve(candidate);
+    const relative = path40.relative(root, resolved);
+    if (relative !== ".." && !relative.startsWith(`..${path40.sep}`) && !path40.isAbsolute(relative)) {
+      candidates.add(resolved);
+    }
+  };
+  const addRelative = (relativePath) => {
+    const normalized = relativePath.replace(/\\/g, "/").replace(/^\/+/, "");
+    if (!normalized) return;
+    addCandidate(path40.join(root, normalized));
+    if (/^\d{4}-\d{2}-\d{2}\//.test(normalized)) {
+      addCandidate(path40.join(root, "facts", normalized));
+    }
+  };
+  if (path40.isAbsolute(resultPath)) {
+    addCandidate(resultPath);
+  } else {
+    addRelative(resultPath);
+    const normalized = resultPath.replace(/\\/g, "/").replace(/^\/+/, "");
+    if (normalized.startsWith(`${collection}/`)) {
+      addRelative(normalized.slice(collection.length + 1));
+    }
+  }
+  let resolvedMemory = null;
+  for (const candidate of candidates) {
+    try {
+      const stats = await lstat6(candidate);
+      if (!stats.isFile() || stats.isSymbolicLink()) continue;
+      const parsed = parseFrontmatter2(await readFile25(candidate, "utf8"));
+      if (!parsed.id || parsed.id.trim().length === 0) {
+        throw new Error("QMD result has no canonical frontmatter id");
+      }
+      const memory = { id: parsed.id, content: parsed.body.trim() };
+      if (resolvedMemory && resolvedMemory.id !== memory.id) {
+        throw new Error("QMD result path resolves to more than one canonical memory id");
+      }
+      resolvedMemory = memory;
+    } catch (error) {
+      if (error instanceof Error && error.message.startsWith("QMD result")) throw error;
+    }
+  }
+  return resolvedMemory;
+}
 async function runAttributeCliCommand(options) {
   const summary = await resolveBenchmarkResultReference(options.resultsDir, options.runRef);
   if (!summary) {
@@ -46677,6 +47136,12 @@ async function runAttributeCliCommand(options) {
 `
     };
   }
+  if (Boolean(options.qmdPath) !== Boolean(options.collection)) {
+    return {
+      exitCode: 1,
+      output: "Error: --qmd <path> and --collection <name> must be provided together.\n"
+    };
+  }
   let memorySnapshot;
   const listMemoriesFn = async () => {
     if (memorySnapshot) return memorySnapshot;
@@ -46697,14 +47162,64 @@ async function runAttributeCliCommand(options) {
   }
   const recallLimitRaw = result.config?.remnicConfig?.recallLimit;
   const recallLimit = typeof recallLimitRaw === "number" && recallLimitRaw > 0 ? recallLimitRaw : 10;
-  const rankMemories2 = async (query, limit) => (await listMemoriesFn()).map((memory) => ({ memory, score: lexicalSimilarity(query, memory.content) })).filter(({ score }) => score > 0).sort((a, b) => b.score - a.score || a.memory.id.localeCompare(b.memory.id)).slice(0, limit).map(({ memory }) => memory);
+  const needsLegacyFallback = result.results.tasks.some(
+    (task) => task.attributionWitness === void 0 && isTaskFailed(task) && Array.isArray(task.goldMemories) && task.goldMemories.length > 0 && !(task.details?.benchmarkFailure && typeof task.details.benchmarkFailure === "object")
+  );
+  if (needsLegacyFallback && options.qmdPath && !options.memoryDir) {
+    return {
+      exitCode: 1,
+      output: "Error: explicit legacy QMD fallback requires --memory-dir <path>.\n"
+    };
+  }
   const env = {
     listMemories: listMemoriesFn,
-    oracleSearch: async (query, limit) => (await rankMemories2(query, limit)).map(({ id }) => ({ id })),
-    recall: rankMemories2,
     recallLimit
   };
-  const report = await attributeRun(result, env, { threshold: options.threshold });
+  let qmdClient;
+  if (needsLegacyFallback && options.qmdPath && options.collection && options.memoryDir) {
+    qmdClient = new QmdClient(options.collection, recallLimit, {
+      qmdPath: options.qmdPath,
+      qmdStrictPath: true
+    });
+    const qmdAvailable = await qmdClient.probe().catch(() => false);
+    const search = async (query, limit) => {
+      if (!qmdAvailable) {
+        throw new Error("QMD unavailable");
+      }
+      const degradations = [];
+      const results = await qmdClient.search(
+        query,
+        options.collection,
+        limit,
+        void 0,
+        { onDegradation: (degradation) => degradations.push(degradation) }
+      );
+      if (degradations.length > 0) {
+        throw new Error("QMD search degraded");
+      }
+      const memories = [];
+      const seenIds = /* @__PURE__ */ new Set();
+      for (const resultItem of results) {
+        const memory = await resolveQmdMemory(options.memoryDir, options.collection, resultItem.path);
+        if (!memory) {
+          throw new Error("QMD result canonical identity unavailable");
+        }
+        if (!seenIds.has(memory.id)) {
+          seenIds.add(memory.id);
+          memories.push(memory);
+        }
+      }
+      return memories;
+    };
+    env.oracleSearch = async (query, limit) => (await search(query, limit)).map(({ id }) => ({ id }));
+    env.recall = search;
+  }
+  let report;
+  try {
+    report = await attributeRun(result, env, { threshold: options.threshold });
+  } finally {
+    await qmdClient?.dispose();
+  }
   const output = options.json ? serializeAttributionReport(report) : renderAttributionReportTable(report);
   return {
     exitCode: 0,