@xdarkicex/openclaw-memory-libravdb 1.4.2 → 1.4.4

package/src/comparison-experiments.ts

@@ -0,0 +1,128 @@
+export const COMPARISON_ABLATION_MODES = [
+  "reserve_bump",
+  "protected_pair_pack",
+  "discriminative_affiliation",
+  "witness_position_pastness",
+  "contamination_penalty",
+  "pair_score_on_witness",
+  "comparison_blend",
+] as const;
+
+export type ComparisonAblationMode = typeof COMPARISON_ABLATION_MODES[number];
+
+export interface ComparisonProfileSummary {
+  ablationMode?: ComparisonAblationMode;
+  rankTotalMs: number;
+  decorateMs: number;
+  slotCoverageMs: number;
+  sideAffiliationMs: number;
+  specificityMs: number;
+  pairSelectionMs: number;
+  greedyFillMs: number;
+  recoveryPackingMs: number;
+  debugBuildMs: number;
+  rawCandidateCount: number;
+  comparisonCandidateCount: number;
+  side0AffiliatedCount: number;
+  side1AffiliatedCount: number;
+  normalizeTermsCalls: number;
+  normalizeContentTermsCalls: number;
+  estimateTokensCalls: number;
+  sortCalls: number;
+  totalSortedLength: number;
+}
+
+export interface ComparisonExperimentConfig {
+  profilingEnabled: boolean;
+  ablationMode: ComparisonAblationMode | null;
+  disableReserveBump: boolean;
+  disableProtectedPairPack: boolean;
+  disableDiscriminativeAffiliation: boolean;
+  disableWitnessPositionPastness: boolean;
+  disableContaminationPenalty: boolean;
+  disablePairScoreOnWitness: boolean;
+  disableComparisonBlend: boolean;
+}
+
+export function resolveComparisonExperimentConfig(
+  env: NodeJS.ProcessEnv = process.env,
+): ComparisonExperimentConfig {
+  const profilingEnabled = env.LONGMEMEVAL_PROFILE_COMPARISON === "1";
+  const rawMode = env.LONGMEMEVAL_COMPARISON_PROFILE_MODE?.trim() ?? "";
+  const ablationMode = COMPARISON_ABLATION_MODES.includes(rawMode as ComparisonAblationMode)
+    ? rawMode as ComparisonAblationMode
+    : null;
+  return {
+    profilingEnabled,
+    ablationMode,
+    disableReserveBump: ablationMode === "reserve_bump",
+    disableProtectedPairPack: ablationMode === "protected_pair_pack",
+    disableDiscriminativeAffiliation: ablationMode === "discriminative_affiliation",
+    disableWitnessPositionPastness: ablationMode === "witness_position_pastness",
+    disableContaminationPenalty: ablationMode === "contamination_penalty",
+    disablePairScoreOnWitness: ablationMode === "pair_score_on_witness",
+    disableComparisonBlend: ablationMode === "comparison_blend",
+  };
+}
+
+export function createComparisonProfileSummary(
+  ablationMode: ComparisonAblationMode | null,
+): ComparisonProfileSummary {
+  return {
+    ablationMode: ablationMode ?? undefined,
+    rankTotalMs: 0,
+    decorateMs: 0,
+    slotCoverageMs: 0,
+    sideAffiliationMs: 0,
+    specificityMs: 0,
+    pairSelectionMs: 0,
+    greedyFillMs: 0,
+    recoveryPackingMs: 0,
+    debugBuildMs: 0,
+    rawCandidateCount: 0,
+    comparisonCandidateCount: 0,
+    side0AffiliatedCount: 0,
+    side1AffiliatedCount: 0,
+    normalizeTermsCalls: 0,
+    normalizeContentTermsCalls: 0,
+    estimateTokensCalls: 0,
+    sortCalls: 0,
+    totalSortedLength: 0,
+  };
+}
+
+export function mergeComparisonProfileSummaries(
+  profiles: ComparisonProfileSummary[],
+): ComparisonProfileSummary | null {
+  if (profiles.length === 0) {
+    return null;
+  }
+
+  const merged = createComparisonProfileSummary(
+    profiles.every((profile) => profile.ablationMode === profiles[0]!.ablationMode)
+      ? (profiles[0]!.ablationMode ?? null)
+      : null,
+  );
+  for (const profile of profiles) {
+    merged.rankTotalMs += profile.rankTotalMs;
+    merged.decorateMs += profile.decorateMs;
+    merged.slotCoverageMs += profile.slotCoverageMs;
+    merged.sideAffiliationMs += profile.sideAffiliationMs;
+    merged.specificityMs += profile.specificityMs;
+    merged.pairSelectionMs += profile.pairSelectionMs;
+    merged.greedyFillMs += profile.greedyFillMs;
+    merged.recoveryPackingMs += profile.recoveryPackingMs;
+    merged.debugBuildMs += profile.debugBuildMs;
+    merged.rawCandidateCount += profile.rawCandidateCount;
+    merged.comparisonCandidateCount += profile.comparisonCandidateCount;
+    merged.side0AffiliatedCount += profile.side0AffiliatedCount;
+    merged.side1AffiliatedCount += profile.side1AffiliatedCount;
+    merged.normalizeTermsCalls += profile.normalizeTermsCalls;
+    merged.normalizeContentTermsCalls += profile.normalizeContentTermsCalls;
+    merged.estimateTokensCalls += profile.estimateTokensCalls;
+    merged.sortCalls += profile.sortCalls;
+    merged.totalSortedLength += profile.totalSortedLength;
+  }
+
+  return merged;
+}

