@remnic/core 9.3.751 → 9.3.752

package/dist/{chunk-RWZB6MAY.js → chunk-VQL22SHO.js}

@@ -7,10 +7,10 @@ import {
 } from "./chunk-EHYB325U.js";
 import {
   CompressionGuidelineCoordinator
-} from "./chunk-5QANTTY2.js";
+} from "./chunk-BIAMJUUJ.js";
 import {
   MaintenanceScheduler
-} from "./chunk-4NWIGAIC.js";
+} from "./chunk-KT2VQLP7.js";
 import {
   runPeerProfileReasoner
 } from "./chunk-I74SUMNI.js";
@@ -19,7 +19,7 @@ import {
 } from "./chunk-7HYPN2GC.js";
 import {
   LcmEngine
-} from "./chunk-V5RVMULT.js";
+} from "./chunk-MLDAD27I.js";
 import {
   chunkTranscriptEntries
 } from "./chunk-TECVW3JP.js";
@@ -29,10 +29,10 @@ import {
 import {
   CompoundingEngine,
   defaultTierMigrationCycleBudget
-} from "./chunk-6SXNQFHB.js";
+} from "./chunk-J2JB6BHT.js";
 import {
   SharedContextManager
-} from "./chunk-JRZV3767.js";
+} from "./chunk-33NX5BLR.js";
 import {
   applyTrustScoreStage,
   buildTrustSignalsForRerank,
@@ -63,7 +63,7 @@ import {
 } from "./chunk-UHGBNIOS.js";
 import {
   HourlySummarizer
-} from "./chunk-NNL4LJAD.js";
+} from "./chunk-QMMCMV2L.js";
 import {
   buildTargetedFactRecallSection,
   shouldRecallTargetedFactEvidence
@@ -106,6 +106,9 @@ import {
   RerankCache,
   rerankLocalOrNoop
 } from "./chunk-E3VODCC3.js";
+import {
+  reorderRecallResultsWithMmr
+} from "./chunk-YDBIWGNI.js";
 import {
   createRecallSectionMetricRecorder
 } from "./chunk-VQ34TERH.js";
@@ -119,24 +122,15 @@ import {
   applyReasoningTraceBoost
 } from "./chunk-ZZTOURJI.js";
 import {
-  reorderRecallResultsWithMmr
-} from "./chunk-YDBIWGNI.js";
+  NegativeExampleStore
+} from "./chunk-EXM3CQTZ.js";
 import {
   applyMemoryWorthFilter,
   buildMemoryWorthCounterMap
 } from "./chunk-3GPTTA4J.js";
-import {
-  NegativeExampleStore
-} from "./chunk-EXM3CQTZ.js";
 import {
   evaluateMemoryActionPolicy
 } from "./chunk-H63EDPFJ.js";
-import {
-  runLiveConnectorsOnce
-} from "./chunk-VU3SVYMA.js";
-import {
-  classifyMemoryKind
-} from "./chunk-YAZNBMNF.js";
 import {
   hasBroadGraphIntent,
   inferIntentFromText,
@@ -144,6 +138,12 @@ import {
   isTaskInitiationIntent,
   planRecallMode
 } from "./chunk-PD6O7AXF.js";
+import {
+  runLiveConnectorsOnce
+} from "./chunk-VU3SVYMA.js";
+import {
+  classifyMemoryKind
+} from "./chunk-YAZNBMNF.js";
 import {
   recordJudgeTrainingPair
 } from "./chunk-XHYGJVXL.js";
@@ -160,7 +160,7 @@ import {
 } from "./chunk-LTHVM4XN.js";
 import {
   ExtractionEngine
-} from "./chunk-QOGXUNWL.js";
+} from "./chunk-SC5AEZLU.js";
 import {
   parseMemoryActionEligibilityContext
 } from "./chunk-5GSUBCZM.js";
@@ -169,7 +169,7 @@ import {
 } from "./chunk-PWFWCGOO.js";
 import {
   LocalLlmClient
-} from "./chunk-DBSMLRTO.js";
+} from "./chunk-MW7UUXTA.js";
 import {
   buildFocusedListRecallSection,
   shouldRecallFocusedListEvidence
@@ -187,35 +187,35 @@ import {
 } from "./chunk-4463LUIE.js";
 import {
   formatDaySummaryMemories
-} from "./chunk-LOPZ2DWR.js";
+} from "./chunk-RRRZ3CLN.js";
 import {
   tryDirectAnswer
 } from "./chunk-Q6IP2ARR.js";
 import {
   EmbeddingFallback
-} from "./chunk-OSMBC3JU.js";
+} from "./chunk-OKOF7ITI.js";
 import {
   buildEntityRecallSection,
   entityRecentTranscriptLookbackHours,
   readRecentEntityTranscriptEntries
-} from "./chunk-QRRBXD24.js";
+} from "./chunk-67JRXV6Z.js";
 import {
   RoutingRulesStore
-} from "./chunk-WIWPSQYU.js";
+} from "./chunk-FXRFFYWD.js";
 import {
   normalizeReplaySessionKey
 } from "./chunk-2PRQG7PV.js";
 import {
   compareVerifiedEpisodeResults,
   searchVerifiedEpisodes
-} from "./chunk-6FNZ3NMS.js";
+} from "./chunk-L3VSTJ2V.js";
 import {
   ThreadingManager
 } from "./chunk-QRDOSYOR.js";
 import {
   compareVerifiedSemanticRuleResults,
   searchVerifiedSemanticRules
-} from "./chunk-W3BFT5OJ.js";
+} from "./chunk-V4ZPLQLC.js";
 import {
   searchWorkProductLedgerEntries
 } from "./chunk-ZRWB5D4H.js";
@@ -228,14 +228,14 @@ import {
 import {
   runNamespaceMaintenanceFanout,
   summarizeNamespaceMaintenanceHealth
-} from "./chunk-SNEXVX3U.js";
+} from "./chunk-UFNQKZV7.js";
 import {
   NamespaceCatalog,
   planNamespaceMaintenance
-} from "./chunk-CGZWGVQF.js";
+} from "./chunk-K5CWCJKJ.js";
 import {
   NamespaceStorageRouter
-} from "./chunk-UU32EAIY.js";
+} from "./chunk-2DPCAW2T.js";
 import {
   searchHarmonicRetrieval
 } from "./chunk-AV5ZEH4M.js";
@@ -243,13 +243,13 @@ import {
   isAboveImportanceThreshold,
   scoreImportance
 } from "./chunk-JXS5PDQ7.js";
-import {
-  recordEvalShadowRecall
-} from "./chunk-3PY7VHV7.js";
 import {
   EXTRACTION_JUDGE_VERDICT_CATEGORY,
   recordJudgeVerdict
 } from "./chunk-BVKCV2ZY.js";
+import {
+  recordEvalShadowRecall
+} from "./chunk-3PY7VHV7.js";
 import {
   collectNativeKnowledgeChunks,
   formatNativeKnowledgeSection,
@@ -261,6 +261,9 @@ import {
 import {
   buildCompressionGuidelinesMarkdown
 } from "./chunk-OD4FM2U7.js";
+import {
+  SmartBuffer
+} from "./chunk-IQWFWSCP.js";
 import {
   buildConsolidationPrompt,
   buildExtensionsBlockForConsolidation,
@@ -270,7 +273,13 @@ import {
   materializeAfterSemanticConsolidation,
   parseConsolidationResponse,
   parseOperatorAwareConsolidationResponse
-} from "./chunk-IKHKHADN.js";
+} from "./chunk-C4LNKQ3M.js";
+import {
+  compileCorrectionRule,
+  correctionsFilePath,
+  loadCorrectionsFile,
+  saveCorrectionsFile
+} from "./chunk-NDAH7BJ5.js";
 import {
   buildRecallQueryPolicy
 } from "./chunk-LBJBNWS2.js";
@@ -281,6 +290,9 @@ import {
 import {
   BootstrapEngine
 } from "./chunk-VGUOEDTU.js";
+import {
+  isDisagreementPrompt
+} from "./chunk-H3FZVNRN.js";
 import {
   BoxBuilder
 } from "./chunk-7FL4CNPV.js";
@@ -290,18 +302,6 @@ import {
 import {
   chunkContent
 } from "./chunk-UQ7RN5HK.js";
-import {
-  SmartBuffer
-} from "./chunk-JZ7P26GF.js";
-import {
-  isDisagreementPrompt
-} from "./chunk-H3FZVNRN.js";
-import {
-  compileCorrectionRule,
-  correctionsFilePath,
-  loadCorrectionsFile,
-  saveCorrectionsFile
-} from "./chunk-NDAH7BJ5.js";
 import {
   WearablesInputError,
   describeErrorForOperator
@@ -310,14 +310,17 @@ import {
   recordDreamsPhaseRun
 } from "./chunk-YF6FMLBT.js";
 import {
+  QmdResultResolver,
   capturePassiveCorrections,
   clusterByKey,
   createCorrectionService,
-  detectPassiveCorrections
-} from "./chunk-UETBEHBA.js";
+  detectPassiveCorrections,
+  qmdCollectionPathParts,
+  selfDeps
+} from "./chunk-VX2RYM2K.js";
 import {
   importCapsule
-} from "./chunk-ARV3AUOM.js";
+} from "./chunk-M5QKGHCR.js";
 import {
   isCodingGraphInstalled
 } from "./chunk-VQ7B2Q6M.js";
@@ -342,14 +345,14 @@ import {
   resolveNamespaceFromStorageDir,
   resolveScopePlan,
   resolveScopeProfilePlan
-} from "./chunk-W3M34XT4.js";
+} from "./chunk-GECEETQ3.js";
 import {
   NamespaceSearchRouter
-} from "./chunk-HAZVVOYT.js";
+} from "./chunk-5DXUE7GB.js";
 import {
   createConversationIndexRuntime,
   createSearchBackend
-} from "./chunk-RNWWAS5V.js";
+} from "./chunk-QRM3K3XT.js";
 import {
   NoopSearchBackend
 } from "./chunk-CYEPCZN5.js";
@@ -372,20 +375,20 @@ import {
 } from "./chunk-QDW3E4RD.js";
 import {
   shouldSkipImplicitExtraction
-} from "./chunk-K5LLP4CY.js";
-import {
-  searchCausalTrajectories
-} from "./chunk-SQNED75R.js";
+} from "./chunk-XKAOT4ZB.js";
 import {
   GraphIndex
 } from "./chunk-EHQ5HO5T.js";
+import {
+  searchCausalTrajectories
+} from "./chunk-V5UV7BOA.js";
 import {
   decideLifecycleTransition,
   resolveLifecycleState
 } from "./chunk-TBBDFYXW.js";
 import {
   buildChainFollowupGenerator
-} from "./chunk-K2R3DEEH.js";
+} from "./chunk-MTN2G4DT.js";
 import {
   ContentHashIndex,
   StorageManager,
@@ -393,7 +396,10 @@ import {
   fingerprintEntityStructuredFacts,
   normalizeAttributePairs,
   parseEntityFile
-} from "./chunk-ZBVQ4ZM4.js";
+} from "./chunk-YGNQG4Q6.js";
+import {
+  buildRetiredFactTombstoneInputs
+} from "./chunk-L2B3EE7B.js";
 import {
   isValidTranscriptDate,
   loadSpeakerRegistry,
@@ -401,9 +407,6 @@ import {
   saveSpeakerRegistry,
   speakerRegistryKey
 } from "./chunk-M7XQSUBB.js";
-import {
-  buildRetiredFactTombstoneInputs
-} from "./chunk-L2B3EE7B.js";
 import {
   assertPathInsideRoot
 } from "./chunk-5GPPACXK.js";
@@ -451,13 +454,43 @@ import {
   fallbackLlmRuntimeContextFromConfig,
   gatewayTaskChainOptions
 } from "./chunk-VUA4S7P6.js";
+import {
+  sanitizeMemoryContent
+} from "./chunk-5GKPFL3S.js";
+import {
+  expandTildePath
+} from "./chunk-EYIEWJNI.js";
+import {
+  readEnvVar,
+  resolveHomeDir
+} from "./chunk-JUC24CTX.js";
+import {
+  log
+} from "./chunk-NU3CSQ4H.js";
 import {
   CAPSULE_ID_PATTERN
 } from "./chunk-WEHSQBFR.js";
 import {
   keyring_exports,
   secureStoreDir
-} from "./chunk-BJMBJZ2Y.js";
+} from "./chunk-GWTFLF2P.js";
+import {
+  assertIsDirectoryNotSymlink,
+  assertRealpathInsideRoot
+} from "./chunk-GCGJW34D.js";
+import {
+  SecureStoreLockedError
+} from "./chunk-J2HSAU72.js";
+import {
+  parseFlexibleIsoTimestamp
+} from "./chunk-P7FMDTKL.js";
+import {
+  ALL_CATEGORY_DIRS,
+  ALL_CATEGORY_KEYS,
+  RECALL_FALLBACK_DIRS,
+  categoryDirName,
+  getCategoryDir
+} from "./chunk-VS2IYZRU.js";
 import {
   buildRetrievedMemoryProvenance
 } from "./chunk-I4WBNM3M.js";
@@ -494,36 +527,6 @@ import {
   resolveSecurityCapabilities,
   resolveUtilityLearningCapabilities
 } from "./chunk-VSF7AAGE.js";
