lynkr 9.11.0 → 9.12.0

package/src/dashboard/api.js

@@ -208,8 +208,12 @@ function routing(req, res) {
     // Cache-aware routing (Phase 6): per-decision switch/hold economics,
     // aggregated into "cache dollars saved by routing".
     const cacheEconomics = telemetry.getCacheEconomics({ since });
+    // Lens money-framing: the MEASURED companion — cache reads actually
+    // served this window, auditable against the bill (vs the projected
+    // figures above). null until cache counters have accrued.
+    const cacheMeasured = telemetry.getMeasuredCacheSavings({ since });
 
-    res.json({ tierDefinitions: TIER_DEFINITIONS, accuracy, stats, providerStats, circuitBreakers: cbStates, cacheEconomics, window: win.label });
+    res.json({ tierDefinitions: TIER_DEFINITIONS, accuracy, stats, providerStats, circuitBreakers: cbStates, cacheEconomics, cacheMeasured, window: win.label });
   } catch (e) {
     res.status(500).json({ error: 'routing_api_error', detail: e.message });
   }
@@ -233,4 +237,76 @@ function logs(req, res) {
   }
 }
 
-module.exports = { overview, usage, routing, logs };
+/* ── Lens endpoints (feature/lens-dashboard) ─────────────────────────── */
+
+// Recommendations — analyzer findings ranked by past overspend.
+function recommendations(req, res) {
+  try {
+    const engine = require('./recommendations');
+    const windowMs = req.query.window === '30d' ? 30 * 86400000
+      : req.query.window === '24h' ? 86400000
+      : 7 * 86400000;
+    res.json(engine.run({ windowMs, force: req.query.force === 'true' }));
+  } catch (e) {
+    res.status(500).json({ error: 'recommendations_api_error', detail: e.message });
+  }
+}
+
+// Session drill-down: per-model mix + context-growth series + raw rows.
+function sessionDetail(req, res) {
+  try {
+    const detail = telemetry.getSessionDetail(req.params.id);
+    if (!detail) return res.status(404).json({ error: 'session_not_found' });
+    res.json(detail);
+  } catch (e) {
+    res.status(500).json({ error: 'session_api_error', detail: e.message });
+  }
+}
+
+// Pivot explorer: metric × dimension (× stack), whitelisted server-side.
+function analytics(req, res) {
+  try {
+    const days = Math.min(90, Math.max(1, parseInt(req.query.days || '7', 10) || 7));
+    const data = telemetry.getAnalytics({
+      metric: req.query.metric,
+      by: req.query.by,
+      stack: req.query.stack || null,
+      since: Date.now() - days * 86400000,
+    });
+    if (!data) return res.status(503).json({ error: 'telemetry_unavailable' });
+    res.json(data);
+  } catch (e) {
+    res.status(500).json({ error: 'analytics_api_error', detail: e.message });
+  }
+}
+
+// Statusline: one cheap snapshot for the zero-token status line — last
+// routed request, today's spend, measured cache re-read share.
+function statusline(req, res) {
+  try {
+    const last = telemetry.query({ limit: 1 })[0] ?? null;
+    const since = Date.now() - 86400000;
+    const db = telemetry.getDb();
+    let today = null;
+    if (db) {
+      today = db.prepare(
+        `SELECT SUM(COALESCE(cost_usd,0)) spend,
+                SUM(COALESCE(cache_read_tokens,0)) rd,
+                SUM(COALESCE(cache_read_tokens,0)+COALESCE(cache_creation_tokens,0)+COALESCE(input_tokens,0)) total
+         FROM routing_telemetry WHERE timestamp > ?`
+      ).get(since);
+    }
+    res.json({
+      last: last && {
+        tier: last.tier, provider: last.provider, model: last.model,
+        pinned: !!last.pinned, at: last.timestamp,
+      },
+      todaySpendUsd: today?.spend ?? null,
+      cacheReadPct: today && today.total > 0 ? Math.round((today.rd / today.total) * 100) : null,
+    });
+  } catch (e) {
+    res.status(500).json({ error: 'statusline_api_error', detail: e.message });
+  }
+}
+
+module.exports = { overview, usage, routing, logs, recommendations, sessionDetail, analytics, statusline };

