@remnic/core 1.1.10 → 1.1.12

package/dist/{chunk-5GCNE7CN.js → chunk-BZSQEPRW.js}

@@ -2,15 +2,12 @@ import {
   CompoundingEngine,
   SharedContextManager,
   defaultTierMigrationCycleBudget
-} from "./chunk-4DXC6HQQ.js";
+} from "./chunk-FQDPCE3I.js";
 import {
   applyUtilityPromotionRuntimePolicy,
   applyUtilityRankingRuntimeDelta,
   loadUtilityRuntimeValues
 } from "./chunk-FSFEQI74.js";
-import {
-  isValidAsOf
-} from "./chunk-MDYG7VI7.js";
 import {
   TierMigrationExecutor
 } from "./chunk-Z5AAYHUC.js";
@@ -25,15 +22,36 @@ import {
 } from "./chunk-UHGBNIOS.js";
 import {
   HourlySummarizer
-} from "./chunk-PHNGXFQ6.js";
+} from "./chunk-7V22HTMD.js";
+import {
+  buildTargetedFactRecallSection,
+  shouldRecallTargetedFactEvidence
+} from "./chunk-VWT3F4IV.js";
 import {
   applyTemporalSupersession,
   normalizeSupersessionKey,
   shouldFilterSupersededFromRecall
-} from "./chunk-ZTSE2ZJ6.js";
+} from "./chunk-OIGNEXKZ.js";
+import {
+  isValidAsOf
+} from "./chunk-MDYG7VI7.js";
 import {
   SessionObserverState
 } from "./chunk-JR4ZC3G4.js";
+import {
+  applyRuntimeRetrievalPolicy
+} from "./chunk-5IZL4DCV.js";
+import {
+  RelevanceStore
+} from "./chunk-5NPGSAVB.js";
+import {
+  RerankCache,
+  rerankLocalOrNoop
+} from "./chunk-C7VW7C3F.js";
+import {
+  buildResponseGuidanceRecallSection,
+  shouldRecallResponseGuidance
+} from "./chunk-OZKZ2TRP.js";
 import {
   mergeWithAgentResults,
   runDirectAgent,
@@ -53,63 +71,66 @@ import {
   resolvePromptTagPrefilterAsync
 } from "./chunk-V3RXWQIE.js";
 import {
-  applyRuntimeRetrievalPolicy
-} from "./chunk-5IZL4DCV.js";
+  LastRecallStore,
+  TierMigrationStatusStore,
+  clampGraphRecallExpandedEntries
+} from "./chunk-WPGJYVUH.js";
 import {
   findUnresolvedEntityRefs
 } from "./chunk-X7XN6YU4.js";
 import {
-  RelevanceStore
-} from "./chunk-5NPGSAVB.js";
-import {
-  RerankCache,
-  rerankLocalOrNoop
-} from "./chunk-C7VW7C3F.js";
+  applyReasoningTraceBoost
+} from "./chunk-ZZTOURJI.js";
 import {
   reorderRecallResultsWithMmr
 } from "./chunk-YDBIWGNI.js";
 import {
   createRecallSectionMetricRecorder
 } from "./chunk-7DHTMOND.js";
-import {
-  LastRecallStore,
-  TierMigrationStatusStore,
-  clampGraphRecallExpandedEntries
-} from "./chunk-WPGJYVUH.js";
 import {
   buildQmdRecallCacheKey,
   getCachedQmdRecall,
   setCachedQmdRecall
 } from "./chunk-YCN4BVDK.js";
-import {
-  applyReasoningTraceBoost
-} from "./chunk-ZZTOURJI.js";
 import {
   NegativeExampleStore
 } from "./chunk-D654IBA6.js";
-import {
-  evaluateMemoryActionPolicy
-} from "./chunk-H63EDPFJ.js";
 import {
   applyMemoryWorthFilter,
   buildMemoryWorthCounterMap
 } from "./chunk-3GPTTA4J.js";
+import {
+  runLiveConnectorsOnce
+} from "./chunk-XMVFHBHT.js";
+import {
+  evaluateMemoryActionPolicy
+} from "./chunk-H63EDPFJ.js";
 import {
   hasBroadGraphIntent,
   inferIntentFromText,
   intentCompatibilityScore,
   isTaskInitiationIntent,
   planRecallMode
-} from "./chunk-GGD5W7TB.js";
-import {
-  runLiveConnectorsOnce
-} from "./chunk-XMVFHBHT.js";
+} from "./chunk-PD6O7AXF.js";
 import {
   classifyMemoryKind
 } from "./chunk-YAZNBMNF.js";
+import {
+  recordJudgeTrainingPair
+} from "./chunk-DF3RVK3X.js";
+import {
+  createDeferCountMap,
+  createVerdictCache,
+  getVerdictKind,
+  judgeFactDurability,
+  validateProcedureExtraction
+} from "./chunk-C4SQJZAF.js";
 import {
   ExtractionEngine
-} from "./chunk-Z5S5HNGY.js";
+} from "./chunk-ZG7PTKBK.js";
+import {
+  looksLikeMechanicalTelemetryTranscript
+} from "./chunk-4RA3C3EV.js";
 import {
   parseMemoryActionEligibilityContext
 } from "./chunk-WW3QQF4H.js";
