@remnic/bench 9.6.31 → 9.6.33

package/dist/index.js

@@ -597,7 +597,7 @@ var LettaMemCorrectAdapter = class {
 var REQUIRED_FRONTMATTER_FIELDS = ["title", "type", "state", "created", "see-also"];
 
 // src/adapters/remnic-adapter.ts
-import { createHash } from "crypto";
+import { createHash as createHash2 } from "crypto";
 import { execFile } from "child_process";
 import {
   chmod,
@@ -629,6 +629,226 @@ import {
   parseEntityFile,
   serializeEntityFile
 } from "@remnic/core";
+import {
+  lcmEvidenceIdentity
+} from "@remnic/core/lcm";
+
+// src/adapters/remnic-recall-trace.ts
+import { createHash } 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: createHash("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;
@@ -1264,7 +1484,7 @@ function benchCoreMemoryTier(memory) {
   return memory.path.includes(`${path.sep}cold${path.sep}`) ? "cold" : "hot";
 }
 function benchCoreMemorySource(sessionId) {
-  return `bench-replay-${createHash("sha256").update(sessionId).digest("hex").slice(0, 16)}`;
+  return `bench-replay-${createHash2("sha256").update(sessionId).digest("hex").slice(0, 16)}`;
 }
 function resolveSessionScopedCorrectionDecision(plan, ownedIds, phase) {
   const actionTargets = [];
@@ -2009,7 +2229,8 @@ function createAdapterFactory(mode) {
       }
       return correctionAccess.service;
     };
-    return {
+    const composeRecall = /* @__PURE__ */ Symbol("benchRecallComposer");
+    const adapter = {
       async store(sessionId, messages, control) {
         throwIfBenchPhaseAborted(control, "store");
         sessionId = normalizeBenchSessionId(sessionId);
@@ -2128,7 +2349,7 @@ function createAdapterFactory(mode) {
           throw error;
         }
       },
-      async recall(sessionId, query, budgetChars, recallOptions = {}, control) {
+      async [composeRecall](sessionId, query, budgetChars, recallOptions = {}, control, traceRecorder) {
         throwIfBenchPhaseAborted(control, "recall");
         const waitForRecall = (promise) => withBenchPhaseAbort(promise, control, "recall");
         sessionId = normalizeBenchSessionId(sessionId);
@@ -2150,6 +2371,10 @@ function createAdapterFactory(mode) {
           );
         }
         const sections = [];
+        const appendSection = (id, source, rendered) => {
+          traceRecorder?.appendSection(id, source, rendered.length);
+          sections.push(rendered);
+        };
         let usedChars = 0;
         const explicitReferences = historicalRecall ? [] : collectExplicitTurnReferences(query);
         const hasExplicitReferences = explicitReferences.length > 0;
@@ -2175,7 +2400,7 @@ function createAdapterFactory(mode) {
           }));
           if (temporalIntervalEvidence) {
             hasTemporalIntervalEvidence = true;
-            sections.push(temporalIntervalEvidence);
+            appendSection("temporal-interval", "derived", temporalIntervalEvidence);
             usedChars += temporalIntervalEvidence.length;
           }
         }
@@ -2187,7 +2412,7 @@ function createAdapterFactory(mode) {
           }));
           if (dependencyVersionEvidence) {
             hasDependencyVersionEvidence = true;
-            sections.push(dependencyVersionEvidence);
+            appendSection("dependency-version", "derived", dependencyVersionEvidence);
             usedChars += dependencyVersionEvidence.length;
           }
         }
@@ -2199,7 +2424,7 @@ function createAdapterFactory(mode) {
             maxChars: Math.min(3e3, Math.floor(budget * 0.25))
           }));
           if (latestQuantitativeEvidence) {
-            sections.push(latestQuantitativeEvidence);
+            appendSection("latest-quantitative", "derived", latestQuantitativeEvidence);
             usedChars += latestQuantitativeEvidence.length;
           }
         }
@@ -2211,10 +2436,11 @@ function createAdapterFactory(mode) {
           }));
           if (userImplementationTargetEvidence) {
             hasUserImplementationTargetEvidence = true;
-            sections.push(userImplementationTargetEvidence);
+            appendSection("implementation-targets", "derived", userImplementationTargetEvidence);
             usedChars += userImplementationTargetEvidence.length;
           }
         }
