@yugenlab/vaayu 0.1.1 → 0.1.3

package/chunks/{chunk-IIET2K6D.js → chunk-YSC77CKZ.js}

@@ -1,26 +1,30 @@
+import {
+  getDayFilePath,
+  listDayFiles
+} from "./chunk-7UOXFHEB.js";
 import {
   PRESERVATION_RATIOS,
   RecallEngine,
   STREAM_ORDER,
   StreamManager
-} from "./chunk-JZU37VQ5.js";
-import {
-  cosineSimilarity,
-  estimateTokens
-} from "./chunk-JAWZ7ANC.js";
+} from "./chunk-LVE2EOOH.js";
 import {
   createSession,
   listSessions,
   loadSession,
   saveSession
-} from "./chunk-L7JICQBW.js";
+} from "./chunk-NHRBVSN3.js";
+import {
+  cosineSimilarity,
+  estimateTokens
+} from "./chunk-JAWZ7ANC.js";
 import {
   DatabaseManager
-} from "./chunk-U6OLJ36B.js";
+} from "./chunk-U62ABYKD.js";
 import {
   SessionError,
   getChitraguptaHome
-} from "./chunk-KC6NRZ7U.js";
+} from "./chunk-UZ6OIVEC.js";
 
 // ../chitragupta/packages/smriti/src/session-export.ts
 function exportSessionToJson(session) {
@@ -224,6 +228,339 @@ function validateExportedSession(data) {
   }
 }
 
