@cognisos/liminal 2.5.0 → 2.5.1

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.5.1" : "2.5.0";
     BANNER_LINES = [
       " ___       ___  _____ ______   ___  ________   ________  ___",
       "|\\  \\     |\\  \\|\\   _ \\  _   \\|\\  \\|\\   ___  \\|\\   __  \\|\\  \\",
@@ -659,74 +670,6 @@ var init_prompts = __esm({
   }
 });
 
-// src/rsc/pipeline.ts
-var pipeline_exports = {};
-__export(pipeline_exports, {
-  RSCPipelineWrapper: () => RSCPipelineWrapper
-});
-import {
-  CompressionPipeline,
-  RSCTransport,
-  RSCEventEmitter,
-  Session,
-  CircuitBreaker
-} from "@cognisos/rsc-sdk";
-var RSCPipelineWrapper;
-var init_pipeline = __esm({
-  "src/rsc/pipeline.ts"() {
-    "use strict";
-    RSCPipelineWrapper = class {
-      pipeline;
-      session;
-      events;
-      transport;
-      circuitBreaker;
-      constructor(config) {
-        this.circuitBreaker = new CircuitBreaker(5, 5 * 60 * 1e3);
-        this.transport = new RSCTransport({
-          baseUrl: config.rscBaseUrl,
-          apiKey: config.rscApiKey,
-          timeout: 3e4,
-          maxRetries: 3,
-          circuitBreaker: this.circuitBreaker
-        });
-        this.events = new RSCEventEmitter();
-        this.session = new Session(config.sessionId);
-        this.pipeline = new CompressionPipeline(
-          this.transport,
-          {
-            threshold: config.compressionThreshold,
-            learnFromResponses: config.learnFromResponses,
-            latencyBudgetMs: config.latencyBudgetMs,
-            sessionId: this.session.sessionId
-          },
-          this.events
-        );
-      }
-      async healthCheck() {
-        try {
-          await this.transport.get("/health");
-          return true;
-        } catch {
-          return false;
-        }
-      }
-      getSessionSummary() {
-        return this.session.getSummary();
-      }
-      getCircuitState() {
-        return this.circuitBreaker.getState();
-      }
-      isCircuitOpen() {
-        return this.circuitBreaker.getState() === "open";
-      }
-      resetCircuitBreaker() {
-        this.circuitBreaker.reset();
-      }
-    };
-  }
-});
-
 // 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 +771,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 +867,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 +983,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 +1473,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 +1527,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 +1581,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 +1614,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 +1650,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 +1667,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 +1728,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 [];
@@ -1823,8 +1954,8 @@ import { stdin, stdout } from "process";
 
 // src/auth/supabase.ts
 import { randomBytes, createHash } from "crypto";
