@remnic/core 9.3.649 → 9.3.651

package/dist/{chunk-5ETA6OAS.js → chunk-SLYD3AH4.js}

@@ -8,7 +8,10 @@ import {
 } from "./chunk-GDB4J2H3.js";
 import {
   importCapsule
-} from "./chunk-NT5TINK5.js";
+} from "./chunk-DHGSZ3UD.js";
+import {
+  decideDisclosureEscalation
+} from "./chunk-H7XKCNR6.js";
 import {
   toRecallExplainJson
 } from "./chunk-IENGGY2C.js";
@@ -17,9 +20,6 @@ import {
   normalizeTags,
   parseTagMatch
 } from "./chunk-BT7NVCML.js";
-import {
-  decideDisclosureEscalation
-} from "./chunk-H7XKCNR6.js";
 import {
   buildProposedActions,
   buildQualityScore,
@@ -27,14 +27,15 @@ import {
   listMemoryGovernanceRuns,
   readMemoryGovernanceRunArtifact,
   runMemoryGovernance
-} from "./chunk-UMTG2BN2.js";
+} from "./chunk-V4UDXYGG.js";
 import {
   clusterByKey,
   combineNamespaces,
+  lcmSessionKeyForNamespace,
   projectTagProjectId,
   resolveCodingNamespaceOverlay,
   resolveGitContext
-} from "./chunk-6GIKAUTN.js";
+} from "./chunk-MMJANTJX.js";
 import {
   getTrustZoneStoreStatus,
   isTrustZoneName,
@@ -52,7 +53,7 @@ import {
 } from "./chunk-BEMWL2FZ.js";
 import {
   namespaceCollectionName
-} from "./chunk-NMIOW7XG.js";
+} from "./chunk-4PTKFBST.js";
 import {
   namespaceIdentityFromToken
 } from "./chunk-ZFXCQPNO.js";
@@ -91,10 +92,10 @@ import {
   buildBriefing,
   parseBriefingFocus,
   parseBriefingWindow
-} from "./chunk-AMACWKM4.js";
+} from "./chunk-IJHLC5CH.js";
 import {
   parseEntityFile
-} from "./chunk-A4BTPHIN.js";
+} from "./chunk-Y7NWBBHV.js";
 import {
   DEFAULT_RECALL_DISCLOSURE,
   isRecallDisclosure
@@ -136,7 +137,7 @@ import {
 } from "./chunk-VFUEZZBS.js";
 import {
   exportCapsule
-} from "./chunk-BUKK5SWA.js";
+} from "./chunk-KQAFEZQX.js";
 import {
   OFFLINE_SYNC_SNAPSHOT_FORMAT,
   applyOfflineSyncChangeset,
@@ -807,6 +808,140 @@ var EngramAccessService = class {
     }
     return combineNamespaces(base, overlay.namespace);
   }