package/src/dashboard/recommendations/cache-weakspots.js

@@ -0,0 +1,88 @@
+/**
+ * cache-weakspots — prompt-cache hit ratio per (provider, model), worst first.
+ *
+ * Reads the per-request cache counters (cache_read_tokens /
+ * cache_creation_tokens). Rows recorded before capture began are NULL and
+ * excluded — when nothing has been measured yet the finding says so
+ * explicitly instead of reporting a fake all-clear.
+ */
+
+const MIN_REQUESTS = 5;
+const WEAK_RATIO = 0.5;
+
+module.exports = {
+  id: 'cache-weakspots',
+  title: 'Weak prompt-cache hit ratios',
+
+  analyze({ db, since }) {
+    const rows = db
+      .prepare(
+        `SELECT provider, model, COUNT(*) n,
+                SUM(COALESCE(cache_read_tokens,0)) rd,
+                SUM(COALESCE(cache_creation_tokens,0)) cr,
+                SUM(COALESCE(input_tokens,0)) inp
+         FROM routing_telemetry
+         WHERE timestamp > ? AND cache_read_tokens IS NOT NULL
+         GROUP BY provider, model
+         HAVING COUNT(*) >= ${MIN_REQUESTS}`
+      )
+      .all(since);
+
+    if (!rows.length) {
+      return {
+        id: this.id, title: this.title, mechanism: 'info', state: 'not_measured',
+        framing: 'usd', pastOverspendUsd: null, pastOverspendTokens: null,
+        stats: [], evidence: { columns: [], rows: [] }, fix: null,
+        caveat: null,
+        estimateBasis: 'Cache counters are captured from this version onward — data accrues as requests flow. An un-run measurement is not an all-clear.',
+      };
+    }
+
+    const { resolveCacheEconomics } = require('../../routing/cache-economics');
+    const weak = [];
+    let usd = 0;
+    for (const r of rows) {
+      const total = r.rd + r.cr + r.inp;
+      const ratio = total > 0 ? r.rd / total : 0;
+      if (ratio >= WEAK_RATIO) continue;
+      const econ = resolveCacheEconomics(r.provider, r.model);
+      // Ceiling: what the uncached input cost beyond cache-read price.
+      const missedUsd = econ.unknownPricing || econ.mechanism === 'local'
+        ? null
+        : (r.inp * Math.max(0, econ.inputPerM - econ.cacheReadPerM)) / 1_000_000;
+      if (missedUsd != null) usd += missedUsd;
+      weak.push([r.provider, r.model, r.n, `${Math.round(ratio * 100)}%`, r.inp, missedUsd ?? '(local/unknown)']);
+    }
+
+    if (!weak.length) {
+      return {
+        id: this.id, title: this.title, mechanism: 'info', state: 'clean',
+        framing: 'usd', pastOverspendUsd: 0, pastOverspendTokens: null,
+        stats: [{ label: 'models measured', value: rows.length }],
+        evidence: { columns: [], rows: [] }, fix: null, caveat: null,
+        estimateBasis: `Hit ratio = cache reads ÷ (reads + writes + uncached input); weak = below ${WEAK_RATIO * 100}%.`,
+      };
+    }
+
+    return {
+      id: this.id,
+      title: this.title,
+      mechanism: 'info',
+      state: 'actionable',
+      framing: 'usd',
+      pastOverspendUsd: usd,
+      pastOverspendTokens: null,
+      stats: [
+        { label: 'weak (provider, model) pairs', value: weak.length },
+        { label: 'models measured', value: rows.length },
+      ],
+      evidence: {
+        columns: ['provider', 'model', 'requests', 'hit ratio', 'uncached input tokens', 'ceiling $'],
+        rows: weak.sort((a, b) => parseFloat(a[3]) - parseFloat(b[3])),
+      },
+      fix: 'Low ratios usually mean an unstable prefix: per-request bytes in the system prompt, client-side history rewrites, or conversations too short to cache. Check the silent-invalidator list and whether the distiller freeze covers these sessions.',
+      caveat: 'The dollar figure is a CEILING — it prices every uncached input token at the read discount, which assumes perfect cacheability. Real recovery is lower.',
+      estimateBasis: 'Uncached input tokens × (input price − cache-read price) for pairs below a 50% hit ratio, this window. NULL-counter rows (pre-capture) excluded.',
+    };
+  },
+};

