@yugenlab/vaayu 0.1.2 → 0.1.3

package/chunks/{chunk-5Z2BKSFF.js → chunk-YSC77CKZ.js}

@@ -1,26 +1,30 @@
+import {
+  getDayFilePath,
+  listDayFiles
+} from "./chunk-7UOXFHEB.js";
 import {
   PRESERVATION_RATIOS,
   RecallEngine,
   STREAM_ORDER,
   StreamManager
-} from "./chunk-F35MWELH.js";
-import {
-  cosineSimilarity,
-  estimateTokens
-} from "./chunk-JAWZ7ANC.js";
+} from "./chunk-LVE2EOOH.js";
 import {
   createSession,
   listSessions,
   loadSession,
   saveSession
-} from "./chunk-2ARPXEDC.js";
+} from "./chunk-NHRBVSN3.js";
+import {
+  cosineSimilarity,
+  estimateTokens
+} from "./chunk-JAWZ7ANC.js";
 import {
   DatabaseManager
-} from "./chunk-UQLPHNGH.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 {
@@ -6932,16 +7269,16 @@ async function recall(query, options) {
 }
 async function searchHybrid(query, project, limit) {
   try {
-    const { HybridSearchEngine: HybridSearchEngine2 } = await import("./hybrid-search-6XMUT66S.js");
+    const { HybridSearchEngine: HybridSearchEngine2 } = await import("./hybrid-search-TX6T3KYH.js");
     let recallEngine = null;
     let graphEngine = null;
     try {
-      const { RecallEngine: RecallEngine2 } = await import("./recall-THTI6ZO2.js");
+      const { RecallEngine: RecallEngine2 } = await import("./recall-IUPQCBYP.js");
       recallEngine = new RecallEngine2();
     } catch {
     }
     try {
-      const { GraphRAGEngine: GraphRAGEngine2 } = await import("./graphrag-6YZ5YPLK.js");
+      const { GraphRAGEngine: GraphRAGEngine2 } = await import("./graphrag-LAZSXLLI.js");
       graphEngine = new GraphRAGEngine2();
     } catch {
     }
@@ -6979,8 +7316,8 @@ async function searchHybrid(query, project, limit) {
 }
 async function searchTurns(query, project) {
   try {
-    const { searchSessions: searchSessions2 } = await import("./search-V7DJ3VNL.js");
-    const { loadSession: loadSession2 } = await import("./session-store-GRKGTMHI.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)) {
@@ -7026,7 +7363,7 @@ async function searchTurns(query, project) {
 }
 async function searchMemoryLayer(query) {
   try {
-    const { searchMemory: searchMemory2 } = await import("./search-V7DJ3VNL.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),
@@ -7040,7 +7377,7 @@ async function searchMemoryLayer(query) {
 }
 async function searchDayFileLayer(query, limit) {
   try {
-    const { hierarchicalTemporalSearch: hierarchicalTemporalSearch2 } = await import("./hierarchical-temporal-search-VA4D3SON.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) => ({
@@ -7055,7 +7392,7 @@ async function searchDayFileLayer(query, limit) {
   } catch {
   }
   try {
-    const { searchDayFiles: searchDayFiles2 } = await import("./day-consolidation-GQ2FDCR2.js");
+    const { searchDayFiles: searchDayFiles2 } = await import("./day-consolidation-U3X6P4ZG.js");
     const results = searchDayFiles2(query, { limit });
     return results.map((r) => ({
       score: 0.5,
@@ -7086,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)";
@@ -7095,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)";
@@ -7105,7 +7442,7 @@ async function loadProviderContext(project, options) {
   }
   let vasanaContext = "";
   try {
-    const { VasanaEngine: VasanaEngine2 } = await import("./vasana-engine-Z4RXW2SB.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) {
@@ -7116,7 +7453,7 @@ async function loadProviderContext(project, options) {
   } catch {
   }
   try {
-    const { listSessions: listSessions2, loadSession: loadSession2 } = await import("./session-store-GRKGTMHI.js");
+    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) {
@@ -7169,6 +7506,11 @@ export {
   exportSessionToMarkdown,
   importSessionFromJson,
   detectExportFormat,
+  createCrossMachineSnapshot,
+  writeCrossMachineSnapshot,
+  readCrossMachineSnapshot,
+  getCrossMachineSyncStatus,
+  importCrossMachineSnapshot,
   branchSession,
   getSessionTree,
   sinkhornKnopp,
@@ -7203,4 +7545,4 @@ export {
   recall,
   loadProviderContext
 };
-//# sourceMappingURL=chunk-5Z2BKSFF.js.map
+//# sourceMappingURL=chunk-YSC77CKZ.js.map