+  /**
+   * Resolve ONE effective memory scope plan for a write-producing request
+   * (#1495 / seed for epic #1494). The returned {@link MemoryScopePlan} is the
+   * single source of truth `observe` (and, later, other write surfaces) consume
+   * so every side effect lands in `plan.writeNamespace`.
+   *
+   * Authorization mirrors {@link resolveCodingScopedWriteNamespace} EXACTLY so
+   * `observe`'s scoping is identical to `memory_store`/`suggestion_submit`
+   * (rule 39 — feature gates identical across code paths):
+   *  - an explicit `namespace` always wins and is authorized strictly through
+   *    `resolveWritableNamespace` → `canWriteNamespace`; an overlay-shaped string
+   *    is never a writable target (rule 42 / 47 / 48);
+   *  - with NO overlay, the base stays on `config.defaultNamespace` (pre-#1434
+   *    behavior), auth-checked;
+   *  - WITH an overlay, the base is the principal self namespace and the overlay
+   *    is REBUILT from that authorized base — never accepted as a caller string.
+   *
+   * READ-ONLY: this never mutates session coding context. Callers that need the
+   * `cwd`/`projectTag` bound to the session (so a later bare recall is scoped)
+   * must attach it via `maybeAttachCodingContext` BEFORE calling this, which
+   * also preserves the no-orphan-context guard (attach only after auth passes).
+   * The overlay here reads the session's attached context first (matching recall
+   * precedence), falling back to the per-call `cwd`/`projectTag`.
+   */
+  async resolveMemoryScopePlan(request) {
+    const warnings = [];
+    const principal = this.resolveRequestPrincipal(
+      request.sessionKey,
+      request.authenticatedPrincipal
+    );
+    const hasExplicitNamespace = typeof request.namespace === "string" && request.namespace.trim().length > 0;
+    if (hasExplicitNamespace) {
+      const writeNamespace2 = this.resolveWritableNamespace(
+        request.namespace,
+        request.sessionKey,
+        request.authenticatedPrincipal
+      );
+      return {
+        principal,
+        explicitNamespace: request.namespace.trim(),
+        baseNamespace: writeNamespace2,
+        writeNamespace: writeNamespace2,
+        objectiveStateNamespace: writeNamespace2,
+        readNamespaces: [writeNamespace2],
+        codingOverlayApplied: false,
+        warnings
+      };
+    }
+    const baseNamespace = defaultNamespaceForPrincipal(
+      principal,
+      this.orchestrator.config
+    );
+    const hasSession = typeof request.sessionKey === "string" && request.sessionKey.length > 0;
+    const overlayEligible = hasSession && this.orchestrator.config.namespacesEnabled === true && this.orchestrator.config.codingMode?.projectScope === true;
+    let attachedContext = hasSession ? this.orchestrator.getCodingContextForSession(request.sessionKey) : null;
+    let seededContext = false;
+    if (overlayEligible && !attachedContext) {
+      attachedContext = await this.resolveCodingContextFromOptions(request);
+      if (attachedContext) {
+        this.orchestrator.setCodingContextForSession(
+          request.sessionKey,
+          attachedContext
+        );
+        seededContext = true;
+      }
+    }
+    const clearSeededContext = () => {
+      if (seededContext && hasSession) {
+        this.orchestrator.setCodingContextForSession(request.sessionKey, null);
+      }
+    };
+    const overlaidBase = this.orchestrator.applyCodingNamespaceOverlay(
+      request.sessionKey,
+      baseNamespace
+    );
+    const codingOverlayApplied = overlaidBase !== baseNamespace;
+    if (!codingOverlayApplied) {
+      const writeNamespace2 = this.resolveWritableNamespace(
+        void 0,
+        request.sessionKey,
+        request.authenticatedPrincipal
+      );
+      const willWriteObjectiveState = this.orchestrator.config.objectiveStateMemoryEnabled === true && this.orchestrator.config.objectiveStateSnapshotWritesEnabled === true;
+      if (willWriteObjectiveState && this.orchestrator.config.namespacesEnabled === true && !canWriteNamespace(principal, baseNamespace, this.orchestrator.config)) {
+        clearSeededContext();
+        throw new EngramAccessInputError(
+          `namespace is not writable: ${baseNamespace}`
+        );
+      }
+      return {
+        principal,
+        // scopeDebug.baseNamespace must report the principal SELF base
+        // (`defaultNamespaceForPrincipal`), NOT the general write namespace —
+        // which collapses to config.defaultNamespace on this implicit no-overlay
+        // path (#1505 cursor "Wrong scopeDebug base namespace"). It already
+        // matches `objectiveStateNamespace` below; `writeNamespace` is unchanged.
+        baseNamespace,
+        writeNamespace: writeNamespace2,
+        // Implicit objective-state stays on the principal self base, NOT the
+        // (possibly default) general write namespace — preserving the #928
+        // semantics the objective-state suite asserts.
+        objectiveStateNamespace: baseNamespace,
+        readNamespaces: [writeNamespace2],
+        codingOverlayApplied: false,
+        warnings
+      };
+    }
+    if (!canWriteNamespace(principal, baseNamespace, this.orchestrator.config)) {
+      clearSeededContext();
+      throw new EngramAccessInputError(
+        `namespace is not writable: ${baseNamespace}`
+      );
+    }
+    const writeNamespace = overlaidBase;
+    const readNamespaces = [writeNamespace];
+    const overlay = resolveCodingNamespaceOverlay(
+      attachedContext,
+      this.orchestrator.config.codingMode,
+      this.orchestrator.config.defaultNamespace
+    );
+    for (const fallback of overlay?.readFallbacks ?? []) {
+      const ns = combineNamespaces(baseNamespace, fallback);
+      if (!readNamespaces.includes(ns)) readNamespaces.push(ns);
+    }
+    return {
+      principal,
+      baseNamespace,
+      writeNamespace,
+      objectiveStateNamespace: writeNamespace,
+      readNamespaces,
+      codingOverlayApplied: true,
+      warnings
+    };
+  }
   async objectiveStateStoreLocationForNamespace(namespace) {
     if (!this.orchestrator.config.namespacesEnabled) {
       return {
@@ -938,7 +1073,10 @@ var EngramAccessService = class {
       options.disclosure,
       {
         query: options.query,
-        ...options.sessionKey ? { sessionKey: options.sessionKey } : {}
+        ...options.sessionKey ? { sessionKey: options.sessionKey } : {},
+        ...options.rawExcerptNamespace ? { rawExcerptNamespace: options.rawExcerptNamespace } : {},
+        ...options.rawExcerptSessionIds ? { rawExcerptSessionIds: options.rawExcerptSessionIds } : {},
+        ...options.rawExcerptsSuppressed ? { rawExcerptsSuppressed: options.rawExcerptsSuppressed } : {}
       }
     );
     const context = results.map((result) => {
@@ -1070,9 +1208,19 @@ var EngramAccessService = class {
       }
       return null;
     };
-    const rawExcerptsResult = await this.fetchRawExcerpts(
+    const rawExcerptsResult = rawContext?.rawExcerptsSuppressed === true ? (
+      // Implicit raw recall with NO readable LCM namespace (#1505 thread
+      // NBHWz): emit empty excerpts rather than falling back to the
+      // write/overlay `namespace` the read gate excludes.
+      []
+    ) : await this.fetchRawExcerpts(
       disclosure,
-      rawContext ? { ...rawContext, namespace } : null
+      rawContext ? {
+        query: rawContext.query,
+        ...rawContext.sessionKey ? { sessionKey: rawContext.sessionKey } : {},
+        namespace: rawContext.rawExcerptNamespace ?? namespace,
+        ...rawContext.rawExcerptSessionIds ? { lcmSessionIds: rawContext.rawExcerptSessionIds } : {}
+      } : null
     );
     const rawExcerpts = rawExcerptsResult ?? void 0;
     for (const memoryPath of snapshot.resultPaths ?? []) {
@@ -1170,22 +1318,32 @@ var EngramAccessService = class {
     const lcm = this.orchestrator.lcmEngine;
     if (!lcm || !lcm.enabled) return [];
     try {
-      const lcmSessionKey = context.namespace && context.namespace !== this.orchestrator.config.defaultNamespace ? `${context.namespace}:${context.sessionKey}` : context.sessionKey;
-      const rows = await lcm.searchContextFull(
-        context.query,
-        // Cap the excerpt fanout so recall responses stay bounded.  Five
-        // matches is enough to anchor the model in the raw transcript
-        // without ballooning token spend; raw is meant as the escape
-        // hatch, not the default.
-        5,
-        lcmSessionKey
-      );
-      return rows.map((r) => ({
-        turnIndex: r.turn_index,
-        role: r.role,
-        content: r.content,
-        sessionId: r.session_id
-      }));
+      const legacyKey = context.namespace && context.namespace !== this.orchestrator.config.defaultNamespace ? `${context.namespace}:${context.sessionKey}` : context.sessionKey;
+      const lcmSessionIds = context.lcmSessionIds && context.lcmSessionIds.length > 0 ? context.lcmSessionIds : [legacyKey];
+      const limit = 5;
+      const seenRows = /* @__PURE__ */ new Set();
+      const excerpts = [];
+      for (const lcmSessionKey of lcmSessionIds) {
+        if (excerpts.length >= limit) break;
+        const rows = await lcm.searchContextFull(
+          context.query,
+          limit,
+          lcmSessionKey
+        );
+        for (const r of rows) {
+          const dedupeKey = `${r.session_id} ${r.turn_index}`;
+          if (seenRows.has(dedupeKey)) continue;
+          seenRows.add(dedupeKey);
+          excerpts.push({
+            turnIndex: r.turn_index,
+            role: r.role,
+            content: r.content,
+            sessionId: r.session_id
+          });
+          if (excerpts.length >= limit) break;
+        }
+      }
+      return excerpts;
     } catch {
       return [];
     }
@@ -1701,9 +1859,26 @@ var EngramAccessService = class {
       topKConfidence
     });
     const disclosure = escalationDecision.effective;
+    const trimmedSessionKey = request.sessionKey?.trim() || void 0;
+    const rawExcerptNamespace = disclosure === "raw" ? this.resolveRawExcerptReadNamespace(
+      request.namespace,
+      trimmedSessionKey,
+      authenticatedPrincipal
+    ) : void 0;
+    const hasExplicitNamespace = typeof request.namespace === "string" && request.namespace.trim().length > 0;
+    const rawExcerptsSuppressed = disclosure === "raw" && !hasExplicitNamespace && rawExcerptNamespace === void 0;
+    const rawExcerptSessionIds = disclosure === "raw" && rawExcerptNamespace && trimmedSessionKey ? this.resolveLcmReadSessionIds(
+      request.namespace,
+      rawExcerptNamespace,
+      trimmedSessionKey,
+      authenticatedPrincipal
+    ) : void 0;
     let results = await this.serializeRecallResults(snapshot, disclosure, {
       query,
-      sessionKey: request.sessionKey
+      sessionKey: trimmedSessionKey,
+      ...rawExcerptNamespace ? { rawExcerptNamespace } : {},
+      ...rawExcerptSessionIds ? { rawExcerptSessionIds } : {},
+      ...rawExcerptsSuppressed ? { rawExcerptsSuppressed } : {}
     });
     const filterTags = normalizeTags(request.tags);
     let tagMatchMode;
@@ -1983,11 +2158,25 @@ var EngramAccessService = class {
           const disclosure2 = request.disclosure;
           const namespace = snapshot.namespace ? this.resolveNamespace(snapshot.namespace) : this.orchestrator.config.defaultNamespace;
           const trimmedSessionKey = request.sessionKey?.trim() || void 0;
-          const rawExcerpts = disclosure2 === "raw" ? await this.fetchRawExcerpts(disclosure2, {
+          const rawExcerptNamespace = disclosure2 === "raw" ? this.resolveRawExcerptReadNamespace(
+            request.namespace,
+            trimmedSessionKey,
+            authenticatedPrincipal
+          ) : namespace;
+          const xrayHasExplicitNamespace = typeof request.namespace === "string" && request.namespace.trim().length > 0;
+          const rawExcerptsSuppressed = disclosure2 === "raw" && !xrayHasExplicitNamespace && rawExcerptNamespace === void 0;
+          const rawExcerptSessionIds = disclosure2 === "raw" && trimmedSessionKey && rawExcerptNamespace ? this.resolveLcmReadSessionIds(
+            request.namespace,
+            rawExcerptNamespace,
+            trimmedSessionKey,
+            authenticatedPrincipal
+          ) : void 0;
+          const rawExcerpts = disclosure2 === "raw" && !rawExcerptsSuppressed ? await this.fetchRawExcerpts(disclosure2, {
             query,
             ...trimmedSessionKey ? { sessionKey: trimmedSessionKey } : {},
-            namespace
-          }) : null;
+            ...rawExcerptNamespace ? { namespace: rawExcerptNamespace } : {},
+            ...rawExcerptSessionIds ? { lcmSessionIds: rawExcerptSessionIds } : {}
+          }) : disclosure2 === "raw" ? [] : null;
           const rawExcerptText = rawExcerpts && rawExcerpts.length > 0 ? rawExcerpts.map((e) => e.content).join("\n") : "";
           const memoryByIndex = await Promise.all(
             snapshot.results.map(async (result) => {
@@ -2041,6 +2230,19 @@ var EngramAccessService = class {
       release();
     }
     if (request.includeRecall === true && xrayResponse.snapshotFound === true && xrayResponse.snapshot) {
+      const xrayRawExcerptNamespace = disclosure === "raw" ? this.resolveRawExcerptReadNamespace(
+        request.namespace,
+        recallSessionKey,
+        authenticatedPrincipal
+      ) : void 0;
+      const xrayHasExplicitNamespace = typeof request.namespace === "string" && request.namespace.trim().length > 0;
+      const xrayRawExcerptsSuppressed = disclosure === "raw" && !xrayHasExplicitNamespace && xrayRawExcerptNamespace === void 0;
+      const xrayRawExcerptSessionIds = disclosure === "raw" && xrayRawExcerptNamespace && recallSessionKey ? this.resolveLcmReadSessionIds(
+        request.namespace,
+        xrayRawExcerptNamespace,
+        recallSessionKey,
+        authenticatedPrincipal
+      ) : void 0;
       return {
         ...xrayResponse,
         recall: await this.buildRecallResponseFromXraySnapshot({
@@ -2050,7 +2252,10 @@ var EngramAccessService = class {
           disclosure,
           startedAt: recallStartedAt,
           requestedMode: request.mode,
-          normalizedMode: mode
+          normalizedMode: mode,
+          ...xrayRawExcerptNamespace ? { rawExcerptNamespace: xrayRawExcerptNamespace } : {},
+          ...xrayRawExcerptSessionIds ? { rawExcerptSessionIds: xrayRawExcerptSessionIds } : {},
+          ...xrayRawExcerptsSuppressed ? { rawExcerptsSuppressed: xrayRawExcerptsSuppressed } : {}
         })
       };
     }
@@ -2987,40 +3192,23 @@ var EngramAccessService = class {
         throw new EngramAccessInputError(`invalid message role: ${msg.role} (expected 'user' or 'assistant')`);
       }
     }
-    const hasExplicitNamespace = typeof request.namespace === "string" && request.namespace.trim().length > 0;
-    const principal = this.resolveRequestPrincipal(
-      request.sessionKey,
-      request.authenticatedPrincipal
-    );
-    const namespace = this.resolveWritableNamespace(
-      request.namespace,
-      request.sessionKey,
-      request.authenticatedPrincipal
-    );
+    const scope = await this.resolveMemoryScopePlan(request);
+    const writeNamespace = scope.writeNamespace;
+    const namespace = scope.explicitNamespace ? scope.writeNamespace : scope.codingOverlayApplied ? this.orchestrator.config.defaultNamespace : scope.writeNamespace;
     const shouldWriteObjectiveState = this.orchestrator.config.objectiveStateMemoryEnabled === true && this.orchestrator.config.objectiveStateSnapshotWritesEnabled === true;
-    const objectiveStateBaseNamespace = hasExplicitNamespace ? namespace : defaultNamespaceForPrincipal(principal, this.orchestrator.config);
-    if (shouldWriteObjectiveState && !hasExplicitNamespace && !canWriteNamespace(
-      principal,
-      objectiveStateBaseNamespace,
-      this.orchestrator.config
-    )) {
-      throw new EngramAccessInputError(
-        `namespace is not writable: ${objectiveStateBaseNamespace}`
-      );
-    }
     await this.maybeAttachCodingContext(request.sessionKey, {
       cwd: request.cwd,
       projectTag: request.projectTag
     });
-    const objectiveStateNamespace = hasExplicitNamespace ? namespace : this.orchestrator.applyCodingNamespaceOverlay(
+    const lcmSessionKey = lcmSessionKeyForNamespace(
+      writeNamespace,
       request.sessionKey,
-      objectiveStateBaseNamespace
-    );
-    const lcmSessionKey = namespace !== this.orchestrator.config.defaultNamespace ? `${namespace}:${request.sessionKey}` : request.sessionKey;
+      this.orchestrator.config.defaultNamespace
+    ) ?? request.sessionKey;
     if (shouldWriteObjectiveState) {
       try {
         const objectiveStateLocation = await this.objectiveStateStoreLocationForNamespace(
-          objectiveStateNamespace
+          scope.objectiveStateNamespace
         );
         await recordObjectiveStateSnapshotsFromObservedMessages({
           memoryDir: objectiveStateLocation.memoryDir,
@@ -3048,7 +3236,16 @@ var EngramAccessService = class {
     if (request.skipExtraction !== true) {
       const turns = request.messages.map((m) => ({
         source: "openclaw",
-        sessionKey: lcmSessionKey,
+        // Identity-vs-routing separation (#1505 thread 1, cursor): extraction
+        // derives the provenance principal via `resolvePrincipal(turn.sessionKey)`
+        // and threads `turn.sessionKey` into conversation threading. Feeding the
+        // namespace-PREFIXED `lcmSessionKey` here mis-derived the principal to
+        // `default` (a `<ns>:<key>` string matches no prefix/map rule and fails
+        // the `agent:` heuristic). Pass the ORIGINAL sessionKey so identity is
+        // correct; storage routing is pinned separately via
+        // writeNamespaceOverride below, and the authenticated principal is pinned
+        // via principalOverride.
+        sessionKey: request.sessionKey,
         role: m.role,
         content: m.content,
         parts: m.parts,
@@ -3056,9 +3253,13 @@ var EngramAccessService = class {
         sourceFormat: m.sourceFormat,
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       }));
+      const writeNamespaceOverride = this.orchestrator.config.namespacesEnabled === true ? writeNamespace : void 0;
+      const principalOverride = typeof scope.principal === "string" && scope.principal.length > 0 ? scope.principal : void 0;
       try {
         const extractionPromise = this.orchestrator.ingestReplayBatch(turns, {
-          archiveLcm: false
+          archiveLcm: false,
+          writeNamespaceOverride,
+          principalOverride
         });
         extractionPromise.catch((err) => {
           log.error(`access-observe background extraction failed: ${err}`);
@@ -3069,12 +3270,21 @@ var EngramAccessService = class {
       }
     }
     log.info(
-      `access-observe namespace=${namespace} sessionKey=${request.sessionKey} messages=${request.messages.length} lcm=${lcmArchived} extraction=${extractionQueued}`
+      `access-observe namespace=${namespace} effectiveNamespace=${writeNamespace} sessionKey=${request.sessionKey} messages=${request.messages.length} lcm=${lcmArchived} extraction=${extractionQueued}`
     );
     return {
       accepted: request.messages.length,
       sessionKey: request.sessionKey,
       namespace,
+      effectiveNamespace: writeNamespace,
+      scopeDebug: {
+        principal: scope.principal,
+        explicitNamespace: scope.explicitNamespace,
+        baseNamespace: scope.baseNamespace,
+        writeNamespace: scope.writeNamespace,
+        codingOverlayApplied: scope.codingOverlayApplied,
+        readNamespaces: scope.readNamespaces
+      },
       lcmArchived,
       extractionQueued
     };
@@ -3084,30 +3294,76 @@ var EngramAccessService = class {
       throw new EngramAccessInputError("query is required and must be a non-empty string");
     }
     const principal = this.resolveRequestPrincipal(request.sessionKey, request.authenticatedPrincipal);
-    const namespace = this.resolveReadableNamespace(request.namespace, principal);
+    const hasExplicitNamespace = typeof request.namespace === "string" && request.namespace.trim().length > 0;
+    const namespace = hasExplicitNamespace ? this.resolveReadableNamespace(request.namespace, principal) : this.resolveImplicitLcmReadFallbackNamespace(principal);
     if (!this.orchestrator.lcmEngine || !this.orchestrator.lcmEngine.enabled) {
       return {
         query: request.query,
-        namespace,
+        namespace: namespace ?? this.orchestrator.config.defaultNamespace,
         results: [],
         count: 0,
         lcmEnabled: false
       };
     }
+    if (namespace === void 0) {
+      return {
+        query: request.query,
+        namespace: this.orchestrator.config.defaultNamespace,
+        results: [],
+        count: 0,
+        lcmEnabled: true
+      };
+    }
     const limit = Math.max(1, Math.min(request.limit ?? 10, 100));
-    const lcmSessionKey = request.sessionKey && namespace !== this.orchestrator.config.defaultNamespace ? `${namespace}:${request.sessionKey}` : request.sessionKey;
-    const lcmSessionPrefix = request.sessionPrefix && namespace !== this.orchestrator.config.defaultNamespace ? `${namespace}:${request.sessionPrefix}` : request.sessionPrefix;
-    const rawResults = await this.orchestrator.lcmEngine.searchContextFull(
-      request.query,
-      limit,
-      lcmSessionKey,
-      lcmSessionPrefix
+    const lcmReadNamespace = this.resolveLcmReadNamespace(
+      request.namespace,
+      namespace,
+      request.sessionKey,
+      request.authenticatedPrincipal
     );
-    const results = rawResults.map((r) => ({
-      sessionId: r.session_id,
-      content: r.content,
-      turnIndex: r.turn_index
-    }));
+    const lcmSessionKeyIds = request.sessionKey ? this.resolveLcmReadSessionIds(
+      request.namespace,
+      namespace,
+      request.sessionKey,
+      request.authenticatedPrincipal
+    ) : [void 0];
+    const lcmSessionPrefix = request.sessionPrefix ? lcmSessionKeyForNamespace(
+      lcmReadNamespace,
+      request.sessionPrefix,
+      this.orchestrator.config.defaultNamespace
+    ) ?? request.sessionPrefix : request.sessionPrefix;
+    const hasScopedSession = typeof request.sessionKey === "string" && request.sessionKey.length > 0 || typeof lcmSessionPrefix === "string" && lcmSessionPrefix.length > 0;
+    if (!hasScopedSession && this.orchestrator.config.namespacesEnabled === true) {
+      return {
+        query: request.query,
+        namespace,
+        results: [],
+        count: 0,
+        lcmEnabled: true
+      };
+    }
+    const seenRows = /* @__PURE__ */ new Set();
+    const results = [];
+    for (const lcmSessionKey of lcmSessionKeyIds) {
+      if (results.length >= limit) break;
+      const rawResults = await this.orchestrator.lcmEngine.searchContextFull(
+        request.query,
+        limit,
+        lcmSessionKey,
+        lcmSessionPrefix
+      );
+      for (const r of rawResults) {
+        const dedupeKey = `${r.session_id}\0${r.turn_index}`;
+        if (seenRows.has(dedupeKey)) continue;
+        seenRows.add(dedupeKey);
+        results.push({
+          sessionId: r.session_id,
+          content: r.content,
+          turnIndex: r.turn_index
+        });
+        if (results.length >= limit) break;
+      }
+    }
     return {
       query: request.query,
       namespace,
@@ -3116,15 +3372,282 @@ var EngramAccessService = class {
       lcmEnabled: true
     };
   }
+  /**
+   * Resolve the LCM `session_id` a same-session READER (compaction flush/record,
+   * `lcmSearch`, raw-excerpt lookup) must target so it matches the key `observe`
+   * archived under (#1495 thread 2 + #1505 round 3, rule 42). One helper for
+   * EVERY access-surface LCM read so the read key cannot drift from the write key
+   * (rule 22).
+   *
+   * Precedence mirrors `observe`'s effective write namespace:
+   *  - With an explicit `request.namespace`, use the already-authorized
+   *    `resolvedNamespace` (the overlay never applies to an explicit write).
+   *  - With NO explicit namespace, an auto-scoped session was archived under
+   *    its coding-overlay namespace, so overlay the session's bound coding
+   *    context onto the principal self base — the SAME resolution
+   *    `resolveMemoryScopePlan`/recall use. `applyCodingNamespaceOverlay`
+   *    returns the base unchanged when projectScope/namespaces are off or no
+   *    context is bound, so single-store / no-overlay flows collapse to the raw
+   *    sessionKey exactly as before.
+   *
+   * Then encode the `${namespace}:${sessionKey}` prefix via the shared helper
+   * so the read key is byte-for-byte what the LCM write and the recall readers
+   * use.
+   */
+  /**
+   * Resolve the effective LCM NAMESPACE a same-session operation must prefix
+   * with (the namespace half of {@link resolveLcmReadSessionKey}). Split out so
+   * `lcmSearch` can apply ONE namespace to BOTH its `sessionKey` and its
+   * `sessionPrefix` — the prefix is a search fragment, not a real session, so its
+   * own coding context can't be looked up; it must inherit the namespace resolved
+   * from the real session (`sessionKeyForOverlay`).
+   *
+   * `purpose` selects the AUTHORIZATION gate applied before honouring the
+   * coding overlay (#1505 round 3 + round 4, codex P2):
+   *
+   *  - `"read"` (`lcmSearch` / raw-excerpt recall): the overlay rows are only
+   *    visible when the principal SELF base is in the READABLE RECALL SET — the
+   *    same gate the orchestrator's `lcmReadNamespaceForSession` and the recall
+   *    namespace set use (`recallNamespacesForPrincipal`, gated by both
+   *    `defaultRecallNamespaces.includes("self")` AND `canReadNamespace`). A
+   *    caller that passed the default read check must NOT receive
+   *    `<principal>-project-*` rows the policy never granted (cross-tenant read
+   *    leak). When the self base is not readable, keep the just-authorized
+   *    namespace (collapses to the raw key on the default store).
+   *
+   *  - `"write"` (`lcmCompactionFlush` / `lcmCompactionRecord`): these are
+   *    write/maintenance operations on the SAME queue `observe` just wrote, so
+   *    the gate must mirror observe's WRITE authorization (`canWriteNamespace`
+   *    on the self base), NOT readability. A principal that can WRITE but not
+   *    READ its self namespace (or whose `defaultRecallNamespaces` omits `self`)
+   *    archived under the overlay key via `observe`; gating compaction by
+   *    readability would fall back to the default/raw key and leave that queue
+   *    never flushed/recorded (round-4 codex P2). Write-authorized ⇒ overlay
+   *    key, matching the observe write key (rule 42 read/write parity; rule 39
+   *    identical gates across paths).
+   */
+  resolveLcmReadNamespace(explicitNamespace, resolvedNamespace, sessionKeyForOverlay, authenticatedPrincipal, purpose = "read") {
+    const hasExplicitNamespace = typeof explicitNamespace === "string" && explicitNamespace.trim().length > 0;
+    if (hasExplicitNamespace) return resolvedNamespace;
+    const principal = this.resolveRequestPrincipal(
+      sessionKeyForOverlay,
+      authenticatedPrincipal
+    );
+    const base = defaultNamespaceForPrincipal(principal, this.orchestrator.config);
+    const overlaid = this.orchestrator.applyCodingNamespaceOverlay(
+      sessionKeyForOverlay,
+      base
+    );
+    if (overlaid === base) return this.orchestrator.config.defaultNamespace;
+    const authorized = purpose === "write" ? canWriteNamespace(principal, base, this.orchestrator.config) : recallNamespacesForPrincipal(
+      principal,
+      this.orchestrator.config
+    ).includes(base);
+    if (authorized) return overlaid;
+    if (purpose === "read") return this.orchestrator.config.defaultNamespace;
+    return resolvedNamespace;
+  }
+  /**
+   * Resolve the namespace the raw-disclosure excerpt lookup
+   * ({@link fetchRawExcerpts}) must prefix its LCM `session_id` with (#1505
+   * thread 2f7). Raw disclosure reads the SAME LCM archive `lcmSearch` and the
+   * in-prompt LCM sections read, so it MUST pass through the identical
+   * read-authorization gate — NOT `snapshot.namespace`, which records the
+   * effective WRITE/overlay namespace (`<principal>-project-*`) even when the
+   * principal can WRITE but not READ its self base (or `defaultRecallNamespaces`
+   * omits `self`). Routing through `resolveLcmReadNamespace(..., "read")` makes
+   * raw disclosure fall back to the default store exactly like normal recall +
+   * `lcmSearch`, so it never attaches overlay transcript rows the read gate
+   * excludes (cross-tenant read leak). Collapses to the default store / raw
+   * sessionKey for single-store / no-overlay / explicit-default flows, so
+   * single-user recall is byte-for-byte unchanged.
+   *
+   * Returns `undefined` when NO readable LCM namespace exists for an IMPLICIT
+   * (no explicit `namespace`) raw recall — i.e. a restrictive `default` READ
+   * policy denies the principal `default` AND no overlay/self namespace is
+   * readable. In that case the caller emits NO excerpts rather than throwing
+   * `namespace is not readable: default` (#1505 thread NBHWz): normal recall
+   * still succeeds via `recallNamespacesForPrincipal`, so `disclosure: "raw"`
+   * must degrade gracefully (empty excerpts), never pre-authorize `default`.
+   *
+   * IMPLICIT-namespace fallback selection derives from the ALREADY
+   * read-authorized recall namespace set (`recallNamespacesForPrincipal` +
+   * `canReadNamespace`) — the principal's self base when it is in the readable
+   * recall set, else `config.defaultNamespace` ONLY when the principal may read
+   * it. It NEVER pre-authorizes `default`. An EXPLICIT `namespace` is still
+   * authorized strictly via `resolveReadableNamespace` (explicit reads must pass
+   * the ACL — no behavior change).
+   */
+  resolveRawExcerptReadNamespace(explicitNamespace, sessionKey, authenticatedPrincipal) {
+    const principal = this.resolveRequestPrincipal(
+      sessionKey,
+      authenticatedPrincipal
+    );
+    const hasExplicitNamespace = typeof explicitNamespace === "string" && explicitNamespace.trim().length > 0;
+    if (hasExplicitNamespace) {
+      const resolvedNamespace = this.resolveReadableNamespace(
+        explicitNamespace,
+        principal
+      );
+      return this.resolveLcmReadNamespace(
+        explicitNamespace,
+        resolvedNamespace,
+        sessionKey,
+        authenticatedPrincipal,
+        "read"
+      );
+    }
+    const fallbackNamespace = this.resolveImplicitLcmReadFallbackNamespace(principal);
+    if (fallbackNamespace === void 0) return void 0;
+    return this.resolveLcmReadNamespace(
+      explicitNamespace,
+      fallbackNamespace,
+      sessionKey,
+      authenticatedPrincipal,
+      "read"
+    );
+  }
+  /**
+   * The base `resolvedNamespace` an IMPLICIT (no explicit `namespace`)
+   * same-session LCM READER (`resolveRawExcerptReadNamespace`, `lcmSearch`)
+   * passes into {@link resolveLcmReadNamespace} — WITHOUT pre-authorizing
+   * `default` (#1505 thread NBHWz). It decides PROCEED vs SUPPRESS only; the
+   * actual LCM prefix is then resolved by `resolveLcmReadNamespace`, which
+   * mirrors the orchestrator's `lcmReadNamespaceForSession` EXACTLY (rule 39 /
+   * 42): the coding overlay when the principal SELF base is in the readable
+   * recall set, else `config.defaultNamespace` (the raw key).
+   *
+   * Returns `config.defaultNamespace` (PROCEED) whenever the principal has ANY
+   * readable LCM access — either `default` itself is readable, OR a coding
+   * overlay / self base is in the readable recall set. The returned value is
+   * ALWAYS `config.defaultNamespace`, NEVER an arbitrary readable recall
+   * namespace (e.g. `shared`): `resolveLcmReadNamespace` returns this fallback
+   * verbatim only on the overlay-applies-but-self-unreadable branch, where the
+   * orchestrator collapses to the default store — so returning anything but the
+   * default store there would prefix LCM reads with `shared:sessionKey` while
+   * in-prompt recall uses the raw `sessionKey`, diverging the two (cursor
+   * "LCM read gate wrong fallback").
+   *
+   * Returns `undefined` (SUPPRESS) only when NO readable LCM namespace exists —
+   * a restrictive `default` READ policy AND no readable overlay/self — so the
+   * caller emits NO rows instead of throwing `namespace is not readable:
+   * default`. Normal recall still succeeds through the readable self namespace.
+   *
+   * Single-store / namespaces-disabled deployments resolve to
+   * `config.defaultNamespace`, keeping single-user recall byte-for-byte
+   * unchanged.
+   */
+  resolveImplicitLcmReadFallbackNamespace(principal) {
+    const config = this.orchestrator.config;
+    if (!config.namespacesEnabled) return config.defaultNamespace;
+    if (canReadNamespace(principal, config.defaultNamespace, config)) {
+      return config.defaultNamespace;
+    }
+    const selfBase = defaultNamespaceForPrincipal(principal, config);
+    const selfReadableInRecall = recallNamespacesForPrincipal(
+      principal,
+      config
+    ).includes(selfBase);
+    return selfReadableInRecall ? config.defaultNamespace : void 0;
+  }
+  resolveLcmReadSessionKey(explicitNamespace, resolvedNamespace, sessionKey, authenticatedPrincipal, purpose = "read") {
+    const effectiveNamespace = this.resolveLcmReadNamespace(
+      explicitNamespace,
+      resolvedNamespace,
+      sessionKey,
+      authenticatedPrincipal,
+      purpose
+    );
+    return lcmSessionKeyForNamespace(
+      effectiveNamespace,
+      sessionKey,
+      this.orchestrator.config.defaultNamespace
+    ) ?? sessionKey;
+  }
+  /**
+   * Resolve the ORDERED, read-authorized set of LCM `session_id`s a same-session
+   * READER (`lcmSearch`, raw-excerpt disclosure) must query so it matches every
+   * key `observe` archived under across the coding scope (#1505 thread "Include
+   * coding fallback namespaces in LCM reads").
+   *
+   * Mirrors the orchestrator recall path exactly (rule 39): `observe` archives
+   * each turn under `${effectiveNamespace}:${sessionKey}` for whichever namespace
+   * was effective at write time, and normal QMD/file recall searches the primary
+   * coding-overlay namespace AND `codingOverlay.readFallbacks` (project → root).
+   * A single overlay key therefore MISSES rows a branch-scoped session archived at
+   * project/root scope. This returns the primary overlay LCM key first, then one
+   * per read fallback, deduped + ordered so the caller can short-circuit on the
+   * first hit.
+   *
+   * READ-AUTHORIZATION (preserved from the round-3..5 `resolveLcmReadNamespace`
+   * "read" gate; rule 42 / 48): the overlay + fallbacks are `<principal>-project-*`
+   * sub-namespaces authorized transitively by the principal SELF base. They are
+   * included ONLY when the self base is in the readable recall set
+   * (`recallNamespacesForPrincipal`). When the self base is NOT readable (write-
+   * only / self-omitted principal), or when an explicit namespace was supplied,
+   * or no overlay applies, this collapses to the single key
+   * {@link resolveLcmReadSessionKey} returns — byte-for-byte the prior behavior
+   * (single-store / no-overlay flows stay the raw `sessionKey`). No
+   * `<principal>-project-*` key is ever searched for an unauthorized reader (no
+   * cross-tenant read leak).
+   */
+  resolveLcmReadSessionIds(explicitNamespace, resolvedNamespace, sessionKey, authenticatedPrincipal) {
+    const primary = this.resolveLcmReadSessionKey(
+      explicitNamespace,
+      resolvedNamespace,
+      sessionKey,
+      authenticatedPrincipal,
+      "read"
+    );
+    const hasExplicitNamespace = typeof explicitNamespace === "string" && explicitNamespace.trim().length > 0;
+    if (hasExplicitNamespace) return [primary];
+    const principal = this.resolveRequestPrincipal(
+      sessionKey,
+      authenticatedPrincipal
+    );
+    const base = defaultNamespaceForPrincipal(
+      principal,
+      this.orchestrator.config
+    );
+    const overlaid = this.orchestrator.applyCodingNamespaceOverlay(
+      sessionKey,
+      base
+    );
+    if (overlaid === base) return [primary];
+    const selfReadableInRecall = recallNamespacesForPrincipal(
+      principal,
+      this.orchestrator.config
+    ).includes(base);
+    if (!selfReadableInRecall) return [primary];
+    const overlay = resolveCodingNamespaceOverlay(
+      this.orchestrator.getCodingContextForSession(sessionKey),
+      this.orchestrator.config.codingMode,
+      this.orchestrator.config.defaultNamespace
+    );
+    const fallbackNamespaces = (overlay?.readFallbacks ?? []).map(
+      (fallback) => combineNamespaces(base, fallback)
+    );
+    const out = [primary];
+    const seen = /* @__PURE__ */ new Set([primary]);
+    for (const ns of fallbackNamespaces) {
+      const key = lcmSessionKeyForNamespace(
+        ns,
+        sessionKey,
+        this.orchestrator.config.defaultNamespace
+      ) ?? sessionKey;
+      if (!seen.has(key)) {
+        seen.add(key);
+        out.push(key);
+      }
+    }
+    return out;
+  }
   async lcmCompactionFlush(request) {
     if (!request.sessionKey || typeof request.sessionKey !== "string" || request.sessionKey.trim().length === 0) {
       throw new EngramAccessInputError("sessionKey is required and must be a non-empty string");
     }
-    const namespace = this.resolveWritableNamespace(
-      request.namespace,
-      request.sessionKey,
-      request.authenticatedPrincipal
-    );
+    const scope = await this.resolveMemoryScopePlan(request);
+    const namespace = scope.explicitNamespace ? scope.writeNamespace : scope.codingOverlayApplied ? this.orchestrator.config.defaultNamespace : scope.writeNamespace;
     if (!this.orchestrator.lcmEngine || !this.orchestrator.lcmEngine.enabled) {
       return {
         enabled: false,
@@ -3134,7 +3657,11 @@ var EngramAccessService = class {
         reason: "LCM is disabled"
       };
     }
-    const lcmSessionKey = namespace !== this.orchestrator.config.defaultNamespace ? `${namespace}:${request.sessionKey}` : request.sessionKey;
+    const lcmSessionKey = lcmSessionKeyForNamespace(
+      scope.writeNamespace,
+      request.sessionKey,
+      this.orchestrator.config.defaultNamespace
+    ) ?? request.sessionKey;
     await this.orchestrator.lcmEngine.waitForSessionObserveIdle(lcmSessionKey);
     await this.orchestrator.lcmEngine.preCompactionFlush(lcmSessionKey);
     return {
@@ -3154,11 +3681,8 @@ var EngramAccessService = class {
     if (!Number.isInteger(request.tokensAfter) || request.tokensAfter < 0) {
       throw new EngramAccessInputError("tokensAfter must be a non-negative integer");
     }
-    const namespace = this.resolveWritableNamespace(
-      request.namespace,
-      request.sessionKey,
-      request.authenticatedPrincipal
-    );
+    const scope = await this.resolveMemoryScopePlan(request);
+    const namespace = scope.explicitNamespace ? scope.writeNamespace : scope.codingOverlayApplied ? this.orchestrator.config.defaultNamespace : scope.writeNamespace;
     if (!this.orchestrator.lcmEngine || !this.orchestrator.lcmEngine.enabled) {
       return {
         enabled: false,
@@ -3168,7 +3692,11 @@ var EngramAccessService = class {
         reason: "LCM is disabled"
       };
     }
-    const lcmSessionKey = namespace !== this.orchestrator.config.defaultNamespace ? `${namespace}:${request.sessionKey}` : request.sessionKey;
+    const lcmSessionKey = lcmSessionKeyForNamespace(
+      scope.writeNamespace,
+      request.sessionKey,
+      this.orchestrator.config.defaultNamespace
+    ) ?? request.sessionKey;
     await this.orchestrator.lcmEngine.waitForSessionObserveIdle(lcmSessionKey);
     await this.orchestrator.lcmEngine.recordCompaction(
       lcmSessionKey,
@@ -4649,4 +5177,4 @@ export {
   shapeMemorySummary,
   EngramAccessService
 };
-//# sourceMappingURL=chunk-5ETA6OAS.js.map
+//# sourceMappingURL=chunk-SLYD3AH4.js.map