+        const explicitCueSelections = [];
         const exactReferenceEvidence = historicalRecall || hasDependencyVersionEvidence ? "" : await waitForRecall(buildExplicitCueRecallSection({
           engine,
           sessionId,
@@ -2223,12 +2449,17 @@ function createAdapterFactory(mode) {
           maxItemChars: CORE_EXPLICIT_CUE_MAX_ITEM_CHARS,
           maxReferences: CORE_EXPLICIT_CUE_MAX_REFERENCES,
           includeBenchmarkAnchorCues: sessionId.startsWith("beam-"),
-          includeStructuredPlanCues: sessionId.startsWith("arena-")
+          includeStructuredPlanCues: sessionId.startsWith("arena-"),
+          ...traceRecorder ? { onEvidenceSelected: (receipt) => {
+            explicitCueSelections.push(receipt);
+          } } : {}
         }));
         if (exactReferenceEvidence) {
-          sections.push(exactReferenceEvidence);
+          appendSection("explicit-cue", "explicit-cue", exactReferenceEvidence);
+          traceRecorder?.recordEvidenceSelections("explicit-cue", explicitCueSelections);
           usedChars += exactReferenceEvidence.length;
         }
+        const trajectorySelections = [];
         const trajectoryAnalysisEvidence = !historicalRecall && sessionId.startsWith("ama-") ? await waitForRecall(buildTrajectoryAnalysisRecallSection({
           engine,
           sessionId,
@@ -2236,10 +2467,17 @@ function createAdapterFactory(mode) {
           maxChars: Math.min(
             CORE_TRAJECTORY_ANALYSIS_MAX_CHARS,
             Math.max(0, Math.floor((budget - usedChars) * 0.55))
-          )
+          ),
+          ...traceRecorder ? { onLineSelected: (receipt) => {
+            trajectorySelections.push(receipt);
+          } } : {}
         })) : "";
         if (trajectoryAnalysisEvidence) {
-          sections.push(trajectoryAnalysisEvidence);
+          appendSection("trajectory-analysis", "trajectory-analysis", trajectoryAnalysisEvidence);
+          traceRecorder?.recordTrajectorySelections(
+            "trajectory-analysis",
+            trajectorySelections
+          );
           usedChars += trajectoryAnalysisEvidence.length;
         }
         if (includeCoreRecall && !requireDirectPersonalHistoryEvidence && !requireDirectTemporalEvidence && !hasTemporalIntervalEvidence && !hasDependencyVersionEvidence && !hasUserImplementationTargetEvidence) {
@@ -2252,17 +2490,27 @@ function createAdapterFactory(mode) {
               )
             )
           );
-          const coreRecall = await waitForRecall(
-            state.orchestrator.recall(query, sessionId, {
-              budgetCharsOverride: coreBudget,
-              mode: "full",
-              ...recallAsOf ? { asOf: recallAsOf } : {}
-            })
+          const coreOptions = {
+            budgetCharsOverride: coreBudget,
+            mode: "full",
+            ...control?.signal ? { abortSignal: control.signal } : {},
+            ...recallAsOf ? { asOf: recallAsOf } : {}
+          };
+          const coreRecall = traceRecorder ? await withBenchPhaseAbort(
+            state.orchestrator.recallWithXrayCapture(query, sessionId, coreOptions),
+            control,
+            "recall",
+            { waitForCompletionOnAbort: true }
+          ).then((capture) => {
+            traceRecorder.recordCoreCapture(capture.snapshot);
+            return capture.result;
+          }) : await waitForRecall(
+            state.orchestrator.recall(query, sessionId, coreOptions)
           );
           if (coreRecall.trim().length > 0) {
             const section = `## Remnic recall pipeline
 ${coreRecall.trim()}`;
-            sections.push(section);
+            appendSection("core", "core", section);
             usedChars += section.length;
           }
         }
@@ -2273,7 +2521,7 @@ ${coreRecall.trim()}`;
               "## Remnic historical recall",
               `No historically valid Remnic memories matched this query as of ${recallAsOf}.`
             ].join("\n");
-            sections.push(section);
+            appendSection("historical-empty", "derived", section);
             usedChars += section.length;
           }
         }
@@ -2289,6 +2537,30 @@ ${coreRecall.trim()}`;
               sessionId
             )
           );
