@yugenlab/vaayu 0.1.10 → 0.1.12

package/chunks/{chunk-HIYHTWFW.js → chunk-FEDPZOZ5.js}

@@ -1,21 +1,23 @@
 import {
-  initAgentSchema
-} from "./chunk-YJRXLRTE.js";
+  initAgentSchema,
+  init_schema
+} from "./chunk-VEZ2DI2M.js";
 import {
-  DatabaseManager
-} from "./chunk-U62ABYKD.js";
+  DatabaseManager,
+  init_database
+} from "./chunk-H46F2Y6R.js";
 import {
   SessionError,
-  getChitraguptaHome
-} from "./chunk-UZ6OIVEC.js";
-
-// ../chitragupta/packages/smriti/src/session-store.ts
-import fs from "fs";
-import { renameSync as nodeRenameSync } from "node:fs";
-import path from "path";
-import crypto from "crypto";
+  getChitraguptaHome,
+  init_dist
+} from "./chunk-KVQH4LE7.js";
+import {
+  __esm,
+  __export,
+  __toCommonJS
+} from "./chunk-NAQKA54E.js";
 
-// ../chitragupta/packages/smriti/src/markdown-parser.ts
+// ../chitragupta/packages/smriti/dist/markdown-parser.js
 function parseFrontmatter(yaml) {
   const result = {};
   const lines = yaml.split("\n");
@@ -23,7 +25,8 @@ function parseFrontmatter(yaml) {
   let currentArray = null;
   for (const line of lines) {
     const trimmed = line.trim();
-    if (!trimmed || trimmed.startsWith("#")) continue;
+    if (!trimmed || trimmed.startsWith("#"))
+      continue;
     if (trimmed.startsWith("- ") && currentKey && currentArray !== null) {
       currentArray.push(trimmed.slice(2).trim());
       continue;
@@ -34,7 +37,8 @@ function parseFrontmatter(yaml) {
       currentKey = null;
     }
     const colonIdx = trimmed.indexOf(":");
-    if (colonIdx === -1) continue;
+    if (colonIdx === -1)
+      continue;
     const key = trimmed.slice(0, colonIdx).trim();
     const rawValue = trimmed.slice(colonIdx + 1).trim();
     if (rawValue === "" || rawValue === void 0) {
@@ -59,9 +63,12 @@ function parseFrontmatter(yaml) {
   return result;
 }
 function parseScalar(value) {
-  if (value === "null" || value === "~") return null;
-  if (value === "true") return true;
-  if (value === "false") return false;
+  if (value === "null" || value === "~")
+    return null;
+  if (value === "true")
+    return true;
+  if (value === "false")
+    return false;
   if (value.startsWith('"') && value.endsWith('"')) {
     return value.slice(1, -1).replace(/\\"/g, '"');
   }
@@ -69,7 +76,8 @@ function parseScalar(value) {
     return value.slice(1, -1);
   }
   const num = Number(value);
-  if (!Number.isNaN(num) && value !== "") return num;
+  if (!Number.isNaN(num) && value !== "")
+    return num;
   return value;
 }
 function parseSessionMarkdown(content) {
@@ -103,7 +111,8 @@ function buildSessionMeta(raw) {
   };
 }
 function parseTurns(body) {
-  if (!body) return [];
+  if (!body)
+    return [];
   body = stripFooter(body);
   const turnPattern = /^## Turn (\d+) — (user|assistant)(?:\s+\(([^)]*)\))?/gm;
   const turns = [];
@@ -129,8 +138,10 @@ function parseTurns(body) {
       const parts = m.meta.split(",").map((s) => s.trim());
       for (const part of parts) {
         const [k, v] = part.split(":").map((s) => s.trim());
-        if (k === "agent") agent = v;
-        if (k === "model") model = v;
+        if (k === "agent")
+          agent = v;
+        if (k === "model")
+          model = v;
       }
     }
     const { content, toolCalls } = parseContentAndToolCalls(rawContent);
@@ -140,9 +151,12 @@ function parseTurns(body) {
       role: m.role,
       content: unescapedContent
     };
-    if (agent) turn.agent = agent;
-    if (model) turn.model = model;
-    if (toolCalls.length > 0) turn.toolCalls = toolCalls;
+    if (agent)
+      turn.agent = agent;
+    if (model)
+      turn.model = model;
+    if (toolCalls.length > 0)
+      turn.toolCalls = toolCalls;
     turns.push(turn);
   }
   return turns;
@@ -193,11 +207,18 @@ function parseToolCallSection(name, section) {
     }
   }
   const toolCall = { name, input, result };
-  if (isError) toolCall.isError = true;
+  if (isError)
+    toolCall.isError = true;
   return toolCall;
 }
+var init_markdown_parser = __esm({
+  "../chitragupta/packages/smriti/dist/markdown-parser.js"() {
+    "use strict";
+    init_dist();
+  }
+});
 
-// ../chitragupta/packages/smriti/src/markdown-writer.ts
+// ../chitragupta/packages/smriti/dist/markdown-writer.js
 function writeFrontmatter(meta) {
   const lines = [];
   lines.push("---");
@@ -247,8 +268,10 @@ function writeTurn(turn) {
   const lines = [];
   let heading = `## Turn ${turn.turnNumber} \u2014 ${turn.role}`;
   const metaParts = [];
-  if (turn.agent) metaParts.push(`agent: ${turn.agent}`);
-  if (turn.model) metaParts.push(`model: ${turn.model}`);
+  if (turn.agent)
+    metaParts.push(`agent: ${turn.agent}`);
+  if (turn.model)
+    metaParts.push(`model: ${turn.model}`);
   if (metaParts.length > 0) {
     heading += ` (${metaParts.join(", ")})`;
   }
@@ -287,143 +310,24 @@ function writeSessionMarkdown(session) {
 function writeTurnMarkdown(turn) {
   return writeTurn(turn);
 }
-
-// ../chitragupta/packages/smriti/src/session-store.ts
-function atomicRename(tmpPath, targetPath) {
-  try {
-    nodeRenameSync(tmpPath, targetPath);
-  } catch {
-    fs.writeFileSync(targetPath, fs.readFileSync(tmpPath, "utf-8"), "utf-8");
-    try {
-      fs.unlinkSync(tmpPath);
-    } catch {
-    }
-  }
-}
-var SESSION_CACHE_MAX = 500;
-var SESSION_CACHE_MAX_BYTES = 25 * 1024 * 1024;
-var sessionCache = /* @__PURE__ */ new Map();
-var sessionCacheSizes = /* @__PURE__ */ new Map();
-var sessionCacheBytes = 0;
-function estimateSessionBytes(session) {
-  let bytes = 200;
-  for (const turn of session.turns) {
-    bytes += Buffer.byteLength(turn.content, "utf-8") + 50;
-  }
-  return bytes;
-}
-function cacheKey(id, project) {
-  return `${id}:${project}`;
-}
-function cacheGet(id, project) {
-  const key = cacheKey(id, project);
-  const entry = sessionCache.get(key);
-  if (!entry) return void 0;
-  const size = sessionCacheSizes.get(key) ?? 0;
-  sessionCache.delete(key);
-  sessionCacheSizes.delete(key);
-  sessionCache.set(key, entry);
-  sessionCacheSizes.set(key, size);
-  return entry;
-}
-function cachePut(id, project, session) {
-  const key = cacheKey(id, project);
-  const existingSize = sessionCacheSizes.get(key) ?? 0;
-  sessionCache.delete(key);
-  sessionCacheSizes.delete(key);
-  sessionCacheBytes -= existingSize;
-  const newSize = estimateSessionBytes(session);
-  while ((sessionCache.size >= SESSION_CACHE_MAX || sessionCacheBytes + newSize > SESSION_CACHE_MAX_BYTES) && sessionCache.size > 0) {
-    const oldest = sessionCache.keys().next().value;
-    if (oldest === void 0) break;
-    const evictedSize = sessionCacheSizes.get(oldest) ?? 0;
-    sessionCache.delete(oldest);
-    sessionCacheSizes.delete(oldest);
-    sessionCacheBytes -= evictedSize;
+var init_markdown_writer = __esm({
+  "../chitragupta/packages/smriti/dist/markdown-writer.js"() {
+    "use strict";
   }
-  sessionCache.set(key, session);
-  sessionCacheSizes.set(key, newSize);
-  sessionCacheBytes += newSize;
-}
-function cacheInvalidate(id, project) {
-  const key = cacheKey(id, project);
-  const size = sessionCacheSizes.get(key) ?? 0;
-  sessionCache.delete(key);
-  sessionCacheSizes.delete(key);
-  sessionCacheBytes -= size;
-}
-function _resetSessionCache() {
-  sessionCache.clear();
-  sessionCacheSizes.clear();
-  sessionCacheBytes = 0;
-}
+});
+
+// ../chitragupta/packages/smriti/dist/session-db.js
+import path from "path";
+import crypto from "crypto";
 function hashProject(project) {
   return crypto.createHash("sha256").update(project).digest("hex").slice(0, 12);
 }
-function generateSessionId(project) {
-  const now = /* @__PURE__ */ new Date();
-  const yyyy = now.getFullYear().toString();
-  const mm = (now.getMonth() + 1).toString().padStart(2, "0");
-  const dd = now.getDate().toString().padStart(2, "0");
-  const dateStr = `${yyyy}-${mm}-${dd}`;
-  const projHash = hashProject(project).slice(0, 8);
-  const baseId = `session-${dateStr}-${projHash}`;
-  const projectDir = getProjectSessionDir(project);
-  const yearMonthDir = path.join(projectDir, yyyy, mm);
-  fs.mkdirSync(yearMonthDir, { recursive: true });
-  const basePath = path.join(yearMonthDir, `${baseId}.md`);
-  if (!fs.existsSync(basePath)) {
-    return {
-      id: baseId,
-      filePath: path.join("sessions", hashProject(project), yyyy, mm, `${baseId}.md`)
-    };
-  }
-  let counter = 2;
-  while (fs.existsSync(path.join(yearMonthDir, `${baseId}-${counter}.md`))) {
-    counter++;
-  }
-  const id = `${baseId}-${counter}`;
-  return {
-    id,
-    filePath: path.join("sessions", hashProject(project), yyyy, mm, `${id}.md`)
-  };
-}
 function getSessionsRoot() {
   return path.join(getChitraguptaHome(), "sessions");
 }
 function getProjectSessionDir(project) {
   return path.join(getSessionsRoot(), hashProject(project));
 }
-function resolveSessionPath(id, project) {
-  const projectDir = getProjectSessionDir(project);
-  const dateMatch = id.match(/^session-(\d{4})-(\d{2})-\d{2}/);
-  if (dateMatch) {
-    const newPath = path.join(projectDir, dateMatch[1], dateMatch[2], `${id}.md`);
-    if (fs.existsSync(newPath)) return newPath;
-  }
-  const oldPath = path.join(projectDir, `${id}.md`);
-  if (fs.existsSync(oldPath)) return oldPath;
-  if (dateMatch) {
-    return path.join(projectDir, dateMatch[1], dateMatch[2], `${id}.md`);
-  }
-  return oldPath;
-}
-function patchFrontmatterUpdated(content, updatedIso) {
-  const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
-  if (!fmMatch) return content;
-  const frontmatter = fmMatch[1];
-  if (!/^updated:\s/m.test(frontmatter)) return content;
-  const patchedFrontmatter = frontmatter.replace(
-    /^updated:\s.*$/m,
-    `updated: ${updatedIso}`
-  );
-  if (patchedFrontmatter === frontmatter) return content;
-  return `---
-${patchedFrontmatter}
----${content.slice(fmMatch[0].length)}`;
-}
-var _dbInitialized = false;
-var _dbInitError = null;
 function getAgentDb() {
   const dbm = DatabaseManager.instance();
   if (!_dbInitialized) {
@@ -517,7 +421,8 @@ function upsertSessionToDb(meta, filePath) {
   }
 }
 function isRecoverableSessionConstraintError(err) {
-  if (!(err instanceof Error)) return false;
+  if (!(err instanceof Error))
+    return false;
   const lower = err.message.toLowerCase();
   return lower.includes("foreign key constraint failed") || lower.includes("constraint failed");
 }
@@ -528,43 +433,21 @@ function seedSessionRowForTurn(sessionId, project, filePath) {
   db.prepare(`
 		INSERT OR IGNORE INTO sessions (id, project, title, created_at, updated_at, turn_count, file_path)
 		VALUES (?, ?, ?, ?, ?, ?, ?)
-	`).run(
-    sessionId,
-    project,
-    "Recovered Session",
-    now,
-    now,
-    0,
-    normalizedFilePath
-  );
+	`).run(sessionId, project, "Recovered Session", now, now, 0, normalizedFilePath);
 }
 function insertTurnToDb(sessionId, turn, context) {
   try {
     const db = getAgentDb();
+    const now = Date.now();
     const writeTurn2 = db.transaction(() => {
-      const now = Date.now();
       const result = db.prepare(`
 				INSERT OR IGNORE INTO turns (session_id, turn_number, role, content, agent, model, tool_calls, created_at)
 				VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-			`).run(
-        sessionId,
-        turn.turnNumber,
-        turn.role,
-        turn.content,
-        turn.agent ?? null,
-        turn.model ?? null,
-        turn.toolCalls ? JSON.stringify(turn.toolCalls) : null,
-        now
-      );
+			`).run(sessionId, turn.turnNumber, turn.role, turn.content, turn.agent ?? null, turn.model ?? null, turn.toolCalls ? JSON.stringify(turn.toolCalls) : null, now);
       if (result.changes > 0) {
-        db.prepare("INSERT OR IGNORE INTO turns_fts (rowid, content) VALUES (?, ?)").run(
-          result.lastInsertRowid,
-          turn.content
-        );
+        db.prepare("INSERT OR IGNORE INTO turns_fts (rowid, content) VALUES (?, ?)").run(result.lastInsertRowid, turn.content);
       }
-      db.prepare(
-        "UPDATE sessions SET turn_count = turn_count + 1, updated_at = ? WHERE id = ?"
-      ).run(now, sessionId);
+      db.prepare("UPDATE sessions SET turn_count = turn_count + 1, updated_at = ? WHERE id = ?").run(now, sessionId);
     });
     try {
       writeTurn2();
@@ -579,87 +462,155 @@ function insertTurnToDb(sessionId, turn, context) {
     }
   } catch (err) {
     const code = typeof err === "object" && err !== null && "code" in err ? String(err.code) : "unknown";
-    process.stderr.write(
-      `[chitragupta] turn insert failed for session ${sessionId} (turn=${turn.turnNumber}, role=${turn.role}, code=${code}): ${err instanceof Error ? err.message : err}
-`
-    );
+    process.stderr.write(`[chitragupta] turn insert failed for session ${sessionId} (turn=${turn.turnNumber}, role=${turn.role}, code=${code}): ${err instanceof Error ? err.message : err}
+`);
   }
 }
-function createSession(opts) {
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const { id, filePath } = generateSessionId(opts.project);
-  const meta = {
-    id,
-    title: opts.title ?? "New Session",
-    created: now,
-    updated: now,
-    agent: opts.agent ?? "chitragupta",
-    model: opts.model ?? "unknown",
-    provider: opts.provider,
-    project: opts.project,
-    parent: opts.parentSessionId ?? null,
-    branch: opts.branch ?? null,
-    tags: opts.tags ?? [],
-    totalCost: 0,
-    totalTokens: 0,
-    metadata: opts.metadata
-  };
-  if (opts.provider) {
-    meta.metadata = { ...meta.metadata, provider: opts.provider };
+function getMaxTurnNumber(sessionId) {
+  try {
+    const db = getAgentDb();
+    const row = db.prepare("SELECT MAX(turn_number) as max_turn FROM turns WHERE session_id = ?").get(sessionId);
+    return row?.max_turn ?? 0;
+  } catch {
+    return 0;
   }
-  const session = { meta, turns: [] };
-  saveSession(session);
-  upsertSessionToDb(meta, filePath);
-  return session;
 }
-function saveSession(session) {
-  const filePath = resolveSessionPath(session.meta.id, session.meta.project);
-  const dir = path.dirname(filePath);
-  try {
-    fs.mkdirSync(dir, { recursive: true });
-    session.meta.updated = (/* @__PURE__ */ new Date()).toISOString();
-    const markdown = writeSessionMarkdown(session);
-    const tmpPath = `${filePath}.tmp.${process.pid}`;
-    fs.writeFileSync(tmpPath, markdown, "utf-8");
-    atomicRename(tmpPath, filePath);
-    cachePut(session.meta.id, session.meta.project, session);
-  } catch (err) {
-    throw new SessionError(
-      `Failed to save session ${session.meta.id} at ${filePath}: ${err.message}`
-    );
+var _dbInitialized, _dbInitError;
+var init_session_db = __esm({
+  "../chitragupta/packages/smriti/dist/session-db.js"() {
+    "use strict";
+    init_dist();
+    init_database();
+    init_schema();
+    _dbInitialized = false;
+    _dbInitError = null;
+  }
+});
+
+// ../chitragupta/packages/smriti/dist/session-store-cache.js
+function estimateSessionBytes(session) {
+  let bytes = 200;
+  for (const turn of session.turns) {
+    bytes += Buffer.byteLength(turn.content, "utf-8") + 50;
   }
+  return bytes;
 }
-function loadSession(id, project) {
-  const cached = cacheGet(id, project);
-  if (cached) return cached;
-  const filePath = resolveSessionPath(id, project);
-  if (!fs.existsSync(filePath)) {
-    throw new SessionError(`Session not found: ${id} (project: ${project})`);
+function cacheKey(id, project) {
+  return `${id}:${project}`;
+}
+function cacheGet(id, project) {
+  const key = cacheKey(id, project);
+  const entry = sessionCache.get(key);
+  if (!entry)
+    return void 0;
+  const size = sessionCacheSizes.get(key) ?? 0;
+  sessionCache.delete(key);
+  sessionCacheSizes.delete(key);
+  sessionCache.set(key, entry);
+  sessionCacheSizes.set(key, size);
+  return entry;
+}
+function cachePut(id, project, session) {
+  const key = cacheKey(id, project);
+  const existingSize = sessionCacheSizes.get(key) ?? 0;
+  sessionCache.delete(key);
+  sessionCacheSizes.delete(key);
+  sessionCacheBytes -= existingSize;
+  const newSize = estimateSessionBytes(session);
+  while ((sessionCache.size >= SESSION_CACHE_MAX || sessionCacheBytes + newSize > SESSION_CACHE_MAX_BYTES) && sessionCache.size > 0) {
+    const oldest = sessionCache.keys().next().value;
+    if (oldest === void 0)
+      break;
+    const evictedSize = sessionCacheSizes.get(oldest) ?? 0;
+    sessionCache.delete(oldest);
+    sessionCacheSizes.delete(oldest);
+    sessionCacheBytes -= evictedSize;
+  }
+  sessionCache.set(key, session);
+  sessionCacheSizes.set(key, newSize);
+  sessionCacheBytes += newSize;
+}
+function cacheInvalidate(id, project) {
+  const key = cacheKey(id, project);
+  const size = sessionCacheSizes.get(key) ?? 0;
+  sessionCache.delete(key);
+  sessionCacheSizes.delete(key);
+  sessionCacheBytes -= size;
+}
+function _resetSessionCache() {
+  sessionCache.clear();
+  sessionCacheSizes.clear();
+  sessionCacheBytes = 0;
+}
+var SESSION_CACHE_MAX, SESSION_CACHE_MAX_BYTES, sessionCache, sessionCacheSizes, sessionCacheBytes;
+var init_session_store_cache = __esm({
+  "../chitragupta/packages/smriti/dist/session-store-cache.js"() {
+    "use strict";
+    SESSION_CACHE_MAX = 500;
+    SESSION_CACHE_MAX_BYTES = 25 * 1024 * 1024;
+    sessionCache = /* @__PURE__ */ new Map();
+    sessionCacheSizes = /* @__PURE__ */ new Map();
+    sessionCacheBytes = 0;
+  }
+});
+
+// ../chitragupta/packages/smriti/dist/session-queries.js
+import fs from "fs";
+import path2 from "path";
+function listSessionsFromFilesystem(project) {
+  const sessionsRoot = getSessionsRoot();
+  if (!fs.existsSync(sessionsRoot))
+    return [];
+  const results = [];
+  if (project) {
+    const projectDir = getProjectSessionDir(project);
+    if (!fs.existsSync(projectDir))
+      return [];
+    results.push(...scanDirRecursive(projectDir));
+  } else {
+    const projectDirs = fs.readdirSync(sessionsRoot, { withFileTypes: true });
+    for (const entry of projectDirs) {
+      if (entry.isDirectory()) {
+        results.push(...scanDirRecursive(path2.join(sessionsRoot, entry.name)));
+      }
+    }
   }
+  results.sort((a, b) => new Date(b.updated).getTime() - new Date(a.updated).getTime());
+  return results;
+}
+function scanDirRecursive(dir) {
+  const metas = [];
   try {
-    const content = fs.readFileSync(filePath, "utf-8");
-    const session = parseSessionMarkdown(content);
-    cachePut(id, project, session);
-    return session;
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path2.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        metas.push(...scanDirRecursive(fullPath));
+      } else if (entry.name.endsWith(".md")) {
+        try {
+          const content = fs.readFileSync(fullPath, "utf-8");
+          const session = parseSessionMarkdown(content);
+          metas.push(session.meta);
+        } catch (err) {
+          process.stderr.write(`[smriti:session-queries] skip unparseable file ${fullPath}: ${err instanceof Error ? err.message : String(err)}
+`);
+        }
+      }
+    }
   } catch (err) {
-    if (err instanceof SessionError) throw err;
-    throw new SessionError(
-      `Failed to load session ${id}: ${err.message}`
-    );
+    process.stderr.write(`[smriti:session-queries] directory scan failed for ${dir}: ${err instanceof Error ? err.message : String(err)}
+`);
   }
+  return metas;
 }
 function listSessions(project) {
   try {
     const db = getAgentDb();
     let rows;
     if (project) {
-      rows = db.prepare(
-        "SELECT * FROM sessions WHERE project = ? ORDER BY updated_at DESC"
-      ).all(project);
+      rows = db.prepare("SELECT * FROM sessions WHERE project = ? ORDER BY updated_at DESC").all(project);
     } else {
-      rows = db.prepare(
-        "SELECT * FROM sessions ORDER BY updated_at DESC"
-      ).all();
+      rows = db.prepare("SELECT * FROM sessions ORDER BY updated_at DESC").all();
     }
     if (rows.length > 0) {
       return rows.map(rowToSessionMeta);
@@ -684,18 +635,16 @@ function listSessionsByDateRange(startMs, endMs, project) {
     const db = getAgentDb();
     let rows;
     if (project) {
-      rows = db.prepare(
-        "SELECT * FROM sessions WHERE project = ? AND created_at >= ? AND created_at < ? ORDER BY created_at ASC"
-      ).all(project, startMs, endMs);
+      rows = db.prepare("SELECT * FROM sessions WHERE project = ? AND created_at >= ? AND created_at < ? ORDER BY created_at ASC").all(project, startMs, endMs);
     } else {
-      rows = db.prepare(
-        "SELECT * FROM sessions WHERE created_at >= ? AND created_at < ? ORDER BY created_at ASC"
-      ).all(startMs, endMs);
+      rows = db.prepare("SELECT * FROM sessions WHERE created_at >= ? AND created_at < ? ORDER BY created_at ASC").all(startMs, endMs);
     }
     if (rows.length > 0) {
       return rows.map(rowToSessionMeta);
     }
-  } catch {
+  } catch (err) {
+    process.stderr.write(`[smriti:session-queries] listSessionsByDateRange SQLite failed: ${err instanceof Error ? err.message : String(err)}
+`);
   }
   const allSessions = listSessionsFromFilesystem(project);
   return allSessions.filter((s) => {
@@ -708,20 +657,18 @@ function listSessionDates(project) {
     const db = getAgentDb();
     let rows;
     if (project) {
-      rows = db.prepare(
-        `SELECT DISTINCT date(created_at / 1000, 'unixepoch') as session_date
+      rows = db.prepare(`SELECT DISTINCT date(created_at / 1000, 'unixepoch') as session_date
 				 FROM sessions WHERE project = ?
-				 ORDER BY session_date DESC`
-      ).all(project);
+				 ORDER BY session_date DESC`).all(project);
     } else {
-      rows = db.prepare(
-        `SELECT DISTINCT date(created_at / 1000, 'unixepoch') as session_date
+      rows = db.prepare(`SELECT DISTINCT date(created_at / 1000, 'unixepoch') as session_date
 				 FROM sessions
-				 ORDER BY session_date DESC`
-      ).all();
+				 ORDER BY session_date DESC`).all();
     }
     return rows.map((r) => r.session_date).filter(Boolean);
-  } catch {
+  } catch (err) {
+    process.stderr.write(`[smriti:session-queries] listSessionDates SQLite failed: ${err instanceof Error ? err.message : String(err)}
+`);
     const allSessions = listSessionsFromFilesystem(project);
     const dates = /* @__PURE__ */ new Set();
     for (const s of allSessions) {
@@ -733,139 +680,25 @@ function listSessionDates(project) {
 function listSessionProjects() {
   try {
     const db = getAgentDb();
-    const rows = db.prepare(
-      `SELECT project, COUNT(*) as count, MAX(updated_at) as last_active
+    const rows = db.prepare(`SELECT project, COUNT(*) as count, MAX(updated_at) as last_active
 			 FROM sessions
 			 GROUP BY project
-			 ORDER BY last_active DESC`
-    ).all();
+			 ORDER BY last_active DESC`).all();
     return rows.map((r) => ({
       project: r.project,
       sessionCount: r.count,
       lastActive: new Date(r.last_active).toISOString()
     }));
-  } catch {
+  } catch (err) {
+    process.stderr.write(`[smriti:session-queries] listSessionProjects SQLite failed: ${err instanceof Error ? err.message : String(err)}
+`);
     return [];
   }
 }
-function listSessionsFromFilesystem(project) {
-  const sessionsRoot = getSessionsRoot();
-  if (!fs.existsSync(sessionsRoot)) return [];
-  const results = [];
-  if (project) {
-    const projectDir = getProjectSessionDir(project);
-    if (!fs.existsSync(projectDir)) return [];
-    results.push(...scanDirRecursive(projectDir));
-  } else {
-    const projectDirs = fs.readdirSync(sessionsRoot, { withFileTypes: true });
-    for (const entry of projectDirs) {
-      if (entry.isDirectory()) {
-        results.push(...scanDirRecursive(path.join(sessionsRoot, entry.name)));
-      }
-    }
-  }
-  results.sort((a, b) => new Date(b.updated).getTime() - new Date(a.updated).getTime());
-  return results;
-}
-function scanDirRecursive(dir) {
-  const metas = [];
-  try {
-    const entries = fs.readdirSync(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      const fullPath = path.join(dir, entry.name);
-      if (entry.isDirectory()) {
-        metas.push(...scanDirRecursive(fullPath));
-      } else if (entry.name.endsWith(".md")) {
-        try {
-          const content = fs.readFileSync(fullPath, "utf-8");
-          const session = parseSessionMarkdown(content);
-          metas.push(session.meta);
-        } catch {
-        }
-      }
-    }
-  } catch {
-  }
-  return metas;
-}
-function deleteSession(id, project) {
-  const filePath = resolveSessionPath(id, project);
-  if (!fs.existsSync(filePath)) {
-    throw new SessionError(`Session not found: ${id} (project: ${project})`);
-  }
-  fs.unlinkSync(filePath);
-  cacheInvalidate(id, project);
-  let dir = path.dirname(filePath);
-  const sessionsRoot = getSessionsRoot();
-  while (dir !== sessionsRoot && dir.length > sessionsRoot.length) {
-    try {
-      const remaining = fs.readdirSync(dir);
-      if (remaining.length === 0) {
-        fs.rmdirSync(dir);
-        dir = path.dirname(dir);
-      } else {
-        break;
-      }
-    } catch {
-      break;
-    }
-  }
-  try {
-    const db = getAgentDb();
-    const turns = db.prepare("SELECT id FROM turns WHERE session_id = ?").all(id);
-    for (const t of turns) {
-      db.prepare("DELETE FROM turns_fts WHERE rowid = ?").run(t.id);
-    }
-    db.prepare("DELETE FROM turns WHERE session_id = ?").run(id);
-    db.prepare("DELETE FROM sessions WHERE id = ?").run(id);
-  } catch {
-  }
-}
-var sessionWriteQueues = /* @__PURE__ */ new Map();
-function addTurn(sessionId, project, turn) {
-  const key = `${sessionId}:${project}`;
-  const prev = sessionWriteQueues.get(key) ?? Promise.resolve();
-  const next = prev.then(() => {
-    const filePath = resolveSessionPath(sessionId, project);
-    if (!fs.existsSync(filePath)) {
-      throw new SessionError(`Session not found: ${sessionId} (project: ${project})`);
-    }
-    const fileContent = fs.readFileSync(filePath, "utf-8");
-    if (!turn.turnNumber) {
-      try {
-        const session = parseSessionMarkdown(fileContent);
-        turn.turnNumber = session.turns.length + 1;
-      } catch {
-        turn.turnNumber = getMaxTurnNumber(sessionId) + 1;
-      }
-    }
-    const updatedIso = (/* @__PURE__ */ new Date()).toISOString();
-    const patchedContent = patchFrontmatterUpdated(fileContent, updatedIso);
-    if (patchedContent !== fileContent) {
-      fs.writeFileSync(filePath, patchedContent, "utf-8");
-    }
-    const turnMd = writeTurnMarkdown(turn);
-    fs.appendFileSync(filePath, `
-${turnMd}
-`, "utf-8");
-    cacheInvalidate(sessionId, project);
-    insertTurnToDb(sessionId, turn, { project, filePath });
-  }).catch((err) => {
-    throw err;
-  }).finally(() => {
-    if (sessionWriteQueues.get(key) === next) {
-      sessionWriteQueues.delete(key);
-    }
-  });
-  sessionWriteQueues.set(key, next);
-  return next;
-}
 function listTurnsWithTimestamps(sessionId, project) {
   try {
     const db = getAgentDb();
-    const rows = db.prepare(
-      "SELECT turn_number, role, content, agent, model, tool_calls, created_at FROM turns WHERE session_id = ? ORDER BY turn_number ASC"
-    ).all(sessionId);
+    const rows = db.prepare("SELECT turn_number, role, content, agent, model, tool_calls, created_at FROM turns WHERE session_id = ? ORDER BY turn_number ASC").all(sessionId);
     if (rows.length > 0) {
       return rows.map((row) => ({
         turnNumber: row.turn_number,
@@ -877,17 +710,67 @@ function listTurnsWithTimestamps(sessionId, project) {
         createdAt: row.created_at
       }));
     }
-  } catch {
+  } catch (err) {
+    process.stderr.write(`[smriti:session-queries] listTurnsWithTimestamps SQLite failed: ${err instanceof Error ? err.message : String(err)}
+`);
   }
   try {
-    const session = loadSession(sessionId, project);
+    const { loadSession: loadSession2 } = (init_session_store(), __toCommonJS(session_store_exports));
+    const session = loadSession2(sessionId, project);
     const baseTime = new Date(session.meta.created).getTime();
     return session.turns.map((turn, i) => ({
       ...turn,
       createdAt: baseTime + i * 1e3
       // 1-second spacing
     }));
-  } catch {
+  } catch (err) {
+    process.stderr.write(`[smriti:session-queries] listTurnsWithTimestamps markdown fallback failed: ${err instanceof Error ? err.message : String(err)}
+`);
+    return [];
+  }
+}
+function findSessionByMetadata(key, value, project) {
+  if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(key)) {
+    return void 0;
+  }
+  try {
+    const db = getAgentDb();
+    const sql = project ? "SELECT * FROM sessions WHERE project = ? AND json_extract(metadata, ?) = ? LIMIT 1" : "SELECT * FROM sessions WHERE json_extract(metadata, ?) = ? LIMIT 1";
+    const params = project ? [project, `$.${key}`, value] : [`$.${key}`, value];
+    const row = db.prepare(sql).get(...params);
+    return row ? rowToSessionMeta(row) : void 0;
+  } catch (err) {
+    process.stderr.write(`[smriti:session-queries] findSessionByMetadata failed: ${err instanceof Error ? err.message : String(err)}
+`);
+    return void 0;
+  }
+}
+function getTurnsSince(sessionId, sinceTurnNumber) {
+  try {
+    const db = getAgentDb();
+    const rows = db.prepare("SELECT turn_number, role, content, agent, model, tool_calls FROM turns WHERE session_id = ? AND turn_number > ? ORDER BY turn_number ASC").all(sessionId, sinceTurnNumber);
+    return rows.map((row) => ({
+      turnNumber: row.turn_number,
+      role: row.role,
+      content: row.content,
+      agent: row.agent ?? void 0,
+      model: row.model ?? void 0,
+      toolCalls: row.tool_calls ? JSON.parse(row.tool_calls) : void 0
+    }));
+  } catch (err) {
+    process.stderr.write(`[smriti:session-queries] getTurnsSince SQLite failed: ${err instanceof Error ? err.message : String(err)}
+`);
+    return [];
+  }
+}
+function getSessionsModifiedSince(project, sinceMs) {
+  try {
+    const db = getAgentDb();
+    const rows = db.prepare("SELECT * FROM sessions WHERE project = ? AND updated_at > ? ORDER BY updated_at ASC").all(project, sinceMs);
+    return rows.map(rowToSessionMeta);
+  } catch (err) {
+    process.stderr.write(`[smriti:session-queries] getSessionsModifiedSince SQLite failed: ${err instanceof Error ? err.message : String(err)}
+`);
     return [];
   }
 }
@@ -912,43 +795,37 @@ function updateSessionMeta(sessionId, updates) {
       sets.push("tags = @tags");
       params.tags = JSON.stringify(updates.tags);
     }
-    if (sets.length === 0) return;
+    if (sets.length === 0)
+      return;
     sets.push("updated_at = @updated_at");
     params.updated_at = Date.now();
     db.prepare(`UPDATE sessions SET ${sets.join(", ")} WHERE id = @id`).run(params);
-  } catch {
-  }
-}
-function getMaxTurnNumber(sessionId) {
-  try {
-    const db = getAgentDb();
-    const row = db.prepare("SELECT MAX(turn_number) as max_turn FROM turns WHERE session_id = ?").get(sessionId);
-    return row?.max_turn ?? 0;
-  } catch {
-    return 0;
+  } catch (err) {
+    process.stderr.write(`[smriti:session-queries] updateSessionMeta failed for ${sessionId}: ${err instanceof Error ? err.message : String(err)}
+`);
   }
 }
-function findSessionByMetadata(key, value, project) {
-  if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(key)) {
-    return void 0;
-  }
-  try {
-    const db = getAgentDb();
-    const sql = project ? "SELECT * FROM sessions WHERE project = ? AND json_extract(metadata, ?) = ? LIMIT 1" : "SELECT * FROM sessions WHERE json_extract(metadata, ?) = ? LIMIT 1";
-    const params = project ? [project, `$.${key}`, value] : [`$.${key}`, value];
-    const row = db.prepare(sql).get(...params);
-    return row ? rowToSessionMeta(row) : void 0;
-  } catch {
-    return void 0;
+var init_session_queries = __esm({
+  "../chitragupta/packages/smriti/dist/session-queries.js"() {
+    "use strict";
+    init_dist();
+    init_markdown_parser();
+    init_session_db();
+    init_session_db();
   }
-}
+});
+
+// ../chitragupta/packages/smriti/dist/session-store-migration.js
+import fs2 from "fs";
+import path3 from "path";
 function migrateExistingSessions(project) {
   const db = getAgentDb();
   const sessionsRoot = getSessionsRoot();
-  if (!fs.existsSync(sessionsRoot)) return { migrated: 0, skipped: 0 };
+  if (!fs2.existsSync(sessionsRoot))
+    return { migrated: 0, skipped: 0 };
   let migrated = 0;
   let skipped = 0;
-  const dirs = project ? [getProjectSessionDir(project)] : fs.readdirSync(sessionsRoot, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => path.join(sessionsRoot, e.name));
+  const dirs = project ? [getProjectSessionDir(project)] : fs2.readdirSync(sessionsRoot, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => path3.join(sessionsRoot, e.name));
   const insertSession = db.prepare(`
 		INSERT OR IGNORE INTO sessions (id, project, title, created_at, updated_at, turn_count, model, agent, cost, tokens, tags, file_path, parent_id, branch, metadata)
 		VALUES (@id, @project, @title, @created_at, @updated_at, @turn_count, @model, @agent, @cost, @tokens, @tags, @file_path, @parent_id, @branch, @metadata)
@@ -957,12 +834,10 @@ function migrateExistingSessions(project) {
 		INSERT OR IGNORE INTO turns (session_id, turn_number, role, content, agent, model, tool_calls, created_at)
 		VALUES (?, ?, ?, ?, ?, ?, ?, ?)
 	`);
-  const insertFts = db.prepare(
-    "INSERT INTO turns_fts (rowid, content) VALUES (?, ?)"
-  );
+  const insertFts = db.prepare("INSERT INTO turns_fts (rowid, content) VALUES (?, ?)");
   const migrateFile = (mdPath, relativePath) => {
     try {
-      const content = fs.readFileSync(mdPath, "utf-8");
+      const content = fs2.readFileSync(mdPath, "utf-8");
       const session = parseSessionMarkdown(content);
       const existing = db.prepare("SELECT id FROM sessions WHERE id = ?").get(session.meta.id);
       if (existing) {
@@ -973,16 +848,7 @@ function migrateExistingSessions(project) {
       row.turn_count = session.turns.length;
       insertSession.run(row);
       for (const turn of session.turns) {
-        const result = insertTurn.run(
-          session.meta.id,
-          turn.turnNumber,
-          turn.role,
-          turn.content,
-          turn.agent ?? null,
-          turn.model ?? null,
-          turn.toolCalls ? JSON.stringify(turn.toolCalls) : null,
-          new Date(session.meta.created).getTime()
-        );
+        const result = insertTurn.run(session.meta.id, turn.turnNumber, turn.role, turn.content, turn.agent ?? null, turn.model ?? null, turn.toolCalls ? JSON.stringify(turn.toolCalls) : null, new Date(session.meta.created).getTime());
         if (result.changes > 0) {
           insertFts.run(result.lastInsertRowid, turn.content);
         }
@@ -994,7 +860,8 @@ function migrateExistingSessions(project) {
   };
   const runMigration = db.transaction(() => {
     for (const dir of dirs) {
-      if (!fs.existsSync(dir)) continue;
+      if (!fs2.existsSync(dir))
+        continue;
       walkMdFiles(dir, sessionsRoot, migrateFile);
     }
   });
@@ -1003,41 +870,305 @@ function migrateExistingSessions(project) {
 }
 function walkMdFiles(dir, sessionsRoot, callback) {
   try {
-    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    const entries = fs2.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path.join(dir, entry.name);
+      const fullPath = path3.join(dir, entry.name);
       if (entry.isDirectory()) {
         walkMdFiles(fullPath, sessionsRoot, callback);
       } else if (entry.name.endsWith(".md")) {
-        const relativePath = path.relative(path.dirname(sessionsRoot), fullPath);
+        const relativePath = path3.relative(path3.dirname(sessionsRoot), fullPath);
         callback(fullPath, relativePath);
       }
     }
   } catch {
   }
 }
+var init_session_store_migration = __esm({
+  "../chitragupta/packages/smriti/dist/session-store-migration.js"() {
+    "use strict";
+    init_markdown_parser();
+    init_session_db();
+  }
+});
+
+// ../chitragupta/packages/smriti/dist/session-store.js
+var session_store_exports = {};
+__export(session_store_exports, {
+  _getDbStatus: () => _getDbStatus,
+  _resetDbInit: () => _resetDbInit,
+  _resetSessionCache: () => _resetSessionCache,
+  addTurn: () => addTurn,
+  createSession: () => createSession,
+  deleteSession: () => deleteSession,
+  findSessionByMetadata: () => findSessionByMetadata,
+  getMaxTurnNumber: () => getMaxTurnNumber,
+  getSessionsModifiedSince: () => getSessionsModifiedSince,
+  getTurnsSince: () => getTurnsSince,
+  listSessionDates: () => listSessionDates,
+  listSessionProjects: () => listSessionProjects,
+  listSessions: () => listSessions,
+  listSessionsByDate: () => listSessionsByDate,
+  listSessionsByDateRange: () => listSessionsByDateRange,
+  listTurnsWithTimestamps: () => listTurnsWithTimestamps,
+  loadSession: () => loadSession,
+  migrateExistingSessions: () => migrateExistingSessions,
+  saveSession: () => saveSession,
+  updateSessionMeta: () => updateSessionMeta
+});
+import fs3 from "fs";
+import { renameSync as nodeRenameSync } from "node:fs";
+import path4 from "path";
+function atomicRename(tmpPath, targetPath) {
+  try {
+    nodeRenameSync(tmpPath, targetPath);
+  } catch (err) {
+    if (!process.env.VITEST) {
+      process.stderr.write(`[smriti:session-store] atomic rename failed, using direct write: ${err instanceof Error ? err.message : String(err)}
+`);
+    }
+    fs3.writeFileSync(targetPath, fs3.readFileSync(tmpPath, "utf-8"), "utf-8");
+    try {
+      fs3.unlinkSync(tmpPath);
+    } catch {
+    }
+  }
+}
+function generateSessionId(project) {
+  const now = /* @__PURE__ */ new Date();
+  const yyyy = now.getFullYear().toString();
+  const mm = (now.getMonth() + 1).toString().padStart(2, "0");
+  const dd = now.getDate().toString().padStart(2, "0");
+  const dateStr = `${yyyy}-${mm}-${dd}`;
+  const projHash = hashProject(project).slice(0, 8);
+  const baseId = `session-${dateStr}-${projHash}`;
+  const projectDir = getProjectSessionDir(project);
+  const yearMonthDir = path4.join(projectDir, yyyy, mm);
+  fs3.mkdirSync(yearMonthDir, { recursive: true });
+  const basePath = path4.join(yearMonthDir, `${baseId}.md`);
+  if (!fs3.existsSync(basePath)) {
+    return {
+      id: baseId,
+      filePath: path4.join("sessions", hashProject(project), yyyy, mm, `${baseId}.md`)
+    };
+  }
+  let counter = 2;
+  while (fs3.existsSync(path4.join(yearMonthDir, `${baseId}-${counter}.md`))) {
+    counter++;
+  }
+  const id = `${baseId}-${counter}`;
+  return {
+    id,
+    filePath: path4.join("sessions", hashProject(project), yyyy, mm, `${id}.md`)
+  };
+}
+function resolveSessionPath(id, project) {
+  const projectDir = getProjectSessionDir(project);
+  const dateMatch = id.match(/^session-(\d{4})-(\d{2})-\d{2}/);
+  if (dateMatch) {
+    const newPath = path4.join(projectDir, dateMatch[1], dateMatch[2], `${id}.md`);
+    if (fs3.existsSync(newPath))
+      return newPath;
+  }
+  const oldPath = path4.join(projectDir, `${id}.md`);
+  if (fs3.existsSync(oldPath))
+    return oldPath;
+  if (dateMatch) {
+    return path4.join(projectDir, dateMatch[1], dateMatch[2], `${id}.md`);
+  }
+  return oldPath;
+}
+function patchFrontmatterUpdated(content, updatedIso) {
+  const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!fmMatch)
+    return content;
+  const frontmatter = fmMatch[1];
+  if (!/^updated:\s/m.test(frontmatter))
+    return content;
+  const patchedFrontmatter = frontmatter.replace(/^updated:\s.*$/m, `updated: ${updatedIso}`);
+  if (patchedFrontmatter === frontmatter)
+    return content;
+  return `---
+${patchedFrontmatter}
+---${content.slice(fmMatch[0].length)}`;
+}
+function createSession(opts) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const { id, filePath } = generateSessionId(opts.project);
+  const meta = {
+    id,
+    title: opts.title ?? "New Session",
+    created: now,
+    updated: now,
+    agent: opts.agent ?? "chitragupta",
+    model: opts.model ?? "unknown",
+    provider: opts.provider,
+    project: opts.project,
+    parent: opts.parentSessionId ?? null,
+    branch: opts.branch ?? null,
+    tags: opts.tags ?? [],
+    totalCost: 0,
+    totalTokens: 0,
+    metadata: opts.metadata
+  };
+  if (opts.provider) {
+    meta.metadata = { ...meta.metadata, provider: opts.provider };
+  }
+  const session = { meta, turns: [] };
+  saveSession(session);
+  upsertSessionToDb(meta, filePath);
+  return session;
+}
+function saveSession(session) {
+  const filePath = resolveSessionPath(session.meta.id, session.meta.project);
+  const dir = path4.dirname(filePath);
+  try {
+    fs3.mkdirSync(dir, { recursive: true });
+    session.meta.updated = (/* @__PURE__ */ new Date()).toISOString();
+    const markdown = writeSessionMarkdown(session);
+    const tmpPath = `${filePath}.tmp.${process.pid}`;
+    fs3.writeFileSync(tmpPath, markdown, "utf-8");
+    atomicRename(tmpPath, filePath);
+    cachePut(session.meta.id, session.meta.project, session);
+  } catch (err) {
+    throw new SessionError(`Failed to save session ${session.meta.id} at ${filePath}: ${err.message}`);
+  }
+}
+function loadSession(id, project) {
+  const cached = cacheGet(id, project);
+  if (cached)
+    return cached;
+  const filePath = resolveSessionPath(id, project);
+  if (!fs3.existsSync(filePath)) {
+    throw new SessionError(`Session not found: ${id} (project: ${project})`);
+  }
+  try {
+    const content = fs3.readFileSync(filePath, "utf-8");
+    const session = parseSessionMarkdown(content);
+    cachePut(id, project, session);
+    return session;
+  } catch (err) {
+    if (err instanceof SessionError)
+      throw err;
+    throw new SessionError(`Failed to load session ${id}: ${err.message}`);
+  }
+}
+function deleteSession(id, project) {
+  const filePath = resolveSessionPath(id, project);
+  if (!fs3.existsSync(filePath)) {
+    throw new SessionError(`Session not found: ${id} (project: ${project})`);
+  }
+  fs3.unlinkSync(filePath);
+  cacheInvalidate(id, project);
+  let dir = path4.dirname(filePath);
+  const sessionsRoot = getSessionsRoot();
+  while (dir !== sessionsRoot && dir.length > sessionsRoot.length) {
+    try {
+      const remaining = fs3.readdirSync(dir);
+      if (remaining.length === 0) {
+        fs3.rmdirSync(dir);
+        dir = path4.dirname(dir);
+      } else {
+        break;
+      }
+    } catch {
+      break;
+    }
+  }
+  try {
+    const db = getAgentDb();
+    const turns = db.prepare("SELECT id FROM turns WHERE session_id = ?").all(id);
+    for (const t of turns) {
+      db.prepare("DELETE FROM turns_fts WHERE rowid = ?").run(t.id);
+    }
+    db.prepare("DELETE FROM turns WHERE session_id = ?").run(id);
+    db.prepare("DELETE FROM sessions WHERE id = ?").run(id);
+  } catch (err) {
+    process.stderr.write(`[smriti:session-store] deleteSession SQLite cleanup failed for ${id}: ${err instanceof Error ? err.message : String(err)}
+`);
+  }
+}
+function addTurn(sessionId, project, turn) {
+  const key = `${sessionId}:${project}`;
+  const prev = sessionWriteQueues.get(key) ?? Promise.resolve();
+  const next = prev.then(() => {
+    const filePath = resolveSessionPath(sessionId, project);
+    if (!fs3.existsSync(filePath)) {
+      throw new SessionError(`Session not found: ${sessionId} (project: ${project})`);
+    }
+    const fileContent = fs3.readFileSync(filePath, "utf-8");
+    if (!turn.turnNumber) {
+      try {
+        const session = parseSessionMarkdown(fileContent);
+        turn.turnNumber = session.turns.length + 1;
+      } catch {
+        turn.turnNumber = getMaxTurnNumber(sessionId) + 1;
+      }
+    }
+    const updatedIso = (/* @__PURE__ */ new Date()).toISOString();
+    const patchedContent = patchFrontmatterUpdated(fileContent, updatedIso);
+    if (patchedContent !== fileContent) {
+      fs3.writeFileSync(filePath, patchedContent, "utf-8");
+    }
+    const turnMd = writeTurnMarkdown(turn);
+    fs3.appendFileSync(filePath, `
+${turnMd}
+`, "utf-8");
+    cacheInvalidate(sessionId, project);
+    insertTurnToDb(sessionId, turn, { project, filePath });
+  }).catch((err) => {
+    throw err;
+  }).finally(() => {
+    if (sessionWriteQueues.get(key) === next) {
+      sessionWriteQueues.delete(key);
+    }
+  });
+  sessionWriteQueues.set(key, next);
+  return next;
+}
+var sessionWriteQueues;
+var init_session_store = __esm({
+  "../chitragupta/packages/smriti/dist/session-store.js"() {
+    init_dist();
+    init_markdown_parser();
+    init_markdown_writer();
+    init_session_db();
+    init_session_store_cache();
+    init_session_store_cache();
+    init_session_db();
+    init_session_queries();
+    init_session_store_migration();
+    sessionWriteQueues = /* @__PURE__ */ new Map();
+  }
+});
 
 export {
   parseSessionMarkdown,
+  init_markdown_parser,
   writeSessionMarkdown,
   writeTurnMarkdown,
-  _resetSessionCache,
+  init_markdown_writer,
+  getAgentDb,
   _resetDbInit,
   _getDbStatus,
-  createSession,
-  saveSession,
-  loadSession,
+  getMaxTurnNumber,
+  init_session_db,
+  _resetSessionCache,
   listSessions,
   listSessionsByDate,
   listSessionsByDateRange,
   listSessionDates,
   listSessionProjects,
-  deleteSession,
-  addTurn,
   listTurnsWithTimestamps,
-  updateSessionMeta,
-  getMaxTurnNumber,
   findSessionByMetadata,
-  migrateExistingSessions
+  getTurnsSince,
+  getSessionsModifiedSince,
+  updateSessionMeta,
+  migrateExistingSessions,
+  createSession,
+  saveSession,
+  loadSession,
+  deleteSession,
+  addTurn,
+  init_session_store
 };
-//# sourceMappingURL=chunk-HIYHTWFW.js.map
+//# sourceMappingURL=chunk-FEDPZOZ5.js.map