squeezr-ai 1.46.2 → 1.80.6

package/dist/__tests__/glossaryStore.test.js

@@ -0,0 +1,37 @@
+import { describe, it, expect } from 'vitest';
+import { updateGlossaryFromRequest, loadGlossary, _internal } from '../glossaryStore.js';
+describe('glossaryStore', () => {
+    it('never mutates the input messages', () => {
+        const messages = [
+            { role: 'user', content: '/long/path/here/file.py '.repeat(25) },
+            { role: 'assistant', content: 'ok' },
+        ];
+        const original = JSON.stringify(messages);
+        updateGlossaryFromRequest(messages);
+        expect(JSON.stringify(messages)).toBe(original);
+    });
+    it('does not assign refs below MIN_OCCURRENCES threshold', () => {
+        const messages = [
+            { role: 'user', content: '/some/path/file.py ' },
+        ];
+        const result = updateGlossaryFromRequest(messages);
+        expect(result.newRefs).toBe(0);
+    });
+    it('countOccurrences returns correct counts', () => {
+        const messages = [
+            { role: 'user', content: '/long/path/project/src/component.tsx '.repeat(25) },
+        ];
+        const counts = _internal.countOccurrences(messages, /(?:[A-Za-z]:[\\/][^\s'"<>|()\[\]{}]+|(?:\/|~\/|\.\/|\.\.\/)[^\s'"<>|()\[\]{}]{20,})/g);
+        const path = '/long/path/project/src/component.tsx';
+        expect(counts.get(path)).toBe(25);
+    });
+    it('assigns sequential $Pn refs', () => {
+        const g = loadGlossary();
+        const start = g.nextId;
+        // All refs must follow the $P prefix pattern
+        for (const ref of Object.values(g.mapping)) {
+            expect(ref).toMatch(/^\$P\d+$/);
+        }
+        expect(start).toBeGreaterThanOrEqual(1);
+    });
+});

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

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

package/dist/__tests__/glossarySub.test.js

@@ -0,0 +1,162 @@
+import { describe, it, expect } from 'vitest';
+import { applyGlossarySubstitution, buildGlossaryLegend } from '../glossarySub.js';
+// Token long enough to pass MIN_TOKEN_CHARS (30)
+const TOKEN_A = '/home/user/Documents/MyProject/src/components/Button.tsx';
+const TOKEN_B = '/home/user/Documents/MyProject/src/services/AuthService.ts';
+const REF_A = '$P1';
+const REF_B = '$P2';
+const MAPPING = { [TOKEN_A]: REF_A, [TOKEN_B]: REF_B };
+function msg(role, text) {
+    return { role, content: text };
+}
+function msgArr(role, ...texts) {
+    return { role, content: texts.map(t => ({ type: 'text', text: t })) };
+}
+// Repeat a message N times to pass the MIN_APPLY_OCCURRENCES (3) threshold
+function repeat(text, n) {
+    return (text + ' ').repeat(n);
+}
+describe('applyGlossarySubstitution', () => {
+    it('no-op when mapping is empty', () => {
+        const msgs = [msg('user', repeat(TOKEN_A, 5)), msg('assistant', 'ok')];
+        const r = applyGlossarySubstitution(msgs, {});
+        expect(r.savedChars).toBe(0);
+        expect(r.netSavedChars).toBe(0);
+        expect(r.refsApplied.size).toBe(0);
+    });
+    it('no-op when token appears < MIN_APPLY_OCCURRENCES times', () => {
+        const msgs = [
+            msg('user', TOKEN_A), // 1 occurrence
+            msg('assistant', TOKEN_A), // 2 occurrences total
+            msg('user', 'final ask'), // last user — skipped
+        ];
+        const r = applyGlossarySubstitution(msgs, MAPPING);
+        expect(r.refsApplied.size).toBe(0);
+    });
+    it('replaces when token appears >= MIN_APPLY_OCCURRENCES times', () => {
+        const msgs = [
+            msg('user', repeat(TOKEN_A, 3)),
+            msg('assistant', `I modified ${TOKEN_A}`),
+            msg('user', 'what next?'), // last user — skipped
+        ];
+        const r = applyGlossarySubstitution(msgs, MAPPING);
+        expect(r.refsApplied.has(TOKEN_A)).toBe(true);
+        expect(r.savedChars).toBeGreaterThan(0);
+    });
+    it('never modifies the last user message', () => {
+        const lastAsk = `check ${TOKEN_A} please`;
+        const msgs = [
+            msg('user', repeat(TOKEN_A, 3)),
+            msg('assistant', TOKEN_A),
+            msg('user', lastAsk),
+        ];
+        applyGlossarySubstitution(msgs, MAPPING);
+        expect(msgs[2].content).toBe(lastAsk);
+    });
+    it('replaces in assistant string content', () => {
+        const msgs = [
+            msg('user', repeat(TOKEN_A, 3)),
+            msg('assistant', `The file is ${TOKEN_A}`),
+            msg('user', 'ok'),
+        ];
+        applyGlossarySubstitution(msgs, MAPPING);
+        expect(msgs[1].content).toContain(REF_A);
+        expect(msgs[1].content).not.toContain(TOKEN_A);
+    });
+    it('replaces in assistant array text blocks', () => {
+        const msgs = [
+            msg('user', repeat(TOKEN_A, 3)),
+            msgArr('assistant', `The file is ${TOKEN_A} and also ${TOKEN_A}`),
+            msg('user', 'ok'),
+        ];
+        applyGlossarySubstitution(msgs, MAPPING);
+        const block = (msgs[1].content)[0];
+        expect(block.text).toContain(REF_A);
+        expect(block.text).not.toContain(TOKEN_A);
+    });
+    it('never touches tool_use blocks inside assistant messages', () => {
+        const msgs = [
+            msg('user', repeat(TOKEN_A, 3)),
+            {
+                role: 'assistant',
+                content: [
+                    { type: 'tool_use', id: 'tu_1', name: 'Read', input: { file_path: TOKEN_A } },
+                    { type: 'text', text: `reading ${TOKEN_A}` },
+                ],
+            },
+            msg('user', 'done'),
+        ];
+        applyGlossarySubstitution(msgs, MAPPING);
+        const blocks = msgs[1].content;
+        // tool_use input must be untouched
+        expect(blocks[0].input?.file_path).toBe(TOKEN_A);
+        // text block is replaced
+        expect(blocks[1].text).toContain(REF_A);
+    });
+    it('never touches tool_result content inside user messages', () => {
+        const msgs = [
+            {
+                role: 'user',
+                content: [
+                    { type: 'tool_result', tool_use_id: 'tu_1', content: `output of ${TOKEN_A}` },
+                ],
+            },
+            msg('assistant', repeat(TOKEN_A, 3)),
+            msg('user', 'next'),
+        ];
+        applyGlossarySubstitution(msgs, MAPPING);
+        const block = msgs[0].content[0];
+        expect(block.content).toContain(TOKEN_A); // untouched
+    });
+    it('replaces longer tokens before shorter (avoids partial match)', () => {
+        const LONG = '/home/user/Documents/MyProject/src/veryLongComponentName.tsx';
+        const SHORT = '/home/user/Documents/MyProject/src';
+        const mapping = { [LONG]: '$P1', [SHORT]: '$P2' };
+        const text = repeat(`${LONG} ${SHORT}`, 3);
+        const msgs = [msg('user', text), msg('assistant', text), msg('user', 'ok')];
+        applyGlossarySubstitution(msgs, mapping);
+        const result = msgs[1].content;
+        // $P1 should appear (long was replaced), not have $P2 inside what was $P1
+        expect(result).toContain('$P1');
+        expect(result).toContain('$P2');
+        // $P2 should NOT appear inside $P1 replacement (i.e., no "$P2/veryLong...")
+        expect(result).not.toContain('$P2/veryLong');
+    });
+    it('handles empty messages array gracefully', () => {
+        const r = applyGlossarySubstitution([], MAPPING);
+        expect(r.savedChars).toBe(0);
+    });
+    it('netSavedChars accounts for legend overhead', () => {
+        const msgs = [
+            msg('user', repeat(TOKEN_A, 5)),
+            msg('assistant', repeat(TOKEN_A, 5)),
+            msg('user', 'done'),
+        ];
+        const r = applyGlossarySubstitution(msgs, MAPPING);
+        expect(r.netSavedChars).toBe(r.savedChars - r.legendChars);
+        expect(r.legendChars).toBeGreaterThan(0);
+    });
+    it('replaces multiple refs in same message', () => {
+        const text = repeat(`${TOKEN_A} and ${TOKEN_B}`, 3);
+        const msgs = [msg('user', text), msg('assistant', text), msg('user', 'ok')];
+        const r = applyGlossarySubstitution(msgs, MAPPING);
+        expect(r.refsApplied.size).toBe(2);
+        const content = msgs[1].content;
+        expect(content).toContain(REF_A);
+        expect(content).toContain(REF_B);
+    });
+});
+describe('buildGlossaryLegend', () => {
+    it('returns empty string for empty map', () => {
+        expect(buildGlossaryLegend(new Map())).toBe('');
+    });
+    it('includes all refs in the legend', () => {
+        const refs = new Map([[TOKEN_A, REF_A], [TOKEN_B, REF_B]]);
+        const legend = buildGlossaryLegend(refs);
+        expect(legend).toContain('$P1');
+        expect(legend).toContain('$P2');
+        expect(legend).toContain(TOKEN_A);
+        expect(legend).toContain(TOKEN_B);
+        expect(legend).toContain('[squeezr-glossary:');
+    });
+});

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

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

package/dist/__tests__/imageDedup.test.js

@@ -0,0 +1,80 @@
+/**
+ * Tests for v1.48.0 image dedup hash-based.
+ */
+import { describe, it, expect } from 'vitest';
+import { dedupImagesAnthropic } from '../imageDedup.js';
+describe('imageDedup', () => {
+    it('replaces duplicate base64 images with text placeholders', () => {
+        const img = { type: 'image', source: { type: 'base64', data: 'abc'.repeat(500), media_type: 'image/png' } };
+        const messages = [
+            { role: 'user', content: [{ ...img }, { type: 'text', text: 'first ask' }] },
+            { role: 'assistant', content: [{ type: 'text', text: 'reply' }] },
+            { role: 'user', content: [{ ...img }, { type: 'text', text: 'follow-up' }] },
+        ];
+        const r = dedupImagesAnthropic(messages);
+        expect(r.dedupCount).toBe(1);
+        expect(messages[0].content[0].type).toBe('text'); // first image got replaced
+        expect(messages[0].content[0].text).toContain('squeezr_expand');
+        expect(messages[2].content[0].type).toBe('image'); // last image stays
+        expect(r.savedChars).toBeGreaterThan(0);
+    });
+    it('keeps single occurrences untouched', () => {
+        const messages = [
+            { role: 'user', content: [{ type: 'image', source: { type: 'base64', data: 'xyz' } }] },
+        ];
+        const r = dedupImagesAnthropic(messages);
+        expect(r.dedupCount).toBe(0);
+        expect(messages[0].content[0].type).toBe('image');
+    });
+    it('ignores non-image content blocks entirely', () => {
+        const messages = [
+            { role: 'user', content: [{ type: 'text', text: 'hello' }, { type: 'tool_result', tool_use_id: 't1', content: 'output' }] },
+        ];
+        const r = dedupImagesAnthropic(messages);
+        expect(r.dedupCount).toBe(0);
+        expect(messages[0].content[0].text).toBe('hello');
+        expect(messages[0].content[1].type).toBe('tool_result');
+    });
+    it('treats different base64 data as distinct images', () => {
+        const messages = [
+            { role: 'user', content: [{ type: 'image', source: { type: 'base64', data: 'aaa'.repeat(500) } }] },
+            { role: 'user', content: [{ type: 'image', source: { type: 'base64', data: 'bbb'.repeat(500) } }] },
+        ];
+        const r = dedupImagesAnthropic(messages);
+        expect(r.dedupCount).toBe(0);
+    });
+    it('dedupes URL-source images by URL', () => {
+        const messages = [
+            { role: 'user', content: [{ type: 'image', source: { type: 'url', url: 'https://example.com/img.png' } }] },
+            { role: 'user', content: [{ type: 'image', source: { type: 'url', url: 'https://example.com/img.png' } }] },
+        ];
+        const r = dedupImagesAnthropic(messages);
+        expect(r.dedupCount).toBe(1);
+        expect(messages[0].content[0].type).toBe('text');
+        expect(messages[1].content[0].type).toBe('image');
+    });
+    it('handles 3+ occurrences keeping only the last', () => {
+        const img = { type: 'image', source: { type: 'base64', data: 'same'.repeat(500) } };
+        const messages = [
+            { role: 'user', content: [{ ...img }] },
+            { role: 'assistant', content: [{ type: 'text', text: 'a' }] },
+            { role: 'user', content: [{ ...img }] },
+            { role: 'assistant', content: [{ type: 'text', text: 'b' }] },
+            { role: 'user', content: [{ ...img }] },
+        ];
+        const r = dedupImagesAnthropic(messages);
+        expect(r.dedupCount).toBe(2);
+        expect(messages[0].content[0].type).toBe('text');
+        expect(messages[2].content[0].type).toBe('text');
+        expect(messages[4].content[0].type).toBe('image');
+    });
+    it('does not touch string-content messages', () => {
+        const messages = [
+            { role: 'user', content: 'plain text message' },
+            { role: 'user', content: 'another plain text' },
+        ];
+        const r = dedupImagesAnthropic(messages);
+        expect(r.dedupCount).toBe(0);
+        expect(messages[0].content).toBe('plain text message');
+    });
+});

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

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

package/dist/__tests__/largeBlock.test.js

@@ -0,0 +1,35 @@
+import { describe, it, expect, vi } from 'vitest';
+// compressor.ts imports the AI SDKs at module load; stub them so the import is cheap.
+vi.mock('@anthropic-ai/sdk', () => ({ default: vi.fn().mockImplementation(function () { return {}; }) }));
+vi.mock('openai', () => ({ default: vi.fn().mockImplementation(function () { return {}; }) }));
+import { splitOnLines } from '../compressor.js';
+describe('splitOnLines (large-block chunking — no data loss)', () => {
+    it('returns the text as a single chunk when it fits', () => {
+        const text = 'line a\nline b\nline c';
+        expect(splitOnLines(text, 1000)).toEqual([text]);
+    });
+    it('covers the ENTIRE input including the tail sentinel when chunked', () => {
+        // Build a >13k block of numbered lines with a unique tail sentinel.
+        const lines = [];
+        for (let i = 0; i < 2000; i++)
+            lines.push(`line ${i}: some tool output content here`);
+        lines.push('TAIL_SENTINEL_UNIQUE_98765 at src/edge/case.ts');
+        const text = lines.join('\n');
+        expect(text.length).toBeGreaterThan(13000);
+        const chunks = splitOnLines(text, 13000);
+        expect(chunks.length).toBeGreaterThan(1);
+        // Every chunk is within budget.
+        for (const c of chunks)
+            expect(c.length).toBeLessThanOrEqual(13000);
+        // The tail sentinel must survive somewhere — the old slice(0,4000) dropped it.
+        expect(chunks.some(c => c.includes('TAIL_SENTINEL_UNIQUE_98765'))).toBe(true);
+        // Rejoining reconstructs the original exactly (no bytes lost at boundaries).
+        expect(chunks.join('\n')).toBe(text);
+    });
+    it('hard-splits a single line longer than maxChars without losing content', () => {
+        const huge = 'x'.repeat(5000);
+        const chunks = splitOnLines(huge, 1000);
+        expect(chunks.length).toBe(5);
+        expect(chunks.join('')).toBe(huge);
+    });
+});

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

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

package/dist/__tests__/mcpFilter.test.js

@@ -0,0 +1,87 @@
+import { describe, it, expect } from 'vitest';
+import { filterMcpTools, mcpServerOf } from '../mcpFilter.js';
+function tool(name, descLen = 100) {
+    return { name, description: 'd'.repeat(descLen), input_schema: { type: 'object' } };
+}
+const TOOLS = [
+    tool('Bash'),
+    tool('Read'),
+    tool('mcp__planning-task-mcp__create_task'),
+    tool('mcp__planning-task-mcp__list_tasks'),
+    tool('mcp__github-mcp__create_pr'),
+    tool('mcp__memory-mcp__get_stats'),
+];
+const NO_MSGS = [];
+describe('mcpServerOf', () => {
+    it('extracts server from mcp tool name', () => {
+        expect(mcpServerOf('mcp__github-mcp__create_pr')).toBe('github-mcp');
+    });
+    it('returns null for built-ins', () => {
+        expect(mcpServerOf('Bash')).toBe(null);
+    });
+    it('handles server-only names', () => {
+        expect(mcpServerOf('mcp__solo')).toBe('solo');
+    });
+});
+describe('filterMcpTools', () => {
+    it('no-op when both lists empty', () => {
+        const { tools, result } = filterMcpTools(TOOLS, NO_MSGS, new Set(), new Set());
+        expect(tools.length).toBe(6);
+        expect(result.removedTools).toBe(0);
+    });
+    it('blocks listed servers', () => {
+        const { tools, result } = filterMcpTools(TOOLS, NO_MSGS, new Set(['planning-task-mcp']), new Set());
+        expect(tools.length).toBe(4);
+        expect(result.removedTools).toBe(2);
+        expect(result.removedServers).toEqual(['planning-task-mcp']);
+        expect(result.savedChars).toBeGreaterThan(0);
+    });
+    it('allow list keeps only listed servers (built-ins always kept)', () => {
+        const { tools, result } = filterMcpTools(TOOLS, NO_MSGS, new Set(), new Set(['github-mcp']));
+        const names = tools.map(t => t.name);
+        expect(names).toContain('Bash');
+        expect(names).toContain('Read');
+        expect(names).toContain('mcp__github-mcp__create_pr');
+        expect(names).not.toContain('mcp__planning-task-mcp__create_task');
+        expect(names).not.toContain('mcp__memory-mcp__get_stats');
+        expect(result.removedTools).toBe(3);
+    });
+    it('allow list takes precedence over block list', () => {
+        const { tools } = filterMcpTools(TOOLS, NO_MSGS, new Set(['github-mcp']), new Set(['github-mcp']));
+        const names = tools.map(t => t.name);
+        // allow wins: github-mcp survives even though blocked
+        expect(names).toContain('mcp__github-mcp__create_pr');
+    });
+    it('NEVER filters built-in tools', () => {
+        const { tools } = filterMcpTools(TOOLS, NO_MSGS, new Set(['planning-task-mcp', 'github-mcp', 'memory-mcp']), new Set());
+        const names = tools.map(t => t.name);
+        expect(names).toContain('Bash');
+        expect(names).toContain('Read');
+    });
+    it('NEVER filters a server used in the conversation', () => {
+        const msgs = [
+            {
+                role: 'assistant',
+                content: [{ type: 'tool_use', id: 't1', name: 'mcp__planning-task-mcp__create_task', input: {} }],
+            },
+            { role: 'user', content: [{ type: 'tool_result', tool_use_id: 't1', content: 'ok' }] },
+        ];
+        const { tools, result } = filterMcpTools(TOOLS, msgs, new Set(['planning-task-mcp']), new Set());
+        const names = tools.map(t => t.name);
+        // Used server is protected
+        expect(names).toContain('mcp__planning-task-mcp__create_task');
+        expect(names).toContain('mcp__planning-task-mcp__list_tasks');
+        expect(result.keptUsedServers).toEqual(['planning-task-mcp']);
+        expect(result.removedTools).toBe(0);
+    });
+    it('handles empty tools array', () => {
+        const { tools, result } = filterMcpTools([], NO_MSGS, new Set(['x']), new Set());
+        expect(tools.length).toBe(0);
+        expect(result.removedTools).toBe(0);
+    });
+    it('handles malformed tool entries gracefully', () => {
+        const badTools = [null, undefined, 'str', 42, tool('mcp__bad-server__x')];
+        const { tools } = filterMcpTools(badTools, NO_MSGS, new Set(['bad-server']), new Set());
+        expect(tools.length).toBe(4); // bad entries kept, mcp tool removed
+    });
+});

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

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

package/dist/__tests__/newFeatures.test.js

@@ -0,0 +1,124 @@
+/**
+ * Smoke tests for the v1.47.x → v1.49.x feature batch.
+ * Verifies each new module fires correctly and is idempotent / byte-stable.
+ */
+import { describe, it, expect } from 'vitest';
+import { dedupSkillBlocks } from '../skillDedup.js';
+import { dedupImagesAnthropic } from '../imageDedup.js';
+import { dedupAttachments } from '../attachmentDedup.js';
+import { compressRepeatedReads } from '../diffRead.js';
+import { summarizeStaleTurns } from '../staleTurnSummary.js';
+import { semanticReadCompress } from '../semanticRead.js';
+import { compressAttachmentText } from '../attachmentCompress.js';
+import { compressStockToolDescs } from '../stockToolDescs.js';
+describe('skillDedup', () => {
+    it('collapses duplicate skill blocks in system prompt', () => {
+        const block = '## Skill: foo\n' + 'long description line with lots of content\n'.repeat(8) + 'final line of the skill block';
+        const prompt = `intro\n\n${block}\n\nsome middle content\n\n${block}\n\nmore content`;
+        const r = dedupSkillBlocks(prompt);
+        expect(r.dedupCount).toBeGreaterThan(0);
+        expect(r.savedChars).toBeGreaterThan(0);
+        expect(r.text.length).toBeLessThan(prompt.length);
+    });
+    it('is a no-op on small prompts', () => {
+        const r = dedupSkillBlocks('hi');
+        expect(r.dedupCount).toBe(0);
+    });
+});
+describe('imageDedup', () => {
+    it('replaces duplicate images with placeholders', () => {
+        const img = { type: 'image', source: { type: 'base64', data: 'abc'.repeat(500), media_type: 'image/png' } };
+        const messages = [
+            { role: 'user', content: [{ ...img }, { type: 'text', text: 'first ask' }] },
+            { role: 'assistant', content: [{ type: 'text', text: 'reply' }] },
+            { role: 'user', content: [{ ...img }, { type: 'text', text: 'follow-up' }] },
+        ];
+        const r = dedupImagesAnthropic(messages);
+        expect(r.dedupCount).toBe(1);
+        expect(messages[0].content[0].type).toBe('text'); // first image got replaced
+        expect(messages[2].content[0].type).toBe('image'); // last image stays
+    });
+});
+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' }] },
+            { role: 'user', content: [{ type: 'text', text: 'live ask' }] },
+        ];
+        const r = dedupAttachments(messages);
+        expect(r.dedupCount).toBeGreaterThan(0);
+    });
+});
+// promptCache removed in v1.51.0 — Claude Code does its own caching natively
+// mcpToolFilter removed in v1.52.0 — caused 429 rate-limit cascades on real Claude Code traffic
+describe('semanticRead', () => {
+    it('elides function bodies in large code files', () => {
+        const py = Array.from({ length: 300 }, (_, i) => i % 30 === 0
+            ? `def function_${i}():\n    x = 1\n    y = 2\n    z = 3\n    a = x + y\n    b = y + z\n    c = a + b\n    return c`
+            : `# filler line ${i}`).join('\n');
+        const r = semanticReadCompress(py, 'foo.py');
+        expect(r.savedChars).toBeGreaterThan(0);
+        expect(r.compressed).toContain('def function_');
+        expect(r.compressed).toContain('squeezr');
+    });
+    it('returns unchanged for small files', () => {
+        const r = semanticReadCompress('def f(): pass', 'x.py');
+        expect(r.savedChars).toBe(0);
+    });
+});
+describe('attachmentCompress', () => {
+    it('compresses large CSV', () => {
+        const rows = Array.from({ length: 200 }, (_, i) => `${i},${i * 2},${i * 3},name_${i}`);
+        const csv = 'id,a,b,name\n' + rows.join('\n');
+        const r = compressAttachmentText(csv);
+        expect(r.type).toBe('csv');
+        expect(r.savedChars).toBeGreaterThan(0);
+    });
+});
+describe('stockToolDescs', () => {
+    it('replaces verbose stock tool description with one-liner', () => {
+        const body = { tools: [{ name: 'Bash', description: 'X'.repeat(2000) }] };
+        const r = compressStockToolDescs(body);
+        expect(r.compressed).toBe(1);
+        expect(body.tools[0].description.length).toBeLessThan(500);
+    });
+});
+describe('staleTurnSummary', () => {
+    it('summarizes old turns for sessions >40 turns', () => {
+        const messages = Array.from({ length: 50 }, (_, i) => ({
+            role: i % 2 === 0 ? 'user' : 'assistant',
+            content: `turn ${i} content with some refactor and fix words. ${'lorem '.repeat(100)}`,
+        }));
+        const r = summarizeStaleTurns(messages);
+        expect(r.collapsedTurns).toBeGreaterThan(0);
+        expect(r.savedChars).toBeGreaterThan(0);
+    });
+    it('preserves last 20 turns', () => {
+        const messages = Array.from({ length: 50 }, (_, i) => ({
+            role: i % 2 === 0 ? 'user' : 'assistant',
+            content: `turn ${i} ${'lorem '.repeat(100)}`,
+        }));
+        summarizeStaleTurns(messages);
+        // Last 20 should still have their original content (>500 chars each)
+        for (let i = 30; i < 50; i++) {
+            expect(messages[i].content).toContain(`turn ${i}`);
+        }
+    });
+});
+describe('diffRead', () => {
+    it('collapses duplicate Reads to references', () => {
+        const fileContent = 'line1\nline2\nline3\n'.repeat(200);
+        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: fileContent }] },
+            { 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: fileContent + 'extra line\n' }] },
+        ];
+        const r = compressRepeatedReads(messages);
+        expect(r.collapsedCount).toBeGreaterThan(0);
+    });
+});

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

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