@@ -118,59 +139,73 @@ import {
 } from "./chunk-QR3C7BKQ.js";
 import {
   LocalLlmClient
-} from "./chunk-NN3LPQ5D.js";
+} from "./chunk-HELQZFZO.js";
 import {
-  buildExplicitCueRecallSection
-} from "./chunk-ERUDW6DU.js";
+  buildFocusedListRecallSection,
+  shouldRecallFocusedListEvidence
+} from "./chunk-DB5A3NHS.js";
 import {
-  recordJudgeTrainingPair
-} from "./chunk-DF3RVK3X.js";
+  buildEntityRecallSection,
+  entityRecentTranscriptLookbackHours,
+  readRecentEntityTranscriptEntries
+} from "./chunk-UVMUAWVT.js";
 import {
-  createDeferCountMap,
-  createVerdictCache,
-  getVerdictKind,
-  judgeFactDurability,
-  validateProcedureExtraction
-} from "./chunk-C4SQJZAF.js";
+  buildEventOrderRecallSection,
+  shouldRecallEventOrderEvidence
+} from "./chunk-6NKAQ74D.js";
+import {
+  buildExplicitCueRecallSection
+} from "./chunk-OAZ5MFUB.js";
 import {
   formatDaySummaryMemories
 } from "./chunk-3IQ2TR4N.js";
 import {
   tryDirectAnswer
-} from "./chunk-6AUUAZEX.js";
+} from "./chunk-5NXIJZFX.js";
 import {
   EmbeddingFallback
 } from "./chunk-Z2E7VW55.js";
 import {
-  buildEntityRecallSection,
-  entityRecentTranscriptLookbackHours,
-  readRecentEntityTranscriptEntries
-} from "./chunk-LIO5X3CM.js";
+  CODEX_THREAD_KEY_PREFIX
+} from "./chunk-3PG3H5TD.js";
 import {
   buildCompressionGuidelinesMarkdown,
   computeCompressionGuidelineCandidate,
   refineCompressionGuidelineCandidateSemantically,
   renderCompressionGuidelinesMarkdown
 } from "./chunk-2NMMFZ5T.js";
+import {
+  buildConsolidationPrompt,
+  buildExtensionsBlockForConsolidation,
+  buildOperatorAwareConsolidationPrompt,
+  chooseConsolidationOperator,
+  findSimilarClusters,
+  materializeAfterSemanticConsolidation,
+  parseConsolidationResponse,
+  parseOperatorAwareConsolidationResponse
+} from "./chunk-CPKTBRS2.js";
 import {
   RoutingRulesStore,
   normalizeReplaySessionKey
-} from "./chunk-SRBJUAMP.js";
+} from "./chunk-FMEBPEAO.js";
 import {
   searchVerifiedEpisodes
-} from "./chunk-RXTFCYQF.js";
+} from "./chunk-JESOB2HO.js";
 import {
   ThreadingManager
 } from "./chunk-JRNQ3RNA.js";
 import {
   searchVerifiedSemanticRules
-} from "./chunk-PB5KW5PL.js";
+} from "./chunk-WEJG4TB5.js";
 import {
   searchWorkProductLedgerEntries
 } from "./chunk-CULXMQJH.js";
 import {
   TranscriptManager
 } from "./chunk-E6K4NIEU.js";
+import {
+  PolicyRuntimeManager
+} from "./chunk-EABGC2TL.js";
 import {
   NamespaceSearchRouter,
   NamespaceStorageRouter,
@@ -178,20 +213,22 @@ import {
   createConversationIndexRuntime,
   createSearchBackend,
   writeConversationChunks
-} from "./chunk-57QNCUEZ.js";
+} from "./chunk-HL5LRPNA.js";
 import {
   parseQmdExplain
 } from "./chunk-P77UEOU2.js";
 import {
-  PolicyRuntimeManager
-} from "./chunk-EABGC2TL.js";
+  isAboveImportanceThreshold,
+  scoreImportance
+} from "./chunk-JXS5PDQ7.js";
 import {
   searchHarmonicRetrieval
 } from "./chunk-HMDCOMYU.js";
 import {
-  isAboveImportanceThreshold,
-  scoreImportance
-} from "./chunk-JXS5PDQ7.js";
+  collectNativeKnowledgeChunks,
+  formatNativeKnowledgeSection,
+  searchNativeKnowledge
+} from "./chunk-7SEAZFFB.js";
 import {
   recordEvalShadowRecall
 } from "./chunk-K6WK37A6.js";
@@ -199,17 +236,9 @@ import {
   EXTRACTION_JUDGE_VERDICT_CATEGORY,
   recordJudgeVerdict
 } from "./chunk-AJU4PJGY.js";
-import {
-  collectNativeKnowledgeChunks,
-  formatNativeKnowledgeSection,
-  searchNativeKnowledge
-} from "./chunk-7SEAZFFB.js";
 import {
   applyCommitmentLedgerLifecycle
 } from "./chunk-FYIYMQ5N.js";
-import {
-  CODEX_THREAD_KEY_PREFIX
-} from "./chunk-3PG3H5TD.js";
 import {
   semanticChunkContent
 } from "./chunk-KVE7R4CG.js";
@@ -219,19 +248,9 @@ import {
 import {
   SmartBuffer
 } from "./chunk-JBMSGZEQ.js";
-import {
-  buildConsolidationPrompt,
-  buildExtensionsBlockForConsolidation,
-  buildOperatorAwareConsolidationPrompt,
-  chooseConsolidationOperator,
-  findSimilarClusters,
-  materializeAfterSemanticConsolidation,
-  parseConsolidationResponse,
-  parseOperatorAwareConsolidationResponse
-} from "./chunk-C5HUWVH2.js";
 import {
   FallbackLlmClient
-} from "./chunk-VX2IUQFE.js";
+} from "./chunk-AQJNPMOA.js";
 import {
   buildRecallQueryPolicy
 } from "./chunk-6HZ6AO2P.js";
