@yugenlab/vaayu 0.1.8 → 0.1.10

package/chunks/chunk-TND3MU4Z.js

@@ -0,0 +1,426 @@
+import {
+  DatabaseManager
+} from "./chunk-U62ABYKD.js";
+import {
+  getChitraguptaHome
+} from "./chunk-UZ6OIVEC.js";
+
+// ../chitragupta/packages/smriti/src/periodic-consolidation.ts
+import fs2 from "node:fs";
+import path from "node:path";
+
+// ../chitragupta/packages/smriti/src/periodic-monthly.ts
+function esc(s) {
+  return s.replace(/\|/g, "\\|").replace(/\n/g, " ");
+}
+function truncate(s, max) {
+  return s.length <= max ? s : s.slice(0, max - 3) + "...";
+}
+function countJsonArray(json) {
+  if (!json) return 0;
+  try {
+    const arr = JSON.parse(json);
+    return Array.isArray(arr) ? arr.length : 0;
+  } catch {
+    return 0;
+  }
+}
+function generateRecommendations(stats, vasanas, vidhis, samskaras, tools) {
+  const recs = [];
+  if (stats.sessions > 0 && stats.cost > 0) {
+    const cps = stats.cost / stats.sessions;
+    if (cps > 1) recs.push(`Average cost per session is $${cps.toFixed(2)} \u2014 consider using lighter models for routine tasks.`);
+  }
+  if (stats.turns > 0 && stats.tokens > 0) {
+    const tpt = Math.round(stats.tokens / stats.turns);
+    if (tpt > 5e3) recs.push(`High token usage per turn (${tpt.toLocaleString()} avg) \u2014 review context window usage and compaction settings.`);
+  }
+  const negVas = vasanas.filter((v) => v.valence === "negative");
+  if (negVas.length > 0) recs.push(`${negVas.length} negative vasana(s) detected: ${negVas.map((v) => v.name).join(", ")}. Investigate root causes.`);
+  const weakVidhis = vidhis.filter((v) => v.success_rate < 0.5);
+  if (weakVidhis.length > 0) recs.push(`${weakVidhis.length} vidhi(s) with sub-50% success rate \u2014 consider refining or deprecating: ${weakVidhis.map((v) => v.name).join(", ")}.`);
+  const strongSam = samskaras.filter((s) => s.confidence > 0.8 && s.observation_count >= 5);
+  if (strongSam.length > 0) recs.push(`${strongSam.length} high-confidence samskara(s) may be ready for vasana crystallization.`);
+  if (tools.size > 0 && stats.sessions >= 5) {
+    if (tools.size / stats.sessions < 1.5) recs.push("Low tool diversity \u2014 explore additional tools to improve efficiency.");
+  }
+  if (recs.length === 0) recs.push("All metrics within healthy ranges. Keep up the momentum.");
+  return recs;
+}
+function buildMonthlyMarkdown(project, period, stats, vasanas, vidhis, samskaras, tools, newNodes, newEdges, recommendations) {
+  const lines = [];
+  lines.push(`# Monthly Consolidation \u2014 ${project} \u2014 ${period}`, `> Generated: ${(/* @__PURE__ */ new Date()).toISOString()}`, "");
+  lines.push("## Summary");
+  lines.push(`- **Sessions**: ${stats.sessions}`, `- **Turns**: ${stats.turns}`);
+  lines.push(`- **Tools Used**: ${tools.size > 0 ? [...tools].sort().join(", ") : "none"}`);
+  lines.push(`- **Total Tokens**: ${stats.tokens.toLocaleString()}`, `- **Estimated Cost**: $${stats.cost.toFixed(4)}`, "");
+  lines.push("## Vasanas Crystallized");
+  if (vasanas.length === 0) {
+    lines.push("_No vasanas crystallized this month._");
+  } else {
+    lines.push("| Tendency | Strength | Valence | Stability |", "|----------|----------|---------|-----------|");
+    for (const v of vasanas) lines.push(`| ${esc(v.name)} | ${v.strength.toFixed(2)} | ${v.valence} | ${v.stability.toFixed(2)} |`);
+  }
+  lines.push("");
+  lines.push("## Vidhis Extracted");
+  if (vidhis.length === 0) {
+    lines.push("_No vidhis extracted this month._");
+  } else {
+    lines.push("| Procedure | Steps | Success Rate | Sessions |", "|-----------|-------|--------------|----------|");
+    for (const v of vidhis) lines.push(`| ${esc(v.name)} | ${countJsonArray(v.steps)} | ${v.success_rate.toFixed(2)} | ${countJsonArray(v.learned_from)} |`);
+  }
+  lines.push("");
+  lines.push("## Top Samskaras");
+  if (samskaras.length === 0) {
+    lines.push("_No active samskaras this month._");
+  } else {
+    lines.push("| Pattern | Type | Confidence | Observations |", "|---------|------|------------|--------------|");
+    for (const s of samskaras) lines.push(`| ${esc(truncate(s.pattern_content, 60))} | ${s.pattern_type} | ${s.confidence.toFixed(2)} | ${s.observation_count} |`);
+  }
+  lines.push("");
+  lines.push("## Knowledge Graph Growth", `- New nodes: ${newNodes}`, `- New edges: ${newEdges}`, "");
+  lines.push("## Recommendations");
+  for (const rec of recommendations) lines.push(`- ${rec}`);
+  lines.push("");
+  return lines.join("\n");
+}
+async function buildMonthlyReport(project, home, baseDir, year, month, writeReport, indexIntoFts, logConsolidation, getReportPath) {
+  const t0 = Date.now();
+  const period = `${year}-${String(month).padStart(2, "0")}`;
+  const start = new Date(Date.UTC(year, month - 1, 1));
+  const end = new Date(Date.UTC(year, month, 1));
+  const startMs = start.getTime();
+  const endMs = end.getTime();
+  const dbm = DatabaseManager.instance(home);
+  const agentDb = dbm.get("agent");
+  const graphDb = dbm.get("graph");
+  const sessions = agentDb.prepare(`SELECT id, title, turn_count, cost, tokens, created_at FROM sessions WHERE project = ? AND created_at >= ? AND created_at < ? ORDER BY created_at ASC`).all(project, startMs, endMs);
+  const sessionIds = sessions.map((s) => s.id);
+  const totalTurns = sessions.reduce((sum, s) => sum + s.turn_count, 0);
+  const totalTokens = sessions.reduce((sum, s) => sum + (s.tokens ?? 0), 0);
+  const totalCost = sessions.reduce((sum, s) => sum + (s.cost ?? 0), 0);
+  const toolSet = /* @__PURE__ */ new Set();
+  if (sessionIds.length > 0) {
+    const ph = sessionIds.map(() => "?").join(",");
+    const turns = agentDb.prepare(`SELECT tool_calls FROM turns WHERE session_id IN (${ph}) AND tool_calls IS NOT NULL`).all(...sessionIds);
+    for (const turn of turns) {
+      if (!turn.tool_calls) continue;
+      try {
+        for (const c of JSON.parse(turn.tool_calls)) {
+          if (c.name) toolSet.add(c.name);
+        }
+      } catch {
+      }
+    }
+  }
+  const vasanas = agentDb.prepare(`SELECT name, description, strength, valence, stability FROM vasanas WHERE (project = ? OR project IS NULL) AND created_at >= ? AND created_at < ? ORDER BY strength DESC`).all(project, startMs, endMs);
+  const vidhis = agentDb.prepare(`SELECT name, steps, success_rate, learned_from FROM vidhis WHERE project = ? AND created_at >= ? AND created_at < ? ORDER BY success_rate DESC`).all(project, startMs, endMs);
+  const samskaras = agentDb.prepare(`SELECT id, pattern_type, pattern_content, confidence, observation_count FROM samskaras WHERE (project = ? OR project IS NULL) AND updated_at >= ? AND updated_at < ? ORDER BY confidence DESC LIMIT 20`).all(project, startMs, endMs);
+  const newNodes = graphDb.prepare(`SELECT COUNT(*) AS cnt FROM nodes WHERE created_at >= ? AND created_at < ?`).get(startMs, endMs)?.cnt ?? 0;
+  const newEdges = graphDb.prepare(`SELECT COUNT(*) AS cnt FROM edges WHERE recorded_at >= ? AND recorded_at < ?`).get(startMs, endMs)?.cnt ?? 0;
+  const stats = { sessions: sessions.length, turns: totalTurns, tokens: totalTokens, cost: totalCost, vasanasCreated: vasanas.length, vidhisCreated: vidhis.length, samskarasActive: samskaras.length };
+  const recommendations = generateRecommendations(stats, vasanas, vidhis, samskaras, toolSet);
+  const markdown = buildMonthlyMarkdown(project, period, stats, vasanas, vidhis, samskaras, toolSet, newNodes, newEdges, recommendations);
+  const filePath = getReportPath("monthly", period);
+  writeReport(filePath, markdown);
+  try {
+    const { indexConsolidationSummary } = await import("./consolidation-indexer-VKQ6DNU3.js");
+    await indexConsolidationSummary("monthly", period, markdown, project);
+  } catch {
+  }
+  indexIntoFts(agentDb, markdown);
+  const durationMs = Date.now() - t0;
+  logConsolidation(agentDb, { project, cycleType: "monthly", cycleId: `monthly-${period}`, vasanasCreated: vasanas.length, vidhisCreated: vidhis.length, samskarasProcessed: samskaras.length, sessionsProcessed: sessions.length, status: "success", createdAt: Date.now() });
+  return { type: "monthly", period, project, filePath, markdown, stats, durationMs };
+}
+
+// ../chitragupta/packages/smriti/src/periodic-yearly.ts
+import fs from "node:fs";
+function esc2(s) {
+  return s.replace(/\|/g, "\\|").replace(/\n/g, " ");
+}
+function truncate2(s, max) {
+  return s.length <= max ? s : s.slice(0, max - 3) + "...";
+}
+function countJsonArray2(json) {
+  if (!json) return 0;
+  try {
+    const arr = JSON.parse(json);
+    return Array.isArray(arr) ? arr.length : 0;
+  } catch {
+    return 0;
+  }
+}
+function analyzeTrends(reports) {
+  const trends = [];
+  if (reports.length < 2) return trends;
+  const sessionCounts = reports.map((r) => r.stats.sessions);
+  const half = Math.floor(sessionCounts.length / 2);
+  const avgFirst = sessionCounts.slice(0, half).reduce((a, b) => a + b, 0) / (half || 1);
+  const avgSecond = sessionCounts.slice(half).reduce((a, b) => a + b, 0) / (sessionCounts.length - half || 1);
+  if (avgSecond > avgFirst * 1.3) trends.push("Session volume increased significantly in the second half of the year.");
+  else if (avgSecond < avgFirst * 0.7) trends.push("Session volume decreased notably in the second half of the year.");
+  const costs = reports.map((r) => r.stats.cost);
+  const costFirst = costs.slice(0, half).reduce((a, b) => a + b, 0);
+  const costSecond = costs.slice(half).reduce((a, b) => a + b, 0);
+  if (costSecond > 0 && costFirst > 0) {
+    if (costSecond < costFirst * 0.8) trends.push("Cost efficiency improved over the year \u2014 spending decreased while activity continued.");
+    else if (costSecond > costFirst * 1.5) trends.push("Spending increased substantially \u2014 review model selection and caching strategies.");
+  }
+  const totalVasanas = reports.reduce((s, r) => s + r.stats.vasanasCreated, 0);
+  const totalVidhis = reports.reduce((s, r) => s + r.stats.vidhisCreated, 0);
+  if (totalVasanas > 10) trends.push(`Strong behavioral crystallization: ${totalVasanas} vasanas formed across the year.`);
+  if (totalVidhis > 5) trends.push(`Active procedural learning: ${totalVidhis} vidhis extracted from repeated patterns.`);
+  if (trends.length === 0) trends.push("Steady, consistent usage throughout the year with no significant inflection points.");
+  return trends;
+}
+function buildYearlyMarkdown(project, period, stats, vasanas, vidhis, samskaras, yearNodes, yearEdges, monthlyReports, trends, prevYearStats) {
+  const lines = [];
+  lines.push(`# Yearly Consolidation \u2014 ${project} \u2014 ${period}`, `> Generated: ${(/* @__PURE__ */ new Date()).toISOString()}`, "");
+  lines.push("## Annual Summary");
+  lines.push(`- **Sessions**: ${stats.sessions}`, `- **Turns**: ${stats.turns}`);
+  lines.push(`- **Total Tokens**: ${stats.tokens.toLocaleString()}`, `- **Estimated Cost**: $${stats.cost.toFixed(4)}`);
+  lines.push(`- **Vasanas Crystallized**: ${stats.vasanasCreated}`, `- **Vidhis Extracted**: ${stats.vidhisCreated}`);
+  lines.push(`- **Samskaras Active**: ${stats.samskarasActive}`, "");
+  if (prevYearStats) {
+    lines.push("## Year-over-Year Comparison");
+    lines.push("| Metric | Previous Year | This Year | Change |", "|--------|---------------|-----------|--------|");
+    const yoy = (label, prev, curr) => {
+      const d = curr - prev;
+      const pct = prev > 0 ? (d / prev * 100).toFixed(1) : "N/A";
+      return `| ${label} | ${prev} | ${curr} | ${d >= 0 ? "+" : ""}${pct !== "N/A" ? pct + "%" : pct} |`;
+    };
+    lines.push(yoy("Sessions", prevYearStats.sessions, stats.sessions));
+    lines.push(yoy("Turns", prevYearStats.turns, stats.turns));
+    lines.push(yoy("Tokens", prevYearStats.tokens, stats.tokens));
+    lines.push(yoy("Vasanas", prevYearStats.vasanasCreated, stats.vasanasCreated));
+    lines.push(yoy("Vidhis", prevYearStats.vidhisCreated, stats.vidhisCreated));
+    lines.push("");
+  }
+  if (monthlyReports.length > 0) {
+    lines.push("## Monthly Breakdown");
+    lines.push("| Month | Sessions | Turns | Tokens | Cost |", "|-------|----------|-------|--------|------|");
+    for (const r of monthlyReports) lines.push(`| ${r.period} | ${r.stats.sessions} | ${r.stats.turns} | ${r.stats.tokens.toLocaleString()} | $${r.stats.cost.toFixed(4)} |`);
+    lines.push("");
+  }
+  lines.push("## Trends");
+  for (const t of trends) lines.push(`- ${t}`);
+  lines.push("");
+  lines.push("## Top Vasanas of the Year");
+  if (vasanas.length === 0) {
+    lines.push("_No vasanas crystallized this year._");
+  } else {
+    lines.push("| Tendency | Strength | Valence | Stability |", "|----------|----------|---------|-----------|");
+    for (const v of vasanas.slice(0, 15)) lines.push(`| ${esc2(v.name)} | ${v.strength.toFixed(2)} | ${v.valence} | ${v.stability.toFixed(2)} |`);
+  }
+  lines.push("");
+  lines.push("## Top Vidhis of the Year");
+  if (vidhis.length === 0) {
+    lines.push("_No vidhis extracted this year._");
+  } else {
+    lines.push("| Procedure | Steps | Success Rate | Sessions |", "|-----------|-------|--------------|----------|");
+    for (const v of vidhis.slice(0, 15)) lines.push(`| ${esc2(v.name)} | ${countJsonArray2(v.steps)} | ${v.success_rate.toFixed(2)} | ${countJsonArray2(v.learned_from)} |`);
+  }
+  lines.push("");
+  lines.push("## Top Samskaras of the Year");
+  if (samskaras.length === 0) {
+    lines.push("_No active samskaras this year._");
+  } else {
+    lines.push("| Pattern | Type | Confidence | Observations |", "|---------|------|------------|--------------|");
+    for (const s of samskaras.slice(0, 20)) lines.push(`| ${esc2(truncate2(s.pattern_content, 60))} | ${s.pattern_type} | ${s.confidence.toFixed(2)} | ${s.observation_count} |`);
+  }
+  lines.push("");
+  lines.push("## Knowledge Graph Growth", `- New nodes: ${yearNodes}`, `- New edges: ${yearEdges}`, "");
+  lines.push("## Database Maintenance", "- VACUUM executed on agent.db, graph.db, vectors.db", "");
+  return lines.join("\n");
+}
+async function buildYearlyReport(project, home, baseDir, year, monthlyFn, extractStatsFromMarkdown, writeReport, indexIntoFts, logConsolidation, getReportPath) {
+  const t0 = Date.now();
+  const period = String(year);
+  const startMs = new Date(Date.UTC(year, 0, 1)).getTime();
+  const endMs = new Date(Date.UTC(year + 1, 0, 1)).getTime();
+  const dbm = DatabaseManager.instance(home);
+  const agentDb = dbm.get("agent");
+  const graphDb = dbm.get("graph");
+  const monthlyReports = [];
+  for (let m = 1; m <= 12; m++) {
+    const mp = `${year}-${String(m).padStart(2, "0")}`;
+    const mPath = getReportPath("monthly", mp);
+    if (!fs.existsSync(mPath)) {
+      const ms = new Date(Date.UTC(year, m - 1, 1)).getTime();
+      const me = new Date(Date.UTC(year, m, 1)).getTime();
+      if (me <= Date.now()) {
+        const cnt = agentDb.prepare(`SELECT COUNT(*) AS cnt FROM sessions WHERE project = ? AND created_at >= ? AND created_at < ?`).get(project, ms, me)?.cnt ?? 0;
+        if (cnt > 0) {
+          monthlyReports.push(await monthlyFn(year, m));
+          continue;
+        }
+      }
+    } else {
+      const content = fs.readFileSync(mPath, "utf-8");
+      monthlyReports.push({ type: "monthly", period: mp, project, filePath: mPath, markdown: content, stats: extractStatsFromMarkdown(content), durationMs: 0 });
+    }
+  }
+  const annualStats = { sessions: 0, turns: 0, tokens: 0, cost: 0, vasanasCreated: 0, vidhisCreated: 0, samskarasActive: 0 };
+  for (const r of monthlyReports) {
+    annualStats.sessions += r.stats.sessions;
+    annualStats.turns += r.stats.turns;
+    annualStats.tokens += r.stats.tokens;
+    annualStats.cost += r.stats.cost;
+    annualStats.vasanasCreated += r.stats.vasanasCreated;
+    annualStats.vidhisCreated += r.stats.vidhisCreated;
+    annualStats.samskarasActive += r.stats.samskarasActive;
+  }
+  const allVasanas = agentDb.prepare(`SELECT name, description, strength, valence, stability FROM vasanas WHERE (project = ? OR project IS NULL) AND created_at >= ? AND created_at < ? ORDER BY strength DESC`).all(project, startMs, endMs);
+  const allVidhis = agentDb.prepare(`SELECT name, steps, success_rate, learned_from FROM vidhis WHERE project = ? AND created_at >= ? AND created_at < ? ORDER BY success_rate DESC`).all(project, startMs, endMs);
+  const allSamskaras = agentDb.prepare(`SELECT id, pattern_type, pattern_content, confidence, observation_count FROM samskaras WHERE (project = ? OR project IS NULL) AND updated_at >= ? AND updated_at < ? ORDER BY confidence DESC LIMIT 30`).all(project, startMs, endMs);
+  const yearNodes = graphDb.prepare(`SELECT COUNT(*) AS cnt FROM nodes WHERE created_at >= ? AND created_at < ?`).get(startMs, endMs)?.cnt ?? 0;
+  const yearEdges = graphDb.prepare(`SELECT COUNT(*) AS cnt FROM edges WHERE recorded_at >= ? AND recorded_at < ?`).get(startMs, endMs)?.cnt ?? 0;
+  let prevYearStats = null;
+  const prevPath = getReportPath("yearly", String(year - 1));
+  if (fs.existsSync(prevPath)) prevYearStats = extractStatsFromMarkdown(fs.readFileSync(prevPath, "utf-8"));
+  const trends = analyzeTrends(monthlyReports);
+  const markdown = buildYearlyMarkdown(project, period, annualStats, allVasanas, allVidhis, allSamskaras, yearNodes, yearEdges, monthlyReports, trends, prevYearStats);
+  const filePath = getReportPath("yearly", period);
+  writeReport(filePath, markdown);
+  try {
+    const { indexConsolidationSummary } = await import("./consolidation-indexer-VKQ6DNU3.js");
+    await indexConsolidationSummary("yearly", period, markdown, project);
+  } catch {
+  }
+  indexIntoFts(agentDb, markdown);
+  dbm.vacuum("agent");
+  dbm.vacuum("graph");
+  dbm.vacuum("vectors");
+  const durationMs = Date.now() - t0;
+  logConsolidation(agentDb, { project, cycleType: "yearly", cycleId: `yearly-${period}`, vasanasCreated: allVasanas.length, vidhisCreated: allVidhis.length, samskarasProcessed: allSamskaras.length, sessionsProcessed: annualStats.sessions, status: "success", createdAt: Date.now() });
+  return { type: "yearly", period, project, filePath, markdown, stats: annualStats, durationMs };
+}
+
+// ../chitragupta/packages/smriti/src/periodic-consolidation.ts
+function projectHash(project) {
+  let h = 2166136261;
+  for (let i = 0; i < project.length; i++) {
+    h ^= project.charCodeAt(i);
+    h = h * 16777619 >>> 0;
+  }
+  return (h >>> 0).toString(16).slice(0, 4);
+}
+var PeriodicConsolidation = class {
+  _project;
+  _home;
+  _hash;
+  _baseDir;
+  constructor(config) {
+    this._project = config.project;
+    this._home = config.chitraguptaHome ?? getChitraguptaHome();
+    this._hash = projectHash(this._project);
+    this._baseDir = path.join(this._home, "consolidated", this._hash);
+  }
+  // ── Public API ────────────────────────────────────────────────────────
+  /** Run monthly consolidation for a specific calendar month. */
+  async monthly(year, month) {
+    return buildMonthlyReport(
+      this._project,
+      this._home,
+      this._baseDir,
+      year,
+      month,
+      this._writeReport.bind(this),
+      this._indexIntoFts.bind(this),
+      this._logConsolidation.bind(this),
+      this.getReportPath.bind(this)
+    );
+  }
+  /** Run yearly consolidation for a specific calendar year. */
+  async yearly(year) {
+    return buildYearlyReport(
+      this._project,
+      this._home,
+      this._baseDir,
+      year,
+      this.monthly.bind(this),
+      this._extractStatsFromMarkdown.bind(this),
+      this._writeReport.bind(this),
+      this._indexIntoFts.bind(this),
+      this._logConsolidation.bind(this),
+      this.getReportPath.bind(this)
+    );
+  }
+  /** Check whether a monthly report exists on disk. */
+  hasMonthlyReport(year, month) {
+    const period = `${year}-${String(month).padStart(2, "0")}`;
+    return fs2.existsSync(this.getReportPath("monthly", period));
+  }
+  /** Check whether a yearly report exists on disk. */
+  hasYearlyReport(year) {
+    return fs2.existsSync(this.getReportPath("yearly", String(year)));
+  }
+  /** Get the absolute file path for a report. */
+  getReportPath(type, period) {
+    return path.join(this._baseDir, type, `${period}.md`);
+  }
+  /** List all existing reports for this project. */
+  listReports() {
+    const reports = [];
+    for (const type of ["monthly", "yearly"]) {
+      const dir = path.join(this._baseDir, type);
+      if (!fs2.existsSync(dir)) continue;
+      const files = fs2.readdirSync(dir).filter((f) => f.endsWith(".md")).sort();
+      for (const file of files) {
+        reports.push({ type, period: file.replace(/\.md$/, ""), path: path.join(dir, file) });
+      }
+    }
+    return reports;
+  }
+  // ── Private Helpers ───────────────────────────────────────────────────
+  /** Write a Markdown report to disk, creating parent dirs as needed. */
+  _writeReport(filePath, content) {
+    fs2.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs2.writeFileSync(filePath, content, "utf-8");
+    fs2.chmodSync(filePath, 384);
+  }
+  /** Index report text into FTS5 for full-text search. */
+  _indexIntoFts(agentDb, content) {
+    try {
+      agentDb.prepare("INSERT INTO turns_fts(content) VALUES (?)").run(content);
+    } catch {
+    }
+  }
+  /** Log a consolidation run to the consolidation_log table. */
+  _logConsolidation(agentDb, entry) {
+    try {
+      agentDb.prepare(
+        `INSERT INTO consolidation_log (project, cycle_type, cycle_id, vasanas_created, vidhis_created, samskaras_processed, sessions_processed, status, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
+      ).run(entry.project, entry.cycleType, entry.cycleId, entry.vasanasCreated, entry.vidhisCreated, entry.samskarasProcessed, entry.sessionsProcessed, entry.status, entry.createdAt);
+    } catch {
+    }
+  }
+  /** Extract stats from a previously generated Markdown report. */
+  _extractStatsFromMarkdown(md) {
+    const stats = { sessions: 0, turns: 0, tokens: 0, cost: 0, vasanasCreated: 0, vidhisCreated: 0, samskarasActive: 0 };
+    const num = (pattern) => {
+      const match = md.match(pattern);
+      return match ? parseFloat(match[1].replace(/,/g, "")) || 0 : 0;
+    };
+    stats.sessions = num(/\*\*Sessions\*\*:\s*([\d,]+)/);
+    stats.turns = num(/\*\*Turns\*\*:\s*([\d,]+)/);
+    stats.tokens = num(/\*\*Total Tokens\*\*:\s*([\d,]+)/);
+    stats.cost = num(/\*\*Estimated Cost\*\*:\s*\$?([\d,.]+)/);
+    const countTableRows = (sectionName) => {
+      const section = md.match(new RegExp(`## ${sectionName}\\n[\\s\\S]*?(?=\\n##|$)`));
+      if (!section) return 0;
+      const rows = (section[0].match(/^\|(?!\s*-)[^|]+\|/gm) || []).length - 1;
+      return rows < 0 ? 0 : rows;
+    };
+    stats.vasanasCreated = countTableRows("Vasanas Crystallized");
+    stats.vidhisCreated = countTableRows("Vidhis Extracted");
+    stats.samskarasActive = countTableRows("Top Samskaras");
+    return stats;
+  }
+};
+
+export {
+  PeriodicConsolidation
+};
+//# sourceMappingURL=chunk-TND3MU4Z.js.map

package/chunks/{chunk-LVE2EOOH.js → chunk-VJHNE47S.js}

@@ -1,7 +1,7 @@
 import {
   listSessions,
   loadSession
-} from "./chunk-NHRBVSN3.js";
+} from "./chunk-HIYHTWFW.js";
 import {
   EmbeddingService,
   cosineSimilarity,
@@ -18,8 +18,7 @@ import {
 } from "./chunk-UZ6OIVEC.js";
 
 // ../chitragupta/packages/smriti/src/recall.ts
-import fs2 from "fs";
-import path2 from "path";
+import fs3 from "fs";
 
 // ../chitragupta/packages/smriti/src/streams.ts
 import fs from "fs";
@@ -368,7 +367,9 @@ function resetOllamaAvailability() {
   _embeddingService.resetAvailability();
 }
 
-// ../chitragupta/packages/smriti/src/recall.ts
+// ../chitragupta/packages/smriti/src/recall-storage.ts
+import fs2 from "fs";
+import path2 from "path";
 var DEFAULT_TOP_K = 10;
 var DEFAULT_THRESHOLD = 0.3;
 function getIndexDir() {
@@ -389,6 +390,72 @@ function blobToVector(blob) {
   );
   return Array.from(float32);
 }
+function migrateEmbeddingsJson() {
+  const jsonPath = getEmbeddingsPath();
+  if (!fs2.existsSync(jsonPath)) {
+    return { migrated: 0, skipped: 0 };
+  }
+  let entries;
+  try {
+    const raw = fs2.readFileSync(jsonPath, "utf-8");
+    entries = JSON.parse(raw);
+  } catch {
+    return { migrated: 0, skipped: 0 };
+  }
+  if (!entries || entries.length === 0) {
+    return { migrated: 0, skipped: 0 };
+  }
+  let migrated = 0;
+  let skipped = 0;
+  try {
+    const dbm = DatabaseManager.instance();
+    initVectorsSchema(dbm);
+    const db = dbm.get("vectors");
+    const txn = db.transaction(() => {
+      const insert = db.prepare(`
+        INSERT OR IGNORE INTO embeddings (id, vector, text, source_type, source_id, dimensions, metadata, created_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+      `);
+      for (const entry of entries) {
+        try {
+          const result = insert.run(
+            entry.id,
+            vectorToBlob(entry.vector),
+            entry.text,
+            entry.source,
+            entry.sourceId,
+            entry.vector.length,
+            JSON.stringify({
+              title: entry.title,
+              summary: entry.summary,
+              tags: entry.tags,
+              date: entry.date,
+              deviceId: entry.deviceId
+            }),
+            new Date(entry.date).getTime()
+          );
+          if (result.changes > 0) {
+            migrated++;
+          } else {
+            skipped++;
+          }
+        } catch {
+          skipped++;
+        }
+      }
+    });
+    txn();
+    try {
+      fs2.renameSync(jsonPath, jsonPath + ".bak");
+    } catch {
+    }
+  } catch {
+    return { migrated: 0, skipped: entries.length };
+  }
+  return { migrated, skipped };
+}
+
+// ../chitragupta/packages/smriti/src/recall.ts
 var _dbInitialized = false;
 function _resetRecallDbInit() {
   _dbInitialized = false;
@@ -480,8 +547,8 @@ var RecallEngine = class {
   loadIndexJson() {
     try {
       const indexPath = getEmbeddingsPath();
-      if (fs2.existsSync(indexPath)) {
-        const raw = fs2.readFileSync(indexPath, "utf-8");
+      if (fs3.existsSync(indexPath)) {
+        const raw = fs3.readFileSync(indexPath, "utf-8");
         this.entries = JSON.parse(raw);
       }
     } catch {
@@ -491,8 +558,8 @@ var RecallEngine = class {
   saveIndexJson() {
     try {
       const dir = getIndexDir();
-      fs2.mkdirSync(dir, { recursive: true });
-      fs2.writeFileSync(
+      fs3.mkdirSync(dir, { recursive: true });
+      fs3.writeFileSync(
         getEmbeddingsPath(),
         JSON.stringify(this.entries, null, "	"),
         "utf-8"
@@ -501,6 +568,7 @@ var RecallEngine = class {
     }
   }
   // ─── Session Indexing ────────────────────────────────────────────
+  /** Index a session's turns into the embedding store. */
   async indexSession(session) {
     if (!this.loaded) this.loadIndex();
     this.entries = this.entries.filter(
@@ -534,6 +602,7 @@ var RecallEngine = class {
     }
     this.saveIndex();
   }
+  /** Index a memory stream into the embedding store. */
   async indexStream(streamType, content, deviceId) {
     if (!this.loaded) this.loadIndex();
     const sourceId = deviceId ? `stream-${streamType}-${deviceId}` : `stream-${streamType}`;
@@ -557,6 +626,7 @@ var RecallEngine = class {
     this.saveIndex();
   }
   // ─── Recall (Search) ─────────────────────────────────────────────
+  /** Search all indexed embeddings for the given query string. */
   async recall(query, options) {
     if (!this.loaded) this.loadIndex();
     if (this.entries.length === 0) return [];
@@ -600,6 +670,7 @@ var RecallEngine = class {
     return results;
   }
   // ─── Re-index ────────────────────────────────────────────────────
+  /** Re-index all sessions and streams from scratch. */
   async reindexAll() {
     this.entries = [];
     const allMetas = listSessions();
@@ -629,77 +700,15 @@ var RecallEngine = class {
     }
     this.saveIndex();
   }
+  /** Return the number of entries in the in-memory index. */
   getIndexSize() {
     return this.entries.length;
   }
+  /** Reset the embedding provider availability cache. */
   resetOllamaAvailability() {
     resetOllamaAvailability();
   }
 };
-function migrateEmbeddingsJson() {
-  const jsonPath = getEmbeddingsPath();
-  if (!fs2.existsSync(jsonPath)) {
-    return { migrated: 0, skipped: 0 };
-  }
-  let entries;
-  try {
-    const raw = fs2.readFileSync(jsonPath, "utf-8");
-    entries = JSON.parse(raw);
-  } catch {
-    return { migrated: 0, skipped: 0 };
-  }
-  if (!entries || entries.length === 0) {
-    return { migrated: 0, skipped: 0 };
-  }
-  let migrated = 0;
-  let skipped = 0;
-  try {
-    const dbm = DatabaseManager.instance();
-    initVectorsSchema(dbm);
-    const db = dbm.get("vectors");
-    const txn = db.transaction(() => {
-      const insert = db.prepare(`
-        INSERT OR IGNORE INTO embeddings (id, vector, text, source_type, source_id, dimensions, metadata, created_at)
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-      `);
-      for (const entry of entries) {
-        try {
-          const result = insert.run(
-            entry.id,
-            vectorToBlob(entry.vector),
-            entry.text,
-            entry.source,
-            entry.sourceId,
-            entry.vector.length,
-            JSON.stringify({
-              title: entry.title,
-              summary: entry.summary,
-              tags: entry.tags,
-              date: entry.date,
-              deviceId: entry.deviceId
-            }),
-            new Date(entry.date).getTime()
-          );
-          if (result.changes > 0) {
-            migrated++;
-          } else {
-            skipped++;
-          }
-        } catch {
-          skipped++;
-        }
-      }
-    });
-    txn();
-    try {
-      fs2.renameSync(jsonPath, jsonPath + ".bak");
-    } catch {
-    }
-  } catch {
-    return { migrated: 0, skipped: entries.length };
-  }
-  return { migrated, skipped };
-}
 
 export {
   STREAM_CONFIGS,
@@ -709,8 +718,8 @@ export {
   configureRecallScoring,
   vectorToBlob,
   blobToVector,
+  migrateEmbeddingsJson,
   _resetRecallDbInit,
-  RecallEngine,
-  migrateEmbeddingsJson
+  RecallEngine
 };
-//# sourceMappingURL=chunk-LVE2EOOH.js.map
+//# sourceMappingURL=chunk-VJHNE47S.js.map