squeezr-ai 1.17.4 → 1.17.6

package/README.md

@@ -174,7 +174,7 @@ Squeezr uses cheap/free models for AI compression (the deterministic layer is pu
 ## CLI commands
 
 ```bash
-squeezr setup      # configure env vars, auto-start, CA trust
+squeezr setup      # configure env vars, auto-start, CA trust, install MCP server
 squeezr start      # start the proxy (auto-restarts if version mismatch after update)
 squeezr update     # kill old processes, install latest from npm, restart
 squeezr stop       # stop the proxy
@@ -184,10 +184,28 @@ squeezr config     # print current config
 squeezr ports      # change HTTP and MITM proxy ports
 squeezr gain       # estimate token savings for a directory
 squeezr discover   # detect which AI CLIs are installed
+squeezr mcp install    # register MCP server in Claude Code, Cursor, Windsurf, Cline
+squeezr mcp uninstall  # remove MCP server registration
 squeezr uninstall  # remove Squeezr completely (env vars, CA, auto-start, logs)
 squeezr version    # print version
 ```
 
+## MCP server
+
+Squeezr ships with a built-in MCP server (`squeezr-mcp`) that gives any MCP-capable AI CLI real-time awareness of Squeezr's state and control over it.
+
+**Installed automatically** by `squeezr setup` into Claude Code, Cursor, Windsurf, and Cline.
+
+Available MCP tools:
+
+| Tool | Description |
+|---|---|
+| `squeezr_status` | Is proxy running? Version, port, uptime, mode |
+| `squeezr_stats` | Token savings, compression %, cost saved, per-tool breakdown |
+| `squeezr_set_mode` | Change compression mode instantly (soft / normal / aggressive / critical) |
+| `squeezr_config` | Current thresholds, keepRecent, cache sizes |
+| `squeezr_habits` | Detect wasteful patterns this session (duplicate reads, high Bash count, cache efficiency) |
+
 ## Requirements
 
 - Node.js 18+ (compatible with Node.js 24)

package/bin/squeezr.js

@@ -199,6 +199,8 @@ Usage:
   squeezr discover         Show pattern coverage report (proxy must be running)
   squeezr status           Check if proxy is running
   squeezr config           Print config file path and current settings
+  squeezr mcp install      Register Squeezr MCP server in Claude Code, Cursor, Windsurf & Cline
+  squeezr mcp uninstall    Remove Squeezr MCP registration
   squeezr ports            Change HTTP and MITM proxy ports
   squeezr tunnel           Expose proxy via Cloudflare Tunnel for Cursor IDE
   squeezr update           Kill old processes, install latest from npm, restart
@@ -391,6 +393,100 @@ function showConfig() {
   }
 }
 