@@ -260,13 +279,13 @@ import {
 import {
   listTrustZoneRecords,
   searchTrustZoneRecords
-} from "./chunk-EQINRHYR.js";
+} from "./chunk-QDZ2RLEC.js";
 import {
   buildXraySnapshot
-} from "./chunk-2YMTO4ZJ.js";
+} from "./chunk-JKDVIE52.js";
 import {
   parseMessageParts
-} from "./chunk-IBX3VFOM.js";
+} from "./chunk-D4GAOFF6.js";
 import {
   objectiveStateStoreOverrideForNamespace,
   searchObjectiveStateSnapshots
@@ -277,31 +296,21 @@ import {
 import {
   launchProcessSync
 } from "./chunk-OR64ZGRZ.js";
+import {
+  buildProcedurePersistBody
+} from "./chunk-QDW3E4RD.js";
 import {
   shouldSkipImplicitExtraction
 } from "./chunk-GVPWB7EY.js";
 import {
   selectRouteRule
 } from "./chunk-2LGMW3DJ.js";
-import {
-  buildProcedurePersistBody
-} from "./chunk-QDW3E4RD.js";
 import {
   GraphIndex
 } from "./chunk-RK2Y4XOM.js";
 import {
   searchCausalTrajectories
 } from "./chunk-G2WADRQ3.js";
-import {
-  canReadNamespace,
-  defaultNamespaceForPrincipal,
-  recallNamespacesForPrincipal,
-  resolvePrincipal
-} from "./chunk-N5AKDXAI.js";
-import {
-  decideLifecycleTransition,
-  resolveLifecycleState
-} from "./chunk-TBBDFYXW.js";
 import {
   ContentHashIndex,
   StorageManager,
@@ -309,8 +318,9 @@ import {
   fingerprintEntityStructuredFacts,
   normalizeAttributePairs,
   normalizeEntityName,
-  parseEntityFile
-} from "./chunk-MCC6KDQF.js";
+  parseEntityFile,
+  parseFlexibleIsoTimestamp
+} from "./chunk-3B6KIRBH.js";
 import {
   attachCitation,
   hasCitationForTemplate,
@@ -318,13 +328,13 @@ import {
 } from "./chunk-NN2DKE4T.js";
 import {
   confidenceTier
-} from "./chunk-VQXK37XA.js";
-import {
-  isActiveMemoryStatus
-} from "./chunk-RULE4VG5.js";
+} from "./chunk-23ZZK64Y.js";
 import {
   openBetterSqlite3
 } from "./chunk-XJKFSSDW.js";
+import {
+  isActiveMemoryStatus
+} from "./chunk-RULE4VG5.js";
 import {
   lintWorkspaceFiles,
   rotateMarkdownFileToArchive
@@ -335,6 +345,16 @@ import {
 import {
   resolveHomeDir
 } from "./chunk-MARWOCVP.js";
+import {
+  canReadNamespace,
+  defaultNamespaceForPrincipal,
+  recallNamespacesForPrincipal,
+  resolvePrincipal
+} from "./chunk-N5AKDXAI.js";
+import {
+  decideLifecycleTransition,
+  resolveLifecycleState
+} from "./chunk-TBBDFYXW.js";
 import {
   log
 } from "./chunk-2ODBA7MQ.js";
@@ -342,6 +362,9 @@ import {
   keyring_exports,
   secureStoreDir
 } from "./chunk-BJMBJZ2Y.js";
+import {
+  buildRetrievedMemoryProvenance
+} from "./chunk-AC5LO7IU.js";
 
 // src/orchestrator.ts
 import path6 from "path";
@@ -2413,6 +2436,15 @@ var LcmSummarizer = class {
    * 2 = Deterministic truncation (no LLM)
    */
   async summarizeWithEscalation(text, targetTokens) {
+    if (this.config.telemetryPrefilterEnabled && looksLikeMechanicalTelemetryTranscript(text)) {
+      return {
+        text: deterministicTruncate(
+          text,
+          Math.min(targetTokens, this.config.deterministicMaxTokens)
+        ),
+        escalation: 2
+      };
+    }
     try {
       const result = await this.summarizeFn(text, targetTokens, false);
       if (result && estimateTokens(result) <= targetTokens * 1.5) {
@@ -2668,6 +2700,8 @@ function extractLcmConfig(cfg) {
     deterministicMaxTokens: cfg.lcmDeterministicMaxTokens ?? 512,
     archiveRetentionDays: cfg.lcmArchiveRetentionDays ?? 90,
     recallBudgetShare: cfg.lcmRecallBudgetShare ?? 0.15,
+    observeConcurrency: typeof cfg.lcmObserveConcurrency === "number" && Number.isFinite(cfg.lcmObserveConcurrency) ? Math.max(1, Math.floor(cfg.lcmObserveConcurrency)) : 1,
+    telemetryPrefilterEnabled: cfg.lcmTelemetryPrefilterEnabled !== false,
     messagePartsEnabled: cfg.messagePartsEnabled === true,
     messagePartsRecallMaxResults: typeof cfg.messagePartsRecallMaxResults === "number" ? Math.max(0, Math.floor(cfg.messagePartsRecallMaxResults)) : 6
   };
@@ -2721,11 +2755,12 @@ var LcmEngine = class {
         leafBatchSize: this.config.leafBatchSize,
         rollupFanIn: this.config.rollupFanIn,
         maxDepth: this.config.maxDepth,
-        deterministicMaxTokens: this.config.deterministicMaxTokens
+        deterministicMaxTokens: this.config.deterministicMaxTokens,
+        telemetryPrefilterEnabled: this.config.telemetryPrefilterEnabled
       }
     );
     const observeQueue = new LcmWorkQueue({
-      concurrency: 1,
+      concurrency: this.config.observeConcurrency,
       worker: async (sessionId, messages) => {
         await this.processObserveMessages(sessionId, messages);
       },
@@ -3025,7 +3060,8 @@ ${preview}`,
       return {
         totalMessages: this.archive.getMessageCount(sessionId),
         totalSummaryNodes: this.dag.getNodeCount(sessionId),
-        maxDepth: this.dag.getMaxDepth(sessionId)
+        maxDepth: this.dag.getMaxDepth(sessionId),
+        maxTurnIndex: this.archive.getMaxTurnIndex(sessionId)
       };
     }
     return {
@@ -3388,6 +3424,102 @@ function sanitizeSessionKeyForFilename(sessionKey) {
   const hash = createHash2("sha256").update(sessionKey).digest("hex").slice(0, 12);
   return `${readable}-${hash}`;
 }
+function latestSourceValidAtFromTurns(turns) {
+  let latestMs = null;
+  for (const turn of turns) {
+    if (turn.extractionContextOnly === true) continue;
+    if (typeof turn.sourceValidAt !== "string") continue;
+    const parsed = parseFlexibleIsoTimestamp(turn.sourceValidAt.trim());
+    if (parsed === null) continue;
+    if (latestMs === null || parsed > latestMs) {
+      latestMs = parsed;
+    }
+  }
+  return latestMs === null ? void 0 : new Date(latestMs).toISOString();
+}
+function sourceValidAtMs(turn) {
+  if (typeof turn.sourceValidAt !== "string") return null;
+  return parseFlexibleIsoTimestamp(turn.sourceValidAt.trim());
+}
+var SOURCE_VALID_AT_CONTEXT_TURNS = 2;
+function sourceValidAtSliceKey(turn, index) {
+  const validAtMs = sourceValidAtMs(turn);
+  return validAtMs === null ? `unknown:${index}` : String(validAtMs);
+}
+function asExtractionContextTurn(turn) {
+  return { ...turn, extractionContextOnly: true };
+}
+function asExtractionTargetTurn(turn) {
+  const { extractionContextOnly: _contextOnly, ...targetTurn } = turn;
+  return targetTurn;
+}
+function sourceValidAtContextTurns(turns, targetStart, targetEnd, targetValidAtMs) {
+  if (targetValidAtMs === null) return [];
+  return turns.flatMap((turn, index) => {
+    if (index >= targetStart && index < targetEnd) return [];
+    const contextValidAtMs = sourceValidAtMs(turn);
+    if (contextValidAtMs === null || contextValidAtMs > targetValidAtMs) {
+      return [];
+    }
+    return [{ turn, index, validAtMs: contextValidAtMs }];
+  }).sort((a, b) => {
+    if (a.validAtMs < b.validAtMs) return -1;
+    if (a.validAtMs > b.validAtMs) return 1;
+    if (a.index === b.index) return 0;
+    return a.index < b.index ? -1 : 1;
+  }).slice(-SOURCE_VALID_AT_CONTEXT_TURNS).map(({ turn }) => asExtractionContextTurn(turn));
+}
+function targetSourceValidAtSortMs(turns) {
+  let latestMs = null;
+  for (const turn of turns) {
+    if (turn.extractionContextOnly === true) continue;
+    const validAtMs = sourceValidAtMs(turn);
+    if (validAtMs === null) continue;
+    if (latestMs === null || validAtMs > latestMs) {
+      latestMs = validAtMs;
+    }
+  }
+  return latestMs ?? Number.POSITIVE_INFINITY;
+}
+function sortSourceValidAtSlicesChronologically(slices) {
+  return slices.map((turns, order) => ({
+    turns,
+    order,
+    targetValidAtMs: targetSourceValidAtSortMs(turns)
+  })).sort((a, b) => {
+    if (a.targetValidAtMs < b.targetValidAtMs) return -1;
+    if (a.targetValidAtMs > b.targetValidAtMs) return 1;
+    if (a.order === b.order) return 0;
+    return a.order < b.order ? -1 : 1;
+  }).map((slice) => slice.turns);
+}
+function splitTurnsBySourceValidAt(turns) {
+  if (turns.length === 0) return [];
+  if (!turns.some((turn) => sourceValidAtMs(turn) !== null)) {
+    return [[...turns]];
+  }
+  const slices = [];
+  let start = 0;
+  while (start < turns.length) {
+    const targetValidAtMs = sourceValidAtMs(turns[start]);
+    const activeKey = sourceValidAtSliceKey(turns[start], start);
+    let end = start + 1;
+    while (end < turns.length && sourceValidAtSliceKey(turns[end], end) === activeKey) {
+      end += 1;
+    }
+    slices.push([
+      ...sourceValidAtContextTurns(
+        turns,
+        start,
+        end,
+        targetValidAtMs
+      ),
+      ...turns.slice(start, end).map(asExtractionTargetTurn)
+    ]);
+    start = end;
+  }
+  return sortSourceValidAtSlicesChronologically(slices);
+}
 function isArtifactMemoryPath(filePath) {
   return /(?:^|[\\/])artifacts(?:[\\/]|$)/i.test(filePath);
 }
@@ -4438,7 +4570,10 @@ var Orchestrator = class _Orchestrator {
       );
       return result2 ? { content: result2.content } : null;
     }
-    const result = await this.fastLlm.chatCompletion(messages, options);
+    const result = await this.fastLlm.chatCompletion(messages, {
+      ...options,
+      forceDisableThinking: true
+    });
     return result ? { content: result.content } : null;
   }
   /**
@@ -4452,7 +4587,12 @@ var Orchestrator = class _Orchestrator {
         chatCompletion: (messages, options) => this.fastChatCompletion(messages, options ?? {})
       };
     }
-    return this.fastLlm;
+    return {
+      chatCompletion: (messages, options) => this.fastLlm.chatCompletion(messages, {
+        ...options ?? {},
+        forceDisableThinking: true
+      })
+    };
   }
   async initialize() {
     this.deferredReady = new Promise((resolve) => {
@@ -5147,7 +5287,7 @@ ${doc.content}` : doc.content,
   }
   async runDeepSleepGovernanceNow(options) {
     const targetStorage = options?.storage ?? this.storage;
-    const { runMemoryGovernance } = await import("./memory-governance-F3QOJGEY.js");
+    const { runMemoryGovernance } = await import("./memory-governance-IMPQZXFC.js");
     const { summarizeGovernanceResultForDreams } = await import("./dreams-ledger-LR2NBAZE.js");
     const govResult = await runMemoryGovernance({
       memoryDir: targetStorage.dir,
@@ -5249,7 +5389,8 @@ ${doc.content}` : doc.content,
             operation: "semantic-consolidation",
             maxTokens: llmOpts.maxTokens,
             temperature: llmOpts.temperature,
-            priority: "background"
+            priority: "background",
+            forceDisableThinking: true
           });
           response = fastResult ? { content: fastResult.content } : null;
         } else {
@@ -7011,6 +7152,11 @@ ${r.snippet.trim()}
     if (!entry) return defaultEnabled;
     return entry.enabled !== false;
   }
+  isSpecializedRecallSectionEnabled(sectionId, topLevelEnabled) {
+    const entry = this.getRecallSectionEntry(sectionId);
+    if (!entry) return topLevelEnabled;
+    return entry.enabled === true || topLevelEnabled && entry.enabled !== false;
+  }
   getRecallSectionMaxChars(sectionId) {
     const entry = this.getRecallSectionEntry(sectionId);
     if (!entry) return void 0;
@@ -9086,6 +9232,114 @@ ${formatted}`;
           log.debug(`Explicit cue recall assembly error: ${err}`);
         }
       }
+      const targetedFactMaxChars = this.getRecallSectionMaxChars("targeted-facts") ?? this.config.targetedFactRecallMaxChars;
+      if (this.isSpecializedRecallSectionEnabled(
+        "targeted-facts",
+        this.config.targetedFactRecallEnabled
+      ) && targetedFactMaxChars !== 0 && this.lcmEngine?.enabled && recallMode !== "no_recall" && shouldRecallTargetedFactEvidence(retrievalQuery)) {
+        try {
+          const targetedFactSection = await buildTargetedFactRecallSection({
+            engine: this.lcmEngine,
+            sessionId: sessionKey,
+            query: retrievalQuery,
+            maxChars: targetedFactMaxChars,
+            maxSearchResults: this.getRecallSectionNumber("targeted-facts", "maxResults") ?? this.config.targetedFactRecallMaxResults,
+            maxScanWindowTurns: this.getRecallSectionNumber("targeted-facts", "maxTurns") ?? this.config.targetedFactRecallScanWindowTurns,
+            maxScanWindowTokens: this.getRecallSectionNumber("targeted-facts", "maxTokens") ?? this.config.targetedFactRecallScanWindowTokens
+          });
+          if (targetedFactSection) {
+            this.appendRecallSection(
+              sectionBuckets,
+              "targeted-facts",
+              targetedFactSection
+            );
+          }
+        } catch (err) {
+          log.debug(`Targeted fact recall assembly error: ${err}`);
+        }
+      }
+      const focusedListMaxChars = this.getRecallSectionMaxChars("focused-list") ?? this.config.focusedListRecallMaxChars;
+      if (this.isSpecializedRecallSectionEnabled(
+        "focused-list",
+        this.config.focusedListRecallEnabled
+      ) && focusedListMaxChars !== 0 && this.lcmEngine?.enabled && recallMode !== "no_recall" && shouldRecallFocusedListEvidence(retrievalQuery)) {
+        try {
+          const focusedListSection = await buildFocusedListRecallSection({
+            engine: this.lcmEngine,
+            sessionId: sessionKey,
+            query: retrievalQuery,
+            maxChars: focusedListMaxChars,
+            maxSearchResults: this.getRecallSectionNumber("focused-list", "maxResults") ?? this.config.focusedListRecallMaxResults,
+            maxScanWindowTurns: this.getRecallSectionNumber("focused-list", "maxTurns") ?? this.config.focusedListRecallScanWindowTurns,
+            maxScanWindowTokens: this.getRecallSectionNumber("focused-list", "maxTokens") ?? this.config.focusedListRecallScanWindowTokens
+          });
+          if (focusedListSection) {
+            this.appendRecallSection(
+              sectionBuckets,
+              "focused-list",
+              focusedListSection
+            );
+          }
+        } catch (err) {
+          log.debug(`Focused list recall assembly error: ${err}`);
+        }
+      }
+      const responseGuidanceMaxChars = this.getRecallSectionMaxChars("response-guidance") ?? this.config.responseGuidanceRecallMaxChars;
+      const responseGuidanceEntry = this.getRecallSectionEntry("response-guidance");
+      const responseGuidanceMatchesQuery = shouldRecallResponseGuidance(retrievalQuery);
+      const responseGuidanceForcedByPipeline = responseGuidanceEntry?.forceGeneric === true && !responseGuidanceMatchesQuery;
+      if (this.isSpecializedRecallSectionEnabled(
+        "response-guidance",
+        this.config.responseGuidanceRecallEnabled
+      ) && responseGuidanceMaxChars !== 0 && this.lcmEngine?.enabled && recallMode !== "no_recall" && (responseGuidanceMatchesQuery || responseGuidanceForcedByPipeline)) {
+        try {
+          const responseGuidanceSection = await buildResponseGuidanceRecallSection({
+            engine: this.lcmEngine,
+            sessionId: sessionKey,
+            query: retrievalQuery,
+            maxChars: responseGuidanceMaxChars,
+            maxSearchResults: this.getRecallSectionNumber("response-guidance", "maxResults") ?? this.config.responseGuidanceRecallMaxResults,
+            maxScanWindowTurns: this.getRecallSectionNumber("response-guidance", "maxTurns") ?? this.config.responseGuidanceRecallScanWindowTurns,
+            maxScanWindowTokens: this.getRecallSectionNumber("response-guidance", "maxTokens") ?? this.config.responseGuidanceRecallScanWindowTokens,
+            forceGeneric: responseGuidanceForcedByPipeline
+          });
+          if (responseGuidanceSection) {
+            this.appendRecallSection(
+              sectionBuckets,
+              "response-guidance",
+              responseGuidanceSection
+            );
+          }
+        } catch (err) {
+          log.debug(`Response guidance recall assembly error: ${err}`);
+        }
+      }
+      const eventOrderMaxChars = this.getRecallSectionMaxChars("event-order") ?? this.config.eventOrderRecallMaxChars;
+      if (this.isSpecializedRecallSectionEnabled(
+        "event-order",
+        this.config.eventOrderRecallEnabled
+      ) && eventOrderMaxChars !== 0 && this.lcmEngine?.enabled && recallMode !== "no_recall" && shouldRecallEventOrderEvidence(retrievalQuery)) {
+        try {
+          const eventOrderSection = await buildEventOrderRecallSection({
+            engine: this.lcmEngine,
+            sessionId: sessionKey,
+            query: retrievalQuery,
+            maxChars: eventOrderMaxChars,
+            maxItems: this.getRecallSectionNumber("event-order", "maxResults") ?? this.config.eventOrderRecallMaxResults,
+            maxScanWindowTurns: this.getRecallSectionNumber("event-order", "maxTurns") ?? this.config.eventOrderRecallScanWindowTurns,
+            maxScanWindowTokens: this.getRecallSectionNumber("event-order", "maxTokens") ?? this.config.eventOrderRecallScanWindowTokens
+          });
+          if (eventOrderSection) {
+            this.appendRecallSection(
+              sectionBuckets,
+              "event-order",
+              eventOrderSection
+            );
+          }
+        } catch (err) {
+          log.debug(`Event order recall assembly error: ${err}`);
+        }
+      }
       if (profile)
         this.appendRecallSection(
           sectionBuckets,
@@ -10093,12 +10347,27 @@ _Context: ${topQuestion.context}_`
             if (xrayResult?.explain?.reinforcementBoost !== void 0 && xrayResult.explain.reinforcementBoost > 0) {
               scoreDecomposition.reinforcementBoost = xrayResult.explain.reinforcementBoost;
             }
+            const resultNamespace = this.namespaceFromPath(recalledPath);
+            let provenance;
+            try {
+              const resultStorage = await this.storageRouter.storageFor(resultNamespace);
+              const memory = await resultStorage.readMemoryByPath(recalledPath);
+              if (memory) {
+                provenance = buildRetrievedMemoryProvenance(memory, {
+                  namespace: resultNamespace,
+                  retrievalReason: `served-by=${servedBy}`,
+                  currentContextScopes: options.currentContextScopes
+                });
+              }
+            } catch {
+            }
             results.push({
               memoryId: derivedId,
               path: recalledPath,
               servedBy,
               scoreDecomposition,
-              admittedBy: []
+              admittedBy: [],
+              ...provenance ? { provenance } : {}
             });
           }
           let xrayConsidered;
@@ -10309,6 +10578,7 @@ _Context: ${topQuestion.context}_`
         role: turn.role,
         content: turn.content,
         timestamp: turn.timestamp,
+        sourceValidAt: turn.sourceValidAt,
         sessionKey: key,
         parts: turn.parts,
         rawContent: turn.rawContent,
@@ -10316,7 +10586,7 @@ _Context: ${topQuestion.context}_`
       });
       bySession.set(key, list);
     }
-    const replayTasks = [];
+    const replaySlices = [];
     for (const [key, sessionTurns] of bySession.entries()) {
       if (sessionTurns.length === 0) continue;
       if (options.archiveLcm !== false && this.lcmEngine?.enabled) {
@@ -10331,19 +10601,33 @@ _Context: ${topQuestion.context}_`
           }))
         );
       }
-      replayTasks.push(
-        new Promise((resolve, reject) => {
-          void this.queueBufferedExtraction(sessionTurns, "trigger_mode", {
-            skipDedupeCheck: true,
-            clearBufferAfterExtraction: false,
-            skipCharThreshold: true,
-            bufferKey: key,
-            extractionDeadlineMs: options.deadlineMs,
-            onTaskSettled: (err) => err ? reject(err) : resolve()
-          }).catch(reject);
-        })
-      );
+      for (const sessionSlice of splitTurnsBySourceValidAt(sessionTurns)) {
+        replaySlices.push({
+          bufferKey: key,
+          order: replaySlices.length,
+          targetValidAtMs: targetSourceValidAtSortMs(sessionSlice),
+          turns: sessionSlice
+        });
+      }
     }
+    const replayTasks = replaySlices.sort((a, b) => {
+      if (a.targetValidAtMs < b.targetValidAtMs) return -1;
+      if (a.targetValidAtMs > b.targetValidAtMs) return 1;
+      if (a.order === b.order) return 0;
+      return a.order < b.order ? -1 : 1;
+    }).map(
+      ({ bufferKey, turns: sessionSlice }) => new Promise((resolve, reject) => {
+        void this.queueBufferedExtraction(sessionSlice, "trigger_mode", {
+          skipDedupeCheck: true,
+          clearBufferAfterExtraction: false,
+          skipCharThreshold: true,
+          skipUserTurnThreshold: true,
+          bufferKey,
+          extractionDeadlineMs: options.deadlineMs,
+          onTaskSettled: (err) => err ? reject(err) : resolve()
+        }).catch(reject);
+      })
+    );
     if (replayTasks.length > 0) {
       const settled = await Promise.allSettled(replayTasks);
       const firstRejected = settled.find(
@@ -10419,6 +10703,7 @@ _Context: ${topQuestion.context}_`
         role: turn.role,
         content: turn.content,
         timestamp: turn.timestamp,
+        sourceValidAt: turn.timestamp,
         sessionKey,
         parts: turn.parts,
         rawContent: turn.rawContent,
@@ -10438,17 +10723,27 @@ _Context: ${topQuestion.context}_`
         }))
       );
     }
-    await new Promise((resolve, reject) => {
-      void this.queueBufferedExtraction(sessionTurns, "trigger_mode", {
-        skipDedupeCheck: true,
-        clearBufferAfterExtraction: false,
-        skipCharThreshold: true,
-        bufferKey: sessionKey,
-        extractionDeadlineMs: options.deadlineMs,
-        writeNamespaceOverride: this.bulkImportWriteNamespace(),
-        onTaskSettled: (err) => err ? reject(err) : resolve()
-      }).catch(reject);
-    });
+    const importTasks = splitTurnsBySourceValidAt(sessionTurns).map(
+      (sessionSlice) => new Promise((resolve, reject) => {
+        void this.queueBufferedExtraction(sessionSlice, "trigger_mode", {
+          skipDedupeCheck: true,
+          clearBufferAfterExtraction: false,
+          skipCharThreshold: true,
+          skipUserTurnThreshold: true,
+          bufferKey: sessionKey,
+          extractionDeadlineMs: options.deadlineMs,
+          writeNamespaceOverride: this.bulkImportWriteNamespace(),
+          onTaskSettled: (err) => err ? reject(err) : resolve()
+        }).catch(reject);
+      })
+    );
+    const settled = await Promise.allSettled(importTasks);
+    const firstRejected = settled.find(
+      (result) => result.status === "rejected"
+    );
+    if (firstRejected) {
+      throw firstRejected.reason;
+    }
   }
   async observeSessionHeartbeat(sessionKey, options = {}) {
     if (this.config.sessionObserverEnabled !== true) return;
@@ -10514,6 +10809,7 @@ _Context: ${topQuestion.context}_`
         await this.runExtraction(turnsToExtract, {
           clearBufferAfterExtraction: options.clearBufferAfterExtraction ?? true,
           skipCharThreshold: options.skipCharThreshold ?? false,
+          skipUserTurnThreshold: options.skipUserTurnThreshold ?? false,
           deadlineMs: options.extractionDeadlineMs,
           bufferKey,
           abortSignal: options.abortSignal,
@@ -10622,6 +10918,7 @@ ${normalized}`).digest("hex");
     log.debug(`running extraction on ${turns.length} turns`);
     const clearBufferAfterExtraction = options.clearBufferAfterExtraction ?? true;
     const skipCharThreshold = options.skipCharThreshold ?? false;
