squeezr-ai 1.46.2 → 1.80.6

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

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

package/dist/__tests__/aiRateLimit.test.js

@@ -0,0 +1,20 @@
+import { describe, it, expect } from 'vitest';
+import { tryConsumeAiCall, aiCallsRemaining, _config } from '../aiRateLimit.js';
+describe('aiRateLimit', () => {
+    it('allows up to MAX_CALLS_PER_WINDOW calls then blocks', () => {
+        // Fresh module state — consume the whole window
+        let allowed = 0;
+        for (let i = 0; i < _config.MAX_CALLS_PER_WINDOW + 10; i++) {
+            if (tryConsumeAiCall())
+                allowed++;
+        }
+        expect(allowed).toBe(_config.MAX_CALLS_PER_WINDOW);
+    });
+    it('reports 0 remaining once exhausted', () => {
+        // Window already exhausted by the previous test (same module instance)
+        expect(aiCallsRemaining()).toBe(0);
+    });
+    it('blocks further calls after exhaustion', () => {
+        expect(tryConsumeAiCall()).toBe(false);
+    });
+});

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

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

package/dist/__tests__/attachmentDedup.test.js

@@ -0,0 +1,89 @@
+/**
+ * Tests for v1.49.0 attachment/artifact dedup.
+ */
+import { describe, it, expect } from 'vitest';
+import { dedupAttachments } from '../attachmentDedup.js';
+describe('attachmentDedup', () => {
+    it('dedupes large repeated text blocks', () => {
+        const big = 'X'.repeat(800);
+        const messages = [
+            { role: 'user', content: [{ type: 'text', text: big }] },
+            { role: 'assistant', content: [{ type: 'text', text: 'ok' }] },
+            { role: 'user', content: [{ type: 'text', text: big }] },
+            { role: 'assistant', content: [{ type: 'text', text: 'live answer' }] },
+            { role: 'user', content: [{ type: 'text', text: 'live ask' }] },
+        ];
+        const r = dedupAttachments(messages);
+        expect(r.dedupCount).toBeGreaterThanOrEqual(1);
+        expect(r.savedChars).toBeGreaterThan(0);
+    });
+    it('never touches the last user message (live ask)', () => {
+        const big = 'Y'.repeat(800);
+        const messages = [
+            { role: 'user', content: [{ type: 'text', text: big }] },
+            { role: 'assistant', content: [{ type: 'text', text: 'ok' }] },
+            { role: 'user', content: [{ type: 'text', text: big }] }, // LAST user — should be preserved
+        ];
+        dedupAttachments(messages);
+        expect(messages[2].content[0].text).toBe(big);
+    });
+    it('never touches the last assistant message (live answer)', () => {
+        const big = 'Z'.repeat(800);
+        const messages = [
+            { role: 'assistant', content: [{ type: 'text', text: big }] },
+            { role: 'user', content: [{ type: 'text', text: 'x' }] },
+            { role: 'assistant', content: [{ type: 'text', text: big }] }, // LAST assistant — preserved
+            { role: 'user', content: [{ type: 'text', text: 'follow up' }] },
+        ];
+        dedupAttachments(messages);
+        expect(messages[2].content[0].text).toBe(big);
+    });
+    it('does not replace blocks below MIN_BLOCK_CHARS threshold', () => {
+        const small = 'hi';
+        const messages = [
+            { role: 'user', content: [{ type: 'text', text: small }] },
+            { role: 'assistant', content: [{ type: 'text', text: 'ack' }] },
+            { role: 'user', content: [{ type: 'text', text: small }] },
+            { role: 'user', content: [{ type: 'text', text: 'live' }] },
+        ];
+        const r = dedupAttachments(messages);
+        expect(r.dedupCount).toBe(0);
+    });
+    it('never touches tool_use or tool_result blocks', () => {
+        const big = 'W'.repeat(800);
+        const messages = [
+            { role: 'assistant', content: [{ type: 'tool_use', id: 't1', name: 'Read', input: { file_path: '/x' } }] },
+            { role: 'user', content: [{ type: 'tool_result', tool_use_id: 't1', content: big }] },
+            { role: 'assistant', content: [{ type: 'tool_use', id: 't2', name: 'Read', input: { file_path: '/x' } }] },
+            { role: 'user', content: [{ type: 'tool_result', tool_use_id: 't2', content: big }] },
+            { role: 'user', content: [{ type: 'text', text: 'live ask' }] },
+        ];
+        dedupAttachments(messages);
+        expect(messages[1].content[0].type).toBe('tool_result');
+        expect(messages[3].content[0].type).toBe('tool_result');
+        expect(messages[1].content[0].content).toBe(big);
+    });
+    it('keeps single-occurrence text blocks untouched', () => {
+        const messages = [
+            { role: 'user', content: [{ type: 'text', text: 'A'.repeat(800) }] },
+            { role: 'assistant', content: [{ type: 'text', text: 'B'.repeat(800) }] },
+            { role: 'user', content: [{ type: 'text', text: 'live' }] },
+        ];
+        const r = dedupAttachments(messages);
+        expect(r.dedupCount).toBe(0);
+        expect(messages[0].content[0].text).toBe('A'.repeat(800));
+        expect(messages[1].content[0].text).toBe('B'.repeat(800));
+    });
+    it('produces non-empty placeholder text (never empty content)', () => {
+        const big = 'D'.repeat(800);
+        const messages = [
+            { role: 'user', content: [{ type: 'text', text: big }] },
+            { role: 'assistant', content: [{ type: 'text', text: 'ok' }] },
+            { role: 'user', content: [{ type: 'text', text: big }] },
+            { role: 'user', content: [{ type: 'text', text: 'live' }] },
+        ];
+        dedupAttachments(messages);
+        expect(typeof messages[0].content[0].text).toBe('string');
+        expect(messages[0].content[0].text.length).toBeGreaterThan(20);
+    });
+});

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

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

