@remnic/core 9.69.52 → 9.69.54

package/dist/{chunk-MSTKJI5T.js → chunk-OKOG5MXF.js}

@@ -111,7 +111,7 @@ import {
 import {
   indexStateViewAnnotatedResults,
   resolveRecallStateViewActive
-} from "./chunk-72N2P44O.js";
+} from "./chunk-ARRKSBQU.js";
 import {
   applyRecallStateViews
 } from "./chunk-DBB5JPSL.js";
@@ -231,7 +231,7 @@ import {
   runTimelinePublishCli,
   screenCandidateFact,
   summarizeVaultPublish
-} from "./chunk-SOFATSHJ.js";
+} from "./chunk-ZHV6FGVF.js";
 import {
   normalizeReplaySessionKey
 } from "./chunk-AJVLDJU6.js";
@@ -261,7 +261,7 @@ import {
 import {
   runNamespaceMaintenanceFanout,
   summarizeNamespaceMaintenanceHealth
-} from "./chunk-SEQ6DWXD.js";
+} from "./chunk-5IKW2VP6.js";
 import {
   planNamespaceMaintenance
 } from "./chunk-7RKAE6Y4.js";
@@ -325,13 +325,14 @@ import {
 import {
   REFUSED_MERGE_CATEGORIES,
   applyNoveltyGate,
+  buildMergeFrontmatterUpdate,
   connectorMatchesScope,
   decideSemanticMerge,
   detectMeetings,
   embeddingsFromCosineHits,
   normalizeConnectorScope,
   runSeedGraduationPass
-} from "./chunk-UVZBDIJX.js";
+} from "./chunk-KGY6F4VJ.js";
 import {
   compileCorrectionRule,
   correctionsFilePath,
@@ -344,9 +345,12 @@ import {
   resolveVaultNotePath
 } from "./chunk-3KJTSCSX.js";
 import {
+  buildRecognitionIndex,
   decideRecognitionTier,
   loadRecognitionIndex,
-  runRecognitionTier
+  recognitionIndexPath,
+  runRecognitionTier,
+  saveRecognitionIndex
 } from "./chunk-4KQIWY4A.js";
 import {
   AMBIENT_CAPTURE_PROMPT_RULE,
@@ -354,7 +358,7 @@ import {
 } from "./chunk-QW27DOHG.js";
 import {
   MeetingsInputError
-} from "./chunk-6KCQNFDQ.js";
+} from "./chunk-SOOWBRMH.js";
 import {
   WearablesInputError,
   describeErrorForOperator
@@ -378,8 +382,10 @@ import {
   SessionContextCoordinator,
   capturePassiveCorrections,
   clusterByKey,
-  detectPassiveCorrections
-} from "./chunk-DCRK7I5E.js";
+  detectPassiveCorrections,
+  renderSessionExperiencePreview,
+  scoreSessionExperienceForPrompt
+} from "./chunk-HUQMVI3A.js";
 import {
   importCapsule
 } from "./chunk-VVX5PZFS.js";
@@ -419,7 +425,7 @@ import {
   isTopLevelArchivePath,
   journalPath,
   writeJournalFile
-} from "./chunk-TEQQQTQS.js";
+} from "./chunk-2HJKAVAS.js";
 import {
   searchHarmonicRetrieval
 } from "./chunk-TQT4AOPO.js";
@@ -661,9 +667,6 @@ import {
 import {
   fallbackLlmRuntimeContextFromConfig
 } from "./chunk-EP6BA7VV.js";
-import {
-  normalizeRecallTokenSet
-} from "./chunk-YCVB7X56.js";
 import {
   graphemeUnits,
   truncateGraphemeSafe
@@ -850,7 +853,7 @@ import {
 } from "./chunk-3WCASNQZ.js";
 
 // src/orchestrator.ts
-import path22 from "path";
+import path23 from "path";
 import { createHash as createHash9 } from "crypto";
 
 // src/orchestration/tier-migration-coordinator.ts
@@ -5600,93 +5603,6 @@ async function persistRepairedContentHash(storage, targetId, committedContent, c
   }
 }
 
-// src/dedup/merge-provenance.ts
-var MERGE_DERIVED_VIA = "merge";
-var ISO_TIMESTAMP = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,9})?(?:Z|[+-]\d{2}:\d{2})$/;
-function assertIsoInstant(value, field) {
-  if (typeof value !== "string" || !ISO_TIMESTAMP.test(value)) {
-    throw new RangeError(`${field} must be a full ISO 8601 instant, got ${JSON.stringify(value)}`);
-  }
-  const ms = Date.parse(value);
-  if (Number.isNaN(ms)) {
-    throw new RangeError(`${field} must be a full ISO 8601 instant, got ${JSON.stringify(value)}`);
-  }
-  if (!new Date(ms).toISOString().startsWith(value.slice(0, 10))) {
-    throw new RangeError(`${field} is not a real calendar date: ${JSON.stringify(value)}`);
-  }
-  return value;
-}
-function assertOffset(value, field) {
-  if (value === void 0) return;
-  if (typeof value !== "number" || !Number.isInteger(value) || value < 0) {
-    throw new RangeError(`${field} must be a non-negative integer when present, got ${String(value)}`);
-  }
-}
-function normalizeSource(source, index) {
-  const label = `sources[${index}]`;
-  for (const field of ["sessionKey", "quote"]) {
-    const value = source[field];
-    if (typeof value !== "string" || value.trim() === "") {
-      throw new RangeError(`${label}.${field} must be a non-blank string`);
-    }
-  }
-  assertIsoInstant(source.observedAt, `${label}.observedAt`);
-  if (source.turnId !== void 0 && (typeof source.turnId !== "string" || source.turnId.trim() === "")) {
-    throw new RangeError(`${label}.turnId must be a non-blank string when present`);
-  }
-  assertOffset(source.charStart, `${label}.charStart`);
-  assertOffset(source.charEnd, `${label}.charEnd`);
-  if (source.charStart !== void 0 && source.charEnd !== void 0 && source.charEnd < source.charStart) {
-    throw new RangeError(`${label}.charEnd must be >= charStart`);
-  }
-  const copy = {
-    sessionKey: source.sessionKey,
-    observedAt: source.observedAt,
-    quote: source.quote
-  };
-  if (source.turnId !== void 0) copy.turnId = source.turnId;
-  if (source.charStart !== void 0) copy.charStart = source.charStart;
-  if (source.charEnd !== void 0) copy.charEnd = source.charEnd;
-  return copy;
-}
-function sourceKey(source) {
-  return JSON.stringify([
-    source.sessionKey,
-    source.turnId ?? null,
-    source.observedAt,
-    source.quote,
-    source.charStart ?? null,
-    source.charEnd ?? null
-  ]);
-}
-function buildMergeFrontmatterUpdate(input) {
-  const updated = assertIsoInstant(input.nowIso, "nowIso");
-  const previous = input.targetReinforcementCount;
-  if (previous !== void 0 && (typeof previous !== "number" || !Number.isInteger(previous) || previous < 0)) {
-    throw new RangeError(
-      `reinforcement_count must be a non-negative integer when supplied, got ${String(previous)}`
-    );
-  }
-  const seen = /* @__PURE__ */ new Set();
-  const sources = [];
-  const append = (source, index) => {
-    const copy = normalizeSource(source, index);
-    const key = sourceKey(copy);
-    if (seen.has(key)) return;
-    seen.add(key);
-    sources.push(copy);
-  };
-  const target = input.targetSources ?? [];
-  target.forEach(append);
-  input.incomingSources.forEach((source, i) => append(source, target.length + i));
-  return {
-    updated,
-    derived_via: MERGE_DERIVED_VIA,
-    reinforcement_count: (previous ?? 0) + 1,
-    sources
-  };
-}
-
 // src/dedup/merge-judge.ts
 import { z } from "zod";
 var MERGE_JUDGE_SYSTEM_PROMPT = `You maintain a long-term memory store. Given a NEW memory and up to N EXISTING
@@ -9897,44 +9813,8 @@ var GraphRecallCoordinator = class {
   }
 };
 
-// src/experience/session-experience-recall.ts
-function tokenOverlapScore(prompt, memoryText) {
-  const norm = (s) => s.toLowerCase().split(/[^a-z0-9]+/).filter((t) => t.length > 2);
-  const promptTokens = new Set(norm(prompt));
-  const memTokens = new Set(norm(memoryText));
-  if (promptTokens.size === 0 || memTokens.size === 0) return 0;
-  let inter = 0;
-  for (const t of promptTokens) {
-    if (memTokens.has(t)) inter++;
-  }
-  const union = /* @__PURE__ */ new Set([...promptTokens, ...memTokens]);
-  return inter / Math.max(1, union.size);
-}
-function isSessionExperienceMemory(memory) {
-  const hash = memory.frontmatter.structuredAttributes?.experience_session_hash;
-  return typeof hash === "string" && hash.length > 0;
-}
-function scoreSessionExperienceForPrompt(memory, prompt) {
-  if (!isSessionExperienceMemory(memory)) return null;
-  const situation = memory.frontmatter.structuredAttributes?.experience_situation ?? "";
-  const situationScore = tokenOverlapScore(prompt, situation);
-  const bodyScore = tokenOverlapScore(prompt, memory.content);
-  return Math.min(1, situationScore * 0.75 + bodyScore * 0.25);
-}
-function renderSessionExperiencePreview(memory) {
-  if (!isSessionExperienceMemory(memory)) return null;
-  const attrs = memory.frontmatter.structuredAttributes ?? {};
-  const situation = (attrs.experience_situation ?? "").trim();
-  const approach = (attrs.experience_approach ?? "").trim();
-  const reflection = (attrs.experience_reflection ?? "").trim();
-  if (situation.length === 0 && approach.length === 0 && reflection.length === 0) {
-    return `Experience. ${memory.content.replace(/\s+/g, " ").trim()}`;
-  }
-  return `Experience. Situation: ${situation} Approach: ${approach} Reflection: ${reflection}`.replace(/\s+/g, " ").trim();
-}
-
 // src/procedural/procedure-recall.ts
-function tokenOverlapScore2(prompt, memoryText) {
+function tokenOverlapScore(prompt, memoryText) {
   const norm = (s) => s.toLowerCase().split(/[^a-z0-9]+/).filter((t) => t.length > 2);
   const promptTokens = new Set(norm(prompt));
   const memTokens = new Set(norm(memoryText));
@@ -9949,7 +9829,7 @@ function tokenOverlapScore2(prompt, memoryText) {
 function scoreProcedureForPrompt(m, prompt, queryIntent, experienceEnabled) {
   const memText = `${m.content}
 ${(m.frontmatter.tags ?? []).join(" ")}`;
-  const jaccard = tokenOverlapScore2(prompt, memText);
+  const jaccard = tokenOverlapScore(prompt, memText);
   const memIntent = inferIntentFromText(m.content.slice(0, 2e3));
   const intentScore = intentCompatibilityScore(queryIntent, memIntent);
   const base = jaccard * 0.55 + intentScore * 0.45;
@@ -17655,7 +17535,121 @@ var OrchestratorInitCoordinator = class {
 };
 
 // src/orchestration/persistence-index.ts
+import path19 from "path";
+
+// src/orchestration/recall-recognition-index.ts
+import { promises as fsp } from "fs";
 import path18 from "path";
+import { setTimeout as delay } from "timers/promises";
+var writeChains = /* @__PURE__ */ new Map();
+var LOCK_POLL_MS = 10;
+var LOCK_ATTEMPTS = 50;
+var LOCK_STALE_MS = 6e4;
+function recognitionDescriptionFromContent(content) {
+  const trimmed = content.trim();
+  if (trimmed.length === 0) return "";
+  const newline = trimmed.indexOf("\n");
+  return newline === -1 ? trimmed : trimmed.slice(0, newline).trimEnd();
+}
+function withIndexChain(indexPath, op) {
+  const previous = writeChains.get(indexPath) ?? Promise.resolve();
+  const run = previous.then(op, op);
+  const tail = run.then(() => void 0, () => void 0);
+  writeChains.set(indexPath, tail);
+  void tail.then(() => {
+    if (writeChains.get(indexPath) === tail) writeChains.delete(indexPath);
+  });
+  return run;
+}
+async function removeAbandonedRecognitionLock(lockDir) {
+  try {
+    const info = await fsp.lstat(lockDir);
+    if (info.isSymbolicLink()) return "blocked";
+    if (!info.isDirectory()) {
+      await fsp.rm(lockDir, { force: true });
+      return "removed";
+    }
+    if (Date.now() - info.mtimeMs < LOCK_STALE_MS) return "wait";
+    await fsp.rm(lockDir, { recursive: true, force: true });
+    return "removed";
+  } catch (error) {
+    if (error?.code === "ENOENT") return "removed";
+    return "blocked";
+  }
+}
+async function withRecognitionIndexLock(memoryDir, op) {
+  const lockDir = `${recognitionIndexPath(memoryDir)}.lock.d`;
+  for (let attempt = 0; attempt < LOCK_ATTEMPTS; attempt++) {
+    try {
+      await fsp.mkdir(lockDir);
+      try {
+        return await op();
+      } finally {
+        await fsp.rm(lockDir, { recursive: true, force: true }).catch(() => void 0);
+      }
+    } catch (error) {
+      const code = error?.code;
+      if (code === "ENOENT") {
+        await fsp.mkdir(path18.dirname(lockDir), { recursive: true }).catch(() => void 0);
+        continue;
+      }
+      if (code !== "EEXIST") throw error;
+      const cleanup = await removeAbandonedRecognitionLock(lockDir);
+      if (cleanup === "blocked") {
+        throw new Error(`recognition index lock blocked at ${lockDir}`);
+      }
+      if (cleanup === "removed") continue;
+      await delay(LOCK_POLL_MS);
+    }
+  }
+  throw new Error(`recognition index lock timed out at ${lockDir}`);
+}
+function applyChanges(entries, changes) {
+  const next = entries.map((entry) => ({ id: entry.id, description: entry.description }));
+  const byId = new Map(next.map((entry, index) => [entry.id, index]));
+  for (const change of changes) {
+    const id = change.id.trim();
+    if (id.length === 0) continue;
+    if (change.action === "remove") {
+      const index = byId.get(id);
+      if (index === void 0) continue;
+      next.splice(index, 1);
+      byId.delete(id);
+      for (const [key, value] of byId) {
+        if (value > index) byId.set(key, value - 1);
+      }
+      continue;
+    }
+    const description = recognitionDescriptionFromContent(change.content);
+    const existing = byId.get(id);
+    if (existing !== void 0) {
+      next[existing] = { id, description };
+    } else {
+      byId.set(id, next.length);
+      next.push({ id, description });
+    }
+  }
+  return next;
+}
+function meaningfulChanges(changes) {
+  return changes.filter((change) => change.id.trim().length > 0);
+}
+async function maintainRecognitionIndexAfterWrite(args) {
+  if (args.enabled !== true) return;
+  const changes = meaningfulChanges(args.changes);
+  if (changes.length === 0) return;
+  const indexPath = recognitionIndexPath(args.memoryDir);
+  await withIndexChain(
+    indexPath,
+    () => withRecognitionIndexLock(args.memoryDir, async () => {
+      const loaded = await loadRecognitionIndex(args.memoryDir);
+      const entries = applyChanges(loaded?.entries ?? [], changes);
+      await saveRecognitionIndex(args.memoryDir, buildRecognitionIndex(entries));
+    })
+  );
+}
+
+// src/orchestration/persistence-index.ts
 var PersistenceIndexCoordinator = class {
   constructor(deps) {
     this.deps = deps;
@@ -17847,7 +17841,7 @@ var PersistenceIndexCoordinator = class {
         const allMems = allMemsForGraph ?? [];
         for (const m of allMems) {
           if (m.frontmatter.entityRef === entityRef) {
-            const rel = path18.relative(storage.dir, m.path);
+            const rel = path19.relative(storage.dir, m.path);
             if (rel !== memoryRelPath) entitySiblings.push(rel);
           }
         }
@@ -17898,6 +17892,7 @@ var PersistenceIndexCoordinator = class {
    * Fail-open: any error is logged but does not abort extraction.
    */
   async updateTemporalTagIndexes(storage, persistedIds) {
+    await this.maintainRecognitionIndex(storage, persistedIds);
     const caps = resolveCapabilities(this.deps.config);
     if (!resolveIndexingCapabilities(this.deps.config).queryAwareIndexing && !caps.parallelRetrieval && !resolveRecallEnhancementCapabilities(this.deps.config).eventOrderRecall)
       return;
@@ -17998,11 +17993,51 @@ var PersistenceIndexCoordinator = class {
     );
     return enriched;
   }
+  /**
+   * Upsert persisted memories into the namespace recognition index.
+   * `recallRecognitionTier !== true` returns before any index I/O.
+   * A missing index is bootstrapped from the active corpus so the first
+   * post-enable write cannot publish a partial index that recall would
+   * treat as the full working set.
+   */
+  async maintainRecognitionIndex(storage, persistedIds) {
+    try {
+      if (this.deps.config.recallRecognitionTier !== true) return;
+      const indexMissing = await loadRecognitionIndex(storage.dir) === null;
+      if (!indexMissing && persistedIds.length === 0) return;
+      const changes = [];
+      const pushUpsert = (memory) => {
+        if (!isActiveMemoryStatus(memory.frontmatter.status)) return;
+        const memoryId = memory.frontmatter.id;
+        if (typeof memoryId !== "string" || memoryId.trim().length === 0) return;
+        changes.push({ action: "upsert", id: memoryId, content: memory.content ?? "" });
+      };
+      if (indexMissing) {
+        const corpus = await storage.readAllMemories().catch(() => []);
+        for (const memory of corpus) pushUpsert(memory);
+      }
+      for (const id of persistedIds) {
+        let memory = await storage.getMemoryById(id);
+        if (!memory) {
+          const cold = await storage.getMemoryByIdIncludingArchived(id).catch(() => null);
+          if (cold && isActiveMemoryStatus(cold.frontmatter.status)) memory = cold;
+        }
+        if (memory) pushUpsert(memory);
+      }
+      await maintainRecognitionIndexAfterWrite({
+        memoryDir: storage.dir,
+        enabled: true,
+        changes
+      });
+    } catch (err) {
+      log.debug(`recognition-index update error (non-fatal): ${err}`);
+    }
+  }
 };
 
 // src/orchestration/workspace-ops.ts
 import { lstat as lstat2, mkdir as mkdir6, readFile as readFile8, readdir as readdir3, realpath as realpath2, writeFile as writeFile6 } from "fs/promises";
-import path19 from "path";
+import path20 from "path";
 
 // src/maintenance/pattern-reinforcement.ts
 function patternReinforcementKey(content) {
@@ -19906,8 +19941,8 @@ var MeetingsService = class {
 // src/orchestration/workspace-ops.ts
 var MEETINGS_BUILD_DEBOUNCE_MS = 5e3;
 function matchesMemoryPath(candidatePath, requestedPath, memoryDir) {
-  const normalizedCandidate = path19.resolve(candidatePath);
-  return normalizedCandidate === path19.resolve(requestedPath) || normalizedCandidate === path19.resolve(memoryDir, requestedPath);
+  const normalizedCandidate = path20.resolve(candidatePath);
+  return normalizedCandidate === path20.resolve(requestedPath) || normalizedCandidate === path20.resolve(memoryDir, requestedPath);
 }
 function accessTrackingPathCandidates(storageDir, memoryPath) {
   const candidates = qmdResultPathCandidates(storageDir, memoryPath);
@@ -19915,12 +19950,12 @@ function accessTrackingPathCandidates(storageDir, memoryPath) {
   if (!parts) return candidates;
   candidates.push(
     ...qmdResultPathCandidates(storageDir, parts.relativePath),
-    ...qmdResultPathCandidates(path19.join(storageDir, "cold"), parts.relativePath)
+    ...qmdResultPathCandidates(path20.join(storageDir, "cold"), parts.relativePath)
   );
   return [...new Set(candidates)];
 }
 function canonicalMemoryPath(memoryPath, memoryDir) {
-  return path19.resolve(path19.isAbsolute(memoryPath) ? memoryPath : path19.resolve(memoryDir, memoryPath));
+  return path20.resolve(path20.isAbsolute(memoryPath) ? memoryPath : path20.resolve(memoryDir, memoryPath));
 }
 var WorkspaceOpsCoordinator = class {
   constructor(deps) {
@@ -20002,15 +20037,15 @@ var WorkspaceOpsCoordinator = class {
     this.deps.lastFileHygieneRunAtMs = now;
     if (hygiene.rotateEnabled) {
       for (const rel of hygiene.rotatePaths) {
-        const abs = path19.isAbsolute(rel) ? rel : path19.join(this.deps.config.workspaceDir, rel);
+        const abs = path20.isAbsolute(rel) ? rel : path20.join(this.deps.config.workspaceDir, rel);
         try {
           const raw = await readFile8(abs, "utf-8");
           if (raw.length > hygiene.rotateMaxBytes) {
-            const archiveDir = path19.join(
+            const archiveDir = path20.join(
               this.deps.config.workspaceDir,
               hygiene.archiveDir
             );
-            const base = path19.basename(abs);
+            const base = path20.basename(abs);
             const prefix = base.toUpperCase().replace(/\.MD$/i, "").replace(/[^A-Z0-9]+/g, "-") || "FILE";
             const { newContent } = await rotateMarkdownFileToArchive({
               filePath: abs,
@@ -20035,8 +20070,8 @@ var WorkspaceOpsCoordinator = class {
         log.warn(w.message);
       }
       if (hygiene.warningsLogEnabled && warnings.length > 0) {
-        const fp = path19.join(this.deps.config.memoryDir, hygiene.warningsLogPath);
-        await mkdir6(path19.dirname(fp), { recursive: true });
+        const fp = path20.join(this.deps.config.memoryDir, hygiene.warningsLogPath);
+        await mkdir6(path20.dirname(fp), { recursive: true });
         const stamp = (/* @__PURE__ */ new Date()).toISOString();
         const block = `
 
