@remnic/core 9.65.2 → 9.65.4

package/dist/{chunk-V3MXUL3D.js → chunk-ZPOHEB5Z.js}

@@ -6,14 +6,14 @@ import {
   loadSyncState,
   syncWearableSource,
   wearableSourceLabel
-} from "./chunk-CDUUDBWJ.js";
+} from "./chunk-VFYRYFLL.js";
 import {
   CompressionGuidelineCoordinator
 } from "./chunk-UXREWVW4.js";
 import {
   ActivityStore,
   MaintenanceScheduler
-} from "./chunk-CT56C22C.js";
+} from "./chunk-LYBIHM4N.js";
 import {
   runPeerProfileReasoner
 } from "./chunk-I74SUMNI.js";
@@ -32,7 +32,7 @@ import {
 import {
   CompoundingEngine,
   defaultTierMigrationCycleBudget
-} from "./chunk-2YI72KM3.js";
+} from "./chunk-UCKG36HO.js";
 import {
   SharedContextManager
 } from "./chunk-VI637ILW.js";
@@ -160,7 +160,7 @@ import {
 } from "./chunk-OH7QLI6W.js";
 import {
   ExtractionEngine
-} from "./chunk-LUNJ3WFO.js";
+} from "./chunk-ZK4BFABK.js";
 import {
   parseMemoryActionEligibilityContext
 } from "./chunk-7BDZTALN.js";
@@ -176,7 +176,7 @@ import {
   getVerdictKind,
   judgeFactDurability,
   validateProcedureExtraction
-} from "./chunk-3DVBKTSO.js";
+} from "./chunk-HSZMX3ZJ.js";
 import {
   buildExplicitCueRecallSection
 } from "./chunk-TVIVY7KU.js";
@@ -184,7 +184,7 @@ import {
   buildEntityRecallSection,
   entityRecentTranscriptLookbackHours,
   readRecentEntityTranscriptEntries
-} from "./chunk-DZUJ46DO.js";
+} from "./chunk-NLEH4RTB.js";
 import {
   planEpisodeWindowsWithFallback
 } from "./chunk-T3GIETKV.js";
@@ -209,14 +209,14 @@ import {
 } from "./chunk-VY47VI2T.js";
 import {
   refreshConvergedNamespaces
-} from "./chunk-Y7DK7HHJ.js";
+} from "./chunk-JPAKBNTM.js";
 import {
   builtInConnectorPackageSpecifier,
   ensureBuiltInWearableConnectors,
   getWearableConnector,
   listWearableConnectors,
   screenCandidateFact
-} from "./chunk-LGO6A7GJ.js";
+} from "./chunk-3JZBPTLD.js";
 import {
   RoutingRulesStore
 } from "./chunk-TBUEE7XF.js";
@@ -226,14 +226,14 @@ import {
 import {
   compareVerifiedEpisodeResults,
   searchVerifiedEpisodes
-} from "./chunk-2E36UXVW.js";
+} from "./chunk-ECLJ4LA2.js";
 import {
   ThreadingManager
 } from "./chunk-OJP3N7UK.js";
 import {
   compareVerifiedSemanticRuleResults,
   searchVerifiedSemanticRules
-} from "./chunk-ZO6AXLEH.js";
+} from "./chunk-OCCHUEZB.js";
 import {
   searchWorkProductLedgerEntries
 } from "./chunk-NRLELHAY.js";
@@ -246,13 +246,13 @@ import {
 import {
   runNamespaceMaintenanceFanout,
   summarizeNamespaceMaintenanceHealth
-} from "./chunk-ZWXJBFZU.js";
+} from "./chunk-YZJM6CLF.js";
 import {
   planNamespaceMaintenance
-} from "./chunk-MN4KB2A4.js";
+} from "./chunk-YDKF4MSJ.js";
 import {
   searchHarmonicRetrieval
-} from "./chunk-SIHSCCUQ.js";
+} from "./chunk-UFR6HX7A.js";
 import {
   isAboveImportanceThreshold,
   scoreImportance
@@ -287,7 +287,7 @@ import {
   materializeAfterSemanticConsolidation,
   parseConsolidationResponse,
   parseOperatorAwareConsolidationResponse
-} from "./chunk-ZQHI2BZB.js";
+} from "./chunk-HF5BUTI6.js";
 import {
   BootstrapEngine
 } from "./chunk-MYVPLJOO.js";
@@ -305,7 +305,7 @@ import {
 } from "./chunk-6TBIWIAG.js";
 import {
   detectMeetings
-} from "./chunk-BWLRUMOG.js";
+} from "./chunk-DPNXADEI.js";
 import {
   compileCorrectionRule,
   correctionsFilePath,
@@ -330,14 +330,14 @@ import {
 } from "./chunk-KD3QD3A5.js";
 import {
   MeetingsInputError
-} from "./chunk-4KYOLI6M.js";
+} from "./chunk-XGM3VQWG.js";
 import {
   WearablesInputError,
   describeErrorForOperator
 } from "./chunk-V7IZKJI3.js";
 import {
   NamespaceCatalog
-} from "./chunk-SQI57UCJ.js";
+} from "./chunk-DUEDOYZD.js";
 import {
   recordDreamsPhaseRun
 } from "./chunk-EQWEIIKQ.js";
@@ -354,7 +354,7 @@ import {
   filterRecallCandidates,
   isGenericRecallExcludedPath,
   isTopLevelArchivePath
-} from "./chunk-SB7D4BT7.js";
+} from "./chunk-AZLLH6YA.js";
 import {
   importCapsule
 } from "./chunk-6433HV72.js";