+    const skipUserTurnThreshold = options.skipUserTurnThreshold ?? false;
     const deadlineMs = typeof options.deadlineMs === "number" && Number.isFinite(options.deadlineMs) ? options.deadlineMs : void 0;
     const bufferKey = options.bufferKey ?? turns[0]?.sessionKey ?? "default";
     const throwIfDeadlineExceeded = (stage) => {
@@ -10652,15 +10949,24 @@ ${normalized}`).digest("hex");
       ...t,
       content: t.content.trim().slice(0, this.config.extractionMaxTurnChars)
     })).filter((t) => t.content.length > 0);
+    const targetTurns = normalizedTurns.filter(
+      (turn) => turn.extractionContextOnly !== true
+    );
+    if (targetTurns.length === 0) {
+      log.debug("skipping extraction: no non-context turns after normalization");
+      await clearBuffer();
+      return;
+    }
+    const sourceValidAt = latestSourceValidAtFromTurns(targetTurns);
     throwIfDeadlineExceeded("before_extract");
     throwIfAborted2("before_extract");
-    const userTurns = normalizedTurns.filter((t) => t.role === "user");
-    const totalChars = normalizedTurns.reduce(
+    const userTurns = targetTurns.filter((t) => t.role === "user");
+    const totalChars = targetTurns.reduce(
       (sum, t) => sum + t.content.length,
       0
     );
     const belowCharThreshold = totalChars < this.config.extractionMinChars;
-    const belowUserTurnThreshold = userTurns.length < this.config.extractionMinUserTurns;
+    const belowUserTurnThreshold = !skipUserTurnThreshold && userTurns.length < this.config.extractionMinUserTurns;
     if (!skipCharThreshold && belowCharThreshold || belowUserTurnThreshold) {
       log.debug(
         `skipping extraction: below threshold (totalChars=${totalChars}, userTurns=${userTurns.length})`
@@ -10674,11 +10980,11 @@ ${normalized}`).digest("hex");
       defaultNamespaceForPrincipal(principal, this.config)
     );
     const storage = await this.storageRouter.storageFor(selfNamespace);
