squeezr-ai 1.46.2 → 1.80.6

package/dist/__tests__/requestCapture.test.js

@@ -0,0 +1,37 @@
+/**
+ * Tests for v1.47.0 request capture mode.
+ * Verifies:
+ *  - Auth headers are redacted
+ *  - Disabled flag is a true no-op
+ *  - Capture limit is honored
+ */
+import { describe, it, expect } from 'vitest';
+import { _internal } from '../requestCapture.js';
+describe('requestCapture', () => {
+    it('redacts sensitive headers', () => {
+        const out = _internal.redactHeaders({
+            'content-type': 'application/json',
+            'authorization': 'Bearer sk-secret-token',
+            'x-api-key': 'sk-ant-secret',
+            'cookie': 'session=abc',
+            'user-agent': 'claude-code/1.0',
+        });
+        expect(out['authorization']).toBe('<redacted>');
+        expect(out['x-api-key']).toBe('<redacted>');
+        expect(out['cookie']).toBe('<redacted>');
+        expect(out['content-type']).toBe('application/json');
+        expect(out['user-agent']).toBe('claude-code/1.0');
+    });
+    it('redacts header names case-insensitively', () => {
+        const out = _internal.redactHeaders({
+            'Authorization': 'Bearer x',
+            'X-Api-Key': 'sk-y',
+        });
+        expect(out['Authorization']).toBe('<redacted>');
+        expect(out['X-Api-Key']).toBe('<redacted>');
+    });
+    it('generates sequentially-numbered capture filenames', () => {
+        const name = _internal.nextCaptureName();
+        expect(name).toMatch(/^req-\d{4}\.json$/);
+    });
+});

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

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

package/dist/__tests__/skillDedup.test.js

@@ -0,0 +1,57 @@
+import { describe, it, expect } from 'vitest';
+import { dedupSkillBlocks } from '../skillDedup.js';
+describe('skillDedup', () => {
+    it('collapses exact duplicate blocks in system prompt', () => {
+        const block = '## Skill: foo\n' + 'long description line with content\n'.repeat(8) + 'final line';
+        const prompt = `intro\n\n${block}\n\nmiddle content\n\n${block}\n\nmore`;
+        const r = dedupSkillBlocks(prompt);
+        expect(r.dedupCount).toBeGreaterThan(0);
+        expect(r.savedChars).toBeGreaterThan(0);
+        expect(r.text.length).toBeLessThan(prompt.length);
+        expect(r.text).toContain('duplicate of block');
+    });
+    it('is a no-op on small prompts', () => {
+        const r = dedupSkillBlocks('hi');
+        expect(r.dedupCount).toBe(0);
+        expect(r.text).toBe('hi');
+    });
+    it('keeps single-occurrence blocks untouched', () => {
+        const prompt = '## Section A\nline\nline\nline\nline\n\n## Section B\nline\nline\nline\nline';
+        const r = dedupSkillBlocks(prompt);
+        expect(r.dedupCount).toBe(0);
+        expect(r.text).toBe(prompt);
+    });
+    it('does not touch blocks below MIN_BLOCK_CHARS', () => {
+        const small = 'short\nblock\nhere\nplease';
+        const prompt = `${small}\n\nother\n\n${small}`;
+        const r = dedupSkillBlocks(prompt);
+        expect(r.dedupCount).toBe(0);
+    });
+    it('does not touch blocks below MIN_BLOCK_LINES', () => {
+        const oneLineButLong = 'X'.repeat(500);
+        const prompt = `${oneLineButLong}\n\nseparator\n\n${oneLineButLong}`;
+        const r = dedupSkillBlocks(prompt);
+        expect(r.dedupCount).toBe(0);
+    });
+    it('preserves separators between non-duplicate blocks', () => {
+        const block1 = 'A\n'.repeat(10);
+        const block2 = 'B\n'.repeat(10);
+        const prompt = `${block1}\n\n${block2}`;
+        const r = dedupSkillBlocks(prompt);
+        expect(r.text).toBe(prompt);
+    });
+    it('handles 3+ duplicates collapsing all but first', () => {
+        const block = '## Skill\n' + 'description line with content\n'.repeat(8) + 'end-line';
+        const between = 'separator block of content\nwith multiple lines\nof content here\nto qualify as block\nwith more text to make it long enough for threshold';
+        const prompt = `intro\n\n${block}\n\n${between}\n\n${block}\n\n${between}\n\n${block}\n\nend`;
+        const r = dedupSkillBlocks(prompt);
+        expect(r.dedupCount).toBeGreaterThanOrEqual(2);
+    });
+    it('byte-exact matching — one char difference = no dedup', () => {
+        const block1 = '## Skill foo\n' + 'description\n'.repeat(8) + 'end';
+        const block2 = '## Skill bar\n' + 'description\n'.repeat(8) + 'end'; // different first line
+        const prompt = `${block1}\n\n${block2}`;
+        const r = dedupSkillBlocks(prompt);
+        expect(r.dedupCount).toBe(0);
+    });
+});

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

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

