@remnic/bench 9.6.32 → 9.6.34

package/dist/index.js

@@ -8998,8 +8998,8 @@ function parseRetryAfterMs(value) {
   if (Number.isNaN(asNumber2)) {
     const dateMs = Date.parse(value);
     if (Number.isFinite(dateMs)) {
-      const delta = dateMs - Date.now();
-      return delta > 0 ? Math.min(delta, MAX_RETRY_AFTER_S * 1e3) : 0;
+      const delta2 = dateMs - Date.now();
+      return delta2 > 0 ? Math.min(delta2, MAX_RETRY_AFTER_S * 1e3) : 0;
     }
   }
   return void 0;
@@ -16394,11 +16394,11 @@ function tokenize(value) {
   return normalizeText(value).replace(/[^\w\s]/g, " ").split(/\s+/).filter((token) => token.length > 0);
 }
 function frequencyMap(tokens) {
-  const counts = /* @__PURE__ */ new Map();
+  const counts2 = /* @__PURE__ */ new Map();
   for (const token of tokens) {
-    counts.set(token, (counts.get(token) ?? 0) + 1);
+    counts2.set(token, (counts2.get(token) ?? 0) + 1);
   }
-  return counts;
+  return counts2;
 }
 function longestCommonSubsequence(left, right) {
   let previous = new Array(right.length + 1).fill(0);
@@ -16806,11 +16806,11 @@ function buildAmaBenchRecallQueries(qaPairs) {
   });
 }
 function questionCounts(qaPairs) {
-  const counts = /* @__PURE__ */ new Map();
+  const counts2 = /* @__PURE__ */ new Map();
   for (const qa of qaPairs) {
-    counts.set(qa.question, (counts.get(qa.question) ?? 0) + 1);
+    counts2.set(qa.question, (counts2.get(qa.question) ?? 0) + 1);
   }
-  return counts;
+  return counts2;
 }
 function isInventoryHistoryQuestion(question) {
   const normalized = question.toLowerCase();
@@ -19847,26 +19847,6 @@ import { collectTemporalLexicalCues } from "@remnic/core";
 import { readFile as readFile15 } from "fs/promises";
 import path17 from "path";
 
-// src/benchmarks/published/longmemeval/fixture.ts
-var LONG_MEM_EVAL_SMOKE_FIXTURE = [
-  {
-    question_id: 1,
-    question_type: "single-session-user",
-    question: "What city does the user live in?",
-    answer: "Paris",
-    question_date: "2025-01-01",
-    haystack_dates: ["2024-12-01"],
-    haystack_session_ids: ["session-1"],
-    haystack_sessions: [
-      [
-        { role: "user", content: "I moved to Paris last year." },
-        { role: "assistant", content: "Paris sounds great." }
-      ]
-    ],
-    answer_session_ids: ["session-1"]
-  }
-];
-
 // src/benchmarks/published/locomo/fixture.ts
 var LOCOMO_SMOKE_FIXTURE = [
   {
@@ -19916,6 +19896,26 @@ var LOCOMO_SMOKE_FIXTURE = [
   }
 ];
 
+// src/benchmarks/published/longmemeval/fixture.ts
+var LONG_MEM_EVAL_SMOKE_FIXTURE = [
+  {
+    question_id: 1,
+    question_type: "single-session-user",
+    question: "What city does the user live in?",
+    answer: "Paris",
+    question_date: "2025-01-01",
+    haystack_dates: ["2024-12-01"],
+    haystack_session_ids: ["session-1"],
+    haystack_sessions: [
+      [
+        { role: "user", content: "I moved to Paris last year." },
+        { role: "assistant", content: "Paris sounds great." }
+      ]
+    ],
+    answer_session_ids: ["session-1"]
+  }
+];
+
 // src/benchmarks/published/dataset-loader.ts
 var LONG_MEM_EVAL_DATASET_FILENAMES = Object.freeze([
   "longmemeval_oracle.json",
@@ -19963,6 +19963,7 @@ async function loadDataset4(options) {
         return {
           source: "dataset",
           filename,
+          sha256: hashString(raw),
           items: applyLimit4(parsed, limit),
           errors
         };
@@ -19978,6 +19979,7 @@ async function loadDataset4(options) {
   }
   return {
     source: "smoke",
+    sha256: hashCanonicalJson(options.smokeFixture),
     items: applyLimit4([...options.smokeFixture], limit),
     errors
   };
@@ -21263,11 +21265,12 @@ var locomoDefinition = {
   }
 };
 async function runLoCoMoBenchmark(options) {
-  const conversations = await loadDataset6(
+  const loaded = await loadLoCoMoDataset(
     options.mode,
     options.datasetDir,
     options.limit
   );
+  const conversations = loaded.items;
   const trialLimit = resolveTrialLimit(options.benchmarkOptions?.trialLimit);
   const multiHopRecallComposition = resolveLoCoMoBooleanOption(
     options.benchmarkOptions?.multiHopRecallComposition,
@@ -21276,7 +21279,7 @@ async function runLoCoMoBenchmark(options) {
   );
   const plans = applyTrialLimit(
     conversations.map(
-      (conversation) => buildPlan2(conversation, multiHopRecallComposition)
+      (conversation) => buildLoCoMoPlan(conversation, multiHopRecallComposition)
     ),
     trialLimit
   );
@@ -21347,7 +21350,7 @@ function applyTrialLimit(plans, trialLimit) {
   }
   return limitedPlans;
 }
-function buildPlan2(conversation, multiHopRecallComposition) {
+function buildLoCoMoPlan(conversation, multiHopRecallComposition) {
   const sessions = extractSessions(conversation.conversation);
   const speakerA = typeof conversation.conversation.speaker_a === "string" ? conversation.conversation.speaker_a : "Speaker A";
   const ingestSessions = [];
@@ -21383,9 +21386,9 @@ function buildTrial(conversationId, qa, questionIndex, sessionIds, multiHopRecal
     expected: qa.answer,
     recallSessionIds: sessionIds,
     answerFormat: "short-with-specifics",
-    recallTextTransform: ({ question, recalledText }) => prioritizeLoCoMoRecallText({
+    recallTextTransform: ({ question, recalledText }) => transformLoCoMoRecallText({
       question,
-      recalledText: sanitizeLoCoMoRecallText({ question, recalledText }),
+      recalledText,
       multiHopRecallComposition
     }),
     answerFallback: ({ question, recalledText }) => answerLoCoMoFromRecall(question, recalledText),
@@ -21586,10 +21589,20 @@ function sanitizeLoCoMoRecallText(args) {
     (id) => queryVisibleIds.has(id) ? id : ""
   );
 }
-function prioritizeLoCoMoRecallText(args) {
-  const lines = dedupePreserveOrder(
-    args.recalledText.replaceAll("\r\n", "\n").replaceAll("\r", "\n").split("\n").map((line) => line.trim()).filter((line) => line.length > 0)
-  );
+function transformLoCoMoRecallText(args) {
+  const sanitized = sanitizeLoCoMoRecallText(args);
+  return prioritizeLoCoMoRecallTextWithTrace({
+    ...args,
+    recalledText: sanitized
+  }).text;
+}
+function prioritizeLoCoMoRecallTextWithTrace(args) {
+  const inputLines = args.recalledText.replaceAll("\r\n", "\n").replaceAll("\r", "\n").split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
+  const lines = dedupePreserveOrder(inputLines);
+  const inputOrdinalByLine = /* @__PURE__ */ new Map();
+  inputLines.forEach((line, index) => {
+    if (!inputOrdinalByLine.has(line)) inputOrdinalByLine.set(line, index);
+  });
   const questionTokens = expandLoCoMoQuestionTokens(
     tokenizeForLoCoMo(args.question)
   );
@@ -21622,25 +21635,90 @@ function prioritizeLoCoMoRecallText(args) {
     )
   ];
   if (direct.length === 0 && linkedHops.length === 0) {
-    return truncateLoCoMoContext(
+    const { text: text2 } = truncateLoCoMoContext(
       args.recalledText,
       LOCOMO_FALLBACK_CONTEXT_MAX_CHARS
     );
+    return {
+      text: text2,
+      receipt: {
+        schemaVersion: 1,
+        mode: "fallback",
+        multiHopRecallComposition: args.multiHopRecallComposition,
+        input: digestLoCoMoContent(args.recalledText),
+        output: digestLoCoMoContent(text2),
+        selectedLines: []
+      }
+    };
   }
-  const sections = [
-    "## LoCoMo Question-Focused Evidence",
-    ...direct.map((entry) => truncateLoCoMoLine(entry.line))
-  ];
+  const sections = ["## LoCoMo Question-Focused Evidence"];
+  const selectedRanges = [];
+  const appendSelectedLine = (input, stage, hop) => {
+    const output = truncateLoCoMoLine(input);
+    const inputOrdinal = inputOrdinalByLine.get(input);
+    if (inputOrdinal === void 0) {
+      throw new Error("LoCoMo composition selected a line outside its normalized input.");
+    }
+    const outputStart = sections.join("\n").length + 1;
+    sections.push(output);
+    selectedRanges.push({
+      input,
+      output,
+      inputOrdinal,
+      stage,
+      ...hop === void 0 ? {} : { hop },
+      outputStart,
+      outputEnd: outputStart + output.length
+    });
+  };
+  for (const entry of direct) appendSelectedLine(entry.line, "direct");
   for (const hop of linkedHops) {
-    sections.push(
-      `## LoCoMo Linked Evidence (hop ${hop.hop})`,
-      ...hop.lines.map(truncateLoCoMoLine)
-    );
+    sections.push(`## LoCoMo Linked Evidence (hop ${hop.hop})`);
+    for (const line of hop.lines) appendSelectedLine(line, "linked", hop.hop);
   }
-  return truncateLoCoMoContext(
+  const truncation = truncateLoCoMoContext(
     sections.join("\n"),
     LOCOMO_FOCUSED_CONTEXT_MAX_CHARS
   );
+  const { text, safePrefixEnd } = truncation;
+  const selectedLines = selectedRanges.map((entry) => {
+    const visibleStart = Math.min(entry.outputStart, safePrefixEnd);
+    const visibleEnd = Math.min(entry.outputEnd, safePrefixEnd);
+    const visible = visibleEnd - visibleStart === entry.output.length;
+    return buildCompositionLineReceipt(entry, visible, visibleStart, visibleEnd);
+  });
+  return {
+    text,
+    receipt: {
+      schemaVersion: 1,
+      mode: "focused",
+      multiHopRecallComposition: args.multiHopRecallComposition,
+      input: digestLoCoMoContent(args.recalledText),
+      output: digestLoCoMoContent(text),
+      selectedLines
+    }
+  };
+}
+function buildCompositionLineReceipt(entry, visible, visibleStart, visibleEnd) {
+  return {
+    inputOrdinal: entry.inputOrdinal,
+    input: digestLoCoMoContent(entry.input),
+    output: digestLoCoMoContent(entry.output),
+    stage: entry.stage,
+    ...entry.hop === void 0 ? {} : { hop: entry.hop },
+    visible,
+    outputStart: entry.outputStart,
+    outputEnd: entry.outputEnd,
+    visibleStart,
+    visibleEnd
+  };
+}
+function digestLoCoMoContent(value) {
+  return {
+    sha256: hashString(value),
+    charCount: value.length,
+    lineCount: value.length === 0 ? 0 : value.split("\n").length
+  };
 }
 function composeLoCoMoLinkedEvidence(args) {
   if (args.direct.length === 0 || args.remainingLineBudget <= 0) {
@@ -21898,13 +21976,16 @@ function truncateLoCoMoLine(line) {
 }
 function truncateLoCoMoContext(text, maxChars) {
   if (text.length <= maxChars) {
-    return text;
+    return { text, safePrefixEnd: text.length };
   }
   const truncated = text.slice(0, maxChars);
   const lastNewline = truncated.lastIndexOf("\n");
   const safePrefix = lastNewline > 0 ? truncated.slice(0, lastNewline) : truncated;
-  return `${safePrefix}
-[LoCoMo context truncated to ${maxChars} characters]`;
+  return {
+    text: `${safePrefix}
+[LoCoMo context truncated to ${maxChars} characters]`,
+    safePrefixEnd: safePrefix.length
+  };
 }
 function countHiddenEvidenceIdsInRecall(evidence, question, recalledText) {
   const queryVisibleIds = collectDialogueIds(question);
@@ -21925,7 +22006,7 @@ function collectDialogueIds(text) {
 function escapeRegExp2(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-async function loadDataset6(mode, datasetDir, limit) {
+async function loadLoCoMoDataset(mode, datasetDir, limit) {
   const loaded = await loadLoCoMo10({
     mode,
     datasetDir,
@@ -21957,7 +22038,15 @@ async function loadDataset6(mode, datasetDir, limit) {
       "[remnic-bench] LoCoMo falling back to smoke fixture: " + loaded.errors.join(" | ")
     );
   }
-  return loaded.items;
+  if (!loaded.sha256) {
+    throw new Error("LoCoMo dataset loader did not provide a content hash.");
+  }
+  return {
+    source: loaded.source,
+    ...loaded.filename === void 0 ? {} : { filename: loaded.filename },
+    sha256: loaded.sha256,
+    items: loaded.items
+  };
 }
 function parseDataset2(raw, filename) {
   const parsed = JSON.parse(raw);
@@ -22241,7 +22330,7 @@ async function loadBeamDatasetPreview(options) {
   }
   let dataset;
   try {
-    dataset = await loadDataset7(
+    dataset = await loadDataset6(
       options.mode === "quick" ? "quick" : "full",
       options.datasetDir,
       options.limit
@@ -22280,7 +22369,7 @@ async function loadBeamDatasetPreview(options) {
   };
 }
 async function runBeamBenchmark(options) {
-  const dataset = await loadDataset7(options.mode, options.datasetDir, options.limit);
+  const dataset = await loadDataset6(options.mode, options.datasetDir, options.limit);
   const tasks = [];
   const taskFilter = normalizeBeamTaskFilter(
     options.benchmarkOptions?.taskFilter
@@ -22467,7 +22556,7 @@ async function runBeamBenchmark(options) {
     }
   };
 }
-async function loadDataset7(mode, datasetDir, limit) {
+async function loadDataset6(mode, datasetDir, limit) {
   const normalizedLimit = normalizeLimit5(limit);
   const ensureDatasetEntries = (entryCount) => {
     if (entryCount === 0) {
@@ -23653,7 +23742,7 @@ var personaMemDefinition = {
   }
 };
 async function runPersonaMemBenchmark(options) {
-  const samples = await loadDataset8(options.mode, options.datasetDir, options.limit);
+  const samples = await loadDataset7(options.mode, options.datasetDir, options.limit);
   const tasks = [];
   const totalTasks = samples.length;
   for (let sampleIndex = 0; sampleIndex < samples.length; sampleIndex += 1) {
@@ -23833,7 +23922,7 @@ async function runPersonaMemBenchmark(options) {
     }
   };
 }
-async function loadDataset8(mode, datasetDir, limit) {
+async function loadDataset7(mode, datasetDir, limit) {
   const normalizedLimit = normalizeLimit6(limit);
   const ensureDatasetSamples = (samples) => {
     if (samples.length === 0) {
@@ -24441,7 +24530,7 @@ var memBenchDefinition = {
   }
 };
 async function runMemBenchBenchmark(options) {
-  const dataset = await loadDataset9(options.mode, options.datasetDir, options.limit);
+  const dataset = await loadDataset8(options.mode, options.datasetDir, options.limit);
   const tasks = [];
   const totalTasks = dataset.length;
   for (const testCase of dataset) {
@@ -24615,7 +24704,7 @@ async function runMemBenchBenchmark(options) {
     }
   };
 }
-async function loadDataset9(mode, datasetDir, limit) {
+async function loadDataset8(mode, datasetDir, limit) {
   const normalizedLimit = normalizeLimit7(limit);
   const ensureDatasetCases = (cases) => {
     if (cases.length === 0) {
@@ -25646,7 +25735,7 @@ var memoryAgentBenchDefinition = {
   }
 };
 async function runMemoryAgentBenchBenchmark(options) {
-  const rawDataset = await loadDataset10(options.mode, options.datasetDir, options.limit);
+  const rawDataset = await loadDataset9(options.mode, options.datasetDir, options.limit);
   const trialLimit = resolveTrialLimit2(options.benchmarkOptions?.trialLimit);
   const benchmarkOptions = trialLimit === void 0 ? options.benchmarkOptions : { ...options.benchmarkOptions ?? {}, trialLimit };
   const dataset = applyTrialLimit2(rawDataset, trialLimit);
@@ -26365,11 +26454,11 @@ function officialF1(prediction, groundTruth) {
   return 2 * precision * recall / (precision + recall);
 }
 function countTokens(tokens) {
-  const counts = /* @__PURE__ */ new Map();
+  const counts2 = /* @__PURE__ */ new Map();
   for (const token of tokens) {
-    counts.set(token, (counts.get(token) ?? 0) + 1);
+    counts2.set(token, (counts2.get(token) ?? 0) + 1);
   }
-  return counts;
+  return counts2;
 }
 function extractRecommendationMovies(output, movieCandidates, aliasCounts) {
   let recommendationText = output;
@@ -26435,14 +26524,14 @@ function stripTrailingRecommendationPunctuation(value) {
   return value.replace(/^["'`]+/g, "").replace(/["'`.!?;:]+$/g, "").trim();
 }
 function countMovieAliases(movieCandidates) {
-  const counts = /* @__PURE__ */ new Map();
+  const counts2 = /* @__PURE__ */ new Map();
   for (const movie of movieCandidates) {
     for (const alias of movieAliases(movie)) {
       const normalizedAlias = alias.toLowerCase();
-      counts.set(normalizedAlias, (counts.get(normalizedAlias) ?? 0) + 1);
+      counts2.set(normalizedAlias, (counts2.get(normalizedAlias) ?? 0) + 1);
     }
   }
-  return counts;
+  return counts2;
 }
 function movieAliases(movie) {
   const aliases = [movie];
@@ -26619,7 +26708,7 @@ function decodeUrlComponentSafely(value) {
     return value;
   }
 }
-async function loadDataset10(mode, datasetDir, limit) {
+async function loadDataset9(mode, datasetDir, limit) {
   const normalizedLimit = normalizeLimit8(limit);
   const ensureDatasetItems = (items) => {
     if (items.length === 0) {
@@ -35522,10 +35611,10 @@ function uptakeLatency(log, corrections, cap) {
     let resolved = cap;
     let found = false;
     for (const entry of post) {
-      const delta = entry.turnIndex - correction.turnIndex;
-      if (delta > cap) break;
+      const delta2 = entry.turnIndex - correction.turnIndex;
+      if (delta2 > cap) break;
       if (probePassesForCorrection(entry, correction)) {
-        resolved = delta;
+        resolved = delta2;
         found = true;
         break;
       }
@@ -38369,11 +38458,11 @@ function compareResults(baseline, candidate, threshold = 0.05, lowerIsBetter = /
       candidate,
       metricName
     );
-    const delta = aggregate.mean - baselineAggregate.mean;
+    const delta2 = aggregate.mean - baselineAggregate.mean;
     const metricDelta = {
       baseline: baselineAggregate.mean,
       candidate: aggregate.mean,
-      delta,
+      delta: delta2,
       percentChange: percentChange(aggregate.mean, baselineAggregate.mean),
       effectSize: {
         cohensD: 0,
@@ -39194,6 +39283,1146 @@ function formatSignedScore2(value) {
   return `${value >= 0 ? "+" : ""}${formatScore2(value)}`;
 }
 
+// src/stats/locomo-retrieval-trace-delta.ts
+var LOCOMO_RETRIEVAL_TRACE_DELTA_SCHEMA_VERSION = 1;
+var CATEGORIES = ["single_hop", "multi_hop", "temporal", "open_domain", "adversarial"];
+var MECHANISMS = [
+  "real-core-visible-lcm-displacement",
+  "lcm-selection-change",
+  "composition-filter-displacement",
+  "composition-digest-change",
+  "budget-truncation-change",
+  "mixed",
+  "no-structural-delta",
+  "insufficient-exact-lineage"
+];
+function diagnoseLoCoMoRetrievalTraceDelta(baseline, real) {
+  assertReceipt(baseline, "baseline");
+  assertReceipt(real, "real");
+  assertComparable(baseline, real);
+  const tasks = baseline.tasks.map(
+    (baselineTask, index) => compareTask(baselineTask, real.tasks[index])
+  );
+  const overall = summarize(tasks);
+  const categories = CATEGORIES.filter((category) => tasks.some((task) => task.category === category)).map(
+    (category) => ({ category, ...summarize(tasks.filter((task) => task.category === category)) })
+  );
+  const multiHop = tasks.filter((task) => task.category === "multi_hop");
+  const candidates = MECHANISMS.filter(
+    (mechanism) => mechanism !== "no-structural-delta" && mechanism !== "insufficient-exact-lineage"
+  ).map((mechanism) => ({ mechanism, count: multiHop.filter((task) => task.mechanism === mechanism).length }));
+  candidates.sort((left, right) => right.count - left.count || left.mechanism.localeCompare(right.mechanism));
+  const dominant = candidates[0];
+  const supported = dominant !== void 0 && dominant.count >= 2 && dominant.count * 2 > multiHop.length;
+  const withoutHash = {
+    schemaVersion: LOCOMO_RETRIEVAL_TRACE_DELTA_SCHEMA_VERSION,
+    benchmarkId: "locomo",
+    analysisKind: "paired-retrieval-structural-delta",
+    sensitivity: {
+      classification: "restricted",
+      contentEncoding: "sha256+length",
+      containsGold: false,
+      containsRawContent: false,
+      containsRawIdentifiers: false
+    },
+    comparison: {
+      baselineArtifactHash: baseline.artifactHash,
+      realArtifactHash: real.artifactHash,
+      retrievalConfigHashesDiffer: true,
+      taskOrderSha256: hashCanonicalJson(baseline.tasks.map((task) => digestIdentifier(task.taskId)))
+    },
+    overall,
+    categories,
+    dominantMultiHopMechanism: {
+      status: supported ? "supported" : "not-supported",
+      ...supported && dominant ? { mechanism: dominant.mechanism } : {},
+      count: dominant?.count ?? 0,
+      taskCount: multiHop.length,
+      rule: "strict-majority-and-at-least-two"
+    },
+    tasks,
+    evidenceBoundary: {
+      attribution: "observed-structural-mechanism-only",
+      causalClaim: false,
+      exactLineageRequired: true,
+      explanation: "Labels summarize paired, content-free structural differences. The budget-truncation label denotes a fixed-budget tail-geometry transition with a stable recorded composition outcome; it does not prove identical prefix content. No label proves that a retrieval mechanism caused an answer or score change."
+    }
+  };
+  return { ...withoutHash, artifactHash: hashCanonicalJson(withoutHash) };
+}
+function serializeLoCoMoRetrievalTraceDelta(report) {
+  return `${canonicalJsonStringify(report, 2)}
+`;
+}
+function compareTask(baseline, real) {
+  const category = categoryOf(baseline.taskId);
+  const dimensions = {
+    sectionVisibleChars: delta(signatures(baseline, "sectionVisibleChars"), signatures(real, "sectionVisibleChars")),
+    selections: delta(signatures(baseline, "selections"), signatures(real, "selections")),
+    archiveRows: delta(signatures(baseline, "archiveRows"), signatures(real, "archiveRows")),
+    lcmCandidates: delta(signatures(baseline, "lcmCandidates"), signatures(real, "lcmCandidates")),
+    coreResults: delta(signatures(baseline, "coreResults"), signatures(real, "coreResults")),
+    coreFilters: delta(signatures(baseline, "coreFilters"), signatures(real, "coreFilters")),
+    coreBudget: delta(signatures(baseline, "coreBudget"), signatures(real, "coreBudget")),
+    recallBudget: delta(signatures(baseline, "recallBudget"), signatures(real, "recallBudget")),
+    compositionPolicy: delta(signatures(baseline, "compositionPolicy"), signatures(real, "compositionPolicy")),
+    compositionDigests: delta(signatures(baseline, "compositionDigests"), signatures(real, "compositionDigests"))
+  };
+  const hasCompleteExactLineage = (task) => {
+    return task.sessions.every((session) => {
+      const renderedSections = session.trace.sections.filter(
+        (section) => section.source === "lcm-summary" || section.source === "raw-row"
+      );
+      const lcmSelections = session.trace.selections.filter(
+        (selection) => selection.kind === "lcm-summary" || selection.kind === "raw-row"
+      );
+      const selectionMatchesSection = (selection) => renderedSections.some((section) => section.id === selection.sectionId && section.source === selection.kind);
+      const renderedLineageComplete = renderedSections.every(
+        (section) => lcmSelections.some(
+          (selection) => selection.sectionId === section.id && selection.kind === section.source && hasExactSelectionLineage(selection)
+        )
+      );
+      const candidateLineageComplete = session.trace.lcmCandidates.every(hasExactCandidateLineage);
+      const hasCarrier = renderedSections.length > 0 && renderedLineageComplete || renderedSections.length === 0 && lcmSelections.length === 0 && session.trace.lcmCandidates.length > 0 && candidateLineageComplete;
+      const hasLcmEvidence = renderedSections.length > 0 || lcmSelections.length > 0 || session.trace.lcmCandidates.length > 0;
+      return (!hasLcmEvidence || hasCarrier) && lcmSelections.every(selectionMatchesSection) && lcmSelections.every(hasExactSelectionLineage) && (renderedSections.length > 0 || candidateLineageComplete) && (session.trace.coreCapture?.results.every(
+        (result) => isSha256Hex(result.memoryIdRef.sha256) && result.memoryIdRef.length > 0
+      ) ?? true);
+    });
+  };
+  const exact = hasCompleteExactLineage(baseline) && hasCompleteExactLineage(real);
+  const lcmSelectionsChanged = delta(
+    exactSelectionSignatures(baseline, "lcm", "emitted"),
+    exactSelectionSignatures(real, "lcm", "emitted")
+  ).changed;
+  const lcmArchiveRowsChanged = delta(
+    exactArchiveRowSignatures(baseline, "lcm"),
+    exactArchiveRowSignatures(real, "lcm")
+  ).changed;
+  const auxiliarySelectionsChanged = delta(
+    exactSelectionSignatures(baseline, "auxiliary", "emitted"),
+    exactSelectionSignatures(real, "auxiliary", "emitted")
+  ).changed;
+  const auxiliaryArchiveRowsChanged = delta(
+    exactArchiveRowSignatures(baseline, "auxiliary"),
+    exactArchiveRowSignatures(real, "auxiliary")
+  ).changed;
+  const core = dimensions.coreResults.changed || dimensions.coreFilters.changed || dimensions.coreBudget.changed;
+  const baselineVisible = visibleCharsByGroup(baseline);
+  const realVisible = visibleCharsByGroup(real);
+  const coreSections = sectionGroupChanged(baseline, real, "core", "emitted");
+  const lcmSections = sectionGroupChanged(baseline, real, "lcm", "emitted");
+  const otherSections = sectionGroupChanged(baseline, real, "other", "emitted");
+  const lcm = lcmSections || lcmSelectionsChanged || lcmArchiveRowsChanged || dimensions.lcmCandidates.changed;
+  const auxiliary = auxiliarySelectionsChanged || auxiliaryArchiveRowsChanged;
+  const other = otherSections || auxiliary;
+  const composedSelectionsChanged = delta(
+    structuralSelectionSignatures(baseline, "all", "composed", false),
+    structuralSelectionSignatures(real, "all", "composed", false)
+  ).changed;
+  const allCandidatesChanged = delta(candidateSignatures(baseline, false), candidateSignatures(real, false)).changed;
+  const compositionPolicy = dimensions.compositionPolicy.changed;
+  const compositionDigests = dimensions.compositionDigests.changed;
+  const compositionOutcomeChanged = compositionOutcomeSignature(baseline) !== compositionOutcomeSignature(real);
+  const budget = dimensions.recallBudget.changed;
+  const coreVisibleLcmDisplacement = core && lcm && realVisible.core > baselineVisible.core && realVisible.lcm < baselineVisible.lcm && !other && !budget && !compositionPolicy;
+  const budgetTailGeometryTransition = budget && hasFixedBudgetTailGeometryTransition(baseline, real) && !core && !composedSelectionsChanged && !allCandidatesChanged && !compositionPolicy && !compositionOutcomeChanged;
+  let mechanism;
+  if (!exact) mechanism = "insufficient-exact-lineage";
+  else if (coreVisibleLcmDisplacement) mechanism = "real-core-visible-lcm-displacement";
+  else if (lcm && !core && !coreSections && !other && !budget && !compositionPolicy)
+    mechanism = "lcm-selection-change";
+  else if (budgetTailGeometryTransition) mechanism = "budget-truncation-change";
+  else if (compositionPolicy && !core && !coreSections && !lcm && !other && !budget)
+    mechanism = "composition-filter-displacement";
+  else if (compositionDigests && !compositionPolicy && !core && !coreSections && !lcm && !other && !budget)
+    mechanism = "composition-digest-change";
+  else if (!core && !coreSections && !lcm && !other && !budget && !compositionPolicy && !compositionDigests)
+    mechanism = "no-structural-delta";
+  else mechanism = "mixed";
+  return { taskRef: digestIdentifier(baseline.taskId), category, mechanism, dimensions };
+}
+function visibleCharsByGroup(task) {
+  const output = { core: 0, lcm: 0, other: 0 };
+  for (const session of task.sessions) {
+    for (const section of session.trace.sections) {
+      if (section.source === "core") {
+        output.core += section.visibleChars;
+      } else if (section.source === "lcm-summary" || section.source === "raw-row") {
+        output.lcm += section.visibleChars;
+      } else {
+        output.other += section.visibleChars;
+      }
+    }
+  }
+  return output;
+}
+function sectionGroupChanged(baseline, real, group, projection) {
+  const signaturesFor = (task) => {
+    const output = [];
+    task.sessions.forEach((session, sessionOrdinal) => {
+      session.trace.sections.forEach((section, sectionOrdinal) => {
+        if (sectionGroup(section.source) === group) {
+          output.push(structuralSectionSignature(section, sessionOrdinal, sectionOrdinal, projection));
+        }
+      });
+    });
+    return output;
+  };
+  return delta(signaturesFor(baseline), signaturesFor(real)).changed;
+}
+function sectionGroup(source) {
+  if (source === "core") return "core";
+  if (source === "lcm-summary" || source === "raw-row") return "lcm";
+  return "other";
+}
+function structuralSectionSignature(section, sessionOrdinal, sectionOrdinal, projection) {
+  return hashCanonicalJson({
+    sessionOrdinal,
+    sectionOrdinal,
+    sectionIdRef: digestIdentifier(section.id),
+    source: section.source,
+    separatorStart: section.separatorStart,
+    contentStart: section.contentStart,
+    contentEnd: section.contentEnd,
+    composedStart: section.composedStart,
+    composedEnd: section.composedEnd,
+    ...projection === "emitted" ? {
+      visibleStart: section.visibleStart,
+      visibleEnd: section.visibleEnd,
+      visibleChars: section.visibleChars
+    } : {}
+  });
+}
+function selectionInScope(selection, scope) {
+  const isLcm = selection.kind === "lcm-summary" || selection.kind === "raw-row";
+  return scope === "all" || (scope === "lcm" ? isLcm : !isLcm);
+}
+function exactSelectionSignatures(task, scope, projection) {
+  return structuralSelectionSignatures(task, scope, projection, true);
+}
+function structuralSelectionSignatures(task, scope, projection, exactOnly) {
+  const output = [];
+  task.sessions.forEach((session, sessionOrdinal) => {
+    for (const value of session.trace.selections) {
+      if (!selectionInScope(value, scope) || exactOnly && !hasExactSelectionLineage(value)) continue;
+      output.push(
+        hashCanonicalJson({
+          sessionOrdinal,
+          sectionIdRef: digestIdentifier(value.sectionId),
+          kind: value.kind,
+          lineageStatus: value.lineageStatus,
+          turnIndex: value.turnIndex,
+          role: value.role,
+          score: value.score,
+          summary: value.summary,
+          archiveRowIds: value.archiveRowIds,
+          composedStart: value.composedStart,
+          composedEnd: value.composedEnd,
+          ...projection === "emitted" ? {
+            visibleStart: value.visibleStart,
+            visibleEnd: value.visibleEnd
+          } : {}
+        })
+      );
+    }
+  });
+  return output;
+}
+function exactArchiveRowSignatures(task, scope) {
+  const output = [];
+  task.sessions.forEach((session, sessionOrdinal) => {
+    for (const value of session.trace.selections) {
+      if (!selectionInScope(value, scope) || !hasExactSelectionLineage(value)) continue;
+      for (const archiveRowId of value.archiveRowIds ?? []) {
+        output.push(hashCanonicalJson({ sessionOrdinal, archiveRowId }));
+      }
+    }
+  });
+  return output;
+}
+function hasExactSelectionLineage(selection) {
+  if (selection.lineageStatus !== "exact") return false;
+  if (selection.kind === "lcm-summary") {
+    return selection.summary !== void 0 && Number.isSafeInteger(selection.summary.depth) && selection.summary.depth >= 0 && Number.isSafeInteger(selection.summary.msgStart) && selection.summary.msgStart >= 0 && Number.isSafeInteger(selection.summary.msgEnd) && selection.summary.msgEnd >= selection.summary.msgStart;
+  }
+  return Array.isArray(selection.archiveRowIds) && selection.archiveRowIds.length > 0 && selection.archiveRowIds.every((id) => Number.isSafeInteger(id) && id > 0);
+}
+function hasExactCandidateLineage(candidate) {
+  return candidate.lineageStatus === "exact" && Number.isSafeInteger(candidate.archiveRowId) && candidate.archiveRowId > 0;
+}
+function candidateSignatures(task, exactOnly) {
+  const output = [];
+  task.sessions.forEach((session, sessionOrdinal) => {
+    for (const value of session.trace.lcmCandidates) {
+      if (exactOnly && !hasExactCandidateLineage(value)) continue;
+      output.push(
+        hashCanonicalJson({
+          sessionOrdinal,
+          rank: value.rank,
+          archiveRowId: value.archiveRowId,
+          turnIndex: value.turnIndex,
+          role: value.role,
+          score: value.score,
+          lineageStatus: value.lineageStatus
+        })
+      );
+    }
+  });
+  return output;
+}
+function signatures(task, dimension) {
+  if (dimension === "selections") return exactSelectionSignatures(task, "all", "emitted");
+  if (dimension === "archiveRows") return exactArchiveRowSignatures(task, "all");
+  if (dimension === "lcmCandidates") return candidateSignatures(task, true);
+  if (dimension === "recallBudget") {
+    return [
+      hashCanonicalJson({
+        recallBudgetChars: task.recallBudgetChars,
+        budgets: task.sessions.map((session) => ({
+          requestedChars: session.trace.budget.requestedChars,
+          truncated: session.trace.budget.truncated
+        }))
+      })
+    ];
+  }
+  if (dimension === "compositionPolicy") {
+    return [
+      hashCanonicalJson({
+        mode: task.composition.mode,
+        multiHopRecallComposition: task.composition.multiHopRecallComposition,
+        selectedLines: task.composition.selectedLines.map((line) => ({
+          inputOrdinal: line.inputOrdinal,
+          stage: line.stage,
+          hop: line.hop,
+          visible: line.visible,
+          outputStart: line.outputStart,
+          outputEnd: line.outputEnd,
+          visibleStart: line.visibleStart,
+          visibleEnd: line.visibleEnd
+        }))
+      })
+    ];
+  }
+  if (dimension === "compositionDigests") {
+    return [
+      hashCanonicalJson({
+        input: task.composition.input,
+        output: task.composition.output,
+        selectedLines: task.composition.selectedLines.map((line) => ({ input: line.input, output: line.output }))
+      })
+    ];
+  }
+  const output = [];
+  task.sessions.forEach((session, sessionOrdinal) => {
+    const trace2 = session.trace;
+    if (dimension === "sectionVisibleChars") {
+      trace2.sections.forEach((value, sectionOrdinal) => {
+        output.push(structuralSectionSignature(value, sessionOrdinal, sectionOrdinal, "emitted"));
+      });
+    } else if (dimension === "coreResults") {
+      for (const [resultOrdinal, value] of (trace2.coreCapture?.results ?? []).entries())
+        output.push(
+          hashCanonicalJson({
+            sessionOrdinal,
+            resultOrdinal,
+            memoryIdRef: value.memoryIdRef,
+            servedBy: value.servedBy,
+            scoreDecomposition: value.scoreDecomposition,
+            admittedBy: value.admittedBy,
+            rejectedBy: value.rejectedBy,
+            disclosure: value.disclosure,
+            estimatedTokens: value.estimatedTokens
+          })
+        );
+    } else if (dimension === "coreFilters") {
+      for (const value of trace2.coreCapture?.filters ?? [])
+        output.push(
+          hashCanonicalJson({
+            sessionOrdinal,
+            name: value.name,
+            considered: value.considered,
+            admitted: value.admitted
+          })
+        );
+    } else if (dimension === "coreBudget") {
+      if (trace2.coreCapture) output.push(hashCanonicalJson({ sessionOrdinal, ...trace2.coreCapture.budget }));
+    }
+  });
+  return output;
+}
+function compositionOutcomeSignature(task) {
+  return hashCanonicalJson({
+    output: task.composition.output,
+    selectedLines: task.composition.selectedLines.map((line) => ({ input: line.input, output: line.output }))
+  });
+}
+function hasFixedBudgetTailGeometryTransition(baseline, real) {
+  let sawTransition = false;
+  for (let index = 0; index < baseline.sessions.length; index += 1) {
+    const baselineSession = baseline.sessions[index];
+    const realSession = real.sessions[index];
+    const baselineTrace = baselineSession?.trace;
+    const realTrace = realSession?.trace;
+    if (!baselineSession || !realSession || !baselineTrace || !realTrace || baselineTrace.budget.requestedChars !== realTrace.budget.requestedChars) {
+      return false;
+    }
+    if (baselineTrace.budget.truncated === realTrace.budget.truncated) {
+      if (baselineTrace.budget.composedChars !== realTrace.budget.composedChars || baselineTrace.budget.returnedChars !== realTrace.budget.returnedChars || sectionGroupChanged(
+        { ...baseline, sessions: [baselineSession] },
+        { ...real, sessions: [realSession] },
+        "core",
+        "composed"
+      ) || sectionGroupChanged(
+        { ...baseline, sessions: [baselineSession] },
+        { ...real, sessions: [realSession] },
+        "lcm",
+        "composed"
+      ) || sectionGroupChanged(
+        { ...baseline, sessions: [baselineSession] },
+        { ...real, sessions: [realSession] },
+        "other",
+        "composed"
+      )) {
+        return false;
+      }
+      continue;
+    }
+    const shorter = baselineTrace.budget.truncated ? realTrace : baselineTrace;
+    const longer = baselineTrace.budget.truncated ? baselineTrace : realTrace;
+    const requested = shorter.budget.requestedChars;
+    if (shorter.budget.truncated || !longer.budget.truncated || shorter.budget.composedChars > requested || longer.budget.composedChars <= requested || shorter.budget.returnedChars !== shorter.budget.composedChars || longer.budget.returnedChars !== requested || shorter.sections.length === 0 || shorter.sections.length !== longer.sections.length) {
+      return false;
+    }
+    const finalIndex = shorter.sections.length - 1;
+    for (let sectionIndex = 0; sectionIndex < finalIndex; sectionIndex += 1) {
+      const shortSection = shorter.sections[sectionIndex];
+      const longSection = longer.sections[sectionIndex];
+      if (!shortSection || !longSection) return false;
+      if (structuralSectionSignature(shortSection, 0, sectionIndex, "composed") !== structuralSectionSignature(longSection, 0, sectionIndex, "composed")) {
+        return false;
+      }
+    }
+    const shortFinal = shorter.sections[finalIndex];
+    const longFinal = longer.sections[finalIndex];
+    if (!shortFinal || !longFinal) return false;
+    const extension = longFinal.composedEnd - shortFinal.composedEnd;
+    if (shortFinal.id !== longFinal.id || shortFinal.source !== longFinal.source || shortFinal.separatorStart !== longFinal.separatorStart || shortFinal.contentStart !== longFinal.contentStart || shortFinal.composedStart !== longFinal.composedStart || shortFinal.contentEnd !== shortFinal.composedEnd || longFinal.contentEnd !== longFinal.composedEnd || shortFinal.composedEnd !== shorter.budget.composedChars || longFinal.composedEnd !== longer.budget.composedChars || extension <= 0 || longFinal.contentEnd - shortFinal.contentEnd !== extension) {
+      return false;
+    }
+    sawTransition = true;
+  }
+  return sawTransition;
+}
+function delta(baseline, real) {
+  const realCounts = counts(real);
+  let sharedCount = 0;
+  for (const entry of baseline) {
+    const available = realCounts.get(entry) ?? 0;
+    if (available > 0) {
+      sharedCount += 1;
+      realCounts.set(entry, available - 1);
+    }
+  }
+  return {
+    baselineCount: baseline.length,
+    realCount: real.length,
+    sharedCount,
+    baselineOnlyCount: baseline.length - sharedCount,
+    realOnlyCount: real.length - sharedCount,
+    changed: sharedCount !== baseline.length || sharedCount !== real.length
+  };
+}
+function counts(values) {
+  const output = /* @__PURE__ */ new Map();
+  for (const value of values) output.set(value, (output.get(value) ?? 0) + 1);
+  return output;
+}
+function summarize(tasks) {
+  const mechanisms = Object.fromEntries(MECHANISMS.map((mechanism) => [mechanism, 0]));
+  for (const task of tasks) mechanisms[task.mechanism] += 1;
+  return { taskCount: tasks.length, mechanisms };
+}
+function digestIdentifier(value) {
+  return { sha256: hashString(value), length: value.length };
+}
+function categoryOf(taskId) {
+  const category = CATEGORIES.find((candidate) => taskId.endsWith(`-${candidate}`));
+  if (!category) throw new Error("LoCoMo retrieval trace task id has an unsupported category.");
+  return category;
+}
+function assertReceipt(receipt, label) {
+  if (!receipt || typeof receipt !== "object") throw new Error(`${label} receipt must be an object.`);
+  assertFiniteJson(receipt, `${label} receipt`);
+  assertExactKeys(
+    receipt,
+    ["schemaVersion", "benchmarkId", "captureKind", "artifactHash", "sensitivity", "provenance", "selection", "tasks"],
+    `${label} receipt`
+  );
+  assertExactKeys(
+    receipt.sensitivity,
+    ["classification", "contentEncoding", "containsGold", "containsRawContent"],
+    `${label} receipt.sensitivity`
+  );
+  assertExactKeys(
+    receipt.provenance,
+    [
+      "gitSha",
+      "remnicVersion",
+      "runtimeProfile",
+      "adapterMode",
+      "replayExtractionMode",
+      "providerFree",
+      "dataset",
+      "retrievalConfigSha256",
+      "recallBudget"
+    ],
+    `${label} receipt.provenance`
+  );
+  assertExactKeys(receipt.provenance.dataset, ["id", "sha256"], `${label} receipt.provenance.dataset`);
+  assertExactKeys(
+    receipt.provenance.recallBudget,
+    ["algorithm", "version"],
+    `${label} receipt.provenance.recallBudget`
+  );
+  assertExactKeys(
+    receipt.selection,
+    ["algorithm", "version", "seed", "candidateCount", "selectedCount", "selectedTaskIds", "selectedTaskIdsSha256"],
+    `${label} receipt.selection`
+  );
+  const { artifactHash, ...withoutHash } = receipt;
+  if (!isSha256Hex(artifactHash) || hashCanonicalJson(withoutHash) !== artifactHash) {
+    throw new Error(`${label} retrieval trace artifact hash verification failed.`);
+  }
+  if (receipt.schemaVersion !== 1 || receipt.benchmarkId !== "locomo" || receipt.captureKind !== "retrieval-only" || receipt.sensitivity.classification !== "restricted" || receipt.sensitivity.contentEncoding !== "sha256+length" || receipt.sensitivity.containsGold !== false || receipt.sensitivity.containsRawContent !== false || receipt.provenance.providerFree !== true || receipt.provenance.adapterMode !== "direct" || receipt.provenance.replayExtractionMode !== "skip" || receipt.provenance.dataset.id !== "locomo-10" || receipt.provenance.recallBudget.algorithm !== "benchmarkRecallBudgetForSessionCount" || receipt.provenance.recallBudget.version !== 1 || typeof receipt.provenance.gitSha !== "string" || receipt.provenance.gitSha.length === 0 || typeof receipt.provenance.remnicVersion !== "string" || receipt.provenance.remnicVersion.length === 0 || receipt.selection.version !== 1 || receipt.selection.algorithm !== "explicit-task-ids" && receipt.selection.algorithm !== "sha256-seeded-sample" || receipt.selection.algorithm === "explicit-task-ids" && receipt.selection.seed !== void 0 || receipt.selection.algorithm === "sha256-seeded-sample" && !isNonNegativeSafeInteger(receipt.selection.seed) || !Array.isArray(receipt.selection.selectedTaskIds) || receipt.selection.selectedTaskIds.some((taskId) => typeof taskId !== "string" || taskId.length === 0) || !Array.isArray(receipt.tasks) || !Number.isSafeInteger(receipt.selection.candidateCount) || !Number.isSafeInteger(receipt.selection.selectedCount) || receipt.selection.selectedCount <= 0 || receipt.selection.candidateCount < receipt.selection.selectedCount || receipt.selection.selectedCount !== receipt.tasks.length || receipt.selection.selectedTaskIds.length !== receipt.tasks.length || new Set(receipt.selection.selectedTaskIds).size !== receipt.selection.selectedTaskIds.length || new Set(receipt.tasks.map((task) => task.taskId)).size !== receipt.tasks.length || receipt.selection.selectedTaskIdsSha256 !== hashCanonicalJson(receipt.selection.selectedTaskIds) || receipt.selection.selectedTaskIds.some((taskId, index) => taskId !== receipt.tasks[index]?.taskId) || receipt.tasks.length === 0) {
+    throw new Error(`${label} retrieval trace receipt violates the restricted provider-free contract.`);
+  }
+  if (!isSha256Hex(receipt.provenance.dataset.sha256) || !isSha256Hex(receipt.provenance.retrievalConfigSha256)) {
+    throw new Error(`${label} retrieval trace receipt contains invalid provenance hashes.`);
+  }
+  for (const task of receipt.tasks) {
+    assertExactKeys(
+      task,
+      ["taskId", "question", "recallBudgetChars", "sessions", "composition"],
+      `${label} retrieval trace task`
+    );
+    if (typeof task.taskId !== "string" || task.taskId.length === 0 || !Array.isArray(task.sessions) || task.sessions.length === 0 || !isDigest(task.question) || !Number.isSafeInteger(task.recallBudgetChars) || task.recallBudgetChars < 0) {
+      throw new Error(`${label} retrieval trace task structure is invalid.`);
+    }
+    categoryOf(task.taskId);
+    assertComposition(task.composition, label);
+    for (const session of task.sessions) {
+      assertExactKeys(session, ["session", "trace"], `${label} retrieval trace session`);
+      const trace2 = session.trace;
+      const expectedComposedChars = Array.isArray(trace2.sections) ? trace2.sections.reduce((maximum, section) => Math.max(maximum, section.composedEnd), 0) : -1;
+      assertExactKeys(
+        trace2,
+        ["schemaVersion", "sensitivity", "sections", "selections", "lcmCandidates", "coreCapture", "budget"],
+        `${label} retrieval structural trace`
+      );
+      assertExactKeys(
+        trace2.sensitivity,
+        ["classification", "contentEncoding", "containsGold"],
+        `${label} retrieval trace sensitivity`
+      );
+      assertExactKeys(
+        trace2.budget,
+        ["requestedChars", "composedChars", "returnedChars", "truncated"],
+        `${label} retrieval trace budget`
+      );
+      if (!isDigest(session.session) || !trace2 || trace2.schemaVersion !== 1 || trace2.sensitivity.classification !== "restricted" || trace2.sensitivity.contentEncoding !== "sha256+length" || trace2.sensitivity.containsGold !== false || !Array.isArray(trace2.sections) || !Array.isArray(trace2.selections) || !Array.isArray(trace2.lcmCandidates) || new Set(trace2.sections.map((section) => section.id)).size !== trace2.sections.length || !isTraceBudget(trace2.budget) || trace2.budget.requestedChars !== task.recallBudgetChars || trace2.budget.composedChars !== expectedComposedChars || trace2.budget.returnedChars !== Math.min(trace2.budget.requestedChars, trace2.budget.composedChars) || trace2.budget.returnedChars > trace2.budget.composedChars || trace2.budget.truncated !== trace2.budget.returnedChars < trace2.budget.composedChars) {
+        throw new Error(`${label} retrieval trace session structure is invalid.`);
+      }
+      let previousContentEnd = 0;
+      for (const [sectionIndex, section] of trace2.sections.entries()) {
+        assertExactKeys(
+          section,
+          [
+            "id",
+            "source",
+            "separatorStart",
+            "contentStart",
+            "contentEnd",
+            "composedStart",
+            "composedEnd",
+            "visibleStart",
+            "visibleEnd",
+            "visibleChars"
+          ],
+          `${label} retrieval trace section`
+        );
+        const expectedVisibleStart = Math.min(section.composedStart, trace2.budget.returnedChars);
+        const expectedVisibleEnd = Math.max(
+          expectedVisibleStart,
+          Math.min(section.composedEnd, trace2.budget.returnedChars)
+        );
+        const expectedSeparatorStart = sectionIndex === 0 ? 0 : previousContentEnd;
+        const expectedContentStart = expectedSeparatorStart + (sectionIndex === 0 ? 0 : 2);
+        if (![
+          "derived",
+          "explicit-cue",
+          "trajectory-analysis",
+          "core",
+          "evidence-pack",
+          "lcm-summary",
+          "raw-row"
+        ].includes(section.source) || typeof section.id !== "string" || section.id.length === 0 || !isTraceRange(section) || ![section.separatorStart, section.contentStart, section.contentEnd].every(isNonNegativeSafeInteger) || section.separatorStart !== expectedSeparatorStart || section.contentStart !== expectedContentStart || section.contentEnd < section.contentStart || section.composedStart !== section.separatorStart || section.composedEnd !== section.contentEnd || !Number.isSafeInteger(section.visibleChars) || section.visibleChars < 0 || section.visibleStart !== expectedVisibleStart || section.visibleEnd !== expectedVisibleEnd || section.visibleChars !== expectedVisibleEnd - expectedVisibleStart) {
+          throw new Error(`${label} retrieval trace section structure is invalid.`);
+        }
+        previousContentEnd = section.contentEnd;
+      }
+      for (const selection of trace2.selections) {
+        assertExactKeys(
+          selection,
+          [
+            "sectionId",
+            "kind",
+            "lineageStatus",
+            "archiveRowIds",
+            "turnIndex",
+            "role",
+            "score",
+            "summary",
+            "composedStart",
+            "composedEnd",
+            "visibleStart",
+            "visibleEnd"
+          ],
+          `${label} retrieval trace selection`
+        );
+        if (selection.summary !== void 0) {
+          assertExactKeys(
+            selection.summary,
+            ["depth", "msgStart", "msgEnd"],
+            `${label} retrieval trace selection summary`
+          );
+        }
+        const selectedSection = trace2.sections.find((section) => section.id === selection.sectionId);
+        const expectedVisibleStart = Math.min(selection.composedStart, trace2.budget.returnedChars);
+        const expectedVisibleEnd = Math.max(
+          expectedVisibleStart,
+          Math.min(selection.composedEnd, trace2.budget.returnedChars)
+        );
+        if (!["evidence-block", "trajectory-line", "lcm-summary", "raw-row"].includes(selection.kind) || typeof selection.sectionId !== "string" || selection.sectionId.length === 0 || selectedSection === void 0 || selection.kind === "lcm-summary" && selectedSection.source !== "lcm-summary" || selection.kind === "raw-row" && selectedSection.source !== "raw-row" || selection.kind === "evidence-block" && selectedSection.source !== "explicit-cue" && selectedSection.source !== "evidence-pack" || selection.kind === "trajectory-line" && selectedSection.source !== "trajectory-analysis" || !isTraceRange(selection) || selection.composedStart < selectedSection.contentStart || selection.composedEnd > selectedSection.contentEnd || selection.visibleStart !== expectedVisibleStart || selection.visibleEnd !== expectedVisibleEnd || selection.lineageStatus !== "exact" && selection.lineageStatus !== "unavailable" || selection.turnIndex !== void 0 && !isNonNegativeSafeInteger(selection.turnIndex) || selection.role !== void 0 && typeof selection.role !== "string" || selection.score !== void 0 && !Number.isFinite(selection.score) || selection.summary !== void 0 && ![selection.summary.depth, selection.summary.msgStart, selection.summary.msgEnd].every(
+          isNonNegativeSafeInteger
+        ) || selection.archiveRowIds !== void 0 && (!Array.isArray(selection.archiveRowIds) || selection.archiveRowIds.some((id) => !Number.isSafeInteger(id) || id <= 0))) {
+          throw new Error(`${label} retrieval trace selection structure is invalid.`);
+        }
+      }
+      for (const candidate of trace2.lcmCandidates) {
+        assertExactKeys(
+          candidate,
+          ["rank", "archiveRowId", "turnIndex", "role", "score", "lineageStatus"],
+          `${label} retrieval trace LCM candidate`
+        );
+        if (candidate.lineageStatus !== "exact" && candidate.lineageStatus !== "unavailable" || !Number.isSafeInteger(candidate.rank) || candidate.rank < 0 || !isNonNegativeSafeInteger(candidate.turnIndex) || typeof candidate.role !== "string" || candidate.score !== void 0 && !Number.isFinite(candidate.score) || candidate.lineageStatus === "exact" && candidate.archiveRowId === void 0 || candidate.lineageStatus === "unavailable" && candidate.archiveRowId !== void 0 || candidate.archiveRowId !== void 0 && (!Number.isSafeInteger(candidate.archiveRowId) || candidate.archiveRowId <= 0)) {
+          throw new Error(`${label} retrieval trace LCM candidate structure is invalid.`);
+        }
+      }
+      if (trace2.coreCapture) {
+        assertExactKeys(trace2.coreCapture, ["budget", "filters", "results"], `${label} retrieval trace core capture`);
+        assertExactKeys(trace2.coreCapture.budget, ["chars", "used"], `${label} retrieval trace core budget`);
+        for (const filter of trace2.coreCapture.filters) {
+          assertExactKeys(filter, ["name", "considered", "admitted"], `${label} retrieval trace core filter`);
+          if (typeof filter.name !== "string" || !isNonNegativeSafeInteger(filter.considered) || !isNonNegativeSafeInteger(filter.admitted) || filter.admitted > filter.considered) {
+            throw new Error(`${label} retrieval trace core filter structure is invalid.`);
+          }
+        }
+        for (const result of trace2.coreCapture.results) {
+          assertExactKeys(
+            result,
+            [
+              "memoryIdRef",
+              "servedBy",
+              "scoreDecomposition",
+              "admittedBy",
+              "rejectedBy",
+              "disclosure",
+              "estimatedTokens"
+            ],
+            `${label} retrieval trace core result`
+          );
+          assertExactKeys(result.memoryIdRef, ["sha256", "length"], `${label} retrieval trace core memory reference`);
+          assertExactKeys(
+            result.scoreDecomposition,
+            ["vector", "bm25", "importance", "mmrPenalty", "tierPrior", "reinforcementBoost", "final"],
+            `${label} retrieval trace score decomposition`
+          );
+          if (typeof result.servedBy !== "string" || !Number.isFinite(result.scoreDecomposition.final) || !Object.values(result.scoreDecomposition).every((score) => score === void 0 || Number.isFinite(score)) || !Array.isArray(result.admittedBy) || result.admittedBy.some((reason) => typeof reason !== "string") || result.rejectedBy !== void 0 && typeof result.rejectedBy !== "string" || result.disclosure !== void 0 && !["chunk", "section", "raw"].includes(result.disclosure) || result.estimatedTokens !== void 0 && !isNonNegativeSafeInteger(result.estimatedTokens)) {
+            throw new Error(`${label} retrieval trace core result structure is invalid.`);
+          }
+        }
+        if (!isCountBudget(trace2.coreCapture.budget) || !Array.isArray(trace2.coreCapture.filters) || !Array.isArray(trace2.coreCapture.results) || trace2.coreCapture.results.some(
+          (result) => !isSha256Hex(result.memoryIdRef?.sha256) || !Number.isSafeInteger(result.memoryIdRef?.length) || result.memoryIdRef.length <= 0
+        )) {
+          throw new Error(`${label} retrieval trace core capture structure is invalid.`);
+        }
+      }
+    }
+  }
+}
+function assertComposition(composition, label) {
+  assertExactKeys(
+    composition,
+    ["schemaVersion", "mode", "multiHopRecallComposition", "input", "output", "selectedLines"],
+    `${label} retrieval trace composition`
+  );
+  if (!composition || composition.schemaVersion !== 1 || composition.mode !== "focused" && composition.mode !== "fallback" || typeof composition.multiHopRecallComposition !== "boolean" || !isDigest(composition.input) || !isDigest(composition.output) || !Array.isArray(composition.selectedLines)) {
+    throw new Error(`${label} retrieval trace composition structure is invalid.`);
+  }
+  let previousOutputEnd = -1;
+  for (const line of composition.selectedLines) {
+    assertExactKeys(
+      line,
+      [
+        "inputOrdinal",
+        "input",
+        "output",
+        "stage",
+        "hop",
+        "visible",
+        "outputStart",
+        "outputEnd",
+        "visibleStart",
+        "visibleEnd"
+      ],
+      `${label} retrieval trace composition line`
+    );
+    if (!isNonNegativeSafeInteger(line.inputOrdinal) || !isDigest(line.input) || !isDigest(line.output) || line.stage !== "direct" && line.stage !== "linked" || line.hop !== void 0 && !isNonNegativeSafeInteger(line.hop) || typeof line.visible !== "boolean" || ![line.outputStart, line.outputEnd, line.visibleStart, line.visibleEnd].every(isNonNegativeSafeInteger) || line.outputStart < previousOutputEnd || line.outputEnd < line.outputStart || line.outputEnd - line.outputStart !== line.output.charCount || line.visibleEnd < line.visibleStart || line.visibleStart > line.outputStart || line.visibleEnd > line.outputEnd || line.visibleEnd > composition.output.charCount || line.visibleStart < line.outputStart && line.visibleStart !== line.visibleEnd || line.visible !== (line.visibleStart === line.outputStart && line.visibleEnd === line.outputEnd)) {
+      throw new Error(`${label} retrieval trace composition line structure is invalid.`);
+    }
+    previousOutputEnd = line.outputEnd;
+  }
+}
+function assertExactKeys(value, allowed, label) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`${label} must be an object.`);
+  }
+  const allowedKeys = new Set(allowed);
+  if (Object.keys(value).some((key) => !allowedKeys.has(key))) {
+    throw new Error(`${label} contains an unsupported field.`);
+  }
+}
+function isNonNegativeSafeInteger(value) {
+  return Number.isSafeInteger(value) && value >= 0;
+}
+function isTraceRange(value) {
+  return [value.composedStart, value.composedEnd, value.visibleStart, value.visibleEnd].every(isNonNegativeSafeInteger) && value.composedEnd >= value.composedStart && value.visibleEnd >= value.visibleStart;
+}
+function isTraceBudget(value) {
+  if (!value || typeof value !== "object") return false;
+  const budget = value;
+  return [budget.requestedChars, budget.composedChars, budget.returnedChars].every(
+    (entry) => Number.isSafeInteger(entry) && entry >= 0
+  ) && typeof budget.truncated === "boolean";
+}
+function isCountBudget(value) {
+  if (!value || typeof value !== "object") return false;
+  const budget = value;
+  return [budget.chars, budget.used].every((entry) => Number.isSafeInteger(entry) && entry >= 0);
+}
+function assertFiniteJson(value, label) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") return;
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) throw new Error(`${label} contains a non-finite number.`);
+    return;
+  }
+  if (Array.isArray(value)) {
+    value.forEach((entry, index) => assertFiniteJson(entry, `${label}[${index}]`));
+    return;
+  }
+  if (!value || typeof value !== "object") throw new Error(`${label} is not canonical JSON.`);
+  for (const [key, entry] of Object.entries(value)) {
+    if (entry === void 0) throw new Error(`${label}.${key} is undefined.`);
+    assertFiniteJson(entry, `${label}.${key}`);
+  }
+}
+function assertComparable(baseline, real) {
+  if (baseline.provenance.runtimeProfile !== "baseline" || real.provenance.runtimeProfile !== "real") {
+    throw new Error("Paired retrieval traces require baseline and real runtime profiles in that order.");
+  }
+  const matching = [
+    [baseline.schemaVersion, real.schemaVersion],
+    [baseline.benchmarkId, real.benchmarkId],
+    [baseline.provenance.gitSha, real.provenance.gitSha],
+    [baseline.provenance.remnicVersion, real.provenance.remnicVersion],
+    [baseline.provenance.dataset.sha256, real.provenance.dataset.sha256],
+    [baseline.provenance.recallBudget.version, real.provenance.recallBudget.version],
+    [baseline.selection.selectedTaskIdsSha256, real.selection.selectedTaskIdsSha256],
+    [canonicalJsonStringify(baseline.selection), canonicalJsonStringify(real.selection)],
+    [baseline.tasks.length, real.tasks.length]
+  ];
+  if (matching.some(([left, right]) => left !== right))
+    throw new Error("Paired retrieval trace provenance does not match.");
+  if (baseline.provenance.retrievalConfigSha256 === real.provenance.retrievalConfigSha256) {
+    throw new Error("Paired retrieval traces must use different baseline and real retrieval configuration hashes.");
+  }
+  baseline.tasks.forEach((left, index) => {
+    const right = real.tasks[index];
+    if (!right || left.taskId !== right.taskId || canonicalJsonStringify(left.question) !== canonicalJsonStringify(right.question) || left.recallBudgetChars !== right.recallBudgetChars || left.sessions.length !== right.sessions.length || left.composition.multiHopRecallComposition !== right.composition.multiHopRecallComposition) {
+      throw new Error(`Paired retrieval trace task mismatch at index ${index}.`);
+    }
+    left.sessions.forEach((session, sessionIndex) => {
+      const other = right.sessions[sessionIndex];
+      if (!other || canonicalJsonStringify(session.session) !== canonicalJsonStringify(other.session)) {
+        throw new Error(`Paired retrieval trace session mismatch at task ${index}, session ${sessionIndex}.`);
+      }
+      if (session.trace.budget.requestedChars !== other.trace.budget.requestedChars) {
+        throw new Error(`Paired retrieval trace budget mismatch at task ${index}, session ${sessionIndex}.`);
+      }
+    });
+  });
+}
+function isDigest(value) {
+  if (!value || typeof value !== "object") return false;
+  if (Object.keys(value).some((key) => !["sha256", "charCount", "lineCount"].includes(key))) return false;
+  const digest = value;
+  return isSha256Hex(digest.sha256) && Number.isSafeInteger(digest.charCount) && digest.charCount >= 0 && Number.isSafeInteger(digest.lineCount) && digest.lineCount >= 0;
+}
+
+// src/benchmarks/published/locomo/retrieval-trace-runner.ts
+var LOCOMO_RETRIEVAL_TRACE_SCHEMA_VERSION = 1;
+var LOCOMO_RETRIEVAL_TRACE_SELECTION_VERSION = 1;
+var LOCOMO_RETRIEVAL_TRACE_BUDGET_VERSION = 1;
+async function preflightLoCoMoRetrievalTraceCapture(options) {
+  assertCaptureOptions(options);
+  assertProviderFreeRetrievalConfig(options.retrievalConfig);
+  const loaded = await loadLoCoMoDataset("full", options.datasetDir);
+  const multiHopRecallComposition = options.multiHopRecallComposition ?? true;
+  const plans = loaded.items.map((conversation) => buildLoCoMoPlan(conversation, multiHopRecallComposition));
+  const selectable = plans.flatMap(
+    (plan, planIndex) => plan.trials.map((trial) => ({ taskId: trial.taskId, planIndex }))
+  );
+  selectLoCoMoRetrievalTraceTasks(selectable, options.selector);
+}
+function buildProviderFreeLoCoMoRetrievalConfig(retrievalConfig) {
+  const sanitized = sanitizeProviderFreeRetrievalConfig(retrievalConfig);
+  return assertProviderFreeRetrievalConfig({
+    ...sanitized,
+    localLlmEnabled: false,
+    localLlmFastEnabled: false,
+    recallPlannerEnabled: false,
+    embeddingFallbackEnabled: false,
+    hostEmbeddingProviderEnabled: false,
+    openaiApiKey: false,
+    modelSource: "plugin"
+  });
+}
+async function captureLoCoMoRetrievalTrace(options) {
+  assertCaptureOptions(options);
+  const retrievalConfig = assertProviderFreeRetrievalConfig(options.retrievalConfig);
+  const recallWithTrace = options.system.recallWithTrace?.bind(options.system);
+  if (!recallWithTrace) {
+    throw new Error("LoCoMo retrieval trace capture requires system.recallWithTrace().");
+  }
+  const loaded = await loadLoCoMoDataset("full", options.datasetDir);
+  const multiHopRecallComposition = options.multiHopRecallComposition ?? true;
+  const plans = loaded.items.map((conversation) => buildLoCoMoPlan(conversation, multiHopRecallComposition));
+  const selectable = plans.flatMap(
+    (plan, planIndex) => plan.trials.map(
+      (trial) => ({
+        taskId: trial.taskId,
+        question: trial.question,
+        recallSessionIds: [...trial.recallSessionIds],
+        planIndex
+      })
+    )
+  );
+  const selection = selectLoCoMoRetrievalTraceTasks(selectable, options.selector);
+  const selectedIds = new Set(selection.selectedTaskIds);
+  const tasks = [];
+  for (let planIndex = 0; planIndex < plans.length; planIndex += 1) {
+    const selected = selectable.filter((task) => task.planIndex === planIndex && selectedIds.has(task.taskId));
+    if (selected.length === 0) continue;
+    const plan = plans[planIndex];
+    if (!plan) throw new Error(`Missing LoCoMo plan at index ${planIndex}.`);
+    await options.system.reset();
+    for (const session of plan.ingestSessions) {
+      if (session.messages.length > 0) {
+        await options.system.store(session.sessionId, session.messages);
+      }
+    }
+    await options.system.drain?.();
+    for (const selectedTask of selected) {
+      const recallBudgetChars = benchmarkRecallBudgetForSessionCount(selectedTask.recallSessionIds.length);
+      const recalled = await Promise.all(
+        selectedTask.recallSessionIds.map(async (sessionId) => {
+          const result = await recallWithTrace(sessionId, selectedTask.question, recallBudgetChars);
+          return {
+            text: result.text,
+            receipt: {
+              session: digestContent(sessionId),
+              trace: sanitizeStructuralTrace(result.trace)
+            }
+          };
+        })
+      );
+      const rawRecalledText = recalled.map((entry) => entry.text).filter(Boolean).join("\n\n");
+      const sanitized = sanitizeLoCoMoRecallText({
+        question: selectedTask.question,
+        recalledText: rawRecalledText
+      });
+      const composition = prioritizeLoCoMoRecallTextWithTrace({
+        question: selectedTask.question,
+        recalledText: sanitized,
+        multiHopRecallComposition
+      });
+      tasks.push({
+        taskId: selectedTask.taskId,
+        question: digestContent(selectedTask.question),
+        recallBudgetChars,
+        sessions: recalled.map((entry) => entry.receipt),
+        composition: composition.receipt
+      });
+    }
+  }
+  const withoutHash = {
+    schemaVersion: LOCOMO_RETRIEVAL_TRACE_SCHEMA_VERSION,
+    benchmarkId: "locomo",
+    captureKind: "retrieval-only",
+    sensitivity: {
+      classification: "restricted",
+      contentEncoding: "sha256+length",
+      containsGold: false,
+      containsRawContent: false
+    },
+    provenance: {
+      gitSha: options.gitSha,
+      remnicVersion: options.remnicVersion,
+      runtimeProfile: options.runtimeProfile,
+      adapterMode: "direct",
+      replayExtractionMode: "skip",
+      providerFree: true,
+      dataset: { id: "locomo-10", sha256: loaded.sha256 },
+      retrievalConfigSha256: hashCanonicalJson(retrievalConfig),
+      recallBudget: {
+        algorithm: "benchmarkRecallBudgetForSessionCount",
+        version: LOCOMO_RETRIEVAL_TRACE_BUDGET_VERSION
+      }
+    },
+    selection,
+    tasks
+  };
+  return {
+    ...withoutHash,
+    artifactHash: hashCanonicalJson(withoutHash)
+  };
+}
+function selectLoCoMoRetrievalTraceTasks(tasks, selector) {
+  const allIds = tasks.map((task) => task.taskId);
+  if (new Set(allIds).size !== allIds.length) {
+    throw new Error("LoCoMo retrieval trace task ids must be unique.");
+  }
+  let selected;
+  let algorithm;
+  let seed;
+  const hasTaskIds = "taskIds" in selector && selector.taskIds !== void 0;
+  const hasSampleSize = "sampleSize" in selector && selector.sampleSize !== void 0;
+  if (Number(hasTaskIds) + Number(hasSampleSize) !== 1) {
+    throw new Error("Choose exactly one LoCoMo retrieval trace selector.");
+  }
+  if (hasTaskIds && "seed" in selector && selector.seed !== void 0) {
+    throw new Error("LoCoMo retrieval trace seed is valid only for seeded sampling.");
+  }
+  if (hasTaskIds) {
+    algorithm = "explicit-task-ids";
+    const requestedTaskIds = selector.taskIds;
+    if (!requestedTaskIds) throw new Error("LoCoMo explicit task ids are required.");
+    const requested = [...requestedTaskIds];
+    if (requested.length === 0) {
+      throw new Error("LoCoMo retrieval trace explicit task selection cannot be empty.");
+    }
+    if (new Set(requested).size !== requested.length) {
+      throw new Error("LoCoMo retrieval trace explicit task ids must not contain duplicates.");
+    }
+    const available = new Set(allIds);
+    const unknown = requested.filter((taskId) => !available.has(taskId));
+    if (unknown.length > 0) {
+      throw new Error(`Unknown LoCoMo retrieval trace task id: ${unknown[0]}`);
+    }
+    const requestedSet = new Set(requested);
+    selected = allIds.filter((taskId) => requestedSet.has(taskId));
+  } else {
+    algorithm = "sha256-seeded-sample";
+    const sampleSize = selector.sampleSize;
+    seed = selector.seed;
+    if (sampleSize === void 0 || seed === void 0) {
+      throw new Error("LoCoMo seeded sampling requires sampleSize and seed.");
+    }
+    if (!Number.isSafeInteger(sampleSize) || sampleSize <= 0 || sampleSize > allIds.length) {
+      throw new Error(`LoCoMo retrieval trace sampleSize must be an integer from 1 to ${allIds.length}.`);
+    }
+    if (!Number.isSafeInteger(seed) || seed < 0) {
+      throw new Error("LoCoMo retrieval trace seed must be a non-negative safe integer.");
+    }
+    const sampled = [...allIds].sort((left, right) => {
+      const leftHash = hashString(`${seed}\0${left}`);
+      const rightHash = hashString(`${seed}\0${right}`);
+      return leftHash.localeCompare(rightHash) || left.localeCompare(right);
+    }).slice(0, sampleSize);
+    const sampledSet = new Set(sampled);
+    selected = allIds.filter((taskId) => sampledSet.has(taskId));
+  }
+  return {
+    algorithm,
+    version: LOCOMO_RETRIEVAL_TRACE_SELECTION_VERSION,
+    ...seed === void 0 ? {} : { seed },
+    candidateCount: allIds.length,
+    selectedCount: selected.length,
+    selectedTaskIds: selected,
+    selectedTaskIdsSha256: hashCanonicalJson(selected)
+  };
+}
+function serializeLoCoMoRetrievalTraceReceipt(receipt) {
+  return `${canonicalJsonStringify(receipt, 2)}
+`;
+}
+function sanitizeStructuralTrace(trace2) {
+  return {
+    schemaVersion: trace2.schemaVersion,
+    sensitivity: { ...trace2.sensitivity },
+    sections: trace2.sections.map((section) => ({ ...section })),
+    selections: trace2.selections.map(({ summary, ...selection }) => ({
+      ...selection,
+      ...selection.archiveRowIds === void 0 ? {} : { archiveRowIds: [...selection.archiveRowIds] },
+      ...summary === void 0 ? {} : { summary: { depth: summary.depth, msgStart: summary.msgStart, msgEnd: summary.msgEnd } }
+    })),
+    lcmCandidates: trace2.lcmCandidates.map((candidate) => ({ ...candidate })),
+    ...trace2.coreCapture === void 0 ? {} : {
+      coreCapture: {
+        budget: { ...trace2.coreCapture.budget },
+        filters: trace2.coreCapture.filters.map((filter) => ({ ...filter })),
+        results: trace2.coreCapture.results.map((result) => {
+          assertMemoryIdRef(result.memoryIdRef);
+          const score = result.scoreDecomposition;
+          return {
+            memoryIdRef: {
+              sha256: result.memoryIdRef.sha256,
+              length: result.memoryIdRef.length
+            },
+            servedBy: result.servedBy,
+            scoreDecomposition: {
+              ...score.vector === void 0 ? {} : { vector: score.vector },
+              ...score.bm25 === void 0 ? {} : { bm25: score.bm25 },
+              ...score.importance === void 0 ? {} : { importance: score.importance },
+              ...score.mmrPenalty === void 0 ? {} : { mmrPenalty: score.mmrPenalty },
+              ...score.tierPrior === void 0 ? {} : { tierPrior: score.tierPrior },
+              ...score.reinforcementBoost === void 0 ? {} : { reinforcementBoost: score.reinforcementBoost },
+              final: score.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 }
+          };
+        })
+      }
+    },
+    budget: { ...trace2.budget }
+  };
+}
+function digestContent(value) {
+  return {
+    sha256: hashString(value),
+    charCount: value.length,
+    lineCount: value.length === 0 ? 0 : value.split("\n").length
+  };
+}
+function assertCaptureOptions(options) {
+  if (!options.datasetDir.trim()) {
+    throw new Error("LoCoMo retrieval trace capture requires datasetDir.");
+  }
+  if (options.runtimeProfile !== "baseline" && options.runtimeProfile !== "real") {
+    throw new Error('LoCoMo retrieval trace runtimeProfile must be "baseline" or "real".');
+  }
+  if (!options.gitSha.trim() || !options.remnicVersion.trim() || options.gitSha === "unknown" || options.remnicVersion === "unknown") {
+    throw new Error("LoCoMo retrieval trace provenance requires gitSha and remnicVersion.");
+  }
+  if (options.providerFreeConfirmed !== true) {
+    throw new Error("LoCoMo retrieval trace capture requires explicit provider-free confirmation.");
+  }
+}
+function assertProviderFreeRetrievalConfig(value) {
+  const config = assertJsonConfig(value);
+  for (const key of [
+    "localLlmEnabled",
+    "localLlmFastEnabled",
+    "recallPlannerEnabled",
+    "embeddingFallbackEnabled",
+    "hostEmbeddingProviderEnabled",
+    "openaiApiKey"
+  ]) {
+    if (config[key] !== false) {
+      throw new Error(`retrievalConfig.${key} must be false for provider-free capture.`);
+    }
+  }
+  if (config.modelSource !== "plugin") {
+    throw new Error('retrievalConfig.modelSource must be "plugin" for provider-free capture.');
+  }
+  return config;
+}
+function assertMemoryIdRef(value) {
+  if (!value || typeof value !== "object" || !/^[0-9a-f]{64}$/u.test(value.sha256) || !Number.isSafeInteger(value.length) || value.length <= 0) {
+    throw new Error("LoCoMo retrieval trace requires a valid content-free memoryIdRef.");
+  }
+}
+function assertJsonConfig(value, path40 = "retrievalConfig") {
+  if (value === null || typeof value === "string" || typeof value === "boolean") return value;
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) throw new Error(`${path40} must contain only finite JSON numbers.`);
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((entry, index) => assertJsonConfig(entry, `${path40}[${index}]`));
+  }
+  if (!value || typeof value !== "object") {
+    throw new Error(`${path40} must be JSON-serializable and provider-free.`);
+  }
+  const output = {};
+  for (const key of Object.keys(value).sort()) {
+    const child = value[key];
+    if (key === "openaiApiKey") {
+      if (child !== false) {
+        throw new Error(`${path40}.${key} must be exactly false for provider-free capture.`);
+      }
+      output[key] = false;
+      continue;
+    }
+    if (isSecretKey(key)) {
+      throw new Error(`${path40}.${key} contains secret-bearing configuration.`);
+    }
+    if (child === void 0) continue;
+    if (/^(?:gatewayConfig|gatewayAgentId|fastGatewayAgentId|internalProvider|llmProvider|llmModel)$/iu.test(key) || key === "modelSource" && child !== "plugin") {
+      throw new Error(`${path40}.${key} is provider-capable configuration.`);
+    }
+    output[key] = assertJsonConfig(child, `${path40}.${key}`);
+  }
+  return output;
+}
+function sanitizeProviderFreeRetrievalConfig(value, path40 = "retrievalConfig") {
+  if (value === null || typeof value === "string" || typeof value === "boolean") return value;
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) throw new Error(`${path40} must contain only finite JSON numbers.`);
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((entry, index) => sanitizeProviderFreeRetrievalConfig(entry, `${path40}[${index}]`));
+  }
+  if (!value || typeof value !== "object") {
+    throw new Error(`${path40} must be JSON-serializable.`);
+  }
+  const output = {};
+  for (const key of Object.keys(value).sort()) {
+    const child = value[key];
+    if (child === void 0) continue;
+    if (isSecretKey(key) || /^(?:gatewayConfig|gatewayAgentId|fastGatewayAgentId|internalProvider|llmProvider|llmModel)$/iu.test(key) || key === "modelSource") {
+      continue;
+    }
+    output[key] = sanitizeProviderFreeRetrievalConfig(child, `${path40}.${key}`);
+  }
+  return output;
+}
+
 // src/integrity/sealed-qrels.ts
 import { readFile as readFile20 } from "fs/promises";
 function isSealedQrelsArtifact(value) {
@@ -43064,6 +44293,10 @@ export {
   LOCOMO_FULL_TASK_COUNT,
   LOCOMO_RECALL_DIFF_LINE_LIMIT,
   LOCOMO_RECALL_EXCERPT_CHARS,
+  LOCOMO_RETRIEVAL_TRACE_BUDGET_VERSION,
+  LOCOMO_RETRIEVAL_TRACE_DELTA_SCHEMA_VERSION,
+  LOCOMO_RETRIEVAL_TRACE_SCHEMA_VERSION,
+  LOCOMO_RETRIEVAL_TRACE_SELECTION_VERSION,
   LONG_MEM_EVAL_DATASET_FILENAMES,
   LettaMemCorrectAdapter,
   LocalLabPreflightError,
@@ -43120,10 +44353,12 @@ export {
   buildCodexCreditReceipt,
   buildJudgePayload,
   buildOracleTrajectoryRecall,
+  buildProviderFreeLoCoMoRetrievalConfig,
   buildSchemaTierFixture,
   buildSchemaTierSmokeFixture,
   calendarFixture,
   canonicalJsonStringify,
+  captureLoCoMoRetrievalTrace,
   captureMachineFingerprint,
   chatFixture,
   checkCodingGraphRegression,
@@ -43174,6 +44409,7 @@ export {
   defaultBenchmarkBaselineDir,
   defaultBenchmarkPublishPath,
   deleteBenchmarkResults,
+  diagnoseLoCoMoRetrievalTraceDelta,
   diagnoseLoComoProfileDelta,
   diagnoseLoComoRecallDelta,
   discoverAllProviders,
@@ -43192,6 +44428,7 @@ export {
   getAblationCell,
   getBenchmark,
   getBenchmarkLowerIsBetter,
+  getGitSha,
   getMemoryEvalDimension,
   getProviderBackedJudgePromptIdentity,
   getRemnicVersion,
@@ -43245,6 +44482,7 @@ export {
   parseSealedQrels,
   pickStableQualifiedName,
   precisionAtK,
+  preflightLoCoMoRetrievalTraceCapture,
   preflightLocalLabRole,
   projectFolderFixture,
   recallAtK,
@@ -43300,6 +44538,8 @@ export {
   selectFixtureVariant,
   serializeBenchmarkArtifact,
   serializeJsonl,
+  serializeLoCoMoRetrievalTraceDelta,
+  serializeLoCoMoRetrievalTraceReceipt,
   serializeSealedQrels,
   shuffleTasks,
   timed,