package/src/dashboard/recommendations/deadweight.js

@@ -0,0 +1,82 @@
+/**
+ * deadweight — tool schemas carried on every request but never called.
+ *
+ * Telemetry stores per-request tool COUNTS, not names, so the detectable
+ * unit is the session: sessions whose every request shipped a tool loadout
+ * and whose tool_calls_made never left zero paid schema rent for nothing.
+ * (Per-tool attribution needs tool names in telemetry — future work.)
+ */
+
+const EST_TOKENS_PER_TOOL = 150; // typical JSON schema; stated in estimateBasis
+const MIN_REQUESTS = 3;
+
+module.exports = {
+  id: 'deadweight',
+  title: 'Tool schemas carried but never used',
+
+  analyze({ db, since }) {
+    const rows = db
+      .prepare(
+        `SELECT session_id,
+                COUNT(*) reqs,
+                AVG(COALESCE(tool_count,0)) avg_tools,
+                MAX(model) model,
+                MAX(provider) provider,
+                SUM(COALESCE(cost_usd,0)) session_cost
+         FROM routing_telemetry
+         WHERE timestamp > ? AND session_id IS NOT NULL AND COALESCE(tool_count,0) > 0
+         GROUP BY session_id
+         HAVING SUM(COALESCE(tool_calls_made,0)) = 0 AND COUNT(*) >= ${MIN_REQUESTS}
+         ORDER BY reqs * avg_tools DESC
+         LIMIT 50`
+      )
+      .all(since);
+
+    if (!rows.length) {
+      return {
+        id: this.id, title: this.title, mechanism: 'snippet', state: 'clean',
+        framing: 'usd', pastOverspendUsd: 0, pastOverspendTokens: 0,
+        stats: [], evidence: { columns: [], rows: [] },
+        fix: null, caveat: null,
+        estimateBasis: 'Sessions with >=3 requests, a tool loadout on every request, and zero tool calls.',
+      };
+    }
+
+    const { resolveCacheEconomics } = require('../../routing/cache-economics');
+    let tokens = 0;
+    let usd = 0;
+    const evidence = [];
+    for (const r of rows) {
+      const wastedTokens = Math.round(r.avg_tools * EST_TOKENS_PER_TOOL * r.reqs);
+      tokens += wastedTokens;
+      const econ = resolveCacheEconomics(r.provider, r.model);
+      const rowUsd = econ.unknownPricing ? null : (wastedTokens * econ.inputPerM) / 1_000_000;
+      if (rowUsd != null) usd += rowUsd;
+      evidence.push([
+        r.session_id, r.reqs, Math.round(r.avg_tools), wastedTokens,
+        rowUsd != null ? rowUsd : '(price unknown)',
+      ]);
+    }
+
+    return {
+      id: this.id,
+      title: this.title,
+      mechanism: 'snippet',
+      state: 'actionable',
+      framing: 'usd',
+      pastOverspendUsd: usd,
+      pastOverspendTokens: tokens,
+      stats: [
+        { label: 'sessions affected', value: rows.length },
+        { label: 'est. schema tokens re-sent', value: tokens },
+      ],
+      evidence: {
+        columns: ['session', 'requests', 'avg tools', 'est. wasted tokens', 'est. $'],
+        rows: evidence,
+      },
+      fix: 'These sessions never called a tool — their MCP servers/tool registrations paid schema rent on every request. Trim unused MCP servers from the client config, or scope them per-project.',
+      caveat: 'Schema size is estimated at ~150 tokens per tool; telemetry stores tool counts, not names, so attribution is per-session rather than per-tool.',
+      estimateBasis: 'avg tools × ~150 est. tokens/schema × requests per session, priced at each session\'s model input rate. Sessions with any tool call are excluded entirely.',
+    };
+  },
+};

