@remnic/core 9.3.751 → 9.3.752

package/dist/{chunk-UETBEHBA.js → chunk-VX2RYM2K.js}

@@ -8,7 +8,7 @@ import {
 } from "./chunk-GDB4J2H3.js";
 import {
   importCapsule
-} from "./chunk-ARV3AUOM.js";
+} from "./chunk-M5QKGHCR.js";
 import {
   getTrustZoneStoreStatus,
   isTrustZoneName,
@@ -56,10 +56,10 @@ import {
   resolveScopeProfilePlan,
   resolveWritableNamespaceValue,
   sanitizeFragment
-} from "./chunk-W3M34XT4.js";
+} from "./chunk-GECEETQ3.js";
 import {
   namespaceCollectionName
-} from "./chunk-HAZVVOYT.js";
+} from "./chunk-5DXUE7GB.js";
 import {
   namespaceIdentityFromToken
 } from "./chunk-ZFXCQPNO.js";
@@ -70,7 +70,7 @@ import {
   listMemoryGovernanceRuns,
   readMemoryGovernanceRunArtifact,
   runMemoryGovernance
-} from "./chunk-K2JM4DZZ.js";
+} from "./chunk-JHZ3LEM7.js";
 import {
   recordMemoryOutcome
 } from "./chunk-EIR5VLIH.js";
@@ -91,7 +91,7 @@ import {
   persistExplicitCapture,
   queueExplicitCaptureForReview,
   validateExplicitCaptureInput
-} from "./chunk-K5LLP4CY.js";
+} from "./chunk-XKAOT4ZB.js";
 import {
   CrossNamespaceBudget
 } from "./chunk-ODPLEWB6.js";
@@ -101,17 +101,17 @@ import {
 import {
   filterTrajectoriesByLookbackDays,
   readCausalTrajectoryRecords
-} from "./chunk-SQNED75R.js";
+} from "./chunk-V5UV7BOA.js";
 import {
   FileCalendarSource,
   buildBriefing,
   enqueuePassiveCorrectionNotification,
   parseBriefingFocus,
   parseBriefingWindow
-} from "./chunk-K2R3DEEH.js";
+} from "./chunk-MTN2G4DT.js";
 import {
   parseEntityFile
-} from "./chunk-ZBVQ4ZM4.js";
+} from "./chunk-YGNQG4Q6.js";
 import {
   stripAttributesSuffix
 } from "./chunk-SVOZFLIQ.js";
@@ -145,9 +145,32 @@ import {
 import {
   computeContentHash
 } from "./chunk-W5H6ZRPT.js";
+import {
+  sanitizeMemoryContent
+} from "./chunk-5GKPFL3S.js";
+import {
+  expandTildePath
+} from "./chunk-EYIEWJNI.js";
+import {
+  log
+} from "./chunk-NU3CSQ4H.js";
 import {
   exportCapsule
-} from "./chunk-KQAFEZQX.js";
+} from "./chunk-FLVL4L3L.js";
+import {
+  OFFLINE_SYNC_SNAPSHOT_FORMAT,
+  applyOfflineSyncChangeset,
+  applyOfflineSyncFileContentChunk,
+  buildOfflineSyncSnapshot,
+  buildOfflineSyncSnapshotForPaths,
+  buildOfflineSyncSnapshotFromBase,
+  compileOfflineSyncExcludeGlobs,
+  iterateOfflineSyncSnapshotFileRecords,
+  readOfflineSyncFileContentChunk
+} from "./chunk-X64YLC24.js";
+import {
+  SecureStoreLockedError
+} from "./chunk-J2HSAU72.js";
 import {
   evaluateActionConfidence
 } from "./chunk-Z2YFLXHU.js";
@@ -173,29 +196,6 @@ import {
   resolveRecallEnhancementCapabilities,
   resolveSecurityCapabilities
 } from "./chunk-VSF7AAGE.js";
-import {
-  sanitizeMemoryContent
-} from "./chunk-5GKPFL3S.js";
-import {
-  expandTildePath
-} from "./chunk-EYIEWJNI.js";
-import {
-  log
-} from "./chunk-NU3CSQ4H.js";
-import {
-  OFFLINE_SYNC_SNAPSHOT_FORMAT,
-  applyOfflineSyncChangeset,
-  applyOfflineSyncFileContentChunk,
-  buildOfflineSyncSnapshot,
-  buildOfflineSyncSnapshotForPaths,
-  buildOfflineSyncSnapshotFromBase,
-  compileOfflineSyncExcludeGlobs,
-  iterateOfflineSyncSnapshotFileRecords,
-  readOfflineSyncFileContentChunk
-} from "./chunk-X64YLC24.js";
-import {
-  SecureStoreLockedError
-} from "./chunk-J2HSAU72.js";
 import {
   isHandleToken
 } from "./chunk-JAKIDQB2.js";
@@ -207,6 +207,10 @@ import {
   hashAccessIdempotencyPayload
 } from "./chunk-VFUEZZBS.js";
 
+// src/access-recall-surface.ts
+import { createHash as createHash5 } from "crypto";
+import * as nodePath2 from "path";
+
 // src/access-service.ts
 import { stat as stat2 } from "fs/promises";
 import * as nodeFs from "fs/promises";
