@remnic/core 1.1.10 → 1.1.12

package/dist/{chunk-WGK4VHGP.js → chunk-MNU6ZBWT.js}

@@ -1,25 +1,17 @@
 import {
   importCapsule
-} from "./chunk-QIGOEM65.js";
+} from "./chunk-IB3BFHGN.js";
 import {
   applyTagFilter,
   normalizeTags,
   parseTagMatch
 } from "./chunk-BT7NVCML.js";
-import {
-  toRecallExplainJson
-} from "./chunk-O4XJUPSF.js";
 import {
   decideDisclosureEscalation
 } from "./chunk-H7XKCNR6.js";
 import {
-  buildProposedActions,
-  buildQualityScore,
-  groupActionsByStatus,
-  listMemoryGovernanceRuns,
-  readMemoryGovernanceRunArtifact,
-  runMemoryGovernance
-} from "./chunk-EYNQTST2.js";
+  toRecallExplainJson
+} from "./chunk-E2UCDP5S.js";
 import {
   clusterByKey,
   resolveGitContext
@@ -32,19 +24,27 @@ import {
   scoreTrustZoneProvenance,
   seedTrustZoneDemoDataset,
   summarizeTrustZonePromotionReadiness
-} from "./chunk-EQINRHYR.js";
+} from "./chunk-QDZ2RLEC.js";
 import {
   estimateRecallTokens
-} from "./chunk-2YMTO4ZJ.js";
-import {
-  recordMemoryOutcome
-} from "./chunk-EIR5VLIH.js";
+} from "./chunk-JKDVIE52.js";
 import {
   recordObjectiveStateSnapshotsFromObservedMessages
-} from "./chunk-HJYHRE4S.js";
+} from "./chunk-242S3I2A.js";
 import {
   objectiveStateStoreOverrideForNamespace
 } from "./chunk-5UM2VJ6D.js";
+import {
+  buildProposedActions,
+  buildQualityScore,
+  groupActionsByStatus,
+  listMemoryGovernanceRuns,
+  readMemoryGovernanceRunArtifact,
+  runMemoryGovernance
+} from "./chunk-4YM32CRU.js";
+import {
+  recordMemoryOutcome
+} from "./chunk-EIR5VLIH.js";
 import {
   buildGraphSnapshot
 } from "./chunk-PCUKNJAZ.js";
@@ -54,15 +54,15 @@ import {
 import {
   formatProfileTraceAscii
 } from "./chunk-NBNN5GOB.js";
+import {
+  buildProcedurePersistBody,
+  normalizeProcedureSteps
+} from "./chunk-QDW3E4RD.js";
 import {
   persistExplicitCapture,
   queueExplicitCaptureForReview,
   validateExplicitCaptureInput
 } from "./chunk-GVPWB7EY.js";
-import {
-  buildProcedurePersistBody,
-  normalizeProcedureSteps
-} from "./chunk-QDW3E4RD.js";
 import {
   CrossNamespaceBudget
 } from "./chunk-GDFS42HT.js";
@@ -70,33 +70,19 @@ import {
   filterTrajectoriesByLookbackDays,
   readCausalTrajectoryRecords
 } from "./chunk-G2WADRQ3.js";
-import {
-  defaultCapsulesDir
-} from "./chunk-74EMIVE4.js";
-import {
-  canReadNamespace,
-  canWriteNamespace,
-  defaultNamespaceForPrincipal,
-  recallNamespacesForPrincipal,
-  resolvePrincipal
-} from "./chunk-N5AKDXAI.js";
 import {
   FileCalendarSource,
   buildBriefing,
   parseBriefingFocus,
   parseBriefingWindow
-} from "./chunk-WTFWLUSX.js";
+} from "./chunk-ZVTKDVVM.js";
 import {
   parseEntityFile
-} from "./chunk-MCC6KDQF.js";
+} from "./chunk-3B6KIRBH.js";
 import {
   DEFAULT_RECALL_DISCLOSURE,
   isRecallDisclosure
-} from "./chunk-VQXK37XA.js";
-import {
-  inferMemoryStatus,
-  toMemoryPathRel
-} from "./chunk-RULE4VG5.js";
+} from "./chunk-23ZZK64Y.js";
 import {
   normalizeProjectionPreview,
   normalizeProjectionTags
@@ -104,6 +90,20 @@ import {
 import {
   getMemoryProjectionPath
 } from "./chunk-XJKFSSDW.js";
+import {
+  inferMemoryStatus,
+  toMemoryPathRel
+} from "./chunk-RULE4VG5.js";
+import {
+  defaultCapsulesDir
+} from "./chunk-74EMIVE4.js";
+import {
+  canReadNamespace,
+  canWriteNamespace,
+  defaultNamespaceForPrincipal,
+  recallNamespacesForPrincipal,
+  resolvePrincipal
+} from "./chunk-N5AKDXAI.js";
 import {
   log
 } from "./chunk-2ODBA7MQ.js";
@@ -116,7 +116,10 @@ import {
 } from "./chunk-XKECPATV.js";
 import {
   exportCapsule
-} from "./chunk-P73JTV34.js";
+} from "./chunk-BBE34QBJ.js";
+import {
+  evaluateActionConfidence
+} from "./chunk-AH2JUU6X.js";
 
 // src/access-service.ts
 import { stat } from "fs/promises";
@@ -1143,24 +1146,24 @@ var EngramAccessService = class {
     }
     throw new EngramAccessInputError(`unsupported recall mode: ${mode}`);
   }