-var SUPABASE_URL = "https://nzcneiyymvgxvttbenhp.supabase.co";
-var SUPABASE_ANON_KEY = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6Im56Y25laXl5bXZneHZ0dGJlbmhwIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NTQwNjQ0MjcsImV4cCI6MjA2OTY0MDQyN30.x3E-zGRadbPMmxRqT_PB_KOi00htKpgeb8GiQa4g2z0";
+var SUPABASE_URL = process.env.LIMINAL_SUPABASE_URL || "https://nzcneiyymvgxvttbenhp.supabase.co";
+var SUPABASE_ANON_KEY = process.env.LIMINAL_SUPABASE_KEY || "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6Im56Y25laXl5bXZneHZ0dGJlbmhwIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NTQwNjQ0MjcsImV4cCI6MjA2OTY0MDQyN30.x3E-zGRadbPMmxRqT_PB_KOi00htKpgeb8GiQa4g2z0";
 function supabaseHeaders(accessToken) {
   const headers = {
     "Content-Type": "application/json",
@@ -1907,18 +2038,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(() => ({}));
@@ -2413,7 +2563,7 @@ import forge from "node-forge";
 var CA_CERT_PATH = join5(LIMINAL_DIR, "ca.pem");
 var CA_KEY_PATH = join5(LIMINAL_DIR, "ca-key.pem");
 function generateCA() {
-  const keys = forge.pki.rsa.generateKeyPair(2048);
+  const keys = forge.pki.rsa.generateKeyPair(4096);
   const cert = forge.pki.createCertificate();
   cert.publicKey = keys.publicKey;
   cert.serialNumber = generateSerialNumber();
@@ -2814,7 +2964,7 @@ var verificationStep = {
   async execute(ctx) {
     console.log(`  Running health checks...`);
     console.log();
-    const { RSCPipelineWrapper: RSCPipelineWrapper2 } = await Promise.resolve().then(() => (init_pipeline(), pipeline_exports));
+    const { RSCPipelineWrapper: RSCPipelineWrapper2 } = await import("@cognisos/proxy-core");
     const config = loadConfig();
     const probe = new RSCPipelineWrapper2({
       rscApiKey: config.apiKey,
@@ -2899,9 +3049,9 @@ async function initCommand() {
   console.log();
 }
 async function checkPort(port) {
-  const { createServer: createServer2 } = await import("net");
+  const { createServer } = await import("net");
   return new Promise((resolve) => {
-    const server = createServer2();
+    const server = createServer();
     server.once("error", () => resolve(false));
     server.once("listening", () => {
       server.close(() => resolve(true));
@@ -2924,632 +3074,18 @@ async function logoutCommand() {
 
 // src/commands/start.ts
 init_loader();
+import { writeFileSync as writeFileSync6 } from "fs";
+import { join as join8 } from "path";
+import { homedir as homedir5 } from "os";
 
 // src/proxy/completions.ts
-import { RSCCircuitOpenError as RSCCircuitOpenError2 } from "@cognisos/rsc-sdk";
-
-// src/rsc/message-compressor.ts
 import { RSCCircuitOpenError } from "@cognisos/rsc-sdk";
-
-// src/rsc/content-segmenter.ts
-function segmentContent(text) {
-  if (text.length === 0) return [{ type: "prose", text: "" }];
-  const segments = [];
-  const lines = text.split("\n");
-  let i = 0;
-  let proseBuf = [];
-  function flushProse() {
-    if (proseBuf.length > 0) {
-      segments.push({ type: "prose", text: proseBuf.join("\n") });
-      proseBuf = [];
-    }
-  }
-  while (i < lines.length) {
-    const line = lines[i];
-    const fenceMatch = matchFenceOpen(line);
-    if (fenceMatch) {
-      if (proseBuf.length > 0) {
-        flushProse();
-        segments[segments.length - 1].text += "\n";
-      }
-      const codeBuf = [line];
-      i++;
-      let closed = false;
-      while (i < lines.length) {
-        codeBuf.push(lines[i]);
-        if (matchFenceClose(lines[i], fenceMatch.char, fenceMatch.length)) {
-          closed = true;
-          i++;
-          break;
-        }
-        i++;
-      }
-      let codeText = codeBuf.join("\n");
-      if (i < lines.length) {
-        codeText += "\n";
-      }
-      segments.push({ type: "code", text: codeText });
-      continue;
-    }
-    if (isIndentedCodeLine(line)) {
-      if (proseBuf.length > 0) {
-        flushProse();
-        segments[segments.length - 1].text += "\n";
-      }
-      const codeBuf = [line];
-      i++;
-      while (i < lines.length) {
-        if (isIndentedCodeLine(lines[i])) {
-          codeBuf.push(lines[i]);
-          i++;
-        } else if (lines[i].trim() === "" && i + 1 < lines.length && isIndentedCodeLine(lines[i + 1])) {
-          codeBuf.push(lines[i]);
-          i++;
-        } else {
-          break;
-        }
-      }
-      let codeText = codeBuf.join("\n");
-      if (i < lines.length) {
-        codeText += "\n";
-      }
-      segments.push({ type: "code", text: codeText });
-      continue;
-    }
-    if (proseBuf.length > 0) {
-      proseBuf.push(line);
-    } else {
-      proseBuf.push(line);
-    }
-    i++;
-  }
-  if (proseBuf.length > 0) {
-    flushProse();
-  }
-  if (segments.length === 0) {
-    return [{ type: "prose", text }];
-  }
-  return segments;
-}
-function matchFenceOpen(line) {
-  const match = line.match(/^( {0,3})((`{3,})|~{3,})(.*)$/);
-  if (!match) return null;
-  const fenceStr = match[2];
-  const char = fenceStr[0];
-  if (char === "`" && match[4] && match[4].includes("`")) return null;
-  return { char, length: fenceStr.length };
-}
-function matchFenceClose(line, char, minLength) {
-  const match = line.match(/^( {0,3})((`{3,})|(~{3,}))\s*$/);
-  if (!match) return false;
-  const fenceStr = match[2];
-  return fenceStr[0] === char && fenceStr.length >= minLength;
-}
-function isIndentedCodeLine(line) {
-  return (line.startsWith("    ") || line.startsWith("	")) && line.trim().length > 0;
-}
-
-// src/rsc/message-compressor.ts
-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, "");
-}
-async function compressMessages(messages, pipeline, session, compressRoles) {
-  let anyCompressed = false;
-  let totalTokensSaved = 0;
-  const compressed = await Promise.all(
-    messages.map(async (msg) => {
-      if (!compressRoles.has(msg.role)) return msg;
-      return compressMessage(msg, pipeline, session, (c2, saved) => {
-        anyCompressed = anyCompressed || c2;
-        totalTokensSaved += saved;
-      });
-    })
-  );
-  return { messages: compressed, anyCompressed, totalTokensSaved };
-}
-async function compressConversation(pipeline, session, plan, options = { compressToolResults: true }) {
-  if (!plan.shouldCompress) {
-    return {
-      messages: plan.messages.map((tm) => tm.message),
-      anyCompressed: false,
-      totalTokensSaved: 0
-    };
-  }
-  const log = options.logFn;
-  const threshold = options.compressionThreshold ?? 100;
-  const results = new Array(plan.messages.length);
-  const compressible = [];
-  for (let i = 0; i < plan.messages.length; i++) {
-    const tm = plan.messages[i];
-    const role = tm.message.role;
-    const blockTypes = Array.isArray(tm.message.content) ? tm.message.content.map((b) => b.type).join(",") : "string";
-    if (tm.tier === "hot") {
-      log?.(`[BLOCK] #${tm.index} ${role} [${blockTypes}] \u2192 HOT (verbatim)`);
-      results[i] = tm.message;
-      continue;
-    }
-    if (tm.eligibleTokens === 0) {
-      log?.(`[BLOCK] #${tm.index} ${role} [${blockTypes}] \u2192 ${tm.tier.toUpperCase()} (0 eligible tok, skip)`);
-      results[i] = tm.message;
-      continue;
-    }
-    const proseEstimate = estimateProseTokens(tm.message, options.compressToolResults);
-    if (proseEstimate < threshold) {
-      log?.(`[BLOCK] #${tm.index} ${role} [${blockTypes}] \u2192 ${tm.tier.toUpperCase()} (${proseEstimate} prose tok after segmentation < ${threshold} threshold, skip)`);
-      results[i] = tm.message;
-      continue;
-    }
-    const { batchText, batchedIndices } = extractBatchableText(tm.message, options.compressToolResults);
-    if (!batchText) {
-      results[i] = tm.message;
-      continue;
-    }
-    log?.(`[BLOCK] #${tm.index} ${role} [${blockTypes}] \u2192 ${tm.tier.toUpperCase()} (${tm.eligibleTokens} eligible tok, ~${proseEstimate} prose tok, batching)`);
-    compressible.push({ planIdx: i, tm, batchText, batchedIndices });
-  }
-  if (compressible.length === 0) {
-    return {
-      messages: results,
-      anyCompressed: false,
-      totalTokensSaved: 0
-    };
-  }
-  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);
-      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})`);
-    } else {
-      log?.(`[COMPRESS-ERROR] ${errMsg}`);
-    }
-    for (const entry of compressible) {
-      if (!results[entry.planIdx]) {
-        results[entry.planIdx] = entry.tm.message;
-      }
-    }
-  } finally {
-    if (options.semaphore) options.semaphore.release();
-  }
-  return { messages: results, anyCompressed, totalTokensSaved };
-}
-function extractBatchableText(msg, compressToolResults) {
-  const batchedIndices = /* @__PURE__ */ new Set();
-  if (typeof msg.content === "string") {
-    if (msg.content.trim()) {
-      return { batchText: msg.content, batchedIndices };
-    }
-    return { batchText: null, batchedIndices };
-  }
-  if (!Array.isArray(msg.content)) return { batchText: null, batchedIndices };
-  const parts = msg.content;
-  const textSegments = [];
-  for (let i = 0; i < parts.length; i++) {
-    const part = parts[i];
-    if (PASSTHROUGH_BLOCK_TYPES.has(part.type)) continue;
-    if (part.type === "text" && typeof part.text === "string" && part.text.trim()) {
-      textSegments.push(part.text);
-      batchedIndices.add(i);
-    }
-    if (part.type === "tool_result" && compressToolResults) {
-      const extracted = extractToolResultText(part);
-      if (extracted) {
-        textSegments.push(extracted);
-        batchedIndices.add(i);
-      }
-    }
-  }
-  return {
-    batchText: textSegments.length > 0 ? textSegments.join("\n\n") : null,
-    batchedIndices
-  };
-}
-function reassembleMessage(msg, compressedText, batchedIndices) {
-  if (typeof msg.content === "string") {
-    return { ...msg, content: compressedText };
-  }
-  if (!Array.isArray(msg.content)) return msg;
-  const parts = msg.content;
-  const newParts = [];
-  let isFirstEligible = true;
-  for (let i = 0; i < parts.length; i++) {
-    if (!batchedIndices.has(i)) {
-      newParts.push(parts[i]);
-      continue;
-    }
-    if (isFirstEligible) {
-      if (parts[i].type === "text") {
-        newParts.push({ ...parts[i], text: compressedText });
-      } else if (parts[i].type === "tool_result") {
-        newParts.push({ ...parts[i], content: compressedText });
-      }
-      isFirstEligible = false;
-    } else {
-      if (parts[i].type === "tool_result") {
-        newParts.push({ ...parts[i], content: "" });
-      }
-    }
-  }
-  return { ...msg, content: newParts };
-}
-function estimateProseTokens(msg, compressToolResults) {
-  const text = extractCompressibleText(msg, compressToolResults);
-  if (!text) return 0;
-  const segments = segmentContent(text);
-  return segments.filter((s) => s.type === "prose").reduce((sum, s) => sum + Math.ceil(s.text.length / 4), 0);
-}
-function extractCompressibleText(msg, compressToolResults) {
-  if (typeof msg.content === "string") {
-    return msg.content.trim() ? msg.content : null;
-  }
-  if (!Array.isArray(msg.content)) return null;
-  const parts = msg.content;
-  const textSegments = [];
-  for (const part of parts) {
-    if (PASSTHROUGH_BLOCK_TYPES.has(part.type)) continue;
-    if (part.type === "text" && typeof part.text === "string" && part.text.trim()) {
-      textSegments.push(part.text);
-    }
-    if (part.type === "tool_result" && compressToolResults) {
-      const extracted = extractToolResultText(part);
-      if (extracted) textSegments.push(extracted);
-    }
-  }
-  return textSegments.length > 0 ? textSegments.join("\n\n") : null;
-}
-function extractToolResultText(part) {
-  if (typeof part.content === "string" && part.content.trim()) {
-    return part.content;
-  }
-  if (Array.isArray(part.content)) {
-    const texts = part.content.filter((inner) => inner.type === "text" && typeof inner.text === "string" && inner.text.trim()).map((inner) => inner.text);
-    return texts.length > 0 ? texts.join("\n") : null;
-  }
-  return null;
-}
-async function compressMessage(msg, pipeline, session, record, options = { compressToolResults: true }) {
-  if (typeof msg.content === "string") {
-    return compressStringContent(msg, pipeline, session, record);
-  }
-  if (Array.isArray(msg.content)) {
-    return compressArrayContent(msg, pipeline, session, record, options);
-  }
-  return msg;
-}
-async function compressStringContent(msg, pipeline, session, record, semaphore, semaphoreTimeoutMs) {
-  const text = msg.content;
-  try {
-    const compressed = await compressTextWithSegmentation(text, pipeline, session, record, semaphore, semaphoreTimeoutMs);
-    return { ...msg, content: compressed };
-  } catch (err) {
-    if (err instanceof RSCCircuitOpenError) {
-      session.recordFailure();
-      throw err;
-    }
-    session.recordFailure();
-    return msg;
-  }
-}
-async function compressArrayContent(msg, pipeline, session, record, options = { compressToolResults: true }) {
-  const parts = msg.content;
-  const compressedParts = await Promise.all(
-    parts.map(async (part) => {
-      if (PASSTHROUGH_BLOCK_TYPES.has(part.type)) return part;
-      if (part.type === "text" && typeof part.text === "string") {
-        try {
-          const compressed = await compressTextWithSegmentation(part.text, pipeline, session, record);
-          return { ...part, text: compressed };
-        } catch (err) {
-          if (err instanceof RSCCircuitOpenError) {
-            session.recordFailure();
-            throw err;
-          }
-          session.recordFailure();
-          return part;
-        }
-      }
-      if (part.type === "tool_result" && options.compressToolResults) {
-        return compressToolResult(part, pipeline, session, record);
-      }
-      return part;
-    })
-  );
-  return { ...msg, content: compressedParts };
-}
-async function compressToolResult(part, pipeline, session, record) {
-  const content = part.content;
-  if (typeof content === "string") {
-    try {
-      const compressed = await compressTextWithSegmentation(content, pipeline, session, record);
-      return { ...part, content: compressed };
-    } catch (err) {
-      if (err instanceof RSCCircuitOpenError) {
-        session.recordFailure();
-        throw err;
-      }
-      session.recordFailure();
-      return part;
-    }
-  }
-  if (Array.isArray(content)) {
-    try {
-      const compressedInner = await Promise.all(
-        content.map(async (inner) => {
-          if (inner.type === "text" && typeof inner.text === "string") {
-            try {
-              const compressed = await compressTextWithSegmentation(inner.text, pipeline, session, record);
-              return { ...inner, text: compressed };
-            } catch (err) {
-              if (err instanceof RSCCircuitOpenError) throw err;
-              session.recordFailure();
-              return inner;
-            }
-          }
-          return inner;
-        })
-      );
-      return { ...part, content: compressedInner };
-    } catch (err) {
-      if (err instanceof RSCCircuitOpenError) {
-        session.recordFailure();
-        throw err;
-      }
-      session.recordFailure();
-      return part;
-    }
-  }
-  return part;
-}
-async function compressTextWithSegmentation(text, pipeline, session, record, semaphore, semaphoreTimeoutMs) {
-  const segments = segmentContent(text);
-  const hasCode = segments.some((s) => s.type === "code");
-  if (!hasCode) {
-    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);
-      record(!result.metrics.skipped, saved);
-      return sanitizeCompressedText(result.text);
-    } finally {
-      if (semaphore) semaphore.release();
-    }
-  }
-  const parts = await Promise.all(
-    segments.map(async (seg) => {
-      if (seg.type === "code") return seg.text;
-      if (seg.text.trim().length === 0) return seg.text;
-      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);
-        record(!result.metrics.skipped, saved);
-        return sanitizeCompressedText(result.text);
-      } catch (err) {
-        if (err instanceof RSCCircuitOpenError) throw err;
-        session.recordFailure();
-        return seg.text;
-      } finally {
-        if (semaphore) semaphore.release();
-      }
-    })
-  );
-  return parts.join("");
-}
-
-// src/rsc/conversation-analyzer.ts
-var SKIP_BLOCK_TYPES = /* @__PURE__ */ new Set(["thinking", "tool_use", "image"]);
-function estimateTokens(text) {
-  return Math.ceil(text.length / 4);
-}
-function estimateBlockTokens(block, compressToolResults) {
-  if (SKIP_BLOCK_TYPES.has(block.type)) return 0;
-  if (block.type === "text" && typeof block.text === "string") {
-    return estimateTokens(block.text);
-  }
-  if (block.type === "tool_result" && compressToolResults) {
-    if (typeof block.content === "string") {
-      return estimateTokens(block.content);
-    }
-    if (Array.isArray(block.content)) {
-      return block.content.reduce(
-        (sum, inner) => sum + estimateBlockTokens(inner, compressToolResults),
-        0
-      );
-    }
-  }
-  return 0;
-}
-function estimateMessageTokens(msg, config) {
-  if (!config.compressRoles.has(msg.role)) return 0;
-  if (typeof msg.content === "string") {
-    return estimateTokens(msg.content);
-  }
-  if (Array.isArray(msg.content)) {
-    return msg.content.reduce(
-      (sum, part) => sum + estimateBlockTokens(part, config.compressToolResults),
-      0
-    );
-  }
-  return 0;
-}
-function analyzeConversation(messages, config) {
-  const n = messages.length;
-  if (n < 5) {
-    const tiered2 = messages.map((msg, i) => ({
-      index: i,
-      message: msg,
-      tier: "hot",
-      eligibleTokens: estimateMessageTokens(msg, config)
-    }));
-    return {
-      messages: tiered2,
-      totalEligibleTokens: 0,
-      shouldCompress: false,
-      hotCount: n,
-      warmCount: 0,
-      coldCount: 0
-    };
-  }
-  const coldEnd = Math.floor(n * config.coldFraction);
-  const hotStart = n - Math.floor(n * config.hotFraction);
-  let totalEligibleTokens = 0;
-  let hotCount = 0;
-  let warmCount = 0;
-  let coldCount = 0;
-  const tiered = messages.map((msg, i) => {
-    let tier;
-    if (i >= hotStart) {
-      tier = "hot";
-      hotCount++;
-    } else if (i < coldEnd) {
-      tier = "cold";
-      coldCount++;
-    } else {
-      tier = "warm";
-      warmCount++;
-    }
-    const eligibleTokens = estimateMessageTokens(msg, config);
-    if (tier !== "hot") {
-      totalEligibleTokens += eligibleTokens;
-    }
-    return { index: i, message: msg, tier, eligibleTokens };
-  });
-  return {
-    messages: tiered,
-    totalEligibleTokens,
-    shouldCompress: totalEligibleTokens >= config.aggregateThreshold,
-    hotCount,
-    warmCount,
-    coldCount
-  };
-}
-
-// src/rsc/learning.ts
-function createStreamLearningBuffer(pipeline) {
-  let buffer = "";
-  return {
-    /** Append a text delta from an SSE chunk */
-    append(text) {
-      buffer += text;
-    },
-    /** Flush the buffer — triggers fire-and-forget learning */
-    flush() {
-      if (buffer.length > 0) {
-        pipeline.triggerLearning(buffer);
-        buffer = "";
-      }
-    },
-    /** Get current buffer contents (for testing) */
-    getBuffer() {
-      return buffer;
-    }
-  };
-}
-
-// src/proxy/streaming.ts
-async function pipeSSEResponse(upstreamResponse, clientRes, onContentDelta, onComplete, totalTokensSaved = 0) {
-  clientRes.writeHead(200, {
-    "Content-Type": "text/event-stream",
-    "Cache-Control": "no-cache",
-    "Connection": "keep-alive",
-    "Access-Control-Allow-Origin": "*"
-  });
-  const reader = upstreamResponse.body.getReader();
-  const decoder = new TextDecoder();
-  let lineBuf = "";
-  const needsAdjustment = totalTokensSaved > 0;
-  try {
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      const chunk = decoder.decode(value, { stream: true });
-      if (!needsAdjustment) {
-        clientRes.write(chunk);
-        lineBuf += chunk;
-        const lines2 = lineBuf.split("\n");
-        lineBuf = lines2.pop() || "";
-        for (const line of lines2) {
-          if (line.startsWith("data: ") && line !== "data: [DONE]") {
-            try {
-              const json = JSON.parse(line.slice(6));
-              const content = json?.choices?.[0]?.delta?.content;
-              if (typeof content === "string") {
-                onContentDelta(content);
-              }
-            } catch {
-            }
-          }
-        }
-        continue;
-      }
-      lineBuf += chunk;
-      const lines = lineBuf.split("\n");
-      lineBuf = lines.pop() || "";
-      let adjusted = false;
-      const outputLines = [];
-      for (const line of lines) {
-        if (line.startsWith("data: ") && line !== "data: [DONE]") {
-          try {
-            const json = JSON.parse(line.slice(6));
-            if (json?.usage?.prompt_tokens != null) {
-              json.usage.prompt_tokens += totalTokensSaved;
-              if (json.usage.total_tokens != null) {
-                json.usage.total_tokens += totalTokensSaved;
-              }
-              outputLines.push(`data: ${JSON.stringify(json)}`);
-              adjusted = true;
-            } else {
-              outputLines.push(line);
-            }
-            const content = json?.choices?.[0]?.delta?.content;
-            if (typeof content === "string") {
-              onContentDelta(content);
-            }
-          } catch {
-            outputLines.push(line);
-          }
-        } else {
-          outputLines.push(line);
-        }
-      }
-      if (adjusted) {
-        const reconstructed = outputLines.join("\n") + "\n";
-        clientRes.write(reconstructed);
-      } else {
-        clientRes.write(chunk);
-      }
-    }
-  } finally {
-    clientRes.end();
-    onComplete();
-  }
-}
+import {
+  compressConversation,
+  analyzeConversation,
+  createStreamLearningBuffer,
+  pipeSSEResponse
+} from "@cognisos/proxy-core";
 
 // src/terminology.ts
 var TIER_LABELS = {
@@ -3586,7 +3122,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 +3181,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;
@@ -3663,7 +3200,7 @@ async function handleChatCompletions(req, res, body, pipeline, config, logger, s
         logger.log(formatSavedLog(result.totalTokensSaved, latencyMs));
       }
     } catch (err) {
-      if (err instanceof RSCCircuitOpenError2) {
+      if (err instanceof RSCCircuitOpenError) {
         logger.log(formatDegradeLog());
       } else {
         logger.log(`[ERROR] Compression failed: ${err instanceof Error ? err.message : String(err)}`);
@@ -3696,7 +3233,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 +3264,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;
@@ -3749,103 +3286,13 @@ async function handleChatCompletions(req, res, body, pipeline, config, logger, s
 }
 
 // src/proxy/messages.ts
-import { RSCCircuitOpenError as RSCCircuitOpenError3 } from "@cognisos/rsc-sdk";
-
-// src/proxy/anthropic-streaming.ts
-function adjustMessageStartLine(dataLine, tokensSaved) {
-  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)}`;
-    }
-  } catch {
-  }
-  return null;
-}
-async function pipeAnthropicSSEResponse(upstreamResponse, clientRes, onContentDelta, onComplete, totalTokensSaved = 0) {
-  clientRes.writeHead(200, {
-    "Content-Type": "text/event-stream",
-    "Cache-Control": "no-cache",
-    "Connection": "keep-alive",
-    "Access-Control-Allow-Origin": "*"
-  });
-  const reader = upstreamResponse.body.getReader();
-  const decoder = new TextDecoder();
-  let lineBuf = "";
-  let currentEvent = "";
-  let usageAdjusted = false;
-  const needsAdjustment = totalTokensSaved > 0;
-  try {
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      const chunk = decoder.decode(value, { stream: true });
-      if (!needsAdjustment || usageAdjusted) {
-        clientRes.write(chunk);
-        lineBuf += chunk;
-        const lines2 = lineBuf.split("\n");
-        lineBuf = lines2.pop() || "";
-        for (const line of lines2) {
-          if (line.startsWith("event: ")) {
-            currentEvent = line.slice(7).trim();
-          } else if (line.startsWith("data: ") && currentEvent === "content_block_delta") {
-            try {
-              const json = JSON.parse(line.slice(6));
-              if (json?.delta?.type === "text_delta" && typeof json.delta.text === "string") {
-                onContentDelta(json.delta.text);
-              }
-            } catch {
-            }
-          }
-        }
-        continue;
-      }
-      lineBuf += chunk;
-      const lines = lineBuf.split("\n");
-      lineBuf = lines.pop() || "";
-      let adjusted = 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 {
-            outputLines.push(line);
-          }
-        } else {
-          outputLines.push(line);
-          if (line.startsWith("data: ") && currentEvent === "content_block_delta") {
-            try {
-              const json = JSON.parse(line.slice(6));
-              if (json?.delta?.type === "text_delta" && typeof json.delta.text === "string") {
-                onContentDelta(json.delta.text);
-              }
-            } catch {
-            }
-          }
-        }
-      }
-      if (adjusted) {
-        const reconstructed = outputLines.join("\n") + "\n" + (lineBuf ? "" : "");
-        clientRes.write(reconstructed);
-      } else {
-        clientRes.write(chunk);
-      }
-    }
-  } finally {
-    clientRes.end();
-    onComplete();
-  }
-}
-
-// src/proxy/messages.ts
+import { RSCCircuitOpenError as RSCCircuitOpenError2 } from "@cognisos/rsc-sdk";
+import {
+  compressConversation as compressConversation2,
+  analyzeConversation as analyzeConversation2,
+  createStreamLearningBuffer as createStreamLearningBuffer2,
+  pipeAnthropicSSEResponse
+} from "@cognisos/proxy-core";
 function setCORSHeaders2(res) {
   res.setHeader("Access-Control-Allow-Origin", "*");
   res.setHeader("Access-Control-Allow-Methods", "POST, GET, OPTIONS");
@@ -3880,7 +3327,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 +3342,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 import("@cognisos/proxy-core");
+  const originalInputTokens = countTok(JSON.stringify(request));
   let messages = request.messages;
   let anyCompressed = false;
   let totalTokensSaved = 0;
@@ -3903,7 +3352,7 @@ async function handleAnthropicMessages(req, res, body, pipeline, config, logger,
     try {
       const compressRoles = new Set(config.compressRoles);
       const compressible = convertAnthropicToCompressible(request.messages);
-      const plan = analyzeConversation(compressible, {
+      const plan = analyzeConversation2(compressible, {
         hotFraction: config.hotFraction,
         coldFraction: config.coldFraction,
         aggregateThreshold: config.aggregateThreshold,
@@ -3931,7 +3380,7 @@ async function handleAnthropicMessages(req, res, body, pipeline, config, logger,
           hotCount++;
         }
       };
-      const result = await compressConversation(
+      const result = await compressConversation2(
         pipeline.pipeline,
         pipeline.session,
         plan,
@@ -3940,7 +3389,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;
@@ -3958,7 +3408,7 @@ async function handleAnthropicMessages(req, res, body, pipeline, config, logger,
         logger.log(formatSavedLog(result.totalTokensSaved, latencyMs));
       }
     } catch (err) {
-      if (err instanceof RSCCircuitOpenError3) {
+      if (err instanceof RSCCircuitOpenError2) {
         logger.log(formatDegradeLog());
       } else {
         logger.log(`[ERROR] Compression failed: ${err instanceof Error ? err.message : String(err)}`);
@@ -3968,6 +3418,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 +3448,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 = createStreamLearningBuffer2(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(
@@ -4047,100 +3508,12 @@ async function handleAnthropicMessages(req, res, body, pipeline, config, logger,
 }
 
 // src/proxy/responses.ts
-import { RSCCircuitOpenError as RSCCircuitOpenError4 } from "@cognisos/rsc-sdk";
-
-// src/proxy/responses-streaming.ts
-async function pipeResponsesSSE(upstreamResponse, clientRes, onContentDelta, onComplete, totalTokensSaved = 0) {
-  clientRes.writeHead(200, {
-    "Content-Type": "text/event-stream",
-    "Cache-Control": "no-cache",
-    "Connection": "keep-alive",
-    "Access-Control-Allow-Origin": "*"
-  });
-  const reader = upstreamResponse.body.getReader();
-  const decoder = new TextDecoder();
-  let lineBuf = "";
-  let currentEvent = "";
-  let usageAdjusted = false;
-  const needsAdjustment = totalTokensSaved > 0;
-  try {
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      const chunk = decoder.decode(value, { stream: true });
-      if (!needsAdjustment || usageAdjusted) {
-        clientRes.write(chunk);
-        lineBuf += chunk;
-        const lines2 = lineBuf.split("\n");
-        lineBuf = lines2.pop() || "";
-        for (const line of lines2) {
-          if (line.startsWith("event: ")) {
-            currentEvent = line.slice(7).trim();
-          } else if (line.startsWith("data: ") && currentEvent === "response.output_text.delta") {
-            try {
-              const json = JSON.parse(line.slice(6));
-              if (typeof json?.delta === "string") {
-                onContentDelta(json.delta);
-              }
-            } catch {
-            }
-          }
-        }
-        continue;
-      }
-      lineBuf += chunk;
-      const lines = lineBuf.split("\n");
-      lineBuf = lines.pop() || "";
-      let adjusted = 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 === "response.completed" && !usageAdjusted) {
-          try {
-            const json = JSON.parse(line.slice(6));
-            if (json?.response?.usage?.input_tokens != null) {
-              json.response.usage.input_tokens += totalTokensSaved;
-              if (json.response.usage.total_tokens != null) {
-                json.response.usage.total_tokens += totalTokensSaved;
-              }
-              outputLines.push(`data: ${JSON.stringify(json)}`);
-              usageAdjusted = true;
-              adjusted = true;
-            } else {
-              outputLines.push(line);
-            }
-          } catch {
-            outputLines.push(line);
-          }
-        } else {
-          outputLines.push(line);
-          if (line.startsWith("data: ") && currentEvent === "response.output_text.delta") {
-            try {
-              const json = JSON.parse(line.slice(6));
-              if (typeof json?.delta === "string") {
-                onContentDelta(json.delta);
-              }
-            } catch {
-            }
-          }
-        }
-      }
-      if (adjusted) {
-        const reconstructed = outputLines.join("\n") + "\n";
-        clientRes.write(reconstructed);
-      } else {
-        clientRes.write(chunk);
-      }
-    }
-  } finally {
-    clientRes.end();
-    onComplete();
-  }
-}
-
-// src/proxy/responses.ts
+import { RSCCircuitOpenError as RSCCircuitOpenError3 } from "@cognisos/rsc-sdk";
+import {
+  compressMessages,
+  createStreamLearningBuffer as createStreamLearningBuffer3,
+  pipeResponsesSSE
+} from "@cognisos/proxy-core";
 function setCORSHeaders3(res) {
   res.setHeader("Access-Control-Allow-Origin", "*");
   res.setHeader("Access-Control-Allow-Methods", "POST, GET, OPTIONS");
@@ -4282,7 +3655,7 @@ async function handleResponses(req, res, body, pipeline, config, logger, semapho
         }
       }
     } catch (err) {
-      if (err instanceof RSCCircuitOpenError4) {
+      if (err instanceof RSCCircuitOpenError3) {
         logger.log(formatDegradeLog());
       } else {
         logger.log(`[ERROR] Compression failed: ${err instanceof Error ? err.message : String(err)}`);
@@ -4317,7 +3690,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 = createStreamLearningBuffer3(pipeline.pipeline);
       logger.log(formatResponseLog(request.model, totalTokensSaved, true));
       await pipeResponsesSSE(
         upstreamResponse,
@@ -4348,7 +3721,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) {
@@ -4577,6 +3950,11 @@ function createRequestHandler(deps) {
         }
         return;
       }
+      if (req.headers["x-liminal-bypass"] === "true") {
+        logger.log(`[PROXY] Bypass: ${method} ${fullUrl}`);
+        await passthroughToUpstream(req, res, fullUrl, config, logger);
+        return;
+      }
       if (method === "GET" && (url === "/health" || url === "/") && !getMitmUpstreamBase(req)) {
         const sessionSummaries = sessions.getAllSummaries();
         sendJSON3(res, 200, {
@@ -4604,12 +3982,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 +4001,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 +4030,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);
@@ -4666,72 +4046,8 @@ function createRequestHandler(deps) {
   };
 }
 
-// src/proxy/server.ts
-import * as http from "http";
-var MAX_PORT_RETRIES = 5;
-var ProxyServer = class {
-  server = null;
-  activePort = null;
-  requestedPort;
-  handler;
-  connectHandler;
-  constructor(port, handler, connectHandler) {
-    this.requestedPort = port;
-    this.handler = handler;
-    this.connectHandler = connectHandler ?? null;
-  }
-  async start() {
-    let lastError = null;
-    for (let attempt = 0; attempt < MAX_PORT_RETRIES; attempt++) {
-      const port = this.requestedPort + attempt;
-      try {
-        await this.listen(port);
-        this.activePort = port;
-        return port;
-      } catch (err) {
-        lastError = err instanceof Error ? err : new Error(String(err));
-        if (err.code !== "EADDRINUSE") {
-          throw lastError;
-        }
-      }
-    }
-    throw lastError ?? new Error(`All ports ${this.requestedPort}-${this.requestedPort + MAX_PORT_RETRIES - 1} in use`);
-  }
-  listen(port) {
-    return new Promise((resolve, reject) => {
-      const server = http.createServer(this.handler);
-      if (this.connectHandler) {
-        server.on("connect", this.connectHandler);
-      }
-      server.on("error", reject);
-      server.listen(port, "127.0.0.1", () => {
-        server.removeListener("error", reject);
-        this.server = server;
-        resolve();
-      });
-    });
-  }
-  async stop() {
-    if (!this.server) return;
-    return new Promise((resolve) => {
-      this.server.close(() => {
-        this.server = null;
-        this.activePort = null;
-        resolve();
-      });
-    });
-  }
-  isRunning() {
-    return this.server !== null && this.server.listening;
-  }
-  getPort() {
-    return this.activePort;
-  }
-  /** Expose internal HTTP server for MITM bridge socket injection */
-  getHttpServer() {
-    return this.server;
-  }
-};
+// src/commands/start.ts
+import { ProxyServer } from "@cognisos/proxy-core";
 
 // src/daemon/logger.ts
 init_paths();
@@ -4789,7 +4105,7 @@ var FileLogger = class {
 };
 
 // src/rsc/session-manager.ts
-init_pipeline();
+import { RSCPipelineWrapper } from "@cognisos/proxy-core";
 var DEFAULT_MAX_SESSIONS = 10;
 var DEFAULT_SESSION_TTL_MS = 30 * 60 * 1e3;
 var EVICTION_INTERVAL_MS = 6e4;
@@ -4814,7 +4130,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 +4139,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 = [];
@@ -4895,59 +4213,8 @@ var SessionManager = class {
   }
 };
 
-// src/rsc/semaphore.ts
-var SemaphoreTimeoutError = class extends Error {
-  constructor(timeoutMs) {
-    super(`Semaphore acquire timed out after ${timeoutMs}ms`);
-    this.name = "SemaphoreTimeoutError";
-  }
-};
-var Semaphore = class {
-  permits;
-  queue = [];
-  constructor(maxPermits) {
-    if (maxPermits < 1) throw new RangeError("maxPermits must be >= 1");
-    this.permits = maxPermits;
-  }
-  get available() {
-    return this.permits;
-  }
-  get waiting() {
-    return this.queue.length;
-  }
-  acquire(timeoutMs) {
-    if (this.permits > 0) {
-      this.permits--;
-      return Promise.resolve();
-    }
-    return new Promise((resolve, reject) => {
-      const waiter = { resolve, reject };
-      this.queue.push(waiter);
-      if (timeoutMs !== void 0 && timeoutMs >= 0) {
-        const timer = setTimeout(() => {
-          const idx = this.queue.indexOf(waiter);
-          if (idx !== -1) {
-            this.queue.splice(idx, 1);
-            reject(new SemaphoreTimeoutError(timeoutMs));
-          }
-        }, timeoutMs);
-        const originalResolve = waiter.resolve;
-        waiter.resolve = () => {
-          clearTimeout(timer);
-          originalResolve();
-        };
-      }
-    });
-  }
-  release() {
-    const next = this.queue.shift();
-    if (next) {
-      next.resolve();
-    } else {
-      this.permits++;
-    }
-  }
-};
+// src/commands/start.ts
+import { Semaphore } from "@cognisos/proxy-core";
 
 // src/rsc/latency-monitor.ts
 var DEFAULT_CONFIG = {
@@ -5399,15 +4666,36 @@ async function startCommand(flags) {
         event.tokensSaved,
         event.processingTimeMs ?? 0
       );
+      pipeline.session.recordCompression(event);
     });
     pipeline.events.on("compression_skipped", (event) => {
       const detail = event.reason === "latency_budget" ? `${event.reason} (${event.estimatedTokens}tok, budget:${event.budgetMs}ms, elapsed:${event.elapsedMs}ms)` : event.reason === "below_threshold" ? `${event.reason} (${event.estimatedTokens}tok < ${config.compressionThreshold}tok threshold)` : `${event.reason} (${event.estimatedTokens}tok)`;
       logger.log(`[LIMINAL] [${key}] Skipped: ${detail}`);
       statsAggregator.recordSkipped(connector, event.estimatedTokens ?? 0);
+      pipeline.session.recordCompression({
+        ...event,
+        inputTokens: event.estimatedTokens ?? 0,
+        outputTokens: event.estimatedTokens ?? 0,
+        tokensSaved: 0,
+        ratio: 1,
+        deltaMdlBits: 0,
+        processingTimeMs: 0,
+        skipped: true,
+        fabricHits: 0,
+        fabricMisses: 0
+      });
     });
     pipeline.events.on("error", (event) => {
       logger.log(`[LIMINAL] [${key}] Error: ${event.error.message}`);
       statsAggregator.recordFailure(connector);
+      pipeline.session.recordFailure();
+    });
+    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 +4723,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({
@@ -5458,6 +4789,11 @@ async function startCommand(flags) {
   try {
     const actualPort = await server.start();
     writePidFile(process.pid);
+    try {
+      const portFilePath = join8(homedir5(), ".liminal", ".port");
+      writeFileSync6(portFilePath, String(actualPort), "utf-8");
+    } catch {
+    }
     logger.log(`[DAEMON] Liminal proxy started on http://127.0.0.1:${actualPort}`);
     logger.log(`[DAEMON] Upstream (OpenAI): ${config.upstreamBaseUrl}`);
     logger.log(`[DAEMON] Upstream (Anthropic): ${config.anthropicUpstreamUrl}`);
@@ -5486,7 +4822,7 @@ async function startCommand(flags) {
       if (caReady) {
         console.log(success("MITM bridge active", "CA trusted"));
       }
-      const { RSCPipelineWrapper: RSCPipelineWrapper3 } = await Promise.resolve().then(() => (init_pipeline(), pipeline_exports));
+      const { RSCPipelineWrapper: RSCPipelineWrapper3 } = await import("@cognisos/proxy-core");
       const probe2 = new RSCPipelineWrapper3({
         rscApiKey: config.apiKey,
         rscBaseUrl: config.apiBaseUrl,
@@ -5524,7 +4860,7 @@ async function startCommand(flags) {
       console.log();
       return;
     }
-    const { RSCPipelineWrapper: RSCPipelineWrapper2 } = await Promise.resolve().then(() => (init_pipeline(), pipeline_exports));
+    const { RSCPipelineWrapper: RSCPipelineWrapper2 } = await import("@cognisos/proxy-core");
     const probe = new RSCPipelineWrapper2({
       rscApiKey: config.apiKey,
       rscBaseUrl: config.apiBaseUrl,
@@ -5640,8 +4976,9 @@ 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 { homedir as homedir6 } from "os";
+import { join as join9 } from "path";
 async function statusCommand() {
   if (!isConfigured()) {
     console.log(error(
@@ -5660,7 +4997,13 @@ async function statusCommand() {
     return;
   }
   const config = loadConfig();
-  const port = config.port;
+  let port = config.port;
+  try {
+    const portFilePath = join9(homedir6(), ".liminal", ".port");
+    const actualPort = parseInt(readFileSync9(portFilePath, "utf-8").trim(), 10);
+    if (!isNaN(actualPort)) port = actualPort;
+  } catch {
+  }
   try {
     const res = await fetch(`http://127.0.0.1:${port}/health`, {
       signal: AbortSignal.timeout(3e3)
@@ -5709,27 +5052,27 @@ async function statusCommand() {
   }
 }
 function printCursorHookStats() {
-  const logPath = join7(process.cwd(), ".fabric", "compress.log");
-  const hooksPath = join7(process.cwd(), ".cursor", "hooks.json");
+  const logPath = join9(process.cwd(), ".fabric", "compress.log");
+  const hooksPath = join9(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 +5106,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(join9(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 +5119,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(join9(dir, entry.name));
     } else {
       count++;
     }
@@ -5864,17 +5207,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 +5243,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 +5253,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 +5343,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 +5463,10 @@ 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 { homedir as homedir5 } from "os";
-import { join as join8 } from "path";
+import { existsSync as existsSync14, readFileSync as readFileSync12, writeFileSync as writeFileSync7, mkdirSync as mkdirSync5, unlinkSync as unlinkSync4, readdirSync as readdirSync2, rmdirSync, appendFileSync as appendFileSync3 } from "fs";
+import { createHash as createHash3 } from "crypto";
+import { homedir as homedir7 } from "os";
+import { join as join10 } from "path";
 
 // src/cursor/hook-template.ts
 function getHookScript() {
@@ -6375,10 +5719,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 +5731,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,
     });
 
@@ -6408,28 +5753,36 @@ main().catch(() => passthrough());
 init_format();
 var HOOK_SCRIPT_NAME = "fabric-compress.js";
 var HOOK_COMMAND = `node .cursor/hooks/${HOOK_SCRIPT_NAME}`;
+function sha256(content) {
+  return createHash3("sha256").update(content, "utf-8").digest("hex");
+}
+function verifyHookIntegrity(scriptPath) {
+  if (!existsSync14(scriptPath)) return false;
+  const onDisk = readFileSync12(scriptPath, "utf-8");
+  return sha256(onDisk) === sha256(getHookScript());
+}
 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 || join10(homedir7(), "AppData", "Local");
+    return existsSync14(join10(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 = join10(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 = join10(workspaceRoot, ".cursor");
+  if (!existsSync14(dir)) mkdirSync5(dir, { recursive: true });
+  writeFileSync7(join10(dir, "hooks.json"), JSON.stringify(data, null, 2) + "\n");
 }
 function hasOurHook(hooks) {
   const entries = hooks.hooks?.preToolUse ?? [];
@@ -6462,24 +5815,24 @@ function removeOurHook(hooks) {
   return hooks;
 }
 function ensureGitignore(workspaceRoot) {
-  const gitignorePath = join8(workspaceRoot, ".gitignore");
+  const gitignorePath = join10(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
 ${entry}
 `);
   } else {
-    writeFileSync6(gitignorePath, `# Liminal compression cache
+    writeFileSync7(gitignorePath, `# Liminal compression cache
 ${entry}
 `);
   }
 }
 function rmdirIfEmpty(dir) {
   try {
-    if (existsSync13(dir) && readdirSync(dir).length === 0) {
+    if (existsSync14(dir) && readdirSync2(dir).length === 0) {
       rmdirSync(dir);
     }
   } catch {
@@ -6502,20 +5855,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 = join10(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 = join10(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(join10(workspaceRoot, ".cursor", "hooks"));
     console.log();
     console.log(success("Hooks removed. Reload Cursor to deactivate."));
     console.log();
@@ -6530,6 +5883,11 @@ async function setupCursorCommand(flags) {
   }
   console.log(success("Cursor found"));
   console.log();
+  const existingScript = join10(workspaceRoot, ".cursor", "hooks", HOOK_SCRIPT_NAME);
+  if (existsSync14(existingScript) && !verifyHookIntegrity(existingScript)) {
+    console.log(warn(`Existing hook script has been modified externally \u2014 it will be overwritten`));
+    console.log();
+  }
   console.log(`  ${c.dim}[2/4]${c.reset} Checking Liminal configuration...`);
   if (!isConfigured()) {
     console.error(error("Liminal is not configured", `Run ${c.bold}liminal init${c.reset}${c.dim} first`));
@@ -6538,11 +5896,15 @@ 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);
-  writeFileSync6(scriptPath, getHookScript(), { mode: 493 });
-  console.log(success(`Wrote .cursor/hooks/${HOOK_SCRIPT_NAME}`));
+  const hooksDir = join10(workspaceRoot, ".cursor", "hooks");
+  if (!existsSync14(hooksDir)) mkdirSync5(hooksDir, { recursive: true });
+  const scriptPath = join10(hooksDir, HOOK_SCRIPT_NAME);
+  writeFileSync7(scriptPath, getHookScript(), { mode: 493 });
+  if (!verifyHookIntegrity(scriptPath)) {
+    console.error(error("Hook script integrity check failed", "File may have been modified after write"));
+    process.exit(1);
+  }
+  console.log(success(`Wrote .cursor/hooks/${HOOK_SCRIPT_NAME}`, "integrity verified"));
   const hooks = readHooksJson(workspaceRoot);
   const updated = addOurHook(hooks);
   writeHooksJson(workspaceRoot, updated);
@@ -6569,8 +5931,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 join11 } from "path";
 async function statsCommand(flags) {
   if (!isConfigured()) {
     console.log(error(
@@ -6606,7 +5968,7 @@ async function statsCommand(flags) {
           agg.recordSkipped(s.connector, 0);
         }
       }
-      const cursorMetrics = parseCursorHookStats();
+      const cursorMetrics = parseCursorHookStats2();
       if (cursorMetrics) {
         agg.setCursorMetrics(cursorMetrics);
       }
@@ -6759,14 +6121,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 = join11(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 +6148,7 @@ function parseCursorHookStats() {
   }
   let cacheCount = 0;
   try {
-    cacheCount = countFilesRecursive(join9(process.cwd(), ".fabric", "cache"));
+    cacheCount = countFilesRecursive2(join11(process.cwd(), ".fabric", "cache"));
   } catch {
   }
   return {
@@ -6799,13 +6161,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(join11(dir, entry.name));
     } else {
       count++;
     }
@@ -6885,9 +6247,94 @@ function parseArgs(argv) {
   }
   return { command, flags };
 }
+function getCommandHelp(cmd) {
+  const helps = {
+    start: `
+  \${c.bold}liminal start\${c.reset} \u2014 Start the compression proxy
+
+  \${c.bold}Usage:\${c.reset}
+    liminal start [options]
+
+  \${c.bold}Options:\${c.reset}
+    -d, --daemon         Run in background (daemon mode)
+    --port PORT          Override proxy port (default: from config)
+    --upstream URL       Override upstream API base URL
+
+  \${c.bold}Examples:\${c.reset}
+    \${c.dim}$\${c.reset} liminal start                 \${c.dim}# Foreground mode\${c.reset}
+    \${c.dim}$\${c.reset} liminal start -d               \${c.dim}# Background daemon\${c.reset}
+    \${c.dim}$\${c.reset} liminal start --port 3142       \${c.dim}# Custom port\${c.reset}
+`,
+    stop: `
+  \${c.bold}liminal stop\${c.reset} \u2014 Stop the running proxy
+
+  \${c.bold}Usage:\${c.reset}
+    liminal stop
+`,
+    status: `
+  \${c.bold}liminal status\${c.reset} \u2014 Show proxy health check
+
+  \${c.bold}Usage:\${c.reset}
+    liminal status
+`,
+    stats: `
+  \${c.bold}liminal stats\${c.reset} \u2014 Compression metrics & savings
+
+  \${c.bold}Usage:\${c.reset}
+    liminal stats [options]
+
+  \${c.bold}Options:\${c.reset}
+    --json               Output as JSON
+`,
+    config: `
+  \${c.bold}liminal config\${c.reset} \u2014 View or edit configuration
+
+  \${c.bold}Usage:\${c.reset}
+    liminal config                  \${c.dim}# Show all config\${c.reset}
+    liminal config --get KEY        \${c.dim}# Get a specific value\${c.reset}
+    liminal config --set KEY=VALUE  \${c.dim}# Set a value\${c.reset}
+`,
+    logs: `
+  \${c.bold}liminal logs\${c.reset} \u2014 View proxy logs
+
+  \${c.bold}Usage:\${c.reset}
+    liminal logs [options]
+
+  \${c.bold}Options:\${c.reset}
+    --follow, -f         Follow log output (tail -f style)
+    --lines N            Number of lines to show (default: 50)
+`,
+    init: `
+  \${c.bold}liminal init\${c.reset} \u2014 Set up Liminal (login, config)
+
+  \${c.bold}Usage:\${c.reset}
+    liminal init
+`,
+    login: `
+  \${c.bold}liminal login\${c.reset} \u2014 Log in or create an account
+
+  \${c.bold}Usage:\${c.reset}
+    liminal login
+`,
+    logout: `
+  \${c.bold}liminal logout\${c.reset} \u2014 Log out of your account
+
+  \${c.bold}Usage:\${c.reset}
+    liminal logout
+`
+  };
+  return helps[cmd] ?? null;
+}
 async function main() {
   const { command, flags } = parseArgs(process.argv);
   if (flags.has("h") || flags.has("help") || command === "help" || command === "--help" || command === "-h") {
+    if (command && command !== "help" && command !== "--help" && command !== "-h") {
+      const helpText = getCommandHelp(command);
+      if (helpText) {
+        console.log(helpText);
+        process.exit(0);
+      }
+    }
     console.log(usage());
     process.exit(0);
   }
@@ -6974,4 +6421,3 @@ async function main() {
   }
 }
 main();
-//# sourceMappingURL=bin.js.map