@@ -4051,7 +4055,7 @@ function isErrnoCode(error, code) {
   return typeof error === "object" && error !== null && "code" in error && error.code === code;
 }
 function sleep(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
 }
 async function acquireClusterWriteLock(memoryDir, clusterHash) {
   const lockRoot = path6.join(path6.resolve(memoryDir), "state", "procedure-miner-locks");
@@ -4090,8 +4094,8 @@ async function withClusterWriteLock(memoryDir, clusterHash, fn) {
   const previous = inProcessClusterWriteLocks.get(inProcessKey) ?? Promise.resolve();
   let releaseInProcess;
   const current = previous.catch(() => void 0).then(
-    () => new Promise((resolve2) => {
-      releaseInProcess = resolve2;
+    () => new Promise((resolve3) => {
+      releaseInProcess = resolve3;
     })
   );
   inProcessClusterWriteLocks.set(inProcessKey, current);
@@ -4747,44 +4751,29 @@ async function promoteMemory(options) {
 
 // src/access-service.ts
 import * as nodePath from "path";
-var EngramAccessInputError = class extends Error {
-};
-function qmdCollectionPathParts(resultPath) {
-  if (!resultPath || nodePath.isAbsolute(resultPath)) return null;
-  const normalized = resultPath.replace(/\\/g, "/").replace(/^\/+/, "");
-  const slashIndex = normalized.indexOf("/");
-  if (slashIndex <= 0 || slashIndex >= normalized.length - 1) return null;
-  const collection = normalized.slice(0, slashIndex);
-  if (/^\d{4}-\d{2}-\d{2}$/.test(collection)) return null;
-  return {
-    collection,
-    relativePath: normalized.slice(slashIndex + 1)
-  };
-}
-function qmdResultPathCandidates(storageDir, resultPath) {
-  const candidates = /* @__PURE__ */ new Set();
-  const storageRoot = nodePath.resolve(storageDir);
-  const addCandidate = (candidate) => {
-    const resolved = nodePath.resolve(candidate);
-    if (isPathInsideStorageRoot(storageRoot, resolved)) {
-      candidates.add(resolved);
-    }
-  };
-  const addRelativeCandidates = (relativePath) => {
-    const normalized = relativePath.replace(/\\/g, "/").replace(/^\/+/, "");
-    if (!normalized) return;
-    addCandidate(nodePath.join(storageRoot, normalized));
-    if (/^\d{4}-\d{2}-\d{2}\//.test(normalized)) {
-      addCandidate(nodePath.join(storageRoot, "facts", normalized));
+
+// src/orchestration/self-deps.ts
+function selfDeps(self) {
+  const source = self;
+  return new Proxy(/* @__PURE__ */ Object.create(null), {
+    get(_target, prop) {
+      const value = source[prop];
+      return typeof value === "function" ? value.bind(self) : value;
+    },
+    set(_target, prop, value) {
+      if (!(prop in source)) return false;
+      source[prop] = value;
+      return true;
+    },
+    has(_target, prop) {
+      return prop in source;
     }
-  };
-  if (nodePath.isAbsolute(resultPath)) {
-    addCandidate(resultPath);
-  } else {
-    addRelativeCandidates(resultPath);
-  }
-  return [...candidates];
+  });
 }
+
+// src/access-service.ts
+var EngramAccessInputError = class extends Error {
+};
 var cachedPackageVersion = null;
 async function getPackageVersion() {
   if (cachedPackageVersion !== null) return cachedPackageVersion;
@@ -4965,6 +4954,16 @@ var EngramAccessService = class {
   budgetLocks = /* @__PURE__ */ new Map();
   budget;
   auditAdapter;
+  /** AccessRecallSurface (access-service decomposition). Lazy; selfDeps live wiring. */
+  _accessRecallSurface;
+  get accessRecallSurface() {
+    if (!this._accessRecallSurface) {
+      this._accessRecallSurface = new AccessRecallSurface(
+        selfDeps(this)
+      );
+    }
+    return this._accessRecallSurface;
+  }
   get briefingEnabled() {
     return this.orchestrator.config.briefing?.enabled === true;
   }
@@ -5453,313 +5452,64 @@ var EngramAccessService = class {
     } : void 0;
   }
   async buildRecallResponseFromXraySnapshot(options) {
-    const memoryIds = options.snapshot.results.map((result) => result.memoryId);
-    const resultPaths = options.snapshot.results.map((result) => result.path);
-    const namespace = options.snapshot.namespace ? this.resolveNamespace(options.snapshot.namespace) : this.orchestrator.config.defaultNamespace;
-    const sourcesUsed = Array.from(
-      new Set(options.snapshot.results.map((result) => result.servedBy))
-    );
-    const snapshotForSerialization = {
-      sessionKey: options.sessionKey ?? "",
-      recordedAt: new Date(options.snapshot.capturedAt).toISOString(),
-      queryHash: createHash4("sha256").update(options.query).digest("hex"),
-      queryLen: options.query.length,
-      memoryIds,
-      namespace,
-      recallNamespaces: [namespace],
-      traceId: options.snapshot.traceId,
-      plannerMode: options.normalizedMode,
-      requestedMode: options.requestedMode && options.requestedMode !== "auto" ? options.requestedMode : void 0,
-      sourcesUsed,
-      budgetsApplied: {
-        appliedTopK: memoryIds.length,
-        recallBudgetChars: options.snapshot.budget.chars,
-        maxMemoryTokens: this.orchestrator.config.maxMemoryTokens,
-        finalContextChars: options.snapshot.budget.used
-      },
-      latencyMs: Date.now() - options.startedAt,
-      resultPaths
-    };
-    const results = await this.serializeRecallResults(
-      snapshotForSerialization,
-      options.disclosure,
-      {
-        query: options.query,
-        ...options.sessionKey ? { sessionKey: options.sessionKey } : {},
-        ...options.rawExcerptNamespace ? { rawExcerptNamespace: options.rawExcerptNamespace } : {},
-        ...options.rawExcerptSessionIds !== void 0 ? { rawExcerptSessionIds: options.rawExcerptSessionIds } : {},
-        ...options.rawExcerptsSuppressed ? { rawExcerptsSuppressed: options.rawExcerptsSuppressed } : {}
-      }
+    return this.accessRecallSurface.buildRecallResponseFromXraySnapshot(
+      options
     );
-    const context = results.map((result) => {
-      const content = typeof result.content === "string" && result.content.length > 0 ? result.content : "";
-      return content || result.preview;
-    }).filter((text) => text.length > 0).join("\n\n");
-    return {
-      query: options.query,
-      ...options.sessionKey ? { sessionKey: options.sessionKey } : {},
-      namespace,
-      context,
-      count: memoryIds.length,
-      memoryIds,
-      results,
-      recordedAt: snapshotForSerialization.recordedAt,
-      traceId: options.snapshot.traceId,
-      plannerMode: options.normalizedMode,
-      fallbackUsed: sourcesUsed.some((source) => source !== "hybrid"),
-      sourcesUsed,
-      disclosure: options.disclosure,
-      budgetsApplied: snapshotForSerialization.budgetsApplied,
-      latencyMs: snapshotForSerialization.latencyMs
-    };
   }
   async serializeRecallResults(snapshot, disclosure, rawContext = null) {
-    if (!snapshot) return [];
-    const namespace = snapshot.namespace ? this.resolveNamespace(snapshot.namespace) : this.orchestrator.config.defaultNamespace;
-    const storage = await this.orchestrator.getStorage(namespace);
-    const storageDir = storage.dir;
-    const recallNamespaces = Array.from(
-      new Set(
-        [
-          namespace,
-          ...Array.isArray(snapshot.recallNamespaces) ? snapshot.recallNamespaces.map((ns) => this.resolveNamespace(ns)) : [],
-          this.orchestrator.config.defaultNamespace,
-          this.orchestrator.config.sharedNamespace,
-          ...(this.orchestrator.config.namespacePolicies ?? []).map((p) => p.name)
-        ].filter((ns) => typeof ns === "string" && ns.length > 0)
-      )
+    return this.accessRecallSurface.serializeRecallResults(
+      snapshot,
+      disclosure,
+      rawContext
     );
-    const results = [];
-    const seen = /* @__PURE__ */ new Set();
-    const collectionNamespaceFromPrefix = (collectionPrefix) => {
-      const baseCollection = this.orchestrator.config.qmdCollection;
-      if (collectionPrefix === baseCollection) return this.orchestrator.config.defaultNamespace;
-      const namespaceSuffix = collectionPrefix.startsWith(`${baseCollection}--`) ? collectionPrefix.slice(baseCollection.length + 2) : "";
-      if (!namespaceSuffix) return null;
-      const decoded = namespaceIdentityFromToken(namespaceSuffix);
-      if (decoded !== null) return decoded || this.orchestrator.config.defaultNamespace;
-      if (namespaceSuffix.startsWith("ns--")) {
-        const legacyNamespace = namespaceSuffix.slice("ns--".length).trim();
-        return legacyNamespace || null;
+  }
+  async storageForAbsoluteRecallPath(memoryPath, primaryNamespace, recallNamespaces = []) {
+    const resolvedPath = nodePath.resolve(memoryPath);
+    const memoryRoot = nodePath.resolve(this.orchestrator.config.memoryDir);
+    const namespacesRoot = nodePath.join(memoryRoot, "namespaces");
+    const configuredNamespaces = /* @__PURE__ */ new Set();
+    configuredNamespaces.add(primaryNamespace);
+    for (const namespace of recallNamespaces) {
+      configuredNamespaces.add(namespace);
+    }
+    configuredNamespaces.add(this.orchestrator.config.defaultNamespace);
+    configuredNamespaces.add(this.orchestrator.config.sharedNamespace);
+    if (isPathInsideStorageRoot(namespacesRoot, resolvedPath)) {
+      const relativeToNamespaces = nodePath.relative(namespacesRoot, resolvedPath);
+      const [namespaceSegment] = relativeToNamespaces.split(/[\\/]/);
+      if (namespaceSegment) {
+        configuredNamespaces.add(
+          namespaceIdentityFromToken(namespaceSegment) ?? namespaceSegment
+        );
       }
-      return null;
-    };
-    const readResultPath = async (memoryPath) => {
-      const parts = qmdCollectionPathParts(memoryPath);
-      const coldCollection = this.orchestrator.config.qmdColdCollection ?? "openclaw-engram-cold";
-      if (parts && parts.collection === coldCollection) {
-        const storages = [];
-        const seenStorageDirs = /* @__PURE__ */ new Set();
-        const addStorage = (candidateStorage) => {
-          const candidateDir = nodePath.resolve(candidateStorage.dir);
-          if (seenStorageDirs.has(candidateDir)) return;
-          seenStorageDirs.add(candidateDir);
-          storages.push({ storage: candidateStorage, dir: candidateDir });
-        };
-        addStorage(storage);
-        for (const recallNamespace of recallNamespaces) {
-          try {
-            addStorage(await this.orchestrator.getStorage(recallNamespace));
-          } catch {
-            continue;
-          }
-        }
-        for (const candidateStorage of storages) {
-          try {
-            const coldRoot = nodePath.join(candidateStorage.dir, "cold");
-            for (const candidatePath of qmdResultPathCandidates(
-              coldRoot,
-              parts.relativePath
-            )) {
-              const memory = await candidateStorage.storage.readMemoryByPath(candidatePath);
-              if (memory) return { memory, baseDir: candidateStorage.dir };
-            }
-          } catch (err) {
-            if (err instanceof SecureStoreLockedError) throw err;
-            continue;
-          }
-        }
-        return null;
+    }
+    for (const policy of this.orchestrator.config.namespacePolicies ?? []) {
+      configuredNamespaces.add(policy.name);
+    }
+    const matches = [];
+    for (const ns of configuredNamespaces) {
+      if (!ns) continue;
+      let candidateStorage;
+      try {
+        candidateStorage = await this.orchestrator.getStorage(ns);
+      } catch {
+        continue;
       }
-      const collectionNamespace = parts ? collectionNamespaceFromPrefix(parts.collection) : null;
-      if (parts && collectionNamespace) {
-        try {
-          const collectionStorage = await this.orchestrator.getStorage(collectionNamespace);
-          for (const candidate of qmdResultPathCandidates(
-            collectionStorage.dir,
-            parts.relativePath
-          )) {
-            const memory = await collectionStorage.readMemoryByPath(candidate);
-            if (memory) return { memory, baseDir: collectionStorage.dir };
-          }
-          return null;
-        } catch (err) {
-          if (err instanceof SecureStoreLockedError) throw err;
-          return null;
-        }
-      }
-      if (nodePath.isAbsolute(memoryPath)) {
-        const ownerStorage = await this.storageForAbsoluteRecallPath(
-          memoryPath,
-          namespace,
-          recallNamespaces
-        );
-        if (!ownerStorage) return null;
-        for (const candidate of qmdResultPathCandidates(
-          ownerStorage.dir,
-          memoryPath
-        )) {
-          const memory = await ownerStorage.storage.readMemoryByPath(candidate);
-          if (memory) return { memory, baseDir: ownerStorage.dir };
-        }
-        return null;
-      }
-      for (const candidate of qmdResultPathCandidates(storageDir, memoryPath)) {
-        const memory = await storage.readMemoryByPath(candidate);
-        if (memory) return { memory, baseDir: storageDir };
-      }
-      return null;
-    };
-    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 ? {
-        query: rawContext.query,
-        ...rawContext.sessionKey ? { sessionKey: rawContext.sessionKey } : {},
-        namespace: rawContext.rawExcerptNamespace ?? namespace,
-        ...rawContext.rawExcerptSessionIds !== void 0 ? { lcmSessionIds: rawContext.rawExcerptSessionIds } : {}
-      } : null
-    );
-    const rawExcerpts = rawExcerptsResult ?? void 0;
-    for (const memoryPath of snapshot.resultPaths ?? []) {
-      if (!memoryPath || seen.has(memoryPath)) continue;
-      const resolved = await readResultPath(memoryPath);
-      if (!resolved) continue;
-      const { memory, baseDir } = resolved;
-      seen.add(memoryPath);
-      results.push(
-        this.serializeMemorySummary(
-          memory,
-          baseDir,
-          disclosure,
-          // Attach the (possibly empty) raw excerpts to the first raw
-          // result; subsequent results do not duplicate the array.
-          results.length === 0 ? rawExcerpts : void 0
-        )
-      );
-    }
-    if (results.length > 0) return results;
-    for (const memoryId of snapshot.memoryIds) {
-      const memory = await storage.getMemoryById(memoryId);
-      if (!memory || seen.has(memory.path)) continue;
-      seen.add(memory.path);
-      results.push(
-        this.serializeMemorySummary(
-          memory,
-          storageDir,
-          disclosure,
-          results.length === 0 ? rawExcerpts : void 0
-        )
-      );
-    }
-    return results;
-  }
-  async storageForAbsoluteRecallPath(memoryPath, primaryNamespace, recallNamespaces = []) {
-    const resolvedPath = nodePath.resolve(memoryPath);
-    const memoryRoot = nodePath.resolve(this.orchestrator.config.memoryDir);
-    const namespacesRoot = nodePath.join(memoryRoot, "namespaces");
-    const configuredNamespaces = /* @__PURE__ */ new Set();
-    configuredNamespaces.add(primaryNamespace);
-    for (const namespace of recallNamespaces) {
-      configuredNamespaces.add(namespace);
-    }
-    configuredNamespaces.add(this.orchestrator.config.defaultNamespace);
-    configuredNamespaces.add(this.orchestrator.config.sharedNamespace);
-    if (isPathInsideStorageRoot(namespacesRoot, resolvedPath)) {
-      const relativeToNamespaces = nodePath.relative(namespacesRoot, resolvedPath);
-      const [namespaceSegment] = relativeToNamespaces.split(/[\\/]/);
-      if (namespaceSegment) {
-        configuredNamespaces.add(
-          namespaceIdentityFromToken(namespaceSegment) ?? namespaceSegment
-        );
-      }
-    }
-    for (const policy of this.orchestrator.config.namespacePolicies ?? []) {
-      configuredNamespaces.add(policy.name);
-    }
-    const matches = [];
-    for (const ns of configuredNamespaces) {
-      if (!ns) continue;
-      let candidateStorage;
-      try {
-        candidateStorage = await this.orchestrator.getStorage(ns);
-      } catch {
-        continue;
-      }
-      const candidateRoot = nodePath.resolve(candidateStorage.dir);
-      if (!isPathInsideStorageRoot(candidateRoot, resolvedPath)) continue;
-      if (candidateRoot === memoryRoot && isPathInsideStorageRoot(namespacesRoot, resolvedPath)) {
-        continue;
+      const candidateRoot = nodePath.resolve(candidateStorage.dir);
+      if (!isPathInsideStorageRoot(candidateRoot, resolvedPath)) continue;
+      if (candidateRoot === memoryRoot && isPathInsideStorageRoot(namespacesRoot, resolvedPath)) {
+        continue;
       }
       matches.push({ storage: candidateStorage, dir: candidateRoot });
     }
     matches.sort((a, b) => b.dir.length - a.dir.length);
     return matches[0] ?? null;
   }
-  /**
-   * Fetch raw transcript excerpts from the LCM archive for `disclosure ===
-   * "raw"` recalls (issue #677 PR 2/4).  Returns `null` for non-raw recall
-   * depths, an empty array when LCM is disabled / not initialized / has no
-   * matches, and an array of LCM-side excerpts otherwise.  Errors are
-   * swallowed and treated as "no excerpts" so a failing LCM never breaks
-   * the recall response.
-   *
-   * Namespace handling: LCM archival prefixes non-default-namespace
-   * sessions with `${namespace}:${sessionKey}` (see `observe()` around
-   * line 2498), so the lookup must mirror that prefix or raw recalls in
-   * non-default namespaces miss their own excerpts.
-   */
   async fetchRawExcerpts(disclosure, context) {
-    if (disclosure !== "raw") return null;
-    if (!context || !context.query) return [];
-    if (!context.sessionKey) return [];
-    const lcm = this.orchestrator.lcmEngine;
-    if (!lcm || !lcm.enabled) return [];
-    try {
-      const legacyKey = context.namespace && context.namespace !== this.orchestrator.config.defaultNamespace ? `${context.namespace}:${context.sessionKey}` : context.sessionKey;
-      const lcmSessionIds = context.lcmSessionIds !== void 0 ? context.lcmSessionIds : [legacyKey];
-      const limit = 5;
-      const seenRows = /* @__PURE__ */ new Set();
-      const excerpts = [];
-      const settledRows = await Promise.allSettled(
-        lcmSessionIds.map(
-          async (lcmSessionKey) => lcm.searchContextFull(context.query, limit, lcmSessionKey)
-        )
-      );
-      for (const result of settledRows) {
-        if (excerpts.length >= limit) break;
-        if (result.status !== "fulfilled") continue;
-        for (const r of result.value) {
-          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 [];
-    }
+    return this.accessRecallSurface.fetchRawExcerpts(
+      disclosure,
+      context
+    );
   }
   async handleIdempotentWrite(options) {
     if (options.skip === true) {
@@ -5845,8 +5595,8 @@ var EngramAccessService = class {
   async withIdempotencyLock(key, fn) {
     const previous = this.idempotencyLocks.get(key) ?? Promise.resolve();
     let release;
-    const current = new Promise((resolve2) => {
-      release = resolve2;
+    const current = new Promise((resolve3) => {
+      release = resolve3;
     });
     const queued = previous.then(() => current, () => current);
     this.idempotencyLocks.set(key, queued);
@@ -5865,8 +5615,8 @@ var EngramAccessService = class {
     const key = principal || "__anonymous__";
     const previous = this.budgetLocks.get(key) ?? Promise.resolve();
     let release;
-    const current = new Promise((resolve2) => {
-      release = resolve2;
+    const current = new Promise((resolve3) => {
+      release = resolve3;
     });
     const queued = previous.then(() => current, () => current);
     this.budgetLocks.set(key, queued);
@@ -6056,14 +5806,14 @@ var EngramAccessService = class {
     const timer = setTimeout(() => controller.abort(), 2e3);
     timer.unref?.();
     try {
-      return await new Promise((resolve2) => {
+      return await new Promise((resolve3) => {
         const onAbort = () => {
           controller.signal.removeEventListener("abort", onAbort);
-          resolve2(false);
+          resolve3(false);
         };
         controller.signal.addEventListener("abort", onAbort, { once: true });
         const probe = typeof qmd.checkAvailability === "function" ? qmd.checkAvailability({ signal: controller.signal }) : qmd.probe();
-        probe.then(resolve2, () => resolve2(false)).finally(() => {
+        probe.then(resolve3, () => resolve3(false)).finally(() => {
           controller.signal.removeEventListener("abort", onAbort);
         });
       });
@@ -6292,588 +6042,90 @@ var EngramAccessService = class {
     });
   }
   async executeRecall(request) {
-    const query = request.query;
-    const callerProvidedDisclosure = request.disclosure !== void 0 && request.disclosure !== null;
-    const requestedDisclosure = (() => {
-      if (!callerProvidedDisclosure) {
-        return DEFAULT_RECALL_DISCLOSURE;
-      }
-      if (!isRecallDisclosure(request.disclosure)) {
-        throw new EngramAccessInputError(
-          `disclosure must be one of: chunk, section, raw (got: ${String(request.disclosure)})`
-        );
+    return this.accessRecallSurface.executeRecall(
+      request
+    );
+  }
+  async recallExplain(request = {}) {
+    const requestedNamespace = request.namespace?.trim() ? this.resolveNamespace(request.namespace) : void 0;
+    const authenticatedPrincipal = request.authenticatedPrincipal?.trim();
+    const principal = authenticatedPrincipal || resolvePrincipal(request.sessionKey, this.orchestrator.config);
+    if (requestedNamespace) {
+      if (!canReadNamespace(principal, requestedNamespace, this.orchestrator.config)) {
+        return { found: false };
       }
-      return request.disclosure;
-    })();
-    if (request.codingContext !== void 0 && request.sessionKey) {
-      this.setCodingContext({
-        sessionKey: request.sessionKey,
-        codingContext: request.codingContext
-      });
+    } else if (resolveNamespaceCapabilities(this.orchestrator.config).namespaces && !principal) {
+      return { found: false };
     }
-    if (request.codingContext === void 0 && request.sessionKey) {
-      await this.maybeAttachCodingContext(request.sessionKey, {
-        cwd: request.cwd,
-        projectTag: request.projectTag
-      });
+    const snapshot = request.sessionKey ? (() => {
+      const candidate = this.orchestrator.lastRecall.get(request.sessionKey);
+      if (!candidate) return null;
+      if (!requestedNamespace) return candidate;
+      return candidate.namespace === requestedNamespace ? candidate : null;
+    })() : (() => {
+      const candidate = this.orchestrator.lastRecall.getMostRecent();
+      if (!candidate) return null;
+      if (!requestedNamespace) return candidate;
+      return candidate.namespace === requestedNamespace ? candidate : null;
+    })();
+    const readableSnapshot = (() => {
+      if (!snapshot || !resolveNamespaceCapabilities(this.orchestrator.config).namespaces) return snapshot;
+      const snapshotNamespace = snapshot.namespace ?? this.orchestrator.config.defaultNamespace;
+      return canReadNamespace(principal, snapshotNamespace, this.orchestrator.config) ? snapshot : null;
+    })();
+    const namespace = (() => {
+      if (requestedNamespace) return requestedNamespace;
+      if (readableSnapshot?.namespace) return readableSnapshot.namespace;
+      const fallbackNamespace = this.orchestrator.config.defaultNamespace;
+      if (!resolveNamespaceCapabilities(this.orchestrator.config).namespaces) return fallbackNamespace;
+      return canReadNamespace(principal, fallbackNamespace, this.orchestrator.config) ? fallbackNamespace : null;
+    })();
+    if (!namespace) return { found: false };
+    const [intent, graph] = await Promise.all([
+      this.orchestrator.getLastIntentSnapshot(namespace),
+      this.orchestrator.getLastGraphRecallSnapshot(namespace)
+    ]);
+    if (!readableSnapshot && !intent && !graph) return { found: false };
+    return { found: true, snapshot: readableSnapshot ?? void 0, intent, graph };
+  }
+  async recallTierExplain(sessionKey, namespace, authenticatedPrincipal) {
+    const namespacesEnabled = resolveNamespaceCapabilities(this.orchestrator.config).namespaces;
+    const requestedNamespace = namespace?.trim() ? this.resolveNamespace(namespace) : void 0;
+    const principal = authenticatedPrincipal?.trim() || resolvePrincipal(sessionKey, this.orchestrator.config);
+    if (requestedNamespace) {
+      if (!canReadNamespace(principal, requestedNamespace, this.orchestrator.config)) {
+        return toRecallExplainJson(null);
+      }
+    } else if (namespacesEnabled && !authenticatedPrincipal?.trim() && !sessionKey?.trim()) {
+      return toRecallExplainJson(null);
     }
-    const authenticatedPrincipal = request.authenticatedPrincipal?.trim();
-    const namespaceOverride = this.resolveRecallNamespace(
-      request.namespace,
-      request.sessionKey,
-      authenticatedPrincipal
+    const candidate = sessionKey ? this.orchestrator.lastRecall.get(sessionKey) : this.orchestrator.lastRecall.getMostRecent();
+    const snapshot = (() => {
+      if (!candidate) return null;
+      if (requestedNamespace) {
+        return candidate.namespace === requestedNamespace ? candidate : null;
+      }
+      if (!namespacesEnabled) return candidate;
+      const snapshotNs = candidate.namespace ?? this.orchestrator.config.defaultNamespace;
+      return canReadNamespace(principal, snapshotNs, this.orchestrator.config) ? candidate : null;
+    })();
+    return toRecallExplainJson(snapshot);
+  }
+  async recallXray(request) {
+    return this.accessRecallSurface.recallXray(
+      request
     );
-    const namespace = namespaceOverride ?? this.orchestrator.config.defaultNamespace;
-    const mode = this.normalizeRecallMode(request.mode);
-    const maybePrincipal = this.resolveRequestPrincipal(request.sessionKey, authenticatedPrincipal);
-    if (resolveNamespaceCapabilities(this.orchestrator.config).namespaces && !maybePrincipal) {
-      throw new EngramAccessInputError(
-        "authentication required: namespaces are enabled and no principal was supplied"
-      );
-    }
-    const principal = maybePrincipal ?? "default";
-    const principalNamespace = defaultNamespaceForPrincipal(principal, this.orchestrator.config);
-    const profileCodingContext = request.sessionKey && typeof this.orchestrator.getCodingContextForSession === "function" ? this.orchestrator.getCodingContextForSession(request.sessionKey) : null;
-    const profileCodingOverlay = !namespaceOverride && profileCodingContext && resolveNamespaceCapabilities(this.orchestrator.config).namespaces && this.orchestrator.config.codingMode?.projectScope ? resolveCodingNamespaceOverlay(
-      profileCodingContext,
-      this.orchestrator.config.codingMode,
-      this.orchestrator.config.defaultNamespace
-    ) : null;
-    const profilePlan = namespaceOverride ? null : resolveScopeProfilePlan({
-      config: this.orchestrator.config,
-      principal,
-      codingContext: profileCodingContext,
-      codingOverlay: profileCodingOverlay
-    });
-    const modeSkipsBudget = mode === "no_recall";
-    const legacyRecallNamespaces = Array.isArray(this.orchestrator.config.defaultRecallNamespaces) ? recallNamespacesForPrincipal(principal, this.orchestrator.config) : [];
-    const effectiveNamespaces = namespaceOverride ? [namespaceOverride] : profilePlan ? expandScopeProfileReadNamespaces({
-      profilePlan,
-      principalSelfNamespace: profilePlan.baseNamespace,
-      config: this.orchestrator.config,
-      principal,
-      codingOverlay: profileCodingOverlay,
-      legacyRecallNamespaces
-    }) : legacyRecallNamespaces;
-    const budgetPrincipalNamespace = profilePlan?.baseNamespace ?? principalNamespace;
-    let budgetDecision;
-    let recordBudgetAfterSuccess = false;
-    if (modeSkipsBudget) {
-      budgetDecision = {
-        allowed: true,
-        reason: "allowed-same-namespace",
-        count: 0,
-        limit: {
-          softLimit: this.orchestrator.config.recallCrossNamespaceBudgetSoftLimit ?? 10,
-          hardLimit: this.orchestrator.config.recallCrossNamespaceBudgetHardLimit ?? 30,
-          windowMs: this.orchestrator.config.recallCrossNamespaceBudgetWindowMs ?? 6e4
-        }
-      };
-    } else {
-      let anyCrossNamespace = false;
-      let denied = null;
-      let crossNamespaceDecision = null;
-      for (const ns of effectiveNamespaces) {
-        const peek = this.budget.peek({
-          principal,
-          principalNamespace: budgetPrincipalNamespace,
-          queryNamespace: ns
-        });
-        if (peek.reason !== "allowed-same-namespace") {
-          anyCrossNamespace = true;
-          crossNamespaceDecision ??= peek;
-        }
-        if (!peek.allowed) {
-          denied = peek;
-          break;
-        }
-      }
-      if (denied) {
-        budgetDecision = denied;
-      } else if (anyCrossNamespace) {
-        budgetDecision = crossNamespaceDecision ?? {
-          allowed: true,
-          reason: "allowed-under-soft",
-          count: 0,
-          limit: {
-            softLimit: this.orchestrator.config.recallCrossNamespaceBudgetSoftLimit ?? 10,
-            hardLimit: this.orchestrator.config.recallCrossNamespaceBudgetHardLimit ?? 30,
-            windowMs: this.orchestrator.config.recallCrossNamespaceBudgetWindowMs ?? 6e4
-          }
-        };
-        recordBudgetAfterSuccess = true;
-      } else {
-        budgetDecision = {
-          allowed: true,
-          reason: "allowed-same-namespace",
-          count: 0,
-          limit: {
-            softLimit: this.orchestrator.config.recallCrossNamespaceBudgetSoftLimit ?? 10,
-            hardLimit: this.orchestrator.config.recallCrossNamespaceBudgetHardLimit ?? 30,
-            windowMs: this.orchestrator.config.recallCrossNamespaceBudgetWindowMs ?? 6e4
-          }
-        };
-      }
-      if (!budgetDecision.allowed) {
-        throw new EngramAccessInputError(
-          `recall denied: cross-namespace budget exceeded (${budgetDecision.count}/${budgetDecision.limit.hardLimit} in ${budgetDecision.limit.windowMs}ms window)`
-        );
-      }
-      this.budget.gc();
-    }
-    const topK = Number.isFinite(request.topK) ? Math.max(0, Math.floor(request.topK ?? 0)) : void 0;
-    let asOf;
-    if (request.asOf !== void 0 && request.asOf !== null) {
-      if (typeof request.asOf !== "string" || request.asOf.trim().length === 0) {
-        throw new EngramAccessInputError(
-          "asOf must be a non-empty ISO 8601 timestamp string"
-        );
-      }
-      const parsed = Date.parse(request.asOf);
-      if (!Number.isFinite(parsed)) {
-        throw new EngramAccessInputError(
-          `asOf must be a parseable ISO 8601 timestamp (got: "${request.asOf}")`
-        );
-      }
-      asOf = request.asOf;
-    }
-    const recallOptions = {
-      namespace: namespaceOverride,
-      topK,
-      mode,
-      ...authenticatedPrincipal ? { principalOverride: authenticatedPrincipal } : {},
-      ...asOf !== void 0 ? { asOf } : {},
-      ...request.includeLowConfidence === true ? { includeLowConfidence: true } : {}
-    };
-    const startedAt = Date.now();
-    const context = await this.orchestrator.recall(query, request.sessionKey, recallOptions);
-    const snapshot = request.sessionKey ? this.orchestrator.lastRecall.get(request.sessionKey) : null;
-    const effectiveNamespace = snapshot?.namespace ? this.resolveNamespace(snapshot.namespace) : namespace;
-    const resultsReturned = snapshot?.memoryIds?.length ?? 0;
-    const appliedTopK = snapshot?.budgetsApplied?.appliedTopK;
-    const configMaxResults = typeof this.orchestrator.config.qmdMaxResults === "number" && Number.isFinite(this.orchestrator.config.qmdMaxResults) && this.orchestrator.config.qmdMaxResults > 0 ? this.orchestrator.config.qmdMaxResults : 0;
-    const topKDenominator = typeof appliedTopK === "number" && Number.isFinite(appliedTopK) && appliedTopK > 0 ? Math.max(appliedTopK, resultsReturned) : typeof topK === "number" && topK > 0 ? Math.max(topK, resultsReturned) : Math.max(configMaxResults, resultsReturned, 1);
-    const topKConfidence = snapshot && topKDenominator > 0 ? Math.min(1, resultsReturned / topKDenominator) : void 0;
-    const escalationDecision = decideDisclosureEscalation({
-      mode: this.orchestrator.config.recallDisclosureEscalation,
-      threshold: this.orchestrator.config.recallDisclosureEscalationThreshold,
-      originalDisclosure: requestedDisclosure,
-      callerProvidedDisclosure,
-      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: trimmedSessionKey,
-      ...rawExcerptNamespace ? { rawExcerptNamespace } : {},
-      ...rawExcerptSessionIds !== void 0 ? { rawExcerptSessionIds } : {},
-      ...rawExcerptsSuppressed ? { rawExcerptsSuppressed } : {}
-    });
-    const filterTags = normalizeTags(request.tags);
-    let tagMatchMode;
-    try {
-      tagMatchMode = parseTagMatch(request.tagMatch);
-    } catch (err) {
-      throw new EngramAccessInputError(
-        err instanceof Error ? err.message : String(err)
-      );
-    }
-    let effectiveContext = context;
-    if (filterTags && filterTags.length > 0) {
-      const beforeIds = results.map((r) => r.id);
-      const { results: admitted } = applyTagFilter(results, {
-        tags: filterTags,
-        tagMatch: tagMatchMode
-      });
-      results = admitted;
-      const admittedIds = new Set(results.map((r) => r.id));
-      const droppedAny = beforeIds.some((id) => !admittedIds.has(id));
-      if (droppedAny) {
-        effectiveContext = results.map((r) => {
-          const content = typeof r.content === "string" ? r.content ?? "" : "";
-          const preview = typeof r.preview === "string" ? r.preview ?? "" : "";
-          return content || preview;
-        }).filter((s) => s.length > 0).join("\n\n");
-      }
-    }
-    const filteredMemoryIds = filterTags && filterTags.length > 0 ? results.map((r) => r.id) : snapshot?.memoryIds ?? [];
-    const debug = await this.buildRecallDebug(
-      snapshot,
-      effectiveNamespace,
-      request.includeDebug === true,
-      request.sessionKey
-    );
-    let auditAnomalies;
-    if (this.auditAdapter) {
-      try {
-        const resolvedAgentId = principal ?? "__anonymous__";
-        const auditEntry = {
-          ts: (/* @__PURE__ */ new Date()).toISOString(),
-          sessionKey: request.sessionKey ?? "",
-          agentId: resolvedAgentId,
-          trigger: "access-surface",
-          queryText: query,
-          candidateMemoryIds: snapshot?.memoryIds ?? [],
-          // Audit must reflect what was actually injected, not what
-          // recall produced before the tag filter. Using `context`
-          // (pre-filter) overstates injectedChars and can leak content
-          // from excluded memories into the audit summary (cursor
-          // Medium on PR #712).
-          summary: effectiveContext.slice(0, 200) || null,
-          injectedChars: effectiveContext.length,
-          toggleState: "enabled",
-          latencyMs: Date.now() - startedAt,
-          plannerMode: snapshot?.plannerMode ?? mode,
-          requestedMode: mode,
-          fallbackUsed: snapshot?.fallbackUsed ?? false
-        };
-        const auditResult = await this.auditAdapter.record(
-          resolvedAgentId || "__anonymous__",
-          auditEntry
-        );
-        auditAnomalies = auditResult.anomalies;
-      } catch {
-      }
-    }
-    return {
-      response: {
-        query,
-        sessionKey: request.sessionKey,
-        namespace: effectiveNamespace,
-        context: effectiveContext,
-        count: filterTags && filterTags.length > 0 ? results.length : snapshot?.memoryIds.length ?? results.length,
-        memoryIds: filteredMemoryIds,
-        results,
-        recordedAt: snapshot?.recordedAt,
-        traceId: snapshot?.traceId,
-        plannerMode: snapshot?.plannerMode ?? mode,
-        fallbackUsed: snapshot?.fallbackUsed ?? false,
-        sourcesUsed: snapshot?.sourcesUsed ?? [],
-        disclosure,
-        budgetsApplied: snapshot?.budgetsApplied,
-        auditAnomalies,
-        budgetWarning: budgetDecision.reason === "warn-over-soft" ? budgetDecision : void 0,
-        latencyMs: snapshot?.latencyMs ?? Date.now() - startedAt,
-        debug
-      },
-      budgetRecordPrincipal: recordBudgetAfterSuccess ? principal : null
-    };
-  }
-  async recallExplain(request = {}) {
-    const requestedNamespace = request.namespace?.trim() ? this.resolveNamespace(request.namespace) : void 0;
-    const authenticatedPrincipal = request.authenticatedPrincipal?.trim();
-    const principal = authenticatedPrincipal || resolvePrincipal(request.sessionKey, this.orchestrator.config);
-    if (requestedNamespace) {
-      if (!canReadNamespace(principal, requestedNamespace, this.orchestrator.config)) {
-        return { found: false };
-      }
-    } else if (resolveNamespaceCapabilities(this.orchestrator.config).namespaces && !principal) {
-      return { found: false };
-    }
-    const snapshot = request.sessionKey ? (() => {
-      const candidate = this.orchestrator.lastRecall.get(request.sessionKey);
-      if (!candidate) return null;
-      if (!requestedNamespace) return candidate;
-      return candidate.namespace === requestedNamespace ? candidate : null;
-    })() : (() => {
-      const candidate = this.orchestrator.lastRecall.getMostRecent();
-      if (!candidate) return null;
-      if (!requestedNamespace) return candidate;
-      return candidate.namespace === requestedNamespace ? candidate : null;
-    })();
-    const readableSnapshot = (() => {
-      if (!snapshot || !resolveNamespaceCapabilities(this.orchestrator.config).namespaces) return snapshot;
-      const snapshotNamespace = snapshot.namespace ?? this.orchestrator.config.defaultNamespace;
-      return canReadNamespace(principal, snapshotNamespace, this.orchestrator.config) ? snapshot : null;
-    })();
-    const namespace = (() => {
-      if (requestedNamespace) return requestedNamespace;
-      if (readableSnapshot?.namespace) return readableSnapshot.namespace;
-      const fallbackNamespace = this.orchestrator.config.defaultNamespace;
-      if (!resolveNamespaceCapabilities(this.orchestrator.config).namespaces) return fallbackNamespace;
-      return canReadNamespace(principal, fallbackNamespace, this.orchestrator.config) ? fallbackNamespace : null;
-    })();
-    if (!namespace) return { found: false };
-    const [intent, graph] = await Promise.all([
-      this.orchestrator.getLastIntentSnapshot(namespace),
-      this.orchestrator.getLastGraphRecallSnapshot(namespace)
-    ]);
-    if (!readableSnapshot && !intent && !graph) return { found: false };
-    return { found: true, snapshot: readableSnapshot ?? void 0, intent, graph };
-  }
-  async recallTierExplain(sessionKey, namespace, authenticatedPrincipal) {
-    const namespacesEnabled = resolveNamespaceCapabilities(this.orchestrator.config).namespaces;
-    const requestedNamespace = namespace?.trim() ? this.resolveNamespace(namespace) : void 0;
-    const principal = authenticatedPrincipal?.trim() || resolvePrincipal(sessionKey, this.orchestrator.config);
-    if (requestedNamespace) {
-      if (!canReadNamespace(principal, requestedNamespace, this.orchestrator.config)) {
-        return toRecallExplainJson(null);
-      }
-    } else if (namespacesEnabled && !authenticatedPrincipal?.trim() && !sessionKey?.trim()) {
-      return toRecallExplainJson(null);
-    }
-    const candidate = sessionKey ? this.orchestrator.lastRecall.get(sessionKey) : this.orchestrator.lastRecall.getMostRecent();
-    const snapshot = (() => {
-      if (!candidate) return null;
-      if (requestedNamespace) {
-        return candidate.namespace === requestedNamespace ? candidate : null;
-      }
-      if (!namespacesEnabled) return candidate;
-      const snapshotNs = candidate.namespace ?? this.orchestrator.config.defaultNamespace;
-      return canReadNamespace(principal, snapshotNs, this.orchestrator.config) ? candidate : null;
-    })();
-    return toRecallExplainJson(snapshot);
-  }
-  /**
-   * Recall X-ray (issue #570).  Runs a recall with `xrayCapture: true`
-   * and returns the resulting snapshot as structured JSON so every
-   * surface (CLI / HTTP / MCP) gets the same payload.  Namespace scope
-   * is enforced before the recall fires (CLAUDE.md rule 42 — read and
-   * write paths must resolve through the same namespace layer) so an
-   * unauthorized principal cannot capture an x-ray for a namespace it
-   * cannot read.
-   */
-  async recallXray(request) {
-    const query = typeof request.query === "string" ? request.query : "";
-    if (query.trim().length === 0) {
-      throw new Error("recallXray: query is required and must be non-empty");
-    }
-    if (request.disclosure !== void 0 && !isRecallDisclosure(request.disclosure)) {
-      throw new EngramAccessInputError(
-        `recallXray: disclosure must be one of: chunk, section, raw (got: ${String(request.disclosure)})`
-      );
-    }
-    const namespacesEnabled = resolveNamespaceCapabilities(this.orchestrator.config).namespaces;
-    const requestedNamespace = request.namespace?.trim() ? this.resolveNamespace(request.namespace) : void 0;
-    const authenticatedPrincipal = request.authenticatedPrincipal?.trim();
-    const principal = authenticatedPrincipal || resolvePrincipal(request.sessionKey, this.orchestrator.config);
-    if (requestedNamespace) {
-      if (!canReadNamespace(
-        principal,
-        requestedNamespace,
-        this.orchestrator.config
-      )) {
-        return { snapshotFound: false };
-      }
-    } else if (namespacesEnabled && !authenticatedPrincipal && !request.sessionKey?.trim()) {
-      return { snapshotFound: false };
-    }
-    let budgetOverride;
-    if (request.budget !== void 0 && request.budget !== null) {
-      const parsed = typeof request.budget === "number" ? request.budget : Number(request.budget);
-      if (!Number.isFinite(parsed) || parsed <= 0 || !Number.isInteger(parsed)) {
-        throw new Error(
-          `recallXray: budget expects a positive integer; got ${JSON.stringify(request.budget)}`
-        );
-      }
-      budgetOverride = parsed;
-    }
-    const mode = this.normalizeRecallMode(request.mode);
-    const disclosure = request.disclosure ?? DEFAULT_RECALL_DISCLOSURE;
-    const previousQueue = this.xrayQueue;
-    let release = () => {
-    };
-    this.xrayQueue = new Promise((resolve2) => {
-      release = resolve2;
-    });
-    await previousQueue;
-    const recallStartedAt = Date.now();
-    const recallSessionKey = request.sessionKey?.trim() || void 0;
-    let xrayResponse = { snapshotFound: false };
-    try {
-      this.orchestrator.clearLastXraySnapshot();
-      await this.orchestrator.recall(query, recallSessionKey, {
-        xrayCapture: true,
-        ...requestedNamespace ? { namespace: requestedNamespace } : {},
-        ...budgetOverride !== void 0 ? { budgetCharsOverride: budgetOverride } : {},
-        ...mode !== void 0 ? { mode } : {},
-        // When the caller supplies an authenticated principal, forward
-        // it via the dedicated override channel so orchestrator-side
-        // ACL decisions use the SAME principal the access-surface
-        // pre-check above authorized.  Threading an
-        // `authenticatedPrincipal` through `sessionKey` would be wrong:
-        // `resolvePrincipal(sessionKey)` only maps configured raw
-        // session keys and otherwise collapses to `"default"`, which
-        // in namespace-enabled deployments produces false denials /
-        // wrong-scope serving despite the pre-check passing
-        // (CLAUDE.md rule 42).
-        ...authenticatedPrincipal ? { principalOverride: authenticatedPrincipal } : {},
-        ...request.currentContextScopes !== void 0 ? { currentContextScopes: request.currentContextScopes } : {}
-      });
-      const rawSnapshot = this.orchestrator.getLastXraySnapshot();
-      const namespaceMismatch = requestedNamespace !== void 0 && rawSnapshot?.namespace !== requestedNamespace;
-      if (!rawSnapshot) {
-        xrayResponse = { snapshotFound: false };
-      } else if (namespaceMismatch) {
-        xrayResponse = { snapshotFound: false };
-      } else {
-        let snapshot = rawSnapshot;
-        const xrayFilterTags = normalizeTags(request.tags);
-        let xrayTagMatch;
-        try {
-          xrayTagMatch = parseTagMatch(request.tagMatch);
-        } catch (err) {
-          throw new EngramAccessInputError(
-            err instanceof Error ? err.message : String(err)
-          );
-        }
-        if (xrayFilterTags && xrayFilterTags.length > 0) {
-          const namespace = snapshot.namespace ? this.resolveNamespace(snapshot.namespace) : this.orchestrator.config.defaultNamespace;
-          const tagsByIndex = await Promise.all(
-            snapshot.results.map(async (result) => {
-              try {
-                const storage = await this.orchestrator.getStorage(namespace);
-                const memory = await storage.readMemoryByPath(result.path);
-                const t = memory?.frontmatter?.tags;
-                return Array.isArray(t) ? normalizeProjectionTags(t) : [];
-              } catch {
-                return [];
-              }
-            })
-          );
-          const tagged = snapshot.results.map((result, index) => ({
-            result,
-            tags: tagsByIndex[index] ?? []
-          }));
-          const { results: admittedTagged, trace } = applyTagFilter(tagged, {
-            tags: xrayFilterTags,
-            tagMatch: xrayTagMatch
-          });
-          const admittedResults = admittedTagged.map((entry) => entry.result);
-          const filters = trace ? [...snapshot.filters, trace] : snapshot.filters;
-          snapshot = { ...snapshot, results: admittedResults, filters };
-        }
-        if (request.disclosure !== void 0) {
-          const disclosure2 = request.disclosure;
-          const namespace = snapshot.namespace ? this.resolveNamespace(snapshot.namespace) : this.orchestrator.config.defaultNamespace;
-          const trimmedSessionKey = request.sessionKey?.trim() || void 0;
-          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 } : {},
-            ...rawExcerptNamespace ? { namespace: rawExcerptNamespace } : {},
-            ...rawExcerptSessionIds !== void 0 ? { 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) => {
-              try {
-                const storage = await this.orchestrator.getStorage(namespace);
-                return await storage.readMemoryByPath(result.path);
-              } catch {
-                return null;
-              }
-            })
-          );
-          const firstReadableIndex = memoryByIndex.findIndex((m) => m !== null);
-          const baseDir = (await this.orchestrator.getStorage(namespace)).dir;
-          const decorated = snapshot.results.map((result, index) => {
-            const memory = memoryByIndex[index];
-            if (!memory) {
-              return { ...result, disclosure: disclosure2 };
-            }
-            const shaped = shapeMemorySummary(
-              memory,
-              baseDir,
-              disclosure2,
-              disclosure2 === "raw" && index === firstReadableIndex && rawExcerpts && rawExcerpts.length > 0 ? rawExcerpts : void 0
-            );
-            return {
-              ...result,
-              disclosure: disclosure2,
-              estimatedTokens: estimateRecallTokens(JSON.stringify(shaped))
-            };
-          });
-          if (disclosure2 === "raw" && firstReadableIndex === -1 && rawExcerptText.length > 0 && decorated.length > 0) {
-            decorated[0] = {
-              ...decorated[0],
-              disclosure: disclosure2,
-              estimatedTokens: estimateRecallTokens(rawExcerptText)
-            };
-          }
-          const decoratedSnapshot = { ...snapshot, results: decorated };
-          xrayResponse = {
-            snapshotFound: true,
-            snapshot: decoratedSnapshot
-          };
-        } else {
-          xrayResponse = {
-            snapshotFound: true,
-            snapshot
-          };
-        }
-      }
-    } finally {
-      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({
-          query,
-          sessionKey: recallSessionKey,
-          snapshot: xrayResponse.snapshot,
-          disclosure,
-          startedAt: recallStartedAt,
-          requestedMode: request.mode,
-          normalizedMode: mode,
-          ...xrayRawExcerptNamespace ? { rawExcerptNamespace: xrayRawExcerptNamespace } : {},
-          ...xrayRawExcerptSessionIds !== void 0 ? { rawExcerptSessionIds: xrayRawExcerptSessionIds } : {},
-          ...xrayRawExcerptsSuppressed ? { rawExcerptsSuppressed: xrayRawExcerptsSuppressed } : {}
-        })
-      };
-    }
-    return xrayResponse;
-  }
-  // Sequence lock for `recallXray` — see comment inside the method.
-  // Lives on the instance so every x-ray call on the same service
-  // shares it, and so separate services in the same process (e.g.
-  // per-tenant) do not block each other.
-  xrayQueue = Promise.resolve();
-  async memoryStore(request, hooks) {
-    const namespace = await this.resolveCodingScopedWriteNamespace(request);
-    const schemaVersion = request.schemaVersion ?? ENGRAM_ACCESS_WRITE_SCHEMA_VERSION;
-    if (schemaVersion !== ENGRAM_ACCESS_WRITE_SCHEMA_VERSION) {
-      throw new EngramAccessInputError(`unsupported schemaVersion: ${schemaVersion}`);
+  }
+  // Sequence lock for `recallXray` — see comment inside the method.
+  // Lives on the instance so every x-ray call on the same service
+  // shares it, and so separate services in the same process (e.g.
+  // per-tenant) do not block each other.
+  xrayQueue = Promise.resolve();
+  async memoryStore(request, hooks) {
+    const namespace = await this.resolveCodingScopedWriteNamespace(request);
+    const schemaVersion = request.schemaVersion ?? ENGRAM_ACCESS_WRITE_SCHEMA_VERSION;
+    if (schemaVersion !== ENGRAM_ACCESS_WRITE_SCHEMA_VERSION) {
+      throw new EngramAccessInputError(`unsupported schemaVersion: ${schemaVersion}`);
     }
     const execute = async () => {
       const candidate = this.validateWriteCandidate(request, namespace);
@@ -9242,1123 +8494,2157 @@ ${next}`);
     return { explanation };
   }
   /**
-   * Read-only graph snapshot for the admin pane (issue #691 PR 2/5).
-   *
-   * Reads adjacency from the JSONL edge store written by `GraphIndex` and
-   * resolves node metadata via the namespaced storage manager.  Namespace
-   * resolution mirrors the read-side path used by `recall` /
-   * `procedureStats`, so multi-principal deployments can't leak edges from
-   * a peer namespace (CLAUDE.md rule 42).
+   * Read-only graph snapshot for the admin pane (issue #691 PR 2/5).
+   *
+   * Reads adjacency from the JSONL edge store written by `GraphIndex` and
+   * resolves node metadata via the namespaced storage manager.  Namespace
+   * resolution mirrors the read-side path used by `recall` /
+   * `procedureStats`, so multi-principal deployments can't leak edges from
+   * a peer namespace (CLAUDE.md rule 42).
+   */
+  async graphSnapshot(request, authenticatedPrincipal) {
+    const namespace = this.resolveReadableNamespace(
+      request.namespace,
+      authenticatedPrincipal
+    );
+    const storage = await this.orchestrator.getStorage(namespace);
+    const cfg = this.orchestrator.config;
+    const graphCaps = resolveGraphConstructionCapabilities(cfg);
+    let namespaceRootReal;
+    try {
+      namespaceRootReal = await nodeFs.realpath(storage.dir);
+    } catch {
+      namespaceRootReal = nodePath.resolve(storage.dir);
+    }
+    const namespaceRootWithSep = namespaceRootReal.endsWith(nodePath.sep) ? namespaceRootReal : namespaceRootReal + nodePath.sep;
+    const loadNode = async (relPath) => {
+      if (nodePath.isAbsolute(relPath)) {
+        log.warn(
+          `graphSnapshot: rejected absolute edge endpoint (len=${relPath.length}) outside namespace root`
+        );
+        return null;
+      }
+      const candidate = nodePath.resolve(namespaceRootReal, relPath);
+      if (candidate !== namespaceRootReal && !candidate.startsWith(namespaceRootWithSep)) {
+        log.warn(
+          `graphSnapshot: rejected traversing edge endpoint (len=${relPath.length}) outside namespace root`
+        );
+        return null;
+      }
+      let canonical;
+      try {
+        canonical = await nodeFs.realpath(candidate);
+      } catch {
+        canonical = candidate;
+      }
+      if (canonical !== namespaceRootReal && !canonical.startsWith(namespaceRootWithSep)) {
+        log.warn(
+          `graphSnapshot: rejected symlinked edge endpoint (len=${relPath.length}) that resolved outside namespace root`
+        );
+        return null;
+      }
+      const memory = await storage.readMemoryByPath(canonical);
+      if (!memory) return null;
+      const fm = memory.frontmatter;
+      return {
+        category: fm.category ?? "unknown",
+        label: fm.id ?? nodePath.basename(canonical, nodePath.extname(canonical)),
+        updated: fm.updated
+      };
+    };
+    return buildGraphSnapshot({
+      memoryDir: namespaceRootReal,
+      graphConfig: {
+        entityGraph: graphCaps.entityGraph,
+        timeGraph: graphCaps.timeGraph,
+        causalGraph: graphCaps.causalGraph
+      },
+      request: {
+        limit: request.limit,
+        since: request.since,
+        focusNodeId: request.focusNodeId,
+        categories: request.categories
+      },
+      loadNode
+    });
+  }
+  async memoryFeedback(request) {
+    if (!resolveRecallEnhancementCapabilities(this.orchestrator.config).feedback) {
+      return {
+        recorded: false,
+        enabled: false,
+        reason: "Feedback is disabled. Enable `feedbackEnabled: true` in the Engram config to store feedback."
+      };
+    }
+    await this.orchestrator.recordMemoryFeedback(
+      request.memoryId,
+      request.vote,
+      request.note
+    );
+    return { recorded: true };
+  }
+  /**
+   * Record a Memory Worth outcome observation (issue #560 PR 3).
+   *
+   * This is distinct from `memoryFeedback` — feedback is a human thumbs
+   * up/down on whether a recalled memory was relevant; outcome is an
+   * automated signal about whether the session that consumed the memory
+   * ultimately succeeded or failed. Outcomes feed the Laplace-smoothed
+   * worth score (`computeMemoryWorth`, PR 2) that PR 4 will use to
+   * downweight memories correlated with bad sessions.
+   *
+   * The underlying writer only touches fact-category memories. Corrections,
+   * procedures, and other kinds return `{ ok: false, reason:
+   * "ineligible_category" }` so a ledger drainer doesn't need to pre-filter.
+   */
+  async memoryOutcome(request) {
+    if (request.memoryId.includes("/") || request.memoryId.includes("\\")) {
+      throw new EngramAccessInputError(
+        "memoryId must not contain path separators"
+      );
+    }
+    const resolvedNs = this.writableNamespaceFor(
+      request.namespace,
+      request.sessionKey,
+      request.principal
+    );
+    const storage = await this.orchestrator.getStorage(resolvedNs);
+    return recordMemoryOutcome(storage, {
+      memoryPath: `${request.memoryId}.md`,
+      outcome: request.outcome,
+      timestamp: request.timestamp
+    });
+  }
+  async memoryPromote(request) {
+    const resolvedNs = this.writableNamespaceFor(request.namespace, request.sessionKey, request.principal);
+    const storage = await this.orchestrator.getStorage(resolvedNs);
+    await storage.updateMemoryFrontmatter(request.memoryId, {
+      lifecycleState: "active",
+      updated: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    return { promoted: true, memoryId: request.memoryId };
+  }
+  async memoryActionApply(request) {
+    const actionTypes = /* @__PURE__ */ new Set([
+      "store_episode",
+      "store_note",
+      "update_note",
+      "create_artifact",
+      "summarize_node",
+      "discard",
+      "link_graph"
+    ]);
+    if (!actionTypes.has(request.action)) {
+      throw new EngramAccessInputError(
+        `memory_action_apply: invalid action ${JSON.stringify(request.action)}`
+      );
+    }
+    if (resolveCompressionCapabilities(this.orchestrator.config).contextCompressionActions !== true) {
+      throw new EngramAccessInputError(
+        "memory_action_apply is disabled; enable contextCompressionActionsEnabled to use this tool"
+      );
+    }
+    const outcome = request.outcome ?? "skipped";
+    if (outcome !== "applied" && outcome !== "skipped" && outcome !== "failed") {
+      throw new EngramAccessInputError(
+        `memory_action_apply: outcome must be "applied", "skipped", or "failed"; got ${JSON.stringify(outcome)}`
+      );
+    }
+    const resolvedNs = this.writableNamespaceFor(
+      request.namespace,
+      request.sessionKey,
+      request.principal
+    );
+    const inputSummaryParts = [
+      request.content,
+      request.category ? `category=${request.category}` : void 0,
+      request.linkTargetId ? `linkTargetId=${request.linkTargetId}` : void 0,
+      request.linkType ? `linkType=${request.linkType}` : void 0,
+      typeof request.linkStrength === "number" ? `linkStrength=${request.linkStrength}` : void 0,
+      request.artifactType ? `artifactType=${request.artifactType}` : void 0,
+      typeof request.execute === "boolean" ? `execute=${request.execute}` : void 0
+    ].filter((part) => typeof part === "string" && part.length > 0);
+    const event = {
+      action: request.action,
+      outcome,
+      namespace: resolvedNs,
+      actor: "access.memory_action_apply",
+      subsystem: "access.memory_action_apply",
+      reason: request.reason,
+      memoryId: request.memoryId,
+      sourceSessionKey: request.sessionKey,
+      inputSummary: inputSummaryParts.length > 0 ? inputSummaryParts.join(" | ").slice(0, 500) : void 0,
+      dryRun: request.dryRun === true,
+      promptHash: typeof request.sourcePrompt === "string" && request.sourcePrompt.length > 0 ? createHash4("sha256").update(request.sourcePrompt).digest("hex") : void 0
+    };
+    const preview = this.orchestrator.previewMemoryActionEvent(event);
+    if (request.dryRun === true) {
+      return { recorded: false, dryRun: true, event: preview };
+    }
+    const recorded = await this.orchestrator.appendMemoryActionEvent(event);
+    return { recorded, event: preview };
+  }
+  async contextCheckpoint(request) {
+    const resolvedNs = this.writableNamespaceFor(request.namespace, request.sessionKey, request.principal);
+    const storage = await this.orchestrator.getStorage(resolvedNs);
+    const storageDir = storage.dir;
+    const { writeFile: writeFile4, mkdir: mkdir5 } = await import("fs/promises");
+    const { join: join3, resolve: resolve3 } = await import("path");
+    const safeKey = request.sessionKey.replace(/[^a-zA-Z0-9_-]/g, "_");
+    if (!safeKey) throw new EngramAccessInputError("sessionKey is required");
+    const checkpointDir = join3(storageDir, "checkpoints", safeKey);
+    const resolved = resolve3(checkpointDir);
+    if (!resolved.startsWith(resolve3(storageDir))) {
+      throw new EngramAccessInputError("Invalid sessionKey");
+    }
+    await mkdir5(checkpointDir, { recursive: true });
+    const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+    const filePath = join3(checkpointDir, `checkpoint-${ts}.md`);
+    await writeFile4(filePath, request.context, "utf-8");
+    return { saved: true };
+  }
+  async lcmStatus() {
+    if (!this.orchestrator.lcmEngine || !this.orchestrator.lcmEngine.enabled) {
+      return {
+        enabled: false,
+        archiveAvailable: false
+      };
+    }
+    const stats = await this.orchestrator.lcmEngine.getStats();
+    return {
+      enabled: true,
+      archiveAvailable: true,
+      stats: {
+        totalTurns: stats.totalMessages
+      }
+    };
+  }
+  /**
+   * Record citation usage from an observed oai-mem-citation block.
+   * For each citation entry, extract the memory ID from the path and
+   * increment its access tracking via the orchestrator. Returns the
+   * count of submitted IDs and the count of IDs that matched real memories.
    */
-  async graphSnapshot(request, authenticatedPrincipal) {
-    const namespace = this.resolveReadableNamespace(
+  async recordCitationUsage(request) {
+    if (request.entries.length === 0) return { submitted: 0, matched: 0 };
+    const resolvedNamespace = this.writableNamespaceFor(
       request.namespace,
-      authenticatedPrincipal
+      request.sessionId,
+      request.authenticatedPrincipal
     );
-    const storage = await this.orchestrator.getStorage(namespace);
-    const cfg = this.orchestrator.config;
-    const graphCaps = resolveGraphConstructionCapabilities(cfg);
-    let namespaceRootReal;
-    try {
-      namespaceRootReal = await nodeFs.realpath(storage.dir);
-    } catch {
-      namespaceRootReal = nodePath.resolve(storage.dir);
-    }
-    const namespaceRootWithSep = namespaceRootReal.endsWith(nodePath.sep) ? namespaceRootReal : namespaceRootReal + nodePath.sep;
-    const loadNode = async (relPath) => {
-      if (nodePath.isAbsolute(relPath)) {
-        log.warn(
-          `graphSnapshot: rejected absolute edge endpoint (len=${relPath.length}) outside namespace root`
-        );
-        return null;
-      }
-      const candidate = nodePath.resolve(namespaceRootReal, relPath);
-      if (candidate !== namespaceRootReal && !candidate.startsWith(namespaceRootWithSep)) {
-        log.warn(
-          `graphSnapshot: rejected traversing edge endpoint (len=${relPath.length}) outside namespace root`
-        );
-        return null;
+    const memoryIds = [];
+    for (const entry of request.entries) {
+      const basename2 = entry.path.split("/").pop() ?? entry.path;
+      const id = basename2.endsWith(".md") ? basename2.slice(0, -3) : basename2;
+      if (id.length > 0) {
+        memoryIds.push(id);
       }
-      let canonical;
+    }
+    if (memoryIds.length === 0) return { submitted: 0, matched: 0 };
+    const storage = await this.orchestrator.getStorage(resolvedNamespace);
+    const existingIds = await storage.filterExistingMemoryIds(memoryIds);
+    const matchedIds = memoryIds.filter((id) => existingIds.has(id));
+    if (matchedIds.length > 0) {
       try {
-        canonical = await nodeFs.realpath(candidate);
+        this.orchestrator.trackMemoryAccess(matchedIds);
       } catch {
-        canonical = candidate;
+        log.debug("citation usage tracking: failed to record access for cited memories");
       }
-      if (canonical !== namespaceRootReal && !canonical.startsWith(namespaceRootWithSep)) {
-        log.warn(
-          `graphSnapshot: rejected symlinked edge endpoint (len=${relPath.length}) that resolved outside namespace root`
+    }
+    return { submitted: memoryIds.length, matched: matchedIds.length };
+  }
+  // ── Operator Console state (issue #688 PR 2/3) ────────────────────────────
+  /**
+   * Gather a point-in-time `ConsoleStateSnapshot` from the orchestrator.
+   *
+   * Principal-aware: `resolveReadableNamespace` enforces ACL before the
+   * snapshot is gathered, so callers cannot read a namespace they don't
+   * have read access to (CLAUDE.md rule 42).  The resolved namespace's
+   * storage directory is forwarded as `config.memoryDir` so the ledger-
+   * tail reader in `gatherConsoleState` scans the correct namespace root
+   * rather than the global root.  Read-only — never mutates orchestrator state.
+   */
+  async consoleState(namespace, principal) {
+    const resolvedNamespace = this.resolveReadableNamespace(namespace, principal);
+    const storage = await this.orchestrator.getStorage(resolvedNamespace);
+    const { gatherConsoleState } = await import("./state-ITXJKXRE.js");
+    const orchestratorProxy = Object.create(this.orchestrator, {
+      config: {
+        value: { ...this.orchestrator.config, memoryDir: storage.dir },
+        enumerable: true,
+        configurable: true
+      }
+    });
+    return gatherConsoleState(orchestratorProxy);
+  }
+  // ── Peer Registry surfaces (issue #679 PR 4/5) ────────────────────────────
+  /**
+   * List all registered peers. Returns the array of `Peer` objects in
+   * deterministic alphabetical order (mirroring `listPeers` storage semantics).
+   */
+  async peerList() {
+    const { listPeers } = await import("./peers/index.js");
+    const peers = await listPeers(this.orchestrator.config.memoryDir);
+    return { peers };
+  }
+  /**
+   * Get a single peer by id. Returns `{ found: false }` when the peer does
+   * not exist rather than throwing, matching the `memoryGet` / `entityGet`
+   * pattern used throughout the service.
+   */
+  async peerGet(peerId) {
+    const peers = await import("./peers/index.js");
+    const validateId = peers.assertValidPeerId;
+    try {
+      validateId(peerId);
+    } catch (err) {
+      throw new EngramAccessInputError(err.message);
+    }
+    const peer = await peers.readPeer(this.orchestrator.config.memoryDir, peerId);
+    if (!peer) return { found: false };
+    return { found: true, peer };
+  }
+  /**
+   * Upsert a peer. Writes `peers/{id}/identity.md`. On first write the
+   * `createdAt` timestamp is set to now; on subsequent writes only
+   * `displayName` and `notes` are mutated (kind and createdAt are immutable
+   * once set, per the storage contract).
+   *
+   * Returns `{ created: true }` on first write, `{ created: false }` on update.
+   */
+  async peerSet(input) {
+    const peers = await import("./peers/index.js");
+    const validateId = peers.assertValidPeerId;
+    const { id } = input;
+    try {
+      validateId(id);
+    } catch (err) {
+      throw new EngramAccessInputError(err.message);
+    }
+    const memoryDir = this.orchestrator.config.memoryDir;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const existing = await peers.readPeer(memoryDir, id);
+    const ALLOWED_KINDS = /* @__PURE__ */ new Set(["self", "human", "agent", "integration"]);
+    if (!existing) {
+      const kind = input.kind ?? "human";
+      if (!ALLOWED_KINDS.has(kind)) {
+        throw new EngramAccessInputError(
+          `peer kind must be one of ${[...ALLOWED_KINDS].join(", ")}`
         );
-        return null;
       }
-      const memory = await storage.readMemoryByPath(canonical);
-      if (!memory) return null;
-      const fm = memory.frontmatter;
-      return {
-        category: fm.category ?? "unknown",
-        label: fm.id ?? nodePath.basename(canonical, nodePath.extname(canonical)),
-        updated: fm.updated
+      const newPeer = {
+        id,
+        kind,
+        displayName: input.displayName ?? id,
+        createdAt: now,
+        updatedAt: now,
+        ...typeof input.notes === "string" ? { notes: input.notes } : {}
       };
+      await peers.writePeer(memoryDir, newPeer);
+      return { ok: true, created: true, peer: newPeer };
+    }
+    const updated = {
+      id: existing.id,
+      kind: existing.kind,
+      createdAt: existing.createdAt,
+      updatedAt: now,
+      displayName: input.displayName !== void 0 ? input.displayName : existing.displayName,
+      ...input.notes !== void 0 ? { notes: input.notes } : existing.notes !== void 0 ? { notes: existing.notes } : {}
     };
-    return buildGraphSnapshot({
-      memoryDir: namespaceRootReal,
-      graphConfig: {
-        entityGraph: graphCaps.entityGraph,
-        timeGraph: graphCaps.timeGraph,
-        causalGraph: graphCaps.causalGraph
-      },
-      request: {
-        limit: request.limit,
-        since: request.since,
-        focusNodeId: request.focusNodeId,
-        categories: request.categories
-      },
-      loadNode
+    await peers.writePeer(memoryDir, updated);
+    return { ok: true, created: false, peer: updated };
+  }
+  /**
+   * Delete a peer by removing `peers/{id}/identity.md`. If the file does not
+   * exist the call is a no-op (idempotent). The peer directory itself
+   * (`peers/{id}/`) is intentionally left in place — profile and interaction
+   * log data are not destroyed.
+   */
+  async peerDelete(peerId) {
+    const peers = await import("./peers/index.js");
+    const validateId = peers.assertValidPeerId;
+    try {
+      validateId(peerId);
+    } catch (err) {
+      throw new EngramAccessInputError(err.message);
+    }
+    const deleted = await peers.deletePeer(this.orchestrator.config.memoryDir, peerId);
+    return { ok: true, deleted };
+  }
+  /**
+   * Destructively purge the entire peer directory for a given peerId —
+   * `identity.md`, `profile.md`, `interactions.log.md`, and any other
+   * files in `peers/{id}/`. Requires `confirm: "yes"` to prevent
+   * accidental invocation.
+   *
+   * This is the DESTRUCTIVE counterpart to `peerDelete`, which only
+   * removes `identity.md`. All companion files are permanently removed.
+   *
+   * Returns `{ ok: true, purged: true }` when the directory existed and
+   * was removed; `{ ok: true, purged: false }` when the directory did
+   * not exist (idempotent no-op).
+   */
+  async peerForget(peerId, opts) {
+    const peers = await import("./peers/index.js");
+    const validateId = peers.assertValidPeerId;
+    try {
+      validateId(peerId);
+    } catch (err) {
+      throw new EngramAccessInputError(err.message);
+    }
+    if (opts.confirm !== "yes") {
+      throw new EngramAccessInputError(
+        "peerForget requires confirm: 'yes' to prevent accidental data loss"
+      );
+    }
+    const result = await peers.forgetPeer(this.orchestrator.config.memoryDir, peerId, {
+      confirm: "yes"
     });
+    return { ok: true, purged: result.purged };
   }
-  async memoryFeedback(request) {
-    if (!resolveRecallEnhancementCapabilities(this.orchestrator.config).feedback) {
-      return {
-        recorded: false,
-        enabled: false,
-        reason: "Feedback is disabled. Enable `feedbackEnabled: true` in the Engram config to store feedback."
-      };
+  /**
+   * Get the evolving cognitive profile for a peer. Returns `{ found: false }`
+   * when no profile file exists yet (profile is written by the async reasoner,
+   * PR 2/5). The peer identity itself need not exist for a profile to exist,
+   * but in practice the reasoner only writes profiles for registered peers.
+   */
+  async peerProfileGet(peerId) {
+    const peers = await import("./peers/index.js");
+    const validateId = peers.assertValidPeerId;
+    try {
+      validateId(peerId);
+    } catch (err) {
+      throw new EngramAccessInputError(err.message);
     }
-    await this.orchestrator.recordMemoryFeedback(
-      request.memoryId,
-      request.vote,
-      request.note
-    );
-    return { recorded: true };
+    const profile = await peers.readPeerProfile(this.orchestrator.config.memoryDir, peerId);
+    if (!profile) return { found: false };
+    return { found: true, profile };
+  }
+  // ── Contradiction Review (issue #520) ──────────────────────────────────────
+  get memoryDir() {
+    return this.orchestrator.config.memoryDir;
   }
   /**
-   * Record a Memory Worth outcome observation (issue #560 PR 3).
+   * Resolve the storage directory for a given namespace.  Used by the SSE
+   * graph-event handler to subscribe to the correct per-namespace bus rather
+   * than the global root (CLAUDE.md rule 42 — read/write paths must resolve
+   * through the same namespace layer).
    *
-   * This is distinct from `memoryFeedback` — feedback is a human thumbs
-   * up/down on whether a recalled memory was relevant; outcome is an
-   * automated signal about whether the session that consumed the memory
-   * ultimately succeeded or failed. Outcomes feed the Laplace-smoothed
-   * worth score (`computeMemoryWorth`, PR 2) that PR 4 will use to
-   * downweight memories correlated with bad sessions.
+   * `principal` must be the transport-bound request principal (from
+   * `resolveRequestPrincipal`).  When namespaces are enabled, an absent
+   * principal causes `resolveReadableNamespace` to throw an auth error,
+   * matching the behaviour of every other authenticated read path.
    *
-   * The underlying writer only touches fact-category memories. Corrections,
-   * procedures, and other kinds return `{ ok: false, reason:
-   * "ineligible_category" }` so a ledger drainer doesn't need to pre-filter.
+   * Falls back to `this.memoryDir` when namespaces are disabled or the
+   * namespace is absent, matching the behaviour of every other read path.
    */
-  async memoryOutcome(request) {
-    if (request.memoryId.includes("/") || request.memoryId.includes("\\")) {
+  async getMemoryDirForNamespace(namespace, principal) {
+    const resolved = this.resolveReadableNamespace(namespace, principal);
+    const storage = await this.orchestrator.getStorage(resolved);
+    return storage.dir;
+  }
+  async getReadableStorageForNamespace(namespace, principal) {
+    const resolved = this.resolveReadableNamespace(namespace, principal);
+    const storage = await this.orchestrator.getStorage(resolved);
+    return { namespace: resolved, storage };
+  }
+  async getWritableStorageForNamespace(namespace, principal) {
+    if (resolveNamespaceCapabilities(this.orchestrator.config).namespaces && !principal?.trim()) {
       throw new EngramAccessInputError(
-        "memoryId must not contain path separators"
+        "authentication required: namespaces are enabled and no principal was supplied"
       );
     }
-    const resolvedNs = this.writableNamespaceFor(
-      request.namespace,
-      request.sessionKey,
-      request.principal
-    );
-    const storage = await this.orchestrator.getStorage(resolvedNs);
-    return recordMemoryOutcome(storage, {
-      memoryPath: `${request.memoryId}.md`,
-      outcome: request.outcome,
-      timestamp: request.timestamp
-    });
+    const resolved = this.writableNamespaceFor(namespace, void 0, principal);
+    const storage = await this.orchestrator.getStorage(resolved);
+    return { namespace: resolved, storage };
   }
-  async memoryPromote(request) {
-    const resolvedNs = this.writableNamespaceFor(request.namespace, request.sessionKey, request.principal);
-    const storage = await this.orchestrator.getStorage(resolvedNs);
-    await storage.updateMemoryFrontmatter(request.memoryId, {
-      lifecycleState: "active",
-      updated: (/* @__PURE__ */ new Date()).toISOString()
+  get storageRef() {
+    return this.orchestrator.storage;
+  }
+  // #1522: recordCatalogWrite removed — catalog touch handled at the storage chokepoint.
+  get configRef() {
+    return this.orchestrator.config;
+  }
+  get localLlmRef() {
+    return this.orchestrator.localLlm ?? null;
+  }
+  get fallbackLlmRef() {
+    return this.orchestrator.fastGatewayLlm ?? null;
+  }
+  get embeddingLookupFactoryRef() {
+    return (storage) => {
+      if (!resolveMemoryLifecycleCapabilities(this.orchestrator.config).embeddingFallback) return void 0;
+      return async (content, limit) => {
+        try {
+          return await this.orchestrator.semanticDedupLookup(content, limit, storage);
+        } catch {
+          return [];
+        }
+      };
+    };
+  }
+  /**
+   * Import a capsule archive into the orchestrator's memory directory.
+   *
+   * Delegates directly to the standalone {@link importCapsuleFn} function.
+   * The `root` parameter defaults to the orchestrator's `memoryDir` when
+   * omitted, so callers that only have access to the service do not need to
+   * thread the config value through.
+   *
+   * `versioning` defaults to the orchestrator's page-versioning config so
+   * `mode: "overwrite"` automatically snapshots prior content without the
+   * caller having to construct the config object.
+   */
+  async capsuleImport(opts) {
+    const { namespace, principal, root: explicitRoot, memoryDir: explicitMemoryDir, ...importOptions } = opts;
+    const resolvedNamespace = this.writableNamespaceFor(namespace, void 0, principal);
+    const storage = await this.orchestrator.getStorage(resolvedNamespace);
+    const root = explicitRoot ?? storage.dir;
+    const memoryDir = explicitMemoryDir ?? this.orchestrator.config.memoryDir;
+    const versioning = importOptions.versioning ?? {
+      enabled: resolveRecallAuxiliaryCapabilities(this.orchestrator.config).versioning,
+      maxVersionsPerPage: this.orchestrator.config.versioningMaxPerPage,
+      sidecarDir: this.orchestrator.config.versioningSidecarDir
+    };
+    await this.validateCapsuleImportArchivePath(importOptions.archivePath);
+    try {
+      return await importCapsule({ ...importOptions, root, memoryDir, versioning });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      if (this.isCapsuleImportArchiveInputError(err, message)) {
+        throw new EngramAccessInputError(`capsule import failed: ${message}`);
+      }
+      throw err;
+    }
+  }
+  async validateCapsuleImportArchivePath(archivePath) {
+    let archiveStat;
+    try {
+      archiveStat = await stat2(archivePath);
+    } catch (err) {
+      if (!this.isCapsuleImportPathInputFsError(err)) throw err;
+      const message = err instanceof Error ? err.message : String(err);
+      throw new EngramAccessInputError(`capsule import failed: archive is not readable: ${message}`);
+    }
+    if (!archiveStat.isFile()) {
+      throw new EngramAccessInputError("capsule import failed: archivePath must point to a file");
+    }
+    try {
+      await nodeFs.access(archivePath, fsConstants.R_OK);
+    } catch (err) {
+      if (!this.isCapsuleImportPathInputFsError(err)) throw err;
+      const message = err instanceof Error ? err.message : String(err);
+      throw new EngramAccessInputError(`capsule import failed: archive is not readable: ${message}`);
+    }
+  }
+  isCapsuleImportPathInputFsError(err) {
+    const code = typeof err === "object" && err !== null && "code" in err ? err.code : void 0;
+    return code === "ENOENT" || code === "ENOTDIR" || code === "EACCES" || code === "EPERM" || code === "ELOOP";
+  }
+  isCapsuleImportArchiveInputError(err, message) {
+    if (err instanceof ZodError) return true;
+    const code = typeof err === "object" && err !== null && "code" in err ? err.code : void 0;
+    if (typeof code === "string" && code.startsWith("Z_")) return true;
+    return message.startsWith("importCapsule: archive") || message.startsWith("importCapsule: bundle") || message.startsWith("importCapsule: manifest") || message.startsWith("importCapsule: record") || /incorrect header check|invalid stored block lengths|not in gzip format|unexpected end of file/i.test(message);
+  }
+  /**
+   * Export a capsule archive from the orchestrator's memory directory.
+   *
+   * HTTP and future MCP surfaces use this rather than calling the transfer
+   * helper directly so namespace ACL checks stay consistent with the archive
+   * write side effect. The exporter still owns archive construction and
+   * validation.
+   */
+  async capsuleExport(opts) {
+    const { namespace, principal, root: explicitRoot, memoryDir: explicitMemoryDir, ...exportOptions } = opts;
+    const resolvedNamespace = this.writableNamespaceFor(namespace, void 0, principal);
+    const storage = await this.orchestrator.getStorage(resolvedNamespace);
+    const root = explicitRoot ?? storage.dir;
+    const memoryDir = explicitMemoryDir ?? this.orchestrator.config.memoryDir;
+    const pluginVersion = exportOptions.pluginVersion ?? await getPackageVersion();
+    return exportCapsule({
+      ...exportOptions,
+      pluginVersion,
+      root,
+      memoryDir: exportOptions.encrypt === true ? memoryDir : void 0
     });
-    return { promoted: true, memoryId: request.memoryId };
   }
-  async memoryActionApply(request) {
-    const actionTypes = /* @__PURE__ */ new Set([
-      "store_episode",
-      "store_note",
-      "update_note",
-      "create_artifact",
-      "summarize_node",
-      "discard",
-      "link_graph"
-    ]);
-    if (!actionTypes.has(request.action)) {
-      throw new EngramAccessInputError(
-        `memory_action_apply: invalid action ${JSON.stringify(request.action)}`
-      );
+  /**
+   * List capsule archives in the namespace-scoped capsule store.
+   *
+   * MCP uses this access-layer method instead of reading arbitrary paths so
+   * capsule discovery remains bound to the same namespace ACLs as export and
+   * import.
+   */
+  async capsuleList(options) {
+    const resolvedNamespace = this.resolveReadableNamespace(options?.namespace, options?.principal);
+    const storage = await this.orchestrator.getStorage(resolvedNamespace);
+    const capsulesDir = defaultCapsulesDir(storage.dir);
+    let dirEntries;
+    try {
+      const capsulesDirStat = await nodeFs.lstat(capsulesDir);
+      if (capsulesDirStat.isSymbolicLink()) {
+        throw new EngramAccessInputError("capsule list failed: capsule store directory must not be a symlink");
+      }
+      if (!capsulesDirStat.isDirectory()) {
+        throw new EngramAccessInputError("capsule list failed: capsule store path must be a directory");
+      }
+      dirEntries = await nodeFs.readdir(capsulesDir, { withFileTypes: true });
+    } catch (err) {
+      const code = typeof err === "object" && err !== null && "code" in err ? err.code : void 0;
+      if (code === "ENOENT") {
+        return { namespace: resolvedNamespace, capsulesDir, capsules: [] };
+      }
+      throw err;
     }
-    if (resolveCompressionCapabilities(this.orchestrator.config).contextCompressionActions !== true) {
-      throw new EngramAccessInputError(
-        "memory_action_apply is disabled; enable contextCompressionActionsEnabled to use this tool"
-      );
+    const archiveNames = dirEntries.filter(
+      (entry) => entry.isFile() && (entry.name.endsWith(".capsule.json.gz") || entry.name.endsWith(".capsule.json.gz.enc"))
+    ).map((entry) => entry.name).sort();
+    const capsules = [];
+    for (const archiveName of archiveNames) {
+      const archivePath = nodePath.join(capsulesDir, archiveName);
+      const id = archiveName.replace(/\.capsule\.json\.gz\.enc$/, "").replace(/\.capsule\.json\.gz$/, "");
+      const manifestPath = nodePath.join(capsulesDir, `${id}.manifest.json`);
+      let createdAt = null;
+      let pluginVersion = null;
+      let fileCount = null;
+      let description = null;
+      let manifestPathOrNull = manifestPath;
+      try {
+        const manifestStat = await nodeFs.lstat(manifestPath);
+        if (manifestStat.isSymbolicLink() || !manifestStat.isFile()) {
+          capsules.push({
+            id,
+            archivePath,
+            manifestPath: manifestPathOrNull,
+            createdAt,
+            pluginVersion,
+            fileCount,
+            description
+          });
+          continue;
+        }
+        const raw = await nodeFs.readFile(manifestPath, "utf-8");
+        const sidecar = JSON.parse(raw);
+        createdAt = typeof sidecar.createdAt === "string" ? sidecar.createdAt : null;
+        pluginVersion = typeof sidecar.pluginVersion === "string" ? sidecar.pluginVersion : null;
+        fileCount = Array.isArray(sidecar.files) ? sidecar.files.length : null;
+        const capsule = sidecar.capsule;
+        description = capsule && typeof capsule.description === "string" ? capsule.description : null;
+      } catch (err) {
+        const code = typeof err === "object" && err !== null && "code" in err ? err.code : void 0;
+        if (code === "ENOENT") {
+          manifestPathOrNull = null;
+        }
+      }
+      capsules.push({
+        id,
+        archivePath,
+        manifestPath: manifestPathOrNull,
+        createdAt,
+        pluginVersion,
+        fileCount,
+        description
+      });
     }
-    const outcome = request.outcome ?? "skipped";
-    if (outcome !== "applied" && outcome !== "skipped" && outcome !== "failed") {
-      throw new EngramAccessInputError(
-        `memory_action_apply: outcome must be "applied", "skipped", or "failed"; got ${JSON.stringify(outcome)}`
+    return { namespace: resolvedNamespace, capsulesDir, capsules };
+  }
+  /**
+   * Operator-configured offline-sync excludes (#1786), compiled once per
+   * service instance. Applied to push-side (snapshot/read) enumeration
+   * only — apply-side stays permissive so remote-authoritative runtime
+   * files keep flowing in.
+   */
+  _offlineSyncUserExcludes = null;
+  get offlineSyncUserExcludes() {
+    if (!this._offlineSyncUserExcludes) {
+      this._offlineSyncUserExcludes = compileOfflineSyncExcludeGlobs(
+        this.orchestrator.config.offlineSyncExcludes ?? []
       );
     }
-    const resolvedNs = this.writableNamespaceFor(
-      request.namespace,
-      request.sessionKey,
-      request.principal
-    );
-    const inputSummaryParts = [
-      request.content,
-      request.category ? `category=${request.category}` : void 0,
-      request.linkTargetId ? `linkTargetId=${request.linkTargetId}` : void 0,
-      request.linkType ? `linkType=${request.linkType}` : void 0,
-      typeof request.linkStrength === "number" ? `linkStrength=${request.linkStrength}` : void 0,
-      request.artifactType ? `artifactType=${request.artifactType}` : void 0,
-      typeof request.execute === "boolean" ? `execute=${request.execute}` : void 0
-    ].filter((part) => typeof part === "string" && part.length > 0);
-    const event = {
-      action: request.action,
-      outcome,
-      namespace: resolvedNs,
-      actor: "access.memory_action_apply",
-      subsystem: "access.memory_action_apply",
-      reason: request.reason,
-      memoryId: request.memoryId,
-      sourceSessionKey: request.sessionKey,
-      inputSummary: inputSummaryParts.length > 0 ? inputSummaryParts.join(" | ").slice(0, 500) : void 0,
-      dryRun: request.dryRun === true,
-      promptHash: typeof request.sourcePrompt === "string" && request.sourcePrompt.length > 0 ? createHash4("sha256").update(request.sourcePrompt).digest("hex") : void 0
+    return this._offlineSyncUserExcludes;
+  }
+  async offlineSyncSnapshot(options = {}) {
+    const resolvedNamespace = this.resolveReadableNamespace(options.namespace, options.principal);
+    const storage = await this.orchestrator.getStorage(resolvedNamespace);
+    const storageHash = createHash4("sha256").update(storage.dir).digest("hex").slice(0, 16);
+    const snapshotBuilder = options.includeContent === false && options.baseFiles && options.baseFiles.length > 0 ? buildOfflineSyncSnapshotFromBase : buildOfflineSyncSnapshot;
+    const snapshot = await snapshotBuilder({
+      root: storage.dir,
+      sourceId: `remnic:${resolvedNamespace}:${storageHash}`,
+      ...options.baseFiles && options.baseFiles.length > 0 ? { baseFiles: options.baseFiles } : {},
+      includeContent: options.includeContent !== false,
+      includeTranscripts: options.includeTranscripts !== false,
+      readFile: async ({ filePath }) => storage.readOfflineSyncFile(filePath),
+      readFileDigest: async ({ filePath }) => storage.digestOfflineSyncFile(filePath),
+      signal: options.signal,
+      userExcludeRegexps: this.offlineSyncUserExcludes
+    });
+    return {
+      namespace: resolvedNamespace,
+      ...snapshot
     };
-    const preview = this.orchestrator.previewMemoryActionEvent(event);
-    if (request.dryRun === true) {
-      return { recorded: false, dryRun: true, event: preview };
-    }
-    const recorded = await this.orchestrator.appendMemoryActionEvent(event);
-    return { recorded, event: preview };
   }
-  async contextCheckpoint(request) {
-    const resolvedNs = this.writableNamespaceFor(request.namespace, request.sessionKey, request.principal);
-    const storage = await this.orchestrator.getStorage(resolvedNs);
-    const storageDir = storage.dir;
-    const { writeFile: writeFile4, mkdir: mkdir5 } = await import("fs/promises");
-    const { join: join2, resolve: resolve2 } = await import("path");
-    const safeKey = request.sessionKey.replace(/[^a-zA-Z0-9_-]/g, "_");
-    if (!safeKey) throw new EngramAccessInputError("sessionKey is required");
-    const checkpointDir = join2(storageDir, "checkpoints", safeKey);
-    const resolved = resolve2(checkpointDir);
-    if (!resolved.startsWith(resolve2(storageDir))) {
-      throw new EngramAccessInputError("Invalid sessionKey");
-    }
-    await mkdir5(checkpointDir, { recursive: true });
-    const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-    const filePath = join2(checkpointDir, `checkpoint-${ts}.md`);
-    await writeFile4(filePath, request.context, "utf-8");
-    return { saved: true };
+  async offlineSyncSnapshotStream(options = {}) {
+    const resolvedNamespace = this.resolveReadableNamespace(options.namespace, options.principal);
+    const storage = await this.orchestrator.getStorage(resolvedNamespace);
+    const storageHash = createHash4("sha256").update(storage.dir).digest("hex").slice(0, 16);
+    return {
+      namespace: resolvedNamespace,
+      format: OFFLINE_SYNC_SNAPSHOT_FORMAT,
+      schemaVersion: 1,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      sourceId: `remnic:${resolvedNamespace}:${storageHash}`,
+      includeTranscripts: options.includeTranscripts !== false,
+      files: iterateOfflineSyncSnapshotFileRecords({
+        root: storage.dir,
+        includeContent: options.includeContent === true,
+        includeTranscripts: options.includeTranscripts !== false,
+        readFile: async ({ filePath }) => storage.readOfflineSyncFile(filePath),
+        readFileDigest: async ({ filePath }) => storage.digestOfflineSyncFile(filePath),
+        signal: options.signal,
+        userExcludeRegexps: this.offlineSyncUserExcludes
+      })
+    };
   }
-  async lcmStatus() {
-    if (!this.orchestrator.lcmEngine || !this.orchestrator.lcmEngine.enabled) {
+  async offlineSyncFiles(options) {
+    const resolvedNamespace = this.resolveReadableNamespace(options.namespace, options.principal);
+    const storage = await this.orchestrator.getStorage(resolvedNamespace);
+    const storageHash = createHash4("sha256").update(storage.dir).digest("hex").slice(0, 16);
+    try {
+      const snapshot = await buildOfflineSyncSnapshotForPaths({
+        root: storage.dir,
+        sourceId: `remnic:${resolvedNamespace}:${storageHash}`,
+        paths: options.paths,
+        includeContent: true,
+        includeTranscripts: options.includeTranscripts !== false,
+        readFile: async ({ filePath }) => storage.readOfflineSyncFile(filePath),
+        userExcludeRegexps: this.offlineSyncUserExcludes
+      });
       return {
-        enabled: false,
-        archiveAvailable: false
+        namespace: resolvedNamespace,
+        ...snapshot
       };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (message.startsWith("paths[]:") || message.startsWith("buildOfflineSyncSnapshotForPaths: record path ") || message.startsWith("offline sync snapshot path is excluded:")) {
+        throw new EngramAccessInputError(message);
+      }
+      throw error;
     }
-    const stats = await this.orchestrator.lcmEngine.getStats();
-    return {
-      enabled: true,
-      archiveAvailable: true,
-      stats: {
-        totalTurns: stats.totalMessages
+  }
+  async offlineSyncFileContent(options) {
+    const resolvedNamespace = this.resolveReadableNamespace(options.namespace, options.principal);
+    const storage = await this.orchestrator.getStorage(resolvedNamespace);
+    try {
+      const chunk = await readOfflineSyncFileContentChunk({
+        root: storage.dir,
+        path: options.path,
+        offset: options.offset,
+        length: options.length,
+        includeTranscripts: options.includeTranscripts !== false,
+        readFile: async ({ filePath }) => storage.readOfflineSyncFile(filePath),
+        userExcludeRegexps: this.offlineSyncUserExcludes
+      });
+      return {
+        namespace: resolvedNamespace,
+        ...chunk
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (message.startsWith("path:") || message.startsWith("offset ") || message.startsWith("offset must ") || message.startsWith("length ") || message.startsWith("offline sync file content ")) {
+        throw new EngramAccessInputError(message);
       }
-    };
+      throw error;
+    }
   }
-  /**
-   * Record citation usage from an observed oai-mem-citation block.
-   * For each citation entry, extract the memory ID from the path and
-   * increment its access tracking via the orchestrator. Returns the
-   * count of submitted IDs and the count of IDs that matched real memories.
-   */
-  async recordCitationUsage(request) {
-    if (request.entries.length === 0) return { submitted: 0, matched: 0 };
+  async offlineSyncApplyFileContent(options) {
     const resolvedNamespace = this.writableNamespaceFor(
-      request.namespace,
-      request.sessionId,
-      request.authenticatedPrincipal
+      options.namespace,
+      void 0,
+      options.principal
     );
-    const memoryIds = [];
-    for (const entry of request.entries) {
-      const basename2 = entry.path.split("/").pop() ?? entry.path;
-      const id = basename2.endsWith(".md") ? basename2.slice(0, -3) : basename2;
-      if (id.length > 0) {
-        memoryIds.push(id);
+    const storage = await this.orchestrator.getStorage(resolvedNamespace);
+    try {
+      const result = await applyOfflineSyncFileContentChunk({
+        root: storage.dir,
+        sourceId: options.sourceId,
+        path: options.path,
+        sha256: options.sha256,
+        bytes: options.bytes,
+        mtimeMs: options.mtimeMs,
+        offset: options.offset,
+        baseSha256: options.baseSha256,
+        content: options.content,
+        includeTranscripts: options.includeTranscripts !== false,
+        readFile: async ({ filePath }) => storage.readOfflineSyncFile(filePath),
+        readFileDigest: async ({ filePath }) => storage.digestOfflineSyncFile(filePath),
+        writeFile: async ({ filePath, content }) => storage.writeOfflineSyncFile(filePath, content),
+        writeStagingFile: async ({ filePath, content }) => storage.writeOfflineSyncStagingFile(filePath, content),
+        writeFileChunks: async ({ filePath, chunks }) => storage.writeOfflineSyncFileChunks(filePath, chunks)
+      });
+      return {
+        namespace: resolvedNamespace,
+        ...result
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (message.startsWith("offline sync") || message.startsWith("path:") || message.startsWith("sourceId must ") || message.startsWith("sha256 must ") || message.startsWith("baseSha256 must ") || message.startsWith("bytes must ") || message.startsWith("mtimeMs must ") || message.startsWith("offset must ") || message.startsWith("content chunk ") || message === "content must be a Buffer") {
+        throw new EngramAccessInputError(message);
       }
+      throw error;
     }
-    if (memoryIds.length === 0) return { submitted: 0, matched: 0 };
+  }
+  async offlineSyncApply(options) {
+    const resolvedNamespace = this.writableNamespaceFor(
+      options.namespace,
+      void 0,
+      options.principal
+    );
     const storage = await this.orchestrator.getStorage(resolvedNamespace);
-    const existingIds = await storage.filterExistingMemoryIds(memoryIds);
-    const matchedIds = memoryIds.filter((id) => existingIds.has(id));
-    if (matchedIds.length > 0) {
-      try {
-        this.orchestrator.trackMemoryAccess(matchedIds);
-      } catch {
-        log.debug("citation usage tracking: failed to record access for cited memories");
+    try {
+      const result = await applyOfflineSyncChangeset({
+        root: storage.dir,
+        changeset: options.changeset,
+        returnCurrentFiles: options.returnCurrentFiles,
+        readFile: async ({ filePath }) => storage.readOfflineSyncFile(filePath),
+        readFileDigest: async ({ filePath }) => storage.digestOfflineSyncFile(filePath),
+        writeFile: async ({ filePath, content }) => storage.writeOfflineSyncFile(filePath, content),
+        deleteFile: async ({ filePath }) => storage.deleteOfflineSyncFile(filePath)
+      });
+      return {
+        namespace: resolvedNamespace,
+        ...result
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (message.startsWith("offline sync")) {
+        throw new EngramAccessInputError(message);
       }
+      throw error;
     }
-    return { submitted: memoryIds.length, matched: matchedIds.length };
   }
-  // ── Operator Console state (issue #688 PR 2/3) ────────────────────────────
+  // ── Dreams pipeline telemetry surfaces (issue #678 PR 3+4) ──────────────
   /**
-   * Gather a point-in-time `ConsoleStateSnapshot` from the orchestrator.
+   * Return per-phase Dreams telemetry for the last N hours (default 24).
+   */
+  async dreamsStatus(options) {
+    const { getDreamsStatus, normalizeDreamsStatusWindowHours } = await import("./dreams-ledger-6UODQOX6.js");
+    let windowHours;
+    try {
+      windowHours = normalizeDreamsStatusWindowHours(options?.windowHours);
+    } catch (error) {
+      throw new EngramAccessInputError(error instanceof Error ? error.message : String(error));
+    }
+    const resolvedNamespace = this.resolveReadableNamespace(options?.namespace, options?.principal);
+    const storage = await this.orchestrator.getStorage(resolvedNamespace);
+    return getDreamsStatus(storage.dir, windowHours);
+  }
+  /**
+   * Manually invoke a single Dreams phase pass (PR 4/4).
    *
-   * Principal-aware: `resolveReadableNamespace` enforces ACL before the
-   * snapshot is gathered, so callers cannot read a namespace they don't
-   * have read access to (CLAUDE.md rule 42).  The resolved namespace's
-   * storage directory is forwarded as `config.memoryDir` so the ledger-
-   * tail reader in `gatherConsoleState` scans the correct namespace root
-   * rather than the global root.  Read-only — never mutates orchestrator state.
+   * Deep-sleep delegates to memory governance (shadow → dry-run, apply → live).
+   * Light-sleep and REM scan the observation ledger and memory corpus
+   * respectively, returning the same telemetry shape as a scheduled run.
    */
-  async consoleState(namespace, principal) {
-    const resolvedNamespace = this.resolveReadableNamespace(namespace, principal);
+  async dreamsRun(options) {
+    const { runDreamsPhase } = await import("./dreams-ledger-6UODQOX6.js");
+    const validPhases = ["lightSleep", "rem", "deepSleep"];
+    if (!validPhases.includes(options.phase)) {
+      throw new EngramAccessInputError(
+        `Invalid phase: ${String(options.phase)}. Must be one of: ${validPhases.join(", ")}`
+      );
+    }
+    const deepSleep = this.orchestrator.config.dreamsPhases.deepSleep;
+    if (options.phase === "deepSleep" && deepSleep.enabled === false && deepSleep.enabledExplicitlySet === true) {
+      throw new EngramAccessInputError(
+        "memory governance is disabled by dreams.phases.deepSleep.enabled=false"
+      );
+    }
+    const dryRun = options.dryRun === true;
+    const resolvedNamespace = this.writableNamespaceFor(
+      options.namespace,
+      void 0,
+      options.authenticatedPrincipal
+    );
     const storage = await this.orchestrator.getStorage(resolvedNamespace);
-    const { gatherConsoleState } = await import("./state-ITXJKXRE.js");
-    const orchestratorProxy = Object.create(this.orchestrator, {
-      config: {
-        value: { ...this.orchestrator.config, memoryDir: storage.dir },
-        enumerable: true,
-        configurable: true
+    const memoryDir = storage.dir;
+    const phaseRunner = dryRun || options.phase === "deepSleep" ? void 0 : async (_opts) => {
+      if (_opts.phase === "lightSleep") {
+        const result3 = await this.orchestrator.runLifecyclePolicyNow(storage);
+        return {
+          itemsProcessed: result3.memoriesAssessed,
+          notes: `scored ${result3.memoriesAssessed} memories`
+        };
       }
+      const result2 = await this.orchestrator.runSemanticConsolidationNow({
+        dryRun: false,
+        storage
+      });
+      const itemsProcessed = result2.clusters.reduce(
+        (sum, cluster) => sum + cluster.memories.length,
+        0
+      );
+      return {
+        itemsProcessed,
+        notes: `REM consolidation found ${result2.clustersFound} clusters`
+      };
+    };
+    const governanceRunner = options.phase === "deepSleep" ? async (_opts) => {
+      return this.orchestrator.runDeepSleepGovernanceNow({
+        storage,
+        dryRun: _opts.dryRun
+      });
+    } : void 0;
+    const result = await runDreamsPhase(
+      { memoryDir, phase: options.phase, dryRun },
+      governanceRunner,
+      phaseRunner
+    );
+    return {
+      phase: result.phase,
+      dryRun: result.dryRun,
+      durationMs: result.durationMs,
+      itemsProcessed: result.itemsProcessed,
+      notes: result.notes
+    };
+  }
+  // ---------------------------------------------------------------------------
+  // Wearables (Limitless / Bee / Omi transcript ingestion)
+  //
+  // Thin delegations to the orchestrator-owned WearablesService — the
+  // same instance behind the CLI, so HTTP/MCP callers observe identical
+  // behavior and validation (renderer-sharing rule).
+  // ---------------------------------------------------------------------------
+  async wearablesStatus() {
+    return this.orchestrator.getWearablesService().status();
+  }
+  async wearablesSync(request) {
+    return this.orchestrator.getWearablesService().sync({
+      source: request.source,
+      date: request.date,
+      days: request.days,
+      forceMemories: request.forceMemories
     });
-    return gatherConsoleState(orchestratorProxy);
   }
-  // ── Peer Registry surfaces (issue #679 PR 4/5) ────────────────────────────
+  async wearablesTranscriptDay(request) {
+    return this.orchestrator.getWearablesService().dayTranscript(request.date, request.source);
+  }
+  async wearablesTranscriptSearch(request) {
+    return this.orchestrator.getWearablesService().searchTranscripts(request.query, {
+      source: request.source,
+      from: request.from,
+      to: request.to,
+      limit: request.limit
+    });
+  }
+  async wearablesTranscriptMemories(request) {
+    return this.orchestrator.getWearablesService().transcriptMemories({
+      source: request.source,
+      date: request.date,
+      limit: request.limit
+    });
+  }
+  // ── Admin console surfaces (issue #1502) ────────────────────────────────
+  //
+  // Thin delegators. Every method threads `this.orchestrator` references
+  // into the pure `admin/admin-surfaces.ts` functions so the dashboard
+  // never re-resolves scope, re-derives promotion targets, or re-lists
+  // namespaces.
   /**
-   * List all registered peers. Returns the array of `Peer` objects in
-   * deterministic alphabetical order (mirroring `listPeers` storage semantics).
+   * Resolve an effective scope inspection for the console. Inputs are
+   * redacted before return so an operator-supplied principal preview /
+   * namespace override never echoes a pasted credential back.
    */
-  async peerList() {
-    const { listPeers } = await import("./peers/index.js");
-    const peers = await listPeers(this.orchestrator.config.memoryDir);
-    return { peers };
+  async adminInspectScope(options) {
+    const config = this.orchestrator.config;
+    const codingContext = options.sessionKey ? this.orchestrator.getCodingContextForSession(options.sessionKey) ?? null : null;
+    const inspection = inspectScope({
+      config,
+      sessionKey: options.sessionKey,
+      namespace: options.namespace,
+      principalOverride: options.principalOverride,
+      codingContext,
+      operation: options.operation
+    });
+    return redactSensitive(inspection);
   }
   /**
-   * Get a single peer by id. Returns `{ found: false }` when the peer does
-   * not exist rather than throwing, matching the `memoryGet` / `entityGet`
-   * pattern used throughout the service.
+   * List configured + discovered namespaces from the catalog with the
+   * admin filters the console exposes.
    */
-  async peerGet(peerId) {
-    const peers = await import("./peers/index.js");
-    const validateId = peers.assertValidPeerId;
-    try {
-      validateId(peerId);
-    } catch (err) {
-      throw new EngramAccessInputError(err.message);
-    }
-    const peer = await peers.readPeer(this.orchestrator.config.memoryDir, peerId);
-    if (!peer) return { found: false };
-    return { found: true, peer };
+  async adminListNamespaces(filter) {
+    const result = await listAdminNamespaces({
+      catalog: this.orchestrator.namespaceCatalog,
+      filter
+    });
+    return redactSensitive(result);
   }
   /**
-   * Upsert a peer. Writes `peers/{id}/identity.md`. On first write the
-   * `createdAt` timestamp is set to now; on subsequent writes only
-   * `displayName` and `notes` are mutated (kind and createdAt are immutable
-   * once set, per the storage contract).
-   *
-   * Returns `{ created: true }` on first write, `{ created: false }` on update.
+   * Per-namespace maintenance + QMD health. QMD diagnostics are probed via
+   * the orchestrator's search health accessor (one probe per namespace).
    */
-  async peerSet(input) {
-    const peers = await import("./peers/index.js");
-    const validateId = peers.assertValidPeerId;
-    const { id } = input;
-    try {
-      validateId(id);
-    } catch (err) {
-      throw new EngramAccessInputError(err.message);
-    }
-    const memoryDir = this.orchestrator.config.memoryDir;
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const existing = await peers.readPeer(memoryDir, id);
-    const ALLOWED_KINDS = /* @__PURE__ */ new Set(["self", "human", "agent", "integration"]);
-    if (!existing) {
-      const kind = input.kind ?? "human";
-      if (!ALLOWED_KINDS.has(kind)) {
-        throw new EngramAccessInputError(
-          `peer kind must be one of ${[...ALLOWED_KINDS].join(", ")}`
-        );
+  async adminMaintenanceHealth() {
+    const report = await gatherMaintenanceHealth({
+      catalog: this.orchestrator.namespaceCatalog,
+      qmdHealthProvider: async (namespace) => {
+        try {
+          const health = await this.orchestrator.searchHealthForNamespace(namespace);
+          return {
+            namespace,
+            collection: health.collection,
+            available: health.available,
+            collectionState: health.collectionState,
+            debugStatus: health.debugStatus,
+            installedVersion: health.installedVersion,
+            supportedVersion: health.supportedVersion,
+            supported: health.supported,
+            upgradeAvailable: health.upgradeAvailable,
+            daemonMode: health.daemonMode
+          };
+        } catch (err) {
+          throw err;
+        }
       }
-      const newPeer = {
-        id,
-        kind,
-        displayName: input.displayName ?? id,
-        createdAt: now,
-        updatedAt: now,
-        ...typeof input.notes === "string" ? { notes: input.notes } : {}
-      };
-      await peers.writePeer(memoryDir, newPeer);
-      return { ok: true, created: true, peer: newPeer };
-    }
-    const updated = {
-      id: existing.id,
-      kind: existing.kind,
-      createdAt: existing.createdAt,
-      updatedAt: now,
-      displayName: input.displayName !== void 0 ? input.displayName : existing.displayName,
-      ...input.notes !== void 0 ? { notes: input.notes } : existing.notes !== void 0 ? { notes: existing.notes } : {}
-    };
-    await peers.writePeer(memoryDir, updated);
-    return { ok: true, created: false, peer: updated };
+    });
+    return redactSensitive(report);
   }
   /**
-   * Delete a peer by removing `peers/{id}/identity.md`. If the file does not
-   * exist the call is a no-op (idempotent). The peer directory itself
-   * (`peers/{id}/`) is intentionally left in place — profile and interaction
-   * log data are not destroyed.
+   * Dry-run transcript/session audit. Detects mixed `other/default` data
+   * and legacy stranded directories. Never applies a migration.
    */
-  async peerDelete(peerId) {
-    const peers = await import("./peers/index.js");
-    const validateId = peers.assertValidPeerId;
-    try {
-      validateId(peerId);
-    } catch (err) {
-      throw new EngramAccessInputError(err.message);
-    }
-    const deleted = await peers.deletePeer(this.orchestrator.config.memoryDir, peerId);
-    return { ok: true, deleted };
+  async adminTranscriptAudit() {
+    const result = await auditTranscripts(this.orchestrator.config.memoryDir);
+    return redactSensitive(result);
   }
   /**
-   * Destructively purge the entire peer directory for a given peerId —
-   * `identity.md`, `profile.md`, `interactions.log.md`, and any other
-   * files in `peers/{id}/`. Requires `confirm: "yes"` to prevent
-   * accidental invocation.
-   *
-   * This is the DESTRUCTIVE counterpart to `peerDelete`, which only
-   * removes `identity.md`. All companion files are permanently removed.
-   *
-   * Returns `{ ok: true, purged: true }` when the directory existed and
-   * was removed; `{ ok: true, purged: false }` when the directory did
-   * not exist (idempotent no-op).
+   * Manually promote a memory into one or more authorized targets. Requires
+   * a non-empty reason (audit-logged). Reuses the scope-profile promotion
+   * resolution and `canWriteNamespace` gate — there is no dashboard-only
+   * write path.
    */
-  async peerForget(peerId, opts) {
-    const peers = await import("./peers/index.js");
-    const validateId = peers.assertValidPeerId;
-    try {
-      validateId(peerId);
-    } catch (err) {
-      throw new EngramAccessInputError(err.message);
-    }
-    if (opts.confirm !== "yes") {
-      throw new EngramAccessInputError(
-        "peerForget requires confirm: 'yes' to prevent accidental data loss"
+  async adminPromoteMemory(request) {
+    const config = this.orchestrator.config;
+    const namespacesEnabled = resolveNamespaceCapabilities(config).namespaces === true;
+    let sourceNamespace;
+    if (request.namespace) {
+      sourceNamespace = this.resolveReadableNamespace(
+        request.namespace,
+        request.principal
+      );
+    } else {
+      const codingContext2 = request.sessionKey ? this.orchestrator.getCodingContextForSession(request.sessionKey) ?? null : null;
+      const plan = resolveScopePlan({
+        config,
+        sessionKey: request.sessionKey,
+        principalOverride: request.principal,
+        codingContext: codingContext2,
+        namespacesEnabled
+      });
+      sourceNamespace = this.resolveReadableNamespace(
+        plan.baseNamespace,
+        request.principal
       );
     }
-    const result = await peers.forgetPeer(this.orchestrator.config.memoryDir, peerId, {
-      confirm: "yes"
+    const codingContext = request.sessionKey ? this.orchestrator.getCodingContextForSession(request.sessionKey) ?? null : null;
+    const codingOverlay = codingContext ? resolveCodingNamespaceOverlay(
+      codingContext,
+      config.codingMode,
+      config.defaultNamespace
+    ) : null;
+    const scopeProfilePlan = resolveScopeProfilePlan({
+      config,
+      principal: request.principal,
+      codingContext,
+      codingOverlay
     });
-    return { ok: true, purged: result.purged };
-  }
-  /**
-   * Get the evolving cognitive profile for a peer. Returns `{ found: false }`
-   * when no profile file exists yet (profile is written by the async reasoner,
-   * PR 2/5). The peer identity itself need not exist for a profile to exist,
-   * but in practice the reasoner only writes profiles for registered peers.
-   */
-  async peerProfileGet(peerId) {
-    const peers = await import("./peers/index.js");
-    const validateId = peers.assertValidPeerId;
+    const storage = {
+      readMemory: async (namespace, memoryId) => {
+        const resolved = await this.orchestrator.getStorage(namespace);
+        const memory = await resolved.getMemoryById(memoryId);
+        if (!memory) return null;
+        return {
+          category: memory.frontmatter.category,
+          content: memory.content,
+          frontmatter: memory.frontmatter
+        };
+      },
+      writePromotedMemory: async (namespace, memory) => {
+        const resolved = await this.orchestrator.getStorage(namespace);
+        const { id, tombstoneBlocked } = await resolved.writeMemory(
+          memory.category,
+          memory.content,
+          {
+            confidence: memory.confidence,
+            tags: memory.tags,
+            entityRef: memory.entityRef,
+            source: `admin-promotion:${memory.sourceNamespace}:${memory.reason.slice(0, 120)}`,
+            lineage: memory.lineage,
+            sourceMemoryId: memory.sourceMemoryId,
+            actor: memory.actor,
+            validAt: memory.validAt
+          }
+        );
+        if (tombstoneBlocked) {
+          throw new Error(
+            "target namespace tombstone-blocked the promoted content (pending_review)"
+          );
+        }
+        return id;
+      }
+    };
     try {
-      validateId(peerId);
+      return await promoteMemory({
+        config,
+        sourceMemoryId: request.sourceMemoryId,
+        sourceNamespace,
+        principal: request.principal,
+        targets: request.targets,
+        reason: request.reason,
+        actor: request.principal ?? "admin-console",
+        storage,
+        scopeProfilePlan
+      });
     } catch (err) {
-      throw new EngramAccessInputError(err.message);
+      if (err instanceof AdminPromotionError) {
+        throw new EngramAccessInputError(err.message);
+      }
+      throw err;
     }
-    const profile = await peers.readPeerProfile(this.orchestrator.config.memoryDir, peerId);
-    if (!profile) return { found: false };
-    return { found: true, profile };
-  }
-  // ── Contradiction Review (issue #520) ──────────────────────────────────────
-  get memoryDir() {
-    return this.orchestrator.config.memoryDir;
-  }
-  /**
-   * Resolve the storage directory for a given namespace.  Used by the SSE
-   * graph-event handler to subscribe to the correct per-namespace bus rather
-   * than the global root (CLAUDE.md rule 42 — read/write paths must resolve
-   * through the same namespace layer).
-   *
-   * `principal` must be the transport-bound request principal (from
-   * `resolveRequestPrincipal`).  When namespaces are enabled, an absent
-   * principal causes `resolveReadableNamespace` to throw an auth error,
-   * matching the behaviour of every other authenticated read path.
-   *
-   * Falls back to `this.memoryDir` when namespaces are disabled or the
-   * namespace is absent, matching the behaviour of every other read path.
-   */
-  async getMemoryDirForNamespace(namespace, principal) {
-    const resolved = this.resolveReadableNamespace(namespace, principal);
-    const storage = await this.orchestrator.getStorage(resolved);
-    return storage.dir;
-  }
-  async getReadableStorageForNamespace(namespace, principal) {
-    const resolved = this.resolveReadableNamespace(namespace, principal);
-    const storage = await this.orchestrator.getStorage(resolved);
-    return { namespace: resolved, storage };
   }
-  async getWritableStorageForNamespace(namespace, principal) {
-    if (resolveNamespaceCapabilities(this.orchestrator.config).namespaces && !principal?.trim()) {
-      throw new EngramAccessInputError(
-        "authentication required: namespaces are enabled and no principal was supplied"
-      );
+};
+
+// src/orchestration/qmd-result-resolver.ts
+import path8 from "path";
+function qmdCollectionPathParts(resultPath) {
+  if (!resultPath || path8.isAbsolute(resultPath)) return null;
+  const normalized = resultPath.replace(/\\/g, "/").replace(/^\/+/, "");
+  const slashIndex = normalized.indexOf("/");
+  if (slashIndex <= 0 || slashIndex >= normalized.length - 1) return null;
+  const collection = normalized.slice(0, slashIndex);
+  if (/^\d{4}-\d{2}-\d{2}$/.test(collection)) return null;
+  return {
+    collection,
+    relativePath: normalized.slice(slashIndex + 1)
+  };
+}
+function qmdResultPathCandidates(storageDir, resultPath) {
+  const candidates = /* @__PURE__ */ new Set();
+  const storageRoot = path8.resolve(storageDir);
+  const addCandidate = (candidate) => {
+    const resolved = path8.resolve(candidate);
+    if (isPathInsideStorageRoot(storageRoot, resolved)) {
+      candidates.add(resolved);
     }
-    const resolved = this.writableNamespaceFor(namespace, void 0, principal);
-    const storage = await this.orchestrator.getStorage(resolved);
-    return { namespace: resolved, storage };
-  }
-  get storageRef() {
-    return this.orchestrator.storage;
-  }
-  // #1522: recordCatalogWrite removed — catalog touch handled at the storage chokepoint.
-  get configRef() {
-    return this.orchestrator.config;
-  }
-  get localLlmRef() {
-    return this.orchestrator.localLlm ?? null;
-  }
-  get fallbackLlmRef() {
-    return this.orchestrator.fastGatewayLlm ?? null;
+  };
+  const addRelativeCandidates = (relativePath) => {
+    const normalized = relativePath.replace(/\\/g, "/").replace(/^\/+/, "");
+    if (!normalized) return;
+    addCandidate(path8.join(storageRoot, normalized));
+    if (/^\d{4}-\d{2}-\d{2}\//.test(normalized)) {
+      addCandidate(path8.join(storageRoot, "facts", normalized));
+    }
+  };
+  if (path8.isAbsolute(resultPath)) {
+    addCandidate(resultPath);
+  } else {
+    addRelativeCandidates(resultPath);
   }
-  get embeddingLookupFactoryRef() {
-    return (storage) => {
-      if (!resolveMemoryLifecycleCapabilities(this.orchestrator.config).embeddingFallback) return void 0;
-      return async (content, limit) => {
+  return [...candidates];
+}
+function storageDirOrNull(storage) {
+  const dir = storage.dir;
+  return typeof dir === "string" && dir.length > 0 ? dir : null;
+}
+var QmdResultResolver = class {
+  getConfig;
+  storageFor;
+  storageDirNamespace;
+  qmdCollectionNamespaceFromPrefix;
+  namespaceFromPath;
+  constructor(options) {
+    this.getConfig = options.getConfig;
+    this.storageFor = options.storageFor;
+    this.storageDirNamespace = options.storageDirNamespace;
+    this.qmdCollectionNamespaceFromPrefix = options.qmdCollectionNamespaceFromPrefix;
+    this.namespaceFromPath = options.namespaceFromPath;
+  }
+  async readQmdResultMemory(resultPath, fallbackStorage, recallNamespaces = []) {
+    const parts = qmdCollectionPathParts(resultPath);
+    const fallbackStorageDir = storageDirOrNull(fallbackStorage);
+    const config = this.getConfig();
+    const coldCollection = config.qmdColdCollection ?? "openclaw-engram-cold";
+    if (parts && parts.collection === coldCollection) {
+      const storages = [];
+      const seenStorageDirs = /* @__PURE__ */ new Set();
+      const addStorage = (storage) => {
+        const storageDir = storageDirOrNull(storage);
+        const storageKey = storageDir ? path8.resolve(storageDir) : `storage-without-dir-${storages.length}`;
+        if (seenStorageDirs.has(storageKey)) return;
+        seenStorageDirs.add(storageKey);
+        storages.push(storage);
+      };
+      const fallbackNamespace = fallbackStorageDir !== null ? this.storageDirNamespace(fallbackStorageDir) : config.defaultNamespace;
+      if (recallNamespaces.length === 0 || !resolveNamespaceCapabilities(config).namespaces || recallNamespaces.includes(fallbackNamespace)) {
+        addStorage(fallbackStorage);
+      }
+      if (recallNamespaces.length > 0) {
+        for (const namespace of recallNamespaces) {
+          try {
+            addStorage(await this.storageFor(namespace));
+          } catch (err) {
+            log.debug("qmd cold result namespace storage lookup skipped", {
+              path: resultPath,
+              namespace,
+              error: err.message
+            });
+          }
+        }
+      }
+      for (const storage of storages) {
+        const storageDir = storageDirOrNull(storage);
+        if (!storageDir) {
+          const memory = await storage.readMemoryByPath(resultPath);
+          if (memory) return memory;
+          continue;
+        }
         try {
-          return await this.orchestrator.semanticDedupLookup(content, limit, storage);
-        } catch {
-          return [];
+          const coldRoot = path8.join(storageDir, "cold");
+          for (const candidate of qmdResultPathCandidates(
+            coldRoot,
+            parts.relativePath
+          )) {
+            const memory = await storage.readMemoryByPath(candidate);
+            if (memory) return memory;
+          }
+        } catch (err) {
+          if (err instanceof SecureStoreLockedError) throw err;
+          log.debug("qmd cold result path lookup failed open", {
+            path: resultPath,
+            collection: coldCollection,
+            error: err.message
+          });
+        }
+      }
+      return null;
+    }
+    const collectionNamespace = parts ? this.qmdCollectionNamespaceFromPrefix(parts.collection) : null;
+    if (parts && collectionNamespace) {
+      try {
+        const collectionStorage = await this.storageFor(collectionNamespace);
+        for (const candidate of qmdResultPathCandidates(
+          collectionStorage.dir,
+          parts.relativePath
+        )) {
+          const memory = await collectionStorage.readMemoryByPath(candidate);
+          if (memory) return memory;
         }
-      };
-    };
-  }
-  /**
-   * Import a capsule archive into the orchestrator's memory directory.
-   *
-   * Delegates directly to the standalone {@link importCapsuleFn} function.
-   * The `root` parameter defaults to the orchestrator's `memoryDir` when
-   * omitted, so callers that only have access to the service do not need to
-   * thread the config value through.
-   *
-   * `versioning` defaults to the orchestrator's page-versioning config so
-   * `mode: "overwrite"` automatically snapshots prior content without the
-   * caller having to construct the config object.
-   */
-  async capsuleImport(opts) {
-    const { namespace, principal, root: explicitRoot, memoryDir: explicitMemoryDir, ...importOptions } = opts;
-    const resolvedNamespace = this.writableNamespaceFor(namespace, void 0, principal);
-    const storage = await this.orchestrator.getStorage(resolvedNamespace);
-    const root = explicitRoot ?? storage.dir;
-    const memoryDir = explicitMemoryDir ?? this.orchestrator.config.memoryDir;
-    const versioning = importOptions.versioning ?? {
-      enabled: resolveRecallAuxiliaryCapabilities(this.orchestrator.config).versioning,
-      maxVersionsPerPage: this.orchestrator.config.versioningMaxPerPage,
-      sidecarDir: this.orchestrator.config.versioningSidecarDir
-    };
-    await this.validateCapsuleImportArchivePath(importOptions.archivePath);
-    try {
-      return await importCapsule({ ...importOptions, root, memoryDir, versioning });
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      if (this.isCapsuleImportArchiveInputError(err, message)) {
-        throw new EngramAccessInputError(`capsule import failed: ${message}`);
+        return null;
+      } catch (err) {
+        if (err instanceof SecureStoreLockedError) throw err;
+        log.debug("qmd result namespace path lookup failed open", {
+          path: resultPath,
+          namespace: collectionNamespace,
+          error: err.message
+        });
+        return null;
       }
-      throw err;
     }
-  }
-  async validateCapsuleImportArchivePath(archivePath) {
-    let archiveStat;
-    try {
-      archiveStat = await stat2(archivePath);
-    } catch (err) {
-      if (!this.isCapsuleImportPathInputFsError(err)) throw err;
-      const message = err instanceof Error ? err.message : String(err);
-      throw new EngramAccessInputError(`capsule import failed: archive is not readable: ${message}`);
+    if (path8.isAbsolute(resultPath)) {
+      if (!fallbackStorageDir) {
+        return await fallbackStorage.readMemoryByPath(resultPath);
+      }
+      const ownerStorage = await this.storageForAbsoluteQmdResultPath(
+        resultPath,
+        fallbackStorage,
+        recallNamespaces
+      );
+      if (!ownerStorage) return null;
+      for (const candidate of qmdResultPathCandidates(
+        ownerStorage.dir,
+        resultPath
+      )) {
+        const memory = await ownerStorage.storage.readMemoryByPath(candidate);
+        if (memory) return memory;
+      }
+      return null;
     }
-    if (!archiveStat.isFile()) {
-      throw new EngramAccessInputError("capsule import failed: archivePath must point to a file");
+    if (!fallbackStorageDir) {
+      return await fallbackStorage.readMemoryByPath(resultPath);
     }
-    try {
-      await nodeFs.access(archivePath, fsConstants.R_OK);
-    } catch (err) {
-      if (!this.isCapsuleImportPathInputFsError(err)) throw err;
-      const message = err instanceof Error ? err.message : String(err);
-      throw new EngramAccessInputError(`capsule import failed: archive is not readable: ${message}`);
+    for (const candidate of qmdResultPathCandidates(
+      fallbackStorageDir,
+      resultPath
+    )) {
+      const memory = await fallbackStorage.readMemoryByPath(candidate);
+      if (memory) return memory;
     }
+    return null;
   }
-  isCapsuleImportPathInputFsError(err) {
-    const code = typeof err === "object" && err !== null && "code" in err ? err.code : void 0;
-    return code === "ENOENT" || code === "ENOTDIR" || code === "EACCES" || code === "EPERM" || code === "ELOOP";
+  async resolveColdQmdResultForRecall(result, fallbackStorage, recallNamespaces = []) {
+    const memory = await this.readQmdResultMemory(
+      result.path,
+      fallbackStorage,
+      recallNamespaces
+    );
+    if (!memory) return null;
+    let ownerNamespace = null;
+    if (path8.isAbsolute(memory.path)) {
+      const ownerStorage = await this.storageForAbsoluteQmdResultPath(
+        memory.path,
+        fallbackStorage,
+        recallNamespaces
+      );
+      ownerNamespace = ownerStorage?.namespace ?? null;
+      if (!ownerNamespace && resolveNamespaceCapabilities(this.getConfig()).namespaces) return null;
+    }
+    ownerNamespace ??= this.namespaceFromPath(memory.path);
+    if (recallNamespaces.length > 0 && !recallNamespaces.includes(ownerNamespace)) {
+      return null;
+    }
+    return {
+      namespace: ownerNamespace,
+      result: {
+        ...result,
+        docid: result.docid || memory.frontmatter.id,
+        path: memory.path,
+        snippet: result.snippet || memory.content.slice(0, 400)
+      }
+    };
   }
-  isCapsuleImportArchiveInputError(err, message) {
-    if (err instanceof ZodError) return true;
-    const code = typeof err === "object" && err !== null && "code" in err ? err.code : void 0;
-    if (typeof code === "string" && code.startsWith("Z_")) return true;
-    return message.startsWith("importCapsule: archive") || message.startsWith("importCapsule: bundle") || message.startsWith("importCapsule: manifest") || message.startsWith("importCapsule: record") || /incorrect header check|invalid stored block lengths|not in gzip format|unexpected end of file/i.test(message);
+  async storageForAbsoluteQmdResultPath(resultPath, fallbackStorage, recallNamespaces = []) {
+    const resolvedPath = path8.resolve(resultPath);
+    const config = this.getConfig();
+    const memoryRoot = path8.resolve(config.memoryDir);
+    const namespacesRoot = path8.join(memoryRoot, "namespaces");
+    const fallbackStorageDir = storageDirOrNull(fallbackStorage);
+    const matches = [];
+    const seenDirs = /* @__PURE__ */ new Set();
+    const maybeAddStorage = (storage, namespace) => {
+      const storageDir = storageDirOrNull(storage);
+      if (!storageDir) return;
+      const candidateRoot = path8.resolve(storageDir);
+      if (seenDirs.has(candidateRoot)) return;
+      if (!isPathInsideStorageRoot(candidateRoot, resolvedPath)) return;
+      if (candidateRoot === memoryRoot && isPathInsideStorageRoot(namespacesRoot, resolvedPath)) {
+        return;
+      }
+      seenDirs.add(candidateRoot);
+      matches.push({ storage, dir: candidateRoot, namespace });
+    };
+    const fallbackNamespace = fallbackStorageDir !== null ? this.storageDirNamespace(fallbackStorageDir) : config.defaultNamespace;
+    maybeAddStorage(fallbackStorage, fallbackNamespace);
+    const candidateNamespaces = /* @__PURE__ */ new Set();
+    candidateNamespaces.add(config.defaultNamespace);
+    candidateNamespaces.add(config.sharedNamespace);
+    for (const ns of recallNamespaces) {
+      candidateNamespaces.add(ns);
+    }
+    if (isPathInsideStorageRoot(namespacesRoot, resolvedPath)) {
+      const relativeToNamespaces = path8.relative(namespacesRoot, resolvedPath);
+      const [namespaceSegment] = relativeToNamespaces.split(/[\\/]/);
+      if (namespaceSegment) {
+        candidateNamespaces.add(
+          namespaceIdentityFromToken(namespaceSegment) ?? namespaceSegment
+        );
+      }
+    }
+    for (const policy of config.namespacePolicies ?? []) {
+      candidateNamespaces.add(policy.name);
+    }
+    for (const ns of candidateNamespaces) {
+      if (!ns) continue;
+      try {
+        maybeAddStorage(await this.storageFor(ns), ns);
+      } catch {
+        continue;
+      }
+    }
+    matches.sort((a, b) => b.dir.length - a.dir.length);
+    return matches[0] ?? null;
   }
-  /**
-   * Export a capsule archive from the orchestrator's memory directory.
-   *
-   * HTTP and future MCP surfaces use this rather than calling the transfer
-   * helper directly so namespace ACL checks stay consistent with the archive
-   * write side effect. The exporter still owns archive construction and
-   * validation.
-   */
-  async capsuleExport(opts) {
-    const { namespace, principal, root: explicitRoot, memoryDir: explicitMemoryDir, ...exportOptions } = opts;
-    const resolvedNamespace = this.writableNamespaceFor(namespace, void 0, principal);
-    const storage = await this.orchestrator.getStorage(resolvedNamespace);
-    const root = explicitRoot ?? storage.dir;
-    const memoryDir = explicitMemoryDir ?? this.orchestrator.config.memoryDir;
-    const pluginVersion = exportOptions.pluginVersion ?? await getPackageVersion();
-    return exportCapsule({
-      ...exportOptions,
-      pluginVersion,
-      root,
-      memoryDir: exportOptions.encrypt === true ? memoryDir : void 0
-    });
+};
+
+// src/access-recall-surface.ts
+var AccessRecallSurface = class {
+  constructor(deps) {
+    this.deps = deps;
   }
-  /**
-   * List capsule archives in the namespace-scoped capsule store.
-   *
-   * MCP uses this access-layer method instead of reading arbitrary paths so
-   * capsule discovery remains bound to the same namespace ACLs as export and
-   * import.
-   */
-  async capsuleList(options) {
-    const resolvedNamespace = this.resolveReadableNamespace(options?.namespace, options?.principal);
-    const storage = await this.orchestrator.getStorage(resolvedNamespace);
-    const capsulesDir = defaultCapsulesDir(storage.dir);
-    let dirEntries;
-    try {
-      const capsulesDirStat = await nodeFs.lstat(capsulesDir);
-      if (capsulesDirStat.isSymbolicLink()) {
-        throw new EngramAccessInputError("capsule list failed: capsule store directory must not be a symlink");
+  deps;
+  async buildRecallResponseFromXraySnapshot(options) {
+    const memoryIds = options.snapshot.results.map((result) => result.memoryId);
+    const resultPaths = options.snapshot.results.map((result) => result.path);
+    const namespace = options.snapshot.namespace ? this.deps.resolveNamespace(options.snapshot.namespace) : this.deps.orchestrator.config.defaultNamespace;
+    const sourcesUsed = Array.from(
+      new Set(options.snapshot.results.map((result) => result.servedBy))
+    );
+    const snapshotForSerialization = {
+      sessionKey: options.sessionKey ?? "",
+      recordedAt: new Date(options.snapshot.capturedAt).toISOString(),
+      queryHash: createHash5("sha256").update(options.query).digest("hex"),
+      queryLen: options.query.length,
+      memoryIds,
+      namespace,
+      recallNamespaces: [namespace],
+      traceId: options.snapshot.traceId,
+      plannerMode: options.normalizedMode,
+      requestedMode: options.requestedMode && options.requestedMode !== "auto" ? options.requestedMode : void 0,
+      sourcesUsed,
+      budgetsApplied: {
+        appliedTopK: memoryIds.length,
+        recallBudgetChars: options.snapshot.budget.chars,
+        maxMemoryTokens: this.deps.orchestrator.config.maxMemoryTokens,
+        finalContextChars: options.snapshot.budget.used
+      },
+      latencyMs: Date.now() - options.startedAt,
+      resultPaths
+    };
+    const results = await this.deps.serializeRecallResults(
+      snapshotForSerialization,
+      options.disclosure,
+      {
+        query: options.query,
+        ...options.sessionKey ? { sessionKey: options.sessionKey } : {},
+        ...options.rawExcerptNamespace ? { rawExcerptNamespace: options.rawExcerptNamespace } : {},
+        ...options.rawExcerptSessionIds !== void 0 ? { rawExcerptSessionIds: options.rawExcerptSessionIds } : {},
+        ...options.rawExcerptsSuppressed ? { rawExcerptsSuppressed: options.rawExcerptsSuppressed } : {}
       }
-      if (!capsulesDirStat.isDirectory()) {
-        throw new EngramAccessInputError("capsule list failed: capsule store path must be a directory");
+    );
+    const context = results.map((result) => {
+      const content = typeof result.content === "string" && result.content.length > 0 ? result.content : "";
+      return content || result.preview;
+    }).filter((text) => text.length > 0).join("\n\n");
+    return {
+      query: options.query,
+      ...options.sessionKey ? { sessionKey: options.sessionKey } : {},
+      namespace,
+      context,
+      count: memoryIds.length,
+      memoryIds,
+      results,
+      recordedAt: snapshotForSerialization.recordedAt,
+      traceId: options.snapshot.traceId,
+      plannerMode: options.normalizedMode,
+      fallbackUsed: sourcesUsed.some((source) => source !== "hybrid"),
+      sourcesUsed,
+      disclosure: options.disclosure,
+      budgetsApplied: snapshotForSerialization.budgetsApplied,
+      latencyMs: snapshotForSerialization.latencyMs
+    };
+  }
+  async serializeRecallResults(snapshot, disclosure, rawContext = null) {
+    if (!snapshot) return [];
+    const namespace = snapshot.namespace ? this.deps.resolveNamespace(snapshot.namespace) : this.deps.orchestrator.config.defaultNamespace;
+    const storage = await this.deps.orchestrator.getStorage(namespace);
+    const storageDir = storage.dir;
+    const recallNamespaces = Array.from(
+      new Set(
+        [
+          namespace,
+          ...Array.isArray(snapshot.recallNamespaces) ? snapshot.recallNamespaces.map((ns) => this.deps.resolveNamespace(ns)) : [],
+          this.deps.orchestrator.config.defaultNamespace,
+          this.deps.orchestrator.config.sharedNamespace,
+          ...(this.deps.orchestrator.config.namespacePolicies ?? []).map((p) => p.name)
+        ].filter((ns) => typeof ns === "string" && ns.length > 0)
+      )
+    );
+    const results = [];
+    const seen = /* @__PURE__ */ new Set();
+    const collectionNamespaceFromPrefix = (collectionPrefix) => {
+      const baseCollection = this.deps.orchestrator.config.qmdCollection;
+      if (collectionPrefix === baseCollection) return this.deps.orchestrator.config.defaultNamespace;
+      const namespaceSuffix = collectionPrefix.startsWith(`${baseCollection}--`) ? collectionPrefix.slice(baseCollection.length + 2) : "";
+      if (!namespaceSuffix) return null;
+      const decoded = namespaceIdentityFromToken(namespaceSuffix);
+      if (decoded !== null) return decoded || this.deps.orchestrator.config.defaultNamespace;
+      if (namespaceSuffix.startsWith("ns--")) {
+        const legacyNamespace = namespaceSuffix.slice("ns--".length).trim();
+        return legacyNamespace || null;
       }
-      dirEntries = await nodeFs.readdir(capsulesDir, { withFileTypes: true });
-    } catch (err) {
-      const code = typeof err === "object" && err !== null && "code" in err ? err.code : void 0;
-      if (code === "ENOENT") {
-        return { namespace: resolvedNamespace, capsulesDir, capsules: [] };
+      return null;
+    };
+    const readResultPath = async (memoryPath) => {
+      const parts = qmdCollectionPathParts(memoryPath);
+      const coldCollection = this.deps.orchestrator.config.qmdColdCollection ?? "openclaw-engram-cold";
+      if (parts && parts.collection === coldCollection) {
+        const storages = [];
+        const seenStorageDirs = /* @__PURE__ */ new Set();
+        const addStorage = (candidateStorage) => {
+          const candidateDir = nodePath2.resolve(candidateStorage.dir);
+          if (seenStorageDirs.has(candidateDir)) return;
+          seenStorageDirs.add(candidateDir);
+          storages.push({ storage: candidateStorage, dir: candidateDir });
+        };
+        addStorage(storage);
+        for (const recallNamespace of recallNamespaces) {
+          try {
+            addStorage(await this.deps.orchestrator.getStorage(recallNamespace));
+          } catch {
+            continue;
+          }
+        }
+        for (const candidateStorage of storages) {
+          try {
+            const coldRoot = nodePath2.join(candidateStorage.dir, "cold");
+            for (const candidatePath of qmdResultPathCandidates(
+              coldRoot,
+              parts.relativePath
+            )) {
+              const memory = await candidateStorage.storage.readMemoryByPath(candidatePath);
+              if (memory) return { memory, baseDir: candidateStorage.dir };
+            }
+          } catch (err) {
+            if (err instanceof SecureStoreLockedError) throw err;
+            continue;
+          }
+        }
+        return null;
       }
-      throw err;
-    }
-    const archiveNames = dirEntries.filter(
-      (entry) => entry.isFile() && (entry.name.endsWith(".capsule.json.gz") || entry.name.endsWith(".capsule.json.gz.enc"))
-    ).map((entry) => entry.name).sort();
-    const capsules = [];
-    for (const archiveName of archiveNames) {
-      const archivePath = nodePath.join(capsulesDir, archiveName);
-      const id = archiveName.replace(/\.capsule\.json\.gz\.enc$/, "").replace(/\.capsule\.json\.gz$/, "");
-      const manifestPath = nodePath.join(capsulesDir, `${id}.manifest.json`);
-      let createdAt = null;
-      let pluginVersion = null;
-      let fileCount = null;
-      let description = null;
-      let manifestPathOrNull = manifestPath;
-      try {
-        const manifestStat = await nodeFs.lstat(manifestPath);
-        if (manifestStat.isSymbolicLink() || !manifestStat.isFile()) {
-          capsules.push({
-            id,
-            archivePath,
-            manifestPath: manifestPathOrNull,
-            createdAt,
-            pluginVersion,
-            fileCount,
-            description
-          });
-          continue;
+      const collectionNamespace = parts ? collectionNamespaceFromPrefix(parts.collection) : null;
+      if (parts && collectionNamespace) {
+        try {
+          const collectionStorage = await this.deps.orchestrator.getStorage(collectionNamespace);
+          for (const candidate of qmdResultPathCandidates(
+            collectionStorage.dir,
+            parts.relativePath
+          )) {
+            const memory = await collectionStorage.readMemoryByPath(candidate);
+            if (memory) return { memory, baseDir: collectionStorage.dir };
+          }
+          return null;
+        } catch (err) {
+          if (err instanceof SecureStoreLockedError) throw err;
+          return null;
         }
-        const raw = await nodeFs.readFile(manifestPath, "utf-8");
-        const sidecar = JSON.parse(raw);
-        createdAt = typeof sidecar.createdAt === "string" ? sidecar.createdAt : null;
-        pluginVersion = typeof sidecar.pluginVersion === "string" ? sidecar.pluginVersion : null;
-        fileCount = Array.isArray(sidecar.files) ? sidecar.files.length : null;
-        const capsule = sidecar.capsule;
-        description = capsule && typeof capsule.description === "string" ? capsule.description : null;
-      } catch (err) {
-        const code = typeof err === "object" && err !== null && "code" in err ? err.code : void 0;
-        if (code === "ENOENT") {
-          manifestPathOrNull = null;
+      }
+      if (nodePath2.isAbsolute(memoryPath)) {
+        const ownerStorage = await this.deps.storageForAbsoluteRecallPath(
+          memoryPath,
+          namespace,
+          recallNamespaces
+        );
+        if (!ownerStorage) return null;
+        for (const candidate of qmdResultPathCandidates(
+          ownerStorage.dir,
+          memoryPath
+        )) {
+          const memory = await ownerStorage.storage.readMemoryByPath(candidate);
+          if (memory) return { memory, baseDir: ownerStorage.dir };
         }
+        return null;
       }
-      capsules.push({
-        id,
-        archivePath,
-        manifestPath: manifestPathOrNull,
-        createdAt,
-        pluginVersion,
-        fileCount,
-        description
-      });
-    }
-    return { namespace: resolvedNamespace, capsulesDir, capsules };
-  }
-  /**
-   * Operator-configured offline-sync excludes (#1786), compiled once per
-   * service instance. Applied to push-side (snapshot/read) enumeration
-   * only — apply-side stays permissive so remote-authoritative runtime
-   * files keep flowing in.
-   */
-  _offlineSyncUserExcludes = null;
-  get offlineSyncUserExcludes() {
-    if (!this._offlineSyncUserExcludes) {
-      this._offlineSyncUserExcludes = compileOfflineSyncExcludeGlobs(
-        this.orchestrator.config.offlineSyncExcludes ?? []
+      for (const candidate of qmdResultPathCandidates(storageDir, memoryPath)) {
+        const memory = await storage.readMemoryByPath(candidate);
+        if (memory) return { memory, baseDir: storageDir };
+      }
+      return null;
+    };
+    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.deps.fetchRawExcerpts(
+      disclosure,
+      rawContext ? {
+        query: rawContext.query,
+        ...rawContext.sessionKey ? { sessionKey: rawContext.sessionKey } : {},
+        namespace: rawContext.rawExcerptNamespace ?? namespace,
+        ...rawContext.rawExcerptSessionIds !== void 0 ? { lcmSessionIds: rawContext.rawExcerptSessionIds } : {}
+      } : null
+    );
+    const rawExcerpts = rawExcerptsResult ?? void 0;
+    for (const memoryPath of snapshot.resultPaths ?? []) {
+      if (!memoryPath || seen.has(memoryPath)) continue;
+      const resolved = await readResultPath(memoryPath);
+      if (!resolved) continue;
+      const { memory, baseDir } = resolved;
+      seen.add(memoryPath);
+      results.push(
+        this.deps.serializeMemorySummary(
+          memory,
+          baseDir,
+          disclosure,
+          // Attach the (possibly empty) raw excerpts to the first raw
+          // result; subsequent results do not duplicate the array.
+          results.length === 0 ? rawExcerpts : void 0
+        )
       );
     }
-    return this._offlineSyncUserExcludes;
-  }
-  async offlineSyncSnapshot(options = {}) {
-    const resolvedNamespace = this.resolveReadableNamespace(options.namespace, options.principal);
-    const storage = await this.orchestrator.getStorage(resolvedNamespace);
-    const storageHash = createHash4("sha256").update(storage.dir).digest("hex").slice(0, 16);
-    const snapshotBuilder = options.includeContent === false && options.baseFiles && options.baseFiles.length > 0 ? buildOfflineSyncSnapshotFromBase : buildOfflineSyncSnapshot;
-    const snapshot = await snapshotBuilder({
-      root: storage.dir,
-      sourceId: `remnic:${resolvedNamespace}:${storageHash}`,
-      ...options.baseFiles && options.baseFiles.length > 0 ? { baseFiles: options.baseFiles } : {},
-      includeContent: options.includeContent !== false,
-      includeTranscripts: options.includeTranscripts !== false,
-      readFile: async ({ filePath }) => storage.readOfflineSyncFile(filePath),
-      readFileDigest: async ({ filePath }) => storage.digestOfflineSyncFile(filePath),
-      signal: options.signal,
-      userExcludeRegexps: this.offlineSyncUserExcludes
-    });
-    return {
-      namespace: resolvedNamespace,
-      ...snapshot
-    };
-  }
-  async offlineSyncSnapshotStream(options = {}) {
-    const resolvedNamespace = this.resolveReadableNamespace(options.namespace, options.principal);
-    const storage = await this.orchestrator.getStorage(resolvedNamespace);
-    const storageHash = createHash4("sha256").update(storage.dir).digest("hex").slice(0, 16);
-    return {
-      namespace: resolvedNamespace,
-      format: OFFLINE_SYNC_SNAPSHOT_FORMAT,
-      schemaVersion: 1,
-      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-      sourceId: `remnic:${resolvedNamespace}:${storageHash}`,
-      includeTranscripts: options.includeTranscripts !== false,
-      files: iterateOfflineSyncSnapshotFileRecords({
-        root: storage.dir,
-        includeContent: options.includeContent === true,
-        includeTranscripts: options.includeTranscripts !== false,
-        readFile: async ({ filePath }) => storage.readOfflineSyncFile(filePath),
-        readFileDigest: async ({ filePath }) => storage.digestOfflineSyncFile(filePath),
-        signal: options.signal,
-        userExcludeRegexps: this.offlineSyncUserExcludes
-      })
-    };
-  }
-  async offlineSyncFiles(options) {
-    const resolvedNamespace = this.resolveReadableNamespace(options.namespace, options.principal);
-    const storage = await this.orchestrator.getStorage(resolvedNamespace);
-    const storageHash = createHash4("sha256").update(storage.dir).digest("hex").slice(0, 16);
-    try {
-      const snapshot = await buildOfflineSyncSnapshotForPaths({
-        root: storage.dir,
-        sourceId: `remnic:${resolvedNamespace}:${storageHash}`,
-        paths: options.paths,
-        includeContent: true,
-        includeTranscripts: options.includeTranscripts !== false,
-        readFile: async ({ filePath }) => storage.readOfflineSyncFile(filePath),
-        userExcludeRegexps: this.offlineSyncUserExcludes
-      });
-      return {
-        namespace: resolvedNamespace,
-        ...snapshot
-      };
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      if (message.startsWith("paths[]:") || message.startsWith("buildOfflineSyncSnapshotForPaths: record path ") || message.startsWith("offline sync snapshot path is excluded:")) {
-        throw new EngramAccessInputError(message);
-      }
-      throw error;
+    if (results.length > 0) return results;
+    for (const memoryId of snapshot.memoryIds) {
+      const memory = await storage.getMemoryById(memoryId);
+      if (!memory || seen.has(memory.path)) continue;
+      seen.add(memory.path);
+      results.push(
+        this.deps.serializeMemorySummary(
+          memory,
+          storageDir,
+          disclosure,
+          results.length === 0 ? rawExcerpts : void 0
+        )
+      );
     }
+    return results;
   }
-  async offlineSyncFileContent(options) {
-    const resolvedNamespace = this.resolveReadableNamespace(options.namespace, options.principal);
-    const storage = await this.orchestrator.getStorage(resolvedNamespace);
+  /**
+   * Fetch raw transcript excerpts from the LCM archive for `disclosure ===
+   * "raw"` recalls (issue #677 PR 2/4).  Returns `null` for non-raw recall
+   * depths, an empty array when LCM is disabled / not initialized / has no
+   * matches, and an array of LCM-side excerpts otherwise.  Errors are
+   * swallowed and treated as "no excerpts" so a failing LCM never breaks
+   * the recall response.
+   *
+   * Namespace handling: LCM archival prefixes non-default-namespace
+   * sessions with `${namespace}:${sessionKey}` (see `observe()` around
+   * line 2498), so the lookup must mirror that prefix or raw recalls in
+   * non-default namespaces miss their own excerpts.
+   */
+  async fetchRawExcerpts(disclosure, context) {
+    if (disclosure !== "raw") return null;
+    if (!context || !context.query) return [];
+    if (!context.sessionKey) return [];
+    const lcm = this.deps.orchestrator.lcmEngine;
+    if (!lcm || !lcm.enabled) return [];
     try {
-      const chunk = await readOfflineSyncFileContentChunk({
-        root: storage.dir,
-        path: options.path,
-        offset: options.offset,
-        length: options.length,
-        includeTranscripts: options.includeTranscripts !== false,
-        readFile: async ({ filePath }) => storage.readOfflineSyncFile(filePath),
-        userExcludeRegexps: this.offlineSyncUserExcludes
-      });
-      return {
-        namespace: resolvedNamespace,
-        ...chunk
-      };
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      if (message.startsWith("path:") || message.startsWith("offset ") || message.startsWith("offset must ") || message.startsWith("length ") || message.startsWith("offline sync file content ")) {
-        throw new EngramAccessInputError(message);
+      const legacyKey = context.namespace && context.namespace !== this.deps.orchestrator.config.defaultNamespace ? `${context.namespace}:${context.sessionKey}` : context.sessionKey;
+      const lcmSessionIds = context.lcmSessionIds !== void 0 ? context.lcmSessionIds : [legacyKey];
+      const limit = 5;
+      const seenRows = /* @__PURE__ */ new Set();
+      const excerpts = [];
+      const settledRows = await Promise.allSettled(
+        lcmSessionIds.map(
+          async (lcmSessionKey) => lcm.searchContextFull(context.query, limit, lcmSessionKey)
+        )
+      );
+      for (const result of settledRows) {
+        if (excerpts.length >= limit) break;
+        if (result.status !== "fulfilled") continue;
+        for (const r of result.value) {
+          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;
+        }
       }
-      throw error;
+      return excerpts;
+    } catch {
+      return [];
     }
   }
-  async offlineSyncApplyFileContent(options) {
-    const resolvedNamespace = this.writableNamespaceFor(
-      options.namespace,
-      void 0,
-      options.principal
-    );
-    const storage = await this.orchestrator.getStorage(resolvedNamespace);
-    try {
-      const result = await applyOfflineSyncFileContentChunk({
-        root: storage.dir,
-        sourceId: options.sourceId,
-        path: options.path,
-        sha256: options.sha256,
-        bytes: options.bytes,
-        mtimeMs: options.mtimeMs,
-        offset: options.offset,
-        baseSha256: options.baseSha256,
-        content: options.content,
-        includeTranscripts: options.includeTranscripts !== false,
-        readFile: async ({ filePath }) => storage.readOfflineSyncFile(filePath),
-        readFileDigest: async ({ filePath }) => storage.digestOfflineSyncFile(filePath),
-        writeFile: async ({ filePath, content }) => storage.writeOfflineSyncFile(filePath, content),
-        writeStagingFile: async ({ filePath, content }) => storage.writeOfflineSyncStagingFile(filePath, content),
-        writeFileChunks: async ({ filePath, chunks }) => storage.writeOfflineSyncFileChunks(filePath, chunks)
-      });
-      return {
-        namespace: resolvedNamespace,
-        ...result
-      };
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      if (message.startsWith("offline sync") || message.startsWith("path:") || message.startsWith("sourceId must ") || message.startsWith("sha256 must ") || message.startsWith("baseSha256 must ") || message.startsWith("bytes must ") || message.startsWith("mtimeMs must ") || message.startsWith("offset must ") || message.startsWith("content chunk ") || message === "content must be a Buffer") {
-        throw new EngramAccessInputError(message);
+  async executeRecall(request) {
+    const query = request.query;
+    const callerProvidedDisclosure = request.disclosure !== void 0 && request.disclosure !== null;
+    const requestedDisclosure = (() => {
+      if (!callerProvidedDisclosure) {
+        return DEFAULT_RECALL_DISCLOSURE;
       }
-      throw error;
+      if (!isRecallDisclosure(request.disclosure)) {
+        throw new EngramAccessInputError(
+          `disclosure must be one of: chunk, section, raw (got: ${String(request.disclosure)})`
+        );
+      }
+      return request.disclosure;
+    })();
+    if (request.codingContext !== void 0 && request.sessionKey) {
+      this.deps.setCodingContext({
+        sessionKey: request.sessionKey,
+        codingContext: request.codingContext
+      });
     }
-  }
-  async offlineSyncApply(options) {
-    const resolvedNamespace = this.writableNamespaceFor(
-      options.namespace,
-      void 0,
-      options.principal
-    );
-    const storage = await this.orchestrator.getStorage(resolvedNamespace);
-    try {
-      const result = await applyOfflineSyncChangeset({
-        root: storage.dir,
-        changeset: options.changeset,
-        returnCurrentFiles: options.returnCurrentFiles,
-        readFile: async ({ filePath }) => storage.readOfflineSyncFile(filePath),
-        readFileDigest: async ({ filePath }) => storage.digestOfflineSyncFile(filePath),
-        writeFile: async ({ filePath, content }) => storage.writeOfflineSyncFile(filePath, content),
-        deleteFile: async ({ filePath }) => storage.deleteOfflineSyncFile(filePath)
+    if (request.codingContext === void 0 && request.sessionKey) {
+      await this.deps.maybeAttachCodingContext(request.sessionKey, {
+        cwd: request.cwd,
+        projectTag: request.projectTag
       });
-      return {
-        namespace: resolvedNamespace,
-        ...result
+    }
+    const authenticatedPrincipal = request.authenticatedPrincipal?.trim();
+    const namespaceOverride = this.deps.resolveRecallNamespace(
+      request.namespace,
+      request.sessionKey,
+      authenticatedPrincipal
+    );
+    const namespace = namespaceOverride ?? this.deps.orchestrator.config.defaultNamespace;
+    const mode = this.deps.normalizeRecallMode(request.mode);
+    const maybePrincipal = this.deps.resolveRequestPrincipal(request.sessionKey, authenticatedPrincipal);
+    if (resolveNamespaceCapabilities(this.deps.orchestrator.config).namespaces && !maybePrincipal) {
+      throw new EngramAccessInputError(
+        "authentication required: namespaces are enabled and no principal was supplied"
+      );
+    }
+    const principal = maybePrincipal ?? "default";
+    const principalNamespace = defaultNamespaceForPrincipal(principal, this.deps.orchestrator.config);
+    const profileCodingContext = request.sessionKey && typeof this.deps.orchestrator.getCodingContextForSession === "function" ? this.deps.orchestrator.getCodingContextForSession(request.sessionKey) : null;
+    const profileCodingOverlay = !namespaceOverride && profileCodingContext && resolveNamespaceCapabilities(this.deps.orchestrator.config).namespaces && this.deps.orchestrator.config.codingMode?.projectScope ? resolveCodingNamespaceOverlay(
+      profileCodingContext,
+      this.deps.orchestrator.config.codingMode,
+      this.deps.orchestrator.config.defaultNamespace
+    ) : null;
+    const profilePlan = namespaceOverride ? null : resolveScopeProfilePlan({
+      config: this.deps.orchestrator.config,
+      principal,
+      codingContext: profileCodingContext,
+      codingOverlay: profileCodingOverlay
+    });
+    const modeSkipsBudget = mode === "no_recall";
+    const legacyRecallNamespaces = Array.isArray(this.deps.orchestrator.config.defaultRecallNamespaces) ? recallNamespacesForPrincipal(principal, this.deps.orchestrator.config) : [];
+    const effectiveNamespaces = namespaceOverride ? [namespaceOverride] : profilePlan ? expandScopeProfileReadNamespaces({
+      profilePlan,
+      principalSelfNamespace: profilePlan.baseNamespace,
+      config: this.deps.orchestrator.config,
+      principal,
+      codingOverlay: profileCodingOverlay,
+      legacyRecallNamespaces
+    }) : legacyRecallNamespaces;
+    const budgetPrincipalNamespace = profilePlan?.baseNamespace ?? principalNamespace;
+    let budgetDecision;
+    let recordBudgetAfterSuccess = false;
+    if (modeSkipsBudget) {
+      budgetDecision = {
+        allowed: true,
+        reason: "allowed-same-namespace",
+        count: 0,
+        limit: {
+          softLimit: this.deps.orchestrator.config.recallCrossNamespaceBudgetSoftLimit ?? 10,
+          hardLimit: this.deps.orchestrator.config.recallCrossNamespaceBudgetHardLimit ?? 30,
+          windowMs: this.deps.orchestrator.config.recallCrossNamespaceBudgetWindowMs ?? 6e4
+        }
       };
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      if (message.startsWith("offline sync")) {
-        throw new EngramAccessInputError(message);
+    } else {
+      let anyCrossNamespace = false;
+      let denied = null;
+      let crossNamespaceDecision = null;
+      for (const ns of effectiveNamespaces) {
+        const peek = this.deps.budget.peek({
+          principal,
+          principalNamespace: budgetPrincipalNamespace,
+          queryNamespace: ns
+        });
+        if (peek.reason !== "allowed-same-namespace") {
+          anyCrossNamespace = true;
+          crossNamespaceDecision ??= peek;
+        }
+        if (!peek.allowed) {
+          denied = peek;
+          break;
+        }
       }
-      throw error;
+      if (denied) {
+        budgetDecision = denied;
+      } else if (anyCrossNamespace) {
+        budgetDecision = crossNamespaceDecision ?? {
+          allowed: true,
+          reason: "allowed-under-soft",
+          count: 0,
+          limit: {
+            softLimit: this.deps.orchestrator.config.recallCrossNamespaceBudgetSoftLimit ?? 10,
+            hardLimit: this.deps.orchestrator.config.recallCrossNamespaceBudgetHardLimit ?? 30,
+            windowMs: this.deps.orchestrator.config.recallCrossNamespaceBudgetWindowMs ?? 6e4
+          }
+        };
+        recordBudgetAfterSuccess = true;
+      } else {
+        budgetDecision = {
+          allowed: true,
+          reason: "allowed-same-namespace",
+          count: 0,
+          limit: {
+            softLimit: this.deps.orchestrator.config.recallCrossNamespaceBudgetSoftLimit ?? 10,
+            hardLimit: this.deps.orchestrator.config.recallCrossNamespaceBudgetHardLimit ?? 30,
+            windowMs: this.deps.orchestrator.config.recallCrossNamespaceBudgetWindowMs ?? 6e4
+          }
+        };
+      }
+      if (!budgetDecision.allowed) {
+        throw new EngramAccessInputError(
+          `recall denied: cross-namespace budget exceeded (${budgetDecision.count}/${budgetDecision.limit.hardLimit} in ${budgetDecision.limit.windowMs}ms window)`
+        );
+      }
+      this.deps.budget.gc();
     }
-  }
-  // ── Dreams pipeline telemetry surfaces (issue #678 PR 3+4) ──────────────
-  /**
-   * Return per-phase Dreams telemetry for the last N hours (default 24).
-   */
-  async dreamsStatus(options) {
-    const { getDreamsStatus, normalizeDreamsStatusWindowHours } = await import("./dreams-ledger-6UODQOX6.js");
-    let windowHours;
-    try {
-      windowHours = normalizeDreamsStatusWindowHours(options?.windowHours);
-    } catch (error) {
-      throw new EngramAccessInputError(error instanceof Error ? error.message : String(error));
+    const topK = Number.isFinite(request.topK) ? Math.max(0, Math.floor(request.topK ?? 0)) : void 0;
+    let asOf;
+    if (request.asOf !== void 0 && request.asOf !== null) {
+      if (typeof request.asOf !== "string" || request.asOf.trim().length === 0) {
+        throw new EngramAccessInputError(
+          "asOf must be a non-empty ISO 8601 timestamp string"
+        );
+      }
+      const parsed = Date.parse(request.asOf);
+      if (!Number.isFinite(parsed)) {
+        throw new EngramAccessInputError(
+          `asOf must be a parseable ISO 8601 timestamp (got: "${request.asOf}")`
+        );
+      }
+      asOf = request.asOf;
     }
-    const resolvedNamespace = this.resolveReadableNamespace(options?.namespace, options?.principal);
-    const storage = await this.orchestrator.getStorage(resolvedNamespace);
-    return getDreamsStatus(storage.dir, windowHours);
-  }
-  /**
-   * Manually invoke a single Dreams phase pass (PR 4/4).
-   *
-   * Deep-sleep delegates to memory governance (shadow → dry-run, apply → live).
-   * Light-sleep and REM scan the observation ledger and memory corpus
-   * respectively, returning the same telemetry shape as a scheduled run.
-   */
-  async dreamsRun(options) {
-    const { runDreamsPhase } = await import("./dreams-ledger-6UODQOX6.js");
-    const validPhases = ["lightSleep", "rem", "deepSleep"];
-    if (!validPhases.includes(options.phase)) {
+    const recallOptions = {
+      namespace: namespaceOverride,
+      topK,
+      mode,
+      ...authenticatedPrincipal ? { principalOverride: authenticatedPrincipal } : {},
+      ...asOf !== void 0 ? { asOf } : {},
+      ...request.includeLowConfidence === true ? { includeLowConfidence: true } : {}
+    };
+    const startedAt = Date.now();
+    const context = await this.deps.orchestrator.recall(query, request.sessionKey, recallOptions);
+    const snapshot = request.sessionKey ? this.deps.orchestrator.lastRecall.get(request.sessionKey) : null;
+    const effectiveNamespace = snapshot?.namespace ? this.deps.resolveNamespace(snapshot.namespace) : namespace;
+    const resultsReturned = snapshot?.memoryIds?.length ?? 0;
+    const appliedTopK = snapshot?.budgetsApplied?.appliedTopK;
+    const configMaxResults = typeof this.deps.orchestrator.config.qmdMaxResults === "number" && Number.isFinite(this.deps.orchestrator.config.qmdMaxResults) && this.deps.orchestrator.config.qmdMaxResults > 0 ? this.deps.orchestrator.config.qmdMaxResults : 0;
+    const topKDenominator = typeof appliedTopK === "number" && Number.isFinite(appliedTopK) && appliedTopK > 0 ? Math.max(appliedTopK, resultsReturned) : typeof topK === "number" && topK > 0 ? Math.max(topK, resultsReturned) : Math.max(configMaxResults, resultsReturned, 1);
+    const topKConfidence = snapshot && topKDenominator > 0 ? Math.min(1, resultsReturned / topKDenominator) : void 0;
+    const escalationDecision = decideDisclosureEscalation({
+      mode: this.deps.orchestrator.config.recallDisclosureEscalation,
+      threshold: this.deps.orchestrator.config.recallDisclosureEscalationThreshold,
+      originalDisclosure: requestedDisclosure,
+      callerProvidedDisclosure,
+      topKConfidence
+    });
+    const disclosure = escalationDecision.effective;
+    const trimmedSessionKey = request.sessionKey?.trim() || void 0;
+    const rawExcerptNamespace = disclosure === "raw" ? this.deps.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.deps.resolveLcmReadSessionIds(
+      request.namespace,
+      rawExcerptNamespace,
+      trimmedSessionKey,
+      authenticatedPrincipal
+    ) : void 0;
+    let results = await this.deps.serializeRecallResults(snapshot, disclosure, {
+      query,
+      sessionKey: trimmedSessionKey,
+      ...rawExcerptNamespace ? { rawExcerptNamespace } : {},
+      ...rawExcerptSessionIds !== void 0 ? { rawExcerptSessionIds } : {},
+      ...rawExcerptsSuppressed ? { rawExcerptsSuppressed } : {}
+    });
+    const filterTags = normalizeTags(request.tags);
+    let tagMatchMode;
+    try {
+      tagMatchMode = parseTagMatch(request.tagMatch);
+    } catch (err) {
       throw new EngramAccessInputError(
-        `Invalid phase: ${String(options.phase)}. Must be one of: ${validPhases.join(", ")}`
+        err instanceof Error ? err.message : String(err)
       );
     }
-    const deepSleep = this.orchestrator.config.dreamsPhases.deepSleep;
-    if (options.phase === "deepSleep" && deepSleep.enabled === false && deepSleep.enabledExplicitlySet === true) {
-      throw new EngramAccessInputError(
-        "memory governance is disabled by dreams.phases.deepSleep.enabled=false"
-      );
+    let effectiveContext = context;
+    if (filterTags && filterTags.length > 0) {
+      const beforeIds = results.map((r) => r.id);
+      const { results: admitted } = applyTagFilter(results, {
+        tags: filterTags,
+        tagMatch: tagMatchMode
+      });
+      results = admitted;
+      const admittedIds = new Set(results.map((r) => r.id));
+      const droppedAny = beforeIds.some((id) => !admittedIds.has(id));
+      if (droppedAny) {
+        effectiveContext = results.map((r) => {
+          const content = typeof r.content === "string" ? r.content ?? "" : "";
+          const preview = typeof r.preview === "string" ? r.preview ?? "" : "";
+          return content || preview;
+        }).filter((s) => s.length > 0).join("\n\n");
+      }
     }
-    const dryRun = options.dryRun === true;
-    const resolvedNamespace = this.writableNamespaceFor(
-      options.namespace,
-      void 0,
-      options.authenticatedPrincipal
+    const filteredMemoryIds = filterTags && filterTags.length > 0 ? results.map((r) => r.id) : snapshot?.memoryIds ?? [];
+    const debug = await this.deps.buildRecallDebug(
+      snapshot,
+      effectiveNamespace,
+      request.includeDebug === true,
+      request.sessionKey
     );
-    const storage = await this.orchestrator.getStorage(resolvedNamespace);
-    const memoryDir = storage.dir;
-    const phaseRunner = dryRun || options.phase === "deepSleep" ? void 0 : async (_opts) => {
-      if (_opts.phase === "lightSleep") {
-        const result3 = await this.orchestrator.runLifecyclePolicyNow(storage);
-        return {
-          itemsProcessed: result3.memoriesAssessed,
-          notes: `scored ${result3.memoriesAssessed} memories`
+    let auditAnomalies;
+    if (this.deps.auditAdapter) {
+      try {
+        const resolvedAgentId = principal ?? "__anonymous__";
+        const auditEntry = {
+          ts: (/* @__PURE__ */ new Date()).toISOString(),
+          sessionKey: request.sessionKey ?? "",
+          agentId: resolvedAgentId,
+          trigger: "access-surface",
+          queryText: query,
+          candidateMemoryIds: snapshot?.memoryIds ?? [],
+          // Audit must reflect what was actually injected, not what
+          // recall produced before the tag filter. Using `context`
+          // (pre-filter) overstates injectedChars and can leak content
+          // from excluded memories into the audit summary (cursor
+          // Medium on PR #712).
+          summary: effectiveContext.slice(0, 200) || null,
+          injectedChars: effectiveContext.length,
+          toggleState: "enabled",
+          latencyMs: Date.now() - startedAt,
+          plannerMode: snapshot?.plannerMode ?? mode,
+          requestedMode: mode,
+          fallbackUsed: snapshot?.fallbackUsed ?? false
         };
+        const auditResult = await this.deps.auditAdapter.record(
+          resolvedAgentId || "__anonymous__",
+          auditEntry
+        );
+        auditAnomalies = auditResult.anomalies;
+      } catch {
       }
-      const result2 = await this.orchestrator.runSemanticConsolidationNow({
-        dryRun: false,
-        storage
-      });
-      const itemsProcessed = result2.clusters.reduce(
-        (sum, cluster) => sum + cluster.memories.length,
-        0
-      );
-      return {
-        itemsProcessed,
-        notes: `REM consolidation found ${result2.clustersFound} clusters`
-      };
-    };
-    const governanceRunner = options.phase === "deepSleep" ? async (_opts) => {
-      return this.orchestrator.runDeepSleepGovernanceNow({
-        storage,
-        dryRun: _opts.dryRun
-      });
-    } : void 0;
-    const result = await runDreamsPhase(
-      { memoryDir, phase: options.phase, dryRun },
-      governanceRunner,
-      phaseRunner
-    );
+    }
     return {
-      phase: result.phase,
-      dryRun: result.dryRun,
-      durationMs: result.durationMs,
-      itemsProcessed: result.itemsProcessed,
-      notes: result.notes
-    };
-  }
-  // ---------------------------------------------------------------------------
-  // Wearables (Limitless / Bee / Omi transcript ingestion)
-  //
-  // Thin delegations to the orchestrator-owned WearablesService — the
-  // same instance behind the CLI, so HTTP/MCP callers observe identical
-  // behavior and validation (renderer-sharing rule).
-  // ---------------------------------------------------------------------------
-  async wearablesStatus() {
-    return this.orchestrator.getWearablesService().status();
-  }
-  async wearablesSync(request) {
-    return this.orchestrator.getWearablesService().sync({
-      source: request.source,
-      date: request.date,
-      days: request.days,
-      forceMemories: request.forceMemories
-    });
-  }
-  async wearablesTranscriptDay(request) {
-    return this.orchestrator.getWearablesService().dayTranscript(request.date, request.source);
-  }
-  async wearablesTranscriptSearch(request) {
-    return this.orchestrator.getWearablesService().searchTranscripts(request.query, {
-      source: request.source,
-      from: request.from,
-      to: request.to,
-      limit: request.limit
-    });
-  }
-  async wearablesTranscriptMemories(request) {
-    return this.orchestrator.getWearablesService().transcriptMemories({
-      source: request.source,
-      date: request.date,
-      limit: request.limit
-    });
-  }
-  // ── Admin console surfaces (issue #1502) ────────────────────────────────
-  //
-  // Thin delegators. Every method threads `this.orchestrator` references
-  // into the pure `admin/admin-surfaces.ts` functions so the dashboard
-  // never re-resolves scope, re-derives promotion targets, or re-lists
-  // namespaces.
-  /**
-   * Resolve an effective scope inspection for the console. Inputs are
-   * redacted before return so an operator-supplied principal preview /
-   * namespace override never echoes a pasted credential back.
-   */
-  async adminInspectScope(options) {
-    const config = this.orchestrator.config;
-    const codingContext = options.sessionKey ? this.orchestrator.getCodingContextForSession(options.sessionKey) ?? null : null;
-    const inspection = inspectScope({
-      config,
-      sessionKey: options.sessionKey,
-      namespace: options.namespace,
-      principalOverride: options.principalOverride,
-      codingContext,
-      operation: options.operation
-    });
-    return redactSensitive(inspection);
-  }
-  /**
-   * List configured + discovered namespaces from the catalog with the
-   * admin filters the console exposes.
-   */
-  async adminListNamespaces(filter) {
-    const result = await listAdminNamespaces({
-      catalog: this.orchestrator.namespaceCatalog,
-      filter
-    });
-    return redactSensitive(result);
-  }
-  /**
-   * Per-namespace maintenance + QMD health. QMD diagnostics are probed via
-   * the orchestrator's search health accessor (one probe per namespace).
-   */
-  async adminMaintenanceHealth() {
-    const report = await gatherMaintenanceHealth({
-      catalog: this.orchestrator.namespaceCatalog,
-      qmdHealthProvider: async (namespace) => {
-        try {
-          const health = await this.orchestrator.searchHealthForNamespace(namespace);
-          return {
-            namespace,
-            collection: health.collection,
-            available: health.available,
-            collectionState: health.collectionState,
-            debugStatus: health.debugStatus,
-            installedVersion: health.installedVersion,
-            supportedVersion: health.supportedVersion,
-            supported: health.supported,
-            upgradeAvailable: health.upgradeAvailable,
-            daemonMode: health.daemonMode
-          };
-        } catch (err) {
-          throw err;
-        }
-      }
-    });
-    return redactSensitive(report);
-  }
-  /**
-   * Dry-run transcript/session audit. Detects mixed `other/default` data
-   * and legacy stranded directories. Never applies a migration.
-   */
-  async adminTranscriptAudit() {
-    const result = await auditTranscripts(this.orchestrator.config.memoryDir);
-    return redactSensitive(result);
-  }
-  /**
-   * Manually promote a memory into one or more authorized targets. Requires
-   * a non-empty reason (audit-logged). Reuses the scope-profile promotion
-   * resolution and `canWriteNamespace` gate — there is no dashboard-only
-   * write path.
-   */
-  async adminPromoteMemory(request) {
-    const config = this.orchestrator.config;
-    const namespacesEnabled = resolveNamespaceCapabilities(config).namespaces === true;
-    let sourceNamespace;
-    if (request.namespace) {
-      sourceNamespace = this.resolveReadableNamespace(
-        request.namespace,
-        request.principal
-      );
-    } else {
-      const codingContext2 = request.sessionKey ? this.orchestrator.getCodingContextForSession(request.sessionKey) ?? null : null;
-      const plan = resolveScopePlan({
-        config,
+      response: {
+        query,
         sessionKey: request.sessionKey,
-        principalOverride: request.principal,
-        codingContext: codingContext2,
-        namespacesEnabled
-      });
-      sourceNamespace = this.resolveReadableNamespace(
-        plan.baseNamespace,
-        request.principal
+        namespace: effectiveNamespace,
+        context: effectiveContext,
+        count: filterTags && filterTags.length > 0 ? results.length : snapshot?.memoryIds.length ?? results.length,
+        memoryIds: filteredMemoryIds,
+        results,
+        recordedAt: snapshot?.recordedAt,
+        traceId: snapshot?.traceId,
+        plannerMode: snapshot?.plannerMode ?? mode,
+        fallbackUsed: snapshot?.fallbackUsed ?? false,
+        sourcesUsed: snapshot?.sourcesUsed ?? [],
+        disclosure,
+        budgetsApplied: snapshot?.budgetsApplied,
+        auditAnomalies,
+        budgetWarning: budgetDecision.reason === "warn-over-soft" ? budgetDecision : void 0,
+        latencyMs: snapshot?.latencyMs ?? Date.now() - startedAt,
+        debug
+      },
+      budgetRecordPrincipal: recordBudgetAfterSuccess ? principal : null
+    };
+  }
+  /**
+   * Recall X-ray (issue #570).  Runs a recall with `xrayCapture: true`
+   * and returns the resulting snapshot as structured JSON so every
+   * surface (CLI / HTTP / MCP) gets the same payload.  Namespace scope
+   * is enforced before the recall fires (CLAUDE.md rule 42 — read and
+   * write paths must resolve through the same namespace layer) so an
+   * unauthorized principal cannot capture an x-ray for a namespace it
+   * cannot read.
+   */
+  async recallXray(request) {
+    const query = typeof request.query === "string" ? request.query : "";
+    if (query.trim().length === 0) {
+      throw new Error("recallXray: query is required and must be non-empty");
+    }
+    if (request.disclosure !== void 0 && !isRecallDisclosure(request.disclosure)) {
+      throw new EngramAccessInputError(
+        `recallXray: disclosure must be one of: chunk, section, raw (got: ${String(request.disclosure)})`
       );
     }
-    const codingContext = request.sessionKey ? this.orchestrator.getCodingContextForSession(request.sessionKey) ?? null : null;
-    const codingOverlay = codingContext ? resolveCodingNamespaceOverlay(
-      codingContext,
-      config.codingMode,
-      config.defaultNamespace
-    ) : null;
-    const scopeProfilePlan = resolveScopeProfilePlan({
-      config,
-      principal: request.principal,
-      codingContext,
-      codingOverlay
-    });
-    const storage = {
-      readMemory: async (namespace, memoryId) => {
-        const resolved = await this.orchestrator.getStorage(namespace);
-        const memory = await resolved.getMemoryById(memoryId);
-        if (!memory) return null;
-        return {
-          category: memory.frontmatter.category,
-          content: memory.content,
-          frontmatter: memory.frontmatter
-        };
-      },
-      writePromotedMemory: async (namespace, memory) => {
-        const resolved = await this.orchestrator.getStorage(namespace);
-        const { id, tombstoneBlocked } = await resolved.writeMemory(
-          memory.category,
-          memory.content,
-          {
-            confidence: memory.confidence,
-            tags: memory.tags,
-            entityRef: memory.entityRef,
-            source: `admin-promotion:${memory.sourceNamespace}:${memory.reason.slice(0, 120)}`,
-            lineage: memory.lineage,
-            sourceMemoryId: memory.sourceMemoryId,
-            actor: memory.actor,
-            validAt: memory.validAt
-          }
+    const namespacesEnabled = resolveNamespaceCapabilities(this.deps.orchestrator.config).namespaces;
+    const requestedNamespace = request.namespace?.trim() ? this.deps.resolveNamespace(request.namespace) : void 0;
+    const authenticatedPrincipal = request.authenticatedPrincipal?.trim();
+    const principal = authenticatedPrincipal || resolvePrincipal(request.sessionKey, this.deps.orchestrator.config);
+    if (requestedNamespace) {
+      if (!canReadNamespace(
+        principal,
+        requestedNamespace,
+        this.deps.orchestrator.config
+      )) {
+        return { snapshotFound: false };
+      }
+    } else if (namespacesEnabled && !authenticatedPrincipal && !request.sessionKey?.trim()) {
+      return { snapshotFound: false };
+    }
+    let budgetOverride;
+    if (request.budget !== void 0 && request.budget !== null) {
+      const parsed = typeof request.budget === "number" ? request.budget : Number(request.budget);
+      if (!Number.isFinite(parsed) || parsed <= 0 || !Number.isInteger(parsed)) {
+        throw new Error(
+          `recallXray: budget expects a positive integer; got ${JSON.stringify(request.budget)}`
         );
-        if (tombstoneBlocked) {
-          throw new Error(
-            "target namespace tombstone-blocked the promoted content (pending_review)"
-          );
-        }
-        return id;
       }
+      budgetOverride = parsed;
+    }
+    const mode = this.deps.normalizeRecallMode(request.mode);
+    const disclosure = request.disclosure ?? DEFAULT_RECALL_DISCLOSURE;
+    const previousQueue = this.deps.xrayQueue;
+    let release = () => {
     };
+    this.deps.xrayQueue = new Promise((resolve3) => {
+      release = resolve3;
+    });
+    await previousQueue;
+    const recallStartedAt = Date.now();
+    const recallSessionKey = request.sessionKey?.trim() || void 0;
+    let xrayResponse = { snapshotFound: false };
     try {
-      return await promoteMemory({
-        config,
-        sourceMemoryId: request.sourceMemoryId,
-        sourceNamespace,
-        principal: request.principal,
-        targets: request.targets,
-        reason: request.reason,
-        actor: request.principal ?? "admin-console",
-        storage,
-        scopeProfilePlan
+      this.deps.orchestrator.clearLastXraySnapshot();
+      await this.deps.orchestrator.recall(query, recallSessionKey, {
+        xrayCapture: true,
+        ...requestedNamespace ? { namespace: requestedNamespace } : {},
+        ...budgetOverride !== void 0 ? { budgetCharsOverride: budgetOverride } : {},
+        ...mode !== void 0 ? { mode } : {},
+        // When the caller supplies an authenticated principal, forward
+        // it via the dedicated override channel so orchestrator-side
+        // ACL decisions use the SAME principal the access-surface
+        // pre-check above authorized.  Threading an
+        // `authenticatedPrincipal` through `sessionKey` would be wrong:
+        // `resolvePrincipal(sessionKey)` only maps configured raw
+        // session keys and otherwise collapses to `"default"`, which
+        // in namespace-enabled deployments produces false denials /
+        // wrong-scope serving despite the pre-check passing
+        // (CLAUDE.md rule 42).
+        ...authenticatedPrincipal ? { principalOverride: authenticatedPrincipal } : {},
+        ...request.currentContextScopes !== void 0 ? { currentContextScopes: request.currentContextScopes } : {}
       });
-    } catch (err) {
-      if (err instanceof AdminPromotionError) {
-        throw new EngramAccessInputError(err.message);
+      const rawSnapshot = this.deps.orchestrator.getLastXraySnapshot();
+      const namespaceMismatch = requestedNamespace !== void 0 && rawSnapshot?.namespace !== requestedNamespace;
+      if (!rawSnapshot) {
+        xrayResponse = { snapshotFound: false };
+      } else if (namespaceMismatch) {
+        xrayResponse = { snapshotFound: false };
+      } else {
+        let snapshot = rawSnapshot;
+        const xrayFilterTags = normalizeTags(request.tags);
+        let xrayTagMatch;
+        try {
+          xrayTagMatch = parseTagMatch(request.tagMatch);
+        } catch (err) {
+          throw new EngramAccessInputError(
+            err instanceof Error ? err.message : String(err)
+          );
+        }
+        if (xrayFilterTags && xrayFilterTags.length > 0) {
+          const namespace = snapshot.namespace ? this.deps.resolveNamespace(snapshot.namespace) : this.deps.orchestrator.config.defaultNamespace;
+          const tagsByIndex = await Promise.all(
+            snapshot.results.map(async (result) => {
+              try {
+                const storage = await this.deps.orchestrator.getStorage(namespace);
+                const memory = await storage.readMemoryByPath(result.path);
+                const t = memory?.frontmatter?.tags;
+                return Array.isArray(t) ? normalizeProjectionTags(t) : [];
+              } catch {
+                return [];
+              }
+            })
+          );
+          const tagged = snapshot.results.map((result, index) => ({
+            result,
+            tags: tagsByIndex[index] ?? []
+          }));
+          const { results: admittedTagged, trace } = applyTagFilter(tagged, {
+            tags: xrayFilterTags,
+            tagMatch: xrayTagMatch
+          });
+          const admittedResults = admittedTagged.map((entry) => entry.result);
+          const filters = trace ? [...snapshot.filters, trace] : snapshot.filters;
+          snapshot = { ...snapshot, results: admittedResults, filters };
+        }
+        if (request.disclosure !== void 0) {
+          const disclosure2 = request.disclosure;
+          const namespace = snapshot.namespace ? this.deps.resolveNamespace(snapshot.namespace) : this.deps.orchestrator.config.defaultNamespace;
+          const trimmedSessionKey = request.sessionKey?.trim() || void 0;
+          const rawExcerptNamespace = disclosure2 === "raw" ? this.deps.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.deps.resolveLcmReadSessionIds(
+            request.namespace,
+            rawExcerptNamespace,
+            trimmedSessionKey,
+            authenticatedPrincipal
+          ) : void 0;
+          const rawExcerpts = disclosure2 === "raw" && !rawExcerptsSuppressed ? await this.deps.fetchRawExcerpts(disclosure2, {
+            query,
+            ...trimmedSessionKey ? { sessionKey: trimmedSessionKey } : {},
+            ...rawExcerptNamespace ? { namespace: rawExcerptNamespace } : {},
+            ...rawExcerptSessionIds !== void 0 ? { 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) => {
+              try {
+                const storage = await this.deps.orchestrator.getStorage(namespace);
+                return await storage.readMemoryByPath(result.path);
+              } catch {
+                return null;
+              }
+            })
+          );
+          const firstReadableIndex = memoryByIndex.findIndex((m) => m !== null);
+          const baseDir = (await this.deps.orchestrator.getStorage(namespace)).dir;
+          const decorated = snapshot.results.map((result, index) => {
+            const memory = memoryByIndex[index];
+            if (!memory) {
+              return { ...result, disclosure: disclosure2 };
+            }
+            const shaped = shapeMemorySummary(
+              memory,
+              baseDir,
+              disclosure2,
+              disclosure2 === "raw" && index === firstReadableIndex && rawExcerpts && rawExcerpts.length > 0 ? rawExcerpts : void 0
+            );
+            return {
+              ...result,
+              disclosure: disclosure2,
+              estimatedTokens: estimateRecallTokens(JSON.stringify(shaped))
+            };
+          });
+          if (disclosure2 === "raw" && firstReadableIndex === -1 && rawExcerptText.length > 0 && decorated.length > 0) {
+            decorated[0] = {
+              ...decorated[0],
+              disclosure: disclosure2,
+              estimatedTokens: estimateRecallTokens(rawExcerptText)
+            };
+          }
+          const decoratedSnapshot = { ...snapshot, results: decorated };
+          xrayResponse = {
+            snapshotFound: true,
+            snapshot: decoratedSnapshot
+          };
+        } else {
+          xrayResponse = {
+            snapshotFound: true,
+            snapshot
+          };
+        }
       }
-      throw err;
+    } finally {
+      release();
+    }
+    if (request.includeRecall === true && xrayResponse.snapshotFound === true && xrayResponse.snapshot) {
+      const xrayRawExcerptNamespace = disclosure === "raw" ? this.deps.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.deps.resolveLcmReadSessionIds(
+        request.namespace,
+        xrayRawExcerptNamespace,
+        recallSessionKey,
+        authenticatedPrincipal
+      ) : void 0;
+      return {
+        ...xrayResponse,
+        recall: await this.deps.buildRecallResponseFromXraySnapshot({
+          query,
+          sessionKey: recallSessionKey,
+          snapshot: xrayResponse.snapshot,
+          disclosure,
+          startedAt: recallStartedAt,
+          requestedMode: request.mode,
+          normalizedMode: mode,
+          ...xrayRawExcerptNamespace ? { rawExcerptNamespace: xrayRawExcerptNamespace } : {},
+          ...xrayRawExcerptSessionIds !== void 0 ? { rawExcerptSessionIds: xrayRawExcerptSessionIds } : {},
+          ...xrayRawExcerptsSuppressed ? { rawExcerptsSuppressed: xrayRawExcerptsSuppressed } : {}
+        })
+      };
     }
+    return xrayResponse;
   }
 };
 
@@ -10373,9 +10659,13 @@ export {
   clusterByKey,
   computeProcedureStats,
   formatProcedureStatsText,
+  qmdCollectionPathParts,
+  QmdResultResolver,
+  AccessRecallSurface,
+  selfDeps,
   EngramAccessInputError,
   ENGRAM_ACCESS_WRITE_SCHEMA_VERSION,
   shapeMemorySummary,
   EngramAccessService
 };
-//# sourceMappingURL=chunk-UETBEHBA.js.map
+//# sourceMappingURL=chunk-VX2RYM2K.js.map