@yugenlab/vaayu 0.1.11 → 0.1.12

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

@@ -1,19 +1,21 @@
 import {
-  initAgentSchema
-} from "./chunk-V2ZIKDN4.js";
+  initAgentSchema,
+  init_schema
+} from "./chunk-VEZ2DI2M.js";
 import {
-  DatabaseManager
-} from "./chunk-67DXWEKG.js";
+  DatabaseManager,
+  init_database
+} from "./chunk-H46F2Y6R.js";
 import {
   SessionError,
-  getChitraguptaHome
-} from "./chunk-2OBLQJYJ.js";
-
-// ../chitragupta/packages/smriti/dist/session-store.js
-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/dist/markdown-parser.js
 function parseFrontmatter(yaml) {
@@ -209,6 +211,12 @@ function parseToolCallSection(name, section) {
     toolCall.isError = true;
   return toolCall;
 }
+var init_markdown_parser = __esm({
+  "../chitragupta/packages/smriti/dist/markdown-parser.js"() {
+    "use strict";
+    init_dist();
+  }
+});
 
 // ../chitragupta/packages/smriti/dist/markdown-writer.js
 function writeFrontmatter(meta) {
@@ -302,147 +310,24 @@ function writeSessionMarkdown(session) {
 function writeTurnMarkdown(turn) {
   return writeTurn(turn);
 }
-
-// ../chitragupta/packages/smriti/dist/session-store.js
-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) {
@@ -553,8 +438,8 @@ function seedSessionRowForTurn(sessionId, project, filePath) {
 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 (?, ?, ?, ?, ?, ?, ?, ?)
@@ -581,153 +466,97 @@ function insertTurnToDb(sessionId, turn, context) {
 `);
   }
 }
-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 = path.dirname(filePath);
+function getMaxTurnNumber(sessionId) {
   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}`);
+    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;
   }
 }
-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})`);
+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;
   }
-  try {
-    const content = fs.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}`);
+});
+
+// ../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 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);
-    } else {
-      rows = db.prepare("SELECT * FROM sessions ORDER BY updated_at DESC").all();
-    }
-    if (rows.length > 0) {
-      return rows.map(rowToSessionMeta);
-    }
-  } catch (err) {
-    process.stderr.write(`[chitragupta] listSessions SQLite failed, falling back to filesystem: ${err instanceof Error ? err.message : err}
-`);
-  }
-  return listSessionsFromFilesystem(project);
+function cacheKey(id, project) {
+  return `${id}:${project}`;
 }
-function listSessionsByDate(date, project) {
-  const dateMatch = date.match(/^(\d{4})-(\d{2})-(\d{2})$/);
-  if (!dateMatch) {
-    throw new SessionError(`Invalid date format: ${date}. Expected YYYY-MM-DD.`);
-  }
-  const startOfDay = (/* @__PURE__ */ new Date(`${date}T00:00:00.000Z`)).getTime();
-  const endOfDay = startOfDay + 864e5;
-  return listSessionsByDateRange(startOfDay, endOfDay, 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 listSessionsByDateRange(startMs, endMs, project) {
-  try {
-    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);
-    } else {
-      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 {
-  }
-  const allSessions = listSessionsFromFilesystem(project);
-  return allSessions.filter((s) => {
-    const created = new Date(s.created).getTime();
-    return created >= startMs && created < endMs;
-  });
-}
-function listSessionDates(project) {
-  try {
-    const db = getAgentDb();
-    let rows;
-    if (project) {
-      rows = db.prepare(`SELECT DISTINCT date(created_at / 1000, 'unixepoch') as session_date
-				 FROM sessions WHERE project = ?
-				 ORDER BY session_date DESC`).all(project);
-    } else {
-      rows = db.prepare(`SELECT DISTINCT date(created_at / 1000, 'unixepoch') as session_date
-				 FROM sessions
-				 ORDER BY session_date DESC`).all();
-    }
-    return rows.map((r) => r.session_date).filter(Boolean);
-  } catch {
-    const allSessions = listSessionsFromFilesystem(project);
-    const dates = /* @__PURE__ */ new Set();
-    for (const s of allSessions) {
-      dates.add(s.created.slice(0, 10));
-    }
-    return [...dates].sort().reverse();
+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 listSessionProjects() {
-  try {
-    const db = getAgentDb();
-    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();
-    return rows.map((r) => ({
-      project: r.project,
-      sessionCount: r.count,
-      lastActive: new Date(r.last_active).toISOString()
-    }));
-  } catch {
-    return [];
-  }
+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))
@@ -742,7 +571,7 @@ function listSessionsFromFilesystem(project) {
     const projectDirs = fs.readdirSync(sessionsRoot, { withFileTypes: true });
     for (const entry of projectDirs) {
       if (entry.isDirectory()) {
-        results.push(...scanDirRecursive(path.join(sessionsRoot, entry.name)));
+        results.push(...scanDirRecursive(path2.join(sessionsRoot, entry.name)));
       }
     }
   }
@@ -754,7 +583,7 @@ function scanDirRecursive(dir) {
   try {
     const entries = fs.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path.join(dir, entry.name);
+      const fullPath = path2.join(dir, entry.name);
       if (entry.isDirectory()) {
         metas.push(...scanDirRecursive(fullPath));
       } else if (entry.name.endsWith(".md")) {
@@ -762,85 +591,109 @@ function scanDirRecursive(dir) {
           const content = fs.readFileSync(fullPath, "utf-8");
           const session = parseSessionMarkdown(content);
           metas.push(session.meta);
-        } catch {
+        } catch (err) {
+          process.stderr.write(`[smriti:session-queries] skip unparseable file ${fullPath}: ${err instanceof Error ? err.message : String(err)}
+`);
         }
       }
     }
-  } catch {
+  } catch (err) {
+    process.stderr.write(`[smriti:session-queries] directory scan failed for ${dir}: ${err instanceof Error ? err.message : String(err)}
+`);
   }
   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;
-    }
-  }
+function listSessions(project) {
   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);
+    let rows;
+    if (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();
     }
-    db.prepare("DELETE FROM turns WHERE session_id = ?").run(id);
-    db.prepare("DELETE FROM sessions WHERE id = ?").run(id);
-  } catch {
+    if (rows.length > 0) {
+      return rows.map(rowToSessionMeta);
+    }
+  } catch (err) {
+    process.stderr.write(`[chitragupta] listSessions SQLite failed, falling back to filesystem: ${err instanceof Error ? err.message : err}
+`);
   }