-  resolveRecallNamespace(namespace, sessionKey) {
+  resolveRecallNamespace(namespace, sessionKey, authenticatedPrincipal) {
     const requested = namespace?.trim();
     if (!requested) return void 0;
     const resolved = this.resolveNamespace(requested);
-    const principal = resolvePrincipal(sessionKey, this.orchestrator.config);
+    const principal = this.resolveRequestPrincipal(sessionKey, authenticatedPrincipal);
     if (!canReadNamespace(principal, resolved, this.orchestrator.config)) {
       throw new EngramAccessInputError(`namespace override is not readable: ${resolved}`);
     }
     return resolved;
   }
-  resolveWritePrincipal(sessionKey, authenticatedPrincipal) {
+  resolveRequestPrincipal(sessionKey, authenticatedPrincipal) {
     const trusted = authenticatedPrincipal?.trim();
     if (trusted) return trusted;
     return resolvePrincipal(sessionKey, this.orchestrator.config);
   }
   resolveWritableNamespace(namespace, sessionKey, authenticatedPrincipal) {
     const resolved = this.resolveNamespace(namespace);
-    const principal = this.resolveWritePrincipal(sessionKey, authenticatedPrincipal);
+    const principal = this.resolveRequestPrincipal(sessionKey, authenticatedPrincipal);
     if (!canWriteNamespace(principal, resolved, this.orchestrator.config)) {
       throw new EngramAccessInputError(`namespace is not writable: ${resolved}`);
     }
@@ -1213,6 +1216,63 @@ var EngramAccessService = class {
       graph
     } : 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: createHash("sha256").update(options.query).digest("hex"),
+      queryLen: options.query.length,
+      memoryIds,
+      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 } : {}
+      }
+    );
+    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;
@@ -1389,6 +1449,9 @@ var EngramAccessService = class {
       projectionAvailable
     };
   }
+  async actionConfidence(request = {}) {
+    return evaluateActionConfidence(request);
+  }
   async daySummary(request) {
     if (!this.orchestrator.config.daySummaryEnabled) {
       throw new EngramAccessInputError("day summary is disabled");
@@ -1572,10 +1635,15 @@ var EngramAccessService = class {
         projectTag: request.projectTag
       });
     }
-    const namespaceOverride = this.resolveRecallNamespace(request.namespace, request.sessionKey);
+    const authenticatedPrincipal = request.authenticatedPrincipal?.trim();
+    const namespaceOverride = this.resolveRecallNamespace(
+      request.namespace,
+      request.sessionKey,
+      authenticatedPrincipal
+    );
     const namespace = namespaceOverride ?? this.orchestrator.config.defaultNamespace;
     const mode = this.normalizeRecallMode(request.mode);
-    const principal = resolvePrincipal(request.sessionKey, this.orchestrator.config);
+    const principal = this.resolveRequestPrincipal(request.sessionKey, authenticatedPrincipal);
     const principalNamespace = defaultNamespaceForPrincipal(principal, this.orchestrator.config);
     const modeSkipsBudget = mode === "no_recall";
     const effectiveNamespaces = namespaceOverride ? [namespaceOverride] : recallNamespacesForPrincipal(principal, this.orchestrator.config);