+
+// ── squeezr mcp ───────────────────────────────────────────────────────────────
+
+async function mcpInstall() {
+  const mcpServerPath = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', 'dist', 'mcp.js')
+  const entry = {
+    type: 'stdio',
+    command: 'node',
+    args: [mcpServerPath],
+  }
+
+  const targets = [
+    {
+      name: 'Claude Code',
+      file: path.join(os.homedir(), '.claude.json'),
+      key: 'mcpServers',
+    },
+    {
+      name: 'Cursor',
+      file: path.join(os.homedir(), '.cursor', 'mcp.json'),
+      key: 'mcpServers',
+    },
+    {
+      name: 'Windsurf',
+      file: path.join(os.homedir(), '.codeium', 'windsurf', 'mcp_config.json'),
+      key: 'mcpServers',
+    },
+    {
+      name: 'Cline / Roo-Cline',
+      file: path.join(os.homedir(), '.vscode', 'extensions', 'mcp_settings.json'),
+      key: 'mcpServers',
+    },
+  ]
+
+  let installed = 0
+
+  for (const target of targets) {
+    try {
+      // Only install into configs that already exist (user has that tool)
+      if (!fs.existsSync(target.file) && target.name !== 'Claude Code') continue
+
+      let cfg = {}
+      if (fs.existsSync(target.file)) {
+        try { cfg = JSON.parse(fs.readFileSync(target.file, 'utf-8')) } catch { cfg = {} }
+      }
+      cfg[target.key] = cfg[target.key] || {}
+      cfg[target.key].squeezr = entry
+
+      const dir = path.dirname(target.file)
+      if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true })
+      fs.writeFileSync(target.file, JSON.stringify(cfg, null, 2))
+      console.log()
+      console.log('  ok ' + target.name + ': ' + target.file)
+    } catch (e) {
+      console.warn()
+      console.warn('  warn ' + target.name + ': ' + (e.message || e))
+  }
+
+  console.log()
+  console.log('MCP server registered in ' + installed + ' client(s).')
+  console.log('Server binary: ' + mcpServerPath)
+  console.log('')
+  console.log('Available tools in Claude/Codex/Cursor:')
+  console.log('  squeezr_status   — Check if Squeezr is running')
+  console.log('  squeezr_stats    — Real-time token savings')
+  console.log('  squeezr_set_mode — Change compression aggressiveness')
+  console.log('  squeezr_config   — Current configuration')
+  console.log('  squeezr_habits   — Wasteful pattern report')
+}
+
+async function mcpUninstall() {
+  const files = [
+    path.join(os.homedir(), '.claude.json'),
+    path.join(os.homedir(), '.cursor', 'mcp.json'),
+    path.join(os.homedir(), '.codeium', 'windsurf', 'mcp_config.json'),
+    path.join(os.homedir(), '.vscode', 'extensions', 'mcp_settings.json'),
+  ]
+  let removed = 0
+  for (const file of files) {
+    if (!fs.existsSync(file)) continue
+    try {
+      const cfg = JSON.parse(fs.readFileSync(file, 'utf-8'))
+      if (cfg.mcpServers?.squeezr) {
+        delete cfg.mcpServers.squeezr
+        fs.writeFileSync(file, JSON.stringify(cfg, null, 2))
+        console.log()
+        removed++
+      }
+    } catch { /* ignore */ }
+  }
+  if (removed === 0) console.log('Squeezr MCP not found in any config.')
+  else console.log()
+}
+
 // ── squeezr ports ─────────────────────────────────────────────────────────────
 
 async function configurePorts() {
@@ -1378,6 +1474,12 @@ switch (command) {
     showConfig()
     break
 
+  case 'mcp': {
+    const subCmd = args[0] ?? 'install'
+    if (subCmd === 'uninstall') await mcpUninstall()
+    else await mcpInstall()
+    break
+  }
   case 'version':
   case '--version':
   case '-v':

package/dist/__tests__/cursorMitm.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/cursorMitm.test.js

@@ -0,0 +1,313 @@
+import { describe, it, expect } from 'vitest';
+// We test the exported utility functions and the ConnectRPC/proto layer.
+// Since cursorMitm.ts has many private functions, we use a test helper approach
+// by importing the module and testing the public API + running integration checks.
+// For testing the proto encoder/decoder, we replicate the minimal logic here
+// since the functions are module-private. We'll also test the full flow.
+// ── ConnectRPC frame tests ───────────────────────────────────────────────────
+function buildConnectFrame(payload, flag = 0) {
+    const header = Buffer.alloc(5);
+    header[0] = flag;
+    header.writeUInt32BE(payload.length, 1);
+    return Buffer.concat([header, payload]);
+}
+function parseConnectFrame(buf) {
+    if (buf.length < 5)
+        return null;
+    const flag = buf[0];
+    const length = buf.readUInt32BE(1);
+    if (buf.length < 5 + length)
+        return null;
+    return { flag, payload: buf.subarray(5, 5 + length), total: 5 + length };
+}
+describe('ConnectRPC frame encoding', () => {
+    it('should round-trip a simple payload', () => {
+        const payload = Buffer.from('hello world');
+        const frame = buildConnectFrame(payload);
+        expect(frame.length).toBe(5 + payload.length);
+        expect(frame[0]).toBe(0); // uncompressed flag
+        const parsed = parseConnectFrame(frame);
+        expect(parsed).not.toBeNull();
+        expect(parsed.flag).toBe(0);
+        expect(parsed.payload.toString()).toBe('hello world');
+        expect(parsed.total).toBe(frame.length);
+    });
+    it('should handle gzip flag', () => {
+        const payload = Buffer.from('compressed data');
+        const frame = buildConnectFrame(payload, 1);
+        const parsed = parseConnectFrame(frame);
+        expect(parsed.flag).toBe(1);
+        expect(parsed.payload.toString()).toBe('compressed data');
+    });
+    it('should return null for incomplete frames', () => {
+        expect(parseConnectFrame(Buffer.alloc(3))).toBeNull();
+        // Header says 100 bytes but only 10 present
+        const incomplete = Buffer.alloc(15);
+        incomplete.writeUInt32BE(100, 1);
+        expect(parseConnectFrame(incomplete)).toBeNull();
+    });
+    it('should handle empty payload', () => {
+        const frame = buildConnectFrame(Buffer.alloc(0));
+        expect(frame.length).toBe(5);
+        const parsed = parseConnectFrame(frame);
+        expect(parsed.payload.length).toBe(0);
+    });
+    it('should handle large payloads', () => {
+        const payload = Buffer.alloc(65536, 0x42);
+        const frame = buildConnectFrame(payload);
+        const parsed = parseConnectFrame(frame);
+        expect(parsed.payload.length).toBe(65536);
+        expect(parsed.payload[0]).toBe(0x42);
+    });
+});
+// ── Protobuf varint tests ────────────────────────────────────────────────────
+function encodeVarint(value) {
+    const bytes = [];
+    while (value > 0x7F) {
+        bytes.push((value & 0x7F) | 0x80);
+        value >>>= 7;
+    }
+    bytes.push(value & 0x7F);
+    return Buffer.from(bytes);
+}
+function decodeVarint(buf, offset) {
+    let value = 0;
+    let shift = 0;
+    let bytesRead = 0;
+    while (offset + bytesRead < buf.length) {
+        const byte = buf[offset + bytesRead];
+        value |= (byte & 0x7F) << shift;
+        bytesRead++;
+        if ((byte & 0x80) === 0)
+            break;
+        shift += 7;
+    }
+    return { value, bytesRead };
+}
+describe('Protobuf varint encoding', () => {
+    it('should encode small numbers', () => {
+        expect(encodeVarint(0)).toEqual(Buffer.from([0]));
+        expect(encodeVarint(1)).toEqual(Buffer.from([1]));
+        expect(encodeVarint(127)).toEqual(Buffer.from([127]));
+    });
+    it('should encode multi-byte varints', () => {
+        expect(encodeVarint(128)).toEqual(Buffer.from([0x80, 0x01]));
+        expect(encodeVarint(300)).toEqual(Buffer.from([0xAC, 0x02]));
+    });
+    it('should round-trip varints', () => {
+        for (const val of [0, 1, 127, 128, 300, 16383, 16384, 65535]) {
+            const buf = encodeVarint(val);
+            const { value } = decodeVarint(buf, 0);
+            expect(value).toBe(val);
+        }
+    });
+});
+// ── Protobuf message building/parsing ────────────────────────────────────────
+function encodeTag(fieldNumber, wireType) {
+    return encodeVarint((fieldNumber << 3) | wireType);
+}
+function encodeLengthDelimited(fieldNumber, data) {
+    const tag = encodeTag(fieldNumber, 2);
+    const len = encodeVarint(data.length);
+    return Buffer.concat([tag, len, data]);
+}
+function encodeString(fieldNumber, str) {
+    return encodeLengthDelimited(fieldNumber, Buffer.from(str, 'utf-8'));
+}
+function encodeVarintField(fieldNumber, value) {
+    const tag = encodeTag(fieldNumber, 0);
+    const val = encodeVarint(value);
+    return Buffer.concat([tag, val]);
+}
+function parseProtoFields(buf) {
+    const fields = [];
+    let offset = 0;
+    while (offset < buf.length) {
+        const tagStart = offset;
+        const { value: tag, bytesRead: tagBytes } = decodeVarint(buf, offset);
+        offset += tagBytes;
+        const fieldNumber = tag >>> 3;
+        const wireType = tag & 0x07;
+        let fieldEnd = offset;
+        switch (wireType) {
+            case 0: {
+                while (fieldEnd < buf.length && (buf[fieldEnd] & 0x80) !== 0)
+                    fieldEnd++;
+                fieldEnd++;
+                break;
+            }
+            case 1: {
+                fieldEnd += 8;
+                break;
+            }
+            case 2: {
+                const { value: len, bytesRead: lenBytes } = decodeVarint(buf, offset);
+                fieldEnd = offset + lenBytes + len;
+                break;
+            }
+            case 5: {
+                fieldEnd += 4;
+                break;
+            }
+            default: fieldEnd = buf.length;
+        }
+        fields.push({ fieldNumber, wireType, data: buf.subarray(tagStart, fieldEnd) });
+        offset = fieldEnd;
+    }
+    return fields;
+}
+function extractPayload(rawField) {
+    let offset = 0;
+    while (offset < rawField.length && (rawField[offset] & 0x80) !== 0)
+        offset++;
+    offset++;
+    const { value: len, bytesRead } = decodeVarint(rawField, offset);
+    offset += bytesRead;
+    return rawField.subarray(offset, offset + len);
+}
+describe('Protobuf field encoding/parsing', () => {
+    it('should encode and parse a string field', () => {
+        const encoded = encodeString(2, 'Hello, world!');
+        const fields = parseProtoFields(encoded);
+        expect(fields.length).toBe(1);
+        expect(fields[0].fieldNumber).toBe(2);
+        expect(fields[0].wireType).toBe(2);
+        const payload = extractPayload(fields[0].data);
+        expect(payload.toString('utf-8')).toBe('Hello, world!');
+    });
+    it('should encode and parse a varint field', () => {
+        const encoded = encodeVarintField(1, 42);
+        const fields = parseProtoFields(encoded);
+        expect(fields.length).toBe(1);
+        expect(fields[0].fieldNumber).toBe(1);
+        expect(fields[0].wireType).toBe(0);
+    });
+    it('should encode and parse a ConversationMessage-like structure', () => {
+        // ConversationMessage: field 1 = role (varint), field 2 = text (string)
+        const msgPayload = Buffer.concat([
+            encodeVarintField(1, 1), // role = HUMAN
+            encodeString(2, 'What is 2+2?'),
+        ]);
+        const conversationField = encodeLengthDelimited(2, msgPayload);
+        const outerFields = parseProtoFields(conversationField);
+        expect(outerFields.length).toBe(1);
+        expect(outerFields[0].fieldNumber).toBe(2);
+        const innerPayload = extractPayload(outerFields[0].data);
+        const innerFields = parseProtoFields(innerPayload);
+        expect(innerFields.length).toBe(2);
+        expect(innerFields[0].fieldNumber).toBe(1); // role
+        expect(innerFields[1].fieldNumber).toBe(2); // text
+        const text = extractPayload(innerFields[1].data).toString('utf-8');
+        expect(text).toBe('What is 2+2?');
+    });
+    it('should handle a full GetChatRequest with multiple conversation messages', () => {
+        // Build a fake GetChatRequest:
+        // field 2 (conversation) repeated, field 5 (workspace_root_path)
+        const msg1 = encodeLengthDelimited(2, Buffer.concat([
+            encodeVarintField(1, 1),
+            encodeString(2, 'Please review my code'),
+        ]));
+        const msg2 = encodeLengthDelimited(2, Buffer.concat([
+            encodeVarintField(1, 2),
+            encodeString(2, 'Sure, I see several issues with your implementation...'),
+        ]));
+        const msg3 = encodeLengthDelimited(2, Buffer.concat([
+            encodeVarintField(1, 1),
+            encodeString(2, 'Can you fix them?'),
+        ]));
+        const workspacePath = encodeString(5, '/home/user/project');
+        const request = Buffer.concat([msg1, msg2, msg3, workspacePath]);
+        const fields = parseProtoFields(request);
+        // Should have 4 fields: 3 conversation + 1 workspace
+        expect(fields.length).toBe(4);
+        const conversationFields = fields.filter(f => f.fieldNumber === 2);
+        expect(conversationFields.length).toBe(3);
+        const otherFields = fields.filter(f => f.fieldNumber !== 2);
+        expect(otherFields.length).toBe(1);
+        expect(otherFields[0].fieldNumber).toBe(5);
+    });
+    it('should preserve round-trip of unknown fields', () => {
+        // Fields we don't know should survive parse → concat(data) unchanged
+        const msg1 = encodeLengthDelimited(2, Buffer.concat([
+            encodeVarintField(1, 1),
+            encodeString(2, 'hello'),
+        ]));
+        const unknownField1 = encodeString(7, 'some-request-id');
+        const unknownField2 = encodeVarintField(27, 1); // is_composer
+        const unknownField3 = encodeString(15, 'conv-id-123');
+        const original = Buffer.concat([msg1, unknownField1, unknownField2, unknownField3]);
+        const fields = parseProtoFields(original);
+        // Reconstructing from raw data should give same bytes
+        const reconstructed = Buffer.concat(fields.map(f => f.data));
+        expect(reconstructed).toEqual(original);
+    });
+});
+// ── Integration: ConnectRPC + Protobuf ───────────────────────────────────────
+describe('ConnectRPC + Protobuf integration', () => {
+    it('should encode a full request frame and parse it back', () => {
+        const msg1 = encodeLengthDelimited(2, Buffer.concat([
+            encodeVarintField(1, 1),
+            encodeString(2, 'User question'),
+        ]));
+        const msg2 = encodeLengthDelimited(2, Buffer.concat([
+            encodeVarintField(1, 2),
+            encodeString(2, 'AI response with lots of context and details'),
+        ]));
+        const requestPayload = Buffer.concat([msg1, msg2]);
+        const frame = buildConnectFrame(requestPayload);
+        // Parse frame
+        const parsed = parseConnectFrame(frame);
+        expect(parsed).not.toBeNull();
+        // Parse proto
+        const fields = parseProtoFields(parsed.payload);
+        expect(fields.filter(f => f.fieldNumber === 2).length).toBe(2);
+    });
+});
+// ── Deterministic compression ────────────────────────────────────────────────
+function deterministicCompress(text) {
+    let out = text;
+    out = out.replace(/\n{3,}/g, '\n\n');
+    out = out.replace(/[ \t]+$/gm, '');
+    const lines = out.split('\n');
+    const result = [];
+    let lastLine = '';
+    let repeatCount = 0;
+    for (const line of lines) {
+        if (line === lastLine && line.trim().length > 0) {
+            repeatCount++;
+        }
+        else {
+            if (repeatCount > 0) {
+                result.push(`  ... (repeated ${repeatCount}x)`);
+                repeatCount = 0;
+            }
+            result.push(line);
+            lastLine = line;
+        }
+    }
+    if (repeatCount > 0)
+        result.push(`  ... (repeated ${repeatCount}x)`);
+    return result.join('\n');
+}
+describe('Deterministic compression', () => {
+    it('should collapse blank lines', () => {
+        const input = 'a\n\n\n\n\nb';
+        expect(deterministicCompress(input)).toBe('a\n\nb');
+    });
+    it('should strip trailing whitespace', () => {
+        const input = 'hello   \nworld\t\t';
+        expect(deterministicCompress(input)).toBe('hello\nworld');
+    });
+    it('should collapse repeated lines', () => {
+        const input = 'error: connection failed\nerror: connection failed\nerror: connection failed\nok';
+        const result = deterministicCompress(input);
+        expect(result).toContain('error: connection failed');
+        expect(result).toContain('repeated 2x');
+        expect(result).toContain('ok');
+    });
+    it('should not collapse empty repeated lines', () => {
+        const input = 'a\n\n\nb';
+        const result = deterministicCompress(input);
+        expect(result).not.toContain('repeated');
+    });
+});

package/dist/compressor.js

@@ -4,6 +4,7 @@ import { CompressionCache } from './cache.js';
 import { preprocess, preprocessForTool, hitPattern } from './deterministic.js';
 import { storeOriginal } from './expand.js';
 import { hashText, getBlock, setBlock } from './sessionCache.js';
+import { effectiveThreshold, effectiveKeepRecent, aiEnabled } from './config.js';
 const COMPRESS_PROMPT = 'You are compressing a coding tool output to save tokens. ' +
     'Extract ONLY what is essential: errors, file paths, function names, ' +
     'test failures, key values, warnings. ' +
@@ -138,7 +139,7 @@ export async function compressAnthropicMessages(messages, apiKey, config, system
     if (config.disabled)
         return [messages, emptySavings()];
     const pressure = estimatePressure(messages, systemExtraChars);
-    const threshold = config.thresholdForPressure(pressure);
+    const threshold = effectiveThreshold(config, pressure);
     const { nameMap: toolIdMap, skipIds } = buildAnthropicToolIdMap(messages);
     const allResults = extractAnthropicToolResults(messages, toolIdMap)
         .filter(r => !skipIds.has(r.toolUseId) && !config.shouldSkipTool(r.tool));
@@ -199,7 +200,7 @@ export async function compressAnthropicMessages(messages, apiKey, config, system
         console.log(`[squeezr/det] Deterministic: -${detSaved.toLocaleString()} chars (~${tokens} tokens) across ${allResults.length} block(s)`);
     }
     // ── Step 2: AI compression for old blocks above threshold ─────────────────
-    const candidates = allResults.slice(0, Math.max(0, allResults.length - config.keepRecent));
+    const candidates = allResults.slice(0, Math.max(0, allResults.length - effectiveKeepRecent(config)));
     const toProcess = candidates.filter(c => c.text.length >= threshold && !dedupedSet.has(`${c.index}:${c.subIndex}`));
     if (toProcess.length === 0)
         return [msgs, emptySavings()];
@@ -217,7 +218,7 @@ export async function compressAnthropicMessages(messages, apiKey, config, system
         if (cached) {
             sessionHits.push({ index: c.index, subIndex: c.subIndex, tool: c.tool, block: cached });
         }
-        else if (c.index === lastMsgIdx && !config.aiSkipTools.has(c.tool.toLowerCase())) {
+        else if (aiEnabled() && c.index === lastMsgIdx && !config.aiSkipTools.has(c.tool.toLowerCase())) {
             // Only AI-compress genuinely new blocks (from the last user message).
             // Historical uncached blocks skip AI compression → prevents burst on first activation.
             toCompress.push(c);
@@ -284,7 +285,7 @@ export async function compressOpenAIMessages(messages, apiKey, config, isLocal =
     if (config.disabled)
         return [messages, emptySavings()];
     const pressure = estimatePressure(messages);
-    const threshold = config.thresholdForPressure(pressure);
+    const threshold = effectiveThreshold(config, pressure);
     const allResults = extractOpenAIToolResults(messages)
         .filter(r => !r.skip && !config.shouldSkipTool(r.tool));
     if (allResults.length === 0)
@@ -333,7 +334,7 @@ export async function compressOpenAIMessages(messages, apiKey, config, isLocal =
         console.log(`[squeezr/det/${tag}] Deterministic: -${detSaved.toLocaleString()} chars across ${allResults.length} block(s)`);
     }
     // Step 2: AI compression for old blocks above threshold
-    const candidates = allResults.slice(0, Math.max(0, allResults.length - config.keepRecent));
+    const candidates = allResults.slice(0, Math.max(0, allResults.length - effectiveKeepRecent(config)));
     const toProcess = candidates.filter(c => c.text.length >= threshold && !dedupedIndices.has(c.index));
     if (toProcess.length === 0)
         return [msgs, emptySavings()];
@@ -352,7 +353,7 @@ export async function compressOpenAIMessages(messages, apiKey, config, isLocal =
         if (cached) {
             sessionHits.push({ index: c.index, tool: c.tool, block: cached });
         }
-        else if (c.index > newStartIdx && !config.aiSkipTools.has(c.tool.toLowerCase())) {
+        else if (aiEnabled() && c.index > newStartIdx && !config.aiSkipTools.has(c.tool.toLowerCase())) {
             // Only AI-compress new tool results (after last assistant turn) — prevents burst on first activation.
             toCompress.push(c);
         }
@@ -390,7 +391,7 @@ export async function compressGeminiContents(contents, apiKey, config) {
     if (config.disabled)
         return [contents, emptySavings()];
     const pressure = estimatePressure(contents);
-    const threshold = config.thresholdForPressure(pressure);
+    const threshold = effectiveThreshold(config, pressure);
     const allResults = [];
     for (let i = 0; i < contents.length; i++) {
         if (contents[i].role !== 'user')
@@ -453,7 +454,7 @@ export async function compressGeminiContents(contents, apiKey, config) {
     if (detSaved > 0)
         console.log(`[squeezr/det/gemini] Deterministic: -${detSaved.toLocaleString()} chars across ${allResults.length} block(s)`);
     // Step 2: AI compression for old blocks above threshold
-    const candidates = allResults.slice(0, Math.max(0, allResults.length - config.keepRecent))
+    const candidates = allResults.slice(0, Math.max(0, allResults.length - effectiveKeepRecent(config)))
         .filter(c => c.text.length >= threshold && !geminiDedupedSet.has(`${c.index}:${c.subIndex}`));
     if (candidates.length === 0)
         return [cts, emptySavings()];
@@ -467,7 +468,7 @@ export async function compressGeminiContents(contents, apiKey, config) {
         const cached = getBlock(hashText(c.text));
         if (cached)
             sessionHits.push({ index: c.index, subIndex: c.subIndex, tool: c.tool, block: cached });
-        else
+        else if (aiEnabled())
             toCompress.push(c);
     }
     const freshlyCompressed = toCompress.length > 0

package/dist/config.d.ts

@@ -26,4 +26,19 @@ export declare class Config {
     shouldSkipTool(toolName: string): boolean;
     isLocalKey(key: string): boolean;
 }
+export type CompressionMode = 'soft' | 'normal' | 'aggressive' | 'critical';
+export interface RuntimeOverrides {
+    mode: CompressionMode;
+    threshold?: number;
+    keepRecent?: number;
+    aiEnabled?: boolean;
+}
+export declare const runtimeOverrides: RuntimeOverrides;
+export declare function applyMode(mode: CompressionMode): void;
+/** Effective threshold — runtime override wins over TOML adaptive threshold */
+export declare function effectiveThreshold(config: Config, pressure: number): number;
+/** Effective keepRecent — runtime override wins */
+export declare function effectiveKeepRecent(config: Config): number;
+/** Whether AI compression is enabled right now */
+export declare function aiEnabled(): boolean;
 export declare const config: Config;

package/dist/config.js

@@ -117,4 +117,30 @@ export class Config {
         return this.localDummyKeys.has(k) || (k.length > 0 && !k.startsWith('sk-') && !k.startsWith('aiza') && !k.startsWith('eyj'));
     }
 }
+const MODES = {
+    soft: { threshold: 3000, keepRecent: 10, aiEnabled: false },
+    normal: { threshold: 800, keepRecent: 3, aiEnabled: true },
+    aggressive: { threshold: 200, keepRecent: 1, aiEnabled: true },
+    critical: { threshold: 50, keepRecent: 0, aiEnabled: true },
+};
+export const runtimeOverrides = { mode: 'normal' };
+export function applyMode(mode) {
+    const preset = MODES[mode];
+    Object.assign(runtimeOverrides, { mode, ...preset });
+    console.log(`[squeezr] Mode → ${mode} (threshold=${preset.threshold}, keepRecent=${preset.keepRecent}, ai=${preset.aiEnabled})`);
+}
+/** Effective threshold — runtime override wins over TOML adaptive threshold */
+export function effectiveThreshold(config, pressure) {
+    if (runtimeOverrides.threshold !== undefined)
+        return runtimeOverrides.threshold;
+    return config.thresholdForPressure(pressure);
+}
+/** Effective keepRecent — runtime override wins */
+export function effectiveKeepRecent(config) {
+    return runtimeOverrides.keepRecent ?? config.keepRecent;
+}
+/** Whether AI compression is enabled right now */
+export function aiEnabled() {
+    return runtimeOverrides.aiEnabled ?? true;
+}
 export const config = new Config();

package/dist/cursorMitm.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Cursor Subscription MITM Proxy
+ *
+ * Intercepts Cursor IDE (Electron/Chromium) traffic to api2.cursor.sh,
+ * compresses the conversation context using Cursor's own models (cursor-small),
+ * and forwards the compressed request transparently.
+ *
+ * Protocol: ConnectRPC over HTTP/2 with binary Protobuf
+ * Target:   api2.cursor.sh/aiserver.v1.ChatService/StreamUnifiedChatWithTools
+ */
+export declare function getCursorStats(): {
+    requests: number;
+    compressed: number;
+    charsSaved: number;
+};
+export declare function getCursorMitmPort(): number;
+export declare function startCursorMitm(): Promise<void>;
+export declare function stopCursorMitm(): void;