package/dist/__tests__/compressibilityProbe.test.js

@@ -0,0 +1,45 @@
+import { describe, it, expect } from 'vitest';
+import { looksIncompressible, deflateRatio } from '../compressibilityProbe.js';
+// Calibrated against real Zest output (see compressibilityProbe.ts):
+//   verbose log w/ repeated lines → deflate ~0.17 → Zest saved 56% → KEEP
+//   dense error/path list        → deflate ~0.76 → Zest saved  0% → SKIP
+//   test output (mixed)          → deflate ~0.63 → Zest saved  5% → SKIP
+const VERBOSE = ('npm warn deprecated foo@1.0.0: use bar\n' +
+    'npm warn deprecated foo@1.0.0: use bar\n' +
+    'npm warn deprecated baz@2.0.0: no longer maintained\n' +
+    'added 1242 packages, and audited 1243 packages in 14s\n' +
+    '201 packages are looking for funding\n' +
+    '  run `npm fund` for details\n' +
+    'found 0 vulnerabilities\n' +
+    'gardening node_modules ... done\n' +
+    'gardening node_modules ... done\n' +
+    'gardening node_modules ... done').repeat(3);
+const DENSE_PATHS = ('src/compressor.ts:268 error TS2322: Type string is not assignable\n' +
+    'src/dashboard.ts:1027 warning unused var aiSavedTok\n' +
+    'src/server.ts:956 note: see https://docs.foo.com/E1234 for details\n' +
+    'src/stats.ts:361 error ENOENT no such file\n' +
+    'src/cache.ts:42 error TS2304: cannot find name foo\n' +
+    'src/expand.ts:88 warning deprecated symbol bar used here\n' +
+    'src/index.ts:12 error TS1005: semicolon expected near token');
+describe('looksIncompressible', () => {
+    it('keeps redundant/verbose blocks (AI will compress them well)', () => {
+        expect(looksIncompressible(VERBOSE)).toBe(false);
+    });
+    it('skips dense path/error dumps (AI would be rejected — wasted call)', () => {
+        expect(looksIncompressible(DENSE_PATHS)).toBe(true);
+    });
+    it('does not probe tiny blocks (deflate ratio is noisy there)', () => {
+        expect(looksIncompressible('error: ENOENT')).toBe(false);
+    });
+    it('respects a custom maxDeflate threshold', () => {
+        // VERBOSE deflates to ~0.17; a 0.1 threshold flips it to "incompressible".
+        expect(looksIncompressible(VERBOSE, 0.1)).toBe(true);
+    });
+    it('deflateRatio is in (0,1] and lower for redundant text', () => {
+        const rVerbose = deflateRatio(VERBOSE);
+        const rDense = deflateRatio(DENSE_PATHS);
+        expect(rVerbose).toBeGreaterThan(0);
+        expect(rVerbose).toBeLessThan(rDense);
+        expect(rDense).toBeLessThanOrEqual(1);
+    });
+});

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

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