package/dist/__tests__/staleTurns.test.js

@@ -0,0 +1,113 @@
+import { describe, it, expect } from 'vitest';
+import { collapseStaleTurns } from '../staleTurns.js';
+function makeConversation(turns, assistantContent = 'A short assistant reply.') {
+    const msgs = [];
+    for (let i = 0; i < turns; i++) {
+        msgs.push({ role: 'user', content: `User turn ${i + 1} asking something important.` });
+        msgs.push({ role: 'assistant', content: assistantContent });
+    }
+    return msgs;
+}
+const LONG_TEXT = 'This is a long assistant response. '.repeat(20);
+describe('collapseStaleTurns', () => {
+    it('no-op when turns <= threshold', () => {
+        const msgs = makeConversation(10, LONG_TEXT);
+        const result = collapseStaleTurns(msgs, 10, 5);
+        expect(result.savedChars).toBe(0);
+        expect(result.collapsedBlocks).toBe(0);
+    });
+    it('triggers when turns > threshold', () => {
+        const msgs = makeConversation(11, LONG_TEXT);
+        const result = collapseStaleTurns(msgs, 10, 5);
+        expect(result.savedChars).toBeGreaterThan(0);
+        expect(result.collapsedBlocks).toBeGreaterThan(0);
+    });
+    it('never touches user messages', () => {
+        const msgs = makeConversation(11, LONG_TEXT);
+        const usersBefore = msgs.filter(m => m.role === 'user').map(m => m.content);
+        collapseStaleTurns(msgs, 10, 5);
+        const usersAfter = msgs.filter(m => m.role === 'user').map(m => m.content);
+        expect(usersAfter).toEqual(usersBefore);
+    });
+    it('never touches tool_use blocks inside assistant messages', () => {
+        const msgs = makeConversation(11);
+        msgs[1].content = [
+            { type: 'tool_use', id: 'tu_1', name: 'Bash', input: { command: 'ls -la' } },
+            { type: 'text', text: LONG_TEXT },
+        ];
+        collapseStaleTurns(msgs, 10, 5);
+        const toolBlock = msgs[1].content[0];
+        expect(toolBlock.type).toBe('tool_use');
+        expect(toolBlock.id).toBe('tu_1');
+    });
+    it('never touches tool_result blocks inside user messages', () => {
+        const msgs = makeConversation(11, LONG_TEXT);
+        msgs[0].content = [
+            { type: 'tool_result', tool_use_id: 'tu_1', content: LONG_TEXT },
+        ];
+        collapseStaleTurns(msgs, 10, 5);
+        const tr = msgs[0].content[0];
+        expect(tr.type).toBe('tool_result');
+        expect(tr.tool_use_id).toBe('tu_1');
+    });
+    it('keeps last keepRecent turns untouched', () => {
+        const msgs = makeConversation(12, LONG_TEXT);
+        collapseStaleTurns(msgs, 10, 5);
+        const assistantMsgs = msgs.filter(m => m.role === 'assistant');
+        for (let i = assistantMsgs.length - 5; i < assistantMsgs.length; i++) {
+            expect(assistantMsgs[i].content).toBe(LONG_TEXT);
+        }
+    });
+    it('compresses stale assistant string content', () => {
+        const msgs = makeConversation(11, LONG_TEXT);
+        collapseStaleTurns(msgs, 10, 5);
+        const staleAssistant = msgs.filter(m => m.role === 'assistant')[0];
+        const compressed = staleAssistant.content;
+        expect(compressed.startsWith('[⧖')).toBe(true);
+        expect(compressed.length).toBeLessThan(LONG_TEXT.length);
+    });
+    it('compresses stale assistant text blocks in array content', () => {
+        const msgs = makeConversation(11);
+        for (let i = 1; i < msgs.length; i += 2) {
+            ;
+            msgs[i].content = [{ type: 'text', text: LONG_TEXT }];
+        }
+        collapseStaleTurns(msgs, 10, 5);
+        const staleAssistant = msgs.filter(m => m.role === 'assistant')[0];
+        const firstBlock = staleAssistant.content[0];
+        expect(firstBlock.text.startsWith('[⧖')).toBe(true);
+    });
+    it('skips blocks below MIN_BLOCK_LEN (250 chars)', () => {
+        const msgs = makeConversation(11, 'Short reply.');
+        const result = collapseStaleTurns(msgs, 10, 5);
+        expect(result.collapsedBlocks).toBe(0);
+        expect(result.savedChars).toBe(0);
+    });
+    it('reports staleCount correctly', () => {
+        const msgs = makeConversation(15, LONG_TEXT);
+        const result = collapseStaleTurns(msgs, 10, 5);
+        expect(result.staleCount).toBe(10);
+    });
+    it('extracts file path keywords into summary', () => {
+        const textWithPath = 'I modified the file src/components/Button.tsx to fix the bug. '.repeat(6);
+        const msgs = makeConversation(11, textWithPath);
+        collapseStaleTurns(msgs, 10, 5);
+        const staleAssistant = msgs.filter(m => m.role === 'assistant')[0];
+        expect(staleAssistant.content).toContain('Button.tsx');
+    });
+    it('handles empty messages array gracefully', () => {
+        const result = collapseStaleTurns([], 10, 5);
+        expect(result.savedChars).toBe(0);
+        expect(result.collapsedBlocks).toBe(0);
+    });
+    it('non-text blocks in assistant arrays are preserved', () => {
+        const msgs = makeConversation(11);
+        msgs[1].content = [
+            { type: 'image', source: { type: 'base64', media_type: 'image/png', data: 'abc' } },
+            { type: 'text', text: LONG_TEXT },
+        ];
+        collapseStaleTurns(msgs, 10, 5);
+        const imgBlock = msgs[1].content[0];
+        expect(imgBlock.type).toBe('image');
+    });
+});

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

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