@@ -380,7 +380,7 @@ import {
 } from "./chunk-ZVZHG7AI.js";
 import {
   buildXraySnapshot
-} from "./chunk-3I7ASZN3.js";
+} from "./chunk-MFOSZUIT.js";
 import {
   objectiveStateStoreOverrideForNamespace,
   searchObjectiveStateSnapshots
@@ -395,9 +395,6 @@ import {
 import {
   LocalLlmClient
 } from "./chunk-IVKIODHO.js";
-import {
-  buildProcedurePersistBody
-} from "./chunk-QDW3E4RD.js";
 import {
   shouldSkipImplicitExtraction
 } from "./chunk-7BEPVIH3.js";
@@ -411,7 +408,7 @@ import {
 } from "./chunk-7ZNJN5WZ.js";
 import {
   NamespaceStorageRouter
-} from "./chunk-LZH5FR2W.js";
+} from "./chunk-CQBIN77D.js";
 import {
   GraphIndex
 } from "./chunk-BIJAWZYW.js";
@@ -462,12 +459,9 @@ import {
   isTaskInitiationIntent,
   planRecallMode
 } from "./chunk-CSAKJVXW.js";
-import {
-  searchCausalTrajectories
-} from "./chunk-PP7R754B.js";
 import {
   buildChainFollowupGenerator
-} from "./chunk-NTWN6HB2.js";
+} from "./chunk-IURMJBGP.js";
 import {
   QmdResultResolver,
   StorageManager,
@@ -486,7 +480,7 @@ import {
   reconstructFusionInputs,
   selfDeps,
   serializeFusionDay
-} from "./chunk-J275IYMG.js";
+} from "./chunk-THVI4Y7X.js";
 import {
   bodyIsEscaped,
   decodeTranscriptBody,
@@ -522,7 +516,7 @@ import {
 } from "./chunk-S2V7RUCL.js";
 import {
   confidenceTier
-} from "./chunk-SBDCZ2AX.js";
+} from "./chunk-LBFFNDFM.js";
 import {
   lintWorkspaceFiles,
   rotateMarkdownFileToArchive
@@ -590,6 +584,12 @@ import {
 import {
   assertExternalWikiRootOutsideMemoryDirCanonical
 } from "./chunk-JV3C2MNQ.js";
+import {
+  buildProcedurePersistBody
+} from "./chunk-QDW3E4RD.js";
+import {
+  searchCausalTrajectories
+} from "./chunk-PP7R754B.js";
 import {
   evaluateSubjectGuard,
   isSharedPromotionTarget,
@@ -650,13 +650,13 @@ import {
   excludeSupportPassportPrivateMemories,
   isSupportPassportPrivateMemory
 } from "./chunk-XDL5CYZN.js";
+import {
+  ContentHashIndex
+} from "./chunk-JOEJG4SD.js";
 import {
   normalizeAttributePairs,
   stripAttributesSuffix
 } from "./chunk-JDSVLVCG.js";
-import {
-  ContentHashIndex
-} from "./chunk-JOEJG4SD.js";
 import {
   sanitizeMemoryContent
 } from "./chunk-5GKPFL3S.js";
@@ -2061,6 +2061,49 @@ ${body}
   }
 };
 
+// src/preferences/drift-recall.ts
+var DAY_MS = 24 * 60 * 60 * 1e3;
+function isPreferenceDriftStageActive(config) {
+  if (!config) return false;
+  const damping = config.recallDamping && config.stalePenalty < 1;
+  return damping || config.annotateAfterDays > 0;
+}
+function driftAgeNote(frontmatter, config, now) {
+  if (config.annotateAfterDays <= 0) return void 0;
+  if (!frontmatter || frontmatter.category !== "preference") return void 0;
+  const anchor = frontmatter.lastCorroborated ?? frontmatter.created;
+  if (typeof anchor !== "string") return void 0;
+  const anchorMs = Date.parse(anchor);
+  if (!Number.isFinite(anchorMs)) return void 0;
+  const ageDays = Math.floor((now.getTime() - anchorMs) / DAY_MS);
+  if (ageDays < config.annotateAfterDays) return void 0;
+  const stated = new Date(anchorMs).toISOString().slice(0, 7);
+  return frontmatter.lastCorroborated ? `(corroborated ${stated}; not since)` : `(stated ${stated}; not corroborated since)`;
+}
+function applyPreferenceDriftRanking(inputs, options) {
+  const { config, now } = options;
+  const damping = config.recallDamping && config.stalePenalty < 1;
+  const scored = inputs.map((input, index) => {
+    const fm = input.frontmatter;
+    const isStalePreference = fm?.category === "preference" && fm.driftState === "stale";
+    const multiplier = damping && isStalePreference ? config.stalePenalty : 1;
+    return {
+      key: input.key,
+      index,
+      multiplier,
+      damped: input.rank * multiplier,
+      note: driftAgeNote(fm, config, now)
+    };
+  });
+  scored.sort((a, b) => {
+    if (a.damped !== b.damped) return a.damped > b.damped ? -1 : 1;
+    if (a.index !== b.index) return a.index < b.index ? -1 : 1;
+    if (a.key !== b.key) return a.key < b.key ? -1 : 1;
+    return 0;
+  });
+  return scored.map((s) => s.note ? { key: s.key, multiplier: s.multiplier, note: s.note } : { key: s.key, multiplier: s.multiplier });
+}
+
 // src/orchestration/recall-rerank-coordinator.ts
 function reconcileRecallResultPartition(partition, appliedResults) {
   return partition ? { appliedResults, headroomResults: partition.headroomResults } : null;
@@ -2260,7 +2303,7 @@ var RecallRerankCoordinator = class _RecallRerankCoordinator {
       namespaces,
       {
         readNamespaceMemories: async (ns) => (await this.getStorage(ns)).readAllMemories(),
-        readMemoryFrontmatter: async (path35, preferredNamespace) => {
+        readMemoryFrontmatter: async (path34, preferredNamespace) => {
           if (!fallbackReader) {
             for (const ns of namespaces) {
               try {
@@ -2272,7 +2315,7 @@ var RecallRerankCoordinator = class _RecallRerankCoordinator {
           }
           if (!fallbackReader) return null;
           const memory = await this.readQmdResultMemory(
-            path35,
+            path34,
             fallbackReader,
             namespaces,
             preferredNamespace
@@ -2337,9 +2380,13 @@ var RecallRerankCoordinator = class _RecallRerankCoordinator {
    * errors so a storage hiccup never breaks a fallback path.
    */
   async applyTrustScoreToBranch(results, namespaces, caps, label, preloadedFrontmatter, abortSignal) {
+    let staged = results;
+    let trustByPath = null;
     if (caps.recallTrustScore && results.length > 0) {
       try {
-        return await this.applyTrustScoreRerank(results, namespaces, preloadedFrontmatter, abortSignal);
+        const outcome = await this.applyTrustScoreRerank(results, namespaces, preloadedFrontmatter, abortSignal);
+        staged = outcome.results;
+        trustByPath = outcome.trustByPath;
       } catch (err) {
         log.debug(`trust-score stage (${label}) failed open`, {
           error: err.message
@@ -2347,20 +2394,106 @@ var RecallRerankCoordinator = class _RecallRerankCoordinator {
       }
     } else if (caps.recallMemoryWorthFilter && results.length > 0) {
       try {
-        const filtered = await this.applyMemoryWorthRerank(
+        staged = await this.applyMemoryWorthRerank(
           results,
           namespaces,
           preloadedFrontmatter,
           abortSignal
         );
-        return { results: filtered, trustByPath: null };
       } catch (err) {
         log.debug(`memory-worth filter (${label}) failed open`, {
           error: err.message
         });
       }
     }
-    return { results, trustByPath: null };
+    const damped = await this.applyPreferenceDriftStage(
+      staged,
+      namespaces,
+      preloadedFrontmatter,
+      abortSignal
+    );
+    return { results: damped, trustByPath };
+  }
+  /**
+   * Issue #2371 — stale-preference damping + injection annotation.
+   *
+   * Runs immediately after the trust/Memory-Worth stage on EVERY recall branch
+   * (hot QMD, embedding fallback, recent scan, cold fallback), so the feature
+   * gate applies uniformly and fallback parity holds (§27, AGENTS.md retrieval
+   * guardrails). Fully inert on the default config: when neither damping nor
+   * annotation is active the input array is returned untouched and NO
+   * frontmatter is read, so recall ordering and injected text stay
+   * byte-identical to pre-#2371.
+   *
+   * Fail-open: any lookup error leaves the branch's results unchanged.
+   */
+  async applyPreferenceDriftStage(results, namespaces, preloadedFrontmatter, abortSignal) {
+    const config = this.getConfig();
+    if (!isPreferenceDriftStageActive(config.driftDetection)) return results;
+    if (results.length === 0) return results;
+    try {
+      const frontmatterByKey = /* @__PURE__ */ new Map();
+      const missing = [];
+      for (const r of results) {
+        const key = memoryMapKey(r);
+        const preloaded = preloadedFrontmatter?.get(key) ?? preloadedFrontmatter?.get(r.path);
+        if (preloaded) {
+          frontmatterByKey.set(key, preloaded.frontmatter);
+        } else {
+          missing.push(r);
+        }
+      }
+      if (missing.length > 0) {
+        let reader = null;
+        for (const ns of namespaces) {
+          try {
+            reader = await this.getStorage(ns);
+            break;
+          } catch {
+          }
+        }
+        if (reader) {
+          const readerNn = reader;
+          const BATCH = 16;
+          for (let off = 0; off < missing.length; off += BATCH) {
+            if (abortSignal?.aborted) break;
+            await Promise.all(
+              missing.slice(off, off + BATCH).map(async (r) => {
+                try {
+                  const memory = await this.readQmdResultMemory(r.path, readerNn, namespaces, r.namespace);
+                  if (memory) frontmatterByKey.set(memoryMapKey(r), memory.frontmatter);
+                } catch (err) {
+                  log.debug("preference-drift: direct path lookup failed", {
+                    path: r.path,
+                    error: err.message
+                  });
+                }
+              })
+            );
+          }
+        }
+      }
+      const ranked = results.map((r, i) => ({
+        key: memoryMapKey(r),
+        rank: results.length - i,
+        frontmatter: frontmatterByKey.get(memoryMapKey(r))
+      }));
+      const ordered = applyPreferenceDriftRanking(ranked, {
+        config: config.driftDetection,
+        now: /* @__PURE__ */ new Date()
+      });
+      const byKey = new Map(results.map((r) => [memoryMapKey(r), r]));
+      const reordered = [];
+      for (const item of ordered) {
+        const original = byKey.get(item.key);
+        if (!original) continue;
+        reordered.push(item.note ? { ...original, driftNote: item.note } : original);
+      }
+      return reordered;
+    } catch (err) {
+      log.debug("preference-drift stage failed open", { error: err.message });
+      return results;
+    }
   }
   diversifyRecallResultsWithHeadroom(sectionId, results, limit, retrievalQuery, caps = resolveCapabilities(this.getConfig())) {
     const safeLimit = typeof limit === "number" && Number.isFinite(limit) ? Math.max(0, Math.floor(limit)) : 0;
@@ -13491,6 +13624,13 @@ var RecallSearchPipelineCoordinator = class {
         });
       }
     }
+    if (results.length > 0) {
+      results = await this.deps.recallRerankCoordinator.applyPreferenceDriftStage(
+        results,
+        options.recallNamespaces,
+        boostInput.memoryByPath
+      );
+    }
     if (options.xrayPoolSizeSink) {
       options.xrayPoolSizeSink.size = Math.max(
         options.xrayPoolSizeSink.size,
@@ -15512,7 +15652,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-H64ZCNIR.js");
+        const { startWearablesAutoSync } = await import("./auto-sync-XVMLL2RH.js");
         if (signal.aborted) return;
         this.deps.wearablesAutoSyncHandle = startWearablesAutoSync(
           {
@@ -22158,9 +22298,9 @@ function readStructuralSymbol(entry) {
   const rec = entry;
   const symbol = typeof rec.symbol === "string" ? rec.symbol.trim() : "";
   if (!symbol) return null;
-  const path35 = typeof rec.path === "string" && rec.path.length > 0 ? rec.path : void 0;
+  const path34 = 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 = path35 !== void 0 && kind !== void 0 ? { symbol, path: path35, kind } : path35 !== void 0 ? { symbol, path: path35 } : kind !== void 0 ? { symbol, kind } : { symbol };
+  const item = path34 !== void 0 && kind !== void 0 ? { symbol, path: path34, kind } : path34 !== void 0 ? { symbol, path: path34 } : kind !== void 0 ? { symbol, kind } : { symbol };
   return item;
 }
 function classifySpawnError(err) {
@@ -24431,474 +24571,9 @@ function walkMdFiles(dir, memoryRootReal, categoryRootReal, callback) {
   }
 }
 
-// src/review/index.ts
+// src/sync/index.ts
 import fs5 from "fs";
 import path29 from "path";
-var historicalIdCache3 = new HistoricalEntityCanonicalIdCache();
-function writeReviewFileCanonicalized(memoryDir, filePath, content) {
-  const stateDir = path29.join(memoryDir, "state");
-  const idsAtWrite = historicalIdCache3.get(stateDir);
-  let originalBytes = null;
-  try {
-    originalBytes = fs5.readFileSync(filePath, "utf8");
-  } catch {
-    originalBytes = null;
-  }
-  const written = canonicalizeEntityRefFrontmatter(content, idsAtWrite);
-  fs5.writeFileSync(filePath, written, "utf8");
-  try {
-    repairContentAfterJournalMoveSync({
-      stateDir,
-      cache: historicalIdCache3,
-      idsAtWrite,
-      rawContent: content,
-      lastWritten: written,
-      rewrite: (next) => fs5.writeFileSync(filePath, next, "utf8")
-    });
-  } catch (err) {
-    try {
-      if (originalBytes === null) {
-        fs5.unlinkSync(filePath);
-      } else {
-        fs5.writeFileSync(filePath, originalBytes, "utf8");
-      }
-    } catch {
-    }
-    throw err;
-  }
-}
-var DEFAULT_CONFIDENCE_THRESHOLD = 0.7;
-function realMemoryRoot(memoryDir) {
-  try {
-    const stat5 = fs5.lstatSync(memoryDir);
-    if (!stat5.isDirectory() || stat5.isSymbolicLink()) return null;
-    return fs5.realpathSync(memoryDir);
-  } catch {
-    return null;
-  }
-}
-function isPathInside2(rootReal, candidateReal) {
-  const relative = path29.relative(rootReal, candidateReal);
-  return relative === "" || !!relative && !relative.startsWith("..") && !path29.isAbsolute(relative);
-}
-function isSafeDirectory(rootReal, dir) {
-  try {
-    const stat5 = fs5.lstatSync(dir);
-    if (!stat5.isDirectory() || stat5.isSymbolicLink()) return false;
-    return isPathInside2(rootReal, fs5.realpathSync(dir));
-  } catch {
-    return false;
-  }
-}
-function ensureSafeDirectory(rootReal, dir) {
-  if (fs5.existsSync(dir)) {
-    if (!isSafeDirectory(rootReal, dir)) {
-      throw new Error(`Refusing to write through unsafe review path: ${dir}`);
-    }
-    return;
-  }
-  fs5.mkdirSync(dir, { recursive: true });
-  if (!isSafeDirectory(rootReal, dir)) {
-    throw new Error(`Refusing to write through unsafe review path: ${dir}`);
-  }
-}
-function listReviewItems(options) {
-  const startTime = Date.now();
-  const {
-    memoryDir,
-    reason: filterReason,
-    limit = 50,
-    confidenceThreshold = DEFAULT_CONFIDENCE_THRESHOLD
-  } = options;
-  const maxItems = Math.max(0, limit);
-  const rootReal = realMemoryRoot(memoryDir);
-  if (!rootReal || maxItems === 0) {
-    return { items: [], total: 0, durationMs: Date.now() - startTime };
-  }
-  const items = [];
-  const isLimitReached = () => items.length >= maxItems;
-  const addItem = (item) => {
-    if (isLimitReached()) return;
-    if (filterReason && item.reviewReason !== filterReason) return;
-    items.push(item);
-  };
-  const suggestionsDir = path29.join(memoryDir, "suggestions");
-  if (!isLimitReached() && fs5.existsSync(suggestionsDir) && isSafeDirectory(rootReal, suggestionsDir)) {
-    walkMd(rootReal, suggestionsDir, (filePath, content) => {
-      if (isLimitReached()) return true;
-      const fm = parseFrontmatter4(content);
-      const body = extractBody4(content);
-      if (!fm?.id) return false;
-      addItem({
-        id: fm.id,
-        content: body,
-        category: fm.category ?? "suggestion",
-        confidence: parseConfidence(fm.confidence, 0.5),
-        confidenceTier: fm.confidenceTier ?? "low",
-        source: fm.source ?? "unknown",
-        filePath,
-        created: fm.created ?? (/* @__PURE__ */ new Date()).toISOString(),
-        reviewReason: "suggestion"
-      });
-      return isLimitReached();
-    });
-  }
-  const reviewDir = path29.join(memoryDir, "review");
-  if (!isLimitReached() && fs5.existsSync(reviewDir) && isSafeDirectory(rootReal, reviewDir)) {
-    walkMd(rootReal, reviewDir, (filePath, content) => {
-      if (isLimitReached()) return true;
-      const fm = parseFrontmatter4(content);
-      const body = extractBody4(content);
-      if (!fm?.id) return false;
-      addItem({
-        id: fm.id,
-        content: body,
-        category: fm.category ?? "review",
-        confidence: parseConfidence(fm.confidence, 0.5),
-        confidenceTier: fm.confidenceTier ?? "low",
-        source: fm.source ?? "unknown",
-        filePath,
-        created: fm.created ?? (/* @__PURE__ */ new Date()).toISOString(),
-        reviewReason: fm.reviewReason ?? "low_confidence",
-        context: fm.context
-      });
-      return isLimitReached();
-    });
-  }
-  const categories = ALL_CATEGORY_DIRS;
-  for (const category of categories) {
-    if (isLimitReached()) break;
-    const dir = path29.join(memoryDir, category);
-    if (!fs5.existsSync(dir) || !isSafeDirectory(rootReal, dir)) continue;
-    walkMd(rootReal, dir, (filePath, content) => {
-      if (isLimitReached()) return true;
-      const fm = parseFrontmatter4(content);
-      const body = extractBody4(content);
-      if (!fm?.id) return false;
-      const confidence = parseConfidence(fm.confidence, 1);
-      if (confidence >= confidenceThreshold && !(typeof fm.blockedBy === "string" && fm.blockedBy.length > 0)) return false;
-      if (parseBoolean(fm.reviewDismissed)) return false;
-      if (items.some((i) => i.id === fm.id)) return false;
-      addItem({
-        id: fm.id,
-        content: body,
-        category: fm.category ?? category.slice(0, -1),
-        confidence,
-        confidenceTier: fm.confidenceTier ?? "low",
-        source: fm.source ?? "unknown",
-        filePath,
-        created: fm.created ?? (/* @__PURE__ */ new Date()).toISOString(),
-        reviewReason: typeof fm.blockedBy === "string" && fm.blockedBy.length > 0 ? "tombstone_blocked" : "low_confidence"
-      });
-      return isLimitReached();
-    });
-  }
-  return {
-    items,
-    total: items.length,
-    durationMs: Date.now() - startTime
-  };
-}
-function performReview(memoryDir, itemId, action, options = {}) {
-  const result = action === "approve" ? approveItem(memoryDir, itemId, options) : action === "dismiss" ? dismissItem(memoryDir, itemId, options) : flagItem(memoryDir, itemId, options);
-  if (result.updatedPath !== void 0) bumpMemoryCorpusVersionForDir(memoryDir);
-  return result;
-}
-function approveItem(memoryDir, itemId, options) {
-  const rootReal = realMemoryRoot(memoryDir);
-  if (!rootReal) return { itemId, action: "approve", message: "Item not found" };
-  const found = findReviewFileById(memoryDir, itemId, options);
-  if (!found) {
-    return { itemId, action: "approve", message: "Item not found" };
-  }
-  const content = fs5.readFileSync(found.filePath, "utf8");
-  const fm = parseFrontmatter4(content);
-  if (!fm) return { itemId, action: "approve", message: "Could not parse frontmatter" };
-  const blockedBy = typeof fm.blockedBy === "string" ? fm.blockedBy : null;
-  const fireBlockedRevocation = () => {
-    if (!blockedBy || !options.onApproveBlockedMemory) return;
-    try {
-      const maybe = options.onApproveBlockedMemory(blockedBy, itemId);
-      if (maybe && typeof maybe.then === "function") {
-        void maybe.catch(() => void 0);
-      }
-    } catch {
-    }
-  };
-  const updatedContent = updateFrontmatterFields(content, {
-    confidence: "0.9",
-    confidenceTier: "high",
-    reviewDismissed: null,
-    // Clear the tombstone-block markers so the promoted memory is active.
-    // Clear the tombstone-block markers AND restore active status so the
-    // promoted memory is fully active in recall + provenance (issue #1579
-    // review: leaving status: pending_review kept it invisible to recall).
-    ...blockedBy ? { blockedBy: null, tombstoneBlockTier: null, status: "active" } : {}
-  });
-  if (found.location === "category") {
-    writeReviewFileCanonicalized(memoryDir, found.filePath, updatedContent);
-    fireBlockedRevocation();
-    return {
-      itemId,
-      action: "approve",
-      updatedPath: found.filePath,
-      message: "Approved low-confidence memory in place with confidence 0.9",
-      ...blockedBy ? { clearedTombstoneId: blockedBy } : {}
-    };
-  }
-  const category = fm.category ?? "fact";
-  const targetDir = getCategoryDir(memoryDir, category);
-  const dateDir = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-  ensureSafeDirectory(rootReal, targetDir);
-  const outputPath = path29.join(targetDir, dateDir, path29.basename(found.filePath));
-  ensureSafeDirectory(rootReal, path29.dirname(outputPath));
-  const reviewStateDir = path29.join(memoryDir, "state");
-  const idsAtWrite = historicalIdCache3.get(reviewStateDir);
-  const promotedWritten = canonicalizeEntityRefFrontmatter(updatedContent, idsAtWrite);
-  const promotedPath = writeFileWithoutClobber(outputPath, promotedWritten, itemId);
-  try {
-    repairContentAfterJournalMoveSync({
-      stateDir: reviewStateDir,
-      cache: historicalIdCache3,
-      idsAtWrite,
-      rawContent: updatedContent,
-      lastWritten: promotedWritten,
-      rewrite: (next) => fs5.writeFileSync(promotedPath, next, "utf8")
-    });
-  } catch (err) {
-    try {
-      fs5.unlinkSync(promotedPath);
-    } catch {
-    }
-    throw err;
-  }
-  fs5.unlinkSync(found.filePath);
-  fireBlockedRevocation();
-  return {
-    itemId,
-    action: "approve",
-    updatedPath: promotedPath,
-    message: `Promoted to ${category} with confidence 0.9`,
-    ...blockedBy ? { clearedTombstoneId: blockedBy } : {}
-  };
-}
-function dismissItem(memoryDir, itemId, options) {
-  const found = findReviewFileById(memoryDir, itemId, options);
-  if (!found) {
-    return { itemId, action: "dismiss", message: "Item not found" };
-  }
-  if (found.location === "queue") {
-    fs5.unlinkSync(found.filePath);
-    return { itemId, action: "dismiss", message: "Dismissed and removed" };
-  }
-  const content = fs5.readFileSync(found.filePath, "utf8");
-  writeReviewFileCanonicalized(
-    memoryDir,
-    found.filePath,
-    updateFrontmatterFields(content, {
-      reviewDismissed: "true",
-      reviewDismissedAt: (/* @__PURE__ */ new Date()).toISOString()
-    })
-  );
-  return {
-    itemId,
-    action: "dismiss",
-    updatedPath: found.filePath,
-    message: "Dismissed low-confidence memory in place"
-  };
-}
-function flagItem(memoryDir, itemId, options) {
-  const found = findReviewFileById(memoryDir, itemId, options);
-  if (!found) {
-    return { itemId, action: "flag", message: "Item not found" };
-  }
-  const content = fs5.readFileSync(found.filePath, "utf8");
-  const fixed = updateFrontmatterFields(content, {
-    flagged: "true",
-    flaggedAt: (/* @__PURE__ */ new Date()).toISOString()
-  });
-  writeReviewFileCanonicalized(memoryDir, found.filePath, fixed);
-  return {
-    itemId,
-    action: "flag",
-    updatedPath: found.filePath,
-    message: "Flagged for further review"
-  };
-}
-function findReviewFileById(memoryDir, id, options = {}) {
-  const rootReal = realMemoryRoot(memoryDir);
-  if (!rootReal) return null;
-  for (const loc of ["suggestions", "review"]) {
-    const dir = path29.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 = path29.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" };
-  }
-  return null;
-}
-function findFileById(rootReal, dir, id, include) {
-  const files = walkMdPaths(rootReal, dir);
-  for (const filePath of files) {
-    const content = readFileSafe3(filePath);
-    if (!content) continue;
-    const fm = parseFrontmatter4(content);
-    if (fm?.id === id && (!include || include(fm))) return filePath;
-  }
-  return null;
-}
-function isLowConfidenceReviewCandidate(fm, options) {
-  const threshold = options.confidenceThreshold ?? DEFAULT_CONFIDENCE_THRESHOLD;
-  if (typeof fm.blockedBy === "string" && fm.blockedBy.length > 0) {
-    return !parseBoolean(fm.reviewDismissed);
-  }
-  return parseConfidence(fm.confidence, 1) < threshold && !parseBoolean(fm.reviewDismissed);
-}
-function parseBoolean(value) {
-  if (typeof value === "boolean") return value;
-  if (typeof value !== "string") return false;
-  const normalized = value.trim().toLowerCase();
-  return normalized === "true" || normalized === "1" || normalized === "yes";
-}
-function parseConfidence(value, fallback) {
-  if (typeof value === "number") return Number.isFinite(value) ? value : fallback;
-  if (typeof value === "string") {
-    const n = parseFloat(value);
-    return Number.isFinite(n) ? n : fallback;
-  }
-  return fallback;
-}
-function updateFrontmatterFields(content, fields) {
-  const match = content.match(/^(---\n)([\s\S]*?)(\n---(?:\n|$))/);
-  if (!match) return content;
-  const seen = /* @__PURE__ */ new Set();
-  const lines = match[2].split("\n");
-  const nextLines = [];
-  for (const line of lines) {
-    const colonIdx = line.indexOf(":");
-    if (colonIdx === -1) {
-      nextLines.push(line);
-      continue;
-    }
-    const key = line.slice(0, colonIdx).trim();
-    if (!Object.prototype.hasOwnProperty.call(fields, key)) {
-      nextLines.push(line);
-      continue;
-    }
-    seen.add(key);
-    const value = fields[key];
-    if (value !== null) {
-      nextLines.push(`${key}: ${value}`);
-    }
-  }
-  for (const [key, value] of Object.entries(fields)) {
-    if (value !== null && !seen.has(key)) {
-      nextLines.push(`${key}: ${value}`);
-    }
-  }
-  return `${match[1]}${nextLines.join("\n")}${match[3]}${content.slice(match[0].length)}`;
-}
-function readFileSafe3(filePath) {
-  try {
-    return fs5.readFileSync(filePath, "utf8");
-  } catch {
-    return null;
-  }
-}
-function writeFileWithoutClobber(basePath, content, discriminator) {
-  const parsed = path29.parse(basePath);
-  const safeDiscriminator = sanitizeFilePart(discriminator);
-  for (let attempt = 0; attempt < 1e3; attempt++) {
-    const candidate = attempt === 0 ? basePath : path29.join(
-      parsed.dir,
-      `${parsed.name}-${safeDiscriminator}${attempt === 1 ? "" : `-${attempt}`}${parsed.ext || ".md"}`
-    );
-    try {
-      fs5.writeFileSync(candidate, content, { encoding: "utf8", flag: "wx" });
-      return candidate;
-    } catch (error) {
-      if (error.code === "EEXIST") continue;
-      throw error;
-    }
-  }
-  throw new Error(`Could not find a free review promotion path for ${basePath}`);
-}
-function sanitizeFilePart(value) {
-  const chars = [];
-  let previousWasDash = false;
-  for (const char of value) {
-    const next = isSafeFilePartChar(char) ? char : "-";
-    if (next === "-" && previousWasDash) continue;
-    chars.push(next);
-    previousWasDash = next === "-";
-    if (chars.length >= 64) break;
-  }
-  let start = 0;
-  let end = chars.length;
-  while (start < end && chars[start] === "-") start++;
-  while (end > start && chars[end - 1] === "-") end--;
-  const sanitized = chars.slice(start, end).join("");
-  return sanitized || "review-item";
-}
-function isSafeFilePartChar(value) {
-  if (value.length !== 1) return false;
-  const code = value.charCodeAt(0);
-  return code >= 48 && code <= 57 || code >= 65 && code <= 90 || code >= 97 && code <= 122 || value === "." || value === "_" || value === "-";
-}
-function parseFrontmatter4(content) {
-  const match = content.match(/^---\n([\s\S]*?)\n---/);
-  if (!match) return null;
-  const fm = {};
-  for (const line of match[1].split("\n")) {
-    const colonIdx = line.indexOf(":");
-    if (colonIdx === -1) continue;
-    const key = line.slice(0, colonIdx).trim();
-    const value = line.slice(colonIdx + 1).trim();
-    fm[key] = value;
-  }
-  return fm;
-}
-function extractBody4(content) {
-  const match = content.match(/^---\n[\s\S]*?\n---\n([\s\S]*)/);
-  return match ? match[1].trim() : content.trim();
-}
-function walkMd(rootReal, dir, callback) {
-  if (!isSafeDirectory(rootReal, dir)) return false;
-  for (const entry of fs5.readdirSync(dir, { withFileTypes: true })) {
-    const fullPath = path29.join(dir, entry.name);
-    if (entry.isSymbolicLink()) continue;
-    if (entry.isDirectory()) {
-      if (walkMd(rootReal, fullPath, callback)) return true;
-    } else if (entry.isFile() && entry.name.endsWith(".md")) {
-      const content = readFileSafe3(fullPath);
-      if (content && callback(fullPath, content) === true) return true;
-    }
-  }
-  return false;
-}
-function walkMdPaths(rootReal, dir) {
-  const results = [];
-  if (!isSafeDirectory(rootReal, dir)) return results;
-  for (const entry of fs5.readdirSync(dir, { withFileTypes: true })) {
-    const fullPath = path29.join(dir, entry.name);
-    if (entry.isSymbolicLink()) continue;
-    if (entry.isDirectory()) {
-      results.push(...walkMdPaths(rootReal, fullPath));
-    } else if (entry.isFile() && entry.name.endsWith(".md")) {
-      results.push(fullPath);
-    }
-  }
-  return results;
-}
-
-// src/sync/index.ts
-import fs6 from "fs";
-import path30 from "path";
 import crypto6 from "crypto";
 var DEFAULT_EXTENSIONS = /* @__PURE__ */ new Set([".md", ".txt", ".mdx", ".rst"]);
 var DEFAULT_EXCLUDE2 = /* @__PURE__ */ new Set([
@@ -24920,7 +24595,7 @@ function syncChanges(options) {
   } = options;
   const extSet = new Set(extensions);
   const excludeSet = /* @__PURE__ */ new Set([...DEFAULT_EXCLUDE2, ...excludeDirs]);
-  const stateFilePath = options.stateFile ?? path30.join(memoryDir, ".sync-state.json");
+  const stateFilePath = options.stateFile ?? path29.join(memoryDir, ".sync-state.json");
   const prevState = loadState(stateFilePath);
   const currentFiles = scanFiles(sourceDir, extSet, excludeSet);
   const changes = computeDiff(currentFiles, prevState.fileHashes, sourceDir);
@@ -24936,8 +24611,8 @@ function syncChanges(options) {
     for (const [relPath, hash] of Object.entries(currentFiles)) {
       newState.fileHashes[relPath] = hash;
     }
-    fs6.mkdirSync(path30.dirname(stateFilePath), { recursive: true });
-    fs6.writeFileSync(stateFilePath, JSON.stringify(newState, null, 2));
+    fs5.mkdirSync(path29.dirname(stateFilePath), { recursive: true });
+    fs5.writeFileSync(stateFilePath, JSON.stringify(newState, null, 2));
   }
   return {
     scanned: Object.keys(currentFiles).length,
@@ -24991,7 +24666,7 @@ function scanFiles(root, extensions, exclude) {
   function walk(dir, isRoot = false) {
     let entries;
     try {
-      entries = fs6.readdirSync(dir, { withFileTypes: true });
+      entries = fs5.readdirSync(dir, { withFileTypes: true });
     } catch (err) {
       if (isRoot) {
         throw new Error(
@@ -25002,15 +24677,15 @@ function scanFiles(root, extensions, exclude) {
     }
     for (const entry of entries) {
       if (exclude.has(entry.name)) continue;
-      const fullPath = path30.join(dir, entry.name);
+      const fullPath = path29.join(dir, entry.name);
       if (entry.isDirectory()) {
         walk(fullPath);
       } else if (entry.isFile()) {
-        const ext = path30.extname(entry.name).toLowerCase();
+        const ext = path29.extname(entry.name).toLowerCase();
         if (!extensions.has(ext)) continue;
-        const relPath = path30.relative(root, fullPath);
+        const relPath = path29.relative(root, fullPath);
         try {
-          const content = fs6.readFileSync(fullPath, "utf8");
+          const content = fs5.readFileSync(fullPath, "utf8");
           result[relPath] = hashContent3(content);
         } catch {
         }
@@ -25023,11 +24698,11 @@ function scanFiles(root, extensions, exclude) {
 function computeDiff(current, previous, sourceDir) {
   const changes = [];
   for (const [relPath, hash] of Object.entries(current)) {
-    const fullPath = path30.join(sourceDir, relPath);
+    const fullPath = path29.join(sourceDir, relPath);
     if (!(relPath in previous)) {
       let size = 0;
       try {
-        size = fs6.statSync(fullPath).size;
+        size = fs5.statSync(fullPath).size;
       } catch {
       }
       changes.push({
@@ -25040,7 +24715,7 @@ function computeDiff(current, previous, sourceDir) {
     } else if (previous[relPath] !== hash) {
       let size = 0;
       try {
-        size = fs6.statSync(fullPath).size;
+        size = fs5.statSync(fullPath).size;
       } catch {
       }
       changes.push({
@@ -25056,7 +24731,7 @@ function computeDiff(current, previous, sourceDir) {
   for (const relPath of Object.keys(previous)) {
     if (!(relPath in current)) {
       changes.push({
-        filePath: path30.join(sourceDir, relPath),
+        filePath: path29.join(sourceDir, relPath),
         relativePath: relPath,
         type: "deleted",
         currentHash: "",
@@ -25068,7 +24743,7 @@ function computeDiff(current, previous, sourceDir) {
 }
 function loadState(stateFilePath) {
   try {
-    const raw = fs6.readFileSync(stateFilePath, "utf8");
+    const raw = fs5.readFileSync(stateFilePath, "utf8");
     return JSON.parse(raw);
   } catch {
     return {
@@ -25085,25 +24760,25 @@ function hashContent3(content) {
 // src/spaces/index.ts
 import { spawnSync } from "child_process";
 import crypto7 from "crypto";
-import fs7 from "fs";
-import path31 from "path";
-var historicalIdCache4 = new HistoricalEntityCanonicalIdCache();
+import fs6 from "fs";
+import path30 from "path";
+var historicalIdCache3 = 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 path31.resolve(memoryDir);
+  return path30.resolve(memoryDir);
 }
 function getSpacesDir(baseDir) {
   const homeDir = baseDir ?? resolveHomeDir();
-  return path31.join(homeDir, ".config", "engram", "spaces");
+  return path30.join(homeDir, ".config", "engram", "spaces");
 }
 function getManifestPath(baseDir) {
-  return path31.join(getSpacesDir(baseDir), "manifest.json");
+  return path30.join(getSpacesDir(baseDir), "manifest.json");
 }
 function loadManifest(baseDir, memoryDirOverride) {
-  if (fs7.existsSync(getManifestPath(baseDir))) {
+  if (fs6.existsSync(getManifestPath(baseDir))) {
     try {
       return readManifestUnlocked(baseDir, memoryDirOverride, { bootstrapIfMissing: false });
     } catch (error) {
@@ -25129,7 +24804,7 @@ function updateManifest(baseDir, updater, memoryDirOverride) {
 }
 function readManifestUnlocked(baseDir, memoryDirOverride, options = {}) {
   const manifestPath2 = getManifestPath(baseDir);
-  if (!fs7.existsSync(manifestPath2)) {
+  if (!fs6.existsSync(manifestPath2)) {
     if (options.bootstrapIfMissing === false) {
       const error = new Error(`Spaces manifest not found: ${manifestPath2}`);
       error.code = "ENOENT";
@@ -25142,21 +24817,21 @@ function readManifestUnlocked(baseDir, memoryDirOverride, options = {}) {
       version: MANIFEST_VERSION
     };
   }
-  const raw = JSON.parse(fs7.readFileSync(manifestPath2, "utf8"));
+  const raw = JSON.parse(fs6.readFileSync(manifestPath2, "utf8"));
   return raw;
 }
 function saveManifestUnlocked(manifest, baseDir) {
   const manifestPath2 = getManifestPath(baseDir);
-  const manifestDir2 = path31.dirname(manifestPath2);
-  fs7.mkdirSync(manifestDir2, { recursive: true });
-  const tempPath = path31.join(manifestDir2, `.manifest.${process.pid}.${Date.now()}.${crypto7.randomUUID()}.tmp`);
+  const manifestDir2 = path30.dirname(manifestPath2);
+  fs6.mkdirSync(manifestDir2, { recursive: true });
+  const tempPath = path30.join(manifestDir2, `.manifest.${process.pid}.${Date.now()}.${crypto7.randomUUID()}.tmp`);
   try {
-    fs7.writeFileSync(tempPath, `${JSON.stringify(manifest, null, 2)}
+    fs6.writeFileSync(tempPath, `${JSON.stringify(manifest, null, 2)}
 `, { flag: "wx" });
-    fs7.renameSync(tempPath, manifestPath2);
+    fs6.renameSync(tempPath, manifestPath2);
   } catch (error) {
     try {
-      fs7.rmSync(tempPath, { force: true });
+      fs6.rmSync(tempPath, { force: true });
     } catch {
     }
     throw error;
@@ -25164,7 +24839,7 @@ function saveManifestUnlocked(manifest, baseDir) {
 }
 function withManifestLock(baseDir, operation) {
   const lockDir = `${getManifestPath(baseDir)}.lock`;
-  fs7.mkdirSync(path31.dirname(lockDir), { recursive: true });
+  fs6.mkdirSync(path30.dirname(lockDir), { recursive: true });
   const lockOwner = acquireManifestLock(lockDir);
   try {
     return operation();
@@ -25177,10 +24852,10 @@ function acquireManifestLock(lockDir) {
   const owner = createManifestLockOwner();
   const reclaimDir = getManifestLockReclaimDir(lockDir);
   while (true) {
-    if (fs7.existsSync(reclaimDir)) {
+    if (fs6.existsSync(reclaimDir)) {
       removeStaleManifestReclaimLock(reclaimDir);
     }
-    if (fs7.existsSync(reclaimDir)) {
+    if (fs6.existsSync(reclaimDir)) {
       if (Date.now() >= deadline) {
         throw new Error(`Timed out waiting for spaces manifest reclaim lock: ${reclaimDir}`);
       }
@@ -25188,15 +24863,15 @@ function acquireManifestLock(lockDir) {
       continue;
     }
     try {
-      fs7.mkdirSync(lockDir, { recursive: false });
+      fs6.mkdirSync(lockDir, { recursive: false });
       try {
-        fs7.writeFileSync(path31.join(lockDir, "owner"), `${owner}
+        fs6.writeFileSync(path30.join(lockDir, "owner"), `${owner}
 `, { flag: "wx" });
       } catch (error) {
-        fs7.rmSync(lockDir, { recursive: true, force: true });
+        fs6.rmSync(lockDir, { recursive: true, force: true });
         throw error;
       }
-      if (fs7.existsSync(reclaimDir)) {
+      if (fs6.existsSync(reclaimDir)) {
         releaseManifestLock(lockDir, owner);
         if (Date.now() >= deadline) {
           throw new Error(`Timed out waiting for spaces manifest reclaim lock: ${reclaimDir}`);
@@ -25220,9 +24895,9 @@ function acquireManifestLock(lockDir) {
 }
 function releaseManifestLock(lockDir, owner) {
   try {
-    const ownerPath = path31.join(lockDir, "owner");
-    if (fs7.readFileSync(ownerPath, "utf8").trim() === owner) {
-      fs7.rmSync(lockDir, { recursive: true, force: true });
+    const ownerPath = path30.join(lockDir, "owner");
+    if (fs6.readFileSync(ownerPath, "utf8").trim() === owner) {
+      fs6.rmSync(lockDir, { recursive: true, force: true });
     }
   } catch (error) {
     if (error.code !== "ENOENT") {
@@ -25234,12 +24909,12 @@ function removeStaleManifestLock(lockDir) {
   const reclaimDir = getManifestLockReclaimDir(lockDir);
   const reclaimOwner = createManifestLockOwner();
   try {
-    fs7.mkdirSync(reclaimDir, { recursive: false });
+    fs6.mkdirSync(reclaimDir, { recursive: false });
     try {
-      fs7.writeFileSync(path31.join(reclaimDir, "owner"), `${reclaimOwner}
+      fs6.writeFileSync(path30.join(reclaimDir, "owner"), `${reclaimOwner}
 `, { flag: "wx" });
     } catch (error) {
-      fs7.rmSync(reclaimDir, { recursive: true, force: true });
+      fs6.rmSync(reclaimDir, { recursive: true, force: true });
       throw error;
     }
   } catch (error) {
@@ -25259,16 +24934,16 @@ function removeStaleManifestLock(lockDir) {
     }
     const tombstoneDir = `${lockDir}.stale.${process.pid}.${crypto7.randomUUID()}`;
     try {
-      fs7.renameSync(lockDir, tombstoneDir);
+      fs6.renameSync(lockDir, tombstoneDir);
     } catch (error) {
       if (error.code !== "ENOENT") {
         throw error;
       }
       return;
     }
-    fs7.rmSync(tombstoneDir, { recursive: true, force: true });
+    fs6.rmSync(tombstoneDir, { recursive: true, force: true });
   } finally {
-    fs7.rmSync(reclaimDir, { recursive: true, force: true });
+    fs6.rmSync(reclaimDir, { recursive: true, force: true });
   }
 }
 function getManifestLockReclaimDir(lockDir) {
@@ -25291,19 +24966,19 @@ function removeStaleManifestReclaimLock(reclaimDir) {
   }
   const tombstoneDir = `${reclaimDir}.stale.${process.pid}.${crypto7.randomUUID()}`;
   try {
-    fs7.renameSync(reclaimDir, tombstoneDir);
+    fs6.renameSync(reclaimDir, tombstoneDir);
   } catch (error) {
     if (error.code !== "ENOENT") {
       throw error;
     }
     return;
   }
-  fs7.rmSync(tombstoneDir, { recursive: true, force: true });
+  fs6.rmSync(tombstoneDir, { recursive: true, force: true });
 }
 function readManifestLockSnapshot(lockDir) {
   let stat5;
   try {
-    stat5 = fs7.statSync(lockDir);
+    stat5 = fs6.statSync(lockDir);
   } catch (error) {
     if (error.code === "ENOENT") {
       return void 0;
@@ -25311,7 +24986,7 @@ function readManifestLockSnapshot(lockDir) {
     throw error;
   }
   try {
-    const owner = fs7.readFileSync(path31.join(lockDir, "owner"), "utf8").trim();
+    const owner = fs6.readFileSync(path30.join(lockDir, "owner"), "utf8").trim();
     return { mtimeMs: stat5.mtimeMs, owner };
   } catch (error) {
     if (error.code === "ENOENT") {
@@ -25383,9 +25058,9 @@ function sleepSync(ms) {
 }
 function createPersonalSpace(baseDir, memoryDirOverride) {
   const homeDir = baseDir ?? resolveHomeDir();
-  const standalonePath = path31.join(homeDir, ".engram", "memory");
-  const openclawPath = path31.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 standalonePath = path30.join(homeDir, ".engram", "memory");
+  const openclawPath = path30.join(homeDir, ".openclaw", "workspace", "memory", "local");
+  const memoryDir = memoryDirOverride ?? readEnvVar("REMNIC_MEMORY_DIR") ?? readEnvVar("ENGRAM_MEMORY_DIR") ?? (fs6.existsSync(standalonePath) ? standalonePath : fs6.existsSync(openclawPath) ? openclawPath : standalonePath);
   const normalizedMemoryDir = normalizeSpaceMemoryDir(memoryDir);
   const now = (/* @__PURE__ */ new Date()).toISOString();
   return {
@@ -25413,7 +25088,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 ?? path31.join(getSpacesDir(options.baseDir), id, "memory")
+    options.memoryDir ?? path30.join(getSpacesDir(options.baseDir), id, "memory")
   );
   const space = updateManifest(options.baseDir, (manifest) => {
     if (manifest.spaces.some((s) => s.id === id)) {
@@ -25433,7 +25108,7 @@ function createSpace(options) {
       owner: readEnvVar("USER"),
       parentSpaceId: options.parentSpaceId
     };
-    fs7.mkdirSync(memoryDir, { recursive: true });
+    fs6.mkdirSync(memoryDir, { recursive: true });
     manifest.spaces.push(created);
     manifest.updatedAt = now;
     return created;
@@ -25591,9 +25266,9 @@ async function promoteSpace(sourceSpaceId, targetSpaceId, options) {
   const subjectWarnings = [];
   const warnedMemoryIds = [];
   if (target.kind === "team") {
-    const sourceFiles = fs7.existsSync(source.memoryDir) ? walkMd2(fs7.realpathSync(source.memoryDir)) : [];
+    const sourceFiles = fs6.existsSync(source.memoryDir) ? walkMd(fs6.realpathSync(source.memoryDir)) : [];
     for (const file of sourceFiles) {
-      const fm = parseSimpleFrontmatter(fs7.readFileSync(file, "utf8"));
+      const fm = parseSimpleFrontmatter(fs6.readFileSync(file, "utf8"));
       if (!fm?.id) continue;
       if (options?.memoryIds?.length && !options.memoryIds.includes(fm.id)) continue;
       const decision = evaluateSubjectGuard({
@@ -25659,39 +25334,39 @@ async function mergeSpaces(sourceSpaceId, targetSpaceId, options) {
   };
 }
 function getAuditLog(baseDir) {
-  const auditPath = path31.join(getSpacesDir(baseDir), "audit.jsonl");
-  if (!fs7.existsSync(auditPath)) return [];
-  const lines = fs7.readFileSync(auditPath, "utf8").trim().split("\n");
+  const auditPath = path30.join(getSpacesDir(baseDir), "audit.jsonl");
+  if (!fs6.existsSync(auditPath)) return [];
+  const lines = fs6.readFileSync(auditPath, "utf8").trim().split("\n");
   return lines.filter((l) => l.trim()).map((l) => JSON.parse(l));
 }
 function appendAudit(entry, baseDir) {
-  const auditPath = path31.join(getSpacesDir(baseDir), "audit.jsonl");
-  fs7.mkdirSync(path31.dirname(auditPath), { recursive: true });
+  const auditPath = path30.join(getSpacesDir(baseDir), "audit.jsonl");
+  fs6.mkdirSync(path30.dirname(auditPath), { recursive: true });
   const full = {
     id: crypto7.randomUUID(),
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
     ...entry
   };
-  fs7.appendFileSync(auditPath, `${JSON.stringify(full)}
+  fs6.appendFileSync(auditPath, `${JSON.stringify(full)}
 `);
 }
 async function copyMemories(sourceDir, targetDir, options) {
-  if (!fs7.existsSync(sourceDir)) {
+  if (!fs6.existsSync(sourceDir)) {
     return { merged: 0, conflicts: [], skipped: 0 };
   }
-  const sourceRoot = fs7.realpathSync(sourceDir);
-  fs7.mkdirSync(targetDir, { recursive: true });
-  const targetRoot = fs7.realpathSync(targetDir);
-  const sourceFiles = walkMd2(sourceRoot);
+  const sourceRoot = fs6.realpathSync(sourceDir);
+  fs6.mkdirSync(targetDir, { recursive: true });
+  const targetRoot = fs6.realpathSync(targetDir);
+  const sourceFiles = walkMd(sourceRoot);
   const sourceEntityIds = new Set(
     sourceFiles.filter((p) => {
       const rp = safeRealpath(p);
       if (!rp || !isPathInsideRoot(rp, sourceRoot)) return false;
-      const rel = path31.relative(sourceRoot, rp);
-      const mapped = path31.resolve(targetRoot, rel);
+      const rel = path30.relative(sourceRoot, rp);
+      const mapped = path30.resolve(targetRoot, rel);
       if (!isPathInsideRoot(mapped, targetRoot)) return false;
       return classifyEntityRefWritePath(targetRoot, mapped) === "entity";
-    }).map((p) => path31.basename(p, ".md"))
+    }).map((p) => path30.basename(p, ".md"))
   );
   const firstEntityId = sourceEntityIds.values().next().value;
   if (firstEntityId === void 0) {
@@ -25699,7 +25374,7 @@ async function copyMemories(sourceDir, targetDir, options) {
   }
   return withRawEntityPageMutation(
     targetRoot,
-    path31.join(targetRoot, "entities", `${firstEntityId}.md`),
+    path30.join(targetRoot, "entities", `${firstEntityId}.md`),
     async () => copyPreparedMemories(
       sourceFiles,
       sourceRoot,
@@ -25725,15 +25400,15 @@ function copyPreparedMemories(sourceFiles, sourceRoot, targetRoot, sourceEntityI
       skipped++;
       continue;
     }
-    const content = fs7.readFileSync(sourcePath, "utf8");
-    const relativePath = path31.relative(sourceRoot, sourceRealPath);
-    const targetPath = path31.resolve(targetRoot, relativePath);
+    const content = fs6.readFileSync(sourcePath, "utf8");
+    const relativePath = path30.relative(sourceRoot, sourceRealPath);
+    const targetPath = path30.resolve(targetRoot, relativePath);
     if (!isPathInsideRoot(targetPath, targetRoot)) {
       skipped++;
       continue;
     }
     const targetKind = classifyEntityRefWritePath(targetRoot, targetPath);
-    const idsAtCompare = historicalIdCache4.get(path31.join(targetRoot, "state"));
+    const idsAtCompare = historicalIdCache3.get(path30.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;
@@ -25745,7 +25420,7 @@ function copyPreparedMemories(sourceFiles, sourceRoot, targetRoot, sourceEntityI
         continue;
       }
     }
-    if (fs7.existsSync(targetPath)) {
+    if (fs6.existsSync(targetPath)) {
       const targetStat = safeLstat(targetPath);
       if (!targetStat?.isFile() || targetStat.isSymbolicLink()) {
         skipped++;
@@ -25757,10 +25432,10 @@ function copyPreparedMemories(sourceFiles, sourceRoot, targetRoot, sourceEntityI
         continue;
       }
     }
-    if (fs7.existsSync(targetPath) && !options?.force) {
-      const targetContent = fs7.readFileSync(targetPath, "utf8");
+    if (fs6.existsSync(targetPath) && !options?.force) {
+      const targetContent = fs6.readFileSync(targetPath, "utf8");
       const targetHash = hashContent4(targetContent);
-      if (hashContent4(canonicalContent) === targetHash && historicalIdCache4.get(path31.join(targetRoot, "state")) === idsAtCompare) {
+      if (hashContent4(canonicalContent) === targetHash && historicalIdCache3.get(path30.join(targetRoot, "state")) === idsAtCompare) {
         skipped++;
         continue;
       }
@@ -25776,48 +25451,48 @@ function copyPreparedMemories(sourceFiles, sourceRoot, targetRoot, sourceEntityI
         continue;
       }
     }
-    fs7.mkdirSync(path31.dirname(targetPath), { recursive: true });
-    const targetParentRealPath = safeRealpath(path31.dirname(targetPath));
+    fs6.mkdirSync(path30.dirname(targetPath), { recursive: true });
+    const targetParentRealPath = safeRealpath(path30.dirname(targetPath));
     if (!targetParentRealPath || !isPathInsideRoot(targetParentRealPath, targetRoot)) {
       skipped++;
       continue;
     }
-    const stateDir = path31.join(targetRoot, "state");
+    const stateDir = path30.join(targetRoot, "state");
     if (targetKind === "memory" && !refHasSourceClaimant) {
-      const idsAtWrite = historicalIdCache4.get(stateDir);
+      const idsAtWrite = historicalIdCache3.get(stateDir);
       const written = canonicalizeEntityRefFrontmatter(content, idsAtWrite);
       let priorTarget = null;
       try {
-        priorTarget = fs7.readFileSync(targetPath, "utf8");
+        priorTarget = fs6.readFileSync(targetPath, "utf8");
       } catch {
         priorTarget = null;
       }
-      fs7.writeFileSync(targetPath, written);
+      fs6.writeFileSync(targetPath, written);
       try {
         repairContentAfterJournalMoveSync({
           stateDir,
-          cache: historicalIdCache4,
+          cache: historicalIdCache3,
           idsAtWrite,
           rawContent: content,
           lastWritten: written,
-          rewrite: (next) => fs7.writeFileSync(targetPath, next)
+          rewrite: (next) => fs6.writeFileSync(targetPath, next)
         });
       } catch (err) {
         try {
           if (priorTarget === null) {
-            fs7.unlinkSync(targetPath);
+            fs6.unlinkSync(targetPath);
           } else {
-            fs7.writeFileSync(targetPath, priorTarget);
+            fs6.writeFileSync(targetPath, priorTarget);
           }
         } catch {
         }
         throw err;
       }
     } else if (targetKind === "memory") {
-      fs7.writeFileSync(targetPath, content);
+      fs6.writeFileSync(targetPath, content);
       reconcileNeeded = true;
     } else {
-      fs7.writeFileSync(targetPath, content);
+      fs6.writeFileSync(targetPath, content);
       if (targetKind === "entity") {
         reconcileNeeded = true;
       }
@@ -25826,18 +25501,18 @@ function copyPreparedMemories(sourceFiles, sourceRoot, targetRoot, sourceEntityI
     bumpMemoryCorpusVersionForDir(targetRoot);
   }
   if (reconcileNeeded) {
-    requestEntityCanonicalIdReconcileSync(path31.join(targetRoot, "state"));
+    requestEntityCanonicalIdReconcileSync(path30.join(targetRoot, "state"));
   }
   return { merged, conflicts, skipped };
 }
 function hashContent4(content) {
   return crypto7.createHash("sha256").update(content).digest("hex").slice(0, 16);
 }
-function walkMd2(dir) {
+function walkMd(dir) {
   const results = [];
   function walk(d) {
-    for (const entry of fs7.readdirSync(d, { withFileTypes: true })) {
-      const fullPath = path31.join(d, entry.name);
+    for (const entry of fs6.readdirSync(d, { withFileTypes: true })) {
+      const fullPath = path30.join(d, entry.name);
       if (entry.isSymbolicLink()) {
         continue;
       }
@@ -25853,21 +25528,21 @@ function walkMd2(dir) {
 }
 function safeLstat(filePath) {
   try {
-    return fs7.lstatSync(filePath);
+    return fs6.lstatSync(filePath);
   } catch {
     return null;
   }
 }
 function safeRealpath(filePath) {
   try {
-    return fs7.realpathSync(filePath);
+    return fs6.realpathSync(filePath);
   } catch {
     return null;
   }
 }
 function isPathInsideRoot(candidatePath, rootPath) {
-  const relative = path31.relative(rootPath, candidatePath);
-  return relative === "" || !relative.startsWith("..") && !path31.isAbsolute(relative);
+  const relative = path30.relative(rootPath, candidatePath);
+  return relative === "" || !relative.startsWith("..") && !path30.isAbsolute(relative);
 }
 function parseSimpleFrontmatter(content) {
   const match = content.match(/^---\n([\s\S]*?)\n---/);
@@ -25986,9 +25661,9 @@ var REMNIC_RECALL_DECISION_RULES = `## When to Use Recall vs Direct Read
 `;
 
 // src/memory-extension/codex-publisher.ts
-import fs8 from "fs";
+import fs7 from "fs";
 import os from "os";
-import path32 from "path";
+import path31 from "path";
 var REMNIC_EXTENSION_DIR_NAME = "remnic";
 function resolveEnvHome(env) {
   if (env === void 0) return resolveHomeDir();
@@ -25997,12 +25672,12 @@ function resolveEnvHome(env) {
 function expandTildeWithHome(input, homeDir) {
   if (input === "~") return homeDir;
   if (input.startsWith("~/") || input.startsWith("~\\")) {
-    return path32.join(homeDir, input.slice(2));
+    return path31.join(homeDir, input.slice(2));
   }
   return input;
 }
 function normalizeHostRoot(input, homeDir) {
-  return path32.resolve(expandTildeWithHome(input.trim(), homeDir));
+  return path31.resolve(expandTildeWithHome(input.trim(), homeDir));
 }
 var CodexMemoryExtensionPublisher = class {
   hostId = "codex";
@@ -26016,13 +25691,13 @@ 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) : path32.resolve(homeDir, ".codex");
-    return path32.join(codexHome, "memories_extensions", REMNIC_EXTENSION_DIR_NAME);
+    const codexHome = codexHomeInput ? normalizeHostRoot(codexHomeInput, homeDir) : path31.resolve(homeDir, ".codex");
+    return path31.join(codexHome, "memories_extensions", REMNIC_EXTENSION_DIR_NAME);
   }
   async isHostAvailable() {
     try {
-      const home = readEnvVar("CODEX_HOME")?.trim() || path32.join(resolveHomeDir(), ".codex");
-      return fs8.existsSync(home);
+      const home = readEnvVar("CODEX_HOME")?.trim() || path31.join(resolveHomeDir(), ".codex");
+      return fs7.existsSync(home);
     } catch {
       return false;
     }
@@ -26072,22 +25747,22 @@ When running inside the Codex phase-2 consolidation sandbox:
   }
   async publish(ctx) {
     const extensionRoot = await this.resolveExtensionRoot();
-    const instructionsPath = path32.join(extensionRoot, "instructions.md");
+    const instructionsPath = path31.join(extensionRoot, "instructions.md");
     const filesWritten = [];
     const skipped = [];
     ctx.log.info(`Publishing Codex memory extension to ${extensionRoot}`);
-    fs8.mkdirSync(extensionRoot, { recursive: true });
+    fs7.mkdirSync(extensionRoot, { recursive: true });
     const content = await this.renderInstructions(ctx);
     const tmpPath = `${instructionsPath}.tmp-${process.pid}-${Date.now()}`;
     try {
-      fs8.writeFileSync(tmpPath, content, "utf-8");
-      fs8.renameSync(tmpPath, instructionsPath);
+      fs7.writeFileSync(tmpPath, content, "utf-8");
+      fs7.renameSync(tmpPath, instructionsPath);
       filesWritten.push(instructionsPath);
       ctx.log.info(`Wrote ${instructionsPath}`);
     } catch (err) {
       try {
-        if (fs8.existsSync(tmpPath)) {
-          fs8.unlinkSync(tmpPath);
+        if (fs7.existsSync(tmpPath)) {
+          fs7.unlinkSync(tmpPath);
         }
       } catch {
       }
@@ -26102,8 +25777,8 @@ When running inside the Codex phase-2 consolidation sandbox:
   }
   async unpublish() {
     const extensionRoot = await this.resolveExtensionRoot();
-    if (fs8.existsSync(extensionRoot)) {
-      fs8.rmSync(extensionRoot, { recursive: true, force: true });
+    if (fs7.existsSync(extensionRoot)) {
+      fs7.rmSync(extensionRoot, { recursive: true, force: true });
     }
   }
 };
@@ -26448,7 +26123,7 @@ async function generateActivityMemories(date, digestBody, config, deps) {
 // src/session-summaries/index.ts
 import { createHash as createHash9 } from "crypto";
 import { lstat as lstat3, mkdir as mkdir7, readFile as readFile7, readdir as readdir4, rename, rm, stat as stat4, writeFile as writeFile7 } from "fs/promises";
-import path33 from "path";
+import path32 from "path";
 
 // src/session-summaries/adapters.ts
 var VALID_ROLES = /* @__PURE__ */ new Set(["user", "assistant", "tool", "system", "other"]);
@@ -26953,7 +26628,7 @@ function shortHash(value, length = 16) {
 async function listTranscriptFiles(root, maxFiles) {
   const out = [];
   let truncated = false;
-  const entrySortKey = (entryName, isDirectory) => isDirectory ? `${entryName}${path33.sep}` : entryName;
+  const entrySortKey = (entryName, isDirectory) => isDirectory ? `${entryName}${path32.sep}` : entryName;
   async function visit(dir) {
     if (truncated) return;
     const entries = (await readdir4(dir, { withFileTypes: true })).sort(
@@ -26963,13 +26638,13 @@ async function listTranscriptFiles(root, maxFiles) {
       if (truncated) return;
       if (entry.name.startsWith(".")) continue;
       if (entry.isSymbolicLink()) continue;
-      const fullPath = path33.join(dir, entry.name);
+      const fullPath = path32.join(dir, entry.name);
       if (entry.isDirectory()) {
         await visit(fullPath);
         continue;
       }
       if (!entry.isFile()) continue;
-      const ext = path33.extname(entry.name).toLowerCase();
+      const ext = path32.extname(entry.name).toLowerCase();
       if (!SUPPORTED_EXTENSIONS.has(ext)) continue;
       out.push(fullPath);
       if (out.length > maxFiles) {
@@ -26996,7 +26671,7 @@ function normalizeInputDir(inputDir) {
   if (typeof inputDir !== "string" || inputDir.trim().length === 0) {
     throw new Error("inputDir must be a non-empty string");
   }
-  return path33.resolve(expandTildePath(inputDir.trim()));
+  return path32.resolve(expandTildePath(inputDir.trim()));
 }
 function initRoleCounts() {
   return {
@@ -27153,11 +26828,11 @@ async function collectLocalSessionSummaries(options) {
       continue;
     }
     seenFileHashes.add(fileHash);
-    const fileExtension = path33.extname(filePath).toLowerCase();
+    const fileExtension = path32.extname(filePath).toLowerCase();
     const parsed = await adapter.parseFile(
       {
         content,
-        fileName: path33.basename(filePath),
+        fileName: path32.basename(filePath),
         fileExtension,
         fileRef: fileHash
       },
@@ -27213,7 +26888,7 @@ async function collectLocalSessionSummaries(options) {
 }
 async function readRedactionConfig(pathLike) {
   if (!pathLike) return void 0;
-  const raw = await readFile7(path33.resolve(expandTildePath(pathLike)), "utf-8");
+  const raw = await readFile7(path32.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");
@@ -27226,15 +26901,15 @@ function toJsonl(drafts) {
 }
 function defaultDraftOutputPath(memoryDir, generatedAt) {
   const stamp = generatedAt.replace(/[:.]/g, "-");
-  return path33.join(
-    path33.resolve(expandTildePath(memoryDir)),
+  return path32.join(
+    path32.resolve(expandTildePath(memoryDir)),
     "state",
     "session-summary-drafts",
     `session-summaries-${stamp}.jsonl`
   );
 }
 async function writeDrafts(filePath, drafts) {
-  await mkdir7(path33.dirname(filePath), { recursive: true });
+  await mkdir7(path32.dirname(filePath), { recursive: true });
   const tempPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
   try {
     await writeFile7(tempPath, toJsonl(drafts), "utf-8");
@@ -27252,7 +26927,7 @@ async function runLocalSessionSummaryCliCommand(options) {
   });
   const wroteFiles = [];
   if (options.output) {
-    const outputPath = path33.resolve(expandTildePath(options.output));
+    const outputPath = path32.resolve(expandTildePath(options.output));
     await writeDrafts(outputPath, report.drafts);
     wroteFiles.push(outputPath);
   }
@@ -27287,19 +26962,19 @@ async function runLocalSessionSummaryCliCommand(options) {
 
 // src/transfer/capsule-fork.ts
 import { lstat as lstat4, mkdir as mkdir8, readFile as readFile8, realpath as realpath3, writeFile as writeFile8 } from "fs/promises";
-import path34 from "path";
+import path33 from "path";
 async function forkCapsule(opts) {
   validateForkId(opts.forkId);
-  const rootAbs = path34.resolve(opts.targetRoot);
+  const rootAbs = path33.resolve(opts.targetRoot);
   await assertIsDirectoryNotSymlink(rootAbs, "forkCapsule", "targetRoot");
-  const forkDirAbs = path34.join(rootAbs, "forks", opts.forkId);
+  const forkDirAbs = path33.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 = path34.resolve(opts.sourceArchive);
+  const archiveAbs = path33.resolve(opts.sourceArchive);
   const importResult = await importCapsule({
     archivePath: archiveAbs,
     root: rootAbs,
@@ -27321,10 +26996,10 @@ async function forkCapsule(opts) {
     importedRecords: importResult.imported.length,
     skippedRecords: importResult.skipped.length
   };
-  const lineagePath = path34.join(forkDirAbs, "lineage.json");
+  const lineagePath = path33.join(forkDirAbs, "lineage.json");
   const rootReal = await realpath3(rootAbs);
   await assertRealpathInsideRoot(rootReal, lineagePath, `forks/${opts.forkId}/lineage.json`, "forkCapsule");
-  await mkdir8(path34.dirname(lineagePath), { recursive: true });
+  await mkdir8(path33.dirname(lineagePath), { recursive: true });
   await writeFile8(lineagePath, JSON.stringify(lineage, null, 2) + "\n", "utf-8");
   return {
     archivePath: archiveAbs,
@@ -27338,11 +27013,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 = path34.resolve(targetRoot);
+  const rootAbs = path33.resolve(targetRoot);
   const rootReal = await realpath3(rootAbs).catch(() => rootAbs);
-  const lineagePath = path34.join(rootReal, "forks", forkId, "lineage.json");
-  const rel = path34.relative(rootReal, lineagePath);
-  if (rel.startsWith("..") || path34.isAbsolute(rel)) {
+  const lineagePath = path33.join(rootReal, "forks", forkId, "lineage.json");
+  const rel = path33.relative(rootReal, lineagePath);
+  if (rel.startsWith("..") || path33.isAbsolute(rel)) {
     return null;
   }
   if (!await isLineagePathContained(rootReal, lineagePath)) {
@@ -27383,23 +27058,26 @@ async function pathEntryExists(absPath) {
 async function isLineagePathContained(rootReal, lineagePath) {
   let existing = lineagePath;
   const suffix = [];
-  while (existing !== path34.dirname(existing)) {
+  while (existing !== path33.dirname(existing)) {
     const st = await lstat4(existing).catch(() => null);
     if (st !== null) break;
-    suffix.unshift(path34.basename(existing));
-    existing = path34.dirname(existing);
+    suffix.unshift(path33.basename(existing));
+    existing = path33.dirname(existing);
   }
   const existingReal = await realpath3(existing).catch(() => existing);
-  const targetReal = suffix.length > 0 ? path34.join(existingReal, ...suffix) : existingReal;
-  const rel = path34.relative(rootReal, targetReal);
+  const targetReal = suffix.length > 0 ? path33.join(existingReal, ...suffix) : existingReal;
+  const rel = path33.relative(rootReal, targetReal);
   if (rel === "") return true;
   if (rel === "..") return false;
-  if (rel.startsWith(`..${path34.sep}`)) return false;
-  if (path34.isAbsolute(rel)) return false;
+  if (rel.startsWith(`..${path33.sep}`)) return false;
+  if (path33.isAbsolute(rel)) return false;
   return true;
 }
 
 export {
+  isPreferenceDriftStageActive,
+  driftAgeNote,
+  applyPreferenceDriftRanking,
   buildProcedureRecallSection,
   RELAY_DEMO_MISSION_ID,
   RELAY_DEMO_NAMESPACE,
@@ -27438,8 +27116,6 @@ export {
   findDuplicates,
   findContradictions,
   decideSemanticDedup,
-  listReviewItems,
-  performReview,
   syncChanges,
   watchForChanges,
   getSpacesDir,
@@ -27514,4 +27190,4 @@ export {
   blendGraphExpandedRecallScore,
   Orchestrator
 };
-//# sourceMappingURL=chunk-V3MXUL3D.js.map
+//# sourceMappingURL=chunk-ZPOHEB5Z.js.map