package/dist/__tests__/compressionGuard.test.js

@@ -0,0 +1,57 @@
+import { describe, it, expect } from 'vitest';
+import { validateCompression } from '../compressionGuard.js';
+describe('validateCompression', () => {
+    it('accepts a good compression that keeps key tokens and saves enough', () => {
+        const original = 'Running tests in src/auth/login.ts\n' +
+            'PASS 42 tests, FAIL 1: expected 200 got 401 at line 88\n' +
+            'See https://example.com/docs/errors for details\n' +
+            'lots of incidental filler text repeated over and over to pad the block length so the ratio is meaningful '.repeat(8);
+        const compressed = 'FAIL src/auth/login.ts line 88: expected 200 got 401. See https://example.com/docs/errors';
+        const r = validateCompression(original, compressed);
+        expect(r.accept).toBe(true);
+        expect(r.ratio).toBeGreaterThan(0.15);
+    });
+    it('rejects when the result is LONGER than the original (negative savings)', () => {
+        const original = 'short output';
+        const compressed = 'this compressed result is actually much longer than the original input text';
+        const r = validateCompression(original, compressed);
+        expect(r.accept).toBe(false);
+        expect(r.reason).toMatch(/ratio/);
+    });
+    it('rejects empty output', () => {
+        const r = validateCompression('some real content '.repeat(20), '   ');
+        expect(r.accept).toBe(false);
+        expect(r.reason).toBe('empty output');
+    });
+    it('rejects when a critical file path is dropped', () => {
+        const original = 'Error in src/payments/checkout.ts at line 12\n' +
+            'stack trace filler '.repeat(40);
+        const compressed = 'Error at line 12'; // dropped the path
+        const r = validateCompression(original, compressed);
+        expect(r.accept).toBe(false);
+        expect(r.reason).toMatch(/critical token/);
+    });
+    it('rejects when an error code is dropped', () => {
+        const original = 'connection failed ECONNREFUSED on attempt 3\n' + 'retry filler '.repeat(40);
+        const compressed = 'connection failed on attempt 3'; // dropped ECONNREFUSED
+        const r = validateCompression(original, compressed);
+        expect(r.accept).toBe(false);
+        expect(r.reason).toMatch(/critical token/);
+    });
+    it('rejects when an URL is dropped', () => {
+        const original = 'fetch https://api.service.com/v2/users returned 500\n' + 'body filler '.repeat(40);
+        const compressed = 'fetch returned 500'; // dropped URL (and 500 is HTTP code, also hard)
+        const r = validateCompression(original, compressed);
+        expect(r.accept).toBe(false);
+    });
+    it('tolerates dropping a few incidental soft tokens', () => {
+        const original = 'function computeTotals iterates items and calls helperOne helperTwo helperThree\n' +
+            'verbose explanation filler text '.repeat(30);
+        // keeps the main identifier, drops a couple of minor helpers — within tolerance
+        const compressed = 'computeTotals iterates items, calls helpers';
+        const r = validateCompression(original, compressed, { minRatio: 0.1 });
+        // soft tolerance is small, so this MAY reject; assert the function runs and returns a ratio
+        expect(typeof r.accept).toBe('boolean');
+        expect(r.ratio).toBeGreaterThan(0);
+    });
+});

package/dist/__tests__/compressor.test.js