+  return listSessionsFromFilesystem(project);
 }
-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})`);
+function listSessionsByDate(date, project) {
+  const dateMatch = date.match(/^(\d{4})-(\d{2})-(\d{2})$/);
+  if (!dateMatch) {
+    throw new SessionError(`Invalid date format: ${date}. Expected YYYY-MM-DD.`);
+  }
+  const startOfDay = (/* @__PURE__ */ new Date(`${date}T00:00:00.000Z`)).getTime();
+  const endOfDay = startOfDay + 864e5;
+  return listSessionsByDateRange(startOfDay, endOfDay, project);
+}
+function listSessionsByDateRange(startMs, endMs, project) {
+  try {
+    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);
+    } else {
+      rows = db.prepare("SELECT * FROM sessions WHERE created_at >= ? AND created_at < ? ORDER BY created_at ASC").all(startMs, endMs);
     }
-    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;
-      }
+    if (rows.length > 0) {
+      return rows.map(rowToSessionMeta);
     }
-    const updatedIso = (/* @__PURE__ */ new Date()).toISOString();
-    const patchedContent = patchFrontmatterUpdated(fileContent, updatedIso);
-    if (patchedContent !== fileContent) {
-      fs.writeFileSync(filePath, patchedContent, "utf-8");
+  } 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) => {
+    const created = new Date(s.created).getTime();
+    return created >= startMs && created < endMs;
+  });
+}
+function listSessionDates(project) {
+  try {
+    const db = getAgentDb();
+    let rows;
+    if (project) {
+      rows = db.prepare(`SELECT DISTINCT date(created_at / 1000, 'unixepoch') as session_date
+				 FROM sessions WHERE project = ?
+				 ORDER BY session_date DESC`).all(project);
+    } else {
+      rows = db.prepare(`SELECT DISTINCT date(created_at / 1000, 'unixepoch') as session_date
+				 FROM sessions
+				 ORDER BY session_date DESC`).all();
     }
-    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);
+    return rows.map((r) => r.session_date).filter(Boolean);
+  } 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) {
+      dates.add(s.created.slice(0, 10));
     }
-  });
-  sessionWriteQueues.set(key, next);
-  return next;
+    return [...dates].sort().reverse();
+  }
+}
+function listSessionProjects() {
+  try {
+    const db = getAgentDb();
+    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();
+    return rows.map((r) => ({
+      project: r.project,
+      sessionCount: r.count,
+      lastActive: new Date(r.last_active).toISOString()
+    }));
+  } catch (err) {
+    process.stderr.write(`[smriti:session-queries] listSessionProjects SQLite failed: ${err instanceof Error ? err.message : String(err)}
+`);
+    return [];
+  }
 }
 function listTurnsWithTimestamps(sessionId, project) {
   try {
@@ -857,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 [];
   }
 }
@@ -897,40 +800,32 @@ function updateSessionMeta(sessionId, updates) {
     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;
+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();
   }
-  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;
-  }
-}
+});
+
+// ../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))
+  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)
@@ -942,7 +837,7 @@ function migrateExistingSessions(project) {
   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) {
@@ -965,7 +860,7 @@ function migrateExistingSessions(project) {
   };
   const runMigration = db.transaction(() => {
     for (const dir of dirs) {
-      if (!fs.existsSync(dir))
+      if (!fs2.existsSync(dir))
         continue;
       walkMdFiles(dir, sessionsRoot, migrateFile);
     }
@@ -975,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-ZYY6N3SP.js.map
+//# sourceMappingURL=chunk-FEDPZOZ5.js.map