@remnic/core 9.69.53 → 9.69.54

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

@@ -231,7 +231,7 @@ import {
   runTimelinePublishCli,
   screenCandidateFact,
   summarizeVaultPublish
-} from "./chunk-TS66MUUJ.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,
@@ -666,9 +667,6 @@ import {
 import {
   fallbackLlmRuntimeContextFromConfig
 } from "./chunk-EP6BA7VV.js";
-import {
-  normalizeRecallTokenSet
-} from "./chunk-YCVB7X56.js";
 import {
   graphemeUnits,
   truncateGraphemeSafe
@@ -2413,7 +2411,7 @@ var RecallRerankCoordinator = class _RecallRerankCoordinator {
       namespaces,
       {
         readNamespaceMemories: async (ns) => (await this.getStorage(ns)).readAllMemories(),
-        readMemoryFrontmatter: async (path42, preferredNamespace) => {
+        readMemoryFrontmatter: async (path41, preferredNamespace) => {
           if (!fallbackReader) {
             for (const ns of namespaces) {
               try {
@@ -2425,7 +2423,7 @@ var RecallRerankCoordinator = class _RecallRerankCoordinator {
           }
           if (!fallbackReader) return null;
           const memory = await this.readQmdResultMemory(
-            path42,
+            path41,
             fallbackReader,
             namespaces,
             preferredNamespace
@@ -5605,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
@@ -24324,9 +24235,9 @@ function readStructuralSymbol(entry) {
   const rec = entry;
   const symbol = typeof rec.symbol === "string" ? rec.symbol.trim() : "";
   if (!symbol) return null;
-  const path42 = typeof rec.path === "string" && rec.path.length > 0 ? rec.path : void 0;
+  const path41 = typeof rec.path === "string" && rec.path.length > 0 ? rec.path : void 0;
   const kind = typeof rec.kind === "string" && rec.kind.length > 0 ? rec.kind : void 0;
-  const item = path42 !== void 0 && kind !== void 0 ? { symbol, path: path42, kind } : path42 !== void 0 ? { symbol, path: path42 } : kind !== void 0 ? { symbol, kind } : { symbol };
+  const item = path41 !== void 0 && kind !== void 0 ? { symbol, path: path41, kind } : path41 !== void 0 ? { symbol, path: path41 } : kind !== void 0 ? { symbol, kind } : { symbol };
   return item;
 }
 function classifySpawnError(err) {
@@ -26302,305 +26213,10 @@ function walkFiles(dir, callback) {
   }
 }
 
-// src/dedup/index.ts
-import crypto5 from "crypto";
+// src/sync/index.ts
 import fs4 from "fs";
 import path31 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 = path31.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 = path31.relative(rootReal, targetReal);
-  if (rel === "" || !rel.startsWith("..") && !path31.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 = path31.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 path32 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",
@@ -26621,7 +26237,7 @@ function syncChanges(options) {
   } = options;
   const extSet = new Set(extensions);
   const excludeSet = /* @__PURE__ */ new Set([...DEFAULT_EXCLUDE2, ...excludeDirs]);
-  const stateFilePath = options.stateFile ?? path32.join(memoryDir, ".sync-state.json");
+  const stateFilePath = options.stateFile ?? path31.join(memoryDir, ".sync-state.json");
   const prevState = loadState(stateFilePath);
   const currentFiles = scanFiles(sourceDir, extSet, excludeSet);
   const changes = computeDiff(currentFiles, prevState.fileHashes, sourceDir);
@@ -26637,8 +26253,8 @@ function syncChanges(options) {
     for (const [relPath, hash] of Object.entries(currentFiles)) {
       newState.fileHashes[relPath] = hash;
     }
-    fs5.mkdirSync(path32.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,
@@ -26692,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(
@@ -26703,16 +26319,16 @@ function scanFiles(root, extensions, exclude) {
     }
     for (const entry of entries) {
       if (exclude.has(entry.name)) continue;
-      const fullPath = path32.join(dir, entry.name);
+      const fullPath = path31.join(dir, entry.name);
       if (entry.isDirectory()) {
         walk(fullPath);
       } else if (entry.isFile()) {
-        const ext = path32.extname(entry.name).toLowerCase();
+        const ext = path31.extname(entry.name).toLowerCase();
         if (!extensions.has(ext)) continue;
-        const relPath = path32.relative(root, fullPath);
+        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 {
         }
       }
@@ -26724,11 +26340,11 @@ function scanFiles(root, extensions, exclude) {
 function computeDiff(current, previous, sourceDir) {
   const changes = [];
   for (const [relPath, hash] of Object.entries(current)) {
-    const fullPath = path32.join(sourceDir, relPath);
+    const fullPath = path31.join(sourceDir, relPath);
     if (!(relPath in previous)) {
       let size = 0;
       try {
-        size = fs5.statSync(fullPath).size;
+        size = fs4.statSync(fullPath).size;
       } catch {
       }
       changes.push({
@@ -26741,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({
@@ -26757,7 +26373,7 @@ function computeDiff(current, previous, sourceDir) {
   for (const relPath of Object.keys(previous)) {
     if (!(relPath in current)) {
       changes.push({
-        filePath: path32.join(sourceDir, relPath),
+        filePath: path31.join(sourceDir, relPath),
         relativePath: relPath,
         type: "deleted",
         currentHash: "",
@@ -26769,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 {
@@ -26779,32 +26395,32 @@ 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 path33 from "path";
+import crypto6 from "crypto";
+import fs5 from "fs";
+import path32 from "path";
 var historicalIdCache3 = new HistoricalEntityCanonicalIdCache();
 var MANIFEST_VERSION = 1;
 var MANIFEST_LOCK_STALE_MS = 3e4;
 var MANIFEST_LOCK_TIMEOUT_MS = MANIFEST_LOCK_STALE_MS + 1e4;
 var MANIFEST_LOCK_SLEEP_MS = 20;
 function normalizeSpaceMemoryDir(memoryDir) {
-  return path33.resolve(memoryDir);
+  return path32.resolve(memoryDir);
 }
 function getSpacesDir(baseDir) {
   const homeDir = baseDir ?? resolveHomeDir();
-  return path33.join(homeDir, ".config", "engram", "spaces");
+  return path32.join(homeDir, ".config", "engram", "spaces");
 }
 function getManifestPath(baseDir) {
-  return path33.join(getSpacesDir(baseDir), "manifest.json");
+  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) {
@@ -26830,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";
@@ -26843,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 = path33.dirname(manifestPath2);
-  fs6.mkdirSync(manifestDir2, { recursive: true });
-  const tempPath = path33.join(manifestDir2, `.manifest.${process.pid}.${Date.now()}.${crypto7.randomUUID()}.tmp`);
+  const manifestDir2 = path32.dirname(manifestPath2);
+  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;
@@ -26865,7 +26481,7 @@ function saveManifestUnlocked(manifest, baseDir) {
 }
 function withManifestLock(baseDir, operation) {
   const lockDir = `${getManifestPath(baseDir)}.lock`;
-  fs6.mkdirSync(path33.dirname(lockDir), { recursive: true });
+  fs5.mkdirSync(path32.dirname(lockDir), { recursive: true });
   const lockOwner = acquireManifestLock(lockDir);
   try {
     return operation();
@@ -26878,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}`);
       }
@@ -26889,15 +26505,15 @@ function acquireManifestLock(lockDir) {
       continue;
     }
     try {
-      fs6.mkdirSync(lockDir, { recursive: false });
+      fs5.mkdirSync(lockDir, { recursive: false });
       try {
-        fs6.writeFileSync(path33.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}`);
@@ -26921,9 +26537,9 @@ function acquireManifestLock(lockDir) {
 }
 function releaseManifestLock(lockDir, owner) {
   try {
-    const ownerPath = path33.join(lockDir, "owner");
-    if (fs6.readFileSync(ownerPath, "utf8").trim() === owner) {
-      fs6.rmSync(lockDir, { recursive: true, force: true });
+    const ownerPath = path32.join(lockDir, "owner");
+    if (fs5.readFileSync(ownerPath, "utf8").trim() === owner) {
+      fs5.rmSync(lockDir, { recursive: true, force: true });
     }
   } catch (error) {
     if (error.code !== "ENOENT") {
@@ -26935,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(path33.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) {
@@ -26958,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) {
@@ -26979,7 +26595,7 @@ function createManifestLockOwner() {
   return JSON.stringify({
     pid: process.pid,
     startKey: readProcessStartKey(process.pid),
-    token: crypto7.randomUUID()
+    token: crypto6.randomUUID()
   });
 }
 function removeStaleManifestReclaimLock(reclaimDir) {
@@ -26990,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;
@@ -27012,7 +26628,7 @@ function readManifestLockSnapshot(lockDir) {
     throw error;
   }
   try {
-    const owner = fs6.readFileSync(path33.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") {
@@ -27084,9 +26700,9 @@ function sleepSync(ms) {
 }
 function createPersonalSpace(baseDir, memoryDirOverride) {
   const homeDir = baseDir ?? resolveHomeDir();
-  const standalonePath = path33.join(homeDir, ".engram", "memory");
-  const openclawPath = path33.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 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") ?? (fs5.existsSync(standalonePath) ? standalonePath : fs5.existsSync(openclawPath) ? openclawPath : standalonePath);
   const normalizedMemoryDir = normalizeSpaceMemoryDir(memoryDir);
   const now = (/* @__PURE__ */ new Date()).toISOString();
   return {
@@ -27114,7 +26730,7 @@ function createSpace(options) {
   const id = options.name.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-");
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const memoryDir = normalizeSpaceMemoryDir(
-    options.memoryDir ?? path33.join(getSpacesDir(options.baseDir), id, "memory")
+    options.memoryDir ?? path32.join(getSpacesDir(options.baseDir), id, "memory")
   );
   const space = updateManifest(options.baseDir, (manifest) => {
     if (manifest.spaces.some((s) => s.id === id)) {
@@ -27134,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;
@@ -27292,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({
@@ -27360,39 +26976,39 @@ async function mergeSpaces(sourceSpaceId, targetSpaceId, options) {
   };
 }
 function getAuditLog(baseDir) {
-  const auditPath = path33.join(getSpacesDir(baseDir), "audit.jsonl");
-  if (!fs6.existsSync(auditPath)) return [];
-  const lines = fs6.readFileSync(auditPath, "utf8").trim().split("\n");
+  const auditPath = path32.join(getSpacesDir(baseDir), "audit.jsonl");
+  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 = path33.join(getSpacesDir(baseDir), "audit.jsonl");
-  fs6.mkdirSync(path33.dirname(auditPath), { recursive: true });
+  const auditPath = path32.join(getSpacesDir(baseDir), "audit.jsonl");
+  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) => {
       const rp = safeRealpath(p);
       if (!rp || !isPathInsideRoot(rp, sourceRoot)) return false;
-      const rel = path33.relative(sourceRoot, rp);
-      const mapped = path33.resolve(targetRoot, rel);
+      const rel = path32.relative(sourceRoot, rp);
+      const mapped = path32.resolve(targetRoot, rel);
       if (!isPathInsideRoot(mapped, targetRoot)) return false;
       return classifyEntityRefWritePath(targetRoot, mapped) === "entity";
-    }).map((p) => path33.basename(p, ".md"))
+    }).map((p) => path32.basename(p, ".md"))
   );
   const firstEntityId = sourceEntityIds.values().next().value;
   if (firstEntityId === void 0) {
@@ -27400,7 +27016,7 @@ async function copyMemories(sourceDir, targetDir, options) {
   }
   return withRawEntityPageMutation(
     targetRoot,
-    path33.join(targetRoot, "entities", `${firstEntityId}.md`),
+    path32.join(targetRoot, "entities", `${firstEntityId}.md`),
     async () => copyPreparedMemories(
       sourceFiles,
       sourceRoot,
@@ -27426,19 +27042,19 @@ function copyPreparedMemories(sourceFiles, sourceRoot, targetRoot, sourceEntityI
       skipped++;
       continue;
     }
-    const content = fs6.readFileSync(sourcePath, "utf8");
-    const relativePath = path33.relative(sourceRoot, sourceRealPath);
-    const targetPath = path33.resolve(targetRoot, relativePath);
+    const content = fs5.readFileSync(sourcePath, "utf8");
+    const relativePath = path32.relative(sourceRoot, sourceRealPath);
+    const targetPath = path32.resolve(targetRoot, relativePath);
     if (!isPathInsideRoot(targetPath, targetRoot)) {
       skipped++;
       continue;
     }
     const targetKind = classifyEntityRefWritePath(targetRoot, targetPath);
-    const idsAtCompare = historicalIdCache3.get(path33.join(targetRoot, "state"));
+    const idsAtCompare = historicalIdCache3.get(path32.join(targetRoot, "state"));
     const sourceRef = targetKind === "memory" ? readEntityRefFromFrontmatter(content) : null;
     const refHasSourceClaimant = sourceRef !== null && sourceEntityIds.has(sourceRef);
     const canonicalContent = targetKind === "memory" && !refHasSourceClaimant ? canonicalizeEntityRefFrontmatter(content, idsAtCompare) : content;
-    const sourceHash = hashContent4(content);
+    const sourceHash = hashContent3(content);
     if (options?.filterIds?.length) {
       const fm = parseSimpleFrontmatter(content);
       if (!fm?.id || !options.filterIds.includes(fm.id)) {
@@ -27446,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++;
@@ -27458,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(path33.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,
@@ -27477,23 +27093,23 @@ function copyPreparedMemories(sourceFiles, sourceRoot, targetRoot, sourceEntityI
         continue;
       }
     }
-    fs6.mkdirSync(path33.dirname(targetPath), { recursive: true });
-    const targetParentRealPath = safeRealpath(path33.dirname(targetPath));
+    fs5.mkdirSync(path32.dirname(targetPath), { recursive: true });
+    const targetParentRealPath = safeRealpath(path32.dirname(targetPath));
     if (!targetParentRealPath || !isPathInsideRoot(targetParentRealPath, targetRoot)) {
       skipped++;
       continue;
     }
-    const stateDir = path33.join(targetRoot, "state");
+    const stateDir = path32.join(targetRoot, "state");
     if (targetKind === "memory" && !refHasSourceClaimant) {
       const idsAtWrite = historicalIdCache3.get(stateDir);
       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,
@@ -27501,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;
       }
@@ -27527,18 +27143,18 @@ function copyPreparedMemories(sourceFiles, sourceRoot, targetRoot, sourceEntityI
     bumpMemoryCorpusVersionForDir(targetRoot);
   }
   if (reconcileNeeded) {
-    requestEntityCanonicalIdReconcileSync(path33.join(targetRoot, "state"));
+    requestEntityCanonicalIdReconcileSync(path32.join(targetRoot, "state"));
   }
   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 })) {
-      const fullPath = path33.join(d, entry.name);
+    for (const entry of fs5.readdirSync(d, { withFileTypes: true })) {
+      const fullPath = path32.join(d, entry.name);
       if (entry.isSymbolicLink()) {
         continue;
       }
@@ -27554,21 +27170,21 @@ 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;
   }
 }
 function isPathInsideRoot(candidatePath, rootPath) {
-  const relative = path33.relative(rootPath, candidatePath);
-  return relative === "" || !relative.startsWith("..") && !path33.isAbsolute(relative);
+  const relative = path32.relative(rootPath, candidatePath);
+  return relative === "" || !relative.startsWith("..") && !path32.isAbsolute(relative);
 }
 function parseSimpleFrontmatter(content) {
   const match = content.match(/^---\n([\s\S]*?)\n---/);
@@ -27687,9 +27303,9 @@ 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 path34 from "path";
+import path33 from "path";
 var REMNIC_EXTENSION_DIR_NAME = "remnic";
 function resolveEnvHome(env) {
   if (env === void 0) return resolveHomeDir();
@@ -27698,12 +27314,12 @@ function resolveEnvHome(env) {
 function expandTildeWithHome(input, homeDir) {
   if (input === "~") return homeDir;
   if (input.startsWith("~/") || input.startsWith("~\\")) {
-    return path34.join(homeDir, input.slice(2));
+    return path33.join(homeDir, input.slice(2));
   }
   return input;
 }
 function normalizeHostRoot(input, homeDir) {
-  return path34.resolve(expandTildeWithHome(input.trim(), homeDir));
+  return path33.resolve(expandTildeWithHome(input.trim(), homeDir));
 }
 var CodexMemoryExtensionPublisher = class {
   hostId = "codex";
@@ -27717,13 +27333,13 @@ var CodexMemoryExtensionPublisher = class {
   async resolveExtensionRoot(env) {
     const homeDir = resolveEnvHome(env);
     const codexHomeInput = env === void 0 ? readEnvVar("CODEX_HOME")?.trim() : env.CODEX_HOME?.trim();
-    const codexHome = codexHomeInput ? normalizeHostRoot(codexHomeInput, homeDir) : path34.resolve(homeDir, ".codex");
-    return path34.join(codexHome, "memories_extensions", REMNIC_EXTENSION_DIR_NAME);
+    const codexHome = codexHomeInput ? normalizeHostRoot(codexHomeInput, homeDir) : path33.resolve(homeDir, ".codex");
+    return path33.join(codexHome, "memories_extensions", REMNIC_EXTENSION_DIR_NAME);
   }
   async isHostAvailable() {
     try {
-      const home = readEnvVar("CODEX_HOME")?.trim() || path34.join(resolveHomeDir(), ".codex");
-      return fs7.existsSync(home);
+      const home = readEnvVar("CODEX_HOME")?.trim() || path33.join(resolveHomeDir(), ".codex");
+      return fs6.existsSync(home);
     } catch {
       return false;
     }
@@ -27773,22 +27389,22 @@ When running inside the Codex phase-2 consolidation sandbox:
   }
   async publish(ctx) {
     const extensionRoot = await this.resolveExtensionRoot();
-    const instructionsPath = path34.join(extensionRoot, "instructions.md");
+    const instructionsPath = path33.join(extensionRoot, "instructions.md");
     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 {
       }
@@ -27803,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 });
     }
   }
 };
@@ -28405,9 +28021,9 @@ function buildWeeklyActivitySummary(cards, options) {
 // src/activity/timeline/weekly-persist.ts
 import { randomBytes as randomBytes3 } from "crypto";
 import { mkdirSync, readFileSync as readFileSync2, renameSync, unlinkSync, writeFileSync } from "fs";
-import path35 from "path";
+import path34 from "path";
 var WEEKLY_SNAPSHOT_FORMAT_VERSION = 1;
-var WEEKLY_SNAPSHOT_DIR = path35.join("activity", "weekly");
+var WEEKLY_SNAPSHOT_DIR = path34.join("activity", "weekly");
 function requireToken(value, name) {
   if (typeof value !== "string" || value.trim().length === 0) {
     throw new TypeError(`${name} must be a non-empty string`);
@@ -28430,8 +28046,8 @@ function weeklySnapshotPath(input) {
   const identity = hashActivityBody(
     `${input.summary.weekStartUtc}\0${input.summary.weekEndUtc}\0${sourceRevision}\0${configHash}`
   );
-  return path35.join(
-    path35.resolve(memoryDir),
+  return path34.join(
+    path34.resolve(memoryDir),
     WEEKLY_SNAPSHOT_DIR,
     namespaceIdentityToken(namespace),
     `${weekDate}--${identity}.json`
@@ -28461,7 +28077,7 @@ function persistWeeklySnapshot(input) {
       throw error;
     }
   }
-  mkdirSync(path35.dirname(filePath), { recursive: true, mode: 448 });
+  mkdirSync(path34.dirname(filePath), { recursive: true, mode: 448 });
   const tmpPath = `${filePath}.${process.pid}.${randomBytes3(8).toString("hex")}.tmp`;
   writeFileSync(tmpPath, text, { encoding: "utf8", mode: 384 });
   try {
@@ -28734,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",
@@ -28966,7 +28729,7 @@ function selectRecapForDay(input) {
 
 // src/activity/journal-read.ts
 import { closeSync, constants as fsConstants, fstatSync, lstatSync, openSync, readFileSync as readFileSync3, realpathSync, statSync as statSync2 } from "fs";
-import path36 from "path";
+import path35 from "path";
 
 // src/activity/journal-section.ts
 function parseAtxHeading(line) {
@@ -29157,8 +28920,8 @@ function readJournalForDate(input) {
   const relative = resolveVaultNotePath(input.vault.dailyNotePath, input.date, {
     timezone: input.timezone
   });
-  const root = path36.resolve(expandTildePath(input.vault.vaultPath));
-  const filePath = path36.join(root, relative);
+  const root = path35.resolve(expandTildePath(input.vault.vaultPath));
+  const filePath = path35.join(root, relative);
   try {
     const rootStat = lstatSync(root);
     if (rootStat.isSymbolicLink() || !rootStat.isDirectory()) {
@@ -29167,8 +28930,8 @@ function readJournalForDate(input) {
   } catch {
     return { ok: true, exists: false, reason: "missing_file", filePath };
   }
-  const lexical = path36.relative(root, filePath);
-  if (lexical.length === 0 || lexical === ".." || lexical.startsWith(`..${path36.sep}`) || path36.isAbsolute(lexical)) {
+  const lexical = path35.relative(root, filePath);
+  if (lexical.length === 0 || lexical === ".." || lexical.startsWith(`..${path35.sep}`) || path35.isAbsolute(lexical)) {
     return { ok: false, reason: "path_escape", filePath };
   }
   if (!containedBySymlinks(root, filePath)) {
@@ -29201,11 +28964,11 @@ function containedBySymlinks(root, dest) {
     try {
       if (statSync2(probe).isFile() || statSync2(probe).isDirectory()) {
         const real = realpathSync(probe);
-        return real === realRoot || real.startsWith(`${realRoot}${path36.sep}`);
+        return real === realRoot || real.startsWith(`${realRoot}${path35.sep}`);
       }
     } catch {
     }
-    const parent = path36.dirname(probe);
+    const parent = path35.dirname(probe);
     if (parent === probe) return false;
     probe = parent;
   }
@@ -29216,15 +28979,15 @@ function symlinkRejected() {
   return err;
 }
 function readVerifiedDailyNote(root, filePath) {
-  const relative = path36.relative(root, filePath);
-  const parts = relative.split(path36.sep).filter((part) => part.length > 0 && part !== ".");
+  const relative = path35.relative(root, filePath);
+  const parts = relative.split(path35.sep).filter((part) => part.length > 0 && part !== ".");
   let cursor = root;
   for (const part of parts) {
-    cursor = path36.join(cursor, part);
+    cursor = path35.join(cursor, part);
     const st = lstatSync(cursor);
     if (st.isSymbolicLink()) throw symlinkRejected();
   }
-  const parent = path36.dirname(filePath);
+  const parent = path35.dirname(filePath);
   const parentLstat = lstatSync(parent);
   if (parentLstat.isSymbolicLink() || !parentLstat.isDirectory()) throw symlinkRejected();
   const nofollow = fsConstants.O_NOFOLLOW ?? 0;
@@ -29248,7 +29011,7 @@ function readVerifiedDailyNote(root, filePath) {
     try {
       const fdPath = realpathSync(`/proc/self/fd/${fd}`);
       const realRoot = realpathSync(root);
-      if (fdPath !== realRoot && !fdPath.startsWith(`${realRoot}${path36.sep}`)) {
+      if (fdPath !== realRoot && !fdPath.startsWith(`${realRoot}${path35.sep}`)) {
         throw symlinkRejected();
       }
     } catch (err) {
@@ -29263,11 +29026,11 @@ function readVerifiedDailyNote(root, filePath) {
 // src/activity/journal-state.ts
 import { createHash as createHash10, randomBytes as randomBytes4 } from "crypto";
 import { mkdirSync as mkdirSync2, readFileSync as readFileSync4, renameSync as renameSync2, writeFileSync as writeFileSync2 } from "fs";
-import path37 from "path";
+import path36 from "path";
 var STATE_DIR_NAME = "state";
 var STATE_FILE_NAME = "timeline.json";
 function timelineStatePath(memoryDir) {
-  return path37.join(memoryDir, STATE_DIR_NAME, STATE_FILE_NAME);
+  return path36.join(memoryDir, STATE_DIR_NAME, STATE_FILE_NAME);
 }
 function hashJournalText(text) {
   return createHash10("sha256").update(text, "utf8").digest("hex");
@@ -29293,14 +29056,14 @@ function readTimelineState(memoryDir) {
 }
 function writeTimelineState(memoryDir, state) {
   const filePath = timelineStatePath(memoryDir);
-  mkdirSync2(path37.dirname(filePath), { recursive: true });
+  mkdirSync2(path36.dirname(filePath), { recursive: true });
   const tempPath = `${filePath}.${process.pid}.${randomBytes4(8).toString("hex")}.tmp`;
   writeFileSync2(tempPath, `${JSON.stringify(state, null, 2)}
 `);
   renameSync2(tempPath, filePath);
 }
 function journalDateLockPath(memoryDir, date) {
-  return path37.join(memoryDir, STATE_DIR_NAME, `journal-extract-${date}.lock`);
+  return path36.join(memoryDir, STATE_DIR_NAME, `journal-extract-${date}.lock`);
 }
 function timelineStateLockPath(memoryDir) {
   return `${timelineStatePath(memoryDir)}.lock`;
@@ -29991,8 +29754,24 @@ 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 path38 from "path";
+import path37 from "path";
 function formatVaultWikilink(notePath) {
   if (typeof notePath !== "string" || notePath.trim().length === 0) {
     throw new RangeError("Vault wikilink path must be a non-empty relative path.");
@@ -30000,7 +29779,7 @@ function formatVaultWikilink(notePath) {
   if (notePath.includes("\n") || notePath.includes("\r")) {
     throw new RangeError("Vault wikilink path must not contain newlines.");
   }
-  if (path38.posix.isAbsolute(notePath) || path38.win32.isAbsolute(notePath)) {
+  if (path37.posix.isAbsolute(notePath) || path37.win32.isAbsolute(notePath)) {
     throw new RangeError("Vault wikilink path must be relative; absolute paths are rejected.");
   }
   if (notePath.split(/[\\/]/).some((segment) => segment === "..")) {
@@ -30022,7 +29801,7 @@ function stripVaultMdSuffix(notePath) {
 }
 
 // src/activity/vault-join.ts
-import path39 from "path";
+import path38 from "path";
 function joinVaultSegments(parts) {
   if (parts.length === 0) {
     throw new RangeError("Vault path parts must be a non-empty list.");
@@ -30037,7 +29816,7 @@ function joinVaultSegments(parts) {
     if (part.includes("\n") || part.includes("\r")) {
       throw new RangeError("Vault path part must not contain a newline.");
     }
-    if (path39.posix.isAbsolute(part) || path39.win32.isAbsolute(part)) {
+    if (path38.posix.isAbsolute(part) || path38.win32.isAbsolute(part)) {
       throw new RangeError("Vault path part must be relative.");
     }
     if (part.split("/").includes("..")) {
@@ -30092,7 +29871,7 @@ function planVaultDryRun(inputs) {
 // src/session-summaries/index.ts
 import { createHash as createHash11 } from "crypto";
 import { lstat as lstat3, mkdir as mkdir7, readFile as readFile9, readdir as readdir4, rename, rm, stat as stat4, writeFile as writeFile7 } from "fs/promises";
-import path40 from "path";
+import path39 from "path";
 
 // src/session-summaries/adapters.ts
 var VALID_ROLES = /* @__PURE__ */ new Set(["user", "assistant", "tool", "system", "other"]);
@@ -30597,7 +30376,7 @@ function shortHash(value, length = 16) {
 async function listTranscriptFiles(root, maxFiles) {
   const out = [];
   let truncated = false;
-  const entrySortKey = (entryName, isDirectory) => isDirectory ? `${entryName}${path40.sep}` : entryName;
+  const entrySortKey = (entryName, isDirectory) => isDirectory ? `${entryName}${path39.sep}` : entryName;
   async function visit(dir) {
     if (truncated) return;
     const entries = (await readdir4(dir, { withFileTypes: true })).sort(
@@ -30607,13 +30386,13 @@ async function listTranscriptFiles(root, maxFiles) {
       if (truncated) return;
       if (entry.name.startsWith(".")) continue;
       if (entry.isSymbolicLink()) continue;
-      const fullPath = path40.join(dir, entry.name);
+      const fullPath = path39.join(dir, entry.name);
       if (entry.isDirectory()) {
         await visit(fullPath);
         continue;
       }
       if (!entry.isFile()) continue;
-      const ext = path40.extname(entry.name).toLowerCase();
+      const ext = path39.extname(entry.name).toLowerCase();
       if (!SUPPORTED_EXTENSIONS.has(ext)) continue;
       out.push(fullPath);
       if (out.length > maxFiles) {
@@ -30640,7 +30419,7 @@ function normalizeInputDir(inputDir) {
   if (typeof inputDir !== "string" || inputDir.trim().length === 0) {
     throw new Error("inputDir must be a non-empty string");
   }
-  return path40.resolve(expandTildePath(inputDir.trim()));
+  return path39.resolve(expandTildePath(inputDir.trim()));
 }
 function initRoleCounts() {
   return {
@@ -30797,11 +30576,11 @@ async function collectLocalSessionSummaries(options) {
       continue;
     }
     seenFileHashes.add(fileHash);
-    const fileExtension = path40.extname(filePath).toLowerCase();
+    const fileExtension = path39.extname(filePath).toLowerCase();
     const parsed = await adapter.parseFile(
       {
         content,
-        fileName: path40.basename(filePath),
+        fileName: path39.basename(filePath),
         fileExtension,
         fileRef: fileHash
       },
@@ -30857,7 +30636,7 @@ async function collectLocalSessionSummaries(options) {
 }
 async function readRedactionConfig(pathLike) {
   if (!pathLike) return void 0;
-  const raw = await readFile9(path40.resolve(expandTildePath(pathLike)), "utf-8");
+  const raw = await readFile9(path39.resolve(expandTildePath(pathLike)), "utf-8");
   const parsed = JSON.parse(raw);
   if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
     throw new Error("redaction config must be a JSON object");
@@ -30870,15 +30649,15 @@ function toJsonl(drafts) {
 }
 function defaultDraftOutputPath(memoryDir, generatedAt) {
   const stamp = generatedAt.replace(/[:.]/g, "-");
-  return path40.join(
-    path40.resolve(expandTildePath(memoryDir)),
+  return path39.join(
+    path39.resolve(expandTildePath(memoryDir)),
     "state",
     "session-summary-drafts",
     `session-summaries-${stamp}.jsonl`
   );
 }
 async function writeDrafts(filePath, drafts) {
-  await mkdir7(path40.dirname(filePath), { recursive: true });
+  await mkdir7(path39.dirname(filePath), { recursive: true });
   const tempPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
   try {
     await writeFile7(tempPath, toJsonl(drafts), "utf-8");
@@ -30896,7 +30675,7 @@ async function runLocalSessionSummaryCliCommand(options) {
   });
   const wroteFiles = [];
   if (options.output) {
-    const outputPath = path40.resolve(expandTildePath(options.output));
+    const outputPath = path39.resolve(expandTildePath(options.output));
     await writeDrafts(outputPath, report.drafts);
     wroteFiles.push(outputPath);
   }
@@ -30931,19 +30710,19 @@ async function runLocalSessionSummaryCliCommand(options) {
 
 // src/transfer/capsule-fork.ts
 import { lstat as lstat4, mkdir as mkdir8, readFile as readFile10, realpath as realpath3, writeFile as writeFile8 } from "fs/promises";
-import path41 from "path";
+import path40 from "path";
 async function forkCapsule(opts) {
   validateForkId(opts.forkId);
-  const rootAbs = path41.resolve(opts.targetRoot);
+  const rootAbs = path40.resolve(opts.targetRoot);
   await assertIsDirectoryNotSymlink(rootAbs, "forkCapsule", "targetRoot");
-  const forkDirAbs = path41.join(rootAbs, "forks", opts.forkId);
+  const forkDirAbs = path40.join(rootAbs, "forks", opts.forkId);
   const forkEntryExists = await pathEntryExists(forkDirAbs);
   if (forkEntryExists) {
     throw new Error(
       `forkCapsule: fork path already exists \u2014 forkId "${opts.forkId}" is already in use at: ${forkDirAbs}`
     );
   }
-  const archiveAbs = path41.resolve(opts.sourceArchive);
+  const archiveAbs = path40.resolve(opts.sourceArchive);
   const importResult = await importCapsule({
     archivePath: archiveAbs,
     root: rootAbs,
@@ -30965,10 +30744,10 @@ async function forkCapsule(opts) {
     importedRecords: importResult.imported.length,
     skippedRecords: importResult.skipped.length
   };
-  const lineagePath = path41.join(forkDirAbs, "lineage.json");
+  const lineagePath = path40.join(forkDirAbs, "lineage.json");
   const rootReal = await realpath3(rootAbs);
   await assertRealpathInsideRoot(rootReal, lineagePath, `forks/${opts.forkId}/lineage.json`, "forkCapsule");
-  await mkdir8(path41.dirname(lineagePath), { recursive: true });
+  await mkdir8(path40.dirname(lineagePath), { recursive: true });
   await writeFile8(lineagePath, JSON.stringify(lineage, null, 2) + "\n", "utf-8");
   return {
     archivePath: archiveAbs,
@@ -30982,11 +30761,11 @@ async function readForkLineage(targetRoot, forkId) {
   if (typeof forkId !== "string" || forkId.length === 0 || forkId.length > 64 || !CAPSULE_ID_PATTERN.test(forkId)) {
     return null;
   }
-  const rootAbs = path41.resolve(targetRoot);
+  const rootAbs = path40.resolve(targetRoot);
   const rootReal = await realpath3(rootAbs).catch(() => rootAbs);
-  const lineagePath = path41.join(rootReal, "forks", forkId, "lineage.json");
-  const rel = path41.relative(rootReal, lineagePath);
-  if (rel.startsWith("..") || path41.isAbsolute(rel)) {
+  const lineagePath = path40.join(rootReal, "forks", forkId, "lineage.json");
+  const rel = path40.relative(rootReal, lineagePath);
+  if (rel.startsWith("..") || path40.isAbsolute(rel)) {
     return null;
   }
   if (!await isLineagePathContained(rootReal, lineagePath)) {
@@ -31027,19 +30806,19 @@ async function pathEntryExists(absPath) {
 async function isLineagePathContained(rootReal, lineagePath) {
   let existing = lineagePath;
   const suffix = [];
-  while (existing !== path41.dirname(existing)) {
+  while (existing !== path40.dirname(existing)) {
     const st = await lstat4(existing).catch(() => null);
     if (st !== null) break;
-    suffix.unshift(path41.basename(existing));
-    existing = path41.dirname(existing);
+    suffix.unshift(path40.basename(existing));
+    existing = path40.dirname(existing);
   }
   const existingReal = await realpath3(existing).catch(() => existing);
-  const targetReal = suffix.length > 0 ? path41.join(existingReal, ...suffix) : existingReal;
-  const rel = path41.relative(rootReal, targetReal);
+  const targetReal = suffix.length > 0 ? path40.join(existingReal, ...suffix) : existingReal;
+  const rel = path40.relative(rootReal, targetReal);
   if (rel === "") return true;
   if (rel === "..") return false;
-  if (rel.startsWith(`..${path41.sep}`)) return false;
-  if (path41.isAbsolute(rel)) return false;
+  if (rel.startsWith(`..${path40.sep}`)) return false;
+  if (path40.isAbsolute(rel)) return false;
   return true;
 }
 
@@ -31082,8 +30861,6 @@ export {
   generateContextTree,
   onboard,
   curate,
-  findDuplicates,
-  findContradictions,
   decideSemanticDedup,
   syncChanges,
   watchForChanges,
@@ -31149,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,
@@ -31190,6 +30970,8 @@ export {
   ACTIVITY_FEATURE_GATES,
   resolveActivityGates,
   filterPrivacyWindow,
+  redactActivityFields,
+  normalizeDropKeys,
   formatVaultWikilink,
   stripVaultMdSuffix,
   joinVaultSegments,
@@ -31228,4 +31010,4 @@ export {
   qmdStartupCollectionChecksWithTimeout,
   Orchestrator
 };
-//# sourceMappingURL=chunk-K7FXR75S.js.map
+//# sourceMappingURL=chunk-OKOG5MXF.js.map