package/src/dashboard/recommendations/downsize.js

@@ -0,0 +1,109 @@
+/**
+ * downsize — request types where the tier below has statistically proven
+ * itself, Wilson-bounded.
+ *
+ * The de-escalator's live rule uses raw averages (>=30 rows, avg quality
+ * >=70). This analyzer applies the stricter test TokenJam-bench uses for
+ * verdicts: the WILSON LOWER BOUND of the lower tier's success rate must
+ * clear the bar, so 21-of-30 (lower bound ~0.52) stays "unproven" while
+ * 140-of-170 (~0.76) is a verdict. Success = quality >= 70 and no error.
+ *
+ * No quality-equivalence claim is made — the verdict is "the lower tier's
+ * measured floor clears the bar on this request type", nothing more.
+ */
+
+const { wilsonLowerBound } = require('./wilson');
+
+const TIER_ORDER = ['SIMPLE', 'MEDIUM', 'COMPLEX', 'REASONING'];
+const MIN_SAMPLES = 20;
+const SUCCESS_QUALITY = 70;
+const WILSON_BAR = 0.7;
+const EVIDENCE_WINDOW_MS = 30 * 24 * 60 * 60 * 1000; // evidence looks back further than the spend window
+
+module.exports = {
+  id: 'downsize',
+  title: 'Tiers that could step down (Wilson-proven)',
+
+  analyze({ db, since, until }) {
+    // Lower-tier track record per request_type over 30 days.
+    const evidence = db
+      .prepare(
+        `SELECT tier, request_type,
+                COUNT(*) n,
+                SUM(CASE WHEN COALESCE(quality_score,0) >= ${SUCCESS_QUALITY} AND error_type IS NULL THEN 1 ELSE 0 END) k,
+                AVG(COALESCE(cost_usd,0)) avg_cost
+         FROM routing_telemetry
+         WHERE timestamp > ? AND tier IS NOT NULL AND request_type IS NOT NULL
+         GROUP BY tier, request_type`
+      )
+      .all(until - EVIDENCE_WINDOW_MS);
+
+    const byKey = new Map(evidence.map((r) => [`${r.tier}::${r.request_type}`, r]));
+
+    // Spend at each upper tier per request_type, this window.
+    const upperSpend = db
+      .prepare(
+        `SELECT tier, request_type, COUNT(*) n, SUM(COALESCE(cost_usd,0)) cost, AVG(COALESCE(cost_usd,0)) avg_cost
+         FROM routing_telemetry
+         WHERE timestamp > ? AND tier IS NOT NULL AND request_type IS NOT NULL
+         GROUP BY tier, request_type`
+      )
+      .all(since);
+
+    const rows = [];
+    let usd = 0;
+    let anyEvidence = false;
+    for (const u of upperSpend) {
+      const idx = TIER_ORDER.indexOf(u.tier);
+      if (idx <= 0) continue;
+      const lower = byKey.get(`${TIER_ORDER[idx - 1]}::${u.request_type}`);
+      if (!lower) continue;
+      anyEvidence = true;
+      if (lower.n < MIN_SAMPLES) continue;
+      const bound = wilsonLowerBound(lower.k, lower.n);
+      if (bound < WILSON_BAR) continue;
+      // Empirical per-request price delta between the two tiers on the SAME
+      // request type — measured, not modeled.
+      const delta = Math.max(0, (u.avg_cost ?? 0) - (lower.avg_cost ?? 0)) * u.n;
+      usd += delta;
+      rows.push([
+        u.request_type, u.tier, `${TIER_ORDER[idx - 1]}`,
+        `${lower.k}/${lower.n}`, bound.toFixed(2), u.n, delta,
+      ]);
+    }
+
+    if (!rows.length) {
+      return {
+        id: this.id, title: this.title, mechanism: 'info',
+        state: anyEvidence ? 'clean' : 'not_measured',
+        framing: 'usd', pastOverspendUsd: anyEvidence ? 0 : null, pastOverspendTokens: null,
+        stats: [],
+        evidence: { columns: [], rows: [] }, fix: null, caveat: null,
+        estimateBasis: anyEvidence
+          ? `No (tier, request_type) pair has a lower tier whose Wilson lower bound clears ${WILSON_BAR} on >=${MIN_SAMPLES} samples yet.`
+          : 'Needs quality-scored telemetry with request_type populated — accrues as traffic flows (request_type capture is recent).',
+      };
+    }
+
+    rows.sort((a, b) => b[6] - a[6]);
+    return {
+      id: this.id,
+      title: this.title,
+      mechanism: 'info',
+      state: 'actionable',
+      framing: 'usd',
+      pastOverspendUsd: usd,
+      pastOverspendTokens: null,
+      stats: [
+        { label: 'proven (request_type, tier) pairs', value: rows.length },
+      ],
+      evidence: {
+        columns: ['request_type', 'served tier', 'proven lower tier', 'lower success', 'Wilson lower bound', 'requests this window', 'measured delta $'],
+        rows,
+      },
+      fix: 'The live de-escalator will demote these automatically as its own thresholds clear; to act sooner, adjust the TIER_* mapping for these request types or lower the de-escalator sample bar deliberately.',
+      caveat: 'Verdict is "the lower tier\'s measured success floor clears the bar" — not quality equivalence. Success = quality >= 70 with no error.',
+      estimateBasis: 'Per-request cost delta between tiers measured on the SAME request_type (30-day evidence window), × this window\'s upper-tier request count. Wilson 95% lower bound.',
+    };
+  },
+};

