entroly-wasm 0.19.4 → 0.19.5

package/js/server.js

@@ -10,6 +10,7 @@ const { CheckpointManager, persistIndex, loadIndex } = require('./checkpoint');
 const { autoIndex, startIncrementalWatcher } = require('./auto_index');
 const { startAutotuneDaemon, FeedbackJournal, TaskProfileOptimizer } = require('./autotune');
 const { VaultManager } = require('./vault');
+const { getTracker } = require('./value_tracker');
 const { EpistemicRouter, BeliefCompiler, VerificationEngine, ChangePipeline, FlowOrchestrator, compileDocs, exportTrainingData } = require('./cogops');
 const { WorkspaceChangeListener } = require('./workspace');
 const { SkillEngine } = require('./skills');
@@ -26,6 +27,11 @@ class EntrolyMCPServer {
     this.engine = new WasmEntrolyEngine();
     this.turnCounter = 0;
 
+    // Shared cross-runtime telemetry sink — SAME file/schema/dir as the
+    // Python tracker, so npm users' value shows up on the same dashboard
+    // as pip/MCP/SDK users. Fail-open: never let telemetry break a tool.
+    try { this.valueTracker = getTracker(); } catch (_) { this.valueTracker = null; }
+
     // Feedback journal — persists episodes for cross-session autotune
     this.feedbackJournal = new FeedbackJournal(this.config.checkpointDir);
     // Task-conditioned weight profiles (novel: per-task-type optimization)
@@ -112,6 +118,8 @@ class EntrolyMCPServer {
       // ── Analysis Tools (2) ──
       { name: 'repo_file_map', description: 'Return the canonical Entroly file map across Python, Rust core, and WASM repos with ownership roles.', inputSchema: { type: 'object', properties: { format: { type: 'string', description: 'Output format: markdown or json', default: 'markdown' } } } },
       { name: 'prefetch_related', description: 'Predict which files the LLM will need next based on co-access patterns and dependency graph.', inputSchema: { type: 'object', properties: { file_path: { type: 'string', description: 'Current file being worked on' }, source_content: { type: 'string', description: 'Content of current file for import analysis', default: '' }, language: { type: 'string', description: 'Programming language', default: '' } }, required: ['file_path'] } },
+      // ── Hallucination Detection Tool ──
+      { name: 'verify_response', description: 'Verify an AI-generated response for hallucination. Computes entity coverage gap, hedging curvature, and entropy consistency. Returns fused_risk [0.0=safe, 1.0=hallucinated], verdict (pass/warn/flag), and flagged claims. All local — zero LLM calls.', inputSchema: { type: 'object', properties: { response: { type: 'string', description: 'The AI-generated text to verify' }, context: { type: 'string', description: 'Source context provided to the AI', default: '' }, prompt: { type: 'string', description: 'Original user prompt', default: '' } }, required: ['response'] } },
     ];
   }
 