-import {
-  sanitizeMemoryContent
-} from "./chunk-5GKPFL3S.js";
-import {
-  expandTildePath
-} from "./chunk-EYIEWJNI.js";
-import {
-  readEnvVar,
-  resolveHomeDir
-} from "./chunk-JUC24CTX.js";
-import {
-  log
-} from "./chunk-NU3CSQ4H.js";
-import {
-  assertIsDirectoryNotSymlink,
-  assertRealpathInsideRoot
-} from "./chunk-GCGJW34D.js";
-import {
-  SecureStoreLockedError
-} from "./chunk-J2HSAU72.js";
-import {
-  parseFlexibleIsoTimestamp
-} from "./chunk-P7FMDTKL.js";
-import {
-  ALL_CATEGORY_DIRS,
-  ALL_CATEGORY_KEYS,
-  RECALL_FALLBACK_DIRS,
-  categoryDirName,
-  getCategoryDir
-} from "./chunk-VS2IYZRU.js";
 import {
   MEMORY_ID_PATTERN,
   buildHandleIndexForResults,
@@ -538,7 +541,7 @@ import {
 } from "./chunk-PVGDJXVK.js";
 
 // src/orchestrator.ts
-import path16 from "path";
+import path15 from "path";
 import { createHash as createHash8 } from "crypto";
 
 // src/orchestration/tier-migration-coordinator.ts
@@ -2157,7 +2160,7 @@ var RecallRerankCoordinator = class _RecallRerankCoordinator {
           nsMap = buildMemoryWorthCounterMap(memories);
           this.memoryWorthCounterCache.set(ns, { at: nowMs, counters: nsMap });
         }
-        for (const [path31, c] of nsMap) counters.set(path31, c);
+        for (const [path30, c] of nsMap) counters.set(path30, c);
       } catch (err) {
         log.debug("memory-worth: failed to read namespace, skipping", {
           namespace: ns,
@@ -2242,7 +2245,7 @@ var RecallRerankCoordinator = class _RecallRerankCoordinator {
       namespaces,
       {
         readNamespaceMemories: async (ns) => (await this.getStorage(ns)).readAllMemories(),
-        readMemoryFrontmatter: async (path31) => {
+        readMemoryFrontmatter: async (path30) => {
           if (!fallbackReader) {
             for (const ns of namespaces) {
               try {
@@ -2253,7 +2256,7 @@ var RecallRerankCoordinator = class _RecallRerankCoordinator {
             }
           }
           if (!fallbackReader) return null;
-          const memory = await this.readQmdResultMemory(path31, fallbackReader, namespaces);
+          const memory = await this.readQmdResultMemory(path30, fallbackReader, namespaces);
           return memory ? memory.frontmatter : null;
         }
       },
@@ -2556,257 +2559,6 @@ var RecallSectionCoordinator = class {
   }
 };
 
-// src/orchestration/qmd-result-resolver.ts
-import path4 from "path";
-function qmdCollectionPathParts(resultPath) {
-  if (!resultPath || path4.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 = path4.resolve(storageDir);
-  const addCandidate = (candidate) => {
-    const resolved = path4.resolve(candidate);
-    if (isPathInsideStorageRoot(storageRoot, resolved)) {
-      candidates.add(resolved);
-    }
-  };
-  const addRelativeCandidates = (relativePath) => {
-    const normalized = relativePath.replace(/\\/g, "/").replace(/^\/+/, "");
-    if (!normalized) return;
-    addCandidate(path4.join(storageRoot, normalized));
-    if (/^\d{4}-\d{2}-\d{2}\//.test(normalized)) {
-      addCandidate(path4.join(storageRoot, "facts", normalized));
-    }
-  };
-  if (path4.isAbsolute(resultPath)) {
-    addCandidate(resultPath);
-  } else {
-    addRelativeCandidates(resultPath);
-  }
-  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 ? path4.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 {
-          const coldRoot = path4.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;
-        }
-        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;
-      }
-    }
-    if (path4.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 (!fallbackStorageDir) {
-      return await fallbackStorage.readMemoryByPath(resultPath);
-    }
-    for (const candidate of qmdResultPathCandidates(
-      fallbackStorageDir,
-      resultPath
-    )) {
-      const memory = await fallbackStorage.readMemoryByPath(candidate);
-      if (memory) return memory;
-    }
-    return null;
-  }
-  async resolveColdQmdResultForRecall(result, fallbackStorage, recallNamespaces = []) {
-    const memory = await this.readQmdResultMemory(
-      result.path,
-      fallbackStorage,
-      recallNamespaces
-    );
-    if (!memory) return null;
-    let ownerNamespace = null;
-    if (path4.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)
-      }
-    };
-  }
-  async storageForAbsoluteQmdResultPath(resultPath, fallbackStorage, recallNamespaces = []) {
-    const resolvedPath = path4.resolve(resultPath);
-    const config = this.getConfig();
-    const memoryRoot = path4.resolve(config.memoryDir);
-    const namespacesRoot = path4.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 = path4.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 = path4.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;
-  }
-};
-
 // src/orchestration/contradiction-linking-coordinator.ts
 var ContradictionLinkingCoordinator = class {
   getConfig;
@@ -2983,7 +2735,7 @@ import { createHash as createHash3 } from "crypto";
 // src/orchestration/orchestrator-helpers.ts
 import { createHash as createHash2 } from "crypto";
 import os from "os";
-import path5 from "path";
+import path4 from "path";
 var BulkImportBatchPartialFailureError = class extends Error {
   partialResult;
   originalError;
@@ -3138,7 +2890,7 @@ async function qmdStartupCollectionCheckWithTimeout(promise, controller, label)
   return await Promise.race([checkedPromise, timeoutPromise]);
 }
 function defaultWorkspaceDir() {
-  return path5.join(os.homedir(), ".openclaw", "workspace");
+  return path4.join(os.homedir(), ".openclaw", "workspace");
 }
 function sanitizeSessionKeyForFilename(sessionKey) {
   const readable = sessionKey.replace(/[^a-zA-Z0-9._-]/g, "_");
@@ -3499,7 +3251,7 @@ function buildMemoryPathById(allMemsForGraph, storageDir) {
   for (const mem of allMemsForGraph ?? []) {
     const id = mem.frontmatter.id;
     if (!id) continue;
-    pathById.set(id, path5.relative(storageDir, mem.path));
+    pathById.set(id, path4.relative(storageDir, mem.path));
   }
   return pathById;
 }
@@ -3507,7 +3259,7 @@ function appendMemoryToGraphContext(options) {
   if (!Array.isArray(options.allMemsForGraph)) return;
   const nowIso = (/* @__PURE__ */ new Date()).toISOString();
   options.allMemsForGraph.push({
-    path: path5.join(options.storageDir, options.memoryRelPath),
+    path: path4.join(options.storageDir, options.memoryRelPath),
     content: options.content,
     frontmatter: {
       id: options.memoryId,
@@ -3527,16 +3279,16 @@ function resolvePersistedMemoryRelativePath(options) {
   const persisted = options.pathById.get(options.memoryId);
   if (persisted) return persisted;
   if (options.category === "correction") {
-    return path5.join("corrections", `${options.memoryId}.md`);
+    return path4.join("corrections", `${options.memoryId}.md`);
   }
   const subtree = categoryDirName(options.category);
   const idParts = options.memoryId.split("-");
   const maybeTimestamp = Number(idParts[1]);
   if (Number.isFinite(maybeTimestamp) && maybeTimestamp > 0) {
     const day = new Date(maybeTimestamp).toISOString().slice(0, 10);
-    return path5.join(subtree, day, `${options.memoryId}.md`);
+    return path4.join(subtree, day, `${options.memoryId}.md`);
   }
-  return path5.join(subtree, `${options.memoryId}.md`);
+  return path4.join(subtree, `${options.memoryId}.md`);
 }
 
 // src/orchestration/extraction-run.ts
@@ -4024,7 +3776,7 @@ ${normalized}`).digest("hex");
 };
 
 // src/orchestration/consolidation-run.ts
-import path6 from "path";
+import path5 from "path";
 import { mkdir as mkdir2, readFile, writeFile as writeFile2 } from "fs/promises";
 var ConsolidationRunCoordinator = class {
   constructor(deps) {
@@ -4252,7 +4004,7 @@ var ConsolidationRunCoordinator = class {
     }
     if (resolveConsolidationCapabilities(config).semanticConsolidation) {
       try {
-        const stateFilePath = path6.join(
+        const stateFilePath = path5.join(
           config.memoryDir,
           "state",
           "semantic-consolidation-last-run.json"
@@ -4300,7 +4052,7 @@ var ConsolidationRunCoordinator = class {
             );
           }
           if (semResult.errors === 0 || semResult.memoriesArchived > 0) {
-            const stateDir = path6.join(config.memoryDir, "state");
+            const stateDir = path5.join(config.memoryDir, "state");
             await mkdir2(stateDir, { recursive: true });
             await writeFile2(
               stateFilePath,
@@ -5985,12 +5737,12 @@ var ExtractionPersistCoordinator = class {
 // src/orchestration/recall-internal.ts
 import { createHash as createHash5 } from "crypto";
 import { readFile as readFile2, stat, unlink } from "fs/promises";
-import path8 from "path";
+import path7 from "path";
 
 // src/orchestration/graph-recall-coordinator.ts
 import { createHash as createHash4 } from "crypto";
 import { mkdir as mkdir3, writeFile as writeFile3 } from "fs/promises";
-import path7 from "path";
+import path6 from "path";
 function mergeGraphExpandedResults(primary, expanded) {
   const mergedByPath = /* @__PURE__ */ new Map();
   for (const item of [...primary, ...expanded]) {
@@ -6006,11 +5758,11 @@ function mergeGraphExpandedResults(primary, expanded) {
   return Array.from(mergedByPath.values());
 }
 function graphPathRelativeToStorage(storageDir, candidatePath) {
-  const absolutePath = path7.isAbsolute(candidatePath) ? candidatePath : path7.resolve(storageDir, candidatePath);
-  const rel = path7.relative(storageDir, absolutePath);
+  const absolutePath = path6.isAbsolute(candidatePath) ? candidatePath : path6.resolve(storageDir, candidatePath);
+  const rel = path6.relative(storageDir, absolutePath);
   if (!rel || rel === ".") return null;
   if (rel.startsWith("..")) return null;
-  return rel.split(path7.sep).join("/");
+  return rel.split(path6.sep).join("/");
 }
 function normalizeGraphActivationScore(score) {
   const bounded = Number.isFinite(score) && score > 0 ? score : 0;
@@ -6081,7 +5833,7 @@ var GraphRecallCoordinator = class {
         resolvedPath = resolvedCold.result.path;
         resolvedResult = resolvedCold.result;
       }
-      if (!path7.isAbsolute(resolvedPath)) {
+      if (!path6.isAbsolute(resolvedPath)) {
         resolvedAmbiguousSeeds.set(result.path, null);
         return null;
       }
@@ -6106,7 +5858,7 @@ var GraphRecallCoordinator = class {
         }
         continue;
       }
-      if (path7.isAbsolute(result.path)) {
+      if (path6.isAbsolute(result.path)) {
         const resolved = await resolveAmbiguousSeedOwner(result, null);
         if (resolved) {
           addResultForNamespace(resolved.namespace, resolved.result);
@@ -6149,7 +5901,7 @@ var GraphRecallCoordinator = class {
         0
       );
       seedPaths.push(
-        ...seedRelativePaths.map((rel) => path7.join(storage.dir, rel))
+        ...seedRelativePaths.map((rel) => path6.join(storage.dir, rel))
       );
       const seedSet = new Set(seedRelativePaths);
       const expanded = await this.graphIndexFor(storage).spreadingActivation(
@@ -6165,7 +5917,7 @@ var GraphRecallCoordinator = class {
       for (const candidate of expanded.slice(0, perNamespaceExpandedCap)) {
         if (deadlineExpired()) break;
         if (seedSet.has(candidate.path)) continue;
-        const memoryPath = path7.resolve(storage.dir, candidate.path);
+        const memoryPath = path6.resolve(storage.dir, candidate.path);
         const memory = await storage.readMemoryByPath(memoryPath);
         if (deadlineExpired()) break;
         if (!memory) continue;
@@ -6190,7 +5942,7 @@ var GraphRecallCoordinator = class {
           path: memory.path,
           score,
           namespace,
-          seed: path7.resolve(storage.dir, candidate.seed),
+          seed: path6.resolve(storage.dir, candidate.seed),
           hopDepth: candidate.hopDepth,
           decayedWeight: candidate.decayedWeight,
           graphType: candidate.graphType,
@@ -6211,12 +5963,12 @@ var GraphRecallCoordinator = class {
   }
   async recordLastGraphRecallSnapshot(options) {
     try {
-      const snapshotPath = path7.join(
+      const snapshotPath = path6.join(
         options.storage.dir,
         "state",
         "last_graph_recall.json"
       );
-      await mkdir3(path7.dirname(snapshotPath), { recursive: true });
+      await mkdir3(path6.dirname(snapshotPath), { recursive: true });
       const now = (/* @__PURE__ */ new Date()).toISOString();
       const totalSeedCount = options.seedPaths.length;
       const totalExpandedCount = options.expandedPaths.length;
@@ -6549,7 +6301,7 @@ var RecallInternalCoordinator = class {
       const graphExpandedResultPaths = /* @__PURE__ */ new Set();
       const graphSourceLabelsForPath = (resultPath) => {
         const labels = [];
-        const normalizedPath = resultPath.split(path8.sep).join("/");
+        const normalizedPath = resultPath.split(path7.sep).join("/");
         const isEntityPath = normalizedPath.startsWith("entities/") || normalizedPath.includes("/entities/");
         if (graphBaselinePaths.has(resultPath)) labels.push("baseline");
         if (graphExpandedResultPaths.has(resultPath))
@@ -6699,7 +6451,7 @@ var RecallInternalCoordinator = class {
         profileStorageNamespaces.map((namespace) => this.deps.storageRouter.storageFor(namespace))
       );
       const emptyProfileStorage = new Proxy(
-        { dir: path8.join(this.deps.config.memoryDir, ".empty-scope-profile") },
+        { dir: path7.join(this.deps.config.memoryDir, ".empty-scope-profile") },
         {
           get(target, prop) {
             if (prop in target) return target[prop];
@@ -8175,11 +7927,11 @@ ${formatted}`;
         if (!resolveRecallAuxiliaryCapabilities(this.deps.config).compactionReset) return null;
         const workspaceDir = compactionWorkspaceDir || this.deps.config.workspaceDir || defaultWorkspaceDir();
         const safeSessionKey = sanitizeSessionKeyForFilename(effectiveSessionKey);
-        const signalPath = path8.join(
+        const signalPath = path7.join(
           workspaceDir,
           `.compaction-reset-signal-${safeSessionKey}`
         );
-        const bootPath = path8.join(workspaceDir, "BOOT.md");
+        const bootPath = path7.join(workspaceDir, "BOOT.md");
         try {
           const signalStat = await stat(signalPath).catch(() => null);
           if (!signalStat) return null;
@@ -10194,7 +9946,7 @@ _Context: ${topQuestion.context}_`
 
 // src/orchestration/recall-search-pipeline.ts
 import { createHash as createHash6 } from "crypto";
-import path9 from "path";
+import path8 from "path";
 
 // src/recall/archive-scoring.ts
 import os2 from "os";
@@ -10796,7 +10548,7 @@ var RecallSearchPipelineCoordinator = class {
     if (hits.length === 0) return [];
     const results = [];
     for (const hit of hits) {
-      const fullPath = path9.isAbsolute(hit.path) ? hit.path : path9.join(this.deps.config.memoryDir, hit.path);
+      const fullPath = path8.isAbsolute(hit.path) ? hit.path : path8.join(this.deps.config.memoryDir, hit.path);
       const memory = await this.deps.storage.readMemoryByPath(fullPath);
       if (!memory) continue;
       results.push({
@@ -10993,7 +10745,7 @@ var RecallSearchPipelineCoordinator = class {
           const storage = await this.deps.storageRouter.storageFor(namespace);
           const storageDir = typeof storage.dir === "string" && storage.dir ? storage.dir : null;
           if (!storageDir) continue;
-          const recallRoot = path9.resolve(storageDir);
+          const recallRoot = path8.resolve(storageDir);
           if (seenRecallRoots.has(recallRoot)) continue;
           seenRecallRoots.add(recallRoot);
           recallRoots.push(recallRoot);
@@ -11017,8 +10769,8 @@ var RecallSearchPipelineCoordinator = class {
           if (resolvedCold) scopedResults.push(resolvedCold.result);
           continue;
         }
-        if (path9.isAbsolute(result.path)) {
-          const resolvedPath = path9.resolve(result.path);
+        if (path8.isAbsolute(result.path)) {
+          const resolvedPath = path8.resolve(result.path);
           if (recallRoots.some(
             (recallRoot) => isPathInsideStorageRoot(recallRoot, resolvedPath)
           )) {
@@ -12041,7 +11793,7 @@ var TurnIngestionCoordinator = class {
 
 // src/orchestration/recall-introspection.ts
 import { mkdir as mkdir5, readFile as readFile4, writeFile as writeFile5 } from "fs/promises";
-import path11 from "path";
+import path10 from "path";
 
 // src/taxonomy/default-taxonomy.ts
 var DEFAULT_TAXONOMY = {
@@ -12164,7 +11916,7 @@ function generateResolverDocument(taxonomy) {
 
 // src/taxonomy/taxonomy-loader.ts
 import { readFile as readFile3, mkdir as mkdir4, writeFile as writeFile4 } from "fs/promises";
-import path10 from "path";
+import path9 from "path";
 var TAXONOMY_DIR = ".taxonomy";
 var TAXONOMY_FILE = "taxonomy.json";
 var MAX_SLUG_LENGTH = 32;
@@ -12262,7 +12014,7 @@ function validateTaxonomy(taxonomy) {
   }
 }
 async function loadTaxonomy(memoryDir) {
-  const taxonomyPath = path10.join(memoryDir, TAXONOMY_DIR, TAXONOMY_FILE);
+  const taxonomyPath = path9.join(memoryDir, TAXONOMY_DIR, TAXONOMY_FILE);
   let raw;
   try {
     raw = await readFile3(taxonomyPath, "utf-8");
@@ -12312,16 +12064,16 @@ async function loadTaxonomy(memoryDir) {
 }
 async function saveTaxonomy(memoryDir, taxonomy) {
   validateTaxonomy(taxonomy);
-  const dir = path10.join(memoryDir, TAXONOMY_DIR);
+  const dir = path9.join(memoryDir, TAXONOMY_DIR);
   await mkdir4(dir, { recursive: true });
-  const filePath = path10.join(dir, TAXONOMY_FILE);
+  const filePath = path9.join(dir, TAXONOMY_FILE);
   await writeFile4(filePath, JSON.stringify(taxonomy, null, 2) + "\n", "utf-8");
 }
 function getTaxonomyDir(memoryDir) {
-  return path10.join(memoryDir, TAXONOMY_DIR);
+  return path9.join(memoryDir, TAXONOMY_DIR);
 }
 function getTaxonomyFilePath(memoryDir) {
-  return path10.join(memoryDir, TAXONOMY_DIR, TAXONOMY_FILE);
+  return path9.join(memoryDir, TAXONOMY_DIR, TAXONOMY_FILE);
 }
 
 // src/orchestration/recall-introspection.ts
@@ -12345,7 +12097,7 @@ var RecallIntrospectionCoordinator = class {
   }
   async getLastGraphRecallSnapshot(namespace) {
     const storage = await this.deps.getStorage(namespace);
-    const snapshotPath = path11.join(
+    const snapshotPath = path10.join(
       storage.dir,
       "state",
       "last_graph_recall.json"
@@ -12384,7 +12136,7 @@ var RecallIntrospectionCoordinator = class {
   }
   async getLastIntentSnapshot(namespace) {
     const storage = await this.deps.getStorage(namespace);
-    const snapshotPath = path11.join(storage.dir, "state", "last_intent.json");
+    const snapshotPath = path10.join(storage.dir, "state", "last_intent.json");
     try {
       const raw = await readFile4(snapshotPath, "utf-8");
       const parsed = JSON.parse(raw);
@@ -12417,7 +12169,7 @@ var RecallIntrospectionCoordinator = class {
   }
   async getLastQmdRecallSnapshot(namespace) {
     const storage = await this.deps.getStorage(namespace);
-    const snapshotPath = path11.join(
+    const snapshotPath = path10.join(
       storage.dir,
       "state",
       "last_qmd_recall.json"
@@ -12703,12 +12455,12 @@ var RecallIntrospectionCoordinator = class {
   }
   async recordLastIntentSnapshot(options) {
     try {
-      const snapshotPath = path11.join(
+      const snapshotPath = path10.join(
         options.storage.dir,
         "state",
         "last_intent.json"
       );
-      await mkdir5(path11.dirname(snapshotPath), { recursive: true });
+      await mkdir5(path10.dirname(snapshotPath), { recursive: true });
       await writeFile5(
         snapshotPath,
         JSON.stringify(options.snapshot, null, 2),
@@ -12720,12 +12472,12 @@ var RecallIntrospectionCoordinator = class {
   }
   async recordLastQmdRecallSnapshot(options) {
     try {
-      const snapshotPath = path11.join(
+      const snapshotPath = path10.join(
         options.storage.dir,
         "state",
         "last_qmd_recall.json"
       );
-      await mkdir5(path11.dirname(snapshotPath), { recursive: true });
+      await mkdir5(path10.dirname(snapshotPath), { recursive: true });
       await writeFile5(
         snapshotPath,
         JSON.stringify(options.snapshot, null, 2),
@@ -12740,8 +12492,8 @@ var RecallIntrospectionCoordinator = class {
       const stateDir = await this.deps.resolveStateDirForNamespace(
         options.namespace
       );
-      const snapshotPath = path11.join(stateDir, "last_intent.json");
-      await mkdir5(path11.dirname(snapshotPath), { recursive: true });
+      const snapshotPath = path10.join(stateDir, "last_intent.json");
+      await mkdir5(path10.dirname(snapshotPath), { recursive: true });
       await writeFile5(
         snapshotPath,
         JSON.stringify(options.snapshot, null, 2),
@@ -12755,7 +12507,7 @@ var RecallIntrospectionCoordinator = class {
 
 // src/orchestration/orchestrator-init.ts
 import { readdir as readdir2, stat as stat2, unlink as unlink2 } from "fs/promises";
-import path12 from "path";
+import path11 from "path";
 var OrchestratorInitCoordinator = class {
   constructor(deps) {
     this.deps = deps;
@@ -12845,7 +12597,7 @@ var OrchestratorInitCoordinator = class {
           const files = await readdir2(wsDir).catch(() => []);
           for (const f of files) {
             if (!f.startsWith(".compaction-reset-signal-")) continue;
-            const fp = path12.join(wsDir, f);
+            const fp = path11.join(wsDir, f);
             const s = await stat2(fp).catch(() => null);
             if (s && Date.now() - s.mtimeMs >= COMPACTION_SIGNAL_MAX_AGE_MS) {
               await unlink2(fp).catch(() => {
@@ -13194,7 +12946,7 @@ var OrchestratorInitCoordinator = class {
 };
 
 // src/orchestration/persistence-index.ts
-import path13 from "path";
+import path12 from "path";
 var PersistenceIndexCoordinator = class {
   constructor(deps) {
     this.deps = deps;
@@ -13336,7 +13088,7 @@ var PersistenceIndexCoordinator = class {
         const allMems = allMemsForGraph ?? [];
         for (const m of allMems) {
           if (m.frontmatter.entityRef === entityRef) {
-            const rel = path13.relative(storage.dir, m.path);
+            const rel = path12.relative(storage.dir, m.path);
             if (rel !== memoryRelPath) entitySiblings.push(rel);
           }
         }
@@ -13467,7 +13219,7 @@ var PersistenceIndexCoordinator = class {
 
 // src/orchestration/workspace-ops.ts
 import { lstat, mkdir as mkdir6, readFile as readFile5, readdir as readdir3, realpath, writeFile as writeFile6 } from "fs/promises";
-import path14 from "path";
+import path13 from "path";
 
 // src/maintenance/pattern-reinforcement.ts
 function patternReinforcementKey(content) {
@@ -14265,15 +14017,15 @@ var WorkspaceOpsCoordinator = class {
     this.deps.lastFileHygieneRunAtMs = now;
     if (hygiene.rotateEnabled) {
       for (const rel of hygiene.rotatePaths) {
-        const abs = path14.isAbsolute(rel) ? rel : path14.join(this.deps.config.workspaceDir, rel);
+        const abs = path13.isAbsolute(rel) ? rel : path13.join(this.deps.config.workspaceDir, rel);
         try {
           const raw = await readFile5(abs, "utf-8");
           if (raw.length > hygiene.rotateMaxBytes) {
-            const archiveDir = path14.join(
+            const archiveDir = path13.join(
               this.deps.config.workspaceDir,
               hygiene.archiveDir
             );
-            const base = path14.basename(abs);
+            const base = path13.basename(abs);
             const prefix = base.toUpperCase().replace(/\.MD$/i, "").replace(/[^A-Z0-9]+/g, "-") || "FILE";
             const { newContent } = await rotateMarkdownFileToArchive({
               filePath: abs,
@@ -14298,8 +14050,8 @@ var WorkspaceOpsCoordinator = class {
         log.warn(w.message);
       }
       if (hygiene.warningsLogEnabled && warnings.length > 0) {
-        const fp = path14.join(this.deps.config.memoryDir, hygiene.warningsLogPath);
-        await mkdir6(path14.dirname(fp), { recursive: true });
+        const fp = path13.join(this.deps.config.memoryDir, hygiene.warningsLogPath);
+        await mkdir6(path13.dirname(fp), { recursive: true });
         const stamp = (/* @__PURE__ */ new Date()).toISOString();
         const block = `
 
@@ -14339,7 +14091,7 @@ var WorkspaceOpsCoordinator = class {
     for (const categoryDir of RECALL_FALLBACK_DIRS) {
       if (memoryRootReal === null) break;
       for (const date of datesToScan) {
-        const dateDir = path14.join(storage.dir, categoryDir, date);
+        const dateDir = path13.join(storage.dir, categoryDir, date);
         try {
           const dirStat = await lstat(dateDir);
           if (dirStat.isSymbolicLink() || !dirStat.isDirectory()) continue;
@@ -14348,7 +14100,7 @@ var WorkspaceOpsCoordinator = class {
           for (const entry of entries) {
             if (entry.isSymbolicLink()) continue;
             if (!entry.name.endsWith(".md")) continue;
-            const fullPath = path14.join(dateDir, entry.name);
+            const fullPath = path13.join(dateDir, entry.name);
             try {
               assertPathInsideRoot(memoryRootReal, await realpath(fullPath), fullPath);
               const raw = await readFile5(fullPath, "utf-8");
@@ -14370,7 +14122,7 @@ var WorkspaceOpsCoordinator = class {
               facts.push({
                 path: fullPath,
                 frontmatter: {
-                  id: fm.id || path14.basename(entry.name, ".md"),
+                  id: fm.id || path13.basename(entry.name, ".md"),
                   category: fm.category || "fact",
                   created,
                   updated: fm.updated || created,
@@ -14393,13 +14145,13 @@ var WorkspaceOpsCoordinator = class {
       return a.frontmatter.created < b.frontmatter.created ? -1 : 1;
     });
     const hourlySummaries = [];
-    const hourlyBaseDir = path14.join(storage.dir, "summaries", "hourly");
+    const hourlyBaseDir = path13.join(storage.dir, "summaries", "hourly");
     try {
       const sessionKeys = await readdir3(hourlyBaseDir, { withFileTypes: true });
       for (const sk of sessionKeys) {
         if (!sk.isDirectory()) continue;
         for (const date of datesToScan) {
-          const summaryFile = path14.join(hourlyBaseDir, sk.name, `${date}.md`);
+          const summaryFile = path13.join(hourlyBaseDir, sk.name, `${date}.md`);
           try {
             const raw = await readFile5(summaryFile, "utf-8");
             const filtered = filterHourlySummaryMarkdownForLocalDay(
@@ -14677,7 +14429,7 @@ ${reflectionsContent.trim()}
 // src/orchestration/namespace-read-fanout.ts
 import { existsSync, readFileSync } from "fs";
 import { stat as stat3 } from "fs/promises";
-import path15 from "path";
+import path14 from "path";
 var NamespaceReadFanoutCoordinator = class {
   constructor(deps) {
     this.deps = deps;
@@ -14704,7 +14456,7 @@ var NamespaceReadFanoutCoordinator = class {
   loadNamespaceStorageDirHintsFromCatalog() {
     if (this.deps.namespaceStorageDirHintsLoaded || !this.deps.namespaceCatalog.enabled) return;
     this.deps.namespaceStorageDirHintsLoaded = true;
-    const catalogPath = path15.join(this.deps.config.memoryDir, "state", "namespaces.jsonl");
+    const catalogPath = path14.join(this.deps.config.memoryDir, "state", "namespaces.jsonl");
     if (!existsSync(catalogPath)) return;
     let body;
     try {
@@ -14741,7 +14493,7 @@ var NamespaceReadFanoutCoordinator = class {
       if (!this.deps.storageDirMatchesNamespaceHint(record.namespace, record.storageDir)) {
         continue;
       }
-      const resolvedStorageDir = path15.resolve(record.storageDir);
+      const resolvedStorageDir = path14.resolve(record.storageDir);
       const current = preferredByStorageDir.get(resolvedStorageDir);
       preferredByStorageDir.set(
         resolvedStorageDir,
@@ -14918,12 +14670,12 @@ var NamespaceReadFanoutCoordinator = class {
   }
   async resolveStateDirForNamespace(namespace) {
     if (!resolveNamespaceCapabilities(this.deps.config).namespaces) {
-      return path15.join(this.deps.config.memoryDir, "state");
+      return path14.join(this.deps.config.memoryDir, "state");
     }
     if (namespace !== this.deps.config.defaultNamespace) {
-      return path15.join(this.deps.config.memoryDir, "namespaces", namespace, "state");
+      return path14.join(this.deps.config.memoryDir, "namespaces", namespace, "state");
     }
-    const candidate = path15.join(
+    const candidate = path14.join(
       this.deps.config.memoryDir,
       "namespaces",
       this.deps.config.defaultNamespace
@@ -14931,11 +14683,11 @@ var NamespaceReadFanoutCoordinator = class {
     try {
       const candidateStat = await stat3(candidate);
       if (candidateStat.isDirectory()) {
-        return path15.join(candidate, "state");
+        return path14.join(candidate, "state");
       }
     } catch {
     }
-    return path15.join(this.deps.config.memoryDir, "state");
+    return path14.join(this.deps.config.memoryDir, "state");
   }
   namespaceFromPath(p) {
     if (!resolveNamespaceCapabilities(this.deps.config).namespaces) return this.deps.config.defaultNamespace;
@@ -14976,30 +14728,426 @@ var NamespaceReadFanoutCoordinator = class {
   }
 };
 
-// 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;
-    }
-  });
-}
-
-// src/orchestrator.ts
-var Orchestrator = class {
-  storage;
-  storageRouter;
-  /** Rebuildable namespace catalog (issue #1499). Inert unless namespaces enabled. */
+// src/orchestration/recall-entry.ts
+var RecallEntryCoordinator = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  deps;
+  async recall(prompt, sessionKey, options = {}) {
+    const caps = resolveCapabilities(this.deps.config);
+    const graphCaps = resolveGraphConstructionCapabilities(this.deps.config);
+    const abortController = new AbortController();
+    const onAbort = () => {
+      abortController.abort();
+    };
+    if (options.abortSignal?.aborted) {
+      abortController.abort();
+    } else {
+      options.abortSignal?.addEventListener("abort", onAbort, { once: true });
+    }
+    const principal = typeof options.principalOverride === "string" && options.principalOverride.length > 0 ? options.principalOverride : resolvePrincipal(sessionKey, this.deps.config);
+    const namespacesEnabled = resolveNamespaceCapabilities(this.deps.config).namespaces;
+    if (namespacesEnabled && !principal) {
+      throw new Error("authentication required: namespaces are enabled and no principal was supplied");
+    }
+    let initGateTimeoutHandle = null;
+    let onInitGateAbort = null;
+    if (this.deps.initPromise) {
+      const gateResult = await Promise.race([
+        this.deps.initPromise.then(() => "ok"),
+        new Promise((resolve) => {
+          initGateTimeoutHandle = setTimeout(
+            () => resolve("timeout"),
+            this.deps.config.initGateTimeoutMs
+          );
+        }),
+        abortController.signal.aborted ? Promise.resolve("aborted") : new Promise((resolve) => {
+          onInitGateAbort = () => resolve("aborted");
+          abortController.signal.addEventListener(
+            "abort",
+            onInitGateAbort,
+            { once: true }
+          );
+        })
+      ]);
+      if (initGateTimeoutHandle) clearTimeout(initGateTimeoutHandle);
+      if (onInitGateAbort)
+        abortController.signal.removeEventListener("abort", onInitGateAbort);
+      if (gateResult === "aborted") {
+        this.deps.logRecallFailure(abortRecallError("recall aborted before init"));
+        return "";
+      }
+      if (gateResult === "timeout") {
+        log.warn("recall: init gate timed out \u2014 proceeding without full init");
+      }
+    }
+    if (resolveRecallAuxiliaryCapabilities(this.deps.config).secureStore && !this.deps.storage.isSecureStoreUnlocked()) {
+      const lockedMsg = "[secure-store locked] Memory store is encrypted and locked. Unlock the secure-store inside this daemon process, or restart the daemon through a secure-store aware launcher that installs the key.";
+      log.warn("recall blocked: secure-store is locked");
+      return lockedMsg;
+    }
+    try {
+      const recallPromise = this.deps.recallInternal(prompt, sessionKey, {
+        ...options,
+        abortSignal: abortController.signal
+      }, caps, graphCaps);
+      const RECALL_TIMEOUT_MS = this.deps.config.recallOuterTimeoutMs ?? 75e3;
+      if (RECALL_TIMEOUT_MS <= 0) {
+        return await recallPromise;
+      }
+      let timeoutHandle = null;
+      const timeoutPromise = new Promise((_, reject) => {
+        timeoutHandle = setTimeout(() => {
+          abortController.abort();
+          reject(new Error("recall timeout"));
+        }, RECALL_TIMEOUT_MS);
+      });
+      let recallResult;
+      try {
+        recallResult = await Promise.race([recallPromise, timeoutPromise]);
+      } finally {
+        if (timeoutHandle) clearTimeout(timeoutHandle);
+      }
+      if (caps.recallDirectAnswer && sessionKey) {
+        try {
+          this.deps.enqueueDirectAnswerObservation(
+            prompt,
+            sessionKey,
+            options.namespace?.trim() || void 0,
+            options.principalOverride,
+            caps,
+            namespacesEnabled
+          );
+        } catch (err) {
+          log.debug(`direct-answer observation setup failed: ${err}`);
+        }
+      }
+      return recallResult;
+    } catch (err) {
+      this.deps.logRecallFailure(err);
+      this.deps.profiler.endTrace();
+      return "";
+    } finally {
+      options.abortSignal?.removeEventListener("abort", onAbort);
+    }
+  }
+  logRecallFailure(err) {
+    const now = Date.now();
+    const errorMsg = err instanceof Error ? err.message : String(err);
+    const LOG_WINDOW_MS = 6e4;
+    const idleSinceLastFailureMs = now - this.deps.lastRecallFailureAtMs;
+    this.deps.lastRecallFailureAtMs = now;
+    if (idleSinceLastFailureMs >= LOG_WINDOW_MS) {
+      this.deps.suppressedRecallFailures = 0;
+    }
+    if (now - this.deps.lastRecallFailureLogAtMs >= LOG_WINDOW_MS) {
+      const suffix = this.deps.suppressedRecallFailures > 0 ? ` (suppressed ${this.deps.suppressedRecallFailures} similar failures in last minute)` : "";
+      log.warn(`recall timed out or failed: ${errorMsg}${suffix}`);
+      this.deps.lastRecallFailureLogAtMs = now;
+      this.deps.suppressedRecallFailures = 0;
+      return;
+    }
+    this.deps.suppressedRecallFailures += 1;
+    log.debug(`recall timed out or failed (suppressed): ${errorMsg}`);
+  }
+  queueEvalShadowRecall(record) {
+    if (!resolveEvalCapabilities(this.deps.config).evalHarness || !resolveEvalCapabilities(this.deps.config).evalShadowMode)
+      return;
+    this.deps.evalShadowWriteChain = this.deps.evalShadowWriteChain.catch(() => void 0).then(async () => {
+      try {
+        await recordEvalShadowRecall({
+          memoryDir: this.deps.config.memoryDir,
+          evalStoreDir: this.deps.config.evalStoreDir,
+          record: {
+            schemaVersion: 1,
+            ...record
+          }
+        });
+      } catch (err) {
+        log.debug(`eval shadow recall write failed: ${err}`);
+      }
+    });
+  }
+  publishRecallResults(options) {
+    const sectionId = "memories";
+    const trustByPath = options.trustByPath ?? null;
+    const injectable = trustByPath ? options.results.filter((r) => !trustByPath.get(r.path)?.quarantined) : options.results;
+    const memoryIds = this.deps.extractMemoryIdsFromResults(injectable);
+    this.deps.trackMemoryAccess(memoryIds);
+    this.deps.appendRecallSection(
+      options.sectionBuckets,
+      sectionId,
+      this.deps.formatQmdResults(options.title, injectable, options.sessionKey, trustByPath)
+    );
+  }
+};
+
+// src/orchestration/session-context.ts
+var SessionContextCoordinator = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  deps;
+  /**
+   * Effective namespace a same-session LCM/structured-history READER must use
+   * to find what the access `observe` surface WROTE (#1495 thread 2).
+   *
+   * This MUST mirror the `observe` scope plan's write-namespace resolution, NOT
+   * `resolveSelfNamespace`: when no coding overlay applies, `observe` archives
+   * under `config.defaultNamespace` (an unqualified observed turn is NOT moved
+   * to the principal self namespace — identical to
+   * `resolveCodingScopedWriteNamespace`/`memory_store`, rule 39). Only when a
+   * coding overlay actually changes the namespace does the writer (and so the
+   * reader) use the overlaid `project-*` namespace. Returning the self base for
+   * the no-overlay case would prefix the read key with a namespace the writer
+   * never used, so the reader would miss its own evidence.
+   *
+   * Honours the access-surface `principalOverride` (#1505 thread 2, codex): when
+   * a recall supplies an authenticated principal NOT encoded in the raw
+   * `sessionKey`, `observe` archived LCM under THAT principal's base namespace.
+   * Deriving the base from `resolvePrincipal(sessionKey)` alone could fall back
+   * to `default`, so principal `alice` observing `sess-1` would write under
+   * `alice` but READ under `default`. Threading the override here keeps the read
+   * base identical to the write base.
+   *
+   * READ-AUTHORIZATION gate (#1505 round 3, codex P2 "Gate LCM recall keys by
+   * readable namespaces"): the overlay LCM read key is a `<principal>-project-*`
+   * sub-namespace of the principal SELF base. The normal recall namespace set
+   * below only substitutes the coding overlay when the principal SELF base is
+   * actually in the readable recall set (`recallNamespacesForPrincipal` — gated
+   * by `defaultRecallNamespaces.includes("self")` AND `canReadNamespace`). If a
+   * principal can WRITE but not READ its self namespace (or `defaultRecall-
+   * Namespaces` omits `self`), QMD/file recall never touches those overlay rows,
+   * so neither may the LCM read key. When the self base is NOT readable, fall
+   * back to the default store — exactly what an unqualified, unauthorized recall
+   * resolves to — rather than injecting overlay rows the rest of recall excludes
+   * (rule 42 read/write parity; rule 48 least-privilege).
+   */
+  lcmReadNamespaceForSession(sessionKey, principalOverride) {
+    const principal = typeof principalOverride === "string" && principalOverride.length > 0 ? principalOverride : this.deps.resolvePrincipal(sessionKey);
+    const base = defaultNamespaceForPrincipal(principal, this.deps.config);
+    const overlaid = this.deps.applyCodingNamespaceOverlay(sessionKey, base);
+    if (overlaid === base) return this.deps.config.defaultNamespace;
+    const selfReadableInRecall = recallNamespacesForPrincipal(
+      principal,
+      this.deps.config
+    ).includes(base);
+    return selfReadableInRecall ? overlaid : this.deps.config.defaultNamespace;
+  }
+  /**
+   * Attach a coding-agent context to a session (issue #569). Called by the
+   * Claude Code / Codex / Cursor connectors at session start after
+   * `resolveGitContext(cwd)`. The context is consulted by the recall path
+   * and the write path so that memories route to a project- (and optionally
+   * branch-) scoped namespace.
+   *
+   * Pass `null` to clear.
+   */
+  setCodingContextForSession(sessionKey, codingContext) {
+    if (typeof sessionKey !== "string" || sessionKey.length === 0) return;
+    this.deps.ensureSessionBindingMaps();
+    if (codingContext === null) {
+      this.deps._codingContextBySession.delete(sessionKey);
+      return;
+    }
+    this.deps._codingContextBySession.set(sessionKey, codingContext);
+  }
+  /**
+   * Read-only accessor for the coding context attached to a session. Returns
+   * `null` when none is set. Used by `remnic doctor` and by tests.
+   *
+   * Defensive `_codingContextBySession` lookup — legacy orchestrator-flush
+   * tests use `Object.create(Orchestrator.prototype)` which does not run
+   * class-field initializers, so the Map may be undefined on stubs.
+   */
+  getCodingContextForSession(sessionKey) {
+    if (typeof sessionKey !== "string" || sessionKey.length === 0) return null;
+    return this.deps._codingContextBySession?.get(sessionKey) ?? null;
+  }
+  /**
+   * Shared helper used by both the recall path and the write path (rule 42).
+   *
+   * Given a base namespace computed from the principal, returns the overlaid
+   * coding namespace when the session has a coding context AND
+   * `codingMode.projectScope` is true AND `namespacesEnabled` is true.
+   * Otherwise returns `baseNamespace` unchanged — CLAUDE.md #30 escape hatch.
+   *
+   * Principal isolation (CLAUDE.md rule 42): the overlay is COMBINED with
+   * the principal-derived `baseNamespace` rather than replacing it, so two
+   * principals working in the same repository do not share memories through
+   * a common `project-*` namespace.
+   *
+   * Namespaces-disabled gate: when `namespacesEnabled` is false, the
+   * storage router maps every namespace to the same `memoryDir`. Returning
+   * `project-*` in that mode would create apparent route separation with
+   * no actual storage isolation — a false-isolation trap. In that mode we
+   * return `baseNamespace` unchanged so coding mode degrades to the existing
+   * unscoped behavior.
+   *
+   * @internal
+   */
+  applyCodingNamespaceOverlay(sessionKey, baseNamespace) {
+    if (!resolveNamespaceCapabilities(this.deps.config).namespaces) return baseNamespace;
+    const codingContext = this.deps.getCodingContextForSession(sessionKey);
+    const overlay = resolveCodingNamespaceOverlay(codingContext, this.deps.config.codingMode, this.deps.config.defaultNamespace);
+    if (!overlay) return baseNamespace;
+    return combineNamespaces(baseNamespace, overlay.namespace);
+  }
+  /**
+   * Register a peer ID for a session so recall can inject the peer's
+   * profile into context (issue #679 PR 3/5). Pass `null` to clear.
+   *
+   * Connectors and the `before_agent_start` hook call this when the
+   * session's counter-party is known. The ID is validated against
+   * `PEER_ID_PATTERN` before storing.
+   *
+   * Fail-closed (Codex P1 review): an invalid peerId clears any
+   * previously registered mapping for the session rather than silently
+   * keeping stale data. This prevents a malformed metadata update from
+   * mixing one peer's profile context into another session.
+   *
+   * Defensive init (Cursor review + rule 16): `Object.create(
+   * Orchestrator.prototype)` stubs in legacy tests skip class-field
+   * initializers, so `_peerIdBySession` may be undefined. Mirror the
+   * same guard used by `setCodingContextForSession`.
+   */
+  setPeerIdForSession(sessionKey, peerId) {
+    if (typeof sessionKey !== "string" || sessionKey.length === 0) return;
+    this.deps.ensureSessionBindingMaps();
+    if (peerId === null) {
+      this.deps._peerIdBySession.delete(sessionKey);
+      return;
+    }
+    if (typeof peerId !== "string" || peerId.length === 0 || peerId.length > 64 || !/^[A-Za-z0-9]+(?:[._-][A-Za-z0-9]+)*$/.test(peerId)) {
+      log.warn(`setPeerIdForSession: invalid peerId \u2014 clearing session mapping`);
+      this.deps._peerIdBySession.delete(sessionKey);
+      return;
+    }
+    this.deps._peerIdBySession.set(sessionKey, peerId);
+  }
+  /**
+   * Return the peer ID registered for a session, or `null` when none
+   * is set. Used by `recallInternal` to inject the peer profile section.
+   * Defensive `_peerIdBySession` lookup — legacy orchestrator-flush tests
+   * use `Object.create(Orchestrator.prototype)` which skips class-field
+   * initializers, so the Map may be undefined on stubs.
+   */
+  getPeerIdForSession(sessionKey) {
+    if (typeof sessionKey !== "string" || sessionKey.length === 0) return null;
+    return this.deps._peerIdBySession?.get(sessionKey) ?? null;
+  }
+  async runDeepSleepGovernanceNow(options) {
+    const targetStorage = options?.storage ?? this.deps.storage;
+    const { runMemoryGovernance } = await import("./maintenance/memory-governance.js");
+    const { summarizeGovernanceResultForDreams } = await import("./dreams-ledger-6UODQOX6.js");
+    const govResult = await runMemoryGovernance({
+      memoryDir: targetStorage.dir,
+      mode: options?.dryRun === true ? "shadow" : "apply"
+    });
+    if (options?.dryRun !== true) {
+      try {
+        await this.deps.processEntitySynthesisQueue(
+          this.deps.storageDirNamespace(targetStorage.dir),
+          5
+        );
+      } catch (error) {
+        log.debug(`deep-sleep governance: entity synthesis refresh failed after apply: ${error}`);
+      }
+    }
+    return summarizeGovernanceResultForDreams(govResult, options?.dryRun === true);
+  }
+  async generateDaySummary(memories) {
+    if (this.deps.initPromise) {
+      let initGateTimeoutHandle;
+      try {
+        await Promise.race([
+          this.deps.initPromise.catch(() => void 0),
+          new Promise((resolve) => {
+            initGateTimeoutHandle = setTimeout(
+              resolve,
+              this.deps.config.initGateTimeoutMs
+            );
+          })
+        ]);
+      } finally {
+        if (initGateTimeoutHandle) clearTimeout(initGateTimeoutHandle);
+      }
+    }
+    return this.deps.extraction.generateDaySummary(memories);
+  }
+  async flushSession(sessionKey, options) {
+    const explicitBufferKey = typeof options.bufferKey === "string" && options.bufferKey.length > 0 ? options.bufferKey : null;
+    const discoveredBufferKeys = explicitBufferKey || typeof sessionKey !== "string" || sessionKey.length === 0 || typeof this.deps.buffer.findBufferKeysForSession !== "function" ? [] : await this.deps.buffer.findBufferKeysForSession(sessionKey);
+    const bufferKeys = explicitBufferKey ? [explicitBufferKey] : discoveredBufferKeys.length > 0 ? discoveredBufferKeys : typeof sessionKey === "string" && sessionKey.length > 0 ? [sessionKey] : ["default"];
+    for (const bufferKey of bufferKeys) {
+      const turns = this.deps.buffer.getTurns(bufferKey);
+      if (turns.length === 0) continue;
+      await new Promise((resolve, reject) => {
+        void this.deps.queueBufferedExtraction(turns, "trigger_mode", {
+          bufferKey,
+          clearBufferAfterExtraction: true,
+          skipDedupeCheck: true,
+          abortSignal: options.abortSignal,
+          onTaskSettled: (error) => error ? reject(error) : resolve()
+        }).catch(reject);
+      });
+    }
+  }
+  /** Lazily construct the CorrectionService for passive capture. Stateless
+   *  across requests (per #1580 design); cached for the orchestrator's life. */
+  passiveCorrectionService() {
+    if (this.deps._passiveCorrectionService) return this.deps._passiveCorrectionService;
+    this.deps._passiveCorrectionService = createCorrectionService({
+      orchestrator: this.deps.orchestratorSelf,
+      // Session-scoped write ACL (review: "passive capture bypasses write
+      // ACL"). A correction detected in session S plans only against S readable
+      // namespaces and applies only to writable ones (rule 42) — passive
+      // capture never becomes a cross-tenant mutation vector. Mirrors the
+      // access-service createCorrectionService wiring rather than bypassing it.
+      resolveAuthorizedNamespace: async (req) => {
+        const principal = req.principal || resolvePrincipal(req.sessionKey, this.deps.config);
+        const ns = req.namespace ?? defaultNamespaceForPrincipal(principal, this.deps.config);
+        if (!canWriteNamespace(principal, ns, this.deps.config)) {
+          throw new Error(
+            `passive correction: namespace "${ns}" is not writable for principal ${principal ?? "(none)"}`
+          );
+        }
+        return ns;
+      },
+      resolveReadableNamespaces: (req) => {
+        const principal = req.principal || resolvePrincipal(req.sessionKey, this.deps.config);
+        return recallNamespacesForPrincipal(principal, this.deps.config);
+      },
+      canWriteNamespace: async (req) => {
+        const principal = req.principal || resolvePrincipal(req.sessionKey, this.deps.config);
+        return canWriteNamespace(principal, req.namespace, this.deps.config);
+      },
+      llmComplete: async ({ system, user }) => {
+        const llmResult = await this.deps.localLlm.chatCompletion(
+          [
+            { role: "system", content: system },
+            { role: "user", content: user }
+          ],
+          { operation: "correction-classify", priority: "background" }
+        );
+        if (!llmResult) {
+          throw new Error(
+            "passive correction classify+draft: local LLM unavailable (disabled or in cooldown)"
+          );
+        }
+        return llmResult.content;
+      }
+    });
+    return this.deps._passiveCorrectionService;
+  }
+};
+
+// src/orchestrator.ts
+var Orchestrator = class {
+  storage;
+  storageRouter;
+  /** Rebuildable namespace catalog (issue #1499). Inert unless namespaces enabled. */
   namespaceCatalog;
   namespaceStorageDirHints = /* @__PURE__ */ new Map();
   namespaceStorageDirHintsLoaded = false;
@@ -15115,6 +15263,18 @@ var Orchestrator = class {
    * (rule 11 — scope globals per plugin ID / session).
    */
   _peerIdBySession = /* @__PURE__ */ new Map();
+  /**
+   * Defensive init for the session-binding maps (issue #1526 seam 28
+   * review). `Object.create(Orchestrator.prototype)` stubs in legacy
+   * tests skip class-field initializers, so the maps may be undefined on
+   * fakes; SessionContextCoordinator calls this before writing so the
+   * maps are created ON THE ORCHESTRATOR (or fake), never on the
+   * coordinator.
+   */
+  ensureSessionBindingMaps() {
+    this._codingContextBySession ??= /* @__PURE__ */ new Map();
+    this._peerIdBySession ??= /* @__PURE__ */ new Map();
+  }
   routingRulesStore = null;
   contentHashIndex = null;
   contentHashIndexesByStorageDir = /* @__PURE__ */ new Map();
@@ -15367,157 +15527,51 @@ var Orchestrator = class {
     );
     return this.applyCodingNamespaceOverlay(sessionKey, base);
   }
-  /**
-   * Effective namespace a same-session LCM/structured-history READER must use
-   * to find what the access `observe` surface WROTE (#1495 thread 2).
-   *
-   * This MUST mirror the `observe` scope plan's write-namespace resolution, NOT
-   * `resolveSelfNamespace`: when no coding overlay applies, `observe` archives
-   * under `config.defaultNamespace` (an unqualified observed turn is NOT moved
-   * to the principal self namespace — identical to
-   * `resolveCodingScopedWriteNamespace`/`memory_store`, rule 39). Only when a
-   * coding overlay actually changes the namespace does the writer (and so the
-   * reader) use the overlaid `project-*` namespace. Returning the self base for
-   * the no-overlay case would prefix the read key with a namespace the writer
-   * never used, so the reader would miss its own evidence.
-   *
-   * Honours the access-surface `principalOverride` (#1505 thread 2, codex): when
-   * a recall supplies an authenticated principal NOT encoded in the raw
-   * `sessionKey`, `observe` archived LCM under THAT principal's base namespace.
-   * Deriving the base from `resolvePrincipal(sessionKey)` alone could fall back
-   * to `default`, so principal `alice` observing `sess-1` would write under
-   * `alice` but READ under `default`. Threading the override here keeps the read
-   * base identical to the write base.
-   *
-   * READ-AUTHORIZATION gate (#1505 round 3, codex P2 "Gate LCM recall keys by
-   * readable namespaces"): the overlay LCM read key is a `<principal>-project-*`
-   * sub-namespace of the principal SELF base. The normal recall namespace set
-   * below only substitutes the coding overlay when the principal SELF base is
-   * actually in the readable recall set (`recallNamespacesForPrincipal` — gated
-   * by `defaultRecallNamespaces.includes("self")` AND `canReadNamespace`). If a
-   * principal can WRITE but not READ its self namespace (or `defaultRecall-
-   * Namespaces` omits `self`), QMD/file recall never touches those overlay rows,
-   * so neither may the LCM read key. When the self base is NOT readable, fall
-   * back to the default store — exactly what an unqualified, unauthorized recall
-   * resolves to — rather than injecting overlay rows the rest of recall excludes
-   * (rule 42 read/write parity; rule 48 least-privilege).
-   */
   lcmReadNamespaceForSession(sessionKey, principalOverride) {
-    const principal = typeof principalOverride === "string" && principalOverride.length > 0 ? principalOverride : this.resolvePrincipal(sessionKey);
-    const base = defaultNamespaceForPrincipal(principal, this.config);
-    const overlaid = this.applyCodingNamespaceOverlay(sessionKey, base);
-    if (overlaid === base) return this.config.defaultNamespace;
-    const selfReadableInRecall = recallNamespacesForPrincipal(
-      principal,
-      this.config
-    ).includes(base);
-    return selfReadableInRecall ? overlaid : this.config.defaultNamespace;
+    return (this.sessionContextCoordinator ?? new SessionContextCoordinator(
+      selfDeps(this)
+    )).lcmReadNamespaceForSession(
+      sessionKey,
+      principalOverride
+    );
   }
-  /**
-   * Attach a coding-agent context to a session (issue #569). Called by the
-   * Claude Code / Codex / Cursor connectors at session start after
-   * `resolveGitContext(cwd)`. The context is consulted by the recall path
-   * and the write path so that memories route to a project- (and optionally
-   * branch-) scoped namespace.
-   *
-   * Pass `null` to clear.
-   */
   setCodingContextForSession(sessionKey, codingContext) {
-    if (typeof sessionKey !== "string" || sessionKey.length === 0) return;
-    if (!this._codingContextBySession) {
-      this._codingContextBySession = /* @__PURE__ */ new Map();
-    }
-    if (codingContext === null) {
-      this._codingContextBySession.delete(sessionKey);
-      return;
-    }
-    this._codingContextBySession.set(sessionKey, codingContext);
+    return (this.sessionContextCoordinator ?? new SessionContextCoordinator(
+      selfDeps(this)
+    )).setCodingContextForSession(
+      sessionKey,
+      codingContext
+    );
   }
-  /**
-   * Read-only accessor for the coding context attached to a session. Returns
-   * `null` when none is set. Used by `remnic doctor` and by tests.
-   *
-   * Defensive `_codingContextBySession` lookup — legacy orchestrator-flush
-   * tests use `Object.create(Orchestrator.prototype)` which does not run
-   * class-field initializers, so the Map may be undefined on stubs.
-   */
   getCodingContextForSession(sessionKey) {
-    if (typeof sessionKey !== "string" || sessionKey.length === 0) return null;
-    return this._codingContextBySession?.get(sessionKey) ?? null;
+    return (this.sessionContextCoordinator ?? new SessionContextCoordinator(
+      selfDeps(this)
+    )).getCodingContextForSession(
+      sessionKey
+    );
   }
-  /**
-   * Shared helper used by both the recall path and the write path (rule 42).
-   *
-   * Given a base namespace computed from the principal, returns the overlaid
-   * coding namespace when the session has a coding context AND
-   * `codingMode.projectScope` is true AND `namespacesEnabled` is true.
-   * Otherwise returns `baseNamespace` unchanged — CLAUDE.md #30 escape hatch.
-   *
-   * Principal isolation (CLAUDE.md rule 42): the overlay is COMBINED with
-   * the principal-derived `baseNamespace` rather than replacing it, so two
-   * principals working in the same repository do not share memories through
-   * a common `project-*` namespace.
-   *
-   * Namespaces-disabled gate: when `namespacesEnabled` is false, the
-   * storage router maps every namespace to the same `memoryDir`. Returning
-   * `project-*` in that mode would create apparent route separation with
-   * no actual storage isolation — a false-isolation trap. In that mode we
-   * return `baseNamespace` unchanged so coding mode degrades to the existing
-   * unscoped behavior.
-   *
-   * @internal
-   */
   applyCodingNamespaceOverlay(sessionKey, baseNamespace) {
-    if (!resolveNamespaceCapabilities(this.config).namespaces) return baseNamespace;
-    const codingContext = this.getCodingContextForSession(sessionKey);
-    const overlay = resolveCodingNamespaceOverlay(codingContext, this.config.codingMode, this.config.defaultNamespace);
-    if (!overlay) return baseNamespace;
-    return combineNamespaces(baseNamespace, overlay.namespace);
+    return (this.sessionContextCoordinator ?? new SessionContextCoordinator(
+      selfDeps(this)
+    )).applyCodingNamespaceOverlay(
+      sessionKey,
+      baseNamespace
+    );
   }
-  /**
-   * Register a peer ID for a session so recall can inject the peer's
-   * profile into context (issue #679 PR 3/5). Pass `null` to clear.
-   *
-   * Connectors and the `before_agent_start` hook call this when the
-   * session's counter-party is known. The ID is validated against
-   * `PEER_ID_PATTERN` before storing.
-   *
-   * Fail-closed (Codex P1 review): an invalid peerId clears any
-   * previously registered mapping for the session rather than silently
-   * keeping stale data. This prevents a malformed metadata update from
-   * mixing one peer's profile context into another session.
-   *
-   * Defensive init (Cursor review + rule 16): `Object.create(
-   * Orchestrator.prototype)` stubs in legacy tests skip class-field
-   * initializers, so `_peerIdBySession` may be undefined. Mirror the
-   * same guard used by `setCodingContextForSession`.
-   */
-  setPeerIdForSession(sessionKey, peerId) {
-    if (typeof sessionKey !== "string" || sessionKey.length === 0) return;
-    if (!this._peerIdBySession) {
-      this._peerIdBySession = /* @__PURE__ */ new Map();
-    }
-    if (peerId === null) {
-      this._peerIdBySession.delete(sessionKey);
-      return;
-    }
-    if (typeof peerId !== "string" || peerId.length === 0 || peerId.length > 64 || !/^[A-Za-z0-9]+(?:[._-][A-Za-z0-9]+)*$/.test(peerId)) {
-      log.warn(`setPeerIdForSession: invalid peerId \u2014 clearing session mapping`);
-      this._peerIdBySession.delete(sessionKey);
-      return;
-    }
-    this._peerIdBySession.set(sessionKey, peerId);
+  setPeerIdForSession(sessionKey, peerId) {
+    return (this.sessionContextCoordinator ?? new SessionContextCoordinator(
+      selfDeps(this)
+    )).setPeerIdForSession(
+      sessionKey,
+      peerId
+    );
   }
-  /**
-   * Return the peer ID registered for a session, or `null` when none
-   * is set. Used by `recallInternal` to inject the peer profile section.
-   * Defensive `_peerIdBySession` lookup — legacy orchestrator-flush tests
-   * use `Object.create(Orchestrator.prototype)` which skips class-field
-   * initializers, so the Map may be undefined on stubs.
-   */
   getPeerIdForSession(sessionKey) {
-    if (typeof sessionKey !== "string" || sessionKey.length === 0) return null;
-    return this._peerIdBySession?.get(sessionKey) ?? null;
+    return (this.sessionContextCoordinator ?? new SessionContextCoordinator(
+      selfDeps(this)
+    )).getPeerIdForSession(
+      sessionKey
+    );
   }
   /**
    * Read-side overlay: returns the list of namespaces a session should read
@@ -15556,7 +15610,7 @@ var Orchestrator = class {
     const defaultNs = normalizeNamespaceIdentity(this.config.defaultNamespace);
     if (ns !== defaultNs && !isSafeRouteNamespace(ns)) return;
     if (!this.storageDirMatchesNamespaceHint(ns, storageDir)) return;
-    const resolvedStorageDir = path16.resolve(storageDir);
+    const resolvedStorageDir = path15.resolve(storageDir);
     let hints = this.namespaceStorageDirHints.get(resolvedStorageDir);
     if (!hints) {
       hints = /* @__PURE__ */ new Set();
@@ -15567,21 +15621,21 @@ var Orchestrator = class {
   storageDirMatchesNamespaceHint(namespace, storageDir) {
     const ns = normalizeNamespaceIdentity(namespace);
     if (!ns) return false;
-    const resolvedStorageDir = path16.resolve(storageDir);
-    const resolvedMemoryDir = path16.resolve(this.config.memoryDir);
+    const resolvedStorageDir = path15.resolve(storageDir);
+    const resolvedMemoryDir = path15.resolve(this.config.memoryDir);
     const defaultNs = normalizeNamespaceIdentity(this.config.defaultNamespace);
     if (resolvedStorageDir === resolvedMemoryDir) return ns === defaultNs;
-    const resolvedNamespacesDir = path16.join(resolvedMemoryDir, "namespaces");
+    const resolvedNamespacesDir = path15.join(resolvedMemoryDir, "namespaces");
     if (!isPathInsideStorageRoot(resolvedNamespacesDir, resolvedStorageDir)) return false;
-    const rawRoot = path16.resolve(resolvedNamespacesDir, ns);
-    const tokenRoot = path16.resolve(resolvedNamespacesDir, namespaceIdentityToken(ns));
+    const rawRoot = path15.resolve(resolvedNamespacesDir, ns);
+    const tokenRoot = path15.resolve(resolvedNamespacesDir, namespaceIdentityToken(ns));
     return resolvedStorageDir === rawRoot || resolvedStorageDir === tokenRoot;
   }
   namespaceStorageDirHintOwnershipRank(record, resolvedStorageDir, configured) {
-    if (resolvedStorageDir === path16.resolve(this.config.memoryDir)) {
+    if (resolvedStorageDir === path15.resolve(this.config.memoryDir)) {
       return record.namespace === normalizeNamespaceIdentity(this.config.defaultNamespace) ? 0 : 3;
     }
-    const leaf = path16.basename(resolvedStorageDir);
+    const leaf = path15.basename(resolvedStorageDir);
     const tokenOwnsRoot = namespaceIdentityToken(record.namespace) === leaf;
     if (tokenOwnsRoot && configured.has(record.namespace)) return 0;
     if (record.namespace === leaf) return 1;
@@ -15718,7 +15772,7 @@ var Orchestrator = class {
     this.config = config;
     this.profiler = new ProfilingCollector({
       enabled: resolvePipelineProcessingCapabilities(this.config).profiling,
-      storageDir: config.profilingStorageDir || path16.join(config.memoryDir, "profiling"),
+      storageDir: config.profilingStorageDir || path15.join(config.memoryDir, "profiling"),
       maxTraces: config.profilingMaxTraces
     });
     this.namespaceCatalog = new NamespaceCatalog(config);
@@ -15788,7 +15842,7 @@ var Orchestrator = class {
     this.compounding = resolveConsolidationCapabilities(config).compounding ? new CompoundingEngine(config, this.storage) : void 0;
     this.buffer = new SmartBuffer(config, this.storage);
     this.transcript = new TranscriptManager(config);
-    this.conversationIndexDir = path16.join(
+    this.conversationIndexDir = path15.join(
       config.memoryDir,
       "conversation-index",
       "chunks"
@@ -15924,7 +15978,7 @@ var Orchestrator = class {
       saveContentHashIndexes: () => this.saveContentHashIndexes()
     });
     this.threading = new ThreadingManager(
-      path16.join(config.memoryDir, "threads"),
+      path15.join(config.memoryDir, "threads"),
       config.threadingGapMinutes
     );
     const lifecycleCaps = resolveMemoryLifecycleCapabilities(config);
@@ -16242,24 +16296,11 @@ ${doc.content}` : doc.content,
     return this.runSemanticConsolidation({ ...options, force: true });
   }
   async runDeepSleepGovernanceNow(options) {
-    const targetStorage = options?.storage ?? this.storage;
-    const { runMemoryGovernance } = await import("./maintenance/memory-governance.js");
-    const { summarizeGovernanceResultForDreams } = await import("./dreams-ledger-6UODQOX6.js");
-    const govResult = await runMemoryGovernance({
-      memoryDir: targetStorage.dir,
-      mode: options?.dryRun === true ? "shadow" : "apply"
-    });
-    if (options?.dryRun !== true) {
-      try {
-        await this.processEntitySynthesisQueue(
-          this.storageDirNamespace(targetStorage.dir),
-          5
-        );
-      } catch (error) {
-        log.debug(`deep-sleep governance: entity synthesis refresh failed after apply: ${error}`);
-      }
-    }
-    return summarizeGovernanceResultForDreams(govResult, options?.dryRun === true);
+    return (this.sessionContextCoordinator ?? new SessionContextCoordinator(
+      selfDeps(this)
+    )).runDeepSleepGovernanceNow(
+      options
+    );
   }
   // Issue #1526 (seam 5): semantic consolidation moved to
   // SemanticConsolidationCoordinator. Thin delegation keeps all
@@ -16290,23 +16331,11 @@ ${doc.content}` : doc.content,
     return this.entitySynthesisCoordinator.processQueue(namespace, maxEntities);
   }
   async generateDaySummary(memories) {
-    if (this.initPromise) {
-      let initGateTimeoutHandle;
-      try {
-        await Promise.race([
-          this.initPromise.catch(() => void 0),
-          new Promise((resolve) => {
-            initGateTimeoutHandle = setTimeout(
-              resolve,
-              this.config.initGateTimeoutMs
-            );
-          })
-        ]);
-      } finally {
-        if (initGateTimeoutHandle) clearTimeout(initGateTimeoutHandle);
-      }
-    }
-    return this.extraction.generateDaySummary(memories);
+    return (this.sessionContextCoordinator ?? new SessionContextCoordinator(
+      selfDeps(this)
+    )).generateDaySummary(
+      memories
+    );
   }
   /**
    * Auto-gather today's facts and hourly summaries from storage, then generate a day summary.
@@ -16402,102 +16431,13 @@ ${doc.content}` : doc.content,
     return this.workspaceOpsCoordinator.validateLocalLlmModel();
   }
   async recall(prompt, sessionKey, options = {}) {
-    const caps = resolveCapabilities(this.config);
-    const graphCaps = resolveGraphConstructionCapabilities(this.config);
-    const abortController = new AbortController();
-    const onAbort = () => {
-      abortController.abort();
-    };
-    if (options.abortSignal?.aborted) {
-      abortController.abort();
-    } else {
-      options.abortSignal?.addEventListener("abort", onAbort, { once: true });
-    }
-    const principal = typeof options.principalOverride === "string" && options.principalOverride.length > 0 ? options.principalOverride : resolvePrincipal(sessionKey, this.config);
-    const namespacesEnabled = resolveNamespaceCapabilities(this.config).namespaces;
-    if (namespacesEnabled && !principal) {
-      throw new Error("authentication required: namespaces are enabled and no principal was supplied");
-    }
-    let initGateTimeoutHandle = null;
-    let onInitGateAbort = null;
-    if (this.initPromise) {
-      const gateResult = await Promise.race([
-        this.initPromise.then(() => "ok"),
-        new Promise((resolve) => {
-          initGateTimeoutHandle = setTimeout(
-            () => resolve("timeout"),
-            this.config.initGateTimeoutMs
-          );
-        }),
-        abortController.signal.aborted ? Promise.resolve("aborted") : new Promise((resolve) => {
-          onInitGateAbort = () => resolve("aborted");
-          abortController.signal.addEventListener(
-            "abort",
-            onInitGateAbort,
-            { once: true }
-          );
-        })
-      ]);
-      if (initGateTimeoutHandle) clearTimeout(initGateTimeoutHandle);
-      if (onInitGateAbort)
-        abortController.signal.removeEventListener("abort", onInitGateAbort);
-      if (gateResult === "aborted") {
-        this.logRecallFailure(abortRecallError("recall aborted before init"));
-        return "";
-      }
-      if (gateResult === "timeout") {
-        log.warn("recall: init gate timed out \u2014 proceeding without full init");
-      }
-    }
-    if (resolveRecallAuxiliaryCapabilities(this.config).secureStore && !this.storage.isSecureStoreUnlocked()) {
-      const lockedMsg = "[secure-store locked] Memory store is encrypted and locked. Unlock the secure-store inside this daemon process, or restart the daemon through a secure-store aware launcher that installs the key.";
-      log.warn("recall blocked: secure-store is locked");
-      return lockedMsg;
-    }
-    try {
-      const recallPromise = this.recallInternal(prompt, sessionKey, {
-        ...options,
-        abortSignal: abortController.signal
-      }, caps, graphCaps);
-      const RECALL_TIMEOUT_MS = this.config.recallOuterTimeoutMs ?? 75e3;
-      if (RECALL_TIMEOUT_MS <= 0) {
-        return await recallPromise;
-      }
-      let timeoutHandle = null;
-      const timeoutPromise = new Promise((_, reject) => {
-        timeoutHandle = setTimeout(() => {
-          abortController.abort();
-          reject(new Error("recall timeout"));
-        }, RECALL_TIMEOUT_MS);
-      });
-      let recallResult;
-      try {
-        recallResult = await Promise.race([recallPromise, timeoutPromise]);
-      } finally {
-        if (timeoutHandle) clearTimeout(timeoutHandle);
-      }
-      if (caps.recallDirectAnswer && sessionKey) {
-        try {
-          this.enqueueDirectAnswerObservation(
-            prompt,
-            sessionKey,
-            options.namespace?.trim() || void 0,
-            options.principalOverride,
-            caps,
-            namespacesEnabled
-          );
-        } catch (err) {
-          log.debug(`direct-answer observation setup failed: ${err}`);
-        }
-      }
-      return recallResult;
-    } catch (err) {
-      this.logRecallFailure(err);
-      this.profiler.endTrace();
-      return "";
-    } finally {
-      options.abortSignal?.removeEventListener("abort", onAbort);
-    }
+    return (this.recallEntryCoordinator ?? new RecallEntryCoordinator(
+      selfDeps(this)
+    )).recall(
+      prompt,
+      sessionKey,
+      options
+    );
   }
   /**
    * Return the most recent X-ray snapshot captured during a
@@ -16540,23 +16480,11 @@ ${doc.content}` : doc.content,
     );
   }
   logRecallFailure(err) {
-    const now = Date.now();
-    const errorMsg = err instanceof Error ? err.message : String(err);
-    const LOG_WINDOW_MS = 6e4;
-    const idleSinceLastFailureMs = now - this.lastRecallFailureAtMs;
-    this.lastRecallFailureAtMs = now;
-    if (idleSinceLastFailureMs >= LOG_WINDOW_MS) {
-      this.suppressedRecallFailures = 0;
-    }
-    if (now - this.lastRecallFailureLogAtMs >= LOG_WINDOW_MS) {
-      const suffix = this.suppressedRecallFailures > 0 ? ` (suppressed ${this.suppressedRecallFailures} similar failures in last minute)` : "";
-      log.warn(`recall timed out or failed: ${errorMsg}${suffix}`);
-      this.lastRecallFailureLogAtMs = now;
-      this.suppressedRecallFailures = 0;
-      return;
-    }
-    this.suppressedRecallFailures += 1;
-    log.debug(`recall timed out or failed (suppressed): ${errorMsg}`);
+    return (this.recallEntryCoordinator ?? new RecallEntryCoordinator(
+      selfDeps(this)
+    )).logRecallFailure(
+      err
+    );
   }
   artifactTypeForCategory(category) {
     if (category === "decision") return "decision";
@@ -16828,6 +16756,35 @@ ${doc.content}` : doc.content,
     }
     return this._namespaceReadFanoutCoordinator;
   }
+  /** RecallEntryCoordinator (issue #1526 seam 28). Lazy; selfDeps live wiring. */
+  _recallEntryCoordinator;
+  get recallEntryCoordinator() {
+    if (!this._recallEntryCoordinator) {
+      this._recallEntryCoordinator = new RecallEntryCoordinator(
+        selfDeps(this)
+      );
+    }
+    return this._recallEntryCoordinator;
+  }
+  /** SessionContextCoordinator (issue #1526 seam 28). Lazy; selfDeps live wiring. */
+  _sessionContextCoordinator;
+  /**
+   * Self-handle read through the selfDeps proxy (seam 28): coordinators
+   * that construct services against the orchestrator instance (e.g. the
+   * passive-correction CorrectionService) receive it via deps instead of
+   * capturing the coordinator's own `this`.
+   */
+  get orchestratorSelf() {
+    return this;
+  }
+  get sessionContextCoordinator() {
+    if (!this._sessionContextCoordinator) {
+      this._sessionContextCoordinator = new SessionContextCoordinator(
+        selfDeps(this)
+      );
+    }
+    return this._sessionContextCoordinator;
+  }
   async recallInternal(prompt, sessionKey, options = {}, caps = resolveCapabilities(this.config), graphCaps = resolveGraphConstructionCapabilities(this.config), lifecycleCaps = resolveMemoryLifecycleCapabilities(this.config)) {
     return this.recallInternalCoordinator.recallInternal(
       prompt,
@@ -16847,22 +16804,12 @@ ${doc.content}` : doc.content,
     );
   }
   async flushSession(sessionKey, options) {
-    const explicitBufferKey = typeof options.bufferKey === "string" && options.bufferKey.length > 0 ? options.bufferKey : null;
-    const discoveredBufferKeys = explicitBufferKey || typeof sessionKey !== "string" || sessionKey.length === 0 || typeof this.buffer.findBufferKeysForSession !== "function" ? [] : await this.buffer.findBufferKeysForSession(sessionKey);
-    const bufferKeys = explicitBufferKey ? [explicitBufferKey] : discoveredBufferKeys.length > 0 ? discoveredBufferKeys : typeof sessionKey === "string" && sessionKey.length > 0 ? [sessionKey] : ["default"];
-    for (const bufferKey of bufferKeys) {
-      const turns = this.buffer.getTurns(bufferKey);
-      if (turns.length === 0) continue;
-      await new Promise((resolve, reject) => {
-        void this.queueBufferedExtraction(turns, "trigger_mode", {
-          bufferKey,
-          clearBufferAfterExtraction: true,
-          skipDedupeCheck: true,
-          abortSignal: options.abortSignal,
-          onTaskSettled: (error) => error ? reject(error) : resolve()
-        }).catch(reject);
-      });
-    }
+    return (this.sessionContextCoordinator ?? new SessionContextCoordinator(
+      selfDeps(this)
+    )).flushSession(
+      sessionKey,
+      options
+    );
   }
   async ingestReplayBatch(turns, options = {}) {
     return this.turnIngestionCoordinator.ingestReplayBatch(
@@ -16923,52 +16870,10 @@ ${doc.content}` : doc.content,
       opts
     );
   }
-  /** Lazily construct the CorrectionService for passive capture. Stateless
-   *  across requests (per #1580 design); cached for the orchestrator's life. */
   passiveCorrectionService() {
-    if (this._passiveCorrectionService) return this._passiveCorrectionService;
-    this._passiveCorrectionService = createCorrectionService({
-      orchestrator: this,
-      // Session-scoped write ACL (review: "passive capture bypasses write
-      // ACL"). A correction detected in session S plans only against S readable
-      // namespaces and applies only to writable ones (rule 42) — passive
-      // capture never becomes a cross-tenant mutation vector. Mirrors the
-      // access-service createCorrectionService wiring rather than bypassing it.
-      resolveAuthorizedNamespace: async (req) => {
-        const principal = req.principal || resolvePrincipal(req.sessionKey, this.config);
-        const ns = req.namespace ?? defaultNamespaceForPrincipal(principal, this.config);
-        if (!canWriteNamespace(principal, ns, this.config)) {
-          throw new Error(
-            `passive correction: namespace "${ns}" is not writable for principal ${principal ?? "(none)"}`
-          );
-        }
-        return ns;
-      },
-      resolveReadableNamespaces: (req) => {
-        const principal = req.principal || resolvePrincipal(req.sessionKey, this.config);
-        return recallNamespacesForPrincipal(principal, this.config);
-      },
-      canWriteNamespace: async (req) => {
-        const principal = req.principal || resolvePrincipal(req.sessionKey, this.config);
-        return canWriteNamespace(principal, req.namespace, this.config);
-      },
-      llmComplete: async ({ system, user }) => {
-        const llmResult = await this.localLlm.chatCompletion(
-          [
-            { role: "system", content: system },
-            { role: "user", content: user }
-          ],
-          { operation: "correction-classify", priority: "background" }
-        );
-        if (!llmResult) {
-          throw new Error(
-            "passive correction classify+draft: local LLM unavailable (disabled or in cooldown)"
-          );
-        }
-        return llmResult.content;
-      }
-    });
-    return this._passiveCorrectionService;
+    return (this.sessionContextCoordinator ?? new SessionContextCoordinator(
+      selfDeps(this)
+    )).passiveCorrectionService();
   }
   async runExtraction(...args) {
     return this.extractionRunCoordinator.runExtraction(...args);
@@ -17156,33 +17061,17 @@ ${doc.content}` : doc.content,
     }
   }
   queueEvalShadowRecall(record) {
-    if (!resolveEvalCapabilities(this.config).evalHarness || !resolveEvalCapabilities(this.config).evalShadowMode)
-      return;
-    this.evalShadowWriteChain = this.evalShadowWriteChain.catch(() => void 0).then(async () => {
-      try {
-        await recordEvalShadowRecall({
-          memoryDir: this.config.memoryDir,
-          evalStoreDir: this.config.evalStoreDir,
-          record: {
-            schemaVersion: 1,
-            ...record
-          }
-        });
-      } catch (err) {
-        log.debug(`eval shadow recall write failed: ${err}`);
-      }
-    });
+    return (this.recallEntryCoordinator ?? new RecallEntryCoordinator(
+      selfDeps(this)
+    )).queueEvalShadowRecall(
+      record
+    );
   }
   publishRecallResults(options) {
-    const sectionId = "memories";
-    const trustByPath = options.trustByPath ?? null;
-    const injectable = trustByPath ? options.results.filter((r) => !trustByPath.get(r.path)?.quarantined) : options.results;
-    const memoryIds = this.extractMemoryIdsFromResults(injectable);
-    this.trackMemoryAccess(memoryIds);
-    this.appendRecallSection(
-      options.sectionBuckets,
-      sectionId,
-      this.formatQmdResults(options.title, injectable, options.sessionKey, trustByPath)
+    return (this.recallEntryCoordinator ?? new RecallEntryCoordinator(
+      selfDeps(this)
+    )).publishRecallResults(
+      options
     );
   }
   /**
@@ -17268,12 +17157,12 @@ ${doc.content}` : doc.content,
    */
   semanticDedupScopeFor(targetStorage) {
     if (!resolveNamespaceCapabilities(this.config).namespaces) return {};
-    const memoryDir = path16.resolve(this.config.memoryDir);
-    const storageDir = path16.resolve(targetStorage.dir);
+    const memoryDir = path15.resolve(this.config.memoryDir);
+    const storageDir = path15.resolve(targetStorage.dir);
     if (storageDir === memoryDir) {
       return { pathExcludePrefixes: ["namespaces/"] };
     }
-    let rel = path16.relative(memoryDir, storageDir);
+    let rel = path15.relative(memoryDir, storageDir);
     if (!rel || rel.startsWith("..")) {
       log.debug(
         `semantic dedup: target storage dir ${storageDir} is outside memoryDir ${memoryDir}; scoping lookup to absolute path prefix`
@@ -17963,9 +17852,9 @@ function readStructuralSymbol(entry) {
   const rec = entry;
   const symbol = typeof rec.symbol === "string" ? rec.symbol.trim() : "";
   if (!symbol) return null;
-  const path31 = typeof rec.path === "string" && rec.path.length > 0 ? rec.path : void 0;
+  const path30 = typeof rec.path === "string" && rec.path.length > 0 ? rec.path : void 0;
   const kind = typeof rec.kind === "string" && rec.kind.length > 0 ? rec.kind : void 0;
-  const item = path31 !== void 0 && kind !== void 0 ? { symbol, path: path31, kind } : path31 !== void 0 ? { symbol, path: path31 } : kind !== void 0 ? { symbol, kind } : { symbol };
+  const item = path30 !== void 0 && kind !== void 0 ? { symbol, path: path30, kind } : path30 !== void 0 ? { symbol, path: path30 } : kind !== void 0 ? { symbol, kind } : { symbol };
   return item;
 }
 function classifySpawnError(err) {
@@ -18039,7 +17928,7 @@ var DEFAULT_GRACE_PERIOD_DAYS = 7;
 
 // src/binary-lifecycle/backend.ts
 import fsp from "fs/promises";
-import path17 from "path";
+import path16 from "path";
 var FilesystemBackend = class {
   type = "filesystem";
   basePath;
@@ -18047,19 +17936,19 @@ var FilesystemBackend = class {
     if (!basePath || basePath.trim().length === 0) {
       throw new Error("FilesystemBackend requires a non-empty basePath");
     }
-    this.basePath = path17.resolve(basePath);
+    this.basePath = path16.resolve(basePath);
   }
   resolveRemotePath(remotePath) {
-    const resolved = path17.isAbsolute(remotePath) ? path17.resolve(remotePath) : path17.resolve(this.basePath, remotePath);
-    const relative = path17.relative(this.basePath, resolved);
-    if (relative === ".." || relative.startsWith(`..${path17.sep}`) || path17.isAbsolute(relative)) {
+    const resolved = path16.isAbsolute(remotePath) ? path16.resolve(remotePath) : path16.resolve(this.basePath, remotePath);
+    const relative = path16.relative(this.basePath, resolved);
+    if (relative === ".." || relative.startsWith(`..${path16.sep}`) || path16.isAbsolute(relative)) {
       throw new Error(`FilesystemBackend remotePath escapes basePath: ${JSON.stringify(remotePath)}`);
     }
     return resolved;
   }
   isInsideBase(candidate, realBase) {
-    const relative = path17.relative(realBase, candidate);
-    return relative === "" || relative !== ".." && !relative.startsWith(`..${path17.sep}`) && !path17.isAbsolute(relative);
+    const relative = path16.relative(realBase, candidate);
+    return relative === "" || relative !== ".." && !relative.startsWith(`..${path16.sep}`) && !path16.isAbsolute(relative);
   }
   async realBasePathIfExists() {
     try {
@@ -18088,13 +17977,13 @@ var FilesystemBackend = class {
   }
   async ensureSafeParentDirectory(dest) {
     const realBase = await this.ensureBaseDirectory();
-    const destDir = path17.dirname(dest);
-    const relativeDir = path17.relative(this.basePath, destDir);
-    const segments = relativeDir === "" ? [] : relativeDir.split(path17.sep);
+    const destDir = path16.dirname(dest);
+    const relativeDir = path16.relative(this.basePath, destDir);
+    const segments = relativeDir === "" ? [] : relativeDir.split(path16.sep);
     let current = this.basePath;
     for (const segment of segments) {
       if (segment === "." || segment === "") continue;
-      current = path17.join(current, segment);
+      current = path16.join(current, segment);
       try {
         const stat5 = await fsp.lstat(current);
         if (stat5.isSymbolicLink()) {
@@ -18122,13 +18011,13 @@ var FilesystemBackend = class {
     if (realBase === null) {
       return null;
     }
-    const destDir = path17.dirname(dest);
-    const relativeDir = path17.relative(this.basePath, destDir);
-    const segments = relativeDir === "" ? [] : relativeDir.split(path17.sep);
+    const destDir = path16.dirname(dest);
+    const relativeDir = path16.relative(this.basePath, destDir);
+    const segments = relativeDir === "" ? [] : relativeDir.split(path16.sep);
     let current = this.basePath;
     for (const segment of segments) {
       if (segment === "." || segment === "") continue;
-      current = path17.join(current, segment);
+      current = path16.join(current, segment);
       let stat5;
       try {
         stat5 = await fsp.lstat(current);
@@ -18176,7 +18065,7 @@ var FilesystemBackend = class {
     return dest;
   }
   async upload(localPath, remotePath) {
-    if (path17.isAbsolute(remotePath)) {
+    if (path16.isAbsolute(remotePath)) {
       throw new Error(`FilesystemBackend upload remotePath must be relative: ${JSON.stringify(remotePath)}`);
     }
     const dest = this.resolveRemotePath(remotePath);
@@ -18249,7 +18138,7 @@ function createBackend(cfg) {
 
 // src/binary-lifecycle/scanner.ts
 import fsp2 from "fs/promises";
-import path18 from "path";
+import path17 from "path";
 import crypto from "crypto";
 function matchesPatterns(filename, patterns) {
   const lower = filename.toLowerCase();
@@ -18274,8 +18163,8 @@ async function scanForBinaries(memoryDir, config, manifest) {
       return;
     }
     for (const entry of entries) {
-      const fullPath = path18.join(dir, entry.name);
-      const relativePath = path18.relative(memoryDir, fullPath).split(path18.sep).join("/");
+      const fullPath = path17.join(dir, entry.name);
+      const relativePath = path17.relative(memoryDir, fullPath).split(path17.sep).join("/");
       if (entry.isDirectory()) {
         if (entry.name === ".binary-lifecycle") continue;
         await walk(fullPath);
@@ -18315,15 +18204,15 @@ async function hashFile(filePath) {
 
 // src/binary-lifecycle/manifest.ts
 import fsp3 from "fs/promises";
-import path19 from "path";
+import path18 from "path";
 import crypto2 from "crypto";
 var MANIFEST_DIR = ".binary-lifecycle";
 var MANIFEST_FILE = "manifest.json";
 function manifestDir(memoryDir) {
-  return path19.join(memoryDir, MANIFEST_DIR);
+  return path18.join(memoryDir, MANIFEST_DIR);
 }
 function manifestPath(memoryDir) {
-  return path19.join(memoryDir, MANIFEST_DIR, MANIFEST_FILE);
+  return path18.join(memoryDir, MANIFEST_DIR, MANIFEST_FILE);
 }
 async function readManifest(memoryDir) {
   const filePath = manifestPath(memoryDir);
@@ -18375,7 +18264,7 @@ function emptyManifest() {
 
 // src/binary-lifecycle/pipeline.ts
 import fsp4 from "fs/promises";
-import path20 from "path";
+import path19 from "path";
 import crypto3 from "crypto";
 async function hashFile2(filePath) {
   const content = await fsp4.readFile(filePath);
@@ -18398,13 +18287,13 @@ function escapeRegex(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function resolveManifestAssetPath(memoryDir, originalPath) {
-  if (originalPath.length === 0 || originalPath.includes("\0") || originalPath.includes("\\") || path20.isAbsolute(originalPath) || path20.win32.isAbsolute(originalPath)) {
+  if (originalPath.length === 0 || originalPath.includes("\0") || originalPath.includes("\\") || path19.isAbsolute(originalPath) || path19.win32.isAbsolute(originalPath)) {
     return null;
   }
-  const memoryRoot = path20.resolve(memoryDir);
-  const fullPath = path20.resolve(memoryRoot, originalPath);
-  const relative = path20.relative(memoryRoot, fullPath);
-  if (relative === "" || relative === ".." || relative.startsWith(`..${path20.sep}`) || path20.isAbsolute(relative)) {
+  const memoryRoot = path19.resolve(memoryDir);
+  const fullPath = path19.resolve(memoryRoot, originalPath);
+  const relative = path19.relative(memoryRoot, fullPath);
+  if (relative === "" || relative === ".." || relative.startsWith(`..${path19.sep}`) || path19.isAbsolute(relative)) {
     return null;
   }
   return fullPath;
@@ -18415,7 +18304,7 @@ function validateBinaryLifecycleConfig(config) {
   }
 }
 function remotePathForAsset(backend, relPath) {
-  const normalized = relPath.split(path20.sep).join("/");
+  const normalized = relPath.split(path19.sep).join("/");
   if (backend.type === "filesystem") {
     return `.binary-lifecycle/mirrors/${normalized}`;
   }
@@ -18428,11 +18317,11 @@ async function stageMirror(memoryDir, newPaths, backend, assets, log2, dryRun) {
   let mirrored = 0;
   const errors = [];
   for (const relPath of newPaths) {
-    const fullPath = path20.join(memoryDir, relPath);
+    const fullPath = path19.join(memoryDir, relPath);
     try {
       const stat5 = await fsp4.stat(fullPath);
       const contentHash = await hashFile2(fullPath);
-      const ext = path20.extname(relPath);
+      const ext = path19.extname(relPath);
       const mimeType = guessMimeType(ext);
       const remotePath = remotePathForAsset(backend, relPath);
       let backendLocation = remotePath;
@@ -18632,10 +18521,10 @@ async function countRemainingLocalReferences(memoryDir, asset, assetAbsolute, md
   return { remaining, errors };
 }
 function markdownReferencePattern(asset, assetAbsolute, mdPath) {
-  const mdDir = path20.dirname(mdPath);
+  const mdDir = path19.dirname(mdPath);
   const candidates = /* @__PURE__ */ new Set();
   const addCandidate = (candidate) => {
-    const normalized = candidate.split(path20.sep).join("/");
+    const normalized = candidate.split(path19.sep).join("/");
     if (normalized.length === 0) return;
     candidates.add(normalized);
     const isParentTraversal = normalized === ".." || normalized.startsWith("../");
@@ -18643,10 +18532,10 @@ function markdownReferencePattern(asset, assetAbsolute, mdPath) {
       candidates.add(`./${normalized}`);
     }
   };
-  addCandidate(path20.relative(mdDir, assetAbsolute));
-  const originalPath = asset.originalPath.split(path20.sep).join("/");
-  const originalAsFileRelative = path20.resolve(mdDir, ...originalPath.split("/"));
-  if (path20.resolve(originalAsFileRelative) === path20.resolve(assetAbsolute)) {
+  addCandidate(path19.relative(mdDir, assetAbsolute));
+  const originalPath = asset.originalPath.split(path19.sep).join("/");
+  const originalAsFileRelative = path19.resolve(mdDir, ...originalPath.split("/"));
+  if (path19.resolve(originalAsFileRelative) === path19.resolve(assetAbsolute)) {
     addCandidate(originalPath);
   }
   addCandidate(`/${originalPath}`);
@@ -18742,7 +18631,7 @@ async function findMarkdownFiles(dir) {
       return;
     }
     for (const entry of entries) {
-      const full = path20.join(current, entry.name);
+      const full = path19.join(current, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === ".binary-lifecycle") continue;
         await walk(full);
@@ -18817,7 +18706,7 @@ async function runBinaryLifecyclePipeline(memoryDir, config, backend, log2, opts
 
 // src/projection/index.ts
 import fs from "fs";
-import path21 from "path";
+import path20 from "path";
 var VALID_PROJECTION_CATEGORIES = new Set(ALL_CATEGORY_KEYS);
 async function generateContextTree(options) {
   const startTime = Date.now();
@@ -18832,8 +18721,8 @@ async function generateContextTree(options) {
   let nodesGenerated = 0;
   let nodesSkipped = 0;
   const categoryCounts = {};
-  const resolvedMemoryDir = path21.resolve(memoryDir);
-  const resolvedOutputDir = path21.resolve(outputDir);
+  const resolvedMemoryDir = path20.resolve(memoryDir);
+  const resolvedOutputDir = path20.resolve(outputDir);
   const requestedCategories = validateProjectionCategories(filterCategories);
   const realMemoryDir = assertSafeMemoryRoot(resolvedMemoryDir);
   assertNotSymlink(resolvedOutputDir, "context tree outputDir");
@@ -18871,7 +18760,7 @@ async function generateContextTree(options) {
     }
   }
   if (includeEntities) {
-    const entitiesDir = path21.join(memoryDir, "entities");
+    const entitiesDir = path20.join(memoryDir, "entities");
     if (fs.existsSync(entitiesDir)) {
       assertSafeInputRoot(realMemoryDir, entitiesDir, "entities root");
       categoryCounts["entity"] = 0;
@@ -18883,7 +18772,7 @@ async function generateContextTree(options) {
           continue;
         }
         const content = fs.readFileSync(filePath, "utf8");
-        const fileName = path21.basename(filePath, ".md");
+        const fileName = path20.basename(filePath, ".md");
         const node = projectEntityNode(fileName, content);
         const outputPath = resolveContainedOutputPath(realOutputDir, "entities", `${fileName}.md`);
         writeProjectedContent(realOutputDir, outputPath, node.content);
@@ -18895,7 +18784,7 @@ async function generateContextTree(options) {
   }
   const shouldIncludeQuestions = includeQuestions && (requestedCategories === void 0 || requestedCategories.includes("question"));
   if (shouldIncludeQuestions) {
-    const questionsDir = path21.join(memoryDir, "questions");
+    const questionsDir = path20.join(memoryDir, "questions");
     if (fs.existsSync(questionsDir)) {
       assertSafeInputRoot(realMemoryDir, questionsDir, "questions root");
       categoryCounts["question"] = 0;
@@ -18936,8 +18825,8 @@ async function generateContextTree(options) {
   };
 }
 function isPathInside(root, candidate) {
-  const relative = path21.relative(root, candidate);
-  return relative === "" || !relative.startsWith("..") && !path21.isAbsolute(relative);
+  const relative = path20.relative(root, candidate);
+  return relative === "" || !relative.startsWith("..") && !path20.isAbsolute(relative);
 }
 function assertNotSymlink(targetPath, label) {
   try {
@@ -18974,12 +18863,12 @@ function assertSafeInputRoot(realMemoryDir, targetPath, label) {
 }
 function assertSafeOutputTarget(realOutputDir, outputPath) {
   let current = realOutputDir;
-  const relative = path21.relative(realOutputDir, outputPath);
-  if (relative.startsWith("..") || path21.isAbsolute(relative)) {
+  const relative = path20.relative(realOutputDir, outputPath);
+  if (relative.startsWith("..") || path20.isAbsolute(relative)) {
     throw new Error(`context tree output path escapes outputDir: ${outputPath}`);
   }
-  for (const segment of relative.split(path21.sep).filter(Boolean)) {
-    current = path21.join(current, segment);
+  for (const segment of relative.split(path20.sep).filter(Boolean)) {
+    current = path20.join(current, segment);
     try {
       const stat5 = fs.lstatSync(current);
       if (stat5.isSymbolicLink()) {
@@ -19009,17 +18898,17 @@ function validateProjectionCategories(categories) {
   return validated;
 }
 function resolveContainedOutputPath(outputRoot, ...segments) {
-  const resolved = path21.resolve(outputRoot, ...segments);
-  const relative = path21.relative(outputRoot, resolved);
-  if (relative === "" || !relative.startsWith("..") && !path21.isAbsolute(relative)) {
+  const resolved = path20.resolve(outputRoot, ...segments);
+  const relative = path20.relative(outputRoot, resolved);
+  if (relative === "" || !relative.startsWith("..") && !path20.isAbsolute(relative)) {
     return resolved;
   }
   throw new Error(`context tree output path escapes outputDir: ${segments.join("/")}`);
 }
 function writeProjectedContent(realOutputDir, outputPath, generatedContent) {
   assertSafeOutputTarget(realOutputDir, outputPath);
-  fs.mkdirSync(path21.dirname(outputPath), { recursive: true });
-  const realParent = fs.realpathSync(path21.dirname(outputPath));
+  fs.mkdirSync(path20.dirname(outputPath), { recursive: true });
+  const realParent = fs.realpathSync(path20.dirname(outputPath));
   if (!isPathInside(realOutputDir, realParent)) {
     throw new Error(`context tree output path escapes outputDir: ${outputPath}`);
   }
@@ -19058,7 +18947,7 @@ function walkR(dir, realMemoryDir) {
   const results = [];
   function walk(directory) {
     for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
-      const fullPath = path21.join(directory, entry.name);
+      const fullPath = path20.join(directory, entry.name);
       if (entry.isSymbolicLink()) {
         throw new Error(`context tree input path contains symlink: ${fullPath}`);
       }
@@ -19111,13 +19000,13 @@ function extractBody(content) {
 }
 function projectNode(filePath, category, fm, rawContent) {
   const body = extractBody(rawContent);
-  const fileName = path21.basename(filePath, ".md");
-  const dateDir = path21.basename(path21.dirname(filePath));
+  const fileName = path20.basename(filePath, ".md");
+  const dateDir = path20.basename(path20.dirname(filePath));
   let relPath;
   if (/^\d{4}-\d{2}-\d{2}$/.test(dateDir)) {
-    relPath = path21.join(category, dateDir, `${fileName}.md`);
+    relPath = path20.join(category, dateDir, `${fileName}.md`);
   } else {
-    relPath = path21.join(category, `${fileName}.md`);
+    relPath = path20.join(category, `${fileName}.md`);
   }
   const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
   const md = `# ${fm.id}
@@ -19163,7 +19052,7 @@ function projectEntityNode(fileName, content) {
 ${content}
 `;
   return {
-    path: path21.join("entities", `${fileName}.md`),
+    path: path20.join("entities", `${fileName}.md`),
     category: "entity",
     title: fileName,
     content: md,
@@ -19216,7 +19105,7 @@ function generateIndex(categoryCounts, outputDir) {
 
 // src/onboarding/index.ts
 import fs2 from "fs";
-import path22 from "path";
+import path21 from "path";
 var LANGUAGE_RULES = [
   {
     language: "TypeScript",
@@ -19318,7 +19207,7 @@ function onboard(options) {
     maxDepth = 6,
     excludeDirs = []
   } = options;
-  const directory = path22.resolve(options.directory ?? process.cwd());
+  const directory = path21.resolve(options.directory ?? process.cwd());
   let rootStat;
   try {
     rootStat = fs2.statSync(directory);
@@ -19360,7 +19249,7 @@ function walkDir(root, exclude, maxDepth) {
     }
     for (const entry of entries) {
       if (exclude.has(entry.name)) continue;
-      const fullPath = path22.join(dir, entry.name);
+      const fullPath = path21.join(dir, entry.name);
       if (entry.isDirectory()) {
         walk(fullPath, depth + 1);
       } else if (entry.isFile()) {
@@ -19375,11 +19264,11 @@ function detectLanguages(files, root) {
   const results = [];
   const extCounts = /* @__PURE__ */ new Map();
   for (const f of files) {
-    const ext = path22.extname(f).toLowerCase();
+    const ext = path21.extname(f).toLowerCase();
     if (ext) extCounts.set(ext, (extCounts.get(ext) ?? 0) + 1);
   }
   const rootFiles = new Set(
-    files.filter((f) => path22.dirname(f) === root).map((f) => path22.basename(f))
+    files.filter((f) => path21.dirname(f) === root).map((f) => path21.basename(f))
   );
   for (const rule of LANGUAGE_RULES) {
     const evidence = [];
@@ -19423,7 +19312,7 @@ function detectLanguages(files, root) {
 }
 function detectShape(files, root) {
   const rootFiles = new Set(
-    files.filter((f) => path22.dirname(f) === root).map((f) => path22.basename(f))
+    files.filter((f) => path21.dirname(f) === root).map((f) => path21.basename(f))
   );
   const rootDirs = /* @__PURE__ */ new Set();
   try {
@@ -19434,7 +19323,7 @@ function detectShape(files, root) {
   }
   const evidence = [];
   if (rootFiles.has("package.json")) {
-    const pkg = readJsonSafe(path22.join(root, "package.json"));
+    const pkg = readJsonSafe(path21.join(root, "package.json"));
     if (pkg?.workspaces) {
       evidence.push("package.json has workspaces");
       return { shape: "monorepo", evidence };
@@ -19448,13 +19337,13 @@ function detectShape(files, root) {
     evidence.push("workspace manifest found");
     return { shape: "workspace", evidence };
   }
-  const cargoToml = readTomlWorkspace(path22.join(root, "Cargo.toml"));
+  const cargoToml = readTomlWorkspace(path21.join(root, "Cargo.toml"));
   if (cargoToml) {
     evidence.push("Cargo.toml has workspace");
     return { shape: "workspace", evidence };
   }
   if (rootFiles.has("package.json")) {
-    const pkg = readJsonSafe(path22.join(root, "package.json"));
+    const pkg = readJsonSafe(path21.join(root, "package.json"));
     if (pkg?.exports || pkg?.main) {
       if (pkg?.bin) {
         evidence.push("package.json has bin");
@@ -19488,8 +19377,8 @@ function discoverDocs(files, root) {
     { pattern: /^\.editorconfig$/i, kind: "config" }
   ];
   for (const filePath of files) {
-    const basename = path22.basename(filePath).toLowerCase();
-    const relPath = path22.relative(root, filePath);
+    const basename = path21.basename(filePath).toLowerCase();
+    const relPath = path21.relative(root, filePath);
     let kind;
     for (const { pattern, kind: k } of docPatterns) {
       if (pattern.test(basename)) {
@@ -19501,7 +19390,7 @@ function discoverDocs(files, root) {
       kind = "docs";
     }
     if (!kind && (basename.endsWith(".md") || basename.endsWith(".mdx"))) {
-      if (path22.dirname(relPath) === "." || isUnderDocsDir(relPath)) {
+      if (path21.dirname(relPath) === "." || isUnderDocsDir(relPath)) {
         kind = "docs";
       }
     }
@@ -19522,7 +19411,7 @@ function discoverDocs(files, root) {
   return docs;
 }
 function isUnderDocsDir(relPath) {
-  const parts = relPath.split(path22.sep);
+  const parts = relPath.split(path21.sep);
   return parts[0] === "docs" || parts[0] === "doc" || parts[0] === "documentation";
 }
 function buildPlan(languages, shape, docs, _root) {
@@ -19566,7 +19455,7 @@ function readTomlWorkspace(filePath) {
 
 // src/curation/index.ts
 import fs3 from "fs";
-import path23 from "path";
+import path22 from "path";
 import crypto4 from "crypto";
 async function curate(options) {
   const startTime = Date.now();
@@ -19657,12 +19546,12 @@ function resolveTargets(targetPath) {
   const extensions = /* @__PURE__ */ new Set([".md", ".txt", ".mdx", ".rst"]);
   function walk(dir) {
     for (const entry of fs3.readdirSync(dir, { withFileTypes: true })) {
-      const fullPath = path23.join(dir, entry.name);
+      const fullPath = path22.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (entry.name !== "node_modules" && entry.name !== ".git") {
           walk(fullPath);
         }
-      } else if (extensions.has(path23.extname(entry.name).toLowerCase())) {
+      } else if (extensions.has(path22.extname(entry.name).toLowerCase())) {
         results.push(fullPath);
       }
     }
@@ -19671,12 +19560,12 @@ function resolveTargets(targetPath) {
   return results;
 }
 function resolveProvenanceRoot(targetPath) {
-  const resolvedTarget = path23.resolve(targetPath);
+  const resolvedTarget = path22.resolve(targetPath);
   const stat5 = fs3.statSync(resolvedTarget);
-  return stat5.isFile() ? path23.dirname(resolvedTarget) : resolvedTarget;
+  return stat5.isFile() ? path22.dirname(resolvedTarget) : resolvedTarget;
 }
 function extractStatements(content, filePath, projectRoot, source, sourceFileHash, categoryOverride, confidence, entityRef, tags) {
-  const relativePath = path23.relative(projectRoot, path23.resolve(filePath)) || path23.basename(filePath);
+  const relativePath = path22.relative(projectRoot, path22.resolve(filePath)) || path22.basename(filePath);
   const statements = [];
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const paragraphs = content.split(/\n{2,}/).map((p) => p.trim()).filter((p) => p.length > 20 && p.length < 2e3);
@@ -19770,7 +19659,7 @@ function loadExistingMemories(memoryDir) {
   if (!fs3.existsSync(memoryDir)) return result;
   const dirs = ALL_CATEGORY_DIRS;
   for (const dir of dirs) {
-    const fullDir = path23.join(memoryDir, dir);
+    const fullDir = path22.join(memoryDir, dir);
     if (!fs3.existsSync(fullDir)) continue;
     walkFiles(fullDir, (filePath) => {
       const content = readFileSafe(filePath);
@@ -19792,10 +19681,10 @@ function writeStatement(stmt, memoryDir) {
   const now = /* @__PURE__ */ new Date();
   const dateDir = now.toISOString().split("T")[0];
   const categoryDir = getCategoryDir(memoryDir, stmt.category);
-  const dir = path23.join(categoryDir, dateDir);
+  const dir = path22.join(categoryDir, dateDir);
   fs3.mkdirSync(dir, { recursive: true });
   const fileName = `${stmt.category}-${Date.now()}-${stmt.id.slice(0, 8)}.md`;
-  const filePath = path23.join(dir, fileName);
+  const filePath = path22.join(dir, fileName);
   const frontmatter = [
     "---",
     `id: ${stmt.id}`,
@@ -19862,7 +19751,7 @@ function extractBody2(content) {
 }
 function walkFiles(dir, callback) {
   for (const entry of fs3.readdirSync(dir, { withFileTypes: true })) {
-    const fullPath = path23.join(dir, entry.name);
+    const fullPath = path22.join(dir, entry.name);
     if (entry.isDirectory()) {
       walkFiles(fullPath, callback);
     } else if (entry.name.endsWith(".md")) {
@@ -19873,7 +19762,7 @@ function walkFiles(dir, callback) {
 
 // src/dedup/index.ts
 import fs4 from "fs";
-import path24 from "path";
+import path23 from "path";
 import crypto5 from "crypto";
 var DEFAULT_DEDUP_THRESHOLD = 0.85;
 var DEFAULT_MAX_LOAD = 1e4;
@@ -20015,7 +19904,7 @@ function loadMemories(memoryDir, categories, maxLoad = 1e4) {
   const memoryRootReal = fs4.realpathSync(memoryDir);
   for (const category of allCategories) {
     if (result.length >= maxLoad) break;
-    const dir = path24.join(memoryDir, category);
+    const dir = path23.join(memoryDir, category);
     if (!fs4.existsSync(dir)) continue;
     const categoryStat = fs4.lstatSync(dir);
     if (categoryStat.isSymbolicLink()) {
@@ -20076,15 +19965,15 @@ function extractBody3(content) {
   return match ? match[1].trim() : content.trim();
 }
 function assertPathInsideRoot2(rootReal, targetReal, sourcePath) {
-  const rel = path24.relative(rootReal, targetReal);
-  if (rel === "" || !rel.startsWith("..") && !path24.isAbsolute(rel)) {
+  const rel = path23.relative(rootReal, targetReal);
+  if (rel === "" || !rel.startsWith("..") && !path23.isAbsolute(rel)) {
     return;
   }
   throw new Error(`Refusing to scan memory path outside root: ${sourcePath}`);
 }
 function walkMdFiles(dir, memoryRootReal, categoryRootReal, callback) {
   for (const entry of fs4.readdirSync(dir, { withFileTypes: true })) {
-    const fullPath = path24.join(dir, entry.name);
+    const fullPath = path23.join(dir, entry.name);
     const entryStat = fs4.lstatSync(fullPath);
     if (entryStat.isSymbolicLink()) {
       throw new Error(`Refusing to scan symlinked memory path: ${fullPath}`);
@@ -20102,7 +19991,7 @@ function walkMdFiles(dir, memoryRootReal, categoryRootReal, callback) {
 
 // src/review/index.ts
 import fs5 from "fs";
-import path25 from "path";
+import path24 from "path";
 var DEFAULT_CONFIDENCE_THRESHOLD = 0.7;
 function realMemoryRoot(memoryDir) {
   try {
@@ -20114,8 +20003,8 @@ function realMemoryRoot(memoryDir) {
   }
 }
 function isPathInside2(rootReal, candidateReal) {
-  const relative = path25.relative(rootReal, candidateReal);
-  return relative === "" || !!relative && !relative.startsWith("..") && !path25.isAbsolute(relative);
+  const relative = path24.relative(rootReal, candidateReal);
+  return relative === "" || !!relative && !relative.startsWith("..") && !path24.isAbsolute(relative);
 }
 function isSafeDirectory(rootReal, dir) {
   try {
@@ -20158,7 +20047,7 @@ function listReviewItems(options) {
     if (filterReason && item.reviewReason !== filterReason) return;
     items.push(item);
   };
-  const suggestionsDir = path25.join(memoryDir, "suggestions");
+  const suggestionsDir = path24.join(memoryDir, "suggestions");
   if (!isLimitReached() && fs5.existsSync(suggestionsDir) && isSafeDirectory(rootReal, suggestionsDir)) {
     walkMd(rootReal, suggestionsDir, (filePath, content) => {
       if (isLimitReached()) return true;
@@ -20179,7 +20068,7 @@ function listReviewItems(options) {
       return isLimitReached();
     });
   }
-  const reviewDir = path25.join(memoryDir, "review");
+  const reviewDir = path24.join(memoryDir, "review");
   if (!isLimitReached() && fs5.existsSync(reviewDir) && isSafeDirectory(rootReal, reviewDir)) {
     walkMd(rootReal, reviewDir, (filePath, content) => {
       if (isLimitReached()) return true;
@@ -20204,7 +20093,7 @@ function listReviewItems(options) {
   const categories = ALL_CATEGORY_DIRS;
   for (const category of categories) {
     if (isLimitReached()) break;
-    const dir = path25.join(memoryDir, category);
+    const dir = path24.join(memoryDir, category);
     if (!fs5.existsSync(dir) || !isSafeDirectory(rootReal, dir)) continue;
     walkMd(rootReal, dir, (filePath, content) => {
       if (isLimitReached()) return true;
@@ -20289,8 +20178,8 @@ function approveItem(memoryDir, itemId, options) {
   const targetDir = getCategoryDir(memoryDir, category);
   const dateDir = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
   ensureSafeDirectory(rootReal, targetDir);
-  const outputPath = path25.join(targetDir, dateDir, path25.basename(found.filePath));
-  ensureSafeDirectory(rootReal, path25.dirname(outputPath));
+  const outputPath = path24.join(targetDir, dateDir, path24.basename(found.filePath));
+  ensureSafeDirectory(rootReal, path24.dirname(outputPath));
   const promotedPath = writeFileWithoutClobber(outputPath, updatedContent, itemId);
   fs5.unlinkSync(found.filePath);
   return {
@@ -20348,13 +20237,13 @@ function findReviewFileById(memoryDir, id, options = {}) {
   const rootReal = realMemoryRoot(memoryDir);
   if (!rootReal) return null;
   for (const loc of ["suggestions", "review"]) {
-    const dir = path25.join(memoryDir, loc);
+    const dir = path24.join(memoryDir, loc);
     if (!fs5.existsSync(dir) || !isSafeDirectory(rootReal, dir)) continue;
     const found = findFileById(rootReal, dir, id);
     if (found) return { filePath: found, location: "queue" };
   }
   for (const category of ALL_CATEGORY_DIRS) {
-    const dir = path25.join(memoryDir, category);
+    const dir = path24.join(memoryDir, category);
     if (!fs5.existsSync(dir) || !isSafeDirectory(rootReal, dir)) continue;
     const found = findFileById(rootReal, dir, id, (fm) => isLowConfidenceReviewCandidate(fm, options));
     if (found) return { filePath: found, location: "category" };
@@ -20430,10 +20319,10 @@ function readFileSafe3(filePath) {
   }
 }
 function writeFileWithoutClobber(basePath, content, discriminator) {
-  const parsed = path25.parse(basePath);
+  const parsed = path24.parse(basePath);
   const safeDiscriminator = sanitizeFilePart(discriminator);
   for (let attempt = 0; attempt < 1e3; attempt++) {
-    const candidate = attempt === 0 ? basePath : path25.join(
+    const candidate = attempt === 0 ? basePath : path24.join(
       parsed.dir,
       `${parsed.name}-${safeDiscriminator}${attempt === 1 ? "" : `-${attempt}`}${parsed.ext || ".md"}`
     );
@@ -20489,7 +20378,7 @@ function extractBody4(content) {
 function walkMd(rootReal, dir, callback) {
   if (!isSafeDirectory(rootReal, dir)) return false;
   for (const entry of fs5.readdirSync(dir, { withFileTypes: true })) {
-    const fullPath = path25.join(dir, entry.name);
+    const fullPath = path24.join(dir, entry.name);
     if (entry.isSymbolicLink()) continue;
     if (entry.isDirectory()) {
       if (walkMd(rootReal, fullPath, callback)) return true;
@@ -20504,7 +20393,7 @@ function walkMdPaths(rootReal, dir) {
   const results = [];
   if (!isSafeDirectory(rootReal, dir)) return results;
   for (const entry of fs5.readdirSync(dir, { withFileTypes: true })) {
-    const fullPath = path25.join(dir, entry.name);
+    const fullPath = path24.join(dir, entry.name);
     if (entry.isSymbolicLink()) continue;
     if (entry.isDirectory()) {
       results.push(...walkMdPaths(rootReal, fullPath));
@@ -20517,7 +20406,7 @@ function walkMdPaths(rootReal, dir) {
 
 // src/sync/index.ts
 import fs6 from "fs";
-import path26 from "path";
+import path25 from "path";
 import crypto6 from "crypto";
 var DEFAULT_EXTENSIONS = /* @__PURE__ */ new Set([".md", ".txt", ".mdx", ".rst"]);
 var DEFAULT_EXCLUDE2 = /* @__PURE__ */ new Set([
@@ -20539,7 +20428,7 @@ function syncChanges(options) {
   } = options;
   const extSet = new Set(extensions);
   const excludeSet = /* @__PURE__ */ new Set([...DEFAULT_EXCLUDE2, ...excludeDirs]);
-  const stateFilePath = options.stateFile ?? path26.join(memoryDir, ".sync-state.json");
+  const stateFilePath = options.stateFile ?? path25.join(memoryDir, ".sync-state.json");
   const prevState = loadState(stateFilePath);
   const currentFiles = scanFiles(sourceDir, extSet, excludeSet);
   const changes = computeDiff(currentFiles, prevState.fileHashes, sourceDir);
@@ -20555,7 +20444,7 @@ function syncChanges(options) {
     for (const [relPath, hash] of Object.entries(currentFiles)) {
       newState.fileHashes[relPath] = hash;
     }
-    fs6.mkdirSync(path26.dirname(stateFilePath), { recursive: true });
+    fs6.mkdirSync(path25.dirname(stateFilePath), { recursive: true });
     fs6.writeFileSync(stateFilePath, JSON.stringify(newState, null, 2));
   }
   return {
@@ -20621,13 +20510,13 @@ function scanFiles(root, extensions, exclude) {
     }
     for (const entry of entries) {
       if (exclude.has(entry.name)) continue;
-      const fullPath = path26.join(dir, entry.name);
+      const fullPath = path25.join(dir, entry.name);
       if (entry.isDirectory()) {
         walk(fullPath);
       } else if (entry.isFile()) {
-        const ext = path26.extname(entry.name).toLowerCase();
+        const ext = path25.extname(entry.name).toLowerCase();
         if (!extensions.has(ext)) continue;
-        const relPath = path26.relative(root, fullPath);
+        const relPath = path25.relative(root, fullPath);
         try {
           const content = fs6.readFileSync(fullPath, "utf8");
           result[relPath] = hashContent3(content);
@@ -20642,7 +20531,7 @@ function scanFiles(root, extensions, exclude) {
 function computeDiff(current, previous, sourceDir) {
   const changes = [];
   for (const [relPath, hash] of Object.entries(current)) {
-    const fullPath = path26.join(sourceDir, relPath);
+    const fullPath = path25.join(sourceDir, relPath);
     if (!(relPath in previous)) {
       let size = 0;
       try {
@@ -20675,7 +20564,7 @@ function computeDiff(current, previous, sourceDir) {
   for (const relPath of Object.keys(previous)) {
     if (!(relPath in current)) {
       changes.push({
-        filePath: path26.join(sourceDir, relPath),
+        filePath: path25.join(sourceDir, relPath),
         relativePath: relPath,
         type: "deleted",
         currentHash: "",
@@ -20705,20 +20594,20 @@ function hashContent3(content) {
 import { spawnSync } from "child_process";
 import crypto7 from "crypto";
 import fs7 from "fs";
-import path27 from "path";
+import path26 from "path";
 var MANIFEST_VERSION = 1;
 var MANIFEST_LOCK_STALE_MS = 3e4;
 var MANIFEST_LOCK_TIMEOUT_MS = MANIFEST_LOCK_STALE_MS + 1e4;
 var MANIFEST_LOCK_SLEEP_MS = 20;
 function normalizeSpaceMemoryDir(memoryDir) {
-  return path27.resolve(memoryDir);
+  return path26.resolve(memoryDir);
 }
 function getSpacesDir(baseDir) {
   const homeDir = baseDir ?? resolveHomeDir();
-  return path27.join(homeDir, ".config", "engram", "spaces");
+  return path26.join(homeDir, ".config", "engram", "spaces");
 }
 function getManifestPath(baseDir) {
-  return path27.join(getSpacesDir(baseDir), "manifest.json");
+  return path26.join(getSpacesDir(baseDir), "manifest.json");
 }
 function loadManifest(baseDir, memoryDirOverride) {
   if (fs7.existsSync(getManifestPath(baseDir))) {
@@ -20765,9 +20654,9 @@ function readManifestUnlocked(baseDir, memoryDirOverride, options = {}) {
 }
 function saveManifestUnlocked(manifest, baseDir) {
   const manifestPath2 = getManifestPath(baseDir);
-  const manifestDir2 = path27.dirname(manifestPath2);
+  const manifestDir2 = path26.dirname(manifestPath2);
   fs7.mkdirSync(manifestDir2, { recursive: true });
-  const tempPath = path27.join(manifestDir2, `.manifest.${process.pid}.${Date.now()}.${crypto7.randomUUID()}.tmp`);
+  const tempPath = path26.join(manifestDir2, `.manifest.${process.pid}.${Date.now()}.${crypto7.randomUUID()}.tmp`);
   try {
     fs7.writeFileSync(tempPath, `${JSON.stringify(manifest, null, 2)}
 `, { flag: "wx" });
@@ -20782,7 +20671,7 @@ function saveManifestUnlocked(manifest, baseDir) {
 }
 function withManifestLock(baseDir, operation) {
   const lockDir = `${getManifestPath(baseDir)}.lock`;
-  fs7.mkdirSync(path27.dirname(lockDir), { recursive: true });
+  fs7.mkdirSync(path26.dirname(lockDir), { recursive: true });
   const lockOwner = acquireManifestLock(lockDir);
   try {
     return operation();
@@ -20808,7 +20697,7 @@ function acquireManifestLock(lockDir) {
     try {
       fs7.mkdirSync(lockDir, { recursive: false });
       try {
-        fs7.writeFileSync(path27.join(lockDir, "owner"), `${owner}
+        fs7.writeFileSync(path26.join(lockDir, "owner"), `${owner}
 `, { flag: "wx" });
       } catch (error) {
         fs7.rmSync(lockDir, { recursive: true, force: true });
@@ -20838,7 +20727,7 @@ function acquireManifestLock(lockDir) {
 }
 function releaseManifestLock(lockDir, owner) {
   try {
-    const ownerPath = path27.join(lockDir, "owner");
+    const ownerPath = path26.join(lockDir, "owner");
     if (fs7.readFileSync(ownerPath, "utf8").trim() === owner) {
       fs7.rmSync(lockDir, { recursive: true, force: true });
     }
@@ -20854,7 +20743,7 @@ function removeStaleManifestLock(lockDir) {
   try {
     fs7.mkdirSync(reclaimDir, { recursive: false });
     try {
-      fs7.writeFileSync(path27.join(reclaimDir, "owner"), `${reclaimOwner}
+      fs7.writeFileSync(path26.join(reclaimDir, "owner"), `${reclaimOwner}
 `, { flag: "wx" });
     } catch (error) {
       fs7.rmSync(reclaimDir, { recursive: true, force: true });
@@ -20929,7 +20818,7 @@ function readManifestLockSnapshot(lockDir) {
     throw error;
   }
   try {
-    const owner = fs7.readFileSync(path27.join(lockDir, "owner"), "utf8").trim();
+    const owner = fs7.readFileSync(path26.join(lockDir, "owner"), "utf8").trim();
     return { mtimeMs: stat5.mtimeMs, owner };
   } catch (error) {
     if (error.code === "ENOENT") {
@@ -21001,8 +20890,8 @@ function sleepSync(ms) {
 }
 function createPersonalSpace(baseDir, memoryDirOverride) {
   const homeDir = baseDir ?? resolveHomeDir();
-  const standalonePath = path27.join(homeDir, ".engram", "memory");
-  const openclawPath = path27.join(homeDir, ".openclaw", "workspace", "memory", "local");
+  const standalonePath = path26.join(homeDir, ".engram", "memory");
+  const openclawPath = path26.join(homeDir, ".openclaw", "workspace", "memory", "local");
   const memoryDir = memoryDirOverride ?? readEnvVar("REMNIC_MEMORY_DIR") ?? readEnvVar("ENGRAM_MEMORY_DIR") ?? (fs7.existsSync(standalonePath) ? standalonePath : fs7.existsSync(openclawPath) ? openclawPath : standalonePath);
   const normalizedMemoryDir = normalizeSpaceMemoryDir(memoryDir);
   const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -21031,7 +20920,7 @@ function createSpace(options) {
   const id = options.name.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-");
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const memoryDir = normalizeSpaceMemoryDir(
-    options.memoryDir ?? path27.join(getSpacesDir(options.baseDir), id, "memory")
+    options.memoryDir ?? path26.join(getSpacesDir(options.baseDir), id, "memory")
   );
   const space = updateManifest(options.baseDir, (manifest) => {
     if (manifest.spaces.some((s) => s.id === id)) {
@@ -21252,14 +21141,14 @@ function mergeSpaces(sourceSpaceId, targetSpaceId, options) {
   };
 }
 function getAuditLog(baseDir) {
-  const auditPath = path27.join(getSpacesDir(baseDir), "audit.jsonl");
+  const auditPath = path26.join(getSpacesDir(baseDir), "audit.jsonl");
   if (!fs7.existsSync(auditPath)) return [];
   const lines = fs7.readFileSync(auditPath, "utf8").trim().split("\n");
   return lines.filter((l) => l.trim()).map((l) => JSON.parse(l));
 }
 function appendAudit(entry, baseDir) {
-  const auditPath = path27.join(getSpacesDir(baseDir), "audit.jsonl");
-  fs7.mkdirSync(path27.dirname(auditPath), { recursive: true });
+  const auditPath = path26.join(getSpacesDir(baseDir), "audit.jsonl");
+  fs7.mkdirSync(path26.dirname(auditPath), { recursive: true });
   const full = {
     id: crypto7.randomUUID(),
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -21291,8 +21180,8 @@ function copyMemories(sourceDir, targetDir, options) {
       continue;
     }
     const content = fs7.readFileSync(sourcePath, "utf8");
-    const relativePath = path27.relative(sourceRoot, sourceRealPath);
-    const targetPath = path27.resolve(targetRoot, relativePath);
+    const relativePath = path26.relative(sourceRoot, sourceRealPath);
+    const targetPath = path26.resolve(targetRoot, relativePath);
     if (!isPathInsideRoot(targetPath, targetRoot)) {
       skipped++;
       continue;
@@ -21334,8 +21223,8 @@ function copyMemories(sourceDir, targetDir, options) {
       skipped++;
       continue;
     }
-    fs7.mkdirSync(path27.dirname(targetPath), { recursive: true });
-    const targetParentRealPath = safeRealpath(path27.dirname(targetPath));
+    fs7.mkdirSync(path26.dirname(targetPath), { recursive: true });
+    const targetParentRealPath = safeRealpath(path26.dirname(targetPath));
     if (!targetParentRealPath || !isPathInsideRoot(targetParentRealPath, targetRoot)) {
       skipped++;
       continue;
@@ -21352,7 +21241,7 @@ function walkMd2(dir) {
   const results = [];
   function walk(d) {
     for (const entry of fs7.readdirSync(d, { withFileTypes: true })) {
-      const fullPath = path27.join(d, entry.name);
+      const fullPath = path26.join(d, entry.name);
       if (entry.isSymbolicLink()) {
         continue;
       }
@@ -21381,8 +21270,8 @@ function safeRealpath(filePath) {
   }
 }
 function isPathInsideRoot(candidatePath, rootPath) {
-  const relative = path27.relative(rootPath, candidatePath);
-  return relative === "" || !relative.startsWith("..") && !path27.isAbsolute(relative);
+  const relative = path26.relative(rootPath, candidatePath);
+  return relative === "" || !relative.startsWith("..") && !path26.isAbsolute(relative);
 }
 function parseSimpleFrontmatter(content) {
   const match = content.match(/^---\n([\s\S]*?)\n---/);
@@ -21503,7 +21392,7 @@ var REMNIC_RECALL_DECISION_RULES = `## When to Use Recall vs Direct Read
 // src/memory-extension/codex-publisher.ts
 import fs8 from "fs";
 import os3 from "os";
-import path28 from "path";
+import path27 from "path";
 var REMNIC_EXTENSION_DIR_NAME = "remnic";
 function resolveEnvHome(env) {
   if (env === void 0) return resolveHomeDir();
@@ -21512,12 +21401,12 @@ function resolveEnvHome(env) {
 function expandTildeWithHome(input, homeDir) {
   if (input === "~") return homeDir;
   if (input.startsWith("~/") || input.startsWith("~\\")) {
-    return path28.join(homeDir, input.slice(2));
+    return path27.join(homeDir, input.slice(2));
   }
   return input;
 }
 function normalizeHostRoot(input, homeDir) {
-  return path28.resolve(expandTildeWithHome(input.trim(), homeDir));
+  return path27.resolve(expandTildeWithHome(input.trim(), homeDir));
 }
 var CodexMemoryExtensionPublisher = class {
   hostId = "codex";
@@ -21531,12 +21420,12 @@ var CodexMemoryExtensionPublisher = class {
   async resolveExtensionRoot(env) {
     const homeDir = resolveEnvHome(env);
     const codexHomeInput = env === void 0 ? readEnvVar("CODEX_HOME")?.trim() : env.CODEX_HOME?.trim();
-    const codexHome = codexHomeInput ? normalizeHostRoot(codexHomeInput, homeDir) : path28.resolve(homeDir, ".codex");
-    return path28.join(codexHome, "memories_extensions", REMNIC_EXTENSION_DIR_NAME);
+    const codexHome = codexHomeInput ? normalizeHostRoot(codexHomeInput, homeDir) : path27.resolve(homeDir, ".codex");
+    return path27.join(codexHome, "memories_extensions", REMNIC_EXTENSION_DIR_NAME);
   }
   async isHostAvailable() {
     try {
-      const home = readEnvVar("CODEX_HOME")?.trim() || path28.join(resolveHomeDir(), ".codex");
+      const home = readEnvVar("CODEX_HOME")?.trim() || path27.join(resolveHomeDir(), ".codex");
       return fs8.existsSync(home);
     } catch {
       return false;
@@ -21587,7 +21476,7 @@ When running inside the Codex phase-2 consolidation sandbox:
   }
   async publish(ctx) {
     const extensionRoot = await this.resolveExtensionRoot();
-    const instructionsPath = path28.join(extensionRoot, "instructions.md");
+    const instructionsPath = path27.join(extensionRoot, "instructions.md");
     const filesWritten = [];
     const skipped = [];
     ctx.log.info(`Publishing Codex memory extension to ${extensionRoot}`);
@@ -21707,7 +21596,7 @@ function publisherForConnector(connectorId) {
 // src/session-summaries/index.ts
 import { createHash as createHash9 } from "crypto";
 import { lstat as lstat2, mkdir as mkdir7, readFile as readFile6, readdir as readdir4, rename, rm, stat as stat4, writeFile as writeFile7 } from "fs/promises";
-import path29 from "path";
+import path28 from "path";
 
 // src/session-summaries/adapters.ts
 var VALID_ROLES = /* @__PURE__ */ new Set(["user", "assistant", "tool", "system", "other"]);
@@ -22212,7 +22101,7 @@ function shortHash(value, length = 16) {
 async function listTranscriptFiles(root, maxFiles) {
   const out = [];
   let truncated = false;
-  const entrySortKey = (entryName, isDirectory) => isDirectory ? `${entryName}${path29.sep}` : entryName;
+  const entrySortKey = (entryName, isDirectory) => isDirectory ? `${entryName}${path28.sep}` : entryName;
   async function visit(dir) {
     if (truncated) return;
     const entries = (await readdir4(dir, { withFileTypes: true })).sort(
@@ -22222,13 +22111,13 @@ async function listTranscriptFiles(root, maxFiles) {
       if (truncated) return;
       if (entry.name.startsWith(".")) continue;
       if (entry.isSymbolicLink()) continue;
-      const fullPath = path29.join(dir, entry.name);
+      const fullPath = path28.join(dir, entry.name);
       if (entry.isDirectory()) {
         await visit(fullPath);
         continue;
       }
       if (!entry.isFile()) continue;
-      const ext = path29.extname(entry.name).toLowerCase();
+      const ext = path28.extname(entry.name).toLowerCase();
       if (!SUPPORTED_EXTENSIONS.has(ext)) continue;
       out.push(fullPath);
       if (out.length > maxFiles) {
@@ -22255,7 +22144,7 @@ function normalizeInputDir(inputDir) {
   if (typeof inputDir !== "string" || inputDir.trim().length === 0) {
     throw new Error("inputDir must be a non-empty string");
   }
-  return path29.resolve(expandTildePath(inputDir.trim()));
+  return path28.resolve(expandTildePath(inputDir.trim()));
 }
 function initRoleCounts() {
   return {
@@ -22412,11 +22301,11 @@ async function collectLocalSessionSummaries(options) {
       continue;
     }
     seenFileHashes.add(fileHash);
-    const fileExtension = path29.extname(filePath).toLowerCase();
+    const fileExtension = path28.extname(filePath).toLowerCase();
     const parsed = await adapter.parseFile(
       {
         content,
-        fileName: path29.basename(filePath),
+        fileName: path28.basename(filePath),
         fileExtension,
         fileRef: fileHash
       },
@@ -22472,7 +22361,7 @@ async function collectLocalSessionSummaries(options) {
 }
 async function readRedactionConfig(pathLike) {
   if (!pathLike) return void 0;
-  const raw = await readFile6(path29.resolve(expandTildePath(pathLike)), "utf-8");
+  const raw = await readFile6(path28.resolve(expandTildePath(pathLike)), "utf-8");
   const parsed = JSON.parse(raw);
   if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
     throw new Error("redaction config must be a JSON object");
@@ -22485,15 +22374,15 @@ function toJsonl(drafts) {
 }
 function defaultDraftOutputPath(memoryDir, generatedAt) {
   const stamp = generatedAt.replace(/[:.]/g, "-");
-  return path29.join(
-    path29.resolve(expandTildePath(memoryDir)),
+  return path28.join(
+    path28.resolve(expandTildePath(memoryDir)),
     "state",
     "session-summary-drafts",
     `session-summaries-${stamp}.jsonl`
   );
 }
 async function writeDrafts(filePath, drafts) {
-  await mkdir7(path29.dirname(filePath), { recursive: true });
+  await mkdir7(path28.dirname(filePath), { recursive: true });
   const tempPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
   try {
     await writeFile7(tempPath, toJsonl(drafts), "utf-8");
@@ -22511,7 +22400,7 @@ async function runLocalSessionSummaryCliCommand(options) {
   });
   const wroteFiles = [];
   if (options.output) {
-    const outputPath = path29.resolve(expandTildePath(options.output));
+    const outputPath = path28.resolve(expandTildePath(options.output));
     await writeDrafts(outputPath, report.drafts);
     wroteFiles.push(outputPath);
   }
@@ -22546,19 +22435,19 @@ async function runLocalSessionSummaryCliCommand(options) {
 
 // src/transfer/capsule-fork.ts
 import { lstat as lstat3, mkdir as mkdir8, readFile as readFile7, realpath as realpath2, writeFile as writeFile8 } from "fs/promises";
-import path30 from "path";
+import path29 from "path";
 async function forkCapsule(opts) {
   validateForkId(opts.forkId);
-  const rootAbs = path30.resolve(opts.targetRoot);
+  const rootAbs = path29.resolve(opts.targetRoot);
   await assertIsDirectoryNotSymlink(rootAbs, "forkCapsule", "targetRoot");
-  const forkDirAbs = path30.join(rootAbs, "forks", opts.forkId);
+  const forkDirAbs = path29.join(rootAbs, "forks", opts.forkId);
   const forkEntryExists = await pathEntryExists(forkDirAbs);
   if (forkEntryExists) {
     throw new Error(
       `forkCapsule: fork path already exists \u2014 forkId "${opts.forkId}" is already in use at: ${forkDirAbs}`
     );
   }
-  const archiveAbs = path30.resolve(opts.sourceArchive);
+  const archiveAbs = path29.resolve(opts.sourceArchive);
   const importResult = await importCapsule({
     archivePath: archiveAbs,
     root: rootAbs,
@@ -22580,10 +22469,10 @@ async function forkCapsule(opts) {
     importedRecords: importResult.imported.length,
     skippedRecords: importResult.skipped.length
   };
-  const lineagePath = path30.join(forkDirAbs, "lineage.json");
+  const lineagePath = path29.join(forkDirAbs, "lineage.json");
   const rootReal = await realpath2(rootAbs);
   await assertRealpathInsideRoot(rootReal, lineagePath, `forks/${opts.forkId}/lineage.json`, "forkCapsule");
-  await mkdir8(path30.dirname(lineagePath), { recursive: true });
+  await mkdir8(path29.dirname(lineagePath), { recursive: true });
   await writeFile8(lineagePath, JSON.stringify(lineage, null, 2) + "\n", "utf-8");
   return {
     archivePath: archiveAbs,
@@ -22597,11 +22486,11 @@ async function readForkLineage(targetRoot, forkId) {
   if (typeof forkId !== "string" || forkId.length === 0 || forkId.length > 64 || !CAPSULE_ID_PATTERN.test(forkId)) {
     return null;
   }
-  const rootAbs = path30.resolve(targetRoot);
+  const rootAbs = path29.resolve(targetRoot);
   const rootReal = await realpath2(rootAbs).catch(() => rootAbs);
-  const lineagePath = path30.join(rootReal, "forks", forkId, "lineage.json");
-  const rel = path30.relative(rootReal, lineagePath);
-  if (rel.startsWith("..") || path30.isAbsolute(rel)) {
+  const lineagePath = path29.join(rootReal, "forks", forkId, "lineage.json");
+  const rel = path29.relative(rootReal, lineagePath);
+  if (rel.startsWith("..") || path29.isAbsolute(rel)) {
     return null;
   }
   if (!await isLineagePathContained(rootReal, lineagePath)) {
@@ -22642,19 +22531,19 @@ async function pathEntryExists(absPath) {
 async function isLineagePathContained(rootReal, lineagePath) {
   let existing = lineagePath;
   const suffix = [];
-  while (existing !== path30.dirname(existing)) {
+  while (existing !== path29.dirname(existing)) {
     const st = await lstat3(existing).catch(() => null);
     if (st !== null) break;
-    suffix.unshift(path30.basename(existing));
-    existing = path30.dirname(existing);
+    suffix.unshift(path29.basename(existing));
+    existing = path29.dirname(existing);
   }
   const existingReal = await realpath2(existing).catch(() => existing);
-  const targetReal = suffix.length > 0 ? path30.join(existingReal, ...suffix) : existingReal;
-  const rel = path30.relative(rootReal, targetReal);
+  const targetReal = suffix.length > 0 ? path29.join(existingReal, ...suffix) : existingReal;
+  const rel = path29.relative(rootReal, targetReal);
   if (rel === "") return true;
   if (rel === "..") return false;
-  if (rel.startsWith(`..${path30.sep}`)) return false;
-  if (path30.isAbsolute(rel)) return false;
+  if (rel.startsWith(`..${path29.sep}`)) return false;
+  if (path29.isAbsolute(rel)) return false;
   return true;
 }
 
@@ -22795,4 +22684,4 @@ export {
   blendGraphExpandedRecallScore,
   Orchestrator
 };
-//# sourceMappingURL=chunk-RWZB6MAY.js.map
+//# sourceMappingURL=chunk-VQL22SHO.js.map