@remnic/core 9.3.648 → 9.3.650

package/dist/{chunk-TWVRDGTX.js → chunk-23RYLGYA.js}

@@ -231,7 +231,7 @@ import {
 } from "./chunk-ZRWB5D4H.js";
 import {
   TranscriptManager
-} from "./chunk-XUGQQPGO.js";
+} from "./chunk-AGRPGAKR.js";
 import {
   NamespaceStorageRouter
 } from "./chunk-D6WVJIS3.js";
@@ -303,8 +303,9 @@ import {
 import {
   clusterByKey,
   combineNamespaces,
+  lcmReadSessionIdsForNamespaces,
   resolveCodingNamespaceOverlay
-} from "./chunk-6GIKAUTN.js";
+} from "./chunk-MMJANTJX.js";
 import {
   listTrustZoneRecords,
   searchTrustZoneRecords
@@ -2512,6 +2513,52 @@ var Orchestrator = class _Orchestrator {
     );
     return this.applyCodingNamespaceOverlay(sessionKey, base);
   }
+  /**
+   * Effective namespace a same-session LCM/structured-history READER must use
+   * to find what the access `observe` surface WROTE (#1495 thread 2).
+   *
+   * This MUST mirror the `observe` scope plan's write-namespace resolution, NOT
+   * `resolveSelfNamespace`: when no coding overlay applies, `observe` archives
+   * under `config.defaultNamespace` (an unqualified observed turn is NOT moved
+   * to the principal self namespace — identical to
+   * `resolveCodingScopedWriteNamespace`/`memory_store`, rule 39). Only when a
+   * coding overlay actually changes the namespace does the writer (and so the
+   * reader) use the overlaid `project-*` namespace. Returning the self base for
+   * the no-overlay case would prefix the read key with a namespace the writer
+   * never used, so the reader would miss its own evidence.
+   *
+   * Honours the access-surface `principalOverride` (#1505 thread 2, codex): when
+   * a recall supplies an authenticated principal NOT encoded in the raw
+   * `sessionKey`, `observe` archived LCM under THAT principal's base namespace.
+   * Deriving the base from `resolvePrincipal(sessionKey)` alone could fall back
+   * to `default`, so principal `alice` observing `sess-1` would write under
+   * `alice` but READ under `default`. Threading the override here keeps the read
+   * base identical to the write base.
+   *
+   * READ-AUTHORIZATION gate (#1505 round 3, codex P2 "Gate LCM recall keys by
+   * readable namespaces"): the overlay LCM read key is a `<principal>-project-*`
+   * sub-namespace of the principal SELF base. The normal recall namespace set
+   * below only substitutes the coding overlay when the principal SELF base is
+   * actually in the readable recall set (`recallNamespacesForPrincipal` — gated
+   * by `defaultRecallNamespaces.includes("self")` AND `canReadNamespace`). If a
+   * principal can WRITE but not READ its self namespace (or `defaultRecall-
+   * Namespaces` omits `self`), QMD/file recall never touches those overlay rows,
+   * so neither may the LCM read key. When the self base is NOT readable, fall
+   * back to the default store — exactly what an unqualified, unauthorized recall
+   * resolves to — rather than injecting overlay rows the rest of recall excludes
+   * (rule 42 read/write parity; rule 48 least-privilege).
+   */
+  lcmReadNamespaceForSession(sessionKey, principalOverride) {
+    const principal = typeof principalOverride === "string" && principalOverride.length > 0 ? principalOverride : this.resolvePrincipal(sessionKey);
+    const base = defaultNamespaceForPrincipal(principal, this.config);
+    const overlaid = this.applyCodingNamespaceOverlay(sessionKey, base);
+    if (overlaid === base) return this.config.defaultNamespace;
+    const selfReadableInRecall = recallNamespacesForPrincipal(
+      principal,
+      this.config
+    ).includes(base);
+    return selfReadableInRecall ? overlaid : this.config.defaultNamespace;
+  }
   /**
    * Attach a coding-agent context to a session (issue #569). Called by the
    * Claude Code / Codex / Cursor connectors at session start after
@@ -6142,6 +6189,30 @@ ${r.snippet.trim()}
       } else {
         recallNamespaces = readableRecallNamespaces;
       }
+      const codingOverlaySelfReadable = codingOverlay !== null && readableRecallNamespaces.includes(principalSelfNamespace);
+      let lcmReadNamespaces;
+      if (namespaceOverride) {
+        lcmReadNamespaces = [namespaceOverride];
+      } else if (codingOverlay && codingSelfNamespace && codingOverlaySelfReadable) {
+        const fallbackNs = codingOverlay.readFallbacks.map(
+          (fallback) => combineNamespaces(principalSelfNamespace, fallback)
+        );
+        lcmReadNamespaces = [codingSelfNamespace, ...fallbackNs];
+      } else {
+        lcmReadNamespaces = [this.config.defaultNamespace];
+      }
+      const lcmReadSessionIds = lcmReadSessionIdsForNamespaces(
+        lcmReadNamespaces,
+        sessionKey,
+        this.config.defaultNamespace
+      );
+      const firstNonEmptyLcmRead = async (read, isEmpty, empty) => {
+        for (const lcmSessionId of lcmReadSessionIds) {
+          const value = await read(lcmSessionId);
+          if (!isEmpty(value)) return value;
+        }
+        return empty;
+      };
       const qmdAvailable = this.qmd.isAvailable();
       let graphDecisionStatus = recallDecision.plannedMode === "graph_mode" ? "skipped" : "not_requested";
       let graphDecisionReason = recallDecision.graphReason;
@@ -7933,13 +8004,21 @@ ${formatted}`;
       const explicitCueMaxChars = this.getRecallSectionMaxChars("explicit-cue") ?? this.config.explicitCueRecallMaxChars;
       if (this.config.explicitCueRecallEnabled && this.isRecallSectionEnabled("explicit-cue") && explicitCueMaxChars !== 0 && this.lcmEngine?.enabled && recallMode !== "no_recall") {
         try {
-          const explicitCueSection = await buildExplicitCueRecallSection({
-            engine: this.lcmEngine,
-            sessionId: sessionKey,
-            query: retrievalQuery,
-            maxChars: explicitCueMaxChars,
-            maxReferences: this.getRecallSectionNumber("explicit-cue", "maxResults") ?? this.config.explicitCueRecallMaxReferences
-          });
+          const explicitCueSection = await firstNonEmptyLcmRead(
+            (lcmSessionId) => buildExplicitCueRecallSection({
+              engine: this.lcmEngine,
+              // #1495 thread 3 + #1505 fallback unification: read across the
+              // ordered LCM read key set (primary overlay → coding fallbacks)
+              // so a branch-scoped session finds its own explicit-cue evidence
+              // even when archived at project/root scope (rule 39).
+              sessionId: lcmSessionId,
+              query: retrievalQuery,
+              maxChars: explicitCueMaxChars,
+              maxReferences: this.getRecallSectionNumber("explicit-cue", "maxResults") ?? this.config.explicitCueRecallMaxReferences
+            }),
+            (s) => !s,
+            ""
+          );
           if (explicitCueSection) {
             this.appendRecallSection(
               sectionBuckets,
@@ -7957,15 +8036,22 @@ ${formatted}`;
         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
-          });
+          const targetedFactSection = await firstNonEmptyLcmRead(
+            (lcmSessionId) => buildTargetedFactRecallSection({
+              engine: this.lcmEngine,
+              // #1495 + #1505 fallback unification: read across the ordered LCM
+              // read key set so a branch-scoped session finds its own
+              // targeted-fact evidence even when archived at project/root scope.
+              sessionId: lcmSessionId,
+              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
+            }),
+            (s) => !s,
+            ""
+          );
           if (targetedFactSection) {
             this.appendRecallSection(
               sectionBuckets,
@@ -7983,15 +8069,22 @@ ${formatted}`;
         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
-          });
+          const focusedListSection = await firstNonEmptyLcmRead(
+            (lcmSessionId) => buildFocusedListRecallSection({
+              engine: this.lcmEngine,
+              // #1495 thread 3 + #1505 fallback unification: read across the
+              // ordered LCM read key set so a branch-scoped session reads its own
+              // focused-list/count evidence even at project/root scope (rule 39).
+              sessionId: lcmSessionId,
+              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
+            }),
+            (s) => !s,
+            ""
+          );
           if (focusedListSection) {
             this.appendRecallSection(
               sectionBuckets,
@@ -8012,16 +8105,23 @@ ${formatted}`;
         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
-          });
+          const responseGuidanceSection = await firstNonEmptyLcmRead(
+            (lcmSessionId) => buildResponseGuidanceRecallSection({
+              engine: this.lcmEngine,
+              // #1495 thread 3 + #1505 fallback unification: read across the
+              // ordered LCM read key set so a branch-scoped session reads its own
+              // response-guidance evidence even at project/root scope (rule 39).
+              sessionId: lcmSessionId,
+              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
+            }),
+            (s) => !s,
+            ""
+          );
           if (responseGuidanceSection) {
             this.appendRecallSection(
               sectionBuckets,
@@ -8039,15 +8139,22 @@ ${formatted}`;
         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
-          });
+          const eventOrderSection = await firstNonEmptyLcmRead(
+            (lcmSessionId) => buildEventOrderRecallSection({
+              engine: this.lcmEngine,
+              // #1495 thread 3 + #1505 fallback unification: read across the
+              // ordered LCM read key set so a branch-scoped session reads its own
+              // chronological event-order evidence even at project/root scope.
+              sessionId: lcmSessionId,
+              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
+            }),
+            (s) => !s,
+            ""
+          );
           if (eventOrderSection) {
             this.appendRecallSection(
               sectionBuckets,
@@ -8182,9 +8289,19 @@ ${tmtNode.summary}`
       }
       if (this.lcmEngine?.enabled && recallMode !== "minimal" && recallMode !== "no_recall") {
         try {
-          const structuredMatches = await this.lcmEngine.searchStructuredParts(
-            sessionKey ?? "default",
-            retrievalQuery
+          const structuredMatches = await firstNonEmptyLcmRead(
+            (lcmSessionId) => this.lcmEngine.searchStructuredParts(
+              // #1495 + #1505 fallback unification: read across the ordered LCM
+              // read key set so a branch-scoped session reads its own structured
+              // message-part evidence even when archived at project/root scope.
+              // Structured parts are inherently per-session (the DAG is keyed by
+              // session_id), so a SESSIONLESS read (`undefined`) normalizes to
+              // empty → no section, the correct pre-#1505 behavior (codex P2).
+              lcmSessionId ?? "",
+              retrievalQuery
+            ),
+            (matches) => matches.length === 0,
+            []
           );
           const structuredSection = this.lcmEngine.formatStructuredRecall(
             structuredMatches,
@@ -8208,9 +8325,19 @@ ${tmtNode.summary}`
               }
             }
           }
-          const lcmSection = await this.lcmEngine.assembleRecall(
-            sessionKey ?? "default",
-            this.config.recallBudgetChars
+          const lcmSection = await firstNonEmptyLcmRead(
+            (lcmSessionId) => this.lcmEngine.assembleRecall(
+              // #1495 + #1505 fallback unification: read across the ordered LCM
+              // read key set so a branch-scoped session reads its own
+              // compressed-history evidence even at project/root scope.
+              // Compressed history is inherently per-session (a per-session DAG),
+              // so a SESSIONLESS read (`undefined`) normalizes to empty → no
+              // section, the correct pre-#1505 behavior (codex P2).
+              lcmSessionId ?? "",
+              this.config.recallBudgetChars
+            ),
+            (s) => !s,
+            ""
           );
           if (lcmSection) {
             this.appendRecallSection(
@@ -9425,6 +9552,8 @@ _Context: ${topQuestion.context}_`
           bufferKey,
           extractionDeadlineMs: options.deadlineMs,
           abortSignal: options.abortSignal,
+          writeNamespaceOverride: options.writeNamespaceOverride,
+          principalOverride: options.principalOverride,
           onTaskSettled: (err) => err ? reject(err) : resolve()
         }).catch(reject);
       })
@@ -9786,7 +9915,8 @@ _Context: ${topQuestion.context}_`
           bufferKey,
           abortSignal: options.abortSignal,
           failOnExtractionFailure: options.failOnExtractionFailure === true,
-          writeNamespaceOverride: options.writeNamespaceOverride
+          writeNamespaceOverride: options.writeNamespaceOverride,
+          principalOverride: options.principalOverride
         });
         settleTask(void 0, result);
       } catch (err) {
@@ -9963,7 +10093,7 @@ ${normalized}`).digest("hex");
         durableOutputCount: 0
       };
     }
-    const principal = resolvePrincipal(sessionKey, this.config);
+    const principal = typeof options.principalOverride === "string" && options.principalOverride.length > 0 ? options.principalOverride : resolvePrincipal(sessionKey, this.config);
     const selfNamespace = typeof options.writeNamespaceOverride === "string" && options.writeNamespaceOverride.length > 0 ? options.writeNamespaceOverride : this.applyCodingNamespaceOverlay(
       sessionKey,
       defaultNamespaceForPrincipal(principal, this.config)
@@ -14302,4 +14432,4 @@ export {
   resolvePersistedMemoryRelativePath,
   Orchestrator
 };
-//# sourceMappingURL=chunk-TWVRDGTX.js.map
+//# sourceMappingURL=chunk-23RYLGYA.js.map