@@ -3,24 +3,36 @@ import { clearExpandStore } from '../expand.js';
 import { clearSessionCache } from '../sessionCache.js';
 // Mock AI SDKs before importing compressor
 vi.mock('@anthropic-ai/sdk', () => ({
-    default: vi.fn().mockImplementation(() => ({
-        messages: {
-            create: vi.fn().mockResolvedValue({
-                content: [{ text: 'AI compressed summary' }],
-            }),
-        },
-    })),
-}));
-vi.mock('openai', () => ({
-    default: vi.fn().mockImplementation(() => ({
-        chat: {
-            completions: {
+    // function (not arrow) — `new Anthropic()` requires a constructable implementation
+    default: vi.fn().mockImplementation(function () {
+        return {
+            messages: {
                 create: vi.fn().mockResolvedValue({
-                    choices: [{ message: { content: 'AI compressed summary' } }],
+                    content: [{ text: 'AI compressed summary' }],
                 }),
             },
-        },
-    })),
+        };
+    }),
+}));
+vi.mock('openai', () => ({
+    default: vi.fn().mockImplementation(function () {
+        return {
+            chat: {
+                completions: {
+                    create: vi.fn().mockResolvedValue({
+                        choices: [{ message: { content: 'AI compressed summary' } }],
+                    }),
+                },
+            },
+        };
+    }),
+}));
+// Force the AI compression master toggle ON for these tests (production default
+// is off + persisted to disk; tests must not depend on the user's local state).
+vi.mock('../aiToggle.js', () => ({
+    isAiCompressionEnabled: () => true,
+    setAiCompression: () => { },
+    toggleAiCompression: () => true,
 }));
 // Mock fetch for Gemini
 const mockFetch = vi.fn().mockResolvedValue({
@@ -50,6 +62,11 @@ const baseConfig = {
     shouldSkipTool: () => false,
     skipTools: new Set(),
     onlyTools: new Set(),
+    aiSkipTools: new Set(),
+    aiCompression: true, // tests exercise the AI path; production default is false
+    compressConversation: false,
+    keepRecentAssistant: 3,
+    assistantThreshold: 300,
 };
 beforeEach(() => {
     clearExpandStore();
@@ -89,9 +106,8 @@ describe('compressAnthropicMessages', () => {
         expect(block.content).not.toContain('[squeezr:');
     });
     it('compresses old blocks beyond keepRecent', async () => {
-        const longText = 'x'.repeat(200);
-        // 2 messages: first is old, second is recent
-        const msgs = makeMessages([longText, longText]);
+        // distinct texts — identical blocks would be collapsed by cross-turn dedup first
+        const msgs = makeMessages(['x'.repeat(1600), 'y'.repeat(1600)]);
         const [result, savings] = await compressAnthropicMessages(msgs, 'key', baseConfig);
         // First block should be compressed
         const firstBlock = result[1].content[0];
@@ -99,8 +115,7 @@ describe('compressAnthropicMessages', () => {
         expect(savings.compressed).toBe(1);
     });
     it('embeds squeezr ID and ratio in compressed content', async () => {
-        const longText = 'x'.repeat(200);
-        const msgs = makeMessages([longText, longText]);
+        const msgs = makeMessages(['x'.repeat(1600), 'y'.repeat(1600)]);
         const [result] = await compressAnthropicMessages(msgs, 'key', baseConfig);
         const compressed = result[1].content[0].content;
         expect(compressed).toMatch(/\[squeezr:[a-f0-9]{6} -\d+%\]/);
@@ -112,8 +127,7 @@ describe('compressAnthropicMessages', () => {
         expect(savings.compressed).toBe(0);
     });
     it('returns dry-run savings without modifying messages', async () => {
-        const longText = 'x'.repeat(200);
-        const msgs = makeMessages([longText, longText]);
+        const msgs = makeMessages(['x'.repeat(1600), 'y'.repeat(1600)]);
         const [result, savings] = await compressAnthropicMessages(msgs, 'key', { ...baseConfig, dryRun: true });
         expect(savings.dryRun).toBe(true);
         // Messages should not be modified
@@ -122,8 +136,7 @@ describe('compressAnthropicMessages', () => {
     });
     it('uses session cache on second call with same content', async () => {
         const Anthropic = (await import('@anthropic-ai/sdk')).default;
-        const longText = 'x'.repeat(200);
-        const msgs = makeMessages([longText, longText]);
+        const msgs = makeMessages(['x'.repeat(200), 'y'.repeat(200)]);
         // First call — compresses
         await compressAnthropicMessages(msgs, 'key', baseConfig);
         const callsAfterFirst = Anthropic.mock.results[0]?.value?.messages?.create?.mock?.calls?.length ?? 0;
@@ -143,13 +156,56 @@ describe('compressAnthropicMessages', () => {
         expect(content).not.toContain('context4');
     });
     it('tracks savings correctly', async () => {
-        const longText = 'x'.repeat(500);
-        const msgs = makeMessages([longText, longText]);
+        const msgs = makeMessages(['x'.repeat(1600), 'y'.repeat(1600)]);
         const [, savings] = await compressAnthropicMessages(msgs, 'key', baseConfig);
         expect(savings.savedChars).toBeGreaterThan(0);
         expect(savings.originalChars).toBeGreaterThan(0);
         expect(savings.byTool.length).toBeGreaterThan(0);
     });
+    it('NEVER AI-compresses tool results at or before the cache_control barrier', async () => {
+        // AI compression is not byte-stable → would invalidate the prompt cache.
+        // A block under (or before) the last cache_control marker must never get an
+        // [squeezr:ID] AI placeholder. Deterministic cleanup MAY touch it (it's stable).
+        const oldText = 'old line\n'.repeat(50); // compressible (dup lines) but cached
+        const newText = 'new line\n'.repeat(50);
+        const msgs = [
+            { role: 'assistant', content: [{ type: 'tool_use', id: 't0', name: 'Bash' }] },
+            { role: 'user', content: [{ type: 'tool_result', tool_use_id: 't0', content: oldText, cache_control: { type: 'ephemeral' } }] },
+            { role: 'assistant', content: [{ type: 'tool_use', id: 't1', name: 'Bash' }] },
+            { role: 'user', content: [{ type: 'tool_result', tool_use_id: 't1', content: newText }] },
+        ];
+        const [result, savings] = await compressAnthropicMessages(msgs, 'key', baseConfig);
+        // Cached block must NOT have an AI placeholder, and cache_control must survive.
+        expect(String(result[1].content[0].content)).not.toContain('[squeezr:');
+        expect(result[1].content[0].cache_control).toEqual({ type: 'ephemeral' });
+        // AI compression count is 0 here: the only old block is the cached one (skipped),
+        // the new block is within keepRecent.
+        expect(savings.compressed).toBe(0);
+    });
+    it('deterministic cleanup IS allowed on the cached prefix (it is byte-stable)', async () => {
+        // A block with duplicate lines under cache_control: det dedup may shrink it,
+        // but the result is identical every request → cache stays valid.
+        const dupText = 'same\n'.repeat(60); // dedup-able by deterministic pass
+        const msgs = [
+            { role: 'assistant', content: [{ type: 'tool_use', id: 't0', name: 'Bash' }] },
+            { role: 'user', content: [{ type: 'tool_result', tool_use_id: 't0', content: dupText, cache_control: { type: 'ephemeral' } }] },
+            { role: 'assistant', content: [{ type: 'tool_use', id: 't1', name: 'Bash' }] },
+            { role: 'user', content: [{ type: 'tool_result', tool_use_id: 't1', content: 'tail\n'.repeat(60) }] },
+        ];
+        // Run twice — the cached block's output must be byte-identical (stable).
+        const [r1] = await compressAnthropicMessages(msgs, 'key', baseConfig);
+        const [r2] = await compressAnthropicMessages(msgs, 'key', baseConfig);
+        const out1 = String(r1[1].content[0].content);
+        const out2 = String(r2[1].content[0].content);
+        expect(out1).toBe(out2); // stable between requests → cache-safe
+        expect(r1[1].content[0].cache_control).toEqual({ type: 'ephemeral' });
+    });
+    it('compresses freely when there is no cache_control marker', async () => {
+        const msgs = makeMessages(['x'.repeat(1600), 'y'.repeat(1600)]);
+        const [, savings] = await compressAnthropicMessages(msgs, 'key', baseConfig);
+        // No barrier → old block is eligible for AI compression
+        expect(savings.compressed).toBe(1);
+    });
 });
 // ── OpenAI format ─────────────────────────────────────────────────────────────
 describe('compressOpenAIMessages', () => {
@@ -172,16 +228,14 @@ describe('compressOpenAIMessages', () => {
         expect(result).toEqual(msgs);
     });
     it('compresses old tool messages', async () => {
-        const longText = 'y'.repeat(200);
-        const msgs = makeMessages([longText, longText]);
+        const msgs = makeMessages(['y'.repeat(200), 'w'.repeat(200)]);
         const [result, savings] = await compressOpenAIMessages(msgs, 'key', baseConfig);
         expect(result[1].content).toContain('[squeezr:');
         expect(savings.compressed).toBe(1);
     });
     it('uses Ollama backend for local keys', async () => {
         const OpenAI = (await import('openai')).default;
-        const longText = 'z'.repeat(200);
-        const msgs = makeMessages([longText, longText]);
+        const msgs = makeMessages(['z'.repeat(200), 'v'.repeat(200)]);
         await compressOpenAIMessages(msgs, 'ollama-key', { ...baseConfig, isLocalKey: () => true }, true);
         // OpenAI client should be called (Ollama uses OpenAI-compatible API)
         expect(OpenAI).toHaveBeenCalled();
@@ -194,11 +248,11 @@ describe('compressOpenAIMessages', () => {
         expect(result).toBeDefined();
     });
     it('returns dry-run without modifications', async () => {
-        const longText = 'z'.repeat(200);
-        const msgs = makeMessages([longText, longText]);
+        const oldText = 'z'.repeat(200);
+        const msgs = makeMessages([oldText, 'v'.repeat(200)]);
         const [result, savings] = await compressOpenAIMessages(msgs, 'key', { ...baseConfig, dryRun: true });
         expect(savings.dryRun).toBe(true);
-        expect(result[1].content).toBe(longText);
+        expect(result[1].content).toBe(oldText);
     });
 });
 // ── Gemini format ─────────────────────────────────────────────────────────────
@@ -220,76 +274,75 @@ describe('compressGeminiContents', () => {
         expect(result).toEqual(cts);
     });
     it('compresses old function responses', async () => {
-        const longText = 'g'.repeat(200);
-        const cts = makeContents([longText, longText]);
+        const cts = makeContents(['g'.repeat(200), 'h'.repeat(200)]);
         const [result, savings] = await compressGeminiContents(cts, 'key', baseConfig);
         const response = result[1].parts[0].functionResponse.response;
         expect(JSON.stringify(response)).toContain('[squeezr:');
         expect(savings.compressed).toBe(1);
     });
     it('uses fetch with Gemini API URL', async () => {
-        const longText = 'g'.repeat(200);
-        const cts = makeContents([longText, longText]);
+        const cts = makeContents(['g'.repeat(200), 'h'.repeat(200)]);
         await compressGeminiContents(cts, 'my-google-key', baseConfig);
         expect(mockFetch).toHaveBeenCalledWith(expect.stringContaining('generativelanguage.googleapis.com'), expect.any(Object));
         expect(mockFetch).toHaveBeenCalledWith(expect.stringContaining('my-google-key'), expect.any(Object));
     });
     it('returns dry-run without modifications', async () => {
-        const longText = 'g'.repeat(200);
-        const cts = makeContents([longText, longText]);
+        const oldText = 'g'.repeat(200);
+        const cts = makeContents([oldText, 'h'.repeat(200)]);
         const [result, savings] = await compressGeminiContents(cts, 'key', { ...baseConfig, dryRun: true });
         expect(savings.dryRun).toBe(true);
         const response = result[1].parts[0].functionResponse.response;
-        expect(response).toBe(longText);
+        expect(response).toBe(oldText);
     });
 });
 // ── skip_tools / only_tools / squeezr:skip ────────────────────────────────────
 describe('skip_tools and squeezr:skip', () => {
-    function makeMessages(toolName, text) {
+    // Per-block texts — identical blocks would be collapsed by cross-turn dedup
+    function makeMessages(toolName, textOld, textRecent) {
         return [
             { role: 'assistant', content: [{ type: 'tool_use', id: 'tool_0', name: toolName }] },
-            { role: 'user', content: [{ type: 'tool_result', tool_use_id: 'tool_0', content: text }] },
+            { role: 'user', content: [{ type: 'tool_result', tool_use_id: 'tool_0', content: textOld }] },
             { role: 'assistant', content: [{ type: 'tool_use', id: 'tool_1', name: toolName }] },
-            { role: 'user', content: [{ type: 'tool_result', tool_use_id: 'tool_1', content: text }] },
+            { role: 'user', content: [{ type: 'tool_result', tool_use_id: 'tool_1', content: textRecent }] },
         ];
     }
     it('skips tool when shouldSkipTool returns true', async () => {
         const longText = 'x'.repeat(200);
-        const msgs = makeMessages('Read', longText);
+        const msgs = makeMessages('Read', longText, 'y'.repeat(200));
         const skipConfig = { ...baseConfig, shouldSkipTool: (t) => t.toLowerCase() === 'read' };
         const [result, savings] = await compressAnthropicMessages(msgs, 'key', skipConfig);
         expect(savings.compressed).toBe(0);
         expect(result[1].content[0].content).toBe(longText);
     });
     it('compresses tool when shouldSkipTool returns false', async () => {
-        const longText = 'x'.repeat(200);
-        const msgs = makeMessages('Bash', longText);
+        const msgs = makeMessages('Bash', 'x'.repeat(1600), 'y'.repeat(1600));
         const [, savings] = await compressAnthropicMessages(msgs, 'key', baseConfig);
         expect(savings.compressed).toBe(1);
     });
     it('respects squeezr:skip inline marker — does not compress that block', async () => {
-        const longText = 'x'.repeat(200);
+        // Unique text per block — identical blocks would be collapsed by cross-turn dedup
+        const skipText = 'x'.repeat(1600);
         // 3 tool calls: tool_0 (skip marker), tool_1 (old, compressible), tool_2 (recent, kept)
         const msgs = [
             {
                 role: 'assistant',
                 content: [{ type: 'tool_use', id: 'tool_0', name: 'Bash', input: { command: 'git diff HEAD~3  # squeezr:skip' } }],
             },
-            { role: 'user', content: [{ type: 'tool_result', tool_use_id: 'tool_0', content: longText }] },
+            { role: 'user', content: [{ type: 'tool_result', tool_use_id: 'tool_0', content: skipText }] },
             {
                 role: 'assistant',
                 content: [{ type: 'tool_use', id: 'tool_1', name: 'Bash', input: { command: 'some other command' } }],
             },
-            { role: 'user', content: [{ type: 'tool_result', tool_use_id: 'tool_1', content: longText }] },
+            { role: 'user', content: [{ type: 'tool_result', tool_use_id: 'tool_1', content: 'y'.repeat(1600) }] },
             {
                 role: 'assistant',
                 content: [{ type: 'tool_use', id: 'tool_2', name: 'Bash', input: { command: 'another command' } }],
             },
-            { role: 'user', content: [{ type: 'tool_result', tool_use_id: 'tool_2', content: longText }] },
+            { role: 'user', content: [{ type: 'tool_result', tool_use_id: 'tool_2', content: 'z'.repeat(1600) }] },
         ];
         const [result, savings] = await compressAnthropicMessages(msgs, 'key', baseConfig);
         // tool_0 has squeezr:skip → not compressed
-        expect(result[1].content[0].content).toBe(longText);
+        expect(result[1].content[0].content).toBe(skipText);
         // tool_1 is old and not skipped → compressed
         expect(savings.compressed).toBe(1);
     });

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

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

package/dist/__tests__/diffRead.test.js

@@ -0,0 +1,83 @@
+import { describe, it, expect } from 'vitest';
+import { compressRepeatedReads } from '../diffRead.js';
+describe('diffRead', () => {
+    it('collapses two Reads of same path with small diff', () => {
+        const fileV1 = Array.from({ length: 100 }, (_, i) => `line ${i}`).join('\n');
+        const fileV2 = fileV1.replace('line 5', 'line 5 modified');
+        const messages = [
+            { role: 'assistant', content: [{ type: 'tool_use', id: 't1', name: 'Read', input: { file_path: '/foo.py' } }] },
+            { role: 'user', content: [{ type: 'tool_result', tool_use_id: 't1', content: fileV1 }] },
+            { role: 'assistant', content: [{ type: 'tool_use', id: 't2', name: 'Read', input: { file_path: '/foo.py' } }] },
+            { role: 'user', content: [{ type: 'tool_result', tool_use_id: 't2', content: fileV2 }] },
+        ];
+        const r = compressRepeatedReads(messages);
+        expect(r.collapsedCount).toBe(1);
+        expect(r.savedChars).toBeGreaterThan(0);
+        const firstResult = messages[1].content[0].content;
+        expect(typeof firstResult).toBe('string');
+        expect(firstResult).toContain('squeezr_expand');
+        expect(messages[3].content[0].content).toBe(fileV2);
+    });
+    it('does NOT touch single Read', () => {
+        const content = 'X'.repeat(2000);
+        const messages = [
+            { role: 'assistant', content: [{ type: 'tool_use', id: 't1', name: 'Read', input: { file_path: '/single.py' } }] },
+            { role: 'user', content: [{ type: 'tool_result', tool_use_id: 't1', content }] },
+        ];
+        const r = compressRepeatedReads(messages);
+        expect(r.collapsedCount).toBe(0);
+        expect(messages[1].content[0].content).toBe(content);
+    });
+    it('preserves tool_use ids and structure', () => {
+        const fileV1 = 'a\n'.repeat(300);
+        const fileV2 = fileV1 + 'extra\n';
+        const messages = [
+            { role: 'assistant', content: [{ type: 'tool_use', id: 'tA', name: 'Read', input: { file_path: '/y.py' } }] },
+            { role: 'user', content: [{ type: 'tool_result', tool_use_id: 'tA', content: fileV1 }] },
+            { role: 'assistant', content: [{ type: 'tool_use', id: 'tB', name: 'Read', input: { file_path: '/y.py' } }] },
+            { role: 'user', content: [{ type: 'tool_result', tool_use_id: 'tB', content: fileV2 }] },
+        ];
+        compressRepeatedReads(messages);
+        expect(messages[0].content[0].id).toBe('tA');
+        expect(messages[0].content[0].name).toBe('Read');
+        expect(messages[2].content[0].id).toBe('tB');
+        expect(messages[1].content[0].tool_use_id).toBe('tA');
+        expect(messages[3].content[0].tool_use_id).toBe('tB');
+    });
+    it('skips reads with identical content', () => {
+        const same = 'identical\n'.repeat(100);
+        const messages = [
+            { role: 'assistant', content: [{ type: 'tool_use', id: 't1', name: 'Read', input: { file_path: '/x.py' } }] },
+            { role: 'user', content: [{ type: 'tool_result', tool_use_id: 't1', content: same }] },
+            { role: 'assistant', content: [{ type: 'tool_use', id: 't2', name: 'Read', input: { file_path: '/x.py' } }] },
+            { role: 'user', content: [{ type: 'tool_result', tool_use_id: 't2', content: same }] },
+        ];
+        const r = compressRepeatedReads(messages);
+        expect(r.collapsedCount).toBe(0);
+    });
+    it('ignores reads of different file paths', () => {
+        const text = 'L\n'.repeat(300);
+        const messages = [
+            { role: 'assistant', content: [{ type: 'tool_use', id: 't1', name: 'Read', input: { file_path: '/a.py' } }] },
+            { role: 'user', content: [{ type: 'tool_result', tool_use_id: 't1', content: text }] },
+            { role: 'assistant', content: [{ type: 'tool_use', id: 't2', name: 'Read', input: { file_path: '/b.py' } }] },
+            { role: 'user', content: [{ type: 'tool_result', tool_use_id: 't2', content: text }] },
+        ];
+        const r = compressRepeatedReads(messages);
+        expect(r.collapsedCount).toBe(0);
+    });
+    it('falls back to reference placeholder when diff would be too big', () => {
+        const fileV1 = Array.from({ length: 100 }, (_, i) => `line ${i} original`).join('\n');
+        const fileV2 = Array.from({ length: 100 }, (_, i) => `line ${i} totally different`).join('\n');
+        const messages = [
+            { role: 'assistant', content: [{ type: 'tool_use', id: 't1', name: 'Read', input: { file_path: '/z.py' } }] },
+            { role: 'user', content: [{ type: 'tool_result', tool_use_id: 't1', content: fileV1 }] },
+            { role: 'assistant', content: [{ type: 'tool_use', id: 't2', name: 'Read', input: { file_path: '/z.py' } }] },
+            { role: 'user', content: [{ type: 'tool_result', tool_use_id: 't2', content: fileV2 }] },
+        ];
+        const r = compressRepeatedReads(messages);
+        expect(r.collapsedCount).toBe(1);
+        const placeholder = messages[1].content[0].content;
+        expect(placeholder).toContain('squeezr_expand');
+    });
+});

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

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