package/dist/__tests__/structuredGuard.test.js

@@ -0,0 +1,72 @@
+import { describe, it, expect } from 'vitest';
+import { looksStructured } from '../structuredGuard.js';
+describe('looksStructured', () => {
+    it('detects a JSON array', () => {
+        expect(looksStructured('[{"a":1},{"a":2}]')).toBe(true);
+    });
+    it('detects a JSON object', () => {
+        expect(looksStructured('{"id":"x","date":"2026-06-09","count":5}')).toBe(true);
+    });
+    it('detects JSONL (one object per line)', () => {
+        const jsonl = [
+            '{"id":1,"date":"2026-01-01"}',
+            '{"id":2,"date":""}',
+            '{"id":3,"date":"2026-01-03"}',
+            '{"id":4,"date":"2026-01-04"}',
+        ].join('\n');
+        expect(looksStructured(jsonl)).toBe(true);
+    });
+    it('detects a record/dict dump with many key:value lines', () => {
+        const dump = [
+            'id: 178895',
+            'date: 2026-06-09',
+            'read: false',
+            'type: info',
+            'title: Hello',
+            'message: world',
+            'userId: abc',
+        ].join('\n');
+        expect(looksStructured(dump)).toBe(true);
+    });
+    it('detects pretty-printed quoted-key dumps', () => {
+        const dump = [
+            '"id": "178895",',
+            '"date": "",',
+            '"read": false,',
+            '"type": "info",',
+            '"title": "Hello",',
+            '"message": "world",',
+        ].join('\n');
+        expect(looksStructured(dump)).toBe(true);
+    });
+    it('detects tab-separated tabular output', () => {
+        const table = [
+            'id\tdate\tread',
+            '1\t2026-01-01\tfalse',
+            '2\t\ttrue',
+            '3\t2026-01-03\tfalse',
+            '4\t2026-01-04\ttrue',
+        ].join('\n');
+        expect(looksStructured(table)).toBe(true);
+    });
+    it('does NOT flag prose', () => {
+        const prose = 'The script processed 178,895 notifications and found that most of them ' +
+            'had a non-empty date field. This is a normal paragraph of text that the ' +
+            'AI compressor can safely summarise without losing any important meaning.';
+        expect(looksStructured(prose)).toBe(false);
+    });
+    it('does NOT flag prose with a couple of incidental "foo: bar" lines', () => {
+        const prose = [
+            'Here is what I found while reviewing the logs.',
+            'Summary: the build passed and tests are green.',
+            'Next step: deploy to staging and verify behaviour.',
+            'Everything looks good and ready to ship now.',
+        ].join('\n');
+        expect(looksStructured(prose)).toBe(false);
+    });
+    it('handles empty / tiny input safely', () => {
+        expect(looksStructured('')).toBe(false);
+        expect(looksStructured('{')).toBe(false);
+        expect(looksStructured('ok')).toBe(false);
+    });
+});

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

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