+          const exactSearchHits = /* @__PURE__ */ new Map();
+          const uniqueLegacySearchHits = /* @__PURE__ */ new Map();
+          const ambiguousLegacySearchHitIds = /* @__PURE__ */ new Set();
+          searchResults.forEach((result, rank) => {
+            const identity = lcmEvidenceIdentity(result, result.session_id);
+            if (identity.archiveRowId !== void 0 && !exactSearchHits.has(identity.id)) {
+              exactSearchHits.set(identity.id, result);
+            } else if (identity.archiveRowId === void 0) {
+              if (uniqueLegacySearchHits.has(identity.id)) {
+                uniqueLegacySearchHits.delete(identity.id);
+                ambiguousLegacySearchHitIds.add(identity.id);
+              } else if (!ambiguousLegacySearchHitIds.has(identity.id)) {
+                uniqueLegacySearchHits.set(identity.id, result);
+              }
+            }
+            traceRecorder?.recordLcmCandidate({
+              rank: rank + 1,
+              ...identity.archiveRowId === void 0 ? {} : { archiveRowId: identity.archiveRowId },
+              turnIndex: result.turn_index,
+              role: result.role,
+              ...typeof result.score === "number" ? { score: result.score } : {},
+              lineageStatus: identity.archiveRowId === void 0 ? "unavailable" : "exact"
+            });
+          });
           if (searchResults.length > 0) {
             const evidenceItems = [];
             const directTemporalEvidenceItems = [];
@@ -2307,8 +2579,20 @@ ${coreRecall.trim()}`;
                   includeCoreRecall ? 1600 : 600
                 )
               );
+              const expandedIdentityCounts = /* @__PURE__ */ new Map();
+              for (const message of expanded) {
+                const expandedIdentity = lcmEvidenceIdentity(
+                  message,
+                  result.session_id
+                );
+                expandedIdentityCounts.set(
+                  expandedIdentity.id,
+                  (expandedIdentityCounts.get(expandedIdentity.id) ?? 0) + 1
+                );
+              }
               if (expanded.length === 0) {
-                const id = `${result.session_id}:${result.turn_index}`;
+                const identity = lcmEvidenceIdentity(result, result.session_id);
+                const { id } = identity;
                 if (!directTemporalTurnIds.has(id) && shouldIncludeDirectTemporalEvidence(
                   result.content,
                   query,
@@ -2317,6 +2601,7 @@ ${coreRecall.trim()}`;
                   directTemporalTurnIds.add(id);
                   directTemporalEvidenceItems.push({
                     id,
+                    ...identity.archiveRowId === void 0 ? {} : { archiveRowId: identity.archiveRowId },
                     sessionId: result.session_id,
                     turnIndex: result.turn_index,
                     role: result.role,
@@ -2336,6 +2621,7 @@ ${coreRecall.trim()}`;
                   seenTurns.add(id);
                   evidenceItems.push({
                     id,
+                    ...identity.archiveRowId === void 0 ? {} : { archiveRowId: identity.archiveRowId },
                     sessionId: result.session_id,
                     turnIndex: result.turn_index,
                     role: result.role,
@@ -2346,7 +2632,10 @@ ${coreRecall.trim()}`;
                 continue;
               }
               for (const message of expanded) {
-                const id = `${result.session_id}:${message.turn_index}`;
+                const identity = lcmEvidenceIdentity(message, result.session_id);
+                const { id } = identity;
+                const attributableSearchHit = identity.archiveRowId === void 0 ? expandedIdentityCounts.get(identity.id) === 1 ? uniqueLegacySearchHits.get(identity.id) : void 0 : exactSearchHits.get(identity.id);
+                const attributableScore = typeof attributableSearchHit?.score === "number" ? attributableSearchHit.score : void 0;
                 if (seenTurns.has(id)) continue;
                 if (!directTemporalTurnIds.has(id) && shouldIncludeDirectTemporalEvidence(
                   message.content,
@@ -2356,11 +2645,12 @@ ${coreRecall.trim()}`;
                   directTemporalTurnIds.add(id);
                   directTemporalEvidenceItems.push({
                     id,
+                    ...identity.archiveRowId === void 0 ? {} : { archiveRowId: identity.archiveRowId },
                     sessionId: result.session_id,
                     turnIndex: message.turn_index,
                     role: message.role,
                     content: message.content,
-                    ...message.turn_index === result.turn_index && typeof result.score === "number" ? { score: result.score } : {}
+                    ...attributableScore === void 0 ? {} : { score: attributableScore }
                   });
                 }
                 if (!shouldIncludeFocusedSearchEvidence(
@@ -2377,18 +2667,23 @@ ${coreRecall.trim()}`;
                 seenTurns.add(id);
                 evidenceItems.push({
                   id,
+                  ...identity.archiveRowId === void 0 ? {} : { archiveRowId: identity.archiveRowId },
                   sessionId: result.session_id,
                   turnIndex: message.turn_index,
                   role: message.role,
                   content: message.content,
-                  ...message.turn_index === result.turn_index && typeof result.score === "number" ? { score: result.score } : {}
+                  ...attributableScore === void 0 ? {} : { score: attributableScore }
                 });
               }
             }
+            const directTemporalSelections = [];
             const directTemporalEvidence = buildEvidencePack(directTemporalEvidenceItems, {
               title: "Direct temporal evidence",
               maxChars: Math.min(searchBudget, 3e3),
-              maxItemChars: 900
+              maxItemChars: 900,
+              ...traceRecorder ? { onSelection: (receipt) => {
+                directTemporalSelections.push(receipt);
+              } } : {}
             });
             let remainingSearchBudget = searchBudget;
             if (directTemporalEvidence) {
@@ -2396,7 +2691,11 @@ ${coreRecall.trim()}`;
                 directTemporalEvidence,
                 "These direct temporal statements match the question wording. Prefer them over indirect schedule-update context unless the question asks for the latest or current value."
               ].join("\n\n");
-              sections.push(section);
+              appendSection("direct-temporal", "evidence-pack", section);
+              traceRecorder?.recordEvidenceSelections(
+                "direct-temporal",
+                directTemporalSelections
+              );
               usedChars += section.length;
               remainingSearchBudget = 0;
             }
@@ -2405,19 +2704,27 @@ ${coreRecall.trim()}`;
               evidenceItems
             );
             if (contradictionGuidance) {
-              sections.push(contradictionGuidance);
+              appendSection("contradiction-guidance", "derived", contradictionGuidance);
               usedChars += contradictionGuidance.length;
             }
+            const searchSelections = [];
             const searchEvidence = buildEvidencePack(
               directTemporalEvidence ? evidenceItems.filter((item) => !directTemporalTurnIds.has(item.id)) : evidenceItems,
               {
                 title: "Search evidence",
                 maxChars: remainingSearchBudget,
-                maxItemChars: 900
+                maxItemChars: 900,
+                ...traceRecorder ? { onSelection: (receipt) => {
+                  searchSelections.push(receipt);
+                } } : {}
               }
             );
             if (searchEvidence) {
-              sections.push(searchEvidence);
+              appendSection("search-evidence", "evidence-pack", searchEvidence);
+              traceRecorder?.recordEvidenceSelections(
+                "search-evidence",
+                searchSelections
+              );
               usedChars += searchEvidence.length;
             }
           }
@@ -2429,17 +2736,26 @@ ${coreRecall.trim()}`;
               "## Remnic recall sufficiency",
               "No direct evidence found for the requested personal background or previous development projects in this session."
             ].join("\n");
-            sections.push(section);
+            appendSection("personal-history-empty", "derived", section);
             usedChars += section.length;
           }
         }
         if (!suppressBroadSummary) {
           const summaryBudget = Math.max(0, budget - usedChars - 4);
-          const recallText = await waitForRecall(
+          const summaryCapture = traceRecorder && engine.assembleRecallWithTrace ? await waitForRecall(
+            engine.assembleRecallWithTrace(sessionId, summaryBudget)
+          ) : void 0;
+          const recallText = summaryCapture?.text ?? await waitForRecall(
             engine.assembleRecall(sessionId, summaryBudget)
           );
           if (recallText) {
-            sections.push(recallText);
+            appendSection("lcm-summary", "lcm-summary", recallText);
+            if (summaryCapture) {
+              traceRecorder?.recordSummarySelections(
+                "lcm-summary",
+                summaryCapture.selectedSummaries
+              );
+            }
           }
         }
         if (!historicalRecall && sections.length === 0) {
@@ -2455,16 +2771,50 @@ ${coreRecall.trim()}`;
               )
             );
             if (expanded.length > 0) {
-              sections.push(
-                `## Raw messages
-${expanded.map((message) => `[${message.role}]: ${message.content}`).join("\n")}`
+              const prefix = "## Raw messages\n";
+              const rows = expanded.map(
+                (message) => `[${message.role}]: ${message.content}`
               );
+              const rawSection = `${prefix}${rows.join("\n")}`;
+              appendSection("raw-messages", "raw-row", rawSection);
+              let rowStart = prefix.length;
+              expanded.forEach((message, index) => {
+                const rowEnd = rowStart + rows[index].length;
+                traceRecorder?.recordRawRow(
+                  "raw-messages",
+                  { start: rowStart, end: rowEnd },
+                  message
+                );
+                rowStart = rowEnd + 1;
+              });
             }
           }
         }
         const joined = sections.join("\n\n");
         return joined.length > budget ? joined.slice(0, budget) : joined;
       },