@@ -130,6 +138,18 @@ class EntrolyMCPServer {
         const profile = this.taskProfiles.applyToEngine(this.engine, query);
         const result = this.engine.optimize(budget, query);
         result._taskProfile = { taskType: profile.taskType, confidence: profile.confidence };
+        // Record value to the shared sink (mirrors entroly/server.py).
+        try {
+          const ts = (result && result.tokens_saved) || 0;
+          if (this.valueTracker && ts > 0) {
+            this.valueTracker.record({
+              tokensSaved: ts,
+              model: (result && result.model) || '',
+              duplicates: (result && result.duplicates_caught) || 0,
+              optimized: true,
+            });
+          }
+        } catch (_) { /* never fail optimization for telemetry */ }
         const state = this.engine.export_state();
         this._lastOptCtx = { weights: { w_r: state.w_recency, w_f: state.w_frequency, w_s: state.w_semantic, w_e: state.w_entropy }, selectedSources: (result.selected || []).map(s => s.source).filter(Boolean), selectedCount: result.selected_count || 0, tokenBudget: budget, query, turn: this.turnCounter };
         if (this.checkpointMgr.shouldAutoCheckpoint()) { try { persistIndex(this.engine, this.indexPath); this.checkpointMgr.save({ engine_state: state, turn: this.turnCounter }); } catch {} }
@@ -181,7 +201,21 @@ class EntrolyMCPServer {
       case 'entroly_dashboard': {
         const stats = this.engine.stats();
         const explanation = this.engine.explain_selection();
-        return { stats, explanation, turn: this.turnCounter };
+        // npm users live in their MCP client (no Python dashboard), so
+        // surface the persisted cross-session value here directly.
+        let value = null;
+        try {
+          if (this.valueTracker) {
+            const tr = this.valueTracker.getTrends();
+            value = {
+              lifetime: tr.lifetime,
+              today: (tr.daily.slice(-1)[0]) || null,
+              recent_activity: tr.activity.slice(0, 10),
+              data_source: 'shared telemetry file (cross-runtime)',
+            };
+          }
+        } catch (_) { /* fail-open */ }
+        return { stats, explanation, value, turn: this.turnCounter };
       }
 
       // ── CogOps Epistemic Tools ──
@@ -327,6 +361,71 @@ class EntrolyMCPServer {
         return { file: args.file_path, language: args.language || 'unknown', predicted_files: imports.slice(0, 10), dep_graph: depStats, engine: 'javascript' };
       }
 
+      // ── Hallucination Detection ──
+      case 'verify_response': {
+        const resp = args.response || '';
+        const ctx = args.context || '';
+        const prm = args.prompt || '';
+
+        // Entity coverage gap: extract identifiers from context vs response
+        const ctxEntities = new Set((ctx + ' ' + prm).match(/[a-zA-Z_][a-zA-Z0-9_.]{2,}/g) || []);
+        const respEntities = (resp.match(/[a-zA-Z_][a-zA-Z0-9_.]{2,}/g) || []);
+        const respUnique = [...new Set(respEntities)];
+        let grounded = 0;
+        const flaggedClaims = [];
+        for (const ent of respUnique) {
+          if (ctxEntities.has(ent) || ent.length <= 3) {
+            grounded++;
+          } else {
+            flaggedClaims.push({ claim: ent, score: 1.0 });
+          }
+        }
+        const entityGap = respUnique.length > 0 ? 1.0 - (grounded / respUnique.length) : 0;
+
+        // ECE-like: hedging language curvature
+        const hedgeWords = ['might', 'could', 'possibly', 'perhaps', 'maybe', 'uncertain', 'likely', 'probably', 'appears to', 'seems'];
+        const wordCount = resp.split(/\s+/).length;
+        let hedgeCount = 0;
+        for (const h of hedgeWords) { hedgeCount += (resp.toLowerCase().match(new RegExp(h, 'g')) || []).length; }
+        const hedgeCurvature = Math.min(1.0, hedgeCount / Math.max(wordCount, 1) * 20);
+
+        // EPR-like: entropy consistency (char-bigram)
+        const bigrams = {};
+        for (let i = 0; i < resp.length - 1; i++) {
+          const bg = resp.slice(i, i + 2);
+          bigrams[bg] = (bigrams[bg] || 0) + 1;
+        }
+        const total = Object.values(bigrams).reduce((a, b) => a + b, 0) || 1;
+        let entropy = 0;
+        for (const c of Object.values(bigrams)) {
+          const p = c / total;
+          if (p > 0) entropy -= p * Math.log2(p);
+        }
+        // Normalize: high entropy is normal for text, low entropy is suspicious
+        const maxEntropy = Math.log2(Math.min(Object.keys(bigrams).length, 500)) || 1;
+        const eprRisk = Math.max(0, 1.0 - entropy / maxEntropy);
+
+        // Fuse (same weights as proxy)
+        const fused = Math.max(0, Math.min(1.0,
+          0.80 * entityGap + 0.08 * hedgeCurvature + 0.07 * eprRisk + 0.05 * 0
+        ));
+
+        let verdict, recommendation;
+        if (fused < 0.15) { verdict = 'pass'; recommendation = 'Accept — response appears well-grounded'; }
+        else if (fused < 0.40) { verdict = 'warn'; recommendation = 'Review — some claims may not be grounded'; }
+        else { verdict = 'flag'; recommendation = 'Reject or rephrase — high hallucination risk'; }
+
+        return {
+          fused_risk: Math.round(fused * 10000) / 10000,
+          verdict,
+          recommendation,
+          witness: { entity_coverage_gap: Math.round(entityGap * 10000) / 10000, total_entities: respUnique.length, grounded_count: grounded },
+          ece: { hedging_curvature: Math.round(hedgeCurvature * 10000) / 10000, hedge_count: hedgeCount },
+          epr: { entropy_risk: Math.round(eprRisk * 10000) / 10000, bigram_entropy: Math.round(entropy * 100) / 100 },
+          flagged_claims: flaggedClaims.slice(0, 10),
+        };
+      }
+
       default:
         throw new Error(`Unknown tool: ${name}`);
     }

package/js/value_tracker.js

@@ -1,13 +1,20 @@
 /**
- * ValueTracker — JS port of entroly/value_tracker.py
+ * ValueTracker — JS port of entroly/value_tracker.py (schema v3)
  *
  * Persistent, lifetime-savings accounting with the self-funded evolution
  * budget invariant:
  *
  *     C_spent(t)  ≤  τ · S(t)         (τ = 5%)
  *
- * Any token-costing evolution step MUST gate on `getEvolutionBudget().canEvolve`.
- * The tracker is atomic-write safe and survives process restarts.
+ * CROSS-RUNTIME CONTRACT: this writes the SAME file, SAME directory and
+ * SAME JSON schema as the Python tracker so that one shared dashboard
+ * shows value no matter whether the user installed via pip (MCP/proxy),
+ * the SDK, or npm (this wasm runtime). The directory resolution and the
+ * UTC date-key formats below MUST stay byte-identical to
+ * entroly/value_tracker.py — diverging them silently re-creates the
+ * "blank dashboard for npm users" bug.
+ *
+ * Atomic-write safe; survives process restarts.
  */
 
 'use strict';
@@ -18,35 +25,22 @@ const os = require('os');
 
 const EVOLUTION_TAX_RATE = 0.05;
 const FILE_NAME = 'value_tracker.json';
+const ACTIVITY_NAME = 'activity.jsonl';
+const SCHEMA_VERSION = 3;
+const MAX_DAILY = 90, MAX_WEEKLY = 52, MAX_MONTHLY = 24, MAX_ACTIVITY = 200;
 
 // Per-model $/1M tokens — kept in sync with entroly/value_tracker.py (×1000).
 const COST_PER_M = {
   default: 3.0,
-  // OpenAI
-  'gpt-4o': 2.5,
-  'gpt-4o-mini': 0.15,
-  'gpt-4-turbo': 10.0,
-  'gpt-4': 30.0,
-  'gpt-3.5-turbo': 0.5,
-  'o1': 15.0,
-  'o1-mini': 3.0,
-  'o3': 10.0,
-  'o3-mini': 1.1,
-  'o4-mini': 1.1,
-  // Anthropic
-  'claude-opus-4': 15.0,
-  'claude-sonnet-4': 3.0,
-  'claude-haiku-4': 0.8,
-  'claude-3-5-sonnet': 3.0,
-  'claude-3-5-haiku': 0.8,
-  // Google
-  'gemini-2.5-pro': 1.25,
-  'gemini-2.5-flash': 0.075,
-  'gemini-1.5-pro': 1.25,
-  'gemini-1.5-flash': 0.075,
+  'gpt-4o': 2.5, 'gpt-4o-mini': 0.15, 'gpt-4-turbo': 10.0, 'gpt-4': 30.0,
+  'gpt-3.5-turbo': 0.5, 'o1': 15.0, 'o1-mini': 3.0, 'o3': 10.0,
+  'o3-mini': 1.1, 'o4-mini': 1.1,
+  'claude-opus-4': 15.0, 'claude-sonnet-4': 3.0, 'claude-haiku-4': 0.8,
+  'claude-3-5-sonnet': 3.0, 'claude-3-5-haiku': 0.8,
+  'gemini-2.5-pro': 1.25, 'gemini-2.5-flash': 0.075,
+  'gemini-1.5-pro': 1.25, 'gemini-1.5-flash': 0.075,
 };
 
-// Old→new name aliases so 'claude-3-opus' hits the same rate as Python.
 const MODEL_ALIASES = {
   'claude-3-opus': 'claude-opus-4',
   'claude-3-sonnet': 'claude-sonnet-4',
@@ -60,11 +54,10 @@ function estimateCost(tokens, model = '') {
   for (const [alias, canonical] of Object.entries(MODEL_ALIASES)) {
     if (m.startsWith(alias)) { m = canonical + m.slice(alias.length); break; }
   }
-  // Longest-prefix match — prevents 'gpt-4o' eating 'gpt-4o-mini'.
-  const keys = Object.keys(COST_PER_M).filter(k => k !== 'default').sort((a, b) => b.length - a.length);
+  const keys = Object.keys(COST_PER_M).filter(k => k !== 'default')
+    .sort((a, b) => b.length - a.length);
   const key = (m && keys.find(k => m.startsWith(k)));
   if (!key && model) {
-    // One-time warning per unknown model — stderr, doesn't pollute stdout.
     if (!estimateCost._warned) estimateCost._warned = new Set();
     if (!estimateCost._warned.has(model)) {
       estimateCost._warned.add(model);
@@ -74,6 +67,29 @@ function estimateCost(tokens, model = '') {
   return (tokens / 1_000_000) * COST_PER_M[key || 'default'];
 }
 
+// ── UTC date keys — MUST match Python time.gmtime()-based keys ──────────
+
+function _pad(n) { return String(n).padStart(2, '0'); }
+
+function _dayKey(d = new Date()) {
+  return `${d.getUTCFullYear()}-${_pad(d.getUTCMonth() + 1)}-${_pad(d.getUTCDate())}`;
+}
+
+function _monthKey(d = new Date()) {
+  return `${d.getUTCFullYear()}-${_pad(d.getUTCMonth() + 1)}`;
+}
+
+function _weekKey(d = new Date()) {
+  // ISO-8601 week, matching Python datetime.date.isocalendar().
+  const t = new Date(Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate()));
+  const day = t.getUTCDay() || 7;          // Mon=1..Sun=7
+  t.setUTCDate(t.getUTCDate() + 4 - day);  // nearest Thursday
+  const isoYear = t.getUTCFullYear();
+  const yearStart = new Date(Date.UTC(isoYear, 0, 1));
+  const week = Math.ceil((((t - yearStart) / 86400000) + 1) / 7);
+  return `${isoYear}-W${_pad(week)}`;
+}
+
 function atomicWrite(filePath, content) {
   const tmp = filePath + '.tmp-' + process.pid;
   fs.writeFileSync(tmp, content, 'utf8');
@@ -82,10 +98,16 @@ function atomicWrite(filePath, content) {
 
 class ValueTracker {
   constructor(dataDir = null) {
-    this._dir = dataDir || path.join(os.homedir(), '.entroly');
+    // Honor ENTROLY_DIR exactly like Python's _default_dir(); else
+    // ~/.entroly. NOT cwd/.entroly — that was the npm/py path split.
+    this._dir = dataDir
+      || process.env.ENTROLY_DIR
+      || path.join(os.homedir(), '.entroly');
     fs.mkdirSync(this._dir, { recursive: true });
     this._path = path.join(this._dir, FILE_NAME);
-    this._data = this._load();
+    this._activityPath = path.join(this._dir, ACTIVITY_NAME);
+    this._data = this._migrate(this._load());
+    this._activity = this._loadActivity();
   }
 
   _load() {
@@ -101,36 +123,143 @@ class ValueTracker {
   _defaults() {
     const now = Date.now() / 1000;
     return {
-      version: 2,
+      version: SCHEMA_VERSION,
       lifetime: {
-        tokens_saved: 0,
-        cost_saved_usd: 0.0,
-        requests_optimized: 0,
-        first_seen: now,
-        last_seen: now,
-        evolution_spent_usd: 0.0,
-        evolution_attempts: 0,
+        tokens_saved: 0, cost_saved_usd: 0.0,
+        requests_optimized: 0, requests_total: 0, duplicates_caught: 0,
+        first_seen: now, last_seen: now,
+        evolution_spent_usd: 0.0, evolution_attempts: 0,
         evolution_successes: 0,
+        hallucinations_blocked: 0, routing_saved_usd: 0.0,
+        routing_decisions: 0,
       },
+      daily: {}, weekly: {}, monthly: {},
     };
   }
 
+  _migrate(data) {
+    // Backward-compatible forward migration (v2 → v3): backfill any
+    // missing keys/buckets without touching existing counters.
+    const base = this._defaults();
+    data.lifetime = data.lifetime || {};
+    for (const [k, v] of Object.entries(base.lifetime)) {
+      if (!(k in data.lifetime)) data.lifetime[k] = v;
+    }
+    for (const b of ['daily', 'weekly', 'monthly']) {
+      if (!data[b] || typeof data[b] !== 'object') data[b] = {};
+    }
+    data.version = SCHEMA_VERSION;
+    return data;
+  }
+
+  _loadActivity() {
+    if (!fs.existsSync(this._activityPath)) return [];
+    try {
+      const out = [];
+      for (const line of fs.readFileSync(this._activityPath, 'utf8').split('\n')) {
+        const s = line.trim();
+        if (!s) continue;
+        try { out.push(JSON.parse(s)); } catch (_) { /* skip */ }
+      }
+      return out.slice(-MAX_ACTIVITY);
+    } catch (_) { return []; }
+  }
+
   _save() {
     try { atomicWrite(this._path, JSON.stringify(this._data, null, 2)); }
     catch (_) { /* best-effort */ }
   }
 
-  record({ tokensSaved = 0, model = '', optimized = true } = {}) {
+  _saveActivity() {
+    try {
+      this._activity = this._activity.slice(-MAX_ACTIVITY);
+      const content = this._activity.map(e => JSON.stringify(e)).join('\n')
+        + (this._activity.length ? '\n' : '');
+      atomicWrite(this._activityPath, content);
+    } catch (_) { /* best-effort */ }
+  }
+
+  _bump(bucketName, key, tokens, cost) {
+    const bucket = this._data[bucketName] || (this._data[bucketName] = {});
+    if (!bucket[key]) bucket[key] = { tokens_saved: 0, cost_saved: 0.0, requests: 0 };
+    bucket[key].tokens_saved += tokens;
+    bucket[key].cost_saved = +(bucket[key].cost_saved + cost).toFixed(6);
+    bucket[key].requests += 1;
+    const limit = { daily: MAX_DAILY, weekly: MAX_WEEKLY, monthly: MAX_MONTHLY }[bucketName];
+    const ks = Object.keys(bucket);
+    if (ks.length > limit) {
+      ks.sort();
+      for (const old of ks.slice(0, ks.length - limit)) delete bucket[old];
+    }
+  }
+
+  record({ tokensSaved = 0, model = '', duplicates = 0, optimized = true } = {}) {
     const cost = estimateCost(tokensSaved, model);
+    const now = new Date();
     const lt = this._data.lifetime;
     lt.tokens_saved += tokensSaved;
     lt.cost_saved_usd = +(lt.cost_saved_usd + cost).toFixed(6);
+    lt.requests_total = (lt.requests_total || 0) + 1;
     if (optimized) lt.requests_optimized += 1;
+    lt.duplicates_caught = (lt.duplicates_caught || 0) + duplicates;
     lt.last_seen = Date.now() / 1000;
+    this._bump('daily', _dayKey(now), tokensSaved, cost);
+    this._bump('weekly', _weekKey(now), tokensSaved, cost);
+    this._bump('monthly', _monthKey(now), tokensSaved, cost);
     this._save();
+    this._activity.push({
+      ts: +(Date.now() / 1000).toFixed(3),
+      kind: 'optimize',
+      summary: `Optimized request: saved ${tokensSaved.toLocaleString()} tokens`
+        + (model ? ` (${model})` : ''),
+      tokens_saved: tokensSaved,
+      cost_saved_usd: +cost.toFixed(6),
+      model: model || '',
+      duplicates,
+      source: 'npm',
+    });
+    this._saveActivity();
     return { tokensSaved, costSaved: cost };
   }
 
+  recordEvent(kind, summary, opts = {}) {
+    try {
+      const row = {
+        ts: +(Date.now() / 1000).toFixed(3),
+        kind: String(kind),
+        summary: String(summary).slice(0, 240),
+        source: opts.source || 'npm',
+      };
+      if (opts.tokensSaved) row.tokens_saved = opts.tokensSaved | 0;
+      if (opts.costSavedUsd) row.cost_saved_usd = +Number(opts.costSavedUsd).toFixed(6);
+      if (opts.model) row.model = opts.model;
+      this._activity.push(row);
+      this._saveActivity();
+    } catch (_) { /* fail-open */ }
+  }
+
+  recordHallucinationBlocked(n = 1, detail = '') {
+    try {
+      this._data.lifetime.hallucinations_blocked =
+        (this._data.lifetime.hallucinations_blocked || 0) + (n | 0);
+      this._save();
+      this.recordEvent('hallucination',
+        detail || `Blocked ${n} unsupported claim(s)`, { source: 'witness' });
+    } catch (_) { /* fail-open */ }
+  }
+
+  recordRoutingSaving(costSavedUsd, chosenModel = '', detail = '') {
+    try {
+      const lt = this._data.lifetime;
+      lt.routing_saved_usd = +((lt.routing_saved_usd || 0) + Number(costSavedUsd)).toFixed(6);
+      lt.routing_decisions = (lt.routing_decisions || 0) + 1;
+      this._save();
+      this.recordEvent('routing',
+        detail || `Routed to ${chosenModel || 'cheaper model'}`,
+        { source: 'ravs', costSavedUsd, model: chosenModel });
+    } catch (_) { /* fail-open */ }
+  }
+
   getEvolutionBudget() {
     const lt = this._data.lifetime;
     const lifetimeSaved = lt.cost_saved_usd || 0;
@@ -152,14 +281,9 @@ class ValueTracker {
     const currentSpent = lt.evolution_spent_usd || 0;
     const totalEarned = lifetimeSaved * EVOLUTION_TAX_RATE;
     const available = totalEarned - currentSpent;
-
     if (costUsd > available + 0.001) {
-      return {
-        status: 'rejected',
-        remainingUsd: +Math.max(0, available).toFixed(6),
-      };
+      return { status: 'rejected', remainingUsd: +Math.max(0, available).toFixed(6) };
     }
-
     lt.evolution_spent_usd = +(currentSpent + costUsd).toFixed(6);
     lt.evolution_attempts = (lt.evolution_attempts || 0) + 1;
     if (success) lt.evolution_successes = (lt.evolution_successes || 0) + 1;
@@ -170,12 +294,43 @@ class ValueTracker {
     };
   }
 
+  // ── Read APIs for the entroly_dashboard MCP tool ───────────────────────
+
+  _sortedBucket(name, lastN) {
+    const b = this._data[name] || {};
+    return Object.keys(b).sort().slice(-lastN).map(k => ({ key: k, ...b[k] }));
+  }
+
+  getTrends() {
+    return {
+      lifetime: { ...this._data.lifetime },
+      daily: this._sortedBucket('daily', 30),
+      weekly: this._sortedBucket('weekly', 12),
+      monthly: this._sortedBucket('monthly', 12),
+      activity: this._activity.slice(-50).reverse(),
+    };
+  }
+
+  getActivity(lastN = 50) {
+    return this._activity.slice(-lastN).reverse();
+  }
+
   stats() {
     return {
       lifetime: { ...this._data.lifetime },
       budget: this.getEvolutionBudget(),
+      activity: this.getActivity(20),
     };
   }
 }
 
-module.exports = { ValueTracker, EVOLUTION_TAX_RATE, estimateCost };
+// Module-level singleton, mirroring Python get_tracker().
+let _tracker = null;
+function getTracker() {
+  if (!_tracker) _tracker = new ValueTracker();
+  return _tracker;
+}
+
+module.exports = {
+  ValueTracker, EVOLUTION_TAX_RATE, estimateCost, getTracker,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "entroly-wasm",
-  "version": "0.19.4",
+  "version": "0.19.5",
   "description": "Information-theoretic context optimization for AI coding agents. Zero-friction, pure WebAssembly - no Python dependency.",
   "main": "index.js",
   "types": "pkg/entroly_wasm.d.ts",