package/dist/__tests__/toolDescComp.test.js

@@ -0,0 +1,157 @@
+import { describe, it, expect } from 'vitest';
+import { compressToolDescriptions } from '../toolDescComp.js';
+const LONG_DESC = 'Execute bash commands in a sandbox environment.\n\nUsage notes:\n- Always quote paths.\n- Never use interactive commands.\n- Timeout is 30 seconds.\n\nCommon patterns:\n  git status\n  npm test\n\nReturns stdout and stderr combined.';
+const SHORT_DESC = 'Short description.';
+describe('compressToolDescriptions', () => {
+    it('no-op when tools array is empty', () => {
+        const r = compressToolDescriptions([], 0, false, false, false);
+        expect(r.savedChars).toBe(0);
+        expect(r.totalTools).toBe(0);
+    });
+    it('no-op when description is shorter than MIN_DESC_LEN', () => {
+        const tools = [{ name: 'Bash', description: SHORT_DESC, input_schema: { type: 'object' } }];
+        const r = compressToolDescriptions(tools, 0, false, false, false);
+        expect(r.savedChars).toBe(0);
+        expect(r.compressedTools).toBe(0);
+    });
+    it('normalizes whitespace in long descriptions', () => {
+        const tools = [{ name: 'Bash', description: LONG_DESC + '\n\n\n\n extra   ', input_schema: {} }];
+        const before = tools[0].description.length;
+        const r = compressToolDescriptions(tools, 0, false, false, false);
+        const after = tools[0].description.length;
+        expect(after).toBeLessThan(before);
+        expect(r.savedChars).toBeGreaterThan(0);
+        expect(r.compressedTools).toBe(1);
+    });
+    it('truncates to maxChars when set', () => {
+        const tools = [{ name: 'Read', description: LONG_DESC, input_schema: {} }];
+        compressToolDescriptions(tools, 80, false, false, false);
+        const desc = tools[0].description;
+        expect(desc.length).toBeLessThanOrEqual(81);
+        expect(desc.endsWith('…')).toBe(true);
+    });
+    it('no truncation when maxChars is 0', () => {
+        const tools = [{ name: 'Read', description: LONG_DESC, input_schema: {} }];
+        compressToolDescriptions(tools, 0, false, false, false);
+        const desc = tools[0].description;
+        expect(desc.endsWith('…')).toBe(false);
+        expect(desc.length).toBeGreaterThan(80);
+    });
+    it('NEVER touches input_schema', () => {
+        const schema = { type: 'object', properties: { command: { type: 'string', description: 'A long command description that should not be touched at all ever.' } } };
+        const schemaStr = JSON.stringify(schema);
+        const tools = [{ name: 'Bash', description: LONG_DESC, input_schema: schema }];
+        compressToolDescriptions(tools, 50, false, false, false);
+        expect(JSON.stringify(tools[0].input_schema)).toBe(schemaStr);
+    });
+    it('NEVER touches tool name', () => {
+        const tools = [{ name: 'Bash', description: LONG_DESC, input_schema: {} }];
+        compressToolDescriptions(tools, 50, false, false, false);
+        expect(tools[0].name).toBe('Bash');
+    });
+    it('skips non-object entries gracefully', () => {
+        const tools = [null, undefined, 'string', 42, { name: 'Bash', description: LONG_DESC }];
+        expect(() => compressToolDescriptions(tools, 0, false, false, false)).not.toThrow();
+    });
+    it('skips tools without a description field', () => {
+        const tools = [{ name: 'Bash', input_schema: {} }];
+        const r = compressToolDescriptions(tools, 0, false, false, false);
+        expect(r.savedChars).toBe(0);
+    });
+    it('does not produce a longer result', () => {
+        const tools = [{ name: 'Bash', description: LONG_DESC, input_schema: {} }];
+        const before = LONG_DESC.length;
+        compressToolDescriptions(tools, 0, false, false, false);
+        const after = tools[0].description.length;
+        expect(after).toBeLessThanOrEqual(before);
+    });
+    it('compresses multiple tools independently', () => {
+        const tools = [
+            { name: 'Bash', description: LONG_DESC + '\n\n\n', input_schema: {} },
+            { name: 'Read', description: LONG_DESC + '\n\n\n\n extra  ', input_schema: {} },
+            { name: 'Tiny', description: SHORT_DESC, input_schema: {} },
+        ];
+        const r = compressToolDescriptions(tools, 0, false, false, false);
+        expect(r.compressedTools).toBe(2);
+        expect(r.totalTools).toBe(3);
+        expect(r.savedChars).toBeGreaterThan(0);
+    });
+    it('handles non-array input gracefully', () => {
+        const r = compressToolDescriptions('not an array', 0, false, false, false);
+        expect(r.savedChars).toBe(0);
+    });
+    it('first-para mode truncates at first blank line', () => {
+        // Need desc > 500 chars with a blank line after first para
+        const bigDesc = LONG_DESC + '\n\n' + LONG_DESC + '\n\n' + LONG_DESC; // ~700 chars, has blank lines
+        const tools = [{ name: 'Bash', description: bigDesc, input_schema: {} }];
+        compressToolDescriptions(tools, 0, true, false, false);
+        const desc = tools[0].description;
+        expect(desc).toContain('Execute bash commands');
+        expect(desc.endsWith('…')).toBe(true);
+        expect(desc.length).toBeLessThan(LONG_DESC.length);
+    });
+    it('first-para mode no-op when description <= MIN_FIRST_PARA_LEN', () => {
+        // LONG_DESC is ~230 chars — below the 500-char threshold for first-para
+        const tools = [{ name: 'Bash', description: LONG_DESC, input_schema: {} }];
+        const before = tools[0].description.length;
+        compressToolDescriptions(tools, 0, true, false, false);
+        const after = tools[0].description.length;
+        // Only whitespace normalization applies (no truncation since < 500 chars)
+        expect(after).toBeLessThanOrEqual(before);
+    });
+    it('first-para mode works on very long descriptions (>500 chars)', () => {
+        const bigDesc = LONG_DESC.repeat(3); // ~690 chars, above 500 threshold
+        const tools = [{ name: 'Workflow', description: bigDesc, input_schema: {} }];
+        compressToolDescriptions(tools, 0, true, false, false);
+        const desc = tools[0].description;
+        expect(desc.length).toBeLessThan(bigDesc.length);
+        expect(desc.endsWith('…')).toBe(true);
+    });
+    it('safe-only mode skips non-whitelist tools', () => {
+        const bigDesc = LONG_DESC.repeat(3);
+        const tools = [
+            { name: 'Workflow', description: bigDesc, input_schema: {} }, // NOT in whitelist
+            { name: 'Bash', description: bigDesc, input_schema: {} }, // IN whitelist
+        ];
+        compressToolDescriptions(tools, 0, true, true, false);
+        const workflow = tools[0].description;
+        const bash = tools[1].description;
+        expect(workflow).toBe(bigDesc); // untouched
+        expect(bash.length).toBeLessThan(bigDesc.length); // compressed
+    });
+    it('safe-only mode=false compresses all tools', () => {
+        const tools = [{ name: 'Workflow', description: LONG_DESC.repeat(3), input_schema: {} }];
+        compressToolDescriptions(tools, 0, true, false, false);
+        expect(tools[0].description.length).toBeLessThan(LONG_DESC.repeat(3).length);
+    });
+    it('expand mode embeds squeezr_expand hint in truncated description', () => {
+        const bigDesc = LONG_DESC.repeat(3);
+        const tools = [{ name: 'Workflow', description: bigDesc, input_schema: {} }];
+        compressToolDescriptions(tools, 0, true, false, true);
+        const desc = tools[0].description;
+        expect(desc).toContain("squeezr_expand(");
+        expect(desc.length).toBeLessThan(bigDesc.length);
+    });
+    it('expand mode works on all tools regardless of whitelist', () => {
+        const bigDesc = LONG_DESC.repeat(3);
+        const tools = [
+            { name: 'Workflow', description: bigDesc, input_schema: {} },
+            { name: 'mcp__custom__tool', description: bigDesc, input_schema: {} },
+        ];
+        compressToolDescriptions(tools, 0, true, true, true); // safeOnly=true but expand=true overrides
+        const workflow = tools[0].description;
+        const mcp = tools[1].description;
+        expect(workflow).toContain('squeezr_expand(');
+        expect(mcp).toContain('squeezr_expand(');
+    });
+    it('expand mode: same content same ID (deterministic for prefix cache)', () => {
+        const bigDesc = LONG_DESC.repeat(3);
+        const tools1 = [{ name: 'Bash', description: bigDesc, input_schema: {} }];
+        const tools2 = [{ name: 'Bash', description: bigDesc, input_schema: {} }];
+        compressToolDescriptions(tools1, 0, true, false, true);
+        compressToolDescriptions(tools2, 0, true, false, true);
+        // Same content → same expand ID → stable for Anthropic prefix cache
+        expect(tools1[0].description)
+            .toBe(tools2[0].description);
+    });
+});

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

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