@@ -1651,6 +1719,7 @@ var EngramAccessService = class {
       namespace: namespaceOverride,
       topK,
       mode,
+      ...authenticatedPrincipal ? { principalOverride: authenticatedPrincipal } : {},
       ...asOf !== void 0 ? { asOf } : {},
       ...request.includeLowConfidence === true ? { includeLowConfidence: true } : {}
     };
@@ -1712,10 +1781,7 @@ var EngramAccessService = class {
     let auditAnomalies;
     if (this.auditAdapter) {
       try {
-        const resolvedAgentId = resolvePrincipal(
-          request.sessionKey,
-          this.orchestrator.config
-        );
+        const resolvedAgentId = principal;
         const auditEntry = {
           ts: (/* @__PURE__ */ new Date()).toISOString(),
           sessionKey: request.sessionKey ?? "",
@@ -1859,6 +1925,8 @@ var EngramAccessService = class {
       }
       budgetOverride = parsed;
     }
+    const mode = this.normalizeRecallMode(request.mode);
+    const disclosure = request.disclosure ?? DEFAULT_RECALL_DISCLOSURE;
     const previousQueue = this.xrayQueue;
     let release = () => {
     };
@@ -1866,12 +1934,16 @@ var EngramAccessService = class {
       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, request.sessionKey?.trim() || void 0, {
+      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
@@ -1882,104 +1954,128 @@ var EngramAccessService = class {
         // in namespace-enabled deployments produces false denials /
         // wrong-scope serving despite the pre-check passing
         // (CLAUDE.md rule 42).
-        ...authenticatedPrincipal ? { principalOverride: authenticatedPrincipal } : {}
+        ...authenticatedPrincipal ? { principalOverride: authenticatedPrincipal } : {},
+        ...request.currentContextScopes !== void 0 ? { currentContextScopes: request.currentContextScopes } : {}
       });
       const rawSnapshot = this.orchestrator.getLastXraySnapshot();
-      if (!rawSnapshot) return { snapshotFound: false };
-      if (requestedNamespace && rawSnapshot.namespace !== requestedNamespace) {
-        return { snapshotFound: false };
-      }
-      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 disclosure = request.disclosure;
-        const namespace = snapshot.namespace ? this.resolveNamespace(snapshot.namespace) : this.orchestrator.config.defaultNamespace;
-        const trimmedSessionKey = request.sessionKey?.trim() || void 0;
-        const rawExcerpts = disclosure === "raw" ? await this.fetchRawExcerpts(disclosure, {
-          query,
-          ...trimmedSessionKey ? { sessionKey: trimmedSessionKey } : {},
-          namespace
-        }) : 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 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 rawExcerpts = disclosure2 === "raw" ? await this.fetchRawExcerpts(disclosure2, {
+            query,
+            ...trimmedSessionKey ? { sessionKey: trimmedSessionKey } : {},
+            namespace
+          }) : 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 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 };
+            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 shaped = shapeMemorySummary(
-            memory,
-            baseDir,
-            disclosure,
-            disclosure === "raw" && index === firstReadableIndex && rawExcerpts && rawExcerpts.length > 0 ? rawExcerpts : void 0
-          );
-          return {
-            ...result,
-            disclosure,
-            estimatedTokens: estimateRecallTokens(JSON.stringify(shaped))
+          const decoratedSnapshot = { ...snapshot, results: decorated };
+          xrayResponse = {
+            snapshotFound: true,
+            snapshot: decoratedSnapshot
           };
-        });
-        if (disclosure === "raw" && firstReadableIndex === -1 && rawExcerptText.length > 0 && decorated.length > 0) {
-          decorated[0] = {
-            ...decorated[0],
-            disclosure,
-            estimatedTokens: estimateRecallTokens(rawExcerptText)
+        } else {
+          xrayResponse = {
+            snapshotFound: true,
+            snapshot
           };
         }
-        return {
-          snapshotFound: true,
-          snapshot: { ...snapshot, results: decorated }
-        };
       }
-      return { snapshotFound: true, snapshot };
     } finally {
       release();
     }
+    if (request.includeRecall === true && xrayResponse.snapshotFound === true && xrayResponse.snapshot) {
+      return {
+        ...xrayResponse,
+        recall: await this.buildRecallResponseFromXraySnapshot({
+          query,
+          sessionKey: recallSessionKey,
+          snapshot: xrayResponse.snapshot,
+          disclosure,
+          startedAt: recallStartedAt,
+          requestedMode: request.mode,
+          normalizedMode: mode
+        })
+      };
+    }
+    return xrayResponse;
   }
   // Sequence lock for `recallXray` — see comment inside the method.
   // Lives on the instance so every x-ray call on the same service