+      recall(sessionId, query, budgetChars, recallOptions = {}, control) {
+        return adapter[composeRecall](
+          sessionId,
+          query,
+          budgetChars,
+          recallOptions,
+          control
+        );
+      },
+      async recallWithTrace(sessionId, query, budgetChars, recallOptions = {}, control) {
+        const budget = budgetChars ?? DEFAULT_BENCH_RECALL_BUDGET_CHARS;
+        const traceRecorder = createBenchRecallTraceRecorder(Math.max(0, budget));
+        const text = await adapter[composeRecall](
+          sessionId,
+          query,
+          budgetChars,
+          recallOptions,
+          control,
+          traceRecorder
+        );
+        return { text, trace: traceRecorder.finalize(text.length) };
+      },
       async assessRecallSupport(request, control) {
         throwIfBenchPhaseAborted(control, "assessRecallSupport");
         return assessRemnicRecallSupport(request, answerSupportMinCoverage);
@@ -2699,6 +3049,7 @@ ${expanded.map((message) => `[${message.role}]: ${message.content}`).join("\n")}
       responder: options.responder,
       judge: options.judge
     };
+    return adapter;
   };
 }
 var createLightweightAdapter = createAdapterFactory("lightweight");
@@ -3434,7 +3785,7 @@ function extractStructuredTrajectoryCueNumber(content) {
 function nextBenchTranscriptTurnId(counters, sessionId, message) {
   const index = counters.get(sessionId) ?? 0;
   counters.set(sessionId, index + 1);
-  const digest = createHash("sha256").update(`${sessionId}
+  const digest = createHash2("sha256").update(`${sessionId}
 ${index}
 ${message.role}
 ${message.content}`).digest("hex").slice(0, 16);
@@ -4301,6 +4652,33 @@ function createTimeoutGuardedAdapter(adapter, options) {
       return adapter.destroy();
     }
   };
+  if (adapter.recallWithTrace) {
+    wrapped.recallWithTrace = (sessionId, query, budgetChars, recallOptions, control) => {
+      if (phaseTimeoutMs === void 0) {
+        return adapter.recallWithTrace(
+          sessionId,
+          query,
+          budgetChars,
+          recallOptions,
+          control
+        );
+      }
+      return run(`recallWithTrace session=${sessionId}`, async (signal) => {
+        const merged = mergeBenchPhaseControl(signal, control);
+        try {
+          return await adapter.recallWithTrace(
+            sessionId,
+            query,
+            budgetChars,
+            recallOptions,
+            merged.control
+          );
+        } finally {
+          merged.cleanup();
+        }
+      });
+    };
+  }
   if (adapter.drain) {
     wrapped.drain = (control) => drainTimeoutMs === void 0 ? adapter.drain(control) : run(
       "drain",
@@ -5101,7 +5479,7 @@ function listMemoryEvalBenchmarkIds() {
 import {
   createCipheriv,
   createDecipheriv,
-  createHash as createHash2,
+  createHash as createHash3,
   randomBytes,
   timingSafeEqual
 } from "crypto";
@@ -5112,10 +5490,10 @@ var AES_TAG_LENGTH = 16;
 var INTEGRITY_HASH_ALGORITHM = "sha256";
 var INTEGRITY_CIPHER_ALGORITHM = "aes-256-gcm";
 function hashString(value) {
-  return createHash2(INTEGRITY_HASH_ALGORITHM).update(value, "utf8").digest("hex");
+  return createHash3(INTEGRITY_HASH_ALGORITHM).update(value, "utf8").digest("hex");
 }
 function hashBytes(value) {
-  return createHash2(INTEGRITY_HASH_ALGORITHM).update(value).digest("hex");
+  return createHash3(INTEGRITY_HASH_ALGORITHM).update(value).digest("hex");
 }
 function canonicalJsonStringify(value, space) {
   return JSON.stringify(value, canonicalReplacer, space);
@@ -5497,14 +5875,14 @@ var BENCHMARK_RESULT_SCHEMA = {
 
 // src/repro-manifest.ts
 import { execFileSync } from "child_process";
-import { createHash as createHash4 } from "crypto";
+import { createHash as createHash5 } from "crypto";
 import { createReadStream } from "fs";
 import { lstat as lstat3, mkdir as mkdir4, readFile as readFile5, readdir as readdir4, readlink, realpath as realpath3, stat as stat2, writeFile as writeFile4 } from "fs/promises";
 import os3 from "os";
 import path5 from "path";
 
 // src/providers/codex-credit-budget.ts
-import { createHash as createHash3 } from "crypto";
+import { createHash as createHash4 } from "crypto";
 import { mkdir as mkdir2, open, readFile as readFile3, rename as rename2, rmdir, unlink as unlink2, writeFile as writeFile2 } from "fs/promises";
 import os from "os";
 import path3 from "path";
@@ -6123,7 +6501,7 @@ function isSha256(value) {
   return typeof value === "string" && /^[a-f0-9]{64}$/.test(value);
 }
 function sha256(value) {
-  return createHash3("sha256").update(value).digest("hex");
+  return createHash4("sha256").update(value).digest("hex");
 }
 function normalizeZero(value) {
   return Object.is(value, -0) ? 0 : value;
@@ -7270,13 +7648,13 @@ var CODEX_CREDIT_REPRO_ENV_KEYS = [
   "REMNIC_BENCH_RUN_ID"
 ];
 function sha256String(value) {
-  return createHash4("sha256").update(value).digest("hex");
+  return createHash5("sha256").update(value).digest("hex");
 }
 function sha256Buffer(value) {
-  return createHash4("sha256").update(value).digest("hex");
+  return createHash5("sha256").update(value).digest("hex");
 }
 async function sha256File(filePath) {
-  const hash = createHash4("sha256");
+  const hash = createHash5("sha256");
   await new Promise((resolve, reject) => {
     const stream = createReadStream(filePath);
     stream.on("data", (chunk) => hash.update(chunk));
@@ -8197,7 +8575,7 @@ async function writeBenchmarkReproManifest(resultsDir, options = {}) {
 }
 
 // src/published-artifact.ts
-import { createHash as createHash5 } from "crypto";
+import { createHash as createHash6 } from "crypto";
 import { mkdir as mkdir5, readFile as readFile6, writeFile as writeFile5 } from "fs/promises";
 import path6 from "path";
 var BENCHMARK_ARTIFACT_SCHEMA_VERSION = 1;
@@ -8343,7 +8721,7 @@ function serializeBenchmarkArtifact(artifact) {
 `;
 }
 function hashBenchmarkArtifact(artifact) {
-  return createHash5("sha256").update(serializeBenchmarkArtifact(artifact)).digest("hex");
+  return createHash6("sha256").update(serializeBenchmarkArtifact(artifact)).digest("hex");
 }
 async function writeBenchmarkArtifact(artifact, outputDir) {
   await mkdir5(outputDir, { recursive: true });
@@ -8361,7 +8739,7 @@ async function writeBenchmarkArtifact(artifact, outputDir) {
   return {
     path: abs,
     filename,
-    sha256: createHash5("sha256").update(body).digest("hex"),
+    sha256: createHash6("sha256").update(body).digest("hex"),
     bytes: Buffer.byteLength(body, "utf8")
   };
 }
@@ -8475,7 +8853,7 @@ async function loadBenchmarkArtifact(filePath) {
   const artifact = parseBenchmarkArtifact(raw);
   return {
     artifact,
-    sha256: createHash5("sha256").update(raw).digest("hex"),
+    sha256: createHash6("sha256").update(raw).digest("hex"),
     bytes: Buffer.byteLength(raw, "utf8")
   };
 }
@@ -9638,7 +10016,7 @@ function createClaudeCliProvider(config, deps) {
 
 // src/providers/codex-cli.ts
 import { spawn as spawn2 } from "child_process";
-import { createHash as createHash6, randomUUID } from "crypto";
+import { createHash as createHash7, randomUUID } from "crypto";
 import { mkdir as mkdir6, mkdtemp as mkdtemp3, readFile as readFile7, rm as rm3, writeFile as writeFile6 } from "fs/promises";
 import os5 from "os";
 import path8 from "path";
@@ -10506,7 +10884,7 @@ function resolveCodexCliDiagnosticsMode(config) {
 }
 function inspectCodexCompletionPrompt(prompt) {
   const stats = {
-    sha256: createHash6("sha256").update(prompt).digest("hex"),
+    sha256: createHash7("sha256").update(prompt).digest("hex"),
     chars: prompt.length,
     lines: prompt.length === 0 ? 0 : prompt.split("\n").length
   };
@@ -12642,7 +13020,7 @@ function asStringArray(value) {
 }
 
 // src/responders.ts
-import { createHash as createHash7 } from "crypto";
+import { createHash as createHash8 } from "crypto";
 import { FallbackLlmClient } from "@remnic/core";
 
 // src/providers/openai-responses.ts
@@ -13115,7 +13493,7 @@ function getProviderBackedJudgePromptIdentity(config) {
     temperature: 0,
     maxTokens: 16
   };
-  return `sha256:${createHash7("sha256").update(JSON.stringify(contract)).digest("hex")}`;
+  return `sha256:${createHash8("sha256").update(JSON.stringify(contract)).digest("hex")}`;
 }
 var AMA_BENCH_RECOMMENDED_JUDGE_SYSTEM_PROMPT = [
   "You are evaluating an AMA-Bench long-horizon memory question.",
@@ -15456,11 +15834,11 @@ async function resolveLocalLabRuntimeProfile(options) {
 // src/benchmark.ts
 import fs2 from "fs";
 import path35 from "path";
-import { createHash as createHash13 } from "crypto";
+import { createHash as createHash14 } from "crypto";
 import { expandTildePath as expandTildePath3 } from "@remnic/core";
 
 // src/judges/judge-cache.ts
-import { createHash as createHash8, randomBytes as randomBytes2 } from "crypto";
+import { createHash as createHash9, randomBytes as randomBytes2 } from "crypto";
 import {
   mkdir as mkdir9,
   readFile as readFile11,
@@ -15503,8 +15881,8 @@ var JudgeCache = class {
   }
   /** Compute the sha256-hex key for a set of parts. Pure, sync, side-effect-free. */
   computeKey(parts) {
-    const fieldDigest = (value) => createHash8("sha256").update(value).digest();
-    return createHash8("sha256").update(fieldDigest(parts.benchmarkId)).update(fieldDigest(parts.datasetVersion)).update(fieldDigest(parts.questionId)).update(fieldDigest(parts.answerText)).update(fieldDigest(parts.judgePromptHash)).update(fieldDigest(parts.judgeModelId)).update(fieldDigest(parts.judgeParamsHash)).digest("hex");
+    const fieldDigest = (value) => createHash9("sha256").update(value).digest();
+    return createHash9("sha256").update(fieldDigest(parts.benchmarkId)).update(fieldDigest(parts.datasetVersion)).update(fieldDigest(parts.questionId)).update(fieldDigest(parts.answerText)).update(fieldDigest(parts.judgePromptHash)).update(fieldDigest(parts.judgeModelId)).update(fieldDigest(parts.judgeParamsHash)).digest("hex");
   }
   /**
    * Read a previously-stored verdict. Returns `undefined` on miss, corrupted
@@ -15699,7 +16077,7 @@ function runJudgeWithCache(options) {
           // Binary prompts are content-sensitive: two distinct prompts of
           // the same character length would collide on the previous
           // `binary:N` key, so key on a sha256 prefix of the prompt body.
-          questionId: `binary:${createHash8("sha256").update(prompt).digest("hex").slice(0, 16)}`,
+          questionId: `binary:${createHash9("sha256").update(prompt).digest("hex").slice(0, 16)}`,
           answerText: prompt,
           judgePromptHash: keyExtras.judgePromptHash ?? "unknown-prompt",
           judgeModelId: keyExtras.judgeModelId ?? "unknown-judge",
@@ -19469,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 = [
   {
@@ -19538,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",
@@ -19585,6 +19963,7 @@ async function loadDataset4(options) {
         return {
           source: "dataset",
           filename,
+          sha256: hashString(raw),
           items: applyLimit4(parsed, limit),
           errors
         };
@@ -19600,6 +19979,7 @@ async function loadDataset4(options) {
   }
   return {
     source: "smoke",
+    sha256: hashCanonicalJson(options.smokeFixture),
     items: applyLimit4([...options.smokeFixture], limit),
     errors
   };
@@ -20885,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,
@@ -20898,7 +21279,7 @@ async function runLoCoMoBenchmark(options) {
   );
   const plans = applyTrialLimit(
     conversations.map(
-      (conversation) => buildPlan2(conversation, multiHopRecallComposition)
+      (conversation) => buildLoCoMoPlan(conversation, multiHopRecallComposition)
     ),
     trialLimit
   );
@@ -20969,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 = [];
@@ -21005,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),
@@ -21208,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)
   );
@@ -21244,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) {
@@ -21520,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);
@@ -21547,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,
@@ -21579,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);
@@ -21863,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
@@ -21902,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
@@ -22089,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) {
@@ -23190,7 +23657,7 @@ var StructuredLiteralParser = class {
 };
 
 // src/benchmarks/published/personamem/runner.ts
-import { createHash as createHash9, randomUUID as randomUUID7 } from "crypto";
+import { createHash as createHash10, randomUUID as randomUUID7 } from "crypto";
 import { readFile as readFile16, realpath as realpath4 } from "fs/promises";
 import path19 from "path";
 
@@ -23275,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) {
@@ -23455,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) {
@@ -23795,7 +24262,7 @@ function buildMcqPrompt(sample, seed) {
 function deterministicShuffle(values, seedMaterial) {
   return values.map((value, index) => ({
     value,
-    key: createHash9("sha256").update(`${seedMaterial}:${index}:${value}`).digest("hex"),
+    key: createHash10("sha256").update(`${seedMaterial}:${index}:${value}`).digest("hex"),
     index
   })).sort((left, right) => {
     const byKey = left.key.localeCompare(right.key);
@@ -24063,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) {
@@ -24237,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) {
@@ -25268,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);
@@ -26241,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) {
@@ -32254,7 +32721,7 @@ function pairedDeltaConfidenceInterval(candidateValues, baselineValues, options
 }
 
 // src/judges/sealed-rubric.ts
-import { createHash as createHash10 } from "crypto";
+import { createHash as createHash11 } from "crypto";
 import { appendFileSync, mkdirSync } from "fs";
 import path31 from "path";
 
@@ -32363,7 +32830,7 @@ function loadSealedRubric(id = DEFAULT_ASSISTANT_RUBRIC_ID, options = {}) {
   if (typeof prompt !== "string" || prompt.length === 0) {
     throw new Error(`sealed rubric not found in registry: ${id}`);
   }
-  const sha2563 = createHash10("sha256").update(prompt, "utf8").digest("hex");
+  const sha2563 = createHash11("sha256").update(prompt, "utf8").digest("hex");
   const version = parseVersionFromId(id);
   return { id, version, prompt, sha256: sha2563 };
 }
@@ -34566,7 +35033,7 @@ async function runRetentionAgedDatasetBenchmark(options) {
 import { randomUUID as randomUUID31 } from "crypto";
 
 // src/benchmarks/remnic/memcorrect/generator.ts
-import { createHash as createHash11 } from "crypto";
+import { createHash as createHash12 } from "crypto";
 
 // src/benchmarks/remnic/memcorrect/token-pools.ts
 var PERSONAS = [
@@ -34890,7 +35357,7 @@ function corpusHash(corpus) {
     uptakeLatencyCap: corpus.options.uptakeLatencyCap,
     scenarios: corpus.scenarios
   });
-  return createHash11("sha256").update(canonical).digest("hex");
+  return createHash12("sha256").update(canonical).digest("hex");
 }
 
 // src/benchmarks/remnic/memcorrect/schema.ts
@@ -35845,7 +36312,7 @@ import { mkdir as mkdir17, writeFile as writeFile16 } from "fs/promises";
 import path34 from "path";
 
 // src/benchmarks/remnic/bounded-memory-contracts/fixture.ts
-import { createHash as createHash12 } from "crypto";
+import { createHash as createHash13 } from "crypto";
 var SCOPE_ACME = "project:acme";
 var SCOPE_BETA = "project:beta";
 var SCOPE_ALICE = "user:alice";
@@ -36328,7 +36795,7 @@ var BOUNDED_MEMORY_SMOKE_FIXTURE = [
 function fixtureHash(tasks) {
   const source = tasks ?? BOUNDED_MEMORY_FIXTURE;
   const payload = JSON.stringify(source);
-  return createHash12("sha256").update(payload, "utf8").digest("hex");
+  return createHash13("sha256").update(payload, "utf8").digest("hex");
 }
 
 // src/benchmarks/remnic/bounded-memory-contracts/agent.ts
@@ -37588,13 +38055,13 @@ function wrapJudgeWithCache(args) {
       // differentiator is part of the prompt hash. Bumping
       // JUDGE_CACHE_PROTOCOL_VERSION invalidates verdicts when judge
       // prompt/parse semantics change (PR #1591, High).
-      judgePromptHash: createHash13("sha256").update(JUDGE_CACHE_PROTOCOL_VERSION).update("
").update(args.amaBenchJudgeProtocol).update("
").update(args.role).digest("hex"),
+      judgePromptHash: createHash14("sha256").update(JUDGE_CACHE_PROTOCOL_VERSION).update("
").update(args.amaBenchJudgeProtocol).update("
").update(args.role).digest("hex"),
       judgeModelId: args.provider?.model !== void 0 && args.provider.model.length > 0 ? `${args.provider.model}${crossJudgeIdSuffix}` : `unknown-${args.role}-judge`,
       // Full judge configuration, deterministically serialized (sorted
       // keys) so provider/base-url/retry changes produce fresh cache
       // keys. `role` is included so primary and cross judges never
       // share a paramsHash.
-      judgeParamsHash: createHash13("sha256").update(
+      judgeParamsHash: createHash14("sha256").update(
         stableStringify2({
           role: args.role,
           provider: args.provider
@@ -38300,7 +38767,7 @@ function formatSignedScore(value) {
 }
 
 // src/stats/locomo-recall-delta.ts
-import { createHash as createHash14 } from "crypto";
+import { createHash as createHash15 } from "crypto";
 import { basename } from "path";
 var LOCOMO_FULL_TASK_COUNT = 1986;
 var LOCOMO_RECALL_EXCERPT_CHARS = 240;
@@ -38781,7 +39248,7 @@ function normalizeText3(value) {
   return value.replaceAll("\r\n", "\n").replaceAll("\r", "\n");
 }
 function sha2562(value) {
-  return createHash14("sha256").update(value).digest("hex");
+  return createHash15("sha256").update(value).digest("hex");
 }
 function stableJson(value) {
   return JSON.stringify(value);
@@ -38816,6 +39283,349 @@ function formatSignedScore2(value) {
   return `${value >= 0 ? "+" : ""}${formatScore2(value)}`;
 }
 
+// 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) {
@@ -40219,7 +41029,7 @@ var chatFixture = {
 };
 
 // src/judges/calibration-slice.ts
-import { createHash as createHash15, randomBytes as randomBytes3 } from "crypto";
+import { createHash as createHash16, randomBytes as randomBytes3 } from "crypto";
 import { chmod as chmod2, lstat as lstat4, mkdir as mkdir18, open as open2, readFile as readFile22, rename as rename4, unlink as unlink4, writeFile as writeFile17 } from "fs/promises";
 import path37 from "path";
 
@@ -40368,7 +41178,7 @@ function selectCalibrationSlice(questionIds, size = CALIBRATION_SLICE_SIZE) {
       unique.push(id);
     }
   }
-  return unique.map((id) => ({ id, digest: createHash15("sha256").update(id, "utf8").digest("hex") })).sort((a, b) => a.digest < b.digest ? -1 : a.digest > b.digest ? 1 : 0).slice(0, Math.min(size, unique.length)).map((entry) => entry.id);
+  return unique.map((id) => ({ id, digest: createHash16("sha256").update(id, "utf8").digest("hex") })).sort((a, b) => a.digest < b.digest ? -1 : a.digest > b.digest ? 1 : 0).slice(0, Math.min(size, unique.length)).map((entry) => entry.id);
 }
 async function runJudgeCalibration(options) {
   const binScore = options.binScore ?? ((score) => binarizeJudgeScore(score));
@@ -40485,7 +41295,7 @@ function hashOrderedQuestionIds(questionIds) {
   if (questionIds.some((id) => typeof id !== "string" || id.length === 0)) {
     throw new Error("hashOrderedQuestionIds: question ids must be non-empty strings.");
   }
-  return createHash15("sha256").update(JSON.stringify(questionIds), "utf8").digest("hex");
+  return createHash16("sha256").update(JSON.stringify(questionIds), "utf8").digest("hex");
 }
 function validatePinnedQuestionIds(ids, availableIds) {
   if (ids.length === 0 || ids.length > CALIBRATION_SLICE_SIZE || ids.some((id) => typeof id !== "string" || id.length === 0) || new Set(ids).size !== ids.length) {
@@ -40498,7 +41308,7 @@ function validatePinnedQuestionIds(ids, availableIds) {
   return [...ids];
 }
 function hashCalibrationAnswerSet(answers) {
-  return createHash15("sha256").update(JSON.stringify(answers.map((answer) => [
+  return createHash16("sha256").update(JSON.stringify(answers.map((answer) => [
     answer.questionId,
     answer.question,
     answer.predicted,
@@ -40564,7 +41374,7 @@ async function loadOrInitializeCheckpoint(benchmarkId, provenance, sliceQuestion
       frontierJudgeConfigHash: provenance.frontierJudgeConfigHash,
       binningIdentity: provenance.binningIdentity
     };
-    const contractHash = createHash15("sha256").update(stableJson2(contract)).digest("hex");
+    const contractHash = createHash16("sha256").update(stableJson2(contract)).digest("hex");
     let raw;
     try {
       const info = await lstat4(checkpointPath);
@@ -42085,7 +42895,7 @@ function createMitigatedTarget(config) {
 }
 
 // src/coding-graph/generator.ts
-import { createHash as createHash16 } from "crypto";
+import { createHash as createHash17 } from "crypto";
 function createSeededRng3(seed) {
   let state = seed >>> 0;
   return function rng() {
@@ -42114,7 +42924,7 @@ var EDGE_TYPE_WEIGHTS = [
 var PROVENANCE_VALUES = ["heuristic", "heuristic", "heuristic", "trace"];
 var AVG_BYTES_PER_LINE = 40;
 function hashContent(input) {
-  return createHash16("sha256").update(input).digest("hex").slice(0, 16);
+  return createHash17("sha256").update(input).digest("hex").slice(0, 16);
 }
 function generateSyntheticRepo(config) {
   const rng = createSeededRng3(config.seed);
@@ -42686,6 +43496,9 @@ export {
   LOCOMO_FULL_TASK_COUNT,
   LOCOMO_RECALL_DIFF_LINE_LIMIT,
   LOCOMO_RECALL_EXCERPT_CHARS,
+  LOCOMO_RETRIEVAL_TRACE_BUDGET_VERSION,
+  LOCOMO_RETRIEVAL_TRACE_SCHEMA_VERSION,
+  LOCOMO_RETRIEVAL_TRACE_SELECTION_VERSION,
   LONG_MEM_EVAL_DATASET_FILENAMES,
   LettaMemCorrectAdapter,
   LocalLabPreflightError,
@@ -42742,10 +43555,12 @@ export {
   buildCodexCreditReceipt,
   buildJudgePayload,
   buildOracleTrajectoryRecall,
+  buildProviderFreeLoCoMoRetrievalConfig,
   buildSchemaTierFixture,
   buildSchemaTierSmokeFixture,
   calendarFixture,
   canonicalJsonStringify,
+  captureLoCoMoRetrievalTrace,
   captureMachineFingerprint,
   chatFixture,
   checkCodingGraphRegression,
@@ -42814,6 +43629,7 @@ export {
   getAblationCell,
   getBenchmark,
   getBenchmarkLowerIsBetter,
+  getGitSha,
   getMemoryEvalDimension,
   getProviderBackedJudgePromptIdentity,
   getRemnicVersion,
@@ -42867,6 +43683,7 @@ export {
   parseSealedQrels,
   pickStableQualifiedName,
   precisionAtK,
+  preflightLoCoMoRetrievalTraceCapture,
   preflightLocalLabRole,
   projectFolderFixture,
   recallAtK,
@@ -42922,6 +43739,7 @@ export {
   selectFixtureVariant,
   serializeBenchmarkArtifact,
   serializeJsonl,
+  serializeLoCoMoRetrievalTraceReceipt,
   serializeSealedQrels,
   shuffleTasks,
   timed,