package/dist/__tests__/toolResultDedup.test.js

@@ -0,0 +1,40 @@
+import { describe, it, expect } from 'vitest';
+import { compressDuplicateToolResults } from '../toolResultDedup.js';
+import { clearExpandStore } from '../expand.js';
+function userToolResult(id, text) {
+    return { role: 'user', content: [{ type: 'tool_result', tool_use_id: id, content: text }] };
+}
+describe('compressDuplicateToolResults', () => {
+    it('collapses an identical tool output that reappears, keeping the latest full', () => {
+        clearExpandStore();
+        const big = 'line of bash output that is fairly long '.repeat(40); // > 500 chars
+        const msgs = [
+            userToolResult('a', big),
+            { role: 'assistant', content: [{ type: 'text', text: 'ok' }] },
+            userToolResult('b', big), // identical re-run
+        ];
+        const r = compressDuplicateToolResults(msgs);
+        expect(r.collapsedCount).toBe(1);
+        expect(r.savedChars).toBeGreaterThan(0);
+        // earlier one replaced with a reference, latest kept full
+        expect(msgs[0].content[0].content).toMatch(/identical tool output/);
+        expect(msgs[2].content[0].content).toBe(big);
+    });
+    it('ignores short outputs and unique outputs', () => {
+        clearExpandStore();
+        const msgs = [
+            userToolResult('a', 'short'),
+            userToolResult('b', 'short'),
+            userToolResult('c', 'a unique long output '.repeat(40)),
+        ];
+        const r = compressDuplicateToolResults(msgs);
+        expect(r.collapsedCount).toBe(0);
+    });
+    it('does not reprocess already-compressed squeezr blocks', () => {
+        clearExpandStore();
+        const tag = '[squeezr: identical tool output as message #2 — squeezr_expand(abc123)]'.padEnd(600, ' ');
+        const msgs = [userToolResult('a', tag), userToolResult('b', tag)];
+        const r = compressDuplicateToolResults(msgs);
+        expect(r.collapsedCount).toBe(0);
+    });
+});