package/src/dashboard/recommendations/index.js

@@ -0,0 +1,106 @@
+/**
+ * Lens recommendations engine.
+ *
+ * Registry-driven analyzers over routing telemetry that answer "what should
+ * the operator change", TokenJam-style, with three disciplines borrowed
+ * deliberately:
+ *
+ *  - PAST OVERSPEND, never projected savings: every dollar figure is
+ *    backward-looking so the operator can check it against a bill already
+ *    paid. Ceilings are labeled as ceilings in estimateBasis.
+ *  - THREE-STATE HONESTY: 'actionable' (evidence found), 'clean' (ran,
+ *    found nothing), 'not_measured' (data doesn't exist yet on this
+ *    install). An un-run scan is not an all-clear.
+ *  - MECHANISM badges: 'auto' (Lynkr could act), 'snippet' (client-side
+ *    fix the operator applies), 'info' (diagnosis only).
+ *
+ * Analyzer contract: analyze({db, since, until}) -> finding
+ *   {id, title, mechanism, state, framing: 'usd'|'tokens',
+ *    pastOverspendUsd|null, pastOverspendTokens|null, stats: [{label,value}],
+ *    evidence: {columns:[], rows:[][]}, fix, caveat, estimateBasis}
+ *
+ * The analyzers' overspend bases are disjoint by construction (dead tool
+ * schemas / harness side traffic / uncached input / tier price deltas), so
+ * the total is a plain sum — revisit if an analyzer is added whose basis
+ * overlaps an existing one.
+ *
+ * @module dashboard/recommendations
+ */
+
+const logger = require('../../logger');
+const telemetry = require('../../routing/telemetry');
+
+const ANALYZERS = [
+  require('./deadweight'),
+  require('./side-requests'),
+  require('./cache-weakspots'),
+  require('./downsize'),
+];
+
+const DEFAULT_WINDOW_MS = 7 * 24 * 60 * 60 * 1000;
+const RESULT_TTL_MS = 45 * 1000;
+
+let _cached = null;
+
+/**
+ * Run all analyzers. Cached for 45s — findings shift slowly and the
+ * dashboard polls every 30s.
+ *
+ * @param {Object} [opts] {windowMs, force}
+ */
+function run(opts = {}) {
+  const windowMs = opts.windowMs ?? DEFAULT_WINDOW_MS;
+  if (!opts.force && _cached && Date.now() - _cached.computedAt < RESULT_TTL_MS
+    && _cached.windowMs === windowMs) {
+    return _cached;
+  }
+
+  const db = telemetry.getDb();
+  const until = Date.now();
+  const since = until - windowMs;
+
+  const findings = [];
+  for (const analyzer of ANALYZERS) {
+    try {
+      const finding = db
+        ? analyzer.analyze({ db, since, until })
+        : { id: analyzer.id, title: analyzer.title, state: 'not_measured', reason: 'telemetry unavailable' };
+      if (finding) findings.push(finding);
+    } catch (err) {
+      logger.debug({ analyzer: analyzer.id, err: err.message }, '[Recommendations] analyzer failed');
+      findings.push({ id: analyzer.id, title: analyzer.title, state: 'not_measured', reason: err.message });
+    }
+  }
+
+  // Rank by dollars, biggest first; token-framed findings after usd ones.
+  findings.sort((a, b) => (b.pastOverspendUsd ?? -1) - (a.pastOverspendUsd ?? -1));
+
+  let spendUsd = 0;
+  try {
+    if (db) {
+      spendUsd = db
+        .prepare('SELECT SUM(COALESCE(cost_usd,0)) s FROM routing_telemetry WHERE timestamp > ?')
+        .get(since)?.s ?? 0;
+    }
+  } catch { /* spend share stays 0 */ }
+
+  const totalRecoverableUsd = findings
+    .filter((f) => f.state === 'actionable' && typeof f.pastOverspendUsd === 'number')
+    .reduce((acc, f) => acc + f.pastOverspendUsd, 0);
+
+  _cached = {
+    computedAt: Date.now(),
+    windowMs,
+    spendUsd,
+    totalRecoverableUsd,
+    findings,
+  };
+  return _cached;
+}
+
+/** Test helper — drop the memoized result. */
+function _clearCacheForTests() {
+  _cached = null;
+}
+
+module.exports = { run, ANALYZERS, _clearCacheForTests };