package/src/context-engine.ts

@@ -13,6 +13,8 @@ import {
   rankSection7VariantCandidates,
 } from "./scoring.js";
 import { buildInjectedMemoryMessageContent, buildMemoryHeader, recentIds } from "./recall-utils.js";
+import { detectDreamQuerySignal, resolveDreamCollection } from "./dream-routing.js";
+import { resolveComparisonExperimentConfig } from "./comparison-experiments.js";
 import {
   decideTemporalSelectorGuard,
   detectTemporalQuerySignal,
@@ -58,6 +60,8 @@ export function buildContextEngineFactory(
   let authoredVariantCache: SearchResult[] | null = null;
   const authoredVariantRecallCache = new Map<string, SearchResult[]>();
   const afterTurnIngestedKeys = new Map<string, number>();
+  // Tracks accumulated uncompacted token count per session for auto-compaction
+  const sessionTokenAccumulators = new Map<string, number>();
 
   // Session-scoped elevated-guidance cache keyed by sessionId + generation + durable namespace + queryText
   const elevatedRecallCache = new Map<string, SearchResult[]>();
@@ -168,6 +172,20 @@ export function buildContextEngineFactory(
         if (result.ingested) {
           rememberAfterTurnIngest(afterTurnIngestedKeys, dedupeKey);
         }
+
+        // Auto-trigger compaction when the session's uncompacted token count exceeds
+        // the budget. This keeps session size bounded without relying on the host
+        // to call compact() explicitly.
+        const sessionTokenBudget = cfg.compactSessionTokenBudget ?? 2000;
+        if (sessionTokenBudget > 0) {
+          const tokens = estimateTokens(normalized.content);
+          const accumulated = (sessionTokenAccumulators.get(sessionId) ?? 0) + tokens;
+          sessionTokenAccumulators.set(sessionId, accumulated);
+          if (accumulated >= sessionTokenBudget) {
+            sessionTokenAccumulators.set(sessionId, 0);
+            void this.compact({ sessionId, force: false }).catch(() => {});
+          }
+        }
       }
     },
     async assemble({ sessionId, sessionKey, userId, messages, tokenBudget, ...rest }: ContextAssembleArgs & Record<string, unknown>) {
@@ -187,11 +205,14 @@ export function buildContextEngineFactory(
           systemPromptAddition: "",
         } satisfies ContextAssembleResult;
       }
+      const dreamQuery = detectDreamQuerySignal(queryText);
       const temporalQuery = detectTemporalQuerySignal(queryText);
       const temporalSelectorGuard = decideTemporalSelectorGuard(queryText, temporalQuery);
+      const comparisonExperiment = resolveComparisonExperimentConfig();
+      const emitComparisonProfile = comparisonExperiment.profilingEnabled;
 
       const excluded = recentIds(normalizedMessages, 4);
-      const cached = recallCache.take({ userId: durableNamespace, queryText });
+      const cached = dreamQuery.active ? undefined : recallCache.take({ userId: durableNamespace, queryText });
 
       const rpc = await getRpc();
 
@@ -252,8 +273,11 @@ export function buildContextEngineFactory(
           cached,
           excluded,
           queryText,
+          dreamQuery,
           temporalQuery,
           temporalSelectorGuard,
+          comparisonExperiment,
+          emitComparisonProfile,
           sessionId,
           userId: durableNamespace,
           visibleMessages: originalMessages,
@@ -289,8 +313,11 @@ export function buildContextEngineFactory(
       cached,
       excluded,
       queryText,
+      dreamQuery,
       temporalQuery,
       temporalSelectorGuard,
+      comparisonExperiment,
+      emitComparisonProfile,
       sessionId,
       userId,
       visibleMessages,
@@ -308,8 +335,11 @@ export function buildContextEngineFactory(
       cached: ReturnType<RecallCache<SearchResult>["take"]>;
       excluded: string[];
       queryText: string;
+      dreamQuery: ReturnType<typeof detectDreamQuerySignal>;
       temporalQuery: ReturnType<typeof detectTemporalQuerySignal>;
       temporalSelectorGuard: ReturnType<typeof decideTemporalSelectorGuard>;
+      comparisonExperiment: ReturnType<typeof resolveComparisonExperimentConfig>;
+      emitComparisonProfile: boolean;
       sessionId: string;
       userId: string;
       visibleMessages: MemoryMessage[];
@@ -321,6 +351,52 @@ export function buildContextEngineFactory(
       const memoryBudget = tokenBudget * (cfg.tokenBudgetFraction ?? 0.25);
       const hardItems = authoredHard;
       const hardUsed = tokenCostSum(hardItems);
+      const dreamMode = dreamQuery.active;
+      const dreamCollection = resolveDreamCollection(userId);
+
+      if (dreamMode) {
+        const authoredSoftTarget = Math.max(0, memoryBudget * (cfg.authoredSoftBudgetFraction ?? 0.3));
+        const softBudget = Math.max(0, Math.min(authoredSoftTarget, memoryBudget - hardUsed));
+        const softItems = fitPromptBudget(authoredSoft, softBudget);
+        const remainingBudget = Math.max(0, memoryBudget - hardUsed - tokenCostSum(softItems));
+
+        profiler?.mark("dream_search");
+        const dreamTopK = Math.max(cfg.topK ?? 8, 1);
+        const dreamHits = await rpc.call<{ results: SearchResult[] }>("search_text", {
+          collection: dreamCollection,
+          text: queryText,
+          k: dreamTopK,
+        });
+
+        profiler?.mark("dream_rank");
+        const rankedDream = rankSection7VariantCandidates(
+          annotateCollection(dreamHits.results ?? [], dreamCollection),
+          {
+            queryText,
+            k1: dreamTopK,
+            k2: dreamTopK,
+            theta1: cfg.section7Theta1,
+            kappa: cfg.section7Kappa,
+            authorityRecencyLambda: cfg.section7AuthorityRecencyLambda,
+            authorityRecencyWeight: cfg.section7AuthorityRecencyWeight,
+            authorityFrequencyWeight: cfg.section7AuthorityFrequencyWeight,
+            authorityAuthoredWeight: cfg.section7AuthorityAuthoredWeight,
+            sessionId,
+            userId,
+          },
+        );
+        const dreamItems = fitPromptBudget(rankedDream, remainingBudget);
+        const selected = [...hardItems, ...softItems, ...dreamItems];
+        const selectedMessages = selected.map((item) => ({
+          role: "system",
+          content: buildInjectedMemoryMessageContent(item),
+        }));
+        return {
+          messages: [...selectedMessages, ...visibleMessages],
+          estimatedTokens: countTokens(selectedMessages) + countTokens(visibleMessages),
+          systemPromptAddition: buildMemoryHeader(selected),
+        };
+      }
 
       profiler?.mark("session");
       const sessionRecords = await rpc.call<{ results: SearchResult[] }>("list_by_meta", {
@@ -397,7 +473,10 @@ export function buildContextEngineFactory(
       const searchSessionSummary = useSessionSummarySearchExperiment(cfg);
       let sessionSearchCollection = `session:${sessionId}`;
       let sessionExcludeIds = [...excluded, ...recentTailIDs];
-      if (searchSessionSummary) {
+      if (dreamMode) {
+        sessionSearchCollection = dreamCollection;
+        sessionExcludeIds = [...excluded];
+      } else if (searchSessionSummary) {
         const summaryCollection = sessionSummaryCollection(sessionId);
         const summaryRecords = await rpc.call<{ results: SearchResult[] }>("list_collection", {
           collection: summaryCollection,
@@ -423,14 +502,18 @@ export function buildContextEngineFactory(
 
       profiler?.mark("recall_user_global");
       const [userHits, globalHits] = await Promise.all([
-        cached?.userHits
+        dreamMode
+          ? Promise.resolve({ results: [] as SearchResult[] })
+          : cached?.userHits
           ? Promise.resolve({ results: cached.userHits })
           : rpc.call<{ results: SearchResult[] }>("search_text", {
               collection: `user:${userId}`,
               text: queryText,
               k: Math.ceil((cfg.topK ?? 8) / 2),
             }),
-        cached?.globalHits
+        dreamMode
+          ? Promise.resolve({ results: [] as SearchResult[] })
+          : cached?.globalHits
           ? Promise.resolve({ results: cached.globalHits })
           : rpc.call<{ results: SearchResult[] }>("search_text", {
               collection: "global",
@@ -439,7 +522,7 @@ export function buildContextEngineFactory(
             }),
       ]);
 
-      if (!cached) {
+      if (!cached && !dreamMode) {
         recallCache.put({
           userId,
           queryText,
@@ -453,7 +536,9 @@ export function buildContextEngineFactory(
       const authoredVariantKey = `${queryText}\n${coarseTopK}`;
       const cachedAuthoredVariantHits = authoredVariantRecallCache.get(authoredVariantKey);
       const [authoredVariantHits] = await Promise.all([
-        cachedAuthoredVariantHits
+        dreamMode
+          ? Promise.resolve({ results: [] as SearchResult[] })
+          : cachedAuthoredVariantHits
           ? Promise.resolve({ results: cachedAuthoredVariantHits })
           : rpc.call<{ results: SearchResult[] }>("search_text", {
               collection: AUTHORED_VARIANT_COLLECTION,
@@ -470,7 +555,9 @@ export function buildContextEngineFactory(
       const elevatedKey = `${sessionId}\n${elevatedGeneration}\n${userId}\n${queryText}`;
       const cachedElevated = elevatedRecallCache.get(elevatedKey);
       const [elevatedHits] = await Promise.all([
-        cachedElevated
+        dreamMode
+          ? Promise.resolve({ results: [] as SearchResult[] })
+          : cachedElevated
           ? Promise.resolve({ results: cachedElevated })
           : rpc.call<{ results: SearchResult[] }>("search_text_collections", {
               collections: [
@@ -489,7 +576,7 @@ export function buildContextEngineFactory(
       profiler?.mark("rank");
       const ranked = rankSection7VariantCandidates(
         [
-          ...annotateCollection(sessionHits.results, `session:${sessionId}`),
+          ...annotateCollection(sessionHits.results, sessionSearchCollection),
           ...elevatedHits.results,
           ...userHits.results,
           ...globalHits.results,
@@ -525,17 +612,31 @@ export function buildContextEngineFactory(
       // Recovery trigger is evaluated before variant fitting so healthy sessions
       // do not lose recall budget to an unused recovery reserve.
       profiler?.mark("recovery_trigger");
-      const recoveryTrigger = detectRetrievalFailure(mergedCandidates, {
-        floorScore: cfg.recoveryFloorScore ?? 0.15,
-        minTopK: cfg.recoveryMinTopK ?? 4,
-        meanConfidenceThresh: cfg.recoveryMinConfidenceMean ?? 0.5,
-      });
-      const crossSessionRawRecovery =
+      const recoveryTrigger = dreamMode
+        ? {
+            signal1CascadeTier3: false,
+            signal2TopScoreBelowFloor: false,
+            signal3AllSummariesLowConfidence: false,
+            fire: false,
+          }
+        : detectRetrievalFailure(mergedCandidates, {
+            floorScore: cfg.recoveryFloorScore ?? 0.15,
+            minTopK: cfg.recoveryMinTopK ?? 4,
+            meanConfidenceThresh: cfg.recoveryMinConfidenceMean ?? 0.5,
+          });
+      const crossSessionRawRecovery = !dreamMode &&
         rawSessionTurns.length === 0 &&
         sessionHits.results.length === 0;
-      const recoveryReserveTokens = (recoveryTrigger.fire || crossSessionRawRecovery)
+      const baseRecoveryReserveTokens = (recoveryTrigger.fire || crossSessionRawRecovery)
         ? Math.min(memoryBudget, Math.max(Math.floor(memoryBudget * 0.10), 16), 128)
         : 0;
+      const isComparisonTemporalRecovery = temporalSelectorGuard.shouldApply &&
+        temporalQuery.matchedPatterns.includes("first or earlier");
+      const recoveryReserveTokens = isComparisonTemporalRecovery &&
+        !comparisonExperiment.disableReserveBump &&
+        baseRecoveryReserveTokens > 0
+        ? Math.min(memoryBudget, Math.max(baseRecoveryReserveTokens, Math.ceil(baseRecoveryReserveTokens * 1.8)))
+        : baseRecoveryReserveTokens;
       const elevatedGuidanceBudget = Math.max(
         0,
         Math.min(
@@ -570,8 +671,10 @@ export function buildContextEngineFactory(
       // it never modifies the C_total(q) output and does not spend from tau_V.
       let recoveryItems: SearchResult[] = [];
       let rawUserRecoveryDebug: NonNullable<NonNullable<ContextAssembleResult["_debug"]>["rawUserRecoveryCandidates"]> = [];
+      let dedupedRecoveryDebug: NonNullable<NonNullable<ContextAssembleResult["_debug"]>["recoveryDedupedOrder"]> = [];
+      let fittedRecoveryDebug: NonNullable<NonNullable<ContextAssembleResult["_debug"]>["recoveryFittedOrder"]> = [];
       let temporalRecoveryResult: TemporalRecoveryRankingResult | null = null;
-      if (recoveryTrigger.fire || crossSessionRawRecovery) {
+      if (!dreamMode && (recoveryTrigger.fire || crossSessionRawRecovery)) {
         profiler?.mark("recovery_expand");
         const recoveryExcludeIDs = [...excluded, ...recentTailIDs, ...theoremSelectedIDs];
         const recoveryCandidates: SearchResult[] = [];
@@ -615,6 +718,7 @@ export function buildContextEngineFactory(
                 maxSelected: 3,
                 nowMs: Date.now(),
                 recencyLambda: cfg.recencyLambdaUser ?? 0.00001,
+                selectionTokenBudget: recoveryReserveTokens,
               })
             : null;
           const reranked = temporalRecoveryResult
@@ -646,26 +750,91 @@ export function buildContextEngineFactory(
                 : 0,
               finalScore: typeof item.finalScore === "number" ? item.finalScore : 0,
               rationale: typeof item.rationale === "string" ? item.rationale : "",
+              comparisonSide: "comparisonSide" in item && (item.comparisonSide === 0 || item.comparisonSide === 1 || item.comparisonSide === null)
+                ? item.comparisonSide
+                : undefined,
+              comparisonSlot: "comparisonSlot" in item && typeof item.comparisonSlot === "string"
+                ? item.comparisonSlot
+                : undefined,
+              comparisonSlotRecall: "comparisonSlotRecall" in item && typeof item.comparisonSlotRecall === "number"
+                ? item.comparisonSlotRecall
+                : undefined,
+              comparisonSlotPrecision: "comparisonSlotPrecision" in item && typeof item.comparisonSlotPrecision === "number"
+                ? item.comparisonSlotPrecision
+                : undefined,
+              comparisonSlotSpecificity: "comparisonSlotSpecificity" in item && typeof item.comparisonSlotSpecificity === "number"
+                ? item.comparisonSlotSpecificity
+                : undefined,
+              comparisonSlotPositionWeightedRecall: "comparisonSlotPositionWeightedRecall" in item && typeof item.comparisonSlotPositionWeightedRecall === "number"
+                ? item.comparisonSlotPositionWeightedRecall
+                : undefined,
+              comparisonSlotPositionWeightedPrecision: "comparisonSlotPositionWeightedPrecision" in item && typeof item.comparisonSlotPositionWeightedPrecision === "number"
+                ? item.comparisonSlotPositionWeightedPrecision
+                : undefined,
+              comparisonSlotPositionWeightedSpecificity: "comparisonSlotPositionWeightedSpecificity" in item && typeof item.comparisonSlotPositionWeightedSpecificity === "number"
+                ? item.comparisonSlotPositionWeightedSpecificity
+                : undefined,
+              comparisonFirstPersonClauseCount: "comparisonFirstPersonClauseCount" in item && typeof item.comparisonFirstPersonClauseCount === "number"
+                ? item.comparisonFirstPersonClauseCount
+                : undefined,
+              comparisonProspectivePersonalVerbCount: "comparisonProspectivePersonalVerbCount" in item && typeof item.comparisonProspectivePersonalVerbCount === "number"
+                ? item.comparisonProspectivePersonalVerbCount
+                : undefined,
+              comparisonPlanningDensity: "comparisonPlanningDensity" in item && typeof item.comparisonPlanningDensity === "number"
+                ? item.comparisonPlanningDensity
+                : undefined,
+              comparisonPastness: "comparisonPastness" in item && typeof item.comparisonPastness === "number"
+                ? item.comparisonPastness
+                : undefined,
+              comparisonSideWitnessScore: "comparisonSideWitnessScore" in item && typeof item.comparisonSideWitnessScore === "number"
+                ? item.comparisonSideWitnessScore
+                : undefined,
             }));
           }
           recoveryCandidates.push(
-            ...reranked.ranked.map((item) => ({
-              ...item,
-              finalScore: typeof item.finalScore === "number" ? item.finalScore : item.score,
-              metadata: {
-                ...item.metadata,
-                recovery_fallback: true,
-                recovery_scope: "user_turns",
-              },
-            })),
+            ...reranked.ranked.map((item) => {
+              return {
+                ...item,
+                finalScore: typeof item.finalScore === "number" ? item.finalScore : item.score,
+                metadata: {
+                  ...item.metadata,
+                  recovery_fallback: true,
+                  recovery_scope: "user_turns",
+                },
+              };
+            }),
           );
         }
 
-        const fittedRecovery = fitPromptBudgetFirstFit(
-          dedupeRecoveryCandidates(recoveryCandidates),
-          recoveryReserveTokens,
-        );
+        const dedupedRecovery = dedupeRecoveryCandidates(recoveryCandidates);
+        const packingStart = temporalRecoveryResult?.comparisonProfile ? process.hrtime.bigint() : 0n;
+        const fittedRecovery = comparisonExperiment.disableProtectedPairPack
+          ? fitPromptBudgetFirstFit(dedupedRecovery, recoveryReserveTokens)
+          : fitProtectedComparisonRecovery(
+            dedupedRecovery,
+            recoveryReserveTokens,
+            temporalRecoveryResult?.comparisonCoverageApplied === true
+              ? temporalRecoveryResult.comparisonWitnessIds
+              : undefined,
+          );
+        if (temporalRecoveryResult?.comparisonProfile) {
+          temporalRecoveryResult.comparisonProfile.recoveryPackingMs += Number(process.hrtime.bigint() - packingStart) / 1_000_000;
+        }
         recoveryItems = fittedRecovery;
+        if (debugRecovery) {
+          dedupedRecoveryDebug = dedupedRecovery.map((item) => ({
+            id: item.id,
+            recoveryScope: typeof item.metadata.recovery_scope === "string" ? item.metadata.recovery_scope : "unknown",
+            finalScore: typeof item.finalScore === "number" ? item.finalScore : item.score,
+            tokenEstimate: estimateTokens(item.text),
+          }));
+          fittedRecoveryDebug = fittedRecovery.map((item) => ({
+            id: item.id,
+            recoveryScope: typeof item.metadata.recovery_scope === "string" ? item.metadata.recovery_scope : "unknown",
+            finalScore: typeof item.finalScore === "number" ? item.finalScore : item.score,
+            tokenEstimate: estimateTokens(item.text),
+          }));
+        }
         if (debugRecovery && rawUserRecoveryDebug.length > 0) {
           const selectedIDs = new Set(
             fittedRecovery
@@ -698,11 +867,11 @@ export function buildContextEngineFactory(
         content: buildInjectedMemoryMessageContent(item),
       }));
 
-      return {
-        messages: [...selectedMessages, ...visibleMessages],
-        estimatedTokens: countTokens(selectedMessages) + countTokens(visibleMessages),
-        systemPromptAddition: buildMemoryHeader(selected),
-        _debug: debugRecovery
+        return {
+          messages: [...selectedMessages, ...visibleMessages],
+          estimatedTokens: countTokens(selectedMessages) + countTokens(visibleMessages),
+          systemPromptAddition: buildMemoryHeader(selected),
+          _debug: (debugRecovery || emitComparisonProfile)
           ? {
               recoveryTriggerFired: recoveryTrigger.fire,
               crossSessionRawRecovery,
@@ -713,10 +882,17 @@ export function buildContextEngineFactory(
               temporalSelectorApplied: temporalSelectorGuard.shouldApply,
               temporalSelectorReason: temporalSelectorGuard.reason,
               temporalRecoverySlots: temporalRecoveryResult?.slots,
+              temporalComparisonCoverageApplied: temporalRecoveryResult?.comparisonCoverageApplied,
+              temporalComparisonCoverageSlots: temporalRecoveryResult?.comparisonCoverageSlots,
+              temporalComparisonCoverageMinTokens: temporalRecoveryResult?.comparisonCoverageMinTokens,
+              temporalComparisonWitnessIds: temporalRecoveryResult?.comparisonWitnessIds,
+              comparisonProfile: temporalRecoveryResult?.comparisonProfile,
+              recoveryDedupedOrder: dedupedRecoveryDebug,
+              recoveryFittedOrder: fittedRecoveryDebug,
               rawUserRecoveryCandidates: rawUserRecoveryDebug,
             }
           : undefined,
-      };
+        };
     },
     async compact({ sessionId, force, targetSize }: ContextCompactArgs) {
       const rpc = await getRpc();
@@ -967,6 +1143,42 @@ function dedupeRecoveryCandidates(items: SearchResult[]): SearchResult[] {
   return [...byKey.values()].sort((left, right) => (right.finalScore ?? right.score) - (left.finalScore ?? left.score));
 }
 
+function fitProtectedComparisonRecovery(
+  items: SearchResult[],
+  tokenBudget: number,
+  protectedWitnessIds?: string[],
+): SearchResult[] {
+  if (!protectedWitnessIds || protectedWitnessIds.length === 0) {
+    return fitPromptBudgetFirstFit(items, tokenBudget);
+  }
+
+  const protectedById = new Map<string, SearchResult>();
+  const remaining: SearchResult[] = [];
+
+  for (const item of items) {
+    if (protectedWitnessIds.includes(item.id) && !protectedById.has(item.id)) {
+      protectedById.set(item.id, item);
+      continue;
+    }
+    remaining.push(item);
+  }
+
+  const protectedItems = protectedWitnessIds
+    .map((id) => protectedById.get(id))
+    .filter((item): item is SearchResult => Boolean(item));
+  if (protectedItems.length !== protectedWitnessIds.length) {
+    return fitPromptBudgetFirstFit(items, tokenBudget);
+  }
+
+  const protectedTokens = protectedItems.reduce((sum, item) => sum + estimateTokens(item.text), 0);
+  if (protectedTokens > tokenBudget) {
+    return fitPromptBudgetFirstFit(items, tokenBudget);
+  }
+
+  const tail = fitPromptBudgetFirstFit(remaining, tokenBudget - protectedTokens);
+  return [...protectedItems, ...tail];
+}
+
 function clampFraction(value: number | undefined): number {
   if (typeof value !== "number" || !Number.isFinite(value)) {
     return 0;
@@ -1046,33 +1258,35 @@ async function ingestCanonicalMessage(params: {
       text: normalized.content,
     });
 
-    if (gating.g >= (params.cfg.ingestionGateThreshold ?? 0.35)) {
-      void rpc.call("insert_text", {
-        collection: `user:${durableNamespace}`,
-        id: `${durableNamespace}:${turnId}`,
-        text: normalized.content,
-        metadata: {
-          role: normalized.role,
-          ts,
-          sessionId: params.sessionId,
-          type: "turn",
-          userId: durableNamespace,
-          source_turn_id: turnId,
-          provenance_class: "durable_user_memory",
-          stability_weight: Math.max(stabilityWeightForMessage(normalized.role), gating.g),
-          gating_score: gating.g,
-          gating_t: gating.t,
-          gating_h: gating.h,
-          gating_r: gating.r,
-          gating_d: gating.d,
-          gating_p: gating.p,
-          gating_a: gating.a,
-          gating_dtech: gating.dtech,
-          gating_gconv: gating.gconv,
-          gating_gtech: gating.gtech,
-        },
-      }).catch(console.error);
-    }
+    // Gating is designed for markdown file deduplication — not conversational content.
+    // User turns must be stored durably regardless of gating score so the agent can recall
+    // friends, preferences, and context across sessions. Gating signals are still
+    // recorded in metadata for observability, but do not gate the insert.
+    void rpc.call("insert_text", {
+      collection: `user:${durableNamespace}`,
+      id: `${durableNamespace}:${turnId}`,
+      text: normalized.content,
+      metadata: {
+        role: normalized.role,
+        ts,
+        sessionId: params.sessionId,
+        type: "turn",
+        userId: durableNamespace,
+        source_turn_id: turnId,
+        provenance_class: "durable_user_memory",
+        stability_weight: Math.max(stabilityWeightForMessage(normalized.role), gating.g),
+        gating_score: gating.g,
+        gating_t: gating.t,
+        gating_h: gating.h,
+        gating_r: gating.r,
+        gating_d: gating.d,
+        gating_p: gating.p,
+        gating_a: gating.a,
+        gating_dtech: gating.dtech,
+        gating_gconv: gating.gconv,
+        gating_gtech: gating.gtech,
+      },
+    }).catch(console.error);
   } catch {
     // Session storage already happened; skip durable promotion on gating failure.
   }