package/dist/aiRateLimit.d.ts

@@ -0,0 +1,19 @@
+/**
+ * AI compression rate limiter (v1.60.0)
+ *
+ * Hard safety net so AI compression can NEVER stampede the user's quota again
+ * (the 2026-06-04 incident: 215 Haiku calls in ~10 min). Sliding window — when
+ * the window is full, AI compression is skipped (deterministic compression still
+ * runs, it's free). Independent of the cache-barrier fix; this is the last line
+ * of defence against any future bug that re-enables a burst.
+ *
+ * Window is process-global (not per-conversation): the user's quota is global.
+ */
+/** Returns true if another AI call is allowed right now (and records it). */
+export declare function tryConsumeAiCall(): boolean;
+/** How many calls remain in the current window (for logging / dashboard). */
+export declare function aiCallsRemaining(): number;
+export declare const _config: {
+    WINDOW_MS: number;
+    MAX_CALLS_PER_WINDOW: number;
+};

package/dist/aiRateLimit.js

@@ -0,0 +1,35 @@
+/**
+ * AI compression rate limiter (v1.60.0)
+ *
+ * Hard safety net so AI compression can NEVER stampede the user's quota again
+ * (the 2026-06-04 incident: 215 Haiku calls in ~10 min). Sliding window — when
+ * the window is full, AI compression is skipped (deterministic compression still
+ * runs, it's free). Independent of the cache-barrier fix; this is the last line
+ * of defence against any future bug that re-enables a burst.
+ *
+ * Window is process-global (not per-conversation): the user's quota is global.
+ */
+const WINDOW_MS = 5 * 60 * 1000; // 5 minutes — matches Claude Code's 5h window cadence
+const MAX_CALLS_PER_WINDOW = 20; // generous for normal use, hard ceiling against bursts
+const callTimestamps = [];
+/** Returns true if another AI call is allowed right now (and records it). */
+export function tryConsumeAiCall() {
+    const now = Date.now();
+    // Drop timestamps outside the window
+    while (callTimestamps.length > 0 && now - callTimestamps[0] > WINDOW_MS) {
+        callTimestamps.shift();
+    }
+    if (callTimestamps.length >= MAX_CALLS_PER_WINDOW)
+        return false;
+    callTimestamps.push(now);
+    return true;
+}
+/** How many calls remain in the current window (for logging / dashboard). */
+export function aiCallsRemaining() {
+    const now = Date.now();
+    while (callTimestamps.length > 0 && now - callTimestamps[0] > WINDOW_MS) {
+        callTimestamps.shift();
+    }
+    return Math.max(0, MAX_CALLS_PER_WINDOW - callTimestamps.length);
+}
+export const _config = { WINDOW_MS, MAX_CALLS_PER_WINDOW };