@@ -20076,7 +20111,7 @@ var WorkspaceOpsCoordinator = class {
     for (const categoryDir of RECALL_FALLBACK_DIRS) {
       if (memoryRootReal === null) break;
       for (const date of datesToScan) {
-        const dateDir = path19.join(storage.dir, categoryDir, date);
+        const dateDir = path20.join(storage.dir, categoryDir, date);
         try {
           const dirStat = await lstat2(dateDir);
           if (dirStat.isSymbolicLink() || !dirStat.isDirectory()) continue;
@@ -20085,7 +20120,7 @@ var WorkspaceOpsCoordinator = class {
           for (const entry of entries) {
             if (entry.isSymbolicLink()) continue;
             if (!entry.name.endsWith(".md")) continue;
-            const fullPath = path19.join(dateDir, entry.name);
+            const fullPath = path20.join(dateDir, entry.name);
             try {
               assertPathInsideRoot(memoryRootReal, await realpath2(fullPath), fullPath);
               const memory = await storage.readMemoryByPath(fullPath);
@@ -20107,13 +20142,13 @@ var WorkspaceOpsCoordinator = class {
       return a.frontmatter.created < b.frontmatter.created ? -1 : 1;
     });
     const hourlySummaries = [];
-    const hourlyBaseDir = path19.join(storage.dir, "summaries", "hourly");
+    const hourlyBaseDir = path20.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 = path19.join(hourlyBaseDir, sk.name, `${date}.md`);
+          const summaryFile = path20.join(hourlyBaseDir, sk.name, `${date}.md`);
           try {
             const raw = await readFile8(summaryFile, "utf-8");
             const filtered = filterHourlySummaryMarkdownForLocalDay(
@@ -20590,18 +20625,18 @@ ${reflectionsContent.trim()}
 // src/orchestration/namespace-read-fanout.ts
 import { existsSync, readFileSync } from "fs";
 import { stat as stat3 } from "fs/promises";
-import path21 from "path";
+import path22 from "path";
 
 // src/orchestration/orchestrator-namespace-scope.ts
-import path20 from "path";
+import path21 from "path";
 function computeSemanticDedupScope(targetStorage, config) {
   if (!resolveNamespaceCapabilities(config).namespaces) return {};
-  const memoryDir = path20.resolve(config.memoryDir);
-  const storageDir = path20.resolve(targetStorage.dir);
+  const memoryDir = path21.resolve(config.memoryDir);
+  const storageDir = path21.resolve(targetStorage.dir);
   if (storageDir === memoryDir) {
     return { pathExcludePrefixes: ["namespaces/"] };
   }
-  let rel = path20.relative(memoryDir, storageDir);
+  let rel = path21.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`
@@ -20654,7 +20689,7 @@ var NamespaceReadFanoutCoordinator = class {
   loadNamespaceStorageDirHintsFromCatalog() {
     if (this.deps.namespaceStorageDirHintsLoaded || !this.deps.namespaceCatalog.enabled) return;
     this.deps.namespaceStorageDirHintsLoaded = true;
-    const catalogPath = path21.join(this.deps.config.memoryDir, "state", "namespaces.jsonl");
+    const catalogPath = path22.join(this.deps.config.memoryDir, "state", "namespaces.jsonl");
     if (!existsSync(catalogPath)) return;
     let body;
     try {
@@ -20691,7 +20726,7 @@ var NamespaceReadFanoutCoordinator = class {
       if (!this.deps.storageDirMatchesNamespaceHint(record.namespace, record.storageDir)) {
         continue;
       }
-      const resolvedStorageDir = path21.resolve(record.storageDir);
+      const resolvedStorageDir = path22.resolve(record.storageDir);
       const current = preferredByStorageDir.get(resolvedStorageDir);
       preferredByStorageDir.set(
         resolvedStorageDir,
@@ -20876,12 +20911,12 @@ var NamespaceReadFanoutCoordinator = class {
   }
   async resolveStateDirForNamespace(namespace) {
     if (!resolveNamespaceCapabilities(this.deps.config).namespaces) {
-      return path21.join(this.deps.config.memoryDir, "state");
+      return path22.join(this.deps.config.memoryDir, "state");
     }
     if (namespace !== this.deps.config.defaultNamespace) {
-      return path21.join(this.deps.config.memoryDir, "namespaces", namespace, "state");
+      return path22.join(this.deps.config.memoryDir, "namespaces", namespace, "state");
     }
-    const candidate = path21.join(
+    const candidate = path22.join(
       this.deps.config.memoryDir,
       "namespaces",
       this.deps.config.defaultNamespace
@@ -20889,11 +20924,11 @@ var NamespaceReadFanoutCoordinator = class {
     try {
       const candidateStat = await stat3(candidate);
       if (candidateStat.isDirectory()) {
-        return path21.join(candidate, "state");
+        return path22.join(candidate, "state");
       }
     } catch {
     }
-    return path21.join(this.deps.config.memoryDir, "state");
+    return path22.join(this.deps.config.memoryDir, "state");
   }
   namespaceFromPath(p) {
     if (!resolveNamespaceCapabilities(this.deps.config).namespaces) return this.deps.config.defaultNamespace;
@@ -21348,7 +21383,7 @@ var Orchestrator = class {
     if (this.destroyed) throw new Error("orchestrator has been destroyed");
     if (!this._dependencyPropagationDelivery) {
       this._dependencyPropagationDelivery = new DependencyPropagationDelivery({
-        queueRoot: path22.join(this.config.memoryDir, "state", "dependency-propagation"),
+        queueRoot: path23.join(this.config.memoryDir, "state", "dependency-propagation"),
         config: this.config,
         extraction: this.extraction,
         getStorage: (namespace) => this.getStorage(namespace),
@@ -21703,7 +21738,7 @@ var Orchestrator = class {
     const defaultNs = normalizeNamespaceIdentity(this.config.defaultNamespace);
     if (ns !== defaultNs && !isSafeRouteNamespace(ns)) return;
     if (!this.storageDirMatchesNamespaceHint(ns, storageDir)) return;
-    const resolvedStorageDir = path22.resolve(storageDir);
+    const resolvedStorageDir = path23.resolve(storageDir);
     let hints = this.namespaceStorageDirHints.get(resolvedStorageDir);
     if (!hints) {
       hints = /* @__PURE__ */ new Set();
@@ -21714,21 +21749,21 @@ var Orchestrator = class {
   storageDirMatchesNamespaceHint(namespace, storageDir) {
     const ns = normalizeNamespaceIdentity(namespace);
     if (!ns) return false;
-    const resolvedStorageDir = path22.resolve(storageDir);
-    const resolvedMemoryDir = path22.resolve(this.config.memoryDir);
+    const resolvedStorageDir = path23.resolve(storageDir);
+    const resolvedMemoryDir = path23.resolve(this.config.memoryDir);
     const defaultNs = normalizeNamespaceIdentity(this.config.defaultNamespace);
     if (resolvedStorageDir === resolvedMemoryDir) return ns === defaultNs;
-    const resolvedNamespacesDir = path22.join(resolvedMemoryDir, "namespaces");
+    const resolvedNamespacesDir = path23.join(resolvedMemoryDir, "namespaces");
     if (!isPathInsideStorageRoot(resolvedNamespacesDir, resolvedStorageDir)) return false;
-    const rawRoot = path22.resolve(resolvedNamespacesDir, ns);
-    const tokenRoot = path22.resolve(resolvedNamespacesDir, namespaceIdentityToken(ns));
+    const rawRoot = path23.resolve(resolvedNamespacesDir, ns);
+    const tokenRoot = path23.resolve(resolvedNamespacesDir, namespaceIdentityToken(ns));
     return resolvedStorageDir === rawRoot || resolvedStorageDir === tokenRoot;
   }
   namespaceStorageDirHintOwnershipRank(record, resolvedStorageDir, configured) {
-    if (resolvedStorageDir === path22.resolve(this.config.memoryDir)) {
+    if (resolvedStorageDir === path23.resolve(this.config.memoryDir)) {
       return record.namespace === normalizeNamespaceIdentity(this.config.defaultNamespace) ? 0 : 3;
     }
-    const leaf = path22.basename(resolvedStorageDir);
+    const leaf = path23.basename(resolvedStorageDir);
     const tokenOwnsRoot = namespaceIdentityToken(record.namespace) === leaf;
     if (tokenOwnsRoot && configured.has(record.namespace)) return 0;
     if (record.namespace === leaf) return 1;
@@ -21869,7 +21904,7 @@ var Orchestrator = class {
     StorageManager.setOkfConformanceDefault(config.memoryDir, config.okf?.conformanceEnabled);
     this.profiler = new ProfilingCollector({
       enabled: resolvePipelineProcessingCapabilities(this.config).profiling,
-      storageDir: config.profilingStorageDir || path22.join(config.memoryDir, "profiling"),
+      storageDir: config.profilingStorageDir || path23.join(config.memoryDir, "profiling"),
       maxTraces: config.profilingMaxTraces
     });
     this.namespaceCatalog = new NamespaceCatalog(config);
@@ -21956,7 +21991,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 = path22.join(
+    this.conversationIndexDir = path23.join(
       config.memoryDir,
       "conversation-index",
       "chunks"
@@ -22107,7 +22142,7 @@ var Orchestrator = class {
       getHandleHistory: () => this.handleHistory
     });
     this.threading = new ThreadingManager(
-      path22.join(config.memoryDir, "threads"),
+      path23.join(config.memoryDir, "threads"),
       config.threadingGapMinutes
     );
     const lifecycleCaps = resolveMemoryLifecycleCapabilities(config);
@@ -24275,8 +24310,8 @@ var DEFAULT_MAX_BINARY_SIZE_BYTES = 50 * 1024 * 1024;
 var DEFAULT_GRACE_PERIOD_DAYS = 7;
 
 // src/binary-lifecycle/backend.ts
-import fsp from "fs/promises";
-import path23 from "path";
+import fsp2 from "fs/promises";
+import path24 from "path";
 var FilesystemBackend = class {
   type = "filesystem";
   basePath;
@@ -24284,30 +24319,30 @@ var FilesystemBackend = class {
     if (!basePath || basePath.trim().length === 0) {
       throw new Error("FilesystemBackend requires a non-empty basePath");
     }
-    this.basePath = path23.resolve(basePath);
+    this.basePath = path24.resolve(basePath);
   }
   resolveRemotePath(remotePath) {
-    const resolved = path23.isAbsolute(remotePath) ? path23.resolve(remotePath) : path23.resolve(this.basePath, remotePath);
-    const relative = path23.relative(this.basePath, resolved);
-    if (relative === ".." || relative.startsWith(`..${path23.sep}`) || path23.isAbsolute(relative)) {
+    const resolved = path24.isAbsolute(remotePath) ? path24.resolve(remotePath) : path24.resolve(this.basePath, remotePath);
+    const relative = path24.relative(this.basePath, resolved);
+    if (relative === ".." || relative.startsWith(`..${path24.sep}`) || path24.isAbsolute(relative)) {
       throw new Error(`FilesystemBackend remotePath escapes basePath: ${JSON.stringify(remotePath)}`);
     }
     return resolved;
   }
   isInsideBase(candidate, realBase) {
-    const relative = path23.relative(realBase, candidate);
-    return relative === "" || relative !== ".." && !relative.startsWith(`..${path23.sep}`) && !path23.isAbsolute(relative);
+    const relative = path24.relative(realBase, candidate);
+    return relative === "" || relative !== ".." && !relative.startsWith(`..${path24.sep}`) && !path24.isAbsolute(relative);
   }
   async realBasePathIfExists() {
     try {
-      const stat5 = await fsp.lstat(this.basePath);
+      const stat5 = await fsp2.lstat(this.basePath);
       if (stat5.isSymbolicLink()) {
         throw new Error(`FilesystemBackend basePath must not be a symlink: ${this.basePath}`);
       }
       if (!stat5.isDirectory()) {
         throw new Error(`FilesystemBackend basePath must be a directory: ${this.basePath}`);
       }
-      return await fsp.realpath(this.basePath);
+      return await fsp2.realpath(this.basePath);
     } catch (err) {
       if (err.code === "ENOENT") {
         return null;
@@ -24316,7 +24351,7 @@ var FilesystemBackend = class {
     }
   }
   async ensureBaseDirectory() {
-    await fsp.mkdir(this.basePath, { recursive: true });
+    await fsp2.mkdir(this.basePath, { recursive: true });
     const realBase = await this.realBasePathIfExists();
     if (realBase === null) {
       throw new Error(`FilesystemBackend failed to create basePath: ${this.basePath}`);
@@ -24325,15 +24360,15 @@ var FilesystemBackend = class {
   }
   async ensureSafeParentDirectory(dest) {
     const realBase = await this.ensureBaseDirectory();
-    const destDir = path23.dirname(dest);
-    const relativeDir = path23.relative(this.basePath, destDir);
-    const segments = relativeDir === "" ? [] : relativeDir.split(path23.sep);
+    const destDir = path24.dirname(dest);
+    const relativeDir = path24.relative(this.basePath, destDir);
+    const segments = relativeDir === "" ? [] : relativeDir.split(path24.sep);
     let current = this.basePath;
     for (const segment of segments) {
       if (segment === "." || segment === "") continue;
-      current = path23.join(current, segment);
+      current = path24.join(current, segment);
       try {
-        const stat5 = await fsp.lstat(current);
+        const stat5 = await fsp2.lstat(current);
         if (stat5.isSymbolicLink()) {
           throw new Error(`FilesystemBackend remotePath traverses symlink: ${current}`);
         }
@@ -24344,10 +24379,10 @@ var FilesystemBackend = class {
         if (err.code !== "ENOENT") {
           throw err;
         }
-        await fsp.mkdir(current);
+        await fsp2.mkdir(current);
       }
     }
-    const realParent = await fsp.realpath(destDir);
+    const realParent = await fsp2.realpath(destDir);
     if (!this.isInsideBase(realParent, realBase)) {
       throw new Error(`FilesystemBackend remotePath parent escapes basePath: ${dest}`);
     }
@@ -24359,16 +24394,16 @@ var FilesystemBackend = class {
     if (realBase === null) {
       return null;
     }
-    const destDir = path23.dirname(dest);
-    const relativeDir = path23.relative(this.basePath, destDir);
-    const segments = relativeDir === "" ? [] : relativeDir.split(path23.sep);
+    const destDir = path24.dirname(dest);
+    const relativeDir = path24.relative(this.basePath, destDir);
+    const segments = relativeDir === "" ? [] : relativeDir.split(path24.sep);
     let current = this.basePath;
     for (const segment of segments) {
       if (segment === "." || segment === "") continue;
-      current = path23.join(current, segment);
+      current = path24.join(current, segment);
       let stat5;
       try {
-        stat5 = await fsp.lstat(current);
+        stat5 = await fsp2.lstat(current);
       } catch (err) {
         if (err.code === "ENOENT") {
           return null;
@@ -24382,7 +24417,7 @@ var FilesystemBackend = class {
         return null;
       }
     }
-    const realParent = await fsp.realpath(destDir).catch((err) => {
+    const realParent = await fsp2.realpath(destDir).catch((err) => {
       if (isErrnoCode(err, "ENOENT")) return null;
       throw err;
     });
@@ -24393,7 +24428,7 @@ var FilesystemBackend = class {
       throw new Error(`FilesystemBackend remotePath parent escapes basePath: ${JSON.stringify(remotePath)}`);
     }
     try {
-      const stat5 = await fsp.lstat(dest);
+      const stat5 = await fsp2.lstat(dest);
       if (stat5.isSymbolicLink()) {
         throw new Error(`FilesystemBackend remotePath points to symlink: ${dest}`);
       }
@@ -24406,20 +24441,20 @@ var FilesystemBackend = class {
       }
       throw err;
     }
-    const realDest = await fsp.realpath(dest);
+    const realDest = await fsp2.realpath(dest);
     if (!this.isInsideBase(realDest, realBase)) {
       throw new Error(`FilesystemBackend remotePath escapes basePath: ${JSON.stringify(remotePath)}`);
     }
     return dest;
   }
   async upload(localPath, remotePath) {
-    if (path23.isAbsolute(remotePath)) {
+    if (path24.isAbsolute(remotePath)) {
       throw new Error(`FilesystemBackend upload remotePath must be relative: ${JSON.stringify(remotePath)}`);
     }
     const dest = this.resolveRemotePath(remotePath);
     const realBase = await this.ensureSafeParentDirectory(dest);
     try {
-      const stat5 = await fsp.lstat(dest);
+      const stat5 = await fsp2.lstat(dest);
       if (stat5.isSymbolicLink()) {
         throw new Error(`FilesystemBackend remotePath points to symlink: ${dest}`);
       }
@@ -24428,8 +24463,8 @@ var FilesystemBackend = class {
         throw err;
       }
     }
-    await fsp.copyFile(localPath, dest);
-    const realDest = await fsp.realpath(dest);
+    await fsp2.copyFile(localPath, dest);
+    const realDest = await fsp2.realpath(dest);
     if (!this.isInsideBase(realDest, realBase)) {
       throw new Error(`FilesystemBackend remotePath escapes basePath: ${JSON.stringify(remotePath)}`);
     }
@@ -24445,7 +24480,7 @@ var FilesystemBackend = class {
       return;
     }
     try {
-      await fsp.unlink(dest);
+      await fsp2.unlink(dest);
     } catch (err) {
       if (err.code !== "ENOENT") throw err;
     }
@@ -24485,8 +24520,8 @@ function createBackend(cfg) {
 }
 
 // src/binary-lifecycle/scanner.ts
-import fsp2 from "fs/promises";
-import path24 from "path";
+import fsp3 from "fs/promises";
+import path25 from "path";
 import crypto from "crypto";
 function matchesPatterns(filename, patterns) {
   const lower = filename.toLowerCase();
@@ -24506,13 +24541,13 @@ async function scanForBinaries(memoryDir, config, manifest) {
   async function walk(dir) {
     let entries;
     try {
-      entries = await fsp2.readdir(dir, { withFileTypes: true });
+      entries = await fsp3.readdir(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
-      const fullPath = path24.join(dir, entry.name);
-      const relativePath = path24.relative(memoryDir, fullPath).split(path24.sep).join("/");
+      const fullPath = path25.join(dir, entry.name);
+      const relativePath = path25.relative(memoryDir, fullPath).split(path25.sep).join("/");
       if (entry.isDirectory()) {
         if (entry.name === ".binary-lifecycle") continue;
         await walk(fullPath);
@@ -24521,7 +24556,7 @@ async function scanForBinaries(memoryDir, config, manifest) {
       if (!entry.isFile()) continue;
       if (!matchesPatterns(entry.name, config.scanPatterns)) continue;
       try {
-        const stat5 = await fsp2.stat(fullPath);
+        const stat5 = await fsp3.stat(fullPath);
         if (stat5.size > config.maxBinarySizeBytes) continue;
         if (stat5.size === 0) continue;
         const existing = tracked.get(relativePath);
@@ -24546,27 +24581,27 @@ async function scanForBinaries(memoryDir, config, manifest) {
   return results;
 }
 async function hashFile(filePath) {
-  const content = await fsp2.readFile(filePath);
+  const content = await fsp3.readFile(filePath);
   return crypto.createHash("sha256").update(content).digest("hex");
 }
 
 // src/binary-lifecycle/manifest.ts
-import fsp3 from "fs/promises";
-import path25 from "path";
+import fsp4 from "fs/promises";
+import path26 from "path";
 import crypto2 from "crypto";
 var MANIFEST_DIR = ".binary-lifecycle";
 var MANIFEST_FILE = "manifest.json";
 function manifestDir(memoryDir) {
-  return path25.join(memoryDir, MANIFEST_DIR);
+  return path26.join(memoryDir, MANIFEST_DIR);
 }
 function manifestPath(memoryDir) {
-  return path25.join(memoryDir, MANIFEST_DIR, MANIFEST_FILE);
+  return path26.join(memoryDir, MANIFEST_DIR, MANIFEST_FILE);
 }
 async function readManifest(memoryDir) {
   const filePath = manifestPath(memoryDir);
   let raw;
   try {
-    raw = await fsp3.readFile(filePath, "utf-8");
+    raw = await fsp4.readFile(filePath, "utf-8");
   } catch (err) {
     if (err.code === "ENOENT") {
       return emptyManifest();
@@ -24590,17 +24625,17 @@ async function readManifest(memoryDir) {
 }
 async function writeManifest(memoryDir, manifest) {
   const dir = manifestDir(memoryDir);
-  await fsp3.mkdir(dir, { recursive: true });
+  await fsp4.mkdir(dir, { recursive: true });
   const dest = manifestPath(memoryDir);
   const tmpSuffix = crypto2.randomBytes(8).toString("hex");
   const tmpPath = `${dest}.${tmpSuffix}.tmp`;
   const content = JSON.stringify(manifest, null, 2) + "\n";
-  await fsp3.writeFile(tmpPath, content, "utf-8");
+  await fsp4.writeFile(tmpPath, content, "utf-8");
   try {
-    await fsp3.rename(tmpPath, dest);
+    await fsp4.rename(tmpPath, dest);
   } catch (renameErr) {
     try {
-      await fsp3.unlink(tmpPath);
+      await fsp4.unlink(tmpPath);
     } catch {
     }
     throw renameErr;
@@ -24611,18 +24646,18 @@ function emptyManifest() {
 }
 
 // src/binary-lifecycle/pipeline.ts
-import fsp4 from "fs/promises";
-import path26 from "path";
+import fsp5 from "fs/promises";
+import path27 from "path";
 import crypto3 from "crypto";
 var historicalIdCache = new HistoricalEntityCanonicalIdCache();
 function isRecallCorpusMarkdown(mdPath, memoryDir) {
-  const rel = path26.relative(memoryDir, mdPath);
-  if (rel.startsWith("..") || path26.isAbsolute(rel)) return false;
-  const top = rel.split(path26.sep)[0];
+  const rel = path27.relative(memoryDir, mdPath);
+  if (rel.startsWith("..") || path27.isAbsolute(rel)) return false;
+  const top = rel.split(path27.sep)[0];
   return RECALL_FALLBACK_DIRS.includes(top);
 }
 async function hashFile2(filePath) {
-  const content = await fsp4.readFile(filePath);
+  const content = await fsp5.readFile(filePath);
   return crypto3.createHash("sha256").update(content).digest("hex");
 }
 function guessMimeType(ext) {
@@ -24642,13 +24677,13 @@ function escapeRegex(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function resolveManifestAssetPath(memoryDir, originalPath) {
-  if (originalPath.length === 0 || originalPath.includes("\0") || originalPath.includes("\\") || path26.isAbsolute(originalPath) || path26.win32.isAbsolute(originalPath)) {
+  if (originalPath.length === 0 || originalPath.includes("\0") || originalPath.includes("\\") || path27.isAbsolute(originalPath) || path27.win32.isAbsolute(originalPath)) {
     return null;
   }
-  const memoryRoot = path26.resolve(memoryDir);
-  const fullPath = path26.resolve(memoryRoot, originalPath);
-  const relative = path26.relative(memoryRoot, fullPath);
-  if (relative === "" || relative === ".." || relative.startsWith(`..${path26.sep}`) || path26.isAbsolute(relative)) {
+  const memoryRoot = path27.resolve(memoryDir);
+  const fullPath = path27.resolve(memoryRoot, originalPath);
+  const relative = path27.relative(memoryRoot, fullPath);
+  if (relative === "" || relative === ".." || relative.startsWith(`..${path27.sep}`) || path27.isAbsolute(relative)) {
     return null;
   }
   return fullPath;
@@ -24659,7 +24694,7 @@ function validateBinaryLifecycleConfig(config) {
   }
 }
 function remotePathForAsset(backend, relPath) {
-  const normalized = relPath.split(path26.sep).join("/");
+  const normalized = relPath.split(path27.sep).join("/");
   if (backend.type === "filesystem") {
     return `.binary-lifecycle/mirrors/${normalized}`;
   }
@@ -24672,11 +24707,11 @@ async function stageMirror(memoryDir, newPaths, backend, assets, log2, dryRun) {
   let mirrored = 0;
   const errors = [];
   for (const relPath of newPaths) {
-    const fullPath = path26.join(memoryDir, relPath);
+    const fullPath = path27.join(memoryDir, relPath);
     try {
-      const stat5 = await fsp4.stat(fullPath);
+      const stat5 = await fsp5.stat(fullPath);
       const contentHash = await hashFile2(fullPath);
-      const ext = path26.extname(relPath);
+      const ext = path27.extname(relPath);
       const mimeType = guessMimeType(ext);
       const remotePath = remotePathForAsset(backend, relPath);
       let backendLocation = remotePath;
@@ -24827,7 +24862,7 @@ async function stageRedirect(memoryDir, assets, log2, dryRun, readMarkdownFile,
     for (const update of updates) {
       try {
         await withRawEntityPageMutation(memoryDir, update.mdPath, async () => {
-          const stateDir = path26.join(memoryDir, "state");
+          const stateDir = path27.join(memoryDir, "state");
           const kind = classifyEntityRefWritePath(memoryDir, update.mdPath);
           if (kind === "memory") {
             const idsAtWrite = historicalIdCache.get(stateDir);
@@ -24920,10 +24955,10 @@ async function countRemainingLocalReferences(memoryDir, asset, assetAbsolute, md
   return { remaining, errors };
 }
 function markdownReferencePattern(asset, assetAbsolute, mdPath) {
-  const mdDir = path26.dirname(mdPath);
+  const mdDir = path27.dirname(mdPath);
   const candidates = /* @__PURE__ */ new Set();
   const addCandidate = (candidate) => {
-    const normalized = candidate.split(path26.sep).join("/");
+    const normalized = candidate.split(path27.sep).join("/");
     if (normalized.length === 0) return;
     candidates.add(normalized);
     const isParentTraversal = normalized === ".." || normalized.startsWith("../");
@@ -24931,10 +24966,10 @@ function markdownReferencePattern(asset, assetAbsolute, mdPath) {
       candidates.add(`./${normalized}`);
     }
   };
-  addCandidate(path26.relative(mdDir, assetAbsolute));
-  const originalPath = asset.originalPath.split(path26.sep).join("/");
-  const originalAsFileRelative = path26.resolve(mdDir, ...originalPath.split("/"));
-  if (path26.resolve(originalAsFileRelative) === path26.resolve(assetAbsolute)) {
+  addCandidate(path27.relative(mdDir, assetAbsolute));
+  const originalPath = asset.originalPath.split(path27.sep).join("/");
+  const originalAsFileRelative = path27.resolve(mdDir, ...originalPath.split("/"));
+  if (path27.resolve(originalAsFileRelative) === path27.resolve(assetAbsolute)) {
     addCandidate(originalPath);
   }
   addCandidate(`/${originalPath}`);
@@ -24998,7 +25033,7 @@ async function stageClean(memoryDir, assets, backend, gracePeriodDays, log2, dry
         continue;
       }
       if (!dryRun) {
-        await fsp4.unlink(fullPath);
+        await fsp5.unlink(fullPath);
         asset.status = "cleaned";
         asset.cleanedAt = (/* @__PURE__ */ new Date()).toISOString();
       }
@@ -25025,12 +25060,12 @@ async function findMarkdownFiles(dir) {
   async function walk(current) {
     let entries;
     try {
-      entries = await fsp4.readdir(current, { withFileTypes: true });
+      entries = await fsp5.readdir(current, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
-      const full = path26.join(current, entry.name);
+      const full = path27.join(current, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === ".binary-lifecycle") continue;
         await walk(full);
@@ -25072,8 +25107,8 @@ async function runBinaryLifecyclePipeline(memoryDir, config, backend, log2, opts
     manifest.assets,
     log2,
     dryRun,
-    opts?.readMarkdownFile ?? ((filePath) => fsp4.readFile(filePath, "utf-8")),
-    opts?.writeMarkdownFile ?? ((filePath, content) => fsp4.writeFile(filePath, content, "utf-8"))
+    opts?.readMarkdownFile ?? ((filePath) => fsp5.readFile(filePath, "utf-8")),
+    opts?.writeMarkdownFile ?? ((filePath, content) => fsp5.writeFile(filePath, content, "utf-8"))
   );
   const cleanResult = await stageClean(
     memoryDir,
@@ -25105,7 +25140,7 @@ async function runBinaryLifecyclePipeline(memoryDir, config, backend, log2, opts
 
 // src/projection/index.ts
 import fs from "fs";
-import path27 from "path";
+import path28 from "path";
 var VALID_PROJECTION_CATEGORIES = new Set(ALL_CATEGORY_KEYS);
 async function generateContextTree(options) {
   const startTime = Date.now();
@@ -25120,8 +25155,8 @@ async function generateContextTree(options) {
   let nodesGenerated = 0;
   let nodesSkipped = 0;
   const categoryCounts = {};
-  const resolvedMemoryDir = path27.resolve(memoryDir);
-  const resolvedOutputDir = path27.resolve(outputDir);
+  const resolvedMemoryDir = path28.resolve(memoryDir);
+  const resolvedOutputDir = path28.resolve(outputDir);
   const requestedCategories = validateProjectionCategories(filterCategories);
   const realMemoryDir = assertSafeMemoryRoot(resolvedMemoryDir);
   assertNotSymlink(resolvedOutputDir, "context tree outputDir");
@@ -25159,7 +25194,7 @@ async function generateContextTree(options) {
     }
   }
   if (includeEntities) {
-    const entitiesDir = path27.join(memoryDir, "entities");
+    const entitiesDir = path28.join(memoryDir, "entities");
     if (fs.existsSync(entitiesDir)) {
       assertSafeInputRoot(realMemoryDir, entitiesDir, "entities root");
       categoryCounts["entity"] = 0;
@@ -25171,7 +25206,7 @@ async function generateContextTree(options) {
           continue;
         }
         const content = fs.readFileSync(filePath, "utf8");
-        const fileName = path27.basename(filePath, ".md");
+        const fileName = path28.basename(filePath, ".md");
         const node = projectEntityNode(fileName, content);
         const outputPath = resolveContainedOutputPath(realOutputDir, "entities", `${fileName}.md`);
         writeProjectedContent(realOutputDir, outputPath, node.content);
@@ -25183,7 +25218,7 @@ async function generateContextTree(options) {
   }
   const shouldIncludeQuestions = includeQuestions && (requestedCategories === void 0 || requestedCategories.includes("question"));
   if (shouldIncludeQuestions) {
-    const questionsDir = path27.join(memoryDir, "questions");
+    const questionsDir = path28.join(memoryDir, "questions");
     if (fs.existsSync(questionsDir)) {
       assertSafeInputRoot(realMemoryDir, questionsDir, "questions root");
       categoryCounts["question"] = 0;
@@ -25224,8 +25259,8 @@ async function generateContextTree(options) {
   };
 }
 function isPathInside(root, candidate) {
-  const relative = path27.relative(root, candidate);
-  return relative === "" || !relative.startsWith("..") && !path27.isAbsolute(relative);
+  const relative = path28.relative(root, candidate);
+  return relative === "" || !relative.startsWith("..") && !path28.isAbsolute(relative);
 }
 function assertNotSymlink(targetPath, label) {
   try {
@@ -25262,12 +25297,12 @@ function assertSafeInputRoot(realMemoryDir, targetPath, label) {
 }
 function assertSafeOutputTarget(realOutputDir, outputPath) {
   let current = realOutputDir;
-  const relative = path27.relative(realOutputDir, outputPath);
-  if (relative.startsWith("..") || path27.isAbsolute(relative)) {
+  const relative = path28.relative(realOutputDir, outputPath);
+  if (relative.startsWith("..") || path28.isAbsolute(relative)) {
     throw new Error(`context tree output path escapes outputDir: ${outputPath}`);
   }
-  for (const segment of relative.split(path27.sep).filter(Boolean)) {
-    current = path27.join(current, segment);
+  for (const segment of relative.split(path28.sep).filter(Boolean)) {
+    current = path28.join(current, segment);
     try {
       const stat5 = fs.lstatSync(current);
       if (stat5.isSymbolicLink()) {
@@ -25297,17 +25332,17 @@ function validateProjectionCategories(categories) {
   return validated;
 }
 function resolveContainedOutputPath(outputRoot, ...segments) {
-  const resolved = path27.resolve(outputRoot, ...segments);
-  const relative = path27.relative(outputRoot, resolved);
-  if (relative === "" || !relative.startsWith("..") && !path27.isAbsolute(relative)) {
+  const resolved = path28.resolve(outputRoot, ...segments);
+  const relative = path28.relative(outputRoot, resolved);
+  if (relative === "" || !relative.startsWith("..") && !path28.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(path27.dirname(outputPath), { recursive: true });
-  const realParent = fs.realpathSync(path27.dirname(outputPath));
+  fs.mkdirSync(path28.dirname(outputPath), { recursive: true });
+  const realParent = fs.realpathSync(path28.dirname(outputPath));
   if (!isPathInside(realOutputDir, realParent)) {
     throw new Error(`context tree output path escapes outputDir: ${outputPath}`);
   }
@@ -25346,7 +25381,7 @@ function walkR(dir, realMemoryDir) {
   const results = [];
   function walk(directory) {
     for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
-      const fullPath = path27.join(directory, entry.name);
+      const fullPath = path28.join(directory, entry.name);
       if (entry.isSymbolicLink()) {
         throw new Error(`context tree input path contains symlink: ${fullPath}`);
       }
@@ -25399,13 +25434,13 @@ function extractBody(content) {
 }
 function projectNode(filePath, category, fm, rawContent) {
   const body = extractBody(rawContent);
-  const fileName = path27.basename(filePath, ".md");
-  const dateDir = path27.basename(path27.dirname(filePath));
+  const fileName = path28.basename(filePath, ".md");
+  const dateDir = path28.basename(path28.dirname(filePath));
   let relPath;
   if (/^\d{4}-\d{2}-\d{2}$/.test(dateDir)) {
-    relPath = path27.join(category, dateDir, `${fileName}.md`);
+    relPath = path28.join(category, dateDir, `${fileName}.md`);
   } else {
-    relPath = path27.join(category, `${fileName}.md`);
+    relPath = path28.join(category, `${fileName}.md`);
   }
   const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
   const md = `# ${fm.id}
@@ -25451,7 +25486,7 @@ function projectEntityNode(fileName, content) {
 ${content}
 `;
   return {
-    path: path27.join("entities", `${fileName}.md`),
+    path: path28.join("entities", `${fileName}.md`),
     category: "entity",
     title: fileName,
     content: md,
@@ -25504,7 +25539,7 @@ function generateIndex(categoryCounts, outputDir) {
 
 // src/onboarding/index.ts
 import fs2 from "fs";
-import path28 from "path";
+import path29 from "path";
 var LANGUAGE_RULES = [
   {
     language: "TypeScript",
@@ -25606,7 +25641,7 @@ function onboard(options) {
     maxDepth = 6,
     excludeDirs = []
   } = options;
-  const directory = path28.resolve(options.directory ?? process.cwd());
+  const directory = path29.resolve(options.directory ?? process.cwd());
   let rootStat;
   try {
     rootStat = fs2.statSync(directory);
@@ -25648,7 +25683,7 @@ function walkDir(root, exclude, maxDepth) {
     }
     for (const entry of entries) {
       if (exclude.has(entry.name)) continue;
-      const fullPath = path28.join(dir, entry.name);
+      const fullPath = path29.join(dir, entry.name);
       if (entry.isDirectory()) {
         walk(fullPath, depth + 1);
       } else if (entry.isFile()) {
@@ -25663,11 +25698,11 @@ function detectLanguages(files, root) {
   const results = [];
   const extCounts = /* @__PURE__ */ new Map();
   for (const f of files) {
-    const ext = path28.extname(f).toLowerCase();
+    const ext = path29.extname(f).toLowerCase();
     if (ext) extCounts.set(ext, (extCounts.get(ext) ?? 0) + 1);
   }
   const rootFiles = new Set(
-    files.filter((f) => path28.dirname(f) === root).map((f) => path28.basename(f))
+    files.filter((f) => path29.dirname(f) === root).map((f) => path29.basename(f))
   );
   for (const rule of LANGUAGE_RULES) {
     const evidence = [];
@@ -25711,7 +25746,7 @@ function detectLanguages(files, root) {
 }
 function detectShape(files, root) {
   const rootFiles = new Set(
-    files.filter((f) => path28.dirname(f) === root).map((f) => path28.basename(f))
+    files.filter((f) => path29.dirname(f) === root).map((f) => path29.basename(f))
   );
   const rootDirs = /* @__PURE__ */ new Set();
   try {
@@ -25722,7 +25757,7 @@ function detectShape(files, root) {
   }
   const evidence = [];
   if (rootFiles.has("package.json")) {
-    const pkg = readJsonSafe(path28.join(root, "package.json"));
+    const pkg = readJsonSafe(path29.join(root, "package.json"));
     if (pkg?.workspaces) {
       evidence.push("package.json has workspaces");
       return { shape: "monorepo", evidence };
@@ -25736,13 +25771,13 @@ function detectShape(files, root) {
     evidence.push("workspace manifest found");
     return { shape: "workspace", evidence };
   }
-  const cargoToml = readTomlWorkspace(path28.join(root, "Cargo.toml"));
+  const cargoToml = readTomlWorkspace(path29.join(root, "Cargo.toml"));
   if (cargoToml) {
     evidence.push("Cargo.toml has workspace");
     return { shape: "workspace", evidence };
   }
   if (rootFiles.has("package.json")) {
-    const pkg = readJsonSafe(path28.join(root, "package.json"));
+    const pkg = readJsonSafe(path29.join(root, "package.json"));
     if (pkg?.exports || pkg?.main) {
       if (pkg?.bin) {
         evidence.push("package.json has bin");
@@ -25776,8 +25811,8 @@ function discoverDocs(files, root) {
     { pattern: /^\.editorconfig$/i, kind: "config" }
   ];
   for (const filePath of files) {
-    const basename = path28.basename(filePath).toLowerCase();
-    const relPath = path28.relative(root, filePath);
+    const basename = path29.basename(filePath).toLowerCase();
+    const relPath = path29.relative(root, filePath);
     let kind;
     for (const { pattern, kind: k } of docPatterns) {
       if (pattern.test(basename)) {
@@ -25789,7 +25824,7 @@ function discoverDocs(files, root) {
       kind = "docs";
     }
     if (!kind && (basename.endsWith(".md") || basename.endsWith(".mdx"))) {
-      if (path28.dirname(relPath) === "." || isUnderDocsDir(relPath)) {
+      if (path29.dirname(relPath) === "." || isUnderDocsDir(relPath)) {
         kind = "docs";
       }
     }
@@ -25810,7 +25845,7 @@ function discoverDocs(files, root) {
   return docs;
 }
 function isUnderDocsDir(relPath) {
-  const parts = relPath.split(path28.sep);
+  const parts = relPath.split(path29.sep);
   return parts[0] === "docs" || parts[0] === "doc" || parts[0] === "documentation";
 }
 function buildPlan(languages, shape, docs, _root) {
@@ -25854,7 +25889,7 @@ function readTomlWorkspace(filePath) {
 
 // src/curation/index.ts
 import fs3 from "fs";
-import path29 from "path";
+import path30 from "path";
 import crypto4 from "crypto";
 async function curate(options) {
   const startTime = Date.now();
@@ -25945,12 +25980,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 = path29.join(dir, entry.name);
+      const fullPath = path30.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (entry.name !== "node_modules" && entry.name !== ".git") {
           walk(fullPath);
         }
-      } else if (extensions.has(path29.extname(entry.name).toLowerCase())) {
+      } else if (extensions.has(path30.extname(entry.name).toLowerCase())) {
         results.push(fullPath);
       }
     }
@@ -25959,12 +25994,12 @@ function resolveTargets(targetPath) {
   return results;
 }
 function resolveProvenanceRoot(targetPath) {
-  const resolvedTarget = path29.resolve(targetPath);
+  const resolvedTarget = path30.resolve(targetPath);
   const stat5 = fs3.statSync(resolvedTarget);
-  return stat5.isFile() ? path29.dirname(resolvedTarget) : resolvedTarget;
+  return stat5.isFile() ? path30.dirname(resolvedTarget) : resolvedTarget;
 }
 function extractStatements(content, filePath, projectRoot, source, sourceFileHash, categoryOverride, confidence, entityRef, tags) {
-  const relativePath = path29.relative(projectRoot, path29.resolve(filePath)) || path29.basename(filePath);
+  const relativePath = path30.relative(projectRoot, path30.resolve(filePath)) || path30.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);
@@ -26058,7 +26093,7 @@ function loadExistingMemories(memoryDir) {
   if (!fs3.existsSync(memoryDir)) return result;
   const dirs = ALL_CATEGORY_DIRS;
   for (const dir of dirs) {
-    const fullDir = path29.join(memoryDir, dir);
+    const fullDir = path30.join(memoryDir, dir);
     if (!fs3.existsSync(fullDir)) continue;
     walkFiles(fullDir, (filePath) => {
       const content = readFileSafe(filePath);
@@ -26081,11 +26116,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 = path29.join(categoryDir, dateDir);
+  const dir = path30.join(categoryDir, dateDir);
   fs3.mkdirSync(dir, { recursive: true });
   const fileName = `${stmt.category}-${Date.now()}-${stmt.id.slice(0, 8)}.md`;
-  const filePath = path29.join(dir, fileName);
-  const historicalIds = historicalIdCache2.get(path29.join(memoryDir, "state"));
+  const filePath = path30.join(dir, fileName);
+  const historicalIds = historicalIdCache2.get(path30.join(memoryDir, "state"));
   const rawBody = `${[
     "---",
     `id: ${stmt.id}`,
@@ -26108,7 +26143,7 @@ ${stmt.content}
   fs3.writeFileSync(filePath, body);
   try {
     repairContentAfterJournalMoveSync({
-      stateDir: path29.join(memoryDir, "state"),
+      stateDir: path30.join(memoryDir, "state"),
       cache: historicalIdCache2,
       idsAtWrite: historicalIds,
       rawContent: rawBody,
@@ -26169,7 +26204,7 @@ function extractBody2(content) {
 }
 function walkFiles(dir, callback) {
   for (const entry of fs3.readdirSync(dir, { withFileTypes: true })) {
-    const fullPath = path29.join(dir, entry.name);
+    const fullPath = path30.join(dir, entry.name);
     if (entry.isDirectory()) {
       walkFiles(fullPath, callback);
     } else if (entry.name.endsWith(".md")) {
@@ -26178,305 +26213,10 @@ function walkFiles(dir, callback) {
   }
 }
 
-// src/dedup/index.ts
-import crypto5 from "crypto";
-import fs4 from "fs";
-import path30 from "path";
-var DEFAULT_DEDUP_THRESHOLD = 0.85;
-var DEFAULT_MAX_LOAD = 1e4;
-function normalizeThreshold(value, defaultValue) {
-  return typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= 1 ? value : defaultValue;
-}
-function normalizeMaxLoad(value, defaultValue) {
-  return typeof value === "number" && Number.isInteger(value) && value >= 0 ? value : defaultValue;
-}
-function findDuplicates(options) {
-  const startTime = Date.now();
-  const { memoryDir } = options;
-  const threshold = normalizeThreshold(options.threshold, DEFAULT_DEDUP_THRESHOLD);
-  const maxLoad = normalizeMaxLoad(options.maxLoad, DEFAULT_MAX_LOAD);
-  const memories = loadMemories(memoryDir, options.categories, maxLoad);
-  const duplicates = [];
-  for (let i = 0; i < memories.length; i++) {
-    for (let j = i + 1; j < memories.length; j++) {
-      const sim = computeSimilarity(memories[i].content, memories[j].content);
-      if (sim >= threshold) {
-        duplicates.push({
-          left: memories[i],
-          right: memories[j],
-          similarity: sim,
-          action: sim >= 0.98 ? "merge" : sim >= 0.9 ? "keep_right" : "keep_left"
-        });
-      }
-    }
-  }
-  return {
-    scanned: memories.length,
-    duplicates,
-    durationMs: Date.now() - startTime
-  };
-}
-function findContradictions(options) {
-  const startTime = Date.now();
-  const { memoryDir } = options;
-  const maxLoad = normalizeMaxLoad(options.maxLoad, DEFAULT_MAX_LOAD);
-  const memories = loadMemories(memoryDir, options.categories, maxLoad);
-  const contradictions = [];
-  for (let i = 0; i < memories.length; i++) {
-    for (let j = i + 1; j < memories.length; j++) {
-      const contra = detectContradiction(memories[i], memories[j]);
-      if (contra) {
-        contradictions.push(contra);
-      }
-    }
-  }
-  return {
-    scanned: memories.length,
-    contradictions,
-    durationMs: Date.now() - startTime
-  };
-}
-function computeSimilarity(a, b) {
-  const normA = normalize(a);
-  const normB = normalize(b);
-  const punctuationBoundariesA = embeddedPunctuationSignature(a);
-  const punctuationBoundariesB = embeddedPunctuationSignature(b);
-  if (punctuationBoundariesA !== punctuationBoundariesB) return 0;
-  if (normA === normB) return 1;
-  if (hashContent2(normA) === hashContent2(normB)) return 0.99;
-  if (normA.length > 50 && normB.length > 50) {
-    if (normA.includes(normB.slice(0, 40)) || normB.includes(normA.slice(0, 40))) {
-      return 0.9;
-    }
-  }
-  const wordsA = tokenizeForSimilarity(normA);
-  const wordsB = tokenizeForSimilarity(normB);
-  const intersection = new Set([...wordsA].filter((w) => wordsB.has(w)));
-  const union = /* @__PURE__ */ new Set([...wordsA, ...wordsB]);
-  if (union.size === 0) return 0;
-  return intersection.size / union.size;
-}
-function embeddedPunctuationSignature(text) {
-  const chars = [...text.normalize("NFC")];
-  const significant = /[\p{L}\p{M}\p{N}]/u;
-  const ignored = /[\s']/u;
-  const boundaries = [];
-  let position = 0;
-  for (let index = 0; index < chars.length; ) {
-    const char = chars[index];
-    if (char === void 0) break;
-    if (significant.test(char)) {
-      position++;
-      index++;
-      continue;
-    }
-    if (ignored.test(char)) {
-      index++;
-      continue;
-    }
-    const start = index;
-    while (index < chars.length) {
-      const next = chars[index];
-      if (next === void 0 || significant.test(next) || ignored.test(next)) break;
-      index++;
-    }
-    const before = chars[start - 1];
-    const after = chars[index];
-    if (before && after && significant.test(before) && significant.test(after)) {
-      boundaries.push(`${position}:${chars.slice(start, index).join("")}`);
-    }
-  }
-  return boundaries.join("\0");
-}
-function normalize(text) {
-  return text.normalize("NFC").toLowerCase().replace(/[^\p{ASCII}\p{L}\p{M}\p{N}\s']/gu, " ").replace(/[^\p{L}\p{M}\p{N}\s']/gu, "").replace(/\s+/g, " ").trim();
-}
-function tokenizeForSimilarity(text) {
-  if (/\p{Script=Hangul}/u.test(text)) {
-    const tokens = normalizeRecallTokenSet(text);
-    for (const segment of text.match(/\p{Script=Hangul}+/gu) ?? []) {
-      const chars = [...segment];
-      for (const size of [1, 2, 3, 4]) {
-        for (let index = 0; index <= chars.length - size; index += 1) {
-          tokens.add(chars.slice(index, index + size).join(""));
-        }
-      }
-    }
-    return tokens;
-  }
-  if (/[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}]/u.test(text)) {
-    return normalizeRecallTokenSet(text);
-  }
-  return text.length === 0 ? /* @__PURE__ */ new Set() : new Set(text.split(/\s+/));
-}
-var NEGATION_WORDS = /* @__PURE__ */ new Set([
-  "not",
-  "don't",
-  "doesn't",
-  "isn't",
-  "aren't",
-  "won't",
-  "can't",
-  "cannot",
-  "never",
-  "no",
-  "none",
-  "neither",
-  "nor",
-  "nothing",
-  "nowhere"
-]);
-function detectContradiction(a, b) {
-  const normA = normalize(a.content);
-  const normB = normalize(b.content);
-  const aHasNegation = containsNegation(normA);
-  const bHasNegation = containsNegation(normB);
-  if (aHasNegation === bHasNegation) return null;
-  const strippedA = stripNegation(normA);
-  const strippedB = stripNegation(normB);
-  const sim = computeSimilarity(strippedA, strippedB);
-  if (sim < 0.7) return null;
-  const oppQuantifiers = [
-    ["always", "never"],
-    ["all", "none"],
-    ["every", "no"],
-    ["must", "must not"],
-    ["should", "should not"],
-    ["can", "cannot"]
-  ];
-  for (const [pos, neg] of oppQuantifiers) {
-    if (a.content.toLowerCase().includes(pos) && b.content.toLowerCase().includes(neg) || a.content.toLowerCase().includes(neg) && b.content.toLowerCase().includes(pos)) {
-      return {
-        left: a,
-        right: b,
-        severity: "high",
-        reason: `Opposite quantifiers: "${pos}" vs "${neg}"`
-      };
-    }
-  }
-  return {
-    left: a,
-    right: b,
-    severity: sim >= 0.85 ? "high" : "medium",
-    reason: "Negated version of similar content"
-  };
-}
-function containsNegation(text) {
-  const words = text.split(/\s+/);
-  return words.some((w) => NEGATION_WORDS.has(w));
-}
-function escapeRegExp(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-var stripNegationPattern = null;
-var stripNegationPatternSource = null;
-function stripNegationRegex() {
-  const alternation = [...NEGATION_WORDS].sort((a, b) => b.length - a.length).map(escapeRegExp).join("|");
-  if (stripNegationPattern === null || stripNegationPatternSource !== alternation) {
-    stripNegationPattern = new RegExp(`\\b(?:${alternation})\\b`, "gi");
-    stripNegationPatternSource = alternation;
-  }
-  return stripNegationPattern;
-}
-function stripNegation(text) {
-  return text.replace(stripNegationRegex(), "").replace(/\s+/g, " ").trim();
-}
-function loadMemories(memoryDir, categories, maxLoad = 1e4) {
-  const result = [];
-  const allCategories = categories ?? ALL_CATEGORY_DIRS;
-  if (!fs4.existsSync(memoryDir)) return result;
-  const memoryRootReal = fs4.realpathSync(memoryDir);
-  for (const category of allCategories) {
-    if (result.length >= maxLoad) break;
-    const dir = path30.join(memoryDir, category);
-    if (!fs4.existsSync(dir)) continue;
-    const categoryStat = fs4.lstatSync(dir);
-    if (categoryStat.isSymbolicLink()) {
-      throw new Error(`Refusing to scan symlinked memory category directory: ${dir}`);
-    }
-    if (!categoryStat.isDirectory()) continue;
-    const categoryRootReal = fs4.realpathSync(dir);
-    assertPathInsideRoot2(memoryRootReal, categoryRootReal, dir);
-    walkMdFiles(dir, memoryRootReal, categoryRootReal, (filePath) => {
-      if (result.length >= maxLoad) return;
-      const content = readFileSafe2(filePath, memoryRootReal, categoryRootReal);
-      if (!content) return;
-      const fm = parseFrontmatter3(content);
-      const body = extractBody3(content);
-      if (!fm?.id || !body) return;
-      result.push({
-        id: fm.id,
-        content: body,
-        category: fm.category ?? category.slice(0, -1),
-        filePath
-      });
-    });
-  }
-  return result;
-}
-function hashContent2(content) {
-  return crypto5.createHash("sha256").update(content).digest("hex").slice(0, 16);
-}
-function readFileSafe2(filePath, memoryRootReal, categoryRootReal) {
-  try {
-    const fileStat = fs4.lstatSync(filePath);
-    if (fileStat.isSymbolicLink()) {
-      throw new Error(`Refusing to read symlinked memory file: ${filePath}`);
-    }
-    const fileReal = fs4.realpathSync(filePath);
-    assertPathInsideRoot2(memoryRootReal, fileReal, filePath);
-    assertPathInsideRoot2(categoryRootReal, fileReal, filePath);
-    return fs4.readFileSync(filePath, "utf8");
-  } catch {
-    return null;
-  }
-}
-function parseFrontmatter3(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 extractBody3(content) {
-  const match = content.match(/^---\n[\s\S]*?\n---\n([\s\S]*)/);
-  return match ? match[1].trim() : content.trim();
-}
-function assertPathInsideRoot2(rootReal, targetReal, sourcePath) {
-  const rel = path30.relative(rootReal, targetReal);
-  if (rel === "" || !rel.startsWith("..") && !path30.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 = path30.join(dir, entry.name);
-    const entryStat = fs4.lstatSync(fullPath);
-    if (entryStat.isSymbolicLink()) {
-      throw new Error(`Refusing to scan symlinked memory path: ${fullPath}`);
-    }
-    const entryReal = fs4.realpathSync(fullPath);
-    assertPathInsideRoot2(memoryRootReal, entryReal, fullPath);
-    assertPathInsideRoot2(categoryRootReal, entryReal, fullPath);
-    if (entryStat.isDirectory()) {
-      walkMdFiles(fullPath, memoryRootReal, categoryRootReal, callback);
-    } else if (entry.name.endsWith(".md")) {
-      callback(fullPath);
-    }
-  }
-}
-
 // src/sync/index.ts
-import fs5 from "fs";
+import fs4 from "fs";
 import path31 from "path";
-import crypto6 from "crypto";
+import crypto5 from "crypto";
 var DEFAULT_EXTENSIONS = /* @__PURE__ */ new Set([".md", ".txt", ".mdx", ".rst"]);
 var DEFAULT_EXCLUDE2 = /* @__PURE__ */ new Set([
   "node_modules",
@@ -26513,8 +26253,8 @@ function syncChanges(options) {
     for (const [relPath, hash] of Object.entries(currentFiles)) {
       newState.fileHashes[relPath] = hash;
     }
-    fs5.mkdirSync(path31.dirname(stateFilePath), { recursive: true });
-    fs5.writeFileSync(stateFilePath, JSON.stringify(newState, null, 2));
+    fs4.mkdirSync(path31.dirname(stateFilePath), { recursive: true });
+    fs4.writeFileSync(stateFilePath, JSON.stringify(newState, null, 2));
   }
   return {
     scanned: Object.keys(currentFiles).length,
@@ -26568,7 +26308,7 @@ function scanFiles(root, extensions, exclude) {
   function walk(dir, isRoot = false) {
     let entries;
     try {
-      entries = fs5.readdirSync(dir, { withFileTypes: true });
+      entries = fs4.readdirSync(dir, { withFileTypes: true });
     } catch (err) {
       if (isRoot) {
         throw new Error(
@@ -26587,8 +26327,8 @@ function scanFiles(root, extensions, exclude) {
         if (!extensions.has(ext)) continue;
         const relPath = path31.relative(root, fullPath);
         try {
-          const content = fs5.readFileSync(fullPath, "utf8");
-          result[relPath] = hashContent3(content);
+          const content = fs4.readFileSync(fullPath, "utf8");
+          result[relPath] = hashContent2(content);
         } catch {
         }
       }
@@ -26604,7 +26344,7 @@ function computeDiff(current, previous, sourceDir) {
     if (!(relPath in previous)) {
       let size = 0;
       try {
-        size = fs5.statSync(fullPath).size;
+        size = fs4.statSync(fullPath).size;
       } catch {
       }
       changes.push({
@@ -26617,7 +26357,7 @@ function computeDiff(current, previous, sourceDir) {
     } else if (previous[relPath] !== hash) {
       let size = 0;
       try {
-        size = fs5.statSync(fullPath).size;
+        size = fs4.statSync(fullPath).size;
       } catch {
       }
       changes.push({
@@ -26645,7 +26385,7 @@ function computeDiff(current, previous, sourceDir) {
 }
 function loadState(stateFilePath) {
   try {
-    const raw = fs5.readFileSync(stateFilePath, "utf8");
+    const raw = fs4.readFileSync(stateFilePath, "utf8");
     return JSON.parse(raw);
   } catch {
     return {
@@ -26655,14 +26395,14 @@ function loadState(stateFilePath) {
     };
   }
 }
-function hashContent3(content) {
-  return crypto6.createHash("sha256").update(content).digest("hex").slice(0, 16);
+function hashContent2(content) {
+  return crypto5.createHash("sha256").update(content).digest("hex").slice(0, 16);
 }
 
 // src/spaces/index.ts
 import { spawnSync } from "child_process";
-import crypto7 from "crypto";
-import fs6 from "fs";
+import crypto6 from "crypto";
+import fs5 from "fs";
 import path32 from "path";
 var historicalIdCache3 = new HistoricalEntityCanonicalIdCache();
 var MANIFEST_VERSION = 1;
@@ -26680,7 +26420,7 @@ function getManifestPath(baseDir) {
   return path32.join(getSpacesDir(baseDir), "manifest.json");
 }
 function loadManifest(baseDir, memoryDirOverride) {
-  if (fs6.existsSync(getManifestPath(baseDir))) {
+  if (fs5.existsSync(getManifestPath(baseDir))) {
     try {
       return readManifestUnlocked(baseDir, memoryDirOverride, { bootstrapIfMissing: false });
     } catch (error) {
@@ -26706,7 +26446,7 @@ function updateManifest(baseDir, updater, memoryDirOverride) {
 }
 function readManifestUnlocked(baseDir, memoryDirOverride, options = {}) {
   const manifestPath2 = getManifestPath(baseDir);
-  if (!fs6.existsSync(manifestPath2)) {
+  if (!fs5.existsSync(manifestPath2)) {
     if (options.bootstrapIfMissing === false) {
       const error = new Error(`Spaces manifest not found: ${manifestPath2}`);
       error.code = "ENOENT";
@@ -26719,21 +26459,21 @@ function readManifestUnlocked(baseDir, memoryDirOverride, options = {}) {
       version: MANIFEST_VERSION
     };
   }
-  const raw = JSON.parse(fs6.readFileSync(manifestPath2, "utf8"));
+  const raw = JSON.parse(fs5.readFileSync(manifestPath2, "utf8"));
   return raw;
 }
 function saveManifestUnlocked(manifest, baseDir) {
   const manifestPath2 = getManifestPath(baseDir);
   const manifestDir2 = path32.dirname(manifestPath2);
-  fs6.mkdirSync(manifestDir2, { recursive: true });
-  const tempPath = path32.join(manifestDir2, `.manifest.${process.pid}.${Date.now()}.${crypto7.randomUUID()}.tmp`);
+  fs5.mkdirSync(manifestDir2, { recursive: true });
+  const tempPath = path32.join(manifestDir2, `.manifest.${process.pid}.${Date.now()}.${crypto6.randomUUID()}.tmp`);
   try {
-    fs6.writeFileSync(tempPath, `${JSON.stringify(manifest, null, 2)}
+    fs5.writeFileSync(tempPath, `${JSON.stringify(manifest, null, 2)}
 `, { flag: "wx" });
-    fs6.renameSync(tempPath, manifestPath2);
+    fs5.renameSync(tempPath, manifestPath2);
   } catch (error) {
     try {
-      fs6.rmSync(tempPath, { force: true });
+      fs5.rmSync(tempPath, { force: true });
     } catch {
     }
     throw error;
@@ -26741,7 +26481,7 @@ function saveManifestUnlocked(manifest, baseDir) {
 }
 function withManifestLock(baseDir, operation) {
   const lockDir = `${getManifestPath(baseDir)}.lock`;
-  fs6.mkdirSync(path32.dirname(lockDir), { recursive: true });
+  fs5.mkdirSync(path32.dirname(lockDir), { recursive: true });
   const lockOwner = acquireManifestLock(lockDir);
   try {
     return operation();
@@ -26754,10 +26494,10 @@ function acquireManifestLock(lockDir) {
   const owner = createManifestLockOwner();
   const reclaimDir = getManifestLockReclaimDir(lockDir);
   while (true) {
-    if (fs6.existsSync(reclaimDir)) {
+    if (fs5.existsSync(reclaimDir)) {
       removeStaleManifestReclaimLock(reclaimDir);
     }
-    if (fs6.existsSync(reclaimDir)) {
+    if (fs5.existsSync(reclaimDir)) {
       if (Date.now() >= deadline) {
         throw new Error(`Timed out waiting for spaces manifest reclaim lock: ${reclaimDir}`);
       }
@@ -26765,15 +26505,15 @@ function acquireManifestLock(lockDir) {
       continue;
     }
     try {
-      fs6.mkdirSync(lockDir, { recursive: false });
+      fs5.mkdirSync(lockDir, { recursive: false });
       try {
-        fs6.writeFileSync(path32.join(lockDir, "owner"), `${owner}
+        fs5.writeFileSync(path32.join(lockDir, "owner"), `${owner}
 `, { flag: "wx" });
       } catch (error) {
-        fs6.rmSync(lockDir, { recursive: true, force: true });
+        fs5.rmSync(lockDir, { recursive: true, force: true });
         throw error;
       }
-      if (fs6.existsSync(reclaimDir)) {
+      if (fs5.existsSync(reclaimDir)) {
         releaseManifestLock(lockDir, owner);
         if (Date.now() >= deadline) {
           throw new Error(`Timed out waiting for spaces manifest reclaim lock: ${reclaimDir}`);
@@ -26798,8 +26538,8 @@ function acquireManifestLock(lockDir) {
 function releaseManifestLock(lockDir, owner) {
   try {
     const ownerPath = path32.join(lockDir, "owner");
-    if (fs6.readFileSync(ownerPath, "utf8").trim() === owner) {
-      fs6.rmSync(lockDir, { recursive: true, force: true });
+    if (fs5.readFileSync(ownerPath, "utf8").trim() === owner) {
+      fs5.rmSync(lockDir, { recursive: true, force: true });
     }
   } catch (error) {
     if (error.code !== "ENOENT") {
@@ -26811,12 +26551,12 @@ function removeStaleManifestLock(lockDir) {
   const reclaimDir = getManifestLockReclaimDir(lockDir);
   const reclaimOwner = createManifestLockOwner();
   try {
-    fs6.mkdirSync(reclaimDir, { recursive: false });
+    fs5.mkdirSync(reclaimDir, { recursive: false });
     try {
-      fs6.writeFileSync(path32.join(reclaimDir, "owner"), `${reclaimOwner}
+      fs5.writeFileSync(path32.join(reclaimDir, "owner"), `${reclaimOwner}
 `, { flag: "wx" });
     } catch (error) {
-      fs6.rmSync(reclaimDir, { recursive: true, force: true });
+      fs5.rmSync(reclaimDir, { recursive: true, force: true });
       throw error;
     }
   } catch (error) {
@@ -26834,18 +26574,18 @@ function removeStaleManifestLock(lockDir) {
     if (isManifestLockOwnerActive(snapshot.owner)) {
       return;
     }
-    const tombstoneDir = `${lockDir}.stale.${process.pid}.${crypto7.randomUUID()}`;
+    const tombstoneDir = `${lockDir}.stale.${process.pid}.${crypto6.randomUUID()}`;
     try {
-      fs6.renameSync(lockDir, tombstoneDir);
+      fs5.renameSync(lockDir, tombstoneDir);
     } catch (error) {
       if (error.code !== "ENOENT") {
         throw error;
       }
       return;
     }
-    fs6.rmSync(tombstoneDir, { recursive: true, force: true });
+    fs5.rmSync(tombstoneDir, { recursive: true, force: true });
   } finally {
-    fs6.rmSync(reclaimDir, { recursive: true, force: true });
+    fs5.rmSync(reclaimDir, { recursive: true, force: true });
   }
 }
 function getManifestLockReclaimDir(lockDir) {
@@ -26855,7 +26595,7 @@ function createManifestLockOwner() {
   return JSON.stringify({
     pid: process.pid,
     startKey: readProcessStartKey(process.pid),
-    token: crypto7.randomUUID()
+    token: crypto6.randomUUID()
   });
 }
 function removeStaleManifestReclaimLock(reclaimDir) {
@@ -26866,21 +26606,21 @@ function removeStaleManifestReclaimLock(reclaimDir) {
   if (isManifestLockOwnerActive(snapshot.owner)) {
     return;
   }
-  const tombstoneDir = `${reclaimDir}.stale.${process.pid}.${crypto7.randomUUID()}`;
+  const tombstoneDir = `${reclaimDir}.stale.${process.pid}.${crypto6.randomUUID()}`;
   try {
-    fs6.renameSync(reclaimDir, tombstoneDir);
+    fs5.renameSync(reclaimDir, tombstoneDir);
   } catch (error) {
     if (error.code !== "ENOENT") {
       throw error;
     }
     return;
   }
-  fs6.rmSync(tombstoneDir, { recursive: true, force: true });
+  fs5.rmSync(tombstoneDir, { recursive: true, force: true });
 }
 function readManifestLockSnapshot(lockDir) {
   let stat5;
   try {
-    stat5 = fs6.statSync(lockDir);
+    stat5 = fs5.statSync(lockDir);
   } catch (error) {
     if (error.code === "ENOENT") {
       return void 0;
@@ -26888,7 +26628,7 @@ function readManifestLockSnapshot(lockDir) {
     throw error;
   }
   try {
-    const owner = fs6.readFileSync(path32.join(lockDir, "owner"), "utf8").trim();
+    const owner = fs5.readFileSync(path32.join(lockDir, "owner"), "utf8").trim();
     return { mtimeMs: stat5.mtimeMs, owner };
   } catch (error) {
     if (error.code === "ENOENT") {
@@ -26962,7 +26702,7 @@ function createPersonalSpace(baseDir, memoryDirOverride) {
   const homeDir = baseDir ?? resolveHomeDir();
   const standalonePath = path32.join(homeDir, ".engram", "memory");
   const openclawPath = path32.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 memoryDir = memoryDirOverride ?? readEnvVar("REMNIC_MEMORY_DIR") ?? readEnvVar("ENGRAM_MEMORY_DIR") ?? (fs5.existsSync(standalonePath) ? standalonePath : fs5.existsSync(openclawPath) ? openclawPath : standalonePath);
   const normalizedMemoryDir = normalizeSpaceMemoryDir(memoryDir);
   const now = (/* @__PURE__ */ new Date()).toISOString();
   return {
@@ -27010,7 +26750,7 @@ function createSpace(options) {
       owner: readEnvVar("USER"),
       parentSpaceId: options.parentSpaceId
     };
-    fs6.mkdirSync(memoryDir, { recursive: true });
+    fs5.mkdirSync(memoryDir, { recursive: true });
     manifest.spaces.push(created);
     manifest.updatedAt = now;
     return created;
@@ -27168,9 +26908,9 @@ async function promoteSpace(sourceSpaceId, targetSpaceId, options) {
   const subjectWarnings = [];
   const warnedMemoryIds = [];
   if (target.kind === "team") {
-    const sourceFiles = fs6.existsSync(source.memoryDir) ? walkMd(fs6.realpathSync(source.memoryDir)) : [];
+    const sourceFiles = fs5.existsSync(source.memoryDir) ? walkMd(fs5.realpathSync(source.memoryDir)) : [];
     for (const file of sourceFiles) {
-      const fm = parseSimpleFrontmatter(fs6.readFileSync(file, "utf8"));
+      const fm = parseSimpleFrontmatter(fs5.readFileSync(file, "utf8"));
       if (!fm?.id) continue;
       if (options?.memoryIds?.length && !options.memoryIds.includes(fm.id)) continue;
       const decision = evaluateSubjectGuard({
@@ -27237,28 +26977,28 @@ async function mergeSpaces(sourceSpaceId, targetSpaceId, options) {
 }
 function getAuditLog(baseDir) {
   const auditPath = path32.join(getSpacesDir(baseDir), "audit.jsonl");
-  if (!fs6.existsSync(auditPath)) return [];
-  const lines = fs6.readFileSync(auditPath, "utf8").trim().split("\n");
+  if (!fs5.existsSync(auditPath)) return [];
+  const lines = fs5.readFileSync(auditPath, "utf8").trim().split("\n");
   return lines.filter((l) => l.trim()).map((l) => JSON.parse(l));
 }
 function appendAudit(entry, baseDir) {
   const auditPath = path32.join(getSpacesDir(baseDir), "audit.jsonl");
-  fs6.mkdirSync(path32.dirname(auditPath), { recursive: true });
+  fs5.mkdirSync(path32.dirname(auditPath), { recursive: true });
   const full = {
-    id: crypto7.randomUUID(),
+    id: crypto6.randomUUID(),
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
     ...entry
   };
-  fs6.appendFileSync(auditPath, `${JSON.stringify(full)}
+  fs5.appendFileSync(auditPath, `${JSON.stringify(full)}
 `);
 }
 async function copyMemories(sourceDir, targetDir, options) {
-  if (!fs6.existsSync(sourceDir)) {
+  if (!fs5.existsSync(sourceDir)) {
     return { merged: 0, conflicts: [], skipped: 0 };
   }
-  const sourceRoot = fs6.realpathSync(sourceDir);
-  fs6.mkdirSync(targetDir, { recursive: true });
-  const targetRoot = fs6.realpathSync(targetDir);
+  const sourceRoot = fs5.realpathSync(sourceDir);
+  fs5.mkdirSync(targetDir, { recursive: true });
+  const targetRoot = fs5.realpathSync(targetDir);
   const sourceFiles = walkMd(sourceRoot);
   const sourceEntityIds = new Set(
     sourceFiles.filter((p) => {
@@ -27302,7 +27042,7 @@ function copyPreparedMemories(sourceFiles, sourceRoot, targetRoot, sourceEntityI
       skipped++;
       continue;
     }
-    const content = fs6.readFileSync(sourcePath, "utf8");
+    const content = fs5.readFileSync(sourcePath, "utf8");
     const relativePath = path32.relative(sourceRoot, sourceRealPath);
     const targetPath = path32.resolve(targetRoot, relativePath);
     if (!isPathInsideRoot(targetPath, targetRoot)) {
@@ -27314,7 +27054,7 @@ function copyPreparedMemories(sourceFiles, sourceRoot, targetRoot, sourceEntityI
     const sourceRef = targetKind === "memory" ? readEntityRefFromFrontmatter(content) : null;
     const refHasSourceClaimant = sourceRef !== null && sourceEntityIds.has(sourceRef);
     const canonicalContent = targetKind === "memory" && !refHasSourceClaimant ? canonicalizeEntityRefFrontmatter(content, idsAtCompare) : content;
-    const sourceHash = hashContent4(content);
+    const sourceHash = hashContent3(content);
     if (options?.filterIds?.length) {
       const fm = parseSimpleFrontmatter(content);
       if (!fm?.id || !options.filterIds.includes(fm.id)) {
@@ -27322,7 +27062,7 @@ function copyPreparedMemories(sourceFiles, sourceRoot, targetRoot, sourceEntityI
         continue;
       }
     }
-    if (fs6.existsSync(targetPath)) {
+    if (fs5.existsSync(targetPath)) {
       const targetStat = safeLstat(targetPath);
       if (!targetStat?.isFile() || targetStat.isSymbolicLink()) {
         skipped++;
@@ -27334,14 +27074,14 @@ function copyPreparedMemories(sourceFiles, sourceRoot, targetRoot, sourceEntityI
         continue;
       }
     }
-    if (fs6.existsSync(targetPath) && !options?.force) {
-      const targetContent = fs6.readFileSync(targetPath, "utf8");
-      const targetHash = hashContent4(targetContent);
-      if (hashContent4(canonicalContent) === targetHash && historicalIdCache3.get(path32.join(targetRoot, "state")) === idsAtCompare) {
+    if (fs5.existsSync(targetPath) && !options?.force) {
+      const targetContent = fs5.readFileSync(targetPath, "utf8");
+      const targetHash = hashContent3(targetContent);
+      if (hashContent3(canonicalContent) === targetHash && historicalIdCache3.get(path32.join(targetRoot, "state")) === idsAtCompare) {
         skipped++;
         continue;
       }
-      if (hashContent4(canonicalContent) !== targetHash && sourceHash !== targetHash) {
+      if (hashContent3(canonicalContent) !== targetHash && sourceHash !== targetHash) {
         conflicts.push({
           memoryId: parseSimpleFrontmatter(content)?.id ?? relativePath,
           sourcePath,
@@ -27353,7 +27093,7 @@ function copyPreparedMemories(sourceFiles, sourceRoot, targetRoot, sourceEntityI
         continue;
       }
     }
-    fs6.mkdirSync(path32.dirname(targetPath), { recursive: true });
+    fs5.mkdirSync(path32.dirname(targetPath), { recursive: true });
     const targetParentRealPath = safeRealpath(path32.dirname(targetPath));
     if (!targetParentRealPath || !isPathInsideRoot(targetParentRealPath, targetRoot)) {
       skipped++;
@@ -27365,11 +27105,11 @@ function copyPreparedMemories(sourceFiles, sourceRoot, targetRoot, sourceEntityI
       const written = canonicalizeEntityRefFrontmatter(content, idsAtWrite);
       let priorTarget = null;
       try {
-        priorTarget = fs6.readFileSync(targetPath, "utf8");
+        priorTarget = fs5.readFileSync(targetPath, "utf8");
       } catch {
         priorTarget = null;
       }
-      fs6.writeFileSync(targetPath, written);
+      fs5.writeFileSync(targetPath, written);
       try {
         repairContentAfterJournalMoveSync({
           stateDir,
@@ -27377,24 +27117,24 @@ function copyPreparedMemories(sourceFiles, sourceRoot, targetRoot, sourceEntityI
           idsAtWrite,
           rawContent: content,
           lastWritten: written,
-          rewrite: (next) => fs6.writeFileSync(targetPath, next)
+          rewrite: (next) => fs5.writeFileSync(targetPath, next)
         });
       } catch (err) {
         try {
           if (priorTarget === null) {
-            fs6.unlinkSync(targetPath);
+            fs5.unlinkSync(targetPath);
           } else {
-            fs6.writeFileSync(targetPath, priorTarget);
+            fs5.writeFileSync(targetPath, priorTarget);
           }
         } catch {
         }
         throw err;
       }
     } else if (targetKind === "memory") {
-      fs6.writeFileSync(targetPath, content);
+      fs5.writeFileSync(targetPath, content);
       reconcileNeeded = true;
     } else {
-      fs6.writeFileSync(targetPath, content);
+      fs5.writeFileSync(targetPath, content);
       if (targetKind === "entity") {
         reconcileNeeded = true;
       }
@@ -27407,13 +27147,13 @@ function copyPreparedMemories(sourceFiles, sourceRoot, targetRoot, sourceEntityI
   }
   return { merged, conflicts, skipped };
 }
-function hashContent4(content) {
-  return crypto7.createHash("sha256").update(content).digest("hex").slice(0, 16);
+function hashContent3(content) {
+  return crypto6.createHash("sha256").update(content).digest("hex").slice(0, 16);
 }
 function walkMd(dir) {
   const results = [];
   function walk(d) {
-    for (const entry of fs6.readdirSync(d, { withFileTypes: true })) {
+    for (const entry of fs5.readdirSync(d, { withFileTypes: true })) {
       const fullPath = path32.join(d, entry.name);
       if (entry.isSymbolicLink()) {
         continue;
@@ -27430,14 +27170,14 @@ function walkMd(dir) {
 }
 function safeLstat(filePath) {
   try {
-    return fs6.lstatSync(filePath);
+    return fs5.lstatSync(filePath);
   } catch {
     return null;
   }
 }
 function safeRealpath(filePath) {
   try {
-    return fs6.realpathSync(filePath);
+    return fs5.realpathSync(filePath);
   } catch {
     return null;
   }
@@ -27563,7 +27303,7 @@ var REMNIC_RECALL_DECISION_RULES = `## When to Use Recall vs Direct Read
 `;
 
 // src/memory-extension/codex-publisher.ts
-import fs7 from "fs";
+import fs6 from "fs";
 import os from "os";
 import path33 from "path";
 var REMNIC_EXTENSION_DIR_NAME = "remnic";
@@ -27599,7 +27339,7 @@ var CodexMemoryExtensionPublisher = class {
   async isHostAvailable() {
     try {
       const home = readEnvVar("CODEX_HOME")?.trim() || path33.join(resolveHomeDir(), ".codex");
-      return fs7.existsSync(home);
+      return fs6.existsSync(home);
     } catch {
       return false;
     }
@@ -27653,18 +27393,18 @@ When running inside the Codex phase-2 consolidation sandbox:
     const filesWritten = [];
     const skipped = [];
     ctx.log.info(`Publishing Codex memory extension to ${extensionRoot}`);
-    fs7.mkdirSync(extensionRoot, { recursive: true });
+    fs6.mkdirSync(extensionRoot, { recursive: true });
     const content = await this.renderInstructions(ctx);
     const tmpPath = `${instructionsPath}.tmp-${process.pid}-${Date.now()}`;
     try {
-      fs7.writeFileSync(tmpPath, content, "utf-8");
-      fs7.renameSync(tmpPath, instructionsPath);
+      fs6.writeFileSync(tmpPath, content, "utf-8");
+      fs6.renameSync(tmpPath, instructionsPath);
       filesWritten.push(instructionsPath);
       ctx.log.info(`Wrote ${instructionsPath}`);
     } catch (err) {
       try {
-        if (fs7.existsSync(tmpPath)) {
-          fs7.unlinkSync(tmpPath);
+        if (fs6.existsSync(tmpPath)) {
+          fs6.unlinkSync(tmpPath);
         }
       } catch {
       }
@@ -27679,8 +27419,8 @@ When running inside the Codex phase-2 consolidation sandbox:
   }
   async unpublish() {
     const extensionRoot = await this.resolveExtensionRoot();
-    if (fs7.existsSync(extensionRoot)) {
-      fs7.rmSync(extensionRoot, { recursive: true, force: true });
+    if (fs6.existsSync(extensionRoot)) {
+      fs6.rmSync(extensionRoot, { recursive: true, force: true });
     }
   }
 };
@@ -28610,6 +28350,153 @@ function findRecurringPatterns(input) {
   return patterns;
 }
 
+// src/activity/timeline/week-dashboard.ts
+var WEEKLY_DASHBOARD_FORMAT_VERSION = 1;
+var DEFAULT_TOP_SOURCE_LIMIT = 10;
+var DAY_MS2 = 864e5;
+var WEEK_DAYS_MS = 7 * DAY_MS2;
+function clippedInWeek(cards, weekStartMs, weekEndMs) {
+  const clipped = [];
+  for (const card of cards) {
+    const startMs = Date.parse(card.startUtc);
+    const endMs = Date.parse(card.endUtc);
+    if (!Number.isFinite(startMs) || !Number.isFinite(endMs) || endMs <= startMs) continue;
+    const clipStartMs = Math.max(startMs, weekStartMs);
+    const clipEndMs = Math.min(endMs, weekEndMs);
+    if (clipEndMs > clipStartMs) {
+      clipped.push({ card, startMs, endMs, clipStartMs, clipEndMs });
+    }
+  }
+  return clipped;
+}
+function normalizedAttribution(cardId, attributions) {
+  const attribution = attributions?.get(cardId);
+  if (attribution === void 0) return null;
+  if (typeof attribution.app !== "string" || attribution.app.trim() === "") {
+    throw new RangeError(`attribution for card ${cardId} must have a non-blank app`);
+  }
+  const app = attribution.app.trim();
+  if (attribution.domain === void 0) return { app };
+  if (typeof attribution.domain !== "string" || attribution.domain.trim() === "") {
+    throw new RangeError(`attribution for card ${cardId} must have a non-blank domain when present`);
+  }
+  return { app, domain: attribution.domain.trim().toLowerCase() };
+}
+function rankTotals(totals, limit) {
+  return [...totals.entries()].map(([key, durationMs]) => ({ key, durationMs })).sort(
+    (a, b) => b.durationMs - a.durationMs || (a.key < b.key ? -1 : a.key > b.key ? 1 : 0)
+  ).slice(0, limit);
+}
+function buildWeeklyDashboard(cards, options) {
+  const summary = buildWeeklyActivitySummary(cards, options);
+  const topSourceLimit = options.topSourceLimit ?? DEFAULT_TOP_SOURCE_LIMIT;
+  if (!Number.isInteger(topSourceLimit) || topSourceLimit < 1) {
+    throw new RangeError(`topSourceLimit must be an integer >= 1; got ${topSourceLimit}`);
+  }
+  const weekStartMs = Date.parse(summary.weekStartUtc);
+  const weekEndMs = Date.parse(summary.weekEndUtc);
+  const inWeek = clippedInWeek(cards, weekStartMs, weekEndMs);
+  const applicationTotals = /* @__PURE__ */ new Map();
+  const domainTotals = /* @__PURE__ */ new Map();
+  const applicationOccurrences = [];
+  const categoryOccurrences = [];
+  const evidence = {
+    activityCardCount: 0,
+    idleCardCount: 0,
+    pauseCardCount: 0,
+    evidenceCount: 0,
+    distinctEvidenceCount: 0
+  };
+  const uncertainty = {
+    clippedCardCount: 0,
+    manualEditCount: 0,
+    unclassifiedCardCount: 0
+  };
+  const distinctEvidence = /* @__PURE__ */ new Set();
+  const dayWindows = summary.days.map((day) => ({
+    date: day.date,
+    startMs: Date.parse(day.startUtc),
+    endMs: Date.parse(day.endUtc)
+  }));
+  for (const day of summary.days) {
+    for (const total of day.categories) {
+      if (total.durationMs > 0) {
+        categoryOccurrences.push({ date: day.date, key: total.categoryId, durationMs: total.durationMs });
+      }
+    }
+  }
+  for (const { card, startMs, endMs, clipStartMs, clipEndMs } of inWeek) {
+    if (startMs < weekStartMs || endMs > weekEndMs) {
+      uncertainty.clippedCardCount++;
+    }
+    if (card.kind === "idle") {
+      evidence.idleCardCount++;
+      continue;
+    }
+    if (card.kind === "pause") {
+      evidence.pauseCardCount++;
+      continue;
+    }
+    evidence.activityCardCount++;
+    for (const id of card.evidenceIds) {
+      evidence.evidenceCount++;
+      distinctEvidence.add(id);
+    }
+    if (card.manualEdit !== void 0) uncertainty.manualEditCount++;
+    if (card.confidence === 0) uncertainty.unclassifiedCardCount++;
+    const attribution = normalizedAttribution(card.id, options.attributions);
+    if (attribution === null) continue;
+    const durationMs = clipEndMs - clipStartMs;
+    applicationTotals.set(attribution.app, (applicationTotals.get(attribution.app) ?? 0) + durationMs);
+    if (attribution.domain !== void 0) {
+      domainTotals.set(attribution.domain, (domainTotals.get(attribution.domain) ?? 0) + durationMs);
+    }
+    for (const day of dayWindows) {
+      const dayStartMs = Math.max(clipStartMs, day.startMs);
+      const dayEndMs = Math.min(clipEndMs, day.endMs);
+      if (dayEndMs > dayStartMs) {
+        applicationOccurrences.push({ date: day.date, key: attribution.app, durationMs: dayEndMs - dayStartMs });
+      }
+    }
+  }
+  evidence.distinctEvidenceCount = distinctEvidence.size;
+  let previousPeriod = { available: false };
+  if (options.previousWeekCards !== void 0) {
+    const previousSummary = buildWeeklyActivitySummary(options.previousWeekCards, {
+      ...options,
+      weekStartUtc: new Date(weekStartMs - WEEK_DAYS_MS).toISOString(),
+      weekEndUtc: summary.weekStartUtc
+    });
+    previousPeriod = compareWeeklyPreviousPeriod({
+      previous: previousSummary,
+      current: summary,
+      previousStartUtc: previousSummary.weekStartUtc,
+      previousEndUtc: previousSummary.weekEndUtc
+    });
+  }
+  return {
+    ...summary,
+    previousPeriod,
+    dashboardFormatVersion: WEEKLY_DASHBOARD_FORMAT_VERSION,
+    sources: {
+      applications: rankTotals(applicationTotals, topSourceLimit),
+      domains: rankTotals(domainTotals, topSourceLimit)
+    },
+    recurring: {
+      categories: findRecurringPatterns({
+        occurrences: categoryOccurrences,
+        minDays: options.recurrenceMinDays
+      }),
+      applications: findRecurringPatterns({
+        occurrences: applicationOccurrences,
+        minDays: options.recurrenceMinDays
+      })
+    },
+    evidence,
+    uncertainty
+  };
+}
+
 // src/activity/timeline/week-config-hash.ts
 var WEEK_START_DAYS = Object.freeze([
   "monday",
@@ -29867,6 +29754,22 @@ function filterPrivacyWindow(items, options) {
   });
 }
 
+// src/activity/privacy-redact.ts
+function redactActivityFields(item, options) {
+  const result = { ...item };
+  for (const key of options.dropKeys) {
+    delete result[key];
+  }
+  return result;
+}
+
+// src/activity/privacy-keys.ts
+function normalizeDropKeys(keys) {
+  const unique = [...new Set(keys.map((key) => key.trim()).filter((key) => key.length > 0))];
+  unique.sort((a, b) => a.localeCompare(b));
+  return unique;
+}
+
 // src/activity/vault-wikilink.ts
 import path37 from "path";
 function formatVaultWikilink(notePath) {
@@ -30958,8 +30861,6 @@ export {
   generateContextTree,
   onboard,
   curate,
-  findDuplicates,
-  findContradictions,
   decideSemanticDedup,
   syncChanges,
   watchForChanges,
@@ -31025,6 +30926,9 @@ export {
   DEFAULT_RECURRENCE_MIN_DAYS,
   MIN_RECURRENCE_MIN_DAYS,
   findRecurringPatterns,
+  WEEKLY_DASHBOARD_FORMAT_VERSION,
+  DEFAULT_TOP_SOURCE_LIMIT,
+  buildWeeklyDashboard,
   WEEK_START_DAYS,
   computeWeeklyConfigHash,
   batchObservations,
@@ -31066,6 +30970,8 @@ export {
   ACTIVITY_FEATURE_GATES,
   resolveActivityGates,
   filterPrivacyWindow,
+  redactActivityFields,
+  normalizeDropKeys,
   formatVaultWikilink,
   stripVaultMdSuffix,
   joinVaultSegments,
@@ -31104,4 +31010,4 @@ export {
   qmdStartupCollectionChecksWithTimeout,
   Orchestrator
 };
-//# sourceMappingURL=chunk-MSTKJI5T.js.map
+//# sourceMappingURL=chunk-OKOG5MXF.js.map