@yugenlab/vaayu 0.1.8 → 0.1.10

package/chunks/{chunk-DOQMEQ5S.js → chunk-AS3DJFY3.js}

@@ -1,7 +1,7 @@
 import {
   blobToVector,
   vectorToBlob
-} from "./chunk-LVE2EOOH.js";
+} from "./chunk-VJHNE47S.js";
 import {
   EmbeddingService,
   cosineSimilarity,
@@ -186,7 +186,7 @@ async function backfillConsolidationIndices() {
       db.prepare("SELECT id FROM embeddings WHERE source_type IN ('daily_summary', 'monthly_summary', 'yearly_summary')").all().map((r) => r.id)
     );
     try {
-      const { listDayFiles, readDayFile } = await import("./day-consolidation-U3X6P4ZG.js");
+      const { listDayFiles, readDayFile } = await import("./day-consolidation-BH3QU2SZ.js");
       const dayFiles = listDayFiles();
       for (const date of dayFiles) {
         const id = buildEmbeddingId("daily", date);
@@ -200,8 +200,8 @@ async function backfillConsolidationIndices() {
     } catch {
     }
     try {
-      const { PeriodicConsolidation } = await import("./periodic-consolidation-4MACZE6S.js");
-      const { listSessionProjects } = await import("./session-store-NDUDYAC7.js");
+      const { PeriodicConsolidation } = await import("./periodic-consolidation-LMYMNS4Q.js");
+      const { listSessionProjects } = await import("./session-store-3BRPGC6P.js");
       const projectEntries = listSessionProjects();
       for (const entry of projectEntries) {
         const project = entry.project;
@@ -237,4 +237,4 @@ export {
   searchConsolidationSummaries,
   backfillConsolidationIndices
 };
-//# sourceMappingURL=chunk-DOQMEQ5S.js.map
+//# sourceMappingURL=chunk-AS3DJFY3.js.map

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

@@ -516,11 +516,33 @@ function upsertSessionToDb(meta, filePath) {
 `);
   }
 }
-function insertTurnToDb(sessionId, turn) {
+function isRecoverableSessionConstraintError(err) {
+  if (!(err instanceof Error)) return false;
+  const lower = err.message.toLowerCase();
+  return lower.includes("foreign key constraint failed") || lower.includes("constraint failed");
+}
+function seedSessionRowForTurn(sessionId, project, filePath) {
+  const db = getAgentDb();
+  const now = Date.now();
+  const normalizedFilePath = path.isAbsolute(filePath) ? path.relative(getChitraguptaHome(), filePath) : filePath;
+  db.prepare(`
+		INSERT OR IGNORE INTO sessions (id, project, title, created_at, updated_at, turn_count, file_path)
+		VALUES (?, ?, ?, ?, ?, ?, ?)
+	`).run(
+    sessionId,
+    project,
+    "Recovered Session",
+    now,
+    now,
+    0,
+    normalizedFilePath
+  );
+}
+function insertTurnToDb(sessionId, turn, context) {
   try {
     const db = getAgentDb();
-    const now = Date.now();
-    const insertTurn = db.transaction(() => {
+    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 (?, ?, ?, ?, ?, ?, ?, ?)
@@ -535,7 +557,7 @@ function insertTurnToDb(sessionId, turn) {
         now
       );
       if (result.changes > 0) {
-        db.prepare("INSERT INTO turns_fts (rowid, content) VALUES (?, ?)").run(
+        db.prepare("INSERT OR IGNORE INTO turns_fts (rowid, content) VALUES (?, ?)").run(
           result.lastInsertRowid,
           turn.content
         );
@@ -544,10 +566,23 @@ function insertTurnToDb(sessionId, turn) {
         "UPDATE sessions SET turn_count = turn_count + 1, updated_at = ? WHERE id = ?"
       ).run(now, sessionId);
     });
-    insertTurn();
+    try {
+      writeTurn2();
+      return;
+    } catch (err) {
+      if (context && isRecoverableSessionConstraintError(err)) {
+        seedSessionRowForTurn(sessionId, context.project, context.filePath);
+        writeTurn2();
+        return;
+      }
+      throw err;
+    }
   } catch (err) {
-    process.stderr.write(`[chitragupta] turn insert failed for session ${sessionId}: ${err instanceof Error ? err.message : err}
-`);
+    const code = typeof err === "object" && err !== null && "code" in err ? String(err.code) : "unknown";
+    process.stderr.write(
+      `[chitragupta] turn insert failed for session ${sessionId} (turn=${turn.turnNumber}, role=${turn.role}, code=${code}): ${err instanceof Error ? err.message : err}
+`
+    );
   }
 }
 function createSession(opts) {
@@ -814,7 +849,7 @@ function addTurn(sessionId, project, turn) {
 ${turnMd}
 `, "utf-8");
     cacheInvalidate(sessionId, project);
-    insertTurnToDb(sessionId, turn);
+    insertTurnToDb(sessionId, turn, { project, filePath });
   }).catch((err) => {
     throw err;
   }).finally(() => {
@@ -1005,4 +1040,4 @@ export {
   findSessionByMetadata,
   migrateExistingSessions
 };
-//# sourceMappingURL=chunk-NHRBVSN3.js.map
+//# sourceMappingURL=chunk-HIYHTWFW.js.map

package/chunks/{chunk-IGBRBFXX.js → chunk-JGI4SDWS.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-CD6DS2HO.js");
+  const { searchConsolidationSummaries } = await import("./consolidation-indexer-VKQ6DNU3.js");
   const yearlyHits = await searchConsolidationSummaries(query, "yearly", {
     limit: 3,
     project: options?.project
@@ -120,4 +120,4 @@ function deduplicateAndSort(results, limit) {
 export {
   hierarchicalTemporalSearch
 };
-//# sourceMappingURL=chunk-IGBRBFXX.js.map
+//# sourceMappingURL=chunk-JGI4SDWS.js.map

package/chunks/{chunk-D3RVJGO7.js → chunk-M7THR63C.js}

@@ -1,26 +1,8 @@
 import {
   searchSessions
-} from "./chunk-PJEYJQ2C.js";
+} from "./chunk-O4KV7TFP.js";
 
-// ../chitragupta/packages/smriti/src/hybrid-search.ts
-var PRAMANA_RELIABILITY = {
-  pratyaksha: 1,
-  anumana: 0.85,
-  shabda: 0.75,
-  upamana: 0.6,
-  arthapatti: 0.5,
-  anupalabdhi: 0.4
-};
-var DEFAULT_CONFIG = {
-  k: 60,
-  topK: 10,
-  enableBM25: true,
-  enableVector: true,
-  enableGraphRAG: true,
-  pramanaWeight: 0.1,
-  enablePramana: true,
-  minScore: 0
-};
+// ../chitragupta/packages/smriti/src/hybrid-search-learner.ts
 function gaussianRandom() {
   const u1 = Math.random();
   const u2 = Math.random();
@@ -61,15 +43,17 @@ var SIGNAL_INDEX = {
 };
 var NUM_SIGNALS = 4;
 var HybridWeightLearner = class {
-  /** Success counts (α) for each of the 4 signals. */
+  /** Success counts (alpha) for each of the 4 signals. */
   _alphas;
-  /** Failure counts (β) for each of the 4 signals. */
+  /** Failure counts (beta) for each of the 4 signals. */
   _betas;
   /** Total feedback events received. */
   _totalFeedback;
   /**
-   * @param priorAlpha - Initial α for all signals. Default: 1 (uniform prior).
-   * @param priorBeta - Initial β for all signals. Default: 1 (uniform prior).
+   * Create a new weight learner with the given prior.
+   *
+   * @param priorAlpha - Initial alpha for all signals. Default: 1 (uniform prior).
+   * @param priorBeta - Initial beta for all signals. Default: 1 (uniform prior).
    */
   constructor(priorAlpha = 1, priorBeta = 1) {
     this._alphas = new Float64Array(NUM_SIGNALS);
@@ -83,7 +67,7 @@ var HybridWeightLearner = class {
   /**
    * Sample a weight vector from the Beta posteriors.
    *
-   * Each signal's weight is sampled from Beta(α_i, β_i), then the 4
+   * Each signal's weight is sampled from Beta(alpha_i, beta_i), then the 4
    * weights are normalized to sum to 1 (Dirichlet-like normalization).
    *
    * @returns Normalized weight vector { bm25, vector, graphrag, pramana }.
@@ -122,8 +106,10 @@ var HybridWeightLearner = class {
     this._totalFeedback += 1;
   }
   /**
-   * Get the posterior mean for each signal: α / (α + β).
+   * Get the posterior mean for each signal: alpha / (alpha + beta).
    * Useful for diagnostics and logging.
+   *
+   * @returns Posterior mean for each of the 4 signals.
    */
   means() {
     const m = (i) => this._alphas[i] / (this._alphas[i] + this._betas[i]);
@@ -148,6 +134,8 @@ var HybridWeightLearner = class {
   /**
    * Restore the learner state from a serialized object.
    *
+   * Silently ignores invalid data to avoid corrupting the current state.
+   *
    * @param data - Previously serialized state from `serialize()`.
    */
   restore(data) {
@@ -161,6 +149,26 @@ var HybridWeightLearner = class {
     this._totalFeedback = data.totalFeedback ?? 0;
   }
 };
+
+// ../chitragupta/packages/smriti/src/hybrid-search.ts
+var PRAMANA_RELIABILITY = {
+  pratyaksha: 1,
+  anumana: 0.85,
+  shabda: 0.75,
+  upamana: 0.6,
+  arthapatti: 0.5,
+  anupalabdhi: 0.4
+};
+var DEFAULT_CONFIG = {
+  k: 60,
+  topK: 10,
+  enableBM25: true,
+  enableVector: true,
+  enableGraphRAG: true,
+  pramanaWeight: 0.1,
+  enablePramana: true,
+  minScore: 0
+};
 function shouldRetrieve(query) {
   const lower = query.toLowerCase().trim();
   const gapPatterns = [
@@ -199,6 +207,7 @@ var HybridSearchEngine = class {
   config;
   weightLearner;
   kalaChakra;
+  /** Create a new hybrid search engine with optional engines and learner. */
   constructor(config, recallEngine, graphEngine, weightLearner) {
     this.config = { ...DEFAULT_CONFIG, ...config };
     this.recallEngine = recallEngine ?? null;
@@ -206,51 +215,33 @@ var HybridSearchEngine = class {
     this.weightLearner = weightLearner ?? null;
     this.kalaChakra = null;
   }
-  /**
-   * Set or replace the RecallEngine instance.
-   */
+  /** Set or replace the RecallEngine instance. */
   setRecallEngine(engine) {
     this.recallEngine = engine;
   }
-  /**
-   * Set or replace the GraphRAGEngine instance.
-   */
+  /** Set or replace the GraphRAGEngine instance. */
   setGraphEngine(engine) {
     this.graphEngine = engine;
   }
-  /**
-   * Set or replace the HybridWeightLearner instance.
-   */
+  /** Set or replace the HybridWeightLearner instance. */
   setWeightLearner(learner) {
     this.weightLearner = learner;
   }
-  /**
-   * Get the current HybridWeightLearner, or null if not set.
-   */
+  /** Get the current HybridWeightLearner, or null if not set. */
   getWeightLearner() {
     return this.weightLearner;
   }
-  /**
-   * Set or replace the KalaChakra temporal awareness engine.
-   * When set, search results with timestamps receive a temporal boost.
-   */
+  /** Set or replace the KalaChakra temporal awareness engine. */
   setKalaChakra(kala) {
     this.kalaChakra = kala;
   }
-  /**
-   * Get the current KalaChakra instance, or null if not set.
-   */
+  /** Get the current KalaChakra instance, or null if not set. */
   getKalaChakra() {
     return this.kalaChakra;
   }
   /**
-   * Record feedback for a search result.
-   *
-   * Updates the Thompson Sampling weight learner based on which signals
-   * contributed to the result the user selected (success) or rejected (failure).
-   *
-   * @param result - The search result receiving feedback.
-   * @param success - true = user found it useful, false = irrelevant.
+   * Record feedback for a search result. Updates Thompson Sampling posteriors
+   * for each contributing signal (and pramana if present).
    */
   recordFeedback(result, success) {
     if (!this.weightLearner) return;
@@ -262,20 +253,8 @@ var HybridSearchEngine = class {
     }
   }
   /**
-   * Perform hybrid search across all enabled rankers.
-   *
-   * Each ranker produces its own ranking. Results are fused via RRF:
-   *   score(d) = Σ w_i / (k + rank_i(d))
-   *
-   * When a HybridWeightLearner is set, w_i are Thompson-sampled weights.
-   * Otherwise, all weights are 1.0 (standard RRF).
-   *
-   * When pramana is enabled, each result receives an additive epistemic boost:
-   *   finalScore += δ * pramanaReliability(d)
-   *
-   * @param query - The search query.
-   * @param configOverride - Optional per-query config overrides.
-   * @returns Fused results sorted by score descending.
+   * Perform hybrid search across all enabled rankers, fusing via weighted RRF.
+   * When a HybridWeightLearner is set, weights are Thompson-sampled; otherwise uniform.
    */
   async search(query, configOverride) {
     const cfg = { ...this.config, ...configOverride };
@@ -412,12 +391,7 @@ var HybridSearchEngine = class {
       timestamp: r.timestamp
     }));
   }
-  /**
-   * Self-RAG gated search — only retrieves if the query signals a knowledge gap.
-   *
-   * @param query - The query to evaluate and optionally search.
-   * @returns Results if retrieval was triggered, empty array otherwise.
-   */
+  /** Self-RAG gated search -- only retrieves if the query signals a knowledge gap. */
   async gatedSearch(query, configOverride) {
     if (!shouldRetrieve(query)) return [];
     return this.search(query, configOverride);
@@ -425,9 +399,9 @@ var HybridSearchEngine = class {
 };
 
 export {
-  PRAMANA_RELIABILITY,
   HybridWeightLearner,
+  PRAMANA_RELIABILITY,
   shouldRetrieve,
   HybridSearchEngine
 };
-//# sourceMappingURL=chunk-D3RVJGO7.js.map
+//# sourceMappingURL=chunk-M7THR63C.js.map

package/chunks/{chunk-OBYBBGHA.js → chunk-N22M7D4P.js}

@@ -2,7 +2,7 @@ import {
   DatabaseManager
 } from "./chunk-U62ABYKD.js";
 
-// ../chitragupta/packages/smriti/src/vasana-engine.ts
+// ../chitragupta/packages/smriti/src/vasana-bocpd.ts
 var FNV_OFFSET = 2166136261;
 var FNV_PRIME = 16777619;
 function fnv1a(input) {
@@ -13,7 +13,7 @@ function fnv1a(input) {
   }
   return hash.toString(16).padStart(8, "0");
 }
-var DEFAULT_CONFIG = {
+var DEFAULT_VASANA_CONFIG = {
   lambda: 50,
   changePointThreshold: 0.3,
   stabilityWindow: 5,
@@ -66,13 +66,104 @@ function logStudentT(x, nu, mu, sigma) {
   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);
 }
+function initBOCPD(cfg) {
+  return {
+    logR: [0],
+    // P(r=0) = 1
+    stats: [{
+      mu: cfg.priorMu,
+      kappa: cfg.priorKappa,
+      alpha: cfg.priorAlpha,
+      beta: cfg.priorAlpha
+    }],
+    stableCount: 0,
+    totalObs: 0,
+    recentCpProbs: []
+  };
+}
+function updateBOCPD(st, x, cfg) {
+  const logH = -Math.log(cfg.lambda);
+  const log1H = Math.log(1 - 1 / 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: cfg.priorMu,
+    kappa: cfg.priorKappa,
+    alpha: cfg.priorAlpha,
+    beta: 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 > cfg.maxRunLength) {
+    const idx = newLR.map((lp, i) => ({ lp, i })).sort((a, b) => b.lp - a.lp);
+    const keep = new Set(idx.slice(0, 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 > cfg.anomalyRevertWindow) {
+    st.recentCpProbs.shift();
+  }
+}
+function serializeBOCPD(states, obs) {
+  return {
+    features: Object.fromEntries(states),
+    observations: Object.fromEntries(obs)
+  };
+}
+function deserializeBOCPD(raw) {
+  return {
+    states: new Map(Object.entries(raw.features)),
+    obs: new Map(
+      Object.entries(raw.observations).map(([k, v]) => [k, Array.isArray(v) ? v : []])
+    )
+  };
+}
+
+// ../chitragupta/packages/smriti/src/vasana-engine.ts
 var VasanaEngine = class {
   cfg;
   states = /* @__PURE__ */ new Map();
   obs = /* @__PURE__ */ new Map();
   cache = /* @__PURE__ */ new Map();
   constructor(config) {
-    const merged = { ...DEFAULT_CONFIG, ...config };
+    const merged = { ...DEFAULT_VASANA_CONFIG, ...config };
     for (const [k, ceil] of Object.entries(HARD_CEILINGS)) {
       const key = k;
       if (typeof merged[key] === "number" && typeof ceil === "number")
@@ -84,12 +175,12 @@ var VasanaEngine = class {
   /** 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());
+      if (!this.states.has(feat)) this.states.set(feat, initBOCPD(this.cfg));
       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);
+      updateBOCPD(this.states.get(feat), val, this.cfg);
     }
   }
   /** Run crystallization: stability check, holdout validation, vasana upsert. */
@@ -264,10 +355,7 @@ var VasanaEngine = class {
   }
   /** Persist BOCPD state (run-length distributions + observations) to SQLite. */
   persist() {
-    const json = JSON.stringify({
-      features: Object.fromEntries(this.states),
-      observations: Object.fromEntries(this.obs)
-    });
+    const json = JSON.stringify(serializeBOCPD(this.states, 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)
@@ -283,9 +371,10 @@ var VasanaEngine = class {
     ).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 : []]));
+      const raw = JSON.parse(row.rule_text);
+      const { states, obs } = deserializeBOCPD(raw);
+      this.states = states;
+      this.obs = obs;
     } catch (err) {
       process.stderr.write(`[vasana-engine] restore() failed to parse BOCPD state: ${err instanceof Error ? err.message : err}
 `);
@@ -293,98 +382,14 @@ var VasanaEngine = class {
       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();
-    }
-  }
+  // ── Deviation Classification ─────────────────────────────────────────
   /**
    * 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
+   * - 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";
@@ -398,9 +403,6 @@ var VasanaEngine = class {
     }
     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])));
@@ -456,8 +458,8 @@ var VasanaEngine = class {
     return m;
   }
   // ── SQLite Helpers ───────────────────────────────────────────────────
-  // Schema mapping: Vasana.tendency→name, sourceSamskaras→source_samskaras(JSON),
-  //                 reinforcementCount→activation_count, lastActivated→last_activated
+  // 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(
@@ -540,6 +542,16 @@ function jsonArr(s) {
 }
 
 export {
+  fnv1a,
+  DEFAULT_VASANA_CONFIG,
+  HARD_CEILINGS,
+  logsumexp,
+  lgamma,
+  logStudentT,
+  initBOCPD,
+  updateBOCPD,
+  serializeBOCPD,
+  deserializeBOCPD,
   VasanaEngine
 };
-//# sourceMappingURL=chunk-OBYBBGHA.js.map
+//# sourceMappingURL=chunk-N22M7D4P.js.map

package/chunks/{chunk-PJEYJQ2C.js → chunk-O4KV7TFP.js}

@@ -5,7 +5,7 @@ import {
 import {
   listSessions,
   loadSession
-} from "./chunk-NHRBVSN3.js";
+} from "./chunk-HIYHTWFW.js";
 import {
   initAgentSchema
 } from "./chunk-YJRXLRTE.js";
@@ -346,4 +346,4 @@ export {
   searchSessions,
   searchMemory
 };
-//# sourceMappingURL=chunk-PJEYJQ2C.js.map
+//# sourceMappingURL=chunk-O4KV7TFP.js.map