package/dist/aiToggle.d.ts

@@ -0,0 +1,14 @@
+/**
+ * AI compression toggle — PERSISTED across restarts.
+ *
+ * Master on/off for AI compression calls (Haiku/GPT/Gemini), controllable from
+ * the dashboard. Persisted to ~/.squeezr/ai-compression.json so a restart keeps
+ * the user's choice. Initial value falls back to the TOML `ai_compression`
+ * setting (default false) when no persisted file exists.
+ *
+ * This is the SECOND gate (alongside the per-request rate limit and the cache
+ * barrier). When OFF, zero AI calls happen regardless of anything else.
+ */
+export declare function isAiCompressionEnabled(): boolean;
+export declare function setAiCompression(val: boolean): void;
+export declare function toggleAiCompression(): boolean;

package/dist/aiToggle.js

@@ -0,0 +1,53 @@
+/**
+ * AI compression toggle — PERSISTED across restarts.
+ *
+ * Master on/off for AI compression calls (Haiku/GPT/Gemini), controllable from
+ * the dashboard. Persisted to ~/.squeezr/ai-compression.json so a restart keeps
+ * the user's choice. Initial value falls back to the TOML `ai_compression`
+ * setting (default false) when no persisted file exists.
+ *
+ * This is the SECOND gate (alongside the per-request rate limit and the cache
+ * barrier). When OFF, zero AI calls happen regardless of anything else.
+ */
+import { readFileSync, writeFileSync, mkdirSync, existsSync, renameSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { config } from './config.js';
+const TOGGLE_FILE = join(homedir(), '.squeezr', 'ai-compression.json');
+function loadPersisted() {
+    try {
+        if (!existsSync(TOGGLE_FILE))
+            return config.aiCompression; // TOML default
+        const data = JSON.parse(readFileSync(TOGGLE_FILE, 'utf-8'));
+        return data.enabled === true;
+    }
+    catch {
+        return config.aiCompression;
+    }
+}
+let enabled = loadPersisted();
+function persist() {
+    try {
+        const dir = join(homedir(), '.squeezr');
+        if (!existsSync(dir))
+            mkdirSync(dir, { recursive: true });
+        const tmp = TOGGLE_FILE + '.tmp';
+        writeFileSync(tmp, JSON.stringify({ enabled }));
+        renameSync(tmp, TOGGLE_FILE);
+    }
+    catch {
+        /* best-effort */
+    }
+}
+export function isAiCompressionEnabled() {
+    return enabled;
+}
+export function setAiCompression(val) {
+    enabled = val;
+    persist();
+    console.log(`[squeezr] AI compression ${val ? 'ON — will call the compression backend' : 'OFF — deterministic only (free)'} (persisted)`);
+}
+export function toggleAiCompression() {
+    setAiCompression(!enabled);
+    return enabled;
+}

package/dist/attachmentCompress.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Try each type-specific compressor in order; return the first one that
+ * produces a meaningfully smaller output. Returns original if none apply.
+ */
+export declare function compressAttachmentText(text: string): {
+    compressed: string;
+    savedChars: number;
+    type: string | null;
+};