package/src/dashboard/recommendations/side-requests.js

@@ -0,0 +1,68 @@
+/**
+ * side-requests — harness side traffic served above the SIMPLE tier.
+ *
+ * Coding harnesses replay the conversation for their own bookkeeping
+ * (title generation, topic detection). Those calls embed the user's text,
+ * so they score like the user's request and ride the same tier — observed
+ * live: a title request served by a frontier COMPLEX model. The whole
+ * category needs a tiny model.
+ */
+
+const SIDE_PATTERNS = [
+  "Generate a title%",
+  "%Analyze if this message indicates a new conversation topic%",
+  "Please write a %commit message%",
+  "Summarize this conversation%",
+];
+
+module.exports = {
+  id: 'side-requests',
+  title: 'Harness side traffic on expensive tiers',
+
+  analyze({ db, since }) {
+    const where = SIDE_PATTERNS.map(() => 'request_text LIKE ?').join(' OR ');
+    const rows = db
+      .prepare(
+        `SELECT tier, provider, model, COUNT(*) n, SUM(COALESCE(cost_usd,0)) cost
+         FROM routing_telemetry
+         WHERE timestamp > ? AND COALESCE(tool_count,0) = 0 AND (${where})
+         GROUP BY tier, provider, model
+         ORDER BY cost DESC`
+      )
+      .all(since, ...SIDE_PATTERNS);
+
+    const above = rows.filter((r) => r.tier && r.tier !== 'SIMPLE');
+    const total = rows.reduce((a, r) => a + r.n, 0);
+    if (!above.length) {
+      return {
+        id: this.id, title: this.title, mechanism: 'auto', state: total > 0 ? 'clean' : 'clean',
+        framing: 'usd', pastOverspendUsd: 0, pastOverspendTokens: null,
+        stats: [{ label: 'side requests seen', value: total }],
+        evidence: { columns: [], rows: [] }, fix: null, caveat: null,
+        estimateBasis: 'Tool-less requests matching known harness bookkeeping prompts (title/topic/commit/summary).',
+      };
+    }
+
+    const usd = above.reduce((a, r) => a + r.cost, 0);
+    return {
+      id: this.id,
+      title: this.title,
+      mechanism: 'auto',
+      state: 'actionable',
+      framing: 'usd',
+      pastOverspendUsd: usd,
+      pastOverspendTokens: null,
+      stats: [
+        { label: 'side requests above SIMPLE', value: above.reduce((a, r) => a + r.n, 0) },
+        { label: 'total side requests', value: total },
+      ],
+      evidence: {
+        columns: ['tier', 'provider', 'model', 'requests', 'spend $'],
+        rows: above.map((r) => [r.tier, r.provider, r.model, r.n, r.cost]),
+      },
+      fix: 'Route harness bookkeeping (title generation, topic detection, commit messages) to the SIMPLE tier unconditionally — a pattern guard ahead of intent scoring. Lynkr can enforce this; the patterns above are the trigger list.',
+      caveat: 'Ceiling figure: it counts the full spend of these calls, not the delta vs a SIMPLE-tier serve (which would be near zero for local SIMPLE tiers).',
+      estimateBasis: 'Sum of cost_usd for tool-less requests matching harness prompt patterns, served on any tier above SIMPLE, this window.',
+    };
+  },
+};

