@remnic/core 9.45.4 → 9.46.0

package/dist/{chunk-DYVMXPCF.js → chunk-M32URQXV.js}

@@ -6,23 +6,23 @@ import {
   loadSyncState,
   syncWearableSource,
   wearableSourceLabel
-} from "./chunk-UV72DEZD.js";
-import {
-  CompressionGuidelineCoordinator
-} from "./chunk-6LKEUCEM.js";
+} from "./chunk-UYUYZ4WY.js";
 import {
   ActivityStore,
   MaintenanceScheduler
-} from "./chunk-JH6BPLOP.js";
+} from "./chunk-E4FOAENZ.js";
 import {
   runPeerProfileReasoner
 } from "./chunk-I74SUMNI.js";
 import {
   migrateFromEngram
 } from "./chunk-7HYPN2GC.js";
+import {
+  CompressionGuidelineCoordinator
+} from "./chunk-6LKEUCEM.js";
 import {
   LcmEngine
-} from "./chunk-6NNNURLK.js";
+} from "./chunk-Z54EM5YZ.js";
 import {
   chunkTranscriptEntries
 } from "./chunk-TECVW3JP.js";
@@ -32,7 +32,7 @@ import {
 import {
   CompoundingEngine,
   defaultTierMigrationCycleBudget
-} from "./chunk-KXEFRMCF.js";
+} from "./chunk-T6JRMVOV.js";
 import {
   SharedContextManager
 } from "./chunk-M23RF3LJ.js";
@@ -41,9 +41,12 @@ import {
   applyUtilityRankingRuntimeDelta,
   loadUtilityRuntimeValues
 } from "./chunk-LXOM6IQU.js";
+import {
+  CODEX_THREAD_KEY_PREFIX
+} from "./chunk-4EX5WZ4M.js";
 import {
   TierMigrationExecutor
-} from "./chunk-VOUOLGIP.js";
+} from "./chunk-YRFAYOFQ.js";
 import {
   decideTierTransition
 } from "./chunk-S75M5ZRK.js";
@@ -53,22 +56,23 @@ import {
 import {
   extractTopics
 } from "./chunk-UHGBNIOS.js";
+import {
+  buildTargetedFactRecallSection,
+  shouldRecallTargetedFactEvidence
+} from "./chunk-T67LUYCR.js";
 import {
   buildTemporalTimelineRecallSection
 } from "./chunk-I6WYQSX4.js";
-import {
-  CODEX_THREAD_KEY_PREFIX
-} from "./chunk-4EX5WZ4M.js";
 import {
   HourlySummarizer
 } from "./chunk-LLJMAULE.js";
-import {
-  buildTargetedFactRecallSection,
-  shouldRecallTargetedFactEvidence
-} from "./chunk-T67LUYCR.js";
 import {
   SessionObserverState
 } from "./chunk-QFN4U7AG.js";
+import {
+  buildResponseGuidanceRecallSection,
+  shouldRecallResponseGuidance
+} from "./chunk-6TCXIRP5.js";
 import {
   mergeWithAgentResults,
   runDirectAgent,
@@ -93,6 +97,9 @@ import {
 import {
   applyRuntimeRetrievalPolicy
 } from "./chunk-5IZL4DCV.js";
+import {
+  findUnresolvedEntityRefs
+} from "./chunk-X7XN6YU4.js";
 import {
   RelevanceStore
 } from "./chunk-LULR4IUW.js";
@@ -102,18 +109,14 @@ import {
   rerankLocalOrNoop
 } from "./chunk-LUDXM7MD.js";
 import {
-  buildResponseGuidanceRecallSection,
-  shouldRecallResponseGuidance
-} from "./chunk-6TCXIRP5.js";
+  createRecallSectionMetricRecorder
+} from "./chunk-C3AKM55W.js";
 import {
   LastRecallStore,
   RecallHandleHistoryStore,
   TierMigrationStatusStore,
   clampGraphRecallExpandedEntries
 } from "./chunk-NM2WP3B7.js";
-import {
-  findUnresolvedEntityRefs
-} from "./chunk-X7XN6YU4.js";
 import {
   dedupeResultsByNamespace,
   hasMemoryForResult,
@@ -125,22 +128,19 @@ import {
 import {
   reorderRecallResultsWithMmr
 } from "./chunk-YDBIWGNI.js";
-import {
-  createRecallSectionMetricRecorder
-} from "./chunk-C3AKM55W.js";
 import {
   applyReasoningTraceBoost
 } from "./chunk-ZZTOURJI.js";
 import {
   installPrioritizedEmbedding
 } from "./chunk-ROI7BK7H.js";
+import {
+  NegativeExampleStore
+} from "./chunk-23L3IXFD.js";
 import {
   applyMemoryWorthFilter,
   buildMemoryWorthCounterMap
 } from "./chunk-3GPTTA4J.js";
-import {
-  NegativeExampleStore
-} from "./chunk-23L3IXFD.js";
 import {
   evaluateMemoryActionPolicy
 } from "./chunk-H63EDPFJ.js";
@@ -154,9 +154,16 @@ import {
   buildFocusedListRecallSection,
   shouldRecallFocusedListEvidence
 } from "./chunk-OH7QLI6W.js";
+import {
+  createDeferCountMap,
+  createVerdictCache,
+  getVerdictKind,
+  judgeFactDurability,
+  validateProcedureExtraction
+} from "./chunk-K2TDK7GG.js";
 import {
   ExtractionEngine
-} from "./chunk-MDISBSYA.js";
+} from "./chunk-PKCLQ7KM.js";
 import {
   parseMemoryActionEligibilityContext
 } from "./chunk-CMQZNEIF.js";
@@ -169,13 +176,6 @@ import {
 import {
   recordJudgeTrainingPair
 } from "./chunk-PWFCHOB3.js";
-import {
-  createDeferCountMap,
-  createVerdictCache,
-  getVerdictKind,
-  judgeFactDurability,
-  validateProcedureExtraction
-} from "./chunk-K2TDK7GG.js";
 import {
   buildExplicitCueRecallSection
 } from "./chunk-TVIVY7KU.js";
@@ -183,7 +183,7 @@ import {
   buildEntityRecallSection,
   entityRecentTranscriptLookbackHours,
   readRecentEntityTranscriptEntries
-} from "./chunk-YMAQDHQM.js";
+} from "./chunk-BDNL34CT.js";
 import {
   buildEventOrderRecallSection,
   shouldRecallEventOrderEvidence
@@ -203,30 +203,30 @@ import {
 } from "./chunk-YK6BDDHP.js";
 import {
   refreshConvergedNamespaces
-} from "./chunk-DSUAAZZX.js";
+} from "./chunk-JFO5QZ7N.js";
 import {
   builtInConnectorPackageSpecifier,
   ensureBuiltInWearableConnectors,
   getWearableConnector,
   listWearableConnectors
-} from "./chunk-5SNZSWWR.js";
-import {
-  normalizeReplaySessionKey
-} from "./chunk-AJVLDJU6.js";
+} from "./chunk-5LRDM4R7.js";
 import {
   RoutingRulesStore
 } from "./chunk-XL24QQ63.js";
+import {
+  normalizeReplaySessionKey
+} from "./chunk-AJVLDJU6.js";
 import {
   compareVerifiedEpisodeResults,
   searchVerifiedEpisodes
-} from "./chunk-NTOIP2E6.js";
+} from "./chunk-W2ZSNIBP.js";
 import {
   ThreadingManager
 } from "./chunk-OJP3N7UK.js";
 import {
   compareVerifiedSemanticRuleResults,
   searchVerifiedSemanticRules
-} from "./chunk-P7NGM24P.js";
+} from "./chunk-YWCOJOUI.js";
 import {
   searchWorkProductLedgerEntries
 } from "./chunk-ZRWB5D4H.js";
@@ -239,18 +239,18 @@ import {
 import {
   runNamespaceMaintenanceFanout,
   summarizeNamespaceMaintenanceHealth
-} from "./chunk-7YERSTN7.js";
+} from "./chunk-5R6S4DJZ.js";
 import {
   NamespaceCatalog,
   planNamespaceMaintenance
-} from "./chunk-7SHJHPTY.js";
-import {
-  searchHarmonicRetrieval
-} from "./chunk-KVJRXN2E.js";
+} from "./chunk-ILBLZ5Y5.js";
 import {
   isAboveImportanceThreshold,
   scoreImportance
 } from "./chunk-JXS5PDQ7.js";
+import {
+  searchHarmonicRetrieval
+} from "./chunk-KVJRXN2E.js";
 import {
   EXTRACTION_JUDGE_VERDICT_CATEGORY,
   recordJudgeVerdict
@@ -275,7 +275,10 @@ import {
   materializeAfterSemanticConsolidation,
   parseConsolidationResponse,
   parseOperatorAwareConsolidationResponse
-} from "./chunk-TN76AKO3.js";
+} from "./chunk-M2INOSTA.js";
+import {
+  BoxBuilder
+} from "./chunk-B7RWBZXW.js";
 import {
   semanticChunkContent
 } from "./chunk-P4BC54KI.js";
@@ -284,7 +287,7 @@ import {
 } from "./chunk-UQ7RN5HK.js";
 import {
   SmartBuffer
-} from "./chunk-U2VLVBBH.js";
+} from "./chunk-64BHFFKZ.js";
 import {
   detectMeetings
 } from "./chunk-AUMWZSE7.js";
@@ -303,6 +306,10 @@ import {
   assertExternalWikiRootOutsideMemoryDirCanonical,
   isExternalWikiCollectionName
 } from "./chunk-JV3C2MNQ.js";
+import {
+  AMBIENT_CAPTURE_PROMPT_RULE,
+  isHighImpactPersonalFact
+} from "./chunk-QW27DOHG.js";
 import {
   buildRecallQueryPolicy
 } from "./chunk-LBJBNWS2.js";
@@ -316,12 +323,9 @@ import {
 import {
   isDisagreementPrompt
 } from "./chunk-H3FZVNRN.js";
-import {
-  BoxBuilder
-} from "./chunk-B7RWBZXW.js";
 import {
   MeetingsInputError
-} from "./chunk-XSFHWBQO.js";
+} from "./chunk-2DSUT7DZ.js";
 import {
   WearablesInputError,
   describeErrorForOperator
@@ -339,17 +343,13 @@ import {
   capturePassiveCorrections,
   clusterByKey,
   detectPassiveCorrections
-} from "./chunk-ZI32MKDW.js";
+} from "./chunk-RCU25Z66.js";
 import {
   importCapsule
 } from "./chunk-A4JMGKCD.js";
 import {
   isCodingGraphInstalled
 } from "./chunk-VQ7B2Q6M.js";
-import {
-  listTrustZoneRecords,
-  searchTrustZoneRecords
-} from "./chunk-JGSKJHF7.js";
 import {
   applyTrustScoreStage,
   buildTrustSignalsForRerank,
@@ -358,8 +358,9 @@ import {
   trustResultKey
 } from "./chunk-GNVZQ5JN.js";
 import {
-  buildXraySnapshot
-} from "./chunk-HFPASSFV.js";
+  listTrustZoneRecords,
+  searchTrustZoneRecords
+} from "./chunk-JGSKJHF7.js";
 import {
   boundRecallContextComposition,
   composeRecallContext,
@@ -367,6 +368,9 @@ import {
   formatCuriosityFooter,
   selectCuriosityQuestion
 } from "./chunk-AHVEHR6K.js";
+import {
+  buildXraySnapshot
+} from "./chunk-P2OTGMTR.js";
 import {
   objectiveStateStoreOverrideForNamespace,
   searchObjectiveStateSnapshots
@@ -387,18 +391,18 @@ import {
 import {
   NamespaceSearchRouter,
   namespaceCollectionName
-} from "./chunk-NUEQKLNB.js";
+} from "./chunk-KMWYZTIE.js";
 import {
   createConversationIndexRuntime,
   createSearchBackend,
   isSearchBackendEnabled
-} from "./chunk-UQWIKLQK.js";
+} from "./chunk-47J4EDGR.js";
 import {
   NoopSearchBackend
 } from "./chunk-CYEPCZN5.js";
 import {
   NamespaceStorageRouter
-} from "./chunk-CLB32OHM.js";
+} from "./chunk-LI7OE7G6.js";
 import {
   writeConversationChunks
 } from "./chunk-72A4L5JJ.js";