-    const shouldPersistProcessedFingerprint = normalizedTurns.some(
+    const shouldPersistProcessedFingerprint = targetTurns.some(
       (turn) => turn.persistProcessedFingerprint === true
     );
     const extractionFingerprint = this.buildExtractionFingerprint(
-      normalizedTurns,
+      targetTurns,
       bufferKey
     );
     let meta = extractionFingerprint && shouldPersistProcessedFingerprint ? await storage.loadMeta() : null;
@@ -10738,7 +11044,7 @@ ${normalized}`).digest("hex");
       result,
       storage,
       threadIdForExtraction,
-      { sessionKey, principal }
+      { sessionKey, principal, validAt: sourceValidAt }
     );
     meta ??= await storage.loadMeta();
     if (extractionFingerprint && shouldPersistProcessedFingerprint) {
@@ -11099,6 +11405,7 @@ ${normalized}`).digest("hex");
       };
       return attachCitation(content, citationContext, citationTemplate);
     };
+    const supersessionOrderingAt = (validAt) => validAt && validAt.length > 0 ? validAt : (/* @__PURE__ */ new Date()).toISOString();
     const persistedIds = [];
     const persistedIdsByStorage = /* @__PURE__ */ new Map();
     const trackPersistedId = (targetStorage, id, options = {}) => {
@@ -11194,7 +11501,7 @@ ${normalized}`).digest("hex");
                   newMemoryId: hashDedupMatchingFact.frontmatter.id,
                   entityRef: options.entityRef,
                   structuredAttributes: options.structuredAttributes,
-                  createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+                  createdAt: supersessionOrderingAt(options.validAt),
                   enabled: true,
                   useCallerTimestamp: true
                 });
@@ -11234,6 +11541,7 @@ ${normalized}`).digest("hex");
             intentActionType: options.intentActionType,
             intentEntityTypes: options.intentEntityTypes,
             memoryKind: options.memoryKind,
