@yugenlab/vaayu 0.1.1 → 0.1.2

package/chunks/{chunk-URGEODS5.js → chunk-DQMAQ2VL.js}

@@ -1,6 +1,6 @@
 import {
   DatabaseManager
-} from "./chunk-U6OLJ36B.js";
+} from "./chunk-UQLPHNGH.js";
 import {
   getChitraguptaHome
 } from "./chunk-KC6NRZ7U.js";
@@ -135,7 +135,7 @@ var PeriodicConsolidation = class {
     const filePath = this.getReportPath("monthly", period);
     this._writeReport(filePath, markdown);
     try {
-      const { indexConsolidationSummary } = await import("./consolidation-indexer-TOTTDZXW.js");
+      const { indexConsolidationSummary } = await import("./consolidation-indexer-A46RJU4R.js");
       await indexConsolidationSummary("monthly", period, markdown, this._project);
     } catch {
     }
@@ -278,7 +278,7 @@ var PeriodicConsolidation = class {
     const filePath = this.getReportPath("yearly", period);
     this._writeReport(filePath, markdown);
     try {
-      const { indexConsolidationSummary } = await import("./consolidation-indexer-TOTTDZXW.js");
+      const { indexConsolidationSummary } = await import("./consolidation-indexer-A46RJU4R.js");
       await indexConsolidationSummary("yearly", period, markdown, this._project);
     } catch {
     }
@@ -749,4 +749,4 @@ var PeriodicConsolidation = class {
 export {
   PeriodicConsolidation
 };
-//# sourceMappingURL=chunk-URGEODS5.js.map
+//# sourceMappingURL=chunk-DQMAQ2VL.js.map

package/chunks/{chunk-JZU37VQ5.js → chunk-F35MWELH.js}

@@ -6,11 +6,13 @@ import {
 import {
   listSessions,
   loadSession
-} from "./chunk-L7JICQBW.js";
+} from "./chunk-2ARPXEDC.js";
 import {
-  DatabaseManager,
   initVectorsSchema
-} from "./chunk-U6OLJ36B.js";
+} from "./chunk-YJRXLRTE.js";
+import {
+  DatabaseManager
+} from "./chunk-UQLPHNGH.js";
 import {
   getChitraguptaHome
 } from "./chunk-KC6NRZ7U.js";
@@ -711,4 +713,4 @@ export {
   RecallEngine,
   migrateEmbeddingsJson
 };
-//# sourceMappingURL=chunk-JZU37VQ5.js.map
+//# sourceMappingURL=chunk-F35MWELH.js.map

package/chunks/chunk-F4T7POKM.js

@@ -0,0 +1,545 @@
+import {
+  DatabaseManager
+} from "./chunk-UQLPHNGH.js";
+
+// ../chitragupta/packages/smriti/src/vasana-engine.ts
+var FNV_OFFSET = 2166136261;
+var FNV_PRIME = 16777619;
+function fnv1a(input) {
+  let hash = FNV_OFFSET;
+  for (let i = 0; i < input.length; i++) {
+    hash ^= input.charCodeAt(i);
+    hash = Math.imul(hash, FNV_PRIME) >>> 0;
+  }
+  return hash.toString(16).padStart(8, "0");
+}
+var DEFAULT_CONFIG = {
+  lambda: 50,
+  changePointThreshold: 0.3,
+  stabilityWindow: 5,
+  windowSize: 20,
+  holdoutTrainRatio: 0.7,
+  accuracyThreshold: 0.6,
+  decayHalfLifeMs: 30 * 864e5,
+  promotionMinProjects: 3,
+  maxRunLength: 200,
+  priorMu: 0,
+  priorKappa: 1,
+  priorAlpha: 1,
+  anomalyRevertWindow: 3,
+  anomalyConfirmRatio: 0.5
+};
+var HARD_CEILINGS = {
+  windowSize: 500,
+  maxRunLength: 2e3,
+  stabilityWindow: 100
+};
+function logsumexp(xs) {
+  if (xs.length === 0) return -Infinity;
+  const m = Math.max(...xs);
+  if (m === -Infinity) return -Infinity;
+  let s = 0;
+  for (let i = 0; i < xs.length; i++) s += Math.exp(xs[i] - m);
+  return m + Math.log(s);
+}
+function lgamma(z) {
+  const c = [
+    0.9999999999998099,
+    676.5203681218851,
+    -1259.1392167224028,
+    771.3234287776531,
+    -176.6150291621406,
+    12.507343278686905,
+    -0.13857109526572012,
+    9984369578019572e-21,
+    15056327351493116e-23
+  ];
+  if (z < 0.5) return Math.log(Math.PI / Math.sin(Math.PI * z)) - lgamma(1 - z);
+  z -= 1;
+  let x = c[0];
+  for (let i = 1; i < 9; i++) x += c[i] / (z + i);
+  const t = z + 7.5;
+  return 0.5 * Math.log(2 * Math.PI) + (z + 0.5) * Math.log(t) - t + Math.log(x);
+}
+function logStudentT(x, nu, mu, sigma) {
+  const safeSigma = sigma > 1e-15 ? sigma : 1e-15;
+  const z = (x - mu) / safeSigma;
+  return lgamma((nu + 1) / 2) - lgamma(nu / 2) - 0.5 * Math.log(nu * Math.PI * safeSigma * safeSigma) - (nu + 1) / 2 * Math.log(1 + z * z / nu);
+}
+var VasanaEngine = class {
+  cfg;
+  states = /* @__PURE__ */ new Map();
+  obs = /* @__PURE__ */ new Map();
+  cache = /* @__PURE__ */ new Map();
+  constructor(config) {
+    const merged = { ...DEFAULT_CONFIG, ...config };
+    for (const [k, ceil] of Object.entries(HARD_CEILINGS)) {
+      const key = k;
+      if (typeof merged[key] === "number" && typeof ceil === "number")
+        merged[key] = Math.min(merged[key], ceil);
+    }
+    this.cfg = merged;
+  }
+  // ── Core API ─────────────────────────────────────────────────────────
+  /** Observe a samskara: extract features and update BOCPD state per dimension. */
+  observe(samskara) {
+    for (const [feat, val] of this.extractFeatures(samskara)) {
+      if (!this.states.has(feat)) this.states.set(feat, this.initState());
+      const buf = this.obs.get(feat) ?? [];
+      buf.push(val);
+      if (buf.length > this.cfg.windowSize) buf.splice(0, buf.length - this.cfg.windowSize);
+      this.obs.set(feat, buf);
+      this.updateBOCPD(feat, val);
+    }
+  }
+  /** Run crystallization: stability check, holdout validation, vasana upsert. */
+  crystallize(project) {
+    const now = Date.now();
+    const res = { created: [], reinforced: [], pending: [], changePoints: [], anomalies: [], timestamp: now };
+    const db = DatabaseManager.instance().get("agent");
+    const rows = db.prepare(
+      `SELECT id, session_id, pattern_type, pattern_content, observation_count,
+			        confidence, pramana_type, project, created_at, updated_at
+			 FROM samskaras WHERE project = ? OR project IS NULL
+			 ORDER BY updated_at DESC LIMIT ?`
+    ).all(project, this.cfg.windowSize * 10);
+    for (const [key, ids] of this.clusterSamskaras(rows)) {
+      const feat = `cluster:${key}`;
+      const st = this.states.get(feat);
+      if (!st) {
+        res.pending.push(key);
+        continue;
+      }
+      const deviation = this.classifyDeviation(st);
+      if (deviation === "change-point") {
+        st.stableCount = 0;
+        res.changePoints.push(key);
+        continue;
+      }
+      if (deviation === "anomaly") {
+        res.anomalies.push(key);
+        continue;
+      }
+      st.stableCount++;
+      if (st.stableCount < this.cfg.stabilityWindow) {
+        res.pending.push(key);
+        continue;
+      }
+      const o = this.obs.get(feat) ?? [];
+      if (o.length < 4) {
+        res.pending.push(key);
+        continue;
+      }
+      const acc = this.holdoutValidation(o);
+      if (acc < this.cfg.accuracyThreshold) {
+        res.pending.push(key);
+        continue;
+      }
+      const stability = this.stabilityScore(st);
+      const valence = this.assignValence(rows.filter((r) => ids.has(r.id)));
+      const vid = fnv1a(key + ":" + project);
+      const existing = this.loadVasana(vid);
+      if (existing) {
+        existing.strength = Math.min(1, existing.strength + 0.1);
+        existing.stability = stability;
+        existing.reinforcementCount++;
+        existing.lastActivated = now;
+        existing.predictiveAccuracy = acc;
+        existing.updatedAt = now;
+        this.saveVasana(existing);
+        res.reinforced.push(existing);
+      } else {
+        const rep = rows.find((r) => ids.has(r.id));
+        const v = {
+          id: vid,
+          tendency: key.replace(/:/g, "-"),
+          description: rep?.pattern_content ?? key,
+          strength: 0.5 + acc * 0.3,
+          stability,
+          valence,
+          sourceSamskaras: [...ids],
+          reinforcementCount: 1,
+          lastActivated: now,
+          predictiveAccuracy: acc,
+          project,
+          createdAt: now,
+          updatedAt: now
+        };
+        this.saveVasana(v);
+        res.created.push(v);
+      }
+    }
+    return res;
+  }
+  /** Reinforce with diminishing returns: delta = 0.1 / (1 + ln(1 + count)). */
+  reinforce(vasanaId) {
+    const v = this.loadVasana(vasanaId);
+    if (!v) return;
+    v.strength = Math.min(1, v.strength + 0.1 / (1 + Math.log(1 + v.reinforcementCount)));
+    v.reinforcementCount++;
+    v.lastActivated = v.updatedAt = Date.now();
+    this.saveVasana(v);
+  }
+  /** Weaken by fixed decrement. */
+  weaken(vasanaId) {
+    const v = this.loadVasana(vasanaId);
+    if (!v) return;
+    v.strength = Math.max(0, v.strength - 0.15);
+    v.updatedAt = Date.now();
+    this.saveVasana(v);
+  }
+  /** Get vasanas for a project (includes global), sorted by strength desc. */
+  getVasanas(project, topK = 20) {
+    const rows = DatabaseManager.instance().get("agent").prepare(
+      `SELECT id,name,description,valence,strength,stability,source_samskaras,
+			        project,created_at,updated_at,last_activated,activation_count
+			 FROM vasanas WHERE project=? OR project IS NULL OR project='__global__'
+			 ORDER BY strength DESC LIMIT ?`
+    ).all(project, topK);
+    return rows.map((r) => this.toVasana(r));
+  }
+  /** Promote project vasanas to global when found in >= promotionMinProjects. */
+  promoteToGlobal() {
+    const now = Date.now();
+    const res = { promoted: [], projectSources: {}, timestamp: now };
+    const db = DatabaseManager.instance().get("agent");
+    const rows = db.prepare(
+      `SELECT id,name,description,valence,strength,stability,source_samskaras,
+			        project,created_at,updated_at,last_activated,activation_count
+			 FROM vasanas WHERE project IS NOT NULL AND project!='__global__' AND strength>=0.4
+			 ORDER BY name`
+    ).all();
+    const byName = /* @__PURE__ */ new Map();
+    for (const r of rows) {
+      const k = r.name.toLowerCase();
+      byName.set(k, [...byName.get(k) ?? [], r]);
+    }
+    for (const [tendency, group] of byName) {
+      const projects = new Set(group.map((r) => r.project));
+      if (projects.size < this.cfg.promotionMinProjects) continue;
+      if (db.prepare(`SELECT 1 FROM vasanas WHERE name=? AND (project IS NULL OR project='__global__')`).get(tendency)) continue;
+      const allSrc = [];
+      for (const r of group) allSrc.push(...jsonArr(r.source_samskaras));
+      const votes = { positive: 0, negative: 0, neutral: 0 };
+      for (const r of group) votes[r.valence]++;
+      const valence = ["positive", "negative", "neutral"].reduce((a, b) => votes[a] >= votes[b] ? a : b);
+      const gv = {
+        id: fnv1a(tendency + ":__global__"),
+        tendency,
+        description: group[0].description,
+        strength: group.reduce((s, r) => s + r.strength, 0) / group.length,
+        stability: Math.max(...group.map((r) => r.stability)),
+        valence,
+        sourceSamskaras: [...new Set(allSrc)],
+        reinforcementCount: group.reduce((s, r) => s + r.activation_count, 0),
+        lastActivated: now,
+        predictiveAccuracy: Math.max(...group.map((r) => r.stability)),
+        project: "__global__",
+        createdAt: now,
+        updatedAt: now
+      };
+      this.saveVasana(gv);
+      res.promoted.push(gv);
+      res.projectSources[tendency] = [...projects];
+    }
+    return res;
+  }
+  /** Exponential decay: strength *= exp(-ln2 * elapsed / halfLife). Deletes below 0.01. */
+  decay(halfLifeMs) {
+    const hl = halfLifeMs ?? this.cfg.decayHalfLifeMs;
+    const now = Date.now();
+    const db = DatabaseManager.instance().get("agent");
+    const rows = db.prepare(`SELECT id, strength, last_activated FROM vasanas`).all();
+    let deleted = 0;
+    for (const r of rows) {
+      const elapsed = now - (r.last_activated ?? now);
+      if (elapsed <= 0) continue;
+      const s = r.strength * Math.exp(-Math.LN2 * elapsed / hl);
+      if (s < 0.01) {
+        db.prepare(`DELETE FROM vasanas WHERE id=?`).run(r.id);
+        deleted++;
+      } else db.prepare(`UPDATE vasanas SET strength=?,updated_at=? WHERE id=?`).run(s, now, r.id);
+    }
+    return deleted;
+  }
+  /** Persist BOCPD state (run-length distributions + observations) to SQLite. */
+  persist() {
+    const json = JSON.stringify({
+      features: Object.fromEntries(this.states),
+      observations: Object.fromEntries(this.obs)
+    });
+    DatabaseManager.instance().get("agent").prepare(
+      `INSERT OR REPLACE INTO consolidation_rules
+			 (id, category, rule_text, confidence, source_sessions, created_at, updated_at, hit_count, project)
+			 VALUES ((SELECT id FROM consolidation_rules WHERE category='bocpd_state' AND project='__vasana_engine__'),
+			         'bocpd_state',?,1.0,NULL,?,?,1,'__vasana_engine__')`
+    ).run(json, Date.now(), Date.now());
+  }
+  /** Restore BOCPD state from SQLite. No-op if nothing persisted. */
+  restore() {
+    const row = DatabaseManager.instance().get("agent").prepare(
+      `SELECT rule_text FROM consolidation_rules
+			 WHERE category='bocpd_state' AND project='__vasana_engine__' LIMIT 1`
+    ).get();
+    if (!row) return;
+    try {
+      const s = JSON.parse(row.rule_text);
+      this.states = new Map(Object.entries(s.features));
+      this.obs = new Map(Object.entries(s.observations).map(([k, v]) => [k, Array.isArray(v) ? v : []]));
+    } catch (err) {
+      process.stderr.write(`[vasana-engine] restore() failed to parse BOCPD state: ${err instanceof Error ? err.message : err}
+`);
+      this.states.clear();
+      this.obs.clear();
+    }
+  }
+  // ── BOCPD Core (Adams & MacKay 2007) ─────────────────────────────────
+  initState() {
+    return {
+      logR: [0],
+      // P(r=0) = 1
+      stats: [{
+        mu: this.cfg.priorMu,
+        kappa: this.cfg.priorKappa,
+        alpha: this.cfg.priorAlpha,
+        beta: this.cfg.priorAlpha
+      }],
+      stableCount: 0,
+      totalObs: 0,
+      recentCpProbs: []
+    };
+  }
+  /**
+   * Online BOCPD update for one observation on one feature dimension.
+   *
+   * 1. Predictive P(x_t | r) via Student-t with Normal-Gamma sufficient stats
+   * 2. Growth: P(r_t=r+1) = P(x|r) * P(r) * (1-H)
+   * 3. Change-point: P(r_t=0) = sum_r P(x|r) * P(r) * H
+   * 4. Normalize, update sufficient stats, prune low-probability tails
+   */
+  updateBOCPD(feat, x) {
+    const st = this.states.get(feat);
+    const logH = -Math.log(this.cfg.lambda);
+    const log1H = Math.log(1 - 1 / this.cfg.lambda);
+    const n = st.logR.length;
+    const lpp = new Array(n);
+    for (let r = 0; r < n; r++) {
+      const s = st.stats[r];
+      lpp[r] = logStudentT(x, 2 * s.alpha, s.mu, Math.sqrt(s.beta * (s.kappa + 1) / (s.alpha * s.kappa)));
+    }
+    const cpTerms = new Array(n);
+    const newLR = new Array(n + 1);
+    for (let r = 0; r < n; r++) {
+      newLR[r + 1] = lpp[r] + st.logR[r] + log1H;
+      cpTerms[r] = lpp[r] + st.logR[r] + logH;
+    }
+    newLR[0] = logsumexp(cpTerms);
+    const logZ = logsumexp(newLR);
+    for (let i = 0; i <= n; i++) newLR[i] -= logZ;
+    const newS = new Array(n + 1);
+    newS[0] = {
+      mu: this.cfg.priorMu,
+      kappa: this.cfg.priorKappa,
+      alpha: this.cfg.priorAlpha,
+      beta: this.cfg.priorAlpha
+    };
+    for (let r = 0; r < n; r++) {
+      const p = st.stats[r];
+      const k = p.kappa + 1;
+      const dx = x - p.mu;
+      newS[r + 1] = {
+        mu: (p.kappa * p.mu + x) / k,
+        kappa: k,
+        alpha: p.alpha + 0.5,
+        beta: p.beta + 0.5 * p.kappa * dx * dx / k
+      };
+    }
+    if (newLR.length > this.cfg.maxRunLength) {
+      const idx = newLR.map((lp, i) => ({ lp, i })).sort((a, b) => b.lp - a.lp);
+      const keep = new Set(idx.slice(0, this.cfg.maxRunLength).map((e) => e.i));
+      const pR = [], pS = [];
+      for (let i = 0; i <= n; i++) if (keep.has(i)) {
+        pR.push(newLR[i]);
+        pS.push(newS[i]);
+      }
+      const norm = logsumexp(pR);
+      for (let i = 0; i < pR.length; i++) pR[i] -= norm;
+      st.logR = pR;
+      st.stats = pS;
+    } else {
+      st.logR = newLR;
+      st.stats = newS;
+    }
+    st.totalObs++;
+    const cpProb = st.logR.length > 0 ? Math.exp(st.logR[0]) : 0;
+    if (!st.recentCpProbs) st.recentCpProbs = [];
+    st.recentCpProbs.push(cpProb);
+    if (st.recentCpProbs.length > this.cfg.anomalyRevertWindow) {
+      st.recentCpProbs.shift();
+    }
+  }
+  /**
+   * Classify a deviation as change-point, anomaly, or stable.
+   *
+   * Joint anomaly/change-point discrimination (arxiv 2508.06385):
+   * - If P(r=0) > threshold and persists across the revert window → change-point
+   * - If P(r=0) > threshold but reverts within the window → anomaly (one-off)
+   * - Otherwise → stable
+   */
+  classifyDeviation(st) {
+    if (st.logR.length === 0) return "stable";
+    const cpProb = Math.exp(st.logR[0]);
+    if (cpProb <= this.cfg.changePointThreshold) return "stable";
+    const recent = st.recentCpProbs ?? [cpProb];
+    const exceedCount = recent.filter((p) => p > this.cfg.changePointThreshold).length;
+    const ratio = exceedCount / Math.max(1, recent.length);
+    if (recent.length >= this.cfg.anomalyRevertWindow && ratio >= this.cfg.anomalyConfirmRatio) {
+      return "change-point";
+    }
+    return "anomaly";
+  }
+  isChangePoint(st) {
+    return this.classifyDeviation(st) === "change-point";
+  }
+  stabilityScore(st) {
+    if (st.logR.length === 0) return 0;
+    return Math.max(0, Math.min(1, 1 - Math.exp(st.logR[0])));
+  }
+  // ── Feature Extraction & Validation ──────────────────────────────────
+  extractFeatures(s) {
+    const f = /* @__PURE__ */ new Map();
+    const tMap = {
+      "tool-sequence": 0.2,
+      preference: 0.4,
+      decision: 0.6,
+      correction: 0.8,
+      convention: 1
+    };
+    f.set(`type:${s.patternType}`, tMap[s.patternType] ?? 0.5);
+    f.set("confidence", s.confidence);
+    f.set("log_obs", Math.min(1, Math.log(1 + s.observationCount) / Math.log(101)));
+    const ch = parseInt(fnv1a(s.patternContent), 16);
+    f.set(`cluster:${s.patternType}:${fnv1a(s.patternContent)}`, ch / 4294967295);
+    return f;
+  }
+  /** 70/30 holdout: fraction of test points within 1.5 sigma of train mean. */
+  holdoutValidation(obs) {
+    if (obs.length < 4) return 0;
+    const si = Math.floor(obs.length * this.cfg.holdoutTrainRatio);
+    const train = obs.slice(0, si), test = obs.slice(si);
+    if (!train.length || !test.length) return 0;
+    const mu = train.reduce((a, b) => a + b, 0) / train.length;
+    const std = Math.sqrt(train.reduce((a, v) => a + (v - mu) ** 2, 0) / train.length + 1e-10);
+    let ok = 0;
+    for (const v of test) if (Math.abs(v - mu) <= 1.5 * std) ok++;
+    return ok / test.length;
+  }
+  assignValence(rows) {
+    let pos = 0, neg = 0;
+    for (const r of rows) {
+      if (r.pattern_type === "correction") neg += r.confidence;
+      else if (r.pattern_type !== "tool-sequence" || r.confidence > 0.6)
+        pos += r.confidence * (r.pattern_type === "tool-sequence" ? 0.5 : 1);
+    }
+    const tot = pos + neg;
+    if (tot < 0.1) return "neutral";
+    return pos / tot > 0.6 ? "positive" : neg / tot > 0.6 ? "negative" : "neutral";
+  }
+  clusterSamskaras(rows) {
+    const m = /* @__PURE__ */ new Map();
+    for (const r of rows) {
+      const k = `${r.pattern_type}:${fnv1a(r.pattern_content.toLowerCase().trim().replace(/\s+/g, " "))}`;
+      const s = m.get(k) ?? /* @__PURE__ */ new Set();
+      s.add(r.id);
+      m.set(k, s);
+    }
+    return m;
+  }
+  // ── SQLite Helpers ───────────────────────────────────────────────────
+  // Schema mapping: Vasana.tendency→name, sourceSamskaras→source_samskaras(JSON),
+  //                 reinforcementCount→activation_count, lastActivated→last_activated
+  saveVasana(v) {
+    const db = DatabaseManager.instance().get("agent");
+    const existing = db.prepare(
+      `SELECT id FROM vasanas WHERE name=? AND (project=? OR (project IS NULL AND ?='__global__'))`
+    ).get(v.tendency, v.project, v.project);
+    if (existing) {
+      db.prepare(
+        `UPDATE vasanas SET description=?,valence=?,strength=?,stability=?,
+				 source_samskaras=?,updated_at=?,last_activated=?,activation_count=? WHERE id=?`
+      ).run(
+        v.description,
+        v.valence,
+        v.strength,
+        v.stability,
+        JSON.stringify(v.sourceSamskaras),
+        v.updatedAt,
+        v.lastActivated,
+        v.reinforcementCount,
+        existing.id
+      );
+    } else {
+      db.prepare(
+        `INSERT INTO vasanas (name,description,valence,strength,stability,source_samskaras,
+				 project,created_at,updated_at,last_activated,activation_count) VALUES (?,?,?,?,?,?,?,?,?,?,?)`
+      ).run(
+        v.tendency,
+        v.description,
+        v.valence,
+        v.strength,
+        v.stability,
+        JSON.stringify(v.sourceSamskaras),
+        v.project === "__global__" ? null : v.project,
+        v.createdAt,
+        v.updatedAt,
+        v.lastActivated,
+        v.reinforcementCount
+      );
+    }
+    this.cache.set(v.id, v);
+  }
+  loadVasana(vid) {
+    if (this.cache.has(vid)) return this.cache.get(vid);
+    const rows = DatabaseManager.instance().get("agent").prepare(
+      `SELECT id,name,description,valence,strength,stability,source_samskaras,
+			        project,created_at,updated_at,last_activated,activation_count FROM vasanas`
+    ).all();
+    for (const r of rows) {
+      const v = this.toVasana(r);
+      this.cache.set(v.id, v);
+    }
+    return this.cache.get(vid) ?? null;
+  }
+  toVasana(r) {
+    const proj = r.project ?? "__global__";
+    return {
+      id: fnv1a(r.name + ":" + proj),
+      tendency: r.name,
+      description: r.description,
+      strength: r.strength,
+      stability: r.stability,
+      valence: r.valence,
+      sourceSamskaras: jsonArr(r.source_samskaras),
+      reinforcementCount: r.activation_count,
+      lastActivated: r.last_activated ?? r.updated_at,
+      predictiveAccuracy: r.stability,
+      project: proj,
+      createdAt: r.created_at,
+      updatedAt: r.updated_at
+    };
+  }
+};
+function jsonArr(s) {
+  if (!s) return [];
+  try {
+    const p = JSON.parse(s);
+    return Array.isArray(p) ? p : [];
+  } catch {
+    return [];
+  }
+}
+
+export {
+  VasanaEngine
+};
+//# sourceMappingURL=chunk-F4T7POKM.js.map

package/chunks/{chunk-H76V36OF.js → chunk-FPNQLJLD.js}

@@ -696,7 +696,7 @@ async function consolidateDay(date, options) {
   if (options?.loadSessions) {
     sessions = await options.loadSessions(date);
   } else {
-    const { listSessionsByDate, listTurnsWithTimestamps, loadSession } = await import("./session-store-XKPGKXUS.js");
+    const { listSessionsByDate, listTurnsWithTimestamps, loadSession } = await import("./session-store-GRKGTMHI.js");
     const metas = listSessionsByDate(date);
     sessions = metas.map((meta) => {
       try {
@@ -771,7 +771,7 @@ async function consolidateDay(date, options) {
   fs.mkdirSync(dir, { recursive: true });
   fs.writeFileSync(dayPath, markdown, "utf-8");
   try {
-    const { indexConsolidationSummary } = await import("./consolidation-indexer-TOTTDZXW.js");
+    const { indexConsolidationSummary } = await import("./consolidation-indexer-A46RJU4R.js");
     await indexConsolidationSummary("daily", date, markdown);
   } catch {
   }
@@ -999,7 +999,7 @@ function isDayConsolidated(date) {
   return fs.existsSync(getDayFilePath(date));
 }
 async function getUnconsolidatedDates(limit) {
-  const { listSessionDates } = await import("./session-store-XKPGKXUS.js");
+  const { listSessionDates } = await import("./session-store-GRKGTMHI.js");
   const sessionDates = listSessionDates();
   const unconsolidated = [];
   for (const date of sessionDates) {
@@ -1026,4 +1026,4 @@ export {
   isDayConsolidated,
   getUnconsolidatedDates
 };
-//# sourceMappingURL=chunk-H76V36OF.js.map
+//# sourceMappingURL=chunk-FPNQLJLD.js.map

package/chunks/{chunk-KDRROLVN.js → chunk-NBXCXQ3H.js}

@@ -1,6 +1,6 @@
 import {
   searchSessions
-} from "./chunk-ITIVYGUG.js";
+} from "./chunk-UW6E7IC4.js";
 
 // ../chitragupta/packages/smriti/src/hybrid-search.ts
 var PRAMANA_RELIABILITY = {
@@ -430,4 +430,4 @@ export {
   shouldRetrieve,
   HybridSearchEngine
 };
-//# sourceMappingURL=chunk-KDRROLVN.js.map
+//# sourceMappingURL=chunk-NBXCXQ3H.js.map

package/chunks/{chunk-YSU3BWV6.js → chunk-OWBBY5XP.js}

@@ -7,7 +7,7 @@ var DEPTH_BOOST = {
 async function hierarchicalTemporalSearch(query, options) {
   const limit = options?.limit ?? 10;
   const results = [];
-  const { searchConsolidationSummaries } = await import("./consolidation-indexer-TOTTDZXW.js");
+  const { searchConsolidationSummaries } = await import("./consolidation-indexer-A46RJU4R.js");
   const yearlyHits = await searchConsolidationSummaries(query, "yearly", {
     limit: 3,
     project: options?.project
@@ -120,4 +120,4 @@ function deduplicateAndSort(results, limit) {
 export {
   hierarchicalTemporalSearch
 };
-//# sourceMappingURL=chunk-YSU3BWV6.js.map
+//# sourceMappingURL=chunk-OWBBY5XP.js.map

package/chunks/{chunk-S4TBVCL2.js → chunk-SLA2OIMG.js}

@@ -8,9 +8,11 @@ import {
   textMatchScore
 } from "./chunk-JAWZ7ANC.js";
 import {
-  DatabaseManager,
   initGraphSchema
-} from "./chunk-U6OLJ36B.js";
+} from "./chunk-YJRXLRTE.js";
+import {
+  DatabaseManager
+} from "./chunk-UQLPHNGH.js";
 import {
   getChitraguptaHome
 } from "./chunk-KC6NRZ7U.js";
@@ -2155,4 +2157,4 @@ export {
   GraphRAGEngine,
   migrateGraphJson
 };
-//# sourceMappingURL=chunk-S4TBVCL2.js.map
+//# sourceMappingURL=chunk-SLA2OIMG.js.map