package/dist/__tests__/qualityHarness.test.js

@@ -0,0 +1,98 @@
+/**
+ * Stage 5 — Quality harness.
+ *
+ * Compresses a corpus of REAL-shaped tool outputs with the live local model (Zest
+ * via Ollama) and measures, per fixture:
+ *   (a) compression ratio (did it actually shrink?)
+ *   (b) hard-token retention (paths / URLs / error codes MUST survive — 100%)
+ *   (c) whether the acceptance guardrail would accept the result
+ *
+ * Skipped automatically when Ollama isn't reachable, so CI without a model stays
+ * green. Run locally with Ollama up:  npm run test:quality
+ */
+import { describe, it, expect } from 'vitest';
+import { compressLargeText } from '../compressor.js';
+import { validateCompression } from '../compressionGuard.js';
+const OLLAMA = process.env.SQUEEZR_LOCAL_UPSTREAM || 'http://localhost:11434';
+const MODEL = process.env.SQUEEZR_LOCAL_MODEL || 'zest';
+async function ollamaUp() {
+    try {
+        const r = await fetch(`${OLLAMA}/api/tags`, { signal: AbortSignal.timeout(1500) });
+        return r.ok;
+    }
+    catch {
+        return false;
+    }
+}
+const UP = await ollamaUp();
+// Hard tokens that MUST survive an ACCEPTED compression: URLs, error/status codes,
+// and explicit filenames. Clean regexes (no greedy path matching) so the harness
+// oracle doesn't produce partial-match artifacts.
+function hardTokens(text) {
+    const sets = [
+        /https?:\/\/[^\s"'<>)\]]+/g, // URLs
+        /\b[\w\-]+\.(?:ts|tsx|js|py|json|md|go|rs|yml|yaml|toml|sql)\b/g, // filenames
+        /\b(?:E[A-Z]{2,}|HTTP\s?\d{3}|exit code \d+|errno\s?\d+|status\s?[45]\d{2})\b/g, // error/status codes
+    ];
+    const out = new Set();
+    for (const re of sets)
+        for (const m of text.match(re) ?? [])
+            out.add(m);
+    return [...out];
+}
+const CORPUS = [
+    {
+        name: 'verbose-file-read',
+        text: `import { readFileSync } from 'node:fs'\nimport { join } from 'node:path'\n` +
+            Array.from({ length: 60 }, (_, i) => `export function handler${i}(req: Request, res: Response) {\n` +
+                `  // process incoming request number ${i} with full validation and logging\n` +
+                `  const data = readFileSync(join('/srv/app/data', 'file${i}.json'), 'utf-8')\n` +
+                `  if (!data) throw new Error('missing file${i}.json at /srv/app/data')\n  return res.json(JSON.parse(data))\n}`).join('\n'),
+    },
+    {
+        name: 'test-failure',
+        text: `FAIL src/auth/login.test.ts > rejects bad password\n` +
+            `AssertionError: expected 401 to equal 200\n  at Object.<anonymous> (src/auth/login.test.ts:88:14)\n` +
+            `  at src/auth/session.ts:42:9\nECONNREFUSED connecting to https://api.internal/auth\n` +
+            'stack frame filler line that pads the block to be worth compressing '.repeat(30),
+    },
+    {
+        name: 'build-log',
+        text: `> tsc\n` + 'compiling module with verbose diagnostic output and progress notes '.repeat(40) +
+            `\nWARNING deprecated API used in src/legacy/parser.ts line 210\n` +
+            `see https://example.com/docs/migration for the upgrade path\nDone in 4.2s`,
+    },
+    {
+        name: 'json-response',
+        text: JSON.stringify({
+            status: 500, error: 'ECONNRESET',
+            endpoint: 'https://api.service.com/v2/orders',
+            items: Array.from({ length: 40 }, (_, i) => ({ id: i, sku: `SKU-${i}`, qty: i * 2, note: 'a fairly long descriptive note about this line item for padding' })),
+        }, null, 2),
+    },
+];
+describe('quality harness (Zest live)', () => {
+    it(`Ollama reachable at ${OLLAMA}`, () => {
+        if (!UP)
+            console.warn(`[harness] Ollama not reachable — quality cases skipped`);
+        expect(true).toBe(true);
+    });
+    for (const fx of CORPUS) {
+        it.skipIf(!UP)(`${fx.name}: compresses and keeps all hard tokens`, async () => {
+            const out = await compressLargeText(fx.text, OLLAMA, MODEL);
+            const ratio = 1 - out.length / fx.text.length;
+            const hard = hardTokens(fx.text);
+            const lost = hard.filter(t => !out.includes(t));
+            const guard = validateCompression(fx.text, out);
+            console.log(`[harness] ${fx.name}: ratio=${(ratio * 100).toFixed(0)}% hardTokens=${hard.length} lost=${lost.length} guard=${guard.accept ? 'accept' : 'reject:' + guard.reason}`);
+            // It must actually shrink the block.
+            expect(ratio).toBeGreaterThan(0);
+            // THE safety property: a compression the guardrail ACCEPTS must not have lost
+            // any hard token. If Zest mangled one, the guardrail must have rejected it
+            // (production then keeps the deterministic form — no quality loss).
+            if (guard.accept) {
+                expect(lost).toEqual([]);
+            }
+        }, 30000);
+    }
+});

package/dist/__tests__/rateLimitHeaders.test.js

@@ -7,6 +7,12 @@
  */
 import { describe, it, expect, vi, afterEach } from 'vitest';
 import { createServer } from 'node:http';
+// The proxy routes api.anthropic.com through anthropicDirectFetch (direct DNS,
+// bypasses global fetch). Mock it to use global fetch so the stub below applies.
+vi.mock('../anthropicDirectFetch.js', () => ({
+    isAnthropicUrl: (url) => url.includes('api.anthropic.com'),
+    anthropicDirectFetch: (url, init) => fetch(url, init),
+}));
 // ── Helper: start a minimal mock Anthropic server ─────────────────────────────
 const RATE_LIMIT_HEADERS = {
     'anthropic-ratelimit-requests-limit': '50',

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

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