@@ -2914,7 +3010,7 @@ var EngramAccessService = class {
       }
     }
     const hasExplicitNamespace = typeof request.namespace === "string" && request.namespace.trim().length > 0;
-    const principal = this.resolveWritePrincipal(
+    const principal = this.resolveRequestPrincipal(
       request.sessionKey,
       request.authenticatedPrincipal
     );
@@ -3009,7 +3105,7 @@ var EngramAccessService = class {
     if (!request.query || typeof request.query !== "string" || request.query.trim().length === 0) {
       throw new EngramAccessInputError("query is required and must be a non-empty string");
     }
-    const principal = this.resolveWritePrincipal(request.sessionKey, request.authenticatedPrincipal);
+    const principal = this.resolveRequestPrincipal(request.sessionKey, request.authenticatedPrincipal);
     const namespace = this.resolveReadableNamespace(request.namespace, principal);
     if (!this.orchestrator.lcmEngine || !this.orchestrator.lcmEngine.enabled) {
       return {
@@ -3040,6 +3136,72 @@ var EngramAccessService = class {
       lcmEnabled: true
     };
   }
+  async lcmCompactionFlush(request) {
+    if (!request.sessionKey || typeof request.sessionKey !== "string" || request.sessionKey.trim().length === 0) {
+      throw new EngramAccessInputError("sessionKey is required and must be a non-empty string");
+    }
+    const namespace = this.resolveWritableNamespace(
+      request.namespace,
+      request.sessionKey,
+      request.authenticatedPrincipal
+    );
+    if (!this.orchestrator.lcmEngine || !this.orchestrator.lcmEngine.enabled) {
+      return {
+        enabled: false,
+        flushed: false,
+        sessionKey: request.sessionKey,
+        namespace,
+        reason: "LCM is disabled"
+      };
+    }
+    const lcmSessionKey = namespace !== this.orchestrator.config.defaultNamespace ? `${namespace}:${request.sessionKey}` : request.sessionKey;
+    await this.orchestrator.lcmEngine.waitForSessionObserveIdle(lcmSessionKey);
+    await this.orchestrator.lcmEngine.preCompactionFlush(lcmSessionKey);
+    return {
+      enabled: true,
+      flushed: true,
+      sessionKey: request.sessionKey,
+      namespace
+    };
+  }
+  async lcmCompactionRecord(request) {
+    if (!request.sessionKey || typeof request.sessionKey !== "string" || request.sessionKey.trim().length === 0) {
+      throw new EngramAccessInputError("sessionKey is required and must be a non-empty string");
+    }
+    if (!Number.isInteger(request.tokensBefore) || request.tokensBefore < 0) {
+      throw new EngramAccessInputError("tokensBefore must be a non-negative integer");
+    }
+    if (!Number.isInteger(request.tokensAfter) || request.tokensAfter < 0) {
+      throw new EngramAccessInputError("tokensAfter must be a non-negative integer");
+    }
+    const namespace = this.resolveWritableNamespace(
+      request.namespace,
+      request.sessionKey,
+      request.authenticatedPrincipal
+    );
+    if (!this.orchestrator.lcmEngine || !this.orchestrator.lcmEngine.enabled) {
+      return {
+        enabled: false,
+        recorded: false,
+        sessionKey: request.sessionKey,
+        namespace,
+        reason: "LCM is disabled"
+      };
+    }
+    const lcmSessionKey = namespace !== this.orchestrator.config.defaultNamespace ? `${namespace}:${request.sessionKey}` : request.sessionKey;
+    await this.orchestrator.lcmEngine.waitForSessionObserveIdle(lcmSessionKey);
+    await this.orchestrator.lcmEngine.recordCompaction(
+      lcmSessionKey,
+      request.tokensBefore,
+      request.tokensAfter
+    );
+    return {
+      enabled: true,
+      recorded: true,
+      sessionKey: request.sessionKey,
+      namespace
+    };
+  }
   // ── Parity tools (match OpenClaw plugin feature set) ──────────────────
   // ── Continuity / Identity ──────────────────────────────────────────────
   async continuityAuditGenerate(request) {
@@ -4289,4 +4451,4 @@ export {
   shapeMemorySummary,
   EngramAccessService
 };
-//# sourceMappingURL=chunk-WGK4VHGP.js.map
+//# sourceMappingURL=chunk-MNU6ZBWT.js.map