+            validAt: options.validAt,
             // Index the RAW content hash so hasFactContentHash(rawContent)
             // returns true on subsequent extractions. Without this, the index
             // would record the hash of citedContent (which changes every call
@@ -11248,7 +11556,7 @@ ${normalized}`).digest("hex");
               newMemoryId: promotedId,
               entityRef: options.entityRef,
               structuredAttributes: options.structuredAttributes,
-              createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+              createdAt: supersessionOrderingAt(options.validAt),
               enabled: true
             });
           } catch (sharedSupersessionErr) {
@@ -11710,6 +12018,7 @@ ${normalized}`).digest("hex");
               intentEntityTypes: inferredIntent?.entityTypes,
               memoryKind: memoryKind2,
               structuredAttributes: fact.structuredAttributes,
+              validAt: sourceContext?.validAt,
               contentHashSource: rawChunkedContent
             }
           );
@@ -11737,7 +12046,8 @@ ${normalized}`).digest("hex");
                 intentGoal: inferredIntent?.goal,
                 intentActionType: inferredIntent?.actionType,
                 intentEntityTypes: inferredIntent?.entityTypes,
-                memoryKind: memoryKind2
+                memoryKind: memoryKind2,
+                validAt: sourceContext?.validAt
               }
             );
           }
@@ -11761,7 +12071,7 @@ ${normalized}`).digest("hex");
               newMemoryId: parentId,
               entityRef: supersessionEntityRef,
               structuredAttributes: fact.structuredAttributes,