+// ../chitragupta/packages/smriti/src/cross-machine-sync.ts
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import crypto from "node:crypto";
+var SNAPSHOT_VERSION = 1;
+var ENTRY_SEPARATOR = "\n---\n\n";
+function sha256(content) {
+  return crypto.createHash("sha256").update(content, "utf-8").digest("hex");
+}
+function toPortablePath(absPath, home) {
+  const rel = path.relative(home, absPath);
+  if (!rel || rel.startsWith("..") || path.isAbsolute(rel)) {
+    throw new SessionError(`Path escapes Chitragupta home: ${absPath}`);
+  }
+  return rel.split(path.sep).join("/");
+}
+function resolveSnapshotPath(relPath, home) {
+  const normalizedRel = relPath.replaceAll("\\", "/");
+  const abs = path.resolve(home, normalizedRel);
+  const homeWithSep = home.endsWith(path.sep) ? home : `${home}${path.sep}`;
+  if (abs !== home && !abs.startsWith(homeWithSep)) {
+    throw new SessionError(`Snapshot path escapes Chitragupta home: ${relPath}`);
+  }
+  return abs;
+}
+function listMemoryFiles(memoryRoot) {
+  if (!fs.existsSync(memoryRoot)) return [];
+  const stack = [memoryRoot];
+  const files = [];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    let entries = [];
+    try {
+      entries = fs.readdirSync(current, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const full = path.join(current, entry.name);
+      if (entry.isDirectory()) {
+        stack.push(full);
+        continue;
+      }
+      if (entry.isFile() && entry.name.endsWith(".md")) {
+        files.push(full);
+      }
+    }
+  }
+  return files.sort();
+}
+function readSyncState(home) {
+  const statePath = path.join(home, "sync-state.json");
+  try {
+    if (!fs.existsSync(statePath)) return {};
+    const raw = fs.readFileSync(statePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function writeSyncState(home, patch) {
+  const statePath = path.join(home, "sync-state.json");
+  const next = { ...readSyncState(home), ...patch };
+  fs.mkdirSync(path.dirname(statePath), { recursive: true });
+  fs.writeFileSync(statePath, JSON.stringify(next, null, "	"), "utf-8");
+}
+function splitMemory(content) {
+  const normalized = content.replaceAll("\r\n", "\n");
+  const parts = normalized.split(ENTRY_SEPARATOR);
+  if (parts.length <= 1) {
+    return { header: normalized.trimEnd(), entries: [] };
+  }
+  const header = (parts[0] ?? "").trimEnd();
+  const entries = parts.slice(1).map((entry) => entry.trim()).filter(Boolean);
+  return { header, entries };
+}
+function mergeMemory(localContent, remoteContent) {
+  const localTrimmed = localContent.trim();
+  const remoteTrimmed = remoteContent.trim();
+  if (!localTrimmed) return remoteTrimmed ? `${remoteTrimmed}
+` : "";
+  if (!remoteTrimmed) return localContent.endsWith("\n") ? localContent : `${localContent}
+`;
+  if (localContent === remoteContent) return localContent;
+  const local = splitMemory(localContent);
+  const remote = splitMemory(remoteContent);
+  if (local.entries.length === 0 && remote.entries.length === 0) {
+    if (localContent.includes(remoteContent)) return localContent;
+    if (remoteContent.includes(localContent)) return remoteContent;
+    return `${localContent.trimEnd()}
+
+---
+
+${remoteContent.trim()}
+`;
+  }
+  const header = local.header || remote.header || "# Memory";
+  const seen = /* @__PURE__ */ new Set();
+  const mergedEntries = [];
+  for (const entry of [...local.entries, ...remote.entries]) {
+    const key = sha256(entry.replace(/\s+/g, " ").trim().toLowerCase());
+    if (seen.has(key)) continue;
+    seen.add(key);
+    mergedEntries.push(entry.trim());
+  }
+  let merged = header.trimEnd();
+  if (mergedEntries.length > 0) {
+    merged += ENTRY_SEPARATOR + mergedEntries.join(ENTRY_SEPARATOR);
+  }
+  if (!merged.endsWith("\n")) merged += "\n";
+  return merged;
+}
+function assertSnapshot(value) {
+  if (!value || typeof value !== "object") {
+    throw new SessionError("Invalid sync snapshot: expected object");
+  }
+  const snapshot = value;
+  if (snapshot.version !== SNAPSHOT_VERSION) {
+    throw new SessionError(`Unsupported sync snapshot version: ${String(snapshot.version)}`);
+  }
+  if (typeof snapshot.exportedAt !== "string") {
+    throw new SessionError("Invalid sync snapshot: missing exportedAt");
+  }
+  if (!Array.isArray(snapshot.files)) {
+    throw new SessionError("Invalid sync snapshot: missing files array");
+  }
+  for (const file of snapshot.files) {
+    if (!file || typeof file !== "object") {
+      throw new SessionError("Invalid sync snapshot: file entry must be object");
+    }
+    const entry = file;
+    if (typeof entry.path !== "string" || !entry.path) {
+      throw new SessionError("Invalid sync snapshot: file.path must be non-empty string");
+    }
+    if (entry.kind !== "day" && entry.kind !== "memory") {
+      throw new SessionError(`Invalid sync snapshot: unsupported kind for ${String(entry.path)}`);
+    }
+    if (typeof entry.content !== "string" || typeof entry.sha256 !== "string") {
+      throw new SessionError(`Invalid sync snapshot: content/hash missing for ${entry.path}`);
+    }
+  }
+}
+function createCrossMachineSnapshot(options) {
+  const includeDays = options?.includeDays ?? true;
+  const includeMemory = options?.includeMemory ?? true;
+  if (!includeDays && !includeMemory) {
+    throw new SessionError("Snapshot must include at least one category: days or memory");
+  }
+  const home = getChitraguptaHome();
+  const files = [];
+  if (includeDays) {
+    let dates = listDayFiles();
+    if (typeof options?.maxDays === "number" && Number.isFinite(options.maxDays)) {
+      dates = dates.slice(0, Math.max(0, Math.floor(options.maxDays)));
+    }
+    for (const date of dates) {
+      const absPath = getDayFilePath(date);
+      if (!fs.existsSync(absPath)) continue;
+      try {
+        const content = fs.readFileSync(absPath, "utf-8");
+        const stat = fs.statSync(absPath);
+        files.push({
+          path: toPortablePath(absPath, home),
+          kind: "day",
+          content,
+          sha256: sha256(content),
+          bytes: Buffer.byteLength(content, "utf-8"),
+          mtimeMs: stat.mtimeMs
+        });
+      } catch {
+      }
+    }
+  }
+  if (includeMemory) {
+    const memoryRoot = path.join(home, "memory");
+    for (const absPath of listMemoryFiles(memoryRoot)) {
+      try {
+        const content = fs.readFileSync(absPath, "utf-8");
+        const stat = fs.statSync(absPath);
+        files.push({
+          path: toPortablePath(absPath, home),
+          kind: "memory",
+          content,
+          sha256: sha256(content),
+          bytes: Buffer.byteLength(content, "utf-8"),
+          mtimeMs: stat.mtimeMs
+        });
+      } catch {
+      }
+    }
+  }
+  return {
+    version: SNAPSHOT_VERSION,
+    exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    source: {
+      machine: os.hostname(),
+      platform: `${process.platform}-${process.arch}`,
+      home
+    },
+    files
+  };
+}
+function writeCrossMachineSnapshot(snapshot, outputPath) {
+  assertSnapshot(snapshot);
+  const resolved = path.resolve(outputPath);
+  fs.mkdirSync(path.dirname(resolved), { recursive: true });
+  fs.writeFileSync(resolved, JSON.stringify(snapshot, null, "	"), "utf-8");
+  writeSyncState(getChitraguptaHome(), {
+    lastExportAt: snapshot.exportedAt,
+    lastExportPath: resolved
+  });
+  return resolved;
+}
+function readCrossMachineSnapshot(snapshotPath) {
+  const resolved = path.resolve(snapshotPath);
+  const raw = fs.readFileSync(resolved, "utf-8");
+  const parsed = JSON.parse(raw);
+  assertSnapshot(parsed);
+  return parsed;
+}
+function getCrossMachineSyncStatus() {
+  const home = getChitraguptaHome();
+  const state = readSyncState(home);
+  const daysCount = listDayFiles().length;
+  const memoryCount = listMemoryFiles(path.join(home, "memory")).length;
+  return {
+    home,
+    daysCount,
+    memoryCount,
+    ...state
+  };
+}
+function writeTextFile(filePath, content) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, content, "utf-8");
+}
+function createConflictPath(conflictRoot, relPath) {
+  const ext = path.extname(relPath);
+  const base = ext ? relPath.slice(0, -ext.length) : relPath;
+  const remoteName = `${base}.remote${ext || ".md"}`;
+  return path.join(conflictRoot, remoteName);
+}
+function importCrossMachineSnapshot(source, options) {
+  const snapshot = typeof source === "string" ? readCrossMachineSnapshot(source) : source;
+  assertSnapshot(snapshot);
+  const home = getChitraguptaHome();
+  const strategy = options?.strategy ?? "safe";
+  const dryRun = options?.dryRun ?? false;
+  const importedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const conflictRoot = path.join(home, "sync-conflicts", importedAt.replace(/[:.]/g, "-"));
+  const totals = {
+    files: snapshot.files.length,
+    created: 0,
+    updated: 0,
+    merged: 0,
+    skipped: 0,
+    conflicts: 0,
+    errors: 0
+  };
+  const changedPaths = [];
+  const conflictPaths = [];
+  const errorPaths = [];
+  for (const file of snapshot.files) {
+    try {
+      const contentHash = sha256(file.content);
+      if (contentHash !== file.sha256) {
+        totals.errors += 1;
+        errorPaths.push(file.path);
+        continue;
+      }
+      const targetPath = resolveSnapshotPath(file.path, home);
+      if (!fs.existsSync(targetPath)) {
+        if (!dryRun) writeTextFile(targetPath, file.content);
+        totals.created += 1;
+        changedPaths.push(file.path);
+        continue;
+      }
+      const localContent = fs.readFileSync(targetPath, "utf-8");
+      if (localContent === file.content || sha256(localContent) === file.sha256) {
+        totals.skipped += 1;
+        continue;
+      }
+      if (file.kind === "memory") {
+        const merged = mergeMemory(localContent, file.content);
+        if (merged === localContent) {
+          totals.skipped += 1;
+          continue;
+        }
+        if (!dryRun) writeTextFile(targetPath, merged);
+        totals.merged += 1;
+        changedPaths.push(file.path);
+        continue;
+      }
+      if (strategy === "preferRemote") {
+        if (!dryRun) writeTextFile(targetPath, file.content);
+        totals.updated += 1;
+        changedPaths.push(file.path);
+        continue;
+      }
+      if (strategy === "preferLocal") {
+        totals.skipped += 1;
+        continue;
+      }
+      const conflictPath = createConflictPath(conflictRoot, file.path);
+      if (!dryRun) writeTextFile(conflictPath, file.content);
+      totals.conflicts += 1;
+      conflictPaths.push(toPortablePath(conflictPath, home));
+    } catch {
+      totals.errors += 1;
+      errorPaths.push(file.path);
+    }
+  }
+  if (!dryRun) {
+    writeSyncState(home, {
+      lastImportAt: importedAt,
+      lastImportSource: snapshot.source.machine,
+      lastImportTotals: totals
+    });
+  }
+  return {
+    importedAt,
+    sourceExportedAt: snapshot.exportedAt,
+    strategy,
+    dryRun,
+    totals,
+    changedPaths,
+    conflictPaths,
+    errorPaths
+  };
+}
+
 // ../chitragupta/packages/smriti/src/branch.ts
 function branchSession(sessionId, project, branchName, fromTurn) {
   const original = loadSession(sessionId, project);
@@ -738,13 +1075,13 @@ function writeDeltaMarkdown(delta) {
 }
 
 // ../chitragupta/packages/smriti/src/compactor.ts
-import fs from "fs";
-import path from "path";
+import fs2 from "fs";
+import path2 from "path";
 function getCompactionDir() {
-  return path.join(getChitraguptaHome(), "smriti", "compaction");
+  return path2.join(getChitraguptaHome(), "smriti", "compaction");
 }
 function getDeltaDir() {
-  return path.join(getChitraguptaHome(), "smriti", "deltas");
+  return path2.join(getChitraguptaHome(), "smriti", "deltas");
 }
 function updateIdentityStream(streamManager, signals) {
   if (signals.identity.length === 0) return;
@@ -926,17 +1263,17 @@ var SessionCompactor = class {
   saveDelta(delta) {
     try {
       const dir = getDeltaDir();
-      fs.mkdirSync(dir, { recursive: true });
-      const filePath = path.join(dir, `${delta.sessionId}.md`);
+      fs2.mkdirSync(dir, { recursive: true });
+      const filePath = path2.join(dir, `${delta.sessionId}.md`);
       const markdown = writeDeltaMarkdown(delta);
-      fs.writeFileSync(filePath, markdown, "utf-8");
+      fs2.writeFileSync(filePath, markdown, "utf-8");
     } catch {
     }
   }
   saveMixingMatrix(sessionId, mixingMatrix, signals) {
     try {
       const dir = getCompactionDir();
-      fs.mkdirSync(dir, { recursive: true });
+      fs2.mkdirSync(dir, { recursive: true });
       const data = {
         sessionId,
         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -955,8 +1292,8 @@ var SessionCompactor = class {
           flow: signals.flow.slice(0, 10)
         }
       };
-      const filePath = path.join(dir, `${sessionId}.json`);
-      fs.writeFileSync(filePath, JSON.stringify(data, null, "	"), "utf-8");
+      const filePath = path2.join(dir, `${sessionId}.json`);
+      fs2.writeFileSync(filePath, JSON.stringify(data, null, "	"), "utf-8");
     } catch {
     }
   }
@@ -1552,10 +1889,10 @@ function computeSimilarity(a, b) {
 }
 
 // ../chitragupta/packages/smriti/src/checkpoint.ts
-import fs2 from "node:fs";
-import path2 from "node:path";
+import fs3 from "node:fs";
+import path3 from "node:path";
 import { randomUUID } from "node:crypto";
-var DEFAULT_CHECKPOINT_DIR = path2.join(".chitragupta", "checkpoints");
+var DEFAULT_CHECKPOINT_DIR = path3.join(".chitragupta", "checkpoints");
 var DEFAULT_INTERVAL = 3e4;
 var DEFAULT_MAX_CHECKPOINTS = 5;
 var CHECKPOINT_EXT = ".json";
@@ -1585,16 +1922,16 @@ var CheckpointManager = class {
    */
   async save(sessionId, data) {
     const sessionDir = this.sessionDir(sessionId);
-    await fs2.promises.mkdir(sessionDir, { recursive: true });
+    await fs3.promises.mkdir(sessionDir, { recursive: true });
     const timestamp = Date.now();
     const uuid = randomUUID().slice(0, 8);
     const filename = `${timestamp}-${uuid}${CHECKPOINT_EXT}`;
-    const filePath = path2.join(sessionDir, filename);
+    const filePath = path3.join(sessionDir, filename);
     const tmpPath = filePath + ".tmp";
     const json = JSON.stringify(data, null, 2);
     const sizeBytes = Buffer.byteLength(json, "utf-8");
-    await fs2.promises.writeFile(tmpPath, json, "utf-8");
-    await fs2.promises.rename(tmpPath, filePath);
+    await fs3.promises.writeFile(tmpPath, json, "utf-8");
+    await fs3.promises.rename(tmpPath, filePath);
     await this.prune(sessionId);
     return {
       id: `${timestamp}-${uuid}`,
@@ -1614,7 +1951,7 @@ var CheckpointManager = class {
     for (const cp of checkpoints) {
       try {
         const filePath = this.checkpointPath(sessionId, cp);
-        const raw = await fs2.promises.readFile(filePath, "utf-8");
+        const raw = await fs3.promises.readFile(filePath, "utf-8");
         const data = JSON.parse(raw);
         if (data.version === 1 && data.sessionId === sessionId) {
           return data;
@@ -1631,10 +1968,10 @@ var CheckpointManager = class {
    */
   list(sessionId) {
     const sessionDir = this.sessionDir(sessionId);
-    if (!fs2.existsSync(sessionDir)) return [];
+    if (!fs3.existsSync(sessionDir)) return [];
     let entries;
     try {
-      entries = fs2.readdirSync(sessionDir);
+      entries = fs3.readdirSync(sessionDir);
     } catch {
       return [];
     }
@@ -1643,22 +1980,22 @@ var CheckpointManager = class {
       if (entry.endsWith(".tmp")) continue;
       const parsed = parseCheckpointFilename(entry);
       if (!parsed) continue;
-      const filePath = path2.join(sessionDir, entry);
+      const filePath = path3.join(sessionDir, entry);
       let size = 0;
       let turnCount = 0;
       try {
-        const stat = fs2.statSync(filePath);
+        const stat = fs3.statSync(filePath);
         size = stat.size;
-        const fd = fs2.openSync(filePath, "r");
+        const fd = fs3.openSync(filePath, "r");
         const buf = Buffer.alloc(Math.min(size, 512));
-        fs2.readSync(fd, buf, 0, buf.length, 0);
-        fs2.closeSync(fd);
+        fs3.readSync(fd, buf, 0, buf.length, 0);
+        fs3.closeSync(fd);
         const snippet = buf.toString("utf-8");
         const turnMatch = snippet.match(/"turns"\s*:\s*\[/);
         if (turnMatch) {
           if (size < 1048576) {
             try {
-              const full = fs2.readFileSync(filePath, "utf-8");
+              const full = fs3.readFileSync(filePath, "utf-8");
               const obj = JSON.parse(full);
               turnCount = obj.turns?.length ?? 0;
             } catch {
@@ -1692,7 +2029,7 @@ var CheckpointManager = class {
     for (const cp of toRemove) {
       try {
         const filePath = this.checkpointPath(sessionId, cp);
-        await fs2.promises.unlink(filePath);
+        await fs3.promises.unlink(filePath);
         removed++;
       } catch {
       }
@@ -1731,24 +2068,24 @@ var CheckpointManager = class {
    */
   async deleteAll(sessionId) {
     const sessionDir = this.sessionDir(sessionId);
-    if (!fs2.existsSync(sessionDir)) return;
+    if (!fs3.existsSync(sessionDir)) return;
     try {
-      await fs2.promises.rm(sessionDir, { recursive: true, force: true });
+      await fs3.promises.rm(sessionDir, { recursive: true, force: true });
     } catch {
     }
   }
   // ─── Private ──────────────────────────────────────────────────────────────
   sessionDir(sessionId) {
-    return path2.join(this.dir, sessionId);
+    return path3.join(this.dir, sessionId);
   }
   checkpointPath(sessionId, cp) {
-    return path2.join(this.sessionDir(sessionId), `${cp.id}${CHECKPOINT_EXT}`);
+    return path3.join(this.sessionDir(sessionId), `${cp.id}${CHECKPOINT_EXT}`);
   }
 };
 
 // ../chitragupta/packages/smriti/src/consolidation.ts
-import fs3 from "fs";
-import path3 from "path";
+import fs4 from "fs";
+import path4 from "path";
 var DEFAULT_CONFIG = {
   minObservations: 2,
   decayRatePerDay: 0.01,
@@ -2036,11 +2373,11 @@ var ConsolidationEngine = class {
    */
   save() {
     const dir = this.getStoragePath();
-    fs3.mkdirSync(dir, { recursive: true });
-    const rulesPath = path3.join(dir, "rules.json");
-    const historyPath = path3.join(dir, "history.json");
-    fs3.writeFileSync(rulesPath, JSON.stringify(this.getRules(), null, "	"), "utf-8");
-    fs3.writeFileSync(historyPath, JSON.stringify(this.history, null, "	"), "utf-8");
+    fs4.mkdirSync(dir, { recursive: true });
+    const rulesPath = path4.join(dir, "rules.json");
+    const historyPath = path4.join(dir, "history.json");
+    fs4.writeFileSync(rulesPath, JSON.stringify(this.getRules(), null, "	"), "utf-8");
+    fs4.writeFileSync(historyPath, JSON.stringify(this.history, null, "	"), "utf-8");
   }
   /**
    * Load previously persisted rules and history from disk.
@@ -2048,11 +2385,11 @@ var ConsolidationEngine = class {
    */
   load() {
     const dir = this.getStoragePath();
-    const rulesPath = path3.join(dir, "rules.json");
-    const historyPath = path3.join(dir, "history.json");
-    if (fs3.existsSync(rulesPath)) {
+    const rulesPath = path4.join(dir, "rules.json");
+    const historyPath = path4.join(dir, "history.json");
+    if (fs4.existsSync(rulesPath)) {
       try {
-        const data = JSON.parse(fs3.readFileSync(rulesPath, "utf-8"));
+        const data = JSON.parse(fs4.readFileSync(rulesPath, "utf-8"));
         this.rules.clear();
         for (const rule of data) {
           this.rules.set(rule.id, rule);
@@ -2063,10 +2400,10 @@ var ConsolidationEngine = class {
         this.rules.clear();
       }
     }
-    if (fs3.existsSync(historyPath)) {
+    if (fs4.existsSync(historyPath)) {
       try {
         this.history = JSON.parse(
-          fs3.readFileSync(historyPath, "utf-8")
+          fs4.readFileSync(historyPath, "utf-8")
         );
       } catch (err) {
         process.stderr.write(`[consolidation] corrupted history.json, starting fresh: ${err instanceof Error ? err.message : err}
@@ -2457,7 +2794,7 @@ var ConsolidationEngine = class {
    * @returns Absolute path to the consolidation storage directory.
    */
   getStoragePath() {
-    return this.config.storagePath ?? path3.join(getChitraguptaHome(), "consolidation");
+    return this.config.storagePath ?? path4.join(getChitraguptaHome(), "consolidation");
   }
 };
 function extractSentenceContaining(text, index) {
@@ -3009,8 +3346,8 @@ var AnveshanaEngine = class {
 };
 
 // ../chitragupta/packages/smriti/src/smaran.ts
-import fs4 from "fs";
-import path4 from "path";
+import fs5 from "fs";
+import path5 from "path";
 var DEFAULT_CONFIG3 = {
   maxEntries: 1e3,
   defaultDecayDays: 90,
@@ -3039,7 +3376,7 @@ var SmaranStore = class {
         SMARAN_HARD_CEILINGS.recallLimit
       )
     };
-    this.storagePath = this.config.storagePath ?? path4.join(getChitraguptaHome(), "smaran");
+    this.storagePath = this.config.storagePath ?? path5.join(getChitraguptaHome(), "smaran");
   }
   // ─── Core CRUD ────────────────────────────────────────────────────────
   /**
@@ -3308,11 +3645,11 @@ var SmaranStore = class {
     this.loaded = true;
   }
   loadAll() {
-    if (!fs4.existsSync(this.storagePath)) return;
-    const files = fs4.readdirSync(this.storagePath).filter((f) => f.endsWith(".md"));
+    if (!fs5.existsSync(this.storagePath)) return;
+    const files = fs5.readdirSync(this.storagePath).filter((f) => f.endsWith(".md"));
     for (const file of files) {
       try {
-        const content = fs4.readFileSync(path4.join(this.storagePath, file), "utf-8");
+        const content = fs5.readFileSync(path5.join(this.storagePath, file), "utf-8");
         const entry = this.fromMarkdown(content);
         if (entry) {
           this.entries.set(entry.id, entry);
@@ -3327,15 +3664,15 @@ var SmaranStore = class {
     }
   }
   saveEntry(entry) {
-    fs4.mkdirSync(this.storagePath, { recursive: true });
-    const filePath = path4.join(this.storagePath, `${entry.id}.md`);
+    fs5.mkdirSync(this.storagePath, { recursive: true });
+    const filePath = path5.join(this.storagePath, `${entry.id}.md`);
     const content = this.toMarkdown(entry);
-    fs4.writeFileSync(filePath, content, { encoding: "utf-8", mode: 384 });
+    fs5.writeFileSync(filePath, content, { encoding: "utf-8", mode: 384 });
   }
   deleteFile(id) {
-    const filePath = path4.join(this.storagePath, `${id}.md`);
+    const filePath = path5.join(this.storagePath, `${id}.md`);
     try {
-      if (fs4.existsSync(filePath)) fs4.unlinkSync(filePath);
+      if (fs5.existsSync(filePath)) fs5.unlinkSync(filePath);
     } catch {
     }
   }
@@ -3581,9 +3918,9 @@ function cleanContent(content) {
 }
 
 // ../chitragupta/packages/smriti/src/identity-context.ts
-import fs5 from "fs";
-import path5 from "path";
-import os from "os";
+import fs6 from "fs";
+import path6 from "path";
+import os2 from "os";
 var DEFAULT_INCLUDE = ["soul", "identity", "personality", "user"];
 var FILE_NAMES = {
   soul: ["SOUL.md", "soul.md"],
@@ -3691,7 +4028,7 @@ var IdentityContext = class {
     const fileNames = FILE_NAMES[type];
     for (const dir of searchDirs) {
       for (const name of fileNames) {
-        const filePath = path5.join(dir, name);
+        const filePath = path6.join(dir, name);
         const content = readFileSafe(filePath);
         if (content) return { type, path: filePath, content };
       }
@@ -3704,13 +4041,13 @@ var IdentityContext = class {
       dirs.push(this.config.projectPath);
       let current = this.config.projectPath;
       for (let i = 0; i < 3; i++) {
-        const parent = path5.dirname(current);
+        const parent = path6.dirname(current);
         if (parent === current) break;
         dirs.push(parent);
         current = parent;
       }
     }
-    dirs.push(os.homedir());
+    dirs.push(os2.homedir());
     return dirs;
   }
   typeLabel(type) {
@@ -3730,8 +4067,8 @@ var IdentityContext = class {
 };
 function readFileSafe(filePath) {
   try {
-    if (fs5.existsSync(filePath)) {
-      const content = fs5.readFileSync(filePath, "utf-8");
+    if (fs6.existsSync(filePath)) {
+      const content = fs6.readFileSync(filePath, "utf-8");
       if (content.trim().length > 0) return content;
     }
   } catch {
@@ -3743,7 +4080,7 @@ function stripFrontmatter(content) {
   return fmMatch ? content.slice(fmMatch[0].length) : content;
 }
 
-// ../chitragupta/packages/smriti/src/vasana-engine.ts
+// ../chitragupta/packages/smriti/src/svapna-consolidation.ts
 var FNV_OFFSET2 = 2166136261;
 var FNV_PRIME2 = 16777619;
 function fnv1a3(input) {
@@ -3755,543 +4092,6 @@ function fnv1a3(input) {
   return hash.toString(16).padStart(8, "0");
 }
 var DEFAULT_CONFIG4 = {
-  lambda: 50,
-  changePointThreshold: 0.3,
-  stabilityWindow: 5,
-  windowSize: 20,
-  holdoutTrainRatio: 0.7,
-  accuracyThreshold: 0.6,
-  decayHalfLifeMs: 30 * 864e5,
-  promotionMinProjects: 3,
-  maxRunLength: 200,
-  priorMu: 0,
-  priorKappa: 1,
-  priorAlpha: 1,
-  anomalyRevertWindow: 3,
-  anomalyConfirmRatio: 0.5
-};
-var HARD_CEILINGS = {
-  windowSize: 500,
-  maxRunLength: 2e3,
-  stabilityWindow: 100
-};
-function logsumexp2(xs) {
-  if (xs.length === 0) return -Infinity;
-  const m = Math.max(...xs);
-  if (m === -Infinity) return -Infinity;
-  let s = 0;
-  for (let i = 0; i < xs.length; i++) s += Math.exp(xs[i] - m);
-  return m + Math.log(s);
-}
-function lgamma(z) {
-  const c = [
-    0.9999999999998099,
-    676.5203681218851,
-    -1259.1392167224028,
-    771.3234287776531,
-    -176.6150291621406,
-    12.507343278686905,
-    -0.13857109526572012,
-    9984369578019572e-21,
-    15056327351493116e-23
-  ];
-  if (z < 0.5) return Math.log(Math.PI / Math.sin(Math.PI * z)) - lgamma(1 - z);
-  z -= 1;
-  let x = c[0];
-  for (let i = 1; i < 9; i++) x += c[i] / (z + i);
-  const t = z + 7.5;
-  return 0.5 * Math.log(2 * Math.PI) + (z + 0.5) * Math.log(t) - t + Math.log(x);
-}
-function logStudentT(x, nu, mu, sigma) {
-  const safeSigma = sigma > 1e-15 ? sigma : 1e-15;
-  const z = (x - mu) / safeSigma;
-  return lgamma((nu + 1) / 2) - lgamma(nu / 2) - 0.5 * Math.log(nu * Math.PI * safeSigma * safeSigma) - (nu + 1) / 2 * Math.log(1 + z * z / nu);
-}
-var VasanaEngine = class {
-  cfg;
-  states = /* @__PURE__ */ new Map();
-  obs = /* @__PURE__ */ new Map();
-  cache = /* @__PURE__ */ new Map();
-  constructor(config) {
-    const merged = { ...DEFAULT_CONFIG4, ...config };
-    for (const [k, ceil] of Object.entries(HARD_CEILINGS)) {
-      const key = k;
-      if (typeof merged[key] === "number" && typeof ceil === "number")
-        merged[key] = Math.min(merged[key], ceil);
-    }
-    this.cfg = merged;
-  }
-  // ── Core API ─────────────────────────────────────────────────────────
-  /** Observe a samskara: extract features and update BOCPD state per dimension. */
-  observe(samskara) {
-    for (const [feat, val] of this.extractFeatures(samskara)) {
-      if (!this.states.has(feat)) this.states.set(feat, this.initState());
-      const buf = this.obs.get(feat) ?? [];
-      buf.push(val);
-      if (buf.length > this.cfg.windowSize) buf.splice(0, buf.length - this.cfg.windowSize);
-      this.obs.set(feat, buf);
-      this.updateBOCPD(feat, val);
-    }
-  }
-  /** Run crystallization: stability check, holdout validation, vasana upsert. */
-  crystallize(project) {
-    const now = Date.now();
-    const res = { created: [], reinforced: [], pending: [], changePoints: [], anomalies: [], timestamp: now };
-    const db = DatabaseManager.instance().get("agent");
-    const rows = db.prepare(
-      `SELECT id, session_id, pattern_type, pattern_content, observation_count,
-			        confidence, pramana_type, project, created_at, updated_at
-			 FROM samskaras WHERE project = ? OR project IS NULL
-			 ORDER BY updated_at DESC LIMIT ?`
-    ).all(project, this.cfg.windowSize * 10);
-    for (const [key, ids] of this.clusterSamskaras(rows)) {
-      const feat = `cluster:${key}`;
-      const st = this.states.get(feat);
-      if (!st) {
-        res.pending.push(key);
-        continue;
-      }
-      const deviation = this.classifyDeviation(st);
-      if (deviation === "change-point") {
-        st.stableCount = 0;
-        res.changePoints.push(key);
-        continue;
-      }
-      if (deviation === "anomaly") {
-        res.anomalies.push(key);
-        continue;
-      }
-      st.stableCount++;
-      if (st.stableCount < this.cfg.stabilityWindow) {
-        res.pending.push(key);
-        continue;
-      }
-      const o = this.obs.get(feat) ?? [];
-      if (o.length < 4) {
-        res.pending.push(key);
-        continue;
-      }
-      const acc = this.holdoutValidation(o);
-      if (acc < this.cfg.accuracyThreshold) {
-        res.pending.push(key);
-        continue;
-      }
-      const stability = this.stabilityScore(st);
-      const valence = this.assignValence(rows.filter((r) => ids.has(r.id)));
-      const vid = fnv1a3(key + ":" + project);
-      const existing = this.loadVasana(vid);
-      if (existing) {
-        existing.strength = Math.min(1, existing.strength + 0.1);
-        existing.stability = stability;
-        existing.reinforcementCount++;
-        existing.lastActivated = now;
-        existing.predictiveAccuracy = acc;
-        existing.updatedAt = now;
-        this.saveVasana(existing);
-        res.reinforced.push(existing);
-      } else {
-        const rep = rows.find((r) => ids.has(r.id));
-        const v = {
-          id: vid,
-          tendency: key.replace(/:/g, "-"),
-          description: rep?.pattern_content ?? key,
-          strength: 0.5 + acc * 0.3,
-          stability,
-          valence,
-          sourceSamskaras: [...ids],
-          reinforcementCount: 1,
-          lastActivated: now,
-          predictiveAccuracy: acc,
-          project,
-          createdAt: now,
-          updatedAt: now
-        };
-        this.saveVasana(v);
-        res.created.push(v);
-      }
-    }
-    return res;
-  }
-  /** Reinforce with diminishing returns: delta = 0.1 / (1 + ln(1 + count)). */
-  reinforce(vasanaId) {
-    const v = this.loadVasana(vasanaId);
-    if (!v) return;
-    v.strength = Math.min(1, v.strength + 0.1 / (1 + Math.log(1 + v.reinforcementCount)));
-    v.reinforcementCount++;
-    v.lastActivated = v.updatedAt = Date.now();
-    this.saveVasana(v);
-  }
-  /** Weaken by fixed decrement. */
-  weaken(vasanaId) {
-    const v = this.loadVasana(vasanaId);
-    if (!v) return;
-    v.strength = Math.max(0, v.strength - 0.15);
-    v.updatedAt = Date.now();
-    this.saveVasana(v);
-  }
-  /** Get vasanas for a project (includes global), sorted by strength desc. */
-  getVasanas(project, topK = 20) {
-    const rows = DatabaseManager.instance().get("agent").prepare(
-      `SELECT id,name,description,valence,strength,stability,source_samskaras,
-			        project,created_at,updated_at,last_activated,activation_count
-			 FROM vasanas WHERE project=? OR project IS NULL OR project='__global__'
-			 ORDER BY strength DESC LIMIT ?`
-    ).all(project, topK);
-    return rows.map((r) => this.toVasana(r));
-  }
-  /** Promote project vasanas to global when found in >= promotionMinProjects. */
-  promoteToGlobal() {
-    const now = Date.now();
-    const res = { promoted: [], projectSources: {}, timestamp: now };
-    const db = DatabaseManager.instance().get("agent");
-    const rows = db.prepare(
-      `SELECT id,name,description,valence,strength,stability,source_samskaras,
-			        project,created_at,updated_at,last_activated,activation_count
-			 FROM vasanas WHERE project IS NOT NULL AND project!='__global__' AND strength>=0.4
-			 ORDER BY name`
-    ).all();
-    const byName = /* @__PURE__ */ new Map();
-    for (const r of rows) {
-      const k = r.name.toLowerCase();
-      byName.set(k, [...byName.get(k) ?? [], r]);
-    }
-    for (const [tendency, group] of byName) {
-      const projects = new Set(group.map((r) => r.project));
-      if (projects.size < this.cfg.promotionMinProjects) continue;
-      if (db.prepare(`SELECT 1 FROM vasanas WHERE name=? AND (project IS NULL OR project='__global__')`).get(tendency)) continue;
-      const allSrc = [];
-      for (const r of group) allSrc.push(...jsonArr(r.source_samskaras));
-      const votes = { positive: 0, negative: 0, neutral: 0 };
-      for (const r of group) votes[r.valence]++;
-      const valence = ["positive", "negative", "neutral"].reduce((a, b) => votes[a] >= votes[b] ? a : b);
-      const gv = {
-        id: fnv1a3(tendency + ":__global__"),
-        tendency,
-        description: group[0].description,
-        strength: group.reduce((s, r) => s + r.strength, 0) / group.length,
-        stability: Math.max(...group.map((r) => r.stability)),
-        valence,
-        sourceSamskaras: [...new Set(allSrc)],
-        reinforcementCount: group.reduce((s, r) => s + r.activation_count, 0),
-        lastActivated: now,
-        predictiveAccuracy: Math.max(...group.map((r) => r.stability)),
-        project: "__global__",
-        createdAt: now,
-        updatedAt: now
-      };
-      this.saveVasana(gv);
-      res.promoted.push(gv);
-      res.projectSources[tendency] = [...projects];
-    }
-    return res;
-  }
-  /** Exponential decay: strength *= exp(-ln2 * elapsed / halfLife). Deletes below 0.01. */
-  decay(halfLifeMs) {
-    const hl = halfLifeMs ?? this.cfg.decayHalfLifeMs;
-    const now = Date.now();
-    const db = DatabaseManager.instance().get("agent");
-    const rows = db.prepare(`SELECT id, strength, last_activated FROM vasanas`).all();
-    let deleted = 0;
-    for (const r of rows) {
-      const elapsed = now - (r.last_activated ?? now);
-      if (elapsed <= 0) continue;
-      const s = r.strength * Math.exp(-Math.LN2 * elapsed / hl);
-      if (s < 0.01) {
-        db.prepare(`DELETE FROM vasanas WHERE id=?`).run(r.id);
-        deleted++;
-      } else db.prepare(`UPDATE vasanas SET strength=?,updated_at=? WHERE id=?`).run(s, now, r.id);
-    }
-    return deleted;
-  }
-  /** Persist BOCPD state (run-length distributions + observations) to SQLite. */
-  persist() {
-    const json = JSON.stringify({
-      features: Object.fromEntries(this.states),
-      observations: Object.fromEntries(this.obs)
-    });
-    DatabaseManager.instance().get("agent").prepare(
-      `INSERT OR REPLACE INTO consolidation_rules
-			 (id, category, rule_text, confidence, source_sessions, created_at, updated_at, hit_count, project)
-			 VALUES ((SELECT id FROM consolidation_rules WHERE category='bocpd_state' AND project='__vasana_engine__'),
-			         'bocpd_state',?,1.0,NULL,?,?,1,'__vasana_engine__')`
-    ).run(json, Date.now(), Date.now());
-  }
-  /** Restore BOCPD state from SQLite. No-op if nothing persisted. */
-  restore() {
-    const row = DatabaseManager.instance().get("agent").prepare(
-      `SELECT rule_text FROM consolidation_rules
-			 WHERE category='bocpd_state' AND project='__vasana_engine__' LIMIT 1`
-    ).get();
-    if (!row) return;
-    try {
-      const s = JSON.parse(row.rule_text);
-      this.states = new Map(Object.entries(s.features));
-      this.obs = new Map(Object.entries(s.observations).map(([k, v]) => [k, Array.isArray(v) ? v : []]));
-    } catch (err) {
-      process.stderr.write(`[vasana-engine] restore() failed to parse BOCPD state: ${err instanceof Error ? err.message : err}
-`);
-      this.states.clear();
-      this.obs.clear();
-    }
-  }
-  // ── BOCPD Core (Adams & MacKay 2007) ─────────────────────────────────
-  initState() {
-    return {
-      logR: [0],
-      // P(r=0) = 1
-      stats: [{
-        mu: this.cfg.priorMu,
-        kappa: this.cfg.priorKappa,
-        alpha: this.cfg.priorAlpha,
-        beta: this.cfg.priorAlpha
-      }],
-      stableCount: 0,
-      totalObs: 0,
-      recentCpProbs: []
-    };
-  }
-  /**
-   * Online BOCPD update for one observation on one feature dimension.
-   *
-   * 1. Predictive P(x_t | r) via Student-t with Normal-Gamma sufficient stats
-   * 2. Growth: P(r_t=r+1) = P(x|r) * P(r) * (1-H)
-   * 3. Change-point: P(r_t=0) = sum_r P(x|r) * P(r) * H
-   * 4. Normalize, update sufficient stats, prune low-probability tails
-   */
-  updateBOCPD(feat, x) {
-    const st = this.states.get(feat);
-    const logH = -Math.log(this.cfg.lambda);
-    const log1H = Math.log(1 - 1 / this.cfg.lambda);
-    const n = st.logR.length;
-    const lpp = new Array(n);
-    for (let r = 0; r < n; r++) {
-      const s = st.stats[r];
-      lpp[r] = logStudentT(x, 2 * s.alpha, s.mu, Math.sqrt(s.beta * (s.kappa + 1) / (s.alpha * s.kappa)));
-    }
-    const cpTerms = new Array(n);
-    const newLR = new Array(n + 1);
-    for (let r = 0; r < n; r++) {
-      newLR[r + 1] = lpp[r] + st.logR[r] + log1H;
-      cpTerms[r] = lpp[r] + st.logR[r] + logH;
-    }
-    newLR[0] = logsumexp2(cpTerms);
-    const logZ = logsumexp2(newLR);
-    for (let i = 0; i <= n; i++) newLR[i] -= logZ;
-    const newS = new Array(n + 1);
-    newS[0] = {
-      mu: this.cfg.priorMu,
-      kappa: this.cfg.priorKappa,
-      alpha: this.cfg.priorAlpha,
-      beta: this.cfg.priorAlpha
-    };
-    for (let r = 0; r < n; r++) {
-      const p = st.stats[r];
-      const k = p.kappa + 1;
-      const dx = x - p.mu;
-      newS[r + 1] = {
-        mu: (p.kappa * p.mu + x) / k,
-        kappa: k,
-        alpha: p.alpha + 0.5,
-        beta: p.beta + 0.5 * p.kappa * dx * dx / k
-      };
-    }
-    if (newLR.length > this.cfg.maxRunLength) {
-      const idx = newLR.map((lp, i) => ({ lp, i })).sort((a, b) => b.lp - a.lp);
-      const keep = new Set(idx.slice(0, this.cfg.maxRunLength).map((e) => e.i));
-      const pR = [], pS = [];
-      for (let i = 0; i <= n; i++) if (keep.has(i)) {
-        pR.push(newLR[i]);
-        pS.push(newS[i]);
-      }
-      const norm = logsumexp2(pR);
-      for (let i = 0; i < pR.length; i++) pR[i] -= norm;
-      st.logR = pR;
-      st.stats = pS;
-    } else {
-      st.logR = newLR;
-      st.stats = newS;
-    }
-    st.totalObs++;
-    const cpProb = st.logR.length > 0 ? Math.exp(st.logR[0]) : 0;
-    if (!st.recentCpProbs) st.recentCpProbs = [];
-    st.recentCpProbs.push(cpProb);
-    if (st.recentCpProbs.length > this.cfg.anomalyRevertWindow) {
-      st.recentCpProbs.shift();
-    }
-  }
-  /**
-   * Classify a deviation as change-point, anomaly, or stable.
-   *
-   * Joint anomaly/change-point discrimination (arxiv 2508.06385):
-   * - If P(r=0) > threshold and persists across the revert window → change-point
-   * - If P(r=0) > threshold but reverts within the window → anomaly (one-off)
-   * - Otherwise → stable
-   */
-  classifyDeviation(st) {
-    if (st.logR.length === 0) return "stable";
-    const cpProb = Math.exp(st.logR[0]);
-    if (cpProb <= this.cfg.changePointThreshold) return "stable";
-    const recent = st.recentCpProbs ?? [cpProb];
-    const exceedCount = recent.filter((p) => p > this.cfg.changePointThreshold).length;
-    const ratio = exceedCount / Math.max(1, recent.length);
-    if (recent.length >= this.cfg.anomalyRevertWindow && ratio >= this.cfg.anomalyConfirmRatio) {
-      return "change-point";
-    }
-    return "anomaly";
-  }
-  isChangePoint(st) {
-    return this.classifyDeviation(st) === "change-point";
-  }
-  stabilityScore(st) {
-    if (st.logR.length === 0) return 0;
-    return Math.max(0, Math.min(1, 1 - Math.exp(st.logR[0])));
-  }
-  // ── Feature Extraction & Validation ──────────────────────────────────
-  extractFeatures(s) {
-    const f = /* @__PURE__ */ new Map();
-    const tMap = {
-      "tool-sequence": 0.2,
-      preference: 0.4,
-      decision: 0.6,
-      correction: 0.8,
-      convention: 1
-    };
-    f.set(`type:${s.patternType}`, tMap[s.patternType] ?? 0.5);
-    f.set("confidence", s.confidence);
-    f.set("log_obs", Math.min(1, Math.log(1 + s.observationCount) / Math.log(101)));
-    const ch = parseInt(fnv1a3(s.patternContent), 16);
-    f.set(`cluster:${s.patternType}:${fnv1a3(s.patternContent)}`, ch / 4294967295);
-    return f;
-  }
-  /** 70/30 holdout: fraction of test points within 1.5 sigma of train mean. */
-  holdoutValidation(obs) {
-    if (obs.length < 4) return 0;
-    const si = Math.floor(obs.length * this.cfg.holdoutTrainRatio);
-    const train = obs.slice(0, si), test = obs.slice(si);
-    if (!train.length || !test.length) return 0;
-    const mu = train.reduce((a, b) => a + b, 0) / train.length;
-    const std = Math.sqrt(train.reduce((a, v) => a + (v - mu) ** 2, 0) / train.length + 1e-10);
-    let ok = 0;
-    for (const v of test) if (Math.abs(v - mu) <= 1.5 * std) ok++;
-    return ok / test.length;
-  }
-  assignValence(rows) {
-    let pos = 0, neg = 0;
-    for (const r of rows) {
-      if (r.pattern_type === "correction") neg += r.confidence;
-      else if (r.pattern_type !== "tool-sequence" || r.confidence > 0.6)
-        pos += r.confidence * (r.pattern_type === "tool-sequence" ? 0.5 : 1);
-    }
-    const tot = pos + neg;
-    if (tot < 0.1) return "neutral";
-    return pos / tot > 0.6 ? "positive" : neg / tot > 0.6 ? "negative" : "neutral";
-  }
-  clusterSamskaras(rows) {
-    const m = /* @__PURE__ */ new Map();
-    for (const r of rows) {
-      const k = `${r.pattern_type}:${fnv1a3(r.pattern_content.toLowerCase().trim().replace(/\s+/g, " "))}`;
-      const s = m.get(k) ?? /* @__PURE__ */ new Set();
-      s.add(r.id);
-      m.set(k, s);
-    }
-    return m;
-  }
-  // ── SQLite Helpers ───────────────────────────────────────────────────
-  // Schema mapping: Vasana.tendency→name, sourceSamskaras→source_samskaras(JSON),
-  //                 reinforcementCount→activation_count, lastActivated→last_activated
-  saveVasana(v) {
-    const db = DatabaseManager.instance().get("agent");
-    const existing = db.prepare(
-      `SELECT id FROM vasanas WHERE name=? AND (project=? OR (project IS NULL AND ?='__global__'))`
-    ).get(v.tendency, v.project, v.project);
-    if (existing) {
-      db.prepare(
-        `UPDATE vasanas SET description=?,valence=?,strength=?,stability=?,
-				 source_samskaras=?,updated_at=?,last_activated=?,activation_count=? WHERE id=?`
-      ).run(
-        v.description,
-        v.valence,
-        v.strength,
-        v.stability,
-        JSON.stringify(v.sourceSamskaras),
-        v.updatedAt,
-        v.lastActivated,
-        v.reinforcementCount,
-        existing.id
-      );
-    } else {
-      db.prepare(
-        `INSERT INTO vasanas (name,description,valence,strength,stability,source_samskaras,
-				 project,created_at,updated_at,last_activated,activation_count) VALUES (?,?,?,?,?,?,?,?,?,?,?)`
-      ).run(
-        v.tendency,
-        v.description,
-        v.valence,
-        v.strength,
-        v.stability,
-        JSON.stringify(v.sourceSamskaras),
-        v.project === "__global__" ? null : v.project,
-        v.createdAt,
-        v.updatedAt,
-        v.lastActivated,
-        v.reinforcementCount
-      );
-    }
-    this.cache.set(v.id, v);
-  }
-  loadVasana(vid) {
-    if (this.cache.has(vid)) return this.cache.get(vid);
-    const rows = DatabaseManager.instance().get("agent").prepare(
-      `SELECT id,name,description,valence,strength,stability,source_samskaras,
-			        project,created_at,updated_at,last_activated,activation_count FROM vasanas`
-    ).all();
-    for (const r of rows) {
-      const v = this.toVasana(r);
-      this.cache.set(v.id, v);
-    }
-    return this.cache.get(vid) ?? null;
-  }
-  toVasana(r) {
-    const proj = r.project ?? "__global__";
-    return {
-      id: fnv1a3(r.name + ":" + proj),
-      tendency: r.name,
-      description: r.description,
-      strength: r.strength,
-      stability: r.stability,
-      valence: r.valence,
-      sourceSamskaras: jsonArr(r.source_samskaras),
-      reinforcementCount: r.activation_count,
-      lastActivated: r.last_activated ?? r.updated_at,
-      predictiveAccuracy: r.stability,
-      project: proj,
-      createdAt: r.created_at,
-      updatedAt: r.updated_at
-    };
-  }
-};
-function jsonArr(s) {
-  if (!s) return [];
-  try {
-    const p = JSON.parse(s);
-    return Array.isArray(p) ? p : [];
-  } catch {
-    return [];
-  }
-}
-
-// ../chitragupta/packages/smriti/src/svapna-consolidation.ts
-var FNV_OFFSET3 = 2166136261;
-var FNV_PRIME3 = 16777619;
-function fnv1a4(input) {
-  let hash = FNV_OFFSET3;
-  for (let i = 0; i < input.length; i++) {
-    hash ^= input.charCodeAt(i);
-    hash = Math.imul(hash, FNV_PRIME3) >>> 0;
-  }
-  return hash.toString(16).padStart(8, "0");
-}
-var DEFAULT_CONFIG5 = {
   maxSessionsPerCycle: 50,
   surpriseThreshold: 0.7,
   minPatternFrequency: 3,
@@ -4317,10 +4117,10 @@ function buildToolFingerprint(toolNames2) {
   const fingerprint = /* @__PURE__ */ new Set();
   if (toolNames2.length === 0) return fingerprint;
   for (const name of toolNames2) {
-    fingerprint.add(fnv1a4(`u:${name}`));
+    fingerprint.add(fnv1a3(`u:${name}`));
   }
   for (let i = 0; i < toolNames2.length - 1; i++) {
-    fingerprint.add(fnv1a4(`b:${toolNames2[i]}:${toolNames2[i + 1]}`));
+    fingerprint.add(fnv1a3(`b:${toolNames2[i]}:${toolNames2[i + 1]}`));
   }
   return fingerprint;
 }
@@ -4412,7 +4212,7 @@ var SvapnaConsolidation = class {
    * @param db - Optional DatabaseManager instance (uses singleton if omitted).
    */
   constructor(config, db) {
-    this.config = { ...DEFAULT_CONFIG5, ...config };
+    this.config = { ...DEFAULT_CONFIG4, ...config };
     this.db = db ?? DatabaseManager.instance();
     this.cycleId = `svapna-${(/* @__PURE__ */ new Date()).toISOString()}`;
   }
@@ -4737,7 +4537,7 @@ var SvapnaConsolidation = class {
     for (const cluster of clusters) {
       if (cluster.sessionIds.size < 2) continue;
       const tendency = this.slugify(cluster.representative);
-      const vasanaId = fnv1a4(`${tendency}:${this.config.project}`);
+      const vasanaId = fnv1a3(`${tendency}:${this.config.project}`);
       const existing = agentDb.prepare("SELECT id, strength, activation_count FROM vasanas WHERE name = ? AND (project = ? OR project IS NULL)").get(tendency, this.config.project);
       if (existing) {
         const newStrength = Math.min(1, existing.strength + 0.1);
@@ -4916,7 +4716,7 @@ var SvapnaConsolidation = class {
         });
       }
       const vidhiName = this.slugify(ngramKey.replace(/ -> /g, "-then-"));
-      const vidhiId = fnv1a4(`${vidhiName}:${this.config.project}`);
+      const vidhiId = fnv1a3(`${vidhiName}:${this.config.project}`);
       const existing = agentDb.prepare("SELECT id FROM vidhis WHERE id = ?").get(vidhiId);
       if (existing) continue;
       const vidhi = {
@@ -5221,8 +5021,8 @@ var SvapnaConsolidation = class {
 };
 
 // ../chitragupta/packages/smriti/src/vidhi-engine.ts
-var FNV_OFFSET4 = 2166136261;
-var FNV_PRIME4 = 16777619;
+var FNV_OFFSET3 = 2166136261;
+var FNV_PRIME3 = 16777619;
 var ACTION_VERBS = /* @__PURE__ */ new Set([
   "add",
   "create",
@@ -5288,24 +5088,24 @@ var ACTION_VERBS = /* @__PURE__ */ new Set([
   "scaffold",
   "bootstrap"
 ]);
-var DEFAULT_CONFIG6 = {
+var DEFAULT_CONFIG5 = {
   minSessions: 3,
   minSuccessRate: 0.8,
   minSequenceLength: 2,
   maxSequenceLength: 5
 };
-function fnv1a5(str) {
-  let hash = FNV_OFFSET4;
+function fnv1a4(str) {
+  let hash = FNV_OFFSET3;
   for (let i = 0; i < str.length; i++) {
     hash ^= str.charCodeAt(i);
-    hash = hash * FNV_PRIME4 >>> 0;
+    hash = hash * FNV_PRIME3 >>> 0;
   }
   return hash.toString(16).padStart(8, "0");
 }
 var VidhiEngine = class {
   _config;
   constructor(config) {
-    this._config = { ...DEFAULT_CONFIG6, ...config };
+    this._config = { ...DEFAULT_CONFIG5, ...config };
   }
   // ─── Public API ───────────────────────────────────────────────────
   /**
@@ -5598,7 +5398,7 @@ var VidhiEngine = class {
   _buildVidhi(agg) {
     const now = Date.now();
     const name = this._generateName(agg.toolNames);
-    const id = fnv1a5(name + "|" + this._config.project);
+    const id = fnv1a4(name + "|" + this._config.project);
     const parameterSchema = {};
     const steps = [];
     for (let stepIdx = 0; stepIdx < agg.toolNames.length; stepIdx++) {
@@ -6056,13 +5856,13 @@ var STOP_WORDS = /* @__PURE__ */ new Set([
   "over",
   "after"
 ]);
-var FNV_OFFSET5 = 2166136261;
-var FNV_PRIME5 = 16777619;
-function fnv1a6(input) {
-  let hash = FNV_OFFSET5;
+var FNV_OFFSET4 = 2166136261;
+var FNV_PRIME4 = 16777619;
+function fnv1a5(input) {
+  let hash = FNV_OFFSET4;
   for (let i = 0; i < input.length; i++) {
     hash ^= input.charCodeAt(i);
-    hash = Math.imul(hash, FNV_PRIME5) >>> 0;
+    hash = Math.imul(hash, FNV_PRIME4) >>> 0;
   }
   return hash.toString(16).padStart(8, "0");
 }
@@ -6079,7 +5879,7 @@ function jaccardSimilarity2(a, b) {
   return union === 0 ? 0 : intersection / union;
 }
 var DAY_MS = 864e5;
-var DEFAULT_CONFIG7 = {
+var DEFAULT_CONFIG6 = {
   decayHalfLife: 7 * DAY_MS,
   // 7 days
   minStrength: 0.01,
@@ -6091,7 +5891,7 @@ var DEFAULT_CONFIG7 = {
   diminishingAlpha: 0.3,
   frequencyDecayBeta: 0.5
 };
-var HARD_CEILINGS2 = {
+var HARD_CEILINGS = {
   maxTraces: 5e4,
   minDecayHalfLife: 36e5,
   // 1 hour minimum
@@ -6105,16 +5905,16 @@ var AkashaField = class {
   reinforcedBy = /* @__PURE__ */ new Map();
   constructor(config) {
     this.config = {
-      ...DEFAULT_CONFIG7,
+      ...DEFAULT_CONFIG6,
       ...config,
       // Clamp to hard ceilings
       maxTraces: Math.min(
-        config?.maxTraces ?? DEFAULT_CONFIG7.maxTraces,
-        HARD_CEILINGS2.maxTraces
+        config?.maxTraces ?? DEFAULT_CONFIG6.maxTraces,
+        HARD_CEILINGS.maxTraces
       ),
       decayHalfLife: Math.max(
-        config?.decayHalfLife ?? DEFAULT_CONFIG7.decayHalfLife,
-        HARD_CEILINGS2.minDecayHalfLife
+        config?.decayHalfLife ?? DEFAULT_CONFIG6.decayHalfLife,
+        HARD_CEILINGS.minDecayHalfLife
       )
     };
   }
@@ -6134,8 +5934,8 @@ var AkashaField = class {
    * @returns The created StigmergicTrace.
    */
   leave(agentId, type, topic, content, metadata) {
-    const truncatedContent = content.length > HARD_CEILINGS2.maxContentSize ? content.slice(0, HARD_CEILINGS2.maxContentSize) : content;
-    const id = `aks-${fnv1a6(agentId + ":" + type + ":" + topic + ":" + truncatedContent)}`;
+    const truncatedContent = content.length > HARD_CEILINGS.maxContentSize ? content.slice(0, HARD_CEILINGS.maxContentSize) : content;
+    const id = `aks-${fnv1a5(agentId + ":" + type + ":" + topic + ":" + truncatedContent)}`;
     const now = Date.now();
     const trace = {
       id,
@@ -6589,7 +6389,7 @@ var DEFAULT_SCALE_WEIGHTS = {
   quarter: 0.08,
   year: 0.07
 };
-var HARD_CEILINGS3 = {
+var HARD_CEILINGS2 = {
   /** Minimum half-life: 1 second. Anything faster is meaningless. */
   minDecayRate: 1e3,
   /** Maximum half-life: 10 years. Beyond this, nothing decays. */
@@ -6636,8 +6436,8 @@ var KalaChakra = class {
         if (config.decayRates[scale] !== void 0) {
           this._decayRates[scale] = clamp(
             config.decayRates[scale],
-            HARD_CEILINGS3.minDecayRate,
-            HARD_CEILINGS3.maxDecayRate
+            HARD_CEILINGS2.minDecayRate,
+            HARD_CEILINGS2.maxDecayRate
           );
         }
       }
@@ -6647,8 +6447,8 @@ var KalaChakra = class {
         if (config.scaleWeights[scale] !== void 0) {
           this._scaleWeights[scale] = clamp(
             config.scaleWeights[scale],
-            HARD_CEILINGS3.minWeight,
-            HARD_CEILINGS3.maxWeight
+            HARD_CEILINGS2.minWeight,
+            HARD_CEILINGS2.maxWeight
           );
         }
       }
@@ -6890,8 +6690,8 @@ var KalaChakra = class {
         if (typeof data.decayRates[scale] === "number") {
           this._decayRates[scale] = clamp(
             data.decayRates[scale],
-            HARD_CEILINGS3.minDecayRate,
-            HARD_CEILINGS3.maxDecayRate
+            HARD_CEILINGS2.minDecayRate,
+            HARD_CEILINGS2.maxDecayRate
           );
         }
       }
@@ -6901,8 +6701,8 @@ var KalaChakra = class {
         if (typeof data.scaleWeights[scale] === "number") {
           this._scaleWeights[scale] = clamp(
             data.scaleWeights[scale],
-            HARD_CEILINGS3.minWeight,
-            HARD_CEILINGS3.maxWeight
+            HARD_CEILINGS2.minWeight,
+            HARD_CEILINGS2.maxWeight
           );
         }
       }
@@ -6943,13 +6743,13 @@ function mondayOfISOWeek(isoYear, isoWeekNum) {
 }
 
 // ../chitragupta/packages/smriti/src/pancha-vritti.ts
-var FNV_OFFSET6 = 2166136261;
-var FNV_PRIME6 = 16777619;
-function fnv1a7(input) {
-  let hash = FNV_OFFSET6;
+var FNV_OFFSET5 = 2166136261;
+var FNV_PRIME5 = 16777619;
+function fnv1a6(input) {
+  let hash = FNV_OFFSET5;
   for (let i = 0; i < input.length; i++) {
     hash ^= input.charCodeAt(i);
-    hash = Math.imul(hash, FNV_PRIME6);
+    hash = Math.imul(hash, FNV_PRIME5);
   }
   return (hash >>> 0).toString(16).padStart(8, "0");
 }
@@ -6967,13 +6767,13 @@ var VRITTI_CONFIDENCE_WEIGHTS = {
   vikalpa: 0.5,
   viparyaya: 0.3
 };
-var DEFAULT_CONFIG8 = {
+var DEFAULT_CONFIG7 = {
   maxClassifications: 5e3,
   minConfidence: 0.4,
   snippetMaxLength: 200,
   confidenceWeights: { ...VRITTI_CONFIDENCE_WEIGHTS }
 };
-var HARD_CEILINGS4 = {
+var HARD_CEILINGS3 = {
   maxClassifications: 5e4,
   snippetMaxLength: 1e3
 };
@@ -7101,23 +6901,23 @@ var PanchaVritti = class {
   totalReclassified = 0;
   constructor(config) {
     const merged = {
-      ...DEFAULT_CONFIG8,
+      ...DEFAULT_CONFIG7,
       ...config,
       confidenceWeights: {
-        ...DEFAULT_CONFIG8.confidenceWeights,
+        ...DEFAULT_CONFIG7.confidenceWeights,
         ...config?.confidenceWeights
       }
     };
-    if (typeof HARD_CEILINGS4.maxClassifications === "number") {
+    if (typeof HARD_CEILINGS3.maxClassifications === "number") {
       merged.maxClassifications = Math.min(
         merged.maxClassifications,
-        HARD_CEILINGS4.maxClassifications
+        HARD_CEILINGS3.maxClassifications
       );
     }
-    if (typeof HARD_CEILINGS4.snippetMaxLength === "number") {
+    if (typeof HARD_CEILINGS3.snippetMaxLength === "number") {
       merged.snippetMaxLength = Math.min(
         merged.snippetMaxLength,
-        HARD_CEILINGS4.snippetMaxLength
+        HARD_CEILINGS3.snippetMaxLength
       );
     }
     this.cfg = merged;
@@ -7151,7 +6951,7 @@ var PanchaVritti = class {
       prePatterns.push("context:error-flag");
     }
     if (content.trim().length === 0) {
-      const id2 = fnv1a7("nidra:" + now.toString());
+      const id2 = fnv1a6("nidra:" + now.toString());
       const classification2 = {
         id: id2,
         type: "nidra",
@@ -7227,7 +7027,7 @@ var PanchaVritti = class {
     if (winnerConfidence < this.cfg.minConfidence) {
       winnerPatterns.push("low-confidence");
     }
-    const id = fnv1a7(winnerType + ":" + content.slice(0, 100) + ":" + now.toString());
+    const id = fnv1a6(winnerType + ":" + content.slice(0, 100) + ":" + now.toString());
     const classification = {
       id,
       type: winnerType,
@@ -7469,16 +7269,16 @@ async function recall(query, options) {
 }
 async function searchHybrid(query, project, limit) {
   try {
-    const { HybridSearchEngine: HybridSearchEngine2 } = await import("./hybrid-search-ZVLZVGFS.js");
+    const { HybridSearchEngine: HybridSearchEngine2 } = await import("./hybrid-search-TX6T3KYH.js");
     let recallEngine = null;
     let graphEngine = null;
     try {
-      const { RecallEngine: RecallEngine2 } = await import("./recall-GMVHWQWW.js");
+      const { RecallEngine: RecallEngine2 } = await import("./recall-IUPQCBYP.js");
       recallEngine = new RecallEngine2();
     } catch {
     }
     try {
-      const { GraphRAGEngine: GraphRAGEngine2 } = await import("./graphrag-ZI2FSU7S.js");
+      const { GraphRAGEngine: GraphRAGEngine2 } = await import("./graphrag-LAZSXLLI.js");
       graphEngine = new GraphRAGEngine2();
     } catch {
     }
@@ -7516,8 +7316,8 @@ async function searchHybrid(query, project, limit) {
 }
 async function searchTurns(query, project) {
   try {
-    const { searchSessions: searchSessions2 } = await import("./search-7HZETVMZ.js");
-    const { loadSession: loadSession2 } = await import("./session-store-XKPGKXUS.js");
+    const { searchSessions: searchSessions2 } = await import("./search-HHSVHBXC.js");
+    const { loadSession: loadSession2 } = await import("./session-store-NDUDYAC7.js");
     const metas = searchSessions2(query, project);
     const results = [];
     for (const meta of metas.slice(0, 10)) {
@@ -7563,7 +7363,7 @@ async function searchTurns(query, project) {
 }
 async function searchMemoryLayer(query) {
   try {
-    const { searchMemory: searchMemory2 } = await import("./search-7HZETVMZ.js");
+    const { searchMemory: searchMemory2 } = await import("./search-HHSVHBXC.js");
     const results = searchMemory2(query);
     return results.slice(0, 5).map((r) => ({
       score: Math.min((r.relevance ?? 0.5) + 0.1, 1),
@@ -7577,7 +7377,7 @@ async function searchMemoryLayer(query) {
 }
 async function searchDayFileLayer(query, limit) {
   try {
-    const { hierarchicalTemporalSearch: hierarchicalTemporalSearch2 } = await import("./hierarchical-temporal-search-ZD46UMKR.js");
+    const { hierarchicalTemporalSearch: hierarchicalTemporalSearch2 } = await import("./hierarchical-temporal-search-ETXYYJZK.js");
     const results = await hierarchicalTemporalSearch2(query, { limit });
     if (results.length > 0) {
       return results.map((r) => ({
@@ -7592,7 +7392,7 @@ async function searchDayFileLayer(query, limit) {
   } catch {
   }
   try {
-    const { searchDayFiles: searchDayFiles2 } = await import("./day-consolidation-NKO63HZQ.js");
+    const { searchDayFiles: searchDayFiles2 } = await import("./day-consolidation-U3X6P4ZG.js");
     const results = searchDayFiles2(query, { limit });
     return results.map((r) => ({
       score: 0.5,
@@ -7623,7 +7423,7 @@ async function loadProviderContext(project, options) {
   let projectMemory = "";
   let recentContext = "";
   try {
-    const { getMemory: getMemory2 } = await import("./memory-store-KNJPMBLQ.js");
+    const { getMemory: getMemory2 } = await import("./memory-store-A6WOWLWC.js");
     globalFacts = getMemory2({ type: "global" });
     if (globalFacts.length > maxLen / 3) {
       globalFacts = globalFacts.slice(0, maxLen / 3) + "\n...(truncated)";
@@ -7632,7 +7432,7 @@ async function loadProviderContext(project, options) {
   }
   if (project) {
     try {
-      const { getMemory: getMemory2 } = await import("./memory-store-KNJPMBLQ.js");
+      const { getMemory: getMemory2 } = await import("./memory-store-A6WOWLWC.js");
       projectMemory = getMemory2({ type: "project", path: project });
       if (projectMemory.length > maxLen / 3) {
         projectMemory = projectMemory.slice(0, maxLen / 3) + "\n...(truncated)";
@@ -7640,8 +7440,20 @@ async function loadProviderContext(project, options) {
     } catch {
     }
   }
+  let vasanaContext = "";
   try {
-    const { listSessions: listSessions2, loadSession: loadSession2 } = await import("./session-store-XKPGKXUS.js");
+    const { VasanaEngine: VasanaEngine2 } = await import("./vasana-engine-G6BPOFX7.js");
+    const engine = new VasanaEngine2();
+    const vasanas = engine.getVasanas(project ?? "__global__", 5);
+    if (vasanas.length > 0) {
+      vasanaContext = vasanas.map(
+        (v) => `- ${v.tendency} (strength: ${(v.strength * 100).toFixed(0)}%): ${v.description}`
+      ).join("\n");
+    }
+  } catch {
+  }
+  try {
+    const { listSessions: listSessions2, loadSession: loadSession2 } = await import("./session-store-NDUDYAC7.js");
     const sessions = project ? listSessions2(project).slice(0, recentLimit) : listSessions2().slice(0, recentLimit);
     const summaries = [];
     for (const meta of sessions) {
@@ -7675,6 +7487,10 @@ async function loadProviderContext(project, options) {
     parts.push("## Recent Sessions\n" + recentContext.trim());
     itemCount += recentContext.split("\n").filter((l) => l.trim()).length;
   }
+  if (vasanaContext.trim()) {
+    parts.push("## Behavioral Patterns\n" + vasanaContext.trim());
+    itemCount += vasanaContext.split("\n").filter((l) => l.trim()).length;
+  }
   const assembled = parts.join("\n\n");
   return {
     globalFacts: globalFacts.trim(),
@@ -7690,6 +7506,11 @@ export {
   exportSessionToMarkdown,
   importSessionFromJson,
   detectExportFormat,
+  createCrossMachineSnapshot,
+  writeCrossMachineSnapshot,
+  readCrossMachineSnapshot,
+  getCrossMachineSyncStatus,
+  importCrossMachineSnapshot,
   branchSession,
   getSessionTree,
   sinkhornKnopp,
@@ -7713,7 +7534,6 @@ export {
   detectMemoryIntent,
   detectCategory,
   IdentityContext,
-  VasanaEngine,
   SvapnaConsolidation,
   VidhiEngine,
   AkashaField,
@@ -7725,4 +7545,4 @@ export {
   recall,
   loadProviderContext
 };
-//# sourceMappingURL=chunk-IIET2K6D.js.map
+//# sourceMappingURL=chunk-YSC77CKZ.js.map