package/src/dashboard/recommendations/wilson.js

@@ -0,0 +1,24 @@
+/**
+ * Wilson score interval — lower bound on a binomial proportion.
+ *
+ * Used by the downsize analyzer: "the lower tier succeeded k of n times"
+ * is only evidence when the LOWER BOUND of the confidence interval clears
+ * the bar. A raw average (k/n >= 0.7) treats 21/30 the same as 700/1000;
+ * Wilson does not — small samples get wide intervals and stay unproven.
+ *
+ * @param {number} successes
+ * @param {number} n
+ * @param {number} [z=1.96] - 95% confidence
+ * @returns {number} lower bound in [0,1]; 0 when n === 0
+ */
+function wilsonLowerBound(successes, n, z = 1.96) {
+  if (!Number.isFinite(n) || n <= 0) return 0;
+  const p = Math.min(1, Math.max(0, successes / n));
+  const z2 = z * z;
+  const denom = 1 + z2 / n;
+  const centre = p + z2 / (2 * n);
+  const margin = z * Math.sqrt((p * (1 - p) + z2 / (4 * n)) / n);
+  return Math.max(0, (centre - margin) / denom);
+}
+
+module.exports = { wilsonLowerBound };

package/src/dashboard/router.js

@@ -18,5 +18,10 @@ router.get('/api/overview', api.overview);
 router.get('/api/usage',    api.usage);
 router.get('/api/routing',  api.routing);
 router.get('/api/logs',     api.logs);
+// Lens (feature/lens-dashboard)
+router.get('/api/recommendations', api.recommendations);
+router.get('/api/sessions/:id',    api.sessionDetail);
+router.get('/api/analytics',       api.analytics);
+router.get('/api/statusline',      api.statusline);
 
 module.exports = router;

package/src/orchestrator/sse-transformer.js

@@ -20,9 +20,14 @@
  */
 const logger = require("../logger");
 
-// Upstreams whose streaming wire format is OpenAI Chat Completions SSE.
-// ollama is excluded (own format + buffering quirks), moonshot/zai are
-// excluded (their invoke fns convert buffered responses to Anthropic).
+// Upstreams whose streaming streaming wire format is OpenAI Chat Completions SSE.
+// ollama is excluded (own format + buffering quirks); zai is excluded (its
+// invoke fn converts buffered responses to Anthropic, and its Anthropic-format
+// endpoint has the native passthrough path instead). moonshot joined the list
+// once invokeMoonshot learned to return the raw stream (its old forced
+// stream:false predated this transformer). Caveat: reasoning_content deltas
+// (kimi thinking) are not reshaped — thinking text is dropped from streamed
+// responses; the buffered path still lifts it into thinking blocks.
 const DEFAULT_OPENAI_SSE_PROVIDERS = [
   "openai",
   "azure-openai",
@@ -30,6 +35,7 @@ const DEFAULT_OPENAI_SSE_PROVIDERS = [
   "databricks",
   "lmstudio",
   "llamacpp",
+  "moonshot",
 ];
 
 function _transformProviders() {