-              createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+              createdAt: supersessionOrderingAt(sourceContext?.validAt),
               enabled: this.config.temporalSupersessionEnabled
             });
           } catch (err) {
@@ -11781,6 +12091,7 @@ ${normalized}`).digest("hex");
             intentActionType: inferredIntent?.actionType,
             intentEntityTypes: inferredIntent?.entityTypes,
             memoryKind: memoryKind2,
+            validAt: sourceContext?.validAt,
             source: extractionWriteSource
           });
           if (this.contentHashIndex) {
@@ -11881,6 +12192,7 @@ ${normalized}`).digest("hex");
           intentEntityTypes: inferredIntent?.entityTypes,
           memoryKind,
           structuredAttributes: fact.structuredAttributes,
+          validAt: sourceContext?.validAt,
           contentHashSource: writeCategory === "fact" ? fact.content : void 0
         }
       );
@@ -11896,7 +12208,7 @@ ${normalized}`).digest("hex");
           newMemoryId: memoryId,
           entityRef: supersessionEntityRef,
           structuredAttributes: fact.structuredAttributes,
-          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          createdAt: supersessionOrderingAt(sourceContext?.validAt),
           enabled: this.config.temporalSupersessionEnabled
         });
       } catch (err) {
@@ -11932,6 +12244,7 @@ ${normalized}`).digest("hex");
         intentActionType: inferredIntent?.actionType,
         intentEntityTypes: inferredIntent?.entityTypes,
         memoryKind,
+        validAt: sourceContext?.validAt,
         source: extractionWriteSource
       });
       if (this.config.multiGraphMemoryEnabled) {
@@ -11996,6 +12309,7 @@ ${normalized}`).digest("hex");
         const safeFacts = Array.isArray(entity?.facts) ? entity.facts.filter((f) => typeof f === "string") : [];
         const id = await storage.writeEntity(name, type, safeFacts, {
           source: typeof entity?.source === "string" ? entity.source : "extraction",
+          timestamp: sourceContext?.validAt,
           sessionKey: sourceContext?.sessionKey,
           principal: sourceContext?.principal,
           structuredSections: Array.isArray(entity?.structuredSections) ? entity.structuredSections : void 0
@@ -14393,4 +14707,4 @@ export {
   resolvePersistedMemoryRelativePath,
   Orchestrator
 };
-//# sourceMappingURL=chunk-5GCNE7CN.js.map
+//# sourceMappingURL=chunk-BZSQEPRW.js.map