@@ -410,7 +414,7 @@ import {
 } from "./chunk-W4FBGYGK.js";
 import {
   buildChainFollowupGenerator
-} from "./chunk-TQ4GD737.js";
+} from "./chunk-L7G72WY4.js";
 import {
   QmdResultResolver,
   StorageManager,
@@ -429,7 +433,10 @@ import {
   reconstructFusionInputs,
   selfDeps,
   serializeFusionDay
-} from "./chunk-FZP32336.js";
+} from "./chunk-IDE5AR5W.js";
+import {
+  buildRetiredFactTombstoneInputs
+} from "./chunk-ENTCVTQR.js";
 import {
   bodyIsEscaped,
   decodeTranscriptBody,
@@ -440,9 +447,6 @@ import {
   saveSpeakerRegistry,
   speakerRegistryKey
 } from "./chunk-UHVXE24Y.js";
-import {
-  buildRetiredFactTombstoneInputs
-} from "./chunk-ENTCVTQR.js";
 import {
   canRecallToolScopedMemory,
   shouldPromoteGlobalFactToShared,
@@ -455,7 +459,7 @@ import {
 } from "./chunk-J6A3CX5N.js";
 import {
   confidenceTier
-} from "./chunk-DZPFMQZ7.js";
+} from "./chunk-3S63QIFQ.js";
 import {
   lintWorkspaceFiles,
   rotateMarkdownFileToArchive
@@ -542,7 +546,7 @@ import {
   throwIfRecallAborted,
   tokenizeRecallQuery,
   utcDateKeysForLocalDay
-} from "./chunk-WQIHRA5F.js";
+} from "./chunk-N3LL5NEU.js";
 import {
   inferIntentFromText,
   intentCompatibilityScore,
@@ -669,7 +673,7 @@ import {
 } from "./chunk-3WCASNQZ.js";
 
 // src/orchestrator.ts
-import path16 from "path";
+import path18 from "path";
 import { createHash as createHash6 } from "crypto";
 
 // src/orchestration/tier-migration-coordinator.ts
@@ -2164,7 +2168,7 @@ var RecallRerankCoordinator = class _RecallRerankCoordinator {
       namespaces,
       {
         readNamespaceMemories: async (ns) => (await this.getStorage(ns)).readAllMemories(),
-        readMemoryFrontmatter: async (path31, preferredNamespace) => {
+        readMemoryFrontmatter: async (path33, preferredNamespace) => {
           if (!fallbackReader) {
             for (const ns of namespaces) {
               try {
@@ -2176,7 +2180,7 @@ var RecallRerankCoordinator = class _RecallRerankCoordinator {
           }
           if (!fallbackReader) return null;
           const memory = await this.readQmdResultMemory(
-            path31,
+            path33,
             fallbackReader,
             namespaces,
             preferredNamespace
@@ -5088,7 +5092,7 @@ var ExtractionPersistCoordinator = class {
 // src/orchestration/recall-internal.ts
 import { createHash as createHash3 } from "crypto";
 import { readFile as readFile2, stat, unlink } from "fs/promises";
-import path7 from "path";
+import path8 from "path";
 
 // src/orchestration/graph-recall-coordinator.ts
 import { createHash as createHash2 } from "crypto";
@@ -5498,6 +5502,158 @@ function filterRecallCandidates(candidates, options) {
   return scopedByNamespace.filter((r) => !isGenericRecallExcludedPath(r.path, pathPolicy, "qmd")).slice(0, Math.max(0, options.limit));
 }
 
+// src/orchestration/recall-profile-storage.ts
+import path7 from "path";
+function resolveCompositeProfileStorage(options) {
+  const { profileStorages, memoryDir } = options;
+  const emptyProfileStorage = new Proxy(
+    { dir: path7.join(memoryDir, ".empty-scope-profile") },
+    {
+      get(target, prop) {
+        if (prop in target) return Reflect.get(target, prop);
+        if (prop === "readProfile") return async () => "";
+        if (prop === "readQuestions" || prop === "listEntityNames" || prop === "readContinuityIncidents")
+          return async () => [];
+        if (prop === "readIdentityAnchor" || prop === "readIdentityImprovementLoops")
+          return async () => "";
+        if (prop === "readEntity" || prop === "readMemoryByPath")
+          return async () => null;
+        return async () => [];
+      }
+    }
+  );
+  const profileStorage = profileStorages.length <= 1 ? profileStorages[0] ?? emptyProfileStorage : new Proxy(profileStorages[0], {
+    get(target, prop) {
+      if (prop === "readProfile") {
+        return async () => {
+          for (const storage of profileStorages) {
+            const profile = await storage.readProfile();
+            if (profile.trim().length > 0) return profile;
+          }
+          return "";
+        };
+      }
+      if (prop === "readQuestions") {
+        return async (...args) => {
+          const merged = [];
+          const seen = /* @__PURE__ */ new Set();
+          const priorityOf = (question) => {
+            const priority = Number(question?.priority ?? 0);
+            return Number.isFinite(priority) ? priority : 0;
+          };
+          for (const storage of profileStorages) {
+            const readFn = storage.readQuestions;
+            const questions = await readFn.call(storage, ...args);
+            for (const question of questions) {
+              const key = typeof question === "string" ? question : JSON.stringify(question);
+              if (seen.has(key)) continue;
+              seen.add(key);
+              merged.push(question);
+            }
+          }
+          return merged.sort(
+            (left, right) => priorityOf(right) - priorityOf(left) || String(left?.id ?? "").localeCompare(String(right?.id ?? ""))
+          );
+        };
+      }
+      if (prop === "readIdentityAnchor") {
+        return async () => {
+          for (const storage of profileStorages) {
+            const anchor = await storage.readIdentityAnchor() ?? "";
+            if (anchor.trim().length > 0) return anchor;
+          }
+          return "";
+        };
+      }
+      if (prop === "readIdentityImprovementLoops") {
+        return async () => {
+          const sections = [];
+          const seen = /* @__PURE__ */ new Set();
+          for (const storage of profileStorages) {
+            const loops = (await storage.readIdentityImprovementLoops() ?? "").trim();
+            if (!loops || seen.has(loops)) continue;
+            seen.add(loops);
+            sections.push(loops);
+          }
+          return sections.join("\n\n");
+        };
+      }
+      if (prop === "readContinuityIncidents") {
+        return async (...args) => {
+          const limit = typeof args[0] === "number" && Number.isFinite(args[0]) ? Math.max(0, args[0]) : void 0;
+          const incidents = [];
+          const seen = /* @__PURE__ */ new Set();
+          const incidentTime = (incident) => {
+            const incObj = incident;
+            const raw = incObj?.updatedAt ?? incObj?.openedAt ?? incObj?.createdAt;
+            const parsed = typeof raw === "string" ? Date.parse(raw) : Number.NaN;
+            return Number.isFinite(parsed) ? parsed : 0;
+          };
+          for (const storage of profileStorages) {
+            const readFn = storage.readContinuityIncidents;
+            for (const incident of await readFn.call(storage, ...args)) {
+              const key = JSON.stringify(incident);
+              if (seen.has(key)) continue;
+              seen.add(key);
+              incidents.push(incident);
+            }
+          }
+          incidents.sort(
+            (left, right) => incidentTime(right) - incidentTime(left) || String(left?.id ?? "").localeCompare(String(right?.id ?? ""))
+          );
+          return limit === void 0 ? incidents : incidents.slice(0, limit);
+        };
+      }
+      if (prop === "listEntityNames") {
+        return async (...args) => {
+          const names = /* @__PURE__ */ new Set();
+          for (const storage of profileStorages) {
+            const listFn = storage.listEntityNames;
+            for (const name of await listFn.call(storage, ...args)) names.add(name);
+          }
+          return [...names];
+        };
+      }
+      if (prop === "readEntity" || prop === "readMemoryByPath") {
+        return async (...args) => {
+          for (const storage of profileStorages) {
+            const methodFn = storage[prop];
+            if (methodFn) {
+              const value = await methodFn.call(storage, ...args);
+              if (value) return value;
+            }
+          }
+          return null;
+        };
+      }
+      if (prop === "readAllMemories") {
+        return async (...args) => {
+          const memories = [];
+          const seen = /* @__PURE__ */ new Set();
+          for (const storage of profileStorages) {
+            const readFn = storage.readAllMemories;
+            for (const memory of await readFn.call(storage, ...args)) {
+              const memObj = memory;
+              const key = String(memObj?.path ?? memObj?.frontmatter?.id ?? JSON.stringify(memory));
+              if (seen.has(key)) continue;
+              seen.add(key);
+              memories.push(memory);
+            }
+          }
+          return memories;
+        };
+      }
+      return Reflect.get(target, prop);
+    }
+  });
+  const profileStorageDirs = Array.from(
+    new Set(
+      profileStorages.map((storage) => storage.dir).filter((dir) => typeof dir === "string" && dir.length > 0)
+    )
+  );
+  return { profileStorage, profileStorageDirs };
+}
+
 // src/orchestration/recall-internal.ts
 var RecallInternalCoordinator = class {
   constructor(deps) {
@@ -5720,7 +5876,7 @@ var RecallInternalCoordinator = class {
       const graphExpandedResultPaths = /* @__PURE__ */ new Set();
       const graphSourceLabelsForPath = (resultPath) => {
         const labels = [];
-        const normalizedPath = resultPath.split(path7.sep).join("/");
+        const normalizedPath = resultPath.split(path8.sep).join("/");
         const isEntityPath = normalizedPath.startsWith("entities/") || normalizedPath.includes("/entities/");
         if (graphBaselinePaths.has(resultPath)) labels.push("baseline");
         if (graphExpandedResultPaths.has(resultPath))
@@ -5881,140 +6037,10 @@ var RecallInternalCoordinator = class {
       const profileStorages = await Promise.all(
         profileStorageNamespaces.map((namespace) => this.deps.storageRouter.storageFor(namespace))
       );
-      const emptyProfileStorage = new Proxy(
-        { dir: path7.join(this.deps.config.memoryDir, ".empty-scope-profile") },
-        {
-          get(target, prop) {
-            if (prop in target) return target[prop];
-            if (prop === "readProfile") return async () => "";
-            if (prop === "readQuestions" || prop === "listEntityNames" || prop === "readContinuityIncidents")
-              return async () => [];
-            if (prop === "readIdentityAnchor" || prop === "readIdentityImprovementLoops")
-              return async () => "";
-            if (prop === "readEntity" || prop === "readMemoryByPath")
-              return async () => null;
-            return async () => [];
-          }
-        }
-      );
-      const profileStorage = profileStorages.length <= 1 ? profileStorages[0] ?? emptyProfileStorage : new Proxy(profileStorages[0], {
-        get(target, prop) {
-          if (prop === "readProfile") {
-            return async () => {
-              for (const storage of profileStorages) {
-                const profile2 = await storage.readProfile();
-                if (profile2.trim().length > 0) return profile2;
-              }
-              return "";
-            };
-          }
-          if (prop === "readQuestions") {
-            return async (...args) => {
-              const merged = [];
-              const seen = /* @__PURE__ */ new Set();
-              const priorityOf = (question) => {
-                const priority = Number(question?.priority ?? 0);
-                return Number.isFinite(priority) ? priority : 0;
-              };
-              for (const storage of profileStorages) {
-                const questions = await storage.readQuestions(...args);
-                for (const question of questions) {
-                  const key = typeof question === "string" ? question : JSON.stringify(question);
-                  if (seen.has(key)) continue;
-                  seen.add(key);
-                  merged.push(question);
-                }
-              }
-              return merged.sort(
-                (left, right) => priorityOf(right) - priorityOf(left) || String(left?.id ?? "").localeCompare(String(right?.id ?? ""))
-              );
-            };
-          }
-          if (prop === "readIdentityAnchor") {
-            return async () => {
-              for (const storage of profileStorages) {
-                const anchor = await storage.readIdentityAnchor() ?? "";
-                if (anchor.trim().length > 0) return anchor;
-              }
-              return "";
-            };
-          }
-          if (prop === "readIdentityImprovementLoops") {
-            return async () => {
-              const sections = [];
-              const seen = /* @__PURE__ */ new Set();
-              for (const storage of profileStorages) {
-                const loops = (await storage.readIdentityImprovementLoops() ?? "").trim();
-                if (!loops || seen.has(loops)) continue;
-                seen.add(loops);
-                sections.push(loops);
-              }
-              return sections.join("\n\n");
-            };
-          }
-          if (prop === "readContinuityIncidents") {
-            return async (...args) => {
-              const limit = typeof args[0] === "number" && Number.isFinite(args[0]) ? Math.max(0, args[0]) : void 0;
-              const incidents = [];
-              const seen = /* @__PURE__ */ new Set();
-              const incidentTime = (incident) => {
-                const raw = incident?.updatedAt ?? incident?.openedAt ?? incident?.createdAt;
-                const parsed = typeof raw === "string" ? Date.parse(raw) : Number.NaN;
-                return Number.isFinite(parsed) ? parsed : 0;
-              };
-              for (const storage of profileStorages) {
-                for (const incident of await storage.readContinuityIncidents(...args)) {
-                  const key = JSON.stringify(incident);
-                  if (seen.has(key)) continue;
-                  seen.add(key);
-                  incidents.push(incident);
-                }
-              }
-              incidents.sort(
-                (left, right) => incidentTime(right) - incidentTime(left) || String(left?.id ?? "").localeCompare(String(right?.id ?? ""))
-              );
-              return limit === void 0 ? incidents : incidents.slice(0, limit);
-            };
-          }
-          if (prop === "listEntityNames") {
-            return async (...args) => {
-              const names = /* @__PURE__ */ new Set();
-              for (const storage of profileStorages) {
-                for (const name of await storage.listEntityNames(...args)) names.add(name);
-              }
-              return [...names];
-            };
-          }
-          if (prop === "readEntity" || prop === "readMemoryByPath") {
-            return async (...args) => {
-              for (const storage of profileStorages) {
-                const value = await storage[prop](...args);
-                if (value) return value;
-              }
-              return null;
-            };
-          }
-          if (prop === "readAllMemories") {
-            return async (...args) => {
-              const memories = [];
-              const seen = /* @__PURE__ */ new Set();
-              for (const storage of profileStorages) {
-                for (const memory of await storage.readAllMemories(...args)) {
-                  const key = String(memory?.path ?? memory?.frontmatter?.id ?? JSON.stringify(memory));
-                  if (seen.has(key)) continue;
-                  seen.add(key);
-                  memories.push(memory);
-                }
-              }
-              return memories;
-            };
-          }
-          return target[prop];
-        }
+      const { profileStorage, profileStorageDirs } = resolveCompositeProfileStorage({
+        profileStorages,
+        memoryDir: this.deps.config.memoryDir
       });
-      const profileStorageDirs = Array.from(
-        new Set(profileStorages.map((storage) => storage.dir).filter((dir) => typeof dir === "string" && dir.length > 0))
-      );
       throwIfRecallAborted(options.abortSignal);
       if (this.deps.namespaceCatalog.enabled && recallResultLimit > 0 && !options.abortSignal?.aborted) {
         for (const ns of recallNamespaces) this.deps.storageRouter.recordRead(ns);
@@ -7366,11 +7392,11 @@ ${formatted}`;
         if (!resolveRecallAuxiliaryCapabilities(this.deps.config).compactionReset) return null;
         const workspaceDir = compactionWorkspaceDir || this.deps.config.workspaceDir || defaultWorkspaceDir();
         const safeSessionKey = sanitizeSessionKeyForFilename(effectiveSessionKey);
-        const signalPath = path7.join(
+        const signalPath = path8.join(
           workspaceDir,
           `.compaction-reset-signal-${safeSessionKey}`
         );
-        const bootPath = path7.join(workspaceDir, "BOOT.md");
+        const bootPath = path8.join(workspaceDir, "BOOT.md");
         try {
           const signalStat = await stat(signalPath).catch(() => null);
           if (!signalStat) return null;
@@ -9600,127 +9626,170 @@ ${tmtNode.summary}`
 
 // src/orchestration/recall-search-pipeline.ts
 import { createHash as createHash4 } from "crypto";
-import path8 from "path";
-var RecallSearchPipelineCoordinator = class {
-  constructor(deps) {
-    this.deps = deps;
-  }
-  deps;
-  async fetchActiveArtifactsForNamespace(namespace, prompt, targetCount) {
-    const storage = await this.deps.storageRouter.storageFor(namespace);
-    let fetchLimit = computeArtifactCandidateFetchLimit(targetCount);
-    const maxFetchLimit = Math.min(800, Math.max(fetchLimit, targetCount * 8));
-    const MAX_ATTEMPTS = 4;
-    let bestFiltered = [];
-    for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt += 1) {
-      const rawResults = await storage.searchArtifacts(prompt, fetchLimit);
-      const sourceIds = Array.from(
-        new Set(
-          rawResults.map((a) => a.frontmatter.sourceMemoryId).filter(
-            (id) => typeof id === "string" && id.length > 0
-          )
+import path10 from "path";
+
+// src/orchestration/recall-search-prefilter.ts
+import path9 from "path";
+async function fetchActiveArtifactsForNamespace(deps, namespace, prompt, targetCount) {
+  const storage = await deps.storageRouter.storageFor(namespace);
+  let fetchLimit = computeArtifactCandidateFetchLimit(targetCount);
+  const maxFetchLimit = Math.min(800, Math.max(fetchLimit, targetCount * 8));
+  const MAX_ATTEMPTS = 4;
+  let bestFiltered = [];
+  for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt += 1) {
+    const rawResults = await storage.searchArtifacts(prompt, fetchLimit);
+    const sourceIds = Array.from(
+      new Set(
+        rawResults.map((a) => a.frontmatter.sourceMemoryId).filter(
+          (id) => typeof id === "string" && id.length > 0
         )
-      );
-      const sourceStatus = sourceIds.length > 0 ? await this.deps.resolveArtifactSourceStatuses(storage, sourceIds) : /* @__PURE__ */ new Map();
-      const filtered = [];
-      for (const artifact of rawResults) {
-        const sourceId = artifact.frontmatter.sourceMemoryId;
-        if (!sourceId) {
-          filtered.push(artifact);
-          if (filtered.length >= targetCount) break;
-          continue;
-        }
-        const status = sourceStatus.get(sourceId) ?? "missing";
-        if (status !== "active") continue;
+      )
+    );
+    const sourceStatus = sourceIds.length > 0 ? await deps.resolveArtifactSourceStatuses(storage, sourceIds) : /* @__PURE__ */ new Map();
+    const filtered = [];
+    for (const artifact of rawResults) {
+      const sourceId = artifact.frontmatter.sourceMemoryId;
+      if (!sourceId) {
         filtered.push(artifact);
         if (filtered.length >= targetCount) break;
+        continue;
       }
-      if (filtered.length >= targetCount) return filtered.slice(0, targetCount);
-      if (filtered.length > bestFiltered.length) {
-        bestFiltered = filtered;
-      }
-      if (rawResults.length === 0) return filtered;
-      if (rawResults.length < fetchLimit && filtered.length > 0)
-        return filtered;
-      if (fetchLimit >= maxFetchLimit) return filtered;
-      const growth = Math.max(targetCount * 2, 12);
-      fetchLimit = Math.min(maxFetchLimit, fetchLimit + growth);
-    }
-    return bestFiltered;
-  }
-  async buildQueryAwarePrefilter(prompt, recallNamespaces) {
-    if (!resolveIndexingCapabilities(this.deps.config).queryAwareIndexing || !prompt.trim()) {
-      return {
-        candidatePaths: null,
-        temporalFromDate: null,
-        matchedTags: [],
-        expandedTags: [],
-        combination: "none",
-        filteredToFullSearch: false
-      };
-    }
-    const temporalFromDate = isTemporalQuery(prompt) ? recencyWindowFromPrompt(prompt, Date.now()) : null;
-    const [rawTemporal, tagSignals] = await readIndexSnapshotAsync(
-      this.deps.config.memoryDir,
-      () => Promise.all([
-        temporalFromDate ? queryByDateRangeAsync(this.deps.config.memoryDir, temporalFromDate) : Promise.resolve(null),
-        resolvePromptTagPrefilterAsync(this.deps.config.memoryDir, prompt).catch(
-          () => ({
-            matchedTags: extractTagsFromPrompt(prompt),
-            expandedTags: extractTagsFromPrompt(prompt),
-            paths: null
-          })
-        )
-      ])
-    );
-    const temporalCandidates = this.deps.scopeQueryAwarePaths(
-      rawTemporal,
-      recallNamespaces
-    );
-    const tagCandidates = this.deps.scopeQueryAwarePaths(
-      tagSignals.paths,
-      recallNamespaces
-    );
-    const maxCandidates = this.deps.config.queryAwareIndexingMaxCandidates;
-    let candidatePaths = null;
-    let combination = "none";
-    let filteredToFullSearch = false;
-    if (tagSignals.matchedTags.length > 0 && tagCandidates !== null && tagCandidates.size === 0) {
-      candidatePaths = tagCandidates;
-      combination = "tag";
-    } else if (temporalCandidates !== null && tagCandidates !== null) {
-      const intersection = new Set(
-        Array.from(temporalCandidates).filter(
-          (memoryPath) => tagCandidates.has(memoryPath)
-        )
-      );
-      if (intersection.size > 0) {
-        candidatePaths = intersection;
-        combination = "intersection";
-      } else {
-        candidatePaths = /* @__PURE__ */ new Set([...temporalCandidates, ...tagCandidates]);
-        combination = "union";
-      }
-    } else if (temporalCandidates !== null) {
-      candidatePaths = temporalCandidates;
-      combination = "temporal";
-    } else if (tagCandidates !== null) {
-      candidatePaths = tagCandidates;
-      combination = "tag";
+      const status = sourceStatus.get(sourceId) ?? "missing";
+      if (status !== "active") continue;
+      filtered.push(artifact);
+      if (filtered.length >= targetCount) break;
     }
-    if (candidatePaths && maxCandidates > 0 && candidatePaths.size > maxCandidates) {
-      filteredToFullSearch = true;
-      candidatePaths = null;
+    if (filtered.length >= targetCount) return filtered.slice(0, targetCount);
+    if (filtered.length > bestFiltered.length) {
+      bestFiltered = filtered;
     }
+    if (rawResults.length === 0) return filtered;
+    if (rawResults.length < fetchLimit && filtered.length > 0)
+      return filtered;
+    if (fetchLimit >= maxFetchLimit) return filtered;
+    const growth = Math.max(targetCount * 2, 12);
+    fetchLimit = Math.min(maxFetchLimit, fetchLimit + growth);
+  }
+  return bestFiltered;
+}
+async function buildQueryAwarePrefilter(deps, prompt, recallNamespaces) {
+  if (!resolveIndexingCapabilities(deps.config).queryAwareIndexing || !prompt.trim()) {
     return {
-      candidatePaths,
-      temporalFromDate,
-      matchedTags: tagSignals.matchedTags,
-      expandedTags: tagSignals.expandedTags,
-      combination,
-      filteredToFullSearch
+      candidatePaths: null,
+      temporalFromDate: null,
+      matchedTags: [],
+      expandedTags: [],
+      combination: "none",
+      filteredToFullSearch: false
     };
   }
+  const temporalFromDate = isTemporalQuery(prompt) ? recencyWindowFromPrompt(prompt, Date.now()) : null;
+  const [rawTemporal, tagSignals] = await readIndexSnapshotAsync(
+    deps.config.memoryDir,
+    () => Promise.all([
+      temporalFromDate ? queryByDateRangeAsync(deps.config.memoryDir, temporalFromDate) : Promise.resolve(null),
+      resolvePromptTagPrefilterAsync(deps.config.memoryDir, prompt).catch(
+        () => ({
+          matchedTags: extractTagsFromPrompt(prompt),
+          expandedTags: extractTagsFromPrompt(prompt),
+          paths: null
+        })
+      )
+    ])
+  );
+  const temporalCandidates = deps.scopeQueryAwarePaths(
+    rawTemporal,
+    recallNamespaces
+  );
+  const tagCandidates = deps.scopeQueryAwarePaths(
+    tagSignals.paths,
+    recallNamespaces
+  );
+  const maxCandidates = deps.config.queryAwareIndexingMaxCandidates;
+  let candidatePaths = null;
+  let combination = "none";
+  let filteredToFullSearch = false;
+  if (tagSignals.matchedTags.length > 0 && tagCandidates !== null && tagCandidates.size === 0) {
+    candidatePaths = tagCandidates;
+    combination = "tag";
+  } else if (temporalCandidates !== null && tagCandidates !== null) {
+    const intersection = new Set(
+      Array.from(temporalCandidates).filter(
+        (memoryPath) => tagCandidates.has(memoryPath)
+      )
+    );
+    if (intersection.size > 0) {
+      candidatePaths = intersection;
+      combination = "intersection";
+    } else {
+      candidatePaths = /* @__PURE__ */ new Set([...temporalCandidates, ...tagCandidates]);
+      combination = "union";
+    }
+  } else if (temporalCandidates !== null) {
+    candidatePaths = temporalCandidates;
+    combination = "temporal";
+  } else if (tagCandidates !== null) {
+    candidatePaths = tagCandidates;
+    combination = "tag";
+  }
+  if (candidatePaths && maxCandidates > 0 && candidatePaths.size > maxCandidates) {
+    filteredToFullSearch = true;
+    candidatePaths = null;
+  }
+  return {
+    candidatePaths,
+    temporalFromDate,
+    matchedTags: tagSignals.matchedTags,
+    expandedTags: tagSignals.expandedTags,
+    combination,
+    filteredToFullSearch
+  };
+}
+async function searchEmbeddingFallback(deps, query, limit) {
+  if (!resolveMemoryLifecycleCapabilities(deps.config).embeddingFallback) return [];
+  if (!await deps.embeddingFallback.isAvailable()) return [];
+  const hits = await deps.embeddingFallback.search(query, limit);
+  if (hits.length === 0) return [];
+  const results = [];
+  for (const hit of hits) {
+    const fullPath = path9.isAbsolute(hit.path) ? hit.path : path9.join(deps.config.memoryDir, hit.path);
+    const memory = await deps.storage.readMemoryByPath(fullPath);
+    if (!memory) continue;
+    results.push({
+      docid: hit.id,
+      path: fullPath,
+      score: hit.score,
+      snippet: memory.content.slice(0, 400).replace(/\n/g, " ")
+    });
+  }
+  return results;
+}
+async function searchQueryAwareFallback(deps, prompt, limit, queryAwarePrefilter, abortSignal) {
+  throwIfRecallAborted(abortSignal);
+  const cappedLimit = Math.max(0, limit);
+  if (cappedLimit === 0 || queryAwarePrefilter?.candidatePaths?.size === 0) return [];
+  const candidatePaths = queryAwarePrefilter?.candidatePaths;
+  const scopedSeedResults = (candidatePaths?.size ? await deps.searchScopedMemoryCandidates(
+    candidatePaths,
+    prompt,
+    candidatePaths.size,
+    { allowArchived: true }
+  ) : []).filter((result) => !isGenericRecallExcludedPath(result.path, deps.config, "qmd"));
+  return scopedSeedResults.slice(0, cappedLimit);
+}
+
+// src/orchestration/recall-search-pipeline.ts
+var RecallSearchPipelineCoordinator = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  deps;
+  async fetchActiveArtifactsForNamespace(namespace, prompt, targetCount) {
+    return fetchActiveArtifactsForNamespace(this.deps, namespace, prompt, targetCount);
+  }
+  async buildQueryAwarePrefilter(prompt, recallNamespaces) {
+    return buildQueryAwarePrefilter(this.deps, prompt, recallNamespaces);
+  }
   async fetchQmdMemoryResultsWithArtifactTopUp(prompt, qmdFetchLimit, qmdHybridFetchLimit, options) {
     throwIfRecallAborted(options.abortSignal);
     const queryAwarePrefilter = options.queryAwarePrefilter ?? await this.deps.buildQueryAwarePrefilter(prompt, options.recallNamespaces);
@@ -9902,40 +9971,14 @@ var RecallSearchPipelineCoordinator = class {
     return capped;
   }
   async searchEmbeddingFallback(query, limit) {
-    if (!resolveMemoryLifecycleCapabilities(this.deps.config).embeddingFallback) return [];
-    if (!await this.deps.embeddingFallback.isAvailable()) return [];
-    const hits = await this.deps.embeddingFallback.search(query, limit);
-    if (hits.length === 0) return [];
-    const results = [];
-    for (const hit of hits) {
-      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({
-        docid: hit.id,
-        path: fullPath,
-        score: hit.score,
-        snippet: memory.content.slice(0, 400).replace(/\n/g, " ")
-      });
-    }
-    return results;
+    return searchEmbeddingFallback(this.deps, query, limit);
   }
   /**
    * Cold fallback retains qualifying query-aware candidates. Archive records
    * belong to dedicated surfaces and never re-enter generic recall.
    */
   async searchQueryAwareFallback(prompt, limit, queryAwarePrefilter, abortSignal) {
-    throwIfRecallAborted(abortSignal);
-    const cappedLimit = Math.max(0, limit);
-    if (cappedLimit === 0 || queryAwarePrefilter?.candidatePaths?.size === 0) return [];
-    const candidatePaths = queryAwarePrefilter?.candidatePaths;
-    const scopedSeedResults = (candidatePaths?.size ? await this.deps.searchScopedMemoryCandidates(
-      candidatePaths,
-      prompt,
-      candidatePaths.size,
-      { allowArchived: true }
-    ) : []).filter((result) => !isGenericRecallExcludedPath(result.path, this.deps.config, "qmd"));
-    return scopedSeedResults.slice(0, cappedLimit);
+    return searchQueryAwareFallback(this.deps, prompt, limit, queryAwarePrefilter, abortSignal);
   }
   async applyColdFallbackPipeline(options) {
     const caps = options.caps ?? resolveCapabilities(this.deps.config);
@@ -10071,7 +10114,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 = path8.resolve(storageDir);
+          const recallRoot = path10.resolve(storageDir);
           if (seenRecallRoots.has(recallRoot)) continue;
           seenRecallRoots.add(recallRoot);
           recallRoots.push(recallRoot);
@@ -10095,8 +10138,8 @@ var RecallSearchPipelineCoordinator = class {
           if (resolvedCold) scopedResults.push(resolvedCold.result);
           continue;
         }
-        if (path8.isAbsolute(result.path)) {
-          if (recallRoots.some((recallRoot) => isPathInsideStorageRoot(recallRoot, path8.resolve(result.path)))) {
+        if (path10.isAbsolute(result.path)) {
+          if (recallRoots.some((recallRoot) => isPathInsideStorageRoot(recallRoot, path10.resolve(result.path)))) {
             scopedResults.push(result);
           }
           continue;
@@ -11185,7 +11228,7 @@ var TurnIngestionCoordinator = class {
 
 // src/orchestration/recall-introspection.ts
 import { mkdir as mkdir5, readFile as readFile4, writeFile as writeFile5 } from "fs/promises";
-import path10 from "path";
+import path12 from "path";
 
 // src/taxonomy/default-taxonomy.ts
 var DEFAULT_TAXONOMY = {
@@ -11308,7 +11351,7 @@ function generateResolverDocument(taxonomy) {
 
 // src/taxonomy/taxonomy-loader.ts
 import { readFile as readFile3, mkdir as mkdir4, writeFile as writeFile4 } from "fs/promises";
-import path9 from "path";
+import path11 from "path";
 var TAXONOMY_DIR = ".taxonomy";
 var TAXONOMY_FILE = "taxonomy.json";
 var MAX_SLUG_LENGTH = 32;
@@ -11406,7 +11449,7 @@ function validateTaxonomy(taxonomy) {
   }
 }
 async function loadTaxonomy(memoryDir) {
-  const taxonomyPath = path9.join(memoryDir, TAXONOMY_DIR, TAXONOMY_FILE);
+  const taxonomyPath = path11.join(memoryDir, TAXONOMY_DIR, TAXONOMY_FILE);
   let raw;
   try {
     raw = await readFile3(taxonomyPath, "utf-8");
@@ -11456,16 +11499,16 @@ async function loadTaxonomy(memoryDir) {
 }
 async function saveTaxonomy(memoryDir, taxonomy) {
   validateTaxonomy(taxonomy);
-  const dir = path9.join(memoryDir, TAXONOMY_DIR);
+  const dir = path11.join(memoryDir, TAXONOMY_DIR);
   await mkdir4(dir, { recursive: true });
-  const filePath = path9.join(dir, TAXONOMY_FILE);
+  const filePath = path11.join(dir, TAXONOMY_FILE);
   await writeFile4(filePath, JSON.stringify(taxonomy, null, 2) + "\n", "utf-8");
 }
 function getTaxonomyDir(memoryDir) {
-  return path9.join(memoryDir, TAXONOMY_DIR);
+  return path11.join(memoryDir, TAXONOMY_DIR);
 }
 function getTaxonomyFilePath(memoryDir) {
-  return path9.join(memoryDir, TAXONOMY_DIR, TAXONOMY_FILE);
+  return path11.join(memoryDir, TAXONOMY_DIR, TAXONOMY_FILE);
 }
 
 // src/orchestration/recall-introspection.ts
@@ -11489,7 +11532,7 @@ var RecallIntrospectionCoordinator = class {
   }
   async getLastGraphRecallSnapshot(namespace) {
     const storage = await this.deps.getStorage(namespace);
-    const snapshotPath = path10.join(
+    const snapshotPath = path12.join(
       storage.dir,
       "state",
       "last_graph_recall.json"
@@ -11528,7 +11571,7 @@ var RecallIntrospectionCoordinator = class {
   }
   async getLastIntentSnapshot(namespace) {
     const storage = await this.deps.getStorage(namespace);
-    const snapshotPath = path10.join(storage.dir, "state", "last_intent.json");
+    const snapshotPath = path12.join(storage.dir, "state", "last_intent.json");
     try {
       const raw = await readFile4(snapshotPath, "utf-8");
       const parsed = JSON.parse(raw);
@@ -11561,7 +11604,7 @@ var RecallIntrospectionCoordinator = class {
   }
   async getLastQmdRecallSnapshot(namespace) {
     const storage = await this.deps.getStorage(namespace);
-    const snapshotPath = path10.join(
+    const snapshotPath = path12.join(
       storage.dir,
       "state",
       "last_qmd_recall.json"
@@ -11851,12 +11894,12 @@ var RecallIntrospectionCoordinator = class {
   }
   async recordLastIntentSnapshot(options) {
     try {
-      const snapshotPath = path10.join(
+      const snapshotPath = path12.join(
         options.storage.dir,
         "state",
         "last_intent.json"
       );
-      await mkdir5(path10.dirname(snapshotPath), { recursive: true });
+      await mkdir5(path12.dirname(snapshotPath), { recursive: true });
       await writeFile5(
         snapshotPath,
         JSON.stringify(options.snapshot, null, 2),
@@ -11868,12 +11911,12 @@ var RecallIntrospectionCoordinator = class {
   }
   async recordLastQmdRecallSnapshot(options) {
     try {
-      const snapshotPath = path10.join(
+      const snapshotPath = path12.join(
         options.storage.dir,
         "state",
         "last_qmd_recall.json"
       );
-      await mkdir5(path10.dirname(snapshotPath), { recursive: true });
+      await mkdir5(path12.dirname(snapshotPath), { recursive: true });
       await writeFile5(
         snapshotPath,
         JSON.stringify(options.snapshot, null, 2),
@@ -11888,8 +11931,8 @@ var RecallIntrospectionCoordinator = class {
       const stateDir = await this.deps.resolveStateDirForNamespace(
         options.namespace
       );
-      const snapshotPath = path10.join(stateDir, "last_intent.json");
-      await mkdir5(path10.dirname(snapshotPath), { recursive: true });
+      const snapshotPath = path12.join(stateDir, "last_intent.json");
+      await mkdir5(path12.dirname(snapshotPath), { recursive: true });
       await writeFile5(
         snapshotPath,
         JSON.stringify(options.snapshot, null, 2),
@@ -11903,7 +11946,7 @@ var RecallIntrospectionCoordinator = class {
 
 // src/orchestration/orchestrator-init.ts
 import { readdir as readdir2, stat as stat2, unlink as unlink2 } from "fs/promises";
-import path11 from "path";
+import path13 from "path";
 var OrchestratorInitCoordinator = class {
   constructor(deps) {
     this.deps = deps;
@@ -12007,7 +12050,7 @@ var OrchestratorInitCoordinator = class {
           const files = await readdir2(wsDir).catch(() => []);
           for (const f of files) {
             if (!f.startsWith(".compaction-reset-signal-")) continue;
-            const fp = path11.join(wsDir, f);
+            const fp = path13.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(() => {
@@ -12202,7 +12245,7 @@ var OrchestratorInitCoordinator = class {
     if (signal.aborted) return;
     if (lifecycleCaps.lifecyclePolicy && resolveQmdCapabilities(this.deps.config).qmdTierMigration) {
       try {
-        const { runFirstStartMigration } = await import("./first-start-migration-F2QJD66E.js");
+        const { runFirstStartMigration } = await import("./first-start-migration-ZSHEFEI3.js");
         const result = await runFirstStartMigration({
           storage: this.deps.storage,
           config: this.deps.config,
@@ -12225,7 +12268,7 @@ var OrchestratorInitCoordinator = class {
     if (signal.aborted) return;
     if (!this.deps.wearablesAutoSyncHandle && this.deps.config.wearables.enabled && this.deps.config.wearables.autoSyncEnabled && Object.values(this.deps.config.wearables.sources).some((source) => source.enabled)) {
       try {
-        const { startWearablesAutoSync } = await import("./auto-sync-UPTUVE4X.js");
+        const { startWearablesAutoSync } = await import("./auto-sync-7O6RP2RT.js");
         if (signal.aborted) return;
         this.deps.wearablesAutoSyncHandle = startWearablesAutoSync(
           {
@@ -12359,7 +12402,7 @@ var OrchestratorInitCoordinator = class {
 };
 
 // src/orchestration/persistence-index.ts
-import path12 from "path";
+import path14 from "path";
 var PersistenceIndexCoordinator = class {
   constructor(deps) {
     this.deps = deps;
@@ -12545,7 +12588,7 @@ var PersistenceIndexCoordinator = class {
         const allMems = allMemsForGraph ?? [];
         for (const m of allMems) {
           if (m.frontmatter.entityRef === entityRef) {
-            const rel = path12.relative(storage.dir, m.path);
+            const rel = path14.relative(storage.dir, m.path);
             if (rel !== memoryRelPath) entitySiblings.push(rel);
           }
         }
@@ -12694,7 +12737,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 path13 from "path";
+import path15 from "path";
 
 // src/maintenance/pattern-reinforcement.ts
 function patternReinforcementKey(content) {
@@ -13865,10 +13908,12 @@ async function writeMeetingEpisodeMemory(record, writer) {
   if (envelope.salvageNotes.length > 0) {
     log.warn(`meeting episode write salvaged invalid fields: ${envelope.salvageNotes.join("; ")}`);
   }
+  const titleIsPersonalClaim = record.title !== void 0 && record.title.length > 0 && isHighImpactPersonalFact({ category: "fact", content: record.title });
+  const uncorroboratedDetection = record.detectionSource === "audio";
   await writer.writeSealedMemory(envelope, {
     importance: scoreImportance(content, "moment", [MEETING_SOURCE_PREFIX]),
     contentHashSource: content,
-    status: "active",
+    status: titleIsPersonalClaim || uncorroboratedDetection ? "pending_review" : "active",
     memoryKind: "episode"
   });
   return true;
@@ -13924,14 +13969,16 @@ async function writeMeetingFact(record, candidate, status, writer) {
   });
 }
 var SUMMARY_FACT_CONFIDENCE = 0.8;
-function resolveMeetingFactOutcome(config, trust, judgeVerdict) {
+function resolveMeetingFactOutcome(config, trust, judgeVerdict, claim) {
   if (config.summaryMode === "review") {
     return judgeVerdict === "reject" ? "drop" : "review";
   }
-  return decideSmart(trust, judgeVerdict, {
-    autoApproveTrust: config.autoApproveTrust,
-    reviewTrust: config.reviewTrust
-  }).outcome;
+  return decideSmart(
+    trust,
+    judgeVerdict,
+    { autoApproveTrust: config.autoApproveTrust, reviewTrust: config.reviewTrust },
+    { capAtReview: isHighImpactPersonalFact(claim) }
+  ).outcome;
 }
 async function generateMeetingSummaryFacts(record, config, deps) {
   const empty = {
@@ -13978,7 +14025,7 @@ async function generateMeetingSummaryFacts(record, config, deps) {
       judgeVerdict,
       evidence
     });
-    const outcome = resolveMeetingFactOutcome(config, trust, judgeVerdict);
+    const outcome = resolveMeetingFactOutcome(config, trust, judgeVerdict, candidate);
     if (outcome === "drop") {
       result.dropped++;
       continue;
@@ -14003,7 +14050,10 @@ async function generateMeetingSummaryFacts(record, config, deps) {
         sourceTrust: config.sourceTrust,
         evidence
       });
-      const outcome = resolveMeetingFactOutcome(config, summaryTrust, void 0);
+      const outcome = resolveMeetingFactOutcome(config, summaryTrust, void 0, {
+        category: "fact",
+        content: summaryText
+      });
       if (outcome === "drop") {
         result.dropped++;
       } else {
@@ -14122,7 +14172,8 @@ Rules:
 - decisions: concrete choices the group made. Omit hypotheticals and discussion that led nowhere.
 - commitments: owner-bearing action items only. If there is no clear owner, omit it.
 - openQuestions: genuinely unresolved questions, not rhetorical asides.
-- Prefer fewer, higher-quality items. Use [] for any empty list. Never invent content the transcript does not support.`;
+- Prefer fewer, higher-quality items. Use [] for any empty list. Never invent content the transcript does not support.
+${AMBIENT_CAPTURE_PROMPT_RULE}`;
 var DECISION_CONFIDENCE = 0.8;
 var COMMITMENT_CONFIDENCE = 0.8;
 var QUESTION_CONFIDENCE = 0.6;
@@ -14593,8 +14644,8 @@ var MeetingsService = class {
 // src/orchestration/workspace-ops.ts
 var MEETINGS_BUILD_DEBOUNCE_MS = 5e3;
 function matchesMemoryPath(candidatePath, requestedPath, memoryDir) {
-  const normalizedCandidate = path13.resolve(candidatePath);
-  return normalizedCandidate === path13.resolve(requestedPath) || normalizedCandidate === path13.resolve(memoryDir, requestedPath);
+  const normalizedCandidate = path15.resolve(candidatePath);
+  return normalizedCandidate === path15.resolve(requestedPath) || normalizedCandidate === path15.resolve(memoryDir, requestedPath);
 }
 function accessTrackingPathCandidates(storageDir, memoryPath) {
   const candidates = qmdResultPathCandidates(storageDir, memoryPath);
@@ -14602,12 +14653,12 @@ function accessTrackingPathCandidates(storageDir, memoryPath) {
   if (!parts) return candidates;
   candidates.push(
     ...qmdResultPathCandidates(storageDir, parts.relativePath),
-    ...qmdResultPathCandidates(path13.join(storageDir, "cold"), parts.relativePath)
+    ...qmdResultPathCandidates(path15.join(storageDir, "cold"), parts.relativePath)
   );
   return [...new Set(candidates)];
 }
 function canonicalMemoryPath(memoryPath, memoryDir) {
-  return path13.resolve(path13.isAbsolute(memoryPath) ? memoryPath : path13.resolve(memoryDir, memoryPath));
+  return path15.resolve(path15.isAbsolute(memoryPath) ? memoryPath : path15.resolve(memoryDir, memoryPath));
 }
 var WorkspaceOpsCoordinator = class {
   constructor(deps) {
@@ -14689,15 +14740,15 @@ var WorkspaceOpsCoordinator = class {
     this.deps.lastFileHygieneRunAtMs = now;
     if (hygiene.rotateEnabled) {
       for (const rel of hygiene.rotatePaths) {
-        const abs = path13.isAbsolute(rel) ? rel : path13.join(this.deps.config.workspaceDir, rel);
+        const abs = path15.isAbsolute(rel) ? rel : path15.join(this.deps.config.workspaceDir, rel);
         try {
           const raw = await readFile5(abs, "utf-8");
           if (raw.length > hygiene.rotateMaxBytes) {
-            const archiveDir = path13.join(
+            const archiveDir = path15.join(
               this.deps.config.workspaceDir,
               hygiene.archiveDir
             );
-            const base = path13.basename(abs);
+            const base = path15.basename(abs);
             const prefix = base.toUpperCase().replace(/\.MD$/i, "").replace(/[^A-Z0-9]+/g, "-") || "FILE";
             const { newContent } = await rotateMarkdownFileToArchive({
               filePath: abs,
@@ -14722,8 +14773,8 @@ var WorkspaceOpsCoordinator = class {
         log.warn(w.message);
       }
       if (hygiene.warningsLogEnabled && warnings.length > 0) {
-        const fp = path13.join(this.deps.config.memoryDir, hygiene.warningsLogPath);
-        await mkdir6(path13.dirname(fp), { recursive: true });
+        const fp = path15.join(this.deps.config.memoryDir, hygiene.warningsLogPath);
+        await mkdir6(path15.dirname(fp), { recursive: true });
         const stamp = (/* @__PURE__ */ new Date()).toISOString();
         const block = `
 
@@ -14763,7 +14814,7 @@ var WorkspaceOpsCoordinator = class {
     for (const categoryDir of RECALL_FALLBACK_DIRS) {
       if (memoryRootReal === null) break;
       for (const date of datesToScan) {
-        const dateDir = path13.join(storage.dir, categoryDir, date);
+        const dateDir = path15.join(storage.dir, categoryDir, date);
         try {
           const dirStat = await lstat(dateDir);
           if (dirStat.isSymbolicLink() || !dirStat.isDirectory()) continue;
@@ -14772,7 +14823,7 @@ var WorkspaceOpsCoordinator = class {
           for (const entry of entries) {
             if (entry.isSymbolicLink()) continue;
             if (!entry.name.endsWith(".md")) continue;
-            const fullPath = path13.join(dateDir, entry.name);
+            const fullPath = path15.join(dateDir, entry.name);
             try {
               assertPathInsideRoot(memoryRootReal, await realpath(fullPath), fullPath);
               const raw = await readFile5(fullPath, "utf-8");
@@ -14794,7 +14845,7 @@ var WorkspaceOpsCoordinator = class {
               facts.push({
                 path: fullPath,
                 frontmatter: {
-                  id: fm.id || path13.basename(entry.name, ".md"),
+                  id: fm.id || path15.basename(entry.name, ".md"),
                   category: fm.category || "fact",
                   created,
                   updated: fm.updated || created,
@@ -14817,13 +14868,13 @@ var WorkspaceOpsCoordinator = class {
       return a.frontmatter.created < b.frontmatter.created ? -1 : 1;
     });
     const hourlySummaries = [];
-    const hourlyBaseDir = path13.join(storage.dir, "summaries", "hourly");
+    const hourlyBaseDir = path15.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 = path13.join(hourlyBaseDir, sk.name, `${date}.md`);
+          const summaryFile = path15.join(hourlyBaseDir, sk.name, `${date}.md`);
           try {
             const raw = await readFile5(summaryFile, "utf-8");
             const filtered = filterHourlySummaryMarkdownForLocalDay(
@@ -15287,18 +15338,18 @@ ${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 path17 from "path";
 
 // src/orchestration/orchestrator-namespace-scope.ts
-import path14 from "path";
+import path16 from "path";
 function computeSemanticDedupScope(targetStorage, config) {
   if (!resolveNamespaceCapabilities(config).namespaces) return {};
-  const memoryDir = path14.resolve(config.memoryDir);
-  const storageDir = path14.resolve(targetStorage.dir);
+  const memoryDir = path16.resolve(config.memoryDir);
+  const storageDir = path16.resolve(targetStorage.dir);
   if (storageDir === memoryDir) {
     return { pathExcludePrefixes: ["namespaces/"] };
   }
-  let rel = path14.relative(memoryDir, storageDir);
+  let rel = path16.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`
@@ -15351,7 +15402,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 = path17.join(this.deps.config.memoryDir, "state", "namespaces.jsonl");
     if (!existsSync(catalogPath)) return;
     let body;
     try {
@@ -15388,7 +15439,7 @@ var NamespaceReadFanoutCoordinator = class {
       if (!this.deps.storageDirMatchesNamespaceHint(record.namespace, record.storageDir)) {
         continue;
       }
-      const resolvedStorageDir = path15.resolve(record.storageDir);
+      const resolvedStorageDir = path17.resolve(record.storageDir);
       const current = preferredByStorageDir.get(resolvedStorageDir);
       preferredByStorageDir.set(
         resolvedStorageDir,
@@ -15569,12 +15620,12 @@ var NamespaceReadFanoutCoordinator = class {
   }
   async resolveStateDirForNamespace(namespace) {
     if (!resolveNamespaceCapabilities(this.deps.config).namespaces) {
-      return path15.join(this.deps.config.memoryDir, "state");
+      return path17.join(this.deps.config.memoryDir, "state");
     }
     if (namespace !== this.deps.config.defaultNamespace) {
-      return path15.join(this.deps.config.memoryDir, "namespaces", namespace, "state");
+      return path17.join(this.deps.config.memoryDir, "namespaces", namespace, "state");
     }
-    const candidate = path15.join(
+    const candidate = path17.join(
       this.deps.config.memoryDir,
       "namespaces",
       this.deps.config.defaultNamespace
@@ -15582,11 +15633,11 @@ var NamespaceReadFanoutCoordinator = class {
     try {
       const candidateStat = await stat3(candidate);
       if (candidateStat.isDirectory()) {
-        return path15.join(candidate, "state");
+        return path17.join(candidate, "state");
       }
     } catch {
     }
-    return path15.join(this.deps.config.memoryDir, "state");
+    return path17.join(this.deps.config.memoryDir, "state");
   }
   namespaceFromPath(p) {
     if (!resolveNamespaceCapabilities(this.deps.config).namespaces) return this.deps.config.defaultNamespace;
@@ -15977,7 +16028,7 @@ var Orchestrator = class {
   rerankCache = new RerankCache();
   /**
    * Per-session workspace selections keyed by sessionKey.
-   * Set by the before_agent_start hook so recall() uses the correct
+   * Set by the before_prompt_build hook so recall() uses the correct
    * agent workspace for BOOT.md injection. Cleared after each recall.
    * Using a Map prevents concurrent sessions from overwriting each other.
    */
@@ -16365,7 +16416,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 = path18.resolve(storageDir);
     let hints = this.namespaceStorageDirHints.get(resolvedStorageDir);
     if (!hints) {
       hints = /* @__PURE__ */ new Set();
@@ -16376,21 +16427,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 = path18.resolve(storageDir);
+    const resolvedMemoryDir = path18.resolve(this.config.memoryDir);
     const defaultNs = normalizeNamespaceIdentity(this.config.defaultNamespace);
     if (resolvedStorageDir === resolvedMemoryDir) return ns === defaultNs;
-    const resolvedNamespacesDir = path16.join(resolvedMemoryDir, "namespaces");
+    const resolvedNamespacesDir = path18.join(resolvedMemoryDir, "namespaces");
     if (!isPathInsideStorageRoot(resolvedNamespacesDir, resolvedStorageDir)) return false;
-    const rawRoot = path16.resolve(resolvedNamespacesDir, ns);
-    const tokenRoot = path16.resolve(resolvedNamespacesDir, namespaceIdentityToken(ns));
+    const rawRoot = path18.resolve(resolvedNamespacesDir, ns);
+    const tokenRoot = path18.resolve(resolvedNamespacesDir, namespaceIdentityToken(ns));
     return resolvedStorageDir === rawRoot || resolvedStorageDir === tokenRoot;
   }
   namespaceStorageDirHintOwnershipRank(record, resolvedStorageDir, configured) {
-    if (resolvedStorageDir === path16.resolve(this.config.memoryDir)) {
+    if (resolvedStorageDir === path18.resolve(this.config.memoryDir)) {
       return record.namespace === normalizeNamespaceIdentity(this.config.defaultNamespace) ? 0 : 3;
     }
-    const leaf = path16.basename(resolvedStorageDir);
+    const leaf = path18.basename(resolvedStorageDir);
     const tokenOwnsRoot = namespaceIdentityToken(record.namespace) === leaf;
     if (tokenOwnsRoot && configured.has(record.namespace)) return 0;
     if (record.namespace === leaf) return 1;
@@ -16530,7 +16581,7 @@ var Orchestrator = class {
     StorageManager.setScopedCacheInvalidationDefault(config.memoryDir, scopedCacheInvalidationEnabled);
     this.profiler = new ProfilingCollector({
       enabled: resolvePipelineProcessingCapabilities(this.config).profiling,
-      storageDir: config.profilingStorageDir || path16.join(config.memoryDir, "profiling"),
+      storageDir: config.profilingStorageDir || path18.join(config.memoryDir, "profiling"),
       maxTraces: config.profilingMaxTraces
     });
     this.namespaceCatalog = new NamespaceCatalog(config);
@@ -16617,7 +16668,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 = path18.join(
       config.memoryDir,
       "conversation-index",
       "chunks"
@@ -16764,7 +16815,7 @@ var Orchestrator = class {
       saveContentHashIndexes: () => this.saveContentHashIndexes()
     });
     this.threading = new ThreadingManager(
-      path16.join(config.memoryDir, "threads"),
+      path18.join(config.memoryDir, "threads"),
       config.threadingGapMinutes
     );
     const lifecycleCaps = resolveMemoryLifecycleCapabilities(config);
@@ -18870,9 +18921,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 path33 = 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 = path33 !== void 0 && kind !== void 0 ? { symbol, path: path33, kind } : path33 !== void 0 ? { symbol, path: path33 } : kind !== void 0 ? { symbol, kind } : { symbol };
   return item;
 }
 function classifySpawnError(err) {
@@ -18946,7 +18997,7 @@ var DEFAULT_GRACE_PERIOD_DAYS = 7;
 
 // src/binary-lifecycle/backend.ts
 import fsp from "fs/promises";
-import path17 from "path";
+import path19 from "path";
 var FilesystemBackend = class {
   type = "filesystem";
   basePath;
@@ -18954,19 +19005,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 = path19.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 = path19.isAbsolute(remotePath) ? path19.resolve(remotePath) : path19.resolve(this.basePath, remotePath);
+    const relative = path19.relative(this.basePath, resolved);
+    if (relative === ".." || relative.startsWith(`..${path19.sep}`) || path19.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 = path19.relative(realBase, candidate);
+    return relative === "" || relative !== ".." && !relative.startsWith(`..${path19.sep}`) && !path19.isAbsolute(relative);
   }
   async realBasePathIfExists() {
     try {
@@ -18995,13 +19046,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 = path19.dirname(dest);
+    const relativeDir = path19.relative(this.basePath, destDir);
+    const segments = relativeDir === "" ? [] : relativeDir.split(path19.sep);
     let current = this.basePath;
     for (const segment of segments) {
       if (segment === "." || segment === "") continue;
-      current = path17.join(current, segment);
+      current = path19.join(current, segment);
       try {
         const stat5 = await fsp.lstat(current);
         if (stat5.isSymbolicLink()) {
@@ -19029,13 +19080,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 = path19.dirname(dest);
+    const relativeDir = path19.relative(this.basePath, destDir);
+    const segments = relativeDir === "" ? [] : relativeDir.split(path19.sep);
     let current = this.basePath;
     for (const segment of segments) {
       if (segment === "." || segment === "") continue;
-      current = path17.join(current, segment);
+      current = path19.join(current, segment);
       let stat5;
       try {
         stat5 = await fsp.lstat(current);
@@ -19083,7 +19134,7 @@ var FilesystemBackend = class {
     return dest;
   }
   async upload(localPath, remotePath) {
-    if (path17.isAbsolute(remotePath)) {
+    if (path19.isAbsolute(remotePath)) {
       throw new Error(`FilesystemBackend upload remotePath must be relative: ${JSON.stringify(remotePath)}`);
     }
     const dest = this.resolveRemotePath(remotePath);
@@ -19156,7 +19207,7 @@ function createBackend(cfg) {
 
 // src/binary-lifecycle/scanner.ts
 import fsp2 from "fs/promises";
-import path18 from "path";
+import path20 from "path";
 import crypto from "crypto";
 function matchesPatterns(filename, patterns) {
   const lower = filename.toLowerCase();
@@ -19181,8 +19232,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 = path20.join(dir, entry.name);
+      const relativePath = path20.relative(memoryDir, fullPath).split(path20.sep).join("/");
       if (entry.isDirectory()) {
         if (entry.name === ".binary-lifecycle") continue;
         await walk(fullPath);
@@ -19222,15 +19273,15 @@ async function hashFile(filePath) {
 
 // src/binary-lifecycle/manifest.ts
 import fsp3 from "fs/promises";
-import path19 from "path";
+import path21 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 path21.join(memoryDir, MANIFEST_DIR);
 }
 function manifestPath(memoryDir) {
-  return path19.join(memoryDir, MANIFEST_DIR, MANIFEST_FILE);
+  return path21.join(memoryDir, MANIFEST_DIR, MANIFEST_FILE);
 }
 async function readManifest(memoryDir) {
   const filePath = manifestPath(memoryDir);
@@ -19282,13 +19333,13 @@ function emptyManifest() {
 
 // src/binary-lifecycle/pipeline.ts
 import fsp4 from "fs/promises";
-import path20 from "path";
+import path22 from "path";
 import crypto3 from "crypto";
 var historicalIdCache = new HistoricalEntityCanonicalIdCache();
 function isRecallCorpusMarkdown(mdPath, memoryDir) {
-  const rel = path20.relative(memoryDir, mdPath);
-  if (rel.startsWith("..") || path20.isAbsolute(rel)) return false;
-  const top = rel.split(path20.sep)[0];
+  const rel = path22.relative(memoryDir, mdPath);
+  if (rel.startsWith("..") || path22.isAbsolute(rel)) return false;
+  const top = rel.split(path22.sep)[0];
   return RECALL_FALLBACK_DIRS.includes(top);
 }
 async function hashFile2(filePath) {
@@ -19312,13 +19363,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("\\") || path22.isAbsolute(originalPath) || path22.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 = path22.resolve(memoryDir);
+  const fullPath = path22.resolve(memoryRoot, originalPath);
+  const relative = path22.relative(memoryRoot, fullPath);
+  if (relative === "" || relative === ".." || relative.startsWith(`..${path22.sep}`) || path22.isAbsolute(relative)) {
     return null;
   }
   return fullPath;
@@ -19329,7 +19380,7 @@ function validateBinaryLifecycleConfig(config) {
   }
 }
 function remotePathForAsset(backend, relPath) {
-  const normalized = relPath.split(path20.sep).join("/");
+  const normalized = relPath.split(path22.sep).join("/");
   if (backend.type === "filesystem") {
     return `.binary-lifecycle/mirrors/${normalized}`;
   }
@@ -19342,11 +19393,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 = path22.join(memoryDir, relPath);
     try {
       const stat5 = await fsp4.stat(fullPath);
       const contentHash = await hashFile2(fullPath);
-      const ext = path20.extname(relPath);
+      const ext = path22.extname(relPath);
       const mimeType = guessMimeType(ext);
       const remotePath = remotePathForAsset(backend, relPath);
       let backendLocation = remotePath;
@@ -19484,7 +19535,7 @@ async function stageRedirect(memoryDir, assets, log2, dryRun, readMarkdownFile,
     for (const update of updates) {
       try {
         await withRawEntityPageMutation(memoryDir, update.mdPath, async () => {
-          const stateDir = path20.join(memoryDir, "state");
+          const stateDir = path22.join(memoryDir, "state");
           const kind = classifyEntityRefWritePath(memoryDir, update.mdPath);
           if (kind === "memory") {
             const idsAtWrite = historicalIdCache.get(stateDir);
@@ -19578,10 +19629,10 @@ async function countRemainingLocalReferences(memoryDir, asset, assetAbsolute, md
   return { remaining, errors };
 }
 function markdownReferencePattern(asset, assetAbsolute, mdPath) {
-  const mdDir = path20.dirname(mdPath);
+  const mdDir = path22.dirname(mdPath);
   const candidates = /* @__PURE__ */ new Set();
   const addCandidate = (candidate) => {
-    const normalized = candidate.split(path20.sep).join("/");
+    const normalized = candidate.split(path22.sep).join("/");
     if (normalized.length === 0) return;
     candidates.add(normalized);
     const isParentTraversal = normalized === ".." || normalized.startsWith("../");
@@ -19589,10 +19640,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(path22.relative(mdDir, assetAbsolute));
+  const originalPath = asset.originalPath.split(path22.sep).join("/");
+  const originalAsFileRelative = path22.resolve(mdDir, ...originalPath.split("/"));
+  if (path22.resolve(originalAsFileRelative) === path22.resolve(assetAbsolute)) {
     addCandidate(originalPath);
   }
   addCandidate(`/${originalPath}`);
@@ -19688,7 +19739,7 @@ async function findMarkdownFiles(dir) {
       return;
     }
     for (const entry of entries) {
-      const full = path20.join(current, entry.name);
+      const full = path22.join(current, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === ".binary-lifecycle") continue;
         await walk(full);
@@ -19763,7 +19814,7 @@ async function runBinaryLifecyclePipeline(memoryDir, config, backend, log2, opts
 
 // src/projection/index.ts
 import fs from "fs";
-import path21 from "path";
+import path23 from "path";
 var VALID_PROJECTION_CATEGORIES = new Set(ALL_CATEGORY_KEYS);
 async function generateContextTree(options) {
   const startTime = Date.now();
@@ -19778,8 +19829,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 = path23.resolve(memoryDir);
+  const resolvedOutputDir = path23.resolve(outputDir);
   const requestedCategories = validateProjectionCategories(filterCategories);
   const realMemoryDir = assertSafeMemoryRoot(resolvedMemoryDir);
   assertNotSymlink(resolvedOutputDir, "context tree outputDir");
@@ -19817,7 +19868,7 @@ async function generateContextTree(options) {
     }
   }
   if (includeEntities) {
-    const entitiesDir = path21.join(memoryDir, "entities");
+    const entitiesDir = path23.join(memoryDir, "entities");
     if (fs.existsSync(entitiesDir)) {
       assertSafeInputRoot(realMemoryDir, entitiesDir, "entities root");
       categoryCounts["entity"] = 0;
@@ -19829,7 +19880,7 @@ async function generateContextTree(options) {
           continue;
         }
         const content = fs.readFileSync(filePath, "utf8");
-        const fileName = path21.basename(filePath, ".md");
+        const fileName = path23.basename(filePath, ".md");
         const node = projectEntityNode(fileName, content);
         const outputPath = resolveContainedOutputPath(realOutputDir, "entities", `${fileName}.md`);
         writeProjectedContent(realOutputDir, outputPath, node.content);
@@ -19841,7 +19892,7 @@ async function generateContextTree(options) {
   }
   const shouldIncludeQuestions = includeQuestions && (requestedCategories === void 0 || requestedCategories.includes("question"));
   if (shouldIncludeQuestions) {
-    const questionsDir = path21.join(memoryDir, "questions");
+    const questionsDir = path23.join(memoryDir, "questions");
     if (fs.existsSync(questionsDir)) {
       assertSafeInputRoot(realMemoryDir, questionsDir, "questions root");
       categoryCounts["question"] = 0;
@@ -19882,8 +19933,8 @@ async function generateContextTree(options) {
   };
 }
 function isPathInside(root, candidate) {
-  const relative = path21.relative(root, candidate);
-  return relative === "" || !relative.startsWith("..") && !path21.isAbsolute(relative);
+  const relative = path23.relative(root, candidate);
+  return relative === "" || !relative.startsWith("..") && !path23.isAbsolute(relative);
 }
 function assertNotSymlink(targetPath, label) {
   try {
@@ -19920,12 +19971,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 = path23.relative(realOutputDir, outputPath);
+  if (relative.startsWith("..") || path23.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(path23.sep).filter(Boolean)) {
+    current = path23.join(current, segment);
     try {
       const stat5 = fs.lstatSync(current);
       if (stat5.isSymbolicLink()) {
@@ -19955,17 +20006,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 = path23.resolve(outputRoot, ...segments);
+  const relative = path23.relative(outputRoot, resolved);
+  if (relative === "" || !relative.startsWith("..") && !path23.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(path23.dirname(outputPath), { recursive: true });
+  const realParent = fs.realpathSync(path23.dirname(outputPath));
   if (!isPathInside(realOutputDir, realParent)) {
     throw new Error(`context tree output path escapes outputDir: ${outputPath}`);
   }
@@ -20004,7 +20055,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 = path23.join(directory, entry.name);
       if (entry.isSymbolicLink()) {
         throw new Error(`context tree input path contains symlink: ${fullPath}`);
       }
@@ -20057,13 +20108,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 = path23.basename(filePath, ".md");
+  const dateDir = path23.basename(path23.dirname(filePath));
   let relPath;
   if (/^\d{4}-\d{2}-\d{2}$/.test(dateDir)) {
-    relPath = path21.join(category, dateDir, `${fileName}.md`);
+    relPath = path23.join(category, dateDir, `${fileName}.md`);
   } else {
-    relPath = path21.join(category, `${fileName}.md`);
+    relPath = path23.join(category, `${fileName}.md`);
   }
   const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
   const md = `# ${fm.id}
@@ -20109,7 +20160,7 @@ function projectEntityNode(fileName, content) {
 ${content}
 `;
   return {
-    path: path21.join("entities", `${fileName}.md`),
+    path: path23.join("entities", `${fileName}.md`),
     category: "entity",
     title: fileName,
     content: md,
@@ -20162,7 +20213,7 @@ function generateIndex(categoryCounts, outputDir) {
 
 // src/onboarding/index.ts
 import fs2 from "fs";
-import path22 from "path";
+import path24 from "path";
 var LANGUAGE_RULES = [
   {
     language: "TypeScript",
@@ -20264,7 +20315,7 @@ function onboard(options) {
     maxDepth = 6,
     excludeDirs = []
   } = options;
-  const directory = path22.resolve(options.directory ?? process.cwd());
+  const directory = path24.resolve(options.directory ?? process.cwd());
   let rootStat;
   try {
     rootStat = fs2.statSync(directory);
@@ -20306,7 +20357,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 = path24.join(dir, entry.name);
       if (entry.isDirectory()) {
         walk(fullPath, depth + 1);
       } else if (entry.isFile()) {
@@ -20321,11 +20372,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 = path24.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) => path24.dirname(f) === root).map((f) => path24.basename(f))
   );
   for (const rule of LANGUAGE_RULES) {
     const evidence = [];
@@ -20369,7 +20420,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) => path24.dirname(f) === root).map((f) => path24.basename(f))
   );
   const rootDirs = /* @__PURE__ */ new Set();
   try {
@@ -20380,7 +20431,7 @@ function detectShape(files, root) {
   }
   const evidence = [];
   if (rootFiles.has("package.json")) {
-    const pkg = readJsonSafe(path22.join(root, "package.json"));
+    const pkg = readJsonSafe(path24.join(root, "package.json"));
     if (pkg?.workspaces) {
       evidence.push("package.json has workspaces");
       return { shape: "monorepo", evidence };
@@ -20394,13 +20445,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(path24.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(path24.join(root, "package.json"));
     if (pkg?.exports || pkg?.main) {
       if (pkg?.bin) {
         evidence.push("package.json has bin");
@@ -20434,8 +20485,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 = path24.basename(filePath).toLowerCase();
+    const relPath = path24.relative(root, filePath);
     let kind;
     for (const { pattern, kind: k } of docPatterns) {
       if (pattern.test(basename)) {
@@ -20447,7 +20498,7 @@ function discoverDocs(files, root) {
       kind = "docs";
     }
     if (!kind && (basename.endsWith(".md") || basename.endsWith(".mdx"))) {
-      if (path22.dirname(relPath) === "." || isUnderDocsDir(relPath)) {
+      if (path24.dirname(relPath) === "." || isUnderDocsDir(relPath)) {
         kind = "docs";
       }
     }
@@ -20468,7 +20519,7 @@ function discoverDocs(files, root) {
   return docs;
 }
 function isUnderDocsDir(relPath) {
-  const parts = relPath.split(path22.sep);
+  const parts = relPath.split(path24.sep);
   return parts[0] === "docs" || parts[0] === "doc" || parts[0] === "documentation";
 }
 function buildPlan(languages, shape, docs, _root) {
@@ -20512,7 +20563,7 @@ function readTomlWorkspace(filePath) {
 
 // src/curation/index.ts
 import fs3 from "fs";
-import path23 from "path";
+import path25 from "path";
 import crypto4 from "crypto";
 async function curate(options) {
   const startTime = Date.now();
@@ -20603,12 +20654,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 = path25.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(path25.extname(entry.name).toLowerCase())) {
         results.push(fullPath);
       }
     }
@@ -20617,12 +20668,12 @@ function resolveTargets(targetPath) {
   return results;
 }
 function resolveProvenanceRoot(targetPath) {
-  const resolvedTarget = path23.resolve(targetPath);
+  const resolvedTarget = path25.resolve(targetPath);
   const stat5 = fs3.statSync(resolvedTarget);
-  return stat5.isFile() ? path23.dirname(resolvedTarget) : resolvedTarget;
+  return stat5.isFile() ? path25.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 = path25.relative(projectRoot, path25.resolve(filePath)) || path25.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);
@@ -20716,7 +20767,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 = path25.join(memoryDir, dir);
     if (!fs3.existsSync(fullDir)) continue;
     walkFiles(fullDir, (filePath) => {
       const content = readFileSafe(filePath);
@@ -20739,11 +20790,11 @@ 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 = path25.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 historicalIds = historicalIdCache2.get(path23.join(memoryDir, "state"));
+  const filePath = path25.join(dir, fileName);
+  const historicalIds = historicalIdCache2.get(path25.join(memoryDir, "state"));
   const rawBody = `${[
     "---",
     `id: ${stmt.id}`,
@@ -20766,7 +20817,7 @@ ${stmt.content}
   fs3.writeFileSync(filePath, body);
   try {
     repairContentAfterJournalMoveSync({
-      stateDir: path23.join(memoryDir, "state"),
+      stateDir: path25.join(memoryDir, "state"),
       cache: historicalIdCache2,
       idsAtWrite: historicalIds,
       rawContent: rawBody,
@@ -20827,7 +20878,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 = path25.join(dir, entry.name);
     if (entry.isDirectory()) {
       walkFiles(fullPath, callback);
     } else if (entry.name.endsWith(".md")) {
@@ -20838,7 +20889,7 @@ function walkFiles(dir, callback) {
 
 // src/dedup/index.ts
 import fs4 from "fs";
-import path24 from "path";
+import path26 from "path";
 import crypto5 from "crypto";
 var DEFAULT_DEDUP_THRESHOLD = 0.85;
 var DEFAULT_MAX_LOAD = 1e4;
@@ -20980,7 +21031,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 = path26.join(memoryDir, category);
     if (!fs4.existsSync(dir)) continue;
     const categoryStat = fs4.lstatSync(dir);
     if (categoryStat.isSymbolicLink()) {
@@ -21041,15 +21092,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 = path26.relative(rootReal, targetReal);
+  if (rel === "" || !rel.startsWith("..") && !path26.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 = path26.join(dir, entry.name);
     const entryStat = fs4.lstatSync(fullPath);
     if (entryStat.isSymbolicLink()) {
       throw new Error(`Refusing to scan symlinked memory path: ${fullPath}`);
@@ -21067,10 +21118,10 @@ function walkMdFiles(dir, memoryRootReal, categoryRootReal, callback) {
 
 // src/review/index.ts
 import fs5 from "fs";
-import path25 from "path";
+import path27 from "path";
 var historicalIdCache3 = new HistoricalEntityCanonicalIdCache();
 function writeReviewFileCanonicalized(memoryDir, filePath, content) {
-  const stateDir = path25.join(memoryDir, "state");
+  const stateDir = path27.join(memoryDir, "state");
   const idsAtWrite = historicalIdCache3.get(stateDir);
   let originalBytes = null;
   try {
@@ -21112,8 +21163,8 @@ function realMemoryRoot(memoryDir) {
   }
 }
 function isPathInside2(rootReal, candidateReal) {
-  const relative = path25.relative(rootReal, candidateReal);
-  return relative === "" || !!relative && !relative.startsWith("..") && !path25.isAbsolute(relative);
+  const relative = path27.relative(rootReal, candidateReal);
+  return relative === "" || !!relative && !relative.startsWith("..") && !path27.isAbsolute(relative);
 }
 function isSafeDirectory(rootReal, dir) {
   try {
@@ -21156,7 +21207,7 @@ function listReviewItems(options) {
     if (filterReason && item.reviewReason !== filterReason) return;
     items.push(item);
   };
-  const suggestionsDir = path25.join(memoryDir, "suggestions");
+  const suggestionsDir = path27.join(memoryDir, "suggestions");
   if (!isLimitReached() && fs5.existsSync(suggestionsDir) && isSafeDirectory(rootReal, suggestionsDir)) {
     walkMd(rootReal, suggestionsDir, (filePath, content) => {
       if (isLimitReached()) return true;
@@ -21177,7 +21228,7 @@ function listReviewItems(options) {
       return isLimitReached();
     });
   }
-  const reviewDir = path25.join(memoryDir, "review");
+  const reviewDir = path27.join(memoryDir, "review");
   if (!isLimitReached() && fs5.existsSync(reviewDir) && isSafeDirectory(rootReal, reviewDir)) {
     walkMd(rootReal, reviewDir, (filePath, content) => {
       if (isLimitReached()) return true;
@@ -21202,7 +21253,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 = path27.join(memoryDir, category);
     if (!fs5.existsSync(dir) || !isSafeDirectory(rootReal, dir)) continue;
     walkMd(rootReal, dir, (filePath, content) => {
       if (isLimitReached()) return true;
@@ -21284,9 +21335,9 @@ 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 reviewStateDir = path25.join(memoryDir, "state");
+  const outputPath = path27.join(targetDir, dateDir, path27.basename(found.filePath));
+  ensureSafeDirectory(rootReal, path27.dirname(outputPath));
+  const reviewStateDir = path27.join(memoryDir, "state");
   const idsAtWrite = historicalIdCache3.get(reviewStateDir);
   const promotedWritten = canonicalizeEntityRefFrontmatter(updatedContent, idsAtWrite);
   const promotedPath = writeFileWithoutClobber(outputPath, promotedWritten, itemId);
@@ -21363,13 +21414,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 = path27.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 = path27.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" };
@@ -21445,10 +21496,10 @@ function readFileSafe3(filePath) {
   }
 }
 function writeFileWithoutClobber(basePath, content, discriminator) {
-  const parsed = path25.parse(basePath);
+  const parsed = path27.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 : path27.join(
       parsed.dir,
       `${parsed.name}-${safeDiscriminator}${attempt === 1 ? "" : `-${attempt}`}${parsed.ext || ".md"}`
     );
@@ -21504,7 +21555,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 = path27.join(dir, entry.name);
     if (entry.isSymbolicLink()) continue;
     if (entry.isDirectory()) {
       if (walkMd(rootReal, fullPath, callback)) return true;
@@ -21519,7 +21570,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 = path27.join(dir, entry.name);
     if (entry.isSymbolicLink()) continue;
     if (entry.isDirectory()) {
       results.push(...walkMdPaths(rootReal, fullPath));
@@ -21532,7 +21583,7 @@ function walkMdPaths(rootReal, dir) {
 
 // src/sync/index.ts
 import fs6 from "fs";
-import path26 from "path";
+import path28 from "path";
 import crypto6 from "crypto";
 var DEFAULT_EXTENSIONS = /* @__PURE__ */ new Set([".md", ".txt", ".mdx", ".rst"]);
 var DEFAULT_EXCLUDE2 = /* @__PURE__ */ new Set([
@@ -21554,7 +21605,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 ?? path28.join(memoryDir, ".sync-state.json");
   const prevState = loadState(stateFilePath);
   const currentFiles = scanFiles(sourceDir, extSet, excludeSet);
   const changes = computeDiff(currentFiles, prevState.fileHashes, sourceDir);
@@ -21570,7 +21621,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(path28.dirname(stateFilePath), { recursive: true });
     fs6.writeFileSync(stateFilePath, JSON.stringify(newState, null, 2));
   }
   return {
@@ -21636,13 +21687,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 = path28.join(dir, entry.name);
       if (entry.isDirectory()) {
         walk(fullPath);
       } else if (entry.isFile()) {
-        const ext = path26.extname(entry.name).toLowerCase();
+        const ext = path28.extname(entry.name).toLowerCase();
         if (!extensions.has(ext)) continue;
-        const relPath = path26.relative(root, fullPath);
+        const relPath = path28.relative(root, fullPath);
         try {
           const content = fs6.readFileSync(fullPath, "utf8");
           result[relPath] = hashContent3(content);
@@ -21657,7 +21708,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 = path28.join(sourceDir, relPath);
     if (!(relPath in previous)) {
       let size = 0;
       try {
@@ -21690,7 +21741,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: path28.join(sourceDir, relPath),
         relativePath: relPath,
         type: "deleted",
         currentHash: "",
@@ -21720,21 +21771,21 @@ function hashContent3(content) {
 import { spawnSync } from "child_process";
 import crypto7 from "crypto";
 import fs7 from "fs";
-import path27 from "path";
+import path29 from "path";
 var historicalIdCache4 = new HistoricalEntityCanonicalIdCache();
 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 path29.resolve(memoryDir);
 }
 function getSpacesDir(baseDir) {
   const homeDir = baseDir ?? resolveHomeDir();
-  return path27.join(homeDir, ".config", "engram", "spaces");
+  return path29.join(homeDir, ".config", "engram", "spaces");
 }
 function getManifestPath(baseDir) {
-  return path27.join(getSpacesDir(baseDir), "manifest.json");
+  return path29.join(getSpacesDir(baseDir), "manifest.json");
 }
 function loadManifest(baseDir, memoryDirOverride) {
   if (fs7.existsSync(getManifestPath(baseDir))) {
@@ -21781,9 +21832,9 @@ function readManifestUnlocked(baseDir, memoryDirOverride, options = {}) {
 }
 function saveManifestUnlocked(manifest, baseDir) {
   const manifestPath2 = getManifestPath(baseDir);
-  const manifestDir2 = path27.dirname(manifestPath2);
+  const manifestDir2 = path29.dirname(manifestPath2);
   fs7.mkdirSync(manifestDir2, { recursive: true });
-  const tempPath = path27.join(manifestDir2, `.manifest.${process.pid}.${Date.now()}.${crypto7.randomUUID()}.tmp`);
+  const tempPath = path29.join(manifestDir2, `.manifest.${process.pid}.${Date.now()}.${crypto7.randomUUID()}.tmp`);
   try {
     fs7.writeFileSync(tempPath, `${JSON.stringify(manifest, null, 2)}
 `, { flag: "wx" });
@@ -21798,7 +21849,7 @@ function saveManifestUnlocked(manifest, baseDir) {
 }
 function withManifestLock(baseDir, operation) {
   const lockDir = `${getManifestPath(baseDir)}.lock`;
-  fs7.mkdirSync(path27.dirname(lockDir), { recursive: true });
+  fs7.mkdirSync(path29.dirname(lockDir), { recursive: true });
   const lockOwner = acquireManifestLock(lockDir);
   try {
     return operation();
@@ -21824,7 +21875,7 @@ function acquireManifestLock(lockDir) {
     try {
       fs7.mkdirSync(lockDir, { recursive: false });
       try {
-        fs7.writeFileSync(path27.join(lockDir, "owner"), `${owner}
+        fs7.writeFileSync(path29.join(lockDir, "owner"), `${owner}
 `, { flag: "wx" });
       } catch (error) {
         fs7.rmSync(lockDir, { recursive: true, force: true });
@@ -21854,7 +21905,7 @@ function acquireManifestLock(lockDir) {
 }
 function releaseManifestLock(lockDir, owner) {
   try {
-    const ownerPath = path27.join(lockDir, "owner");
+    const ownerPath = path29.join(lockDir, "owner");
     if (fs7.readFileSync(ownerPath, "utf8").trim() === owner) {
       fs7.rmSync(lockDir, { recursive: true, force: true });
     }
@@ -21870,7 +21921,7 @@ function removeStaleManifestLock(lockDir) {
   try {
     fs7.mkdirSync(reclaimDir, { recursive: false });
     try {
-      fs7.writeFileSync(path27.join(reclaimDir, "owner"), `${reclaimOwner}
+      fs7.writeFileSync(path29.join(reclaimDir, "owner"), `${reclaimOwner}
 `, { flag: "wx" });
     } catch (error) {
       fs7.rmSync(reclaimDir, { recursive: true, force: true });
@@ -21945,7 +21996,7 @@ function readManifestLockSnapshot(lockDir) {
     throw error;
   }
   try {
-    const owner = fs7.readFileSync(path27.join(lockDir, "owner"), "utf8").trim();
+    const owner = fs7.readFileSync(path29.join(lockDir, "owner"), "utf8").trim();
     return { mtimeMs: stat5.mtimeMs, owner };
   } catch (error) {
     if (error.code === "ENOENT") {
@@ -22017,8 +22068,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 = path29.join(homeDir, ".engram", "memory");
+  const openclawPath = path29.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();
@@ -22047,7 +22098,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 ?? path29.join(getSpacesDir(options.baseDir), id, "memory")
   );
   const space = updateManifest(options.baseDir, (manifest) => {
     if (manifest.spaces.some((s) => s.id === id)) {
@@ -22268,14 +22319,14 @@ async function mergeSpaces(sourceSpaceId, targetSpaceId, options) {
   };
 }
 function getAuditLog(baseDir) {
-  const auditPath = path27.join(getSpacesDir(baseDir), "audit.jsonl");
+  const auditPath = path29.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 = path29.join(getSpacesDir(baseDir), "audit.jsonl");
+  fs7.mkdirSync(path29.dirname(auditPath), { recursive: true });
   const full = {
     id: crypto7.randomUUID(),
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -22296,11 +22347,11 @@ async function copyMemories(sourceDir, targetDir, options) {
     sourceFiles.filter((p) => {
       const rp = safeRealpath(p);
       if (!rp || !isPathInsideRoot(rp, sourceRoot)) return false;
-      const rel = path27.relative(sourceRoot, rp);
-      const mapped = path27.resolve(targetRoot, rel);
+      const rel = path29.relative(sourceRoot, rp);
+      const mapped = path29.resolve(targetRoot, rel);
       if (!isPathInsideRoot(mapped, targetRoot)) return false;
       return classifyEntityRefWritePath(targetRoot, mapped) === "entity";
-    }).map((p) => path27.basename(p, ".md"))
+    }).map((p) => path29.basename(p, ".md"))
   );
   const firstEntityId = sourceEntityIds.values().next().value;
   if (firstEntityId === void 0) {
@@ -22308,7 +22359,7 @@ async function copyMemories(sourceDir, targetDir, options) {
   }
   return withRawEntityPageMutation(
     targetRoot,
-    path27.join(targetRoot, "entities", `${firstEntityId}.md`),
+    path29.join(targetRoot, "entities", `${firstEntityId}.md`),
     async () => copyPreparedMemories(
       sourceFiles,
       sourceRoot,
@@ -22335,14 +22386,14 @@ function copyPreparedMemories(sourceFiles, sourceRoot, targetRoot, sourceEntityI
       continue;
     }
     const content = fs7.readFileSync(sourcePath, "utf8");
-    const relativePath = path27.relative(sourceRoot, sourceRealPath);
-    const targetPath = path27.resolve(targetRoot, relativePath);
+    const relativePath = path29.relative(sourceRoot, sourceRealPath);
+    const targetPath = path29.resolve(targetRoot, relativePath);
     if (!isPathInsideRoot(targetPath, targetRoot)) {
       skipped++;
       continue;
     }
     const targetKind = classifyEntityRefWritePath(targetRoot, targetPath);
-    const idsAtCompare = historicalIdCache4.get(path27.join(targetRoot, "state"));
+    const idsAtCompare = historicalIdCache4.get(path29.join(targetRoot, "state"));
     const sourceRef = targetKind === "memory" ? readEntityRefFromFrontmatter(content) : null;
     const refHasSourceClaimant = sourceRef !== null && sourceEntityIds.has(sourceRef);
     const canonicalContent = targetKind === "memory" && !refHasSourceClaimant ? canonicalizeEntityRefFrontmatter(content, idsAtCompare) : content;
@@ -22369,7 +22420,7 @@ function copyPreparedMemories(sourceFiles, sourceRoot, targetRoot, sourceEntityI
     if (fs7.existsSync(targetPath) && !options?.force) {
       const targetContent = fs7.readFileSync(targetPath, "utf8");
       const targetHash = hashContent4(targetContent);
-      if (hashContent4(canonicalContent) === targetHash && historicalIdCache4.get(path27.join(targetRoot, "state")) === idsAtCompare) {
+      if (hashContent4(canonicalContent) === targetHash && historicalIdCache4.get(path29.join(targetRoot, "state")) === idsAtCompare) {
         skipped++;
         continue;
       }
@@ -22385,13 +22436,13 @@ function copyPreparedMemories(sourceFiles, sourceRoot, targetRoot, sourceEntityI
         continue;
       }
     }
-    fs7.mkdirSync(path27.dirname(targetPath), { recursive: true });
-    const targetParentRealPath = safeRealpath(path27.dirname(targetPath));
+    fs7.mkdirSync(path29.dirname(targetPath), { recursive: true });
+    const targetParentRealPath = safeRealpath(path29.dirname(targetPath));
     if (!targetParentRealPath || !isPathInsideRoot(targetParentRealPath, targetRoot)) {
       skipped++;
       continue;
     }
-    const stateDir = path27.join(targetRoot, "state");
+    const stateDir = path29.join(targetRoot, "state");
     if (targetKind === "memory" && !refHasSourceClaimant) {
       const idsAtWrite = historicalIdCache4.get(stateDir);
       const written = canonicalizeEntityRefFrontmatter(content, idsAtWrite);
@@ -22435,7 +22486,7 @@ function copyPreparedMemories(sourceFiles, sourceRoot, targetRoot, sourceEntityI
     bumpMemoryCorpusVersionForDir(targetRoot);
   }
   if (reconcileNeeded) {
-    requestEntityCanonicalIdReconcileSync(path27.join(targetRoot, "state"));
+    requestEntityCanonicalIdReconcileSync(path29.join(targetRoot, "state"));
   }
   return { merged, conflicts, skipped };
 }
@@ -22446,7 +22497,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 = path29.join(d, entry.name);
       if (entry.isSymbolicLink()) {
         continue;
       }
@@ -22475,8 +22526,8 @@ function safeRealpath(filePath) {
   }
 }
 function isPathInsideRoot(candidatePath, rootPath) {
-  const relative = path27.relative(rootPath, candidatePath);
-  return relative === "" || !relative.startsWith("..") && !path27.isAbsolute(relative);
+  const relative = path29.relative(rootPath, candidatePath);
+  return relative === "" || !relative.startsWith("..") && !path29.isAbsolute(relative);
 }
 function parseSimpleFrontmatter(content) {
   const match = content.match(/^---\n([\s\S]*?)\n---/);
@@ -22597,7 +22648,7 @@ var REMNIC_RECALL_DECISION_RULES = `## When to Use Recall vs Direct Read
 // src/memory-extension/codex-publisher.ts
 import fs8 from "fs";
 import os from "os";
-import path28 from "path";
+import path30 from "path";
 var REMNIC_EXTENSION_DIR_NAME = "remnic";
 function resolveEnvHome(env) {
   if (env === void 0) return resolveHomeDir();
@@ -22606,12 +22657,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 path30.join(homeDir, input.slice(2));
   }
   return input;
 }
 function normalizeHostRoot(input, homeDir) {
-  return path28.resolve(expandTildeWithHome(input.trim(), homeDir));
+  return path30.resolve(expandTildeWithHome(input.trim(), homeDir));
 }
 var CodexMemoryExtensionPublisher = class {
   hostId = "codex";
@@ -22625,12 +22676,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) : path30.resolve(homeDir, ".codex");
+    return path30.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() || path30.join(resolveHomeDir(), ".codex");
       return fs8.existsSync(home);
     } catch {
       return false;
@@ -22681,7 +22732,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 = path30.join(extensionRoot, "instructions.md");
     const filesWritten = [];
     const skipped = [];
     ctx.log.info(`Publishing Codex memory extension to ${extensionRoot}`);
@@ -23057,7 +23108,7 @@ async function generateActivityMemories(date, digestBody, config, deps) {
 // src/session-summaries/index.ts
 import { createHash as createHash7 } 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 path31 from "path";
 
 // src/session-summaries/adapters.ts
 var VALID_ROLES = /* @__PURE__ */ new Set(["user", "assistant", "tool", "system", "other"]);
@@ -23562,7 +23613,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}${path31.sep}` : entryName;
   async function visit(dir) {
     if (truncated) return;
     const entries = (await readdir4(dir, { withFileTypes: true })).sort(
@@ -23572,13 +23623,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 = path31.join(dir, entry.name);
       if (entry.isDirectory()) {
         await visit(fullPath);
         continue;
       }
       if (!entry.isFile()) continue;
-      const ext = path29.extname(entry.name).toLowerCase();
+      const ext = path31.extname(entry.name).toLowerCase();
       if (!SUPPORTED_EXTENSIONS.has(ext)) continue;
       out.push(fullPath);
       if (out.length > maxFiles) {
@@ -23605,7 +23656,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 path31.resolve(expandTildePath(inputDir.trim()));
 }
 function initRoleCounts() {
   return {
@@ -23762,11 +23813,11 @@ async function collectLocalSessionSummaries(options) {
       continue;
     }
     seenFileHashes.add(fileHash);
-    const fileExtension = path29.extname(filePath).toLowerCase();
+    const fileExtension = path31.extname(filePath).toLowerCase();
     const parsed = await adapter.parseFile(
       {
         content,
-        fileName: path29.basename(filePath),
+        fileName: path31.basename(filePath),
         fileExtension,
         fileRef: fileHash
       },
@@ -23822,7 +23873,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(path31.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");
@@ -23835,15 +23886,15 @@ function toJsonl(drafts) {
 }
 function defaultDraftOutputPath(memoryDir, generatedAt) {
   const stamp = generatedAt.replace(/[:.]/g, "-");
-  return path29.join(
-    path29.resolve(expandTildePath(memoryDir)),
+  return path31.join(
+    path31.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(path31.dirname(filePath), { recursive: true });
   const tempPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
   try {
     await writeFile7(tempPath, toJsonl(drafts), "utf-8");
@@ -23861,7 +23912,7 @@ async function runLocalSessionSummaryCliCommand(options) {
   });
   const wroteFiles = [];
   if (options.output) {
-    const outputPath = path29.resolve(expandTildePath(options.output));
+    const outputPath = path31.resolve(expandTildePath(options.output));
     await writeDrafts(outputPath, report.drafts);
     wroteFiles.push(outputPath);
   }
@@ -23896,19 +23947,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 path32 from "path";
 async function forkCapsule(opts) {
   validateForkId(opts.forkId);
-  const rootAbs = path30.resolve(opts.targetRoot);
+  const rootAbs = path32.resolve(opts.targetRoot);
   await assertIsDirectoryNotSymlink(rootAbs, "forkCapsule", "targetRoot");
-  const forkDirAbs = path30.join(rootAbs, "forks", opts.forkId);
+  const forkDirAbs = path32.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 = path32.resolve(opts.sourceArchive);
   const importResult = await importCapsule({
     archivePath: archiveAbs,
     root: rootAbs,
@@ -23930,10 +23981,10 @@ async function forkCapsule(opts) {
     importedRecords: importResult.imported.length,
     skippedRecords: importResult.skipped.length
   };
-  const lineagePath = path30.join(forkDirAbs, "lineage.json");
+  const lineagePath = path32.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(path32.dirname(lineagePath), { recursive: true });
   await writeFile8(lineagePath, JSON.stringify(lineage, null, 2) + "\n", "utf-8");
   return {
     archivePath: archiveAbs,
@@ -23947,11 +23998,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 = path32.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 = path32.join(rootReal, "forks", forkId, "lineage.json");
+  const rel = path32.relative(rootReal, lineagePath);
+  if (rel.startsWith("..") || path32.isAbsolute(rel)) {
     return null;
   }
   if (!await isLineagePathContained(rootReal, lineagePath)) {
@@ -23992,19 +24043,19 @@ async function pathEntryExists(absPath) {
 async function isLineagePathContained(rootReal, lineagePath) {
   let existing = lineagePath;
   const suffix = [];
-  while (existing !== path30.dirname(existing)) {
+  while (existing !== path32.dirname(existing)) {
     const st = await lstat3(existing).catch(() => null);
     if (st !== null) break;
-    suffix.unshift(path30.basename(existing));
-    existing = path30.dirname(existing);
+    suffix.unshift(path32.basename(existing));
+    existing = path32.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 ? path32.join(existingReal, ...suffix) : existingReal;
+  const rel = path32.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(`..${path32.sep}`)) return false;
+  if (path32.isAbsolute(rel)) return false;
   return true;
 }
 
@@ -24124,4 +24175,4 @@ export {
   filterRecallCandidates,
   Orchestrator
 };
-//# sourceMappingURL=chunk-DYVMXPCF.js.map
+//# sourceMappingURL=chunk-M32URQXV.js.map