@cognisos/liminal 2.5.0 → 2.6.0-beta.0

package/dist/bin.js

@@ -1,6 +1,8 @@
 #!/usr/bin/env node
 var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
 }) : x)(function(x) {
@@ -14,6 +16,15 @@ var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/ui/format.ts
 function disableColor() {
@@ -215,7 +226,7 @@ var init_version = __esm({
   "src/version.ts"() {
     "use strict";
     init_format();
-    VERSION = true ? "2.5.0" : "2.5.0";
+    VERSION = true ? "2.6.0-beta.0" : "2.5.0";
     BANNER_LINES = [
       " ___       ___  _____ ______   ___  ________   ________  ___",
       "|\\  \\     |\\  \\|\\   _ \\  _   \\|\\  \\|\\   ___  \\|\\   __  \\|\\  \\",
@@ -727,6 +738,35 @@ var init_pipeline = __esm({
   }
 });
 
+// src/rsc/tokenizer.ts
+var tokenizer_exports = {};
+__export(tokenizer_exports, {
+  countTokens: () => countTokens,
+  countTokensBytes: () => countTokensBytes
+});
+function countTokens(text) {
+  if (!_countTokens) {
+    try {
+      const mod = __require("@anthropic-ai/tokenizer");
+      _countTokens = mod.countTokens;
+    } catch {
+      _countTokens = (t) => Math.ceil(Buffer.byteLength(t, "utf-8") / 4);
+    }
+  }
+  return _countTokens(text);
+}
+function countTokensBytes(bytes) {
+  const text = Buffer.from(bytes).toString("utf-8");
+  return countTokens(text);
+}
+var _countTokens;
+var init_tokenizer = __esm({
+  "src/rsc/tokenizer.ts"() {
+    "use strict";
+    _countTokens = null;
+  }
+});
+
 // src/daemon/lifecycle.ts
 import { readFileSync as readFileSync6, writeFileSync as writeFileSync4, unlinkSync as unlinkSync3, existsSync as existsSync8 } from "fs";
 import { fork } from "child_process";
@@ -828,10 +868,35 @@ var init_aggregator = __esm({
       tools = /* @__PURE__ */ new Map();
       cursorMetrics = null;
       costPerMillionTokens;
+      /** Actual input_tokens from Anthropic API responses (verified ground truth) */
+      actualInputTokensTotal = 0;
+      /** Actual output_tokens from Anthropic API responses */
+      actualOutputTokensTotal = 0;
+      /** Pre-compression input token count from tokenizer */
+      originalInputEstimateTotal = 0;
+      /** Verified tokens saved: countTokens(pre) - countTokens(post) */
+      verifiedSavedTotal = 0;
+      /** Number of API responses with verified usage data */
+      verifiedRequestCount = 0;
       constructor(costPerMillionTokens = DEFAULT_COST_PER_MILLION_TOKENS) {
         this.costPerMillionTokens = costPerMillionTokens;
       }
       // ── Recording events ──────────────────────────────────────────────
+      /**
+       * Record verified token counts from an Anthropic API response.
+       *
+       * @param actualInput  - usage.input_tokens from Anthropic (post-compression ground truth)
+       * @param actualOutput - usage.output_tokens from Anthropic (generated tokens ground truth)
+       * @param verifiedSaved - tokens saved, computed as countTokens(pre) - countTokens(post) using real tokenizer
+       * @param originalInputTokens - token count of full request before compression
+       */
+      recordApiUsage(actualInput, actualOutput, verifiedSaved, originalInputTokens) {
+        this.actualInputTokensTotal += actualInput;
+        this.actualOutputTokensTotal += actualOutput;
+        this.originalInputEstimateTotal += originalInputTokens;
+        this.verifiedSavedTotal += verifiedSaved;
+        this.verifiedRequestCount++;
+      }
       recordCompression(toolId, tokensProcessed, tokensSaved, latencyMs) {
         const m = this.getOrCreateTool(toolId);
         m.calls++;
@@ -899,10 +964,18 @@ var init_aggregator = __esm({
         for (const [id, m] of this.tools) {
           byTool[id] = { ...m };
         }
+        const verifiedInputSaved = this.verifiedSavedTotal;
+        const verifiedSavingsRate = this.originalInputEstimateTotal > 0 ? verifiedInputSaved / this.originalInputEstimateTotal : 0;
         return {
           sessionStartedAt: this.startedAt.toISOString(),
           uptimeMs,
           ...totals,
+          actualInputTokens: this.actualInputTokensTotal,
+          actualOutputTokens: this.actualOutputTokensTotal,
+          originalInputEstimate: this.originalInputEstimateTotal,
+          verifiedInputSaved,
+          verifiedSavingsRate,
+          verifiedRequestCount: this.verifiedRequestCount,
           savingsRate: rate,
           contextExtension: this.contextExtension(rate),
           estimatedCostSavedUsd: this.estimatedCostSaved(totals.tokensSaved),
@@ -1007,6 +1080,101 @@ var init_store = __esm({
   }
 });
 
+// src/cursor/stats.ts
+var stats_exports = {};
+__export(stats_exports, {
+  parseCursorHookStats: () => parseCursorHookStats,
+  readCursorLogEntries: () => readCursorLogEntries
+});
+import { existsSync as existsSync10, readFileSync as readFileSync8, readdirSync } from "fs";
+import { join as join7 } from "path";
+function parseCursorHookStats(cwd = process.cwd()) {
+  const logPath = join7(cwd, ".fabric", "compress.log");
+  if (!existsSync10(logPath)) return null;
+  let compressions = 0, errors = 0;
+  let tokensProcessed = 0, tokensSaved = 0;
+  let apiMsSumMs = 0;
+  const files = /* @__PURE__ */ new Set();
+  const content = readFileSync8(logPath, "utf-8").trim();
+  if (!content) return null;
+  for (const line of content.split("\n")) {
+    try {
+      const entry = JSON.parse(line);
+      if (entry.type === "compressed") {
+        compressions++;
+        tokensProcessed += entry.inputTokens ?? Math.ceil((entry.inputSize ?? 0) / 3);
+        tokensSaved += entry.tokensSaved ?? 0;
+        apiMsSumMs += entry.apiMs ?? 0;
+        files.add(entry.file);
+      } else if (entry.type === "error") {
+        errors++;
+      }
+    } catch {
+    }
+  }
+  let cacheCount = 0;
+  try {
+    cacheCount = countFilesRecursive(join7(cwd, ".fabric", "cache"));
+  } catch {
+  }
+  return {
+    files: files.size,
+    compressions,
+    errors,
+    tokensProcessed,
+    tokensSaved,
+    apiMsSumMs,
+    cacheCount
+  };
+}
+function readCursorLogEntries(maxEntries = 50, cwd = process.cwd()) {
+  const logPath = join7(cwd, ".fabric", "compress.log");
+  if (!existsSync10(logPath)) return [];
+  const content = readFileSync8(logPath, "utf-8").trim();
+  if (!content) return [];
+  const lines = content.split("\n");
+  const recent = lines.slice(-maxEntries);
+  const entries = [];
+  for (const line of recent) {
+    try {
+      const entry = JSON.parse(line);
+      const ts = entry.ts ? new Date(entry.ts) : /* @__PURE__ */ new Date();
+      const time = ts.toTimeString().slice(0, 8);
+      if (entry.type === "compressed") {
+        const pct = entry.savedPct ?? (entry.inputTokens && entry.tokensSaved ? +(entry.tokensSaved / entry.inputTokens * 100).toFixed(1) : 0);
+        entries.push({
+          ts: entry.ts,
+          line: `[${time}] [CURSOR] ${entry.file} \u2192 ${entry.tokensSaved} tok saved (${pct}%) ${entry.apiMs}ms`
+        });
+      } else if (entry.type === "error") {
+        entries.push({
+          ts: entry.ts,
+          line: `[${time}] [CURSOR] ${entry.file} \u2192 ERROR: ${entry.error ?? "unknown"}`
+        });
+      }
+    } catch {
+    }
+  }
+  return entries;
+}
+function countFilesRecursive(dir) {
+  if (!existsSync10(dir)) return 0;
+  let count = 0;
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    if (entry.isDirectory()) {
+      count += countFilesRecursive(join7(dir, entry.name));
+    } else {
+      count++;
+    }
+  }
+  return count;
+}
+var init_stats = __esm({
+  "src/cursor/stats.ts"() {
+    "use strict";
+  }
+});
+
 // src/ui/screen.ts
 var SEQ, Screen;
 var init_screen = __esm({
@@ -1402,15 +1570,39 @@ var init_stats_view = __esm({
         lines.push(formatRow("Savings Rate", sRate, aRate, colW));
         lines.push(formatRow("Context Extension", sExt, aExt, colW));
         lines.push(blank());
+        lines.push(divider("Verified (Anthropic API)", w));
+        lines.push(blank());
+        if (health && health.verifiedRequestCount && health.verifiedRequestCount > 0) {
+          const actualIn = health.actualInputTokens ?? 0;
+          const actualOut = health.actualOutputTokens ?? 0;
+          const origEst = health.originalInputEstimate ?? 0;
+          const saved = health.verifiedInputSaved ?? 0;
+          const rate = health.verifiedSavingsRate ?? 0;
+          const reqs = health.verifiedRequestCount;
+          lines.push(formatRow("Input (actual)", formatNum(actualIn), "\u2014", colW));
+          lines.push(formatRow("Input (pre-comp)", formatNum(origEst), "\u2014", colW));
+          lines.push(formatRow("Input Saved", formatNum(saved), "\u2014", colW));
+          lines.push(formatRow("Input Savings Rate", `${(rate * 100).toFixed(1)}%`, "\u2014", colW));
+          lines.push(blank());
+          lines.push(formatRow("Output (actual)", formatNum(actualOut), "\u2014", colW));
+          lines.push(formatRow("Total (in + out)", formatNum(actualIn + actualOut), "\u2014", colW));
+          lines.push(blank());
+          lines.push(formatRow("Verified Requests", String(reqs), "\u2014", colW));
+        } else {
+          lines.push(`  ${c.dim}No verified data yet \u2014 waiting for API responses${c.reset}`);
+        }
+        lines.push(blank());
         lines.push(divider("Cost Impact", w));
         lines.push(blank());
         lines.push(hdr);
         lines.push(sep);
         lines.push(formatRow("Est. Cost Saved", sCost, aCost, colW));
         lines.push(blank());
+        let byToolRendered = false;
         if (health && health.sessions.length > 0) {
           lines.push(divider("By Tool", w));
           lines.push(blank());
+          byToolRendered = true;
           const byTool = /* @__PURE__ */ new Map();
           for (const s of health.sessions) {
             const existing = byTool.get(s.connector) ?? { calls: 0, compressed: 0, failed: 0, processed: 0, saved: 0, p95: null };
@@ -1432,6 +1624,19 @@ var init_stats_view = __esm({
             lines.push(blank());
           }
         }
+        if (health?.cursor) {
+          const cur = health.cursor;
+          if (!byToolRendered) {
+            lines.push(divider("By Tool", w));
+            lines.push(blank());
+          }
+          const curPct = cur.tokensProcessed > 0 ? `${(cur.tokensSaved / cur.tokensProcessed * 100).toFixed(1)}%` : "\u2014";
+          const avgMs = cur.compressions > 0 ? Math.round(cur.apiMsSumMs / cur.compressions) : 0;
+          lines.push(`${c.bold}${formatLabel("cursor")}${c.reset}`);
+          lines.push(`  Files: ${cur.files} unique (${cur.compressions} compressions${cur.errors > 0 ? `, ${c.red}${cur.errors} errors${c.reset}` : ""}) | Saved: ${formatNum(cur.tokensSaved)} tok (${curPct})`);
+          lines.push(`  Cache: ${cur.cacheCount} files | Avg API: ${avgMs}ms/file`);
+          lines.push(blank());
+        }
         if (cum.sessionCount > 0) {
           lines.push(`${c.dim}${cum.sessionCount} session${cum.sessionCount !== 1 ? "s" : ""} recorded${c.reset}`);
         }
@@ -1473,6 +1678,17 @@ var init_config_view = __esm({
 });
 
 // src/ui/views/logs-view.ts
+function getCursorLogs() {
+  if (!_readCursorLogs) {
+    try {
+      const mod = (init_stats(), __toCommonJS(stats_exports));
+      _readCursorLogs = () => mod.readCursorLogEntries(50);
+    } catch {
+      _readCursorLogs = () => [];
+    }
+  }
+  return _readCursorLogs();
+}
 function colorizeLog(line, maxWidth) {
   const display = line.length > maxWidth ? line.slice(0, maxWidth - 1) + "\u2026" : line;
   const match = display.match(/^\[(\d{2}:\d{2}:\d{2}(?:\.\d+)?)\]\s*(.*)$/);
@@ -1495,21 +1711,33 @@ function colorizeLog(line, maxWidth) {
   }
   return `${c.dim}${ts} ${rest}${c.reset}`;
 }
-var logsView;
+var _readCursorLogs, logsView;
 var init_logs_view = __esm({
   "src/ui/views/logs-view.ts"() {
     "use strict";
     init_format();
     init_layout();
+    _readCursorLogs = null;
     logsView = {
       id: "logs",
       label: "Logs",
       render(state, size) {
         const lines = [];
         const w = Math.max(40, size.cols - 6);
-        lines.push(divider("Daemon Logs", w));
+        lines.push(divider("All Logs", w));
         lines.push(blank());
-        if (state.recentLogs.length === 0) {
+        const cursorEntries = getCursorLogs();
+        const allLogs = [];
+        for (const line of state.recentLogs) {
+          const match = line.match(/^\[(\d{2}:\d{2}:\d{2}(?:\.\d+)?)\]/);
+          allLogs.push({ ts: match?.[1] ?? "99:99:99", line, source: "daemon" });
+        }
+        for (const entry of cursorEntries) {
+          allLogs.push({ ts: entry.ts, line: entry.line, source: "cursor" });
+        }
+        const daemonLogs = state.recentLogs;
+        const combined = [...daemonLogs, ...cursorEntries.map((e) => e.line)];
+        if (combined.length === 0) {
           if (!state.daemonRunning) {
             lines.push(`${c.dim}Daemon not running \u2014 no logs to show.${c.reset}`);
           } else {
@@ -1519,12 +1747,12 @@ var init_logs_view = __esm({
           return lines;
         }
         const maxLines = Math.max(5, size.rows - 7);
-        const tail = state.recentLogs.slice(-maxLines);
+        const tail = combined.slice(-maxLines);
         for (const line of tail) {
           lines.push(colorizeLog(line, w));
         }
         lines.push(blank());
-        lines.push(`${c.dim}Showing last ${tail.length} lines \u2014 refreshes every 2s${c.reset}`);
+        lines.push(`${c.dim}Showing last ${tail.length} lines (daemon + cursor) \u2014 refreshes every 2s${c.reset}`);
         return lines;
       }
     };
@@ -1536,7 +1764,7 @@ var hub_exports = {};
 __export(hub_exports, {
   runHub: () => runHub
 });
-import { existsSync as existsSync15, statSync as statSync3 } from "fs";
+import { existsSync as existsSync16, statSync as statSync3 } from "fs";
 function createInitialState() {
   const state = {
     health: null,
@@ -1597,7 +1825,7 @@ async function refreshState(state) {
 }
 function tailLogFile(maxLines) {
   try {
-    if (!existsSync15(LOG_FILE)) return [];
+    if (!existsSync16(LOG_FILE)) return [];
     const stat = statSync3(LOG_FILE);
     const readSize = Math.min(stat.size, 32 * 1024);
     if (readSize === 0) return [];
@@ -1907,18 +2135,37 @@ async function createApiKey(accessToken, userId, source = "cli") {
   );
   const apiKey = `${prefix}${randomBytes(32).toString("hex")}`;
   const keyHash = createHash("sha256").update(apiKey).digest("hex");
+  let projectId;
+  let orgId;
+  try {
+    const projRes = await fetch(
+      `${SUPABASE_URL}/rest/v1/projects?id=eq.${userId}&select=id,org_id&limit=1`,
+      { headers: supabaseHeaders(accessToken), signal: AbortSignal.timeout(1e4) }
+    );
+    if (projRes.ok) {
+      const rows = await projRes.json();
+      if (Array.isArray(rows) && rows.length > 0) {
+        projectId = rows[0].id;
+        orgId = rows[0].org_id;
+      }
+    }
+  } catch {
+  }
+  const insertPayload = {
+    user_id: userId,
+    key_name: keyName,
+    key_hash: keyHash,
+    is_active: true
+  };
+  if (projectId) insertPayload.project_id = projectId;
+  if (orgId) insertPayload.organization_id = orgId;
   const res = await fetch(`${SUPABASE_URL}/rest/v1/user_api_keys`, {
     method: "POST",
     headers: {
       ...supabaseHeaders(accessToken),
       "Prefer": "return=representation"
     },
-    body: JSON.stringify({
-      user_id: userId,
-      key_name: keyName,
-      key_hash: keyHash,
-      is_active: true
-    })
+    body: JSON.stringify(insertPayload)
   });
   if (!res.ok) {
     const body = await res.json().catch(() => ({}));
@@ -2929,6 +3176,7 @@ init_loader();
 import { RSCCircuitOpenError as RSCCircuitOpenError2 } from "@cognisos/rsc-sdk";
 
 // src/rsc/message-compressor.ts
+import { createHash as createHash2 } from "crypto";
 import { RSCCircuitOpenError } from "@cognisos/rsc-sdk";
 
 // src/rsc/content-segmenter.ts
@@ -3030,6 +3278,10 @@ function isIndentedCodeLine(line) {
 }
 
 // src/rsc/message-compressor.ts
+init_tokenizer();
+function contentHash(text) {
+  return createHash2("sha256").update(text).digest("hex").slice(0, 16);
+}
 var PASSTHROUGH_BLOCK_TYPES = /* @__PURE__ */ new Set(["thinking", "tool_use", "image"]);
 function sanitizeCompressedText(text) {
   return text.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g, "");
@@ -3097,43 +3349,90 @@ async function compressConversation(pipeline, session, plan, options = { compres
   }
   let anyCompressed = false;
   let totalTokensSaved = 0;
-  if (options.semaphore) await options.semaphore.acquire(options.semaphoreTimeoutMs);
-  try {
-    const batchSegments = compressible.map((entry) => ({
-      index: entry.planIdx,
-      text: entry.batchText
-    }));
-    const batchResults = await pipeline.normalizeBatch(batchSegments);
-    for (const entry of compressible) {
-      const result = batchResults.get(entry.planIdx);
-      if (!result || result.metrics.skipped) {
-        results[entry.planIdx] = entry.tm.message;
-        continue;
-      }
-      const compressed = sanitizeCompressedText(result.text);
-      const saved = Math.max(0, result.metrics.tokensSaved);
+  const cache = options.stickyCache;
+  const uncached = [];
+  for (const entry of compressible) {
+    if (!cache) {
+      uncached.push(entry);
+      continue;
+    }
+    const hash = contentHash(entry.batchText);
+    const cached = cache.get(hash);
+    if (cached !== void 0) {
+      log?.(`[STICKY] Cache hit for message #${entry.tm.index}`);
+      const originalTokens = countTokens(entry.batchText);
+      const compressedTokens = countTokens(cached);
+      const saved = Math.max(0, originalTokens - compressedTokens);
       if (saved > 0) {
         anyCompressed = true;
         totalTokensSaved += saved;
       }
-      session.recordCompression(result.metrics);
-      results[entry.planIdx] = reassembleMessage(entry.tm.message, compressed, entry.batchedIndices);
-    }
-  } catch (err) {
-    const errMsg = err instanceof Error ? err.message : String(err);
-    if (err instanceof RSCCircuitOpenError) {
-      session.recordFailure();
-      log?.(`[COMPRESS-ERROR] Circuit open \u2014 passing through (${errMsg})`);
+      session.recordCompression({
+        inputTokens: originalTokens,
+        outputTokens: compressedTokens,
+        tokensSaved: saved,
+        skipped: false,
+        fabricHits: 0,
+        fabricMisses: 0,
+        ratio: compressedTokens / Math.max(originalTokens, 1),
+        deltaMdlBits: 0,
+        processingTimeMs: 0
+      });
+      results[entry.planIdx] = reassembleMessage(entry.tm.message, cached, entry.batchedIndices);
     } else {
-      log?.(`[COMPRESS-ERROR] ${errMsg}`);
+      uncached.push(entry);
     }
-    for (const entry of compressible) {
-      if (!results[entry.planIdx]) {
-        results[entry.planIdx] = entry.tm.message;
+  }
+  if (uncached.length > 0) {
+    if (options.semaphore) await options.semaphore.acquire(options.semaphoreTimeoutMs);
+    try {
+      const batchSegments = uncached.map((entry) => ({
+        index: entry.planIdx,
+        text: entry.batchText
+      }));
+      const batchResults = await pipeline.normalizeBatch(batchSegments);
+      for (const entry of uncached) {
+        const result = batchResults.get(entry.planIdx);
+        if (!result || result.metrics.skipped) {
+          results[entry.planIdx] = entry.tm.message;
+          continue;
+        }
+        const compressed = sanitizeCompressedText(result.text);
+        const originalTokens = countTokens(entry.batchText);
+        const compressedTokens = countTokens(compressed);
+        const saved = Math.max(0, originalTokens - compressedTokens);
+        const realMetrics = {
+          ...result.metrics,
+          inputTokens: originalTokens,
+          outputTokens: compressedTokens,
+          tokensSaved: saved
+        };
+        if (saved > 0) {
+          anyCompressed = true;
+          totalTokensSaved += saved;
+        }
+        session.recordCompression(realMetrics);
+        results[entry.planIdx] = reassembleMessage(entry.tm.message, compressed, entry.batchedIndices);
+        if (cache) {
+          cache.set(contentHash(entry.batchText), compressed);
+        }
+      }
+    } catch (err) {
+      const errMsg = err instanceof Error ? err.message : String(err);
+      if (err instanceof RSCCircuitOpenError) {
+        session.recordFailure();
+        log?.(`[COMPRESS-ERROR] Circuit open \u2014 passing through (${errMsg})`);
+      } else {
+        log?.(`[COMPRESS-ERROR] ${errMsg}`);
       }
+      for (const entry of uncached) {
+        if (!results[entry.planIdx]) {
+          results[entry.planIdx] = entry.tm.message;
+        }
+      }
+    } finally {
+      if (options.semaphore) options.semaphore.release();
     }
-  } finally {
-    if (options.semaphore) options.semaphore.release();
   }
   return { messages: results, anyCompressed, totalTokensSaved };
 }
@@ -3156,6 +3455,7 @@ function extractBatchableText(msg, compressToolResults) {
       batchedIndices.add(i);
     }
     if (part.type === "tool_result" && compressToolResults) {
+      if (part.is_error) continue;
       const extracted = extractToolResultText(part);
       if (extracted) {
         textSegments.push(extracted);
@@ -3190,7 +3490,8 @@ function reassembleMessage(msg, compressedText, batchedIndices) {
       isFirstEligible = false;
     } else {
       if (parts[i].type === "tool_result") {
-        newParts.push({ ...parts[i], content: "" });
+        const cleared = parts[i].is_error ? parts[i] : { ...parts[i], content: "" };
+        newParts.push(cleared);
       }
     }
   }
@@ -3272,7 +3573,7 @@ async function compressArrayContent(msg, pipeline, session, record, options = {
           return part;
         }
       }
-      if (part.type === "tool_result" && options.compressToolResults) {
+      if (part.type === "tool_result" && options.compressToolResults && !part.is_error) {
         return compressToolResult(part, pipeline, session, record);
       }
       return part;
@@ -3331,8 +3632,11 @@ async function compressTextWithSegmentation(text, pipeline, session, record, sem
     if (semaphore) await semaphore.acquire(semaphoreTimeoutMs);
     try {
       const result = await pipeline.compressForLLM(text);
-      session.recordCompression(result.metrics);
-      const saved = Math.max(0, result.metrics.tokensSaved);
+      const originalTok = countTokens(text);
+      const compressedTok = countTokens(sanitizeCompressedText(result.text));
+      const saved = Math.max(0, originalTok - compressedTok);
+      const realMetrics = { ...result.metrics, inputTokens: originalTok, outputTokens: compressedTok, tokensSaved: saved };
+      session.recordCompression(realMetrics);
       record(!result.metrics.skipped, saved);
       return sanitizeCompressedText(result.text);
     } finally {
@@ -3346,8 +3650,11 @@ async function compressTextWithSegmentation(text, pipeline, session, record, sem
       if (semaphore) await semaphore.acquire(semaphoreTimeoutMs);
       try {
         const result = await pipeline.compressForLLM(seg.text);
-        session.recordCompression(result.metrics);
-        const saved = Math.max(0, result.metrics.tokensSaved);
+        const originalTok = countTokens(seg.text);
+        const compressedTok = countTokens(sanitizeCompressedText(result.text));
+        const saved = Math.max(0, originalTok - compressedTok);
+        const realMetrics = { ...result.metrics, inputTokens: originalTok, outputTokens: compressedTok, tokensSaved: saved };
+        session.recordCompression(realMetrics);
         record(!result.metrics.skipped, saved);
         return sanitizeCompressedText(result.text);
       } catch (err) {
@@ -3372,7 +3679,7 @@ function estimateBlockTokens(block, compressToolResults) {
   if (block.type === "text" && typeof block.text === "string") {
     return estimateTokens(block.text);
   }
-  if (block.type === "tool_result" && compressToolResults) {
+  if (block.type === "tool_result" && compressToolResults && !block.is_error) {
     if (typeof block.content === "string") {
       return estimateTokens(block.content);
     }
@@ -3586,7 +3893,7 @@ function extractBearerToken(req) {
   if (!auth || !auth.startsWith("Bearer ")) return null;
   return auth.slice(7);
 }
-async function handleChatCompletions(req, res, body, pipeline, config, logger, semaphore, latencyMonitor, sessionKey) {
+async function handleChatCompletions(req, res, body, pipeline, config, logger, semaphore, latencyMonitor, sessionKey, stickyCache) {
   const request = body;
   if (!request.messages || !Array.isArray(request.messages)) {
     sendJSON(res, 400, {
@@ -3645,7 +3952,8 @@ async function handleChatCompletions(req, res, body, pipeline, config, logger, s
           compressionThreshold: config.compressionThreshold,
           logFn: blockLogFn,
           semaphore,
-          semaphoreTimeoutMs: config.concurrencyTimeoutMs
+          semaphoreTimeoutMs: config.concurrencyTimeoutMs,
+          stickyCache
         }
       );
       const totalBlocks = batchedCount + skippedCount + hotCount;
@@ -3696,7 +4004,7 @@ async function handleChatCompletions(req, res, body, pipeline, config, logger, s
       return;
     }
     if (request.stream && upstreamResponse.body) {
-      const learningBuffer = anyCompressed ? createStreamLearningBuffer(pipeline.pipeline) : null;
+      const learningBuffer = createStreamLearningBuffer(pipeline.pipeline);
       logger.log(formatResponseLog(request.model, totalTokensSaved, true));
       await pipeSSEResponse(
         upstreamResponse,
@@ -3727,7 +4035,7 @@ async function handleChatCompletions(req, res, body, pipeline, config, logger, s
     setCORSHeaders(res);
     res.writeHead(200, { "Content-Type": "application/json" });
     res.end(finalBody);
-    if (anyCompressed) {
+    {
       try {
         const parsed = JSON.parse(responseBody);
         const content = parsed?.choices?.[0]?.message?.content;
@@ -3752,18 +4060,33 @@ async function handleChatCompletions(req, res, body, pipeline, config, logger, s
 import { RSCCircuitOpenError as RSCCircuitOpenError3 } from "@cognisos/rsc-sdk";
 
 // src/proxy/anthropic-streaming.ts
-function adjustMessageStartLine(dataLine, tokensSaved) {
+function parseMessageStart(dataLine, tokensSaved) {
+  try {
+    const json = JSON.parse(dataLine.slice(6));
+    const usage2 = json?.message?.usage;
+    if (usage2?.input_tokens != null) {
+      const actual = usage2.input_tokens + (usage2.cache_creation_input_tokens ?? 0) + (usage2.cache_read_input_tokens ?? 0);
+      if (tokensSaved > 0) {
+        json.message.usage.input_tokens += tokensSaved;
+        return [`data: ${JSON.stringify(json)}`, actual];
+      }
+      return [null, actual];
+    }
+  } catch {
+  }
+  return [null, null];
+}
+function parseMessageDelta(dataLine) {
   try {
     const json = JSON.parse(dataLine.slice(6));
-    if (json?.message?.usage?.input_tokens != null) {
-      json.message.usage.input_tokens += tokensSaved;
-      return `data: ${JSON.stringify(json)}`;
+    if (json?.usage?.output_tokens != null) {
+      return json.usage.output_tokens;
     }
   } catch {
   }
   return null;
 }
-async function pipeAnthropicSSEResponse(upstreamResponse, clientRes, onContentDelta, onComplete, totalTokensSaved = 0) {
+async function pipeAnthropicSSEResponse(upstreamResponse, clientRes, onContentDelta, onComplete, totalTokensSaved = 0, onUsage) {
   clientRes.writeHead(200, {
     "Content-Type": "text/event-stream",
     "Cache-Control": "no-cache",
@@ -3774,14 +4097,19 @@ async function pipeAnthropicSSEResponse(upstreamResponse, clientRes, onContentDe
   const decoder = new TextDecoder();
   let lineBuf = "";
   let currentEvent = "";
-  let usageAdjusted = false;
+  let capturedInputTokens = null;
+  let capturedOutputTokens = null;
+  let inputAdjusted = false;
   const needsAdjustment = totalTokensSaved > 0;
+  const needsCapture = !!onUsage;
   try {
     while (true) {
       const { done, value } = await reader.read();
       if (done) break;
       const chunk = decoder.decode(value, { stream: true });
-      if (!needsAdjustment || usageAdjusted) {
+      const inputDone = !needsAdjustment || inputAdjusted;
+      const captureDone = !needsCapture || capturedInputTokens != null && capturedOutputTokens != null;
+      if (inputDone && captureDone) {
         clientRes.write(chunk);
         lineBuf += chunk;
         const lines2 = lineBuf.split("\n");
@@ -3804,21 +4132,32 @@ async function pipeAnthropicSSEResponse(upstreamResponse, clientRes, onContentDe
       lineBuf += chunk;
       const lines = lineBuf.split("\n");
       lineBuf = lines.pop() || "";
-      let adjusted = false;
+      let lineModified = false;
       const outputLines = [];
       for (const line of lines) {
         if (line.startsWith("event: ")) {
           currentEvent = line.slice(7).trim();
           outputLines.push(line);
-        } else if (line.startsWith("data: ") && currentEvent === "message_start" && !usageAdjusted) {
-          const adjustedLine = adjustMessageStartLine(line, totalTokensSaved);
-          if (adjustedLine) {
-            outputLines.push(adjustedLine);
-            usageAdjusted = true;
-            adjusted = true;
+        } else if (line.startsWith("data: ") && currentEvent === "message_start" && capturedInputTokens == null) {
+          const [adjusted, actual] = parseMessageStart(line, totalTokensSaved);
+          if (actual != null) {
+            capturedInputTokens = actual;
+            inputAdjusted = true;
+            if (adjusted && needsAdjustment) {
+              outputLines.push(adjusted);
+              lineModified = true;
+            } else {
+              outputLines.push(line);
+            }
           } else {
             outputLines.push(line);
           }
+        } else if (line.startsWith("data: ") && currentEvent === "message_delta" && capturedOutputTokens == null) {
+          const outputTok = parseMessageDelta(line);
+          if (outputTok != null) {
+            capturedOutputTokens = outputTok;
+          }
+          outputLines.push(line);
         } else {
           outputLines.push(line);
           if (line.startsWith("data: ") && currentEvent === "content_block_delta") {
@@ -3832,14 +4171,20 @@ async function pipeAnthropicSSEResponse(upstreamResponse, clientRes, onContentDe
           }
         }
       }
-      if (adjusted) {
-        const reconstructed = outputLines.join("\n") + "\n" + (lineBuf ? "" : "");
+      if (lineModified) {
+        const reconstructed = outputLines.join("\n") + "\n";
         clientRes.write(reconstructed);
       } else {
         clientRes.write(chunk);
       }
     }
   } finally {
+    if (onUsage && (capturedInputTokens != null || capturedOutputTokens != null)) {
+      onUsage({
+        inputTokens: capturedInputTokens ?? 0,
+        outputTokens: capturedOutputTokens ?? 0
+      });
+    }
     clientRes.end();
     onComplete();
   }
@@ -3880,7 +4225,7 @@ function convertCompressedToAnthropic(messages) {
     content: msg.content
   }));
 }
-async function handleAnthropicMessages(req, res, body, pipeline, config, logger, semaphore, latencyMonitor, sessionKey) {
+async function handleAnthropicMessages(req, res, body, pipeline, config, logger, semaphore, latencyMonitor, sessionKey, onUsage, stickyCache) {
   const request = body;
   if (!request.messages || !Array.isArray(request.messages)) {
     sendAnthropicError(res, 400, "invalid_request_error", "messages is required and must be an array");
@@ -3895,6 +4240,8 @@ async function handleAnthropicMessages(req, res, body, pipeline, config, logger,
     sendAnthropicError(res, 401, "authentication_error", "Authentication required (x-api-key or Authorization header)");
     return;
   }
+  const { countTokens: countTok } = await Promise.resolve().then(() => (init_tokenizer(), tokenizer_exports));
+  const originalInputTokens = countTok(JSON.stringify(request));
   let messages = request.messages;
   let anyCompressed = false;
   let totalTokensSaved = 0;
@@ -3940,7 +4287,8 @@ async function handleAnthropicMessages(req, res, body, pipeline, config, logger,
           compressionThreshold: config.compressionThreshold,
           logFn: blockLogFn,
           semaphore,
-          semaphoreTimeoutMs: config.concurrencyTimeoutMs
+          semaphoreTimeoutMs: config.concurrencyTimeoutMs,
+          stickyCache
         }
       );
       const totalBlocks = batchedCount + skippedCount + hotCount;
@@ -3968,6 +4316,8 @@ async function handleAnthropicMessages(req, res, body, pipeline, config, logger,
   }
   const upstreamUrl = `${config.anthropicUpstreamUrl}/v1/messages`;
   const upstreamBody = { ...request, messages };
+  const compressedInputTokens = countTok(JSON.stringify(upstreamBody));
+  const verifiedTokensSaved = Math.max(0, originalInputTokens - compressedInputTokens);
   const upstreamHeaders = {
     ...authHeaders,
     "anthropic-version": req.headers["anthropic-version"] || "2023-06-01",
@@ -3996,35 +4346,44 @@ async function handleAnthropicMessages(req, res, body, pipeline, config, logger,
       return;
     }
     if (request.stream && upstreamResponse.body) {
-      const learningBuffer = anyCompressed ? createStreamLearningBuffer(pipeline.pipeline) : null;
+      const learningBuffer = createStreamLearningBuffer(pipeline.pipeline);
       logger.log(formatResponseLog(request.model, totalTokensSaved, true));
       await pipeAnthropicSSEResponse(
         upstreamResponse,
         res,
         (text) => learningBuffer?.append(text),
         () => learningBuffer?.flush(),
-        totalTokensSaved
+        totalTokensSaved,
+        onUsage ? (usage2) => {
+          onUsage(usage2, verifiedTokensSaved, originalInputTokens);
+          logger.log(`[TOKENS] input: ${usage2.inputTokens} | output: ${usage2.outputTokens} | verified_saved: ${verifiedTokensSaved} | orig_tok: ${originalInputTokens} | comp_tok: ${compressedInputTokens}`);
+        } : void 0
       );
       return;
     }
     const responseBody = await upstreamResponse.text();
     logger.log(formatResponseLog(request.model, totalTokensSaved));
     let finalBody = responseBody;
-    if (totalTokensSaved > 0) {
-      try {
-        const parsed = JSON.parse(responseBody);
-        if (parsed?.usage?.input_tokens != null) {
+    try {
+      const parsed = JSON.parse(responseBody);
+      if (parsed?.usage) {
+        const actualInput = (parsed.usage.input_tokens ?? 0) + (parsed.usage.cache_creation_input_tokens ?? 0) + (parsed.usage.cache_read_input_tokens ?? 0);
+        const actualOutput = parsed.usage.output_tokens ?? 0;
+        if (onUsage) {
+          onUsage({ inputTokens: actualInput, outputTokens: actualOutput }, verifiedTokensSaved, originalInputTokens);
+          logger.log(`[TOKENS] input: ${actualInput} | output: ${actualOutput} | verified_saved: ${verifiedTokensSaved} | orig_tok: ${originalInputTokens} | comp_tok: ${compressedInputTokens}`);
+        }
+        if (totalTokensSaved > 0 && parsed.usage.input_tokens != null) {
           parsed.usage.input_tokens += totalTokensSaved;
           finalBody = JSON.stringify(parsed);
-          logger.log(`[TOKENS] Adjusted input_tokens by +${totalTokensSaved}`);
         }
-      } catch {
       }
+    } catch {
     }
     setCORSHeaders2(res);
     res.writeHead(200, { "Content-Type": "application/json" });
     res.end(finalBody);
-    if (anyCompressed) {
+    {
       try {
         const parsed = JSON.parse(responseBody);
         const textBlocks = parsed?.content?.filter(
@@ -4317,7 +4676,7 @@ async function handleResponses(req, res, body, pipeline, config, logger, semapho
       return;
     }
     if (request.stream && upstreamResponse.body) {
-      const learningBuffer = anyCompressed ? createStreamLearningBuffer(pipeline.pipeline) : null;
+      const learningBuffer = createStreamLearningBuffer(pipeline.pipeline);
       logger.log(formatResponseLog(request.model, totalTokensSaved, true));
       await pipeResponsesSSE(
         upstreamResponse,
@@ -4348,7 +4707,7 @@ async function handleResponses(req, res, body, pipeline, config, logger, semapho
     setCORSHeaders3(res);
     res.writeHead(200, { "Content-Type": "application/json" });
     res.end(finalBody);
-    if (anyCompressed) {
+    {
       try {
         const parsed = JSON.parse(responseBody);
         if (parsed?.output) {
@@ -4604,12 +4963,14 @@ function createRequestHandler(deps) {
             calls_failed: s.failedCalls,
             p95_latency_ms: latencyMonitor.getSessionP95(s.key),
             last_active_ago_ms: Date.now() - s.lastAccessedAt
-          }))
+          })),
+          ...deps.getVerifiedTokens ? deps.getVerifiedTokens() : {},
+          ...deps.getCursorMetrics ? { cursor: deps.getCursorMetrics() } : {}
         });
         return;
       }
       const sessionKey = identifySession(req, url);
-      const pipeline = sessions.getOrCreate(sessionKey);
+      const { pipeline, stickyCache } = sessions.getOrCreate(sessionKey);
       if (method === "POST" && (url === "/v1/chat/completions" || url === "/chat/completions")) {
         const body = await readBody(req);
         let parsed;
@@ -4621,7 +4982,7 @@ function createRequestHandler(deps) {
           });
           return;
         }
-        await handleChatCompletions(req, res, parsed, pipeline, config, logger, semaphore, latencyMonitor, sessionKey.raw);
+        await handleChatCompletions(req, res, parsed, pipeline, config, logger, semaphore, latencyMonitor, sessionKey.raw, stickyCache);
         return;
       }
       if (method === "POST" && (url === "/v1/responses" || url === "/responses")) {
@@ -4650,7 +5011,7 @@ function createRequestHandler(deps) {
           });
           return;
         }
-        await handleAnthropicMessages(req, res, parsed, pipeline, config, logger, semaphore, latencyMonitor, sessionKey.raw);
+        await handleAnthropicMessages(req, res, parsed, pipeline, config, logger, semaphore, latencyMonitor, sessionKey.raw, deps.onUsage, stickyCache);
         return;
       }
       await passthroughToUpstream(req, res, fullUrl, config, logger);
@@ -4814,7 +5175,7 @@ var SessionManager = class {
     if (existing) {
       existing.lastAccessedAt = Date.now();
       existing.requestCount++;
-      return existing.pipeline;
+      return { pipeline: existing.pipeline, stickyCache: existing.stickyCache };
     }
     if (this.sessions.size >= this.config.maxSessions) {
       this.evictLRU();
@@ -4823,14 +5184,16 @@ var SessionManager = class {
       ...this.config.pipelineConfig,
       sessionId: key.raw
     });
+    const stickyCache = /* @__PURE__ */ new Map();
     this.sessions.set(key.raw, {
       pipeline,
+      stickyCache,
       lastAccessedAt: Date.now(),
       requestCount: 1,
       connector: key.connector
     });
     this.config.onSessionCreated?.(key.raw, pipeline);
-    return pipeline;
+    return { pipeline, stickyCache };
   }
   getAllSummaries() {
     const entries = [];
@@ -5409,6 +5772,13 @@ async function startCommand(flags) {
       logger.log(`[LIMINAL] [${key}] Error: ${event.error.message}`);
       statsAggregator.recordFailure(connector);
     });
+    pipeline.events.on("learning", (event) => {
+      if (event.error) {
+        logger.log(`[LIMINAL] [${key}] Learning error: ${event.error}`);
+      } else if (event.tokensIngested > 0) {
+        logger.log(`[LIMINAL] [${key}] Learning: ${event.tokensIngested} tokens ingested (deferred:${event.deferred})`);
+      }
+    });
     pipeline.events.on("degradation", (event) => {
       logger.log(`[LIMINAL] [${key}] Circuit ${event.circuitState}: ${event.reason}`);
     });
@@ -5435,7 +5805,50 @@ async function startCommand(flags) {
     logger.log(`[LATENCY] ${alert.type.toUpperCase()}: ${alert.message} (${alert.activeSessions} sessions) \u2014 ${alert.suggestion}`);
   });
   const mitmStats = new MitmStats();
-  const deps = { sessions, semaphore, latencyMonitor, mitmStats, config: resolvedConfig, logger };
+  const deps = {
+    sessions,
+    semaphore,
+    latencyMonitor,
+    mitmStats,
+    config: resolvedConfig,
+    logger,
+    onUsage: (usage2, verifiedSaved, originalInputTokens) => {
+      statsAggregator.recordApiUsage(usage2.inputTokens, usage2.outputTokens, verifiedSaved, originalInputTokens);
+      if (resolvedConfig.rscApiKey && resolvedConfig.rscBaseUrl) {
+        const body = JSON.stringify({
+          model: "cli",
+          actual_input_tokens: usage2.inputTokens,
+          actual_output_tokens: usage2.outputTokens,
+          original_input_bytes: originalInputTokens * 4
+        });
+        fetch(`${resolvedConfig.rscBaseUrl}/api/v1/usage/verified`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "Authorization": `Bearer ${resolvedConfig.rscApiKey}`
+          },
+          body,
+          signal: AbortSignal.timeout(5e3)
+        }).catch(() => {
+        });
+      }
+    },
+    getVerifiedTokens: () => {
+      const snap = statsAggregator.snapshot();
+      return {
+        actualInputTokens: snap.actualInputTokens,
+        actualOutputTokens: snap.actualOutputTokens,
+        originalInputEstimate: snap.originalInputEstimate,
+        verifiedInputSaved: snap.verifiedInputSaved,
+        verifiedSavingsRate: snap.verifiedSavingsRate,
+        verifiedRequestCount: snap.verifiedRequestCount
+      };
+    },
+    getCursorMetrics: () => {
+      const { parseCursorHookStats: parseCursorHookStats3 } = (init_stats(), __toCommonJS(stats_exports));
+      return parseCursorHookStats3();
+    }
+  };
   const handler = createRequestHandler(deps);
   let mitmHandler;
   const connectHandler = createConnectHandler({
@@ -5640,8 +6053,8 @@ async function stopCommand() {
 init_lifecycle();
 init_loader();
 init_format();
-import { existsSync as existsSync10, readFileSync as readFileSync8 } from "fs";
-import { join as join7 } from "path";
+import { existsSync as existsSync11, readFileSync as readFileSync9 } from "fs";
+import { join as join8 } from "path";
 async function statusCommand() {
   if (!isConfigured()) {
     console.log(error(
@@ -5709,27 +6122,27 @@ async function statusCommand() {
   }
 }
 function printCursorHookStats() {
-  const logPath = join7(process.cwd(), ".fabric", "compress.log");
-  const hooksPath = join7(process.cwd(), ".cursor", "hooks.json");
+  const logPath = join8(process.cwd(), ".fabric", "compress.log");
+  const hooksPath = join8(process.cwd(), ".cursor", "hooks.json");
   let hooksActive = false;
   try {
-    if (existsSync10(hooksPath)) {
-      const data = JSON.parse(readFileSync8(hooksPath, "utf-8"));
+    if (existsSync11(hooksPath)) {
+      const data = JSON.parse(readFileSync9(hooksPath, "utf-8"));
       const entries = data?.hooks?.preToolUse ?? [];
       hooksActive = entries.some((e) => e.command?.includes("fabric-compress"));
     }
   } catch {
   }
-  if (!hooksActive && !existsSync10(logPath)) return;
+  if (!hooksActive && !existsSync11(logPath)) return;
   console.log(sectionHeader("Cursor Hooks"));
   console.log();
   console.log(label("Status", hooksActive ? `${c.green}active${c.reset}` : `${c.dim}not installed${c.reset}`));
-  if (!existsSync10(logPath)) {
+  if (!existsSync11(logPath)) {
     console.log(label("Stats", `${c.dim}no compression data yet${c.reset}`));
     console.log();
     return;
   }
-  const lines = readFileSync8(logPath, "utf-8").trim().split("\n");
+  const lines = readFileSync9(logPath, "utf-8").trim().split("\n");
   let compressed = 0;
   let errors = 0;
   let totalInputSize = 0;
@@ -5763,7 +6176,7 @@ function printCursorHookStats() {
   const avgApiMs = compressed > 0 ? Math.round(totalApiMs / compressed) : 0;
   let cacheCount = 0;
   try {
-    cacheCount = countFiles(join7(process.cwd(), ".fabric", "cache"));
+    cacheCount = countFiles(join8(process.cwd(), ".fabric", "cache"));
   } catch {
   }
   console.log(label("Files", `${files.size} unique ${c.dim}(${compressed} compressions${errors > 0 ? `, ${c.red}${errors} errors${c.reset}${c.dim}` : ""})${c.reset}`));
@@ -5776,12 +6189,12 @@ function printCursorHookStats() {
   console.log();
 }
 function countFiles(dir) {
-  if (!existsSync10(dir)) return 0;
-  const { readdirSync: readdirSync2, statSync: statSync4 } = __require("fs");
+  if (!existsSync11(dir)) return 0;
+  const { readdirSync: readdirSync3, statSync: statSync4 } = __require("fs");
   let count = 0;
-  for (const entry of readdirSync2(dir, { withFileTypes: true })) {
+  for (const entry of readdirSync3(dir, { withFileTypes: true })) {
     if (entry.isDirectory()) {
-      count += countFiles(join7(dir, entry.name));
+      count += countFiles(join8(dir, entry.name));
     } else {
       count++;
     }
@@ -5864,17 +6277,17 @@ async function configCommand(flags) {
 
 // src/commands/logs.ts
 init_paths();
-import { readFileSync as readFileSync9, existsSync as existsSync11, statSync as statSync2, createReadStream } from "fs";
+import { readFileSync as readFileSync10, existsSync as existsSync12, statSync as statSync2, createReadStream } from "fs";
 import { watchFile, unwatchFile } from "fs";
 async function logsCommand(flags) {
   const follow = flags.has("follow") || flags.has("f");
   const linesFlag = flags.get("lines") ?? flags.get("n");
   const lines = typeof linesFlag === "string" ? parseInt(linesFlag, 10) : 50;
-  if (!existsSync11(LOG_FILE)) {
+  if (!existsSync12(LOG_FILE)) {
     console.log('No log file found. Start the daemon with "liminal start" to generate logs.');
     return;
   }
-  const content = readFileSync9(LOG_FILE, "utf-8");
+  const content = readFileSync10(LOG_FILE, "utf-8");
   const allLines = content.split("\n");
   const tail = allLines.slice(-lines - 1);
   process.stdout.write(tail.join("\n"));
@@ -5900,7 +6313,7 @@ async function logsCommand(flags) {
 }
 
 // src/commands/uninstall.ts
-import { existsSync as existsSync12, rmSync, readFileSync as readFileSync10 } from "fs";
+import { existsSync as existsSync13, rmSync, readFileSync as readFileSync11 } from "fs";
 init_paths();
 init_lifecycle();
 init_prompts();
@@ -5910,9 +6323,9 @@ var GREEN = "\x1B[32m";
 var YELLOW = "\x1B[33m";
 var RESET = "\x1B[0m";
 function loadConfiguredTools() {
-  if (!existsSync12(CONFIG_FILE)) return [];
+  if (!existsSync13(CONFIG_FILE)) return [];
   try {
-    const raw = readFileSync10(CONFIG_FILE, "utf-8");
+    const raw = readFileSync11(CONFIG_FILE, "utf-8");
     const config = JSON.parse(raw);
     if (Array.isArray(config.tools)) return config.tools;
   } catch {
@@ -6000,7 +6413,7 @@ async function uninstallCommand() {
       }
     }
   }
-  if (existsSync12(LIMINAL_DIR)) {
+  if (existsSync13(LIMINAL_DIR)) {
     console.log();
     const removeData = await selectPrompt({
       message: "Remove ~/.liminal/ directory? (config, logs, PID file)",
@@ -6120,9 +6533,9 @@ async function untrustCACommand() {
 // src/commands/setup-cursor.ts
 init_loader();
 init_version();
-import { existsSync as existsSync13, readFileSync as readFileSync11, writeFileSync as writeFileSync6, mkdirSync as mkdirSync5, unlinkSync as unlinkSync4, readdirSync, rmdirSync, appendFileSync as appendFileSync3 } from "fs";
+import { existsSync as existsSync14, readFileSync as readFileSync12, writeFileSync as writeFileSync6, mkdirSync as mkdirSync5, unlinkSync as unlinkSync4, readdirSync as readdirSync2, rmdirSync, appendFileSync as appendFileSync3 } from "fs";
 import { homedir as homedir5 } from "os";
-import { join as join8 } from "path";
+import { join as join9 } from "path";
 
 // src/cursor/hook-template.ts
 function getHookScript() {
@@ -6375,10 +6788,11 @@ async function main() {
     if (!fs.existsSync(cacheDir)) fs.mkdirSync(cacheDir, { recursive: true });
     fs.writeFileSync(cachePath, result.text, "utf-8");
 
-    // Use server-side token counts (actual tokenizer, not byte estimate)
-    // Fall back to ~4 chars/token estimate if server doesn't return counts
-    const inputTokens = result.inputTokens || Math.ceil(result.inputSize / 4);
-    const outputTokens = result.outputTokens || Math.ceil(result.outputSize / 4);
+    // Use server-side token counts from tiktoken-rs (cl100k_base BPE tokenizer)
+    // Fall back to ~3 chars/token estimate if server doesn't return counts
+    const inputTokens = result.inputTokens || Math.ceil(result.inputSize / 3);
+    const outputTokens = result.outputTokens || Math.ceil(result.outputSize / 3);
+    const tokensSaved = Math.max(0, inputTokens - outputTokens);
     logEntry({
       type: "compressed",
       file: relativePath,
@@ -6386,8 +6800,8 @@ async function main() {
       outputSize: result.outputSize,
       inputTokens: inputTokens,
       outputTokens: outputTokens,
-      tokensSaved: inputTokens - outputTokens,
-      savedPct: +((1 - result.outputSize / result.inputSize) * 100).toFixed(1),
+      tokensSaved: tokensSaved,
+      savedPct: inputTokens > 0 ? +((tokensSaved / inputTokens) * 100).toFixed(1) : 0,
       apiMs: elapsed,
     });
 
@@ -6410,26 +6824,26 @@ var HOOK_SCRIPT_NAME = "fabric-compress.js";
 var HOOK_COMMAND = `node .cursor/hooks/${HOOK_SCRIPT_NAME}`;
 function isCursorInstalled2() {
   if (process.platform === "darwin") {
-    return existsSync13("/Applications/Cursor.app");
+    return existsSync14("/Applications/Cursor.app");
   }
   if (process.platform === "win32") {
-    const localAppData = process.env.LOCALAPPDATA || join8(homedir5(), "AppData", "Local");
-    return existsSync13(join8(localAppData, "Programs", "Cursor", "Cursor.exe"));
+    const localAppData = process.env.LOCALAPPDATA || join9(homedir5(), "AppData", "Local");
+    return existsSync14(join9(localAppData, "Programs", "Cursor", "Cursor.exe"));
   }
-  return existsSync13("/usr/bin/cursor");
+  return existsSync14("/usr/bin/cursor");
 }
 function readHooksJson(workspaceRoot) {
-  const hooksPath = join8(workspaceRoot, ".cursor", "hooks.json");
+  const hooksPath = join9(workspaceRoot, ".cursor", "hooks.json");
   try {
-    return JSON.parse(readFileSync11(hooksPath, "utf-8"));
+    return JSON.parse(readFileSync12(hooksPath, "utf-8"));
   } catch {
     return {};
   }
 }
 function writeHooksJson(workspaceRoot, data) {
-  const dir = join8(workspaceRoot, ".cursor");
-  if (!existsSync13(dir)) mkdirSync5(dir, { recursive: true });
-  writeFileSync6(join8(dir, "hooks.json"), JSON.stringify(data, null, 2) + "\n");
+  const dir = join9(workspaceRoot, ".cursor");
+  if (!existsSync14(dir)) mkdirSync5(dir, { recursive: true });
+  writeFileSync6(join9(dir, "hooks.json"), JSON.stringify(data, null, 2) + "\n");
 }
 function hasOurHook(hooks) {
   const entries = hooks.hooks?.preToolUse ?? [];
@@ -6462,10 +6876,10 @@ function removeOurHook(hooks) {
   return hooks;
 }
 function ensureGitignore(workspaceRoot) {
-  const gitignorePath = join8(workspaceRoot, ".gitignore");
+  const gitignorePath = join9(workspaceRoot, ".gitignore");
   const entry = ".fabric/";
-  if (existsSync13(gitignorePath)) {
-    const content = readFileSync11(gitignorePath, "utf-8");
+  if (existsSync14(gitignorePath)) {
+    const content = readFileSync12(gitignorePath, "utf-8");
     if (content.includes(entry)) return;
     appendFileSync3(gitignorePath, `
 # Liminal compression cache
@@ -6479,7 +6893,7 @@ ${entry}
 }
 function rmdirIfEmpty(dir) {
   try {
-    if (existsSync13(dir) && readdirSync(dir).length === 0) {
+    if (existsSync14(dir) && readdirSync2(dir).length === 0) {
       rmdirSync(dir);
     }
   } catch {
@@ -6502,20 +6916,20 @@ async function setupCursorCommand(flags) {
       writeHooksJson(workspaceRoot, updated2);
       console.log(success("Removed hook entry from .cursor/hooks.json"));
     } else {
-      const hooksJsonPath = join8(workspaceRoot, ".cursor", "hooks.json");
+      const hooksJsonPath = join9(workspaceRoot, ".cursor", "hooks.json");
       try {
         unlinkSync4(hooksJsonPath);
       } catch {
       }
       console.log(success("Deleted .cursor/hooks.json", "no remaining hooks"));
     }
-    const scriptPath2 = join8(workspaceRoot, ".cursor", "hooks", HOOK_SCRIPT_NAME);
+    const scriptPath2 = join9(workspaceRoot, ".cursor", "hooks", HOOK_SCRIPT_NAME);
     try {
       unlinkSync4(scriptPath2);
       console.log(success(`Deleted .cursor/hooks/${HOOK_SCRIPT_NAME}`));
     } catch {
     }
-    rmdirIfEmpty(join8(workspaceRoot, ".cursor", "hooks"));
+    rmdirIfEmpty(join9(workspaceRoot, ".cursor", "hooks"));
     console.log();
     console.log(success("Hooks removed. Reload Cursor to deactivate."));
     console.log();
@@ -6538,9 +6952,9 @@ async function setupCursorCommand(flags) {
   console.log(success("API key configured"));
   console.log();
   console.log(`  ${c.dim}[3/4]${c.reset} Installing compression hooks...`);
-  const hooksDir = join8(workspaceRoot, ".cursor", "hooks");
-  if (!existsSync13(hooksDir)) mkdirSync5(hooksDir, { recursive: true });
-  const scriptPath = join8(hooksDir, HOOK_SCRIPT_NAME);
+  const hooksDir = join9(workspaceRoot, ".cursor", "hooks");
+  if (!existsSync14(hooksDir)) mkdirSync5(hooksDir, { recursive: true });
+  const scriptPath = join9(hooksDir, HOOK_SCRIPT_NAME);
   writeFileSync6(scriptPath, getHookScript(), { mode: 493 });
   console.log(success(`Wrote .cursor/hooks/${HOOK_SCRIPT_NAME}`));
   const hooks = readHooksJson(workspaceRoot);
@@ -6569,8 +6983,8 @@ init_loader();
 init_store();
 init_aggregator();
 init_format();
-import { existsSync as existsSync14, readFileSync as readFileSync12 } from "fs";
-import { join as join9 } from "path";
+import { existsSync as existsSync15, readFileSync as readFileSync13 } from "fs";
+import { join as join10 } from "path";
 async function statsCommand(flags) {
   if (!isConfigured()) {
     console.log(error(
@@ -6606,7 +7020,7 @@ async function statsCommand(flags) {
           agg.recordSkipped(s.connector, 0);
         }
       }
-      const cursorMetrics = parseCursorHookStats();
+      const cursorMetrics = parseCursorHookStats2();
       if (cursorMetrics) {
         agg.setCursorMetrics(cursorMetrics);
       }
@@ -6759,14 +7173,14 @@ async function statsCommand(flags) {
   console.log(`  ${c.dim}\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500${c.reset}`);
   console.log();
 }
-function parseCursorHookStats() {
-  const logPath = join9(process.cwd(), ".fabric", "compress.log");
-  if (!existsSync14(logPath)) return null;
+function parseCursorHookStats2() {
+  const logPath = join10(process.cwd(), ".fabric", "compress.log");
+  if (!existsSync15(logPath)) return null;
   let compressions = 0, errors = 0;
   let tokensProcessed = 0, tokensSaved = 0;
   let apiMsSumMs = 0;
   const files = /* @__PURE__ */ new Set();
-  const lines = readFileSync12(logPath, "utf-8").trim().split("\n");
+  const lines = readFileSync13(logPath, "utf-8").trim().split("\n");
   for (const line of lines) {
     try {
       const entry = JSON.parse(line);
@@ -6786,7 +7200,7 @@ function parseCursorHookStats() {
   }
   let cacheCount = 0;
   try {
-    cacheCount = countFilesRecursive(join9(process.cwd(), ".fabric", "cache"));
+    cacheCount = countFilesRecursive2(join10(process.cwd(), ".fabric", "cache"));
   } catch {
   }
   return {
@@ -6799,13 +7213,13 @@ function parseCursorHookStats() {
     cacheCount
   };
 }
-function countFilesRecursive(dir) {
-  if (!existsSync14(dir)) return 0;
-  const { readdirSync: readdirSync2 } = __require("fs");
+function countFilesRecursive2(dir) {
+  if (!existsSync15(dir)) return 0;
+  const { readdirSync: readdirSync3 } = __require("fs");
   let count = 0;
-  for (const entry of readdirSync2(dir, { withFileTypes: true })) {
+  for (const entry of readdirSync3(dir, { withFileTypes: true })) {
     if (entry.isDirectory()) {
-      count += countFilesRecursive(join9(dir, entry.name));
+      count += countFilesRecursive2(join10(dir, entry.name));
     } else {
       count++;
     }